[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>

.gitignore

@@ -18,28 +18,28 @@ _cgo_*
 _obj
 _test
 _testmain.go
+build.out
+test.out
+doc/articles/wiki/*.bin
+misc/cgo/life/run.out
+misc/cgo/stdio/run.out
+misc/cgo/testso/main
+src/cmd/cgo/zdefaultcc.go
+src/cmd/go/zdefaultcc.go
+src/cmd/go/zosarch.go
+src/cmd/internal/obj/zbootstrap.go
+src/go/build/zcgo.go
+src/go/doc/headscan
+src/runtime/internal/sys/zversion.go
+src/unicode/maketables
+src/*.*/
+test/pass.out
+test/run.out
+test/times.out
+test/garbage/*.out
+goinstall.log
+last-change
+VERSION.cache
 
-/VERSION.cache
-/bin/
-/build.out
-/doc/articles/wiki/*.bin
-/goinstall.log
-/last-change
-/misc/cgo/life/run.out
-/misc/cgo/stdio/run.out
-/misc/cgo/testso/main
-/pkg/
-/src/*.*/
-/src/cmd/cgo/zdefaultcc.go
-/src/cmd/go/zdefaultcc.go
-/src/cmd/go/zosarch.go
-/src/cmd/internal/obj/zbootstrap.go
-/src/go/build/zcgo.go
-/src/go/doc/headscan
-/src/runtime/internal/sys/zversion.go
-/src/unicode/maketables
-/test.out
-/test/garbage/*.out
-/test/pass.out
-/test/run.out
-/test/times.out
+bin/
+pkg/

AUTHORS

@@ -29,13 +29,11 @@ Akshat Kumar <seed@mail.nanosouffle.net>
 Alan Shreve <alan@inconshreveable.com>
 Albert Nigmatzianov <albertnigma@gmail.com>
 Albert Strasheim <fullung@gmail.com>
-Albert Yu <yukinying@gmail.com>
 Alberto Bertogli <albertito@blitiri.com.ar>
 Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Alessandro Arzilli <alessandro.arzilli@gmail.com>
-Alessandro Baffa <alessandro.baffa@gmail.com>
 Alex A Skinner <alex@lx.lc>
 Alex Brainman <alex.brainman@gmail.com>
 Alex Browne <stephenalexbrowne@gmail.com>
@@ -47,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>
@@ -56,7 +53,6 @@ Alexander Surma <surma@surmair.de>
 Alexander Zhavnerchik <alex.vizor@gmail.com>
 Alexander Zolotov <goldifit@gmail.com>
 Alexandre Cesaro <alexandre.cesaro@gmail.com>
-Alexandre Fiori <fiorix@gmail.com>
 Alexandre Normand <alexandre.normand@gmail.com>
 Alexei Sholik <alcosholik@gmail.com>
 Alexey Borzenkov <snaury@gmail.com>
@@ -73,7 +69,6 @@ Andreas Auernhammer <aead@mail.de>
 Andreas Litt <andreas.litt@gmail.com>
 Andrei Korzhevskii <a.korzhevskiy@gmail.com>
 Andrei Vieru <euvieru@gmail.com>
-Andrew Austin <andrewaclt@gmail.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
 Andrew Bursavich <abursavich@gmail.com>
@@ -93,7 +88,6 @@ Andrey Petrov <andrey.petrov@shazow.net>
 Andriy Lytvynov <lytvynov.a.v@gmail.com>
 Andy Balholm <andy@balholm.com>
 Andy Davis <andy@bigandian.com>
-Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Maloney <asmaloney@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -104,8 +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>
-Antonio Bibiano <antbbn@gmail.com>
 Apisak Darakananda <pongad@gmail.com>
 Aram Hăvărneanu <aram@mgk.ro>
 Areski Belaid <areski@gmail.com>
@@ -125,9 +117,7 @@ Aulus Egnatius Varialus <varialus@gmail.com>
 awaw fumin <awawfumin@gmail.com>
 Ayanamist Yang <ayanamist@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
-Baiju Muthukadan <baiju.m.mail@gmail.com>
 Ben Burkert <ben@benburkert.com>
-Ben Lubar <ben.lubar@gmail.com>
 Ben Olive <sionide21@gmail.com>
 Benjamin Black <b@b3k.us>
 Benny Siegert <bsiegert@gmail.com>
@@ -173,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>
@@ -269,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.
@@ -285,7 +273,6 @@ Erik St. Martin <alakriti@gmail.com>
 Erik Westrup <erik.westrup@gmail.com>
 Ernest Chiang <ernest_chiang@htc.com>
 Esko Luontola <esko.luontola@gmail.com>
-Euan Kemp <euank@euank.com>
 Evan Phoenix <evan@phx.io>
 Evan Shaw <chickencha@gmail.com>
 Ewan Chou <coocood@gmail.com>
@@ -341,7 +328,6 @@ Hajime Hoshi <hajimehoshi@gmail.com>
 Hari haran <hariharan.uno@gmail.com>
 Hariharan Srinath <srinathh@gmail.com>
 Harley Laue <losinggeneration@gmail.com>
-Harry Moreno <morenoh149@gmail.com>
 Harshavardhana <hrshvardhana@gmail.com>
 Håvard Haugen <havard.haugen@gmail.com>
 Hector Chu <hectorchu@gmail.com>
@@ -409,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>
@@ -444,8 +429,6 @@ Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Wills <runningwild@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
 Joonas Kuorilehto <joneskoo@derbian.fi>
-Joop Kiefte <ikojba@gmail.com> <joop@kiefte.net>
-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>
@@ -467,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>
@@ -511,15 +492,12 @@ Luigi Riefolo <luigi.riefolo@gmail.com>
 Luit van Drongelen <luitvd@gmail.com>
 Luka Zakrajšek <tr00.g33k@gmail.com>
 Luke Curley <qpingu@gmail.com>
-Maksym Trykur <maksym.trykur@gmail.com>
 Mal Curtis <mal@mal.co.nz>
 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>
@@ -557,8 +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>
-Matthieu Olivier <olivier.matthieu@gmail.com>
-Max Riveiro <kavu13@gmail.com>
 Maxim Khitrov <max@mxcrypt.com>
 Maxwell Krohn <themax@gmail.com>
 MediaMath, Inc
@@ -623,7 +599,6 @@ Nicholas Presta <nick@nickpresta.ca> <nick1presta@gmail.com>
 Nicholas Sullivan <nicholas.sullivan@gmail.com>
 Nicholas Waples <nwaples@gmail.com>
 Nick Craig-Wood <nick@craig-wood.com> <nickcw@gmail.com>
-Nick Leli <nicholasleli@gmail.com>
 Nick Patavalis <nick.patavalis@gmail.com>
 Nick Petroni <npetroni@cs.umd.edu>
 Nicolas Kaiser <nikai@nikai.net>
@@ -631,12 +606,10 @@ Nicolas Owens <mischief@offblast.org>
 Nicolas S. Dade <nic.dade@gmail.com>
 Niels Widger <niels.widger@gmail.com>
 Nigel Kerr <nigel.kerr@gmail.com>
-Nik Nyby <nnyby@columbia.edu>
 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>
@@ -657,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>
@@ -701,11 +673,9 @@ Quentin Perez <qperez@ocs.online.net>
 Quoc-Viet Nguyen <afelion@gmail.com>
 RackTop Systems Inc.
 Radu Berinde <radu@cockroachlabs.com>
-Rafal Jeczalik <rjeczalik@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
 Rajat Goel <rajat.goel2010@gmail.com>
 Ralph Corderoy <ralph@inputplus.co.uk>
-Raphael Geronimi <raphael.geronimi@gmail.com>
 Red Hat, Inc.
 Reinaldo de Souza Jr <juniorz@gmail.com>
 Rémy Oudompheng <oudomphe@phare.normalesup.org>
@@ -736,12 +706,10 @@ Ron Minnich <rminnich@gmail.com>
 Ross Light <rlight2@gmail.com>
 Rowan Worth <sqweek@gmail.com>
 Russell Haering <russellhaering@gmail.com>
-Ryan Bagwell <ryanbagwell@outlook.com>
 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>
@@ -776,7 +744,6 @@ Simon Whitehead <chemnova@gmail.com>
 Sina Siadat <siadat@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Song Gao <song@gao.io>
-Sourcegraph Inc
 Spencer Nelson <s@spenczar.com>
 Spring Mc <heresy.mc@gmail.com>
 Square, Inc.
@@ -800,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>
@@ -814,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>
@@ -833,7 +798,6 @@ Totoro W <tw19881113@gmail.com>
 Travis Cline <travis.cline@gmail.com>
 Trey Lawrence <lawrence.trey@gmail.com>
 Trey Tacon <ttacon@gmail.com>
-Tristan Colgate <tcolgate@gmail.com>
 Tristan Ooohry <ooohry@gmail.com>
 Tudor Golubenco <tudor.g@gmail.com>
 Tuo Shan <sturbo89@gmail.com>
@@ -881,10 +845,8 @@ 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>
 Zorion Arrizabalaga <zorionk@gmail.com>
-Фахриддин Балтаев <faxriddinjon@gmail.com>
 申习之 <bronze1man@gmail.com>

CONTRIBUTING.md

@@ -7,11 +7,6 @@ It is the work of hundreds of contributors. We appreciate your help!
 
 ## Filing issues
 
-General questions should go to the
-[golang-nuts mailing list](https://groups.google.com/group/golang-nuts) or
-[other forum](https://golang.org/wiki/Questions) instead of the issue tracker.
-The gophers there will answer or ask you to file an issue if you've tripped over a bug.
-
 When filing an issue, make sure to answer these five questions:
 
 1. What version of Go are you using (`go version`)?
@@ -20,7 +15,8 @@ When filing an issue, make sure to answer these five questions:
 4. What did you expect to see?
 5. What did you see instead?
 
-For change proposals, see [Proposing Changes To Go](https://github.com/golang/proposal/).
+General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
+The gophers there will answer or ask you to file an issue if you've tripped over a bug.
 
 Sensitive security-related issues should be reported to [security@golang.org](mailto:security@golang.org).
 
@@ -32,7 +28,6 @@ before sending patches.
 **We do not accept GitHub pull requests**
 (we use [an instance](https://go-review.googlesource.com/) of the
 [Gerrit](https://www.gerritcodereview.com/) code review system instead).
-Also, please do not post patches on the issue tracker.
 
 Unless otherwise noted, the Go source files are distributed under
 the BSD-style license found in the LICENSE file.

CONTRIBUTORS

@@ -55,13 +55,11 @@ Alan Donovan <adonovan@google.com>
 Alan Shreve <alan@inconshreveable.com>
 Albert Nigmatzianov <albertnigma@gmail.com>
 Albert Strasheim <fullung@gmail.com>
-Albert Yu <yukinying@gmail.com>
 Alberto Bertogli <albertito@blitiri.com.ar>
 Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Alessandro Arzilli <alessandro.arzilli@gmail.com>
-Alessandro Baffa <alessandro.baffa@gmail.com>
 Alex A Skinner <alex@lx.lc>
 Alex Brainman <alex.brainman@gmail.com>
 Alex Bramley <abramley@google.com>
@@ -75,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>
@@ -84,7 +81,6 @@ Alexander Surma <surma@surmair.de>
 Alexander Zhavnerchik <alex.vizor@gmail.com>
 Alexander Zolotov <goldifit@gmail.com>
 Alexandre Cesaro <alexandre.cesaro@gmail.com>
-Alexandre Fiori <fiorix@gmail.com>
 Alexandre Normand <alexandre.normand@gmail.com>
 Alexandru Moșoi <brtzsnr@gmail.com>
 Alexei Sholik <alcosholik@gmail.com>
@@ -105,7 +101,6 @@ Andreas Litt <andreas.litt@gmail.com>
 Andrei Korzhevskii <a.korzhevskiy@gmail.com>
 Andrei Vieru <euvieru@gmail.com>
 Andres Erbsen <andreser@google.com>
-Andrew Austin <andrewaclt@gmail.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
 Andrew Bursavich <abursavich@gmail.com>
@@ -128,7 +123,6 @@ Andrey Petrov <andrey.petrov@shazow.net>
 Andriy Lytvynov <lytvynov.a.v@gmail.com>
 Andy Balholm <andy@balholm.com>
 Andy Davis <andy@bigandian.com>
-Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Maloney <asmaloney@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -139,8 +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 Bibiano <antbbn@gmail.com>
 Antonio Murdaca <runcom@redhat.com>
 Apisak Darakananda <pongad@gmail.com>
 Aram Hăvărneanu <aram@mgk.ro>
@@ -163,12 +155,10 @@ Austin Clements <austin@google.com> <aclements@csail.mit.edu>
 awaw fumin <awawfumin@gmail.com>
 Ayanamist Yang <ayanamist@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
-Baiju Muthukadan <baiju.m.mail@gmail.com>
 Balazs Lecz <leczb@google.com>
 Ben Burkert <ben@benburkert.com>
 Ben Eitzen <eitzenb@golang.org>
 Ben Fried <ben.fried@gmail.com>
-Ben Lubar <ben.lubar@gmail.com>
 Ben Lynn <benlynn@gmail.com>
 Ben Olive <sionide21@gmail.com>
 Benjamin Black <b@b3k.us>
@@ -243,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>
@@ -316,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>
@@ -372,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>
@@ -392,7 +379,6 @@ Ernest Chiang <ernest_chiang@htc.com>
 Esko Luontola <esko.luontola@gmail.com>
 Ethan Burns <eaburns@google.com>
 Ethan Miller <eamiller@us.ibm.com>
-Euan Kemp <euank@euank.com>
 Evan Broder <evan@stripe.com>
 Evan Brown <evanbrown@google.com>
 Evan Kroske <evankroske@google.com>
@@ -463,7 +449,6 @@ Han-Wen Nienhuys <hanwen@google.com>
 Hari haran <hariharan.uno@gmail.com>
 Hariharan Srinath <srinathh@gmail.com>
 Harley Laue <losinggeneration@gmail.com>
-Harry Moreno <morenoh149@gmail.com>
 Harshavardhana <hrshvardhana@gmail.com>
 Håvard Haugen <havard.haugen@gmail.com>
 Hector Chu <hectorchu@gmail.com>
@@ -485,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>
@@ -534,7 +518,6 @@ Jan Ziak <0xe2.0x9a.0x9b@gmail.com>
 Jani Monoses <jani.monoses@ubuntu.com> <jani.monoses@gmail.com>
 Jaroslavas Počepko <jp@webmaster.ms>
 Jason Barnett <jason.w.barnett@gmail.com>
-Jason Buberel <jbuberel@google.com>
 Jason Del Ponte <delpontej@gmail.com>
 Jason Hall <jasonhall@google.com>
 Jason Smale <jsmale@zendesk.com>
@@ -554,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>
@@ -604,8 +586,6 @@ Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Wills <runningwild@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
 Joonas Kuorilehto <joneskoo@derbian.fi>
-Joop Kiefte <ikojba@gmail.com> <joop@kiefte.net>
-Jordan Lewis <jordanthelewis@gmail.com>
 Jos Visser <josv@google.com>
 Jose Luis Vázquez González <josvazg@gmail.com>
 Joseph Bonneau <jcb@google.com>
@@ -637,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>
@@ -692,7 +670,6 @@ Luke Curley <qpingu@gmail.com>
 Luna Duclos <luna.duclos@palmstonegames.com>
 Luuk van Dijk <lvd@golang.org> <lvd@google.com>
 Lynn Boger <laboger@linux.vnet.ibm.com>
-Maksym Trykur <maksym.trykur@gmail.com>
 Mal Curtis <mal@mal.co.nz>
 Manfred Touron <m@42.am>
 Manoj Dayaram <platform-dev@moovweb.com> <manoj.dayaram@moovweb.com>
@@ -701,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>
@@ -720,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>
@@ -749,8 +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>
-Matthieu Olivier <olivier.matthieu@gmail.com>
-Max Riveiro <kavu13@gmail.com>
 Maxim Khitrov <max@mxcrypt.com>
 Maxim Pimenov <mpimenov@google.com>
 Maxim Ushakov <ushakov@google.com>
@@ -834,7 +806,6 @@ Nicholas Waples <nwaples@gmail.com>
 Nick Cooper <nmvc@google.com>
 Nick Craig-Wood <nick@craig-wood.com> <nickcw@gmail.com>
 Nick Harper <nharper@google.com>
-Nick Leli <nicholasleli@gmail.com>
 Nick Patavalis <nick.patavalis@gmail.com>
 Nick Petroni <npetroni@cs.umd.edu>
 Nicolas Kaiser <nikai@nikai.net>
@@ -843,13 +814,11 @@ Nicolas S. Dade <nic.dade@gmail.com>
 Niels Widger <niels.widger@gmail.com>
 Nigel Kerr <nigel.kerr@gmail.com>
 Nigel Tao <nigeltao@golang.org>
-Nik Nyby <nnyby@columbia.edu>
 Niko Dziemba <niko@dziemba.com>
 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>
@@ -868,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>
@@ -926,19 +894,15 @@ Quan Tran <qeed.quan@gmail.com>
 Quan Yong Zhai <qyzhai@gmail.com>
 Quentin Perez <qperez@ocs.online.net>
 Quentin Smith <quentin@golang.org>
-Quinn Slack <sqs@sourcegraph.com>
 Quoc-Viet Nguyen <afelion@gmail.com>
 Radu Berinde <radu@cockroachlabs.com>
-Rafal Jeczalik <rjeczalik@gmail.com>
 Rahul Chaudhry <rahulchaudhry@chromium.org>
 Raif S. Naffah <go@naffah-raif.name>
 Rajat Goel <rajat.goel2010@gmail.com>
 Ralph Corderoy <ralph@inputplus.co.uk>
 Ramesh Dharan <dharan@google.com>
 Raph Levien <raph@google.com>
-Raphael Geronimi <raphael.geronimi@gmail.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>
@@ -979,14 +943,12 @@ Rowan Worth <sqweek@gmail.com>
 Rui Ueyama <ruiu@google.com>
 Russ Cox <rsc@golang.org>
 Russell Haering <russellhaering@gmail.com>
-Ryan Bagwell <ryanbagwell@outlook.com>
 Ryan Barrett <ryanb@google.com>
 Ryan Brown <ribrdb@google.com>
 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>
@@ -1050,7 +1012,6 @@ Stéphane Travostino <stephane.travostino@gmail.com>
 Stephen Ma <stephenm@golang.org>
 Stephen McQuay <stephen@mcquay.me>
 Stephen Weinberg <stephen@q5comm.com>
-Steve Francia <spf@golang.org>
 Steve McCoy <mccoyst@gmail.com>
 Steve Newman <snewman@google.com>
 Steve Phillips <elimisteve@gmail.com>
@@ -1068,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>
@@ -1084,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>
@@ -1113,7 +1072,6 @@ Trevor Strohman <trevor.strohman@gmail.com>
 Trey Lawrence <lawrence.trey@gmail.com>
 Trey Tacon <ttacon@gmail.com>
 Tristan Amini <tamini01@ca.ibm.com>
-Tristan Colgate <tcolgate@gmail.com>
 Tristan Ooohry <ooohry@gmail.com>
 Tudor Golubenco <tudor.g@gmail.com>
 Tuo Shan <sturbo89@gmail.com> <shantuo@google.com>
@@ -1174,10 +1132,8 @@ 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>
 Zorion Arrizabalaga <zorionk@gmail.com>
-Фахриддин Балтаев <faxriddinjon@gmail.com>
 申习之 <bronze1man@gmail.com>

VERSION

@@ -1 +0,0 @@
-go1.8rc1

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

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/asm.html

@@ -838,44 +838,6 @@ It is a scaled mode as on the x86, but the only scale allowed is <code>1</code>.
 
 </ul>
 
-<h3 id="mips">MIPS, MIPS64</h3>
-
-<p>
-General purpose registers are named <code>R0</code> through <code>R31</code>,
-floating point registers are <code>F0</code> through <code>F31</code>.
-</p>
-
-<p>
-<code>R30</code> is reserved to point to <code>g</code>.
-<code>R23</code> is used as a temporary register.
-</p>
-
-<p>
-In a <code>TEXT</code> directive, the frame size <code>$-4</code> for MIPS or
-<code>$-8</code> for MIPS64 instructs the linker not to save <code>LR</code>.
-</p>
-
-<p>
-<code>SP</code> refers to the virtual stack pointer.
-For the hardware register, use <code>R29</code>.
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>16(R1)</code>: The location at <code>R1</code> plus 16.
-</li>
-
-<li>
-<code>(R1)</code>: Alias for <code>0(R1)</code>.
-</li>
-
-</ul>
-
 <h3 id="unsupported_opcodes">Unsupported opcodes</h3>
 
 <p>

doc/code.html

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

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>
-$ <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,
@@ -313,10 +325,16 @@ environment variables under Windows</a>.
 <h2 id="help">Getting help</h2>
 
 <p>
-  For help, see the <a href="/help/">list of Go mailing lists, forums, and places to chat</a>.
+For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
+<a href="http://freenode.net/">Freenode</a> IRC server.
 </p>
 
 <p>
-  Report bugs either by running “<b><code>go</code> <code>bug</code></b>”, or
-  manually at the <a href="https://golang.org/issue">Go issue tracker</a>.
+The official mailing list for discussion of the Go language is
+<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+</p>
+
+<p>
+Report bugs using the
+<a href="//golang.org/issue">Go issue tracker</a>.
 </p>

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)
 	}
 }
 

lib/time/update.bash

@@ -8,8 +8,8 @@
 # Consult http://www.iana.org/time-zones for the latest versions.
 
 # Versions to use.
-CODE=2016j
-DATA=2016j
+CODE=2016i
+DATA=2016i
 
 set -e
 rm -rf work

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,128 +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
-	}
-
-	// Restrict the number of attempts based on RLIMIT_NPROC.
-	// Tediously, RLIMIT_NPROC was left out of the syscall package,
-	// probably because it is not in POSIX.1, so we define it here.
-	// It is not defined on Solaris.
-	var nproc int
-	setNproc := true
-	switch runtime.GOOS {
-	default:
-		setNproc = false
-	case "linux":
-		nproc = 6
-	case "darwin", "dragonfly", "freebsd", "netbsd", "openbsd":
-		nproc = 7
-	}
-	if setNproc {
-		var rlim syscall.Rlimit
-		if syscall.Getrlimit(nproc, &rlim) == nil {
-			max := int(rlim.Cur) / (threads + 5)
-			if attempts > max {
-				t.Logf("lowering attempts from %d to %d for RLIMIT_NPROC", attempts, max)
-				attempts = max
-			}
-		}
-	}
-
-	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/main2.c

@@ -21,7 +21,7 @@ int main(void) {
 
   // The descriptor will be initialized in a thread, so we have to
   // give a chance to get opened.
-  for (i = 0; i < 1000; i++) {
+  for (i = 0; i < 100; i++) {
     n = read(fd, buf, sizeof buf);
     if (n >= 0)
       break;

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

@@ -24,14 +24,8 @@ msan=yes
 
 TMPDIR=${TMPDIR:-/tmp}
 echo 'int main() { return 0; }' > ${TMPDIR}/testsanitizers$$.c
-if $CC -fsanitize=memory -o ${TMPDIR}/testsanitizers$$ ${TMPDIR}/testsanitizers$$.c 2>&1 | grep "unrecognized" >& /dev/null; then
-  echo "skipping msan tests: $CC -fsanitize=memory not supported"
-  msan=no
-elif ! test -x ${TMPDIR}/testsanitizers$$; then
-  echo "skipping msan tests: $CC -fsanitize-memory did not generate an executable"
-  msan=no
-elif ! ${TMPDIR}/testsanitizers$$ >/dev/null 2>&1; then
-  echo "skipping msan tests: $CC -fsanitize-memory generates broken executable"
+if $CC -fsanitize=memory -c ${TMPDIR}/testsanitizers$$.c -o ${TMPDIR}/testsanitizers$$.o 2>&1 | grep "unrecognized" >& /dev/null; then
+  echo "skipping msan tests: -fsanitize=memory not supported"
   msan=no
 fi
 rm -f ${TMPDIR}/testsanitizers$$.*
@@ -150,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,67 +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, and the Go signal handler
-// was not preserving callee-saved registers from C callers.
-
-/*
-#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;
-	void *prev = NULL, *cur;
-
-	gettimeofday(&tvstart, NULL);
-	for (n = 0; n < 1<<20; n++) {
-		cur = malloc(n);
-		free(prev);
-		prev = cur;
-
-		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;
-		}
-	}
-
-	free(prev);
-}
-*/
-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,18 +7,6 @@ import (
 	"runtime"
 )
 
-// Having a function declared in the main package triggered
-// golang.org/issue/18250
-func DeclaredInMain() {
-}
-
-type C struct {
-}
-
-func F() *C {
-	return nil
-}
-
 func main() {
 	defer depBase.ImplementedInAsm()
 	// This code below causes various go.itab.* symbols to be generated in
@@ -27,9 +15,4 @@ func main() {
 	reflect.TypeOf(os.Stdout).Elem()
 	runtime.GC()
 	depBase.V = depBase.F() + 1
-
-	var c *C
-	if reflect.TypeOf(F).Out(0) != reflect.TypeOf(c) {
-		panic("bad reflection results, see golang.org/issue/18252")
-	}
 }

misc/ios/clangwrap.sh

@@ -17,4 +17,4 @@ else
 	exit 1
 fi
 
-exec $CLANG -arch $CLANGARCH -isysroot $SDK_PATH -mios-version-min=6.0 "$@"
+exec $CLANG -arch $CLANGARCH -isysroot $SDK_PATH "$@"

src/archive/zip/reader.go

@@ -13,6 +13,7 @@ import (
 	"hash/crc32"
 	"io"
 	"os"
+	"time"
 )
 
 var (
@@ -289,13 +290,16 @@ func readDirectoryHeader(f *File, r io.Reader) error {
 		// Other zip authors might not even follow the basic format,
 		// and we'll just ignore the Extra content in that case.
 		b := readBuf(f.Extra)
+
+	Extras:
 		for len(b) >= 4 { // need at least tag and size
 			tag := b.uint16()
 			size := b.uint16()
 			if int(size) > len(b) {
 				break
 			}
-			if tag == zip64ExtraId {
+			switch tag {
+			case zip64ExtraId:
 				// update directory values from the zip64 extra block.
 				// They should only be consulted if the sizes read earlier
 				// are maxed out.
@@ -323,7 +327,42 @@ func readDirectoryHeader(f *File, r io.Reader) error {
 					}
 					f.headerOffset = int64(eb.uint64())
 				}
-				break
+				break Extras
+
+			case ntfsExtraId:
+				if size == 32 {
+					eb := readBuf(b[:size])
+					eb.uint32() // reserved
+					eb.uint16() // tag1
+					size1 := eb.uint16()
+					if size1 == 24 {
+						sub := readBuf(eb[:size1])
+						lo := sub.uint32()
+						hi := sub.uint32()
+						tick := (uint64(uint64(lo)|uint64(hi)<<32) - 116444736000000000) / 10000000
+						f.SetModTime(time.Unix(int64(tick), 0))
+					}
+				}
+				break Extras
+
+			case unixExtraId:
+				if size >= 12 {
+					eb := readBuf(b[:size])
+					eb.uint32()          // AcTime
+					epoch := eb.uint32() // ModTime
+					f.SetModTime(time.Unix(int64(epoch), 0))
+					break Extras
+				}
+			case exttsExtraId:
+				if size >= 3 {
+					eb := readBuf(b[:size])
+					flags := eb.uint8()  // Flags
+					epoch := eb.uint32() // AcTime/ModTime/CrTime
+					if flags&1 != 0 {
+						f.SetModTime(time.Unix(int64(epoch), 0))
+					}
+					break Extras
+				}
 			}
 			b = b[size:]
 		}
@@ -508,6 +547,12 @@ func findSignatureInBlock(b []byte) int {
 
 type readBuf []byte
 
+func (b *readBuf) uint8() uint8 {
+	v := uint8((*b)[0])
+	*b = (*b)[1:]
+	return v
+}
+
 func (b *readBuf) uint16() uint16 {
 	v := binary.LittleEndian.Uint16(*b)
 	*b = (*b)[2:]

src/archive/zip/reader_test.go

@@ -65,13 +65,13 @@ var tests = []ZipTest{
 			{
 				Name:    "test.txt",
 				Content: []byte("This is a test text file.\n"),
-				Mtime:   "09-05-10 12:12:02",
+				Mtime:   "09-05-10 02:12:00",
 				Mode:    0644,
 			},
 			{
 				Name:  "gophercolor16x16.png",
 				File:  "gophercolor16x16.png",
-				Mtime: "09-05-10 15:52:58",
+				Mtime: "09-05-10 05:52:58",
 				Mode:  0644,
 			},
 		},
@@ -83,13 +83,13 @@ var tests = []ZipTest{
 			{
 				Name:    "test.txt",
 				Content: []byte("This is a test text file.\n"),
-				Mtime:   "09-05-10 12:12:02",
+				Mtime:   "09-05-10 02:12:00",
 				Mode:    0644,
 			},
 			{
 				Name:  "gophercolor16x16.png",
 				File:  "gophercolor16x16.png",
-				Mtime: "09-05-10 15:52:58",
+				Mtime: "09-05-10 05:52:58",
 				Mode:  0644,
 			},
 		},
@@ -144,6 +144,17 @@ var tests = []ZipTest{
 		Name: "unix.zip",
 		File: crossPlatform,
 	},
+	{
+		Name: "extra-timestamp.zip",
+		File: []ZipTestFile{
+			{
+				Name:    "hello.txt",
+				Content: []byte(""),
+				Mtime:   "01-06-16 12:25:56",
+				Mode:    0666,
+			},
+		},
+	},
 	{
 		// created by Go, before we wrote the "optional" data
 		// descriptor signatures (which are required by OS X)
@@ -152,13 +163,13 @@ var tests = []ZipTest{
 			{
 				Name:    "foo.txt",
 				Content: []byte("foo\n"),
-				Mtime:   "03-08-12 16:59:10",
+				Mtime:   "03-09-12 00:59:10",
 				Mode:    0644,
 			},
 			{
 				Name:    "bar.txt",
 				Content: []byte("bar\n"),
-				Mtime:   "03-08-12 16:59:12",
+				Mtime:   "03-09-12 00:59:12",
 				Mode:    0644,
 			},
 		},
@@ -205,13 +216,13 @@ var tests = []ZipTest{
 			{
 				Name:    "foo.txt",
 				Content: []byte("foo\n"),
-				Mtime:   "03-08-12 16:59:10",
+				Mtime:   "03-09-12 00:59:10",
 				Mode:    0644,
 			},
 			{
 				Name:    "bar.txt",
 				Content: []byte("bar\n"),
-				Mtime:   "03-08-12 16:59:12",
+				Mtime:   "03-09-12 00:59:12",
 				Mode:    0644,
 			},
 		},
@@ -225,14 +236,14 @@ var tests = []ZipTest{
 			{
 				Name:       "foo.txt",
 				Content:    []byte("foo\n"),
-				Mtime:      "03-08-12 16:59:10",
+				Mtime:      "03-09-12 00:59:10",
 				Mode:       0644,
 				ContentErr: ErrChecksum,
 			},
 			{
 				Name:    "bar.txt",
 				Content: []byte("bar\n"),
-				Mtime:   "03-08-12 16:59:12",
+				Mtime:   "03-09-12 00:59:12",
 				Mode:    0644,
 			},
 		},

src/archive/zip/struct.go

@@ -63,6 +63,9 @@ const (
 
 	// extra header id's
 	zip64ExtraId = 0x0001 // zip64 Extended Information Extra Field
+	ntfsExtraId  = 0x000a // NTFS Extra Field
+	unixExtraId  = 0x000d // UNIX Extra Field
+	exttsExtraId = 0x5455 // Extended Timestamp Extra Field
 )
 
 // FileHeader describes a file within a zip file.

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 {
@@ -103,6 +99,18 @@ func (w *Writer) Close() error {
 			b.uint32(h.UncompressedSize)
 		}
 
+		// use Extended Timestamp Extra Field.
+		if h.ModifiedTime != 0 || h.ModifiedDate != 0 {
+			mt := uint32(h.ModTime().Unix())
+			var mbuf [9]byte // 2x uint16 + uint8 + uint32
+			eb := writeBuf(mbuf[:])
+			eb.uint16(exttsExtraId)
+			eb.uint16(5)  // size = uint8 + uint32
+			eb.uint8(1)   // flags = modtime
+			eb.uint32(mt) // ModTime
+			h.Extra = append(h.Extra, mbuf[:]...)
+		}
+
 		b.uint16(uint16(len(h.Name)))
 		b.uint16(uint16(len(h.Extra)))
 		b.uint16(uint16(len(h.Comment)))
@@ -132,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[:])
 
@@ -385,6 +389,11 @@ func (w nopCloser) Close() error {
 
 type writeBuf []byte
 
+func (b *writeBuf) uint8(v uint8) {
+	(*b)[0] = v
+	*b = (*b)[1:]
+}
+
 func (b *writeBuf) uint16(v uint16) {
 	binary.LittleEndian.PutUint16(*b, v)
 	*b = (*b)[2:]

src/archive/zip/writer_test.go

@@ -11,6 +11,7 @@ import (
 	"math/rand"
 	"os"
 	"testing"
+	"time"
 )
 
 // TODO(adg): a more sophisticated test suite
@@ -20,6 +21,7 @@ type WriteTest struct {
 	Data   []byte
 	Method uint16
 	Mode   os.FileMode
+	Mtime  string
 }
 
 var writeTests = []WriteTest{
@@ -28,30 +30,35 @@ var writeTests = []WriteTest{
 		Data:   []byte("Rabbits, guinea pigs, gophers, marsupial rats, and quolls."),
 		Method: Store,
 		Mode:   0666,
+		Mtime:  "02-01-08 00:01:02",
 	},
 	{
 		Name:   "bar",
 		Data:   nil, // large data set in the test
 		Method: Deflate,
 		Mode:   0644,
+		Mtime:  "03-02-08 01:02:03",
 	},
 	{
 		Name:   "setuid",
 		Data:   []byte("setuid file"),
 		Method: Deflate,
 		Mode:   0755 | os.ModeSetuid,
+		Mtime:  "04-03-08 02:03:04",
 	},
 	{
 		Name:   "setgid",
 		Data:   []byte("setgid file"),
 		Method: Deflate,
 		Mode:   0755 | os.ModeSetgid,
+		Mtime:  "05-04-08 03:04:04",
 	},
 	{
 		Name:   "symlink",
 		Data:   []byte("../link/target"),
 		Method: Deflate,
 		Mode:   0755 | os.ModeSymlink,
+		Mtime:  "03-02-08 11:22:33",
 	},
 }
 
@@ -148,6 +155,11 @@ func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
 	if wt.Mode != 0 {
 		header.SetMode(wt.Mode)
 	}
+	mtime, err := time.Parse("01-02-06 15:04:05", wt.Mtime)
+	if err != nil {
+		t.Fatal("time.Parse:", err)
+	}
+	header.SetModTime(mtime)
 	f, err := w.CreateHeader(header)
 	if err != nil {
 		t.Fatal(err)
@@ -178,6 +190,21 @@ func testReadFile(t *testing.T, f *File, wt *WriteTest) {
 	if !bytes.Equal(b, wt.Data) {
 		t.Errorf("File contents %q, want %q", b, wt.Data)
 	}
+
+	mtime, err := time.Parse("01-02-06 15:04:05", wt.Mtime)
+	if err != nil {
+		t.Fatal("time.Parse:", err)
+	}
+
+	diff := mtime.Sub(f.ModTime())
+	if diff < 0 {
+		diff = -diff
+	}
+
+	// allow several time span
+	if diff > 5*time.Second {
+		t.Errorf("File modtime %v, want %v", mtime, f.ModTime())
+	}
 }
 
 func BenchmarkCompressedZipGarbage(b *testing.B) {

src/archive/zip/zip_test.go

@@ -8,13 +8,12 @@ package zip
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"hash"
-	"internal/race"
 	"internal/testenv"
 	"io"
 	"io/ioutil"
+	"reflect"
 	"sort"
 	"strings"
 	"testing"
@@ -113,6 +112,44 @@ func TestFileHeaderRoundTrip64(t *testing.T) {
 	testHeaderRoundTrip(fh, uint32max, fh.UncompressedSize64, t)
 }
 
+func TestZeroFileRoundTrip(t *testing.T) {
+	var b bytes.Buffer
+	w := NewWriter(&b)
+	if _, err := w.Create(""); err != nil {
+		t.Fatal(err)
+	}
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	r, err := NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify that fields that should reasonably be the zero value stays
+	// as the zero value.
+	var want FileHeader
+	if len(r.File) != 1 {
+		t.Fatalf("len(r.File) = %d, want 1", len(r.File))
+	}
+	fh := r.File[0].FileHeader
+	got := FileHeader{
+		Name:               fh.Name,
+		ModifiedTime:       fh.ModifiedTime,
+		ModifiedDate:       fh.ModifiedDate,
+		UncompressedSize:   fh.UncompressedSize,
+		UncompressedSize64: fh.UncompressedSize64,
+		ExternalAttrs:      fh.ExternalAttrs,
+		Comment:            fh.Comment,
+	}
+	if len(fh.Extra) > 0 {
+		got.Extra = fh.Extra
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("FileHeader mismatch:\ngot  %#v\nwant %#v", got, want)
+	}
+}
+
 type repeatedByte struct {
 	off int64
 	b   byte
@@ -234,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)
@@ -244,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.
@@ -255,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)
@@ -593,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)
 	}
 }
 
@@ -680,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/bytes/buffer.go

@@ -23,7 +23,7 @@ type Buffer struct {
 
 // The readOp constants describe the last action performed on
 // the buffer, so that UnreadRune and UnreadByte can check for
-// invalid usage. opReadRuneX constants are chosen such that
+// invalid usage. opReadRuneX constants are choosen such that
 // converted to int they correspond to the rune size that was read.
 type readOp int
 

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/asm_test.go

@@ -175,14 +175,6 @@ func f(b []byte, i int) uint64 {
 	},
 	{"amd64", "linux", `
 import "encoding/binary"
-func f(b []byte, v uint64) {
-	binary.BigEndian.PutUint64(b, v)
-}
-`,
-		[]string{"\tBSWAPQ\t"},
-	},
-	{"amd64", "linux", `
-import "encoding/binary"
 func f(b []byte) uint32 {
 	return binary.BigEndian.Uint32(b)
 }
@@ -194,14 +186,6 @@ import "encoding/binary"
 func f(b []byte, i int) uint32 {
 	return binary.BigEndian.Uint32(b[i:])
 }
-`,
-		[]string{"\tBSWAPL\t"},
-	},
-	{"amd64", "linux", `
-import "encoding/binary"
-func f(b []byte, v uint32) {
-	binary.BigEndian.PutUint32(b, v)
-}
 `,
 		[]string{"\tBSWAPL\t"},
 	},
@@ -221,19 +205,6 @@ func f(b []byte, i int) uint32 {
 `,
 		[]string{"\tMOVL\t\\(.*\\)\\(.*\\*1\\),"},
 	},
-
-	// Structure zeroing.  See issue #18370.
-	{"amd64", "linux", `
-type T struct {
-	a, b, c int
-}
-func f(t *T) {
-	*t = T{}
-}
-`,
-		[]string{"\tMOVQ\t\\$0, \\(.*\\)", "\tMOVQ\t\\$0, 8\\(.*\\)", "\tMOVQ\t\\$0, 16\\(.*\\)"},
-	},
-	// TODO: add a test for *t = T{3,4,5} when we fix that.
 }
 
 // mergeEnvLists merges the two environment lists such that

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

@@ -1000,7 +1000,7 @@ func parName(f *Field, numbered bool) string {
 		Fatalf("invalid symbol name: %s", name)
 	}
 
-	// Functions that can be inlined use numbered parameters so we can distinguish them
+	// Functions that can be inlined use numbered parameters so we can distingish them
 	// from other names in their context after inlining (i.e., the parameter numbering
 	// is a form of parameter rewriting). See issue 4326 for an example and test case.
 	if forceObjFileStability || numbered {

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

@@ -15,7 +15,6 @@ var runtimeDecls = [...]struct {
 	{"panicwrap", funcTag, 7},
 	{"gopanic", funcTag, 9},
 	{"gorecover", funcTag, 12},
-	{"goschedguarded", funcTag, 5},
 	{"printbool", funcTag, 14},
 	{"printfloat", funcTag, 16},
 	{"printint", funcTag, 18},

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

@@ -21,7 +21,6 @@ func panicwrap(string, string, string)
 
 func gopanic(interface{})
 func gorecover(*int32) interface{}
-func goschedguarded()
 
 func printbool(bool)
 func printfloat(float64)

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,13 +1048,12 @@ 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]
 
 	case strings.HasPrefix(text, "go:cgo_"):
-		lineno = p.baseline + int32(line) - 1 // pragcgo may call yyerror
 		pragcgobuf += pragcgo(text)
 		fallthrough // because of //go:cgo_unsafe_args
 	default:
@@ -1063,7 +1061,6 @@ func (p *noder) pragma(pos, line int, text string) syntax.Pragma {
 		if i := strings.Index(text, " "); i >= 0 {
 			verb = verb[:i]
 		}
-		lineno = p.baseline + int32(line) - 1 // pragmaValue may call yyerror
 		return syntax.Pragma(pragmaValue(verb))
 	}
 

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
@@ -998,6 +986,7 @@ func itabname(t, itype *Type) *Node {
 		Fatalf("itabname(%v, %v)", t, itype)
 	}
 	s := Pkglookup(t.tconv(FmtLeft)+","+itype.tconv(FmtLeft), itabpkg)
+	Linksym(s).Set(obj.AttrLocal, true)
 	if s.Def == nil {
 		n := newname(s)
 		n.Type = Types[TUINT8]
@@ -1343,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))
 		}
@@ -1410,15 +1399,15 @@ func dumptypestructs() {
 		// }
 		o := dsymptr(i.sym, 0, dtypesym(i.itype), 0)
 		o = dsymptr(i.sym, o, dtypesym(i.t), 0)
-		o += Widthptr + 8                      // skip link/bad/inhash fields
+		o += Widthptr + 8                      // skip link/bad/unused fields
 		o += len(imethods(i.itype)) * Widthptr // skip fun method pointers
 		// at runtime the itab will contain pointers to types, other itabs and
 		// method functions. None are allocated on heap, so we can use obj.NOPTR.
-		ggloblsym(i.sym, int32(o), int16(obj.DUPOK|obj.NOPTR))
+		ggloblsym(i.sym, int32(o), int16(obj.DUPOK|obj.NOPTR|obj.LOCAL))
 
 		ilink := Pkglookup(i.t.tconv(FmtLeft)+","+i.itype.tconv(FmtLeft), itablinkpkg)
 		dsymptr(ilink, 0, i.sym, 0)
-		ggloblsym(ilink, int32(Widthptr), int16(obj.DUPOK|obj.RODATA))
+		ggloblsym(ilink, int32(Widthptr), int16(obj.DUPOK|obj.RODATA|obj.LOCAL))
 	}
 
 	// process ptabs

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:
@@ -1078,8 +1076,6 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 
 		var r *Node
 		if n.Right != nil {
-			// n.Right is stack temporary used as backing store.
-			init.Append(nod(OAS, n.Right, nil)) // zero backing store, just in case (#18410)
 			r = nod(OADDR, n.Right, nil)
 			r = typecheck(r, Erv)
 		} else {
@@ -1197,7 +1193,7 @@ func getlit(lit *Node) int {
 	return -1
 }
 
-// stataddr sets nam to the static address of n and reports whether it succeeded.
+// stataddr sets nam to the static address of n and reports whether it succeeeded.
 func stataddr(nam *Node, n *Node) bool {
 	if n == nil {
 		return false

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

@@ -64,9 +64,6 @@ func buildssa(fn *Node) *ssa.Func {
 	s.config = initssa()
 	s.f = s.config.NewFunc()
 	s.f.Name = name
-	if fn.Func.Pragma&Nosplit != 0 {
-		s.f.NoSplit = true
-	}
 	s.exitCode = fn.Func.Exit
 	s.panics = map[funcLine]*ssa.Block{}
 	s.config.DebugTest = s.config.DebugHashMatch("GOSSAHASH", name)

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/type.go

@@ -213,7 +213,7 @@ func (t *Type) FuncType() *FuncType {
 	return t.Extra.(*FuncType)
 }
 
-// InterMethType contains Type fields specific to interface method pseudo-types.
+// InterMethType contains Type fields specific to interface method psuedo-types.
 type InterMethType struct {
 	Nname *Node
 }

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

@@ -859,7 +859,7 @@ OpSwitch:
 			}
 
 			if n.Type.Etype != TFUNC || !n.IsMethod() {
-				yyerror("type %v has no method %S", n.Left.Type, n.Sym)
+				yyerror("type %v has no method %S", n.Left.Type, n.Right.Sym)
 				n.Type = nil
 				return n
 			}

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 {
@@ -694,10 +726,6 @@ opswitch:
 			break
 		}
 
-		if !instrumenting && iszero(n.Right) && !needwritebarrier(n.Left, n.Right) {
-			break
-		}
-
 		switch n.Right.Op {
 		default:
 			n.Right = walkexpr(n.Right, init)
@@ -2071,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/checkbce.go

@@ -6,7 +6,7 @@ package ssa
 
 // checkbce prints all bounds checks that are present in the function.
 // Useful to find regressions. checkbce is only activated when with
-// corresponding debug options, so it's off by default.
+// corresponsing debug options, so it's off by default.
 // See test/checkbce.go
 func checkbce(f *Func) {
 	if f.pass.debug <= 0 {

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

@@ -5,7 +5,6 @@
 package ssa
 
 import (
-	"cmd/internal/obj"
 	"fmt"
 	"log"
 	"os"
@@ -350,8 +349,6 @@ var passes = [...]pass{
 	{name: "writebarrier", fn: writebarrier, required: true}, // expand write barrier ops
 	{name: "fuse", fn: fuse},
 	{name: "dse", fn: dse},
-	{name: "insert resched checks", fn: insertLoopReschedChecks,
-		disabled: obj.Preemptibleloops_enabled == 0}, // insert resched checks in loops.
 	{name: "tighten", fn: tighten}, // move values closer to their uses
 	{name: "lower", fn: lower, required: true},
 	{name: "lowered cse", fn: cse},
@@ -381,13 +378,7 @@ type constraint struct {
 }
 
 var passOrder = [...]constraint{
-	// "insert resched checks" uses mem, better to clean out stores first.
-	{"dse", "insert resched checks"},
-	// insert resched checks adds new blocks containing generic instructions
-	{"insert resched checks", "lower"},
-	{"insert resched checks", "tighten"},
-
-	// prove relies on common-subexpression elimination for maximum benefits.
+	// prove reliese on common-subexpression elimination for maximum benefits.
 	{"generic cse", "prove"},
 	// deadcode after prove to eliminate all new dead blocks.
 	{"prove", "generic deadcode"},

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

@@ -93,7 +93,7 @@ type Logger interface {
 	// Warnl writes compiler messages in the form expected by "errorcheck" tests
 	Warnl(line int32, fmt_ string, args ...interface{})
 
-	// Forwards the Debug flags from gc
+	// Fowards the Debug flags from gc
 	Debug_checknil() bool
 	Debug_wb() bool
 }

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/func.go

@@ -24,7 +24,6 @@ type Func struct {
 	vid        idAlloc     // value ID allocator
 
 	scheduled bool // Values in Blocks are in final order
-	NoSplit   bool // true if function is marked as nosplit.  Used by schedule check pass.
 
 	// when register allocation is done, maps value ids to locations
 	RegAlloc []Location

src/cmd/compile/internal/ssa/gen/ARM64Ops.go

@@ -12,7 +12,7 @@ import "strings"
 //  - Integer types live in the low portion of registers. Upper portions are junk.
 //  - Boolean types use the low-order byte of a register. 0=false, 1=true.
 //    Upper bytes are junk.
-//  - *const instructions may use a constant larger than the instruction can encode.
+//  - *const instructions may use a constant larger than the instuction can encode.
 //    In this case the assembler expands to multiple instructions and uses tmp
 //    register (R27).
 

src/cmd/compile/internal/ssa/gen/ARMOps.go

@@ -12,7 +12,7 @@ import "strings"
 //  - Integer types live in the low portion of registers. Upper portions are junk.
 //  - Boolean types use the low-order byte of a register. 0=false, 1=true.
 //    Upper bytes are junk.
-//  - *const instructions may use a constant larger than the instruction can encode.
+//  - *const instructions may use a constant larger than the instuction can encode.
 //    In this case the assembler expands to multiple instructions and uses tmp
 //    register (R11).
 

src/cmd/compile/internal/ssa/gen/MIPS64Ops.go

@@ -12,7 +12,7 @@ import "strings"
 //  - Integer types live in the low portion of registers. Upper portions are junk.
 //  - Boolean types use the low-order byte of a register. 0=false, 1=true.
 //    Upper bytes are junk.
-//  - *const instructions may use a constant larger than the instruction can encode.
+//  - *const instructions may use a constant larger than the instuction can encode.
 //    In this case the assembler expands to multiple instructions and uses tmp
 //    register (R23).
 

src/cmd/compile/internal/ssa/gen/MIPSOps.go

@@ -13,7 +13,7 @@ import "strings"
 //  - Boolean types use the low-order byte of a register. 0=false, 1=true.
 //    Upper bytes are junk.
 //  - Unused portions of AuxInt are filled by sign-extending the used portion.
-//  - *const instructions may use a constant larger than the instruction can encode.
+//  - *const instructions may use a constant larger than the instuction can encode.
 //    In this case the assembler expands to multiple instructions and uses tmp
 //    register (R23).
 

src/cmd/compile/internal/ssa/gen/PPC64Ops.go

@@ -12,7 +12,7 @@ import "strings"
 //  - Less-than-64-bit integer types live in the low portion of registers.
 //    For now, the upper portion is junk; sign/zero-extension might be optimized in the future, but not yet.
 //  - Boolean types are zero or 1; stored in a byte, but loaded with AMOVBZ so the upper bytes of a register are zero.
-//  - *const instructions may use a constant larger than the instruction can encode.
+//  - *const instructions may use a constant larger than the instuction can encode.
 //    In this case the assembler expands to multiple instructions and uses tmp
 //    register (R31).