purego: extend struct argument support to Linux amd64/arm64

Expands struct argument and return value support from Darwin-only to both
Darwin and Linux on amd64 and arm64 architectures. This change enables
purego to handle struct marshalling on additional platforms while
maintaining the existing safety checks for unsupported architectures.

Updates platform validation logic to check both GOOS and GOARCH, ensuring
struct support is only enabled on tested platform combinations. The build
constraints for struct tests are updated accordingly to include Linux.

Adds test coverage for pointer wrapper structs to validate proper handling
of single and multiple pointer fields within structs, ensuring correct
register allocation and marshalling across the expanded platform support.

Author: tmc

func.go

@@ -60,7 +60,7 @@ func RegisterLibFunc(fptr any, handle uintptr, name string) {
 //	int64 <=> int64_t
 //	float32 <=> float
 //	float64 <=> double
-//	struct <=> struct (WIP - darwin only)
+//	struct <=> struct (darwin amd64/arm64, linux amd64/arm64)
 //	func <=> C function
 //	unsafe.Pointer, *T <=> void*
 //	[]T => void*
@@ -169,8 +169,16 @@ func RegisterFunc(fptr any, cfn uintptr) {
 					stack++
 				}
 			case reflect.Struct:
-				if runtime.GOOS != "darwin" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") {
-					panic("purego: struct arguments are only supported on darwin amd64 & arm64")
+				// Struct arguments are supported on:
+				// - darwin amd64 & arm64
+				// - linux amd64 & arm64
+				switch runtime.GOARCH {
+				case "amd64", "arm64":
+					if runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
+						panic("purego: struct arguments are only supported on darwin and linux")
+					}
+				default:
+					panic("purego: struct arguments are only supported on amd64 and arm64")
 				}
 				if arg.Size() == 0 {
 					continue
@@ -190,8 +198,16 @@ func RegisterFunc(fptr any, cfn uintptr) {
 			}
 		}
 		if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct {
-			if runtime.GOOS != "darwin" {
-				panic("purego: struct return values only supported on darwin arm64 & amd64")
+			// Struct return values are supported on:
+			// - darwin amd64 & arm64
+			// - linux amd64 & arm64
+			switch runtime.GOARCH {
+			case "amd64", "arm64":
+				if runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
+					panic("purego: struct return values are only supported on darwin and linux")
+				}
+			default:
+				panic("purego: struct return values are only supported on amd64 and arm64")
 			}
 			outType := ty.Out(0)
 			checkStructFieldsSupported(outType)

struct_amd64.go

@@ -169,9 +169,10 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp
 				}
 				shift += 8
 				class |= _INTEGER
-			case reflect.Pointer:
-				ok = false
-				return
+			case reflect.Pointer, reflect.UnsafePointer:
+				val = uint64(f.Pointer())
+				shift = 64
+				class = _INTEGER
 			case reflect.Int8:
 				val |= uint64(f.Int()&0xFF) << shift
 				shift += 8
@@ -241,7 +242,7 @@ func placeStack(v reflect.Value, addStack func(uintptr)) {
 	for i := 0; i < v.Type().NumField(); i++ {
 		f := v.Field(i)
 		switch f.Kind() {
-		case reflect.Pointer:
+		case reflect.Pointer, reflect.UnsafePointer:
 			addStack(f.Pointer())
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 			addStack(uintptr(f.Int()))

struct_arm64.go

@@ -175,7 +175,7 @@ func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr
 				shift = 0
 				flushed = true
 				class = _NO_CLASS
-			case reflect.Ptr:
+			case reflect.Ptr, reflect.UnsafePointer:
 				addInt(f.Pointer())
 				shift = 0
 				flushed = true

struct_test.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors
 
-//go:build darwin && (arm64 || amd64)
+//go:build (darwin && (arm64 || amd64)) || (linux && (arm64 || amd64))
 
 package purego_test
 
@@ -498,6 +498,44 @@ func TestRegisterFunc_structArgs(t *testing.T) {
 			t.Fatalf("FourInt32s returned %q wanted %q", result, want)
 		}
 	}
+	{
+		// Simple pointer wrapper struct - tests single pointer field
+		type PointerWrapper struct {
+			ctx unsafe.Pointer
+		}
+		var ExtractPointer func(wrapper PointerWrapper) uintptr
+		purego.RegisterLibFunc(&ExtractPointer, lib, "ExtractPointer")
+
+		// Use actual allocated memory to satisfy checkptr
+		testValue := new(int)
+		expectedPtr := uintptr(unsafe.Pointer(testValue))
+		result := ExtractPointer(PointerWrapper{ctx: unsafe.Pointer(testValue)})
+		if result != expectedPtr {
+			t.Fatalf("ExtractPointer returned %#x wanted %#x", result, expectedPtr)
+		}
+		runtime.KeepAlive(testValue)
+	}
+	{
+		// Two pointer struct - tests register allocation for multiple pointer fields
+		type TwoPointers struct {
+			ptr1, ptr2 unsafe.Pointer
+		}
+		var AddPointers func(wrapper TwoPointers) uintptr
+		purego.RegisterLibFunc(&AddPointers, lib, "AddPointers")
+
+		// Use actual allocated memory to satisfy checkptr
+		val1 := new(int)
+		val2 := new(int)
+		ptr1 := uintptr(unsafe.Pointer(val1))
+		ptr2 := uintptr(unsafe.Pointer(val2))
+		expected := ptr1 + ptr2
+		result := AddPointers(TwoPointers{unsafe.Pointer(val1), unsafe.Pointer(val2)})
+		if result != expected {
+			t.Fatalf("AddPointers returned %#x wanted %#x", result, expected)
+		}
+		runtime.KeepAlive(val1)
+		runtime.KeepAlive(val2)
+	}
 }
 
 func TestRegisterFunc_structReturns(t *testing.T) {

testdata/structtest/struct_test.c

@@ -278,7 +278,7 @@ unsigned int Array2UnsignedShorts(struct Array2UnsignedShort a) {
 }
 
 struct Array4Chars {
-    char a[4];
+    int8_t a[4];
 };
 
 int Array4Chars(struct Array4Chars a) {
@@ -377,3 +377,22 @@ char* FourInt32s(struct FourInt32s s) {
     snprintf(result, 64, "%d:%d:%d:%d", s.f0, s.f1, s.f2, s.f3);
     return result;
 }
+
+// Simple pointer wrapper struct - tests single pointer field
+struct PointerWrapper {
+    void* ctx;
+};
+
+uintptr_t ExtractPointer(struct PointerWrapper wrapper) {
+    return (uintptr_t)wrapper.ctx;
+}
+
+// Two pointer struct - tests register allocation for multiple pointer fields
+struct TwoPointers {
+    void* ptr1;
+    void* ptr2;
+};
+
+uintptr_t AddPointers(struct TwoPointers wrapper) {
+    return (uintptr_t)wrapper.ptr1 + (uintptr_t)wrapper.ptr2;
+}