minor manual format corrections

R=rsc
https://golang.org/cl/172042

remove uses of string concatenation from src and misc directory

R=rsc
https://golang.org/cl/172041

hgtags: add release tag, again.

R=r
https://golang.org/cl/170049

hgtags: looks like they have to be full hashes

R=r
https://golang.org/cl/170048

hgtags: add release pointing at 2009-12-09's checkin.

R=r
https://golang.org/cl/170047

hgtags: tag release.2009-12-07 (where gccgo is)
   and release.2009-12-09 (where we are)

shorten tags because it is too hard to look up the
full size hash and overkill anyway.

R=r
https://golang.org/cl/171047

doc/contribute: try to make it clearer that you send a review with hg mail, not hg submit.

R=r
https://golang.org/cl/171046

added benchmarks to rand_test.go;
removed superfluous field name in lockedSource.

R=r, rsc
https://golang.org/cl/170043

syscalls can return negative i/o counts. fix bugs in ReadAt and WriteAt not to include
negative counts in return values.

R=rsc
CC=golang-dev
https://golang.org/cl/170044

doc: split contribute.html into code.html and contribute.html

R=r
https://golang.org/cl/170042

Make the operations on the global rng thread safe.

R=r, rsc
CC=golang-dev
https://golang.org/cl/168041

Continuation of issue 221 fix. When 8g or 6g or 5g are called with a
UTF-8 string, Yconv() converts it into an octal sequence. If the
string converted to more than 30 bytes, the str buffer would
overflow. For example, 4 Greek runes became 32 bytes, 3 Hiragana
runes became 36 bytes, and 2 Gothic runes became 32 bytes. In
8l, 6l and 5l the function is Sconv(). For some reason, only 5l uses
the constant STRINGSZ (defined as 200) for the buffer size.

R=rsc
https://golang.org/cl/168045

json package: Fixed handling of nil values

Fixes #400.

R=golang-dev, rsc
https://golang.org/cl/167058

Added my name to the AUTHORS and CONTRIBUTORS list

R=rsc
https://golang.org/cl/165101

Added XTEA block cipher package to src/pkg/crypto

This is an adaption of the code from http://en.wikipedia.org/wiki/XTEA. The package also implements the block.Cipher
interface so that it can be used with the various block modes.

R=rsc
https://golang.org/cl/157152

runtime: start new darwin/amd64 threads on correct stack,
    then enable stack check.

R=r
https://golang.org/cl/165100

A+C: two more names
   Kei Son has completed the CLA.
   Yves Junqueira is a Google employee.

R=r
https://golang.org/cl/167057

bufio: use copy - significant speedup for writers

R=r
https://golang.org/cl/167047

Fix stack on FreeBSD / add stack check across the board

FreeBSD was passing stk as the new thread's stack base, while
stk is the top of the stack in go. The added check should cause
a trap if this ever comes up in any new ports, or regresses
in current ones.

R=rsc
CC=golang-dev
https://golang.org/cl/167055

When SA_SIGINFO is set, we should use __sa_sigaction on FreeBSD

R=rsc
CC=golang-dev
https://golang.org/cl/165097

6l, 8l: make string buffer big enough for 8 chars (and then some)

Fixes #221.

R=ken2
https://golang.org/cl/165086

test/bench: faster fasta (mostly due to bufio fix)

R=r
https://golang.org/cl/165083

runtime: don't touch pages of memory unnecessarily.
cuts working size for hello world from 6 MB to 1.2 MB.
still some work to be done, but diminishing returns.

R=r
https://golang.org/cl/165080

runtime: introduce unsafe.New and unsafe.NewArray
    to provide functionality previously hacked in to
    reflect and gob.

R=r
https://golang.org/cl/165076

use a bootstrap array to avoid allocation for short vectors

R=r
https://golang.org/cl/165078

Remove copyBytes completely in favor of copy.

R=r, rsc
https://golang.org/cl/165068

pick off special one-byte case in copy. worth 2x in benchmarks (38ns->16ns).
the one-item case could be generalized easily with no cost. worth considering.

R=rsc
CC=golang-dev, cw
https://golang.org/cl/167044

the AST walker currently provides no way to find out how the
nodes in the tree are nested with respect to one another.
a simple change to the Visitor interface makes it possible
to do this (for example to maintain a current node-depth, or a
knowledge of the name of the current function).

