[dev.tls] dev.tls: remove sentinel file

Now that we're branched in the history we don't need this anymore.

Change-Id: I0655b2496e273aec87e77557bc4baa06bbc8cfcf
Reviewed-on: https://go-review.googlesource.com/33109
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>

AUTHORS

@@ -45,7 +45,6 @@ Alex Sergeyev <abc@alexsergeyev.com>
 Alexander Demakin <alexander.demakin@gmail.com>
 Alexander Döring <email@alexd.ch>
 Alexander Larsson <alexander.larsson@gmail.com>
-Alexander Menzhinsky <amenzhinsky@gmail.com>
 Alexander Morozov <lk4d4math@gmail.com>
 Alexander Neumann <alexander@bumpern.de>
 Alexander Orlov <alexander.orlov@loxal.net>
@@ -99,7 +98,6 @@ Anthony Canino <anthony.canino1@gmail.com>
 Anthony Eufemio <anthony.eufemio@gmail.com>
 Anthony Martin <ality@pbrane.org>
 Anthony Starks <ajstarks@gmail.com>
-Anthony Woods <awoods@raintank.io>
 Apisak Darakananda <pongad@gmail.com>
 Aram Hăvărneanu <aram@mgk.ro>
 Areski Belaid <areski@gmail.com>
@@ -165,7 +163,6 @@ Chris Jones <chris@cjones.org>
 Chris Kastorff <encryptio@gmail.com>
 Chris Lennert <calennert@gmail.com>
 Chris McGee <sirnewton_01@yahoo.ca> <newton688@gmail.com>
-Chris Stockton <chrisstocktonaz@gmail.com>
 Christian Couder <chriscool@tuxfamily.org>
 Christian Himpel <chressie@googlemail.com>
 Christine Hansmann <chhansmann@gmail.com>
@@ -261,7 +258,6 @@ Egon Elbre <egonelbre@gmail.com>
 Ehren Kret <ehren.kret@gmail.com>
 Eivind Uggedal <eivind@uggedal.com>
 Elias Naur <elias.naur@gmail.com>
-Elliot Morrison-Reed <elliotmr@gmail.com>
 Emil Hessman <c.emil.hessman@gmail.com> <emil@hessman.se>
 Emmanuel Odeke <emm.odeke@gmail.com> <odeke@ualberta.ca>
 Empirical Interfaces Inc.
@@ -399,7 +395,6 @@ Jens Frederich <jfrederich@gmail.com>
 Jeremy Jackins <jeremyjackins@gmail.com>
 Jeroen Bobbeldijk <jerbob92@gmail.com>
 Jess Frazelle <me@jessfraz.com>
-Jesse Szwedko <jesse.szwedko@gmail.com>
 Jihyun Yu <yjh0502@gmail.com>
 Jim McGrath <jimmc2@gmail.com>
 Jimmy Zelinskie <jimmyzelinskie@gmail.com>
@@ -434,7 +429,6 @@ Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Wills <runningwild@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
 Joonas Kuorilehto <joneskoo@derbian.fi>
-Jordan Lewis <jordanthelewis@gmail.com>
 Jose Luis Vázquez González <josvazg@gmail.com>
 Joseph Holsten <joseph@josephholsten.com>
 Josh Bleecher Snyder <josharian@gmail.com>
@@ -456,8 +450,6 @@ Kamil Kisiel <kamil@kamilkisiel.net> <kamil.kisiel@gmail.com>
 Kang Hu <hukangustc@gmail.com>
 Kato Kazuyoshi <kato.kazuyoshi@gmail.com>
 Katrina Owen <katrina.owen@gmail.com>
-Kaviraj Kanagaraj <kavirajkanagaraj@gmail.com>
-Keegan Carruthers-Smith <keegan.csmith@gmail.com>
 Kei Son <hey.calmdown@gmail.com>
 Keith Ball <inflatablewoman@gmail.com>
 Keith Rarick <kr@xph.us>
@@ -505,9 +497,7 @@ Manfred Touron <m@42.am>
 Manu S Ajith <neo@codingarena.in>
 Manuel Mendez <mmendez534@gmail.com>
 Marc Weistroff <marc@weistroff.net>
-Marcel Edmund Franke <marcel.edmund.franke@gmail.com>
 Marco Hennings <marco.hennings@freiheit.com>
-Marin Bašić <marin.basic02@gmail.com>
 Mark Bucciarelli <mkbucc@gmail.com>
 Mark Severson <miquella@gmail.com>
 Mark Theunissen <mark.theunissen@gmail.com>
@@ -545,7 +535,6 @@ Matthew Denton <mdenton@skyportsystems.com>
 Matthew Holt <Matthew.Holt+git@gmail.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
 Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
-Max Riveiro <kavu13@gmail.com>
 Maxim Khitrov <max@mxcrypt.com>
 Maxwell Krohn <themax@gmail.com>
 MediaMath, Inc
@@ -621,7 +610,6 @@ Niko Dziemba <niko@dziemba.com>
 Nikolay Turpitko <nikolay@turpitko.com>
 Noah Campbell <noahcampbell@gmail.com>
 Norberto Lopes <nlopes.ml@gmail.com>
-Odin Ugedal <odin@ugedal.com>
 Oleg Vakheta <helginet@gmail.com>
 Oleku Konko <oleku.konko@gmail.com>
 Oling Cat <olingcat@gmail.com>
@@ -642,7 +630,6 @@ Pascal S. de Kloe <pascal@quies.net>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
-Patrick Lee <pattyshack101@gmail.com>
 Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
 Patrick Smith <pat42smith@gmail.com>
@@ -723,7 +710,6 @@ Ryan Hitchman <hitchmanr@gmail.com>
 Ryan Lower <rpjlower@gmail.com>
 Ryan Seys <ryan@ryanseys.com>
 Ryan Slade <ryanslade@gmail.com>
-Ryuzo Yamamoto <ryuzo.yamamoto@gmail.com>
 S.Çağlar Onur <caglar@10ur.org>
 Salmān Aljammāz <s@0x65.net>
 Sam Hug <samuel.b.hug@gmail.com>
@@ -781,7 +767,6 @@ Szabolcs Nagy <nsz@port70.net>
 Tad Glines <tad.glines@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
 Takeshi YAMANASHI <9.nashi@gmail.com>
-Takuya Ueda <uedatakuya@gmail.com>
 Tal Shprecher <tshprecher@gmail.com>
 Tamir Duberstein <tamird@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
@@ -795,7 +780,6 @@ Thomas de Zeeuw <thomasdezeeuw@gmail.com>
 Thomas Desrosiers <thomasdesr@gmail.com>
 Thomas Kappler <tkappler@gmail.com>
 Thorben Krueger <thorben.krueger@gmail.com>
-Thordur Bjornsson <thorduri@secnorth.net>
 Tilman Dilo <tilman.dilo@gmail.com>
 Tim Cooijmans <timcooijmans@gmail.com>
 Tim Ebringer <tim.ebringer@gmail.com>
@@ -861,7 +845,6 @@ Yoshiyuki Kanno <nekotaroh@gmail.com> <yoshiyuki.kanno@stoic.co.jp>
 Yusuke Kagiwada <block.rxckin.beats@gmail.com>
 Yuusei Kuwana <kuwana@kumama.org>
 Yuval Pavel Zholkover <paulzhol@gmail.com>
-Zac Bergquist <zbergquist99@gmail.com>
 Zemanta d.o.o.
 Zev Goldstein <zev.goldstein@gmail.com>
 Ziad Hatahet <hatahet@gmail.com>

CONTRIBUTORS

@@ -73,7 +73,6 @@ Alex Vaghin <crhyme@google.com>
 Alexander Demakin <alexander.demakin@gmail.com>
 Alexander Döring <email@alexd.ch>
 Alexander Larsson <alexander.larsson@gmail.com>
-Alexander Menzhinsky <amenzhinsky@gmail.com>
 Alexander Morozov <lk4d4math@gmail.com>
 Alexander Neumann <alexander@bumpern.de>
 Alexander Orlov <alexander.orlov@loxal.net>
@@ -134,7 +133,6 @@ Anthony Canino <anthony.canino1@gmail.com>
 Anthony Eufemio <anthony.eufemio@gmail.com>
 Anthony Martin <ality@pbrane.org>
 Anthony Starks <ajstarks@gmail.com>
-Anthony Woods <awoods@raintank.io>
 Antonio Murdaca <runcom@redhat.com>
 Apisak Darakananda <pongad@gmail.com>
 Aram Hăvărneanu <aram@mgk.ro>
@@ -235,7 +233,6 @@ Chris Kastorff <encryptio@gmail.com>
 Chris Lennert <calennert@gmail.com>
 Chris Manghane <cmang@golang.org>
 Chris McGee <sirnewton_01@yahoo.ca> <newton688@gmail.com>
-Chris Stockton <chrisstocktonaz@gmail.com>
 Chris Zou <chriszou@ca.ibm.com>
 Christian Couder <chriscool@tuxfamily.org>
 Christian Himpel <chressie@googlemail.com> <chressie@gmail.com>
@@ -308,7 +305,6 @@ David Glasser <glasser@meteor.com>
 David Howden <dhowden@gmail.com>
 David Hubbard <dsp@google.com>
 David Jakob Fritz <david.jakob.fritz@gmail.com>
-David Lazar <lazard@golang.org>
 David Leon Gil <coruus@gmail.com>
 David McLeish <davemc@google.com>
 David Presotto <presotto@gmail.com>
@@ -364,7 +360,6 @@ Egon Elbre <egonelbre@gmail.com>
 Ehren Kret <ehren.kret@gmail.com>
 Eivind Uggedal <eivind@uggedal.com>
 Elias Naur <elias.naur@gmail.com>
-Elliot Morrison-Reed <elliotmr@gmail.com>
 Emil Hessman <c.emil.hessman@gmail.com> <emil@hessman.se>
 Emmanuel Odeke <emm.odeke@gmail.com> <odeke@ualberta.ca>
 Eoghan Sherry <ejsherry@gmail.com>
@@ -475,7 +470,6 @@ Ian Gudger <ian@loosescre.ws>
 Ian Lance Taylor <iant@golang.org>
 Icarus Sparry <golang@icarus.freeuk.com>
 Idora Shinatose <idora.shinatose@gmail.com>
-Igor Bernstein <igorbernstein@google.com>
 Igor Dolzhikov <bluesriverz@gmail.com>
 Ilya Tocar <ilya.tocar@intel.com>
 INADA Naoki <songofacandy@gmail.com>
@@ -543,7 +537,6 @@ Jeremy Jackins <jeremyjackins@gmail.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
 Jeroen Bobbeldijk <jerbob92@gmail.com>
 Jess Frazelle <me@jessfraz.com>
-Jesse Szwedko <jesse.szwedko@gmail.com>
 Jihyun Yu <yjh0502@gmail.com>
 Jim Cote <jfcote87@gmail.com>
 Jim Kingdon <jim@bolt.me>
@@ -593,7 +586,6 @@ Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Wills <runningwild@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
 Joonas Kuorilehto <joneskoo@derbian.fi>
-Jordan Lewis <jordanthelewis@gmail.com>
 Jos Visser <josv@google.com>
 Jose Luis Vázquez González <josvazg@gmail.com>
 Joseph Bonneau <jcb@google.com>
@@ -625,10 +617,8 @@ Kang Hu <hukangustc@gmail.com>
 Karan Dhiman <karandhi@ca.ibm.com>
 Kato Kazuyoshi <kato.kazuyoshi@gmail.com>
 Katrina Owen <katrina.owen@gmail.com>
-Kaviraj Kanagaraj <kavirajkanagaraj@gmail.com>
 Kay Zhu <kayzhu@google.com>
 KB Sriram <kbsriram@google.com>
-Keegan Carruthers-Smith <keegan.csmith@gmail.com>
 Kei Son <hey.calmdown@gmail.com>
 Keith Ball <inflatablewoman@gmail.com>
 Keith Randall <khr@golang.org>
@@ -688,11 +678,9 @@ Manu S Ajith <neo@codingarena.in>
 Manuel Mendez <mmendez534@gmail.com>
 Marc Weistroff <marc@weistroff.net>
 Marc-Antoine Ruel <maruel@chromium.org>
-Marcel Edmund Franke <marcel.edmund.franke@gmail.com>
 Marcel van Lohuizen <mpvl@golang.org>
 Marco Hennings <marco.hennings@freiheit.com>
 Marga Manterola <marga@google.com>
-Marin Bašić <marin.basic02@gmail.com>
 Marius Nuennerich <mnu@google.com>
 Mark Bucciarelli <mkbucc@gmail.com>
 Mark Severson <miquella@gmail.com>
@@ -707,7 +695,6 @@ Markus Zimmermann <zimmski@gmail.com>
 Martin Bertschler <mbertschler@gmail.com>
 Martin Garton <garton@gmail.com>
 Martin Hamrle <martin.hamrle@gmail.com>
-Martin Kreichgauer <martinkr@google.com>
 Martin Möhrmann <moehrmann@google.com> <martisch@uos.de>
 Martin Neubauer <m.ne@gmx.net>
 Martin Olsson <martin@minimum.se>
@@ -736,7 +723,6 @@ Matthew Denton <mdenton@skyportsystems.com>
 Matthew Holt <Matthew.Holt+git@gmail.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
 Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
-Max Riveiro <kavu13@gmail.com>
 Maxim Khitrov <max@mxcrypt.com>
 Maxim Pimenov <mpimenov@google.com>
 Maxim Ushakov <ushakov@google.com>
@@ -833,7 +819,6 @@ Nikolay Turpitko <nikolay@turpitko.com>
 Noah Campbell <noahcampbell@gmail.com>
 Nodir Turakulov <nodir@google.com>
 Norberto Lopes <nlopes.ml@gmail.com>
-Odin Ugedal <odin@ugedal.com>
 Oleg Vakheta <helginet@gmail.com>
 Oleku Konko <oleku.konko@gmail.com>
 Oling Cat <olingcat@gmail.com>
@@ -852,7 +837,6 @@ Pascal S. de Kloe <pascal@quies.net>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
-Patrick Lee <pattyshack101@gmail.com>
 Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
 Patrick Riley <pfr@google.com>
@@ -919,7 +903,6 @@ Ralph Corderoy <ralph@inputplus.co.uk>
 Ramesh Dharan <dharan@google.com>
 Raph Levien <raph@google.com>
 Raul Silvera <rsilvera@google.com>
-Rebecca Stambler <rstambler@golang.org>
 Reinaldo de Souza Jr <juniorz@gmail.com>
 Rémy Oudompheng <oudomphe@phare.normalesup.org> <remyoudompheng@gmail.com>
 Rhys Hiltner <rhys@justin.tv>
@@ -966,7 +949,6 @@ Ryan Hitchman <hitchmanr@gmail.com>
 Ryan Lower <rpjlower@gmail.com>
 Ryan Seys <ryan@ryanseys.com>
 Ryan Slade <ryanslade@gmail.com>
-Ryuzo Yamamoto <ryuzo.yamamoto@gmail.com>
 S.Çağlar Onur <caglar@10ur.org>
 Sai Cheemalapati <saicheems@google.com>
 Salmān Aljammāz <s@0x65.net>
@@ -1047,7 +1029,6 @@ Tad Glines <tad.glines@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
 Takashi Matsuo <tmatsuo@google.com>
 Takeshi YAMANASHI <9.nashi@gmail.com>
-Takuya Ueda <uedatakuya@gmail.com>
 Tal Shprecher <tshprecher@gmail.com>
 Tamir Duberstein <tamird@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
@@ -1063,7 +1044,6 @@ Thomas Desrosiers <thomasdesr@gmail.com>
 Thomas Habets <habets@google.com>
 Thomas Kappler <tkappler@gmail.com>
 Thorben Krueger <thorben.krueger@gmail.com>
-Thordur Bjornsson <thorduri@secnorth.net>
 Tilman Dilo <tilman.dilo@gmail.com>
 Tim Cooijmans <timcooijmans@gmail.com>
 Tim Ebringer <tim.ebringer@gmail.com>
@@ -1152,7 +1132,6 @@ Yusuke Kagiwada <block.rxckin.beats@gmail.com>
 Yuusei Kuwana <kuwana@kumama.org>
 Yuval Pavel Zholkover <paulzhol@gmail.com>
 Yves Junqueira <yvesj@google.com> <yves.junqueira@gmail.com>
-Zac Bergquist <zbergquist99@gmail.com>
 Zev Goldstein <zev.goldstein@gmail.com>
 Zhongwei Yao <zhongwei.yao@arm.com>
 Ziad Hatahet <hatahet@gmail.com>

api/except.txt

@@ -338,7 +338,3 @@ pkg unicode, const Version = "6.2.0"
 pkg unicode, const Version = "6.3.0"
 pkg unicode, const Version = "7.0.0"
 pkg unicode, const Version = "8.0.0"
-pkg syscall (openbsd-386), const SYS_KILL = 37
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 37
-pkg syscall (openbsd-amd64), const SYS_KILL = 37
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 37

api/go1.8.txt

@@ -1,262 +0,0 @@
-pkg compress/gzip, const HuffmanOnly = -2
-pkg compress/gzip, const HuffmanOnly ideal-int
-pkg compress/zlib, const HuffmanOnly = -2
-pkg compress/zlib, const HuffmanOnly ideal-int
-pkg crypto/tls, const ECDSAWithP256AndSHA256 = 1027
-pkg crypto/tls, const ECDSAWithP256AndSHA256 SignatureScheme
-pkg crypto/tls, const ECDSAWithP384AndSHA384 = 1283
-pkg crypto/tls, const ECDSAWithP384AndSHA384 SignatureScheme
-pkg crypto/tls, const ECDSAWithP521AndSHA512 = 1539
-pkg crypto/tls, const ECDSAWithP521AndSHA512 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA1 = 513
-pkg crypto/tls, const PKCS1WithSHA1 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA256 = 1025
-pkg crypto/tls, const PKCS1WithSHA256 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA384 = 1281
-pkg crypto/tls, const PKCS1WithSHA384 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA512 = 1537
-pkg crypto/tls, const PKCS1WithSHA512 SignatureScheme
-pkg crypto/tls, const PSSWithSHA256 = 2052
-pkg crypto/tls, const PSSWithSHA256 SignatureScheme
-pkg crypto/tls, const PSSWithSHA384 = 2053
-pkg crypto/tls, const PSSWithSHA384 SignatureScheme
-pkg crypto/tls, const PSSWithSHA512 = 2054
-pkg crypto/tls, const PSSWithSHA512 SignatureScheme
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 49187
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 = 52393
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 49191
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 = 52392
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 uint16
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 = 60
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const X25519 = 29
-pkg crypto/tls, const X25519 CurveID
-pkg crypto/tls, method (*Config) Clone() *Config
-pkg crypto/tls, method (*Conn) CloseWrite() error
-pkg crypto/tls, type CertificateRequestInfo struct
-pkg crypto/tls, type CertificateRequestInfo struct, AcceptableCAs [][]uint8
-pkg crypto/tls, type CertificateRequestInfo struct, SignatureSchemes []SignatureScheme
-pkg crypto/tls, type ClientHelloInfo struct, Conn net.Conn
-pkg crypto/tls, type ClientHelloInfo struct, SignatureSchemes []SignatureScheme
-pkg crypto/tls, type ClientHelloInfo struct, SupportedProtos []string
-pkg crypto/tls, type ClientHelloInfo struct, SupportedVersions []uint16
-pkg crypto/tls, type Config struct, GetClientCertificate func(*CertificateRequestInfo) (*Certificate, error)
-pkg crypto/tls, type Config struct, GetConfigForClient func(*ClientHelloInfo) (*Config, error)
-pkg crypto/tls, type Config struct, KeyLogWriter io.Writer
-pkg crypto/tls, type Config struct, VerifyPeerCertificate func([][]uint8, [][]*x509.Certificate) error
-pkg crypto/tls, type SignatureScheme uint16
-pkg crypto/x509, const NameMismatch = 5
-pkg crypto/x509, const NameMismatch InvalidReason
-pkg crypto/x509, const SHA256WithRSAPSS = 13
-pkg crypto/x509, const SHA256WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, const SHA384WithRSAPSS = 14
-pkg crypto/x509, const SHA384WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, const SHA512WithRSAPSS = 15
-pkg crypto/x509, const SHA512WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, type UnknownAuthorityError struct, Cert *Certificate
-pkg database/sql, const LevelDefault = 0
-pkg database/sql, const LevelDefault IsolationLevel
-pkg database/sql, const LevelLinearizable = 7
-pkg database/sql, const LevelLinearizable IsolationLevel
-pkg database/sql, const LevelReadCommitted = 2
-pkg database/sql, const LevelReadCommitted IsolationLevel
-pkg database/sql, const LevelReadUncommitted = 1
-pkg database/sql, const LevelReadUncommitted IsolationLevel
-pkg database/sql, const LevelRepeatableRead = 4
-pkg database/sql, const LevelRepeatableRead IsolationLevel
-pkg database/sql, const LevelSerializable = 6
-pkg database/sql, const LevelSerializable IsolationLevel
-pkg database/sql, const LevelSnapshot = 5
-pkg database/sql, const LevelSnapshot IsolationLevel
-pkg database/sql, const LevelWriteCommitted = 3
-pkg database/sql, const LevelWriteCommitted IsolationLevel
-pkg database/sql/driver, type ConnBeginTx interface { BeginTx }
-pkg database/sql/driver, type ConnBeginTx interface, BeginTx(context.Context, TxOptions) (Tx, error)
-pkg database/sql/driver, type ConnPrepareContext interface { PrepareContext }
-pkg database/sql/driver, type ConnPrepareContext interface, PrepareContext(context.Context, string) (Stmt, error)
-pkg database/sql/driver, type ExecerContext interface { ExecContext }
-pkg database/sql/driver, type ExecerContext interface, ExecContext(context.Context, string, []NamedValue) (Result, error)
-pkg database/sql/driver, type IsolationLevel int
-pkg database/sql/driver, type NamedValue struct
-pkg database/sql/driver, type NamedValue struct, Name string
-pkg database/sql/driver, type NamedValue struct, Ordinal int
-pkg database/sql/driver, type NamedValue struct, Value Value
-pkg database/sql/driver, type Pinger interface { Ping }
-pkg database/sql/driver, type Pinger interface, Ping(context.Context) error
-pkg database/sql/driver, type QueryerContext interface { QueryContext }
-pkg database/sql/driver, type QueryerContext interface, QueryContext(context.Context, string, []NamedValue) (Rows, error)
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface { Close, ColumnTypeDatabaseTypeName, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, ColumnTypeDatabaseTypeName(int) string
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeLength interface { Close, ColumnTypeLength, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeLength interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeLength interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeLength interface, ColumnTypeLength(int) (int64, bool)
-pkg database/sql/driver, type RowsColumnTypeLength interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeNullable interface { Close, ColumnTypeNullable, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeNullable interface, ColumnTypeNullable(int) (bool, bool)
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface { Close, ColumnTypePrecisionScale, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Close() error
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, ColumnTypePrecisionScale(int) (int64, int64, bool)
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeScanType interface { Close, ColumnTypeScanType, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeScanType interface, ColumnTypeScanType(int) reflect.Type
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Next([]Value) error
-pkg database/sql/driver, type RowsNextResultSet interface { Close, Columns, HasNextResultSet, Next, NextResultSet }
-pkg database/sql/driver, type RowsNextResultSet interface, Close() error
-pkg database/sql/driver, type RowsNextResultSet interface, Columns() []string
-pkg database/sql/driver, type RowsNextResultSet interface, HasNextResultSet() bool
-pkg database/sql/driver, type RowsNextResultSet interface, NextResultSet() error
-pkg database/sql/driver, type RowsNextResultSet interface, Next([]Value) error
-pkg database/sql/driver, type StmtExecContext interface { ExecContext }
-pkg database/sql/driver, type StmtExecContext interface, ExecContext(context.Context, []NamedValue) (Result, error)
-pkg database/sql/driver, type StmtQueryContext interface { QueryContext }
-pkg database/sql/driver, type StmtQueryContext interface, QueryContext(context.Context, []NamedValue) (Rows, error)
-pkg database/sql/driver, type TxOptions struct
-pkg database/sql/driver, type TxOptions struct, Isolation IsolationLevel
-pkg database/sql/driver, type TxOptions struct, ReadOnly bool
-pkg database/sql, func Named(string, interface{}) NamedArg
-pkg database/sql, method (*ColumnType) DatabaseTypeName() string
-pkg database/sql, method (*ColumnType) DecimalSize() (int64, int64, bool)
-pkg database/sql, method (*ColumnType) Length() (int64, bool)
-pkg database/sql, method (*ColumnType) Name() string
-pkg database/sql, method (*ColumnType) Nullable() (bool, bool)
-pkg database/sql, method (*ColumnType) ScanType() reflect.Type
-pkg database/sql, method (*DB) BeginTx(context.Context, *TxOptions) (*Tx, error)
-pkg database/sql, method (*DB) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*DB) PingContext(context.Context) error
-pkg database/sql, method (*DB) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*DB) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*DB) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*Rows) ColumnTypes() ([]*ColumnType, error)
-pkg database/sql, method (*Rows) NextResultSet() bool
-pkg database/sql, method (*Stmt) ExecContext(context.Context, ...interface{}) (Result, error)
-pkg database/sql, method (*Stmt) QueryContext(context.Context, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Stmt) QueryRowContext(context.Context, ...interface{}) *Row
-pkg database/sql, method (*Tx) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*Tx) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*Tx) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Tx) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*Tx) StmtContext(context.Context, *Stmt) *Stmt
-pkg database/sql, type ColumnType struct
-pkg database/sql, type IsolationLevel int
-pkg database/sql, type NamedArg struct
-pkg database/sql, type NamedArg struct, Name string
-pkg database/sql, type NamedArg struct, Value interface{}
-pkg database/sql, type TxOptions struct
-pkg database/sql, type TxOptions struct, Isolation IsolationLevel
-pkg database/sql, type TxOptions struct, ReadOnly bool
-pkg debug/pe, method (*COFFSymbol) FullName(StringTable) (string, error)
-pkg debug/pe, method (StringTable) String(uint32) (string, error)
-pkg debug/pe, type File struct, COFFSymbols []COFFSymbol
-pkg debug/pe, type File struct, StringTable StringTable
-pkg debug/pe, type Reloc struct
-pkg debug/pe, type Reloc struct, SymbolTableIndex uint32
-pkg debug/pe, type Reloc struct, Type uint16
-pkg debug/pe, type Reloc struct, VirtualAddress uint32
-pkg debug/pe, type Section struct, Relocs []Reloc
-pkg debug/pe, type StringTable []uint8
-pkg encoding/base64, method (Encoding) Strict() *Encoding
-pkg encoding/json, method (RawMessage) MarshalJSON() ([]uint8, error)
-pkg encoding/json, type UnmarshalTypeError struct, Field string
-pkg encoding/json, type UnmarshalTypeError struct, Struct string
-pkg expvar, func Handler() http.Handler
-pkg expvar, method (*Float) Value() float64
-pkg expvar, method (Func) Value() interface{}
-pkg expvar, method (*Int) Value() int64
-pkg expvar, method (*String) Value() string
-pkg go/build, type NoGoError struct, Ignored bool
-pkg go/doc, func IsPredeclared(string) bool
-pkg go/types, func Default(Type) Type
-pkg go/types, func IdenticalIgnoreTags(Type, Type) bool
-pkg math/big, method (*Float) Scan(fmt.ScanState, int32) error
-pkg math/big, method (*Int) Sqrt(*Int) *Int
-pkg math/rand, func Uint64() uint64
-pkg math/rand, method (*Rand) Uint64() uint64
-pkg math/rand, type Source64 interface, Int63() int64
-pkg math/rand, type Source64 interface { Int63, Seed, Uint64 }
-pkg math/rand, type Source64 interface, Seed(int64)
-pkg math/rand, type Source64 interface, Uint64() uint64
-pkg net/http, const TrailerPrefix ideal-string
-pkg net/http, const TrailerPrefix = "Trailer:"
-pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeDone func(tls.ConnectionState, error)
-pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeStart func()
-pkg net/http/httputil, type ReverseProxy struct, ModifyResponse func(*http.Response) error
-pkg net/http, method (*Server) Close() error
-pkg net/http, method (*Server) Shutdown(context.Context) error
-pkg net/http, type Pusher interface { Push }
-pkg net/http, type Pusher interface, Push(string, *PushOptions) error
-pkg net/http, type PushOptions struct
-pkg net/http, type PushOptions struct, Header Header
-pkg net/http, type PushOptions struct, Method string
-pkg net/http, type Request struct, GetBody func() (io.ReadCloser, error)
-pkg net/http, type Server struct, IdleTimeout time.Duration
-pkg net/http, type Server struct, ReadHeaderTimeout time.Duration
-pkg net/http, type Transport struct, ProxyConnectHeader Header
-pkg net/http, var ErrAbortHandler error
-pkg net/http, var ErrServerClosed error
-pkg net/http, var NoBody noBody
-pkg net/mail, func ParseDate(string) (time.Time, error)
-pkg net, method (*Buffers) Read([]uint8) (int, error)
-pkg net, method (*Buffers) WriteTo(io.Writer) (int64, error)
-pkg net, method (*Resolver) LookupAddr(context.Context, string) ([]string, error)
-pkg net, method (*Resolver) LookupCNAME(context.Context, string) (string, error)
-pkg net, method (*Resolver) LookupHost(context.Context, string) ([]string, error)
-pkg net, method (*Resolver) LookupIPAddr(context.Context, string) ([]IPAddr, error)
-pkg net, method (*Resolver) LookupMX(context.Context, string) ([]*MX, error)
-pkg net, method (*Resolver) LookupNS(context.Context, string) ([]*NS, error)
-pkg net, method (*Resolver) LookupPort(context.Context, string, string) (int, error)
-pkg net, method (*Resolver) LookupSRV(context.Context, string, string, string) (string, []*SRV, error)
-pkg net, method (*Resolver) LookupTXT(context.Context, string) ([]string, error)
-pkg net, method (*UnixListener) SetUnlinkOnClose(bool)
-pkg net, type Buffers [][]uint8
-pkg net, type Dialer struct, Resolver *Resolver
-pkg net, type Resolver struct
-pkg net, type Resolver struct, PreferGo bool
-pkg net/url, func PathEscape(string) string
-pkg net/url, func PathUnescape(string) (string, error)
-pkg net/url, method (*URL) Hostname() string
-pkg net/url, method (*URL) MarshalBinary() ([]uint8, error)
-pkg net/url, method (*URL) Port() string
-pkg net/url, method (*URL) UnmarshalBinary([]uint8) error
-pkg net, var DefaultResolver *Resolver
-pkg os, func Executable() (string, error)
-pkg os, var ErrClosed error
-pkg plugin, func Open(string) (*Plugin, error)
-pkg plugin, method (*Plugin) Lookup(string) (Symbol, error)
-pkg plugin, type Plugin struct
-pkg plugin, type Symbol interface {}
-pkg reflect, func Swapper(interface{}) func(int, int)
-pkg runtime, func MutexProfile([]BlockProfileRecord) (int, bool)
-pkg runtime, func SetMutexProfileFraction(int) int
-pkg runtime, type MemStats struct, NumForcedGC uint32
-pkg sort, func Slice(interface{}, func(int, int) bool)
-pkg sort, func SliceIsSorted(interface{}, func(int, int) bool) bool
-pkg sort, func SliceStable(interface{}, func(int, int) bool)
-pkg syscall (linux-arm-cgo), func TimevalToNsec(Timeval) int64
-pkg syscall (linux-arm), func TimevalToNsec(Timeval) int64
-pkg syscall (openbsd-386), const SYS_KILL = 122
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 122
-pkg syscall (openbsd-amd64), const SYS_KILL = 122
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 122
-pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY = 145
-pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY Errno
-pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY = 145
-pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY Errno
-pkg testing, func CoverMode() string
-pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg testing, method (*B) Name() string
-pkg testing, method (*T) Name() string
-pkg testing, type TB interface, Name() string
-pkg time, func Until(Time) Duration

