detached 33b97fd

Increase max argument to 15 (#182)

commit
33b97fd6a58bb9b0a49975db60adc78b4619047e
author
TotallyGamerJet · · 2023-11-29 13:11 UTC
committer
GitHub · · 2023-11-29 13:11 UTC
parent
192c5e8
signature
GPG Unverified4AEE18F83AFDEB23 The key is unknown
10 files · +184 -130
Split
UnifiedSplit
M callback_test.go +7 -7
@@ -126,18 +126,18 @@ func TestNewCallbackFloat32(t *testing.T) {
126126 func TestNewCallbackFloat32AndFloat64(t *testing.T) {
127127 // This tests that calling a function with a mix of float32 and float64 arguments works
128128 const (
129- expectedCbTotalF32 = float32(30)
130- expectedCbTotalF64 = float64(15)
129+ expectedCbTotalF32 = float32(72)
130+ expectedCbTotalF64 = float64(48)
131131 )
132132 var cbTotalF32 float32
133133 var cbTotalF64 float64
134- imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32) {
135- cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9
136- cbTotalF64 = f4 + f5 + f6
134+ imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32) {
135+ cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9 + f13 + f14 + f15
136+ cbTotalF64 = f4 + f5 + f6 + f10 + f11 + f12
137137 })
138- var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32)
138+ var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32)
139139 purego.RegisterFunc(&fn, imp)
140- fn(1, 2, 3, 4, 5, 6, 7, 8, 9)
140+ fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
141141
142142 if cbTotalF32 != expectedCbTotalF32 {
143143 t.Errorf("cbTotalF32 not correct got %f but wanted %f", cbTotalF32, expectedCbTotalF32)
@@ -126,18 +126,18 @@ func TestNewCallbackFloat32(t *testing.T) {
126 func TestNewCallbackFloat32AndFloat64(t *testing.T) {126 func TestNewCallbackFloat32AndFloat64(t *testing.T) {
127 // This tests that calling a function with a mix of float32 and float64 arguments works127 // This tests that calling a function with a mix of float32 and float64 arguments works
128 const (128 const (
129- expectedCbTotalF32 = float32(30)129+ expectedCbTotalF32 = float32(72)
130- expectedCbTotalF64 = float64(15)130+ expectedCbTotalF64 = float64(48)
131 )131 )
132 var cbTotalF32 float32132 var cbTotalF32 float32
133 var cbTotalF64 float64133 var cbTotalF64 float64
134- imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32) {134+ imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32) {
135- cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9135+ cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9 + f13 + f14 + f15
136- cbTotalF64 = f4 + f5 + f6136+ cbTotalF64 = f4 + f5 + f6 + f10 + f11 + f12
137 })137 })
138- var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32)138+ var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32)
139 purego.RegisterFunc(&fn, imp)139 purego.RegisterFunc(&fn, imp)
140- fn(1, 2, 3, 4, 5, 6, 7, 8, 9)140+ fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
141 141
142 if cbTotalF32 != expectedCbTotalF32 {142 if cbTotalF32 != expectedCbTotalF32 {
143 t.Errorf("cbTotalF32 not correct got %f but wanted %f", cbTotalF32, expectedCbTotalF32)143 t.Errorf("cbTotalF32 not correct got %f but wanted %f", cbTotalF32, expectedCbTotalF32)
M func.go +8 -4
@@ -236,17 +236,21 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
236236 var r1, r2 uintptr
237237 if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" {
238238 // Use the normal arm64 calling convention even on Windows
239- syscall := syscall9Args{
239+ syscall := syscall15Args{
240240 cfn,
241- sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8],
241+ sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5],
242+ sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],
243+ sysargs[12], sysargs[13], sysargs[14],
242244 floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7],
243245 0, 0, 0,
244246 }
245- runtime_cgocall(syscall9XABI0, unsafe.Pointer(&syscall))
247+ runtime_cgocall(syscall15XABI0, unsafe.Pointer(&syscall))
246248 r1, r2 = syscall.r1, syscall.r2
247249 } else {
248250 // This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
249- r1, r2, _ = syscall_syscall9X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8])
251+ r1, r2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4],
252+ sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],
253+ sysargs[12], sysargs[13], sysargs[14])
250254 }
251255 if ty.NumOut() == 0 {
252256 return nil
@@ -236,17 +236,21 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
236 var r1, r2 uintptr236 var r1, r2 uintptr
237 if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" {237 if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" {
238 // Use the normal arm64 calling convention even on Windows238 // Use the normal arm64 calling convention even on Windows
239- syscall := syscall9Args{239+ syscall := syscall15Args{
240 cfn,240 cfn,
241- sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8],241+ sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5],
242+ sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],
243+ sysargs[12], sysargs[13], sysargs[14],
242 floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7],244 floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7],
243 0, 0, 0,245 0, 0, 0,
244 }246 }
245- runtime_cgocall(syscall9XABI0, unsafe.Pointer(&syscall))247+ runtime_cgocall(syscall15XABI0, unsafe.Pointer(&syscall))
246 r1, r2 = syscall.r1, syscall.r2248 r1, r2 = syscall.r1, syscall.r2
247 } else {249 } else {
248 // This is a fallback for Windows amd64, 386, and arm. Note this may not support floats250 // This is a fallback for Windows amd64, 386, and arm. Note this may not support floats
249- r1, r2, _ = syscall_syscall9X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8])251+ r1, r2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4],
252+ sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11],
253+ sysargs[12], sysargs[13], sysargs[14])
250 }254 }
251 if ty.NumOut() == 0 {255 if ty.NumOut() == 0 {
252 return nil256 return nil
M func_test.go +7 -7
@@ -47,19 +47,19 @@ func TestRegisterFunc(t *testing.T) {
4747 }
4848
4949 func ExampleNewCallback() {
50- cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int) int {
51- fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8, a9)
52- return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9
50+ cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int {
51+ fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
52+ return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15
5353 })
5454
55- var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int) int
55+ var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int
5656 purego.RegisterFunc(&fn, cb)
5757
58- ret := fn(1, 2, 3, 4, 5, 6, 7, 8, 9)
58+ ret := fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
5959 fmt.Println(ret)
6060
61- // Output: 1 2 3 4 5 6 7 8 9
62- // 45
61+ // Output: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
62+ // 120
6363 }
6464
6565 func Test_qsort(t *testing.T) {
@@ -47,19 +47,19 @@ func TestRegisterFunc(t *testing.T) {
47 }47 }
48 48
49 func ExampleNewCallback() {49 func ExampleNewCallback() {
50- cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int) int {50+ cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int {
51- fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8, a9)51+ fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
52- return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a952+ return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15
53 })53 })
54 54
55- var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int) int55+ var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int
56 purego.RegisterFunc(&fn, cb)56 purego.RegisterFunc(&fn, cb)
57 57
58- ret := fn(1, 2, 3, 4, 5, 6, 7, 8, 9)58+ ret := fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
59 fmt.Println(ret)59 fmt.Println(ret)
60 60
61- // Output: 1 2 3 4 5 6 7 8 961+ // Output: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
62- // 4562+ // 120
63 }63 }
64 64
65 func Test_qsort(t *testing.T) {65 func Test_qsort(t *testing.T) {
M internal/cgo/syscall_cgo_unix.go +18 -12
@@ -16,18 +16,21 @@ package cgo
1616 #include <errno.h>
1717 #include <assert.h>
1818
19-typedef struct syscall9Args {
19+typedef struct syscall15Args {
2020 uintptr_t fn;
21- uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9;
21+ uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15;
2222 uintptr_t f1, f2, f3, f4, f5, f6, f7, f8;
2323 uintptr_t r1, r2, err;
24-} syscall9Args;
24+} syscall15Args;
2525
26-void syscall9(struct syscall9Args *args) {
26+void syscall15(struct syscall15Args *args) {
2727 assert((args->f1|args->f2|args->f3|args->f4|args->f5|args->f6|args->f7|args->f8) == 0);
28- uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9);
28+ uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6,
29+ uintptr_t a7, uintptr_t a8, uintptr_t a9, uintptr_t a10, uintptr_t a11, uintptr_t a12,
30+ uintptr_t a13, uintptr_t a14, uintptr_t a15);
2931 *(void**)(&func_name) = (void*)(args->fn);
30- uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9);
32+ uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9,
33+ args->a10,args->a11,args->a12,args->a13,args->a14,args->a15);
3134 args->r1 = r1;
3235 args->err = errno;
3336 }
@@ -36,8 +39,8 @@ void syscall9(struct syscall9Args *args) {
3639 import "C"
3740 import "unsafe"
3841
39-// assign purego.syscall9XABI0 to the C version of this function.
40-var Syscall9XABI0 = unsafe.Pointer(C.syscall9)
42+// assign purego.syscall15XABI0 to the C version of this function.
43+var Syscall15XABI0 = unsafe.Pointer(C.syscall15)
4144
4245 // all that is needed is to assign each dl function because then its
4346 // symbol will then be made available to the linker and linked to inside dlfcn.go
@@ -49,10 +52,13 @@ var (
4952 )
5053
5154 //go:nosplit
52-func Syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
53- args := C.syscall9Args{C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3),
55+func Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
56+ args := C.syscall15Args{
57+ C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3),
5458 C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6),
55- C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
56- C.syscall9(&args)
59+ C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), C.uintptr_t(a10), C.uintptr_t(a11), C.uintptr_t(a12),
60+ C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61+ }
62+ C.syscall15(&args)
5763 return uintptr(args.r1), uintptr(args.r2), uintptr(args.err)
5864 }
@@ -16,18 +16,21 @@ package cgo
16 #include <errno.h>16 #include <errno.h>
17 #include <assert.h>17 #include <assert.h>
18 18
19-typedef struct syscall9Args {19+typedef struct syscall15Args {
20 uintptr_t fn;20 uintptr_t fn;
21- uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9;21+ uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15;
22 uintptr_t f1, f2, f3, f4, f5, f6, f7, f8;22 uintptr_t f1, f2, f3, f4, f5, f6, f7, f8;
23 uintptr_t r1, r2, err;23 uintptr_t r1, r2, err;
24-} syscall9Args;24+} syscall15Args;
25 25
26-void syscall9(struct syscall9Args *args) {26+void syscall15(struct syscall15Args *args) {
27 assert((args->f1|args->f2|args->f3|args->f4|args->f5|args->f6|args->f7|args->f8) == 0);27 assert((args->f1|args->f2|args->f3|args->f4|args->f5|args->f6|args->f7|args->f8) == 0);
28- uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9);28+ uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6,
29+ uintptr_t a7, uintptr_t a8, uintptr_t a9, uintptr_t a10, uintptr_t a11, uintptr_t a12,
30+ uintptr_t a13, uintptr_t a14, uintptr_t a15);
29 *(void**)(&func_name) = (void*)(args->fn);31 *(void**)(&func_name) = (void*)(args->fn);
30- uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9);32+ uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9,
33+ args->a10,args->a11,args->a12,args->a13,args->a14,args->a15);
31 args->r1 = r1;34 args->r1 = r1;
32 args->err = errno;35 args->err = errno;
33 }36 }
@@ -36,8 +39,8 @@ void syscall9(struct syscall9Args *args) {
36 import "C"39 import "C"
37 import "unsafe"40 import "unsafe"
38 41
39-// assign purego.syscall9XABI0 to the C version of this function.42+// assign purego.syscall15XABI0 to the C version of this function.
40-var Syscall9XABI0 = unsafe.Pointer(C.syscall9)43+var Syscall15XABI0 = unsafe.Pointer(C.syscall15)
41 44
42 // all that is needed is to assign each dl function because then its45 // all that is needed is to assign each dl function because then its
43 // symbol will then be made available to the linker and linked to inside dlfcn.go46 // symbol will then be made available to the linker and linked to inside dlfcn.go
@@ -49,10 +52,13 @@ var (
49 )52 )
50 53
51 //go:nosplit54 //go:nosplit
52-func Syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {55+func Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
53- args := C.syscall9Args{C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3),56+ args := C.syscall15Args{
57+ C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3),
54 C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6),58 C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6),
55- C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}59+ C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), C.uintptr_t(a10), C.uintptr_t(a11), C.uintptr_t(a12),
56- C.syscall9(&args)60+ C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61+ }
62+ C.syscall15(&args)
57 return uintptr(args.r1), uintptr(args.r2), uintptr(args.err)63 return uintptr(args.r1), uintptr(args.r2), uintptr(args.err)
58 }64 }
M sys_amd64.s +60 -38
@@ -8,8 +8,11 @@
88 #include "go_asm.h"
99 #include "funcdata.h"
1010
11-// syscall9X calls a function in libc on behalf of the syscall package.
12-// syscall9X takes a pointer to a struct like:
11+#define STACK_SIZE 80
12+#define PTR_ADDRESS (STACK_SIZE - 8)
13+
14+// syscall15X calls a function in libc on behalf of the syscall package.
15+// syscall15X takes a pointer to a struct like:
1316 // struct {
1417 // fn uintptr
1518 // a1 uintptr
@@ -21,54 +24,73 @@
2124 // a7 uintptr
2225 // a8 uintptr
2326 // a9 uintptr
27+// a10 uintptr
28+// a11 uintptr
29+// a12 uintptr
30+// a13 uintptr
31+// a14 uintptr
32+// a15 uintptr
2433 // r1 uintptr
2534 // r2 uintptr
2635 // err uintptr
2736 // }
28-// syscall9X must be called on the g0 stack with the
37+// syscall15X must be called on the g0 stack with the
2938 // C calling convention (use libcCall).
30-GLOBL ·syscall9XABI0(SB), NOPTR|RODATA, $8
31-DATA ·syscall9XABI0(SB)/8, $syscall9X(SB)
32-TEXT syscall9X(SB), NOSPLIT|NOFRAME, $0
39+GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
40+DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
41+TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0
3342 PUSHQ BP
3443 MOVQ SP, BP
35- SUBQ $32, SP
36- MOVQ DI, 24(BP) // save the pointer
37-
38- MOVQ syscall9Args_f1(DI), X0 // f1
39- MOVQ syscall9Args_f2(DI), X1 // f2
40- MOVQ syscall9Args_f3(DI), X2 // f3
41- MOVQ syscall9Args_f4(DI), X3 // f4
42- MOVQ syscall9Args_f5(DI), X4 // f5
43- MOVQ syscall9Args_f6(DI), X5 // f6
44- MOVQ syscall9Args_f7(DI), X6 // f7
45- MOVQ syscall9Args_f8(DI), X7 // f8
46-
47- MOVQ syscall9Args_fn(DI), R10 // fn
48- MOVQ syscall9Args_a2(DI), SI // a2
49- MOVQ syscall9Args_a3(DI), DX // a3
50- MOVQ syscall9Args_a4(DI), CX // a4
51- MOVQ syscall9Args_a5(DI), R8 // a5
52- MOVQ syscall9Args_a6(DI), R9 // a6
53- MOVQ syscall9Args_a7(DI), R11 // a7
54- MOVQ syscall9Args_a8(DI), R12 // a8
55- MOVQ syscall9Args_a9(DI), R13 // a9
56- MOVQ syscall9Args_a1(DI), DI // a1
44+ SUBQ $STACK_SIZE, SP
45+ MOVQ DI, PTR_ADDRESS(BP) // save the pointer
46+ MOVQ DI, R11
47+
48+ MOVQ syscall15Args_f1(R11), X0 // f1
49+ MOVQ syscall15Args_f2(R11), X1 // f2
50+ MOVQ syscall15Args_f3(R11), X2 // f3
51+ MOVQ syscall15Args_f4(R11), X3 // f4
52+ MOVQ syscall15Args_f5(R11), X4 // f5
53+ MOVQ syscall15Args_f6(R11), X5 // f6
54+ MOVQ syscall15Args_f7(R11), X6 // f7
55+ MOVQ syscall15Args_f8(R11), X7 // f8
56+
57+ MOVQ syscall15Args_a1(R11), DI // a1
58+ MOVQ syscall15Args_a2(R11), SI // a2
59+ MOVQ syscall15Args_a3(R11), DX // a3
60+ MOVQ syscall15Args_a4(R11), CX // a4
61+ MOVQ syscall15Args_a5(R11), R8 // a5
62+ MOVQ syscall15Args_a6(R11), R9 // a6
5763
5864 // push the remaining paramters onto the stack
59- MOVQ R11, 0(SP) // push a7
60- MOVQ R12, 8(SP) // push a8
61- MOVQ R13, 16(SP) // push a9
62- XORL AX, AX // vararg: say "no float args"
63-
65+ MOVQ syscall15Args_a7(R11), R12
66+ MOVQ R12, 0(SP) // push a7
67+ MOVQ syscall15Args_a8(R11), R12
68+ MOVQ R12, 8(SP) // push a8
69+ MOVQ syscall15Args_a9(R11), R12
70+ MOVQ R12, 16(SP) // push a9
71+ MOVQ syscall15Args_a10(R11), R12
72+ MOVQ R12, 24(SP) // push a10
73+ MOVQ syscall15Args_a11(R11), R12
74+ MOVQ R12, 32(SP) // push a11
75+ MOVQ syscall15Args_a12(R11), R12
76+ MOVQ R12, 40(SP) // push a12
77+ MOVQ syscall15Args_a13(R11), R12
78+ MOVQ R12, 48(SP) // push a13
79+ MOVQ syscall15Args_a14(R11), R12
80+ MOVQ R12, 56(SP) // push a14
81+ MOVQ syscall15Args_a15(R11), R12
82+ MOVQ R12, 64(SP) // push a15
83+ XORL AX, AX // vararg: say "no float args"
84+
85+ MOVQ syscall15Args_fn(R11), R10 // fn
6486 CALL R10
6587
66- MOVQ 24(BP), DI // get the pointer back
67- MOVQ AX, syscall9Args_r1(DI) // r1
68- MOVQ X0, syscall9Args_r2(DI) // r2
88+ MOVQ PTR_ADDRESS(BP), DI // get the pointer back
89+ MOVQ AX, syscall15Args_r1(DI) // r1
90+ MOVQ X0, syscall15Args_r2(DI) // r2
6991
70- XORL AX, AX // no error (it's ignored anyway)
71- ADDQ $32, SP
92+ XORL AX, AX // no error (it's ignored anyway)
93+ ADDQ $STACK_SIZE, SP
7294 MOVQ BP, SP
7395 POPQ BP
7496 RET
@@ -8,8 +8,11 @@
8 #include "go_asm.h"8 #include "go_asm.h"
9 #include "funcdata.h"9 #include "funcdata.h"
10 10
11-// syscall9X calls a function in libc on behalf of the syscall package.11+#define STACK_SIZE 80
12-// syscall9X takes a pointer to a struct like:12+#define PTR_ADDRESS (STACK_SIZE - 8)
13+
14+// syscall15X calls a function in libc on behalf of the syscall package.
15+// syscall15X takes a pointer to a struct like:
13 // struct {16 // struct {
14 // fn uintptr17 // fn uintptr
15 // a1 uintptr18 // a1 uintptr
@@ -21,54 +24,73 @@
21 // a7 uintptr24 // a7 uintptr
22 // a8 uintptr25 // a8 uintptr
23 // a9 uintptr26 // a9 uintptr
27+// a10 uintptr
28+// a11 uintptr
29+// a12 uintptr
30+// a13 uintptr
31+// a14 uintptr
32+// a15 uintptr
24 // r1 uintptr33 // r1 uintptr
25 // r2 uintptr34 // r2 uintptr
26 // err uintptr35 // err uintptr
27 // }36 // }
28-// syscall9X must be called on the g0 stack with the37+// syscall15X must be called on the g0 stack with the
29 // C calling convention (use libcCall).38 // C calling convention (use libcCall).
30-GLOBL ·syscall9XABI0(SB), NOPTR|RODATA, $839+GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
31-DATA ·syscall9XABI0(SB)/8, $syscall9X(SB)40+DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
32-TEXT syscall9X(SB), NOSPLIT|NOFRAME, $041+TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0
33 PUSHQ BP42 PUSHQ BP
34 MOVQ SP, BP43 MOVQ SP, BP
35- SUBQ $32, SP44+ SUBQ $STACK_SIZE, SP
36- MOVQ DI, 24(BP) // save the pointer45+ MOVQ DI, PTR_ADDRESS(BP) // save the pointer
37-46+ MOVQ DI, R11
38- MOVQ syscall9Args_f1(DI), X0 // f147+
39- MOVQ syscall9Args_f2(DI), X1 // f248+ MOVQ syscall15Args_f1(R11), X0 // f1
40- MOVQ syscall9Args_f3(DI), X2 // f349+ MOVQ syscall15Args_f2(R11), X1 // f2
41- MOVQ syscall9Args_f4(DI), X3 // f450+ MOVQ syscall15Args_f3(R11), X2 // f3
42- MOVQ syscall9Args_f5(DI), X4 // f551+ MOVQ syscall15Args_f4(R11), X3 // f4
43- MOVQ syscall9Args_f6(DI), X5 // f652+ MOVQ syscall15Args_f5(R11), X4 // f5
44- MOVQ syscall9Args_f7(DI), X6 // f753+ MOVQ syscall15Args_f6(R11), X5 // f6
45- MOVQ syscall9Args_f8(DI), X7 // f854+ MOVQ syscall15Args_f7(R11), X6 // f7
46-55+ MOVQ syscall15Args_f8(R11), X7 // f8
47- MOVQ syscall9Args_fn(DI), R10 // fn56+
48- MOVQ syscall9Args_a2(DI), SI // a257+ MOVQ syscall15Args_a1(R11), DI // a1
49- MOVQ syscall9Args_a3(DI), DX // a358+ MOVQ syscall15Args_a2(R11), SI // a2
50- MOVQ syscall9Args_a4(DI), CX // a459+ MOVQ syscall15Args_a3(R11), DX // a3
51- MOVQ syscall9Args_a5(DI), R8 // a560+ MOVQ syscall15Args_a4(R11), CX // a4
52- MOVQ syscall9Args_a6(DI), R9 // a661+ MOVQ syscall15Args_a5(R11), R8 // a5
53- MOVQ syscall9Args_a7(DI), R11 // a762+ MOVQ syscall15Args_a6(R11), R9 // a6
54- MOVQ syscall9Args_a8(DI), R12 // a8
55- MOVQ syscall9Args_a9(DI), R13 // a9
56- MOVQ syscall9Args_a1(DI), DI // a1
57 63
58 // push the remaining paramters onto the stack64 // push the remaining paramters onto the stack
59- MOVQ R11, 0(SP) // push a765+ MOVQ syscall15Args_a7(R11), R12
60- MOVQ R12, 8(SP) // push a866+ MOVQ R12, 0(SP) // push a7
61- MOVQ R13, 16(SP) // push a967+ MOVQ syscall15Args_a8(R11), R12
62- XORL AX, AX // vararg: say "no float args"68+ MOVQ R12, 8(SP) // push a8
63-69+ MOVQ syscall15Args_a9(R11), R12
70+ MOVQ R12, 16(SP) // push a9
71+ MOVQ syscall15Args_a10(R11), R12
72+ MOVQ R12, 24(SP) // push a10
73+ MOVQ syscall15Args_a11(R11), R12
74+ MOVQ R12, 32(SP) // push a11
75+ MOVQ syscall15Args_a12(R11), R12
76+ MOVQ R12, 40(SP) // push a12
77+ MOVQ syscall15Args_a13(R11), R12
78+ MOVQ R12, 48(SP) // push a13
79+ MOVQ syscall15Args_a14(R11), R12
80+ MOVQ R12, 56(SP) // push a14
81+ MOVQ syscall15Args_a15(R11), R12
82+ MOVQ R12, 64(SP) // push a15
83+ XORL AX, AX // vararg: say "no float args"
84+
85+ MOVQ syscall15Args_fn(R11), R10 // fn
64 CALL R1086 CALL R10
65 87
66- MOVQ 24(BP), DI // get the pointer back88+ MOVQ PTR_ADDRESS(BP), DI // get the pointer back
67- MOVQ AX, syscall9Args_r1(DI) // r189+ MOVQ AX, syscall15Args_r1(DI) // r1
68- MOVQ X0, syscall9Args_r2(DI) // r290+ MOVQ X0, syscall15Args_r2(DI) // r2
69 91
70- XORL AX, AX // no error (it's ignored anyway)92+ XORL AX, AX // no error (it's ignored anyway)
71- ADDQ $32, SP93+ ADDQ $STACK_SIZE, SP
72 MOVQ BP, SP94 MOVQ BP, SP
73 POPQ BP95 POPQ BP
74 RET96 RET
M sys_arm64.s +59 -37
@@ -7,8 +7,11 @@
77 #include "go_asm.h"
88 #include "funcdata.h"
99
10-// syscall9X calls a function in libc on behalf of the syscall package.
11-// syscall9X takes a pointer to a struct like:
10+#define STACK_SIZE 64
11+#define PTR_ADDRESS (STACK_SIZE - 8)
12+
13+// syscall15X calls a function in libc on behalf of the syscall package.
14+// syscall15X takes a pointer to a struct like:
1215 // struct {
1316 // fn uintptr
1417 // a1 uintptr
@@ -20,44 +23,63 @@
2023 // a7 uintptr
2124 // a8 uintptr
2225 // a9 uintptr
26+// a10 uintptr
27+// a11 uintptr
28+// a12 uintptr
29+// a13 uintptr
30+// a14 uintptr
31+// a15 uintptr
2332 // r1 uintptr
2433 // r2 uintptr
2534 // err uintptr
2635 // }
27-// syscall9X must be called on the g0 stack with the
36+// syscall15X must be called on the g0 stack with the
2837 // C calling convention (use libcCall).
29-GLOBL ·syscall9XABI0(SB), NOPTR|RODATA, $8
30-DATA ·syscall9XABI0(SB)/8, $syscall9X(SB)
31-TEXT syscall9X(SB), NOSPLIT, $0
32- SUB $16, RSP // push structure pointer
33- MOVD R0, 8(RSP)
34-
35- FMOVD syscall9Args_f1(R0), F0 // f1
36- FMOVD syscall9Args_f2(R0), F1 // f2
37- FMOVD syscall9Args_f3(R0), F2 // f3
38- FMOVD syscall9Args_f4(R0), F3 // f4
39- FMOVD syscall9Args_f5(R0), F4 // f5
40- FMOVD syscall9Args_f6(R0), F5 // f6
41- FMOVD syscall9Args_f7(R0), F6 // f7
42- FMOVD syscall9Args_f8(R0), F7 // f8
43-
44- MOVD syscall9Args_fn(R0), R12 // fn
45- MOVD syscall9Args_a2(R0), R1 // a2
46- MOVD syscall9Args_a3(R0), R2 // a3
47- MOVD syscall9Args_a4(R0), R3 // a4
48- MOVD syscall9Args_a5(R0), R4 // a5
49- MOVD syscall9Args_a6(R0), R5 // a6
50- MOVD syscall9Args_a7(R0), R6 // a7
51- MOVD syscall9Args_a8(R0), R7 // a8
52- MOVD syscall9Args_a9(R0), R8 // a9
53- MOVD syscall9Args_a1(R0), R0 // a1
54-
55- MOVD R8, (RSP) // push a9 onto stack
56-
57- BL (R12)
58-
59- MOVD 8(RSP), R2 // pop structure pointer
60- ADD $16, RSP
61- MOVD R0, syscall9Args_r1(R2) // save r1
62- FMOVD F0, syscall9Args_r2(R2) // save r2
38+GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
39+DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
40+TEXT syscall15X(SB), NOSPLIT, $0
41+ SUB $STACK_SIZE, RSP // push structure pointer
42+ MOVD R0, PTR_ADDRESS(RSP)
43+ MOVD R0, R9
44+
45+ FMOVD syscall15Args_f1(R9), F0 // f1
46+ FMOVD syscall15Args_f2(R9), F1 // f2
47+ FMOVD syscall15Args_f3(R9), F2 // f3
48+ FMOVD syscall15Args_f4(R9), F3 // f4
49+ FMOVD syscall15Args_f5(R9), F4 // f5
50+ FMOVD syscall15Args_f6(R9), F5 // f6
51+ FMOVD syscall15Args_f7(R9), F6 // f7
52+ FMOVD syscall15Args_f8(R9), F7 // f8
53+
54+ MOVD syscall15Args_a1(R9), R0 // a1
55+ MOVD syscall15Args_a2(R9), R1 // a2
56+ MOVD syscall15Args_a3(R9), R2 // a3
57+ MOVD syscall15Args_a4(R9), R3 // a4
58+ MOVD syscall15Args_a5(R9), R4 // a5
59+ MOVD syscall15Args_a6(R9), R5 // a6
60+ MOVD syscall15Args_a7(R9), R6 // a7
61+ MOVD syscall15Args_a8(R9), R7 // a8
62+
63+ MOVD syscall15Args_a9(R9), R10
64+ MOVD R10, 0(RSP) // push a9 onto stack
65+ MOVD syscall15Args_a10(R9), R10
66+ MOVD R10, 8(RSP) // push a10 onto stack
67+ MOVD syscall15Args_a11(R9), R10
68+ MOVD R10, 16(RSP) // push a11 onto stack
69+ MOVD syscall15Args_a12(R9), R10
70+ MOVD R10, 24(RSP) // push a12 onto stack
71+ MOVD syscall15Args_a13(R9), R10
72+ MOVD R10, 32(RSP) // push a13 onto stack
73+ MOVD syscall15Args_a14(R9), R10
74+ MOVD R10, 40(RSP) // push a14 onto stack
75+ MOVD syscall15Args_a15(R9), R10
76+ MOVD R10, 48(RSP) // push a15 onto stack
77+
78+ MOVD syscall15Args_fn(R9), R10 // fn
79+ BL (R10)
80+
81+ MOVD PTR_ADDRESS(RSP), R2 // pop structure pointer
82+ ADD $STACK_SIZE, RSP
83+ MOVD R0, syscall15Args_r1(R2) // save r1
84+ FMOVD F0, syscall15Args_r2(R2) // save r2
6385 RET
@@ -7,8 +7,11 @@
7 #include "go_asm.h"7 #include "go_asm.h"
8 #include "funcdata.h"8 #include "funcdata.h"
9 9
10-// syscall9X calls a function in libc on behalf of the syscall package.10+#define STACK_SIZE 64
11-// syscall9X takes a pointer to a struct like:11+#define PTR_ADDRESS (STACK_SIZE - 8)
12+
13+// syscall15X calls a function in libc on behalf of the syscall package.
14+// syscall15X takes a pointer to a struct like:
12 // struct {15 // struct {
13 // fn uintptr16 // fn uintptr
14 // a1 uintptr17 // a1 uintptr
@@ -20,44 +23,63 @@
20 // a7 uintptr23 // a7 uintptr
21 // a8 uintptr24 // a8 uintptr
22 // a9 uintptr25 // a9 uintptr
26+// a10 uintptr
27+// a11 uintptr
28+// a12 uintptr
29+// a13 uintptr
30+// a14 uintptr
31+// a15 uintptr
23 // r1 uintptr32 // r1 uintptr
24 // r2 uintptr33 // r2 uintptr
25 // err uintptr34 // err uintptr
26 // }35 // }
27-// syscall9X must be called on the g0 stack with the36+// syscall15X must be called on the g0 stack with the
28 // C calling convention (use libcCall).37 // C calling convention (use libcCall).
29-GLOBL ·syscall9XABI0(SB), NOPTR|RODATA, $838+GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
30-DATA ·syscall9XABI0(SB)/8, $syscall9X(SB)39+DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
31-TEXT syscall9X(SB), NOSPLIT, $040+TEXT syscall15X(SB), NOSPLIT, $0
32- SUB $16, RSP // push structure pointer41+ SUB $STACK_SIZE, RSP // push structure pointer
33- MOVD R0, 8(RSP)42+ MOVD R0, PTR_ADDRESS(RSP)
34-43+ MOVD R0, R9
35- FMOVD syscall9Args_f1(R0), F0 // f144+
36- FMOVD syscall9Args_f2(R0), F1 // f245+ FMOVD syscall15Args_f1(R9), F0 // f1
37- FMOVD syscall9Args_f3(R0), F2 // f346+ FMOVD syscall15Args_f2(R9), F1 // f2
38- FMOVD syscall9Args_f4(R0), F3 // f447+ FMOVD syscall15Args_f3(R9), F2 // f3
39- FMOVD syscall9Args_f5(R0), F4 // f548+ FMOVD syscall15Args_f4(R9), F3 // f4
40- FMOVD syscall9Args_f6(R0), F5 // f649+ FMOVD syscall15Args_f5(R9), F4 // f5
41- FMOVD syscall9Args_f7(R0), F6 // f750+ FMOVD syscall15Args_f6(R9), F5 // f6
42- FMOVD syscall9Args_f8(R0), F7 // f851+ FMOVD syscall15Args_f7(R9), F6 // f7
43-52+ FMOVD syscall15Args_f8(R9), F7 // f8
44- MOVD syscall9Args_fn(R0), R12 // fn53+
45- MOVD syscall9Args_a2(R0), R1 // a254+ MOVD syscall15Args_a1(R9), R0 // a1
46- MOVD syscall9Args_a3(R0), R2 // a355+ MOVD syscall15Args_a2(R9), R1 // a2
47- MOVD syscall9Args_a4(R0), R3 // a456+ MOVD syscall15Args_a3(R9), R2 // a3
48- MOVD syscall9Args_a5(R0), R4 // a557+ MOVD syscall15Args_a4(R9), R3 // a4
49- MOVD syscall9Args_a6(R0), R5 // a658+ MOVD syscall15Args_a5(R9), R4 // a5
50- MOVD syscall9Args_a7(R0), R6 // a759+ MOVD syscall15Args_a6(R9), R5 // a6
51- MOVD syscall9Args_a8(R0), R7 // a860+ MOVD syscall15Args_a7(R9), R6 // a7
52- MOVD syscall9Args_a9(R0), R8 // a961+ MOVD syscall15Args_a8(R9), R7 // a8
53- MOVD syscall9Args_a1(R0), R0 // a162+
54-63+ MOVD syscall15Args_a9(R9), R10
55- MOVD R8, (RSP) // push a9 onto stack64+ MOVD R10, 0(RSP) // push a9 onto stack
56-65+ MOVD syscall15Args_a10(R9), R10
57- BL (R12)66+ MOVD R10, 8(RSP) // push a10 onto stack
58-67+ MOVD syscall15Args_a11(R9), R10
59- MOVD 8(RSP), R2 // pop structure pointer68+ MOVD R10, 16(RSP) // push a11 onto stack
60- ADD $16, RSP69+ MOVD syscall15Args_a12(R9), R10
61- MOVD R0, syscall9Args_r1(R2) // save r170+ MOVD R10, 24(RSP) // push a12 onto stack
62- FMOVD F0, syscall9Args_r2(R2) // save r271+ MOVD syscall15Args_a13(R9), R10
72+ MOVD R10, 32(RSP) // push a13 onto stack
73+ MOVD syscall15Args_a14(R9), R10
74+ MOVD R10, 40(RSP) // push a14 onto stack
75+ MOVD syscall15Args_a15(R9), R10
76+ MOVD R10, 48(RSP) // push a15 onto stack
77+
78+ MOVD syscall15Args_fn(R9), R10 // fn
79+ BL (R10)
80+
81+ MOVD PTR_ADDRESS(RSP), R2 // pop structure pointer
82+ ADD $STACK_SIZE, RSP
83+ MOVD R0, syscall15Args_r1(R2) // save r1
84+ FMOVD F0, syscall15Args_r2(R2) // save r2
63 RET85 RET
M syscall.go +2 -2
@@ -6,7 +6,7 @@
66 package purego
77
88 const (
9- maxArgs = 9
9+ maxArgs = 15
1010 numOfFloats = 8 // arm64 and amd64 both have 8 float registers
1111 )
1212
@@ -36,5 +36,5 @@ func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) {
3636 // add padding so there is no out-of-bounds slicing
3737 var tmp [maxArgs]uintptr
3838 copy(tmp[:], args)
39- return syscall_syscall9X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8])
39+ return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14])
4040 }
@@ -6,7 +6,7 @@
6 package purego6 package purego
7 7
8 const (8 const (
9- maxArgs = 99+ maxArgs = 15
10 numOfFloats = 8 // arm64 and amd64 both have 8 float registers10 numOfFloats = 8 // arm64 and amd64 both have 8 float registers
11 )11 )
12 12
@@ -36,5 +36,5 @@ func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) {
36 // add padding so there is no out-of-bounds slicing36 // add padding so there is no out-of-bounds slicing
37 var tmp [maxArgs]uintptr37 var tmp [maxArgs]uintptr
38 copy(tmp[:], args)38 copy(tmp[:], args)
39- return syscall_syscall9X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8])39+ return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14])
40 }40 }
M syscall_cgo_linux.go +7 -7
@@ -11,18 +11,18 @@ import (
1111 "github.com/ebitengine/purego/internal/cgo"
1212 )
1313
14-var syscall9XABI0 = uintptr(cgo.Syscall9XABI0)
14+var syscall15XABI0 = uintptr(cgo.Syscall15XABI0)
1515
1616 // this is only here to make the assembly files happy :)
17-type syscall9Args struct {
18- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr
19- f1, f2, f3, f4, f5, f6, f7, f8 uintptr
20- r1, r2, err uintptr
17+type syscall15Args struct {
18+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
19+ f1, f2, f3, f4, f5, f6, f7, f8 uintptr
20+ r1, r2, err uintptr
2121 }
2222
2323 //go:nosplit
24-func syscall_syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
25- return cgo.Syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9)
24+func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
25+ return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
2626 }
2727
2828 func NewCallback(_ interface{}) uintptr {
@@ -11,18 +11,18 @@ import (
11 "github.com/ebitengine/purego/internal/cgo"11 "github.com/ebitengine/purego/internal/cgo"
12 )12 )
13 13
14-var syscall9XABI0 = uintptr(cgo.Syscall9XABI0)14+var syscall15XABI0 = uintptr(cgo.Syscall15XABI0)
15 15
16 // this is only here to make the assembly files happy :)16 // this is only here to make the assembly files happy :)
17-type syscall9Args struct {17+type syscall15Args struct {
18- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr18+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
19- f1, f2, f3, f4, f5, f6, f7, f8 uintptr19+ f1, f2, f3, f4, f5, f6, f7, f8 uintptr
20- r1, r2, err uintptr20+ r1, r2, err uintptr
21 }21 }
22 22
23 //go:nosplit23 //go:nosplit
24-func syscall_syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {24+func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
25- return cgo.Syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9)25+ return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
26 }26 }
27 27
28 func NewCallback(_ interface{}) uintptr {28 func NewCallback(_ interface{}) uintptr {
M syscall_sysv.go +9 -9
@@ -12,22 +12,22 @@ import (
1212 "unsafe"
1313 )
1414
15-var syscall9XABI0 uintptr
15+var syscall15XABI0 uintptr
1616
17-type syscall9Args struct {
18- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr
19- f1, f2, f3, f4, f5, f6, f7, f8 uintptr
20- r1, r2, err uintptr
17+type syscall15Args struct {
18+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
19+ f1, f2, f3, f4, f5, f6, f7, f8 uintptr
20+ r1, r2, err uintptr
2121 }
2222
2323 //go:nosplit
24-func syscall_syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
25- args := syscall9Args{
26- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9,
24+func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
25+ args := syscall15Args{
26+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
2727 a1, a2, a3, a4, a5, a6, a7, a8,
2828 r1, r2, err,
2929 }
30- runtime_cgocall(syscall9XABI0, unsafe.Pointer(&args))
30+ runtime_cgocall(syscall15XABI0, unsafe.Pointer(&args))
3131 return args.r1, args.r2, args.err
3232 }
3333
@@ -12,22 +12,22 @@ import (
12 "unsafe"12 "unsafe"
13 )13 )
14 14
15-var syscall9XABI0 uintptr15+var syscall15XABI0 uintptr
16 16
17-type syscall9Args struct {17+type syscall15Args struct {
18- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr18+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
19- f1, f2, f3, f4, f5, f6, f7, f8 uintptr19+ f1, f2, f3, f4, f5, f6, f7, f8 uintptr
20- r1, r2, err uintptr20+ r1, r2, err uintptr
21 }21 }
22 22
23 //go:nosplit23 //go:nosplit
24-func syscall_syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {24+func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
25- args := syscall9Args{25+ args := syscall15Args{
26- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9,26+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
27 a1, a2, a3, a4, a5, a6, a7, a8,27 a1, a2, a3, a4, a5, a6, a7, a8,
28 r1, r2, err,28 r1, r2, err,
29 }29 }
30- runtime_cgocall(syscall9XABI0, unsafe.Pointer(&args))30+ runtime_cgocall(syscall15XABI0, unsafe.Pointer(&args))
31 return args.r1, args.r2, args.err31 return args.r1, args.r2, args.err
32 }32 }
33 33
M syscall_windows.go +7 -7
@@ -10,16 +10,16 @@ import (
1010 "golang.org/x/sys/windows"
1111 )
1212
13-var syscall9XABI0 uintptr
13+var syscall15XABI0 uintptr
1414
15-type syscall9Args struct {
16- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr
17- f1, f2, f3, f4, f5, f6, f7, f8 uintptr
18- r1, r2, err uintptr
15+type syscall15Args struct {
16+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
17+ f1, f2, f3, f4, f5, f6, f7, f8 uintptr
18+ r1, r2, err uintptr
1919 }
2020
21-func syscall_syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
22- r1, r2, errno := syscall.Syscall9(fn, 9, a1, a2, a3, a4, a5, a6, a7, a8, a9)
21+func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
22+ r1, r2, errno := syscall.Syscall15(fn, 15, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
2323 return r1, r2, uintptr(errno)
2424 }
2525
@@ -10,16 +10,16 @@ import (
10 "golang.org/x/sys/windows"10 "golang.org/x/sys/windows"
11 )11 )
12 12
13-var syscall9XABI0 uintptr13+var syscall15XABI0 uintptr
14 14
15-type syscall9Args struct {15+type syscall15Args struct {
16- fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr16+ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
17- f1, f2, f3, f4, f5, f6, f7, f8 uintptr17+ f1, f2, f3, f4, f5, f6, f7, f8 uintptr
18- r1, r2, err uintptr18+ r1, r2, err uintptr
19 }19 }
20 20
21-func syscall_syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {21+func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
22- r1, r2, errno := syscall.Syscall9(fn, 9, a1, a2, a3, a4, a5, a6, a7, a8, a9)22+ r1, r2, errno := syscall.Syscall15(fn, 15, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
23 return r1, r2, uintptr(errno)23 return r1, r2, uintptr(errno)
24 }24 }
25 25

Keyboard shortcuts

Single-key shortcuts are on. ctrl k and esc work whatever this says.

ctrl k :
go to a section, branch, tag, file or repository
?
this list
j k
move the row cursor down / up
enter
open the row under the cursor; on Files, a directory opens or closes in place
↑ ↓ ← → home end
in the file tree (focus on a row): previous / next row, close / open a directory or go to its parent / first entry, first / last row. They never open a file
l h
on Files: open a directory or a file / close a directory or go up to its parent, then to the parent page. Elsewhere: into the side panel (on a merge request, its files) / back to the content; there j k move between its controls
g g G
first / last row
/
filter the list; on Files, find a file anywhere in the repository (esc clears, enter opens the best match)
b
switch branch or tag
g s g f g c g b g m g i g r g a
tabs: summary, files, commits, branches & tags, merge requests, issues, releases, actions (when available)
g h
home
w
wide mode: use the whole width of the screen, or not (remembered)
y
copy a permalink pinned to the commit
d u x
diff: split / unified / collapse or expand all
e E
diff: the whole file in view / every file, with the lines the hunks hide
n
merge request: next note in the diff
esc
close a dialog, leave a field

Branches 1

Tags 102

↑↓ moveenter openesc close