Backends and assemblers

Part I · 85 threads in 5 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

Backends and assemblers (Go 1.0–1.6)

Reader: Claude Sonnet. Cites 1,322 of 1,498 commits in this slice; every non-noise commit is cited, plus 25 larger commits the noise filter had set aside, which a separate gap reader described. Skimmed the design-heavy messages; the ppc64 and nacl threads rest mostly on subject lines. About 500 small commits are cited in grouped items.

Per-architecture compilers 6g/8g/5g/9g and the shared gc code generator

Span: Go 1.0 → Go 1.6 · Status at go1.17: the Prog-list code generators were replaced by the SSA backend (1.7 onward, other area); in 1.6 they still existed as Go packages cmd/compile/internal/{amd64,x86,arm,arm64,ppc64,mips64} → continues as Register-based calling convention (ABIInternal) ports beyond amd64 and amd64 code generation and GOAMD64 microarchitecture levels (1.18+)

Continues in: Removal of the legacy backend and decoupling gc from the code generators (Go 1.7 → Go 1.9)

Design. The compiler was one front end (src/cmd/gc, C plus yacc) and one back-end directory per architecture, each a copy of the same structure: gsubr.c (instruction emission gins, regalloc/regfree, gmove, optoas mapping Go operators to machine opcodes), cgen.c (expression code generation: cgen, agen, bgen, sgen), ggen.c (calls, clearfat, divide, shift), galign.c, and reg.c/peep.c for the optimizer. Code generation was a Sethi-Ullman tree walk: ullman numbers decide evaluation order (0eda21a2fd made the minimum 1 so “not computed” and “trivial” differ), registers come from regalloc, and running out gives “out of registers” (made a fatal error rather than a recoverable path in 5g/8g in 1.4, c1c5d479bd). Many bug-fix commits are the same fix applied three times (6feb61325a, 7e144bcab0, 0b2353edcb, 46fcfdaa7d).

6g (amd64) came first (0cafb9ea3d; div/mod d83b994da6; shifts and multiplies f7753f1687; floating point 36bfd2a906). 8g (386) started as “minimal 8g” on 2009-03-31 (dc5b4678e2), grew 64-bit arithmetic through register pairs (a8e4ed6a3d, split into cgen64.c by ab3d40b271) and x87 float with float→integer conversions that emulate the x86 overflow results 1<<15/1<<31/1<<63 (a00bfb5b49). 5g (ARM) was copied from 6g on 2009-05-01 (eac5db7f4c), “rebooted” 2009-05-28 (63e1b714de), and stack splitting for ARM arrived in a grab-bag change (1ac2cfc720); function literals b4896b496e; hardware float came later (9c6df3ca13, after software float 69188ad9bb).

Shared logic was hoisted into cmd/gc over time: portable statement generation and signature generation (bac922c6e1, 5e792b6c09, d30285a6f5, 531f242f5d), static initialisation (62231e91d0, da49bfe664, moved to gc cb49a999d1), division by constants (34f76b5de5), the walk-pass division rewrite (4cc9de9147), proginfo tables (1.2), and in 1.5 the wholesale unification of cgen/regalloc (b115c35ee3, “cutting 5 copies to 1”; motivation: a following change would implement x.(*T) without a runtime call, now 5x easier). Alignment became explicit and per-type in 2010 (e7a0f67603, groundwork for max-field alignment, issue 482).

Timeline.

• Go 1.0 — Done:
  • 2008: 6g emits amd64 (0cafb9ea3d, d83b994da6, f7753f1687, 36bfd2a906, method/interface code 8231e94520); morestack magic number $a-b produced by 6g and 6c (3f982aeaf6); fat-copy and overlap fixes (30fd44cf9d).
  • 2009: 8g and 5g created and bootstrapped (dc5b4678e2, a8e4ed6a3d, 3aa006b8cd, eac5db7f4c, 63e1b714de, 190b5c9ad2, 4556c04d8b, 86987055a3, 6d0983ae46); nil-pointer checks in 8g (9dd2e1e30f); inline x[lo:] slicing (652f55672d, 9bf597a210, bf0130cc0f); Go types in the object symbol table (43f29e64a6); first attempt at bounds-check elimination for range and [256]array[byte] (fdb030d86f); 8g bounds failures call throwindex (dc30800c28).
  • 2010: complex numbers (426099f42e for 6g, f229c8b546 identical 6g/8g with 5g a stub, b0ad7a4268 5g regalloc for complex); string index inlined in all three (e48c0fb562); amd64 TLS moved to segment memory so R14/R15 return to the register pool (e473f42b2d); ARM hardware float (9c6df3ca13); O(1) string compare when lengths differ (30dd191171); dead code elided (410927d1ad).
  • 2011–Feb 2012: explicit alignments (e7a0f67603), inline append when len<cap (d6b2925923), compact stack frames (2ac375b2df, ARM 2ad42a8249, unified layout 5ddf6255a1), f() < g() order (bac8f18035), goto restrictions (7f4c5ea7d8), interface ==/!= fast-path on differing types (f91cc3bdbb, ~3x for err == io.EOF), correct boundary checks in all compilers (6ed2b6c47d), NOPTRBSS for large pointer-free data (5bcad92f07). Left open: 6g still had 32-bit int; 5g and 8g trailed 6g in code quality.
• Go 1.1 — Done: user-visible int becomes 64-bit on amd64: the compiler first learns len/cap are int (650160e36a), then flips (10ea6519e4, assembly offsets converted mechanically). 6g may use R14/R15 (8f8640a057) and all 16 SSE registers (57ad05db15); 8g imports componentgen (ae0862c1ec; LEAL count for cmd/go 89774 → 47548), igen cases (f4e76d5e02), no address-of-slice for &s[i] (2de064b63c, acbe6c94d7 for 6g); panicindex out of line (fefae6eed1); contiguous loop layout (001b75c942); 5g backports of 6g constant-operand code (7b36acc4ac, ed0c5dd11f, bbccfddb84, 01ddc8bd9a, 905e8dfa27, d8008a9eef, 3dcc63f750, 5bdf40dcca, bdd9f29780); user-visible GO386=387|sse selects FPU flavour, default 387 (9afb34b42e); method values (d3c758d7d2); closures without runtime code generation (9f647288ef) after the indirect func-value representation (1903ad7189); explicit TYPE pseudo-instructions for locals (1d5dc4fd48). Left open: no auto-detection of SSE2 (commit: “no auto-detection is performed”).
• Go 1.2 — Done: trampolines moved to portable code (1f51d27922, 31be5deae4), proginfo in every back end (see optimizer thread). Left open: nothing noted.
• Go 1.3 — Done: the back ends link against liblink (f606c1be80) and start emitting code for the new liveness maps (f056daf075); amd64p32 initialisation linkarchinit (e31a1ce109, d4896fb876), register-width stack alignment (3d5e219e02).
• Go 1.4 — Done: registerize small structs/arrays in 5g and 8g (527ae57e65); explicit zeroing simplified so *x = T{} needs no write barrier (3c40ee0fe0); fatal “out of registers” (c1c5d479bd); 5g does not make register variables for directly called functions (bb4a358af3).
• Go 1.5 — Done: back ends converted to Go and moved to cmd/internal/gc (8c195bdf12, 3af0d791be); portable cgen/regalloc/componentgen (b115c35ee3, b960263244), reg.c portable (ad88fd1d4a), cmd/gc made a library (349ecfb0d6, eb1774fa19); 9g and 7g added (see port threads); go tool compile/go tool link replace 5g/5l etc. (17eba6e6b7). Left open: machine-translated C idioms (goto, pointer arithmetic) cleaned only gradually (4492811c05, acba34e45f).
• Go 1.6 — Done: mips64 back end copied from ppc64 (14f919578d, d5cd4ab46a); Etype/Op named types and bool fields (8e7a3ea11e, 8712e1867b, 259466452d, 05c35ac5d1); 387 builds stop using fucomi* (3d01f28e47). Left open: the SSA backend (dev.ssa) was the planned replacement for amd64 in 1.7.

Register allocation and the peephole optimizer (reg.c, peep.c)

Span: Go 1.0 → Go 1.6 · Status at go1.17: replaced by the SSA register allocator; the old optimizer was gone before go1.17 → continues as Register allocator, scheduler and block-level backend passes (1.18+)

Continues in: Register allocation, flag allocation and stack slots (Go 1.7 → Go 1.11)

Design. On top of the on-the-fly regalloc, each back end had reg.c (called regopt) and peep.c. regopt builds a flow graph (Flow/Reg) over the Prog list, assigns each local/arg/global a Var (a bit in Bits sets), solves liveness, and “paints” (paint1/paint2) non-address-taken variables into free registers when width, stack offset and etype agree. peep does copy propagation (copyprop/copyu/subprop), redundant-move removal and fixjmp. First cut 2dd16a3208 (2008-11-18) and e081f25c3e; registerization of builtin structures (strings, slices, interfaces) 3dc3ef4cf7, 96cbdd62b6; large functions skipped (bc15b94181).

Correctness drove most of the work: liveness for registers was added to 8g in 2011 by modelling each machine register as a pseudo-variable (84f291b1bd), so a temporary whose range was nested in a live BX span could no longer receive BX; one commit (e419535f2a) repaired a regression that registerized nothing (“2-3x slower”); loop detection was confused by dead code with rpo 0, fixed together with a JMP-to-JMP squashing pass (e2d326b878). In 1.2 the per-opcode switches duplicated across reg.c/peep.c were replaced by proginfo (instruction flags plus registers set/used/indexed): the 6g version (24c8035fbe) found that copyu listed neither INCB, JPS, MOVAPD, MOVBWSX, MOVBWZX, PCDATA, POPQ, PUSHQ, STD, TESTB, TESTQ nor XCHGL and needc only a handful of carry-using instructions; 8g and 5g followed (ac0df6ce89, a07218385c), flow-graph code moved to portable popt (b3b87143f2, dbf96addfb).

Timeline.

• Go 1.0 — Done: optimizer and indexing/op= improvements (2dd16a3208, e081f25c3e, a6182dab47, 9a5c7eab16, c8a66a98ff); constant propagation for assignments (567a7bf664); 8g optimizer (0eb2a79ff3, 4ab0ce107a); aliasing fixes (bedfc2c2f1, cd00bc78da); ARM optimizer (90ca4d75a4, 4ed17ceace), disabled for the release (1c99bdc8e5, d88f717da6), peep re-enabled (1f55105f66, 2799e0ecb9, dc331e6565, 63c24081a0); register liveness (84f291b1bd); “registerize variables again” (e419535f2a); loop finding (e2d326b878); flush modified globals aggressively (8998835543); constant propagation friendly to inlining (fff732ea2c); byte-move rewrite in 8g with up to -69.83% on crc32 (23f6479be6). Left open: ARM peephole disabled in releases; optimizer bugs recurring.
• Go 1.1 — Done: 5c regopt re-enabled (70db440885); 6g peephole (3d3b4906f9: shifts do not stop subprop, redundant MOVLQZX removed, early loads); fixjmp for 6c/8c (5cb1ed2189); ONAME nodes recycled to denote registers (45fe306ac8); return registers optimizable (b73a1a8e32, bdd9f29780); 8g drops redundant temporaries before regopt (fa316ba4d8, 14f3276c9d, extended to SSE2 cf77dd37e7: Erf frame 220 → 84 bytes, Lgamma 948 → 44); 5g peephole reactivation incl. EOR → MVN and MOVB elimination (542dd8b9fb, 3f26c5e124); short-integer arithmetic eliminated where possible (8f3c2055bd); componentgen for 5g and for small arrays/structs on 6g (ee3e2ac1a6, 16072c7497, 022b361ae2: the 64-bit int had made it ineffective); 6c rotate/shift peephole (41ec481a53, bb192d1399: (x<<a)|(x>>b) becomes a rotate).
• Go 1.2 — Done: proginfo in all three (24c8035fbe, ac0df6ce89, a07218385c, 9a0a59f171); portable optimization logic and flow graph (b3b87143f2, dbf96addfb); temporary-merging pass using greedy linear scan (Poletto-Sarkar), cutting the number of functions with too many vars in godoc from 83 to 32 (fa72679f07, 72636eb506); O(n) reset loop removed from copyprop (6d47de2f40); faster compilation by memset (06e686def6); MOVBS/MOVHS pseudo-instructions on ARM to make short-integer semantics explicit (3670337097, 357f733695). Left open: the back ends only track the first 128 variables per function (commit text, fa72679f07).
• Go 1.3 — Done: no credit for NOPs in allocation (1848d71445); more aliasing by fixing etype mismatches (03c0f3fea9, 0a8a719ded preserve wide values in large functions); globals and results flushed/loaded correctly (f5184d3437); undefined instruction has no successors (85e4cb2f10); liveness-aware regopt fixes (26ad5d4ff0, 684332f47c, 1afbceb599: fat vardef-initialised variables live at calls; up to 7% slower end-to-end).
• Go 1.4 — Done: register variables for small structs/arrays on 5g/8g (527ae57e65); registerized addr nodes cleared so full registerized temporaries stop reserving stack (be2ad1d7f5); optimizer failure fatal in the C compilers (3147d2c4ee).
• Go 1.5 — Done: float-constant propagation and MOVSD $0 → XORPS (43c87aa481); 9g regopt (743bdf612a) and peephole (ed5488eece); Bits as uint64 array (fa32e922d5); registerization limits raised (d47fe8092e) and extended to 7g/9g (e040fd4654); cached ProgInfo (fd38dbc8a1); reg.c portable (ad88fd1d4a); debug prints (5b38501a4f). Left open: generated temps in bool codegen (a44becef4a) still produced extra moves.
• Go 1.6 — Done: register fix for == (6ec1809b83), regopt must not use REGTMP on ppc64 or CX in PIC (0357c38adf, 61da0e92d0, 9514285da9); AVARLIVE in peep for arm/arm64/mips64/ppc64 (5f23bc8903); duffcopy clobbering X0 (ffb20631fc, 0bef88aa5f).

Expression and statement code quality in 6g/8g/5g (division, bounds checks, loops, slices, interfaces)

Span: Go 1.0 → Go 1.6 · Status at go1.17: superseded by SSA rules and lowering → continues as amd64 code generation and GOAMD64 microarchitecture levels (1.18+)

Continues in: amd64 and 386 instruction selection (Go 1.7 → Go 1.11)

Design. A long run of targeted improvements, each tied to a benchmark. Integer division by constants was implemented in 6g in August 2009 (f1baf78247 powers of two; 34f76b5de5 “integer division by a constant done”, with rotate-carry instructions) and in 1.1 moved into the walk pass (4cc9de9147) so 5g and 8g got shifts and magic multiplies; 64-bit division stayed in 6g, and restore magic multiply for /=, %= (061061e77c). Bounds checks: panicindex calls moved out of line so hot loops hold more useful code per cache line (fefae6eed1; two new instruction forms with expected-not-taken branches reversed); loop conditions marked likely so loops are laid out contiguously (001b75c942, replacing expecttaken); conditional branches gbranch take a likely argument. Slicing: x[lo:hi] expanded in the front end (40af78c19e), copy to a direct memmove call with a new OSPTR node for the data pointer (ff416a3f19), convT2E inlined for uintptr-shaped T (8f84328fdc).

Timeline.

