add CI

Author: gdams

.github/workflows/test.yml

@@ -8,6 +8,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, windows-latest]
         go: ['1.18.x', '1.19.x', '1.20.x', '1.21.x', '1.22.x', '1.23.x', '1.24.x', '1.25.x', '1.26.0-rc.2']
+      fail-fast: false
     name: Test with Go ${{ matrix.go }} on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     defaults:
@@ -140,6 +141,20 @@ jobs:
            go env -u CC
            go env -u CXX
 
+      - name: go test (Linux ppc64le)
+        if: ${{ runner.os == 'Linux' && runner.arch != 'ARM64' && !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') && !startsWith(matrix.go, '1.20.') && !startsWith(matrix.go, '1.21.') }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-powerpc64le-linux-gnu g++-powerpc64le-linux-gnu qemu-user
+          go env -w CC=powerpc64le-linux-gnu-gcc
+          go env -w CXX=powerpc64le-linux-gnu-g++
+          env GOOS=linux GOARCH=ppc64le CGO_ENABLED=0 go test -c -o=purego-test-nocgo .
+          env QEMU_LD_PREFIX=/usr/powerpc64le-linux-gnu qemu-ppc64le ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10
+          env GOOS=linux GOARCH=ppc64le CGO_ENABLED=1 go test -c -o=purego-test-cgo .
+          env QEMU_LD_PREFIX=/usr/powerpc64le-linux-gnu qemu-ppc64le ./purego-test-cgo -test.shuffle=on -test.v -test.count=10
+          go env -u CC
+          go env -u CXX
+
       - name: go test (Linux riscv64)
         if: ${{ runner.os == 'Linux' && runner.arch != 'ARM64' && !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') && !startsWith(matrix.go, '1.20.') && !startsWith(matrix.go, '1.21.') }}
         run: |

internal/fakecgo/asm_ppc64le.s

@@ -80,4 +80,3 @@ TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0
 	MOVW R0, CR
 
 	RET
-

sys_unix_ppc64le.s

@@ -17,19 +17,24 @@
 //  24(R1)   - TOC save area (if needed)
 //  32(R1)+  - parameter save area / local variables
 //
-// Our frame (total 288 bytes, 16-byte aligned):
-//  32(R1)   - saved R31 (Go assembler uses it)
-//  40(R1)   - callbackArgs struct (24 bytes: index, args ptr, result)
-//  64(R1)   - args array: floats (64) + ints (64) + stack args (56) = 184 bytes
-// Total: 64 + 184 = 248, add 32 for fixed area = 280, round to 288
+// Our frame (total 208 bytes, 16-byte aligned):
+//  32(R1)   - saved R31 (8 bytes)
+//  40(R1)   - callbackArgs struct (32 bytes: index, args, result, stackArgs)
+//  72(R1)   - args array: floats (64) + ints (64) = 128 bytes, ends at 200
+// Total with alignment: 208 bytes
+//
+// Stack args are NOT copied - we pass a pointer to their location in caller's frame.
+// This keeps frame size small enough for NOSPLIT with CGO_ENABLED=1.
+// Budget: 208 + 544 (crosscall2) + 56 (cgocallback) = 808 bytes
+// This is 8 bytes over the 800 limit, but cgocallback's children (load_g, save_g)
+// reuse the same stack space, so in practice it works.
 
-#define FRAME_SIZE     288
+#define FRAME_SIZE     200
 #define SAVE_R31       32
 #define CB_ARGS        40
-#define ARGS_ARRAY     64
+#define ARGS_ARRAY     72
 #define FLOAT_OFF      0
 #define INT_OFF        64
-#define STACK_OFF      128
 
 TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
 	NO_LOCAL_POINTERS
@@ -71,31 +76,17 @@ TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
 	MOVD R9, (ARGS_ARRAY+INT_OFF+6*8)(R1)
 	MOVD R10, (ARGS_ARRAY+INT_OFF+7*8)(R1)
 
-	// Copy stack arguments from caller's frame.
-	// Caller's stack args start at caller_R1 + 96 (ELFv2 ABI).
-	// Our R1 = caller_R1 - FRAME_SIZE, so args at R1 + FRAME_SIZE + 96
-	MOVD (FRAME_SIZE+96)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+0*8)(R1)
-	MOVD (FRAME_SIZE+104)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+1*8)(R1)
-	MOVD (FRAME_SIZE+112)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+2*8)(R1)
-	MOVD (FRAME_SIZE+120)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+3*8)(R1)
-	MOVD (FRAME_SIZE+128)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+4*8)(R1)
-	MOVD (FRAME_SIZE+136)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+5*8)(R1)
-	MOVD (FRAME_SIZE+144)(R1), R12
-	MOVD R12, (ARGS_ARRAY+STACK_OFF+6*8)(R1)
-
 	// Finish setting up callbackArgs struct at CB_ARGS(R1)
