aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/gc
AgeCommit message (Collapse)Author
2015-02-23[dev.cc] cmd/6a, cmd/6g etc: replace C implementations with Go implementationsRuss Cox
Change-Id: I58e00a39cf63df07813d21453f91e68eef6a413c Reviewed-on: https://go-review.googlesource.com/5635 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20[dev.cc] all: merge master (5868ce3) into dev.ccRuss Cox
This time for sure! Change-Id: I7e7ea24edb7c2f711489e162fb97237a87533089
2015-02-20[dev.cc] cmd/gc: tweak default fatal in ordersafeexpr for c2goRuss Cox
c2go was putting a fallthrough after the fatal call. Changed c2go to know that fatal doesn't return, but then there is a missing return at the end of the translated Go function. Move code around a little to make C and Go agree. Change-Id: Icef3d55ccdde0709c02dd0c2b78826f6da33a146 Reviewed-on: https://go-review.googlesource.com/5170 Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
2015-02-18cmd/gc: replace NULL by nilDavid du Colombier
In CL 3964, NULL was used instead of nil. However, Plan 9 doesn't declare NULL. Change-Id: Ied3850aca5c8bca5974105129a37d575df33f6ec Reviewed-on: https://go-review.googlesource.com/5150 Reviewed-by: Minux Ma <minux@golang.org>
2015-02-18cmd/gc: generate simpler names for closuresDmitry Vyukov
Fixes #8291 There were several complaints about closure names in the issue tracker. The first problem is that you see names like net/http.func·001 in profiles, traces, etc. And there is no way to figure out what is that function. Another issue is non-US-ascii symbols. All programs out there should accept UTF-8. But unfortunately it is not true in reality. For example, less does not render middle dot properly. This change prepends outer function name to closure name and replaces middle dot with dot. Now names look like: main.glob.func1 main.glob.func2 main.glob.func2.1 main.init.1 main.init.1.func1 main.init.1.func1.1 main.main.func1 main.main.func1.1 Change-Id: I725726af88f2ad3ced2e3450f0f06bf459fd91c0 Reviewed-on: https://go-review.googlesource.com/3964 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-17[dev.cc] cmd/gc, cmd/ld, runtime: minor tweaks for c2goRuss Cox
Change-Id: I3be69a4ebf300ad24b55b5f43fd7ad1f001c762e Reviewed-on: https://go-review.googlesource.com/4838 Reviewed-by: Rob Pike <r@golang.org>
2015-02-15cmd/gc: fix noscan mapsDmitry Vyukov
Change 85e7bee introduced a bug: it marks map buckets as noscan when key and val do not contain pointers. However, buckets with large/outline key or val do contain pointers. This change takes key/val size into consideration when marking buckets as noscan. Change-Id: I7172a0df482657be39faa59e2579dd9f209cb54d Reviewed-on: https://go-review.googlesource.com/4901 Reviewed-by: Keith Randall <khr@golang.org>
2015-02-13cmd/gc: replace NULL by nilDavid du Colombier
In CL 4050, NULL was used instead of nil. However, Plan 9 doesn't declare NULL. Change-Id: I8295a3102509a1ce417278f23a37cbf65938cce1 Reviewed-on: https://go-review.googlesource.com/4814 Reviewed-by: Minux Ma <minux@golang.org> Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13cmd/gc: minor adjustments for C to Go translationRuss Cox
- remove a few uses of ? : - rename variables named len - rewrite a few gotos as nested switches - move goto targets to scope allowed by Go - use consistent return type of anyregalloc (was int or int32 in different places) - remove unused nr variable in agen - include proper headers in generated builtin1.c - avoid strange sized %E formats (%-6E, %2E) - change gengcmask argument from uint8[16] to uint8* (diagnosed by c2go; not an array in any real sense). - replace #ifdef XXX with comment block in 5g/peep.c - expand and remove FAIL macro from 5g - expand and remove noimpl macro from 9g - print regalloc errors to stdout in 8g (only use of fprint(2, ...) in all compilers) Still producing bit-for-bit identical output. Change-Id: Id46efcd2a89241082b234f63f375b66f2754d695 Reviewed-on: https://go-review.googlesource.com/4646 Reviewed-by: Austin Clements <austin@google.com>
2015-02-13cmd/gc: eliminate some pointer arithmeticRuss Cox
In mparith, all the a1-- are problematic. Rewrite it all without pointers. It's clearer anyway. In popt, v is problematic because it is used both as a fixed pointer (v = byvar[i]) and as a moving pointer (v = var; v++) aka slice. Eliminate pointer movement. Tested that this still produces bit-for-bit output for 'go build -a std' compared to d260756 (current master). Change-Id: I1a1bed0f98b594c3864fe95075dd95f9b52113e0 Reviewed-on: https://go-review.googlesource.com/4645 Reviewed-by: Austin Clements <austin@google.com>
2015-02-13cmd/gc: rename arch to thearchRuss Cox
Otherwise the exported variable collides with the type Arch. While we're here, remove arch.dumpit (now in portable code) and add arch.defframe (forgotten originally, somehow). Change-Id: I1b3a7dd7e96c5f632dba7cd6c1217b42a2004d72 Reviewed-on: https://go-review.googlesource.com/4644 Reviewed-by: Austin Clements <austin@google.com>
2015-02-13cmd/gc: add .y to error about missing x in x.yRuss Cox
If the Go source says x.y, and x is undefined, today we get undefined: x Change to: undefined: x in x.y Change-Id: I8ea95503bd469ea933c6bcbd675b7122a5d454f3 Reviewed-on: https://go-review.googlesource.com/4643 Reviewed-by: Austin Clements <austin@google.com>
2015-02-13cmd/gc: add debugging to liveness analysisRuss Cox
Even with debugmerge = 1, the debugging output only happens with the -v command-line flag. This is useful because it gets added in automatically when debugging things like registerization with -R -v. Change-Id: I9a5c7f562507b72e8e2fe2686fd07d069721345a Reviewed-on: https://go-review.googlesource.com/4641 Reviewed-by: Austin Clements <austin@google.com>
2015-02-13cmd/gc: correct errors in constant parsingRuss Cox
Change-Id: I36f77e7ac7f727d8f3b51133f4b3ef93c35b09f6 Reviewed-on: https://go-review.googlesource.com/4640 Reviewed-by: Austin Clements <austin@google.com>
2015-02-13cmd/gc: avoid writing past end of region arrayRuss Cox
Noticed last week. Just saw a strange build failure in the revised rcmp (called by qsort on region) and this fixed it. Submitting first to avoid finding out which of my pending CLs tickled the problem. Change-Id: I4cafd611e2bf8e813e57ad0025e48bde5ae54359 Reviewed-on: https://go-review.googlesource.com/4830 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13cmd/gc: transform closure calls to function callsDmitry Vyukov
Currently we always create context objects for closures that capture variables. However, it is completely unnecessary for direct calls of closures (whether it is func()(), defer func()() or go func()()). This change transforms any OCALLFUNC(OCLOSURE) to normal function call. Closed variables become function arguments. This transformation is especially beneficial for go func(), because we do not need to allocate context object on heap. But it makes direct closure calls a bit faster as well (see BenchmarkClosureCall). On implementation level it required to introduce yet another compiler pass. However, the pass iterates only over xtop, so it should not be an issue. Transformation consists of two parts: closure transformation and call site transformation. We can't run these parts on different sides of escape analysis, because tree state is inconsistent. We can do both parts during typecheck, we don't know how to capture variables and don't have call site. We can't do both parts during walk of OCALLFUNC, because we can walk OCLOSURE body earlier. So now capturevars pass only decides how to capture variables (this info is required for escape analysis). New transformclosure pass, that runs just before order/walk, does all transformations of a closure. And later walk of OCALLFUNC(OCLOSURE) transforms call site. benchmark old ns/op new ns/op delta BenchmarkClosureCall 4.89 3.09 -36.81% BenchmarkCreateGoroutinesCapture 1634 1294 -20.81% benchmark old allocs new allocs delta BenchmarkCreateGoroutinesCapture 6 2 -66.67% benchmark old bytes new bytes delta BenchmarkCreateGoroutinesCapture 176 48 -72.73% Change-Id: Ic85e1706e18c3235cc45b3c0c031a9c1cdb7a40e Reviewed-on: https://go-review.googlesource.com/4050 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-13cmd/gc: restore amd64p32 hack for bucket sizeDmitry Vyukov
This was accidentially removed in: https://go-review.googlesource.com/#/c/3508/8/src/cmd/gc/reflect.c Change-Id: I06dd5bb0cb3e2811bd4ef605d7a5225cfa033fe0 Reviewed-on: https://go-review.googlesource.com/4731 Reviewed-by: Keith Randall <khr@golang.org>
2015-02-12cmd/gc: evaluate concrete == interface without allocatingJosh Bleecher Snyder
Consider an interface value i of type I and concrete value c of type C. Prior to this CL, i==c was evaluated as I(c) == i Evaluating I(c) can allocate. This CL changes the evaluation of i==c to x, ok := i.(C); ok && x == c The new generated code is shorter and does not allocate directly. If C is small, as it is in every instance in the stdlib, the new code also uses less stack space and makes one runtime call instead of two. If C is very large, the original implementation is used. The cutoff for "very large" is 1<<16, following the stack vs heap cutoff used elsewhere. This kind of comparison occurs in 38 places in the stdlib, mostly in the net and os packages. benchmark old ns/op new ns/op delta BenchmarkEqEfaceConcrete 29.5 7.92 -73.15% BenchmarkEqIfaceConcrete 32.1 7.90 -75.39% BenchmarkNeEfaceConcrete 29.9 7.90 -73.58% BenchmarkNeIfaceConcrete 35.9 7.90 -77.99% Fixes #9370. Change-Id: I7c4555950bcd6406ee5c613be1f2128da2c9a2b7 Reviewed-on: https://go-review.googlesource.com/2096 Reviewed-by: Russ Cox <rsc@golang.org> Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
2015-02-12cmd/gc: allocate non-escaping maps on stackDmitry Vyukov
Extend escape analysis to make(map[k]v). If it does not escape, allocate temp buffer for hmap and one bucket on stack. There are 75 cases of non-escaping maps in std lib. benchmark old allocs new allocs delta BenchmarkConcurrentStmtQuery 16161 15161 -6.19% BenchmarkConcurrentTxQuery 17658 16658 -5.66% BenchmarkConcurrentTxStmtQuery 16157 15156 -6.20% BenchmarkConcurrentRandom 13637 13114 -3.84% BenchmarkManyConcurrentQueries 22 20 -9.09% BenchmarkDecodeComplex128Slice 250 188 -24.80% BenchmarkDecodeFloat64Slice 250 188 -24.80% BenchmarkDecodeInt32Slice 250 188 -24.80% BenchmarkDecodeStringSlice 2250 2188 -2.76% BenchmarkNewEmptyMap 1 0 -100.00% BenchmarkNewSmallMap 2 0 -100.00% benchmark old ns/op new ns/op delta BenchmarkNewEmptyMap 124 55.7 -55.08% BenchmarkNewSmallMap 317 148 -53.31% benchmark old allocs new allocs delta BenchmarkNewEmptyMap 1 0 -100.00% BenchmarkNewSmallMap 2 0 -100.00% benchmark old bytes new bytes delta BenchmarkNewEmptyMap 48 0 -100.00% BenchmarkNewSmallMap 192 0 -100.00% Fixes #5449 Change-Id: I24fa66f949d2f138885d9e66a0d160240dc9e8fa Reviewed-on: https://go-review.googlesource.com/3508 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: Dmitry Vyukov <dvyukov@google.com>
2015-02-12cmd/gc: restore stack frame debuggingDmitry Vyukov
Dump frames of functions. Add function name and var width to output. Change-Id: Ida06b8def96178fa550ca90836eb4a2509b9e13f Reviewed-on: https://go-review.googlesource.com/3870 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-12runtime: fix race instrumentation of appendDmitry Vyukov
typedslicecopy is another write barrier that is not understood by racewalk. It seems quite complex to handle it in the compiler, so instead just instrument it in runtime. Update #9796 Change-Id: I0eb6abf3a2cd2491a338fab5f7da22f01bf7e89b Reviewed-on: https://go-review.googlesource.com/4370 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-12cmd/gc: remove several copies of outervalueDmitry Vyukov
Walk calls it outervalue, racewalk calls it basenod, isstack does it manually and slightly differently. Change-Id: Id5b5d32b8faf143fe9d34bd08457bfab6fb33daa Reviewed-on: https://go-review.googlesource.com/3745 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-12cmd/gc: allocate buffers for non-escaping string conversions on stackDmitry Vyukov
Support the following conversions in escape analysis: []rune("foo") []byte("foo") string([]rune{}) If the result does not escape, allocate temp buffer on stack and pass it to runtime functions. Change-Id: I1d075907eab8b0109ad7ad1878104b02b3d5c690 Reviewed-on: https://go-review.googlesource.com/3590 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-11cmd/gc: avoid %#016x, which really means Go's %#014xRuss Cox
(In non-Go print formats, the 016 includes the leading 0x prefix. No one noticed, but we were printing hex numbers with a minimum of 30 digits, not 32.) Change-Id: I10ff7a51a567ad7c8440418ac034be9e4b2d6bc1 Reviewed-on: https://go-review.googlesource.com/4592 Reviewed-by: Austin Clements <austin@google.com>
2015-02-11cmd/gc: use go.builtin as package prefix, not go%2ebuiltinRuss Cox
This matches all the other pseudo-packages. The line was simply forgotten. Change-Id: I278f6cbcfc883ea7efad07f99fc8c853b9b5d274 Reviewed-on: https://go-review.googlesource.com/4591 Reviewed-by: Austin Clements <austin@google.com>
2015-02-11cmd/gc: make qsort comparisons totally orderedRuss Cox
Otherwise different qsort implementations might result in different sort orders and therefore different compiled object files. Change-Id: Ie783ba55a55af06941307e150b0c406e0a8128b0 Reviewed-on: https://go-review.googlesource.com/4590 Reviewed-by: Austin Clements <austin@google.com>
2015-02-11cmd/gc: remove C subclassing trick from popt.cRuss Cox
It does not convert to Go well. Being able to do this just once, instead of 4 times, was the primary motivation for all the recent refactoring (not that it wasn't overdue). Still bit-for-bit identical. Change-Id: Ia01f17948441bf64fa78ec4226f0bb40af0bbaab Reviewed-on: https://go-review.googlesource.com/3962 Reviewed-by: Austin Clements <austin@google.com>
2015-02-11cmd/gc: move reg.c into portable codeRuss Cox
Now there is only one registerizer shared among all the systems. There are some unfortunate special cases based on arch.thechar in reg.c, to preserve bit-for-bit compatibility during the refactoring. Most are probably bugs one way or another and should be revisited. Change-Id: I153b435c0eaa05bbbeaf8876822eeb6dedaae3cf Reviewed-on: https://go-review.googlesource.com/3883 Reviewed-by: Austin Clements <austin@google.com>
2015-02-11cmd/gc: remove cgen_asop, no longer usedRuss Cox
gc/order.c rewrites OASOP nodes into ordinary assignments. The back ends never see them anymore. Change-Id: I268ac8bdc92dccd7123110a21f99ada3ceeb2baa Reviewed-on: https://go-review.googlesource.com/3882 Reviewed-by: Austin Clements <austin@google.com>
2015-02-11cmd/gc: factor newly-portable code into gc directoryRuss Cox
This isn't everything, but it's a start. Still producing bit-identical compiler output. The semantics of the old back ends is preserved, even when they are probably buggy. There are some TODOs in gc/gsubr.c to remove special cases to preserve bugs in 5g and 8g. Change-Id: I28ae295fbfc94ef9df43e13ab96bd6fc2f194bc4 Reviewed-on: https://go-review.googlesource.com/3802 Reviewed-by: Austin Clements <austin@google.com>
2015-02-09cmd/gc: remove dead codeDmitry Vyukov
Change-Id: Ib46a42fc873066b1cc00368fe43648f08dce48bd Reviewed-on: https://go-review.googlesource.com/4200 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2015-02-06cmd/gc: eliminate dead code in switch statementsJosh Bleecher Snyder
Ordinary switch statements are rewritten into a sequence of if statements. Staticly dead cases were not being eliminated because the rewrite introduced a temporary, which hid the fact that the case was a constant. Stop doing that. This eliminates dead code in the standard library at: runtime/cgocall.go:219 runtime/cgocall.go:269 debug/gosym/pclntab.go:175 debug/macho/file.go:208 math/big/nat.go:635 math/big/nat.go:850 math/big/nat.go:1058 cmd/pprof/internal/commands/commands.go:86 net/sock_bsd.go:19 cmd/go/build.go:2657 cmd/go/env.go:90 Fixes #9608. Change-Id: Ic23a05dfbb1ad91d5f62a6506b35a13e51b33e38 Reviewed-on: https://go-review.googlesource.com/3980 Reviewed-by: Keith Randall <khr@golang.org>
2015-02-06runtime: speed up eqstringJosh Bleecher Snyder
eqstring does not need to check the length of the strings. 6g benchmark old ns/op new ns/op delta BenchmarkCompareStringEqual 7.03 6.14 -12.66% BenchmarkCompareStringIdentical 3.36 3.04 -9.52% 5g benchmark old ns/op new ns/op delta BenchmarkCompareStringEqual 238 232 -2.52% BenchmarkCompareStringIdentical 90.8 80.7 -11.12% The equivalent PPC changes are in a separate commit because I don't have the hardware to test them. Change-Id: I292874324b9bbd9d24f57a390cfff8b550cdd53c Reviewed-on: https://go-review.googlesource.com/3955 Reviewed-by: Keith Randall <khr@golang.org>
2015-02-06all: don't refer to code.google.com/p/go{,-wiki}/Péter Surányi
Only documentation / comment changes. Update references to point to golang.org permalinks or go.googlesource.com/go. References in historical release notes under doc are left as is. Change-Id: Icfc14e4998723e2c2d48f9877a91c5abef6794ea Reviewed-on: https://go-review.googlesource.com/4060 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-02-04cmd/gc: don't copy string in range []byte(str)Dmitry Vyukov
Using benchmark from the issue: benchmark old ns/op new ns/op delta BenchmarkRangeStringCast 2162 1152 -46.72% benchmark old allocs new allocs delta BenchmarkRangeStringCast 1 0 -100.00% Fixes #2204 Change-Id: I92c5edd2adca4a7b6fba00713a581bf49dc59afe Reviewed-on: https://go-review.googlesource.com/3790 Reviewed-by: Keith Randall <khr@golang.org>
2015-02-03liblink: define fixed A-numbers for common instructionsRuss Cox
This makes names like ANOP, ATEXT, AGLOBL, ACALL, AJMP, ARET available for use by architecture-independent processing passes. On arm and ppc64, the alternate names are now aliases for the official ones (ABL for ACALL, AB or ABR for AJMP, ARETURN for ARET). Change-Id: Id027771243795af2b3745199c645b6e1bedd7d18 Reviewed-on: https://go-review.googlesource.com/3577 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Austin Clements <austin@google.com>
2015-02-03liblink: the zero Prog is now valid and ready for useRuss Cox
Use AXXX instead of AGOK (neither is a valid instruction but AXXX is zero) for the initial setting of Prog.as, and now there are no non-zero default field settings. Remove the arch-specific zprog/zprg in favor of a single global zprog. Remove the arch-specific prg constructor in favor of emallocz(sizeof(Prog)). Change-Id: Ia73078726768333d7cdba296f548170c1bea9498 Reviewed-on: https://go-review.googlesource.com/3575 Reviewed-by: Aram Hăvărneanu <aram@mgk.ro> Reviewed-by: Austin Clements <austin@google.com>
2015-02-03liblink: place TEXT/GLOBL flags in p->from3 alwaysRuss Cox
Before, amd64 and 386 stored the flags in p->from.scale and arm and ppc64 stored the flags in p->reg. Both caused special cases in printing and in handling of the addresses. To avoid possible conflicts with the real meaning of p->from and to avoid storing a non-register value in a reg field, use from3 to hold a TYPE_CONST value giving the flags. There is still a special case for printing, because the flags are specified without a $, and normally a TYPE_CONST prints with a $. But that's much less special than what came before. This allows us to remove the textflag and settextflag methods from LinkArch. They are no longer architecture-specific. Change-Id: I931da8e1ecd92e127cd9aa44ef5a73c42e730110 Reviewed-on: https://go-review.googlesource.com/3572 Reviewed-by: Austin Clements <austin@google.com>
2015-02-03cmd/gc: fix capturing by value for range statementsDmitry Vyukov
Kindly detected by race builders by failing TestRaceRange. ORANGE typecheck does not increment decldepth around body. Change-Id: I0df5f310cb3370a904c94d9647a9cf0f15729075 Reviewed-on: https://go-review.googlesource.com/3507 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-03cmd/gc: typecheck type switch variablesDmitry Vyukov
Type switch variables was not typechecked. Previously it lead only to a minor consequence: switch unsafe.Sizeof = x.(type) { generated an inconsistent error message. But capturing by value functionality now requries typechecking of all ONAMEs. Fixes #9731 Change-Id: If037883cba53d85028fb97b1328696091b3b7ddd Reviewed-on: https://go-review.googlesource.com/3600 Reviewed-by: Russ Cox <rsc@golang.org>
2015-02-02cmd/gc: always treat the output parameters as having been assigned in ↵Shenghou Ma
capturevars. Fixes #9738. Change-Id: Iab75de2d78335d4e31c3dce6a0e1826d8cddf5f3 Reviewed-on: https://go-review.googlesource.com/3690 Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
2015-01-30liblink: fix arm build againDave Cheney
Another attempt to fix the arm build by moving the include of signal.h to cmd/lex.c, unless we are building on plan9. Obviously if we had a plan9/arm builder this would probably not work, but this is only a temporary measure until the c2go transition is complete. Change-Id: I7f8ae27349b2e7a09c55db03e02a01939159a268 Reviewed-on: https://go-review.googlesource.com/3566 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-30cmd/gc, cmd/ld, liblink: update for portable Prog, Addr changesRuss Cox
Change-Id: Ia6f8badca56565b9df80c8dbe28c47f6cf7e653f Reviewed-on: https://go-review.googlesource.com/3515 Reviewed-by: Austin Clements <austin@google.com> Reviewed-by: Aram Hăvărneanu <aram@mgk.ro>
2015-01-29cmd/gc: capture variables by valueDmitry Vyukov
Language specification says that variables are captured by reference. And that is what gc compiler does. However, in lots of cases it is possible to capture variables by value under the hood without affecting visible behavior of programs. For example, consider the following typical pattern: func (o *Obj) requestMany(urls []string) []Result { wg := new(sync.WaitGroup) wg.Add(len(urls)) res := make([]Result, len(urls)) for i := range urls { i := i go func() { res[i] = o.requestOne(urls[i]) wg.Done() }() } wg.Wait() return res } Currently o, wg, res, and i are captured by reference causing 3+len(urls) allocations (e.g. PPARAM o is promoted to PPARAMREF and moved to heap). But all of them can be captured by value without changing behavior. This change implements simple strategy for capturing by value: if a captured variable is not addrtaken and never assigned to, then it is captured by value (it is effectively const). This simple strategy turned out to be very effective: ~80% of all captures in std lib are turned into value captures. The remaining 20% are mostly in defers and non-escaping closures, that is, they do not cause allocations anyway. benchmark old allocs new allocs delta BenchmarkCompressedZipGarbage 153 126 -17.65% BenchmarkEncodeDigitsSpeed1e4 91 69 -24.18% BenchmarkEncodeDigitsSpeed1e5 178 129 -27.53% BenchmarkEncodeDigitsSpeed1e6 1510 1051 -30.40% BenchmarkEncodeDigitsDefault1e4 100 75 -25.00% BenchmarkEncodeDigitsDefault1e5 193 139 -27.98% BenchmarkEncodeDigitsDefault1e6 1420 985 -30.63% BenchmarkEncodeDigitsCompress1e4 100 75 -25.00% BenchmarkEncodeDigitsCompress1e5 193 139 -27.98% BenchmarkEncodeDigitsCompress1e6 1420 985 -30.63% BenchmarkEncodeTwainSpeed1e4 109 81 -25.69% BenchmarkEncodeTwainSpeed1e5 211 151 -28.44% BenchmarkEncodeTwainSpeed1e6 1588 1097 -30.92% BenchmarkEncodeTwainDefault1e4 103 77 -25.24% BenchmarkEncodeTwainDefault1e5 199 143 -28.14% BenchmarkEncodeTwainDefault1e6 1324 917 -30.74% BenchmarkEncodeTwainCompress1e4 103 77 -25.24% BenchmarkEncodeTwainCompress1e5 190 137 -27.89% BenchmarkEncodeTwainCompress1e6 1327 919 -30.75% BenchmarkConcurrentDBExec 16223 16220 -0.02% BenchmarkConcurrentStmtQuery 17687 16182 -8.51% BenchmarkConcurrentStmtExec 5191 5186 -0.10% BenchmarkConcurrentTxQuery 17665 17661 -0.02% BenchmarkConcurrentTxExec 15154 15150 -0.03% BenchmarkConcurrentTxStmtQuery 17661 16157 -8.52% BenchmarkConcurrentTxStmtExec 3677 3673 -0.11% BenchmarkConcurrentRandom 14000 13614 -2.76% BenchmarkManyConcurrentQueries 25 22 -12.00% BenchmarkDecodeComplex128Slice 318 252 -20.75% BenchmarkDecodeFloat64Slice 318 252 -20.75% BenchmarkDecodeInt32Slice 318 252 -20.75% BenchmarkDecodeStringSlice 2318 2252 -2.85% BenchmarkDecode 11 8 -27.27% BenchmarkEncodeGray 64 56 -12.50% BenchmarkEncodeNRGBOpaque 64 56 -12.50% BenchmarkEncodeNRGBA 67 58 -13.43% BenchmarkEncodePaletted 68 60 -11.76% BenchmarkEncodeRGBOpaque 64 56 -12.50% BenchmarkGoLookupIP 153 139 -9.15% BenchmarkGoLookupIPNoSuchHost 508 466 -8.27% BenchmarkGoLookupIPWithBrokenNameServer 245 226 -7.76% BenchmarkClientServer 62 59 -4.84% BenchmarkClientServerParallel4 62 59 -4.84% BenchmarkClientServerParallel64 62 59 -4.84% BenchmarkClientServerParallelTLS4 79 76 -3.80% BenchmarkClientServerParallelTLS64 112 109 -2.68% BenchmarkCreateGoroutinesCapture 10 6 -40.00% BenchmarkAfterFunc 1006 1005 -0.10% Fixes #6632. Change-Id: I0cd51e4d356331d7f3c5f447669080cd19b0d2ca Reviewed-on: https://go-review.googlesource.com/3166 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-28cmd/gc: allocate stack buffer for ORUNESTRDmitry Vyukov
If result of string(i) does not escape, allocate a [4]byte temp on stack for it. Change-Id: If31ce9447982929d5b3b963fd0830efae4247c37 Reviewed-on: https://go-review.googlesource.com/3411 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-28cmd/gc: allocate buffers for non-escaped strings on stackDmitry Vyukov
Currently we always allocate string buffers in heap. For example, in the following code we allocate a temp string just for comparison: if string(byteSlice) == "abc" { ... } This change extends escape analysis to cover []byte->string conversions and string concatenation. If the result of operations does not escape, compiler allocates a small buffer on stack and passes it to slicebytetostring and concatstrings. Then runtime uses the buffer if the result fits into it. Size of the buffer is 32 bytes. There is no fundamental theory behind this number. Just an observation that on std lib tests/benchmarks frequency of string allocation is inversely proportional to string length; and there is significant number of allocations up to length 32. benchmark old allocs new allocs delta BenchmarkFprintfBytes 2 1 -50.00% BenchmarkDecodeComplex128Slice 318 316 -0.63% BenchmarkDecodeFloat64Slice 318 316 -0.63% BenchmarkDecodeInt32Slice 318 316 -0.63% BenchmarkDecodeStringSlice 2318 2316 -0.09% BenchmarkStripTags 11 5 -54.55% BenchmarkDecodeGray 111 102 -8.11% BenchmarkDecodeNRGBAGradient 200 188 -6.00% BenchmarkDecodeNRGBAOpaque 165 152 -7.88% BenchmarkDecodePaletted 319 309 -3.13% BenchmarkDecodeRGB 166 157 -5.42% BenchmarkDecodeInterlacing 279 268 -3.94% BenchmarkGoLookupIP 153 135 -11.76% BenchmarkGoLookupIPNoSuchHost 508 466 -8.27% BenchmarkGoLookupIPWithBrokenNameServer 245 226 -7.76% BenchmarkClientServerParallel4 62 61 -1.61% BenchmarkClientServerParallel64 62 61 -1.61% BenchmarkClientServerParallelTLS4 79 78 -1.27% BenchmarkClientServerParallelTLS64 112 111 -0.89% benchmark old ns/op new ns/op delta BenchmarkFprintfBytes 381 311 -18.37% BenchmarkStripTags 2615 2351 -10.10% BenchmarkDecodeNRGBAGradient 3715887 3635096 -2.17% BenchmarkDecodeNRGBAOpaque 3047645 2928644 -3.90% BenchmarkGoLookupIP 153 135 -11.76% BenchmarkGoLookupIPNoSuchHost 508 466 -8.27% Change-Id: I9ec01da816945c3329d7be3c7794b520418c3f99 Reviewed-on: https://go-review.googlesource.com/3120 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-28cmd/gc: don't copy []byte during string comparisonDmitry Vyukov
Currently we allocate a new string during []byte->string conversion in string comparison expressions. String allocation is unnecessary in this case, because comparison does memorize the strings for later use. This change uses slicebytetostringtmp to construct temp string directly from []byte buffer and passes it to runtime.eqstring. Change-Id: If00f1faaee2076baa6f6724d245d5b5e0f59b563 Reviewed-on: https://go-review.googlesource.com/3410 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-28cmd/gc: ignore re-slicing in escape analysisDmitry Vyukov
Escape analysis treats everything assigned to OIND/ODOTPTR as escaping. As the result b escapes in the following code: func (b *Buffer) Foo() { n, m := ... b.buf = b.buf[n:m] } This change recognizes such assignments and ignores them. Update issue #9043. Update issue #7921. There are two similar cases in std lib that benefit from this optimization. First is in archive/zip: type readBuf []byte func (b *readBuf) uint32() uint32 { v := binary.LittleEndian.Uint32(*b) *b = (*b)[4:] return v } Second is in time: type data struct { p []byte error bool } func (d *data) read(n int) []byte { if len(d.p) < n { d.p = nil d.error = true return nil } p := d.p[0:n] d.p = d.p[n:] return p } benchmark old ns/op new ns/op delta BenchmarkCompressedZipGarbage 32431724 32217851 -0.66% benchmark old allocs new allocs delta BenchmarkCompressedZipGarbage 153 143 -6.54% Change-Id: Ia6cd32744e02e36d6d8c19f402f8451101711626 Reviewed-on: https://go-review.googlesource.com/3162 Reviewed-by: Keith Randall <khr@golang.org> Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-28cmd/gc: improve escape analysis for &T{...}Dmitry Vyukov
Currently all PTRLIT element initializers escape. There is no reason for that. This change links STRUCTLIT to PTRLIT; STRUCTLIT element initializers are already linked to the STRUCTLIT. As the result, PTRLIT element initializers escape when PTRLIT itself escapes. Change-Id: I89ecd8677cbf81addcfd469cd2fd461c0e9bf7dd Reviewed-on: https://go-review.googlesource.com/3031 Reviewed-by: Russ Cox <rsc@golang.org>
2015-01-28cmd/gc: fix condition for fast pathed interface conversionsDmitry Vyukov
For some reason the current conditions require the type to be "uintptr-shaped". This cuts off structs and arrays with a pointer. isdirectiface and width==widthptr is sufficient condition to enable the fast paths. Change-Id: I11842531e7941365413606cfd6c34c202aa14786 Reviewed-on: https://go-review.googlesource.com/3414 Reviewed-by: Russ Cox <rsc@golang.org>
generated by cgit v1.3 (git 2.53.0) at 2026-04-16 06:08:42 +0000