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

package main

type T struct {
	a, b, c int
}

func usestack() {
	usestack1(32)
}
func usestack1(d int) byte {
	if d == 0 {
		return 0
	}
	var b [1024]byte
	usestack1(d - 1)
	return b[3]
}

const n = 100000

func main() {
	c := make(chan interface{})
	done := make(chan bool)

	}
}

func main() {
	defer func() {
		useStack(100) // force a stack copy
		// We're expecting a panic.
		// The bug in this issue causes a throw, which this recover() will not squash.
		recover()
	}()
	junk() // fill the stack with invalid pointers
	f(nil, nil)
}

func useStack(n int) {
	if n == 0 {
		return
	}
	useStack(n - 1)
}

//go:noinline
func junk() uintptr {

	// overwrite x on the garbage stack.
	defer func() {
		c := make(chan bool)
		go func() {
			useStack(1000)
			c <- true
		}()
		<-c

	}()

	// This defer causes a stack copy.
	// The old stack is now garbage.
	defer func() {
		useStack(1000)
	}()

	// Trigger a segfault.
	*g = 0

	// Make the return statement unreachable.

package main

type T struct {
	a, b int
}

//go:noinline
func f(x *T, p *bool, n int) {
	*p = n != 0
	useStack(1000)
	g(&x.b)
}

//go:noinline
func g(p *int) {
}

func useStack(n int) {
	if n == 0 {
		return
	}
	useStack(n - 1)
}

func main() {
	mustPanic(func() {
		var b bool
		f(nil, &b, 3)
	})
}

func mustPanic(f func()) {

}

type F func(W)

func foo(f F) {
	defer func() {
		if r := recover(); r != nil {
			usestack(1000)
		}
	}()
	f(nil)
}

func main() {
	foo(func(w W) {
		var x []string
		w.Write([]byte(x[5]))
	})
}

func usestack(n int) {
	if n == 0 {
		return
	}
	usestack(n - 1)

static callback *bigStackCallback;

static void useStack(int bytes) {
	// Windows doesn't like huge frames, so we grow the stack 64k at a time.
	char x[64<<10];
	if (bytes < sizeof x) {
		bigStackCallback(x);
	} else {
		useStack(bytes - sizeof x);
	}
}

static DWORD WINAPI threadEntry(LPVOID lpParam) {
	useStack(STACK_SIZE - (128<<10));
	return 0;
}

void bigStack(callback *cb) {

	if n == 0 {
		f()
		return
	}
	var b [1024]byte // makes frame about 1KB
	useStackAndCall(n-1+int(b[99]), f)
}

func useStack(n int) {
	useStackAndCall(n, func() {})
}

func growing(c chan int, done chan struct{}) {
	for n := range c {
		useStack(n)
		done <- struct{}{}
	}
	done <- struct{}{}
}

func TestStackCache(t *testing.T) {

	target := func(in []Value) []Value {
		runtime.GC()
		useStack(16)
		return []Value{ValueOf(9)}
	}

	var concrete func(*int, int) int
	fn := MakeFunc(ValueOf(concrete).Type(), target)
	ValueOf(&concrete).Elem().Set(fn)
	x := concrete(nil, 7)
	if x != 9 {
		t.Errorf("have %#q want 9", x)
	}
}

// use about n KB of stack
func useStack(n int) {
	if n == 0 {
		return
	}