OS layer, stacks and panics

Part I · 48 threads in 3 era slices, from Go 1.0 to Go 1.28. Each thread gives its design, then a per-release timeline of what landed (Done) and what was still open. Release labels in a timeline link to that release's page.

● = the thread had substantive commits in that cycle; hover for the stage summary, click to jump to it in the release page.

Thread map, Go 1.0 – 1.17

Thread map, Go 1.18 – 1.28

OS interface, stacks and panics (Go 1.0–1.4)

Reader: Claude Sonnet. Cites 962 of 1,120 commits in this slice; every non-noise commit is cited, plus 18 larger commits the noise filter had set aside, which a separate gap reader described. Read the design-heavy messages and subject lines.

Segmented stacks to contiguous (copied) stacks

Span: Go 1.0 → Go 1.4 · Status at go1.17: still the design at go1.17 (stack growth by copying, 2 KB minimum, no segment chain) → continues as Stack growth, stack bounds and the crash stack (1.18+)

Continues in: Goroutine stack growth, shrinking, GC stack barriers and stack objects (Go 1.5 → Go 1.17)

Design. The first scheme, from 2008, is Ken Thompson’s “segmented stacks AND goroutines” (751ce3a77a): every goroutine starts on a small segment, each function prologue compares SP against a per-G stack guard, and a failing check calls morestack, which allocates a new segment, records the old one in a Stktop header (the “stack top” record: old base, old guard, argument pointer, free flag), copies the incoming arguments over, and runs the function there. On return the function lands in lessstack/oldstack, which pops the segment. The linker (6l pass.c) inserted the check; d3204ef19f and 44f65c8f08 taught the traceback to hop across segments, and later 4b376ef328 made it work through an active lessstack. This is the “hot split” design: a loop that straddles a segment boundary pays an alloc/free per iteration, which is why the segment size became a tuning knob.

During Go 1.2 the default segment size was changed from 4 kB to 8 kB (408238e20b) as an explicit stopgap: the message reports GobEncode -64% and Template -17% on amd64, notes that demand paging means the unused second 4 kB is not resident, and says “khr’s new stacks will avoid needing to make this decision at all”. It was briefly reverted to the old value for the dev cycle and then set back to 8 kB (6aee29648f). Go 1.2 also added a hard limit on stack growth, 1 GB on 64-bit and 250 MB on 32-bit (757e0de89f), so runaway recursion dies with a diagnostic instead of eating the machine.

Contiguous stacks arrive in 1.3. The main commit is 1665b006a5 (“grow stack by copying”, 2014-02-26): GOCOPYSTACK=0 disables shrinking (b8d40172ce); 1a89e6388c consolidates all stack-size and segment-origin bookkeeping in stackalloc/stackfree after finding three bugs (g->stacksize accounting wrong across copystack/shrinkstack, stktop->free not maintained, a FixedStack block that came from the heap being freed into the stack cache); 5daffee17f fixes the size check that looked only at the top segment; 84570aa9a1 rounds stack sizes to powers of two; 1f4d2e79b0 adds efence support. Copying needs exact pointer maps: cfb347fc0a fixes the PC used for liveness lookup (the instruction before the return address, matching what the GC does), 14d2ee1d00 adds a “continuation PC” for frames stopped by a fault (pc after the last deferproc CALL, or 0) because liveness is recorded only at CALLs, and fc6753c7cd/3d1c3e1e26 make defers copyable.

Go 1.4 commits to copying and deletes the old scheme. 15b76ad94b (“assume precisestack, copystack, StackCopyAlways, ScanStackByFrames”) removes the fallbacks (348 insertions, 2893 deletions in 48 files): the Stktop chain, M.moreargp/moreargsize/moreframesize/cret, lessstack, oldstack, many amd64 morestack variants, and replaces stackguard/stackbase/stack0/stacksize/syscallstack/syscallguard/forkstackguard in G by simple bounds (lo, hi). The split prologue shortens because frame/arg sizes are no longer passed. 6c934238c9 lowers the minimum stack to 2 KB (8 KB on Windows, 4 KB on plan9), cutting 100,000 goroutines on linux/amd64 from about 819 MB to 245 MB. The mechanics around it: 92eb1e1600 frees the stacks of Gdead goroutines at GC time, 9198ed4bd6 lets the onM frame be copied (so the goroutine that triggers GC can be shrunk), d6d7170de4 fixes a race between stack shrinking (during mark) and stack-cache flushing, e844f53a01 stops scanning frames/args conservatively (crash instead), and 193daab988 forbids conservative data/bss objects in the linker.

Timeline.

• Go 1.0 — Done: segmented stacks and goroutines 751ce3a77a (2008-07); traceback across segments d3204ef19f, 44f65c8f08, 4b376ef328; fix for stack-limit register placement 24838a2df6; 32-bit stack-switching fixes 5273868f67, aa3222d88f; stack overflow debugging add89dd1ba; stack check added on all OSes 5a4a08fab8, 0400a7f8b1; cgo stack guard fix for >8K C stacks fbfed49134; linker stack-split logic near the default segment size 9e5db8c90a; GC race on g->sched.sp/stackbase/stackguard while in syscalls fixed by saving a consistent triple g->gcsp/gcstack/gcguard in entersyscall (370276a3e5). Left open: each split allocates a segment, so hot-split behaviour was not addressed.
• Go 1.1 — Done: nothing structural; 1a4599b41a clears the locked bit when a goroutine exits. Left open: nothing noted.
• Go 1.2 — Done: user-visible 4 kB to 8 kB default segment (408238e20b); stack-size limit 757e0de89f; f0d73fbc7c uses gp->sched.sp for the overflow check; 6fa3c89b77 records proper goroutine state during split (see prologue thread); ebc5513be6 double-checks the calling goroutine in newstack; fd23958f49 fixes memory leaks where defer argp/pc pointed into freed segments. Left open: the commit message of 408238e20b calls 8 kB a stopgap pending new stacks.
• Go 1.3 — Done: user-visible contiguous stacks (copystack/shrinkstack, main commit outside the slice) with fixes 1a89e6388c, 5daffee17f, 84570aa9a1, 1f4d2e79b0, b8d40172ce, 8ca3372d7b (bad g status after copystack), 7c75a862b4 (false retention via m->moreargp/morebuf), cfb347fc0a, 14d2ee1d00, fc6753c7cd, 3d1c3e1e26, 72c5d5e756 (reflect.call must copy back only results because wrapper methods rewrite the receiver slot). Segment size back to 8 kB 6aee29648f. Left open: both mechanisms coexist (stktop chain, non-copying shrink); GOCOPYSTACK=0 escape hatch.
• Go 1.4 — Done: single contiguous stack with (lo, hi) bounds 15b76ad94b; 2 KB minimum 6c934238c9; StackCopyAlways stress mode toggled on/off several times during the conversion (277ef8fa07 off, 318294286a on, 176020e1b1 off after a windows/amd64 failure in copystack, 815a843b6a on, finally assumed by 15b76ad94b); f8f630f5ec uses reflect.call in panics instead of newstackcall; 0f99a91bb5 lets the copier update Panic structs; 47f251c1ce/1b6807bb06 make cgo cope with a moved G stack; 59dd20f4d3 fixes Windows syscalls for copying stacks; Gdead stack freeing 92eb1e1600. Left open: nothing noted beyond later fixes (a shrink/netpoll race was still fixed on the release branch).

Stack-split prologue, nosplit budget and C-on-Go-stack detection

Span: Go 1.0 → Go 1.4 · Status at go1.17: the prologue check and nosplit budget persist (budget size changed); StackPreempt-style guard poisoning persists → continues as Stack growth, stack bounds and the crash stack (1.18+)

Continues in: Goroutine stack growth, shrinking, GC stack barriers and stack objects (Go 1.5 → Go 1.17)

Design. In Go 1.2 6fa3c89b77 changes the prologue so that after call morestack there is an extra jmp start; the jump is never executed by the CPU. runtime.rewindmorestack decodes it to find the function start, and morestack returns directly to the start label. Effects: newstack can save a coherent goroutine state at function entry, so a traceback at a split overflow works with no special cases; the check is repeated, which doubles as a verification that the new stack is big enough; and rewinding makes preemption possible because the goroutine can resume on its original stack and re-run the check. 031c107cad fixes the linker for large-frame split plus preempt check. Runtime assembly marked NOSPLIT must fit a fixed budget that cmd/ld checks statically (failures such as d83688165a, ddc01d5b06 show the call-chain accounting for notetsleep); the budget grows through Go 1.4: fe91006a02 (+32 bytes), 397bdb216f (to 192), b6951bcc0b (split limit again).

In 1.4 the C-to-Go conversion needs to know that no C code runs on a Go stack. c81a0ed3c5 changes the C prologue (liblink/obj5.c, obj6.c, obj8.c) to compare against a different G word, stackguard1: it holds the normal guard on g0 and gsignal, and ^0 on ordinary goroutine stacks, so the check fails and calls morestackc, which aborts with a message about C code on a Go stack. This is dynamic and covers function pointers; it immediately found sigpanic being pushed onto Go stacks from the signal handlers. 32ecf57d22 rejects onM calls from the gsignal stack (onM assumes it runs on curg or g0, and scalararg/ptrarg are not reentrant); d16a2ad09b makes traceback look past onM and fakes an mstart caller on the rented g0 stack; 1d550b87db allows crashing from the gsignal stack; 12308d5a0b fixes the throwsplit check, which ran on g0 where it was never set. For assembly functions that appear mid-stack, 99f7df0598 makes cmd/gc turn a Go prototype into myfunc.args_stackmap (two bitmaps: inputs live at entry; inputs+outputs after GO_RESULTS_INITIALIZED) and adds GO_ARGS, NO_LOCAL_POINTERS in funcdata.h; 653fb6d872 makes GO_ARGS the default for functions beginning with a middle dot.

Timeline.

• Go 1.0 — Done: stack-limit setup bugs 24838a2df6; 1ed7f18165 better calling of morestack; stack check everywhere (5a4a08fab8). Left open: nothing noted.
• Go 1.2 — Done: 6fa3c89b77 rewindmorestack; a83748596c, 9ddfb64365 record argument size in assembly functions and use it for frames; 58f12ffd79, 13507e0697 morestack/lessstack in tracebacks; e84d9e1fb3 no stack splits in syscall status (new notetsleepg, entersyscall/exitsyscall arranged not to call split functions) with the follow-ups d83688165a, ddc01d5b06, 21315c3428; 12e46e42ec call trampolines not NOSPLIT; 9cd570680b/034d5fcc30 reimplement then restore the old reflect.call (the no-split version was dropped for cgo); 5a54696d78, 0273dc131e, e838334beb, ed467db6d8 replace numeric textflags by symbolic NOSPLIT|DUPOK|NOPROF. Left open: nosplit headroom is tight.
• Go 1.3 — Done: relax preemption assertion during stack split 00a757fb74; 8ca3372d7b. Left open: nothing noted.
• Go 1.4 — Done: fe91006a02 and 397bdb216f enlarge the nosplit area, c81a0ed3c5 C-on-Go-stack detection, 32ecf57d22, d16a2ad09b, 12308d5a0b, 99f7df0598, 653fb6d872, 40dd6bf38e; 9198ed4bd6. Left open: the dynamic check only catches code that executes.

Goroutine preemption (stackguard0, 10 ms and GC preemption)

Span: Go 1.2 → Go 1.2 · Status at go1.17: replaced by asynchronous (signal-based) preemption in a later release; the cooperative stack-check mechanism remains as a fallback → continues as Signals and async-preemption machinery (1.18+)

Continues in: Asynchronous preemption: signal plumbing, injected calls and per-arch support (Go 1.14 → Go 1.16)

Design. Go 1.2 is the first release with a preemptive scheduler, built from the stack check. f5becf4233 adds stackguard0 to G: it is what the prologue compares against; the real bound stays in stackguard. Setting stackguard0 = StackPreempt makes the next function call enter morestack, and newstack recognizes the sentinel as a preemption request instead of a growth request. 354ec51666 adds the preemption function (unused at first), d67e7e3acf adds lr, ctxt, ret to Gobuf so a goroutine can be rescheduled mid-prologue, 1e112cd59f makes stoptheworld issue preemption requests every 100 us (“the last patch for preemptive scheduler”), and bc31bcccd3 preempts any goroutine that runs longer than 10 ms (sysmon-driven). ef12bbfc9d disables preemption during deferreturn, fd23958f49 fixes defer leaks, f70a19f085/4eb17ecd1f fix goroutine status corruption when entersyscall’s lock call splits the stack.

Timeline.

• Go 1.2 — Done: user-visible preemption of tight loops that call functions: f5becf4233, 354ec51666, d67e7e3acf, 1e112cd59f, bc31bcccd3, ef12bbfc9d, 4eb17ecd1f. Left open: loops with no function calls are not preempted (the mechanism needs a prologue check).
• Go 1.3 — Done: 00a757fb74 relaxes an assertion that fired when preemption and stack split coincided. Left open: nothing noted.

Panic, defer, recover and Goexit

Span: Go 1.0 → Go 1.4 · Status at go1.17: replaced by open-coded defers and the new panic loop in later releases (1.14, then 1.22) → continues as Defer, panic and recover re-implementation (1.18+)

Continues in: Defer, panic, recover and Goexit (runtime side) (Go 1.5 → Go 1.17)

Design. In the C runtime, panic.c keeps two stacks per G: g->defer (Defer records, LIFO) and g->panic (Panic records). gopanic runs deferred calls from g->defer; recover is legal only when called directly by the deferred function, and gorecover verifies this through an argp comparison against the Panic. 0de71619ce (Go 1.1) aggregates defer allocations (Defer records allocated in batches and kept on a free list), removing the per-defer allocation and about 30% of the time in BenchmarkDefer (165 to 113 ns, allocs 1 to 0); 72e83483a7 shows cgo calls allocating Defer on the stack.

Two correctness issues dominate the history. First, wrapper methods: for defer iface.M() the compiler-generated wrapper adds a second frame, so recover() returned nil. 7276c02b41 (1.2) adds g->panicwrap, which wrappers bump on entry and decrement on exit, and propagates the Stktop.panic flag forward on stack split. 8473695797 (1.4) throws this out as “fatally flawed” and replaces it with Panic.argp, adjusted on wrapper entry only, so unwinding need not undo anything. Second, copying stacks: f95beae61d makes the GC and copystack both use traceback over the Defer chain, keeps the executing Defer on the list until its arguments are copied (fixing two races and a dangling-pointer bug in copystack), and removes dabort and the untyped allocation; the new tests were TestDeferPtrsPanic, TestDeferPtrsGoexit, TestPanicUseStack.

Go 1.4 converts it all to Go: f44073785a (deferproc/deferreturn), 8217b4a203 (panic and recover, first as panic1.go so the diff was readable, merged in 3a3d47db37), 7006aafdcd preallocates index/slice panic errors, 523aa93288 moves panicindex/panicslice. Semantics fixes: dd740343e0 stack-allocates the Panic struct in 1.3 so panicking does not malloc; f946a7ca09 fixes heap corruption and Defer leaks in recursive panics; 15274e5c9b documents that Goexit cannot be recovered; 0306478fe5 skips already-started defers when Goexit and panic interact; e6708ee9b1/94bdf13497 clear Defer fields before unlinking; 36207a91d3 (with 060a988011 on Windows) makes defer of a nil func panic at the defer statement, and 5032a7dc0c (1.0) gives a distinct message for calling a nil func value.

Timeline.