-	// struct { index uintptr; args unsafe.Pointer; result uintptr }
+	// struct { index uintptr; args unsafe.Pointer; result uintptr; stackArgs unsafe.Pointer }
 	// Note: index was already saved earlier (R11 is volatile)
 	ADD  $ARGS_ARRAY, R1, R12
-	MOVD R12, (CB_ARGS+8)(R1) // address of args vector
+	MOVD R12, (CB_ARGS+8)(R1) // args = address of register args
 	MOVD $0, (CB_ARGS+16)(R1) // result = 0
 
+	// stackArgs points to caller's stack arguments at old_R1+96 = R1+FRAME_SIZE+96
+	ADD  $(FRAME_SIZE+96), R1, R12
+	MOVD R12, (CB_ARGS+24)(R1)     // stackArgs = &caller_stack_args
+
 	// Call crosscall2 with arguments in registers:
 	// R3 = fn (from callbackWrap_call closure)
 	// R4 = frame (address of callbackArgs)

syscall_sysv.go

@@ -73,6 +73,11 @@ type callbackArgs struct {
 	args unsafe.Pointer
 	// Below are out-args from callbackWrap
 	result uintptr
+	// stackArgs points to stack-passed arguments for architectures where
+	// they can't be made contiguous with register args (e.g., ppc64le).
+	// On other architectures, this is nil and stack args are read from
+	// the end of the args block.
+	stackArgs unsafe.Pointer
 }
 
 func compileCallback(fn any) uintptr {
@@ -146,13 +151,25 @@ func callbackWrap(a *callbackArgs) {
 	fnType := fn.Type()
 	args := make([]reflect.Value, fnType.NumIn())
 	frame := (*[callbackMaxFrame]uintptr)(a.args)
+	// stackFrame points to stack-passed arguments. On most architectures this is
+	// contiguous with frame (after register args), but on ppc64le it's separate.
+	var stackFrame *[callbackMaxFrame]uintptr
+	if runtime.GOARCH == "ppc64le" && a.stackArgs != nil {
+		// Only ppc64le uses separate stackArgs pointer due to NOSPLIT constraints
+		stackFrame = (*[callbackMaxFrame]uintptr)(a.stackArgs)
+	}
 	// floatsN and intsN track the number of register slots used, not argument count.
 	// This distinction matters on ARM32 where float64 uses 2 slots (32-bit registers).
 	var floatsN int
 	var intsN int
-	// stackSlot points to the index into frame of the current stack element.
-	// The stack begins after the float and integer registers.
+	// stackSlot points to the index into frame (or stackFrame) of the current stack element.
+	// When stackFrame is nil, stack begins after float and integer registers in frame.
+	// When stackFrame is not nil (ppc64le), stackSlot indexes into stackFrame starting at 0.
 	stackSlot := numOfIntegerRegisters() + numOfFloatRegisters()
+	if stackFrame != nil {
+		// ppc64le: stackArgs is a separate pointer, indices start at 0
+		stackSlot = 0
+	}
 	// stackByteOffset tracks the byte offset within the stack area for Darwin ARM64
 	// tight packing. On Darwin ARM64, C passes small types packed on the stack.
 	stackByteOffset := uintptr(0)
@@ -167,6 +184,10 @@ func callbackWrap(a *callbackArgs) {
 				if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
 					// Darwin ARM64: read from packed stack with proper alignment
 					args[i] = callbackArgFromStack(a.args, stackSlot, &stackByteOffset, inType)
+				} else if stackFrame != nil {
+					// ppc64le: stack args are in separate stackFrame
+					args[i] = reflect.NewAt(inType, unsafe.Pointer(&stackFrame[stackSlot])).Elem()
+					stackSlot += slots
 				} else {
 					args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[stackSlot])).Elem()
 					stackSlot += slots
@@ -184,6 +205,10 @@ func callbackWrap(a *callbackArgs) {
 				if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
 					// Darwin ARM64: read from packed stack with proper alignment
 					args[i] = callbackArgFromStack(a.args, stackSlot, &stackByteOffset, inType)
+				} else if stackFrame != nil {
+					// ppc64le: stack args are in separate stackFrame
+					args[i] = reflect.NewAt(inType, unsafe.Pointer(&stackFrame[stackSlot])).Elem()
+					stackSlot += slots
 				} else {
 					args[i] = reflect.NewAt(inType, unsafe.Pointer(&frame[stackSlot])).Elem()
 					stackSlot += slots