cmd/compile: switch to a register-based calling convention for Go functions

[aclements]

I propose that we switch the Go internal ABI (used between Go functions) from stack-based to register-based argument and result passing for Go ~1.16~ 1.17.

I lay out the details of our proposal and the work required in this document.

The ABI specification can be found here.

This was previously proposed in #18597, where @dr2chase did some excellent prototyping work that our new proposal builds on. With multiple ABI support, we’re now in a much better position to execute on this without breaking compatibility with the existing body of Go assembly code. I’ve opened this new issue to focus on discussion of our new proposal.

/cc @dr2chase @danscales @thanm @cherrymui @mknyszek @prattmic @randall77

An incomplete and evolving list of tasks:

• [X] Define ABI specification (CL, @aclements)
• [X] Add GOEXPERIMENT=regabi and asm macro (CL)
• [x] cmd/compile: late call lowering (CLs)
• [x] cmd/compile: implement register arguments (@dr2chase)
  • [x] spill around morestack call (CL)
  • [x] add temporary ABI pragma for testing (CL)
  • [x] add abstract argument registers (WIP CL)
  • [x] implement ABI rules (CL)
  • [x] use abstract argument registers
• [x] cmd/compile: implement register returns
  • [x] late return lowering (CL, @dr2chase)
  • [x] implement ABI rules (CL, @thanm)
• [x] cmd/compile: ABI wrappers (CL, old CL)
  • [x] cmd/link: mangle wrapper names for ELF (CL)
  • [x] cmd/link: mangle wrapper names for PE (CL)
  • [x] implement zeroing of X15 in ABI0->ABIInternal wrappers (CL)
• [X] cmd/asm: add syntax for runtime packages to reference ABIInternal symbols (CL)
  • [x] Mark runtime.{goexit,asyncPreempt}, reflect.{makeFuncStub,methodValueCall} definitions ABIInternal (CL)
  • [x] Mark reference to runtime.callbackWrap in sys_windows_amd64.s as ABIInternal (CL)
• [x] runtime: fix assembly closure calls (mcall) (@aclements, CL)
• [x] reflect: support calling ABIInternal (CL)
• [x] reflect: support MakeFunc and method value calls (CL)
• [x] go and defer statements
  • [x] cmd/compile: desugar go/defer to zero-argument (@thanm, CL)
  • [x] cmd/compile: fix defer recover() (@cherrymui, CL)
  • [x] cmd/compile: desugar go/defer with results (@cherrymui, CL)
• [X] cmd/cgo: decouple cgo callbacks from ABI (CL)
• [x] runtime: finalizer support (CL)
• [x] runtime: Windows callback support (CL)
• [x] cmd/internal/obj: introduce and use RegEntryTmp registers in prologue (@mknyszek, CL)
• [x] cmd/compile: generate correct ABI0 argument maps for body-less functions (see WriteFuncMap) (@dr2chase, CL)
• [x] cmd/compile: make cgo_unsafe_args generate an ABI0 function (or an ABIInternal-with-no-registers function) (@cherrymui, CL)
• [x] runtime: update debug call protocol (CL)
• [x] Fix ABI0/ABIInternal confusion in cgo (CL)
• [x] Run signature fuzzer and fix bugs (everyone)
• [x] Get all.bash to pass on Linux, Windows, and Darwin (everyone)

High-priority non-critical path

• [x] Export ABI information across package boundaries to eliminate more wrappers (@aclements, CL)
• [x] Make funcPC always return the "native" PC of a function (maybe also introduce ABIOther) (@cherrymui, CL)
• [x] Strip unnecessary ABIInternal annotations once funcPC is in
• [x] Tracebacks
  • [x] Define extended argument metadata format (in progress, @cherrymui)
  • [x] cmd/compile: produce extended argument metadata (@cherrymui, CL)
  • [x] runtime: consume extended argument metadata (@cherrymui, CL)
  • [x] cmd/compile,runtime: traceback metadata for spill slot liveness
• [x] DWARF
  • [x] cmd/compile: ensure arguments have appropriate DWARF locations
  • [x] Ensure GDB and Delve can find register arguments
  • ~[ ] cmd/compile: add a DWARF vendor attribute with function argument frame size (context)~
• [x] Wrapper mangling for non-critical arches
  • [x] cmd/link: mangle wrapper names for Mach-O (CL)
  • [x] cmd/link: mangle wrapper names for xcoff
  • [x] cmd/link: mangle wrapper names for Plan 9