• Go 1.0 — Done: panic output and tracebacks for all goroutines (3835e01d97); array slice error includes bounds (9b8a6dc7da); runtime errors become real runtime.Error values (63e878a750, “type assertion a runtime.Error, the first of many”); divide by zero and nil dereference become panics via signals (5963dbac08); deferred calls run at Goexit (83727ccf7c); startpanic so only one thread handles an incoming SIGQUIT (55a54691f9); no breakpoint on terminal panic (59ce067da8); distinct panic message for calling a nil func value (5032a7dc0c); signal information printed during panic (12307008e9); range+panic line number fixes (12a5774cde). Left open: nothing noted.
• Go 1.1 — Done: defer pooling 0de71619ce; a22389ec38 prints “fatal error” instead of “throw”; f84d5dd475 panics possible before malloc is ready; c74f3c4576 panic/recover in the Plan 9 note handler; 7de3d71797 saves LR on panic for ARM leaf-function tracebacks; 5146a93e72 GOTRACEBACK=crash. Left open: nothing noted.
• Go 1.2 — Done: 7276c02b41 panicwrap; ef12bbfc9d; fa4984d535 shows the runtime.panic frame in tracebacks. Left open: panicwrap accounting wrong (replaced in 1.4).
• Go 1.3 — Done: user-visible e56c6e7535 debug.SetPanicOnFault; dd740343e0; f946a7ca09; 6c9f198c9a, c8c18614af print a stack trace for “panic during panic” without recursing; 1569628725 hardens when a runtime fault is turned into a panic (not during malloc, crash handling); 4110271501 treats a fault during the runtime like an unexpected fault address; c792bde9ef no ... formal argument to deferreturn. Left open: nothing noted.
• Go 1.4 — Done: full conversion to Go (f44073785a, 8217b4a203, 3a3d47db37, 523aa93288, 7006aafdcd, f8f630f5ec); 8473695797; f95beae61d; 15274e5c9b; 0306478fe5; 36207a91d3, 060a988011; c4efaac15d fixes unrecovered panic on an external (cgo) thread; 7bcbdbd904 fixes the size passed to malloc for Panic. Left open: recover still depends on argp arithmetic.

Tracebacks, crash output and GOTRACEBACK

Span: Go 1.0 → Go 1.4 · Status at go1.17: gentraceback is the single stack walker (becomes the unwinder iterator in 1.21) → continues as Unwinder: gentraceback → unwinder iterator, inline unwinder, pcvalue cache (1.18+)

Continues in: Tracebacks, symbol tables and runtime.Callers/CallersFrames (Go 1.5 → Go 1.17)

Design. Tracebacks start as a hand-written frame walk in rt2_amd64.c (aeb43984ec, 2008). a5433369aa uses the pc/ln table to print file:line per frame; d040d26863 and 2b39165f1e set and fix the format (all frames; previously stopped one frame early); ec913c42b3 backs PCs up to the call line. 3835e01d97 prints all goroutines, 324cc3d040 (2011) records the creation PC and prints “goroutine created by”. 48bd13911d (2012) uses GOTRACEBACK=2 to include runtime frames without recompiling; 5146a93e72 (1.1) adds GOTRACEBACK=crash (traceback including runtime frames, then crash for a core dump), with Windows and Plan 9 handlers adapted; 0097d30c97 (1.3) unblocks signals before a core dump.

Subsequent work makes the walker robust: c3e54f0988 and 63f38d62ac handle calls through nil function pointers, 7081e67565 non-standard ARM call sequences, f58ba18a08 nascent goroutines and closures; 13507e0697, 58f12ffd79 morestack/lessstack; 326ae8d14e traceback in cgo programs; 89c5d17878, 92b4741728 gdb breakpoints in x86 traceback; cc84176108 prints the g0 stack when throwing on it with GOTRACEBACK>=2; 2fb87ddb59 prints the goroutine header on faults; fa4984d535 shows runtime.panic.

The 1.4 round is about PC semantics. a22c11b995 adds a trap flag to gentraceback: previously “never subtract 1 from the initial PC” was right only for signals; now traceback defaults to “starting with a return PC” and tracebacktrap is used from the signal handlers. a5a0733144 makes the top-most return PC goexit+PCQuantum (goexit implemented in assembly so the first instruction can be skipped) so that PC-1 is never in a different function, which removed the last special case for runtime.Callers consumers. 3de7ba1873 makes PC/SP fields uintptr; 7ba41e9972 moves traceback helpers to traceback.go; f95beae61d and e844f53a01 rely on traceback for defers and conservative-scan removal.

Timeline.

• Go 1.0 — Done: 2008: first traceback aeb43984ec, segmented-stack traceback d3204ef19f, source lines a5433369aa, format d040d26863/2b39165f1e, all goroutines 3835e01d97, stop when PC leaves text bad8c3d5dd, PC fixes ec913c42b3. 2009: call-instruction accounting dbecfbf86d, 63810f840f; correct pc in fn+%#x 4962e7ee9b; 386 32-bit hex a65bf95dd8. 2010–2012: ARM traceback 6c196015e0, 7081e67565; argument dump 7eb13b95a3; crash trace on amd64 befecf6b59; creation PC 324cc3d040; traceback through active lessstack 4b376ef328; omit breakpoint on terminal panic 59ce067da8; GOTRACEBACK=2 48bd13911d; runtime.Callers 2b7d147f1a. Left open: nothing noted.
• Go 1.1 — Done: GOTRACEBACK=crash 5146a93e72; ARM LR 7de3d71797. Left open: nothing noted.
• Go 1.2 — Done: fa4984d535, cc84176108, 13507e0697, 58f12ffd79, 326ae8d14e, 16d6b6c771 (PCDATA reader exported), 32b770b2c0 (jump to badmcall so traceback reports the caller of mcall). Left open: nothing noted.
• Go 1.3 — Done: 0097d30c97, 89c5d17878, 92b4741728, 2fb87ddb59, 6c9f198c9a, 14d2ee1d00. Left open: nothing noted.
• Go 1.4 — Done: a22c11b995, a5a0733144, 3de7ba1873, 7ba41e9972, d16a2ad09b, 597f87c997 (no trace past jmpdefer on ARM), 6fb9d50d15 more detail on adjustframe crash, b3d5a695a6 diagnostics for non-copyable frames. Left open: nothing noted.

Symbol tables, pclntab and runtime.Caller/FuncForPC

Span: Go 1.0 → Go 1.4 · Status at go1.17: pclntab is still the design (format changed in 1.2 and 1.16/1.18) → continues as Symbol tables, runtime.Caller and CallersFrames (1.18+)

Continues in: Tracebacks, symbol tables and runtime.Callers/CallersFrames (Go 1.5 → Go 1.17)

Design. From 2008 the linker emits a pc/line table and a symbol table read directly by the runtime (symtab.c, a5433369aa). Early fixes deal with whole-package compilation producing symbol-table “history stacks” (84852fe220), the first function’s line (a343e5ceb1), and call-by-return functions (63810f840f). 610757b155 (2012) deletes a duplicate pcln walker; 091191336a, cf37254b1c fix crashes in Caller.

In Go 1.1, c8dcaeb25d re-encodes the table “without changing semantics”: symbol addresses become full-pointer-size host-endian words (so the host linker, gcc, can fill them and pick addresses above 4 GB) and other values (frame sizes) become varints; for godoc on OS X/amd64 the table shrinks 8% (1,546,276 to 1,425,668 bytes). 46d7d5fcf5 hides the symbol table from the GC; 83445fdcc3 (1.2) uses persistentalloc for the symtab to reduce heap. In Go 1.4 symbol handling moves to Go: 0be59730fd adds symtab.go (FuncForPC, Func.FileLine etc.), 97f8386af7 converts symtab.c, 3d128dbf96 removes holes in FUNCDATA tables, 3e62d2184a fixes an endianness assumption decoding ftab. a5a0733144/a22c11b995 define when callers subtract 1 from PCs.

Timeline.

• Go 1.0 — Done: pc/ln table printing a5433369aa; history-stack decoding 84852fe220; runtime.Callers 2b7d147f1a, runtime.FuncLine fix 4e64555894; ARM symbol-table size and leaf function handling 6c196015e0; runtime· prefix on all runtime symbols to avoid collisions with C libraries 68b4255a96 (symbols left alone: cgo names, linker-known names such as pclntab, epclntab, symtab, esymtab, text, etext). Left open: nothing noted.
• Go 1.1 — Done: new encoding c8dcaeb25d; hidden from GC 46d7d5fcf5. Left open: “required step” for host-linker (external link) work.
• Go 1.2 — Done: persistentalloc 83445fdcc3; PCDATA reader exported 16d6b6c771; ed467db6d8. Left open: nothing noted.
• Go 1.4 — Done: Go symtab 0be59730fd, 97f8386af7; FUNCDATA holes 3d128dbf96; ftab endianness 3e62d2184a; Left open: nothing noted.

Signals: handling, os/signal, foreign threads

Span: Go 1.0 → Go 1.4 · Status at go1.17: still the design (handlers installed with sigaction, sigqueue for os/signal) → continues as Signals and async-preemption machinery (1.18+)

Continues in: Signals: masks, forwarding, sigaltstack and the unified Unix signal layer (Go 1.5 → Go 1.17)

Design. Signals appear in 2008 as a fault-reporting mechanism (aeb43984ec, 7b210c5b2f, 3311e1b673 dump registers) and become a panic mechanism in 2010: 5963dbac08 turns divide-by-zero and nil dereference into runtime panics via a sigpanic the handler pushes on the faulting goroutine’s stack; the g at signal time is passed to the handler (690291a2c0); a67258f380 fixes proper signal handling (no init on g0) and 4aaf948f90 masks signals during the handler on OS X. b5866494ea (2009-12) adds os/signal; 08579c26dd makes the runtime crash on most signals unless os/signal is imported; 807605d0fc catches all signals only if os/signal is in use; 35586f718c (2012-02) adds selective handling; cb4428e555 (1.1) adds Stop and care with SIGHUP; 3d8ebefbbe permits default behaviour of SIGTSTP/TTIN/TTOU; b9e051e82d ignores SIGSETXID (33) on GNU/Linux; d9fc789df2 makes SIGSYS notifiable on FreeBSD. The signal queue becomes lock-free in Go 1.1 (91484c6c48 fixes a sigqueue crash) and is converted to Go in 1.4 (651d0cf204, redone as 81ed684a71).

Signal masking is a recurring bug source: 240b1d5b44, 224f05ba88 (2012-02) mask signals around thread creation, 1fc9a17c7e/9eeb90945e do the same in runtime/cgo, b0891060ae (FreeBSD “double fault” if a signal lands before minit installs the handler), 098b9dcf2f (openbsd), 4eb7ba743d (darwin: sigprocmask is process-wide, so two concurrent thread starts could block all signals forever, including SIGSEGV for nil derefs), 41183d015d replaces sigprocmask by pthread_sigmask in cgo, 699dbb60b7 always sets the signal mask before pthread_create.

Mixed-language programs (cgo, SWIG, C++ threads) forced handling for threads without an M: 532dee3842 (1.1) discards SIGPROF on non-Go threads through runtime.badsignal(int32); b23691148f and e49f945603 print an error for other signals; 2f1ead7095 (1.2) “correctly handle signals received on foreign threads” by queueing them to sigqueue instead of crashing, deleting about 160 lines of per-OS code; f322c78692 fixes a crash in badsignal caused by a split prologue; ae73b90369 makes ARM call badsignal. e56c6e7535 (1.3) adds debug.SetPanicOnFault so a program can recover from memory faults (mmap’d files, address probing), hardened by 1569628725.

Timeline.

• Go 1.0 — Done: 2008: signal handling and registers aeb43984ec, 206daeabda, 3311e1b673; SIGSEGV/SIGTRAP details 6e8dbc2051, ab9f27b227, a67258f380. 2009: SIGPIPE ignored 2cf5c809d0; os/signal b5866494ea; crash by default 08579c26dd; sigaction layouts for 386 and linux f529224039, fd5fa4b301. 2010: snow-leopard kernel bug workaround (2f0cae46d8: OS X forces gs=0x37, so threads without USER_CTHREAD segment fault on IRET into the handler; fixed by using thread_fast_set_cthread_self); 807605d0fc; 386 handler bug 53a529ab2b; 68b0a87966. 2011: print signal info 12307008e9; signal stack bug 820dc9ff1a; 8698bb6c8c turns “too many EPIPE” into a real SIGPIPE; 5690ddc7fa no panic on SIGILL. 2012: 35586f718c, 55a54691f9, 1707a9977f (fix FP control word on all threads), 240b1d5b44, 224f05ba88. Left open: signals on foreign threads not handled (diagnostics only: b23691148f, 9b73238daa).
• Go 1.1 — Done: cb4428e555, 532dee3842, e49f945603, b9e051e82d, ecb2a0a9e5, d3d89ae7d2 (check rt_sigaction results), 91484c6c48, 4eb7ba743d, fb7f217fe7, f322c78692; Plan 9 signal handling in Go ccdca2cd6b and note-handler panics c74f3c4576; NetBSD signal ABI v2 79473d6b1c. Left open: foreign-thread signals other than SIGPROF.
• Go 1.2 — Done: 2f1ead7095, ae73b90369, e555172592 (NetBSD/ARM sigreturn). Left open: nothing noted.
• Go 1.3 — Done: user-visible e56c6e7535; 0097d30c97, 41183d015d, 699dbb60b7, d9fc789df2; c4770b991b co-exists with NPTL pthread_cancel; 053127b12f nacl signals. Left open: nothing noted.
• Go 1.4 — Done: sigqueue in Go 651d0cf204, 81ed684a71; 201cfe4afb runs the Windows sighandler on g0; c548cc2ec8 fixes Windows handlers; de14137b4f drops SA_RESTORER on ARM; d7b678b2ca Solaris sigtramp register restore. Left open: nothing noted.

Threads, locks and the OS scheduler interface

Span: Go 1.0 → Go 1.4 · Status at go1.17: still the design (futex/sema based lock_futex.go, lock_sema.go) → continues as Syscall layer: AllThreadsSyscall, internal/runtime/syscall, libc and Windows SyscallN (1.18+)

Continues in: Thread lifecycle, physical page size and scheduler-facing OS hooks (Go 1.5 → Go 1.16)

Design. Early threading was per-OS: clone+futex on Linux (770b872752), Mach bsdthread_create on darwin, semaphores. 5ff12f871f (2008) uses kernel semaphores only under real contention; 0365b989a4 allocates Mach semaphores lazily. efc86a74e4 makes $GOMAXPROCS mean number of CPUs running Go code rather than number of threads.

In 2011 Dmitriy Vyukov reworked the locks: 4e5086b993 (Linux) is a hybrid spin-then-block mutex designed because runtime critical sections are tiny and pure blocking mutexes cause context switches; ee24bfc058 unifies mutexes across OSes into two generic implementations, lock_futex and lock_sema, with each OS supplying a few callbacks (futex wait/wake, semacreate/semasleep), eliminating channel finalizers (d770aadee5 removed them first for Linux/FreeBSD/Plan 9; chan creation fell from 1132 to 381 ns). On Darwin the old lock made BenchmarkChanContended-2 take 6735 ns versus 263 ns afterwards. openbsd locking 060ffabd18; ae9b661fa8 uses private umtx ops on FreeBSD; 9fe8681df6 UMTX_OP_WAIT_UINT; 8ba5c5593f works around a Linux futex kernel bug.

Thread-start protocol: d1bafffa4b lets goroutines run during init and 6808da0163 then locks the main goroutine to the main OS thread during init (programs wanting this for main.main call LockOSThread). In Go 1.1 e6a3e22c75 starts all threads with runtime.mstart, a0955a2aa2 splits minit into mpreinit (on parent, may allocate) and minit (child, cannot), and 1e063eea38 prepares M’s without an mcache for the new scheduler. Other OS-facing work: 4f308edc86 uses sched_getaffinity for NumCPU; 0629354bd3 handles out-of-threads on Linux; a574822f80 disables Windows dynamic priority boosting; OpenBSD thread work (8aa2591b13, and 689d5b9163 using __tfork).

Timeline.

• Go 1.0 — Done: 2008: Darwin threads 376898ca8b, GOMAXPROCS semantics efc86a74e4, semaphore use 5ff12f871f. 2009: clone/futex 770b872752, CLONE_PTRACE removed 89f8238a99. 2011: Linux mutex 4e5086b993; chan finalizer removal d770aadee5; unify ee24bfc058; parallel GC enabling osyield/usleep on all OSes (d324f2143b, 40c26fff14, 723f73caec, d573ad2671); goroutines during init d1bafffa4b and main-thread lock 6808da0163; runtime.ncpu on OpenBSD/FreeBSD (b2f1eba324, 12bf00054e). 2012: cputicks 8e765da941. Left open: runtime used 1:1 M:N without per-P state (scheduler redesign is in another area).
• Go 1.1 — Done: e6a3e22c75, a0955a2aa2, 4f308edc86, 86d509b463, 1a4599b41a, c5f694a5c9 (fix new scheduler on freebsd, windows). Left open: nothing noted.
• Go 1.2 — Done: a574822f80 (Windows priority boost); 45cff65502 switch to OS stack in Windows osyield/usleep; dfdd1ba028 no GC on g0; 6401e0f83f no finalizers on g0; 34c67eb24e lazy extra M. Left open: nothing noted.
• Go 1.3 — Done: ae9b661fa8; c4770b991b; 86c976ffd0 monotonic timers (clock thread). Left open: nothing noted.
• Go 1.4 — Done: 3a7f6646cf lock.c converted to Go; the Lock to Mutex rename (fee7c69c6c); df75f082d3 makes usleep/osyield callable from a cgo callback; 88d53ddb17 releases Windows thread handle in unminit; 9f012e1002 calls rfork on the scheduler stack on Plan 9; b143feb143 int64 reconstruction in semasleep. Left open:* nothing noted.

