{"sigpanic", 1},

	// compiler backend inserted calls
	{"gcWriteBarrier", 1},
	{"duffzero", 1},
	{"duffcopy", 1},

	// assembler backend inserted calls
	{"morestack", 0},        // asm function, ABI0
	{"morestackc", 0},       // asm function, ABI0
	{"morestack_noctxt", 0}, // asm function, ABI0

	{"runtime.newproc", 1},
	{"runtime.panicoverflow", 1},
	{"runtime.sigpanic", 1},
	{"runtime.gcWriteBarrier", 1},
	{"runtime.duffzero", 1},
	{"runtime.duffcopy", 1},
	{"runtime.morestack", 0},
	{"runtime.morestackc", 0},
	{"runtime.morestack_noctxt", 0},
	{"type:int8", 0},
	{"type:*int8", 0},
	{"type:uint8", 0},
	{"type:*uint8", 0},
	{"type:int16", 0},
	{"type:*int16", 0},
	{"type:uint16", 0},

	}
}

//go:noinline
func anotherFunc(n int) {
	// Trigger a stack growth on at least some calls to
	// anotherFunc to test that mayMoreStack is called outside the
	// morestack loop. It's also important that it is called
	// before (not after) morestack, but that's hard to test.
	var x [1 << 10]byte

	if n > 1 {
		anotherFunc(n - 1)
	}

	runtime.KeepAlive(x)

}

type StructF0S1 struct {
	_ uint16
}

// 0 returns 3 params
//go:registerparams
//go:noinline
func Test0(p0 uint32, p1 StructF0S0, p2 int32) {
	// consume some stack space, so as to trigger morestack
	var pad [256]uint64
	pad[FailCount]++
	if p0 == 0 {
		return
	}
	p1f0c := int16(-3096)
	if p1.F0 != p1f0c {
		NoteFailureElem(0, "genChecker0", "parm", 1, 0, pad[0])
		return
	}
	p1f1c := "f6ꂅ8ˋ<"

	"gopanic":            abi.FuncID_gopanic,
	"handleAsyncEvent":   abi.FuncID_handleAsyncEvent,
	"main":               abi.FuncID_runtime_main,
	"mcall":              abi.FuncID_mcall,
	"morestack":          abi.FuncID_morestack,
	"mstart":             abi.FuncID_mstart,
	"panicwrap":          abi.FuncID_panicwrap,
	"runfinq":            abi.FuncID_runfinq,
	"sigpanic":           abi.FuncID_sigpanic,

	// See golang.org/issue/12210.
	if(ctx.uc_stack.ss_size < 1024*1024)
		g->stacklo -= 1024*1024 - ctx.uc_stack.ss_size;

	// Sanity check the results now, rather than getting a
	// morestack on g0 crash.
	if (g->stacklo >= g->stackhi) {
		fatalf("bad stack bounds: lo=%p hi=%p", (void*)(g->stacklo), (void*)(g->stackhi));
	}
}

void
_cgo_sys_thread_start(ThreadStart *ts)
{
	pthread_attr_t attr;

	if (pbounds == NULL) {
		pbounds = &bounds[0];
	}

	x_cgo_getstackbound(pbounds);

	g->stacklo = *pbounds;

	// Sanity check the results now, rather than getting a
	// morestack on g0 crash.
	if (g->stacklo >= g->stackhi) {
		fprintf(stderr, "runtime/cgo: bad stack bounds: lo=%p hi=%p\n", (void*)(g->stacklo), (void*)(g->stackhi));
		abort();
	}
}