cgo: support errno value as second return parameter

Making this work on all targets was interesting but there's now a test
in place to make sure this works on all targets that have the CGo test
enabled (which is almost all targets).

Author: aykevl

builder/picolibc.go

@@ -34,6 +34,7 @@ var libPicolibc = Library{
 			"-D__OBSOLETE_MATH_FLOAT=1", // use old math code that doesn't expect a FPU
 			"-D__OBSOLETE_MATH_DOUBLE=0",
 			"-D_WANT_IO_C99_FORMATS",
+			"-D__PICOLIBC_ERRNO_FUNCTION=__errno_location",
 			"-nostdlibinc",
 			"-isystem", newlibDir + "/libc/include",
 			"-I" + newlibDir + "/libc/tinystdio",

cgo/cgo.go

@@ -139,7 +139,10 @@ typedef unsigned long long  _Cgo_ulonglong;
 // These functions will be modified to get a "C." prefix, so the source below
 // doesn't reflect the final AST.
 const generatedGoFilePrefix = `
-import "unsafe"
+import (
+	"syscall"
+	"unsafe"
+)
 
 var _ unsafe.Pointer
 
@@ -169,6 +172,13 @@ func __CBytes([]byte) unsafe.Pointer
 func CBytes(b []byte) unsafe.Pointer {
 	return C.__CBytes(b)
 }
+
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func __get_errno_num() uintptr
+
+func __get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
+}
 `
 
 // Process extracts `import "C"` statements from the AST, parses the comment
@@ -225,7 +235,7 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 		switch decl := decl.(type) {
 		case *ast.FuncDecl:
 			switch decl.Name.Name {
-			case "CString", "GoString", "GoStringN", "__GoStringN", "GoBytes", "__GoBytes", "CBytes", "__CBytes":
+			case "CString", "GoString", "GoStringN", "__GoStringN", "GoBytes", "__GoBytes", "CBytes", "__CBytes", "__get_errno_num", "__get_errno":
 				// Adjust the name to have a "C." prefix so it is correctly
 				// resolved.
 				decl.Name.Name = "C." + decl.Name.Name
@@ -1279,6 +1289,45 @@ extern __typeof(%s) %s __attribute__((alias(%#v)));
 // separate namespace (no _Cgo_ hacks like in gc).
 func (f *cgoFile) walker(cursor *astutil.Cursor, names map[string]clangCursor) bool {
 	switch node := cursor.Node().(type) {
+	case *ast.AssignStmt:
+		// An assign statement could be something like this:
+		//
+		//   val, errno := C.some_func()
+		//
+		// Check whether it looks like that, and if so, read the errno value and
+		// return it as the second return value. The call will be transformed
+		// into something like this:
+		//
+		//   val, errno := C.some_func(), C.__get_errno()
+		if len(node.Lhs) != 2 || len(node.Rhs) != 1 {
+			return true
+		}
+		rhs, ok := node.Rhs[0].(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		fun, ok := rhs.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+		x, ok := fun.X.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if found, ok := names[fun.Sel.Name]; ok && x.Name == "C" {
+			// Replace "C"."some_func" into "C.somefunc".
+			rhs.Fun = &ast.Ident{
+				NamePos: x.NamePos,
+				Name:    f.getASTDeclName(fun.Sel.Name, found, true),
+			}
+			// Add the errno value as the second value in the statement.
+			node.Rhs = append(node.Rhs, &ast.CallExpr{
+				Fun: &ast.Ident{
+					NamePos: node.Lhs[1].End(),
+					Name:    "C.__get_errno",
+				},
+			})
+		}
 	case *ast.CallExpr:
 		fun, ok := node.Fun.(*ast.SelectorExpr)
 		if !ok {

compileopts/config.go

@@ -331,6 +331,7 @@ func (c *Config) CFlags(libclang bool) []string {
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(picolibcDir, "include"),
 			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
+			"-D__PICOLIBC_ERRNO_FUNCTION=__errno_location",
 		)
 	case "musl":
 		root := goenv.Get("TINYGOROOT")
@@ -340,6 +341,7 @@ func (c *Config) CFlags(libclang bool) []string {
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
 			"-isystem", filepath.Join(root, "lib", "musl", "include"),
 		)
 	case "wasi-libc":

src/runtime/baremetal.go

@@ -86,3 +86,16 @@ func AdjustTimeOffset(offset int64) {
 	// TODO: do this atomically?
 	timeOffset += offset
 }
+
+// Picolibc is not configured to define its own errno value, instead it calls
+// __errno_location.
+// TODO: a global works well enough for now (same as errno on Linux with
+// -scheduler=tasks), but this should ideally be a thread-local variable stored
+// in task.Task.
+// Especially when we add multicore support for microcontrollers.
+var errno int32
+
+//export __errno_location
+func libc_errno_location() *int32 {
+	return &errno
+}

src/runtime/os_darwin.go

@@ -151,7 +151,7 @@ func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	r1 = uintptr(result)
 	if result == -1 {
 		// Syscall returns -1 on failure.
-		err = uintptr(*libc___error())
+		err = uintptr(*libc_errno_location())
 	}
 	return
 }
@@ -161,7 +161,7 @@ func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	r1 = call_syscallX(fn, a1, a2, a3)
 	if int64(r1) == -1 {
 		// Syscall returns -1 on failure.
-		err = uintptr(*libc___error())
+		err = uintptr(*libc_errno_location())
 	}
 	return
 }
@@ -171,7 +171,7 @@ func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 	r1 = call_syscallX(fn, a1, a2, a3)
 	if r1 == 0 {
 		// Syscall returns a pointer on success, or NULL on failure.
-		err = uintptr(*libc___error())
+		err = uintptr(*libc_errno_location())
 	}
 	return
 }
@@ -182,7 +182,7 @@ func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
 	r1 = uintptr(result)
 	if result == -1 {
 		// Syscall returns -1 on failure.
-		err = uintptr(*libc___error())
+		err = uintptr(*libc_errno_location())
 	}
 	return
 }
@@ -192,7 +192,7 @@ func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
 	r1 = call_syscall6X(fn, a1, a2, a3, a4, a5, a6)
 	if int64(r1) == -1 {
 		// Syscall returns -1 on failure.
-		err = uintptr(*libc___error())
+		err = uintptr(*libc_errno_location())
 	}
 	return
 }
@@ -216,7 +216,7 @@ func libc_getpagesize() int32
 //	}
 //
 //export __error
-func libc___error() *int32
+func libc_errno_location() *int32
 
 //export tinygo_syscall
 func call_syscall(fn, a1, a2, a3 uintptr) int32

src/runtime/os_linux.go

@@ -139,3 +139,8 @@ func hardwareRand() (n uint64, ok bool) {
 //
 //export getrandom
 func libc_getrandom(buf unsafe.Pointer, buflen uintptr, flags uint32) uint32
+
+// int *__errno_location(void);
+//
+//export __errno_location
+func libc_errno_location() *int32

src/runtime/os_windows.go

@@ -113,3 +113,6 @@ func syscall_Getpagesize() int {
 	_GetSystemInfo(unsafe.Pointer(&info))
 	return int(info.dwpagesize)
 }
+
+//export _errno
+func libc_errno_location() *int32

src/runtime/runtime.go

@@ -127,3 +127,8 @@ func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
 func getAuxv() []uintptr {
 	return nil
 }
+
+// Called from cgo to obtain the errno value.
+func cgo_errno() uintptr {
+	return uintptr(*libc_errno_location())
+}

src/runtime/runtime_wasm_js.go

@@ -36,3 +36,8 @@ func ticks() timeUnit
 func beforeExit() {
 	__stdio_exit()
 }
+
+// int *__errno_location(void);
+//
+//export __errno_location
+func libc_errno_location() *int32

testdata/cgo/main.c

@@ -77,3 +77,8 @@ double doSqrt(double x) {
 void printf_single_int(char *format, int arg) {
 	printf(format, arg);
 }
+
+int set_errno(int err) {
+	errno = err;
+	return -1;
+}