api/next.txt

@@ -0,0 +1,193 @@
+pkg compress/gzip, const HuffmanOnly = -2
+pkg compress/gzip, const HuffmanOnly ideal-int
+pkg compress/zlib, const HuffmanOnly = -2
+pkg compress/zlib, const HuffmanOnly ideal-int
+pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 49187
+pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16
+pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 = 52393
+pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 uint16
+pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 49191
+pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16
+pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 = 52392
+pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 uint16
+pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 = 60
+pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 uint16
+pkg crypto/tls, const X25519 = 29
+pkg crypto/tls, const X25519 CurveID
+pkg crypto/tls, method (*Config) Clone() *Config
+pkg crypto/tls, type ClientHelloInfo struct, Conn net.Conn
+pkg crypto/tls, type ClientHelloInfo struct, SignatureSchemes []uint16
+pkg crypto/tls, type ClientHelloInfo struct, SupportedProtos []string
+pkg crypto/tls, type ClientHelloInfo struct, SupportedVersions []uint16
+pkg crypto/tls, type Config struct, GetConfigForClient func(*ClientHelloInfo) (*Config, error)
+pkg crypto/tls, type Config struct, KeyLogWriter io.Writer
+pkg crypto/tls, type Config struct, VerifyPeerCertificate func([][]uint8, [][]*x509.Certificate) error
+pkg crypto/x509, const NameMismatch = 5
+pkg crypto/x509, const NameMismatch InvalidReason
+pkg crypto/x509, const SHA256WithRSAPSS = 13
+pkg crypto/x509, const SHA256WithRSAPSS SignatureAlgorithm
+pkg crypto/x509, const SHA384WithRSAPSS = 14
+pkg crypto/x509, const SHA384WithRSAPSS SignatureAlgorithm
+pkg crypto/x509, const SHA512WithRSAPSS = 15
+pkg crypto/x509, const SHA512WithRSAPSS SignatureAlgorithm
+pkg database/sql, func Param(string, interface{}) NamedParam
+pkg database/sql, method (*ColumnType) DatabaseTypeName() string
+pkg database/sql, method (*ColumnType) DecimalSize() (int64, int64, bool)
+pkg database/sql, method (*ColumnType) Length() (int64, bool)
+pkg database/sql, method (*ColumnType) Name() string
+pkg database/sql, method (*ColumnType) Nullable() (bool, bool)
+pkg database/sql, method (*ColumnType) ScanType() reflect.Type
+pkg database/sql, method (*DB) BeginContext(context.Context) (*Tx, error)
+pkg database/sql, method (*DB) ExecContext(context.Context, string, ...interface{}) (Result, error)
+pkg database/sql, method (*DB) PingContext(context.Context) error
+pkg database/sql, method (*DB) PrepareContext(context.Context, string) (*Stmt, error)
+pkg database/sql, method (*DB) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
+pkg database/sql, method (*DB) QueryRowContext(context.Context, string, ...interface{}) *Row
+pkg database/sql, method (*Rows) ColumnTypes() ([]*ColumnType, error)
+pkg database/sql, method (*Rows) NextResultSet() bool
+pkg database/sql, method (*Stmt) ExecContext(context.Context, ...interface{}) (Result, error)
+pkg database/sql, method (*Stmt) QueryContext(context.Context, ...interface{}) (*Rows, error)
+pkg database/sql, method (*Stmt) QueryRowContext(context.Context, ...interface{}) *Row
+pkg database/sql, method (*Tx) ExecContext(context.Context, string, ...interface{}) (Result, error)
+pkg database/sql, method (*Tx) PrepareContext(context.Context, string) (*Stmt, error)
+pkg database/sql, method (*Tx) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
+pkg database/sql, method (*Tx) QueryRowContext(context.Context, string, ...interface{}) *Row
+pkg database/sql, method (*Tx) StmtContext(context.Context, *Stmt) *Stmt
+pkg database/sql, type ColumnType struct
+pkg database/sql, type NamedParam struct
+pkg database/sql, type NamedParam struct, Name string
+pkg database/sql, type NamedParam struct, Value interface{}
+pkg database/sql/driver, type ConnBeginContext interface { BeginContext }
+pkg database/sql/driver, type ConnBeginContext interface, BeginContext(context.Context) (Tx, error)
+pkg database/sql/driver, type ConnPrepareContext interface { PrepareContext }
+pkg database/sql/driver, type ConnPrepareContext interface, PrepareContext(context.Context, string) (Stmt, error)
+pkg database/sql/driver, type ExecerContext interface { ExecContext }
+pkg database/sql/driver, type ExecerContext interface, ExecContext(context.Context, string, []NamedValue) (Result, error)
+pkg database/sql/driver, type NamedValue struct
+pkg database/sql/driver, type NamedValue struct, Name string
+pkg database/sql/driver, type NamedValue struct, Ordinal int
+pkg database/sql/driver, type NamedValue struct, Value Value
+pkg database/sql/driver, type QueryerContext interface { QueryContext }
+pkg database/sql/driver, type QueryerContext interface, QueryContext(context.Context, string, []NamedValue) (Rows, error)
+pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface { Close, ColumnTypeDatabaseTypeName, Columns, Next }
+pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Close() error
+pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, ColumnTypeDatabaseTypeName(int) string
+pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Columns() []string
+pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Next([]Value) error
+pkg database/sql/driver, type RowsColumnTypeLength interface { Close, ColumnTypeLength, Columns, Next }
+pkg database/sql/driver, type RowsColumnTypeLength interface, Close() error
+pkg database/sql/driver, type RowsColumnTypeLength interface, ColumnTypeLength(int) (int64, bool)
+pkg database/sql/driver, type RowsColumnTypeLength interface, Columns() []string
+pkg database/sql/driver, type RowsColumnTypeLength interface, Next([]Value) error
+pkg database/sql/driver, type RowsColumnTypeNullable interface { Close, ColumnTypeNullable, Columns, Next }
+pkg database/sql/driver, type RowsColumnTypeNullable interface, Close() error
+pkg database/sql/driver, type RowsColumnTypeNullable interface, ColumnTypeNullable(int) (bool, bool)
+pkg database/sql/driver, type RowsColumnTypeNullable interface, Columns() []string
+pkg database/sql/driver, type RowsColumnTypeNullable interface, Next([]Value) error
+pkg database/sql/driver, type RowsColumnTypePrecisionScale interface { Close, ColumnTypePrecisionScale, Columns, Next }
+pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Close() error
+pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, ColumnTypePrecisionScale(int) (int64, int64, bool)
+pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Columns() []string
+pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Next([]Value) error
+pkg database/sql/driver, type RowsColumnTypeScanType interface { Close, ColumnTypeScanType, Columns, Next }
+pkg database/sql/driver, type RowsColumnTypeScanType interface, Close() error
+pkg database/sql/driver, type RowsColumnTypeScanType interface, ColumnTypeScanType(int) reflect.Type
+pkg database/sql/driver, type RowsColumnTypeScanType interface, Columns() []string
+pkg database/sql/driver, type RowsColumnTypeScanType interface, Next([]Value) error
+pkg database/sql/driver, type RowsNextResultSet interface { Close, Columns, HasNextResultSet, Next, NextResultSet }
+pkg database/sql/driver, type RowsNextResultSet interface, Close() error
+pkg database/sql/driver, type RowsNextResultSet interface, Columns() []string
+pkg database/sql/driver, type RowsNextResultSet interface, HasNextResultSet() bool
+pkg database/sql/driver, type RowsNextResultSet interface, Next([]Value) error
+pkg database/sql/driver, type RowsNextResultSet interface, NextResultSet() error
+pkg database/sql/driver, type StmtExecContext interface { ExecContext }
+pkg database/sql/driver, type StmtExecContext interface, ExecContext(context.Context, []NamedValue) (Result, error)
+pkg database/sql/driver, type StmtQueryContext interface { QueryContext }
+pkg database/sql/driver, type StmtQueryContext interface, QueryContext(context.Context, []NamedValue) (Rows, error)
+pkg debug/gosym, func PCValue([]uint8, uint64, int) int
+pkg debug/pe, method (*COFFSymbol) FullName(StringTable) (string, error)
+pkg debug/pe, method (StringTable) String(uint32) (string, error)
+pkg debug/pe, type File struct, COFFSymbols []COFFSymbol
+pkg debug/pe, type File struct, StringTable StringTable
+pkg debug/pe, type Reloc struct
+pkg debug/pe, type Reloc struct, SymbolTableIndex uint32
+pkg debug/pe, type Reloc struct, Type uint16
+pkg debug/pe, type Reloc struct, VirtualAddress uint32
+pkg debug/pe, type Section struct, Relocs []Reloc
+pkg debug/pe, type StringTable []uint8
+pkg encoding/base64, method (Encoding) Strict() *Encoding
+pkg encoding/json, type UnmarshalTypeError struct, Field string
+pkg encoding/json, type UnmarshalTypeError struct, Struct string
+pkg expvar, func Handler() http.Handler
+pkg expvar, method (*Float) Value() float64
+pkg expvar, method (*Int) Value() int64
+pkg expvar, method (*String) Value() string
+pkg expvar, method (Func) Value() interface{}
+pkg go/ast, method (*AliasSpec) End() token.Pos
+pkg go/ast, method (*AliasSpec) Pos() token.Pos
+pkg go/ast, type AliasSpec struct
+pkg go/ast, type AliasSpec struct, Comment *CommentGroup
+pkg go/ast, type AliasSpec struct, Doc *CommentGroup
+pkg go/ast, type AliasSpec struct, Name *Ident
+pkg go/ast, type AliasSpec struct, Orig Expr
+pkg go/build, type NoGoError struct, Ignored bool
+pkg go/doc, func IsPredeclared(string) bool
+pkg go/token, const ALIAS = 87
+pkg go/token, const ALIAS Token
+pkg go/types, func Default(Type) Type
+pkg go/types, func IdenticalIgnoreTags(Type, Type) bool
+pkg math/big, method (*Float) Scan(fmt.ScanState, int32) error
+pkg math/big, method (*Int) Sqrt(*Int) *Int
+pkg math/rand, func Uint64() uint64
+pkg math/rand, method (*Rand) Uint64() uint64
+pkg net, method (*Buffers) Read([]uint8) (int, error)
+pkg net, method (*Buffers) WriteTo(io.Writer) (int64, error)
+pkg net, method (*Resolver) LookupAddr(context.Context, string) ([]string, error)
+pkg net, method (*Resolver) LookupCNAME(context.Context, string) (string, error)
+pkg net, method (*Resolver) LookupHost(context.Context, string) ([]string, error)
+pkg net, method (*Resolver) LookupIPAddr(context.Context, string) ([]IPAddr, error)
+pkg net, method (*Resolver) LookupMX(context.Context, string) ([]*MX, error)
+pkg net, method (*Resolver) LookupNS(context.Context, string) ([]*NS, error)
+pkg net, method (*Resolver) LookupPort(context.Context, string, string) (int, error)
+pkg net, method (*Resolver) LookupSRV(context.Context, string, string, string) (string, []*SRV, error)
+pkg net, method (*Resolver) LookupTXT(context.Context, string) ([]string, error)
+pkg net, type Buffers [][]uint8
+pkg net, type Dialer struct, Resolver *Resolver
+pkg net, type Resolver struct
+pkg net, type Resolver struct, PreferGo bool
+pkg net, var DefaultResolver *Resolver
+pkg net/http, type PushOptions struct
+pkg net/http, type PushOptions struct, Header Header
+pkg net/http, type PushOptions struct, Method string
+pkg net/http, type Pusher interface { Push }
+pkg net/http, type Pusher interface, Push(string, *PushOptions) error
+pkg net/http, type Request struct, GetBody func() (io.ReadCloser, error)
+pkg net/http, var NoBody noBody
+pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeDone func(tls.ConnectionState, error)
+pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeStart func()
+pkg net/mail, func ParseDate(string) (time.Time, error)
+pkg net/url, func PathEscape(string) string
+pkg net/url, func PathUnescape(string) (string, error)
+pkg net/url, method (*URL) Hostname() string
+pkg net/url, method (*URL) MarshalBinary() ([]uint8, error)
+pkg net/url, method (*URL) Port() string
+pkg net/url, method (*URL) UnmarshalBinary([]uint8) error
+pkg os, var ErrClosed error
+pkg plugin, func Open(string) (*Plugin, error)
+pkg plugin, method (*Plugin) Lookup(string) (Symbol, error)
+pkg plugin, type Plugin struct
+pkg plugin, type Symbol interface {}
+pkg reflect, func Swapper(interface{}) func(int, int)
+pkg sort, func Slice(interface{}, func(int, int) bool)
+pkg sort, func SliceIsSorted(interface{}, func(int, int) bool) bool
+pkg sort, func SliceStable(interface{}, func(int, int) bool)
+pkg syscall (linux-arm), func TimevalToNsec(Timeval) int64
+pkg syscall (linux-arm-cgo), func TimevalToNsec(Timeval) int64
+pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY = 145
+pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY Errno
+pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY = 145
+pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY Errno
+pkg testing, method (*B) Name() string
+pkg testing, method (*T) Name() string
+pkg testing, type TB interface, Name() string
+pkg time, func Until(Time) Duration

doc/articles/go_command.html

@@ -97,14 +97,13 @@ a tool like the go command to look at an unfamiliar import path and
 deduce where to obtain the source code.</p>
 
 <p>Second, the place to store sources in the local file system is derived
-in a known way from the import path, specifically
-<code>$GOPATH/src/&lt;import-path&gt;</code>.
-If unset, <code>$GOPATH</code> defaults to a subdirectory
-named <code>go</code> in the user's home directory.
+in a known way from the import path.  Specifically, the first choice
+is <code>$GOPATH/src/&lt;import-path&gt;</code>.  If <code>$GOPATH</code> is
+unset, the go command will fall back to storing source code alongside the
+standard Go packages, in <code>$GOROOT/src/&lt;import-path&gt;</code>.
 If <code>$GOPATH</code> is set to a list of paths, the go command tries
 <code>&lt;dir&gt;/src/&lt;import-path&gt;</code> for each of the directories in
-that list.
-</p>
+that list.</p>
 
 <p>Each of those trees contains, by convention, a top-level directory named
 "<code>bin</code>", for holding compiled executables, and a top-level directory
@@ -138,13 +137,28 @@ to the use of a specific tool chain.</p>
 
 <h2>Getting started with the go command</h2>
 
-<p>Finally, a quick tour of how to use the go command.
-As mentioned above, the default <code>$GOPATH</code> on Unix is <code>$HOME/go</code>.
-We'll store our programs there.
-To use a different location, you can set <code>$GOPATH</code>;
-see <a href="/doc/code.html">How to Write Go Code</a> for details.
+<p>Finally, a quick tour of how to use the go command, to supplement
+the information in <a href="/doc/code.html">How to Write Go Code</a>,
+which you might want to read first.  Assuming you want
+to keep your source code separate from the Go distribution source
+tree, the first step is to set <code>$GOPATH</code>, the one piece of global
+configuration that the go command needs.  The <code>$GOPATH</code> can be a
+list of directories, but by far the most common usage should be to set it to a
+single directory.  In particular, you do not need a separate entry in
+<code>$GOPATH</code> for each of your projects.  One <code>$GOPATH</code> can
+support many projects.</p>
 
-<p>We first add some source code.  Suppose we want to use
+<p>Here’s an example.  Let’s say we decide to keep our Go code in the directory
+<code>$HOME/mygo</code>.  We need to create that directory and set
+<code>$GOPATH</code> accordingly.</p>
+
+<pre>
+$ mkdir $HOME/mygo
+$ export GOPATH=$HOME/mygo
+$
+</pre>
+
+<p>Into this directory, we now add some source code.  Suppose we want to use
 the indexing library from the codesearch project along with a left-leaning
 red-black tree.  We can install both with the "<code>go get</code>"
 subcommand:</p>
@@ -155,8 +169,8 @@ $ go get github.com/petar/GoLLRB/llrb
 $
 </pre>
 
-<p>Both of these projects are now downloaded and installed into <code>$HOME/go</code>,
-which contains the two directories
+<p>Both of these projects are now downloaded and installed into our
+<code>$GOPATH</code> directory. The one tree now contains the two directories
 <code>src/github.com/google/codesearch/index/</code> and
 <code>src/github.com/petar/GoLLRB/llrb/</code>, along with the compiled
 packages (in <code>pkg/</code>) for those libraries and their dependencies.</p>
@@ -170,7 +184,6 @@ the pattern "<code>./...</code>" means start in the current directory
 ("<code>...</code>"):</p>
 
 <pre>
-$ cd $HOME/go/src
 $ go list ./...
 github.com/google/codesearch/cmd/cgrep
 github.com/google/codesearch/cmd/cindex
@@ -202,7 +215,7 @@ $
 current directory:</p>
 
 <pre>
-$ cd github.com/google/codesearch/regexp
+$ cd $GOPATH/src/github.com/google/codesearch/regexp
 $ go list
 github.com/google/codesearch/regexp
 $ go test -v
@@ -231,6 +244,9 @@ pick such a long name, but that ability would require additional configuration
 and complexity in the tool. Typing an extra directory name or two is a small
 price to pay for the increased simplicity and power.</p>
 
+<p>As the example shows, it’s fine to work with packages from many different
+projects at once within a single <code>$GOPATH</code> root directory.</p>
+
 <h2>Limitations</h2>
 
 <p>As mentioned above, the go command is not a general-purpose build

doc/code.html

@@ -120,43 +120,30 @@ We will discuss the distinction <a href="#PackageNames">later</a>.
 
 <p>
 The <code>GOPATH</code> environment variable specifies the location of your
-workspace. It defaults to a directory named <code>go</code> inside your home directory,
-so <code>$HOME/go</code> on Unix,
-<code>$home/go</code> on Plan 9,
-and <code>%USERPROFILE%\go</code> (usually <code>C:\Users\YourName\go</code>) on Windows.
-If you would like to work in a different location, you will need to set
-<code>GOPATH</code> 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.
+workspace. It is likely the only environment variable you'll need to set
+when developing Go code.
 </p>
 
 <p>
-The command <code>go</code> <code>env</code> <code>GOPATH</code>
-prints the effective current <code>GOPATH</code>;
-it prints the default location if the environment variable is unset.
+To get started, create a workspace directory and set <code>GOPATH</code>
+accordingly. Your workspace can be located wherever you like, but we'll use
+<code>$HOME/work</code> in this document. Note that this must <b>not</b> be the
+same path as your Go installation.
+(Another common setup is to set <code>GOPATH=$HOME</code>.)
 </p>
 
+<pre>
+$ <b>mkdir $HOME/work</b>
+$ <b>export GOPATH=$HOME/work</b>
+</pre>
+
 <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>
+$ <b>export PATH=$PATH:$GOPATH/bin</b>
 </pre>
 
 <p>

doc/conduct.html

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

doc/devel/release.html

@@ -50,23 +50,11 @@ See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.1">Go
 </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,
+go1.7.2 (released 2016/10/17) 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.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.2">Go
+1.7.2 milestone</a> on our issue tracker for details.
 </p>
 
 <h2 id="go1.6">go1.6 (released 2016/02/17)</h2>
@@ -100,13 +88,6 @@ 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>

doc/devel/weekly.html