Visit(nil) is called at the end of a node's children;
this make possible the channel-based interface below,
amongst other possibilities.

It is still just as simple to get the original behaviour - just
return the same Visitor from Visit.

Here are a couple of possible Visitor types.

// closure-based
type FVisitor func(n interface{}) FVisitor
func (f FVisitor) Visit(n interface{}) Visitor {
return f(n);
}

// channel-based
type CVisitor chan Visit;
type Visit struct {
node interface{};
reply chan CVisitor;
};
func (v CVisitor) Visit(n interface{}) Visitor
{
if n == nil {
close(v);
} else {
reply := make(chan CVisitor);
v <- Visit{n, reply};
r := <-reply;
if r == nil {
return nil;
}
return r;
}
return nil;
}

R=gri
CC=rsc
https://golang.org/cl/166047

changes necessary to get the new chameneosredux onto shootout.alioth.debian.org .
it's now there: http://shootout.alioth.debian.org/u32q/benchmark.php?test=chameneosredux&lang=all&box=1!

R=r, rsc
CC=golang-dev
https://golang.org/cl/167043

save a few ns by inlining (which mostly simplifies things anyway).
a couple of cleanups.
don't keep big buffers in the free list.

R=rsc
CC=golang-dev
https://golang.org/cl/166078

unexport Fmt. it's not needed outside this package any more
cleans up godoc's output for package fmt substantially.

R=rsc
CC=golang-dev
https://golang.org/cl/165070

Make printing faster by avoiding mallocs and some other advances.
Roughly 33% faster for simple cases, probably more for complex ones.

Before:

mallocs per Sprintf(""): 4
mallocs per Sprintf("xxx"): 6
mallocs per Sprintf("%x"): 10
mallocs per Sprintf("%x %x"): 12

Now:

mallocs per Sprintf(""): 2
mallocs per Sprintf("xxx"): 3
mallocs per Sprintf("%x"): 5
mallocs per Sprintf("%x %x"): 7

Speed improves because of avoiding mallocs and also by sharing a bytes.Buffer
between print.go and format.go rather than copying the data back after each
printed item.

Before:

fmt_test.BenchmarkSprintfEmpty 1000000       1346 ns/op
fmt_test.BenchmarkSprintfString 500000       3461 ns/op
fmt_test.BenchmarkSprintfInt 500000       3671 ns/op

Now:

fmt_test.BenchmarkSprintfEmpty  2000000        995 ns/op
fmt_test.BenchmarkSprintfString  1000000       2745 ns/op
fmt_test.BenchmarkSprintfInt  1000000       2391 ns/op
fmt_test.BenchmarkSprintfIntInt   500000       3751 ns/op

I believe there is more to get but this is a good milestone.

R=rsc
CC=golang-dev, hong
https://golang.org/cl/166076

runtime: disable pointer scan optimization
  * broken by reflect, gob

TBR=r
https://golang.org/cl/166077

Fix syscall.Statfs and syscall.Fstatfs for 386 GNU/Linux.

For 386 we use the [f]statfs64 system call, which takes three
parameters: the filename, the size of the statfs64 structure,
and a pointer to the structure itself.

R=rsc
https://golang.org/cl/166073

test/bench: use range in reverse-complement

1.9s gcc reverse-complement.c

reverse-complement.go
4.5s / 3.5s original, with/without bounds checks
3.5s / 3.3s bounds check reduction
3.3s / 2.8s smarter garbage collector
2.6s / 2.3s assembler bytes.IndexByte
2.5s / 2.1s even smarter garbage collector
2.3s / 2.1s fix optimizer unnecessary spill bug
2.0s / 1.9s change loop to range (this CL)

R=r
https://golang.org/cl/166072

gc/runtime: pass type structure to makeslice.
  * inform garbage collector about memory with no pointers in it

1.9s gcc reverse-complement.c

reverse-complement.go
4.5s / 3.5s original, with/without bounds checks
3.5s / 3.3s bounds check reduction
3.3s / 2.8s smarter garbage collector
2.6s / 2.3s assembler bytes.IndexByte
2.5s / 2.1s even smarter garbage collector (this CL)

R=r
https://golang.org/cl/165064

gc: walk pointer in range on slice/array

R=ken2
https://golang.org/cl/166071

6g/8g optimizer fix: throw functions now in runtime

