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

package p

func f1(x *[1<<30 - 1e6]byte) byte {
	for _, b := range *x {
		return b
	}
	return 0
}
func f2(x *[1<<30 + 1e6]byte) byte { // GC_ERROR "stack frame too large"
	for _, b := range *x {
		return b
	}
	return 0

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

package runtime

import "unsafe"

// This file handles some syscalls from the syscall package
// Especially, syscalls use during forkAndExecInChild which must not split the stack

//go:cgo_import_dynamic libc_chdir chdir "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_chroot chroot "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_dup2 dup2 "libc.a/shr_64.o"

	var b [10000] int64;  // this causes a runtime crash
	_, _ = a, b;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug092.go && 6l bug092.6 && 6.out
Illegal instruction

gri: array size matters, possibly related to stack overflow check?

}

func test13reflect2() {
	f := reflect.TypeOf(T5{}).Method(0).Func.Interface().(func(T5))
	defer f(T5{})
	panic(13)
}

// enormous receiver + enormous method frame, so wrapper splits stack to call M,
// and then M splits stack to allocate its frame.
// recover must look back two frames to find the panic.
type T6 [8192]byte

var global byte

func (T6) M() {
	var x [8192]byte
	x[0] = 1
	x[1] = 2

// 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 10486.
// Check stack walk during div by zero fault,
// especially on software divide systems.

package main

import "runtime"

var A, B int

func divZero() int {
	defer func() {
		if p := recover(); p != nil {
			var pcs [512]uintptr

// run

// Copyright 2019 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 30476: KeepAlive didn't keep stack object alive.

package main

import "runtime"

func main() {
	x := new([10]int)
	runtime.SetFinalizer(x, func(*[10]int) { panic("FAIL: finalizer runs") })
	p := &T{x, 0}
	use(p)
	runtime.GC()
	runtime.GC()

//
// The heap lock must not be held over this operation, since it will briefly acquire
// the heap lock.
//
// Must be called on the system stack because it acquires the heap lock.
//
//go:systemstack
func (p *pageAlloc) enableChunkHugePages() {
	// Grab the heap lock to turn on huge pages for new chunks and clone the current
	// heap address space ranges.
	//

	var stack []*loadPkg
	for p := pkg; p != nil; p = p.stack {
		stack = append(stack, p)
	}

	var buf strings.Builder
	for i := len(stack) - 1; i >= 0; i-- {
		p := stack[i]
		fmt.Fprint(&buf, p.path)
		if p.testOf != nil {
			fmt.Fprint(&buf, ".test")
		}
		if i > 0 {
			if stack[i-1].testOf == p {
				fmt.Fprint(&buf, " tested by\n\t")
			} else {
				fmt.Fprint(&buf, " imports\n\t")

//#include <string.h>
import "C"

// #include
// void cfunc() {} // uses cgo_topofstack

import (
	"reflect"
	"strings"

	"testplugin/common"
)

func init() {
	_ = strings.NewReplacer() // trigger stack unwind, Issue #18190.
	C.strerror(C.EIO)         // uses cgo_topofstack
	common.X = 2
}

type sameNameReusedInPlugins struct {
	X string
}

type sameNameHolder struct {
	F *sameNameReusedInPlugins
}

			continue
		}

		// There are four cases to handle in translating each
		// argument:
		// 1. Stack -> stack translation.
		// 2. Stack -> registers translation.
		// 3. Registers -> stack translation.
		// 4. Registers -> registers translation.

		// If the value ABI passes the value on the stack,
		// then the method ABI does too, because it has strictly
		// fewer arguments. Simply copy between the two.