syscall: implement C-packed callback support for Darwin ARM64

Implement proper C-packed argument layout in the callback wrapper,
allowing callbacks to correctly handle packed stack arguments on
Darwin ARM64.

Changes:
- Split callbackWrap into platform-specific versions
- callbackWrapDarwinARM64: handles C-packed stack layout with natural
  alignment for Darwin ARM64
- callbackWrapGeneric: maintains 8-byte slot layout for other platforms
- Add comprehensive tests for int32, mixed types, and small types
- Test both Go→C→Go callback paths with real C code

This enables callbacks to work properly with C-packed arguments,
fixing argument misalignment issues on Darwin ARM64.

Author: tmc

callback_test.go

@@ -173,3 +173,151 @@ func ExampleNewCallback_cdecl() {
 
 	// Output: 83
 }
+
+func TestNewCallbackInt32Packing(t *testing.T) {
+	var result int32
+	cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 int32) int32 {
+		result = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12
+		return result
+	})
+
+	var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 int32) int32
+	purego.RegisterFunc(&fn, cb)
+
+	got := fn(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37)
+	want := int32(197)
+
+	if got != want {
+		t.Errorf("callback returned %d, want %d", got, want)
+	}
+}
+
+func TestNewCallbackMixedPacking(t *testing.T) {
+	var gotI32_1, gotI32_2 int32
+	var gotI64 int64
+	cb := purego.NewCallback(func(r1, r2, r3, r4, r5, r6, r7, r8 int64, s1 int32, s2 int64, s3 int32) {
+		gotI32_1 = s1
+		gotI64 = s2
+		gotI32_2 = s3
+	})
+
+	var fn func(r1, r2, r3, r4, r5, r6, r7, r8 int64, s1 int32, s2 int64, s3 int32)
+	purego.RegisterFunc(&fn, cb)
+
+	fn(1, 2, 3, 4, 5, 6, 7, 8, 100, 200, 300)
+
+	if gotI32_1 != 100 || gotI64 != 200 || gotI32_2 != 300 {
+		t.Errorf("got (%d, %d, %d), want (100, 200, 300)", gotI32_1, gotI64, gotI32_2)
+	}
+}
+
+func TestNewCallbackSmallTypes(t *testing.T) {
+	var gotBool bool
+	var gotI8 int8
+	var gotU8 uint8
+	var gotI16 int16
+	var gotU16 uint16
+	var gotI32 int32
+	cb := purego.NewCallback(func(r1, r2, r3, r4, r5, r6, r7, r8 int64, b bool, i8 int8, u8 uint8, i16 int16, u16 uint16, i32 int32) {
+		gotBool = b
+		gotI8 = i8
+		gotU8 = u8
+		gotI16 = i16
+		gotU16 = u16
+		gotI32 = i32
+	})
+
+	var fn func(r1, r2, r3, r4, r5, r6, r7, r8 int64, b bool, i8 int8, u8 uint8, i16 int16, u16 uint16, i32 int32)
+	purego.RegisterFunc(&fn, cb)
+
+	fn(1, 2, 3, 4, 5, 6, 7, 8, true, -42, 200, -1000, 50000, 123456)
+
+	if !gotBool || gotI8 != -42 || gotU8 != 200 || gotI16 != -1000 || gotU16 != 50000 || gotI32 != 123456 {
+		t.Errorf("got (bool=%v, i8=%d, u8=%d, i16=%d, u16=%d, i32=%d), want (true, -42, 200, -1000, 50000, 123456)",
+			gotBool, gotI8, gotU8, gotI16, gotU16, gotI32)
+	}
+}
+
+func TestCallbackFromC(t *testing.T) {
+	libFileName := filepath.Join(t.TempDir(), "libcbpackingtest.so")
+
+	if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_packing_test.c")); err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(libFileName)
+
+	lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL)
+	if err != nil {
+		t.Fatalf("Dlopen(%q) failed: %v", libFileName, err)
+	}
+
+	t.Run("int32_packing", func(t *testing.T) {
+		var result int32
+		goCallback := func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 int32) int32 {
+			result = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12
+			return result
+		}
+
+		var callCallbackInt32Packing func(uintptr) int32
+		purego.RegisterLibFunc(&callCallbackInt32Packing, lib, "callCallbackInt32Packing")
+
+		cb := purego.NewCallback(goCallback)
+		got := callCallbackInt32Packing(cb)
+		want := int32(197) // sum of primes: 2+3+5+7+11+13+17+19+23+29+31+37
+
+		if got != want {
+			t.Errorf("C called callback returned %d, want %d", got, want)
+		}
+		if result != want {
+			t.Errorf("callback received wrong args, sum=%d, want %d", result, want)
+		}
+	})
+
+	t.Run("mixed_packing", func(t *testing.T) {
+		var gotI32_1, gotI32_2 int32
+		var gotI64 int64
+		goCallback := func(r1, r2, r3, r4, r5, r6, r7, r8 int64, s1 int32, s2 int64, s3 int32) {
+			gotI32_1 = s1
+			gotI64 = s2
+			gotI32_2 = s3
+		}
+
+		var callCallbackMixedPacking func(uintptr)
+		purego.RegisterLibFunc(&callCallbackMixedPacking, lib, "callCallbackMixedPacking")
+
+		cb := purego.NewCallback(goCallback)
+		callCallbackMixedPacking(cb)
+
+		if gotI32_1 != 100 || gotI64 != 200 || gotI32_2 != 300 {
+			t.Errorf("callback received (%d, %d, %d), want (100, 200, 300)", gotI32_1, gotI64, gotI32_2)
+		}
+	})
+
+	t.Run("small_types", func(t *testing.T) {
+		var gotBool bool
+		var gotI8 int8
+		var gotU8 uint8
+		var gotI16 int16
+		var gotU16 uint16
+		var gotI32 int32
+		goCallback := func(r1, r2, r3, r4, r5, r6, r7, r8 int64, b bool, i8 int8, u8 uint8, i16 int16, u16 uint16, i32 int32) {
+			gotBool = b
+			gotI8 = i8
+			gotU8 = u8
+			gotI16 = i16
+			gotU16 = u16
+			gotI32 = i32
+		}
+
+		var callCallbackSmallTypes func(uintptr)
+		purego.RegisterLibFunc(&callCallbackSmallTypes, lib, "callCallbackSmallTypes")
+
+		cb := purego.NewCallback(goCallback)
+		callCallbackSmallTypes(cb)
+
+		if !gotBool || gotI8 != -42 || gotU8 != 200 || gotI16 != -1000 || gotU16 != 50000 || gotI32 != 123456 {
+			t.Errorf("callback received (bool=%v, i8=%d, u8=%d, i16=%d, u16=%d, i32=%d), want (true, -42, 200, -1000, 50000, 123456)",
+				gotBool, gotI8, gotU8, gotI16, gotU16, gotI32)
+		}
+	})
+}