R=ken2
https://golang.org/cl/166070

test/bench: dead code in reverse-complement

R=r
https://golang.org/cl/165065

gotest: stop if the // gotest commands fail

R=r
https://golang.org/cl/166067

net: more fiddling with the udp test.
  i don't know why the timeout needs
  to be so big.

R=r
https://golang.org/cl/165063

libmach: fix disassembly of MOVLQSX

R=r
https://golang.org/cl/166068

gotest: ignore *_test.pb.go

R=r
https://golang.org/cl/166064

Add syscall.Rename for NaCl.  Fixes NaCl build.

R=rsc
https://golang.org/cl/165062

runtime: shift the index for the sort by one.

Makes the code look cleaner, even if it's a little harder to figure
out from the sort invariants.

R=rsc
CC=golang-dev
https://golang.org/cl/165061

Add os.Rename.

R=rsc
https://golang.org/cl/166058

Remove global chanlock.

On a microbenchmark that ping-pongs on lots of channels, this makes
the multithreaded case about 20% faster and the uniprocessor case
about 1% slower. (Due to cache effects, I expect.)

R=rsc, agl
CC=golang-dev
https://golang.org/cl/166043

bytes: asm for bytes.IndexByte

PERFORMANCE DIFFERENCE

SUMMARY

                                                   amd64           386
2.2 GHz AMD Opteron 8214 HE (Linux)             3.0x faster    8.2x faster
3.60 GHz Intel Xeon (Linux)                     2.2x faster    6.2x faster
2.53 GHz Intel Core2 Duo E7200 (Linux)          1.5x faster    4.4x faster
2.66 Ghz Intel Xeon 5150 (Mac Pro, OS X)        1.5x SLOWER    3.0x faster
2.33 GHz Intel Xeon E5435 (Linux)               1.5x SLOWER    3.0x faster
2.33 GHz Intel Core2 T7600 (MacBook Pro, OS X)  1.4x SLOWER    3.0x faster
1.83 GHz Intel Core2 T5600 (Mac Mini, OS X)        none*       3.0x faster

* but yesterday I consistently saw 1.4x SLOWER.

DETAILS

2.2 GHz AMD Opteron 8214 HE (Linux)

amd64 (3x faster)

IndexByte4K            500000           3733 ns/op     1097.24 MB/s
IndexByte4M               500        4328042 ns/op      969.10 MB/s
IndexByte64M               50       67866160 ns/op      988.84 MB/s

IndexBytePortable4K    200000          11161 ns/op      366.99 MB/s
IndexBytePortable4M       100       11795880 ns/op      355.57 MB/s
IndexBytePortable64M       10      188675000 ns/op      355.68 MB/s

386 (8.2x faster)

IndexByte4K            500000           3734 ns/op     1096.95 MB/s
IndexByte4M               500        4209954 ns/op      996.28 MB/s
IndexByte64M               50       68031980 ns/op      986.43 MB/s

IndexBytePortable4K     50000          30670 ns/op      133.55 MB/s
IndexBytePortable4M        50       31868220 ns/op      131.61 MB/s
IndexBytePortable64M        2      508851500 ns/op      131.88 MB/s

3.60 GHz Intel Xeon (Linux)

amd64 (2.2x faster)

IndexByte4K            500000           4612 ns/op      888.12 MB/s
IndexByte4M               500        4835250 ns/op      867.44 MB/s
IndexByte64M               20       77388450 ns/op      867.17 MB/s

IndexBytePortable4K    200000          10306 ns/op      397.44 MB/s
IndexBytePortable4M       100       11201460 ns/op      374.44 MB/s
IndexBytePortable64M       10      179456800 ns/op      373.96 MB/s

386 (6.3x faster)

IndexByte4K            500000           4631 ns/op      884.47 MB/s
IndexByte4M               500        4846388 ns/op      865.45 MB/s
IndexByte64M               20       78691200 ns/op      852.81 MB/s

IndexBytePortable4K    100000          28989 ns/op      141.29 MB/s
IndexBytePortable4M        50       31183180 ns/op      134.51 MB/s
IndexBytePortable64M        5      498347200 ns/op      134.66 MB/s

2.53 GHz Intel Core2 Duo E7200  (Linux)

amd64 (1.5x faster)