• Go 1.0 — Done: divide-by-constant (f1baf78247, 34f76b5de5), 8-bit div/mod (3f91f80a21), inline slicearray/sliceslice (9bf597a210, bf0130cc0f), x[lo:] (652f55672d), scaled indexing (c8a66a98ff), 64-bit shift fix (e5bd12ea90), NaN-safe comparisons (109a976355, ef46a9ddac), avoid unneeded conversions in bounds checks (d14baee96e), a[byte(x)] truncation (ba50599e46), bounds checks off support (c332ff42fe), 8g: float->uint64 (a551ffe809, f570d9d765).
• Go 1.1 — Done: out-of-line panicindex (fefae6eed1), contiguous loops (001b75c942), rotate code (c6ce44822c, later partly rolled back for 8g 251199c430), float->uint64 truncation fix (e80f6a4de1), inline slice[arr,str] (40af78c19e), convT2E (8f84328fdc), nil-comparison without extra agen (ff642e290f), no LEA of interfaces on method calls (b45b6fd1c7), 6g float move without MOVSD between registers (a768de8347), sbop swap logic (de96df1b02), simplified integer division (a617d06252), zerostack experiment: user-visible GOEXPERIMENT=zerostack clears the stack on function entry to avoid GC false positives (b7603cfc2c); cmd/gc: avoid duplicate allocation during inlining (a72f9f46a2); large-model flag for 6c/6g (fe14ee52cc); more nil-pointer-to-large-struct checks (578dc3a96c). Left open: zerostack was expensive (the commit says so) and opt-in.
• Go 1.2 — Done: copy inlined as memmove (ff416a3f19), nil-check on &x and removal of redundant &x.Field checks (999a36f9af, aa0439ba65), 6c/8c avoid long multiplication (2c0b00744f), full 64-bit address in block copy (f268c295a3), very wide offsets (9c21ce54dd), no constant propagation of non-constant LEA (3c3ce8e7fb), clearfat de-interleaved (85a7c090c4), defer caller line numbers via a real NOP (7e97d39879; XCHG AX,AX / AND.EQ R0,R0,R0).
• Go 1.3 — Done: 6g inline copies of up to 4 words, after reflect.Value grew to 4 words and json fell ~50% (to ~5%) (0ea20bc981); unaligned load/stores for trailing bytes in sgen/clearfat (2b93c4dd06); small zeroings in straight-line code (14664050b9); bypass DATA for integer-constant data (4acb70d377); a register for nil-checking constants (52e6d7c622).
• Go 1.4 — Done: explicit zeroing without write barrier, MOVs instead of repeated STOSQ (3c40ee0fe0); extern = <N> code (0edafefc36); no address-as-constant in amd64 instructions (ce35994d4e).
• Go 1.5 — Done: float-constant propagation (43c87aa481), componentgen on string constants (94410c794e), zero via register (01ef6dbfa5, 8f734d4e2f), 2- and 3-word sgen (747c849833, c1c3ce6b36), boolean values via SETcc instead of jumps (13cb62c764), hardware math.Sqrt on amd64/arm (92dba0d278), runtime.getg inlined (92c826b1b2, garbage benchmark +2.6%), MOV instead of LEA 0(R0) (0f0bc0f016), shifts for power-of-two indexing (135389d0ff), write-barrier-aware slice update x = x[:i] (d447279927) and typedmemmove from sgen (2a73559023, 2b7505e28a for RISC), panicindex marked as not returning (fc595b78d2), ginscmp hook (f8d14fc3a0), generated temps in bool codegen (a44becef4a), missing write barrier in append(x, BigStructWithPointers) (366ba526e8, 9c9e36b340).
• Go 1.6 — Done: test-first-field-of-struct special case for amd64 and 386 (9aed0b7e3d, f3b064ae01), magic-multiply no longer smashes AX (03c8164849), write barrier on type switch (e3033fc535), Syscall-like functions for liveness (1ac637c766), args_stackmap not for func _ (292ad59291).

Stack frames, pointer maps and liveness analysis in the compiler

Span: Go 1.2 → Go 1.6 · Status at go1.17: liveness analysis (plive) and per-call-site stack maps remain; pointer bitmaps are still 1 bit per word → continues as Stack slot merging, liveness and stack maps (1.18+)

Continues in: Liveness, stack maps, safepoints and write barriers (Go 1.7 → Go 1.11)

Design. Precise stack scanning needed, for every call site, a map of which frame slots hold live pointers. Go 1.2 built the plumbing: the C compiler emits argument pointer maps (9b1f1833de) and locals bitmaps (73c93a404c); a dedicated FUNCDATA number carries the runtime’s GC metadata, and the old pseudo-instructions and linker code that handled them are removed (48769bf546); the assemblers learn PCDATA/FUNCDATA (47b89a37d9, 8c741c97f7); cmd/cc records the size of locals (e4b5cbde46) and the argument size for every call (4e141145b7, 7b3c8b7ac8); interface and eface words are encoded distinctly in the map (abc516e420) so the collector can use the type word to decide whether the data word is a pointer (21ea5103a4). Because the maps could still see stale slots, pointers in the frame and the results are zeroed on entry (7910cd68b5, “up to 30% slowdown”, an “intermediate step”), with “has pointers” separated from “needs zeroing” (3b4d792606).

Go 1.3 computed the maps by dataflow liveness (f056daf075): a backward analysis over the flow graph yields, at each safepoint, the set of live pointer-bearing slots (“mean reduction of 65% in the number of stack slots scanned” under GOGC=1 all.bash), but the commit notes scanning was still not precise because pointers confound reaching definitions. Variables are tracked as whole units; compiler-inserted VARDEF marks the start of life for fat variables, placed “before the initialization but after any final use” (7a7c0ffb47), and VARKILL ends the life of temporaries whose address went to runtime map/chan calls (b700cb4974). Variables that are “ambiguously live” (live on some paths, uninitialised on others) are zeroed on entry; only those are zeroed after 6722d45631 rather than all pointer-bearing locals, with address-taken-but-non-escaping variables handled in ca9975a45e. In 1.4 assembly functions get maps derived from their Go prototypes (myfunc.args_stackmap, 99f7df0598), slices and strings are treated like pointers (613383c765), and argsize PCDATA is no longer generated (68c1c6afa0). In 1.5 the stack, data and bss maps shrink to 1 bit per word because there are no multiword GC types left (4d0f3a1c95).

Timeline.

• Go 1.2 — Done: funcdata/pcdata plumbing (48769bf546, 47b89a37d9, 8c741c97f7, de6da4a8bd), C and Go argument/locals bitmaps (9b1f1833de, 73c93a404c, 2db5e4bb0b), interface encoding (abc516e420, 21ea5103a4), zero pointers on entry (7910cd68b5, 3b4d792606, d3b04f46b5, 390656affd), nosplit pointer maps from the linker (037a1a9f31), . Left open: maps conservative; liveness analysis not written (commit text: “intermediate step”).
• Go 1.3 — Done: liveness-based maps (f056daf075; d4f68f2892, 6965a752a7, bc9691c465 dead-value maps disabled/renamed), compile-time speedups (0e97f4187e: up to 7x, 145edc283f), many correctness fixes: addressed results 824e918ca4, block-move init 91b1f7cb15, tail-jump wrappers 02ae91f342, funcs ending in panic ab9e8d068a, non-returning functions af545660d5, fat variables 7a7c0ffb47, no fallthrough edge after panic 28479f2c32, zeroing to enable precise stack accounting a81692e265 (only effective with a debug flag), zero only ambiguously live variables 6722d45631, 1ca1cbea65, VARKILL for runtime-call temporaries b700cb4974, stack map entries redone to avoid false retention 1b45cc45e3, don’t zero more than needed 47acf16709, relaxed zeroing in 6g f400d9aafc, input variables vs regopt 26ad5d4ff0, globals/args/results f5184d3437, vardef-initialised fat variables live at calls 1afbceb599 (slowdown up to 7%), reflect.callXX maps cee8bcabfa. Left open: zeroing “pretty inefficient” (issue 7624) and too many ambiguously live variables (issue 7345).
• Go 1.4 — Done: local type information is emitted explicitly (see the 1.1 note on 1d5dc4fd48^1.1, 43c04ba1b8^1.1, aa3efb28f0^1.1); args_stackmap for assembly functions from Go prototypes (99f7df0598), slices/strings scanned like pointers (613383c765), all G frames copyable (00365b13b4), argsize PCDATA dropped (68c1c6afa0), auxiliary symbols marked pointer-free (8b20e7bb7e), runtime package decls never heap-promoted (064acace5b), liveness ~10x faster (7aa3031eba), invalid GC pointer crashes (11e53e46a6), emit code for extern init (0edafefc36).
• Go 1.5 — Done: 1-bit stack/data/bss bitmaps (4d0f3a1c95), fixed-size frames in goproc/deferproc (53c5226f9f), larger stack guard for unoptimized builds (a55b131393), liveness debugging (fa7efa2cb0), gc: restore stack frame debugging (aed88be021). Left open: nothing noted.
• Go 1.6 — Done: Syscall-like assembly functions recognised for liveness so arguments stay live for the whole call (1ac637c766); no args_stackmap for func _ (292ad59291); AVARLIVE in peephole passes (5f23bc8903).

Stack frame layout, prologues, stack split and frame pointers

