// Some will be stack phis. For those stack phis, make sure the spill
	// of the second argument uses the phi's width (4 bytes), not its width
	// (8 bytes).  Otherwise, a random stack slot gets clobbered.

	runtime.Gosched()
	return a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x + y + z
}

func TestPhi(t *testing.T) {
	want := int32(0)
	got := foo()

	bl	saveregs
	stdu	1, -296(1)

	// Set up Go ABI constant registers
	// Must match _cgo_reginit in runtime package.
	xor 0, 0, 0

	// Restore g pointer (r30 in Go ABI, which may have been clobbered by C)
	mr	30, 4

	// Call fn
	mr	12, 3
	mtctr	12
	bctrl

	addi	1, 1, 296
	bl	restoreregs
	ld	2, 40(1)
	ld	0, 16(1)
	mtlr	0
	blr

saveregs:
	// Save callee-save registers

// leading to incorrect results. That is, it ensures that it's safe to write
//
//	v.Invert(v)
//
// or
//
//	v.Add(v, v)
//
// without any of the inputs getting clobbered by the output being written.
func TestAliasing(t *testing.T) {
	type target struct {
		name     string
		oneArgF  func(v, x *Element) *Element
		twoArgsF func(v, x, y *Element) *Element
	}

			}

			if len(chunks) == 0 {
				return
			}

			// Verify that appending to the end of the first chunk does not
			// clobber the beginning of the next chunk.
			s := Clone(tc.s)
			chunks[0] = append(chunks[0], -1)
			if !Equal(s, tc.s) {
				t.Errorf("slice was clobbered: %v, want %v", s, tc.s)
			}
		})
	}
}

func TestChunkPanics(t *testing.T) {
	for _, test := range []struct {

				if elf.ProgType(phdr.Type) == elf.PT_NOTE {
					// Increase the size so we keep
					// reading notes.
					order.PutUint64(data[phoff+4*8:], phdr.Filesz+1)

					// Clobber the Align field to zero.
					order.PutUint64(data[phoff+6*8:], 0)

					// Clobber the note type so we
					// keep reading notes.
					order.PutUint32(data[phdr.Off+12:], 0)
				}

				phoff += phsize
			}

		// This case handles the possibility where a flag value is generated but never used.
		// In that case, there's no corresponding Select to overwrite the flags value,
		// so we must consider flags clobbered by the tuple-generating instruction.
		return true
	}
	return false
}

// copyFlags copies v (flag generator) into b, returns the copy.
// If v's arg is also flags, copy recursively.

	// one is A1 -> A1carry -> A1Carryvalue, the other is A2 -> A2carry -> A2Carryvalue. If they
	// are not scheduled properly, the carry will be clobbered, causing the carry to be regenerated.
	c := testConfigARM64(t)
	fun := c.Fun("entry",
		Bloc("entry",
			Valu("mem0", OpInitMem, types.TypeMem, 0, nil),
			Valu("x", OpARM64MOVDconst, c.config.Types.UInt64, 5, nil),

// to the buffer space in R25.
// It clobbers R23 (the linker temp register).
// The act of CALLing gcWriteBarrier will clobber R31 (LR).
// It does not clobber any other general-purpose registers,
// but may clobber others (e.g., floating point registers).
TEXT gcWriteBarrier<>(SB),NOSPLIT,$192
	// Save the registers clobbered by the fast path.
	MOVV	R1, 184(R29)
	MOVV	R2, 192(R29)
retry:

// to the buffer space in X24.
// It clobbers X31 aka T6 (the linker temp register - REG_TMP).
// The act of CALLing gcWriteBarrier will clobber RA (LR).
// It does not clobber any other general-purpose registers,
// but may clobber others (e.g., floating point registers).
TEXT gcWriteBarrier<>(SB),NOSPLIT,$208
	// Save the registers clobbered by the fast path.
	MOV	A0, 24*8(X2)
	MOV	A1, 25*8(X2)
retry:

#include "textflag.h"

// ENDIAN_MOVE generates the appropriate
// 4 byte load for big or little endian.
// The 4 bytes at ptr+off is loaded into dst.
// The idx reg is only needed for big endian
// and is clobbered when used.
#ifdef GOARCH_ppc64le
#define ENDIAN_MOVE(off, ptr, dst, idx) \
	MOVWZ	off(ptr),dst
#else
#define ENDIAN_MOVE(off, ptr, dst, idx) \
	MOVD	$off,idx; \
	MOVWBR	(idx)(ptr), dst
#endif