{runtime,cmd}/cgo: improve error messages after panic

This commit improves the error messages returned by cgoCheckResult
and cgoCheckPointer after pointer panics.

Therefore:

- change the signature of cgoCheckArg (it does the real work behind them)
- change the signature of cgoCheckUnknownPointer
- introduce cgoFormatErr (it formats an error message with the caller name)
- update pointer tests.

1. cgoCheckResult

When an unpinned Go pointer is returned to a C function, this error shows up:

> panic: runtime error: cgo result is unpinned Go pointer or points to unpinned Go pointer
>
> goroutine 17 [running, locked to thread]:
> panic({0x78fa15d1e5c0?, 0xc00001e050?})
>         /usr/lib/go/src/runtime/panic.go:802 +0x168
> runtime.cgoCheckArg(0x78fa15d1bf20, 0xc000066e50, 0x0?, 0x0, {0x78fa15cfaa62, 0x42})
>         /usr/lib/go/src/runtime/cgocall.go:679 +0x35b
> runtime.cgoCheckResult({0x78fa15d1bf20, 0xc000066e50})
>         /usr/lib/go/src/runtime/cgocall.go:795 +0x4b
> _cgoexp_1ff3739d54a6_foo(0x7fff7f7b0220)
>         _cgo_gotypes.go:65 +0x5d
> runtime.cgocallbackg1(0x78fa15cf16c0, 0x7fff7f7b0220, 0x0)
>         /usr/lib/go/src/runtime/cgocall.go:446 +0x289
> runtime.cgocallbackg(0x78fa15cf16c0, 0x7fff7f7b0220, 0x0)
>         /usr/lib/go/src/runtime/cgocall.go:350 +0x132
> runtime.cgocallbackg(0x78fa15cf16c0, 0x7fff7f7b0220, 0x0)
>         <autogenerated>:1 +0x2b
> runtime.cgocallback(0x0, 0x0, 0x0)
>         /usr/lib/go/src/runtime/asm_amd64.s:1082 +0xcd
> runtime.goexit({})
>         /usr/lib/go/src/runtime/asm_amd64.s:1693 +0x1

_cgoexp_1ff3739d54a6_foo is the faulty caller; it is not obvious to
find it in the stack trace. Moreover the error does say which kind of
pointer caused the panic.

Retrieve caller name and pointer kind; use them in the error message:

> panic: runtime error: result of cgo function foo is unpinned Go string or points to unpinned Go string
>
> goroutine 17 [running, locked to thread]:
> panic({0x7feae6c50640?, 0x26fcc9896000?})
>         /mnt/go/src/runtime/panic.go:877 +0x16f
> runtime.cgoCheckArg(0x7feae6c4dee0, 0x26fcc9774e50, 0x0?, 0x0, {0x26fcc9894000, 0x52})
>         /mnt/go/src/runtime/cgocall.go:678 +0x35b
> runtime.cgoCheckResult({0x7feae6c4dee0, 0x26fcc9774e50})
>         /mnt/go/src/runtime/cgocall.go:797 +0x85
> _cgoexp_9ed4cd31b2e5_foo(0x7ffcc89baf10)
>         _cgo_gotypes.go:65 +0x5d
> runtime.cgocallbackg1(0x7feae6c1d340, 0x7ffcc89baf10, 0x0)
>         /mnt/go/src/runtime/cgocall.go:446 +0x289
> runtime.cgocallbackg(0x7feae6c1d340, 0x7ffcc89baf10, 0x0)
>         /mnt/go/src/runtime/cgocall.go:350 +0x132
> runtime.cgocallbackg(0x7feae6c1d340, 0x7ffcc89baf10, 0x0)
>         <autogenerated>:1 +0x2b
> runtime.cgocallback(0x0, 0x0, 0x0)
>         /mnt/go/src/runtime/asm_amd64.s:1098 +0xcd
> runtime.goexit({})
>         /mnt/go/src/runtime/asm_amd64.s:1709 +0x1

2. cgoCheckPointer

When an unpinned Go pointer is passed to a C function, this error shows up:

> panic: runtime error: cgo argument has Go pointer to unpinned Go pointer
>
> goroutine 1 [running]:
> main.main.func1(...)
>         /mnt/go/src/test.go:15
> main.main()
>         /mnt/go/src/test.go:15 +0x79
> exit status 2

Retrieve callee name and pointer kind; use them in the error message.

> panic: runtime error: cgo argument of function main.main.func1 has Go pointer to unpinned Go pointer
>
> goroutine 1 [running]:
> main.main.func1(...)
>         /mnt/go/src/test.go:15
> main.main()
>         /mnt/go/src/test.go:15 +0x88
> exit status 2

Cc: Keith Randall <khr@golang.org>
Cc: Sean Liao <sean@liao.dev>
Suggested-by: Ian Lance Taylor <iant@golang.org>
GH: #75856

Author: ariel-anieli

src/cmd/cgo/internal/testerrors/ptr_test.go

@@ -694,7 +694,7 @@ func testOne(t *testing.T, pt ptrTest, exe, exe2 string) {
 		if err == nil {
 			t.Logf("%s", buf)
 			t.Fatalf("did not fail as expected")
-		} else if !bytes.Contains(buf, []byte("Go pointer")) {
+		} else if !bytes.Contains(buf, []byte("unpinned Go")) {
 			t.Logf("%s", buf)
 			t.Fatalf("did not print expected error (failed with %v)", err)
 		}

src/runtime/cgocall.go

@@ -591,15 +591,18 @@ func cgoCheckPointer(ptr any, arg any) {
 	cgoCheckArg(t, ep.data, !t.IsDirectIface(), top, cgoCheckPointerFail)
 }
 
-const cgoCheckPointerFail = "cgo argument has Go pointer to unpinned Go pointer"
-const cgoResultFail = "cgo result is unpinned Go pointer or points to unpinned Go pointer"
+type cgoErrorMsg int
+const (
+	cgoCheckPointerFail cgoErrorMsg = iota
+	cgoResultFail
+)
 
 // cgoCheckArg is the real work of cgoCheckPointer and cgoCheckResult.
 // The argument p is either a pointer to the value (of type t), or the value
 // itself, depending on indir. The top parameter is whether we are at the top
 // level, where Go pointers are allowed. Go pointers to pinned objects are
 // allowed as long as they don't reference other unpinned pointers.
-func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
+func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg cgoErrorMsg) {
 	if !t.Pointers() || p == nil {
 		// If the type has no pointers there is nothing to do.
 		return
@@ -625,15 +628,15 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
 		// These types contain internal pointers that will
 		// always be allocated in the Go heap. It's never OK
 		// to pass them to C.
-		panic(errorString(msg))
+		panic(cgoFormatErr(msg, t.Kind()))
 	case abi.Func:
 		if indir {
 			p = *(*unsafe.Pointer)(p)
 		}
 		if !cgoIsGoPointer(p) {
 			return
 		}
-		panic(errorString(msg))
+		panic(cgoFormatErr(msg, t.Kind()))
 	case abi.Interface:
 		it := *(**_type)(p)
 		if it == nil {
@@ -643,14 +646,14 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
 		// constant. A type not known at compile time will be
 		// in the heap and will not be OK.
 		if inheap(uintptr(unsafe.Pointer(it))) {
-			panic(errorString(msg))
+			panic(cgoFormatErr(msg, t.Kind()))
 		}
 		p = *(*unsafe.Pointer)(add(p, goarch.PtrSize))
 		if !cgoIsGoPointer(p) {
 			return
 		}
 		if !top && !isPinned(p) {
-			panic(errorString(msg))
+			panic(cgoFormatErr(msg, t.Kind()))
 		}
 		cgoCheckArg(it, p, !it.IsDirectIface(), false, msg)
 	case abi.Slice:
@@ -661,7 +664,7 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
 			return
 		}
 		if !top && !isPinned(p) {
-			panic(errorString(msg))
+			panic(cgoFormatErr(msg, t.Kind()))
 		}
 		if !st.Elem.Pointers() {
 			return
@@ -676,7 +679,7 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
 			return
 		}
 		if !top && !isPinned(ss.str) {
-			panic(errorString(msg))
+			panic(cgoFormatErr(msg, t.Kind()))
 		}
 	case abi.Struct:
 		st := (*structtype)(unsafe.Pointer(t))
@@ -705,7 +708,7 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
 			return
 		}
 		if !top && !isPinned(p) {
-			panic(errorString(msg))
+			panic(cgoFormatErr(msg, t.Kind()))
 		}
 
 		cgoCheckUnknownPointer(p, msg)
@@ -716,7 +719,7 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
 // memory. It checks whether that Go memory contains any other
 // pointer into unpinned Go memory. If it does, we panic.
 // The return values are unused but useful to see in panic tracebacks.
-func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
+func cgoCheckUnknownPointer(p unsafe.Pointer, msg cgoErrorMsg) (base, i uintptr) {
 	if inheap(uintptr(p)) {
 		b, span, _ := findObject(uintptr(p), 0, 0)
 		base = b
@@ -731,7 +734,7 @@ func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
 			}
 			pp := *(*unsafe.Pointer)(unsafe.Pointer(addr))
 			if cgoIsGoPointer(pp) && !isPinned(pp) {
-				panic(errorString(msg))
+				panic(cgoFormatErr(msg, abi.Pointer))
 			}
 		}
 		return
@@ -741,7 +744,7 @@ func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
 		if cgoInRange(p, datap.data, datap.edata) || cgoInRange(p, datap.bss, datap.ebss) {
 			// We have no way to know the size of the object.
 			// We have to assume that it might contain a pointer.
-			panic(errorString(msg))
+			panic(cgoFormatErr(msg, abi.Pointer))
 		}
 		// In the text or noptr sections, we know that the
 		// pointer does not point to a Go pointer.
@@ -794,3 +797,64 @@ func cgoCheckResult(val any) {
 	t := ep._type
 	cgoCheckArg(t, ep.data, !t.IsDirectIface(), false, cgoResultFail)
 }
+
+// cgoFormatErr is called to format an error message with the caller name.
+func cgoFormatErr(error cgoErrorMsg, kind abi.Kind) errorString {
+	pcs := make([]uintptr, 10)
+	var msg, kindname string
+	var callerName string = " "
+
+	// A truncated copy of the abi variable
+	// https://go.dev/src/internal/abi/type.go
+	var kindNames = []string{
+		abi.Chan:          "channel",
+		abi.Func:          "function",
+		abi.Interface:     "interface",
+		abi.Map:           "map",
+		abi.Pointer:       "pointer",
+		abi.Slice:         "slice",
+		abi.String:        "string",
+		abi.Struct:        "struct",
+		abi.UnsafePointer: "unsafe pointer",
+	}
+
+	kindname = kindNames[kind]
+
+	n := Callers(0, pcs)
+	pcs = pcs[:n]
+
+	frames := CallersFrames(pcs)
+
+	for {
+		frame, more := frames.Next()
+
+		// The caller name should be within the top ten frames.
+		if !more {
+			throw("can't happen")
+			break
+		}
+
+		// Expected format of cgo caller name: _cgoexp_3c910ddb72c4_foo
+		if error == cgoResultFail && frame.Function[0:8] == "_cgoexp_" {
+			callerName += frame.Function[21:] + " "
+			break
+		}
+
+		// Expected format of cgo callee name: GoRoutineName.ModuleName.funcX
+		// It's the first function on the stack out of the runtime package
+		if error == cgoCheckPointerFail && frame.Function[0:8] != "runtime." {
+			callerName += frame.Function + " "
+			break
+		}
+	}
+
+	if error == cgoResultFail {
+		msg = "result of cgo function" + callerName
+		msg += "is unpinned Go " + kindname + " or points to unpinned Go " + kindname
+	} else if error == cgoCheckPointerFail {
+		msg = "cgo argument of function" + callerName
+		msg += "has Go pointer to unpinned Go " + kindname
+	}
+
+	return errorString(msg)
+}