Span: Go 1.0 → Go 1.6 · Status at go1.17: prologue generation per architecture in cmd/internal/obj/*; frame pointers kept on amd64 (default) and arm64 → continues as Prologue, frame pointer, stack split and function alignment (cmd/internal/obj) (1.18+)

Continues in: Prologues, frame pointers, NOFRAME and tail calls (Go 1.7 → Go 1.11)

Design. Segmented-stack prologues are emitted by the assembler/linker pass (originally in the linkers, from 1.3 in liblink and then cmd/internal/obj/<arch>/obj*.go): compare SP (or SP minus frame) with g->stackguard and call runtime.morestack, with the frame and argument sizes passed via a magic $a-b operand (3f982aeaf6, 2008). The compilers lay out locals: 2011 saw compaction by sharing slots (2ac375b2df, ARM 2ad42a8249) and a unified layout (5ddf6255a1); 6c/8c frames were cut about in half in 1.1 (139448fe95). In 1.5, with the ARM and arm64 and x86 prologues, “static branch prediction guesses forward branches aren’t taken”, so the forward branch now means “grow” (f4b48de3ad x86, 54789eff38 arm64) and ARM executes one conditional branch rather than three conditional instructions, adding 4 bytes per function (5353cde080). Knowledge of the fixed part of the stack frame was centralised (97055dc1f1) because ppc64le shared libraries need the TOC pointer at 24(R1); larger frames raised the nosplit limit (c1b6e392f5).

The framepointer GOEXPERIMENT (1.5) makes the amd64 toolchain keep BP chains like gcc -fno-omit-frame-pointer so Linux perf/VTune can unwind Go stacks: compilers don’t clobber BP and liblink emits the saving prologue (3c0fee10db); duffcopy/duffzero are fixed for it (08af4c3a79).

Timeline.

• Go 1.0 — Done: morestack magic operand (3f982aeaf6), stack-split segment size bug (cb15bbe748), argsize rounding smash on 32-bit (de663b2d6b), 5l morestack for ARM (1ac2cfc720), NOSPLIT checks in cc (36c5c5bf40), frame compaction (2ac375b2df, 2ad42a8249, 5ddf6255a1), .
• Go 1.1 — Done: 6c/8c stack frames cut by about half (139448fe95), clearstk deleted (96b0594833), fix for large stacks (d127ed5378).
• Go 1.2 — Done: pointer-map-aware zeroing of frames and stkptrsize (d3b04f46b5, 390656affd).
• Go 1.3 — Done: register-width stack alignment for amd64p32 (3d5e219e02), zero at start of frame more efficiently (383963b506), NaCl zeroing (bfbb2e827b).
• Go 1.4 — Done: ARM wrapper prologue (fb818eab7f).
• Go 1.5 — Done: frame pointer experiment (3c0fee10db, 08af4c3a79, 90c0fefe51), predictable prologues (f4b48de3ad, 5353cde080, 54789eff38), correct pc/sp info for the prologue (0a3c991fd3), arm64 frame alignment (3952057cf6, 034a10d44c), stack guard (a55b131393), Link.Symmorestack removed (4b23b50fb4), 386 prologue fixes in position-independent mode.
• Go 1.6 — Done: x86 functions aligned and padded with INT $3 (0xCC) rather than 0x00 which can decode as valid instructions (7d2c6eb3f5); PCSP table fixed at morestack calls (66f1f89dc0); fixed stack part centralised (97055dc1f1); ppc64x stack limit raised (c1b6e392f5); stack barriers in ppc64le shared libs (3a1bed82a6).

Zeroing and copying: Duff’s device, REP, unaligned moves and AVX2 runtime assembly

Span: Go 1.0 → Go 1.6 · Status at go1.17: duffzero/duffcopy still used by amd64 at go1.17 → continues as Duff’s device replaced by generated loops; Zero/Move lowering (1.20+)

Continues in: Memory clearing and copying: Zero, Move and Duff’s device (Go 1.7 → Go 1.11)

Design. Compiler-generated copies and clears (sgen, clearfat) went from REP MOVSQ/STOSQ to straight-line code and Duff’s device. In 1.0 the convention was that the direction flag is always clear (8f53bc0612) so the compiler could emit memcpy/memset as REP. In 1.3, since REP has “really high startup overhead”, 6g inlines copies up to four words (0ea20bc981, after reflect.Value grew to 4 words and json went ~50% slower), uses overlapping unaligned loads/stores for trailing bytes (2b93c4dd06), zeroes small objects in straight-line code (14664050b9), and the runtime uses a Duff’s device instead of REP (6c7cbf086c, 51b72d94de, 383963b506). In 1.4 repeated STOSQ became MOVs (3c40ee0fe0). In 1.5 2- and 3-word sgen were special-cased because they are 85% (6g) / 70% (8g) of sgen calls (747c849833), and duffzero used MOVUPS to zero 16 bytes at a time (2421c6e3df). Duff’s device is disabled on NaCl (c6a41a3559) and on Plan 9 for duffcopy (50ad337238) and ppc64 duffzero (cda1fc0071).

Timeline.

• Go 1.0 — Done: direction-bit convention (8f53bc0612), fat copy overlap (30fd44cf9d), reverse character copy in sgen (1d0b65d33f).
• Go 1.3 — Done: the changes listed above (0ea20bc981, 2b93c4dd06, 14664050b9, 6c7cbf086c, 51b72d94de, 383963b506); Duff off on NaCl (c6a41a3559). Left open: “TODO: REP still used for reverse copying when regions overlap”.
• Go 1.4 — Done: 3c40ee0fe0;
• Go 1.5 — Done: 747c849833, c1c3ce6b36, 01ef6dbfa5, 8f734d4e2f (zero via a register in componentgen), faster aeshash hashing several streams in parallel (7a4a64e8f3).
• Go 1.6 — Done: MOVUPS-based duffzero (2421c6e3df), AVX2 versions of Compare, string compare, IndexByte and memclr (0e23ca41d9, 967564be7e, 321a40721b up to -49% at 4K, b597e1ed54), SSE4.1 Floor/Ceil (37cfb2e07e, ~-30%), duffcopy clobbers X0 (ffb20631fc, 0bef88aa5f).

liblink: a shared assembler/linker library

Span: Go 1.3 → Go 1.5 · Status at go1.17: converted to Go as cmd/internal/obj in 1.5 (this thread); the C library itself was deleted (3317e7f19a) → continues as Prologue, frame pointer, stack split and function alignment (cmd/internal/obj) (1.18+)

Continues in: cmd/internal/obj: Prog/LSym refactoring, concurrent backend and object-writing (Go 1.7 → Go 1.11)

Design. For the Go 1.3 linker plan, the per-architecture logic that lived in 5l/6l/8l (instruction selection, span layout, prologue/stack-split rewriting, TLS and branch fix-ups) was extracted into src/liblink, linked into compilers (5g/6g/8g), C compilers (5c/6c/8c) and assemblers (5a/6a/8a) (f7aaa553da, 76a8c873cf, f606c1be80; the C-compiler change also updated cc/gc: 870e821ded). The big commit a9f6db58ce (“move instruction selection + layout into compilers, assemblers”) added a new object file reader/writer (liblink/objfile.c), a pcdata iterator, removed the “line number stack” and “path fragments” from object files and the linker, made DWARF a single compilation unit, and disabled the check for chains of nosplit functions (issue 6931). The point is that each tool emits finished machine code and the linker only relocates and lays out symbols. Object files gained a version number so later format changes are easy (0e8de61d73, “changes we know we want to make, but not before Go 1.3”), the arch-specific constants were removed from the format (8d39e55c65), and a leaf bit so the linker records correct frame sizes (needed for ARM tracebacks, cc08d9232c). A direct consequence: liblink can no longer depend on link-time decisions. linkmode was removed from the ARM (dab127baf5) and x86 paths, which broke cgo TLS on ARM until b377c9c6a9 and 1dd4da1459 (adding an AMRC instruction for MRC/MCR so rewriting no longer matches bit patterns of AWORD).

Timeline.

• Go 1.3 — Done: adoption by assemblers, C compilers and Go compilers (f7aaa553da, 76a8c873cf, f606c1be80), new object format (a9f6db58ce), many Plan 9 / warning fixes (b9bed39714, 52ee63f544, 6e97513012, 0830f64bf0), explicit field for duplicate globl detection (4890502af6), either of conflicting symbols may say dupok (c9f12d2289), symgrow check (6111dc4e71), TLS register on 386/amd64 so 4(GS) rewrites are explicit (90093f0634; the commit says rewrites “had gotten out of control”), linkmode removal and ARM cgo fixes (dab127baf5, b377c9c6a9, 1dd4da1459, 9ed5995cfe), object version (0e8de61d73), leaf bit (cc08d9232c), NaCl morestack (9460cf7825, 88f84b3e41), field tracking (d9c9665f1d), remove never-executed code (f4ecfaa442). Left open: nosplit-chain check disabled (issue 6931).
• Go 1.4 — Done: preliminary plan9/amd64 (decd810945), nacl/arm (783bcba84d), LinkArch.textflag() instead of thechar switches (3c24b60fd3), big-endian support (08ee2661f2), shorter zeroing-register encoding (24db881689), MOVBQZX as MOVZBL (bbc6bb9a99), literal-word comparison on ARM (b916dc1992), way to avoid pc-relative addressing for Solaris (4516a60062), DATA must be offset-ordered with no overlap (5e6bd29c2c), %^ verb and C_* constants moved (d69d0fe92b), arm MRC replacement generated in liblink (0b36211cfb), gotos rewritten for translation (8e0e09ae7d), fb818eab7f, 20a5de9eb6, a6feaf3aff, ae027f52fe.
• Go 1.5 — Done: the C library is converted to Go (see C→Go thread), made uniform (see cmd/internal/obj thread) and finally deleted (3317e7f19a); liblink fixes during the transition (0185ba76ed, e04c8b063f do not patch jumps to jumps to symbols, 3be0a0ef6f, 52d277906d, dba9eb3369 GOEXPERIMENT in runtime and liblink, 281ae92881 SETcc encoding, ab9ec2e401, 6c78443b3e code for debugging bad returns, 9b1b0a46dd fail for too-large register offset).

Normalising Prog/Addr in cmd/internal/obj (the portable instruction representation)

Span: Go 1.5 → Go 1.6 · Status at go1.17: the design (portable Prog, Addr with TYPE_*, From3/RegTo2, shared A* numbers, Link context) is still in place → continues as Prologue, frame pointer, stack split and function alignment (cmd/internal/obj) (1.18+)

Continues in: cmd/internal/obj: Prog/LSym refactoring, concurrent backend and object-writing (Go 1.7 → Go 1.11)

Design. Before 1.5, each liblink architecture had its own Prog/Addr conventions. In January 2015 Russ Cox made them uniform so that one set of architecture-independent passes (and cmd/asm) could operate on them: the zero Prog is valid and has as set to AXXX instead of AGOK (76fed5426c); common instructions get fixed numbers ANOP, ATEXT, AGLOBL, ACALL, AJMP, ARET with arm/ppc64 aliases (2e5b065ac2); TEXT $frame-arg is encoded the same way on all architectures (72521319c7); TEXT/GLOBL flags live in p->from3 (77a415e5a6) and DATA size in from3.offset (3ac37c72ae); constants must use TYPE_ADDR not TYPE_CONST, with an input checker in liblink/pass.c (1f2d7bf44f); ARM conditions renumbered so C_SCOND_NONE == 0 (e66ad16ddb); dead p->back computation removed (6654188190). The portable Prog/Addr layer was ported to every back end in five parallel commits (5a2771e286, 0d599909e9, 604138e87b, a5b1baeed7, da47902d02). Later cleanups: Addr.U struct replaced by Val interface{} (532ccae154), Prog.From3 a pointer (c413c45e6d), two unused fields removed (2286e452bd, 1378173785, 4ed7d06a87), Pcrel and Comefrom combined (c04813e130), global Aconv/Dconv/Rconv and Prog.String replacing per-arch Pconv (74e88dfdee, 29421cbb5b, daddeb2686, 24a43e6a75, 40ff393e4c), go generated Anames (4b981ed3e6), unary-destination tables moved from asm into obj (8974fb9ba5), symbol table as a map (049eee6806), line history reimplemented with O(log n) lookup (861546543a), Ctxt.Endian deleted (ea7be5170a), Link.Tlsoffset removed (7bf959c67a), ProgInfo layout (b795ce9ab0, 30b966307f), keyed ProgInfo literals (2468227038).

Timeline.

• Go 1.5 — Done: the list above; cmd/internal/obj created from liblink (d6f6e420fc, 24dfaba6d1, 1fc330d8fe, dc7b54bed2), shift of x86 SHRQ second source to From3 (3d0397a4f4), CALL *name(SB) (b66a509992), PINSRD (29f18f2800), CMPPS memory third arg (59584ede73), cleanup (ad49c7bb62, fc28fd1eb8, e7ffafdb6e, 0088ddc3a0, 873483c682, 8d16253c90). Left open: the code generator still produced Prog lists per function and wrote objects at the end.
• Go 1.6 — Done: code layout (span) separated from object writing so the compiler could lay out each function as it is compiled, “should reduce the working set of the compiler. But not until Go 1.7” (ed03dab853); Tlsoffset removal (7bf959c67a); ProgInfo layout (b795ce9ab0).

The Plan 9 C compilers (cc, 5c/6c/8c) in the Go toolchain

Span: Go 1.0 → Go 1.5 · Status at go1.17: removed in 1.5 (4a42fae2cd on dev.cc); runtime was rewritten in Go and assembly

Design. src/cmd/cc plus 5c/6c/8c compiled the runtime’s C code and cgo helpers; the tree adopted Plan 9’s lib9/libbio in 2008 (69b74c3953) and brought in 8c/8l/8a (4dee747fb9, af0143ce03) and 5a/5c/5l (db3a21d7c6) from the Inferno distribution. The compilers shared cc/pgen.c/pswt.c (27432d67ec) and their own register allocator (reg.c) and peephole (peep.c), with alignment rules kept consistent with the matching Go back ends (7fbf9fcba9, b331f3cfd0). Go-specific extensions: #pragma textflag, dataflag, dynexport, varargck countpos/type for the Windows stdcall helpers (fe2ccb53c0), NOPTRBSS (5bcad92f07), 21-bit rune wide strings (781b2a2519), PREFETCH builtin (d42495aa80, ARM 278d4a583d), nested package calls like sync»atomic·LoadInt32 (8be5e8a419), and a mode that emits Go definitions of C types and variables (efda876a94) used to generate defs_*.go; in 1.4 Eface maps to interface{} (948bb9150e) and structs without tags are disallowed (3ffd29fb2c). For precise GC cc emits argument pointer maps and locals bitmaps (9b1f1833de, 73c93a404c), gc bitmaps in read-only memory (a26c01ad44) and gains the same linkarchinit as gc for amd64p32 (d4896fb876). Optimizations in 6c: avoid long multiplication (2c0b00744f), rotates (bb192d1399, 41ec481a53), NaN-safe floating point (109a976355), fixjmp in regopt (5cb1ed2189), 64-bit switch values (6481e37d28, d89b7173c2).

Timeline.

• Go 1.0 — Done: the imports and 8c/5c bring-up above; many 6c/8c code-gen fixes (902a4d5f29 large constants, 5e5476c2fe byte* difference, d4ad8e8ce3 misaligned arguments, 494bcc80e4 extern static registers in 5c, ee7c64efe5 extern register vars only in MOVL, 3e0adc9ffb vlong condition, 5124e66fca), removal of fixed-size buffers (139a053733, 77053797e0, 0e47c75f60), -S line numbers (2cda191aef), 5c do not use R9/R10 (c475c3071a) and gcc/Plan 9 build fixes (b0449c50f7, 5ea4d73b17, 4c6280b0f1, 3f2cc8ba7e, c8c6e1961d), b0449c50f7.
• Go 1.1 — Done: GOROOT_FINAL (bcdafaa582), 6c rotates (bb192d1399, 41ec481a53), MOVQL for explicit truncation (e530d6a1e0), 5c regopt re-enabled (70db440885), R12 and F8–F15 usable on ARM (d87bc2f0c0), uint right-shift constant eval (34ad3995e0), large model flag (fe14ee52cc), dynamic-linker autodetection (dac4c3eee9), struct literal side effects (c13866db7f).
• Go 1.2 — Done: cc rejects unions with pointers (dbee8ad0f9), isolated textflag/dataflag (2449909d81), wide-char fix (5b15b44434), full 64-bit block copy (f268c295a3), pointer maps (9b1f1833de, 2db5e4bb0b), %Q (237e7c134c), AFUNCDATA PC fix (de6da4a8bd), fix undefined behaviour (8d5ec52e6c).
• Go 1.3 — Done: liblink (76a8c873cf), NaCl (7954b2b90b), amd64p32 (d4896fb876), bitmaps in rodata (a26c01ad44).
• Go 1.4 — Done: Eface → interface{} (948bb9150e), no tag-less structs (3ffd29fb2c), make optimizer failure fatal (3147d2c4ee), diagnose Go calling C (0bb14d74f1), stop emitting argsize PCDATA (68c1c6afa0), #pragma pack off error (86c4c4f00c). Left open: the runtime still contained C (c2go translation was the plan).
• Go 1.5 — Done: cc, 5c, 6c, 8c removed on dev.cc (4a42fae2cd), 9c removed (1a68ac2538, an earlier 9c existed on dev.power64: 83f6aadf16, 95e8a3a1da, 860f941e7f, 25bde37af4), lexbody/macbody deleted after the assemblers were replaced (184eb0ac9e).

Assemblers: 5a/6a/8a/9a and the Go cmd/asm

Span: Go 1.0 → Go 1.6 · Status at go1.17: cmd/asm (cmd/asm/internal/{arch,asm,flags,lex} + cmd/internal/obj) is the assembler → continues as arm64 code generation and assembler (and the other per-arch assembler threads) (1.18+)

Continues in: x86 assembler: AVX, AVX2, AVX-512 and the instruction table (Go 1.7 → Go 1.11) · ARM64 assembler (Go 1.7 → Go 1.11) · 32-bit ARM, MIPS and PPC64 assemblers (Go 1.7 → Go 1.11)

Design. The Plan 9-derived assemblers were yacc programs (a.y, lex.c) per architecture. They gained x86 coverage over time (386 SSE2 5da37c0901, XMM registers 755e13877f, AES 297bb12809, CMPPD e5009e29ea, IMULL grammar 1738dc0e71, $(-1) forms 6d9c02aea3, MOVQL ea86752206, amd64p32 e509bbc943, SETPC a6feaf3aff), ARM (PLD 2031252fb8, MULW{T,B} a0084b3494, m/g registers 5d081792b6) and pseudo-ops (PCDATA 47b89a37d9, FUNCDATA 8c741c97f7). In 1.3 they used liblink (f7aaa553da) and in late 2014 labels became function-scoped (b55791e200).

For Go 1.5 cmd/asm replaced them. Rob Pike’s design (dev.cc): a single assembler driven by cmd/asm/internal/arch tables (register names, instruction aliases, per-arch operand rules), lex (a macro-processing tokenizer with #define, #ifdef, #include; d6eb21e331 rewrote the macro processor), asm (parser and instruction builder), flags, producing obj.Prog lists consumed by cmd/internal/obj. Development was bootstrapped by converting the old assemblers mechanically to Go (9e2f8fdb6f, 4ca2fc4d8b “new5a etc, cmd/internal/asm”) and verifying the new assembler byte-for-byte against them: cmd/asm was first the “verify” pass in cmd/go (“verifyAsm”), then made the first assembler (4100f7d95c), and the runtime was the last package verified (e59ed477c3). Once identical, the C assemblers and cmd/internal/asm were deleted (3af0d791be, ba0c142d32, 861af80458).

Timeline.

• Go 1.0 — Done: documentation of the assemblers and loaders (b5ab5d4f12), Windows paths (aed2c06dcb), fixed buffers (07d3e0dce4, 0e47c75f60, 77053797e0), delete 8a’s dreg l.s (783c46b197).
• Go 1.1 — Done: PLD (2031252fb8), MULW (a0084b3494), SSE2 and XMM (5da37c0901, 755e13877f), AES (297bb12809), GOROOT_FINAL (6af069f3e1), delete dead code (6a22e2fb3f).
• Go 1.2 — Done: flag parsing (8124a02cb2), PCDATA/FUNCDATA (47b89a37d9, 8c741c97f7), m/g for ARM (5d081792b6), MOVBS/MOVHS (3670337097).
• Go 1.3 — Done: liblink (f7aaa553da), generated .y fixes (426b48a775), MOVQL (ea86752206), amd64p32 (e509bbc943), link to the new assembler document (0bdd90bc0a).
• Go 1.4 — Done: AJxx condition-code docs (c6442c994a), SETPC encoding (a6feaf3aff).
• Go 1.5 — Done: the new assembler: arch, addr and lex packages and the assembler proper (6017f68029, 40eb0ed0d8, 8642639575, fdeee3a538), identical output to new6a (89162307cd), TEXT $3-2 parsing (92e5120c77), macros (d6eb21e331, 5beec6a699), rewrite for the new obj API (cb19a20121), runtime final fixes (e59ed477c3), architectures: 386 (ef664199cb), ARM (c497349a5b, 5d111b898a, 5d987f1513 MCR), ppc64 (e559c5cce2, 5b9429d122, adff896e4c), ppc64le (9c0c050773), arm64 (18d9ddc35c, a175fa3bc3, ef49b4ca78); 4(SP) illegal except on 386 (345350bf07); LOOP as a branch on x86 (9a420f4cf3); order of assemblers (4100f7d95c); removing the objects when assembly fails (3b1d0d0f07); function-scoped labels (b55791e200, b528063099); old assemblers deleted (621d75999f rename to old5a, ba0c142d32, 861af80458). Left open: shift handling and macros had follow-up bugs (58d177c63e, 989b372a5c, d6eb21e331).
• Go 1.6 — Done: robustness against fuzzing (7437e3f02e, df37c4b987, 63e2bed0ab, 5e89acb580, 980cb0caf2, 173bf3487f, 49580db149, 49065cbfe4), nested #if (eaea5ade2b), more than one encoding error reported (36edf48a10), -e flag (02717bdc20), mips64 (43ea305435), ARM CMPF/CMPD (36af087aef), arm64 condition-code aliases (61a3ebed55); x86: YMM registers (d2b0c387b2), VEX encodings VZEROUPPER, VMOVDQU, VMOVDQA, VMOVNTDQ (9dd81d6227), then “correct, complete” AVX (8d881b811d), BMI-style PDEP/PEXT (0bae38e094), POPCNT (d3ff40fb1f, 7f620a57d0), HADDPD/HADDPS (e634765941), requested amd64 instructions (863d9b66f8), TSX (e9081b3c76), PSRLW fix (d96b4c494f), reject foo(SB)(AX) (9d6427d899).

C→Go translation of the toolchain (liblink, assemblers, compilers; dev.cc)

Span: Go 1.4 → Go 1.5 · Status at go1.17: complete; all tools are Go

Design. The dev.cc branch used Russ Cox’s rsc.io/c2go translator to convert the C toolchain mechanically, then hand-fixed leftovers. Preparation (1.4) was annotation-driven: #define to enum, /*c2go */ comments giving the effect of macros, braces in struct initialisers (ebce79446d). Conversion order: first liblink as cmd/internal/obj with a temporary dual mode where C liblink calls go tool objwriter to write objects, selected by $GOOBJ and $GOOBJWRITER and verified against the C output (be818361b9, 725e3a7afb, 283b23297a, d6f6e420fc, 24dfaba6d1, 1fc330d8fe, 2ecefd41fa disabled the GOOBJ=2 default, 25c140aaa0 turned off the verification), then the assemblers (9e2f8fdb6f, 4ca2fc4d8b, 67e7ded029), then the compilers and linkers into cmd/internal/gc, cmd/internal/ld, cmd/new6g etc (8c195bdf12: 88448 lines added). Repeated reconversions (dc7b54bed2, f6791da7ad, 53d4123fbc adding profiling) followed C-side changes until the freeze, when the C implementations were replaced by the Go ones (3af0d791be: 170 files, +9484/-93906) and then the C libraries and their dist code were deleted (3317e7f19a). Source simplifications for translation went into mainline: cmd/gc as a real library (349ecfb0d6), simplifying code (e82003e750, 5c87cf7608, 2286989912, 3be0a0ef6f), and removal of C tricks (subclassing in popt.c 1250d2e374, pointer arithmetic acba34e45f, qsort order 90965718a8). After the switch the Go source was cleaned: goto removal (4492811c05), idiomatic bool fields (25da594c6a, 38a61ff41f, 75883bae28), unembedding Node.Func/Name (3ed9e4ca3c, 8fa14ea8b4), Fprintf-style cleanups (494e317fbf), destuttering (ce469fadd8).

