[release-branch.go1.10] go1.10.5

Change-Id: Ibad4471510ea8546954c4361424daadb845b2f3f
Reviewed-on: https://go-review.googlesource.com/c/147183
Run-TryBot: Andrew Bonventre <andybons@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

.gitattributes

@@ -1,16 +1,10 @@
 # Treat all files in the Go repo as binary, with no git magic updating
-# line endings. This produces predictable results in different environments.
-#
-# Windows users contributing to Go will need to use a modern version
-# of git and editors capable of LF line endings.
-#
-# Windows .bat files are known to have multiple bugs when run with LF
-# endings, and so they are checked in with CRLF endings, with a test
-# in test/winbatch.go to catch problems. (See golang.org/issue/37791.)
+# line endings. Windows users contributing to Go will need to use a
+# modern version of git and editors capable of LF line endings.
 #
 # We'll prevent accidental CRLF line endings from entering the repo
-# via the git-codereview gofmt checks and tests.
+# via the git-review gofmt checks.
 #
-# See golang.org/issue/9281.
+# See golang.org/issue/9281
 
 * -text

.github/ISSUE_TEMPLATE

@@ -1,38 +1,24 @@
-<!--
 Please answer these questions before submitting your issue. Thanks!
-For questions please use one of our forums: https://github.com/golang/go/wiki/Questions
--->
+
 
 ### What version of Go are you using (`go version`)?
 
-<pre>
-$ go version
-
-</pre>
 
 ### Does this issue reproduce with the latest release?
 
 
-
 ### What operating system and processor architecture are you using (`go env`)?
 
-<details><summary><code>go env</code> Output</summary><br><pre>
-$ go env
-
-</pre></details>
 
 ### 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?
 
 
-
 ### What did you see instead?
+

.github/PULL_REQUEST_TEMPLATE

@@ -1,25 +0,0 @@
-This PR will be imported into Gerrit with the title and first
-comment (this text) used to generate the subject and body of
-the Gerrit change.
-
-**Please ensure you adhere to every item in this list.**
-
-More info can be found at https://github.com/golang/go/wiki/CommitMessage
-
-+ The PR title is formatted as follows: `net/http: frob the quux before blarfing`
-  + The package name goes before the colon
-  + The part after the colon uses the verb tense + phrase that completes the blank in,
-    "This change modifies Go to ___________"
-  + Lowercase verb after the colon
-  + No trailing period
-  + Keep the title as short as possible. ideally under 76 characters or shorter
-+ No Markdown
-+ The first PR comment (this one) is wrapped at 76 characters, unless it's
-  really needed (ASCII art, table, or long link)
-+ If there is a corresponding issue, add either `Fixes #1234` or `Updates #1234`
-  (the latter if this is not a complete fix) to this comment
-+ If referring to a repo other than `golang/go` you can use the
-  `owner/repo#issue_number` syntax: `Fixes golang/tools#1234`
-+ We do not use Signed-off-by lines in Go. Please don't add them.
-  Our Gerrit server & GitHub bots enforce CLA compliance instead.
-+ Delete these instructions once you have read and applied them

.github/SUPPORT.md

@@ -9,6 +9,6 @@ For asking questions, see:
 
 * [Gophers Slack](https://gophers.slack.com), use the [invite app](https://invite.slack.golangbridge.org/) for access
 
-* [Stack Overflow](https://stackoverflow.com/questions/tagged/go) with questions tagged "go"
+* [Stack Overflow](http://stackoverflow.com/questions/tagged/go) with questions tagged "go"
 
 * **IRC** channel #go-nuts on Freenode

README.md

@@ -19,19 +19,19 @@ BSD-style license found in the LICENSE file.
 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](./doc/install.html) in your web browser for installation
+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](./doc/install-source.html)
+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 thousands of contributors. We appreciate your help!
+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

SECURITY.md

@@ -1,13 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-We support the past two Go releases (for example, Go 1.12.x and Go 1.13.x).
-
-See https://golang.org/wiki/Go-Release-Cycle and in particular the
-[Release Maintenance](https://github.com/golang/go/wiki/Go-Release-Cycle#release-maintenance)
-part of that page.
-
-## Reporting a Vulnerability
-
-See https://golang.org/security for how to report a vulnerability.

VERSION

@@ -0,0 +1 @@
+go1.10.5

api/README

@@ -11,3 +11,4 @@ compatibility.
 next.txt is the only file intended to be mutated. It's a list of
 features that may be added to the next version. It only affects
 warning output from the go api tool.
+

api/except.txt

@@ -2,12 +2,12 @@ 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 os, const ModeType = 2399141888
-pkg os, const ModeType = 2399666176
 pkg os (linux-arm), const O_SYNC = 4096
 pkg os (linux-arm-cgo), const O_SYNC = 4096
-pkg os (linux-arm), const O_SYNC = 1052672
-pkg os (linux-arm-cgo), const O_SYNC = 1052672
+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
@@ -15,30 +15,25 @@ 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 ImplementsGetwd = false
 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 ImplementsGetwd = false
 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 ImplementsGetwd = false
 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 ImplementsGetwd = false
 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 ImplementsGetwd = false
 pkg syscall (freebsd-arm), const O_CLOEXEC = 0
 pkg syscall (freebsd-arm), const SIOCAIFADDR = 2151967019
 pkg syscall (freebsd-arm), const SIOCGIFSTATUS = 3274991931
@@ -70,7 +65,6 @@ 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 ImplementsGetwd = false
 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
@@ -104,12 +98,6 @@ 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-386), const ImplementsGetwd = false
-pkg syscall (netbsd-386-cgo), const ImplementsGetwd = false
-pkg syscall (netbsd-amd64), const ImplementsGetwd = false
-pkg syscall (netbsd-amd64-cgo), const ImplementsGetwd = false
-pkg syscall (netbsd-arm), const ImplementsGetwd = false
-pkg syscall (netbsd-arm-cgo), const ImplementsGetwd = false
 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
@@ -118,7 +106,6 @@ 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 ImplementsGetwd = false
 pkg syscall (openbsd-386), const RTF_FMASK = 63496
 pkg syscall (openbsd-386), const RTM_VERSION = 4
 pkg syscall (openbsd-386), const SIOCBRDGDADDR = 2150132039
@@ -171,7 +158,6 @@ pkg syscall (openbsd-386), type Timespec struct, Sec int32
 pkg syscall (openbsd-386), type Timeval struct, Sec int32
 pkg syscall (openbsd-386-cgo), const BIOCGRTIMEOUT = 1074283118
 pkg syscall (openbsd-386-cgo), const BIOCSRTIMEOUT = 2148024941
-pkg syscall (openbsd-386-cgo), const ImplementsGetwd = false
 pkg syscall (openbsd-386-cgo), const RTF_FMASK = 63496
 pkg syscall (openbsd-386-cgo), const RTM_VERSION = 4
 pkg syscall (openbsd-386-cgo), const SIOCBRDGDADDR = 2150132039
@@ -234,7 +220,6 @@ pkg syscall (openbsd-amd64), const EFER_NXE = 2048
 pkg syscall (openbsd-amd64), const EFER_NXE ideal-int
 pkg syscall (openbsd-amd64), const EFER_SCE = 1
 pkg syscall (openbsd-amd64), const EFER_SCE ideal-int
-pkg syscall (openbsd-amd64), const ImplementsGetwd = false
 pkg syscall (openbsd-amd64), const PMC5_PIPELINE_FLUSH = 21
 pkg syscall (openbsd-amd64), const PMC5_PIPELINE_FLUSH ideal-int
 pkg syscall (openbsd-amd64), const RTF_FMASK = 63496
@@ -297,7 +282,6 @@ pkg syscall (openbsd-amd64-cgo), const EFER_NXE = 2048
 pkg syscall (openbsd-amd64-cgo), const EFER_NXE ideal-int
 pkg syscall (openbsd-amd64-cgo), const EFER_SCE = 1
 pkg syscall (openbsd-amd64-cgo), const EFER_SCE ideal-int
-pkg syscall (openbsd-amd64-cgo), const ImplementsGetwd = false
 pkg syscall (openbsd-amd64-cgo), const PMC5_PIPELINE_FLUSH = 21
 pkg syscall (openbsd-amd64-cgo), const PMC5_PIPELINE_FLUSH ideal-int
 pkg syscall (openbsd-amd64-cgo), const RTF_FMASK = 63496
@@ -361,99 +345,3 @@ 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"
-pkg syscall (windows-386), const TOKEN_ALL_ACCESS = 983295
-pkg syscall (windows-386), type AddrinfoW struct, Addr uintptr
-pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
-pkg syscall (windows-386), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
-pkg syscall (windows-386), type CertContext struct, CertInfo uintptr
-pkg syscall (windows-386), type CertRevocationInfo struct, CrlInfo uintptr
-pkg syscall (windows-386), type CertRevocationInfo struct, OidSpecificInfo uintptr
-pkg syscall (windows-386), type CertSimpleChain struct, TrustListInfo uintptr
-pkg syscall (windows-386), type RawSockaddrAny struct, Pad [96]int8
-pkg syscall (windows-amd64), const TOKEN_ALL_ACCESS = 983295
-pkg syscall (windows-amd64), type AddrinfoW struct, Addr uintptr
-pkg syscall (windows-amd64), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
-pkg syscall (windows-amd64), type CertChainPolicyStatus struct, ExtraPolicyStatus uintptr
-pkg syscall (windows-amd64), type CertContext struct, CertInfo uintptr
-pkg syscall (windows-amd64), type CertRevocationInfo struct, CrlInfo uintptr
-pkg syscall (windows-amd64), type CertRevocationInfo struct, OidSpecificInfo uintptr
-pkg syscall (windows-amd64), type CertSimpleChain struct, TrustListInfo uintptr
-pkg syscall (windows-amd64), type RawSockaddrAny struct, Pad [96]int8
-pkg syscall (freebsd-386), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-386), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-386), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-386), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-386), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-386), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-386), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-386), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-386), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-386), type Stat_t struct, Pad_cgo_0 [8]uint8
-pkg syscall (freebsd-386), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-386), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-386), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-386-cgo), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-386-cgo), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-386-cgo), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Pad_cgo_0 [8]uint8
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-amd64), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-amd64), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-amd64), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-amd64), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-amd64), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-amd64), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-amd64), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-amd64), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-amd64-cgo), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-arm), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-arm), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-arm), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-arm), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-arm), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-arm), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-arm), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-arm), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-arm-cgo), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntonname [88]int8
-pkg text/scanner, const GoTokens = 1012
-pkg unicode, const Version = "10.0.0"
-pkg unicode, const Version = "11.0.0"
-pkg unicode, const Version = "12.0.0"

api/go1.11.txt

@@ -1,559 +0,0 @@
-pkg crypto/cipher, func NewGCMWithTagSize(Block, int) (AEAD, error)
-pkg crypto/rsa, method (*PrivateKey) Size() int
-pkg crypto/rsa, method (*PublicKey) Size() int
-pkg crypto/tls, method (*ConnectionState) ExportKeyingMaterial(string, []uint8, int) ([]uint8, error)
-pkg database/sql, method (IsolationLevel) String() string
-pkg database/sql, type DBStats struct, Idle int
-pkg database/sql, type DBStats struct, InUse int
-pkg database/sql, type DBStats struct, MaxIdleClosed int64
-pkg database/sql, type DBStats struct, MaxLifetimeClosed int64
-pkg database/sql, type DBStats struct, MaxOpenConnections int
-pkg database/sql, type DBStats struct, WaitCount int64
-pkg database/sql, type DBStats struct, WaitDuration time.Duration
-pkg debug/elf, const ELFOSABI_AROS = 15
-pkg debug/elf, const ELFOSABI_AROS OSABI
-pkg debug/elf, const ELFOSABI_CLOUDABI = 17
-pkg debug/elf, const ELFOSABI_CLOUDABI OSABI
-pkg debug/elf, const ELFOSABI_FENIXOS = 16
-pkg debug/elf, const ELFOSABI_FENIXOS OSABI
-pkg debug/elf, const EM_56800EX = 200
-pkg debug/elf, const EM_56800EX Machine
-pkg debug/elf, const EM_68HC05 = 72
-pkg debug/elf, const EM_68HC05 Machine
-pkg debug/elf, const EM_68HC08 = 71
-pkg debug/elf, const EM_68HC08 Machine
-pkg debug/elf, const EM_68HC11 = 70
-pkg debug/elf, const EM_68HC11 Machine
-pkg debug/elf, const EM_68HC16 = 69
-pkg debug/elf, const EM_68HC16 Machine
-pkg debug/elf, const EM_78KOR = 199
-pkg debug/elf, const EM_78KOR Machine
-pkg debug/elf, const EM_8051 = 165
-pkg debug/elf, const EM_8051 Machine
-pkg debug/elf, const EM_ALTERA_NIOS2 = 113
-pkg debug/elf, const EM_ALTERA_NIOS2 Machine
-pkg debug/elf, const EM_AMDGPU = 224
-pkg debug/elf, const EM_AMDGPU Machine
-pkg debug/elf, const EM_ARCA = 109
-pkg debug/elf, const EM_ARCA Machine
-pkg debug/elf, const EM_ARC_COMPACT = 93
-pkg debug/elf, const EM_ARC_COMPACT Machine
-pkg debug/elf, const EM_ARC_COMPACT2 = 195
-pkg debug/elf, const EM_ARC_COMPACT2 Machine
-pkg debug/elf, const EM_AVR = 83
-pkg debug/elf, const EM_AVR Machine
-pkg debug/elf, const EM_AVR32 = 185
-pkg debug/elf, const EM_AVR32 Machine
-pkg debug/elf, const EM_BA1 = 201
-pkg debug/elf, const EM_BA1 Machine
-pkg debug/elf, const EM_BA2 = 202
-pkg debug/elf, const EM_BA2 Machine
-pkg debug/elf, const EM_BLACKFIN = 106
-pkg debug/elf, const EM_BLACKFIN Machine
-pkg debug/elf, const EM_BPF = 247
-pkg debug/elf, const EM_BPF Machine
-pkg debug/elf, const EM_C166 = 116
-pkg debug/elf, const EM_C166 Machine
-pkg debug/elf, const EM_CDP = 215
-pkg debug/elf, const EM_CDP Machine
-pkg debug/elf, const EM_CE = 119
-pkg debug/elf, const EM_CE Machine
-pkg debug/elf, const EM_CLOUDSHIELD = 192
-pkg debug/elf, const EM_CLOUDSHIELD Machine
-pkg debug/elf, const EM_COGE = 216
-pkg debug/elf, const EM_COGE Machine
-pkg debug/elf, const EM_COOL = 217
-pkg debug/elf, const EM_COOL Machine
-pkg debug/elf, const EM_COREA_1ST = 193
-pkg debug/elf, const EM_COREA_1ST Machine
-pkg debug/elf, const EM_COREA_2ND = 194
-pkg debug/elf, const EM_COREA_2ND Machine
-pkg debug/elf, const EM_CR = 103
-pkg debug/elf, const EM_CR Machine
-pkg debug/elf, const EM_CR16 = 177
-pkg debug/elf, const EM_CR16 Machine
-pkg debug/elf, const EM_CRAYNV2 = 172
-pkg debug/elf, const EM_CRAYNV2 Machine
-pkg debug/elf, const EM_CRIS = 76
-pkg debug/elf, const EM_CRIS Machine
-pkg debug/elf, const EM_CRX = 114
-pkg debug/elf, const EM_CRX Machine
-pkg debug/elf, const EM_CSR_KALIMBA = 219
-pkg debug/elf, const EM_CSR_KALIMBA Machine
-pkg debug/elf, const EM_CUDA = 190
-pkg debug/elf, const EM_CUDA Machine
-pkg debug/elf, const EM_CYPRESS_M8C = 161
-pkg debug/elf, const EM_CYPRESS_M8C Machine
-pkg debug/elf, const EM_D10V = 85
-pkg debug/elf, const EM_D10V Machine
-pkg debug/elf, const EM_D30V = 86
-pkg debug/elf, const EM_D30V Machine
-pkg debug/elf, const EM_DSP24 = 136
-pkg debug/elf, const EM_DSP24 Machine
-pkg debug/elf, const EM_DSPIC30F = 118
-pkg debug/elf, const EM_DSPIC30F Machine
-pkg debug/elf, const EM_DXP = 112
-pkg debug/elf, const EM_DXP Machine
-pkg debug/elf, const EM_ECOG1 = 168
-pkg debug/elf, const EM_ECOG1 Machine
-pkg debug/elf, const EM_ECOG16 = 176
-pkg debug/elf, const EM_ECOG16 Machine
-pkg debug/elf, const EM_ECOG1X = 168
-pkg debug/elf, const EM_ECOG1X Machine
-pkg debug/elf, const EM_ECOG2 = 134
-pkg debug/elf, const EM_ECOG2 Machine
-pkg debug/elf, const EM_ETPU = 178
-pkg debug/elf, const EM_ETPU Machine
-pkg debug/elf, const EM_EXCESS = 111
-pkg debug/elf, const EM_EXCESS Machine
-pkg debug/elf, const EM_F2MC16 = 104
-pkg debug/elf, const EM_F2MC16 Machine
-pkg debug/elf, const EM_FIREPATH = 78
-pkg debug/elf, const EM_FIREPATH Machine
-pkg debug/elf, const EM_FR30 = 84
-pkg debug/elf, const EM_FR30 Machine
-pkg debug/elf, const EM_FT32 = 222
-pkg debug/elf, const EM_FT32 Machine
-pkg debug/elf, const EM_FX66 = 66
-pkg debug/elf, const EM_FX66 Machine
-pkg debug/elf, const EM_HUANY = 81
-pkg debug/elf, const EM_HUANY Machine
-pkg debug/elf, const EM_INTEL205 = 205
-pkg debug/elf, const EM_INTEL205 Machine
-pkg debug/elf, const EM_INTEL206 = 206
-pkg debug/elf, const EM_INTEL206 Machine
-pkg debug/elf, const EM_INTEL207 = 207
-pkg debug/elf, const EM_INTEL207 Machine
-pkg debug/elf, const EM_INTEL208 = 208
-pkg debug/elf, const EM_INTEL208 Machine
-pkg debug/elf, const EM_INTEL209 = 209
-pkg debug/elf, const EM_INTEL209 Machine
-pkg debug/elf, const EM_IP2K = 101
-pkg debug/elf, const EM_IP2K Machine
-pkg debug/elf, const EM_JAVELIN = 77
-pkg debug/elf, const EM_JAVELIN Machine
-pkg debug/elf, const EM_K10M = 181
-pkg debug/elf, const EM_K10M Machine
-pkg debug/elf, const EM_KM32 = 210
-pkg debug/elf, const EM_KM32 Machine
-pkg debug/elf, const EM_KMX16 = 212
-pkg debug/elf, const EM_KMX16 Machine
-pkg debug/elf, const EM_KMX32 = 211
-pkg debug/elf, const EM_KMX32 Machine
-pkg debug/elf, const EM_KMX8 = 213
-pkg debug/elf, const EM_KMX8 Machine
-pkg debug/elf, const EM_KVARC = 214
-pkg debug/elf, const EM_KVARC Machine
-pkg debug/elf, const EM_L10M = 180
-pkg debug/elf, const EM_L10M Machine
-pkg debug/elf, const EM_LANAI = 244
-pkg debug/elf, const EM_LANAI Machine
-pkg debug/elf, const EM_LATTICEMICO32 = 138
-pkg debug/elf, const EM_LATTICEMICO32 Machine
-pkg debug/elf, const EM_M16C = 117
-pkg debug/elf, const EM_M16C Machine
-pkg debug/elf, const EM_M32C = 120
-pkg debug/elf, const EM_M32C Machine
-pkg debug/elf, const EM_M32R = 88
-pkg debug/elf, const EM_M32R Machine
-pkg debug/elf, const EM_MANIK = 171
-pkg debug/elf, const EM_MANIK Machine
-pkg debug/elf, const EM_MAX = 102
-pkg debug/elf, const EM_MAX Machine
-pkg debug/elf, const EM_MAXQ30 = 169
-pkg debug/elf, const EM_MAXQ30 Machine
-pkg debug/elf, const EM_MCHP_PIC = 204
-pkg debug/elf, const EM_MCHP_PIC Machine
-pkg debug/elf, const EM_MCST_ELBRUS = 175
-pkg debug/elf, const EM_MCST_ELBRUS Machine
-pkg debug/elf, const EM_METAG = 174
-pkg debug/elf, const EM_METAG Machine
-pkg debug/elf, const EM_MICROBLAZE = 189
-pkg debug/elf, const EM_MICROBLAZE Machine
-pkg debug/elf, const EM_MMDSP_PLUS = 160
-pkg debug/elf, const EM_MMDSP_PLUS Machine
-pkg debug/elf, const EM_MMIX = 80
-pkg debug/elf, const EM_MMIX Machine
-pkg debug/elf, const EM_MN10200 = 90
-pkg debug/elf, const EM_MN10200 Machine
-pkg debug/elf, const EM_MN10300 = 89
-pkg debug/elf, const EM_MN10300 Machine
-pkg debug/elf, const EM_MOXIE = 223
-pkg debug/elf, const EM_MOXIE Machine
-pkg debug/elf, const EM_MSP430 = 105
-pkg debug/elf, const EM_MSP430 Machine
-pkg debug/elf, const EM_NDS32 = 167
-pkg debug/elf, const EM_NDS32 Machine
-pkg debug/elf, const EM_NORC = 218
-pkg debug/elf, const EM_NORC Machine
-pkg debug/elf, const EM_NS32K = 97
-pkg debug/elf, const EM_NS32K Machine
-pkg debug/elf, const EM_OPEN8 = 196
-pkg debug/elf, const EM_OPEN8 Machine
-pkg debug/elf, const EM_OPENRISC = 92
-pkg debug/elf, const EM_OPENRISC Machine
-pkg debug/elf, const EM_PDP10 = 64
-pkg debug/elf, const EM_PDP10 Machine
-pkg debug/elf, const EM_PDP11 = 65
-pkg debug/elf, const EM_PDP11 Machine
-pkg debug/elf, const EM_PDSP = 63
-pkg debug/elf, const EM_PDSP Machine
-pkg debug/elf, const EM_PJ = 91
-pkg debug/elf, const EM_PJ Machine
-pkg debug/elf, const EM_PRISM = 82
-pkg debug/elf, const EM_PRISM Machine
-pkg debug/elf, const EM_QDSP6 = 164
-pkg debug/elf, const EM_QDSP6 Machine
-pkg debug/elf, const EM_R32C = 162
-pkg debug/elf, const EM_R32C Machine
-pkg debug/elf, const EM_RISCV = 243
-pkg debug/elf, const EM_RISCV Machine
-pkg debug/elf, const EM_RL78 = 197
-pkg debug/elf, const EM_RL78 Machine
-pkg debug/elf, const EM_RS08 = 132
-pkg debug/elf, const EM_RS08 Machine
-pkg debug/elf, const EM_RX = 173
-pkg debug/elf, const EM_RX Machine
-pkg debug/elf, const EM_SCORE7 = 135
-pkg debug/elf, const EM_SCORE7 Machine
-pkg debug/elf, const EM_SEP = 108
-pkg debug/elf, const EM_SEP Machine
-pkg debug/elf, const EM_SE_C17 = 139
-pkg debug/elf, const EM_SE_C17 Machine
-pkg debug/elf, const EM_SE_C33 = 107
-pkg debug/elf, const EM_SE_C33 Machine
-pkg debug/elf, const EM_SHARC = 133
-pkg debug/elf, const EM_SHARC Machine
-pkg debug/elf, const EM_SLE9X = 179
-pkg debug/elf, const EM_SLE9X Machine
-pkg debug/elf, const EM_SNP1K = 99
-pkg debug/elf, const EM_SNP1K Machine
-pkg debug/elf, const EM_ST19 = 74
-pkg debug/elf, const EM_ST19 Machine
-pkg debug/elf, const EM_ST200 = 100
-pkg debug/elf, const EM_ST200 Machine
-pkg debug/elf, const EM_ST7 = 68
-pkg debug/elf, const EM_ST7 Machine
-pkg debug/elf, const EM_ST9PLUS = 67
-pkg debug/elf, const EM_ST9PLUS Machine
-pkg debug/elf, const EM_STM8 = 186
-pkg debug/elf, const EM_STM8 Machine
-pkg debug/elf, const EM_STXP7X = 166
-pkg debug/elf, const EM_STXP7X Machine
-pkg debug/elf, const EM_SVX = 73
-pkg debug/elf, const EM_SVX Machine
-pkg debug/elf, const EM_TILE64 = 187
-pkg debug/elf, const EM_TILE64 Machine
-pkg debug/elf, const EM_TILEGX = 191
-pkg debug/elf, const EM_TILEGX Machine
-pkg debug/elf, const EM_TILEPRO = 188
-pkg debug/elf, const EM_TILEPRO Machine
-pkg debug/elf, const EM_TI_ARP32 = 143
-pkg debug/elf, const EM_TI_ARP32 Machine
-pkg debug/elf, const EM_TI_C2000 = 141
-pkg debug/elf, const EM_TI_C2000 Machine
-pkg debug/elf, const EM_TI_C5500 = 142
-pkg debug/elf, const EM_TI_C5500 Machine
-pkg debug/elf, const EM_TI_C6000 = 140
-pkg debug/elf, const EM_TI_C6000 Machine
-pkg debug/elf, const EM_TI_PRU = 144
-pkg debug/elf, const EM_TI_PRU Machine
-pkg debug/elf, const EM_TMM_GPP = 96
-pkg debug/elf, const EM_TMM_GPP Machine
-pkg debug/elf, const EM_TPC = 98
-pkg debug/elf, const EM_TPC Machine
-pkg debug/elf, const EM_TRIMEDIA = 163
-pkg debug/elf, const EM_TRIMEDIA Machine
-pkg debug/elf, const EM_TSK3000 = 131
-pkg debug/elf, const EM_TSK3000 Machine
-pkg debug/elf, const EM_UNICORE = 110
-pkg debug/elf, const EM_UNICORE Machine
-pkg debug/elf, const EM_V850 = 87
-pkg debug/elf, const EM_V850 Machine
-pkg debug/elf, const EM_VAX = 75
-pkg debug/elf, const EM_VAX Machine
-pkg debug/elf, const EM_VIDEOCORE = 95
-pkg debug/elf, const EM_VIDEOCORE Machine
-pkg debug/elf, const EM_VIDEOCORE3 = 137
-pkg debug/elf, const EM_VIDEOCORE3 Machine
-pkg debug/elf, const EM_VIDEOCORE5 = 198
-pkg debug/elf, const EM_VIDEOCORE5 Machine
-pkg debug/elf, const EM_VISIUM = 221
-pkg debug/elf, const EM_VISIUM Machine
-pkg debug/elf, const EM_XCORE = 203
-pkg debug/elf, const EM_XCORE Machine
-pkg debug/elf, const EM_XGATE = 115
-pkg debug/elf, const EM_XGATE Machine
-pkg debug/elf, const EM_XIMO16 = 170
-pkg debug/elf, const EM_XIMO16 Machine
-pkg debug/elf, const EM_XTENSA = 94
-pkg debug/elf, const EM_XTENSA Machine
-pkg debug/elf, const EM_Z80 = 220
-pkg debug/elf, const EM_Z80 Machine
-pkg debug/elf, const EM_ZSP = 79
-pkg debug/elf, const EM_ZSP Machine
-pkg debug/elf, const R_RISCV_32 = 1
-pkg debug/elf, const R_RISCV_32 R_RISCV
-pkg debug/elf, const R_RISCV_64 = 2
-pkg debug/elf, const R_RISCV_64 R_RISCV
-pkg debug/elf, const R_RISCV_ADD16 = 34
-pkg debug/elf, const R_RISCV_ADD16 R_RISCV
-pkg debug/elf, const R_RISCV_ADD32 = 35
-pkg debug/elf, const R_RISCV_ADD32 R_RISCV
-pkg debug/elf, const R_RISCV_ADD64 = 36
-pkg debug/elf, const R_RISCV_ADD64 R_RISCV
-pkg debug/elf, const R_RISCV_ADD8 = 33
-pkg debug/elf, const R_RISCV_ADD8 R_RISCV
-pkg debug/elf, const R_RISCV_ALIGN = 43
-pkg debug/elf, const R_RISCV_ALIGN R_RISCV
-pkg debug/elf, const R_RISCV_BRANCH = 16
-pkg debug/elf, const R_RISCV_BRANCH R_RISCV
-pkg debug/elf, const R_RISCV_CALL = 18
-pkg debug/elf, const R_RISCV_CALL R_RISCV
-pkg debug/elf, const R_RISCV_CALL_PLT = 19
-pkg debug/elf, const R_RISCV_CALL_PLT R_RISCV
-pkg debug/elf, const R_RISCV_COPY = 4
-pkg debug/elf, const R_RISCV_COPY R_RISCV
-pkg debug/elf, const R_RISCV_GNU_VTENTRY = 42
-pkg debug/elf, const R_RISCV_GNU_VTENTRY R_RISCV
-pkg debug/elf, const R_RISCV_GNU_VTINHERIT = 41
-pkg debug/elf, const R_RISCV_GNU_VTINHERIT R_RISCV
-pkg debug/elf, const R_RISCV_GOT_HI20 = 20
-pkg debug/elf, const R_RISCV_GOT_HI20 R_RISCV
-pkg debug/elf, const R_RISCV_GPREL_I = 47
-pkg debug/elf, const R_RISCV_GPREL_I R_RISCV
-pkg debug/elf, const R_RISCV_GPREL_S = 48
-pkg debug/elf, const R_RISCV_GPREL_S R_RISCV
-pkg debug/elf, const R_RISCV_HI20 = 26
-pkg debug/elf, const R_RISCV_HI20 R_RISCV
-pkg debug/elf, const R_RISCV_JAL = 17
-pkg debug/elf, const R_RISCV_JAL R_RISCV
-pkg debug/elf, const R_RISCV_JUMP_SLOT = 5
-pkg debug/elf, const R_RISCV_JUMP_SLOT R_RISCV
-pkg debug/elf, const R_RISCV_LO12_I = 27
-pkg debug/elf, const R_RISCV_LO12_I R_RISCV
-pkg debug/elf, const R_RISCV_LO12_S = 28
-pkg debug/elf, const R_RISCV_LO12_S R_RISCV
-pkg debug/elf, const R_RISCV_NONE = 0
-pkg debug/elf, const R_RISCV_NONE R_RISCV
-pkg debug/elf, const R_RISCV_PCREL_HI20 = 23
-pkg debug/elf, const R_RISCV_PCREL_HI20 R_RISCV
-pkg debug/elf, const R_RISCV_PCREL_LO12_I = 24
-pkg debug/elf, const R_RISCV_PCREL_LO12_I R_RISCV
-pkg debug/elf, const R_RISCV_PCREL_LO12_S = 25
-pkg debug/elf, const R_RISCV_PCREL_LO12_S R_RISCV
-pkg debug/elf, const R_RISCV_RELATIVE = 3
-pkg debug/elf, const R_RISCV_RELATIVE R_RISCV
-pkg debug/elf, const R_RISCV_RELAX = 51
-pkg debug/elf, const R_RISCV_RELAX R_RISCV
-pkg debug/elf, const R_RISCV_RVC_BRANCH = 44
-pkg debug/elf, const R_RISCV_RVC_BRANCH R_RISCV
-pkg debug/elf, const R_RISCV_RVC_JUMP = 45
-pkg debug/elf, const R_RISCV_RVC_JUMP R_RISCV
-pkg debug/elf, const R_RISCV_RVC_LUI = 46
-pkg debug/elf, const R_RISCV_RVC_LUI R_RISCV
-pkg debug/elf, const R_RISCV_SET16 = 55
-pkg debug/elf, const R_RISCV_SET16 R_RISCV
-pkg debug/elf, const R_RISCV_SET32 = 56
-pkg debug/elf, const R_RISCV_SET32 R_RISCV
-pkg debug/elf, const R_RISCV_SET6 = 53
-pkg debug/elf, const R_RISCV_SET6 R_RISCV
-pkg debug/elf, const R_RISCV_SET8 = 54
-pkg debug/elf, const R_RISCV_SET8 R_RISCV
-pkg debug/elf, const R_RISCV_SUB16 = 38
-pkg debug/elf, const R_RISCV_SUB16 R_RISCV
-pkg debug/elf, const R_RISCV_SUB32 = 39
-pkg debug/elf, const R_RISCV_SUB32 R_RISCV
-pkg debug/elf, const R_RISCV_SUB6 = 52
-pkg debug/elf, const R_RISCV_SUB6 R_RISCV
-pkg debug/elf, const R_RISCV_SUB64 = 40
-pkg debug/elf, const R_RISCV_SUB64 R_RISCV
-pkg debug/elf, const R_RISCV_SUB8 = 37
-pkg debug/elf, const R_RISCV_SUB8 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_DTPMOD32 = 6
-pkg debug/elf, const R_RISCV_TLS_DTPMOD32 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_DTPMOD64 = 7
-pkg debug/elf, const R_RISCV_TLS_DTPMOD64 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_DTPREL32 = 8
-pkg debug/elf, const R_RISCV_TLS_DTPREL32 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_DTPREL64 = 9
-pkg debug/elf, const R_RISCV_TLS_DTPREL64 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_GD_HI20 = 22
-pkg debug/elf, const R_RISCV_TLS_GD_HI20 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_GOT_HI20 = 21
-pkg debug/elf, const R_RISCV_TLS_GOT_HI20 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_TPREL32 = 10
-pkg debug/elf, const R_RISCV_TLS_TPREL32 R_RISCV
-pkg debug/elf, const R_RISCV_TLS_TPREL64 = 11
-pkg debug/elf, const R_RISCV_TLS_TPREL64 R_RISCV
-pkg debug/elf, const R_RISCV_TPREL_ADD = 32
-pkg debug/elf, const R_RISCV_TPREL_ADD R_RISCV
-pkg debug/elf, const R_RISCV_TPREL_HI20 = 29
-pkg debug/elf, const R_RISCV_TPREL_HI20 R_RISCV
-pkg debug/elf, const R_RISCV_TPREL_I = 49
-pkg debug/elf, const R_RISCV_TPREL_I R_RISCV
-pkg debug/elf, const R_RISCV_TPREL_LO12_I = 30
-pkg debug/elf, const R_RISCV_TPREL_LO12_I R_RISCV
-pkg debug/elf, const R_RISCV_TPREL_LO12_S = 31
-pkg debug/elf, const R_RISCV_TPREL_LO12_S R_RISCV
-pkg debug/elf, const R_RISCV_TPREL_S = 50
-pkg debug/elf, const R_RISCV_TPREL_S R_RISCV
-pkg debug/elf, method (R_RISCV) GoString() string
-pkg debug/elf, method (R_RISCV) String() string
-pkg debug/elf, type R_RISCV int
-pkg debug/macho, const CpuArm64 = 16777228
-pkg debug/macho, const CpuArm64 Cpu
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_ARCHITECTURE = 7
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_ARCHITECTURE ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_BASERELOC = 5
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_BASERELOC ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT = 11
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR = 14
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_DEBUG = 6
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_DEBUG ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT = 13
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_EXCEPTION = 3
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_EXCEPTION ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_EXPORT = 0
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_EXPORT ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_GLOBALPTR = 8
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_GLOBALPTR ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_IAT = 12
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_IAT ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_IMPORT = 1
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_IMPORT ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG = 10
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_RESOURCE = 2
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_RESOURCE ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_SECURITY = 4
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_SECURITY ideal-int
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_TLS = 9
-pkg debug/pe, const IMAGE_DIRECTORY_ENTRY_TLS ideal-int
-pkg debug/pe, const IMAGE_FILE_MACHINE_ARM64 = 43620
-pkg debug/pe, const IMAGE_FILE_MACHINE_ARM64 ideal-int
-pkg go/ast, type CompositeLit struct, Incomplete bool
-pkg go/token, method (*File) AddLineColumnInfo(int, string, int, int)
-pkg go/types, func NewInterfaceType([]*Func, []Type) *Interface
-pkg go/types, method (*Interface) EmbeddedType(int) Type
-pkg go/types, method (*Var) Embedded() bool
-pkg net, method (*ListenConfig) Listen(context.Context, string, string) (Listener, error)
-pkg net, method (*ListenConfig) ListenPacket(context.Context, string, string) (PacketConn, error)
-pkg net, type Dialer struct, Control func(string, string, syscall.RawConn) error
-pkg net, type ListenConfig struct
-pkg net, type ListenConfig struct, Control func(string, string, syscall.RawConn) error
-pkg net/http, const SameSiteDefaultMode = 1
-pkg net/http, const SameSiteDefaultMode SameSite
-pkg net/http, const SameSiteLaxMode = 2
-pkg net/http, const SameSiteLaxMode SameSite
-pkg net/http, const SameSiteStrictMode = 3
-pkg net/http, const SameSiteStrictMode SameSite
-pkg net/http, const StatusMisdirectedRequest = 421
-pkg net/http, const StatusMisdirectedRequest ideal-int
-pkg net/http, type Cookie struct, SameSite SameSite
-pkg net/http, type SameSite int
-pkg net/http, type Transport struct, MaxConnsPerHost int
-pkg net/http/httptrace, type ClientTrace struct, Got1xxResponse func(int, textproto.MIMEHeader) error
-pkg net/http/httptrace, type ClientTrace struct, WroteHeaderField func(string, []string)
-pkg net/http/httputil, type ReverseProxy struct, ErrorHandler func(http.ResponseWriter, *http.Request, error)
-pkg os, const ModeIrregular = 524288
-pkg os, const ModeIrregular FileMode
-pkg os, const ModeType = 2399666176
-pkg os, func UserCacheDir() (string, error)
-pkg os/signal, func Ignored(os.Signal) bool
-pkg regexp/syntax, method (Op) String() string
-pkg runtime/trace, func IsEnabled() bool
-pkg runtime/trace, func Log(context.Context, string, string)
-pkg runtime/trace, func Logf(context.Context, string, string, ...interface{})
-pkg runtime/trace, func NewTask(context.Context, string) (context.Context, *Task)
-pkg runtime/trace, func StartRegion(context.Context, string) *Region
-pkg runtime/trace, func WithRegion(context.Context, string, func())
-pkg runtime/trace, method (*Region) End()
-pkg runtime/trace, method (*Task) End()
-pkg runtime/trace, type Region struct
-pkg runtime/trace, type Task struct
-pkg syscall (netbsd-386), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (netbsd-386), func Pipe2([]int, int) error
-pkg syscall (netbsd-386-cgo), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (netbsd-386-cgo), func Pipe2([]int, int) error
-pkg syscall (netbsd-amd64), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (netbsd-amd64), func Pipe2([]int, int) error
-pkg syscall (netbsd-amd64-cgo), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (netbsd-amd64-cgo), func Pipe2([]int, int) error
-pkg syscall (netbsd-arm), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (netbsd-arm), func Pipe2([]int, int) error
-pkg syscall (netbsd-arm-cgo), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (netbsd-arm-cgo), func Pipe2([]int, int) error
-pkg syscall (openbsd-386), const SOCK_CLOEXEC = 32768
-pkg syscall (openbsd-386), const SOCK_CLOEXEC ideal-int
-pkg syscall (openbsd-386), const SOCK_NONBLOCK = 16384
-pkg syscall (openbsd-386), const SOCK_NONBLOCK ideal-int
-pkg syscall (openbsd-386), const SYS_ACCEPT4 = 93
-pkg syscall (openbsd-386), const SYS_ACCEPT4 ideal-int
-pkg syscall (openbsd-386), const SYS_PIPE2 = 101
-pkg syscall (openbsd-386), const SYS_PIPE2 ideal-int
-pkg syscall (openbsd-386), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (openbsd-386), func Pipe2([]int, int) error
-pkg syscall (openbsd-386-cgo), const SOCK_CLOEXEC = 32768
-pkg syscall (openbsd-386-cgo), const SOCK_CLOEXEC ideal-int
-pkg syscall (openbsd-386-cgo), const SOCK_NONBLOCK = 16384
-pkg syscall (openbsd-386-cgo), const SOCK_NONBLOCK ideal-int
-pkg syscall (openbsd-386-cgo), const SYS_ACCEPT4 = 93
-pkg syscall (openbsd-386-cgo), const SYS_ACCEPT4 ideal-int
-pkg syscall (openbsd-386-cgo), const SYS_PIPE2 = 101
-pkg syscall (openbsd-386-cgo), const SYS_PIPE2 ideal-int
-pkg syscall (openbsd-386-cgo), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (openbsd-386-cgo), func Pipe2([]int, int) error
-pkg syscall (openbsd-amd64), const SOCK_CLOEXEC = 32768
-pkg syscall (openbsd-amd64), const SOCK_CLOEXEC ideal-int
-pkg syscall (openbsd-amd64), const SOCK_NONBLOCK = 16384
-pkg syscall (openbsd-amd64), const SOCK_NONBLOCK ideal-int
-pkg syscall (openbsd-amd64), const SYS_ACCEPT4 = 93
-pkg syscall (openbsd-amd64), const SYS_ACCEPT4 ideal-int
-pkg syscall (openbsd-amd64), const SYS_PIPE2 = 101
-pkg syscall (openbsd-amd64), const SYS_PIPE2 ideal-int
-pkg syscall (openbsd-amd64), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (openbsd-amd64), func Pipe2([]int, int) error
-pkg syscall (openbsd-amd64-cgo), const SOCK_CLOEXEC = 32768
-pkg syscall (openbsd-amd64-cgo), const SOCK_CLOEXEC ideal-int
-pkg syscall (openbsd-amd64-cgo), const SOCK_NONBLOCK = 16384
-pkg syscall (openbsd-amd64-cgo), const SOCK_NONBLOCK ideal-int
-pkg syscall (openbsd-amd64-cgo), const SYS_ACCEPT4 = 93
-pkg syscall (openbsd-amd64-cgo), const SYS_ACCEPT4 ideal-int
-pkg syscall (openbsd-amd64-cgo), const SYS_PIPE2 = 101
-pkg syscall (openbsd-amd64-cgo), const SYS_PIPE2 ideal-int
-pkg syscall (openbsd-amd64-cgo), func Accept4(int, int) (int, Sockaddr, error)
-pkg syscall (openbsd-amd64-cgo), func Pipe2([]int, int) error
-pkg syscall (windows-386), const TOKEN_ADJUST_SESSIONID = 256
-pkg syscall (windows-386), const TOKEN_ADJUST_SESSIONID ideal-int
-pkg syscall (windows-386), const TOKEN_ALL_ACCESS = 983551
-pkg syscall (windows-386), type AddrinfoW struct, Addr Pointer
-pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara Pointer
-pkg syscall (windows-386), type CertChainPolicyStatus struct, ExtraPolicyStatus Pointer
-pkg syscall (windows-386), type CertContext struct, CertInfo *CertInfo
-pkg syscall (windows-386), type CertInfo struct
-pkg syscall (windows-386), type CertRevocationCrlInfo struct
-pkg syscall (windows-386), type CertRevocationInfo struct, CrlInfo *CertRevocationCrlInfo
-pkg syscall (windows-386), type CertRevocationInfo struct, OidSpecificInfo Pointer
-pkg syscall (windows-386), type CertSimpleChain struct, TrustListInfo *CertTrustListInfo
-pkg syscall (windows-386), type CertTrustListInfo struct
-pkg syscall (windows-386), type Pointer *struct
-pkg syscall (windows-amd64), const TOKEN_ADJUST_SESSIONID = 256
-pkg syscall (windows-amd64), const TOKEN_ADJUST_SESSIONID ideal-int
-pkg syscall (windows-amd64), const TOKEN_ALL_ACCESS = 983551
-pkg syscall (windows-amd64), type AddrinfoW struct, Addr Pointer
-pkg syscall (windows-amd64), type CertChainPolicyPara struct, ExtraPolicyPara Pointer
-pkg syscall (windows-amd64), type CertChainPolicyStatus struct, ExtraPolicyStatus Pointer
-pkg syscall (windows-amd64), type CertContext struct, CertInfo *CertInfo
-pkg syscall (windows-amd64), type CertInfo struct
-pkg syscall (windows-amd64), type CertRevocationCrlInfo struct
-pkg syscall (windows-amd64), type CertRevocationInfo struct, CrlInfo *CertRevocationCrlInfo
-pkg syscall (windows-amd64), type CertRevocationInfo struct, OidSpecificInfo Pointer
-pkg syscall (windows-amd64), type CertSimpleChain struct, TrustListInfo *CertTrustListInfo
-pkg syscall (windows-amd64), type CertTrustListInfo struct
-pkg syscall (windows-amd64), type Pointer *struct
-pkg syscall, const ImplementsGetwd = true
-pkg text/template/parse, type PipeNode struct, IsAssign bool

api/go1.12.txt

@@ -1,228 +0,0 @@
-pkg bytes, func ReplaceAll([]uint8, []uint8, []uint8) []uint8
-pkg crypto/tls, const TLS_AES_128_GCM_SHA256 = 4865
-pkg crypto/tls, const TLS_AES_128_GCM_SHA256 uint16
-pkg crypto/tls, const TLS_AES_256_GCM_SHA384 = 4866
-pkg crypto/tls, const TLS_AES_256_GCM_SHA384 uint16
-pkg crypto/tls, const TLS_CHACHA20_POLY1305_SHA256 = 4867
-pkg crypto/tls, const TLS_CHACHA20_POLY1305_SHA256 uint16
-pkg crypto/tls, const VersionTLS13 = 772
-pkg crypto/tls, const VersionTLS13 ideal-int
-pkg crypto/tls, type RecordHeaderError struct, Conn net.Conn
-pkg debug/elf, const R_RISCV_32_PCREL = 57
-pkg debug/elf, const R_RISCV_32_PCREL R_RISCV
-pkg debug/pe, const IMAGE_FILE_MACHINE_ARMNT = 452
-pkg debug/pe, const IMAGE_FILE_MACHINE_ARMNT ideal-int
-pkg expvar, method (*Map) Delete(string)
-pkg go/doc, const PreserveAST = 4
-pkg go/doc, const PreserveAST Mode
-pkg go/importer, func ForCompiler(*token.FileSet, string, Lookup) types.Importer
-pkg go/token, method (*File) LineStart(int) Pos
-pkg io, type StringWriter interface { WriteString }
-pkg io, type StringWriter interface, WriteString(string) (int, error)
-pkg log, method (*Logger) Writer() io.Writer
-pkg math/bits, func Add(uint, uint, uint) (uint, uint)
-pkg math/bits, func Add32(uint32, uint32, uint32) (uint32, uint32)
-pkg math/bits, func Add64(uint64, uint64, uint64) (uint64, uint64)
-pkg math/bits, func Div(uint, uint, uint) (uint, uint)
-pkg math/bits, func Div32(uint32, uint32, uint32) (uint32, uint32)
-pkg math/bits, func Div64(uint64, uint64, uint64) (uint64, uint64)
-pkg math/bits, func Mul(uint, uint) (uint, uint)
-pkg math/bits, func Mul32(uint32, uint32) (uint32, uint32)
-pkg math/bits, func Mul64(uint64, uint64) (uint64, uint64)
-pkg math/bits, func Sub(uint, uint, uint) (uint, uint)
-pkg math/bits, func Sub32(uint32, uint32, uint32) (uint32, uint32)
-pkg math/bits, func Sub64(uint64, uint64, uint64) (uint64, uint64)
-pkg net/http, const StatusTooEarly = 425
-pkg net/http, const StatusTooEarly ideal-int
-pkg net/http, method (*Client) CloseIdleConnections()
-pkg os, const ModeType = 2401763328
-pkg os, func UserHomeDir() (string, error)
-pkg os, method (*File) SyscallConn() (syscall.RawConn, error)
-pkg os, method (*ProcessState) ExitCode() int
-pkg os/exec, method (ExitError) ExitCode() int
-pkg reflect, method (*MapIter) Key() Value
-pkg reflect, method (*MapIter) Next() bool
-pkg reflect, method (*MapIter) Value() Value
-pkg reflect, method (Value) MapRange() *MapIter
-pkg reflect, type MapIter struct
-pkg runtime/debug, func ReadBuildInfo() (*BuildInfo, bool)
-pkg runtime/debug, type BuildInfo struct
-pkg runtime/debug, type BuildInfo struct, Deps []*Module
-pkg runtime/debug, type BuildInfo struct, Main Module
-pkg runtime/debug, type BuildInfo struct, Path string
-pkg runtime/debug, type Module struct
-pkg runtime/debug, type Module struct, Path string
-pkg runtime/debug, type Module struct, Replace *Module
-pkg runtime/debug, type Module struct, Sum string
-pkg runtime/debug, type Module struct, Version string
-pkg strings, func ReplaceAll(string, string, string) string
-pkg strings, method (*Builder) Cap() int
-pkg syscall (freebsd-386), const S_IRWXG = 56
-pkg syscall (freebsd-386), const S_IRWXG ideal-int
-pkg syscall (freebsd-386), const S_IRWXO = 7
-pkg syscall (freebsd-386), const S_IRWXO ideal-int
-pkg syscall (freebsd-386), func Fstatat(int, string, *Stat_t, int) error
-pkg syscall (freebsd-386), func Mknod(string, uint32, uint64) error
-pkg syscall (freebsd-386), type Dirent struct, Fileno uint64
-pkg syscall (freebsd-386), type Dirent struct, Namlen uint16
-pkg syscall (freebsd-386), type Dirent struct, Off int64
-pkg syscall (freebsd-386), type Dirent struct, Pad0 uint8
-pkg syscall (freebsd-386), type Dirent struct, Pad1 uint16
-pkg syscall (freebsd-386), type Stat_t struct, Atim_ext int32
-pkg syscall (freebsd-386), type Stat_t struct, Blksize int32
-pkg syscall (freebsd-386), type Stat_t struct, Btim_ext int32
-pkg syscall (freebsd-386), type Stat_t struct, Ctim_ext int32
-pkg syscall (freebsd-386), type Stat_t struct, Dev uint64
-pkg syscall (freebsd-386), type Stat_t struct, Gen uint64
-pkg syscall (freebsd-386), type Stat_t struct, Ino uint64
-pkg syscall (freebsd-386), type Stat_t struct, Mtim_ext int32
-pkg syscall (freebsd-386), type Stat_t struct, Nlink uint64
-pkg syscall (freebsd-386), type Stat_t struct, Padding0 int16
-pkg syscall (freebsd-386), type Stat_t struct, Padding1 int32
-pkg syscall (freebsd-386), type Stat_t struct, Rdev uint64
-pkg syscall (freebsd-386), type Stat_t struct, Spare [10]uint64
-pkg syscall (freebsd-386), type Statfs_t struct, Mntfromname [1024]int8
-pkg syscall (freebsd-386), type Statfs_t struct, Mntonname [1024]int8
-pkg syscall (freebsd-386-cgo), const S_IRWXG = 56
-pkg syscall (freebsd-386-cgo), const S_IRWXG ideal-int
-pkg syscall (freebsd-386-cgo), const S_IRWXO = 7
-pkg syscall (freebsd-386-cgo), const S_IRWXO ideal-int
-pkg syscall (freebsd-386-cgo), func Fstatat(int, string, *Stat_t, int) error
-pkg syscall (freebsd-386-cgo), func Mknod(string, uint32, uint64) error
-pkg syscall (freebsd-386-cgo), type Dirent struct, Fileno uint64
-pkg syscall (freebsd-386-cgo), type Dirent struct, Namlen uint16
-pkg syscall (freebsd-386-cgo), type Dirent struct, Off int64
-pkg syscall (freebsd-386-cgo), type Dirent struct, Pad0 uint8
-pkg syscall (freebsd-386-cgo), type Dirent struct, Pad1 uint16
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Atim_ext int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Blksize int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Btim_ext int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Ctim_ext int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Dev uint64
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Gen uint64
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Ino uint64
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Mtim_ext int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Nlink uint64
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Padding0 int16
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Padding1 int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Rdev uint64
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Spare [10]uint64
-pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntfromname [1024]int8
-pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntonname [1024]int8
-pkg syscall (freebsd-amd64), const S_IRWXG = 56
-pkg syscall (freebsd-amd64), const S_IRWXG ideal-int
-pkg syscall (freebsd-amd64), const S_IRWXO = 7
-pkg syscall (freebsd-amd64), const S_IRWXO ideal-int
-pkg syscall (freebsd-amd64), func Fstatat(int, string, *Stat_t, int) error
-pkg syscall (freebsd-amd64), func Mknod(string, uint32, uint64) error
-pkg syscall (freebsd-amd64), type Dirent struct, Fileno uint64
-pkg syscall (freebsd-amd64), type Dirent struct, Namlen uint16
-pkg syscall (freebsd-amd64), type Dirent struct, Off int64
-pkg syscall (freebsd-amd64), type Dirent struct, Pad0 uint8
-pkg syscall (freebsd-amd64), type Dirent struct, Pad1 uint16
-pkg syscall (freebsd-amd64), type Stat_t struct, Blksize int32
-pkg syscall (freebsd-amd64), type Stat_t struct, Dev uint64
-pkg syscall (freebsd-amd64), type Stat_t struct, Gen uint64
-pkg syscall (freebsd-amd64), type Stat_t struct, Ino uint64
-pkg syscall (freebsd-amd64), type Stat_t struct, Nlink uint64
-pkg syscall (freebsd-amd64), type Stat_t struct, Padding0 int16
-pkg syscall (freebsd-amd64), type Stat_t struct, Padding1 int32
-pkg syscall (freebsd-amd64), type Stat_t struct, Rdev uint64
-pkg syscall (freebsd-amd64), type Stat_t struct, Spare [10]uint64
-pkg syscall (freebsd-amd64), type Statfs_t struct, Mntfromname [1024]int8
-pkg syscall (freebsd-amd64), type Statfs_t struct, Mntonname [1024]int8
-pkg syscall (freebsd-amd64-cgo), const S_IRWXG = 56
-pkg syscall (freebsd-amd64-cgo), const S_IRWXG ideal-int
-pkg syscall (freebsd-amd64-cgo), const S_IRWXO = 7
-pkg syscall (freebsd-amd64-cgo), const S_IRWXO ideal-int
-pkg syscall (freebsd-amd64-cgo), func Fstatat(int, string, *Stat_t, int) error
-pkg syscall (freebsd-amd64-cgo), func Mknod(string, uint32, uint64) error
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Fileno uint64
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Namlen uint16
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Off int64
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Pad0 uint8
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Pad1 uint16
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Blksize int32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Dev uint64
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Gen uint64
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Ino uint64
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Nlink uint64
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Padding0 int16
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Padding1 int32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Rdev uint64
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Spare [10]uint64
-pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntfromname [1024]int8
-pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntonname [1024]int8
-pkg syscall (freebsd-arm), const S_IRWXG = 56
-pkg syscall (freebsd-arm), const S_IRWXG ideal-int
-pkg syscall (freebsd-arm), const S_IRWXO = 7
-pkg syscall (freebsd-arm), const S_IRWXO ideal-int
-pkg syscall (freebsd-arm), func Fstatat(int, string, *Stat_t, int) error
-pkg syscall (freebsd-arm), func Mknod(string, uint32, uint64) error
-pkg syscall (freebsd-arm), type Dirent struct, Fileno uint64
-pkg syscall (freebsd-arm), type Dirent struct, Namlen uint16
-pkg syscall (freebsd-arm), type Dirent struct, Off int64
-pkg syscall (freebsd-arm), type Dirent struct, Pad0 uint8
-pkg syscall (freebsd-arm), type Dirent struct, Pad1 uint16
-pkg syscall (freebsd-arm), type Stat_t struct, Blksize int32
-pkg syscall (freebsd-arm), type Stat_t struct, Dev uint64
-pkg syscall (freebsd-arm), type Stat_t struct, Gen uint64
-pkg syscall (freebsd-arm), type Stat_t struct, Ino uint64
-pkg syscall (freebsd-arm), type Stat_t struct, Nlink uint64
-pkg syscall (freebsd-arm), type Stat_t struct, Padding0 int16
-pkg syscall (freebsd-arm), type Stat_t struct, Padding1 int32
-pkg syscall (freebsd-arm), type Stat_t struct, Rdev uint64
-pkg syscall (freebsd-arm), type Stat_t struct, Spare [10]uint64
-pkg syscall (freebsd-arm), type Statfs_t struct, Mntfromname [1024]int8
-pkg syscall (freebsd-arm), type Statfs_t struct, Mntonname [1024]int8
-pkg syscall (freebsd-arm-cgo), const S_IRWXG = 56
-pkg syscall (freebsd-arm-cgo), const S_IRWXG ideal-int
-pkg syscall (freebsd-arm-cgo), const S_IRWXO = 7
-pkg syscall (freebsd-arm-cgo), const S_IRWXO ideal-int
-pkg syscall (freebsd-arm-cgo), func Fstatat(int, string, *Stat_t, int) error
-pkg syscall (freebsd-arm-cgo), func Mknod(string, uint32, uint64) error
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Fileno uint64
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Namlen uint16
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Off int64
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Pad0 uint8
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Pad1 uint16
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Blksize int32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Dev uint64
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Gen uint64
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Ino uint64
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Nlink uint64
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Padding0 int16
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Padding1 int32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Rdev uint64
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Spare [10]uint64
-pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntfromname [1024]int8
-pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntonname [1024]int8
-pkg syscall (openbsd-386), const S_IRWXG = 56
-pkg syscall (openbsd-386), const S_IRWXG ideal-int
-pkg syscall (openbsd-386), const S_IRWXO = 7
-pkg syscall (openbsd-386), const S_IRWXO ideal-int
-pkg syscall (openbsd-386-cgo), const S_IRWXG = 56
-pkg syscall (openbsd-386-cgo), const S_IRWXG ideal-int
-pkg syscall (openbsd-386-cgo), const S_IRWXO = 7
-pkg syscall (openbsd-386-cgo), const S_IRWXO ideal-int
-pkg syscall (openbsd-amd64), const S_IRWXG = 56
-pkg syscall (openbsd-amd64), const S_IRWXG ideal-int
-pkg syscall (openbsd-amd64), const S_IRWXO = 7
-pkg syscall (openbsd-amd64), const S_IRWXO ideal-int
-pkg syscall (openbsd-amd64-cgo), const S_IRWXG = 56
-pkg syscall (openbsd-amd64-cgo), const S_IRWXG ideal-int
-pkg syscall (openbsd-amd64-cgo), const S_IRWXO = 7
-pkg syscall (openbsd-amd64-cgo), const S_IRWXO ideal-int
-pkg syscall (windows-386), const UNIX_PATH_MAX = 108
-pkg syscall (windows-386), const UNIX_PATH_MAX ideal-int
-pkg syscall (windows-386), func Syscall18(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (windows-386), type RawSockaddrAny struct, Pad [100]int8
-pkg syscall (windows-386), type RawSockaddrUnix struct, Family uint16
-pkg syscall (windows-386), type RawSockaddrUnix struct, Path [108]int8
-pkg syscall (windows-amd64), const UNIX_PATH_MAX = 108
-pkg syscall (windows-amd64), const UNIX_PATH_MAX ideal-int
-pkg syscall (windows-amd64), func Syscall18(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
-pkg syscall (windows-amd64), type RawSockaddrAny struct, Pad [100]int8
-pkg syscall (windows-amd64), type RawSockaddrUnix struct, Family uint16
-pkg syscall (windows-amd64), type RawSockaddrUnix struct, Path [108]int8
-pkg syscall, type RawSockaddrUnix struct

api/go1.14.txt

@@ -1,197 +0,0 @@
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 52393
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 52392
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16
-pkg crypto/tls, func CipherSuiteName(uint16) string
-pkg crypto/tls, func CipherSuites() []*CipherSuite
-pkg crypto/tls, func InsecureCipherSuites() []*CipherSuite
-pkg crypto/tls, method (*CertificateRequestInfo) SupportsCertificate(*Certificate) error
-pkg crypto/tls, method (*ClientHelloInfo) SupportsCertificate(*Certificate) error
-pkg crypto/tls, type Certificate struct, SupportedSignatureAlgorithms []SignatureScheme
-pkg crypto/tls, type CertificateRequestInfo struct, Version uint16
-pkg crypto/tls, type CipherSuite struct
-pkg crypto/tls, type CipherSuite struct, ID uint16
-pkg crypto/tls, type CipherSuite struct, Insecure bool
-pkg crypto/tls, type CipherSuite struct, Name string
-pkg crypto/tls, type CipherSuite struct, SupportedVersions []uint16
-pkg debug/dwarf, const AttrAddrBase = 115
-pkg debug/dwarf, const AttrAddrBase Attr
-pkg debug/dwarf, const AttrAlignment = 136
-pkg debug/dwarf, const AttrAlignment Attr
-pkg debug/dwarf, const AttrBinaryScale = 91
-pkg debug/dwarf, const AttrBinaryScale Attr
-pkg debug/dwarf, const AttrCallAllCalls = 122
-pkg debug/dwarf, const AttrCallAllCalls Attr
-pkg debug/dwarf, const AttrCallAllSourceCalls = 123
-pkg debug/dwarf, const AttrCallAllSourceCalls Attr
-pkg debug/dwarf, const AttrCallAllTailCalls = 124
-pkg debug/dwarf, const AttrCallAllTailCalls Attr
-pkg debug/dwarf, const AttrCallDataLocation = 133
-pkg debug/dwarf, const AttrCallDataLocation Attr
-pkg debug/dwarf, const AttrCallDataValue = 134
-pkg debug/dwarf, const AttrCallDataValue Attr
-pkg debug/dwarf, const AttrCallOrigin = 127
-pkg debug/dwarf, const AttrCallOrigin Attr
-pkg debug/dwarf, const AttrCallPC = 129
-pkg debug/dwarf, const AttrCallPC Attr
-pkg debug/dwarf, const AttrCallParameter = 128
-pkg debug/dwarf, const AttrCallParameter Attr
-pkg debug/dwarf, const AttrCallReturnPC = 125
-pkg debug/dwarf, const AttrCallReturnPC Attr
-pkg debug/dwarf, const AttrCallTailCall = 130
-pkg debug/dwarf, const AttrCallTailCall Attr
-pkg debug/dwarf, const AttrCallTarget = 131
-pkg debug/dwarf, const AttrCallTarget Attr
-pkg debug/dwarf, const AttrCallTargetClobbered = 132
-pkg debug/dwarf, const AttrCallTargetClobbered Attr
-pkg debug/dwarf, const AttrCallValue = 126
-pkg debug/dwarf, const AttrCallValue Attr
-pkg debug/dwarf, const AttrConstExpr = 108
-pkg debug/dwarf, const AttrConstExpr Attr
-pkg debug/dwarf, const AttrDataBitOffset = 107
-pkg debug/dwarf, const AttrDataBitOffset Attr
-pkg debug/dwarf, const AttrDecimalScale = 92
-pkg debug/dwarf, const AttrDecimalScale Attr
-pkg debug/dwarf, const AttrDecimalSign = 94
-pkg debug/dwarf, const AttrDecimalSign Attr
-pkg debug/dwarf, const AttrDefaulted = 139
-pkg debug/dwarf, const AttrDefaulted Attr
-pkg debug/dwarf, const AttrDeleted = 138
-pkg debug/dwarf, const AttrDeleted Attr
-pkg debug/dwarf, const AttrDigitCount = 95
-pkg debug/dwarf, const AttrDigitCount Attr
-pkg debug/dwarf, const AttrDwoName = 118
-pkg debug/dwarf, const AttrDwoName Attr
-pkg debug/dwarf, const AttrElemental = 102
-pkg debug/dwarf, const AttrElemental Attr
-pkg debug/dwarf, const AttrEndianity = 101
-pkg debug/dwarf, const AttrEndianity Attr
-pkg debug/dwarf, const AttrEnumClass = 109
-pkg debug/dwarf, const AttrEnumClass Attr
-pkg debug/dwarf, const AttrExplicit = 99
-pkg debug/dwarf, const AttrExplicit Attr
-pkg debug/dwarf, const AttrExportSymbols = 137
-pkg debug/dwarf, const AttrExportSymbols Attr
-pkg debug/dwarf, const AttrLinkageName = 110
-pkg debug/dwarf, const AttrLinkageName Attr
-pkg debug/dwarf, const AttrLoclistsBase = 140
-pkg debug/dwarf, const AttrLoclistsBase Attr
-pkg debug/dwarf, const AttrMacros = 121
-pkg debug/dwarf, const AttrMacros Attr
-pkg debug/dwarf, const AttrMainSubprogram = 106
-pkg debug/dwarf, const AttrMainSubprogram Attr
-pkg debug/dwarf, const AttrMutable = 97
-pkg debug/dwarf, const AttrMutable Attr
-pkg debug/dwarf, const AttrNoreturn = 135
-pkg debug/dwarf, const AttrNoreturn Attr
-pkg debug/dwarf, const AttrObjectPointer = 100
-pkg debug/dwarf, const AttrObjectPointer Attr
-pkg debug/dwarf, const AttrPictureString = 96
-pkg debug/dwarf, const AttrPictureString Attr
-pkg debug/dwarf, const AttrPure = 103
-pkg debug/dwarf, const AttrPure Attr
-pkg debug/dwarf, const AttrRank = 113
-pkg debug/dwarf, const AttrRank Attr
-pkg debug/dwarf, const AttrRecursive = 104
-pkg debug/dwarf, const AttrRecursive Attr
-pkg debug/dwarf, const AttrReference = 119
-pkg debug/dwarf, const AttrReference Attr
-pkg debug/dwarf, const AttrRnglistsBase = 116
-pkg debug/dwarf, const AttrRnglistsBase Attr
-pkg debug/dwarf, const AttrRvalueReference = 120
-pkg debug/dwarf, const AttrRvalueReference Attr
-pkg debug/dwarf, const AttrSignature = 105
-pkg debug/dwarf, const AttrSignature Attr
-pkg debug/dwarf, const AttrSmall = 93
-pkg debug/dwarf, const AttrSmall Attr
-pkg debug/dwarf, const AttrStrOffsetsBase = 114
-pkg debug/dwarf, const AttrStrOffsetsBase Attr
-pkg debug/dwarf, const AttrStringLengthBitSize = 111
-pkg debug/dwarf, const AttrStringLengthBitSize Attr
-pkg debug/dwarf, const AttrStringLengthByteSize = 112
-pkg debug/dwarf, const AttrStringLengthByteSize Attr
-pkg debug/dwarf, const AttrThreadsScaled = 98
-pkg debug/dwarf, const AttrThreadsScaled Attr
-pkg debug/dwarf, const ClassAddrPtr = 15
-pkg debug/dwarf, const ClassAddrPtr Class
-pkg debug/dwarf, const ClassLocList = 16
-pkg debug/dwarf, const ClassLocList Class
-pkg debug/dwarf, const ClassRngList = 17
-pkg debug/dwarf, const ClassRngList Class
-pkg debug/dwarf, const ClassRngListsPtr = 18
-pkg debug/dwarf, const ClassRngListsPtr Class
-pkg debug/dwarf, const ClassStrOffsetsPtr = 19
-pkg debug/dwarf, const ClassStrOffsetsPtr Class
-pkg debug/dwarf, const TagAtomicType = 71
-pkg debug/dwarf, const TagAtomicType Tag
-pkg debug/dwarf, const TagCallSite = 72
-pkg debug/dwarf, const TagCallSite Tag
-pkg debug/dwarf, const TagCallSiteParameter = 73
-pkg debug/dwarf, const TagCallSiteParameter Tag
-pkg debug/dwarf, const TagCoarrayType = 68
-pkg debug/dwarf, const TagCoarrayType Tag
-pkg debug/dwarf, const TagDynamicType = 70
-pkg debug/dwarf, const TagDynamicType Tag
-pkg debug/dwarf, const TagGenericSubrange = 69
-pkg debug/dwarf, const TagGenericSubrange Tag
-pkg debug/dwarf, const TagImmutableType = 75
-pkg debug/dwarf, const TagImmutableType Tag
-pkg debug/dwarf, const TagSkeletonUnit = 74
-pkg debug/dwarf, const TagSkeletonUnit Tag
-pkg debug/dwarf, method (*Data) AddSection(string, []uint8) error
-pkg debug/dwarf, method (*LineReader) Files() []*LineFile
-pkg debug/dwarf, method (*Reader) ByteOrder() binary.ByteOrder
-pkg encoding/asn1, const TagBMPString = 30
-pkg encoding/asn1, const TagBMPString ideal-int
-pkg encoding/json, method (*Decoder) InputOffset() int64
-pkg go/build, type Context struct, Dir string
-pkg go/doc, func NewFromFiles(*token.FileSet, []*ast.File, string, ...interface{}) (*Package, error)
-pkg go/doc, type Example struct, Suffix string
-pkg go/doc, type Func struct, Examples []*Example
-pkg go/doc, type Package struct, Examples []*Example
-pkg go/doc, type Type struct, Examples []*Example
-pkg hash/maphash, func MakeSeed() Seed
-pkg hash/maphash, method (*Hash) BlockSize() int
-pkg hash/maphash, method (*Hash) Reset()
-pkg hash/maphash, method (*Hash) Seed() Seed
-pkg hash/maphash, method (*Hash) SetSeed(Seed)
-pkg hash/maphash, method (*Hash) Size() int
-pkg hash/maphash, method (*Hash) Sum([]uint8) []uint8
-pkg hash/maphash, method (*Hash) Sum64() uint64
-pkg hash/maphash, method (*Hash) Write([]uint8) (int, error)
-pkg hash/maphash, method (*Hash) WriteByte(uint8) error
-pkg hash/maphash, method (*Hash) WriteString(string) (int, error)
-pkg hash/maphash, type Hash struct
-pkg hash/maphash, type Seed struct
-pkg log, const Lmsgprefix = 64
-pkg log, const Lmsgprefix ideal-int
-pkg math, func FMA(float64, float64, float64) float64
-pkg math/bits, func Rem(uint, uint, uint) uint
-pkg math/bits, func Rem32(uint32, uint32, uint32) uint32
-pkg math/bits, func Rem64(uint64, uint64, uint64) uint64
-pkg mime/multipart, method (*Reader) NextRawPart() (*Part, error)
-pkg net/http, method (Header) Values(string) []string
-pkg net/http, type Transport struct, DialTLSContext func(context.Context, string, string) (net.Conn, error)
-pkg net/http/httptest, type Server struct, EnableHTTP2 bool
-pkg net/textproto, method (MIMEHeader) Values(string) []string
-pkg strconv, method (*NumError) Unwrap() error
-pkg syscall (windows-386), const CTRL_CLOSE_EVENT = 2
-pkg syscall (windows-386), const CTRL_CLOSE_EVENT ideal-int
-pkg syscall (windows-386), const CTRL_LOGOFF_EVENT = 5
-pkg syscall (windows-386), const CTRL_LOGOFF_EVENT ideal-int
-pkg syscall (windows-386), const CTRL_SHUTDOWN_EVENT = 6
-pkg syscall (windows-386), const CTRL_SHUTDOWN_EVENT ideal-int
-pkg syscall (windows-amd64), const CTRL_CLOSE_EVENT = 2
-pkg syscall (windows-amd64), const CTRL_CLOSE_EVENT ideal-int
-pkg syscall (windows-amd64), const CTRL_LOGOFF_EVENT = 5
-pkg syscall (windows-amd64), const CTRL_LOGOFF_EVENT ideal-int
-pkg syscall (windows-amd64), const CTRL_SHUTDOWN_EVENT = 6
-pkg syscall (windows-amd64), const CTRL_SHUTDOWN_EVENT ideal-int
-pkg testing, method (*B) Cleanup(func())
-pkg testing, method (*T) Cleanup(func())
-pkg testing, type TB interface, Cleanup(func())
-pkg unicode, const Version = "12.0.0"
-pkg unicode, var Elymaic *RangeTable
-pkg unicode, var Nandinagari *RangeTable
-pkg unicode, var Nyiakeng_Puachue_Hmong *RangeTable
-pkg unicode, var Wancho *RangeTable

api/go1.15.txt

@@ -1,130 +0,0 @@
-pkg bufio, var ErrBadReadCount error
-pkg crypto, method (Hash) String() string
-pkg crypto/ecdsa, func SignASN1(io.Reader, *PrivateKey, []uint8) ([]uint8, error)
-pkg crypto/ecdsa, func VerifyASN1(*PublicKey, []uint8, []uint8) bool
-pkg crypto/ecdsa, method (*PrivateKey) Equal(crypto.PrivateKey) bool
-pkg crypto/ecdsa, method (*PublicKey) Equal(crypto.PublicKey) bool
-pkg crypto/ed25519, method (PrivateKey) Equal(crypto.PrivateKey) bool
-pkg crypto/ed25519, method (PublicKey) Equal(crypto.PublicKey) bool
-pkg crypto/elliptic, func MarshalCompressed(Curve, *big.Int, *big.Int) []uint8
-pkg crypto/elliptic, func UnmarshalCompressed(Curve, []uint8) (*big.Int, *big.Int)
-pkg crypto/rsa, method (*PrivateKey) Equal(crypto.PrivateKey) bool
-pkg crypto/rsa, method (*PublicKey) Equal(crypto.PublicKey) bool
-pkg crypto/tls, method (*Dialer) Dial(string, string) (net.Conn, error)
-pkg crypto/tls, method (*Dialer) DialContext(context.Context, string, string) (net.Conn, error)
-pkg crypto/tls, method (ClientAuthType) String() string
-pkg crypto/tls, method (CurveID) String() string
-pkg crypto/tls, method (SignatureScheme) String() string
-pkg crypto/tls, type Config struct, VerifyConnection func(ConnectionState) error
-pkg crypto/tls, type Dialer struct
-pkg crypto/tls, type Dialer struct, Config *Config
-pkg crypto/tls, type Dialer struct, NetDialer *net.Dialer
-pkg crypto/x509, func CreateRevocationList(io.Reader, *RevocationList, *Certificate, crypto.Signer) ([]uint8, error)
-pkg crypto/x509, type RevocationList struct
-pkg crypto/x509, type RevocationList struct, ExtraExtensions []pkix.Extension
-pkg crypto/x509, type RevocationList struct, NextUpdate time.Time
-pkg crypto/x509, type RevocationList struct, Number *big.Int
-pkg crypto/x509, type RevocationList struct, RevokedCertificates []pkix.RevokedCertificate
-pkg crypto/x509, type RevocationList struct, SignatureAlgorithm SignatureAlgorithm
-pkg crypto/x509, type RevocationList struct, ThisUpdate time.Time
-pkg database/sql, method (*DB) SetConnMaxIdleTime(time.Duration)
-pkg database/sql, method (*Row) Err() error
-pkg database/sql, type DBStats struct, MaxIdleTimeClosed int64
-pkg database/sql/driver, type Validator interface { IsValid }
-pkg database/sql/driver, type Validator interface, IsValid() bool
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_APPCONTAINER = 4096
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_APPCONTAINER ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 64
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = 128
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_GUARD_CF = 16384
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_GUARD_CF ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA = 32
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NO_BIND = 2048
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NO_BIND ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NO_ISOLATION = 512
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NO_ISOLATION ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NO_SEH = 1024
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NO_SEH ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NX_COMPAT = 256
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_NX_COMPAT ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = 32768
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE ideal-int
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = 8192
-pkg debug/pe, const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER ideal-int
-pkg debug/pe, const IMAGE_FILE_32BIT_MACHINE = 256
-pkg debug/pe, const IMAGE_FILE_32BIT_MACHINE ideal-int
-pkg debug/pe, const IMAGE_FILE_AGGRESIVE_WS_TRIM = 16
-pkg debug/pe, const IMAGE_FILE_AGGRESIVE_WS_TRIM ideal-int
-pkg debug/pe, const IMAGE_FILE_BYTES_REVERSED_HI = 32768
-pkg debug/pe, const IMAGE_FILE_BYTES_REVERSED_HI ideal-int
-pkg debug/pe, const IMAGE_FILE_BYTES_REVERSED_LO = 128
-pkg debug/pe, const IMAGE_FILE_BYTES_REVERSED_LO ideal-int
-pkg debug/pe, const IMAGE_FILE_DEBUG_STRIPPED = 512
-pkg debug/pe, const IMAGE_FILE_DEBUG_STRIPPED ideal-int
-pkg debug/pe, const IMAGE_FILE_DLL = 8192
-pkg debug/pe, const IMAGE_FILE_DLL ideal-int
-pkg debug/pe, const IMAGE_FILE_EXECUTABLE_IMAGE = 2
-pkg debug/pe, const IMAGE_FILE_EXECUTABLE_IMAGE ideal-int
-pkg debug/pe, const IMAGE_FILE_LARGE_ADDRESS_AWARE = 32
-pkg debug/pe, const IMAGE_FILE_LARGE_ADDRESS_AWARE ideal-int
-pkg debug/pe, const IMAGE_FILE_LINE_NUMS_STRIPPED = 4
-pkg debug/pe, const IMAGE_FILE_LINE_NUMS_STRIPPED ideal-int
-pkg debug/pe, const IMAGE_FILE_LOCAL_SYMS_STRIPPED = 8
-pkg debug/pe, const IMAGE_FILE_LOCAL_SYMS_STRIPPED ideal-int
-pkg debug/pe, const IMAGE_FILE_NET_RUN_FROM_SWAP = 2048
-pkg debug/pe, const IMAGE_FILE_NET_RUN_FROM_SWAP ideal-int
-pkg debug/pe, const IMAGE_FILE_RELOCS_STRIPPED = 1
-pkg debug/pe, const IMAGE_FILE_RELOCS_STRIPPED ideal-int
-pkg debug/pe, const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP = 1024
-pkg debug/pe, const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP ideal-int
-pkg debug/pe, const IMAGE_FILE_SYSTEM = 4096
-pkg debug/pe, const IMAGE_FILE_SYSTEM ideal-int
-pkg debug/pe, const IMAGE_FILE_UP_SYSTEM_ONLY = 16384
-pkg debug/pe, const IMAGE_FILE_UP_SYSTEM_ONLY ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_APPLICATION = 10
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_APPLICATION ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER = 11
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_ROM = 13
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_ROM ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER = 12
-pkg debug/pe, const IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_NATIVE = 1
-pkg debug/pe, const IMAGE_SUBSYSTEM_NATIVE ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_NATIVE_WINDOWS = 8
-pkg debug/pe, const IMAGE_SUBSYSTEM_NATIVE_WINDOWS ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_OS2_CUI = 5
-pkg debug/pe, const IMAGE_SUBSYSTEM_OS2_CUI ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_POSIX_CUI = 7
-pkg debug/pe, const IMAGE_SUBSYSTEM_POSIX_CUI ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_UNKNOWN = 0
-pkg debug/pe, const IMAGE_SUBSYSTEM_UNKNOWN ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION = 16
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_CE_GUI = 9
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_CE_GUI ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_CUI = 3
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_CUI ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_GUI = 2
-pkg debug/pe, const IMAGE_SUBSYSTEM_WINDOWS_GUI ideal-int
-pkg debug/pe, const IMAGE_SUBSYSTEM_XBOX = 14
-pkg debug/pe, const IMAGE_SUBSYSTEM_XBOX ideal-int
-pkg math/big, method (*Int) FillBytes([]uint8) []uint8
-pkg net, method (*Resolver) LookupIP(context.Context, string, string) ([]IP, error)
-pkg net/url, method (*URL) EscapedFragment() string
-pkg net/url, method (*URL) Redacted() string
-pkg net/url, type URL struct, RawFragment string
-pkg os, method (*File) ReadFrom(io.Reader) (int64, error)
-pkg os, var ErrDeadlineExceeded error
-pkg regexp, method (*Regexp) SubexpIndex(string) int
-pkg strconv, func FormatComplex(complex128, uint8, int, int) string
-pkg strconv, func ParseComplex(string, int) (complex128, error)
-pkg sync, method (*Map) LoadAndDelete(interface{}) (interface{}, bool)
-pkg testing, method (*B) TempDir() string
-pkg testing, method (*T) Deadline() (time.Time, bool)
-pkg testing, method (*T) TempDir() string
-pkg testing, type TB interface, TempDir() string
-pkg time, method (*Ticker) Reset(Duration)

api/next.txt

@@ -1,19 +0,0 @@
-pkg unicode, const Version = "13.0.0"
-pkg unicode, var Chorasmian *RangeTable
-pkg unicode, var Dives_Akuru *RangeTable
-pkg unicode, var Khitan_Small_Script *RangeTable
-pkg unicode, var Yezidi *RangeTable
-pkg text/template/parse, const NodeComment = 20
-pkg text/template/parse, const NodeComment NodeType
-pkg text/template/parse, const ParseComments = 1
-pkg text/template/parse, const ParseComments Mode
-pkg text/template/parse, method (*CommentNode) Copy() Node
-pkg text/template/parse, method (*CommentNode) String() string
-pkg text/template/parse, method (CommentNode) Position() Pos
-pkg text/template/parse, method (CommentNode) Type() NodeType
-pkg text/template/parse, type CommentNode struct
-pkg text/template/parse, type CommentNode struct, Text string
-pkg text/template/parse, type CommentNode struct, embedded NodeType
-pkg text/template/parse, type CommentNode struct, embedded Pos
-pkg text/template/parse, type Mode uint
-pkg text/template/parse, type Tree struct, Mode Mode

doc/articles/go_command.html

@@ -74,7 +74,7 @@ important, the use of the tool itself.</p>
 <p>The <code>go</code> command requires that code adheres to a few key,
 well-established conventions.</p>
 
-<p>First, the import path is derived in a known way from the URL of the
+<p>First, the import path is derived in an known way from the URL of the
 source code.  For Bitbucket, GitHub, Google Code, and Launchpad, the
 root directory of the repository is identified by the repository's
 main URL, without the <code>http://</code> prefix.  Subdirectories are named by

doc/articles/race_detector.html

@@ -133,11 +133,6 @@ cost of increased memory usage.
 <code>halt_on_error</code> (default <code>0</code>): Controls whether the program
 exits after reporting first data race.
 </li>
-
-<li>
-<code>atexit_sleep_ms</code> (default <code>1000</code>): Amount of milliseconds
-to sleep in the main goroutine before exiting.
-</li>
 </ul>
 
 <p>
@@ -379,46 +374,11 @@ func (w *Watchdog) Start() {
 }
 </pre>
 
-<h3 id="Unsynchronized_send_and_close_operations">Unsynchronized send and close operations</h3>
-
-<p>
-As this example demonstrates, unsynchronized send and close operations
-on the same channel can also be a race condition:
-</p>
-
-<pre>
-c := make(chan struct{}) // or buffered channel
-
-// The race detector cannot derive the happens before relation
-// for the following send and close operations. These two operations
-// are unsynchronized and happen concurrently.
-go func() { c <- struct{}{} }()
-close(c)
-</pre>
-
-<p>
-According to the Go memory model, a send on a channel happens before
-the corresponding receive from that channel completes. To synchronize
-send and close operations, use a receive operation that guarantees
-the send is done before the close:
-</p>
-
-<pre>
-c := make(chan struct{}) // or buffered channel
-
-go func() { c <- struct{}{} }()
-<-c
-close(c)
-</pre>
-
 <h2 id="Supported_Systems">Supported Systems</h2>
 
 <p>
-  The race detector runs on
-  <code>linux/amd64</code>, <code>linux/ppc64le</code>,
-  <code>linux/arm64</code>, <code>freebsd/amd64</code>,
-  <code>netbsd/amd64</code>, <code>darwin/amd64</code>,
-  and <code>windows/amd64</code>.
+The race detector runs on <code>darwin/amd64</code>, <code>freebsd/amd64</code>,
+<code>linux/amd64</code>, and <code>windows/amd64</code>.
 </p>
 
 <h2 id="Runtime_Overheads">Runtime Overhead</h2>
@@ -427,14 +387,3 @@ close(c)
 The cost of race detection varies by program, but for a typical program, memory
 usage may increase by 5-10x and execution time by 2-20x.
 </p>
-
-<p>
-The race detector currently allocates an extra 8 bytes per <code>defer</code>
-and <code>recover</code> statement. Those extra allocations <a
-href="https://golang.org/issue/26813">are not recovered until the goroutine
-exits</a>. This means that if you have a long-running goroutine that is
-periodically issuing <code>defer</code> and <code>recover</code> calls,
-the program memory usage may grow without bound. These memory allocations
-will not show up in the output of <code>runtime.ReadMemStats</code> or
-<code>runtime/pprof</code>.
-</p>

doc/articles/wiki/final-noclosure.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (
@@ -92,7 +90,7 @@ func getTitle(w http.ResponseWriter, r *http.Request) (string, error) {
 	m := validPath.FindStringSubmatch(r.URL.Path)
 	if m == nil {
 		http.NotFound(w, r)
-		return "", errors.New("invalid Page Title")
+		return "", errors.New("Invalid Page Title")
 	}
 	return m[2], nil // The title is the second subexpression.
 }

doc/articles/wiki/final-noerror.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/final-parsetemplate.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/final-template.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/final-test.patch

@@ -0,0 +1,27 @@
+--- 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
+ }

doc/articles/wiki/final.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/final_test.go

@@ -1,24 +0,0 @@
-// Copyright 2019 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.
-
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-)
-
-func serve() error {
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println(l.Addr().String())
-	s := &http.Server{}
-	return s.Serve(l)
-}

doc/articles/wiki/get.go

@@ -0,0 +1,63 @@
+// Copyright 2011 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
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+)
+
+var (
+	post = flag.String("post", "", "urlencoded form data to POST")
+	addr = flag.Bool("addr", false, "find open address and print to stdout")
+	wait = flag.Duration("wait_for_port", 0, "if non-zero, the amount of time to wait for the address to become available")
+)
+
+func main() {
+	flag.Parse()
+	if *addr {
+		l, err := net.Listen("tcp", "127.0.0.1:0")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer l.Close()
+		fmt.Print(l.Addr())
+		return
+	}
+	url := flag.Arg(0)
+	if url == "" {
+		log.Fatal("no url supplied")
+	}
+	var r *http.Response
+	var err error
+	loopUntil := time.Now().Add(*wait)
+	for {
+		if *post != "" {
+			b := strings.NewReader(*post)
+			r, err = http.Post(url, "application/x-www-form-urlencoded", b)
+		} else {
+			r, err = http.Get(url)
+		}
+		if err == nil || *wait == 0 || time.Now().After(loopUntil) {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer r.Body.Close()
+	_, err = io.Copy(os.Stdout, r.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

doc/articles/wiki/go.mod

@@ -1,3 +0,0 @@
-module doc/articles/wiki
-
-go 1.14

doc/articles/wiki/http-sample.go

@@ -1,5 +1,3 @@
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/index.html

@@ -257,7 +257,6 @@ To use the <code>net/http</code> package, it must be imported:
 import (
 	"fmt"
 	"io/ioutil"
-	"log"
 	<b>"net/http"</b>
 )
 </pre>
@@ -582,7 +581,7 @@ this, we can write a function to validate the title with a regular expression.
 
 <p>
 First, add <code>"regexp"</code> to the <code>import</code> list.
-Then we can create a global variable to store our validation
+Then we can create a global variable to store our validation 
 expression:
 </p>
 
@@ -675,7 +674,7 @@ The closure returned by <code>makeHandler</code> is a function that takes
 an <code>http.ResponseWriter</code> and <code>http.Request</code> (in other
 words, an <code>http.HandlerFunc</code>).
 The closure extracts the <code>title</code> from the request path, and
-validates it with the <code>validPath</code> regexp. If the
+validates it with the <code>TitleValidator</code> regexp. If the
 <code>title</code> is invalid, an error will be written to the
 <code>ResponseWriter</code> using the <code>http.NotFound</code> function.
 If the <code>title</code> is valid, the enclosed handler function

doc/articles/wiki/notemplate.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/part1-noerror.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/part1.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/part2.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/part3-errorhandling.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/part3.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 package main
 
 import (

doc/articles/wiki/test.bash

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# Copyright 2010 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.
+
+set -e
+
+if ! which patch > /dev/null; then
+	echo "Skipping test; patch command not found."
+	exit 0
+fi
+
+wiki_pid=
+cleanup() {
+	kill $wiki_pid
+	rm -f test_*.out Test.txt final-test.go final-test.bin final-test-port.txt a.out get.bin
+}
+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
+	for fn in *.go; do
+		go build -o a.out $fn
+	done
+fi
+
+go build -o get.bin get.go
+cp final.go final-test.go
+patch final-test.go final-test.patch > /dev/null
+go build -o final-test.bin final-test.go
+./final-test.bin &
+wiki_pid=$!
+
+l=0
+while [ ! -f ./final-test-port.txt ]
+do
+	l=$(($l+1))
+	if [ "$l" -gt 5 ]
+	then
+		echo "port not available within 5 seconds"
+		exit 1
+		break
+	fi
+	sleep 1
+done
+
+addr=$(cat final-test-port.txt)
+./get.bin http://$addr/edit/Test > test_edit.out
+diff -u test_edit.out test_edit.good
+./get.bin -post=body=some%20content http://$addr/save/Test > test_save.out
+diff -u test_save.out test_view.good # should be the same as viewing
+diff -u Test.txt test_Test.txt.good
+./get.bin http://$addr/view/Test > test_view.out
+diff -u test_view.out test_view.good
+
+echo PASS

doc/articles/wiki/wiki_test.go

@@ -1,165 +0,0 @@
-// Copyright 2019 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_test
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestSnippetsCompile(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping slow builds in short mode")
-	}
-
-	goFiles, err := filepath.Glob("*.go")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, f := range goFiles {
-		if strings.HasSuffix(f, "_test.go") {
-			continue
-		}
-		f := f
-		t.Run(f, func(t *testing.T) {
-			t.Parallel()
-
-			cmd := exec.Command("go", "build", "-o", os.DevNull, f)
-			out, err := cmd.CombinedOutput()
-			if err != nil {
-				t.Errorf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-			}
-		})
-	}
-}
-
-func TestWikiServer(t *testing.T) {
-	must := func(err error) {
-		if err != nil {
-			t.Helper()
-			t.Fatal(err)
-		}
-	}
-
-	dir, err := ioutil.TempDir("", t.Name())
-	must(err)
-	defer os.RemoveAll(dir)
-
-	// We're testing a walkthrough example of how to write a server.
-	//
-	// That server hard-codes a port number to make the walkthrough simpler, but
-	// we can't assume that the hard-coded port is available on an arbitrary
-	// builder. So we'll patch out the hard-coded port, and replace it with a
-	// function that writes the server's address to stdout
-	// so that we can read it and know where to send the test requests.
-
-	finalGo, err := ioutil.ReadFile("final.go")
-	must(err)
-	const patchOld = `log.Fatal(http.ListenAndServe(":8080", nil))`
-	patched := bytes.ReplaceAll(finalGo, []byte(patchOld), []byte(`log.Fatal(serve())`))
-	if bytes.Equal(patched, finalGo) {
-		t.Fatalf("Can't patch final.go: %q not found.", patchOld)
-	}
-	must(ioutil.WriteFile(filepath.Join(dir, "final_patched.go"), patched, 0644))
-
-	// Build the server binary from the patched sources.
-	// The 'go' command requires that they all be in the same directory.
-	// final_test.go provides the implemtation for our serve function.
-	must(copyFile(filepath.Join(dir, "final_srv.go"), "final_test.go"))
-	cmd := exec.Command("go", "build",
-		"-o", filepath.Join(dir, "final.exe"),
-		filepath.Join(dir, "final_patched.go"),
-		filepath.Join(dir, "final_srv.go"))
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-	}
-
-	// Run the server in our temporary directory so that it can
-	// write its content there. It also needs a couple of template files,
-	// and looks for them in the same directory.
-	must(copyFile(filepath.Join(dir, "edit.html"), "edit.html"))
-	must(copyFile(filepath.Join(dir, "view.html"), "view.html"))
-	cmd = exec.Command(filepath.Join(dir, "final.exe"))
-	cmd.Dir = dir
-	stderr := bytes.NewBuffer(nil)
-	cmd.Stderr = stderr
-	stdout, err := cmd.StdoutPipe()
-	must(err)
-	must(cmd.Start())
-
-	defer func() {
-		cmd.Process.Kill()
-		err := cmd.Wait()
-		if stderr.Len() > 0 {
-			t.Logf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, stderr)
-		}
-	}()
-
-	var addr string
-	if _, err := fmt.Fscanln(stdout, &addr); err != nil || addr == "" {
-		t.Fatalf("Failed to read server address: %v", err)
-	}
-
-	// The server is up and has told us its address.
-	// Make sure that its HTTP API works as described in the article.
-
-	r, err := http.Get(fmt.Sprintf("http://%s/edit/Test", addr))
-	must(err)
-	responseMustMatchFile(t, r, "test_edit.good")
-
-	r, err = http.Post(fmt.Sprintf("http://%s/save/Test", addr),
-		"application/x-www-form-urlencoded",
-		strings.NewReader("body=some%20content"))
-	must(err)
-	responseMustMatchFile(t, r, "test_view.good")
-
-	gotTxt, err := ioutil.ReadFile(filepath.Join(dir, "Test.txt"))
-	must(err)
-	wantTxt, err := ioutil.ReadFile("test_Test.txt.good")
-	must(err)
-	if !bytes.Equal(wantTxt, gotTxt) {
-		t.Fatalf("Test.txt differs from expected after posting to /save.\ngot:\n%s\nwant:\n%s", gotTxt, wantTxt)
-	}
-
-	r, err = http.Get(fmt.Sprintf("http://%s/view/Test", addr))
-	must(err)
-	responseMustMatchFile(t, r, "test_view.good")
-}
-
-func responseMustMatchFile(t *testing.T, r *http.Response, filename string) {
-	t.Helper()
-
-	defer r.Body.Close()
-	body, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	wantBody, err := ioutil.ReadFile(filename)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(body, wantBody) {
-		t.Fatalf("%v: body does not match %s.\ngot:\n%s\nwant:\n%s", r.Request.URL, filename, body, wantBody)
-	}
-}
-
-func copyFile(dst, src string) error {
-	buf, err := ioutil.ReadFile(src)
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(dst, buf, 0644)
-}

doc/asm.html

@@ -57,66 +57,59 @@ func main() {
 	println(3)
 }
 $ GOOS=linux GOARCH=amd64 go tool compile -S x.go        # or: go build -gcflags -S x.go
-"".main STEXT size=74 args=0x0 locals=0x10
-	0x0000 00000 (x.go:3)	TEXT	"".main(SB), $16-0
-	0x0000 00000 (x.go:3)	MOVQ	(TLS), CX
-	0x0009 00009 (x.go:3)	CMPQ	SP, 16(CX)
-	0x000d 00013 (x.go:3)	JLS	67
-	0x000f 00015 (x.go:3)	SUBQ	$16, SP
-	0x0013 00019 (x.go:3)	MOVQ	BP, 8(SP)
-	0x0018 00024 (x.go:3)	LEAQ	8(SP), BP
-	0x001d 00029 (x.go:3)	FUNCDATA	$0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
-	0x001d 00029 (x.go:3)	FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
-	0x001d 00029 (x.go:3)	FUNCDATA	$2, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
-	0x001d 00029 (x.go:4)	PCDATA	$0, $0
-	0x001d 00029 (x.go:4)	PCDATA	$1, $0
-	0x001d 00029 (x.go:4)	CALL	runtime.printlock(SB)
-	0x0022 00034 (x.go:4)	MOVQ	$3, (SP)
-	0x002a 00042 (x.go:4)	CALL	runtime.printint(SB)
-	0x002f 00047 (x.go:4)	CALL	runtime.printnl(SB)
-	0x0034 00052 (x.go:4)	CALL	runtime.printunlock(SB)
-	0x0039 00057 (x.go:5)	MOVQ	8(SP), BP
-	0x003e 00062 (x.go:5)	ADDQ	$16, SP
-	0x0042 00066 (x.go:5)	RET
-	0x0043 00067 (x.go:5)	NOP
-	0x0043 00067 (x.go:3)	PCDATA	$1, $-1
-	0x0043 00067 (x.go:3)	PCDATA	$0, $-1
-	0x0043 00067 (x.go:3)	CALL	runtime.morestack_noctxt(SB)
-	0x0048 00072 (x.go:3)	JMP	0
+
+--- prog list "main" ---
+0000 (x.go:3) TEXT    main+0(SB),$8-0
+0001 (x.go:3) FUNCDATA $0,gcargs·0+0(SB)
+0002 (x.go:3) FUNCDATA $1,gclocals·0+0(SB)
+0003 (x.go:4) MOVQ    $3,(SP)
+0004 (x.go:4) PCDATA  $0,$8
+0005 (x.go:4) CALL    ,runtime.printint+0(SB)
+0006 (x.go:4) PCDATA  $0,$-1
+0007 (x.go:4) PCDATA  $0,$0
+0008 (x.go:4) CALL    ,runtime.printnl+0(SB)
+0009 (x.go:4) PCDATA  $0,$-1
+0010 (x.go:5) RET     ,
 ...
 </pre>
 
 <p>
 The <code>FUNCDATA</code> and <code>PCDATA</code> directives contain information
 for use by the garbage collector; they are introduced by the compiler.
-</p>
+</p> 
+
+<!-- Commenting out because the feature is gone but it's popular and may come back.
 
 <p>
-To see what gets put in the binary after linking, use <code>go tool objdump</code>:
+To see what gets put in the binary after linking, add the <code>-a</code> flag to the linker:
 </p>
 
 <pre>
-$ go build -o x.exe x.go
-$ go tool objdump -s main.main x.exe
-TEXT main.main(SB) /tmp/x.go
-  x.go:3		0x10501c0		65488b0c2530000000	MOVQ GS:0x30, CX
-  x.go:3		0x10501c9		483b6110		CMPQ 0x10(CX), SP
-  x.go:3		0x10501cd		7634			JBE 0x1050203
-  x.go:3		0x10501cf		4883ec10		SUBQ $0x10, SP
-  x.go:3		0x10501d3		48896c2408		MOVQ BP, 0x8(SP)
-  x.go:3		0x10501d8		488d6c2408		LEAQ 0x8(SP), BP
-  x.go:4		0x10501dd		e86e45fdff		CALL runtime.printlock(SB)
-  x.go:4		0x10501e2		48c7042403000000	MOVQ $0x3, 0(SP)
-  x.go:4		0x10501ea		e8e14cfdff		CALL runtime.printint(SB)
-  x.go:4		0x10501ef		e8ec47fdff		CALL runtime.printnl(SB)
-  x.go:4		0x10501f4		e8d745fdff		CALL runtime.printunlock(SB)
-  x.go:5		0x10501f9		488b6c2408		MOVQ 0x8(SP), BP
-  x.go:5		0x10501fe		4883c410		ADDQ $0x10, SP
-  x.go:5		0x1050202		c3			RET
-  x.go:3		0x1050203		e83882ffff		CALL runtime.morestack_noctxt(SB)
-  x.go:3		0x1050208		ebb6			JMP main.main(SB)
+$ go tool 6l -a x.6        # or: go build -ldflags -a x.go
+codeblk [0x2000,0x1d059) at offset 0x1000
+002000	main.main            | (3)	TEXT	main.main+0(SB),$8
+002000	65488b0c25a0080000   | (3)	MOVQ	2208(GS),CX
+002009	483b21               | (3)	CMPQ	SP,(CX)
+00200c	7707                 | (3)	JHI	,2015
+00200e	e83da20100           | (3)	CALL	,1c250+runtime.morestack00
+002013	ebeb                 | (3)	JMP	,2000
+002015	4883ec08             | (3)	SUBQ	$8,SP
+002019	                     | (3)	FUNCDATA	$0,main.gcargs·0+0(SB)
+002019	                     | (3)	FUNCDATA	$1,main.gclocals·0+0(SB)
+002019	48c7042403000000     | (4)	MOVQ	$3,(SP)
+002021	                     | (4)	PCDATA	$0,$8
+002021	e8aad20000           | (4)	CALL	,f2d0+runtime.printint
+002026	                     | (4)	PCDATA	$0,$-1
+002026	                     | (4)	PCDATA	$0,$0
+002026	e865d40000           | (4)	CALL	,f490+runtime.printnl
+00202b	                     | (4)	PCDATA	$0,$-1
+00202b	4883c408             | (5)	ADDQ	$8,SP
+00202f	c3                   | (5)	RET	,
+...
 </pre>
 
+-->
+
 <h3 id="constants">Constants</h3>
 
 <p>
@@ -273,7 +266,7 @@ that assembly programming is a fraught endeavor.
 </p>
 
 <p>
-In Go object files and binaries, the full name of a symbol is the
+In Go object files and binaries, the full name of a symbol is the 
 package path followed by a period and the symbol name:
 <code>fmt.Printf</code> or <code>math/rand.Int</code>.
 Because the assembler's parser treats period and slash as punctuation,
@@ -437,31 +430,6 @@ This is a wrapper function and should not count as disabling <code>recover</code
 (For <code>TEXT</code> items.)
 This function is a closure so it uses its incoming context register.
 </li>
-<li>
-<code>LOCAL</code> = 128
-<br>
-This symbol is local to the dynamic shared object.
-</li>
-<li>
-<code>TLSBSS</code> = 256
-<br>
-(For <code>DATA</code> and <code>GLOBL</code> items.)
-Put this data in thread local storage.
-</li>
-<li>
-<code>NOFRAME</code> = 512
-<br>
-(For <code>TEXT</code> items.)
-Do not insert instructions to allocate a stack frame and save/restore the return
-address, even if this is not a leaf function.
-Only valid on functions that declare a frame size of 0.
-</li>
-<li>
-<code>TOPFRAME</code> = 2048
-<br>
-(For <code>TEXT</code> items.)
-Function is the top of the call stack. Traceback should stop at this function.
-</li>
 </ul>
 
 <h3 id="runtime">Runtime Coordination</h3>
@@ -517,7 +485,7 @@ even for assembly functions not called directly from Go.
 At the start of the function, the arguments are assumed
 to be initialized but the results are assumed uninitialized.
 If the results will hold live pointers during a call instruction,
-the function should start by zeroing the results and then
+the function should start by zeroing the results and then 
 executing the pseudo-instruction <code>GO_RESULTS_INITIALIZED</code>.
 This instruction records that the results are now initialized
 and should be scanned during stack movement and garbage collection.
@@ -535,7 +503,7 @@ on the <code>TEXT</code> instruction.
 The pointer information can also be omitted if the
 function contains no call instructions.
 Otherwise, the local stack frame must not contain pointers,
-and the assembly must confirm this fact by executing the
+and the assembly must confirm this fact by executing the 
 pseudo-instruction <code>NO_LOCAL_POINTERS</code>.
 Because stack resizing is implemented by moving the stack,
 the stack pointer may change during any function call:
@@ -615,37 +583,27 @@ Here follow some descriptions of key Go-specific details for the supported archi
 <p>
 The runtime pointer to the <code>g</code> structure is maintained
 through the value of an otherwise unused (as far as Go is concerned) register in the MMU.
-An OS-dependent macro <code>get_tls</code> is defined for the assembler if the source is
-in the <code>runtime</code> package and includes a special header, <code>go_tls.h</code>:
+A OS-dependent macro <code>get_tls</code> is defined for the assembler if the source includes
+a special header, <code>go_asm.h</code>:
 </p>
 
 <pre>
-#include "go_tls.h"
+#include "go_asm.h"
 </pre>
 
 <p>
 Within the runtime, the <code>get_tls</code> macro loads its argument register
 with a pointer to the <code>g</code> pointer, and the <code>g</code> struct
 contains the <code>m</code> pointer.
-There's another special header containing the offsets for each
-element of <code>g</code>, called <code>go_asm.h</code>.
 The sequence to load <code>g</code> and <code>m</code> using <code>CX</code> looks like this:
 </p>
 
 <pre>
-#include "go_tls.h"
-#include "go_asm.h"
-...
 get_tls(CX)
 MOVL	g(CX), AX     // Move g into AX.
 MOVL	g_m(AX), BX   // Move g.m into BX.
 </pre>
 
-<p>
-Note: The code above works only in the <code>runtime</code> package, while <code>go_tls.h</code> also
-applies to <a href="#arm">arm</a>, <a href="#amd64">amd64</a> and amd64p32, and <code>go_asm.h</code> applies to all architectures.
-</p>
-
 <p>
 Addressing modes:
 </p>
@@ -687,13 +645,6 @@ MOVQ	g(CX), AX     // Move g into AX.
 MOVQ	g_m(AX), BX   // Move g.m into BX.
 </pre>
 
-<p>
-Register <code>BP</code> is callee-save.
-The assembler automatically inserts <code>BP</code> save/restore when frame size is larger than zero.
-Using <code>BP</code> as a general purpose register is allowed,
-however it can interfere with sampling-based profiling.
-</p>
-
 <h3 id="arm">ARM</h3>
 
 <p>
@@ -789,7 +740,6 @@ The ARM64 port is in an experimental state.
 
 <p>
 <code>R18</code> is the "platform register", reserved on the Apple platform.
-To prevent accidental misuse, the register is named <code>R18_PLATFORM</code>.
 <code>R27</code> and <code>R28</code> are reserved by the compiler and linker.
 <code>R29</code> is the frame pointer.
 <code>R30</code> is the link register.
@@ -864,16 +814,27 @@ The other extensions include <code>SXTH</code> (16-bit), <code>SXTW</code> (32-b
 Reference: <a href="/pkg/cmd/internal/obj/arm64">Go ARM64 Assembly Instructions Reference Manual</a>
 </p>
 
-<h3 id="ppc64">PPC64</h3>
+<h3 id="ppc64">64-bit PowerPC, a.k.a. ppc64</h3>
 
 <p>
-This assembler is used by GOARCH values ppc64 and ppc64le.
+The 64-bit PowerPC port is in an experimental state.
 </p>
 
 <p>
-Reference: <a href="/pkg/cmd/internal/obj/ppc64">Go PPC64 Assembly Instructions Reference Manual</a>
+Addressing modes:
 </p>
 
+<ul>
+
+<li>
+<code>(R5)(R6*1)</code>: The location at <code>R5</code> plus <code>R6</code>. It is a scaled
+mode as on the x86, but the only scale allowed is <code>1</code>.
+</li>
+
+<li>
+<code>(R5+R6)</code>: Alias for (R5)(R6*1)
+</li>
+
 </ul>
 
 <h3 id="s390x">IBM z/Architecture, a.k.a. s390x</h3>

doc/cmd.html

@@ -18,8 +18,10 @@ underlying binary with arguments appropriate to package-level processing.
 
 <p>
 The programs can also be run as stand-alone binaries, with unmodified arguments,
-using the go <code>tool</code> subcommand, such as <code>go tool cgo</code>.
-For most commands this is mainly useful for debugging.
+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
 the go <code>tool</code> subcommand.
 </p>
@@ -49,6 +51,7 @@ The <code>go</code> program manages Go source code and runs the other
 commands listed here.
 See the command docs for usage
 details.
+<br><br>
 </td>
 </tr>
 
@@ -73,7 +76,7 @@ and rewrites them to use newer ones.</td>
 </tr>
 
 <tr>
-<td><a href="/cmd/gofmt/">fmt</a></td>
+<td><a href="/cmd/go/">fmt</a></td>
 <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
 <td>Fmt formats Go packages, it is also available as an independent <a href="/cmd/gofmt/">
 gofmt</a> command with more general options.</td>

doc/code.html

@@ -0,0 +1,683 @@
+<!--{
+	"Title": "How to Write Go Code"
+}-->
+
+<h2 id="Introduction">Introduction</h2>
+
+<p>
+This document demonstrates the development of a simple Go package and
+introduces the <a href="/cmd/go/">go tool</a>, the standard way to fetch,
+build, and install Go packages and commands.
+</p>
+
+<p>
+The <code>go</code> tool requires you to organize your code in a specific
+way. Please read this document carefully.
+It explains the simplest way to get up and running with your Go installation.
+</p>
+
+<p>
+A similar explanation is available as a
+<a href="//www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>.
+</p>
+
+
+<h2 id="Organization">Code organization</h2>
+
+<h3 id="Overview">Overview</h3>
+
+<ul>
+	<li>Go programmers typically keep all their Go code in a single <i>workspace</i>.</li>
+	<li>A workspace contains many version control <i>repositories</i>
+	    (managed by Git, for example).</li>
+	<li>Each repository contains one or more <i>packages</i>.</li>
+	<li>Each package consists of one or more Go source files in a single directory.</li>
+	<li>The path to a package's directory determines its <i>import path</i>.</li>
+</ul>
+
+<p>
+Note that this differs from other programming environments in which every
+project has a separate workspace and workspaces are closely tied to version
+control repositories.
+</p>
+
+<h3 id="Workspaces">Workspaces</h3>
+
+<p>
+A workspace is a directory hierarchy with three directories at its root:
+</p>
+
+<ul>
+<li><code>src</code> contains Go source files,
+<li><code>pkg</code> contains package objects, and
+<li><code>bin</code> contains executable commands.
+</ul>
+
+<p>
+The <code>go</code> tool builds source packages and installs the resulting
+binaries to the <code>pkg</code> and <code>bin</code> directories.
+</p>
+
+<p>
+The <code>src</code> subdirectory typically contains multiple version control
+repositories (such as for Git or Mercurial) that track the development of one
+or more source packages.
+</p>
+
+<p>
+To give you an idea of how a workspace looks in practice, here's an example:
+</p>
+
+<pre>
+bin/
+    hello                          # command executable
+    outyet                         # command executable
+pkg/
+    linux_amd64/
+        github.com/golang/example/
+            stringutil.a           # package object
+src/
+    <a href="https://github.com/golang/example/">github.com/golang/example/</a>
+        .git/                      # Git repository metadata
+	hello/
+	    hello.go               # command source
+	outyet/
+	    main.go                # command source
+	    main_test.go           # test source
+	stringutil/
+	    reverse.go             # package source
+	    reverse_test.go        # test source
+    <a href="https://golang.org/x/image/">golang.org/x/image/</a>
+        .git/                      # Git repository metadata
+	bmp/
+	    reader.go              # package source
+	    writer.go              # package source
+    ... (many more repositories and packages omitted) ...
+</pre>
+
+<p>
+The tree above shows a workspace containing two repositories
+(<code>example</code> and <code>image</code>).
+The <code>example</code> repository contains two commands (<code>hello</code>
+and <code>outyet</code>) and one library (<code>stringutil</code>).
+The <code>image</code> repository contains the <code>bmp</code> package
+and <a href="https://godoc.org/golang.org/x/image">several others</a>.
+</p>
+
+<p>
+A typical workspace contains many source repositories containing many
+packages and commands. Most Go programmers keep <i>all</i> their Go source code
+and dependencies in a single workspace.
+</p>
+
+<p>
+Commands and libraries are built from different kinds of source packages.
+We will discuss the distinction <a href="#PackageNames">later</a>.
+</p>
+
+
+<h3 id="GOPATH">The <code>GOPATH</code> environment variable</h3>
+
+<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.
+</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
+same path as your Go installation.
+</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>
+
+<p>
+For convenience, add the workspace's <code>bin</code> subdirectory
+to your <code>PATH</code>:
+</p>
+
+<pre>
+$ <b>export PATH=$PATH:$(go env 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>.
+</p>
+
+<h3 id="ImportPaths">Import paths</h3>
+
+<p>
+An <i>import path</i> is a string that uniquely identifies a package.
+A package's import path corresponds to its location inside a workspace
+or in a remote repository (explained below).
+</p>
+
+<p>
+The packages from the standard library are given short import paths such as
+<code>"fmt"</code> and <code>"net/http"</code>.
+For your own packages, you must choose a base path that is unlikely to
+collide with future additions to the standard library or other external
+libraries.
+</p>
+
+<p>
+If you keep your code in a source repository somewhere, then you should use the
+root of that source repository as your base path.
+For instance, if you have a <a href="https://github.com/">GitHub</a> account at
+<code>github.com/user</code>, that should be your base path.
+</p>
+
+<p>
+Note that you don't need to publish your code to a remote repository before you
+can build it. It's just a good habit to organize your code as if you will
+publish it someday. In practice you can choose any arbitrary path name,
+as long as it is unique to the standard library and greater Go ecosystem.
+</p>
+
+<p>
+We'll use <code>github.com/user</code> as our base path. Create a directory
+inside your workspace in which to keep source code:
+</p>
+
+<pre>
+$ <b>mkdir -p $GOPATH/src/github.com/user</b>
+</pre>
+
+
+<h3 id="Command">Your first program</h3>
+
+<p>
+To compile and run a simple program, first choose a package path (we'll use
+<code>github.com/user/hello</code>) and create a corresponding package directory
+inside your workspace:
+</p>
+
+<pre>
+$ <b>mkdir $GOPATH/src/github.com/user/hello</b>
+</pre>
+
+<p>
+Next, create a file named <code>hello.go</code> inside that directory,
+containing the following Go code.
+</p>
+
+<pre>
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Printf("Hello, world.\n")
+}
+</pre>
+
+<p>
+Now you can build and install that program with the <code>go</code> tool:
+</p>
+
+<pre>
+$ <b>go install github.com/user/hello</b>
+</pre>
+
+<p>
+Note that you can run this command from anywhere on your system. The
+<code>go</code> tool finds the source code by looking for the
+<code>github.com/user/hello</code> package inside the workspace specified by
+<code>GOPATH</code>.
+</p>
+
+<p>
+You can also omit the package path if you run <code>go install</code> from the
+package directory:
+</p>
+
+<pre>
+$ <b>cd $GOPATH/src/github.com/user/hello</b>
+$ <b>go install</b>
+</pre>
+
+<p>
+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>.
+</p>
+
+<p>
+The <code>go</code> tool will only print output when an error occurs, so if
+these commands produce no output they have executed successfully.
+</p>
+
+<p>
+You can now run the program by typing its full path at the command line:
+</p>
+
+<pre>
+$ <b>$GOPATH/bin/hello</b>
+Hello, world.
+</pre>
+
+<p>
+Or, as you have added <code>$GOPATH/bin</code> to your <code>PATH</code>,
+just type the binary name:
+</p>
+
+<pre>
+$ <b>hello</b>
+Hello, world.
+</pre>
+
+<p>
+If you're using a source control system, now would be a good time to initialize
+a repository, add the files, and commit your first change. Again, this step is
+optional: you do not need to use source control to write Go code.
+</p>
+
+<pre>
+$ <b>cd $GOPATH/src/github.com/user/hello</b>
+$ <b>git init</b>
+Initialized empty Git repository in /home/user/work/src/github.com/user/hello/.git/
+$ <b>git add hello.go</b>
+$ <b>git commit -m "initial commit"</b>
+[master (root-commit) 0b4507d] initial commit
+ 1 file changed, 1 insertion(+)
+  create mode 100644 hello.go
+</pre>
+
+<p>
+Pushing the code to a remote repository is left as an exercise for the reader.
+</p>
+
+
+<h3 id="Library">Your first library</h3>
+
+<p>
+Let's write a library and use it from the <code>hello</code> program.
+</p>
+
+<p>
+Again, the first step is to choose a package path (we'll use
+<code>github.com/user/stringutil</code>) and create the package directory:
+</p>
+
+<pre>
+$ <b>mkdir $GOPATH/src/github.com/user/stringutil</b>
+</pre>
+
+<p>
+Next, create a file named <code>reverse.go</code> in that directory with the
+following contents.
+</p>
+
+<pre>
+// Package stringutil contains utility functions for working with strings.
+package stringutil
+
+// Reverse returns its argument string reversed rune-wise left to right.
+func Reverse(s string) string {
+	r := []rune(s)
+	for i, j := 0, len(r)-1; i &lt; len(r)/2; i, j = i+1, j-1 {
+		r[i], r[j] = r[j], r[i]
+	}
+	return string(r)
+}
+</pre>
+
+<p>
+Now, test that the package compiles with <code>go build</code>:
+</p>
+
+<pre>
+$ <b>go build github.com/user/stringutil</b>
+</pre>
+
+<p>
+Or, if you are working in the package's source directory, just:
+</p>
+
+<pre>
+$ <b>go build</b>
+</pre>
+
+<p>
+This won't produce an output file. To do that, you must use <code>go
+install</code>, which places the package object inside the <code>pkg</code>
+directory of the workspace.
+</p>
+
+<p>
+After confirming that the <code>stringutil</code> package builds,
+modify your original <code>hello.go</code> (which is in
+<code>$GOPATH/src/github.com/user/hello</code>) to use it:
+</p>
+
+<pre>
+package main
+
+import (
+	"fmt"
+
+	<b>"github.com/user/stringutil"</b>
+)
+
+func main() {
+	fmt.Printf(stringutil.Reverse("!oG ,olleH"))
+}
+</pre>
+
+<p>
+Whenever the <code>go</code> tool installs a package or binary, it also
+installs whatever dependencies it has.
+So when you install the <code>hello</code> program
+</p>
+
+<pre>
+$ <b>go install github.com/user/hello</b>
+</pre>
+
+<p>
+the <code>stringutil</code> package will be installed as well, automatically.
+</p>
+
+<p>
+Running the new version of the program, you should see a new, reversed message:
+</p>
+
+<pre>
+$ <b>hello</b>
+Hello, Go!
+</pre>
+
+<p>
+After the steps above, your workspace should look like this:
+</p>
+
+<pre>
+bin/
+    hello                 # command executable
+pkg/
+    linux_amd64/          # this will reflect your OS and architecture
+        github.com/user/
+            stringutil.a  # package object
+src/
+    github.com/user/
+        hello/
+            hello.go      # command source
+        stringutil/
+            reverse.go    # package source
+</pre>
+
+<p>
+Note that <code>go install</code> placed the <code>stringutil.a</code> object
+in a directory inside <code>pkg/linux_amd64</code> that mirrors its source
+directory.
+This is so that future invocations of the <code>go</code> tool can find the
+package object and avoid recompiling the package unnecessarily.
+The <code>linux_amd64</code> part is there to aid in cross-compilation,
+and will reflect the operating system and architecture of your system.
+</p>
+
+<p>
+Go command executables are statically linked; the package objects need not
+be present to run Go programs.
+</p>
+
+
+<h3 id="PackageNames">Package names</h3>
+
+<p>
+The first statement in a Go source file must be
+</p>
+
+<pre>
+package <i>name</i>
+</pre>
+
+<p>
+where <code><i>name</i></code> is the package's default name for imports.
+(All files in a package must use the same <code><i>name</i></code>.)
+</p>
+
+<p>
+Go's convention is that the package name is the last element of the
+import path: the package imported as "<code>crypto/rot13</code>"
+should be named <code>rot13</code>.
+</p>
+
+<p>
+Executable commands must always use <code>package main</code>.
+</p>
+
+<p>
+There is no requirement that package names be unique
+across all packages linked into a single binary,
+only that the import paths (their full file names) be unique.
+</p>
+
+<p>
+See <a href="/doc/effective_go.html#names">Effective Go</a> to learn more about
+Go's naming conventions.
+</p>
+
+
+<h2 id="Testing">Testing</h2>
+
+<p>
+Go has a lightweight test framework composed of the <code>go test</code>
+command and the <code>testing</code> package.
+</p>
+
+<p>
+You write a test by creating a file with a name ending in <code>_test.go</code>
+that contains functions named <code>TestXXX</code> with signature
+<code>func (t *testing.T)</code>.
+The test framework runs each such function;
+if the function calls a failure function such as <code>t.Error</code> or
+<code>t.Fail</code>, the test is considered to have failed.
+</p>
+
+<p>
+Add a test to the <code>stringutil</code> package by creating the file
+<code>$GOPATH/src/github.com/user/stringutil/reverse_test.go</code> containing
+the following Go code.
+</p>
+
+<pre>
+package stringutil
+
+import "testing"
+
+func TestReverse(t *testing.T) {
+	cases := []struct {
+		in, want string
+	}{
+		{"Hello, world", "dlrow ,olleH"},
+		{"Hello, 世界", "界世 ,olleH"},
+		{"", ""},
+	}
+	for _, c := range cases {
+		got := Reverse(c.in)
+		if got != c.want {
+			t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+</pre>
+
+<p>
+Then run the test with <code>go test</code>:
+</p>
+
+<pre>
+$ <b>go test github.com/user/stringutil</b>
+ok  	github.com/user/stringutil 0.165s
+</pre>
+
+<p>
+As always, if you are running the <code>go</code> tool from the package
+directory, you can omit the package path:
+</p>
+
+<pre>
+$ <b>go test</b>
+ok  	github.com/user/stringutil 0.165s
+</pre>
+
+<p>
+Run <code><a href="/cmd/go/#hdr-Test_packages">go help test</a></code> and see the
+<a href="/pkg/testing/">testing package documentation</a> for more detail.
+</p>
+
+
+<h2 id="remote">Remote packages</h2>
+
+<p>
+An import path can describe how to obtain the package source code using a
+revision control system such as Git or Mercurial. The <code>go</code> tool uses
+this property to automatically fetch packages from remote repositories.
+For instance, the examples described in this document are also kept in a
+Git repository hosted at GitHub
+<code><a href="https://github.com/golang/example">github.com/golang/example</a></code>.
+If you include the repository URL in the package's import path,
+<code>go get</code> will fetch, build, and install it automatically:
+</p>
+
+<pre>
+$ <b>go get github.com/golang/example/hello</b>
+$ <b>$GOPATH/bin/hello</b>
+Hello, Go examples!
+</pre>
+
+<p>
+If the specified package is not present in a workspace, <code>go get</code>
+will place it inside the first workspace specified by <code>GOPATH</code>.
+(If the package does already exist, <code>go get</code> skips the remote
+fetch and behaves the same as <code>go install</code>.)
+</p>
+
+<p>
+After issuing the above <code>go get</code> command, the workspace directory
+tree should now look like this:
+</p>
+
+<pre>
+bin/
+    hello                           # command executable
+pkg/
+    linux_amd64/
+        github.com/golang/example/
+            stringutil.a            # package object
+        github.com/user/
+            stringutil.a            # package object
+src/
+    github.com/golang/example/
+	.git/                       # Git repository metadata
+        hello/
+            hello.go                # command source
+        stringutil/
+            reverse.go              # package source
+            reverse_test.go         # test source
+    github.com/user/
+        hello/
+            hello.go                # command source
+        stringutil/
+            reverse.go              # package source
+            reverse_test.go         # test source
+</pre>
+
+<p>
+The <code>hello</code> command hosted at GitHub depends on the
+<code>stringutil</code> package within the same repository. The imports in
+<code>hello.go</code> file use the same import path convention, so the
+<code>go get</code> command is able to locate and install the dependent
+package, too.
+</p>
+
+<pre>
+import "github.com/golang/example/stringutil"
+</pre>
+
+<p>
+This convention is the easiest way to make your Go packages available for
+others to use.
+The <a href="//golang.org/wiki/Projects">Go Wiki</a>
+and <a href="//godoc.org/">godoc.org</a>
+provide lists of external Go projects.
+</p>
+
+<p>
+For more information on using remote repositories with the <code>go</code> tool, see
+<code><a href="/cmd/go/#hdr-Remote_import_paths">go help importpath</a></code>.
+</p>
+
+
+<h2 id="next">What's next</h2>
+
+<p>
+Subscribe to the
+<a href="//groups.google.com/group/golang-announce">golang-announce</a>
+mailing list to be notified when a new stable version of Go is released.
+</p>
+
+<p>
+See <a href="/doc/effective_go.html">Effective Go</a> for tips on writing
+clear, idiomatic Go code.
+</p>
+
+<p>
+Take <a href="//tour.golang.org/">A Tour of Go</a> to learn the language
+proper.
+</p>
+
+<p>
+Visit the <a href="/doc/#articles">documentation page</a> for a set of in-depth
+articles about the Go language and its libraries and tools.
+</p>
+
+
+<h2 id="help">Getting help</h2>
+
+<p>
+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>
+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>

doc/codewalk/codewalk.js

@@ -276,7 +276,7 @@ CodewalkViewer.prototype.changeSelectedComment = function(target) {
   }
 
   // Force original file even if user hasn't changed comments since they may
-  // have navigated away from it within the iframe without us knowing.
+  // have nagivated away from it within the iframe without us knowing.
   this.navigateToCode(currentFile);
 };
 

doc/codewalk/codewalk_test.go

@@ -1,52 +0,0 @@
-// Copyright 2019 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_test
-
-import (
-	"bytes"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-)
-
-// TestMarkov tests the code dependency of markov.xml.
-func TestMarkov(t *testing.T) {
-	cmd := exec.Command("go", "run", "markov.go")
-	cmd.Stdin = strings.NewReader("foo")
-	cmd.Stderr = bytes.NewBuffer(nil)
-	out, err := cmd.Output()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-	}
-
-	if !bytes.Equal(out, []byte("foo\n")) {
-		t.Fatalf(`%s with input "foo" did not output "foo":\n%s`, strings.Join(cmd.Args, " "), out)
-	}
-}
-
-// TestPig tests the code dependency of functions.xml.
-func TestPig(t *testing.T) {
-	cmd := exec.Command("go", "run", "pig.go")
-	cmd.Stderr = bytes.NewBuffer(nil)
-	out, err := cmd.Output()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-	}
-
-	const want = "Wins, losses staying at k = 100: 210/990 (21.2%), 780/990 (78.8%)\n"
-	if !bytes.Contains(out, []byte(want)) {
-		t.Fatalf(`%s: unexpected output\ngot:\n%s\nwant output containing:\n%s`, strings.Join(cmd.Args, " "), out, want)
-	}
-}
-
-// TestURLPoll tests the code dependency of sharemem.xml.
-func TestURLPoll(t *testing.T) {
-	cmd := exec.Command("go", "build", "-o", os.DevNull, "urlpoll.go")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-	}
-}

doc/codewalk/run

@@ -0,0 +1,21 @@
+#!/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.
+
+set -e
+
+function fail {
+	echo FAIL: doc/codewalk/$1
+	exit 1
+}
+
+# markov.xml
+echo foo | go run markov.go | grep foo > /dev/null || fail markov
+
+# functions.xml
+go run pig.go | grep 'Wins, losses staying at k = 100: 210/990 (21.2%), 780/990 (78.8%)' > /dev/null || fail pig
+
+# sharemem.xml: only build the example, as it uses the network
+go build urlpoll.go || fail urlpoll
+rm -f urlpoll

doc/conduct.html

@@ -0,0 +1,211 @@
+<!--{
+	"Title": "Go Community Code of Conduct",
+	"Path":  "/conduct",
+	"Template": true
+}-->
+
+<style>
+ul {
+	max-width: 800px;
+}
+ul ul {
+	margin: 0 0 5px;
+}
+</style>
+
+<h2 id="about">About</h2>
+
+<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 gender identity and expression, sexual orientation,
+disabilities, neurodiversity, physical appearance, body size, ethnicity, nationality,
+race, age, religion, or similar personal characteristics.
+</p>
+
+<p>
+The first goal of the Code of Conduct is to specify a baseline standard
+of behavior so that people with different social values and communication
+styles can talk about Go effectively, productively, and respectfully.
+</p>
+
+<p>
+The second goal is to provide a mechanism for resolving conflicts in the
+community when they arise.
+</p>
+
+<p>
+The third goal of the Code of Conduct is to make our community welcoming to
+people from different backgrounds.
+Diversity is critical to the project; for Go to be successful, it needs
+contributors and users from all backgrounds.
+(See <a href="https://blog.golang.org/open-source">Go, Open Source, Community</a>.)
+</p>
+
+<p>
+We believe that healthy debate and disagreement are essential to a healthy project and community.
+However, it is never ok to be disrespectful.
+We value diverse opinions, but we value respectful behavior more.
+</p>
+
+<h2 id="values">Gopher values</h2>
+
+<p>
+These are the values to which people in the Go community (“Gophers”) should aspire.
+</p>
+
+<ul>
+<li>Be friendly and welcoming
+<li>Be patient
+    <ul>
+    <li>Remember that people have varying communication styles and that not
+        everyone is using their native language.
+        (Meaning and tone can be lost in translation.)
+    </ul>
+<li>Be thoughtful
+    <ul>
+    <li>Productive communication requires effort.
+        Think about how your words will be interpreted.
+    <li>Remember that sometimes it is best to refrain entirely from commenting.
+    </ul>
+<li>Be respectful
+    <ul>
+    <li>In particular, respect differences of opinion.
+    </ul>
+<li>Be charitable
+    <ul>
+    <li>Interpret the arguments of others in good faith, do not seek to disagree.
+    <li>When we do disagree, try to understand why.
+    </ul>
+<li>Avoid destructive behavior:
+    <ul>
+    <li>Derailing: stay on topic; if you want to talk about something else,
+        start a new conversation.
+    <li>Unconstructive criticism: don't merely decry the current state of affairs;
+        offer—or at least solicit—suggestions as to how things may be improved.
+    <li>Snarking (pithy, unproductive, sniping comments)
+    <li>Discussing potentially offensive or sensitive issues;
+        this all too often leads to unnecessary conflict.
+    <li>Microaggressions: brief and commonplace verbal, behavioral and
+        environmental indignities that communicate hostile, derogatory or negative
+        slights and insults to a person or group.
+    </ul>
+</ul>
+
+<p>
+People are complicated.
+You should expect to be misunderstood and to misunderstand others;
+when this inevitably occurs, resist the urge to be defensive or assign blame.
+Try not to take offense where no offense was intended.
+Give people the benefit of the doubt.
+Even if the intent was to provoke, do not rise to it.
+It is the responsibility of <i>all parties</i> to de-escalate conflict when it arises.
+</p>
+
+<h2 id="code">Code of Conduct</h2>
+
+<h3 id="our-pledge">Our Pledge</h3>
+
+<p>In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of
+experience, education, socio-economic status, nationality, personal appearance,
+race, religion, or sexual identity and orientation.</p>
+
+<h3 id="our-standards">Our Standards</h3>
+
+<p>Examples of behavior that contributes to creating a positive environment
+include:</p>
+
+<ul>
+<li>Using welcoming and inclusive language</li>
+<li>Being respectful of differing viewpoints and experiences</li>
+<li>Gracefully accepting constructive criticism</li>
+<li>Focusing on what is best for the community</li>
+<li>Showing empathy towards other community members</li>
+</ul>
+
+<p>Examples of unacceptable behavior by participants include:</p>
+
+<ul>
+<li>The use of sexualized language or imagery and unwelcome sexual attention or
+advances</li>
+<li>Trolling, insulting/derogatory comments, and personal or political attacks</li>
+<li>Public or private harassment</li>
+<li>Publishing others&rsquo; private information, such as a physical or electronic
+address, without explicit permission</li>
+<li>Other conduct which could reasonably be considered inappropriate in a
+professional setting</li>
+</ul>
+
+<h3 id="our-responsibilities">Our Responsibilities</h3>
+
+<p>Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.</p>
+
+<p>Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, or to ban temporarily or permanently any
+contributor for other behaviors that they deem inappropriate, threatening,
+offensive, or harmful.</p>
+
+<h3 id="scope">Scope</h3>
+
+<p>This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.</p>
+
+<p>This Code of Conduct also applies outside the project spaces when the Project
+Steward has a reasonable belief that an individual&rsquo;s behavior may have a
+negative impact on the project or its community.</p>
+
+<h3 id="conflict-resolution"></a>Conflict Resolution</h3>
+
+<p>We do not believe that all conflict is bad; healthy debate and disagreement
+often yield positive results. However, it is never okay to be disrespectful or
+to engage in behavior that violates the project’s code of conduct.</p>
+
+<p>If you see someone violating the code of conduct, you are encouraged to address
+the behavior directly with those involved. Many issues can be resolved quickly
+and easily, and this gives people more control over the outcome of their
+dispute. If you are unable to resolve the matter for any reason, or if the
+behavior is threatening or harassing, report it. We are dedicated to providing
+an environment where participants feel welcome and safe.</p>
+
+<p id="reporting">Reports should be directed to Cassandra Salisbury, the
+Go Project Steward, at <i>conduct@golang.org</i>.
+It is the Project Steward’s duty to
+receive and address reported violations of the code of conduct. They will then
+work with a committee consisting of representatives from the Open Source
+Programs Office and the Google Open Source Strategy team. If for any reason you
+are uncomfortable reaching out the Project Steward, please email
+the Google Open Source Programs Office at <i>opensource@google.com</i>.</p>
+
+<p>We will investigate every complaint, but you may not receive a direct response.
+We will use our discretion in determining when and how to follow up on reported
+incidents, which may range from not taking action to permanent expulsion from
+the project and project-sponsored spaces. We will notify the accused of the
+report and provide them an opportunity to discuss it before any action is taken.
+The identity of the reporter will be omitted from the details of the report
+supplied to the accused. In potentially harmful situations, such as ongoing
+harassment or threats to anyone&rsquo;s safety, we may take action without notice.</p>
+
+<h3 id="attribution">Attribution</h3>
+
+<p>This Code of Conduct is adapted from the Contributor Covenant, version 1.4,
+available at
+<a href="https://www.contributor-covenant.org/version/1/4/code-of-conduct.html">https://www.contributor-covenant.org/version/1/4/code-of-conduct.html</a></p>
+
+<h2 id="summary">Summary</h2>
+
+<ul>
+<li>Treat everyone with respect and kindness.
+<li>Be thoughtful in how you communicate.
+<li>Don’t be destructive or inflammatory.
+<li>If you encounter an issue, please mail <a href="mailto:conduct@golang.org">conduct@golang.org</a>.
+</ul>

doc/contrib.html

@@ -0,0 +1,123 @@
+<!--{
+	"Title": "The Go Project",
+	"Path": "/project/"
+}-->
+
+<img class="gopher" src="/doc/gopher/project.png" />
+
+<div id="manual-nav"></div>
+
+<p>
+Go is an open source project developed by a team at
+<a href="//google.com/">Google</a> and many
+<a href="/CONTRIBUTORS">contributors</a> from the open source community.
+</p>
+
+<p>
+Go is distributed under a <a href="/LICENSE">BSD-style license</a>.
+</p>
+
+<h3 id="announce"><a href="//groups.google.com/group/golang-announce">Announcements Mailing List</a></h3>
+<p>
+A low traffic mailing list for important announcements, such as new releases.
+</p>
+<p>
+We encourage all Go users to subscribe to
+<a href="//groups.google.com/group/golang-announce">golang-announce</a>.
+</p>
+
+
+<h2 id="go1">Version history</h2>
+
+<h3 id="release"><a href="/doc/devel/release.html">Release History</a></h3>
+
+<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>
+	<li><a href="/doc/go1.4">Go 1.4</a> <small>(December 2014)</small></li>
+	<li><a href="/doc/go1.3">Go 1.3</a> <small>(June 2014)</small></li>
+	<li><a href="/doc/go1.2">Go 1.2</a> <small>(December 2013)</small></li>
+	<li><a href="/doc/go1.1">Go 1.1</a> <small>(May 2013)</small></li>
+	<li><a href="/doc/go1">Go 1</a> <small>(March 2012)</small></li>
+</ul>
+
+<h3 id="go1compat"><a href="/doc/go1compat">Go 1 and the Future of Go Programs</a></h3>
+<p>
+What Go 1 defines and the backwards-compatibility guarantees one can expect as
+Go 1 matures.
+</p>
+
+
+<h2 id="resources">Developer Resources</h2>
+
+<h3 id="source"><a href="https://golang.org/change">Source Code</a></h3>
+<p>Check out the Go source code.</p>
+
+<h3 id="golang-dev"><a href="https://groups.google.com/group/golang-dev">Developer</a> and
+<a href="https://groups.google.com/group/golang-codereviews">Code Review Mailing List</a></h3>
+<p>The <a href="https://groups.google.com/group/golang-dev">golang-dev</a>
+mailing list is for discussing code changes to the Go project.
+The <a href="https://groups.google.com/group/golang-codereviews">golang-codereviews</a>
+mailing list is for actual reviewing of the code changes (CLs).</p>
+
+<p>For general discussion of Go programming, see <a
+href="https://groups.google.com/group/golang-nuts">golang-nuts</a>.</p>
+
+<h3 id="golang-checkins"><a href="https://groups.google.com/group/golang-checkins">Checkins Mailing List</a></h3>
+<p>A mailing list that receives a message summarizing each checkin to the Go repository.</p>
+
+<h3 id="build_status"><a href="//build.golang.org/">Build Status</a></h3>
+<p>View the status of Go builds across the supported operating
+systems and architectures.</p>
+
+
+<h2 id="howto">How you can help</h2>
+
+<h3><a href="//golang.org/issue">Reporting issues</a></h3>
+
+<p>
+If you spot bugs, mistakes, or inconsistencies in the Go project's code or
+documentation, please let us know by
+<a href="//golang.org/issue/new">filing a ticket</a>
+on our <a href="//golang.org/issue">issue tracker</a>.
+(Of course, you should check it's not an existing issue before creating
+a new one.)
+</p>
+
+<p>
+We pride ourselves on being meticulous; no issue is too small.
+</p>
+
+<p>
+Security-related issues should be reported to
+<a href="mailto:security@golang.org">security@golang.org</a>.<br>
+See the <a href="/security">security policy</a> for more details.
+</p>
+
+<p>
+Community-related issues should be reported to
+<a href="mailto:conduct@golang.org">conduct@golang.org</a>.<br>
+See the <a href="/conduct">Code of Conduct</a> for more details.
+</p>
+
+<h3><a href="/doc/contribute.html">Contributing code</a></h3>
+
+<p>
+Go is an open source project and we welcome contributions from the community.
+</p>
+<p>
+To get started, read these <a href="/doc/contribute.html">contribution
+guidelines</a> for information on design, testing, and our code review process.
+</p>
+<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>
+are particularly in need of outside help.
+</p>

doc/contribute.html

@@ -26,7 +26,7 @@ see <a href="gccgo_contribute.html">Contributing to gccgo</a>.
 
 <h2 id="contributor">Becoming a contributor</h2>
 
-<h3 id="contrib_overview">Overview</h3>
+<h3>Overview</h3>
 
 <p>
 The first step is registering as a Go contributor and configuring your environment.
@@ -46,8 +46,7 @@ CLA (Contributor License Agreement).
 <li>
 <b>Step 2</b>: Configure authentication credentials for the Go Git repository.
 Visit <a href="https://go.googlesource.com/">go.googlesource.com</a>, click
-on the gear icon (top right), then on "Obtain password", and follow the
-instructions.
+on "Generate Password" (top right), and follow the instructions.
 </li>
 <li>
 <b>Step 3</b>: Register for Gerrit, the code review tool used by the Go team,
@@ -74,7 +73,7 @@ $ go-contrib-init
 <p>
 The rest of this chapter elaborates on these instructions.
 If you have completed the steps above (either manually or through the tool), jump to
-<a href="#before_contributing">Before contributing code</a>.
+<a href="#making_a_change">Making a change</a>.
 </p>
 
 <h3 id="google_account">Step 0: Select a Google Account</h3>
@@ -93,10 +92,10 @@ account to use.
 </p>
 
 <p>
-Google accounts can either be Gmail e-mail accounts, G Suite organization accounts, or
+Google accounts can either be Gmail e-mail accounts, G-Suite organization accounts, or
 accounts associated with an external e-mail address.
 For instance, if you need to use
-an existing corporate e-mail that is not managed through G Suite, you can create
+an existing corporate e-mail that is not managed through G-Suite, you can create
 an account associated
 <a href="https://accounts.google.com/SignUpWithoutGmail">with your existing
 e-mail address</a>.
@@ -169,12 +168,12 @@ completed and update the <code>AUTHORS</code> file.
 <h3 id="config_git_auth">Step 2: Configure git authentication</h3>
 
 <p>
-The main Go repository is located at
+Go development happens on
 <a href="https://go.googlesource.com">go.googlesource.com</a>,
 a Git server hosted by Google.
 Authentication on the web server is made through your Google account, but
 you also need to configure <code>git</code> on your computer to access it.
-Follow these steps:
+Follow this steps:
 </p>
 
 <ol>
@@ -191,8 +190,8 @@ This key is paired with one that is generated and stored on the server,
 analogous to how SSH keys work.
 </li>
 <li>
-Copy and run this script locally in your terminal to store your secret
-authentication token in a <code>.gitcookies</code> file.
+Copy and run this script locally in your command line terminal to store your
+secret authentication token in a <code>.gitcookies</code> file.
 If you are using a Windows computer and running <code>cmd</code>,
 you should instead follow the instructions in the yellow box to run the command;
 otherwise run the regular script.
@@ -238,50 +237,29 @@ $ git codereview help
 </pre>
 
 <p>
-prints help text, not an error. If it prints an error, make sure that
-<code>$GOPATH/bin</code> is in your <code>$PATH</code>.
+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 <code>git</code> exec-path.
 Run <code>git --exec-path</code> to discover the right location then create a
-symbolic link or just copy the executable from <code>$GOPATH/bin</code> to this
-directory.
+symbolic link or just copy the executable from $GOPATH/bin to this directory.
 </p>
 
 
 <h2 id="before_contributing">Before contributing code</h2>
 
 <p>
-The project welcomes code patches, but to make sure things are well
-coordinated you should discuss any significant change before starting
-the work.
-It's recommended that you signal your intention to contribute in the
-issue tracker, either by <a href="https://golang.org/issue/new">filing
-a new issue</a> or by claiming
-an <a href="https://golang.org/issues">existing one</a>.
+The project welcomes submissions but to make sure things are well
+coordinated we ask that everyone to discuss any significant changes to the
+Go repositories before starting work.
+Best practice is to connect your work to the issue tracker,
+either by <a href="https://golang.org/issue/new">filing a new issue</a>
+or by claiming an <a href="https://golang.org/issues">existing issue</a>.
 </p>
 
-<h3 id="where">Where to contribute</h3>
-
-<p>
-The Go project consists of the main
-<a href="https://go.googlesource.com/go">go</a> repository, which contains the
-source code for the Go language, as well as many golang.org/x/... repostories.
-These contain the various tools and infrastructure that support Go. For
-example, <a href="https://go.googlesource.com/pkgsite">golang.org/x/pkgsite</a>
-is for <a href="https://pkg.go.dev">pkg.go.dev</a>,
-<a href="https://go.googlesource.com/playground">golang.org/x/playground</a>
-is for the Go playground, and
-<a href="https://go.googlesource.com/tools">golang.org/x/tools</a> contains
-a variety of Go tools, including the Go language server,
-<a href="https://golang.org/s/gopls">gopls</a>. You can see a
-list of all the golang.org/x/... repositories on
-<a href="https://go.googlesource.com">go.googlesource.com</a>.
-</p>
-
-<h3 id="check_tracker">Check the issue tracker</h3>
+<h3>Check the issue tracker</h3>
 
 <p>
 Whether you already know what contribution to make, or you are searching for
@@ -290,13 +268,6 @@ always the first place to go.
 Issues are triaged to categorize them and manage the workflow.
 </p>
 
-<p>
-The majority of the golang.org/x/... repos also use the main Go
-issue tracker. However, a few of these repositories manage their issues
-separately, so please be sure to check the right tracker for the repository to
-which you would like to contribute.
-</p>
-
 <p>
 Most issues will be marked with one of the following workflow labels:
 </p>
@@ -310,7 +281,7 @@ Most issues will be marked with one of the following workflow labels:
 	<b>NeedsDecision</b>: the issue is relatively well understood, but the
 	Go team hasn't yet decided the best way to address it.
 	It would be better to wait for a decision before writing code.
-	If you are interested in working on an issue in this state,
+	If you are interested on working on an issue in this state,
 	feel free to "ping" maintainers in the issue's comments
 	if some time has passed without a decision.
 	</li>
@@ -320,25 +291,6 @@ Most issues will be marked with one of the following workflow labels:
 	</li>
 </ul>
 
-<p>
-You can use GitHub's search functionality to find issues to help out with. Examples:
-</p>
-
-<ul>
-	<li>
-	Issues that need investigation: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsInvestigation"><code>is:issue is:open label:NeedsInvestigation</code></a>
-	</li>
-	<li>
-	Issues that need a fix: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix"><code>is:issue is:open label:NeedsFix</code></a>
-	</li>
-	<li>
-	Issues that need a fix and have a CL: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix+%22golang.org%2Fcl%22"><code>is:issue is:open label:NeedsFix "golang.org/cl"</code></a>
-	</li>
-	<li>
-	Issues that need a fix and do not have a CL: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix+NOT+%22golang.org%2Fcl%22"><code>is:issue is:open label:NeedsFix NOT "golang.org/cl"</code></a>
-	</li>
-</ul>
-
 <h3 id="design">Open an issue for any new problem</h3>
 
 <p>
@@ -354,21 +306,16 @@ the code review tool is not the place for high-level discussions.
 
 <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>
-for the main Go repository. The latter half of each cycle is a three-month
-feature freeze during which only bug fixes and documentation updates are
-accepted. New contributions can be sent during a feature freeze, but they will
-not be merged until the freeze is over. The freeze applies to the entire main
-repository as well as to the code in golang.org/x/... repositories that is
-needed to build the binaries included in the release. See the lists of packages
-vendored into
-<a href="https://github.com/golang/go/blob/master/src/vendor/modules.txt">the standard library</a>
-and the <a href="https://github.com/golang/go/blob/master/src/cmd/vendor/modules.txt"><code>go</code> command</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 documentation updates are accepted.
+New contributions can be
+sent during a feature freeze but will not be accepted until the freeze is over.
 </p>
 
 <p>
-Significant changes to the language, libraries, or tools must go
-through the
+Changes in general other than bug and documentation fixes
+must go through the
 <a href="https://golang.org/s/proposal-process">change proposal process</a>
 before they can be accepted.
 </p>
@@ -390,11 +337,10 @@ GitHub pull requests to Gerrit.
 
 <p>
 Open a pull request as you normally would.
-Gopherbot will create a corresponding Gerrit change and post a link to
-it on your GitHub pull request; updates to the pull request will also
-get reflected in the Gerrit change.
-When somebody comments on the change, their comment will be also
-posted in your pull request, so you will get a notification.
+Gopherbot will automatically
+sync the code and post a link to Gerrit.
+When somebody comments on the
+change, it will be posted in the pull request, so you will also get a notification.
 </p>
 
 <p>
@@ -426,11 +372,11 @@ Remember you can always visit Gerrit to see the fine-grained review.
 <p>
 It is not possible to fully sync Gerrit and GitHub, at least at the moment,
 so we recommend learning Gerrit.
-It's different but powerful and familiarity with it will help you understand
-the flow.
+It's different but powerful and familiarity
+with help you understand the flow.
 </p>
 
-<h3 id="gerrit_overview">Overview</h3>
+<h3>Overview</h3>
 
 <p>
 This is an overview of the overall process:
@@ -438,29 +384,13 @@ This is an overview of the overall process:
 
 <ul>
 <li>
-<b>Step 1:</b> Clone the source code from <code>go.googlesource.com</code> and
-make sure it's stable by compiling and testing it once.
-
-<p>If you're making a change to the
-<a href="https://go.googlesource.com/go">main Go repository</a>:</p>
-
+<b>Step 1:</b> Clone the Go source code from GitHub or go.googlesource.com
+and make sure it's stable by compiling and testing it once:
 <pre>
-$ git clone https://go.googlesource.com/go
+$ git clone https://github.com/golang/go    # or https://go.googlesource.com/go
 $ cd go/src
 $ ./all.bash                                # compile and test
 </pre>
-
-<p>
-If you're making a change to one of the golang.org/x/... repositories
-(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a>,
-in this example):
-</p>
-
-<pre>
-$ git clone https://go.googlesource.com/tools
-$ cd tools
-$ go test ./...                             # compile and test
-</pre>
 </li>
 
 <li>
@@ -480,23 +410,15 @@ $ [etc.]
 </li>
 
 <li>
-<b>Step 3:</b> Test your changes, either by running the tests in the package
-you edited or by re-running <code>all.bash</code>.
-
-<p>In the main Go repository:</p>
+<b>Step 3:</b> Test your changes, re-running <code>all.bash</code>.
 <pre>
 $ ./all.bash    # recompile and test
 </pre>
-
-<p>In a golang.org/x/... repository:</p>
-<pre>
-$ go test ./... # recompile and test
-</pre>
 </li>
 
 <li>
 <b>Step 4:</b> Send the changes for review to Gerrit using <code>git</code>
-<code>codereview</code> <code>mail</code> (which doesn't use e-mail, despite the name).
+<code>codereview</code> <code>mail</code>(which doesn't use e-mail, despite the name).
 <pre>
 $ git codereview mail     # send changes to Gerrit
 </pre>
@@ -519,29 +441,22 @@ The rest of this section describes these steps in more detail.
 </p>
 
 
-<h3 id="checkout_go">Step 1: Clone the source code</h3>
+<h3 id="checkout_go">Step 1: Clone the Go source code</h3>
 
 <p>
 In addition to a recent Go installation, you need to have a local copy of the source
 checked out from the correct repository.
 You can check out the Go source repo onto your local file system anywhere
 you want as long as it's outside your <code>GOPATH</code>.
-Clone from <code>go.googlesource.com</code> (not GitHub):
+Either clone from
+<code>go.googlesource.com</code> or from GitHub:
 </p>
 
-<p>Main Go repository:</p>
 <pre>
-$ git clone https://go.googlesource.com/go
+$ git clone https://github.com/golang/go   # or https://go.googlesource.com/go
 $ cd go
 </pre>
 
-<p>golang.org/x/... repository</p>
-(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a> in this example):
-<pre>
-$ git clone https://go.googlesource.com/tools
-$ cd tools
-</pre>
-
 <h3 id="make_branch">Step 2: Prepare changes in a new branch</h3>
 
 <p>
@@ -605,20 +520,18 @@ into a single one.
 <p>
 You've <a href="code.html">written and tested your code</a>, but
 before sending code out for review, run <i>all the tests for the whole
-tree</i> to make sure the changes don't break other packages or programs.
+tree</i> to make sure the changes don't break other packages or programs:
 </p>
 
-<h4 id="test-gorepo">In the main Go repository</h4>
-
-<p>This can be done by running <code>all.bash</code>:</p>
-
 <pre>
 $ cd go/src
 $ ./all.bash
 </pre>
 
 <p>
-(To build under Windows use <code>all.bat</code>)
+(To build under Windows use <code>all.bat</code>; this also requires
+setting the environment variable <code>GOROOT_BOOTSTRAP</code> to the
+directory holding the Go tree for the bootstrap compiler.)
 </p>
 
 <p>
@@ -632,7 +545,7 @@ ALL TESTS PASSED
 
 <p>
 You can use <code>make.bash</code> instead of <code>all.bash</code>
-to just build the compiler and the standard library without running the test suite.
+to just build the compiler and standard packages without running the test suite.
 Once the <code>go</code> tool is built, it will be installed as <code>bin/go</code>
 under the directory in which you cloned the Go repository, and you can
 run it directly from there.
@@ -640,33 +553,6 @@ See also
 the section on how to <a href="#quick_test">test your changes quickly</a>.
 </p>
 
-<h4 id="test-xrepo">In the golang.org/x/... repositories</h4>
-
-<p>
-Run the tests for the entire repository
-(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a>,
-in this example):
-</p>
-
-<pre>
-$ cd tools
-$ go test ./...
-</pre>
-
-<p>
-If you're concerned about the build status,
-you can check the <a href="https://build.golang.org">Build Dashboard</a>.
-Test failures may also be caught by the TryBots in code review.
-</p>
-
-<p>
-Some repositories, like
-<a href="https://go.googlesource.com/vscode-go">golang.org/x/vscode-go</a> will
-have different testing infrastructures, so always check the documentation
-for the repository in which you are working. The README file in the root of the
-repository will usually have this information.
-</p>
-
 <h3 id="mail">Step 4: Send changes for review</h3>
 
 <p>
@@ -711,9 +597,8 @@ if you prefer.
 </p>
 
 <p>
-If you need to revise your change after the review, edit the files in
-the same branch you previously created, add them to the Git staging
-area, and then amend the commit with
+If you need to revise your change after the review, edit the files in correct branch,
+add them to the Git staging area, and then amend the commit with
 <code>git</code> <code>codereview</code> <code>change</code>:
 </p>
 
@@ -754,12 +639,12 @@ The existing implementation has poor numerical properties for
 large arguments, so use the McGillicutty algorithm to improve
 accuracy above 1e10.
 
-The algorithm is described at https://wikipedia.org/wiki/McGillicutty_Algorithm
+The algorithm is described at http://wikipedia.org/wiki/McGillicutty_Algorithm
 
 Fixes #159
 </pre>
 
-<h3 id="first_line">First line</h3>
+<h3>First line</h3>
 
 <p>
 The first line of the change description is conventionally a short one-line
@@ -777,7 +662,7 @@ and actually summarizes the result of the change.
 Follow the first line by a blank line.
 </p>
 
-<h3 id="main_content">Main content</h3>
+<h3>Main content</h3>
 
 <p>
 The rest of the description elaborates and should provide context for the
@@ -789,13 +674,13 @@ Don't use HTML, Markdown, or any other markup language.
 
 <p>
 Add any relevant information, such as benchmark data if the change
-affects performance.
-The <a href="https://godoc.org/golang.org/x/perf/cmd/benchstat">benchstat</a>
+afects performance.
+The <a href="https://godoc.org/golang.org/x/tools/cmd/benchcmp">benchcmp</a>
 tool is conventionally used to format
 benchmark data for change descriptions.
 </p>
 
-<h3 id="ref_issues">Referencing issues</h3>
+<h3>Referencing issues</h3>
 
 <p>
 The special notation "Fixes #12345" associates the change with issue 12345 in the
@@ -813,10 +698,10 @@ when the change is applied.
 </p>
 
 <p>
-If you are sending a change against a golang.org/x/... repository, you must use
+If you are sending a change against a subrepository, you must use
 the fully-qualified syntax supported by GitHub to make sure the change is
-linked to the issue in the main repository, not the x/ repository.
-Most issues are tracked in the main repository's issue tracker.
+linked to the issue in the main repository, not the subrepository.
+All issues are tracked in the main repository's issue tracker.
 The correct form is "Fixes golang/go#159".
 </p>
 
@@ -1016,13 +901,13 @@ New files that you contribute should use the standard copyright header:
 </p>
 
 <pre>
-// Copyright 2020 The Go Authors. All rights reserved.
+// 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>
-(Use the current year if you're reading this in 2021 or beyond.)
+(Use the current year if you're reading this in 2019 or beyond.)
 Files in the repository are copyrighted the year they are added.
 Do not update the copyright year on files that you change.
 </p>
@@ -1052,7 +937,7 @@ remote: ERROR:  does not match your user account.
 <p>
 you need to configure Git for this repository to use the
 e-mail address that you registered with.
-To change the e-mail address to ensure this doesn't happen again, run:
+To change the e-mail address for this doesn't happen again, run:
 </p>
 
 <pre>
@@ -1099,8 +984,8 @@ followed by <code>run.bash</code>.
 
 <li>
 In this section, we'll call the directory into which you cloned the Go repository <code>$GODIR</code>.
-The <code>go</code> tool built by <code>$GODIR/src/make.bash</code> will be installed
-in <code>$GODIR/bin/go</code> and you
+The <code>go</code> tool built by <code>$GODIR/make.bash</code>will be installed
+in <code>$GODIR/bin/go</code>and you
 can invoke it to test your code.
 For instance, if you
 have modified the compiler and you want to test how it affects the
@@ -1163,6 +1048,25 @@ $ $GODIR/bin/go run run.go
 </pre>
 </ul>
 
+<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>), and follow the
+normal contribution flow.
+</p>
+
 
 <h3 id="cc">Specifying a reviewer / CCing others</h3>
 
@@ -1283,5 +1187,5 @@ $ git codereview mail HEAD
 
 <p>
 Make sure to explicitly specify <code>HEAD</code>, which is usually not required when sending
-single changes. More details can be found in the <a href="https://pkg.go.dev/golang.org/x/review/git-codereview?tab=doc#hdr-Multiple_Commit_Work_Branches">git-codereview documentation</a>.
+single changes.
 </p>

doc/debugging_with_gdb.html

@@ -18,13 +18,13 @@ Gccgo has native gdb support.
 </p>
 <p>
 Note that 
-<a href="https://github.com/go-delve/delve">Delve</a> is a better
+<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/go-delve/delve/tree/master/Documentation/installation">
+<a href="https://github.com/derekparker/delve/tree/master/Documentation/installation">
  the Delve documentation</a>.
 </p>
 </i>
@@ -47,7 +47,7 @@ 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="https://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
+<a href="http://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
 </p>
 
 <p>
@@ -57,7 +57,7 @@ Besides this overview you might want to consult the
 
 <p>
 When you compile and link your Go programs with the <code>gc</code> toolchain
-on Linux, macOS, FreeBSD or NetBSD, the resulting binaries contain DWARFv4
+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
 use to inspect a live process or a core dump.
 </p>
@@ -149,9 +149,6 @@ Inspecting goroutines:
 (gdb) <b>help goroutine</b></pre>
 For example:
 <pre>(gdb) <b>goroutine 12 bt</b></pre>
-You can inspect all goroutines by passing <code>all</code> instead of a specific goroutine's ID.
-For example:
-<pre>(gdb) <b>goroutine all bt</b></pre>
 </li>
 </ul>
 
@@ -182,15 +179,7 @@ from it.</li>
 <code>"fmt.Print"</code> as an unstructured literal with a <code>"."</code>
 that needs to be quoted.  It objects even more strongly to method names of
 the form <code>pkg.(*MyType).Meth</code>.
-<li>As of Go 1.11, debug information is compressed by default.
-Older versions of gdb, such as the one available by default on MacOS,
-do not understand the compression.
-You can generate uncompressed debug information by using <code>go
-build -ldflags=-compressdwarf=false</code>.
-(For convenience you can put the <code>-ldflags</code> option in
-the <a href="/cmd/go/#hdr-Environment_variables"><code>GOFLAGS</code>
-environment variable</a> so that you don't have to specify it each time.)
-</li>
+<li>All global variables are lumped into package <code>"main"</code>.</li>
 </ol>
 
 <h2 id="Tutorial">Tutorial</h2>
@@ -259,7 +248,7 @@ Use the <code>"l"</code> or <code>"list"</code> command to inspect source code.
 </pre>
 
 <p>
-List a specific part of the source parameterizing <code>"list"</code> with a
+List a specific part of the source parametrizing <code>"list"</code> with a
 function name (it must be qualified with its package name).
 </p>
 

doc/devel/pre_go1.html

@@ -0,0 +1,455 @@
+<!--{
+	"Title": "Pre-Go 1 Release History"
+}-->
+
+<p>
+This page summarizes the changes between stable releases of Go prior to Go 1.
+See the <a href="release.html">Release History</a> page for notes on recent releases.
+</p>
+
+<h2 id="r60">r60 (released 2011/09/07)</h2>
+
+<p>
+The r60 release corresponds to 
+<code><a href="weekly.html#2011-08-17">weekly.2011-08-17</a></code>.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-08-17">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r60">Mercurial change list</a>.
+</p>
+
+<h3 id="r60.lang">Language</h3>
+
+<p>
+An "else" block is now required to have braces except if the body of the "else"
+is another "if". Since gofmt always puts those braces in anyway,
+gofmt-formatted programs will not be affected.
+To fix other programs, run gofmt.
+</p>
+
+<h3 id="r60.pkg">Packages</h3>
+
+<p>
+<a href="/pkg/http/">Package http</a>'s URL parsing and query escaping code
+(such as <code>ParseURL</code> and <code>URLEscape</code>) has been moved to
+the new <a href="/pkg/url/">url package</a>, with several simplifications to
+the names. Client code can be updated automatically with gofix.
+</p>
+
+<p>
+<a href="/pkg/image/">Package image</a> has had significant changes made to the
+<code>Pix</code> field of struct types such as
+<a href="/pkg/image/#RGBA">image.RGBA</a> and
+<a href="/pkg/image/#NRGBA">image.NRGBA</a>.
+The <a href="/pkg/image/#Image">image.Image</a> interface type has not changed,
+though, and you should not need to change your code if you don't explicitly
+refer to <code>Pix</code> fields. For example, if you decode a number of images
+using the <a href="/pkg/image/jpeg/">image/jpeg</a> package, compose them using
+<a href="/pkg/image/draw/">image/draw</a>, and then encode the result using
+<a href="/pkg/img/png">image/png</a>, then your code should still work as
+before.
+If your code <i>does</i> refer to <code>Pix</code> fields see the 
+<a href="/doc/devel/weekly.html#2011-07-19">weekly.2011-07-19</a>
+snapshot notes for how to update your code.
+</p>
+
+<p>
+<a href="/pkg/template/">Package template</a> has been replaced with a new
+templating package (formerly <code>exp/template</code>). The original template
+package is still available as <a href="/pkg/old/template/">old/template</a>.
+The <code>old/template</code> package is deprecated and will be removed.
+The Go tree has been updated to use the new template package. We encourage
+users of the old template package to switch to the new one. Code that uses
+<code>template</code> or <code>exp/template</code> will need to change its
+import lines to <code>"old/template"</code> or <code>"template"</code>,
+respectively.
+</p>
+
+<h3 id="r60.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now uses a new tag selection scheme.
+When downloading or updating, goinstall looks for a tag or branch with the
+<code>"go."</code> prefix that corresponds to the local Go version. For Go
+<code>release.r58</code> it looks for <code>go.r58</code>. For
+<code>weekly.2011-06-03</code> it looks for <code>go.weekly.2011-06-03</code>.
+If the specific <code>go.X</code> tag or branch is not found, it chooses the
+closest earlier version. If an appropriate tag or branch is found, goinstall
+uses that version of the code. Otherwise it uses the default version selected
+by the version control system. Library authors are encouraged to use the
+appropriate tag or branch names in their repositories to make their libraries
+more accessible.
+</p>
+
+<h3 id="r60.minor">Minor revisions</h3>
+
+<p>
+r60.1 includes a 
+<a href="//golang.org/change/1824581bf62d">linker
+fix</a>, a pair of
+<a href="//golang.org/change/9ef4429c2c64">goplay</a>
+<a href="//golang.org/change/d42ed8c3098e">fixes</a>,
+and a <code>json</code> package
+<a href="//golang.org/change/d5e97874fe84">fix</a> and
+a new
+<a href="//golang.org/change/4f0e6269213f">struct tag
+option</a>.
+</p>
+
+<p>
+r60.2
+<a href="//golang.org/change/ff19536042ac">fixes</a>
+a memory leak involving maps.
+</p>
+
+<p>
+r60.3 fixes a
+<a href="//golang.org/change/01fa62f5e4e5">reflect bug</a>.
+</p>
+
+<h2 id="r59">r59 (released 2011/08/01)</h2>
+
+<p>
+The r59 release corresponds to 
+<code><a href="weekly.html#2011-07-07">weekly.2011-07-07</a></code>.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-07-07">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r59">Mercurial change list</a>.
+</p>
+
+<h3 id="r59.lang">Language</h3>
+
+<p>
+This release includes a language change that restricts the use of
+<code>goto</code>.  In essence, a <code>goto</code> statement outside a block
+cannot jump to a label inside that block. Your code may require changes if it
+uses <code>goto</code>.
+See <a href="//golang.org/change/dc6d3cf9279d">this
+changeset</a> for how the new rule affected the Go tree.
+</p>
+
+<h3 id="r59.pkg">Packages</h3>
+
+<p>
+As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<p>
+<a href="/pkg/http">Package http</a> has a new
+<a href="/pkg/http/#FileSystem">FileSystem</a> interface that provides access
+to files. The <a href="/pkg/http/#FileServer">FileServer</a> helper now takes a
+<code>FileSystem</code> argument instead of an explicit file system root. By
+implementing your own <code>FileSystem</code> you can use the
+<code>FileServer</code> to serve arbitrary data.
+</p>
+
+<p>
+<a href="/pkg/os/">Package os</a>'s <code>ErrorString</code> type has been
+hidden. Most uses of <code>os.ErrorString</code> can be replaced with
+<a href="/pkg/os/#NewError">os.NewError</a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/">Package reflect</a> supports a new struct tag scheme
+that enables sharing of struct tags between multiple packages.
+In this scheme, the tags must be of the form:
+</p>
+<pre>
+	`key:"value" key2:"value2"`
+</pre>
+<p>
+The <a href="/pkg/reflect/#StructField">StructField</a> type's Tag field now
+has type <a href="/pkg/reflect/#StructTag">StructTag</a>, which has a
+<code>Get</code> method. Clients of <a href="/pkg/json">json</a> and
+<a href="/pkg/xml">xml</a> will need to be updated. Code that says
+</p>
+<pre>
+	type T struct {
+		X int "name"
+	}
+</pre>
+<p>
+should become
+</p>
+<pre>
+	type T struct {
+		X int `json:"name"`  // or `xml:"name"`
+	}
+</pre>
+<p>
+Use <a href="/cmd/govet/">govet</a> to identify struct tags that need to be
+changed to use the new syntax.
+</p>
+
+<p>
+<a href="/pkg/sort/">Package sort</a>'s <code>IntArray</code> type has been
+renamed to <a href="/pkg/sort/#IntSlice">IntSlice</a>, and similarly for
+<a href="/pkg/sort/#Float64Slice">Float64Slice</a> and
+<a href="/pkg/sort/#StringSlice">StringSlice</a>.
+</p>
+
+<p>
+<a href="/pkg/strings/">Package strings</a>'s <code>Split</code> function has
+itself been split into <a href="/pkg/strings/#Split">Split</a> and
+<a href="/pkg/strings/#SplitN">SplitN</a>.
+<code>SplitN</code> is the same as the old <code>Split</code>.
+The new <code>Split</code> is equivalent to <code>SplitN</code> with a final
+argument of -1.
+</p>
+
+<a href="/pkg/image/draw/">Package image/draw</a>'s
+<a href="/pkg/image/draw/#Draw">Draw</a> function now takes an additional
+argument, a compositing operator.
+If in doubt, use <a href="/pkg/image/draw/#Op">draw.Over</a>.
+</p>
+
+<h3 id="r59.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now installs packages and commands from
+arbitrary remote repositories (not just Google Code, Github, and so on).
+See the <a href="/cmd/goinstall/">goinstall documentation</a> for details.
+</p>
+
+<h2 id="r58">r58 (released 2011/06/29)</h2>
+
+<p>
+The r58 release corresponds to 
+<code><a href="weekly.html#2011-06-09">weekly.2011-06-09</a></code>
+with additional bug fixes.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-06-09">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r58">Mercurial change list</a>.
+</p>
+
+<h3 id="r58.lang">Language</h3>
+
+<p>
+This release fixes a <a href="//golang.org/change/b720749486e1">use of uninitialized memory in programs that misuse <code>goto</code></a>.
+</p>
+
+<h3 id="r58.pkg">Packages</h3>
+
+<p>
+As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<p>
+<a href="/pkg/http/">Package http</a> drops the <code>finalURL</code> return
+value from the <a href="/pkg/http/#Client.Get">Client.Get</a> method. The value
+is now available via the new <code>Request</code> field on <a
+href="/pkg/http/#Response">http.Response</a>.
+Most instances of the type map[string][]string in have been
+replaced with the new <a href="/pkg/http/#Values">Values</a> type.
+</p>
+
+<p>
+<a href="/pkg/exec/">Package exec</a> has been redesigned with a more
+convenient and succinct API.
+</p>
+
+<p>
+<a href="/pkg/strconv/">Package strconv</a>'s <a href="/pkg/strconv/#Quote">Quote</a>
+function now escapes only those Unicode code points not classified as printable
+by <a href="/pkg/unicode/#IsPrint">unicode.IsPrint</a>.
+Previously Quote would escape all non-ASCII characters.
+This also affects the <a href="/pkg/fmt/">fmt</a> package's <code>"%q"</code>
+formatting directive. The previous quoting behavior is still available via
+strconv's new <a href="/pkg/strconv/#QuoteToASCII">QuoteToASCII</a> function.   
+</p>
+
+<p>
+<a href="/pkg/os/signal/">Package os/signal</a>'s
+<a href="/pkg/os/#Signal">Signal</a> and 
+<a href="/pkg/os/#UnixSignal">UnixSignal</a> types have been moved to the
+<a href="/pkg/os/">os</a> package.
+</p>
+
+<p>
+<a href="/pkg/image/draw/">Package image/draw</a> is the new name for
+<code>exp/draw</code>. The GUI-related code from <code>exp/draw</code> is now
+located in the <a href="/pkg/exp/gui/">exp/gui</a> package.
+</p>
+
+<h3 id="r58.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now observes the GOPATH environment
+variable to build and install your own code and external libraries outside of
+the Go tree (and avoid writing Makefiles).
+</p>
+
+
+<h3 id="r58.minor">Minor revisions</h3>
+
+<p>r58.1 adds 
+<a href="//golang.org/change/293c25943586">build</a> and
+<a href="//golang.org/change/bf17e96b6582">runtime</a>
+changes to make Go run on OS X 10.7 Lion.
+</p>
+
+<h2 id="r57">r57 (released 2011/05/03)</h2>
+
+<p>
+The r57 release corresponds to 
+<code><a href="weekly.html#2011-04-27">weekly.2011-04-27</a></code>
+with additional bug fixes.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-04-27">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r57">Mercurial change list</a>.
+</p>
+
+<p>The new <a href="/cmd/gofix">gofix</a> tool finds Go programs that use old APIs and rewrites them to use
+newer ones.  After you update to a new Go release, gofix helps make the
+necessary changes to your programs. Gofix will handle the http, os, and syscall
+package changes described below, and we will update the program to keep up with
+future changes to the libraries. 
+Gofix can’t
+handle all situations perfectly, so read and test the changes it makes before
+committing them.
+See <a href="//blog.golang.org/2011/04/introducing-gofix.html">the gofix blog post</a> for more
+information.</p>
+
+<h3 id="r57.lang">Language</h3>
+
+<p>
+<a href="/doc/go_spec.html#Receive_operator">Multiple assignment syntax</a> replaces the <code>closed</code> function.
+The syntax for channel
+receives allows an optional second assigned value, a boolean value
+indicating whether the channel is closed. This code:
+</p>
+
+<pre>
+	v := &lt;-ch
+	if closed(ch) {
+		// channel is closed
+	}
+</pre>
+
+<p>should now be written as:</p>
+
+<pre>
+	v, ok := &lt;-ch
+	if !ok {
+		// channel is closed
+	}
+</pre>
+
+<p><a href="/doc/go_spec.html#Label_scopes">Unused labels are now illegal</a>, just as unused local variables are.</p>
+
+<h3 id="r57.pkg">Packages</h3>
+
+<p>
+<a href="/pkg/gob/">Package gob</a> will now encode and decode values of types that implement the
+<a href="/pkg/gob/#GobEncoder">GobEncoder</a> and
+<a href="/pkg/gob/#GobDecoder">GobDecoder</a> interfaces. This allows types with unexported
+fields to transmit self-consistent descriptions; examples include 
+<a href="/pkg/big/#Int.GobDecode">big.Int</a> and <a href="/pkg/big/#Rat.GobDecode">big.Rat</a>.
+</p>
+
+<p>
+<a href="/pkg/http/">Package http</a> has been redesigned.
+For clients, there are new
+<a href="/pkg/http/#Client">Client</a> and <a href="/pkg/http/#Transport">Transport</a>
+abstractions that give more control over HTTP details such as headers sent
+and redirections followed.  These abstractions make it easy to implement
+custom clients that add functionality such as <a href="//code.google.com/p/goauth2/source/browse/oauth/oauth.go">OAuth2</a>.
+For servers, <a href="/pkg/http/#ResponseWriter">ResponseWriter</a>
+has dropped its non-essential methods.
+The Hijack and Flush methods are no longer required;
+code can test for them by checking whether a specific value implements
+<a href="/pkg/http/#Hijacker">Hijacker</a> or <a href="/pkg/http/#Flusher">Flusher</a>.
+The RemoteAddr and UsingTLS methods are replaced by <a href="/pkg/http/#Request">Request</a>'s
+RemoteAddr and TLS fields.
+The SetHeader method is replaced by a Header method;
+its result, of type <a href="/pkg/http/#Header">Header</a>,
+implements Set and other methods.
+</p>
+
+<p>
+<a href="/pkg/net/">Package net</a>
+drops the <code>laddr</code> argument from <a href="/pkg/net/#Conn.Dial">Dial</a>
+and drops the <code>cname</code> return value
+from <a href="/pkg/net/#LookupHost">LookupHost</a>.
+The implementation now uses <a href="/cmd/cgo/">cgo</a> to implement
+network name lookups using the C library getaddrinfo(3)
+function when possible.  This ensures that Go and C programs
+resolve names the same way and also avoids the OS X 
+application-level firewall.
+</p>
+
+<p>
+<a href="/pkg/os/">Package os</a>
+introduces simplified <a href="/pkg/os/#File.Open">Open</a>
+and <a href="/pkg/os/#File.Create">Create</a> functions.
+The original Open is now available as <a href="/pkg/os/#File.OpenFile">OpenFile</a>.
+The final three arguments to <a href="/pkg/os/#Process.StartProcess">StartProcess</a>
+have been replaced by a pointer to a <a href="/pkg/os/#ProcAttr">ProcAttr</a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/">Package reflect</a> has been redesigned.
+<a href="/pkg/reflect/#Type">Type</a> is now an interface that implements
+all the possible type methods.
+Instead of a type switch on a Type <code>t</code>, switch on <code>t.Kind()</code>.
+<a href="/pkg/reflect/#Value">Value</a> is now a struct value that
+implements all the possible value methods.
+Instead of a type switch on a Value <code>v</code>, switch on <code>v.Kind()</code>.
+Typeof and NewValue are now called <a href="/pkg/reflect/#Type.TypeOf">TypeOf</a> and <a href="/pkg/reflect/#Value.ValueOf">ValueOf</a>
+To create a writable Value, use <code>New(t).Elem()</code> instead of <code>Zero(t)</code>.
+See <a href="//golang.org/change/843855f3c026">the change description</a>
+for the full details.
+The new API allows a more efficient implementation of Value
+that avoids many of the allocations required by the previous API.
+</p>
+
+<p>
+Remember that gofix will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<h3 id="r57.cmd">Tools</h3>
+
+<p><a href="/cmd/gofix/">Gofix</a>, a new command, is described above.</p>
+
+<p>
+<a href="/cmd/gotest/">Gotest</a> is now a Go program instead of a shell script.
+The new <code>-test.short</code> flag in combination with package testing's Short function
+allows you to write tests that can be run in normal or &ldquo;short&rdquo; mode;
+all.bash runs tests in short mode to reduce installation time.
+The Makefiles know about the flag: use <code>make testshort</code>.
+</p>
+
+<p>
+The run-time support now implements CPU and memory profiling.
+Gotest's new 
+<a href="/cmd/gotest/"><code>-test.cpuprofile</code> and
+<code>-test.memprofile</code> flags</a> make it easy to
+profile tests.
+To add profiling to your web server, see the <a href="/pkg/http/pprof/">http/pprof</a>
+documentation.
+For other uses, see the <a href="/pkg/runtime/pprof/">runtime/pprof</a> documentation.
+</p>
+
+<h3 id="r57.minor">Minor revisions</h3>
+
+<p>r57.1 fixes a <a href="//golang.org/change/ff2bc62726e7145eb2ecc1e0f076998e4a8f86f0">nil pointer dereference in http.FormFile</a>.</p>
+<p>r57.2 fixes a <a href="//golang.org/change/063b0ff67d8277df03c956208abc068076818dae">use of uninitialized memory in programs that misuse <code>goto</code></a>.</p>
+
+<h2 id="r56">r56 (released 2011/03/16)</h2>
+
+<p>
+The r56 release was the first stable release and corresponds to
+<code><a href="weekly.html#2011-03-07">weekly.2011-03-07.1</a></code>.
+The numbering starts at 56 because before this release,
+what we now consider weekly snapshots were called releases.
+</p>

doc/devel/release.html

@@ -0,0 +1,475 @@
+<!--{
+	"Title": "Release History"
+}-->
+
+<p>This page summarizes the changes between official stable releases of Go.
+The <a href="//golang.org/change">change log</a> has the full details.</p>
+
+<p>To update to a specific release, use:</p>
+
+<pre>
+git pull
+git checkout <i>release-branch</i>
+</pre>
+
+<h2 id="policy">Release Policy</h2>
+
+<p>
+Each major Go release is supported until there are two newer major releases.
+For example, Go 1.5 was supported until the Go 1.7 release, and Go 1.6 was
+supported until the Go 1.8 release.
+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.6.1, Go 1.6.2, and so on).
+</p>
+
+<h2 id="go1.10">go1.10 (released 2018/02/16)</h2>
+
+<p>
+Go 1.10 is a major release of Go.
+Read the <a href="/doc/go1.10">Go 1.10 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.10.minor">Minor revisions</h3>
+
+<p>
+go1.10.1 (released 2018/03/28) includes fixes to the compiler, runtime, and the
+<code>archive/zip</code>, <code>crypto/tls</code>, <code>crypto/x509</code>,
+<code>encoding/json</code>, <code>net</code>, <code>net/http</code>, and
+<code>net/http/pprof</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.1">Go
+1.10.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.2 (released 2018/05/01) includes fixes to the compiler, linker, and go
+command.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.2">Go
+1.10.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.3 (released 2018/06/05) includes fixes to the go command, and the
+<code>crypto/tls</code>, <code>crypto/x509</code>, and <code>strings</code> packages.
+In particular, it adds <a href="https://go.googlesource.com/go/+/d4e21288e444d3ffd30d1a0737f15ea3fc3b8ad9">
+minimal support to the go command for the vgo transition</a>.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.3">Go
+1.10.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.4 (released 2018/08/24) includes fixes to the go command, linker, and the
+<code>net/http</code>, <code>mime/multipart</code>, <code>ld/macho</code>,
+<code>bytes</code>, and <code>strings</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.4">Go
+1.10.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.5 (released 2018/11/02) includes fixes to the go command, linker, runtime
+and the <code>database/sql</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.5">Go
+1.10.5 milestone</a> on our issue tracker for details.
+</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.
+</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>
+
+<p>
+go1.9.3 (released 2018/01/22) includes fixes to the compiler, runtime,
+and the <code>database/sql</code>, <code>math/big</code>, <code>net/http</code>,
+and <code>net/url</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.3">Go
+1.9.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.4 (released 2018/02/07) includes a security fix to “go get”.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.4">Go
+1.9.4</a> milestone on our issue tracker for details.
+</p>
+
+<p>
+go1.9.5 (released 2018/03/28) includes fixes to the compiler, go command, and
+<code>net/http/pprof</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.5">Go
+1.9.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.6 (released 2018/05/01) includes fixes to the compiler and go command.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.6">Go
+1.9.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.7 (released 2018/06/05) includes fixes to the go command, and the
+<code>crypto/x509</code>, and <code>strings</code> packages.
+In particular, it adds <a href="https://go.googlesource.com/go/+/d4e21288e444d3ffd30d1a0737f15ea3fc3b8ad9">
+minimal support to the go command for the vgo transition</a>.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.7">Go
+1.9.7 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.
+</p>
+
+<p>
+go1.8.6 (released 2018/01/22) includes the same fix in <code>math/big</code>
+as Go 1.9.3 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.6">Go
+1.8.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.7 (released 2018/02/07) includes a security fix to “go get”.
+It contains the same fix as Go 1.9.4 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.7">Go
+1.8.7</a> milestone on our issue tracker for details.
+</p>
+
+<h2 id="go1.7">go1.7 (released 2016/08/15)</h2>
+
+<p>
+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>
+Go 1.6 is a major release of Go.
+Read the <a href="/doc/go1.6">Go 1.6 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.6.minor">Minor revisions</h3>
+
+<p>
+go1.6.1 (released 2016/04/12) includes two security fixes.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
+1.6.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.2 (released 2016/04/20) includes fixes to the compiler, runtime, tools,
+documentation, and the <code>mime/multipart</code>, <code>net/http</code>, and
+<code>sort</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.2">Go
+1.6.2 milestone</a> on our issue tracker for details.
+</p>
+
+<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.
+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>
+Go 1.5 is a major release of Go.
+Read the <a href="/doc/go1.5">Go 1.5 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.5.minor">Minor revisions</h3>
+
+<p>
+go1.5.1 (released 2015/09/08) includes bug fixes to the compiler, assembler, and
+the <code>fmt</code>, <code>net/textproto</code>, <code>net/http</code>, and
+<code>runtime</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.1">Go
+1.5.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.5.2 (released 2015/12/02) includes bug fixes to the compiler, linker, and
+the <code>mime/multipart</code>, <code>net</code>, and <code>runtime</code>
+packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.2">Go
+1.5.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.5.3 (released 2016/01/13) includes a security fix to the <code>math/big</code> package
+affecting the <code>crypto/tls</code> package.
+See the <a href="https://golang.org/s/go153announce">release announcement</a> for details.
+</p>
+
+<p>
+go1.5.4 (released 2016/04/12) includes two security fixes.
+It contains the same fixes as Go 1.6.1 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
+1.6.1 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.4">go1.4 (released 2014/12/10)</h2>
+
+<p>
+Go 1.4 is a major release of Go.
+Read the <a href="/doc/go1.4">Go 1.4 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.4.minor">Minor revisions</h3>
+
+<p>
+go1.4.1 (released 2015/01/15) includes bug fixes to the linker and the <code>log</code>, <code>syscall</code>, and <code>runtime</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.1">Go 1.4.1 milestone on our issue tracker</a> for details.
+</p>
+
+<p>
+go1.4.2 (released 2015/02/17) includes bug fixes to the <code>go</code> command, the compiler and linker, and the <code>runtime</code>, <code>syscall</code>, <code>reflect</code>, and <code>math/big</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.2">Go 1.4.2 milestone on our issue tracker</a> for details.
+</p>
+
+<p>
+go1.4.3 (released 2015/09/22) includes security fixes to the <code>net/http</code> package and bug fixes to the <code>runtime</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.3">Go 1.4.3 milestone on our issue tracker</a> for details.
+</p>
+
+<h2 id="go1.3">go1.3 (released 2014/06/18)</h2>
+
+<p>
+Go 1.3 is a major release of Go.
+Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.3.minor">Minor revisions</h3>
+
+<p>
+go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.3.1">change history</a> for details.
+</p>
+
+<p>
+go1.3.2 (released 2014/09/25) includes bug fixes to cgo and the crypto/tls packages.
+See the <a href="https://github.com/golang/go/commits/go1.3.2">change history</a> for details.
+</p>
+
+<p>
+go1.3.3 (released 2014/09/30) includes further bug fixes to cgo, the runtime package, and the nacl port.
+See the <a href="https://github.com/golang/go/commits/go1.3.3">change history</a> for details.
+</p>
+
+<h2 id="go1.2">go1.2 (released 2013/12/01)</h2>
+
+<p>
+Go 1.2 is a major release of Go.
+Read the <a href="/doc/go1.2">Go 1.2 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.2.minor">Minor revisions</h3>
+
+<p>
+go1.2.1 (released 2014/03/02) includes bug fixes to the <code>runtime</code>, <code>net</code>, and <code>database/sql</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.2.1">change history</a> for details.
+</p>
+
+<p>
+go1.2.2 (released 2014/05/05) includes a
+<a href="https://github.com/golang/go/commits/go1.2.2">security fix</a>
+that affects the tour binary included in the binary distributions (thanks to Guillaume T).
+</p>
+
+<h2 id="go1.1">go1.1 (released 2013/05/13)</h2>
+
+<p>
+Go 1.1 is a major release of Go.
+Read the <a href="/doc/go1.1">Go 1.1 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.1.minor">Minor revisions</h3>
+
+<p>
+go1.1.1 (released 2013/06/13) includes several compiler and runtime bug fixes.
+See the <a href="https://github.com/golang/go/commits/go1.1.1">change history</a> for details.
+</p>
+
+<p>
+go1.1.2 (released 2013/08/13) includes fixes to the <code>gc</code> compiler
+and <code>cgo</code>, and the <code>bufio</code>, <code>runtime</code>,
+<code>syscall</code>, and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.1.2">change history</a> for details.
+If you use package syscall's <code>Getrlimit</code> and <code>Setrlimit</code>
+functions under Linux on the ARM or 386 architectures, please note change
+<a href="//golang.org/cl/11803043">11803043</a>
+that fixes <a href="//golang.org/issue/5949">issue 5949</a>.
+</p>
+
+<h2 id="go1">go1 (released 2012/03/28)</h2>
+
+<p>
+Go 1 is a major release of Go that will be stable in the long term.
+Read the <a href="/doc/go1.html">Go 1 Release Notes</a> for more information.
+</p>
+
+<p>
+It is intended that programs written for Go 1 will continue to compile and run
+correctly, unchanged, under future versions of Go 1.
+Read the <a href="/doc/go1compat.html">Go 1 compatibility document</a> for more
+about the future of Go 1.
+</p>
+
+<p>
+The go1 release corresponds to
+<code><a href="weekly.html#2012-03-27">weekly.2012-03-27</a></code>.
+</p>
+
+<h3 id="go1.minor">Minor revisions</h3>
+
+<p>
+go1.0.1 (released 2012/04/25) was issued to
+<a href="//golang.org/cl/6061043">fix</a> an
+<a href="//golang.org/issue/3545">escape analysis bug</a>
+that can lead to memory corruption.
+It also includes several minor code and documentation fixes.
+</p>
+
+<p>
+go1.0.2 (released 2012/06/13) was issued to fix two bugs in the implementation
+of maps using struct or array keys:
+<a href="//golang.org/issue/3695">issue 3695</a> and
+<a href="//golang.org/issue/3573">issue 3573</a>.
+It also includes many minor code and documentation fixes.
+</p>
+
+<p>
+go1.0.3 (released 2012/09/21) includes minor code and documentation fixes.
+</p>
+
+<p>
+See the <a href="https://github.com/golang/go/commits/release-branch.go1">go1 release branch history</a> for the complete list of changes.
+</p>
+
+<h2 id="pre.go1">Older releases</h2>
+
+<p>
+See the <a href="pre_go1.html">Pre-Go 1 Release History</a> page for notes
+on earlier releases.
+</p>
+

doc/diagnostics.html

@@ -50,7 +50,7 @@ trace. Use tools in isolation to get more precise info.
 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/README.md">pprof visualization tool</a>.
+<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
@@ -127,7 +127,7 @@ so it is recommended to collect only a single profile at a time.
 <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/README.md">go tool pprof</a></code>.
+<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>
@@ -456,15 +456,3 @@ 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>
-
-<p>The GODEBUG environmental variable can be used to disable use of
-instruction set extensions in the standard library and runtime.</p>
-
-<ul>
-<li>GODEBUG=cpu.all=off disables the use of all optional
-instruction set extensions.</li>
-<li>GODEBUG=cpu.<em>extension</em>=off disables use of instructions from the
-specified instruction set extension.<br>
-<em>extension</em> is the lower case name for the instruction set extension
-such as <em>sse41</em> or <em>avx</em>.</li>
-</ul>

doc/docs.html

@@ -0,0 +1,232 @@
+<!--{
+	"Title": "Documentation",
+	"Path": "/doc/",
+	"Template": true
+}-->
+
+<p>
+The Go programming language is an open source project to make programmers more
+productive.
+</p>
+
+<p>
+Go is expressive, concise, clean, and efficient. Its concurrency
+mechanisms make it easy to write programs that get the most out of multicore
+and networked machines, while its novel type system enables flexible and
+modular program construction. Go compiles quickly to machine code yet has the
+convenience of garbage collection and the power of run-time reflection. It's a
+fast, statically typed, compiled language that feels like a dynamically typed,
+interpreted language.
+</p>
+
+<div id="manual-nav"></div>
+
+<h2>Installing Go</h2>
+
+<h3><a href="/doc/install">Getting Started</a></h3>
+<p>
+Instructions for downloading and installing the Go compilers, tools, and
+libraries.
+</p>
+
+
+<h2 id="learning">Learning Go</h2>
+
+<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>
+<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.
+</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.
+</p>
+
+<h3 id="effective_go"><a href="effective_go.html">Effective Go</a></h3>
+<p>
+A document that gives tips for writing clear, idiomatic Go code.
+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.
+</p>
+
+<h3 id="wiki"><a href="/wiki">The Go Wiki</a></h3>
+<p>A wiki maintained by the Go community.</p>
+
+<h4 id="learn_more">More</h4>
+<p>
+See the <a href="/wiki/Learn">Learn</a> page at the <a href="/wiki">Wiki</a>
+for more Go learning resources.
+</p>
+
+
+<h2 id="references">References</h2>
+
+<h3 id="pkg"><a href="/pkg/">Package Documentation</a></h3>
+<p>
+The documentation for the Go standard library.
+</p>
+
+<h3 id="cmd"><a href="/doc/cmd">Command Documentation</a></h3>
+<p>
+The documentation for the Go tools.
+</p>
+
+<h3 id="spec"><a href="/ref/spec">Language Specification</a></h3>
+<p>
+The official Go Language specification.
+</p>
+
+<h3 id="go_mem"><a href="/ref/mem">The Go Memory Model</a></h3>
+<p>
+A document that specifies the conditions under which reads of a variable in
+one goroutine can be guaranteed to observe values produced by writes to the
+same variable in a different goroutine.
+</p>
+
+<h3 id="release"><a href="/doc/devel/release.html">Release History</a></h3>
+<p>A summary of the changes between Go releases.</p>
+
+
+<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>
+Guided tours of Go programs.
+</p>
+<ul>
+<li><a href="/doc/codewalk/functions">First-Class Functions in Go</a></li>
+<li><a href="/doc/codewalk/markov">Generating arbitrary text: a Markov chain algorithm</a></li>
+<li><a href="/doc/codewalk/sharemem">Share Memory by Communicating</a></li>
+<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>
+<li><a href="/blog/gos-declaration-syntax">Go's Declaration Syntax</a></li>
+<li><a href="/blog/defer-panic-and-recover">Defer, Panic, and Recover</a></li>
+<li><a href="/blog/go-concurrency-patterns-timing-out-and">Go Concurrency Patterns: Timing out, moving on</a></li>
+<li><a href="/blog/go-slices-usage-and-internals">Go Slices: usage and internals</a></li>
+<li><a href="/blog/gif-decoder-exercise-in-go-interfaces">A GIF decoder: an exercise in Go interfaces</a></li>
+<li><a href="/blog/error-handling-and-go">Error Handling and Go</a></li>
+<li><a href="/blog/organizing-go-code">Organizing Go code</a></li>
+</ul>
+
+<h4>Packages</h4>
+<ul>
+<li><a href="/blog/json-and-go">JSON and Go</a> - using the <a href="/pkg/encoding/json/">json</a> package.</li>
+<li><a href="/blog/gobs-of-data">Gobs of data</a> - the design and use of the <a href="/pkg/encoding/gob/">gob</a> package.</li>
+<li><a href="/blog/laws-of-reflection">The Laws of Reflection</a> - the fundamentals of the <a href="/pkg/reflect/">reflect</a> package.</li>
+<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="/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="/blog/race-detector">Introducing the Go Race Detector</a> - an introduction to the race detector.</li>
+{{end}}
+</ul>
+
+<h4 id="articles_more">More</h4>
+<p>
+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"/>
+
+<h3 id="video_tour_of_go"><a href="http://research.swtch.com/gotour">A Video Tour of Go</a></h3>
+<p>
+Three things that make Go fast, fun, and productive:
+interfaces, reflection, and concurrency. Builds a toy web crawler to
+demonstrate these.
+</p>
+
+<h3 id="go_code_that_grows"><a href="//vimeo.com/53221560">Code that grows with grace</a></h3>
+<p>
+One of Go's key design goals is code adaptability; that it should be easy to take a simple design and build upon it in a clean and natural way. In this talk Andrew Gerrand describes a simple "chat roulette" server that matches pairs of incoming TCP connections, and then use Go's concurrency mechanisms, interfaces, and standard library to extend it with a web interface and other features. While the function of the program changes dramatically, Go's flexibility preserves the original design as it grows.
+</p>
+
+<h3 id="go_concurrency_patterns"><a href="//www.youtube.com/watch?v=f6kdp27TYZs">Go Concurrency Patterns</a></h3>
+<p>
+Concurrency is the key to designing high performance network services. Go's concurrency primitives (goroutines and channels) provide a simple and efficient means of expressing concurrent execution. In this talk we see how tricky concurrency problems can be solved gracefully with simple Go code.
+</p>
+
+<h3 id="advanced_go_concurrency_patterns"><a href="//www.youtube.com/watch?v=QDDwwePbDtw">Advanced Go Concurrency Patterns</a></h3>
+<p>
+This talk expands on the <i>Go Concurrency Patterns</i> talk to dive deeper into Go's concurrency primitives.
+</p>
+
+<h4 id="talks_more">More</h4>
+<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>
+
+<p>
+See the <a href="/wiki/NonEnglish">NonEnglish</a> page
+at the <a href="/wiki">Wiki</a> for localized
+documentation.
+</p>

doc/editors.html

@@ -9,7 +9,7 @@
   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="https://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
+  <a href="http://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
 </p>
 
 <h2 id="options">Options</h2>
@@ -20,7 +20,7 @@ editing, navigation, testing, and debugging experience.
 
 <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=golang.go">Visual Studio Code</a>:
+<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>
@@ -28,7 +28,7 @@ or as a plugin for IntelliJ IDEA Ultimate</li>
 </ul>
 
 <p>
-Note that these are only a few top solutions; a more comprehensive
+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.

doc/effective_go.html

@@ -246,16 +246,14 @@ func Compile(str string) (*Regexp, error) {
 
 <p>
 If every doc comment begins with the name of the item it describes,
-you can use the <a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol">doc</a>
-subcommand of the <a href="/cmd/go/">go</a> tool
-and run the output through <code>grep</code>.
+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>
-$ go doc -all regexp | grep -i parse
+$ godoc regexp | grep -i parse
 </pre>
 
 <p>
@@ -266,10 +264,10 @@ which recalls the word you're looking for.
 </p>
 
 <pre>
-$ go doc -all regexp | grep -i parse
+$ godoc regexp | grep parse
     Compile parses a regular expression and returns, if successful, a Regexp
-    MustCompile is like Compile but panics if the expression cannot be parsed.
     parsed. It simplifies safe initialization of global variables holding
+    cannot be parsed. It simplifies safe initialization of global variables
 $
 </pre>
 
@@ -624,7 +622,7 @@ if it has already been declared, provided:
 <li>this declaration is in the same scope as the existing declaration of <code>v</code>
 (if <code>v</code> is already declared in an outer scope, the declaration will create a new variable §),</li>
 <li>the corresponding value in the initialization is assignable to <code>v</code>, and</li>
-<li>there is at least one other variable that is created by the declaration.</li>
+<li>there is at least one other variable in the declaration that is being declared anew.</li>
 </ul>
 
 <p>
@@ -1404,11 +1402,11 @@ the moment, the following snippet would also read the first 32 bytes of the buff
     var err error
     for i := 0; i &lt; 32; i++ {
         nbytes, e := f.Read(buf[i:i+1])  // Read one byte.
-        n += nbytes
         if nbytes == 0 || e != nil {
             err = e
             break
         }
+        n += nbytes
     }
 </pre>
 <p>
@@ -1680,15 +1678,13 @@ maps.  Here is a print statement for the time zone map defined in the previous s
 fmt.Printf("%v\n", timeZone)  // or just fmt.Println(timeZone)
 </pre>
 <p>
-which gives output:
+which gives output
 </p>
 <pre>
-map[CST:-21600 EST:-18000 MST:-25200 PST:-28800 UTC:0]
+map[CST:-21600 PST:-28800 EST:-18000 UTC:0 MST:-25200]
 </pre>
 <p>
-For maps, <code>Printf</code> and friends sort the output lexicographically by key.
-</p>
-<p>
+For maps the keys may be output in any order, of course.
 When printing a struct, the modified format <code>%+v</code> annotates the
 fields of the structure with their names, and for any value the alternate
 format <code>%#v</code> prints the value in full Go syntax.
@@ -1712,7 +1708,7 @@ prints
 &amp;{7 -2.35 abc   def}
 &amp;{a:7 b:-2.35 c:abc     def}
 &amp;main.T{a:7, b:-2.35, c:"abc\tdef"}
-map[string]int{"CST":-21600, "EST":-18000, "MST":-25200, "PST":-28800, "UTC":0}
+map[string] int{"CST":-21600, "PST":-28800, "EST":-18000, "UTC":0, "MST":-25200}
 </pre>
 <p>
 (Note the ampersands.)
@@ -1735,7 +1731,7 @@ fmt.Printf(&quot;%T\n&quot;, timeZone)
 prints
 </p>
 <pre>
-map[string]int
+map[string] int
 </pre>
 <p>
 If you want to control the default format for a custom type, all that's required is to define
@@ -2108,14 +2104,12 @@ In this contrived example <code>Sequence</code> satisfies both.
 
 <p>
 The <code>String</code> method of <code>Sequence</code> is recreating the
-work that <code>Sprint</code> already does for slices.
-(It also has complexity O(N²), which is poor.) We can share the
-effort (and also speed it up) if we convert the <code>Sequence</code> to a plain
+work that <code>Sprint</code> already does for slices.  We can share the
+effort if we convert the <code>Sequence</code> to a plain
 <code>[]int</code> before calling <code>Sprint</code>.
 </p>
 <pre>
 func (s Sequence) String() string {
-    s = s.Copy()
     sort.Sort(s)
     return fmt.Sprint([]int(s))
 }
@@ -2142,7 +2136,6 @@ type Sequence []int
 
 // Method for printing - sorts the elements before printing
 func (s Sequence) String() string {
-    s = s.Copy()
     sort.IntSlice(s).Sort()
     return fmt.Sprint([]int(s))
 }
@@ -2282,8 +2275,8 @@ The  <code>crypto/cipher</code> interfaces look like this:
 <pre>
 type Block interface {
     BlockSize() int
-    Encrypt(dst, src []byte)
-    Decrypt(dst, src []byte)
+    Encrypt(src, dst []byte)
+    Decrypt(src, dst []byte)
 }
 
 type Stream interface {
@@ -2336,9 +2329,10 @@ of the request from the client.
 </p>
 <p>
 For brevity, let's ignore POSTs and assume HTTP requests are always
-GETs; that simplification does not affect the way the handlers are set up.
-Here's a trivial implementation of a handler to count the number of times
-the page is visited.
+GETs; that simplification does not affect the way the handlers are
+set up.  Here's a trivial but complete implementation of a handler to
+count the number of times the
+page is visited.
 </p>
 <pre>
 // Simple counter server.
@@ -2354,11 +2348,6 @@ func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 <p>
 (Keeping with our theme, note how <code>Fprintf</code> can print to an
 <code>http.ResponseWriter</code>.)
-In a real server, access to <code>ctr.n</code> would need protection from
-concurrent access.
-See the <code>sync</code> and <code>atomic</code> packages for suggestions.
-</p>
-<p>
 For reference, here's how to attach such a server to a node on the URL tree.
 </p>
 <pre>
@@ -2699,7 +2688,8 @@ type ReadWriter interface {
 <p>
 This says just what it looks like: A <code>ReadWriter</code> can do
 what a <code>Reader</code> does <em>and</em> what a <code>Writer</code>
-does; it is a union of the embedded interfaces.
+does; it is a union of the embedded interfaces (which must be disjoint
+sets of methods).
 Only interfaces can be embedded within interfaces.
 </p>
 <p>
@@ -2772,7 +2762,7 @@ type Job struct {
 }
 </pre>
 <p>
-The <code>Job</code> type now has the <code>Print</code>, <code>Printf</code>, <code>Println</code>
+The <code>Job</code> type now has the <code>Log</code>, <code>Logf</code>
 and other
 methods of <code>*log.Logger</code>.  We could have given the <code>Logger</code>
 a field name, of course, but it's not necessary to do so.  And now, once
@@ -2780,7 +2770,7 @@ initialized, we can
 log to the <code>Job</code>:
 </p>
 <pre>
-job.Println("starting now...")
+job.Log("starting now...")
 </pre>
 <p>
 The <code>Logger</code> is a regular field of the <code>Job</code> struct,
@@ -2807,8 +2797,8 @@ we would write <code>job.Logger</code>,
 which would be useful if we wanted to refine the methods of <code>Logger</code>.
 </p>
 <pre>
-func (job *Job) Printf(format string, args ...interface{}) {
-    job.Logger.Printf("%q: %s", job.Command, fmt.Sprintf(format, args...))
+func (job *Job) Logf(format string, args ...interface{}) {
+    job.Logger.Logf("%q: %s", job.Command, fmt.Sprintf(format, args...))
 }
 </pre>
 <p>

doc/gccgo_contribute.html

@@ -22,7 +22,7 @@ file HACKING</a> in the gofrontend repository.
 You must follow the <a href="/doc/contribute.html#copyright">Go copyright
 rules</a> for all changes to the gccgo frontend and the associated
 libgo library.  Code that is part of GCC rather than gccgo must follow
-the general <a href="https://gcc.gnu.org/contribute.html">GCC
+the general <a href="http://gcc.gnu.org/contribute.html">GCC
 contribution rules</a>.
 </p>
 
@@ -30,9 +30,9 @@ contribution rules</a>.
 
 <p>
 The master sources for the gccgo frontend may be found at
-<a href="https://go.googlesource.com/gofrontend">https://go.googlesource.com/gofrontend</a>.
+<a href="http://go.googlesource.com/gofrontend">http://go.googlesource.com/gofrontend</a>.
 They are mirrored
-at <a href="https://github.com/golang/gofrontend">https://github.com/golang/gofrontend</a>.
+at <a href="http://github.com/golang/gofrontend">http://github.com/golang/gofrontend</a>.
 The master sources are not buildable by themselves, but only in
 conjunction with GCC (in the future, other compilers may be
 supported).  Changes made to the gccgo frontend are also applied to
@@ -105,7 +105,7 @@ or <code>gcc/testsuite/go.dg</code> directories in the GCC repository.
 <p>
 Changes to the Go frontend should follow the same process as for the
 main Go repository, only for the <code>gofrontend</code> project and
-the <code>gofrontend-dev@googlegroups.com</code> mailing list
+the <code>gofrontend-dev@googlegroups.com</code> mailing list 
 rather than the <code>go</code> project and the
 <code>golang-dev@googlegroups.com</code> mailing list.  Those changes
 will then be merged into the GCC sources.

doc/gccgo_install.html

@@ -5,11 +5,11 @@
 
 <p>
 This document explains how to use gccgo, a compiler for
-the Go language. The gccgo compiler is a new frontend
-for GCC, the widely used GNU compiler. Although the
+the Go language.  The gccgo compiler is a new frontend
+for GCC, the widely used GNU compiler.  Although the
 frontend itself is under a BSD-style license, gccgo is
 normally used as part of GCC and is then covered by
-the <a href="https://www.gnu.org/licenses/gpl.html">GNU General Public
+the <a href="http://www.gnu.org/licenses/gpl.html">GNU General Public
 License</a> (the license covers gccgo itself as part of GCC; it
 does not cover code generated by gccgo).
 </p>
@@ -24,10 +24,10 @@ compiler.
 
 <p>
 The simplest way to install gccgo is to install a GCC binary release
-built to include Go support. GCC binary releases are available from
-<a href="https://gcc.gnu.org/install/binaries.html">various
+built to include Go support.  GCC binary releases are available from
+<a href="http://gcc.gnu.org/install/binaries.html">various
 websites</a> and are typically included as part of GNU/Linux
-distributions. We expect that most people who build these binaries
+distributions.  We expect that most people who build these binaries
 will include Go support.
 </p>
 
@@ -38,7 +38,7 @@ The GCC 4.7.1 release and all later 4.7 releases include a complete
 
 <p>
 Due to timing, the GCC 4.8.0 and 4.8.1 releases are close to but not
-identical to Go 1.1. The GCC 4.8.2 release includes a complete Go
+identical to Go 1.1.  The GCC 4.8.2 release includes a complete Go
 1.1.2 implementation.
 </p>
 
@@ -48,51 +48,49 @@ The GCC 4.9 releases include a complete Go 1.2 implementation.
 
 <p>
 The GCC 5 releases include a complete implementation of the Go 1.4
-user libraries. The Go 1.4 runtime is not fully merged, but that
+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
+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
+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 include a complete implementation of the Go 1.10.1
-release. The Go 1.10 runtime has now been fully merged into the GCC
-development sources, and concurrent garbage collection is fully
-supported.
-</p>
-
-<p>
-The GCC 9 releases include a complete implementation of the Go 1.12.2
-release.
+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>
-If you cannot use a release, or prefer to build gccgo for yourself, the
-gccgo source code is accessible via Git. The GCC web site has
-<a href="https://gcc.gnu.org/git.html">instructions for getting the GCC
-source code</a>. The gccgo source code is included. As a convenience, a
-stable version of the Go support is available in the
-<code>devel/gccgo</code> branch of the main GCC code repository:
-<code>git://gcc.gnu.org/git/gcc.git</code>.
+If you cannot use a release, or prefer to build gccgo for
+yourself, 
+the gccgo source code is accessible via Subversion.  The
+GCC web site
+has <a href="http://gcc.gnu.org/svn.html">instructions for getting the
+GCC source code</a>.  The gccgo source code is included.  As a
+convenience, a stable version of the Go support is available in
+a branch of the main GCC code
+repository: <code>svn://gcc.gnu.org/svn/gcc/branches/gccgo</code>.
 This branch is periodically updated with stable Go compiler sources.
 </p>
 
 <p>
 Note that although <code>gcc.gnu.org</code> is the most convenient way
 to get the source code for the Go frontend, it is not where the master
-sources live. If you want to contribute changes to the Go frontend
+sources live.  If you want to contribute changes to the Go frontend
 compiler, see <a href="/doc/gccgo_contribute.html">Contributing to
 gccgo</a>.
 </p>
@@ -102,16 +100,16 @@ gccgo</a>.
 
 <p>
 Building gccgo is just like building GCC
-with one or two additional options. See
-the <a href="https://gcc.gnu.org/install/">instructions on the gcc web
-site</a>. When you run <code>configure</code>, add the
+with one or two additional options.  See
+the <a href="http://gcc.gnu.org/install/">instructions on the gcc web
+site</a>.  When you run <code>configure</code>, add the
 option <code>--enable-languages=c,c++,go</code> (along with other
-languages you may want to build). If you are targeting a 32-bit x86,
+languages you may want to build).  If you are targeting a 32-bit x86,
 then you will want to build gccgo to default to
 supporting locked compare and exchange instructions; do this by also
 using the <code>configure</code> option <code>--with-arch=i586</code>
 (or a newer architecture, depending on where you need your programs to
-run). If you are targeting a 64-bit x86, but sometimes want to use
+run).  If you are targeting a 64-bit x86, but sometimes want to use
 the <code>-m32</code> option, then use the <code>configure</code>
 option <code>--with-arch-32=i586</code>.
 </p>
@@ -120,27 +118,30 @@ option <code>--with-arch-32=i586</code>.
 
 <p>
 On x86 GNU/Linux systems the gccgo compiler is able to
-use a small discontiguous stack for goroutines. This permits programs
+use a small discontiguous stack for goroutines.  This permits programs
 to run many more goroutines, since each goroutine can use a relatively
-small stack. Doing this requires using the gold linker version 2.22
-or later. You can either install GNU binutils 2.22 or later, or you
+small stack.  Doing this requires using the gold linker version 2.22
+or later.  You can either install GNU binutils 2.22 or later, or you
 can build gold yourself.
 </p>
 
 <p>
 To build gold yourself, build the GNU binutils,
 using <code>--enable-gold=default</code> when you run
-the <code>configure</code> script. Before building, you must install
-the flex and bison packages. A typical sequence would look like
+the <code>configure</code> script.  Before building, you must install
+the flex and bison packages.  A typical sequence would look like
 this (you can replace <code>/opt/gold</code> with any directory to
 which you have write access):
 </p>
 
 <pre>
-git clone git://sourceware.org/git/binutils-gdb.git
+cvs -z 9 -d :pserver:anoncvs@sourceware.org:/cvs/src login
+[password is "anoncvs"]
+[The next command will create a directory named src, not binutils]
+cvs -z 9 -d :pserver:anoncvs@sourceware.org:/cvs/src co binutils
 mkdir binutils-objdir
 cd binutils-objdir
-../binutils-gdb/configure --enable-gold=default --prefix=/opt/gold
+../src/configure --enable-gold=default --prefix=/opt/gold
 make
 make install
 </pre>
@@ -155,8 +156,8 @@ option <code>--with-ld=<var>GOLD_BINARY</var></code>.
 <p>
 A number of prerequisites are required to build GCC, as
 described on
-the <a href="https://gcc.gnu.org/install/prerequisites.html">gcc web
-site</a>. It is important to install all the prerequisites before
+the <a href="http://gcc.gnu.org/install/prerequisites.html">gcc web
+site</a>.  It is important to install all the prerequisites before
 running the gcc <code>configure</code> script.
 The prerequisite libraries can be conveniently downloaded using the
 script <code>contrib/download_prerequisites</code> in the GCC sources.
@@ -171,7 +172,7 @@ described above):
 </p>
 
 <pre>
-git clone --branch devel/gccgo git://gcc.gnu.org/git/gcc.git gccgo
+svn checkout svn://gcc.gnu.org/svn/gcc/branches/gccgo gccgo
 mkdir objdir
 cd objdir
 ../gccgo/configure --prefix=/opt/gccgo --enable-languages=c,c++,go --with-ld=/opt/gold/bin/ld
@@ -182,7 +183,7 @@ make install
 <h2 id="Using_gccgo">Using gccgo</h2>
 
 <p>
-The gccgo compiler works like other gcc frontends. As of GCC 5 the gccgo
+The gccgo compiler works like other gcc frontends.  As of GCC 5 the gccgo
 installation also includes a version of the <code>go</code> command,
 which may be used to build Go programs as described at
 <a href="https://golang.org/cmd/go">https://golang.org/cmd/go</a>.
@@ -207,7 +208,7 @@ gccgo -o file file.o
 
 <p>
 To run the resulting file, you will need to tell the program where to
-find the compiled Go packages. There are a few ways to do this:
+find the compiled Go packages.  There are a few ways to do this:
 </p>
 
 <ul>
@@ -225,11 +226,11 @@ export LD_LIBRARY_PATH
 
 <p>
 Here <code>${prefix}</code> is the <code>--prefix</code> option used
-when building gccgo. For a binary install this is
-normally <code>/usr</code>. Whether to use <code>lib</code>
+when building gccgo.  For a binary install this is
+normally <code>/usr</code>.  Whether to use <code>lib</code>
 or <code>lib64</code> depends on the target.
 Typically <code>lib64</code> is correct for x86_64 systems,
-and <code>lib</code> is correct for other systems. The idea is to
+and <code>lib</code> is correct for other systems.  The idea is to
 name the directory where <code>libgo.so</code> is found.
 </p>
 
@@ -324,9 +325,9 @@ objcopy -j .go_export FILE.o FILE.gox
 
 <p>
 The gccgo compiler will look in the current
-directory for import files. In more complex scenarios you
+directory for import files.  In more complex scenarios you
 may pass the <code>-I</code> or <code>-L</code> option to
-gccgo. Both options take directories to search. The
+gccgo.  Both options take directories to search. The
 <code>-L</code> option is also passed to the linker.
 </p>
 
@@ -347,11 +348,11 @@ gccgo -o main main.o mypackage.o   # Explicitly links with mypackage.o
 
 <p>
 If you use the <code>-g</code> option when you compile, you can run
-<code>gdb</code> on your executable. The debugger has only limited
-knowledge about Go. You can set breakpoints, single-step,
-etc. You can print variables, but they will be printed as though they
-had C/C++ types. For numeric types this doesn't matter. Go strings
-and interfaces will show up as two-element structures. Go
+<code>gdb</code> on your executable.  The debugger has only limited
+knowledge about Go.  You can set breakpoints, single-step,
+etc.  You can print variables, but they will be printed as though they
+had C/C++ types.  For numeric types this doesn't matter.  Go strings
+and interfaces will show up as two-element structures.  Go
 maps and channels are always represented as C pointers to run-time
 structures.
 </p>
@@ -398,7 +399,7 @@ assuming that the C pointer does point to 10 elements.
 </p>
 
 <p>
-A slice in Go is a structure. The current definition is
+A slice in Go is a structure.  The current definition is
 (this is <b style="color: red;">subject to change</b>):
 </p>
 
@@ -412,15 +413,15 @@ struct __go_slice {
 
 <p>
 The type of a Go function is a pointer to a struct (this is
-<b style="color: red;">subject to change</b>). The first field in the
+<b style="color: red;">subject to change</b>).  The first field in the
 struct points to the code of the function, which will be equivalent to
 a pointer to a C function whose parameter types are equivalent, with
-an additional trailing parameter. The trailing parameter is the
+an additional trailing parameter.  The trailing parameter is the
 closure, and the argument to pass is a pointer to the Go function
 struct.
 
 When a Go function returns more than one value, the C function returns
-a struct. For example, these functions are roughly equivalent:
+a struct.  For example, these functions are roughly equivalent:
 </p>
 
 <pre>
@@ -457,7 +458,7 @@ pointer while the C function is still using it.
 <p>
 Go code can call C functions directly using a Go extension implemented
 in gccgo: a function declaration may be preceded by
-<code>//extern NAME</code>. For example, here is how the C function
+<code>//extern NAME</code>.  For example, here is how the C function
 <code>open</code> can be declared in Go:
 </p>
 
@@ -517,11 +518,11 @@ the <code>-gccgo</code> option instead.
 
 <p>
 Compile your C code as usual, and add the option
-<code>-fdump-go-spec=<var>FILENAME</var></code>. This will create the
+<code>-fdump-go-spec=<var>FILENAME</var></code>.  This will create the
 file <code><var>FILENAME</var></code> as a side effect of the
-compilation. This file will contain Go declarations for the types,
-variables and functions declared in the C code. C types that can not
-be represented in Go will be recorded as comments in the Go code. The
+compilation.  This file will contain Go declarations for the types,
+variables and functions declared in the C code.  C types that can not
+be represented in Go will be recorded as comments in the Go code.  The
 generated file will not have a <code>package</code> declaration, but
 can otherwise be compiled directly by gccgo.
 </p>

doc/go1.10.html

@@ -12,7 +12,7 @@ Do not send CLs removing the interior tags from such phrases.
 -->
 
 <style>
-  main ul li { margin: 0.5em 0; }
+ul li { margin: 0.5em 0; }
 </style>
 
 <h2 id="introduction">Introduction to Go 1.10</h2>
@@ -30,7 +30,7 @@ adds <a href="#test">caching of successful test results</a>,
 runs <a href="#test-vet">vet automatically during tests</a>,
 and
 permits <a href="#cgo">passing string values directly between Go and C using cgo</a>.
-A new <a href="#cgo">hard-coded set of safe compiler options</a> may cause
+A new <a href="#cgo">compiler option whitelist</a> may cause
 unexpected <a href="https://golang.org/s/invalidflag"><code>invalid
 flag</code></a> errors in code that built successfully with older
 releases.
@@ -267,7 +267,7 @@ and the <a href="/cmd/test2json/">test2json documentation</a>.
 
 <p>
 Options specified by cgo using <code>#cgo CFLAGS</code> and the like
-are now checked against a list of permitted options.
+are now checked against a whitelist of permitted options.
 This closes a security hole in which a downloaded package uses
 compiler options like
 <span style="white-space: nowrap"><code>-fplugin</code></span>

doc/go1.11.html

@@ -1,934 +0,0 @@
-<!--{
-	"Title": "Go 1.11 Release Notes",
-	"Path":  "/doc/go1.11",
-	"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.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.11</h2>
-
-<p>
-  The latest Go release, version 1.11, arrives six months after <a href="go1.10">Go 1.10</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are no changes to the language specification.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p> <!-- CL 94255, CL 115038, etc -->
-  As <a href="go1.10#ports">announced in the Go 1.10 release notes</a>, Go 1.11 now requires
-  OpenBSD 6.2 or later, macOS 10.10 Yosemite or later, or Windows 7 or later;
-  support for previous versions of these operating systems has been removed.
-</p>
-
-<p> <!-- CL 121657 -->
-  Go 1.11 supports the upcoming OpenBSD 6.4 release. Due to changes in
-  the OpenBSD kernel, older versions of Go will not work on OpenBSD 6.4.
-</p>
-
-<p>
-  There are <a href="https://golang.org/issue/25206">known issues</a> with NetBSD on i386 hardware.
-</p>
-
-<p><!-- CL 107935 -->
-  The race detector is now supported on <code>linux/ppc64le</code>
-  and, to a lesser extent, on <code>netbsd/amd64</code>. The NetBSD race detector support
-  has <a href="https://golang.org/issue/26403">known issues</a>.
-</p>
-
-<p><!-- CL 109255 -->
-  The memory sanitizer (<code>-msan</code>) is now supported on <code>linux/arm64</code>.
-</p>
-
-<p><!-- CL 93875 -->
-  The build modes <code>c-shared</code> and <code>c-archive</code> are now supported on
-  <code>freebsd/amd64</code>.
-</p>
-
-<p id="mips"><!-- CL 108475 -->
-  On 64-bit MIPS systems, the new environment variable settings
-  <code>GOMIPS64=hardfloat</code> (the default) and
-  <code>GOMIPS64=softfloat</code> select whether to use
-  hardware instructions or software emulation for floating-point computations.
-  For 32-bit systems, the environment variable is still <code>GOMIPS</code>,
-  as <a href="go1.10#mips">added in Go 1.10</a>.
-</p>
-
-<p><!-- CL 107475 -->
-  On soft-float ARM systems (<code>GOARM=5</code>), Go now uses a more
-  efficient software floating point interface. This is transparent to
-  Go code, but ARM assembly that uses floating-point instructions not
-  guarded on GOARM will break and must be ported to
-  the <a href="https://golang.org/cl/107475">new interface</a>.
-</p>
-
-<p><!-- CL 94076 -->
-  Go 1.11 on ARMv7 no longer requires a Linux kernel configured
-  with <code>KUSER_HELPERS</code>. This setting is enabled in default
-  kernel configurations, but is sometimes disabled in stripped-down
-  configurations.
-</p>
-
-<h3 id="wasm">WebAssembly</h3>
-<p>
-  Go 1.11 adds an experimental port to <a href="https://webassembly.org">WebAssembly</a>
-  (<code>js/wasm</code>).
-</p>
-<p>
-  Go programs currently compile to one WebAssembly module that
-  includes the Go runtime for goroutine scheduling, garbage
-  collection, maps, etc.
-  As a result, the resulting size is at minimum around
-  2 MB, or 500 KB compressed. Go programs can call into JavaScript
-  using the new experimental
-  <a href="/pkg/syscall/js/"><code>syscall/js</code></a> package.
-  Binary size and interop with other languages has not yet been a
-  priority but may be addressed in future releases.
-</p>
-<p>
-  As a result of the addition of the new <code>GOOS</code> value
-  "<code>js</code>" and <code>GOARCH</code> value "<code>wasm</code>",
-  Go files named <code>*_js.go</code> or <code>*_wasm.go</code> will
-  now be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
-  tools</a> except when those GOOS/GOARCH values are being used.
-  If you have existing filenames matching those patterns, you will need to rename them.
-</p>
-<p>
-  More information can be found on the
-  <a href="https://golang.org/wiki/WebAssembly">WebAssembly wiki page</a>.
-</p>
-
-<h3 id="riscv">RISC-V GOARCH values reserved</h3>
-<p><!-- CL 106256 -->
-  The main Go compiler does not yet support the RISC-V architecture <!-- is gonna change everything -->
-  but we've reserved the <code>GOARCH</code> values
-  "<code>riscv</code>" and "<code>riscv64</code>", as used by Gccgo,
-  which does support RISC-V. This means that Go files
-  named <code>*_riscv.go</code> will now also
-  be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
-  tools</a> except when those GOOS/GOARCH values are being used.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="modules">Modules, package versioning, and dependency management</h3>
-<p>
-  Go 1.11 adds preliminary support for a <a href="/cmd/go/#hdr-Modules__module_versions__and_more">new concept called “modules,”</a>
-  an alternative to GOPATH with integrated support for versioning and
-  package distribution.
-  Using modules, developers are no longer confined to working inside GOPATH,
-  version dependency information is explicit yet lightweight,
-  and builds are more reliable and reproducible.
-</p>
-
-<p>
-  Module support is considered experimental.
-  Details are likely to change in response to feedback from Go 1.11 users,
-  and we have more tools planned.
-  Although the details of module support may change, projects that convert
-  to modules using Go 1.11 will continue to work with Go 1.12 and later.
-  If you encounter bugs using modules,
-  please <a href="https://golang.org/issue/new">file issues</a>
-  so we can fix them. For more information, see the
-  <a href="/cmd/go#hdr-Modules__module_versions__and_more"><code>go</code> command documentation</a>.
-</p>
-
-<h3 id="importpath">Import path restriction</h3>
-
-<p>
-  Because Go module support assigns special meaning to the
-  <code>@</code> symbol in command line operations,
-  the <code>go</code> command now disallows the use of
-  import paths containing <code>@</code> symbols.
-  Such import paths were never allowed by <code>go</code> <code>get</code>,
-  so this restriction can only affect users building
-  custom GOPATH trees by other means.
-</p>
-
-<h3 id="gopackages">Package loading</h3>
-
-<p>
-  The new package
-  <a href="https://godoc.org/golang.org/x/tools/go/packages"><code>golang.org/x/tools/go/packages</code></a>
-  provides a simple API for locating and loading packages of Go source code.
-  Although not yet part of the standard library, for many tasks it
-  effectively replaces the <a href="/pkg/go/build"><code>go/build</code></a>
-  package, whose API is unable to fully support modules.
-  Because it runs an external query command such as
-  <a href="/cmd/go/#hdr-List_packages"><code>go list</code></a>
-  to obtain information about Go packages, it enables the construction of
-  analysis tools that work equally well with alternative build systems
-  such as <a href="https://bazel.build">Bazel</a>
-  and <a href="https://buckbuild.com">Buck</a>.
-</p>
-
-<h3 id="gocache">Build cache requirement</h3>
-
-<p>
-  Go 1.11 will be the last release to support setting the environment
-  variable <code>GOCACHE=off</code> to disable the
-  <a href="/cmd/go/#hdr-Build_and_test_caching">build cache</a>,
-  introduced in Go 1.10.
-  Starting in Go 1.12, the build cache will be required,
-  as a step toward eliminating <code>$GOPATH/pkg</code>.
-  The module and package loading support described above
-  already require that the build cache be enabled.
-  If you have disabled the build cache to avoid problems you encountered,
-  please <a href="https://golang.org/issue/new">file an issue</a> to let us know about them.
-</p>
-
-<h3 id="compiler">Compiler toolchain</h3>
-
-<p><!-- CL 109918 -->
-  More functions are now eligible for inlining by default, including
-  functions that call <code>panic</code>.
-</p>
-
-<p><!-- CL 97375 -->
-  The compiler toolchain now supports column information
-  in <a href="/cmd/compile/#hdr-Compiler_Directives">line
-  directives</a>.
-</p>
-
-<p><!-- CL 106797 -->
-  A new package export data format has been introduced.
-  This should be transparent to end users, except for speeding up
-  build times for large Go projects.
-  If it does cause problems, it can be turned off again by
-  passing <code>-gcflags=all=-iexport=false</code> to
-  the <code>go</code> tool when building a binary.
-</p>
-
-<p><!-- CL 100459 -->
-  The compiler now rejects unused variables declared in a type switch
-  guard, such as <code>x</code> in the following example:
-</p>
-<pre>
-func f(v interface{}) {
-	switch x := v.(type) {
-	}
-}
-</pre>
-<p>
-  This was already rejected by both <code>gccgo</code>
-  and <a href="/pkg/go/types/">go/types</a>.
-</p>
-
-<h3 id="assembler">Assembler</h3>
-
-<p><!-- CL 113315 -->
-  The assembler for <code>amd64</code> now accepts AVX512 instructions.
-</p>
-
-<h3 id="debugging">Debugging</h3>
-
-<p><!-- CL 100738, CL 93664 -->
-  The compiler now produces significantly more accurate debug
-  information for optimized binaries, including variable location
-  information, line numbers, and breakpoint locations.
-
-  This should make it possible to debug binaries
-  compiled <em>without</em> <code>-N</code>&nbsp;<code>-l</code>.
-
-  There are still limitations to the quality of the debug information,
-  some of which are fundamental, and some of which will continue to
-  improve with future releases.
-</p>
-
-<p><!-- CL 118276 -->
-  DWARF sections are now compressed by default because of the expanded
-  and more accurate debug information produced by the compiler.
-
-  This is transparent to most ELF tools (such as debuggers on Linux
-  and *BSD) and is supported by the Delve debugger on all platforms,
-  but has limited support in the native tools on macOS and Windows.
-
-  To disable DWARF compression,
-  pass <code>-ldflags=-compressdwarf=false</code> to
-  the <code>go</code> tool when building a binary.
-</p>
-
-<p><!-- CL 109699 -->
-  Go 1.11 adds experimental support for calling Go functions from
-  within a debugger.
-
-  This is useful, for example, to call <code>String</code> methods
-  when paused at a breakpoint.
-
-  This is currently only supported by Delve (version 1.1.0 and up).
-</p>
-
-<h3 id="test">Test</h3>
-
-<p>
-  Since Go 1.10, the <code>go</code>&nbsp;<code>test</code> command runs
-  <code>go</code>&nbsp;<code>vet</code> on the package being tested,
-  to identify problems before running the test. Since <code>vet</code>
-  typechecks the code with <a href="/pkg/go/types/">go/types</a>
-  before running, tests that do not typecheck will now fail.
-
-  In particular, tests that contain an unused variable inside a
-  closure compiled with Go 1.10, because the Go compiler incorrectly
-  accepted them (<a href="https://golang.org/issues/3059">Issue #3059</a>),
-  but will now fail, since <code>go/types</code> correctly reports an
-  "unused variable" error in this case.
-</p>
-
-<p><!-- CL 102696 -->
-  The <code>-memprofile</code> flag
-  to <code>go</code>&nbsp;<code>test</code> now defaults to the
-  "allocs" profile, which records the total bytes allocated since the
-  test began (including garbage-collected bytes).
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<p><!-- CL 108555 -->
-  The <a href="/cmd/vet/"><code>go</code>&nbsp;<code>vet</code></a>
-  command now reports a fatal error when the package under analysis
-  does not typecheck. Previously, a type checking error simply caused
-  a warning to be printed, and <code>vet</code> to exit with status 1.
-</p>
-
-<p><!-- CL 108559 -->
-  Additionally, <a href="/cmd/vet"><code>go</code>&nbsp;<code>vet</code></a>
-  has become more robust when format-checking <code>printf</code> wrappers.
-  Vet now detects the mistake in this example:
-</p>
-
-<pre>
-func wrapper(s string, args ...interface{}) {
-	fmt.Printf(s, args...)
-}
-
-func main() {
-	wrapper("%s", 42)
-}
-</pre>
-
-<h3 id="trace">Trace</h3>
-
-<p><!-- CL 63274 -->
-  With the new <code>runtime/trace</code>
-  package's <a href="/pkg/runtime/trace/#hdr-User_annotation">user
-  annotation API</a>, users can record application-level information
-  in execution traces and create groups of related goroutines.
-  The <code>go</code>&nbsp;<code>tool</code>&nbsp;<code>trace</code>
-  command visualizes this information in the trace view and the new
-  user task/region analysis page.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-Since Go 1.10, cgo has translated some C pointer types to the Go
-type <code>uintptr</code>. These types include
-the <code>CFTypeRef</code> hierarchy in Darwin's CoreFoundation
-framework and the <code>jobject</code> hierarchy in Java's JNI
-interface. In Go 1.11, several improvements have been made to the code
-that detects these types. Code that uses these types may need some
-updating. See the <a href="go1.10.html#cgo">Go 1.10 release notes</a> for
-details. <!-- CL 126275, CL 127156, CL 122217, CL 122575, CL 123177 -->
-</p>
-
-<h3 id="go_command">Go command</h3>
-
-<p><!-- CL 126656 -->
-  The environment variable <code>GOFLAGS</code> may now be used
-  to set default flags for the <code>go</code> command.
-  This is useful in certain situations.
-  Linking can be noticeably slower on underpowered systems due to DWARF,
-  and users may want to set <code>-ldflags=-w</code> by default.
-  For modules, some users and CI systems will want vendoring always,
-  so they should set <code>-mod=vendor</code> by default.
-  For more information, see the <a href="/cmd/go/#hdr-Environment_variables"><code>go</code>
-  command documentation</a>.
-</p>
-
-<h3 id="godoc">Godoc</h3>
-
-<p>
-  Go 1.11 will be the last release to support <code>godoc</code>'s command-line interface.
-  In future releases, <code>godoc</code> will only be a web server. Users should use
-  <code>go</code> <code>doc</code> for command-line help output instead.
-</p>
-
-<p><!-- CL 85396, CL 124495 -->
-  The <code>godoc</code> web server now shows which version of Go introduced
-  new API features. The initial Go version of types, funcs, and methods are shown
-  right-aligned. For example, see <a href="/pkg/os/#UserCacheDir"><code>UserCacheDir</code></a>, with "1.11"
-  on the right side. For struct fields, inline comments are added when the struct field was
-  added in a Go version other than when the type itself was introduced.
-  For a struct field example, see
-  <a href="/pkg/net/http/httptrace/#ClientTrace.Got1xxResponse"><code>ClientTrace.Got1xxResponse</code></a>.
-</p>
-
-<h3 id="gofmt">Gofmt</h3>
-
-<p>
-  One minor detail of the default formatting of Go source code has changed.
-  When formatting expression lists with inline comments, the comments were
-  aligned according to a heuristic.
-  However, in some cases the alignment would be split up too easily, or
-  introduce too much whitespace.
-  The heuristic has been changed to behave better for human-written code.
-</p>
-
-<p>
-  Note that these kinds of minor updates to gofmt are expected from time to
-  time.
-  In general, systems that need consistent formatting of Go source code should
-  use a specific version of the <code>gofmt</code> binary.
-  See the <a href="/pkg/go/format/">go/format</a> package documentation for more
-  information.
-</p>
-
-<h3 id="run">Run</h3>
-
-<p>
-  <!-- CL 109341 -->
-  The <a href="/cmd/go/"><code>go</code>&nbsp;<code>run</code></a>
-  command now allows a single import path, a directory name or a
-  pattern matching a single package.
-  This allows <code>go</code>&nbsp;<code>run</code>&nbsp;<code>pkg</code> or <code>go</code>&nbsp;<code>run</code>&nbsp;<code>dir</code>, most importantly <code>go</code>&nbsp;<code>run</code>&nbsp;<code>.</code>
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 85887 -->
-  The runtime now uses a sparse heap layout so there is no longer a
-  limit to the size of the Go heap (previously, the limit was 512GiB).
-  This also fixes rare "address space conflict" failures in mixed Go/C
-  binaries or binaries compiled with <code>-race</code>.
-</p>
-
-<p><!-- CL 108679, CL 106156 -->
-  On macOS and iOS, the runtime now uses <code>libSystem.dylib</code> instead of
-  calling the kernel directly. This should make Go binaries more
-  compatible with future versions of macOS and iOS.
-  The <a href="/pkg/syscall">syscall</a> package still makes direct
-  system calls; fixing this is planned for a future release.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise
-statements about performance are difficult to make.  Most programs
-should run a bit faster, due to better generated code and
-optimizations in the core library.
-</p>
-
-<p><!-- CL 74851 -->
-There were multiple performance changes to the <code>math/big</code>
-package as well as many changes across the tree specific to <code>GOARCH=arm64</code>.
-</p>
-
-<h3 id="performance-compiler">Compiler toolchain</h3>
-
-<p><!-- CL 110055 -->
-  The compiler now optimizes map clearing operations of the form:
-</p>
-<pre>
-for k := range m {
-	delete(m, k)
-}
-</pre>
-
-<p><!-- CL 109517 -->
-  The compiler now optimizes slice extension of the form
-  <code>append(s,</code>&nbsp;<code>make([]T,</code>&nbsp;<code>n)...)</code>.
-</p>
-
-<p><!-- CL 100277, CL 105635, CL 109776 -->
-  The compiler now performs significantly more aggressive bounds-check
-  and branch elimination. Notably, it now recognizes transitive
-  relations, so if <code>i&lt;j</code> and <code>j&lt;len(s)</code>,
-  it can use these facts to eliminate the bounds check
-  for <code>s[i]</code>. It also understands simple arithmetic such
-  as <code>s[i-10]</code> and can recognize more inductive cases in
-  loops. Furthermore, the compiler now uses bounds information to more
-  aggressively optimize shift operations.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<p>
-  All of the changes to the standard library are minor.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<!-- CL 115095: https://golang.org/cl/115095: yes (`go test pkg` now always builds pkg even if there are no test files): cmd/go: output coverage report even if there are no test files -->
-<!-- CL 110395: https://golang.org/cl/110395: cmd/go, cmd/compile: use Windows response files to avoid arg length limits -->
-<!-- CL 112436: https://golang.org/cl/112436: cmd/pprof: add readline support similar to upstream -->
-
-
-<dl id="crypto"><dt><a href="/pkg/crypto/">crypto</a></dt>
-  <dd>
-    <p><!-- CL 64451 -->
-      Certain crypto operations, including
-      <a href="/pkg/crypto/ecdsa/#Sign"><code>ecdsa.Sign</code></a>,
-      <a href="/pkg/crypto/rsa/#EncryptPKCS1v15"><code>rsa.EncryptPKCS1v15</code></a> and
-      <a href="/pkg/crypto/rsa/#GenerateKey"><code>rsa.GenerateKey</code></a>,
-      now randomly read an extra byte of randomness to ensure tests don't rely on internal behavior.
-    </p>
-
-</dl><!-- crypto -->
-
-<dl id="crypto/cipher"><dt><a href="/pkg/crypto/cipher/">crypto/cipher</a></dt>
-  <dd>
-    <p><!-- CL 48510, CL 116435 -->
-      The new function <a href="/pkg/crypto/cipher/#NewGCMWithTagSize"><code>NewGCMWithTagSize</code></a>
-      implements Galois Counter Mode with non-standard tag lengths for compatibility with existing cryptosystems.
-    </p>
-
-</dl><!-- crypto/cipher -->
-
-<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
-  <dd>
-    <p><!-- CL 103876 -->
-      <a href="/pkg/crypto/rsa/#PublicKey"><code>PublicKey</code></a> now implements a
-      <a href="/pkg/crypto/rsa/#PublicKey.Size"><code>Size</code></a> method that
-      returns the modulus size in bytes.
-    </p>
-
-</dl><!-- crypto/rsa -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 85115 -->
-      <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>'s new
-      <a href="/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial"><code>ExportKeyingMaterial</code></a>
-      method allows exporting keying material bound to the
-      connection according to RFC 5705.
-    </p>
-
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 123355, CL 123695 -->
-      The deprecated, legacy behavior of treating the <code>CommonName</code> field as
-      a hostname when no Subject Alternative Names are present is now disabled when the CN is not a
-      valid hostname.
-      The <code>CommonName</code> can be completely ignored by adding the experimental value
-      <code>x509ignoreCN=1</code> to the <code>GODEBUG</code> environment variable.
-      When the CN is ignored, certificates without SANs validate under chains with name constraints
-      instead of returning <code>NameConstraintsWithoutSANs</code>.
-    </p>
-
-    <p><!-- CL 113475 -->
-      Extended key usage restrictions are again checked only if they appear in the <code>KeyUsages</code>
-      field of <a href="/pkg/crypto/x509/#VerifyOptions"><code>VerifyOptions</code></a>, instead of always being checked.
-      This matches the behavior of Go 1.9 and earlier.
-    </p>
-
-    <p><!-- CL 102699 -->
-      The value returned by <a href="/pkg/crypto/x509/#SystemCertPool"><code>SystemCertPool</code></a>
-      is now cached and might not reflect system changes between invocations.
-    </p>
-
-</dl><!-- crypto/x509 -->
-
-<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
-  <dd>
-    <p><!-- CL 112115 -->
-      More <a href="/pkg/debug/elf/#ELFOSABI_NONE"><code>ELFOSABI</code></a>
-      and <a href="/pkg/debug/elf/#EM_NONE"><code>EM</code></a>
-      constants have been added.
-    </p>
-
-</dl><!-- debug/elf -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 110561 -->
-      <code>Marshal</code> and <code><a href="/pkg/encoding/asn1/#Unmarshal">Unmarshal</a></code>
-      now support "private" class annotations for fields.
-    </p>
-
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/base32"><dt><a href="/pkg/encoding/base32/">encoding/base32</a></dt>
-  <dd>
-    <p><!-- CL 112516 -->
-      The decoder now consistently
-      returns <code>io.ErrUnexpectedEOF</code> for an incomplete
-      chunk. Previously it would return <code>io.EOF</code> in some
-      cases.
-    </p>
-
-</dl><!-- encoding/base32 -->
-
-<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
-  <dd>
-    <p><!-- CL 99696 -->
-      The <code>Reader</code> now rejects attempts to set
-      the <a href="/pkg/encoding/csv/#Reader.Comma"><code>Comma</code></a>
-      field to a double-quote character, as double-quote characters
-      already have a special meaning in CSV.
-    </p>
-
-</dl><!-- encoding/csv -->
-
-<!-- CL 100235 was reverted -->
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 121815 -->
-      The package has changed its behavior when a typed interface
-      value is passed to an implicit escaper function. Previously such
-      a value was written out as (an escaped form)
-      of <code>&lt;nil&gt;</code>. Now such values are ignored, just
-      as an untyped <code>nil</code> value is (and always has been)
-      ignored.
-    </p>
-
-</dl><!-- html/template -->
-
-<dl id="image/gif"><dt><a href="/pkg/image/gif/">image/gif</a></dt>
-  <dd>
-    <p><!-- CL 93076 -->
-      Non-looping animated GIFs are now supported. They are denoted by having a
-      <code><a href="/pkg/image/gif/#GIF.LoopCount">LoopCount</a></code> of -1.
-    </p>
-
-</dl><!-- image/gif -->
-
-<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
-  <dd>
-    <p><!-- CL 105675 -->
-      The <code><a href="/pkg/io/ioutil/#TempFile">TempFile</a></code>
-      function now supports specifying where the random characters in
-      the filename are placed. If the <code>prefix</code> argument
-      includes a "<code>*</code>", the random string replaces the
-      "<code>*</code>". For example, a <code>prefix</code> argument of "<code>myname.*.bat</code>" will
-      result in a random filename such as
-      "<code>myname.123456.bat</code>". If no "<code>*</code>" is
-      included the old behavior is retained, and the random digits are
-      appended to the end.
-    </p>
-
-</dl><!-- io/ioutil -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-
-    <p><!-- CL 108996 -->
-      <a href="/pkg/math/big/#Int.ModInverse"><code>ModInverse</code></a> now returns nil when g and n are not relatively prime. The result was previously undefined.
-    </p>
-
-</dl><!-- math/big -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p><!-- CL 121055 -->
-      The handling of form-data with missing/empty file names has been
-      restored to the behavior in Go 1.9: in the
-      <a href="/pkg/mime/multipart/#Form"><code>Form</code></a> for
-      the form-data part the value is available in
-      the <code>Value</code> field rather than the <code>File</code>
-      field. In Go releases 1.10 through 1.10.3 a form-data part with
-      a missing/empty file name and a non-empty "Content-Type" field
-      was stored in the <code>File</code> field.  This change was a
-      mistake in 1.10 and has been reverted to the 1.9 behavior.
-    </p>
-
-</dl><!-- mime/multipart -->
-
-<dl id="mime/quotedprintable"><dt><a href="/pkg/mime/quotedprintable/">mime/quotedprintable</a></dt>
-  <dd>
-    <p><!-- CL 121095 -->
-      To support invalid input found in the wild, the package now
-      permits non-ASCII bytes but does not validate their encoding.
-    </p>
-
-</dl><!-- mime/quotedprintable -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 72810 -->
-      The new <a href="/pkg/net/#ListenConfig"><code>ListenConfig</code></a> type and the new
-      <a href="/pkg/net/#Dialer.Control"><code>Dialer.Control</code></a> field permit
-      setting socket options before accepting and creating connections, respectively.
-    </p>
-
-    <p><!-- CL 76391 -->
-      The <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn</code></a> <code>Read</code>
-      and <code>Write</code> methods now work correctly on Windows.
-    </p>
-
-    <p><!-- CL 107715 -->
-      The <code>net</code> package now automatically uses the
-      <a href="http://man7.org/linux/man-pages/man2/splice.2.html"><code>splice</code> system call</a>
-      on Linux when copying data between TCP connections in
-      <a href="/pkg/net/#TCPConn.ReadFrom"><code>TCPConn.ReadFrom</code></a>, as called by
-      <a href="/pkg/io/#Copy"><code>io.Copy</code></a>. The result is faster, more efficient TCP proxying.
-    </p>
-
-    <p><!-- CL 108297 -->
-      The <a href="/pkg/net/#TCPConn.File"><code>TCPConn.File</code></a>,
-      <a href="/pkg/net/#UDPConn.File"><code>UDPConn.File</code></a>,
-      <a href="/pkg/net/#UnixCOnn.File"><code>UnixConn.File</code></a>,
-      and <a href="/pkg/net/#IPConn.File"><code>IPConn.File</code></a>
-      methods no longer put the returned <code>*os.File</code> into
-      blocking mode.
-    </p>
-
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 71272 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> type has a
-      new <a href="/pkg/net/http/#Transport.MaxConnsPerHost"><code>MaxConnsPerHost</code></a>
-      option that permits limiting the maximum number of connections
-      per host.
-    </p>
-
-    <p><!-- CL 79919 -->
-      The <a href="/pkg/net/http/#Cookie"><code>Cookie</code></a> type has a new
-      <a href="/pkg/net/http/#Cookie.SameSite"><code>SameSite</code></a> field
-      (of new type also named
-      <a href="/pkg/net/http/#SameSite"><code>SameSite</code></a>) to represent the new cookie attribute recently supported by most browsers.
-      The <code>net/http</code>'s <code>Transport</code> does not use the <code>SameSite</code>
-      attribute itself, but the package supports parsing and serializing the
-      attribute for browsers to use.
-    </p>
-
-    <p><!-- CL 81778 -->
-      It is no longer allowed to reuse a <a href="/pkg/net/http/#Server"><code>Server</code></a>
-      after a call to
-      <a href="/pkg/net/http/#Server.Shutdown"><code>Shutdown</code></a> or
-      <a href="/pkg/net/http/#Server.Close"><code>Close</code></a>. It was never officially supported
-      in the past and had often surprising behavior. Now, all future calls to the server's <code>Serve</code>
-      methods will return errors after a shutdown or close.
-    </p>
-
-    <!-- CL 89275 was reverted before Go 1.11 -->
-
-    <p><!-- CL 93296 -->
-      The constant <code>StatusMisdirectedRequest</code> is now defined for HTTP status code 421.
-    </p>
-
-    <p><!-- CL 123875 -->
-      The HTTP server will no longer cancel contexts or send on
-      <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
-      channels upon receiving pipelined HTTP/1.1 requests. Browsers do
-      not use HTTP pipelining, but some clients (such as
-      Debian's <code>apt</code>) may be configured to do so.
-    </p>
-
-    <p><!-- CL 115255 -->
-      <a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>, which is used by the
-      <a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport</code></a>, now
-      supports CIDR notation and ports in the <code>NO_PROXY</code> environment variable.
-    </p>
-
-</dl><!-- net/http -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 77410 -->
-      The
-      <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
-      has a new
-      <a href="/pkg/net/http/httputil/#ReverseProxy.ErrorHandler"><code>ErrorHandler</code></a>
-      option to permit changing how errors are handled.
-    </p>
-
-    <p><!-- CL 115135 -->
-      The <code>ReverseProxy</code> now also passes
-      "<code>TE:</code>&nbsp;<code>trailers</code>" request headers
-      through to the backend, as required by the gRPC protocol.
-    </p>
-
-</dl><!-- net/http/httputil -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 78835 -->
-      The new <a href="/pkg/os/#UserCacheDir"><code>UserCacheDir</code></a> function
-      returns the default root directory to use for user-specific cached data.
-    </p>
-
-    <p><!-- CL 94856 -->
-      The new <a href="/pkg/os/#ModeIrregular"><code>ModeIrregular</code></a>
-      is a <a href="/pkg/os/#FileMode"><code>FileMode</code></a> bit to represent
-      that a file is not a regular file, but nothing else is known about it, or that
-      it's not a socket, device, named pipe, symlink, or other file type for which
-      Go has a defined mode bit.
-    </p>
-
-    <p><!-- CL 99337 -->
-      <a href="/pkg/os/#Symlink"><code>Symlink</code></a> now works
-      for unprivileged users on Windows 10 on machines with Developer
-      Mode enabled.
-    </p>
-
-    <p><!-- CL 100077 -->
-      When a non-blocking descriptor is passed
-      to <a href="/pkg/os#NewFile"><code>NewFile</code></a>, the
-      resulting <code>*File</code> will be kept in non-blocking
-      mode. This means that I/O for that <code>*File</code> will use
-      the runtime poller rather than a separate thread, and that
-      the <a href="/pkg/os/#File.SetDeadline"><code>SetDeadline</code></a>
-      methods will work.
-    </p>
-
-</dl><!-- os -->
-
-<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
-  <dd>
-    <p><!-- CL 108376 -->
-      The new <a href="/pkg/os/signal/#Ignored"><code>Ignored</code></a> function reports
-      whether a signal is currently ignored.
-    </p>
-
-</dl><!-- os/signal -->
-
-<dl id="os/user"><dt><a href="/pkg/os/user/">os/user</a></dt>
-  <dd>
-    <p><!-- CL 92456 -->
-      The <code>os/user</code> package can now be built in pure Go
-      mode using the build tag "<code>osusergo</code>",
-      independent of the use of the environment
-      variable <code>CGO_ENABLED=0</code>. Previously the only way to use
-      the package's pure Go implementation was to disable <code>cgo</code>
-      support across the entire program.
-    </p>
-
-</dl><!-- os/user -->
-
-<!-- CL 101715 was reverted -->
-
-<dl id="pkg-runtime"><dt id="runtime-again"><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-
-    <p><!-- CL 70993 -->
-      Setting the <code>GODEBUG=tracebackancestors=<em>N</em></code>
-      environment variable now extends tracebacks with the stacks at
-      which goroutines were created, where <em>N</em> limits the
-      number of ancestor goroutines to report.
-    </p>
-
-</dl><!-- runtime -->
-
-<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
-  <dd>
-    <p><!-- CL 102696 -->
-      This release adds a new "allocs" profile type that profiles
-      total number of bytes allocated since the program began
-      (including garbage-collected bytes). This is identical to the
-      existing "heap" profile viewed in <code>-alloc_space</code> mode.
-      Now <code>go test -memprofile=...</code> reports an "allocs" profile
-      instead of "heap" profile.
-    </p>
-
-</dl><!-- runtime/pprof -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 87095 -->
-      The mutex profile now includes reader/writer contention
-      for <a href="/pkg/sync/#RWMutex"><code>RWMutex</code></a>.
-      Writer/writer contention was already included in the mutex
-      profile.
-    </p>
-
-</dl><!-- sync -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 106275 -->
-      On Windows, several fields were changed from <code>uintptr</code> to a new
-      <a href="/pkg/syscall/?GOOS=windows&GOARCH=amd64#Pointer"><code>Pointer</code></a>
-      type to avoid problems with Go's garbage collector. The same change was made
-      to the <a href="https://godoc.org/golang.org/x/sys/windows"><code>golang.org/x/sys/windows</code></a>
-      package. For any code affected, users should first migrate away from the <code>syscall</code>
-      package to the <code>golang.org/x/sys/windows</code> package, and then change
-      to using the <code>Pointer</code>, while obeying the
-      <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code> conversion rules</a>.
-    </p>
-
-    <p><!-- CL 118658 -->
-      On Linux, the <code>flags</code> parameter to
-      <a href="/pkg/syscall/?GOOS=linux&GOARCH=amd64#Faccessat"><code>Faccessat</code></a>
-      is now implemented just as in glibc. In earlier Go releases the
-      flags parameter was ignored.
-    </p>
-
-    <p><!-- CL 118658 -->
-      On Linux, the <code>flags</code> parameter to
-      <a href="/pkg/syscall/?GOOS=linux&GOARCH=amd64#Fchmodat"><code>Fchmodat</code></a>
-      is now validated. Linux's <code>fchmodat</code> doesn't support the <code>flags</code> parameter
-      so we now mimic glibc's behavior and return an error if it's non-zero.
-    </p>
-
-</dl><!-- syscall -->
-
-<dl id="text/scanner"><dt><a href="/pkg/text/scanner/">text/scanner</a></dt>
-  <dd>
-    <p><!-- CL 112037 -->
-      The <a href="/pkg/text/scanner/#Scanner.Scan"><code>Scanner.Scan</code></a> method now returns
-      the <a href="/pkg/text/scanner/#RawString"><code>RawString</code></a> token
-      instead of <a href="/pkg/text/scanner/#String"><code>String</code></a>
-      for raw string literals.
-    </p>
-
-</dl><!-- text/scanner -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 84480 -->
-      Modifying template variables via assignments is now permitted via the <code>=</code> token:
-    </p>
-    <pre>
-  {{"{{"}} $v := "init" {{"}}"}}
-  {{"{{"}} if true {{"}}"}}
-    {{"{{"}} $v = "changed" {{"}}"}}
-  {{"{{"}} end {{"}}"}}
-  v: {{"{{"}} $v {{"}}"}} {{"{{"}}/* "changed" */{{"}}"}}</pre>
-
-    <p><!-- CL 95215 -->
-      In previous versions untyped <code>nil</code> values passed to
-      template functions were ignored. They are now passed as normal
-      arguments.
-    </p>
-
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 98157 -->
-	  Parsing of timezones denoted by sign and offset is now
-	  supported. In previous versions, numeric timezone names
-	  (such as <code>+03</code>) were not considered valid, and only
-	  three-letter abbreviations (such as <code>MST</code>) were accepted
-	  when expecting a timezone name.
-    </p>
-</dl><!-- time -->

doc/go1.12.html

@@ -1,949 +0,0 @@
-<!--{
-        "Title": "Go 1.12 Release Notes",
-        "Path":  "/doc/go1.12",
-        "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.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.12</h2>
-
-<p>
-  The latest Go release, version 1.12, arrives six months after <a href="go1.11">Go 1.11</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are no changes to the language specification.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p><!-- CL 138675 -->
-  The race detector is now supported on <code>linux/arm64</code>.
-</p>
-
-<p id="freebsd">
-  Go 1.12 is the last release that is supported on FreeBSD 10.x, which has
-  already reached end-of-life. Go 1.13 will require FreeBSD 11.2+ or FreeBSD
-  12.0+.
-  FreeBSD 12.0+ requires a kernel with the COMPAT_FREEBSD11 option set (this is the default).
-</p>
-
-<p><!-- CL 146898 -->
-  cgo is now supported on <code>linux/ppc64</code>.
-</p>
-
-<p id="hurd"><!-- CL 146023 -->
-  <code>hurd</code> is now a recognized value for <code>GOOS</code>, reserved
-  for the GNU/Hurd system for use with <code>gccgo</code>.
-</p>
-
-<h3 id="windows">Windows</h3>
-
-<p>
-  Go's new <code>windows/arm</code> port supports running Go on Windows 10
-  IoT Core on 32-bit ARM chips such as the Raspberry Pi 3.
-</p>
-
-<h3 id="aix">AIX</h3>
-
-<p>
-  Go now supports AIX 7.2 and later on POWER8 architectures (<code>aix/ppc64</code>). External linking, cgo, pprof and the race detector aren't yet supported.
-</p>
-
-<h3 id="darwin">Darwin</h3>
-
-<p>
-  Go 1.12 is the last release that will run on macOS 10.10 Yosemite.
-  Go 1.13 will require macOS 10.11 El Capitan or later.
-</p>
-
-<p><!-- CL 141639 -->
-  <code>libSystem</code> is now used when making syscalls on Darwin,
-  ensuring forward-compatibility with future versions of macOS and iOS.
-  <!-- CL 153338 -->
-  The switch to <code>libSystem</code> triggered additional App Store
-  checks for private API usage. Since it is considered private,
-  <code>syscall.Getdirentries</code> now always fails with
-  <code>ENOSYS</code> on iOS.
-  Additionally, <a href="/pkg/syscall/#Setrlimit"><code>syscall.Setrlimit</code></a>
-  reports <code>invalid</code> <code>argument</code> in places where it historically
-  succeeded. These consequences are not specific to Go and users should expect
-  behavioral parity with <code>libSystem</code>'s implementation going forward.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="vet"><code>go tool vet</code> no longer supported</h3>
-
-<p>
-  The <code>go vet</code> command has been rewritten to serve as the
-  base for a range of different source code analysis tools. See
-  the <a href="https://godoc.org/golang.org/x/tools/go/analysis">golang.org/x/tools/go/analysis</a>
-  package for details. A side-effect is that <code>go tool vet</code>
-  is no longer supported. External tools that use <code>go tool
-  vet</code> must be changed to use <code>go
-  vet</code>. Using <code>go vet</code> instead of <code>go tool
-  vet</code> should work with all supported versions of Go.
-</p>
-
-<p>
-  As part of this change, the experimental <code>-shadow</code> option
-  is no longer available with <code>go vet</code>. Checking for
-  variable shadowing may now be done using
-<pre>
-go get -u golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
-go vet -vettool=$(which shadow)
-</pre>
-</p>
-
-<h3 id="tour">Tour</h3>
-
-<p> <!-- CL 152657 -->
-The Go tour is no longer included in the main binary distribution. To
-run the tour locally, instead of running <code>go</code> <code>tool</code> <code>tour</code>,
-manually install it:
-<pre>
-go get -u golang.org/x/tour
-tour
-</pre>
-</p>
-
-<h3 id="gocache">Build cache requirement</h3>
-
-<p>
-  The <a href="/cmd/go/#hdr-Build_and_test_caching">build cache</a> is now
-  required as a step toward eliminating
-  <code>$GOPATH/pkg</code>. Setting the environment variable
-  <code>GOCACHE=off</code> will cause <code>go</code> commands that write to the
-  cache to fail.
-</p>
-
-<h3 id="binary-only">Binary-only packages</h3>
-
-<p>
-  Go 1.12 is the last release that will support binary-only packages.
-</p>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-	Go 1.12 will translate the C type <code>EGLDisplay</code> to the Go type <code>uintptr</code>.
-	This change is similar to how Go 1.10 and newer treats Darwin's CoreFoundation
-	and Java's JNI types. See the
-	<a href="/cmd/cgo/#hdr-Special_cases">cgo documentation</a>
-	for more information.
-</p>
-
-<p><!-- CL 152657 -->
-  Mangled C names are no longer accepted in packages that use Cgo. Use the Cgo
-  names instead. For example, use the documented cgo name <code>C.char</code>
-  rather than the mangled name <code>_Ctype_char</code> that cgo generates.
-</p>
-
-<h3 id="modules">Modules</h3>
-
-<p><!-- CL 148517 -->
-  When <code>GO111MODULE</code> is set to <code>on</code>, the <code>go</code>
-  command now supports module-aware operations outside of a module directory,
-  provided that those operations do not need to resolve import paths relative to
-  the current directory or explicitly edit the <code>go.mod</code> file.
-  Commands such as <code>go</code> <code>get</code>,
-  <code>go</code> <code>list</code>, and
-  <code>go</code> <code>mod</code> <code>download</code> behave as if in a
-  module with initially-empty requirements.
-  In this mode, <code>go</code> <code>env</code> <code>GOMOD</code> reports
-  the system's null device (<code>/dev/null</code> or <code>NUL</code>).
-</p>
-
-<p><!-- CL 146382 -->
-  <code>go</code> commands that download and extract modules are now safe to
-  invoke concurrently.
-  The module cache (<code>GOPATH/pkg/mod</code>) must reside in a filesystem that
-  supports file locking.
-</p>
-
-<p><!-- CL 147282, 147281 -->
-  The <code>go</code> directive in a <code>go.mod</code> file now indicates the
-  version of the language used by the files within that module.
-  It will be set to the current release
-  (<code>go</code> <code>1.12</code>) if no existing version is
-  present.
-  If the <code>go</code> directive for a module specifies a
-  version <em>newer</em> than the toolchain in use, the <code>go</code> command
-  will attempt to build the packages regardless, and will note the mismatch only if
-  that build fails.
-</p>
-
-<p><!-- CL 147282, 147281 -->
-  This changed use of the <code>go</code> directive means that if you
-  use Go 1.12 to build a module, thus recording <code>go 1.12</code>
-  in the <code>go.mod</code> file, you will get an error when
-  attempting to build the same module with Go 1.11 through Go 1.11.3.
-  Go 1.11.4 or later will work fine, as will releases older than Go 1.11.
-  If you must use Go 1.11 through 1.11.3, you can avoid the problem by
-  setting the language version to 1.11, using the Go 1.12 go tool,
-  via <code>go mod edit -go=1.11</code>.
-</p>
-
-<p><!-- CL 152739 -->
-  When an import cannot be resolved using the active modules,
-  the <code>go</code> command will now try to use the modules mentioned in the
-  main module's <code>replace</code> directives before consulting the module
-  cache and the usual network sources.
-  If a matching replacement is found but the <code>replace</code> directive does
-  not specify a version, the <code>go</code> command uses a pseudo-version
-  derived from the zero <code>time.Time</code> (such
-  as <code>v0.0.0-00010101000000-000000000000</code>).
-</p>
-
-<h3 id="compiler">Compiler toolchain</h3>
-
-<p><!-- CL 134155, 134156 -->
-  The compiler's live variable analysis has improved. This may mean that
-  finalizers will be executed sooner in this release than in previous
-  releases. If that is a problem, consider the appropriate addition of a
-  <a href="/pkg/runtime/#KeepAlive"><code>runtime.KeepAlive</code></a> call.
-</p>
-
-<p><!-- CL 147361 -->
-  More functions are now eligible for inlining by default, including
-  functions that do nothing but call another function.
-  This extra inlining makes it additionally important to use
-  <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
-  instead of iterating over the result of
-  <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a> directly.
-<pre>
-// Old code which no longer works correctly (it will miss inlined call frames).
-var pcs [10]uintptr
-n := runtime.Callers(1, pcs[:])
-for _, pc := range pcs[:n] {
-	f := runtime.FuncForPC(pc)
-	if f != nil {
-		fmt.Println(f.Name())
-	}
-}
-</pre>
-<pre>
-// New code which will work correctly.
-var pcs [10]uintptr
-n := runtime.Callers(1, pcs[:])
-frames := runtime.CallersFrames(pcs[:n])
-for {
-	frame, more := frames.Next()
-	fmt.Println(frame.Function)
-	if !more {
-		break
-	}
-}
-</pre>
-</p>
-
-<p><!-- CL 153477 -->
-  Wrappers generated by the compiler to implement method expressions
-  are no longer reported
-  by <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
-  and <a href="/pkg/runtime/#Stack"><code>runtime.Stack</code></a>. They
-  are also not printed in panic stack traces.
-
-  This change aligns the <code>gc</code> toolchain to match
-  the <code>gccgo</code> toolchain, which already elided such wrappers
-  from stack traces.
-
-  Clients of these APIs might need to adjust for the missing
-  frames. For code that must interoperate between 1.11 and 1.12
-  releases, you can replace the method expression <code>x.M</code>
-  with the function literal <code>func (...) { x.M(...) } </code>.
-</p>
-
-<p><!-- CL 144340 -->
-  The compiler now accepts a <code>-lang</code> flag to set the Go language
-  version to use. For example, <code>-lang=go1.8</code> causes the compiler to
-  emit an error if the program uses type aliases, which were added in Go 1.9.
-  Language changes made before Go 1.12 are not consistently enforced.
-</p>
-
-<p><!-- CL 147160 -->
-  The compiler toolchain now uses different conventions to call Go
-  functions and assembly functions. This should be invisible to users,
-  except for calls that simultaneously cross between Go and
-  assembly <em>and</em> cross a package boundary. If linking results
-  in an error like "relocation target not defined for ABIInternal (but
-  is defined for ABI0)", please refer to the
-  <a href="https://github.com/golang/proposal/blob/master/design/27539-internal-abi.md#compatibility">compatibility section</a>
-  of the ABI design document.
-</p>
-
-<p><!-- CL 145179 -->
-  There have been many improvements to the DWARF debug information
-  produced by the compiler, including improvements to argument
-  printing and variable location information.
-</p>
-
-<p><!-- CL 61511 -->
-  Go programs now also maintain stack frame pointers on <code>linux/arm64</code>
-  for the benefit of profiling tools like <code>perf</code>. The frame pointer
-  maintenance has a small run-time overhead that varies but averages around 3%.
-  To build a toolchain that does not use frame pointers, set
-  <code>GOEXPERIMENT=noframepointer</code> when running <code>make.bash</code>.
-</p>
-
-<p><!-- CL 142717 -->
-  The obsolete "safe" compiler mode (enabled by the <code>-u</code> gcflag) has been removed.
-</p>
-
-<h3 id="godoc"><code>godoc</code> and <code>go</code> <code>doc</code></h3>
-
-<p>
-  In Go 1.12, <code>godoc</code> no longer has a command-line interface and
-  is only a web server. Users should use <code>go</code> <code>doc</code>
-  for command-line help output instead. Go 1.12 is the last release that will
-  include the <code>godoc</code> webserver; in Go 1.13 it will be available
-  via <code>go</code> <code>get</code>.
-</p>
-
-<p><!-- CL 141977 -->
-  <code>go</code> <code>doc</code> now supports the <code>-all</code> flag,
-  which will cause it to print all exported APIs and their documentation,
-  as the <code>godoc</code> command line used to do.
-</p>
-
-<p><!-- CL 140959 -->
-  <code>go</code> <code>doc</code> also now includes the <code>-src</code> flag,
-  which will show the target's source code.
-</p>
-
-<h3 id="trace">Trace</h3>
-
-<p><!-- CL 60790 -->
-  The trace tool now supports plotting mutator utilization curves,
-  including cross-references to the execution trace. These are useful
-  for analyzing the impact of the garbage collector on application
-  latency and throughput.
-</p>
-
-<h3 id="assembler">Assembler</h3>
-
-<p><!-- CL 147218 -->
-  On <code>arm64</code>, the platform register was renamed from
-  <code>R18</code> to <code>R18_PLATFORM</code> to prevent accidental
-  use, as the OS could choose to reserve this register.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 138959 -->
-  Go 1.12 significantly improves the performance of sweeping when a
-  large fraction of the heap remains live. This reduces allocation
-  latency immediately following a garbage collection.
-</p>
-
-<p><!-- CL 139719 -->
-  The Go runtime now releases memory back to the operating system more
-  aggressively, particularly in response to large allocations that
-  can't reuse existing heap space.
-</p>
-
-<p><!-- CL 146342, CL 146340, CL 146345, CL 146339, CL 146343, CL 146337, CL 146341, CL 146338 -->
-  The Go runtime's timer and deadline code is faster and scales better
-  with higher numbers of CPUs. In particular, this improves the
-  performance of manipulating network connection deadlines.
-</p>
-
-<p><!-- CL 135395 -->
-  On Linux, the runtime now uses <code>MADV_FREE</code> to release unused
-  memory. This is more efficient but may result in higher reported
-  RSS. The kernel will reclaim the unused data when it is needed.
-  To revert to the Go 1.11 behavior (<code>MADV_DONTNEED</code>), set the
-  environment variable <code>GODEBUG=madvdontneed=1</code>.
-</p>
-
-<p><!-- CL 149578 -->
-  Adding cpu.<em>extension</em>=off to the
-  <a href="/doc/diagnostics.html#godebug">GODEBUG</a> environment
-  variable now disables the use of optional CPU instruction
-  set extensions in the standard library and runtime. This is not
-  yet supported on Windows.
-</p>
-
-<p><!-- CL 158337 -->
-  Go 1.12 improves the accuracy of memory profiles by fixing
-  overcounting of large heap allocations.
-</p>
-
-<p><!-- CL 159717 -->
-  Tracebacks, <code>runtime.Caller</code>,
-  and <code>runtime.Callers</code> no longer include
-  compiler-generated initialization functions.  Doing a traceback
-  during the initialization of a global variable will now show a
-  function named <code>PKG.init.ializers</code>.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="tls_1_3">TLS 1.3</h3>
-
-<p>
-  Go 1.12 adds opt-in support for TLS 1.3 in the <code>crypto/tls</code> package as
-  specified by <a href="https://www.rfc-editor.org/info/rfc8446">RFC 8446</a>. It can
-  be enabled by adding the value <code>tls13=1</code> to the <code>GODEBUG</code>
-  environment variable. It will be enabled by default in Go 1.13.
-</p>
-
-<p>
-  To negotiate TLS 1.3, make sure you do not set an explicit <code>MaxVersion</code> in
-  <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> and run your program with
-  the environment variable <code>GODEBUG=tls13=1</code> set.
-</p>
-
-<p>
-  All TLS 1.2 features except <code>TLSUnique</code> in
-  <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
-  and renegotiation are available in TLS 1.3 and provide equivalent or
-  better security and performance. Note that even though TLS 1.3 is backwards
-  compatible with previous versions, certain legacy systems might not work
-  correctly when attempting to negotiate it. RSA certificate keys too small
-  to be secure (including 512-bit keys) will not work with TLS 1.3.
-</p>
-
-<p>
-  TLS 1.3 cipher suites are not configurable. All supported cipher suites are
-  safe, and if <code>PreferServerCipherSuites</code> is set in
-  <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> the preference order
-  is based on the available hardware.
-</p>
-
-<p>
-  Early data (also called "0-RTT mode") is not currently supported as a
-  client or server. Additionally, a Go 1.12 server does not support skipping
-  unexpected early data if a client sends it. Since TLS 1.3 0-RTT mode
-  involves clients keeping state regarding which servers support 0-RTT,
-  a Go 1.12 server cannot be part of a load-balancing pool where some other
-  servers do support 0-RTT. If switching a domain from a server that supported
-  0-RTT to a Go 1.12 server, 0-RTT would have to be disabled for at least the
-  lifetime of the issued session tickets before the switch to ensure
-  uninterrupted operation.
-</p>
-
-<p>
-  In TLS 1.3 the client is the last one to speak in the handshake, so if it causes
-  an error to occur on the server, it will be returned on the client by the first
-  <a href="/pkg/crypto/tls/#Conn.Read"><code>Read</code></a>, not by
-  <a href="/pkg/crypto/tls/#Conn.Handshake"><code>Handshake</code></a>. For
-  example, that will be the case if the server rejects the client certificate.
-  Similarly, session tickets are now post-handshake messages, so are only
-  received by the client upon its first
-  <a href="/pkg/crypto/tls/#Conn.Read"><code>Read</code></a>.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<!-- TODO: CL 115677: https://golang.org/cl/115677: cmd/vet: check embedded field tags too -->
-
-<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
-  <dd>
-    <p><!-- CL 149297 -->
-      <code>Reader</code>'s <a href="/pkg/bufio/#Reader.UnreadRune"><code>UnreadRune</code></a> and
-      <a href="/pkg/bufio/#Reader.UnreadByte"><code>UnreadByte</code></a> methods will now return an error
-      if they are called after <a href="/pkg/bufio/#Reader.Peek"><code>Peek</code></a>.
-    </p>
-
-</dl><!-- bufio -->
-
-<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
-  <dd>
-    <p><!-- CL 137855 -->
-      The new function <a href="/pkg/bytes/#ReplaceAll"><code>ReplaceAll</code></a> returns a copy of
-      a byte slice with all non-overlapping instances of a value replaced by another.
-    </p>
-
-    <p><!-- CL 145098 -->
-      A pointer to a zero-value <a href="/pkg/bytes/#Reader"><code>Reader</code></a> is now
-      functionally equivalent to <a href="/pkg/bytes/#NewReader"><code>NewReader</code></a><code>(nil)</code>.
-      Prior to Go 1.12, the former could not be used as a substitute for the latter in all cases.
-    </p>
-
-</dl><!-- bytes -->
-
-<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
-  <dd>
-    <p><!-- CL 139419 -->
-      A warning will now be printed to standard error the first time
-      <code>Reader.Read</code> is blocked for more than 60 seconds waiting
-      to read entropy from the kernel.
-    </p>
-
-    <p><!-- CL 120055 -->
-      On FreeBSD, <code>Reader</code> now uses the <code>getrandom</code>
-      system call if available, <code>/dev/urandom</code> otherwise.
-    </p>
-
-</dl><!-- crypto/rand -->
-
-<dl id="crypto/rc4"><dt><a href="/pkg/crypto/rc4/">crypto/rc4</a></dt>
-  <dd>
-    <p><!-- CL 130397 -->
-      This release removes the assembly implementations, leaving only
-      the pure Go version. The Go compiler generates code that is
-      either slightly better or slightly worse, depending on the exact
-      CPU. RC4 is insecure and should only be used for compatibility
-      with legacy systems.
-    </p>
-
-</dl><!-- crypto/rc4 -->
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 143177 -->
-      If a client sends an initial message that does not look like TLS, the server
-      will no longer reply with an alert, and it will expose the underlying
-      <code>net.Conn</code> in the new field <code>Conn</code> of
-      <a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>.
-    </p>
-
-</dl><!-- crypto/tls -->
-
-<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p><!-- CL 145738 -->
-      A query cursor can now be obtained by passing a
-      <a href="/pkg/database/sql/#Rows"><code>*Rows</code></a>
-      value to the <a href="/pkg/database/sql/#Row.Scan"><code>Row.Scan</code></a> method.
-    </p>
-
-</dl><!-- database/sql -->
-
-<dl id="expvar"><dt><a href="/pkg/expvar/">expvar</a></dt>
-  <dd>
-    <p><!-- CL 139537 -->
-      The new <a href="/pkg/expvar/#Map.Delete"><code>Delete</code></a> method allows
-      for deletion of key/value pairs from a <a href="/pkg/expvar/#Map"><code>Map</code></a>.
-    </p>
-
-</dl><!-- expvar -->
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <p><!-- CL 142737 -->
-      Maps are now printed in key-sorted order to ease testing. The ordering rules are:
-      <ul>
-        <li>When applicable, nil compares low
-        <li>ints, floats, and strings order by <
-        <li>NaN compares less than non-NaN floats
-        <li>bool compares false before true
-        <li>Complex compares real, then imaginary
-        <li>Pointers compare by machine address
-        <li>Channel values compare by machine address
-        <li>Structs compare each field in turn
-        <li>Arrays compare each element in turn
-        <li>Interface values compare first by <code>reflect.Type</code> describing the concrete type
-            and then by concrete value as described in the previous rules.
-      </ul>
-    </p>
-
-    <p><!-- CL 129777 -->
-      When printing maps, non-reflexive key values like <code>NaN</code> were previously
-      displayed as <code>&lt;nil&gt;</code>. As of this release, the correct values are printed.
-    </p>
-
-</dl><!-- fmt -->
-
-<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-  <dd>
-    <p><!-- CL 140958 -->
-      To address some outstanding issues in <a href="/cmd/doc/"><code>cmd/doc</code></a>,
-      this package has a new <a href="/pkg/go/doc/#Mode"><code>Mode</code></a> bit,
-      <code>PreserveAST</code>, which controls whether AST data is cleared.
-    </p>
-
-</dl><!-- go/doc -->
-
-<dl id="go/token"><dt><a href="/pkg/go/token/">go/token</a></dt>
-  <dd>
-    <p><!-- CL 134075 -->
-      The <a href="/pkg/go/token#File"><code>File</code></a> type has a new
-      <a href="/pkg/go/token#File.LineStart"><code>LineStart</code></a> field,
-      which returns the position of the start of a given line. This is especially useful
-      in programs that occasionally handle non-Go files, such as assembly, but wish to use
-      the <code>token.Pos</code> mechanism to identify file positions.
-    </p>
-
-</dl><!-- go/token -->
-
-<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
-  <dd>
-    <p><!-- CL 118755 -->
-      The <a href="/pkg/image/#RegisterFormat"><code>RegisterFormat</code></a> function is now safe for concurrent use.
-    </p>
-
-</dl><!-- image -->
-
-<dl id="image/png"><dt><a href="/pkg/image/png/">image/png</a></dt>
-  <dd>
-    <p><!-- CL 134235 -->
-      Paletted images with fewer than 16 colors now encode to smaller outputs.
-    </p>
-
-</dl><!-- image/png -->
-
-<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
-  <dd>
-    <p><!-- CL 139457 -->
-      The new <a href="/pkg/io#StringWriter"><code>StringWriter</code></a> interface wraps the
-      <a href="/pkg/io/#WriteString"><code>WriteString</code></a> function.
-    </p>
-
-</dl><!-- io -->
-
-<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
-  <dd>
-    <p><!-- CL 153059 -->
-      The functions
-      <a href="/pkg/math/#Sin"><code>Sin</code></a>,
-      <a href="/pkg/math/#Cos"><code>Cos</code></a>,
-      <a href="/pkg/math/#Tan"><code>Tan</code></a>,
-      and <a href="/pkg/math/#Sincos"><code>Sincos</code></a> now
-      apply Payne-Hanek range reduction to huge arguments. This
-      produces more accurate answers, but they will not be bit-for-bit
-      identical with the results in earlier releases.
-    </p>
-</dl><!-- math -->
-
-<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
-  <dd>
-    <p><!-- CL 123157 -->
-    New extended precision operations <a href="/pkg/math/bits/#Add"><code>Add</code></a>, <a href="/pkg/math/bits/#Sub"><code>Sub</code></a>, <a href="/pkg/math/bits/#Mul"><code>Mul</code></a>, and <a href="/pkg/math/bits/#Div"><code>Div</code></a> are available in <code>uint</code>, <code>uint32</code>, and <code>uint64</code> versions.
-    </p>
-
-</dl><!-- math/bits -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 146659 -->
-      The
-      <a href="/pkg/net/#Dialer.DualStack"><code>Dialer.DualStack</code></a> setting is now ignored and deprecated;
-      RFC 6555 Fast Fallback ("Happy Eyeballs") is now enabled by default. To disable, set
-      <a href="/pkg/net/#Dialer.FallbackDelay"><code>Dialer.FallbackDelay</code></a> to a negative value.
-    </p>
-
-    <p><!-- CL 107196 -->
-      Similarly, TCP keep-alives are now enabled by default if
-      <a href="/pkg/net/#Dialer.KeepAlive"><code>Dialer.KeepAlive</code></a> is zero.
-      To disable, set it to a negative value.
-    </p>
-
-    <p><!-- CL 113997 -->
-      On Linux, the <a href="http://man7.org/linux/man-pages/man2/splice.2.html"><code>splice</code> system call</a> is now used when copying from a
-      <a href="/pkg/net/#UnixConn"><code>UnixConn</code></a> to a
-      <a href="/pkg/net/#TCPConn"><code>TCPConn</code></a>.
-    </p>
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 143177 -->
-      The HTTP server now rejects misdirected HTTP requests to HTTPS servers with a plaintext "400 Bad Request" response.
-    </p>
-
-    <p><!-- CL 130115 -->
-      The new <a href="/pkg/net/http/#Client.CloseIdleConnections"><code>Client.CloseIdleConnections</code></a>
-      method calls the <code>Client</code>'s underlying <code>Transport</code>'s <code>CloseIdleConnections</code>
-      if it has one.
-    </p>
-
-    <p><!-- CL 145398 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer rejects HTTP responses which declare
-      HTTP Trailers but don't use chunked encoding. Instead, the declared trailers are now just ignored.
-    </p>
-
-    <p><!-- CL 152080 --> <!-- CL 151857 -->
-      The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer handles <code>MAX_CONCURRENT_STREAMS</code> values
-      advertised from HTTP/2 servers as strictly as it did during Go 1.10 and Go 1.11. The default behavior is now back
-      to how it was in Go 1.9: each connection to a server can have up to <code>MAX_CONCURRENT_STREAMS</code> requests
-      active and then new TCP connections are created as needed. In Go 1.10 and Go 1.11 the <code>http2</code> package
-      would block and wait for requests to finish instead of creating new connections.
-      To get the stricter behavior back, import the
-      <a href="https://godoc.org/golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a> package
-      directly and set
-      <a href="https://godoc.org/golang.org/x/net/http2#Transport.StrictMaxConcurrentStreams"><code>Transport.StrictMaxConcurrentStreams</code></a> to
-      <code>true</code>.
-    </p>
-
-</dl><!-- net/http -->
-
-<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-  <dd>
-    <p><!-- CL 159157, CL 160178 -->
-      <a href="/pkg/net/url/#Parse"><code>Parse</code></a>,
-      <a href="/pkg/net/url/#ParseRequestURI"><code>ParseRequestURI</code></a>,
-      and
-      <a href="/pkg/net/url/#URL.Parse"><code>URL.Parse</code></a>
-      now return an
-      error for URLs containing ASCII control characters, which includes NULL,
-      tab, and newlines.
-    </p>
-
-</dl><!-- net/url -->
-
-<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
-  <dd>
-    <p><!-- CL 146437 -->
-      The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> now automatically
-      proxies WebSocket requests.
-    </p>
-
-</dl><!-- net/http/httputil -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 125443 -->
-      The new <a href="/pkg/os/#ProcessState.ExitCode"><code>ProcessState.ExitCode</code></a> method
-      returns the process's exit code.
-    </p>
-
-    <p><!-- CL 135075 -->
-      <code>ModeCharDevice</code> has been added to the <code>ModeType</code> bitmask, allowing for
-      <code>ModeDevice | ModeCharDevice</code> to be recovered when masking a
-      <a href="/pkg/os/#FileMode"><code>FileMode</code></a> with <code>ModeType</code>.
-    </p>
-
-    <p><!-- CL 139418 -->
-      The new function <a href="/pkg/os/#UserHomeDir"><code>UserHomeDir</code></a> returns the
-      current user's home directory.
-    </p>
-
-    <p><!-- CL 146020 -->
-      <a href="/pkg/os/#RemoveAll"><code>RemoveAll</code></a> now supports paths longer than 4096 characters
-      on most Unix systems.
-    </p>
-
-    <p><!-- CL 130676 -->
-      <a href="/pkg/os/#File.Sync"><code>File.Sync</code></a> now uses <code>F_FULLFSYNC</code> on macOS
-      to correctly flush the file contents to permanent storage.
-      This may cause the method to run more slowly than in previous releases.
-    </p>
-
-    <p><!--CL 155517 -->
-      <a href="/pkg/os/#File"><code>File</code></a> now supports
-      a <a href="/pkg/os/#File.SyscallConn"><code>SyscallConn</code></a>
-      method returning
-      a <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn</code></a>
-      interface value. This may be used to invoke system-specific
-      operations on the underlying file descriptor.
-    </p>
-
-</dl><!-- os -->
-
-<dl id="path/filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
-  <dd>
-    <p><!-- CL 145220 -->
-      The <a href="/pkg/path/filepath/#IsAbs"><code>IsAbs</code></a> function now returns true when passed
-      a reserved filename on Windows such as <code>NUL</code>.
-      <a href="https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#naming-conventions">List of reserved names.</a>
-    </p>
-
-</dl><!-- path/filepath -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 33572 -->
-      A new <a href="/pkg/reflect#MapIter"><code>MapIter</code></a> type is
-      an iterator for ranging over a map. This type is exposed through the
-      <a href="/pkg/reflect#Value"><code>Value</code></a> type's new
-      <a href="/pkg/reflect#Value.MapRange"><code>MapRange</code></a> method.
-      This follows the same iteration semantics as a range statement, with <code>Next</code>
-      to advance the iterator, and <code>Key</code>/<code>Value</code> to access each entry.
-    </p>
-
-</dl><!-- reflect -->
-
-<dl id="regexp"><dt><a href="/pkg/regexp/">regexp</a></dt>
-  <dd>
-    <p><!-- CL 139784 -->
-      <a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> is no longer necessary
-      to avoid lock contention, so it has been given a partial deprecation comment.
-      <a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a>
-      may still be appropriate if the reason for its use is to make two copies with
-      different <a href="/pkg/regexp/#Regexp.Longest"><code>Longest</code></a> settings.
-    </p>
-
-</dl><!-- regexp -->
-
-<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
-  <dd>
-    <p><!-- CL 144220 -->
-      A new <a href="/pkg/runtime/debug/#BuildInfo"><code>BuildInfo</code></a> type
-      exposes the build information read from the running binary, available only in
-      binaries built with module support. This includes the main package path, main
-      module information, and the module dependencies. This type is given through the
-      <a href="/pkg/runtime/debug/#ReadBuildInfo"><code>ReadBuildInfo</code></a> function
-      on <a href="/pkg/runtime/debug/#BuildInfo"><code>BuildInfo</code></a>.
-    </p>
-
-</dl><!-- runtime/debug -->
-
-<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
-  <dd>
-    <p><!-- CL 137855 -->
-      The new function <a href="/pkg/strings/#ReplaceAll"><code>ReplaceAll</code></a> returns a copy of
-      a string with all non-overlapping instances of a value replaced by another.
-    </p>
-
-    <p><!-- CL 145098 -->
-      A pointer to a zero-value <a href="/pkg/strings/#Reader"><code>Reader</code></a> is now
-      functionally equivalent to <a href="/pkg/strings/#NewReader"><code>NewReader</code></a><code>(nil)</code>.
-      Prior to Go 1.12, the former could not be used as a substitute for the latter in all cases.
-    </p>
-
-    <p><!-- CL 122835 -->
-      The new <a href="/pkg/strings/#Builder.Cap"><code>Builder.Cap</code></a> method returns the capacity of the builder's underlying byte slice.
-    </p>
-
-    <p><!-- CL 131495 -->
-      The character mapping functions <a href="/pkg/strings/#Map"><code>Map</code></a>,
-      <a href="/pkg/strings/#Title"><code>Title</code></a>,
-      <a href="/pkg/strings/#ToLower"><code>ToLower</code></a>,
-      <a href="/pkg/strings/#ToLowerSpecial"><code>ToLowerSpecial</code></a>,
-      <a href="/pkg/strings/#ToTitle"><code>ToTitle</code></a>,
-      <a href="/pkg/strings/#ToTitleSpecial"><code>ToTitleSpecial</code></a>,
-      <a href="/pkg/strings/#ToUpper"><code>ToUpper</code></a>, and
-      <a href="/pkg/strings/#ToUpperSpecial"><code>ToUpperSpecial</code></a>
-      now always guarantee to return valid UTF-8. In earlier releases, if the input was invalid UTF-8 but no character replacements
-      needed to be applied, these routines incorrectly returned the invalid UTF-8 unmodified.
-    </p>
-
-</dl><!-- strings -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 138595 -->
-      64-bit inodes are now supported on FreeBSD 12. Some types have been adjusted accordingly.
-    </p>
-
-    <p><!-- CL 125456 -->
-      The Unix socket
-      (<a href="https://blogs.msdn.microsoft.com/commandline/2017/12/19/af_unix-comes-to-windows/"><code>AF_UNIX</code></a>)
-      address family is now supported for compatible versions of Windows.
-    </p>
-
-    <p><!-- CL 147117 -->
-      The new function  <a href="/pkg/syscall/?GOOS=windows&GOARCH=amd64#Syscall18"><code>Syscall18</code></a>
-      has been introduced for Windows, allowing for calls with up to 18 arguments.
-    </p>
-
-</dl><!-- syscall -->
-
-<dl id="syscall/js"><dt><a href="/pkg/syscall/js/">syscall/js</a></dt>
-  <dd>
-    <p><!-- CL 153559 -->
-    <p>
-      The <code>Callback</code> type and <code>NewCallback</code> function have been renamed;
-      they are now called
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Func"><code>Func</code></a> and
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#FuncOf"><code>FuncOf</code></a>, respectively.
-      This is a breaking change, but WebAssembly support is still experimental
-      and not yet subject to the
-      <a href="/doc/go1compat">Go 1 compatibility promise</a>. Any code using the
-      old names will need to be updated.
-    </p>
-
-    <p><!-- CL 141644 -->
-      If a type implements the new
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Wrapper"><code>Wrapper</code></a>
-      interface,
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#ValueOf"><code>ValueOf</code></a>
-      will use it to return the JavaScript value for that type.
-    </p>
-
-    <p><!-- CL 143137 -->
-      The meaning of the zero
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value"><code>Value</code></a>
-      has changed. It now represents the JavaScript <code>undefined</code> value
-      instead of the number zero.
-      This is a breaking change, but WebAssembly support is still experimental
-      and not yet subject to the
-      <a href="/doc/go1compat">Go 1 compatibility promise</a>. Any code relying on
-      the zero <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value"><code>Value</code></a>
-      to mean the number zero will need to be updated.
-    </p>
-
-    <p><!-- CL 144384 -->
-      The new
-      <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value.Truthy"><code>Value.Truthy</code></a>
-      method reports the
-      <a href="https://developer.mozilla.org/en-US/docs/Glossary/Truthy">JavaScript "truthiness"</a>
-      of a given value.
-    </p>
-
-</dl><!-- syscall/js -->
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- CL 139258 -->
-    The <a href="/cmd/go/#hdr-Testing_flags"><code>-benchtime</code></a> flag now supports setting an explicit iteration count instead of a time when the value ends with an "<code>x</code>". For example, <code>-benchtime=100x</code> runs the benchmark 100 times.
-    </p>
-
-</dl><!-- testing -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 142217 -->
-      When executing a template, long context values are no longer truncated in errors.
-    </p>
-    <p>
-      <code>executing "tmpl" at <.very.deep.context.v...>: map has no entry for key "notpresent"</code>
-    </p>
-    <p>
-      is now
-    </p>
-    <p>
-      <code>executing "tmpl" at <.very.deep.context.value.notpresent>: map has no entry for key "notpresent"</code>
-    </p>
-
-  <dd>
-    <p><!-- CL 143097 -->
-      If a user-defined function called by a template panics, the
-      panic is now caught and returned as an error by
-      the <code>Execute</code> or <code>ExecuteTemplate</code> method.
-    </p>
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 151299 -->
-      The time zone database in <code>$GOROOT/lib/time/zoneinfo.zip</code>
-      has been updated to version 2018i. Note that this ZIP file is
-      only used if a time zone database is not provided by the operating
-      system.
-    </p>
-
-</dl><!-- time -->
-
-<dl id="unsafe"><dt><a href="/pkg/unsafe/">unsafe</a></dt>
-  <dd>
-    <p><!-- CL 146058 -->
-      It is invalid to convert a nil <code>unsafe.Pointer</code> to <code>uintptr</code> and back with arithmetic.
-      (This was already invalid, but will now cause the compiler to misbehave.)
-    </p>
-
-</dl><!-- unsafe -->

doc/go1.14.html

@@ -1,924 +0,0 @@
-<!--{
-        "Title": "Go 1.14 Release Notes",
-        "Path":  "/doc/go1.14"
-}-->
-
-<!--
-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.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.14</h2>
-
-<p>
-  The latest Go release, version 1.14, arrives six months after <a href="go1.13">Go 1.13</a>.
-  Most of its changes are in the implementation of the toolchain, runtime, and libraries.
-  As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-  Module support in the <code>go</code> command is now ready for production use,
-  and we encourage all users to <a href="https://blog.golang.org/migrating-to-go-modules">migrate to Go
-  modules for dependency management</a>. If you are unable to migrate due to a problem in the Go
-  toolchain, please ensure that the problem has an
-  <a href="https://golang.org/issue?q=is%3Aissue+is%3Aopen+label%3Amodules">open issue</a>
-  filed. (If the issue is not on the <code>Go1.15</code> milestone, please let us
-  know why it prevents you from migrating so that we can prioritize it
-  appropriately.)
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  Per the <a href="https://github.com/golang/proposal/blob/master/design/6977-overlapping-interfaces.md">overlapping interfaces proposal</a>,
-  Go 1.14 now permits embedding of interfaces with overlapping method sets:
-  methods from an embedded interface may have the same names and identical signatures
-  as methods already present in the (embedding) interface. This solves problems that typically
-  (but not exclusively) occur with diamond-shaped embedding graphs.
-  Explicitly declared methods in an interface must remain
-  <a href="https://tip.golang.org/ref/spec#Uniqueness_of_identifiers">unique</a>, as before.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<h3 id="darwin">Darwin</h3>
-
-<p>
-  Go 1.14 is the last release that will run on macOS 10.11 El Capitan.
-  Go 1.15 will require macOS 10.12 Sierra or later.
-</p>
-
-<p><!-- golang.org/issue/34749 -->
-  Go 1.14 is the last Go release to support 32-bit binaries on
-  macOS (the <code>darwin/386</code> port). They are no longer
-  supported by macOS, starting with macOS 10.15 (Catalina).
-  Go continues to support the 64-bit <code>darwin/amd64</code> port.
-</p>
-
-<p><!-- golang.org/issue/34751 -->
-  Go 1.14 will likely be the last Go release to support 32-bit
-  binaries on iOS, iPadOS, watchOS, and tvOS
-  (the <code>darwin/arm</code> port). Go continues to support the
-  64-bit <code>darwin/arm64</code> port.
-</p>
-
-<h3 id="windows">Windows</h3>
-
-<p><!-- CL 203601 -->
-  Go binaries on Windows now
-  have <a href="https://docs.microsoft.com/en-us/windows/win32/memory/data-execution-prevention">DEP
-  (Data Execution Prevention)</a> enabled.
-</p>
-
-<p><!-- CL 202439 -->
-  On Windows, creating a file
-  via <a href="/pkg/os#CreateFile"><code>os.OpenFile</code></a> with
-  the <a href="/pkg/os/#O_CREATE"><code>os.O_CREATE</code></a> flag, or
-  via <a href="/pkg/syscall#Open"><code>syscall.Open</code></a> with
-  the <a href="/pkg/syscall#O_CREAT"><code>syscall.O_CREAT</code></a>
-  flag, will now create the file as read-only if the
-  bit <code>0o200</code> (owner write permission) is not set in the
-  permission argument. This makes the behavior on Windows more like
-  that on Unix systems.
-</p>
-
-<h3 id="wasm">WebAssembly</h3>
-
-<p><!-- CL 203600 -->
-  JavaScript values referenced from Go via <code>js.Value</code>
-  objects can now be garbage collected.
-</p>
-
-<p><!-- CL 203600 -->
-  <code>js.Value</code> values can no longer be compared using
-  the <code>==</code> operator, and instead must be compared using
-  their <code>Equal</code> method.
-</p>
-
-<p><!-- CL 203600 -->
-  <code>js.Value</code> now
-  has <code>IsUndefined</code>, <code>IsNull</code>,
-  and <code>IsNaN</code> methods.
-</p>
-
-<h3 id="riscv">RISC-V</h3>
-
-<p><!-- Issue 27532 -->
-  Go 1.14 contains experimental support for 64-bit RISC-V on Linux
-  (<code>GOOS=linux</code>, <code>GOARCH=riscv64</code>). Be aware
-  that performance, assembly syntax stability, and possibly
-  correctness are a work in progress.
-</p>
-
-<h3 id="freebsd">FreeBSD</h3>
-
-<p><!-- CL 199919 -->
-  Go now supports the 64-bit ARM architecture on FreeBSD 12.0 or later (the
-  <code>freebsd/arm64</code> port).
-</p>
-
-<h3 id="nacl">Native Client (NaCl)</h3>
-
-<p><!-- golang.org/issue/30439 -->
-  As <a href="go1.13#ports">announced</a> in the Go 1.13 release notes,
-  Go 1.14 drops support for the Native Client platform (<code>GOOS=nacl</code>).
-</p>
-
-<h3 id="illumos">Illumos</h3>
-
-<p><!-- CL 203758 -->
-  The runtime now respects zone CPU caps
-  (the <code>zone.cpu-cap</code> resource control)
-  for <code>runtime.NumCPU</code> and the default value
-  of <code>GOMAXPROCS</code>.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="go-command">Go command</h3>
-
-<h4 id="vendor">Vendoring</h4>
-<!-- golang.org/issue/33848 -->
-
-<p>
-  When the main module contains a top-level <code>vendor</code> directory and
-  its <code>go.mod</code> file specifies <code>go</code> <code>1.14</code> or
-  higher, the <code>go</code> command now defaults to <code>-mod=vendor</code>
-  for operations that accept that flag. A new value for that flag,
-  <code>-mod=mod</code>, causes the <code>go</code> command to instead load
-  modules from the module cache (as when no <code>vendor</code> directory is
-  present).
-</p>
-
-<p>
-  When <code>-mod=vendor</code> is set (explicitly or by default), the
-  <code>go</code> command now verifies that the main module's
-  <code>vendor/modules.txt</code> file is consistent with its
-  <code>go.mod</code> file.
-</p>
-
-<p>
-  <code>go</code> <code>list</code> <code>-m</code> no longer silently omits
-  transitive dependencies that do not provide packages in
-  the <code>vendor</code> directory. It now fails explicitly if
-  <code>-mod=vendor</code> is set and information is requested for a module not
-  mentioned in <code>vendor/modules.txt</code>.
-</p>
-
-<h4 id="go-flags">Flags</h4>
-
-<p><!-- golang.org/issue/32502, golang.org/issue/30345 -->
-  The <code>go</code> <code>get</code> command no longer accepts
-  the <code>-mod</code> flag. Previously, the flag's setting either
-  <a href="https://golang.org/issue/30345">was ignored</a> or
-  <a href="https://golang.org/issue/32502">caused the build to fail</a>.
-</p>
-
-<p><!-- golang.org/issue/33326 -->
-  <code>-mod=readonly</code> is now set by default when the <code>go.mod</code>
-  file is read-only and no top-level <code>vendor</code> directory is present.
-</p>
-
-<p><!-- golang.org/issue/31481 -->
-  <code>-modcacherw</code> is a new flag that instructs the <code>go</code>
-  command to leave newly-created directories in the module cache at their
-  default permissions rather than making them read-only.
-  The use of this flag makes it more likely that tests or other tools will
-  accidentally add files not included in the module's verified checksum.
-  However, it allows the use of <code>rm</code> <code>-rf</code>
-  (instead of <code>go</code> <code>clean</code> <code>-modcache</code>)
-  to remove the module cache.
-</p>
-
-<p><!-- golang.org/issue/34506 -->
-  <code>-modfile=file</code> is a new flag that instructs the <code>go</code>
-  command to read (and possibly write) an alternate <code>go.mod</code> file
-  instead of the one in the module root directory. A file
-  named <code>go.mod</code> must still be present in order to determine the
-  module root directory, but it is not accessed. When <code>-modfile</code> is
-  specified, an alternate <code>go.sum</code> file is also used: its path is
-  derived from the <code>-modfile</code> flag by trimming the <code>.mod</code>
-  extension and appending <code>.sum</code>.
-</p>
-
-<h4 id="go-env-vars">Environment variables</h4>
-
-<p><!-- golang.org/issue/32966 -->
-  <code>GOINSECURE</code> is a new environment variable that instructs
-  the <code>go</code> command to not require an HTTPS connection, and to skip
-  certificate validation, when fetching certain modules directly from their
-  origins. Like the existing <code>GOPRIVATE</code> variable, the value
-  of <code>GOINSECURE</code> is a comma-separated list of glob patterns.
-</p>
-
-<h4 id="commands-outside-modules">Commands outside modules</h4>
-
-<p><!-- golang.org/issue/32027 -->
-  When module-aware mode is enabled explicitly (by setting
-  <code>GO111MODULE=on</code>), most module commands have more
-  limited functionality if no <code>go.mod</code> file is present. For
-  example, <code>go</code> <code>build</code>,
-  <code>go</code> <code>run</code>, and other build commands can only build
-  packages in the standard library and packages specified as <code>.go</code>
-  files on the command line.
-</p>
-
-<p>
-  Previously, the <code>go</code> command would resolve each package path
-  to the latest version of a module but would not record the module path
-  or version. This resulted in <a href="https://golang.org/issue/32027">slow,
-  non-reproducible builds</a>.
-</p>
-
-<p>
-  <code>go</code> <code>get</code> continues to work as before, as do
-  <code>go</code> <code>mod</code> <code>download</code> and
-  <code>go</code> <code>list</code> <code>-m</code> with explicit versions.
-</p>
-
-<h4 id="incompatible-versions"><code>+incompatible</code> versions</h4>
-<!-- golang.org/issue/34165 -->
-
-<p>
-  If the latest version of a module contains a <code>go.mod</code> file,
-  <code>go</code> <code>get</code> will no longer upgrade to an
-  <a href="/cmd/go/#hdr-Module_compatibility_and_semantic_versioning">incompatible</a>
-  major version of that module unless such a version is requested explicitly
-  or is already required.
-  <code>go</code> <code>list</code> also omits incompatible major versions
-  for such a module when fetching directly from version control, but may
-  include them if reported by a proxy.
-</p>
-
-
-<h4 id="go.mod"><code>go.mod</code> file maintenance</h4>
-<!-- golang.org/issue/34822 -->
-
-<p>
-  <code>go</code> commands other than
-  <code>go</code> <code>mod</code> <code>tidy</code> no longer
-  remove a <code>require</code> directive that specifies a version of an indirect dependency
-  that is already implied by other (transitive) dependencies of the main
-  module.
-</p>
-
-<p>
-  <code>go</code> commands other than
-  <code>go</code> <code>mod</code> <code>tidy</code> no longer
-  edit the <code>go.mod</code> file if the changes are only cosmetic.
-</p>
-
-<p>
-  When <code>-mod=readonly</code> is set, <code>go</code> commands will no
-  longer fail due to a missing <code>go</code> directive or an erroneous
-  <code>//&nbsp;indirect</code> comment.
-</p>
-
-<h4 id="module-downloading">Module downloading</h4>
-
-<p><!-- golang.org/issue/26092 -->
-  The <code>go</code> command now supports Subversion repositories in module mode.
-</p>
-
-<p><!-- golang.org/issue/30748 -->
-  The <code>go</code> command now includes snippets of plain-text error messages
-  from module proxies and other HTTP servers.
-  An error message will only be shown if it is valid UTF-8 and consists of only
-  graphic characters and spaces.
-</p>
-
-<h4 id="go-test">Testing</h4>
-
-<p><!-- golang.org/issue/24929 -->
-  <code>go test -v</code> now streams <code>t.Log</code> output as it happens,
-  rather than at the end of all tests.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p><!-- CL 190098 -->
-  This release improves the performance of most uses
-  of <code>defer</code> to incur almost zero overhead compared to
-  calling the deferred function directly.
-  As a result, <code>defer</code> can now be used in
-  performance-critical code without overhead concerns.
-</p>
-
-<p><!-- CL 201760, CL 201762 and many others -->
-  Goroutines are now asynchronously preemptible.
-  As a result, loops without function calls no longer potentially
-  deadlock the scheduler or significantly delay garbage collection.
-  This is supported on all platforms except <code>windows/arm</code>,
-  <code>darwin/arm</code>, <code>js/wasm</code>, and
-  <code>plan9/*</code>.
-</p>
-
-<p>
-  A consequence of the implementation of preemption is that on Unix
-  systems, including Linux and macOS systems, programs built with Go
-  1.14 will receive more signals than programs built with earlier
-  releases.
-  This means that programs that use packages
-  like <a href="/pkg/syscall/"><code>syscall</code></a>
-  or <a href="https://godoc.org/golang.org/x/sys/unix"><code>golang.org/x/sys/unix</code></a>
-  will see more slow system calls fail with <code>EINTR</code> errors.
-  Those programs will have to handle those errors in some way, most
-  likely looping to try the system call again.  For more
-  information about this
-  see <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>man
-  7 signal</code></a> for Linux systems or similar documentation for
-  other systems.
-</p>
-
-<p><!-- CL 201765, CL 195701 and many others -->
-  The page allocator is more efficient and incurs significantly less
-  lock contention at high values of <code>GOMAXPROCS</code>.
-  This is most noticeable as lower latency and higher throughput for
-  large allocations being done in parallel and at a high rate.
-</p>
-
-<p><!-- CL 171844 and many others -->
-  Internal timers, used by
-  <a href="/pkg/time/#After"><code>time.After</code></a>,
-  <a href="/pkg/time/#Tick"><code>time.Tick</code></a>,
-  <a href="/pkg/net/#Conn"><code>net.Conn.SetDeadline</code></a>,
-  and friends, are more efficient, with less lock contention and fewer
-  context switches.
-  This is a performance improvement that should not cause any user
-  visible changes.
-</p>
-
-<h2 id="compiler">Compiler</h2>
-
-<p><!-- CL 162237 -->
-  This release adds <code>-d=checkptr</code> as a compile-time option
-  for adding instrumentation to check that Go code is following
-  <code>unsafe.Pointer</code> safety rules dynamically.
-  This option is enabled by default (except on Windows) with
-  the <code>-race</code> or <code>-msan</code> flags, and can be
-  disabled with <code>-gcflags=all=-d=checkptr=0</code>.
-  Specifically, <code>-d=checkptr</code> checks the following:
-</p>
-
-<ol>
-  <li>
-    When converting <code>unsafe.Pointer</code> to <code>*T</code>,
-    the resulting pointer must be aligned appropriately
-    for <code>T</code>.
-  </li>
-  <li>
-    If the result of pointer arithmetic points into a Go heap object,
-    one of the <code>unsafe.Pointer</code>-typed operands must point
-    into the same object.
-  </li>
-</ol>
-
-<p>
-  Using <code>-d=checkptr</code> is not currently recommended on
-  Windows because it causes false alerts in the standard library.
-</p>
-
-<p><!-- CL 204338 -->
-  The compiler can now emit machine-readable logs of key optimizations
-  using the <code>-json</code> flag, including inlining, escape
-  analysis, bounds-check elimination, and nil-check elimination.
-</p>
-
-<p><!-- CL 196959 -->
-  Detailed escape analysis diagnostics (<code>-m=2</code>) now work again.
-  This had been dropped from the new escape analysis implementation in
-  the previous release.
-</p>
-
-<p><!-- CL 196217 -->
-  All Go symbols in macOS binaries now begin with an underscore,
-  following platform conventions.
-</p>
-
-<p><!-- CL 202117 -->
-  This release includes experimental support for compiler-inserted
-  coverage instrumentation for fuzzing.
-  See <a href="https://golang.org/issue/14565">issue 14565</a> for more
-  details.
-  This API may change in future releases.
-</p>
-
-<p><!-- CL 174704 --><!-- CL 196784 -->
-  Bounds check elimination now uses information from slice creation and can
-  eliminate checks for indexes with types smaller than <code>int</code>.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="hash/maphash">New byte sequence hashing package</h3>
-
-<p> <!-- golang.org/issue/28322, CL 186877 -->
-  Go 1.14 includes a new package,
-  <a href="/pkg/hash/maphash/"><code>hash/maphash</code></a>,
-  which provides hash functions on byte sequences.
-  These hash functions are intended to be used to implement hash tables or
-  other data structures that need to map arbitrary strings or byte
-  sequences to a uniform distribution on unsigned 64-bit integers.
-</p>
-<p>
-  The hash functions are collision-resistant but not cryptographically secure.
-</p>
-<p>
-  The hash value of a given byte sequence is consistent within a
-  single process, but will be different in different processes.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
-  <dd>
-    <p><!-- CL 191976 -->
-      Support for SSL version 3.0 (SSLv3) has been removed. Note that SSLv3 is the
-      <a href="https://tools.ietf.org/html/rfc7568">cryptographically broken</a>
-      protocol predating TLS.
-    </p>
-
-    <p><!-- CL 191999 -->
-      TLS 1.3 can't be disabled via the <code>GODEBUG</code> environment
-      variable anymore. Use the
-      <a href="/pkg/crypto/tls/#Config.MaxVersion"><code>Config.MaxVersion</code></a>
-      field to configure TLS versions.
-    </p>
-
-    <p><!-- CL 205059 -->
-      When multiple certificate chains are provided through the
-      <a href="/pkg/crypto/tls/#Config.Certificates"><code>Config.Certificates</code></a>
-      field, the first one compatible with the peer is now automatically
-      selected. This allows for example providing an ECDSA and an RSA
-      certificate, and letting the package automatically select the best one.
-      Note that the performance of this selection is going to be poor unless the
-      <a href="/pkg/crypto/tls/#Certificate.Leaf"><code>Certificate.Leaf</code></a>
-      field is set. The
-      <a href="/pkg/crypto/tls/#Config.NameToCertificate"><code>Config.NameToCertificate</code></a>
-      field, which only supports associating a single certificate with
-      a give name, is now deprecated and should be left as <code>nil</code>.
-      Similarly the
-      <a href="/pkg/crypto/tls/#Config.BuildNameToCertificate"><code>Config.BuildNameToCertificate</code></a>
-      method, which builds the <code>NameToCertificate</code> field
-      from the leaf certificates, is now deprecated and should not be
-      called.
-    </p>
-
-    <p><!-- CL 175517 -->
-      The new <a href="/pkg/crypto/tls/#CipherSuites"><code>CipherSuites</code></a>
-      and <a href="/pkg/crypto/tls/#InsecureCipherSuites"><code>InsecureCipherSuites</code></a>
-      functions return a list of currently implemented cipher suites.
-      The new <a href="/pkg/crypto/tls/#CipherSuiteName"><code>CipherSuiteName</code></a>
-      function returns a name for a cipher suite ID.
-    </p>
-
-    <p><!-- CL 205058, 205057 -->
-      The new <a href="/pkg/crypto/tls/#ClientHelloInfo.SupportsCertificate">
-      <code>(*ClientHelloInfo).SupportsCertificate</code></a> and
-      <a href="/pkg/crypto/tls/#CertificateRequestInfo.SupportsCertificate">
-      <code>(*CertificateRequestInfo).SupportsCertificate</code></a>
-      methods expose whether a peer supports a certain certificate.
-    </p>
-
-    <p><!-- CL 174329 -->
-      The <code>tls</code> package no longer supports the legacy Next Protocol
-      Negotiation (NPN) extension and now only supports ALPN. In previous
-      releases it supported both. There are no API changes and applications
-      should function identically as before. Most other clients and servers have
-      already removed NPN support in favor of the standardized ALPN.
-    </p>
-
-    <p><!-- CL 205063, 205062 -->
-      RSA-PSS signatures are now used when supported in TLS 1.2 handshakes. This
-      won't affect most applications, but custom
-      <a href="/pkg/crypto/tls/#Certificate.PrivateKey"><code>Certificate.PrivateKey</code></a>
-      implementations that don't support RSA-PSS signatures will need to use the new
-      <a href="/pkg/crypto/tls/#Certificate.SupportedSignatureAlgorithms">
-      <code>Certificate.SupportedSignatureAlgorithms</code></a>
-      field to disable them.
-    </p>
-
-    <p><!-- CL 205059, 205059 -->
-      <a href="/pkg/crypto/tls/#Config.Certificates"><code>Config.Certificates</code></a> and
-      <a href="/pkg/crypto/tls/#Config.GetCertificate"><code>Config.GetCertificate</code></a>
-      can now both be nil if
-      <a href="/pkg/crypto/tls/#Config.GetConfigForClient"><code>Config.GetConfigForClient</code></a>
-      is set. If the callbacks return neither certificates nor an error, the
-      <code>unrecognized_name</code> is now sent.
-    </p>
-
-    <p><!-- CL 205058 -->
-      The new <a href="/pkg/crypto/tls/#CertificateRequestInfo.Version"><code>CertificateRequestInfo.Version</code></a>
-      field provides the TLS version to client certificates callbacks.
-    </p>
-
-    <p><!-- CL 205068 -->
-      The new <code>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256</code> and
-      <code>TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256</code> constants use
-      the final names for the cipher suites previously referred to as
-      <code>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305</code> and
-      <code>TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305</code>.
-    </p>
-  </dd>
-</dl><!-- crypto/tls -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 204046 -->
-      <a href="/pkg/crypto/x509/#Certificate.CreateCRL"><code>Certificate.CreateCRL</code></a>
-      now supports Ed25519 issuers.
-    </p>
-  </dd>
-</dl>
-
-<dl id="debug/dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
-  <dd>
-    <p><!-- CL 175138 -->
-      The <code>debug/dwarf</code> package now supports reading DWARF
-      version 5.
-    </p>
-    <p>
-      The new
-      method <a href="/pkg/debug/dwarf/#Data.AddSection"><code>(*Data).AddSection</code></a>
-      supports adding arbitrary new DWARF sections from the input file
-      to the DWARF <code>Data</code>.
-    </p>
-
-    <p><!-- CL 192698 -->
-      The new
-      method <a href="/pkg/debug/dwarf/#Reader.ByteOrder"><code>(*Reader).ByteOrder</code></a>
-      returns the byte order of the current compilation unit.
-      This may be used to interpret attributes that are encoded in the
-      native ordering, such as location descriptions.
-    </p>
-
-    <p><!-- CL 192699 -->
-      The new
-      method <a href="/pkg/debug/dwarf/#LineReader.Files"><code>(*LineReader).Files</code></a>
-      returns the file name table from a line reader.
-      This may be used to interpret the value of DWARF attributes such
-      as <code>AttrDeclFile</code>.
-    </p>
-  </dd>
-</dl><!-- debug/dwarf -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 126624 -->
-      <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a>
-      now supports ASN.1 string type BMPString, represented by the new
-      <a href="/pkg/encoding/asn1/#TagBMPString"><code>TagBMPString</code></a>
-      constant.
-    </p>
-  </dd>
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
-  <dd>
-    <p><!-- CL 200677 -->
-      The <a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
-      type supports a new
-      method <a href="/pkg/encoding/json/#Decoder.InputOffset"><code>InputOffset</code></a>
-      that returns the input stream byte offset of the current
-      decoder position.
-    </p>
-
-    <p><!-- CL 200217 -->
-      <a href="/pkg/encoding/json/#Compact"><code>Compact</code></a> no longer
-      escapes the <code>U+2028</code> and <code>U+2029</code> characters, which
-      was never a documented feature. For proper escaping, see <a
-      href="/pkg/encoding/json/#HTMLEscape"><code>HTMLEscape</code></a>.
-    </p>
-
-    <p><!-- CL 195045 -->
-      <a href="/pkg/encoding/json/#Number"><code>Number</code></a> no longer
-      accepts invalid numbers, to follow the documented behavior more closely.
-      If a program needs to accept invalid numbers like the empty string,
-      consider wrapping the type with <a href="/pkg/encoding/json/#Unmarshaler"><code>Unmarshaler</code></a>.
-    </p>
-
-    <p><!-- CL 200237 -->
-      <a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>
-      can now support map keys with string underlying type which implement
-      <a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>.
-    </p>
-  </dd>
-</dl><!-- encoding/json -->
-
-<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
-  <dd>
-    <p><!-- CL 203820, 211657 -->
-      The <a href="/pkg/go/build/#Context"><code>Context</code></a>
-      type has a new field <code>Dir</code> which may be used to set
-      the working directory for the build.
-      The default is the current directory of the running process.
-      In module mode, this is used to locate the main module.
-    </p>
-  </dd>
-</dl><!-- go/build -->
-
-<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
-  <dd>
-    <p><!-- CL 204830 -->
-      The new
-      function <a href="/pkg/go/doc/#NewFromFiles"><code>NewFromFiles</code></a>
-      computes package documentation from a list
-      of <code>*ast.File</code>'s and associates examples with the
-      appropriate package elements.
-      The new information is available in a new <code>Examples</code>
-      field
-      in the <a href="/pkg/go/doc/#Package"><code>Package</code></a>, <a href="/pkg/go/doc/#Type"><code>Type</code></a>,
-      and <a href="/pkg/go/doc/#Func"><code>Func</code></a> types, and a
-      new <a href="/pkg/go/doc/#Example.Suffix"><code>Suffix</code></a>
-      field in
-      the <a href="/pkg/go/doc/#Example"><code>Example</code></a>
-      type.
-    </p>
-  </dd>
-</dl><!-- go/doc -->
-
-<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
-  <dd>
-    <p><!-- CL 198488 -->
-      <a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a> can now create directories
-      whose names have predictable prefixes and suffixes.
-      As with <a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>, if the pattern
-      contains a '*', the random string replaces the last '*'.
-    </p>
-  </dd>
-</dl>
-
-<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
-  <dd>
-    <p><!-- CL 186182 -->
-      The
-      new <a href="https://tip.golang.org/pkg/log/#pkg-constants"><code>Lmsgprefix</code></a>
-      flag may be used to tell the logging functions to emit the
-      optional output prefix immediately before the log message rather
-      than at the start of the line.
-    </p>
-  </dd>
-</dl><!-- log -->
-
-<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
-  <dd>
-    <p><!-- CL 127458 -->
-      The new <a href="/pkg/math/#FMA"><code>FMA</code></a> function
-      computes <code>x*y+z</code> in floating point with no
-      intermediate rounding of the <code>x*y</code>
-      computation. Several architectures implement this computation
-      using dedicated hardware instructions for additional performance.
-    </p>
-  </dd>
-</dl><!-- math -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 164972 -->
-      The <a href="/pkg/math/big/#Int.GCD"><code>GCD</code></a> method
-      now allows the inputs <code>a</code> and <code>b</code> to be
-      zero or negative.
-    </p>
-  </dd>
-</dl><!-- math/big -->
-
-<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
-  <dd>
-    <p><!-- CL 197838 -->
-      The new functions
-      <a href="/pkg/math/bits/#Rem"><code>Rem</code></a>,
-      <a href="/pkg/math/bits/#Rem32"><code>Rem32</code></a>, and
-      <a href="/pkg/math/bits/#Rem64"><code>Rem64</code></a>
-      support computing a remainder even when the quotient overflows.
-    </p>
-  </dd>
-</dl><!-- math/bits -->
-
-<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
-  <dd>
-    <p><!-- CL 186927 -->
-      The default type of <code>.js</code> and <code>.mjs</code> files
-      is now <code>text/javascript</code> rather
-      than <code>application/javascript</code>.
-      This is in accordance
-      with <a href="https://datatracker.ietf.org/doc/draft-ietf-dispatch-javascript-mjs/">an
-      IETF draft</a> that treats <code>application/javascript</code> as obsolete.
-    </p>
-  </dd>
-</dl><!-- mime -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p>
-      The
-      new <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>
-      method <a href="/pkg/mime/multipart/#Reader.NextRawPart"><code>NextRawPart</code></a>
-      supports fetching the next MIME part without transparently
-      decoding <code>quoted-printable</code> data.
-    </p>
-  </dd>
-</dl><!-- mime/multipart -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 200760 -->
-      The new <a href="/pkg/net/http/#Header"><code>Header</code></a>
-      method <a href="/pkg/net/http/#Header.Values"><code>Values</code></a>
-      can be used to fetch all values associated with a
-      canonicalized key.
-    </p>
-
-    <p><!-- CL 61291 -->
-      The
-      new <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-      field <a href="/pkg/net/http/#Transport.DialTLSContext"><code>DialTLSContext</code></a>
-      can be used to specify an optional dial function for creating
-      TLS connections for non-proxied HTTPS requests.
-      This new field can be used instead
-      of <a href="/pkg/net/http/#Transport.DialTLS"><code>DialTLS</code></a>,
-      which is now considered deprecated; <code>DialTLS</code> will
-      continue to work, but new code should
-      use <code>DialTLSContext</code>, which allows the transport to
-      cancel dials as soon as they are no longer needed.
-    </p>
-
-    <p><!-- CL 192518, CL 194218 -->
-      On Windows, <a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> now correctly
-      serves files larger than 2GB.
-    </p>
-  </dd>
-</dl><!-- net/http -->
-
-<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
-  <dd>
-    <p><!-- CL 201557 -->
-      The
-      new <a href="/pkg/net/http/httptest/#Server"><code>Server</code></a>
-      field <a href="/pkg/net/http/httptest/#Server.EnableHTTP2"><code>EnableHTTP2</code></a>
-      supports enabling HTTP/2 on the test server.
-    </p>
-  </dd>
-</dl><!-- net/http/httptest -->
-
-<dl id="net/textproto"><dt><a href="/pkg/net/textproto/">net/textproto</a></dt>
-  <dd>
-    <p><!-- CL 200760 -->
-      The
-      new <a href="/pkg/net/textproto/#MIMEHeader"><code>MIMEHeader</code></a>
-      method <a href="/pkg/net/textproto/#MIMEHeader.Values"><code>Values</code></a>
-      can be used to fetch all values associated with a canonicalized
-      key.
-    </p>
-  </dd>
-</dl><!-- net/textproto -->
-
-<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
-  <dd>
-    <p><!-- CL 185117 -->
-      When parsing of a URL fails
-      (for example by <a href="/pkg/net/url/#Parse"><code>Parse</code></a>
-      or <a href="/pkg/net/url/#ParseRequestURI"><code>ParseRequestURI</code></a>),
-      the resulting <a href="/pkg/net/url/#Error.Error"><code>Error</code></a> message
-      will now quote the unparsable URL.
-      This provides clearer structure and consistency with other parsing errors.
-    </p>
-  </dd>
-</dl><!-- net/url -->
-
-<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
-  <dd>
-    <p><!-- CL 187739 -->
-      On Windows,
-      the <code>CTRL_CLOSE_EVENT</code>, <code>CTRL_LOGOFF_EVENT</code>,
-      and <code>CTRL_SHUTDOWN_EVENT</code> events now generate
-      a <code>syscall.SIGTERM</code> signal, similar to how Control-C
-      and Control-Break generate a <code>syscall.SIGINT</code> signal.
-    </p>
-  </dd>
-</dl><!-- os/signal -->
-
-<dl id="plugin"><dt><a href="/pkg/plugin/">plugin</a></dt>
-  <dd>
-    <p><!-- CL 191617 -->
-      The <code>plugin</code> package now supports <code>freebsd/amd64</code>.
-    </p>
-  </dd>
-</dl><!-- plugin -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 85661 -->
-      <a href="/pkg/reflect#StructOf"><code>StructOf</code></a> now
-      supports creating struct types with unexported fields, by
-      setting the <code>PkgPath</code> field in
-      a <code>StructField</code> element.
-    </p>
-  </dd>
-</dl><!-- reflect -->
-
-<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-    <p><!-- CL 200081 -->
-      <code>runtime.Goexit</code> can no longer be aborted by a
-      recursive <code>panic</code>/<code>recover</code>.
-    </p>
-
-    <p><!-- CL 188297, CL 191785 -->
-      On macOS, <code>SIGPIPE</code> is no longer forwarded to signal
-      handlers installed before the Go runtime is initialized.
-      This is necessary because macOS delivers <code>SIGPIPE</code>
-      <a href="https://golang.org/issue/33384">to the main thread</a>
-      rather than the thread writing to the closed pipe.
-    </p>
-  </dd>
-</dl><!-- runtime -->
-
-<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
-  <dd>
-    <p><!-- CL 204636, 205097 -->
-    The generated profile no longer includes the pseudo-PCs used for inline
-    marks. Symbol information of inlined functions is encoded in
-    <a href="https://github.com/google/pprof/blob/5e96527/proto/profile.proto#L177-L184">the format</a>
-    the pprof tool expects. This is a fix for the regression introduced
-    during recent releases.
-    </p>
-  </dd>
-</dl><!-- runtime/pprof -->
-
-<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
-  <dd>
-    <p>
-      The <a href="/pkg/strconv/#NumError"><code>NumError</code></a>
-      type now has
-      an <a href="/pkg/strconv/#NumError.Unwrap"><code>Unwrap</code></a>
-      method that may be used to retrieve the reason that a conversion
-      failed.
-      This supports using <code>NumError</code> values
-      with <a href="/pkg/errors/#Is"><code>errors.Is</code></a> to see
-      if the underlying error
-      is <a href="/pkg/strconv/#pkg-variables"><code>strconv.ErrRange</code></a>
-      or <a href="/pkg/strconv/#pkg-variables"><code>strconv.ErrSyntax</code></a>.
-    </p>
-  </dd>
-</dl><!-- strconv -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 200577 -->
-      Unlocking a highly contended <code>Mutex</code> now directly
-      yields the CPU to the next goroutine waiting for
-      that <code>Mutex</code>. This significantly improves the
-      performance of highly contended mutexes on high CPU count
-      machines.
-    </p>
-  </dd>
-</dl><!-- sync -->
-
-<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
-  <dd>
-    <p><!-- CL 201359 -->
-       The testing package now supports cleanup functions, called after
-       a test or benchmark has finished, by calling
-       <a href="/pkg/testing#T.Cleanup"><code>T.Cleanup</code></a> or
-       <a href="/pkg/testing#B.Cleanup"><code>B.Cleanup</code></a> respectively.
-    </p>
-  </dd>
-</dl><!-- testing -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 206124 -->
-      The text/template package now correctly reports errors when a
-      parenthesized argument is used as a function.
-      This most commonly shows up in erroneous cases like
-      <code>{{if (eq .F "a") or (eq .F "b")}}</code>.
-      This should be written as <code>{{if or (eq .F "a") (eq .F "b")}}</code>.
-      The erroneous case never worked as expected, and will now be
-      reported with an error <code>can't give argument to non-function</code>.
-    </p>
-  </dd>
-</dl><!-- text/template -->
-
-<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
-  <dd>
-    <p>
-      The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-      support throughout the system has been upgraded from Unicode 11.0 to
-      <a href="https://www.unicode.org/versions/Unicode12.0.0/">Unicode 12.0</a>,
-      which adds 554 new characters, including four new scripts, and 61 new emoji.
-    </p>
-  </dd>
-</dl><!-- unicode -->

doc/go1.16.html

@@ -1,191 +0,0 @@
-<!--{
-	"Title": "Go 1.16 Release Notes",
-	"Path":  "/doc/go1.16"
-}-->
-
-<!--
-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.
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">DRAFT RELEASE NOTES — Introduction to Go 1.16</h2>
-
-<p>
-  <strong>
-    Go 1.16 is not yet released. These are work-in-progress
-    release notes. Go 1.16 is expected to be released in February 2021.
-  </strong>
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  TODO
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-  TODO
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<p>
-  TODO
-</p>
-
-<h3 id="go-command">Go command</h3>
-
-<p><!-- golang.org/issue/24031 -->
-  <code>retract</code> directives may now be used in a <code>go.mod</code> file
-  to indicate that certain published versions of the module should not be used
-  by other modules. A module author may retract a version after a severe problem
-  is discovered or if the version was published unintentionally.<br>
-  TODO: write and link to section in golang.org/ref/mod<br>
-  TODO: write and link to tutorial or blog post
-</p>
-
-<p><!-- golang.org/issue/29062 -->
-  When using <code>go test</code>, a test that
-  calls <code>os.Exit(0)</code> during execution of a test function
-  will now be considered to fail.
-  This will help catch cases in which a test calls code that calls
-  os.Exit(0) and thereby stops running all future tests.
-  If a <code>TestMain</code> function calls <code>os.Exit(0)</code>
-  that is still considered to be a passing test.
-</p>
-
-<h4 id="all-pattern">The <code>all</code> pattern</h4>
-
-<p><!-- golang.org/cl/240623 -->
-  When the main module's <code>go.mod</code> file
-  declares <code>go</code> <code>1.16</code> or higher, the <code>all</code>
-  package pattern now matches only those packages that are transitively imported
-  by a package or test found in the main module. (Packages imported by <em>tests
-  of</em> packages imported by the main module are no longer included.) This is
-  the same set of packages retained
-  by <code>go</code> <code>mod</code> <code>vendor</code> since Go 1.11.
-</p>
-
-<p>
-  TODO
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<p>
-  TODO
-</p>
-
-<h2 id="compiler">Compiler</h2>
-
-<p>
-  TODO
-</p>
-
-<h2 id="linker">Linker</h2>
-
-<p>
-  This release includes additional improvements to the Go linker,
-  reducing linker resource usage (both time and memory) and improving
-  code robustness/maintainability. These changes form the second half
-  of a two-release project to
-  <a href="https://golang.org/s/better-linker">modernize the Go
-  linker</a>.
-</p>
-
-<p>
-  The linker changes in 1.16 extend the 1.15 improvements to all
-  supported architecture/OS combinations (the 1.15 performance improvements
-  were primarily focused on <code>ELF</code>-based OSes and
-  <code>amd64</code> architectures).  For a representative set of
-  large Go programs, linking is 20-35% faster than 1.15 and requires
-  5-15% less memory on average for <code>linux/amd64</code>, with larger
-  improvements for other architectures and OSes.
-</p>
-
-<p>
-  TODO: update with final numbers later in the release.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<p>
-  TODO
-</p>
-
-<h3 id="net"><a href="/pkg/net/">net</a></h3>
-
-<p><!-- CL 250357 -->
-  The case of I/O on a closed network connection, or I/O on a network
-  connection that is closed before any of the I/O completes, can now
-  be detected using the new <a href="/pkg/net/#ErrClosed">ErrClosed</a> error.
-  A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
-  In earlier releases the only way to reliably detect this case was to
-  match the string returned by the <code>Error</code> method
-  with <code>"use of closed network connection"</code>.
-</p>
-
-
-<h3 id="text/template/parse"><a href="/pkg/text/template/parse/">text/template/parse</a></h3>
-
-<p><!-- CL 229398, golang.org/issue/34652 -->
-  A new <a href="/pkg/text/template/parse/#CommentNode"><code>CommentNode</code></a>
-  was added to the parse tree. The <a href="/pkg/text/template/parse/#Mode"><code>Mode</code></a>
-  field in the <code>parse.Tree</code> enables access to it.
-</p>
-<!-- text/template/parse -->
-
-<h3 id="unicode"><a href="/pkg/unicode/">unicode</a></h3>
-
-<p><!-- CL 248765 -->
-  The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-  support throughout the system has been upgraded from Unicode 12.0.0 to
-  <a href="https://www.unicode.org/versions/Unicode13.0.0/">Unicode 13.0.0</a>,
-  which adds 5,930 new characters, including four new scripts, and 55 new emoji.
-  Unicode 13.0.0 also designates plane 3 (U+30000-U+3FFFF) as the tertiary
-  ideographic plane.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<p>
-  TODO
-</p>
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-    <p><!-- CL 233637 -->
-      In the <a href="/pkg/net/http/"><code>net/http</code></a> package, the
-      behavior of <a href="/pkg/net/http/#StripPrefix"><code>StripPrefix</code></a>
-      has been changed to strip the prefix from the request URL's
-      <code>RawPath</code> field in addition to its <code>Path</code> field.
-      In past releases, only the <code>Path</code> field was trimmed, and so if the
-      request URL contained any escaped characters the URL would be modified to
-      have mismatched <code>Path</code> and <code>RawPath</code> fields.
-      In Go 1.16, <code>StripPrefix</code> trims both fields.
-      If there are escaped characters in the prefix part of the request URL the
-      handler serves a 404 instead of its previous behavior of invoking the
-      underlying handler with a mismatched <code>Path</code>/<code>RawPath</code> pair.
-    </p>
-
-    <p><!-- CL 252497 -->
-     The <a href="/pkg/net/http/"><code>net/http</code></a> package now rejects HTTP range requests
-     of the form <code>"Range": "bytes=--N"</code> where <code>"-N"</code> is a negative suffix length, for
-     example <code>"Range": "bytes=--2"</code>. It now replies with a <code>416 "Range Not Satisfiable"</code> response.
-    </p>
-  </dd>
-</dl><!-- net/http -->

doc/go1.2.html

@@ -860,13 +860,13 @@ The new build tag <code>netgo</code> (off by default) allows the construction of
 The <a href="/pkg/net/"><code>net</code></a> package adds a new field
 <code>DualStack</code> to the <a href="/pkg/net/#Dialer"><code>Dialer</code></a>
 struct for TCP connection setup using a dual IP stack as described in
-<a href="https://tools.ietf.org/html/rfc6555">RFC 6555</a>.
+<a href="http://tools.ietf.org/html/rfc6555">RFC 6555</a>.
 </li>
 
 <li>
 The <a href="/pkg/net/http/"><code>net/http</code></a> package will no longer
 transmit cookies that are incorrect according to
-<a href="https://tools.ietf.org/html/rfc6265">RFC 6265</a>.
+<a href="http://tools.ietf.org/html/rfc6265">RFC 6265</a>.
 It just logs an error and sends nothing.
 Also,
 the <a href="/pkg/net/http/"><code>net/http</code></a> package's

doc/go1.3.html

@@ -373,7 +373,7 @@ which can be useful information when debugging deadlocks or performance issues.
 
 <p>
 A new package <a href="/pkg/debug/plan9obj/"><code>debug/plan9obj</code></a> was added to the standard library.
-It implements access to Plan 9 <a href="https://9p.io/magic/man2html/6/a.out">a.out</a> object files.
+It implements access to Plan 9 <a href="http://plan9.bell-labs.com/magic/man2html/6/a.out">a.out</a> object files.
 </p>
 
 <h3 id="major_library_changes">Major changes to the library</h3>
@@ -525,7 +525,7 @@ client.
 The <a href="/pkg/net/http/"><code>net/http</code></a> package's
 <a href="/pkg/net/http/#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>
 method will now return an error if the body's <code>Content-Type</code>
-is not <code>multipart/form-data</code>.
+is not <code>mutipart/form-data</code>.
 Prior to Go 1.3 it would silently fail and return <code>nil</code>.
 Code that relies on the previous behavior should be updated.
 </li>

doc/go1.4.html

@@ -420,7 +420,7 @@ to automate the running of tools to generate source code before compilation.
 For example, it can be used to run the <a href="/cmd/yacc"><code>yacc</code></a>
 compiler-compiler on a <code>.y</code> file to produce the Go source file implementing the grammar,
 or to automate the generation of <code>String</code> methods for typed constants using the new
-<a href="https://godoc.org/golang.org/x/tools/cmd/stringer">stringer</a>
+<a href="http://godoc.org/golang.org/x/tools/cmd/stringer">stringer</a>
 tool in the <code>golang.org/x/tools</code> subrepository.
 </p>
 
@@ -619,9 +619,9 @@ has been created to serve as the location for new developments to support system
 calls on all kernels.
 It has a nicer structure, with three packages that each hold the implementation of
 system calls for one of
-<a href="https://godoc.org/golang.org/x/sys/unix">Unix</a>,
-<a href="https://godoc.org/golang.org/x/sys/windows">Windows</a> and
-<a href="https://godoc.org/golang.org/x/sys/plan9">Plan 9</a>.
+<a href="http://godoc.org/golang.org/x/sys/unix">Unix</a>,
+<a href="http://godoc.org/golang.org/x/sys/windows">Windows</a> and
+<a href="http://godoc.org/golang.org/x/sys/plan9">Plan 9</a>.
 These packages will be curated more generously, accepting all reasonable changes
 that reflect kernel interfaces in those operating systems.
 See the documentation and the article mentioned above for more information.
@@ -670,7 +670,7 @@ The <a href="/pkg/crypto/"><code>crypto</code></a> package now has a
 
 <li>
 The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports ALPN as defined in <a href="https://tools.ietf.org/html/rfc7301">RFC 7301</a>.
+now supports ALPN as defined in <a href="http://tools.ietf.org/html/rfc7301">RFC 7301</a>.
 </li>
 
 <li>

doc/go1.6.html

@@ -10,7 +10,7 @@ Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .
 -->
 
 <style>
-  main ul li { margin: 0.5em 0; }
+ul li { margin: 0.5em 0; }
 </style>
 
 <h2 id="introduction">Introduction to Go 1.6</h2>
@@ -116,7 +116,7 @@ instead of generated from <a href="/cmd/yacc/">yacc</a>.
 <p>
 The compiler, linker, and <code>go</code> command have a new flag <code>-msan</code>,
 analogous to <code>-race</code> and only available on linux/amd64,
-that enables interoperation with the <a href="https://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
+that enables interoperation with the <a href="http://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
 Such interoperation is useful mainly for testing a program containing suspect C or C++ code.
 </p>
 

doc/go1.7.html

@@ -22,7 +22,7 @@ Do not send CLs removing the interior tags from such phrases.
 -->
 
 <style>
-  main ul li { margin: 0.5em 0; }
+ul li { margin: 0.5em 0; }
 </style>
 
 <h2 id="introduction">Introduction to Go 1.7</h2>
@@ -89,7 +89,7 @@ POWER5 architecture.
 </p>
 
 <p>
-The OpenBSD port now requires OpenBSD 5.6 or later, for access to the <a href="https://man.openbsd.org/getentropy.2"><i>getentropy</i>(2)</a> system call.
+The OpenBSD port now requires OpenBSD 5.6 or later, for access to the <a href="http://man.openbsd.org/getentropy.2"><i>getentropy</i>(2)</a> system call.
 </p>
 
 <h3 id="known_issues">Known Issues</h3>

doc/go1.8.html

@@ -12,7 +12,7 @@ Do not send CLs removing the interior tags from such phrases.
 -->
 
 <style>
-  main ul li { margin: 0.5em 0; }
+ul li { margin: 0.5em 0; }
 </style>
 
 <h2 id="introduction">Introduction to Go 1.8</h2>

doc/go1.9.html

@@ -12,7 +12,7 @@ Do not send CLs removing the interior tags from such phrases.
 -->
 
 <style>
-  main ul li { margin: 0.5em 0; }
+ul li { margin: 0.5em 0; }
 </style>
 
 <h2 id="introduction">Introduction to Go 1.9</h2>
@@ -862,7 +862,7 @@ version of gccgo.
 
 </dl><!-- reflect -->
 
-<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
+<dl id="runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
   <dd>
     <p><!-- CL 37233, CL 37726 -->
       Tracebacks generated by the runtime and recorded in profiles are

doc/go_mem.html

@@ -273,7 +273,9 @@ func f() {
 	a = "hello, world"
 	<-c
 }
+</pre>
 
+<pre>
 func main() {
 	go f()
 	c &lt;- 0
@@ -416,12 +418,8 @@ func twoprint() {
 </pre>
 
 <p>
-calling <code>twoprint</code> will call <code>setup</code> exactly
-once.
-The <code>setup</code> function will complete before either call
-of <code>print</code>.
-The result will be that <code>"hello, world"</code> will be printed
-twice.
+calling <code>twoprint</code> causes <code>"hello, world"</code> to be printed twice.
+The first call to <code>doprint</code> runs <code>setup</code> once.
 </p>
 
 <h2>Incorrect synchronization</h2>

doc/go_spec.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jan 14, 2020",
+	"Subtitle": "Version of May 9, 2018",
 	"Path": "/ref/spec"
 }-->
 
@@ -20,8 +20,8 @@ dependencies.
 </p>
 
 <p>
-The grammar is compact and simple to parse, allowing for easy analysis
-by automatic tools such as integrated development environments.
+The grammar is compact and regular, allowing for easy analysis by
+automatic tools such as integrated development environments.
 </p>
 
 <h2 id="Notation">Notation</h2>
@@ -69,7 +69,7 @@ language.
 
 <p>
 Source code is Unicode text encoded in
-<a href="https://en.wikipedia.org/wiki/UTF-8">UTF-8</a>. The text is not
+<a href="http://en.wikipedia.org/wiki/UTF-8">UTF-8</a>. The text is not
 canonicalized, so a single accented code point is distinct from the
 same character constructed from combining an accent and a letter;
 those are treated as two code points.  For simplicity, this document
@@ -104,7 +104,7 @@ unicode_digit  = /* a Unicode code point classified as "Number, decimal digit" *
 </pre>
 
 <p>
-In <a href="https://www.unicode.org/versions/Unicode8.0.0/">The Unicode Standard 8.0</a>,
+In <a href="http://www.unicode.org/versions/Unicode8.0.0/">The Unicode Standard 8.0</a>,
 Section 4.5 "General Category" defines a set of character categories.
 Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo
 as Unicode letters, and those in the Number category Nd as Unicode digits.
@@ -118,7 +118,6 @@ The underscore character <code>_</code> (U+005F) is considered a letter.
 <pre class="ebnf">
 letter        = unicode_letter | "_" .
 decimal_digit = "0" … "9" .
-binary_digit  = "0" | "1" .
 octal_digit   = "0" … "7" .
 hex_digit     = "0" … "9" | "A" … "F" | "a" … "f" .
 </pre>
@@ -274,156 +273,71 @@ The following character sequences represent <a href="#Operators">operators</a>
 <p>
 An integer literal is a sequence of digits representing an
 <a href="#Constants">integer constant</a>.
-An optional prefix sets a non-decimal base: <code>0b</code> or <code>0B</code>
-for binary, <code>0</code>, <code>0o</code>, or <code>0O</code> for octal,
-and <code>0x</code> or <code>0X</code> for hexadecimal.
-A single <code>0</code> is considered a decimal zero.
-In hexadecimal literals, letters <code>a</code> through <code>f</code>
-and <code>A</code> through <code>F</code> represent values 10 through 15.
-</p>
-
-<p>
-For readability, an underscore character <code>_</code> may appear after
-a base prefix or between successive digits; such underscores do not change
-the literal's value.
+An optional prefix sets a non-decimal base: <code>0</code> for octal, <code>0x</code> or
+<code>0X</code> for hexadecimal.  In hexadecimal literals, letters
+<code>a-f</code> and <code>A-F</code> represent values 10 through 15.
 </p>
 <pre class="ebnf">
-int_lit        = decimal_lit | binary_lit | octal_lit | hex_lit .
-decimal_lit    = "0" | ( "1" … "9" ) [ [ "_" ] decimal_digits ] .
-binary_lit     = "0" ( "b" | "B" ) [ "_" ] binary_digits .
-octal_lit      = "0" [ "o" | "O" ] [ "_" ] octal_digits .
-hex_lit        = "0" ( "x" | "X" ) [ "_" ] hex_digits .
-
-decimal_digits = decimal_digit { [ "_" ] decimal_digit } .
-binary_digits  = binary_digit { [ "_" ] binary_digit } .
-octal_digits   = octal_digit { [ "_" ] octal_digit } .
-hex_digits     = hex_digit { [ "_" ] hex_digit } .
+int_lit     = decimal_lit | octal_lit | hex_lit .
+decimal_lit = ( "1" … "9" ) { decimal_digit } .
+octal_lit   = "0" { octal_digit } .
+hex_lit     = "0" ( "x" | "X" ) hex_digit { hex_digit } .
 </pre>
 
 <pre>
 42
-4_2
 0600
-0_600
-0o600
-0O600       // second character is capital letter 'O'
 0xBadFace
-0xBad_Face
-0x_67_7a_2f_cc_40_c6
 170141183460469231731687303715884105727
-170_141183_460469_231731_687303_715884_105727
-
-_42         // an identifier, not an integer literal
-42_         // invalid: _ must separate successive digits
-4__2        // invalid: only one _ at a time
-0_xBadFace  // invalid: _ must separate successive digits
 </pre>
 
-
 <h3 id="Floating-point_literals">Floating-point literals</h3>
-
 <p>
-A floating-point literal is a decimal or hexadecimal representation of a
+A floating-point literal is a decimal representation of a
 <a href="#Constants">floating-point constant</a>.
+It has an integer part, a decimal point, a fractional part,
+and an exponent part.  The integer and fractional part comprise
+decimal digits; the exponent part is an <code>e</code> or <code>E</code>
+followed by an optionally signed decimal exponent.  One of the
+integer part or the fractional part may be elided; one of the decimal
+point or the exponent may be elided.
 </p>
-
-<p>
-A decimal floating-point literal consists of an integer part (decimal digits),
-a decimal point, a fractional part (decimal digits), and an exponent part
-(<code>e</code> or <code>E</code> followed by an optional sign and decimal digits).
-One of the integer part or the fractional part may be elided; one of the decimal point
-or the exponent part may be elided.
-An exponent value exp scales the mantissa (integer and fractional part) by 10<sup>exp</sup>.
-</p>
-
-<p>
-A hexadecimal floating-point literal consists of a <code>0x</code> or <code>0X</code>
-prefix, an integer part (hexadecimal digits), a radix point, a fractional part (hexadecimal digits),
-and an exponent part (<code>p</code> or <code>P</code> followed by an optional sign and decimal digits).
-One of the integer part or the fractional part may be elided; the radix point may be elided as well,
-but the exponent part is required. (This syntax matches the one given in IEEE 754-2008 §5.12.3.)
-An exponent value exp scales the mantissa (integer and fractional part) by 2<sup>exp</sup>.
-</p>
-
-<p>
-For readability, an underscore character <code>_</code> may appear after
-a base prefix or between successive digits; such underscores do not change
-the literal value.
-</p>
-
 <pre class="ebnf">
-float_lit         = decimal_float_lit | hex_float_lit .
-
-decimal_float_lit = decimal_digits "." [ decimal_digits ] [ decimal_exponent ] |
-                    decimal_digits decimal_exponent |
-                    "." decimal_digits [ decimal_exponent ] .
-decimal_exponent  = ( "e" | "E" ) [ "+" | "-" ] decimal_digits .
-
-hex_float_lit     = "0" ( "x" | "X" ) hex_mantissa hex_exponent .
-hex_mantissa      = [ "_" ] hex_digits "." [ hex_digits ] |
-                    [ "_" ] hex_digits |
-                    "." hex_digits .
-hex_exponent      = ( "p" | "P" ) [ "+" | "-" ] decimal_digits .
+float_lit = decimals "." [ decimals ] [ exponent ] |
+            decimals exponent |
+            "." decimals [ exponent ] .
+decimals  = decimal_digit { decimal_digit } .
+exponent  = ( "e" | "E" ) [ "+" | "-" ] decimals .
 </pre>
 
 <pre>
 0.
 72.40
-072.40       // == 72.40
+072.40  // == 72.40
 2.71828
 1.e+0
 6.67428e-11
 1E6
 .25
 .12345E+5
-1_5.         // == 15.0
-0.15e+0_2    // == 15.0
-
-0x1p-2       // == 0.25
-0x2.p10      // == 2048.0
-0x1.Fp+0     // == 1.9375
-0X.8p-0      // == 0.5
-0X_1FFFP-16  // == 0.1249847412109375
-0x15e-2      // == 0x15e - 2 (integer subtraction)
-
-0x.p1        // invalid: mantissa has no digits
-1p-2         // invalid: p exponent requires hexadecimal mantissa
-0x1.5e-2     // invalid: hexadecimal mantissa requires p exponent
-1_.5         // invalid: _ must separate successive digits
-1._5         // invalid: _ must separate successive digits
-1.5_e1       // invalid: _ must separate successive digits
-1.5e_1       // invalid: _ must separate successive digits
-1.5e1_       // invalid: _ must separate successive digits
 </pre>
 
-
 <h3 id="Imaginary_literals">Imaginary literals</h3>
-
 <p>
-An imaginary literal represents the imaginary part of a
+An imaginary literal is a decimal representation of the imaginary part of a
 <a href="#Constants">complex constant</a>.
-It consists of an <a href="#Integer_literals">integer</a> or
-<a href="#Floating-point_literals">floating-point</a> literal
-followed by the lower-case letter <code>i</code>.
-The value of an imaginary literal is the value of the respective
-integer or floating-point literal multiplied by the imaginary unit <i>i</i>.
+It consists of a
+<a href="#Floating-point_literals">floating-point literal</a>
+or decimal integer followed
+by the lower-case letter <code>i</code>.
 </p>
-
 <pre class="ebnf">
-imaginary_lit = (decimal_digits | int_lit | float_lit) "i" .
+imaginary_lit = (decimals | float_lit) "i" .
 </pre>
 
-<p>
-For backward compatibility, an imaginary literal's integer part consisting
-entirely of decimal digits (and possibly underscores) is considered a decimal
-integer, even if it starts with a leading <code>0</code>.
-</p>
-
 <pre>
 0i
-0123i         // == 123i for backward-compatibility
-0o123i        // == 0o123 * 1i == 83i
-0xabci        // == 0xabc * 1i == 2748i
+011i  // == 11i
 0.i
 2.71828i
 1.e+0i
@@ -431,7 +345,6 @@ integer, even if it starts with a leading <code>0</code>.
 1E6i
 .25i
 .12345E+5i
-0x1p-2i       // == 0x1p-2 * 1i == 0.25i
 </pre>
 
 
@@ -448,7 +361,6 @@ of the character itself,
 while multi-character sequences beginning with a backslash encode
 values in various formats.
 </p>
-
 <p>
 The simplest form represents the single character within the quotes;
 since Go source text is Unicode characters encoded in UTF-8, multiple
@@ -458,7 +370,6 @@ a literal <code>a</code>, Unicode U+0061, value <code>0x61</code>, while
 <code>'ä'</code> holds two bytes (<code>0xc3</code> <code>0xa4</code>) representing
 a literal <code>a</code>-dieresis, U+00E4, value <code>0xe4</code>.
 </p>
-
 <p>
 Several backslash escapes allow arbitrary values to be encoded as
 ASCII text.  There are four ways to represent the integer value
@@ -469,7 +380,6 @@ plain backslash <code>\</code> followed by exactly three octal digits.
 In each case the value of the literal is the value represented by
 the digits in the corresponding base.
 </p>
-
 <p>
 Although these representations all result in an integer, they have
 different valid ranges.  Octal escapes must represent a value between
@@ -478,11 +388,9 @@ by construction. The escapes <code>\u</code> and <code>\U</code>
 represent Unicode code points so within them some values are illegal,
 in particular those above <code>0x10FFFF</code> and surrogate halves.
 </p>
-
 <p>
 After a backslash, certain single-character escapes represent special values:
 </p>
-
 <pre class="grammar">
 \a   U+0007 alert or bell
 \b   U+0008 backspace
@@ -495,7 +403,6 @@ After a backslash, certain single-character escapes represent special values:
 \'   U+0027 single quote  (valid escape only within rune literals)
 \"   U+0022 double quote  (valid escape only within string literals)
 </pre>
-
 <p>
 All other sequences starting with a backslash are illegal inside rune literals.
 </p>
@@ -539,7 +446,6 @@ A string literal represents a <a href="#Constants">string constant</a>
 obtained from concatenating a sequence of characters. There are two forms:
 raw string literals and interpreted string literals.
 </p>
-
 <p>
 Raw string literals are character sequences between back quotes, as in
 <code>`foo`</code>.  Within the quotes, any character may appear except
@@ -551,7 +457,6 @@ contain newlines.
 Carriage return characters ('\r') inside raw string literals
 are discarded from the raw string value.
 </p>
-
 <p>
 Interpreted string literals are character sequences between double
 quotes, as in <code>&quot;bar&quot;</code>.
@@ -691,7 +596,6 @@ precision in the language, a compiler may implement them using an
 internal representation with limited precision.  That said, every
 implementation must:
 </p>
-
 <ul>
 	<li>Represent integer constants with at least 256 bits.</li>
 
@@ -709,14 +613,12 @@ implementation must:
 	    represent a floating-point or complex constant due to limits
 	    on precision.</li>
 </ul>
-
 <p>
 These requirements apply both to literal constants and to the result
 of evaluating <a href="#Constant_expressions">constant
 expressions</a>.
 </p>
 
-
 <h2 id="Variables">Variables</h2>
 
 <p>
@@ -891,7 +793,7 @@ rune        alias for int32
 
 <p>
 The value of an <i>n</i>-bit integer is <i>n</i> bits wide and represented using
-<a href="https://en.wikipedia.org/wiki/Two's_complement">two's complement arithmetic</a>.
+<a href="http://en.wikipedia.org/wiki/Two's_complement">two's complement arithmetic</a>.
 </p>
 
 <p>
@@ -909,7 +811,7 @@ To avoid portability issues all numeric types are <a href="#Type_definitions">de
 types</a> and thus distinct except
 <code>byte</code>, which is an <a href="#Alias_declarations">alias</a> for <code>uint8</code>, and
 <code>rune</code>, which is an alias for <code>int32</code>.
-Explicit conversions
+Conversions
 are required when different numeric types are mixed in an expression
 or assignment. For instance, <code>int32</code> and <code>int</code>
 are not the same type even though they may have the same size on a
@@ -921,7 +823,6 @@ particular architecture.
 <p>
 A <i>string type</i> represents the set of string values.
 A string value is a (possibly empty) sequence of bytes.
-The number of bytes is called the length of the string and is never negative.
 Strings are immutable: once created,
 it is impossible to change the contents of a string.
 The predeclared string type is <code>string</code>;
@@ -929,7 +830,7 @@ it is a <a href="#Type_definitions">defined type</a>.
 </p>
 
 <p>
-The length of a string <code>s</code> can be discovered using
+The length of a string <code>s</code> (its size in bytes) can be discovered using
 the built-in function <a href="#Length_and_capacity"><code>len</code></a>.
 The length is a compile-time constant if the string is a constant.
 A string's bytes can be accessed by integer <a href="#Index_expressions">indices</a>
@@ -945,7 +846,8 @@ string, <code>&amp;s[i]</code> is invalid.
 <p>
 An array is a numbered sequence of elements of a single
 type, called the element type.
-The number of elements is called the length of the array and is never negative.
+The number of elements is called the length and is never
+negative.
 </p>
 
 <pre class="ebnf">
@@ -981,7 +883,6 @@ multi-dimensional types.
 A slice is a descriptor for a contiguous segment of an <i>underlying array</i> and
 provides access to a numbered sequence of elements from that array.
 A slice type denotes the set of all slices of arrays of its element type.
-The number of elements is called the length of the slice and is never negative.
 The value of an uninitialized slice is <code>nil</code>.
 </p>
 
@@ -990,7 +891,8 @@ SliceType = "[" "]" ElementType .
 </pre>
 
 <p>
-The length of a slice <code>s</code> can be discovered by the built-in function
+Like arrays, slices are indexable and have a length.  The length of a
+slice <code>s</code> can be discovered by the built-in function
 <a href="#Length_and_capacity"><code>len</code></a>; unlike with arrays it may change during
 execution.  The elements can be addressed by integer <a href="#Index_expressions">indices</a>
 0 through <code>len(s)-1</code>.  The slice index of a
@@ -1244,36 +1146,24 @@ The value of an uninitialized variable of interface type is <code>nil</code>.
 </p>
 
 <pre class="ebnf">
-InterfaceType      = "interface" "{" { ( MethodSpec | InterfaceTypeName ) ";" } "}" .
-MethodSpec         = MethodName Signature .
+InterfaceType      = "interface" "{" { MethodSpec ";" } "}" .
+MethodSpec         = MethodName Signature | InterfaceTypeName .
 MethodName         = identifier .
 InterfaceTypeName  = TypeName .
 </pre>
 
 <p>
-An interface type may specify methods <i>explicitly</i> through method specifications,
-or it may <i>embed</i> methods of other interfaces through interface type names.
+As with all method sets, in an interface type, each method must have a
+<a href="#Uniqueness_of_identifiers">unique</a>
+non-<a href="#Blank_identifier">blank</a> name.
 </p>
 
 <pre>
-// A simple File interface.
+// A simple File interface
 interface {
-	Read([]byte) (int, error)
-	Write([]byte) (int, error)
-	Close() error
-}
-</pre>
-
-<p>
-The name of each explicitly specified method must be <a href="#Uniqueness_of_identifiers">unique</a>
-and not <a href="#Blank_identifier">blank</a>.
-</p>
-
-<pre>
-interface {
-	String() string
-	String() string  // illegal: String not unique
-	_(x int)         // illegal: method must have non-blank name
+	Read(b Buffer) bool
+	Write(b Buffer) bool
+	Close()
 }
 </pre>
 
@@ -1284,9 +1174,9 @@ have the method set
 </p>
 
 <pre>
-func (p T) Read(p []byte) (n int, err error)
-func (p T) Write(p []byte) (n int, err error)
-func (p T) Close() error
+func (p T) Read(b Buffer) bool { return … }
+func (p T) Write(b Buffer) bool { return … }
+func (p T) Close() { … }
 </pre>
 
 <p>
@@ -1336,41 +1226,27 @@ as the <code>File</code> interface.
 <p>
 An interface <code>T</code> may use a (possibly qualified) interface type
 name <code>E</code> in place of a method specification. This is called
-<i>embedding</i> interface <code>E</code> in <code>T</code>.
-The <a href="#Method_sets">method set</a> of <code>T</code> is the <i>union</i>
-of the method sets of <code>T</code>’s explicitly declared methods and of
-<code>T</code>’s embedded interfaces.
+<i>embedding</i> interface <code>E</code> in <code>T</code>; it adds
+all (exported and non-exported) methods of <code>E</code> to the interface
+<code>T</code>.
 </p>
 
 <pre>
-type Reader interface {
-	Read(p []byte) (n int, err error)
-	Close() error
-}
-
-type Writer interface {
-	Write(p []byte) (n int, err error)
-	Close() error
-}
-
-// ReadWriter's methods are Read, Write, and Close.
 type ReadWriter interface {
-	Reader  // includes methods of Reader in ReadWriter's method set
-	Writer  // includes methods of Writer in ReadWriter's method set
+	Read(b Buffer) bool
+	Write(b Buffer) bool
 }
-</pre>
 
-<p>
-A <i>union</i> of method sets contains the (exported and non-exported)
-methods of each method set exactly once, and methods with the
-<a href="#Uniqueness_of_identifiers">same</a> names must
-have <a href="#Type_identity">identical</a> signatures.
-</p>
+type File interface {
+	ReadWriter  // same as adding the methods of ReadWriter
+	Locker      // same as adding the methods of Locker
+	Close()
+}
 
-<pre>
-type ReadCloser interface {
-	Reader   // includes methods of Reader in ReadCloser's method set
-	Close()  // illegal: signatures of Reader.Close and Close are different
+type LockedFile interface {
+	Locker
+	File        // illegal: Lock, Unlock not unique
+	Lock()      // illegal: Lock not unique
 }
 </pre>
 
@@ -1473,8 +1349,7 @@ The optional <code>&lt;-</code> operator specifies the channel <i>direction</i>,
 <i>send</i> or <i>receive</i>. If no direction is given, the channel is
 <i>bidirectional</i>.
 A channel may be constrained only to send or only to receive by
-<a href="#Assignments">assignment</a> or
-explicit <a href="#Conversions">conversion</a>.
+<a href="#Conversions">conversion</a> or <a href="#Assignments">assignment</a>.
 </p>
 
 <pre>
@@ -2042,7 +1917,7 @@ of the last non-empty expression list.
 <p>
 A type declaration binds an identifier, the <i>type name</i>, to a <a href="#Types">type</a>.
 Type declarations come in two forms: alias declarations and type definitions.
-</p>
+<p>
 
 <pre class="ebnf">
 TypeDecl = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
@@ -2194,9 +2069,9 @@ Otherwise, each variable is initialized to its <a href="#The_zero_value">zero va
 If a type is present, each variable is given that type.
 Otherwise, each variable is given the type of the corresponding
 initialization value in the assignment.
-If that value is an untyped constant, it is first implicitly
+If that value is an untyped constant, it is first
 <a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>;
-if it is an untyped boolean value, it is first implicitly converted to type <code>bool</code>.
+if it is an untyped boolean value, it is first converted to type <code>bool</code>.
 The predeclared value <code>nil</code> cannot be used to initialize a variable
 with no explicit type.
 </p>
@@ -2237,8 +2112,8 @@ with initializer expressions but no types:
 i, j := 0, 10
 f := func() int { return 7 }
 ch := make(chan int)
-r, w, _ := os.Pipe()  // os.Pipe() returns a connected pair of Files and an error, if any
-_, y, _ := coord(p)   // coord() returns three values; only interested in y coordinate
+r, w := os.Pipe(fd)  // os.Pipe() returns two values
+_, y, _ := coord(p)  // coord() returns three values; only interested in y coordinate
 </pre>
 
 <p>
@@ -2327,11 +2202,11 @@ Receiver   = Parameters .
 <p>
 The receiver is specified via an extra parameter section preceding the method
 name. That parameter section must declare a single non-variadic parameter, the receiver.
-Its type must be a <a href="#Type_definitions">defined</a> type <code>T</code> or a
-pointer to a defined type <code>T</code>. <code>T</code> is called the receiver
-<i>base type</i>. A receiver base type cannot be a pointer or interface type and
-it must be defined in the same package as the method.
-The method is said to be <i>bound</i> to its receiver base type and the method name
+Its type must be of the form <code>T</code> or <code>*T</code> (possibly using
+parentheses) where <code>T</code> is a type name. The type denoted by <code>T</code> is called
+the receiver <i>base type</i>; it must not be a pointer or interface type and
+it must be <a href="#Type_definitions">defined</a> in the same package as the method.
+The method is said to be <i>bound</i> to the base type and the method name
 is visible only within <a href="#Selectors">selectors</a> for type <code>T</code>
 or <code>*T</code>.
 </p>
@@ -2351,7 +2226,7 @@ the non-blank method and field names must be distinct.
 </p>
 
 <p>
-Given defined type <code>Point</code>, the declarations
+Given type <code>Point</code>, the declarations
 </p>
 
 <pre>
@@ -2413,7 +2288,7 @@ operand only on the left-hand side of an <a href="#Assignments">assignment</a>.
 Operand     = Literal | OperandName | "(" Expression ")" .
 Literal     = BasicLit | CompositeLit | FunctionLit .
 BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
-OperandName = identifier | QualifiedIdent .
+OperandName = identifier | QualifiedIdent.
 </pre>
 
 <h3 id="Qualified_identifiers">Qualified identifiers</h3>
@@ -2539,24 +2414,10 @@ For array and slice literals the following rules apply:
 generates a pointer to a unique <a href="#Variables">variable</a> initialized
 with the literal's value.
 </p>
-
 <pre>
 var pointer *Point3D = &amp;Point3D{y: 1000}
 </pre>
 
-<p>
-Note that the <a href="#The_zero_value">zero value</a> for a slice or map
-type is not the same as an initialized but empty value of the same type.
-Consequently, taking the address of an empty slice or map composite literal
-does not have the same effect as allocating a new slice or map value with
-<a href="#Allocation">new</a>.
-</p>
-
-<pre>
-p1 := &amp;[]int{}    // p1 points to an initialized, empty slice with value []int{} and length 0
-p2 := new([]int)  // p2 points to an uninitialized slice with value nil and length 0
-</pre>
-
 <p>
 The length of an array literal is the length specified in the literal type.
 If fewer elements than the length are provided in the literal, the missing
@@ -3288,14 +3149,6 @@ is a <code>nil</code> slice. Otherwise, if the result is a slice, it shares its
 array with the operand.
 </p>
 
-<pre>
-var a [10]int
-s1 := a[3:7]   // underlying array of s1 is array a; &amp;s1[2] == &amp;a[5]
-s2 := s1[1:4]  // underlying array of s2 is underlying array of s1 which is array a; &amp;s2[1] == &amp;a[5]
-s2[1] = 42     // s2[1] == s1[2] == a[5] == 42; they all refer to the same underlying array element
-</pre>
-
-
 <h4>Full slice expressions</h4>
 
 <p>
@@ -3407,7 +3260,7 @@ var v, ok T1 = x.(T)
 yields an additional untyped boolean value. The value of <code>ok</code> is <code>true</code>
 if the assertion holds. Otherwise it is <code>false</code> and the value of <code>v</code> is
 the <a href="#The_zero_value">zero value</a> for type <code>T</code>.
-No <a href="#Run_time_panics">run-time panic</a> occurs in this case.
+No run-time panic occurs in this case.
 </p>
 
 
@@ -3532,7 +3385,7 @@ within <code>Greeting</code>, <code>who</code> will have the value
 </p>
 
 <p>
-If the final argument is assignable to a slice type <code>[]T</code>, it is
+If the final argument is assignable to a slice type <code>[]T</code>, it may be
 passed unchanged as the value for a <code>...T</code> parameter if the argument
 is followed by <code>...</code>. In this case no new slice is created.
 </p>
@@ -3580,16 +3433,16 @@ For operations involving constants only, see the section on
 
 <p>
 Except for shift operations, if one operand is an untyped <a href="#Constants">constant</a>
-and the other operand is not, the constant is implicitly <a href="#Conversions">converted</a>
+and the other operand is not, the constant is <a href="#Conversions">converted</a>
 to the type of the other operand.
 </p>
 
 <p>
-The right operand in a shift expression must have integer type
+The right operand in a shift expression must have unsigned integer type
 or be an untyped constant <a href="#Representability">representable</a> by a
 value of type <code>uint</code>.
 If the left operand of a non-constant shift expression is an untyped constant,
-it is first implicitly converted to the type it would assume if the shift expression were
+it is first converted to the type it would assume if the shift expression were
 replaced by its left operand alone.
 </p>
 
@@ -3690,7 +3543,7 @@ x = q*y + r  and  |r| &lt; |y|
 
 <p>
 with <code>x / y</code> truncated towards zero
-(<a href="https://en.wikipedia.org/wiki/Modulo_operation">"truncated division"</a>).
+(<a href="http://en.wikipedia.org/wiki/Modulo_operation">"truncated division"</a>).
 </p>
 
 <pre>
@@ -3732,9 +3585,7 @@ be replaced by a bitwise AND operation:
 
 <p>
 The shift operators shift the left operand by the shift count specified by the
-right operand, which must be non-negative. If the shift count is negative at run time,
-a <a href="#Run_time_panics">run-time panic</a> occurs.
-The shift operators implement arithmetic shifts if the left operand is a signed
+right operand. They implement arithmetic shifts if the left operand is a signed
 integer and logical shifts if it is an unsigned integer.
 There is no upper limit on the shift count. Shifts behave
 as if the left operand is shifted <code>n</code> times by 1 for a shift
@@ -3773,7 +3624,7 @@ For signed integers, the operations <code>+</code>,
 <code>-</code>, <code>*</code>, <code>/</code>, and <code>&lt;&lt;</code> may legally
 overflow and the resulting value exists and is deterministically defined
 by the signed integer representation, the operation, and its operands.
-Overflow does not cause a <a href="#Run_time_panics">run-time panic</a>.
+No exception is raised as a result of overflow.
 A compiler may not optimize code under the assumption that overflow does
 not occur. For instance, it may not assume that <code>x &lt; x + 1</code> is always true.
 </p>
@@ -3794,7 +3645,7 @@ occurs is implementation-specific.
 An implementation may combine multiple floating-point operations into a single
 fused operation, possibly across statements, and produce a result that differs
 from the value obtained by executing and rounding the instructions individually.
-An explicit floating-point type <a href="#Conversions">conversion</a> rounds to
+A floating-point type <a href="#Conversions">conversion</a> explicitly rounds to
 the precision of the target type, preventing fusion that would discard that rounding.
 </p>
 
@@ -4056,14 +3907,7 @@ channel is closed and empty.
 <h3 id="Conversions">Conversions</h3>
 
 <p>
-A conversion changes the <a href="#Types">type</a> of an expression
-to the type specified by the conversion.
-A conversion may appear literally in the source, or it may be <i>implied</i>
-by the context in which an expression appears.
-</p>
-
-<p>
-An <i>explicit</i> conversion is an expression of the form <code>T(x)</code>
+Conversions are expressions of the form <code>T(x)</code>
 where <code>T</code> is a type and <code>x</code> is an expression
 that can be converted to type <code>T</code>.
 </p>
@@ -4094,7 +3938,7 @@ func() int(x)    // x is converted to func() int (unambiguous)
 A <a href="#Constants">constant</a> value <code>x</code> can be converted to
 type <code>T</code> if <code>x</code> is <a href="#Representability">representable</a>
 by a value of <code>T</code>.
-As a special case, an integer constant <code>x</code> can be explicitly converted to a
+As a special case, an integer constant <code>x</code> can be converted to a
 <a href="#String_types">string type</a> using the
 <a href="#Conversions_to_and_from_a_string_type">same rule</a>
 as for non-constant <code>x</code>.
@@ -4828,13 +4672,13 @@ to the type of the operand to which it is assigned, with the following special c
 <li>
 	If an untyped constant
 	is assigned to a variable of interface type or the blank identifier,
-	the constant is first implicitly <a href="#Conversions">converted</a> to its
+	the constant is first <a href="#Conversions">converted</a> to its
 	 <a href="#Constants">default type</a>.
 </li>
 
 <li>
 	If an untyped boolean value is assigned to a variable of interface type or
-	the blank identifier, it is first implicitly converted to type <code>bool</code>.
+	the blank identifier, it is first converted to type <code>bool</code>.
 </li>
 </ol>
 
@@ -4920,14 +4764,14 @@ ExprSwitchCase = "case" ExpressionList | "default" .
 </pre>
 
 <p>
-If the switch expression evaluates to an untyped constant, it is first implicitly
+If the switch expression evaluates to an untyped constant, it is first
 <a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>;
-if it is an untyped boolean value, it is first implicitly converted to type <code>bool</code>.
+if it is an untyped boolean value, it is first converted to type <code>bool</code>.
 The predeclared untyped value <code>nil</code> cannot be used as a switch expression.
 </p>
 
 <p>
-If a case expression is untyped, it is first implicitly <a href="#Conversions">converted</a>
+If a case expression is untyped, it is first <a href="#Conversions">converted</a>
 to the type of the switch expression.
 For each (possibly converted) case expression <code>x</code> and the value <code>t</code>
 of the switch expression, <code>x == t</code> must be a valid <a href="#Comparison_operators">comparison</a>.
@@ -5279,7 +5123,7 @@ for i, s := range a {
 }
 
 var key string
-var val interface{}  // element type of m is assignable to val
+var val interface {}  // element type of m is assignable to val
 m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
 for key, val = range m {
 	h(key, val)
@@ -5702,10 +5546,7 @@ executes, the function value and parameters to the call are
 and saved anew but the actual function is not invoked.
 Instead, deferred functions are invoked immediately before
 the surrounding function returns, in the reverse order
-they were deferred. That is, if the surrounding function
-returns through an explicit <a href="#Return_statements">return statement</a>,
-deferred functions are executed <i>after</i> any result parameters are set
-by that return statement but <i>before</i> the function returns to its caller.
+they were deferred.
 If a deferred function value evaluates
 to <code>nil</code>, execution <a href="#Handling_panics">panics</a>
 when the function is invoked, not when the "defer" statement is executed.
@@ -5731,13 +5572,12 @@ for i := 0; i &lt;= 3; i++ {
 	defer fmt.Print(i)
 }
 
-// f returns 42
+// f returns 1
 func f() (result int) {
 	defer func() {
-		// result is accessed after it was set to 6 by the return statement
-		result *= 7
+		result++
 	}()
-	return 6
+	return 0
 }
 </pre>
 
@@ -6037,7 +5877,7 @@ floating-point type and the return type is the complex type
 with the corresponding floating-point constituents:
 <code>complex64</code> for <code>float32</code> arguments, and
 <code>complex128</code> for <code>float64</code> arguments.
-If one of the arguments evaluates to an untyped constant, it is first implicitly
+If one of the arguments evaluates to an untyped constant, it is first
 <a href="#Conversions">converted</a> to the type of the other argument.
 If both arguments evaluate to untyped constants, they must be non-complex
 numbers or their imaginary parts must be zero, and the return value of
@@ -6069,7 +5909,7 @@ var a = complex(2, -2)             // complex128
 const b = complex(1.0, -1.4)       // untyped complex constant 1 - 1.4i
 x := float32(math.Cos(math.Pi/2))  // float32
 var c64 = complex(5, -x)           // complex64
-var s int = complex(1, 0)          // untyped complex constant 1 + 0i can be converted to int
+var s uint = complex(1, 0)         // untyped complex constant 1 + 0i can be converted to uint
 _ = complex(1, 2&lt;&lt;s)               // illegal: 2 assumes floating-point type, cannot shift
 var rl = real(c64)                 // float32
 var im = imag(a)                   // float64
@@ -6269,7 +6109,7 @@ package and may be relative to a repository of installed packages.
 <p>
 Implementation restriction: A compiler may restrict ImportPaths to
 non-empty strings using only characters belonging to
-<a href="https://www.unicode.org/versions/Unicode6.3.0/">Unicode's</a>
+<a href="http://www.unicode.org/versions/Unicode6.3.0/">Unicode's</a>
 L, M, N, P, and S general categories (the Graphic characters without
 spaces) and may also exclude the characters
 <code>!"#$%&amp;'()*,:;&lt;=&gt;?[\]^`{|}</code>
@@ -6410,16 +6250,16 @@ var t T
 <h3 id="Package_initialization">Package initialization</h3>
 
 <p>
-Within a package, package-level variable initialization proceeds stepwise,
-with each step selecting the variable earliest in <i>declaration order</i>
-which has no dependencies on uninitialized variables.
+Within a package, package-level variables are initialized in
+<i>declaration order</i> but after any of the variables
+they <i>depend</i> on.
 </p>
 
 <p>
 More precisely, a package-level variable is considered <i>ready for
 initialization</i> if it is not yet initialized and either has
 no <a href="#Variable_declarations">initialization expression</a> or
-its initialization expression has no <i>dependencies</i> on uninitialized variables.
+its initialization expression has no dependencies on uninitialized variables.
 Initialization proceeds by repeatedly initializing the next package-level
 variable that is earliest in declaration order and ready for initialization,
 until there are no variables ready for initialization.
@@ -6431,23 +6271,6 @@ process ends, those variables are part of one or more initialization cycles,
 and the program is not valid.
 </p>
 
-<p>
-Multiple variables on the left-hand side of a variable declaration initialized
-by single (multi-valued) expression on the right-hand side are initialized
-together: If any of the variables on the left-hand side is initialized, all
-those variables are initialized in the same step.
-</p>
-
-<pre>
-var x = a
-var a, b = f() // a and b are initialized together, before x is initialized
-</pre>
-
-<p>
-For the purpose of package initialization, <a href="#Blank_identifier">blank</a>
-variables are treated like any other variables in declarations.
-</p>
-
 <p>
 The declaration order of variables declared in multiple files is determined
 by the order in which the files are presented to the compiler: Variables
@@ -6489,16 +6312,22 @@ or to a function or method that depends on <code>y</code>.
 </li>
 </ul>
 
+<p>
+Dependency analysis is performed per package; only references referring
+to variables, functions, and methods declared in the current package
+are considered.
+</p>
+
 <p>
 For example, given the declarations
 </p>
 
 <pre>
 var (
-	a = c + b  // == 9
-	b = f()    // == 4
-	c = f()    // == 5
-	d = 3      // == 5 after initialization has finished
+	a = c + b
+	b = f()
+	c = f()
+	d = 3
 )
 
 func f() int {
@@ -6509,39 +6338,6 @@ func f() int {
 
 <p>
 the initialization order is <code>d</code>, <code>b</code>, <code>c</code>, <code>a</code>.
-Note that the order of subexpressions in initialization expressions is irrelevant:
-<code>a = c + b</code> and <code>a = b + c</code> result in the same initialization
-order in this example.
-</p>
-
-<p>
-Dependency analysis is performed per package; only references referring
-to variables, functions, and (non-interface) methods declared in the current
-package are considered. If other, hidden, data dependencies exists between
-variables, the initialization order between those variables is unspecified.
-</p>
-
-<p>
-For instance, given the declarations
-</p>
-
-<pre>
-var x = I(T{}).ab()   // x has an undetected, hidden dependency on a and b
-var _ = sideEffect()  // unrelated to x, a, or b
-var a = b
-var b = 42
-
-type I interface      { ab() []int }
-type T struct{}
-func (T) ab() []int   { return []int{a, b} }
-</pre>
-
-<p>
-the variable <code>a</code> will be initialized after <code>b</code> but
-whether <code>x</code> is initialized before <code>b</code>, between
-<code>b</code> and <code>a</code>, or after <code>a</code>, and
-thus also the moment at which <code>sideEffect()</code> is called (before
-or after <code>x</code> is initialized) is not specified.
 </p>
 
 <p>

doc/help.html

@@ -8,7 +8,7 @@
 
 <h2 id="help">Get help</h2>
 
-<img class="gopher" src="/doc/gopher/help.png" alt=""/>
+<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>
@@ -27,11 +27,6 @@ The <a href="https://forum.golangbridge.org/">Go Forum</a> is a discussion
 forum for Go programmers.
 </p>
 
-<h3 id="discord"><a href="https://discord.gg/64C346U">Gophers Discord</a></h3>
-<p>
-Get live support and talk with other gophers on the Go Discord.
-</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>
 
@@ -59,6 +54,9 @@ for important announcements, such as the availability of new Go releases.
 <h3 id="twitter"><a href="https://twitter.com/golang">@golang at Twitter</a></h3>
 <p>The Go project's official Twitter account.</p>
 
+<h3 id="pluscom"><a href="https://plus.google.com/communities/114112804251407510571">Go+ community</a></h3>
+<p>A Google+ community for Go enthusiasts.</p>
+
 <h3 id="reddit"><a href="https://reddit.com/r/golang">golang sub-Reddit</a></h3>
 <p>
 The <a href="https://reddit.com/r/golang">golang sub-Reddit</a> is a place

doc/install-source.html

@@ -33,70 +33,74 @@ compiler using the GCC back end, see
 </p>
 
 <p>
-The Go compilers support the following instruction sets:
+The Go compilers support eight instruction sets.
+There are important differences in the quality of the compilers for the different
+architectures.
+</p>
 
 <dl>
 <dt>
-  <code>amd64</code>, <code>386</code>
+	<code>amd64</code> (also known as <code>x86-64</code>)
 </dt>
 <dd>
-  The <code>x86</code> instruction set, 64- and 32-bit.
+	A mature implementation.
 </dd>
 <dt>
-  <code>arm64</code>, <code>arm</code>
+	<code>386</code> (<code>x86</code> or <code>x86-32</code>)
 </dt>
 <dd>
-  The <code>ARM</code> instruction set, 64-bit (<code>AArch64</code>) and 32-bit.
+	Comparable to the <code>amd64</code> port.
 </dd>
 <dt>
-  <code>mips64</code>, <code>mips64le</code>, <code>mips</code>,  <code>mipsle</code>
+	<code>arm</code> (<code>ARM</code>)
 </dt>
 <dd>
-  The <code>MIPS</code> instruction set, big- and little-endian, 64- and 32-bit.
+	Supports Linux, FreeBSD, NetBSD, OpenBSD and Darwin binaries. Less widely used than the other ports.
 </dd>
 <dt>
-  <code>ppc64</code>, <code>ppc64le</code>
+	<code>arm64</code> (<code>AArch64</code>)
 </dt>
 <dd>
-  The 64-bit PowerPC instruction set, big- and little-endian.
+	Supports Linux and Darwin binaries. New in 1.5 and not as well exercised as other ports.
 </dd>
 <dt>
-  <code>riscv64</code>
+	<code>ppc64, ppc64le</code> (64-bit PowerPC big- and little-endian)
 </dt>
 <dd>
-  The 64-bit RISC-V instruction set.
+	Supports Linux binaries. New in 1.5 and not as well exercised as other ports.
 </dd>
 <dt>
-  <code>s390x</code>
+	<code>mips, mipsle</code> (32-bit MIPS big- and little-endian)
 </dt>
 <dd>
-  The IBM z/Architecture.
+	Supports Linux binaries. New in 1.8 and not as well exercised as other ports.
 </dd>
 <dt>
-  <code>wasm</code>
+	<code>mips64, mips64le</code> (64-bit MIPS big- and little-endian)
 </dt>
 <dd>
-  <a href="https://webassembly.org">WebAssembly</a>.
+	Supports Linux binaries. New in 1.6 and not as well exercised as other ports.
+</dd>
+<dt>
+	<code>s390x</code> (IBM System z)
+</dt>
+<dd>
+	Supports Linux binaries. New in 1.7 and not as well exercised as other ports.
 </dd>
 </dl>
+
+<p>
+Except for things like low-level operating system interface code, the run-time
+support is the same in all ports and includes a mark-and-sweep garbage
+collector, efficient array and string slicing, and support for efficient
+goroutines, such as stacks that grow and shrink on demand.
 </p>
 
 <p>
-The compilers can target the AIX, Android, DragonFly BSD, FreeBSD,
-Illumos, Linux, macOS/iOS (Darwin), NetBSD, OpenBSD, Plan 9, Solaris,
-and Windows operating systems (although not all operating systems
-support all architectures).
-</p>
-
-<p>
-A list of ports which are considered "first class" is available at the
-<a href="/wiki/PortingPolicy#first-class-ports">first class ports</a>
-wiki page.
-</p>
-
-<p>
-The full set of supported combinations is listed in the
-discussion of <a href="#environment">environment variables</a> below.
+The compilers can target the DragonFly BSD, FreeBSD, Linux, NetBSD, OpenBSD,
+OS X (Darwin), Plan 9, Solaris and Windows operating systems.
+The full set of supported combinations is listed in the discussion of
+<a href="#environment">environment variables</a> below.
 </p>
 
 <p>
@@ -112,19 +116,23 @@ Go does not support CentOS 6 on these systems.
 
 </div>
 
-<h2 id="go14">Install Go compiler binaries for bootstrap</h2>
+<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 scripts that do the initial build of the tools look for a "go" command
-in <code>$PATH</code>, so as long as you have Go installed in your
-system and configured in your <code>$PATH</code>, you are ready to build Go
-from source. 
-Or if you prefer you can set <code>$GOROOT_BOOTSTRAP</code> to the
-root of a Go installation to use to build the new Go toolchain;
-<code>$GOROOT_BOOTSTRAP/bin/go</code> should be the go command to use.</p>
+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>.
+</p>
 
-<h3 id="bootstrapFromBinaryRelease">Bootstrap toolchain from binary release</h3>
+<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.
+</p>
 
 <p>
 To use a binary release as a bootstrap toolchain, see
@@ -132,8 +140,6 @@ To use a binary release as a bootstrap toolchain, see
 packaged Go distribution.
 </p>
 
-<h3 id="bootstrapFromSource">Bootstrap toolchain from source</h3>
-
 <p>
 To build a bootstrap toolchain from source, use
 either the git branch <code>release-branch.go1.4</code> or
@@ -147,17 +153,6 @@ the environment, and run <code>make.bash</code> (or,
 on Windows, <code>make.bat</code>).
 </p>
 
-<p>
-Once the Go 1.4 source has been unpacked into your GOROOT_BOOTSTRAP directory,
-you must keep this git clone instance checked out to branch
-<code>release-branch.go1.4</code>.  Specifically, do not attempt to reuse
-this git clone in the later step named "Fetch the repository."  The go1.4
-bootstrap toolchain <b>must be able</b> to properly traverse the go1.4 sources
-that it assumes are present under this repository root.
-</p>
-
-<h3 id="bootstrapFromCrosscompiledSource">Bootstrap toolchain from cross-compiled source</h3>
-
 <p>
 To cross-compile a bootstrap toolchain from source, which is
 necessary on systems Go 1.4 did not target (for
@@ -180,8 +175,6 @@ That tree can be copied to a machine of the given target type
 and used as <code>GOROOT_BOOTSTRAP</code> to bootstrap a local build.
 </p>
 
-<h3 id="bootstrapFromGccgo">Bootstrap toolchain using gccgo</h3>
-
 <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
@@ -204,7 +197,7 @@ have a <code>git</code> command before proceeding.)
 <p>
 If you do not have a working Git installation,
 follow the instructions on the
-<a href="https://git-scm.com/downloads">Git downloads</a> page.
+<a href="http://git-scm.com/downloads">Git downloads</a> page.
 </p>
 
 <h2 id="ccompiler">(Optional) Install a C compiler</h2>
@@ -225,14 +218,15 @@ To build without <code>cgo</code>, set the environment variable
 
 <h2 id="fetch">Fetch the repository</h2>
 
-<p>Change to the directory where you intend to install Go, and make sure
-the <code>goroot</code> directory does not exist. Then clone the repository
-and check out the latest release tag (<code class="versionTag">go1.12</code>,
-for example):</p>
+<p>Go will install to a directory named <code>go</code>.
+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>
 
 <pre>
-$ git clone https://go.googlesource.com/go goroot
-$ cd goroot
+$ git clone https://go.googlesource.com/go
+$ cd go
 $ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></span>
 </pre>
 
@@ -240,20 +234,6 @@ $ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></span>
 Where <code>&lt;tag&gt;</code> is the version string of the release.
 </p>
 
-<p>Go will be installed in the directory where it is checked out. For example,
-if Go is checked out in <code>$HOME/goroot</code>, executables will be installed
-in <code>$HOME/goroot/bin</code>. The directory may have any name, but note
-that if Go is checked out in <code>$HOME/go</code>, it will conflict with
-the default location of <code>$GOPATH</code>.
-See <a href="#gopath"><code>GOPATH</code></a> below.</p>
-
-<p>
-Reminder: If you opted to also compile the bootstrap binaries from source (in an
-earlier section), you still need to <code>git clone</code> again at this point
-(to checkout the latest <code>&lt;tag&gt;</code>), because you must keep your
-go1.4 repository distinct.
-</p>
-
 <h2 id="head">(Optional) Switch to the master branch</h2>
 
 <p>If you intend to modify the go source code, and
@@ -369,7 +349,15 @@ provides <b>essential setup instructions</b> for using the Go tools.
 <p>
 The source code for several Go tools (including <a href="/cmd/godoc/">godoc</a>)
 is kept in <a href="https://golang.org/x/tools">the go.tools repository</a>.
-To install one of the tools (<code>godoc</code> in this case):
+To install all of them, run the <code>go</code> <code>get</code> command:
+</p>
+
+<pre>
+$ go get golang.org/x/tools/cmd/...
+</pre>
+
+<p>
+Or if you just want to install a specific command (<code>godoc</code> in this case):
 </p>
 
 <pre>
@@ -386,11 +374,21 @@ You must also have a workspace (<code>GOPATH</code>) set up;
 see <a href="/doc/code.html">How to Write Go Code</a> for the details.
 </p>
 
+<p>
+<b>Note</b>: The <code>go</code> command will install the <code>godoc</code>
+binary to <code>$GOROOT/bin</code> (or <code>$GOBIN</code>) and the
+<code>cover</code> and <code>vet</code> binaries to
+<code>$GOROOT/pkg/tool/$GOOS_$GOARCH</code>.
+You can access the latter commands with
+"<code>go</code> <code>tool</code> <code>cover</code>" and
+"<code>go</code> <code>tool</code> <code>vet</code>".
+</p>
+
 <h2 id="community">Community resources</h2>
 
 <p>
 The usual community resources such as
-<code>#go-nuts</code> on the <a href="https://freenode.net/">Freenode</a> IRC server
+<code>#go-nuts</code> on the <a href="http://freenode.net/">Freenode</a> IRC server
 and the
 <a href="//groups.google.com/group/golang-nuts">Go Nuts</a>
 mailing list have active developers that can help you with problems
@@ -461,43 +459,6 @@ but move it elsewhere after the build, set
 </p>
 </li>
 
-<li id="gopath"><code>$GOPATH</code>
-<p>
-The directory where Go projects outside the Go distribution are typically
-checked out. For example, <code>golang.org/x/tools</code> might be checked out
-to <code>$GOPATH/src/golang.org/x/tools</code>. Executables outside the
-Go distribution are installed in <code>$GOPATH/bin</code> (or
-<code>$GOBIN</code>, if set). Modules are downloaded and cached in
-<code>$GOPATH/pkg/mod</code>.
-</p>
-
-<p>The default location of <code>$GOPATH</code> is <code>$HOME/go</code>,
-and it's not usually necessary to set <code>GOPATH</code> explicitly. However,
-if you have checked out the Go distribution to <code>$HOME/go</code>,
-you must set <code>GOPATH</code> to another location to avoid conflicts.
-</p>
-</li>
-
-<li><code>$GOBIN</code>
-<p>
-The directory where executables outside the Go distribution are installed
-using the <a href="/cmd/go">go command</a>. For example,
-<code>go get golang.org/x/tools/cmd/godoc</code> downloads, builds, and
-installs <code>$GOBIN/godoc</code>. By default, <code>$GOBIN</code> is
-<code>$GOPATH/bin</code> (or <code>$HOME/go/bin</code> if <code>GOPATH</code>
-is not set). After installing, you will want to add this directory to
-your <code>$PATH</code> so you can use installed tools.
-</p>
-
-<p>
-Note that the Go distribution's executables are installed in
-<code>$GOROOT/bin</code> (for executables invoked by people) or
-<code>$GOTOOLDIR</code> (for executables invoked by the go command;
-defaults to <code>$GOROOT/pkg/$GOOS_GOARCH</code>) instead of
-<code>$GOBIN</code>.
-</p>
-</li>
-
 <li><code>$GOOS</code> and <code>$GOARCH</code>
 <p>
 The name of the target operating system and compilation architecture.
@@ -507,48 +468,34 @@ These default to the values of <code>$GOHOSTOS</code> and
 
 <p>
 Choices for <code>$GOOS</code> are
-<code>android</code>, <code>darwin</code> (macOS/iOS),
-<code>dragonfly</code>, <code>freebsd</code>, <code>illumos</code>, <code>js</code>,
+<code>darwin</code> (Mac OS X 10.8 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>.
-</p>
-
-<p>
 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),
-<code>s390x</code> (IBM System z 64-bit, big-endian), and
-<code>wasm</code> (WebAssembly 32-bit).
-</p>
-
-<p>
+<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).
 The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <table cellpadding="0">
 <tr>
 <th width="50"></th><th align="left" width="100"><code>$GOOS</code></th> <th align="left" width="100"><code>$GOARCH</code></th>
 </tr>
 <tr>
-<td></td><td><code>aix</code></td> <td><code>ppc64</code></td>
-</tr>
-<tr>
-<td></td><td><code>android</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>android</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
 <td></td><td><code>android</code></td> <td><code>arm</code></td>
 </tr>
 <tr>
-<td></td><td><code>android</code></td> <td><code>arm64</code></td>
+<td></td><td><code>darwin</code></td> <td><code>386</code></td>
 </tr>
 <tr>
 <td></td><td><code>darwin</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
+<td></td><td><code>darwin</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
 <td></td><td><code>darwin</code></td> <td><code>arm64</code></td>
 </tr>
 <tr>
@@ -564,12 +511,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>freebsd</code></td> <td><code>arm</code></td>
 </tr>
 <tr>
-<td></td><td><code>illumos</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
-<td></td><td><code>js</code></td> <td><code>wasm</code></td>
-</tr>
-<tr>
 <td></td><td><code>linux</code></td> <td><code>386</code></td>
 </tr>
 <tr>
@@ -600,9 +541,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>linux</code></td> <td><code>mips64le</code></td>
 </tr>
 <tr>
-<td></td><td><code>linux</code></td> <td><code>riscv64</code></td>
-</tr>
-<tr>
 <td></td><td><code>linux</code></td> <td><code>s390x</code></td>
 </tr>
 <tr>
@@ -624,18 +562,12 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>openbsd</code></td> <td><code>arm</code></td>
 </tr>
 <tr>
-<td></td><td><code>openbsd</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
 <td></td><td><code>plan9</code></td> <td><code>386</code></td>
 </tr>
 <tr>
 <td></td><td><code>plan9</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
-<td></td><td><code>plan9</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
 <td></td><td><code>solaris</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
@@ -663,6 +595,17 @@ For example, you should not set <code>$GOHOSTARCH</code> to
 <code>arm</code> on an x86 system.
 </p>
 
+<li><code>$GOBIN</code>
+<p>
+The location where Go binaries will be installed.
+The default is <code>$GOROOT/bin</code>.
+After installing, you will want to arrange to add this
+directory to your <code>$PATH</code>, so you can use the tools.
+If <code>$GOBIN</code> is set, the <a href="/cmd/go">go command</a>
+installs all commands there.
+</p>
+</li>
+
 <li><code>$GO386</code> (for <code>386</code> only, default is auto-detected
 if built on either <code>386</code> or <code>amd64</code>, <code>387</code> otherwise)
 <p>
@@ -696,35 +639,16 @@ contains further details regarding Go's ARM support.
 </p>
 </li>
 
-<li><code>$GOMIPS</code> (for <code>mips</code> and <code>mipsle</code> only) <br> <code>$GOMIPS64</code> (for <code>mips64</code> and <code>mips64le</code> only)
+<li><code>$GOMIPS</code> (for <code>mips</code> and <code>mipsle</code> only)
 <p>
-	These variables set whether to use floating point instructions. Set to "<code>hardfloat</code>" to use floating point instructions; this is the default.  Set to "<code>softfloat</code>" to use soft floating point.
-</p>
-</li>
-
-<li><code>$GOPPC64</code> (for <code>ppc64</code> and <code>ppc64le</code> only)
-<p>
-This variable sets the processor level (i.e. Instruction Set Architecture version)
-for which the compiler will target. The default is <code>power8</code>.
+This sets whether to use floating point instructions.
 </p>
 <ul>
-	<li><code>GOPPC64=power8</code>: generate ISA v2.07 instructions</li>
-	<li><code>GOPPC64=power9</code>: generate ISA v3.00 instructions</li>
+	<li><code>GOMIPS=hardfloat</code>: use floating point instructions (the default)</li>
+	<li><code>GOMIPS=softfloat</code>: use soft floating point</li>
 </ul>
 </li>
 
-
-<li><code>$GOWASM</code> (for <code>wasm</code> only)
-	<p>
-	This variable is a comma separated list of <a href="https://github.com/WebAssembly/proposals">experimental WebAssembly features</a> that the compiled WebAssembly binary is allowed to use.
-	The default is to use no experimental features.
-	</p>
-	<ul>
-		<li><code>GOWASM=satconv</code>: generate <a href="https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md">saturating (non-trapping) float-to-int conversions</a></li>
-		<li><code>GOWASM=signext</code>: generate <a href="https://github.com/WebAssembly/sign-extension-ops/blob/master/proposals/sign-extension-ops/Overview.md">sign-extension operators</a></li>
-	</ul>
-</li>
-
 </ul>
 
 <p>
@@ -746,6 +670,7 @@ something like this:
 </p>
 
 <pre>
+export GOROOT=$HOME/go1.X
 export GOARCH=amd64
 export GOOS=linux
 </pre>

doc/install.html

@@ -17,7 +17,7 @@
 <p>
 <a href="/dl/" target="_blank">Official binary
 distributions</a> are available for the FreeBSD (release 10-STABLE and above),
-Linux, macOS (10.11 and above), and Windows operating systems and
+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.
 </p>
@@ -49,15 +49,15 @@ If your OS or architecture is not on the list, you may be able to
 <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.11 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 valign='top'><td>Windows 7, Server 2008R2 or later</td> <td>amd64, 386</td> <td>use MinGW (<code>386</code>) or MinGW-W64 (<code>amd64</code>) gcc<sup>&#8224;</sup>.<br>No need for cygwin or msys.</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>
 </table>
 
 <p>
 <sup>&#8224;</sup>A C compiler 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="https://developer.apple.com/Xcode/">Xcode</a>. If you have already
+<a href="http://developer.apple.com/Xcode/">Xcode</a>. If you have already
 installed Xcode 4.3+, you can install it from the Components tab of the
 Downloads preferences panel.
 </p>
@@ -74,7 +74,7 @@ first <a href="#uninstall">remove the existing version</a>.
 
 <div id="tarballInstructions">
 
-<h3 id="tarball">Linux, macOS, and FreeBSD tarballs</h3>
+<h3 id="tarball">Linux, Mac OS X, and FreeBSD tarballs</h3>
 
 <p>
 <a href="/dl/">Download the archive</a>
@@ -114,11 +114,36 @@ or execute them from the profile using a command such as
 <code>source $HOME/.profile</code>.
 </p>
 
+<h4 id="tarball_non_standard">Installing to a custom location</h4>
+
+<p>
+The Go binary distributions assume they will be installed in
+<code>/usr/local/go</code> (or <code>c:\Go</code> under Windows),
+but it is possible to install the Go tools to a different location.
+In this case you must set the <code>GOROOT</code> environment variable
+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>:
+</p>
+
+<pre>
+export GOROOT=$HOME/go1.X
+export PATH=$PATH:$GOROOT/bin
+</pre>
+
+<p>
+<b>Note</b>: <code>GOROOT</code> must be set only when installing to a custom
+location.
+</p>
+
 </div><!-- tarballInstructions -->
 
 <div id="darwinPackageInstructions">
 
-<h3 id="macos"><div id="osx"></div>macOS package installer</h3>
+<h3 id="osx">Mac OS X package installer</h3>
 
 <p>
 <a href="/dl/">Download the package file</a>,
@@ -171,6 +196,11 @@ command prompts for the change to take effect.
 <a href="/dl/">Download the zip file</a> and extract it into the directory of your choice (we suggest <code>c:\Go</code>).
 </p>
 
+<p>
+If you chose a directory other than <code>c:\Go</code>,
+you must set the <code>GOROOT</code> environment variable to your chosen path.
+</p>
+
 <p>
 Add the <code>bin</code> subdirectory of your Go root (for example, <code>c:\Go\bin</code>) to your <code>PATH</code> environment variable.
 </p>
@@ -192,11 +222,20 @@ Settings" option inside the "System" control panel.
 <h2 id="testing">Test your installation</h2>
 
 <p>
-Check that Go is installed correctly by building a simple program, as follows.
+Check that Go is installed correctly by setting up a workspace
+and building a simple program, as follows.
 </p>
 
 <p>
-Create a file named <code>hello.go</code> that looks like:
+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>.)
+</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:
 </p>
 
 <pre>
@@ -214,17 +253,19 @@ Then build it with the <code>go</code> tool:
 </p>
 
 <pre class="testUnix">
-$ <b>go build hello.go</b>
+$ <b>cd $HOME/go/src/hello</b>
+$ <b>go build</b>
 </pre>
 
 <pre class="testWindows">
-C:\Users\Gopher\go\src\hello&gt; <b>go build hello.go</b>
+C:\&gt; <b>cd %USERPROFILE%\go\src\hello</b>
+C:\Users\Gopher\go\src\hello&gt; <b>go build</b>
 </pre>
 
 <p>
 The command above will build an executable named
 <code class="testUnix">hello</code><code class="testWindows">hello.exe</code>
-in the current directory alongside your source code.
+in the directory alongside your source code.
 Execute it to see the greeting:
 </p>
 
@@ -242,6 +283,12 @@ 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> <code>-i</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,
@@ -249,45 +296,12 @@ which describes some essential concepts about using the Go tools.
 </p>
 
 
-<h2 id="extra_versions">Installing extra Go versions</h2>
-
-<p>
-It may be useful to have multiple Go versions installed on the same machine, for
-example, to ensure that a package's tests pass on multiple Go versions.
-Once you have one Go version installed, you can install another (such as 1.10.7)
-as follows:
-</p>
-
-<pre>
-$ go get golang.org/dl/go1.10.7
-$ go1.10.7 download
-</pre>
-
-<p>
-The newly downloaded version can be used like <code>go</code>:
-</p>
-
-<pre>
-$ go1.10.7 version
-go version go1.10.7 linux/amd64
-</pre>
-
-<p>
-All Go versions available via this method are listed on
-<a href="https://godoc.org/golang.org/dl#pkg-subdirectories">the download page</a>.
-You can find where each of these extra Go versions is installed by looking
-at its <code>GOROOT</code>; for example, <code>go1.10.7 env GOROOT</code>.
-To uninstall a downloaded version, just remove its <code>GOROOT</code> directory
-and the <code>goX.Y.Z</code> binary.
-</p>
-
-
 <h2 id="uninstall">Uninstalling Go</h2>
 
 <p>
 To remove an existing Go installation from your system delete the
 <code>go</code> directory. This is usually <code>/usr/local/go</code>
-under Linux, macOS, and FreeBSD or <code>c:\Go</code>
+under Linux, Mac OS X, and FreeBSD or <code>c:\Go</code>
 under Windows.
 </p>
 
@@ -296,7 +310,7 @@ You should also remove the Go <code>bin</code> directory from your
 <code>PATH</code> environment variable.
 Under Linux and FreeBSD you should edit <code>/etc/profile</code> or
 <code>$HOME/.profile</code>.
-If you installed Go with the <a href="#macos">macOS package</a> then you
+If you installed Go with the <a href="#osx">Mac OS X package</a> then you
 should remove the <code>/etc/paths.d/go</code> file.
 Windows users should read the section about <a href="#windows_env">setting
 environment variables under Windows</a>.

doc/play/hello.go

@@ -1,5 +1,3 @@
-// You can edit this code!
-// Click here and start typing.
 package main
 
 import "fmt"

doc/progs/eff_qr.go

@@ -41,9 +41,9 @@ const templateStr = `
 <br>
 <br>
 {{end}}
-<form action="/" name=f method="GET">
-	<input maxLength=1024 size=70 name=s value="" title="Text to QR Encode">
-	<input type=submit value="Show QR" name=qr>
+<form action="/" name=f method="GET"><input maxLength=1024 size=70
+name=s value="" title="Text to QR Encode"><input type=submit
+value="Show QR" name=qr>
 </form>
 </body>
 </html>

doc/progs/eff_sequence.go

@@ -28,18 +28,11 @@ func (s Sequence) Swap(i, j int) {
 	s[i], s[j] = s[j], s[i]
 }
 
-// Copy returns a copy of the Sequence.
-func (s Sequence) Copy() Sequence {
-	copy := make(Sequence, 0, len(s))
-	return append(copy, s...)
-}
-
 // Method for printing - sorts the elements before printing.
 func (s Sequence) String() string {
-	s = s.Copy() // Make a copy; don't overwrite argument.
 	sort.Sort(s)
 	str := "["
-	for i, elem := range s { // Loop is O(N²); will fix that in next example.
+	for i, elem := range s {
 		if i > 0 {
 			str += " "
 		}

doc/progs/run.go

@@ -16,7 +16,6 @@ import (
 	"regexp"
 	"runtime"
 	"strings"
-	"time"
 )
 
 const usage = `go run run.go [tests]
@@ -27,8 +26,6 @@ Tests may be specified without their .go suffix.
 `
 
 func main() {
-	start := time.Now()
-
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, usage)
 		flag.PrintDefaults()
@@ -73,9 +70,6 @@ func main() {
 		}
 	}
 	os.Remove(tmpdir)
-	if rc == 0 {
-		fmt.Printf("ok\t%s\t%s\n", filepath.Base(os.Args[0]), time.Since(start).Round(time.Millisecond))
-	}
 	os.Exit(rc)
 }
 
@@ -84,7 +78,7 @@ func main() {
 // and checks that the output matches the regexp want.
 func test(tmpdir, file, want string) error {
 	// Build the program.
-	prog := filepath.Join(tmpdir, file+".exe")
+	prog := filepath.Join(tmpdir, file)
 	cmd := exec.Command("go", "build", "-o", prog, file+".go")
 	out, err := cmd.CombinedOutput()
 	if err != nil {
@@ -105,7 +99,7 @@ func test(tmpdir, file, want string) error {
 
 	// Canonicalize output.
 	out = bytes.TrimRight(out, "\n")
-	out = bytes.ReplaceAll(out, []byte{'\n'}, []byte{' '})
+	out = bytes.Replace(out, []byte{'\n'}, []byte{' '}, -1)
 
 	// Check the result.
 	match, err := regexp.Match(want, out)

doc/root.html

@@ -0,0 +1,164 @@
+<!--{
+	"Path": "/",
+	"Template": true
+}-->
+
+<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!
+// Click here and start typing.
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, 世界")
+}</textarea>
+</div>
+<div class="output">
+<pre>
+Hello, 世界
+</pre>
+</div>
+<div class="buttons">
+<a class="run" href="#" title="Run this code [shift-enter]">Run</a>
+{{if not $.GoogleCN}}
+<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}}
+</div>
+<div class="toys">
+<select>
+	<option value="hello.go">Hello, World!</option>
+	<option value="life.go">Conway's Game of Life</option>
+	<option value="fib.go">Fibonacci Closure</option>
+	<option value="peano.go">Peano Integers</option>
+	<option value="pi.go">Concurrent pi</option>
+	<option value="sieve.go">Concurrent Prime Sieve</option>
+	<option value="solitaire.go">Peg Solitaire Solver</option>
+	<option value="tree.go">Tree Comparison</option>
+</select>
+</div>
+</div>
+
+</div>
+
+<div class="right">
+
+<div id="about">
+Go is an open source programming language that makes it easy to build
+simple, reliable, and efficient software.
+</div>
+
+<div id="gopher"></div>
+
+<a href="/dl/" id="start">
+<span class="big">Download Go</span>
+<span class="desc">
+Binary distributions available for<br>
+Linux, Mac OS X, Windows, and more.
+</span>
+</a>
+
+</div>
+
+<div style="clear: both"></div>
+
+{{if not $.GoogleCN}}
+<div class="left">
+  <div id="video">
+    <div class="rootHeading">Featured video</div>
+	<div class="js-frontpage-video" style="--aspect-ratio-padding: 58.07%;"><iframe width="415" height="241" src="//www.youtube.com/embed/ytEkHepK08c" frameborder="0" allowfullscreen></iframe></div>
+  </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>
+{{end}}
+
+<div style="clear: both;"></div>
+
+<script>
+(function() {
+	'use strict';
+
+	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()
+		}
+	});
+
+	{{if not $.GoogleCN}}
+
+	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.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);
+		}
+	}
+
+	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);
+		// Compute the aspect ratio (as a percentage) of the video
+		// using the fixed width 415 and the height of the current video, v.h.
+		var ar = 100*v.h/415;
+		$('.js-frontpage-video').attr('style', '--aspect-ratio-padding: ' + ar + '%;');
+	});
+
+	{{end}}
+})();
+</script>

doc/security.html

@@ -0,0 +1,180 @@
+<!--{
+	"Title": "Go Security Policy",
+	"Path":  "/security",
+	"Template": true
+}-->
+
+<h2>Implementation</h2>
+
+<h3>Reporting a Security Bug</h3>
+
+<p>
+Please report to us any issues you find.
+This document explains how to do that and what to expect in return.
+</p>
+
+<p>
+All security bugs in the Go distribution should be reported by email to
+<a href="mailto:security@golang.org">security@golang.org</a>.
+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).
+</p>
+
+<p>
+Please use a descriptive subject line for your report email.
+After the initial reply to your report, the security team will endeavor to keep
+you informed of the progress being made towards a fix and full announcement.
+These updates will be sent at least every five days.
+In reality, this is more likely to be every 24-48 hours.
+</p>
+
+<p>
+If you have not received a reply to your email within 48 hours or you have not
+heard from the security team for the past five days please contact the Go
+security team directly:
+</p>
+
+<ul>
+<li>Primary security coordinator: <a href="mailto:adg@golang.org">Andrew Gerrand</a>  (<a href="https://drive.google.com/a/google.com/file/d/0B42ZAZN5yFufRldybEVNandRN2c/view">public key</a>).</li>
+<li>Secondary coordinator: <a href="mailto:agl@golang.org">Adam Langley</a> (<a href="https://www.imperialviolet.org/key.asc">public key</a>).</li>
+<li>If you receive no response, mail <a href="mailto:golang-dev@googlegroups.com">golang-dev@googlegroups.com</a> or use the <a href="https://groups.google.com/forum/#!forum/golang-dev">golang-dev web interface</a>.</li>
+</ul>
+
+<p>
+Please note that golang-dev is a public discussion forum.
+When escalating on this list, please do not disclose the details of the issue.
+Simply state that you're trying to reach a member of the security team.
+</p>
+
+<h3>Flagging Existing Issues as Security-related</h3>
+
+<p>
+If you believe that an <a href="https://golang.org/issue">existing issue</a>
+is security-related, we ask that you send an email to
+<a href="mailto:security@golang.org">security@golang.org</a>.
+The email should include the issue ID and a short description of why it should
+be handled according to this security policy.
+</p>
+
+<h3>Disclosure Process</h3>
+
+<p>The Go project uses the following disclosure process:</p>
+
+<ol>
+<li>Once the security report is received it is assigned a primary handler.
+This person coordinates the fix and release process.</li>
+<li>The issue is confirmed and a list of affected software is determined.</li>
+<li>Code is audited to find any potential similar problems.</li>
+<li>If it is determined, in consultation with the submitter, that a CVE-ID is
+required, the primary handler obtains one via email to
+<a href="http://oss-security.openwall.org/wiki/mailing-lists/distros">oss-distros</a>.</li>
+<li>Fixes are prepared for the two most recent major releases and the head/master
+revision. These fixes are not yet committed to the public repository.</li>
+<li>A notification is sent to the
+<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
+mailing list to give users time to prepare their systems for the update.</li>
+<li>Three working days following this notification, the fixes are applied to
+the <a href="https://go.googlesource.com/go">public repository</a> and a new
+Go release is issued.</li>
+<li>On the date that the fixes are applied, announcements are sent to
+<a href="https://groups.google.com/group/golang-announce">golang-announce</a>,
+<a href="https://groups.google.com/group/golang-dev">golang-dev</a>, and
+<a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>.
+</ol>
+
+<p>
+This process can take some time, especially when coordination is required with
+maintainers of other projects. Every effort will be made to handle the bug in
+as timely a manner as possible, however it's important that we follow the
+process described above to ensure that disclosures are handled consistently.
+</p>
+
+<p>
+For security issues that include the assignment of a CVE-ID,
+the issue is listed publicly under the
+<a href="https://www.cvedetails.com/vulnerability-list/vendor_id-14185/Golang.html">"Golang" product on the CVEDetails website</a>
+as well as the
+<a href="https://web.nvd.nist.gov/view/vuln/search">National Vulnerability Disclosure site</a>.
+</p>
+
+<h3>Receiving Security Updates</h3>
+
+<p>
+The best way to receive security announcements is to subscribe to the
+<a href="https://groups.google.com/forum/#!forum/golang-announce">golang-announce</a>
+mailing list. Any messages pertaining to a security issue will be prefixed
+with <code>[security]</code>.
+</p>
+
+<h3>Comments on This Policy</h3>
+
+<p>
+If you have any suggestions to improve this policy, please send an email to
+<a href="mailto:golang-dev@golang.org">golang-dev@golang.org</a> for discussion.
+</p>
+
+<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
+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+=WE0r
+-----END PGP PUBLIC KEY BLOCK-----
+</pre>

lib/time/README

@@ -3,7 +3,7 @@ the code and data maintained as part of the IANA Time Zone Database.
 The IANA asserts that the database is in the public domain.
 
 For more information, see
-https://www.iana.org/time-zones
+http://www.iana.org/time-zones
 ftp://ftp.iana.org/tz/code/tz-link.htm
 http://tools.ietf.org/html/rfc6557
 

lib/time/update.bash

@@ -5,35 +5,47 @@
 
 # This script rebuilds the time zone files using files
 # downloaded from the ICANN/IANA distribution.
-# Consult https://www.iana.org/time-zones for the latest versions.
+# Consult http://www.iana.org/time-zones for the latest versions.
 
 # Versions to use.
-CODE=2020a
-DATA=2020a
+CODE=2017c
+DATA=2017c
 
 set -e
 rm -rf work
 mkdir work
 cd work
 mkdir zoneinfo
-curl -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
-curl -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
+curl -L -O http://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
+curl -L -O http://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
 tar xzf tzcode$CODE.tar.gz
 tar xzf tzdata$DATA.tar.gz
 
+# Turn off 64-bit output in time zone files.
+# We don't need those until 2037.
+perl -p -i -e 's/pass <= 2/pass <= 1/' zic.c
+
 make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo posix_only
 
+# America/Los_Angeles should not be bigger than 1100 bytes.
+# If it is, we probably failed to disable the 64-bit output, which
+# triples the size of the files.
+size=$(ls -l zoneinfo/America/Los_Angeles | awk '{print $5}')
+if [ $size -gt 1200 ]; then
+	echo 'zone file too large; 64-bit edit failed?' >&2
+	exit 2
+fi
+
 cd zoneinfo
 rm -f ../../zoneinfo.zip
 zip -0 -r ../../zoneinfo.zip *
 cd ../..
 
-go generate time/tzdata
-
 echo
-if [ "$1" = "-work" ]; then
+if [ "$1" = "-work" ]; then 
 	echo Left workspace behind in work/.
 else
 	rm -rf work
 fi
 echo New time zone files in zoneinfo.zip.
+

misc/android/README

@@ -6,20 +6,6 @@ mobile subrepository:
 
 	https://github.com/golang/mobile
 
-To run the standard library tests, enable Cgo and use an appropriate
-C compiler from the Android NDK. For example,
-
-	CGO_ENABLED=1 \
-	GOOS=android \
-	GOARCH=arm64 \
-	CC_FOR_TARGET=$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android21-clang \
-	./all.bash
-
-To run tests on the Android device, add the bin directory to PATH so the
-go tool can find the go_android_$GOARCH_exec wrapper generated by
-make.bash. For example, to run the go1 benchmarks
-
-	export PATH=$GOROOT/bin:$PATH
-	cd $GOROOT/test/bench/go1/
-	GOOS=android GOARCH=arm64 go test -bench=. -count=N -timeout=T
+To run the standard library tests, see androidtest.bash. Run it as
 
+	CC_FOR_TARGET=.../ndk-gcc GOARCH=arm GOARM=7 ./androidtest.bash

misc/android/cleaner.go

@@ -0,0 +1,39 @@
+// 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.
+
+// Cleaner removes anything from /data/local/tmp/goroot not on a builtin list.
+// Used by androidtest.bash.
+package main
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func main() {
+	const goroot = "/data/local/tmp/goroot"
+	expect := make(map[string]bool)
+	for _, f := range strings.Split(files, "\n") {
+		expect[filepath.Join(goroot, f)] = true
+	}
+
+	err := filepath.Walk(goroot, func(path string, info os.FileInfo, err error) error {
+		if expect[path] {
+			return nil
+		}
+		log.Printf("removing %s", path)
+		if err := os.RemoveAll(path); err != nil {
+			return err
+		}
+		if info.IsDir() {
+			return filepath.SkipDir
+		}
+		return nil
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+}

misc/android/go_android_exec.go

@@ -2,33 +2,30 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
 // This program can be used as go_android_GOARCH_exec by the Go tool.
 // It executes binaries on an android device using adb.
 package main
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"go/build"
 	"io"
-	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
-	"os/signal"
 	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
-	"syscall"
 )
 
-func run(args ...string) (string, error) {
-	cmd := adbCmd(args...)
+func run(args ...string) string {
+	if flags := os.Getenv("GOANDROID_ADB_FLAGS"); flags != "" {
+		args = append(strings.Split(flags, " "), args...)
+	}
 	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.
@@ -40,302 +37,108 @@ func run(args ...string) (string, error) {
 	// forcing cmd.Run to use another pipe and goroutine to pass
 	// along stderr from adb.
 	cmd.Stderr = struct{ io.Writer }{os.Stderr}
+	log.Printf("adb %s", strings.Join(args, " "))
 	err := cmd.Run()
 	if err != nil {
-		return "", fmt.Errorf("adb %s: %v", strings.Join(args, " "), err)
+		log.Fatalf("adb %s: %v", strings.Join(args, " "), err)
 	}
-	return buf.String(), nil
-}
-
-func adb(args ...string) error {
-	if out, err := adbCmd(args...).CombinedOutput(); err != nil {
-		fmt.Fprintf(os.Stderr, "adb %s\n%s", strings.Join(args, " "), out)
-		return err
-	}
-	return nil
-}
-
-func adbCmd(args ...string) *exec.Cmd {
-	if flags := os.Getenv("GOANDROID_ADB_FLAGS"); flags != "" {
-		args = append(strings.Split(flags, " "), args...)
-	}
-	return exec.Command("adb", args...)
+	return buf.String()
 }
 
 const (
-	deviceRoot   = "/data/local/tmp/go_android_exec"
-	deviceGoroot = deviceRoot + "/goroot"
+	// Directory structure on the target device androidtest.bash assumes.
+	deviceGoroot = "/data/local/tmp/goroot"
+	deviceGopath = "/data/local/tmp/gopath"
 )
 
 func main() {
 	log.SetFlags(0)
 	log.SetPrefix("go_android_exec: ")
-	exitCode, err := runMain()
-	if err != nil {
-		log.Fatal(err)
-	}
-	os.Exit(exitCode)
-}
-
-func runMain() (int, error) {
-	// Concurrent use of adb is flaky, so serialize adb commands.
-	// See https://github.com/golang/go/issues/23795 or
-	// https://issuetracker.google.com/issues/73230216.
-	lockPath := filepath.Join(os.TempDir(), "go_android_exec-adb-lock")
-	lock, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0666)
-	if err != nil {
-		return 0, err
-	}
-	defer lock.Close()
-	if err := syscall.Flock(int(lock.Fd()), syscall.LOCK_EX); err != nil {
-		return 0, err
-	}
-
-	// In case we're booting a device or emulator alongside all.bash, wait for
-	// it to be ready. adb wait-for-device is not enough, we have to
-	// wait for sys.boot_completed.
-	if err := adb("wait-for-device", "exec-out", "while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;"); err != nil {
-		return 0, err
-	}
-
-	// Done once per make.bash.
-	if err := adbCopyGoroot(); err != nil {
-		return 0, err
-	}
 
 	// Prepare a temporary directory that will be cleaned up at the end.
-	// Binary names can conflict.
-	// E.g. template.test from the {html,text}/template packages.
-	binName := filepath.Base(os.Args[1])
-	deviceGotmp := fmt.Sprintf(deviceRoot+"/%s-%d", binName, os.Getpid())
-	deviceGopath := deviceGotmp + "/gopath"
-	defer adb("exec-out", "rm", "-rf", deviceGotmp) // Clean up.
+	deviceGotmp := fmt.Sprintf("/data/local/tmp/%s-%d",
+		filepath.Base(os.Args[1]), os.Getpid())
+	run("shell", "mkdir", "-p", deviceGotmp)
 
 	// Determine the package by examining the current working
 	// directory, which will look something like
 	// "$GOROOT/src/mime/multipart" or "$GOPATH/src/golang.org/x/mobile".
 	// We extract everything after the $GOROOT or $GOPATH to run on the
 	// same relative directory on the target device.
-	subdir, inGoRoot, err := subdir()
-	if err != nil {
-		return 0, err
-	}
-	deviceCwd := filepath.Join(deviceGopath, subdir)
-	if inGoRoot {
-		deviceCwd = filepath.Join(deviceGoroot, subdir)
-	} else {
-		if err := adb("exec-out", "mkdir", "-p", deviceCwd); err != nil {
-			return 0, err
-		}
-		if err := adbCopyTree(deviceCwd, subdir); err != nil {
-			return 0, err
-		}
-
-		// Copy .go files from the package.
-		goFiles, err := filepath.Glob("*.go")
-		if err != nil {
-			return 0, err
-		}
-		if len(goFiles) > 0 {
-			args := append(append([]string{"push"}, goFiles...), deviceCwd)
-			if err := adb(args...); err != nil {
-				return 0, err
-			}
-		}
+	subdir, inGoRoot := subdir()
+	deviceCwd := filepath.Join(deviceGoroot, subdir)
+	if !inGoRoot {
+		deviceCwd = filepath.Join(deviceGopath, subdir)
 	}
 
-	deviceBin := fmt.Sprintf("%s/%s", deviceGotmp, binName)
-	if err := adb("push", os.Args[1], deviceBin); err != nil {
-		return 0, err
-	}
+	// Binary names can conflict.
+	// E.g. template.test from the {html,text}/template packages.
+	binName := filepath.Base(os.Args[1])
+	deviceBin := fmt.Sprintf("%s/%s-%d", deviceGotmp, binName, os.Getpid())
 
-	// Forward SIGQUIT from the go command to show backtraces from
-	// the binary instead of from this wrapper.
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, syscall.SIGQUIT)
-	go func() {
-		for range quit {
-			// We don't have the PID of the running process; use the
-			// binary name instead.
-			adb("exec-out", "killall -QUIT "+binName)
-		}
-	}()
-	// In light of
+	// The push of the binary happens in parallel with other tests.
+	// Unfortunately, a simultaneous call to adb shell hold open
+	// file descriptors, so it is necessary to push then move to
+	// avoid a "text file busy" error on execution.
+	// https://code.google.com/p/android/issues/detail?id=65857
+	run("push", os.Args[1], deviceBin+"-tmp")
+	run("shell", "cp '"+deviceBin+"-tmp' '"+deviceBin+"'")
+	run("shell", "rm '"+deviceBin+"-tmp'")
+
+	// The adb shell command will return an exit code of 0 regardless
+	// of the command run. E.g.
+	//      $ adb shell false
+	//      $ echo $?
+	//      0
 	// https://code.google.com/p/android/issues/detail?id=3254
-	// dont trust the exitcode of adb. Instead, append the exitcode to
-	// the output and parse it from there.
+	// So we append the exitcode to the output and parse it from there.
 	const exitstr = "exitcode="
 	cmd := `export TMPDIR="` + deviceGotmp + `"` +
 		`; export GOROOT="` + deviceGoroot + `"` +
 		`; export GOPATH="` + deviceGopath + `"` +
-		`; export CGO_ENABLED=0` +
-		`; export GOPROXY=` + os.Getenv("GOPROXY") +
-		`; export GOCACHE="` + deviceRoot + `/gocache"` +
-		`; export PATH=$PATH:"` + deviceGoroot + `/bin"` +
 		`; cd "` + deviceCwd + `"` +
 		"; '" + deviceBin + "' " + strings.Join(os.Args[2:], " ") +
 		"; echo -n " + exitstr + "$?"
-	output, err := run("exec-out", cmd)
-	signal.Reset(syscall.SIGQUIT)
-	close(quit)
-	if err != nil {
-		return 0, err
-	}
+	output := run("shell", cmd)
+
+	run("shell", "rm", "-rf", deviceGotmp) // Clean up.
 
 	exitIdx := strings.LastIndex(output, exitstr)
 	if exitIdx == -1 {
-		return 0, fmt.Errorf("no exit code: %q", output)
+		log.Fatalf("no exit code: %q", output)
 	}
 	code, err := strconv.Atoi(output[exitIdx+len(exitstr):])
 	if err != nil {
-		return 0, fmt.Errorf("bad exit code: %v", err)
+		log.Fatalf("bad exit code: %v", err)
 	}
-	return code, nil
+	os.Exit(code)
 }
 
 // subdir determines the package based on the current working directory,
 // and returns the path to the package source relative to $GOROOT (or $GOPATH).
-func subdir() (pkgpath string, underGoRoot bool, err error) {
+func subdir() (pkgpath string, underGoRoot bool) {
 	cwd, err := os.Getwd()
 	if err != nil {
-		return "", false, err
+		log.Fatal(err)
 	}
-	cwd, err = filepath.EvalSymlinks(cwd)
-	if err != nil {
-		return "", false, err
-	}
-	goroot, err := filepath.EvalSymlinks(runtime.GOROOT())
-	if err != nil {
-		return "", false, err
-	}
-	if subdir, err := filepath.Rel(goroot, cwd); err == nil {
-		if !strings.Contains(subdir, "..") {
-			return subdir, true, nil
+	if root := runtime.GOROOT(); strings.HasPrefix(cwd, root) {
+		subdir, err := filepath.Rel(root, cwd)
+		if err != nil {
+			log.Fatal(err)
 		}
+		return subdir, true
 	}
 
 	for _, p := range filepath.SplitList(build.Default.GOPATH) {
-		pabs, err := filepath.EvalSymlinks(p)
-		if err != nil {
-			return "", false, err
+		if !strings.HasPrefix(cwd, p) {
+			continue
 		}
-		if subdir, err := filepath.Rel(pabs, cwd); err == nil {
-			if !strings.Contains(subdir, "..") {
-				return subdir, false, nil
-			}
+		subdir, err := filepath.Rel(p, cwd)
+		if err == nil {
+			return subdir, false
 		}
 	}
-	return "", false, fmt.Errorf("the current path %q is not in either GOROOT(%q) or GOPATH(%q)",
+	log.Fatalf("the current path %q is not in either GOROOT(%q) or GOPATH(%q)",
 		cwd, runtime.GOROOT(), build.Default.GOPATH)
-}
-
-// adbCopyTree copies testdata, go.mod, go.sum files from subdir
-// and from parent directories all the way up to the root of subdir.
-// go.mod and go.sum files are needed for the go tool modules queries,
-// and the testdata directories for tests.  It is common for tests to
-// reach out into testdata from parent packages.
-func adbCopyTree(deviceCwd, subdir string) error {
-	dir := ""
-	for {
-		for _, path := range []string{"testdata", "go.mod", "go.sum"} {
-			path := filepath.Join(dir, path)
-			if _, err := os.Stat(path); err != nil {
-				continue
-			}
-			devicePath := filepath.Join(deviceCwd, dir)
-			if err := adb("exec-out", "mkdir", "-p", devicePath); err != nil {
-				return err
-			}
-			if err := adb("push", path, devicePath); err != nil {
-				return err
-			}
-		}
-		if subdir == "." {
-			break
-		}
-		subdir = filepath.Dir(subdir)
-		dir = filepath.Join(dir, "..")
-	}
-	return nil
-}
-
-// adbCopyGoroot clears deviceRoot for previous versions of GOROOT, GOPATH
-// and temporary data. Then, it copies relevant parts of GOROOT to the device,
-// including the go tool built for android.
-// A lock file ensures this only happens once, even with concurrent exec
-// wrappers.
-func adbCopyGoroot() error {
-	// Also known by cmd/dist. The bootstrap command deletes the file.
-	statPath := filepath.Join(os.TempDir(), "go_android_exec-adb-sync-status")
-	stat, err := os.OpenFile(statPath, os.O_CREATE|os.O_RDWR, 0666)
-	if err != nil {
-		return err
-	}
-	defer stat.Close()
-	// Serialize check and copying.
-	if err := syscall.Flock(int(stat.Fd()), syscall.LOCK_EX); err != nil {
-		return err
-	}
-	s, err := ioutil.ReadAll(stat)
-	if err != nil {
-		return err
-	}
-	if string(s) == "done" {
-		return nil
-	}
-	// Delete GOROOT, GOPATH and any leftover test data.
-	if err := adb("exec-out", "rm", "-rf", deviceRoot); err != nil {
-		return err
-	}
-	deviceBin := filepath.Join(deviceGoroot, "bin")
-	if err := adb("exec-out", "mkdir", "-p", deviceBin); err != nil {
-		return err
-	}
-	goroot := runtime.GOROOT()
-	// Build go for android.
-	goCmd := filepath.Join(goroot, "bin", "go")
-	tmpGo, err := ioutil.TempFile("", "go_android_exec-cmd-go-*")
-	if err != nil {
-		return err
-	}
-	tmpGo.Close()
-	defer os.Remove(tmpGo.Name())
-
-	if out, err := exec.Command(goCmd, "build", "-o", tmpGo.Name(), "cmd/go").CombinedOutput(); err != nil {
-		return fmt.Errorf("failed to build go tool for device: %s\n%v", out, err)
-	}
-	deviceGo := filepath.Join(deviceBin, "go")
-	if err := adb("push", tmpGo.Name(), deviceGo); err != nil {
-		return err
-	}
-	for _, dir := range []string{"src", "test", "lib", "api"} {
-		if err := adb("push", filepath.Join(goroot, dir), filepath.Join(deviceGoroot)); err != nil {
-			return err
-		}
-	}
-
-	// Copy only the relevant from pkg.
-	if err := adb("exec-out", "mkdir", "-p", filepath.Join(deviceGoroot, "pkg", "tool")); err != nil {
-		return err
-	}
-	if err := adb("push", filepath.Join(goroot, "pkg", "include"), filepath.Join(deviceGoroot, "pkg")); err != nil {
-		return err
-	}
-	runtimea, err := exec.Command(goCmd, "list", "-f", "{{.Target}}", "runtime").Output()
-	pkgdir := filepath.Dir(string(runtimea))
-	if pkgdir == "" {
-		return errors.New("could not find android pkg dir")
-	}
-	if err := adb("push", pkgdir, filepath.Join(deviceGoroot, "pkg")); err != nil {
-		return err
-	}
-	tooldir := filepath.Join(goroot, "pkg", "tool", filepath.Base(pkgdir))
-	if err := adb("push", tooldir, filepath.Join(deviceGoroot, "pkg", "tool")); err != nil {
-		return err
-	}
-
-	if _, err := stat.Write([]byte("done")); err != nil {
-		return err
-	}
-	return nil
+	return "", false
 }

misc/benchcmp

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+echo 'misc/benchcmp has moved:' >&2
+echo '	go get -u golang.org/x/tools/cmd/benchcmp' >&2
+exit 2

misc/cgo/errors/errors_test.go

@@ -18,7 +18,7 @@ import (
 )
 
 func path(file string) string {
-	return filepath.Join("testdata", file)
+	return filepath.Join("src", file)
 }
 
 func check(t *testing.T, file string) {
@@ -63,7 +63,7 @@ func expect(t *testing.T, file string, errors []*regexp.Regexp) {
 	defer os.RemoveAll(dir)
 
 	dst := filepath.Join(dir, strings.TrimSuffix(file, ".go"))
-	cmd := exec.Command("go", "build", "-gcflags=-L -e", "-o="+dst, path(file)) // TODO(gri) no need for -gcflags=-L if go tool is adjusted
+	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")
@@ -107,23 +107,26 @@ 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",
-		"issue28721.go",
-		"issue33061.go",
 	} {
 		check(t, file)
 	}
 
 	if sizeofLongDouble(t) > 8 {
-		for _, file := range []string{
-			"err4.go",
-			"issue28069.go",
-		} {
-			check(t, file)
-		}
+		check(t, "err4.go")
 	}
 }
 

misc/cgo/errors/ptr_test.go

@@ -7,25 +7,21 @@
 package errorstest
 
 import (
+	"bufio"
 	"bytes"
-	"flag"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
-	"sync/atomic"
 	"testing"
 )
 
-var tmp = flag.String("tmp", "", "use `dir` for temporary files and do not clean up")
-
 // ptrTest is the tests without the boilerplate.
 type ptrTest struct {
 	name      string   // for reporting
 	c         string   // the cgo comment
-	c1        string   // cgo comment forced into non-export cgo file
 	imports   []string // a list of imports
 	support   string   // supporting functions
 	body      string   // the body of the main function
@@ -43,248 +39,253 @@ var ptrTests = []ptrTest{
 	{
 		// Passing a pointer to a struct that contains a Go pointer.
 		name: "ptr1",
-		c:    `typedef struct s1 { int *p; } s1; void f1(s1 *ps) {}`,
-		body: `C.f1(&C.s1{new(C.int)})`,
+		c:    `typedef struct s { int *p; } s; void f(s *ps) {}`,
+		body: `C.f(&C.s{new(C.int)})`,
 		fail: true,
 	},
 	{
 		// Passing a pointer to a struct that contains a Go pointer.
 		name: "ptr2",
-		c:    `typedef struct s2 { int *p; } s2; void f2(s2 *ps) {}`,
-		body: `p := &C.s2{new(C.int)}; C.f2(p)`,
+		c:    `typedef struct s { int *p; } s; void f(s *ps) {}`,
+		body: `p := &C.s{new(C.int)}; C.f(p)`,
 		fail: true,
 	},
 	{
 		// Passing a pointer to an int field of a Go struct
 		// that (irrelevantly) contains a Go pointer.
 		name: "ok1",
-		c:    `struct s3 { int i; int *p; }; void f3(int *p) {}`,
-		body: `p := &C.struct_s3{i: 0, p: new(C.int)}; C.f3(&p.i)`,
+		c:    `struct s { int i; int *p; }; void f(int *p) {}`,
+		body: `p := &C.struct_s{i: 0, p: new(C.int)}; C.f(&p.i)`,
 		fail: false,
 	},
 	{
 		// Passing a pointer to a pointer field of a Go struct.
-		name: "ptrfield",
-		c:    `struct s4 { int i; int *p; }; void f4(int **p) {}`,
-		body: `p := &C.struct_s4{i: 0, p: new(C.int)}; C.f4(&p.p)`,
+		name: "ptr-field",
+		c:    `struct s { int i; int *p; }; void f(int **p) {}`,
+		body: `p := &C.struct_s{i: 0, p: new(C.int)}; C.f(&p.p)`,
 		fail: true,
 	},
 	{
 		// Passing a pointer to a pointer field of a Go
 		// struct, where the field does not contain a Go
 		// pointer, but another field (irrelevantly) does.
-		name: "ptrfieldok",
-		c:    `struct s5 { int *p1; int *p2; }; void f5(int **p) {}`,
-		body: `p := &C.struct_s5{p1: nil, p2: new(C.int)}; C.f5(&p.p1)`,
+		name: "ptr-field-ok",
+		c:    `struct s { int *p1; int *p2; }; void f(int **p) {}`,
+		body: `p := &C.struct_s{p1: nil, p2: new(C.int)}; C.f(&p.p1)`,
 		fail: false,
 	},
 	{
 		// Passing the address of a slice with no Go pointers.
-		name:    "sliceok1",
-		c:       `void f6(void **p) {}`,
+		name:    "slice-ok-1",
+		c:       `void f(void **p) {}`,
 		imports: []string{"unsafe"},
-		body:    `s := []unsafe.Pointer{nil}; C.f6(&s[0])`,
+		body:    `s := []unsafe.Pointer{nil}; C.f(&s[0])`,
 		fail:    false,
 	},
 	{
 		// Passing the address of a slice with a Go pointer.
-		name:    "sliceptr1",
-		c:       `void f7(void **p) {}`,
+		name:    "slice-ptr-1",
+		c:       `void f(void **p) {}`,
 		imports: []string{"unsafe"},
-		body:    `i := 0; s := []unsafe.Pointer{unsafe.Pointer(&i)}; C.f7(&s[0])`,
+		body:    `i := 0; s := []unsafe.Pointer{unsafe.Pointer(&i)}; C.f(&s[0])`,
 		fail:    true,
 	},
 	{
 		// Passing the address of a slice with a Go pointer,
 		// where we are passing the address of an element that
 		// is not a Go pointer.
-		name:    "sliceptr2",
-		c:       `void f8(void **p) {}`,
+		name:    "slice-ptr-2",
+		c:       `void f(void **p) {}`,
 		imports: []string{"unsafe"},
-		body:    `i := 0; s := []unsafe.Pointer{nil, unsafe.Pointer(&i)}; C.f8(&s[0])`,
+		body:    `i := 0; s := []unsafe.Pointer{nil, unsafe.Pointer(&i)}; C.f(&s[0])`,
 		fail:    true,
 	},
 	{
 		// Passing the address of a slice that is an element
 		// in a struct only looks at the slice.
-		name:    "sliceok2",
-		c:       `void f9(void **p) {}`,
+		name:    "slice-ok-2",
+		c:       `void f(void **p) {}`,
 		imports: []string{"unsafe"},
-		support: `type S9 struct { p *int; s []unsafe.Pointer }`,
-		body:    `i := 0; p := &S9{p:&i, s:[]unsafe.Pointer{nil}}; C.f9(&p.s[0])`,
+		support: `type S struct { p *int; s []unsafe.Pointer }`,
+		body:    `i := 0; p := &S{p:&i, s:[]unsafe.Pointer{nil}}; C.f(&p.s[0])`,
 		fail:    false,
 	},
 	{
 		// Passing the address of a slice of an array that is
 		// an element in a struct, with a type conversion.
-		name:    "sliceok3",
-		c:       `void f10(void* p) {}`,
+		name:    "slice-ok-3",
+		c:       `void f(void* p) {}`,
 		imports: []string{"unsafe"},
-		support: `type S10 struct { p *int; a [4]byte }`,
-		body:    `i := 0; p := &S10{p:&i}; s := p.a[:]; C.f10(unsafe.Pointer(&s[0]))`,
+		support: `type S struct { p *int; a [4]byte }`,
+		body:    `i := 0; p := &S{p:&i}; s := p.a[:]; C.f(unsafe.Pointer(&s[0]))`,
 		fail:    false,
 	},
 	{
 		// Passing the address of a slice of an array that is
 		// an element in a struct, with a type conversion.
-		name:    "sliceok4",
-		c:       `typedef void* PV11; void f11(PV11 p) {}`,
+		name:    "slice-ok-4",
+		c:       `typedef void* PV; void f(PV p) {}`,
 		imports: []string{"unsafe"},
-		support: `type S11 struct { p *int; a [4]byte }`,
-		body:    `i := 0; p := &S11{p:&i}; C.f11(C.PV11(unsafe.Pointer(&p.a[0])))`,
+		support: `type S struct { p *int; a [4]byte }`,
+		body:    `i := 0; p := &S{p:&i}; C.f(C.PV(unsafe.Pointer(&p.a[0])))`,
 		fail:    false,
 	},
 	{
 		// Passing the address of a static variable with no
 		// pointers doesn't matter.
 		name:    "varok",
-		c:       `void f12(char** parg) {}`,
-		support: `var hello12 = [...]C.char{'h', 'e', 'l', 'l', 'o'}`,
-		body:    `parg := [1]*C.char{&hello12[0]}; C.f12(&parg[0])`,
+		c:       `void f(char** parg) {}`,
+		support: `var hello = [...]C.char{'h', 'e', 'l', 'l', 'o'}`,
+		body:    `parg := [1]*C.char{&hello[0]}; C.f(&parg[0])`,
 		fail:    false,
 	},
 	{
 		// Passing the address of a static variable with
 		// pointers does matter.
-		name:    "var1",
-		c:       `void f13(char*** parg) {}`,
-		support: `var hello13 = [...]*C.char{new(C.char)}`,
-		body:    `parg := [1]**C.char{&hello13[0]}; C.f13(&parg[0])`,
+		name:    "var",
+		c:       `void f(char*** parg) {}`,
+		support: `var hello = [...]*C.char{new(C.char)}`,
+		body:    `parg := [1]**C.char{&hello[0]}; C.f(&parg[0])`,
 		fail:    true,
 	},
 	{
 		// Storing a Go pointer into C memory should fail.
 		name: "barrier",
 		c: `#include <stdlib.h>
-		    char **f14a() { return malloc(sizeof(char*)); }
-		    void f14b(char **p) {}`,
-		body:      `p := C.f14a(); *p = new(C.char); C.f14b(p)`,
+                    char **f1() { return malloc(sizeof(char*)); }
+                    void f2(char **p) {}`,
+		body:      `p := C.f1(); *p = new(C.char); C.f2(p)`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// Storing a Go pointer into C memory by assigning a
 		// large value should fail.
-		name: "barrierstruct",
+		name: "barrier-struct",
 		c: `#include <stdlib.h>
-		    struct s15 { char *a[10]; };
-		    struct s15 *f15() { return malloc(sizeof(struct s15)); }
-		    void f15b(struct s15 *p) {}`,
-		body:      `p := C.f15(); p.a = [10]*C.char{new(C.char)}; C.f15b(p)`,
+                    struct s { char *a[10]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}`,
+		body:      `p := C.f1(); p.a = [10]*C.char{new(C.char)}; C.f2(p)`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// Storing a Go pointer into C memory using a slice
 		// copy should fail.
-		name: "barrierslice",
+		name: "barrier-slice",
 		c: `#include <stdlib.h>
-		    struct s16 { char *a[10]; };
-		    struct s16 *f16() { return malloc(sizeof(struct s16)); }
-		    void f16b(struct s16 *p) {}`,
-		body:      `p := C.f16(); copy(p.a[:], []*C.char{new(C.char)}); C.f16b(p)`,
+                    struct s { char *a[10]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}`,
+		body:      `p := C.f1(); copy(p.a[:], []*C.char{new(C.char)}); C.f2(p)`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// A very large value uses a GC program, which is a
 		// different code path.
-		name: "barriergcprogarray",
+		name: "barrier-gcprog-array",
 		c: `#include <stdlib.h>
-		    struct s17 { char *a[32769]; };
-		    struct s17 *f17() { return malloc(sizeof(struct s17)); }
-		    void f17b(struct s17 *p) {}`,
-		body:      `p := C.f17(); p.a = [32769]*C.char{new(C.char)}; C.f17b(p)`,
+                    struct s { char *a[32769]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}`,
+		body:      `p := C.f1(); p.a = [32769]*C.char{new(C.char)}; C.f2(p)`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// Similar case, with a source on the heap.
-		name: "barriergcprogarrayheap",
+		name: "barrier-gcprog-array-heap",
 		c: `#include <stdlib.h>
-		    struct s18 { char *a[32769]; };
-		    struct s18 *f18() { return malloc(sizeof(struct s18)); }
-		    void f18b(struct s18 *p) {}
-		    void f18c(void *p) {}`,
+                    struct s { char *a[32769]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}
+                    void f3(void *p) {}`,
 		imports:   []string{"unsafe"},
-		body:      `p := C.f18(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f18b(p); n[0] = nil; C.f18c(unsafe.Pointer(n))`,
+		body:      `p := C.f1(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f2(p); n[0] = nil; C.f3(unsafe.Pointer(n))`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// A GC program with a struct.
-		name: "barriergcprogstruct",
+		name: "barrier-gcprog-struct",
 		c: `#include <stdlib.h>
-		    struct s19a { char *a[32769]; };
-		    struct s19b { struct s19a f; };
-		    struct s19b *f19() { return malloc(sizeof(struct s19b)); }
-		    void f19b(struct s19b *p) {}`,
-		body:      `p := C.f19(); p.f = C.struct_s19a{[32769]*C.char{new(C.char)}}; C.f19b(p)`,
+                    struct s { char *a[32769]; };
+                    struct s2 { struct s f; };
+                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
+                    void f2(struct s2 *p) {}`,
+		body:      `p := C.f1(); p.f = C.struct_s{[32769]*C.char{new(C.char)}}; C.f2(p)`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// Similar case, with a source on the heap.
-		name: "barriergcprogstructheap",
+		name: "barrier-gcprog-struct-heap",
 		c: `#include <stdlib.h>
-		    struct s20a { char *a[32769]; };
-		    struct s20b { struct s20a f; };
-		    struct s20b *f20() { return malloc(sizeof(struct s20b)); }
-		    void f20b(struct s20b *p) {}
-		    void f20c(void *p) {}`,
+                    struct s { char *a[32769]; };
+                    struct s2 { struct s f; };
+                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
+                    void f2(struct s2 *p) {}
+                    void f3(void *p) {}`,
 		imports:   []string{"unsafe"},
-		body:      `p := C.f20(); n := &C.struct_s20a{[32769]*C.char{new(C.char)}}; p.f = *n; C.f20b(p); n.a[0] = nil; C.f20c(unsafe.Pointer(n))`,
+		body:      `p := C.f1(); n := &C.struct_s{[32769]*C.char{new(C.char)}}; p.f = *n; C.f2(p); n.a[0] = nil; C.f3(unsafe.Pointer(n))`,
 		fail:      true,
 		expensive: true,
 	},
 	{
 		// Exported functions may not return Go pointers.
 		name: "export1",
-		c:    `extern unsigned char *GoFn21();`,
-		support: `//export GoFn21
-		          func GoFn21() *byte { return new(byte) }`,
-		body: `C.GoFn21()`,
+		c:    `extern unsigned char *GoFn();`,
+		support: `//export GoFn
+                          func GoFn() *byte { return new(byte) }`,
+		body: `C.GoFn()`,
 		fail: true,
 	},
 	{
 		// Returning a C pointer is fine.
 		name: "exportok",
 		c: `#include <stdlib.h>
-		    extern unsigned char *GoFn22();`,
-		support: `//export GoFn22
-		          func GoFn22() *byte { return (*byte)(C.malloc(1)) }`,
-		body: `C.GoFn22()`,
+                    extern unsigned char *GoFn();`,
+		support: `//export GoFn
+                          func GoFn() *byte { return (*byte)(C.malloc(1)) }`,
+		body: `C.GoFn()`,
 	},
 	{
 		// Passing a Go string is fine.
-		name: "passstring",
+		name: "pass-string",
 		c: `#include <stddef.h>
-		    typedef struct { const char *p; ptrdiff_t n; } gostring23;
-		    gostring23 f23(gostring23 s) { return s; }`,
+                    typedef struct { const char *p; ptrdiff_t n; } gostring;
+                    gostring f(gostring s) { return s; }`,
 		imports: []string{"unsafe"},
-		body:    `s := "a"; r := C.f23(*(*C.gostring23)(unsafe.Pointer(&s))); if *(*string)(unsafe.Pointer(&r)) != s { panic(r) }`,
+		body:    `s := "a"; r := C.f(*(*C.gostring)(unsafe.Pointer(&s))); if *(*string)(unsafe.Pointer(&r)) != s { panic(r) }`,
 	},
 	{
 		// Passing a slice of Go strings fails.
-		name:    "passstringslice",
-		c:       `void f24(void *p) {}`,
+		name:    "pass-string-slice",
+		c:       `void f(void *p) {}`,
 		imports: []string{"strings", "unsafe"},
-		support: `type S24 struct { a [1]string }`,
-		body:    `s := S24{a:[1]string{strings.Repeat("a", 2)}}; C.f24(unsafe.Pointer(&s.a[0]))`,
+		support: `type S struct { a [1]string }`,
+		body:    `s := S{a:[1]string{strings.Repeat("a", 2)}}; C.f(unsafe.Pointer(&s.a[0]))`,
 		fail:    true,
 	},
 	{
 		// Exported functions may not return strings.
-		name:    "retstring",
-		c:       `extern void f25();`,
+		name:    "ret-string",
+		c:       `extern void f();`,
 		imports: []string{"strings"},
-		support: `//export GoStr25
-		          func GoStr25() string { return strings.Repeat("a", 2) }`,
-		body: `C.f25()`,
-		c1: `#include <stddef.h>
-		     typedef struct { const char *p; ptrdiff_t n; } gostring25;
-		     extern gostring25 GoStr25();
-		     void f25() { GoStr25(); }`,
+		support: `//export GoStr
+                          func GoStr() string { return strings.Repeat("a", 2) }`,
+		body: `C.f()`,
+		extra: []extra{
+			{
+				"call.c",
+				`#include <stddef.h>
+                                 typedef struct { const char *p; ptrdiff_t n; } gostring;
+                                 extern gostring GoStr();
+                                 void f() { GoStr(); }`,
+			},
+		},
 		fail: true,
 	},
 	{
@@ -295,37 +296,37 @@ var ptrTests = []ptrTest{
 		// that is, we are testing something that is not unsafe.
 		name: "ptrdata1",
 		c: `#include <stdlib.h>
-		    void f26(void* p) {}`,
+                    void f(void* p) {}`,
 		imports: []string{"unsafe"},
-		support: `type S26 struct { p *int; a [8*8]byte; u uintptr }`,
-		body:    `i := 0; p := &S26{u:uintptr(unsafe.Pointer(&i))}; q := (*S26)(C.malloc(C.size_t(unsafe.Sizeof(*p)))); *q = *p; C.f26(unsafe.Pointer(q))`,
+		support: `type S struct { p *int; a [8*8]byte; u uintptr }`,
+		body:    `i := 0; p := &S{u:uintptr(unsafe.Pointer(&i))}; q := (*S)(C.malloc(C.size_t(unsafe.Sizeof(*p)))); *q = *p; C.f(unsafe.Pointer(q))`,
 		fail:    false,
 	},
 	{
 		// Like ptrdata1, but with a type that uses a GC program.
 		name: "ptrdata2",
 		c: `#include <stdlib.h>
-		    void f27(void* p) {}`,
+                    void f(void* p) {}`,
 		imports: []string{"unsafe"},
-		support: `type S27 struct { p *int; a [32769*8]byte; q *int; u uintptr }`,
-		body:    `i := 0; p := S27{u:uintptr(unsafe.Pointer(&i))}; q := (*S27)(C.malloc(C.size_t(unsafe.Sizeof(p)))); *q = p; C.f27(unsafe.Pointer(q))`,
+		support: `type S struct { p *int; a [32769*8]byte; q *int; u uintptr }`,
+		body:    `i := 0; p := S{u:uintptr(unsafe.Pointer(&i))}; q := (*S)(C.malloc(C.size_t(unsafe.Sizeof(p)))); *q = p; C.f(unsafe.Pointer(q))`,
 		fail:    false,
 	},
 	{
 		// Check deferred pointers when they are used, not
 		// when the defer statement is run.
-		name: "defer1",
-		c:    `typedef struct s28 { int *p; } s28; void f28(s28 *ps) {}`,
-		body: `p := &C.s28{}; defer C.f28(p); p.p = new(C.int)`,
+		name: "defer",
+		c:    `typedef struct s { int *p; } s; void f(s *ps) {}`,
+		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; } u29; void f29(u29 *pu) {}`,
+		c:       `typedef union { char **p; unsigned long i; } u; void f(u *pu) {}`,
 		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f29((*C.u29)(unsafe.Pointer(&p)))`,
+		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
 		fail:    true,
 	},
 	{
@@ -335,255 +336,115 @@ var ptrTests = []ptrTest{
 		// integer that happens to have the same
 		// representation as a pointer.
 		name:    "union2",
-		c:       `typedef union { unsigned long i; } u39; void f39(u39 *pu) {}`,
+		c:       `typedef union { unsigned long i; } u; void f(u *pu) {}`,
 		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f39((*C.u39)(unsafe.Pointer(&p)))`,
+		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:    "preemptduringcall",
-		c:       `void f30() {}`,
+		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.f30(); runtime.GOMAXPROCS(i) }; wg.Done() }(i) }; wg.Wait()`,
+		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,
 	},
 	{
 		// Test poller deadline with cgocheck=2.  Issue #23435.
 		name:    "deadline",
-		c:       `#define US31 10`,
+		c:       `#define US 10`,
 		imports: []string{"os", "time"},
-		body:    `r, _, _ := os.Pipe(); r.SetDeadline(time.Now().Add(C.US31 * time.Microsecond))`,
-		fail:    false,
-	},
-	{
-		// Test for double evaluation of channel receive.
-		name:    "chanrecv",
-		c:       `void f32(char** p) {}`,
-		imports: []string{"time"},
-		body:    `c := make(chan []*C.char, 2); c <- make([]*C.char, 1); go func() { time.Sleep(10 * time.Second); panic("received twice from chan") }(); C.f32(&(<-c)[0]);`,
-		fail:    false,
-	},
-	{
-		// Test that converting the address of a struct field
-		// to unsafe.Pointer still just checks that field.
-		// Issue #25941.
-		name:    "structfield",
-		c:       `void f33(void* p) {}`,
-		imports: []string{"unsafe"},
-		support: `type S33 struct { p *int; a [8]byte; u uintptr }`,
-		body:    `s := &S33{p: new(int)}; C.f33(unsafe.Pointer(&s.a))`,
-		fail:    false,
-	},
-	{
-		// Test that converting multiple struct field
-		// addresses to unsafe.Pointer still just checks those
-		// fields. Issue #25941.
-		name:    "structfield2",
-		c:       `void f34(void* p, int r, void* s) {}`,
-		imports: []string{"unsafe"},
-		support: `type S34 struct { a [8]byte; p *int; b int64; }`,
-		body:    `s := &S34{p: new(int)}; C.f34(unsafe.Pointer(&s.a), 32, unsafe.Pointer(&s.b))`,
-		fail:    false,
-	},
-	{
-		// Test that second argument to cgoCheckPointer is
-		// evaluated when a deferred function is deferred, not
-		// when it is run.
-		name:    "defer2",
-		c:       `void f35(char **pc) {}`,
-		support: `type S35a struct { s []*C.char }; type S35b struct { ps *S35a }`,
-		body:    `p := &S35b{&S35a{[]*C.char{nil}}}; defer C.f35(&p.ps.s[0]); p.ps = nil`,
-		fail:    false,
-	},
-	{
-		// Test that indexing into a function call still
-		// examines only the slice being indexed.
-		name:    "buffer",
-		c:       `void f36(void *p) {}`,
-		imports: []string{"bytes", "unsafe"},
-		body:    `var b bytes.Buffer; b.WriteString("a"); C.f36(unsafe.Pointer(&b.Bytes()[0]))`,
-		fail:    false,
-	},
-	{
-		// Test that bgsweep releasing a finalizer is OK.
-		name:    "finalizer",
-		c:       `// Nothing to declare.`,
-		imports: []string{"os"},
-		support: `func open37() { os.Open(os.Args[0]) }; var G37 [][]byte`,
-		body:    `for i := 0; i < 10000; i++ { G37 = append(G37, make([]byte, 4096)); if i % 100 == 0 { G37 = nil; open37() } }`,
-		fail:    false,
-	},
-	{
-		// Test that converting generated struct to interface is OK.
-		name:    "structof",
-		c:       `// Nothing to declare.`,
-		imports: []string{"reflect"},
-		support: `type MyInt38 int; func (i MyInt38) Get() int { return int(i) }; type Getter38 interface { Get() int }`,
-		body:    `t := reflect.StructOf([]reflect.StructField{{Name: "MyInt38", Type: reflect.TypeOf(MyInt38(0)), Anonymous: true}}); v := reflect.New(t).Elem(); v.Interface().(Getter38).Get()`,
-		fail:    false,
-	},
-	{
-		// Test that a converted address of a struct field results
-		// in a check for just that field and not the whole struct.
-		name:    "structfieldcast",
-		c:       `struct S40i { int i; int* p; }; void f40(struct S40i* p) {}`,
-		support: `type S40 struct { p *int; a C.struct_S40i }`,
-		body:    `s := &S40{p: new(int)}; C.f40((*C.struct_S40i)(&s.a))`,
+		body:    `r, _, _ := os.Pipe(); r.SetDeadline(time.Now().Add(C.US * time.Microsecond))`,
 		fail:    false,
 	},
 }
 
 func TestPointerChecks(t *testing.T) {
-	dir, exe := buildPtrTests(t)
-
-	// We (TestPointerChecks) return before the parallel subtest functions do,
-	// so we can't just defer os.RemoveAll(dir). Instead we have to wait for
-	// the parallel subtests to finish. This code looks racy but is not:
-	// the add +1 run in serial before testOne blocks. The -1 run in parallel
-	// after testOne finishes.
-	var pending int32
 	for _, pt := range ptrTests {
 		pt := pt
 		t.Run(pt.name, func(t *testing.T) {
-			atomic.AddInt32(&pending, +1)
-			defer func() {
-				if atomic.AddInt32(&pending, -1) == 0 {
-					os.RemoveAll(dir)
-				}
-			}()
-			testOne(t, pt, exe)
+			testOne(t, pt)
 		})
 	}
 }
 
-func buildPtrTests(t *testing.T) (dir, exe string) {
-	var gopath string
-	if *tmp != "" {
-		gopath = *tmp
-		dir = ""
-	} else {
-		d, err := ioutil.TempDir("", filepath.Base(t.Name()))
-		if err != nil {
-			t.Fatal(err)
-		}
-		dir = d
-		gopath = d
-	}
-
-	src := filepath.Join(gopath, "src", "ptrtest")
-	if err := os.MkdirAll(src, 0777); err != nil {
-		t.Fatal(err)
-	}
-	if err := ioutil.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest"), 0666); err != nil {
-		t.Fatal(err)
-	}
-
-	// Prepare two cgo inputs: one for standard cgo and one for //export cgo.
-	// (The latter cannot have C definitions, only declarations.)
-	var cgo1, cgo2 bytes.Buffer
-	fmt.Fprintf(&cgo1, "package main\n\n/*\n")
-	fmt.Fprintf(&cgo2, "package main\n\n/*\n")
-
-	// C code
-	for _, pt := range ptrTests {
-		cgo := &cgo1
-		if strings.Contains(pt.support, "//export") {
-			cgo = &cgo2
-		}
-		fmt.Fprintf(cgo, "%s\n", pt.c)
-		fmt.Fprintf(&cgo1, "%s\n", pt.c1)
-	}
-	fmt.Fprintf(&cgo1, "*/\nimport \"C\"\n\n")
-	fmt.Fprintf(&cgo2, "*/\nimport \"C\"\n\n")
-
-	// Imports
-	did1 := make(map[string]bool)
-	did2 := make(map[string]bool)
-	did1["os"] = true // for ptrTestMain
-	fmt.Fprintf(&cgo1, "import \"os\"\n")
-
-	for _, pt := range ptrTests {
-		did := did1
-		cgo := &cgo1
-		if strings.Contains(pt.support, "//export") {
-			did = did2
-			cgo = &cgo2
-		}
-		for _, imp := range pt.imports {
-			if !did[imp] {
-				did[imp] = true
-				fmt.Fprintf(cgo, "import %q\n", imp)
-			}
-		}
-	}
-
-	// Func support and bodies.
-	for _, pt := range ptrTests {
-		cgo := &cgo1
-		if strings.Contains(pt.support, "//export") {
-			cgo = &cgo2
-		}
-		fmt.Fprintf(cgo, "%s\nfunc %s() {\n%s\n}\n", pt.support, pt.name, pt.body)
-	}
-
-	// Func list and main dispatch.
-	fmt.Fprintf(&cgo1, "var funcs = map[string]func() {\n")
-	for _, pt := range ptrTests {
-		fmt.Fprintf(&cgo1, "\t%q: %s,\n", pt.name, pt.name)
-	}
-	fmt.Fprintf(&cgo1, "}\n\n")
-	fmt.Fprintf(&cgo1, "%s\n", ptrTestMain)
-
-	if err := ioutil.WriteFile(filepath.Join(src, "cgo1.go"), cgo1.Bytes(), 0666); err != nil {
-		t.Fatal(err)
-	}
-	if err := ioutil.WriteFile(filepath.Join(src, "cgo2.go"), cgo2.Bytes(), 0666); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := exec.Command("go", "build", "-o", "ptrtest.exe")
-	cmd.Dir = src
-	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("go build: %v\n%s", err, out)
-	}
-
-	return dir, filepath.Join(src, "ptrtest.exe")
-}
-
-const ptrTestMain = `
-func main() {
-	for _, arg := range os.Args[1:] {
-		f := funcs[arg]
-		if f == nil {
-			panic("missing func "+arg)
-		}
-		f()
-	}
-}
-`
-
-var csem = make(chan bool, 16)
-
-func testOne(t *testing.T, pt ptrTest, exe string) {
+func testOne(t *testing.T, pt ptrTest) {
 	t.Parallel()
 
-	// Run the tests in parallel, but don't run too many
-	// executions in parallel, to avoid overloading the system.
-	runcmd := func(cgocheck string) ([]byte, error) {
-		csem <- true
-		defer func() { <-csem }()
-		cmd := exec.Command(exe, pt.name)
-		cmd.Env = append(os.Environ(), "GODEBUG=cgocheck="+cgocheck)
-		return cmd.CombinedOutput()
+	gopath, err := ioutil.TempDir("", filepath.Base(t.Name()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(gopath)
+
+	src := filepath.Join(gopath, "src")
+	if err := os.Mkdir(src, 0777); err != nil {
+		t.Fatal(err)
 	}
 
+	name := filepath.Join(src, fmt.Sprintf("%s.go", filepath.Base(t.Name())))
+	f, err := os.Create(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	b := bufio.NewWriter(f)
+	fmt.Fprintln(b, `package main`)
+	fmt.Fprintln(b)
+	fmt.Fprintln(b, `/*`)
+	fmt.Fprintln(b, pt.c)
+	fmt.Fprintln(b, `*/`)
+	fmt.Fprintln(b, `import "C"`)
+	fmt.Fprintln(b)
+	for _, imp := range pt.imports {
+		fmt.Fprintln(b, `import "`+imp+`"`)
+	}
+	if len(pt.imports) > 0 {
+		fmt.Fprintln(b)
+	}
+	if len(pt.support) > 0 {
+		fmt.Fprintln(b, pt.support)
+		fmt.Fprintln(b)
+	}
+	fmt.Fprintln(b, `func main() {`)
+	fmt.Fprintln(b, pt.body)
+	fmt.Fprintln(b, `}`)
+
+	if err := b.Flush(); err != nil {
+		t.Fatalf("flushing %s: %v", name, err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatalf("closing %s: %v", name, err)
+	}
+
+	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)
+		}
+	}
+
+	args := func(cmd *exec.Cmd) string {
+		return strings.Join(cmd.Args, " ")
+	}
+
+	cmd := exec.Command("go", "build")
+	cmd.Dir = src
+	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)
+	}
+
+	exe := filepath.Join(src, filepath.Base(src))
+	cmd = exec.Command(exe)
+	cmd.Dir = src
+
 	if pt.expensive {
-		buf, err := runcmd("1")
+		cmd.Env = cgocheckEnv("1")
+		buf, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Logf("%s", buf)
+			t.Logf("%#q:\n%s", args(cmd), buf)
 			if pt.fail {
 				t.Fatalf("test marked expensive, but failed when not expensive: %v", err)
 			} else {
@@ -591,43 +452,65 @@ func testOne(t *testing.T, pt ptrTest, exe string) {
 			}
 		}
 
+		cmd = exec.Command(exe)
+		cmd.Dir = src
 	}
 
-	cgocheck := ""
 	if pt.expensive {
-		cgocheck = "2"
+		cmd.Env = cgocheckEnv("2")
 	}
 
-	buf, err := runcmd(cgocheck)
+	buf, err = cmd.CombinedOutput()
 	if pt.fail {
 		if err == nil {
-			t.Logf("%s", buf)
+			t.Logf("%#q:\n%s", args(cmd), buf)
 			t.Fatalf("did not fail as expected")
 		} else if !bytes.Contains(buf, []byte("Go pointer")) {
-			t.Logf("%s", buf)
+			t.Logf("%#q:\n%s", args(cmd), buf)
 			t.Fatalf("did not print expected error (failed with %v)", err)
 		}
 	} else {
 		if err != nil {
-			t.Logf("%s", buf)
+			t.Logf("%#q:\n%s", args(cmd), buf)
 			t.Fatalf("failed unexpectedly: %v", err)
 		}
 
 		if !pt.expensive {
 			// Make sure it passes with the expensive checks.
-			buf, err := runcmd("2")
+			cmd := exec.Command(exe)
+			cmd.Dir = src
+			cmd.Env = cgocheckEnv("2")
+			buf, err := cmd.CombinedOutput()
 			if err != nil {
-				t.Logf("%s", buf)
+				t.Logf("%#q:\n%s", args(cmd), buf)
 				t.Fatalf("failed unexpectedly with expensive checks: %v", err)
 			}
 		}
 	}
 
 	if pt.fail {
-		buf, err := runcmd("0")
+		cmd = exec.Command(exe)
+		cmd.Dir = src
+		cmd.Env = cgocheckEnv("0")
+		buf, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Logf("%s", buf)
+			t.Logf("%#q:\n%s", args(cmd), buf)
 			t.Fatalf("failed unexpectedly with GODEBUG=cgocheck=0: %v", err)
 		}
 	}
 }
+
+func cgocheckEnv(val string) []string {
+	return addEnv("GODEBUG", "cgocheck="+val)
+}
+
+func addEnv(key, val string) []string {
+	env := []string{key + "=" + val}
+	look := key + "="
+	for _, e := range os.Environ() {
+		if !strings.HasPrefix(e, look) {
+			env = append(env, e)
+		}
+	}
+	return env
+}

misc/cgo/errors/src/err1.go

@@ -0,0 +1,18 @@
+// 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.
+
+package main
+
+/*
+#cgo LDFLAGS: -L/nonexist
+
+void test() {
+	xxx;		// ERROR HERE
+}
+*/
+import "C"
+
+func main() {
+	C.test()
+}

misc/cgo/errors/src/err2.go

@@ -0,0 +1,13 @@
+// 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.
+
+package main
+
+import "C"
+
+func main() {
+	s := ""
+	_ = s
+	C.malloc(s) // ERROR HERE
+}

misc/cgo/errors/src/err3.go

@@ -0,0 +1,18 @@
+// Copyright 2014 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
+
+/*
+typedef struct foo foo_t;
+typedef struct bar bar_t;
+
+foo_t *foop;
+*/
+import "C"
+
+func main() {
+	x := (*C.bar_t)(nil)
+	C.foop = x // ERROR HERE
+}

misc/cgo/errors/src/issue13129.go

@@ -0,0 +1,14 @@
+// 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 13129: used to output error about C.unsignedshort with CC=clang
+
+package main
+
+import "C"
+
+func main() {
+	var x C.ushort
+	x = int(0) // ERROR HERE: C\.ushort
+}