cgo runtime support and non-Go threads

Span: Go 1.0 → Go 1.4 · Status at go1.17: still the design in outline (cgocall/asmcgocall, cgocallback, extra M) → continues as C-to-Go callbacks: extra-M reuse, system-stack bounds, init gating (1.18+)

Continues in: cgo runtime support: pointer checks, callbacks, extra Ms, C-to-Go call path (Go 1.5 → Go 1.17)

Design. cgo begins in 2009 (fdc4b4a47f FFI start, 12fc217336 checkpoint, 133a158bd8 “cgo working on darwin+linux amd64+386”, with 8c/8l dynamic loading and a libcgo). In 2010 b07b04d35f takes over as runtime/cgo, replacing libcgo (98b2d7062e), adds export (2d0ff3f1a6, 2e20386fc7) and SWIG callbacks (17d50d8664). The central design, from f9ca3b5d5b (2011-03): scheduler/cgo reorganization introduces runtime.mcall(f), which runs f on the m->g0 stack and replaces the scheduler loop (gosave/gogo), eliminating fake states (Grecovery, Gstackalloc); the Go->C path is cgocall -> asmcgocall, the C->Go path is cgocallback -> cgocallbackg running on the m->curg stack accounted against $GOMAXPROCS (between exitsyscall and entersyscall). The old scheme broke because gogo back into the scheduler loop used a lowered g0->sched.sp that no longer pointed at a valid frame. 72e83483a7 speeds a cgo call from 669 to 330 ns by allocating the Defer on the stack.

Go 1.1 makes C threads first-class: 86d509b463 and 6c976393ae (“allow cgo callbacks on non-Go threads”, 448 additions across 16 files) let a thread created by C call into Go by borrowing an M (needm/dropm), with signal stack handled via signalstack(p==nil); 3d2dfc5a7b adds cgocallback_gofunc taking a Go func value; e9a3087e29 tracks memory allocated by non-Go code so a poorly timed GC cannot collect it. 1.2 refines: 34c67eb24e creates the extra M lazily, on first cgo call, so deadlock detection works for programs that import net or C but don’t use them (and under the race detector); 397ba2cb4a/647eaed93b wrap C.malloc. 1.4 rewrites stubs: 54138e1ac3 generates cgo wrappers in Go, cb767247ca refactors asmcgocall, 47f251c1ce and 1b6807bb06 handle G stack copies during cgo (return value location), c81a0ed3c5 replaces C callbacks, e1364a6d0e fixes cgo_topofstack, 685204747d fixes _cgo_allocate(0), c4efaac15d unrecovered panic on an external thread.

Timeline.

• Go 1.0 — Done: 2009: FFI start fdc4b4a47f; cgo 133a158bd8. 2010: runtime/cgo b07b04d35f, 7eeebf49be; export 2d0ff3f1a6, 2e20386fc7; initcgo on all amd64 a4f8d36ba5. 2011: SWIG 17d50d8664; reorganization f9ca3b5d5b; pthread_create error check a026d0fc76; os.Setenv updates C env 623e7de187; fast cgo 72e83483a7; cgo build without cgo c02423902d; g0 stack guard fix for >8K fbfed49134. 2012: signal masking in runtime/cgo 1fc9a17c7e, 9eeb90945e; diagnostics for callbacks on non-Go threads 9b73238daa. Left open: C threads cannot call Go.
• Go 1.1 — Done: 86d509b463, 6c976393ae, 3d2dfc5a7b, e9a3087e29, e49f945603; cgo on Linux/ARM 5cffce611a, on NetBSD 5131deeeb2, 2fdd60b9b6, on OpenBSD 708db79011; 4eb7ba743d; 6a70f9d073 passes setmg to cgo_init; 9de38d6788 exports symbols in both link modes; d17506e52d makes crosscall2 assembly. Left open: nothing noted.
• Go 1.2 — Done: user-visible 34c67eb24e; dba623b1c7, f011282578 cgocallback_gofunc work; 2560f8fe22, cb30917387 NOSPLIT callbacks; cgo on dragonfly 2b44b36487; 397ba2cb4a. Left open: nothing noted.
• Go 1.3 — Done: 28792f5d83 no cgocall in forkAndExecInChild helpers; 1bb4f37fce cgo re-enabled on FreeBSD; 1249d3a518. Left open: nothing noted.
• Go 1.4 — Done: 54138e1ac3, cb767247ca, 47f251c1ce, 1b6807bb06, 1aa65fe8d4, b4bfa6c964 (save g to TLS more aggressively: callback thread with TLS holding g0 instead of curg faulted into sigpanic with wrong g). Left open: nothing noted.

TLS, g/m registers and shared-library linking

Span: Go 1.0 → Go 1.4 · Status at go1.17: still the design in outline (g in TLS or a reserved register) → continues as Library entry points and runtime initialization (1.18+)

Continues in: Shared-library and buildmode entry points (c-archive, c-shared, plugin, shared) (Go 1.5 → Go 1.17)

Design. From the start g and m were “extern register” slots (TLS on x86, R9/R10 on ARM). 386 first used %fs, then bbcb91a3a7 (2009) moved to %gs as required for NaCl and standard for TLS. On Linux/386 2d6ae385e1 uses an Xen-friendly ELF TLS sequence; on Darwin 386, 2f0cae46d8 replaced i386_set_ldt by thread_fast_set_cthread_self; Windows used ArbitraryUserPointer (9569c67a6b). 1564b984a5 removes a duplicate GS setup. In Go 1.1 36b414f639 and dfc22e29ec change the amd64/386 startup convention so _rt0_$GOARCH_$GOOS sets DI=argc, SI=argv and jumps to _rt0_amd64, matching the C main signature, so Go can be linked against a libc main.

Shared libraries: 45233734e2 (1.2, Elias Naur) merges runtime.g and runtime.m TLS pseudo-symbols into runtime.tlsgm, moves TLS code from gcc-compiled to internally-compiled code using MRC on ARM with 5l fallbacks, adds -linkmode external to 5l, and implements -shared (6l emits a shared library): TLS uses the initial-exec model (faster than local dynamic, available because Linux reserves static TLS space), .init_array registers the Go runtime with cgo at load time, and cgo functions get “hidden” visibility to avoid GOT calls. e0db7fae87 adds .note.GNU-stack. Android (1.4): a36348008c adds GOOS=android (linux treated as android for file matching), and 12b990ba7d “TLS emulation for android”: since Linux’s linker TLS relocation and Darwin’s fixed pthread key slot both fail late in an Android process, the runtime calls pthread_key_create, takes the first slot, and stores it in runtime.tlsg, a normal variable. 89f185fe8a removes the m register entirely (code uses g->m), freeing ARM R9, required because NaCl ARM cannot use R9; benchmarks showed no change (Go 1 macrobenchmarks within noise). b4bfa6c964, 4769f87e0d, d8fd8d89ea (1.2: use m and g names instead of R9/R10 in ARM assembly), 0b36211cfb.

Timeline.

• Go 1.0 — Done: bbcb91a3a7 %gs; 2d6ae385e1; 9569c67a6b Windows TLS slot; 7e77623120/e42788628a^1.1 Plan 9 TLS (G and M relative to _tos, later PID from TLS in 1.1); 1b14bdbf1c nacl (ldt0setup sets GS itself). Left open: no shared libraries.
• Go 1.1 — Done: 36b414f639, dfc22e29ec startup convention; 6a70f9d073; b42ebb6fbf NetBSD TLS. Left open: nothing noted.
• Go 1.2 — Done: user-visible 45233734e2 external linking on ARM and -shared; d8fd8d89ea; 3ec0427a07, 254dc5fdbe ARMv5T target; e0db7fae87^1.1 was 1.1. Left open: “this CL only addresses the low level linker work”.
• Go 1.3 — Done: d2fe44d568 loads runtime.goarm as byte. Left open: nothing noted.
• Go 1.4 — Done: a36348008c, 12b990ba7d, c1c8c3c8c4 export _rt0 for android, 72faffbc70; 89f185fe8a removes extern register m; 4769f87e0d; 0b36211cfb. Left open: nothing noted.

Clocks, vDSO and timers

Span: Go 1.0 → Go 1.4 · Status at go1.17: vDSO clock_gettime still used on Linux → continues as vDSO, vgetrandom and fast clocks (1.18+)

Continues in: vDSO, time sources and process-wide randomness (Go 1.5 → Go 1.17)

Design. Time source work, mostly for time.Now and runtime.nanotime. c19b373c8a (2011) adds CPU profiling timers via setitimer (8dee872963). 3b860269ee adds runtime timers for package time. Go 1.1 brings fast paths: 3a66bc415e/c7be4defe3 read OS X time from the comm page, cutting BenchmarkNow from 197 to 33 ns (amd64) and 364 to 38 ns (386), arguing it also makes CPU profiles more accurate because OS X delivers profiling signals on exit from system calls; 024a92c1da and 4022fc4e21 call the Linux vDSO (gettimeofday, then clock_gettime, giving true nanosecond resolution, 27.4 to 24.4 ns), with 2637777527 duplicating nanotime to avoid vDSO stack overflow on a small stack; 7777bac6e4 uses clock_gettime for Linux 386/arm, FreeBSD, NetBSD, OpenBSD. Go 1.3 introduces monotonic clocks for timers (86c976ffd0 linux 386/amd64, 7206f50f71 arm, 36013e4a22 FreeBSD, 3734663805 OpenBSD, b4dc91e386 dragonfly); 350a8fcde1 restores Unix time for MemStats.LastGC after that change. Go 1.4: 74b62b4864 monotonic on Windows, 13d0b82bc8 time.now in assembly on plan9/solaris/windows, 1db4c8dc41 fixes vDSO lookup to use the dynamic hash table, 2fe9482343 revives fake time for nacl, with 138b5ccd12 disabling it in some cases.

Timeline.

• Go 1.0 — Done: c19b373c8a, 8dee872963, 3b860269ee, f437331f80, efe3d35fc5, 8e765da941 (cputicks seeds fastrand against hash-table complexity attacks; RDTSC on amd64, constant 0 on ARM). Left open: the commit says “update 8a to recognize RDTSC”.
• Go 1.1 — Done: c7be4defe3, 3a66bc415e, 024a92c1da, 4022fc4e21, 2637777527, 7777bac6e4. Left open: nothing noted.
• Go 1.3 — Done: 86c976ffd0, 7206f50f71, 36013e4a22, 3734663805, b4dc91e386, 350a8fcde1. Left open: nothing noted.
• Go 1.4 — Done: 74b62b4864, 13d0b82bc8, 1db4c8dc41, 2fe9482343, 138b5ccd12, b60d5e12e9 warns that cputicks may not be monotonic. Left open: nothing noted.

Windows runtime port

Span: Go 1.0 → Go 1.4 · Status at go1.17: still VEH-based exception handling → continues as Windows runtime port (1.18+)

Continues in: Windows runtime (Go 1.5 → Go 1.17)

Design. Windows 386 (6bfe5f55f4, Hector Chu, 2010-01: 600 lines) is a Windows-DLL based port using syscall stubs; e00795859b adds mingw-style syscall to call DLLs; scheduler runs on the OS stack during syscalls (c1e20720f7, f95a2f2b97). Exceptions: aae5f91213 (2011-01) implements SEH; f0b8f84d37 adds callbacks (syscall.NewCallback); 1723fbe13e a console ctrl handler for SIGINT; f83609f642 adds windows/amd64 (2011-06) with Win64 stack alignment fixes (a6e60916c1, fbdec642a9) and 9b011500c0, acfb0a1584, e753512e2d for exception handling, the ctrl handler and cgo callbacks. In Go 1.3 Russ Cox found that SEH cannot work with Go’s stack usage: records must live on the OS stack, are interpreted by position, and need active maintenance at cgo switches (1249d3a518 fixes a dangling-SEH bug after Go->C->Go panics). 3750904a7e and a837347dd9 replace SEH by vectored exception handling (VEH), “like a Unix signal handler”, dropping 7 #ifdefs; side effect: windows/386 requires Windows XP or later (Windows 2000 dropped). 2dc7552f57, a1778ec146 ignore exceptions from non-Go code / foreign threads, 17a108ba07/e9ecd4aec5 handle all exceptions.

Windows also gets runtime-integrated networking: ea15104110 (a hint to the scheduler when GetQueuedCompletionStatus will block, for BenchmarkTCP4Persistent 4004000 to 33906 ns), 6ea7bf253c moves netpoll into the runtime, 65834685d3 uses GetQueuedCompletionStatusEx if present, and 277a7b22f1 tolerates its absence. Callback and syscall plumbing: 4216203bcf removes then 7f8a5057dd restores NewCallbackCDecl; 05a5de30f0 stops generating code at runtime in NewCallback; 1.4 38ce599494 converts NewCallback to Go, 2eccf0d18f converts syscall_windows.c to Go, 73f5010dc6 allows calling stdcall from Go, 201cfe4afb runs the sighandler on g0; a574822f80 disables dynamic priority boosting (2+ s timer starvation on a uniprocessor server).

Timeline.

• Go 1.0 — Done: 6bfe5f55f4, e00795859b, aae5f91213, f0b8f84d37, f83609f642, 9b011500c0, 9569c67a6b (TLS via ArbitraryUserPointer), 9fd26872cb pprof on Windows, b873701dbd callbacks not GC’d, 428062da4e. Left open: cgo on Windows via ld flags only.
• Go 1.1 — Done: afe0e97aa6 handles exceptions even in cgo programs; 6ec551887a callbacks match new func value representation; 8aafb44b0b. Left open: nothing noted.
• Go 1.2 — Done: user-visible a574822f80; 6ea7bf253c, 65834685d3; 05a5de30f0; 4216203bcf. Left open: nothing noted.
• Go 1.3 — Done: user-visible VEH 3750904a7e, a837347dd9, 1249d3a518, eca55f5ac0 (fix the Windows CPU profiler), 277a7b22f1, 2dc7552f57. Left open: nothing noted.
• Go 1.4 — Done: 74b62b4864, a1778ec146, 17a108ba07, e9ecd4aec5, 38ce599494, 2eccf0d18f, 73f5010dc6, 59dd20f4d3, 201cfe4afb, 2c780a35b9, f8474fa01d, 2ed209eaf5. Left open: nothing noted.

Platform ports: OS and architecture matrix

Span: Go 1.0 → Go 1.4 · Status at go1.17: these ports persist except plan9/solaris variants carried through later work; nacl removed later → continues as New, ported and removed platforms (1.18+)

Continues in: New and ported OS/arch targets, 1.5–1.17 (Go 1.5 → Go 1.17)

Design. The runtime is split into architecture-dependent and OS-dependent files since 2008-06 (aeb43984ec “factor into architecture-dependent and -independent pieces. ditto OS”), reorganized into amd64/, darwin/, linux/ subtrees in 2009-03 (fcd76f7dc9, 878822f355, 8ee041dc24) with godefs-generated defs.h (08cfcd1dd6, 209865be7c), later flat os_*.c, sys_*.s, defs_*.h naming (e9d62a6d81, “refactor os-specific code”, 1.1), and dd2abe5152 (2011-11) converts runtime/syscall defs from godefs to cgo. Go 1.0 inherits: Linux/darwin amd64 (2008–2009), 386 (2009-03), ARM (2009-05 onward: 7943556970, be639b9a51, kernel cas 9ad9742157, softfloat 7c2b1597c6 precise float64, Android hardware 52c549fc9b), FreeBSD (0489a260da, b3f538a4fd), nacl (2009-09; removed 2010-12 by 0c54225b51 and restored in 1.3), Windows (above), Plan 9 (99a10eff16), tiny/embedded experiments (da9bc7ae7d, removed 434f1e32a0), OpenBSD (21ac258e07 amd64, 9ef17990c2 386), NetBSD (26089cfe25, 728c16cf13).