@@ -519,7 +519,7 @@ Other changes:
 	fix FreeBSD signal handling around thread creation (thanks Devon H. O'Dell),
 	goroutine profile, stack dumps,
 	implement runtime.osyield on FreeBSD 386, amd64 (thanks Devon H. O'Dell),
-	permit default behavior of SIGTSTP, SIGTTIN, SIGTTOU,
+	permit default behaviour of SIGTSTP, SIGTTIN, SIGTTOU,
 	release unused memory to the OS (thanks Sébastien Paolacci),
 	remove an obsolete file (thanks Mikio Hara).
 * spec: make all comparison results untyped bool,
@@ -2450,7 +2450,7 @@ The http package's URL parsing and query escaping code (such as ParseURL and
 URLEscape) has been moved to the new url package, with several simplifications
 to the names. Client code can be updated automatically with gofix.
 
-* asn1: support unmarshaling structs with int32 members (thanks Dave Cheney).
+* asn1: support unmarshalling structs with int32 members (thanks Dave Cheney).
 * build: allow builds without cgo or hg,
 	support versioning without hg (thanks Gustavo Niemeyer).
 * builtin: add documentation for builtins.
@@ -3030,7 +3030,7 @@ Other changes:
 * 5g: alignment fixes.
 * 6l, 8l: fix Mach-O binaries with many dynamic libraries.
 * 8l: emit resources (.rsrc) in Windows PE.  (thanks Wei Guangjing).
-* asn1: fix marshaling of empty optional RawValues (thanks Mikkel Krautz).
+* asn1: fix marshalling of empty optional RawValues (thanks Mikkel Krautz).
 * big: make Int and Rat implement fmt.Scanner (thanks Evan Shaw),
 	~8x faster number scanning,
 	remove some unnecessary conversions.
@@ -4157,7 +4157,7 @@ Other changes in this release:
 * suffixarray: use binary search for both ends of Lookup (thanks Eric Eisner).
 * syscall: add missing network interface constants (thanks Mikio Hara).
 * template: treat map keys as zero, not non-existent (thanks Roger Peppe).
-* time: allow canceling of After events (thanks Roger Peppe),
+* time: allow cancelling of After events (thanks Roger Peppe),
         support Solaris zoneinfo directory.
 * token/position: added SetLinesForContent.
 * unicode: update to unicode 6.0.0.
@@ -4238,7 +4238,7 @@ example: http://golang.org/pkg/xml/
 <pre>
 The json, gob, and template packages have changed, and code that uses them
 may need to be updated after this release. They will no longer read or write
-unexported struct fields. When marshaling a struct with json or gob the
+unexported struct fields. When marshalling a struct with json or gob the
 unexported fields will be silently ignored. Attempting to unmarshal json or
 gob data into an unexported field will generate an error. Accessing an
 unexported field from a template will cause the Execute function to return
@@ -5682,7 +5682,7 @@ Other changes:
 	pidigits ~10% performance win by using adds instead of shifts.
 * time: remove incorrect time.ISO8601 and add time.RFC3339 (thanks Micah Stetson).
 * utf16: add DecodeRune, EncodeRune.
-* xml: add support for XML marshaling embedded structs (thanks Raif S. Naffah),
+* xml: add support for XML marshalling embedded structs (thanks Raif S. Naffah),
 	new "innerxml" tag to collect inner XML.
 </pre>
 
@@ -5696,7 +5696,7 @@ This release contains many changes:
 * cmath: new complex math library (thanks Charles L. Dorian).
 * docs: update to match current coding style (thanks Christopher Wedgwood).
 * exp/eval: fix example and add target to Makefile (thanks Evan Shaw).
-* fmt: change behavior of format verb %b to match %x when negative (thanks Andrei Vieru).
+* fmt: change behaviour of format verb %b to match %x when negative (thanks Andrei Vieru).
 * gc: compile s == "" as len(s) == 0,
 	distinguish fatal compiler bug from error+exit,
 	fix alignment on non-amd64,
@@ -5925,10 +5925,10 @@ Other changes and fixes:
 * 8a/8l: Added CMOVcc instructions (thanks Evan Shaw)
 * 8l: pe executable building code changed to include import table for kernel32.dll functions (thanks Alex Brainman)
 * 5g/6g/8g: bug fixes
-* asn1: bug fixes and additions (incl marshaling)
+* asn1: bug fixes and additions (incl marshalling)
 * build: fix build for Native Client, Linux/ARM
 * dashboard: show benchmarks, add garbage collector benchmarks
-* encoding/pem: add marshaling support
+* encoding/pem: add marshalling support
 * exp/draw: fast paths for a nil mask
 * godoc: support for directories outside $GOROOT
 * http: sort header keys when writing Response or Request to wire (thanks Petar Maymounkov)

doc/go1.8.txt

@@ -1,23 +1,82 @@
-This file lists things yet to be moved into go1.8.html or deemed too
-minor to mention. Either way, delete from here when done.
+Overall:
+
+plugin build mode & package (many CLs)
+Many ppc64, s390x, arm, arm64 optimizations
+New frontend
+Improvements to binary size, runtime speed, compile speed.
+Hybrid barrier. <100us GC pauses.
+
+Language:
+
+Alias declarations?
 
 Tools:
 
+compile: SSA for 386, nacl, arm, arm64, ppc64, ppc64le, s390x ... (many CLs)
+yacc: "go tool yacc" is removed. now at golang.org/x/tools/cmd/goyacc (CL 27324, CL 27325)
 go: -buildmode=c-archive now builds PIC on ELF (CL 24180)
 go: mobile pkg dir change, recommend using go list in scripts (CL 24930, CL 27929)
 go, dist: can set default pkg-config tool using PKG_CONFIG env var (CL 29991)
 go: can set secure/insecure GIT schemes using GIT_ALLOW_PROTOCOL env var (CL 30135)
 
+Ports:
+
+dragonfly: go1.8 requires DragonFly BSD 4.4.4 or above (CL 29491)
+plan9: various fixes (Close unblocks Read, I/O deadline maybe?)
+mips, mipsle
+
 API additions and behavior changes:
 
+all: freeze net/rpc and reword the 'frozen' message in other frozen packages (CL 32112)
+archive/tar: fix and cleanup readOldGNUSparseMap (CL 28471)
+archive/tar: fix parsePAX to be POSIX.1-2001 compliant (CL 31440)
+archive/tar: fix parsePAXTime (CL 31441)
+archive/tar: make Reader handle GNU format properly (CL 31444)
+archive/tar: reapply Header.Size to regFileReader after merging (CL 28418)
+archive/tar: validate sparse headers in parsePAX (CL 31439)
+archive/zip: handle mtime in NTFS/UNIX/ExtendedTS extra fields (CL 18274)
+archive/zip: only use Extended Timestamp on non-zero MS-DOS timestamps (CL 30811)
+cmd/cgo: add -srcdir option (CL 32354)
+cmd/cgo: fix line info in _cgo_gotypes.go (CL 29713)
+cmd/cgo: throw if C.malloc returns nil (CL 31768)
 cmd/compile, runtime, etc: get rid of constant FP registers (CL 28095)
 cmd/compile, runtime: add go:yeswritebarrierrec pragma (CL 30938)
+cmd/compile/internal/gc: add runtime/trace support (CL 25354)
 cmd/compile/internal/gc: enable new parser by default (CL 27203)
 cmd/compile/internal/syntax: fast Go syntax trees, initial commit (CL 27195)
+cmd/compile: add SSA backend for s390x and enable by default (CL 28978)
 cmd/compile: add compiler phase timing (CL 24462)
+cmd/compile: add go:notinheap type pragma (CL 30939)
 cmd/compile: add inline explainer (CL 22782)
+cmd/compile: args no longer live until end of function - use runtime.KeepAlive instead (CL 28310)
 cmd/compile: enable flag-specified dump of specific phase+function (CL 23044)
-
+cmd/compile: fail gracefully on export format skew (CL 27814)
+cmd/compile: import/export of alias declarations (CL 32090)
+cmd/compile: inline convI2E (CL 31260)
+cmd/compile: make ssa compilation unconditional (CL 29155)
+cmd/compile: remove -A flag (CL 31497)
+cmd/compile: remove old lexer and parser (CL 32020)
+cmd/compile: remove support for textual export format (CL 27171)
+cmd/cover: Fix compiler directives handling (CL 30161)
+cmd/cover: handle gotos (CL 30977)
+cmd/dist, go/build: make CGO_ENABLED during make.bash sticky (CL 31141)
+cmd/dist: enable plugin test on darwin/amd64 (CL 29396)
+cmd/dist: test PIE internal linking on linux/amd64 (CL 28545)
+cmd/doc: ensure summaries truly are only one line (CL 25420)
+cmd/doc: perform type grouping for constants and variables (CL 25419)
+cmd/doc: show documentation for interface methods when requested explicitly (CL 31852)
+cmd/fix: add golang.org/x/net/context fix (CL 28872)
+cmd/go, testing: indicate when no tests are run (CL 22341)
+cmd/go: add bug command (CL 28485)
+cmd/go: add distribution-specific info for Linux to bug command (CL 28581)
+cmd/go: apply import restrictions to test code too (CL 31821)
+cmd/go: diagnose non-canonical import paths before compilation (CL 31668)
+cmd/go: enable -buildmode=plugin on darwin/amd64 (CL 29395)
+cmd/go: for -msan build runtime/cgo with -fsanitize=memory (CL 24855)
+cmd/go: make bug subcommand open the browser (CL 29210)
+cmd/go: make go test -i -o x.test actually write x.test (CL 31352)
+cmd/go: print more env variables in "go env" (CL 31330)
+cmd/go: referee another vendor vs symlink fight (CL 31665)
 cmd/internal/obj, cmd/link: darwin dynlink support (CL 29393)
 cmd/internal/objfile: add ppc64/ppc64le disassembler support (CL 9682)
 cmd/link, cmd/go: delay linking of mingwex and mingw32 until very end (CL 26670)
@@ -26,30 +85,359 @@ cmd/link: add trampolines for too far calls in ppc64x (CL 30850)
 cmd/link: allow internal PIE linking (CL 28543)
 cmd/link: fix -X importpath.name=value when import path needs escaping (CL 31970)
 cmd/link: fix -buildmode=pie / -linkshared combination (CL 28996)
-cmd/link: for -buildmode=exe pass -no-pie to external linker (CL 33106)
 cmd/link: insert trampolines for too-far jumps on ARM (CL 29397)
 cmd/link: non-executable stack support for Solaris (CL 24142)
+cmd/link: plugin support on darwin/amd64 (CL 29394)
 cmd/link: put text at address 0x1000000 on darwin/amd64 (CL 32185)
 cmd/link: remove the -shared flag (CL 28852)
 cmd/link: split large elf text sections on ppc64x (CL 27790)
 cmd/link: trampoline support for external linking on ARM (CL 31143)
 cmd/objdump: implement objdump of .o files (CL 24818)
-
+cmd/pprof: instruction-level granularity in callgrind output (CL 23781)
+cmd/trace: add option to output pprof files (CL 23324)
+cmd/trace: fix a runnable goroutine count bug (CL 25552)
+cmd/trace: move process-wide GC events to their own row (CL 30017)
+cmd/vet: accept space-separated tag lists for compatibility with cmd/go (CL 32030)
+cmd/vet: allow ^& uintptr arithmetic (CL 27156)
+cmd/vet: allow any printf verb with any interface (CL 27127)
+cmd/vet: check for copying of array of locks (CL 24340)
+cmd/vet: check for duplicate json, xml struct field tags (CL 16704)
+cmd/vet: diagnose non-space-separated struct tag like `json:"x",xml:"y"` (CL 32031)
+cmd/vet: improve asmdecl parameter handling (CL 27150)
+cmd/vet: properly handle indexed arguments in printf (CL 24391)
+cmd/vet: skip printf check for non-constant format string during failed import (CL 29014)
+compress/flate: always return uncompressed data in the event of error (CL 28216)
+compress/flate: level 1 (best speed) match across blocks (CL 31640)
+compress/flate: make compression level 0 consistent (CL 31174)
+compress/flate: tighten the BestSpeed max match offset bound. (CL 32149)
+compress/gzip, compress/zlib: add HuffmanOnly as compression levels. (CL 31186)
+compress/gzip: only encode MTIME if it is valid (CL 32325)
+context: make DeadlineExceeded implement net.Error (CL 30370)
+crypto/cipher: enforce message size limits for GCM (CL 28410)
+crypto/rsa: ensure that generating toy RSA keys doesn't loop (CL 28969)
+crypto/tls: add CloseWrite method to Conn (CL 25159)
+crypto/tls: add CloseWrite method to Conn (CL 31318)
+crypto/tls: add Config.Clone (CL 28075)
+crypto/tls: add Config.GetConfigForClient (CL 30790)
+crypto/tls: add GetClientCertificate callback (CL 32115)
+crypto/tls: add KeyLogWriter for debugging (CL 27434)
+crypto/tls: add VerifyPeerCertificate to tls.Config (CL 26654)
+crypto/tls: add a SignatureScheme type. (CL 32119)
+crypto/tls: don't generate random ticket keys if already set (CL 27317)
+crypto/tls: enable ChaCha20-Poly1305 cipher suites by default. (CL 30958)
+crypto/tls: expand ClientHelloInfo (CL 31391)
+crypto/tls: fix deadlock when racing to complete handshake (CL 29164)
+crypto/tls: flush the buffer on handshake errors (CL 28818)
+crypto/tls: implement countermeasures against CBC padding oracles (CL 18130)
+crypto/tls: set Conn.ConnectionState.ServerName unconditionally (CL 22862)
+crypto/tls: support AES-128-CBC cipher suites with SHA-256 (CL 27315)
+crypto/tls: support ChaCha20-Poly1305. (CL 30957)
+crypto/tls: support X25519 (CL 30824, CL 30825)
+crypto/x509: Fix bug in UnknownAuthorityError.Error (CL 27992)
+crypto/x509: allow a leaf certificate to be specified directly as root (CL 27393)
+crypto/x509: check that the issuer name matches the issuer's subject name (CL 23571)
+crypto/x509: don't accept a root that already appears in a chain. (CL 32121)
+crypto/x509: fix name constraints handling (CL 30155)
+crypto/x509: implement SystemCertPool on Windows (CL 30578)
+crypto/x509: parse all names in an RDN (CL 30810)
+crypto/x509: recognise ISO OID for RSA+SHA1 (CL 27394)
+crypto/x509: require a NULL parameters for RSA public keys (CL 16166)
+crypto/x509: require a NULL parameters for RSA public keys (CL 27312)
+crypto/x509: return error for missing SerialNumber (CL 27238)
+crypto/x509: support PSS signatures (CL 24743)
+crypto/x509: support RHEL 7 cert bundle (CL 30375)
+database/sql: accept nil pointers to Valuers implemented on value receivers (CL 31259)
+database/sql: add Pinger interface to driver Conn (CL 32136)
+database/sql: add context helper methods and transaction types (CL 31258)
+database/sql: add context methods (CL 29381)
+database/sql: add option to use named parameter in query arguments (CL 30166)
+database/sql: add support for multiple result sets (CL 30592)
+database/sql: don't hang if the driver Exec method panics (CL 23576)
+database/sql: support returning query database types (CL 29961)
+debug/elf: add sparc64 relocations (CL 30870)
+debug/pe: revert CL 22720 (CL 27212)
+doc: document minimum OS X version as 10.8 (CL 28870)
+encoding/base64: add Encoding.Strict (CL 24964)
+encoding/binary: add bool support (CL 28514)
+encoding/json: add struct and field name to UnmarshalTypeError message (CL 18692)
+encoding/json: fix decoding of null into Unmarshaler, TextUnmarshaler (CL 30944)
+encoding/json: marshal the RawMessage value type the same as its pointer type (CL 21811)
+encoding/json: use standard ES6 formatting for numbers during marshal (CL 30371)
+encoding/pem: be stricter about the ending line (CL 27391)
+encoding/xml: add wildcard support for collecting all attributes (CL 30946)
+encoding/xml: prevent omitempty from omitting non-nil pointers to empty values (CL 15684)
+expvar: add Value methods (CL 30917)
+expvar: export http.Handler (CL 24722)
+flag: arrange for FlagSet.Usage to be non-nil by default (CL 31576)
+fmt: document and adjust Scanf space handling to eliminate a few paradoxes (CL 30611)
+go/ast, go/parser: parse alias declarations (CL 30211)
 go/build: allow % in ${SRCDIR} expansion for Jenkins (CL 31611)
 go/build: do not record go:binary-only-package if build tags not satisfied (CL 31577)
-go/build: implement default GOPATH (CL 32019)
-
+go/doc: add IsPredeclared function (CL 29870)
+go/doc: allow ToHTML to properly handle URLs containing semicolons (CL 25385)
+go/internal/gcimporter: fail gracefully on export format skew (CL 27816)
+go/token: fix race in FileSet.PositionFor. (CL 25345)
+go/types: expose Default function, which converts untyped T to T (CL 30715)
+go/types: handle imported aliases (CL 32534)
+go/types: match cmd/compile's alignment for complex64 (CL 31939)
+go/types: minimal support for alias declarations: don't crash (CL 30213)
+html/template: check "type" attribute in <script> (CL 14336)
+image/color: tweak the formula for converting to gray. (CL 31538)
+image/png: implement grayscale transparency. (CL 32143)
+image/png: implement truecolor transparency. (CL 32140)
+image/png: improve compression by skipping filter for paletted images (CL 29872)
+internal/trace: fix analysis of EvGoWaiting/EvGoInSyscall events (CL 25572)
+io: fix infinite loop bug in MultiReader (CL 27397)
+io: make MultiReader nil exhausted Readers for earlier GC (CL 28533)
+math/big: Rat.SetString to report error if input is not consumed entirely (CL 30472)
+math/big: add (*Int).Sqrt (CL 30706)
+math/big: implement Float.Scan, type assert fmt interfaces to enforce docs (CL 30723)
+math/big: support negative numbers in ModInverse (CL 29299)
+math/big: test and optimize Exp(2, y, n) for large y, odd n (CL 30708)
+math/cmplx: prevent infinite loop in tanSeries (CL 31952)
+math/rand: add Rand.Uint64 (CL 27253)
+math: fix Gamma(-171.5) on all platforms (CL 30540)
+mime/quotedprintable: accept = not followed by 2 hex digits as literal equals (CL 32174)
+mime/quotedprintable: accept trailing soft line-break at the end of message (CL 27530)
+mime: preserve unnecessary backslash escapes as literals (CL 32175)
+net/http, net/http/httptest: make http2's TrailerPrefix work for http1 (CL 32479)
+net/http/httptest: fill ContentLength in recorded Response (CL 28302)
+net/http/httptrace: add ClientTrace.TLSHandshakeStart & TLSHandshakeDone (CL 30359)
+net/http/httputil: add ModifyResponse to reverseProxy (CL 32356)
+net/http/httputil: copy header map if necessary in ReverseProxy (CL 28493)
+net/http/httputil: log err encountered during reverseproxy body copying (CL 30692)
+net/http/httputil: make ReverseProxy send nil Body requests when possible (CL 28412)
+net/http/httputil: remove custom hop-by-hop headers from response in ReverseProxy (CL 28810)
+net/http/httputil: remove proxied headers mentioned in connection-tokens (CL 27970)
+net/http/internal: don't block unnecessarily in ChunkedReader (CL 31329)
+net/http: add NoBody, don't return nil from NewRequest on zero bodies (CL 31726)
+net/http: add Request.GetBody func for 307/308 redirects (CL 31733)
+net/http: add Server.Close & Server.Shutdown for forced & graceful shutdown (CL 32329)
+net/http: add Server.ReadHeaderTimeout, IdleTimeout, document WriteTimeout (CL 32024)
+net/http: add Transport.ProxyConnectHeader to control headers to proxies (CL 32481)
+net/http: add an interface for HTTP/2 server push (CL 32012)
+net/http: allow Handlers to test Hijacked conn without spamming error log (CL 30812)
+net/http: don't sniff Request.Body on 100-continue requests in Transport (CL 30151)
+net/http: handle 3xx redirects properly (CL 29852)
+net/http: make Client copy headers on redirect (CL 28930)
+net/http: make DefaultTransport's Dialer enable DualStack ("Happy Eyeballs") (CL 28077)
+net/http: make NewRequest set empty Body nil, don't peek Read Body in Transport (CL 31445)
+net/http: make Redirect escape non-ASCII in Location header (CL 31732)
+net/http: make Server Handler's Request.Context be done on conn errors (CL 31173)
+net/http: make Transport reject URLs with bogus ports with non-digits (CL 32482)
+net/http: make Transport retry non-idempotent requests if no bytes written (CL 27117)
+net/http: make Transport support international domain names (CL 29072)
+net/http: omit Content-Length in Response.Write for 1xx or 204 status (CL 28351)
+net/http: returned typed error on Transport proxy dial (CL 30750)
+net/http: send Content-Range if no byte range overlaps (CL 24212)
+net/http: skip test needing good DNS in short mode, except on builders (CL 28782)
+net/http: support multiple identical Content-Length headers (CL 31252)
+net/http: update bundled http2, add h2 Transport.IdleConnTimeout tests (CL 30078)
+net/mail: allow empty quoted string name in address again (CL 32176)
+net/mail: expose ParseDate, for use parsing Resent-Date headers (CL 31581)
+net/url: add PathEscape, PathUnescape (CL 31322)
+net/url: add URL.Hostname and URL.Port accessors (CL 28933)
+net/url: handle escaped paths in ResolveReference (CL 28343)
+net/url: make URL implement encoding.BinaryMarshaler, BinaryUnmarshaler (CL 31467)
+net/url: prefix relative paths containing ":" in the first segment with "./" (CL 29610)
+net/url: reject colon in first segment of relative path in Parse (CL 31582)
+net: add (*UnixListener).SetUnlinkOnClose (CL 32099)
+net: add Buffers type, do writev on unix (CL 29951)
+net: add Resolver type, Dialer.Resolver, and DefaultResolver (CL 29440)
+net: always wake up the readers on close on Plan 9 (CL 31390)
+net: break up >1GB reads and writes on stream connections (CL 31584)
+net: close the connection gracefully on Plan 9 (CL 31271)
+net: implement network interface API for Plan 9 (CL 29963)
+net: implement network interface API for Solaris (CL 29892)
+net: make LookupPort and lookupProtocol work on nacl (CL 28951)
+net: make lookupPort case-insensitive on Plan 9 (CL 29051)
+net: only remove Unix domain socket file on the first call to Close (CL 32098)
+net: remove parsing of negative decimals in IPv4 literal (CL 28414)
+net: respect resolv.conf rotate option (CL 29233)
+net: support "option ndots:0" in resolv.conf (CL 24901)
+net: there are no invalid domain names anymore (CL 31468)
+net: use libresolv rules for ndots range and validation (CL 24901)
+os, syscall: fix incorrect offset calculation in Readlink on windows (CL 31118)
+os: add ErrClosed, return for use of closed File (CL 30614)
+os: add Executable() (CL 16551)
+os: consider only files from #M as regular on Plan 9 (CL 32152)
+os: don't let File.Readdir return an empty slice and nil error (CL 28056)
+os: make IsExist report true on ERROR_DIR_NOT_EMPTY on Windows (CL 29753)
+os: make Windows readConsole handle input and output correctly (CL 29493)
+os: prevent infinite symlink loop of Stat on Windows (CL 27580)
+os: reject Rename("old", "new") where new is a directory (CL 31358)
+os: use GetConsoleCP() instead of GetACP() (CL 27575)
+path/filepath: don't return SkipDir at top (CL 24780)
+path/filepath: fix Abs on Windows (CL 32292)
+path/filepath: fix match of \\?\c:\* on Windows (CL 31460)
+path/filepath: handle ".." in normalizing a path on Windows (CL 27410)
+path/filepath: handle "C:." correctly in EvalSymlinks on Windows (CL 28214)
+plugin: darwin support (CL 29392)
+plugin: mention OS X support and concurrency (CL 31463)
+plugin: new package for loading plugins (CL 27823)
+reflect: add Swapper func (CL 30088)
+reflect: fix DeepEqual for some cyclic corner cases (CL 31588)
+reflect: ignore struct tags when converting structs (CL 30191)
+runtime, cmd/trace: annotate different mark worker types (CL 30702)
+runtime, runtime/cgo: revert CL 18814; don't drop signal stack in new thread on dragonfly (CL 29971)
+runtime/pprof: write profiles in protobuf format. (CL 32257)
+runtime/race: don't crash on invalid PCs (CL 29714)
 runtime/race: update race runtime (CL 32160)
+runtime: Profile goroutines holding contended mutexes. (CL 29650)
 runtime: assume 64kB physical pages on ARM (CL 25021)
 runtime: disable stack rescanning by default (CL 31766)
 runtime: don't call cgocallback from signal handler (CL 30218)
+runtime: fetch physical page size from the OS (CL 25050)
 runtime: fix check for vacuous page boundary rounding (CL 27230)
 runtime: fix map iterator concurrent map check (CL 24749)
 runtime: fix newextram PC passed to race detector (CL 29712)
 runtime: implement unconditional hybrid barrier (CL 31765)
-runtime: include pre-panic/throw logs in core dumps (CL 32013)
 runtime: limit the number of map overflow buckets (CL 25049)
 runtime: pass windows float syscall args via XMM (CL 32173)
 runtime: print sigcode on signal crash (CL 32183)
 runtime: record current PC for SIGPROF on non-Go thread (CL 30252)
+runtime: report GCSys and OtherSys in heap profile (CL 29276)
 runtime: sleep on CLOCK_MONOTONIC in futexsleep1 on freebsd (CL 30154)
+runtime: use RtlGenRandom instead of CryptGenRandom (CL 29700)
+runtime: use clock_gettime(CLOCK_REALTIME) for nanosecond-precision time.now on arm64, mips64x (CL 32177)
+runtime: use correct system page size on all arches (CL 25022)
+sort: add Slice, SliceStable, and SliceIsSorted (CL 27321)
+spec: add new language for alias declarations (CL 30601)
+spec: ignore struct tags when converting structs (CL 24190)
+spec: require 16 bit minimum exponent in constants rather than 32 (CL 17711)
+spec: update language on type switches to match implementations (CL 27356)
+strconv: strip \r in raw strings passed to Unquote (CL 31210)
+strings, bytes: panic if Repeat overflows or if given a negative count (CL 29954)
+sync: enable Pool when using race detector (CL 31589)
+sync: throw, not panic, for unlock of unlocked mutex (CL 31359)
+syscall: add bounds checking and error returns to ParseNetlinkMessage (CL 26990)
+syscall: fix Send{msg,msgN}, Recvmsg and control message handling on solaris (CL 30171)
+syscall: make Getpagesize return system-reported page size (CL 25051)
+syscall: make Utimes on Solaris match all the other geese (CL 31446)
+syscall: remove X__cmsg_data from Cmsghdr (CL 32319)
+syscall: unify NsecToTime{spec,val}, fix for times < 1970 (CL 30826)
+syscall: validate ParseDirent inputs (CL 23780)
+testing/quick, text/tabwriter: freeze packages (CL 31910)
+testing: add Name method to *T and *B (CL 29970)
+testing: add a method testing.CoverMode (CL 32483)
+testing: respect benchtime on very fast benchmarks (CL 26664)
+text/template: add support for reflect.Value args, results in funcs (CL 31462)
+time: add Until helper function (CL 20118)
+time: allow long fractions in ParseDuration (CL 29338)
+time: be consistent about representation of UTC location in Time struct (CL 31144)
+unicode: change SimpleFold to handle invalid runes (CL 30935)
+website: recreate 16px and 32px favicon (CL 26850)
+
+Optimizations:
+
+bytes, strings: optimize for ASCII sets (CL 31593)
+bytes, strings: optimize multi-byte index operations on s390x (CL 32447)
+bytes,strings: use IndexByte more often in Index on AMD64 (CL 31690)
+bytes: Use the same algorithm as strings for Index (CL 22550)
+bytes: improve WriteRune performance (CL 28816)
+bytes: improve performance for bytes.Compare on ppc64x (CL 30949)
+bytes: make IndexRune faster (CL 28537)
+cmd/asm, go/build: invoke cmd/asm only once per package (CL 27636)
+cmd/compile, cmd/link: more efficient typelink generation (CL 31772)
+cmd/compile, cmd/link: stop generating unused go.string.hdr symbols. (CL 31030)
+cmd/compile,runtime: redo how map assignments work (CL 30815)
+cmd/compile/internal/obj/x86: eliminate some function prologues (CL 24814)
+cmd/compile: accept literals in samesafeexpr (CL 26666)
+cmd/compile: add more non-returning runtime calls (CL 28965)
+cmd/compile: add size hint to map literal allocations (CL 23558)
+cmd/compile: be more aggressive in tighten pass for booleans (CL 28390)
+cmd/compile: directly construct Fields instead of ODCLFIELD nodes (CL 31670)
+cmd/compile: don't reserve X15 for float sub/div any more (CL 28272)
+cmd/compile: don’t generate pointless gotos during inlining (CL 27461)
+cmd/compile: fold negation into comparison operators (CL 28232)
+cmd/compile: generate makeslice calls with int arguments (CL 27851)
+cmd/compile: handle e == T comparison more efficiently (CL 26660)
+cmd/compile: improve s390x SSA rules for logical ops (CL 31754)
+cmd/compile: improve s390x rules for folding ADDconst into loads/stores (CL 30616)
+cmd/compile: improve string iteration performance (CL 27853)
+cmd/compile: improve tighten pass (CL 28712)
+cmd/compile: inline _, ok = i.(T) (CL 26658)
+cmd/compile: inline atomics from runtime/internal/atomic on amd64 (CL 27641, CL 27813)
+cmd/compile: inline convT2{I,E} when result doesn't escape (CL 29373)
+cmd/compile: inline x, ok := y.(T) where T is a scalar (CL 26659)
+cmd/compile: intrinsify atomic operations on s390x (CL 31614)
+cmd/compile: intrinsify math/big.mulWW, divWW on AMD64 (CL 30542)
+cmd/compile: intrinsify runtime/internal/atomic.Xaddint64 (CL 29274)
+cmd/compile: intrinsify slicebytetostringtmp when not instrumenting (CL 29017)
+cmd/compile: intrinsify sync/atomic for amd64 (CL 28076)
+cmd/compile: make [0]T and [1]T SSAable types (CL 32416)
+cmd/compile: make link register allocatable in non-leaf functions (CL 30597)
+cmd/compile: missing float indexed loads/stores on amd64 (CL 28273)
+cmd/compile: move stringtoslicebytetmp to the backend (CL 32158)
+cmd/compile: only generate ·f symbols when necessary (CL 31031)
+cmd/compile: optimize bool to int conversion (CL 22711)
+cmd/compile: optimize integer "in range" expressions (CL 27652)
+cmd/compile: remove Zero and NilCheck for newobject (CL 27930)
+cmd/compile: remove duplicate nilchecks (CL 29952)
+cmd/compile: remove some write barriers for stack writes (CL 30290)
+cmd/compile: simplify div/mod on ARM (CL 29390)
+cmd/compile: statically initialize some interface values (CL 26668)
+cmd/compile: unroll comparisons to short constant strings (CL 26758)
+cmd/compile: use 2-result divide op (CL 25004)
+cmd/compile: use masks instead of branches for slicing (CL 32022)
+cmd/compile: when inlining ==, don’t take the address of the values (CL 22277)
+container/heap: remove one unnecessary comparison in Fix (CL 24273)
+crypto/sha256: improve performance for sha256.block on ppc64le (CL 32318)
+crypto/sha512: improve performance for sha512.block on ppc64le (CL 32320)
+crypto/{aes,cipher}: add optimized implementation of AES-GCM for s390x (CL 30361)
+encoding/asn1: reduce allocations in Marshal (CL 27030)
+encoding/csv: avoid allocations when reading records (CL 24723)
+encoding/hex: change lookup table from string to array (CL 27254)
+encoding/json: Use a lookup table for safe characters (CL 24466)
+hash/crc32: improve the AMD64 implementation using SSE4.2 (CL 24471)
+hash/crc32: improve the AMD64 implementation using SSE4.2 (CL 27931)
+hash/crc32: improve the processing of the last bytes in the SSE4.2 code for AMD64 (CL 24470)
+image/color: improve speed of RGBA methods (CL 31773)
+image/draw: optimize drawFillOver as drawFillSrc for opaque fills (CL 28790)
+math/big: avoid allocation in float.{Add, Sub} when there's no aliasing (CL 23568)
+math/big: make division faster (CL 30613)
+math/big: slightly faster float->decimal conversion (CL 31250)
+math/big: use array instead of slice for deBruijn lookups (CL 26663)
+math/big: uses SIMD for some math big functions on s390x (CL 32211)
+math: speed up Gamma(+Inf) (CL 31370)
+math: speed up bessel functions on AMD64 (CL 28086)
+reflect: avoid zeroing memory that will be overwritten (CL 28011)
+regexp: avoid alloc in QuoteMeta when not quoting (CL 31395)
+regexp: reduce mallocs in Regexp.Find* and Regexp.ReplaceAll* (CL 23030)
+runtime: cgo calls are about 100ns faster (CL 29656, CL 30080)
+runtime: defer is now 2X faster (CL 29656)
+runtime: implement getcallersp in Go (CL 29655)
+runtime: improve memmove for amd64 (CL 22515, CL 29590)
+runtime: increase malloc size classes (CL 24493)
+runtime: large objects no longer cause significant goroutine pauses (CL 23540)
+runtime: make append only clear uncopied memory (CL 30192)
+runtime: make assists perform root jobs (CL 32432)
+runtime: memclr perf improvements on ppc64x (CL 30373)
+runtime: minor string/rune optimizations (CL 27460)
+runtime: optimize defer code (CL 29656)
+runtime: remove a load and shift from scanobject (CL 22712)
+runtime: remove defer from standard cgo call (CL 30080)
+runtime: speed up StartTrace with lots of blocked goroutines (CL 25573)
+runtime: speed up non-ASCII rune decoding (CL 28490)
+strconv: make FormatFloat slowpath a little faster (CL 30099)
+strings: add special cases for Join of 2 and 3 strings (CL 25005)
+strings: make IndexRune faster (CL 28546)
+strings: use AVX2 for Index if available (CL 22551)
+strings: use Index in Count (CL 28586)
+syscall: avoid convT2I allocs for common Windows error values (CL 28484, CL 28990)
+text/template: improve lexer performance in finding left delimiters (CL 24863)
+unicode/utf8: optimize ValidRune (CL 32122)
+unicode/utf8: reduce bounds checks in EncodeRune (CL 28492)
+
+Documentation:
+
+all: many more examples in documentations (many CLs)
+runtime: runtime.MemStats has much more detailed documentation (CL 28972)
+
+Binary Size:
+
+cmd/link: more efficient encoding of DWARF line number information (CL 30577)
+cmd/compile: recognize integer ranges in switch statements (CL 26770)
+cmd/compile: use two tables for table-driven map inserts (CL 26669)
+cmd/link: when dynlinking, do not mangle short symbol names (CL 26890)
+cmd/compile, runtime: stop padding stackmaps to 4 bytes (CL 30817)

doc/go_faq.html

@@ -769,29 +769,6 @@ for i, v := range t {
 }
 </pre>
 
-<h3 id="convert_slice_with_same_underlying_type">
-Can I convert []T1 to []T2 if T1 and T2 have the same underlying type?</h3>
-
-This last line of this code sample does not compile.
-
-<pre>
-type T1 int
-type T2 int
-var t1 T1
-var x = T2(t1) // OK
-var st1 []T1
-var sx = ([]T2)(st1) // NOT OK
-</pre>
-
-<p>
-In Go, types are closely tied to methods, in that every named type has
-a (possibly empty) method set.
-The general rule is that you can change the name of the type being
-converted (and thus possibly change its method set) but you can't
-change the name (and method set) of elements of a composite type.
-Go requires you to be explicit about type conversions.
-</p>
-
 <h3 id="nil_error">
 Why is my nil error value not equal to nil?
 </h3>
@@ -1094,7 +1071,7 @@ it's easy to work around this. For GitHub, try one of these solutions:
 <ul>
 <li>Manually clone the repository in the expected package directory:
 <pre>
-$ cd src/github.com/username
+$ cd $GOPATH/src/github.com/username
 $ git clone git@github.com:username/package.git
 </pre>
 </li>

doc/go_spec.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of November 18, 2016",
+	"Subtitle": "Version of November 4, 2016",
 	"Path": "/ref/spec"
 }-->
 