Timeline.

• Go 1.4 — Done: c2go annotations (ebce79446d). Left open: the actual conversion.
• Go 1.5 — Done: conversions and the switch (above), go tool compile / go tool link (17eba6e6b7), old assemblers deleted (ba0c142d32), cmd/dist Go constant for external linking (7934199877). Left open: generated code still C-flavoured (acba34e45f).
• Go 1.6 — Done: janitoring of map/slice literals and gc (3c37a61455, 7d48573d46, 90f69259ec, 932c1e3dd3, dd42eff8fe, 3e476827a6, 6d0178359f, ea4e321d4d).

The ppc64 / ppc64le port (dev.power64, 9g/9a/9l)

Span: Go 1.5 → Go 1.6 · Status at go1.17: production port with shared-library support → continues as PPC64 / Power10 backend (GOPPC64, prefixed instructions, PC-relative code) (1.18+)

Continues in: 32-bit ARM, MIPS and PPC64 assemblers (Go 1.7 → Go 1.11) · Multi-architecture SSA ports: PPC64, MIPS64, MIPS32, s390x (Go 1.7 → Go 1.11)

Design. The port started on 2014-08-06 by importing the Vita Nuova 9a/9c/9l code without modification, “concatenating several cmd/9l files together to form the liblink files” (117b1d4685), then converting 9c/9a to liblink with Go argument passing and both endiannesses (83f6aadf16, bcf7f61f83, 4be75c8f26) and writing 9g from the 6g/5g model (“first check point” 4928b2074b). The code generator copies the template: zerorange (b1c9a8bce3), loops for memmove in sgen (372b5cebe7), ginscon2 for CMP/CMPU (893f28ca16), NaN-correct float compares (27e657ef68, aa739b8d03), MOVD $con(Ra), Rb → ADD (f375c0eb0d), large constants (ba9a11e557), stack split and long conditional branches in liblink (f4529adabe). Bits became a uint64 array (fa32e922d5); progtable gets CC/V/VCC variants (e78777ebfe) and proginfo for DUFFZERO/DUFFCOPY (ee853dacf5, 60f66aa817); regopt (743bdf612a) and a peephole (ed5488eece) were implemented, R_CALLPOWER like ELF R_PPC64_REL24 (6f755f2f8f), R13 avoided (bbd2127909). Frame alignment: 8-byte argument size on power64 (93341e8664, bc8d35a9cf). ARETURN was unified with obj.ARET (9389a86b01, 16310571d1) and ppc64 DS-form loads/stores handled in obj and the linker (5e1d0fcbed).

Go 1.6 added position-independent code: -shared/-dynlink on ppc64 (c23c8d58d6), a TOC pointer maintained in R2 following the ELFv2 ABI: global entry point instructions, local-entry metadata for the system linker, save/restore around calls (368d548417), TOC-relative loads of static data (bd329d47d9), GOT access (2ac993107f), IE-model TLS (a35c85c0cc, further “like a platform linker” c9b8cab16c), no PLT call to morestack (64fbca41c8), stack barriers in ppc64le shared libs (3a1bed82a6), larger minimum frame (97055dc1f1, c1b6e392f5). Regopt must not use REGTMP (0357c38adf).

Timeline.

• Go 1.5 — Done: the port as above, plus cmd/asm support (e559c5cce2, 9c0c050773), 9g: fix nilopt (810019286f), fix under-zeroing in clearfat (6e86003651), fix addr width and enable MOV* width check (22c929f538, c1e8c57c3d), nilopt (5e4989cf0a disables, 810019286f fixes), REGZERO for the zero register (1e1c9dc2c8). Left open: “disable stack split for now” at the start (05d670f757), “No peep optimizer” on 7g; nilopt disabled initially (5e4989cf0a); suboptimal copy code noted (36f879780a).
• Go 1.6 — Done: the PIC/TOC work listed above, SRADCC immediate assembly (10c0753761), epilogue for non-leaf generated methods (710b9ad617), archreloc simplification (d821ae2a9e).

The arm64 (ARMv8) port (7g/7a/7l)

Span: Go 1.5 → Go 1.6 · Status at go1.17: production port → continues as arm64 code generation and assembler (1.18+)

Continues in: ARM64 assembler (Go 1.7 → Go 1.11) · Multi-architecture SSA ports: ARM, 386, ARM64 (dev.ssa) (Go 1.7 → Go 1.8)

Design. Aram Hăvărneanu’s port landed in March 2015 as three parts: the assembler/obj package (26bbe7ac9b: 32 64-bit integer registers, 32 128-bit vector registers (unused), R31 is either hardware stack pointer RSP or zero register ZR depending on the instruction; hardware SP must be 16-byte aligned), cmd/asm support (18d9ddc35c) and the 7g compiler “based on 9g” (02c1a9d87d, “No peep optimizer yet”). Because ARM64 has no absolute addressing for text, 6e3a2a3f9f removed it from .text; ef49b4ca78 added CSEL; a175fa3bc3 parses register pairs for LDP/STP; 888d44d3c1 uses the zero register in componentgen; e040fd4654 raised registerization; prologues were made predictable (54789eff38); frames must be aligned (3952057cf6) and misaligned frames are rejected except empty ones (034a10d44c); 0f27b91522 introduces RegTo2 instead of a full Addr; 467a2cb73c drops the Reginuse check in clearfat. In 1.6: loads from memory use two instructions rather than three (3a9bc571b0), TLS (72180c3b82 “native-ish”, 80d9106487 initial-exec), GOT access in -dynlink (3534e2bef4), branch enlargement (2a031e6a2a, literal pool flush 73d590b4bd), CASE/BCASE removed (3578bdf3c3, ARM 8d478e845c).

Timeline.

• Go 1.5 — Done: 26bbe7ac9b, 18d9ddc35c, 02c1a9d87d, 6e3a2a3f9f, ef49b4ca78, a175fa3bc3, 72f8102244, 888d44d3c1, 0f27b91522, 54789eff38, 3952057cf6, 034a10d44c, 467a2cb73c. Left open: “No peep optimizer yet”, no shared linking.
• Go 1.6 — Done: 3a9bc571b0, 72180c3b82, 3534e2bef4, 80d9106487, 2a031e6a2a, 73d590b4bd, 3578bdf3c3, 61a3ebed55, 5f23bc8903.

The mips64 port and the mips/mips64 register space

Span: Go 1.6 → Go 1.6 · Status at go1.17: production port → continues as s390x, MIPS, 386 and 32-bit ARM backends (1.18+)

Continues in: Multi-architecture SSA ports: PPC64, MIPS64, MIPS32, s390x (Go 1.7 → Go 1.11)

Design. The port was built the same way as arm64 by copying ppc64: cmd/internal/obj/mips first as a mechanical copy “to reduce code difference when adding the mips64 port” (5cc86c6f55), cmd/compile/internal/mips64 likewise (14f919578d), then real support for GOARCH=mips64{,le} in obj (fa6a1ecd63), cmd/asm (43ea305435) and the compiler (d5cd4ab46a, 689 insertions / 1129 deletions relative to the copy). Register space was reduced afterwards (1b6d55acab).

Timeline.

• Go 1.6 — Done: the above. Left open: nothing noted besides that the port starts with the ppc64 structure.

Native Client (nacl/386, nacl/amd64p32, nacl/arm) and amd64p32 in the toolchain

Span: Go 1.3 → Go 1.6 · Status at go1.17: not covered by this range’s commits after 1.5

Design. The first merge was a mechanical import of Russ Cox’s NaCl branch (7c8280c9ef, per golang.org/s/go13nacl), followed by assembler/compiler support (7954b2b90b): consult $GOARCH, and in 6c under NaCl “some of the more complex addressing modes must be disabled, and the BP and R15 registers must not be used”. amd64p32 (32-bit pointers on amd64) required linkarchinit in cc and gc (d4896fb876, e31a1ce109), 6a support (e509bbc943), morestack fixes (9460cf7825), stack alignment fixes (3d5e219e02), correct stack zeroing (741244e433, bfbb2e827b, ac0e12d158), and Duff’s device disabled (c6a41a3559). nacl/386 (88f84b3e41) and nacl/arm (783bcba84d, large stack offsets 782eea0190) followed.

Timeline.

• Go 1.3 — Done: 7c8280c9ef, 7954b2b90b, d4896fb876, e31a1ce109, e509bbc943, 9460cf7825, 88f84b3e41, 741244e433, bfbb2e827b, c6a41a3559, 3d5e219e02. Left open: working NaCl support not included in the first merge (“does not include working NaCl support”).
• Go 1.4 — Done: nacl/arm (783bcba84d), ac0e12d158, 8a7597fd7a.
• Go 1.5 — Done: amd64p32 build fixes (12079acaa0, cbc854a799), nacl/arm stack offsets (782eea0190).

Position-independent code, dynamic linking and TLS in the assemblers

Span: Go 1.3 → Go 1.6 · Status at go1.17: working on amd64, 386, arm, arm64, ppc64le → continues as Prologue, frame pointer, stack split and function alignment (cmd/internal/obj) (1.18+)

Design. With liblink, TLS and shared-library rewrites became explicit assembler passes. 1.3: a TLS pseudo-register introduced for 386/amd64 so 4(GS)-style operands are rewritten in one place (90093f0634); 1.5: -shared re-enabled on amd64 with -shared flags in cmd/asm and 6g (09d9520be9), -shared TLS base computation on x86 (e73981512f, 14fbec49dc), -dynlink access to global data through the GOT (84207a2500), duffcopy/duffzero called via GOT (1d1c61ba7d), R15 freed when not needed for GOT indirection (8a3132dd5e), framepointer and prologue changes. 1.6: GOT access on arm (e6ceb92e1c), arm64 (3534e2bef4), ppc64le (2ac993107f) and 386 (cb0393866a, 342f17eaf7), independent bits of toolchain TLS support (9e6ba37b86, 7bf959c67a), “a saner model for TLS on arm” (b0344e9fd5), native-ish TLS on arm64 (72180c3b82), initial-exec (80d9106487), IE on ppc64le (a35c85c0cc), regopt must not use CX in PIC on 386 (61da0e92d0, 9514285da9) and android/386 local-exec (0fbf0955d4), -shared/-dynlink on ppc64 (c23c8d58d6), x86 GOT rewrite factored (3c85e1b186). Solaris needed a way to avoid pc-relative addressing (4516a60062, 1.4).

Timeline.

• Go 1.3 — Done: 90093f0634.
• Go 1.4 — Done: 4516a60062.
• Go 1.5 — Done: 09d9520be9, e73981512f, 14fbec49dc, 84207a2500, 1d1c61ba7d, 8a3132dd5e, 264858c46e, 0661143447.
• Go 1.6 — Done: the list above. Left open: “the make TLS make sense project has quite a few more steps to go” (9e6ba37b86).

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 · 1.5 · 1.6

Backends and assemblers (Go 1.7–1.11)

Reader: Claude Sonnet. Cites 1,255 of 1,416 commits in this slice; every non-noise commit is cited, plus 16 larger commits the noise filter had set aside, which a separate gap reader described. Read the opening lines of the design-heavy messages and 11 full messages, but no diffs. Many timeline entries are hash lists with brief explanations.

SSA backend bring-up on amd64 (dev.ssa merge)

