MOVQ R15, AX // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
	RET
TEXT ·a8(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0
	ADDQ AX, R15 // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
	RET
TEXT ·a9(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0
	ORQ R15, R15 // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
	RET

import (
	"sync/atomic"
)

var cnt32 int32

//go:noinline
func test32(a, b []int) bool {
	// Try to generate flag value, issue atomic
	// adds and then re-use the flag value to see if
	// the atomic add has clobbered them.
	atomic.AddInt32(&cnt32, 1)
	if len(a) == len(b) {
		atomic.AddInt32(&cnt32, 2)
	}
	atomic.AddInt32(&cnt32, 4)
	if len(a) >= len(b) {
		atomic.AddInt32(&cnt32, 8)
	}
	if len(a) <= len(b) {

	"testing"
)

type T struct {
	x [2]int64 // field that will be clobbered. Also makes type not SSAable.
	p *byte    // has a pointer
}

//go:noinline
func makeT() T {
	return T{}
}

var g T

var sink interface{}

func TestIssue15854(t *testing.T) {
	for i := 0; i < 10000; i++ {
		if g.x[0] != 0 {
			t.Fatalf("g.x[0] clobbered with %x\n", g.x[0])
		}

	// amd64:-`MOVQ\t\$-2401018187971961171, BP` // frame pointer is not clobbered
	StackArgsCall([10]int{a, b, c})
	// amd64:`MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`, `MOVQ\t\$-2401018187971961171, DX`
	// amd64:-`MOVQ\t\$-2401018187971961171, AX`, -`MOVQ\t\$-2401018187971961171, R11` // register args are not clobbered
	RegArgsCall(a, b, c, d)
}

//go:noinline
func StackArgsCall([10]int) {}

// run

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 12133.  The CX register was getting clobbered
// because we did not keep track of its allocation correctly.

package main

import "fmt"

func main() {
	want := uint(48)
	got := f1(48)
	if got != want {
		fmt.Println("got", got, ", wanted", want)

// license that can be found in the LICENSE file.

// Issue 10320: 7g failed to compile a program because it attempted
// to use ZR as register. Other programs compiled but failed to
// execute correctly because they clobbered the g register.

package main

func main() {
	var x00, x01, x02, x03, x04, x05, x06, x07, x08, x09 int
	var x10, x11, x12, x13, x14, x15, x16, x17, x18, x19 int

// when they are assigned to a PPARAMOUT slot before
// the last GC safepoint.

package main

import (
	"fmt"
	"runtime"
)

// When a T is deallocated, T[1] is certain to
// get clobbered (the runtime writes 0xdeaddeaddeaddead there).
type T [4]int

func f() (r, s *T) {
	r = &T{0x30, 0x31, 0x32, 0x33}
	runtime.GC()
	s = &T{0x40, 0x41, 0x42, 0x43}
	runtime.GC()
	return
}

func main() {

	MOVBU	c+8(FP), R2
	MOVW	$ret+12(FP), R7
	B	countbytebody<>(SB)

// Input:
// R0: data
// R1: data length
// R2: byte to find
// R7: address to put result
//
// On exit:
// R4 and R8 are clobbered
TEXT countbytebody<>(SB),NOSPLIT,$0
	MOVW	$0, R8	// R8 = count of byte to search
	CMP	$0, R1
	B.EQ	done	// short path to handle 0-byte case
	ADD	R0, R1	// R1 is the end of the range
byte_loop:
	MOVBU.P	1(R0), R4

				active = true
				continue
			}
			if !active {
				continue
			}

			if asmWriteBP.MatchString(line) { // clobber of BP, function is not OK
				pass.Reportf(analysisutil.LineStart(tf, lineno), "frame pointer is clobbered before saving")
				active = false
				continue
			}
			if asmMentionBP.MatchString(line) { // any other use of BP might be a read, so function is OK
				active = false

in `ReplicationController` / `Deployment` / `ReplicaSet` unset for Horizontal Scaling,
leave `resources` for container unset for Vertical Scaling. The periodic reconcile
won't clobbered these fields, hence they could be managed by Horizontal / Vertical
Auto-scaler.

## Add-on naming

The suggested naming for most of the resources is `<basename>` (with no version number).