@@ -265,7 +265,7 @@ The following character sequences represent <a href="#Operators">operators</a>,
 *    ^     *=    ^=     &lt;-    &gt;     &gt;=    {    }
 /    &lt;&lt;    /=    &lt;&lt;=    ++    =     :=    ,    ;
 %    &gt;&gt;    %=    &gt;&gt;=    --    !     ...   .    :
-     &amp;^          &amp;^=
+     &amp;^          &amp;^=    =&gt;
 </pre>
 
 <h3 id="Integer_literals">Integer literals</h3>
@@ -2006,7 +2006,7 @@ _, y, _ := coord(p)  // coord() returns three values; only interested in y coord
 <p>
 Unlike regular variable declarations, a short variable declaration may <i>redeclare</i>
 variables provided they were originally declared earlier in the same block
-(or the parameter lists if the block is the function body) with the same type,
+(or the parameter lists if the block is the function body) with the same type, 
 and at least one of the non-<a href="#Blank_identifier">blank</a> variables is new.
 As a consequence, redeclaration can only appear in a multi-variable short declaration.
 Redeclaration does not introduce a new variable; it just assigns a new value to the original.
@@ -2352,11 +2352,10 @@ the <code>&amp;T</code> when the element or key type is <code>*T</code>.
 [][]int{{1, 2, 3}, {4, 5}}          // same as [][]int{[]int{1, 2, 3}, []int{4, 5}}
 [][]Point{{{0, 1}, {1, 2}}}         // same as [][]Point{[]Point{Point{0, 1}, Point{1, 2}}}
 map[string]Point{"orig": {0, 0}}    // same as map[string]Point{"orig": Point{0, 0}}
-map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}
 
-type PPoint *Point
-[2]*Point{{1.5, -3.5}, {}}          // same as [2]*Point{&amp;Point{1.5, -3.5}, &amp;Point{}}
-[2]PPoint{{1.5, -3.5}, {}}          // same as [2]PPoint{PPoint(&amp;Point{1.5, -3.5}), PPoint(&amp;Point{})}
+[...]*Point{{1.5, -3.5}, {0, 0}}    // same as [...]*Point{&amp;Point{1.5, -3.5}, &amp;Point{0, 0}}
+
+map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}
 </pre>
 
 <p>
@@ -4799,8 +4798,8 @@ The "fallthrough" statement is not permitted in a type switch.
 <h3 id="For_statements">For statements</h3>
 
 <p>
-A "for" statement specifies repeated execution of a block. There are three forms:
-The iteration may be controlled by a single condition, a "for" clause, or a "range" clause.
+A "for" statement specifies repeated execution of a block. The iteration is
+controlled by a condition, a "for" clause, or a "range" clause.
 </p>
 
 <pre class="ebnf">
@@ -4808,8 +4807,6 @@ ForStmt = "for" [ Condition | ForClause | RangeClause ] Block .
 Condition = Expression .
 </pre>
 
-<h4 id="For_condition">For statements with single condition</h4>
-
 <p>
 In its simplest form, a "for" statement specifies the repeated execution of
 a block as long as a boolean condition evaluates to true.
@@ -4824,8 +4821,6 @@ for a &lt; b {
 }
 </pre>
 
-<h4 id="For_clause">For statements with <code>for</code> clause</h4>
-
 <p>
 A "for" statement with a ForClause is also controlled by its condition, but
 additionally it may specify an <i>init</i>
@@ -4864,8 +4859,6 @@ for cond { S() }    is the same as    for ; cond ; { S() }
 for      { S() }    is the same as    for true     { S() }
 </pre>
 
-<h4 id="For_range">For statements with <code>range</code> clause</h4>
-
 <p>
 A "for" statement with a "range" clause
 iterates through all entries of an array, slice, string or map,

doc/help.html

@@ -11,9 +11,6 @@
 
 <h3 id="mailinglist"><a href="https://groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
 <p>
-Get help from Go users, and share your work on the official mailing list.
-</p>
-<p>
 Search the <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>
 archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
 <a href="//golang.org/wiki">wiki</a> before posting.
@@ -21,12 +18,12 @@ archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
 
 <h3 id="forum"><a href="https://forum.golangbridge.org/">Go Forum</a></h3>
 <p>
-The <a href="https://forum.golangbridge.org/">Go Forum</a> is a discussion
+The <a href="https://forum.golangbridge.org/">Go Forum</a> is an alternate discussion
 forum for Go programmers.
 </p>
 
 <h3 id="slack"><a href="https://blog.gopheracademy.com/gophers-slack-community/">Gopher Slack</a></h3>
-<p>Get live support from other users in the Go slack channel.</p>
+<p>Get live support from the official Go slack channel.</p>
 
 <h3 id="irc"><a href="irc:irc.freenode.net/go-nuts">Go IRC Channel</a></h3>
 <p>Get live support at <b>#go-nuts</b> on <b>irc.freenode.net</b>, the official

doc/install-source.html

@@ -33,7 +33,7 @@ compiler using the GCC back end, see
 </p>
 
 <p>
-The Go compilers support eight instruction sets.
+The Go compilers support seven instruction sets.
 There are important differences in the quality of the compilers for the different
 architectures.
 </p>
@@ -55,7 +55,7 @@ architectures.
 	<code>arm</code> (<code>ARM</code>)
 </dt>
 <dd>
-	Supports Linux, FreeBSD, NetBSD, OpenBSD and Darwin binaries. Less widely used than the other ports.
+	Supports Linux, FreeBSD, NetBSD and Darwin binaries. Less widely used than the other ports.
 </dd>
 <dt>
 	<code>arm64</code> (<code>AArch64</code>)
@@ -69,12 +69,6 @@ architectures.
 <dd>
 	Supports Linux binaries. New in 1.5 and not as well exercised as other ports.
 </dd>
-<dt>
-	<code>mips, mipsle</code> (32-bit MIPS big- and little-endian)
-</dt>
-<dd>
-	Supports Linux binaries. New in 1.8 and not as well exercised as other ports.
-</dd>
 <dt>
 	<code>mips64, mips64le</code> (64-bit MIPS big- and little-endian)
 </dt>
@@ -218,7 +212,7 @@ To build without <code>cgo</code>, set the environment variable
 Change to the directory that will be its parent
 and make sure the <code>go</code> directory does not exist.
 Then clone the repository and check out the latest release tag
-(<code class="versionTag">go1.7.4</code>, for example):</p>
+(<code class="versionTag">go1.7.2</code>, for example):</p>
 
 <pre>
 $ git clone https://go.googlesource.com/go
@@ -335,7 +329,7 @@ You just need to do a little more setup.
 </p>
 
 <p>
-The <a href="/doc/code.html">How to Write Go Code</a> document
+The <a href="/doc/code.html">How to Write Go Code</a> document 
 provides <b>essential setup instructions</b> for using the Go tools.
 </p>
 
@@ -361,7 +355,7 @@ $ go get golang.org/x/tools/cmd/godoc
 </pre>
 
 <p>
-To install these tools, the <code>go</code> <code>get</code> command requires
+To install these tools, the <code>go</code> <code>get</code> command requires 
 that <a href="#git">Git</a> be installed locally.
 </p>
 
@@ -406,7 +400,7 @@ New releases are announced on the
 <a href="//groups.google.com/group/golang-announce">golang-announce</a>
 mailing list.
 Each announcement mentions the latest release tag, for instance,
-<code class="versionTag">go1.7.4</code>.
+<code class="versionTag">go1.7.2</code>.
 </p>
 
 <p>
@@ -436,7 +430,7 @@ to override the defaults.
 <ul>
 <li><code>$GOROOT</code>
 <p>
-The root of the Go tree, often <code>$HOME/go1.X</code>.
+The root of the Go tree, often <code>$HOME/go</code>.
 Its value is built into the tree when it is compiled, and
 defaults to the parent of the directory where <code>all.bash</code> was run.
 There is no need to set this unless you want to switch between multiple
@@ -449,7 +443,7 @@ The value assumed by installed binaries and scripts when
 <code>$GOROOT</code> is not set explicitly.
 It defaults to the value of <code>$GOROOT</code>.
 If you want to build the Go tree in one location
-but move it elsewhere after the build, set
+but move it elsewhere after the build, set 
 <code>$GOROOT_FINAL</code> to the eventual location.
 </p>
 
@@ -469,7 +463,6 @@ Choices for <code>$GOARCH</code> are
 <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), and <code>mips64</code> (MIPS 64-bit, big-endian).
-<code>mipsle</code> (MIPS 32-bit, little-endian), and <code>mips</code> (MIPS 32-bit, big-endian).
 The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <table cellpadding="0">
 <tr>
@@ -521,12 +514,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>linux</code></td> <td><code>ppc64le</code></td>
 </tr>
 <tr>
-<td></td><td><code>linux</code></td> <td><code>mips</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mipsle</code></td>
-</tr>
-<tr>
 <td></td><td><code>linux</code></td> <td><code>mips64</code></td>
 </tr>
 <tr>
@@ -579,7 +566,7 @@ architecture.
 Valid choices are the same as for <code>$GOOS</code> and
 <code>$GOARCH</code>, listed above.
 The specified values must be compatible with the local system.
-For example, you should not set <code>$GOHOSTARCH</code> to
+For example, you should not set <code>$GOHOSTARCH</code> to 
 <code>arm</code> on an x86 system.
 </p>
 
@@ -640,12 +627,12 @@ not <code>amd64</code>.
 <p>
 If you choose to override the defaults,
 set these variables in your shell profile (<code>$HOME/.bashrc</code>,
-<code>$HOME/.profile</code>, or equivalent). The settings might look
+<code>$HOME/.profile</code>, or equivalent). The settings might look 
 something like this:
 </p>
 
 <pre>
-export GOROOT=$HOME/go1.X
+export GOROOT=$HOME/go
 export GOARCH=amd64
 export GOOS=linux
 </pre>

doc/install.html

@@ -47,8 +47,8 @@ If your OS or architecture is not on the list, you may be able to
 <th align="center">Notes</th>
 </tr>
 <tr><td colspan="3"><hr></td></tr>
-<tr><td>FreeBSD 8-STABLE or later</td> <td>amd64, 386</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
-<tr><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm, s390x, ppc64le</td> <td>CentOS/RHEL 5.x not supported</td></tr>
+<tr><td>FreeBSD 8-STABLE or later</td> <td>amd64</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
+<tr><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm</td> <td>CentOS/RHEL 5.x not supported</td></tr>
 <tr><td>Mac OS X 10.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 or later</td> <td>amd64, 386</td> <td>use MinGW gcc<sup>&#8224;</sup>. No need for cygwin or msys.</td></tr>
 </table>
@@ -117,12 +117,12 @@ to point to the directory in which it was installed.
 </p>
 
 <p>
-For example, if you installed Go to your home directory you should add
-commands like the following to <code>$HOME/.profile</code>:
+For example, if you installed Go to your home directory you should add the
+following commands to <code>$HOME/.profile</code>:
 </p>
 
 <pre>
-export GOROOT=$HOME/go1.X
+export GOROOT=$HOME/go
 export PATH=$PATH:$GOROOT/bin
 </pre>
 
@@ -219,16 +219,37 @@ and building a simple program, as follows.
 </p>
 
 <p>
-Create your <a href="code.html#Workspaces">workspace</a> directory,
-<code class="testUnix">$HOME/go</code><code class="testWindows">%USERPROFILE%\go</code>.
-(If you'd like to use a different directory,
-you will need to set the <code>GOPATH</code> environment variable;
-see <a href="code.html#Workspaces">How to Write Go Code</a> for details.)
+Create a directory to contain your <a href="code.html#Workspaces">workspace</a>,
+<code class="testUnix">$HOME/work</code>
+<code class="testWindows" style="display: none">C:\work</code>
+for example, and set the <code>GOPATH</code> environment
+variable to point to that location.
+</p>
+
+<pre class="testUnix">
+$ <b>export GOPATH=$HOME/work</b>
+</pre>
+
+<pre class="testWindows" style="display: none">
+C:\&gt; <b>set GOPATH=C:\work</b>
+</pre>
+
+<p>
+<span class="testUnix">
+You should put the above command in your shell startup script
+(<code>$HOME/.profile</code> for example).
+</span>
+<span class="testWindows">
+On Windows, follow the <a href="#windows_env">instructions above</a> to set the
+<code>GOPATH</code> environment variable on your system.
+</span>
 </p>
 
 <p>
-Next, make the directory <code>src/hello</code> inside your workspace,
-and in that directory create a file named <code>hello.go</code> that looks like:
+Next, make the directories <code>src/github.com/user/hello</code> inside your
+workspace (if you use GitHub, substitute your user name for <code>user</code>),
+and inside the <code>hello</code> directory create a file named <code>hello.go</code>
+with the following contents:
 </p>
 
 <pre>
@@ -242,33 +263,30 @@ func main() {
 </pre>
 
 <p>
-Then build it with the <code>go</code> tool:
+Then compile it with the <code>go</code> tool:
 </p>
 
 <pre class="testUnix">
-$ <b>cd $HOME/go/src/hello
-$ <b>go build</b>
+$ <b>go install github.com/user/hello</b>
 </pre>
 
 <pre class="testWindows" style="display: none">
-C:\&gt; <b>cd %USERPROFILE%\go\src\hello<b>
-C:\Users\Gopher\go\src\hello&gt; <b>go build</b>
+C:\&gt; <b>go install github.com/user/hello</b>
 </pre>
 
 <p>
-The command above will build an executable named
-<code class="testUnix">hello</code><code class="testWindows">hello.exe</code>
-in the directory alongside your source code.
-Execute it to see the greeting:
+The command above will put an executable command named <code>hello</code> 
+(or <code>hello.exe</code>) inside the <code>bin</code> directory of your workspace.
+Execute the command to see the greeting:
 </p>
 
 <pre class="testUnix">
-$ <b>./hello</b>
+$ <b>$GOPATH/bin/hello</b>
 hello, world
 </pre>
 
 <pre class="testWindows" style="display: none">
-C:\Users\Gopher\go\src\hello&gt; <b>hello</b>
+C:\&gt; <b>%GOPATH%\bin\hello</b>
 hello, world
 </pre>
 
@@ -276,12 +294,6 @@ hello, world
 If you see the "hello, world" message then your Go installation is working.
 </p>
 
-<p>
-You can run <code>go</code> <code>install</code> to install the binary into
-your workspace's <code>bin</code> directory
-or <code>go</code> <code>clean</code> to remove it.
-</p>
-
 <p>
 Before rushing off to write Go code please read the
 <a href="/doc/code.html">How to Write Go Code</a> document,

doc/progs/json1.go

@@ -28,7 +28,7 @@ func Encode() {
 
 	expected := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
 	if !reflect.DeepEqual(b, expected) {
-		log.Panicf("Error marshaling %q, expected %q, got %q.", m, expected, b)
+		log.Panicf("Error marshalling %q, expected %q, got %q.", m, expected, b)
 	}
 
 }
@@ -49,7 +49,7 @@ func Decode() {
 	}
 
 	if !reflect.DeepEqual(m, expected) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q.", b, expected, m)
 	}
 
 	m = Message{
@@ -77,7 +77,7 @@ func PartialDecode() {
 	}
 
 	if !reflect.DeepEqual(expected, m) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q.", b, expected, m)
 	}
 }
 

doc/progs/json3.go