• [x] runtime: simplify go/defer call paths
  • [x] assert that go/defer frames are zero sized (CL)
  • [x] replace defer reflectcall with a direct closure call (CL)
• [x] cmd/internal/obj: reject splittable ABIInternal functions without morestack spill info (e.g., asm functions) because we can't generate a correct morestack path (CL)
• [x] cmd/asm: don't reference args_stackmap in ABIInternal functions (because it's for ABI0) (CL)
• [x] Port performance-critical assembly to ABIInternal (see CL 296372 for valuable functions) (CL 308931, CL 310184)
• [x] math: fix overhead of assembly->Go calls CL 310331
• [x] Release notes
  • Mention undocumented behavior we've observed applications depending on that may have changed.
  • Using reflect.ValueOf(fn).Pointer() to get the PC of an assembly function will now return the PC of the ABI wrapper
  • Performance surprise: calling from assembly to Go is slightly more expensive.
  • Performance surprise: calling an assembly function via a closure is slightly more expensive.
  • Traceback format is much improved

Enabling steps

• [x] Enable regabiwrappers by default on amd64 (Linux, Windows, and Darwin)
• [x] Enable regabidefer
• [x] Enable regabireflect
• [x] Enable regabig
• [x] Enable regabiargs

Testing

• [ ] Function signature fuzzer (ongoing)
  • [ ] Static call, closure call, method call, interface call, reflect.{ValueOf(target),MakeFunc(x, target),Method(x)}.{Call,Interface}, called from defer, called from go, called as a finalizer
  • [x] {Big,Small} {argument,result} in {memory,registers} and {not addressed,addressed and not leaked to heap,addressed and leaked to heap}
  • [x] Use defer in a test function (check arguments, modify results)
  • [x] Pass pointers-to-stack and pointers-to-heap
  • [x] Cause result to move to heap
  • [x] runtime: add MoveStackOnNextCall, assertions for pointer-to-stack/pointer-to-heap, assertions for live/dead (@aclements, CL)
  • [x] Integrate runtime testing hook
  • [ ] Clean up fuzzer, and get into tools repo.
• [x] cmd/compile: revive clobberdead (CL)
• [x] cmd/compile: add clobberdeadreg (CL)

Post-MVP

• [x] Move g from TLS to register (CL)
  • [x] Use g register on non-Linux OSes (see CL)
• [x] Reserve and use X15 as zero register (CL)
  • ~[ ] Should this be X0 for more compact instruction encoding?~
• [ ] Port to other platforms
  • [x] amd64
  • [x] arm64
  • [ ] mips
  • [x] ppc
  • [ ] s390x
  • [x] risc-v
  • ~[ ] porting guide~