IndexByte4K            500000           6502 ns/op      629.96 MB/s
IndexByte4M               500        6692208 ns/op      626.74 MB/s
IndexByte64M               10      107410400 ns/op      624.79 MB/s

IndexBytePortable4K    200000           9721 ns/op      421.36 MB/s
IndexBytePortable4M       100       10013680 ns/op      418.86 MB/s
IndexBytePortable64M       10      160460800 ns/op      418.23 MB/s

386 (4.4x faster)

IndexByte4K            500000           6505 ns/op      629.67 MB/s
IndexByte4M               500        6694078 ns/op      626.57 MB/s
IndexByte64M               10      107397600 ns/op      624.86 MB/s

IndexBytePortable4K    100000          28835 ns/op      142.05 MB/s
IndexBytePortable4M        50       29562680 ns/op      141.88 MB/s
IndexBytePortable64M        5      473221400 ns/op      141.81 MB/s

2.66 Ghz Intel Xeon 5150  (Mac Pro, OS X)

amd64 (1.5x SLOWER)

IndexByte4K            200000           9290 ns/op      440.90 MB/s
IndexByte4M               200        9568925 ns/op      438.33 MB/s
IndexByte64M               10      154473600 ns/op      434.44 MB/s

IndexBytePortable4K    500000           6202 ns/op      660.43 MB/s
IndexBytePortable4M       500        6583614 ns/op      637.08 MB/s
IndexBytePortable64M       20      107166250 ns/op      626.21 MB/s

386 (3x faster)

IndexByte4K            200000           9301 ns/op      440.38 MB/s
IndexByte4M               200        9568025 ns/op      438.37 MB/s
IndexByte64M               10      154391000 ns/op      434.67 MB/s

IndexBytePortable4K    100000          27526 ns/op      148.80 MB/s
IndexBytePortable4M       100       28302490 ns/op      148.20 MB/s
IndexBytePortable64M        5      454170200 ns/op      147.76 MB/s

2.33 GHz Intel Xeon E5435  (Linux)

amd64 (1.5x SLOWER)

IndexByte4K            200000          10601 ns/op      386.38 MB/s
IndexByte4M               100       10827240 ns/op      387.38 MB/s
IndexByte64M               10      173175500 ns/op      387.52 MB/s

IndexBytePortable4K    500000           7082 ns/op      578.37 MB/s
IndexBytePortable4M       500        7391792 ns/op      567.43 MB/s
IndexBytePortable64M       20      122618550 ns/op      547.30 MB/s

386 (3x faster)

IndexByte4K            200000          11074 ns/op      369.88 MB/s
IndexByte4M               100       10902620 ns/op      384.71 MB/s
IndexByte64M               10      181292800 ns/op      370.17 MB/s

IndexBytePortable4K     50000          31725 ns/op      129.11 MB/s
IndexBytePortable4M        50       32564880 ns/op      128.80 MB/s
IndexBytePortable64M        2      545926000 ns/op      122.93 MB/s

2.33 GHz Intel Core2 T7600 (MacBook Pro, OS X)

amd64 (1.4x SLOWER)

IndexByte4K            200000          11120 ns/op      368.35 MB/s
IndexByte4M               100       11531950 ns/op      363.71 MB/s
IndexByte64M               10      184819000 ns/op      363.11 MB/s

IndexBytePortable4K    500000           7419 ns/op      552.10 MB/s
IndexBytePortable4M       200        8018710 ns/op      523.06 MB/s
IndexBytePortable64M       10      127614900 ns/op      525.87 MB/s

386 (3x faster)

IndexByte4K            200000          11114 ns/op      368.54 MB/s
IndexByte4M               100       11443530 ns/op      366.52 MB/s
IndexByte64M               10      185212000 ns/op      362.34 MB/s

IndexBytePortable4K     50000          32891 ns/op      124.53 MB/s
IndexBytePortable4M        50       33930580 ns/op      123.61 MB/s
IndexBytePortable64M        2      545400500 ns/op      123.05 MB/s

1.83 GHz Intel Core2 T5600  (Mac Mini, OS X)

amd64 (no difference)

IndexByte4K            200000          13497 ns/op      303.47 MB/s
IndexByte4M               100       13890650 ns/op      301.95 MB/s
IndexByte64M                5      222358000 ns/op      301.81 MB/s