@@ -33,7 +33,7 @@ func Decode() {
 	}
 
 	if !reflect.DeepEqual(f, expected) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, f)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q", b, expected, f)
 	}
 
 	f = map[string]interface{}{

doc/progs/json4.go

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

misc/cgo/errors/ptr.go

@@ -322,27 +322,6 @@ var ptrTests = []ptrTest{
 		body: `p := &C.s{}; defer C.f(p); p.p = new(C.int)`,
 		fail: true,
 	},
-	{
-		// Check a pointer to a union if the union has any
-		// pointer fields.
-		name:    "union1",
-		c:       `typedef union { char **p; unsigned long i; } u; void f(u *pu) {}`,
-		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
-		fail:    true,
-	},
-	{
-		// Don't check a pointer to a union if the union does
-		// not have any pointer fields.
-		// Like ptrdata1 above, the uintptr represents an
-		// integer that happens to have the same
-		// representation as a pointer.
-		name:    "union2",
-		c:       `typedef union { unsigned long i; } u; void f(u *pu) {}`,
-		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
-		fail:    false,
-	},
 }
 
 func main() {

misc/cgo/test/cgo_test.go

@@ -74,7 +74,5 @@ func Test8756(t *testing.T)                  { test8756(t) }
 func Test17065(t *testing.T)                 { test17065(t) }
 func TestThreadLock(t *testing.T)            { testThreadLockFunc(t) }
 func TestCheckConst(t *testing.T)            { testCheckConst(t) }
-func Test17537(t *testing.T)                 { test17537(t) }
-func Test18126(t *testing.T)                 { test18126(t) }
 
 func BenchmarkCgoCall(b *testing.B) { benchCgoCall(b) }

misc/cgo/test/cgo_unix_test.go

@@ -10,4 +10,3 @@ import "testing"
 
 func TestSigaltstack(t *testing.T) { testSigaltstack(t) }
 func TestSigprocmask(t *testing.T) { testSigprocmask(t) }
-func Test18146(t *testing.T)       { test18146(t) }

misc/cgo/test/issue17537.go

@@ -1,58 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 17537.  The void* cast introduced by cgo to avoid problems
-// with const/volatile qualifiers breaks C preprocessor macros that
-// emulate functions.
-
-package cgotest
-
-/*
-#include <stdlib.h>
-
-typedef struct {
-	int i;
-} S17537;
-
-int I17537(S17537 *p);
-
-#define I17537(p) ((p)->i)
-
-// Calling this function used to fail without the cast.
-const int F17537(const char **p) {
-	return **p;
-}
-
-// Calling this function used to trigger an error from the C compiler
-// (issue 18298).
-void F18298(const void *const *p) {
-}
-
-// Test that conversions between typedefs work as they used to.
-typedef const void *T18298_1;
-struct S18298 { int i; };
-typedef const struct S18298 *T18298_2;
-void G18298(T18298_1 t) {
-}
-*/
-import "C"
-
-import "testing"
-
-func test17537(t *testing.T) {
-	v := C.S17537{i: 17537}
-	if got, want := C.I17537(&v), C.int(17537); got != want {
-		t.Errorf("got %d, want %d", got, want)
-	}
-
-	p := (*C.char)(C.malloc(1))
-	*p = 17
-	if got, want := C.F17537(&p), C.int(17); got != want {
-		t.Errorf("got %d, want %d", got, want)
-	}
-
-	C.F18298(nil)
-	var v18298 C.T18298_2
-	C.G18298(C.T18298_1(v18298))
-}

misc/cgo/test/issue18126.go

@@ -1,26 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 18126: cgo check of void function returning errno.
-
-package cgotest
-
-/*
-#include <stdlib.h>
-
-void Issue18126C(void **p) {
-}
-*/
-import "C"
-
-import (
-	"testing"
-)
-
-func test18126(t *testing.T) {
-	p := C.malloc(1)
-	_, err := C.Issue18126C(&p)
-	C.free(p)
-	_ = err
-}

misc/cgo/test/issue18146.go

@@ -1,103 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !windows
-
-// Issue 18146: pthread_create failure during syscall.Exec.
-
-package cgotest
-
-import "C"
-
-import (
-	"bytes"
-	"crypto/md5"
-	"os"
-	"os/exec"
-	"runtime"
-	"syscall"
-	"testing"
-	"time"
-)
-
-func test18146(t *testing.T) {
-	if runtime.GOOS == "darwin" {
-		t.Skipf("skipping flaky test on %s; see golang.org/issue/18202", runtime.GOOS)
-	}
-
-	if runtime.GOARCH == "mips" || runtime.GOARCH == "mips64" {
-		t.Skipf("skipping on %s", runtime.GOARCH)
-	}
-
-	attempts := 1000
-	threads := 4
-
-	if testing.Short() {
-		attempts = 100
-	}
-
-	if os.Getenv("test18146") == "exec" {
-		runtime.GOMAXPROCS(1)
-		for n := threads; n > 0; n-- {
-			go func() {
-				for {
-					_ = md5.Sum([]byte("Hello, !"))
-				}
-			}()
-		}
-		runtime.GOMAXPROCS(threads)
-		argv := append(os.Args, "-test.run=NoSuchTestExists")
-		if err := syscall.Exec(os.Args[0], argv, nil); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	var cmds []*exec.Cmd
-	defer func() {
-		for _, cmd := range cmds {
-			cmd.Process.Kill()
-		}
-	}()
-
-	args := append(append([]string(nil), os.Args[1:]...), "-test.run=Test18146")
-	for n := attempts; n > 0; n-- {
-		cmd := exec.Command(os.Args[0], args...)
-		cmd.Env = append(os.Environ(), "test18146=exec")
-		buf := bytes.NewBuffer(nil)
-		cmd.Stdout = buf
-		cmd.Stderr = buf
-		if err := cmd.Start(); err != nil {
-			// We are starting so many processes that on
-			// some systems (problem seen on Darwin,
-			// Dragonfly, OpenBSD) the fork call will fail
-			// with EAGAIN.
-			if pe, ok := err.(*os.PathError); ok {
-				err = pe.Err
-			}
-			if se, ok := err.(syscall.Errno); ok && (se == syscall.EAGAIN || se == syscall.EMFILE) {
-				time.Sleep(time.Millisecond)
-				continue
-			}
-
-			t.Error(err)
-			return
-		}
-		cmds = append(cmds, cmd)
-	}
-
-	failures := 0
-	for _, cmd := range cmds {
-		err := cmd.Wait()
-		if err == nil {
-			continue
-		}
-
-		t.Errorf("syscall.Exec failed: %v\n%s", err, cmd.Stdout)
-		failures++
-	}
-
-	if failures > 0 {
-		t.Logf("Failed %v of %v attempts.", failures, len(cmds))
-	}
-}

misc/cgo/test/issue7978.go

@@ -88,20 +88,9 @@ func issue7978wait(store uint32, wait uint32) {
 
 //export issue7978cb
 func issue7978cb() {
-	// Force a stack growth from the callback to put extra
-	// pressure on the runtime. See issue #17785.
-	growStack(64)
 	issue7978wait(3, 4)
 }
 
-func growStack(n int) int {
-	var buf [128]int
-	if n == 0 {
-		return 0
-	}
-	return buf[growStack(n-1)]
-}
-
 func issue7978go() {
 	C.issue7978c((*C.uint32_t)(&issue7978sync))
 	issue7978wait(7, 8)

misc/cgo/test/issue9400/asm_mipsx.s

@@ -1,31 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build mips mipsle
-// +build !gccgo
-
-#include "textflag.h"
-
-TEXT ·RewindAndSetgid(SB),NOSPLIT,$-4-0
-	// Rewind stack pointer so anything that happens on the stack
-	// will clobber the test pattern created by the caller
-	ADDU	$(1024*8), R29
-
-	// Ask signaller to setgid
-	MOVW	$1, R1
-	SYNC
-	MOVW	R1, ·Baton(SB)
-	SYNC
-
-	// Wait for setgid completion
-loop:
-	SYNC
-	MOVW	·Baton(SB), R1
-	OR	R2, R2, R2	// hint that we're in a spin loop
-	BNE	R1, loop
-	SYNC
-
-	// Restore stack
-	ADDU	$(-1024*8), R29
-	RET

misc/cgo/testcarchive/main2.c

@@ -112,7 +112,6 @@ int main(int argc, char** argv) {
 	int verbose;
 	sigset_t mask;
 	int i;
-	struct timespec ts;
 
 	verbose = argc > 1;
 	setvbuf(stdout, NULL, _IONBF, 0);
@@ -162,11 +161,11 @@ int main(int argc, char** argv) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (!sigioSeen) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}

misc/cgo/testcarchive/main3.c

@@ -9,7 +9,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <sched.h>
 
 #include "libgo3.h"
@@ -29,7 +28,6 @@ int main(int argc, char** argv) {
 	int verbose;
 	struct sigaction sa;
 	int i;
-	struct timespec ts;
 
 	verbose = argc > 2;
 	setvbuf(stdout, NULL, _IONBF, 0);
@@ -66,11 +64,11 @@ int main(int argc, char** argv) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (!sigioSeen) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}
@@ -140,11 +138,11 @@ int main(int argc, char** argv) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (!sigioSeen) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}

misc/cgo/testcarchive/main4.c

@@ -8,7 +8,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <sched.h>
 #include <pthread.h>
 
@@ -49,7 +48,6 @@ static void* thread1(void* arg __attribute__ ((unused))) {
 	stack_t ss;
 	int i;
 	stack_t nss;
-	struct timespec ts;
 
 	// Set up an alternate signal stack for this thread.
 	memset(&ss, 0, sizeof ss);
@@ -75,11 +73,11 @@ static void* thread1(void* arg __attribute__ ((unused))) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (SIGIOCount() == 0) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}
@@ -107,7 +105,6 @@ static void* thread2(void* arg __attribute__ ((unused))) {
 	int i;
 	int oldcount;
 	pthread_t tid;
-	struct timespec ts;
 	stack_t nss;
 
 	// Set up an alternate signal stack for this thread.
@@ -132,11 +129,11 @@ static void* thread2(void* arg __attribute__ ((unused))) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (SIGIOCount() == oldcount) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}

misc/cgo/testcshared/main4.c

@@ -77,7 +77,6 @@ int main(int argc, char** argv) {
 	void (*fn)(void);
 	sigset_t mask;
 	int i;
-	struct timespec ts;
 
 	verbose = argc > 2;
 	setvbuf(stdout, NULL, _IONBF, 0);
@@ -167,11 +166,11 @@ int main(int argc, char** argv) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (!sigioSeen) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}

misc/cgo/testcshared/main5.c

@@ -10,7 +10,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <sched.h>
 #include <dlfcn.h>
 
@@ -32,7 +31,6 @@ int main(int argc, char** argv) {
 	void (*fn1)(void);
 	int (*sawSIGIO)(void);
 	int i;
-	struct timespec ts;
 
 	verbose = argc > 2;
 	setvbuf(stdout, NULL, _IONBF, 0);
@@ -79,11 +77,11 @@ int main(int argc, char** argv) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (!sigioSeen) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}
@@ -184,11 +182,11 @@ int main(int argc, char** argv) {
 	// Wait until the signal has been delivered.
 	i = 0;
 	while (!sigioSeen) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 1000000;
-		nanosleep(&ts, NULL);
+		if (sched_yield() < 0) {
+			perror("sched_yield");
+		}
 		i++;
-		if (i > 5000) {
+		if (i > 100000) {
 			fprintf(stderr, "looping too long waiting for signal\n");
 			exit(EXIT_FAILURE);
 		}

misc/cgo/testcshared/test.bash

@@ -105,7 +105,7 @@ status=0
 
 # test0: exported symbols in shared lib are accessible.
 # TODO(iant): using _shared here shouldn't really be necessary.
-$(go env CC) ${GOGCCFLAGS} -I ${installdir} -o testp main0.c ./libgo.$libext
+$(go env CC) ${GOGCCFLAGS} -I ${installdir} -o testp main0.c libgo.$libext
 binpush testp
 
 output=$(run LD_LIBRARY_PATH=. ./testp)

misc/cgo/testplugin/altpath/src/common/common.go

@@ -1,11 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package common
-
-var X int
-
-func init() {
-	X = 4
-}

misc/cgo/testplugin/altpath/src/plugin-mismatch/main.go

@@ -1,17 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// // No C code required.
-import "C"
-
-// The common package imported here does not match the common package
-// imported by plugin1. A program that attempts to load plugin1 and
-// plugin-mismatch should produce an error.
-import "common"
-
-func ReadCommonX() int {
-	return common.X
-}

misc/cgo/testplugin/src/host/host.go

@@ -9,7 +9,6 @@ import (
 	"log"
 	"path/filepath"
 	"plugin"
-	"strings"
 
 	"common"
 )
@@ -18,35 +17,6 @@ func init() {
 	common.X *= 5
 }
 
-// testUnnamed tests that two plugins built with .go files passed on
-// the command line do not have overlapping symbols. That is,
-// unnamed1.so/FuncInt and unnamed2.so/FuncInt should be distinct functions.
-func testUnnamed() {
-	p, err := plugin.Open("unnamed1.so")
-	if err != nil {
-		log.Fatalf(`plugin.Open("unnamed1.so"): %v`, err)
-	}
-	fn, err := p.Lookup("FuncInt")
-	if err != nil {
-		log.Fatalf(`unnamed1.so: Lookup("FuncInt") failed: %v`, err)
-	}
-	if got, want := fn.(func() int)(), 1; got != want {
-		log.Fatalf("unnamed1.so: FuncInt()=%d, want %d", got, want)
-	}
-
-	p, err = plugin.Open("unnamed2.so")
-	if err != nil {
-		log.Fatalf(`plugin.Open("unnamed2.so"): %v`, err)
-	}
-	fn, err = p.Lookup("FuncInt")
-	if err != nil {
-		log.Fatalf(`unnamed2.so: Lookup("FuncInt") failed: %v`, err)
-	}
-	if got, want := fn.(func() int)(), 2; got != want {
-		log.Fatalf("unnamed2.so: FuncInt()=%d, want %d", got, want)
-	}
-}
-
 func main() {
 	if got, want := common.X, 3*5; got != want {
 		log.Fatalf("before plugin load common.X=%d, want %d", got, want)
@@ -134,15 +104,5 @@ func main() {
 		log.Fatalf("after loading plugin2, common.X=%d, want %d", got, want)
 	}
 
-	_, err = plugin.Open("plugin-mismatch.so")
-	if err == nil {
-		log.Fatal(`plugin.Open("plugin-mismatch.so"): should have failed`)
-	}
-	if s := err.Error(); !strings.Contains(s, "different version") {
-		log.Fatalf(`plugin.Open("plugin-mismatch.so"): error does not mention "different version": %v`, s)
-	}
-
-	testUnnamed()
-
 	fmt.Println("PASS")
 }

misc/cgo/testplugin/src/plugin1/plugin1.go

@@ -9,10 +9,7 @@ import "C"
 
 import "common"
 
-func F() int {
-	_ = make([]byte, 1<<21) // trigger stack unwind, Issue #18190.
-	return 3
-}
+func F() int { return 3 }
 
 func ReadCommonX() int {
 	return common.X
@@ -20,17 +17,9 @@ func ReadCommonX() int {
 
 var Seven int
 
-func call(fn func()) {
-	fn()
-}
-
-func g() {
-	common.X *= Seven
-}
-
 func init() {
 	Seven = 7
-	call(g)
+	common.X *= Seven
 }
 
 func main() {

misc/cgo/testplugin/src/plugin2/plugin2.go

@@ -4,21 +4,12 @@
 
 package main
 
-//#include <errno.h>
-//#include <string.h>
+// // No C code required.
 import "C"
 
-// #include
-// void cfunc() {} // uses cgo_topofstack
-
-import (
-	"common"
-	"strings"
-)
+import "common"
 
 func init() {
-	_ = strings.NewReplacer() // trigger stack unwind, Issue #18190.
-	C.strerror(C.EIO)         // uses cgo_topofstack
 	common.X = 2
 }
 

misc/cgo/testplugin/test.bash

@@ -15,8 +15,7 @@ goos=$(go env GOOS)
 goarch=$(go env GOARCH)
 
 function cleanup() {
-	rm -f plugin*.so unnamed*.so
-	rm -rf host pkg sub
+	rm -rf plugin1.so host pkg sub
 }
 trap cleanup EXIT
 
@@ -25,10 +24,7 @@ mkdir sub
 
 GOPATH=$(pwd) go build -buildmode=plugin plugin1
 GOPATH=$(pwd) go build -buildmode=plugin plugin2
-GOPATH=$(pwd)/altpath go build -buildmode=plugin plugin-mismatch
 GOPATH=$(pwd) go build -buildmode=plugin -o=sub/plugin1.so sub/plugin1
-GOPATH=$(pwd) go build -buildmode=plugin unnamed1.go
-GOPATH=$(pwd) go build -buildmode=plugin unnamed2.go
 GOPATH=$(pwd) go build host
 
 LD_LIBRARY_PATH=$(pwd) ./host

misc/cgo/testplugin/unnamed1.go

@@ -1,12 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// // No C code required.
-import "C"
-
-func FuncInt() int { return 1 }
-
-func main() {}

misc/cgo/testplugin/unnamed2.go

@@ -1,12 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// // No C code required.
-import "C"
-
-func FuncInt() int { return 2 }
-
-func main() {}

misc/cgo/testsanitizers/test.bash

@@ -144,8 +144,6 @@ if test "$tsan" = "yes"; then
     testtsan tsan2.go
     testtsan tsan3.go
     testtsan tsan4.go
-    testtsan tsan8.go
-    testtsan tsan9.go
 
     # These tests are only reliable using clang or GCC version 7 or later.
     # Otherwise runtime/cgo/libcgo.h can't tell whether TSAN is in use.

misc/cgo/testsanitizers/tsan8.go

@@ -1,60 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// This program failed when run under the C/C++ ThreadSanitizer.  The TSAN
-// sigaction function interceptor returned SIG_DFL instead of the Go runtime's
-// handler in registerSegvForwarder.
-
-/*
-#cgo CFLAGS: -fsanitize=thread
-#cgo LDFLAGS: -fsanitize=thread
-
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-struct sigaction prev_sa;
-
-void forwardSignal(int signo, siginfo_t *info, void *context) {
-	// One of sa_sigaction and/or sa_handler
-	if ((prev_sa.sa_flags&SA_SIGINFO) != 0) {
-		prev_sa.sa_sigaction(signo, info, context);
-		return;
-	}
-	if (prev_sa.sa_handler != SIG_IGN && prev_sa.sa_handler != SIG_DFL) {
-		prev_sa.sa_handler(signo);
-		return;
-	}
-
-	fprintf(stderr, "No Go handler to forward to!\n");
-	abort();
-}
-
-void registerSegvFowarder() {
-	struct sigaction sa;
-	memset(&sa, 0, sizeof(sa));
-	sigemptyset(&sa.sa_mask);
-	sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
-	sa.sa_sigaction = forwardSignal;
-
-	if (sigaction(SIGSEGV, &sa, &prev_sa) != 0) {
-		perror("failed to register SEGV forwarder");
-		exit(EXIT_FAILURE);
-	}
-}
-*/
-import "C"
-
-func main() {
-	C.registerSegvFowarder()
-
-	defer func() {
-		recover()
-	}()
-	var nilp *int
-	*nilp = 42
-}

misc/cgo/testsanitizers/tsan9.go

@@ -1,60 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// This program failed when run under the C/C++ ThreadSanitizer. The
-// TSAN library was not keeping track of whether signals should be
-// delivered on the alternate signal stack.
-
-/*
-#cgo CFLAGS: -g -fsanitize=thread
-#cgo LDFLAGS: -g -fsanitize=thread
-
-#include <stdlib.h>
-#include <sys/time.h>
-
-void spin() {
-	size_t n;
-	struct timeval tvstart, tvnow;
-	int diff;
-
-	gettimeofday(&tvstart, NULL);
-	for (n = 0; n < 1<<20; n++) {
-		free(malloc(n));
-		gettimeofday(&tvnow, NULL);
-		diff = (tvnow.tv_sec - tvstart.tv_sec) * 1000 * 1000 + (tvnow.tv_usec - tvstart.tv_usec);
-
-		// Profile frequency is 100Hz so we should definitely
-		// get a signal in 50 milliseconds.
-		if (diff > 50 * 1000) {
-			break;
-		}
-	}
-}
-*/
-import "C"
-
-import (
-	"io/ioutil"
-	"runtime/pprof"
-	"time"
-)
-
-func goSpin() {
-	start := time.Now()
-	for n := 0; n < 1<<20; n++ {
-		_ = make([]byte, n)
-		if time.Since(start) > 50*time.Millisecond {
-			break
-		}
-	}
-}
-
-func main() {
-	pprof.StartCPUProfile(ioutil.Discard)
-	go C.spin()
-	goSpin()
-	pprof.StopCPUProfile()
-}

misc/cgo/testshared/src/exe/exe.go

@@ -7,11 +7,6 @@ import (
 	"runtime"
 )
 
-// Having a function declared in the main package triggered
-// golang.org/issue/18250
-func DeclaredInMain() {
-}
-
 func main() {
 	defer depBase.ImplementedInAsm()
 	// This code below causes various go.itab.* symbols to be generated in

src/archive/zip/writer.go

@@ -22,10 +22,6 @@ type Writer struct {
 	last        *fileWriter
 	closed      bool
 	compressors map[uint16]Compressor
-
-	// testHookCloseSizeOffset if non-nil is called with the size
-	// of offset of the central directory at Close.
-	testHookCloseSizeOffset func(size, offset uint64)
 }
 
 type header struct {
@@ -144,11 +140,7 @@ func (w *Writer) Close() error {
 	size := uint64(end - start)
 	offset := uint64(start)
 
-	if f := w.testHookCloseSizeOffset; f != nil {
-		f(size, offset)
-	}
-
-	if records >= uint16max || size >= uint32max || offset >= uint32max {
+	if records > uint16max || size > uint32max || offset > uint32max {
 		var buf [directory64EndLen + directory64LocLen]byte
 		b := writeBuf(buf[:])
 

src/archive/zip/zip_test.go

@@ -8,10 +8,8 @@ package zip
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"hash"
-	"internal/race"
 	"internal/testenv"
 	"io"
 	"io/ioutil"
@@ -273,7 +271,6 @@ func TestZip64(t *testing.T) {
 	if testing.Short() {
 		t.Skip("slow test; skipping")
 	}
-	t.Parallel()
 	const size = 1 << 32 // before the "END\n" part
 	buf := testZip64(t, size)
 	testZip64DirectoryRecordLength(buf, t)
@@ -283,7 +280,6 @@ func TestZip64EdgeCase(t *testing.T) {
 	if testing.Short() {
 		t.Skip("slow test; skipping")
 	}
-	t.Parallel()
 	// Test a zip file with uncompressed size 0xFFFFFFFF.
 	// That's the magic marker for a 64-bit file, so even though
 	// it fits in a 32-bit field we must use the 64-bit field.
@@ -294,256 +290,6 @@ func TestZip64EdgeCase(t *testing.T) {
 	testZip64DirectoryRecordLength(buf, t)
 }
 
-// Tests that we generate a zip64 file if the the directory at offset
-// 0xFFFFFFFF, but not before.
-func TestZip64DirectoryOffset(t *testing.T) {
-	if testing.Short() && race.Enabled {
-		t.Skip("skipping in short mode")
-	}
-	t.Parallel()
-	const filename = "huge.txt"
-	gen := func(wantOff uint64) func(*Writer) {
-		return func(w *Writer) {
-			w.testHookCloseSizeOffset = func(size, off uint64) {
-				if off != wantOff {
-					t.Errorf("central directory offset = %d (%x); want %d", off, off, wantOff)
-				}
-			}
-			f, err := w.CreateHeader(&FileHeader{
-				Name:   filename,
-				Method: Store,
-			})
-			if err != nil {
-				t.Fatal(err)
-			}
-			f.(*fileWriter).crc32 = fakeHash32{}
-			size := wantOff - fileHeaderLen - uint64(len(filename)) - dataDescriptorLen
-			if _, err := io.CopyN(f, zeros{}, int64(size)); err != nil {
-				t.Fatal(err)
-			}
-			if err := w.Close(); err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-	t.Run("uint32max-2_NoZip64", func(t *testing.T) {
-		t.Parallel()
-		if generatesZip64(t, gen(0xfffffffe)) {
-			t.Error("unexpected zip64")
-		}
-	})
-	t.Run("uint32max-1_Zip64", func(t *testing.T) {
-		t.Parallel()
-		if !generatesZip64(t, gen(0xffffffff)) {
-			t.Error("expected zip64")
-		}
-	})
-}
-
-// At 16k records, we need to generate a zip64 file.
-func TestZip64ManyRecords(t *testing.T) {
-	if testing.Short() && race.Enabled {
-		t.Skip("skipping in short mode")
-	}
-	t.Parallel()
-	gen := func(numRec int) func(*Writer) {
-		return func(w *Writer) {
-			for i := 0; i < numRec; i++ {
-				_, err := w.CreateHeader(&FileHeader{
-					Name:   "a.txt",
-					Method: Store,
-				})
-				if err != nil {
-					t.Fatal(err)
-				}
-			}
-			if err := w.Close(); err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-	// 16k-1 records shouldn't make a zip64:
-	t.Run("uint16max-1_NoZip64", func(t *testing.T) {
-		t.Parallel()
-		if generatesZip64(t, gen(0xfffe)) {
-			t.Error("unexpected zip64")
-		}
-	})
-	// 16k records should make a zip64:
-	t.Run("uint16max_Zip64", func(t *testing.T) {
-		t.Parallel()
-		if !generatesZip64(t, gen(0xffff)) {
-			t.Error("expected zip64")
-		}
-	})
-}
-
-// suffixSaver is an io.Writer & io.ReaderAt that remembers the last 0
-// to 'keep' bytes of data written to it. Call Suffix to get the
-// suffix bytes.
-type suffixSaver struct {
-	keep  int
-	buf   []byte
-	start int
-	size  int64
-}
-
-func (ss *suffixSaver) Size() int64 { return ss.size }
-
-var errDiscardedBytes = errors.New("ReadAt of discarded bytes")
-
-func (ss *suffixSaver) ReadAt(p []byte, off int64) (n int, err error) {
-	back := ss.size - off
-	if back > int64(ss.keep) {
-		return 0, errDiscardedBytes
-	}
-	suf := ss.Suffix()
-	n = copy(p, suf[len(suf)-int(back):])
-	if n != len(p) {
-		err = io.EOF
-	}
-	return
-}
-
-func (ss *suffixSaver) Suffix() []byte {
-	if len(ss.buf) < ss.keep {
-		return ss.buf
-	}
-	buf := make([]byte, ss.keep)
-	n := copy(buf, ss.buf[ss.start:])
-	copy(buf[n:], ss.buf[:])
-	return buf
-}
-
-func (ss *suffixSaver) Write(p []byte) (n int, err error) {
-	n = len(p)
-	ss.size += int64(len(p))
-	if len(ss.buf) < ss.keep {
-		space := ss.keep - len(ss.buf)
-		add := len(p)
-		if add > space {
-			add = space
-		}
-		ss.buf = append(ss.buf, p[:add]...)
-		p = p[add:]
-	}
-	for len(p) > 0 {
-		n := copy(ss.buf[ss.start:], p)
-		p = p[n:]
-		ss.start += n
-		if ss.start == ss.keep {
-			ss.start = 0
-		}
-	}
-	return
-}
-
-// generatesZip64 reports whether f wrote a zip64 file.
-// f is also responsible for closing w.
-func generatesZip64(t *testing.T, f func(w *Writer)) bool {
-	ss := &suffixSaver{keep: 10 << 20}
-	w := NewWriter(ss)
-	f(w)
-	return suffixIsZip64(t, ss)
-}
-
-type sizedReaderAt interface {
-	io.ReaderAt
-	Size() int64
-}
-
-func suffixIsZip64(t *testing.T, zip sizedReaderAt) bool {
-	d := make([]byte, 1024)
-	if _, err := zip.ReadAt(d, zip.Size()-int64(len(d))); err != nil {
-		t.Fatalf("ReadAt: %v", err)
-	}
-
-	sigOff := findSignatureInBlock(d)
-	if sigOff == -1 {
-		t.Errorf("failed to find signature in block")
-		return false
-	}
-
-	dirOff, err := findDirectory64End(zip, zip.Size()-int64(len(d))+int64(sigOff))
-	if err != nil {
-		t.Fatalf("findDirectory64End: %v", err)
-	}
-	if dirOff == -1 {
-		return false
-	}
-
-	d = make([]byte, directory64EndLen)
-	if _, err := zip.ReadAt(d, dirOff); err != nil {
-		t.Fatalf("ReadAt(off=%d): %v", dirOff, err)
-	}
-
-	b := readBuf(d)
-	if sig := b.uint32(); sig != directory64EndSignature {
-		return false
-	}
-
-	size := b.uint64()
-	if size != directory64EndLen-12 {
-		t.Errorf("expected length of %d, got %d", directory64EndLen-12, size)
-	}
-	return true
-}
-
-// Zip64 is required if the total size of the records is uint32max.
-func TestZip64LargeDirectory(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping in short mode")
-	}
-	t.Parallel()
-	// gen returns a func that writes a zip with a wantLen bytes
-	// of central directory.
-	gen := func(wantLen int64) func(*Writer) {
-		return func(w *Writer) {
-			w.testHookCloseSizeOffset = func(size, off uint64) {
-				if size != uint64(wantLen) {
-					t.Errorf("Close central directory size = %d; want %d", size, wantLen)
-				}
-			}
-
-			uint16string := strings.Repeat(".", uint16max)
-			remain := wantLen
-			for remain > 0 {
-				commentLen := int(uint16max) - directoryHeaderLen - 1
-				thisRecLen := directoryHeaderLen + int(uint16max) + commentLen
-				if int64(thisRecLen) > remain {
-					remove := thisRecLen - int(remain)
-					commentLen -= remove
-					thisRecLen -= remove
-				}
-				remain -= int64(thisRecLen)
-				f, err := w.CreateHeader(&FileHeader{
-					Name:    uint16string,
-					Comment: uint16string[:commentLen],
-				})
-				if err != nil {
-					t.Fatalf("CreateHeader: %v", err)
-				}
-				f.(*fileWriter).crc32 = fakeHash32{}
-			}
-			if err := w.Close(); err != nil {
-				t.Fatalf("Close: %v", err)
-			}
-		}
-	}
-	t.Run("uint32max-1_NoZip64", func(t *testing.T) {
-		t.Parallel()
-		if generatesZip64(t, gen(uint32max-1)) {
-			t.Error("unexpected zip64")
-		}
-	})
-	t.Run("uint32max_HasZip64", func(t *testing.T) {
-		t.Parallel()
-		if !generatesZip64(t, gen(uint32max)) {
-			t.Error("expected zip64")
-		}
-	})
-}
-
 func testZip64(t testing.TB, size int64) *rleBuffer {
 	const chunkSize = 1024
 	chunks := int(size / chunkSize)
@@ -632,8 +378,30 @@ func testZip64(t testing.TB, size int64) *rleBuffer {
 
 // Issue 9857
 func testZip64DirectoryRecordLength(buf *rleBuffer, t *testing.T) {
-	if !suffixIsZip64(t, buf) {
-		t.Fatal("not a zip64")
+	d := make([]byte, 1024)
+	if _, err := buf.ReadAt(d, buf.Size()-int64(len(d))); err != nil {
+		t.Fatal("read:", err)
+	}
+
+	sigOff := findSignatureInBlock(d)
+	dirOff, err := findDirectory64End(buf, buf.Size()-int64(len(d))+int64(sigOff))
+	if err != nil {
+		t.Fatal("findDirectory64End:", err)
+	}
+
+	d = make([]byte, directory64EndLen)
+	if _, err := buf.ReadAt(d, dirOff); err != nil {
+		t.Fatal("read:", err)
+	}
+
+	b := readBuf(d)
+	if sig := b.uint32(); sig != directory64EndSignature {
+		t.Fatalf("Expected directory64EndSignature (%d), got %d", directory64EndSignature, sig)
+	}
+
+	size := b.uint64()
+	if size != directory64EndLen-12 {
+		t.Fatalf("Expected length of %d, got %d", directory64EndLen-12, size)
 	}
 }
 
@@ -719,47 +487,3 @@ func BenchmarkZip64Test(b *testing.B) {
 		testZip64(b, 1<<26)
 	}
 }
-
-func TestSuffixSaver(t *testing.T) {
-	const keep = 10
-	ss := &suffixSaver{keep: keep}
-	ss.Write([]byte("abc"))
-	if got := string(ss.Suffix()); got != "abc" {
-		t.Errorf("got = %q; want abc", got)
-	}
-	ss.Write([]byte("defghijklmno"))
-	if got := string(ss.Suffix()); got != "fghijklmno" {
-		t.Errorf("got = %q; want fghijklmno", got)
-	}
-	if got, want := ss.Size(), int64(len("abc")+len("defghijklmno")); got != want {
-		t.Errorf("Size = %d; want %d", got, want)
-	}
-	buf := make([]byte, ss.Size())
-	for off := int64(0); off < ss.Size(); off++ {
-		for size := 1; size <= int(ss.Size()-off); size++ {
-			readBuf := buf[:size]
-			n, err := ss.ReadAt(readBuf, off)
-			if off < ss.Size()-keep {
-				if err != errDiscardedBytes {
-					t.Errorf("off %d, size %d = %v, %v (%q); want errDiscardedBytes", off, size, n, err, readBuf[:n])
-				}
-				continue
-			}
-			want := "abcdefghijklmno"[off : off+int64(size)]
-			got := string(readBuf[:n])
-			if err != nil || got != want {
-				t.Errorf("off %d, size %d = %v, %v (%q); want %q", off, size, n, err, got, want)
-			}
-		}
-	}
-
-}
-
-type zeros struct{}
-
-func (zeros) Read(p []byte) (int, error) {
-	for i := range p {
-		p[i] = 0
-	}
-	return len(p), nil
-}

src/cmd/api/run.go

@@ -26,7 +26,7 @@ func main() {
 	}
 
 	out, err := exec.Command("go", "tool", "api",
-		"-c", file("go1", "go1.1", "go1.2", "go1.3", "go1.4", "go1.5", "go1.6", "go1.7", "go1.8"),
+		"-c", file("go1", "go1.1", "go1.2", "go1.3", "go1.4", "go1.5", "go1.6", "go1.7"),
 		"-next", file("next"),
 		"-except", file("except")).CombinedOutput()
 	if err != nil {

src/cmd/asm/internal/arch/amd64.go

@@ -13,8 +13,8 @@ import (
 	"cmd/internal/obj/x86"
 )
 
-// IsAMD4OP reports whether the op (as defined by an amd64.A* constant) is
-// a 4-operand instruction.
+// IsAMD4OP reports whether the op (as defined by an ppc64.A* constant) is
+// The FMADD-like instructions behave similarly.
 func IsAMD4OP(op obj.As) bool {
 	switch op {
 	case x86.AVPERM2F128,

src/cmd/asm/internal/arch/s390x.go

@@ -110,8 +110,6 @@ func IsS390xWithIndex(op obj.As) bool {
 		return true
 	case s390x.AVLEG, s390x.AVLEF, s390x.AVLEH, s390x.AVLEB:
 		return true
-	case s390x.AVSTEG, s390x.AVSTEF, s390x.AVSTEH, s390x.AVSTEB:
-		return true
 	case s390x.AVPDI:
 		return true
 	}

src/cmd/asm/internal/asm/testdata/s390x.s

@@ -333,10 +333,7 @@ TEXT main·foo(SB),7,$16-0 // TEXT main.foo(SB), 7, $16-0
 	VLEF	$2, (R0), V31           // VLEF    (R0), $2, V31           // e7f000002803
 	VLEH	$3, (R12), V16          // VLEH    (R12), $3, V16          // e700c0003801
 	VLEB	$15, 4095(R9), V15      // VLEB    4095(R9), $15, V15      // e7f09ffff000
-	VSTEG	$1, V30, (R1)(R2*1)     // VSTEG   V30, $1, (R1)(R2*1)     // e7e21000180a
-	VSTEF	$3, V2, (R9)            // VSTEF   V2, $3, (R9)            // e7209000300b
-	VSTEH	$7, V31, (R2)           // VSTEH   V31, $7, (R2)           // e7f020007809
-	VSTEB	$15, V29, 4094(R12)     // VSTEB   V29, $15, 4094(R12)     // e7d0cffef808
+
 
 	RET
 

src/cmd/cgo/gcc.go

@@ -713,7 +713,15 @@ func (p *Package) rewriteCall(f *File, call *Call, name *Name) bool {
 			List: params,
 		},
 	}
-	if name.FuncType.Result != nil {
+	var fbody ast.Stmt
+	if name.FuncType.Result == nil {
+		fbody = &ast.ExprStmt{
+			X: fcall,
+		}
+	} else {
+		fbody = &ast.ReturnStmt{
+			Results: []ast.Expr{fcall},
+		}
 		rtype := p.rewriteUnsafe(name.FuncType.Result.Go)
 		if rtype != name.FuncType.Result.Go {
 			needsUnsafe = true
@@ -726,45 +734,6 @@ func (p *Package) rewriteCall(f *File, call *Call, name *Name) bool {
 			},
 		}
 	}
-
-	// There is a Ref pointing to the old call.Call.Fun.
-	for _, ref := range f.Ref {
-		if ref.Expr == &call.Call.Fun {
-			ref.Expr = &fcall.Fun
-
-			// If this call expects two results, we have to
-			// adjust the results of the function we generated.
-			if ref.Context == "call2" {
-				if ftype.Results == nil {
-					// An explicit void argument
-					// looks odd but it seems to
-					// be how cgo has worked historically.
-					ftype.Results = &ast.FieldList{
-						List: []*ast.Field{
-							&ast.Field{
-								Type: ast.NewIdent("_Ctype_void"),
-							},
-						},
-					}
-				}
-				ftype.Results.List = append(ftype.Results.List,
-					&ast.Field{
-						Type: ast.NewIdent("error"),
-					})
-			}
-		}
-	}
-
-	var fbody ast.Stmt
-	if ftype.Results == nil {
-		fbody = &ast.ExprStmt{
-			X: fcall,
-		}
-	} else {
-		fbody = &ast.ReturnStmt{
-			Results: []ast.Expr{fcall},
-		}
-	}
 	call.Call.Fun = &ast.FuncLit{
 		Type: ftype,
 		Body: &ast.BlockStmt{
@@ -774,6 +743,22 @@ func (p *Package) rewriteCall(f *File, call *Call, name *Name) bool {
 	call.Call.Lparen = token.NoPos
 	call.Call.Rparen = token.NoPos
 
+	// There is a Ref pointing to the old call.Call.Fun.
+	for _, ref := range f.Ref {
+		if ref.Expr == &call.Call.Fun {
+			ref.Expr = &fcall.Fun
+
+			// If this call expects two results, we have to
+			// adjust the results of the  function we generated.
+			if ref.Context == "call2" {
+				ftype.Results.List = append(ftype.Results.List,
+					&ast.Field{
+						Type: ast.NewIdent("error"),
+					})
+			}
+		}
+	}
+
 	return needsUnsafe
 }
 
@@ -817,11 +802,6 @@ func (p *Package) hasPointer(f *File, t ast.Expr, top bool) bool {
 		if !top {
 			return true
 		}
-		// Check whether this is a pointer to a C union (or class)
-		// type that contains a pointer.
-		if unionWithPointer[t.X] {
-			return true
-		}
 		return p.hasPointer(f, t.X, false)
 	case *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.ChanType:
 		return true
@@ -1210,8 +1190,6 @@ func (p *Package) gccMachine() []string {
 		return []string{"-m64"}
 	case "mips64", "mips64le":
 		return []string{"-mabi=64"}
-	case "mips", "mipsle":
-		return []string{"-mabi=32"}
 	}
 	return nil
 }
@@ -1440,10 +1418,6 @@ var tagGen int
 var typedef = make(map[string]*Type)
 var goIdent = make(map[string]*ast.Ident)
 
-// unionWithPointer is true for a Go type that represents a C union (or class)
-// that may contain a pointer. This is used for cgo pointer checking.
-var unionWithPointer = make(map[ast.Expr]bool)
-
 func (c *typeConv) Init(ptrSize, intSize int64) {
 	c.ptrSize = ptrSize
 	c.intSize = intSize
@@ -1493,19 +1467,6 @@ func base(dt dwarf.Type) dwarf.Type {
 	return dt
 }
 
-// unqual strips away qualifiers from a DWARF type.
-// In general we don't care about top-level qualifiers.
-func unqual(dt dwarf.Type) dwarf.Type {
-	for {
-		if d, ok := dt.(*dwarf.QualType); ok {
-			dt = d.Type
-		} else {
-			break
-		}
-	}
-	return dt
-}
-
 // Map from dwarf text names to aliases we use in package "C".
 var dwarfToName = map[string]string{
 	"long int":               "long",
@@ -1729,15 +1690,6 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		if _, ok := base(dt.Type).(*dwarf.VoidType); ok {
 			t.Go = c.goVoidPtr
 			t.C.Set("void*")
-			dq := dt.Type
-			for {
-				if d, ok := dq.(*dwarf.QualType); ok {
-					t.C.Set(d.Qual + " " + t.C.String())
-					dq = d.Type
-				} else {
-					break
-				}
-			}
 			break
 		}
 
@@ -1750,16 +1702,9 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		c.ptrs[dt.Type] = append(c.ptrs[dt.Type], t)
 
 	case *dwarf.QualType:
-		t1 := c.Type(dt.Type, pos)
-		t.Size = t1.Size
-		t.Align = t1.Align
-		t.Go = t1.Go
-		if unionWithPointer[t1.Go] {
-			unionWithPointer[t.Go] = true
-		}
-		t.EnumValues = nil
-		t.Typedef = ""
-		t.C.Set("%s "+dt.Qual, t1.C)
+		// Ignore qualifier.
+		t = c.Type(dt.Type, pos)
+		c.m[dtype] = t
 		return t
 
 	case *dwarf.StructType:
@@ -1791,9 +1736,6 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		switch dt.Kind {
 		case "class", "union":
 			t.Go = c.Opaque(t.Size)
-			if c.dwarfHasPointer(dt, pos) {
-				unionWithPointer[t.Go] = true
-			}
 			if t.C.Empty() {
 				t.C.Set("__typeof__(unsigned char[%d])", t.Size)
 			}
@@ -1836,9 +1778,6 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		goIdent[name.Name] = name
 		sub := c.Type(dt.Type, pos)
 		t.Go = name
-		if unionWithPointer[sub.Go] {
-			unionWithPointer[t.Go] = true
-		}
 		t.Size = sub.Size
 		t.Align = sub.Align
 		oldType := typedef[name.Name]
@@ -1969,7 +1908,7 @@ func isStructUnionClass(x ast.Expr) bool {
 // FuncArg returns a Go type with the same memory layout as
 // dtype when used as the type of a C function argument.
 func (c *typeConv) FuncArg(dtype dwarf.Type, pos token.Pos) *Type {
-	t := c.Type(unqual(dtype), pos)
+	t := c.Type(dtype, pos)
 	switch dt := dtype.(type) {
 	case *dwarf.ArrayType:
 		// Arrays are passed implicitly as pointers in C.
@@ -2033,7 +1972,7 @@ func (c *typeConv) FuncType(dtype *dwarf.FuncType, pos token.Pos) *FuncType {
 	if _, ok := dtype.ReturnType.(*dwarf.VoidType); ok {
 		gr = []*ast.Field{{Type: c.goVoid}}
 	} else if dtype.ReturnType != nil {
-		r = c.Type(unqual(dtype.ReturnType), pos)
+		r = c.Type(dtype.ReturnType, pos)
 		gr = []*ast.Field{{Type: r.Go}}
 	}
 	return &FuncType{
@@ -2220,44 +2159,6 @@ func (c *typeConv) Struct(dt *dwarf.StructType, pos token.Pos) (expr *ast.Struct
 	return
 }
 
-// dwarfHasPointer returns whether the DWARF type dt contains a pointer.
-func (c *typeConv) dwarfHasPointer(dt dwarf.Type, pos token.Pos) bool {
-	switch dt := dt.(type) {
-	default:
-		fatalf("%s: unexpected type: %s", lineno(pos), dt)
-		return false
-
-	case *dwarf.AddrType, *dwarf.BoolType, *dwarf.CharType, *dwarf.EnumType,
-		*dwarf.FloatType, *dwarf.ComplexType, *dwarf.FuncType,
-		*dwarf.IntType, *dwarf.UcharType, *dwarf.UintType, *dwarf.VoidType:
-
-		return false
-
-	case *dwarf.ArrayType:
-		return c.dwarfHasPointer(dt.Type, pos)
-
-	case *dwarf.PtrType:
-		return true
-
-	case *dwarf.QualType:
-		return c.dwarfHasPointer(dt.Type, pos)
-
-	case *dwarf.StructType:
-		for _, f := range dt.Field {
-			if c.dwarfHasPointer(f.Type, pos) {
-				return true
-			}
-		}
-		return false
-
-	case *dwarf.TypedefType:
-		if dt.Name == "_GoString_" || dt.Name == "_GoBytes_" {
-			return true
-		}
-		return c.dwarfHasPointer(dt.Type, pos)
-	}
-}
-
 func upper(s string) string {
 	if s == "" {
 		return ""

src/cmd/cgo/out.go

@@ -355,7 +355,11 @@ func (p *Package) structType(n *Name) (string, int64) {
 			fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
 			off += pad
 		}
-		fmt.Fprintf(&buf, "\t\t%s r;\n", t.C)
+		qual := ""
+		if c := t.C.String(); c[len(c)-1] == '*' {
+			qual = "const "
+		}
+		fmt.Fprintf(&buf, "\t\t%s%s r;\n", qual, t.C)
 		off += t.Size
 	}
 	if off%p.PtrSize != 0 {
@@ -616,10 +620,20 @@ func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
 		}
 	}
 	fmt.Fprintf(fgcc, "%s(", n.C)
-	for i := range n.FuncType.Params {
+	for i, t := range n.FuncType.Params {
 		if i > 0 {
 			fmt.Fprintf(fgcc, ", ")
 		}
+		// We know the type params are correct, because
+		// the Go equivalents had good type params.
+		// However, our version of the type omits the magic
+		// words const and volatile, which can provoke
+		// C compiler warnings. Silence them by casting
+		// all pointers to void*.  (Eventually that will produce
+		// other warnings.)
+		if c := t.C.String(); c[len(c)-1] == '*' {
+			fmt.Fprintf(fgcc, "(void*)")
+		}
 		fmt.Fprintf(fgcc, "a->p%d", i)
 	}
 	fmt.Fprintf(fgcc, ");\n")
@@ -679,10 +693,14 @@ func (p *Package) writeGccgoOutputFunc(fgcc *os.File, n *Name) {
 		}
 	}
 	fmt.Fprintf(fgcc, "%s(", n.C)
-	for i := range n.FuncType.Params {
+	for i, t := range n.FuncType.Params {
 		if i > 0 {
 			fmt.Fprintf(fgcc, ", ")
 		}
+		// Cast to void* to avoid warnings due to omitted qualifiers.
+		if c := t.C.String(); c[len(c)-1] == '*' {
+			fmt.Fprintf(fgcc, "(void*)")
+		}
 		fmt.Fprintf(fgcc, "p%d", i)
 	}
 	fmt.Fprintf(fgcc, ");\n")

src/cmd/compile/internal/gc/go.go

@@ -119,12 +119,8 @@ var linkobj string
 
 var bout *bio.Writer
 
-// nerrors is the number of compiler errors reported
-// since the last call to saveerrors.
 var nerrors int
 
-// nsavederrors is the total number of compiler errors
-// reported before the last call to saveerrors.
 var nsavederrors int
 
 var nsyntaxerrors int

src/cmd/compile/internal/gc/inl.go

@@ -107,12 +107,6 @@ func caninl(fn *Node) {
 		return
 	}
 
-	// If marked "go:cgo_unsafe_args", don't inline
-	if fn.Func.Pragma&CgoUnsafeArgs != 0 {
-		reason = "marked go:cgo_unsafe_args"
-		return
-	}
-
 	// If fn has no body (is defined outside of Go), cannot inline it.
 	if fn.Nbody.Len() == 0 {
 		reason = "no function body"
@@ -787,9 +781,10 @@ func mkinlcall1(n *Node, fn *Node, isddd bool) *Node {
 			as.Right = nodnil()
 			as.Right.Type = varargtype
 		} else {
-			varslicetype := typSlice(varargtype.Elem())
-			as.Right = nod(OCOMPLIT, nil, typenod(varslicetype))
+			vararrtype := typArray(varargtype.Elem(), int64(varargcount))
+			as.Right = nod(OCOMPLIT, nil, typenod(vararrtype))
 			as.Right.List.Set(varargs)
+			as.Right = nod(OSLICE, as.Right, nil)
 		}
 
 		as = typecheck(as, Etop)

src/cmd/compile/internal/gc/main.go

@@ -98,9 +98,6 @@ func supportsDynlink(arch *sys.Arch) bool {
 var timings Timings
 var benchfile string
 
-// Main parses flags and Go source files specified in the command-line
-// arguments, type-checks the parsed Go package, compiles functions to machine
-// code, and finally writes the compiled package definition to disk.
 func Main() {
 	timings.Start("fe", "init")
 
@@ -486,7 +483,6 @@ func Main() {
 		errorexit()
 	}
 
-	// Write object data to disk.
 	timings.Start("be", "dumpobj")
 	dumpobj()
 	if asmhdr != "" {

src/cmd/compile/internal/gc/noder.go

@@ -29,7 +29,7 @@ func parseFile(filename string) {
 
 	if !imported_unsafe {
 		for _, x := range p.linknames {
-			p.error(syntax.Error{Line: x, Msg: "//go:linkname only allowed in Go files that import \"unsafe\""})
+			p.error(syntax.Error{0, x, "//go:linkname only allowed in Go files that import \"unsafe\""})
 		}
 	}
 
@@ -1022,18 +1022,17 @@ func (p *noder) error(err error) {
 func (p *noder) pragma(pos, line int, text string) syntax.Pragma {
 	switch {
 	case strings.HasPrefix(text, "line "):
-		// Want to use LastIndexByte below but it's not defined in Go1.4 and bootstrap fails.
-		i := strings.LastIndex(text, ":") // look from right (Windows filenames may contain ':')
+		i := strings.IndexByte(text, ':')
 		if i < 0 {
 			break
 		}
 		n, err := strconv.Atoi(text[i+1:])
 		if err != nil {
-			// TODO: make this an error instead? it is almost certainly a bug.
+			// todo: make this an error instead? it is almost certainly a bug.
 			break
 		}
 		if n > 1e8 {
-			p.error(syntax.Error{Pos: pos, Line: line, Msg: "line number out of range"})
+			p.error(syntax.Error{pos, line, "line number out of range"})
 			errorexit()
 		}
 		if n <= 0 {
@@ -1049,7 +1048,7 @@ func (p *noder) pragma(pos, line int, text string) syntax.Pragma {
 
 		f := strings.Fields(text)
 		if len(f) != 3 {
-			p.error(syntax.Error{Pos: pos, Line: line, Msg: "usage: //go:linkname localname linkname"})
+			p.error(syntax.Error{pos, line, "usage: //go:linkname localname linkname"})
 			break
 		}
 		lookup(f[1]).Linkname = f[2]

src/cmd/compile/internal/gc/obj.go

@@ -354,12 +354,6 @@ func dsymptrOffLSym(s *obj.LSym, off int, x *obj.LSym, xoff int) int {
 	return off
 }
 
-func dsymptrWeakOffLSym(s *obj.LSym, off int, x *obj.LSym) int {
-	s.WriteWeakOff(Ctxt, int64(off), x, 0)
-	off += 4
-	return off
-}
-
 func gdata(nam *Node, nr *Node, wid int) {
 	if nam.Op != ONAME {
 		Fatalf("gdata nam op %v", nam.Op)

src/cmd/compile/internal/gc/pgen.go

@@ -380,9 +380,6 @@ func compile(fn *Node) {
 	if fn.Func.Wrapper {
 		ptxt.From3.Offset |= obj.WRAPPER
 	}
-	if fn.Func.NoFramePointer {
-		ptxt.From3.Offset |= obj.NOFRAME
-	}
 	if fn.Func.Needctxt {
 		ptxt.From3.Offset |= obj.NEEDCTXT
 	}
@@ -430,8 +427,9 @@ func compile(fn *Node) {
 			}
 			fallthrough
 		case PPARAM, PPARAMOUT:
-			// The symbol is excluded later from debugging info if its name begins ".autotmp_", but the type is still necessary.
-			// See bugs #17644 and #17830 and cmd/internal/dwarf/dwarf.go
+			if n.IsAutoTmp() { // skip debugging info for temporaries
+				continue
+			}
 			p := Gins(obj.ATYPE, n, nil)
 			p.From.Sym = obj.Linklookup(Ctxt, n.Sym.Name, 0)
 			p.To.Type = obj.TYPE_MEM

src/cmd/compile/internal/gc/reflect.go

@@ -494,31 +494,26 @@ func dgopkgpathOffLSym(s *obj.LSym, ot int, pkg *Pkg) int {
 }
 
 // isExportedField reports whether a struct field is exported.
-// It also returns the package to use for PkgPath for an unexported field.
-func isExportedField(ft *Field) (bool, *Pkg) {
+func isExportedField(ft *Field) bool {
 	if ft.Sym != nil && ft.Embedded == 0 {
-		return exportname(ft.Sym.Name), ft.Sym.Pkg
+		return exportname(ft.Sym.Name)
 	} else {
 		if ft.Type.Sym != nil &&
 			(ft.Type.Sym.Pkg == builtinpkg || !exportname(ft.Type.Sym.Name)) {
-			return false, ft.Type.Sym.Pkg
+			return false
 		} else {
-			return true, nil
+			return true
 		}
 	}
 }
 
 // dnameField dumps a reflect.name for a struct field.
-func dnameField(s *Sym, ot int, spkg *Pkg, ft *Field) int {
+func dnameField(s *Sym, ot int, ft *Field) int {
 	var name string
 	if ft.Sym != nil && ft.Embedded == 0 {
 		name = ft.Sym.Name
 	}
-	isExported, fpkg := isExportedField(ft)
-	if isExported || fpkg == spkg {
-		fpkg = nil
-	}
-	nsym := dname(name, ft.Note, fpkg, isExported)
+	nsym := dname(name, ft.Note, nil, isExportedField(ft))
 	return dsymptrLSym(Linksym(s), ot, nsym, 0)
 }
 
@@ -834,13 +829,9 @@ func dcommontype(s *Sym, ot int, t *Type) int {
 		algsym = dalgsym(t)
 	}
 
-	sptrWeak := true
 	var sptr *Sym
-	if !t.IsPtr() || t.ptrTo != nil {
-		tptr := ptrto(t)
-		if t.Sym != nil || methods(tptr) != nil {
-			sptrWeak = false
-		}
+	tptr := ptrto(t)
+	if !t.IsPtr() && (t.Sym != nil || methods(tptr) != nil) {
 		sptr = dtypesym(tptr)
 	}
 
@@ -927,13 +918,10 @@ func dcommontype(s *Sym, ot int, t *Type) int {
 
 	nsym := dname(p, "", nil, exported)
 	ot = dsymptrOffLSym(Linksym(s), ot, nsym, 0) // str
-	// ptrToThis
 	if sptr == nil {
 		ot = duint32(s, ot, 0)
-	} else if sptrWeak {
-		ot = dsymptrWeakOffLSym(Linksym(s), ot, Linksym(sptr))
 	} else {
-		ot = dsymptrOffLSym(Linksym(s), ot, Linksym(sptr), 0)
+		ot = dsymptrOffLSym(Linksym(s), ot, Linksym(sptr), 0) // ptrToThis
 	}
 
 	return ot
@@ -1344,7 +1332,7 @@ ok:
 
 		for _, f := range t.Fields().Slice() {
 			// ../../../../runtime/type.go:/structField
-			ot = dnameField(s, ot, pkg, f)
+			ot = dnameField(s, ot, f)
 			ot = dsymptr(s, ot, dtypesym(f.Type), 0)
 			ot = duintptr(s, ot, uint64(f.Offset))
 		}

src/cmd/compile/internal/gc/sinit.go

@@ -295,9 +295,7 @@ func staticcopy(l *Node, r *Node, out *[]*Node) bool {
 		if staticcopy(l, r, out) {
 			return true
 		}
-		// We may have skipped past one or more OCONVNOPs, so
-		// use conv to ensure r is assignable to l (#13263).
-		*out = append(*out, nod(OAS, l, conv(r, l.Type)))
+		*out = append(*out, nod(OAS, l, r))
 		return true
 
 	case OLITERAL:

src/cmd/compile/internal/gc/subr.go

@@ -58,8 +58,6 @@ func (x byLineno) Len() int           { return len(x) }
 func (x byLineno) Less(i, j int) bool { return x[i].lineno < x[j].lineno }
 func (x byLineno) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 
-// flusherrors sorts errors seen so far by line number, prints them to stdout,
-// and empties the errors array.
 func flusherrors() {
 	Ctxt.Bso.Flush()
 	if len(errors) == 0 {
@@ -1810,8 +1808,6 @@ func genwrapper(rcvr *Type, method *Field, newnam *Sym, iface int) {
 		n := nod(ORETJMP, nil, nil)
 		n.Left = newname(methodsym(method.Sym, methodrcvr, 0))
 		fn.Nbody.Append(n)
-		// When tail-calling, we can't use a frame pointer.
-		fn.Func.NoFramePointer = true
 	} else {
 		fn.Func.Wrapper = true // ignore frame for panic+recover matching
 		call := nod(OCALL, dot, nil)

src/cmd/compile/internal/gc/swt.go

@@ -11,6 +11,9 @@ const (
 	switchKindExpr  = iota // switch a {...} or switch 5 {...}
 	switchKindTrue         // switch true {...} or switch {...}
 	switchKindFalse        // switch false {...}
+
+	// type switch
+	switchKindType // switch a.(type) {...}
 )
 
 const (

src/cmd/compile/internal/gc/syntax.go

@@ -317,7 +317,6 @@ type Func struct {
 	Needctxt        bool   // function uses context register (has closure variables)
 	ReflectMethod   bool   // function calls reflect.Type.Method or MethodByName
 	IsHiddenClosure bool
-	NoFramePointer  bool // Must not use a frame pointer for this function
 }
 
 type Op uint8

src/cmd/compile/internal/gc/testdata/array.go

@@ -106,7 +106,7 @@ func testSliceSetElement() {
 func testSlicePanic1() {
 	defer func() {
 		if r := recover(); r != nil {
-			println("panicked as expected")
+			println("paniced as expected")
 		}
 	}()
 
@@ -119,7 +119,7 @@ func testSlicePanic1() {
 func testSlicePanic2() {
 	defer func() {
 		if r := recover(); r != nil {
-			println("panicked as expected")
+			println("paniced as expected")
 		}
 	}()
 

src/cmd/compile/internal/gc/testdata/string.go

@@ -73,7 +73,7 @@ func testStructSlice() {
 func testStringSlicePanic() {
 	defer func() {
 		if r := recover(); r != nil {
-			println("panicked as expected")
+			println("paniced as expected")
 		}
 	}()
 
@@ -148,7 +148,7 @@ func testInt64Index() {
 func testInt64IndexPanic() {
 	defer func() {
 		if r := recover(); r != nil {
-			println("panicked as expected")
+			println("paniced as expected")
 		}
 	}()
 
@@ -161,7 +161,7 @@ func testInt64IndexPanic() {
 func testInt64SlicePanic() {
 	defer func() {
 		if r := recover(); r != nil {
-			println("panicked as expected")
+			println("paniced as expected")
 		}
 	}()
 

src/cmd/compile/internal/gc/walk.go

@@ -433,6 +433,38 @@ func convFuncName(from, to *Type) string {
 	panic("unreachable")
 }
 
+// Build name of function: assertI2E etc.
+// If with2suffix is true, the form ending in "2" is returned".
+func assertFuncName(from, to *Type, with2suffix bool) string {
+	l := len("assertX2X2")
+	if !with2suffix {
+		l--
+	}
+	tkind := to.iet()
+	switch from.iet() {
+	case 'E':
+		switch tkind {
+		case 'I':
+			return "assertE2I2"[:l]
+		case 'E':
+			return "assertE2E2"[:l]
+		case 'T':
+			return "assertE2T2"[:l]
+		}
+	case 'I':
+		switch tkind {
+		case 'I':
+			return "assertI2I2"[:l]
+		case 'E':
+			return "assertI2E2"[:l]
+		case 'T':
+			return "assertI2T2"[:l]
+		}
+	}
+	Fatalf("unknown assert func %c2%c", from.iet(), to.iet())
+	panic("unreachable")
+}
+
 // The result of walkexpr MUST be assigned back to n, e.g.
 // 	n.Left = walkexpr(n.Left, init)
 func walkexpr(n *Node, init *Nodes) *Node {
@@ -2067,6 +2099,11 @@ func isstack(n *Node) bool {
 	return false
 }
 
+func (n *Node) isGlobal() bool {
+	n = outervalue(n)
+	return n.Op == ONAME && n.Class == PEXTERN
+}
+
 // Do we need a write barrier for the assignment l = r?
 func needwritebarrier(l *Node, r *Node) bool {
 	if !use_writebarrier {

src/cmd/compile/internal/ssa/cse.go

@@ -188,10 +188,7 @@ func cse(f *Func) {
 	for _, b := range f.Blocks {
 	out:
 		for _, v := range b.Values {
-			// New values are created when selectors are copied to
-			// a new block. We can safely ignore those new values,
-			// since they have already been copied (issue 17918).
-			if int(v.ID) >= len(rewrite) || rewrite[v.ID] != nil {
+			if rewrite[v.ID] != nil {
 				continue
 			}
 			if v.Op != OpSelect0 && v.Op != OpSelect1 {

src/cmd/compile/internal/ssa/export_test.go

@@ -6,7 +6,6 @@ package ssa
 
 import (
 	"cmd/internal/obj"
-	"cmd/internal/obj/x86"
 	"testing"
 )
 
@@ -17,7 +16,7 @@ var Deadcode = deadcode
 var Copyelim = copyelim
 
 func testConfig(t testing.TB) *Config {
-	testCtxt := &obj.Link{Arch: &x86.Linkamd64}
+	testCtxt := &obj.Link{}
 	return NewConfig("amd64", DummyFrontend{t}, testCtxt, true)
 }
 
@@ -68,7 +67,7 @@ func (DummyFrontend) Line(line int32) string {
 func (DummyFrontend) AllocFrame(f *Func) {
 }
 func (DummyFrontend) Syslook(s string) interface{} {
-	return DummySym(s)
+	return nil
 }
 
 func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
@@ -99,7 +98,3 @@ func (d DummyFrontend) CanSSA(t Type) bool {
 	// There are no un-SSAable types in dummy land.
 	return true
 }
-
-type DummySym string
-
-func (s DummySym) String() string { return string(s) }

src/cmd/compile/internal/ssa/regalloc.go

@@ -869,6 +869,7 @@ func (s *regAllocState) regalloc(f *Func) {
 				m := s.values[a.ID].regs &^ phiUsed & s.allocatable
 				if m != 0 {
 					r := pickReg(m)
+					s.freeReg(r)
 					phiUsed |= regMask(1) << r
 					phiRegs = append(phiRegs, r)
 				} else {
@@ -877,7 +878,7 @@ func (s *regAllocState) regalloc(f *Func) {
 			}
 
 			// Second pass - deallocate any phi inputs which are now dead.
-			for i, v := range phis {
+			for _, v := range phis {
 				if !s.values[v.ID].needReg {
 					continue
 				}
@@ -886,31 +887,6 @@ func (s *regAllocState) regalloc(f *Func) {
 					// Input is dead beyond the phi, deallocate
 					// anywhere else it might live.
 					s.freeRegs(s.values[a.ID].regs)
-				} else {
-					// Input is still live.
-					// Try to move it around before kicking out, if there is a free register.
-					// We generate a Copy in the predecessor block and record it. It will be
-					// deleted if never used.
-					r := phiRegs[i]
-					if r == noRegister {
-						continue
-					}
-					// Pick a free register. At this point some registers used in the predecessor
-					// block may have been deallocated. Those are the ones used for Phis. Exclude
-					// them (and they are not going to be helpful anyway).
-					m := s.compatRegs(a.Type) &^ s.used &^ phiUsed
-					if m != 0 && !s.values[a.ID].rematerializeable && countRegs(s.values[a.ID].regs) == 1 {
-						r2 := pickReg(m)
-						c := p.NewValue1(a.Line, OpCopy, a.Type, s.regs[r].c)
-						s.copies[c] = false
-						if s.f.pass.debug > regDebug {
-							fmt.Printf("copy %s to %s : %s\n", a, c, s.registers[r2].Name())
-						}
-						s.setOrig(c, a)
-						s.assignReg(r2, a, c)
-						s.endRegs[p.ID] = append(s.endRegs[p.ID], endReg{r2, a, c})
-					}
-					s.freeReg(r)
 				}
 			}
 

src/cmd/compile/internal/ssa/type_test.go

@@ -44,7 +44,7 @@ func (t *TypeImpl) IsVoid() bool           { return false }
 func (t *TypeImpl) String() string         { return t.Name }
 func (t *TypeImpl) SimpleString() string   { return t.Name }
 func (t *TypeImpl) ElemType() Type         { return t.Elem_ }
-func (t *TypeImpl) PtrTo() Type            { return TypeBytePtr }
+func (t *TypeImpl) PtrTo() Type            { panic("not implemented") }
 func (t *TypeImpl) NumFields() int         { panic("not implemented") }
 func (t *TypeImpl) FieldType(i int) Type   { panic("not implemented") }
 func (t *TypeImpl) FieldOff(i int) int64   { panic("not implemented") }

src/cmd/compile/internal/ssa/writebarrier.go

@@ -78,6 +78,7 @@ func writebarrier(f *Func) {
 					defer f.retSparseSet(wbs)
 				}
 
+				mem := v.Args[2]
 				line := v.Line
 
 				// there may be a sequence of WB stores in the current block. find them.
@@ -105,20 +106,6 @@ func writebarrier(f *Func) {
 					}
 				}
 
-				// find the memory before the WB stores
-				// this memory is not a WB store but it is used in a WB store.
-				var mem *Value
-				for _, w := range storeWBs {
-					a := w.Args[len(w.Args)-1]
-					if wbs.contains(a.ID) {
-						continue
-					}
-					if mem != nil {
-						b.Fatalf("two stores live simultaneously: %s, %s", mem, a)
-					}
-					mem = a
-				}
-
 				b.Values = append(b.Values[:i], others...) // move WB ops out of this block
 
 				bThen := f.NewBlock(BlockPlain)
@@ -190,39 +177,20 @@ func writebarrier(f *Func) {
 				// which may be used in subsequent blocks. Other memories in the
 				// sequence must be dead after this block since there can be only
 				// one memory live.
-				last := storeWBs[0]
-				if len(storeWBs) > 1 {
-					// find the last store
-					last = nil
-					wbs.clear() // we reuse wbs to record WB stores that is used in another WB store
-					for _, w := range storeWBs {
-						wbs.add(w.Args[len(w.Args)-1].ID)
-					}
-					for _, w := range storeWBs {
-						if wbs.contains(w.ID) {
-							continue
-						}
-						if last != nil {
-							b.Fatalf("two stores live simultaneously: %s, %s", last, w)
-						}
-						last = w
+				v = storeWBs[len(storeWBs)-1]
+				bEnd.Values = append(bEnd.Values, v)
+				v.Block = bEnd
+				v.reset(OpPhi)
+				v.Type = TypeMem
+				v.AddArg(memThen)
+				v.AddArg(memElse)
+				for _, w := range storeWBs[:len(storeWBs)-1] {
+					for _, a := range w.Args {
+						a.Uses--
 					}
 				}
-				bEnd.Values = append(bEnd.Values, last)
-				last.Block = bEnd
-				last.reset(OpPhi)
-				last.Type = TypeMem
-				last.AddArg(memThen)
-				last.AddArg(memElse)
-				for _, w := range storeWBs {
-					if w != last {
-						w.resetArgs()
-					}
-				}
-				for _, w := range storeWBs {
-					if w != last {
-						f.freeValue(w)
-					}
+				for _, w := range storeWBs[:len(storeWBs)-1] {
+					f.freeValue(w)
 				}
 
 				if f.Config.fe.Debug_wb() {

src/cmd/compile/internal/ssa/writebarrier_test.go

@@ -1,29 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssa
-
-import "testing"
-
-func TestWriteBarrierStoreOrder(t *testing.T) {
-	// Make sure writebarrier phase works even StoreWB ops are not in dependency order
-	c := testConfig(t)
-	ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing
-	fun := Fun(c, "entry",
-		Bloc("entry",
-			Valu("start", OpInitMem, TypeMem, 0, nil),
-			Valu("sb", OpSB, TypeInvalid, 0, nil),
-			Valu("sp", OpSP, TypeInvalid, 0, nil),
-			Valu("v", OpConstNil, ptrType, 0, nil),
-			Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
-			Valu("wb2", OpStoreWB, TypeMem, 8, nil, "addr1", "v", "wb1"),
-			Valu("wb1", OpStoreWB, TypeMem, 8, nil, "addr1", "v", "start"), // wb1 and wb2 are out of order
-			Goto("exit")),
-		Bloc("exit",
-			Exit("wb2")))
-
-	CheckFunc(fun.f)
-	writebarrier(fun.f)
-	CheckFunc(fun.f)
-}

src/cmd/compile/internal/syntax/nodes.go

@@ -14,8 +14,7 @@ type Node interface {
 }
 
 type node struct {
-	// commented out for now since not yet used
-	// doc  *Comment // nil means no comment(s) attached
+	doc  *Comment // nil means no comment(s) attached
 	pos  uint32
 	line uint32
 }

src/cmd/compile/internal/syntax/parser.go

@@ -26,6 +26,8 @@ type parser struct {
 	indent []byte // tracing support
 }
 
+type parserError string // for error recovery if no error handler was installed
+
 func (p *parser) init(src io.Reader, errh ErrorHandler, pragh PragmaHandler) {
 	p.scanner.init(src, errh, pragh)
 
@@ -1807,19 +1809,24 @@ func (p *parser) commClause() *CommClause {
 	switch p.tok {
 	case _Case:
 		p.next()
-		c.Comm = p.simpleStmt(nil, false)
+		lhs := p.exprList()
 
-		// The syntax restricts the possible simple statements here to:
-		//
-		//     lhs <- x (send statement)
-		//     <-x
-		//     lhs = <-x
-		//     lhs := <-x
-		//
-		// All these (and more) are recognized by simpleStmt and invalid
-		// syntax trees are flagged later, during type checking.
-		// TODO(gri) eventually may want to restrict valid syntax trees
-		// here.
+		if _, ok := lhs.(*ListExpr); !ok && p.tok == _Arrow {
+			// lhs <- x
+		} else {
+			// lhs
+			// lhs = <-x
+			// lhs := <-x
+			if p.tok == _Assign || p.tok == _Define {
+				// TODO(gri) check that lhs has at most 2 entries
+			} else if p.tok == _Colon {
+				// TODO(gri) check that lhs has at most 1 entry
+			} else {
+				panic("unimplemented")
+			}
+		}
+
+		c.Comm = p.simpleStmt(lhs, false)
 
 	case _Default:
 		p.next()

src/cmd/compile/internal/syntax/parser_test.go

@@ -179,6 +179,6 @@ func TestParseFile(t *testing.T) {
 		t.Error("missing io error")
 	}
 	if err != first {
-		t.Errorf("got %v; want first error %v", err, first)
+		t.Error("got %v; want first error %v", err, first)
 	}
 }

src/cmd/compile/main.go

@@ -9,7 +9,6 @@ import (
 	"cmd/compile/internal/arm"
 	"cmd/compile/internal/arm64"
 	"cmd/compile/internal/gc"
-	"cmd/compile/internal/mips"
 	"cmd/compile/internal/mips64"
 	"cmd/compile/internal/ppc64"
 	"cmd/compile/internal/s390x"
@@ -37,8 +36,6 @@ func main() {
 		arm.Init()
 	case "arm64":
 		arm64.Init()
-	case "mips", "mipsle":
-		mips.Init()
 	case "mips64", "mips64le":
 		mips64.Init()
 	case "ppc64", "ppc64le":

src/cmd/cover/html.go

@@ -64,12 +64,9 @@ func htmlOutput(profile, outfile string) error {
 	} else {
 		out, err = os.Create(outfile)
 	}
-	if err != nil {
-		return err
-	}
 	err = htmlTemplate.Execute(out, d)
-	if err2 := out.Close(); err == nil {
-		err = err2
+	if err == nil {
+		err = out.Close()
 	}
 	if err != nil {
 		return err

src/cmd/cover/profile.go

@@ -93,29 +93,6 @@ func ParseProfiles(fileName string) ([]*Profile, error) {
 	}
 	for _, p := range files {
 		sort.Sort(blocksByStart(p.Blocks))
-		// Merge samples from the same location.
-		j := 1
-		for i := 1; i < len(p.Blocks); i++ {
-			b := p.Blocks[i]
-			last := p.Blocks[j-1]
-			if b.StartLine == last.StartLine &&
-				b.StartCol == last.StartCol &&
-				b.EndLine == last.EndLine &&
-				b.EndCol == last.EndCol {
-				if b.NumStmt != last.NumStmt {
-					return nil, fmt.Errorf("inconsistent NumStmt: changed from %d to %d", last.NumStmt, b.NumStmt)
-				}
-				if mode == "set" {
-					p.Blocks[j-1].Count |= b.Count
-				} else {
-					p.Blocks[j-1].Count += b.Count
-				}
-				continue
-			}
-			p.Blocks[j] = b
-			j++
-		}
-		p.Blocks = p.Blocks[:j]
 	}
 	// Generate a sorted slice.
 	profiles := make([]*Profile, 0, len(files))

src/cmd/dist/build.go

@@ -1107,8 +1107,6 @@ var cgoEnabled = map[string]bool{
 	"linux/arm64":     true,
 	"linux/ppc64":     false,
 	"linux/ppc64le":   true,
-	"linux/mips":      true,
-	"linux/mipsle":    true,
 	"linux/mips64":    true,
 	"linux/mips64le":  true,
 	"linux/s390x":     true,

src/cmd/dist/buildtool.go

@@ -37,7 +37,6 @@ var bootstrapDirs = []string{
 	"cmd/compile/internal/arm",
 	"cmd/compile/internal/arm64",
 	"cmd/compile/internal/gc",
-	"cmd/compile/internal/mips",
 	"cmd/compile/internal/mips64",
 	"cmd/compile/internal/ppc64",
 	"cmd/compile/internal/s390x",
@@ -60,7 +59,6 @@ var bootstrapDirs = []string{
 	"cmd/link/internal/arm",
 	"cmd/link/internal/arm64",
 	"cmd/link/internal/ld",
-	"cmd/link/internal/mips",
 	"cmd/link/internal/mips64",
 	"cmd/link/internal/ppc64",
 	"cmd/link/internal/s390x",

src/cmd/dist/test.go

@@ -15,7 +15,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
-	"runtime"
 	"strconv"
 	"strings"
 	"sync"
@@ -153,11 +152,8 @@ func (t *tester) run() {
 	}
 
 	t.timeoutScale = 1
-	switch t.goarch {
-	case "arm":
+	if t.goarch == "arm" || t.goos == "windows" {
 		t.timeoutScale = 2
-	case "mips", "mipsle", "mips64", "mips64le":
-		t.timeoutScale = 4
 	}
 	if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
 		t.timeoutScale, err = strconv.Atoi(s)
@@ -332,10 +328,6 @@ func (t *tester) registerRaceBenchTest(pkg string) {
 	})
 }
 
-// stdOutErrAreTerminals is defined in test_linux.go, to report
-// whether stdout & stderr are terminals.
-var stdOutErrAreTerminals func() bool
-
 func (t *tester) registerTests() {
 	if strings.HasSuffix(os.Getenv("GO_BUILDER_NAME"), "-vetall") {
 		// Run vet over std and cmd and call it quits.
@@ -352,27 +344,6 @@ func (t *tester) registerTests() {
 		return
 	}
 
-	// This test needs its stdout/stderr to be terminals, so we don't run it from cmd/go's tests.
-	// See issue 18153.
-	if runtime.GOOS == "linux" {
-		t.tests = append(t.tests, distTest{
-			name:    "cmd_go_test_terminal",
-			heading: "cmd/go terminal test",
-			fn: func(dt *distTest) error {
-				t.runPending(dt)
-				if !stdOutErrAreTerminals() {
-					fmt.Println("skipping terminal test; stdout/stderr not terminals")
-					return nil
-				}
-				cmd := exec.Command("go", "test")
-				cmd.Dir = filepath.Join(os.Getenv("GOROOT"), "src/cmd/go/testdata/testterminal18153")
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-				return cmd.Run()
-			},
-		})
-	}
-
 	// Fast path to avoid the ~1 second of `go list std cmd` when
 	// the caller lists specific tests to run. (as the continuous
 	// build coordinator does).
@@ -741,7 +712,7 @@ func (t *tester) internalLink() bool {
 	// Internally linking cgo is incomplete on some architectures.
 	// https://golang.org/issue/10373
 	// https://golang.org/issue/14449
-	if t.goarch == "arm64" || t.goarch == "mips64" || t.goarch == "mips64le" || t.goarch == "mips" || t.goarch == "mipsle" {
+	if t.goarch == "arm64" || t.goarch == "mips64" || t.goarch == "mips64le" {
 		return false
 	}
 	return true
@@ -775,18 +746,11 @@ func (t *tester) supportedBuildmode(mode string) bool {
 		}
 		return false
 	case "plugin":
-		if os.Getenv("GO_BUILDER_NAME") == "linux-amd64-noopt" {
-			// Skip the plugin tests on noopt. They're
-			// causing build failures potentially
-			// obscuring other issues. This is hopefully a
-			// temporary workaround. See golang.org/issue/17937.
-			return false
-		}
-
 		// linux-arm64 is missing because it causes the external linker
 		// to crash, see https://golang.org/issue/17138
 		switch pair {
-		case "linux-386", "linux-amd64", "linux-arm":
+		case "linux-386", "linux-amd64", "linux-arm",
+			"darwin-amd64":
 			return true
 		}
 		return false
@@ -1091,7 +1055,7 @@ func (t *tester) runFlag(rx string) string {
 func (t *tester) raceTest(dt *distTest) error {
 	t.addCmd(dt, "src", "go", "test", "-race", "-i", "runtime/race", "flag", "os/exec")
 	t.addCmd(dt, "src", "go", "test", "-race", t.runFlag("Output"), "runtime/race")
-	t.addCmd(dt, "src", "go", "test", "-race", "-short", t.runFlag("TestParse|TestEcho|TestStdinCloseRace"), "flag", "os/exec")
+	t.addCmd(dt, "src", "go", "test", "-race", "-short", t.runFlag("TestParse|TestEcho"), "flag", "os/exec")
 	// We don't want the following line, because it
 	// slows down all.bash (by 10 seconds on my laptop).
 	// The race builder should catch any error here, but doesn't.
@@ -1104,7 +1068,7 @@ func (t *tester) raceTest(dt *distTest) error {
 	}
 	if t.extLink() {
 		// Test with external linking; see issue 9133.
-		t.addCmd(dt, "src", "go", "test", "-race", "-short", "-ldflags=-linkmode=external", t.runFlag("TestParse|TestEcho|TestStdinCloseRace"), "flag", "os/exec")
+		t.addCmd(dt, "src", "go", "test", "-race", "-short", "-ldflags=-linkmode=external", t.runFlag("TestParse|TestEcho"), "flag", "os/exec")
 	}
 	return nil
 }

src/cmd/dist/test_linux.go

@@ -1,27 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux
-
-package main
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const ioctlReadTermios = syscall.TCGETS
-
-// isTerminal reports whether fd is a terminal.
-func isTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}
-
-func init() {
-	stdOutErrAreTerminals = func() bool {
-		return isTerminal(1) && isTerminal(2)
-	}
-}

src/cmd/dist/util.go

@@ -393,14 +393,6 @@ func errprintf(format string, args ...interface{}) {
 func main() {
 	os.Setenv("TERM", "dumb") // disable escape codes in clang errors
 
-	// provide -check-armv6k first, before checking for $GOROOT so that
-	// it is possible to run this check without having $GOROOT available.
-	if len(os.Args) > 1 && os.Args[1] == "-check-armv6k" {
-		useARMv6K() // might fail with SIGILL
-		println("ARMv6K supported.")
-		os.Exit(0)
-	}
-
 	slash = string(filepath.Separator)
 
 	gohostos = runtime.GOOS
@@ -453,11 +445,6 @@ func main() {
 			if elfIsLittleEndian(os.Args[0]) {
 				gohostarch = "mips64le"
 			}
-		case strings.Contains(out, "mips"):
-			gohostarch = "mips"
-			if elfIsLittleEndian(os.Args[0]) {
-				gohostarch = "mipsle"
-			}
 		case strings.Contains(out, "s390x"):
 			gohostarch = "s390x"
 		case gohostos == "darwin":

src/cmd/dist/util_gc.go

@@ -25,8 +25,3 @@ func useVFPv1()
 // useVFPv3 tries to execute one VFPv3 instruction on ARM.
 // It will crash the current process if VFPv3 is missing.
 func useVFPv3()
-
-// useARMv6K tries to run ARMv6K instructions on ARM.
-// It will crash the current process if it doesn't implement
-// ARMv6K or above.
-func useARMv6K()

src/cmd/dist/util_gccgo.go

@@ -22,5 +22,3 @@ func cansse2() bool { return C.supports_sse2() != 0 }
 func useVFPv1() {}
 
 func useVFPv3() {}
-
-func useARMv6K() {}

src/cmd/dist/vfp_arm.s

@@ -15,12 +15,3 @@ TEXT ·useVFPv1(SB),NOSPLIT,$0
 TEXT ·useVFPv3(SB),NOSPLIT,$0
 	WORD $0xeeb70b00	// vmov.f64 d0, #112
 	RET
-
-// try to run ARMv6K (or above) "ldrexd" instruction
-TEXT ·useARMv6K(SB),NOSPLIT,$32
-	MOVW R13, R2
-	BIC  $15, R13
-	WORD $0xe1bd0f9f	// ldrexd r0, r1, [sp]
-	WORD $0xf57ff01f	// clrex
-	MOVW R2, R13
-	RET

src/cmd/dist/vfp_default.s

@@ -11,6 +11,3 @@ TEXT ·useVFPv1(SB),NOSPLIT,$0
 
 TEXT ·useVFPv3(SB),NOSPLIT,$0
 	RET
-
-TEXT ·useARMv6K(SB),NOSPLIT,$0
-	RET

src/cmd/go/alldocs.go

@@ -929,11 +929,8 @@
 // On Windows, the value is a semicolon-separated string.
 // On Plan 9, the value is a list.
 //
-// If the environment variable is unset, GOPATH defaults
-// to a subdirectory named "go" in the user's home directory
-// ($HOME/go on Unix, %USERPROFILE%\go on Windows),
-// unless that directory holds a Go distribution.
-// Run "go env GOPATH" to see the current GOPATH.
+// GOPATH must be set to get, build and install packages outside the
+// standard Go tree.
 //
 // Each directory listed in GOPATH must have a prescribed structure:
 //
@@ -961,9 +958,9 @@
 //
 // Here's an example directory layout:
 //
-//     GOPATH=/home/user/go
+//     GOPATH=/home/user/gocode
 //
-//     /home/user/go/
+//     /home/user/gocode/
 //         src/
 //             foo/
 //                 bar/               (go code in package bar)
@@ -989,7 +986,7 @@
 // by code in the directory tree rooted at the parent of "internal".
 // Here's an extended version of the directory layout above:
 //
-//     /home/user/go/
+//     /home/user/gocode/
 //         src/
 //             crash/
 //                 bang/              (go code in package bang)
@@ -1027,7 +1024,7 @@
 // but with the "internal" directory renamed to "vendor"
 // and a new foo/vendor/crash/bang directory added:
 //
-//     /home/user/go/
+//     /home/user/gocode/
 //         src/
 //             crash/
 //                 bang/              (go code in package bang)

src/cmd/go/bug.go

@@ -39,14 +39,10 @@ func runBug(cmd *Command, args []string) {
 	fmt.Fprint(&buf, "#### System details\n\n")
 	fmt.Fprintln(&buf, "```")
 	fmt.Fprintf(&buf, "go version %s %s/%s\n", runtime.Version(), runtime.GOOS, runtime.GOARCH)
-	env := newEnv
+	env := mkEnv()
 	env = append(env, extraEnvVars()...)
 	for _, e := range env {
-		// Hide the TERM environment variable from "go bug".
-		// See issue #18128
-		if e.name != "TERM" {
-			fmt.Fprintf(&buf, "%s=\"%s\"\n", e.name, e.value)
-		}
+		fmt.Fprintf(&buf, "%s=\"%s\"\n", e.name, e.value)
 	}
 	printGoDetails(&buf)
 	printOSDetails(&buf)

src/cmd/go/build.go

@@ -413,7 +413,8 @@ func buildModeInit() {
 		} else {
 			switch platform {
 			case "linux/amd64", "linux/arm", "linux/arm64", "linux/386",
-				"android/amd64", "android/arm", "android/arm64", "android/386":
+				"android/amd64", "android/arm", "android/arm64", "android/386",
+				"darwin/amd64":
 			default:
 				fatalf("-buildmode=plugin not supported on %s\n", platform)
 			}
@@ -2405,7 +2406,8 @@ func (gcToolchain) gc(b *builder, p *Package, archive, obj string, asmhdr bool,
 func (gcToolchain) asm(b *builder, p *Package, obj string, sfiles []string) ([]string, error) {
 	// Add -I pkg/GOOS_GOARCH so #include "textflag.h" works in .s files.
 	inc := filepath.Join(goroot, "pkg", "include")
-	args := []interface{}{buildToolExec, tool("asm"), "-trimpath", b.work, "-I", obj, "-I", inc, "-D", "GOOS_" + goos, "-D", "GOARCH_" + goarch, buildAsmflags}
+	ofile := obj + "asm.o"
+	args := []interface{}{buildToolExec, tool("asm"), "-o", ofile, "-trimpath", b.work, "-I", obj, "-I", inc, "-D", "GOOS_" + goos, "-D", "GOARCH_" + goarch, buildAsmflags}
 	if p.ImportPath == "runtime" && goarch == "386" {
 		for _, arg := range buildAsmflags {
 			if arg == "-dynlink" {
@@ -2413,16 +2415,13 @@ func (gcToolchain) asm(b *builder, p *Package, obj string, sfiles []string) ([]s
 			}
 		}
 	}
-	var ofiles []string
 	for _, sfile := range sfiles {
-		ofile := obj + sfile[:len(sfile)-len(".s")] + ".o"
-		ofiles = append(ofiles, ofile)
-		a := append(args, "-o", ofile, mkAbs(p.Dir, sfile))
-		if err := b.run(p.Dir, p.ImportPath, nil, a...); err != nil {
-			return nil, err
-		}
+		args = append(args, mkAbs(p.Dir, sfile))
 	}
-	return ofiles, nil
+	if err := b.run(p.Dir, p.ImportPath, nil, args...); err != nil {
+		return nil, err
+	}
+	return []string{ofile}, nil
 }
 
 // toolVerify checks that the command line args writes the same output file
@@ -2581,11 +2580,7 @@ func (gcToolchain) ld(b *builder, root *action, out string, allactions []*action
 		ldflags = append(ldflags, "-w")
 	}
 	if buildBuildmode == "plugin" {
-		pluginpath := root.p.ImportPath
-		if pluginpath == "command-line-arguments" {
-			pluginpath = "plugin/unnamed-" + root.p.buildID
-		}
-		ldflags = append(ldflags, "-pluginpath", pluginpath)
+		ldflags = append(ldflags, "-pluginpath", root.p.ImportPath)
 	}
 
 	// If the user has not specified the -extld option, then specify the
@@ -3219,8 +3214,6 @@ func (b *builder) gccArchArgs() []string {
 		return []string{"-m64", "-march=z196"}
 	case "mips64", "mips64le":
 		return []string{"-mabi=64"}
-	case "mips", "mipsle":
-		return []string{"-mabi=32", "-march=mips32"}
 	}
 	return nil
 }
@@ -3776,11 +3769,7 @@ func instrumentInit() {
 		return
 	}
 	if buildRace && buildMSan {
-		fmt.Fprintf(os.Stderr, "go %s: may not use -race and -msan simultaneously\n", flag.Args()[0])
-		os.Exit(2)
-	}
-	if buildMSan && (goos != "linux" || goarch != "amd64") {
-		fmt.Fprintf(os.Stderr, "-msan is not supported on %s/%s\n", goos, goarch)
+		fmt.Fprintf(os.Stderr, "go %s: may not use -race and -msan simultaneously", flag.Args()[0])
 		os.Exit(2)
 	}
 	if goarch != "amd64" || goos != "linux" && goos != "freebsd" && goos != "darwin" && goos != "windows" {

src/cmd/go/env.go

@@ -40,7 +40,7 @@ func mkEnv() []envVar {
 		{"GOHOSTARCH", runtime.GOARCH},
 		{"GOHOSTOS", runtime.GOOS},
 		{"GOOS", goos},
-		{"GOPATH", buildContext.GOPATH},
+		{"GOPATH", os.Getenv("GOPATH")},
 		{"GORACE", os.Getenv("GORACE")},
 		{"GOROOT", goroot},
 		{"GOTOOLDIR", toolDir},
@@ -62,11 +62,13 @@ func mkEnv() []envVar {
 		env = append(env, envVar{"GO386", os.Getenv("GO386")})
 	}
 
-	cmd := b.gccCmd(".")
-	env = append(env, envVar{"CC", cmd[0]})
-	env = append(env, envVar{"GOGCCFLAGS", strings.Join(cmd[3:], " ")})
-	cmd = b.gxxCmd(".")
-	env = append(env, envVar{"CXX", cmd[0]})
+	if goos != "plan9" {
+		cmd := b.gccCmd(".")
+		env = append(env, envVar{"CC", cmd[0]})
+		env = append(env, envVar{"GOGCCFLAGS", strings.Join(cmd[3:], " ")})
+		cmd = b.gxxCmd(".")
+		env = append(env, envVar{"CXX", cmd[0]})
+	}
 
 	if buildContext.CgoEnabled {
 		env = append(env, envVar{"CGO_ENABLED", "1"})
@@ -102,7 +104,7 @@ func extraEnvVars() []envVar {
 }
 
 func runEnv(cmd *Command, args []string) {
-	env := newEnv
+	env := mkEnv()
 	env = append(env, extraEnvVars()...)
 	if len(args) > 0 {
 		for _, name := range args {

src/cmd/go/get.go

@@ -205,10 +205,6 @@ var downloadRootCache = map[string]bool{}
 // download runs the download half of the get command
 // for the package named by the argument.
 func download(arg string, parent *Package, stk *importStack, mode int) {
-	if mode&useVendor != 0 {
-		// Caller is responsible for expanding vendor paths.
-		panic("internal error: download mode has useVendor set")
-	}
 	load := func(path string, mode int) *Package {
 		if parent == nil {
 			return loadPackage(path, stk)
@@ -319,43 +315,33 @@ func download(arg string, parent *Package, stk *importStack, mode int) {
 		}
 
 		// Process dependencies, now that we know what they are.
-		imports := p.Imports
-		if mode&getTestDeps != 0 {
-			// Process test dependencies when -t is specified.
-			// (But don't get test dependencies for test dependencies:
-			// we always pass mode 0 to the recursive calls below.)
-			imports = stringList(imports, p.TestImports, p.XTestImports)
-		}
-		for i, path := range imports {
+		for _, path := range p.Imports {
 			if path == "C" {
 				continue
 			}
-			// Fail fast on import naming full vendor path.
-			// Otherwise expand path as needed for test imports.
-			// Note that p.Imports can have additional entries beyond p.build.Imports.
-			orig := path
-			if i < len(p.build.Imports) {
-				orig = p.build.Imports[i]
-			}
-			if j, ok := findVendor(orig); ok {
-				stk.push(path)
-				err := &PackageError{
-					ImportStack: stk.copy(),
-					Err:         "must be imported as " + path[j+len("vendor/"):],
-				}
-				stk.pop()
-				errorf("%s", err)
-				continue
-			}
-			// If this is a test import, apply vendor lookup now.
-			// We cannot pass useVendor to download, because
-			// download does caching based on the value of path,
-			// so it must be the fully qualified path already.
-			if i >= len(p.Imports) {
-				path = vendoredImportPath(p, path)
-			}
+			// Don't get test dependencies recursively.
+			// Imports is already vendor-expanded.
 			download(path, p, stk, 0)
 		}
+		if mode&getTestDeps != 0 {
+			// Process test dependencies when -t is specified.
+			// (Don't get test dependencies for test dependencies.)
+			// We pass useVendor here because p.load does not
+			// vendor-expand TestImports and XTestImports.
+			// The call to loadImport inside download needs to do that.
+			for _, path := range p.TestImports {
+				if path == "C" {
+					continue
+				}
+				download(path, p, stk, useVendor)
+			}
+			for _, path := range p.XTestImports {
+				if path == "C" {
+					continue
+				}
+				download(path, p, stk, useVendor)
+			}
+		}
 
 		if isWildcard {
 			stk.pop()
@@ -431,10 +417,6 @@ func downloadPackage(p *Package) error {
 		if list[0] == goroot {
 			return fmt.Errorf("cannot download, $GOPATH must not be set to $GOROOT. For more details see: 'go help gopath'")
 		}
-		if _, err := os.Stat(filepath.Join(list[0], "src/cmd/go/alldocs.go")); err == nil {
-			return fmt.Errorf("cannot download, %s is a GOROOT, not a GOPATH. For more details see: 'go help gopath'", list[0])
-		}
-		p.build.Root = list[0]
 		p.build.SrcRoot = filepath.Join(list[0], "src")
 		p.build.PkgRoot = filepath.Join(list[0], "pkg")
 	}
@@ -463,19 +445,11 @@ func downloadPackage(p *Package) error {
 		if _, err := os.Stat(root); err == nil {
 			return fmt.Errorf("%s exists but %s does not - stale checkout?", root, meta)
 		}
-
-		_, err := os.Stat(p.build.Root)
-		gopathExisted := err == nil
-
 		// Some version control tools require the parent of the target to exist.
 		parent, _ := filepath.Split(root)
 		if err = os.MkdirAll(parent, 0777); err != nil {
 			return err
 		}
-		if buildV && !gopathExisted && p.build.Root == buildContext.GOPATH {
-			fmt.Fprintf(os.Stderr, "created GOPATH=%s; see 'go help gopath'\n", p.build.Root)
-		}
-
 		if err = vcs.create(root, repo); err != nil {
 			return err
 		}

src/cmd/go/go_test.go

@@ -6,6 +6,7 @@ package main_test
 
 import (
 	"bytes"
+	"flag"
 	"fmt"
 	"go/build"
 	"go/format"
@@ -49,17 +50,6 @@ func init() {
 			// many linux/arm machines are too slow to run
 			// the full set of external tests.
 			skipExternal = true
-		case "mips", "mipsle", "mips64", "mips64le":
-			// Also slow.
-			skipExternal = true
-			if testenv.Builder() != "" {
-				// On the builders, skip the cmd/go
-				// tests. They're too slow and already
-				// covered by other ports. There's
-				// nothing os/arch specific in the
-				// tests.
-				canRun = false
-			}
 		}
 	case "freebsd":
 		switch runtime.GOARCH {
@@ -77,6 +67,8 @@ func init() {
 // The TestMain function creates a go command for testing purposes and
 // deletes it after the tests have been run.
 func TestMain(m *testing.M) {
+	flag.Parse()
+
 	if canRun {
 		args := []string{"build", "-tags", "testgo", "-o", "testgo" + exeSuffix}
 		if race.Enabled {
@@ -1063,14 +1055,14 @@ func TestInternalPackagesInGOROOTAreRespected(t *testing.T) {
 	tg := testgo(t)
 	defer tg.cleanup()
 	tg.runFail("build", "-v", "./testdata/testinternal")
-	tg.grepBoth(`testinternal(\/|\\)p\.go\:3\:8\: use of internal package not allowed`, "wrong error message for testdata/testinternal")
+	tg.grepBoth("use of internal package not allowed", "wrong error message for testdata/testinternal")
 }
 
 func TestInternalPackagesOutsideGOROOTAreRespected(t *testing.T) {
 	tg := testgo(t)
 	defer tg.cleanup()
 	tg.runFail("build", "-v", "./testdata/testinternal2")
-	tg.grepBoth(`testinternal2(\/|\\)p\.go\:3\:8\: use of internal package not allowed`, "wrote error message for testdata/testinternal2")
+	tg.grepBoth("use of internal package not allowed", "wrote error message for testdata/testinternal2")
 }
 
 func TestRunInternal(t *testing.T) {
@@ -1080,7 +1072,7 @@ func TestRunInternal(t *testing.T) {
 	tg.setenv("GOPATH", dir)
 	tg.run("run", filepath.Join(dir, "src/run/good.go"))
 	tg.runFail("run", filepath.Join(dir, "src/run/bad.go"))
-	tg.grepStderr(`testdata(\/|\\)src(\/|\\)run(\/|\\)bad\.go\:3\:8\: use of internal package not allowed`, "unexpected error for run/bad.go")
+	tg.grepStderr("use of internal package not allowed", "unexpected error for run/bad.go")
 }
 
 func testMove(t *testing.T, vcs, url, base, config string) {
@@ -1672,156 +1664,15 @@ func TestMentionGOPATHNotOnSecondEntry(t *testing.T) {
 	}
 }
 
-func homeEnvName() string {
-	switch runtime.GOOS {
-	case "windows":
-		return "USERPROFILE"
-	case "plan9":
-		return "home"
-	default:
-		return "HOME"
-	}
-}
-
-// Test go env missing GOPATH shows default.
-func TestMissingGOPATHEnvShowsDefault(t *testing.T) {
+// Test missing GOPATH is reported.
+func TestMissingGOPATHIsReported(t *testing.T) {
 	tg := testgo(t)
 	defer tg.cleanup()
 	tg.parallel()
 	tg.setenv("GOPATH", "")
-	tg.run("env", "GOPATH")
-
-	want := filepath.Join(os.Getenv(homeEnvName()), "go")
-	got := strings.TrimSpace(tg.getStdout())
-	if got != want {
-		t.Errorf("got %q; want %q", got, want)
-	}
-}
-
-// Test go get missing GOPATH causes go get to warn if directory doesn't exist.
-func TestMissingGOPATHGetWarnsIfNotExists(t *testing.T) {
-	testenv.MustHaveExternalNetwork(t)
-
-	if _, err := exec.LookPath("git"); err != nil {
-		t.Skip("skipping because git binary not found")
-	}
-
-	tg := testgo(t)
-	defer tg.cleanup()
-
-	// setenv variables for test and defer deleting temporary home directory.
-	tg.setenv("GOPATH", "")
-	tmp, err := ioutil.TempDir("", "")
-	if err != nil {
-		t.Fatalf("could not create tmp home: %v", err)
-	}
-	defer os.RemoveAll(tmp)
-	tg.setenv(homeEnvName(), tmp)
-
-	tg.run("get", "-v", "github.com/golang/example/hello")
-
-	want := fmt.Sprintf("created GOPATH=%s; see 'go help gopath'", filepath.Join(tmp, "go"))
-	got := strings.TrimSpace(tg.getStderr())
-	if !strings.Contains(got, want) {
-		t.Errorf("got %q; want %q", got, want)
-	}
-}
-
-// Test go get missing GOPATH causes no warning if directory exists.
-func TestMissingGOPATHGetDoesntWarnIfExists(t *testing.T) {
-	testenv.MustHaveExternalNetwork(t)
-
-	if _, err := exec.LookPath("git"); err != nil {
-		t.Skip("skipping because git binary not found")
-	}
-
-	tg := testgo(t)
-	defer tg.cleanup()
-
-	// setenv variables for test and defer resetting them.
-	tg.setenv("GOPATH", "")
-	tmp, err := ioutil.TempDir("", "")
-	if err != nil {
-		t.Fatalf("could not create tmp home: %v", err)
-	}
-	defer os.RemoveAll(tmp)
-	if err := os.Mkdir(filepath.Join(tmp, "go"), 0777); err != nil {
-		t.Fatalf("could not create $HOME/go: %v", err)
-	}
-
-	tg.setenv(homeEnvName(), tmp)
-
-	tg.run("get", "github.com/golang/example/hello")
-
-	got := strings.TrimSpace(tg.getStderr())
-	if got != "" {
-		t.Errorf("got %q; wants empty", got)
-	}
-}
-
-// Test go get missing GOPATH fails if pointed file is not a directory.
-func TestMissingGOPATHGetFailsIfItsNotDirectory(t *testing.T) {
-	testenv.MustHaveExternalNetwork(t)
-
-	tg := testgo(t)
-	defer tg.cleanup()
-
-	// setenv variables for test and defer resetting them.
-	tg.setenv("GOPATH", "")
-	tmp, err := ioutil.TempDir("", "")
-	if err != nil {
-		t.Fatalf("could not create tmp home: %v", err)
-	}
-	defer os.RemoveAll(tmp)
-
-	path := filepath.Join(tmp, "go")
-	if err := ioutil.WriteFile(path, nil, 0777); err != nil {
-		t.Fatalf("could not create GOPATH at %s: %v", path, err)
-	}
-	tg.setenv(homeEnvName(), tmp)
-
-	const pkg = "github.com/golang/example/hello"
-	tg.runFail("get", pkg)
-
-	msg := "not a directory"
-	if runtime.GOOS == "windows" {
-		msg = "The system cannot find the path specified."
-	}
-	want := fmt.Sprintf("package %s: mkdir %s: %s", pkg, filepath.Join(tmp, "go"), msg)
-	got := strings.TrimSpace(tg.getStderr())
-	if got != want {
-		t.Errorf("got %q; wants %q", got, want)
-	}
-}
-
-// Test go install of missing package when missing GOPATH fails and shows default GOPATH.
-func TestMissingGOPATHInstallMissingPackageFailsAndShowsDefault(t *testing.T) {
-	tg := testgo(t)
-	defer tg.cleanup()
-
-	// setenv variables for test and defer resetting them.
-	tg.setenv("GOPATH", "")
-	tmp, err := ioutil.TempDir("", "")
-	if err != nil {
-		t.Fatalf("could not create tmp home: %v", err)
-	}
-	defer os.RemoveAll(tmp)
-	if err := os.Mkdir(filepath.Join(tmp, "go"), 0777); err != nil {
-		t.Fatalf("could not create $HOME/go: %v", err)
-	}
-	tg.setenv(homeEnvName(), tmp)
-
-	const pkg = "github.com/golang/example/hello"
-	tg.runFail("install", pkg)
-
-	pkgPath := filepath.Join(strings.Split(pkg, "/")...)
-	want := fmt.Sprintf("can't load package: package %s: cannot find package \"%s\" in any of:", pkg, pkg) +
-		fmt.Sprintf("\n\t%s (from $GOROOT)", filepath.Join(runtime.GOROOT(), "src", pkgPath)) +
-		fmt.Sprintf("\n\t%s (from $GOPATH)", filepath.Join(tmp, "go", "src", pkgPath))
-
-	got := strings.TrimSpace(tg.getStderr())
-	if got != want {
-		t.Errorf("got %q; wants %q", got, want)
+	tg.runFail("install", "foo/quxx")
+	if tg.grepCountBoth(`\(\$GOPATH not set\. For more details see: 'go help gopath'\)$`) != 1 {
+		t.Error(`go install foo/quxx expected error: ($GOPATH not set. For more details see: 'go help gopath')`)
 	}
 }
 
@@ -2073,7 +1924,9 @@ func TestCaseCollisions(t *testing.T) {
 
 // Issue 8181.
 func TestGoGetDashTIssue8181(t *testing.T) {
-	testenv.MustHaveExternalNetwork(t)
+	if testing.Short() {
+		t.Skip("skipping test that uses network in short mode")
+	}
 
 	tg := testgo(t)
 	defer tg.cleanup()
@@ -2087,7 +1940,9 @@ func TestGoGetDashTIssue8181(t *testing.T) {
 
 func TestIssue11307(t *testing.T) {
 	// go get -u was not working except in checkout directory
-	testenv.MustHaveExternalNetwork(t)
+	if testing.Short() {
+		t.Skip("skipping test that uses network in short mode")
+	}
 
 	tg := testgo(t)
 	defer tg.cleanup()
@@ -2355,9 +2210,8 @@ func TestCgoPkgConfig(t *testing.T) {
 	tg.parallel()
 
 	tg.run("env", "PKG_CONFIG")
-	pkgConfig := strings.TrimSpace(tg.getStdout())
-	if out, err := exec.Command(pkgConfig, "--atleast-pkgconfig-version", "0.24").CombinedOutput(); err != nil {
-		t.Skipf("%s --atleast-pkgconfig-version 0.24: %v\n%s", pkgConfig, err, out)
+	if _, err := exec.LookPath(strings.TrimSpace(tg.getStdout())); err != nil {
+		t.Skip("skipping because pkg-config could not be found")
 	}
 
 	// OpenBSD's pkg-config is strict about whitespace and only
@@ -3588,12 +3442,6 @@ func TestGoEnv(t *testing.T) {
 	tg.setenv("CGO_CFLAGS", "-foobar")
 	tg.run("env", "CGO_CFLAGS")
 	tg.grepStdout("^-foobar$", "CGO_CFLAGS not honored")
-
-	tg.setenv("CC", "gcc -fmust -fgo -ffaster")
-	tg.run("env", "CC")
-	tg.grepStdout("gcc", "CC not found")
-	tg.run("env", "GOGCCFLAGS")
-	tg.grepStdout("-ffaster", "CC arguments not found")
 }
 
 const (
@@ -3718,28 +3566,3 @@ func TestLinkXImportPathEscape(t *testing.T) {
 		tg.t.Fatal(`incorrect output: expected "linkXworked\n"`)
 	}
 }
-
-// Issue 18044.
-func TestLdBindNow(t *testing.T) {
-	tg := testgo(t)
-	defer tg.cleanup()
-	tg.parallel()
-	tg.setenv("LD_BIND_NOW", "1")
-	tg.run("help")
-}
-
-// Issue 18225.
-// This is really a cmd/asm issue but this is a convenient place to test it.
-func TestConcurrentAsm(t *testing.T) {
-	tg := testgo(t)
-	defer tg.cleanup()
-	tg.parallel()
-	asm := `DATA ·constants<>+0x0(SB)/8,$0
-GLOBL ·constants<>(SB),8,$8
-`
-	tg.tempFile("go/src/p/a.s", asm)
-	tg.tempFile("go/src/p/b.s", asm)
-	tg.tempFile("go/src/p/p.go", `package p`)
-	tg.setenv("GOPATH", tg.path("go"))
-	tg.run("build", "p")
-}

src/cmd/go/help.go

@@ -289,11 +289,8 @@ On Unix, the value is a colon-separated string.
 On Windows, the value is a semicolon-separated string.
 On Plan 9, the value is a list.
 
-If the environment variable is unset, GOPATH defaults
-to a subdirectory named "go" in the user's home directory
-($HOME/go on Unix, %USERPROFILE%\go on Windows),
-unless that directory holds a Go distribution.
-Run "go env GOPATH" to see the current GOPATH.
+GOPATH must be set to get, build and install packages outside the
+standard Go tree.
 
 Each directory listed in GOPATH must have a prescribed structure:
 
@@ -321,9 +318,9 @@ of DIR/bin. GOBIN must be an absolute path.
 
 Here's an example directory layout:
 
-    GOPATH=/home/user/go
+    GOPATH=/home/user/gocode
 
-    /home/user/go/
+    /home/user/gocode/
         src/
             foo/
                 bar/               (go code in package bar)
@@ -349,7 +346,7 @@ Code in or below a directory named "internal" is importable only
 by code in the directory tree rooted at the parent of "internal".
 Here's an extended version of the directory layout above:
 
-    /home/user/go/
+    /home/user/gocode/
         src/
             crash/
                 bang/              (go code in package bang)
@@ -387,7 +384,7 @@ Here's the example from the previous section,
 but with the "internal" directory renamed to "vendor"
 and a new foo/vendor/crash/bang directory added:
 
-    /home/user/go/
+    /home/user/gocode/
         src/
             crash/
                 bang/              (go code in package bang)

src/cmd/go/main.go

@@ -115,7 +115,6 @@ func setExitStatus(n int) {
 }
 
 var origEnv []string
-var newEnv []envVar
 
 func main() {
 	_ = go11tag
@@ -136,7 +135,7 @@ func main() {
 	// Diagnose common mistake: GOPATH==GOROOT.
 	// This setting is equivalent to not setting GOPATH at all,
 	// which is not what most people want when they do it.
-	if gopath := buildContext.GOPATH; gopath == runtime.GOROOT() {
+	if gopath := os.Getenv("GOPATH"); gopath == runtime.GOROOT() {
 		fmt.Fprintf(os.Stderr, "warning: GOPATH set to GOROOT (%s) has no effect\n", gopath)
 	} else {
 		for _, p := range filepath.SplitList(gopath) {
@@ -165,8 +164,7 @@ func main() {
 	// but in practice there might be skew
 	// This makes sure we all agree.
 	origEnv = os.Environ()
-	newEnv = mkEnv()
-	for _, env := range newEnv {
+	for _, env := range mkEnv() {
 		if os.Getenv(env.name) != env.value {
 			os.Setenv(env.name, env.value)
 		}

src/cmd/go/pkg.go

@@ -178,9 +178,7 @@ func (p *Package) copyBuild(pp *build.Package) {
 	p.CgoCXXFLAGS = pp.CgoCXXFLAGS
 	p.CgoLDFLAGS = pp.CgoLDFLAGS
 	p.CgoPkgConfig = pp.CgoPkgConfig
-	// We modify p.Imports in place, so make copy now.
-	p.Imports = make([]string, len(pp.Imports))
-	copy(p.Imports, pp.Imports)
+	p.Imports = pp.Imports
 	p.TestGoFiles = pp.TestGoFiles
 	p.TestImports = pp.TestImports
 	p.XTestGoFiles = pp.XTestGoFiles
@@ -373,8 +371,10 @@ func loadImport(path, srcDir string, parent *Package, stk *importStack, importPo
 			err = fmt.Errorf("code in directory %s expects import %q", bp.Dir, bp.ImportComment)
 		}
 		p.load(stk, bp, err)
-		if p.Error != nil && p.Error.Pos == "" {
-			p = setErrorPos(p, importPos)
+		if p.Error != nil && p.Error.Pos == "" && len(importPos) > 0 {
+			pos := importPos[0]
+			pos.Filename = shortPath(pos.Filename)
+			p.Error.Pos = pos.String()
 		}
 
 		if origPath != cleanImport(origPath) {
@@ -388,11 +388,11 @@ func loadImport(path, srcDir string, parent *Package, stk *importStack, importPo
 
 	// Checked on every import because the rules depend on the code doing the importing.
 	if perr := disallowInternal(srcDir, p, stk); perr != p {
-		return setErrorPos(perr, importPos)
+		return perr
 	}
 	if mode&useVendor != 0 {
 		if perr := disallowVendor(srcDir, origPath, p, stk); perr != p {
-			return setErrorPos(perr, importPos)
+			return perr
 		}
 	}
 
@@ -402,7 +402,12 @@ func loadImport(path, srcDir string, parent *Package, stk *importStack, importPo
 			ImportStack: stk.copy(),
 			Err:         fmt.Sprintf("import %q is a program, not an importable package", path),
 		}
-		return setErrorPos(&perr, importPos)
+		if len(importPos) > 0 {
+			pos := importPos[0]
+			pos.Filename = shortPath(pos.Filename)
+			perr.Error.Pos = pos.String()
+		}
+		return &perr
 	}
 
 	if p.local && parent != nil && !parent.local {
@@ -411,21 +416,17 @@ func loadImport(path, srcDir string, parent *Package, stk *importStack, importPo
 			ImportStack: stk.copy(),
 			Err:         fmt.Sprintf("local import %q in non-local package", path),
 		}
-		return setErrorPos(&perr, importPos)
+		if len(importPos) > 0 {
+			pos := importPos[0]
+			pos.Filename = shortPath(pos.Filename)
+			perr.Error.Pos = pos.String()
+		}
+		return &perr
 	}
 
 	return p
 }
 
-func setErrorPos(p *Package, importPos []token.Position) *Package {
-	if len(importPos) > 0 {
-		pos := importPos[0]
-		pos.Filename = shortPath(pos.Filename)
-		p.Error.Pos = pos.String()
-	}
-	return p
-}
-
 func cleanImport(path string) string {
 	orig := path
 	path = pathpkg.Clean(path)
@@ -585,11 +586,6 @@ func disallowInternal(srcDir string, p *Package, stk *importStack) *Package {
 		return p
 	}
 
-	// We can't check standard packages with gccgo.
-	if buildContext.Compiler == "gccgo" && p.Standard {
-		return p
-	}
-
 	// The stack includes p.ImportPath.
 	// If that's the only thing on the stack, we started
 	// with a name given on the command line, not an
@@ -1638,7 +1634,7 @@ func computeBuildID(p *Package) {
 	// Include the content of runtime/internal/sys/zversion.go in the hash
 	// for package runtime. This will give package runtime a
 	// different build ID in each Go release.
-	if p.Standard && p.ImportPath == "runtime/internal/sys" && buildContext.Compiler != "gccgo" {
+	if p.Standard && p.ImportPath == "runtime/internal/sys" {
 		data, err := ioutil.ReadFile(filepath.Join(p.Dir, "zversion.go"))
 		if err != nil {
 			fatalf("go: %s", err)

src/cmd/go/test.go

@@ -13,6 +13,7 @@ import (
 	"go/doc"
 	"go/parser"
 	"go/token"
+	"io"
 	"os"
 	"os/exec"
 	"path"
@@ -1121,8 +1122,12 @@ func (b *builder) runTest(a *action) error {
 	cmd.Env = envForDir(cmd.Dir, origEnv)
 	var buf bytes.Buffer
 	if testStreamOutput {
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
+		// The only way to keep the ordering of the messages and still
+		// intercept its contents. os/exec will share the same Pipe for
+		// both Stdout and Stderr when running the test program.
+		mw := io.MultiWriter(os.Stdout, &buf)
+		cmd.Stdout = mw
+		cmd.Stderr = mw
 	} else {
 		cmd.Stdout = &buf
 		cmd.Stderr = &buf
@@ -1187,7 +1192,7 @@ func (b *builder) runTest(a *action) error {
 	t := fmt.Sprintf("%.3fs", time.Since(t0).Seconds())
 	if err == nil {
 		norun := ""
-		if testShowPass {
+		if testShowPass && !testStreamOutput {
 			a.testOutput.Write(out)
 		}
 		if bytes.HasPrefix(out, noTestsToRun[1:]) || bytes.Contains(out, noTestsToRun) {
@@ -1199,7 +1204,9 @@ func (b *builder) runTest(a *action) error {
 
 	setExitStatus(1)
 	if len(out) > 0 {
-		a.testOutput.Write(out)
+		if !testStreamOutput {
+			a.testOutput.Write(out)
+		}
 		// assume printing the test binary's exit status is superfluous
 	} else {
 		fmt.Fprintf(a.testOutput, "%s\n", err)

src/cmd/go/testdata/src/dupload/dupload.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	_ "dupload/p2"
+	_"dupload/p2"
 	_ "p"
 )