func.go

@@ -390,12 +390,7 @@ func RegisterFunc(fptr any, cfn uintptr) {
 			isInt := !isFloat && v.Kind() != reflect.Struct
 			wouldBeOnStack := (isInt && numInts >= numOfIntegerRegisters()) || (isFloat && numFloats >= numOfFloatRegisters)
 
-			// Don't use C struct packing when calling callbacks, as the callback wrapper
-			// expects the old unpacked layout where each argument is in its own 8-byte slot.
-			// TODO: Fix the callback wrapper to handle C-packed layout correctly.
-			isCallback := isCallbackFunction(cfn)
-
-			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && wouldBeOnStack && !isCallback {
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && wouldBeOnStack {
 				// Collect remaining arguments that will go on the stack.
 				// We need to bundle them into a struct to get proper C packing.
 				var stackArgs []reflect.Value

syscall_cgo_linux.go

@@ -19,7 +19,3 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a
 func NewCallback(_ any) uintptr {
 	panic("purego: NewCallback on Linux is only supported on amd64/arm64/loong64")
 }
-
-func isCallbackFunction(cfn uintptr) bool {
-	return false
-}

syscall_sysv.go

@@ -124,10 +124,6 @@ const ptrSize = unsafe.Sizeof((*int)(nil))
 
 const callbackMaxFrame = 64 * ptrSize
 
-func isCallbackFunction(cfn uintptr) bool {
-	return cfn >= callbackasmABI0 && cfn < callbackasmABI0+uintptr(callbackMaxFrame*8)
-}
-
 // callbackasm is implemented in zcallback_GOOS_GOARCH.s
 //
 //go:linkname __callbackasm callbackasm
@@ -148,6 +144,38 @@ func callbackWrap(a *callbackArgs) {
 	cbs.lock.Unlock()
 	fnType := fn.Type()
 	args := make([]reflect.Value, fnType.NumIn())
+
+	if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" {
+		callbackWrapDarwinARM64(a, fn, fnType, args)
+	} else {
+		callbackWrapGeneric(a, fn, fnType, args)
+	}
+
+	ret := fn.Call(args)
+	if len(ret) > 0 {
+		switch k := ret[0].Kind(); k {
+		case reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uintptr:
+			a.result = uintptr(ret[0].Uint())
+		case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8:
+			a.result = uintptr(ret[0].Int())
+		case reflect.Bool:
+			if ret[0].Bool() {
+				a.result = 1
+			} else {
+				a.result = 0
+			}
+		case reflect.Pointer:
+			a.result = ret[0].Pointer()
+		case reflect.UnsafePointer:
+			a.result = ret[0].Pointer()
+		default:
+			panic("purego: unsupported kind: " + k.String())
+		}
+	}
+}
+
+// callbackWrapGeneric handles callbacks with unpacked (8-byte slot) argument layout.
+func callbackWrapGeneric(a *callbackArgs, fn reflect.Value, fnType reflect.Type, args []reflect.Value) {
 	frame := (*[callbackMaxFrame]uintptr)(a.args)
 	var floatsN int // floatsN represents the number of float arguments processed
 	var intsN int   // intsN represents the number of integer arguments processed
@@ -170,7 +198,6 @@ func callbackWrap(a *callbackArgs) {
 			args[i] = reflect.Zero(fnType.In(i))
 			continue
 		default:
-
 			if intsN >= numOfIntegerRegisters() {
 				pos = stack
 				stack++
@@ -182,25 +209,54 @@ func callbackWrap(a *callbackArgs) {
 		}
 		args[i] = reflect.NewAt(fnType.In(i), unsafe.Pointer(&frame[pos])).Elem()
 	}
-	ret := fn.Call(args)
-	if len(ret) > 0 {
-		switch k := ret[0].Kind(); k {
-		case reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uintptr:
-			a.result = uintptr(ret[0].Uint())
-		case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8:
-			a.result = uintptr(ret[0].Int())
-		case reflect.Bool:
-			if ret[0].Bool() {
-				a.result = 1
+}
+
+// callbackWrapDarwinARM64 handles callbacks with C-packed stack argument layout on Darwin ARM64.
+func callbackWrapDarwinARM64(a *callbackArgs, fn reflect.Value, fnType reflect.Type, args []reflect.Value) {
+	frameBytes := (*[callbackMaxFrame * 8]byte)(a.args)
+	var floatsN int
+	var intsN int
+	// stackOffset tracks byte offset into the stack portion (after registers)
+	stackOffset := (numOfIntegerRegisters() + numOfFloatRegisters) * 8
+
+	for i := range args {
+		argType := fnType.In(i)
+		argSize := int(argType.Size())
+		// Natural alignment: align to the argument's size (min 1, max 8)
+		alignment := argSize
+		if alignment > 8 {
+			alignment = 8
+		}
+
+		switch argType.Kind() {
+		case reflect.Float32, reflect.Float64:
+			if floatsN >= numOfFloatRegisters {
+				// Stack argument - align and use C packing
+				stackOffset = (stackOffset + alignment - 1) & ^(alignment - 1)
+				args[i] = reflect.NewAt(argType, unsafe.Pointer(&frameBytes[stackOffset])).Elem()
+				stackOffset += argSize
 			} else {
-				a.result = 0
+				// Register argument
+				pos := floatsN * 8
+				args[i] = reflect.NewAt(argType, unsafe.Pointer(&frameBytes[pos])).Elem()
 			}
-		case reflect.Pointer:
-			a.result = ret[0].Pointer()
-		case reflect.UnsafePointer:
-			a.result = ret[0].Pointer()
+			floatsN++
+		case reflect.Struct:
+			// This is the CDecl field
+			args[i] = reflect.Zero(argType)
+			continue
 		default:
-			panic("purego: unsupported kind: " + k.String())
+			if intsN >= numOfIntegerRegisters() {
+				// Stack argument - align and use C packing
+				stackOffset = (stackOffset + alignment - 1) & ^(alignment - 1)
+				args[i] = reflect.NewAt(argType, unsafe.Pointer(&frameBytes[stackOffset])).Elem()
+				stackOffset += argSize
+			} else {
+				// Register argument - integers start after floats
+				pos := (numOfFloatRegisters + intsN) * 8
+				args[i] = reflect.NewAt(argType, unsafe.Pointer(&frameBytes[pos])).Elem()
+			}
+			intsN++
 		}
 	}
 }

syscall_windows.go

@@ -41,10 +41,6 @@ func NewCallback(fn any) uintptr {
 	return syscall.NewCallback(fn)
 }
 
-func isCallbackFunction(cfn uintptr) bool {
-	return false
-}
-
 func loadSymbol(handle uintptr, name string) (uintptr, error) {
 	return syscall.GetProcAddress(syscall.Handle(handle), name)
 }

testdata/libcbtest/callback_packing_test.c

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
+
+#include <stdint.h>
+
+typedef int32_t (*callback_int32)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t,
+                                   int32_t, int32_t, int32_t, int32_t);
+
+int32_t callCallbackInt32Packing(const void *fp) {
+    return ((callback_int32)(fp))(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37);
+}
+
+typedef void (*callback_mixed)(int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t,
+                                int32_t, int64_t, int32_t);
+
+void callCallbackMixedPacking(const void *fp) {
+    ((callback_mixed)(fp))(1, 2, 3, 4, 5, 6, 7, 8, 100, 200, 300);
+}
+
+typedef void (*callback_small_types)(int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t, int64_t,
+                                      _Bool, int8_t, uint8_t, int16_t, uint16_t, int32_t);
+
+void callCallbackSmallTypes(const void *fp) {
+    ((callback_small_types)(fp))(1, 2, 3, 4, 5, 6, 7, 8, 1, -42, 200, -1000, 50000, 123456);
+}