IndexBytePortable4K    200000          13584 ns/op      301.53 MB/s
IndexBytePortable4M       100       13913280 ns/op      301.46 MB/s
IndexBytePortable64M       10      222572600 ns/op      301.51 MB/s

386 (3x faster)

IndexByte4K            200000          13565 ns/op      301.95 MB/s
IndexByte4M               100       13882640 ns/op      302.13 MB/s
IndexByte64M                5      221411600 ns/op      303.10 MB/s

IndexBytePortable4K     50000          39978 ns/op      102.46 MB/s
IndexBytePortable4M        50       41038160 ns/op      102.20 MB/s
IndexBytePortable64M        2      656362500 ns/op      102.24 MB/s

R=r
CC=golang-dev
https://golang.org/cl/166055

spec: document that built-ins cannot be used as func values

R=gri
CC=golang-dev
https://golang.org/cl/164088

make Native Client support build again,
add README explaining how to try the
web demos.

Fixes #339.

R=r
CC=barry.d.silverman, bss, vadim
https://golang.org/cl/165057

testing: compute MB/s in benchmarks

R=r
https://golang.org/cl/166060

avoid an allocation inside bytes.Buffer by providing a static array.

R=rsc
https://golang.org/cl/165058

8l: fix print line number format, buffer overflow

R=ken2
https://golang.org/cl/165059

net: turn off empty packet test by default

Fixes #374.

R=r
https://golang.org/cl/166053

gc: check for assignment to private fields during initialization

R=ken2
https://golang.org/cl/165055

6g code gen bug

R=rsc
https://golang.org/cl/166052

Add Count, Cycle, ZipWith, GroupBy, Repeat, RepeatTimes, Unique to exp/iterable.

Modify iterFunc to take chan<- instead of just chan.

R=rsc, dsymonds1
CC=golang-dev, r
https://golang.org/cl/160064

crypto/rsa: fix shadowing error.

Fixes bug 375.

R=rsc
https://golang.org/cl/165045

runtime: fix Caller crash on 386.

Fixes #176.

R=r
https://golang.org/cl/166044

faq: add question about translation

R=jini, r
https://golang.org/cl/163092

codereview: do not gofmt deleted files

R=r
https://golang.org/cl/164083

Make.conf: fix if $HOME has spaces

R=r
https://golang.org/cl/164086

runtime: malloc fixes
  * throw away dead code
  * add mlookup counter
  * add malloc counter
  * set up for blocks with no pointers

Fixes #367.

R=r
https://golang.org/cl/165050

The String() method requires global state that makes it not work outside of this package,
so make it a local method (_String()).

R=rsc
CC=golang-dev
https://golang.org/cl/165049

error propagation in gob/encoder.

R=rsc
CC=golang-dev
https://golang.org/cl/165048

Add ReadFrom and WriteTo methods to bytes.Buffer, to enable i/o without buffer allocation.
Use them in Copy and Copyn.
Speed up ReadFile by using ReadFrom and avoiding Copy altogether (a minor win).

R=rsc, gri
CC=golang-dev
https://golang.org/cl/166041

gc: Allow allow data types up to 1GB

R=rsc
https://golang.org/cl/164095

- include type-associated consts and vars when filtering a PackageDoc
- fixes a godoc issue (for instance, "godoc os EOF" now shows an entry)

R=r
CC=rsc
https://golang.org/cl/165042

gc: handle _ = <-c in select.

Fixes #238.

R=ken2
https://golang.org/cl/163098

gc: recursive type error

Fixes #245.

R=ken2
https://golang.org/cl/164094

gc: better diagnosis of initialization loops

Fixes bug 292.

R=ken2
https://golang.org/cl/164093

gc: minor import grammar bug fixes

Fixes #364.

R=ken2
https://golang.org/cl/164092

minor improvement to formatting: don't allocate padding strings every time.

R=rsc
https://golang.org/cl/164090

gc: function argument ordering bug

Fixes #370.

R=ken2
https://golang.org/cl/163097

gc: make 'invalid rune in string' a little less cryptic

Fixes #371.

R=ken2
https://golang.org/cl/164091

move ReadFile, WriteFile, and ReadDir into a separate io/ioutil package.
this breaks the dependency of package io on package bytes.

R=rsc
CC=golang-dev
https://golang.org/cl/163085

Runes: turn string into []int
Split: fixed typo in documentation

