)
	flagalloc(f.f)
	regalloc(f.f)
	checkFunc(f.f)
	// There should be a spill in loop1, and nowhere else.
	// TODO: resurrect moving spills out of loops? We could put spills at the start of both exit1 and exit2.
	if numSpills(f.blocks["loop1"]) != 1 {
		t.Errorf("spill missing from loop1")
	}
	if numSpills(f.blocks["loop2"]) != 0 {
		t.Errorf("spill present in loop2")
	}
	if numSpills(f.blocks["exit1"]) != 0 {

func readUint16le(b []byte) uint64 {
	y := uint64(binary.LittleEndian.Uint16(b))
	nop() // force spill
	return y
}

func readUint16be(b []byte) uint64 {
	y := uint64(binary.BigEndian.Uint16(b))
	nop() // force spill
	return y
}

func readUint32le(b []byte) uint64 {
	y := uint64(binary.LittleEndian.Uint32(b))
	nop() // force spill
	return y
}

func readUint32be(b []byte) uint64 {

)

// Reader reads a byte stream, validates it, and produces trace events.
type Reader struct {
	r           *bufio.Reader
	lastTs      Time
	gen         *generation
	spill       *spilledBatch
	spillErr    error // error from reading spill
	frontier    []*batchCursor
	cpuSamples  []cpuSample
	order       ordering
	emittedSync bool

	go121Events *oldTraceConverter
}

// NewReader creates a new trace reader.

// Notes:
// - 386 fails due to spilling a register
// amd64:"TEXT\t.*, [$]0-"
// arm:"TEXT\t.*, [$]0-" (spills return address)
// arm64:"TEXT\t.*, [$]0-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// Note: that 386 currently has to spill a register.
func KeepWanted(t *T) {
	*t = T{A: t.A, B: t.B, C: t.C, D: t.D}
}

}

//go:registerparams
//go:noinline
func G(a, b, c, d, e, f *int) {
	var scratch [1000 * 100]int
	scratch[*a] = *f                    // scratch[6] = 1
	fmt.Println(*a, *b, *c, *d, *e, *f) // Forces it to spill b
	sink = scratch[*b+1]                // scratch[5+1] == 1
	*f, *a = *a, *f
	*e, *b = *b, *e
	*d, *c = *c, *d
}

func main() {
	a, b, c, d, e, f := 1, 2, 3, 4, 5, 6
	F(&a, &b, &c, &d, &e, &f)

//
// When the buffer fills up, the write barrier invokes the slow path
// (wbBufFlush) to flush the buffer to the GC work queues. In this
// path, since the compiler didn't spill registers, we spill *all*
// registers and disallow any GC safe points that could observe the
// stack frame (since we don't know the types of the spilled
// registers).

package runtime

import (
	"internal/goarch"

	//    │ └---- Next 2 bits -> sub-bucket 0
	//    └------- Bit 10 set -> bucket 2
	//
	// Following this pattern, bucket 38 will have the bit 46 set. We don't
	// have any buckets for higher values, so we spill the rest into an overflow
	// bucket containing values of 2^47-1 nanoseconds or approx. 1 day or more.
	// This range is more than enough to handle durations produced by the runtime.
	timeHistMinBucketBits = 9

	}
	if g := p.Get(); g != "b" {
		t.Fatalf("got %#v; want b", g)
	}
	if g := p.Get(); g != nil {
		t.Fatalf("got %#v; want nil", g)
	}
	Runtime_procUnpin()

	// Put in a large number of objects so they spill into
	// stealable space.
	for i := 0; i < 100; i++ {
		p.Put("c")
	}
	// After one GC, the victim cache should keep them alive.
	runtime.GC()
	if g := p.Get(); g != "c" {
		t.Fatalf("got %#v; want c after GC", g)

	// if called from a non-go thread.
	XORPS	X15, X15
	XORQ	R14, R14

	get_tls(AX)
	CMPQ	AX, $0
	JE	2(PC)
	// Exception from Go thread, set R14.
	MOVQ	g(AX), R14

	// Reserve space for spill slots.
	ADJSP	$16
	MOVQ	CX, AX
	MOVQ	DX, BX
	// Calling ABIInternal because TLS might be nil.
	CALL	runtime·sigtrampgo<ABIInternal>(SB)
	// Return value is already stored in AX.

	ADJSP	$-16

        when:
        output.println("1st line")
        output.text("2nd line")
        output.text(" - still 2nd line")
        output.println()
        output.text("3rd line")

        then:
        result.toString() == TextUtil.toPlatformLineSeparators("""[PREFIX]1st line
[PREFIX]2nd line - still 2nd line
[PREFIX]3rd line""")
    }

    def "allows not prefixing first line"() {