On systems where the mmap succeeds
(e.g., sysctl -w vm.mmap_min_addr=0)
it changes the signal code delivered for a
nil fault from ``page not mapped'' to
``invalid permissions for page.''
TBR=r
CC=golang-dev
https://golang.org/cl/2294041
There are a variety of token pairs that if printed
without separating blank may combine into a different
token sequence. Most of these (except for INT + .)
don't happen at the moment due to the spacing
introduced between expression operands. However, this
will prevent errors should the expression spacing
change.
R=rsc
CC=golang-dev
https://golang.org/cl/2207044
Not all OS make that the default.
Can finally do this now that the syscall package
has the right definitions.
Fixes#679.
R=r
CC=golang-dev
https://golang.org/cl/2204048
THIS WILL BREAK THE BUILD.
The z files have socketpair code in them that was
written by hand; breaking the build with this is the first
step in getting rid of that hand-written code.
R=adg
TBR=adg
CC=golang-dev
https://golang.org/cl/2197050
work on FreeBSD even without /usr/src/sys.
work on systems where gcc -static is broken.
TBR so I can test my semi-automated z builder.
TBR=adg
CC=golang-dev
https://golang.org/cl/2215046
Replace Marshal with MarshalToMemory
(no one was using old Marshal anyway).
Swap arguments to Unmarshal.
Fixes#1133.
R=agl1
CC=golang-dev
https://golang.org/cl/2249045
This is a replacement for pending CL 2219042. It only contains
the raw suffixarray functionality with two methods:
- New create a new index from some data
- Lookup lookup occurences of a bytes slice in the data
Any other functionality (dealing with multiple data sets and
the corresponding position lists) is generic and doesn't have
to be part of this package.
Known performance bug: This implementation works fine for data sets
up to several megabytes as long as it doesn't contain very long
contiguous sequences of equal bytes. For instance, index creation for
all .go files under GOROOT (250KLOCs, approx. 9MB) takes ~50s on
2.66 GHz Intel Xeon as long as test/fixedbugs/257.go is excluded.
With that file, index creation times takes several days. 257.go contains
a string of 1M smiley faces.
There are more sophisticated suffixarray creation algorithms which
can handle very long common prefixes. The implementation can be
updated w/o the need to change the interface.
R=rsc, r, PeterGo
CC=golang-dev
https://golang.org/cl/2265041
Fixes#1124.
Implementation is suggested by Skip.
Test is suggested by PeterGo.
R=r, PeterGo, rsc
CC=golang-dev, skip.tavakkolian
https://golang.org/cl/2256041
* Add documentation about array arguments. Fixes issue 1125.
* Do not interpret x, y := z, w as special errno form. Fixes issue 952.
* Fix nested Go calls (brainman). Fixes issue 907.
R=r
CC=golang-dev
https://golang.org/cl/2214044
Regenerate zsyscall_linux_*.go files with recent changes to
mksyscall.sh.
Add socketpair to syscall_linux_amd64.go; for some reason it
was in the generated file but not in the source file.
R=rsc, r2
CC=golang-dev
https://golang.org/cl/2190044
The key/value format of X.500 names means that it's possible to encode
a name with multiple values for, say, organisation. RFC5280
doesn't seem to consider this, but there are Verisign root
certificates which do this and, in order to find the correct
root certificate in some cases, we need to handle it.
Also, CA certificates should set the CA flag and we now check
this. After looking at the other X.509 extensions it appears
that they are universally ignored/bit rotted away so we ignore
them.
R=rsc
CC=golang-dev
https://golang.org/cl/2249042
asn1: add support for T61String because this is the string type which
several www.google.com certificates are now using for fields like
CommonName
tls: force a handshake in Dial so that certificates are ready
afterwards.
Fixes#1114.
R=rsc
CC=golang-dev
https://golang.org/cl/2216043
The decoder was crashing when handling an rpc that expected
a struct but was delivered something else. This diagnoses the
problem. The other direction (expecting non-struct but getting
one) was already handled.
R=rsc
CC=golang-dev
https://golang.org/cl/2246041
* SHOW DB responds with a
"110 n databases present - text follows" -- parse it.
* Doing a Define() on a non-existing word gives error
"invalid definition count: no", when we really
want "552 no match".
R=rsc
CC=golang-dev
https://golang.org/cl/2211041
The panic NaN was a translation error.
The earliest version said panic "return sys.NaN()",
and when sys.NaN came along, it changed
to "panic sys.NaN()" instead of "return sys.NaN()".
R=r
CC=golang-dev
https://golang.org/cl/2106049
g is not in r15 anymore.
now it's in a per-thread memory segment,
which is valid even inside a signal handler,
so we can just refer to g directly.
Fixes#1082.
R=r
CC=golang-dev
https://golang.org/cl/2149045
1) hack regalloc to leave R9 (m) and R10 (g) alone.
the real fix is tricker, but this gets us running
2) fix up the few places in the package sources that
the shortage of registers affects, by simplifying
some expressions.
all of this should be reverted when the right fix is in.
Fixes#1084.
R=rsc
CC=golang-dev
https://golang.org/cl/2132046
Add windows NOTEST list to pkg make file.
5a make file. the change removes a space
character that was included when appending
an extension to TARG.
R=brainman, rsc
CC=golang-dev
https://golang.org/cl/2140046
Need to correct for deferproc's extra 2 words of stack or in some
cases (such as memory profiling) traceback can cause a crash.
Also bulletproof the closure test.
R=rsc
CC=golang-dev
https://golang.org/cl/2138047
Old code was using recursion to traverse object graph.
New code uses an explicit stack, cutting the per-pointer
footprint to two words during the recursion and avoiding
the standard allocator and stack splitting code.
in test/garbage:
Reduces parser runtime by 2-3%
Reduces Peano runtime by 40%
Increases tree runtime by 4-5%
R=r
CC=golang-dev
https://golang.org/cl/2150042
Also add exporter.Drain() to wait for completion.
This makes it possible for an Exporter to fire off a message
and wait (by calling Drain) for the message to be received,
even if a client has yet to call to retrieve it.
Once this design is settled, I'll do the same for import send.
Testing strategies welcome. I have some working stand-alone
tests.
R=rsc
CC=golang-dev
https://golang.org/cl/2137041
This is a common task, so it makes sense to have a helper to do it.
(App Engine doesn't like "Transfer-Encoding: chunked" for POST
bodies, which is the default for regular Post.)
R=rsc
CC=golang-dev
https://golang.org/cl/2113041
It's unlikely to affect any extant code, but I wanted to make this API change
before digging in for a rewrite.
R=rsc
CC=golang-dev
https://golang.org/cl/2112041
Two tests start a goroutine which runs exportSend, and then
the tests run importReceive. exportSend creates an export
channel. importReceive asks to receive values on that
channel. Because exportSend runs in a separate goroutine,
it's possible for the export client to receive the request for
values on the channel, from importReceive, before the
goroutine actually creates the export channel. That causes an
error: "export: no such channel: exportedSend". This patch
avoids the race by creating the export channel before starting
the goroutine.
There does not seem to be a similar race condition in the
tests which send data in the other direction.
R=r
CC=golang-dev
https://golang.org/cl/2026045
- refine/define Scope, Object, and Type structures
(note: scope.go has the addition of types, the rest is only re-organized
for better readability)
- implemented top-level of type checker:
resolve global type declarations (deal with double decls, cycles, etc.)
- temporary hooks for checking of const/var declarations, function/method bodies
- test harness for fine-grained testing (exact error locations)
with initial set of tests
This is a subset of the code for easier review.
R=rsc
CC=golang-dev
https://golang.org/cl/1967049
Based on the observation that a great number of the types that
are copied or compared in interfaces, maps, and channels are
word-sized, this uses specialized copy and equality functions
for them that use a word instead of 4 or 8 bytes. Seems to yield
0-6% improvements in performance in the benchmarks I've run.
For example, with the regexp benchmarks:
Before:
regexp.BenchmarkLiteral 500000 3.26 µs/op
regexp.BenchmarkNotLiteral 100000 13.67 µs/op
regexp.BenchmarkMatchClass 100000 18.72 µs/op
regexp.BenchmarkMatchClass_InRange 100000 20.04 µs/op
regexp.BenchmarkReplaceAll 100000 27.85 µs/op
After:
regexp.BenchmarkLiteral 500000 3.11 µs/op
regexp.BenchmarkNotLiteral 200000 13.29 µs/op
regexp.BenchmarkMatchClass 100000 17.65 µs/op
regexp.BenchmarkMatchClass_InRange 100000 18.49 µs/op
regexp.BenchmarkReplaceAll 100000 26.34 µs/op
R=rsc
CC=golang-dev
https://golang.org/cl/1967047
Commands written in Go depend on Go packages, so they
cannot be built by src/cmd/make.bash. They have been
built by src/make.bash after all the packages are done, but
we want to be able to use cgo (written in Go) during the build
of package net. To make this possible, build the commands
from src/pkg/Makefile instead of src/make.bash, so that they
are included in the package dependency analysis.
R=r
CC=golang-dev
https://golang.org/cl/1972046
Due to header key normalization/typo, the server never responds with
the protocol header in place. This breaks all (draft76) applications
that are using the protocol-header.
R=ukai, rsc
CC=golang-dev
https://golang.org/cl/1969046
Despite the name, URL escaping is for a small subpiece of the URL only.
This particular URL is being emitted in an <a href=""> tag and in that
context it should be HTML escaped, not URL escaped.
In addition to fixing a bug, this change cuts a dependency chain
from go/doc to net, clearing the way for use of cgo
(which imports go/doc) during the compilation of package net.
R=gri
CC=golang-dev
https://golang.org/cl/1960050
The runtime only passes 32 bits of file offset,
but the kernel wants 64 bits, so have to add
zeros explicitly in a copy of the arguments.
R=adg, Martin Neubauer
CC=golang-dev
https://golang.org/cl/1933044
Augmented ASTs may contain cycles. Keep
track of already printed objects and refer
to them with a line number instead of
printing them again.
R=rsc
CC=golang-dev
https://golang.org/cl/1998042
go/ast: implement Fprint and print functions to
print AST nodes
gofmt: print AST nodes by setting -ast flag
R=rsc, r
CC=golang-dev
https://golang.org/cl/1981044
Function to create a GoString with a known length so it can contain NUL
bytes anywhere in the string. Some C libraries have strings like this.
R=rsc
CC=golang-dev
https://golang.org/cl/2007042
(Argument: For any *PtrValue p, it should
always be possible to do: p.PointTo(p.Elem()),
even if p.Elem() is nil.)
Fixes#1028.
R=rsc
CC=golang-dev, r
https://golang.org/cl/1938044
tabwriter: Introduce a new flag StripEscape to control
if tabwriter.Escape chars should be stripped or passed
through unchanged.
go/printer: Don't modify tabwriter.Escape'd text. This
involved a new implementation of the internal trimmer
object.
Does not affect formatting of any existing code under
$GOROOT/src and $GOROOT/misc.
Fixes#1030.
R=rsc
CC=golang-dev
https://golang.org/cl/1943045
the solution must work around a weakness in the reflection library:
there is no way to do type-safe conversions under reflection.
R=rsc
CC=golang-dev
https://golang.org/cl/2000041
This changeset implements client certificate support in crypto/tls
for both handshake_server.go and handshake_client.go
The updated server implementation sends an empty CertificateAuthorities
field in the CertificateRequest, thus allowing clients to send any
certificates they wish. Likewise, the client code will only respond
with its certificate when the server requests a certificate with this
field empty.
R=agl, rsc, agl1
CC=golang-dev
https://golang.org/cl/1975042