Todd Neal [Mon, 14 Mar 2016 04:04:31 +0000 (23:04 -0500)]
cmd/compile: change the type of ssa Warnl line number
Line numbers are always int32, so the Warnl function should take the
line number as an int32 as well. This matches gc.Warnl and removes
a cast every place it's used.
The only remaining place that generated ADATA
Prog was the assembler. Stop, and delete some
now-dead code.
Passes toolstash -cmp.
Change-Id: I26578ff1b4868e98562b44f69d909c083e96f8d5
Reviewed-on: https://go-review.googlesource.com/20646 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
Instead of generating ADATA instructions for
static data, write that static data directly
into the linker sym.
This is considerably more efficient.
The assembler still generates
ADATA instructions, so the ADATA machinery
cannot be dismantled yet. (Future work.)
Skipping ADATA has a significant impact
compiling the unicode package, which has lots
of static data.
name old time/op new time/op delta
Unicode 227ms ±10% 192ms ± 4% -15.61% (p=0.000 n=29+30)
name old alloc/op new alloc/op delta
Unicode 51.0MB ± 0% 45.8MB ± 0% -10.29% (p=0.000 n=30+30)
name old allocs/op new allocs/op delta
Unicode 610k ± 0% 578k ± 0% -5.29% (p=0.000 n=30+30)
This does not pass toolstash -cmp, because
this changes the order in which some relocations
get added, and thus it changes the output from
the compiler. It is not worth the execution time
to sort the relocs in the normal case.
However, compiling with -S -v generates identical
output if (1) you suppress printing of ADATA progs
in flushplist and (2) you suppress printing of
cpu timing. It is reasonable to suppress printing
the ADATA progs, since the data itself is dumped
later. I am therefore fairly confident that all
changes are superficial and non-functional.
Fixes #14786, although there's more to do
in general.
Change-Id: I8dfabe7b423b31a30e516cfdf005b62a2e9ccd82
Reviewed-on: https://go-review.googlesource.com/20645 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
Dominik Honnef [Mon, 14 Mar 2016 00:59:22 +0000 (01:59 +0100)]
reflect: use SelectDir instead of uintptr in runtimeSelect
And fix the wrong comment.
Initially found this because the comment was wrong about the possible
values. Then noticed that there doesn't seem to be any reason to use
uintptr over SelectDir.
Martin Möhrmann [Sun, 13 Mar 2016 17:58:17 +0000 (18:58 +0100)]
runtime: speed up growslice by avoiding divisions
Only compute the number of maximum allowed elements per slice once.
Special case newcap computation for slices with byte sized elements.
name old time/op new time/op delta
GrowSliceBytes-2 61.1ns ± 1% 43.4ns ± 1% -29.00% (p=0.000 n=20+20)
GrowSliceInts-2 85.9ns ± 1% 75.7ns ± 1% -11.80% (p=0.000 n=20+20)
Change-Id: I5d9c0d5987cdd108ac29dc32e31912dcefa2324d
Reviewed-on: https://go-review.googlesource.com/20653 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Brad Fitzpatrick [Sun, 13 Mar 2016 19:40:09 +0000 (12:40 -0700)]
os/user: fix formatting of error group lookup message
It was failing like "unknown groupid ᎈ|" instead of "unknown groupid
5000" due to the conversion from int to string.
Updates #14806
Change-Id: I83e4b478ff628ad4053573a9f32b3fadce22e847
Reviewed-on: https://go-review.googlesource.com/20642 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
cmd/internal/obj: sort relocs by off when printing
This makes the output of compiling with -S more
stable in the face of unimportant variation in the
order in which relocs are generated.
It is also more pleasant to read the relocs when
they are sorted.
Also, do some minor cleanup.
For #14786
Change-Id: Id92020b13fd21777dfb5b29c2722c3b2eb27001b
Reviewed-on: https://go-review.googlesource.com/20641 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Matthew Dempsky [Fri, 11 Mar 2016 00:15:44 +0000 (16:15 -0800)]
cmd/compile: rework how fieldtrack is implemented
Shrinks gc.Type and gc.Func slightly.
Passes "GOEXPERIMENT=fieldtrack ./all.bash" and "go test -a
-toolexec='toolstash -cmp' -ldflags=-k=rsc.io/tmp/fieldtrack.tracked
rsc.io/tmp/fieldtrack".
Todd Neal [Sat, 12 Mar 2016 01:36:54 +0000 (19:36 -0600)]
cmd/compile: const folding for float32/64
Split the auxFloat type into 32/64 bit versions and perform checking for
exactly representable float32 values. Perform const folding on
float32/64. Comment out some const negation rules that the frontend
already performs.
Alexandru Moșoi [Mon, 7 Mar 2016 17:36:16 +0000 (18:36 +0100)]
cmd/compile/internal/ssa: generalize prove to all booleans
* Refacts a bit saving and restoring parents restrictions
* Shaves ~100k from pkg/tools/linux_amd64,
but most of the savings come from the rewrite rules.
* Improves on the following artificial test case:
func f1(a4 bool, a6 bool) bool {
return a6 || (a6 || (a6 || a4)) || (a6 || (a4 || a6 || (false || a6)))
}
Change-Id: I714000f75a37a3a6617c6e6834c75bd23674215f
Reviewed-on: https://go-review.googlesource.com/20306 Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Alexandru Moșoi <alexandru@mosoi.ro>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Emmanuel Odeke [Sat, 27 Feb 2016 10:14:06 +0000 (03:14 -0700)]
net/http: make ParseMultipartForm also populate Request.PostForm
Ensures that after request.ParseMultipartForm has been invoked,
Request.PostForm and Request.Form are both populated with the
same formValues read in, instead of only populating Request.Form.
Alex Brainman [Fri, 11 Mar 2016 01:19:08 +0000 (12:19 +1100)]
cmd/link: rewrite pe symbol table generating code
Every go executable has COFF symbol table appended at the end. The table is
used by nm and addr2line and contains all symbols present in the executable.
The table is quite large. For example, my go.exe has 11736 records.
To generate symbol table:
1) we walk "all symbols" list to count symbols we want for the table;
2) we allocate large global array of COFFSym structs (32 bytes each)
to fit our symbols;
3) we walk "all symbols" list again to fill our array with contents;
4) we iterate over our global array to write all records to the file.
This CL changes all these steps with single step:
- walk "all symbols" list and write each COFF symbol table record to
the file as we go.
I hope new version is faster and uses less garbage, but I don't know
how to benchmark this.
Change-Id: Ie4870583250131ea4428e0e83a0696c9df1794e0
Reviewed-on: https://go-review.googlesource.com/20580 Reviewed-by: David Crawshaw <crawshaw@golang.org>
Run-TryBot: David Crawshaw <crawshaw@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
Keith Randall [Sat, 12 Mar 2016 01:39:00 +0000 (17:39 -0800)]
cmd/compile: strength reduce *24
We use *24 a lot for pointer arithmetic when accessing slices
of slices ([][]T). Rewrite to use an LEA and a shift.
The shift will likely be free, as it often gets folded into
an indexed load/store.
Robert Griesemer [Sat, 12 Mar 2016 01:12:31 +0000 (17:12 -0800)]
cmd/compile: remove structpkg global variable
The structpkg global variable was only used to verify internal
consistency when declaring methods during import. Track the
value in the parser and binary importer directly and pass it
to the relevant function as an argument.
David Crawshaw [Fri, 11 Mar 2016 22:49:07 +0000 (17:49 -0500)]
cmd/compile: compute number of arguments correctly
The outCount value includes a flag bit for dotdotdot.
If we have this count incorrect, then the offset for the
methodset *rtype are in the wrong place.
Fixes #14783
Change-Id: If5acb16af08d4ffe36c8c9ee389c32f2712ce757
Reviewed-on: https://go-review.googlesource.com/20566 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Tom Bergan [Thu, 18 Feb 2016 02:20:24 +0000 (18:20 -0800)]
crypto/tls: implement dynamic record sizing
Currently, if a client of crypto/tls (e.g., net/http, http2) calls
tls.Conn.Write with a 33KB buffer, that ends up writing three TLS
records: 16KB, 16KB, and 1KB. Slow clients (such as 2G phones) must
download the first 16KB record before they can decrypt the first byte.
To improve latency, it's better to send smaller TLS records. However,
sending smaller records adds overhead (more overhead bytes and more
crypto calls), which slightly hurts throughput.
A simple heuristic, implemented in this change, is to send small
records for new connections, then boost to large records after the
first 1MB has been written on the connection.
Fixes #14376
Change-Id: Ice0f6279325be6775aa55351809f88e07dd700cd
Reviewed-on: https://go-review.googlesource.com/19591
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Tom Bergan <tombergan@google.com> Reviewed-by: Adam Langley <agl@golang.org>
Ian Lance Taylor [Fri, 11 Mar 2016 21:04:07 +0000 (13:04 -0800)]
cmd/compile: don't copy all type nodes for builtin functions
Only copy the ones that actually change. Also combine deep and substAny
functions into one. The Type.Copyany field is now unused, so remove it.
Passes toolstash -cmp.
Change-Id: Id28a9bf144ecf3e522aad00496f8a21ae2b74680
Reviewed-on: https://go-review.googlesource.com/20600 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Adam Langley [Thu, 10 Mar 2016 22:52:01 +0000 (14:52 -0800)]
crypto/tls: better error for oversized handshake messages.
This change improves the error message when encountering a TLS handshake
message that is larger than our limit (64KB). Previously the error was
just “local error: internal error”.
Robert Griesemer [Fri, 11 Mar 2016 22:28:16 +0000 (14:28 -0800)]
cmd/compile: move lexer into separate file (cleanup)
This is really moving all the non-lexer pieces out of lex.go
into main.go. It's always been confusing that the top-most
compiler entry point (Main) is in the same file with the
lexer. Both files remain of substantial size (> 1000 lines),
which justifies this even more.
No other changes.
Change-Id: I03895589d5e3cc2340580350bbc1420539893dfc
Reviewed-on: https://go-review.googlesource.com/20601
Run-TryBot: Robert Griesemer <gri@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
David Crawshaw [Thu, 10 Mar 2016 21:15:26 +0000 (16:15 -0500)]
cmd/compile: track reflect.Type.Method in deadcode
In addition to reflect.Value.Call, exported methods can be invoked
by the Func value in the reflect.Method struct. This CL has the
compiler track what functions get access to a legitimate reflect.Method
struct by looking for interface calls to either of:
This is a little overly conservative. If a user implements a type
with one of these methods without using the underlying calls on
reflect.Type, the linker will assume the worst and include all
exported methods. But it's cheap.
No change to any of the binary sizes reported in cl/20483.
For #14740
Change-Id: Ie17786395d0453ce0384d8b240ecb043b7726137
Reviewed-on: https://go-review.googlesource.com/20489 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Klaus Post [Tue, 8 Mar 2016 14:54:50 +0000 (15:54 +0100)]
compress/flate: optimize huffman bit encoder
Part 1 of optimizing the deflater. This optimizes the bitwriter by:
* Removing allocations.
* Storing compound values for bit codes instead of 2 separate tables.
* Accumulate 48 bits between writes instead of 24.
* Inline bit flushing.
This also contains code that will be used in later CL's
(writeBlockDynamic, writeBlockHuff).
Tests for Huffman bit writer encoding regressions has been added.
Klaus Post [Fri, 11 Mar 2016 11:23:11 +0000 (12:23 +0100)]
compress/flate: test if results are deterministic
This will test if deflate output is deterministic between two runs
of the deflater, when write sizes differ.
The deflater makes no official promises that results are
deterministic between runs, but this is a good test to determine
unintentional randomness.
Note that this does not guarantee that results are deterministic
across platforms nor that results will be deterministic between
Go versions. This is also not guarantees we should imply.
Matthew Dempsky [Fri, 11 Mar 2016 03:05:45 +0000 (19:05 -0800)]
cmd/compile: simplify transformclosure
Use idiomatic slicing operations instead of incrementally building a
linked list.
Passes toolstash -cmp.
Change-Id: Idb0e40c7b4d7d1110d23828afa8ae1d157ba905f
Reviewed-on: https://go-review.googlesource.com/20556 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Matthew Dempsky [Fri, 11 Mar 2016 02:23:03 +0000 (18:23 -0800)]
cmd/compile: cleanup unsafenmagic
In particular, make Alignof work more like Sizeof. Other idiomatic
cleanups while here.
Passes toolstash -cmp.
Change-Id: I4def20894f3d95e49ab6a50ddba189be36fdd258
Reviewed-on: https://go-review.googlesource.com/20555
Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
Matthew Dempsky [Fri, 11 Mar 2016 04:07:00 +0000 (20:07 -0800)]
cmd/compile: eliminate uses of Type.Down in alg.go
This could be done by threading the Iter value down through memrun and
ispaddedfield, but that ends up a bit clunky. This way is also closer
to how we'll want the code to look once fields are kept in slices.
Keith Randall [Thu, 10 Mar 2016 21:05:56 +0000 (13:05 -0800)]
cmd/compile: regalloc of two address instructions
x86 has a lot of instructions that require the output to be in the same
register as one of the inputs. When allocating the output register,
allocate the same register as the input if it is available.
Improves the performance of golang.org/x/crypto/sha3 by
10% (from 6% slower than 1.6 to 4% faster).
Robert Griesemer [Thu, 10 Mar 2016 23:07:08 +0000 (15:07 -0800)]
cmd/compile: call missing popdcl in various genxxx functions
Not calling popdcl doesn't have an impact on generated code but
the result is a growing (rather than empty) stack of symbols,
possibly causing more data to remain alive than necessary.
Also: minor cleanups.
Change-Id: Ic4fdbcd8843637d69ab1aa15e896a7e6339bc990
Reviewed-on: https://go-review.googlesource.com/20554 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Robert Griesemer <gri@golang.org>
Keith Randall [Wed, 9 Mar 2016 04:09:48 +0000 (20:09 -0800)]
cmd/compile: don't use PPARAMOUT names for temps
The location of VARDEFs is incorrect for PPARAMOUT variables
which are also used as temporary locations. We put in VARDEFs
when setting the variable at return time, but when the location
is also used as a temporary the lifetime values are wrong.
Fix copyelim to update the names map properly. This is a
real name bug fix which, as a result, allows me to
write a reasonable test to trigger the PPARAMOUT bug.
This is kind of a band-aid fix for #14591. A more pricipled
fix (which allows values to be stored in the return variable
earlier than the return point) will be harder.
Adam Langley [Thu, 10 Mar 2016 22:25:50 +0000 (14:25 -0800)]
crypto/x509/pkix: make 'v1' the default CRL version.
PKIX versions are off-by-one, so v1 is actually a zero on the wire, v2
is a one, and so on.
The RFC says that the version in a CRL is optional, but doesn't say what
the default is. Since v2 is the only accepted version, I had made the
default v2. However, OpenSSL considers the default to be v1. Also, if
the default is v2 and the element is optional then we'll never actually
write v2 on the wire. That's contrary to the RFC which clearly assumes
that v2 will be expressed on the wire in some cases.
Therefore, this change aligns with OpenSSL and assumes that v1 is the
default CRL version.
Matthew Dempsky [Thu, 10 Mar 2016 22:35:39 +0000 (14:35 -0800)]
cmd/compile: rename ssa.Type's Elem method to ElemType
I would like to add a
func (t *Type) Elem() *Type
method to package gc, but that would collide with the existing
func (t *Type) Elem() ssa.Type
method needed to make *gc.Type implement ssa.Type. Because the latter
is much less widely used right now than the former will be, this CL
renames it to ElemType.
Longer term, hopefully gc and ssa will share a common Type interface,
and ElemType can go away.
Change-Id: I270008515dc4c01ef531cf715637a924659c4735
Reviewed-on: https://go-review.googlesource.com/20546
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
Keith Randall [Thu, 10 Mar 2016 03:27:57 +0000 (19:27 -0800)]
cmd/compile: fix defer/deferreturn
Make sure we do any just-before-return cleanup on all paths out of a
function, including when recovering. Each exit path should include
deferreturn (if there are any defers) and then the exit
code (e.g. copying heap-escaping return values back to the stack).
Introduce a Defer SSA block type which has two outgoing edges - one the
fallthrough edge (the defer was queued successfully) and one which
immediately returns (the defer had a successful recover() call and
normal execution should resume at the return point).
Fixes #14725
Change-Id: Iad035c9fd25ef8b7a74dafbd7461cf04833d981f
Reviewed-on: https://go-review.googlesource.com/20486 Reviewed-by: David Chase <drchase@google.com>
Matthew Dempsky [Thu, 10 Mar 2016 09:50:58 +0000 (01:50 -0800)]
cmd/compile: more use of IterXXX functions
This CL was mostly produced by a one-off automated rewrite tool
looking for statements like "for X := T.Type; X != nil; X = X.Down"
and a few minor variations.
Passes toolstash -cmp.
Change-Id: Ib22705e37d078ef97841ee2e08f60bdbcabb94ad
Reviewed-on: https://go-review.googlesource.com/20520
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
Lynn Boger [Tue, 16 Feb 2016 18:24:12 +0000 (12:24 -0600)]
math: improve sqrt for ppc64le,ppc64
The existing implementation uses code written in Go to
implement Sqrt; this adds the assembler to use the sqrt
instruction for Power and makes the necessary changes to
allow it to be inlined.
The following tests showed this relative improvement:
Dave Cheney [Sat, 5 Mar 2016 03:44:11 +0000 (14:44 +1100)]
cmd/compile/internal: peep.go cleanups
More cleanups after CL 20089
- copysub, take a bool rather than an int for the f (force) parameter.
- copysub returns a bool rather than an int.
- prevl, reg is now int16, which reduces type conversion in its callers.
- copy1, reduce the scope of t and p variables.
- small simplifications in copyau1, copyas, etc.
- {mips64,ppc64}/regzer returns a bool.
- apply CL 20181 to x86/peep.go which was missed in the last CL.
- various comment fixes.
Change-Id: Ib73ffb768c979ce86f1614e5366fd576dea50986
Reviewed-on: https://go-review.googlesource.com/20281 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Dave Cheney <dave@cheney.net>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Matthew Dempsky [Fri, 26 Feb 2016 04:29:09 +0000 (20:29 -0800)]
cmd/compile: support arbitrarily deep embedded fields
Fixes #13337.
Change-Id: Ie74d00390111796619150287d3f7a147750ab456
Reviewed-on: https://go-review.googlesource.com/19932 Reviewed-by: Ian Lance Taylor <iant@golang.org>
Matthew Dempsky [Thu, 10 Mar 2016 04:54:59 +0000 (20:54 -0800)]
cmd/compile: rename Recv->Recvs and Recv0->Recv
Change-Id: Ice3aa807169f4fec85745a3991b1084a9f85c1b5
Reviewed-on: https://go-review.googlesource.com/20499
Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
Matthew Dempsky [Thu, 10 Mar 2016 04:45:18 +0000 (20:45 -0800)]
cmd/compile: add Recv0 and Field helper methods for Type
Accessing the n'th field of a struct is fairly common, and in
particular accessing the 0'th field of the receiver parameter list is
very common. Add helper methods for both of these tasks and update
code to make use of them.
Change-Id: I81f551fecdca306b3800636caebcd0dc106f2ed7
Reviewed-on: https://go-review.googlesource.com/20498
Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Dave Cheney <dave@cheney.net>
Matthew Dempsky [Thu, 10 Mar 2016 03:32:10 +0000 (19:32 -0800)]
cmd/compile: replace more unnecessary **Type with *Type
Also, more lazy variable declarations, and make Dijkstra happy by
replacing "goto loop" with a for loop.
Change-Id: Idf2cd779a92eb3f33bd3394e12c9a0be72002ff4
Reviewed-on: https://go-review.googlesource.com/20496 Reviewed-by: Dave Cheney <dave@cheney.net> Reviewed-by: Ian Lance Taylor <iant@golang.org>
Matthew Dempsky [Wed, 9 Mar 2016 23:32:57 +0000 (15:32 -0800)]
cmd/compile: consolidate Type construction and copying code
This should is preparatory cleanup to make it easier to use separate
types to represent each kind of Go type, rather than a single omnibus
Type struct with heavily overloaded fields.
Also, add TODO comments marking assignments that change an existing
Type's kind, as they need to be removed before we can factor Type.
With this, the start and end of geneq and genhash
are parallel. This removes a few rare nilchecks
from generated hash functions, but nothing
to write home about.
David Crawshaw [Tue, 8 Mar 2016 04:45:04 +0000 (23:45 -0500)]
cmd/link: prune unused methods
Today the linker keeps all methods of reachable types. This is
necessary if a program uses reflect.Value.Call. But while use of
reflection is widespread in Go for encoders and decoders, using
it to call a method is rare.
This CL looks for the use of reflect.Value.Call in a program, and
if it is absent, adopts a (reasonably conservative) method pruning
strategy as part of dead code elimination. Any method that is
directly called is kept, and any method that matches a used
interface's method signature is kept.
Whether or not a method body is kept is determined by the relocation
from its receiver's *rtype to its *rtype. A small change in the
compiler marks these relocations as R_METHOD so they can be easily
collected and manipulated by the linker.
As a bonus, this technique removes the text segment of methods that
have been inlined. Looking at the output of building cmd/objdump with
-ldflags=-v=2 shows that inlined methods like
runtime.(*traceAllocBlockPtr).ptr are removed from the program.
Relatively little work is necessary to do this. Linking two
examples, jujud and cmd/objdump show no more than +2% link time.
Binaries that do not use reflect.Call.Value drop 4 - 20% in size:
The trivial Hello example program goes from 2MB to 1.68MB:
package main
import "fmt"
func main() {
fmt.Println("Hello, 世界")
}
Method pruning also helps when building small binaries with
"-ldflags=-s -w". The above program goes from 1.43MB to 1.2MB.
Unfortunately the linker can only tell if reflect.Value.Call has been
statically linked, not if it is dynamically used. And while use is
rare, it is linked into a very common standard library package,
text/template. The result is programs like cmd/go, which don't use
reflect.Value.Call, see limited benefit from this CL. If binary size
is important enough it may be possible to address this in future work.
Brad Fitzpatrick [Tue, 8 Mar 2016 23:16:16 +0000 (23:16 +0000)]
cmd/compile: shrink tables
Drops cmd/binary size from 14.41 MiB to 11.42 MiB.
Before:
text data bss dec hex filename 81212103521696 737960 12380866 bceac2 ../pkg/tool/linux_amd64/compile
bradfitz@dev-bradfitz-debian2:~/go/src$ ls -l ../pkg/tool/linux_amd64/compile
-rwxr-xr-x 1 bradfitz bradfitz 15111272 Mar 8 23:32 ../pkg/tool/linux_amd64/compile
a2afc0 51312 R html.statictmp_0085
6753f0 56592 T cmd/internal/obj/x86.doasm
625480 58080 T cmd/compile/internal/gc.typecheck1
f34c40 65688 D runtime.trace
be0a20 133552 D cmd/compile/internal/ppc64.varianttable
c013e0 265856 D cmd/compile/internal/arm.progtable
c42260 417280 D cmd/compile/internal/amd64.progtable
ca8060 417280 D cmd/compile/internal/x86.progtable
f44ce0 500640 D cmd/internal/obj/arm64.oprange
d0de60 534208 D cmd/compile/internal/ppc64.progtable
d90520 667520 D cmd/compile/internal/arm64.progtable
e334a0 790368 D cmd/compile/internal/mips64.progtable
a3e8c0 1579362 r runtime.pclntab
After:
text data bss dec hex filename 8128226 375954 246432 8750612 858614 ../pkg/tool/linux_amd64/compile
-rwxr-xr-x 1 bradfitz bradfitz 11971432 Mar 8 23:35 ../pkg/tool/linux_amd64/compile
6436d0 43936 T cmd/compile/internal/gc.walkexpr
c13ca0 45056 D cmd/compile/internal/ssa.opcodeTable
5d8ea0 50256 T cmd/compile/internal/gc.(*state).expr
818c50 50448 T cmd/compile/internal/ssa.rewriteValueAMD64_OpMove
a2d0e0 51312 R html.statictmp_0085
6753d0 56592 T cmd/internal/obj/x86.doasm
625460 58080 T cmd/compile/internal/gc.typecheck1
c38fe0 65688 D runtime.trace
a409e0 1578810 r runtime.pclntab
Martin Möhrmann [Sat, 5 Mar 2016 23:39:37 +0000 (00:39 +0100)]
fmt: refactor pointer formatting and improve tests
Uses a switch statement for direct format function selection
similar to other types verb handling in fmt.
Applies padding also to nil pointers formatted with %v.
Guards against "slice bounds out of range" panic in TestSprintf
when a pointer test results in a formatted string s
that is shorter than the index i the pointer should appear in.
Adds more and rearranges tests.
Fixes #14712
Fixes #14714
Change-Id: Iaf5ae37b7e6ba7d27d528d199f2b2eb9d5829b8c
Reviewed-on: https://go-review.googlesource.com/20371
Run-TryBot: Rob Pike <r@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rob Pike <r@golang.org>
Richard Miller [Wed, 9 Mar 2016 16:16:05 +0000 (16:16 +0000)]
runtime: Plan 9 - prevent preemption by GC while exiting
On Plan 9, there's no "kill all threads" system call, so exit is done
by sending a "go: exit" note to each OS process. If concurrent GC
occurs during this loop, deadlock sometimes results. Prevent this by
incrementing m.locks before sending notes.
Alexandru Moșoi [Thu, 3 Mar 2016 10:13:43 +0000 (11:13 +0100)]
cmd/compile/internal/ssa: lower builtins much later
* Move lowering into a separate pass.
* SliceLen/SliceCap is now available to various intermediate passes
which use useful for bounds checking.
* Add a second opt pass to handle the new opportunities
Decreases the code size of binaries in pkg/tool/linux_amd64
by ~45K.
Updates #14564 #14606
Change-Id: I5b2bd6202181c50623a3585fbf15c0d6db6d4685
Reviewed-on: https://go-review.googlesource.com/20172
Run-TryBot: Alexandru Moșoi <alexandru@mosoi.ro>
TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Chase <drchase@google.com>