go/src/cmd/compile/internal/ssa/stackalloc.go, branch makepkg

cmd/compile: optimize liveness in stackalloc

2025-11-12T18:02:27Z

The stackalloc code needs to run a liveness pass to build the interference graph between stack slots. Because the values that we need liveness over is so sparse, we can optimize the analysis by using a path exploration algorithm rather than a iterative dataflow one In local testing, this cuts 74.05 ms of CPU time off a build of cmd/compile. Change-Id: I765ace87d5e8aae177e65eb63da482e3d698bea7 Reviewed-on: https://go-review.googlesource.com/c/go/+/718540 Reviewed-by: Keith Randall Auto-Submit: Keith Randall Reviewed-by: Junyang Shao LUCI-TryBot-Result: Go LUCI Reviewed-by: Keith Randall

cmd/compile: use the builtin clear

2025-04-18T11:21:12Z

To simplify the code a bit. Change-Id: Ia72f576de59ff161ec389a4992bb635f89783540 GitHub-Last-Rev: eaec8216be964418a085649fcca53a042f28ce1a GitHub-Pull-Request: golang/go#73411 Reviewed-on: https://go-review.googlesource.com/c/go/+/666117 LUCI-TryBot-Result: Go LUCI Auto-Submit: Keith Randall Reviewed-by: Michael Pratt Reviewed-by: Keith Randall Reviewed-by: Keith Randall

cmd/compile: soften type matching when allocating stack slots

2024-02-29T21:29:41Z

Currently we use pointer equality on types when deciding whether we can reuse a stack slot. That's too strict, as we don't guarantee pointer equality for the same type. In particular, it can vary based on whether PtrTo has been called in the frontend or not. Instead, use the type's LinkString, which is guaranteed to both be unique for a type, and to not vary given two different type structures describing the same type. Update #65783 Change-Id: I64f55138475f04bfa30cfb819b786b7cc06aebe4 Reviewed-on: https://go-review.googlesource.com/c/go/+/565436 Reviewed-by: Keith Randall Reviewed-by: Matthew Dempsky LUCI-TryBot-Result: Go LUCI Auto-Submit: Keith Randall Reviewed-by: Cuong Manh Le

cmd/compile/internal/ssa: replace Frontend.Auto with Func.NewLocal

2023-09-08T19:09:14Z

Change-Id: I0858568d225daba1c318842dc0c9b5e652dff612 Reviewed-on: https://go-review.googlesource.com/c/go/+/526519 Auto-Submit: Matthew Dempsky LUCI-TryBot-Result: Go LUCI Reviewed-by: Keith Randall Reviewed-by: Keith Randall

cmd/compile: add cache of sizeable objects so they can be reused

2022-10-31T21:41:20Z

We kind of have this mechanism already, just normalizing it and using it in a bunch of places. Previously a bunch of places cached slices only for the duration of a single function compilation. Now we can reuse slices across a whole compiler run. Use a sync.Pool of powers-of-two sizes. This lets us use not too much memory, and avoid holding onto memory we're no longer using when a GC happens. There's a few different types we need, so generate the code for it. Generics would be useful here, but we can't use generics in the compiler because of bootstrapping. Change-Id: I6cf37e7b7b2e802882aaa723a0b29770511ccd82 Reviewed-on: https://go-review.googlesource.com/c/go/+/444820 Run-TryBot: Keith Randall Reviewed-by: Heschi Kreinick TryBot-Result: Gopher Robot Reviewed-by: David Chase

cmd/compile: manage Slot array better

2021-05-08T17:03:18Z

steals idea from CL 312093 further investigation revealed additional duplicate slots (equivalent, but not equal), so delete those too. Rearranged Func.Names to be addresses of slots, create canonical addresses so that split slots (which use those addresses to refer to their parent, and split slots can be further split) will preserve "equivalent slots are equal". Removes duplicates, improves metrics for "args at entry". Change-Id: I5bbdcb50bd33655abcab3d27ad8cdce25499faaf Reviewed-on: https://go-review.googlesource.com/c/go/+/312292 Trust: David Chase Run-TryBot: David Chase TryBot-Result: Go Bot Reviewed-by: Cherry Mui

cmd/compile: make the stack allocator more careful about register args.

2021-05-03T17:46:12Z

Assignment between input parameters causes them to have more than one "Name", and running this backwards from names to values can end up confusing (conflating) parameter spill slots. Around 105a6e9518, this cases a stack overflow running go test -race encoding/pem because two slice parameters spill (incorrectly) into the same stack slots (in the AB?I-defined parameter spill area). This also tickles a failure in cue, which turned out to be easier to isolate. Fixes #45851. Updates #40724. Change-Id: I39c56815bd6abb652f1ccbe83c47f4f373a125c3 Reviewed-on: https://go-review.googlesource.com/c/go/+/313212 Trust: David Chase Run-TryBot: David Chase TryBot-Result: Go Bot Reviewed-by: Cherry Zhang

cmd/compile: spill all the parameters around morestack

2021-04-16T20:12:20Z

former code only spilled those parameters mentioned in code AT THE REGISTER LEVEL, this caused problems with liveness sometimes (which worked on whole variables including aggregates). Updates #40724. Change-Id: Ib9fdc50d95d1d2b1f1e405dd370540e88582ac71 Reviewed-on: https://go-review.googlesource.com/c/go/+/310690 Trust: David Chase Run-TryBot: David Chase TryBot-Result: Go Bot Reviewed-by: Cherry Zhang

Revert "cmd/compile: ensure spills of int/float reg args land in abi slots"

2021-04-09T15:01:13Z

This reverts CL 308510. Reason for revert: It breaks "GOEXPERIMENT=regabi,regabiargs ./make.bash" Change-Id: I553654690ec73120f8a6258dd80623853c430df0 Reviewed-on: https://go-review.googlesource.com/c/go/+/308932 Trust: David Chase Reviewed-by: Cherry Zhang

cmd/compile: ensure spills of int/float reg args land in abi slots

2021-04-09T14:33:44Z

We noticed a while ago that register argument spills were not always landing where they should. Updates #40724. Change-Id: I0b7c3279a2f6270577481c252bae4568cbb6e796 Reviewed-on: https://go-review.googlesource.com/c/go/+/308510 Trust: David Chase Run-TryBot: David Chase Reviewed-by: Cherry Zhang