f := reflect.MakeFunc(t, F).Interface().(func())
		defer f()
		growstack(10000)
		done <- true
	}()
	<-done
	go func() {
		// Test reflect.methodValueCall.
		f := reflect.ValueOf(T{}).Method(0).Interface().(func())
		defer f()
		growstack(10000)
		done <- true
	}()
	<-done
}

func growstack(x int) {
	if x == 0 {
		return
	}
	growstack(x - 1)

	}
	// Grow stack so that partial call x becomes invalid if allocated on stack.
	growstack(10000)
	c := make(chan bool)
	// Spoil the previous stack segment.
	go func() {
		c <- true
	}()
	<-c
	return f
}

func growstack(x int) {
	if x == 0 {
		return
	}
	growstack(x - 1)

func test() {
	pwd, err := os.Getwd()
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	fmt.Println(pwd)
}

func main() {
	growstack() // Use stack early to prevent growth during test, which confuses gdb
	test()
}

var snk string

//go:noinline
func growstack() {
	snk = fmt.Sprintf("%#v,%#v,%#v", 1, true, "cat")

package main

import (
	"bytes"
	"strings"
)

func growstack(n int) {
	if n > 0 {
		growstack(n - 1)
	}
}

func main() {
	c := make(chan struct{})
	go compare(c)
	go equal(c)
	go indexByte(c)
	go indexByteString(c)
	<-c
	<-c
	<-c
	<-c
}

func compare(c chan struct{}) {
	defer bytes.Compare(nil, nil)
	growstack(10000)
	c <- struct{}{}
}
func equal(c chan struct{}) {

//go:noinline
func isFoo(t *thing, b big) bool {
	return true
}

func main() {
	growstack() // Use stack early to prevent growth during test, which confuses gdb
	t := &thing{name: "t", self: nil, next: nil, stuff: make([]big, 1)}
	u := thing{name: "u", self: t, next: t, stuff: make([]big, 1)}
	test(t, &u)
}

var snk string

//go:noinline
func growstack() {
	snk = fmt.Sprintf("%#v,%#v,%#v", 1, true, "cat")

		}
		t += i * a
		n += a
		fmt.Fprintf(os.Stderr, "%d\t%d\t%d\t%d\t%d\n", i, a, n, i*a, t) //gdb-dbg=(n,i,t)
	}
}

func main() {
	growstack() // Use stack early to prevent growth during test, which confuses gdb
	test()
}

var snk string

//go:noinline
func growstack() {
	snk = fmt.Sprintf("%#v,%#v,%#v", 1, true, "cat")

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"time"
)

func main() {
	growstack() // Use stack early to prevent growth during test, which confuses gdb
	test()
}

//go:noinline
func id(x int) int {
	return x
}

func test() {
	x := id(0)
	y := id(0)
	fmt.Println(x)

}

func BenchmarkStackLeak(b *testing.B) {
	done := make(chan bool, 1)
	for i := 0; i < b.N; i++ {
		go func() {
			growStack(rand.Intn(100))
			done <- true
		}()
		<-done
	}
}

func growStack(i int) {
	if i == 0 {
		return
	}
	growStack(i - 1)

	g, after := startDebugCallWorker(t)
	defer after()

	// Inject a call that grows the stack. debugCallWorker checks
	// for stack pointer breakage.
	if _, err := runtime.InjectDebugCall(g, func() { growStack(nil) }, nil, nil, debugCallTKill, false); err != nil {
		t.Fatal(err)
	}
}

//go:nosplit
func debugCallUnsafePointWorker(gpp **runtime.G, ready, stop *uint32) {