• [x] Eliminate legacy ABI paths for all platforms, even if they're using ABIInternal with 0 registers
• [ ] Eliminate spill slots?
• [ ] Pass pointer-shaped method receiver in context register (#44827)
• [x] runtime: simplify go/defer call paths
  • [x] simplify go/defer paths to assume zero args/results
  • [x] simplify special _defer allocator and remove special _defer cases from mallocgc (because _defer records will be fixed size).
• [ ] cmd/vet: add syntax and checks for register arguments and results in assembly like x+0(FP)
• [ ] cmd/vet: check argument size for ABIInternal functions and fix runtime asm declarations

Cleanup (can be done later)

• [ ] runtime: port all assembly -> Go calls to ABIInternal?
• [x] Eliminate ABIAlias support from cmd/compile, cmd/link, and object format
• [x] remove now-redundant fields from ssa.AuxCall
• [x] rationalize use of LocalsOffset/FrameOffset (for registers that use a link register, e.g. arm64, powerppc).
• [ ] cmd/compile: revisit abiutils.go and clean up the API (also reduce ABIConfig copying)
• [ ] cmd/internal/obj: generate stack maps in obj so we can better compact the morestack/body maps and reduce subtlety?
• [x] cmd/compile,runtime: re-enable passing arguments to go in runtime (context)
• [ ] cmd/compile: always attach ir.Func to function ir.Names (context)
• [x] cmd/compile: support ABIInternal for tail calls (context)
• [x] cmd/compile: once wrapping of defers is on for all arch/OS combinations, it should be possible to simplify or remove some of the openDefer processing in ssagen (notablly we could get rid of openDeferSave()
• ~[ ] runtime: think about an ABI-insensitive debugCall~ Delve uses DWARF information
• [ ] Fix up named slots & value association
• [ ] fix firstpos in ssa.go – sometimes it's late.

[gopherbot]

Change https://golang.org/cl/305330 mentions this issue: runtime: add GC testing helpers for regabi signature fuzzer

[gopherbot]

Change https://golang.org/cl/305669 mentions this issue: runtime: use ABIInternal for closure calls from assembly

[gopherbot]

Change https://golang.org/cl/305671 mentions this issue: cmd/compile: emit writebarriers in specified ABI

[aclements]

One example is to interface with the Core Audio APIs. In this specific case, the support for callbacks with floating point argument is needed.

@emarj, are you saying that there's already Go code that calls these, or just giving a theoretical example? Unless I'm completely misunderstanding the Windows calling convention, it has never worked for a Go callback to accept floating-point arguments. As of Go 1.16 NewCallback will actually panic, but before that it would simply do the wrong thing. If it's a theoretical example, it would great if you could open a new issue about adding support for floating-point Windows callback arguments so we can track that separately.

[gopherbot]

Change https://golang.org/cl/305672 mentions this issue: cmd/compile: make expandCalls preserve types of pointer stores

[gopherbot]

Change https://golang.org/cl/305550 mentions this issue: cmd/compile: wrap defer/go call with results

[gopherbot]

Change https://golang.org/cl/304771 mentions this issue: cmd/compile: be sure to wrap defer/go calls with arguments

[gopherbot]

Change https://golang.org/cl/305549 mentions this issue: cmd/compile: check deferred nil interface call before wrapping it

[emarj]

@emarj, are you saying that there's already Go code that calls these, or just giving a theoretical example? Unless I'm completely misunderstanding the Windows calling convention, it has never worked for a Go callback to accept floating-point arguments. As of Go 1.16 NewCallback will actually panic, but before that it would simply do the wrong thing. If it's a theoretical example, it would great if you could open a new issue about adding support for floating-point Windows callback arguments so we can track that separately.

@aclements I'm sorry for the confusion. There are pure Go libraries that implements these Windows APIs, but they are incomplete for this reason (i.e. they cannot implement callbacks). There is no (afaik) actual code that does that, because, as you said, it is not possible at the moment. I discover that myself trying to improve one of those libraries (https://github.com/moutend/go-wca for reference).

I commented here since I saw there is work being done in the "calling conventions area" and maybe this could be addressed. But now I understand it is better to open a new issue, since this is a feature request.

[gopherbot]

Change https://golang.org/cl/305829 mentions this issue: cmd/compile: make amd64 version of zerorange regabi-friendly

[gopherbot]

Change https://golang.org/cl/305849 mentions this issue: dashboard: add windows- and darwin- amd64-regabi builders

[aclements]

@emarj , thanks for opening the issue! You're right that they're related issues. We're in a much better place to support floating-point arguments to callbacks now. Previously NewCallback could sort of pretend that the Windows calling convention and Go calling convention were close enough that it didn't need to do any complicated translation, and adding floating-point to that would have been really hard. With Go switching to a register-based calling convention, it has to really understand both calling conventions and translate between them, so adding floating-point support now is actually much easier.

[gopherbot]

Change https://golang.org/cl/306009 mentions this issue: runtime: check that defer/go frames are empty

[gopherbot]

Change https://golang.org/cl/306010 mentions this issue: runtime: replace reflectcall of defers with direct call

[gopherbot]

Change https://golang.org/cl/306109 mentions this issue: reflect: undo register count increments on register assignment failure

[gopherbot]

Change https://golang.org/cl/306409 mentions this issue: cmd/compile: fix incoming ABI with GOEXPERIMENT=regabiargs

[gopherbot]

Change https://golang.org/cl/306410 mentions this issue: cmd/compile: fix outgoing calls with GOEXPERIMENT=regabiargs

[aclements]

As of tip:

$ cat hello.go
package main

func main() {
    println("hello with registers")
}
$ GOEXPERIMENT=regabi,regabiargs go run hello.go
hello with registers

This means the full register ABI is running well enough to bring up the whole runtime (including the scheduler, GC, starting lots of threads and goroutines, allocating a bunch, etc) and get to main.main.

[gopherbot]

Change https://golang.org/cl/306469 mentions this issue: cmd/compile: fix register/offset calculation for trailing empty field case.

[gopherbot]

Change https://golang.org/cl/306571 mentions this issue: reflect,runtime: assume register ABI with GOEXPERIMENT=regabiargs

[gopherbot]

Change https://golang.org/cl/306869 mentions this issue: cmd/compile: mark unused values as invalid to prevent problems in expandCalls

[gopherbot]

Change https://golang.org/cl/306929 mentions this issue: reflect: remove short-circuits for zero-sized types in ABI algorithm

[gopherbot]

Change https://golang.org/cl/306910 mentions this issue: runtime: make concatstring{2,3,4,5} consistent w/ compiler's use

[gopherbot]

Change https://golang.org/cl/306931 mentions this issue: runtime: make reflectcall ABI0 on amd64

[gopherbot]

Change https://golang.org/cl/307009 mentions this issue: cmd/internal/obj: use REGENTRYTMP* in a few more places

[gopherbot]

Change https://golang.org/cl/304470 mentions this issue: cmd/compile, runtime: add metadata for argument printing in traceback

[gopherbot]

Change https://golang.org/cl/307309 mentions this issue: cmd/compile: add "surprised by IData of Arg" case for register args

[gopherbot]

Change https://golang.org/cl/307229 mentions this issue: cmd/link: mangle function name with ABI on Mach-O

[gopherbot]

Change https://golang.org/cl/307232 mentions this issue: cmd/compile, runtime: use ABI-aware function converting float to interface

[gopherbot]

Change https://golang.org/cl/307231 mentions this issue: cmd/compile: load results into registers on open defer return path

[gopherbot]

Change https://golang.org/cl/307235 mentions this issue: cmd/compile: untangle Wrapper and ABIWrapper flags

[gopherbot]

Change https://golang.org/cl/307234 mentions this issue: cmd/compile: disable tail call for method wrappers when RegabiArgs is enabled

[gopherbot]

Change https://golang.org/cl/307233 mentions this issue: cmd/compile: reference ABIInternal memequal_varlen

[gopherbot]

Change https://golang.org/cl/307390 mentions this issue: runtime: mark abort as ABIInternal on amd64

[gopherbot]

Change https://golang.org/cl/307391 mentions this issue: runtime: use funcID to identify abort in isAbortPC

[gopherbot]

Change https://golang.org/cl/307236 mentions this issue: cmd/compile: enable panic+recover adjustment for some ABI wrappers

[gopherbot]

Change https://golang.org/cl/307237 mentions this issue: reflect: call ABI0 callReflect/callMethod

[gopherbot]

Change https://golang.org/cl/307529 mentions this issue: cmd/compile: check for unused OpArg* and mark invalid (again)

[gopherbot]

Change https://golang.org/cl/307829 mentions this issue: cmd/compile/internal/amd64: follow-on regabi fix for amd64 zerorange

[gopherbot]

Change https://golang.org/cl/307869 mentions this issue: reflect: refactor funcLayout tests

[gopherbot]

Change https://golang.org/cl/307909 mentions this issue: cmd/compile: pre-spill pointers in aggregate-typed register args

[gopherbot]

Change https://golang.org/cl/307872 mentions this issue: runtime: set up read-only dummy TLS space for needm on Windows

[gopherbot]

Change https://golang.org/cl/308189 mentions this issue: reflect: fix typo in result-in-registers case

[gopherbot]

Change https://golang.org/cl/308309 mentions this issue: cmd/compile: sanitize before/after expansion OpSelectN references

[gopherbot]

Change https://golang.org/cl/308510 mentions this issue: cmd/compile: ensure spills of int/float reg args land in abi slots

[gopherbot]

Change https://golang.org/cl/308069 mentions this issue: cmd/compile: fix buglet in walk convert phase relating to convT64

[gopherbot]

Change https://golang.org/cl/308589 mentions this issue: cmd/compile: add recursive-invalidate Value method, use in expand_calls

[gopherbot]

Change https://golang.org/cl/308590 mentions this issue: test/abi: clean up test to fix builders

[gopherbot]

Change https://golang.org/cl/308689 mentions this issue: cmd/compile: fix buglet in walk convert phase relating to convF32/64

[gopherbot]

Change https://golang.org/cl/308889 mentions this issue: test/abi: disable test on windows for now