Go 1.1 adds NetBSD working (5a043de746, fb32d60cd1, ARM 37aba1aa77), FreeBSD/ARM (366268aa79), Plan 9 64-bit (a72bebf6e1), cgo on NetBSD/OpenBSD/FreeBSD-ARM. Go 1.2 adds dragonfly amd64 (ac00524beb), 386 (465ba6b78c), FreeBSD/ARM EABI (649a2a9be5) and the FreeBSD/amd64 INT 0x80 workaround (555da73c56: the SYSCALL fast path is broken for restarting syscalls, with a C reproducer; filed as PR 182161). Go 1.3 adds Solaris (a46b434931, 50df136483) and Native Client (4a000b9d51, “nacl import round 2”: amd64p32 and x86-32 runtime/syscall support, networking, bootstrap, per the go13nacl design), plus openbsd ABI break (471763f657). Go 1.4 adds Android (a36348008c), Plan 9/amd64 (decd810945, 70f928698b), NaCl/ARM (d1177ed40d), Solaris cleanup (b4c28d9180, e77c2fe313), and GOARM fixes (66795e8ba1).

Timeline.

• Go 1.0 — Done: 2008–2009: arch/OS split aeb43984ec, fcd76f7dc9, 878822f355; 386 0d3a043de9, 4702c0e5ef; ARM start 7943556970, be639b9a51; nacl 1b14bdbf1c; FreeBSD 0489a260da, b3f538a4fd, 5a4a08fab8. 2010: Windows 6bfe5f55f4; Plan 9 99a10eff16, 8221eb9103; ARM softfloat 7c2b1597c6; nacl removal 0c54225b51. 2011: OpenBSD 21ac258e07, 9ef17990c2, 1075af0cce, 8aa2591b13; windows/amd64 f83609f642; NetBSD 26089cfe25, 728c16cf13; godefs->cgo dd2abe5152. 2012: ARM OABI error bb40196ebf. Left open: nothing noted.
• Go 1.1 — Done: NetBSD 5a043de746, fb32d60cd1, 37aba1aa77, 2fdd60b9b6, 79473d6b1c; FreeBSD/ARM 366268aa79, c2d2bfcc49, 092b7cfb08; Plan 9/amd64 a72bebf6e1, e42788628a; ARM hw float requirement 212ce41d00; Linux/ARM cgo 5cffce611a; e9d62a6d81. Left open: nothing noted.
• Go 1.2 — Done: user-visible dragonfly ac00524beb, 465ba6b78c, 2b44b36487; 6252b41981 removes OABI check; 649a2a9be5; 555da73c56; ff86d222be fixes syscall numbers on freebsd/openbsd 386. Left open: “still some breakages” on freebsd/arm.
• Go 1.3 — Done: user-visible Solaris a46b434931, 50df136483; NaCl 4a000b9d51, 0c6e4b9660, 9ab4d1d6b3, 6431be3fe4, 053127b12f, f2037e1533, 6436df0d81, 4bc632cead, 0c2a727477; 471763f657. Left open: nothing noted.
• Go 1.4 — Done: user-visible Android a36348008c, 12b990ba7d, c1c8c3c8c4; NaCl/ARM d1177ed40d; Plan 9/amd64 decd810945; a84e3ad198 (nsec syscall on Plan 9). Left open: nothing noted.

Integrated network poller: OS back-ends

Span: Go 1.1 → Go 1.4 · Status at go1.17: still the design (epoll, kqueue, IOCP, solaris ports) → continues as Syscall layer: AllThreadsSyscall, internal/runtime/syscall, libc and Windows SyscallN (1.18+)

Design. The OS-facing half of the netpoll that Dmitriy Vyukov added with the new scheduler: netpoll.goc (common) plus netpoll_epoll.c, netpoll_kqueue.c, netpoll_windows.c, netpoll_stub.c. 0bee99ab3b (Darwin) and 49e0300854 (Linux) land together in 2013-03: BenchmarkTCP4Persistent falls 93% on linux/amd64 (115647 to 7782 ns) and 51% on darwin; at high thread counts OneShot got 30% worse (16/32 threads). ARM follows (1d64d04da5, -38% to -43% OneShot), then FreeBSD/OpenBSD (c5732c8526), NetBSD (c4cdd35e6e), FreeBSD/ARM (e82614e5be), Windows (6ea7bf253c, 7-9% faster, 65834685d3 batch dequeue). In 1.4 91a670d179 converts common code, epoll and kqueue to Go (Windows and Solaris stayed C);

Timeline.

• Go 1.1 — Done: user-visible integrated pollers Darwin 0bee99ab3b, Linux 49e0300854, ARM 1d64d04da5, Windows hint ea15104110. Left open: BSDs and Windows use the old external pollster; slower at 16–32 threads.
• Go 1.2 — Done: c5732c8526, c4cdd35e6e, e82614e5be, 6ea7bf253c, 65834685d3. Left open: nothing noted.
• Go 1.3 — Done: 277a7b22f1. Left open: nothing noted.
• Go 1.4 — Done: 91a670d179. Left open: Windows and Solaris code remained C.

Runtime C-to-Go conversion and the Go calling convention in C (1.4)

Span: Go 1.4 → Go 1.4 · Status at go1.17: completed; no C left in the runtime → continues as Library entry points and runtime initialization (1.18+)

Continues in: C-to-Go conversion of the runtime’s OS, arch and signal layers ([dev.cc]) (Go 1.5 → Go 1.5)

Design. In 1.4 the runtime starts being rewritten in Go. The enabling step is 25f6b02ab0 (2014-08-27): the C compilers adopt the Go calling convention (results on the stack after arguments, except ... functions), making it possible to rewrite C functions one at a time “without worrying about which languages call that function”. All runtime assembly was updated from 40(SP) to name+10(FP) references with Go prototypes for every assembly function, so go vet runtime checks them; vet found many wrong MOVL/MOVQ widths in the openbsd and other less-used ports. 012ceed914 makes onM and mcall take Go func values; 4aa50434e1 adds gomallocgc; d4df63c3e8 converts type algorithms (alg.print and alg.copy deleted); 3a7f6646cf locks; 50199d7b35 env; 47d6af2f68 chanrecv; 39ffa8be78 Stack; b4c28d9180 syscall_solaris; 91a670d179 netpoll; 7ba41e9972 traceback bits; 9a75c74836, f611ae1c75 generate Go struct definitions from C headers; 0a7c7ac80e makes g->atomicstatus atomic with a Gscan bit to support the concurrent GC. Supporting conventions: cb040d59b9/e8fc362049 use textflag.h, 99f7df0598, 193daab988.

Timeline.

• Go 1.3 — Done: 85cae877f5 and 7400be87d8 (1.0) had already added generated Go definitions for C structs. Left open: nothing noted.
• Go 1.4 — Done: 25f6b02ab0, 012ceed914, 4aa50434e1, d4df63c3e8, 3a7f6646cf, 50199d7b35, 47d6af2f68, 39ffa8be78, 38ce599494, b4c28d9180, 0a7c7ac80e, 9a75c74836, f611ae1c75, d2574e2adb, ddce7c35f4; c007ce824d moves package sources from src/pkg to src. Left open: Windows/Solaris netpoll still C; onM bridge between Go and C.

Startup, auxv, randomness and security-adjacent runtime details

Span: Go 1.0 → Go 1.4 · Status at go1.17: still present → continues as Security hardening: AT_SECURE, std fds, AT_RANDOM, gated debug features (1.20+)

Continues in: CPU feature detection (internal/cpu), auxv parsing and GODEBUG=cpu.* (Go 1.9 → Go 1.17)

Design. a642ca4930 (1.1) decodes the ELF auxiliary vector on Linux/ARM (AT_RANDOM, AT_HWCAP, AT_PLATFORM) to seed the map hash with a per-process random number (only AT_RANDOM used), d1e06dab7c removes an alignment assumption; 8e765da941 seeds fastrand; a5d4024139 and db53d97ac4, ee66972dce in the hash function (AES hash) are perf details. 5146a93e72 GOTRACEBACK. 44fd1d1a6a gives clear messages for DYLD_INSERT_LIBRARIES on Darwin.

Timeline.

• Go 1.0 — Done: 8e765da941, 3f7a32405d warns on SELinux mmap failures, 65b036c381 avoids doubling memory on grsec kernels, 102274a30e sizes arena to fit address-space limit. Left open: nothing noted.
• Go 1.1 — Done: a642ca4930, d1e06dab7c, 44fd1d1a6a, a5d4024139. Left open: HWCAP/PLATFORM unused (“future CLs will make use of the others”).

Changes in this slice that are not part of a thread are listed on the release pages: 1.0 · 1.1 · 1.2 · 1.3 · 1.4

OS interface, stacks and panics (Go 1.5–1.17)

Reader: Claude Sonnet. Cites 1,427 of 1,750 commits in this slice; every non-noise commit is cited, plus 15 larger commits the noise filter had set aside, which a separate gap reader described. Read the design-heavy messages and subject lines. The “Other notable changes” section was generated from the subjects of leftover commits, so its items are lists rather than explanations.

C-to-Go conversion of the runtime’s OS, arch and signal layers ([dev.cc])

Span: Go 1.5 → Go 1.5 · Status at go1.17: done in 1.5; the all-Go layout (os_$GOOS.go, signal_$GOOS_$GOARCH.go, sys_$GOOS_$GOARCH.s, defs_*.go, one sigctxt per OS/arch) is still the structure at go1.17.

Earlier history: Runtime C-to-Go conversion and the Go calling convention in C (1.4) (Go 1.4 → Go 1.4)

Design. The [dev.cc] branch removed all C from package runtime, so the Plan 9 C compiler (cmd/cc) was no longer needed to build it. Russ Cox’s bulk conversions were done with an automated tool “and then modified only as necessary to make it compile and run”: panic and stack code (panic.c, stack.c to Go, d98553a727), runtime/cgo (9f99d531a0), operating-system support code (e785e3acf8), arch-specific .c/.h (9204821731), defs_$GOOS_$GOARCH.h to defs_*.go (580ef3e4af), and assembly adapted to the Go-built go_asm.h (15ced2d008). The signal handlers overused macros and could not be converted automatically; a sigctxt type was defined per OS/arch with a common implicit interface used by the arch-independent handler (2d917c0c26). cmd/dist stopped generating special headers, compiles Go sources before the rest of the package so the compiler can write go_asm.h, and TLS information moved into src/runtime/go_tls.h (0d49f7b5fc).

