}
	arg := cgoTracebackArg{
		context: ctxt,
		buf:     (*uintptr)(noescape(unsafe.Pointer(&buf[0]))),
		max:     uintptr(len(buf)),
	}
	if msanenabled {
		msanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
	}
	if asanenabled {
		asanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
	}
	call(cgoTraceback, noescape(unsafe.Pointer(&arg)))

			linesOut = append(linesOut, "")

			// #cgo (nocallback|noescape) <function name>
			if fields := strings.Fields(l); len(fields) == 3 {
				directive := fields[1]
				funcName := fields[2]
				if directive == "nocallback" {
					fatalf("#cgo nocallback disabled until Go 1.23")
					f.NoCallbacks[funcName] = true
				} else if directive == "noescape" {
					fatalf("#cgo noescape disabled until Go 1.23")
					f.NoEscapes[funcName] = true

		if len(line) < 5 || line[:4] != "#cgo" || (line[4] != ' ' && line[4] != '\t') {
			continue
		}

		// #cgo (nocallback|noescape) <function name>
		if fields := strings.Fields(line); len(fields) == 3 && (fields[1] == "nocallback" || fields[1] == "noescape") {
			continue
		}

		// Split at colon.
		line, argstr, ok := strings.Cut(strings.TrimSpace(line[4:]), ":")
		if !ok {

//
// This is nosplit simply to avoid extra pointer shuffling that may
// complicate a test.
//
//go:nosplit
func gcTestPointerClass(p unsafe.Pointer) string {
	p2 := uintptr(noescape(p))
	gp := getg()
	if gp.stack.lo <= p2 && p2 < gp.stack.hi {
		return "stack"
	}
	if base, _, _ := findObject(p2, 0, 0); base != 0 {
		return "heap"
	}
	for _, datap := range activeModules() {

	if n.AddError {
		fmt.Fprintf(fgo2, "\tif errno != 0 { r2 = syscall.Errno(errno) }\n")
	}
	if noCallback {
		fmt.Fprintf(fgo2, "\t_Cgo_no_callback(false)\n")
	}

	// skip _Cgo_use when noescape exist,
	// so that the compiler won't force to escape them to heap.
	if !p.noEscapes[n.C] {
		fmt.Fprintf(fgo2, "\tif _Cgo_always_false {\n")
		if d.Type.Params != nil {
			for i := range d.Type.Params.List {