misc/nacl: include parser.go for cmd/compile/internal/syntax tests

Fix suggested by Minux. Change-Id: Ia7aa8ccccc16535af4ec3ad23830ef0aa5d776ac Reviewed-on: https://go-review.googlesource.com/27193 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Minux Ma <minux@golang.org>
cmd/compile/internal/syntax: match old parser errors and line numbers
2026-02-03 09:25:06 +03:00 · 2016-08-16 22:42:13 +00:00 · 2016-08-16 14:32:09 -07:00 · 2016-08-16 14:32:09 -07:00 · 2016-08-16 14:32:09 -07:00 · 2016-08-16 14:32:09 -07:00
4074 changed files with 215293 additions and 637062 deletions
--- a/.github/CODE_OF_CONDUCT.md
+++ b/.github/CODE_OF_CONDUCT.md
@@ -1,3 +0,0 @@
-# Code of Conduct
-
-Please read the [Go Community Code of Conduct](https://golang.org/conduct).
--- a/.github/ISSUE_TEMPLATE
+++ b/.github/ISSUE_TEMPLATE
@@ -1,24 +1,20 @@
 Please answer these questions before submitting your issue. Thanks!

-
-### What version of Go are you using (`go version`)?
+1. What version of Go are you using (`go version`)?


-### Does this issue reproduce with the latest release?
+2. What operating system and processor architecture are you using (`go env`)?


-### What operating system and processor architecture are you using (`go env`)?
-
-
-### What did you do?
-
+3. What did you do?
 If possible, provide a recipe for reproducing the error.
 A complete runnable program is good.
 A link on play.golang.org is best.


-### What did you expect to see?
+4. What did you expect to see?


-### What did you see instead?
+5. What did you see instead?
+

--- a/.github/SUPPORT.md
+++ b/.github/SUPPORT.md
@@ -1,14 +0,0 @@
-Unlike many projects on GitHub, the Go project does not use its bug tracker for general discussion or asking questions.
-We only use our bug tracker for tracking bugs and tracking proposals going through the [Proposal Process](https://golang.org/s/proposal-process).
-
-For asking questions, see:
-
-* [The golang-nuts mailing list](https://groups.google.com/d/forum/golang-nuts)
-
-* [The Go Forum](https://forum.golangbridge.org/), a web-based forum
-
-* [Gophers Slack](https://gophers.slack.com), use the [invite app](https://invite.slack.golangbridge.org/) for access
-
-* [Stack Overflow](http://stackoverflow.com/questions/tagged/go) with questions tagged "go"
-
-* **IRC** channel #go-nuts on Freenode
--- a/.gitignore
+++ b/.gitignore
@@ -18,34 +18,28 @@ _cgo_*
 _obj
 _test
 _testmain.go
+build.out
+test.out
+doc/articles/wiki/*.bin
+misc/cgo/life/run.out
+misc/cgo/stdio/run.out
+misc/cgo/testso/main
+src/cmd/cgo/zdefaultcc.go
+src/cmd/go/zdefaultcc.go
+src/cmd/go/zosarch.go
+src/cmd/internal/obj/zbootstrap.go
+src/go/build/zcgo.go
+src/go/doc/headscan
+src/runtime/internal/sys/zversion.go
+src/unicode/maketables
+src/*.*/
+test/pass.out
+test/run.out
+test/times.out
+test/garbage/*.out
+goinstall.log
+last-change
+VERSION.cache

-/VERSION.cache
-/bin/
-/build.out
-/doc/articles/wiki/*.bin
-/goinstall.log
-/last-change
-/misc/cgo/life/run.out
-/misc/cgo/stdio/run.out
-/misc/cgo/testso/main
-/pkg/
-/src/*.*/
-/src/cmd/cgo/zdefaultcc.go
-/src/cmd/dist/dist
-/src/cmd/go/internal/cfg/zdefaultcc.go
-/src/cmd/go/internal/cfg/zosarch.go
-/src/cmd/internal/objabi/zbootstrap.go
-/src/go/build/zcgo.go
-/src/go/doc/headscan
-/src/runtime/internal/sys/zversion.go
-/src/unicode/maketables
-/test.out
-/test/garbage/*.out
-/test/pass.out
-/test/run.out
-/test/times.out
-
-# This file includes artifacts of Go build that should not be checked in.
-# For files created by specific development environment (e.g. editor),
-# use alternative ways to exclude files from git.
-# For example, set up .git/info/exclude or use a global .gitignore.
+bin/
+pkg/
--- a/490
+++ b/490
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,19 +4,10 @@ Go is an open source project.

 It is the work of hundreds of contributors. We appreciate your help!

-## Before filing an issue
-
-If you are unsure whether you have found a bug, please consider asking in the [golang-nuts mailing
-list](https://groups.google.com/forum/#!forum/golang-nuts) or [other forums](https://golang.org/help/) first. If
-the behavior you are seeing is confirmed as a bug or issue, it can easily be re-raised in the issue tracker.

 ## Filing issues

-Sensitive security-related issues should be reported to [security@golang.org](mailto:security@golang.org).
-See the [security policy](https://golang.org/security) for details.
-
-The recommended way to file an issue is by running `go bug`.
-Otherwise, when filing an issue, make sure to answer these five questions:
+When filing an issue, make sure to answer these five questions:

 1. What version of Go are you using (`go version`)?
 2. What operating system and processor architecture are you using?
@@ -24,16 +15,19 @@ Otherwise, when filing an issue, make sure to answer these five questions:
 4. What did you expect to see?
 5. What did you see instead?

-For change proposals, see [Proposing Changes To Go](https://github.com/golang/proposal/).
+General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
+The gophers there will answer or ask you to file an issue if you've tripped over a bug.
+
+Sensitive security-related issues should be reported to [security@golang.org](mailto:security@golang.org).

 ## Contributing code

-Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html) before sending patches.
+Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
+before sending patches.

 **We do not accept GitHub pull requests**
 (we use [an instance](https://go-review.googlesource.com/) of the
 [Gerrit](https://www.gerritcodereview.com/) code review system instead).
-Also, please do not post patches on the issue tracker.

 Unless otherwise noted, the Go source files are distributed under
 the BSD-style license found in the LICENSE file.
--- a/584
+++ b/584
--- a/README.md
+++ b/README.md
@@ -4,42 +4,40 @@ Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.

 ![Gopher image](doc/gopher/fiveyears.jpg)
-*Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
+
+For documentation about how to install and use Go,
+visit https://golang.org/ or load doc/install-source.html
+in your web browser.

 Our canonical Git repository is located at https://go.googlesource.com/go.
 There is a mirror of the repository at https://github.com/golang/go.

-Unless otherwise noted, the Go source files are distributed under the
-BSD-style license found in the LICENSE file.
-
-### Download and Install
-
-#### Binary Distributions
-
-Official binary distributions are available at https://golang.org/dl/.
-
-After downloading a binary release, visit https://golang.org/doc/install
-or load doc/install.html in your web browser for installation
-instructions.
-
-#### Install From Source
-
-If a binary distribution is not available for your combination of
-operating system and architecture, visit
-https://golang.org/doc/install/source or load doc/install-source.html
-in your web browser for source installation instructions.
-
-### Contributing
-
 Go is the work of hundreds of contributors. We appreciate your help!

 To contribute, please read the contribution guidelines:
 	https://golang.org/doc/contribute.html

-Note that the Go project does not use GitHub pull requests, and that
-we use the issue tracker for bug reports and proposals only. See
-https://golang.org/wiki/Questions for a list of places to ask
-questions about the Go language.
+##### Note that we do not accept pull requests and that we use the issue tracker for bug reports and proposals only. Please ask questions on https://forum.golangbridge.org or https://groups.google.com/forum/#!forum/golang-nuts.

-[rf]: https://reneefrench.blogspot.com/
-[cc3-by]: https://creativecommons.org/licenses/by/3.0/
+Unless otherwise noted, the Go source files are distributed
+under the BSD-style license found in the LICENSE file.
+
+--
+
+## Binary Distribution Notes
+
+If you have just untarred a binary Go distribution, you need to set
+the environment variable $GOROOT to the full path of the go
+directory (the one containing this file).  You can omit the
+variable if you unpack it into /usr/local/go, or if you rebuild
+from sources by running all.bash (see doc/install-source.html).
+You should also add the Go binary directory $GOROOT/bin
+to your shell's path.
+
+For example, if you extracted the tar file into $HOME/go, you might
+put the following in your .profile:
+
+	export GOROOT=$HOME/go
+	export PATH=$PATH:$GOROOT/bin
+
+See https://golang.org/doc/install or doc/install.html for more details.
--- a/api/except.txt
+++ b/api/except.txt
@@ -1,109 +1,23 @@
-pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
-pkg math/big, const MaxBase = 36
-pkg math/big, type Word uintptr
 pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
+pkg syscall (darwin-386), func Fchflags(string, int) error
+pkg syscall (darwin-386-cgo), func Fchflags(string, int) error
+pkg syscall (darwin-amd64), func Fchflags(string, int) error
+pkg syscall (darwin-amd64-cgo), func Fchflags(string, int) error
+pkg syscall (freebsd-386), func Fchflags(string, int) error
+pkg syscall (freebsd-amd64), func Fchflags(string, int) error
+pkg syscall (freebsd-arm), func Fchflags(string, int) error
+pkg syscall (freebsd-arm-cgo), func Fchflags(string, int) error
+pkg syscall (netbsd-arm), func Fchflags(string, int) error
+pkg syscall (netbsd-arm-cgo), func Fchflags(string, int) error
+pkg testing, func RegisterCover(Cover)
+pkg text/template/parse, type DotNode bool
+pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg os (linux-arm), const O_SYNC = 4096
 pkg os (linux-arm-cgo), const O_SYNC = 4096
 pkg syscall (darwin-386), const ImplementsGetwd = false
-pkg syscall (darwin-386), func Fchflags(string, int) error
 pkg syscall (darwin-386-cgo), const ImplementsGetwd = false
-pkg syscall (darwin-386-cgo), func Fchflags(string, int) error
 pkg syscall (darwin-amd64), const ImplementsGetwd = false
-pkg syscall (darwin-amd64), func Fchflags(string, int) error
 pkg syscall (darwin-amd64-cgo), const ImplementsGetwd = false
-pkg syscall (darwin-amd64-cgo), func Fchflags(string, int) error
-pkg syscall (freebsd-386), const AF_MAX = 38
-pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-386), const ELAST = 94
-pkg syscall (freebsd-386), const O_CLOEXEC = 0
-pkg syscall (freebsd-386), func Fchflags(string, int) error
-pkg syscall (freebsd-386-cgo), const AF_MAX = 38
-pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-386-cgo), const ELAST = 94
-pkg syscall (freebsd-386-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-amd64), const AF_MAX = 38
-pkg syscall (freebsd-amd64), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-amd64), const ELAST = 94
-pkg syscall (freebsd-amd64), const O_CLOEXEC = 0
-pkg syscall (freebsd-amd64), func Fchflags(string, int) error
-pkg syscall (freebsd-amd64-cgo), const AF_MAX = 38
-pkg syscall (freebsd-amd64-cgo), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-amd64-cgo), const ELAST = 94
-pkg syscall (freebsd-amd64-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm), const AF_MAX = 38
-pkg syscall (freebsd-arm), const BIOCGRTIMEOUT = 1074545262
-pkg syscall (freebsd-arm), const BIOCSRTIMEOUT = 2148287085
-pkg syscall (freebsd-arm), const ELAST = 94
-pkg syscall (freebsd-arm), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm), const SIOCAIFADDR = 2151967019
-pkg syscall (freebsd-arm), const SIOCGIFSTATUS = 3274991931
-pkg syscall (freebsd-arm), const SIOCSIFPHYADDR = 2151967046
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET = 537
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT = 536
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET = 535
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT = 534
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET = 515
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT = 533
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SizeofBpfHdr = 24
-pkg syscall (freebsd-arm), const SizeofIfData = 88
-pkg syscall (freebsd-arm), const SizeofIfMsghdr = 104
-pkg syscall (freebsd-arm), const SizeofSockaddrDatalink = 56
-pkg syscall (freebsd-arm), const SizeofSockaddrUnix = 108
-pkg syscall (freebsd-arm), const TIOCTIMESTAMP = 1074558041
-pkg syscall (freebsd-arm), func Fchflags(string, int) error
-pkg syscall (freebsd-arm), type BpfHdr struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type Stat_t struct, Pad_cgo_0 [4]uint8
-pkg syscall (freebsd-arm-cgo), const AF_MAX = 38
-pkg syscall (freebsd-arm-cgo), const BIOCGRTIMEOUT = 1074545262
-pkg syscall (freebsd-arm-cgo), const BIOCSRTIMEOUT = 2148287085
-pkg syscall (freebsd-arm-cgo), const ELAST = 94
-pkg syscall (freebsd-arm-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm-cgo), const SIOCAIFADDR = 2151967019
-pkg syscall (freebsd-arm-cgo), const SIOCGIFSTATUS = 3274991931
-pkg syscall (freebsd-arm-cgo), const SIOCSIFPHYADDR = 2151967046
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET = 537
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT = 536
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET = 535
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT = 534
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET = 515
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT = 533
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SizeofBpfHdr = 24
-pkg syscall (freebsd-arm-cgo), const SizeofIfData = 88
-pkg syscall (freebsd-arm-cgo), const SizeofIfMsghdr = 104
-pkg syscall (freebsd-arm-cgo), const SizeofSockaddrDatalink = 56
-pkg syscall (freebsd-arm-cgo), const SizeofSockaddrUnix = 108
-pkg syscall (freebsd-arm-cgo), const TIOCTIMESTAMP = 1074558041
-pkg syscall (freebsd-arm-cgo), func Fchflags(string, int) error
-pkg syscall (freebsd-arm-cgo), type BpfHdr struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Pad_cgo_0 [4]uint8
-pkg syscall (linux-386), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-386-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-amd64), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-amd64-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-arm), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-arm-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (netbsd-arm), const SizeofIfData = 132
-pkg syscall (netbsd-arm), func Fchflags(string, int) error
-pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
-pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
-pkg syscall (netbsd-arm-cgo), func Fchflags(string, int) error
-pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-386), const BIOCGRTIMEOUT = 1074283118
 pkg syscall (openbsd-386), const BIOCSRTIMEOUT = 2148024941
 pkg syscall (openbsd-386), const RTF_FMASK = 63496
@@ -332,16 +246,87 @@ pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, F_spare [3]uint32
 pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Pad_cgo_0 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Sec int32
-pkg testing, func RegisterCover(Cover)
-pkg testing, func MainStart(func(string, string) (bool, error), []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg text/template/parse, type DotNode bool
-pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg unicode, const Version = "6.2.0"
+pkg syscall (freebsd-386), const AF_MAX = 38
+pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-386), const ELAST = 94
+pkg syscall (freebsd-386), const O_CLOEXEC = 0
+pkg syscall (freebsd-386-cgo), const AF_MAX = 38
+pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-386-cgo), const ELAST = 94
+pkg syscall (freebsd-386-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-amd64), const AF_MAX = 38
+pkg syscall (freebsd-amd64), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-amd64), const ELAST = 94
+pkg syscall (freebsd-amd64), const O_CLOEXEC = 0
+pkg syscall (freebsd-amd64-cgo), const AF_MAX = 38
+pkg syscall (freebsd-amd64-cgo), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-amd64-cgo), const ELAST = 94
+pkg syscall (freebsd-amd64-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-arm), const AF_MAX = 38
+pkg syscall (freebsd-arm), const BIOCGRTIMEOUT = 1074545262
+pkg syscall (freebsd-arm), const BIOCSRTIMEOUT = 2148287085
+pkg syscall (freebsd-arm), const ELAST = 94
+pkg syscall (freebsd-arm), const O_CLOEXEC = 0
+pkg syscall (freebsd-arm), const SIOCAIFADDR = 2151967019
+pkg syscall (freebsd-arm), const SIOCGIFSTATUS = 3274991931
+pkg syscall (freebsd-arm), const SIOCSIFPHYADDR = 2151967046
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET = 537
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT = 536
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET = 535
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT = 534
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET = 515
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT = 533
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT ideal-int
+pkg syscall (freebsd-arm), const SizeofBpfHdr = 24
+pkg syscall (freebsd-arm), const SizeofIfData = 88
+pkg syscall (freebsd-arm), const SizeofIfMsghdr = 104
+pkg syscall (freebsd-arm), const SizeofSockaddrDatalink = 56
+pkg syscall (freebsd-arm), const SizeofSockaddrUnix = 108
+pkg syscall (freebsd-arm), const TIOCTIMESTAMP = 1074558041
+pkg syscall (freebsd-arm), type BpfHdr struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type Stat_t struct, Pad_cgo_0 [4]uint8
+pkg syscall (freebsd-arm-cgo), const AF_MAX = 38
+pkg syscall (freebsd-arm-cgo), const BIOCGRTIMEOUT = 1074545262
+pkg syscall (freebsd-arm-cgo), const BIOCSRTIMEOUT = 2148287085
+pkg syscall (freebsd-arm-cgo), const ELAST = 94
+pkg syscall (freebsd-arm-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-arm-cgo), const SIOCAIFADDR = 2151967019
+pkg syscall (freebsd-arm-cgo), const SIOCGIFSTATUS = 3274991931
+pkg syscall (freebsd-arm-cgo), const SIOCSIFPHYADDR = 2151967046
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET = 537
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT = 536
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET = 535
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT = 534
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET = 515
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT = 533
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT ideal-int
+pkg syscall (freebsd-arm-cgo), const SizeofBpfHdr = 24
+pkg syscall (freebsd-arm-cgo), const SizeofIfData = 88
+pkg syscall (freebsd-arm-cgo), const SizeofIfMsghdr = 104
+pkg syscall (freebsd-arm-cgo), const SizeofSockaddrDatalink = 56
+pkg syscall (freebsd-arm-cgo), const SizeofSockaddrUnix = 108
+pkg syscall (freebsd-arm-cgo), const TIOCTIMESTAMP = 1074558041
+pkg syscall (freebsd-arm-cgo), type BpfHdr struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Pad_cgo_0 [4]uint8
+pkg syscall (netbsd-arm), const SizeofIfData = 132
+pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
+pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
+pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
 pkg unicode, const Version = "6.3.0"
 pkg unicode, const Version = "7.0.0"
 pkg unicode, const Version = "8.0.0"
-pkg syscall (openbsd-386), const SYS_KILL = 37
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 37
-pkg syscall (openbsd-amd64), const SYS_KILL = 37
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 37
-pkg unicode, const Version = "9.0.0"
--- a/api/go1.10.txt
+++ b/api/go1.10.txt
@@ -1,645 +0,0 @@
-pkg archive/tar, const FormatGNU = 8
-pkg archive/tar, const FormatGNU Format
-pkg archive/tar, const FormatPAX = 4
-pkg archive/tar, const FormatPAX Format
-pkg archive/tar, const FormatUSTAR = 2
-pkg archive/tar, const FormatUSTAR Format
-pkg archive/tar, const FormatUnknown = 0
-pkg archive/tar, const FormatUnknown Format
-pkg archive/tar, method (Format) String() string
-pkg archive/tar, type Format int
-pkg archive/tar, type Header struct, Format Format
-pkg archive/tar, type Header struct, PAXRecords map[string]string
-pkg archive/zip, method (*Writer) SetComment(string) error
-pkg archive/zip, type FileHeader struct, Modified time.Time
-pkg archive/zip, type FileHeader struct, NonUTF8 bool
-pkg bufio, method (*Reader) Size() int
-pkg bufio, method (*Writer) Size() int
-pkg crypto/tls, const ECDSAWithSHA1 = 515
-pkg crypto/tls, const ECDSAWithSHA1 SignatureScheme
-pkg crypto/x509, const CANotAuthorizedForExtKeyUsage = 9
-pkg crypto/x509, const CANotAuthorizedForExtKeyUsage InvalidReason
-pkg crypto/x509, const ExtKeyUsageMicrosoftCommercialCodeSigning = 12
-pkg crypto/x509, const ExtKeyUsageMicrosoftCommercialCodeSigning ExtKeyUsage
-pkg crypto/x509, const ExtKeyUsageMicrosoftKernelCodeSigning = 13
-pkg crypto/x509, const ExtKeyUsageMicrosoftKernelCodeSigning ExtKeyUsage
-pkg crypto/x509, const NameConstraintsWithoutSANs = 6
-pkg crypto/x509, const NameConstraintsWithoutSANs InvalidReason
-pkg crypto/x509, const TooManyConstraints = 8
-pkg crypto/x509, const TooManyConstraints InvalidReason
-pkg crypto/x509, const UnconstrainedName = 7
-pkg crypto/x509, const UnconstrainedName InvalidReason
-pkg crypto/x509, func MarshalPKCS1PublicKey(*rsa.PublicKey) []uint8
-pkg crypto/x509, func MarshalPKCS8PrivateKey(interface{}) ([]uint8, error)
-pkg crypto/x509, func ParsePKCS1PublicKey([]uint8) (*rsa.PublicKey, error)
-pkg crypto/x509, method (PublicKeyAlgorithm) String() string
-pkg crypto/x509, type Certificate struct, ExcludedEmailAddresses []string
-pkg crypto/x509, type Certificate struct, ExcludedIPRanges []*net.IPNet
-pkg crypto/x509, type Certificate struct, ExcludedURIDomains []string
-pkg crypto/x509, type Certificate struct, PermittedEmailAddresses []string
-pkg crypto/x509, type Certificate struct, PermittedIPRanges []*net.IPNet
-pkg crypto/x509, type Certificate struct, PermittedURIDomains []string
-pkg crypto/x509, type Certificate struct, URIs []*url.URL
-pkg crypto/x509, type CertificateInvalidError struct, Detail string
-pkg crypto/x509, type CertificateRequest struct, URIs []*url.URL
-pkg crypto/x509, type VerifyOptions struct, MaxConstraintComparisions int
-pkg crypto/x509/pkix, method (Name) String() string
-pkg crypto/x509/pkix, method (RDNSequence) String() string
-pkg database/sql, func OpenDB(driver.Connector) *DB
-pkg database/sql/driver, type Connector interface { Connect, Driver }
-pkg database/sql/driver, type Connector interface, Connect(context.Context) (Conn, error)
-pkg database/sql/driver, type Connector interface, Driver() Driver
-pkg database/sql/driver, type DriverContext interface { OpenConnector }
-pkg database/sql/driver, type DriverContext interface, OpenConnector(string) (Connector, error)
-pkg database/sql/driver, type SessionResetter interface { ResetSession }
-pkg database/sql/driver, type SessionResetter interface, ResetSession(context.Context) error
-pkg debug/elf, const R_386_16 = 20
-pkg debug/elf, const R_386_16 R_386
-pkg debug/elf, const R_386_32PLT = 11
-pkg debug/elf, const R_386_32PLT R_386
-pkg debug/elf, const R_386_8 = 22
-pkg debug/elf, const R_386_8 R_386
-pkg debug/elf, const R_386_GOT32X = 43
-pkg debug/elf, const R_386_GOT32X R_386
-pkg debug/elf, const R_386_IRELATIVE = 42
-pkg debug/elf, const R_386_IRELATIVE R_386
-pkg debug/elf, const R_386_PC16 = 21
-pkg debug/elf, const R_386_PC16 R_386
-pkg debug/elf, const R_386_PC8 = 23
-pkg debug/elf, const R_386_PC8 R_386
-pkg debug/elf, const R_386_SIZE32 = 38
-pkg debug/elf, const R_386_SIZE32 R_386
-pkg debug/elf, const R_386_TLS_DESC = 41
-pkg debug/elf, const R_386_TLS_DESC R_386
-pkg debug/elf, const R_386_TLS_DESC_CALL = 40
-pkg debug/elf, const R_386_TLS_DESC_CALL R_386
-pkg debug/elf, const R_386_TLS_GOTDESC = 39
-pkg debug/elf, const R_386_TLS_GOTDESC R_386
-pkg debug/elf, const R_AARCH64_LD64_GOTOFF_LO15 = 310
-pkg debug/elf, const R_AARCH64_LD64_GOTOFF_LO15 R_AARCH64
-pkg debug/elf, const R_AARCH64_LD64_GOTPAGE_LO15 = 313
-pkg debug/elf, const R_AARCH64_LD64_GOTPAGE_LO15 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSGD_ADR_PREL21 = 512
-pkg debug/elf, const R_AARCH64_TLSGD_ADR_PREL21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G0_NC = 516
-pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G1 = 515
-pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLD_ADR_PAGE21 = 518
-pkg debug/elf, const R_AARCH64_TLSLD_ADR_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLD_ADR_PREL21 = 517
-pkg debug/elf, const R_AARCH64_TLSLD_ADR_PREL21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLD_LDST128_DTPREL_LO12 = 572
-pkg debug/elf, const R_AARCH64_TLSLD_LDST128_DTPREL_LO12 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC = 573
-pkg debug/elf, const R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_LDST128_TPREL_LO12 = 570
-pkg debug/elf, const R_AARCH64_TLSLE_LDST128_TPREL_LO12 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC = 571
-pkg debug/elf, const R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC R_AARCH64
-pkg debug/elf, const R_ARM_ABS32_NOI = 55
-pkg debug/elf, const R_ARM_ABS32_NOI R_ARM
-pkg debug/elf, const R_ARM_ALU_PCREL_15_8 = 33
-pkg debug/elf, const R_ARM_ALU_PCREL_15_8 R_ARM
-pkg debug/elf, const R_ARM_ALU_PCREL_23_15 = 34
-pkg debug/elf, const R_ARM_ALU_PCREL_23_15 R_ARM
-pkg debug/elf, const R_ARM_ALU_PCREL_7_0 = 32
-pkg debug/elf, const R_ARM_ALU_PCREL_7_0 R_ARM
-pkg debug/elf, const R_ARM_ALU_PC_G0 = 58
-pkg debug/elf, const R_ARM_ALU_PC_G0 R_ARM
-pkg debug/elf, const R_ARM_ALU_PC_G0_NC = 57
-pkg debug/elf, const R_ARM_ALU_PC_G0_NC R_ARM
-pkg debug/elf, const R_ARM_ALU_PC_G1 = 60
-pkg debug/elf, const R_ARM_ALU_PC_G1 R_ARM
-pkg debug/elf, const R_ARM_ALU_PC_G1_NC = 59
-pkg debug/elf, const R_ARM_ALU_PC_G1_NC R_ARM
-pkg debug/elf, const R_ARM_ALU_PC_G2 = 61
-pkg debug/elf, const R_ARM_ALU_PC_G2 R_ARM
-pkg debug/elf, const R_ARM_ALU_SBREL_19_12_NC = 36
-pkg debug/elf, const R_ARM_ALU_SBREL_19_12_NC R_ARM
-pkg debug/elf, const R_ARM_ALU_SBREL_27_20_CK = 37
-pkg debug/elf, const R_ARM_ALU_SBREL_27_20_CK R_ARM
-pkg debug/elf, const R_ARM_ALU_SB_G0 = 71
-pkg debug/elf, const R_ARM_ALU_SB_G0 R_ARM
-pkg debug/elf, const R_ARM_ALU_SB_G0_NC = 70
-pkg debug/elf, const R_ARM_ALU_SB_G0_NC R_ARM
-pkg debug/elf, const R_ARM_ALU_SB_G1 = 73
-pkg debug/elf, const R_ARM_ALU_SB_G1 R_ARM
-pkg debug/elf, const R_ARM_ALU_SB_G1_NC = 72
-pkg debug/elf, const R_ARM_ALU_SB_G1_NC R_ARM
-pkg debug/elf, const R_ARM_ALU_SB_G2 = 74
-pkg debug/elf, const R_ARM_ALU_SB_G2 R_ARM
-pkg debug/elf, const R_ARM_BASE_ABS = 31
-pkg debug/elf, const R_ARM_BASE_ABS R_ARM
-pkg debug/elf, const R_ARM_CALL = 28
-pkg debug/elf, const R_ARM_CALL R_ARM
-pkg debug/elf, const R_ARM_GOTOFF12 = 98
-pkg debug/elf, const R_ARM_GOTOFF12 R_ARM
-pkg debug/elf, const R_ARM_GOTRELAX = 99
-pkg debug/elf, const R_ARM_GOTRELAX R_ARM
-pkg debug/elf, const R_ARM_GOT_ABS = 95
-pkg debug/elf, const R_ARM_GOT_ABS R_ARM
-pkg debug/elf, const R_ARM_GOT_BREL12 = 97
-pkg debug/elf, const R_ARM_GOT_BREL12 R_ARM
-pkg debug/elf, const R_ARM_GOT_PREL = 96
-pkg debug/elf, const R_ARM_GOT_PREL R_ARM
-pkg debug/elf, const R_ARM_IRELATIVE = 160
-pkg debug/elf, const R_ARM_IRELATIVE R_ARM
-pkg debug/elf, const R_ARM_JUMP24 = 29
-pkg debug/elf, const R_ARM_JUMP24 R_ARM
-pkg debug/elf, const R_ARM_LDC_PC_G0 = 67
-pkg debug/elf, const R_ARM_LDC_PC_G0 R_ARM
-pkg debug/elf, const R_ARM_LDC_PC_G1 = 68
-pkg debug/elf, const R_ARM_LDC_PC_G1 R_ARM
-pkg debug/elf, const R_ARM_LDC_PC_G2 = 69
-pkg debug/elf, const R_ARM_LDC_PC_G2 R_ARM
-pkg debug/elf, const R_ARM_LDC_SB_G0 = 81
-pkg debug/elf, const R_ARM_LDC_SB_G0 R_ARM
-pkg debug/elf, const R_ARM_LDC_SB_G1 = 82
-pkg debug/elf, const R_ARM_LDC_SB_G1 R_ARM
-pkg debug/elf, const R_ARM_LDC_SB_G2 = 83
-pkg debug/elf, const R_ARM_LDC_SB_G2 R_ARM
-pkg debug/elf, const R_ARM_LDRS_PC_G0 = 64
-pkg debug/elf, const R_ARM_LDRS_PC_G0 R_ARM
-pkg debug/elf, const R_ARM_LDRS_PC_G1 = 65
-pkg debug/elf, const R_ARM_LDRS_PC_G1 R_ARM
-pkg debug/elf, const R_ARM_LDRS_PC_G2 = 66
-pkg debug/elf, const R_ARM_LDRS_PC_G2 R_ARM
-pkg debug/elf, const R_ARM_LDRS_SB_G0 = 78
-pkg debug/elf, const R_ARM_LDRS_SB_G0 R_ARM
-pkg debug/elf, const R_ARM_LDRS_SB_G1 = 79
-pkg debug/elf, const R_ARM_LDRS_SB_G1 R_ARM
-pkg debug/elf, const R_ARM_LDRS_SB_G2 = 80
-pkg debug/elf, const R_ARM_LDRS_SB_G2 R_ARM
-pkg debug/elf, const R_ARM_LDR_PC_G1 = 62
-pkg debug/elf, const R_ARM_LDR_PC_G1 R_ARM
-pkg debug/elf, const R_ARM_LDR_PC_G2 = 63
-pkg debug/elf, const R_ARM_LDR_PC_G2 R_ARM
-pkg debug/elf, const R_ARM_LDR_SBREL_11_10_NC = 35
-pkg debug/elf, const R_ARM_LDR_SBREL_11_10_NC R_ARM
-pkg debug/elf, const R_ARM_LDR_SB_G0 = 75
-pkg debug/elf, const R_ARM_LDR_SB_G0 R_ARM
-pkg debug/elf, const R_ARM_LDR_SB_G1 = 76
-pkg debug/elf, const R_ARM_LDR_SB_G1 R_ARM
-pkg debug/elf, const R_ARM_LDR_SB_G2 = 77
-pkg debug/elf, const R_ARM_LDR_SB_G2 R_ARM
-pkg debug/elf, const R_ARM_ME_TOO = 128
-pkg debug/elf, const R_ARM_ME_TOO R_ARM
-pkg debug/elf, const R_ARM_MOVT_ABS = 44
-pkg debug/elf, const R_ARM_MOVT_ABS R_ARM
-pkg debug/elf, const R_ARM_MOVT_BREL = 85
-pkg debug/elf, const R_ARM_MOVT_BREL R_ARM
-pkg debug/elf, const R_ARM_MOVT_PREL = 46
-pkg debug/elf, const R_ARM_MOVT_PREL R_ARM
-pkg debug/elf, const R_ARM_MOVW_ABS_NC = 43
-pkg debug/elf, const R_ARM_MOVW_ABS_NC R_ARM
-pkg debug/elf, const R_ARM_MOVW_BREL = 86
-pkg debug/elf, const R_ARM_MOVW_BREL R_ARM
-pkg debug/elf, const R_ARM_MOVW_BREL_NC = 84
-pkg debug/elf, const R_ARM_MOVW_BREL_NC R_ARM
-pkg debug/elf, const R_ARM_MOVW_PREL_NC = 45
-pkg debug/elf, const R_ARM_MOVW_PREL_NC R_ARM
-pkg debug/elf, const R_ARM_PLT32_ABS = 94
-pkg debug/elf, const R_ARM_PLT32_ABS R_ARM
-pkg debug/elf, const R_ARM_PREL31 = 42
-pkg debug/elf, const R_ARM_PREL31 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_0 = 112
-pkg debug/elf, const R_ARM_PRIVATE_0 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_1 = 113
-pkg debug/elf, const R_ARM_PRIVATE_1 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_10 = 122
-pkg debug/elf, const R_ARM_PRIVATE_10 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_11 = 123
-pkg debug/elf, const R_ARM_PRIVATE_11 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_12 = 124
-pkg debug/elf, const R_ARM_PRIVATE_12 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_13 = 125
-pkg debug/elf, const R_ARM_PRIVATE_13 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_14 = 126
-pkg debug/elf, const R_ARM_PRIVATE_14 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_15 = 127
-pkg debug/elf, const R_ARM_PRIVATE_15 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_2 = 114
-pkg debug/elf, const R_ARM_PRIVATE_2 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_3 = 115
-pkg debug/elf, const R_ARM_PRIVATE_3 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_4 = 116
-pkg debug/elf, const R_ARM_PRIVATE_4 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_5 = 117
-pkg debug/elf, const R_ARM_PRIVATE_5 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_6 = 118
-pkg debug/elf, const R_ARM_PRIVATE_6 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_7 = 119
-pkg debug/elf, const R_ARM_PRIVATE_7 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_8 = 120
-pkg debug/elf, const R_ARM_PRIVATE_8 R_ARM
-pkg debug/elf, const R_ARM_PRIVATE_9 = 121
-pkg debug/elf, const R_ARM_PRIVATE_9 R_ARM
-pkg debug/elf, const R_ARM_REL32_NOI = 56
-pkg debug/elf, const R_ARM_REL32_NOI R_ARM
-pkg debug/elf, const R_ARM_RXPC25 = 249
-pkg debug/elf, const R_ARM_RXPC25 R_ARM
-pkg debug/elf, const R_ARM_SBREL31 = 39
-pkg debug/elf, const R_ARM_SBREL31 R_ARM
-pkg debug/elf, const R_ARM_TARGET1 = 38
-pkg debug/elf, const R_ARM_TARGET1 R_ARM
-pkg debug/elf, const R_ARM_TARGET2 = 41
-pkg debug/elf, const R_ARM_TARGET2 R_ARM
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G0_NC = 132
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G0_NC R_ARM
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G1_NC = 133
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G1_NC R_ARM
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G2_NC = 134
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G2_NC R_ARM
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G3 = 135
-pkg debug/elf, const R_ARM_THM_ALU_ABS_G3 R_ARM
-pkg debug/elf, const R_ARM_THM_ALU_PREL_11_0 = 53
-pkg debug/elf, const R_ARM_THM_ALU_PREL_11_0 R_ARM
-pkg debug/elf, const R_ARM_THM_GOT_BREL12 = 131
-pkg debug/elf, const R_ARM_THM_GOT_BREL12 R_ARM
-pkg debug/elf, const R_ARM_THM_JUMP11 = 102
-pkg debug/elf, const R_ARM_THM_JUMP11 R_ARM
-pkg debug/elf, const R_ARM_THM_JUMP19 = 51
-pkg debug/elf, const R_ARM_THM_JUMP19 R_ARM
-pkg debug/elf, const R_ARM_THM_JUMP24 = 30
-pkg debug/elf, const R_ARM_THM_JUMP24 R_ARM
-pkg debug/elf, const R_ARM_THM_JUMP6 = 52
-pkg debug/elf, const R_ARM_THM_JUMP6 R_ARM
-pkg debug/elf, const R_ARM_THM_JUMP8 = 103
-pkg debug/elf, const R_ARM_THM_JUMP8 R_ARM
-pkg debug/elf, const R_ARM_THM_MOVT_ABS = 48
-pkg debug/elf, const R_ARM_THM_MOVT_ABS R_ARM
-pkg debug/elf, const R_ARM_THM_MOVT_BREL = 88
-pkg debug/elf, const R_ARM_THM_MOVT_BREL R_ARM
-pkg debug/elf, const R_ARM_THM_MOVT_PREL = 50
-pkg debug/elf, const R_ARM_THM_MOVT_PREL R_ARM
-pkg debug/elf, const R_ARM_THM_MOVW_ABS_NC = 47
-pkg debug/elf, const R_ARM_THM_MOVW_ABS_NC R_ARM
-pkg debug/elf, const R_ARM_THM_MOVW_BREL = 89
-pkg debug/elf, const R_ARM_THM_MOVW_BREL R_ARM
-pkg debug/elf, const R_ARM_THM_MOVW_BREL_NC = 87
-pkg debug/elf, const R_ARM_THM_MOVW_BREL_NC R_ARM
-pkg debug/elf, const R_ARM_THM_MOVW_PREL_NC = 49
-pkg debug/elf, const R_ARM_THM_MOVW_PREL_NC R_ARM
-pkg debug/elf, const R_ARM_THM_PC12 = 54
-pkg debug/elf, const R_ARM_THM_PC12 R_ARM
-pkg debug/elf, const R_ARM_THM_TLS_CALL = 93
-pkg debug/elf, const R_ARM_THM_TLS_CALL R_ARM
-pkg debug/elf, const R_ARM_THM_TLS_DESCSEQ16 = 129
-pkg debug/elf, const R_ARM_THM_TLS_DESCSEQ16 R_ARM
-pkg debug/elf, const R_ARM_THM_TLS_DESCSEQ32 = 130
-pkg debug/elf, const R_ARM_THM_TLS_DESCSEQ32 R_ARM
-pkg debug/elf, const R_ARM_TLS_CALL = 91
-pkg debug/elf, const R_ARM_TLS_CALL R_ARM
-pkg debug/elf, const R_ARM_TLS_DESCSEQ = 92
-pkg debug/elf, const R_ARM_TLS_DESCSEQ R_ARM
-pkg debug/elf, const R_ARM_TLS_DTPMOD32 = 17
-pkg debug/elf, const R_ARM_TLS_DTPMOD32 R_ARM
-pkg debug/elf, const R_ARM_TLS_DTPOFF32 = 18
-pkg debug/elf, const R_ARM_TLS_DTPOFF32 R_ARM
-pkg debug/elf, const R_ARM_TLS_GD32 = 104
-pkg debug/elf, const R_ARM_TLS_GD32 R_ARM
-pkg debug/elf, const R_ARM_TLS_GOTDESC = 90
-pkg debug/elf, const R_ARM_TLS_GOTDESC R_ARM
-pkg debug/elf, const R_ARM_TLS_IE12GP = 111
-pkg debug/elf, const R_ARM_TLS_IE12GP R_ARM
-pkg debug/elf, const R_ARM_TLS_IE32 = 107
-pkg debug/elf, const R_ARM_TLS_IE32 R_ARM
-pkg debug/elf, const R_ARM_TLS_LDM32 = 105
-pkg debug/elf, const R_ARM_TLS_LDM32 R_ARM
-pkg debug/elf, const R_ARM_TLS_LDO12 = 109
-pkg debug/elf, const R_ARM_TLS_LDO12 R_ARM
-pkg debug/elf, const R_ARM_TLS_LDO32 = 106
-pkg debug/elf, const R_ARM_TLS_LDO32 R_ARM
-pkg debug/elf, const R_ARM_TLS_LE12 = 110
-pkg debug/elf, const R_ARM_TLS_LE12 R_ARM
-pkg debug/elf, const R_ARM_TLS_LE32 = 108
-pkg debug/elf, const R_ARM_TLS_LE32 R_ARM
-pkg debug/elf, const R_ARM_TLS_TPOFF32 = 19
-pkg debug/elf, const R_ARM_TLS_TPOFF32 R_ARM
-pkg debug/elf, const R_ARM_V4BX = 40
-pkg debug/elf, const R_ARM_V4BX R_ARM
-pkg debug/elf, const R_PPC64_ADDR16_HIGH = 110
-pkg debug/elf, const R_PPC64_ADDR16_HIGH R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HIGHA = 111
-pkg debug/elf, const R_PPC64_ADDR16_HIGHA R_PPC64
-pkg debug/elf, const R_PPC64_ADDR64_LOCAL = 117
-pkg debug/elf, const R_PPC64_ADDR64_LOCAL R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HIGH = 114
-pkg debug/elf, const R_PPC64_DTPREL16_HIGH R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHA = 115
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHA R_PPC64
-pkg debug/elf, const R_PPC64_ENTRY = 118
-pkg debug/elf, const R_PPC64_ENTRY R_PPC64
-pkg debug/elf, const R_PPC64_IRELATIVE = 248
-pkg debug/elf, const R_PPC64_IRELATIVE R_PPC64
-pkg debug/elf, const R_PPC64_JMP_IREL = 247
-pkg debug/elf, const R_PPC64_JMP_IREL R_PPC64
-pkg debug/elf, const R_PPC64_PLT16_LO_DS = 60
-pkg debug/elf, const R_PPC64_PLT16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_PLTGOT16 = 52
-pkg debug/elf, const R_PPC64_PLTGOT16 R_PPC64
-pkg debug/elf, const R_PPC64_PLTGOT16_DS = 65
-pkg debug/elf, const R_PPC64_PLTGOT16_DS R_PPC64
-pkg debug/elf, const R_PPC64_PLTGOT16_HA = 55
-pkg debug/elf, const R_PPC64_PLTGOT16_HA R_PPC64
-pkg debug/elf, const R_PPC64_PLTGOT16_HI = 54
-pkg debug/elf, const R_PPC64_PLTGOT16_HI R_PPC64
-pkg debug/elf, const R_PPC64_PLTGOT16_LO = 53
-pkg debug/elf, const R_PPC64_PLTGOT16_LO R_PPC64
-pkg debug/elf, const R_PPC64_PLTGOT_LO_DS = 66
-pkg debug/elf, const R_PPC64_PLTGOT_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_REL16DX_HA = 246
-pkg debug/elf, const R_PPC64_REL16DX_HA R_PPC64
-pkg debug/elf, const R_PPC64_REL24_NOTOC = 116
-pkg debug/elf, const R_PPC64_REL24_NOTOC R_PPC64
-pkg debug/elf, const R_PPC64_SECTOFF_DS = 61
-pkg debug/elf, const R_PPC64_SECTOFF_DS R_PPC64
-pkg debug/elf, const R_PPC64_SECTOFF_LO_DS = 61
-pkg debug/elf, const R_PPC64_SECTOFF_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_TOCSAVE = 109
-pkg debug/elf, const R_PPC64_TOCSAVE R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HIGH = 112
-pkg debug/elf, const R_PPC64_TPREL16_HIGH R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HIGHA = 113
-pkg debug/elf, const R_PPC64_TPREL16_HIGHA R_PPC64
-pkg debug/elf, const R_X86_64_GOT64 = 27
-pkg debug/elf, const R_X86_64_GOT64 R_X86_64
-pkg debug/elf, const R_X86_64_GOTOFF64 = 25
-pkg debug/elf, const R_X86_64_GOTOFF64 R_X86_64
-pkg debug/elf, const R_X86_64_GOTPC32 = 26
-pkg debug/elf, const R_X86_64_GOTPC32 R_X86_64
-pkg debug/elf, const R_X86_64_GOTPC32_TLSDESC = 34
-pkg debug/elf, const R_X86_64_GOTPC32_TLSDESC R_X86_64
-pkg debug/elf, const R_X86_64_GOTPC64 = 29
-pkg debug/elf, const R_X86_64_GOTPC64 R_X86_64
-pkg debug/elf, const R_X86_64_GOTPCREL64 = 28
-pkg debug/elf, const R_X86_64_GOTPCREL64 R_X86_64
-pkg debug/elf, const R_X86_64_GOTPCRELX = 41
-pkg debug/elf, const R_X86_64_GOTPCRELX R_X86_64
-pkg debug/elf, const R_X86_64_GOTPLT64 = 30
-pkg debug/elf, const R_X86_64_GOTPLT64 R_X86_64
-pkg debug/elf, const R_X86_64_IRELATIVE = 37
-pkg debug/elf, const R_X86_64_IRELATIVE R_X86_64
-pkg debug/elf, const R_X86_64_PC32_BND = 39
-pkg debug/elf, const R_X86_64_PC32_BND R_X86_64
-pkg debug/elf, const R_X86_64_PC64 = 24
-pkg debug/elf, const R_X86_64_PC64 R_X86_64
-pkg debug/elf, const R_X86_64_PLT32_BND = 40
-pkg debug/elf, const R_X86_64_PLT32_BND R_X86_64
-pkg debug/elf, const R_X86_64_PLTOFF64 = 31
-pkg debug/elf, const R_X86_64_PLTOFF64 R_X86_64
-pkg debug/elf, const R_X86_64_RELATIVE64 = 38
-pkg debug/elf, const R_X86_64_RELATIVE64 R_X86_64
-pkg debug/elf, const R_X86_64_REX_GOTPCRELX = 42
-pkg debug/elf, const R_X86_64_REX_GOTPCRELX R_X86_64
-pkg debug/elf, const R_X86_64_SIZE32 = 32
-pkg debug/elf, const R_X86_64_SIZE32 R_X86_64
-pkg debug/elf, const R_X86_64_SIZE64 = 33
-pkg debug/elf, const R_X86_64_SIZE64 R_X86_64
-pkg debug/elf, const R_X86_64_TLSDESC = 36
-pkg debug/elf, const R_X86_64_TLSDESC R_X86_64
-pkg debug/elf, const R_X86_64_TLSDESC_CALL = 35
-pkg debug/elf, const R_X86_64_TLSDESC_CALL R_X86_64
-pkg debug/macho, const ARM64_RELOC_ADDEND = 10
-pkg debug/macho, const ARM64_RELOC_ADDEND RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_BRANCH26 = 2
-pkg debug/macho, const ARM64_RELOC_BRANCH26 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_GOT_LOAD_PAGE21 = 5
-pkg debug/macho, const ARM64_RELOC_GOT_LOAD_PAGE21 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_GOT_LOAD_PAGEOFF12 = 6
-pkg debug/macho, const ARM64_RELOC_GOT_LOAD_PAGEOFF12 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_PAGE21 = 3
-pkg debug/macho, const ARM64_RELOC_PAGE21 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_PAGEOFF12 = 4
-pkg debug/macho, const ARM64_RELOC_PAGEOFF12 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_POINTER_TO_GOT = 7
-pkg debug/macho, const ARM64_RELOC_POINTER_TO_GOT RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_SUBTRACTOR = 1
-pkg debug/macho, const ARM64_RELOC_SUBTRACTOR RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_TLVP_LOAD_PAGE21 = 8
-pkg debug/macho, const ARM64_RELOC_TLVP_LOAD_PAGE21 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_TLVP_LOAD_PAGEOFF12 = 9
-pkg debug/macho, const ARM64_RELOC_TLVP_LOAD_PAGEOFF12 RelocTypeARM64
-pkg debug/macho, const ARM64_RELOC_UNSIGNED = 0
-pkg debug/macho, const ARM64_RELOC_UNSIGNED RelocTypeARM64
-pkg debug/macho, const ARM_RELOC_BR24 = 5
-pkg debug/macho, const ARM_RELOC_BR24 RelocTypeARM
-pkg debug/macho, const ARM_RELOC_HALF = 8
-pkg debug/macho, const ARM_RELOC_HALF RelocTypeARM
-pkg debug/macho, const ARM_RELOC_HALF_SECTDIFF = 9
-pkg debug/macho, const ARM_RELOC_HALF_SECTDIFF RelocTypeARM
-pkg debug/macho, const ARM_RELOC_LOCAL_SECTDIFF = 3
-pkg debug/macho, const ARM_RELOC_LOCAL_SECTDIFF RelocTypeARM
-pkg debug/macho, const ARM_RELOC_PAIR = 1
-pkg debug/macho, const ARM_RELOC_PAIR RelocTypeARM
-pkg debug/macho, const ARM_RELOC_PB_LA_PTR = 4
-pkg debug/macho, const ARM_RELOC_PB_LA_PTR RelocTypeARM
-pkg debug/macho, const ARM_RELOC_SECTDIFF = 2
-pkg debug/macho, const ARM_RELOC_SECTDIFF RelocTypeARM
-pkg debug/macho, const ARM_RELOC_VANILLA = 0
-pkg debug/macho, const ARM_RELOC_VANILLA RelocTypeARM
-pkg debug/macho, const ARM_THUMB_32BIT_BRANCH = 7
-pkg debug/macho, const ARM_THUMB_32BIT_BRANCH RelocTypeARM
-pkg debug/macho, const ARM_THUMB_RELOC_BR22 = 6
-pkg debug/macho, const ARM_THUMB_RELOC_BR22 RelocTypeARM
-pkg debug/macho, const FlagAllModsBound = 4096
-pkg debug/macho, const FlagAllModsBound uint32
-pkg debug/macho, const FlagAllowStackExecution = 131072
-pkg debug/macho, const FlagAllowStackExecution uint32
-pkg debug/macho, const FlagAppExtensionSafe = 33554432
-pkg debug/macho, const FlagAppExtensionSafe uint32
-pkg debug/macho, const FlagBindAtLoad = 8
-pkg debug/macho, const FlagBindAtLoad uint32
-pkg debug/macho, const FlagBindsToWeak = 65536
-pkg debug/macho, const FlagBindsToWeak uint32
-pkg debug/macho, const FlagCanonical = 16384
-pkg debug/macho, const FlagCanonical uint32
-pkg debug/macho, const FlagDeadStrippableDylib = 4194304
-pkg debug/macho, const FlagDeadStrippableDylib uint32
-pkg debug/macho, const FlagDyldLink = 4
-pkg debug/macho, const FlagDyldLink uint32
-pkg debug/macho, const FlagForceFlat = 256
-pkg debug/macho, const FlagForceFlat uint32
-pkg debug/macho, const FlagHasTLVDescriptors = 8388608
-pkg debug/macho, const FlagHasTLVDescriptors uint32
-pkg debug/macho, const FlagIncrLink = 2
-pkg debug/macho, const FlagIncrLink uint32
-pkg debug/macho, const FlagLazyInit = 64
-pkg debug/macho, const FlagLazyInit uint32
-pkg debug/macho, const FlagNoFixPrebinding = 1024
-pkg debug/macho, const FlagNoFixPrebinding uint32
-pkg debug/macho, const FlagNoHeapExecution = 16777216
-pkg debug/macho, const FlagNoHeapExecution uint32
-pkg debug/macho, const FlagNoMultiDefs = 512
-pkg debug/macho, const FlagNoMultiDefs uint32
-pkg debug/macho, const FlagNoReexportedDylibs = 1048576
-pkg debug/macho, const FlagNoReexportedDylibs uint32
-pkg debug/macho, const FlagNoUndefs = 1
-pkg debug/macho, const FlagNoUndefs uint32
-pkg debug/macho, const FlagPIE = 2097152
-pkg debug/macho, const FlagPIE uint32
-pkg debug/macho, const FlagPrebindable = 2048
-pkg debug/macho, const FlagPrebindable uint32
-pkg debug/macho, const FlagPrebound = 16
-pkg debug/macho, const FlagPrebound uint32
-pkg debug/macho, const FlagRootSafe = 262144
-pkg debug/macho, const FlagRootSafe uint32
-pkg debug/macho, const FlagSetuidSafe = 524288
-pkg debug/macho, const FlagSetuidSafe uint32
-pkg debug/macho, const FlagSplitSegs = 32
-pkg debug/macho, const FlagSplitSegs uint32
-pkg debug/macho, const FlagSubsectionsViaSymbols = 8192
-pkg debug/macho, const FlagSubsectionsViaSymbols uint32
-pkg debug/macho, const FlagTwoLevel = 128
-pkg debug/macho, const FlagTwoLevel uint32
-pkg debug/macho, const FlagWeakDefines = 32768
-pkg debug/macho, const FlagWeakDefines uint32
-pkg debug/macho, const GENERIC_RELOC_LOCAL_SECTDIFF = 4
-pkg debug/macho, const GENERIC_RELOC_LOCAL_SECTDIFF RelocTypeGeneric
-pkg debug/macho, const GENERIC_RELOC_PAIR = 1
-pkg debug/macho, const GENERIC_RELOC_PAIR RelocTypeGeneric
-pkg debug/macho, const GENERIC_RELOC_PB_LA_PTR = 3
-pkg debug/macho, const GENERIC_RELOC_PB_LA_PTR RelocTypeGeneric
-pkg debug/macho, const GENERIC_RELOC_SECTDIFF = 2
-pkg debug/macho, const GENERIC_RELOC_SECTDIFF RelocTypeGeneric
-pkg debug/macho, const GENERIC_RELOC_TLV = 5
-pkg debug/macho, const GENERIC_RELOC_TLV RelocTypeGeneric
-pkg debug/macho, const GENERIC_RELOC_VANILLA = 0
-pkg debug/macho, const GENERIC_RELOC_VANILLA RelocTypeGeneric
-pkg debug/macho, const LoadCmdRpath = 2147483676
-pkg debug/macho, const LoadCmdRpath LoadCmd
-pkg debug/macho, const X86_64_RELOC_BRANCH = 2
-pkg debug/macho, const X86_64_RELOC_BRANCH RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_GOT = 4
-pkg debug/macho, const X86_64_RELOC_GOT RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_GOT_LOAD = 3
-pkg debug/macho, const X86_64_RELOC_GOT_LOAD RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_SIGNED = 1
-pkg debug/macho, const X86_64_RELOC_SIGNED RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_SIGNED_1 = 6
-pkg debug/macho, const X86_64_RELOC_SIGNED_1 RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_SIGNED_2 = 7
-pkg debug/macho, const X86_64_RELOC_SIGNED_2 RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_SIGNED_4 = 8
-pkg debug/macho, const X86_64_RELOC_SIGNED_4 RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_SUBTRACTOR = 5
-pkg debug/macho, const X86_64_RELOC_SUBTRACTOR RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_TLV = 9
-pkg debug/macho, const X86_64_RELOC_TLV RelocTypeX86_64
-pkg debug/macho, const X86_64_RELOC_UNSIGNED = 0
-pkg debug/macho, const X86_64_RELOC_UNSIGNED RelocTypeX86_64
-pkg debug/macho, method (RelocTypeARM) GoString() string
-pkg debug/macho, method (RelocTypeARM) String() string
-pkg debug/macho, method (RelocTypeARM64) GoString() string
-pkg debug/macho, method (RelocTypeARM64) String() string
-pkg debug/macho, method (RelocTypeGeneric) GoString() string
-pkg debug/macho, method (RelocTypeGeneric) String() string
-pkg debug/macho, method (RelocTypeX86_64) GoString() string
-pkg debug/macho, method (RelocTypeX86_64) String() string
-pkg debug/macho, method (Rpath) Raw() []uint8
-pkg debug/macho, method (Type) GoString() string
-pkg debug/macho, method (Type) String() string
-pkg debug/macho, type Reloc struct
-pkg debug/macho, type Reloc struct, Addr uint32
-pkg debug/macho, type Reloc struct, Extern bool
-pkg debug/macho, type Reloc struct, Len uint8
-pkg debug/macho, type Reloc struct, Pcrel bool
-pkg debug/macho, type Reloc struct, Scattered bool
-pkg debug/macho, type Reloc struct, Type uint8
-pkg debug/macho, type Reloc struct, Value uint32
-pkg debug/macho, type RelocTypeARM int
-pkg debug/macho, type RelocTypeARM64 int
-pkg debug/macho, type RelocTypeGeneric int
-pkg debug/macho, type RelocTypeX86_64 int
-pkg debug/macho, type Rpath struct
-pkg debug/macho, type Rpath struct, Path string
-pkg debug/macho, type Rpath struct, embedded LoadBytes
-pkg debug/macho, type RpathCmd struct
-pkg debug/macho, type RpathCmd struct, Cmd LoadCmd
-pkg debug/macho, type RpathCmd struct, Len uint32
-pkg debug/macho, type RpathCmd struct, Path uint32
-pkg debug/macho, type Section struct, Relocs []Reloc
-pkg encoding/asn1, const TagNumericString = 18
-pkg encoding/asn1, const TagNumericString ideal-int
-pkg encoding/asn1, func MarshalWithParams(interface{}, string) ([]uint8, error)
-pkg encoding/csv, type ParseError struct, StartLine int
-pkg encoding/hex, func NewDecoder(io.Reader) io.Reader
-pkg encoding/hex, func NewEncoder(io.Writer) io.Writer
-pkg encoding/json, method (*Decoder) DisallowUnknownFields()
-pkg encoding/xml, func NewTokenDecoder(TokenReader) *Decoder
-pkg encoding/xml, type TokenReader interface { Token }
-pkg encoding/xml, type TokenReader interface, Token() (Token, error)
-pkg flag, method (*FlagSet) ErrorHandling() ErrorHandling
-pkg flag, method (*FlagSet) Name() string
-pkg flag, method (*FlagSet) Output() io.Writer
-pkg html/template, type Srcset string
-pkg math, func Erfcinv(float64) float64
-pkg math, func Erfinv(float64) float64
-pkg math, func Round(float64) float64
-pkg math, func RoundToEven(float64) float64
-pkg math/big, const MaxBase = 62
-pkg math/big, method (*Float) Sqrt(*Float) *Float
-pkg math/big, method (*Int) CmpAbs(*Int) int
-pkg math/rand, func Shuffle(int, func(int, int))
-pkg math/rand, method (*Rand) Shuffle(int, func(int, int))
-pkg net, method (*TCPListener) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*UnixListener) SyscallConn() (syscall.RawConn, error)
-pkg net/smtp, method (*Client) Noop() error
-pkg os, func IsTimeout(error) bool
-pkg os, method (*File) SetDeadline(time.Time) error
-pkg os, method (*File) SetReadDeadline(time.Time) error
-pkg os, method (*File) SetWriteDeadline(time.Time) error
-pkg os, method (*PathError) Timeout() bool
-pkg os, method (*SyscallError) Timeout() bool
-pkg os, var ErrNoDeadline error
-pkg strings, method (*Builder) Grow(int)
-pkg strings, method (*Builder) Len() int
-pkg strings, method (*Builder) Reset()
-pkg strings, method (*Builder) String() string
-pkg strings, method (*Builder) Write([]uint8) (int, error)
-pkg strings, method (*Builder) WriteByte(uint8) error
-pkg strings, method (*Builder) WriteRune(int32) (int, error)
-pkg strings, method (*Builder) WriteString(string) (int, error)
-pkg strings, type Builder struct
-pkg syscall (freebsd-386), const SYS_UTIMENSAT = 547
-pkg syscall (freebsd-386), const SYS_UTIMENSAT ideal-int
-pkg syscall (freebsd-386-cgo), const SYS_UTIMENSAT = 547
-pkg syscall (freebsd-386-cgo), const SYS_UTIMENSAT ideal-int
-pkg syscall (freebsd-amd64), const SYS_UTIMENSAT = 547
-pkg syscall (freebsd-amd64), const SYS_UTIMENSAT ideal-int
-pkg syscall (freebsd-amd64-cgo), const SYS_UTIMENSAT = 547
-pkg syscall (freebsd-amd64-cgo), const SYS_UTIMENSAT ideal-int
-pkg syscall (freebsd-arm), const SYS_UTIMENSAT = 547
-pkg syscall (freebsd-arm), const SYS_UTIMENSAT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_UTIMENSAT = 547
-pkg syscall (freebsd-arm-cgo), const SYS_UTIMENSAT ideal-int
-pkg syscall (windows-386), func CreateProcessAsUser(Token, *uint16, *uint16, *SecurityAttributes, *SecurityAttributes, bool, uint32, *uint16, *uint16, *StartupInfo, *ProcessInformation) error
-pkg syscall (windows-386), type SysProcAttr struct, Token Token
-pkg syscall (windows-amd64), func CreateProcessAsUser(Token, *uint16, *uint16, *SecurityAttributes, *SecurityAttributes, bool, uint32, *uint16, *uint16, *StartupInfo, *ProcessInformation) error
-pkg syscall (windows-amd64), type SysProcAttr struct, Token Token
-pkg text/template/parse, const NodeBreak = 20
-pkg text/template/parse, const NodeBreak NodeType
-pkg text/template/parse, const NodeContinue = 21
-pkg text/template/parse, const NodeContinue NodeType
-pkg text/template/parse, method (*BreakNode) Copy() Node
-pkg text/template/parse, method (*BreakNode) Position() Pos
-pkg text/template/parse, method (*BreakNode) String() string
-pkg text/template/parse, method (*BreakNode) Type() NodeType
-pkg text/template/parse, method (*ContinueNode) Copy() Node
-pkg text/template/parse, method (*ContinueNode) Position() Pos
-pkg text/template/parse, method (*ContinueNode) String() string
-pkg text/template/parse, method (*ContinueNode) Type() NodeType
-pkg text/template/parse, type BreakNode struct
-pkg text/template/parse, type BreakNode struct, embedded NodeType
-pkg text/template/parse, type BreakNode struct, embedded Pos
-pkg text/template/parse, type ContinueNode struct
-pkg text/template/parse, type ContinueNode struct, embedded NodeType
-pkg text/template/parse, type ContinueNode struct, embedded Pos
-pkg time, func LoadLocationFromTZData(string, []uint8) (*Location, error)
-pkg unicode, const Version = "10.0.0"
-pkg unicode, var Masaram_Gondi *RangeTable
-pkg unicode, var Nushu *RangeTable
-pkg unicode, var Regional_Indicator *RangeTable
-pkg unicode, var Soyombo *RangeTable
-pkg unicode, var Zanabazar_Square *RangeTable
--- a/api/go1.8.txt
+++ b/api/go1.8.txt
@@ -1,261 +0,0 @@
-pkg compress/gzip, const HuffmanOnly = -2
-pkg compress/gzip, const HuffmanOnly ideal-int
-pkg compress/zlib, const HuffmanOnly = -2
-pkg compress/zlib, const HuffmanOnly ideal-int
-pkg crypto/tls, const ECDSAWithP256AndSHA256 = 1027
-pkg crypto/tls, const ECDSAWithP256AndSHA256 SignatureScheme
-pkg crypto/tls, const ECDSAWithP384AndSHA384 = 1283
-pkg crypto/tls, const ECDSAWithP384AndSHA384 SignatureScheme
-pkg crypto/tls, const ECDSAWithP521AndSHA512 = 1539
-pkg crypto/tls, const ECDSAWithP521AndSHA512 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA1 = 513
-pkg crypto/tls, const PKCS1WithSHA1 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA256 = 1025
-pkg crypto/tls, const PKCS1WithSHA256 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA384 = 1281
-pkg crypto/tls, const PKCS1WithSHA384 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA512 = 1537
-pkg crypto/tls, const PKCS1WithSHA512 SignatureScheme
-pkg crypto/tls, const PSSWithSHA256 = 2052
-pkg crypto/tls, const PSSWithSHA256 SignatureScheme
-pkg crypto/tls, const PSSWithSHA384 = 2053
-pkg crypto/tls, const PSSWithSHA384 SignatureScheme
-pkg crypto/tls, const PSSWithSHA512 = 2054
-pkg crypto/tls, const PSSWithSHA512 SignatureScheme
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 49187
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 = 52393
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 49191
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 = 52392
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 uint16
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 = 60
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const X25519 = 29
-pkg crypto/tls, const X25519 CurveID
-pkg crypto/tls, method (*Config) Clone() *Config
-pkg crypto/tls, method (*Conn) CloseWrite() error
-pkg crypto/tls, type CertificateRequestInfo struct
-pkg crypto/tls, type CertificateRequestInfo struct, AcceptableCAs [][]uint8
-pkg crypto/tls, type CertificateRequestInfo struct, SignatureSchemes []SignatureScheme
-pkg crypto/tls, type ClientHelloInfo struct, Conn net.Conn
-pkg crypto/tls, type ClientHelloInfo struct, SignatureSchemes []SignatureScheme
-pkg crypto/tls, type ClientHelloInfo struct, SupportedProtos []string
-pkg crypto/tls, type ClientHelloInfo struct, SupportedVersions []uint16
-pkg crypto/tls, type Config struct, GetClientCertificate func(*CertificateRequestInfo) (*Certificate, error)
-pkg crypto/tls, type Config struct, GetConfigForClient func(*ClientHelloInfo) (*Config, error)
-pkg crypto/tls, type Config struct, KeyLogWriter io.Writer
-pkg crypto/tls, type Config struct, VerifyPeerCertificate func([][]uint8, [][]*x509.Certificate) error
-pkg crypto/tls, type SignatureScheme uint16
-pkg crypto/x509, const NameMismatch = 5
-pkg crypto/x509, const NameMismatch InvalidReason
-pkg crypto/x509, const SHA256WithRSAPSS = 13
-pkg crypto/x509, const SHA256WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, const SHA384WithRSAPSS = 14
-pkg crypto/x509, const SHA384WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, const SHA512WithRSAPSS = 15
-pkg crypto/x509, const SHA512WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, type UnknownAuthorityError struct, Cert *Certificate
-pkg database/sql, const LevelDefault = 0
-pkg database/sql, const LevelDefault IsolationLevel
-pkg database/sql, const LevelLinearizable = 7
-pkg database/sql, const LevelLinearizable IsolationLevel
-pkg database/sql, const LevelReadCommitted = 2
-pkg database/sql, const LevelReadCommitted IsolationLevel
-pkg database/sql, const LevelReadUncommitted = 1
-pkg database/sql, const LevelReadUncommitted IsolationLevel
-pkg database/sql, const LevelRepeatableRead = 4
-pkg database/sql, const LevelRepeatableRead IsolationLevel
-pkg database/sql, const LevelSerializable = 6
-pkg database/sql, const LevelSerializable IsolationLevel
-pkg database/sql, const LevelSnapshot = 5
-pkg database/sql, const LevelSnapshot IsolationLevel
-pkg database/sql, const LevelWriteCommitted = 3
-pkg database/sql, const LevelWriteCommitted IsolationLevel
-pkg database/sql/driver, type ConnBeginTx interface { BeginTx }
-pkg database/sql/driver, type ConnBeginTx interface, BeginTx(context.Context, TxOptions) (Tx, error)
-pkg database/sql/driver, type ConnPrepareContext interface { PrepareContext }
-pkg database/sql/driver, type ConnPrepareContext interface, PrepareContext(context.Context, string) (Stmt, error)
-pkg database/sql/driver, type ExecerContext interface { ExecContext }
-pkg database/sql/driver, type ExecerContext interface, ExecContext(context.Context, string, []NamedValue) (Result, error)
-pkg database/sql/driver, type IsolationLevel int
-pkg database/sql/driver, type NamedValue struct
-pkg database/sql/driver, type NamedValue struct, Name string
-pkg database/sql/driver, type NamedValue struct, Ordinal int
-pkg database/sql/driver, type NamedValue struct, Value Value
-pkg database/sql/driver, type Pinger interface { Ping }
-pkg database/sql/driver, type Pinger interface, Ping(context.Context) error
-pkg database/sql/driver, type QueryerContext interface { QueryContext }
-pkg database/sql/driver, type QueryerContext interface, QueryContext(context.Context, string, []NamedValue) (Rows, error)
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface { Close, ColumnTypeDatabaseTypeName, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, ColumnTypeDatabaseTypeName(int) string
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeLength interface { Close, ColumnTypeLength, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeLength interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeLength interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeLength interface, ColumnTypeLength(int) (int64, bool)
-pkg database/sql/driver, type RowsColumnTypeLength interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeNullable interface { Close, ColumnTypeNullable, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeNullable interface, ColumnTypeNullable(int) (bool, bool)
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface { Close, ColumnTypePrecisionScale, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Close() error
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, ColumnTypePrecisionScale(int) (int64, int64, bool)
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeScanType interface { Close, ColumnTypeScanType, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeScanType interface, ColumnTypeScanType(int) reflect.Type
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Next([]Value) error
-pkg database/sql/driver, type RowsNextResultSet interface { Close, Columns, HasNextResultSet, Next, NextResultSet }
-pkg database/sql/driver, type RowsNextResultSet interface, Close() error
-pkg database/sql/driver, type RowsNextResultSet interface, Columns() []string
-pkg database/sql/driver, type RowsNextResultSet interface, HasNextResultSet() bool
-pkg database/sql/driver, type RowsNextResultSet interface, NextResultSet() error
-pkg database/sql/driver, type RowsNextResultSet interface, Next([]Value) error
-pkg database/sql/driver, type StmtExecContext interface { ExecContext }
-pkg database/sql/driver, type StmtExecContext interface, ExecContext(context.Context, []NamedValue) (Result, error)
-pkg database/sql/driver, type StmtQueryContext interface { QueryContext }
-pkg database/sql/driver, type StmtQueryContext interface, QueryContext(context.Context, []NamedValue) (Rows, error)
-pkg database/sql/driver, type TxOptions struct
-pkg database/sql/driver, type TxOptions struct, Isolation IsolationLevel
-pkg database/sql/driver, type TxOptions struct, ReadOnly bool
-pkg database/sql, func Named(string, interface{}) NamedArg
-pkg database/sql, method (*ColumnType) DatabaseTypeName() string
-pkg database/sql, method (*ColumnType) DecimalSize() (int64, int64, bool)
-pkg database/sql, method (*ColumnType) Length() (int64, bool)
-pkg database/sql, method (*ColumnType) Name() string
-pkg database/sql, method (*ColumnType) Nullable() (bool, bool)
-pkg database/sql, method (*ColumnType) ScanType() reflect.Type
-pkg database/sql, method (*DB) BeginTx(context.Context, *TxOptions) (*Tx, error)
-pkg database/sql, method (*DB) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*DB) PingContext(context.Context) error
-pkg database/sql, method (*DB) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*DB) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*DB) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*Rows) ColumnTypes() ([]*ColumnType, error)
-pkg database/sql, method (*Rows) NextResultSet() bool
-pkg database/sql, method (*Stmt) ExecContext(context.Context, ...interface{}) (Result, error)
-pkg database/sql, method (*Stmt) QueryContext(context.Context, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Stmt) QueryRowContext(context.Context, ...interface{}) *Row
-pkg database/sql, method (*Tx) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*Tx) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*Tx) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Tx) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*Tx) StmtContext(context.Context, *Stmt) *Stmt
-pkg database/sql, type ColumnType struct
-pkg database/sql, type IsolationLevel int
-pkg database/sql, type NamedArg struct
-pkg database/sql, type NamedArg struct, Name string
-pkg database/sql, type NamedArg struct, Value interface{}
-pkg database/sql, type TxOptions struct
-pkg database/sql, type TxOptions struct, Isolation IsolationLevel
-pkg database/sql, type TxOptions struct, ReadOnly bool
-pkg debug/pe, method (*COFFSymbol) FullName(StringTable) (string, error)
-pkg debug/pe, method (StringTable) String(uint32) (string, error)
-pkg debug/pe, type File struct, COFFSymbols []COFFSymbol
-pkg debug/pe, type File struct, StringTable StringTable
-pkg debug/pe, type Reloc struct
-pkg debug/pe, type Reloc struct, SymbolTableIndex uint32
-pkg debug/pe, type Reloc struct, Type uint16
-pkg debug/pe, type Reloc struct, VirtualAddress uint32
-pkg debug/pe, type Section struct, Relocs []Reloc
-pkg debug/pe, type StringTable []uint8
-pkg encoding/base64, method (Encoding) Strict() *Encoding
-pkg encoding/json, method (RawMessage) MarshalJSON() ([]uint8, error)
-pkg encoding/json, type UnmarshalTypeError struct, Field string
-pkg encoding/json, type UnmarshalTypeError struct, Struct string
-pkg expvar, func Handler() http.Handler
-pkg expvar, method (*Float) Value() float64
-pkg expvar, method (Func) Value() interface{}
-pkg expvar, method (*Int) Value() int64
-pkg expvar, method (*String) Value() string
-pkg go/doc, func IsPredeclared(string) bool
-pkg go/types, func Default(Type) Type
-pkg go/types, func IdenticalIgnoreTags(Type, Type) bool
-pkg math/big, method (*Float) Scan(fmt.ScanState, int32) error
-pkg math/big, method (*Int) Sqrt(*Int) *Int
-pkg math/rand, func Uint64() uint64
-pkg math/rand, method (*Rand) Uint64() uint64
-pkg math/rand, type Source64 interface, Int63() int64
-pkg math/rand, type Source64 interface { Int63, Seed, Uint64 }
-pkg math/rand, type Source64 interface, Seed(int64)
-pkg math/rand, type Source64 interface, Uint64() uint64
-pkg net/http, const TrailerPrefix ideal-string
-pkg net/http, const TrailerPrefix = "Trailer:"
-pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeDone func(tls.ConnectionState, error)
-pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeStart func()
-pkg net/http/httputil, type ReverseProxy struct, ModifyResponse func(*http.Response) error
-pkg net/http, method (*Server) Close() error
-pkg net/http, method (*Server) Shutdown(context.Context) error
-pkg net/http, type Pusher interface { Push }
-pkg net/http, type Pusher interface, Push(string, *PushOptions) error
-pkg net/http, type PushOptions struct
-pkg net/http, type PushOptions struct, Header Header
-pkg net/http, type PushOptions struct, Method string
-pkg net/http, type Request struct, GetBody func() (io.ReadCloser, error)
-pkg net/http, type Server struct, IdleTimeout time.Duration
-pkg net/http, type Server struct, ReadHeaderTimeout time.Duration
-pkg net/http, type Transport struct, ProxyConnectHeader Header
-pkg net/http, var ErrAbortHandler error
-pkg net/http, var ErrServerClosed error
-pkg net/http, var NoBody noBody
-pkg net/mail, func ParseDate(string) (time.Time, error)
-pkg net, method (*Buffers) Read([]uint8) (int, error)
-pkg net, method (*Buffers) WriteTo(io.Writer) (int64, error)
-pkg net, method (*Resolver) LookupAddr(context.Context, string) ([]string, error)
-pkg net, method (*Resolver) LookupCNAME(context.Context, string) (string, error)
-pkg net, method (*Resolver) LookupHost(context.Context, string) ([]string, error)
-pkg net, method (*Resolver) LookupIPAddr(context.Context, string) ([]IPAddr, error)
-pkg net, method (*Resolver) LookupMX(context.Context, string) ([]*MX, error)
-pkg net, method (*Resolver) LookupNS(context.Context, string) ([]*NS, error)
-pkg net, method (*Resolver) LookupPort(context.Context, string, string) (int, error)
-pkg net, method (*Resolver) LookupSRV(context.Context, string, string, string) (string, []*SRV, error)
-pkg net, method (*Resolver) LookupTXT(context.Context, string) ([]string, error)
-pkg net, method (*UnixListener) SetUnlinkOnClose(bool)
-pkg net, type Buffers [][]uint8
-pkg net, type Dialer struct, Resolver *Resolver
-pkg net, type Resolver struct
-pkg net, type Resolver struct, PreferGo bool
-pkg net/url, func PathEscape(string) string
-pkg net/url, func PathUnescape(string) (string, error)
-pkg net/url, method (*URL) Hostname() string
-pkg net/url, method (*URL) MarshalBinary() ([]uint8, error)
-pkg net/url, method (*URL) Port() string
-pkg net/url, method (*URL) UnmarshalBinary([]uint8) error
-pkg net, var DefaultResolver *Resolver
-pkg os, func Executable() (string, error)
-pkg os, var ErrClosed error
-pkg plugin, func Open(string) (*Plugin, error)
-pkg plugin, method (*Plugin) Lookup(string) (Symbol, error)
-pkg plugin, type Plugin struct
-pkg plugin, type Symbol interface {}
-pkg reflect, func Swapper(interface{}) func(int, int)
-pkg runtime, func MutexProfile([]BlockProfileRecord) (int, bool)
-pkg runtime, func SetMutexProfileFraction(int) int
-pkg runtime, type MemStats struct, NumForcedGC uint32
-pkg sort, func Slice(interface{}, func(int, int) bool)
-pkg sort, func SliceIsSorted(interface{}, func(int, int) bool) bool
-pkg sort, func SliceStable(interface{}, func(int, int) bool)
-pkg syscall (linux-arm-cgo), func TimevalToNsec(Timeval) int64
-pkg syscall (linux-arm), func TimevalToNsec(Timeval) int64
-pkg syscall (openbsd-386), const SYS_KILL = 122
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 122
-pkg syscall (openbsd-amd64), const SYS_KILL = 122
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 122
-pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY = 145
-pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY Errno
-pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY = 145
-pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY Errno
-pkg testing, func CoverMode() string
-pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg testing, method (*B) Name() string
-pkg testing, method (*T) Name() string
-pkg testing, type TB interface, Name() string
-pkg time, func Until(Time) Duration
--- a/api/go1.9.txt
+++ b/api/go1.9.txt
@@ -1,169 +0,0 @@
-pkg crypto, const BLAKE2b_256 = 17
-pkg crypto, const BLAKE2b_256 Hash
-pkg crypto, const BLAKE2b_384 = 18
-pkg crypto, const BLAKE2b_384 Hash
-pkg crypto, const BLAKE2b_512 = 19
-pkg crypto, const BLAKE2b_512 Hash
-pkg crypto, const BLAKE2s_256 = 16
-pkg crypto, const BLAKE2s_256 Hash
-pkg crypto/x509, type Certificate struct, ExcludedDNSDomains []string
-pkg database/sql, method (*Conn) BeginTx(context.Context, *TxOptions) (*Tx, error)
-pkg database/sql, method (*Conn) Close() error
-pkg database/sql, method (*Conn) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*Conn) PingContext(context.Context) error
-pkg database/sql, method (*Conn) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*Conn) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Conn) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*DB) Conn(context.Context) (*Conn, error)
-pkg database/sql, type Conn struct
-pkg database/sql, type Out struct
-pkg database/sql, type Out struct, Dest interface{}
-pkg database/sql, type Out struct, In bool
-pkg database/sql, var ErrConnDone error
-pkg database/sql/driver, type NamedValueChecker interface { CheckNamedValue }
-pkg database/sql/driver, type NamedValueChecker interface, CheckNamedValue(*NamedValue) error
-pkg database/sql/driver, var ErrRemoveArgument error
-pkg encoding/asn1, const TagNull = 5
-pkg encoding/asn1, const TagNull ideal-int
-pkg encoding/asn1, var NullBytes []uint8
-pkg encoding/asn1, var NullRawValue RawValue
-pkg encoding/base32, const NoPadding = -1
-pkg encoding/base32, const NoPadding int32
-pkg encoding/base32, const StdPadding = 61
-pkg encoding/base32, const StdPadding int32
-pkg encoding/base32, method (Encoding) WithPadding(int32) *Encoding
-pkg encoding/csv, type Reader struct, ReuseRecord bool
-pkg encoding/json, func Valid([]uint8) bool
-pkg go/ast, type TypeSpec struct, Assign token.Pos
-pkg go/types, func SizesFor(string, string) Sizes
-pkg go/types, method (*TypeName) IsAlias() bool
-pkg hash/fnv, func New128() hash.Hash
-pkg hash/fnv, func New128a() hash.Hash
-pkg html/template, const ErrPredefinedEscaper = 11
-pkg html/template, const ErrPredefinedEscaper ErrorCode
-pkg image/png, type Encoder struct, BufferPool EncoderBufferPool
-pkg image/png, type EncoderBuffer struct
-pkg image/png, type EncoderBufferPool interface { Get, Put }
-pkg image/png, type EncoderBufferPool interface, Get() *EncoderBuffer
-pkg image/png, type EncoderBufferPool interface, Put(*EncoderBuffer)
-pkg math/big, method (*Int) IsInt64() bool
-pkg math/big, method (*Int) IsUint64() bool
-pkg math/big, type Word uint
-pkg math/bits, const UintSize = 64
-pkg math/bits, const UintSize ideal-int
-pkg math/bits, func LeadingZeros(uint) int
-pkg math/bits, func LeadingZeros16(uint16) int
-pkg math/bits, func LeadingZeros32(uint32) int
-pkg math/bits, func LeadingZeros64(uint64) int
-pkg math/bits, func LeadingZeros8(uint8) int
-pkg math/bits, func Len(uint) int
-pkg math/bits, func Len16(uint16) int
-pkg math/bits, func Len32(uint32) int
-pkg math/bits, func Len64(uint64) int
-pkg math/bits, func Len8(uint8) int
-pkg math/bits, func OnesCount(uint) int
-pkg math/bits, func OnesCount16(uint16) int
-pkg math/bits, func OnesCount32(uint32) int
-pkg math/bits, func OnesCount64(uint64) int
-pkg math/bits, func OnesCount8(uint8) int
-pkg math/bits, func Reverse(uint) uint
-pkg math/bits, func Reverse16(uint16) uint16
-pkg math/bits, func Reverse32(uint32) uint32
-pkg math/bits, func Reverse64(uint64) uint64
-pkg math/bits, func Reverse8(uint8) uint8
-pkg math/bits, func ReverseBytes(uint) uint
-pkg math/bits, func ReverseBytes16(uint16) uint16
-pkg math/bits, func ReverseBytes32(uint32) uint32
-pkg math/bits, func ReverseBytes64(uint64) uint64
-pkg math/bits, func RotateLeft(uint, int) uint
-pkg math/bits, func RotateLeft16(uint16, int) uint16
-pkg math/bits, func RotateLeft32(uint32, int) uint32
-pkg math/bits, func RotateLeft64(uint64, int) uint64
-pkg math/bits, func RotateLeft8(uint8, int) uint8
-pkg math/bits, func TrailingZeros(uint) int
-pkg math/bits, func TrailingZeros16(uint16) int
-pkg math/bits, func TrailingZeros32(uint32) int
-pkg math/bits, func TrailingZeros64(uint64) int
-pkg math/bits, func TrailingZeros8(uint8) int
-pkg mime, var ErrInvalidMediaParameter error
-pkg mime/multipart, type FileHeader struct, Size int64
-pkg mime/multipart, var ErrMessageTooLarge error
-pkg net, method (*IPConn) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*TCPConn) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*UDPConn) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*UnixConn) SyscallConn() (syscall.RawConn, error)
-pkg net, type Resolver struct, Dial func(context.Context, string, string) (Conn, error)
-pkg net, type Resolver struct, StrictErrors bool
-pkg net/http, func ServeTLS(net.Listener, Handler, string, string) error
-pkg net/http, method (*Server) RegisterOnShutdown(func())
-pkg net/http, method (*Server) ServeTLS(net.Listener, string, string) error
-pkg net/http/fcgi, func ProcessEnv(*http.Request) map[string]string
-pkg net/http/httptest, method (*Server) Certificate() *x509.Certificate
-pkg net/http/httptest, method (*Server) Client() *http.Client
-pkg reflect, func MakeMapWithSize(Type, int) Value
-pkg runtime/pprof, func Do(context.Context, LabelSet, func(context.Context))
-pkg runtime/pprof, func ForLabels(context.Context, func(string, string) bool)
-pkg runtime/pprof, func Label(context.Context, string) (string, bool)
-pkg runtime/pprof, func Labels(...string) LabelSet
-pkg runtime/pprof, func SetGoroutineLabels(context.Context)
-pkg runtime/pprof, func WithLabels(context.Context, LabelSet) context.Context
-pkg runtime/pprof, type LabelSet struct
-pkg sync, method (*Map) Delete(interface{})
-pkg sync, method (*Map) Load(interface{}) (interface{}, bool)
-pkg sync, method (*Map) LoadOrStore(interface{}, interface{}) (interface{}, bool)
-pkg sync, method (*Map) Range(func(interface{}, interface{}) bool)
-pkg sync, method (*Map) Store(interface{}, interface{})
-pkg sync, type Map struct
-pkg syscall (darwin-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (darwin-386), type Credential struct, NoSetGroups bool
-pkg syscall (darwin-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (darwin-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-386-cgo), func Pipe2([]int, int) error
-pkg syscall (freebsd-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-386), func Pipe2([]int, int) error
-pkg syscall (freebsd-386), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-amd64-cgo), func Pipe2([]int, int) error
-pkg syscall (freebsd-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-amd64), func Pipe2([]int, int) error
-pkg syscall (freebsd-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-arm-cgo), func Pipe2([]int, int) error
-pkg syscall (freebsd-arm-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-arm), func Pipe2([]int, int) error
-pkg syscall (freebsd-arm), type Credential struct, NoSetGroups bool
-pkg syscall (linux-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (linux-386-cgo), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-386), type Credential struct, NoSetGroups bool
-pkg syscall (linux-386), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (linux-amd64), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-arm-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-arm), type Credential struct, NoSetGroups bool
-pkg syscall (linux-arm), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (netbsd-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-386), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-arm-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-arm), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-386), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (windows-386), const WSAECONNABORTED = 10053
-pkg syscall (windows-386), const WSAECONNABORTED Errno
-pkg syscall (windows-amd64), const WSAECONNABORTED = 10053
-pkg syscall (windows-amd64), const WSAECONNABORTED Errno
-pkg syscall, type Conn interface { SyscallConn }
-pkg syscall, type Conn interface, SyscallConn() (RawConn, error)
-pkg syscall, type RawConn interface { Control, Read, Write }
-pkg syscall, type RawConn interface, Control(func(uintptr)) error
-pkg syscall, type RawConn interface, Read(func(uintptr) bool) error
-pkg syscall, type RawConn interface, Write(func(uintptr) bool) error
-pkg testing, method (*B) Helper()
-pkg testing, method (*T) Helper()
-pkg testing, type TB interface, Helper()
-pkg time, method (Duration) Round(Duration) Duration
-pkg time, method (Duration) Truncate(Duration) Duration
--- a/doc/articles/go_command.html
+++ b/doc/articles/go_command.html
@@ -97,14 +97,13 @@ a tool like the go command to look at an unfamiliar import path and
 deduce where to obtain the source code.</p>

 <p>Second, the place to store sources in the local file system is derived
-in a known way from the import path, specifically
-<code>$GOPATH/src/&lt;import-path&gt;</code>.
-If unset, <code>$GOPATH</code> defaults to a subdirectory
-named <code>go</code> in the user's home directory.
+in a known way from the import path.  Specifically, the first choice
+is <code>$GOPATH/src/&lt;import-path&gt;</code>.  If <code>$GOPATH</code> is
+unset, the go command will fall back to storing source code alongside the
+standard Go packages, in <code>$GOROOT/src/&lt;import-path&gt;</code>.
 If <code>$GOPATH</code> is set to a list of paths, the go command tries
 <code>&lt;dir&gt;/src/&lt;import-path&gt;</code> for each of the directories in
-that list.
-</p>
+that list.</p>

 <p>Each of those trees contains, by convention, a top-level directory named
 "<code>bin</code>", for holding compiled executables, and a top-level directory
@@ -134,30 +133,45 @@ be able to adapt to changing build environments and conditions. For
 example, if we allowed extra configuration such as compiler flags or
 command line recipes, then that configuration would need to be updated
 each time the build tools changed; it would also be inherently tied
-to the use of a specific toolchain.</p>
+to the use of a specific tool chain.</p>

 <h2>Getting started with the go command</h2>

-<p>Finally, a quick tour of how to use the go command.
-As mentioned above, the default <code>$GOPATH</code> on Unix is <code>$HOME/go</code>.
-We'll store our programs there.
-To use a different location, you can set <code>$GOPATH</code>;
-see <a href="/doc/code.html">How to Write Go Code</a> for details.
+<p>Finally, a quick tour of how to use the go command, to supplement
+the information in <a href="/doc/code.html">How to Write Go Code</a>,
+which you might want to read first.  Assuming you want
+to keep your source code separate from the Go distribution source
+tree, the first step is to set <code>$GOPATH</code>, the one piece of global
+configuration that the go command needs.  The <code>$GOPATH</code> can be a
+list of directories, but by far the most common usage should be to set it to a
+single directory.  In particular, you do not need a separate entry in
+<code>$GOPATH</code> for each of your projects.  One <code>$GOPATH</code> can
+support many projects.</p>

-<p>We first add some source code.  Suppose we want to use
+<p>Here’s an example.  Let’s say we decide to keep our Go code in the directory
+<code>$HOME/mygo</code>.  We need to create that directory and set
+<code>$GOPATH</code> accordingly.</p>
+
+<pre>
+$ mkdir $HOME/mygo
+$ export GOPATH=$HOME/mygo
+$
+</pre>
+
+<p>Into this directory, we now add some source code.  Suppose we want to use
 the indexing library from the codesearch project along with a left-leaning
 red-black tree.  We can install both with the "<code>go get</code>"
 subcommand:</p>

 <pre>
-$ go get github.com/google/codesearch/index
+$ go get code.google.com/p/codesearch/index
 $ go get github.com/petar/GoLLRB/llrb
 $
 </pre>

-<p>Both of these projects are now downloaded and installed into <code>$HOME/go</code>,
-which contains the two directories
-<code>src/github.com/google/codesearch/index/</code> and
+<p>Both of these projects are now downloaded and installed into our
+<code>$GOPATH</code> directory. The one tree now contains the two directories
+<code>src/code.google.com/p/codesearch/index/</code> and
 <code>src/github.com/petar/GoLLRB/llrb/</code>, along with the compiled
 packages (in <code>pkg/</code>) for those libraries and their dependencies.</p>

@@ -170,14 +184,13 @@ the pattern "<code>./...</code>" means start in the current directory
 ("<code>...</code>"):</p>

 <pre>
-$ cd $HOME/go/src
 $ go list ./...
-github.com/google/codesearch/cmd/cgrep
-github.com/google/codesearch/cmd/cindex
-github.com/google/codesearch/cmd/csearch
-github.com/google/codesearch/index
-github.com/google/codesearch/regexp
-github.com/google/codesearch/sparse
+code.google.com/p/codesearch/cmd/cgrep
+code.google.com/p/codesearch/cmd/cindex
+code.google.com/p/codesearch/cmd/csearch
+code.google.com/p/codesearch/index
+code.google.com/p/codesearch/regexp
+code.google.com/p/codesearch/sparse
 github.com/petar/GoLLRB/example
 github.com/petar/GoLLRB/llrb
 $
@@ -187,12 +200,12 @@ $

 <pre>
 $ go test ./...
-?   	github.com/google/codesearch/cmd/cgrep	[no test files]
-?   	github.com/google/codesearch/cmd/cindex	[no test files]
-?   	github.com/google/codesearch/cmd/csearch	[no test files]
-ok  	github.com/google/codesearch/index	0.203s
-ok  	github.com/google/codesearch/regexp	0.017s
-?   	github.com/google/codesearch/sparse	[no test files]
+?       code.google.com/p/codesearch/cmd/cgrep   [no test files]
+?       code.google.com/p/codesearch/cmd/cindex  [no test files]
+?       code.google.com/p/codesearch/cmd/csearch [no test files]
+ok      code.google.com/p/codesearch/index       0.239s
+ok      code.google.com/p/codesearch/regexp      0.021s
+?       code.google.com/p/codesearch/sparse      [no test files]
 ?       github.com/petar/GoLLRB/example          [no test files]
 ok      github.com/petar/GoLLRB/llrb             0.231s
 $
@@ -202,18 +215,18 @@ $
 current directory:</p>

 <pre>
-$ cd github.com/google/codesearch/regexp
+$ cd $GOPATH/src/code.google.com/p/codesearch/regexp
 $ go list
-github.com/google/codesearch/regexp
+code.google.com/p/codesearch/regexp
 $ go test -v
-=== RUN   TestNstateEnc
--- PASS: TestNstateEnc (0.00s)
-=== RUN   TestMatch
--- PASS: TestMatch (0.00s)
-=== RUN   TestGrep
--- PASS: TestGrep (0.00s)
+=== RUN TestNstateEnc
+--- PASS: TestNstateEnc (0.00 seconds)
+=== RUN TestMatch
+--- PASS: TestMatch (0.01 seconds)
+=== RUN TestGrep
+--- PASS: TestGrep (0.00 seconds)
 PASS
-ok  	github.com/google/codesearch/regexp	0.018s
+ok      code.google.com/p/codesearch/regexp     0.021s
 $ go install
 $
 </pre>
@@ -231,6 +244,9 @@ pick such a long name, but that ability would require additional configuration
 and complexity in the tool. Typing an extra directory name or two is a small
 price to pay for the increased simplicity and power.</p>

+<p>As the example shows, it’s fine to work with packages from many different
+projects at once within a single <code>$GOPATH</code> root directory.</p>
+
 <h2>Limitations</h2>

 <p>As mentioned above, the go command is not a general-purpose build
@@ -239,7 +255,8 @@ In particular, it does not have any facility for generating Go
 source files <em>during</em> a build, although it does provide
 <a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
 <code>generate</code></a>,
-which can automate the creation of Go files <em>before</em> the build.
+which can automate the creation of Go files <em>before</em>
+the build, such as by running <code>yacc</code>.
 For more advanced build setups, you may need to write a
 makefile (or a configuration file for the build tool of your choice)
 to run whatever tool creates the Go files and then check those generated source files
--- a/doc/articles/wiki/final-noclosure.go
+++ b/doc/articles/wiki/final-noclosure.go
@@ -8,7 +8,6 @@ import (
 	"errors"
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"regexp"
 )
@@ -99,5 +98,5 @@ func main() {
 	http.HandleFunc("/view/", viewHandler)
 	http.HandleFunc("/edit/", editHandler)
 	http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/final-noerror.go
+++ b/doc/articles/wiki/final-noerror.go
@@ -7,7 +7,6 @@ package main
 import (
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 )

@@ -50,5 +49,5 @@ func viewHandler(w http.ResponseWriter, r *http.Request) {
 func main() {
 	http.HandleFunc("/view/", viewHandler)
 	http.HandleFunc("/edit/", editHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/final-parsetemplate.go
+++ b/doc/articles/wiki/final-parsetemplate.go
@@ -7,7 +7,6 @@ package main
 import (
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"regexp"
 )
@@ -88,5 +87,5 @@ func main() {
 	http.HandleFunc("/view/", makeHandler(viewHandler))
 	http.HandleFunc("/edit/", makeHandler(editHandler))
 	http.HandleFunc("/save/", makeHandler(saveHandler))
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/final-template.go
+++ b/doc/articles/wiki/final-template.go
@@ -7,7 +7,6 @@ package main
 import (
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 )

@@ -62,5 +61,5 @@ func main() {
 	http.HandleFunc("/view/", viewHandler)
 	http.HandleFunc("/edit/", editHandler)
 	http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/final-test.patch
+++ b/doc/articles/wiki/final-test.patch
@@ -1,27 +1,36 @@
--- final.go	2017-08-31 13:19:00.422925489 -0700
-+++ final-test.go	2017-08-31 13:23:43.381391659 -0700
-@@ -8,6 +8,7 @@
- 	"html/template"
- 	"io/ioutil"
- 	"log"
-+	"net"
- 	"net/http"
- 	"regexp"
- )
-@@ -86,5 +87,15 @@
- 	http.HandleFunc("/edit/", makeHandler(editHandler))
- 	http.HandleFunc("/save/", makeHandler(saveHandler))
- 
-	log.Fatal(http.ListenAndServe(":8080", nil))
-+	l, err := net.Listen("tcp", "127.0.0.1:0")
-+	if err != nil {
-+		log.Fatal(err)
-+	}
-+	err = ioutil.WriteFile("final-test-port.txt", []byte(l.Addr().String()), 0644)
-+	if err != nil {
-+		log.Fatal(err)
-+	}
-+	s := &http.Server{}
-+	s.Serve(l)
-+	return
- }
+*** final.go	2015-06-14 23:59:22.000000000 +0200
+--- final-test.go	2015-06-15 00:15:41.000000000 +0200
+***************
+*** 7,12 ****
+--- 7,14 ----
+  import (
+  	"html/template"
+  	"io/ioutil"
+ 	"log"
+ 	"net"
+  	"net/http"
+  	"regexp"
+  )
+***************
+*** 85,89 ****
+  	http.HandleFunc("/edit/", makeHandler(editHandler))
+  	http.HandleFunc("/save/", makeHandler(saveHandler))
+  
+! 	http.ListenAndServe(":8080", nil)
+  }
+--- 87,101 ----
+  	http.HandleFunc("/edit/", makeHandler(editHandler))
+  	http.HandleFunc("/save/", makeHandler(saveHandler))
+  
+! 	l, err := net.Listen("tcp", "127.0.0.1:0")
+! 	if err != nil {
+! 		log.Fatal(err)
+! 	}
+! 	err = ioutil.WriteFile("final-test-port.txt", []byte(l.Addr().String()), 0644)
+! 	if err != nil {
+! 		log.Fatal(err)
+! 	}
+! 	s := &http.Server{}
+! 	s.Serve(l)
+! 	return
+  }
--- a/doc/articles/wiki/final.go
+++ b/doc/articles/wiki/final.go
@@ -7,7 +7,6 @@ package main
 import (
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"regexp"
 )
@@ -86,5 +85,5 @@ func main() {
 	http.HandleFunc("/edit/", makeHandler(editHandler))
 	http.HandleFunc("/save/", makeHandler(saveHandler))

-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/http-sample.go
+++ b/doc/articles/wiki/http-sample.go
@@ -2,7 +2,6 @@ package main

 import (
 	"fmt"
-	"log"
 	"net/http"
 )

@@ -12,5 +11,5 @@ func handler(w http.ResponseWriter, r *http.Request) {

 func main() {
 	http.HandleFunc("/", handler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/index.html
+++ b/doc/articles/wiki/index.html
@@ -179,7 +179,7 @@ You can compile and run the program like this:
 <pre>
 $ go build wiki.go
 $ ./wiki
-This is a sample Page.
+This is a sample page.
 </pre>

 <p>
@@ -213,12 +213,6 @@ worry about its second parameter, <code>nil</code>, for now.)
 This function will block until the program is terminated.
 </p>

-<p>
-<code>ListenAndServe</code> always returns an error, since it only returns when an
-unexpected error occurs.
-In order to log that error we wrap the function call with <code>log.Fatal</code>.
-</p>
-
 <p>
 The function <code>handler</code> is of the type <code>http.HandlerFunc</code>.
 It takes an <code>http.ResponseWriter</code> and an <code>http.Request</code> as
--- a/doc/articles/wiki/notemplate.go
+++ b/doc/articles/wiki/notemplate.go
@@ -7,7 +7,6 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
-	"log"
 	"net/http"
 )

@@ -53,5 +52,5 @@ func editHandler(w http.ResponseWriter, r *http.Request) {
 func main() {
 	http.HandleFunc("/view/", viewHandler)
 	http.HandleFunc("/edit/", editHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/part2.go
+++ b/doc/articles/wiki/part2.go
@@ -7,7 +7,6 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
-	"log"
 	"net/http"
 )

@@ -38,5 +37,5 @@ func viewHandler(w http.ResponseWriter, r *http.Request) {

 func main() {
 	http.HandleFunc("/view/", viewHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/part3-errorhandling.go
+++ b/doc/articles/wiki/part3-errorhandling.go
@@ -7,7 +7,6 @@ package main
 import (
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 )

@@ -70,5 +69,5 @@ func main() {
 	http.HandleFunc("/view/", viewHandler)
 	http.HandleFunc("/edit/", editHandler)
 	http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/part3.go
+++ b/doc/articles/wiki/part3.go
@@ -7,7 +7,6 @@ package main
 import (
 	"html/template"
 	"io/ioutil"
-	"log"
 	"net/http"
 )

@@ -54,5 +53,5 @@ func main() {
 	http.HandleFunc("/view/", viewHandler)
 	http.HandleFunc("/edit/", editHandler)
 	//http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
+	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/test.bash
+++ b/doc/articles/wiki/test.bash
@@ -20,7 +20,7 @@ trap cleanup 0 INT
 rm -f get.bin final-test.bin a.out

 # If called with -all, check that all code snippets compile.
-if [ "$1" = "-all" ]; then
+if [ "$1" == "-all" ]; then
 	for fn in *.go; do
 		go build -o a.out $fn
 	done
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -29,7 +29,7 @@ Instead, the compiler operates on a kind of semi-abstract instruction set,
 and instruction selection occurs partly after code generation.
 The assembler works on the semi-abstract form, so
 when you see an instruction like <code>MOV</code>
-what the toolchain actually generates for that operation might
+what the tool chain actually generates for that operation might
 not be a move instruction at all, perhaps a clear or load.
 Or it might correspond exactly to the machine instruction with that name.
 In general, machine-specific operations tend to appear as themselves, while more general concepts like
@@ -139,7 +139,7 @@ The exact set depends on the architecture.
 <p>
 There are four predeclared symbols that refer to pseudo-registers.
 These are not real registers, but rather virtual registers maintained by
-the toolchain, such as a frame pointer.
+the tool chain, such as a frame pointer.
 The set of pseudo-registers is the same for all architectures:
 </p>

@@ -838,50 +838,6 @@ It is a scaled mode as on the x86, but the only scale allowed is <code>1</code>.

 </ul>

-<h3 id="mips">MIPS, MIPS64</h3>
-
-<p>
-General purpose registers are named <code>R0</code> through <code>R31</code>,
-floating point registers are <code>F0</code> through <code>F31</code>.
-</p>
-
-<p>
-<code>R30</code> is reserved to point to <code>g</code>.
-<code>R23</code> is used as a temporary register.
-</p>
-
-<p>
-In a <code>TEXT</code> directive, the frame size <code>$-4</code> for MIPS or
-<code>$-8</code> for MIPS64 instructs the linker not to save <code>LR</code>.
-</p>
-
-<p>
-<code>SP</code> refers to the virtual stack pointer.
-For the hardware register, use <code>R29</code>.
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>16(R1)</code>: The location at <code>R1</code> plus 16.
-</li>
-
-<li>
-<code>(R1)</code>: Alias for <code>0(R1)</code>.
-</li>
-
-</ul>
-
-<p>
-The value of <code>GOMIPS</code> environment variable (<code>hardfloat</code> or
-<code>softfloat</code>) is made available to assembly code by predefining either
-<code>GOMIPS_hardfloat</code> or <code>GOMIPS_softfloat</code>.
-</p>
-
 <h3 id="unsupported_opcodes">Unsupported opcodes</h3>

 <p>
--- a/doc/cmd.html
+++ b/doc/cmd.html
@@ -22,7 +22,7 @@ using the go <code>tool</code> subcommand, such as <code>go tool vet</code>.
 This style of invocation allows, for instance, checking a single source file
 rather than an entire package: <code>go tool vet myprogram.go</code> as
 compared to <code>go vet mypackage</code>.
-Some of the commands, such as <code>pprof</code>, are accessible only through
+Some of the commands, such as <code>yacc</code>, are accessible only through
 the go <code>tool</code> subcommand.
 </p>

@@ -62,7 +62,7 @@ details.
 </tr>

 <tr>
-<td><a href="/cmd/cover/">cover</a></td>
+<td><a href="//godoc.org/golang.org/x/tools/cmd/cover/">cover</a></td>
 <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
 <td>Cover is a program for creating and analyzing the coverage profiles
 generated by <code>"go test -coverprofile"</code>.</td>
@@ -95,6 +95,12 @@ gofmt</a> command with more general options.</td>
 calls whose arguments do not align with the format string.</td>
 </tr>

+<tr>
+<td><a href="/cmd/yacc/">yacc</a></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
+<td>Yacc is a version of yacc that generates parsers implemented in Go.</td>
+</tr>
+
 </table>

 <p>
--- a/doc/code.html
+++ b/doc/code.html
@@ -120,26 +120,22 @@ We will discuss the distinction <a href="#PackageNames">later</a>.

 <p>
 The <code>GOPATH</code> environment variable specifies the location of your
-workspace. It defaults to a directory named <code>go</code> inside your home directory,
-so <code>$HOME/go</code> on Unix,
-<code>$home/go</code> on Plan 9,
-and <code>%USERPROFILE%\go</code> (usually <code>C:\Users\YourName\go</code>) on Windows.
+workspace. It is likely the only environment variable you'll need to set
+when developing Go code.
 </p>

 <p>
-If you would like to work in a different location, you will need to
-<a href="https://golang.org/wiki/SettingGOPATH">set <code>GOPATH</code></a>
-to the path to that directory.
-(Another common setup is to set <code>GOPATH=$HOME</code>.)
-Note that <code>GOPATH</code> must <b>not</b> be the
+To get started, create a workspace directory and set <code>GOPATH</code>
+accordingly. Your workspace can be located wherever you like, but we'll use
+<code>$HOME/work</code> in this document. Note that this must <b>not</b> be the
 same path as your Go installation.
+(Another common setup is to set <code>GOPATH=$HOME</code>.)
 </p>

-<p>
-The command <code>go</code> <code>env</code> <code>GOPATH</code>
-prints the effective current <code>GOPATH</code>;
-it prints the default location if the environment variable is unset.
-</p>
+<pre>
+$ <b>mkdir $HOME/work</b>
+$ <b>export GOPATH=$HOME/work</b>
+</pre>

 <p>
 For convenience, add the workspace's <code>bin</code> subdirectory
@@ -147,30 +143,13 @@ to your <code>PATH</code>:
 </p>

 <pre>
-$ <b>export PATH=$PATH:$(go env GOPATH)/bin</b>
+$ <b>export PATH=$PATH:$GOPATH/bin</b>
 </pre>

 <p>
-The scripts in the rest of this document use <code>$GOPATH</code>
-instead of <code>$(go env GOPATH)</code> for brevity.
-To make the scripts run as written
-if you have not set GOPATH,
-you can substitute $HOME/go in those commands
-or else run:
-</p>
-
-<pre>
-$ <b>export GOPATH=$(go env GOPATH)</b>
-</pre>
-
-<p>
-To learn more about the <code>GOPATH</code> environment variable, see
-<a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>'go help gopath'</code></a>.
-</p>
-
-<p>
-To use a custom workspace location,
-<a href="https://golang.org/wiki/SettingGOPATH">set the <code>GOPATH</code> environment variable</a>.
+To learn more about setting up the <code>GOPATH</code> environment variable,
+please see
+<a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>go help gopath</code></a>
 </p>

 <h3 id="ImportPaths">Import paths</h3>
@@ -270,7 +249,7 @@ This command builds the <code>hello</code> command, producing an executable
 binary. It then installs that binary to the workspace's <code>bin</code>
 directory as <code>hello</code> (or, under Windows, <code>hello.exe</code>).
 In our example, that will be <code>$GOPATH/bin/hello</code>, which is
-<code>$HOME/go/bin/hello</code>.
+<code>$HOME/work/bin/hello</code>.
 </p>

 <p>
--- a/doc/conduct.html
+++ b/doc/conduct.html
@@ -20,8 +20,8 @@ ul ul {
 <p>
 Online communities include people from many different backgrounds.
 The Go contributors are committed to providing a friendly, safe and welcoming
-environment for all, regardless of age, disability, gender, nationality,
-ethnicity, religion, sexuality, or similar personal characteristic.
+environment for all, regardless of age, disability, gender, nationality, race,
+religion, sexuality, or similar personal characteristic.
 </p>

 <p>
@@ -67,6 +67,7 @@ official forums operated by the Go project (“Go spaces”):
    <li>The <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a> and
        <a href="https://groups.google.com/group/golang-dev">golang-dev</a> mailing lists.
 <li>The #go-nuts IRC channel on Freenode.
+<li>The <a href="https://reddit.com/r/golang">/r/golang subreddit</a>.
 </ul>

 <p>
@@ -148,26 +149,29 @@ These actions are explicitly forbidden in Go spaces:

 <p>
 The Go spaces are not free speech venues; they are for discussion about Go.
-Each of these spaces have their own moderators.
+These spaces have moderators.
+The goal of the moderators is to facilitate civil discussion about Go.
 </p>

 <p>
 When using the official Go spaces you should act in the spirit of the “Gopher
 values”.
-If a reported conflict cannot be resolved amicably, the CoC Working Group
-may make a recommendation to the relevant forum moderators.
+If you conduct yourself in a way that is explicitly forbidden by the CoC,
+you will be warned and asked to stop.
+If you do not stop, you will be removed from our community spaces temporarily.
+Repeated, willful breaches of the CoC will result in a permanent ban.
 </p>

 <p>
-CoC Working Group members and forum moderators are held to a higher standard than other community members.
-If a working group member or moderator creates an inappropriate situation, they
-should expect less leeway than others, and should expect to be removed from
-their position if they cannot adhere to the CoC.
+Moderators are held to a higher standard than other community members.
+If a moderator creates an inappropriate situation, they should expect less
+leeway than others, and should expect to be removed from their position if they
+cannot adhere to the CoC.
 </p>

 <p>
-Complaints about working group member or moderator actions must be handled 
-using the reporting process below.
+Complaints about moderator actions must be handled using the reporting process
+below.
 </p>

 <h2 id="reporting">Reporting issues</h2>
@@ -182,6 +186,8 @@ satisfaction of all parties. They are:
 <ul>
 	<li>Aditya Mukerjee &lt;dev@chimeracoder.net&gt;
 	<li>Andrew Gerrand &lt;adg@golang.org&gt;
+	<li>Dave Cheney &lt;dave@cheney.net&gt;
+	<li>Jason Buberel &lt;jbuberel@google.com&gt;
 	<li>Peggy Li &lt;peggyli.224@gmail.com&gt;
 	<li>Sarah Adams &lt;sadams.codes@gmail.com&gt;
 	<li>Steve Francia &lt;steve.francia@gmail.com&gt;
@@ -196,10 +202,13 @@ particular individual or group.
 </p>

 <ul>
-<li>Mail <a href="mailto:conduct@golang.org">conduct@golang.org</a>.
+<li>Mail <a href="mailto:conduct@golang.org">conduct@golang.org</a> or
+    <a href="https://golang.org/s/conduct-report">submit an anonymous report</a>.
    <ul>
    <li>Your message will reach the Working Group.
    <li>Reports are confidential within the Working Group.
+    <li>Should you choose to remain anonymous then the Working Group cannot
+        notify you of the outcome of your report.
    <li>You may contact a member of the group directly if you do not feel
        comfortable contacting the group as a whole. That member will then raise
        the issue with the Working Group as a whole, preserving the privacy of the
@@ -221,8 +230,11 @@ particular individual or group.
 <li>The Working Group will reach a decision as to how to act. These may include:
    <ul>
    <li>Nothing.
-    <li>Passing the report along to the offender.
-    <li>A recommendation of action to the relevant forum moderators.
+    <li>A request for a private or public apology.
+    <li>A private or public warning.
+    <li>An imposed vacation (for instance, asking someone to abstain for a week
+        from a mailing list or IRC).
+    <li>A permanent or temporary ban from some or all Go spaces.
    </ul>
 <li>The Working Group will reach out to the original reporter to let them know
    the decision.
@@ -235,6 +247,7 @@ particular individual or group.
 conflicts in the most harmonious way possible.</b>
 We hope that in most cases issues may be resolved through polite discussion and
 mutual agreement.
+Bannings and other forceful measures are to be employed only as a last resort.
 </p>

 <p>
--- a/doc/contrib.html
+++ b/doc/contrib.html
@@ -34,9 +34,6 @@ We encourage all Go users to subscribe to
 <p>A <a href="/doc/devel/release.html">summary</a> of the changes between Go releases. Notes for the major releases:</p>

 <ul>
-	<li><a href="/doc/go1.10">Go 1.10</a> <small>(February 2018)</small></li>
-	<li><a href="/doc/go1.9">Go 1.9</a> <small>(August 2017)</small></li>
-	<li><a href="/doc/go1.8">Go 1.8</a> <small>(February 2017)</small></li>
 	<li><a href="/doc/go1.7">Go 1.7</a> <small>(August 2016)</small></li>
 	<li><a href="/doc/go1.6">Go 1.6</a> <small>(February 2016)</small></li>
 	<li><a href="/doc/go1.5">Go 1.5</a> <small>(August 2015)</small></li>
@@ -118,6 +115,6 @@ guidelines</a> for information on design, testing, and our code review process.
 <p>
 Check <a href="//golang.org/issue">the tracker</a> for 
 open issues that interest you. Those labeled
-<a href="https://github.com/golang/go/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22">help wanted</a>
+<a href="https://github.com/golang/go/issues?q=is%3Aopen+is%3Aissue+label%3Ahelpwanted">helpwanted</a>
 are particularly in need of outside help.
 </p>
--- a/doc/contribute.html
+++ b/doc/contribute.html
@@ -1,12 +1,14 @@
 <!--{
-	"Title": "Contribution Guide"
+	"Title": "Contribution Guidelines"
 }-->

+<h2 id="Introduction">Introduction</h2>
+
 <p>
-The Go project welcomes all contributors. The process of contributing
-to the Go project may be different than many projects you are used to.
-This document is intended as a guide to help you through the contribution
-process. This guide assumes you have a basic understanding of Git and Go.
+This document explains how to contribute changes to the Go project.
+It assumes you have followed the
+<a href="/doc/install/source">installation instructions</a> and
+have <a href="code.html">written and tested your code</a>.
 </p>

 <p>
@@ -18,99 +20,127 @@ see <a href="gccgo_contribute.html">Contributing to gccgo</a>.)
 Sensitive security-related issues should be reported to <a href="mailto:security@golang.org">security@golang.org</a>.
 </p>

-<h1 id="contributor">Becoming a contributor</h1>
+<h2 id="Design">Discuss your design</h2>

 <p>
-Before you can contribute to the Go project you need to setup a few prerequisites.
-The Go project uses <a href="https://www.gerritcodereview.com/">Gerrit</a>, an open
-source online tool, to perform all code reviews.
-Gerrit uses your email address as a unique identifier.
-The Go project contributing flow is currently configured to work only with Google Accounts.
-You must go through the following process <em>prior to contributing</em>.
-You only need to do this once per Google Account.
+The project welcomes submissions but please let everyone know what
+you're working on if you want to change or add to the Go repositories.
 </p>

-<h2 id="go-contrib-init">Automatically set up &amp; diagnose your development environment</h3>
 <p>
-  The <code>go-contrib-init</code> tool configures and debugs your Go
-  development environment, automatically performing many of the steps
-  on this page, or telling you what you need to do next. If you wish
-  to use it, run:
+Before undertaking to write something new for the Go project,
+please <a href="https://golang.org/issue/new">file an issue</a>
+(or claim an <a href="https://golang.org/issues">existing issue</a>).
+Significant changes must go through the
+<a href="https://golang.org/s/proposal-process">change proposal process</a>
+before they can be accepted.
+</p>
+
+<p>
+This process gives everyone a chance to validate the design,
+helps prevent duplication of effort,
+and ensures that the idea fits inside the goals for the language and tools.
+It also checks that the design is sound before code is written;
+the code review tool is not the place for high-level discussions.
+</p>
+
+<p>
+When planning work, please note that the Go project follows a
+<a href="https://golang.org/wiki/Go-Release-Cycle">six-month
+development cycle</a>. The latter half of each cycle is a three-month
+feature freeze during which only bug fixes and doc updates are accepted.
+New work cannot be submitted during a feature freeze.
+</p>
+
+<h2 id="Testing">Testing redux</h2>
+
+<p>
+You've <a href="code.html">written and tested your code</a>, but
+before sending code out for review, run all the tests for the whole
+tree to make sure the changes don't break other packages or programs:
 </p>

 <pre>
-$ go get -u golang.org/x/tools/cmd/go-contrib-init
-$ cd /code/to/edit
-$ go-contrib-init
+$ cd go/src
+$ ./all.bash
 </pre>

 <p>
-  The tool will either set things up, tell you that everything is
-  configured, or tell you what steps you need to do manually.
-</p>
-
-<h2 id="auth">Configure Git to use Gerrit</h2>
-<p>
-You'll need a web browser and a command line terminal.
-You should already have Git installed.
+(To build under Windows use <code>all.bat</code>.)
 </p>

 <p>
-Gerrit uses Google Accounts for authentication.
-If you don't have a Google Account, you can create an account which
+After running for a while, the command should print
+"<code>ALL</code> <code>TESTS</code> <code>PASSED</code>".
+</p>
+
+<h2 id="Code_review">Code review</h2>
+
+<p>
+Changes to Go must be reviewed before they are accepted,
+no matter who makes the change.
+A custom git command called <code>git-codereview</code>,
+discussed below, helps manage the code review process through a Google-hosted
+<a href="https://go-review.googlesource.com/">instance</a> of the code review
+system called <a href="https://www.gerritcodereview.com/">Gerrit</a>.
+</p>
+
+<h3 id="auth">Set up authentication for code review</h3>
+
+<p>
+Gerrit uses Google Accounts for authentication. If you don't have
+a Google Account, you can create an account which
 <a href="https://www.google.com/accounts/NewAccount">includes
 a new Gmail email account</a> or create an account associated
 <a href="https://accounts.google.com/SignUpWithoutGmail">with your existing
 email address</a>.
 </p>

-<h3>Step 1: Sign in to googlesource and generate a password</h3>
+<p>
+The email address associated with the Google Account you use will be recorded in
+the <a href="https://go.googlesource.com/go/+log/">change log</a>
+and in the <a href="/CONTRIBUTORS">contributors file</a>.
+</p>

 <p>
-Visit <a href="https://go.googlesource.com">go.googlesource.com</a>
+To set up your account in Gerrit, visit
+<a href="https://go.googlesource.com">go.googlesource.com</a>
 and click on "Generate Password" in the page's top right menu bar.
+</p>
+
+<p>
 You will be redirected to accounts.google.com to sign in.
 </p>

-<h3>Step 2: Run the provided script</h3>
 <p>
-After signing in, you are taken to a page on go.googlesource.com with the title "Configure Git".
-This page contains a personalized script which when run locally will configure git
-to have your unique authentication key.
-This key is paired with one generated server side similar to how ssh keys work.
+Once signed in, you are returned back to go.googlesource.com to "Configure Git".
+Follow the instructions on the page.
+(If you are on a Windows computer, you should instead follow the instructions
+in the yellow box to run the command.)
 </p>

 <p>
-Copy and run this script locally in your command line terminal.
-(On a Windows computer using cmd you should instead follow the instructions
-in the yellow box to run the command. If you are using git-bash use the same
-script as *nix.)
-</p>
-
-<p>
-Your secret authentication token is now in a <code>.gitcookies</code> file
+Your secret authentication token is now in a <code>.gitcookie</code> file
 and Git is configured to use this file.
 </p>

-<h3 id="gerrit">Step 3: Register with Gerrit</h3>
+<h3 id="gerrit">Register with Gerrit</h3>

 <p>
-Now that you have your authentication token, you need to register your
-account with Gerrit.
-To do this, visit <a href="https://go-review.googlesource.com/login/">
-go-review.googlesource.com/login/</a>.
-Sign in using the same Google Account you used above.
+Now that you have your authentication token,
+you need to register your account with Gerrit.
+To do this, visit
+<a href="https://go-review.googlesource.com/login/">
+go-review.googlesource.com/login/</a>. You will immediately be redirected
+to Google Accounts. Sign in using the same Google Account you used above.
+That is all that is required.
 </p>

-<h2 id="cla">Contributor License Agreement</h2>
-
-<h3 id="which_cla">Which CLA</h3>
-<p>
-Before sending your first change to the Go project
-you must have completed one of the following two CLAs.
-Which CLA you should sign depends on who owns the copyright to your work.
-</p>
+<h3 id="cla">Contributor License Agreement</h3>

+<p>Gerrit serves as the gatekeeper and uses your e-mail address as the key.
+To send your first change to the Go project from a given address,
+you must have completed one of the contributor license agreements:
 <ul>
 <li>
 If you are the copyright holder, you will need to agree to the
@@ -121,49 +151,37 @@ contributor license agreement</a>, which can be completed online.
 If your organization is the copyright holder, the organization
 will need to agree to the
 <a href="https://developers.google.com/open-source/cla/corporate">corporate
-contributor license agreement</a>.<br>
+contributor license agreement</a>.
+(If the copyright holder for your code has already completed the
+agreement in connection with another Google open source project,
+it does not need to be completed again.)
 </li>
 </ul>

 <p>
-<i>If the copyright holder for your contribution has already completed the
-agreement in connection with another Google open source project,
-it does not need to be completed again.</i>
-</p>
-
-<h3 id="signing_cla">Completing the CLA</h3>
-
-<p>
-You can see your currently signed agreements and sign new ones through the Gerrit
-interface.
-To do this, <a href="https://go-review.googlesource.com/login/">Log into Gerrit</a>,
-then visit the <a href="https://go-review.googlesource.com/settings/agreements">Agreements</a>
-page.
-If you do not have a signed agreement listed there, you can create one
-by clicking "New Contributor Agreement" and following the steps.
+You can use the links above to create and sign the contributor license agreement
+or you can show your current agreements and create new ones through the Gerrit
+interface.  <a href="https://go-review.googlesource.com/login/">Log into Gerrit</a>,
+click your name in the upper-right, choose "Settings", then select "Agreements"
+from the topics on the left. If you do not have a signed agreement listed here,
+you can create one by clicking "New Contributor Agreement" and following the steps.
 </p>

 <p>
-If the copyright holder for the code you are submitting changes &mdash; for example,
-if you start contributing code on behalf of a new company &mdash; please send email
-to golang-dev and let us know, so that we can make sure an appropriate agreement is
-completed and update the <code>AUTHORS</code> file.
+This rigmarole only needs to be done for your first submission for each email address.
 </p>

-<span id="Code_review"></span>
-<h1 id="prepare_dev_env">Preparing a Development Environment for Contributing</h1>
-
-<h2 id="git-codereview">Setting up Git for submission to Gerrit</h2>
 <p>
-Changes to Go must be reviewed before they are accepted, no matter who makes the change.
-A custom git command called <code>git-codereview</code>, discussed below,
-helps manage the code review process through a Google-hosted
-<a href="https://go-review.googlesource.com/">instance</a> of Gerrit.
+If the copyright holder for the code you are submitting changes—for example,
+if you start contributing code on behalf of a new company—please send email
+to let us know, so that we can make sure an appropriate agreement is completed
+and update the <code>AUTHORS</code> file.
 </p>

-<h3 id="git-codereview_install">Install the git-codereview command</h3>
+<h3 id="git-codereview">Install the git-codereview command</h3>
+
 <p>
-Install the <code>git-codereview</code> command by running,
+Now install the <code>git-codereview</code> command by running,
 </p>

 <pre>
@@ -183,29 +201,25 @@ $ git codereview help
 prints help text, not an error.
 </p>

-<p>
-On Windows, when using git-bash you must make sure that
-<code>git-codereview.exe</code> is in your git exec-path.
-Run <code>git --exec-path</code> to discover the right location then create a
-symbolic link or simply copy the executable from $GOPATH/bin to this directory.
-</p>
-
 <p>
 <b>Note to Git aficionados:</b>
 The <code>git-codereview</code> command is not required to
-upload and manage Gerrit code reviews.
-For those who prefer plain Git, the text below gives the Git equivalent of
-each git-codereview command.
+upload and manage Gerrit code reviews. For those who prefer plain Git, the text
+below gives the Git equivalent of each git-codereview command.
+</p>
+
+<p>If you do use plain
+Git, note that you still need the commit hooks that the git-codereview command
+configures; those hooks add a Gerrit <code>Change-Id</code> line to the commit
+message and check that all Go source files have been formatted with gofmt. Even
+if you intend to use plain Git for daily work, install the hooks in a new Git
+checkout by running <code>git-codereview</code> <code>hooks</code>.
 </p>

 <p>
-If you do use plain Git, note that you still need the commit hooks that the
-git-codereview command configures; those hooks add a Gerrit
-<code>Change-Id</code> line to the commit message and check that all Go source
-files have been formatted with gofmt.
-Even if you intend to use plain Git for
-daily work, install the hooks in a new Git checkout by running
-<code>git-codereview</code> <code>hooks</code>.
+The workflow described below assumes a single change per branch.
+It is also possible to prepare a sequence of (usually related) changes in a single branch.
+See the <a href="https://golang.org/x/review/git-codereview">git-codereview documentation</a> for details.
 </p>

 <h3 id="git-config">Set up git aliases</h3>
@@ -250,8 +264,7 @@ To install them, copy this text into your Git configuration file
 	sync = codereview sync
 </pre>

-<span id="help"></span>
-<h3 id="understanding_git-codereview">Understanding the git-codereview command</h3>
+<h3 id="help">Understanding the git-codereview command</h3>

 <p>After installing the <code>git-codereview</code> command, you can run</p>

@@ -264,79 +277,11 @@ to learn more about its commands.
 You can also read the <a href="https://godoc.org/golang.org/x/review/git-codereview">command documentation</a>.
 </p>

-
-<h1 id="making_a_contribution">Making a Contribution</h1>
-
-<h2 id="Design">Discuss your design</h2>
-
-<p>
-The project welcomes submissions but please let everyone know what
-you're working on if you want to change or add to the Go repositories.
-</p>
-
-<p>
-Before undertaking to write something new for the Go project,
-please <a href="https://golang.org/issue/new">file an issue</a>
-(or claim an <a href="https://golang.org/issues">existing issue</a>).
-Significant changes must go through the
-<a href="https://golang.org/s/proposal-process">change proposal process</a>
-before they can be accepted.
-</p>
-
-<p>
-This process gives everyone a chance to validate the design,
-helps prevent duplication of effort,
-and ensures that the idea fits inside the goals for the language and tools.
-It also checks that the design is sound before code is written;
-the code review tool is not the place for high-level discussions.
-</p>
-
-<p>
-When planning work, please note that the Go project follows a <a
-href="https://golang.org/wiki/Go-Release-Cycle">six-month development cycle</a>.
-The latter half of each cycle is a three-month feature freeze during
-which only bug fixes and doc updates are accepted. New contributions can be
-sent during a feature freeze but will not be accepted until the freeze thaws.
-</p>
-
-<h3 id="scratch">Not sure what change to make?</h3>
-
-<p>
-If you want to become familiar with Gerrit and the contribution process,
-but aren't sure what you'd like to contribute just yet, you can use the <a
-href="https://go.googlesource.com/scratch">scratch repository</a> to practice
-making a change.
-</p>
-
-<h2 id="making_a_change">Making a change</h2>
-
-<h3 id="checkout_go">Getting Go Source</h3>
-<p>
-First you need to have a local copy of the source checked out from the correct
-repository.
-As Go builds Go you will also likely need to have a working version
-of Go installed (some documentation changes may not need this).
-This should be a recent version of Go and can be obtained via any package or
-binary distribution or you can build it from source.
-</p>
-
-<p>
-You should checkout the Go source repo anywhere you want as long as it's
-outside of your $GOPATH.
-Go to a directory where you want the source to appear and run the following
-command in a terminal.
-</p>
-
-<pre>
-$ git clone https://go.googlesource.com/go
-$ cd go
-</pre>
-
-<h3 id="master">Contributing to the main Go tree</h3>
+<h3 id="master">Switch to the master branch</h3>

 <p>
 Most Go installations use a release branch, but new changes should
-only be made based on the master branch. <br>
+only be made based on the master branch.
 (They may be applied later to a release branch as part of the release process,
 but most contributors won't do this themselves.)
 Before making a change, make sure you start on the master branch:
@@ -352,61 +297,10 @@ $ git sync
 <code>git</code> <code>pull</code> <code>-r</code>.)
 </p>

-<h3 id="subrepos">Contributing to subrepositories (golang.org/x/...)</h3>
-
-<p>
-If you are contributing a change to a subrepository, obtain the
-Go package using <code>go get</code>. For example, to contribute
-to <code>golang.org/x/oauth2</code>, check out the code by running:
-</p>
-
-<pre>
-$ go get -d golang.org/x/oauth2/...
-</pre>
-
-<p>
-Then, change your directory to the package's source directory
-(<code>$GOPATH/src/golang.org/x/oauth2</code>).
-</p>
-
-<h3 id="change">Make your changes</h3>
-
-<p>
-The entire checked-out tree is editable.
-Make your changes as you see fit ensuring that you create appropriate
-tests along with your changes. Test your changes as you go.
-</p>
-
-<h3 id="copyright">Copyright</h3>
-
-<p>
-Files in the Go repository don't list author names, both to avoid clutter
-and to avoid having to keep the lists up to date.
-Instead, your name will appear in the
-<a href="https://golang.org/change">change log</a> and in the <a
-href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file and perhaps the <a
-href="/AUTHORS"><code>AUTHORS</code></a> file.
-These files are automatically generated from the commit logs periodically.
-The <a href="/AUTHORS"><code>AUTHORS</code></a> file defines who &ldquo;The Go
-Authors&rdquo;&mdash;the copyright holders&mdash;are.
-</p>
-
-<p>New files that you contribute should use the standard copyright header:</p>
-
-<pre>
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-</pre>
-
-<p>
-Files in the repository are copyright the year they are added.
-Do not update the copyright year on files that you change.
-</p>
-
-<h3 id="commit_changes">Commit your changes</h3>
+<h3 id="change">Make a change</h3>

 <p>
+The entire checked-out tree is writable.
 Once you have edited files, you must tell Git that they have been modified.
 You must also tell Git about any files that are added, removed, or renamed files.
 These operations are done with the usual Git commands,
@@ -417,26 +311,16 @@ and
 </p>

 <p>
-Once you have the changes queued up, you will want to commit them.
-In the Go contribution workflow this is done with a <code>git</code>
-<code>change</code> command, which creates a local branch and commits the changes
-directly to that local branch.
-</p>
-
-<p>
-The workflow described here assumes a single change per branch.
-It is also possible to prepare a sequence of (usually related) changes in a single branch.
-See the <a href="https://golang.org/x/review/git-codereview">git-codereview documentation</a> for details.
-</p>
+If you wish to checkpoint your work, or are ready to send the code out for review, run</p>

 <pre>
 $ git change <i>&lt;branch&gt;</i>
 </pre>

 <p>
+from any directory in your Go repository to commit the changes so far.
 The name <i>&lt;branch&gt;</i> is an arbitrary one you choose to identify the
-local branch containing your changes and will not be used elsewhere.
-This is an offline operation and nothing will be sent to the server yet.
+local branch containing your changes.
 </p>

 <p>
@@ -447,11 +331,9 @@ then <code>git</code> <code>commit</code>.)
 </p>

 <p>
-As the <code>git</code> <code>commit</code> is the final step, Git will open an
-editor to ask for a commit message. (It uses the editor named by
-the <code>$EDITOR</code> environment variable,
+Git will open a change description file in your editor.
+(It uses the editor named by the <code>$EDITOR</code> environment variable,
 <code>vi</code> by default.)
-
 The file will look like:
 </p>

@@ -470,7 +352,7 @@ At the beginning of this file is a blank line; replace it
 with a thorough description of your change.
 The first line of the change description is conventionally a one-line
 summary of the change, prefixed by the primary affected package,
-and is used as the subject for code review email.
+and is used as the subject for code review mail.
 It should complete the sentence "This change modifies Go to _____."
 The rest of the description elaborates and should provide context for the
 change and explain what it does.
@@ -505,7 +387,7 @@ Fixes #159

 <p>
 The commented section of the file lists all the modified files in your client.
-It is best to keep unrelated changes in different commits,
+It is best to keep unrelated changes in different change lists,
 so if you see a file listed that should not be included, abort
 the command and move that file to a different branch.
 </p>
@@ -513,7 +395,7 @@ the command and move that file to a different branch.
 <p>
 The special notation "Fixes #159" associates the change with issue 159 in the
 <a href="https://golang.org/issue/159">Go issue tracker</a>.
-When this change is eventually applied, the issue
+When this change is eventually submitted, the issue
 tracker will automatically mark the issue as fixed.
 (There are several such conventions, described in detail in the
 <a href="https://help.github.com/articles/closing-issues-via-commit-messages/">GitHub Issue Tracker documentation</a>.)
@@ -524,13 +406,6 @@ Once you have finished writing the commit message,
 save the file and exit the editor.
 </p>

-<p>
-You must have the $EDITOR environment variable set properly and working properly (exiting cleanly)
-for this operation to succeed.
-If you run into any issues at this step, it's likely your editor isn't exiting cleanly.
-Try setting a different editor in your $EDITOR environment variable.
-</p>
-
 <p>
 If you wish to do more editing, re-stage your changes using
 <code>git</code> <code>add</code>, and then run
@@ -541,8 +416,8 @@ $ git change
 </pre>

 <p>
-to update the change description and incorporate the staged changes.
-The change description contains a <code>Change-Id</code> line near the bottom,
+to update the change description and incorporate the staged changes.  The
+change description contains a <code>Change-Id</code> line near the bottom,
 added by a Git commit hook during the initial
 <code>git</code> <code>change</code>.
 That line is used by Gerrit to match successive uploads of the same change.
@@ -554,44 +429,35 @@ Do not edit or delete it.
 runs <code>git</code> <code>commit</code> <code>--amend</code>.)
 </p>

-<h3 id="Testing">Testing</h3>
+<h3 id="mail">Mail the change for review</h3>

 <p>
-You've <a href="code.html">written and tested your code</a>, but
-before sending code out for review, run all the tests for the whole
-tree to make sure the changes don't break other packages or programs:
-</p>
-
-<pre>
-$ cd go/src
-$ ./all.bash
-</pre>
-
-<p>
-(To build under Windows use <code>all.bat</code>.)
-</p>
-
-<p>
-After running for a while, the command should print
-</p>
-
-<pre>
-"ALL TESTS PASSED".
-</pre>
-
-<h3 id="mail">Send the change for review</h3>
-
-<p>
-Once the change is ready, send it for review.
-This is similar to a <code>git push</code> in a GitHub style workflow.
-This is done via the mail alias setup earlier which despite its name, doesn't
-directly mail anything, it simply sends the change to Gerrit via git push.
+Once the change is ready, mail it out for review:
 </p>

 <pre>
 $ git mail
 </pre>

+<p>
+You can specify a reviewer or CC interested parties
+using the <code>-r</code> or <code>-cc</code> options.
+Both accept a comma-separated list of email addresses:
+</p>
+
+<pre>
+$ git mail -r joe@golang.org -cc mabel@example.com,math-nuts@swtch.com
+</pre>
+
+<p>
+Unless explicitly told otherwise, such as in the discussion leading
+up to sending in the change list, it's better not to specify a reviewer.
+All changes are automatically CC'ed to the
+<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
+mailing list. If this is your first ever change, there may be a moderation
+delay before it appears on the mailing list, to prevent spam.
+</p>
+
 <p>
 (In Git terms, <code>git</code> <code>mail</code> pushes the local committed
 changes to Gerrit using <code>git</code> <code>push</code> <code>origin</code>
@@ -600,7 +466,7 @@ changes to Gerrit using <code>git</code> <code>push</code> <code>origin</code>

 <p>
 If your change relates to an open issue, please add a comment to the issue
-announcing your proposed fix, including a link to your change.
+announcing your proposed fix, including a link to your CL.
 </p>

 <p>
@@ -613,76 +479,7 @@ remote: New Changes:
 remote:   https://go-review.googlesource.com/99999 math: improved Sin, Cos and Tan precision for very large arguments
 </pre>

-<h3>Troubleshooting</h3>
-
-<p>
-The most common way that the <code>git mail</code> command fails is because the
-email address used has not gone through the setup above.
-<br>
-If you see something like...
-</p>
-
-<pre>
-remote: Processing changes: refs: 1, done
-remote:
-remote: ERROR:  In commit ab13517fa29487dcf8b0d48916c51639426c5ee9
-remote: ERROR:  author email address XXXXXXXXXXXXXXXXXXX
-remote: ERROR:  does not match your user account.
-</pre>
-
-<p>
-You need to either add the email address listed to the CLA or set this repo to use
-another email address already approved.
-</p>
-
-<p>
-First let's change the email address for this repo so this doesn't happen again.
-You can change your email address for this repo with the following command:
-</p>
-
-<pre>
-$ git config user.email email@address.com
-</pre>
-
-<p>
-Then change the previous commit to use this alternative email address.
-You can do that with:
-</p>
-
-<pre>
-$ git commit --amend --author="Author Name &lt;email@address.com&gt;"
-</pre>
-
-<p>
-Finally try to resend with:
-</p>
-
-<pre>
-$ git mail
-</pre>
-
-<h3 id="cc">Specifying a reviewer / CCing others</h3>
-
-<p>
-Unless explicitly told otherwise, such as in the discussion leading
-up to sending in the change, it's better not to specify a reviewer.
-All changes are automatically CC'ed to the
-<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
-mailing list. If this is your first ever change, there may be a moderation
-delay before it appears on the mailing list, to prevent spam.
-</p>
-
-<p>
-You can specify a reviewer or CC interested parties
-using the <code>-r</code> or <code>-cc</code> options.
-Both accept a comma-separated list of email addresses:
-</p>
-
-<pre>
-$ git mail -r joe@golang.org -cc mabel@example.com,math-nuts@swtch.com
-</pre>
-
-<h2 id="review">Going through the review process</h2>
+<h3 id="review">Reviewing code</h3>

 <p>
 Running <code>git</code> <code>mail</code> will send an email to you and the
@@ -690,30 +487,22 @@ reviewers asking them to visit the issue's URL and make comments on the change.
 When done, the reviewer adds comments through the Gerrit user interface
 and clicks "Reply" to send comments back.
 You will receive a mail notification when this happens.
-You may reply through the web interface or
-<a href="https://gerrit-review.googlesource.com/Documentation/intro-user.html#reply-by-email">via email</a>.
+You must reply through the web interface.
+(Unlike with the old Rietveld review system, replying by mail has no effect.)
 </p>

-<h3 id="revise">Revise and resend</h3>
+<h3 id="revise">Revise and upload</h3>

 <p>
-The Go contribution workflow is optimized for iterative revisions based on
-feedback.
-It is rare that an initial contribution will be ready to be applied as is.
-As you revise your contribution and resend Gerrit will retain a history of
-all the changes and comments made in the single URL.
-</p>
-
-<p>
-You may respond to review comments through the web interface or
-<a href="https://gerrit-review.googlesource.com/Documentation/intro-user.html#reply-by-email">via email</a>.
+You must respond to review comments through the web interface.
+(Unlike with the old Rietveld review system, responding by mail has no effect.)
 </p>

 <p>
 When you have revised the code and are ready for another round of review,
 stage those changes and use <code>git</code> <code>change</code> to update the
 commit.
-To send the updated change for another round of review,
+To send the update change list for another round of review,
 run <code>git</code> <code>mail</code> again.
 </p>

@@ -745,8 +534,6 @@ $ git sync
 <code>git</code> <code>pull</code> <code>-r</code>.)
 </p>

-<h3 id="resolving_conflicts">Resolving Conflicts</h3>
-
 <p>
 If files you were editing have changed, Git does its best to merge the
 remote changes into your local changes.
@@ -822,8 +609,8 @@ might turn up:
 <p>
 Git doesn't show it, but suppose the original text that both edits
 started with was 1e8; you changed it to 1e10 and the other change to 1e9,
-so the correct answer might now be 1e10.
-First, edit the section to remove the markers and leave the correct code:
+so the correct answer might now be 1e10.  First, edit the section
+to remove the markers and leave the correct code:
 </p>

 <pre>
@@ -852,13 +639,10 @@ restore the change commit.
 <h3 id="download">Reviewing code by others</h3>

 <p>
-As part of the review process reviewers can propose changes directly (in the
-GitHub workflow this would be someone else attaching commits to a pull request).
-
-You can import these changes proposed by someone else into your local Git repository.
+You can import a change proposed by someone else into your local Git repository.
 On the Gerrit review page, click the "Download ▼" link in the upper right
-corner, copy the "Checkout" command and run it from your local Git repo. It
-should look something like this:
+corner, copy the "Checkout" command and run it from your local Git repo.
+It should look something like this:
 </p>

 <pre>
@@ -869,11 +653,11 @@ $ git fetch https://go.googlesource.com/review refs/changes/21/1221/1 &amp;&amp;
 To revert, change back to the branch you were working in.
 </p>

-<h2 id="submit">Apply the change to the master branch</h2>
+<h3 id="submit">Submit the change after the review</h3>

 <p>
 After the code has been <code>LGTM</code>'ed, an approver may
-apply it to the master branch using the Gerrit UI.
+submit it to the master branch using the Gerrit UI.
 There is a "Submit" button on the web page for the change
 that appears once the change is approved (marked +2).
 </p>
@@ -885,13 +669,41 @@ and the code review will be updated with a link to the change
 in the repository.
 Since the method used to integrate the changes is "Cherry Pick",
 the commit hashes in the repository will be changed by
-the "Submit" operation.
+the submit operation.
 </p>

-<h2 id="more">More information</h2>
+<h3 id="more">More information</h3>

 <p>
-In addition to the information here, the Go community maintains a <a
-href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
+In addition to the information here, the Go community maintains a <a href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
 Feel free to contribute to this page as you learn the review process.
 </p>
+
+<h2 id="copyright">Copyright</h2>
+
+<p>Files in the Go repository don't list author names,
+both to avoid clutter and to avoid having to keep the lists up to date.
+Instead, your name will appear in the
+<a href="https://golang.org/change">change log</a>
+and in the <a href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file
+and perhaps the <a href="/AUTHORS"><code>AUTHORS</code></a> file.
+</p>
+
+<p>The <a href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file
+defines who the Go contributors&mdash;the people&mdash;are;
+the <a href="/AUTHORS"><code>AUTHORS</code></a> file defines
+who &ldquo;The Go Authors&rdquo;&mdash;the copyright holders&mdash;are.
+These files will be periodically updated based on the commit logs.
+
+<p>Code that you contribute should use the standard copyright header:</p>
+
+<pre>
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+</pre>
+
+<p>
+Files in the repository are copyright the year they are added. It is not
+necessary to update the copyright year on files that you change.
+</p>
--- a/doc/debugging_with_gdb.html
+++ b/doc/debugging_with_gdb.html
@@ -3,84 +3,50 @@
 	"Path": "/doc/gdb"
 }-->

-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
-->
-
-<i>
-<p>
-The following instructions apply to the standard toolchain
-(the <code>gc</code> Go compiler and tools).
-Gccgo has native gdb support.
-</p>
-<p>
-Note that 
-<a href="https://github.com/derekparker/delve">Delve</a> is a better 
-alternative to GDB when debugging Go programs built with the standard
-toolchain. It understands the Go runtime, data structures, and
-expressions better than GDB. Delve currently supports Linux, OSX,
-and Windows on <code>amd64</code>.
-For the most up-to-date list of supported platforms, please see
-<a href="https://github.com/derekparker/delve/tree/master/Documentation/installation">
- the Delve documentation</a>.
-</p>
-</i>
+<p><i>
+This applies to the <code>gc</code> toolchain. Gccgo has native gdb support.
+Besides this overview you might want to consult the
+<a href="http://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
+</i></p>

 <p>
 GDB does not understand Go programs well.
 The stack management, threading, and runtime contain aspects that differ
 enough from the execution model GDB expects that they can confuse
-the debugger and cause incorrect results even when the program is
-compiled with gccgo.
-As a consequence, although GDB can be useful in some situations (e.g.,
-debugging Cgo code, or debugging the runtime itself), it is not
-a reliable debugger for Go programs, particularly heavily concurrent
-ones.  Moreover, it is not a priority for the Go project to address
-these issues, which are difficult.
-</p>
-
-<p>
+the debugger, even when the program is compiled with gccgo.
+As a consequence, although GDB can be useful in some situations, it is
+not a reliable debugger for Go programs, particularly heavily concurrent ones.
+Moreover, it is not a priority for the Go project to address these issues, which
+are difficult.
 In short, the instructions below should be taken only as a guide to how
 to use GDB when it works, not as a guarantee of success.
-
-Besides this overview you might want to consult the
-<a href="http://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
 </p>

 <p>
+In time, a more Go-centric debugging architecture may be required.
 </p>

 <h2 id="Introduction">Introduction</h2>

 <p>
 When you compile and link your Go programs with the <code>gc</code> toolchain
-on Linux, Mac OS X, FreeBSD or NetBSD, the resulting binaries contain DWARFv4
-debugging information that recent versions (&ge;7.5) of the GDB debugger can
+on Linux, Mac OS X, FreeBSD or NetBSD, the resulting binaries contain DWARFv3
+debugging information that recent versions (&gt;7.1) of the GDB debugger can
 use to inspect a live process or a core dump.
 </p>

 <p>
 Pass the <code>'-w'</code> flag to the linker to omit the debug information
-(for example, <code>go</code> <code>build</code> <code>-ldflags=-w</code> <code>prog.go</code>).
+(for example, <code>go build -ldflags "-w" prog.go</code>).
 </p>

 <p>
 The code generated by the <code>gc</code> compiler includes inlining of
 function invocations and registerization of variables. These optimizations
-can sometimes make debugging with <code>gdb</code> harder.
-If you find that you need to disable these optimizations,
-build your program using <code>go</code> <code>build</code> <code>-gcflags=all="-N -l"</code>.
-</p>
-
-<p>
-If you want to use gdb to inspect a core dump, you can trigger a dump
-on a program crash, on systems that permit it, by setting
-<code>GOTRACEBACK=crash</code> in the environment (see the
-<a href="/pkg/runtime/#hdr-Environment_Variables"> runtime package
-documentation</a> for more info).
+can sometimes make debugging with <code>gdb</code> harder. To disable them
+when debugging, pass the flags <code>-gcflags "-N -l"</code> to the
+<a href="/cmd/go"><code>go</code></a> command used to build the code being
+debugged.
 </p>

 <h3 id="Common_Operations">Common Operations</h3>
@@ -119,7 +85,7 @@ Show the name, type and location of global variables:

 <p>
 A recent extension mechanism to GDB allows it to load extension scripts for a
-given binary. The toolchain uses this to extend GDB with a handful of
+given binary. The tool chain uses this to extend GDB with a handful of
 commands to inspect internals of the runtime code (such as goroutines) and to
 pretty print the built-in map, slice and channel types.
 </p>
@@ -164,7 +130,7 @@ the DWARF code.

 <p>
 If you're interested in what the debugging information looks like, run
-<code>objdump</code> <code>-W</code> <code>a.out</code> and browse through the <code>.debug_*</code>
+'<code>objdump -W 6.out</code>' and browse through the <code>.debug_*</code>
 sections.
 </p>

@@ -187,7 +153,7 @@ the form <code>pkg.(*MyType).Meth</code>.
 <p>
 In this tutorial we will inspect the binary of the
 <a href="/pkg/regexp/">regexp</a> package's unit tests. To build the binary,
-change to <code>$GOROOT/src/regexp</code> and run <code>go</code> <code>test</code> <code>-c</code>.
+change to <code>$GOROOT/src/regexp</code> and run <code>go test -c</code>.
 This should produce an executable file named <code>regexp.test</code>.
 </p>

@@ -213,7 +179,7 @@ Loading Go Runtime support.
 </pre>

 <p>
-The message "Loading Go Runtime support" means that GDB loaded the
+The message <code>"Loading Go Runtime support"</code> means that GDB loaded the
 extension from <code>$GOROOT/src/runtime/runtime-gdb.py</code>.
 </p>

@@ -378,7 +344,7 @@ Stack level 0, frame at 0x7ffff7f9ff88:
 </pre>

 <p>
-The command <code>info</code> <code>locals</code> lists all variables local to the function and their values, but is a bit
+The command <code>info locals</code> lists all variables local to the function and their values, but is a bit
 dangerous to use, since it will also try to print uninitialized variables. Uninitialized slices may cause gdb to try
 to print arbitrary large arrays.
 </p>
@@ -411,9 +377,7 @@ $3 = struct hchan&lt;*testing.T&gt;
 </pre>

 <p>
-That <code>struct</code> <code>hchan&lt;*testing.T&gt;</code> is the
-runtime-internal representation of a channel. It is currently empty,
-or gdb would have pretty-printed its contents.
+That <code>struct hchan&lt;*testing.T&gt;</code> is the runtime-internal representation of a channel.  It is currently empty, or gdb would have pretty-printed it's contents.
 </p>

 <p>
--- a/doc/devel/release.html
+++ b/doc/devel/release.html
@@ -15,88 +15,19 @@ git checkout <i>release-branch</i>
 <h2 id="policy">Release Policy</h2>

 <p>
-Each major Go release is supported until there are two newer major releases.
-For example, Go 1.8 is supported until Go 1.10 is released,
-and Go 1.9 is supported until Go 1.11 is released.
-We fix critical problems, including <a href="/security">critical security problems</a>,
-in supported releases as needed by issuing minor revisions
-(for example, Go 1.9.1, Go 1.9.2, and so on).
-</p>
-
-<h2 id="go1.9">go1.9 (released 2017/08/24)</h2>
-
-<p>
-Go 1.9 is a major release of Go.
-Read the <a href="/doc/go1.9">Go 1.9 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.9.minor">Minor revisions</h3>
-
-<p>
-go1.9.1 (released 2017/10/04) includes two security fixes.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.1">Go
-1.9.1 milestone</a> on our issue tracker for details.
+Each major Go release obsoletes and ends support for the previous one.
+For example, if Go 1.5 has been released, then it is the current release
+and Go 1.4 and earlier are no longer supported.
+We fix critical problems in the current release as needed by issuing minor revisions
+(for example, Go 1.5.1, Go 1.5.2, and so on).
 </p>

 <p>
-go1.9.2 (released 2017/10/25) includes fixes to the compiler, linker, runtime,
-documentation, <code>go</code> command,
-and the <code>crypto/x509</code>, <code>database/sql</code>, <code>log</code>,
-and <code>net/smtp</code> packages.
-It includes a fix to a bug introduced in Go 1.9.1 that broke <code>go</code> <code>get</code>
-of non-Git repositories under certain conditions.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.2">Go
-1.9.2 milestone</a> on our issue tracker for details.
-</p>
-
-<h2 id="go1.8">go1.8 (released 2017/02/16)</h2>
-
-<p>
-Go 1.8 is a major release of Go.
-Read the <a href="/doc/go1.8">Go 1.8 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.8.minor">Minor revisions</h3>
-
-<p>
-go1.8.1 (released 2017/04/07) includes fixes to the compiler, linker, runtime,
-documentation, <code>go</code> command and the <code>crypto/tls</code>,
-<code>encoding/xml</code>, <code>image/png</code>, <code>net</code>,
-<code>net/http</code>, <code>reflect</code>, <code>text/template</code>,
-and <code>time</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.1">Go
-1.8.1 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.8.2 (released 2017/05/23) includes a security fix to the
-<code>crypto/elliptic</code> package.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
-1.8.2 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.8.3 (released 2017/05/24) includes fixes to the compiler, runtime,
-documentation, and the <code>database/sql</code> package.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.3">Go
-1.8.3 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.8.4 (released 2017/10/04) includes two security fixes.
-It contains the same fixes as Go 1.9.1 and was released at the same time.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.4">Go
-1.8.4 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.8.5 (released 2017/10/25) includes fixes to the compiler, linker, runtime,
-documentation, <code>go</code> command,
-and the <code>crypto/x509</code> and <code>net/smtp</code> packages.
-It includes a fix to a bug introduced in Go 1.8.4 that broke <code>go</code> <code>get</code>
-of non-Git repositories under certain conditions.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.5">Go
-1.8.5 milestone</a> on our issue tracker for details.
+As a special case, we issue minor revisions for critical security problems
+in both the current release and the previous release.
+For example, if Go 1.5 is the current release then we will issue minor revisions
+to fix critical security problems in both Go 1.4 and Go 1.5 as they arise.
+See the <a href="/security">security policy</a> for more details.
 </p>

 <h2 id="go1.7">go1.7 (released 2016/08/15)</h2>
@@ -106,52 +37,6 @@ Go 1.7 is a major release of Go.
 Read the <a href="/doc/go1.7">Go 1.7 Release Notes</a> for more information.
 </p>

-<h3 id="go1.7.minor">Minor revisions</h3>
-
-<p>
-go1.7.1 (released 2016/09/07) includes fixes to the compiler, runtime,
-documentation, and the <code>compress/flate</code>, <code>hash/crc32</code>,
-<code>io</code>, <code>net</code>, <code>net/http</code>,
-<code>path/filepath</code>, <code>reflect</code>, and <code>syscall</code>
-packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.1">Go
-1.7.1 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.2 should not be used. It was tagged but not fully released.
-The release was deferred due to a last minute bug report.
-Use go1.7.3 instead, and refer to the summary of changes below.
-</p>
-
-<p>
-go1.7.3 (released 2016/10/19) includes fixes to the compiler, runtime,
-and the <code>crypto/cipher</code>, <code>crypto/tls</code>,
-<code>net/http</code>, and <code>strings</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.3">Go
-1.7.3 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.4 (released 2016/12/01) includes two security fixes.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
-1.7.4 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.5 (released 2017/01/26) includes fixes to the compiler, runtime,
-and the <code>crypto/x509</code> and <code>time</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.5">Go
-1.7.5 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.6 (released 2017/05/23) includes the same security fix as Go 1.8.2 and
-was released at the same time.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
-1.8.2 milestone</a> on our issue tracker for details.
-</p>
-
 <h2 id="go1.6">go1.6 (released 2016/02/17)</h2>

 <p>
@@ -178,18 +63,11 @@ See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.2">Go
 <p>
 go1.6.3 (released 2016/07/17) includes security fixes to the
 <code>net/http/cgi</code> package and <code>net/http</code> package when used in
-a CGI environment.
+a CGI environment. This release also adds support for macOS Sierra.
 See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.3">Go
 1.6.3 milestone</a> on our issue tracker for details.
 </p>

-<p>
-go1.6.4 (released 2016/12/01) includes two security fixes.
-It contains the same fixes as Go 1.7.4 and was released at the same time.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
-1.7.4 milestone</a> on our issue tracker for details.
-</p>
-
 <h2 id="go1.5">go1.5 (released 2015/08/19)</h2>

 <p>
--- a/doc/devel/weekly.html
+++ b/doc/devel/weekly.html
@@ -519,7 +519,7 @@ Other changes:
 	fix FreeBSD signal handling around thread creation (thanks Devon H. O'Dell),
 	goroutine profile, stack dumps,
 	implement runtime.osyield on FreeBSD 386, amd64 (thanks Devon H. O'Dell),
-	permit default behavior of SIGTSTP, SIGTTIN, SIGTTOU,
+	permit default behaviour of SIGTSTP, SIGTTIN, SIGTTOU,
 	release unused memory to the OS (thanks Sébastien Paolacci),
 	remove an obsolete file (thanks Mikio Hara).
 * spec: make all comparison results untyped bool,
@@ -2450,7 +2450,7 @@ The http package's URL parsing and query escaping code (such as ParseURL and
 URLEscape) has been moved to the new url package, with several simplifications
 to the names. Client code can be updated automatically with gofix.

-* asn1: support unmarshaling structs with int32 members (thanks Dave Cheney).
+* asn1: support unmarshalling structs with int32 members (thanks Dave Cheney).
 * build: allow builds without cgo or hg,
 	support versioning without hg (thanks Gustavo Niemeyer).
 * builtin: add documentation for builtins.
@@ -3030,7 +3030,7 @@ Other changes:
 * 5g: alignment fixes.
 * 6l, 8l: fix Mach-O binaries with many dynamic libraries.
 * 8l: emit resources (.rsrc) in Windows PE.  (thanks Wei Guangjing).
-* asn1: fix marshaling of empty optional RawValues (thanks Mikkel Krautz).
+* asn1: fix marshalling of empty optional RawValues (thanks Mikkel Krautz).
 * big: make Int and Rat implement fmt.Scanner (thanks Evan Shaw),
 	~8x faster number scanning,
 	remove some unnecessary conversions.
@@ -4157,7 +4157,7 @@ Other changes in this release:
 * suffixarray: use binary search for both ends of Lookup (thanks Eric Eisner).
 * syscall: add missing network interface constants (thanks Mikio Hara).
 * template: treat map keys as zero, not non-existent (thanks Roger Peppe).
-* time: allow canceling of After events (thanks Roger Peppe),
+* time: allow cancelling of After events (thanks Roger Peppe),
        support Solaris zoneinfo directory.
 * token/position: added SetLinesForContent.
 * unicode: update to unicode 6.0.0.
@@ -4238,7 +4238,7 @@ example: http://golang.org/pkg/xml/
 <pre>
 The json, gob, and template packages have changed, and code that uses them
 may need to be updated after this release. They will no longer read or write
-unexported struct fields. When marshaling a struct with json or gob the
+unexported struct fields. When marshalling a struct with json or gob the
 unexported fields will be silently ignored. Attempting to unmarshal json or
 gob data into an unexported field will generate an error. Accessing an
 unexported field from a template will cause the Execute function to return
@@ -5682,7 +5682,7 @@ Other changes:
 	pidigits ~10% performance win by using adds instead of shifts.
 * time: remove incorrect time.ISO8601 and add time.RFC3339 (thanks Micah Stetson).
 * utf16: add DecodeRune, EncodeRune.
-* xml: add support for XML marshaling embedded structs (thanks Raif S. Naffah),
+* xml: add support for XML marshalling embedded structs (thanks Raif S. Naffah),
 	new "innerxml" tag to collect inner XML.
 </pre>

@@ -5696,7 +5696,7 @@ This release contains many changes:
 * cmath: new complex math library (thanks Charles L. Dorian).
 * docs: update to match current coding style (thanks Christopher Wedgwood).
 * exp/eval: fix example and add target to Makefile (thanks Evan Shaw).
-* fmt: change behavior of format verb %b to match %x when negative (thanks Andrei Vieru).
+* fmt: change behaviour of format verb %b to match %x when negative (thanks Andrei Vieru).
 * gc: compile s == "" as len(s) == 0,
 	distinguish fatal compiler bug from error+exit,
 	fix alignment on non-amd64,
@@ -5925,10 +5925,10 @@ Other changes and fixes:
 * 8a/8l: Added CMOVcc instructions (thanks Evan Shaw)
 * 8l: pe executable building code changed to include import table for kernel32.dll functions (thanks Alex Brainman)
 * 5g/6g/8g: bug fixes
-* asn1: bug fixes and additions (incl marshaling)
+* asn1: bug fixes and additions (incl marshalling)
 * build: fix build for Native Client, Linux/ARM
 * dashboard: show benchmarks, add garbage collector benchmarks
-* encoding/pem: add marshaling support
+* encoding/pem: add marshalling support
 * exp/draw: fast paths for a nil mask
 * godoc: support for directories outside $GOROOT
 * http: sort header keys when writing Response or Request to wire (thanks Petar Maymounkov)
--- a/doc/diagnostics.html
+++ b/doc/diagnostics.html
@@ -1,460 +0,0 @@
-<!--{
-	"Title": "Diagnostics",
-	"Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-The Go ecosystem provides a large suite of APIs and tools to
-diagnose logic and performance problems in Go programs. This page
-summarizes the available tools and helps Go users pick the right one
-for their specific problem.
-</p>
-
-<p>
-Diagnostics solutions can be categorized into the following groups:
-</p>
-
-<ul>
-<li><strong>Profiling</strong>: Profiling tools analyze the complexity and costs of a
-Go program such as its memory usage and frequently called
-functions to identify the expensive sections of a Go program.</li>
-<li><strong>Tracing</strong>: Tracing is a way to instrument code to analyze latency
-throughout the lifecycle of a call or user request. Traces provide an
-overview of how much latency each component contributes to the overall
-latency in a system. Traces can span multiple Go processes.</li>
-<li><strong>Debugging</strong>: Debugging allows us to pause a Go program and examine
-its execution. Program state and flow can be verified with debugging.</li>
-<li><strong>Runtime statistics and events</strong>: Collection and analysis of runtime stats and events
-provides a high-level overview of the health of Go programs. Spikes/dips of metrics
-helps us to identify changes in throughput, utilization, and performance.</li>
-</ul>
-
-<p>
-Note: Some diagnostics tools may interfere with each other. For example, precise
-memory profiling skews CPU profiles and goroutine blocking profiling affects scheduler
-trace. Use tools in isolation to get more precise info.
-</p>
-
-<h2 id="profiling">Profiling</h2>
-
-<p>
-Profiling is useful for identifying expensive or frequently called sections
-of code. The Go runtime provides <a href="https://golang.org/pkg/runtime/pprof/">
-profiling data</a> in the format expected by the
-<a href="https://github.com/google/pprof/blob/master/doc/pprof.md">pprof visualization tool</a>.
-The profiling data can be collected during testing
-via <code>go</code> <code>test</code> or endpoints made available from the <a href="/pkg/net/http/pprof/">
-net/http/pprof</a> package. Users need to collect the profiling data and use pprof tools to filter
-and visualize the top code paths.
-</p>
-
-<p>Predefined profiles provided by the <a href="/pkg/runtime/pprof">runtime/pprof</a> package:</p>
-
-<ul>
-<li>
-<strong>cpu</strong>: CPU profile determines where a program spends
-its time while actively consuming CPU cycles (as opposed to while sleeping or waiting for I/O).
-</li>
-<li>
-<strong>heap</strong>: Heap profile reports memory allocation samples;
-used to monitor current and historical memory usage, and to check for memory leaks.
-</li>
-<li>
-<strong>threadcreate</strong>: Thread creation profile reports the sections
-of the program that lead the creation of new OS threads.
-</li>
-<li>
-<strong>goroutine</strong>: Goroutine profile reports the stack traces of all current goroutines.
-</li>
-<li>
-<strong>block</strong>: Block profile shows where goroutines block waiting on synchronization
-primitives (including timer channels). Block profile is not enabled by default;
-use <code>runtime.SetBlockProfileRate</code> to enable it.
-</li>
-<li>
-<strong>mutex</strong>: Mutex profile reports the lock contentions. When you think your
-CPU is not fully utilized due to a mutex contention, use this profile. Mutex profile
-is not enabled by default, see <code>runtime.SetMutexProfileFraction</code> to enable it.
-</li>
-</ul>
-
-
-<p><strong>What other profilers can I use to profile Go programs?</strong></p>
-
-<p>
-On Linux, <a href="https://perf.wiki.kernel.org/index.php/Tutorial">perf tools</a>
-can be used for profiling Go programs. Perf can profile
-and unwind cgo/SWIG code and kernel, so it can be useful to get insights into
-native/kernel performance bottlenecks. On macOS,
-<a href="https://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/">Instruments</a>
-suite can be used profile Go programs.
-</p>
-
-<p><strong>Can I profile my production services?</strong></p>
-
-<p>Yes. It is safe to profile programs in production, but enabling
-some profiles (e.g. the CPU profile) adds cost. You should expect to
-see performance downgrade. The performance penalty can be estimated
-by measuring the overhead of the profiler before turning it on in
-production.
-</p>
-
-<p>
-You may want to periodically profile your production services.
-Especially in a system with many replicas of a single process, selecting
-a random replica periodically is a safe option.
-Select a production process, profile it for
-X seconds for every Y seconds and save the results for visualization and
-analysis; then repeat periodically. Results may be manually and/or automatically
-reviewed to find problems.
-Collection of profiles can interfere with each other,
-so it is recommended to collect only a single profile at a time.
-</p>
-
-<p>
-<strong>What are the best ways to visualize the profiling data?</strong>
-</p>
-
-<p>
-The Go tools provide text, graph, and <a href="http://valgrind.org/docs/manual/cl-manual.html">callgrind</a>
-visualization of the profile data using
-<code><a href="https://github.com/google/pprof/blob/master/doc/pprof.md">go tool pprof</a></code>.
-Read <a href="https://blog.golang.org/profiling-go-programs">Profiling Go programs</a>
-to see them in action.
-</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-text.png">
-<br>
-<small>Listing of the most expensive calls as text.</small>
-</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-dot.png">
-<br>
-<small>Visualization of the most expensive calls as a graph.</small>
-</p>
-
-<p>Weblist view displays the expensive parts of the source line by line in
-an HTML page. In the following example, 530ms is spent in the
-<code>runtime.concatstrings</code> and cost of each line is presented
-in the listing.</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-weblist.png">
-<br>
-<small>Visualization of the most expensive calls as weblist.</small>
-</p>
-
-<p>
-Another way to visualize profile data is a <a href="http://www.brendangregg.com/flamegraphs.html">flame graph</a>.
-Flame graphs allow you to move in a specific ancestry path, so you can zoom
-in/out of specific sections of code.
-The <a href="https://github.com/google/pprof">upstream pprof</a>
-has support for flame graphs.
-</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/flame.png">
-<br>
-<small>Flame graphs offers visualization to spot the most expensive code-paths.</small>
-</p>
-
-<p><strong>Am I restricted to the built-in profiles?</strong></p>
-
-<p>
-Additionally to what is provided by the runtime, Go users can create
-their custom profiles via <a href="/pkg/runtime/pprof/#Profile">pprof.Profile</a>
-and use the existing tools to examine them.
-</p>
-
-<p><strong>Can I serve the profiler handlers (/debug/pprof/...) on a different path and port?</strong></p>
-
-<p>
-Yes. The <code>net/http/pprof</code> package registers its handlers to the default
-mux by default, but you can also register them yourself by using the handlers
-exported from the package.
-</p>
-
-<p>
-For example, the following example will serve the pprof.Profile
-handler on :7777 at /custom_debug_path/profile:
-</p>
-
-<p>
-<pre>
-package main
-
-import (
-	"log"
-	"net/http"
-	"net/http/pprof"
-)
-
-func main() {
-	mux := http.NewServeMux()
-	mux.HandleFunc("/custom_debug_path/profile", pprof.Profile)
-	log.Fatal(http.ListenAndServe(":7777", mux))
-}
-</pre>
-</p>
-
-<h2 id="tracing">Tracing</h2>
-
-<p>
-Tracing is a way to instrument code to analyze latency throughout the
-lifecycle of a chain of calls. Go provides
-<a href="https://godoc.org/golang.org/x/net/trace">golang.org/x/net/trace</a>
-package as a minimal tracing backend per Go node and provides a minimal
-instrumentation library with a simple dashboard. Go also provides
-an execution tracer to trace the runtime events within an interval.
-</p>
-
-<p>Tracing enables us to:</p>
-
-<ul>
-<li>Instrument and profile application latency in a Go process.</li>
-<li>Measure the cost of specific calls in a long chain of calls.</li>
-<li>Figure out the utilization and performance improvements.
-Bottlenecks are not always obvious without tracing data.</li>
-</ul>
-
-<p>
-In monolithic systems, it's relatively easy to collect diagnostic data
-from the building blocks of a program. All modules live within one
-process and share common resources to report logs, errors, and other
-diagnostic information. Once your system grows beyond a single process and
-starts to become distributed, it becomes harder to follow a call starting
-from the front-end web server to all of its back-ends until a response is
-returned back to the user. This is where distributed tracing plays a big
-role to instrument and analyze your production systems.
-</p>
-
-<p>
-Distributed tracing is a way to instrument code to analyze latency throughout
-the lifecycle of a user request. When a system is distributed and when
-conventional profiling and debugging tools don’t scale, you might want
-to use distributed tracing tools to analyze the performance of your user
-requests and RPCs.
-</p>
-
-<p>Distributed tracing enables us to:</p>
-
-<ul>
-<li>Instrument and profile application latency in a large system.</li>
-<li>Track all RPCs within the lifecycle of a user request and see integration issues
-that are only visible in production.</li>
-<li>Figure out performance improvements that can be applied to our systems.
-Many bottlenecks are not obvious before the collection of tracing data.</li>
-</ul>
-
-<p>The Go ecosystem provides various distributed tracing libraries per tracing system
-and backend-agnostic ones.</p>
-
-
-<p><strong>Is there a way to automatically intercept each function call and create traces?</strong></p>
-
-<p>
-Go doesn’t provide a way to automatically intercept every function call and create
-trace spans. You need to manually instrument your code to create, end, and annotate spans.
-</p>
-
-<p><strong>How should I propagate trace headers in Go libraries?</strong></p>
-
-<p>
-You can propagate trace identifiers and tags in the
-<a href="/pkg/context#Context"><code>context.Context</code></a>.
-There is no canonical trace key or common representation of trace headers
-in the industry yet. Each tracing provider is responsible for providing propagation
-utilities in their Go libraries.
-</p>
-
-<p>
-<strong>What other low-level events from the standard library or
-runtime can be included in a trace?</strong>
-</p>
-
-<p>
-The standard library and runtime are trying to expose several additional APIs
-to notify on low level internal events. For example,
-<a href="/pkg/net/http/httptrace#ClientTrace"><code>httptrace.ClientTrace</code></a>
-provides APIs to follow low-level events in the life cycle of an outgoing request.
-There is an ongoing effort to retrieve low-level runtime events from
-the runtime execution tracer and allow users to define and record their user events.
-</p>
-
-<h2 id="debugging">Debugging</h2>
-
-<p>
-Debugging is the process of identifying why a program misbehaves.
-Debuggers allow us to understand a program’s execution flow and current state.
-There are several styles of debugging; this section will only focus on attaching
-a debugger to a program and core dump debugging.
-</p>
-
-<p>Go users mostly use the following debuggers:</p>
-
-<ul>
-<li>
-<a href="https://github.com/derekparker/delve">Delve</a>:
-Delve is a debugger for the Go programming language. It has
-support for Go’s runtime concepts and built-in types. Delve is
-trying to be a fully featured reliable debugger for Go programs.
-</li>
-<li>
-<a href="https://golang.org/doc/gdb">GDB</a>:
-Go provides GDB support via the standard Go compiler and Gccgo.
-The stack management, threading, and runtime contain aspects that differ
-enough from the execution model GDB expects that they can confuse the
-debugger, even when the program is compiled with gccgo. Even though
-GDB can be used to debug Go programs, it is not ideal and may
-create confusion.
-</li>
-</ul>
-
-<p><strong>How well do debuggers work with Go programs?</strong></p>
-
-<p>
-The <code>gc</code> compiler performs optimizations such as
-function inlining and variable registerization. These optimizations
-sometimes make debugging with debuggers harder. There is an ongoing
-effort to improve the quality of the DWARF information generated for
-optimized binaries. Until those improvements are available, we recommend
-disabling optimizations when building the code being debugged. The following
-command builds a package with no compiler optimizations:
-
-<p>
-<pre>
-$ go build -gcflags=all="-N -l"
-</pre>
-</p>
-
-As part of the improvement effort, Go 1.10 introduced a new compiler
-flag <code>-dwarflocationlists</code>. The flag causes the compiler to
-add location lists that helps debuggers work with optimized binaries.
-The following command builds a package with optimizations but with
-the DWARF location lists:
-
-<p>
-<pre>
-$ go build -gcflags="-dwarflocationlists=true"
-</pre>
-</p>
-
-<p><strong>What’s the recommended debugger user interface?</strong></p>
-
-<p>
-Even though both delve and gdb provides CLIs, most editor integrations
-and IDEs provides debugging-specific user interfaces. Please refer to
-the <a href="/doc/editors.html">editors guide</a> to see the options
-with debugger UI support.
-</p>
-
-<p><strong>Is it possible to do postmortem debugging with Go programs?</strong></p>
-
-<p>
-A core dump file is a file that contains the memory dump of a running
-process and its process status. It is primarily used for post-mortem
-debugging of a program and to understand its state
-while it is still running. These two cases make debugging of core
-dumps a good diagnostic aid to postmortem and analyze production
-services. It is possible to obtain core files from Go programs and
-use delve or gdb to debug, see the
-<a href="https://golang.org/wiki/CoreDumpDebugging">core dump debugging</a>
-page for a step-by-step guide.
-</p>
-
-<h2 id="runtime">Runtime statistics and events</h2>
-
-<p>
-The runtime provides stats and reporting of internal events for
-users to diagnose performance and utilization problems at the
-runtime level.
-</p>
-
-<p>
-Users can monitor these stats to better understand the overall
-health and performance of Go programs.
-Some frequently monitored stats and states:
-</p>
-
-<ul>
-<li><code><a href="/pkg/runtime/#ReadMemStats">runtime.ReadMemStats</a></code>
-reports the metrics related to heap
-allocation and garbage collection. Memory stats are useful for
-monitoring how much memory resources a process is consuming,
-whether the process can utilize memory well, and to catch
-memory leaks.</li>
-<li><code><a href="/pkg/runtime/debug/#ReadGCStats">debug.ReadGCStats</a></code>
-reads statistics about garbage collection.
-It is useful to see how much of the resources are spent on GC pauses.
-It also reports a timeline of garbage collector pauses and pause time percentiles.</li>
-<li><code><a href="/pkg/runtime/debug/#Stack">debug.Stack</a></code>
-returns the current stack trace. Stack trace
-is useful to see how many goroutines are currently running,
-what they are doing, and whether they are blocked or not.</li>
-<li><code><a href="/pkg/runtime/debug/#WriteHeapDump">debug.WriteHeapDump</a></code>
-suspends the execution of all goroutines
-and allows you to dump the heap to a file. A heap dump is a
-snapshot of a Go process' memory at a given time. It contains all
-allocated objects as well as goroutines, finalizers, and more.</li>
-<li><code><a href="/pkg/runtime#NumGoroutine">runtime.NumGoroutine</a></code>
-returns the number of current goroutines.
-The value can be monitored to see whether enough goroutines are
-utilized, or to detect goroutine leaks.</li>
-</ul>
-
-<h3 id="execution-tracer">Execution tracer</h3>
-
-<p>Go comes with a runtime execution tracer to capture a wide range
-of runtime events. Scheduling, syscall, garbage collections,
-heap size, and other events are collected by runtime and available
-for visualization by the go tool trace. Execution tracer is a tool
-to detect latency and utilization problems. You can examine how well
-the CPU is utilized, and when networking or syscalls are a cause of
-preemption for the goroutines.</p>
-
-<p>Tracer is useful to:</p>
-<ul>
-<li>Understand how your goroutines execute.</li>
-<li>Understand some of the core runtime events such as GC runs.</li>
-<li>Identify poorly parallelized execution.</li>
-</ul>
-
-<p>However, it is not great for identifying hot spots such as
-analyzing the cause of excessive memory or CPU usage.
-Use profiling tools instead first to address them.</p>
-
-<p>
-<img width="800" src="https://storage.googleapis.com/golangorg-assets/tracer-lock.png">
-</p>
-
-<p>Above, the go tool trace visualization shows the execution started
-fine, and then it became serialized. It suggests that there might
-be lock contention for a shared resource that creates a bottleneck.</p>
-
-<p>See <a href="https://golang.org/cmd/trace/"><code>go</code> <code>tool</code> <code>trace</code></a>
-to collect and analyze runtime traces.
-</p>
-
-<h3 id="godebug">GODEBUG</h3>
-
-<p>Runtime also emits events and information if
-<a href="https://golang.org/pkg/runtime/#hdr-Environment_Variables">GODEBUG</a>
-environmental variable is set accordingly.</p>
-
-<ul>
-<li>GODEBUG=gctrace=1 prints garbage collector events at
-each collection, summarizing the amount of memory collected
-and the length of the pause.</li>
-<li>GODEBUG=schedtrace=X prints scheduling events every X milliseconds.</li>
-</ul>
--- a/doc/docs.html
+++ b/doc/docs.html
@@ -1,7 +1,6 @@
 <!--{
 	"Title": "Documentation",
-	"Path": "/doc/",
-	"Template": true
+	"Path": "/doc/"
 }-->

 <p>
@@ -34,43 +33,22 @@ libraries.

 <img class="gopher" src="/doc/gopher/doc.png"/>

-<h3 id="go_tour">
-	{{if $.GoogleCN}}
-	  A Tour of Go
-	{{else}}
-	  <a href="//tour.golang.org/">A Tour of Go</a>
-	{{end}}
-</h3>
+<h3 id="go_tour"><a href="//tour.golang.org/">A Tour of Go</a></h3>
 <p>
 An interactive introduction to Go in three sections.
 The first section covers basic syntax and data structures; the second discusses
 methods and interfaces; and the third introduces Go's concurrency primitives.
 Each section concludes with a few exercises so you can practice what you've
-learned. You can {{if not $.GoogleCN}}<a href="//tour.golang.org/">take the tour
-online</a> or{{end}} install it locally with:
-</p>
-<pre>
-$ go get golang.org/x/tour/gotour
-</pre>
-<p>
-This will place the <code>gotour</code> binary in your workspace's <code>bin</code> directory.
+learned. You can <a href="//tour.golang.org/">take the tour online</a> or
+<a href="//code.google.com/p/go-tour/">install it locally</a>.
 </p>

 <h3 id="code"><a href="code.html">How to write Go code</a></h3>
 <p>
-{{if not $.GoogleCN}}
-Also available as a <a href="//www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>, this
-{{else}}
-This
-{{end}}
-doc explains how to use the <a href="/cmd/go/">go command</a>
-to fetch, build, and install packages, commands, and run tests.
-</p>
-
-<h3 id="editors"><a href="editors.html">Editor plugins and IDEs</a></h3>
-<p>
-A document that summarizes commonly used editor plugins and IDEs with
-Go support.
+Also available as a
+<a href="//www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>, this doc
+explains how to use the <a href="/cmd/go/">go command</a> to fetch, build, and
+install packages, commands, and run tests.
 </p>

 <h3 id="effective_go"><a href="effective_go.html">Effective Go</a></h3>
@@ -80,11 +58,6 @@ A must read for any new Go programmer. It augments the tour and
 the language specification, both of which should be read first.
 </p>

-<h3 id="diagnostics"><a href="/doc/diagnostics.html">Diagnostics</a></h3>
-<p>
-Summarizes tools and methodologies to diagnose problems in Go programs.
-</p>
-
 <h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
 <p>
 Answers to common questions about Go.
@@ -130,11 +103,9 @@ same variable in a different goroutine.

 <h2 id="articles">Articles</h2>

-{{if not $.GoogleCN}}
 <h3 id="blog"><a href="//blog.golang.org/">The Go Blog</a></h3>
 <p>The official blog of the Go project, featuring news and in-depth articles by
 the Go team and guests.</p>
-{{end}}

 <h4>Codewalks</h4>
 <p>
@@ -147,7 +118,6 @@ Guided tours of Go programs.
 <li><a href="/doc/articles/wiki/">Writing Web Applications</a> - building a simple web application.</li>
 </ul>

-{{if not $.GoogleCN}}
 <h4>Language</h4>
 <ul>
 <li><a href="/blog/json-rpc-tale-of-interfaces">JSON-RPC: a tale of interfaces</a></li>
@@ -168,20 +138,17 @@ Guided tours of Go programs.
 <li><a href="/blog/go-image-package">The Go image package</a> - the fundamentals of the <a href="/pkg/image/">image</a> package.</li>
 <li><a href="/blog/go-imagedraw-package">The Go image/draw package</a> - the fundamentals of the <a href="/pkg/image/draw/">image/draw</a> package.</li>
 </ul>
-{{end}}

 <h4>Tools</h4>
 <ul>
 <li><a href="/doc/articles/go_command.html">About the Go command</a> - why we wrote it, what it is, what it's not, and how to use it.</li>
-<li><a href="/doc/gdb">Debugging Go Code with GDB</a></li>
-<li><a href="/doc/articles/race_detector.html">Data Race Detector</a> - a manual for the data race detector.</li>
-<li><a href="/doc/asm">A Quick Guide to Go's Assembler</a> - an introduction to the assembler used by Go.</li>
-{{if not $.GoogleCN}}
 <li><a href="/blog/c-go-cgo">C? Go? Cgo!</a> - linking against C code with <a href="/cmd/cgo/">cgo</a>.</li>
+<li><a href="/doc/gdb">Debugging Go Code with GDB</a></li>
 <li><a href="/blog/godoc-documenting-go-code">Godoc: documenting Go code</a> - writing good documentation for <a href="/cmd/godoc/">godoc</a>.</li>
 <li><a href="/blog/profiling-go-programs">Profiling Go Programs</a></li>
+<li><a href="/doc/articles/race_detector.html">Data Race Detector</a> - a manual for the data race detector.</li>
 <li><a href="/blog/race-detector">Introducing the Go Race Detector</a> - an introduction to the race detector.</li>
-{{end}}
+<li><a href="/doc/asm">A Quick Guide to Go's Assembler</a> - an introduction to the assembler used by Go.</li>
 </ul>

 <h4 id="articles_more">More</h4>
@@ -190,7 +157,7 @@ See the <a href="/wiki/Articles">Articles page</a> at the
 <a href="/wiki">Wiki</a> for more Go articles.
 </p>

-{{if not $.GoogleCN}}
+
 <h2 id="talks">Talks</h2>

 <img class="gopher" src="/doc/gopher/talks.png"/>
@@ -221,7 +188,7 @@ This talk expands on the <i>Go Concurrency Patterns</i> talk to dive deeper into
 <p>
 See the <a href="/talks">Go Talks site</a> and <a href="/wiki/GoTalks">wiki page</a> for more Go talks.
 </p>
-{{end}}
+

 <h2 id="nonenglish">Non-English Documentation</h2>

--- a/doc/editors.html
+++ b/doc/editors.html
@@ -1,231 +0,0 @@
-<!--{
-	"Title": "Editor plugins and IDEs",
-	"Template": true
-}-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-  This document lists commonly used editor plugins and IDEs from the Go ecosystem
-  that make Go development more productive and seamless.
-  A comprehensive list of editor support and IDEs for Go development is available at
-  <a href="http://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
-</p>
-
-<h2 id="options">Options</h2>
-<p>
-The Go ecosystem provides a variety of editor plugins and IDEs to enhance your day-to-day
-editing, navigation, testing, and debugging experience.
-</p>
-
-<ul>
-<li><a href="https://github.com/fatih/vim-go">vim</a>: vim-go plugin provides Go programming language support</li>
-<li><a href="https://marketplace.visualstudio.com/items?itemName=lukehoban.Go">Visual Studio Code</a>:
-Go extension provides support for the Go programming language</li>
-<li><a href="https://www.jetbrains.com/go">GoLand</a>: GoLand is distributed either as a standalone IDE
-or as a plugin for IntelliJ IDEA Ultimate</li>
-<li><a href="https://atom.io/packages/go-plus">Atom</a>: Go-Plus is an Atom package that provides enhanced Go support</li>
-</ul>
-
-<p>
-Note that these are only a few top solutions; a more comphensive
-community-maintained list of
-<a href="https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins">IDEs and text editor plugins</a>
-is available at the Wiki.
-</p>
-
-<p>
-Each development environment integrates a number of Go-specific tools.
-The following feature matrix lists and compares the most significant features.
-</p>
-
-<table class="features-matrix">
-  <tr>
-    <th></th>
-    <th><img title="Vim Go" src="/doc/editors/vimgo.png"><br>vim</th>
-    <th><img title="Visual Studio Code" src="/doc/editors/vscodego.png"><br>Visual Studio Code</th>
-    <th><img title="GoLand" src="/doc/editors/goland.png"><br>GoLand</th>
-    <th><img title="Go-Plus" src="/doc/editors/go-plus.png"><br>Atom</th>
-  </tr>
-  <tr>
-    <td class="feature-row" colspan="5">Editing features</td>
-  </tr>
-  <tr>
-    <td>Build and run from the editor/IDE</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Autocompletion of identifiers (variable, method, and function names)</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Type-aware autocompletion</td>
-    <td class="no">No</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="no">No</td>
-  </tr>
-  <tr>
-    <td>Rename identifiers</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Auto format, build, vet, and lint on save</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes<sup>1</sup></td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Auto insert import paths and remove unused on save</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes<sup>2</sup></td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Auto generate JSON, XML tags for struct fields</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td class="feature-row" colspan="5">Navigation features</td>
-  </tr>
-  <tr>
-    <td>Display documentation inline, or open godoc in browser</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Switch between <code>*.go</code> and <code>*_test.go</code> file</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">No</td>
-  </tr>
-  <tr>
-    <td>Jump to definition and referees</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Look up for interface implementations</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Search for callers and callees</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td class="feature-row" colspan="5">Testing and debugging features</td>
-  </tr>
-  <tr>
-    <td>Debugger support</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes<sup>3</sup></td>
-
-  </tr>
-  <tr>
-    <td>Run a single test case, all tests from file, or all tests from a package</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="no">No</td>
-  </tr>
-  <tr>
-    <td>Auto generate tests for packages, files and identifiers</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="no">No</td>
-  </tr>
-  <tr>
-    <td>Debug tests</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes<sup>3</sup></td>
-  </tr>
-  <tr>
-    <td>Display test coverage</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr class="download">
-    <td></td>
-    <td><a href="https://github.com/fatih/vim-go">Install</a></td>
-    <td><a href="https://marketplace.visualstudio.com/items?itemName=lukehoban.Go">Install</a></td>
-    <td><a href="https://www.jetbrains.com/go">Install</a></td>
-    <td><a href="https://atom.io/packages/go-plus">Install</a></td>
-  </tr>
-</table>
-
-<p>
-<sup>1</sup>Possible when enabled via Settings &gt; Go &gt; On Save, <code>go</code> <code>vet</code> and <code>golint</code> are available via plugins. Also runs tests on save if configured.
-<br>
-<sup>2</sup>Additionally, user input can disambiguate when two or more options are available.
-<br>
-<sup>3</sup>Available if the <a href="https://atom.io/packages/go-debug">go-debug</a> package is installed.
-</p>
-
-</div>
-
-<style>
-.features-matrix {
-  min-width: 800px;
-  border-collapse: collapse;
-}
-.features-matrix th {
-  width: 60px;
-  text-align: center;
-  font-size: 14px;
-  color: #666;
-}
-.features-matrix th img {
-  width: 48px;
-}
-.features-matrix .yes {
-  text-align: center;
-}
-.features-matrix .no {
-  text-align: center;
-  background-color: #ffe9e9;
-}
-.features-matrix .download {
-  font-weight: bold;
-  text-align: center;
-}
-.features-matrix td {
-  padding: 11px 5px 11px 5px;
-  border-bottom: solid 1px #ebebeb;
-}
-.features-matrix .feature-row {
-  background-color: #ebebeb;
-  font-weight: bold;
-}
-</style>
--- a/doc/editors/go-plus.png
+++ b/doc/editors/go-plus.png
--- a/doc/editors/goland.png
+++ b/doc/editors/goland.png
--- a/doc/editors/vimgo.png
+++ b/doc/editors/vimgo.png
--- a/doc/editors/vscodego.png
+++ b/doc/editors/vscodego.png
--- a/doc/effective_go.html
+++ b/doc/effective_go.html
@@ -245,15 +245,15 @@ func Compile(str string) (*Regexp, error) {
 </pre>

 <p>
-If every doc comment begins with the name of the item it describes,
-the output of <code>godoc</code> can usefully be run through <code>grep</code>.
+If the name always begins the comment, the output of <code>godoc</code>
+can usefully be run through <code>grep</code>.
 Imagine you couldn't remember the name "Compile" but were looking for
 the parsing function for regular expressions, so you ran
 the command,
 </p>

 <pre>
-$ godoc regexp | grep -i parse
+$ godoc regexp | grep parse
 </pre>

 <p>
@@ -1431,7 +1431,9 @@ func Append(slice, data []byte) []byte {
        slice = newSlice
    }
    slice = slice[0:l+len(data)]
-    copy(slice[l:], data)
+    for i, c := range data {
+        slice[l+i] = c
+    }
    return slice
 }
 </pre>
@@ -1519,7 +1521,7 @@ for i := range picture {
 <p>
 Maps are a convenient and powerful built-in data structure that associate
 values of one type (the <em>key</em>) with values of another type
-(the <em>element</em> or <em>value</em>).
+(the <em>element</em> or <em>value</em>)
 The key can be of any type for which the equality operator is defined,
 such as integers,
 floating point and complex numbers,
@@ -1578,7 +1580,7 @@ if attended[person] { // will be false if person is not in the map
 <p>
 Sometimes you need to distinguish a missing entry from
 a zero value.  Is there an entry for <code>"UTC"</code>
-or is that 0 because it's not in the map at all?
+or is that the empty string because it's not in the map at all?
 You can discriminate with a form of multiple assignment.
 </p>
 <pre>
@@ -1831,7 +1833,7 @@ for a min function that chooses the least of a list of integers:
 </p>
 <pre>
 func Min(a ...int) int {
-    min := int(^uint(0) &gt;&gt; 1)  // largest int
+    min := int(^uint(0) >> 1)  // largest int
    for _, i := range a {
        if i &lt; min {
            min = i
@@ -2407,7 +2409,7 @@ The <code>http</code> package contains this code:
 // Handler object that calls f.
 type HandlerFunc func(ResponseWriter, *Request)

-// ServeHTTP calls f(w, req).
+// ServeHTTP calls f(c, req).
 func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
    f(w, req)
 }
@@ -2445,7 +2447,7 @@ the handler installed at that page has value <code>ArgServer</code>
 and type <code>HandlerFunc</code>.
 The HTTP server will invoke the method <code>ServeHTTP</code>
 of that type, with <code>ArgServer</code> as the receiver, which will in turn call
-<code>ArgServer</code> (via the invocation <code>f(w, req)</code>
+<code>ArgServer</code> (via the invocation <code>f(c, req)</code>
 inside <code>HandlerFunc.ServeHTTP</code>).
 The arguments will then be displayed.
 </p>
@@ -2790,7 +2792,7 @@ job := &amp;Job{command, log.New(os.Stderr, "Job: ", log.Ldate)}
 <p>
 If we need to refer to an embedded field directly, the type name of the field,
 ignoring the package qualifier, serves as a field name, as it did
-in the <code>Read</code> method of our <code>ReadWriter</code> struct.
+in the <code>Read</code> method of our <code>ReaderWriter</code> struct.
 Here, if we needed to access the
 <code>*log.Logger</code> of a <code>Job</code> variable <code>job</code>,
 we would write <code>job.Logger</code>,
--- a/doc/gccgo_contribute.html
+++ b/doc/gccgo_contribute.html
@@ -12,7 +12,7 @@ information on building gccgo for yourself,
 see <a href="/doc/gccgo_install.html">Setting up and using gccgo</a>.
 For more of the gritty details on the process of doing development
 with the gccgo frontend,
-see <a href="https://go.googlesource.com/gofrontend/+/master/HACKING">the
+see <a href="https://code.google.com/p/gofrontend/source/browse/HACKING">the
 file HACKING</a> in the gofrontend repository.
 </p>

--- a/doc/gccgo_install.html
+++ b/doc/gccgo_install.html
@@ -52,26 +52,6 @@ user libraries.  The Go 1.4 runtime is not fully merged, but that
 should not be visible to Go programs.
 </p>

-<p>
-The GCC 6 releases include a complete implementation of the Go 1.6.1
-user libraries.  The Go 1.6 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 7 releases include a complete implementation of the Go 1.8.1
-user libraries.  As with earlier releases, the Go 1.8 runtime is not
-fully merged, but that should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 8 releases are expected to include a complete implementation
-of the Go 1.10 release, depending on release timing.  The Go 1.10
-runtime has now been fully merged into the GCC development sources,
-and concurrent garbage collection is expected to be fully supported in
-GCC 8.
-</p>
-
 <h2 id="Source_code">Source code</h2>

 <p>
@@ -180,6 +160,23 @@ make
 make install
 </pre>

+<h3 id="Ubuntu">A note on Ubuntu</h3>
+
+<p>
+Current versions of Ubuntu and versions of GCC before 4.8 disagree on
+where system libraries and header files are found.  This is not a
+gccgo issue.  When building older versions of GCC, setting these
+environment variables while configuring and building gccgo may fix the
+problem.
+</p>
+
+<pre>
+LIBRARY_PATH=/usr/lib/x86_64-linux-gnu
+C_INCLUDE_PATH=/usr/include/x86_64-linux-gnu
+CPLUS_INCLUDE_PATH=/usr/include/x86_64-linux-gnu
+export LIBRARY_PATH C_INCLUDE_PATH CPLUS_INCLUDE_PATH
+</pre>
+
 <h2 id="Using_gccgo">Using gccgo</h2>

 <p>
@@ -367,15 +364,12 @@ or with C++ code compiled using <code>extern "C"</code>.
 <h3 id="Types">Types</h3>

 <p>
-Basic types map directly: an <code>int32</code> in Go is
-an <code>int32_t</code> in C, an <code>int64</code> is
-an <code>int64_t</code>, etc.
-The Go type <code>int</code> is an integer that is the same size as a
-pointer, and as such corresponds to the C type <code>intptr_t</code>.
-Go <code>byte</code> is equivalent to C <code>unsigned char</code>.
-Pointers in Go are pointers in C.
-A Go <code>struct</code> is the same as C <code>struct</code> with the
-same fields and types.
+Basic types map directly: an <code>int</code> in Go is an <code>int</code>
+in C, an <code>int32</code> is an <code>int32_t</code>,
+etc.  Go <code>byte</code> is equivalent to C <code>unsigned
+char</code>.
+Pointers in Go are pointers in C. A Go <code>struct</code> is the same as C
+<code>struct</code> with the same fields and types.
 </p>

 <p>
@@ -386,7 +380,7 @@ structure (this is <b style="color: red;">subject to change</b>):
 <pre>
 struct __go_string {
  const unsigned char *__data;
-  intptr_t __length;
+  int __length;
 };
 </pre>

@@ -406,8 +400,8 @@ A slice in Go is a structure.  The current definition is
 <pre>
 struct __go_slice {
  void *__values;
-  intptr_t __count;
-  intptr_t __capacity;
+  int __count;
+  int __capacity;
 };
 </pre>

@@ -532,3 +526,15 @@ This procedure is full of unstated caveats and restrictions and we make no
 guarantee that it will not change in the future. It is more useful as a
 starting point for real Go code than as a regular procedure.
 </p>
+
+<h2 id="RTEMS_Port">RTEMS Port</h2>
+<p>
+The gccgo compiler has been ported to <a href="http://www.rtems.com/">
+<code>RTEMS</code></a>. <code>RTEMS</code> is a real-time executive
+that provides a high performance environment for embedded applications
+on a range of processors and embedded hardware. The current gccgo
+port is for x86. The goal is to extend the port to most of the
+<a href="http://www.rtems.org/wiki/index.php/SupportedCPUs">
+architectures supported by <code>RTEMS</code></a>. For more information on the port,
+as well as instructions on how to install it, please see this
+<a href="http://www.rtems.org/wiki/index.php/GCCGoRTEMS"><code>RTEMS</code> Wiki page</a>.
--- a/doc/go1.1.html
+++ b/doc/go1.1.html
@@ -166,7 +166,7 @@ providing a complete Go 1.1 implementation.
 <h3 id="gc_flag">Command-line flag parsing</h3>

 <p>
-In the gc toolchain, the compilers and linkers now use the
+In the gc tool chain, the compilers and linkers now use the
 same command-line flag parsing rules as the Go flag package, a departure
 from the traditional Unix flag parsing. This may affect scripts that invoke
 the tool directly.
@@ -305,7 +305,7 @@ The race detector is documented in <a href="/doc/articles/race_detector.html">a
 <p>
 Due to the change of the <a href="#int"><code>int</code></a> to 64 bits and
 a new internal <a href="//golang.org/s/go11func">representation of functions</a>,
-the arrangement of function arguments on the stack has changed in the gc toolchain.
+the arrangement of function arguments on the stack has changed in the gc tool chain.
 Functions written in assembly will need to be revised at least
 to adjust frame pointer offsets.
 </p>
@@ -395,7 +395,7 @@ Run <code>go help test</code> for more information.
 The <a href="/cmd/fix/"><code>fix</code></a> command, usually run as
 <code>go fix</code>, no longer applies fixes to update code from
 before Go 1 to use Go 1 APIs.
-To update pre-Go 1 code to Go 1.1, use a Go 1.0 toolchain
+To update pre-Go 1 code to Go 1.1, use a Go 1.0 tool chain
 to convert the code to Go 1.0 first.
 </p>

@@ -427,7 +427,7 @@ To build a file only with Go 1.0.x, use the converse constraint:
 <h3 id="platforms">Additional platforms</h3>

 <p>
-The Go 1.1 toolchain adds experimental support for <code>freebsd/arm</code>,
+The Go 1.1 tool chain adds experimental support for <code>freebsd/arm</code>,
 <code>netbsd/386</code>, <code>netbsd/amd64</code>, <code>netbsd/arm</code>,
 <code>openbsd/386</code> and <code>openbsd/amd64</code> platforms.
 </p>
--- a/doc/go1.10.html
+++ b/doc/go1.10.html
--- a/doc/go1.2.html
+++ b/doc/go1.2.html
@@ -266,7 +266,7 @@ is now an error.
 <p>
 On the ARM, the toolchain supports "external linking", which
 is a step towards being able to build shared libraries with the gc
-toolchain and to provide dynamic linking support for environments
+tool chain and to provide dynamic linking support for environments
 in which that is necessary.
 </p>

--- a/doc/go1.3.html
+++ b/doc/go1.3.html
@@ -11,7 +11,7 @@ The latest Go release, version 1.3, arrives six months after 1.2,
 and contains no language changes.
 It focuses primarily on implementation work, providing 
 precise garbage collection,
-a major refactoring of the compiler toolchain that results in
+a major refactoring of the compiler tool chain that results in
 faster builds, especially for large projects,
 significant performance improvements across the board,
 and support for DragonFly BSD, Solaris, Plan 9 and Google's Native Client architecture (NaCl).
@@ -285,7 +285,7 @@ building and linking with a shared library.
 <h3 id="gc_flag">Command-line flag parsing</h3>

 <p>
-In the gc toolchain, the assemblers now use the
+In the gc tool chain, the assemblers now use the
 same command-line flag parsing rules as the Go flag package, a departure
 from the traditional Unix flag parsing.
 This may affect scripts that invoke the tool directly.
--- a/doc/go1.7.html
+++ b/doc/go1.7.html
@@ -43,7 +43,7 @@ includes the <a href="#context">context package</a>, promoted from the
 and now used in the standard library;
 and <a href="#testing">adds support in the testing package</a> for
 creating hierarchies of tests and benchmarks.
-The release also <a href="#cmd_go">finalizes the vendoring support</a>
+The release also <a href="#cmd/go">finalizes the vendoring support</a>
 started in Go 1.5, making it a standard feature.
 </p>

@@ -67,7 +67,8 @@ This change has no effect on the correctness of existing programs.

 <p>
 Go 1.7 adds support for macOS 10.12 Sierra.
-Binaries built with versions of Go before 1.7 will not work
+This support was backported to Go 1.6.3.
+Binaries built with versions of Go before 1.6.3 will not work
 correctly on Sierra.
 </p>

@@ -394,9 +395,9 @@ This allows the use of contexts for cancelation, timeouts, and passing
 request-scoped data in other standard library packages,
 including
 <a href="#net">net</a>,
-<a href="#net_http">net/http</a>,
+<a href="#net/http">net/http</a>,
 and
-<a href="#os_exec">os/exec</a>,
+<a href="#os/exec">os/exec</a>,
 as noted below.
 </p>

@@ -908,7 +909,7 @@ For example, the address on which a request received is
 <p>
 The server's <a href="/pkg/net/http/#Server.Serve"><code>Serve</code></a> method
 now only enables HTTP/2 support if the <code>Server.TLSConfig</code> field is <code>nil</code>
-or includes <code>"h2"</code> in its <code>TLSConfig.NextProtos</code>.
+or includes <code>"h2"</code> in its <code>TLSConfig.NextProto</code>.
 </p>

 <p>
--- a/doc/go1.8.html
+++ b/doc/go1.8.html
--- a/doc/go1.9.html
+++ b/doc/go1.9.html
--- a/doc/go1compat.html
+++ b/doc/go1compat.html
@@ -190,8 +190,8 @@ For details and background, see
 <h2 id="tools">Tools</h2>

 <p>
-Finally, the Go toolchain (compilers, linkers, build tools, and so
-on) is under active development and may change behavior. This
+Finally, the Go tool chain (compilers, linkers, build tools, and so
+on) are under active development and may change behavior. This
 means, for instance, that scripts that depend on the location and
 properties of the tools may be broken by a point release.
 </p>
--- a/doc/go_faq.html
+++ b/doc/go_faq.html
@@ -271,27 +271,6 @@ you will need to abide by the guidelines at

 <h2 id="Design">Design</h2>

-<h3 id="runtime">
-Does Go have a runtime?</h3>
-
-<p>
-Go does have an extensive library, called the <em>runtime</em>,
-that is part of every Go program.
-The runtime library implements garbage collection, concurrency,
-stack management, and other critical features of the Go language.
-Although it is more central to the language, Go's runtime is analogous
-to <code>libc</code>, the C library.
-</p>
-
-<p>
-It is important to understand, however, that Go's runtime does not
-include a virtual machine, such as is provided by the Java runtime.
-Go programs are compiled ahead of time to native machine code.
-Thus, although the term is often used to describe the virtual
-environment in which a program runs, in Go the word &ldquo;runtime&rdquo;
-is just the name given to the library providing critical language services.
-</p>
-
 <h3 id="unicode_identifiers">
 What's up with Unicode identifiers?</h3>

@@ -769,29 +748,6 @@ for i, v := range t {
 }
 </pre>

-<h3 id="convert_slice_with_same_underlying_type">
-Can I convert []T1 to []T2 if T1 and T2 have the same underlying type?</h3>
-
-This last line of this code sample does not compile.
-
-<pre>
-type T1 int
-type T2 int
-var t1 T1
-var x = T2(t1) // OK
-var st1 []T1
-var sx = ([]T2)(st1) // NOT OK
-</pre>
-
-<p>
-In Go, types are closely tied to methods, in that every named type has
-a (possibly empty) method set.
-The general rule is that you can change the name of the type being
-converted (and thus possibly change its method set) but you can't
-change the name (and method set) of elements of a composite type.
-Go requires you to be explicit about type conversions.
-</p>
-
 <h3 id="nil_error">
 Why is my nil error value not equal to nil?
 </h3>
@@ -912,7 +868,6 @@ Why does Go not have covariant result types?</h3>

 <p>
 Covariant result types would mean that an interface like
-</p>

 <pre>
 type Copyable interface {
@@ -920,15 +875,13 @@ type Copyable interface {
 }
 </pre>

-<p>
 would be satisfied by the method
-</p>

 <pre>
 func (v Value) Copy() Value
 </pre>

-<p>because <code>Value</code> implements the empty interface.
+because <code>Value</code> implements the empty interface.
 In Go method types must match exactly, so <code>Value</code> does not
 implement <code>Copyable</code>.
 Go separates the notion of what a
@@ -1094,7 +1047,7 @@ it's easy to work around this. For GitHub, try one of these solutions:
 <ul>
 <li>Manually clone the repository in the expected package directory:
 <pre>
-$ cd src/github.com/username
+$ cd $GOPATH/src/github.com/username
 $ git clone git@github.com:username/package.git
 </pre>
 </li>
@@ -1140,7 +1093,7 @@ program is one tool to help automate this process.
 </p>

 <p>
-The Go 1.5 release added a facility to the
+The Go 1.5 release includes an experimental facility to the
 <a href="https://golang.org/cmd/go">go</a> command
 that makes it easier to manage external dependencies by "vendoring"
 them into a special directory near the package that depends upon them.
@@ -1148,13 +1101,6 @@ See the <a href="https://golang.org/s/go15vendor">design
 document</a> for details.
 </p>

-<p>
-Work is underway on an experimental package management tool,
-<a href="https://github.com/golang/dep"><code>dep</code></a>, to learn
-more about how tooling can help package management. More information can be found in
-<a href="https://github.com/golang/dep/blob/master/docs/FAQ.md">the <code>dep</code> FAQ</a>.
-</p>
-
 <h2 id="Pointers">Pointers and Allocation</h2>

 <h3 id="pass_by_value">
@@ -1181,12 +1127,6 @@ struct.  If the interface value holds a pointer, copying the interface value
 makes a copy of the pointer, but again not the data it points to.
 </p>

-<p>
-Note that this discussion is about the semantics of the operations.
-Actual implementations may apply optimizations to avoid copying
-as long as the optimizations do not change the semantics.
-</p>
-
 <h3 id="pointer_to_interface">
 When should I use a pointer to an interface?</h3>

@@ -1322,26 +1262,11 @@ size of value should use an explicitly sized type, like <code>int64</code>.
 Prior to Go 1.1, the 64-bit Go compilers (both gc and gccgo) used
 a 32-bit representation for <code>int</code>. As of Go 1.1 they use
 a 64-bit representation.
-</p>
-
-<p>
 On the other hand, floating-point scalars and complex
-types are always sized (there are no <code>float</code> or <code>complex</code> basic types),
-because programmers should be aware of precision when using floating-point numbers.
-The default type used for an (untyped) floating-point constant is <code>float64</code>.
-Thus <code>foo</code> <code>:=</code> <code>3.0</code> declares a variable <code>foo</code>
-of type <code>float64</code>.
-For a <code>float32</code> variable initialized by an (untyped) constant, the variable type
-must be specified explicitly in the variable declaration:
-</p>
-
-<pre>
-var foo float32 = 3.0
-</pre>
-
-<p>
-Alternatively, the constant must be given a type with a conversion as in
-<code>foo := float32(3.0)</code>.
+numbers are always sized: <code>float32</code>, <code>complex64</code>,
+etc., because programmers should be aware of precision when using
+floating-point numbers.
+The default size of a floating-point constant is <code>float64</code>.
 </p>

 <h3 id="stack_or_heap">
@@ -1476,53 +1401,6 @@ For more detail on this topic see the talk entitled,
 <a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">Concurrency
 is not Parallelism</a>.

-<h3 id="no_goroutine_id">
-Why is there no goroutine ID?</h3>
-
-<p>
-Goroutines do not have names; they are just anonymous workers.
-They expose no unique identifier, name, or data structure to the programmer.
-Some people are surprised by this, expecting the <code>go</code>
-statement to return some item that can be used to access and control
-the goroutine later.
-</p>
-
-<p>
-The fundamental reason goroutines are anonymous is so that
-the full Go language is available when programming concurrent code.
-By contrast, the usage patterns that develop when threads and goroutines are
-named can restrict what a library using them can do.
-</p>
-
-<p>
-Here is an illustration of the difficulties.
-Once one names a goroutine and constructs a model around
-it, it becomes special, and one is tempted to associate all computation
-with that goroutine, ignoring the possibility
-of using multiple, possibly shared goroutines for the processing.
-If the <code>net/http</code> package associated per-request
-state with a goroutine,
-clients would be unable to use more goroutines
-when serving a request.
-</p>
-
-<p>
-Moreover, experience with libraries such as those for graphics systems
-that require all processing to occur on the "main thread"
-has shown how awkward and limiting the approach can be when
-deployed in a concurrent language.
-The very existence of a special thread or goroutine forces
-the programmer to distort the program to avoid crashes
-and other problems caused by inadvertently operating
-on the wrong thread.
-</p>
-
-<p>
-For those cases where a particular goroutine is truly special,
-the language provides features such as channels that can be
-used in flexible ways to interact with it.
-</p>
-
 <h2 id="Functions_methods">Functions and Methods</h2>

 <h3 id="different_method_sets">
@@ -1792,7 +1670,8 @@ What compiler technology is used to build the compilers?</h3>

 <p>
 <code>Gccgo</code> has a front end written in C++, with a recursive descent parser coupled to the
-standard GCC back end. <code>Gc</code> is written in Go with a recursive descent parser
+standard GCC back end. <code>Gc</code> is written in Go using
+<code>yacc</code>/<code>bison</code> for the parser
 and uses a custom loader, also written in Go but
 based on the Plan 9 loader, to generate ELF/Mach-O/PE binaries.
 </p>
@@ -1842,7 +1721,7 @@ supported by recent modifications to the gold linker.
 Why is my trivial program such a large binary?</h3>

 <p>
-The linker in the <code>gc</code> toolchain
+The linker in the <code>gc</code> tool chain
 creates statically-linked binaries by default.  All Go binaries therefore include the Go
 run-time, along with the run-time type information necessary to support dynamic
 type checks, reflection, and even panic-time stack traces.
@@ -1853,7 +1732,7 @@ A simple C "hello, world" program compiled and linked statically using gcc
 on Linux is around 750 kB,
 including an implementation of <code>printf</code>.
 An equivalent Go program using <code>fmt.Printf</code>
-is around 1.5 MB, but
+is around 2.3 MB, but
 that includes more powerful run-time support and type information.
 </p>

--- a/doc/go_spec.html
+++ b/doc/go_spec.html
--- a/doc/gopher/favicon.svg
+++ b/doc/gopher/favicon.svg
@@ -1,238 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="32"
-   height="32"
-   viewBox="0 0 32 32.000001"
-   id="svg4416"
-   version="1.1"
-   inkscape:version="0.91 r13725"
-   sodipodi:docname="favicon.svg"
-   inkscape:export-filename="../../favicon.png"
-   inkscape:export-xdpi="90"
-   inkscape:export-ydpi="90">
-  <defs
-     id="defs4418" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="15.839192"
-     inkscape:cx="17.966652"
-     inkscape:cy="9.2991824"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="true"
-     units="px"
-     inkscape:snap-bbox="true"
-     inkscape:snap-bbox-edge-midpoints="false"
-     inkscape:bbox-nodes="true"
-     showguides="false"
-     inkscape:window-width="1920"
-     inkscape:window-height="1018"
-     inkscape:window-x="1912"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:object-nodes="true"
-     inkscape:snap-smooth-nodes="true"
-     inkscape:snap-global="false">
-    <inkscape:grid
-       type="xygrid"
-       id="grid5148" />
-  </sodipodi:namedview>
-  <metadata
-     id="metadata4421">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="icon"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(0,-1020.3622)">
-    <ellipse
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="ellipse4216"
-       cx="-907.35657"
-       cy="479.90009"
-       rx="3.5793996"
-       ry="3.8207953"
-       transform="matrix(-0.49169095,-0.87076978,-0.87076978,0.49169095,0,0)"
-       inkscape:transform-center-x="0.67794294"
-       inkscape:transform-center-y="-2.3634048" />
-    <ellipse
-       inkscape:transform-center-y="-2.3633882"
-       inkscape:transform-center-x="-0.67793718"
-       transform="matrix(0.49169095,-0.87076978,0.87076978,0.49169095,0,0)"
-       ry="3.8207953"
-       rx="3.5793996"
-       cy="507.8461"
-       cx="-891.57654"
-       id="ellipse4463"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
-    <path
-       inkscape:connector-curvature="0"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 16.091693,1021.3642 c -1.105749,0.01 -2.210341,0.049 -3.31609,0.09 C 6.8422558,1021.6738 2,1026.3942 2,1032.3622 c 0,2.9786 0,13 0,20 l 28,0 c 0,-8 0,-16 0,-20 0,-5.9683 -4.667345,-10.4912 -10.59023,-10.908 -1.10575,-0.078 -2.212328,-0.099 -3.318077,-0.09 z"
-       id="path4465"
-       sodipodi:nodetypes="ccsccscc" />
-    <path
-       inkscape:transform-center-y="-1.3604657"
-       inkscape:transform-center-x="-0.98424303"
-       sodipodi:nodetypes="sssssss"
-       inkscape:connector-curvature="0"
-       id="path4469"
-       d="m 4.6078867,1025.0462 c 0.459564,0.2595 1.818262,1.2013 1.980983,1.648 0.183401,0.5035 0.159385,1.0657 -0.114614,1.551 -0.346627,0.6138 -1.005341,0.9487 -1.696421,0.9365 -0.339886,-0.01 -1.720283,-0.6372 -2.042561,-0.8192 -0.97754,-0.5519 -1.350795,-1.7418 -0.833686,-2.6576 0.517109,-0.9158 1.728749,-1.2107 2.706299,-0.6587 z"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
-    <rect
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32850246;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="rect4473"
-       width="3.0866659"
-       height="3.5313663"
-       x="14.406213"
-       y="1035.6842"
-       ry="0.62426329" />
-    <path
-       inkscape:connector-curvature="0"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 16,1023.3622 c -9,0 -12,3.7153 -12,9 l 0,20 24,0 c -0.04889,-7.3562 0,-18 0,-20 0,-5.2848 -3,-9 -12,-9 z"
-       id="path4471"
-       sodipodi:nodetypes="zsccsz" />
-    <path
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 27.074073,1025.0462 c -0.45957,0.2595 -1.818257,1.2013 -1.980979,1.648 -0.183401,0.5035 -0.159384,1.0657 0.114614,1.551 0.346627,0.6138 1.005335,0.9487 1.696415,0.9365 0.33988,-0.01 1.72029,-0.6372 2.04256,-0.8192 0.97754,-0.5519 1.35079,-1.7418 0.83369,-2.6576 -0.51711,-0.9158 -1.72876,-1.2107 -2.7063,-0.6587 z"
-       id="path4481"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="sssssss"
-       inkscape:transform-center-x="0.98424094"
-       inkscape:transform-center-y="-1.3604657" />
-    <circle
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="circle4477"
-       cx="21.175734"
-       cy="1030.3542"
-       r="4.6537542"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       r="4.8316345"
-       cy="1030.3542"
-       cx="10.339486"
-       id="circle4483"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       inkscape:export-ydpi="90"
-       inkscape:export-xdpi="90"
-       inkscape:export-filename=".\rect4485.png"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="rect4246"
-       width="3.6673687"
-       height="4.1063409"
-       x="14.115863"
-       y="1035.9174"
-       ry="0.72590536" />
-    <rect
-       ry="0.72590536"
-       y="1035.2253"
-       x="14.115863"
-       height="4.1063409"
-       width="3.6673687"
-       id="rect4485"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#fffcfb;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 19.999735,1036.5289 c 0,0.838 -0.871228,1.2682 -2.144766,1.1659 -0.02366,0 -0.04795,-0.6004 -0.254147,-0.5832 -0.503669,0.042 -1.095902,-0.02 -1.685964,-0.02 -0.612939,0 -1.206342,0.1826 -1.68549,0.017 -0.110233,-0.038 -0.178298,0.5838 -0.261532,0.5816 -1.243685,-0.033 -2.078803,-0.3383 -2.078803,-1.1618 0,-1.2118 1.815635,-2.1941 4.055351,-2.1941 2.239704,0 4.055351,0.9823 4.055351,2.1941 z"
-       id="path4487"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="sssssssss"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       sodipodi:nodetypes="sssssssss"
-       inkscape:connector-curvature="0"
-       id="path4489"
-       d="m 19.977414,1035.7004 c 0,0.5685 -0.433659,0.8554 -1.138091,1.0001 -0.291933,0.06 -0.630371,0.096 -1.003719,0.1166 -0.56405,0.032 -1.207782,0.031 -1.89122,0.031 -0.672834,0 -1.307182,0 -1.864904,-0.029 -0.306268,-0.017 -0.589429,-0.043 -0.843164,-0.084 -0.813833,-0.1318 -1.324962,-0.417 -1.324962,-1.0344 0,-1.1601 1.805642,-2.1006 4.03303,-2.1006 2.227377,0 4.03303,0.9405 4.03303,2.1006 z"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#c38c74;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <ellipse
-       cy="1033.8501"
-       cx="15.944382"
-       id="ellipse4491"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#23201f;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       rx="2.0801733"
-       ry="1.343747"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="circle4493"
-       cx="12.414201"
-       cy="1030.3542"
-       r="1.9630634"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       r="1.9630634"
-       cy="1030.3542"
-       cx="23.110121"
-       id="circle4495"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       sodipodi:nodetypes="cc"
-       inkscape:connector-curvature="0"
-       id="path4497"
-       d="m 5.0055377,1027.2727 c -1.170435,-1.0835 -2.026973,-0.7721 -2.044172,-0.7463"
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-    <path
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 4.3852457,1026.9152 c -1.158557,0.036 -1.346704,0.6303 -1.33881,0.6523"
-       id="path4499"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 26.630533,1027.1724 c 1.17043,-1.0835 2.02697,-0.7721 2.04417,-0.7463"
-       id="path4501"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cc" />
-    <path
-       sodipodi:nodetypes="cc"
-       inkscape:connector-curvature="0"
-       id="path4503"
-       d="m 27.321773,1026.673 c 1.15856,0.036 1.3467,0.6302 1.3388,0.6522"
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-  </g>
-</svg>
--- a/doc/help.html
+++ b/doc/help.html
@@ -1,7 +1,6 @@
 <!--{
 	"Title": "Help",
-	"Path": "/help/",
-	"Template": true
+	"Path": "/help/"
 }-->

 <div id="manual-nav"></div>
@@ -10,12 +9,8 @@

 <img class="gopher" src="/doc/gopher/help.png"/>

-{{if not $.GoogleCN}}
 <h3 id="mailinglist"><a href="https://groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
 <p>
-Get help from Go users, and share your work on the official mailing list.
-</p>
-<p>
 Search the <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>
 archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
 <a href="//golang.org/wiki">wiki</a> before posting.
@@ -23,22 +18,20 @@ archives and consult the <a href="/doc/go_faq.html">FAQ</a> and

 <h3 id="forum"><a href="https://forum.golangbridge.org/">Go Forum</a></h3>
 <p>
-The <a href="https://forum.golangbridge.org/">Go Forum</a> is a discussion
+The <a href="https://forum.golangbridge.org/">Go Forum</a> is an alternate discussion
 forum for Go programmers.
 </p>

 <h3 id="slack"><a href="https://blog.gopheracademy.com/gophers-slack-community/">Gopher Slack</a></h3>
-<p>Get live support from other users in the Go slack channel.</p>
+<p>Get live support from the official Go slack channel.</p>

 <h3 id="irc"><a href="irc:irc.freenode.net/go-nuts">Go IRC Channel</a></h3>
 <p>Get live support at <b>#go-nuts</b> on <b>irc.freenode.net</b>, the official
 Go IRC channel.</p>
-{{end}}

 <h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
 <p>Answers to common questions about Go.</p>

-{{if not $.GoogleCN}}
 <h2 id="inform">Stay informed</h2>

 <h3 id="announce"><a href="https://groups.google.com/group/golang-announce">Go Announcements Mailing List</a></h3>
@@ -63,13 +56,6 @@ The <a href="https://reddit.com/r/golang">golang sub-Reddit</a> is a place
 for Go news and discussion.
 </p>

-<h3 id="gotime"><a href="https://changelog.com/gotime">Go Time Podcast</a></h3>
-<p>
-The <a href="https://changelog.com/gotime">Go Time podcast</a> is a panel of Go experts and special guests
-discussing the Go programming language, the community, and everything in between.
-</p>
-{{end}}
-
 <h2 id="community">Community resources</h2>

 <h3 id="go_user_groups"><a href="/wiki/GoUserGroups">Go User Groups</a></h3>
@@ -78,13 +64,11 @@ Each month in places around the world, groups of Go programmers ("gophers")
 meet to talk about Go. Find a chapter near you.
 </p>

-{{if not $.GoogleCN}}
 <h3 id="playground"><a href="/play">Go Playground</a></h3>
 <p>A place to write, run, and share Go code.</p>

 <h3 id="wiki"><a href="/wiki">Go Wiki</a></h3>
 <p>A wiki maintained by the Go community.</p>
-{{end}}

 <h3 id="conduct"><a href="/conduct">Code of Conduct</a></h3>
 <p>
--- a/doc/install-source.html
+++ b/doc/install-source.html
@@ -24,7 +24,7 @@ packages, though, read on.
 <div class="detail">

 <p>
-There are two official Go compiler toolchains.
+There are two official Go compiler tool chains.
 This document focuses on the <code>gc</code> Go
 compiler and tools.
 For information on how to work on <code>gccgo</code>, a more traditional
@@ -33,7 +33,7 @@ compiler using the GCC back end, see
 </p>

 <p>
-The Go compilers support eight instruction sets.
+The Go compilers support seven instruction sets.
 There are important differences in the quality of the compilers for the different
 architectures.
 </p>
@@ -43,19 +43,23 @@ architectures.
 	<code>amd64</code> (also known as <code>x86-64</code>)
 </dt>
 <dd>
-	A mature implementation.
+	A mature implementation. New in 1.7 is its SSA-based back end
+	that generates compact, efficient code.
 </dd>
 <dt>
 	<code>386</code> (<code>x86</code> or <code>x86-32</code>)
 </dt>
 <dd>
-	Comparable to the <code>amd64</code> port.
+	Comparable to the <code>amd64</code> port, but does
+	not yet use the SSA-based back end. It has an effective
+	optimizer (registerizer) and generates good code (although
+	<code>gccgo</code> can do noticeably better sometimes).
 </dd>
 <dt>
 	<code>arm</code> (<code>ARM</code>)
 </dt>
 <dd>
-	Supports Linux, FreeBSD, NetBSD, OpenBSD and Darwin binaries. Less widely used than the other ports.
+	Supports Linux, FreeBSD, NetBSD and Darwin binaries. Less widely used than the other ports.
 </dd>
 <dt>
 	<code>arm64</code> (<code>AArch64</code>)
@@ -69,12 +73,6 @@ architectures.
 <dd>
 	Supports Linux binaries. New in 1.5 and not as well exercised as other ports.
 </dd>
-<dt>
-	<code>mips, mipsle</code> (32-bit MIPS big- and little-endian)
-</dt>
-<dd>
-	Supports Linux binaries. New in 1.8 and not as well exercised as other ports.
-</dd>
 <dt>
 	<code>mips64, mips64le</code> (64-bit MIPS big- and little-endian)
 </dt>
@@ -119,45 +117,29 @@ Go does not support CentOS 6 on these systems.
 <h2 id="go14">Install Go compiler binaries</h2>

 <p>
-The Go toolchain is written in Go. To build it, you need a Go compiler installed.
+The Go tool chain is written in Go. To build it, you need a Go compiler installed.
 The scripts that do the initial build of the tools look for an existing Go tool
-chain in <code>$GOROOT_BOOTSTRAP</code>.
-If unset, the default value of <code>GOROOT_BOOTSTRAP</code>
-is <code>$HOME/go1.4</code>.
+chain in <code>$HOME/go1.4</code>.
+(This path may be overridden by setting the <code>GOROOT_BOOTSTRAP</code>
+environment variable.)
 </p>

 <p>
-There are many options for the bootstrap toolchain.
-After obtaining one, set <code>GOROOT_BOOTSTRAP</code> to the
-directory containing the unpacked tree.
-For example, <code>$GOROOT_BOOTSTRAP/bin/go</code> should be
-the <code>go</code> command binary for the bootstrap toolchain.
+Build the tools with Go version 1.4 or a point release (1.4.1, 1.4.2 etc.).
+Go 1.4 binaries can be found at <a href="/dl/">the downloads page</a>.
 </p>

 <p>
-To use a binary release as a bootstrap toolchain, see
-<a href="/dl/">the downloads page</a> or use any other
-packaged Go distribution.
+Download the zip or tarball of Go 1.4 for your platform and extract it to
+<code>$HOME/go1.4</code> (or your nominated <code>GOROOT_BOOTSTRAP</code>
+location).
 </p>

 <p>
-To build a bootstrap toolchain from source, use
-either the git branch <code>release-branch.go1.4</code> or
-<a href="https://dl.google.com/go/go1.4-bootstrap-20171003.tar.gz">go1.4-bootstrap-20171003.tar.gz</a>,
-which contains the Go 1.4 source code plus accumulated fixes
-to keep the tools running on newer operating systems.
-(Go 1.4 was the last distribution in which the toolchain was written in C.)
-After unpacking the Go 1.4 source, <code>cd</code> to
-the <code>src</code> subdirectory, set <code>CGO_ENABLED=0</code> in
-the environment, and run <code>make.bash</code> (or,
-on Windows, <code>make.bat</code>).
-</p>
-
-<p>
-To cross-compile a bootstrap toolchain from source, which is
-necessary on systems Go 1.4 did not target (for
-example, <code>linux/ppc64le</code>), install Go on a different system
-and run <a href="/src/bootstrap.bash">bootstrap.bash</a>.
+If you want to install Go 1.5 on a system that is not supported by Go 1.4 (such
+as <code>linux/ppc64</code> and <code>linux/mips64le</code>) you can either use
+<a href="/src/bootstrap.bash">bootstrap.bash</a> on a system that can bootstrap Go
+1.5 normally, or bootstrap with gccgo 5.
 </p>

 <p>
@@ -176,9 +158,8 @@ and used as <code>GOROOT_BOOTSTRAP</code> to bootstrap a local build.
 </p>

 <p>
-To use gccgo as the bootstrap toolchain, you need to arrange
-for <code>$GOROOT_BOOTSTRAP/bin/go</code> to be the go tool that comes
-as part of gccgo 5. For example on Ubuntu Vivid:
+To use gccgo, you need to arrange for <code>$GOROOT_BOOTSTRAP/bin/go</code> to be
+the go tool that comes as part of gccgo 5. For example on Ubuntu Vivid:
 </p>

 <pre>
@@ -222,7 +203,7 @@ To build without <code>cgo</code>, set the environment variable
 Change to the directory that will be its parent
 and make sure the <code>go</code> directory does not exist.
 Then clone the repository and check out the latest release tag
-(<code class="versionTag">go1.9</code>, for example):</p>
+(<code class="versionTag">go1.7</code>, for example):</p>

 <pre>
 $ git clone https://go.googlesource.com/go
@@ -339,7 +320,7 @@ You just need to do a little more setup.
 </p>

 <p>
-The <a href="/doc/code.html">How to Write Go Code</a> document
+The <a href="/doc/code.html">How to Write Go Code</a> document 
 provides <b>essential setup instructions</b> for using the Go tools.
 </p>

@@ -365,7 +346,7 @@ $ go get golang.org/x/tools/cmd/godoc
 </pre>

 <p>
-To install these tools, the <code>go</code> <code>get</code> command requires
+To install these tools, the <code>go</code> <code>get</code> command requires 
 that <a href="#git">Git</a> be installed locally.
 </p>

@@ -410,7 +391,7 @@ New releases are announced on the
 <a href="//groups.google.com/group/golang-announce">golang-announce</a>
 mailing list.
 Each announcement mentions the latest release tag, for instance,
-<code class="versionTag">go1.9</code>.
+<code class="versionTag">go1.7</code>.
 </p>

 <p>
@@ -440,7 +421,7 @@ to override the defaults.
 <ul>
 <li><code>$GOROOT</code>
 <p>
-The root of the Go tree, often <code>$HOME/go1.X</code>.
+The root of the Go tree, often <code>$HOME/go</code>.
 Its value is built into the tree when it is compiled, and
 defaults to the parent of the directory where <code>all.bash</code> was run.
 There is no need to set this unless you want to switch between multiple
@@ -453,7 +434,7 @@ The value assumed by installed binaries and scripts when
 <code>$GOROOT</code> is not set explicitly.
 It defaults to the value of <code>$GOROOT</code>.
 If you want to build the Go tree in one location
-but move it elsewhere after the build, set
+but move it elsewhere after the build, set 
 <code>$GOROOT_FINAL</code> to the eventual location.
 </p>

@@ -465,16 +446,14 @@ These default to the values of <code>$GOHOSTOS</code> and

 <p>
 Choices for <code>$GOOS</code> are
-<code>darwin</code> (Mac OS X 10.8 and above and iOS), <code>dragonfly</code>, <code>freebsd</code>,
+<code>darwin</code> (Mac OS X 10.7 and above and iOS), <code>dragonfly</code>, <code>freebsd</code>,
 <code>linux</code>, <code>netbsd</code>, <code>openbsd</code>,
 <code>plan9</code>, <code>solaris</code> and <code>windows</code>.
 Choices for <code>$GOARCH</code> are
 <code>amd64</code> (64-bit x86, the most mature port),
 <code>386</code> (32-bit x86), <code>arm</code> (32-bit ARM), <code>arm64</code> (64-bit ARM),
 <code>ppc64le</code> (PowerPC 64-bit, little-endian), <code>ppc64</code> (PowerPC 64-bit, big-endian),
-<code>mips64le</code> (MIPS 64-bit, little-endian), <code>mips64</code> (MIPS 64-bit, big-endian),
-<code>mipsle</code> (MIPS 32-bit, little-endian), <code>mips</code> (MIPS 32-bit, big-endian), and
-<code>s390x</code> (IBM System z 64-bit, big-endian).
+<code>mips64le</code> (MIPS 64-bit, little-endian), and <code>mips64</code> (MIPS 64-bit, big-endian).
 The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <table cellpadding="0">
 <tr>
@@ -526,21 +505,12 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>linux</code></td> <td><code>ppc64le</code></td>
 </tr>
 <tr>
-<td></td><td><code>linux</code></td> <td><code>mips</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mipsle</code></td>
-</tr>
-<tr>
 <td></td><td><code>linux</code></td> <td><code>mips64</code></td>
 </tr>
 <tr>
 <td></td><td><code>linux</code></td> <td><code>mips64le</code></td>
 </tr>
 <tr>
-<td></td><td><code>linux</code></td> <td><code>s390x</code></td>
-</tr>
-<tr>
 <td></td><td><code>netbsd</code></td> <td><code>386</code></td>
 </tr>
 <tr>
@@ -587,7 +557,7 @@ architecture.
 Valid choices are the same as for <code>$GOOS</code> and
 <code>$GOARCH</code>, listed above.
 The specified values must be compatible with the local system.
-For example, you should not set <code>$GOHOSTARCH</code> to
+For example, you should not set <code>$GOHOSTARCH</code> to 
 <code>arm</code> on an x86 system.
 </p>

@@ -648,12 +618,12 @@ not <code>amd64</code>.
 <p>
 If you choose to override the defaults,
 set these variables in your shell profile (<code>$HOME/.bashrc</code>,
-<code>$HOME/.profile</code>, or equivalent). The settings might look
+<code>$HOME/.profile</code>, or equivalent). The settings might look 
 something like this:
 </p>

 <pre>
-export GOROOT=$HOME/go1.X
+export GOROOT=$HOME/go
 export GOARCH=amd64
 export GOOS=linux
 </pre>
--- a/doc/install.html
+++ b/doc/install.html
@@ -16,7 +16,7 @@

 <p>
 <a href="https://golang.org/dl/" target="_blank">Official binary
-distributions</a> are available for the FreeBSD (release 10-STABLE and above),
+distributions</a> are available for the FreeBSD (release 8-STABLE and above),
 Linux, Mac OS X (10.8 and above), and Windows operating systems and
 the 32-bit (<code>386</code>) and 64-bit (<code>amd64</code>) x86 processor
 architectures.
@@ -33,7 +33,7 @@ system and architecture, try
 <h2 id="requirements">System requirements</h2>

 <p>
-Go <a href="https://golang.org/dl/">binary distributions</a> are available for these supported operating systems and architectures.
+Go binary distributions are available for these supported operating systems and architectures.
 Please ensure your system meets these requirements before proceeding.
 If your OS or architecture is not on the list, you may be able to
 <a href="/doc/install/source">install from source</a> or
@@ -47,14 +47,14 @@ If your OS or architecture is not on the list, you may be able to
 <th align="center">Notes</th>
 </tr>
 <tr><td colspan="3"><hr></td></tr>
-<tr><td>FreeBSD 10.3 or later</td> <td>amd64, 386</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
-<tr valign='top'><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm, arm64,<br>s390x, ppc64le</td> <td>CentOS/RHEL 5.x not supported.<br>Install from source for other libc.</td></tr>
-<tr><td>macOS 10.8 or later</td> <td>amd64</td> <td>use the clang or gcc<sup>&#8224;</sup> that comes with Xcode<sup>&#8225;</sup> for <code>cgo</code> support</td></tr>
-<tr><td>Windows XP SP2 or later</td> <td>amd64, 386</td> <td>use MinGW gcc<sup>&#8224;</sup>. No need for cygwin or msys.</td></tr>
+<tr><td>FreeBSD 8-STABLE or later</td> <td>amd64</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
+<tr><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm</td> <td>CentOS/RHEL 5.x not supported</td></tr>
+<tr><td>Mac OS X 10.7 or later</td> <td>amd64</td> <td>use the clang or gcc<sup>&#8224;</sup> that comes with Xcode<sup>&#8225;</sup> for <code>cgo</code> support</td></tr>
+<tr><td>Windows XP or later</td> <td>amd64, 386</td> <td>use MinGW gcc<sup>&#8224;</sup>. No need for cygwin or msys.</td></tr>
 </table>

 <p>
-<sup>&#8224;</sup>A C compiler is required only if you plan to use
+<sup>&#8224;</sup><code>gcc</code> is required only if you plan to use
 <a href="/cmd/cgo">cgo</a>.<br/>
 <sup>&#8225;</sup>You only need to install the command line tools for
 <a href="http://developer.apple.com/Xcode/">Xcode</a>. If you have already
@@ -117,12 +117,12 @@ to point to the directory in which it was installed.
 </p>

 <p>
-For example, if you installed Go to your home directory you should add
-commands like the following to <code>$HOME/.profile</code>:
+For example, if you installed Go to your home directory you should add the
+following commands to <code>$HOME/.profile</code>:
 </p>

 <pre>
-export GOROOT=$HOME/go1.X
+export GOROOT=$HOME/go
 export PATH=$PATH:$GOROOT/bin
 </pre>

@@ -219,15 +219,37 @@ and building a simple program, as follows.
 </p>

 <p>
-Create your <a href="code.html#Workspaces">workspace</a> directory,
-<code class="testUnix">$HOME/go</code><code class="testWindows">%USERPROFILE%\go</code>.
-(If you'd like to use a different directory,
-you will need to <a href="https://golang.org/wiki/SettingGOPATH">set the <code>GOPATH</code> environment variable</a>.)
+Create a directory to contain your <a href="code.html#Workspaces">workspace</a>,
+<code class="testUnix">$HOME/work</code>
+<code class="testWindows" style="display: none">C:\work</code>
+for example, and set the <code>GOPATH</code> environment
+variable to point to that location.
+</p>
+
+<pre class="testUnix">
+$ <b>export GOPATH=$HOME/work</b>
+</pre>
+
+<pre class="testWindows" style="display: none">
+C:\&gt; <b>set GOPATH=C:\work</b>
+</pre>
+
+<p>
+<span class="testUnix">
+You should put the above command in your shell startup script
+(<code>$HOME/.profile</code> for example).
+</span>
+<span class="testWindows">
+On Windows, follow the <a href="#windows_env">instructions above</a> to set the
+<code>GOPATH</code> environment variable on your system.
+</span>
 </p>

 <p>
-Next, make the directory <code>src/hello</code> inside your workspace,
-and in that directory create a file named <code>hello.go</code> that looks like:
+Next, make the directories <code>src/github.com/user/hello</code> inside your
+workspace (if you use GitHub, substitute your user name for <code>user</code>),
+and inside the <code>hello</code> directory create a file named <code>hello.go</code>
+with the following contents:
 </p>

 <pre>
@@ -241,33 +263,30 @@ func main() {
 </pre>

 <p>
-Then build it with the <code>go</code> tool:
+Then compile it with the <code>go</code> tool:
 </p>

 <pre class="testUnix">
-$ <b>cd $HOME/go/src/hello</b>
-$ <b>go build</b>
+$ <b>go install github.com/user/hello</b>
 </pre>

-<pre class="testWindows">
-C:\&gt; <b>cd %USERPROFILE%\go\src\hello</b>
-C:\Users\Gopher\go\src\hello&gt; <b>go build</b>
+<pre class="testWindows" style="display: none">
+C:\&gt; <b>go install github.com/user/hello</b>
 </pre>

 <p>
-The command above will build an executable named
-<code class="testUnix">hello</code><code class="testWindows">hello.exe</code>
-in the directory alongside your source code.
-Execute it to see the greeting:
+The command above will put an executable command named <code>hello</code> 
+(or <code>hello.exe</code>) inside the <code>bin</code> directory of your workspace.
+Execute the command to see the greeting:
 </p>

 <pre class="testUnix">
-$ <b>./hello</b>
+$ <b>$GOPATH/bin/hello</b>
 hello, world
 </pre>

-<pre class="testWindows">
-C:\Users\Gopher\go\src\hello&gt; <b>hello</b>
+<pre class="testWindows" style="display: none">
+C:\&gt; <b>%GOPATH%\bin\hello</b>
 hello, world
 </pre>

@@ -275,12 +294,6 @@ hello, world
 If you see the "hello, world" message then your Go installation is working.
 </p>

-<p>
-You can run <code>go</code> <code>install</code> to install the binary into
-your workspace's <code>bin</code> directory
-or <code>go</code> <code>clean</code> to remove it.
-</p>
-
 <p>
 Before rushing off to write Go code please read the
 <a href="/doc/code.html">How to Write Go Code</a> document,
@@ -312,10 +325,16 @@ environment variables under Windows</a>.
 <h2 id="help">Getting help</h2>

 <p>
-  For help, see the <a href="/help/">list of Go mailing lists, forums, and places to chat</a>.
+For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
+<a href="http://freenode.net/">Freenode</a> IRC server.
 </p>

 <p>
-  Report bugs either by running “<b><code>go</code> <code>bug</code></b>”, or
-  manually at the <a href="https://golang.org/issue">Go issue tracker</a>.
+The official mailing list for discussion of the Go language is
+<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+</p>
+
+<p>
+Report bugs using the
+<a href="//golang.org/issue">Go issue tracker</a>.
 </p>
--- a/doc/progs/json1.go
+++ b/doc/progs/json1.go
@@ -28,7 +28,7 @@ func Encode() {

 	expected := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
 	if !reflect.DeepEqual(b, expected) {
-		log.Panicf("Error marshaling %q, expected %q, got %q.", m, expected, b)
+		log.Panicf("Error marshalling %q, expected %q, got %q.", m, expected, b)
 	}

 }
@@ -49,7 +49,7 @@ func Decode() {
 	}

 	if !reflect.DeepEqual(m, expected) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q.", b, expected, m)
 	}

 	m = Message{
@@ -77,7 +77,7 @@ func PartialDecode() {
 	}

 	if !reflect.DeepEqual(expected, m) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q.", b, expected, m)
 	}
 }

--- a/doc/progs/json3.go
+++ b/doc/progs/json3.go
@@ -33,7 +33,7 @@ func Decode() {
 	}

 	if !reflect.DeepEqual(f, expected) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, f)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q", b, expected, f)
 	}

 	f = map[string]interface{}{
--- a/doc/progs/json4.go
+++ b/doc/progs/json4.go
@@ -36,7 +36,7 @@ func Decode() {
 	}

 	if !reflect.DeepEqual(expected, m) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q", b, expected, m)
 	}
 }

--- a/doc/progs/run.go
+++ b/doc/progs/run.go
@@ -219,5 +219,12 @@ func fixcgo() {
 		// cgo1 and cgo2 don't run on netbsd, srandom has a different signature
 		skipTest("cgo1")
 		skipTest("cgo2")
+		// cgo3 and cgo4 don't run on netbsd, since cgo cannot handle stdout correctly, see issue #10715.
+		skipTest("cgo3")
+		skipTest("cgo4")
+	case "openbsd", "solaris":
+		// cgo3 and cgo4 don't run on openbsd and solaris, since cgo cannot handle stdout correctly, see issue #10715.
+		skipTest("cgo3")
+		skipTest("cgo4")
 	}
 }
--- a/doc/root.html
+++ b/doc/root.html
@@ -6,9 +6,7 @@
 <div class="left">

 <div id="learn">
-{{if not $.GoogleCN}}
 <a class="popout share">Pop-out</a>
-{{end}}
 <div class="rootHeading">Try Go</div>
 <div class="input">
 <textarea spellcheck="false" class="code">// You can edit this code!
@@ -28,10 +26,10 @@ Hello, 世界
 </div>
 <div class="buttons">
 <a class="run" href="#" title="Run this code [shift-enter]">Run</a>
-{{if not $.GoogleCN}}
+{{if $.Share}}
 <a class="share" href="#" title="Share this code">Share</a>
-<a class="tour" href="//tour.golang.org/" title="Learn Go from your browser">Tour</a>
 {{end}}
+<a class="tour" href="//tour.golang.org/" title="Learn Go from your browser">Tour</a>
 </div>
 <div class="toys">
 <select>
@@ -70,91 +68,85 @@ Linux, Mac OS X, Windows, and more.

 <div style="clear: both"></div>

-{{if not $.GoogleCN}}
 <div class="left">
-  <div id="video">
-    <div class="rootHeading">Featured video</div>
-    <iframe width="415" height="241" src="//www.youtube.com/embed/ytEkHepK08c" frameborder="0" allowfullscreen></iframe>
-  </div>
+
+<div id="video">
+<div class="rootHeading">Featured video</div>
+<iframe width="415" height="241" src="//www.youtube.com/embed/ytEkHepK08c" frameborder="0" allowfullscreen></iframe>
+</div>
+
 </div>

 <div class="right">
-	<div id="blog">
-		<div class="rootHeading">Featured articles</div>
-		<div class="read"><a href="//blog.golang.org/">Read more</a></div>
-	</div>
+
+<div id="blog">
+<div class="rootHeading">Featured articles</div>
+<div class="read"><a href="//blog.golang.org/">Read more</a></div>
+</div>
+
 </div>
-{{end}}

 <div style="clear: both;"></div>

-<script>
-(function() {
-	'use strict';
+<script type="text/javascript">

-	window.initFuncs.push(function() {
-		// Set up playground if enabled.
-		if (window.playground) {
-			window.playground({
-				"codeEl":        "#learn .code",
-				"outputEl":      "#learn .output",
-				"runEl":         "#learn .run",
-				"shareEl":       "#learn .share",
-				"shareRedirect": "//play.golang.org/p/",
-				"toysEl":        "#learn .toys select"
-			});
-		} else {
-			$('#learn').hide()
-		}
-	});
+function readableTime(t) {
+	var m = ["January", "February", "March", "April", "May", "June", "July",
+		"August", "September", "October", "November", "December"];
+	var p = t.substring(0, t.indexOf("T")).split("-");
+	var d = new Date(p[0], p[1]-1, p[2]);
+	return d.getDate() + " " + m[d.getMonth()] + " " + d.getFullYear();
+}

-	{{if not $.GoogleCN}}
+function feedLoaded(result) {
+	var blog = document.getElementById("blog");
+	var read = blog.getElementsByClassName("read")[0];
+	for (var i = 0; i < result.length && i < 2; i++) {
+		var entry = result[i];
+		var title = document.createElement("a");
+		title.className = "title";
+		title.href = entry.Link;
+		title.innerHTML = entry.Title;
+		blog.insertBefore(title, read);
+		var extract = document.createElement("div");
+		extract.className = "extract";
+		extract.innerHTML = entry.Summary;
+		blog.insertBefore(extract, read);
+		var when = document.createElement("div");
+		when.className = "when";
+		when.innerHTML = "Published " + readableTime(entry.Time);
+		blog.insertBefore(when, read);
+	}
+}

-	function readableTime(t) {
-		var m = ["January", "February", "March", "April", "May", "June", "July",
-			"August", "September", "October", "November", "December"];
-		var p = t.substring(0, t.indexOf("T")).split("-");
-		var d = new Date(p[0], p[1]-1, p[2]);
-		return d.getDate() + " " + m[d.getMonth()] + " " + d.getFullYear();
+window.initFuncs.push(function() {
+	// Set up playground if enabled.
+	if (window.playground) {
+		window.playground({
+			"codeEl":        "#learn .code",
+			"outputEl":      "#learn .output",
+			"runEl":         "#learn .run",
+			"shareEl":       "#learn .share",
+			"shareRedirect": "//play.golang.org/p/",
+			"toysEl":        "#learn .toys select"
+		});
+	} else {
+		$('#learn').hide()
 	}

-	window.feedLoaded = function(result) {
-		var blog = document.getElementById("blog");
-		var read = blog.getElementsByClassName("read")[0];
-		for (var i = 0; i < result.length && i < 2; i++) {
-			var entry = result[i];
-			var title = document.createElement("a");
-			title.className = "title";
-			title.href = entry.Link;
-			title.innerHTML = entry.Title;
-			blog.insertBefore(title, read);
-			var extract = document.createElement("div");
-			extract.className = "extract";
-			extract.innerHTML = entry.Summary;
-			blog.insertBefore(extract, read);
-			var when = document.createElement("div");
-			when.className = "when";
-			when.innerHTML = "Published " + readableTime(entry.Time);
-			blog.insertBefore(when, read);
-		}
-	}
+	// Load blog feed.
+	$('<script/>').attr('text', 'text/javascript')
+		.attr('src', '//blog.golang.org/.json?jsonp=feedLoaded')
+		.appendTo('body');

-	window.initFuncs.push(function() {
-		// Load blog feed.
-		$('<script/>').attr('text', 'text/javascript')
-			.attr('src', '//blog.golang.org/.json?jsonp=feedLoaded')
-			.appendTo('body');
+	// Set the video at random.
+	var videos = [
+		{h: 241, s: "//www.youtube.com/embed/ytEkHepK08c"}, // Tour of Go
+		{h: 241, s: "//www.youtube.com/embed/f6kdp27TYZs"}, // Concurrency Patterns
+		{h: 233, s: "//player.vimeo.com/video/69237265"}    // Simple environment
+	];
+	var v = videos[Math.floor(Math.random()*videos.length)];
+	$('#video iframe').attr('height', v.h).attr('src', v.s);
+});

-		// Set the video at random.
-		var videos = [
-			{h: 241, s: "//www.youtube.com/embed/ytEkHepK08c"}, // Tour of Go
-			{h: 241, s: "//www.youtube.com/embed/f6kdp27TYZs"}, // Concurrency Patterns
-			{h: 233, s: "//player.vimeo.com/video/69237265"}    // Simple environment
-		];
-		var v = videos[Math.floor(Math.random()*videos.length)];
-		$('#video iframe').attr('height', v.h).attr('src', v.s);
-	});
-
-	{{end}}
-})();
 </script>
--- a/doc/security.html
+++ b/doc/security.html
@@ -20,7 +20,7 @@ This mail is delivered to a small security team.
 Your email will be acknowledged within 24 hours, and you'll receive a more
 detailed response to your email within 72 hours indicating the next steps in
 handling your report.
-For critical problems, you can encrypt your report using our PGP key (listed below).
+If you would like, you can encrypt your report using our PGP key (listed below).
 </p>

 <p>
@@ -118,12 +118,6 @@ If you have any suggestions to improve this policy, please send an email to

 <h3>PGP Key for <a href="mailto:security@golang.org">security@golang.org</a></h3>

-<p>
-We accept PGP-encrypted email, but the majority of the security team
-are not regular PGP users so it's somewhat inconvenient. Please only
-use PGP for critical security reports.
-</p>
-
 <pre>
 -----BEGIN PGP PUBLIC KEY BLOCK-----
 Comment: GPGTools - https://gpgtools.org
--- a/favicon.ico
+++ b/favicon.ico
--- a/lib/time/update.bash
+++ b/lib/time/update.bash
@@ -8,8 +8,8 @@
 # Consult http://www.iana.org/time-zones for the latest versions.

 # Versions to use.
-CODE=2017c
-DATA=2017c
+CODE=2016f
+DATA=2016f

 set -e
 rm -rf work
@@ -42,7 +42,7 @@ zip -0 -r ../../zoneinfo.zip *
 cd ../..

 echo
-if [ "$1" = "-work" ]; then 
+if [ "$1" == "-work" ]; then 
 	echo Left workspace behind in work/.
 else
 	rm -rf work
--- a/lib/time/zoneinfo.zip
+++ b/lib/time/zoneinfo.zip
--- a/misc/android/go_android_exec.go
+++ b/misc/android/go_android_exec.go
@@ -24,16 +24,7 @@ func run(args ...string) string {
 	buf := new(bytes.Buffer)
 	cmd := exec.Command("adb", args...)
 	cmd.Stdout = io.MultiWriter(os.Stdout, buf)
-	// If the adb subprocess somehow hangs, go test will kill this wrapper
-	// and wait for our os.Stderr (and os.Stdout) to close as a result.
-	// However, if the os.Stderr (or os.Stdout) file descriptors are
-	// passed on, the hanging adb subprocess will hold them open and
-	// go test will hang forever.
-	//
-	// Avoid that by wrapping stderr, breaking the short circuit and
-	// forcing cmd.Run to use another pipe and goroutine to pass
-	// along stderr from adb.
-	cmd.Stderr = struct{ io.Writer }{os.Stderr}
+	cmd.Stderr = os.Stderr
 	log.Printf("adb %s", strings.Join(args, " "))
 	err := cmd.Run()
 	if err != nil {
--- a/misc/cgo/errors/src/err1.go
+++ b/misc/cgo/errors/src/err1.go
--- a/misc/cgo/errors/src/err2.go
+++ b/misc/cgo/errors/src/err2.go
--- a/misc/cgo/errors/src/err3.go
+++ b/misc/cgo/errors/src/err3.go
--- a/misc/cgo/errors/errors_test.go
+++ b/misc/cgo/errors/errors_test.go
@@ -1,161 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package errorstest
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func path(file string) string {
-	return filepath.Join("src", file)
-}
-
-func check(t *testing.T, file string) {
-	t.Run(file, func(t *testing.T) {
-		t.Parallel()
-
-		contents, err := ioutil.ReadFile(path(file))
-		if err != nil {
-			t.Fatal(err)
-		}
-		var errors []*regexp.Regexp
-		for i, line := range bytes.Split(contents, []byte("\n")) {
-			if bytes.HasSuffix(line, []byte("ERROR HERE")) {
-				re := regexp.MustCompile(regexp.QuoteMeta(fmt.Sprintf("%s:%d:", file, i+1)))
-				errors = append(errors, re)
-				continue
-			}
-
-			frags := bytes.SplitAfterN(line, []byte("ERROR HERE: "), 2)
-			if len(frags) == 1 {
-				continue
-			}
-			re, err := regexp.Compile(string(frags[1]))
-			if err != nil {
-				t.Errorf("Invalid regexp after `ERROR HERE: `: %#q", frags[1])
-				continue
-			}
-			errors = append(errors, re)
-		}
-		if len(errors) == 0 {
-			t.Fatalf("cannot find ERROR HERE")
-		}
-		expect(t, file, errors)
-	})
-}
-
-func expect(t *testing.T, file string, errors []*regexp.Regexp) {
-	dir, err := ioutil.TempDir("", filepath.Base(t.Name()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-
-	dst := filepath.Join(dir, strings.TrimSuffix(file, ".go"))
-	cmd := exec.Command("go", "build", "-gcflags=-L", "-o="+dst, path(file)) // TODO(gri) no need for -gcflags=-L if go tool is adjusted
-	out, err := cmd.CombinedOutput()
-	if err == nil {
-		t.Errorf("expected cgo to fail but it succeeded")
-	}
-
-	lines := bytes.Split(out, []byte("\n"))
-	for _, re := range errors {
-		found := false
-		for _, line := range lines {
-			if re.Match(line) {
-				t.Logf("found match for %#q: %q", re, line)
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Errorf("expected error output to contain %#q", re)
-		}
-	}
-
-	if t.Failed() {
-		t.Logf("actual output:\n%s", out)
-	}
-}
-
-func sizeofLongDouble(t *testing.T) int {
-	cmd := exec.Command("go", "run", path("long_double_size.go"))
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
-	}
-
-	i, err := strconv.Atoi(strings.TrimSpace(string(out)))
-	if err != nil {
-		t.Fatalf("long_double_size.go printed invalid size: %s", out)
-	}
-	return i
-}
-
-func TestReportsTypeErrors(t *testing.T) {
-	for _, file := range []string{
-		"err1.go",
-		"err2.go",
-		"err3.go",
-		"issue7757.go",
-		"issue8442.go",
-		"issue11097a.go",
-		"issue11097b.go",
-		"issue13129.go",
-		"issue13423.go",
-		"issue13467.go",
-		"issue13635.go",
-		"issue13830.go",
-		"issue16116.go",
-		"issue16591.go",
-		"issue18452.go",
-		"issue18889.go",
-	} {
-		check(t, file)
-	}
-
-	if sizeofLongDouble(t) > 8 {
-		check(t, "err4.go")
-	}
-}
-
-func TestToleratesOptimizationFlag(t *testing.T) {
-	for _, cflags := range []string{
-		"",
-		"-O",
-	} {
-		cflags := cflags
-		t.Run(cflags, func(t *testing.T) {
-			t.Parallel()
-
-			cmd := exec.Command("go", "build", path("issue14669.go"))
-			cmd.Env = append(os.Environ(), "CGO_CFLAGS="+cflags)
-			out, err := cmd.CombinedOutput()
-			if err != nil {
-				t.Errorf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
-			}
-		})
-	}
-}
-
-func TestMallocCrashesOnNil(t *testing.T) {
-	t.Parallel()
-
-	cmd := exec.Command("go", "run", path("malloc.go"))
-	out, err := cmd.CombinedOutput()
-	if err == nil {
-		t.Logf("%#q:\n%s", strings.Join(cmd.Args, " "), out)
-		t.Fatalf("succeeded unexpectedly")
-	}
-}
--- a/misc/cgo/errors/src/issue11097a.go
+++ b/misc/cgo/errors/src/issue11097a.go
--- a/misc/cgo/errors/src/issue11097b.go
+++ b/misc/cgo/errors/src/issue11097b.go
--- a/misc/cgo/errors/src/issue13129.go
+++ b/misc/cgo/errors/src/issue13129.go
@@ -10,5 +10,5 @@ import "C"

 func main() {
 	var x C.ushort
-	x = int(0) // ERROR HERE: C\.ushort
+	x = int(0) // ERROR HERE
 }
--- a/misc/cgo/errors/src/issue13423.go
+++ b/misc/cgo/errors/src/issue13423.go
--- a/misc/cgo/errors/issue13635.go
+++ b/misc/cgo/errors/issue13635.go
@@ -0,0 +1,24 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// issue 13635: used to output error about C.unsignedchar.
+// This test tests all such types.
+
+package pkg
+
+import "C"
+
+func main() {
+	var (
+		_ C.uchar         = "uc"  // ERROR HERE
+		_ C.schar         = "sc"  // ERROR HERE
+		_ C.ushort        = "us"  // ERROR HERE
+		_ C.uint          = "ui"  // ERROR HERE
+		_ C.ulong         = "ul"  // ERROR HERE
+		_ C.longlong      = "ll"  // ERROR HERE
+		_ C.ulonglong     = "ull" // ERROR HERE
+		_ C.complexfloat  = "cf"  // ERROR HERE
+		_ C.complexdouble = "cd"  // ERROR HERE
+	)
+}
--- a/misc/cgo/errors/src/issue13830.go
+++ b/misc/cgo/errors/src/issue13830.go
--- a/misc/cgo/errors/src/issue14669.go
+++ b/misc/cgo/errors/src/issue14669.go
--- a/misc/cgo/errors/src/issue16116.go
+++ b/misc/cgo/errors/src/issue16116.go
--- a/misc/cgo/errors/src/issue7757.go
+++ b/misc/cgo/errors/src/issue7757.go
--- a/misc/cgo/errors/src/issue8442.go
+++ b/misc/cgo/errors/src/issue8442.go
--- a/misc/cgo/errors/ptr_test.go
+++ b/misc/cgo/errors/ptr_test.go
@@ -4,18 +4,20 @@

 // Tests that cgo detects invalid pointer passing at runtime.

-package errorstest
+package main

 import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
-	"testing"
+	"sync"
 )

 // ptrTest is the tests without the boilerplate.
@@ -320,176 +322,221 @@ var ptrTests = []ptrTest{
 		body: `p := &C.s{}; defer C.f(p); p.p = new(C.int)`,
 		fail: true,
 	},
-	{
-		// Check a pointer to a union if the union has any
-		// pointer fields.
-		name:    "union1",
-		c:       `typedef union { char **p; unsigned long i; } u; void f(u *pu) {}`,
-		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
-		fail:    true,
-	},
-	{
-		// Don't check a pointer to a union if the union does
-		// not have any pointer fields.
-		// Like ptrdata1 above, the uintptr represents an
-		// integer that happens to have the same
-		// representation as a pointer.
-		name:    "union2",
-		c:       `typedef union { unsigned long i; } u; void f(u *pu) {}`,
-		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
-		fail:    false,
-	},
-	{
-		// Test preemption while entering a cgo call. Issue #21306.
-		name:    "preempt-during-call",
-		c:       `void f() {}`,
-		imports: []string{"runtime", "sync"},
-		body:    `var wg sync.WaitGroup; wg.Add(100); for i := 0; i < 100; i++ { go func(i int) { for j := 0; j < 100; j++ { C.f(); runtime.GOMAXPROCS(i) }; wg.Done() }(i) }; wg.Wait()`,
-		fail:    false,
-	},
 }

-func TestPointerChecks(t *testing.T) {
-	for _, pt := range ptrTests {
-		pt := pt
-		t.Run(pt.name, func(t *testing.T) {
-			testOne(t, pt)
-		})
-	}
+func main() {
+	os.Exit(doTests())
 }

-func testOne(t *testing.T, pt ptrTest) {
-	t.Parallel()
-
-	gopath, err := ioutil.TempDir("", filepath.Base(t.Name()))
+func doTests() int {
+	gopath, err := ioutil.TempDir("", "cgoerrors")
 	if err != nil {
-		t.Fatal(err)
+		fmt.Fprintln(os.Stderr, err)
+		return 2
 	}
 	defer os.RemoveAll(gopath)

-	src := filepath.Join(gopath, "src")
-	if err := os.Mkdir(src, 0777); err != nil {
-		t.Fatal(err)
+	if err := os.MkdirAll(filepath.Join(gopath, "src"), 0777); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return 2
 	}

-	name := filepath.Join(src, fmt.Sprintf("%s.go", filepath.Base(t.Name())))
+	workers := runtime.NumCPU() + 1
+
+	var wg sync.WaitGroup
+	c := make(chan int)
+	errs := make(chan int)
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func() {
+			worker(gopath, c, errs)
+			wg.Done()
+		}()
+	}
+
+	for i := range ptrTests {
+		c <- i
+	}
+	close(c)
+
+	go func() {
+		wg.Wait()
+		close(errs)
+	}()
+
+	tot := 0
+	for e := range errs {
+		tot += e
+	}
+	return tot
+}
+
+func worker(gopath string, c, errs chan int) {
+	e := 0
+	for i := range c {
+		if !doOne(gopath, i) {
+			e++
+		}
+	}
+	if e > 0 {
+		errs <- e
+	}
+}
+
+func doOne(gopath string, i int) bool {
+	t := &ptrTests[i]
+
+	dir := filepath.Join(gopath, "src", fmt.Sprintf("dir%d", i))
+	if err := os.Mkdir(dir, 0777); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return false
+	}
+
+	name := filepath.Join(dir, fmt.Sprintf("t%d.go", i))
 	f, err := os.Create(name)
 	if err != nil {
-		t.Fatal(err)
+		fmt.Fprintln(os.Stderr, err)
+		return false
 	}

 	b := bufio.NewWriter(f)
 	fmt.Fprintln(b, `package main`)
 	fmt.Fprintln(b)
 	fmt.Fprintln(b, `/*`)
-	fmt.Fprintln(b, pt.c)
+	fmt.Fprintln(b, t.c)
 	fmt.Fprintln(b, `*/`)
 	fmt.Fprintln(b, `import "C"`)
 	fmt.Fprintln(b)
-	for _, imp := range pt.imports {
+	for _, imp := range t.imports {
 		fmt.Fprintln(b, `import "`+imp+`"`)
 	}
-	if len(pt.imports) > 0 {
+	if len(t.imports) > 0 {
 		fmt.Fprintln(b)
 	}
-	if len(pt.support) > 0 {
-		fmt.Fprintln(b, pt.support)
+	if len(t.support) > 0 {
+		fmt.Fprintln(b, t.support)
 		fmt.Fprintln(b)
 	}
 	fmt.Fprintln(b, `func main() {`)
-	fmt.Fprintln(b, pt.body)
+	fmt.Fprintln(b, t.body)
 	fmt.Fprintln(b, `}`)

 	if err := b.Flush(); err != nil {
-		t.Fatalf("flushing %s: %v", name, err)
+		fmt.Fprintf(os.Stderr, "flushing %s: %v\n", name, err)
+		return false
 	}
 	if err := f.Close(); err != nil {
-		t.Fatalf("closing %s: %v", name, err)
+		fmt.Fprintf(os.Stderr, "closing %s: %v\n", name, err)
+		return false
 	}

-	for _, e := range pt.extra {
-		if err := ioutil.WriteFile(filepath.Join(src, e.name), []byte(e.contents), 0644); err != nil {
-			t.Fatalf("writing %s: %v", e.name, err)
+	for _, e := range t.extra {
+		if err := ioutil.WriteFile(filepath.Join(dir, e.name), []byte(e.contents), 0644); err != nil {
+			fmt.Fprintf(os.Stderr, "writing %s: %v\n", e.name, err)
+			return false
 		}
 	}

-	args := func(cmd *exec.Cmd) string {
-		return strings.Join(cmd.Args, " ")
-	}
+	ok := true

 	cmd := exec.Command("go", "build")
-	cmd.Dir = src
+	cmd.Dir = dir
 	cmd.Env = addEnv("GOPATH", gopath)
 	buf, err := cmd.CombinedOutput()
 	if err != nil {
-		t.Logf("%#q:\n%s", args(cmd), buf)
-		t.Fatalf("failed to build: %v", err)
+		fmt.Fprintf(os.Stderr, "test %s failed to build: %v\n%s", t.name, err, buf)
+		return false
 	}

-	exe := filepath.Join(src, filepath.Base(src))
+	exe := filepath.Join(dir, filepath.Base(dir))
 	cmd = exec.Command(exe)
-	cmd.Dir = src
+	cmd.Dir = dir

-	if pt.expensive {
+	if t.expensive {
 		cmd.Env = cgocheckEnv("1")
 		buf, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Logf("%#q:\n%s", args(cmd), buf)
-			if pt.fail {
-				t.Fatalf("test marked expensive, but failed when not expensive: %v", err)
+			var errbuf bytes.Buffer
+			if t.fail {
+				fmt.Fprintf(&errbuf, "test %s marked expensive but failed when not expensive: %v\n", t.name, err)
 			} else {
-				t.Errorf("failed unexpectedly with GODEBUG=cgocheck=1: %v", err)
+				fmt.Fprintf(&errbuf, "test %s failed unexpectedly with GODEBUG=cgocheck=1: %v\n", t.name, err)
 			}
+			reportTestOutput(&errbuf, t.name, buf)
+			os.Stderr.Write(errbuf.Bytes())
+			ok = false
 		}

 		cmd = exec.Command(exe)
-		cmd.Dir = src
+		cmd.Dir = dir
 	}

-	if pt.expensive {
+	if t.expensive {
 		cmd.Env = cgocheckEnv("2")
 	}

 	buf, err = cmd.CombinedOutput()
-	if pt.fail {
+
+	if t.fail {
 		if err == nil {
-			t.Logf("%#q:\n%s", args(cmd), buf)
-			t.Fatalf("did not fail as expected")
+			var errbuf bytes.Buffer
+			fmt.Fprintf(&errbuf, "test %s did not fail as expected\n", t.name)
+			reportTestOutput(&errbuf, t.name, buf)
+			os.Stderr.Write(errbuf.Bytes())
+			ok = false
 		} else if !bytes.Contains(buf, []byte("Go pointer")) {
-			t.Logf("%#q:\n%s", args(cmd), buf)
-			t.Fatalf("did not print expected error (failed with %v)", err)
+			var errbuf bytes.Buffer
+			fmt.Fprintf(&errbuf, "test %s output does not contain expected error (failed with %v)\n", t.name, err)
+			reportTestOutput(&errbuf, t.name, buf)
+			os.Stderr.Write(errbuf.Bytes())
+			ok = false
 		}
 	} else {
 		if err != nil {
-			t.Logf("%#q:\n%s", args(cmd), buf)
-			t.Fatalf("failed unexpectedly: %v", err)
+			var errbuf bytes.Buffer
+			fmt.Fprintf(&errbuf, "test %s failed unexpectedly: %v\n", t.name, err)
+			reportTestOutput(&errbuf, t.name, buf)
+			os.Stderr.Write(errbuf.Bytes())
+			ok = false
 		}

-		if !pt.expensive {
+		if !t.expensive && ok {
 			// Make sure it passes with the expensive checks.
 			cmd := exec.Command(exe)
-			cmd.Dir = src
+			cmd.Dir = dir
 			cmd.Env = cgocheckEnv("2")
 			buf, err := cmd.CombinedOutput()
 			if err != nil {
-				t.Logf("%#q:\n%s", args(cmd), buf)
-				t.Fatalf("failed unexpectedly with expensive checks: %v", err)
+				var errbuf bytes.Buffer
+				fmt.Fprintf(&errbuf, "test %s failed unexpectedly with expensive checks: %v\n", t.name, err)
+				reportTestOutput(&errbuf, t.name, buf)
+				os.Stderr.Write(errbuf.Bytes())
+				ok = false
 			}
 		}
 	}

-	if pt.fail {
+	if t.fail && ok {
 		cmd = exec.Command(exe)
-		cmd.Dir = src
+		cmd.Dir = dir
 		cmd.Env = cgocheckEnv("0")
 		buf, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Logf("%#q:\n%s", args(cmd), buf)
-			t.Fatalf("failed unexpectedly with GODEBUG=cgocheck=0: %v", err)
+			var errbuf bytes.Buffer
+			fmt.Fprintf(&errbuf, "test %s failed unexpectedly with GODEBUG=cgocheck=0: %v\n", t.name, err)
+			reportTestOutput(&errbuf, t.name, buf)
+			os.Stderr.Write(errbuf.Bytes())
+			ok = false
 		}
 	}
+
+	return ok
+}
+
+func reportTestOutput(w io.Writer, name string, buf []byte) {
+	fmt.Fprintf(w, "=== test %s output ===\n", name)
+	fmt.Fprintf(w, "%s", buf)
+	fmt.Fprintf(w, "=== end of test %s output ===\n", name)
 }

 func cgocheckEnv(val string) []string {
--- a/misc/cgo/errors/src/err4.go
+++ b/misc/cgo/errors/src/err4.go
@@ -1,15 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-long double x = 0;
-*/
-import "C"
-
-func main() {
-	_ = C.x // ERROR HERE
-	_ = C.x
-}
--- a/misc/cgo/errors/src/issue13467.go
+++ b/misc/cgo/errors/src/issue13467.go
@@ -1,15 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package p
-
-/*
-static int transform(int x) { return x; }
-*/
-import "C"
-
-func F() {
-	var x rune = '✈'
-	var _ rune = C.transform(x) // ERROR HERE: C\.int
-}
--- a/misc/cgo/errors/src/issue13635.go
+++ b/misc/cgo/errors/src/issue13635.go
@@ -1,24 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// issue 13635: used to output error about C.unsignedchar.
-// This test tests all such types.
-
-package pkg
-
-import "C"
-
-func main() {
-	var (
-		_ C.uchar         = "uc"  // ERROR HERE: C\.uchar
-		_ C.schar         = "sc"  // ERROR HERE: C\.schar
-		_ C.ushort        = "us"  // ERROR HERE: C\.ushort
-		_ C.uint          = "ui"  // ERROR HERE: C\.uint
-		_ C.ulong         = "ul"  // ERROR HERE: C\.ulong
-		_ C.longlong      = "ll"  // ERROR HERE: C\.longlong
-		_ C.ulonglong     = "ull" // ERROR HERE: C\.ulonglong
-		_ C.complexfloat  = "cf"  // ERROR HERE: C\.complexfloat
-		_ C.complexdouble = "cd"  // ERROR HERE: C\.complexdouble
-	)
-}
--- a/misc/cgo/errors/src/issue16591.go
+++ b/misc/cgo/errors/src/issue16591.go
@@ -1,17 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 16591: Test that we detect an invalid call that was being
-// hidden by a type conversion inserted by cgo checking.
-
-package p
-
-// void f(int** p) { }
-import "C"
-
-type x *C.int
-
-func F(p *x) {
-	C.f(p) // ERROR HERE
-}
--- a/misc/cgo/errors/src/issue18452.go
+++ b/misc/cgo/errors/src/issue18452.go
@@ -1,18 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 18452: show pos info in undefined name errors
-
-package p
-
-import (
-	"C"
-	"fmt"
-)
-
-func a() {
-	fmt.Println("Hello, world!")
-	C.function_that_does_not_exist() // ERROR HERE
-	C.pi                             // ERROR HERE
-}
--- a/misc/cgo/errors/src/issue18889.go
+++ b/misc/cgo/errors/src/issue18889.go
@@ -1,7 +0,0 @@
-package main
-
-import "C"
-
-func main() {
-	_ = C.malloc // ERROR HERE
-}
--- a/misc/cgo/errors/src/long_double_size.go
+++ b/misc/cgo/errors/src/long_double_size.go
@@ -1,16 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-const int sizeofLongDouble = sizeof(long double);
-*/
-import "C"
-
-import "fmt"
-
-func main() {
-	fmt.Println(C.sizeofLongDouble)
-}
--- a/misc/cgo/errors/src/malloc.go
+++ b/misc/cgo/errors/src/malloc.go
@@ -1,34 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test that C.malloc does not return nil.
-
-package main
-
-// #include <stdlib.h>
-import "C"
-
-import (
-	"fmt"
-	"runtime"
-)
-
-func main() {
-	var size C.size_t
-	size--
-
-	// The Dragonfly libc succeeds when asked to allocate
-	// 0xffffffffffffffff bytes, so pass a different value that
-	// causes it to fail.
-	if runtime.GOOS == "dragonfly" {
-		size = C.size_t(0x7fffffff << (32 * (^uintptr(0) >> 63)))
-	}
-
-	p := C.malloc(size)
-	if p == nil {
-		fmt.Println("malloc: C.malloc returned nil")
-		// Just exit normally--the test script expects this
-		// program to crash, so exiting normally indicates failure.
-	}
-}
--- a/misc/cgo/errors/test.bash
+++ b/misc/cgo/errors/test.bash
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+
+# Copyright 2013 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+check() {
+	file=$1
+	line=$(grep -n 'ERROR HERE' $file | sed 's/:.*//')
+	if [ "$line" = "" ]; then
+		echo 1>&2 misc/cgo/errors/test.bash: BUG: cannot find ERROR HERE in $file
+		exit 1
+	fi
+	expect $file $file:$line:
+}
+
+expect() {
+	file=$1
+	shift
+	if go build $file >errs 2>&1; then
+		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected cgo to fail on $file but it succeeded
+		exit 1
+	fi
+	if ! test -s errs; then
+		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected error output for $file but saw none
+		exit 1
+	fi
+	for error; do
+		if ! fgrep $error errs >/dev/null 2>&1; then
+			echo 1>&2 misc/cgo/errors/test.bash: BUG: expected error output for $file to contain \"$error\" but saw:
+			cat 1>&2 errs
+			exit 1
+		fi
+	done
+}
+
+check err1.go
+check err2.go
+check err3.go
+check issue7757.go
+check issue8442.go
+check issue11097a.go
+check issue11097b.go
+expect issue13129.go C.ushort
+check issue13423.go
+expect issue13635.go C.uchar C.schar C.ushort C.uint C.ulong C.longlong C.ulonglong C.complexfloat C.complexdouble
+check issue13830.go
+check issue16116.go
+
+if ! go build issue14669.go; then
+	exit 1
+fi
+if ! CGO_CFLAGS="-O" go build issue14669.go; then
+	exit 1
+fi
+
+if ! go run ptr.go; then
+	exit 1
+fi
+
+rm -rf errs _obj
+exit 0
--- a/misc/cgo/fortran/test.bash
+++ b/misc/cgo/fortran/test.bash
@@ -12,7 +12,7 @@ FC=$1
 goos=$(go env GOOS)

 libext="so"
-if [ "$goos" = "darwin" ]; then
+if [ "$goos" == "darwin" ]; then
 	libext="dylib"
 fi

--- a/misc/cgo/life/main.go
+++ b/misc/cgo/life/main.go
@@ -1,4 +1,4 @@
-// cmpout -tags=use_go_run
+// cmpout

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -11,10 +11,9 @@
 package main

 import (
+	"."
 	"flag"
 	"fmt"
-
-	"."
 )

 const MAXDIM = 100
--- a/misc/cgo/stdio/chain.go
+++ b/misc/cgo/stdio/chain.go
@@ -1,4 +1,4 @@
-// cmpout -tags=use_go_run
+// cmpout

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
--- a/misc/cgo/stdio/fib.go
+++ b/misc/cgo/stdio/fib.go
@@ -1,4 +1,4 @@
-// cmpout -tags=use_go_run
+// cmpout

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
--- a/misc/cgo/stdio/hello.go
+++ b/misc/cgo/stdio/hello.go
@@ -1,4 +1,4 @@
-// cmpout -tags=use_go_run
+// cmpout

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
--- a/misc/cgo/test/api.go
+++ b/misc/cgo/test/api.go
@@ -7,11 +7,6 @@
 package cgotest

 // #include <stdlib.h>
-//
-// // Test for issue 17723.
-// typedef char *cstring_pointer;
-// static void cstring_pointer_fun(cstring_pointer dummy) { }
-//
 // const char *api_hello = "hello!";
 import "C"
 import "unsafe"
@@ -26,5 +21,4 @@ func testAPI() {
 	var b []byte
 	b = C.GoBytes(unsafe.Pointer(C.api_hello), C.int(6))
 	_, _ = s, b
-	C.cstring_pointer_fun(nil)
 }
--- a/misc/cgo/test/basic.go
+++ b/misc/cgo/test/basic.go
@@ -162,6 +162,3 @@ func testUnsignedInt(t *testing.T) {
 func sliceOperands(array [2000]int) {
 	_ = array[C.KILO:C.KILO:C.KILO] // no type error
 }
-
-// set in cgo_thread_lock.go init
-var testThreadLockFunc = func(*testing.T) {}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Matthew Dempsky	e809658d77	misc/nacl: include parser.go for cmd/compile/internal/syntax tests Fix suggested by Minux. Change-Id: Ia7aa8ccccc16535af4ec3ad23830ef0aa5d776ac Reviewed-on: https://go-review.googlesource.com/27193 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Minux Ma <minux@golang.org>	2016-08-16 22:42:13 +00:00
Matthew Dempsky	504a104a2c	cmd/compile/internal/syntax: match old parser errors and line numbers This makes a bunch of changes to package syntax to tweak line numbers for AST nodes. For example, short variable declaration statements are now associated with the location of the ":=" token, and function calls are associated with the location of the final ")" token. These help satisfy many unit tests that assume the old parser's behavior. Because many of these changes are questionable, they're guarded behind a new "gcCompat" const to make them easy to identify and revisit in the future. A handful of remaining tests are too difficult to make behave identically. These have been updated to execute with -newparser=0 and comments explaining why they need to be fixed. all.bash now passes with both the old and new parsers. Change-Id: Iab834b71ca8698d39269f261eb5c92a0d55a3bf4	2016-08-16 14:32:09 -07:00
Matthew Dempsky	29cfbcfef4	cmd/compile/internal/gc: use new AST parser Introduce a new noder type to transform package syntax's AST into gc's Node tree. Hidden behind a new -newparser flag. Change-Id: Id0e862ef6196c41533876afc4ec289e21d422d18	2016-08-16 14:32:09 -07:00
Matthew Dempsky	55b9234023	cmd/dist: build cmd/compile/internal/syntax Change-Id: Ie6dd2318e031be445c0b1ae65d4c78723d5a1167	2016-08-16 14:32:09 -07:00
Matthew Dempsky	d6d493fc56	cmd/compile/internal/syntax: add a Line method to interface Node Change-Id: I64baf334a35c72336d26fa6755c67eb9d6f4e93c	2016-08-16 14:32:09 -07:00
Matthew Dempsky	4bc85b2eb8	cmd/compile/internal/syntax: refactor DeclStmt parsing No behavior change. Change-Id: I93c7cb7ab76b5afa74e6a1f092b7045fb96467b1	2016-08-16 14:32:09 -07:00
Matthew Dempsky	83153e7f37	cmd/compile/internal/syntax: emit errors for unexpected top-level tokens Fixes cmd/go's TestIssue7108. Change-Id: I8436b0e3e5a9b36649d46a9c2c741d820115a5d1	2016-08-16 14:32:09 -07:00
Matthew Dempsky	7a8201b924	cmd/compile/internal/syntax: change Read to still return the AST If we the caller provided an error handler, still return our best effort parsed AST tree.	2016-08-16 14:32:09 -07:00
Matthew Dempsky	38d52ef0c4	cmd/compile/internal/syntax: fix off-by-1 for implicit semicolons pos and line already refer to the position immediately before the returned newline character, so no need to decrement them further. Change-Id: I1d7a32cde55a5b8a1c6fd882ec8ba532869cc858	2016-08-16 14:32:08 -07:00
Robert Griesemer	f82bd3cc7d	cmd/compile/internal/syntax: better error positions for scanner errors For string/comment not terminated errors, report error at the start of the string/comment rather than the end of the file.	2016-08-16 14:32:08 -07:00
Robert Griesemer	3c72ed3bfa	cmd/compile/internal/syntax: provide LitKind to identify literals - various minor cleanups related to literal scanning - report newlines in character and regular string literals (plus tests)	2016-08-16 14:32:08 -07:00
Matthew Dempsky	a17ec6b30c	cmd/compile/internal/syntax: simplify BOM handling Change-Id: I5e2522d34720d7687e1e9ff0831936702976a1c7	2016-08-16 14:32:08 -07:00
Matthew Dempsky	0d8ac5ecf1	cmd/compile/internal/syntax: cleanup TypeSwitchGuard handling Fixes typeswitch3.go and at least recognizes the error in typesw.go (albeit wrong line number and non-pretty-printed syntax.Expr output). Change-Id: I38b8e923265b0e7b3c301aea2f4a901bbabc24b5	2016-08-16 14:32:08 -07:00
Robert Griesemer	573afbcdb6	cmd/compile/internal/syntax: export ImplicitOne and use to identify x++/x-- + minor documentation improvements	2016-08-16 14:32:08 -07:00
Robert Griesemer	a6a4701053	cmd/compile/internal/syntax: minor cleanups in source handling	2016-08-16 14:32:08 -07:00
Matthew Dempsky	81839a93a9	cmd/compile/internal/syntax: represent empty statements with EmptyStmt Fixes fixedbugs/bug031.go. Change-Id: Icc1846368802d71ade14e1a6b79cb6ee651b663e	2016-08-16 14:32:07 -07:00
Robert Griesemer	3a7da56582	cmd/compile/internal/syntax: fix many string/rune literal corner cases + many more test cases	2016-08-16 14:32:07 -07:00
Robert Griesemer	f363ad2a55	cmd/compile/internal/syntax: fix source.getr The source's rune reader logic was overly clever and tried to determine if an invalid rune was due to an actual source error or due to not enough bytes in the buffer. Replaced with slightly optimized version of bufio Reader's ReadRune method for now. Performance may be a tiny bit lower but we can always optimize later. Fixes endless loops when parsing certain source files. Added test case to ScanError test.	2016-08-16 14:32:07 -07:00
Robert Griesemer	fe52bcc8e6	cmd/compile/internal/syntax: rudimentary support for error reporting If an ErrorHandler is provided with a syntax.ReadXXX function, it is invoked for each error encountered. Will need to be refined, but should enable progress with all.bash. Also: - added tests for lexical errors - fixed endless loops when encountering non-terminated strings and comments	2016-08-16 14:32:07 -07:00
Robert Griesemer	f50329534a	cmd/compile/internal/syntax: skip verbose tests in -short mode	2016-08-16 14:32:07 -07:00
Matthew Dempsky	1d8cdaf6ce	cmd/compile/internal/syntax: insert implicit semicolons before EOF Fixes test/eof.go. Change-Id: Idaa2713bb1669ec165f3a2687fcfa2f8d8c70c74	2016-08-16 14:32:07 -07:00
Matthew Dempsky	49fb8d3cdb	cmd/compile/internal/syntax: fix general comment lexing Previously, we failed to recognize "**/" as the end of a general comment. Fixes ken/embed.go. Change-Id: Ibed746da105453420ec2d184e7be1a5de15927a6	2016-08-16 14:32:06 -07:00
Robert Griesemer	9be3d08e6a	cmd/compile/internal/syntax: fix lexing of ".45e1" and add token tests	2016-08-16 14:32:06 -07:00
Matthew Dempsky	b3efd7d6e8	cmd/compile/internal/syntax: fix dot-import parsing Change-Id: Iba8c9d9c01516706a2fc6ca5502401cfc063f210	2016-08-16 14:32:06 -07:00
Matthew Dempsky	1a5acb4b3a	cmd/compile/internal/syntax: pragma support for new parser Change-Id: Id4d9b40900b97708d2b4586f5a745dcb8b0eb8bd	2016-08-16 14:32:06 -07:00
Matthew Dempsky	4b1cc51518	cmd/compile/internal/syntax: simplify IfStmt Change IfStmt's Else field from []Stmt to Stmt like in go/ast. Change-Id: I835577beaf12b6e5895bc93041c13403143b4d2d	2016-08-16 14:32:06 -07:00
Matthew Dempsky	4f989a487d	cmd/compile/internal/syntax: various tweaks Export token constants needed by users (Break, Continue, Defer, Fallthrough, Go, and Goto). Fix parsing of Continue statements: previously they would be parsed as a BranchStmt with Break as the token. Change aNode, aDecl, aStmt, aExpr, etc.'s tag methods to take a pointer receiver to prevent accidents like trying to type assert from syntax.Expr to syntax.ListExpr instead of *syntax.ListExpr. Relocate pointer fields to the end of AST nodes so the GC can short-circuit scanning objects. Change-Id: Ib7505e75726816e260b9b29a2f726f76bf1a38b4	2016-08-16 14:32:02 -07:00
Robert Griesemer	d5bb1db3ec	cmd/compile/internal/syntax: don't allocate a string for each keyword $ go test -run StdLib -fast parsed 1074061 lines (2828 files) in 571.1019ms (1880681 lines/s) allocated 263.676Mb (461.696Mb/s) PASS	2016-08-16 10:48:20 -07:00
Robert Griesemer	c7cc983097	cmd/compile/internal/syntax: implement buffered reading from io.Reader No performance impact: $ go test -run StdLib -fast parsed 1073074 lines (2823 files) in 575.606804ms (1864248 lines/s) allocated 263.956Mb (458.570Mb/s) PASS	2016-08-16 10:48:01 -07:00
Robert Griesemer	a85b9c5467	cmd/compile/internal/syntax: fast Go syntax trees, initial commit. Syntax tree nodes, scanner, parser, basic printers. Builds syntax trees for entire Go std lib at a rate of ~1.8M lines/s in warmed up state (MacMini, 2.3 GHz Intel Core i7, 8GB RAM): $ go test -run StdLib -fast parsed 1074617 lines (2832 files) in 579.66364ms (1853863 lines/s) allocated 282.212Mb (486.854Mb/s) PASS	2016-08-16 10:45:05 -07:00