Span: Go 1.7 → Go 1.7 · Status at go1.17: still the design at go1.17 (the same cmd/compile/internal/ssa package: Value/Block/Func, generic ops lowered by gen/*.rules, passes list in compile.go) → continues as Register allocator, scheduler and block-level backend passes (1.18+)

Design. Every commit in this thread is a [dev.ssa] commit with a 2015–2016 author date but first shipped in Go 1.7. The compiler front end (gc) converts its Node IR into SSA form (d2fd43aa77, cmd/internal/gc: convert standard IR into SSA) and then generates machine code straight from SSA values (083a646f63, Generate code from ssa form). The SSA package represents a function as blocks of Values with an opcode, a type, argument list, AuxInt and Aux fields (8f22b5292f added AuxInt; 16b1fce921 added aux typing and per-op flags; 4e95dfed01 added a max argument length per opcode). Opcodes and the lowering rules are described by tables and rule files under ssa/gen and are autogenerated (0dca7351e9 autogenerates opcodes; a9cec30fdc adds block rewriting rules; 177b697ba5 lets a rule choose a target block; 0d91018082 adds simplifying block rules).

A second early design decision concerns narrow integers. Initially values of sub-register width kept their high bits correctly sign/zero extended; 2a5e6c47bc redid this so the compiler treats the high bits of a register as junk, so ops producing subword results need not extend, at the cost of extending when a wider use appears. 67fdb0de86 made opcodes width- and sign-specific, 9cb332efd4 split OpConst into Const8/16/32/64, and 7fc5621991 later defined the high bits of AuxInt to be the sign-extended version of the low bits, so that (Const8 [0x1]) and (Const8 [0x101]) become the same value for CSE.

Memory is modeled as a single linear chain: 6241a41e33 enforces one live memory state, and e98edc88c9 makes the scheduler enforce load/store ordering. Panics and calls were first special ops and then ordinary calls to runtime functions (3a70bf9c0c, d24768e14d completing call ops). Nil checks, bounds checks (3e7904b648 improved inBounds rules), go/defer (9569b957cb), closures and addressed variables (956f3199a3), complex arithmetic (3a9d0ac3c8), string ops (f7f604e284), FP support (997a9f32b0, 8e601b23cd, 4282588694), and GC bitmaps for SSA-compiled code (d2107fc987) were added one language feature at a time. Development was driven by GOSSAFUNC/GOSSAPKG environment variables so single functions or packages could be compiled by SSA without rebuilding the compiler (d298209b1c), and the HTML dump of every pass was added around GOSSAFUNC (later made readable by b13b249f43).

Timeline.

• Go 1.7 — Done: user-visible the SSA path exists and generates amd64 code: conversion from IR (d2fd43aa77), codegen from SSA (083a646f63), memory zeroing (66b47812eb), static data (6b41665039, 7c18f8cdc3 writes static data straight into the linker symbol instead of ADATA Progs), strength reduction of constant multiplies/divides (3e7e519c36, d8f1f8d856, a3055af45e for 64-bit constant divides, 77b527e283 for 24), const folding for floats (f6ceed2cab), bool ops (8b92397bcd), intrinsics (8eec2bbfbc). The compilation trigger changed from “compile everything with SSA and decide whether to use it” to deciding up front which functions go through SSA (5b355a7907). Compile-time work made the pass pipeline cheap: sparse sets cached on Func and reused across passes (f962f33035, 3297a4f5f3), preallocated values/blocks and backing store for Preds/Succs/Values (2f57d0fe02, 056c09bb88), faster CSE (6a96a2fe5a, 88c1ef5b45 handling commutative ops), value use counts kept in SSA (56e0ecc5ea), critical-edge pass tweaks (50bc546d43, b2dc1f82a5). Bugs of the period (flags clobbered by SETcc/REPSTOSQ/LEA, e.g. 8f51ae8ba5, f3171994e9, 4219aba5db, 2511cf03b9) show the flag handling being worked out empirically. Also: ba8a146af4 prints register names, 288817b05a reduces line-number churn, 686fbdb3b0 makes compilation deterministic. Left open:* only amd64 is supported (4c9a470d46 “start on ARM port” at the end of the cycle); the old cgen-based backend still exists and is the fallback, and UnimplementedF stubs remain (5b355a7907 TODO: “get rid of all the UnimplementedF stuff”).

Register allocation, flag allocation and stack slots

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (global allocator in regalloc.go, separate flagalloc, stackalloc) → continues as Register allocator, scheduler and block-level backend passes (1.18+)

Continues in: SSA infrastructure passes: layout, regalloc, scheduling, flagalloc, block shape (Go 1.12 → Go 1.17)

Earlier history: Register allocation and the peephole optimizer (reg.c, peep.c) (Go 1.0 → Go 1.6)

Design. The first SSA backend used a local, per-basic-block allocator. 0b46b42943 replaced it with a global (whole-function) register allocator in which clobbers are handled properly. Its structure persisted through 1.11: values are allocated in block order using use distances computed backwards from block ends, with phi values given the registers of their inputs, and merge edges repaired by a “shuffle” pass that inserts copies/loads/stores. ddeee0eed3 enforces that phis come first, f206b16ff7 assigns unused registers to phi ops, d7ad7b9efe zeroes register masks per edge, and 7d61246972 introduces reserved registers (SP, SB, g, etc.).

Flags are not allocated like normal registers: 9f8f8c27dc took a simple approach: never spill flags, and when a flag value is needed again, recompute it by reloading its arguments; fewer than 200 flag spills occurred during make.bash. d04f38e3ee fixed the “find original inputs” step after rematerialization. c140df0326 moved flag allocation into a separate pass (flagalloc), and 0484052358 removed flags from regMask. Because rematerializable ops can be inserted after flagalloc, 2cb61aa3f7 (1.10) added a check that they never clobber flags and fixed the offenders, which is why ADDQconst could not be made rematerializable and 9916feeddf (1.11) rewrites (ADDQconst SP) into a LEA instead.

Spill and stack-slot placement evolved: 366dcc4529 reuses stack slots for spill locations; 7d9f1067d1 reordered register and stack allocation (previously registers, then merge-edge fixup, then stack slots, which produced LoadReg/StoreReg pairs through the same slot that could not be seen until too late); c64a6f6362 added rematerialization of constants and addresses; 02f4d0a130 starts arguments as spilled; 75102afce7 and 7d9f1067d1 are the “better register allocator” rounds; 9d6e605cf7, b57ac33331 and 815c9a7f28 add forward-looking desired-register biasing and use of loop information. Instruction-specific needs: 369f4f5de5 and 0004f34cef allocate for two-address instructions (resultInArg0) and enforce them. 1.8 refined: f876fb9bae copies the value being evicted to a spare register before kicking it out (helpful for x86 DIV and MIPS MUL/DIV, reducing “spilled value remains” by 1% for cmd/go); 348275cda6 copies a still-live Phi input to a spare register to avoid a spill; 1bddd2ee6a does not shuffle rematerializable values around; 7bd88a651d does not sink a spill out of a loop if it satisfies a merge edge; 6dc356a76a erases register copies deterministically; 833ed7c431 reorganizes SSA register numbering; 15817e409b makes the link register allocatable in non-leaf functions (s390x first, then ARM64 5c59cb4aa3, MIPS64 4f6d479186, ARM f9238a76ff), with RC4 on s390x improving up to 40%.

In 1.9 886e9e6065 pushes spills farther from their generator into unlikely branches; 8a44c8efae stops spilling rematerializable values when resolving merge edges; 8a5175df35 improves the startRegs calculation (a value used only after a call need not be live at block entry); 9664bc1d1f fixes phi updates for preemptible loops; cfb0d34992 lets XCHG use stack pointers. In 1.10 7eaa8efbe4 stops spills clobbering differently-typed views of arguments. In 1.11 dafca7de0f prefers rematerialization to copying, 014a9048d4 resolves a long-standing TODO by evicting a register holding a rematerializable value first, 840f25bedd introduces dense numbering for GP registers, 31e1c30f55 forbids LoadReg of the g register, 2ba98f1ae9/377a2cb2d2 remove regalloc allocations.

Timeline.

• Go 1.7 — Done: global allocator (0b46b42943), reserved registers (7d61246972), rematerialization (c64a6f6362), stack-slot reuse (366dcc4529), separate flag allocation (c140df0326) and spilling flags by recomputation (9f8f8c27dc, d04f38e3ee), allocation-order change (7d9f1067d1), two-address instruction allocation (369f4f5de5, 0004f34cef), loop-aware and forward-looking tweaks (815c9a7f28, 9d6e605cf7, b57ac33331), moving constant phi arguments closer to the phi (305a0ac123), 3572c6418b keeping pointer input arguments live. Left open: spills always placed right after the defining op; stack-slot assignment still coarse.
• Go 1.8 — Done: copy-before-evict (f876fb9bae), Phi-input copies (348275cda6), LR as allocatable register on s390x/ARM64/MIPS64/ARM (15817e409b, 5c59cb4aa3, 4f6d479186, f9238a76ff), flags removed from register masks (0484052358), SSA register numbering (833ed7c431), do not sink spills used for merge edges (7bd88a651d), d0fa6c2f9e adding SSAReg, a2beee000b special-register checks, regalloc checks only when enabled (93d5f43a29), PPC CheckLoweredPhi (4c8baa0ad0). Left open: nothing noted beyond later spill placement.
• Go 1.9 — Done: better spill placement (886e9e6065), no spill of rematerializable values at merge edges (8a44c8efae), startRegs fix (8a5175df35), preemptible-loop phi fix (9664bc1d1f), rewrite of rematerializable/flag interplay discussed in 2cb61aa3f7^1.10’s predecessor work. Left open: ADDQconst could not be marked rematerializable because it clobbers flags (documented in 2cb61aa3f7^1.10 the next cycle).
• Go 1.10 — Done: rematerializable ops must not clobber flags, with a checker (2cb61aa3f7); 7dd279013b marks ADD[Q|L]const rematerializable (reverted in the same cycle per 2cb61aa3f7); e01eac371a marks LoweredGetCallerPC rematerializable; 7eaa8efbe4. Left open: nothing noted.
• Go 1.11 — Done: preferring rematerialization (dafca7de0f, 014a9048d4), LEA of SP instead of ADDQconst (9916feeddf), dense GP register numbering (840f25bedd), g-register guard (31e1c30f55), allocation reductions (2ba98f1ae9, 377a2cb2d2, cd2cb6e3f5 caching sparse maps), 3a9e4440fd moving tighten after lowering so that rematerializable/flag-generating decisions benefit from lowered CSE. Left open: nothing noted.

Scheduling, tighten, block layout and CFG passes

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (schedule, tighten, layout, looprotate, branchelim, fuse) → continues as Register allocator, scheduler and block-level backend passes (1.18+)

Continues in: SSA infrastructure passes: layout, regalloc, scheduling, flagalloc, block shape (Go 1.12 → Go 1.17)

Design. The scheduler orders values inside a block subject to phis first, control values last, and memory-ordering constraints. Early commits fixed correctness: phis scheduled first (4e204b42f5, f1401f1a10), control values live at the end of the block (573c791e81), values depending on the control scheduled later (21e6a055c1), load/store ordering (e98edc88c9). b1785a5065 replaced ad hoc ordering with a heap-based priority queue; after trying several heuristics the winning one for the Go tools was “line-number order, then more args before fewer, then variable ID order”. Later fixes: tuple ops (225ef76c25, 1c53a1b197), storeOrder (a355639c60, 978af9c2db, 1a27f048ad), and allocation cuts (41e176fbe0, 00c8e149b6, 4ed94ef1a8).

tighten (f91ff1a509) moves values closer to their uses: in the initial restricted version it moved 84,437 values during make.bash. Special cases were added (not moving SP/SB 6548b63d6b, respecting phis e5fe33e546, not moving mem-using values 65df9c4c2b, aggressive for booleans fe5619b479). In 1.11 3a9e4440fd runs tighten again after lowering, reducing spills.

Layout changed several times. 4b0d74f89d (1.9) lays out exit blocks last (restoring the 1.8 property that panics sit at function end; Fannkuch11 -7%), 638ebb04f2 extends looprotate to move the entire run of contiguous header blocks, and 73f1a1a1a7 (1.10) uses a reverse postorder traversal. In 1.11 c18ff18465 decouples the emitted block order from the regalloc block order and ab48574bab uses Block.Likely to put the likely branch first when neither successor follows. Branch elimination: 2d0172c3a7 adds a branchelim pass producing CondSelect and the arm64 CSEL lowering (go1 Gzip more than 10% faster), and 080187f4f7 / a35ec9a59e (a duplicated subject) enable it on amd64 as CMOV with special NaN handling for FP. CFG editing became constant-time with edge indexes in Preds/Succs (4fa050024f, fixing O(n^2) in deadcode and fuse); 10f38f51ef distinguishes exit and return blocks.

Timeline.

• Go 1.7 — Done: scheduler fixes (4e204b42f5, a678a5c7a5, e98edc88c9), tighten (f91ff1a509), priority-queue scheduler (b1785a5065), critical edges (a2f8b0d0e4), constant-time CFG editing (4fa050024f), exit vs return blocks (10f38f51ef), load-of-store replaced with copy (5c5fa3628c), prove pass extended to constant comparisons (47c9e139ae). Left open: tighten ran only before lowering.
• Go 1.8 — Done: tuple scheduling fixes (225ef76c25, 1c53a1b197), aggressive tighten for booleans (fe5619b479), c345a3913f removes BlockCall, reverse of nil-check blocks (see nil check thread), 8c24bff52b stack layout in SSA. Left open: nothing noted.
• Go 1.9 — Done: exit blocks last (4b0d74f89d), contiguous looprotate (638ebb04f2), storeOrder fix (a355639c60, 978af9c2db), boolean simplification rules (6a24b2d0c1), 27bc723b51 loop depth init, 1213776650/6664ccb453 concurrency tuning (see obj thread). Left open: nothing noted.
• Go 1.10 — Done: RPO traversal (73f1a1a1a7), 770d8d8207 free values earlier in nilcheck, 18b48afec9. Left open: nothing noted.
• Go 1.11 — Done: CondSelect/CMOV (2d0172c3a7, 080187f4f7, a35ec9a59e), likely-first layout (ab48574bab), decoupled emission order (c18ff18465), tighten after lowering (3a9e4440fd), f7404974da finishing GOEXPERIMENT=preemptibleloops (likely bit bug), d9a50a6531 and 9eb4590ad2 use prove-pass facts for CtzNonZero and bounded shifts, bff29f2d17/caa1b4afbd/9dc351beba handling zero-width ops. Left open: nothing noted.

Rewrite-rule machinery and compile-time performance of the SSA compiler

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (rulegen.go, | alternation, automatic commutation) → continues as Late-lower pass, memory-op combining and arch-independent rule migration (1.18+)

Continues in: Rewrite-rule generator (rulegen): ellipses, commutativity loops, typed aux (Go 1.13 → Go 1.17)

Design. Rules in gen/*.rules are compiled by rulegen.go into rewriteARCH.go. In 1.8 6a1153acb4 extracted parseValue from genMatch0/genResult0 to share parsing and validation; e4355aeedf added sanity checks on rules (1.7). In 1.9: 041ecb697f (reverted and then relanded as 53f8a6aeb0: “a redo of an undo of the original buggy CL”) makes the generator automatically generate both argument orders for commutative ops, eliminating pairs like (ADDL x (MOVLconst [c])) / (ADDL (MOVLconst [c]) x); fc327a14c4 removes order canonicalization rules from MIPS. 193510f2f6 evaluates config lazily in rewrite functions; eaa198f3d1 stops generating block successor variables; fc7b83d192 breaks up large value rewrite functions into chunks of ten cases (cmd/compile/internal/ssa compiles 23% faster: 7.33s to 5.64s); 5548f7d5cf removes bounds checks from generated code; 69fe9ea43e adopts the “generated code header”; 5e4a958351 refactors portable Op handling. In 1.11 rules gained | alternation (ec62ee7f6d, cab7ba0b28, 3553262248, 8993e16932, ebeea20a49, 1e05924cf5, af11038428, c284171bbb, 0a4c439d3f aggregate AMD64 and other-arch rules), and aff222cd18 trims PPC64 rules to shrink rewritePPC64.go.

Compilation speed of the compiler itself was part of this work. Per-func caches (f962f33035), ssa.Config/ssa.Func/ssa.Cache roles defined in 1.9 (43afcb5c96, a5e3cac895, 88e47187c1, 2cdb7f118a moving Frontend to Func, aea3aff669 separating ssa.Frontend and ssa.TypeSource), where cached values/blocks receive IDs without coupling Func and Config; not creating duplicate constant OffPtr SP values (3dcfce8d19, which were almost 30% of CSE’d values), CSE allocation reductions (f791b288d1), reuse of sparse maps (cd2cb6e3f5), stack-allocated worklists (00c8e149b6, 4ed94ef1a8). The ssa.Type interface was replaced by *types.Type (46b88c9fbc) once types was extricated from gc, reversing the dependency direction. The 1.7 commit 0ac0e22fa7 shrank compiler tables, cutting the cmd/compile binary from 14.41 to 11.42 MiB.

Timeline.

• Go 1.7 — Done: rule sanity checks (e4355aeedf), strength-reduction rule generalizations (3e7e519c36, d8f1f8d856), 1cc5789df9 many small rewrites, 0fb818a424 copy values during rewrites, 4989337192 allow control values to be CSEd, 16b1fce921 aux typing. Left open: both operand orders written out by hand.
• Go 1.8 — Done: parseValue refactor (6a1153acb4), rulegen/gen directory split from main build (7208a2cd78^1.7, 1.7), ad8b8f644e dead-rule removal. Left open: rule duplication for commutative ops.
• Go 1.9 — Done: automatic commutation (041ecb697f then relanded 53f8a6aeb0), chunked rewrite functions (fc7b83d192), no successor variables (eaa198f3d1), lazy config (193510f2f6), cheaper CSE (f791b288d1), Func/Config/Cache roles (43afcb5c96, a5e3cac895), *types.Type in SSA (46b88c9fbc), d11a2184fb earlier GC of freed constants, 3dcfce8d19. Left open: rules for different operand widths still repetitive.
• Go 1.10 — Done: 1787ced894 removes Symbol wrappers from Aux fields; ca360c3992 better XPos for rematerialized values and JMPs; f22cf7131a uses src.NoXPos for entry-block constants. Left open: nothing noted.
• Go 1.11 — Done: | alternation across 386, ARM, MIPS, MIPS64, PPC64, s390x and AMD64 rule files (ec62ee7f6d, cab7ba0b28, 3553262248, 8993e16932, ebeea20a49, 1e05924cf5, af11038428), 4f5389c321 moves SSA local type definitions to one location, aad71d3163 rewrites ssa/README.md, 398a8ed653 removes broken rules, 0029cd479e adds LocalAddr (SP,mem operands). Left open: nothing noted.

Multi-architecture SSA ports: ARM, 386, ARM64 (dev.ssa)

Span: Go 1.7 → Go 1.8 · Status at go1.17: still the design at go1.17 (each architecture owns ssa/gen/ARCH.rules, ARCHOps.go and cmd/compile/internal/ARCH/ssa.go) → continues as s390x, MIPS, 386 and 32-bit ARM backends (1.18+) and arm64 code generation and assembler (1.18+)

Continues in: 386, ARM (32-bit), MIPS/MIPS64 and the 387 removal (Go 1.12 → Go 1.17)

Earlier history: The arm64 (ARMv8) port (7g/7a/7l) (Go 1.5 → Go 1.6)

Design. Per-architecture backend = ARCHOps.go (op table with register masks and flags), ARCH.rules (lowering and peepholes), rewriteARCH.go (generated), and ARCH/ssa.go (emission from SSA values to obj.Prog). 1.7 had a4e31d42ee removing amd64 code from package gc and the core gen tool, making room for other arch backends, and 4c9a470d46 (“start on ARM port”). The 1.8 cycle is almost entirely about having every Go architecture generate code through SSA. ARM was staged in the open on dev.ssa: symbolic constants e1a2ea88d0, bools ccaed50c7b, shifts and multiplies 8f72690711, Zero/Move/Copy 8357ec37ae, Defer/RetJmp d108bc0e73, 64-bit decomposition 8756d9253f, 64-bit shifts 4636d02244, Div/Convert/GetClosurePtr e78d90beeb, floating point 59e11d7827, GetG 93b8aab5c9; the optimizations 8599fdd9b6, 8cc3f4a17e (shifted operands and indexed loads/stores, split shifts into several ops so constant folding and CSE work, conditional moves), df43cf033f (NilCheck), f55317828b (alignment for Zero/Move), 7d70f84f54 (FP, and teaching the runtime softfloat simulator to compare against 0), NaCl 6b6de15d32, and cf92e3845f (use a 2-result divide op).

386 got an initial port 14cf6e2083, with 64-bit ops aee8d8b9dd, “now works” df2f813bd2, GO386=387 c069bc4996, and PIC handling: 2cbdd55d64 handles that globals on 386 PIC need a two-instruction sequence with a CALL to a PC-getter into a tmp register, requiring careful register allocation; 77ef597f38, 8f955d3664, 94c8e59ae1 complete it. amd64p32 was ported at 69a755b602. ARM64 started with ae9570a5b9, 83208504fe, ed1ad8f56c, 659dd4f1d7 and d99cee79b9, which enables SSA by default for ARM64 after adding zero-register use, shifted ops, and fast division (previously disabled because the old backend generated slower code with it).

Timeline.

• Go 1.7 — Done: 4c9a470d46 starts ARM port; 7c6b48ffba fixes comparison and conditional branch for SSA on ARM; 74a9bad638 enables const division on arm64 (-67% for DivconstI64); 52fe472472 zeroes unaligned memory a byte at a time on ARM; f3d54789f7 power5 instructions for uint64 to float on ppc64; 1f4f2d0d39, bf151cc2aa unsigned to float fixes. Left open: all ports other than amd64 still on the old backend.
• Go 1.8 — Done: ARM (series above, d8181d5d75 simplify MOVWreg, 7b9873b9b9 NEGF/NEGD), 386 (14cf6e2083..df2f813bd2, c069bc4996, 2cbdd55d64), ARM64 (ae9570a5b9..d99cee79b9, ed1ad8f56c, b662e524e4 CBZ/CBNZ, 4d5bb76279), amd64p32 (69a755b602), many intrinsics. Left open: ARM64’s Duff device disabled on darwin (1e94d79f9d); ARM and ARM64 offset folding limits (see 1.9).
• Go 1.9 — Done: ARM64 address folding refactor 4eb48a336e, b53f0f8c96, 6464e5dc4b not folding offsets for args because args are not 8-byte aligned to SP; fb0ccc5d0a adds assembler support for large/unaligned loads and stores so folding can resume; 38fbada557 more ARM constant folding; 01b1a34aac rework of udiv on ARM; a041806335, 14f3ca56ed, 6897030fe3 assembler constant-pool avoidance. Left open: ARM64 assembler still rejects many forms (see assembler thread).

Multi-architecture SSA ports: PPC64, MIPS64, MIPS32, s390x

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17; ppc64x, mips64x, mipsx and s390x all remain stack-ABI backends → continues as PPC64 / Power10 backend (GOPPC64, prefixed instructions, PC-relative code) (1.18+) and s390x, MIPS, 386 and 32-bit ARM backends (1.18+)

Continues in: PPC64 / POWER backend and assembler (Go 1.12 → Go 1.17) · s390x backend: compare-and-branch, intrinsics, assembler (Go 1.12 → Go 1.17)

Earlier history: The ppc64 / ppc64le port (dev.power64, 9g/9a/9l) (Go 1.5 → Go 1.6) · The mips64 port and the mips/mips64 register space (Go 1.6 → Go 1.6)

Design. The same four-file scheme as above. PPC64 has no store-immediate, so 806cacc7c6 replaced the pseudo-instruction with storezero (R0 is reserved as zero in Go). The PPC64 SSA port started at 03d152f36f, with calls 2d16e43158, zero/move dede2061f3, compare-to-bool, shifts and high multiply dd1d9b36c6, loads/stores by type, shifts, divisions 01ae4b1da4, FP ff37d0e681 and d08010f94e, then 5b9ff11c3d “ppc64le working, not optimized enough” and eed061f89c enabling big-endian; address folding a1dc9465a1; nil-check removal 0e0ab20334. MIPS64 followed (310a40b4f2 start, e71e1fe87e working, 7f27f1dfdd optimizations plus SSA on by default). MIPS32 arrived as a new port 66fdf433b0 (cmd/internal/sys), 5d28bc58b6 (obj/mips), f58ce7fe79 (asm), 247fc4a98e (ssa), f4c997578a (compile). Big-endian 4-byte unaligned load rules were fixed in 26a6131bac.

s390x is the one wholly new architecture in the range: obj and asm in 1.7 (2a7e85f162, 13f97ea456, 85bbabd9c4, 354e9778a3), SSA lowering a223ccae38 and 613ba6cda8, and in 1.8 6ec993adc3 adds the SSA backend and enables it by default; 1cfb5c3fd5 adds canMergeLoad to decide whether a load can be merged into an operation without reordering relative to stores; 962dc4b44d improves load/store merging; 122abe6b12 folds extensions into constants; 3202aa7800 leaves constants visible to the compiler instead of hiding XOR -1 in the assembler; bd8a39b67a adds fused multiply-add (blocking fusion when a cast intervenes, with explicit float/complex OCONV kept as rounding operations); 8afa8a3374 uses 32-bit comparisons; 5d9c78201f allows R11.

Timeline.

• Go 1.7 — Done: s390x assembler/object/asm/ssa/gc support (2a7e85f162, 13f97ea456, 85bbabd9c4, 354e9778a3, a223ccae38, 613ba6cda8, cd6b2b7451, 3c8ef0e0c9 64-bit multiplication with immediates); MIPS64 REGTMP/SB/TLS work (a409fb80b0, 8dc0444a04, 981395103e, 3b0b30727c); ppc64x atomics (eeca3ba92f, with sync moved outside the lwarx/stwcx loop). Left open: s390x and MIPS64 only reach SSA in the next release.
• Go 1.8 — Done: PPC64 and PPC64le SSA, MIPS64 SSA (7f27f1dfdd), s390x SSA (6ec993adc3), MIPS32 new port (66fdf433b0..f4c997578a), SSA unconditional (167e381f40). Left open: PPC64 load/store merging and several float conversions still go through memory (44053de365^1.9 and 40e25895e3^1.10 fix this in 1.9/1.10).
• Go 1.9 — Done: PPC64 rotates (9248ff46a8, 01c8719f8b moves rotate generation to SSA), ANDN (95f3e47456^1.8, 695f12c21a), fused multiply-add (17570a9afb), LoweredZero/LoweredMove (23bd919136, a8b2e4a630, b8d327a438), register-based int/float conversion (44053de365, requiring Power8), 13c35a1b20 no scratch stack location, c644a76e1f removing OldArch checks, 4dbcb53d0b, ddf807fce8, f75b5e99ed s390x rule fixes, 93b7eb973f.
• Go 1.10 — Done: PPC64 math/Float64bits conversion rules (40e25895e3), Abs/Copysign (4d0151ede5), 622cfd8833 not folding global addresses into load/store on PPC64 so temp register reloads are not repeated, little-endian consecutive-byte load/store merging (bb1fd3b5ff), b74b43de68 requests R12 for indirect calls on ppc64le, s390x Abs/Copysign (96cdacb971) and rounding (7582494e06, 4745604bcb), 33c246ff92 immediate sign extension fix. Left open: big-endian ppc64 merging “will be done later” (bb1fd3b5ff).
• Go 1.11 — Done: ec62ee7f6d-style rule compaction, aff222cd18 smaller PPC64 rewrite, 8af0c77df3, 331c187b17, 8afa8a3374 s390x simplifications, ae10914e67 LAA/LAAG clobber flags, de186c63ce calls clobber g on s390x, ebb67d993a Round intrinsic on ppc64x, 6aeddb1b57 Sqrt on mips64, 30311e8860 loads without DS relocation for go.string on ppc64le, 1566bf9025. Left open: nothing noted.

WebAssembly backend

Span: Go 1.11 → Go 1.11 · Status at go1.17: still the design at go1.17 → continues as WebAssembly backend (1.18+)

Continues in: WebAssembly backend (Go 1.12 → Go 1.16)

Design. 3b137dd2df adds the wasm architecture to the compile command (design doc referenced from the message; generated opGen.go, rewriteWasm.go, obj/wasm/anames.go; linker support in a later commit). Go SSA instructions operate on registers while WebAssembly instructions operate on an operand stack, so one Go add would naively map to four WebAssembly instructions (push local A, push local B, add, store to local). 482d241936 “add wasm stack optimization” addresses that: it keeps single-use intermediate values on the wasm stack instead of round-tripping through locals. The remaining wasm-specific issues in 1.11 are fixes: valid offsets for Load/Store in the assembler (bf23a4e61d), write-barrier control value (8aa57f1e9d), OffPtr with negative offset (88dc4aee7c), and folding the offset into LoweredAddr (1d303a0086) so the address is rematerializable and not materialized before the variable becomes live (otherwise liveness complained about a variable live on entry).

Timeline.

• Go 1.11 — Done: user-visible new architecture in the compiler (3b137dd2df), stack optimization (482d241936), rule file name fix (cc0aaff40e), assembler offset fix (bf23a4e61d), write-barrier control (8aa57f1e9d), negative OffPtr (88dc4aee7c), address offset folding (1d303a0086). Left open: the linker half is separate (“A later commit will contain the corresponding linker changes”, 3b137dd2df).

Removal of the legacy backend and decoupling gc from the code generators

Span: Go 1.7 → Go 1.9 · Status at go1.17: done; the per-architecture ssa.go files are the only code generators → continues as Prologue, frame pointer, stack split and function alignment (cmd/internal/obj) (1.18+) (frame handling)

Earlier history: Per-architecture compilers 6g/8g/5g/9g and the shared gc code generator (Go 1.0 → Go 1.6)

Design. Until 1.7 each architecture had a cgen-style generator (5g/6g/8g/9g descendants) with gins, Naddr, Betypeinit, Thearch-driven register allocator reg.go and peep.go. In 1.8 167e381f40 made SSA compilation unconditional (removing ssa=0, GOSSAHASH, GOSSAPKG, SSATEST; GOSSAFUNC now only controls printing), e7cc9c4f4d “delete lots of the legacy backend”, followed by f03855f40e, 838eaa738f, ad7732a9ac (gins), 1f2930cb5c (old register allocator), 544010a05a (Betypeinit), 8a0bd5dc01/78c46581f4 (appendpp dedup), e6134702bb (simplify obj.ProgInfo). 882dd1c3ba then enabled rewritings that the old backends had blocked. In 1.9 the remaining dependencies on gc were cut so that the backend can run concurrently and on its own types: 3e2f980e27 passes gc.Thearch into GOARCH.Init, 352e19c92c eliminates Gins and Naddr, c3a50ad3c7 removes Prog-related globals, 0a94daa378 funnels SSA Prog creation through SSAGenState, 263ba3ac7b makes defframe arch-independent, da8e939ba9 threads Curfn through SSA and ef1ab0f0f4 forbids Curfn use in the backend. The stack frame itself is laid out during SSA (8c24bff52b, 1.8).

Timeline.

• Go 1.7 — Done: amd64 code removed from gc (a4e31d42ee); a40b27e304 eliminates arch-specific typedefs; cea5d26aa2 removes Thearch.Linkarchinit. Left open: old backend still compiles everything not in SSA.
• Go 1.8 — Done: unconditional SSA (167e381f40), legacy-backend deletion (e7cc9c4f4d, f03855f40e, 838eaa738f, ad7732a9ac, 1f2930cb5c, 544010a05a, ae7e0ad7b8, 24965bc96c), d6194c1fd1 changes goarch.Main into goarch.Init, 08feadbd6e removes Arch.REGCTXT, dd748cf314/bb2bbfa086/79db1625b9 simplify address generation, 8c24bff52b stack layout in SSA, c345a3913f removes BlockCall. Left open: the front end still reaches backend through global Curfn, Thearch.
• Go 1.9 — Done: Thearch plumbing (3e2f980e27, 3e63cdf850), Curfn removal (ef1ab0f0f4, 6652572b75, 1911087dee), Prog globals gone (c3a50ad3c7), 0a94daa378 SSAGenState, 263ba3ac7b defframe, 174b858f78 frame size passed to defframe. Left open: nothing noted.

Liveness, stack maps, safepoints and write barriers

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (liveness over SSA, asynchronous-preemption-capable register maps) → continues as Stack slot merging, liveness and stack maps (1.18+)

Continues in: Safepoints, unsafe points and stack maps for asynchronous preemption (Go 1.14 → Go 1.16)

Earlier history: Stack frames, pointer maps and liveness analysis in the compiler (Go 1.2 → Go 1.6)

Design. Liveness analysis (plive.go) originally ran over the legacy Prog list. The SSA backend initially kept it working by emitting Progs that it analysed afterward, with workarounds such as teaching the analysis about pxor and LEAW (73024083b0, 617e892b87), and splitting named compound AUTOs into one-word variables (4a7aba775d: liveness could not handle spilling to multiword types because there was no valid place for VARDEFs). Correctness items in 1.7/1.8: keeping heap pointers live for escaping output parameters (6effdd28de, 519b469795), args alive in tail calls (e3f1c66f31, 3dfb92f254), relaxing “ambiguously live” (6c5e377d23), args no longer live to end of function (ca4089ad62).

The big change was in 1.9: liveness was refactored (2d78538c12) and ported to the SSA CFG (325904fe6a, 1298 lines changed in plive.go), instead of analysing Progs. This depended on SymEffect attributes added to SSA ops (1cdf4bf33f, 691755304c), a map instead of Node.Opt for variable indices to avoid races (794d29a46f), and PC-order block visiting (ea8c7dae4f). b612ab3acb made liveness cheaper with many variables via sparse progeffects; 38dee12dea zeroes ambiguously live variables at VARKILLs; 7cd6310014 skips maps when the stack is too large. 1.8’s f6aec889e1 added the writebarrier phase: the front end emits StoreWB/MoveWB ops, which the phase expands to branches and runtime calls after writes to static stack locations have been recognized and their barriers removed (all instances found by the #17330 script eliminated except two false positives). 1.10’s 7e343134d3 adds compiler support for the buffered write barrier (initially amd64 only; old eager barrier kept so tests that need liveness maps at barrier calls can opt in); in 1.11 the runtime and compiler support for the buffered barrier is added for 386 (252f1170e5), amd64p32 (24dd83d7eb), arm (1de1f316df), arm64 (79594ee95a), mips64 (a39de96438), mips (313a4b2b7f), ppc64 (ae7d5f84f8) and s390x (2ae1e1ae2f).

In 1.11 liveness was generalized to all instructions: a367f44c18 makes almost every operation a safepoint (excluding runtime code other than calls, nosplit functions other than calls, instructions between the write-barrier flag load and the write, and instructions leading up to a uintptr→unsafe.Pointer conversion), 61158c162f tracks which registers contain live pointers (bitmaps in parallel with stack variables), ed7a0682e2 emits stack-map indexes wherever they change instead of only at CALLs, and 9f95c9db23 records register maps as FUNCDATA/PCDATA with an independent index. The cost was then reduced: d7d9df8a5b introduces LivenessMap/LivenessIndex, 75dadbec1e replaces a per-Value map with a dense slice, 3c36b8be66 compacts maps incrementally per block, 1e27e4807b trims trailing non-pointers in args maps, f11e9aac4f reuses structures via ssa.Cache, 577c05ca1c/60c76f7656/3c4aaf8a32 speed up bit-vector code; 132900982c ignores g in the analysis and 97bea97065 fixes the unsafe-point analysis with -N.

Timeline.

• Go 1.7 — Done: d5297f7261 fixes quadratic regalloc liveness (slice3.go >10m to ~20s), d2107fc987 GC bitmaps for SSA code, 4a7aba775d splitting compound autos, 3572c6418b pointer args live throughout, 6effdd28de, 519b469795, f4d38a8792 de-dups gclocals symbols. Left open: liveness still operates on Progs.
• Go 1.8 — Done: writebarrier phase (f6aec889e1), nil-check redo (3134ab3c2d: BlockCheck removed, multiple NilCheck ops per block, arch-specific elimination moved into a pass using new opcode flags), stack frame layout during SSA (8c24bff52b), 943f5afe22 stackmap dumping refactor, ca4089ad62. Left open: nothing noted.
• Go 1.9 — Done: SSA liveness (325904fe6a, 2d78538c12, ea8c7dae4f), 1cdf4bf33f/691755304c SymEffects, b612ab3acb, 38dee12dea, 7b8f51188b bitmap generation refactor, 8179b9b462 output params live with defer, 7cd6310014. Left open: nothing noted.
• Go 1.10 — Done: buffered write barrier compiler support (7e343134d3), 0153a4130d fixes runtime.KeepAlive, e130dcf051 aborts earlier on huge frames. Left open: buffered barrier only implemented on amd64 at this commit.
• Go 1.11 — Done: buffered write barrier on all remaining runtime architectures (252f1170e5, 24dd83d7eb, 1de1f316df, 79594ee95a, a39de96438, 313a4b2b7f, ae7d5f84f8, 2ae1e1ae2f), safepoints almost everywhere (a367f44c18), register liveness maps (61158c162f, 9f95c9db23, ed7a0682e2), memory optimization (d7d9df8a5b, 75dadbec1e, 3c36b8be66, f11e9aac4f, 1e27e4807b, bdb65da049), d15d055054/06b326054d reject huge argument areas, 85cfa4d55e degenerate write barrier case. Left open: optimized in later CLs (61158c162f: “We’ll optimize this in later CLs”).

DWARF variable locations, statement positions and inline info from the backend

Span: Go 1.9 → Go 1.11 · Status at go1.17: still the design at go1.17 (location lists generated from SSA LocalSlot tracking; is_stmt boundaries) → continues as Register allocator, scheduler and block-level backend passes (1.18+)

Continues in: Debug info generated by the backend: statements, location lists, line tables (Go 1.12 → Go 1.17)

Design. Position representation first changed on [dev.inline]: 82d0caea2c made src.Pos abstract, ad4efedc6c made obj.Prog use src.Pos, 4808fc4443 replaced it with syntax.Pos (the old LineHist table unused), and 472c792e0a introduced the compact 8-byte XPos (global translation table, O(1) conversion). 33c036867f removed LineHist remnants. For tracebacks with inlining, 699175a11a created two tables per function: an inlining tree stored in funcdata and a PC-value table mapping PCs to tree nodes (or -1); 4435fcfd6c (1.10) added DWARF inlined-instance records gated by -gendwarfinl=N (0 off, 1 without inlined-variable tracking, 2 with).

Optimized-code debugging came from [dev.debug]: 2d57d94ac3 tracks variable decomposition in LocalSlot, and 4c54a047c6 makes the compiler represent variable locations in registers/stack as DWARF location lists (previously all variables claimed to be on the stack, so debuggers showed stale data); limitations of SSA make it imprecise. 6bbe1bc940 extends ranges over control-flow instructions that do not come from Values; d58d90152b fixes RegKill timing; 2075a9323d (1.11) completely redesigns generation: no RegKills; liveness is recomputed from Op clobber information, avoiding adding RegKills to empty blocks. Memory use was cut (39eea62340, a306341db7, 9c854d65a3, 108efc79c7, e181852dd4, 438a757d73), stack-only variables tracked from VarDef/VarKill (44e65f2c94), and c2c1822b12 adds a pass to identify “first” SSA node per statement with never-boundary kinds (VarKill, VarDef, Phi), moving boundaries forward when values are removed, while dead03b794 makes the linker process is_stmt into line tables; b9a365681f adjusts is-statement flags. Related: ca360c3992, a042221cdb, 7bac2a95f6 plumbs prologueEnd, 3d6e4ec0a8-era arm64 DWARF register definitions (9b95611e38, 0eacf8cbdf).

Timeline.

• Go 1.9 — Done: XPos and src.Pos plumbing (82d0caea2c, ad4efedc6c, 4808fc4443, 472c792e0a), inline PC-value tables (699175a11a, 0824ae6dc1), dwarf.Var generation moved into the compiler (68177d9ec0), 1a7582f5e9, 00263a8968 line-number churn reduction. Left open: variables always described as being on the stack.
• Go 1.10 — Done: dev.debug location tracking (2d57d94ac3, 4c54a047c6), -gendwarfinl (4435fcfd6c), 3ba818c894 distinguishing args from return values, 6bbe1bc940, 0b6b5641d7 correct stack slots, d58d90152b, 87f83eac7f, 4a1be1e1da DW_AT_decl_line. Left open: location lists computed from regalloc liveness (replaced in 1.11).
• Go 1.11 — Done: location-list redesign (2075a9323d), memory reductions (39eea62340, a306341db7, 9c854d65a3, 108efc79c7, ac81c5c402), stack-only vars (44e65f2c94), statement boundaries (c2c1822b12, b9a365681f, dead03b794), line directives with columns (515fa58ac9, b3cb740be5), eca41af012 base address selectors for dsymutil. Left open: nothing noted.

Intrinsics for atomics, math/bits, math and runtime helpers

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (intrinsics table in ssa.go, SSA ops with per-arch lowerings) → continues as Atomics and memory-ordering code generation (1.18+) and Multi-word arithmetic, intrinsics and carry-chain support (1.18+)

Continues in: math/bits, atomic and runtime intrinsics (cross-architecture) (Go 1.12 → Go 1.17)

Design. Intrinsics are recognised in the front end by package/function name and replaced by generic SSA ops (or by inline code with explicit control flow), which each architecture lowers to one instruction. 1.7 started with 8eec2bbfbc (a first set of intrinsics; one was needed for the future GC, Bswap added as a convenience; the bit-scan family was left unfinished because “scan forward” and “count leading zeroes” don’t match). In 1.8, 320ddcf834 inlines atomic reads and writes on amd64; to keep atomic loads from being reordered they return a <value, memory> tuple, and the meaning of resultInArg0 for tuple ops was changed to mean the first part of the tuple. 84aac622a4 finishes the rest of runtime/internal/atomic on amd64. Other architectures: Ctz/Bswap on ARM64 (4354ffd38b) and ARM (8ff4260777), And8/Or8 on ARM64 (38d35e714a), s390x Ctz/Bswap (e94c52933b) and atomics (517a44d57e), ppc64x atomics (95c9583a18, 1.9), MIPS64 atomics (d63de28711, 1.10), 2756d56c89 math/big.mulWW/divWW on AMD64, d7c7d88b2c mulWW on ARM64.

1.9 introduced math/bits intrinsics: 495b167919 Len/LeadingZeros (the 8-bit case disabled because the Go table lookup was faster), 5cadc91b3c OnesCount on amd64 (guarded by a CPU-feature check because POPCNT may be missing; “Rewrite rules can’t generate control flow at the moment, so the intrinsifier needs to generate that code”), 42e97468a1 Reverse on ARM64, 8304d10763 OnesCount/Len/TrailingZeros on ppc64x, rotates 7e07e635f3 (non-constant, amd64), fa3fe2e3c6 (PPC64 rules matching the RotateLeft code), 01c8719f8b. 1.10 adds math functions: 94484d8ed5 Trunc/Ceil/Floor on amd64 (SSE4.1 round), 0f19e24da7 ppc64x, 7582494e06 s390x (and Round), 2f1f607b21 and 4745604bcb RoundToEven, fb05948d9e Abs on amd64 via int/fp register moves, 4d0151ede5 Abs/Copysign ppc64x, 96cdacb971 s390x. 6cac100eef (1.10) adds the caller-pc intrinsic; 6f3e5e637c getcallersp; and in 1.11 bd8a88729c, 20102594a0 extend getcallerpc to arm64 and all LR architectures. 1.11 additionally: ARMv8.1 LDADDAL for atomic add behind a CPU feature check (0a7ac93c27, Xadd 98% faster), fcba05148f OnesCount arm64, 07f0f09563 Ceil/Floor/Round/Trunc arm64, ebb67d993a Round ppc64x, 6aeddb1b57 Sqrt on mips64, 54dbab5221/1d321ada73 Ctz8/16 and Len8/16 ops on amd64, d9a50a6531 CtzNonZero from the prove pass, 8bf4b7e673 BSFL/BSRL as result-only ops.

Timeline.

• Go 1.7 — Done: first intrinsics (8eec2bbfbc). Left open: bit-scan family incomplete (8eec2bbfbc).
• Go 1.8 — Done: amd64 atomics (320ddcf834, 84aac622a4), ARM64/ARM/s390x intrinsics (4354ffd38b, 8ff4260777, 38d35e714a, e94c52933b, 517a44d57e), big arithmetic helpers (2756d56c89), 10f757486e bswap for big-endian reads. Left open: nothing noted.
• Go 1.9 — Done: math/bits (495b167919, 5cadc91b3c, 42e97468a1, 8304d10763), rotates (7e07e635f3, fa3fe2e3c6^1.10), ppc64x atomics (95c9583a18), fused multiply-add (bd8a39b67a, 17570a9afb). Left open: Len8 is disabled (495b167919).
• Go 1.10 — Done: math rounding and Abs intrinsics (94484d8ed5, 0f19e24da7, 7582494e06, 2f1f607b21, 4745604bcb, fb05948d9e, 4d0151ede5, 96cdacb971), caller pc/sp (6cac100eef, 6f3e5e637c), MIPS64 atomics (d63de28711). Left open: nothing noted.
• Go 1.11 — Done: the 1.11 items above (0a7ac93c27, fcba05148f, 07f0f09563, ebb67d993a, 6aeddb1b57, 54dbab5221, 1d321ada73, d9a50a6531, d7c7d88b2c, bd8a88729c, 20102594a0, 44b826bb28 (AtomicAnd8/Or8 register fix on ARM64)). Left open: nothing noted.

Memory-op combining, byte-order idioms and load/store folding

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (rewrite-rule based) → continues as Late-lower pass, memory-op combining and arch-independent rule migration (1.18+)

Design. Loads: 12e60452e9 combines smaller loads into a larger load using AMD64 rules (not stores: “harder because we need to make sure intermediate memory states aren’t observed”); 7294ccb54e joins indexed byte loads; da19a0cff4 and 481fe59012 fix address and offset bugs; b81f2f106f places the combined load at the location of the last byte load. Stores: 217c284995 (1.7) combines stores into larger widths and da34ddf24b (1.10) combines more constant stores. Byte-order idioms: 10f757486e (1.8) generates bswap+load/store for big-endian reads/writes (helping encoding/binary), bd91e3569a handles indexed stores, 4477fd097f handles 2-byte loads as a word load plus rolw 8, 0f2ef0ad44 (1.11) adds the missing LittleEndian.PutUint{16,32} rules, ARM64 mirrors these for little-endian (77ba071ec6) and big-endian stores (39fefa0709, 05962561ae), 9c99512d18 (1.10) combines consecutive loads and stores on amd64 (67fdf587dc then stops 64-bit combining), and PPC64 little-endian (bb1fd3b5ff). Load/op fusion: f94e0745b3, 9278a04a8f (1.7), 21c71d7788 (1.9, combine load+op on AMD64), 86dc86b4f9 (do not merge load+op if the other op arg is still live: 86dc86b4f9), 0fe58bf650; SETcc to memory (6b8a3c8889, 624630b824); ac29f4d01c ADD[Q|L]constmem; 1.11 4b00d3f4a2 compares directly with memory, 20cf5c4962 386 binary ops with a memory operand, cd65bbc01b 386 SUBL, 098ca846c7 ops with memory destination on 386; 29fcd57a9f folds offsets into memory ops; 983fca55c0 prefers non-indexed stores on amd64; a4e1a72f0a adds MOVLloadidx8/MOVLstoreidx8; 22115859a5/b1df8d6ffa LEAL{1,2,4,8}. Subword elision bugs: 9613a638a9, 1e0819101b.

Timeline.

• Go 1.7 — Done: load combining (12e60452e9, 7294ccb54e, b81f2f106f, 481fe59012), store combining (217c284995), idx1 loads/stores (af517da2f9), ec5083e49b SHLQ into loads/stores, 3dd4f74e06 shifts into LEAs, 036d09d5bf/dc5a7682f0/9e3c68f1e0 32-bit operands for byte ops, drop most byte/word insns. Left open: bounds checks of combined loads separate issue (12e60452e9).
• Go 1.8 — Done: bswap idioms (10f757486e), 33b71dfa1c/f357091a6d combine extensions with loads, s390x merging (962dc4b44d, 1cfb5c3fd5), deb4177cf0 masks instead of branches for slicing (Slicemask better in 3d5eb4a6be^1.9, 1.9). Left open: nothing noted.
• Go 1.9 — Done: bd91e3569a, 4477fd097f, 21c71d7788, 0fe58bf650, 86dc86b4f9, b548eee3d9/074b73b1b2 fixes, f9bec9eb42 (MOVL for small constants: 1657 MOVQ replaced, binary 4KB smaller).
• Go 1.10 — Done: 9c99512d18, da34ddf24b, 67fdf587dc, 624630b824, 6b8a3c8889, ac29f4d01c, bb1fd3b5ff, a2f22a6803 indexed MOVB/MOVBU/MOVH/MOVHU on ARM, 782ee23884 redundant zero extension removal. Left open: big-endian ppc64 merging (bb1fd3b5ff).
• Go 1.11 — Done: 0f2ef0ad44, 77ba071ec6, 39fefa0709, ecd9e8a2fe zero stores combined on arm64, 34f5f8a580/aaf73c6d1e register-indexed and shifted-register-indexed ARM64 loads/stores, 4b00d3f4a2, 20cf5c4962, 098ca846c7, 29fcd57a9f, 983fca55c0. Left open: nothing noted.

amd64 and 386 instruction selection

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 → continues as amd64 code generation and GOAMD64 microarchitecture levels (1.18+)

Continues in: amd64 lowering: read-modify-write, load-op, addressing modes pass, intrinsic-friendly rules (Go 1.12 → Go 1.17)

Earlier history: Expression and statement code quality in 6g/8g/5g (division, bounds checks, loops, slices, interfaces) (Go 1.0 → Go 1.6)

Design. The AMD64 rules grew from the straight lowering in 1.7. 1.7: sub-word ops became 32-bit ops (036d09d5bf, dc5a7682f0, 9e3c68f1e0, e96b232993 promote byte/word operation, 04945edd40 ANDQ to MOV?ZX); multiply strength-reduction (d8f1f8d856); constant folding (7a4211bc1f, d8ee180ab2 CMPQ/ANDQ, 8448d3aace CMPconst and SHR, afafab3b97 shifts with 6-bit counter); 7a60a962b9 ECX reserved for PIC. 1.8: 8589049d5c breaks false dependency of CVTSL2SS etc. by XORing the destination (and fixes a regression since 1.7), cc0248aea5 stops reserving X15 for float sub/div, c53879512f missing float indexed loads/stores, d251030fa6 no >32-bit constants folded into MULQ, 7ff0c8267f. 1.9: f9bec9eb42, 3e63cdf850, 9d5987d79f (upper-bit-clear idiom via shift-rotate), cfb0d34992. 1.10: df70982825 (SSE 16-byte stores to zero small blocks; duffzero only for 65+ bytes; duffzero now uses leaq to avoid clobbering flags), 14cb41584d/adbfdfe377 useSSE flag so Plan 9 avoids MOVO (no FP in the note handler), 18b48afec9 MOVQconvert as resultInArg0, 03614562ca, a5868a47c6 moves MOV→XOR rewriting for zero from the assembler into the compiler, 40649e6979. 1.11: bit-test BT/BTS/BTR/BTC patterns (79112707bb, eb44b8635c removes BTQconst rule), CMOV (080187f4f7), f4d9c30901, 85a8d25d53 IMUL3, 6a74fe2f15 more constant multiplication, d292f77e95 2*x+c as LEAx1, 54dbab5221, 3f483e6520, 24cd112086 double NEG, 4f7b774822 Move specialization, 098ca846c7/cd65bbc01b/20cf5c4962 for 386, 4c800f03c9 large offsets on 386 (1.10), d3026dd30a, f5d4863130. 386 SSE vs 387 chosen once in Init (3e2f980e27).

Timeline.

• Go 1.7 — Done: the items above; 6b02a19247 SSE4.2 strings.Index; 009c002c92 AVX2 for sha. Left open: indexed forms incomplete.
• Go 1.8 — Done: 8589049d5c, cc0248aea5, c53879512f, 10f757486e, d251030fa6.
• Go 1.9 — Done: f9bec9eb42, 9d5987d79f, 0fe58bf650, a4e1a72f0a^1.10 (actually 1.10), 3e63cdf850.
• Go 1.10 — Done: df70982825, 14cb41584d, adbfdfe377, a5868a47c6, a4e1a72f0a, ac29f4d01c, 6b8a3c8889, 7dd279013b. Left open: ADDconst rematerialization reverted (2cb61aa3f7).
• Go 1.11 — Done: the 1.11 items above, plus 0cacc4d0e2, 22115859a5, b1df8d6ffa, c284171bbb, 8bf4b7e673, 29e5a81e28 BS{F,R}L clobber flags, b71ea0b7dd CMOVLEQF clobbers AX.

ARM and ARM64 instruction selection and fused operations

Span: Go 1.8 → Go 1.11 · Status at go1.17: still the design at go1.17 → continues as arm64 code generation and assembler (1.18+)

Continues in: arm64 backend and assembler (Go 1.12 → Go 1.17)

Design. Both ARM backends gained patterns for instructions that combine several operations, mostly contributed in 1.10–1.11 with each CL citing a micro-benchmark. 32-bit ARM: MULS (64607dbd26), MULAF/MULSF/MULAD/MULSD (a07176b45a), NMULF/NMULD (2899c3e8cb), BFX/BFXU bit-field extract (9732485851), CMN/TST/TEQ (1ec78d1dd1), single-instruction MOVB/MOVH sign/zero-extensions on ARMv6/7 (78ea9a7129), indexed byte/half loads (a2f22a6803), bc723cf340 AuxInt must fit int32, b08a9b7ecc switching to portable softfloat for GOARM=5 (the compiler generates runtime calls for FP rather than the assembler inserting _sfloat calls). ARM64: CSEL (2d0172c3a7), TBZ/TBNZ when comparing with zero (cdd961630c), FNMUL (ebb77aa867), MNEG (3c8b824453, 20046020c4), FMADD/FMSUB/FNMADD/FNMSUB (f4c3072cf5, with a FP accuracy bug fixed by 7113d3a512), bitfield opcodes EXTR/BFI/BFXIL/SBFIZ/SBFX/UBFIZ/UBFX (e244a7a7d3), EON/ORN (1057624985), CMN/TST (f524268c40), shifted/indexed memory ops (34f5f8a580, aaf73c6d1e), 51932c326f fixing shift absorption leaving dead Values that inflated use counts, RBIT/REV (8577f81a10), 257b01f8f4 ANDconst to mask leading/trailing bits, ARMv8.1 LSE atomics (0a7ac93c27), fb0ccc5d0a offset folding. c02fc1605a zeroes memory with STP of ZR pairs; b46d398887 memclr with ZVA; 8916773a3d DUFFCOPY with LDP.

Timeline.

• Go 1.8 — Done: initial ARM (8cc3f4a17e) and ARM64 (d99cee79b9, ed1ad8f56c, 659dd4f1d7) optimizations. Left open: assembler restrictions on offsets.
• Go 1.9 — Done: 8577f81a10, 257b01f8f4, 4eb48a336e, fb0ccc5d0a, 38fbada557.
• Go 1.10 — Done: ARM fused ops and extensions (a2f22a6803, 64607dbd26, 2899c3e8cb, a07176b45a, 9732485851, 1ec78d1dd1, 78ea9a7129), ARM64 07ec4385f1 omit boolean zero extension, c02fc1605a.
• Go 1.11 — Done: ARM64 fused ops and CSEL (2d0172c3a7, cdd961630c, ebb77aa867, 3c8b824453, f4c3072cf5, e244a7a7d3, 1057624985, f524268c40, 34f5f8a580, aaf73c6d1e, ecd9e8a2fe, 77ba071ec6, 39fefa0709), f6ce1e2aa5/78a579316b bugfixes, b08a9b7ecc softfloat on ARM.

Memory clearing and copying: Zero, Move and Duff’s device

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (Duff’s device for large Zero/Move, inline stores for small) → continues as Duff’s device replaced by generated loops; Zero/Move lowering (1.20+)

Earlier history: Zeroing and copying: Duff’s device, REP, unaligned moves and AVX2 runtime assembly (Go 1.0 → Go 1.6)

Design. SSA Zero and Move ops lower to straight-line stores below a size threshold, DUFFZERO/DUFFCOPY entry points for mid-size blocks, and REP string ops for large blocks. 1.7: 66b47812eb initial zeroing, f8fc3710fd mem copies in the amd64 backend, 039d455f9d and d55a099e22 don’t use duffzero/duffcopy on Plan 9, 111d590f86 fixes a possible spill of an invalid pointer with DUFFZERO on AMD64 (Duff device clobbers registers the allocator thinks hold live pointers), 4219aba5db REPSTOSQ clobbers flags. 1.8: 9d4b40f55d implements and uses DUFFCOPY on ARM64, 1e94d79f9d disables Duff on darwin/arm64, 114c05962c fixes the invalid pointer spill in large Zero/Move on ARM, c69dd3f054 enables DUFFZERO in defframe on MIPS64, f5516559e6 fixes zero-range merging. 1.9: ppc64x LoweredZero/LoweredMove improvements (23bd919136: ClearFat12 -71%, ClearFat16 -91%; a8b2e4a630). 1.10: df70982825 16-byte SSE zeroing (duffzero only 65+ bytes, since each duffzero call also saves/restores BP), c02fc1605a STP of ZR on arm64, da34ddf24b. 1.11: 4f7b774822 direct movs for Move up to 79 bytes on amd64 (sizes 32/48/64 with SSE), 094258408d overlapping MOVDs for fractional words on arm64, ecd9e8a2fe, 8916773a3d uses LDP in DUFFCOPY on ARM64, b46d398887 ZVA memclr.

Timeline.

• Go 1.7 — Done: 66b47812eb, f8fc3710fd, 039d455f9d, d55a099e22, 111d590f86. Left open: Duff’s device unsafe interplay with the allocator.
• Go 1.8 — Done: 9d4b40f55d, 1e94d79f9d, 114c05962c, c69dd3f054, dede2061f3 (PPC zeroing and moves).
• Go 1.9 — Done: 23bd919136, a8b2e4a630, b8d327a438, fddc004537 no nil check for Zero/Move on 386, AMD64 and S390X.
• Go 1.10 — Done: df70982825, c02fc1605a, 3fda3765b8 (PPC64 rule regression fix).
• Go 1.11 — Done: 4f7b774822, 094258408d, ecd9e8a2fe, 8916773a3d, b46d398887. Left open: Duff’s device still used for mid-size blocks (later replaced).

cmd/internal/obj: Prog/LSym refactoring, concurrent backend and object-writing

Span: Go 1.7 → Go 1.11 · Status at go1.17: still the design at go1.17 (assemblers take a newprog allocator, per-function FuncInfo) → continues as Prologue, frame pointer, stack split and function alignment (cmd/internal/obj) (1.18+)

Continues in: New object file format and content-addressable symbols (dev.link, assembler side) (Go 1.14 → Go 1.16)

Earlier history: Normalising Prog/Addr in cmd/internal/obj (the portable instruction representation) (Go 1.5 → Go 1.6) · liblink: a shared assembler/linker library (Go 1.3 → Go 1.5)

Design. The Go-ified liblink (cmd/internal/obj) was reshaped over this range to make the assembler stage independent of global state, as a prerequisite for the concurrent backend (-c). 1.7: 0d9258a830 introduces a distinct As type for opcodes (e853131699 stops using as+ALAST as an opcode), 2dcbbbd193/4f753e77f1 remove obj.ADATA (data now written directly into LSyms 7c18f8cdc3), symbol references added to the object file (3648d2d4cd, 16029babe2 dedup), 24fc323442 splits plist flushing from object writing, 014f3e1e09 an idiomatic object writer, 8262564971 estimates x86 text size, fe5eac63c4 hoists fieldtrack. 1.8: 1bd91d4ccc removes Addr.Etype/Width, 7124056f7e drops Gotype, d391dc260a makes LSym attributes a bitfield (LSym 136 to 128 bytes on 64-bit), 6fe1febc86 replaces AGLOBL with (*Link).Globl, 246074d043 removes ACHECKNIL, 9b88fac00c/0cd8faf744 reduce per-arch opcode space with a safety check, e6134702bb extracts ProgInfo, 4c9a372946 removes rewindmorestack, d61c07ffd8 introduces ctxt.Logf. 1.9 is the big cleanup: bed8129ee6 removes the Follow pass (which reordered/copied even hand-written assembly; SSA now lays code out well), 7c84dc79fd bumps the object magic to go19ld, 9cb2ee0ff2 moves STEXT-only fields into a FuncInfo struct (1747078695 un-embeds it), ce3ee7cdae moves Text flags from From3.Offset into From.Sym.Attribute, Prog allocation moved to clients (5b59b32c97, 5c359d8083), eager initialization (3b251e603d, 63c1aff60b), 735fe51a4b adds LookupInit for lazily initialised LSyms, hash split by version (6e97c71cb7, then 405a280d01 eliminates LSym.Version), 26308fb481 tracks pcln filenames as strings (removing 85% of Ctxt.Lookup calls), assemblers made concurrency-safe (x86 2ebe1bdd89/4f122e82fe AsmBuf; arm dcf643f1fd; mips c4135d61bb; arm64 b5931020b7; ppc64 f95de5c679; s390x 1e69245418), removal of Curp/Cursym/Mode/Asmode globals (7e817859b3, 166160b446, a470e5d4b8, cfb3c8df62, cf2b32e719), 826a09cd65 SortSlice, da15fe6870 gclocals handling, 18fb670e5e fixing LSym.Type at compile time instead of in the linker, 1e3570ac86 extracts shared objabi, and in the compiler 6664ccb453 compiles more complex functions first (statement count as a proxy) and 1213776650 uses a buffered channel for the function queue. 1.10: 8c67f210a1 changes Prog.From3 to RestArgs []Addr so instructions can carry many operands (needed for AVX/AVX-512).