R=rsc, r, r1
https://golang.org/cl/157170

updated documentation for gofmt

R=rsc
https://golang.org/cl/164085

8g: discard tempalloc/tempfree experiment
in favor of tempname.
allows optimizer to do more.
unfortunately, optimizer seems to be broken; disable it.

R=ken2
https://golang.org/cl/163091

6g etc: groundwork for eliminating redundant bounds checks.
drop check in range over array.
drop check in [256]array indexed by byte.

R=ken2
https://golang.org/cl/163088

Add flag -tabindent to gofmt: forces use of
tabs for indentation even if -spaces is set.

Changes to gofmt:
- added -tabindent flag
- don't recompute parser and printer mode repeatedly

Changes to go/printer:
- provide new printing mode TabIndent

Changes to tabwriter:
- implement new mode TabIndent to use tabs independent
  of the actual padding character for leading empty columns
- distinguish between minimal cell width and tab width
  (tabwidth is only used if the output contains tabs,
  minwidth and padding are always considered)
- fixed and added more comments
- some additional factoring

By default, -tabindent is disabled and the default gofmt
behavior is unchanged. By setting -spaces and -tabindent,
gofmt will use tabs for indentation but do any other
alignment with spaces. This permits a user to change the
visible indentation by simply changing the editor's tab
width and the code will remain properly aligned without
the need to rerun gofmt.

R=rsc
https://golang.org/cl/163068

net: test and fix support for 0-length datagram packets.

Fixes #274.

R=r
CC=jonathan.r.hudson
https://golang.org/cl/163072

change the naming example from Vector to Ring due to loss of vector.New()

R=rsc
CC=golang-dev
https://golang.org/cl/164082

Add copy to the list of predeclared functions.

R=gri
https://golang.org/cl/164081

gofmt: race condition in error reporting and setting exit code

How to reproduce:

$ mkdir /tmp/foo
$ cp /dev/null /tmp/foo/bar.go
$ chmod -r /tmp/foo/bar.go
$ gofmt /tmp/foo
open /tmp/foo/bar.go: permission denied
$ echo $? # should echo 2
0
$

Maybe you need to put a call to time.Sleep at the beginning of report().

R=gri
CC=golang-dev
https://golang.org/cl/164073

apply gofmt to json files

R=rsc
https://golang.org/cl/164071

fix segfault printing errors. add test case and improve messages.

Fixes #338.

R=rsc
CC=golang-dev
https://golang.org/cl/163083

test that arrays work properly.
can't mix slices and arrays now; perhaps that should be a TODO

R=rsc
https://golang.org/cl/164079

codereview: move reviewers to cc line after submit,
  so that the issue stops showing up on the
  per-reviewer dashboard page.

R=r
https://golang.org/cl/164075

time: another bug in SecondsToUTC.
added random test to look for more.

Fixes #363.

R=r, cw
https://golang.org/cl/163071

Add Shutdown to 32-bit GNU/Linux build.

Submitting as a TBR to fix the build.

R=dho, rsc
https://golang.org/cl/164078

lxml.etree is the wrong location for this alt package

  on my linux machine this is the correct one. lxml.etree
  exists with an ElementTree class, but does not contain
  an .XML method.

R=rsc
https://golang.org/cl/163082

xml.etree can also be lxml.etree (e.g. CentOS 5.4 with Python 2.4.3)

R=rsc
CC=golang-dev
https://golang.org/cl/164053

time: fix handling of Jan 1 1601, 1201, 801, ...

R=r
CC=hurtonm
https://golang.org/cl/164074

net: fix netFD.Close races

Fixes #271.
Fixes #321.

R=rsc, agl, cw
CC=golang-dev
https://golang.org/cl/163052

explicitly catch attempt to decode into a value - must be a pointer to see the result.

R=rsc
https://golang.org/cl/163070

make io.ReadFile use Stat.Size as a hint for preallocation

R=rsc
CC=golang-dev
https://golang.org/cl/163069

Add syscall.Shutdown to FreeBSD i386/amd64

Necessary for 163052

R=rsc
CC=golang-dev
https://golang.org/cl/164068

8g: Match sgen definition to declaration

R=rsc
CC=golang-dev
https://golang.org/cl/164069

FreeBSD needs #!/usr/bin/env bash (fixes broken build on FreeBSD)

R=gri
https://golang.org/cl/163067