aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/compile/internal/walk
AgeCommit message (Collapse)Author
2026-02-02internal/maps,cmd/compile/internal/walk: replace calls to mapaccess1* with ↵ArsenySamoylov
mapaccess2* mapaccess1* and mapaccess2* functions share the same implementation and differ only in whether the boolean "found" is returned. This change replaces mapaccess1* calls with mapaccess2*. We can do this transparently, since the call site can safely discard the second (boolean) result. Ideally, mapacces1* functions could be removed entirely, but this change keeps them as thin wrappers for compatibility. Fixes #73196 Change-Id: I07c3423d22ed1095ac3666d00e134c2747b2f9c1 Reviewed-on: https://go-review.googlesource.com/c/go/+/736020 Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Michael Pratt <mpratt@google.com> Auto-Submit: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org>
2026-01-28cmd/compile: simplify slice/array range loops on loong64Guoqi Chen
loong64 supports R+R addressing ({st,ld}x.{b,h,w,d} instructions) and has implemented the relevant lowering rules (only width is 1). Removes 1616 instructions from the go binary on loong64. file before after Δ % asm 575366 575314 -52 -0.0090% cgo 489972 489884 -88 -0.0180% compile 2920418 2920110 -308 -0.0105% cover 540458 540290 -168 -0.0311% fix 865840 865668 -172 -0.0199% link 732858 732662 -196 -0.0267% preprofile 246022 245978 -44 -0.0179% vet 839268 839124 -144 -0.0172% go 1666470 1666114 -356 -0.0214% gofmt 326526 326438 -88 -0.0270% total 9203198 9201582 -1616 -0.0176% Change-Id: If3518547c785764877a6cf987781d43d8b572990 Reviewed-on: https://go-review.googlesource.com/c/go/+/738240 Reviewed-by: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
2026-01-23cmd/compile: simplify AlgType usageKeith Randall
Only walk needs to distinguish different sizes of AMEM. Move the size-distinguishing AlgType there. Change-Id: I0a725b5bd13795a623b3668325f1068579abd340 Reviewed-on: https://go-review.googlesource.com/c/go/+/727461 Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Carlos Amedee <carlos@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2026-01-23cmd/compile: clean up eq and hash implementationsKeith Randall
Use unsafe.Pointer instead of *any as the argument type. Now that we're using signatures, we don't have exact types so we might as well use unsafe.Pointer everywhere. Simplify hash function choice a bit. Change-Id: If1a07091031c4b966fde3a1d66295a04fd5a838c Reviewed-on: https://go-review.googlesource.com/c/go/+/727501 Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com>
2026-01-23cmd/compile: redo how equality functions are generatedkhr@golang.org
Instead of generating an equality function for each type that needs it, generate one per "signature". A "signature" is a summary of the comparisons needed to check a type for equality. For instance, the type type S struct { i int32 j uint32 s string e error } Will have the signature "M8SI". M8 = 8 bytes of regular memory S = string I = nonempty interface This way, potentially many types that have the same signature can share the same equality function. The number of generated equality functions in the go binary is reduced from 634 to 286. The go binary is ~1% smaller. The generation of equality functions gets simpler (particularly, how we do inlining of sub-types, unrolling, etc.) and the generated code is probably a bit more efficient. The new function names are kind of weird, but will seldom show up for users. They will appear in cpu profiles, and in tracebacks in the situation where comparisons panic because an interface somewhere in the type being compared contains an uncomparable type (e.g. a slice). Note that this CL only affects generated comparison functions. It does not generally affect generated code for == (except when that code decides to call a comparison function as a subtask). Maybe a TODO for the future. Update #6853 Change-Id: I202bd6424cb6bf7c745a62c9603d4f01dc1a1fc8 Reviewed-on: https://go-review.googlesource.com/c/go/+/725380 Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Keith Randall <khr@google.com>
2026-01-22cmd/compile: fix mis-compilation for static array initializationCuong Manh Le
The bug was first introduced when the compiler is still written in C, with CL 2254041. The static array was laid out with the wrong context, causing a stack pointer will be stored in global object. Fixes #61730 Fixes #77193 Change-Id: I22c8393314d251beb53db537043a63714c84f36a Reviewed-on: https://go-review.googlesource.com/c/go/+/737821 Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Keith Randall <khr@golang.org>
2025-11-24runtime: add GODEBUG=tracebacklabels=1 to include pprof labels in tracebacksDavid Finkel
Copy LabelSet to an internal package as label.Set, and include (escaped) labels within goroutine stack dumps. Labels are added to the goroutine header as quoted key:value pairs, so the line may get long if there are a lot of labels. To handle escaping, we add a printescaped function to the runtime and hook it up to the print function in the compiler with a new runtime.quoted type that's a sibling to runtime.hex. (in fact, we leverage some of the machinery from printhex to generate escape sequences). The escaping can be improved for printable runes outside basic ASCII (particularly for languages using non-latin stripts). Additionally, invalid UTF-8 can be improved. So we can experiment with the output format make this opt-in via a a new tracebacklabels GODEBUG var. Updates #23458 Updates #76349 Change-Id: I08e78a40c55839a809236fff593ef2090c13c036 Reviewed-on: https://go-review.googlesource.com/c/go/+/694119 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Michael Pratt <mpratt@google.com> Auto-Submit: Michael Pratt <mpratt@google.com> Reviewed-by: Alan Donovan <adonovan@google.com>
2025-11-20cmd/compile: stack allocate backing stores during appendkhr@golang.org
We can already stack allocate the backing store during append if the resulting backing store doesn't escape. See CL 664299. This CL enables us to often stack allocate the backing store during append *even if* the result escapes. Typically, for code like: func f(n int) []int { var r []int for i := range n { r = append(r, i) } return r } the backing store for r escapes, but only by returning it. Could we operate with r on the stack for most of its lifeime, and only move it to the heap at the return point? The current implementation of append will need to do an allocation each time it calls growslice. This will happen on the 1st, 2nd, 4th, 8th, etc. append calls. The allocations done by all but the last growslice call will then immediately be garbage. We'd like to avoid doing some of those intermediate allocations if possible. We rewrite the above code by introducing a move2heap operation: func f(n int) []int { var r []int for i := range n { r = append(r, i) } r = move2heap(r) return r } Using the move2heap runtime function, which does: move2heap(r): If r is already backed by heap storage, return r. Otherwise, copy r to the heap and return the copy. Now we can treat the backing store of r allocated at the append site as not escaping. Previous stack allocation optimizations now apply, which can use a fixed-size stack-allocated backing store for r when appending. See the description in cmd/compile/internal/slice/slice.go for how we ensure that this optimization is safe. Change-Id: I81f36e58bade2241d07f67967d8d547fff5302b8 Reviewed-on: https://go-review.googlesource.com/c/go/+/707755 Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: David Chase <drchase@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-10-30cmd/compile: implement bits.Mul64 on 32-bit systemsRuss Cox
This CL implements Mul64uhilo, Hmul64, Hmul64u, and Avg64u on 32-bit systems, with the effect that constant division of both int64s and uint64s can now be emitted directly in all cases, and also that bits.Mul64 can be intrinsified on 32-bit systems. Previously, constant division of uint64s by values 0 ≤ c ≤ 0xFFFF were implemented as uint32 divisions by c and some fixup. After expanding those smaller constant divisions, the code for i/999 required: (386) 7 mul, 10 add, 2 sub, 3 rotate, 3 shift (104 bytes) (arm) 7 mul, 9 add, 3 sub, 2 shift (104 bytes) (mips) 7 mul, 10 add, 5 sub, 6 shift, 3 sgtu (176 bytes) For that much code, we might as well use a full 64x64->128 multiply that can be used for all divisors, not just small ones. Having done that, the same i/999 now generates: (386) 4 mul, 9 add, 2 sub, 2 or, 6 shift (112 bytes) (arm) 4 mul, 8 add, 2 sub, 2 or, 3 shift (92 bytes) (mips) 4 mul, 11 add, 3 sub, 6 shift, 8 sgtu, 4 or (196 bytes) The size increase on 386 is due to a few extra register spills. The size increase on mips is due to add-with-carry being hard. The new approach is more general, letting us delete the old special case and guarantee that all int64 and uint64 divisions by constants are generated directly on 32-bit systems. This especially speeds up code making heavy use of bits.Mul64 with a constant argument, which happens in strconv and various crypto packages. A few examples are benchmarked below. pkg: cmd/compile/internal/test benchmark \ host local linux-amd64 s7 linux-386 s7:GOARCH=386 vs base vs base vs base vs base vs base DivconstI64 ~ ~ ~ -49.66% -21.02% ModconstI64 ~ ~ ~ -13.45% +14.52% DivisiblePow2constI64 ~ ~ ~ +0.97% -1.32% DivisibleconstI64 ~ ~ ~ -20.01% -48.28% DivisibleWDivconstI64 ~ ~ -1.76% -38.59% -42.74% DivconstU64/3 ~ ~ ~ -13.82% -4.09% DivconstU64/5 ~ ~ ~ -14.10% -3.54% DivconstU64/37 -2.07% -4.45% ~ -19.60% -9.55% DivconstU64/1234567 ~ ~ ~ -61.55% -56.93% ModconstU64 ~ ~ ~ -6.25% ~ DivisibleconstU64 ~ ~ ~ -2.78% -7.82% DivisibleWDivconstU64 ~ ~ ~ +4.23% +2.56% pkg: math/bits benchmark \ host s7 linux-amd64 linux-386 s7:GOARCH=386 vs base vs base vs base vs base Add ~ ~ ~ ~ Add32 +1.59% ~ ~ ~ Add64 ~ ~ ~ ~ Add64multiple ~ ~ ~ ~ Sub ~ ~ ~ ~ Sub32 ~ ~ ~ ~ Sub64 ~ ~ -9.20% ~ Sub64multiple ~ ~ ~ ~ Mul ~ ~ ~ ~ Mul32 ~ ~ ~ ~ Mul64 ~ ~ -41.58% -53.21% Div ~ ~ ~ ~ Div32 ~ ~ ~ ~ Div64 ~ ~ ~ ~ pkg: strconv benchmark \ host s7 linux-amd64 linux-386 s7:GOARCH=386 vs base vs base vs base vs base ParseInt/Pos/7bit ~ ~ -11.08% -6.75% ParseInt/Pos/26bit ~ ~ -13.65% -11.02% ParseInt/Pos/31bit ~ ~ -14.65% -9.71% ParseInt/Pos/56bit -1.80% ~ -17.97% -10.78% ParseInt/Pos/63bit ~ ~ -13.85% -9.63% ParseInt/Neg/7bit ~ ~ -12.14% -7.26% ParseInt/Neg/26bit ~ ~ -14.18% -9.81% ParseInt/Neg/31bit ~ ~ -14.51% -9.02% ParseInt/Neg/56bit ~ ~ -15.79% -9.79% ParseInt/Neg/63bit ~ ~ -15.68% -11.07% AppendFloat/Decimal ~ ~ -7.25% -12.26% AppendFloat/Float ~ ~ -15.96% -19.45% AppendFloat/Exp ~ ~ -13.96% -17.76% AppendFloat/NegExp ~ ~ -14.89% -20.27% AppendFloat/LongExp ~ ~ -12.68% -17.97% AppendFloat/Big ~ ~ -11.10% -16.64% AppendFloat/BinaryExp ~ ~ ~ ~ AppendFloat/32Integer ~ ~ -10.05% -10.91% AppendFloat/32ExactFraction ~ ~ -8.93% -13.00% AppendFloat/32Point ~ ~ -10.36% -14.89% AppendFloat/32Exp ~ ~ -9.88% -13.54% AppendFloat/32NegExp ~ ~ -10.16% -14.26% AppendFloat/32Shortest ~ ~ -11.39% -14.96% AppendFloat/32Fixed8Hard ~ ~ ~ -2.31% AppendFloat/32Fixed9Hard ~ ~ ~ -7.01% AppendFloat/64Fixed1 ~ ~ -2.83% -8.23% AppendFloat/64Fixed2 ~ ~ ~ -7.94% AppendFloat/64Fixed3 ~ ~ -4.07% -7.22% AppendFloat/64Fixed4 ~ ~ -7.24% -7.62% AppendFloat/64Fixed12 ~ ~ -6.57% -4.82% AppendFloat/64Fixed16 ~ ~ -4.00% -5.81% AppendFloat/64Fixed12Hard -2.22% ~ -4.07% -6.35% AppendFloat/64Fixed17Hard -2.12% ~ ~ -3.79% AppendFloat/64Fixed18Hard -1.89% ~ +2.48% ~ AppendFloat/Slowpath64 -1.85% ~ -14.49% -18.21% AppendFloat/SlowpathDenormal64 ~ ~ -13.08% -19.41% pkg: crypto/internal/fips140/nistec/fiat benchmark \ host s7 linux-amd64 linux-386 s7:GOARCH=386 vs base vs base vs base vs base Mul/P224 ~ ~ -29.95% -39.60% Mul/P384 ~ ~ -37.11% -63.33% Mul/P521 ~ ~ -26.62% -12.42% Square/P224 +1.46% ~ -40.62% -49.18% Square/P384 ~ ~ -45.51% -69.68% Square/P521 +90.37% ~ -25.26% -11.23% (The +90% is a separate problem and not real; that much variation can be seen on that system by running the same binary from two different files.) pkg: crypto/internal/fips140/edwards25519 benchmark \ host s7 linux-amd64 linux-386 s7:GOARCH=386 vs base vs base vs base vs base EncodingDecoding ~ ~ -34.67% -35.75% ScalarBaseMult ~ ~ -31.25% -30.29% ScalarMult ~ ~ -33.45% -32.54% VarTimeDoubleScalarBaseMult ~ ~ -33.78% -33.68% Change-Id: Id3c91d42cd01def6731b755e99f8f40c6ad1bb65 Reviewed-on: https://go-review.googlesource.com/c/go/+/716061 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Russ Cox <rsc@golang.org> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com>
2025-10-29runtime: use internal/strconvRuss Cox
Runtime doing its own number formatting dates back to when runtime was the bottom-most Go package. Those days are long gone. Use internal/strconv to avoid duplicating code and also to get better floating-point formatting: % go1.24.6 run x.go +1.234568e+004 % go run x.go 12345.678 % With accurate floating point it becomes necessary to introduce separate printers for float32 vs float64 and for complex64 vs complex128. Otherwise float32(93.7) prints as 93.69999694824219. Change-Id: I25ae3f09519342dc3d1dcabf4711651423e00128 Reviewed-on: https://go-review.googlesource.com/c/go/+/716002 Reviewed-by: David Chase <drchase@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-10-03cmd/compile: minor tweak for race detectorDavid Chase
This makes the front-end a little bit less temp-happy when instrumenting, which repairs the "is it a constant?" test in the simd intrinsic conversion which is otherwise broken by race detection. Also, this will perhaps be better code. Cherry-picked from the dev.simd branch. This CL is not necessarily SIMD specific. Apply early to reduce risk. Change-Id: I84b7a45b7bff62bb2c9f9662466b50858d288645 Reviewed-on: https://go-review.googlesource.com/c/go/+/685637 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Junyang Shao <shaojunyang@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-on: https://go-review.googlesource.com/c/go/+/708856
2025-08-05cmd/compile, runtime: add checkptr instrumentation for unsafe.AddCuong Manh Le
Fixes #74431 Change-Id: Id651ea0b82599ccaff8816af0a56ddbb149b6f89 Reviewed-on: https://go-review.googlesource.com/c/go/+/692015 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org> Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: t hepudds <thepudds1460@gmail.com> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
2025-07-30all: remove redundant Swiss prefixesMichael Pratt
Now that there is only one map implementation we can simplify names. For #54766. Change-Id: I6a6a636cc6a8fc5e7712c27782fc0ced7467b939 Reviewed-on: https://go-review.googlesource.com/c/go/+/691596 Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Michael Pratt <mpratt@google.com> Reviewed-by: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-07-30all: remove GOEXPERIMENT=swissmapMichael Pratt
For #54766. Change-Id: I6a6a636c40b5fe2e8b0d4a5e23933492bc8bb76e Reviewed-on: https://go-review.googlesource.com/c/go/+/691595 Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Michael Pratt <mpratt@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org>
2025-07-25cmd/compile: remove unused arg from gorecoverKeith Randall
We don't need this argument anymore to match up a recover with its corresponding panic. Change-Id: I5d3646cdd766259ee9d3d995a2f215f02e17abc6 Reviewed-on: https://go-review.googlesource.com/c/go/+/685555 Reviewed-by: Michael Knyszek <mknyszek@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
2025-06-30cmd/compile/internal/escape: add debug hash for literal allocation optimizationsthepudds
Several CLs earlier in this stack added optimizations to reduce user allocations by recognizing and taking advantage of literals, including CL 649555, CL 649079, and CL 649035. This CL adds debug hashing of those changes, which enables use of the bisect tool, such as 'bisect -compile=literalalloc go test -run=Foo'. This also allows these optimizations to be manually disabled via '-gcflags=all=-d=literalallochash=n'. Updates #71359 Change-Id: I854f7742a6efa5b17d914932d61a32b2297f0c88 Reviewed-on: https://go-review.googlesource.com/c/go/+/675415 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: David Chase <drchase@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com>
2025-06-04Revert "cmd/compile: Enable inlining of tail calls"Cherry Mui
This reverts CL 650455 and CL 655816. Reason for revert: it causes #73747. Properly fixing it gets into trickiness with defer/recover, wrapper, and inlining. We're late in the Go 1.25 release cycle. Fixes #73747. Change-Id: Ifb343d522b18fec3fec73a7c886678032ac8e4df Reviewed-on: https://go-review.googlesource.com/c/go/+/678575 Reviewed-by: Carlos Amedee <carlos@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
2025-05-27cmd/compile/internal/walk: use original type for composite literals in addrTempthepudds
When creating a new *ir.Name or *ir.LinksymOffsetExpr to represent a composite literal stored in the read-only data section, we should use the original type of the expression that was found via ir.ReassignOracle.StaticValue. (This is needed because the StaticValue method can traverse through OCONVNOP operations to find its final result.) Otherwise, the compilation may succeed, but the linker might erroneously conclude that a type is not used and prune an itab when it should not, leading to a call at execution-time to runtime.unreachableMethod, which throws "fatal error: unreachable method called. linker bug?". The tests exercise both the case of a zero value struct literal that can be represented by the read-only runtime.zeroVal, which was the case of the simplified example from #73888, and also modifies that example to test the non zero value struct literal case. This CL makes two similar changes for those two cases. We can get either of the tests we are adding to fail independently if we only make a single corresponding change. Fixes #73888 Updates #71359 Change-Id: Ifd91f445cc168ab895cc27f7964a6557d5cc32e5 Reviewed-on: https://go-review.googlesource.com/c/go/+/676517 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Michael Knyszek <mknyszek@google.com>
2025-05-21cmd/compile, unique: model data flow of non-string pointersCherry Mui
Currently, hash/maphash.Comparable escapes its parameter if it contains non-string pointers, but does not escape strings or types that contain strings but no other pointers. This is achieved by a compiler intrinsic. unique.Make does something similar: it stores its parameter to a central map, with strings cloned. So from the escape analysis's perspective, the non-string pointers are passed through, whereas string pointers are not. We currently cannot model this type of type-dependent data flow directly in Go. So we do this with a compiler intrinsic. In fact, we can unify this and the intrinsic above. Tests are from Jake Bailey's CL 671955 (thanks!). Fixes #73680. Change-Id: Ia6a78e09dee39f8d9198a16758e4b5322ee2c56a Reviewed-on: https://go-review.googlesource.com/c/go/+/675156 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: David Chase <drchase@google.com> Reviewed-by: Jake Bailey <jacob.b.bailey@gmail.com>
2025-05-21cmd/compile/internal/walk: use global zeroVal in interface conversions for ↵thepudds
zero values This is a small-ish adjustment to the change earlier in our stack in CL 649555, which started creating read-only global storage for a composite literal used in an interface conversion and setting the interface data pointer to point to that global storage. In some cases, there are execution-time performance benefits to point to runtime.zeroVal in particular. In reflect, pointer checks against the runtime.zeroVal memory address are used to side-step some work, such as in reflect.Value.Set and reflect.Value.IsZero. In this CL, we therefore dig up the zeroVal symbol, and we use the machinery from earlier in our stack to use a pointer to zeroVal for the interface data pointer if we see examples like: sink = S{} or: s := S{} sink = s CL 649076 (also earlier in our stack) added most of the tests along with debug diagnostics in convert.go to make it easier to test this change. We add a benchmark in reflect to show examples of performance benefit. The left column is our immediately prior CL 649555, and the right is this CL. (The arrays of structs here do not seem to benefit, which we attempt to address in our next CL). goos: linux goarch: amd64 pkg: reflect cpu: Intel(R) Xeon(R) CPU @ 2.80GHz │ cl-649555 │ new │ │ sec/op │ sec/op vs base │ Zero/IsZero/ByteArray/size=16-4 4.176n ± 0% 4.171n ± 0% ~ (p=0.151 n=20) Zero/IsZero/ByteArray/size=64-4 6.921n ± 0% 3.864n ± 0% -44.16% (p=0.000 n=20) Zero/IsZero/ByteArray/size=1024-4 21.210n ± 0% 3.878n ± 0% -81.72% (p=0.000 n=20) Zero/IsZero/BigStruct/size=1024-4 25.505n ± 0% 5.061n ± 0% -80.15% (p=0.000 n=20) Zero/IsZero/SmallStruct/size=16-4 4.188n ± 0% 4.191n ± 0% ~ (p=0.106 n=20) Zero/IsZero/SmallStructArray/size=64-4 8.639n ± 0% 8.636n ± 0% ~ (p=0.973 n=20) Zero/IsZero/SmallStructArray/size=1024-4 79.99n ± 0% 80.06n ± 0% ~ (p=0.213 n=20) Zero/IsZero/Time/size=24-4 7.232n ± 0% 3.865n ± 0% -46.56% (p=0.000 n=20) Zero/SetZero/ByteArray/size=16-4 13.47n ± 0% 13.09n ± 0% -2.78% (p=0.000 n=20) Zero/SetZero/ByteArray/size=64-4 14.14n ± 0% 13.70n ± 0% -3.15% (p=0.000 n=20) Zero/SetZero/ByteArray/size=1024-4 24.22n ± 0% 20.18n ± 0% -16.68% (p=0.000 n=20) Zero/SetZero/BigStruct/size=1024-4 24.24n ± 0% 20.18n ± 0% -16.73% (p=0.000 n=20) Zero/SetZero/SmallStruct/size=16-4 13.45n ± 0% 13.10n ± 0% -2.60% (p=0.000 n=20) Zero/SetZero/SmallStructArray/size=64-4 14.12n ± 0% 13.69n ± 0% -3.05% (p=0.000 n=20) Zero/SetZero/SmallStructArray/size=1024-4 24.62n ± 0% 21.61n ± 0% -12.26% (p=0.000 n=20) Zero/SetZero/Time/size=24-4 13.59n ± 0% 13.40n ± 0% -1.40% (p=0.000 n=20) geomean 14.06n 10.19n -27.54% Finally, here are results from the benchmark example from #71323. Note however that almost all the benefit shown here is from our earlier CL 649555, which is a more general purpose change and eliminates the allocation using a different read-only global than this CL. │ go1.24 │ new │ │ sec/op │ sec/op vs base │ InterfaceAny 112.6000n ± 5% 0.8078n ± 3% -99.28% (p=0.000 n=20) ReflectValue 11.63n ± 2% 11.59n ± 0% ~ (p=0.330 n=20) │ go1.24.out │ new.out │ │ B/op │ B/op vs base │ InterfaceAny 224.0 ± 0% 0.0 ± 0% -100.00% (p=0.000 n=20) ReflectValue 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=20) ¹ │ go1.24.out │ new.out │ │ allocs/op │ allocs/op vs base │ InterfaceAny 1.000 ± 0% 0.000 ± 0% -100.00% (p=0.000 n=20) ReflectValue 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=20) ¹ Updates #71359 Updates #71323 Change-Id: I64d8cf1a7900f011d2ec59b948388aeda1150676 Reviewed-on: https://go-review.googlesource.com/c/go/+/649078 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: David Chase <drchase@google.com>
2025-05-21cmd/compile/internal/walk: convert composite literals to interfaces without ↵thepudds
allocating Today, this interface conversion causes the struct literal to be heap allocated: var sink any func example1() { sink = S{1, 1} } For basic literals like integers that are directly used in an interface conversion that would otherwise allocate, the compiler is able to use read-only global storage (see #18704). This CL extends that to struct and array literals as well by creating read-only global storage that is able to represent for example S{1, 1}, and then using a pointer to that storage in the interface when the interface conversion happens. A more challenging example is: func example2() { v := S{1, 1} sink = v } In this case, the struct literal is not directly part of the interface conversion, but is instead assigned to a local variable. To still avoid heap allocation in cases like this, in walk we construct a cache that maps from expressions used in interface conversions to earlier expressions that can be used to represent the same value (via ir.ReassignOracle.StaticValue). This is somewhat analogous to how we avoided heap allocation for basic literals in CL 649077 earlier in our stack, though here we also need to do a little more work to create the read-only global. CL 649076 (also earlier in our stack) added most of the tests along with debug diagnostics in convert.go to make it easier to test this change. See the writeup in #71359 for details. Fixes #71359 Fixes #71323 Updates #62653 Updates #53465 Updates #8618 Change-Id: I8924f0c69ff738ea33439bd6af7b4066af493b90 Reviewed-on: https://go-review.googlesource.com/c/go/+/649555 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@google.com>
2025-05-20cmd/compile/internal/escape: additional constant and zero value tests and ↵thepudds
logging This adds additional logging for the work that walk does to reduce how often an interface conversion results in an allocation. Also, as part of #71359, we will be updating how escape analysis and walk handle basic literals, composite literals, and zero values, so add some tests that uses this new logging. By the end of our CL stack, we address all of these tests. Updates #71359 Change-Id: I43fde8343d9aacaec1e05360417908014a86c8bd Reviewed-on: https://go-review.googlesource.com/c/go/+/649076 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: David Chase <drchase@google.com> Auto-Submit: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-05-19cmd/compile: align stack-allocated backing stores higher than requiredKeith Randall
Because that's what mallocgc did and some user code came to rely on it. Fixes #73199 Change-Id: I45ca00d2ea448e6729ef9ac4cec3c1eb0ceccc89 Reviewed-on: https://go-review.googlesource.com/c/go/+/666116 Reviewed-by: t hepudds <thepudds1460@gmail.com> Reviewed-by: Keith Randall <khr@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Keith Randall <khr@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com>
2025-04-24cmd/compile: add cast in range loop final value computationKeith Randall
When replacing a loop where the iteration variable has a named type, we need to compute the last iteration value as i = T(len(a)-1), not just i = len(a)-1. Fixes #73491 Change-Id: Ic1cc3bdf8571a40c10060f929a9db8a888de2b70 Reviewed-on: https://go-review.googlesource.com/c/go/+/667815 Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Keith Randall <khr@google.com> Reviewed-by: Junyang Shao <shaojunyang@google.com> Reviewed-by: Keith Randall <khr@google.com>
2025-04-21cmd/compile: ensure we evaluate side effects of len() argKeith Randall
For any len() which requires the evaluation of its arg (according to the spec). Update #72844 Change-Id: Id2b0bcc78073a6d5051abd000131dafdf65e7f26 Reviewed-on: https://go-review.googlesource.com/c/go/+/658097 Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com>
2025-04-21cmd/compile: don't evaluate side effects of range over arrayKeith Randall
If the thing we're ranging over is an array or ptr to array, and it doesn't have a function call or channel receive in it, then we shouldn't evaluate it. Typecheck the ranged-over value as a constant in that case. That makes the unified exporter replace the range expression with a constant int. Change-Id: I0d4ea081de70d20cf6d1fa8d25ef6cb021975554 Reviewed-on: https://go-review.googlesource.com/c/go/+/659317 Reviewed-by: Junyang Shao <shaojunyang@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Robert Griesemer <gri@google.com>
2025-04-15cmd/compile/internal/escape: add hash for bisecting stack allocation of ↵thepudds
variable-sized makeslice CL 653856 enabled stack allocation of variable-sized makeslice results. This CL adds debug hashing of that change, plus a debug flag to control the byte threshold used. The debug hashing machinery means we also now have a way to disable just the CL 653856 optimization by doing -gcflags='all=-d=variablemakehash=n' or similar, though the stderr output will then typically have many lines of debug hash output. Using this CL plus the bisect command, I was able to retroactively find one of the lines of code responsible for #73199: $ bisect -compile=variablemake go test -skip TestListWireGuardDrivers [...] bisect: FOUND failing change set --- change set #1 (enabling changes causes failure) ./security_windows.go:1321:38 (variablemake) ./security_windows.go:1321:38 (variablemake) --- Previously, I had tracked down those lines by diffing '-gcflags=-m=1' output and brief code inspection, but seeing the bisect was very nice. This CL also adds a compiler debug flag to control the threshold for stack allocation of variably sized make results. This can help us identify more code that is relying on certain stack allocations. This might be a temporary flag that we delete prior to Go 1.25 (given we would not want people to rely on it), or maybe it might make sense to keep it for some period of time beyond the release of Go 1.25 to help the ecosystem shake out other bugs. Using these two flags together (and picking a threshold of 64 rather than the default of 32), it looks for example like this x/sys/windows code might be relying on stack allocation of a byte slice: $ bisect -compile=variablemake go test -gcflags=-d=variablemakethreshold=64 -skip TestListWireGuardDrivers [...] bisect: FOUND failing change set --- change set #1 (enabling changes causes failure) ./syscall_windows_test.go:1178:16 (variablemake) Updates #73199 Fixes #73253 Change-Id: I160179a0e3c148c3ea86be5c9b6cea8a52c3e5b7 Reviewed-on: https://go-review.googlesource.com/c/go/+/663795 Auto-Submit: Keith Randall <khr@golang.org> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-04-11cmd/compile: turn off variable-sized make() stack allocation with -NKeith Randall
Give people a way to turn this optimization off. (Currently the constant-sized make() stack allocation is not disabled with -N. Kinda inconsistent, but oh well, probably worse to change it now.) Update #73253 Change-Id: Idb9ffde444f34e70673147fd6a962368904a7a55 Reviewed-on: https://go-review.googlesource.com/c/go/+/664655 Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> Reviewed-by: Jorropo <jorropo.pgm@gmail.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: t hepudds <thepudds1460@gmail.com>
2025-04-04cmd/compile: allow pointer-containing elements in stack allocationsKeith Randall
For variable-sized allocations. Turns out that we already implement the correct escape semantics for this case. Even when the result of the "make" does not escape, everything assigned into it does. Change-Id: Ia123c538d39f2f1e1581c24e4135a65af3821c5e Reviewed-on: https://go-review.googlesource.com/c/go/+/657937 Reviewed-by: Cherry Mui <cherryyz@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Robert Griesemer <gri@google.com>
2025-04-04cmd/compile: stack allocate variable-sized makesliceKeith Randall
Instead of always allocating variable-sized "make" calls on the heap, allocate a small, constant-sized array on the stack and use that array as the backing store if it is big enough. Requires the result of the "make" doesn't escape. if cap <= K { var arr [K]E slice = arr[:len:cap] } else { slice = makeslice(E, len, cap) } Pretty conservatively for now, K = 32/sizeof(E). The slice header is already 24 bytes, so wasting 32 bytes of stack if the requested size is too big isn't that bad. Larger would waste more stack space but maybe avoid more allocations. This CL also requires the element type be pointer-free. Maybe we could relax that at some point, but it is hard. If the element type has pointers we can get heap->stack pointers (in the case where the requested size is too big and the slice is heap allocated). Note that this only handles the case of makeslice called directly from compiler-generated code. It does not handle slices built in the runtime on behalf of the program (e.g. in growslice). Some of those are currently handled by passing in a tmpBuf (e.g. concatstrings), but we could probably do more. Change-Id: I8378efad527cd00d25948a80b82a68d88fbd93a1 Reviewed-on: https://go-review.googlesource.com/c/go/+/653856 Reviewed-by: Robert Griesemer <gri@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cherry Mui <cherryyz@google.com>
2025-03-11cmd/compile: Enable inlining of tail callsAlexander Musman
Enable inlining tail calls and do not limit emitting tail calls only to the non-inlineable methods when generating wrappers. This change produces additional code size reduction. Code size difference measured with this change (tried for x86_64): etcd binary: .text section size: 10613393 -> 10593841 (0.18%) total binary size: 33450787 -> 33424307 (0.07%) compile binary: .text section size: 10171025 -> 10126545 (0.43%) total binary size: 28241012 -> 28192628 (0.17%) cockroach binary: .text section size: 83947260 -> 83694140 (0.3%) total binary size: 263799808 -> 263534160 (0.1%) Change-Id: I694f83cb838e64bd4c51f05b7b9f2bf0193bb551 Reviewed-on: https://go-review.googlesource.com/c/go/+/650455 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@golang.org> Auto-Submit: Keith Randall <khr@golang.org>
2025-02-25cmd/compile, runtime: optimize concatbytesCuong Manh Le
CL 527935 optimized []byte(string1 + string2) to use runtime.concatbytes to prevent concatenating of strings before converting to slices. However, the optimization is implemented without allowing temporary buffer for slice on stack, causing un-necessary allocations. To fix this, optimize concatbytes to use temporary buffer if the result string length fit to the buffer size. Fixes #71943 Change-Id: I1d3c374cd46aad8f83a271b8a5ca79094f9fd8db Reviewed-on: https://go-review.googlesource.com/c/go/+/652395 Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Michael Pratt <mpratt@google.com>
2025-02-13cmd/compile: move []byte->string map key optimization to ssaKeith Randall
If we call slicebytetostring immediately (with no intervening writes) before calling map access or delete functions with the resulting string as the key, then we can just use the ptr/len of the slicebytetostring argument as the key. This avoids an allocation. Fixes #44898 Update #71132 There's old code in cmd/compile/internal/walk/order.go that handles some of these cases. 1. m[string(b)] 2. s := string(b); m[s] 3. m[[2]string{string(b1),string(b2)}] The old code handled cases 1&3. The new code handles cases 1&2. We'll leave the old code around to keep 3 working, although it seems not terribly common. Case 2 happens particularly after inlining, so it is pretty common. Change-Id: I8913226ca79d2c65f4e2bd69a38ac8c976a57e43 Reviewed-on: https://go-review.googlesource.com/c/go/+/640656 Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Michael Pratt <mpratt@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-02-10cmd/compile: avoid ifaceeq call if we know the interface is directKeith Randall
We can just use == if the interface is direct. Fixes #70738 Change-Id: Ia9a644791a370fec969c04c42d28a9b58f16911f Reviewed-on: https://go-review.googlesource.com/c/go/+/635435 Auto-Submit: Keith Randall <khr@golang.org> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: David Chase <drchase@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-02-04cmd/compile: prefer hv2 <= 127 over hv2 < 128Jakub Ciolek
This is shorter to encode on AMD64/x86. Shrinks a few functions and doesn't seem to cause any regressions. No size impact on other archs. Covers a bit more than CL 639935. compilecmp linux/amd64: unicode/utf8 unicode/utf8.RuneCountInString changed unicode/utf8.RuneCount changed unicode/utf8 [cmd/compile] unicode/utf8.RuneCount changed unicode/utf8.RuneCountInString changed runtime runtime.countrunes changed runtime.stringtoslicerune 413 -> 379 (-8.23%) runtime [cmd/compile] runtime.countrunes changed runtime.stringtoslicerune 413 -> 379 (-8.23%) bytes bytes.containsRune 143 -> 139 (-2.80%) bytes.IndexAny changed bytes.Runes 462 -> 455 (-1.52%) bytes.trimLeftUnicode changed bytes.trimRightUnicode 325 -> 316 (-2.77%) bytes.LastIndexAny 1261 -> 1256 (-0.40%) bytes.Count 524 -> 520 (-0.76%) strings strings.Map 1241 -> 1230 (-0.89%) strings.TrimFunc 261 -> 255 (-2.30%) strings.Count changed strings.IndexRune changed strings.TrimLeftFunc 249 -> 241 (-3.21%) strings.explode 462 -> 441 (-4.55%) strings.IndexAny changed strings.ToValidUTF8 changed strings.FieldsFunc 744 -> 741 (-0.40%) strings.EqualFold 638 -> 625 (-2.04%) strings.IndexFunc 185 -> 179 (-3.24%) strings.ContainsFunc 189 -> 185 (-2.12%) strings.indexFunc 213 -> 209 (-1.88%) go/build/constraint go/build/constraint.(*exprParser).lex changed go/build/constraint.isValidTag changed regexp/syntax regexp/syntax.isValidCaptureName 180 -> 174 (-3.33%) regexp/syntax.literalRegexp changed regexp/syntax.(*parser).parsePerlFlags changed regexp/syntax.parse changed time time.tzsetName 471 -> 455 (-3.40%) time.tzsetRule 2476 -> 2444 (-1.29%) time.tzsetNum 389 -> 365 (-6.17%) time.quote 1239 -> 1221 (-1.45%) time.tzsetOffset 1332 -> 1317 (-1.13%) io/fs io/fs.FileMode.String changed reflect reflect.Value.Seq2.func4 changed reflect.Value.Seq.func4 changed reflect.isValidFieldName 265 -> 261 (-1.51%) bytes [cmd/compile] bytes.Runes 462 -> 455 (-1.52%) bytes.trimLeftUnicode changed bytes.LastIndexAny 1261 -> 1256 (-0.40%) bytes.IndexAny changed bytes.trimRightUnicode 325 -> 316 (-2.77%) bytes.Count 524 -> 520 (-0.76%) bytes.containsRune 143 -> 139 (-2.80%) strings [cmd/compile] strings.indexFunc 213 -> 209 (-1.88%) strings.IndexAny changed strings.FieldsFunc 744 -> 741 (-0.40%) strings.IndexRune changed strings.Count changed strings.IndexFunc 185 -> 179 (-3.24%) strings.Map 1241 -> 1230 (-0.89%) strings.TrimFunc 261 -> 255 (-2.30%) strings.ToValidUTF8 changed strings.explode 462 -> 441 (-4.55%) strings.EqualFold 638 -> 625 (-2.04%) strings.ContainsFunc 189 -> 185 (-2.12%) strings.TrimLeftFunc 249 -> 241 (-3.21%) go/build/constraint [cmd/compile] go/build/constraint.(*exprParser).lex changed go/build/constraint.isValidTag changed regexp/syntax [cmd/compile] regexp/syntax.literalRegexp changed regexp/syntax.parse changed regexp/syntax.(*parser).parsePerlFlags changed regexp/syntax.isValidCaptureName 180 -> 174 (-3.33%) fmt fmt.(*ss).scanOne changed fmt.(*ss).scanUint changed fmt.(*ss).scanInt changed fmt.(*fmt).pad changed fmt.(*ss).getBase 447 -> 435 (-2.68%) fmt.(*fmt).fmtS 217 -> 211 (-2.76%) fmt.(*ss).consume changed fmt.(*fmt).fmtQ 494 -> 485 (-1.82%) fmt.(*fmt).truncateString changed fmt.(*ss).scanComplex changed fmt.(*ss).okVerb 410 -> 409 (-0.24%) fmt.(*ss).convertString 447 -> 436 (-2.46%) fmt.(*ss).peek changed fmt.FormatString 650 -> 625 (-3.85%) fmt.(*fmt).padString changed fmt.(*ss).convertFloat changed fmt.(*ss).scanBool changed fmt.indexRune changed time [cmd/compile] time.tzsetNum 389 -> 365 (-6.17%) time.tzsetOffset 1332 -> 1317 (-1.13%) time.tzsetName 471 -> 455 (-3.40%) time.tzsetRule 2476 -> 2444 (-1.29%) time.quote 1239 -> 1221 (-1.45%) net/url net/url.validOptionalPort 189 -> 186 (-1.59%) net/url.validUserinfo 229 -> 204 (-10.92%) net/url.parseAuthority 972 -> 948 (-2.47%) net/url.parseHost 1372 -> 1371 (-0.07%) net/url.splitHostPort 584 -> 581 (-0.51%) reflect [cmd/compile] reflect.isValidFieldName 265 -> 261 (-1.51%) reflect.Value.Seq2.func4 changed reflect.Value.Seq.func4 changed compress/gzip compress/gzip.(*Writer).writeString changed encoding/json encoding/json.isValidTag 313 -> 308 (-1.60%) testing testing.rewrite changed testing.(*B).ReportMetric changed mime mime.consumeValue 1012 -> 997 (-1.48%) mime.isToken 180 -> 172 (-4.44%) mime.checkMediaTypeDisposition changed mime.FormatMediaType 6375 -> 6343 (-0.50%) mime.consumeToken changed mime.needsEncoding 137 -> 135 (-1.46%) mime.WordEncoder.Encode 216 -> 210 (-2.78%) mime.consumeMediaParam 1620 -> 1605 (-0.93%) mime.hasNonWhitespace 142 -> 139 (-2.11%) mime.(*WordDecoder).DecodeHeader 2643 -> 2630 (-0.49%) mime.ParseMediaType 3037 -> 3035 (-0.07%) go/token go/token.IsIdentifier changed encoding/asn1 encoding/asn1.makeField changed text/tabwriter text/tabwriter.(*Writer).Write 3465 -> 3454 (-0.32%) text/tabwriter.(*Writer).updateWidth changed text/tabwriter.(*Writer).endEscape 335 -> 327 (-2.39%) internal/buildcfg internal/buildcfg.goriscv64 changed go/doc/comment go/doc/comment.wrap 5496 -> 5489 (-0.13%) go/doc/comment.(*Printer).Text 1033 -> 1030 (-0.29%) go/doc/comment.validImportPath 661 -> 648 (-1.97%) go/doc/comment.(*Heading).DefaultID changed go/doc/comment.(*textPrinter).text 1070 -> 1069 (-0.09%) archive/tar archive/tar.splitUSTARPath changed archive/tar.(*Writer).writeRawFile changed archive/tar.(*Reader).readHeader 2416 -> 2415 (-0.04%) archive/tar.isASCII 136 -> 133 (-2.21%) archive/tar.Header.allowedFormats.func1 changed archive/tar.toASCII 415 -> 393 (-5.30%) archive/tar.(*Writer).writePAXHeader.func1 645 -> 627 (-2.79%) crypto/x509/pkix crypto/x509/pkix.RDNSequence.String 1502 -> 1486 (-1.07%) go/constant go/constant.(*stringVal).String changed vendor/golang.org/x/net/idna vendor/golang.org/x/net/idna.decode changed vendor/golang.org/x/net/idna.encode 2000 -> 1968 (-1.60%) internal/trace/raw internal/trace/raw.readArgs 783 -> 781 (-0.26%) internal/trace/raw.NewTextReader 1158 -> 1157 (-0.09%) internal/trace/raw.readToken 542 -> 532 (-1.85%) cmd/internal/objabi cmd/internal/objabi.DecodeArg changed cmd/internal/quoted cmd/internal/quoted.Join changed cmd/internal/pkgpath cmd/internal/pkgpath.toSymbolV3 changed cmd/internal/pkgpath.toSymbolV2 changed testing/fstest testing/fstest.(*fsTester).checkGlob changed text/template text/template.JSEscapeString changed text/template.goodName changed io/fs [cmd/compile] io/fs.FileMode.String changed go/printer go/printer.sanitizeImportPath 470 -> 463 (-1.49%) go/printer.(*printer).isOneLineFieldList changed go/printer.identListSize 261 -> 254 (-2.68%) go/doc go/doc.assumedPackageName changed go/doc.firstSentence changed net net.parseCriteria.func1 changed net.hasUpperCase 181 -> 180 (-0.55%) net.parsePort changed net.lookupStaticHost changed html/template html/template.htmlNameFilter 251 -> 249 (-0.80%) vendor/golang.org/x/net/http/httpguts vendor/golang.org/x/net/http/httpguts.tokenEqual changed vendor/golang.org/x/net/http/httpguts.headerValueContainsToken 971 -> 965 (-0.62%) mime/multipart mime/multipart.(*Writer).SetBoundary 510 -> 505 (-0.98%) go/build go/build.splitQuoted 1157 -> 1148 (-0.78%) go/build.parseGoEmbed changed go/build.isValidImport 203 -> 197 (-2.96%) net/mail net/mail.(*addrParser).parseAddress changed net/mail.quoteString changed net/mail.(*Address).String changed crypto/x509 crypto/x509.(*Certificate).VerifyHostname 1020 -> 1018 (-0.20%) crypto/x509.toLowerCaseASCII 223 -> 215 (-3.59%) crypto/x509.matchHostnames changed crypto/x509.validHostname 506 -> 505 (-0.20%) crypto/x509.isIA5String 197 -> 186 (-5.58%) crypto/x509.parseNameConstraintsExtension.func1 changed crypto/x509.matchExactly changed crypto/x509.parseSANExtension.func1 1996 -> 1982 (-0.70%) crypto/x509.marshalSANs 3071 -> 3051 (-0.65%) crypto/x509.domainToReverseLabels 820 -> 805 (-1.83%) crypto/x509.buildCertExtensions.func2 changed crypto/x509.(*OID).unmarshalOIDText 1359 -> 1355 (-0.29%) crypto/x509.parseASN1String 1350 -> 1334 (-1.19%) cmd/cgo main.checkImportSymName changed main.splitQuoted 1157 -> 1148 (-0.78%) fmt [cmd/compile] fmt.(*fmt).fmtQ 494 -> 485 (-1.82%) fmt.(*ss).scanComplex changed fmt.(*fmt).truncateString changed fmt.(*fmt).pad changed fmt.(*ss).getBase 447 -> 435 (-2.68%) fmt.(*ss).convertFloat changed fmt.(*fmt).padString changed fmt.(*fmt).fmtS 217 -> 211 (-2.76%) fmt.(*ss).scanInt changed fmt.indexRune changed fmt.(*ss).okVerb 410 -> 409 (-0.24%) fmt.FormatString 650 -> 625 (-3.85%) fmt.(*ss).consume changed fmt.(*ss).scanUint changed fmt.(*ss).scanOne changed fmt.(*ss).peek changed fmt.(*ss).convertString 447 -> 436 (-2.46%) fmt.(*ss).scanBool changed internal/buildcfg [cmd/compile] internal/buildcfg.goriscv64 changed cmd/compile/internal/base cmd/compile/internal/base.lines.write 1451 -> 1450 (-0.07%) cmd/compile/internal/base.isnumber 165 -> 154 (-6.67%) go/token [cmd/compile] go/token.IsIdentifier changed net/url [cmd/compile] net/url.validOptionalPort 189 -> 186 (-1.59%) net/url.splitHostPort 584 -> 581 (-0.51%) net/url.parseAuthority 972 -> 948 (-2.47%) net/url.validUserinfo 229 -> 204 (-10.92%) net/url.parseHost 1372 -> 1371 (-0.07%) cmd/internal/objabi [cmd/compile] cmd/internal/objabi.DecodeArg changed text/tabwriter [cmd/compile] text/tabwriter.(*Writer).endEscape 335 -> 327 (-2.39%) text/tabwriter.(*Writer).updateWidth changed text/tabwriter.(*Writer).Write 3465 -> 3454 (-0.32%) go/doc/comment [cmd/compile] go/doc/comment.validImportPath 661 -> 648 (-1.97%) go/doc/comment.wrap 5496 -> 5489 (-0.13%) go/doc/comment.(*Printer).Text 1033 -> 1030 (-0.29%) go/doc/comment.(*textPrinter).text 1070 -> 1069 (-0.09%) go/doc/comment.(*Heading).DefaultID changed compress/gzip [cmd/compile] compress/gzip.(*Writer).writeString changed encoding/json [cmd/compile] encoding/json.isValidTag 313 -> 308 (-1.60%) cmd/doc main.match 549 -> 542 (-1.28%) go/types go/types.validatedImportPath changed go/types.(*Checker).lookupError 3109 -> 3082 (-0.87%) go/types.stripAnnotations 233 -> 229 (-1.72%) go/types.tail 153 -> 148 (-3.27%) go/types.isValidName 345 -> 330 (-4.35%) cmd/compile/internal/syntax cmd/compile/internal/syntax.(*scanner).lineComment 655 -> 634 (-3.21%) cmd/compile/internal/syntax.(*scanner).fullComment 527 -> 517 (-1.90%) crypto/tls crypto/tls.validDNSName changed go/constant [cmd/compile] go/constant.(*stringVal).String changed cmd/go/internal/str cmd/go/internal/str.ToFold 293 -> 278 (-5.12%) cmd/go/internal/str.QuoteGlob changed go/doc [cmd/compile] go/doc.firstSentence changed go/doc.assumedPackageName changed cmd/compile/internal/base [cmd/compile] cmd/compile/internal/base.lines.write 1451 -> 1450 (-0.07%) cmd/compile/internal/base.isnumber 165 -> 154 (-6.67%) cmd/compile/internal/syntax [cmd/compile] cmd/compile/internal/syntax.(*scanner).fullComment 527 -> 517 (-1.90%) cmd/compile/internal/syntax.(*scanner).lineComment changed cmd/vendor/golang.org/x/mod/module cmd/vendor/golang.org/x/mod/module.unescapeString 500 -> 487 (-2.60%) cmd/vendor/golang.org/x/mod/module.escapeString 538 -> 519 (-3.53%) cmd/vendor/golang.org/x/mod/module.checkPath changed cmd/vendor/golang.org/x/mod/module.checkElem changed cmd/vendor/golang.org/x/mod/module.CheckPath changed cmd/vendor/golang.org/x/mod/sumdb/note cmd/vendor/golang.org/x/mod/sumdb/note.isValidName 246 -> 244 (-0.81%) cmd/go/internal/base cmd/go/internal/base.validToolName 150 -> 142 (-5.33%) cmd/go/internal/base.ToolPath 488 -> 474 (-2.87%) cmd/go/internal/imports cmd/go/internal/imports.matchTag changed go/build [cmd/compile] go/build.isValidImport 203 -> 197 (-2.96%) go/build.splitQuoted 1157 -> 1148 (-0.78%) go/build.parseGoEmbed changed cmd/vendor/golang.org/x/mod/modfile cmd/vendor/golang.org/x/mod/modfile.Position.add 421 -> 412 (-2.14%) cmd/vendor/golang.org/x/mod/modfile.MustQuote 380 -> 372 (-2.11%) cmd/vendor/golang.org/x/mod/zip cmd/vendor/golang.org/x/mod/zip.strToFold changed cmd/link/internal/benchmark cmd/link/internal/benchmark.makeBenchString 476 -> 453 (-4.83%) cmd/internal/script cmd/internal/script.wrapLine 773 -> 766 (-0.91%) cmd/compile/internal/ir cmd/compile/internal/ir.splitPkg changed cmd/compile/internal/ir.splitType changed cmd/compile/internal/ir.LookupMethodSelector changed cmd/go/internal/modindex cmd/go/internal/modindex.parseGoEmbed changed cmd/go/internal/modindex.splitQuoted 1157 -> 1148 (-0.78%) cmd/pack main.setOp 325 -> 308 (-5.23%) cmd/vendor/golang.org/x/term cmd/vendor/golang.org/x/term.(*Terminal).handleKey changed cmd/compile/internal/types2 cmd/compile/internal/types2.validatedImportPath changed cmd/compile/internal/types2.tail 153 -> 148 (-3.27%) cmd/compile/internal/types2.(*Checker).lookupError 3717 -> 3690 (-0.73%) cmd/compile/internal/types2.isValidName 345 -> 330 (-4.35%) cmd/compile/internal/types2.stripAnnotations 233 -> 229 (-1.72%) net/http net/http.NewRequestWithContext 2251 -> 2245 (-0.27%) net/http.isValidWildcardName 357 -> 351 (-1.68%) net/http.ParseCookie 1100 -> 1099 (-0.09%) net/http.ParseSetCookie changed net/http.readCookies changed net/http.(*http2Framer).readMetaFrame.func1 changed net/http.isCookieNameValid changed net/http.(*Cookie).String changed net/http.(*Cookie).Valid changed net/http.validMethod changed net/http.parsePattern 4343 -> 4330 (-0.30%) net/http.http2validWireHeaderFieldName changed net/http.http2encodeHeaders changed net/http.(*Transport).roundTrip changed cmd/compile/internal/types2 [cmd/compile] cmd/compile/internal/types2.validatedImportPath changed cmd/compile/internal/types2.stripAnnotations 233 -> 229 (-1.72%) cmd/compile/internal/types2.tail 153 -> 148 (-3.27%) cmd/compile/internal/types2.(*Checker).lookupError 3717 -> 3690 (-0.73%) cmd/compile/internal/types2.isValidName 345 -> 330 (-4.35%) cmd/compile/internal/ir [cmd/compile] cmd/compile/internal/ir.LookupMethodSelector changed cmd/compile/internal/ir.splitType changed cmd/compile/internal/ir.splitPkg changed cmd/compile/internal/typecheck cmd/compile/internal/typecheck.stringtoruneslit changed net/http/cookiejar net/http/cookiejar.encode 1944 -> 1936 (-0.41%) expvar expvar.appendJSONQuote changed cmd/go/internal/web cmd/go/internal/web.(*Response).formatErrorDetail 1552 -> 1529 (-1.48%) cmd/vendor/golang.org/x/text/internal/language cmd/vendor/golang.org/x/text/internal/language.Parse 1102 -> 1099 (-0.27%) cmd/vendor/golang.org/x/tools/go/analysis cmd/vendor/golang.org/x/tools/go/analysis.validIdent 351 -> 346 (-1.42%) cmd/compile/internal/typecheck [cmd/compile] cmd/compile/internal/typecheck.stringtoruneslit changed cmd/vendor/github.com/google/pprof/internal/report cmd/vendor/github.com/google/pprof/internal/report.rightPad 377 -> 365 (-3.18%) cmd/vendor/github.com/google/pprof/internal/report.indentation 169 -> 165 (-2.37%) cmd/vendor/github.com/google/pprof/internal/report.makeWebListLine changed cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag.(*checker).plusBuildLine changed cmd/vendor/golang.org/x/tools/go/analysis/passes/directive cmd/vendor/golang.org/x/tools/go/analysis/passes/directive.(*checker).comment changed cmd/vendor/rsc.io/markdown cmd/vendor/rsc.io/markdown.(*CodeBlock).PrintHTML changed cmd/vendor/rsc.io/markdown.(*Code).printMarkdown changed cmd/vendor/rsc.io/markdown.newATXHeading changed cmd/vendor/rsc.io/markdown.longestSequence 249 -> 237 (-4.82%) cmd/vendor/rsc.io/markdown.newFence changed cmd/link/internal/ld cmd/link/internal/ld.methodref.isExported changed cmd/go/internal/modload cmd/go/internal/modload.ShortMessage changed cmd/go/internal/work cmd/go/internal/work.encodeArg changed cmd/compile/internal/walk cmd/compile/internal/walk.rangeAssign2 changed cmd/compile/internal/walk.arrayRangeClear changed cmd/compile/internal/walk.rangeAssign changed cmd/compile/internal/walk.mapClear changed cmd/compile/internal/walk.arrayClear changed cmd/compile/internal/walk.isMapClear changed cmd/compile/internal/walk.walkRange 15218 -> 15538 (+2.10%) cmd/compile/internal/walk.mapRangeClear changed cmd/compile/internal/walk.mapRangeClear.func1 changed cmd/compile/internal/walk.rangeConvert changed cmd/compile/internal/noder cmd/compile/internal/noder.checkImportPath changed cmd/compile/internal/noder.pragmaFields changed cmd/compile/internal/noder.parseGoEmbed 1309 -> 1300 (-0.69%) cmd/compile/internal/walk [cmd/compile] cmd/compile/internal/walk.mapRangeClear changed cmd/compile/internal/walk.rangeAssign2 changed cmd/compile/internal/walk.arrayClear changed cmd/compile/internal/walk.arrayRangeClear changed cmd/compile/internal/walk.walkRange 14789 -> 15109 (+2.16%) cmd/compile/internal/walk.mapRangeClear.func1 changed cmd/compile/internal/walk.rangeConvert changed cmd/compile/internal/walk.mapClear changed cmd/compile/internal/walk.isMapClear changed cmd/compile/internal/walk.rangeAssign changed cmd/compile/internal/noder [cmd/compile] cmd/compile/internal/noder.pragmaFields changed cmd/compile/internal/noder.parseGoEmbed 1309 -> 1300 (-0.69%) cmd/compile/internal/noder.checkImportPath changed file before after Δ % runtime.s 577251 577217 -34 -0.006% runtime [cmd/compile].s 642419 642385 -34 -0.005% bytes.s 36806 36777 -29 -0.079% strings.s 44176 44100 -76 -0.172% regexp/syntax.s 81719 81713 -6 -0.007% time.s 94341 94236 -105 -0.111% reflect.s 180291 180287 -4 -0.002% bytes [cmd/compile].s 38181 38152 -29 -0.076% strings [cmd/compile].s 44192 44116 -76 -0.172% regexp/syntax [cmd/compile].s 81719 81713 -6 -0.007% fmt.s 75019 74955 -64 -0.085% time [cmd/compile].s 94341 94236 -105 -0.111% net/url.s 37111 37055 -56 -0.151% reflect [cmd/compile].s 180340 180336 -4 -0.002% encoding/json.s 110294 110289 -5 -0.005% mime.s 47009 46913 -96 -0.204% text/tabwriter.s 9538 9519 -19 -0.199% go/doc/comment.s 49401 49377 -24 -0.049% archive/tar.s 71994 71950 -44 -0.061% crypto/x509/pkix.s 8493 8477 -16 -0.188% vendor/golang.org/x/net/idna.s 21271 21239 -32 -0.150% internal/trace/raw.s 15413 15400 -13 -0.084% go/printer.s 93669 93655 -14 -0.015% net.s 299569 299568 -1 -0.000% html/template.s 97069 97067 -2 -0.002% vendor/golang.org/x/net/http/httpguts.s 3187 3181 -6 -0.188% mime/multipart.s 31070 31065 -5 -0.016% go/build.s 75077 75062 -15 -0.020% crypto/x509.s 177195 177104 -91 -0.051% cmd/cgo.s 215638 215629 -9 -0.004% fmt [cmd/compile].s 86358 86294 -64 -0.074% cmd/compile/internal/base.s 44380 44368 -12 -0.027% net/url [cmd/compile].s 37222 37166 -56 -0.150% text/tabwriter [cmd/compile].s 9649 9630 -19 -0.197% go/doc/comment [cmd/compile].s 49512 49488 -24 -0.048% encoding/json [cmd/compile].s 110712 110707 -5 -0.005% cmd/doc.s 54581 54574 -7 -0.013% go/types.s 558219 558168 -51 -0.009% cmd/compile/internal/syntax.s 181755 181724 -31 -0.017% cmd/go/internal/str.s 3166 3151 -15 -0.474% cmd/compile/internal/base [cmd/compile].s 44589 44577 -12 -0.027% cmd/compile/internal/syntax [cmd/compile].s 196105 196095 -10 -0.005% cmd/vendor/golang.org/x/mod/module.s 19140 19108 -32 -0.167% cmd/vendor/golang.org/x/mod/sumdb/note.s 12831 12829 -2 -0.016% cmd/go/internal/base.s 20413 20391 -22 -0.108% go/build [cmd/compile].s 75188 75173 -15 -0.020% cmd/vendor/golang.org/x/mod/modfile.s 116513 116496 -17 -0.015% cmd/link/internal/benchmark.s 4068 4045 -23 -0.565% cmd/internal/script.s 83442 83435 -7 -0.008% cmd/go/internal/modindex.s 83527 83518 -9 -0.011% cmd/pack.s 9128 9111 -17 -0.186% cmd/compile/internal/types2.s 540279 540228 -51 -0.009% net/http.s 620639 620613 -26 -0.004% cmd/compile/internal/types2 [cmd/compile].s 577279 577228 -51 -0.009% net/http/cookiejar.s 28569 28561 -8 -0.028% cmd/go/internal/web.s 16316 16293 -23 -0.141% cmd/vendor/golang.org/x/text/internal/language.s 57819 57816 -3 -0.005% cmd/vendor/golang.org/x/tools/go/analysis.s 5528 5523 -5 -0.090% cmd/vendor/github.com/google/pprof/internal/report.s 83881 83865 -16 -0.019% cmd/vendor/rsc.io/markdown.s 117312 117300 -12 -0.010% cmd/compile/internal/walk.s 329328 329648 +320 +0.097% cmd/compile/internal/noder.s 262295 262286 -9 -0.003% cmd/compile/internal/walk [cmd/compile].s 350300 350620 +320 +0.091% cmd/compile/internal/noder [cmd/compile].s 298464 298455 -9 -0.003% total 36179015 36177972 -1043 -0.003% Change-Id: I191371db975761c24e53bb83bef0c42fa8ba3485 Reviewed-on: https://go-review.googlesource.com/c/go/+/641758 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2025-01-28runtime: rename mapiterinit and mapiternextMichael Pratt
mapiterinit allows external linkname. These users must allocate their own iter struct for initialization by mapiterinit. Since the type is unexported, they also must define the struct themselves. As a result, they of course define the struct matching the old hiter definition (in map_noswiss.go). The old definition is smaller on 32-bit platforms. On those platforms, mapiternext will clobber memory outside of the caller's allocation. On all platforms, the pointer layout between the old hiter and new maps.Iter does not match. Thus the GC may miss pointers and free reachable objects early, or it may see non-pointers that look like heap pointers and throw due to invalid references to free objects. To avoid these issues, we must keep mapiterinit and mapiternext with the old hiter definition. The most straightforward way to do this is to use mapiterinit and mapiternext as a compatibility layer between the old and new iter types. The first step to that is to move normal map use off of these functions, which is what this CL does. Introduce new mapIterStart and mapIterNext functions that replace the former functions everywhere in the toolchain. These have the same behavior as the old functions. This CL temporarily makes the old functions throw to ensure we don't have hidden dependencies on them. We cannot remove them entirely because GOEXPERIMENT=noswissmap still uses the old names, and internal/goobj requires all builtins to exist regardless of GOEXPERIMENT. The next CL will introduce the compatibility layer. I want to avoid using linkname between runtime and reflect, as that would also allow external linknames. So mapIterStart and mapIterNext are duplicated in reflect, which can be done trivially, as it imports internal/runtime/maps. For #71408. Change-Id: I6a6a636c6d4bd1392618c67ca648d3f061afe669 Reviewed-on: https://go-review.googlesource.com/c/go/+/643898 Auto-Submit: Michael Pratt <mpratt@google.com> Reviewed-by: Keith Randall <khr@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org>
2024-12-02hash/maphash, cmd/compile: make Comparable[string] not escape its argumentCherry Mui
Currently, maphash.Comparable forces its argument to escape if it contains a pointer, as we cannot hash stack pointers, which will change when the stack moves. However, for a string, it is actually okay if its data pointer points to the stack, as the hash depends on only the content, not the pointer. Currently there is no way to write this type-dependent escape logic in Go code. So we implement it in the compiler as an intrinsic. The compiler can also recognize not just the string type, but types whose pointers are all string pointers, and make them not escape. Fixes #70560. Change-Id: I3bf219ad71a238d2e35f0ea33de96487bc8cc231 Reviewed-on: https://go-review.googlesource.com/c/go/+/632715 Reviewed-by: David Chase <drchase@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2024-11-21all: fix some function names and typos in commentcuishuang
Change-Id: I07e7c8eaa5bd4bac0d576b2f2f4cd3f81b0b77a4 Reviewed-on: https://go-review.googlesource.com/c/go/+/630055 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Commit-Queue: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> Reviewed-by: Russ Cox <rsc@golang.org> Auto-Submit: Ian Lance Taylor <iant@google.com>
2024-11-18cmd/compile: avoid static init of strings in FIPS modeRuss Cox
Strings have relocations, and data relocations are bad. Other literals are fine. Fixes build failure in pending CL 628776. Change-Id: I7a38bbff9776a365c5823d54c4a00e068dda5d9a Reviewed-on: https://go-review.googlesource.com/c/go/+/628915 Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Robert Griesemer <gri@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Russ Cox <rsc@golang.org>
2024-11-13cmd/compile, cmd/link: add FIPS verification supportRuss Cox
For FIPS init-time code+data verification, we need to arrange to put the FIPS symbols into contiguous regions of the executable and then record those sections along with the expected checksum. The cmd/internal/obj changes identify the FIPS symbols and give them distinguished types, which the linker then places in contiguous regions. The linker also writes out information to use at run time to find the FIPS sections, along with the expected hash. See cmd/internal/obj/fips.go and cmd/link/internal/ld/fips.go for more details. The code is disabled in this commit. CL 625998 and 625999 adds tests. CL 626000 enables the code. For #69536. Change-Id: I48da6db94bc0bea7428c43d4abcf999527bccfcd Reviewed-on: https://go-review.googlesource.com/c/go/+/625997 Auto-Submit: Russ Cox <rsc@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2024-11-07cmd/internal/obj: replace obj.Addrel func with LSym.AddRel methodRuss Cox
The old API was to do r := obj.AddRel(sym) r.Type = this r.Off = that etc The new API is: sym.AddRel(ctxt, obj.Reloc{Type: this: Off: that, etc}) This new API is more idiomatic and avoids ever having relocations that are only partially constructed. Most importantly, it sets up for sym.AddRel being able to check relocation validity in the future. (Passing ctxt is for use in validity checking.) Passes golang.org/x/tools/cmd/toolstash/buildall. Change-Id: I042ea76e61bb3bf6402f98ca11291a13f4799972 Reviewed-on: https://go-review.googlesource.com/c/go/+/625616 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cherry Mui <cherryyz@google.com>
2024-10-30cmd/compile,internal/runtime/maps: stack allocated maps and small allocMichael Pratt
The compiler will stack allocate the Map struct and initial group if possible. Stack maps are initialized inline without calling into the runtime. Small heap allocated maps use makemap_small. These are the same heuristics as existing maps. For #54766. Cq-Include-Trybots: luci.golang.try:gotip-linux-amd64-longtest-swissmap Change-Id: I6c371d1309716fd1c38a3212d417b3c76db5c9b9 Reviewed-on: https://go-review.googlesource.com/c/go/+/622042 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Michael Pratt <mpratt@google.com>
2024-10-30runtime,internal/runtime/maps: specialized swissmapsMichael Pratt
Add all the specialized variants that exist for the existing maps. Like the existing maps, the fast variants do not support indirect key/elem. Note that as of this CL, the Get and Put methods on Map/table are effectively dead. They are only reachable from the internal/runtime/maps unit tests. For #54766. Cq-Include-Trybots: luci.golang.try:gotip-linux-amd64-longtest-swissmap Change-Id: I95297750be6200f34ec483e4cfc897f048c26db7 Reviewed-on: https://go-review.googlesource.com/c/go/+/616463 Reviewed-by: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Michael Pratt <mpratt@google.com> Reviewed-by: Keith Randall <khr@google.com>
2024-10-25cmd/compile: optimize type switch for a single runtime known type with a ↵Youlin Feng
case var Change-Id: I03ba70076d6dd3c0b9624d14699b7dd91a3c0e9b Reviewed-on: https://go-review.googlesource.com/c/go/+/618476 Reviewed-by: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com>
2024-10-14all: wire up swisstable mapsMichael Pratt
Use the new SwissTable-based map in internal/runtime/maps as the basis for the runtime map when GOEXPERIMENT=swissmap. Integration is complete enough to pass all.bash. Notable missing features: * Race integration / concurrent write detection * Stack-allocated maps * Specialized "fast" map variants * Indirect key / elem For #54766. Cq-Include-Trybots: luci.golang.try:gotip-linux-ppc64_power10,gotip-linux-amd64-longtest-swissmap Change-Id: Ie97b656b6d8e05c0403311ae08fef9f51756a639 Reviewed-on: https://go-review.googlesource.com/c/go/+/594596 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Michael Knyszek <mknyszek@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2024-10-07cmd/compile: avoid dynamic type when possibleCuong Manh Le
If the expression type is a single compile-time known type, use that type instead of the dynamic one, so the later passes of the compiler could skip un-necessary runtime calls. Thanks Youlin Feng for writing the original test case. Change-Id: I3f65ab90f041474a9731338a82136c1d394c1773 Reviewed-on: https://go-review.googlesource.com/c/go/+/616975 Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com>
2024-09-16cmd/compile: remove ir.OGETCALLERPCMichael Pratt
Nothing ever creates this op, so it can be safely removed. Note that SSA still intrinsifies runtime.getcallerpc. The similar ir.OGETCALLERSP is still used for defer handling in typecheck/func.go:tcRecover. For #54766. Change-Id: I6bdb2072af2c068080ae977c0cbd4684d0c7c752 Reviewed-on: https://go-review.googlesource.com/c/go/+/613496 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Auto-Submit: Michael Pratt <mpratt@google.com>
2024-09-11cmd/compile/internal/typecheck: simplify IndexConstCuong Manh Le
types2 handles all constant-related bounds checks in user Go code now, so it's safe to remove the check in IndexConst function. Change-Id: I9116493f191c4df1cce7e43c8ac3dc5bf020fd5c Reviewed-on: https://go-review.googlesource.com/c/go/+/611675 Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Tim King <taking@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@golang.org>
2024-09-10cmd/compile: remove trivial closure referenceCuong Manh Le
Trivial closures will be converted to global functions, thus they are not closures anymore. Using fn.IsClosure function is enough, allow removing the trivial/non-trivial closures in the code. Change-Id: Iceb186dd92c1732b101e221ebc13406db35c69ea Reviewed-on: https://go-review.googlesource.com/c/go/+/611995 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Tim King <taking@google.com> Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com>
2024-09-10cmd/compile: optimize []byte(string1 + string2)Paschalis Tsilias
This CL optimizes the compilation of string-to-bytes conversion in the case of string additions. Fixes #62407 Change-Id: Ic47df758478e5d061880620025c4ec7dbbff8a64 Reviewed-on: https://go-review.googlesource.com/c/go/+/527935 Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Keith Randall <khr@golang.org> Auto-Submit: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Tim King <taking@google.com>
generated by cgit v1.3 (git 2.53.0) at 2026-04-15 08:15:27 +0000