aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/compile/internal/base
AgeCommit message (Collapse)Author
2023-01-26cmd/compile: remove -d=typecheckinl flagMatthew Dempsky
This flag forced the compiler to eagerly type check all available inline function bodies, which presumably was useful in the early days of implementing inlining support. However, it shouldn't have any significance with the unified frontend, since the same code paths are used for constructing normal function bodies as for inlining. Updates #57410. Change-Id: I6842cf86bcd0fbf22ac336f2fc0b7b8fe14bccca Reviewed-on: https://go-review.googlesource.com/c/go/+/458617 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Keith Randall <khr@google.com> Auto-Submit: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2023-01-25cmd: remove GOEXPERIMENT=nounified knobMatthew Dempsky
This CL removes the GOEXPERIMENT=nounified knob, and any conditional statements that depend on that knob. Further CLs to remove unreachable code follow this one. Updates #57410. Change-Id: I39c147e1a83601c73f8316a001705778fee64a91 Reviewed-on: https://go-review.googlesource.com/c/go/+/458615 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com>
2023-01-17cmd/compile: remove support for old comparable semanticsRobert Griesemer
Change-Id: I730da5082ea6de1510482aabaa2915e83d3819a5 Reviewed-on: https://go-review.googlesource.com/c/go/+/461607 Reviewed-by: Robert Griesemer <gri@google.com> Auto-Submit: Robert Griesemer <gri@google.com> Reviewed-by: Robert Findley <rfindley@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Robert Griesemer <gri@google.com>
2022-12-01go/types, types2: make the new comparable semantics the defaultRobert Griesemer
Ordinary interface types now satisfy comparable constraints. This is a fully backward-compatible change: it simply permits additional code to be valid that wasn't valid before. This change makes the new comparable semantics the default behavior, depending on the Go -lang version. It also renames the flag types2.Config.AltComparableSemantics to types2.Config.OldComparableSemantics and inverts its meaning (or types.Config.oldComparableSemantics respectively). Add new predicate Satisfies (matching the predicate Implements but for constraint satisfaction), per the proposal description. Adjust some existing tests by setting -oldComparableSemantics and add some new tests that verify version-dependent behavior. The compiler flag -oldcomparable may be used to temporarily switch back to the Go 1.18/1.19 behavior should this change cause problems, or to identify that a problem is unrelated to this change. The flag will be removed for Go 1.21. For #52509. For #56548. For #57011. Change-Id: I8b3b3d9d492fc24b0693567055f0053ccb5aeb42 Reviewed-on: https://go-review.googlesource.com/c/go/+/454575 TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@google.com> Run-TryBot: Robert Griesemer <gri@google.com> Reviewed-by: Robert Findley <rfindley@google.com>
2022-12-01Revert "go/types, types2: make the new comparable semantics the default"Robert Griesemer
The CL below was accidentally submitted, while waiting for the freeze exception. Reverting. This reverts commit 15e705ea963b5008112793507365e24b743606bc. Change-Id: I4dbf92dcb01fa9245a6e6a2d1514d8aa898d0048 Reviewed-on: https://go-review.googlesource.com/c/go/+/454476 Reviewed-by: Robert Griesemer <gri@google.com> Run-TryBot: Robert Griesemer <gri@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Robert Findley <rfindley@google.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Auto-Submit: Robert Griesemer <gri@google.com>
2022-12-01go/types, types2: make the new comparable semantics the defaultRobert Griesemer
Ordinary interface types now satisfy comparable constraints. This change makes the new comparable semantics the default behavior, depending on the Go -lang version. It also renames the flag types2.Config.AltComparableSemantics to types2.Config.OldComparableSemantics and inverts its meaning (or types.Config.oldComparableSemantics respectively). Adjust some existing tests by setting -oldComparableSemantics and add some new tests that verify version-dependent behavior. The compiler flag -oldcomparable may be used to temporarily switch back to the Go 1.18/1.19 behavior should this change cause problems, or to identify that a problem is unrelated to this change. The flag will be removed for Go 1.21. For #52509. For #56548. Change-Id: Ic2b22db9433a8dd81dc1ed9d30835f0395fb7205 Reviewed-on: https://go-review.googlesource.com/c/go/+/453978 Reviewed-by: Robert Findley <rfindley@google.com> Reviewed-by: Robert Griesemer <gri@google.com> Run-TryBot: Robert Griesemer <gri@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Robert Griesemer <gri@google.com>
2022-11-23cmd/compile: reenable inlstaticinitRuss Cox
This was disabled in CL 452676 out of an abundance of caution, but further analysis has shown that the failures were not being caused by this optimization. Instead the sequence of commits was: CL 450136 cmd/compile: handle simple inlined calls in staticinit ... CL 449937 archive/tar, archive/zip: return ErrInsecurePath for unsafe paths ... CL 451555 cmd/compile: fix static init for inlined calls The failures in question became compile failures in the first CL and started building again after the last CL. But in the interim the code had been broken by the middle CL. CL 451555 was just the first time that the tests could run and fail. For #30820. Change-Id: I65064032355b56fdb43d9731be2f9f32ef6ee600 Reviewed-on: https://go-review.googlesource.com/c/go/+/452817 Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: Russ Cox <rsc@golang.org> Auto-Submit: Russ Cox <rsc@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-11-22cmd/compile: add -d=inlstaticinit debug flagMatthew Dempsky
This CL adds -d=inlstaticinit to control whether static initialization of inlined function calls (added in CL 450136) is allowed. We've needed to fix it once already (CL 451555) and Google-internal testing is hitting additional failure cases, so putting this optimization behind a feature flag seems appropriate regardless. Also, while we diagnose and fix the remaining cases, this CL also disables the optimization to avoid miscompilations. Updates #56894. Change-Id: If52a358ad1e9d6aad1c74fac5a81ff9cfa5a3793 Reviewed-on: https://go-review.googlesource.com/c/go/+/452676 Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com>
2022-11-21cmd/compile: reject anonymous interface cyclesMatthew Dempsky
This CL changes cmd/compile to reject anonymous interface cycles like: type I interface { m() interface { I } } We don't anticipate any users to be affected by this change in practice. Nonetheless, this CL also adds a `-d=interfacecycles` compiler flag to suppress the error. And assuming no issue reports from users, we'll move the check into go/types and types2 instead. Updates #56103. Change-Id: I1f1dce2d7aa19fb388312cc020e99cc354afddcb Reviewed-on: https://go-review.googlesource.com/c/go/+/445598 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Robert Griesemer <gri@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Matthew Dempsky <mdempsky@google.com>
2022-11-18all: add missing periods in commentscui fliter
Change-Id: I69065f8adf101fdb28682c55997f503013a50e29 Reviewed-on: https://go-review.googlesource.com/c/go/+/449757 Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Joedian Reid <joedian@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Keith Randall <khr@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Joedian Reid <joedian@golang.org> Run-TryBot: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com>
2022-11-18cmd/compile/internal/base, cmd/internal/bio: use syscall.Mmap on aixTobias Klauser
Change-Id: Ic28612952eb9abf14425f0bb14043b10f6050d94 Reviewed-on: https://go-review.googlesource.com/c/go/+/450195 Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> Reviewed-by: Joedian Reid <joedian@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Tobias Klauser <tobias.klauser@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com>
2022-11-16cmd/compile: handle simple inlined calls in staticinitRuss Cox
Global variable initializers like var myErr error = &myError{"msg"} have been converted to statically initialized data from the earliest days of Go: there is no init-time execution or allocation for that line of code. But if the expression is moved into an inlinable function, the static initialization no longer happens. That is, this code has always executed and allocated at init time, even after we added inlining to the compiler, which should in theory make this code equivalent to the original: func NewError(s string) error { return &myError{s} } var myErr2 = NewError("msg") This CL makes the static initialization rewriter understand inlined functions consisting of a single return statement, like in this example, so that myErr2 can be implemented as statically initialized data too, just like myErr, with no init-time execution or allocation. A real example of code that benefits from this rewrite is all globally declared errors created with errors.New, like package io var EOF = errors.New("EOF") Package io no longer has to allocate and initialize EOF each time a program starts. Another example of code that benefits is any globally declared godebug setting (using the API from CL 449504), like package http var http2server = godebug.New("http2server") These are no longer allocated and initialized at program startup either. The list of functions that are inlined into static initializers when compiling std and cmd (along with how many times each occurs) is: cmd/compile/internal/ssa.StringToAux (3) cmd/compile/internal/walk.mkmapnames (4) errors.New (360) go/ast.NewIdent (1) go/constant.MakeBool (4) go/constant.MakeInt64 (3) image.NewUniform (4) image/color.ModelFunc (11) internal/godebug.New (12) vendor/golang.org/x/text/unicode/bidi.newBidiTrie (1) vendor/golang.org/x/text/unicode/norm.newNfcTrie (1) vendor/golang.org/x/text/unicode/norm.newNfkcTrie (1) For the cmd/go binary, this CL cuts the number of init-time allocations from about 1920 to about 1620 (a 15% reduction). The total executable code footprint of init functions is reduced by 24kB, from 137kB to 113kB (an 18% reduction). The overall binary size is reduced by 45kB, from 15.335MB to 15.290MB (a 0.3% reduction). (The binary size savings is larger than the executable code savings because every byte of executable code also requires corresponding runtime tables for unwinding, source-line mapping, and so on.) Also merge test/sinit_run.go, which had stopped testing anything at all as of CL 161337 (Feb 2019) and initempty.go into a new test noinit.go. Fixes #30820. Change-Id: I52f7275b1ac2a0a32e22c29f9095071c7b1fac20 Reviewed-on: https://go-review.googlesource.com/c/go/+/450136 Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Joedian Reid <joedian@golang.org> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Than McIntosh <thanm@google.com> Auto-Submit: Russ Cox <rsc@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Russ Cox <rsc@golang.org>
2022-11-15cmd/compile: add testing-flag guard to package-is-collected assertDavid Chase
On advice of the department of garbage collection, forcing a garbage collection generally does not improve performance. However, this-data-is-now-unreachable is a good property to be able to test, and that requires finalizers and a forced GC. So, to save build time, this test was removed from the compiler itself, but to verify the property, it was added to the fma_test (and the end-to-end dependence on the flag was tested with an inserted failure in testing the test). TODO: also turn on the new -d=gccheck=1 debug flag on the ssacheck builder. Benchmarking reveals that it is profitable to avoid this GC, with about 1.5% reduction in both user and wall time. (48 p) https://perf.golang.org/search?q=upload:20221103.3 (12 p) https://perf.golang.org/search?q=upload:20221103.5 Change-Id: I4c4816d619735838a32388acf0cc5eb1cd5f0db5 Reviewed-on: https://go-review.googlesource.com/c/go/+/447359 Reviewed-by: Cherry Mui <cherryyz@google.com> Run-TryBot: David Chase <drchase@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
2022-11-10cmd/compile: adjust PGO inlining default parametersCherry Mui
Adjust PGO inlining default parameters to 99% CDF threshold and 2000 budget. Benchmark results (mostly from Sweet) show that this set of parameters performs reasonably well, with a few percent speedup at the cost of a few percent binary size increase. Also rename the debug flags to start with "pgo", to make it clear that they are related to PGO. Change-Id: I0749249b1298d1dc55a28993c37b3185f9d7639d Reviewed-on: https://go-review.googlesource.com/c/go/+/449477 Run-TryBot: Cherry Mui <cherryyz@google.com> Reviewed-by: Michael Pratt <mpratt@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-11-10cmd/compile: add ability to hash-debug on file:line, including inliningDavid Chase
Modified the fmahash gc debug flag to use this, and modified the test to check for a hash match that includes inlining. Also made the test non-short to ensure portability. Note fma.go has been enhanced into an FMA test that requires two separate FMAs in order to "fail"; if either one is 2-rounding, then it "passes". (It neither passes nor fails here; its role is to demonstrate that the FMAs are correctly reported; the enhanced failure mode was discovered while testing the search tool.) Change-Id: I4e328e3654f442d498eac982135420abb59c5434 Reviewed-on: https://go-review.googlesource.com/c/go/+/448358 TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Than McIntosh <thanm@google.com> Run-TryBot: David Chase <drchase@google.com>
2022-11-07cmd/compile: let compiler downgrade its own concurrencyDavid Chase
This gets the Go command out of the business of thinking it understands compiler debug flags, and allows the compiler to turn down its worker concurrency instead of failing and forcing the user to do the very same thing. Debug flags that are obviously safe for concurrency (at least to me) are tagged; probably there's more. Change-Id: I59bb19861d8a654a9cfd2364ee78c8628212f82e Reviewed-on: https://go-review.googlesource.com/c/go/+/448359 Reviewed-by: Cherry Mui <cherryyz@google.com> Run-TryBot: David Chase <drchase@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-11-04cmd/compile: tweak compiler concurrencyDavid Chase
Default concurrency is now GOMAXPROCS, though this is normally reduced to 4 by the go build commmand. If compiler flags don't permit concurrency, silently turn it down instead of failing the compilation. Change-Id: Id26cc3214e0ca402d60f915e98276a58d809e097 Reviewed-on: https://go-review.googlesource.com/c/go/+/447358 TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@google.com>
2022-11-04cmd/compile: change the multiple (gossa)hash separator from ; to /David Chase
Semicolon has bad copy-paste ergonomics; it requires quoting. Slash is okay, and won't be a separator ever in debug strings because it is already used in e.g. ssa/phase/debug=etc. Change-Id: I493360e9282666eea1a342971a77df2ebd6c92ad Reviewed-on: https://go-review.googlesource.com/c/go/+/447975 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-11-03cmd/compile: if GOGC is not set, temporarily boost it for rapid starting ↵David Chase
heap growth Benchmarking suggests about a 14-17% reduction in user build time, about 3.5-7.8% reduction for wall time. This helps most builds because small packages are common. Latest benchmarks (after the last round of improvement): (12 processors) https://perf.golang.org/search?q=upload:20221102.20 (GOMAXPROCS=2) https://perf.golang.org/search?q=upload:20221103.1 (48 processors) https://perf.golang.org/search?q=upload:20221102.19 (The number of compiler workers is capped at min(4, GOMAXPROCS)) An earlier, similar version of this CL at one point observed a 27% reduction in user build time (building 40+ benchmarks, 20 times), but the current form is judged to be the most reliable; it may be profitable to tweak the numbers slightly later, and/or to adjust the number of compiler workers. We've talked about doing this in the past, the "new"(ish) metrics package makes it a more tractable proposition. The method here is: 1. If os.Getenv("GOGC") is empty, then increase GOGC to a large value, calculated to grow the heap to 32 + 4 * compile_parallelism before a GC occurs (e.g., on a >= 4 processor box, 64M). In practice, sometimes GC occurs before that, but this still results in fewer GCs and saved time. This is "heap goal". 2. Use a finalizer to approximately detect when GC occurs, and use runtime metrics to track progress towards the goal heap size, readjusting GOGC to retarget it as necessary. Reset GOGC to 100 when the heap is "close enough" to the goal. One feared failure mode of doing this is that the finalizer will be slow to run and the heap will grow exceptionally large before GOGC is reset; I monitored the heap size at reset and exit across several boxes with a variety of processor counts and extra noise (including several builds in parallel, including a laptop with a busy many-tabs browser running) and overshoot effectively does not occur. In some cases the compiler's heap grows so rapidly that estimated live exceeds the GC goal, but this is not delayed-finalizer overshoot; the compiler is just using that much memory. In a small number of cases (3% of GCs in make.bash) the new goal is larger than predicted by as much as 38%, so check for that and redo the adjustment. I considered instead using the maximum heap size limit + GC-detecting-finalizer + reset instead, but to me that seemed like it might have a worse bad-case outcome; if the reset is delayed, it's possible the GC would start running frequently, making it harder to run the finalizer, reach 50% utilization, and the extra GCs would lose the advantage. This might also perform badly in the case that a rapidly growing heap outruns goal. In practice, this sort of overshoot hasn't been observed, and a goal of 64M is small enough to tolerate plenty of overshoot anyway. This version of the CL includes a comment urging anyone who sees the code and thinks it would work for them, to update a bug (to be created if the CL is approved) with information about their situation/experience, so that we may consider creating some more official and reliable way of obtaining the same result. Change-Id: I45df1c927c1a7d7503ade1abd1a3300e27516633 Reviewed-on: https://go-review.googlesource.com/c/go/+/436235 Run-TryBot: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
2022-11-03cmd/compile: add debug-hash flag for fused-multiply-addDavid Chase
This adds a -d debug flag "fmahash" for hashcode search for floating point architecture-dependent problems. This variable has no effect on architectures w/o fused-multiply-add. This was rebased onto the GOSSAHASH renovation so that this could have its own dedicated environment variable, and so that it would be cheap (a nil check) to check it in the normal case. Includes a basic test of the trigger plumbing. Sample use (on arm64, ppc64le, s390x): % GOCOMPILEDEBUG=fmahash=001110110 \ go build -o foo cmd/compile/internal/ssa/testdata/fma.go fmahash triggered main.main:24 101111101101111001110110 GOFMAHASH triggered main.main:20 010111010000101110111011 1.0000000000000002 1.0000000000000004 -2.220446049250313e-16 exit status 1 The intended use is in conjunction with github.com/dr2chase/gossahash, which will probably acquire a flag "-fma" to streamline its use. This tool+use was inspired by an ad hoc use of this technique "in anger" to debug this very problem. This is also a dry-run for using this same technique to identify code sensitive to loop variable lifetime/capture, should we make that change. Example intended use, with current search tool (using old environment variable), for a test example: gossahash -e GOFMAHASH GOMAGIC=GOFMAHASH go run fma.go Trying go args=[...], env=[GOFMAHASH=1 GOMAGIC=GOFMAHASH] go failed (81 distinct triggers): exit status 1 Trying go args=[...], env=[GOFMAHASH=11 GOMAGIC=GOFMAHASH] go failed (39 distinct triggers): exit status 1 Trying go args=[...], env=[GOFMAHASH=011 GOMAGIC=GOFMAHASH] go failed (18 distinct triggers): exit status 1 Trying go args=[...], env=[GOFMAHASH=0011 GOMAGIC=GOFMAHASH] Trying go args=[...], env=[GOFMAHASH=1011 GOMAGIC=GOFMAHASH] ... Trying go args=[...], env=[GOFMAHASH=0110111011 GOMAGIC=GOFMAHASH] Trying go args=[...], env=[GOFMAHASH=1110111011 GOMAGIC=GOFMAHASH] go failed (2 distinct triggers): exit status 1 Trigger string is 'GOFMAHASH triggered math.qzero:427 111111101010011110111011', repeated 6 times Trigger string is 'GOFMAHASH triggered main.main:20 010111010000101110111011', repeated 1 times Trying go args=[...], env=[GOFMAHASH=01110111011 GOMAGIC=GOFMAHASH] go failed (1 distinct triggers): exit status 1 Trigger string is 'GOFMAHASH triggered main.main:20 010111010000101110111011', repeated 1 times Review GSHS_LAST_FAIL.0.log for failing run FINISHED, suggest this command line for debugging: GOSSAFUNC='main.main:20 010111010000101110111011' \ GOFMAHASH=01110111011 GOMAGIC=GOFMAHASH go run fma.go Change-Id: Ifa22dd8f1c37c18fc8a4f7c396345a364bc367d5 Reviewed-on: https://go-review.googlesource.com/c/go/+/394754 TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: David Chase <drchase@google.com> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2022-11-03cmd/compile: use CDF to determine PGO inline thresholdCherry Mui
Currently in PGO we use a percentage threshold to determine if a callsite is hot. This CL uses a different method -- treating the hottest callsites that make up cumulatively top X% of total edge weights as hot (X=95 for now). This default might work better for a wider range of profiles. (The absolute threshold can still be changed by a flag.) For #55022. Change-Id: I7e3b6f0c3cf23f9a89dd5994c10075b498bf14ee Reviewed-on: https://go-review.googlesource.com/c/go/+/447016 TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Cherry Mui <cherryyz@google.com> Reviewed-by: Michael Pratt <mpratt@google.com>
2022-11-02cmd/compile: use edge weights to decide inlineability in PGOCherry Mui
Currently, with PGO, the inliner uses node weights to decide if a function is inlineable (with a larger budget). But the actual inlining is determined by the weight of the call edge. There is a discrepancy that, if a callee node is hot but the call edge is not, it would not inlined, and marking the callee inlineable would of no use. Instead of using two kinds of weights, we just use the edge weights to decide inlineability. If a function is the callee of a hot call edge, its inlineability is determined with a larger threshold. For a function that exceeds the regular inlining budget, it is still inlined only when the call edge is hot, as it would exceed the regular inlining cost for non-hot call sites, even if it is marked inlineable. For #55022. Change-Id: I93fa9919fc6bcbb394e6cfe54ec96a96eede08f7 Reviewed-on: https://go-review.googlesource.com/c/go/+/447015 Run-TryBot: Cherry Mui <cherryyz@google.com> Reviewed-by: Michael Pratt <mpratt@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-11-02cmd/compile: renovate GOSSAHASHDavid Chase
Randomized feature enable/disable might be something we use to help users debug any problems with changed loop variable capture, and there's another CL that would like to use it to help in locating places where "fused" multiply add instructions change program behavior. This CL: - adds the ability to include an integer parameter (e.g. line number) - replumbed the environment variable into a flag to simplify go build cache management - but added an environment variable to allow flag setting through the environment - which adds the possibility of switching on a different variable (if there's one built-in for variable capture, it shouldn't be GOSSAHASH) - cleaned up the checking code - adds tests for all the intended behavior - removes the case for GSHS_LOGFILE; TBD whether we'll need to put that back or if there is another way. Change-Id: I8503e1bb3dbc4a743aea696e04411ea7ab884787 Reviewed-on: https://go-review.googlesource.com/c/go/+/443063 Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Keith Randall <khr@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Russ Cox <rsc@golang.org> Run-TryBot: David Chase <drchase@google.com>
2022-10-31cmd/compile: add ability to indicate 'concurrentOk' for debug flagsDavid Chase
Also removes no-longer-needed "Any" field from compiler's DebugFlags. Test/use case for this is the fmahash CL. Change-Id: I214f02c91f30fc2ce53caf75fa5e2b905dd33429 Reviewed-on: https://go-review.googlesource.com/c/go/+/445495 TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: David Chase <drchase@google.com>
2022-10-28cmd/compile: Enables PGO in Go and performs profile-guided inliningRaj Barik
For #55022 Change-Id: I51f1ba166d5a66dcaf4b280756be4a6bf9545c5e Reviewed-on: https://go-review.googlesource.com/c/go/+/429863 TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: Michael Pratt <mpratt@google.com> Run-TryBot: Cherry Mui <cherryyz@google.com>
2022-10-25cmd/compile: add support for alternative comparable semanticsRobert Griesemer
Add the experimental compiler flag -altcomparable. If set, the compiler uses alternative comparable semantics: any ordinary (non-type parameter) interface implements the comparable constraint. This permits experimenting with this alternative semantics akin to what is proposed in #52509. For #52509. Change-Id: I64192eee6f2a550eeb50de011079f2f0b994cf94 Reviewed-on: https://go-review.googlesource.com/c/go/+/444636 Run-TryBot: Robert Griesemer <gri@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@google.com> Auto-Submit: Robert Griesemer <gri@google.com> Reviewed-by: Robert Griesemer <gri@google.com> Reviewed-by: Robert Findley <rfindley@google.com>
2022-10-04cmd/cgo, cmd/compile, cmd/link: remove old style build tagsRuss Cox
[Roll-forward of CL 436915 by Tobias Klauser, with builtin and gen directories dropped now that they've been handled separately.] The minimum bootstrap version for Go ≥ 1.20 is Go 1.17. That version supports the new style //go:build lines. Thus the old style //+build lines can be dropped in this part of the tree as well. Leave the //+build lines in cmd/dist which will ensure the minimum Go version during bootstrap. As suggested by Cherry during review of CL 430496 For #44505 Change-Id: Ifa686656c3e50bf7f92f70747b44d74a7d51bad8 Reviewed-on: https://go-review.googlesource.com/c/go/+/435473 Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Russ Cox <rsc@golang.org>
2022-10-04cmd/internal/sys: migrate support.go functions to new internal pkgThan McIntosh
Separate out the functions from cmd/internal/sys/support.go and migrate them to a new package internal/platform, so that functions such as "RaceDetectorSupported" can be called from tests in std as well as in cmd. This isn't a complete move of everything in cmd/internal/sys; there are still many functions left. The original version of this CL (patch set 1) called the new package "internal/sys", but for packages that needed both "internal/sys" and "cmd/internal/sys" the import of the former had to be done with a different name, which was confusing and also required a hack in cmd/dist. Updates #56006. Change-Id: I866d62e75adbf3a640a06e2c7386a6e9e2a18d91 Reviewed-on: https://go-review.googlesource.com/c/go/+/438475 Reviewed-by: Bryan Mills <bcmills@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> Run-TryBot: Than McIntosh <thanm@google.com>
2022-10-03cmd/compile/internal: fix a few function names on commentscui fliter
Change-Id: If78c6d3c6183494f71f2857e496e172a789da39f GitHub-Last-Rev: 58e0b75052a92cb720371d2b3c75e1de79d79bdc GitHub-Pull-Request: golang/go#55992 Reviewed-on: https://go-review.googlesource.com/c/go/+/437517 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Keith Randall <khr@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Keith Randall <khr@golang.org> Auto-Submit: Keith Randall <khr@golang.org>
2022-09-30Revert "cmd/cgo, cmd/compile, cmd/link: remove old style build tags"Than McIntosh
This reverts commit 66165739828b8326b625463beb51ae510b2ab8dd, corresponding to CL 436915. Reason for revert: this is causing some bootstrap build problems with older versions of Go 1.17, as I understand it. Still under investigation. Change-Id: Idb6e17ff7b47004cbf87f967af6d84f214d8abb5 Reviewed-on: https://go-review.googlesource.com/c/go/+/435471 Reviewed-by: David Chase <drchase@google.com>
2022-09-30cmd/cgo, cmd/compile, cmd/link: remove old style build tagsTobias Klauser
The minimum bootstrap version for Go ≥ 1.20 is Go 1.17. That version supports the new style //go:build lines. Thus the old style //+build lines can be dropped in this part of the tree as well. Leave the //+build lines in cmd/dist which will ensure the minimum Go version during bootstrap. As suggested by Cherry during review of CL 430496 For #44505 Change-Id: If53c0b02cacbfb055a33e73cfd38578dfd3aa340 Reviewed-on: https://go-review.googlesource.com/c/go/+/436915 TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> Auto-Submit: Tobias Klauser <tobias.klauser@gmail.com> Reviewed-by: Than McIntosh <thanm@google.com>
2022-09-28cmd/compile/internal/base: replace io/ioutil with os packagecui fliter
Change-Id: Ide7618b65fcff7947809051d51b993d330e35717 GitHub-Last-Rev: 298853a82006655fe4f226cc5bea3bc21613b832 GitHub-Pull-Request: golang/go#55914 Reviewed-on: https://go-review.googlesource.com/c/go/+/435537 Run-TryBot: Robert Griesemer <gri@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Robert Griesemer <gri@google.com> Reviewed-by: Robert Griesemer <gri@google.com> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2022-09-27cmd/compile: add coverage fixup modeThan McIntosh
Adds a -coveragecfg=<configfile> command line option to the compiler to help support a cooperative "tool and compiler" mode for coverage instrumentation. In this mode the cmd/cover tool generates most of the counter instrumentation via source-to-source rewriting, but the compiler fixes up the result if passed the "-coveragecfg" option. The fixups include: - reclassifying counter variables (special storage class) - marking meta-data variables are read-only - adding in an init call to do registation Updates #51430. Change-Id: Iead72b85209725ee044542374465f118a3ee72e0 Reviewed-on: https://go-review.googlesource.com/c/go/+/395895 Reviewed-by: David Chase <drchase@google.com> Run-TryBot: Than McIntosh <thanm@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-09-20all: replace package ioutil with os and io in srcAndy Pan
For #45557 Change-Id: I56824135d86452603dd4ed4bab0e24c201bb0683 Reviewed-on: https://go-review.googlesource.com/c/go/+/426257 Run-TryBot: Ian Lance Taylor <iant@google.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Run-TryBot: Andy Pan <panjf2000@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@google.com>
2022-09-15cmd, syscall: use syscall.Mmap on solaris for Go ≥ 1.20Tobias Klauser
CL 413374 added syscall.Mmap on solaris. Use it in cmd/compile and cmd/link if the bootstrap toolchain is Go ≥ 1.20. For #52875 For #54265 Change-Id: I9a0534bf97926eecf0c6f1f9218e855344ba158f Reviewed-on: https://go-review.googlesource.com/c/go/+/430496 Reviewed-by: Bryan Mills <bcmills@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> Auto-Submit: Tobias Klauser <tobias.klauser@gmail.com> Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
2022-09-09all: transfer reflect.{SliceHeader, StringHeader} to unsafeheader.{Slice, ↵hopehook
String} After we deprecated reflect.{SliceHeader, StringHeader}, it is recommended to use unsafe.{Slice, String} to replace its work. However, the compiler and linker cannot be migrated for the time being. As a temporary strategy, using the "internal/unsafeheader" package like other code is the most suitable choice at present. For #53003. Change-Id: I69d0ef72e2d95caabd0706bbb247a719d225c758 Reviewed-on: https://go-review.googlesource.com/c/go/+/429755 Auto-Submit: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: hopehook <hopehook@golangcn.org>
2022-09-02cmd/compile/internal/base: use runtime.KeepAlive in MapFileTobias Klauser
Go 1.17 will be used instead of Go 1.4 as minimum required version for bootstrap, so runtime.KeepAlive introduced in Go 1.7 can be used in cmd/compile. For #44505 Change-Id: I96bd6619c4476e36ee1d93ca049da622a3a78f97 Reviewed-on: https://go-review.googlesource.com/c/go/+/427114 Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> Reviewed-by: Matthew Dempsky <mdempsky@google.com> Auto-Submit: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Heschi Kreinick <heschi@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-08-30cmd/compile: fix unified IR shapifying recursive instantiated typesCuong Manh Le
Shape-based stenciling in unified IR is done by converting type argument to its underlying type. So it agressively check that type argument is not a TFORW. However, for recursive instantiated type argument, it may still be a TFORW when shapifying happens. Thus the assertion failed, causing the compiler crashing. To fix it, just allow fully instantiated type when shapifying. Fixes #54512 Fixes #54722 Change-Id: I527e3fd696388c8a37454e738f0324f0c2ec16cb Reviewed-on: https://go-review.googlesource.com/c/go/+/426335 TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com> Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Heschi Kreinick <heschi@google.com> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2022-08-23cmd/compile: fix unified IR's pointer-shapingMatthew Dempsky
In CL 424734, I implemented pointer shaping for unified IR. Evidently though, we didn't have any test cases that check that uses of pointer-shaped expressions were handled correctly. In the reported test case, the struct field "children items[*node[T]]" gets shaped to "children items[go.shape.*uint8]" (underlying type "[]go.shape.*uint8"); and so the expression "n.children[i]" has type "go.shape.*uint8" and the ".items" field selection expression fails. The fix implemented in this CL is that any expression of derived type now gets an explicit "reshape" operation applied to it, to ensure it has the appropriate type for its context. E.g., the "n.children[i]" OINDEX expression above gets "reshaped" from "go.shape.*uint8" to "*node[go.shape.int]", allowing the field selection to succeed. This CL also adds a "-d=reshape" compiler debugging flag, because I anticipate debugging reshaping operations will be something to come up again in the future. Fixes #54535. Change-Id: Id847bd8f51300d2491d679505ee4d2e974ca972a Reviewed-on: https://go-review.googlesource.com/c/go/+/424936 Reviewed-by: David Chase <drchase@google.com> Reviewed-by: hopehook <hopehook@qq.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-08-17cmd/compile: gofmt -w -shopehook
Change-Id: I4dad103d23121a21b04800ec157487fdf79f89a6 Reviewed-on: https://go-review.googlesource.com/c/go/+/424398 Run-TryBot: hopehook <hopehook@qq.com> Reviewed-by: Robert Griesemer <gri@google.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Run-TryBot: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-08-10cmd/compile: refactor GOSSAHASH debugging to make it usable outside ssa package.David Chase
I've needed this more than once in the past, I hack it in, then throw it away, seems sensible to make the change and save it. Fixes #53937. Change-Id: I7fe886b1c93d73cbf553bed587f2c30f0f5d5a0b Reviewed-on: https://go-review.googlesource.com/c/go/+/418015 Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Keith Randall <khr@golang.org>
2022-08-09all: use ":" for compiler generated symbolsCuong Manh Le
As it can't appear in user package paths. There is a hack for handling "go:buildid" and "type:*" on windows/386. Previously, windows/386 requires underscore prefix on external symbols, but that's only applied for SHOSTOBJ/SUNDEFEXT or cgo export symbols. "go.buildid" is STEXT, "type.*" is STYPE, thus they are not prefixed with underscore. In external linking mode, the external linker can't resolve them as external symbols. But we are lucky that they have "." in their name, so the external linker see them as Forwarder RVA exports. See: - https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#export-address-table - https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=ld/pe-dll.c;h=e7b82ba6ffadf74dc1b9ee71dc13d48336941e51;hb=HEAD#l972) This CL changes "." to ":" in symbols name, so theses symbols can not be found by external linker anymore. So a hacky way is adding the underscore prefix for these 2 symbols. I don't have enough knowledge to verify whether adding the underscore for all STEXT/STYPE symbols are fine, even if it could be, that would be done in future CL. Fixes #37762 Change-Id: I92eaaf24c0820926a36e0530fdb07b07af1fcc35 Reviewed-on: https://go-review.googlesource.com/c/go/+/317917 Reviewed-by: Than McIntosh <thanm@google.com> Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-07-19[dev.unified] all: merge master (8e1e64c) into dev.unifiedDavid Chase
Conflicts: - test/run.go Conflicts in the known-fails list, plus removed a test from the known-fails that now works. Merge List: + 2022-07-19 8e1e64c16a cmd/compile: fix mknode script + 2022-07-19 28be440d34 A+C: add Weizhi Yan + 2022-07-19 85a482fc24 runtime: revert to using the precomputed trigger for pacer calculations + 2022-07-19 ae7340ab68 CONTRIBUTORS: update for the Go 1.19 release + 2022-07-18 de8101d21b runtime: fix typos + 2022-07-18 967a3d985d cmd/compile: revert "remove -installsuffix flag" + 2022-07-18 c0c1bbde17 http: improve Get documentation + 2022-07-15 2aa473cc54 go/types, types2: correct alignment of atomic.Int64 + 2022-07-15 4651ebf961 encoding/gob: s/TestIngoreDepthLimit/TestIgnoreDepthLimit/ + 2022-07-14 dc00aed6de go/parser: skip TestParseDepthLimit for short tests + 2022-07-14 783ff7dfc4 encoding/xml: skip TestCVE202230633 for short tests + 2022-07-14 aa80228526 cmd/go/internal/modfetch: avoid duplicating path components in Git fetch errors + 2022-07-14 b9d5a25442 cmd/go: save zip sums for downloaded modules in 'go mod download' in a workspace + 2022-07-14 a906d3dd09 cmd/go: avoid re-enqueuing workspace dependencies with errors + 2022-07-14 266c70c263 doc/go1.19: add a release note for 'go list -json=SomeField' + 2022-07-13 558785a0a9 cmd/compile: remove -installsuffix flag + 2022-07-13 1355ea3045 cmd/compile: remove -importmap flag + 2022-07-13 f71f3d1b86 misc/cgo/testshared: run tests only in GOPATH mode + 2022-07-13 feada53661 misc/cgo/testcshared: don't rely on an erroneous install target in tests + 2022-07-13 c006b7ac27 runtime: clear timerModifiedEarliest when last timer is deleted + 2022-07-13 923740a8cc cmd/compile: fix type assert in dict pass + 2022-07-12 bf2ef26be3 cmd/go: in script tests, avoid checking non-main packages for staleness + 2022-07-12 5f5cae7200 cmd/go: avoid indexing GOROOT packages when the compiler is 'gccgo' + 2022-07-12 c2edb2c841 cmd/go: port TestIssue16471 to a script test and add verbose logging + 2022-07-12 9c2526e637 cmd/go/internal/modfetch/codehost: add missing newline in '# lock' log message + 2022-07-12 85486bcccb image/jpeg: increase TestLargeImageWithShortData timeout by an order of magnitude + 2022-07-12 27794c4d4a cmd/go/internal/modload: ignore disallowed errors when checking for updates + 2022-07-12 b2b8872c87 compress/gzip: fix stack exhaustion bug in Reader.Read + 2022-07-12 ac68c6c683 path/filepath: fix stack exhaustion in Glob + 2022-07-12 fa2d41d0ca io/fs: fix stack exhaustion in Glob + 2022-07-12 6fa37e98ea encoding/gob: add a depth limit for ignored fields + 2022-07-12 695be961d5 go/parser: limit recursion depth + 2022-07-12 08c46ed43d encoding/xml: use iterative Skip, rather than recursive + 2022-07-12 c4c1993fd2 encoding/xml: limit depth of nesting in unmarshal + 2022-07-12 913d05133c cmd/go: avoid spurious readdir during fsys.Walk + 2022-07-12 d3d7998756 net/http: clarify that MaxBytesReader returns *MaxBytesError + 2022-07-11 126c22a098 syscall: gofmt after CL 412114 + 2022-07-11 123a6328b7 internal/trace: don't report regions on system goroutines + 2022-07-11 846490110a runtime/race: update amd64 syso images to avoid sse4 + 2022-07-11 b75ad09cae cmd/trace: fix typo in web documentation + 2022-07-11 7510e597de cmd/go: make module index loading O(1) + 2022-07-11 b8bf820d5d cmd/nm: don't rely on an erroneous install target in tests + 2022-07-11 ad641e8521 misc/cgo/testcarchive: don't rely on an erroneous install target in tests + 2022-07-11 bf5898ef53 net/url: use EscapedPath for url.JoinPath + 2022-07-11 398dcd1cf0 database/sql: make TestTxContextWaitNoDiscard test more robust + 2022-07-11 f956941b0f cmd/go: use package index for std in load.loadPackageData + 2022-07-11 59ab6f351a net/http: remove Content-Encoding in writeNotModified + 2022-07-08 c1a4e0fe01 cmd/compile: fix libfuzzer instrumentation line number + 2022-07-08 5c1a13e7a4 cmd/go: avoid setting variables for '/' and ':' in TestScript subprocess environments + 2022-07-08 180bcad33d net/http: wait for listeners to exit in Server.Close and Shutdown + 2022-07-08 14abe8aa73 cmd/compile: don't convert to interface{} for un-comparable types in generic switch + 2022-07-07 1ebc983000 runtime: overestimate the amount of allocated memory in heapLive + 2022-07-07 c177d9d98a crypto/x509: restrict CRL number to <=20 octets + 2022-07-07 486fc01770 crypto/x509: correctly parse CRL entry extensions + 2022-07-07 8ac58de185 crypto/x509: populate Number and AKI of parsed CRLs + 2022-07-07 0c7fcf6bd1 cmd/link: explicitly disable PIE for windows/amd64 -race mode + 2022-07-07 eaf2125654 cmd/go: default to "exe" build mode for windows -race + 2022-07-06 1243ec9c17 cmd/compile: only check implicit dots for method call enabled by a type bound + 2022-07-06 c391156f96 cmd/go: set up git identity for build_buildvcs_auto.txt + 2022-07-06 2acd3646fc cmd/compile: rework induction variable detector + 2022-07-06 53a4152d47 os/exec: clarify that Wait must be called + 2022-07-06 177306f630 cmd/internal/notsha256: add purego tag as needed + 2022-07-06 f4755fc733 cmd/dist: use purego tag when building the bootstrap binaries + 2022-07-06 4484c30f78 misc/cgo/test: make TestSetgidStress cheaper + 2022-07-06 2007599dc8 test: recognize new gofrontend error message + 2022-07-05 d602380f58 cmd/compile: drop "buildcfg" from no instrument packages + 2022-07-05 c111091071 cmd/go: make module@nonexistentversion failures reusable + 2022-07-05 5f305ae8e5 cmd/go: add -reuse flag to make proxy invocations more efficient + 2022-07-05 84e091eef0 cmd/go: record origin metadata during module download + 2022-07-04 ceda93ed67 build/constraint: update doc to mention a feature added in Go 1.17 + 2022-07-04 3cf79d9610 runtime: pass correct string to exits on Plan 9 + 2022-07-01 e822b1e26e net/http: omit invalid header value from error message + 2022-07-01 4a2a3bca18 cmd/go, go/build: clarify build constraint docs + 2022-07-01 9a4d5357f4 flag: highlight support for double dashes in docs + 2022-07-01 c847a2c9f0 go/types, types2: document that exported predicates are unspecified for invalid type arguments + 2022-06-30 405c269b85 go/types, types2: re-enable a couple of commented out tests + 2022-06-30 aad9382e59 go/doc/comment: support links in lists in comments + 2022-06-30 af725f4286 os: fix a typo in path_windows.go Change-Id: I381728322188aca0bfa81a946d6aedda8c07903c
2022-07-18cmd/compile: revert "remove -installsuffix flag"Matthew Dempsky
This reverts CL 415236 (commit 558785a0a9df5fbb7e9617c05059cf2892884620). Reason for revert: Google's internal build system uses -installsuffix. Restoring -installsuffix for Go 1.19, and will try again for Go 1.20. Change-Id: Id6571f34f99f01bcf55e8e949e6fe7b6c1896134 Reviewed-on: https://go-review.googlesource.com/c/go/+/418036 TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Matthew Dempsky <mdempsky@google.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: David Chase <drchase@google.com>
2022-07-13cmd/compile: remove -installsuffix flagMatthew Dempsky
Obsoleted by -importcfg. cmd/link has a similar flag, but it seems to still be needed at least for misc/cgo/testshared.TestGopathShlib. I can't immediately tell why (has something to do with finding .so files), but it doesn't appear to possibly affect cmd/compile. Updates #51225. Change-Id: I80c6aef860bd162c010ad4a1a4f532b400cf901c Reviewed-on: https://go-review.googlesource.com/c/go/+/415236 Reviewed-by: David Chase <drchase@google.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Russ Cox <rsc@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-07-13cmd/compile: remove -importmap flagMatthew Dempsky
Obsoleted by -importcfg, and no longer used by anything. Updates #51225. Change-Id: I49e646d2728347f862f90805051bb03dd4f4bed2 Reviewed-on: https://go-review.googlesource.com/c/go/+/415235 Reviewed-by: Russ Cox <rsc@golang.org> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: David Chase <drchase@google.com>
2022-07-12internal/pkgbits: change EnableSync into a dynamic knobMatthew Dempsky
Rather than requiring users to recompile the compiler and all tools to enable/disable sync markers, this CL adds a flag word into the Unified IR file format to allow indicating whether they're enabled or not. This in turn requires bumping the file format version. Thanks to drchase@ for benchmarks showing this isn't as expensive as I feared it would be. Change-Id: I99afa0ee0b6ef5f30ed8ca840805ff9fd46b1857 Reviewed-on: https://go-review.googlesource.com/c/go/+/417097 Reviewed-by: David Chase <drchase@google.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-07-05cmd/compile: drop "buildcfg" from no instrument packagesMichael Pratt
Package buildcfg was added to this list by CL 403851, but package buildcfg does not exist. This was probably intended to refer to internal/buildcfg, but internal/buildcfg is only used by the compiler so it is not clear why it couldn't be instrumented. For #44853. Change-Id: Iad2517358be79c3eabf240376156bcff0c4bcefc Reviewed-on: https://go-review.googlesource.com/c/go/+/414516 Reviewed-by: Bryan Mills <bcmills@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Michael Pratt <mpratt@google.com>
2022-05-11cmd/internal/obj: add a flag to not write referenced symbol names in object fileCherry Mui
The Go object file references (some of) symbols from other packages by indices, not by names. The linker doesn't need the symbol names to do the linking. The names are included in the object file so it is self-contained and tools (objdump, nm) can read the referenced symbol names. Including the names increases object file size. Add a flag to disable it on demand (off by default). Change-Id: I143a0eb656997497c750b8eb1541341b2aee8f30 Reviewed-on: https://go-review.googlesource.com/c/go/+/404297 TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Cherry Mui <cherryyz@google.com> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2022-05-04cmd/compile: enable Asan check for global variablesfanzha02
With this patch, -asan option can detect the error memory access to global variables. So this patch makes a few changes: 1. Add the asanregisterglobals runtime support function, which calls asan runtime function _asan_register_globals to register global variables. 2. Create a new initialization function for the package being compiled. This function initializes an array of instrumented global variables and pass it to function runtime.asanregisterglobals. An instrumented global variable has trailing redzone. 3. Writes the new size of instrumented global variables that have trailing redzones into object file. 4. Notice that the current implementation is only compatible with the ASan library from version v7 to v9. Therefore, using the -asan option requires that the gcc version is not less than 7 and the clang version is less than 4, otherwise a segmentation fault will occur. So this patch adds a check on whether the compiler being used is a supported version in cmd/go. (This is a redo of CL 401775 with a fix for a build break due to an intervening commit that removed the internal/execabs package.) Updates #44853. Change-Id: I719d4ef2b22cb2d5516e1494cd453c3efb47d6c7 Reviewed-on: https://go-review.googlesource.com/c/go/+/403851 Auto-Submit: Bryan Mills <bcmills@google.com> Run-TryBot: Bryan Mills <bcmills@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@google.com>
generated by cgit v1.3 (git 2.53.0) at 2026-04-15 10:02:11 +0000