Each OS port was then converted on its own: FreeBSD (aac17fd4e1), Solaris (e088e16256; memory management consolidated with the BSDs, assembly thunks replaced by the new //go:linkname; the first step built but did not run because binaries no longer linked libc), openbsd/amd64 and 386 (ba603c3100, 9ad6b7e322), dragonfly (1d05d5880e, 6ddc2cb80c), netbsd (cfc8099a9a, 0d76887433, 7d516079de), Windows (b27c0618eb, ab4578adef), NaCl (ad8179281d), Plan 9 (e9c57d8a2d), Android/ARM (d3526ea0f6). GOOS/GOARCH-specific constant files are now produced with go generate (0fe444d3e8). Residual C-isms were then deleted: strcmp-style helpers (7b36227002), unneeded C headers (57cefa657d), thunk_windows.s (20dce04742), cgocall/asmcgocall (2858b73843), cgo_allocate (6a2b0c0b6d), gogetcallerpc/gogetcallersp (7abdc90fe3), and the stackguard1 field that had distinguished C code on Go stacks (ab0535ae3f).

Timeline.

• Go 1.5 — Done: everything above, plus the ppc64 sigctxt/asm conversions (312a64ec4e, 54d731452d, 3f27c3ae37, 0da27cb8b0, 70f6769b60, f4627d1b05, d11a425959), a siginfo si_addr field (f4a525452e) and a generated Windows callback list (dcb2ec3b65, 3f19541752). Fixes needed for the converted code: nil-pointer crash handler on Solaris (9d6825edee), freebsd __progname export (37cae806cb), missed “M stack” references (0e8fed098c), Windows goenvs (0a38b2cdaf, a88d709268). Left open: Solaris was “just a rough translation of the original C code, cleanup will come in a different CL” (e088e16256).

New and ported OS/arch targets, 1.5–1.17

Span: Go 1.5 → Go 1.17 · Status at go1.17: linux/{ppc64,ppc64le,arm64,mips,mipsle,mips64,mips64le,s390x,riscv64}, android/{386,arm,arm64,amd64}, js/wasm, aix/ppc64, darwin/arm64 (iOS) and ios, illumos, freebsd/arm64, netbsd/arm64, openbsd/{arm,arm64,mips64}, plan9/arm exist; nacl, darwin/arm, darwin/386, dragonfly/386 removed; windows/arm64 landing → continues as New, ported and removed platforms (1.18+).

Earlier history: Platform ports: OS and architecture matrix (Go 1.0 → Go 1.4)

Design. A port adds rt0_*.s, asm_$GOARCH.s, sys_$GOOS_$GOARCH.s, defs_*, a sigctxt in signal_$GOOS_$GOARCH.go, and an os_$GOOS.go with osinit/newosproc/minit. From 1.6 per-arch constants live in runtime/internal/sys and atomics in runtime/internal/atomic (67faca7d9c, 432cb66f16, d3498c5abd, 80d0b98d80). Each new port repeats the same checklist: link-register frame rules, memory barriers in cas, cputicks, startup randomness from auxv AT_RANDOM, vDSO time, signal frames, cgo (crosscall2, _cgo_sys_thread_create), TLS, addmoduledata for shared builds, and later async-preemption injection.

Timeline.

• Go 1.5 — Done: [dev.power64] bring-up for linux/power64 and power64le: manual and portable parts, generated headers, switchtoM/onM, morestack, newstackcall, reflect.call, time.now, 64k pages on power64le (5f691cfaf1, 2abf3c5583, 91447ab502, ab29d5b4ae, c229cec23a, 268d901199, ebf42035b7, b7a6fd28db, 5f02073ded, f9fdc887ae, fd21b9f8b5, 062e354c84, 1b130a08d8, 8881e032d4, b6d6eb21ec, 6e73ae88b5, b3375771fc, ecbe6b9f7f, 249e8f700a, e445f75dbc, a08783f078, cb4f5e1970, 87b4149b22, b55791e200, 097362fd2e, c24156bafe, 6e86003651, 40a5b3ecb1), then renamed ppc64 (09d92b6bbf) and given cgo (af7ca8dce4, f1c4444dfc). linux/arm64 (846ee0465b, syscall error checks 3a56aa0d3e, 64k page rounding 7a63ab1a65, cgo d0b62d8bfa, 0accc80fbb); darwin/arm (56e8f8e822, cgo a5bff443c7, EXC_BAD_ACCESS handler 1b49a86ece, later turned off by default 4044adedf7) and darwin/arm64 (4a71b91d29, 828de09f8b, 989f0ee80a, 9cde36be54, c-archive entry e8b7133e9b); openbsd/arm (be3133bfda); android/arm shared-library init (d1eee2cebf, ede863c673); Solaris cgo (121489cbfd) and direct libc linking in place of dlopen/dlsym once lazy binding existed (fe5ef5c9d7); FreeBSD uses the SYSCALL instruction (e9ce76b0ec); the dragonfly/386 port is removed (3b1d692093). Left open: the darwin/arm cgo EXC_BAD_ACCESS handler was disabled by default pending a fix (4044adedf7).
• Go 1.6 — Done: linux/mips64 and mips64le files (a36dda7880, 980b00f55b, e0053f8b1c, 846a9adf05, b2b8559987), android/amd64 syscalls and TLS (30ee5919bd, dfc8649854), android/arm64 (ce8f49f42f, 4480d6a927, c091d4cd25, d26a0952a8, c-shared 73ff7cb1ed), android/386 (34db31d5f5, 05c4c6e2f4, b2259dcef0, 90e26f52c6), runtime/internal/sys machinery (432cb66f16, c3ba74931f, d3498c5abd), a 64 kB system stack on arm (21f35b33c2), and larger frames/stack limits on ppc64 (c83c806535, c1b6e392f5, b8f8969fbd, a4855812e2). Left open: mips64 cgo and runtime tail landed in 1.7.
• Go 1.7 — Done: linux/s390x (cc17d1ba76, 0f08dd2183, e6f36f0cd5, 7cbe7b1e86, 78ecd61f62, d8e8fc292a, 0324a3f828), linux/mips64x cgo (b6687c8933, 5d002dbc21, 6e90432342, 2e32efc44a), plan9/arm signal handling and files (d145456b16, 0de0cafb9f), set_thread_area instead of modify_ldt on linux/386 (0f86d1edfb), int 0x80 for linux/386 syscalls (1439158120). Left open: nothing noted.
• Go 1.8 — Done: linux/mips and mipsle (fa77001648, b241a06479, 272032d0b2, b909d01152, 3444e5b355, 526b2f85ce, 155d314e50), s390x vector facility and HWCAP (d38d59ffb5, f1515a01fd, f1ad4863aa, 62dafbb4c6), ppc64x HWCAP (40aaf28312), plugin support in the runtime (0cbb12f0bb, b4c9829c22, f4c7a12c2c, 54ec7b072e, b531eb3062, 81a61a96c9). Left open: nothing noted.
• Go 1.11 — Done: js/wasm (80e69220c8, 35ea62468b): no threads, hence no preemption and no sysmon at first; RISC-V names reserved (9446eaa944); freebsd c-shared (88129f0cb2).
• Go 1.12 — Done: windows/arm (d24ec86e4f, QPC time e3b4b7baad, 84066f1b0b, traceback/profile fixes 9ab2ffe8e9, 6764d7aeac, 1ca84deeb0), AIX (bf8e6b7027, 9f78aa7744, ff99a61e5e, 8f9902da26, 49be65eeba, 18b84cbd42, 3855fe7254, 976bab6003), openbsd/arm cgo (c52beb1087, 47a71d9d77, f95578cd5f), initial cgo for ppc64 (1135071b47), FreeBSD 12 ino64 syscall types (dc6eb200dd).
• Go 1.13 — Done: aix/ppc64 completion (c1e2227505, 8bad008cf5, 53d859bdf5, 0cd74d1f11, bf103723f8, b5cf035d1c, 38dc177d3a, 3aacfce6cf, 4e2b4d7fb2, cbaa8e5f93, 8c7564dead, d5014ec05b, b2453c0588), netbsd/arm64 (d23cba683e, 37133b5d63), openbsd/arm64 (3d94dd78d4, 17a7f21790, 08b956f378, 998cc2a1c5), illumos split from solaris (f686a2890b), dynamic Android TLS offset (1d10b17589, 95f18757a0, f18c31a49c, eddb41eb2c).
• Go 1.14 — Done: freebsd/arm64 (6b6e67f9b9, cgo 33e3983db8, 5e35845a4a, 316fb95f4f, 4b1b18d106), linux/riscv64 (8e0be05ec7, 82a2f825b7), NaCl removed (a38a917aee, 03ef105dae).
• Go 1.15 — Done: darwin/arm and darwin/386 removed (da8591b61c, f7e6ab44b4, 8b4cbcc320, d5e1b7ca68); cgo for riscv64 follows in 1.16.
• Go 1.16 — Done: GOOS=ios (a413908dd0, 869c02ce1f, entry points 0040adfd0f, f1e3c8f142, 3923460dda), darwin/arm64 without cgo (72dec90bfd, a0a44397e9, 7c8d82e92b, 28e549dec3, 7f688d18c0), cgo on linux/riscv64 (393f2bb067), openbsd/mips64 (4d6dfd64c1, 55f8d56c31, 9c91cab0da), netbsd/arm64 fixes (8ab020adb2, 1f4d035178, 567ef8bd8e), darwin/arm remnants removed (d277a36123).
• Go 1.17 — Done: windows/arm64 (3527caa7d6, 427bd7599d, c7c6c113be, 16330817aa, a25d1d45d9, 78afca22c9), cgo for openbsd/mips64 (f68878f0fc), GOARCH=loong64 reserved (2b00a54baf). Left open: windows/arm64 is “intended to land in the Go 1.17 cycle” as a stack of CLs (3527caa7d6).

Goroutine stack growth, shrinking, GC stack barriers and stack objects

Span: Go 1.5 → Go 1.17 · Status at go1.17: still the design at go1.17: contiguous stacks copied by copystack, shrunk during concurrent mark, stack barriers gone, stack objects used for address-taken locals → continues as Stack growth, stack bounds and the crash stack (1.18+).

Earlier history: Segmented stacks to contiguous (copied) stacks (Go 1.0 → Go 1.4) · Stack-split prologue, nosplit budget and C-on-Go-stack detection (Go 1.0 → Go 1.4)

Design. After the 1.3 contiguous-stack switch, 1.5 added GC stack barriers to avoid re-scanning whole stacks at mark termination: during the first scan, at exponentially spaced points, return PCs are overwritten with a stub (stackBarrier) that records how far the stack has unwound and jumps to the saved PC; the second scan only goes as deep as the lowest barrier that has not been hit (faa7a7e8ae). A 50 MB-heap deep recursion that cost ~150 ms to rescan fell to 10–20 ms mark termination (goscheme from 100–500 ms). The barriers reserved part of every stack (firstStackBarrierOffset), which interacted with shrinking (7387121ddb accounts for the guard when halving) and with cgo (e2bb03f175 forbids a barrier in cgocallback_gofunc’s frame because that slot holds sched.pc). In 1.7, shrinkstack was made safe against concurrent channel operations by locking all channels the G is blocked on and CAS-ing pointers in send/receive slots (276b177771), and shrinking moved from STW mark termination (~5 ms/MB copied + 2 µs/shrink) to the concurrent mark phase (f11e4eb5cc, da153354b2). aed861038f (1.7) adds a stack free list, and 0cbf8d13a7 (1.6) reuses large stack spans (a program that grew to 1 GB stayed at ~30 MB).

Stack barriers became unnecessary once the hybrid write barrier meant stacks are not rescanned, and were removed in 1.9 (d089a6c718, ~1100 lines). Stack-copy cost work: pcvalue cache (see tracebacks), faster readvarint/stackmapdata (aafd96408f), iterating only set bits in adjustpointers (5af0b28a73, 2e7e57770c, 31cfa7f2f2), no write barrier in adjustpointers (a5c3bbe0b4) or in newstack/gogo (shading g.sched.ctxt at scan instead, 3beaf26e4f), and rewindmorestack removed because per-PC SP deltas let the prologue’s re-jump be recorded as frame size 0 (4c9a372946). Go 1.12’s “stack objects” (cbafcc55e8) record every address-taken local in a FUNCDATA and compute liveness at scan time by marking from pointers found in the frame and defer records, replacing “ambiguously live” conservativeness. 1.17 changes growth sizing (b1760f3a27 from 1.15 grows more than 2x when the frame is large; 287c5e8066 fixes the growth loop so copystack is not called redundantly).

Timeline.

• Go 1.5 — Done: stack barriers (faa7a7e8ae), no write barrier in adjustpointers (a5c3bbe0b4), shrinkstack honours the stack guard (7387121ddb), avoid double-scanning of stacks (724f8298a8), no barrier in cgocallback_gofunc, Goexit calls goexit1 to avoid “leftover stack barriers” (ad731887a7), stack debug fixes (0c22a74e85), 2-bit heap bitmap which also shifted stack-map formats (0234dfd493), profiling on g0 (db6f88a84b). Left open: barriers cost 2–3% on non-recursive programs (faa7a7e8ae).
• Go 1.6 — Done: merged stack1.go/stack2.go (db2e73faeb), barrier sync checks (77e528293b, bb6fb929d6, ecf388f3a4, e2bb03f175), recycling large stack spans (0cbf8d13a7), pcvalue cache for stack scan (beedb1ec33: Issue10898 16.5 s to 9.2 s), 64 kB system stack on arm (21f35b33c2).
• Go 1.7 — Done: concurrent-safe shrinkstack (276b177771), shrink during concurrent mark (f11e4eb5cc), copy before adjusting (da153354b2), stack free-list (aed861038f), stackfree on the system stack (6a86dbe75f), duplicate channels in shrinkstack selects (84bb9e62f0), transient _Gwaiting states fixed in newstack (3c2a21ff13), poisonStack checks dropped (9e8fa1e99c), stack guard shrunk in [dev.ssa] (d3f15ff6bc).
• Go 1.8 — Done: stackmaps no longer padded to 4 bytes (303b69feb7), rewindmorestack removed (4c9a372946), clearer morestack (bf9c71cb43, 687d9d5d78), bad stack pointer message (3df926d52a), barrier slice nil with 0 barriers (3193c71c5b). Left open: barriers still present, removed in 1.9.
• Go 1.9 — Done: stack barriers removed (d089a6c718), faster stack copy (aafd96408f), allocManual/freeManual generalization of stack span allocation (407c56ae9f, 9741f0275c), stackFromSystem and stackCache=0 fixes (8a1c5b2e48, 475425201a), 2 MB stacks on 64-bit Windows (c2c07c7989).
• Go 1.10 — Done: never allocate during an unrecoverable panic (2edc4d4634), throwsplit traces and no stack growth in sigpanic when throwsplit (4671da0414, 44213336f0, 9483a0bc23), write barriers removed in newstack/gogo (3beaf26e4f), 1 MB stacks on 32-bit Windows (77ea9f9f31).
• Go 1.11 — Done: faster/inlinable stack copy (605c9feeb1, 5af0b28a73, 31cfa7f2f2, 2e7e57770c), entry stack map (0fd427fda7), g0 stack overflow handled gracefully on Windows (78561c4ae9), g0 stack bounds on Windows (52e782a2d6, 99e9be8043, d6b56bb301), goid in split-stack throw (183fd6f19b).
• Go 1.12 — Done: stack objects (cbafcc55e8), reduced pcvalue linear search with a 2x8 associative cache (7d6b5e340c).
• Go 1.13 — Done: stack freeing separated from shrinking (68d89bb8e0), m.libcallsp check now panics, one lock per stackpool order.
• Go 1.14 — Done: prints SP and old bounds on stack overflow (0f25102858), stack-growth during VDSO/signal fixes (758eb020f7).
• Go 1.15 — Done: grow more than 2x if the new frame is large (b1760f3a27).
• Go 1.17 — Done: stack growth loop fix (287c5e8066); 49add6ad90 fixes spurious stack overflow detection, fbed561f8a resets an accidentally set stack poison flag, 97b3ce430b stops gcTestMoveStackOnNextCall from doubling. Left open: nothing noted.

Tracebacks, symbol tables and runtime.Callers/CallersFrames

Span: Go 1.5 → Go 1.17 · Status at go1.17: gentraceback is still the single stack walker, now inline-aware, TOPFRAME/SPWRITE-driven → continues as Unwinder: gentraceback → unwinder iterator, inline unwinder, pcvalue cache (1.18+) and Symbol tables, runtime.Caller and CallersFrames (1.18+).

Earlier history: Tracebacks, crash output and GOTRACEBACK (Go 1.0 → Go 1.4) · Symbol tables, pclntab and runtime.Caller/FuncForPC (Go 1.0 → Go 1.4)

Design. gentraceback walks frames using the _func table, a per-PC SP-delta pcvalue stream and PCDATA/FUNCDATA (stack maps, args maps). Cost is dominated by pcvalue decoding; since big stacks usually repeat a few recursive functions, 1.6 puts a small randomly-replaced cache in front of the lookup, threaded from stack scan, adjust and traceback (beedb1ec33); 1.12 refines it to [2][8] entries with a cheap associative index, inserting new entries at the front for recursive stacks (7d6b5e340c).

In 1.9 the compiler’s inlining tables are consumed: tracebacks show inlined frames (781fd3998e), runtime.Callers counts logical rather than physical frames by encoding a partial skip in a pseudo-PC skipPleaseUseCallersFrames+n stored in pcs[1] (ee97216a17), CallersFrames expands inlined calls (7bf0adc6ad, iteratively 7f32d41e5d, non-escaping variant 38521004ed), and FuncForPC behaviour with inlining is documented (d58125ecd2, 58ae050055, a776087ee3). 1.10 hides <autogenerated> wrapper methods (e97209515a). 1.13 makes Frames.Next delay file/line lookup (c77a9e0aa5), and re-orders PCDATA/FUNCDATA indices by use frequency, shrinking binaries ~0.5% (4aeac68c92); 1.16 compacts the FUNCDATA indices (f96b62be2e). 1.13 and 1.17 add the TOPFRAME function attribute: runtime.goexit marks the top of stack on link-register archs (aafe257390), 1.17 uses it for all top-of-stack functions and moves mstart to assembly (54da3ab385, a1ffbe9c69, 5ecd9e34df), and replaces the “clever” prediction of whether a profile traceback is safe with a FuncInfo SPWRITE flag (fbe74dbf42). 01f05d8ff1 makes asmcgocall save traceback context like systemstack, removing a special case (1.17). GOTRACEBACK=single becomes the default (bf1de1b141, 1.6) with none/single/all/system/crash names.

Timeline.

• Go 1.5 — Done: traceback fixes (894024f478, 0bcdffeea6, 68117a91ae, e544bee1dd), no container symbols in functab (6dd31660b0), missing pcdata tables recorded (434e0bc0a0), pcln check near foreign code (74ec5bf2d8), moduledata validity checks (fa896733b5, 692054e76e, be0cb9224b), per-thread traces during GODEBUG=crash (5bfed7c6c0, f0876a1a94, 142e434006). Left open: every pcvalue lookup decodes from scratch.
• Go 1.6 — Done: pcvalue cache (beedb1ec33), GOTRACEBACK=single default (bf1de1b141), cgo pointer-check debugging prints (166cfd2c87).
• Go 1.7 — Done: print signal name in panic messages (1a7fc2357b), symbolic backtrace of C code during a cgo crash (ea306ae625), call user Error/String methods before freezing the world on crash (e960302410), off-by-one in module-for-PC (1716162a9a), cgo traceback gets signal context (3d037cfaf8), SIGPROF on non-Go thread collects a stack (84d8aff94c).
• Go 1.8 — Done: getcallersp in Go (d211c2d377), sigcode printed on signal crash (09692182fa), bad ftab index handled (b2d34fa51b), non-looping panic printing (7faf702396).
• Go 1.9 — Done: inlined frames in tracebacks, Callers and CallersFrames (781fd3998e, ee97216a17, 7bf0adc6ad, 7f32d41e5d, 38521004ed, 390fdead0b), user stack of other threads printed in GOTRACEBACK=crash (4b8f41daa6, f2e87158f0), FuncForPC docs (d58125ecd2, 58ae050055), nil Func.Name (a776087ee3), findmoduledatap call reduction (0efc8b2188).
• Go 1.10 — Done: hide autogenerated wrappers (e97209515a), intrinsic getclosureptr (57bf6aca71), getcallerpc loses its argument (229aaac19e), avoid bad unwinding from sigpanic in C code is 1.11.
• Go 1.11 — Done: ddb503be96 (always treat the signal PC as sigpanic’s caller), traceback from VDSO code (419c06455a) and outermost libc call (fe68ab3bcd), C backtrace from signal handler on darwin/amd64 (5929ead6fb), getcallersp dummy arg removed (22f4280b9a).
• Go 1.12 — Done: traceback marks freshly allocated _defer (db1e8a9e1f), FuncForPC no longer crashes between functions (462e90259a), refined pcvalue cache (7d6b5e340c), windows/arm sigpanic tracebacks (9ab2ffe8e9).
• Go 1.13 — Done: TOPFRAME on goexit (aafe257390), PCDATA/FUNCDATA reordering (4aeac68c92), lazy file/line in Frames.Next (c77a9e0aa5), dumpgoroutine follow-ups in 1.14.
• Go 1.14 — Done: multiple frames per PC for the race detector (a14efb1be3), dumpgoroutine copes with open-coded defers (1f3339f441), injected-call frames understood by traceback on ARM/ARM64/MIPS/PPC64/S390X (2ff746d7dc, 1b0b980904, a930fede73, 374c2847f9, 933bf75eda), expandFinalInlineFrame empty stack ( is 1.15).
• Go 1.15 — Done: print instruction bytes on SIGILL (63f1bc5992), expandFinalInlineFrame handles an empty stack (5bc75a3097), crash on SI_USER SigPanic (e5bd6e1c79), riscv64 goexit TOPFRAME (a1ffbe9c69).
• Go 1.16 — Done: print faulting instruction on SIGFPE (88c094c96a), compact FUNCDATA indices (f96b62be2e), debug.SetPanicOnFault errors get an Addr method (d91d0762c7).
• Go 1.17 — Done: SPWRITE and TOPFRAME driven traceback (fbe74dbf42, 54da3ab385, 5ecd9e34df), unified asmcgocall/systemstack traceback setup (01f05d8ff1), non-strict InlTreeIndex lookup in Frames.Next and expandFinalInlineFrame (e4a4161f1f, aad13cbb74), funcID-based abort detection (298975c634, ff614b13d9). Left open: the unwinder was still the monolithic gentraceback; the iterator-based replacement came later (see status link).

Defer, panic, recover and Goexit (runtime side)

Span: Go 1.5 → Go 1.17 · Status at go1.17: three defer kinds (heap/stack records via deferproc/deferprocStack, open-coded defers via funcdata bits), all processed by gopanic with a _defer chain; GOEXPERIMENT=regabidefer makes deferred calls func() → continues as Defer, panic and recover re-implementation (1.18+).

Earlier history: Panic, defer, recover and Goexit (Go 1.0 → Go 1.4)

Design. Until 1.13 every defer was a heap-chained _defer record with a copied argument frame. 1.8 made the common path cheap: deferproc/deferreturn no longer switch to the system stack on every call (only the slow allocation/free paths do), they are nosplit so preemption and stack growth cannot intervene without acquirem/releasem, and zero-size and pointer-size frames are special-cased (f8b2314c56: runtime defer benchmark -42%, Lock/defer-Unlock overhead 61.4 ns to 27.9 ns; getcallersp as Go helps, d211c2d377). Cgo calls dropped the defer that unwound endcgo, folding it into the callback defer (441502154f). Go 1.14’s open-coded defers (compiler/linker/runtime change that also added funcdata FUNCDATA_OpenCodedDeferInfo, be64a19d99/dad616375f, outside this slice’s list) make the common case inline code; the runtime side is that panic/Goexit must find those frames: gopanic scans the stack for frames with the funcdata, adds a _defer entry on the fly for each (addOneOpenDeferFrame) so open-coded and record defers run in correct order and a “started” state can be stored; on recover the stale entries have to be removed from the chain. Fixes during 1.14/1.15/1.16 show the subtlety: newdefer must not link the record to g0 when called on the system stack (825ae71e56), repeated panic/recover/re-panic left stale entries (fae87a2223), nil deferred function must fault in deferreturn() (22d28a24c8), dumpgoroutine (1f3339f441), and in 1.16 entries must be removed in all cases after recover, aborting the removal loop at any started defer (a5a5e2c968, which explicitly leaves bug 43920 “a more complex fix” open). With GOEXPERIMENT=regabidefer (1.17) deferred functions have the fixed signature func(), so reflectcall of defers becomes a direct closure call (c847932804), frames of defer/go are asserted empty (e0ce0af6ef), and the deferreturn dummy argument is dropped (585b52261c).

Crash handling: startpanic_m never allocates (2edc4d4634), fatalpanic is split into fatalthrow and fatalpanic and the final crash performed outside systemstack so debuggers see a sane stack (b1d1ec9183), and unrecoverable panic handling runs on the system stack (9d59234cbe, 7f1b2738bb, 60a9e5d613). throw on out-of-range index inside runtime (f43aa1df70), and runtime.Goexit uses goexit1 (ad731887a7).

Timeline.

• Go 1.5 — Done: panic/stack code in Go (d98553a727), reflectcall write barriers (df027aceb9), Goexit calls goexit1 (ad731887a7), goexit prototype hardened (ad731887a7).
• Go 1.6 — Done: panic1.go merged into panic.go (9358f7fa61), Go/cgo exported function may not return Go pointers (0e2c635788).
• Go 1.7 — Done: simplified setPanicOnFault (6af4e996e2), user Error/String called before the world freezes (e960302410).
• Go 1.8 — Done: optimized defer (f8b2314c56), getcallersp in Go (d211c2d377), call* signatures and zero-size deferArgs fixed (a73d68e75e), reflectcall write barriers simplified for the hybrid barrier (79561a84ce), cgo call without defer (441502154f). Left open: defer still costs ~28 ns over no-defer (f8b2314c56); “a future Go release will drop the cost of defer to nothing” (441502154f).
• Go 1.10 — Done: no allocation in unrecoverable panic (2edc4d4634), write barriers allowed in startpanic_m (070cc8eb02), deferreturn avoids typedmemmove for nosplit limits (332719f7ce).
• Go 1.11 — Done: abort path unification (c950a90d72, 60a9e5d613), unrecoverable panic handling moves to the system stack (9d59234cbe), crash outside systemstack (b1d1ec9183), recursive panic on bad lock count avoided (4991bc6257).
• Go 1.12 — Done: traceback shows whether a _defer was just allocated (db1e8a9e1f), no write barrier in startpanic_m (9ed9df6ca2).
• Go 1.14 — Done: open-coded defers’ runtime parts as described (see 1f3339f441), the nil-defer fault in deferreturn (22d28a24c8). Left open: repeated panic/recover with open-coded defers could leave stale entries (fixed in 1.15).
• Go 1.15 — Done: stale open-coded defer entries removed over the whole chain (fae87a2223), g0 defer-list pollution fixed (825ae71e56 was committed 2020-03 and ships in 1.15).
• Go 1.16 — Done: removal of open-coded defer entries in all recover cases (a5a5e2c968).
• Go 1.17 — Done: regabidefer prerequisites (c847932804, e0ce0af6ef, 585b52261c), deferreturn frames checks, reflectcall ABI0 on amd64 (d8306ee1f9), gosave deleted (8fa84772ba, b110a43628), jmpdefer handled by SPWRITE (fbe74dbf42), direct unlockOSThread instead of a defer in Windows syscalls to avoid nosplit overflow (4dbad79510).

Signals: masks, forwarding, sigaltstack and the unified Unix signal layer

Span: Go 1.5 → Go 1.17 · Status at go1.17: one signal_unix.go with sighandler, sigtrampgo, adjustSignalStack, sigfwdgo; libc sigaction under cgo; M-targeted signals for preemption → continues as Signals and async-preemption machinery (1.18+).

Earlier history: Signals: handling, os/signal, foreign threads (Go 1.0 → Go 1.4)

Design. The policy settled in 1.5: a Go program always needs synchronous signals (SIGSEGV, SIGBUS, SIGFPE, the _SigPanic set) enabled; signal.Notify needs at least one thread with the signal unblocked. msigsave saves each thread’s mask in m.sigsave at needm/newm; minit unblocks only essential signals (_SigUnblock: synchronous ones, SIGILL, SIGTRAP, SIGPROF, SIGSTKFLT), unminit restores the saved mask, and a helper thread is started on first Notify to keep notifications deliverable (84cfba17c2); a follow-up unblocks glibc’s setxid/cancel signals (ffd7d31787, 675eb72c28). Programs started with SIGHUP/INT/QUIT/ABRT/TERM blocked now ignore them. 1.5 adds signal forwarding to a handler installed before Go’s: forwarded iff a non-SIG_DFL handler existed, the signal is synchronous (SEGV/BUS/FPE), and it occurred on a non-Go thread or in cgo code (5c8fbc6f1e, Linux; darwin/amd64 a5b693b431), with SIGSETXID/SIGCANCEL on the signal stack (675eb72c28) and re-raise on non-Go threads (872b168fe3). 1.6 extends this to c-archive/c-shared (no unnecessary handlers fbdfa99246, synchronous install 21b4f234c7, restore original disposition a7d2b4d7ce, e24b2445b4), preserves/adjusts the signal stack on C threads (a7cad52e04, f7e51c1320, f8e6418637), and fixes exit status when killed by a signal (2c67c8c303). 1.8 collapses duplicated per-OS handlers into signal_unix.go (9e028b70ea, ab552aa3b6, 159a90b93a, 343bec53c7, d15295c679, c2735039f3, ac24388e5e, e2e11f02a4, 097a581dc0, fdc167164e, f05cd4cde5, eb268cb321), and uses libc sigaction under cgo (1f605175b0, fe057c1478); SIGPIPE is handled in c-archive/c-shared and non-Go SIGPIPE forwarded (d24b57a6a1, refined 78074f6850). 1.9 uses atomics for fwdSig and an immutable sigtable (87ad863f35); 1.10 forwards crashing signals to late-registered handlers and makes the process die via the previous handler so Crashlytics-style handlers see SIGABRT (5500c9ce27, c3189cee71), restores the Go-allocated gsignal stack in unminit after an OS-provided one replaced it (292558be02, which on 1.9 meant two handlers on one stack), and never frees OS-created signal stacks (44d9e96da9). 1.14 makes Go always use a Go signal stack in non-cgo programs (73d20f8186), factors sigtrampgo (d29c14f3d2) and crashes if a signal arrives with a bad G and no extra M (03c58c9dcc); a kernel bug in Linux 5.2–5.4.1 corrupting vector registers when the signal stack was not faulted in is worked around by mlocking the top of every signal stack (8174f7fb2b, 1c8d1f45ba, 69614c0d0e, 9d4717d5f1), made non-fatal (b851e51160, 71218dbc40) and reverted in 1.16 (92bda33d27).

Timeline.

• Go 1.5 — Done: signal forwarding (5c8fbc6f1e), mask policy (84cfba17c2, 8017ace496), os/signal ignore/reset (194ad16b83), SIGPROF from foreign threads ignored before cgo init (5da9c8cd0a), notes on Plan 9 (d5d4ab7819), signal handling on Plan 9 (f85a05581e, 3d032d7653), runtime·raise on dragonfly (d9ee9a0f6e), windows exception code made arch independent (6e774faed7, d1af6bed84, e0d9342da7, 5c4a86d0d0). Left open: forwarding only on Linux and darwin/amd64.
• Go 1.6 — Done: c-archive/shared signal handling (fbdfa99246, 21b4f234c7, a7d2b4d7ce, e24b2445b4, a7cad52e04, f7e51c1320), SIGCONT/SIGTSTP/SIGCANCEL policy (81b35117d9, 3fd19fdc51), allow signal.Ignore of user-generated throwing signals (81adfa508a), nowritebarrierrec in signal path (84a95be922, e126f30a66), m.sigmask typed sigset (7db77271e4, a7383fc467), drop signal stack on NetBSD/DragonFly threads and related (4c4476c297, 123510bf83, 801bebefa9, aea4de80f9), Darwin sigaltstack fixes (f40c05eea4, 0408ca7de1, fb30270037), OS X TRAP bug (331a6055ab), sigfwd stack alignment (2d916bec96), pthread_sigmask on darwin arm (e884334b55), SIGRTMAX qemu workaround (d10675089d), SIGEMT on mips64 (68c6aad58b), signal-handler sigpanic via r12 on ppc64 (f000523018), sigsetstack on Solaris (956535f5cb), exit status (2c67c8c303), integer compare fix (b9fde8605e), drop unneeded sigfwd on unsupported platforms (9fb79380f0), sigreturn stub (31322996fd), sigsend compare (a94e906c41), EPIPE behaviour (58c73de7d0).
• Go 1.7 — Done: better last-ditch forwarding for Unix libraries (df2b2eb63d), don’t unblock all signals on BSDs (6f59ccb052), drop _SigUnblock for SIGSYS (be730b49ca), yield after raising a killing signal (c1b32acefb), openbsd/386 sigreturn (5bd37b8e78), darwin amd64 INT $3 after sigtramp (ff227b8a56), SIGPROF on non-Go thread traceback (84d8aff94c), Solaris signals (562e38c0af), Plan 9 signals (d145456b16).
• Go 1.8 — Done: unification listed above, SIGSTOP on Solaris (84803f3da1), sigtramp callee-saved registers (29cb72154d, fdde7ba2a2), no cgocallback from signal handler (6c13a1db2e), crash if signal arrives on g0 stack (fded5dbb2f), sleeping to let bad signals deliver (75055de84a), SIGPROF PC on non-Go thread (d03e8b226c), SIGPIPE in libraries (d24b57a6a1), sigset on ppc64 BE (15937ccb89), sigfwd alignment (8380de416b), dragonfly signal-stack revert (5db80c30e6, a0d330f1dd).
• Go 1.9 — Done: SIGPROF enabled/disabled with profiling (e24228af25), SIGPIPE refinement (78074f6850), signals under TSAN polled via libc (29edf0f9fe, a8dd20d389), atomic fwdSig (87ad863f35), signal stack on main thread cleared (5dc14af682), reset handlers to default in forked child (df0892cbf8, 28f650a2f7), sigaction sa_flags fix (4210930a28).
• Go 1.10 — Done: previous-handler death (5500c9ce27), late handler forwarding (c3189cee71), sigTabT unified (6126384f6d), Solaris sigtrampgo (ae84aaee44), foreign handlers on Darwin (057a34a281), do not block signals that kill the program (eb97160f46), sigctxt.fault() normalized (56462d0f10), gsignal stack restore (292558be02), never-freed OS signal stacks (44d9e96da9), documented sigtrampgo (294963fb7f), ios sigstack (764a6ac29e), dieFromSignal sleeps longer on Darwin (0ec59e4c08).
• Go 1.11 — Done: libc signals on Darwin/iOS (ec989337c5, 021c39d7a3, 467e15accc, c2fdb42b16), rt_sigaction to sigaction rename (c2f28de732), SIGRTMAX/32/33 errors ignored (2aef675000, c0e5485bd5), os/signal.Ignored (dfb1b69665), abort handling on arm64/Windows (0def0f2e99, 7001ac5394).
• Go 1.12 — Done: sigInitIgnored nosplit (97f1535285), tgkill for raise (43f54c8d2e), abort check on Windows (9be01c2eab).
• Go 1.13 — Done: sigpipe check fix (0c75eb824c), darwin signal wake-up via a pipe (c485e8b559), sigtramp callee-saved registers on arm64/arm Darwin (cbdf9ade56, df901bce5e), sigfwd and sigtramp on AIX (bf103723f8, b5cf035d1c).
• Go 1.14 — Done: SIGURG not a bad signal (f770366f6d), no forward of SIGPIPE on macOS (d56a86e01f, 2afe9d4dec), sighandler moved to signal_unix.go (426bfbe9a3), ignoring SIGPROF when disabling (fd33b2c974), Go signal stack always used without cgo (73d20f8186), the mlock workaround (8174f7fb2b, 69614c0d0e, 9d4717d5f1, 1c8d1f45ba), setg after sigFetchG (fb05264fe1, f07cbc7f88), crash with bad G (03c58c9dcc), Windows lastcontinuehandler in DLLs (e5e5fb024a) and CTRL_CLOSE/LOGOFF/SHUTDOWN as SIGTERM (5d1a95175e).
• Go 1.15 — Done: SI_USER SigPanic crash (e5bd6e1c79), setg to gsignal before adjustSignalStack (d286e61b67), no preempt signal if one is pending (0c0e8f224d), DLL receiving a signal does not exit (5756808ce8), remove runtime sigqueue init (2681efaf0e), mlock don’t crash (b851e51160, 71218dbc40), Plan 9 notes enabled later (bb59a1360a).
• Go 1.16 — Done: signal 34 for musl setgid (49b017fe59), mlock reverted (92bda33d27), needm blocks signals before allocating an M (368c401164), signal handler checks g0 last (3a778ff50f), iscgo does not block nptl signals (b0b0d98283), Windows ctrl handler no longer exits (c0dded04f7, 8cfa01943a), os/signal deadlock with AllThreadsSyscall fixed (fd6ba1c8a2), setitimer per-process (bd519d0c87).
• Go 1.17 — Done: sigpanic0 on all OSes (2698be4905), ppc64 signals with cgo and callCgoSigaction (d9e068d289), CPU profiling disabled before removing SIGPROF handler (57aaa19aae), Windows non-Go thread signal aborts (cd28ca3a4e), Windows SEH on arm64 illegal instruction (70546f6404), macOS sigNoteSleep EINTR loop (77aa209b38).

Asynchronous preemption: signal plumbing, injected calls and per-arch support

Span: Go 1.14 → Go 1.16 · Status at go1.17: still the design at go1.17 → continues as Signals and async-preemption machinery (1.18+).

Paths not taken: Loop preemption by compiler-inserted checks and page faults (superseded)

Earlier history: Goroutine preemption (stackguard0, 10 ms and GC preemption) (Go 1.2 → Go 1.2)

Design. Go 1.14’s non-cooperative preemption splits into (1) delivering a signal to the right thread and (2) injecting a call at the interrupted PC. For (1), suspendG marks the G for preemption and sends its M a “wake up and look around” SIGURG; the handler checks whether the M runs a G with a preemption request at a safe point, counting received preemption signals so suspendG can detect a failed attempt and retry without a back channel (62e53b7922). Targeted M signals were added OS by OS: Linux (334291d1f6, tgkill), BSDs (8714e39497), libc-based OSes (42aab4b0af); Windows uses SuspendThread (b89b4623eb). For (2), sigctxt.pushCall pushes a call to asyncPreempt at the signalled site (2d031dc559, 386/amd64 first), also used to clean up preparePanic; asyncPreempt saves all registers; non-amd64 archs must clobber one register to return from the injected call (REGTMP on arm64/mips/s390x/riscv64, CTR on ppc64) so those sequences are marked non-preemptible (ee330385ca restarts/preempts some instruction sequences; 2ff746d7dc ARM, 1b0b980904 ARM64, a930fede73 MIPS/MIPS64, 374c2847f9 PPC64, 933bf75eda S390X, b89f4c6720 riscv64). MIPS CALL is not atomic: a signal can see updated LR with stale PC, so no preempt there (a930fede73). Debugger call injection reuses the same safe-point machinery (see separate thread).

Timeline.

• Go 1.14 — Done: signal-based suspend (62e53b7922), x86 call injection (2d031dc559), M-targeted signals (334291d1f6, 8714e39497, 42aab4b0af), ARM/ARM64/MIPS/PPC64/S390X (2ff746d7dc, 1b0b980904, a930fede73, 374c2847f9, 933bf75eda), Windows preemption via SuspendThread (b89b4623eb, 17e97322fb in 1.15) with a CAS protocol protecting external code from ExitProcess (957259b7e2), g register saved on the gsignal stack during VDSO calls on ARM/ARM64 (758eb020f7, 75c839af22), darwin/arm64 enabled with cgo only (52d5e76b39, 995ade86e3, 67f0f83216), AVX upper-half cleaned on darwin/amd64 entry (123f7dd3e1), VZEROUPPER guarded in 1.15. Left open: darwin/arm64 without cgo not supported until 1.16.
• Go 1.15 — Done: preempt/restart some instruction sequences (ee330385ca), riscv64 (b89f4c6720), skip preempt when disabled (d1015f3e58), no preempt signal when one is pending (0c0e8f224d), Windows Context allocation tidy (2a029b3f26).
• Go 1.16 — Done: wait for/avoid preemption signals around syscall.Exec (05739d6f17, 21cfadf0dc, 64fb6ae95f), always on for darwin/arm64 (7c8d82e92b), 386 SSE guard restored (67edc0ed81), riscv64 X27 not saved (76661d12e8).
• Go 1.17 — Done: save R15 before checking AVX state (c49c7a675a), gp==nil check before preemption state (98dd205fa4), SIGPROF handler ordering (57aaa19aae), avoid preemption when returning from Go to C (70fd4e47d7).

cgo runtime support: pointer checks, callbacks, extra Ms, C-to-Go call path

Span: Go 1.5 → Go 1.17 · Status at go1.17: the simplified C→Go path (crosscall2 → cgocallback → cgocallbackg → _cgoexp_GoF), cgocheck=1 pointer rules, extra-M list with batch creation → continues as C-to-Go callbacks: extra-M reuse, system-stack bounds, init gating (1.18+).

Earlier history: cgo runtime support and non-Go threads (Go 1.0 → Go 1.4)

Design. Pointer-passing rules from proposal #12416 are enforced dynamically: cmd/cgo wraps pointer arguments in cgoCheckPointer and GODEBUG=cgocheck=0 disables it (9dcc58c3d1, 1.6), extended to exported-function returns (0e2c635788), unsafe.Pointer(&s[0]) (d91ec5bb40), strings (e97096661e), C pointers inside the arena range (dd6753a6f2), and finally optimized (e85ffec784, ~30% + 20% + 15%). The runtime cost of entering C was shaved: no defer in cgocall (441502154f), no lockOSThread per call (332719f7ce), correct liveness across the “time warp” of a callback (f6bff1d587). Callbacks from C threads use an “extra M” pool: needm takes one, needextram asks to allocate a replacement, and 1.7 makes it create as many as threads waiting, fixing a thundering herd on FreeBSD (-74% wall time of CgoCallbackGC) (50048a4e8e); dropm ordering fixes on non-x86 (c02aa463db), minimized time between lockextra/unlockextra (efd93a412e), and signals blocked before the M is allocated (368c401164). In 1.16 the C→Go call path was redesigned: instead of cgo generating an argument struct with exactly the Go stack layout and reflectcalling a generated function, cgo now generates a Go function that takes a struct pointer, unpacks it and makes a normal call; cgocallback_gofunc is merged into cgocallback and reflectcall is no longer needed on this path (30c1887873). 1.17 unifies C→Go ABI transitions in macros (7ad496b6f5) and calls cgocallbackg indirectly (d3853fb4e6).

Timeline.

• Go 1.5 — Done: the extra M for cgo is initialized during mstart (b8caed823b), needextram becomes a bool (e9d9d0befc), cgocallback waits for package init (3b22ffc07e), shared-library init waits for runtime init at the first cgo call (e8694c8196), pointers passed to C escape to the heap (2c2770c3d4), TMPDIR/initial working directory handling in cgo (b54d313205, f6fb549d22, 249894ab6c), PTHREAD_*_INITIALIZER (0c62c93a09), TLS halved offset on ELF/intel (658a338f78).
• Go 1.6 — Done: pointer checks (9dcc58c3d1, 0e2c635788, d91ec5bb40, e97096661e, dd6753a6f2, 166cfd2c87, 387d5b8cfb), msan with cgo (0c1f0549b8), asmcgocall without a g (3af29fb858), Solaris syscall without g (35a5bd6431), dropm on arm/arm64/ppc64/mips64 (c02aa463db), ppc64le cgocallback (3dda43c6aa), mmap in cgo avoids write barrier (b3c05f08a9).
• Go 1.7 — Done: cgo context function (5f9a870bf1, b30814bbd6, 88e0ec2979), TSAN support for malloc, acquire/release and locks (a5d1a72a40, 66736880ca, cf862478c8), mp.cgocallers (59fc42b230, 58394fd7d5), extra Ms as needed (50048a4e8e), cgocallback_gofunc fixes on arm64/ppc64x/arm (9fe572e509, 58f52cbb79, 690de51ffa), callee-saved FP registers (71916437fb, a7f7a9cca7, 72eb46c5a0), iOS exception handler signals (be10c51500).
• Go 1.8 — Done: no defer in standard cgo call (441502154f), pointer-check function literal (a16954b8a7), undead arguments (f6bff1d587), pthread_create retry on EAGAIN (7cba779cea, 80acfe950f), tsan around setenv (2d85e87f08), big-endian mips64 callback (14ff7cc94c), s390x FP register saves (06fcc32d14).
• Go 1.9 — Done: GOTRACEBACK=crash promptly in cgo binaries (f2e87158f0), Android TLS slot search (0476c7a7b5), openbsd PT_TLS (9417c022c6), CFRelease (2b4274d667).
• Go 1.10 — Done: no lockOSThread per cgo call (332719f7ce), PPC64LE cgo traceback (6fd1f825c1), crosscall2 frame (913fb18e7e), x_cgo_yield inlining defeated (e0545faf27), darwin/arm panicmem without init function (69b0b3ad22, ae175f74cb).
• Go 1.11 — Done: C backtrace from signal handler on darwin/amd64 (5929ead6fb), NetBSD TSAN (f5921d48f1), memory sanitizer on arm64 (e8d417d272), iOS SIGINT handshake removed (144fae8ed5).
• Go 1.13 — Done: Windows _cgo_sys_thread_create calling convention (bec67e1130), Android threadentry unification (b2f19dad8b), cgo_wait_runtime_init_done prototype (9586c093a2), AIX asmcgocall ABI (c1e2227505).
• Go 1.14 — Done: cgoCheckPointer optimized (e85ffec784), -Wno-nullability-completeness (fb37821014), unsetenv wrapper fix in 1.15.
• Go 1.15 — Done: arm64 infinite cgo callstack fixed with CFA info in crosscall1 (8e121b1587).
• Go 1.16 — Done: simplified C→Go path (30c1887873), call16 everywhere (9dc65d7dc9, 40bff82885), tidy cgocallback (c91dffbc9a), Windows callback compile tidy (bda37a0b8a), Android NDK 22 (1d78139128).
• Go 1.17 — Done: runtime/cgo.Handle for managing Go values across C (972e883925), unified C→Go ABI transitions (7ad496b6f5), cgocallbackg called indirectly (d3853fb4e6), setg_gcc in crosscall_amd64 (63de211014), msan unpoisoning of cgoCallers (7aeaad5c86), ppc64x crosscall2 (bade680867), needm bypasses ABI wrapper on Windows (fef5a15396). Left open: nothing noted.

Shared-library and buildmode entry points (c-archive, c-shared, plugin, shared)

Span: Go 1.5 → Go 1.17 · Status at go1.17: per-arch _rt0_*_lib entry points exist for linux, darwin, windows, android, ios; init runs on a new thread and the loader thread returns → continues as Library entry points and runtime initialization (1.18+).

Earlier history: TLS, g/m registers and shared-library linking (Go 1.0 → Go 1.4)

Design. -buildmode=c-archive/c-shared needs the runtime to start inside a host process: the library entry point (_rt0_$GOARCH_$GOOS_lib) creates an OS thread to run the regular runtime init, returns immediately to the loader thread, and the first cgo call waits for init to finish (e8694c8196, linux/amd64 first, then ARM 93644c9118, android/arm d1eee2cebf, darwin/amd64 b0a85f5d93, darwin/arm 6e3a6c4d38, darwin/arm64 e8b7133e9b, linux/386 9c1868d06d, linux/arm64 73ff7cb1ed, ppc64le 8a1dc32447, darwin/386 47ccf96a95). Entry points must save callee-saved registers (357a013060, ca4ea81d86, fb30270037, ea4b785ae0), align the stack (10c8b2374f, 26015b9563, 48754592e0), set R0 on ppc64le (9aea0e89b6), and in 1.10 the three amd64 and 386/arm exe/lib entry points are unified (cf3f771203, 30cb30e596, 378de1ae43, d92aaa9707), with hasmain in moduledata (c58b98b2d6). -buildmode=shared and plugins need addmoduledata (arm64 4e3deae96d, arm 1b4d28f8cf, ppc64le 1ccefcd1b8, 386 09d7de8d61, fixes be0cb9224b, 87a51a0787) and module bookkeeping: activeModules slice swapped atomically because a plugin’s moduledata is visible before initialized (54ec7b072e, f096b5b340), reordering main first (b531eb3062), duplicate itabs (81a61a96c9), module typemaps visible to GC (f4c7a12c2c), non-throwing duplicate open (d8ae2156fe), PIC for vsyscall helper on 386 (bc3f14fd2a, 6056cc5df6, 7af0839e11), PIC rules on ppc64 (6deb3c0619), TLSG_IS_VARIABLE etc.

Timeline.

• Go 1.5 — Done: init at library load (e8694c8196), darwin/amd64, ARM, android, 386 entry points (b0a85f5d93, 93644c9118, d1eee2cebf, ede863c673, 9c1868d06d, c8aba85e4a) and addmoduledata fix per platform ABI (be0cb9224b). Left open: only linux/amd64 first (“Next step is to support it on linux_arm”, e8694c8196).
• Go 1.6 — Done: arm64 and arm addmoduledata (4e3deae96d, 1b4d28f8cf), ppc64le (1ccefcd1b8), 386 (09d7de8d61), shared-mode tweaks (c5856cfdb6, 35d71d6727), darwin/386 (47ccf96a95), arm64 c-shared (73ff7cb1ed), PIC vsyscall on 386 (bc3f14fd2a, 6056cc5df6, 7af0839e11).
• Go 1.7 — Done: ppc64le library startup (8a1dc32447, 32302d6289), Windows c-archive (ed8f0e5c33), defer in 386 shared (26849746c9), 16-byte stack alignment (26015b9563, 10c8b2374f).
• Go 1.8 — Done: plugin package and runtime checks (0cbb12f0bb, b4c9829c22, f4c7a12c2c, 54ec7b072e, 81a61a96c9, b531eb3062), Android libs read /proc/self/auxv (6f287fa2bb).
• Go 1.9 — Done: ppc64le c-archive init fixed (daa0ddde93), CR saved/restored on ppc64le (b1af5393d9).
• Go 1.10 — Done: amd64/386/arm entry unification (cf3f771203, 30cb30e596, 378de1ae43, d92aaa9707, c58b98b2d6), plugin re-enabled on darwin/amd64 (1134411a83), c-shared on ppc64le (3e7abf82e3), error not throw on duplicate plugin open (d8ae2156fe).
• Go 1.11 — Done: freebsd/amd64 c-shared and c-archive (88129f0cb2).
• Go 1.13 — Done: aix/ppc64 library startup and c-archive (38dc177d3a, 3aacfce6cf).
• Go 1.16 — Done: iOS entry points (0040adfd0f), Windows PIE symbol export (e463c28cc1), automatic dynamic library linking in the linker (7ee2622443).
• Go 1.17 — Done: Windows amd64 lib entry stack alignment and refactor (e0fae78e1d, 3e0b1cdb5d), arm64 Windows lib entry in 16330817aa.

vDSO, time sources and process-wide randomness

Span: Go 1.5 → Go 1.17 · Status at go1.17: vDSO used for clock_gettime on linux/{amd64,386,arm,arm64,mips64x,ppc64x}; Darwin/Windows use libc/KUSER_SHARED_DATA; fastrand seeded from OS randomness → continues as vDSO, vgetrandom and fast clocks (1.18+).

Earlier history: Clocks, vDSO and timers (Go 1.0 → Go 1.4)

Design. The Linux vDSO ELF parser (vdso_linux.go, originally amd64 only) found __vdso_clock_gettime; 1.10 adds DT_GNU_HASH (9065c3bf34), splits arch specifics (4477107b7b, c14dcfda6b) and brings linux/386 (af40cbe83c: 6.89x faster time.Now, 5–10x for the vDSO path). Calling C vDSO code from a goroutine stack is unsafe: GCC stack probes in hardened kernels need a page of stack, so amd64 vDSO calls switch to g0/gsignal and align the stack (a158382b1c, 1.10); 1.11 records caller PC/SP in m.vdsoPC/vdsoSP so SIGPROF can traceback through VDSO instead of reporting _ExternalCode (419c06455a), then linux/arm (51b027116c) and arm64 (ea59ebd338). 1.12 adds ppc64x (dbd8af7472), 1.14 mips64x (210e3677f9), and ARM/ARM64 save g on the gsignal stack before VDSO calls because the vDSO may clobber the g register (758eb020f7), unless already handling a signal (75c839af22), plus nanotime1/walltime1 made reentrant by saving/restoring previous vdso PC/SP (a93a4c1780, 1.15), frame-pointer and R11 fixes (21713f41d1, 2ee2c6232c, 3eab754cd0), PPC64 r30 clobbering by the kernel’s new C vDSO (16e82be454, 1.17), and a fallback to real syscalls when neither vDSO nor vsyscall exist (3caaaddffd, 1.16; mips64 return-code check df81a15819). Other clocks: Darwin mach_absolute_time for monotonic nanotime (e546b295b8), monotonic+wall fetched together on Darwin and Windows (e4371fb179, with 0e3355903d monotonic time.Now in 1.9), FreeBSD fast clock_gettime incl. HPET (744ccbb852, 58c231f244, a9fc375258), NetBSD/Solaris monotonic (2065685664, 66fcf45477, 2df5cdbadf), clock_gettime instead of gettimeofday on darwin (ae76f6e962), fastrand in Go (d03c124860) and consistent OS-seeded fastrand across archs (97d0505334), startup randomness from AT_RANDOM on arm/arm64/mips64x via a common auxv parser (3aba41d6c3, a2eded3421, 2e32efc44a, c955bb2040, 90addd3d41).

Timeline.

• Go 1.5 — Done: urandom instead of random (1de9c4073b), AT_RANDOM on arm (3aba41d6c3, f15c675fb4), get_random_bytes on NaCl (003dccfac4), fake time to stdout/stderr (242050d07f).
• Go 1.7 — Done: AT_RANDOM on arm64/mips64x (a2eded3421, 2e32efc44a), common auxv (c955bb2040, 90addd3d41), Sierra nanotime fixes (fad2bbdc6a, 2da5633eb9), iOS 10 gettimeofday ABI (9fde86b012).
• Go 1.8 — Done: clock_gettime on ppc64x/s390x/arm64/mips64x (0df5ab7e65, 61d5daea0a, 5594074dcd), Linux auxv extracted (d39b7b5347).
• Go 1.9 — Done: mach_absolute_time (e546b295b8), monotonic time.Now (0e3355903d), faster Now on Darwin and Windows (e4371fb179), Wine time (9f98e49825), internal/cpu package arrives (69972aea74).
• Go 1.10 — Done: DT_GNU_HASH (9065c3bf34), linux/386 vDSO (af40cbe83c), vdso_linux generalization (4477107b7b, c14dcfda6b), amd64 vDSO on large stack (a158382b1c), Sierra/High Sierra clocks (d8ff3d5920, 2d6f941e8c), NetBSD monotonic (2065685664, 66fcf45477).
• Go 1.11 — Done: vDSO traceback (419c06455a), simplified linux 386/amd64 walltime (5b21bf6f81), linux/arm and arm64 vDSO (51b027116c, ea59ebd338), vDSO stack-switch check (9745397e1d), FreeBSD fast clock (744ccbb852, 58c231f244, a9fc375258), libc time on Darwin (cc09212f59, 6c6e22e5a9), auxv for FreeBSD/NetBSD/DragonFly/Solaris (2e84dc2596, 4ff4e50725, 9364c13d09, 01237b1362, 6f47fa2d6c, 51e19d6032).
• Go 1.12 — Done: ppc64x vDSO (dbd8af7472), refactored startNano (a1ee0a21cf).
• Go 1.13 — Done: setNsec for timespec (0a7bc8f430), NetBSD/amd64 timespec fix (ee551846fa).
• Go 1.14 — Done: Wine hacks removed (b4ad49f9f7), nanotime/walltime wrapped (4af3c17f8c), mips64x vDSO (210e3677f9), Solaris monotonic (2df5cdbadf), fastrand seeding unified (97d0505334), VDSO arm fix (904f046e2b), nanotime1 BP/R11/offsets (21713f41d1, 2ee2c6232c, 3eab754cd0), PPC offsets (71239b4f49), ppc64x and darwin syscall perf (c1635ad8f0).
• Go 1.16 — Done: reentrant nanotime1 (a93a4c1780), vDSO/vsyscall fallback (3caaaddffd), mips64 return check (df81a15819), riscv64 RDTIME (cf9b4f63a5), Darwin clock_gettime (ae76f6e962).
• Go 1.17 — Done: PPC vDSO g clobbering (16e82be454), Windows time constants and files consolidated (e51246c881, b36596b14f), removal of linux-amd64 walltime function (b15372f39b), nanotimeQPC called normally (6639bb894d, 4deaa6a178), Plan 9 hashkey init (a95454b6f3).

Darwin and OpenBSD move to libc; Solaris and AIX libcall; syscall wrapper layer

Span: Go 1.5 → Go 1.17 · Status at go1.17: macOS and iOS, Solaris/illumos and AIX go through libc via libcCall/asmcgocall trampolines, and openbsd/{amd64,386,arm,arm64} link libc and use pthreads; Linux/FreeBSD still use raw syscalls → continues as Syscall layer: AllThreadsSyscall, internal/runtime/syscall, libc and Windows SyscallN (1.18+).

Design. Because Apple, Solaris and OpenBSD do not promise a stable syscall ABI, Go moves syscalls to libc calls issued from the system stack. On Darwin 1.11 starts with thread creation via pthread (b7f1777a70), exit (21656d09b7), then open/close/read/write (16d1a8e6e3), raise, sigaction/sigprocmask (ec989337c5), nanotime and time.now (cc09212f59, 6c6e22e5a9), kevent (72c29fc8cd), semaphores (5b5473c6bf), and the same for iOS (c8d07295c5, 021c39d7a3, c824f540d9, cdffe9b1e3); the profiler is kept happy by wrapper frames (ef53de8ba4). 1.12 does the same for package syscall via libSystem (a3b01440fe, be5f646dab, 9eb383e8f0), 1.13 avoids _getdirentries64 (9da6530faa), 1.13 also uses dispatch semaphores (85d56c3096), a pipe to wake signal_recv (c485e8b559), and MADV_FREE_REUSABLE (abf8e355a8); 1.14 adds nonblockingPipe and netpollBreak (3b0aa546d2, 50f4896b72) and read/write returning negative errno (b653c878b1). 1.17 uses entersyscall in syscall_syscallX (700b73975e), marks wrappers ABIInternal and later abi.FuncPCABI0 (bfc7418e6d, c430313992). In 1.16, openbsd/amd64 is switched to libc and pthreads (d047c91a6c, dab3e5affe, 8634a234df, 928bda4f4a, b268b60774, 66ee8b158f, 725a642c2d), then arm64 (3d40895e36, 6c8fbfbdcf, cd176b3615, 376518d77f) and in 1.17 386 and arm (4893eee9dc, c3b2b04156, faff49aae6, 8e91458b19, 8ec8f6aa87, 83df4a590b, 603f43cbae, bedf2c4886). Solaris uses libcall structs with RawSyscall panicking (613f8cad90, f0939ba5b1, 4902778607, fe5ef5c9d7); AIX uses the AIX C ABI in asmcgocall (c1e2227505) and libcall on stack (4e2b4d7fb2, cbaa8e5f93).

Timeline.

• Go 1.11 — Done: Darwin/iOS libc migration (b7f1777a70, 21656d09b7, ce5c3871a4, 16d1a8e6e3, c2fdb42b16, cc09212f59, c8d07295c5, c1a068012c, ec989337c5, 467e15accc, ef53de8ba4, 6c6e22e5a9, 021c39d7a3, f027d1a878, 72c29fc8cd, c824f540d9, 5b5473c6bf, cdffe9b1e3, 6fdbed0543, 76e92d1c9e, b3a854c733, e86c26789d). Left open: syscall package itself still raw syscalls.
• Go 1.12 — Done: libSystem for package syscall (a3b01440fe, be5f646dab, 9eb383e8f0), Solaris syscall to libc files (49be65eeba).
• Go 1.13 — Done: 9da6530faa, 85d56c3096, c485e8b559, d410642f49, 7d65e3a853, abf8e355a8, c00ff65d01 (default system stack size on non-cgo macOS), f6b42a53e5/d32ec38f1c DNS via libSystem (internal, then removed).
• Go 1.14 — Done: c1635ad8f0, d56a86e01f, 3b0aa546d2, b653c878b1, 47efbf0a4e (fcntl consistency), 904e1136c2 (Solaris pipe).
• Go 1.15 — Done: Security.framework without cgo uses runtime.syscallNoErr variants (6f52790a20), dropping darwin/arm and 386 (da8591b61c, 8b4cbcc320).
• Go 1.16 — Done: openbsd/amd64 and arm64 to libc (listed above), _exit on darwin (8438a5779b), syscall.Exec preemption guard (64fb6ae95f, 05739d6f17), accept4 on illumos (9cec50f50c), FreeBSD errors (4d27c4c223), cgo_import_dynamic for libc.so (66ee8b158f). Left open: openbsd/386 and arm remained on raw syscalls until 1.17.
• Go 1.17 — Done: openbsd/386 and arm libc (listed above), Darwin entersyscall (700b73975e), ABIInternal marking (bfc7418e6d, c430313992), osyield nosplit on OpenBSD (02699f810a), raise nosplit ( is 1.15).

Windows runtime

Span: Go 1.5 → Go 1.17 · Status at go1.17: Windows 10 long-path support, arm and arm64, high-resolution waitable timers, QPC/KUSER time, SuspendThread preemption, stdcall via syscall_syscall*, callbacks via compileCallback → continues as Windows runtime port (1.18+).

Earlier history: Windows runtime port (Go 1.0 → Go 1.4)

Design. Windows ABI calls go through asmstdcall using libcall structs (414444d416), argument sizes encoded as Foo%3 import decorations for external linking (6112e6e404), float arguments returned in XMM (450d0b2f30, 9c02c75639). exceptionhandler / lastcontinuehandler are architecture-independent in signal_windows.go (6e774faed7, d1af6bed84), with CTRL_* events mapped to SIGTERM (5d1a95175e). Stack sizing is a recurring theme: unified PE header and runtime reservation (da11a9dda3), 2 MB on amd64 always (c2c07c7989) and 1 MB on 386 (77ea9f9f31), query real size (99e9be8043, 52e782a2d6, d6b56bb301). Timers: reduce resolution when idle (11eaf42886), osyield via SwitchToThread (1f5b1b2b66), usleep with CreateWaitableTimerEx high resolution (515e6a9b12, 6965b01ea2), suspend/resume monitoring (d85072ff86, 056a3d1c6f, d2de9bd59c, d467f3bbc9). Callbacks: syscall.NewCallback fix for sub-word arguments by building a C→Go frame map from the signature (532c199ee5, bda37a0b8a), compileCallback for the ctrl handler (e512bc2cf0), externalthreadhandler eliminated (c19759aa48, 5421c37a1d), newm for profileloop (e69f02265c), set up read-only dummy TLS for needm on non-Go threads (31d2556273, fef5a15396), all necessary registers saved on entry (dba2eab826). Windows/ARM arrived in 1.12 and windows/arm64 in 1.17 (see ports).

Timeline.

• Go 1.5 — Done: WER dialog suppressed (03d6637dbb), VEH on XP (77f4571f71, d5004ee69e), unified stack reservation (da11a9dda3), goenvs (a88d709268), exception trace output (e544bee1dd), sysargs and pipe fixes.
• Go 1.6 — Done: WriteConsole for print/panic (d958881271), NumCPU with affinity (6410e67a1e), timeBeginPeriod removal then revert (ab4c9298b8 in 1.7), msvcrt link (0b5bcf53ee), larger assumed stack in handlers (fdf9b3c994), usleep2 params (d7c12042bf).
• Go 1.7 — Done: only search System32 for DLLs (683448a304), SwitchToThread osyield (1f5b1b2b66), c-archive on Windows (ed8f0e5c33), XMM callee-saved in cgo (71916437fb), framepointer mode safe on Windows (d9557523c2).
• Go 1.8 — Done: RtlGenRandom (db82cf4e50), semaphore error checks (1a3b739b26), XMM float syscall args (9c02c75639), msvcrt/math/threads libs not linked by default (dd307da10c, 9ac60181e2, f595848e9a), CreateThread panic on exit (f24384f686).
• Go 1.9 — Done: reduced timer resolution when idle (11eaf42886), 2 MB stacks (c2c07c7989), syscall.Exit uses runtime.exit (cfae35efa5), time on Wine (9f98e49825).
• Go 1.10 — Done: 1 MB stacks on 386 (77ea9f9f31), syscall.Exit (438c8f6b53).
• Go 1.11 — Done: abort handling (7001ac5394), g0 stack bounds (52e782a2d6, 99e9be8043, d6b56bb301, 78561c4ae9), profileloop races ( in 1.12).
• Go 1.12 — Done: windows/arm (d24ec86e4f), Syscall18 (e8df7df68f), case-insensitive env (f08352bd16), unminit/profile race (c216c3aa9f).
• Go 1.13 — Done: safe DLL loading (9b6e9f0c8c), NewCallback returns all bits (5cf4e442a5), windows-amd64-2012 build (ef4666ecce).
• Go 1.14 — Done: ExitProcess/preemption protocol (957259b7e2), DLL lastcontinuehandler (e5e5fb024a), control events (5d1a95175e), Wine hacks removed (b4ad49f9f7), profile thread validity (6fd467ee29), m.thread in mOS (91bb1d734e).
• Go 1.15 — Done: always use GetQueuedCompletionStatusEx (e3cf0525b0), float syscall returns (450d0b2f30), DLL signal no-exit (5756808ce8).
• Go 1.16 — Done: CreateWaitableTimerEx usleep (515e6a9b12, 6965b01ea2), ctrl handler no longer exits (c0dded04f7, 8cfa01943a), DuplicateHandle error detection (682a1d2176), event handle freeing (dbab079835), sub-word callback args (532c199ee5), windows/arm callbackasm1 (4d048194cd), abort address on windows/arm (0252cfd84d).
• Go 1.17 — Done: windows/arm64 (3527caa7d6, 427bd7599d, c7c6c113be, 16330817aa, 76ab626bfc), long paths without fixup on Windows 10 1607+ (b8371d495b), Windows callback improvements for the register ABI (44dd06670f, 4356e7e85f, 836dbdb15b, 639cb1b629, ab02cbd29f), windows/arm fixes (75e273fc2c, 91cc484ea9, 5421c37a1d, c4b771348c, 080119799b, fbe74dbf42), profiler finds g by SP (ece954d8b8), abort crashes earlier (38672d3dcf), setlasterror removed (678568a5cf), non-Go-thread signal abort (cd28ca3a4e).

CPU feature detection (internal/cpu), auxv parsing and GODEBUG=cpu.*

Span: Go 1.9 → Go 1.17 · Status at go1.17: internal/cpu is the single detection layer (x86, arm, arm64, ppc64x, s390x, mips64x) with GODEBUG=cpu.feature=off/on → continues as CPU feature detection, GOAMD64 checks and cpu GODEBUG options (1.18+).

Earlier history: Startup, auxv, randomness and security-adjacent runtime details (Go 1.0 → Go 1.4)

Design. Before 1.9 each arch kept support_* flags in the runtime. internal/cpu (69972aea74) gathers detection into one dependency-free package; x86 detection (66bfbd9ad7, FMA 1a3230f281), ppc64x via HWCAP (6661cf6dfd), s390x facilities via STFLE and HWCAP; the runtime then uses internal/cpu for alginit, AVX/AVX2 memmove and IndexByte choices (954f651ccc, 6b5236ae53, e0ac5f540b, d0712096b3, ace5fa1a60, 91d326e734, b64e817853). GODEBUGCPU (compiler experiment debugcpu, 1.11: f045ddc624) lets one disable features by name; 1.12 makes the syntax off/on with warnings (4fb8b1de3c, 3e0227f6a0, 980340ade7) and moves it to GODEBUG=cpu.feature=value (2de53906e1). Detection widened: ARM hardware divide (2e8c31b3d2), FMA (bb3bf5bb53), CacheLinePad in place of sys.CacheLineSize (7b9c2c1950, 60f83621fc, 961eb13b67), AIX (cb07f492db), s390x API aligned with x/sys/cpu (1f17d61026, ba978f5fff), MIPS64x (e48a83f077), s390x/ppc64/AIX HWCAP moved in (f8aecbbff5, 96bd0b1d4c), arm64 consolidation (de932da453) and darwin/arm64 (c155931974), testing prints CPU label via internal/sysinfo (b7a2d413a3), FMA disabled without OSXSAVE (dda2991c2e). Per-arch asm: arm64 memmove with a flag preferring aligned loads/stores (d5388e23b5), IndexByte/memclr SIMD on arm64 (d259815ccb), arm64 crc32, 64 byte cache line on arm64 (e0e7c03d14), arm64 LSE atomics added in 1.17 (07ff596404) after being disabled on Android (efd229238a).

Timeline.

• Go 1.9 — Done: internal/cpu created (69972aea74), crc32 on arm64 (ab636b899c).
• Go 1.10 — Done: ppc64x detection (6661cf6dfd), x86 FMA (1a3230f281), x86 detection moved into internal/cpu (66bfbd9ad7, b3ee6f0c2e, c4ee0e2a8b), cache line size 64 on arm64 (e0e7c03d14), ADX assembler support (44943aff33).
• Go 1.11 — Done: GODEBUGCPU experiment (f045ddc624), naming cleanups (57020705f3, 7289607b1b, d46980995b), runtime uses internal/cpu (954f651ccc, 6b5236ae53, e0ac5f540b, d0712096b3, ace5fa1a60, 91d326e734), crypto/tls use common detection (3f2039e28d, 7ba0c6235f).
• Go 1.12 — Done: GODEBUG cpu options (2de53906e1, 4fb8b1de3c, 3e0227f6a0, 980340ade7), ARM hw divide (2e8c31b3d2), cache-line padding (7b9c2c1950, 961eb13b67, 60f83621fc), AIX detection (cb07f492db), z14 (897e0807c3), constants typed (2556df0ac0, 21ac811924, bb3bf5bb53).
• Go 1.13 — Done: s390x API alignment and new ECDSA/EDDSA caps (1f17d61026, ba978f5fff), remove FreeBSD workarounds (3b6216ed06), physHugePageSize (1033065ee3, 7fcba81549), openbsd/arm64 HWCap (08b956f378).
• Go 1.15 — Done: MIPS64x features (e48a83f077), anonymous struct feature vars (b79acf97c7), VZEROUPPER guard (c46ffdd2ec).
• Go 1.16 — Done: arm64 consolidation (de932da453), explicit no-init archs (feb984c96b), s390x/ppc64/AIX moved (f8aecbbff5, 96bd0b1d4c), darwin/arm64 (c155931974), FMA/OSXSAVE (dda2991c2e), benchmark CPU label (b7a2d413a3), netbsd/arm64 HWCap (1f4d035178).
• Go 1.17 — Done: LSE atomics on arm64 (07ff596404), internal/atomic extended to match sync/atomic (af1789a61c).