Keith Randall [Fri, 16 Sep 2016 19:11:33 +0000 (12:11 -0700)]
cmd/compile: turn live variable test off for ppc
ppc64 has an extraneous variable live in some situations.
We need a better tighten pass to get rid of this extra variable.
I'm working on it, but fix the test in the meantime.
Fixes build for ppc64.
Change-Id: I1efb9ccb234a64f2a1c228abd2b3195f67fbeb41
Reviewed-on: https://go-review.googlesource.com/29353 Reviewed-by: David Chase <drchase@google.com>
Keith Randall [Fri, 16 Sep 2016 16:36:00 +0000 (09:36 -0700)]
cmd/compile: reorganize SSA register numbering
Teach SSA about the cmd/internal/obj/$ARCH register numbering.
It can then return that numbering when requested. Each architecture
now does not need to know anything about the internal SSA numbering
of registers.
Change-Id: I34472a2736227c15482e60994eebcdd2723fa52d
Reviewed-on: https://go-review.googlesource.com/29249 Reviewed-by: David Chase <drchase@google.com>
David Crawshaw [Fri, 16 Sep 2016 15:35:53 +0000 (11:35 -0400)]
cmd/link: give RelocVariant a type, document Reloc
Change-Id: Ib20263405a08674b5e160295fc965da4c8b54b34
Reviewed-on: https://go-review.googlesource.com/29248 Reviewed-by: Ian Lance Taylor <iant@golang.org>
David Crawshaw [Fri, 9 Sep 2016 21:34:07 +0000 (17:34 -0400)]
cmd/link: attempt to rationalize linkmode init
This CL gives Linkmode a type, switches it to the standard flag
handling mechanism, and deduplicates some logic.
There is a semantic change in this CL. Previously if a link was
invoked explicitly with -linkmode=internal, any condition that forced
external linking would silently override this and use external
linking. Instead it now fails with a reason why. I believe this is an
improvement, but will change it back if there's disagreement.
Fixes #12848
Change-Id: Ic80e341fff65ecfdd2b6fdd6079674cc7210fc5f
Reviewed-on: https://go-review.googlesource.com/28971
Run-TryBot: David Crawshaw <crawshaw@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
David Crawshaw [Fri, 26 Aug 2016 12:51:58 +0000 (08:51 -0400)]
cmd/go: support -buildmode=plugin on linux
Change-Id: I0c8a04457db28c55c35c9a186b63c40f40730e39
Reviewed-on: https://go-review.googlesource.com/27824 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Bias {Eq,Neq}{8,16} to prefer the extension likely to match
their operand's load (if loaded), and elide sign and zero
extending MOV{B,W}, MOV{B,W}Z when their operands are already
appropriately extended.
Matthew Dempsky [Thu, 15 Sep 2016 23:33:11 +0000 (16:33 -0700)]
cmd/compile: remove traces of old register allocator
Only added lines are moving amd64 and x86's ginsnop functions from
gsubr.go to ggen.go to match other architectures, so all of the
gsubr.go files can go away.
Change-Id: Ib2292460c155ae6d9dcf5c9801f178031d8eea7a
Reviewed-on: https://go-review.googlesource.com/29240
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Dave Cheney <dave@cheney.net>
Alberto Bertogli [Thu, 15 Sep 2016 01:32:44 +0000 (02:32 +0100)]
net: document dummy byte in ReadMsgUnix and WriteMsgUnix
ReadMsgUnix and WriteMsgUnix both will read/write 1 byte from/to the
socket if they were given no buffer to read/write, to avoid a common
pitfall in out of band operations (they will usually block
indefinitely if there's no actual data to read).
This patch adds a note about this behaviour in their documentation, so
users can be aware of it.
Change-Id: I751f0e12bb4d80311e94ea8de023595c5d40ec3e
Reviewed-on: https://go-review.googlesource.com/29180
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
David Chase [Thu, 15 Sep 2016 20:51:35 +0000 (16:51 -0400)]
cmd/compile: adapt GOSSAHASH to set a DebugTest flag in ssa.Config
Binary search remains our friend.
Suppose you add an ought-to-be-benign pattern to PPC64.rules,
and make.bash starts crashing. You can guard the pattern(s)
with config.DebugTest:
David Chase [Thu, 15 Sep 2016 16:43:29 +0000 (12:43 -0400)]
cmd/compile: repair GOSSAFUNC functionality
GOSSAFUNC=foo had previously only done printing for the
single function foo, and didn't quite clean up after itself
properly. Changes ensures that Config.HTML != nil iff
GOSSAFUNC==name-of-current-function.
Change-Id: I255e2902dfc64f715d93225f0d29d9525c06f764
Reviewed-on: https://go-review.googlesource.com/29250
Run-TryBot: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
The only remaining consumers of gins were
ginsnop and arch-independent opcodes like GVARDEF.
Rewrite ginsnop to create and populate progs directly.
Move arch-independent opcodes to package gc
and simplify.
Delete some now unused code.
There is more.
Step one towards eliminating gc.Node.Reg.
cmd/compile: unroll comparisons to short constant strings
Unroll s == "ab" to
len(s) == 2 && s[0] == 'a' && s[1] == 'b'
This generates faster and shorter code
by avoiding a runtime call.
Do something similar for !=.
The cutoff length is 6. This was chosen empirically
by examining binary sizes on arm, arm64, 386, and amd64
using the SSA backend.
For all architectures examined, 4, 5, and 6 were
the ideal cutoff, with identical binary sizes.
The distribution of constant string equality sizes
during 'go build -a std' is:
40.81% 622 len 0
14.11% 215 len 4
9.45% 144 len 1
7.81% 119 len 3
7.48% 114 len 5
5.12% 78 len 7
4.13% 63 len 2
3.54% 54 len 8
2.69% 41 len 6
1.18% 18 len 10
0.85% 13 len 9
0.66% 10 len 14
0.59% 9 len 17
0.46% 7 len 11
0.26% 4 len 12
0.20% 3 len 19
0.13% 2 len 13
0.13% 2 len 15
0.13% 2 len 16
0.07% 1 len 20
0.07% 1 len 23
0.07% 1 len 33
0.07% 1 len 36
A cutoff of length 6 covers most of the cases.
Benchmarks on amd64 comparing a string to a constant of length 3:
The change to the prove test preserves the
existing intent of the test. When the string was
short, there was a new "proved in bounds" report
that referred to individual byte comparisons.
Dave Cheney [Thu, 15 Sep 2016 05:45:10 +0000 (15:45 +1000)]
cmd/compile/internal/gc: unexport more helper functions
After the removal of the old backend many types are no longer referenced
outside internal/gc. Make these functions private so that tools like
honnef.co/go/unused can spot when they become dead code. In doing so
this CL identified several previously public helpers which are no longer
used, so removes them.
After the removal of the old backend many types are no longer referenced
outside internal/gc. Make these functions private so that tools like
honnef.co/go/unused can spot when they become dead code. In doing so
this CL identified several previously public helpers which are no longer
used, so removes them.
Keith Randall [Wed, 14 Sep 2016 00:01:01 +0000 (17:01 -0700)]
cmd/compile: redo nil checks
Get rid of BlockCheck. Josh goaded me into it, and I went
down a rabbithole making it happen.
NilCheck now panics if the pointer is nil and returns void, as before.
BlockCheck is gone, and NilCheck is no longer a Control value for
any block. It just exists (and deadcode knows not to throw it away).
I rewrote the nilcheckelim pass to handle this case. In particular,
there can now be multiple NilCheck ops per block.
I moved all of the arch-dependent nil check elimination done as
part of ssaGenValue into its own proper pass, so we don't have to
duplicate that code for every architecture.
Making the arch-dependent nil check its own pass means I needed
to add a bunch of flags to the opcode table so I could write
the code without arch-dependent ops everywhere.
Change-Id: I419f891ac9b0de313033ff09115c374163416a9f
Reviewed-on: https://go-review.googlesource.com/29120
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Chase <drchase@google.com>
We will soon add dedicated builders for running vet/all.
Their name will end with "-vetall".
On those builders, run vet/all and nothing else.
On all other builders, including local all.bash,
don't run vet/all at all, because it is slow.
Martin Möhrmann [Sat, 10 Sep 2016 20:44:00 +0000 (22:44 +0200)]
cmd/compile: intrinsify slicebytetostringtmp when not instrumenting
when not instrumenting:
- Intrinsify uses of slicebytetostringtmp within the runtime package
in the ssa backend.
- Pass OARRAYBYTESTRTMP nodes to the compiler backends for lowering
instead of generating calls to slicebytetostringtmp.
name old time/op new time/op delta
ConcatStringAndBytes-4 27.9ns ± 2% 24.7ns ± 2% -11.52% (p=0.000 n=43+43)
Fixes #17044
Change-Id: I51ce9c3b93284ce526edd0234f094e98580faf2d
Reviewed-on: https://go-review.googlesource.com/29017
Run-TryBot: Martin Möhrmann <martisch@uos.de>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
Joe Tsai [Sun, 4 Sep 2016 01:16:52 +0000 (18:16 -0700)]
time: document in UnixNano when the value is valid
It is unlikely that the value of UnixNano overflow in most
use cases. However, the max date of 2262 is also within the range
where it may be of concern to some users. Rather than have each
person recompute when this overflows to validate if its okay for
their use case, we just document it as within the years 1678 and
2262, for user's convenience.
Fixes #16977
Change-Id: I4988738c147f4a6d30f8b8735c3941b75113bb16
Reviewed-on: https://go-review.googlesource.com/28478 Reviewed-by: Andrew Gerrand <adg@golang.org>
cmd/dist: skip compiling 100 packages without benchmarks in race mode
The go_test_bench:* tests run:
go test -short -race -run=^$ -benchtime=.1s -cpu=4 $PKG
... on each discovered package with any tests. (The same set used for
the "go_test:*" tests)
That set was 168 packages:
$ go tool dist test -list | grep go_test: | wc -l
168
But only 76 of those have a "func Benchmark", and running each
"go_test_bench:" test and compiling it in race mode, just to do
nothing took 1-2 seconds each.
So stop doing that and filter out the useless packages earlier. Now:
$ go tool dist test -list -race | grep go_test_bench: | wc -l
76
Should save 90-180 seconds. (or maybe 45 seconds for trybots, since
they're sharded)
Updates #17104
Change-Id: I08ccb072a0dc0454ea425540ee8e74b59f83b773
Reviewed-on: https://go-review.googlesource.com/29153
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
net/http: clarify Request.ContentLength behavior on the client.
While you could argue the previous wording technically said that -1 is
an acceptable way to indicate "unknown" on the client, it could be read
as ambiguous. Now it's clear that both 0 and -1 mean unknown.
David Crawshaw [Tue, 13 Sep 2016 23:04:25 +0000 (19:04 -0400)]
cmd/internal/obj: regenerate stringer values
Created by running 'go generate'.
That made debugging fun today.
Change-Id: I9ffe00877851f2b198275220ad6058b9005daa72
Reviewed-on: https://go-review.googlesource.com/29117 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
David Crawshaw [Tue, 6 Sep 2016 11:46:59 +0000 (07:46 -0400)]
cmd/link: address comments from CL 28540
Change-Id: I11899096c71ee0e24e902c87914601fcd7ffd7a9
Reviewed-on: https://go-review.googlesource.com/28967 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Hiroshi Ioka [Tue, 2 Aug 2016 05:41:53 +0000 (14:41 +0900)]
encoding/asn1: reduce allocations in Marshal
Current code uses trees of bytes.Buffer as data representation.
Each bytes.Buffer takes 4k bytes at least, so it's waste of memory.
The change introduces trees of lazy-encoder as
alternative one which reduce allocations.
name old time/op new time/op delta
Marshal-4 64.7µs ± 2% 42.0µs ± 1% -35.07% (p=0.000 n=9+10)
name old alloc/op new alloc/op delta
Marshal-4 35.1kB ± 0% 7.6kB ± 0% -78.27% (p=0.000 n=10+10)
name old allocs/op new allocs/op delta
Marshal-4 503 ± 0% 293 ± 0% -41.75% (p=0.000 n=10+10)
Change-Id: I32b96c20b8df00414b282d69743d71a598a11336
Reviewed-on: https://go-review.googlesource.com/27030 Reviewed-by: Adam Langley <agl@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Adam Langley <agl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
net/http: make Transport support international domain names
This CL makes code like this work:
res, err := http.Get("https://фу.бар/баз")
So far, IDNA support is limited to the http1 and http2 Transports.
The http package is currently responsible for converting domain names
into Punycode before calling the net layer. The http package also has
to Punycode-ify the hostname for the Host & :authority headers for
HTTP/1 and HTTP/2, respectively.
No automatic translation from Punycode back to Unicode is performed,
per Go's historical behavior. Docs are updated where relevant. No
changes needed to the Server package. Things are already in ASCII
at that point.
No changes to the net package, at least yet.
Updates x/net/http2 to git rev 57c7820 for https://golang.org/cl/29071
Updates x/net/http2 (and x/net/lex/httplex) to git rev 749a502 for:
http2: don't sniff first Request.Body byte in Transport until we have a conn
https://golang.org/cl/29074
Fixes #17071
http2: add Transport support for unicode domain names
https://golang.org/cl/29071
Updates #13835
http2: don't send bogus :path pseudo headers if Request.URL.Opaque is set
https://golang.org/cl/27632
+
http2: fix bug where '*' as a valid :path value in Transport
https://golang.org/cl/29070
Updates #16847
http2: fix all vet warnings
https://golang.org/cl/28344
Updates #16228
Updates #11041
Also uses the new -underscore flag to x/tools/cmd/bundle from
https://golang.org/cl/29086
Consider repeatedly adding many items to a map
and then deleting them all, as in #16070. The map
itself doesn't need to grow above the high water
mark of number of items. However, due to random
collisions, the map can accumulate overflow
buckets.
Prior to this CL, those overflow buckets were
never removed, which led to a slow memory leak.
The problem with removing overflow buckets is
iterators. The obvious approach is to repack
keys and values and eliminate unused overflow
buckets. However, keys, values, and overflow
buckets cannot be manipulated without disrupting
iterators.
This CL takes a different approach, which is to
reuse the existing map growth mechanism,
which is well established, well tested, and
safe in the presence of iterators.
When a map has accumulated enough overflow buckets
we trigger map growth, but grow into a map of the
same size as before. The old overflow buckets will
be left behind for garbage collection.
For the code in #16070, instead of climbing
(very slowly) forever, memory usage now cycles
between 264mb and 483mb every 15 minutes or so.
To avoid increasing the size of maps,
the overflow bucket counter is only 16 bits.
For large maps, the counter is incremented
stochastically.
Robert Griesemer [Tue, 13 Sep 2016 00:30:35 +0000 (17:30 -0700)]
cmd/compile: reduce allocs some more
Also: update fmt_test.go.
Together with the previous commits, we are now at or below c85b77c
levels in terms of allocation for the benchmark described in #16897
(old = c85b77c, new = this commit):
Paul Borman [Tue, 12 Jul 2016 15:54:09 +0000 (08:54 -0700)]
text/template: improve lexer performance in finding left delimiters.
The existing implementation calls l.next for each run up to the next
instance of the left delimiter ({{). For ascii text, this is multiple
function calls per byte. Change to use strings.Index to find the left
delimiter. The performace improvement ranges from 1:1 (no text outside
of {{}}'s) to multiple times faster (9:1 was seen on 8K of text with no
{{ }}'s).
Change-Id: I2f82bea63b78b6714f09a725f7b2bbb00a3448a3
Reviewed-on: https://go-review.googlesource.com/24863 Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Rob Pike <r@golang.org>
Robert Griesemer [Mon, 12 Sep 2016 20:44:43 +0000 (13:44 -0700)]
cmd/compile: reduce allocs to c85b77c (pre-fmt.go change) levels
Linker and reflect info generation (reflect.go) relies on formatting
of types (tconv). The fmt.Format based approach introduces extra
allocations, which matter in those cases. Resurrected sconv and tconv
code from commit c85b77c (fmt.go only); and adjusted it slightly.
The formatter-based approach is still used throughout the rest of the
compiler, but reflect.go now uses the tconv method that simply returns
the desired string.
(The timing data below may not be accurate; I've included it only for
comparison with the numbers in issue #16897).
The code for sconv/tconv in fmt.go now closely match the code from c85b77c
again; except that the functions are now methods. Removing the use of
the bytes.Buffer in tconv and special-caseing interface{} has helped a
small amount as well:
Keith Randall [Fri, 9 Sep 2016 20:11:07 +0000 (13:11 -0700)]
cmd/compile: get rid of BlockCall
No need for it, we can treat calls as (mostly) normal values
that take a memory and return a memory.
Lowers the number of basic blocks needed to represent a function.
"go test -c net/http" uses 27% fewer basic blocks.
Probably doesn't affect generated code much, but should help
various passes whose running time and/or space depends on
the number of basic blocks.
Keith Randall [Mon, 12 Sep 2016 22:19:36 +0000 (15:19 -0700)]
runtime: make gdb test resilient to line numbering
Don't break on line number, instead break on the actual call.
This makes the test more robust to line numbering changes in the backend.
A CL (28950) changed the generated code line numbering slightly. A MOVW
$0, R0 instruction at the start of the function changed to line
10 (because several constant zero instructions got CSEd, and one gets
picked arbitrarily). That's too fragile for a test.
And v3 will do the right clobbering of flags. But in the rare
cases where we issue a tuple-with-flag op and the flag portion
is dead, then we never issue a Select1. But v1 still clobbers flags,
so we need to respect that.
Quentin Smith [Wed, 7 Sep 2016 22:07:45 +0000 (18:07 -0400)]
time: improve Truncate and Round documentation
Truncate and Round operate on absolute time, which means that
Truncate(Hour) may return a time with non-zero Minute(). Document that
more clearly, and remove the misleading example which suggests it is
safe.
Updates #16647
Change-Id: I930584ca030dd12849195d45e49ed2fb74e0c9ac
Reviewed-on: https://go-review.googlesource.com/28730 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Matthew Dempsky [Mon, 12 Sep 2016 20:39:54 +0000 (13:39 -0700)]
cmd/compile: remove incannedimport
This used to be used to give special semantics to the builtin
definitions of package runtime and unsafe, but none of those are
relevant anymore:
- The builtin runtime and unsafe packages do not risk triggering false
import cycles since they no longer contain `import "runtime"`.
- bimport.go never creates ODCLTYPE, so no need to special case them.
- "incannedimport != 0" is only true when "importpkg != nil" anyway,
so "incannedimport == 0 && importpkg == nil" is equivalent to just
"importpkg == nil".
Matthew Dempsky [Mon, 12 Sep 2016 20:27:36 +0000 (13:27 -0700)]
cmd/compile: remove Pointer from builtin/unsafe.go
We already explicitly construct the "unsafe.Pointer" type in typeinit
because we need it for Types[TUNSAFEPTR]. No point in also having it
in builtin/unsafe.go if it just means (*importer).importtype needs to
fix it.
Robert Griesemer [Sat, 10 Sep 2016 04:08:46 +0000 (21:08 -0700)]
cmd/compile: rewrite %1v and %2v formats to %S and %L (short and long)
- also consistently use %v instead of %s when we have a (gc) Formatter
- rewrite done automatically using Formats test in -u (update) mode
- manual update of format strings that were not single string constants
- updated fmt.go, fmt_test.go accordingly
- fmt_test: permit "%T" always
Change-Id: I8f0704286aba5704600ad0c4a4484005b79b905d
Reviewed-on: https://go-review.googlesource.com/28954 Reviewed-by: Matthew Dempsky <mdempsky@google.com>