feat: add fixed-arity Syscall0–Syscall15 variants to avoid heap allocation

[RomainMuller]

Motivation

SyscallN is variadic (args ...uintptr). When called across a module
boundary the compiler must materialise the args as a []uintptr slice at
the call site. Because of //go:uintptrescapes the compiler cannot prove
the slice doesn't escape, so it is heap-allocated even for small, short-lived
call sites (anyhow, since the call is cross-module, the slice always escapes).

This allocation can represent a significant cost (time + GC churn) when calls are frequently made using the low-level API. Having fixed-arity variants helps alleviate this and can result in a 75% overhead reduction (almost entirely from the slice allocation).

What this PR does

Adds Syscall0 through Syscall15 — fixed-arity wrappers with explicit
named uintptr parameters. No slice is created at the call site; the
individual arguments are passed in registers, eliminating the allocation
entirely.

Internally each wrapper follows the same path as SyscallN:

• a zero-initialised [maxArgs]uintptr array for integer args and one for
  float args are allocated on the wrapper's own stack frame,
• the explicit arguments are assigned into those arrays,
• the existing syscall_SyscallN internal is called (no new assembly),
• the Windows path delegates to syscall_syscallN as before.

//go:uintptrescapes is retained on all wrappers for the same GC-pinning
reason it is present on SyscallN.

Testing

Two C helpers are added to testdata/abitest/abi_test.c:

• stack_0_uintptr() — returns the constant 42 (smoke-tests Syscall0)
• stack_15_uintptr(a1..a15) — returns the sum of its 15 arguments

A syscall_fixed sub-test inside TestABI_ArgumentPassing exercises every
arity (0–15), checks the absolute expected value, and verifies parity with
the equivalent SyscallN call.

[qmuntal]

Why don't you remove //go:uintptrescapes from SyscallN instead, and add //go:nosplit + //go:uintptrkeepalive. This is how syscall.SyscallN is implemented on Windows, and it's alloc-free: https://github.com/golang/go/blob/17bd5ab8c650155dd2bd09f7005726552639eea0/src/syscall/dll_windows.go#L98.

[RomainMuller]

it's alloc-free

Is it? I've not found a way to get the compiler to not always heap-escape the variadic slice for a cross-module call?

Specifically, my benchmark always shows 1 alloc that matches the vararg slice size... Only because it's cross-module.

[eliottness]

On our side this is the last allocation we have in the hot path for our FFI calls. Would be awesome to get alloc parity with CGO there

[hajimehoshi]

Is it? I've not found a way to get the compiler to not always heap-escape the variadic slice for a cross-module call?

So didn't //go:nosplit + //go:uintptrkeepalive work?

[TotallyGamerJet]

Why don't you remove //go:uintptrescapes from SyscallN instead, and add //go:nosplit + //go:uintptrkeepalive. This is how syscall.SyscallN is implemented on Windows, and it's alloc-free: https://github.com/golang/go/blob/17bd5ab8c650155dd2bd09f7005726552639eea0/src/syscall/dll_windows.go#L98.

The syscalln that it calls does have the noescape pragma which I think may be the reason?