[release-branch.go1.16] go1.16.3

Change-Id: Iace7cfec757a6d0bac25f729be5ecb2ae3b59d74
Reviewed-on: https://go-review.googlesource.com/c/go/+/306569
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Carlos Amedee <carlos@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: David Chase <drchase@google.com>
TryBot-Result: Go Bot <gobot@golang.org>

CONTRIBUTORS

@@ -30,6 +30,7 @@ Aaron Bieber <deftly@gmail.com>
 Aaron Cannon <cannona@fireantproductions.com>
 Aaron France <aaron.l.france@gmail.com>
 Aaron Jacobs <jacobsa@google.com>
+Aaron Jensen <jensen.aaro@gmail.com>
 Aaron Kemp <kemp.aaron@gmail.com>
 Aaron Patterson <tenderlove@ruby-lang.org>
 Aaron Stein <aaronstein12@gmail.com>
@@ -71,9 +72,11 @@ Ahmet Alp Balkan <ahmetb@google.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
 Ahsun Ahmed <ahmed.ahsun@gmail.com>
+Aidan Coyle <packrat386@gmail.com>
 Aiden Scandella <ai@uber.com>
 Ainar Garipov <gugl.zadolbal@gmail.com>
 Aishraj Dahal <aishraj@users.noreply.github.com>
+Ajanthan Balachandran <balaajanthan@gmail.com>
 Akhil Indurti <aindurti@gmail.com>
 Akihiro Suda <suda.kyoto@gmail.com>
 Akshat Kumar <seed@mail.nanosouffle.net>
@@ -104,9 +107,11 @@ Alex Buchanan <buchanae@gmail.com>
 Alex Carol <alex.carol.c@gmail.com>
 Alex Gaynor <alex@alloy.us>
 Alex Harford <alex.harford@saucelabs.com>
+Alex Hays <alex.hays@leftfieldlabs.com>
 Alex Jin <toalexjin@gmail.com>
 Alex Kohler <alexjohnkohler@gmail.com>
 Alex Myasoedov <msoedov@gmail.com>
+Alex Opie <amtopie@gmail.com>
 Alex Plugaru <alex@plugaru.org> <alexandru.plugaru@gmail.com>
 Alex Schroeder <alex@gnu.org>
 Alex Sergeyev <abc@alexsergeyev.com>
@@ -119,6 +124,7 @@ Alexander F Rødseth <alexander.rodseth@appeartv.com>
 Alexander Greim <alexxx@iltempo.de>
 Alexander Guz <kalimatas@gmail.com>
 Alexander Kauer <alexander@affine.space>
+Alexander Klauer <Alexander.Klauer@googlemail.com>
 Alexander Kucherenko <alxkchr@gmail.com>
 Alexander Larsson <alexander.larsson@gmail.com>
 Alexander Lourier <aml@rulezz.ru>
@@ -150,16 +156,19 @@ Alexey Naidonov <alexey.naidyonov@gmail.com>
 Alexey Neganov <neganovalexey@gmail.com>
 Alexey Palazhchenko <alexey.palazhchenko@gmail.com>
 Alexey Semenyuk <alexsemenyuk88@gmail.com>
+Alexey Vilenskiy <bynovhack@gmail.com>
 Alexis Hildebrandt <surryhill@gmail.com>
 Alexis Hunt <lexer@google.com>
 Alexis Imperial-Legrand <ail@google.com>
 Ali Farooq <ali.farooq0@pm.me>
 Ali Rizvi-Santiago <arizvisa@gmail.com>
 Aliaksandr Valialkin <valyala@gmail.com>
+Alice Merrick <amerrick@google.com>
 Alif Rachmawadi <subosito@gmail.com>
 Allan Simon <allan.simon@supinfo.com>
 Allen Li <ayatane@google.com>
 Alok Menghrajani <alok.menghrajani@gmail.com>
+Alwin Doss <alwindoss84@gmail.com>
 Aman Gupta <aman@tmm1.net>
 Amarjeet Anand <amarjeetanandsingh@gmail.com>
 Amir Mohammad Saied <amir@gluegadget.com>
@@ -168,6 +177,8 @@ Amrut Joshi <amrut.joshi@gmail.com>
 An Long <aisk1988@gmail.com>
 An Xiao <hac@zju.edu.cn>
 Anand K. Mistry <anand@mistry.ninja>
+Ananya Saxena <ananyasaxena1@gmail.com>
+Anatol Pomozov <anatol.pomozov@gmail.com>
 Anders Pearson <anders@columbia.edu>
 Anderson Queiroz <contato@andersonq.eti.br>
 André Carvalho <asantostc@gmail.com>
@@ -199,6 +210,7 @@ Andrew G. Morgan <agm@google.com>
 Andrew Gerrand <adg@golang.org>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Jackura <ajackura@google.com>
+Andrew Kemm <andrewkemm@gmail.com>
 Andrew Louis <alouis@digitalocean.com>
 Andrew Lutomirski <andy@luto.us>
 Andrew Medvedev <andrew.y.medvedev@gmail.com>
@@ -216,6 +228,7 @@ Andrew Werner <andrew@upthere.com> <awerner32@gmail.com>
 Andrew Wilkins <axwalk@gmail.com>
 Andrew Williams <williams.andrew@gmail.com>
 Andrew Z Allen <me@andrewzallen.com>
+Andrey Bokhanko <andreybokhanko@gmail.com>
 Andrey Mirtchovski <mirtchovski@gmail.com>
 Andrey Petrov <andrey.petrov@shazow.net>
 Andrii Soldatenko <andrii.soldatenko@gmail.com>
@@ -230,6 +243,7 @@ Andy Maloney <asmaloney@gmail.com>
 Andy Pan <panjf2000@gmail.com>
 Andy Walker <walkeraj@gmail.com>
 Andy Wang <cbeuw.andy@gmail.com>
+Andy Williams <andy@andy.xyz>
 Andzej Maciusovic <andzej.maciusovic@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -274,6 +288,7 @@ Arne Hormann <arnehormann@gmail.com>
 Arnout Engelen <arnout@bzzt.net>
 Aron Nopanen <aron.nopanen@gmail.com>
 Artem Alekseev <artem.alekseev@intel.com>
+Artem Khvastunov <artem.khvastunov@jetbrains.com>
 Artem Kolin <artemkaxboy@gmail.com>
 Arthur Fabre <arthur@arthurfabre.com>
 Arthur Khashaev <arthur@khashaev.ru>
@@ -281,8 +296,10 @@ Artyom Pervukhin <artyom.pervukhin@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
 Ashish Gandhi <ag@ashishgandhi.org>
 Asim Shankar <asimshankar@gmail.com>
+Assel Meher <asselmeher@gmail.com>
 Atin Malaviya <amalaviy@akamai.com>
 Ato Araki <ato.araki@gmail.com>
+Atsushi Toyama <atsushi.tohyama.160.333@gmail.com>
 Audrey Lim <audreylh@gmail.com>
 Audrius Butkevicius <audrius.butkevicius@gmail.com>
 Augusto Roman <aroman@gmail.com>
@@ -291,6 +308,7 @@ Aurélien Rainone <aurelien.rainone@gmail.com>
 Aurélio A. Heckert <aurium@gmail.com>
 Austin Clements <austin@google.com> <aclements@csail.mit.edu>
 Avi Flax <avi@timehop.com>
+Aviv Klasquin Komissar <avivklas@gmail.com>
 awaw fumin <awawfumin@gmail.com>
 Awn Umar <awn@cryptolosophy.io>
 Axel Wagner <axel.wagner.hh@googlemail.com>
@@ -298,6 +316,7 @@ Ayan George <ayan@ayan.net>
 Ayanamist Yang <ayanamist@gmail.com>
 Ayke van Laethem <aykevanlaethem@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
+Ayzat Sadykov <ayzat.ziko.93@gmail.com>
 Azat Kaumov <kaumov.a.r@gmail.com>
 Baiju Muthukadan <baiju.m.mail@gmail.com>
 Balaram Makam <bmakam.qdt@qualcommdatacenter.com>
@@ -308,10 +327,12 @@ Bartosz Grzybowski <melkorm@gmail.com>
 Bartosz Oler <brtsz@google.com>
 Bastian Ike <bastian.ike@gmail.com>
 Ben Burkert <ben@benburkert.com>
+Ben Cartwright-Cox <Ben@Benjojo.co.uk>
 Ben Eitzen <eitzenb@golang.org>
 Ben Fried <ben.fried@gmail.com>
 Ben Haines <bhainesva@gmail.com>
 Ben Hoyt <benhoyt@gmail.com>
+Ben Kraft <benkraft@khanacademy.org>
 Ben Laurie <ben@links.org> <benl@google.com>
 Ben Lubar <ben.lubar@gmail.com>
 Ben Lynn <benlynn@gmail.com>
@@ -319,6 +340,7 @@ Ben Olive <sionide21@gmail.com>
 Ben Schwartz <bemasc@google.com>
 Ben Shi <powerman1st@163.com>
 Ben Toews <mastahyeti@gmail.com>
+Benjamin Barenblat <bbaren@google.com>
 Benjamin Black <b@b3k.us>
 Benjamin Cable <cable.benjamin@gmail.com>
 Benjamin Hsieh <tanookiben@users.noreply.github.com>
@@ -356,6 +378,7 @@ Bobby Powers <bobbypowers@gmail.com>
 Boqin Qin <bobbqqin@gmail.com>
 Boris Nagaev <nagaev@google.com>
 Borja Clemente <borja.clemente@gmail.com>
+Boshi Lian <bolian@microsoft.com>
 Brad Burch <brad.burch@gmail.com>
 Brad Erickson <bderickson@gmail.com>
 Brad Fitzpatrick <bradfitz@golang.org> <bradfitz@gmail.com>
@@ -368,10 +391,12 @@ Bradford Lamson-Scribner <brad.lamson@gmail.com>
 Bradley Falzon <brad@teambrad.net>
 Brady Catherman <brady@gmail.com>
 Brady Sullivan <brady@bsull.com>
+Branden J. Brown <zephyrtronium@gmail.com>
 Brandon Bennett <bbennett@fb.com>
 Brandon Gilmore <varz@google.com>
 Brandon Philips <brandon@ifup.org>
 Brandon Ryan <bjryan19@gmail.com>
+Brave Cow <rsr715@gmail.com>
 Brayden Cloud <bcloud@google.com>
 Brendan Daniel Tracey <tracey.brendan@gmail.com>
 Brendan O'Dea <bod@golang.org>
@@ -389,6 +414,7 @@ Brian Slesinsky <skybrian@google.com>
 Brian Smith <ohohvi@gmail.com>
 Brian Starke <brian.starke@gmail.com>
 Bryan Alexander <Kozical@msn.com>
+Bryan Boreham <bjboreham@gmail.com>
 Bryan C. Mills <bcmills@google.com>
 Bryan Chan <bryan.chan@ca.ibm.com>
 Bryan Ford <brynosaurus@gmail.com>
@@ -407,6 +433,7 @@ Carl Mastrangelo <notcarl@google.com>
 Carl Shapiro <cshapiro@google.com> <cshapiro@golang.org>
 Carlisia Campos <carlisia@grokkingtech.io>
 Carlo Alberto Ferraris <cafxx@strayorange.com>
+Carlos Alexandro Becker <caarlos0@gmail.com>
 Carlos Amedee <carlos@golang.org>
 Carlos Castillo <cookieo9@gmail.com>
 Carlos Cirello <uldericofilho@gmail.com>
@@ -422,6 +449,7 @@ Casey Callendrello <squeed@gmail.com>
 Casey Marshall <casey.marshall@gmail.com>
 Catalin Nicutar <cnicutar@google.com>
 Catalin Patulea <catalinp@google.com>
+Cathal O'Callaghan <cathalsocallaghan@gmail.com>
 Cedric Staub <cs@squareup.com>
 Cezar Sá Espinola <cezarsa@gmail.com>
 Chad Rosier <mrosier.qdt@qualcommdatacenter.com>
@@ -434,10 +462,14 @@ Charles Kenney <charlesc.kenney@gmail.com>
 Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
 Charles Weill <weill@google.com>
+Charlotte Brandhorst-Satzkorn <catzkorn@gmail.com>
 Chauncy Cullitan <chauncyc@google.com>
+Chen Zhidong <njutczd@gmail.com>
 Chen Zhihan <energiehund@gmail.com>
 Cherry Zhang <cherryyz@google.com>
 Chew Choon Keat <choonkeat@gmail.com>
+Chiawen Chen <golopot@gmail.com>
+Chirag Sukhala <cchirag77@gmail.com>
 Cholerae Hu <choleraehyq@gmail.com>
 Chotepud Teo <AlexRouSg@users.noreply.github.com>
 Chris Ball <chris@printf.net>
@@ -460,6 +492,8 @@ Chris Raynor <raynor@google.com>
 Chris Roche <rodaine@gmail.com>
 Chris Smith <chrsmith@users.noreply.github.com>
 Chris Stockton <chrisstocktonaz@gmail.com>
+Chris Taylor <taylorza@gmail.com>
+Chris Waldon <christopher.waldon.dev@gmail.com>
 Chris Zou <chriszou@ca.ibm.com>
 Christian Alexander <christian@linux.com>
 Christian Couder <chriscool@tuxfamily.org>
@@ -467,6 +501,7 @@ Christian Himpel <chressie@googlemail.com> <chressie@gmail.com>
 Christian Muehlhaeuser <muesli@gmail.com>
 Christian Pellegrin <chri@evolware.org>
 Christian R. Petrin <christianpetrin@gmail.com>
+Christian Svensson <blue@cmd.nu>
 Christine Hansmann <chhansmann@gmail.com>
 Christoffer Buchholz <christoffer.buchholz@gmail.com>
 Christoph Blecker <admin@toph.ca>
@@ -474,6 +509,7 @@ Christoph Hack <christoph@tux21b.org>
 Christopher Cahoon <chris.cahoon@gmail.com>
 Christopher Guiney <chris@guiney.net>
 Christopher Henderson <chris@chenderson.org>
+Christopher Hlubek <christopher.hlubek@networkteam.com>
 Christopher Koch <chrisko@google.com>
 Christopher Loessl <cloessl+github@gmail.com>
 Christopher Nelson <nadiasvertex@gmail.com>
@@ -506,7 +542,10 @@ Costin Chirvasuta <ctin@google.com>
 Craig Citro <craigcitro@google.com>
 Cristian Staretu <unclejacksons@gmail.com>
 Cuihtlauac ALVARADO <cuihtlauac.alvarado@orange.com>
+Cuong Manh Le <cuong@orijtech.com>
+Curtis La Graff <curtis@lagraff.me>
 Cyrill Schumacher <cyrill@schumacher.fm>
+Dai Jie <gzdaijie@gmail.com>
 Daisuke Fujita <dtanshi45@gmail.com>
 Daisuke Suzuki <daisuzu@gmail.com>
 Daker Fernandes Pinheiro <daker.fernandes.pinheiro@intel.com>
@@ -525,12 +564,14 @@ Dan Peterson <dpiddy@gmail.com>
 Dan Pupius <dan@medium.com>
 Dan Scales <danscales@google.com>
 Dan Sinclair <dan.sinclair@gmail.com>
+Daniel Cohen <dcohen@gatech.edu>
 Daniel Cormier <danielc@knowbe4.com>
 Daniël de Kok <me@danieldk.eu>
 Daniel Fleischman <danielfleischman@gmail.com>
 Daniel Ingram <ingramds@appstate.edu>
 Daniel Johansson <dajo2002@gmail.com>
 Daniel Kerwin <d.kerwin@gini.net>
+Daniel Kessler <dkess@google.com>
 Daniel Krech <eikeon@eikeon.com>
 Daniel Kumor <rdkumor@gmail.com>
 Daniel Langner <s8572327@gmail.com>
@@ -538,10 +579,12 @@ Daniel Lidén <daniel.liden.87@gmail.com>
 Daniel Lublin <daniel@lublin.se>
 Daniel Mangum <georgedanielmangum@gmail.com>
 Daniel Martí <mvdan@mvdan.cc>
+Daniel McCarney <cpu@letsencrypt.org>
 Daniel Morsing <daniel.morsing@gmail.com>
 Daniel Nadasi <dnadasi@google.com>
 Daniel Nephin <dnephin@gmail.com>
 Daniel Ortiz Pereira da Silva <daniel.particular@gmail.com>
+Daniel S. Fava <danielsfava@gmail.com>
 Daniel Skinner <daniel@dasa.cc>
 Daniel Speichert <daniel@speichert.pl>
 Daniel Theophanes <kardianos@gmail.com>
@@ -563,6 +606,7 @@ Dave Cheney <dave@cheney.net>
 Dave Day <djd@golang.org>
 Dave Grijalva <dgrijalva@ngmoco.com>
 Dave MacFarlane <driusan@gmail.com>
+Dave Pifke <dave@pifke.org>
 Dave Russell <forfuncsake@gmail.com>
 David Anderson <danderson@google.com>
 David Barnett <dbarnett@google.com>
@@ -593,6 +637,7 @@ David McLeish <davemc@google.com>
 David Ndungu <dnjuguna@gmail.com>
 David NewHamlet <david@newhamlet.com>
 David Presotto <presotto@gmail.com>
+David Qu <davidqu12345@gmail.com>
 David R. Jenni <david.r.jenni@gmail.com>
 David Sansome <me@davidsansome.com>
 David Stainton <dstainton415@gmail.com>
@@ -642,6 +687,7 @@ Diwaker Gupta <diwakergupta@gmail.com>
 Dmitri Goutnik <dgoutnik@gmail.com>
 Dmitri Popov <operator@cv.dp-net.com>
 Dmitri Shuralyov <dmitshur@golang.org> <dmitri@shuralyov.com>
+Dmitrii Okunev <xaionaro@gmail.com>
 Dmitriy Cherchenko <dcherchenko@gmail.com>
 Dmitriy Dudkin <dudkin.dmitriy@gmail.com>
 Dmitriy Shelenin <deemok@googlemail.com> <deemok@gmail.com>
@@ -655,6 +701,7 @@ Dmitry Yakunin <nonamezeil@gmail.com>
 Doga Fincan <doga@icloud.com>
 Domas Tamašauskas <puerdomus@gmail.com>
 Domen Ipavec <domen@ipavec.net>
+Dominic Della Valle <ddvpublic@Gmail.com>
 Dominic Green <dominicgreen1@gmail.com>
 Dominik Honnef <dominik.honnef@gmail.com>
 Dominik Vogt <vogt@linux.vnet.ibm.com>
@@ -696,6 +743,7 @@ Elias Naur <mail@eliasnaur.com> <elias.naur@gmail.com>
 Elliot Morrison-Reed <elliotmr@gmail.com>
 Ellison Leão <ellisonleao@gmail.com>
 Emerson Lin <linyintor@gmail.com>
+Emil Bektimirov <lefelys@gmail.com>
 Emil Hessman <emil@hessman.se>
 Emil Mursalimov <mursalimovemeel@gmail.com>
 Emilien Kenler <hello@emilienkenler.com>
@@ -760,6 +808,7 @@ Fatih Arslan <fatih@arslan.io>
 Fazal Majid <majid@apsalar.com>
 Fazlul Shahriar <fshahriar@gmail.com>
 Federico Bond <federicobond@gmail.com>
+Federico Guerinoni <guerinoni.federico@gmail.com>
 Federico Simoncelli <fsimonce@redhat.com>
 Fedor Indutny <fedor@indutny.com>
 Fedor Korotkiy <dartslon@gmail.com>
@@ -781,6 +830,7 @@ Florin Patan <florinpatan@gmail.com>
 Folke Behrens <folke@google.com>
 Ford Hurley <ford.hurley@gmail.com>
 Francesc Campoy <campoy@golang.org>
+Francesco Guardiani <francescoguard@gmail.com>
 Francesco Renzi <rentziass@gmail.com>
 Francisco Claude <fclaude@recoded.cl>
 Francisco Rojas <francisco.rojas.gallegos@gmail.com>
@@ -811,8 +861,10 @@ Gabriel Russell <gabriel.russell@gmail.com>
 Gareth Paul Jones <gpj@foursquare.com>
 Garret Kelly <gdk@google.com>
 Garrick Evans <garrick@google.com>
+Garry McNulty <garrmcnu@gmail.com>
 Gary Burd <gary@beagledreams.com> <gary.burd@gmail.com>
 Gary Elliott <garyelliott@google.com>
+Gaurav Singh <gaurav1086@gmail.com>
 Gaurish Sharma <contact@gaurishsharma.com>
 Gautham Thambidorai <gautham.dorai@gmail.com>
 Gauthier Jolly <gauthier.jolly@gmail.com>
@@ -827,6 +879,7 @@ Georg Reinke <guelfey@gmail.com>
 George Gkirtsou <ggirtsou@gmail.com>
 George Hartzell <hartzell@alerce.com>
 George Shammas <george@shamm.as> <georgyo@gmail.com>
+George Tsilias <tsiliasg@gmail.com>
 Gerasimos (Makis) Maropoulos <kataras2006@hotmail.com>
 Gerasimos Dimitriadis <gedimitr@gmail.com>
 Gergely Brautigam <skarlso777@gmail.com>
@@ -862,6 +915,7 @@ GitHub User @frennkie (6499251) <mail@rhab.de>
 GitHub User @geedchin (11672310) <geedchin@gmail.com>
 GitHub User @GrigoriyMikhalkin (3637857) <grigoriymikhalkin@gmail.com>
 GitHub User @hengwu0 (41297446) <41297446+hengwu0@users.noreply.github.com>
+GitHub User @hitzhangjie (3725760) <hit.zhangjie@gmail.com>
 GitHub User @itchyny (375258) <itchyny@hatena.ne.jp>
 GitHub User @jinmiaoluo (39730824) <jinmiaoluo@icloud.com>
 GitHub User @jopbrown (6345470) <msshane2008@gmail.com>
@@ -873,6 +927,7 @@ GitHub User @LotusFenn (13775899) <fenn.lotus@gmail.com>
 GitHub User @ly303550688 (11519839) <yang.liu636@gmail.com>
 GitHub User @madiganz (18340029) <zacharywmadigan@gmail.com>
 GitHub User @maltalex (10195391) <code@bit48.net>
+GitHub User @markruler (38225900) <csu0414@gmail.com>
 GitHub User @Matts966 (28551465) <Matts966@users.noreply.github.com>
 GitHub User @micnncim (21333876) <micnncim@gmail.com>
 GitHub User @mkishere (224617) <224617+mkishere@users.noreply.github.com>
@@ -886,6 +941,8 @@ GitHub User @ramenjuniti (32011829) <ramenjuniti@gmail.com>
 GitHub User @saitarunreddy (21041941) <saitarunreddypalla@gmail.com>
 GitHub User @shogo-ma (9860598) <Choroma194@gmail.com>
 GitHub User @skanehira (7888591) <sho19921005@gmail.com>
+GitHub User @soolaugust (10558124) <soolaugust@gmail.com>
+GitHub User @surechen (7249331) <surechen17@gmail.com>
 GitHub User @tatsumack (4510569) <tatsu.mack@gmail.com>
 GitHub User @tell-k (26263) <ffk2005@gmail.com>
 GitHub User @tennashi (10219626) <tennashio@gmail.com>
@@ -908,6 +965,7 @@ Gordon Tyler <gordon@doxxx.net>
 Graham King <graham4king@gmail.com>
 Graham Miller <graham.miller@gmail.com>
 Grant Griffiths <ggp493@gmail.com>
+Green Lightning <GreenLightning.git@googlemail.com>
 Greg Poirier <greg.istehbest@gmail.com>
 Greg Steuck <gnezdo+github@google.com>
 Greg Thelen <gthelen@google.com>
@@ -920,6 +978,7 @@ Guilherme Garnier <guilherme.garnier@gmail.com>
 Guilherme Goncalves <guilhermeaugustosg@gmail.com>
 Guilherme Rezende <guilhermebr@gmail.com>
 Guillaume J. Charmes <guillaume@charmes.net>
+Guillaume Sottas <guillaumesottas@gmail.com>
 Günther Noack <gnoack@google.com>
 Guobiao Mei <meiguobiao@gmail.com>
 Guoliang Wang <iamwgliang@gmail.com>
@@ -936,6 +995,8 @@ HAMANO Tsukasa <hamano@osstech.co.jp>
 Han-Wen Nienhuys <hanwen@google.com>
 Hang Qian <hangqian90@gmail.com>
 Hanjun Kim <hallazzang@gmail.com>
+Hanlin Shi <shihanlin9@gmail.com>
+Haoran Luo <haoran.luo@chaitin.com>
 Haosdent Huang <haosdent@gmail.com>
 Harald Nordgren <haraldnordgren@gmail.com>
 Hari haran <hariharan.uno@gmail.com>
@@ -950,9 +1011,11 @@ Håvard Haugen <havard.haugen@gmail.com>
 He Liu <liulonnie@gmail.com>
 Hector Chu <hectorchu@gmail.com>
 Hector Martin Cantero <hector@marcansoft.com>
+Hein Khant Zaw <heinkhantzaw1@gmail.com>
 Henning Schmiedehausen <henning@schmiedehausen.org>
 Henrik Edwards <henrik.edwards@gmail.com>
 Henrik Hodne <henrik@hodne.io>
+Henrique Vicente <henriquevicente@gmail.com>
 Henry Adi Sumarto <henry.adisumarto@gmail.com>
 Henry Bubert <google@mindeco.de>
 Henry Chang <mr.changyuheng@gmail.com>
@@ -969,6 +1032,7 @@ Hironao OTSUBO <motemen@gmail.com>
 Hiroshi Ioka <hirochachacha@gmail.com>
 Hitoshi Mitake <mitake.hitoshi@gmail.com>
 Holden Huang <ttyh061@gmail.com>
+Songlin Jiang <hollowman@hollowman.ml>
 Hong Ruiqi <hongruiqi@gmail.com>
 Hongfei Tan <feilengcui008@gmail.com>
 Horacio Duran <horacio.duran@gmail.com>
@@ -990,6 +1054,7 @@ Ian Haken <ihaken@netflix.com>
 Ian Kent <iankent85@gmail.com>
 Ian Lance Taylor <iant@golang.org>
 Ian Leue <ian@appboy.com>
+Ian Tay <iantay@google.com>
 Ian Zapolsky <ianzapolsky@gmail.com>
 Ibrahim AshShohail <ibra.sho@gmail.com>
 Icarus Sparry <golang@icarus.freeuk.com>
@@ -997,9 +1062,11 @@ Iccha Sethi <icchasethi@gmail.com>
 Idora Shinatose <idora.shinatose@gmail.com>
 Ignacio Hagopian <jsign.uy@gmail.com>
 Igor Bernstein <igorbernstein@google.com>
+Igor Bolotnikov <igor.v.bolotnikov@gmail.com>
 Igor Dolzhikov <bluesriverz@gmail.com>
 Igor Vashyst <ivashyst@gmail.com>
 Igor Zhilianin <igor.zhilianin@gmail.com>
+Ikko Ashimine <eltociear@gmail.com>
 Illya Yalovyy <yalovoy@gmail.com>
 Ilya Sinelnikov <sidhmangh@gmail.com>
 Ilya Tocar <ilya.tocar@intel.com>
@@ -1037,6 +1104,7 @@ Jacob Blain Christen <dweomer5@gmail.com>
 Jacob H. Haven <jacob@cloudflare.com>
 Jacob Hoffman-Andrews <github@hoffman-andrews.com>
 Jacob Walker <jacobwalker0814@gmail.com>
+Jaden Teng <long.asyn@gmail.com>
 Jae Kwon <jae@tendermint.com>
 Jake B <doogie1012@gmail.com>
 Jakob Borg <jakob@nym.se>
@@ -1044,6 +1112,7 @@ Jakob Weisblat <jakobw@mit.edu>
 Jakub Čajka <jcajka@redhat.com>
 Jakub Kaczmarzyk <jakubk@mit.edu>
 Jakub Ryszard Czarnowicz <j.czarnowicz@gmail.com>
+Jakub Warczarek <jakub.warczarek@gmail.com>
 Jamal Carvalho <jamal.a.carvalho@gmail.com>
 James Aguilar <jaguilar@google.com>
 James Bardin <j.bardin@gmail.com>
@@ -1056,9 +1125,11 @@ James Eady <jmeady@google.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
 James Hartig <fastest963@gmail.com>
+James Kasten <jdkasten@google.com>
 James Lawrence <jljatone@gmail.com>
 James Meneghello <rawrz0r@gmail.com>
 James Myers <jfmyers9@gmail.com>
+James Naftel <james.naftel@gmail.com>
 James Neve <jamesoneve@gmail.com>
 James Nugent <james@jen20.com>
 James P. Cooper <jamespcooper@gmail.com>
@@ -1108,6 +1179,7 @@ Javier Kohen <jkohen@google.com>
 Javier Revillas <jrevillas@massivedynamic.io>
 Javier Segura <javism@gmail.com>
 Jay Conrod <jayconrod@google.com>
+Jay Lee <BusyJayLee@gmail.com>
 Jay Taylor <outtatime@gmail.com>
 Jay Weisskopf <jay@jayschwa.net>
 Jean de Klerk <deklerk@google.com>
@@ -1140,14 +1212,17 @@ Jeremy Jay <jeremy@pbnjay.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
 Jeroen Bobbeldijk <jerbob92@gmail.com>
 Jeroen Simonetti <jeroen@simonetti.nl>
+Jérôme Doucet <jerdct@gmail.com>
 Jerrin Shaji George <jerrinsg@gmail.com>
 Jess Frazelle <me@jessfraz.com>
 Jesse Szwedko <jesse.szwedko@gmail.com>
 Jesús Espino <jespinog@gmail.com>
 Jia Zhan <jzhan@uber.com>
 Jiacai Liu <jiacai2050@gmail.com>
+Jiahao Lu <lujjjh@gmail.com>
 Jianing Yu <jnyu@google.com>
 Jianqiao Li <jianqiaoli@google.com>
+Jiayu Yi <yijiayu@gmail.com>
 Jie Ma <jienius@outlook.com>
 Jihyun Yu <yjh0502@gmail.com>
 Jim Cote <jfcote87@gmail.com>
@@ -1183,6 +1258,7 @@ Joey Geiger <jgeiger@users.noreply.github.com>
 Johan Brandhorst <johan.brandhorst@gmail.com>
 Johan Euphrosine <proppy@google.com>
 Johan Jansson <johan.jansson@iki.fi>
+Johan Knutzen <johan@senri.se>
 Johan Sageryd <j@1616.se>
 John Asmuth <jasmuth@gmail.com>
 John Beisley <huin@google.com>
@@ -1210,6 +1286,7 @@ Johnny Luo <johnnyluo1980@gmail.com>
 Jon Chen <jchen@justin.tv>
 Jon Johnson <jonjohnson@google.com>
 Jonas Bernoulli <jonas@bernoul.li>
+Jonathan Albrecht <jonathan.albrecht@ibm.com>
 Jonathan Allie <jonallie@google.com>
 Jonathan Amsterdam <jba@google.com>
 Jonathan Boulle <jonathanboulle@gmail.com>
@@ -1223,6 +1300,7 @@ Jonathan Pentecost <pentecostjonathan@gmail.com>
 Jonathan Pittman <jmpittman@google.com> <jonathan.mark.pittman@gmail.com>
 Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Stacks <jonstacks13@gmail.com>
+Jonathan Swinney <jswinney@amazon.com>
 Jonathan Wills <runningwild@gmail.com>
 Jonathon Lacher <jonathon.lacher@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
@@ -1233,6 +1311,7 @@ Jordan Krage <jmank88@gmail.com>
 Jordan Lewis <jordanthelewis@gmail.com>
 Jordan Liggitt <liggitt@google.com>
 Jordan Rhee <jordanrh@microsoft.com>
+Jordan Rupprecht <rupprecht@google.com>
 Jordi Martin <jordimartin@gmail.com>
 Jorge Araya <jorgejavieran@yahoo.com.mx>
 Jorge L. Fatta <jorge.fatta@auth0.com>
@@ -1276,6 +1355,7 @@ Julien Salleyron <julien.salleyron@gmail.com>
 Julien Schmidt <google@julienschmidt.com>
 Julio Montes <julio.montes@intel.com>
 Jun Zhang <jim.zoumo@gmail.com>
+Junchen Li <junchen.li@arm.com>
 Junda Liu <junda@celer.network>
 Jungho Ahn <jhahn@google.com>
 Junya Hayashi <ledmonster@gmail.com>
@@ -1287,6 +1367,7 @@ Justin Nuß <nuss.justin@gmail.com>
 Justyn Temme <justyntemme@gmail.com>
 Kai Backman <kaib@golang.org>
 Kai Dong <dokia2357@gmail.com>
+Kai Lüke <kai@kinvolk.io>
 Kai Trukenmüller <ktye78@gmail.com>
 Kale Blankenship <kale@lemnisys.com>
 Kaleb Elwert <kelwert@atlassian.com>
@@ -1314,6 +1395,7 @@ Kazuhiro Sera <seratch@gmail.com>
 KB Sriram <kbsriram@google.com>
 Keegan Carruthers-Smith <keegan.csmith@gmail.com>
 Kei Son <hey.calmdown@gmail.com>
+Keiichi Hirobe <chalenge.akane@gmail.com>
 Keiji Yoshida <keijiyoshida.mail@gmail.com>
 Keisuke Kishimoto <keisuke.kishimoto@gmail.com>
 Keith Ball <inflatablewoman@gmail.com>
@@ -1322,6 +1404,7 @@ Keith Rarick <kr@xph.us>
 Kelly Heller <pestophagous@gmail.com>
 Kelsey Hightower <kelsey.hightower@gmail.com>
 Kelvin Foo Chuan Lyi <vmirage@gmail.com>
+Kemal Elmizan <kemalelmizan@gmail.com>
 Ken Friedenbach <kenliz@cruzio.com>
 Ken Rockot <ken@oz.gs> <ken.rockot@gmail.com>
 Ken Sedgwick <ken@bonsai.com>
@@ -1331,6 +1414,7 @@ Kenji Kaneda <kenji.kaneda@gmail.com>
 Kenji Yano <kenji.yano@gmail.com>
 Kenneth Shaw <kenshaw@gmail.com>
 Kenny Grant <kennygrant@gmail.com>
+Kensei Nakada <handbomusic@gmail.com>
 Kenta Mori <zoncoen@gmail.com>
 Kerollos Magdy <kerolloz@yahoo.com>
 Ketan Parmar <ketanbparmar@gmail.com>
@@ -1342,10 +1426,12 @@ Kevin Gillette <extemporalgenome@gmail.com>
 Kevin Kirsche <kev.kirsche@gmail.com>
 Kevin Klues <klueska@gmail.com> <klueska@google.com>
 Kevin Malachowski <chowski@google.com>
+Kevin Parsons <kevpar@microsoft.com>
 Kevin Ruffin <kruffin@gmail.com>
 Kevin Vu <kevin.m.vu@gmail.com>
 Kevin Zita <bleedgreenandgold@gmail.com>
 Keyan Pishdadian <kpishdadian@gmail.com>
+Keyuan Li <keyuanli123@gmail.com>
 Kezhu Wang <kezhuw@gmail.com>
 Khosrow Moossavi <khos2ow@gmail.com>
 Kieran Colford <kieran@kcolford.com>
@@ -1358,6 +1444,7 @@ Kirill Smelkov <kirr@nexedi.com>
 Kirill Tatchihin <kirabsuir@gmail.com>
 Kirk Han <kirk91.han@gmail.com>
 Kirklin McDonald <kirklin.mcdonald@gmail.com>
+KJ Tsanaktsidis <ktsanaktsidis@zendesk.com>
 Klaus Post <klauspost@gmail.com>
 Kodie Goodwin <kodiegoodwin@gmail.com>
 Koichi Shiraishi <zchee.io@gmail.com>
@@ -1371,6 +1458,7 @@ Kris Kwiatkowski <kris@cloudflare.com>
 Kris Nova <kris@nivenly.com>
 Kris Rousey <krousey@google.com>
 Kristopher Watts <traetox@gmail.com>
+Krzysztof Dąbrowski <krzysdabro@live.com>
 Kshitij Saraogi <kshitijsaraogi@gmail.com>
 Kun Li <likunarmstrong@gmail.com>
 Kunpei Sakai <namusyaka@gmail.com>
@@ -1412,8 +1500,10 @@ Leonardo Comelli <leonardo.comelli@gmail.com>
 Leonel Quinteros <leonel.quinteros@gmail.com>
 Lev Shamardin <shamardin@gmail.com>
 Lewin Bormann <lewin.bormann@gmail.com>
+Lewis Waddicor <nemesismk2@gmail.com>
 Liam Haworth <liam@haworth.id.au>
 Lily Chung <lilithkchung@gmail.com>
+Lingchao Xin <douglarek@gmail.com>
 Lion Yang <lion@aosc.xyz>
 Liz Rice <liz@lizrice.com>
 Lloyd Dewolf <foolswisdom@gmail.com>
@@ -1427,6 +1517,7 @@ Luan Santos <cfcluan@gmail.com>
 Lubomir I. Ivanov <neolit123@gmail.com>
 Luca Bruno <luca.bruno@coreos.com>
 Luca Greco <luca.greco@alcacoop.it>
+Luca Spiller <luca@stackednotion.com>
 Lucas Bremgartner <lucas.bremgartner@gmail.com>
 Lucas Clemente <lclemente@google.com>
 Lucien Stuker <lucien.stuker@gmail.com>
@@ -1450,6 +1541,8 @@ Maarten Bezemer <maarten.bezemer@gmail.com>
 Maciej Dębski <maciejd@google.com>
 Madhu Rajanna <madhupr007@gmail.com>
 Magnus Hiie <magnus.hiie@gmail.com>
+Mahdi Hosseini Moghaddam <seyed.mahdi.hosseini.moghaddam@ibm.com>
+Maia Lee <maia.lee@leftfieldlabs.com>
 Maicon Costa <maiconscosta@gmail.com>
 Mak Kolybabi <mak@kolybabi.com>
 Maksym Trykur <maksym.trykur@gmail.com>
@@ -1470,6 +1563,7 @@ Marcel Edmund Franke <marcel.edmund.franke@gmail.com>
 Marcel van Lohuizen <mpvl@golang.org>
 Marcelo Cantos <marcelo.cantos@gmail.com>
 Marcelo E. Magallon <marcelo.magallon@gmail.com>
+Marco Gazerro <gazerro@open2b.com>
 Marco Hennings <marco.hennings@freiheit.com>
 Marcus Weiner <marcus.weiner@gmail.com>
 Marcus Willock <crazcalm@gmail.com>
@@ -1481,6 +1575,7 @@ Marius A. Eriksen <marius@grailbio.com>
 Marius Nuennerich <mnu@google.com>
 Mark Adams <mark@markadams.me>
 Mark Bucciarelli <mkbucc@gmail.com>
+Mark Dain <mark@markdain.net>
 Mark Glines <mark@glines.org>
 Mark Harrison <marhar@google.com>
 Mark Percival <m@mdp.im>
@@ -1533,6 +1628,7 @@ Máté Gulyás <mgulyas86@gmail.com>
 Matej Baćo <matejbaco@gmail.com>
 Mateus Amin <mateus.amin@gmail.com>
 Mateusz Czapliński <czapkofan@gmail.com>
+Matheus Alcantara <matheusssilv97@gmail.com>
 Mathias Beke <git@denbeke.be>
 Mathias Hall-Andersen <mathias@hall-andersen.dk>
 Mathias Leppich <mleppich@muhqu.de>
@@ -1566,6 +1662,7 @@ Matthew Waters <mwwaters@gmail.com>
 Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
 Matthieu Olivier <olivier.matthieu@gmail.com>
 Matthijs Kooijman <matthijs@stdin.nl>
+Max Drosdo.www <g1ran1q@gmail.com>
 Max Riveiro <kavu13@gmail.com>
 Max Schmitt <max@schmitt.mx>
 Max Semenik <maxsem.wiki@gmail.com>
@@ -1603,6 +1700,7 @@ Michael Hudson-Doyle <michael.hudson@linaro.org>
 Michael Kasch <michael.kasch@gmail.com>
 Michael Käufl <golang@c.michael-kaeufl.de>
 Michael Kelly <mjk@google.com>
+Michaël Lévesque-Dion <mlevesquedion@google.com>
 Michael Lewis <mikelikespie@gmail.com>
 Michael MacInnis <Michael.P.MacInnis@gmail.com>
 Michael Marineau <michael.marineau@coreos.com>
@@ -1624,6 +1722,7 @@ Michael Teichgräber <mteichgraeber@gmx.de> <mt4swm@googlemail.com>
 Michael Traver <mtraver@google.com>
 Michael Vetter <g.bluehut@gmail.com>
 Michael Vogt <mvo@ubuntu.com>
+Michail Kargakis <mkargaki@redhat.com>
 Michal Bohuslávek <mbohuslavek@gmail.com>
 Michal Cierniak <cierniak@google.com>
 Michał Derkacz <ziutek@lnet.pl>
@@ -1633,6 +1732,7 @@ Michal Pristas <michal.pristas@gmail.com>
 Michal Rostecki <mrostecki@suse.de>
 Michalis Kargakis <michaliskargakis@gmail.com>
 Michel Lespinasse <walken@google.com>
+Michele Di Pede <michele.di.pede@gmail.com>
 Mickael Kerjean <mickael.kerjean@gmail.com>
 Mickey Reiss <mickeyreiss@gmail.com>
 Miek Gieben <miek@miek.nl> <remigius.gieben@gmail.com>
@@ -1670,6 +1770,7 @@ Miquel Sabaté Solà <mikisabate@gmail.com>
 Mirko Hansen <baaazen@gmail.com>
 Miroslav Genov <mgenov@gmail.com>
 Misty De Meo <mistydemeo@gmail.com>
+Mohamed Attahri <mohamed@attahri.com>
 Mohit Agarwal <mohit@sdf.org>
 Mohit kumar Bajoria <mohitbajo36@gmail.com>
 Mohit Verma <vmohit.93@gmail.com>
@@ -1683,6 +1784,7 @@ Môshe van der Sterre <moshevds@gmail.com>
 Mostyn Bramley-Moore <mostyn@antipode.se>
 Mrunal Patel <mrunalp@gmail.com>
 Muhammad Falak R Wani <falakreyaz@gmail.com>
+Muhammad Hamza Farrukh <hamzafarrukh141@gmail.com>
 Muhammed Uluyol <uluyol0@gmail.com>
 Muir Manders <muir@mnd.rs>
 Mukesh Sharma <sharma.mukesh439@gmail.com>
@@ -1692,6 +1794,7 @@ Naman Aggarwal <aggarwal.nam@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nao Yonashiro <owan.orisano@gmail.com>
 Naoki Kanatani <k12naoki@gmail.com>
+Natanael Copa <ncopa@mirantis.com>
 Nate Wilkinson <nathanwilk7@gmail.com>
 Nathan Cantelmo <n.cantelmo@gmail.com>
 Nathan Caza <mastercactapus@gmail.com>
@@ -1708,6 +1811,7 @@ Nathaniel Cook <nvcook42@gmail.com>
 Naveen Kumar Sangi <naveenkumarsangi@protonmail.com>
 Neeilan Selvalingam <neeilan96@gmail.com>
 Neelesh Chandola <neelesh.c98@gmail.com>
+Nehal J Wani <nehaljw.kkd1@gmail.com>
 Neil Lyons <nwjlyons@googlemail.com>
 Neuman Vong <neuman.vong@gmail.com>
 Neven Sajko <nsajko@gmail.com>
@@ -1760,6 +1864,7 @@ Noel Georgi <git@frezbo.com>
 Norberto Lopes <nlopes.ml@gmail.com>
 Norman B. Lancaster <qbradq@gmail.com>
 Nuno Cruces <ncruces@users.noreply.github.com>
+Obei Sideg <obei.sideg@gmail.com>
 Obeyda Djeffal <djefobey@gmail.com>
 Odin Ugedal <odin@ugedal.com>
 Oleg Bulatov <dmage@yandex-team.ru>
@@ -1769,12 +1874,17 @@ Oling Cat <olingcat@gmail.com>
 Oliver Hookins <ohookins@gmail.com>
 Oliver Powell <oliverpowell84@gmail.com>
 Oliver Stenbom <ostenbom@pivotal.io>
+Oliver Tan <otan@cockroachlabs.com>
 Oliver Tonnhofer <olt@bogosoft.com>
 Olivier Antoine <olivier.antoine@gmail.com>
 Olivier Duperray <duperray.olivier@gmail.com>
 Olivier Poitrey <rs@dailymotion.com>
 Olivier Saingre <osaingre@gmail.com>
+Olivier Wulveryck <olivier.wulveryck@gmail.com>
 Omar Jarjur <ojarjur@google.com>
+Onkar Jadhav <omjadhav2610@gmail.com>
+Ori Bernstein <ori@eigenstate.org>
+Ori Rawlings <orirawlings@gmail.com>
 Oryan Moshe <iamoryanmoshe@gmail.com>
 Osamu TONOMORI <osamingo@gmail.com>
 Özgür Kesim <oec-go@kesim.org>
@@ -1798,7 +1908,9 @@ Pat Moroney <pat@pat.email>
 Patrick Barker <barkerp@vmware.com>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
+Patrick Gundlach <gundlach@speedata.de>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
+Patrick Jones <ithuriel@google.com>
 Patrick Lee <pattyshack101@gmail.com>
 Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
@@ -1811,6 +1923,9 @@ Paul Borman <borman@google.com>
 Paul Boyd <boyd.paul2@gmail.com>
 Paul Chang <paulchang@google.com>
 Paul D. Weber <x0bdev@gmail.com>
+Paul Davis <43160081+Pawls@users.noreply.github.com>
+Paul E. Murphy <murp@ibm.com>
+Paul Forgey <paulf@tessier-ashpool.net>
 Paul Hammond <paul@paulhammond.org>
 Paul Hankin <paulhankin@google.com>
 Paul Jolly <paul@myitcv.org.uk>
@@ -1836,7 +1951,9 @@ Pavel Zinovkin <pavel.zinovkin@gmail.com>
 Pavlo Sumkin <ymkins@gmail.com>
 Pawel Knap <pawelknap88@gmail.com>
 Pawel Szczur <filemon@google.com>
+Paweł Szulik <pawel.szulik@intel.com>
 Pei Xian Chee <luciolas1991@gmail.com>
+Pei-Ming Wu <p408865@gmail.com>
 Percy Wegmann <ox.to.a.cart@gmail.com>
 Perry Abbott <perry.j.abbott@gmail.com>
 Petar Dambovaliev <petar.atanasov.1987@gmail.com>
@@ -1876,6 +1993,7 @@ Philip Hofer <phofer@umich.edu>
 Philip K. Warren <pkwarren@gmail.com>
 Philip Nelson <me@pnelson.ca>
 Philipp Stephani <phst@google.com>
+Phillip Campbell <15082+phillc@users.noreply.github.com>
 Pierre Carru <pierre.carru@eshard.com>
 Pierre Durand <pierredurand@gmail.com>
 Pierre Prinetti <pierreprinetti@gmail.com>
@@ -1885,6 +2003,7 @@ Pieter Droogendijk <pieter@binky.org.uk>
 Pietro Gagliardi <pietro10@mac.com>
 Piyush Mishra <piyush@codeitout.com>
 Plekhanov Maxim <kishtatix@gmail.com>
+Poh Zi How <poh.zihow@gmail.com>
 Polina Osadcha <polliosa@google.com>
 Pontus Leitzler <leitzler@gmail.com>
 Povilas Versockas <p.versockas@gmail.com>
@@ -1904,14 +2023,17 @@ Quentin Perez <qperez@ocs.online.net>
 Quentin Renard <contact@asticode.com>
 Quentin Smith <quentin@golang.org>
 Quey-Liang Kao <s101062801@m101.nthu.edu.tw>
+Quim Muntal <quimmuntal@gmail.com>
 Quinn Slack <sqs@sourcegraph.com>
 Quinten Yearsley <qyearsley@chromium.org>
 Quoc-Viet Nguyen <afelion@gmail.com>
+Radek Simko <radek.simko@gmail.com>
 Radek Sohlich <sohlich@gmail.com>
 Radu Berinde <radu@cockroachlabs.com>
 Rafal Jeczalik <rjeczalik@gmail.com>
 Raghavendra Nagaraj <jamdagni86@gmail.com>
 Rahul Chaudhry <rahulchaudhry@chromium.org>
+Rahul Wadhwani <rahulwadhwani21@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
 Rajat Goel <rajat.goel2010@gmail.com>
 Rajath Agasthya <rajathagasthya@gmail.com>
@@ -1935,6 +2057,7 @@ Ren Ogaki <re.yuz77777@gmail.com>
 Rens Rikkerink <Ikkerens@users.noreply.github.com>
 Rhys Hiltner <rhys@justin.tv>
 Ricardo Padilha <ricardospadilha@gmail.com>
+Ricardo Pchevuzinske Katz <ricardo.katz@serpro.gov.br>
 Ricardo Seriani <ricardo.seriani@gmail.com>
 Richard Barnes <rlb@ipv.sx>
 Richard Crowley <r@rcrowley.org>
@@ -1991,6 +2114,7 @@ Roman Kollár <roman.kollar.0@gmail.com>
 Roman Shchekin <mrqtros@gmail.com>
 Ron Hashimoto <mail@h2so5.net>
 Ron Minnich <rminnich@gmail.com>
+Ronnie Ebrin <ebrin.ronnie@protonmail.com>
 Ross Chater <rdchater@gmail.com>
 Ross Kinsey <rossikinsey@gmail.com>
 Ross Light <light@google.com> <rlight2@gmail.com>
@@ -2010,6 +2134,7 @@ Ryan Brown <ribrdb@google.com>
 Ryan Canty <jrcanty@gmail.com>
 Ryan Dahl <ry@tinyclouds.org>
 Ryan Hitchman <hitchmanr@gmail.com>
+Ryan Kohler <ryankohler@google.com>
 Ryan Lower <rpjlower@gmail.com>
 Ryan Roden-Corrent <ryan@rcorre.net>
 Ryan Seys <ryan@ryanseys.com>
@@ -2023,7 +2148,9 @@ S.Çağlar Onur <caglar@10ur.org>
 Sabin Mihai Rapan <sabin.rapan@gmail.com>
 Sad Pencil <qh06@qq.com>
 Sai Cheemalapati <saicheems@google.com>
+Sai Kiran Dasika <kirandasika30@gmail.com>
 Sakeven Jiang <jc5930@sina.cn>
+Salaheddin M. Mahmud <salah.mahmud@gmail.com>
 Salmān Aljammāz <s@0x65.net>
 Sam Arnold <sarnold64@bloomberg.net>
 Sam Boyer <tech@samboyer.org>
@@ -2033,6 +2160,7 @@ Sam Ding <samding@ca.ibm.com>
 Sam Hug <samuel.b.hug@gmail.com>
 Sam Thorogood <thorogood@google.com> <sam.thorogood@gmail.com>
 Sam Whited <sam@samwhited.com>
+Sam Xie <xsambundy@gmail.com>
 Sameer Ajmani <sameer@golang.org> <ajmani@gmail.com>
 Sami Commerot <samic@google.com>
 Sami Pönkänen <sami.ponkanen@gmail.com>
@@ -2042,6 +2170,7 @@ Samuele Pedroni <pedronis@lucediurna.net>
 Sander van Harmelen <sander@vanharmelen.nl>
 Sanjay Menakuru <balasanjay@gmail.com>
 Santhosh Kumar Tekuri <santhosh.tekuri@gmail.com>
+Santiago De la Cruz <51337247+xhit@users.noreply.github.com>
 Sarah Adams <shadams@google.com>
 Sardorbek Pulatov <sardorbek.pulatov@outlook.com>
 Sascha Brawer <sascha@brawer.ch>
@@ -2062,6 +2191,7 @@ Sean Chittenden <seanc@joyent.com>
 Sean Christopherson <sean.j.christopherson@intel.com>
 Sean Dolphin <Sean.Dolphin@kpcompass.com>
 Sean Harger <sharger@google.com>
+Sean Hildebrand <seanwhildebrand@gmail.com>
 Sean Liao <seankhliao@gmail.com>
 Sean Rees <sean@erifax.org>
 Sebastiaan van Stijn <github@gone.nl>
@@ -2094,10 +2224,12 @@ Serhii Aheienko <serhii.aheienko@gmail.com>
 Seth Hoenig <seth.a.hoenig@gmail.com>
 Seth Vargo <sethvargo@gmail.com>
 Shahar Kohanim <skohanim@gmail.com>
+Shailesh Suryawanshi <ss.shailesh28@gmail.com>
 Shamil Garatuev <garatuev@gmail.com>
 Shane Hansen <shanemhansen@gmail.com>
 Shang Jian Ding <sding3@ncsu.edu>
 Shaozhen Ding <dsz0111@gmail.com>
+Shaquille Que <shaquille@golang.org>
 Shaquille Wyan Que <shaqqywyan@gmail.com>
 Shaun Dunning <shaun.dunning@uservoice.com>
 Shawn Elliott <selliott@microsoft.com>
@@ -2108,8 +2240,11 @@ Shenghou Ma <minux@golang.org> <minux.ma@gmail.com>
 Shengjing Zhu <zsj950618@gmail.com>
 Shengyu Zhang <shengyu.zhang@chaitin.com>
 Shi Han Ng <shihanng@gmail.com>
+ShihCheng Tu <mrtoastcheng@gmail.com>
 Shijie Hao <haormj@gmail.com>
+Shin Fan <shinfan@google.com>
 Shinji Tanaka <shinji.tanaka@gmail.com>
+Shinnosuke Sawada <6warashi9@gmail.com>
 Shintaro Kaneko <kaneshin0120@gmail.com>
 Shivakumar GN <shivakumar.gn@gmail.com>
 Shivani Singhal <shivani.singhal2804@gmail.com>
@@ -2121,17 +2256,21 @@ Silvan Jegen <s.jegen@gmail.com>
 Simarpreet Singh <simar@linux.com>
 Simon Drake <simondrake1990@gmail.com>
 Simon Ferquel <simon.ferquel@docker.com>
+Simon Frei <freisim93@gmail.com>
 Simon Jefford <simon.jefford@gmail.com>
 Simon Rawet <simon@rawet.se>
 Simon Rozman <simon@rozman.si>
+Simon Ser <contact@emersion.fr>
 Simon Thulbourn <simon+github@thulbourn.com>
 Simon Whitehead <chemnova@gmail.com>
 Sina Siadat <siadat@gmail.com>
 Sjoerd Siebinga <sjoerd.siebinga@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Song Gao <song@gao.io>
+Songjiayang <songjiayang1@gmail.com>
 Soojin Nam <jsunam@gmail.com>
 Søren L. Hansen <soren@linux2go.dk>
+Sparrow Li <liyuancylx@gmail.com>
 Spencer Kocot <spencerkocot@gmail.com>
 Spencer Nelson <s@spenczar.com>
 Spencer Tung <spencertung@google.com>
@@ -2140,12 +2279,14 @@ Srdjan Petrovic <spetrovic@google.com>
 Sridhar Venkatakrishnan <sridhar@laddoo.net>
 Srinidhi Kaushik <shrinidhi.kaushik@gmail.com>
 StalkR <stalkr@stalkr.net>
+Stan Hu <stanhu@gmail.com>
 Stan Schwertly <stan@schwertly.com>
 Stanislav Afanasev <php.progger@gmail.com>
 Steeve Morin <steeve.morin@gmail.com>
 Stefan Baebler <sbaebler@outbrain.com>
 Stefan Nilsson <snilsson@nada.kth.se> <trolleriprofessorn@gmail.com>
 Stepan Shabalin <neverliberty@gmail.com>
+Stephan Klatt <stephan.klatt@gmail.com>
 Stephan Renatus <srenatus@chef.io>
 Stephan Zuercher <zuercher@gmail.com>
 Stéphane Travostino <stephane.travostino@gmail.com>
@@ -2163,13 +2304,16 @@ Steve Mynott <steve.mynott@gmail.com>
 Steve Newman <snewman@google.com>
 Steve Phillips <elimisteve@gmail.com>
 Steve Streeting <steve@stevestreeting.com>
+Steve Traut <straut@google.com>
 Steven Buss <sbuss@google.com>
 Steven Elliot Harris <seharris@gmail.com>
 Steven Erenst <stevenerenst@gmail.com>
 Steven Hartland <steven.hartland@multiplay.co.uk>
 Steven Littiebrant <imgroxx@gmail.com>
+Steven Maude <git@stevenmaude.co.uk>
 Steven Wilkin <stevenwilkin@gmail.com>
 Stuart Jansen <sjansen@buscaluz.org>
+Subham Sarkar <sarkar.subhams2@gmail.com>
 Sue Spence <virtuallysue@gmail.com>
 Sugu Sougoumarane <ssougou@gmail.com>
 Suharsh Sivakumar <suharshs@google.com>
@@ -2193,6 +2337,7 @@ Taesu Pyo <pyotaesu@gmail.com>
 Tai Le <letientai299@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
 Takashi Matsuo <tmatsuo@google.com>
+Takashi Mima <tks.m1205@gmail.com>
 Takayoshi Nishida <takayoshi.nishida@gmail.com>
 Takeshi YAMANASHI <9.nashi@gmail.com>
 Takuto Ikuta <tikuta@google.com>
@@ -2221,6 +2366,7 @@ Thanatat Tamtan <acoshift@gmail.com>
 The Hatsune Daishi <nao20010128@gmail.com>
 Thiago Avelino <t@avelino.xxx>
 Thiago Fransosi Farina <thiago.farina@gmail.com> <tfarina@chromium.org>
+Thom Wiggers <thom@thomwiggers.nl>
 Thomas Alan Copeland <talan.copeland@gmail.com>
 Thomas Bonfort <thomas.bonfort@gmail.com>
 Thomas Bouldin <inlined@google.com>
@@ -2245,6 +2391,7 @@ Tim Ebringer <tim.ebringer@gmail.com>
 Tim Heckman <t@heckman.io>
 Tim Henderson <tim.tadh@gmail.com>
 Tim Hockin <thockin@google.com>
+Tim King <taking@google.com>
 Tim Möhlmann <muhlemmer@gmail.com>
 Tim Swast <swast@google.com>
 Tim Wright <tenortim@gmail.com>
@@ -2252,8 +2399,10 @@ Tim Xu <xiaoxubeii@gmail.com>
 Timmy Douglas <timmyd983@gmail.com>
 Timo Savola <timo.savola@gmail.com>
 Timo Truyts <alkaloid.btx@gmail.com>
+Timothy Gu <timothygu99@gmail.com>
 Timothy Studd <tim@timstudd.com>
 Tipp Moseley <tipp@google.com>
+Tiwei Bie <tiwei.btw@antgroup.com>
 Tobias Assarsson <tobias.assarsson@gmail.com>
 Tobias Columbus <tobias.columbus@gmail.com> <tobias.columbus@googlemail.com>
 Tobias Klauser <tklauser@distanz.ch>
@@ -2268,11 +2417,13 @@ Tom Lanyon <tomlanyon@google.com>
 Tom Levy <tomlevy93@gmail.com>
 Tom Limoncelli <tal@whatexit.org>
 Tom Linford <tomlinford@gmail.com>
+Tom Panton <tom@tomandtally.co.uk>
 Tom Parkin <tom.parkin@gmail.com>
 Tom Payne <twpayne@gmail.com>
 Tom Szymanski <tgs@google.com>
 Tom Thorogood <me+google@tomthorogood.co.uk>
 Tom Wilkie <tom@weave.works>
+Tom Zierbock <tomzierbock@gmail.com>
 Tomas Dabasinskas <tomas@dabasinskas.net>
 Tommy Schaefer <tommy.schaefer@teecom.com>
 Tomohiro Kusumoto <zabio1192@gmail.com>
@@ -2298,6 +2449,7 @@ Tristan Colgate <tcolgate@gmail.com>
 Tristan Ooohry <ooohry@gmail.com>
 Tristan Rice <rice@fn.lc>
 Troels Thomsen <troels@thomsen.io>
+Trong Bui <trong.buiquoc@gmail.com>
 Trung Nguyen <trung.n.k@gmail.com>
 Tsuji Daishiro <dram.dt.shonan@gmail.com>
 Tudor Golubenco <tudor.g@gmail.com>
@@ -2308,6 +2460,7 @@ Tyler Bunnell <tylerbunnell@gmail.com>
 Tyler Treat <ttreat31@gmail.com>
 Tyson Andre <tysonandre775@gmail.com>
 Tzach Shabtay <tzachshabtay@gmail.com>
+Tzu-Chiao Yeh <su3g4284zo6y7@gmail.com>
 Tzu-Jung Lee <roylee17@currant.com>
 Udalov Max <re.udalov@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
@@ -2316,6 +2469,7 @@ Ulrich Kunitz <uli.kunitz@gmail.com>
 Umang Parmar <umangjparmar@gmail.com>
 Uriel Mangado <uriel@berlinblue.org>
 Urvil Patel <patelurvil38@gmail.com>
+Utkarsh Dixit <53217283+utkarsh-extc@users.noreply.github.com>
 Uttam C Pawar <uttam.c.pawar@intel.com>
 Vadim Grek <vadimprog@gmail.com>
 Vadim Vygonets <unixdj@gmail.com>
@@ -2327,6 +2481,7 @@ Venil Noronha <veniln@vmware.com>
 Veselkov Konstantin <kostozyb@gmail.com>
 Viacheslav Poturaev <vearutop@gmail.com>
 Victor Chudnovsky <vchudnov@google.com>
+Victor Michel <victor@optimyze.cloud>
 Victor Vrantchan <vrancean+github@gmail.com>
 Vignesh Ramachandra <vickyramachandra@gmail.com>
 Vikas Kedia <vikask@google.com>
@@ -2341,6 +2496,7 @@ Visweswara R <r.visweswara@gmail.com>
 Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
 Vitor De Mario <vitordemario@gmail.com>
 Vivek Sekhar <vsekhar@google.com>
+Vivek V <iamvivekv96@gmail.com>
 Vivian Liang <vliang88@gmail.com>
 Vlad Krasnov <vlad@cloudflare.com>
 Vladimir Evgrafov <evgrafov.vladimir@gmail.com>
@@ -2392,6 +2548,7 @@ Wu Yunzhou <yunzhouwu@gmail.com>
 Xi Ruoyao <xry23333@gmail.com>
 Xia Bin <snyh@snyh.org>
 Xiangdong Ji <xiangdong.ji@arm.com>
+Xiaodong Liu <teaofmoli@gmail.com>
 Xing Xing <mikespook@gmail.com>
 Xingqang Bai <bxq2011hust@qq.com>
 Xu Fei <badgangkiller@gmail.com>
@@ -2459,6 +2616,7 @@ Zhou Peng <p@ctriple.cn>
 Ziad Hatahet <hatahet@gmail.com>
 Ziheng Liu <lzhfromustc@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
+Zyad A. Ali <zyad.ali.me@gmail.com>
 Максадбек Ахмедов <a.maksadbek@gmail.com>
 Максим Федосеев <max.faceless.frei@gmail.com>
 Роман Хавроненко <hagen1778@gmail.com>

README.md

@@ -3,7 +3,7 @@
 Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.
 
-![Gopher image](doc/gopher/fiveyears.jpg)
+![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
 *Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
 
 Our canonical Git repository is located at https://go.googlesource.com/go.
@@ -19,22 +19,20 @@ BSD-style license found in the LICENSE file.
 Official binary distributions are available at https://golang.org/dl/.
 
 After downloading a binary release, visit https://golang.org/doc/install
-or load [doc/install.html](./doc/install.html) in your web browser for installation
-instructions.
+for installation instructions.
 
 #### Install From Source
 
 If a binary distribution is not available for your combination of
 operating system and architecture, visit
-https://golang.org/doc/install/source or load [doc/install-source.html](./doc/install-source.html)
-in your web browser for source installation instructions.
+https://golang.org/doc/install/source
+for source installation instructions.
 
 ### Contributing
 
 Go is the work of thousands of contributors. We appreciate your help!
 
-To contribute, please read the contribution guidelines:
-	https://golang.org/doc/contribute.html
+To contribute, please read the contribution guidelines at https://golang.org/doc/contribute.html.
 
 Note that the Go project uses the issue tracker for bug reports and
 proposals only. See https://golang.org/wiki/Questions for a list of

VERSION

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

api/except.txt

@@ -2,12 +2,56 @@ pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
 pkg math/big, const MaxBase = 36
 pkg math/big, type Word uintptr
 pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
+pkg os (linux-arm), const O_SYNC = 1052672
+pkg os (linux-arm), const O_SYNC = 4096
+pkg os (linux-arm-cgo), const O_SYNC = 1052672
+pkg os (linux-arm-cgo), const O_SYNC = 4096
+pkg os, const ModeAppend FileMode
+pkg os, const ModeCharDevice FileMode
+pkg os, const ModeDevice FileMode
+pkg os, const ModeDir FileMode
+pkg os, const ModeExclusive FileMode
+pkg os, const ModeIrregular FileMode
+pkg os, const ModeNamedPipe FileMode
+pkg os, const ModePerm FileMode
+pkg os, const ModeSetgid FileMode
+pkg os, const ModeSetuid FileMode
+pkg os, const ModeSocket FileMode
+pkg os, const ModeSticky FileMode
+pkg os, const ModeSymlink FileMode
+pkg os, const ModeTemporary FileMode
 pkg os, const ModeType = 2399141888
 pkg os, const ModeType = 2399666176
-pkg os (linux-arm), const O_SYNC = 4096
-pkg os (linux-arm-cgo), const O_SYNC = 4096
-pkg os (linux-arm), const O_SYNC = 1052672
-pkg os (linux-arm-cgo), const O_SYNC = 1052672
+pkg os, const ModeType FileMode
+pkg os, func Chmod(string, FileMode) error
+pkg os, func Lstat(string) (FileInfo, error)
+pkg os, func Mkdir(string, FileMode) error
+pkg os, func MkdirAll(string, FileMode) error
+pkg os, func OpenFile(string, int, FileMode) (*File, error)
+pkg os, func SameFile(FileInfo, FileInfo) bool
+pkg os, func Stat(string) (FileInfo, error)
+pkg os, method (*File) Chmod(FileMode) error
+pkg os, method (*File) Readdir(int) ([]FileInfo, error)
+pkg os, method (*File) Stat() (FileInfo, error)
+pkg os, method (*PathError) Error() string
+pkg os, method (*PathError) Timeout() bool
+pkg os, method (*PathError) Unwrap() error
+pkg os, method (FileMode) IsDir() bool
+pkg os, method (FileMode) IsRegular() bool
+pkg os, method (FileMode) Perm() FileMode
+pkg os, method (FileMode) String() string
+pkg os, type FileInfo interface { IsDir, ModTime, Mode, Name, Size, Sys }
+pkg os, type FileInfo interface, IsDir() bool
+pkg os, type FileInfo interface, ModTime() time.Time
+pkg os, type FileInfo interface, Mode() FileMode
+pkg os, type FileInfo interface, Name() string
+pkg os, type FileInfo interface, Size() int64
+pkg os, type FileInfo interface, Sys() interface{}
+pkg os, type FileMode uint32
+pkg os, type PathError struct
+pkg os, type PathError struct, Err error
+pkg os, type PathError struct, Op string
+pkg os, type PathError struct, Path string
 pkg syscall (darwin-amd64), const ImplementsGetwd = false
 pkg syscall (darwin-amd64), func Fchflags(string, int) error
 pkg syscall (darwin-amd64-cgo), const ImplementsGetwd = false
@@ -18,22 +62,72 @@ pkg syscall (freebsd-386), const ELAST = 94
 pkg syscall (freebsd-386), const ImplementsGetwd = false
 pkg syscall (freebsd-386), const O_CLOEXEC = 0
 pkg syscall (freebsd-386), func Fchflags(string, int) error
+pkg syscall (freebsd-386), func Mknod(string, uint32, int) error
+pkg syscall (freebsd-386), type Dirent struct, Fileno uint32
+pkg syscall (freebsd-386), type Dirent struct, Namlen uint8
+pkg syscall (freebsd-386), type Stat_t struct, Blksize uint32
+pkg syscall (freebsd-386), type Stat_t struct, Dev uint32
+pkg syscall (freebsd-386), type Stat_t struct, Gen uint32
+pkg syscall (freebsd-386), type Stat_t struct, Ino uint32
+pkg syscall (freebsd-386), type Stat_t struct, Lspare int32
+pkg syscall (freebsd-386), type Stat_t struct, Nlink uint16
+pkg syscall (freebsd-386), type Stat_t struct, Pad_cgo_0 [8]uint8
+pkg syscall (freebsd-386), type Stat_t struct, Rdev uint32
+pkg syscall (freebsd-386), type Statfs_t struct, Mntfromname [88]int8
+pkg syscall (freebsd-386), type Statfs_t struct, Mntonname [88]int8
 pkg syscall (freebsd-386-cgo), const AF_MAX = 38
 pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX = 242
 pkg syscall (freebsd-386-cgo), const ELAST = 94
 pkg syscall (freebsd-386-cgo), const ImplementsGetwd = false
 pkg syscall (freebsd-386-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-386-cgo), func Mknod(string, uint32, int) error
+pkg syscall (freebsd-386-cgo), type Dirent struct, Fileno uint32
+pkg syscall (freebsd-386-cgo), type Dirent struct, Namlen uint8
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Blksize uint32
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Dev uint32
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Gen uint32
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Ino uint32
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Lspare int32
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Nlink uint16
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Pad_cgo_0 [8]uint8
+pkg syscall (freebsd-386-cgo), type Stat_t struct, Rdev uint32
+pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntfromname [88]int8
+pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntonname [88]int8
 pkg syscall (freebsd-amd64), const AF_MAX = 38
 pkg syscall (freebsd-amd64), const DLT_MATCHING_MAX = 242
 pkg syscall (freebsd-amd64), const ELAST = 94
 pkg syscall (freebsd-amd64), const ImplementsGetwd = false
 pkg syscall (freebsd-amd64), const O_CLOEXEC = 0
 pkg syscall (freebsd-amd64), func Fchflags(string, int) error
+pkg syscall (freebsd-amd64), func Mknod(string, uint32, int) error
+pkg syscall (freebsd-amd64), type Dirent struct, Fileno uint32
+pkg syscall (freebsd-amd64), type Dirent struct, Namlen uint8
+pkg syscall (freebsd-amd64), type Stat_t struct, Blksize uint32
+pkg syscall (freebsd-amd64), type Stat_t struct, Dev uint32
+pkg syscall (freebsd-amd64), type Stat_t struct, Gen uint32
+pkg syscall (freebsd-amd64), type Stat_t struct, Ino uint32
+pkg syscall (freebsd-amd64), type Stat_t struct, Lspare int32
+pkg syscall (freebsd-amd64), type Stat_t struct, Nlink uint16
+pkg syscall (freebsd-amd64), type Stat_t struct, Rdev uint32
+pkg syscall (freebsd-amd64), type Statfs_t struct, Mntfromname [88]int8
+pkg syscall (freebsd-amd64), type Statfs_t struct, Mntonname [88]int8
 pkg syscall (freebsd-amd64-cgo), const AF_MAX = 38
 pkg syscall (freebsd-amd64-cgo), const DLT_MATCHING_MAX = 242
 pkg syscall (freebsd-amd64-cgo), const ELAST = 94
 pkg syscall (freebsd-amd64-cgo), const ImplementsGetwd = false
 pkg syscall (freebsd-amd64-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-amd64-cgo), func Mknod(string, uint32, int) error
+pkg syscall (freebsd-amd64-cgo), type Dirent struct, Fileno uint32
+pkg syscall (freebsd-amd64-cgo), type Dirent struct, Namlen uint8
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Blksize uint32
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Dev uint32
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Gen uint32
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Ino uint32
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Lspare int32
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Nlink uint16
+pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Rdev uint32
+pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntfromname [88]int8
+pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntonname [88]int8
 pkg syscall (freebsd-arm), const AF_MAX = 38
 pkg syscall (freebsd-arm), const BIOCGRTIMEOUT = 1074545262
 pkg syscall (freebsd-arm), const BIOCSRTIMEOUT = 2148287085
@@ -62,10 +156,22 @@ pkg syscall (freebsd-arm), const SizeofSockaddrDatalink = 56
 pkg syscall (freebsd-arm), const SizeofSockaddrUnix = 108
 pkg syscall (freebsd-arm), const TIOCTIMESTAMP = 1074558041
 pkg syscall (freebsd-arm), func Fchflags(string, int) error
+pkg syscall (freebsd-arm), func Mknod(string, uint32, int) error
 pkg syscall (freebsd-arm), type BpfHdr struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type Dirent struct, Fileno uint32
+pkg syscall (freebsd-arm), type Dirent struct, Namlen uint8
 pkg syscall (freebsd-arm), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
 pkg syscall (freebsd-arm), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type Stat_t struct, Blksize uint32
+pkg syscall (freebsd-arm), type Stat_t struct, Dev uint32
+pkg syscall (freebsd-arm), type Stat_t struct, Gen uint32
+pkg syscall (freebsd-arm), type Stat_t struct, Ino uint32
+pkg syscall (freebsd-arm), type Stat_t struct, Lspare int32
+pkg syscall (freebsd-arm), type Stat_t struct, Nlink uint16
 pkg syscall (freebsd-arm), type Stat_t struct, Pad_cgo_0 [4]uint8
+pkg syscall (freebsd-arm), type Stat_t struct, Rdev uint32
+pkg syscall (freebsd-arm), type Statfs_t struct, Mntfromname [88]int8
+pkg syscall (freebsd-arm), type Statfs_t struct, Mntonname [88]int8
 pkg syscall (freebsd-arm-cgo), const AF_MAX = 38
 pkg syscall (freebsd-arm-cgo), const BIOCGRTIMEOUT = 1074545262
 pkg syscall (freebsd-arm-cgo), const BIOCSRTIMEOUT = 2148287085
@@ -94,10 +200,22 @@ pkg syscall (freebsd-arm-cgo), const SizeofSockaddrDatalink = 56
 pkg syscall (freebsd-arm-cgo), const SizeofSockaddrUnix = 108
 pkg syscall (freebsd-arm-cgo), const TIOCTIMESTAMP = 1074558041
 pkg syscall (freebsd-arm-cgo), func Fchflags(string, int) error
+pkg syscall (freebsd-arm-cgo), func Mknod(string, uint32, int) error
 pkg syscall (freebsd-arm-cgo), type BpfHdr struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type Dirent struct, Fileno uint32
+pkg syscall (freebsd-arm-cgo), type Dirent struct, Namlen uint8
 pkg syscall (freebsd-arm-cgo), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
 pkg syscall (freebsd-arm-cgo), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Blksize uint32
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Dev uint32
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Gen uint32
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Ino uint32
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Lspare int32
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Nlink uint16
 pkg syscall (freebsd-arm-cgo), type Stat_t struct, Pad_cgo_0 [4]uint8
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Rdev uint32
+pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntfromname [88]int8
+pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntonname [88]int8
 pkg syscall (linux-386), type Cmsghdr struct, X__cmsg_data [0]uint8
 pkg syscall (linux-386-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
 pkg syscall (linux-amd64), type Cmsghdr struct, X__cmsg_data [0]uint8
@@ -109,10 +227,10 @@ pkg syscall (netbsd-386-cgo), const ImplementsGetwd = false
 pkg syscall (netbsd-amd64), const ImplementsGetwd = false
 pkg syscall (netbsd-amd64-cgo), const ImplementsGetwd = false
 pkg syscall (netbsd-arm), const ImplementsGetwd = false
-pkg syscall (netbsd-arm-cgo), const ImplementsGetwd = false
 pkg syscall (netbsd-arm), const SizeofIfData = 132
 pkg syscall (netbsd-arm), func Fchflags(string, int) error
 pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
+pkg syscall (netbsd-arm-cgo), const ImplementsGetwd = false
 pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
 pkg syscall (netbsd-arm-cgo), func Fchflags(string, int) error
 pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
@@ -140,6 +258,7 @@ pkg syscall (openbsd-386), const SYS_GETITIMER = 86
 pkg syscall (openbsd-386), const SYS_GETRUSAGE = 117
 pkg syscall (openbsd-386), const SYS_GETTIMEOFDAY = 116
 pkg syscall (openbsd-386), const SYS_KEVENT = 270
+pkg syscall (openbsd-386), const SYS_KILL = 37
 pkg syscall (openbsd-386), const SYS_LSTAT = 293
 pkg syscall (openbsd-386), const SYS_NANOSLEEP = 240
 pkg syscall (openbsd-386), const SYS_SELECT = 93
@@ -193,6 +312,7 @@ pkg syscall (openbsd-386-cgo), const SYS_GETITIMER = 86
 pkg syscall (openbsd-386-cgo), const SYS_GETRUSAGE = 117
 pkg syscall (openbsd-386-cgo), const SYS_GETTIMEOFDAY = 116
 pkg syscall (openbsd-386-cgo), const SYS_KEVENT = 270
+pkg syscall (openbsd-386-cgo), const SYS_KILL = 37
 pkg syscall (openbsd-386-cgo), const SYS_LSTAT = 293
 pkg syscall (openbsd-386-cgo), const SYS_NANOSLEEP = 240
 pkg syscall (openbsd-386-cgo), const SYS_SELECT = 93
@@ -257,6 +377,7 @@ pkg syscall (openbsd-amd64), const SYS_GETITIMER = 86
 pkg syscall (openbsd-amd64), const SYS_GETRUSAGE = 117
 pkg syscall (openbsd-amd64), const SYS_GETTIMEOFDAY = 116
 pkg syscall (openbsd-amd64), const SYS_KEVENT = 270
+pkg syscall (openbsd-amd64), const SYS_KILL = 37
 pkg syscall (openbsd-amd64), const SYS_LSTAT = 293
 pkg syscall (openbsd-amd64), const SYS_NANOSLEEP = 240
 pkg syscall (openbsd-amd64), const SYS_SELECT = 93
@@ -320,6 +441,7 @@ pkg syscall (openbsd-amd64-cgo), const SYS_GETITIMER = 86
 pkg syscall (openbsd-amd64-cgo), const SYS_GETRUSAGE = 117
 pkg syscall (openbsd-amd64-cgo), const SYS_GETTIMEOFDAY = 116
 pkg syscall (openbsd-amd64-cgo), const SYS_KEVENT = 270
+pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 37
 pkg syscall (openbsd-amd64-cgo), const SYS_LSTAT = 293
 pkg syscall (openbsd-amd64-cgo), const SYS_NANOSLEEP = 240
 pkg syscall (openbsd-amd64-cgo), const SYS_SELECT = 93
@@ -348,19 +470,6 @@ pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, F_spare [3]uint32
 pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Pad_cgo_0 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Sec int32
-pkg testing, func RegisterCover(Cover)
-pkg testing, func MainStart(func(string, string) (bool, error), []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg text/template/parse, type DotNode bool
-pkg text/template/parse, type Node interface { Copy, String, Type }
-pkg unicode, const Version = "6.2.0"
-pkg unicode, const Version = "6.3.0"
-pkg unicode, const Version = "7.0.0"
-pkg unicode, const Version = "8.0.0"
-pkg syscall (openbsd-386), const SYS_KILL = 37
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 37
-pkg syscall (openbsd-amd64), const SYS_KILL = 37
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 37
-pkg unicode, const Version = "9.0.0"
 pkg syscall (windows-386), const TOKEN_ALL_ACCESS = 983295
 pkg syscall (windows-386), type AddrinfoW struct, Addr uintptr
 pkg syscall (windows-386), type CertChainPolicyPara struct, ExtraPolicyPara uintptr
@@ -379,81 +488,16 @@ pkg syscall (windows-amd64), type CertRevocationInfo struct, CrlInfo uintptr
 pkg syscall (windows-amd64), type CertRevocationInfo struct, OidSpecificInfo uintptr
 pkg syscall (windows-amd64), type CertSimpleChain struct, TrustListInfo uintptr
 pkg syscall (windows-amd64), type RawSockaddrAny struct, Pad [96]int8
-pkg syscall (freebsd-386), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-386), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-386), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-386), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-386), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-386), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-386), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-386), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-386), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-386), type Stat_t struct, Pad_cgo_0 [8]uint8
-pkg syscall (freebsd-386), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-386), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-386), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-386-cgo), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-386-cgo), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-386-cgo), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Pad_cgo_0 [8]uint8
-pkg syscall (freebsd-386-cgo), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-386-cgo), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-amd64), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-amd64), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-amd64), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-amd64), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-amd64), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-amd64), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-amd64), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-amd64), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-amd64), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-amd64-cgo), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-amd64-cgo), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-amd64-cgo), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-amd64-cgo), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-arm), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-arm), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-arm), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-arm), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-arm), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-arm), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-arm), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-arm), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-arm), type Statfs_t struct, Mntonname [88]int8
-pkg syscall (freebsd-arm-cgo), func Mknod(string, uint32, int) error
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Fileno uint32
-pkg syscall (freebsd-arm-cgo), type Dirent struct, Namlen uint8
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Blksize uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Dev uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Gen uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Ino uint32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Lspare int32
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Nlink uint16
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Rdev uint32
-pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntfromname [88]int8
-pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntonname [88]int8
+pkg testing, func MainStart(func(string, string) (bool, error), []InternalTest, []InternalBenchmark, []InternalExample) *M
+pkg testing, func RegisterCover(Cover)
 pkg text/scanner, const GoTokens = 1012
+pkg text/template/parse, type DotNode bool
+pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg unicode, const Version = "10.0.0"
 pkg unicode, const Version = "11.0.0"
 pkg unicode, const Version = "12.0.0"
+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 unicode, const Version = "9.0.0"

api/go1.16.txt

@@ -0,0 +1,501 @@
+pkg archive/zip, method (*ReadCloser) Open(string) (fs.File, error)
+pkg archive/zip, method (*Reader) Open(string) (fs.File, error)
+pkg crypto/x509, method (SystemRootsError) Unwrap() error
+pkg debug/elf, const DT_ADDRRNGHI = 1879047935
+pkg debug/elf, const DT_ADDRRNGHI DynTag
+pkg debug/elf, const DT_ADDRRNGLO = 1879047680
+pkg debug/elf, const DT_ADDRRNGLO DynTag
+pkg debug/elf, const DT_AUDIT = 1879047932
+pkg debug/elf, const DT_AUDIT DynTag
+pkg debug/elf, const DT_AUXILIARY = 2147483645
+pkg debug/elf, const DT_AUXILIARY DynTag
+pkg debug/elf, const DT_CHECKSUM = 1879047672
+pkg debug/elf, const DT_CHECKSUM DynTag
+pkg debug/elf, const DT_CONFIG = 1879047930
+pkg debug/elf, const DT_CONFIG DynTag
+pkg debug/elf, const DT_DEPAUDIT = 1879047931
+pkg debug/elf, const DT_DEPAUDIT DynTag
+pkg debug/elf, const DT_FEATURE = 1879047676
+pkg debug/elf, const DT_FEATURE DynTag
+pkg debug/elf, const DT_FILTER = 2147483647
+pkg debug/elf, const DT_FILTER DynTag
+pkg debug/elf, const DT_FLAGS_1 = 1879048187
+pkg debug/elf, const DT_FLAGS_1 DynTag
+pkg debug/elf, const DT_GNU_CONFLICT = 1879047928
+pkg debug/elf, const DT_GNU_CONFLICT DynTag
+pkg debug/elf, const DT_GNU_CONFLICTSZ = 1879047670
+pkg debug/elf, const DT_GNU_CONFLICTSZ DynTag
+pkg debug/elf, const DT_GNU_HASH = 1879047925
+pkg debug/elf, const DT_GNU_HASH DynTag
+pkg debug/elf, const DT_GNU_LIBLIST = 1879047929
+pkg debug/elf, const DT_GNU_LIBLIST DynTag
+pkg debug/elf, const DT_GNU_LIBLISTSZ = 1879047671
+pkg debug/elf, const DT_GNU_LIBLISTSZ DynTag
+pkg debug/elf, const DT_GNU_PRELINKED = 1879047669
+pkg debug/elf, const DT_GNU_PRELINKED DynTag
+pkg debug/elf, const DT_MIPS_AUX_DYNAMIC = 1879048241
+pkg debug/elf, const DT_MIPS_AUX_DYNAMIC DynTag
+pkg debug/elf, const DT_MIPS_BASE_ADDRESS = 1879048198
+pkg debug/elf, const DT_MIPS_BASE_ADDRESS DynTag
+pkg debug/elf, const DT_MIPS_COMPACT_SIZE = 1879048239
+pkg debug/elf, const DT_MIPS_COMPACT_SIZE DynTag
+pkg debug/elf, const DT_MIPS_CONFLICT = 1879048200
+pkg debug/elf, const DT_MIPS_CONFLICT DynTag
+pkg debug/elf, const DT_MIPS_CONFLICTNO = 1879048203
+pkg debug/elf, const DT_MIPS_CONFLICTNO DynTag
+pkg debug/elf, const DT_MIPS_CXX_FLAGS = 1879048226
+pkg debug/elf, const DT_MIPS_CXX_FLAGS DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASS = 1879048215
+pkg debug/elf, const DT_MIPS_DELTA_CLASS DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM = 1879048224
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM_NO = 1879048225
+pkg debug/elf, const DT_MIPS_DELTA_CLASSSYM_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_CLASS_NO = 1879048216
+pkg debug/elf, const DT_MIPS_DELTA_CLASS_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE = 1879048217
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE DynTag
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE_NO = 1879048218
+pkg debug/elf, const DT_MIPS_DELTA_INSTANCE_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_RELOC = 1879048219
+pkg debug/elf, const DT_MIPS_DELTA_RELOC DynTag
+pkg debug/elf, const DT_MIPS_DELTA_RELOC_NO = 1879048220
+pkg debug/elf, const DT_MIPS_DELTA_RELOC_NO DynTag
+pkg debug/elf, const DT_MIPS_DELTA_SYM = 1879048221
+pkg debug/elf, const DT_MIPS_DELTA_SYM DynTag
+pkg debug/elf, const DT_MIPS_DELTA_SYM_NO = 1879048222
+pkg debug/elf, const DT_MIPS_DELTA_SYM_NO DynTag
+pkg debug/elf, const DT_MIPS_DYNSTR_ALIGN = 1879048235
+pkg debug/elf, const DT_MIPS_DYNSTR_ALIGN DynTag
+pkg debug/elf, const DT_MIPS_FLAGS = 1879048197
+pkg debug/elf, const DT_MIPS_FLAGS DynTag
+pkg debug/elf, const DT_MIPS_GOTSYM = 1879048211
+pkg debug/elf, const DT_MIPS_GOTSYM DynTag
+pkg debug/elf, const DT_MIPS_GP_VALUE = 1879048240
+pkg debug/elf, const DT_MIPS_GP_VALUE DynTag
+pkg debug/elf, const DT_MIPS_HIDDEN_GOTIDX = 1879048231
+pkg debug/elf, const DT_MIPS_HIDDEN_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_HIPAGENO = 1879048212
+pkg debug/elf, const DT_MIPS_HIPAGENO DynTag
+pkg debug/elf, const DT_MIPS_ICHECKSUM = 1879048195
+pkg debug/elf, const DT_MIPS_ICHECKSUM DynTag
+pkg debug/elf, const DT_MIPS_INTERFACE = 1879048234
+pkg debug/elf, const DT_MIPS_INTERFACE DynTag
+pkg debug/elf, const DT_MIPS_INTERFACE_SIZE = 1879048236
+pkg debug/elf, const DT_MIPS_INTERFACE_SIZE DynTag
+pkg debug/elf, const DT_MIPS_IVERSION = 1879048196
+pkg debug/elf, const DT_MIPS_IVERSION DynTag
+pkg debug/elf, const DT_MIPS_LIBLIST = 1879048201
+pkg debug/elf, const DT_MIPS_LIBLIST DynTag
+pkg debug/elf, const DT_MIPS_LIBLISTNO = 1879048208
+pkg debug/elf, const DT_MIPS_LIBLISTNO DynTag
+pkg debug/elf, const DT_MIPS_LOCALPAGE_GOTIDX = 1879048229
+pkg debug/elf, const DT_MIPS_LOCALPAGE_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_LOCAL_GOTIDX = 1879048230
+pkg debug/elf, const DT_MIPS_LOCAL_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_LOCAL_GOTNO = 1879048202
+pkg debug/elf, const DT_MIPS_LOCAL_GOTNO DynTag
+pkg debug/elf, const DT_MIPS_MSYM = 1879048199
+pkg debug/elf, const DT_MIPS_MSYM DynTag
+pkg debug/elf, const DT_MIPS_OPTIONS = 1879048233
+pkg debug/elf, const DT_MIPS_OPTIONS DynTag
+pkg debug/elf, const DT_MIPS_PERF_SUFFIX = 1879048238
+pkg debug/elf, const DT_MIPS_PERF_SUFFIX DynTag
+pkg debug/elf, const DT_MIPS_PIXIE_INIT = 1879048227
+pkg debug/elf, const DT_MIPS_PIXIE_INIT DynTag
+pkg debug/elf, const DT_MIPS_PLTGOT = 1879048242
+pkg debug/elf, const DT_MIPS_PLTGOT DynTag
+pkg debug/elf, const DT_MIPS_PROTECTED_GOTIDX = 1879048232
+pkg debug/elf, const DT_MIPS_PROTECTED_GOTIDX DynTag
+pkg debug/elf, const DT_MIPS_RLD_MAP = 1879048214
+pkg debug/elf, const DT_MIPS_RLD_MAP DynTag
+pkg debug/elf, const DT_MIPS_RLD_MAP_REL = 1879048245
+pkg debug/elf, const DT_MIPS_RLD_MAP_REL DynTag
+pkg debug/elf, const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 1879048237
+pkg debug/elf, const DT_MIPS_RLD_TEXT_RESOLVE_ADDR DynTag
+pkg debug/elf, const DT_MIPS_RLD_VERSION = 1879048193
+pkg debug/elf, const DT_MIPS_RLD_VERSION DynTag
+pkg debug/elf, const DT_MIPS_RWPLT = 1879048244
+pkg debug/elf, const DT_MIPS_RWPLT DynTag
+pkg debug/elf, const DT_MIPS_SYMBOL_LIB = 1879048228
+pkg debug/elf, const DT_MIPS_SYMBOL_LIB DynTag
+pkg debug/elf, const DT_MIPS_SYMTABNO = 1879048209
+pkg debug/elf, const DT_MIPS_SYMTABNO DynTag
+pkg debug/elf, const DT_MIPS_TIME_STAMP = 1879048194
+pkg debug/elf, const DT_MIPS_TIME_STAMP DynTag
+pkg debug/elf, const DT_MIPS_UNREFEXTNO = 1879048210
+pkg debug/elf, const DT_MIPS_UNREFEXTNO DynTag
+pkg debug/elf, const DT_MOVEENT = 1879047674
+pkg debug/elf, const DT_MOVEENT DynTag
+pkg debug/elf, const DT_MOVESZ = 1879047675
+pkg debug/elf, const DT_MOVESZ DynTag
+pkg debug/elf, const DT_MOVETAB = 1879047934
+pkg debug/elf, const DT_MOVETAB DynTag
+pkg debug/elf, const DT_PLTPAD = 1879047933
+pkg debug/elf, const DT_PLTPAD DynTag
+pkg debug/elf, const DT_PLTPADSZ = 1879047673
+pkg debug/elf, const DT_PLTPADSZ DynTag
+pkg debug/elf, const DT_POSFLAG_1 = 1879047677
+pkg debug/elf, const DT_POSFLAG_1 DynTag
+pkg debug/elf, const DT_PPC64_GLINK = 1879048192
+pkg debug/elf, const DT_PPC64_GLINK DynTag
+pkg debug/elf, const DT_PPC64_OPD = 1879048193
+pkg debug/elf, const DT_PPC64_OPD DynTag
+pkg debug/elf, const DT_PPC64_OPDSZ = 1879048194
+pkg debug/elf, const DT_PPC64_OPDSZ DynTag
+pkg debug/elf, const DT_PPC64_OPT = 1879048195
+pkg debug/elf, const DT_PPC64_OPT DynTag
+pkg debug/elf, const DT_PPC_GOT = 1879048192
+pkg debug/elf, const DT_PPC_GOT DynTag
+pkg debug/elf, const DT_PPC_OPT = 1879048193
+pkg debug/elf, const DT_PPC_OPT DynTag
+pkg debug/elf, const DT_RELACOUNT = 1879048185
+pkg debug/elf, const DT_RELACOUNT DynTag
+pkg debug/elf, const DT_RELCOUNT = 1879048186
+pkg debug/elf, const DT_RELCOUNT DynTag
+pkg debug/elf, const DT_SPARC_REGISTER = 1879048193
+pkg debug/elf, const DT_SPARC_REGISTER DynTag
+pkg debug/elf, const DT_SYMINENT = 1879047679
+pkg debug/elf, const DT_SYMINENT DynTag
+pkg debug/elf, const DT_SYMINFO = 1879047935
+pkg debug/elf, const DT_SYMINFO DynTag
+pkg debug/elf, const DT_SYMINSZ = 1879047678
+pkg debug/elf, const DT_SYMINSZ DynTag
+pkg debug/elf, const DT_SYMTAB_SHNDX = 34
+pkg debug/elf, const DT_SYMTAB_SHNDX DynTag
+pkg debug/elf, const DT_TLSDESC_GOT = 1879047927
+pkg debug/elf, const DT_TLSDESC_GOT DynTag
+pkg debug/elf, const DT_TLSDESC_PLT = 1879047926
+pkg debug/elf, const DT_TLSDESC_PLT DynTag
+pkg debug/elf, const DT_USED = 2147483646
+pkg debug/elf, const DT_USED DynTag
+pkg debug/elf, const DT_VALRNGHI = 1879047679
+pkg debug/elf, const DT_VALRNGHI DynTag
+pkg debug/elf, const DT_VALRNGLO = 1879047424
+pkg debug/elf, const DT_VALRNGLO DynTag
+pkg debug/elf, const DT_VERDEF = 1879048188
+pkg debug/elf, const DT_VERDEF DynTag
+pkg debug/elf, const DT_VERDEFNUM = 1879048189
+pkg debug/elf, const DT_VERDEFNUM DynTag
+pkg debug/elf, const PT_AARCH64_ARCHEXT = 1879048192
+pkg debug/elf, const PT_AARCH64_ARCHEXT ProgType
+pkg debug/elf, const PT_AARCH64_UNWIND = 1879048193
+pkg debug/elf, const PT_AARCH64_UNWIND ProgType
+pkg debug/elf, const PT_ARM_ARCHEXT = 1879048192
+pkg debug/elf, const PT_ARM_ARCHEXT ProgType
+pkg debug/elf, const PT_ARM_EXIDX = 1879048193
+pkg debug/elf, const PT_ARM_EXIDX ProgType
+pkg debug/elf, const PT_GNU_EH_FRAME = 1685382480
+pkg debug/elf, const PT_GNU_EH_FRAME ProgType
+pkg debug/elf, const PT_GNU_MBIND_HI = 1685386580
+pkg debug/elf, const PT_GNU_MBIND_HI ProgType
+pkg debug/elf, const PT_GNU_MBIND_LO = 1685382485
+pkg debug/elf, const PT_GNU_MBIND_LO ProgType
+pkg debug/elf, const PT_GNU_PROPERTY = 1685382483
+pkg debug/elf, const PT_GNU_PROPERTY ProgType
+pkg debug/elf, const PT_GNU_RELRO = 1685382482
+pkg debug/elf, const PT_GNU_RELRO ProgType
+pkg debug/elf, const PT_GNU_STACK = 1685382481
+pkg debug/elf, const PT_GNU_STACK ProgType
+pkg debug/elf, const PT_MIPS_ABIFLAGS = 1879048195
+pkg debug/elf, const PT_MIPS_ABIFLAGS ProgType
+pkg debug/elf, const PT_MIPS_OPTIONS = 1879048194
+pkg debug/elf, const PT_MIPS_OPTIONS ProgType
+pkg debug/elf, const PT_MIPS_REGINFO = 1879048192
+pkg debug/elf, const PT_MIPS_REGINFO ProgType
+pkg debug/elf, const PT_MIPS_RTPROC = 1879048193
+pkg debug/elf, const PT_MIPS_RTPROC ProgType
+pkg debug/elf, const PT_OPENBSD_BOOTDATA = 1705253862
+pkg debug/elf, const PT_OPENBSD_BOOTDATA ProgType
+pkg debug/elf, const PT_OPENBSD_RANDOMIZE = 1705237478
+pkg debug/elf, const PT_OPENBSD_RANDOMIZE ProgType
+pkg debug/elf, const PT_OPENBSD_WXNEEDED = 1705237479
+pkg debug/elf, const PT_OPENBSD_WXNEEDED ProgType
+pkg debug/elf, const PT_PAX_FLAGS = 1694766464
+pkg debug/elf, const PT_PAX_FLAGS ProgType
+pkg debug/elf, const PT_S390_PGSTE = 1879048192
+pkg debug/elf, const PT_S390_PGSTE ProgType
+pkg debug/elf, const PT_SUNWSTACK = 1879048187
+pkg debug/elf, const PT_SUNWSTACK ProgType
+pkg debug/elf, const PT_SUNW_EH_FRAME = 1685382480
+pkg debug/elf, const PT_SUNW_EH_FRAME ProgType
+pkg embed, method (FS) Open(string) (fs.File, error)
+pkg embed, method (FS) ReadDir(string) ([]fs.DirEntry, error)
+pkg embed, method (FS) ReadFile(string) ([]uint8, error)
+pkg embed, type FS struct
+pkg flag, func Func(string, string, func(string) error)
+pkg flag, method (*FlagSet) Func(string, string, func(string) error)
+pkg go/build, type Package struct, EmbedPatterns []string
+pkg go/build, type Package struct, EmbedPatternPos map[string][]token.Position
+pkg go/build, type Package struct, IgnoredOtherFiles []string
+pkg go/build, type Package struct, TestEmbedPatterns []string
+pkg go/build, type Package struct, TestEmbedPatternPos map[string][]token.Position
+pkg go/build, type Package struct, XTestEmbedPatterns []string
+pkg go/build, type Package struct, XTestEmbedPatternPos map[string][]token.Position
+pkg go/build/constraint, func IsGoBuild(string) bool
+pkg go/build/constraint, func IsPlusBuild(string) bool
+pkg go/build/constraint, func Parse(string) (Expr, error)
+pkg go/build/constraint, func PlusBuildLines(Expr) ([]string, error)
+pkg go/build/constraint, method (*AndExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*AndExpr) String() string
+pkg go/build/constraint, method (*NotExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*NotExpr) String() string
+pkg go/build/constraint, method (*OrExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*OrExpr) String() string
+pkg go/build/constraint, method (*SyntaxError) Error() string
+pkg go/build/constraint, method (*TagExpr) Eval(func(string) bool) bool
+pkg go/build/constraint, method (*TagExpr) String() string
+pkg go/build/constraint, type AndExpr struct
+pkg go/build/constraint, type AndExpr struct, X Expr
+pkg go/build/constraint, type AndExpr struct, Y Expr
+pkg go/build/constraint, type Expr interface, Eval(func(string) bool) bool
+pkg go/build/constraint, type Expr interface, String() string
+pkg go/build/constraint, type Expr interface, unexported methods
+pkg go/build/constraint, type NotExpr struct
+pkg go/build/constraint, type NotExpr struct, X Expr
+pkg go/build/constraint, type OrExpr struct
+pkg go/build/constraint, type OrExpr struct, X Expr
+pkg go/build/constraint, type OrExpr struct, Y Expr
+pkg go/build/constraint, type SyntaxError struct
+pkg go/build/constraint, type SyntaxError struct, Err string
+pkg go/build/constraint, type SyntaxError struct, Offset int
+pkg go/build/constraint, type TagExpr struct
+pkg go/build/constraint, type TagExpr struct, Tag string
+pkg html/template, func ParseFS(fs.FS, ...string) (*Template, error)
+pkg html/template, method (*Template) ParseFS(fs.FS, ...string) (*Template, error)
+pkg io, func NopCloser(Reader) ReadCloser
+pkg io, func ReadAll(Reader) ([]uint8, error)
+pkg io, type ReadSeekCloser interface { Close, Read, Seek }
+pkg io, type ReadSeekCloser interface, Close() error
+pkg io, type ReadSeekCloser interface, Read([]uint8) (int, error)
+pkg io, type ReadSeekCloser interface, Seek(int64, int) (int64, error)
+pkg io, var Discard Writer
+pkg io/fs, const ModeAppend = 1073741824
+pkg io/fs, const ModeAppend FileMode
+pkg io/fs, const ModeCharDevice = 2097152
+pkg io/fs, const ModeCharDevice FileMode
+pkg io/fs, const ModeDevice = 67108864
+pkg io/fs, const ModeDevice FileMode
+pkg io/fs, const ModeDir = 2147483648
+pkg io/fs, const ModeDir FileMode
+pkg io/fs, const ModeExclusive = 536870912
+pkg io/fs, const ModeExclusive FileMode
+pkg io/fs, const ModeIrregular = 524288
+pkg io/fs, const ModeIrregular FileMode
+pkg io/fs, const ModeNamedPipe = 33554432
+pkg io/fs, const ModeNamedPipe FileMode
+pkg io/fs, const ModePerm = 511
+pkg io/fs, const ModePerm FileMode
+pkg io/fs, const ModeSetgid = 4194304
+pkg io/fs, const ModeSetgid FileMode
+pkg io/fs, const ModeSetuid = 8388608
+pkg io/fs, const ModeSetuid FileMode
+pkg io/fs, const ModeSocket = 16777216
+pkg io/fs, const ModeSocket FileMode
+pkg io/fs, const ModeSticky = 1048576
+pkg io/fs, const ModeSticky FileMode
+pkg io/fs, const ModeSymlink = 134217728
+pkg io/fs, const ModeSymlink FileMode
+pkg io/fs, const ModeTemporary = 268435456
+pkg io/fs, const ModeTemporary FileMode
+pkg io/fs, const ModeType = 2401763328
+pkg io/fs, const ModeType FileMode
+pkg io/fs, func Glob(FS, string) ([]string, error)
+pkg io/fs, func ReadDir(FS, string) ([]DirEntry, error)
+pkg io/fs, func ReadFile(FS, string) ([]uint8, error)
+pkg io/fs, func Stat(FS, string) (FileInfo, error)
+pkg io/fs, func Sub(FS, string) (FS, error)
+pkg io/fs, func ValidPath(string) bool
+pkg io/fs, func WalkDir(FS, string, WalkDirFunc) error
+pkg io/fs, method (*PathError) Error() string
+pkg io/fs, method (*PathError) Timeout() bool
+pkg io/fs, method (*PathError) Unwrap() error
+pkg io/fs, method (FileMode) IsDir() bool
+pkg io/fs, method (FileMode) IsRegular() bool
+pkg io/fs, method (FileMode) Perm() FileMode
+pkg io/fs, method (FileMode) String() string
+pkg io/fs, method (FileMode) Type() FileMode
+pkg io/fs, type DirEntry interface { Info, IsDir, Name, Type }
+pkg io/fs, type DirEntry interface, Info() (FileInfo, error)
+pkg io/fs, type DirEntry interface, IsDir() bool
+pkg io/fs, type DirEntry interface, Name() string
+pkg io/fs, type DirEntry interface, Type() FileMode
+pkg io/fs, type FS interface { Open }
+pkg io/fs, type FS interface, Open(string) (File, error)
+pkg io/fs, type File interface { Close, Read, Stat }
+pkg io/fs, type File interface, Close() error
+pkg io/fs, type File interface, Read([]uint8) (int, error)
+pkg io/fs, type File interface, Stat() (FileInfo, error)
+pkg io/fs, type FileInfo interface { IsDir, ModTime, Mode, Name, Size, Sys }
+pkg io/fs, type FileInfo interface, IsDir() bool
+pkg io/fs, type FileInfo interface, ModTime() time.Time
+pkg io/fs, type FileInfo interface, Mode() FileMode
+pkg io/fs, type FileInfo interface, Name() string
+pkg io/fs, type FileInfo interface, Size() int64
+pkg io/fs, type FileInfo interface, Sys() interface{}
+pkg io/fs, type FileMode uint32
+pkg io/fs, type GlobFS interface { Glob, Open }
+pkg io/fs, type GlobFS interface, Glob(string) ([]string, error)
+pkg io/fs, type GlobFS interface, Open(string) (File, error)
+pkg io/fs, type PathError struct
+pkg io/fs, type PathError struct, Err error
+pkg io/fs, type PathError struct, Op string
+pkg io/fs, type PathError struct, Path string
+pkg io/fs, type ReadDirFS interface { Open, ReadDir }
+pkg io/fs, type ReadDirFS interface, Open(string) (File, error)
+pkg io/fs, type ReadDirFS interface, ReadDir(string) ([]DirEntry, error)
+pkg io/fs, type ReadDirFile interface { Close, Read, ReadDir, Stat }
+pkg io/fs, type ReadDirFile interface, Close() error
+pkg io/fs, type ReadDirFile interface, Read([]uint8) (int, error)
+pkg io/fs, type ReadDirFile interface, ReadDir(int) ([]DirEntry, error)
+pkg io/fs, type ReadDirFile interface, Stat() (FileInfo, error)
+pkg io/fs, type ReadFileFS interface { Open, ReadFile }
+pkg io/fs, type ReadFileFS interface, Open(string) (File, error)
+pkg io/fs, type ReadFileFS interface, ReadFile(string) ([]uint8, error)
+pkg io/fs, type StatFS interface { Open, Stat }
+pkg io/fs, type StatFS interface, Open(string) (File, error)
+pkg io/fs, type StatFS interface, Stat(string) (FileInfo, error)
+pkg io/fs, type SubFS interface { Open, Sub }
+pkg io/fs, type SubFS interface, Open(string) (File, error)
+pkg io/fs, type SubFS interface, Sub(string) (FS, error)
+pkg io/fs, type WalkDirFunc func(string, DirEntry, error) error
+pkg io/fs, var ErrClosed error
+pkg io/fs, var ErrExist error
+pkg io/fs, var ErrInvalid error
+pkg io/fs, var ErrNotExist error
+pkg io/fs, var ErrPermission error
+pkg io/fs, var SkipDir error
+pkg log, func Default() *Logger
+pkg net, var ErrClosed error
+pkg net/http, func FS(fs.FS) FileSystem
+pkg net/http, type Transport struct, GetProxyConnectHeader func(context.Context, *url.URL, string) (Header, error)
+pkg os, const ModeAppend fs.FileMode
+pkg os, const ModeCharDevice fs.FileMode
+pkg os, const ModeDevice fs.FileMode
+pkg os, const ModeDir fs.FileMode
+pkg os, const ModeExclusive fs.FileMode
+pkg os, const ModeIrregular fs.FileMode
+pkg os, const ModeNamedPipe fs.FileMode
+pkg os, const ModePerm fs.FileMode
+pkg os, const ModeSetgid fs.FileMode
+pkg os, const ModeSetuid fs.FileMode
+pkg os, const ModeSocket fs.FileMode
+pkg os, const ModeSticky fs.FileMode
+pkg os, const ModeSymlink fs.FileMode
+pkg os, const ModeTemporary fs.FileMode
+pkg os, const ModeType fs.FileMode
+pkg os, func Chmod(string, fs.FileMode) error
+pkg os, func CreateTemp(string, string) (*File, error)
+pkg os, func DirFS(string) fs.FS
+pkg os, func Lstat(string) (fs.FileInfo, error)
+pkg os, func Mkdir(string, fs.FileMode) error
+pkg os, func MkdirAll(string, fs.FileMode) error
+pkg os, func MkdirTemp(string, string) (string, error)
+pkg os, func OpenFile(string, int, fs.FileMode) (*File, error)
+pkg os, func ReadDir(string) ([]fs.DirEntry, error)
+pkg os, func ReadFile(string) ([]uint8, error)
+pkg os, func SameFile(fs.FileInfo, fs.FileInfo) bool
+pkg os, func Stat(string) (fs.FileInfo, error)
+pkg os, func WriteFile(string, []uint8, fs.FileMode) error
+pkg os, method (*File) Chmod(fs.FileMode) error
+pkg os, method (*File) ReadDir(int) ([]fs.DirEntry, error)
+pkg os, method (*File) Readdir(int) ([]fs.FileInfo, error)
+pkg os, method (*File) Stat() (fs.FileInfo, error)
+pkg os, type DirEntry = fs.DirEntry
+pkg os, type FileInfo = fs.FileInfo
+pkg os, type FileMode = fs.FileMode
+pkg os, type PathError = fs.PathError
+pkg os, var ErrProcessDone error
+pkg os/signal, func NotifyContext(context.Context, ...os.Signal) (context.Context, context.CancelFunc)
+pkg path/filepath, func WalkDir(string, fs.WalkDirFunc) error
+pkg runtime/metrics, const KindBad = 0
+pkg runtime/metrics, const KindBad ValueKind
+pkg runtime/metrics, const KindFloat64 = 2
+pkg runtime/metrics, const KindFloat64 ValueKind
+pkg runtime/metrics, const KindFloat64Histogram = 3
+pkg runtime/metrics, const KindFloat64Histogram ValueKind
+pkg runtime/metrics, const KindUint64 = 1
+pkg runtime/metrics, const KindUint64 ValueKind
+pkg runtime/metrics, func All() []Description
+pkg runtime/metrics, func Read([]Sample)
+pkg runtime/metrics, method (Value) Float64() float64
+pkg runtime/metrics, method (Value) Float64Histogram() *Float64Histogram
+pkg runtime/metrics, method (Value) Kind() ValueKind
+pkg runtime/metrics, method (Value) Uint64() uint64
+pkg runtime/metrics, type Description struct
+pkg runtime/metrics, type Description struct, Cumulative bool
+pkg runtime/metrics, type Description struct, Description string
+pkg runtime/metrics, type Description struct, Kind ValueKind
+pkg runtime/metrics, type Description struct, Name string
+pkg runtime/metrics, type Float64Histogram struct
+pkg runtime/metrics, type Float64Histogram struct, Buckets []float64
+pkg runtime/metrics, type Float64Histogram struct, Counts []uint64
+pkg runtime/metrics, type Sample struct
+pkg runtime/metrics, type Sample struct, Name string
+pkg runtime/metrics, type Sample struct, Value Value
+pkg runtime/metrics, type Value struct
+pkg runtime/metrics, type ValueKind int
+pkg syscall (linux-386), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386), func Setegid(int) error
+pkg syscall (linux-386), func Seteuid(int) error
+pkg syscall (linux-386-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-386-cgo), func Setegid(int) error
+pkg syscall (linux-386-cgo), func Seteuid(int) error
+pkg syscall (linux-amd64), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64), func Setegid(int) error
+pkg syscall (linux-amd64), func Seteuid(int) error
+pkg syscall (linux-amd64-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-amd64-cgo), func Setegid(int) error
+pkg syscall (linux-amd64-cgo), func Seteuid(int) error
+pkg syscall (linux-arm), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm), func Setegid(int) error
+pkg syscall (linux-arm), func Seteuid(int) error
+pkg syscall (linux-arm-cgo), func AllThreadsSyscall(uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm-cgo), func AllThreadsSyscall6(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) (uintptr, uintptr, Errno)
+pkg syscall (linux-arm-cgo), func Setegid(int) error
+pkg syscall (linux-arm-cgo), func Seteuid(int) error
+pkg syscall (windows-386), method (*DLLError) Unwrap() error
+pkg syscall (windows-386), type SysProcAttr struct, NoInheritHandles bool
+pkg syscall (windows-amd64), method (*DLLError) Unwrap() error
+pkg syscall (windows-amd64), type SysProcAttr struct, NoInheritHandles bool
+pkg testing/fstest, func TestFS(fs.FS, ...string) error
+pkg testing/fstest, method (MapFS) Glob(string) ([]string, error)
+pkg testing/fstest, method (MapFS) Open(string) (fs.File, error)
+pkg testing/fstest, method (MapFS) ReadDir(string) ([]fs.DirEntry, error)
+pkg testing/fstest, method (MapFS) ReadFile(string) ([]uint8, error)
+pkg testing/fstest, method (MapFS) Stat(string) (fs.FileInfo, error)
+pkg testing/fstest, method (MapFS) Sub(string) (fs.FS, error)
+pkg testing/fstest, type MapFS map[string]*MapFile
+pkg testing/fstest, type MapFile struct
+pkg testing/fstest, type MapFile struct, Data []uint8
+pkg testing/fstest, type MapFile struct, ModTime time.Time
+pkg testing/fstest, type MapFile struct, Mode fs.FileMode
+pkg testing/fstest, type MapFile struct, Sys interface{}
+pkg testing/iotest, func ErrReader(error) io.Reader
+pkg testing/iotest, func TestReader(io.Reader, []uint8) error
+pkg text/template, func ParseFS(fs.FS, ...string) (*Template, error)
+pkg text/template, method (*Template) ParseFS(fs.FS, ...string) (*Template, error)
+pkg text/template/parse, const NodeComment = 20
+pkg text/template/parse, const NodeComment NodeType
+pkg text/template/parse, const ParseComments = 1
+pkg text/template/parse, const ParseComments Mode
+pkg text/template/parse, method (*CommentNode) Copy() Node
+pkg text/template/parse, method (*CommentNode) String() string
+pkg text/template/parse, method (CommentNode) Position() Pos
+pkg text/template/parse, method (CommentNode) Type() NodeType
+pkg text/template/parse, type CommentNode struct
+pkg text/template/parse, type CommentNode struct, Text string
+pkg text/template/parse, type CommentNode struct, embedded NodeType
+pkg text/template/parse, type CommentNode struct, embedded Pos
+pkg text/template/parse, type Mode uint
+pkg text/template/parse, type Tree struct, Mode Mode
+pkg unicode, const Version = "13.0.0"
+pkg unicode, var Chorasmian *RangeTable
+pkg unicode, var Dives_Akuru *RangeTable
+pkg unicode, var Khitan_Small_Script *RangeTable
+pkg unicode, var Yezidi *RangeTable

api/next.txt

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

doc/articles/go_command.html

@@ -1,254 +0,0 @@
-<!--{
-	"title": "About the go command"
-}-->
-
-<p>The Go distribution includes a command, named
-"<code><a href="/cmd/go/">go</a></code>", that
-automates the downloading, building, installation, and testing of Go packages
-and commands.  This document talks about why we wrote a new command, what it
-is, what it's not, and how to use it.</p>
-
-<h2>Motivation</h2>
-
-<p>You might have seen early Go talks in which Rob Pike jokes that the idea
-for Go arose while waiting for a large Google server to compile.  That
-really was the motivation for Go: to build a language that worked well
-for building the large software that Google writes and runs. It was
-clear from the start that such a language must provide a way to
-express dependencies between code libraries clearly, hence the package
-grouping and the explicit import blocks.  It was also clear from the
-start that you might want arbitrary syntax for describing the code
-being imported; this is why import paths are string literals.</p>
-
-<p>An explicit goal for Go from the beginning was to be able to build Go
-code using only the information found in the source itself, not
-needing to write a makefile or one of the many modern replacements for
-makefiles.  If Go needed a configuration file to explain how to build
-your program, then Go would have failed.</p>
-
-<p>At first, there was no Go compiler, and the initial development
-focused on building one and then building libraries for it. For
-expedience, we postponed the automation of building Go code by using
-make and writing makefiles.  When compiling a single package involved
-multiple invocations of the Go compiler, we even used a program to
-write the makefiles for us.  You can find it if you dig through the
-repository history.</p>
-
-<p>The purpose of the new go command is our return to this ideal, that Go
-programs should compile without configuration or additional effort on
-the part of the developer beyond writing the necessary import
-statements.</p>
-
-<h2>Configuration versus convention</h2>
-
-<p>The way to achieve the simplicity of a configuration-free system is to
-establish conventions. The system works only to the extent that those conventions
-are followed. When we first launched Go, many people published packages that
-had to be installed in certain places, under certain names, using certain build
-tools, in order to be used. That's understandable: that's the way it works in
-most other languages. Over the last few years we consistently reminded people
-about the <code>goinstall</code> command
-(now replaced by <a href="/cmd/go/#hdr-Download_and_install_packages_and_dependencies"><code>go get</code></a>)
-and its conventions: first, that the import path is derived in a known way from
-the URL of the source code; second, that the place to store the sources in
-the local file system is derived in a known way from the import path; third,
-that each directory in a source tree corresponds to a single package; and
-fourth, that the package is built using only information in the source code.
-Today, the vast majority of packages follow these conventions.
-The Go ecosystem is simpler and more powerful as a result.</p>
-
-<p>We received many requests to allow a makefile in a package directory to
-provide just a little extra configuration beyond what's in the source code.
-But that would have introduced new rules. Because we did not accede to such
-requests, we were able to write the go command and eliminate our use of make
-or any other build system.</p>
-
-<p>It is important to understand that the go command is not a general
-build tool. It cannot be configured and it does not attempt to build
-anything but Go packages.  These are important simplifying
-assumptions: they simplify not only the implementation but also, more
-important, the use of the tool itself.</p>
-
-<h2>Go's conventions</h2>
-
-<p>The <code>go</code> command requires that code adheres to a few key,
-well-established conventions.</p>
-
-<p>First, the import path is derived in a known way from the URL of the
-source code.  For Bitbucket, GitHub, Google Code, and Launchpad, the
-root directory of the repository is identified by the repository's
-main URL, without the <code>http://</code> prefix.  Subdirectories are named by
-adding to that path.
-For example, the Go example programs are obtained by running</p>
-
-<pre>
-git clone https://github.com/golang/example
-</pre>
-
-<p>and thus the import path for the root directory of that repository is
-"<code>github.com/golang/example</code>".
-The <a href="https://godoc.org/github.com/golang/example/stringutil">stringutil</a>
-package is stored in a subdirectory, so its import path is
-"<code>github.com/golang/example/stringutil</code>".</p>
-
-<p>These paths are on the long side, but in exchange we get an
-automatically managed name space for import paths and the ability for
-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.
-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>
-
-<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
-named "<code>pkg</code>", for holding compiled packages that can be imported,
-and the "<code>src</code>" directory, for holding package source files.
-Imposing this structure lets us keep each of these directory trees
-self-contained: the compiled form and the sources are always near each
-other.</p>
-
-<p>These naming conventions also let us work in the reverse direction,
-from a directory name to its import path. This mapping is important
-for many of the go command's subcommands, as we'll see below.</p>
-
-<p>Third, each directory in a source tree corresponds to a single
-package. By restricting a directory to a single package, we don't have
-to create hybrid import paths that specify first the directory and
-then the package within that directory.  Also, most file management
-tools and UIs work on  directories as fundamental units.  Tying the
-fundamental Go unit&mdash;the package&mdash;to file system structure means
-that file system tools become Go package tools.  Copying, moving, or
-deleting a package corresponds to copying, moving, or deleting a
-directory.</p>
-
-<p>Fourth, each package is built using only the information present in
-the source files.  This makes it much more likely that the tool will
-be able to adapt to changing build environments and conditions. For
-example, if we allowed extra configuration such as compiler flags or
-command line recipes, then that configuration would need to be updated
-each time the build tools changed; it would also be inherently tied
-to the use of a specific toolchain.</p>
-
-<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>We first add some source code.  Suppose we want to use
-the indexing library from the codesearch project along with a left-leaning
-red-black tree.  We can install both with the "<code>go get</code>"
-subcommand:</p>
-
-<pre>
-$ go get github.com/google/codesearch/index
-$ go get github.com/petar/GoLLRB/llrb
-$
-</pre>
-
-<p>Both of these projects are now downloaded and installed into <code>$HOME/go</code>,
-which contains the two directories
-<code>src/github.com/google/codesearch/index/</code> and
-<code>src/github.com/petar/GoLLRB/llrb/</code>, along with the compiled
-packages (in <code>pkg/</code>) for those libraries and their dependencies.</p>
-
-<p>Because we used version control systems (Mercurial and Git) to check
-out the sources, the source tree also contains the other files in the
-corresponding repositories, such as related packages. The "<code>go list</code>"
-subcommand lists the import paths corresponding to its arguments, and
-the pattern "<code>./...</code>" means start in the current directory
-("<code>./</code>") and find all packages below that directory
-("<code>...</code>"):</p>
-
-<pre>
-$ cd $HOME/go/src
-$ go list ./...
-github.com/google/codesearch/cmd/cgrep
-github.com/google/codesearch/cmd/cindex
-github.com/google/codesearch/cmd/csearch
-github.com/google/codesearch/index
-github.com/google/codesearch/regexp
-github.com/google/codesearch/sparse
-github.com/petar/GoLLRB/example
-github.com/petar/GoLLRB/llrb
-$
-</pre>
-
-<p>We can also test those packages:</p>
-
-<pre>
-$ go test ./...
-?   	github.com/google/codesearch/cmd/cgrep	[no test files]
-?   	github.com/google/codesearch/cmd/cindex	[no test files]
-?   	github.com/google/codesearch/cmd/csearch	[no test files]
-ok  	github.com/google/codesearch/index	0.203s
-ok  	github.com/google/codesearch/regexp	0.017s
-?   	github.com/google/codesearch/sparse	[no test files]
-?       github.com/petar/GoLLRB/example          [no test files]
-ok      github.com/petar/GoLLRB/llrb             0.231s
-$
-</pre>
-
-<p>If a go subcommand is invoked with no paths listed, it operates on the
-current directory:</p>
-
-<pre>
-$ cd github.com/google/codesearch/regexp
-$ go list
-github.com/google/codesearch/regexp
-$ go test -v
-=== RUN   TestNstateEnc
---- PASS: TestNstateEnc (0.00s)
-=== RUN   TestMatch
---- PASS: TestMatch (0.00s)
-=== RUN   TestGrep
---- PASS: TestGrep (0.00s)
-PASS
-ok  	github.com/google/codesearch/regexp	0.018s
-$ go install
-$
-</pre>
-
-<p>That "<code>go install</code>" subcommand installs the latest copy of the
-package into the pkg directory. Because the go command can analyze the
-dependency graph, "<code>go install</code>" also installs any packages that
-this package imports but that are out of date, recursively.</p>
-
-<p>Notice that "<code>go install</code>" was able to determine the name of the
-import path for the package in the current directory, because of the convention
-for directory naming.  It would be a little more convenient if we could pick
-the name of the directory where we kept source code, and we probably wouldn't
-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>
-
-<h2>Limitations</h2>
-
-<p>As mentioned above, the go command is not a general-purpose build
-tool.
-In particular, it does not have any facility for generating Go
-source files <em>during</em> a build, although it does provide
-<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
-<code>generate</code></a>,
-which can automate the creation of Go files <em>before</em> the build.
-For more advanced build setups, you may need to write a
-makefile (or a configuration file for the build tool of your choice)
-to run whatever tool creates the Go files and then check those generated source files
-into your repository. This is more work for you, the package author,
-but it is significantly less work for your users, who can use
-"<code>go get</code>" without needing to obtain and build
-any additional tools.</p>
-
-<h2>More information</h2>
-
-<p>For more information, read <a href="/doc/code.html">How to Write Go Code</a>
-and see the <a href="/cmd/go/">go command documentation</a>.</p>

doc/articles/index.html

@@ -1,8 +0,0 @@
-<!--{
-	"Title": "/doc/articles/"
-}-->
-
-<p>
-See the <a href="/doc/#articles">Documents page</a> and the
-<a href="/blog/index">Blog index</a> for a complete list of Go articles.
-</p>

doc/articles/race_detector.html

@@ -1,440 +0,0 @@
-<!--{
-	"Title": "Data Race Detector",
-	"Template": true
-}-->
-
-<h2 id="Introduction">Introduction</h2>
-
-<p>
-Data races are among the most common and hardest to debug types of bugs in concurrent systems.
-A data race occurs when two goroutines access the same variable concurrently and at least one of the accesses is a write.
-See the <a href="/ref/mem/">The Go Memory Model</a> for details.
-</p>
-
-<p>
-Here is an example of a data race that can lead to crashes and memory corruption:
-</p>
-
-<pre>
-func main() {
-	c := make(chan bool)
-	m := make(map[string]string)
-	go func() {
-		m["1"] = "a" // First conflicting access.
-		c &lt;- true
-	}()
-	m["2"] = "b" // Second conflicting access.
-	&lt;-c
-	for k, v := range m {
-		fmt.Println(k, v)
-	}
-}
-</pre>
-
-<h2 id="Usage">Usage</h2>
-
-<p>
-To help diagnose such bugs, Go includes a built-in data race detector.
-To use it, add the <code>-race</code> flag to the go command:
-</p>
-
-<pre>
-$ go test -race mypkg    // to test the package
-$ go run -race mysrc.go  // to run the source file
-$ go build -race mycmd   // to build the command
-$ go install -race mypkg // to install the package
-</pre>
-
-<h2 id="Report_Format">Report Format</h2>
-
-<p>
-When the race detector finds a data race in the program, it prints a report.
-The report contains stack traces for conflicting accesses, as well as stacks where the involved goroutines were created.
-Here is an example:
-</p>
-
-<pre>
-WARNING: DATA RACE
-Read by goroutine 185:
-  net.(*pollServer).AddFD()
-      src/net/fd_unix.go:89 +0x398
-  net.(*pollServer).WaitWrite()
-      src/net/fd_unix.go:247 +0x45
-  net.(*netFD).Write()
-      src/net/fd_unix.go:540 +0x4d4
-  net.(*conn).Write()
-      src/net/net.go:129 +0x101
-  net.func·060()
-      src/net/timeout_test.go:603 +0xaf
-
-Previous write by goroutine 184:
-  net.setWriteDeadline()
-      src/net/sockopt_posix.go:135 +0xdf
-  net.setDeadline()
-      src/net/sockopt_posix.go:144 +0x9c
-  net.(*conn).SetDeadline()
-      src/net/net.go:161 +0xe3
-  net.func·061()
-      src/net/timeout_test.go:616 +0x3ed
-
-Goroutine 185 (running) created at:
-  net.func·061()
-      src/net/timeout_test.go:609 +0x288
-
-Goroutine 184 (running) created at:
-  net.TestProlongTimeout()
-      src/net/timeout_test.go:618 +0x298
-  testing.tRunner()
-      src/testing/testing.go:301 +0xe8
-</pre>
-
-<h2 id="Options">Options</h2>
-
-<p>
-The <code>GORACE</code> environment variable sets race detector options.
-The format is:
-</p>
-
-<pre>
-GORACE="option1=val1 option2=val2"
-</pre>
-
-<p>
-The options are:
-</p>
-
-<ul>
-<li>
-<code>log_path</code> (default <code>stderr</code>): The race detector writes
-its report to a file named <code>log_path.<em>pid</em></code>.
-The special names <code>stdout</code>
-and <code>stderr</code> cause reports to be written to standard output and
-standard error, respectively.
-</li>
-
-<li>
-<code>exitcode</code> (default <code>66</code>): The exit status to use when
-exiting after a detected race.
-</li>
-
-<li>
-<code>strip_path_prefix</code> (default <code>""</code>): Strip this prefix
-from all reported file paths, to make reports more concise.
-</li>
-
-<li>
-<code>history_size</code> (default <code>1</code>): The per-goroutine memory
-access history is <code>32K * 2**history_size elements</code>.
-Increasing this value can avoid a "failed to restore the stack" error in reports, at the
-cost of increased memory usage.
-</li>
-
-<li>
-<code>halt_on_error</code> (default <code>0</code>): Controls whether the program
-exits after reporting first data race.
-</li>
-
-<li>
-<code>atexit_sleep_ms</code> (default <code>1000</code>): Amount of milliseconds
-to sleep in the main goroutine before exiting.
-</li>
-</ul>
-
-<p>
-Example:
-</p>
-
-<pre>
-$ GORACE="log_path=/tmp/race/report strip_path_prefix=/my/go/sources/" go test -race
-</pre>
-
-<h2 id="Excluding_Tests">Excluding Tests</h2>
-
-<p>
-When you build with <code>-race</code> flag, the <code>go</code> command defines additional
-<a href="/pkg/go/build/#hdr-Build_Constraints">build tag</a> <code>race</code>.
-You can use the tag to exclude some code and tests when running the race detector.
-Some examples:
-</p>
-
-<pre>
-// +build !race
-
-package foo
-
-// The test contains a data race. See issue 123.
-func TestFoo(t *testing.T) {
-	// ...
-}
-
-// The test fails under the race detector due to timeouts.
-func TestBar(t *testing.T) {
-	// ...
-}
-
-// The test takes too long under the race detector.
-func TestBaz(t *testing.T) {
-	// ...
-}
-</pre>
-
-<h2 id="How_To_Use">How To Use</h2>
-
-<p>
-To start, run your tests using the race detector (<code>go test -race</code>).
-The race detector only finds races that happen at runtime, so it can't find
-races in code paths that are not executed.
-If your tests have incomplete coverage,
-you may find more races by running a binary built with <code>-race</code> under a realistic
-workload.
-</p>
-
-<h2 id="Typical_Data_Races">Typical Data Races</h2>
-
-<p>
-Here are some typical data races.  All of them can be detected with the race detector.
-</p>
-
-<h3 id="Race_on_loop_counter">Race on loop counter</h3>
-
-<pre>
-func main() {
-	var wg sync.WaitGroup
-	wg.Add(5)
-	for i := 0; i < 5; i++ {
-		go func() {
-			fmt.Println(i) // Not the 'i' you are looking for.
-			wg.Done()
-		}()
-	}
-	wg.Wait()
-}
-</pre>
-
-<p>
-The variable <code>i</code> in the function literal is the same variable used by the loop, so
-the read in the goroutine races with the loop increment.
-(This program typically prints 55555, not 01234.)
-The program can be fixed by making a copy of the variable:
-</p>
-
-<pre>
-func main() {
-	var wg sync.WaitGroup
-	wg.Add(5)
-	for i := 0; i < 5; i++ {
-		go func(j int) {
-			fmt.Println(j) // Good. Read local copy of the loop counter.
-			wg.Done()
-		}(i)
-	}
-	wg.Wait()
-}
-</pre>
-
-<h3 id="Accidentally_shared_variable">Accidentally shared variable</h3>
-
-<pre>
-// ParallelWrite writes data to file1 and file2, returns the errors.
-func ParallelWrite(data []byte) chan error {
-	res := make(chan error, 2)
-	f1, err := os.Create("file1")
-	if err != nil {
-		res &lt;- err
-	} else {
-		go func() {
-			// This err is shared with the main goroutine,
-			// so the write races with the write below.
-			_, err = f1.Write(data)
-			res &lt;- err
-			f1.Close()
-		}()
-	}
-	f2, err := os.Create("file2") // The second conflicting write to err.
-	if err != nil {
-		res &lt;- err
-	} else {
-		go func() {
-			_, err = f2.Write(data)
-			res &lt;- err
-			f2.Close()
-		}()
-	}
-	return res
-}
-</pre>
-
-<p>
-The fix is to introduce new variables in the goroutines (note the use of <code>:=</code>):
-</p>
-
-<pre>
-			...
-			_, err := f1.Write(data)
-			...
-			_, err := f2.Write(data)
-			...
-</pre>
-
-<h3 id="Unprotected_global_variable">Unprotected global variable</h3>
-
-<p>
-If the following code is called from several goroutines, it leads to races on the <code>service</code> map.
-Concurrent reads and writes of the same map are not safe:
-</p>
-
-<pre>
-var service map[string]net.Addr
-
-func RegisterService(name string, addr net.Addr) {
-	service[name] = addr
-}
-
-func LookupService(name string) net.Addr {
-	return service[name]
-}
-</pre>
-
-<p>
-To make the code safe, protect the accesses with a mutex:
-</p>
-
-<pre>
-var (
-	service   map[string]net.Addr
-	serviceMu sync.Mutex
-)
-
-func RegisterService(name string, addr net.Addr) {
-	serviceMu.Lock()
-	defer serviceMu.Unlock()
-	service[name] = addr
-}
-
-func LookupService(name string) net.Addr {
-	serviceMu.Lock()
-	defer serviceMu.Unlock()
-	return service[name]
-}
-</pre>
-
-<h3 id="Primitive_unprotected_variable">Primitive unprotected variable</h3>
-
-<p>
-Data races can happen on variables of primitive types as well (<code>bool</code>, <code>int</code>, <code>int64</code>, etc.),
-as in this example:
-</p>
-
-<pre>
-type Watchdog struct{ last int64 }
-
-func (w *Watchdog) KeepAlive() {
-	w.last = time.Now().UnixNano() // First conflicting access.
-}
-
-func (w *Watchdog) Start() {
-	go func() {
-		for {
-			time.Sleep(time.Second)
-			// Second conflicting access.
-			if w.last < time.Now().Add(-10*time.Second).UnixNano() {
-				fmt.Println("No keepalives for 10 seconds. Dying.")
-				os.Exit(1)
-			}
-		}
-	}()
-}
-</pre>
-
-<p>
-Even such "innocent" data races can lead to hard-to-debug problems caused by
-non-atomicity of the memory accesses,
-interference with compiler optimizations,
-or reordering issues accessing processor memory .
-</p>
-
-<p>
-A typical fix for this race is to use a channel or a mutex.
-To preserve the lock-free behavior, one can also use the
-<a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package.
-</p>
-
-<pre>
-type Watchdog struct{ last int64 }
-
-func (w *Watchdog) KeepAlive() {
-	atomic.StoreInt64(&amp;w.last, time.Now().UnixNano())
-}
-
-func (w *Watchdog) Start() {
-	go func() {
-		for {
-			time.Sleep(time.Second)
-			if atomic.LoadInt64(&amp;w.last) < time.Now().Add(-10*time.Second).UnixNano() {
-				fmt.Println("No keepalives for 10 seconds. Dying.")
-				os.Exit(1)
-			}
-		}
-	}()
-}
-</pre>
-
-<h3 id="Unsynchronized_send_and_close_operations">Unsynchronized send and close operations</h3>
-
-<p>
-As this example demonstrates, unsynchronized send and close operations
-on the same channel can also be a race condition:
-</p>
-
-<pre>
-c := make(chan struct{}) // or buffered channel
-
-// The race detector cannot derive the happens before relation
-// for the following send and close operations. These two operations
-// are unsynchronized and happen concurrently.
-go func() { c <- struct{}{} }()
-close(c)
-</pre>
-
-<p>
-According to the Go memory model, a send on a channel happens before
-the corresponding receive from that channel completes. To synchronize
-send and close operations, use a receive operation that guarantees
-the send is done before the close:
-</p>
-
-<pre>
-c := make(chan struct{}) // or buffered channel
-
-go func() { c <- struct{}{} }()
-<-c
-close(c)
-</pre>
-
-<h2 id="Supported_Systems">Supported Systems</h2>
-
-<p>
-  The race detector runs on
-  <code>linux/amd64</code>, <code>linux/ppc64le</code>,
-  <code>linux/arm64</code>, <code>freebsd/amd64</code>,
-  <code>netbsd/amd64</code>, <code>darwin/amd64</code>,
-  and <code>windows/amd64</code>.
-</p>
-
-<h2 id="Runtime_Overheads">Runtime Overhead</h2>
-
-<p>
-The cost of race detection varies by program, but for a typical program, memory
-usage may increase by 5-10x and execution time by 2-20x.
-</p>
-
-<p>
-The race detector currently allocates an extra 8 bytes per <code>defer</code>
-and <code>recover</code> statement. Those extra allocations <a
-href="https://golang.org/issue/26813">are not recovered until the goroutine
-exits</a>. This means that if you have a long-running goroutine that is
-periodically issuing <code>defer</code> and <code>recover</code> calls,
-the program memory usage may grow without bound. These memory allocations
-will not show up in the output of <code>runtime.ReadMemStats</code> or
-<code>runtime/pprof</code>.
-</p>

doc/articles/wiki/edit.html

@@ -1,6 +0,0 @@
-<h1>Editing {{.Title}}</h1>
-
-<form action="/save/{{.Title}}" method="POST">
-<div><textarea name="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea></div>
-<div><input type="submit" value="Save"></div>
-</form>

doc/articles/wiki/final-noclosure.go

@@ -1,105 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"errors"
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"regexp"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title, err := getTitle(w, r)
-	if err != nil {
-		return
-	}
-	p, err := loadPage(title)
-	if err != nil {
-		http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-		return
-	}
-	renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-	title, err := getTitle(w, r)
-	if err != nil {
-		return
-	}
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request) {
-	title, err := getTitle(w, r)
-	if err != nil {
-		return
-	}
-	body := r.FormValue("body")
-	p := &Page{Title: title, Body: []byte(body)}
-	err = p.save()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-	t, err := template.ParseFiles(tmpl + ".html")
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	err = t.Execute(w, p)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
-
-func getTitle(w http.ResponseWriter, r *http.Request) (string, error) {
-	m := validPath.FindStringSubmatch(r.URL.Path)
-	if m == nil {
-		http.NotFound(w, r)
-		return "", errors.New("invalid Page Title")
-	}
-	return m[2], nil // The title is the second subexpression.
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	http.HandleFunc("/edit/", editHandler)
-	http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/final-noerror.go

@@ -1,56 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/edit/"):]
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	t, _ := template.ParseFiles("edit.html")
-	t.Execute(w, p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/view/"):]
-	p, _ := loadPage(title)
-	t, _ := template.ParseFiles("view.html")
-	t.Execute(w, p)
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	http.HandleFunc("/edit/", editHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/final-parsetemplate.go

@@ -1,94 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"regexp"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
-	p, err := loadPage(title)
-	if err != nil {
-		http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-		return
-	}
-	renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request, title string) {
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
-	body := r.FormValue("body")
-	p := &Page{Title: title, Body: []byte(body)}
-	err := p.save()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-	t, err := template.ParseFiles(tmpl + ".html")
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	err = t.Execute(w, p)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
-
-func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		m := validPath.FindStringSubmatch(r.URL.Path)
-		if m == nil {
-			http.NotFound(w, r)
-			return
-		}
-		fn(w, r, m[2])
-	}
-}
-
-func main() {
-	http.HandleFunc("/view/", makeHandler(viewHandler))
-	http.HandleFunc("/edit/", makeHandler(editHandler))
-	http.HandleFunc("/save/", makeHandler(saveHandler))
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/final-template.go

@@ -1,68 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/edit/"):]
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	renderTemplate(w, "edit", p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/view/"):]
-	p, _ := loadPage(title)
-	renderTemplate(w, "view", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/save/"):]
-	body := r.FormValue("body")
-	p := &Page{Title: title, Body: []byte(body)}
-	p.save()
-	http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-	t, _ := template.ParseFiles(tmpl + ".html")
-	t.Execute(w, p)
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	http.HandleFunc("/edit/", editHandler)
-	http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/final.go

@@ -1,92 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"regexp"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
-	p, err := loadPage(title)
-	if err != nil {
-		http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-		return
-	}
-	renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request, title string) {
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
-	body := r.FormValue("body")
-	p := &Page{Title: title, Body: []byte(body)}
-	err := p.save()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-var templates = template.Must(template.ParseFiles("edit.html", "view.html"))
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-	err := templates.ExecuteTemplate(w, tmpl+".html", p)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
-
-func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		m := validPath.FindStringSubmatch(r.URL.Path)
-		if m == nil {
-			http.NotFound(w, r)
-			return
-		}
-		fn(w, r, m[2])
-	}
-}
-
-func main() {
-	http.HandleFunc("/view/", makeHandler(viewHandler))
-	http.HandleFunc("/edit/", makeHandler(editHandler))
-	http.HandleFunc("/save/", makeHandler(saveHandler))
-
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/final_test.go

@@ -1,24 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-)
-
-func serve() error {
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println(l.Addr().String())
-	s := &http.Server{}
-	return s.Serve(l)
-}

doc/articles/wiki/go.mod

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

doc/articles/wiki/http-sample.go

@@ -1,18 +0,0 @@
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-)
-
-func handler(w http.ResponseWriter, r *http.Request) {
-	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
-}
-
-func main() {
-	http.HandleFunc("/", handler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/index.html

@@ -1,741 +0,0 @@
-<!--{
-	"Title": "Writing Web Applications",
-	"Template": true
-}-->
-
-<h2>Introduction</h2>
-
-<p>
-Covered in this tutorial:
-</p>
-<ul>
-<li>Creating a data structure with load and save methods</li>
-<li>Using the <code>net/http</code> package to build web applications
-<li>Using the <code>html/template</code> package to process HTML templates</li>
-<li>Using the <code>regexp</code> package to validate user input</li>
-<li>Using closures</li>
-</ul>
-
-<p>
-Assumed knowledge:
-</p>
-<ul>
-<li>Programming experience</li>
-<li>Understanding of basic web technologies (HTTP, HTML)</li>
-<li>Some UNIX/DOS command-line knowledge</li>
-</ul>
-
-<h2>Getting Started</h2>
-
-<p>
-At present, you need to have a FreeBSD, Linux, OS X, or Windows machine to run Go.
-We will use <code>$</code> to represent the command prompt.
-</p>
-
-<p>
-Install Go (see the <a href="/doc/install">Installation Instructions</a>).
-</p>
-
-<p>
-Make a new directory for this tutorial inside your <code>GOPATH</code> and cd to it:
-</p>
-
-<pre>
-$ mkdir gowiki
-$ cd gowiki
-</pre>
-
-<p>
-Create a file named <code>wiki.go</code>, open it in your favorite editor, and
-add the following lines:
-</p>
-
-<pre>
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-)
-</pre>
-
-<p>
-We import the <code>fmt</code> and <code>ioutil</code> packages from the Go
-standard library. Later, as we implement additional functionality, we will
-add more packages to this <code>import</code> declaration.
-</p>
-
-<h2>Data Structures</h2>
-
-<p>
-Let's start by defining the data structures. A wiki consists of a series of
-interconnected pages, each of which has a title and a body (the page content).
-Here, we define <code>Page</code> as a struct with two fields representing
-the title and body.
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^type Page/` `/}/`}}
-
-<p>
-The type <code>[]byte</code> means "a <code>byte</code> slice".
-(See <a href="/doc/articles/slices_usage_and_internals.html">Slices: usage and
-internals</a> for more on slices.)
-The <code>Body</code> element is a <code>[]byte</code> rather than
-<code>string</code> because that is the type expected by the <code>io</code>
-libraries we will use, as you'll see below.
-</p>
-
-<p>
-The <code>Page</code> struct describes how page data will be stored in memory.
-But what about persistent storage? We can address that by creating a
-<code>save</code> method on <code>Page</code>:
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^func.*Page.*save/` `/}/`}}
-
-<p>
-This method's signature reads: "This is a method named <code>save</code> that
-takes as its receiver <code>p</code>, a pointer to <code>Page</code> . It takes
-no parameters, and returns a value of type <code>error</code>."
-</p>
-
-<p>
-This method will save the <code>Page</code>'s <code>Body</code> to a text
-file. For simplicity, we will use the <code>Title</code> as the file name.
-</p>
-
-<p>
-The <code>save</code> method returns an <code>error</code> value because
-that is the return type of <code>WriteFile</code> (a standard library function
-that writes a byte slice to a file).  The <code>save</code> method returns the
-error value, to let the application handle it should anything go wrong while
-writing the file.  If all goes well, <code>Page.save()</code> will return
-<code>nil</code> (the zero-value for pointers, interfaces, and some other
-types).
-</p>
-
-<p>
-The octal integer literal <code>0600</code>, passed as the third parameter to
-<code>WriteFile</code>, indicates that the file should be created with
-read-write permissions for the current user only. (See the Unix man page
-<code>open(2)</code> for details.)
-</p>
-
-<p>
-In addition to saving pages, we will want to load pages, too:
-</p>
-
-{{code "doc/articles/wiki/part1-noerror.go" `/^func loadPage/` `/^}/`}}
-
-<p>
-The function <code>loadPage</code> constructs the file name from the title
-parameter, reads the file's contents into a new variable <code>body</code>, and
-returns a pointer to a <code>Page</code> literal constructed with the proper
-title and body values.
-</p>
-
-<p>
-Functions can return multiple values. The standard library function
-<code>io.ReadFile</code> returns <code>[]byte</code> and <code>error</code>.
-In <code>loadPage</code>, error isn't being handled yet; the "blank identifier"
-represented by the underscore (<code>_</code>) symbol is used to throw away the
-error return value (in essence, assigning the value to nothing).
-</p>
-
-<p>
-But what happens if <code>ReadFile</code> encounters an error?  For example,
-the file might not exist. We should not ignore such errors.  Let's modify the
-function to return <code>*Page</code> and <code>error</code>.
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^func loadPage/` `/^}/`}}
-
-<p>
-Callers of this function can now check the second parameter; if it is
-<code>nil</code> then it has successfully loaded a Page. If not, it will be an
-<code>error</code> that can be handled by the caller (see the
-<a href="/ref/spec#Errors">language specification</a> for details).
-</p>
-
-<p>
-At this point we have a simple data structure and the ability to save to and
-load from a file. Let's write a <code>main</code> function to test what we've
-written:
-</p>
-
-{{code "doc/articles/wiki/part1.go" `/^func main/` `/^}/`}}
-
-<p>
-After compiling and executing this code, a file named <code>TestPage.txt</code>
-would be created, containing the contents of <code>p1</code>. The file would
-then be read into the struct <code>p2</code>, and its <code>Body</code> element
-printed to the screen.
-</p>
-
-<p>
-You can compile and run the program like this:
-</p>
-
-<pre>
-$ go build wiki.go
-$ ./wiki
-This is a sample Page.
-</pre>
-
-<p>
-(If you're using Windows you must type "<code>wiki</code>" without the
-"<code>./</code>" to run the program.)
-</p>
-
-<p>
-<a href="part1.go">Click here to view the code we've written so far.</a>
-</p>
-
-<h2>Introducing the <code>net/http</code> package (an interlude)</h2>
-
-<p>
-Here's a full working example of a simple web server:
-</p>
-
-{{code "doc/articles/wiki/http-sample.go"}}
-
-<p>
-The <code>main</code> function begins with a call to
-<code>http.HandleFunc</code>, which tells the <code>http</code> package to
-handle all requests to the web root (<code>"/"</code>) with
-<code>handler</code>.
-</p>
-
-<p>
-It then calls <code>http.ListenAndServe</code>, specifying that it should
-listen on port 8080 on any interface (<code>":8080"</code>). (Don't
-worry about its second parameter, <code>nil</code>, for now.)
-This function will block until the program is terminated.
-</p>
-
-<p>
-<code>ListenAndServe</code> always returns an error, since it only returns when an
-unexpected error occurs.
-In order to log that error we wrap the function call with <code>log.Fatal</code>.
-</p>
-
-<p>
-The function <code>handler</code> is of the type <code>http.HandlerFunc</code>.
-It takes an <code>http.ResponseWriter</code> and an <code>http.Request</code> as
-its arguments.
-</p>
-
-<p>
-An <code>http.ResponseWriter</code> value assembles the HTTP server's response; by writing
-to it, we send data to the HTTP client.
-</p>
-
-<p>
-An <code>http.Request</code> is a data structure that represents the client
-HTTP request. <code>r.URL.Path</code> is the path component
-of the request URL. The trailing <code>[1:]</code> means
-"create a sub-slice of <code>Path</code> from the 1st character to the end."
-This drops the leading "/" from the path name.
-</p>
-
-<p>
-If you run this program and access the URL:
-</p>
-<pre>http://localhost:8080/monkeys</pre>
-<p>
-the program would present a page containing:
-</p>
-<pre>Hi there, I love monkeys!</pre>
-
-<h2>Using <code>net/http</code> to serve wiki pages</h2>
-
-<p>
-To use the <code>net/http</code> package, it must be imported:
-</p>
-
-<pre>
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	<b>"net/http"</b>
-)
-</pre>
-
-<p>
-Let's create a handler, <code>viewHandler</code> that will allow users to
-view a wiki page. It will handle URLs prefixed with "/view/".
-</p>
-
-{{code "doc/articles/wiki/part2.go" `/^func viewHandler/` `/^}/`}}
-
-<p>
-Again, note the use of <code>_</code> to ignore the <code>error</code>
-return value from <code>loadPage</code>. This is done here for simplicity
-and generally considered bad practice. We will attend to this later.
-</p>
-
-<p>
-First, this function extracts the page title from <code>r.URL.Path</code>,
-the path component of the request URL.
-The <code>Path</code> is re-sliced with <code>[len("/view/"):]</code> to drop
-the leading <code>"/view/"</code> component of the request path.
-This is because the path will invariably begin with <code>"/view/"</code>,
-which is not part of the page's title.
-</p>
-
-<p>
-The function then loads the page data, formats the page with a string of simple
-HTML, and writes it to <code>w</code>, the <code>http.ResponseWriter</code>.
-</p>
-
-<p>
-To use this handler, we rewrite our <code>main</code> function to
-initialize <code>http</code> using the <code>viewHandler</code> to handle
-any requests under the path <code>/view/</code>.
-</p>
-
-{{code "doc/articles/wiki/part2.go" `/^func main/` `/^}/`}}
-
-<p>
-<a href="part2.go">Click here to view the code we've written so far.</a>
-</p>
-
-<p>
-Let's create some page data (as <code>test.txt</code>), compile our code, and
-try serving a wiki page.
-</p>
-
-<p>
-Open <code>test.txt</code> file in your editor, and save the string "Hello world" (without quotes)
-in it.
-</p>
-
-<pre>
-$ go build wiki.go
-$ ./wiki
-</pre>
-
-<p>
-(If you're using Windows you must type "<code>wiki</code>" without the
-"<code>./</code>" to run the program.)
-</p>
-
-<p>
-With this web server running, a visit to <code><a
-href="http://localhost:8080/view/test">http://localhost:8080/view/test</a></code>
-should show a page titled "test" containing the words "Hello world".
-</p>
-
-<h2>Editing Pages</h2>
-
-<p>
-A wiki is not a wiki without the ability to edit pages. Let's create two new
-handlers: one named <code>editHandler</code> to display an 'edit page' form,
-and the other named <code>saveHandler</code> to save the data entered via the
-form.
-</p>
-
-<p>
-First, we add them to <code>main()</code>:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/^func main/` `/^}/`}}
-
-<p>
-The function <code>editHandler</code> loads the page
-(or, if it doesn't exist, create an empty <code>Page</code> struct),
-and displays an HTML form.
-</p>
-
-{{code "doc/articles/wiki/notemplate.go" `/^func editHandler/` `/^}/`}}
-
-<p>
-This function will work fine, but all that hard-coded HTML is ugly.
-Of course, there is a better way.
-</p>
-
-<h2>The <code>html/template</code> package</h2>
-
-<p>
-The <code>html/template</code> package is part of the Go standard library.
-We can use <code>html/template</code> to keep the HTML in a separate file,
-allowing us to change the layout of our edit page without modifying the
-underlying Go code.
-</p>
-
-<p>
-First, we must add <code>html/template</code> to the list of imports. We
-also won't be using <code>fmt</code> anymore, so we have to remove that.
-</p>
-
-<pre>
-import (
-	<b>"html/template"</b>
-	"io/ioutil"
-	"net/http"
-)
-</pre>
-
-<p>
-Let's create a template file containing the HTML form.
-Open a new file named <code>edit.html</code>, and add the following lines:
-</p>
-
-{{code "doc/articles/wiki/edit.html"}}
-
-<p>
-Modify <code>editHandler</code> to use the template, instead of the hard-coded
-HTML:
-</p>
-
-{{code "doc/articles/wiki/final-noerror.go" `/^func editHandler/` `/^}/`}}
-
-<p>
-The function <code>template.ParseFiles</code> will read the contents of
-<code>edit.html</code> and return a <code>*template.Template</code>.
-</p>
-
-<p>
-The method <code>t.Execute</code> executes the template, writing the
-generated HTML to the <code>http.ResponseWriter</code>.
-The <code>.Title</code> and <code>.Body</code> dotted identifiers refer to
-<code>p.Title</code> and <code>p.Body</code>.
-</p>
-
-<p>
-Template directives are enclosed in double curly braces.
-The <code>printf "%s" .Body</code> instruction is a function call
-that outputs <code>.Body</code> as a string instead of a stream of bytes,
-the same as a call to <code>fmt.Printf</code>.
-The <code>html/template</code> package helps guarantee that only safe and
-correct-looking HTML is generated by template actions. For instance, it
-automatically escapes any greater than sign (<code>&gt;</code>), replacing it
-with <code>&amp;gt;</code>, to make sure user data does not corrupt the form
-HTML.
-</p>
-
-<p>
-Since we're working with templates now, let's create a template for our
-<code>viewHandler</code> called <code>view.html</code>:
-</p>
-
-{{code "doc/articles/wiki/view.html"}}
-
-<p>
-Modify <code>viewHandler</code> accordingly:
-</p>
-
-{{code "doc/articles/wiki/final-noerror.go" `/^func viewHandler/` `/^}/`}}
-
-<p>
-Notice that we've used almost exactly the same templating code in both
-handlers. Let's remove this duplication by moving the templating code
-to its own function:
-</p>
-
-{{code "doc/articles/wiki/final-template.go" `/^func renderTemplate/` `/^}/`}}
-
-<p>
-And modify the handlers to use that function:
-</p>
-
-{{code "doc/articles/wiki/final-template.go" `/^func viewHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final-template.go" `/^func editHandler/` `/^}/`}}
-
-<p>
-If we comment out the registration of our unimplemented save handler in
-<code>main</code>, we can once again build and test our program.
-<a href="part3.go">Click here to view the code we've written so far.</a>
-</p>
-
-<h2>Handling non-existent pages</h2>
-
-<p>
-What if you visit <a href="http://localhost:8080/view/APageThatDoesntExist">
-<code>/view/APageThatDoesntExist</code></a>? You'll see a page containing
-HTML. This is because it ignores the error return value from
-<code>loadPage</code> and continues to try and fill out the template
-with no data. Instead, if the requested Page doesn't exist, it should
-redirect the client to the edit Page so the content may be created:
-</p>
-
-{{code "doc/articles/wiki/part3-errorhandling.go" `/^func viewHandler/` `/^}/`}}
-
-<p>
-The <code>http.Redirect</code> function adds an HTTP status code of
-<code>http.StatusFound</code> (302) and a <code>Location</code>
-header to the HTTP response.
-</p>
-
-<h2>Saving Pages</h2>
-
-<p>
-The function <code>saveHandler</code> will handle the submission of forms
-located on the edit pages. After uncommenting the related line in
-<code>main</code>, let's implement the handler:
-</p>
-
-{{code "doc/articles/wiki/final-template.go" `/^func saveHandler/` `/^}/`}}
-
-<p>
-The page title (provided in the URL) and the form's only field,
-<code>Body</code>, are stored in a new <code>Page</code>.
-The <code>save()</code> method is then called to write the data to a file,
-and the client is redirected to the <code>/view/</code> page.
-</p>
-
-<p>
-The value returned by <code>FormValue</code> is of type <code>string</code>.
-We must convert that value to <code>[]byte</code> before it will fit into
-the <code>Page</code> struct. We use <code>[]byte(body)</code> to perform
-the conversion.
-</p>
-
-<h2>Error handling</h2>
-
-<p>
-There are several places in our program where errors are being ignored.  This
-is bad practice, not least because when an error does occur the program will
-have unintended behavior. A better solution is to handle the errors and return
-an error message to the user. That way if something does go wrong, the server
-will function exactly how we want and the user can be notified.
-</p>
-
-<p>
-First, let's handle the errors in <code>renderTemplate</code>:
-</p>
-
-{{code "doc/articles/wiki/final-parsetemplate.go" `/^func renderTemplate/` `/^}/`}}
-
-<p>
-The <code>http.Error</code> function sends a specified HTTP response code
-(in this case "Internal Server Error") and error message.
-Already the decision to put this in a separate function is paying off.
-</p>
-
-<p>
-Now let's fix up <code>saveHandler</code>:
-</p>
-
-{{code "doc/articles/wiki/part3-errorhandling.go" `/^func saveHandler/` `/^}/`}}
-
-<p>
-Any errors that occur during <code>p.save()</code> will be reported
-to the user.
-</p>
-
-<h2>Template caching</h2>
-
-<p>
-There is an inefficiency in this code: <code>renderTemplate</code> calls
-<code>ParseFiles</code> every time a page is rendered.
-A better approach would be to call <code>ParseFiles</code> once at program
-initialization, parsing all templates into a single <code>*Template</code>.
-Then we can use the
-<a href="/pkg/html/template/#Template.ExecuteTemplate"><code>ExecuteTemplate</code></a>
-method to render a specific template.
-</p>
-
-<p>
-First we create a global variable named <code>templates</code>, and initialize
-it with <code>ParseFiles</code>.
-</p>
-
-{{code "doc/articles/wiki/final.go" `/var templates/`}}
-
-<p>
-The function <code>template.Must</code> is a convenience wrapper that panics
-when passed a non-nil <code>error</code> value, and otherwise returns the
-<code>*Template</code> unaltered. A panic is appropriate here; if the templates
-can't be loaded the only sensible thing to do is exit the program.
-</p>
-
-<p>
-The <code>ParseFiles</code> function takes any number of string arguments that
-identify our template files, and parses those files into templates that are
-named after the base file name. If we were to add more templates to our
-program, we would add their names to the <code>ParseFiles</code> call's
-arguments.
-</p>
-
-<p>
-We then modify the <code>renderTemplate</code> function to call the
-<code>templates.ExecuteTemplate</code> method with the name of the appropriate
-template:
-</p>
-
-{{code "doc/articles/wiki/final.go" `/func renderTemplate/` `/^}/`}}
-
-<p>
-Note that the template name is the template file name, so we must
-append <code>".html"</code> to the <code>tmpl</code> argument.
-</p>
-
-<h2>Validation</h2>
-
-<p>
-As you may have observed, this program has a serious security flaw: a user
-can supply an arbitrary path to be read/written on the server. To mitigate
-this, we can write a function to validate the title with a regular expression.
-</p>
-
-<p>
-First, add <code>"regexp"</code> to the <code>import</code> list.
-Then we can create a global variable to store our validation
-expression:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/^var validPath/`}}
-
-<p>
-The function <code>regexp.MustCompile</code> will parse and compile the
-regular expression, and return a <code>regexp.Regexp</code>.
-<code>MustCompile</code> is distinct from <code>Compile</code> in that it will
-panic if the expression compilation fails, while <code>Compile</code> returns
-an <code>error</code> as a second parameter.
-</p>
-
-<p>
-Now, let's write a function that uses the <code>validPath</code>
-expression to validate path and extract the page title:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/func getTitle/` `/^}/`}}
-
-<p>
-If the title is valid, it will be returned along with a <code>nil</code>
-error value. If the title is invalid, the function will write a
-"404 Not Found" error to the HTTP connection, and return an error to the
-handler. To create a new error, we have to import the <code>errors</code>
-package.
-</p>
-
-<p>
-Let's put a call to <code>getTitle</code> in each of the handlers:
-</p>
-
-{{code "doc/articles/wiki/final-noclosure.go" `/^func viewHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final-noclosure.go" `/^func editHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final-noclosure.go" `/^func saveHandler/` `/^}/`}}
-
-<h2>Introducing Function Literals and Closures</h2>
-
-<p>
-Catching the error condition in each handler introduces a lot of repeated code.
-What if we could wrap each of the handlers in a function that does this
-validation and error checking? Go's
-<a href="/ref/spec#Function_literals">function
-literals</a> provide a powerful means of abstracting functionality
-that can help us here.
-</p>
-
-<p>
-First, we re-write the function definition of each of the handlers to accept
-a title string:
-</p>
-
-<pre>
-func viewHandler(w http.ResponseWriter, r *http.Request, title string)
-func editHandler(w http.ResponseWriter, r *http.Request, title string)
-func saveHandler(w http.ResponseWriter, r *http.Request, title string)
-</pre>
-
-<p>
-Now let's define a wrapper function that <i>takes a function of the above
-type</i>, and returns a function of type <code>http.HandlerFunc</code>
-(suitable to be passed to the function <code>http.HandleFunc</code>):
-</p>
-
-<pre>
-func makeHandler(fn func (http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		// Here we will extract the page title from the Request,
-		// and call the provided handler 'fn'
-	}
-}
-</pre>
-
-<p>
-The returned function is called a closure because it encloses values defined
-outside of it. In this case, the variable <code>fn</code> (the single argument
-to <code>makeHandler</code>) is enclosed by the closure. The variable
-<code>fn</code> will be one of our save, edit, or view handlers.
-</p>
-
-<p>
-Now we can take the code from <code>getTitle</code> and use it here
-(with some minor modifications):
-</p>
-
-{{code "doc/articles/wiki/final.go" `/func makeHandler/` `/^}/`}}
-
-<p>
-The closure returned by <code>makeHandler</code> is a function that takes
-an <code>http.ResponseWriter</code> and <code>http.Request</code> (in other
-words, an <code>http.HandlerFunc</code>).
-The closure extracts the <code>title</code> from the request path, and
-validates it with the <code>validPath</code> regexp. If the
-<code>title</code> is invalid, an error will be written to the
-<code>ResponseWriter</code> using the <code>http.NotFound</code> function.
-If the <code>title</code> is valid, the enclosed handler function
-<code>fn</code> will be called with the <code>ResponseWriter</code>,
-<code>Request</code>, and <code>title</code> as arguments.
-</p>
-
-<p>
-Now we can wrap the handler functions with <code>makeHandler</code> in
-<code>main</code>, before they are registered with the <code>http</code>
-package:
-</p>
-
-{{code "doc/articles/wiki/final.go" `/func main/` `/^}/`}}
-
-<p>
-Finally we remove the calls to <code>getTitle</code> from the handler functions,
-making them much simpler:
-</p>
-
-{{code "doc/articles/wiki/final.go" `/^func viewHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final.go" `/^func editHandler/` `/^}/`}}
-{{code "doc/articles/wiki/final.go" `/^func saveHandler/` `/^}/`}}
-
-<h2>Try it out!</h2>
-
-<p>
-<a href="final.go">Click here to view the final code listing.</a>
-</p>
-
-<p>
-Recompile the code, and run the app:
-</p>
-
-<pre>
-$ go build wiki.go
-$ ./wiki
-</pre>
-
-<p>
-Visiting <a href="http://localhost:8080/view/ANewPage">http://localhost:8080/view/ANewPage</a>
-should present you with the page edit form. You should then be able to
-enter some text, click 'Save', and be redirected to the newly created page.
-</p>
-
-<h2>Other tasks</h2>
-
-<p>
-Here are some simple tasks you might want to tackle on your own:
-</p>
-
-<ul>
-<li>Store templates in <code>tmpl/</code> and page data in <code>data/</code>.
-<li>Add a handler to make the web root redirect to
-	<code>/view/FrontPage</code>.</li>
-<li>Spruce up the page templates by making them valid HTML and adding some
-	CSS rules.</li>
-<li>Implement inter-page linking by converting instances of
-	<code>[PageName]</code> to <br>
-	<code>&lt;a href="/view/PageName"&gt;PageName&lt;/a&gt;</code>.
-	(hint: you could use <code>regexp.ReplaceAllFunc</code> to do this)
-	</li>
-</ul>

doc/articles/wiki/notemplate.go

@@ -1,59 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/view/"):]
-	p, _ := loadPage(title)
-	fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/edit/"):]
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	fmt.Fprintf(w, "<h1>Editing %s</h1>"+
-		"<form action=\"/save/%s\" method=\"POST\">"+
-		"<textarea name=\"body\">%s</textarea><br>"+
-		"<input type=\"submit\" value=\"Save\">"+
-		"</form>",
-		p.Title, p.Title, p.Body)
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	http.HandleFunc("/edit/", editHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/part1-noerror.go

@@ -1,35 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) *Page {
-	filename := title + ".txt"
-	body, _ := ioutil.ReadFile(filename)
-	return &Page{Title: title, Body: body}
-}
-
-func main() {
-	p1 := &Page{Title: "TestPage", Body: []byte("This is a sample page.")}
-	p1.save()
-	p2 := loadPage("TestPage")
-	fmt.Println(string(p2.Body))
-}

doc/articles/wiki/part1.go

@@ -1,38 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func main() {
-	p1 := &Page{Title: "TestPage", Body: []byte("This is a sample Page.")}
-	p1.save()
-	p2, _ := loadPage("TestPage")
-	fmt.Println(string(p2.Body))
-}

doc/articles/wiki/part2.go

@@ -1,44 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/view/"):]
-	p, _ := loadPage(title)
-	fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/part3-errorhandling.go

@@ -1,76 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-	t, _ := template.ParseFiles(tmpl + ".html")
-	t.Execute(w, p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/view/"):]
-	p, err := loadPage(title)
-	if err != nil {
-		http.Redirect(w, r, "/edit/"+title, http.StatusFound)
-		return
-	}
-	renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/edit/"):]
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	renderTemplate(w, "edit", p)
-}
-
-func saveHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/save/"):]
-	body := r.FormValue("body")
-	p := &Page{Title: title, Body: []byte(body)}
-	err := p.save()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	http.Redirect(w, r, "/view/"+title, http.StatusFound)
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	http.HandleFunc("/edit/", editHandler)
-	http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/part3.go

@@ -1,60 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"html/template"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-type Page struct {
-	Title string
-	Body  []byte
-}
-
-func (p *Page) save() error {
-	filename := p.Title + ".txt"
-	return ioutil.WriteFile(filename, p.Body, 0600)
-}
-
-func loadPage(title string) (*Page, error) {
-	filename := title + ".txt"
-	body, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	return &Page{Title: title, Body: body}, nil
-}
-
-func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
-	t, _ := template.ParseFiles(tmpl + ".html")
-	t.Execute(w, p)
-}
-
-func viewHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/view/"):]
-	p, _ := loadPage(title)
-	renderTemplate(w, "view", p)
-}
-
-func editHandler(w http.ResponseWriter, r *http.Request) {
-	title := r.URL.Path[len("/edit/"):]
-	p, err := loadPage(title)
-	if err != nil {
-		p = &Page{Title: title}
-	}
-	renderTemplate(w, "edit", p)
-}
-
-func main() {
-	http.HandleFunc("/view/", viewHandler)
-	http.HandleFunc("/edit/", editHandler)
-	//http.HandleFunc("/save/", saveHandler)
-	log.Fatal(http.ListenAndServe(":8080", nil))
-}

doc/articles/wiki/test_Test.txt.good

@@ -1 +0,0 @@
-some content

doc/articles/wiki/test_edit.good

@@ -1,6 +0,0 @@
-<h1>Editing Test</h1>
-
-<form action="/save/Test" method="POST">
-<div><textarea name="body" rows="20" cols="80"></textarea></div>
-<div><input type="submit" value="Save"></div>
-</form>

doc/articles/wiki/test_view.good

@@ -1,5 +0,0 @@
-<h1>Test</h1>
-
-<p>[<a href="/edit/Test">edit</a>]</p>
-
-<div>some content</div>

doc/articles/wiki/view.html

@@ -1,5 +0,0 @@
-<h1>{{.Title}}</h1>
-
-<p>[<a href="/edit/{{.Title}}">edit</a>]</p>
-
-<div>{{printf "%s" .Body}}</div>

doc/articles/wiki/wiki_test.go

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

doc/asm.html

@@ -464,6 +464,57 @@ Function is the top of the call stack. Traceback should stop at this function.
 </li>
 </ul>
 
+<h3 id="data-offsets">Interacting with Go types and constants</h3>
+
+<p>
+If a package has any .s files, then <code>go build</code> will direct
+the compiler to emit a special header called <code>go_asm.h</code>,
+which the .s files can then <code>#include</code>.
+The file contains symbolic <code>#define</code> constants for the
+offsets of Go struct fields, the sizes of Go struct types, and most
+Go <code>const</code> declarations defined in the current package.
+Go assembly should avoid making assumptions about the layout of Go
+types and instead use these constants.
+This improves the readability of assembly code, and keeps it robust to
+changes in data layout either in the Go type definitions or in the
+layout rules used by the Go compiler.
+</p>
+
+<p>
+Constants are of the form <code>const_<i>name</i></code>.
+For example, given the Go declaration <code>const bufSize =
+1024</code>, assembly code can refer to the value of this constant
+as <code>const_bufSize</code>.
+</p>
+
+<p>
+Field offsets are of the form <code><i>type</i>_<i>field</i></code>.
+Struct sizes are of the form <code><i>type</i>__size</code>.
+For example, consider the following Go definition:
+</p>
+
+<pre>
+type reader struct {
+	buf [bufSize]byte
+	r   int
+}
+</pre>
+
+<p>
+Assembly can refer to the size of this struct
+as <code>reader__size</code> and the offsets of the two fields
+as <code>reader_buf</code> and <code>reader_r</code>.
+Hence, if register <code>R1</code> contains a pointer to
+a <code>reader</code>, assembly can reference the <code>r</code> field
+as <code>reader_r(R1)</code>.
+</p>
+
+<p>
+If any of these <code>#define</code> names are ambiguous (for example,
+a struct with a <code>_size</code> field), <code>#include
+"go_asm.h"</code> will fail with a "redefinition of macro" error.
+</p>
+
 <h3 id="runtime">Runtime Coordination</h3>
 
 <p>
@@ -615,21 +666,15 @@ Here follow some descriptions of key Go-specific details for the supported archi
 <p>
 The runtime pointer to the <code>g</code> structure is maintained
 through the value of an otherwise unused (as far as Go is concerned) register in the MMU.
-An OS-dependent macro <code>get_tls</code> is defined for the assembler if the source is
-in the <code>runtime</code> package and includes a special header, <code>go_tls.h</code>:
+In the runtime package, assembly code can include <code>go_tls.h</code>, which defines
+an OS- and architecture-dependent macro <code>get_tls</code> for accessing this register.
+The <code>get_tls</code> macro takes one argument, which is the register to load the
+<code>g</code> pointer into.
 </p>
 
-<pre>
-#include "go_tls.h"
-</pre>
-
 <p>
-Within the runtime, the <code>get_tls</code> macro loads its argument register
-with a pointer to the <code>g</code> pointer, and the <code>g</code> struct
-contains the <code>m</code> pointer.
-There's another special header containing the offsets for each
-element of <code>g</code>, called <code>go_asm.h</code>.
-The sequence to load <code>g</code> and <code>m</code> using <code>CX</code> looks like this:
+For example, the sequence to load <code>g</code> and <code>m</code>
+using <code>CX</code> looks like this:
 </p>
 
 <pre>
@@ -642,8 +687,7 @@ MOVL	g_m(AX), BX   // Move g.m into BX.
 </pre>
 
 <p>
-Note: The code above works only in the <code>runtime</code> package, while <code>go_tls.h</code> also
-applies to <a href="#arm">arm</a>, <a href="#amd64">amd64</a> and amd64p32, and <code>go_asm.h</code> applies to all architectures.
+The <code>get_tls</code> macro is also defined on <a href="#amd64">amd64</a>.
 </p>
 
 <p>

doc/cmd.html

@@ -1,100 +0,0 @@
-<!--{
-	"Title": "Command Documentation",
-	"Path":  "/doc/cmd"
-}-->
-
-<p>
-There is a suite of programs to build and process Go source code.
-Instead of being run directly, programs in the suite are usually invoked
-by the <a href="/cmd/go/">go</a> program.
-</p>
-
-<p>
-The most common way to run these programs is as a subcommand of the go program,
-for instance as <code>go fmt</code>. Run like this, the command operates on
-complete packages of Go source code, with the go program invoking the
-underlying binary with arguments appropriate to package-level processing.
-</p>
-
-<p>
-The programs can also be run as stand-alone binaries, with unmodified arguments,
-using the go <code>tool</code> subcommand, such as <code>go tool cgo</code>.
-For most commands this is mainly useful for debugging.
-Some of the commands, such as <code>pprof</code>, are accessible only through
-the go <code>tool</code> subcommand.
-</p>
-
-<p>
-Finally the <code>fmt</code> and <code>godoc</code> commands are installed
-as regular binaries called <code>gofmt</code> and <code>godoc</code> because
-they are so often referenced.
-</p>
-
-<p>
-Click on the links for more documentation, invocation methods, and usage details.
-</p>
-
-<table class="dir">
-<tr>
-<th>Name</th>
-<th>&nbsp;&nbsp;&nbsp;&nbsp;</th>
-<th>Synopsis</th>
-</tr>
-
-<tr>
-<td><a href="/cmd/go/">go</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>
-The <code>go</code> program manages Go source code and runs the other
-commands listed here.
-See the command docs for usage
-details.
-</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/cgo/">cgo</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Cgo enables the creation of Go packages that call C code.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/cover/">cover</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Cover is a program for creating and analyzing the coverage profiles
-generated by <code>"go test -coverprofile"</code>.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/fix/">fix</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Fix finds Go programs that use old features of the language and libraries
-and rewrites them to use newer ones.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/gofmt/">fmt</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Fmt formats Go packages, it is also available as an independent <a href="/cmd/gofmt/">
-gofmt</a> command with more general options.</td>
-</tr>
-
-<tr>
-<td><a href="//godoc.org/golang.org/x/tools/cmd/godoc/">godoc</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Godoc extracts and generates documentation for Go packages.</td>
-</tr>
-
-<tr>
-<td><a href="/cmd/vet/">vet</a></td>
-<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
-<td>Vet examines Go source code and reports suspicious constructs, such as Printf
-calls whose arguments do not align with the format string.</td>
-</tr>
-
-</table>
-
-<p>
-This is an abridged list. See the <a href="/cmd/">full command reference</a>
-for documentation of the compilers and more.
-</p>

doc/codewalk/codewalk.css

@@ -1,234 +0,0 @@
-/*
-   Copyright 2010 The Go Authors. All rights reserved.
-   Use of this source code is governed by a BSD-style
-   license that can be found in the LICENSE file.
-*/
-
-#codewalk-main {
-  text-align: left;
-  width: 100%;
-  overflow: auto;
-}
-
-#code-display {
-  border: 0;
-  width: 100%;
-}
-
-.setting {
-  font-size: 8pt;
-  color: #888888;
-  padding: 5px;
-}
-
-.hotkey {
-  text-decoration: underline;
-}
-
-/* Style for Comments (the left-hand column) */
-
-#comment-column {
-  margin: 0pt;
-  width: 30%;
-}
-
-#comment-column.right {
-  float: right;
-}
-
-#comment-column.left {
-  float: left;
-}
-
-#comment-area {
-  overflow-x: hidden;
-  overflow-y: auto;
-}
-
-.comment {
-  cursor: pointer;
-  font-size: 16px;
-  border: 2px solid #ba9836;
-  margin-bottom: 10px;
-  margin-right: 10px;  /* yes, for both .left and .right */
-}
-
-.comment:last-child {
-  margin-bottom: 0px;
-}
-
-.right .comment {
-  margin-left: 10px;
-}
-
-.right .comment.first {
-}
-
-.right .comment.last {
-}
-
-.left .comment.first {
-}
-
-.left .comment.last {
-}
-
-.comment.selected {
-  border-color: #99b2cb;
-}
-
-.right .comment.selected {
-  border-left-width: 12px;
-  margin-left: 0px;
-}
-
-.left .comment.selected {
-  border-right-width: 12px;
-  margin-right: 0px;
-}
-
-.comment-link {
-  display: none;
-}
-
-.comment-title {
-  font-size: small;
-  font-weight: bold;
-  background-color: #fffff0;
-  padding-right: 10px;
-  padding-left: 10px;
-  padding-top: 5px;
-  padding-bottom: 5px;
-}
-
-.right .comment-title {
-}
-
-.left .comment-title {
-}
-
-.comment.selected .comment-title {
-  background-color: #f8f8ff;
-}
-
-.comment-text {
-  overflow: auto;
-  padding-left: 10px;
-  padding-right: 10px;
-  padding-top: 10px;
-  padding-bottom: 5px;
-  font-size: small;
-  line-height: 1.3em;
-}
-
-.comment-text p {
-  margin-top: 0em;
-  margin-bottom: 0.5em;
-}
-
-.comment-text p:last-child {
-  margin-bottom: 0em;
-}
-
-.file-name {
-  font-size: x-small;
-  padding-top: 0px;
-  padding-bottom: 5px;
-}
-
-.hidden-filepaths .file-name {
-  display: none;
-}
-
-.path-dir {
-  color: #555;
-}
-
-.path-file {
-  color: #555;
-}
-
-
-/* Style for Code (the right-hand column) */
-
-/* Wrapper for the code column to make widths get calculated correctly */
-#code-column {
-  display: block;
-  position: relative;
-  margin: 0pt;
-  width: 70%;
-}
-
-#code-column.left {
-  float: left;
-}
-
-#code-column.right {
-  float: right;
-}
-
-#code-area {
-  background-color: #f8f8ff;
-  border: 2px solid #99b2cb;
-  padding: 5px;
-}
-
-.left #code-area {
-  margin-right: -1px;
-}
-
-.right #code-area {
-  margin-left: -1px;
-}
-
-#code-header {
-  margin-bottom: 5px;
-}
-
-#code {
-  background-color: white;
-}
-
-code {
-  font-size: 100%;
-}
-
-.codewalkhighlight {
-  font-weight: bold;
-  background-color: #f8f8ff;
-}
-
-#code-display {
-  margin-top: 0px;
-  margin-bottom: 0px;
-}
-
-#sizer {
-  position: absolute;
-  cursor: col-resize;
-  left: 0px;
-  top: 0px;
-  width: 8px;
-}
-
-/* Style for options (bottom strip) */
-
-#code-options {
-  display: none;
-}
-
-#code-options > span {
-  padding-right: 20px;
-}
-
-#code-options .selected {
-  border-bottom: 1px dotted;
-}
-
-#comment-options {
-  text-align: center;
-}
-
-div#content {
-  padding-bottom: 0em;
-}

doc/codewalk/codewalk.js

@@ -1,305 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/**
- * A class to hold information about the Codewalk Viewer.
- * @param {jQuery} context The top element in whose context the viewer should
- *     operate.  It will not touch any elements above this one.
- * @constructor
- */
- var CodewalkViewer = function(context) {
-  this.context = context;
-
-  /**
-   * The div that contains all of the comments and their controls.
-   */
-  this.commentColumn = this.context.find('#comment-column');
-
-  /**
-   * The div that contains the comments proper.
-   */
-  this.commentArea = this.context.find('#comment-area');
-
-  /**
-   * The div that wraps the iframe with the code, as well as the drop down menu
-   * listing the different files.
-   * @type {jQuery}
-   */
-  this.codeColumn = this.context.find('#code-column');
-
-  /**
-   * The div that contains the code but excludes the options strip.
-   * @type {jQuery}
-   */
-  this.codeArea = this.context.find('#code-area');
-
-  /**
-   * The iframe that holds the code (from Sourcerer).
-   * @type {jQuery}
-   */
-  this.codeDisplay = this.context.find('#code-display');
-
-  /**
-   * The overlaid div used as a grab handle for sizing the code/comment panes.
-   * @type {jQuery}
-   */
-  this.sizer = this.context.find('#sizer');
-
-  /**
-   * The full-screen overlay that ensures we don't lose track of the mouse
-   * while dragging.
-   * @type {jQuery}
-   */
-  this.overlay = this.context.find('#overlay');
-
-  /**
-   * The hidden input field that we use to hold the focus so that we can detect
-   * shortcut keypresses.
-   * @type {jQuery}
-   */
-  this.shortcutInput = this.context.find('#shortcut-input');
-
-  /**
-   * The last comment that was selected.
-   * @type {jQuery}
-   */
-  this.lastSelected = null;
-};
-
-/**
- * Minimum width of the comments or code pane, in pixels.
- * @type {number}
- */
-CodewalkViewer.MIN_PANE_WIDTH = 200;
-
-/**
- * Navigate the code iframe to the given url and update the code popout link.
- * @param {string} url The target URL.
- * @param {Object} opt_window Window dependency injection for testing only.
- */
-CodewalkViewer.prototype.navigateToCode = function(url, opt_window) {
-  if (!opt_window) opt_window = window;
-  // Each iframe is represented by two distinct objects in the DOM:  an iframe
-  // object and a window object.  These do not expose the same capabilities.
-  // Here we need to get the window representation to get the location member,
-  // so we access it directly through window[] since jQuery returns the iframe
-  // representation.
-  // We replace location rather than set so as not to create a history for code
-  // navigation.
-  opt_window['code-display'].location.replace(url);
-  var k = url.indexOf('&');
-  if (k != -1) url = url.slice(0, k);
-  k = url.indexOf('fileprint=');
-  if (k != -1) url = url.slice(k+10, url.length);
-  this.context.find('#code-popout-link').attr('href', url);
-};
-
-/**
- * Selects the first comment from the list and forces a refresh of the code
- * view.
- */
-CodewalkViewer.prototype.selectFirstComment = function() {
-  // TODO(rsc): handle case where there are no comments
-  var firstSourcererLink = this.context.find('.comment:first');
-  this.changeSelectedComment(firstSourcererLink);
-};
-
-/**
- * Sets the target on all links nested inside comments to be _blank.
- */
-CodewalkViewer.prototype.targetCommentLinksAtBlank = function() {
-  this.context.find('.comment a[href], #description a[href]').each(function() {
-    if (!this.target) this.target = '_blank';
-  });
-};
-
-/**
- * Installs event handlers for all the events we care about.
- */
-CodewalkViewer.prototype.installEventHandlers = function() {
-  var self = this;
-
-  this.context.find('.comment')
-      .click(function(event) {
-        if (jQuery(event.target).is('a[href]')) return true;
-        self.changeSelectedComment(jQuery(this));
-        return false;
-      });
-
-  this.context.find('#code-selector')
-      .change(function() {self.navigateToCode(jQuery(this).val());});
-
-  this.context.find('#description-table .quote-feet.setting')
-      .click(function() {self.toggleDescription(jQuery(this)); return false;});
-
-  this.sizer
-      .mousedown(function(ev) {self.startSizerDrag(ev); return false;});
-  this.overlay
-      .mouseup(function(ev) {self.endSizerDrag(ev); return false;})
-      .mousemove(function(ev) {self.handleSizerDrag(ev); return false;});
-
-  this.context.find('#prev-comment')
-      .click(function() {
-          self.changeSelectedComment(self.lastSelected.prev()); return false;
-      });
-
-  this.context.find('#next-comment')
-      .click(function() {
-          self.changeSelectedComment(self.lastSelected.next()); return false;
-      });
-
-  // Workaround for Firefox 2 and 3, which steal focus from the main document
-  // whenever the iframe content is (re)loaded.  The input field is not shown,
-  // but is a way for us to bring focus back to a place where we can detect
-  // keypresses.
-  this.context.find('#code-display')
-      .load(function(ev) {self.shortcutInput.focus();});
-
-  jQuery(document).keypress(function(ev) {
-    switch(ev.which) {
-      case 110:  // 'n'
-          self.changeSelectedComment(self.lastSelected.next());
-          return false;
-      case 112:  // 'p'
-          self.changeSelectedComment(self.lastSelected.prev());
-          return false;
-      default:  // ignore
-    }
-  });
-
-  window.onresize = function() {self.updateHeight();};
-};
-
-/**
- * Starts dragging the pane sizer.
- * @param {Object} ev The mousedown event that started us dragging.
- */
-CodewalkViewer.prototype.startSizerDrag = function(ev) {
-  this.initialCodeWidth = this.codeColumn.width();
-  this.initialCommentsWidth = this.commentColumn.width();
-  this.initialMouseX = ev.pageX;
-  this.overlay.show();
-};
-
-/**
- * Handles dragging the pane sizer.
- * @param {Object} ev The mousemove event updating dragging position.
- */
-CodewalkViewer.prototype.handleSizerDrag = function(ev) {
-  var delta = ev.pageX - this.initialMouseX;
-  if (this.codeColumn.is('.right')) delta = -delta;
-  var proposedCodeWidth = this.initialCodeWidth + delta;
-  var proposedCommentWidth = this.initialCommentsWidth - delta;
-  var mw = CodewalkViewer.MIN_PANE_WIDTH;
-  if (proposedCodeWidth < mw) delta = mw - this.initialCodeWidth;
-  if (proposedCommentWidth < mw) delta = this.initialCommentsWidth - mw;
-  proposedCodeWidth = this.initialCodeWidth + delta;
-  proposedCommentWidth = this.initialCommentsWidth - delta;
-  // If window is too small, don't even try to resize.
-  if (proposedCodeWidth < mw || proposedCommentWidth < mw) return;
-  this.codeColumn.width(proposedCodeWidth);
-  this.commentColumn.width(proposedCommentWidth);
-  this.options.codeWidth = parseInt(
-      this.codeColumn.width() /
-      (this.codeColumn.width() + this.commentColumn.width()) * 100);
-  this.context.find('#code-column-width').text(this.options.codeWidth + '%');
-};
-
-/**
- * Ends dragging the pane sizer.
- * @param {Object} ev The mouseup event that caused us to stop dragging.
- */
-CodewalkViewer.prototype.endSizerDrag = function(ev) {
-  this.overlay.hide();
-  this.updateHeight();
-};
-
-/**
- * Toggles the Codewalk description between being shown and hidden.
- * @param {jQuery} target The target that was clicked to trigger this function.
- */
-CodewalkViewer.prototype.toggleDescription = function(target) {
-  var description = this.context.find('#description');
-  description.toggle();
-  target.find('span').text(description.is(':hidden') ? 'show' : 'hide');
-  this.updateHeight();
-};
-
-/**
- * Changes the side of the window on which the code is shown and saves the
- * setting in a cookie.
- * @param {string?} codeSide The side on which the code should be, either
- *     'left' or 'right'.
- */
-CodewalkViewer.prototype.changeCodeSide = function(codeSide) {
-  var commentSide = codeSide == 'left' ? 'right' : 'left';
-  this.context.find('#set-code-' + codeSide).addClass('selected');
-  this.context.find('#set-code-' + commentSide).removeClass('selected');
-  // Remove previous side class and add new one.
-  this.codeColumn.addClass(codeSide).removeClass(commentSide);
-  this.commentColumn.addClass(commentSide).removeClass(codeSide);
-  this.sizer.css(codeSide, 'auto').css(commentSide, 0);
-  this.options.codeSide = codeSide;
-};
-
-/**
- * Adds selected class to newly selected comment, removes selected style from
- * previously selected comment, changes drop down options so that the correct
- * file is selected, and updates the code popout link.
- * @param {jQuery} target The target that was clicked to trigger this function.
- */
-CodewalkViewer.prototype.changeSelectedComment = function(target) {
-  var currentFile = target.find('.comment-link').attr('href');
-  if (!currentFile) return;
-
-  if (!(this.lastSelected && this.lastSelected.get(0) === target.get(0))) {
-    if (this.lastSelected) this.lastSelected.removeClass('selected');
-    target.addClass('selected');
-    this.lastSelected = target;
-    var targetTop = target.position().top;
-    var parentTop = target.parent().position().top;
-    if (targetTop + target.height() > parentTop + target.parent().height() ||
-        targetTop < parentTop) {
-      var delta = targetTop - parentTop;
-      target.parent().animate(
-          {'scrollTop': target.parent().scrollTop() + delta},
-          Math.max(delta / 2, 200), 'swing');
-    }
-    var fname = currentFile.match(/(?:select=|fileprint=)\/[^&]+/)[0];
-    fname = fname.slice(fname.indexOf('=')+2, fname.length);
-    this.context.find('#code-selector').val(fname);
-    this.context.find('#prev-comment').toggleClass(
-        'disabled', !target.prev().length);
-    this.context.find('#next-comment').toggleClass(
-        'disabled', !target.next().length);
-  }
-
-  // Force original file even if user hasn't changed comments since they may
-  // have navigated away from it within the iframe without us knowing.
-  this.navigateToCode(currentFile);
-};
-
-/**
- * Updates the viewer by changing the height of the comments and code so that
- * they fit within the height of the window.  The function is typically called
- * after the user changes the window size.
- */
-CodewalkViewer.prototype.updateHeight = function() {
-  var windowHeight = jQuery(window).height() - 5  // GOK
-  var areaHeight = windowHeight - this.codeArea.offset().top
-  var footerHeight = this.context.find('#footer').outerHeight(true)
-  this.commentArea.height(areaHeight - footerHeight - this.context.find('#comment-options').outerHeight(true))
-  var codeHeight = areaHeight - footerHeight - 15  // GOK
-  this.codeArea.height(codeHeight)
-  this.codeDisplay.height(codeHeight - this.codeDisplay.offset().top + this.codeArea.offset().top);
-  this.sizer.height(codeHeight);
-};
-
-window.initFuncs.push(function() {
-  var viewer = new CodewalkViewer(jQuery('#codewalk-main'));
-  viewer.selectFirstComment();
-  viewer.targetCommentLinksAtBlank();
-  viewer.installEventHandlers();
-  viewer.updateHeight();
-});

doc/codewalk/codewalk.xml

@@ -1,124 +0,0 @@
-<codewalk title="How to Write a Codewalk">
-
-<step title="Introduction" src="doc/codewalk/codewalk.xml">
-	A codewalk is a guided tour through a piece of code.
-	It consists of a sequence of steps, each typically explaining
-	a highlighted section of code.
-	<br/><br/>
-	
-	The <a href="/cmd/godoc">godoc</a> web server translates
-	an XML file like the one in the main window pane into the HTML
-	page that you're viewing now.
-	<br/><br/>
-	
-	The codewalk with URL path <code>/doc/codewalk/</code><i>name</i>
-	is loaded from the input file <code>$GOROOT/doc/codewalk/</code><i>name</i><code>.xml</code>.
-	<br/><br/>
-	
-	This codewalk explains how to write a codewalk by examining
-	its own source code,
-	<code><a href="/doc/codewalk/codewalk.xml">$GOROOT/doc/codewalk/codewalk.xml</a></code>,
-	shown in the main window pane to the left.	
-</step>
-
-<step title="Title" src="doc/codewalk/codewalk.xml:/title=/">
-	The codewalk input file is an XML file containing a single
-	<code>&lt;codewalk&gt;</code> element.
-	That element's <code>title</code> attribute gives the title
-	that is used both on the codewalk page and in the codewalk list.
-</step>
-
-<step title="Steps" src="doc/codewalk/codewalk.xml:/&lt;step/,/step&gt;/">
-	Each step in the codewalk is a <code>&lt;step&gt;</code> element 
-	nested inside the main <code>&lt;codewalk&gt;</code>.
-	The step element's <code>title</code> attribute gives the step's title,
-	which is shown in a shaded bar above the main step text.
-	The element's <code>src</code> attribute specifies the source
-	code to show in the main window pane and, optionally, a range of 
-	lines to highlight.
-	<br/><br/>
-	
-	The first step in this codewalk does not highlight any lines:
-	its <code>src</code> is just a file name.
-</step>
-
-<step title="Specifying a source line" src='doc/codewalk/codewalk.xml:/title="Title"/'>
-	The most complex part of the codewalk specification is
-	saying what lines to highlight.
-	Instead of ordinary line numbers,
-	the codewalk uses an address syntax that makes it possible
-	to describe the match by its content.
-	As the file gets edited, this descriptive address has a better
-	chance to continue to refer to the right section of the file.
-	<br/><br/>
-
-	To specify a source line, use a <code>src</code> attribute of the form
-	<i>filename</i><code>:</code><i>address</i>,
-	where <i>address</i> is an address in the syntax used by the text editors <i>sam</i> and <i>acme</i>.
-	<br/><br/>
-	
-	The simplest address is a single regular expression.
-	The highlighted line in the main window pane shows that the
-	address for the &ldquo;Title&rdquo; step was <code>/title=/</code>,
-	which matches the first instance of that <a href="/pkg/regexp">regular expression</a> (<code>title=</code>) in the file.
-</step>
-
-<step title="Specifying a source range" src='doc/codewalk/codewalk.xml:/title="Steps"/'>
-	To highlight a range of source lines, the simplest address to use is
-	a pair of regular expressions
-	<code>/</code><i>regexp1</i><code>/,/</code><i>regexp2</i><code>/</code>.
-	The highlight begins with the line containing the first match for <i>regexp1</i>
-	and ends with the line containing the first match for <i>regexp2</i>
-	after the end of the match for <i>regexp1</i>.
-	Ignoring the HTML quoting, 
-	The line containing the first match for <i>regexp1</i> will be the first one highlighted,
-	and the line containing the first match for <i>regexp2</i>.
-	<br/><br/>
-	
-	The address <code>/&lt;step/,/step&gt;/</code> looks for the first instance of
-	<code>&lt;step</code> in the file, and then starting after that point,
-	looks for the first instance of <code>step&gt;</code>.
-	(Click on the &ldquo;Steps&rdquo; step above to see the highlight in action.)
-	Note that the <code>&lt;</code> and <code>&gt;</code> had to be written
-	using XML escapes in order to be valid XML.
-</step>
-
-<step title="Advanced addressing" src="doc/codewalk/codewalk.xml:/Advanced/,/step&gt;/">
-	The <code>/</code><i>regexp</i><code>/</code>
- 	and <code>/</code><i>regexp1</i><code>/,/</code><i>regexp2</i><code>/</code>
- 	forms suffice for most highlighting.
- 	<br/><br/>
-
-	The full address syntax is summarized in this table
-	(an excerpt of Table II from
-	<a href="https://9p.io/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
-	<br/><br/>
-
-	<table>
-	<tr><td colspan="2"><b>Simple addresses</b></td></tr>
-	<tr><td><code>#</code><i>n</i></td>
-	    <td>The empty string after character <i>n</i></td></tr>
-	<tr><td><i>n</i></td>
-	    <td>Line <i>n</i></td></tr>
-	<tr><td><code>/</code><i>regexp</i><code>/</code></td>
-	    <td>The first following match of the regular expression</td></tr>
-	<!-- not supported (yet?)
-	<tr><td><code>–/</code><i>regexp</i><code>/</code></td>
-	    <td>The first previous match of the regular expression</td></tr>
-	-->
-	<tr><td><code>$</code></td>
-	    <td>The null string at the end of the file</td></tr>
-
-	<tr><td colspan="2"><b>Compound addresses</b></td></tr>
-	<tr><td><i>a1</i><code>+</code><i>a2</i></td>
-	    <td>The address <i>a2</i> evaluated starting at the right of <i>a1</i></td></tr>
-	<tr><td><i>a1</i><code>-</code><i>a2</i></td>
-	    <td>The address <i>a2</i> evaluated in the reverse direction starting at the left of <i>a1</i></td></tr>
-	<tr><td><i>a1</i><code>,</code><i>a2</i></td>
-	    <td>From the left of <i>a1</i> to the right of <i>a2</i> (default <code>0,$</code>).</td></tr>
-	</table>
-</step>
-
-
-	
-</codewalk>

doc/codewalk/codewalk_test.go

@@ -1,52 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main_test
-
-import (
-	"bytes"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-)
-
-// TestMarkov tests the code dependency of markov.xml.
-func TestMarkov(t *testing.T) {
-	cmd := exec.Command("go", "run", "markov.go")
-	cmd.Stdin = strings.NewReader("foo")
-	cmd.Stderr = bytes.NewBuffer(nil)
-	out, err := cmd.Output()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-	}
-
-	if !bytes.Equal(out, []byte("foo\n")) {
-		t.Fatalf(`%s with input "foo" did not output "foo":\n%s`, strings.Join(cmd.Args, " "), out)
-	}
-}
-
-// TestPig tests the code dependency of functions.xml.
-func TestPig(t *testing.T) {
-	cmd := exec.Command("go", "run", "pig.go")
-	cmd.Stderr = bytes.NewBuffer(nil)
-	out, err := cmd.Output()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
-	}
-
-	const want = "Wins, losses staying at k = 100: 210/990 (21.2%), 780/990 (78.8%)\n"
-	if !bytes.Contains(out, []byte(want)) {
-		t.Fatalf(`%s: unexpected output\ngot:\n%s\nwant output containing:\n%s`, strings.Join(cmd.Args, " "), out, want)
-	}
-}
-
-// TestURLPoll tests the code dependency of sharemem.xml.
-func TestURLPoll(t *testing.T) {
-	cmd := exec.Command("go", "build", "-o", os.DevNull, "urlpoll.go")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
-	}
-}

doc/codewalk/functions.xml

@@ -1,105 +0,0 @@
-<codewalk title="First-Class Functions in Go">
-
-<step title="Introduction" src="doc/codewalk/pig.go">
-	Go supports first class functions, higher-order functions, user-defined
-	function types, function literals, closures, and multiple return values.
-  <br/><br/>
-
-	This rich feature set supports a functional programming style in a strongly
-	typed language.
-	<br/><br/>
-
-	In this codewalk we will look at a simple program that simulates a dice game
-	called <a href="http://en.wikipedia.org/wiki/Pig_(dice)">Pig</a> and evaluates
-	basic strategies.
-</step>
-
-<step title="Game overview" src="doc/codewalk/pig.go:/\/\/ A score/,/thisTurn int\n}/">
-  Pig is a two-player game played with a 6-sided die.  Each turn, you may roll or stay.
-	<ul>
-		<li> If you roll a 1, you lose all points for your turn and play passes to
-			your opponent.  Any other roll adds its value to your turn score.  </li>
-		<li> If you stay, your turn score is added to your total score, and play passes
-			to your opponent.  </li>
-	</ul>
-	
-	The first person to reach 100 total points wins.
-	<br/><br/>
-
-	The <code>score</code> type stores the scores of the current and opposing
-	players, in addition to the points accumulated during the current turn.
-</step>
-
-<step title="User-defined function types" src="doc/codewalk/pig.go:/\/\/ An action/,/bool\)/">
-	In Go, functions can be passed around just like any other value. A function's
-	type signature describes the types of its arguments and return values.
-	<br/><br/>
-
-	The <code>action</code> type is a function that takes a <code>score</code>
-	and returns the resulting <code>score</code> and whether the current turn is
-	over.
-	<br/><br/>
-
-  If the turn is over, the <code>player</code> and <code>opponent</code> fields
-  in the resulting <code>score</code> should be swapped, as it is now the other player's
-  turn.
-</step>
-
-<step title="Multiple return values" src="doc/codewalk/pig.go:/\/\/ roll returns/,/true\n}/">
-	Go functions can return multiple values.  
-	<br/><br/>
-
-	The functions <code>roll</code> and <code>stay</code> each return a pair of
-	values.  They also match the <code>action</code> type signature.  These
-	<code>action</code> functions define the rules of Pig.
-</step>
-
-<step title="Higher-order functions" src="doc/codewalk/pig.go:/\/\/ A strategy/,/action\n/">
-	A function can use other functions as arguments and return values.
-	<br/><br/>
-
-  A <code>strategy</code> is a function that takes a <code>score</code> as input
-  and returns an <code>action</code> to perform.  <br/>
-  (Remember, an <code>action</code> is itself a function.)
-</step>
-
-<step title="Function literals and closures" src="doc/codewalk/pig.go:/return func/,/return roll\n\t}/">
-	Anonymous functions can be declared in Go, as in this example.  Function
-	literals are closures: they inherit the scope of the function in which they
-	are declared.
-	<br/><br/>
-
-	One basic strategy in Pig is to continue rolling until you have accumulated at
-	least k points in a turn, and then stay.  The argument <code>k</code> is
-	enclosed by this function literal, which matches the <code>strategy</code> type
-	signature.
-</step>
-
-<step title="Simulating games" src="doc/codewalk/pig.go:/\/\/ play/,/currentPlayer\n}/">
-  We simulate a game of Pig by calling an <code>action</code> to update the
-  <code>score</code> until one player reaches 100 points.  Each
-  <code>action</code> is selected by calling the <code>strategy</code> function
-  associated with the current player.
-</step>
-
-<step title="Simulating a tournament" src="doc/codewalk/pig.go:/\/\/ roundRobin/,/gamesPerStrategy\n}/">
-	The <code>roundRobin</code> function simulates a tournament and tallies wins.
-	Each strategy plays each other strategy <code>gamesPerSeries</code> times.
-</step>
-	
-<step title="Variadic function declarations" src="doc/codewalk/pig.go:/\/\/ ratioS/,/string {/">
-	Variadic functions like <code>ratioString</code> take a variable number of
-	arguments.  These arguments are available as a slice inside the function.
-</step>
-
-<step title="Simulation results" src="doc/codewalk/pig.go:/func main/,/\n}/">
-	The <code>main</code> function defines 100 basic strategies, simulates a round
-	robin tournament, and then prints the win/loss record of each strategy.
-	<br/><br/>
-
-	Among these strategies, staying at 25 is best, but the <a
-	href="http://www.google.com/search?q=optimal+play+pig">optimal strategy for
-	Pig</a> is much more complex.
-</step>
-
-</codewalk>

doc/codewalk/markov.go

@@ -1,130 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Generating random text: a Markov chain algorithm
-
-Based on the program presented in the "Design and Implementation" chapter
-of The Practice of Programming (Kernighan and Pike, Addison-Wesley 1999).
-See also Computer Recreations, Scientific American 260, 122 - 125 (1989).
-
-A Markov chain algorithm generates text by creating a statistical model of
-potential textual suffixes for a given prefix. Consider this text:
-
-	I am not a number! I am a free man!
-
-Our Markov chain algorithm would arrange this text into this set of prefixes
-and suffixes, or "chain": (This table assumes a prefix length of two words.)
-
-	Prefix       Suffix
-
-	"" ""        I
-	"" I         am
-	I am         a
-	I am         not
-	a free       man!
-	am a         free
-	am not       a
-	a number!    I
-	number! I    am
-	not a        number!
-
-To generate text using this table we select an initial prefix ("I am", for
-example), choose one of the suffixes associated with that prefix at random
-with probability determined by the input statistics ("a"),
-and then create a new prefix by removing the first word from the prefix
-and appending the suffix (making the new prefix is "am a"). Repeat this process
-until we can't find any suffixes for the current prefix or we exceed the word
-limit. (The word limit is necessary as the chain table may contain cycles.)
-
-Our version of this program reads text from standard input, parsing it into a
-Markov chain, and writes generated text to standard output.
-The prefix and output lengths can be specified using the -prefix and -words
-flags on the command-line.
-*/
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io"
-	"math/rand"
-	"os"
-	"strings"
-	"time"
-)
-
-// Prefix is a Markov chain prefix of one or more words.
-type Prefix []string
-
-// String returns the Prefix as a string (for use as a map key).
-func (p Prefix) String() string {
-	return strings.Join(p, " ")
-}
-
-// Shift removes the first word from the Prefix and appends the given word.
-func (p Prefix) Shift(word string) {
-	copy(p, p[1:])
-	p[len(p)-1] = word
-}
-
-// Chain contains a map ("chain") of prefixes to a list of suffixes.
-// A prefix is a string of prefixLen words joined with spaces.
-// A suffix is a single word. A prefix can have multiple suffixes.
-type Chain struct {
-	chain     map[string][]string
-	prefixLen int
-}
-
-// NewChain returns a new Chain with prefixes of prefixLen words.
-func NewChain(prefixLen int) *Chain {
-	return &Chain{make(map[string][]string), prefixLen}
-}
-
-// Build reads text from the provided Reader and
-// parses it into prefixes and suffixes that are stored in Chain.
-func (c *Chain) Build(r io.Reader) {
-	br := bufio.NewReader(r)
-	p := make(Prefix, c.prefixLen)
-	for {
-		var s string
-		if _, err := fmt.Fscan(br, &s); err != nil {
-			break
-		}
-		key := p.String()
-		c.chain[key] = append(c.chain[key], s)
-		p.Shift(s)
-	}
-}
-
-// Generate returns a string of at most n words generated from Chain.
-func (c *Chain) Generate(n int) string {
-	p := make(Prefix, c.prefixLen)
-	var words []string
-	for i := 0; i < n; i++ {
-		choices := c.chain[p.String()]
-		if len(choices) == 0 {
-			break
-		}
-		next := choices[rand.Intn(len(choices))]
-		words = append(words, next)
-		p.Shift(next)
-	}
-	return strings.Join(words, " ")
-}
-
-func main() {
-	// Register command-line flags.
-	numWords := flag.Int("words", 100, "maximum number of words to print")
-	prefixLen := flag.Int("prefix", 2, "prefix length in words")
-
-	flag.Parse()                     // Parse command-line flags.
-	rand.Seed(time.Now().UnixNano()) // Seed the random number generator.
-
-	c := NewChain(*prefixLen)     // Initialize a new Chain.
-	c.Build(os.Stdin)             // Build chains from standard input.
-	text := c.Generate(*numWords) // Generate text.
-	fmt.Println(text)             // Write text to standard output.
-}

doc/codewalk/markov.xml

@@ -1,307 +0,0 @@
-<!--
-Copyright 2011 The Go Authors. All rights reserved.
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file.
--->
-
-<codewalk title="Generating arbitrary text: a Markov chain algorithm">
-
-<step title="Introduction" src="doc/codewalk/markov.go:/Generating/,/line\./">
-	This codewalk describes a program that generates random text using
-	a Markov chain algorithm. The package comment describes the algorithm
-	and the operation of the program. Please read it before continuing.
-</step>
-
-<step title="Modeling Markov chains" src="doc/codewalk/markov.go:/	chain/">
-	A chain consists of a prefix and a suffix. Each prefix is a set
-	number of words, while a suffix is a single word.
-	A prefix can have an arbitrary number of suffixes.
-	To model this data, we use a <code>map[string][]string</code>.
-	Each map key is a prefix (a <code>string</code>) and its values are
-	lists of suffixes (a slice of strings, <code>[]string</code>).
-	<br/><br/>
-	Here is the example table from the package comment
-	as modeled by this data structure:
-	<pre>
-map[string][]string{
-	" ":          {"I"},
-	" I":         {"am"},
-	"I am":       {"a", "not"},
-	"a free":     {"man!"},
-	"am a":       {"free"},
-	"am not":     {"a"},
-	"a number!":  {"I"},
-	"number! I":  {"am"},
-	"not a":      {"number!"},
-}</pre>
-	While each prefix consists of multiple words, we
-	store prefixes in the map as a single <code>string</code>.
-	It would seem more natural to store the prefix as a
-	<code>[]string</code>, but we can't do this with a map because the
-	key type of a map must implement equality (and slices do not).
-	<br/><br/>
-	Therefore, in most of our code we will model prefixes as a
-	<code>[]string</code> and join the strings together with a space
-	to generate the map key:
-	<pre>
-Prefix               Map key
-
-[]string{"", ""}     " "
-[]string{"", "I"}    " I"
-[]string{"I", "am"}  "I am"
-</pre>
-</step>
-
-<step title="The Chain struct" src="doc/codewalk/markov.go:/type Chain/,/}/">
-	The complete state of the chain table consists of the table itself and
-	the word length of the prefixes. The <code>Chain</code> struct stores
-	this data.
-</step>
-
-<step title="The NewChain constructor function" src="doc/codewalk/markov.go:/func New/,/\n}/">
-	The <code>Chain</code> struct has two unexported fields (those that
-	do not begin with an upper case character), and so we write a
-	<code>NewChain</code> constructor function that initializes the
-	<code>chain</code> map with <code>make</code> and sets the
-	<code>prefixLen</code> field.
-	<br/><br/>
-	This is constructor function is not strictly necessary as this entire
-	program is within a single package (<code>main</code>) and therefore
-	there is little practical difference between exported and unexported
-	fields. We could just as easily write out the contents of this function
-	when we want to construct a new Chain.
-	But using these unexported fields is good practice; it clearly denotes
-	that only methods of Chain and its constructor function should access
-	those fields. Also, structuring <code>Chain</code> like this means we
-	could easily move it into its own package at some later date.
-</step>
-
-<step title="The Prefix type" src="doc/codewalk/markov.go:/type Prefix/">
-	Since we'll be working with prefixes often, we define a
-	<code>Prefix</code> type with the concrete type <code>[]string</code>.
-	Defining a named type clearly allows us to be explicit when we are
-	working with a prefix instead of just a <code>[]string</code>.
-	Also, in Go we can define methods on any named type (not just structs),
-	so we can add methods that operate on <code>Prefix</code> if we need to.
-</step>
-
-<step title="The String method" src="doc/codewalk/markov.go:/func[^\n]+String/,/}/">
-	The first method we define on <code>Prefix</code> is
-	<code>String</code>. It returns a <code>string</code> representation
-	of a <code>Prefix</code> by joining the slice elements together with
-	spaces. We will use this method to generate keys when working with
-	the chain map.
-</step>
-
-<step title="Building the chain" src="doc/codewalk/markov.go:/func[^\n]+Build/,/\n}/">
-	The <code>Build</code> method reads text from an <code>io.Reader</code>
-	and parses it into prefixes and suffixes that are stored in the
-	<code>Chain</code>.
-	<br/><br/>
-	The <code><a href="/pkg/io/#Reader">io.Reader</a></code> is an
-	interface type that is widely used by the standard library and
-	other Go code. Our code uses the
-	<code><a href="/pkg/fmt/#Fscan">fmt.Fscan</a></code> function, which
-	reads space-separated values from an <code>io.Reader</code>.
-	<br/><br/>
-	The <code>Build</code> method returns once the <code>Reader</code>'s
-	<code>Read</code> method returns <code>io.EOF</code> (end of file)
-	or some other read error occurs.
-</step>
-
-<step title="Buffering the input" src="doc/codewalk/markov.go:/bufio\.NewReader/">
-	This function does many small reads, which can be inefficient for some
-	<code>Readers</code>. For efficiency we wrap the provided
-	<code>io.Reader</code> with
-	<code><a href="/pkg/bufio/">bufio.NewReader</a></code> to create a
-	new <code>io.Reader</code> that provides buffering.
-</step>
-
-<step title="The Prefix variable" src="doc/codewalk/markov.go:/make\(Prefix/">
-	At the top of the function we make a <code>Prefix</code> slice
-	<code>p</code> using the <code>Chain</code>'s <code>prefixLen</code>
-	field as its length.
-	We'll use this variable to hold the current prefix and mutate it with
-	each new word we encounter.
-</step>
-
-<step title="Scanning words" src="doc/codewalk/markov.go:/var s string/,/\n		}/">
-	In our loop we read words from the <code>Reader</code> into a
-	<code>string</code> variable <code>s</code> using
-	<code>fmt.Fscan</code>. Since <code>Fscan</code> uses space to
-	separate each input value, each call will yield just one word
-	(including punctuation), which is exactly what we need.
-	<br/><br/>
-	<code>Fscan</code> returns an error if it encounters a read error
-	(<code>io.EOF</code>, for example) or if it can't scan the requested
-	value (in our case, a single string). In either case we just want to
-	stop scanning, so we <code>break</code> out of the loop.
-</step>
-
-<step title="Adding a prefix and suffix to the chain" src="doc/codewalk/markov.go:/	key/,/key\], s\)">
-	The word stored in <code>s</code> is a new suffix. We add the new
-	prefix/suffix combination to the <code>chain</code> map by computing
-	the map key with <code>p.String</code> and appending the suffix
-	to the slice stored under that key.
-	<br/><br/>
-	The built-in <code>append</code> function appends elements to a slice
-	and allocates new storage when necessary. When the provided slice is
-	<code>nil</code>, <code>append</code> allocates a new slice.
-	This behavior conveniently ties in with the semantics of our map:
-	retrieving an unset key returns the zero value of the value type and
-	the zero value of <code>[]string</code> is <code>nil</code>.
-	When our program encounters a new prefix (yielding a <code>nil</code>
-	value in the map) <code>append</code> will allocate a new slice.
-	<br/><br/>
-	For more information about the <code>append</code> function and slices
-	in general see the
-	<a href="/doc/articles/slices_usage_and_internals.html">Slices: usage and internals</a> article.
-</step>
-
-<step title="Pushing the suffix onto the prefix" src="doc/codewalk/markov.go:/p\.Shift/">
-	Before reading the next word our algorithm requires us to drop the
-	first word from the prefix and push the current suffix onto the prefix.
-	<br/><br/>
-	When in this state
-	<pre>
-p == Prefix{"I", "am"}
-s == "not" </pre>
-	the new value for <code>p</code> would be
-	<pre>
-p == Prefix{"am", "not"}</pre>
-	This operation is also required during text generation so we put
-	the code to perform this mutation of the slice inside a method on
-	<code>Prefix</code> named <code>Shift</code>.
-</step>
-
-<step title="The Shift method" src="doc/codewalk/markov.go:/func[^\n]+Shift/,/\n}/">
-	The <code>Shift</code> method uses the built-in <code>copy</code>
-	function to copy the last len(p)-1 elements of <code>p</code> to
-	the start of the slice, effectively moving the elements
-	one index to the left (if you consider zero as the leftmost index).
-	<pre>
-p := Prefix{"I", "am"}
-copy(p, p[1:])
-// p == Prefix{"am", "am"}</pre>
-	We then assign the provided <code>word</code> to the last index
-	of the slice:
-	<pre>
-// suffix == "not"
-p[len(p)-1] = suffix
-// p == Prefix{"am", "not"}</pre>
-</step>
-
-<step title="Generating text" src="doc/codewalk/markov.go:/func[^\n]+Generate/,/\n}/">
-	The <code>Generate</code> method is similar to <code>Build</code>
-	except that instead of reading words from a <code>Reader</code>
-	and storing them in a map, it reads words from the map and
-	appends them to a slice (<code>words</code>).
-	<br/><br/>
-	<code>Generate</code> uses a conditional for loop to generate
-	up to <code>n</code> words.
-</step>
-
-<step title="Getting potential suffixes" src="doc/codewalk/markov.go:/choices/,/}\n/">
-	At each iteration of the loop we retrieve a list of potential suffixes
-	for the current prefix. We access the <code>chain</code> map at key
-	<code>p.String()</code> and assign its contents to <code>choices</code>.
-	<br/><br/>
-	If <code>len(choices)</code> is zero we break out of the loop as there
-	are no potential suffixes for that prefix.
-	This test also works if the key isn't present in the map at all:
-	in that case, <code>choices</code> will be <code>nil</code> and the
-	length of a <code>nil</code> slice is zero.
-</step>
-
-<step title="Choosing a suffix at random" src="doc/codewalk/markov.go:/next := choices/,/Shift/">
-	To choose a suffix we use the
-	<code><a href="/pkg/math/rand/#Intn">rand.Intn</a></code> function.
-	It returns a random integer up to (but not including) the provided
-	value. Passing in <code>len(choices)</code> gives us a random index
-	into the full length of the list.
-	<br/><br/>
-	We use that index to pick our new suffix, assign it to
-	<code>next</code> and append it to the <code>words</code> slice.
-	<br/><br/>
-	Next, we <code>Shift</code> the new suffix onto the prefix just as
-	we did in the <code>Build</code> method.
-</step>
-
-<step title="Returning the generated text" src="doc/codewalk/markov.go:/Join\(words/">
-	Before returning the generated text as a string, we use the
-	<code>strings.Join</code> function to join the elements of
-	the <code>words</code> slice together, separated by spaces.
-</step>
-
-<step title="Command-line flags" src="doc/codewalk/markov.go:/Register command-line flags/,/prefixLen/">
-	To make it easy to tweak the prefix and generated text lengths we
-	use the <code><a href="/pkg/flag/">flag</a></code> package to parse
-	command-line flags.
-	<br/><br/>
-	These calls to <code>flag.Int</code> register new flags with the
-	<code>flag</code> package. The arguments to <code>Int</code> are the
-	flag name, its default value, and a description. The <code>Int</code>
-	function returns a pointer to an integer that will contain the
-	user-supplied value (or the default value if the flag was omitted on
-	the command-line).
-</step>
-
-<step title="Program set up" src="doc/codewalk/markov.go:/flag.Parse/,/rand.Seed/">
-	The <code>main</code> function begins by parsing the command-line
-	flags with <code>flag.Parse</code> and seeding the <code>rand</code>
-	package's random number generator with the current time.
-	<br/><br/>
-	If the command-line flags provided by the user are invalid the
-	<code>flag.Parse</code> function will print an informative usage
-	message and terminate the program.
-</step>
-
-<step title="Creating and building a new Chain" src="doc/codewalk/markov.go:/c := NewChain/,/c\.Build/">
-	To create the new <code>Chain</code> we call <code>NewChain</code>
-	with the value of the <code>prefix</code> flag.
-	<br/><br/>
-	To build the chain we call <code>Build</code> with
-	<code>os.Stdin</code> (which implements <code>io.Reader</code>) so
-	that it will read its input from standard input.
-</step>
-
-<step title="Generating and printing text" src="doc/codewalk/markov.go:/c\.Generate/,/fmt.Println/">
-	Finally, to generate text we call <code>Generate</code> with
-	the value of the <code>words</code> flag and assigning the result
-	to the variable <code>text</code>.
-	<br/><br/>
-	Then we call <code>fmt.Println</code> to write the text to standard
-	output, followed by a carriage return.
-</step>
-
-<step title="Using this program" src="doc/codewalk/markov.go">
-	To use this program, first build it with the
-	<a href="/cmd/go/">go</a> command:
-	<pre>
-$ go build markov.go</pre>
-	And then execute it while piping in some input text:
-	<pre>
-$ echo "a man a plan a canal panama" \
-	| ./markov -prefix=1
-a plan a man a plan a canal panama</pre>
-	Here's a transcript of generating some text using the Go distribution's
-	README file as source material:
-	<pre>
-$ ./markov -words=10 &lt; $GOROOT/README
-This is the source code repository for the Go source
-$ ./markov -prefix=1 -words=10 &lt; $GOROOT/README
-This is the go directory (the one containing this README).
-$ ./markov -prefix=1 -words=10 &lt; $GOROOT/README
-This is the variable if you have just untarred a</pre>
-</step>
-
-<step title="An exercise for the reader" src="doc/codewalk/markov.go">
-	The <code>Generate</code> function does a lot of allocations when it
-	builds the <code>words</code> slice. As an exercise, modify it to
-	take an <code>io.Writer</code> to which it incrementally writes the
-	generated text with <code>Fprint</code>.
-	Aside from being more efficient this makes <code>Generate</code>
-	more symmetrical to <code>Build</code>.
-</step>
-
-</codewalk>

doc/codewalk/pig.go

@@ -1,121 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-	"math/rand"
-)
-
-const (
-	win            = 100 // The winning score in a game of Pig
-	gamesPerSeries = 10  // The number of games per series to simulate
-)
-
-// A score includes scores accumulated in previous turns for each player,
-// as well as the points scored by the current player in this turn.
-type score struct {
-	player, opponent, thisTurn int
-}
-
-// An action transitions stochastically to a resulting score.
-type action func(current score) (result score, turnIsOver bool)
-
-// roll returns the (result, turnIsOver) outcome of simulating a die roll.
-// If the roll value is 1, then thisTurn score is abandoned, and the players'
-// roles swap.  Otherwise, the roll value is added to thisTurn.
-func roll(s score) (score, bool) {
-	outcome := rand.Intn(6) + 1 // A random int in [1, 6]
-	if outcome == 1 {
-		return score{s.opponent, s.player, 0}, true
-	}
-	return score{s.player, s.opponent, outcome + s.thisTurn}, false
-}
-
-// stay returns the (result, turnIsOver) outcome of staying.
-// thisTurn score is added to the player's score, and the players' roles swap.
-func stay(s score) (score, bool) {
-	return score{s.opponent, s.player + s.thisTurn, 0}, true
-}
-
-// A strategy chooses an action for any given score.
-type strategy func(score) action
-
-// stayAtK returns a strategy that rolls until thisTurn is at least k, then stays.
-func stayAtK(k int) strategy {
-	return func(s score) action {
-		if s.thisTurn >= k {
-			return stay
-		}
-		return roll
-	}
-}
-
-// play simulates a Pig game and returns the winner (0 or 1).
-func play(strategy0, strategy1 strategy) int {
-	strategies := []strategy{strategy0, strategy1}
-	var s score
-	var turnIsOver bool
-	currentPlayer := rand.Intn(2) // Randomly decide who plays first
-	for s.player+s.thisTurn < win {
-		action := strategies[currentPlayer](s)
-		s, turnIsOver = action(s)
-		if turnIsOver {
-			currentPlayer = (currentPlayer + 1) % 2
-		}
-	}
-	return currentPlayer
-}
-
-// roundRobin simulates a series of games between every pair of strategies.
-func roundRobin(strategies []strategy) ([]int, int) {
-	wins := make([]int, len(strategies))
-	for i := 0; i < len(strategies); i++ {
-		for j := i + 1; j < len(strategies); j++ {
-			for k := 0; k < gamesPerSeries; k++ {
-				winner := play(strategies[i], strategies[j])
-				if winner == 0 {
-					wins[i]++
-				} else {
-					wins[j]++
-				}
-			}
-		}
-	}
-	gamesPerStrategy := gamesPerSeries * (len(strategies) - 1) // no self play
-	return wins, gamesPerStrategy
-}
-
-// ratioString takes a list of integer values and returns a string that lists
-// each value and its percentage of the sum of all values.
-// e.g., ratios(1, 2, 3) = "1/6 (16.7%), 2/6 (33.3%), 3/6 (50.0%)"
-func ratioString(vals ...int) string {
-	total := 0
-	for _, val := range vals {
-		total += val
-	}
-	s := ""
-	for _, val := range vals {
-		if s != "" {
-			s += ", "
-		}
-		pct := 100 * float64(val) / float64(total)
-		s += fmt.Sprintf("%d/%d (%0.1f%%)", val, total, pct)
-	}
-	return s
-}
-
-func main() {
-	strategies := make([]strategy, win)
-	for k := range strategies {
-		strategies[k] = stayAtK(k + 1)
-	}
-	wins, games := roundRobin(strategies)
-
-	for k := range strategies {
-		fmt.Printf("Wins, losses staying at k =% 4d: %s\n",
-			k+1, ratioString(wins[k], games-wins[k]))
-	}
-}

doc/codewalk/sharemem.xml

@@ -1,181 +0,0 @@
-<codewalk title="Share Memory By Communicating">
-
-<step title="Introduction" src="doc/codewalk/urlpoll.go">
-Go's approach to concurrency differs from the traditional use of
-threads and shared memory. Philosophically, it can be summarized:
-<br/><br/>
-<i>Don't communicate by sharing memory; share memory by communicating.</i>
-<br/><br/>
-Channels allow you to pass references to data structures between goroutines.
-If you consider this as passing around ownership of the data (the ability to
-read and write it), they become a powerful and expressive synchronization 
-mechanism.
-<br/><br/>
-In this codewalk we will look at a simple program that polls a list of
-URLs, checking their HTTP response codes and periodically printing their state.
-</step>
-
-<step title="State type" src="doc/codewalk/urlpoll.go:/State/,/}/">
-The State type represents the state of a URL.
-<br/><br/>
-The Pollers send State values to the StateMonitor,
-which maintains a map of the current state of each URL.
-</step>
-
-<step title="Resource type" src="doc/codewalk/urlpoll.go:/Resource/,/}/">
-A Resource represents the state of a URL to be polled: the URL itself
-and the number of errors encountered since the last successful poll.
-<br/><br/>
-When the program starts, it allocates one Resource for each URL.
-The main goroutine and the Poller goroutines send the Resources to
-each other on channels.
-</step>
-
-<step title="Poller function" src="doc/codewalk/urlpoll.go:/func Poller/,/\n}/">
-Each Poller receives Resource pointers from an input channel.
-In this program, the convention is that sending a Resource pointer on
-a channel passes ownership of the underlying data from the sender
-to the receiver.  Because of this convention, we know that
-no two goroutines will access this Resource at the same time.
-This means we don't have to worry about locking to prevent concurrent 
-access to these data structures.
-<br/><br/>
-The Poller processes the Resource by calling its Poll method.
-<br/><br/>
-It sends a State value to the status channel, to inform the StateMonitor
-of the result of the Poll.
-<br/><br/>
-Finally, it sends the Resource pointer to the out channel. This can be
-interpreted as the Poller saying &quot;I'm done with this Resource&quot; and 
-returning ownership of it to the main goroutine. 
-<br/><br/>
-Several goroutines run Pollers, processing Resources in parallel.
-</step>
-
-<step title="The Poll method" src="doc/codewalk/urlpoll.go:/Poll executes/,/\n}/">
-The Poll method (of the Resource type) performs an HTTP HEAD request
-for the Resource's URL and returns the HTTP response's status code.
-If an error occurs, Poll logs the message to standard error and returns the 
-error string instead.
-</step>
-
-<step title="main function" src="doc/codewalk/urlpoll.go:/func main/,/\n}/">
-The main function starts the Poller and StateMonitor goroutines
-and then loops passing completed Resources back to the pending
-channel after appropriate delays.
-</step>
-
-<step title="Creating channels" src="doc/codewalk/urlpoll.go:/Create our/,/complete/">
-First, main makes two channels of *Resource, pending and complete.
-<br/><br/>
-Inside main, a new goroutine sends one Resource per URL to pending
-and the main goroutine receives completed Resources from complete.
-<br/><br/>
-The pending and complete channels are passed to each of the Poller
-goroutines, within which they are known as in and out. 
-</step>
-
-<step title="Initializing StateMonitor" src="doc/codewalk/urlpoll.go:/Launch the StateMonitor/,/statusInterval/">
-StateMonitor will initialize and launch a goroutine that stores the state 
-of each Resource. We will look at this function in detail later. 
-<br/><br/>
-For now, the important thing to note is that it returns a channel of State, 
-which is saved as status and passed to the Poller goroutines.
-</step>
-
-<step title="Launching Poller goroutines" src="doc/codewalk/urlpoll.go:/Launch some Poller/,/}/">
-Now that it has the necessary channels, main launches a number of
-Poller goroutines, passing the channels as arguments.
-The channels provide the means of communication between the main, Poller, and 
-StateMonitor goroutines.
-</step>
-
-<step title="Send Resources to pending" src="doc/codewalk/urlpoll.go:/Send some Resources/,/}\(\)/">
-To add the initial work to the system, main starts a new goroutine
-that allocates and sends one Resource per URL to pending.
-<br/><br/>
-The new goroutine is necessary because unbuffered channel sends and
-receives are synchronous. That means these channel sends will block until
-the Pollers are ready to read from pending.
-<br/><br/>
-Were these sends performed in the main goroutine with fewer Pollers than 
-channel sends, the program would reach a deadlock situation, because
-main would not yet be receiving from complete.
-<br/><br/>
-Exercise for the reader: modify this part of the program to read a list of
-URLs from a file. (You may want to move this goroutine into its own
-named function.)
-</step>
-
-<step title="Main Event Loop" src="doc/codewalk/urlpoll.go:/range complete/,/\n	}/">
-When a Poller is done with a Resource, it sends it on the complete channel.
-This loop receives those Resource pointers from complete.
-For each received Resource, it starts a new goroutine calling
-the Resource's Sleep method.  Using a new goroutine for each
-ensures that the sleeps can happen in parallel.
-<br/><br/>
-Note that any single Resource pointer may only be sent on either pending or
-complete at any one time. This ensures that a Resource is either being
-handled by a Poller goroutine or sleeping, but never both simultaneously.  
-In this way, we share our Resource data by communicating.
-</step>
-
-<step title="The Sleep method" src="doc/codewalk/urlpoll.go:/Sleep/,/\n}/">
-Sleep calls time.Sleep to pause before sending the Resource to done.
-The pause will either be of a fixed length (pollInterval) plus an
-additional delay proportional to the number of sequential errors (r.errCount).
-<br/><br/>
-This is an example of a typical Go idiom: a function intended to run inside 
-a goroutine takes a channel, upon which it sends its return value 
-(or other indication of completed state).
-</step>
-
-<step title="StateMonitor" src="doc/codewalk/urlpoll.go:/StateMonitor/,/\n}/">
-The StateMonitor receives State values on a channel and periodically
-outputs the state of all Resources being polled by the program.
-</step>
-
-<step title="The updates channel" src="doc/codewalk/urlpoll.go:/updates :=/">
-The variable updates is a channel of State, on which the Poller goroutines
-send State values.
-<br/><br/>
-This channel is returned by the function.
-</step>
-
-<step title="The urlStatus map" src="doc/codewalk/urlpoll.go:/urlStatus/">
-The variable urlStatus is a map of URLs to their most recent status. 
-</step>
-
-<step title="The Ticker object" src="doc/codewalk/urlpoll.go:/ticker/">
-A time.Ticker is an object that repeatedly sends a value on a channel at a 
-specified interval. 
-<br/><br/>
-In this case, ticker triggers the printing of the current state to 
-standard output every updateInterval nanoseconds.
-</step>
-
-<step title="The StateMonitor goroutine" src="doc/codewalk/urlpoll.go:/go func/,/}\(\)/">
-StateMonitor will loop forever, selecting on two channels: 
-ticker.C and update. The select statement blocks until one of its 
-communications is ready to proceed.
-<br/><br/>
-When StateMonitor receives a tick from ticker.C, it calls logState to
-print the current state.  When it receives a State update from updates,
-it records the new status in the urlStatus map.
-<br/><br/>
-Notice that this goroutine owns the urlStatus data structure,
-ensuring that it can only be accessed sequentially. 
-This prevents memory corruption issues that might arise from parallel reads 
-and/or writes to a shared map.
-</step>
-
-<step title="Conclusion" src="doc/codewalk/urlpoll.go">
-In this codewalk we have explored a simple example of using Go's concurrency
-primitives to share memory through communication.
-<br/><br/>
-This should provide a starting point from which to explore the ways in which
-goroutines and channels can be used to write expressive and concise concurrent
-programs.
-</step>
-	
-</codewalk>

doc/codewalk/urlpoll.go

@@ -1,116 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"log"
-	"net/http"
-	"time"
-)
-
-const (
-	numPollers     = 2                // number of Poller goroutines to launch
-	pollInterval   = 60 * time.Second // how often to poll each URL
-	statusInterval = 10 * time.Second // how often to log status to stdout
-	errTimeout     = 10 * time.Second // back-off timeout on error
-)
-
-var urls = []string{
-	"http://www.google.com/",
-	"http://golang.org/",
-	"http://blog.golang.org/",
-}
-
-// State represents the last-known state of a URL.
-type State struct {
-	url    string
-	status string
-}
-
-// StateMonitor maintains a map that stores the state of the URLs being
-// polled, and prints the current state every updateInterval nanoseconds.
-// It returns a chan State to which resource state should be sent.
-func StateMonitor(updateInterval time.Duration) chan<- State {
-	updates := make(chan State)
-	urlStatus := make(map[string]string)
-	ticker := time.NewTicker(updateInterval)
-	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				logState(urlStatus)
-			case s := <-updates:
-				urlStatus[s.url] = s.status
-			}
-		}
-	}()
-	return updates
-}
-
-// logState prints a state map.
-func logState(s map[string]string) {
-	log.Println("Current state:")
-	for k, v := range s {
-		log.Printf(" %s %s", k, v)
-	}
-}
-
-// Resource represents an HTTP URL to be polled by this program.
-type Resource struct {
-	url      string
-	errCount int
-}
-
-// Poll executes an HTTP HEAD request for url
-// and returns the HTTP status string or an error string.
-func (r *Resource) Poll() string {
-	resp, err := http.Head(r.url)
-	if err != nil {
-		log.Println("Error", r.url, err)
-		r.errCount++
-		return err.Error()
-	}
-	r.errCount = 0
-	return resp.Status
-}
-
-// Sleep sleeps for an appropriate interval (dependent on error state)
-// before sending the Resource to done.
-func (r *Resource) Sleep(done chan<- *Resource) {
-	time.Sleep(pollInterval + errTimeout*time.Duration(r.errCount))
-	done <- r
-}
-
-func Poller(in <-chan *Resource, out chan<- *Resource, status chan<- State) {
-	for r := range in {
-		s := r.Poll()
-		status <- State{r.url, s}
-		out <- r
-	}
-}
-
-func main() {
-	// Create our input and output channels.
-	pending, complete := make(chan *Resource), make(chan *Resource)
-
-	// Launch the StateMonitor.
-	status := StateMonitor(statusInterval)
-
-	// Launch some Poller goroutines.
-	for i := 0; i < numPollers; i++ {
-		go Poller(pending, complete, status)
-	}
-
-	// Send some Resources to the pending queue.
-	go func() {
-		for _, url := range urls {
-			pending <- &Resource{url: url}
-		}
-	}()
-
-	for r := range complete {
-		go r.Sleep(pending)
-	}
-}

doc/debugging_with_gdb.html

@@ -1,554 +0,0 @@
-<!--{
-	"Title": "Debugging Go Code with GDB",
-	"Path": "/doc/gdb"
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
--->
-
-<i>
-<p>
-The following instructions apply to the standard toolchain
-(the <code>gc</code> Go compiler and tools).
-Gccgo has native gdb support.
-</p>
-<p>
-Note that 
-<a href="https://github.com/go-delve/delve">Delve</a> is a better
-alternative to GDB when debugging Go programs built with the standard
-toolchain. It understands the Go runtime, data structures, and
-expressions better than GDB. Delve currently supports Linux, OSX,
-and Windows on <code>amd64</code>.
-For the most up-to-date list of supported platforms, please see
-<a href="https://github.com/go-delve/delve/tree/master/Documentation/installation">
- the Delve documentation</a>.
-</p>
-</i>
-
-<p>
-GDB does not understand Go programs well.
-The stack management, threading, and runtime contain aspects that differ
-enough from the execution model GDB expects that they can confuse
-the debugger and cause incorrect results even when the program is
-compiled with gccgo.
-As a consequence, although GDB can be useful in some situations (e.g.,
-debugging Cgo code, or debugging the runtime itself), it is not
-a reliable debugger for Go programs, particularly heavily concurrent
-ones.  Moreover, it is not a priority for the Go project to address
-these issues, which are difficult.
-</p>
-
-<p>
-In short, the instructions below should be taken only as a guide to how
-to use GDB when it works, not as a guarantee of success.
-
-Besides this overview you might want to consult the
-<a href="https://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
-</p>
-
-<p>
-</p>
-
-<h2 id="Introduction">Introduction</h2>
-
-<p>
-When you compile and link your Go programs with the <code>gc</code> toolchain
-on Linux, macOS, FreeBSD or NetBSD, the resulting binaries contain DWARFv4
-debugging information that recent versions (&ge;7.5) of the GDB debugger can
-use to inspect a live process or a core dump.
-</p>
-
-<p>
-Pass the <code>'-w'</code> flag to the linker to omit the debug information
-(for example, <code>go</code> <code>build</code> <code>-ldflags=-w</code> <code>prog.go</code>).
-</p>
-
-<p>
-The code generated by the <code>gc</code> compiler includes inlining of
-function invocations and registerization of variables. These optimizations
-can sometimes make debugging with <code>gdb</code> harder.
-If you find that you need to disable these optimizations,
-build your program using <code>go</code> <code>build</code> <code>-gcflags=all="-N -l"</code>.
-</p>
-
-<p>
-If you want to use gdb to inspect a core dump, you can trigger a dump
-on a program crash, on systems that permit it, by setting
-<code>GOTRACEBACK=crash</code> in the environment (see the
-<a href="/pkg/runtime/#hdr-Environment_Variables"> runtime package
-documentation</a> for more info).
-</p>
-
-<h3 id="Common_Operations">Common Operations</h3>
-
-<ul>
-<li>
-Show file and line number for code, set breakpoints and disassemble:
-<pre>(gdb) <b>list</b>
-(gdb) <b>list <i>line</i></b>
-(gdb) <b>list <i>file.go</i>:<i>line</i></b>
-(gdb) <b>break <i>line</i></b>
-(gdb) <b>break <i>file.go</i>:<i>line</i></b>
-(gdb) <b>disas</b></pre>
-</li>
-<li>
-Show backtraces and unwind stack frames:
-<pre>(gdb) <b>bt</b>
-(gdb) <b>frame <i>n</i></b></pre>
-</li>
-<li>
-Show the name, type and location on the stack frame of local variables,
-arguments and return values:
-<pre>(gdb) <b>info locals</b>
-(gdb) <b>info args</b>
-(gdb) <b>p variable</b>
-(gdb) <b>whatis variable</b></pre>
-</li>
-<li>
-Show the name, type and location of global variables:
-<pre>(gdb) <b>info variables <i>regexp</i></b></pre>
-</li>
-</ul>
-
-
-<h3 id="Go_Extensions">Go Extensions</h3>
-
-<p>
-A recent extension mechanism to GDB allows it to load extension scripts for a
-given binary. The toolchain uses this to extend GDB with a handful of
-commands to inspect internals of the runtime code (such as goroutines) and to
-pretty print the built-in map, slice and channel types.
-</p>
-
-<ul>
-<li>
-Pretty printing a string, slice, map, channel or interface:
-<pre>(gdb) <b>p <i>var</i></b></pre>
-</li>
-<li>
-A $len() and $cap() function for strings, slices and maps:
-<pre>(gdb) <b>p $len(<i>var</i>)</b></pre>
-</li>
-<li>
-A function to cast interfaces to their dynamic types:
-<pre>(gdb) <b>p $dtype(<i>var</i>)</b>
-(gdb) <b>iface <i>var</i></b></pre>
-<p class="detail"><b>Known issue:</b> GDB can’t automatically find the dynamic
-type of an interface value if its long name differs from its short name
-(annoying when printing stacktraces, the pretty printer falls back to printing
-the short type name and a pointer).</p>
-</li>
-<li>
-Inspecting goroutines:
-<pre>(gdb) <b>info goroutines</b>
-(gdb) <b>goroutine <i>n</i> <i>cmd</i></b>
-(gdb) <b>help goroutine</b></pre>
-For example:
-<pre>(gdb) <b>goroutine 12 bt</b></pre>
-You can inspect all goroutines by passing <code>all</code> instead of a specific goroutine's ID.
-For example:
-<pre>(gdb) <b>goroutine all bt</b></pre>
-</li>
-</ul>
-
-<p>
-If you'd like to see how this works, or want to extend it, take a look at <a
-href="/src/runtime/runtime-gdb.py">src/runtime/runtime-gdb.py</a> in
-the Go source distribution. It depends on some special magic types
-(<code>hash&lt;T,U&gt;</code>) and variables (<code>runtime.m</code> and
-<code>runtime.g</code>) that the linker
-(<a href="/src/cmd/link/internal/ld/dwarf.go">src/cmd/link/internal/ld/dwarf.go</a>) ensures are described in
-the DWARF code.
-</p>
-
-<p>
-If you're interested in what the debugging information looks like, run
-<code>objdump</code> <code>-W</code> <code>a.out</code> and browse through the <code>.debug_*</code>
-sections.
-</p>
-
-
-<h3 id="Known_Issues">Known Issues</h3>
-
-<ol>
-<li>String pretty printing only triggers for type string, not for types derived
-from it.</li>
-<li>Type information is missing for the C parts of the runtime library.</li>
-<li>GDB does not understand Go’s name qualifications and treats
-<code>"fmt.Print"</code> as an unstructured literal with a <code>"."</code>
-that needs to be quoted.  It objects even more strongly to method names of
-the form <code>pkg.(*MyType).Meth</code>.
-<li>As of Go 1.11, debug information is compressed by default.
-Older versions of gdb, such as the one available by default on MacOS,
-do not understand the compression.
-You can generate uncompressed debug information by using <code>go
-build -ldflags=-compressdwarf=false</code>.
-(For convenience you can put the <code>-ldflags</code> option in
-the <a href="/cmd/go/#hdr-Environment_variables"><code>GOFLAGS</code>
-environment variable</a> so that you don't have to specify it each time.)
-</li>
-</ol>
-
-<h2 id="Tutorial">Tutorial</h2>
-
-<p>
-In this tutorial we will inspect the binary of the
-<a href="/pkg/regexp/">regexp</a> package's unit tests. To build the binary,
-change to <code>$GOROOT/src/regexp</code> and run <code>go</code> <code>test</code> <code>-c</code>.
-This should produce an executable file named <code>regexp.test</code>.
-</p>
-
-
-<h3 id="Getting_Started">Getting Started</h3>
-
-<p>
-Launch GDB, debugging <code>regexp.test</code>:
-</p>
-
-<pre>
-$ <b>gdb regexp.test</b>
-GNU gdb (GDB) 7.2-gg8
-Copyright (C) 2010 Free Software Foundation, Inc.
-License GPLv  3+: GNU GPL version 3 or later &lt;http://gnu.org/licenses/gpl.html&gt;
-Type "show copying" and "show warranty" for licensing/warranty details.
-This GDB was configured as "x86_64-linux".
-
-Reading symbols from  /home/user/go/src/regexp/regexp.test...
-done.
-Loading Go Runtime support.
-(gdb) 
-</pre>
-
-<p>
-The message "Loading Go Runtime support" means that GDB loaded the
-extension from <code>$GOROOT/src/runtime/runtime-gdb.py</code>.
-</p>
-
-<p>
-To help GDB find the Go runtime sources and the accompanying support script,
-pass your <code>$GOROOT</code> with the <code>'-d'</code> flag:
-</p>
-
-<pre>
-$ <b>gdb regexp.test -d $GOROOT</b>
-</pre>
-
-<p>
-If for some reason GDB still can't find that directory or that script, you can load
-it by hand by telling gdb (assuming you have the go sources in
-<code>~/go/</code>):
-</p>
-
-<pre>
-(gdb) <b>source ~/go/src/runtime/runtime-gdb.py</b>
-Loading Go Runtime support.
-</pre>
-
-<h3 id="Inspecting_the_source">Inspecting the source</h3>
-
-<p>
-Use the <code>"l"</code> or <code>"list"</code> command to inspect source code.
-</p>
-
-<pre>
-(gdb) <b>l</b>
-</pre>
-
-<p>
-List a specific part of the source parameterizing <code>"list"</code> with a
-function name (it must be qualified with its package name).
-</p>
-
-<pre>
-(gdb) <b>l main.main</b>
-</pre>
-
-<p>
-List a specific file and line number:
-</p>
-
-<pre>
-(gdb) <b>l regexp.go:1</b>
-(gdb) <i># Hit enter to repeat last command. Here, this lists next 10 lines.</i>
-</pre>
-
-
-<h3 id="Naming">Naming</h3>
-
-<p>
-Variable and function names must be qualified with the name of the packages
-they belong to. The <code>Compile</code> function from the <code>regexp</code>
-package is known to GDB as <code>'regexp.Compile'</code>. 
-</p>
-
-<p>
-Methods must be qualified with the name of their receiver types. For example,
-the <code>*Regexp</code> type’s <code>String</code> method is known as
-<code>'regexp.(*Regexp).String'</code>.
-</p>
-
-<p>
-Variables that shadow other variables are magically suffixed with a number in the debug info.
-Variables referenced by closures will appear as pointers magically prefixed with '&amp;'.
-</p>
-
-<h3 id="Setting_breakpoints">Setting breakpoints</h3>
-
-<p>
-Set a breakpoint at the <code>TestFind</code> function:
-</p>
-
-<pre>
-(gdb) <b>b 'regexp.TestFind'</b>
-Breakpoint 1 at 0x424908: file /home/user/go/src/regexp/find_test.go, line 148.
-</pre>
-
-<p>
-Run the program:
-</p>
-
-<pre>
-(gdb) <b>run</b>
-Starting program: /home/user/go/src/regexp/regexp.test
-
-Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
-148	func TestFind(t *testing.T) {
-</pre>
-
-<p>
-Execution has paused at the breakpoint.
-See which goroutines are running, and what they're doing:
-</p>
-
-<pre>
-(gdb) <b>info goroutines</b>
-  1  waiting runtime.gosched
-* 13  running runtime.goexit
-</pre>
-
-<p>
-the one marked with the <code>*</code> is the current goroutine.
-</p>
-
-<h3 id="Inspecting_the_stack">Inspecting the stack</h3>
-
-<p>
-Look at the stack trace for where we’ve paused the program:
-</p>
-
-<pre>
-(gdb) <b>bt</b>  <i># backtrace</i>
-#0  regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
-#1  0x000000000042f60b in testing.tRunner (t=0xf8404a89c0, test=0x573720) at /home/user/go/src/testing/testing.go:156
-#2  0x000000000040df64 in runtime.initdone () at /home/user/go/src/runtime/proc.c:242
-#3  0x000000f8404a89c0 in ?? ()
-#4  0x0000000000573720 in ?? ()
-#5  0x0000000000000000 in ?? ()
-</pre>
-
-<p>
-The other goroutine, number 1, is stuck in <code>runtime.gosched</code>, blocked on a channel receive:
-</p>
-
-<pre>
-(gdb) <b>goroutine 1 bt</b>
-#0  0x000000000040facb in runtime.gosched () at /home/user/go/src/runtime/proc.c:873
-#1  0x00000000004031c9 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
- at  /home/user/go/src/runtime/chan.c:342
-#2  0x0000000000403299 in runtime.chanrecv1 (t=void, c=void) at/home/user/go/src/runtime/chan.c:423
-#3  0x000000000043075b in testing.RunTests (matchString={void (struct string, struct string, bool *, error *)}
- 0x7ffff7f9ef60, tests=  []testing.InternalTest = {...}) at /home/user/go/src/testing/testing.go:201
-#4  0x00000000004302b1 in testing.Main (matchString={void (struct string, struct string, bool *, error *)} 
- 0x7ffff7f9ef80, tests= []testing.InternalTest = {...}, benchmarks= []testing.InternalBenchmark = {...})
-at /home/user/go/src/testing/testing.go:168
-#5  0x0000000000400dc1 in main.main () at /home/user/go/src/regexp/_testmain.go:98
-#6  0x00000000004022e7 in runtime.mainstart () at /home/user/go/src/runtime/amd64/asm.s:78
-#7  0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
-#8  0x0000000000000000 in ?? ()
-</pre>
-
-<p>
-The stack frame shows we’re currently executing the <code>regexp.TestFind</code> function, as expected.
-</p>
-
-<pre>
-(gdb) <b>info frame</b>
-Stack level 0, frame at 0x7ffff7f9ff88:
- rip = 0x425530 in regexp.TestFind (/home/user/go/src/regexp/find_test.go:148); 
-    saved rip 0x430233
- called by frame at 0x7ffff7f9ffa8
- source language minimal.
- Arglist at 0x7ffff7f9ff78, args: t=0xf840688b60
- Locals at 0x7ffff7f9ff78, Previous frame's sp is 0x7ffff7f9ff88
- Saved registers:
-  rip at 0x7ffff7f9ff80
-</pre>
-
-<p>
-The command <code>info</code> <code>locals</code> lists all variables local to the function and their values, but is a bit
-dangerous to use, since it will also try to print uninitialized variables. Uninitialized slices may cause gdb to try
-to print arbitrary large arrays.
-</p>
-
-<p>
-The function’s arguments:
-</p>
-
-<pre>
-(gdb) <b>info args</b>
-t = 0xf840688b60
-</pre>
-
-<p>
-When printing the argument, notice that it’s a pointer to a
-<code>Regexp</code> value. Note that GDB has incorrectly put the <code>*</code>
-on the right-hand side of the type name and made up a 'struct' keyword, in traditional C style.
-</p>
-
-<pre>
-(gdb) <b>p re</b>
-(gdb) p t
-$1 = (struct testing.T *) 0xf840688b60
-(gdb) p t
-$1 = (struct testing.T *) 0xf840688b60
-(gdb) p *t
-$2 = {errors = "", failed = false, ch = 0xf8406f5690}
-(gdb) p *t-&gt;ch
-$3 = struct hchan&lt;*testing.T&gt;
-</pre>
-
-<p>
-That <code>struct</code> <code>hchan&lt;*testing.T&gt;</code> is the
-runtime-internal representation of a channel. It is currently empty,
-or gdb would have pretty-printed its contents.
-</p>
-
-<p>
-Stepping forward:
-</p>
-
-<pre>
-(gdb) <b>n</b>  <i># execute next line</i>
-149             for _, test := range findTests {
-(gdb)    <i># enter is repeat</i>
-150                     re := MustCompile(test.pat)
-(gdb) <b>p test.pat</b>
-$4 = ""
-(gdb) <b>p re</b>
-$5 = (struct regexp.Regexp *) 0xf84068d070
-(gdb) <b>p *re</b>
-$6 = {expr = "", prog = 0xf840688b80, prefix = "", prefixBytes =  []uint8, prefixComplete = true, 
-  prefixRune = 0, cond = 0 '\000', numSubexp = 0, longest = false, mu = {state = 0, sema = 0}, 
-  machine =  []*regexp.machine}
-(gdb) <b>p *re->prog</b>
-$7 = {Inst =  []regexp/syntax.Inst = {{Op = 5 '\005', Out = 0, Arg = 0, Rune =  []int}, {Op = 
-    6 '\006', Out = 2, Arg = 0, Rune =  []int}, {Op = 4 '\004', Out = 0, Arg = 0, Rune =  []int}}, 
-  Start = 1, NumCap = 2}
-</pre>
-
-
-<p>
-We can step into the <code>String</code>function call with <code>"s"</code>:
-</p>
-
-<pre>
-(gdb) <b>s</b>
-regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/regexp/regexp.go:97
-97      func (re *Regexp) String() string {
-</pre>
-
-<p>
-Get a stack trace to see where we are:
-</p>
-
-<pre>
-(gdb) <b>bt</b>
-#0  regexp.(*Regexp).String (re=0xf84068d070, noname=void)
-    at /home/user/go/src/regexp/regexp.go:97
-#1  0x0000000000425615 in regexp.TestFind (t=0xf840688b60)
-    at /home/user/go/src/regexp/find_test.go:151
-#2  0x0000000000430233 in testing.tRunner (t=0xf840688b60, test=0x5747b8)
-    at /home/user/go/src/testing/testing.go:156
-#3  0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
-....
-</pre>
-
-<p>
-Look at the source code:
-</p>
-
-<pre>
-(gdb) <b>l</b>
-92              mu      sync.Mutex
-93              machine []*machine
-94      }
-95
-96      // String returns the source text used to compile the regular expression.
-97      func (re *Regexp) String() string {
-98              return re.expr
-99      }
-100
-101     // Compile parses a regular expression and returns, if successful,
-</pre>
-
-<h3 id="Pretty_Printing">Pretty Printing</h3>
-
-<p>
-GDB's pretty printing mechanism is triggered by regexp matches on type names.  An example for slices:
-</p>
-
-<pre>
-(gdb) <b>p utf</b>
-$22 =  []uint8 = {0 '\000', 0 '\000', 0 '\000', 0 '\000'}
-</pre>
-
-<p>
-Since slices, arrays and strings are not C pointers, GDB can't interpret the subscripting operation for you, but
-you can look inside the runtime representation to do that (tab completion helps here):
-</p>
-<pre>
-
-(gdb) <b>p slc</b>
-$11 =  []int = {0, 0}
-(gdb) <b>p slc-&gt;</b><i>&lt;TAB&gt;</i>
-array  slc    len    
-(gdb) <b>p slc->array</b>
-$12 = (int *) 0xf84057af00
-(gdb) <b>p slc->array[1]</b>
-$13 = 0</pre>
-
-
-
-<p>
-The extension functions $len and $cap work on strings, arrays and slices:
-</p>
-
-<pre>
-(gdb) <b>p $len(utf)</b>
-$23 = 4
-(gdb) <b>p $cap(utf)</b>
-$24 = 4
-</pre>
-
-<p>
-Channels and maps are 'reference' types, which gdb shows as pointers to C++-like types <code>hash&lt;int,string&gt;*</code>.  Dereferencing will trigger prettyprinting
-</p>
-
-<p>
-Interfaces are represented in the runtime as a pointer to a type descriptor and a pointer to a value.  The Go GDB runtime extension decodes this and automatically triggers pretty printing for the runtime type.  The extension function <code>$dtype</code> decodes the dynamic type for you (examples are taken from a breakpoint at <code>regexp.go</code> line 293.)
-</p>
-
-<pre>
-(gdb) <b>p i</b>
-$4 = {str = "cbb"}
-(gdb) <b>whatis i</b>
-type = regexp.input
-(gdb) <b>p $dtype(i)</b>
-$26 = (struct regexp.inputBytes *) 0xf8400b4930
-(gdb) <b>iface i</b>
-regexp.input: struct regexp.inputBytes *
-</pre>

doc/diagnostics.html

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

doc/editors.html

@@ -1,35 +0,0 @@
-<!--{
-	"Title": "Editor plugins and IDEs",
-	"Template": true
-}-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-  This document lists commonly used editor plugins and IDEs from the Go ecosystem
-  that make Go development more productive and seamless.
-  A comprehensive list of editor support and IDEs for Go development is available at
-  <a href="https://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
-</p>
-
-<h2 id="options">Options</h2>
-<p>
-The Go ecosystem provides a variety of editor plugins and IDEs to enhance your day-to-day
-editing, navigation, testing, and debugging experience.
-</p>
-
-<ul>
-<li><a href="https://github.com/fatih/vim-go">vim</a>: vim-go plugin provides Go programming language support</li>
-<li><a href="https://marketplace.visualstudio.com/items?itemName=golang.go">Visual Studio Code</a>:
-Go extension provides support for the Go programming language</li>
-<li><a href="https://www.jetbrains.com/go">GoLand</a>: GoLand is distributed either as a standalone IDE
-or as a plugin for IntelliJ IDEA Ultimate</li>
-<li><a href="https://atom.io/packages/go-plus">Atom</a>: Go-Plus is an Atom package that provides enhanced Go support</li>
-</ul>
-
-<p>
-Note that these are only a few top solutions; a more comprehensive
-community-maintained list of
-<a href="https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins">IDEs and text editor plugins</a>
-is available at the Wiki.
-</p>

doc/gccgo_contribute.html

@@ -1,112 +0,0 @@
-<!--{
-	"Title": "Contributing to the gccgo frontend"
-}-->
-
-<h2>Introduction</h2>
-
-<p>
-These are some notes on contributing to the gccgo frontend for GCC.
-For information on contributing to parts of Go other than gccgo,
-see <a href="/doc/contribute.html">Contributing to the Go project</a>.  For
-information on building gccgo for yourself,
-see <a href="/doc/gccgo_install.html">Setting up and using gccgo</a>.
-For more of the gritty details on the process of doing development
-with the gccgo frontend,
-see <a href="https://go.googlesource.com/gofrontend/+/master/HACKING">the
-file HACKING</a> in the gofrontend repository.
-</p>
-
-<h2>Legal Prerequisites</h2>
-
-<p>
-You must follow the <a href="/doc/contribute.html#copyright">Go copyright
-rules</a> for all changes to the gccgo frontend and the associated
-libgo library.  Code that is part of GCC rather than gccgo must follow
-the general <a href="https://gcc.gnu.org/contribute.html">GCC
-contribution rules</a>.
-</p>
-
-<h2>Code</h2>
-
-<p>
-The master sources for the gccgo frontend may be found at
-<a href="https://go.googlesource.com/gofrontend">https://go.googlesource.com/gofrontend</a>.
-They are mirrored
-at <a href="https://github.com/golang/gofrontend">https://github.com/golang/gofrontend</a>.
-The master sources are not buildable by themselves, but only in
-conjunction with GCC (in the future, other compilers may be
-supported).  Changes made to the gccgo frontend are also applied to
-the GCC source code repository hosted at <code>gcc.gnu.org</code>.  In
-the <code>gofrontend</code> repository, the <code>go</code> directory
-is mirrored to the <code>gcc/go/gofrontend</code> directory in the GCC
-repository, and the <code>gofrontend</code> <code>libgo</code>
-directory is mirrored to the GCC <code>libgo</code> directory.  In
-addition, the <code>test</code> directory
-from <a href="//go.googlesource.com/go">the main Go repository</a>
-is mirrored to the <code>gcc/testsuite/go.test/test</code> directory
-in the GCC repository.
-</p>
-
-<p>
-Changes to these directories always flow from the master sources to
-the GCC repository.  The files should never be changed in the GCC
-repository except by changing them in the master sources and mirroring
-them.
-</p>
-
-<p>
-The gccgo frontend is written in C++.
-It follows the GNU and GCC coding standards for C++.
-In writing code for the frontend, follow the formatting of the
-surrounding code.
-Almost all GCC-specific code is not in the frontend proper and is
-instead in the GCC sources in the <code>gcc/go</code> directory.
-</p>
-
-<p>
-The run-time library for gccgo is mostly the same as the library
-in <a href="//go.googlesource.com/go">the main Go repository</a>.
-The library code in the Go repository is periodically merged into
-the <code>libgo/go</code> directory of the <code>gofrontend</code> and
-then the GCC repositories, using the shell
-script <code>libgo/merge.sh</code>.  Accordingly, most library changes
-should be made in the main Go repository.  The files outside
-of <code>libgo/go</code> are gccgo-specific; that said, some of the
-files in <code>libgo/runtime</code> are based on files
-in <code>src/runtime</code> in the main Go repository.
-</p>
-
-<h2>Testing</h2>
-
-<p>
-All patches must be tested.  A patch that introduces new failures is
-not acceptable.
-</p>
-
-<p>
-To run the gccgo test suite, run <code>make check-go</code> in your
-build directory.  This will run various tests
-under <code>gcc/testsuite/go.*</code> and will also run
-the <code>libgo</code> testsuite.  This copy of the tests from the
-main Go repository is run using the DejaGNU script found
-in <code>gcc/testsuite/go.test/go-test.exp</code>.
-</p>
-
-<p>
-Most new tests should be submitted to the main Go repository for later
-mirroring into the GCC repository.  If there is a need for specific
-tests for gccgo, they should go in
-the <code>gcc/testsuite/go.go-torture</code>
-or <code>gcc/testsuite/go.dg</code> directories in the GCC repository.
-</p>
-
-<h2>Submitting Changes</h2>
-
-<p>
-Changes to the Go frontend should follow the same process as for the
-main Go repository, only for the <code>gofrontend</code> project and
-the <code>gofrontend-dev@googlegroups.com</code> mailing list
-rather than the <code>go</code> project and the
-<code>golang-dev@googlegroups.com</code> mailing list.  Those changes
-will then be merged into the GCC sources.
-</p>

doc/gccgo_install.html

@@ -1,533 +0,0 @@
-<!--{
-	"Title": "Setting up and using gccgo",
-	"Path": "/doc/install/gccgo"
-}-->
-
-<p>
-This document explains how to use gccgo, a compiler for
-the Go language. The gccgo compiler is a new frontend
-for GCC, the widely used GNU compiler. Although the
-frontend itself is under a BSD-style license, gccgo is
-normally used as part of GCC and is then covered by
-the <a href="https://www.gnu.org/licenses/gpl.html">GNU General Public
-License</a> (the license covers gccgo itself as part of GCC; it
-does not cover code generated by gccgo).
-</p>
-
-<p>
-Note that gccgo is not the <code>gc</code> compiler; see
-the <a href="/doc/install.html">Installing Go</a> instructions for that
-compiler.
-</p>
-
-<h2 id="Releases">Releases</h2>
-
-<p>
-The simplest way to install gccgo is to install a GCC binary release
-built to include Go support. GCC binary releases are available from
-<a href="https://gcc.gnu.org/install/binaries.html">various
-websites</a> and are typically included as part of GNU/Linux
-distributions. We expect that most people who build these binaries
-will include Go support.
-</p>
-
-<p>
-The GCC 4.7.1 release and all later 4.7 releases include a complete
-<a href="/doc/go1.html">Go 1</a> compiler and libraries.
-</p>
-
-<p>
-Due to timing, the GCC 4.8.0 and 4.8.1 releases are close to but not
-identical to Go 1.1. The GCC 4.8.2 release includes a complete Go
-1.1.2 implementation.
-</p>
-
-<p>
-The GCC 4.9 releases include a complete Go 1.2 implementation.
-</p>
-
-<p>
-The GCC 5 releases include a complete implementation of the Go 1.4
-user libraries. The Go 1.4 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 6 releases include a complete implementation of the Go 1.6.1
-user libraries. The Go 1.6 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 7 releases include a complete implementation of the Go 1.8.1
-user libraries. As with earlier releases, the Go 1.8 runtime is not
-fully merged, but that should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 8 releases include a complete implementation of the Go 1.10.1
-release. The Go 1.10 runtime has now been fully merged into the GCC
-development sources, and concurrent garbage collection is fully
-supported.
-</p>
-
-<p>
-The GCC 9 releases include a complete implementation of the Go 1.12.2
-release.
-</p>
-
-<h2 id="Source_code">Source code</h2>
-
-<p>
-If you cannot use a release, or prefer to build gccgo for yourself, the
-gccgo source code is accessible via Git. The GCC web site has
-<a href="https://gcc.gnu.org/git.html">instructions for getting the GCC
-source code</a>. The gccgo source code is included. As a convenience, a
-stable version of the Go support is available in the
-<code>devel/gccgo</code> branch of the main GCC code repository:
-<code>git://gcc.gnu.org/git/gcc.git</code>.
-This branch is periodically updated with stable Go compiler sources.
-</p>
-
-<p>
-Note that although <code>gcc.gnu.org</code> is the most convenient way
-to get the source code for the Go frontend, it is not where the master
-sources live. If you want to contribute changes to the Go frontend
-compiler, see <a href="/doc/gccgo_contribute.html">Contributing to
-gccgo</a>.
-</p>
-
-
-<h2 id="Building">Building</h2>
-
-<p>
-Building gccgo is just like building GCC
-with one or two additional options. See
-the <a href="https://gcc.gnu.org/install/">instructions on the gcc web
-site</a>. When you run <code>configure</code>, add the
-option <code>--enable-languages=c,c++,go</code> (along with other
-languages you may want to build). If you are targeting a 32-bit x86,
-then you will want to build gccgo to default to
-supporting locked compare and exchange instructions; do this by also
-using the <code>configure</code> option <code>--with-arch=i586</code>
-(or a newer architecture, depending on where you need your programs to
-run). If you are targeting a 64-bit x86, but sometimes want to use
-the <code>-m32</code> option, then use the <code>configure</code>
-option <code>--with-arch-32=i586</code>.
-</p>
-
-<h3 id="Gold">Gold</h3>
-
-<p>
-On x86 GNU/Linux systems the gccgo compiler is able to
-use a small discontiguous stack for goroutines. This permits programs
-to run many more goroutines, since each goroutine can use a relatively
-small stack. Doing this requires using the gold linker version 2.22
-or later. You can either install GNU binutils 2.22 or later, or you
-can build gold yourself.
-</p>
-
-<p>
-To build gold yourself, build the GNU binutils,
-using <code>--enable-gold=default</code> when you run
-the <code>configure</code> script. Before building, you must install
-the flex and bison packages. A typical sequence would look like
-this (you can replace <code>/opt/gold</code> with any directory to
-which you have write access):
-</p>
-
-<pre>
-git clone git://sourceware.org/git/binutils-gdb.git
-mkdir binutils-objdir
-cd binutils-objdir
-../binutils-gdb/configure --enable-gold=default --prefix=/opt/gold
-make
-make install
-</pre>
-
-<p>
-However you install gold, when you configure gccgo, use the
-option <code>--with-ld=<var>GOLD_BINARY</var></code>.
-</p>
-
-<h3 id="Prerequisites">Prerequisites</h3>
-
-<p>
-A number of prerequisites are required to build GCC, as
-described on
-the <a href="https://gcc.gnu.org/install/prerequisites.html">gcc web
-site</a>. It is important to install all the prerequisites before
-running the gcc <code>configure</code> script.
-The prerequisite libraries can be conveniently downloaded using the
-script <code>contrib/download_prerequisites</code> in the GCC sources.
-
-<h3 id="Build_commands">Build commands</h3>
-
-<p>
-Once all the prerequisites are installed, then a typical build and
-install sequence would look like this (only use
-the <code>--with-ld</code> option if you are using the gold linker as
-described above):
-</p>
-
-<pre>
-git clone --branch devel/gccgo git://gcc.gnu.org/git/gcc.git gccgo
-mkdir objdir
-cd objdir
-../gccgo/configure --prefix=/opt/gccgo --enable-languages=c,c++,go --with-ld=/opt/gold/bin/ld
-make
-make install
-</pre>
-
-<h2 id="Using_gccgo">Using gccgo</h2>
-
-<p>
-The gccgo compiler works like other gcc frontends. As of GCC 5 the gccgo
-installation also includes a version of the <code>go</code> command,
-which may be used to build Go programs as described at
-<a href="https://golang.org/cmd/go">https://golang.org/cmd/go</a>.
-</p>
-
-<p>
-To compile a file without using the <code>go</code> command:
-</p>
-
-<pre>
-gccgo -c file.go
-</pre>
-
-<p>
-That produces <code>file.o</code>. To link files together to form an
-executable:
-</p>
-
-<pre>
-gccgo -o file file.o
-</pre>
-
-<p>
-To run the resulting file, you will need to tell the program where to
-find the compiled Go packages. There are a few ways to do this:
-</p>
-
-<ul>
-<li>
-<p>
-Set the <code>LD_LIBRARY_PATH</code> environment variable:
-</p>
-
-<pre>
-LD_LIBRARY_PATH=${prefix}/lib/gcc/MACHINE/VERSION
-[or]
-LD_LIBRARY_PATH=${prefix}/lib64/gcc/MACHINE/VERSION
-export LD_LIBRARY_PATH
-</pre>
-
-<p>
-Here <code>${prefix}</code> is the <code>--prefix</code> option used
-when building gccgo. For a binary install this is
-normally <code>/usr</code>. Whether to use <code>lib</code>
-or <code>lib64</code> depends on the target.
-Typically <code>lib64</code> is correct for x86_64 systems,
-and <code>lib</code> is correct for other systems. The idea is to
-name the directory where <code>libgo.so</code> is found.
-</p>
-
-</li>
-
-<li>
-<p>
-Passing a <code>-Wl,-R</code> option when you link (replace lib with
-lib64 if appropriate for your system):
-</p>
-
-<pre>
-go build -gccgoflags -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
-[or]
-gccgo -o file file.o -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
-</pre>
-</li>
-
-<li>
-<p>
-Use the <code>-static-libgo</code> option to link statically against
-the compiled packages.
-</p>
-</li>
-
-<li>
-<p>
-Use the <code>-static</code> option to do a fully static link (the
-default for the <code>gc</code> compiler).
-</p>
-</li>
-</ul>
-
-<h2 id="Options">Options</h2>
-
-<p>
-The gccgo compiler supports all GCC options
-that are language independent, notably the <code>-O</code>
-and <code>-g</code> options.
-</p>
-
-<p>
-The <code>-fgo-pkgpath=PKGPATH</code> option may be used to set a
-unique prefix for the package being compiled.
-This option is automatically used by the go command, but you may want
-to use it if you invoke gccgo directly.
-This option is intended for use with large
-programs that contain many packages, in order to allow multiple
-packages to use the same identifier as the package name.
-The <code>PKGPATH</code> may be any string; a good choice for the
-string is the path used to import the package.
-</p>
-
-<p>
-The <code>-I</code> and <code>-L</code> options, which are synonyms
-for the compiler, may be used to set the search path for finding
-imports.
-These options are not needed if you build with the go command.
-</p>
-
-<h2 id="Imports">Imports</h2>
-
-<p>
-When you compile a file that exports something, the export
-information will be stored directly in the object file.
-If you build with gccgo directly, rather than with the go command,
-then when you import a package, you must tell gccgo how to find the
-file.
-</p>
-
-<p>
-When you import the package <var>FILE</var> with gccgo,
-it will look for the import data in the following files, and use the
-first one that it finds.
-
-<ul>
-<li><code><var>FILE</var>.gox</code>
-<li><code>lib<var>FILE</var>.so</code>
-<li><code>lib<var>FILE</var>.a</code>
-<li><code><var>FILE</var>.o</code>
-</ul>
-
-<p>
-<code><var>FILE</var>.gox</code>, when used, will typically contain
-nothing but export data. This can be generated from
-<code><var>FILE</var>.o</code> via
-</p>
-
-<pre>
-objcopy -j .go_export FILE.o FILE.gox
-</pre>
-
-<p>
-The gccgo compiler will look in the current
-directory for import files. In more complex scenarios you
-may pass the <code>-I</code> or <code>-L</code> option to
-gccgo. Both options take directories to search. The
-<code>-L</code> option is also passed to the linker.
-</p>
-
-<p>
-The gccgo compiler does not currently (2015-06-15) record
-the file name of imported packages in the object file. You must
-arrange for the imported data to be linked into the program.
-Again, this is not necessary when building with the go command.
-</p>
-
-<pre>
-gccgo -c mypackage.go              # Exports mypackage
-gccgo -c main.go                   # Imports mypackage
-gccgo -o main main.o mypackage.o   # Explicitly links with mypackage.o
-</pre>
-
-<h2 id="Debugging">Debugging</h2>
-
-<p>
-If you use the <code>-g</code> option when you compile, you can run
-<code>gdb</code> on your executable. The debugger has only limited
-knowledge about Go. You can set breakpoints, single-step,
-etc. You can print variables, but they will be printed as though they
-had C/C++ types. For numeric types this doesn't matter. Go strings
-and interfaces will show up as two-element structures. Go
-maps and channels are always represented as C pointers to run-time
-structures.
-</p>
-
-<h2 id="C_Interoperability">C Interoperability</h2>
-
-<p>
-When using gccgo there is limited interoperability with C,
-or with C++ code compiled using <code>extern "C"</code>.
-</p>
-
-<h3 id="Types">Types</h3>
-
-<p>
-Basic types map directly: an <code>int32</code> in Go is
-an <code>int32_t</code> in C, an <code>int64</code> is
-an <code>int64_t</code>, etc.
-The Go type <code>int</code> is an integer that is the same size as a
-pointer, and as such corresponds to the C type <code>intptr_t</code>.
-Go <code>byte</code> is equivalent to C <code>unsigned char</code>.
-Pointers in Go are pointers in C.
-A Go <code>struct</code> is the same as C <code>struct</code> with the
-same fields and types.
-</p>
-
-<p>
-The Go <code>string</code> type is currently defined as a two-element
-structure (this is <b style="color: red;">subject to change</b>):
-</p>
-
-<pre>
-struct __go_string {
-  const unsigned char *__data;
-  intptr_t __length;
-};
-</pre>
-
-<p>
-You can't pass arrays between C and Go. However, a pointer to an
-array in Go is equivalent to a C pointer to the
-equivalent of the element type.
-For example, Go <code>*[10]int</code> is equivalent to C <code>int*</code>,
-assuming that the C pointer does point to 10 elements.
-</p>
-
-<p>
-A slice in Go is a structure. The current definition is
-(this is <b style="color: red;">subject to change</b>):
-</p>
-
-<pre>
-struct __go_slice {
-  void *__values;
-  intptr_t __count;
-  intptr_t __capacity;
-};
-</pre>
-
-<p>
-The type of a Go function is a pointer to a struct (this is
-<b style="color: red;">subject to change</b>). The first field in the
-struct points to the code of the function, which will be equivalent to
-a pointer to a C function whose parameter types are equivalent, with
-an additional trailing parameter. The trailing parameter is the
-closure, and the argument to pass is a pointer to the Go function
-struct.
-
-When a Go function returns more than one value, the C function returns
-a struct. For example, these functions are roughly equivalent:
-</p>
-
-<pre>
-func GoFunction(int) (int, float64)
-struct { int i; float64 f; } CFunction(int, void*)
-</pre>
-
-<p>
-Go <code>interface</code>, <code>channel</code>, and <code>map</code>
-types have no corresponding C type (<code>interface</code> is a
-two-element struct and <code>channel</code> and <code>map</code> are
-pointers to structs in C, but the structs are deliberately undocumented). C
-<code>enum</code> types correspond to some integer type, but precisely
-which one is difficult to predict in general; use a cast. C <code>union</code>
-types have no corresponding Go type. C <code>struct</code> types containing
-bitfields have no corresponding Go type. C++ <code>class</code> types have
-no corresponding Go type.
-</p>
-
-<p>
-Memory allocation is completely different between C and Go, as Go uses
-garbage collection. The exact guidelines in this area are undetermined,
-but it is likely that it will be permitted to pass a pointer to allocated
-memory from C to Go. The responsibility of eventually freeing the pointer
-will remain with C side, and of course if the C side frees the pointer
-while the Go side still has a copy the program will fail. When passing a
-pointer from Go to C, the Go function must retain a visible copy of it in
-some Go variable. Otherwise the Go garbage collector may delete the
-pointer while the C function is still using it.
-</p>
-
-<h3 id="Function_names">Function names</h3>
-
-<p>
-Go code can call C functions directly using a Go extension implemented
-in gccgo: a function declaration may be preceded by
-<code>//extern NAME</code>. For example, here is how the C function
-<code>open</code> can be declared in Go:
-</p>
-
-<pre>
-//extern open
-func c_open(name *byte, mode int, perm int) int
-</pre>
-
-<p>
-The C function naturally expects a NUL-terminated string, which in
-Go is equivalent to a pointer to an array (not a slice!) of
-<code>byte</code> with a terminating zero byte. So a sample call
-from Go would look like (after importing the <code>syscall</code> package):
-</p>
-
-<pre>
-var name = [4]byte{'f', 'o', 'o', 0};
-i := c_open(&amp;name[0], syscall.O_RDONLY, 0);
-</pre>
-
-<p>
-(this serves as an example only, to open a file in Go please use Go's
-<code>os.Open</code> function instead).
-</p>
-
-<p>
-Note that if the C function can block, such as in a call
-to <code>read</code>, calling the C function may block the Go program.
-Unless you have a clear understanding of what you are doing, all calls
-between C and Go should be implemented through cgo or SWIG, as for
-the <code>gc</code> compiler.
-</p>
-
-<p>
-The name of Go functions accessed from C is subject to change. At present
-the name of a Go function that does not have a receiver is
-<code>prefix.package.Functionname</code>. The prefix is set by
-the <code>-fgo-prefix</code> option used when the package is compiled;
-if the option is not used, the default is <code>go</code>.
-To call the function from C you must set the name using
-a GCC extension.
-</p>
-
-<pre>
-extern int go_function(int) __asm__ ("myprefix.mypackage.Function");
-</pre>
-
-<h3 id="Automatic_generation_of_Go_declarations_from_C_source_code">
-Automatic generation of Go declarations from C source code</h3>
-
-<p>
-The Go version of GCC supports automatically generating
-Go declarations from C code. The facility is rather awkward, and most
-users should use the <a href="/cmd/cgo">cgo</a> program with
-the <code>-gccgo</code> option instead.
-</p>
-
-<p>
-Compile your C code as usual, and add the option
-<code>-fdump-go-spec=<var>FILENAME</var></code>. This will create the
-file <code><var>FILENAME</var></code> as a side effect of the
-compilation. This file will contain Go declarations for the types,
-variables and functions declared in the C code. C types that can not
-be represented in Go will be recorded as comments in the Go code. The
-generated file will not have a <code>package</code> declaration, but
-can otherwise be compiled directly by gccgo.
-</p>
-
-<p>
-This procedure is full of unstated caveats and restrictions and we make no
-guarantee that it will not change in the future. It is more useful as a
-starting point for real Go code than as a regular procedure.
-</p>

doc/go1.11.html

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

doc/go1.12.html

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

doc/go1.14.html

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

doc/go1.2.html

@@ -1,979 +0,0 @@
-<!--{
-	"Title": "Go 1.2 Release Notes",
-	"Path":  "/doc/go1.2",
-	"Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.2</h2>
-
-<p>
-Since the release of <a href="/doc/go1.1.html">Go version 1.1</a> in April, 2013,
-the release schedule has been shortened to make the release process more efficient.
-This release, Go version 1.2 or Go 1.2 for short, arrives roughly six months after 1.1,
-while 1.1 took over a year to appear after 1.0.
-Because of the shorter time scale, 1.2 is a smaller delta than the step from 1.0 to 1.1,
-but it still has some significant developments, including
-a better scheduler and one new language feature.
-Of course, Go 1.2 keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a>.
-The overwhelming majority of programs built with Go 1.1 (or 1.0 for that matter)
-will run without any changes whatsoever when moved to 1.2,
-although the introduction of one restriction
-to a corner of the language may expose already-incorrect code
-(see the discussion of the <a href="#use_of_nil">use of nil</a>).
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-In the interest of firming up the specification, one corner case has been clarified,
-with consequences for programs.
-There is also one new language feature.
-</p>
-
-<h3 id="use_of_nil">Use of nil</h3>
-
-<p>
-The language now specifies that, for safety reasons,
-certain uses of nil pointers are guaranteed to trigger a run-time panic.
-For instance, in Go 1.0, given code like
-</p>
-
-<pre>
-type T struct {
-    X [1<<24]byte
-    Field int32
-}
-
-func main() {
-    var x *T
-    ...
-}
-</pre>
-
-<p>
-the <code>nil</code> pointer <code>x</code> could be used to access memory incorrectly:
-the expression <code>x.Field</code> could access memory at address <code>1<<24</code>.
-To prevent such unsafe behavior, in Go 1.2 the compilers now guarantee that any indirection through
-a nil pointer, such as illustrated here but also in nil pointers to arrays, nil interface values,
-nil slices, and so on, will either panic or return a correct, safe non-nil value.
-In short, any expression that explicitly or implicitly requires evaluation of a nil address is an error.
-The implementation may inject extra tests into the compiled program to enforce this behavior.
-</p>
-
-<p>
-Further details are in the
-<a href="//golang.org/s/go12nil">design document</a>.
-</p>
-
-<p>
-<em>Updating</em>:
-Most code that depended on the old behavior is erroneous and will fail when run.
-Such programs will need to be updated by hand.
-</p>
-
-<h3 id="three_index">Three-index slices</h3>
-
-<p>
-Go 1.2 adds the ability to specify the capacity as well as the length when using a slicing operation
-on an existing array or slice.
-A slicing operation creates a new slice by describing a contiguous section of an already-created array or slice:
-</p>
-
-<pre>
-var array [10]int
-slice := array[2:4]
-</pre>
-
-<p>
-The capacity of the slice is the maximum number of elements that the slice may hold, even after reslicing;
-it reflects the size of the underlying array.
-In this example, the capacity of the <code>slice</code> variable is 8.
-</p>
-
-<p>
-Go 1.2 adds new syntax to allow a slicing operation to specify the capacity as well as the length.
-A second
-colon introduces the capacity value, which must be less than or equal to the capacity of the
-source slice or array, adjusted for the origin. For instance,
-</p>
-
-<pre>
-slice = array[2:4:7]
-</pre>
-
-<p>
-sets the slice to have the same length as in the earlier example but its capacity is now only 5 elements (7-2).
-It is impossible to use this new slice value to access the last three elements of the original array.
-</p>
-
-<p>
-In this three-index notation, a missing first index (<code>[:i:j]</code>) defaults to zero but the other
-two indices must always be specified explicitly.
-It is possible that future releases of Go may introduce default values for these indices.
-</p>
-
-<p>
-Further details are in the
-<a href="//golang.org/s/go12slice">design document</a>.
-</p>
-
-<p>
-<em>Updating</em>:
-This is a backwards-compatible change that affects no existing programs.
-</p>
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="preemption">Pre-emption in the scheduler</h3>
-
-<p>
-In prior releases, a goroutine that was looping forever could starve out other
-goroutines on the same thread, a serious problem when GOMAXPROCS
-provided only one user thread.
-In Go 1.2, this is partially addressed: The scheduler is invoked occasionally
-upon entry to a function.
-This means that any loop that includes a (non-inlined) function call can
-be pre-empted, allowing other goroutines to run on the same thread.
-</p>
-
-<h3 id="thread_limit">Limit on the number of threads</h3>
-
-<p>
-Go 1.2 introduces a configurable limit (default 10,000) to the total number of threads
-a single program may have in its address space, to avoid resource starvation
-issues in some environments.
-Note that goroutines are multiplexed onto threads so this limit does not directly
-limit the number of goroutines, only the number that may be simultaneously blocked
-in a system call.
-In practice, the limit is hard to reach.
-</p>
-
-<p>
-The new <a href="/pkg/runtime/debug/#SetMaxThreads"><code>SetMaxThreads</code></a> function in the
-<a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package controls the thread count limit.
-</p>
-
-<p>
-<em>Updating</em>:
-Few functions will be affected by the limit, but if a program dies because it hits the
-limit, it could be modified to call <code>SetMaxThreads</code> to set a higher count.
-Even better would be to refactor the program to need fewer threads, reducing consumption
-of kernel resources.
-</p>
-
-<h3 id="stack_size">Stack size</h3>
-
-<p>
-In Go 1.2, the minimum size of the stack when a goroutine is created has been lifted from 4KB to 8KB.
-Many programs were suffering performance problems with the old size, which had a tendency
-to introduce expensive stack-segment switching in performance-critical sections.
-The new number was determined by empirical testing.
-</p>
-
-<p>
-At the other end, the new function <a href="/pkg/runtime/debug/#SetMaxStack"><code>SetMaxStack</code></a>
-in the <a href="/pkg/runtime/debug"><code>runtime/debug</code></a> package controls
-the <em>maximum</em> size of a single goroutine's stack.
-The default is 1GB on 64-bit systems and 250MB on 32-bit systems.
-Before Go 1.2, it was too easy for a runaway recursion to consume all the memory on a machine.
-</p>
-
-<p>
-<em>Updating</em>:
-The increased minimum stack size may cause programs with many goroutines to use
-more memory. There is no workaround, but plans for future releases
-include new stack management technology that should address the problem better.
-</p>
-
-<h3 id="cgo_and_cpp">Cgo and C++</h3>
-
-<p>
-The <a href="/cmd/cgo/"><code>cgo</code></a> command will now invoke the C++
-compiler to build any pieces of the linked-to library that are written in C++;
-<a href="/cmd/cgo/">the documentation</a> has more detail.
-</p>
-
-<h3 id="go_tools_godoc">Godoc and vet moved to the go.tools subrepository</h3>
-
-<p>
-Both binaries are still included with the distribution, but the source code for the
-godoc and vet commands has moved to the
-<a href="//code.google.com/p/go.tools">go.tools</a> subrepository.
-</p>
-
-<p>
-Also, the core of the godoc program has been split into a
-<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fgodoc">library</a>,
-while the command itself is in a separate
-<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fcmd%2Fgodoc">directory</a>.
-The move allows the code to be updated easily and the separation into a library and command
-makes it easier to construct custom binaries for local sites and different deployment methods.
-</p>
-
-<p>
-<em>Updating</em>:
-Since godoc and vet are not part of the library,
-no client Go code depends on the their source and no updating is required.
-</p>
-
-<p>
-The binary distributions available from <a href="//golang.org">golang.org</a>
-include these binaries, so users of these distributions are unaffected.
-</p>
-
-<p>
-When building from source, users must use "go get" to install godoc and vet.
-(The binaries will continue to be installed in their usual locations, not
-<code>$GOPATH/bin</code>.)
-</p>
-
-<pre>
-$ go get code.google.com/p/go.tools/cmd/godoc
-$ go get code.google.com/p/go.tools/cmd/vet
-</pre>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-We expect the future GCC 4.9 release to include gccgo with full
-support for Go 1.2.
-In the current (4.8.2) release of GCC, gccgo implements Go 1.1.2.
-</p>
-
-<h3 id="gc_changes">Changes to the gc compiler and linker</h3>
-
-<p>
-Go 1.2 has several semantic changes to the workings of the gc compiler suite.
-Most users will be unaffected by them.
-</p>
-
-<p>
-The <a href="/cmd/cgo/"><code>cgo</code></a> command now
-works when C++ is included in the library being linked against.
-See the <a href="/cmd/cgo/"><code>cgo</code></a> documentation
-for details.
-</p>
-
-<p>
-The gc compiler displayed a vestigial detail of its origins when
-a program had no <code>package</code> clause: it assumed
-the file was in package <code>main</code>.
-The past has been erased, and a missing <code>package</code> clause
-is now an error.
-</p>
-
-<p>
-On the ARM, the toolchain supports "external linking", which
-is a step towards being able to build shared libraries with the gc
-toolchain and to provide dynamic linking support for environments
-in which that is necessary.
-</p>
-
-<p>
-In the runtime for the ARM, with <code>5a</code>, it used to be possible to refer
-to the runtime-internal <code>m</code> (machine) and <code>g</code>
-(goroutine) variables using <code>R9</code> and <code>R10</code> directly.
-It is now necessary to refer to them by their proper names.
-</p>
-
-<p>
-Also on the ARM, the <code>5l</code> linker (sic) now defines the
-<code>MOVBS</code> and <code>MOVHS</code> instructions
-as synonyms of <code>MOVB</code> and <code>MOVH</code>,
-to make clearer the separation between signed and unsigned
-sub-word moves; the unsigned versions already existed with a
-<code>U</code> suffix.
-</p>
-
-<h3 id="cover">Test coverage</h3>
-
-<p>
-One major new feature of <a href="/pkg/go/"><code>go test</code></a> is
-that it can now compute and, with help from a new, separately installed
-"go tool cover" program, display test coverage results.
-</p>
-
-<p>
-The cover tool is part of the
-<a href="https://code.google.com/p/go/source/checkout?repo=tools"><code>go.tools</code></a>
-subrepository.
-It can be installed by running
-</p>
-
-<pre>
-$ go get code.google.com/p/go.tools/cmd/cover
-</pre>
-
-<p>
-The cover tool does two things.
-First, when "go test" is given the <code>-cover</code> flag, it is run automatically 
-to rewrite the source for the package and insert instrumentation statements.
-The test is then compiled and run as usual, and basic coverage statistics are reported:
-</p>
-
-<pre>
-$ go test -cover fmt
-ok  	fmt	0.060s	coverage: 91.4% of statements
-$
-</pre>
-
-<p>
-Second, for more detailed reports, different flags to "go test" can create a coverage profile file,
-which the cover program, invoked with "go tool cover", can then analyze.
-</p>
-
-<p>
-Details on how to generate and analyze coverage statistics can be found by running the commands
-</p>
-
-<pre>
-$ go help testflag
-$ go tool cover -help
-</pre>
-
-<h3 id="go_doc">The go doc command is deleted</h3>
-
-<p>
-The "go doc" command is deleted.
-Note that the <a href="/cmd/godoc/"><code>godoc</code></a> tool itself is not deleted,
-just the wrapping of it by the <a href="/cmd/go/"><code>go</code></a> command.
-All it did was show the documents for a package by package path,
-which godoc itself already does with more flexibility.
-It has therefore been deleted to reduce the number of documentation tools and,
-as part of the restructuring of godoc, encourage better options in future.
-</p>
-
-<p>
-<em>Updating</em>: For those who still need the precise functionality of running
-</p>
-
-<pre>
-$ go doc
-</pre>
-
-<p>
-in a directory, the behavior is identical to running
-</p>
-
-<pre>
-$ godoc .
-</pre>
-
-<h3 id="gocmd">Changes to the go command</h3>
-
-<p>
-The <a href="/cmd/go/"><code>go get</code></a> command
-now has a <code>-t</code> flag that causes it to download the dependencies
-of the tests run by the package, not just those of the package itself.
-By default, as before, dependencies of the tests are not downloaded.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-There are a number of significant performance improvements in the standard library; here are a few of them.
-</p>
-
-<ul> 
-
-<li>
-The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>
-decompresses about 30% faster.
-</li>
-
-<li>
-The <a href="/pkg/crypto/des/"><code>crypto/des</code></a> package
-is about five times faster.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-encodes about 30% faster.
-</li>
-
-<li>
-Networking performance on Windows and BSD systems is about 30% faster through the use
-of an integrated network poller in the runtime, similar to what was done for Linux and OS X
-in Go 1.1.
-</li>
-
-</ul>
-
-<h2 id="library">Changes to the standard library</h2>
-
-
-<h3 id="archive_tar_zip">The archive/tar and archive/zip packages</h3>
-
-<p>
-The
-<a href="/pkg/archive/tar/"><code>archive/tar</code></a>
-and
-<a href="/pkg/archive/zip/"><code>archive/zip</code></a>
-packages have had a change to their semantics that may break existing programs.
-The issue is that they both provided an implementation of the
-<a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a>
-interface that was not compliant with the specification for that interface.
-In particular, their <code>Name</code> method returned the full
-path name of the entry, but the interface specification requires that
-the method return only the base name (final path element).
-</p>
-
-<p>
-<em>Updating</em>: Since this behavior was newly implemented and
-a bit obscure, it is possible that no code depends on the broken behavior.
-If there are programs that do depend on it, they will need to be identified
-and fixed manually.
-</p>
-
-<h3 id="encoding">The new encoding package</h3>
-
-<p>
-There is a new package, <a href="/pkg/encoding/"><code>encoding</code></a>,
-that defines a set of standard encoding interfaces that may be used to
-build custom marshalers and unmarshalers for packages such as
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a>,
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a>,
-and
-<a href="/pkg/encoding/binary/"><code>encoding/binary</code></a>.
-These new interfaces have been used to tidy up some implementations in
-the standard library.
-</p>
-
-<p>
-The new interfaces are called
-<a href="/pkg/encoding/#BinaryMarshaler"><code>BinaryMarshaler</code></a>,
-<a href="/pkg/encoding/#BinaryUnmarshaler"><code>BinaryUnmarshaler</code></a>,
-<a href="/pkg/encoding/#TextMarshaler"><code>TextMarshaler</code></a>,
-and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>TextUnmarshaler</code></a>.
-Full details are in the <a href="/pkg/encoding/">documentation</a> for the package
-and a separate <a href="//golang.org/s/go12encoding">design document</a>.
-</p>
-
-<h3 id="fmt_indexed_arguments">The fmt package</h3>
-
-<p>
-The <a href="/pkg/fmt/"><code>fmt</code></a> package's formatted print
-routines such as <a href="/pkg/fmt/#Printf"><code>Printf</code></a>
-now allow the data items to be printed to be accessed in arbitrary order
-by using an indexing operation in the formatting specifications.
-Wherever an argument is to be fetched from the argument list for formatting,
-either as the value to be formatted or as a width or specification integer,
-a new optional indexing notation <code>[</code><em>n</em><code>]</code>
-fetches argument <em>n</em> instead.
-The value of <em>n</em> is 1-indexed.
-After such an indexing operating, the next argument to be fetched by normal
-processing will be <em>n</em>+1.
-</p>
-
-<p>
-For example, the normal <code>Printf</code> call
-</p>
-
-<pre>
-fmt.Sprintf("%c %c %c\n", 'a', 'b', 'c')
-</pre>
-
-<p>
-would create the string <code>"a b c"</code>, but with indexing operations like this,
-</p>
-
-<pre>
-fmt.Sprintf("%[3]c %[1]c %c\n", 'a', 'b', 'c')
-</pre>
-
-<p>
-the result is "<code>"c a b"</code>. The <code>[3]</code> index accesses the third formatting
-argument, which is <code>'c'</code>, <code>[1]</code> accesses the first, <code>'a'</code>,
-and then the next fetch accesses the argument following that one, <code>'b'</code>.
-</p>
-
-<p>
-The motivation for this feature is programmable format statements to access
-the arguments in different order for localization, but it has other uses:
-</p>
-
-<pre>
-log.Printf("trace: value %v of type %[1]T\n", expensiveFunction(a.b[c]))
-</pre>
-
-<p>
-<em>Updating</em>: The change to the syntax of format specifications
-is strictly backwards compatible, so it affects no working programs.
-</p>
-
-<h3 id="text_template">The text/template and html/template packages</h3>
-
-<p>
-The
-<a href="/pkg/text/template/"><code>text/template</code></a> package
-has a couple of changes in Go 1.2, both of which are also mirrored in the
-<a href="/pkg/html/template/"><code>html/template</code></a> package.
-</p>
-
-<p>
-First, there are new default functions for comparing basic types.
-The functions are listed in this table, which shows their names and
-the associated familiar comparison operator.
-</p>
-
-<table cellpadding="0" summary="Template comparison functions">
-<tr>
-<th width="50"></th><th width="100">Name</th> <th width="50">Operator</th>
-</tr>
-<tr>
-<td></td><td><code>eq</code></td> <td><code>==</code></td>
-</tr>
-<tr>
-<td></td><td><code>ne</code></td> <td><code>!=</code></td>
-</tr>
-<tr>
-<td></td><td><code>lt</code></td> <td><code>&lt;</code></td>
-</tr>
-<tr>
-<td></td><td><code>le</code></td> <td><code>&lt;=</code></td>
-</tr>
-<tr>
-<td></td><td><code>gt</code></td> <td><code>&gt;</code></td>
-</tr>
-<tr>
-<td></td><td><code>ge</code></td> <td><code>&gt;=</code></td>
-</tr>
-</table>
-
-<p>
-These functions behave slightly differently from the corresponding Go operators.
-First, they operate only on basic types (<code>bool</code>, <code>int</code>,
-<code>float64</code>, <code>string</code>, etc.).
-(Go allows comparison of arrays and structs as well, under some circumstances.)
-Second, values can be compared as long as they are the same sort of value:
-any signed integer value can be compared to any other signed integer value for example. (Go
-does not permit comparing an <code>int8</code> and an <code>int16</code>).
-Finally, the <code>eq</code> function (only) allows comparison of the first
-argument with one or more following arguments. The template in this example,
-</p>
-
-<pre>
-{{"{{"}}if eq .A 1 2 3 {{"}}"}} equal {{"{{"}}else{{"}}"}} not equal {{"{{"}}end{{"}}"}}
-</pre>
-
-<p>
-reports "equal" if <code>.A</code> is equal to <em>any</em> of 1, 2, or 3.
-</p>
-
-<p>
-The second change is that a small addition to the grammar makes "if else if" chains easier to write.
-Instead of writing,
-</p>
-
-<pre>
-{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else{{"}}"}} {{"{{"}}if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}} {{"{{"}}end{{"}}"}} 
-</pre>
-
-<p>
-one can fold the second "if" into the "else" and have only one "end", like this:
-</p>
-
-<pre>
-{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}}
-</pre>
-
-<p>
-The two forms are identical in effect; the difference is just in the syntax.
-</p>
-
-<p>
-<em>Updating</em>: Neither the "else if" change nor the comparison functions
-affect existing programs. Those that
-already define functions called <code>eq</code> and so on through a function
-map are unaffected because the associated function map will override the new
-default function definitions.
-</p>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-There are two new packages.
-</p>
-
-<ul>
-<li>
-The <a href="/pkg/encoding/"><code>encoding</code></a> package is
-<a href="#encoding">described above</a>.
-</li>
-<li>
-The <a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package
-provides standard color palettes.
-</li>
-</ul>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package
-adds the
-<a href="/pkg/archive/zip/#File.DataOffset"><code>DataOffset</code></a> accessor
-to return the offset of a file's (possibly compressed) data within the archive.
-</li>
-
-<li>
-The <a href="/pkg/bufio/"><code>bufio</code></a> package
-adds <a href="/pkg/bufio/#Reader.Reset"><code>Reset</code></a>
-methods to <a href="/pkg/bufio/#Reader"><code>Reader</code></a> and
-<a href="/pkg/bufio/#Writer"><code>Writer</code></a>.
-These methods allow the <a href="/pkg/io/#Reader"><code>Readers</code></a>
-and <a href="/pkg/io/#Writer"><code>Writers</code></a>
-to be re-used on new input and output readers and writers, saving
-allocation overhead. 
-</li>
-
-<li>
-The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>
-can now decompress concatenated archives.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>
-package adds a <a href="/pkg/compress/flate/#Writer.Reset"><code>Reset</code></a> 
-method on the <a href="/pkg/compress/flate/#Writer"><code>Writer</code></a>,
-to make it possible to reduce allocation when, for instance, constructing an
-archive to hold multiple compressed files.
-</li>
-
-<li>
-The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package's
-<a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a> type adds a
-<a href="/pkg/compress/gzip/#Writer.Reset"><code>Reset</code></a>
-so it may be reused.
-</li>
-
-<li>
-The <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> package's
-<a href="/pkg/compress/zlib/#Writer"><code>Writer</code></a> type adds a
-<a href="/pkg/compress/zlib/#Writer.Reset"><code>Reset</code></a>
-so it may be reused.
-</li>
-
-<li>
-The <a href="/pkg/container/heap/"><code>container/heap</code></a> package
-adds a <a href="/pkg/container/heap/#Fix"><code>Fix</code></a>
-method to provide a more efficient way to update an item's position in the heap.
-</li>
-
-<li>
-The <a href="/pkg/container/list/"><code>container/list</code></a> package
-adds the <a href="/pkg/container/list/#List.MoveBefore"><code>MoveBefore</code></a>
-and
-<a href="/pkg/container/list/#List.MoveAfter"><code>MoveAfter</code></a>
-methods, which implement the obvious rearrangement.
-</li>
-
-<li>
-The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package
-adds the a new GCM mode (Galois Counter Mode), which is almost always
-used with AES encryption.
-</li>
-
-<li>
-The 
-<a href="/pkg/crypto/md5/"><code>crypto/md5</code></a> package
-adds a new <a href="/pkg/crypto/md5/#Sum"><code>Sum</code></a> function
-to simplify hashing without sacrificing performance.
-</li>
-
-<li>
-Similarly, the 
-<a href="/pkg/crypto/md5/"><code>crypto/sha1</code></a> package
-adds a new <a href="/pkg/crypto/sha1/#Sum"><code>Sum</code></a> function.
-</li>
-
-<li>
-Also, the
-<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a> package
-adds <a href="/pkg/crypto/sha256/#Sum256"><code>Sum256</code></a>
-and <a href="/pkg/crypto/sha256/#Sum224"><code>Sum224</code></a> functions.
-</li>
-
-<li>
-Finally, the <a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a> package
-adds <a href="/pkg/crypto/sha512/#Sum512"><code>Sum512</code></a> and
-<a href="/pkg/crypto/sha512/#Sum384"><code>Sum384</code></a> functions.
-</li>
-
-<li>
-The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
-adds support for reading and writing arbitrary extensions.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package adds
-support for TLS 1.1, 1.2 and AES-GCM.
-</li>
-
-<li>
-The <a href="/pkg/database/sql/"><code>database/sql</code></a> package adds a
-<a href="/pkg/database/sql/#DB.SetMaxOpenConns"><code>SetMaxOpenConns</code></a>
-method on <a href="/pkg/database/sql/#DB"><code>DB</code></a> to limit the
-number of open connections to the database.
-</li>
-
-<li>
-The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package
-now always allows trailing commas on fields.
-</li>
-
-<li>
-The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> package
-now treats channel and function fields of structures as if they were unexported,
-even if they are not. That is, it ignores them completely. Previously they would
-trigger an error, which could cause unexpected compatibility problems if an
-embedded structure added such a field.
-The package also now supports the generic <code>BinaryMarshaler</code> and
-<code>BinaryUnmarshaler</code> interfaces of the
-<a href="/pkg/encoding/"><code>encoding</code></a> package
-described above.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-now will always escape ampersands as "\u0026" when printing strings.
-It will now accept but correct invalid UTF-8 in
-<a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
-(such input was previously rejected).
-Finally, it now supports the generic encoding interfaces of the
-<a href="/pkg/encoding/"><code>encoding</code></a> package
-described above.
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package
-now allows attributes stored in pointers to be marshaled.
-It also supports the generic encoding interfaces of the
-<a href="/pkg/encoding/"><code>encoding</code></a> package
-described above through the new
-<a href="/pkg/encoding/xml/#Marshaler"><code>Marshaler</code></a>,
-<a href="/pkg/encoding/xml/#Unmarshaler"><code>Unmarshaler</code></a>,
-and related
-<a href="/pkg/encoding/xml/#MarshalerAttr"><code>MarshalerAttr</code></a> and
-<a href="/pkg/encoding/xml/#UnmarshalerAttr"><code>UnmarshalerAttr</code></a>
-interfaces.
-The package also adds a
-<a href="/pkg/encoding/xml/#Encoder.Flush"><code>Flush</code></a> method
-to the
-<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>
-type for use by custom encoders. See the documentation for
-<a href="/pkg/encoding/xml/#Encoder.EncodeToken"><code>EncodeToken</code></a>
-to see how to use it.
-</li>
-
-<li>
-The <a href="/pkg/flag/"><code>flag</code></a> package now
-has a <a href="/pkg/flag/#Getter"><code>Getter</code></a> interface
-to allow the value of a flag to be retrieved. Due to the
-Go 1 compatibility guidelines, this method cannot be added to the existing
-<a href="/pkg/flag/#Value"><code>Value</code></a>
-interface, but all the existing standard flag types implement it.
-The package also now exports the <a href="/pkg/flag/#CommandLine"><code>CommandLine</code></a>
-flag set, which holds the flags from the command line.
-</li>
-
-<li>
-The <a href="/pkg/go/ast/"><code>go/ast</code></a> package's
-<a href="/pkg/go/ast/#SliceExpr"><code>SliceExpr</code></a> struct
-has a new boolean field, <code>Slice3</code>, which is set to true
-when representing a slice expression with three indices (two colons).
-The default is false, representing the usual two-index form.
-</li>
-
-<li>
-The <a href="/pkg/go/build/"><code>go/build</code></a> package adds
-the <code>AllTags</code> field
-to the <a href="/pkg/go/build/#Package"><code>Package</code></a> type,
-to make it easier to process build tags.
-</li>
-
-<li>
-The <a href="/pkg/image/draw/"><code>image/draw</code></a> package now
-exports an interface, <a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>,
-that wraps the standard <a href="/pkg/image/draw/#Draw"><code>Draw</code></a> method.
-The Porter-Duff operators now implement this interface, in effect binding an operation to
-the draw operator rather than providing it explicitly.
-Given a paletted image as its destination, the new
-<a href="/pkg/image/draw/#FloydSteinberg"><code>FloydSteinberg</code></a>
-implementation of the
-<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>
-interface will use the Floyd-Steinberg error diffusion algorithm to draw the image.
-To create palettes suitable for such processing, the new
-<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> interface
-represents implementations of quantization algorithms that choose a palette
-given a full-color image.
-There are no implementations of this interface in the library.
-</li>
-
-<li>
-The <a href="/pkg/image/gif/"><code>image/gif</code></a> package
-can now create GIF files using the new
-<a href="/pkg/image/gif/#Encode"><code>Encode</code></a>
-and <a href="/pkg/image/gif/#EncodeAll"><code>EncodeAll</code></a>
-functions.
-Their options argument allows specification of an image
-<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> to use;
-if it is <code>nil</code>, the generated GIF will use the 
-<a href="/pkg/image/color/palette/#Plan9"><code>Plan9</code></a>
-color map (palette) defined in the new
-<a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package.
-The options also specify a
-<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>
-to use to create the output image;
-if it is <code>nil</code>, Floyd-Steinberg error diffusion is used.
-</li>
-
-<li>
-The <a href="/pkg/io/#Copy"><code>Copy</code></a> method of the
-<a href="/pkg/io/"><code>io</code></a> package now prioritizes its
-arguments differently.
-If one argument implements <a href="/pkg/io/#WriterTo"><code>WriterTo</code></a>
-and the other implements <a href="/pkg/io/#ReaderFrom"><code>ReaderFrom</code></a>,
-<a href="/pkg/io/#Copy"><code>Copy</code></a> will now invoke
-<a href="/pkg/io/#WriterTo"><code>WriterTo</code></a> to do the work,
-so that less intermediate buffering is required in general.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package requires cgo by default
-because the host operating system must in general mediate network call setup.
-On some systems, though, it is possible to use the network without cgo, and useful
-to do so, for instance to avoid dynamic linking.
-The new build tag <code>netgo</code> (off by default) allows the construction of a
-<code>net</code> package in pure Go on those systems where it is possible.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package adds a new field
-<code>DualStack</code> to the <a href="/pkg/net/#Dialer"><code>Dialer</code></a>
-struct for TCP connection setup using a dual IP stack as described in
-<a href="https://tools.ietf.org/html/rfc6555">RFC 6555</a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package will no longer
-transmit cookies that are incorrect according to
-<a href="https://tools.ietf.org/html/rfc6265">RFC 6265</a>.
-It just logs an error and sends nothing.
-Also,
-the <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#ReadResponse"><code>ReadResponse</code></a>
-function now permits the <code>*Request</code> parameter to be <code>nil</code>,
-whereupon it assumes a GET request.
-Finally, an HTTP server will now serve HEAD
-requests transparently, without the need for special casing in handler code.
-While serving a HEAD request, writes to a 
-<a href="/pkg/net/http/#Handler"><code>Handler</code></a>'s
-<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
-are absorbed by the
-<a href="/pkg/net/http/#Server"><code>Server</code></a>
-and the client receives an empty body as required by the HTTP specification.
-</li>
-
-<li>
-The <a href="/pkg/os/exec/"><code>os/exec</code></a> package's 
-<a href="/pkg/os/exec/#Cmd.StdinPipe"><code>Cmd.StdinPipe</code></a> method 
-returns an <code>io.WriteCloser</code>, but has changed its concrete
-implementation from <code>*os.File</code> to an unexported type that embeds
-<code>*os.File</code>, and it is now safe to close the returned value.
-Before Go 1.2, there was an unavoidable race that this change fixes.
-Code that needs access to the methods of <code>*os.File</code> can use an
-interface type assertion, such as <code>wc.(interface{ Sync() error })</code>.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package relaxes
-the constraints on finalizer functions in
-<a href="/pkg/runtime/#SetFinalizer"><code>SetFinalizer</code></a>: the
-actual argument can now be any type that is assignable to the formal type of
-the function, as is the case for any normal function call in Go.
-</li>
-
-<li>
-The <a href="/pkg/sort/"><code>sort</code></a> package has a new
-<a href="/pkg/sort/#Stable"><code>Stable</code></a> function that implements
-stable sorting. It is less efficient than the normal sort algorithm, however.
-</li>
-
-<li>
-The <a href="/pkg/strings/"><code>strings</code></a> package adds
-an <a href="/pkg/strings/#IndexByte"><code>IndexByte</code></a>
-function for consistency with the <a href="/pkg/bytes/"><code>bytes</code></a> package.
-</li>
-
-<li>
-The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package
-adds a new set of swap functions that atomically exchange the argument with the
-value stored in the pointer, returning the old value.
-The functions are
-<a href="/pkg/sync/atomic/#SwapInt32"><code>SwapInt32</code></a>,
-<a href="/pkg/sync/atomic/#SwapInt64"><code>SwapInt64</code></a>,
-<a href="/pkg/sync/atomic/#SwapUint32"><code>SwapUint32</code></a>,
-<a href="/pkg/sync/atomic/#SwapUint64"><code>SwapUint64</code></a>,
-<a href="/pkg/sync/atomic/#SwapUintptr"><code>SwapUintptr</code></a>,
-and
-<a href="/pkg/sync/atomic/#SwapPointer"><code>SwapPointer</code></a>,
-which swaps an <code>unsafe.Pointer</code>.
-</li>
-
-<li>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package now implements
-<a href="/pkg/syscall/#Sendfile"><code>Sendfile</code></a> for Darwin.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package
-now exports the <a href="/pkg/testing/#TB"><code>TB</code></a> interface.
-It records the methods in common with the
-<a href="/pkg/testing/#T"><code>T</code></a>
-and
-<a href="/pkg/testing/#B"><code>B</code></a> types,
-to make it easier to share code between tests and benchmarks.
-Also, the
-<a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a>
-function now quantizes the return value to an integer (although it
-still has type <code>float64</code>), to round off any error caused by
-initialization and make the result more repeatable. 
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package
-now automatically dereferences pointer values when evaluating the arguments
-to "escape" functions such as "html", to bring the behavior of such functions
-in agreement with that of other printing functions such as "printf".
-</li>
-
-<li>
-In the <a href="/pkg/time/"><code>time</code></a> package, the
-<a href="/pkg/time/#Parse"><code>Parse</code></a> function
-and
-<a href="/pkg/time/#Time.Format"><code>Format</code></a>
-method
-now handle time zone offsets with seconds, such as in the historical
-date "1871-01-01T05:33:02+00:34:08".
-Also, pattern matching in the formats for those routines is stricter: a non-lowercase letter
-must now follow the standard words such as "Jan" and "Mon".
-</li>
-
-<li>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package
-adds <a href="/pkg/unicode/#In"><code>In</code></a>,
-a nicer-to-use but equivalent version of the original
-<a href="/pkg/unicode/#IsOneOf"><code>IsOneOf</code></a>,
-to see whether a character is a member of a Unicode category.
-</li>
-
-</ul>

doc/go1.3.html

@@ -1,608 +0,0 @@
-<!--{
-	"Title": "Go 1.3 Release Notes",
-	"Path":  "/doc/go1.3",
-	"Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.3</h2>
-
-<p>
-The latest Go release, version 1.3, arrives six months after 1.2,
-and contains no language changes.
-It focuses primarily on implementation work, providing 
-precise garbage collection,
-a major refactoring of the compiler toolchain that results in
-faster builds, especially for large projects,
-significant performance improvements across the board,
-and support for DragonFly BSD, Solaris, Plan 9 and Google's Native Client architecture (NaCl).
-It also has an important refinement to the memory model regarding synchronization.
-As always, Go 1.3 keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a>,
-and almost everything 
-will continue to compile and run without change when moved to 1.3.
-</p>
-
-<h2 id="os">Changes to the supported operating systems and architectures</h2>
-
-<h3 id="win2000">Removal of support for Windows 2000</h3>
-
-<p>
-Microsoft stopped supporting Windows 2000 in 2010.
-Since it has <a href="https://codereview.appspot.com/74790043">implementation difficulties</a>
-regarding exception handling (signals in Unix terminology),
-as of Go 1.3 it is not supported by Go either.
-</p>
-
-<h3 id="dragonfly">Support for DragonFly BSD</h3>
-
-<p>
-Go 1.3 now includes experimental support for DragonFly BSD on the <code>amd64</code> (64-bit x86) and <code>386</code> (32-bit x86) architectures.
-It uses DragonFly BSD 3.6 or above.
-</p>
-
-<h3 id="freebsd">Support for FreeBSD</h3>
-
-<p>
-It was not announced at the time, but since the release of Go 1.2, support for Go on FreeBSD
-requires FreeBSD 8 or above.
-</p>
-
-<p>
-As of Go 1.3, support for Go on FreeBSD requires that the kernel be compiled with the
-<code>COMPAT_FREEBSD32</code> flag configured.
-</p>
-
-<p>
-In concert with the switch to EABI syscalls for ARM platforms, Go 1.3 will run only on FreeBSD 10.
-The x86 platforms, 386 and amd64, are unaffected.
-</p>
-
-<h3 id="nacl">Support for Native Client</h3>
-
-<p>
-Support for the Native Client virtual machine architecture has returned to Go with the 1.3 release.
-It runs on the 32-bit Intel architectures (<code>GOARCH=386</code>) and also on 64-bit Intel, but using
-32-bit pointers (<code>GOARCH=amd64p32</code>).
-There is not yet support for Native Client on ARM.
-Note that this is Native Client (NaCl), not Portable Native Client (PNaCl).
-Details about Native Client are <a href="https://developers.google.com/native-client/dev/">here</a>;
-how to set up the Go version is described <a href="//golang.org/wiki/NativeClient">here</a>.
-</p>
-
-<h3 id="netbsd">Support for NetBSD</h3>
-
-<p>
-As of Go 1.3, support for Go on NetBSD requires NetBSD 6.0 or above.
-</p>
-
-<h3 id="openbsd">Support for OpenBSD</h3>
-
-<p>
-As of Go 1.3, support for Go on OpenBSD requires OpenBSD 5.5 or above.
-</p>
-
-<h3 id="plan9">Support for Plan 9</h3>
-
-<p>
-Go 1.3 now includes experimental support for Plan 9 on the <code>386</code> (32-bit x86) architecture.
-It requires the <code>Tsemacquire</code> syscall, which has been in Plan 9 since June, 2012.
-</p>
-
-<h3 id="solaris">Support for Solaris</h3>
-
-<p>
-Go 1.3 now includes experimental support for Solaris on the <code>amd64</code> (64-bit x86) architecture.
-It requires illumos, Solaris 11 or above.
-</p>
-
-<h2 id="memory">Changes to the memory model</h2>
-
-<p>
-The Go 1.3 memory model <a href="https://codereview.appspot.com/75130045">adds a new rule</a>
-concerning sending and receiving on buffered channels,
-to make explicit that a buffered channel can be used as a simple
-semaphore, using a send into the
-channel to acquire and a receive from the channel to release.
-This is not a language change, just a clarification about an expected property of communication.
-</p>
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="stacks">Stack</h3>
-
-<p>
-Go 1.3 has changed the implementation of goroutine stacks away from the old,
-"segmented" model to a contiguous model.
-When a goroutine needs more stack
-than is available, its stack is transferred to a larger single block of memory.
-The overhead of this transfer operation amortizes well and eliminates the old "hot spot"
-problem when a calculation repeatedly steps across a segment boundary.
-Details including performance numbers are in this
-<a href="//golang.org/s/contigstacks">design document</a>.
-</p>
-
-<h3 id="garbage_collector">Changes to the garbage collector</h3>
-
-<p>
-For a while now, the garbage collector has been <em>precise</em> when examining
-values in the heap; the Go 1.3 release adds equivalent precision to values on the stack.
-This means that a non-pointer Go value such as an integer will never be mistaken for a
-pointer and prevent unused memory from being reclaimed.
-</p>
-
-<p>
-Starting with Go 1.3, the runtime assumes that values with pointer type
-contain pointers and other values do not.
-This assumption is fundamental to the precise behavior of both stack expansion
-and garbage collection.
-Programs that use <a href="/pkg/unsafe/">package unsafe</a>
-to store integers in pointer-typed values are illegal and will crash if the runtime detects the behavior.
-Programs that use <a href="/pkg/unsafe/">package unsafe</a> to store pointers
-in integer-typed values are also illegal but more difficult to diagnose during execution.
-Because the pointers are hidden from the runtime, a stack expansion or garbage collection
-may reclaim the memory they point at, creating
-<a href="//en.wikipedia.org/wiki/Dangling_pointer">dangling pointers</a>.
-</p>
-
-<p>
-<em>Updating</em>: Code that uses <code>unsafe.Pointer</code> to convert
-an integer-typed value held in memory into a pointer is illegal and must be rewritten.
-Such code can be identified by <code>go vet</code>.
-</p>
-
-<h3 id="map">Map iteration</h3>
-
-<p>
-Iterations over small maps no longer happen in a consistent order.
-Go 1 defines that &ldquo;<a href="//golang.org/ref/spec#For_statements">The iteration order over maps
-is not specified and is not guaranteed to be the same from one iteration to the next.</a>&rdquo;
-To keep code from depending on map iteration order,
-Go 1.0 started each map iteration at a random index in the map.
-A new map implementation introduced in Go 1.1 neglected to randomize
-iteration for maps with eight or fewer entries, although the iteration order
-can still vary from system to system.
-This has allowed people to write Go 1.1 and Go 1.2 programs that
-depend on small map iteration order and therefore only work reliably on certain systems.
-Go 1.3 reintroduces random iteration for small maps in order to flush out these bugs.
-</p>
-
-<p>
-<em>Updating</em>: If code assumes a fixed iteration order for small maps,
-it will break and must be rewritten not to make that assumption.
-Because only small maps are affected, the problem arises most often in tests.
-</p>
-
-<h3 id="liblink">The linker</h3>
-
-<p>
-As part of the general <a href="//golang.org/s/go13linker">overhaul</a> to
-the Go linker, the compilers and linkers have been refactored.
-The linker is still a C program, but now the instruction selection phase that
-was part of the linker has been moved to the compiler through the creation of a new
-library called <code>liblink</code>.
-By doing instruction selection only once, when the package is first compiled,
-this can speed up compilation of large projects significantly.
-</p>
-
-<p>
-<em>Updating</em>: Although this is a major internal change, it should have no
-effect on programs.
-</p>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-GCC release 4.9 will contain the Go 1.2 (not 1.3) version of gccgo.
-The release schedules for the GCC and Go projects do not coincide,
-which means that 1.3 will be available in the development branch but
-that the next GCC release, 4.10, will likely have the Go 1.4 version of gccgo.
-</p>
-
-<h3 id="gocmd">Changes to the go command</h3>
-
-<p>
-The <a href="/cmd/go/"><code>cmd/go</code></a> command has several new
-features.
-The <a href="/cmd/go/"><code>go run</code></a> and
-<a href="/cmd/go/"><code>go test</code></a> subcommands
-support a new <code>-exec</code> option to specify an alternate
-way to run the resulting binary.
-Its immediate purpose is to support NaCl.
-</p>
-
-<p>
-The test coverage support of the <a href="/cmd/go/"><code>go test</code></a>
-subcommand now automatically sets the coverage mode to <code>-atomic</code>
-when the race detector is enabled, to eliminate false reports about unsafe
-access to coverage counters.
-</p>
-
-<p>
-The <a href="/cmd/go/"><code>go test</code></a> subcommand
-now always builds the package, even if it has no test files.
-Previously, it would do nothing if no test files were present.
-</p>
-
-<p>
-The <a href="/cmd/go/"><code>go build</code></a> subcommand
-supports a new <code>-i</code> option to install dependencies
-of the specified target, but not the target itself.
-</p>
-
-<p>
-Cross compiling with <a href="/cmd/cgo/"><code>cgo</code></a> enabled
-is now supported.
-The CC_FOR_TARGET and CXX_FOR_TARGET environment
-variables are used when running all.bash to specify the cross compilers
-for C and C++ code, respectively.
-</p>
-
-<p>
-Finally, the go command now supports packages that import Objective-C
-files (suffixed <code>.m</code>) through cgo.
-</p>
-
-<h3 id="cgo">Changes to cgo</h3>
-
-<p>
-The <a href="/cmd/cgo/"><code>cmd/cgo</code></a> command,
-which processes <code>import "C"</code> declarations in Go packages,
-has corrected a serious bug that may cause some packages to stop compiling.
-Previously, all pointers to incomplete struct types translated to the Go type <code>*[0]byte</code>,
-with the effect that the Go compiler could not diagnose passing one kind of struct pointer
-to a function expecting another.
-Go 1.3 corrects this mistake by translating each different
-incomplete struct to a different named type.
-</p>
-
-<p>
-Given the C declaration <code>typedef struct S T</code> for an incomplete <code>struct S</code>,
-some Go code used this bug to refer to the types <code>C.struct_S</code> and <code>C.T</code> interchangeably.
-Cgo now explicitly allows this use, even for completed struct types.
-However, some Go code also used this bug to pass (for example) a <code>*C.FILE</code>
-from one package to another.
-This is not legal and no longer works: in general Go packages
-should avoid exposing C types and names in their APIs.
-</p>
-
-<p>
-<em>Updating</em>: Code confusing pointers to incomplete types or
-passing them across package boundaries will no longer compile
-and must be rewritten.
-If the conversion is correct and must be preserved,
-use an explicit conversion via <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code></a>.
-</p>
-
-<h3 id="swig">SWIG 3.0 required for programs that use SWIG</h3>
-
-<p>
-For Go programs that use SWIG, SWIG version 3.0 is now required.
-The <a href="/cmd/go"><code>cmd/go</code></a> command will now link the
-SWIG generated object files directly into the binary, rather than
-building and linking with a shared library.
-</p>
-
-<h3 id="gc_flag">Command-line flag parsing</h3>
-
-<p>
-In the gc toolchain, the assemblers now use the
-same command-line flag parsing rules as the Go flag package, a departure
-from the traditional Unix flag parsing.
-This may affect scripts that invoke the tool directly.
-For example,
-<code>go tool 6a -SDfoo</code> must now be written
-<code>go tool 6a -S -D foo</code>.
-(The same change was made to the compilers and linkers in <a href="/doc/go1.1#gc_flag">Go 1.1</a>.)
-</p>
-
-<h3 id="godoc">Changes to godoc</h3>
-<p>
-When invoked with the <code>-analysis</code> flag, 
-<a href="//godoc.org/golang.org/x/tools/cmd/godoc">godoc</a>
-now performs sophisticated <a href="/lib/godoc/analysis/help.html">static
-analysis</a> of the code it indexes.  
-The results of analysis are presented in both the source view and the
-package documentation view, and include the call graph of each package
-and the relationships between 
-definitions and references,
-types and their methods,
-interfaces and their implementations,
-send and receive operations on channels,
-functions and their callers, and
-call sites and their callees.
-</p>
-
-<h3 id="misc">Miscellany</h3>
-
-<p>
-The program <code>misc/benchcmp</code> that compares
-performance across benchmarking runs has been rewritten.
-Once a shell and awk script in the main repository, it is now a Go program in the <code>go.tools</code> repo.
-Documentation is <a href="//godoc.org/golang.org/x/tools/cmd/benchcmp">here</a>.
-</p>
-
-<p>
-For the few of us that build Go distributions, the tool <code>misc/dist</code> has been
-moved and renamed; it now lives in <code>misc/makerelease</code>, still in the main repository.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-The performance of Go binaries for this release has improved in many cases due to changes
-in the runtime and garbage collection, plus some changes to libraries.
-Significant instances include:
-</p>
-
-<ul> 
-
-<li>
-The runtime handles defers more efficiently, reducing the memory footprint by about two kilobytes
-per goroutine that calls defer.
-</li>
-
-<li>
-The garbage collector has been sped up, using a concurrent sweep algorithm,
-better parallelization, and larger pages.
-The cumulative effect can be a 50-70% reduction in collector pause time.
-</li>
-
-<li>
-The race detector (see <a href="/doc/articles/race_detector.html">this guide</a>)
-is now about 40% faster.
-</li>
-
-<li>
-The regular expression package <a href="/pkg/regexp/"><code>regexp</code></a>
-is now significantly faster for certain simple expressions due to the implementation of
-a second, one-pass execution engine.
-The choice of which engine to use is automatic;
-the details are hidden from the user.
-</li>
-
-</ul>
-
-<p>
-Also, the runtime now includes in stack dumps how long a goroutine has been blocked,
-which can be useful information when debugging deadlocks or performance issues.
-</p>
-
-<h2 id="library">Changes to the standard library</h2>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-A new package <a href="/pkg/debug/plan9obj/"><code>debug/plan9obj</code></a> was added to the standard library.
-It implements access to Plan 9 <a href="https://9p.io/magic/man2html/6/a.out">a.out</a> object files.
-</p>
-
-<h3 id="major_library_changes">Major changes to the library</h3>
-
-<p>
-A previous bug in <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a>
-made it possible to skip verification in TLS inadvertently.
-In Go 1.3, the bug is fixed: one must specify either ServerName or
-InsecureSkipVerify, and if ServerName is specified it is enforced.
-This may break existing code that incorrectly depended on insecure
-behavior.
-</p>
-
-<p>
-There is an important new type added to the standard library: <a href="/pkg/sync/#Pool"><code>sync.Pool</code></a>.
-It provides an efficient mechanism for implementing certain types of caches whose memory
-can be reclaimed automatically by the system.
-</p>
-
-<p>
-The <a href="/pkg/testing/"><code>testing</code></a> package's benchmarking helper,
-<a href="/pkg/testing/#B"><code>B</code></a>, now has a
-<a href="/pkg/testing/#B.RunParallel"><code>RunParallel</code></a> method
-to make it easier to run benchmarks that exercise multiple CPUs.
-</p>
-
-<p>
-<em>Updating</em>: The crypto/tls fix may break existing code, but such
-code was erroneous and should be updated.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-
-<li> In the <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package,
-a new <a href="/pkg/crypto/tls/#DialWithDialer"><code>DialWithDialer</code></a>
-function lets one establish a TLS connection using an existing dialer, making it easier
-to control dial options such as timeouts.
-The package also now reports the TLS version used by the connection in the
-<a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
-struct.
-</li>
-
-<li> The <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-function of the <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports parsing (and elsewhere, serialization) of PKCS #10 certificate
-signature requests.
-</li>
-
-<li>
-The formatted print functions of the <code>fmt</code> package now define <code>%F</code>
-as a synonym for <code>%f</code> when printing floating-point values.
-</li>
-
-<li>
-The <a href="/pkg/math/big/"><code>math/big</code></a> package's
-<a href="/pkg/math/big/#Int"><code>Int</code></a> and
-<a href="/pkg/math/big/#Rat"><code>Rat</code></a> types
-now implement
-<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>.
-</li>
-
-<li>
-The complex power function, <a href="/pkg/math/cmplx/#Pow"><code>Pow</code></a>,
-now specifies the behavior when the first argument is zero.
-It was undefined before.
-The details are in the <a href="/pkg/math/cmplx/#Pow">documentation for the function</a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now exposes the
-properties of a TLS connection used to make a client request in the new
-<a href="/pkg/net/http/#Response"><code>Response.TLS</code></a> field.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-allows setting an optional server error logger
-with <a href="/pkg/net/http/#Server"><code>Server.ErrorLog</code></a>.
-The default is still that all errors go to stderr.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-supports disabling HTTP keep-alive connections on the server
-with <a href="/pkg/net/http/#Server.SetKeepAlivesEnabled"><code>Server.SetKeepAlivesEnabled</code></a>.
-The default continues to be that the server does keep-alive (reuses
-connections for multiple requests) by default.
-Only resource-constrained servers or those in the process of graceful
-shutdown will want to disable them.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package adds an optional
-<a href="/pkg/net/http/#Transport"><code>Transport.TLSHandshakeTimeout</code></a>
-setting to cap the amount of time HTTP client requests will wait for
-TLS handshakes to complete.
-It's now also set by default
-on <a href="/pkg/net/http#DefaultTransport"><code>DefaultTransport</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport</code></a>,
-used by the HTTP client code, now
-enables <a href="http://en.wikipedia.org/wiki/Keepalive#TCP_keepalive">TCP
-keep-alives</a> by default.
-Other <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-values with a nil <code>Dial</code> field continue to function the same
-as before: no TCP keep-alives are used.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package
-now enables <a href="http://en.wikipedia.org/wiki/Keepalive#TCP_keepalive">TCP
-keep-alives</a> for incoming server requests when
-<a href="/pkg/net/http/#ListenAndServe"><code>ListenAndServe</code></a>
-or
-<a href="/pkg/net/http/#ListenAndServeTLS"><code>ListenAndServeTLS</code></a>
-are used.
-When a server is started otherwise, TCP keep-alives are not enabled.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package now
-provides an
-optional <a href="/pkg/net/http/#Server"><code>Server.ConnState</code></a>
-callback to hook various phases of a server connection's lifecycle
-(see <a href="/pkg/net/http/#ConnState"><code>ConnState</code></a>).
-This can be used to implement rate limiting or graceful shutdown.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's HTTP
-client now has an
-optional <a href="/pkg/net/http/#Client"><code>Client.Timeout</code></a>
-field to specify an end-to-end timeout on requests made using the
-client.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>
-method will now return an error if the body's <code>Content-Type</code>
-is not <code>multipart/form-data</code>.
-Prior to Go 1.3 it would silently fail and return <code>nil</code>.
-Code that relies on the previous behavior should be updated.
-</li>
-
-<li> In the <a href="/pkg/net/"><code>net</code></a> package,
-the <a href="/pkg/net/#Dialer"><code>Dialer</code></a> struct now
-has a <code>KeepAlive</code> option to specify a keep-alive period for the connection.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's 
-<a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-now closes <a href="/pkg/net/http/#Request"><code>Request.Body</code></a>
-consistently, even on error.
-</li>
-
-<li>
-The <a href="/pkg/os/exec/"><code>os/exec</code></a> package now implements
-what the documentation has always said with regard to relative paths for the binary.
-In particular, it only calls <a href="/pkg/os/exec/#LookPath"><code>LookPath</code></a>
-when the binary's file name contains no path separators.
-</li>
-
-<li>
-The <a href="/pkg/reflect/#Value.SetMapIndex"><code>SetMapIndex</code></a>
-function in the <a href="/pkg/reflect/"><code>reflect</code></a> package
-no longer panics when deleting from a <code>nil</code> map.
-</li>
-
-<li>
-If the main goroutine calls 
-<a href="/pkg/runtime/#Goexit"><code>runtime.Goexit</code></a>
-and all other goroutines finish execution, the program now always crashes,
-reporting a detected deadlock.
-Earlier versions of Go handled this situation inconsistently: most instances
-were reported as deadlocks, but some trivial cases exited cleanly instead.
-</li>
-
-<li>
-The runtime/debug package now has a new function
-<a href="/pkg/runtime/debug/#WriteHeapDump"><code>debug.WriteHeapDump</code></a>
-that writes out a description of the heap.
-</li>
-
-<li>
-The <a href="/pkg/strconv/#CanBackquote"><code>CanBackquote</code></a>
-function in the <a href="/pkg/strconv/"><code>strconv</code></a> package
-now considers the <code>DEL</code> character, <code>U+007F</code>, to be
-non-printing.
-</li>
-
-<li>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package now provides
-<a href="/pkg/syscall/#SendmsgN"><code>SendmsgN</code></a>
-as an alternate version of
-<a href="/pkg/syscall/#Sendmsg"><code>Sendmsg</code></a>
-that returns the number of bytes written.
-</li>
-
-<li>
-On Windows, the <a href="/pkg/syscall/"><code>syscall</code></a> package now
-supports the cdecl calling convention through the addition of a new function
-<a href="/pkg/syscall/#NewCallbackCDecl"><code>NewCallbackCDecl</code></a>
-alongside the existing function
-<a href="/pkg/syscall/#NewCallback"><code>NewCallback</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package now
-diagnoses tests that call <code>panic(nil)</code>, which are almost always erroneous.
-Also, tests now write profiles (if invoked with profiling flags) even on failure.
-</li>
-
-<li>
-The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
-support throughout the system has been upgraded from
-Unicode 6.2.0 to <a href="http://www.unicode.org/versions/Unicode6.3.0/">Unicode 6.3.0</a>.
-</li>
-
-</ul>

doc/go1.4.html

@@ -1,896 +0,0 @@
-<!--{
-	"Title": "Go 1.4 Release Notes",
-	"Path":  "/doc/go1.4",
-	"Template": true
-}-->
-
-<h2 id="introduction">Introduction to Go 1.4</h2>
-
-<p>
-The latest Go release, version 1.4, arrives as scheduled six months after 1.3.
-</p>
-
-<p>
-It contains only one tiny language change,
-in the form of a backwards-compatible simple variant of <code>for</code>-<code>range</code> loop,
-and a possibly breaking change to the compiler involving methods on pointers-to-pointers.
-</p>
-
-<p>
-The release focuses primarily on implementation work, improving the garbage collector
-and preparing the ground for a fully concurrent collector to be rolled out in the
-next few releases.
-Stacks are now contiguous, reallocated when necessary rather than linking on new
-"segments";
-this release therefore eliminates the notorious "hot stack split" problem.
-There are some new tools available including support in the <code>go</code> command
-for build-time source code generation.
-The release also adds support for ARM processors on Android and Native Client (NaCl)
-and for AMD64 on Plan 9.
-</p>
-
-<p>
-As always, Go 1.4 keeps the <a href="/doc/go1compat.html">promise
-of compatibility</a>,
-and almost everything 
-will continue to compile and run without change when moved to 1.4.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<h3 id="forrange">For-range loops</h3>
-<p>
-Up until Go 1.3, <code>for</code>-<code>range</code> loop had two forms
-</p>
-
-<pre>
-for i, v := range x {
-	...
-}
-</pre>
-
-<p>
-and
-</p>
-
-<pre>
-for i := range x {
-	...
-}
-</pre>
-
-<p>
-If one was not interested in the loop values, only the iteration itself, it was still
-necessary to mention a variable (probably the <a href="/ref/spec#Blank_identifier">blank identifier</a>, as in
-<code>for</code> <code>_</code> <code>=</code> <code>range</code> <code>x</code>), because
-the form
-</p>
-
-<pre>
-for range x {
-	...
-}
-</pre>
-
-<p>
-was not syntactically permitted.
-</p>
-
-<p>
-This situation seemed awkward, so as of Go 1.4 the variable-free form is now legal.
-The pattern arises rarely but the code can be cleaner when it does.
-</p>
-
-<p>
-<em>Updating</em>: The change is strictly backwards compatible to existing Go
-programs, but tools that analyze Go parse trees may need to be modified to accept
-this new form as the
-<code>Key</code> field of <a href="/pkg/go/ast/#RangeStmt"><code>RangeStmt</code></a>
-may now be <code>nil</code>.
-</p>
-
-<h3 id="methodonpointertopointer">Method calls on **T</h3>
-
-<p>
-Given these declarations,
-</p>
-
-<pre>
-type T int
-func (T) M() {}
-var x **T
-</pre>
-
-<p>
-both <code>gc</code> and <code>gccgo</code> accepted the method call
-</p>
-
-<pre>
-x.M()
-</pre>
-
-<p>
-which is a double dereference of the pointer-to-pointer <code>x</code>.
-The Go specification allows a single dereference to be inserted automatically,
-but not two, so this call is erroneous according to the language definition.
-It has therefore been disallowed in Go 1.4, which is a breaking change,
-although very few programs will be affected.
-</p>
-
-<p>
-<em>Updating</em>: Code that depends on the old, erroneous behavior will no longer
-compile but is easy to fix by adding an explicit dereference.
-</p>
-
-<h2 id="os">Changes to the supported operating systems and architectures</h2>
-
-<h3 id="android">Android</h3>
-
-<p>
-Go 1.4 can build binaries for ARM processors running the Android operating system.
-It can also build a <code>.so</code> library that can be loaded by an Android application
-using the supporting packages in the <a href="https://golang.org/x/mobile">mobile</a> subrepository.
-A brief description of the plans for this experimental port are available
-<a href="https://golang.org/s/go14android">here</a>.
-</p>
-
-<h3 id="naclarm">NaCl on ARM</h3>
-
-<p>
-The previous release introduced Native Client (NaCl) support for the 32-bit x86
-(<code>GOARCH=386</code>)
-and 64-bit x86 using 32-bit pointers (GOARCH=amd64p32).
-The 1.4 release adds NaCl support for ARM (GOARCH=arm).
-</p>
-
-<h3 id="plan9amd64">Plan9 on AMD64</h3>
-
-<p>
-This release adds support for the Plan 9 operating system on AMD64 processors,
-provided the kernel supports the <code>nsec</code> system call and uses 4K pages.
-</p>
-
-<h2 id="compatibility">Changes to the compatibility guidelines</h2>
-
-<p>
-The <a href="/pkg/unsafe/"><code>unsafe</code></a> package allows one
-to defeat Go's type system by exploiting internal details of the implementation
-or machine representation of data.
-It was never explicitly specified what use of <code>unsafe</code> meant
-with respect to compatibility as specified in the
-<a href="go1compat.html">Go compatibility guidelines</a>.
-The answer, of course, is that we can make no promise of compatibility
-for code that does unsafe things.
-</p>
-
-<p>
-We have clarified this situation in the documentation included in the release.
-The <a href="go1compat.html">Go compatibility guidelines</a> and the
-docs for the <a href="/pkg/unsafe/"><code>unsafe</code></a> package
-are now explicit that unsafe code is not guaranteed to remain compatible.
-</p>
-  
-<p>
-<em>Updating</em>: Nothing technical has changed; this is just a clarification
-of the documentation.
-</p>
-
-
-<h2 id="impl">Changes to the implementations and tools</h2>
-
-<h3 id="runtime">Changes to the runtime</h3>
-
-<p>
-Prior to Go 1.4, the runtime (garbage collector, concurrency support, interface management,
-maps, slices, strings, ...) was mostly written in C, with some assembler support.
-In 1.4, much of the code has been translated to Go so that the garbage collector can scan
-the stacks of programs in the runtime and get accurate information about what variables
-are active.
-This change was large but should have no semantic effect on programs.
-</p>
-
-<p>
-This rewrite allows the garbage collector in 1.4 to be fully precise,
-meaning that it is aware of the location of all active pointers in the program.
-This means the heap will be smaller as there will be no false positives keeping non-pointers alive.
-Other related changes also reduce the heap size, which is smaller by 10%-30% overall
-relative to the previous release.
-</p>
-
-<p>
-A consequence is that stacks are no longer segmented, eliminating the "hot split" problem.
-When a stack limit is reached, a new, larger stack is allocated, all active frames for
-the goroutine are copied there, and any pointers into the stack are updated.
-Performance can be noticeably better in some cases and is always more predictable.
-Details are available in <a href="https://golang.org/s/contigstacks">the design document</a>.
-</p>
-
-<p>
-The use of contiguous stacks means that stacks can start smaller without triggering performance issues,
-so the default starting size for a goroutine's stack in 1.4 has been reduced from 8192 bytes to 2048 bytes.
-</p>
-
-<p>
-As preparation for the concurrent garbage collector scheduled for the 1.5 release,
-writes to pointer values in the heap are now done by a function call,
-called a write barrier, rather than directly from the function updating the value.
-In this next release, this will permit the garbage collector to mediate writes to the heap while it is running.
-This change has no semantic effect on programs in 1.4, but was
-included in the release to test the compiler and the resulting performance.
-</p>
-
-<p>
-The implementation of interface values has been modified.
-In earlier releases, the interface contained a word that was either a pointer or a one-word
-scalar value, depending on the type of the concrete object stored.
-This implementation was problematical for the garbage collector,
-so as of 1.4 interface values always hold a pointer.
-In running programs, most interface values were pointers anyway,
-so the effect is minimal, but programs that store integers (for example) in
-interfaces will see more allocations.
-</p>
-
-<p>
-As of Go 1.3, the runtime crashes if it finds a memory word that should contain
-a valid pointer but instead contains an obviously invalid pointer (for example, the value 3).
-Programs that store integers in pointer values may run afoul of this check and crash.
-In Go 1.4, setting the <a href="/pkg/runtime/"><code>GODEBUG</code></a> variable
-<code>invalidptr=0</code> disables
-the crash as a workaround, but we cannot guarantee that future releases will be
-able to avoid the crash; the correct fix is to rewrite code not to alias integers and pointers.
-</p>
-
-<h3 id="asm">Assembly</h3>
-
-<p>
-The language accepted by the assemblers <code>cmd/5a</code>, <code>cmd/6a</code>
-and <code>cmd/8a</code> has had several changes,
-mostly to make it easier to deliver type information to the runtime.
-</p>
-
-<p>
-First, the <code>textflag.h</code> file that defines flags for <code>TEXT</code> directives
-has been copied from the linker source directory to a standard location so it can be
-included with the simple directive
-</p>
-
-<pre>
-#include "textflag.h"
-</pre>
-
-<p>
-The more important changes are in how assembler source can define the necessary
-type information.
-For most programs it will suffice to move data
-definitions (<code>DATA</code> and <code>GLOBL</code> directives)
-out of assembly into Go files
-and to write a Go declaration for each assembly function.
-The <a href="/doc/asm#runtime">assembly document</a> describes what to do.
-</p>
-
-<p>
-<em>Updating</em>:
-Assembly files that include <code>textflag.h</code> from its old
-location will still work, but should be updated.
-For the type information, most assembly routines will need no change,
-but all should be examined.
-Assembly source files that define data,
-functions with non-empty stack frames, or functions that return pointers
-need particular attention.
-A description of the necessary (but simple) changes
-is in the <a href="/doc/asm#runtime">assembly document</a>.
-</p>
-
-<p>
-More information about these changes is in the <a href="/doc/asm">assembly document</a>.
-</p>
-
-<h3 id="gccgo">Status of gccgo</h3>
-
-<p>
-The release schedules for the GCC and Go projects do not coincide.
-GCC release 4.9 contains the Go 1.2 version of gccgo.
-The next release, GCC 5, will likely have the Go 1.4 version of gccgo.
-</p>
-
-<h3 id="internalpackages">Internal packages</h3>
-
-<p>
-Go's package system makes it easy to structure programs into components with clean boundaries,
-but there are only two forms of access: local (unexported) and global (exported).
-Sometimes one wishes to have components that are not exported,
-for instance to avoid acquiring clients of interfaces to code that is part of a public repository
-but not intended for use outside the program to which it belongs.
-</p>
-
-<p>
-The Go language does not have the power to enforce this distinction, but as of Go 1.4 the
-<a href="/cmd/go/"><code>go</code></a> command introduces
-a mechanism to define "internal" packages that may not be imported by packages outside
-the source subtree in which they reside.
-</p>
-
-<p>
-To create such a package, place it in a directory named <code>internal</code> or in a subdirectory of a directory
-named internal.
-When the <code>go</code> command sees an import of a package with <code>internal</code> in its path,
-it verifies that the package doing the import
-is within the tree rooted at the parent of the <code>internal</code> directory.
-For example, a package <code>.../a/b/c/internal/d/e/f</code>
-can be imported only by code in the directory tree rooted at <code>.../a/b/c</code>.
-It cannot be imported by code in <code>.../a/b/g</code> or in any other repository.
-</p>
-
-<p>
-For Go 1.4, the internal package mechanism is enforced for the main Go repository;
-from 1.5 and onward it will be enforced for any repository.
-</p>
-
-<p>
-Full details of the mechanism are in
-<a href="https://golang.org/s/go14internal">the design document</a>.
-</p>
-
-<h3 id="canonicalimports">Canonical import paths</h3>
-
-<p>
-Code often lives in repositories hosted by public services such as <code>github.com</code>,
-meaning that the import paths for packages begin with the name of the hosting service,
-<code>github.com/rsc/pdf</code> for example.
-One can use
-<a href="/cmd/go/#hdr-Remote_import_paths">an existing mechanism</a>
-to provide a "custom" or "vanity" import path such as
-<code>rsc.io/pdf</code>, but
-that creates two valid import paths for the package.
-That is a problem: one may inadvertently import the package through the two
-distinct paths in a single program, which is wasteful;
-miss an update to a package because the path being used is not recognized to be
-out of date;
-or break clients using the old path by moving the package to a different hosting service.
-</p>
-
-<p>
-Go 1.4 introduces an annotation for package clauses in Go source that identify a canonical
-import path for the package.
-If an import is attempted using a path that is not canonical,
-the <a href="/cmd/go/"><code>go</code></a> command
-will refuse to compile the importing package.
-</p>
-
-<p>
-The syntax is simple: put an identifying comment on the package line.
-For our example, the package clause would read:
-</p>
-
-<pre>
-package pdf // import "rsc.io/pdf"
-</pre>
-
-<p>
-With this in place,
-the <code>go</code> command will
-refuse to compile a package that imports <code>github.com/rsc/pdf</code>, 
-ensuring that the code can be moved without breaking users.
-</p>
-
-<p>
-The check is at build time, not download time, so if <code>go</code> <code>get</code>
-fails because of this check, the mis-imported package has been copied to the local machine
-and should be removed manually.
-</p>
-
-<p>
-To complement this new feature, a check has been added at update time to verify
-that the local package's remote repository matches that of its custom import.
-The <code>go</code> <code>get</code> <code>-u</code> command will fail to
-update a package if its remote repository has changed since it was first
-downloaded.
-The new <code>-f</code> flag overrides this check.
-</p>
-
-<p>
-Further information is in
-<a href="https://golang.org/s/go14customimport">the design document</a>.
-</p>
-
-<h3 id="subrepo">Import paths for the subrepositories</h3>
-
-<p>
-The Go project subrepositories (<code>code.google.com/p/go.tools</code> and so on)
-are now available under custom import paths replacing <code>code.google.com/p/go.</code> with <code>golang.org/x/</code>,
-as in <code>golang.org/x/tools</code>.
-We will add canonical import comments to the code around June 1, 2015,
-at which point Go 1.4 and later will stop accepting the old <code>code.google.com</code> paths.
-</p>
-
-<p>
-<em>Updating</em>: All code that imports from subrepositories should change
-to use the new <code>golang.org</code> paths.
-Go 1.0 and later can resolve and import the new paths, so updating will not break
-compatibility with older releases.
-Code that has not updated will stop compiling with Go 1.4 around June 1, 2015.
-</p>
-
-<h3 id="gogenerate">The go generate subcommand</h3>
-
-<p>
-The <a href="/cmd/go/"><code>go</code></a> command has a new subcommand,
-<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go generate</code></a>,
-to automate the running of tools to generate source code before compilation.
-For example, it can be used to run the <a href="/cmd/yacc"><code>yacc</code></a>
-compiler-compiler on a <code>.y</code> file to produce the Go source file implementing the grammar,
-or to automate the generation of <code>String</code> methods for typed constants using the new
-<a href="https://godoc.org/golang.org/x/tools/cmd/stringer">stringer</a>
-tool in the <code>golang.org/x/tools</code> subrepository.
-</p>
-
-<p>
-For more information, see the 
-<a href="https://golang.org/s/go1.4-generate">design document</a>.
-</p>
-
-<h3 id="filenames">Change to file name handling</h3>
-
-<p>
-Build constraints, also known as build tags, control compilation by including or excluding files
-(see the documentation <a href="/pkg/go/build/"><code>/go/build</code></a>).
-Compilation can also be controlled by the name of the file itself by "tagging" the file with
-a suffix (before the <code>.go</code> or <code>.s</code> extension) with an underscore
-and the name of the architecture or operating system.
-For instance, the file <code>gopher_arm.go</code> will only be compiled if the target
-processor is an ARM.
-</p>
-
-<p>
-Before Go 1.4, a file called just <code>arm.go</code> was similarly tagged, but this behavior
-can break sources when new architectures are added, causing files to suddenly become tagged.
-In 1.4, therefore, a file will be tagged in this manner only if the tag (architecture or operating
-system name) is preceded by an underscore.
-</p>
-
-<p>
-<em>Updating</em>: Packages that depend on the old behavior will no longer compile correctly.
-Files with names like <code>windows.go</code> or <code>amd64.go</code> should either
-have explicit build tags added to the source or be renamed to something like
-<code>os_windows.go</code> or <code>support_amd64.go</code>.
-</p>
-
-<h3 id="gocmd">Other changes to the go command</h3>
-
-<p>
-There were a number of minor changes to the
-<a href="/cmd/go/"><code>cmd/go</code></a>
-command worth noting.
-</p>
-
-<ul>
-
-<li>
-Unless <a href="/cmd/cgo/"><code>cgo</code></a> is being used to build the package,
-the <code>go</code> command now refuses to compile C source files,
-since the relevant C compilers
-(<a href="/cmd/6c/"><code>6c</code></a> etc.)
-are intended to be removed from the installation in some future release.
-(They are used today only to build part of the runtime.)
-It is difficult to use them correctly in any case, so any extant uses are likely incorrect,
-so we have disabled them.
-</li>
-
-<li>
-The <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>test</code></a>
-subcommand has a new flag, <code>-o</code>, to set the name of the resulting binary,
-corresponding to the same flag in other subcommands.
-The non-functional <code>-file</code> flag has been removed.
-</li>
-
-<li>
-The <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>test</code></a>
-subcommand will compile and link all <code>*_test.go</code> files in the package,
-even when there are no <code>Test</code> functions in them. 
-It previously ignored such files.
-</li>
-
-<li>
-The behavior of the
-<a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>build</code></a>
-subcommand's
-<code>-a</code> flag has been changed for non-development installations.
-For installations running a released distribution, the <code>-a</code> flag will no longer
-rebuild the standard library and commands, to avoid overwriting the installation's files.
-</li>
-
-</ul>
-
-<h3 id="pkg">Changes to package source layout</h3>
-
-<p>
-In the main Go source repository, the source code for the packages was kept in
-the directory <code>src/pkg</code>, which made sense but differed from
-other repositories, including the Go subrepositories.
-In Go 1.4, the<code> pkg</code> level of the source tree is now gone, so for example
-the <a href="/pkg/fmt/"><code>fmt</code></a> package's source, once kept in
-directory <code>src/pkg/fmt</code>, now lives one level higher in <code>src/fmt</code>.
-</p>
-
-<p>
-<em>Updating</em>: Tools like <code>godoc</code> that discover source code
-need to know about the new location. All tools and services maintained by the Go team
-have been updated.
-</p>
-
-
-<h3 id="swig">SWIG</h3>
-
-<p>
-Due to runtime changes in this release, Go 1.4 requires SWIG 3.0.3.
-</p>
-
-<h3 id="misc">Miscellany</h3>
-
-<p>
-The standard repository's top-level <code>misc</code> directory used to contain
-Go support for editors and IDEs: plugins, initialization scripts and so on.
-Maintaining these was becoming time-consuming
-and needed external help because many of the editors listed were not used by
-members of the core team.
-It also required us to make decisions about which plugin was best for a given
-editor, even for editors we do not use.
-</p>
-
-<p>
-The Go community at large is much better suited to managing this information.
-In Go 1.4, therefore, this support has been removed from the repository.
-Instead, there is a curated, informative list of what's available on
-a <a href="//golang.org/wiki/IDEsAndTextEditorPlugins">wiki page</a>.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-Most programs will run about the same speed or slightly faster in 1.4 than in 1.3;
-some will be slightly slower.
-There are many changes, making it hard to be precise about what to expect.
-</p>
-
-<p>
-As mentioned above, much of the runtime was translated to Go from C,
-which led to some reduction in heap sizes.
-It also improved performance slightly because the Go compiler is better
-at optimization, due to things like inlining, than the C compiler used to build
-the runtime.
-</p>
-
-<p>
-The garbage collector was sped up, leading to measurable improvements for
-garbage-heavy programs.
-On the other hand, the new write barriers slow things down again, typically
-by about the same amount but, depending on their behavior, some programs
-may be somewhat slower or faster.
-</p>
-
-<p>
-Library changes that affect performance are documented below.
-</p>
-
-<h2 id="library">Changes to the standard library</h2>
-
-<h3 id="new_packages">New packages</h3>
-
-<p>
-There are no new packages in this release.
-</p>
-
-<h3 id="major_library_changes">Major changes to the library</h3>
-
-<h4 id="scanner">bufio.Scanner</h4>
-
-<p>
-The <a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type in the
-<a href="/pkg/bufio/"><code>bufio</code></a> package
-has had a bug fixed that may require changes to custom
-<a href="/pkg/bufio/#SplitFunc"><code>split functions</code></a>. 
-The bug made it impossible to generate an empty token at EOF; the fix
-changes the end conditions seen by the split function.
-Previously, scanning stopped at EOF if there was no more data.
-As of 1.4, the split function will be called once at EOF after input is exhausted,
-so the split function can generate a final empty token
-as the documentation already promised.
-</p>
-
-<p>
-<em>Updating</em>: Custom split functions may need to be modified to
-handle empty tokens at EOF as desired.
-</p>
-
-<h4 id="syscall">syscall</h4>
-
-<p>
-The <a href="/pkg/syscall/"><code>syscall</code></a> package is now frozen except
-for changes needed to maintain the core repository.
-In particular, it will no longer be extended to support new or different system calls
-that are not used by the core.
-The reasons are described at length in <a href="https://golang.org/s/go1.4-syscall">a
-separate document</a>.
-</p>
-
-<p>
-A new subrepository, <a href="https://golang.org/x/sys">golang.org/x/sys</a>,
-has been created to serve as the location for new developments to support system
-calls on all kernels.
-It has a nicer structure, with three packages that each hold the implementation of
-system calls for one of
-<a href="https://godoc.org/golang.org/x/sys/unix">Unix</a>,
-<a href="https://godoc.org/golang.org/x/sys/windows">Windows</a> and
-<a href="https://godoc.org/golang.org/x/sys/plan9">Plan 9</a>.
-These packages will be curated more generously, accepting all reasonable changes
-that reflect kernel interfaces in those operating systems.
-See the documentation and the article mentioned above for more information.
-</p>
-
-<p>
-<em>Updating</em>: Existing programs are not affected as the <code>syscall</code>
-package is largely unchanged from the 1.3 release.
-Future development that requires system calls not in the <code>syscall</code> package
-should build on <code>golang.org/x/sys</code> instead.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-The following list summarizes a number of minor changes to the library, mostly additions.
-See the relevant package documentation for more information about each change.
-</p>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package's
-<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> now supports a
-<a href="/pkg/archive/zip/#Writer.Flush"><code>Flush</code></a> method.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
-and <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a>
-packages now support a <code>Reset</code> method
-for the decompressors, allowing them to reuse buffers and improve performance.
-The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package also has a
-<a href="/pkg/compress/gzip/#Reader.Multistream"><code>Multistream</code></a> method to control support
-for multistream files.
-</li>
-
-<li>
-The <a href="/pkg/crypto/"><code>crypto</code></a> package now has a
-<a href="/pkg/crypto/#Signer"><code>Signer</code></a> interface, implemented by the
-<code>PrivateKey</code> types in
-<a href="/pkg/crypto/ecdsa"><code>crypto/ecdsa</code></a> and
-<a href="/pkg/crypto/rsa"><code>crypto/rsa</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports ALPN as defined in <a href="https://tools.ietf.org/html/rfc7301">RFC 7301</a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports programmatic selection of server certificates
-through the new <a href="/pkg/crypto/tls/#Config.CertificateForName"><code>CertificateForName</code></a> function
-of the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> struct.
-</li>
-
-<li>
-Also in the crypto/tls package, the server now supports 
-<a href="https://tools.ietf.org/html/draft-ietf-tls-downgrade-scsv-00">TLS_FALLBACK_SCSV</a>
-to help clients detect fallback attacks.
-(The Go client does not support fallback at all, so it is not vulnerable to
-those attacks.)
-</li>
-
-<li>
-The <a href="/pkg/database/sql/"><code>database/sql</code></a> package can now list all registered
-<a href="/pkg/database/sql/#Drivers"><code>Drivers</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a> package now supports
-<a href="/pkg/debug/dwarf/#UnspecifiedType"><code>UnspecifiedType</code></a>s.
-</li>
-
-<li>
-In the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
-optional elements with a default value will now only be omitted if they have that value.
-</li>
-
-<li>
-The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package no longer
-quotes empty strings but does quote the end-of-data marker <code>\.</code> (backslash dot).
-This is permitted by the definition of CSV and allows it to work better with Postgres.
-</li>
-
-<li>
-The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> package has been rewritten to eliminate
-the use of unsafe operations, allowing it to be used in environments that do not permit use of the
-<a href="/pkg/unsafe/"><code>unsafe</code></a> package.
-For typical uses it will be 10-30% slower, but the delta is dependent on the type of the data and
-in some cases, especially involving arrays, it can be faster.
-There is no functional change.
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
-<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> can now report its input offset.
-</li>
-
-<li>
-In the <a href="/pkg/fmt/"><code>fmt</code></a> package,
-formatting of pointers to maps has changed to be consistent with that of pointers
-to structs, arrays, and so on.
-For instance, <code>&amp;map[string]int{"one":</code> <code>1}</code> now prints by default as
-<code>&amp;map[one:</code> <code>1]</code> rather than as a hexadecimal pointer value.
-</li>
-
-<li>
-The <a href="/pkg/image/"><code>image</code></a> package's
-<a href="/pkg/image/#Image"><code>Image</code></a>
-implementations like
-<a href="/pkg/image/#RGBA"><code>RGBA</code></a> and
-<a href="/pkg/image/#Gray"><code>Gray</code></a> have specialized
-<a href="/pkg/image/#RGBA.RGBAAt"><code>RGBAAt</code></a> and
-<a href="/pkg/image/#Gray.GrayAt"><code>GrayAt</code></a> methods alongside the general
-<a href="/pkg/image/#Image.At"><code>At</code></a> method.
-</li>
-
-<li>
-The <a href="/pkg/image/png/"><code>image/png</code></a> package now has an
-<a href="/pkg/image/png/#Encoder"><code>Encoder</code></a>
-type to control the compression level used for encoding.
-</li>
-
-<li>
-The <a href="/pkg/math/"><code>math</code></a> package now has a
-<a href="/pkg/math/#Nextafter32"><code>Nextafter32</code><a/> function.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#Request"><code>Request</code></a> type
-has a new <a href="/pkg/net/http/#Request.BasicAuth"><code>BasicAuth</code></a> method
-that returns the username and password from authenticated requests using the
-HTTP Basic Authentication
-Scheme.
-</li>
-
-<li>The <a href="/pkg/net/http/"><code>net/http</code></a> package's
-<a href="/pkg/net/http/#Request"><code>Transport</code></a> type
-has a new <a href="/pkg/net/http/#Transport.DialTLS"><code>DialTLS</code></a> hook
-that allows customizing the behavior of outbound TLS connections.
-</li>
-
-<li>
-The <a href="/pkg/net/http/httputil/"><code>net/http/httputil</code></a> package's
-<a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> type
-has a new field,
-<a href="/pkg/net/http/#ReverseProxy.ErrorLog"><code>ErrorLog</code></a>, that
-provides user control of logging.
-</li>
-
-<li>
-The <a href="/pkg/os/"><code>os</code></a> package
-now implements symbolic links on the Windows operating system
-through the <a href="/pkg/os/#Symlink"><code>Symlink</code></a> function.
-Other operating systems already have this functionality.
-There is also a new <a href="/pkg/os/#Unsetenv"><code>Unsetenv</code></a> function.
-</li>
-
-<li>
-The <a href="/pkg/reflect/"><code>reflect</code></a> package's
-<a href="/pkg/reflect/#Type"><code>Type</code></a> interface
-has a new method, <a href="/pkg/reflect/#type.Comparable"><code>Comparable</code></a>,
-that reports whether the type implements general comparisons.
-</li>
-
-<li>
-Also in the <a href="/pkg/reflect/"><code>reflect</code></a> package, the
-<a href="/pkg/reflect/#Value"><code>Value</code></a> interface is now three instead of four words
-because of changes to the implementation of interfaces in the runtime.
-This saves memory but has no semantic effect.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package
-now implements monotonic clocks on Windows,
-as it already did for the other systems.
-</li>
-
-<li>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package's
-<a href="/pkg/runtime/#MemStats.Mallocs"><code>Mallocs</code></a> counter
-now counts very small allocations that were missed in Go 1.3.
-This may break tests using <a href="/pkg/runtime/#ReadMemStats"><code>ReadMemStats</code></a>
-or <a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a>
-due to the more accurate answer.
-</li>
-
-<li>
-In the <a href="/pkg/runtime/"><code>runtime</code></a> package,
-an array <a href="/pkg/runtime/#MemStats.PauseEnd"><code>PauseEnd</code></a>
-has been added to the
-<a href="/pkg/runtime/#MemStats"><code>MemStats</code></a>
-and <a href="/pkg/runtime/#GCStats"><code>GCStats</code></a> structs.
-This array is a circular buffer of times when garbage collection pauses ended.
-The corresponding pause durations are already recorded in
-<a href="/pkg/runtime/#MemStats.PauseNs"><code>PauseNs</code></a>
-</li>
-
-<li>
-The <a href="/pkg/runtime/race/"><code>runtime/race</code></a> package
-now supports FreeBSD, which means the
-<a href="/pkg/cmd/go/"><code>go</code></a> command's <code>-race</code>
-flag now works on FreeBSD.
-</li>
-
-<li>
-The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package
-has a new type, <a href="/pkg/sync/atomic/#Value"><code>Value</code></a>.
-<code>Value</code> provides an efficient mechanism for atomic loads and
-stores of values of arbitrary type.
-</li>
-
-<li>
-In the <a href="/pkg/syscall/"><code>syscall</code></a> package's
-implementation on Linux, the
-<a href="/pkg/syscall/#Setuid"><code>Setuid</code></a>
-and <a href="/pkg/syscall/#Setgid"><code>Setgid</code></a> have been disabled
-because those system calls operate on the calling thread, not the whole process, which is
-different from other platforms and not the expected result.
-</li>
-
-<li>
-The <a href="/pkg/testing/"><code>testing</code></a> package
-has a new facility to provide more control over running a set of tests.
-If the test code contains a function
-<pre>
-func TestMain(m *<a href="/pkg/testing/#M"><code>testing.M</code></a>) 
-</pre>
-
-that function will be called instead of running the tests directly.
-The <code>M</code> struct contains methods to access and run the tests.
-</li>
-
-<li>
-Also in the <a href="/pkg/testing/"><code>testing</code></a> package,
-a new <a href="/pkg/testing/#Coverage"><code>Coverage</code></a>
-function reports the current test coverage fraction,
-enabling individual tests to report how much they are contributing to the
-overall coverage.
-</li>
-
-<li>
-The <a href="/pkg/text/scanner/"><code>text/scanner</code></a> package's
-<a href="/pkg/text/scanner/#Scanner"><code>Scanner</code></a> type
-has a new function,
-<a href="/pkg/text/scanner/#Scanner.IsIdentRune"><code>IsIdentRune</code></a>,
-allowing one to control the definition of an identifier when scanning.
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package's boolean
-functions <code>eq</code>, <code>lt</code>, and so on have been generalized to allow comparison
-of signed and unsigned integers, simplifying their use in practice.
-(Previously one could only compare values of the same signedness.)
-All negative values compare less than all unsigned values.
-</li>
-
-<li>
-The <code>time</code> package now uses the standard symbol for the micro prefix,
-the micro symbol (U+00B5 'µ'), to print microsecond durations.
-<a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> still accepts <code>us</code>
-but the package no longer prints microseconds as <code>us</code>.
-<br>
-<em>Updating</em>: Code that depends on the output format of durations
-but does not use ParseDuration will need to be updated.
-</li>
-
-</ul>

doc/go1.6.html

@@ -1,923 +0,0 @@
-<!--{
-	"Title": "Go 1.6 Release Notes",
-	"Path":  "/doc/go1.6",
-	"Template": true
-}-->
-
-<!--
-Edit .,s;^PKG:([a-z][A-Za-z0-9_/]+);<a href="/pkg/\1/"><code>\1</code></a>;g
-Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',]|$);<a href="/pkg/\1/#\2\3"><code>\3</code></a>\4;g
--->
-
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.6</h2>
-
-<p>
-The latest Go release, version 1.6, arrives six months after 1.5.
-Most of its changes are in the implementation of the language, runtime, and libraries.
-There are no changes to the language specification.
-As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-The release adds new ports to <a href="#ports">Linux on 64-bit MIPS and Android on 32-bit x86</a>;
-defined and enforced <a href="#cgo">rules for sharing Go pointers with C</a>;
-transparent, automatic <a href="#http2">support for HTTP/2</a>;
-and a new mechanism for <a href="#template">template reuse</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-There are no language changes in this release.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-Go 1.6 adds experimental ports to
-Linux on 64-bit MIPS (<code>linux/mips64</code> and <code>linux/mips64le</code>).
-These ports support <code>cgo</code> but only with internal linking.
-</p>
-
-<p>
-Go 1.6 also adds an experimental port to Android on 32-bit x86 (<code>android/386</code>).
-</p>
-
-<p>
-On FreeBSD, Go 1.6 defaults to using <code>clang</code>, not <code>gcc</code>, as the external C compiler.
-</p>
-
-<p>
-On Linux on little-endian 64-bit PowerPC (<code>linux/ppc64le</code>),
-Go 1.6 now supports <code>cgo</code> with external linking and
-is roughly feature complete.
-</p>
-
-<p>
-On NaCl, Go 1.5 required SDK version pepper-41.
-Go 1.6 adds support for later SDK versions.
-</p>
-
-<p>
-On 32-bit x86 systems using the <code>-dynlink</code> or <code>-shared</code> compilation modes,
-the register CX is now overwritten by certain memory references and should
-be avoided in hand-written assembly.
-See the <a href="/doc/asm#x86">assembly documentation</a> for details.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-There is one major change to <a href="/cmd/cgo/"><code>cgo</code></a>, along with one minor change.
-</p>
-
-<p>
-The major change is the definition of rules for sharing Go pointers with C code,
-to ensure that such C code can coexist with Go's garbage collector.
-Briefly, Go and C may share memory allocated by Go
-when a pointer to that memory is passed to C as part of a <code>cgo</code> call,
-provided that the memory itself contains no pointers to Go-allocated memory,
-and provided that C does not retain the pointer after the call returns.
-These rules are checked by the runtime during program execution:
-if the runtime detects a violation, it prints a diagnosis and crashes the program.
-The checks can be disabled by setting the environment variable
-<code>GODEBUG=cgocheck=0</code>, but note that the vast majority of
-code identified by the checks is subtly incompatible with garbage collection
-in one way or another.
-Disabling the checks will typically only lead to more mysterious failure modes.
-Fixing the code in question should be strongly preferred
-over turning off the checks.
-See the <a href="/cmd/cgo/#hdr-Passing_pointers"><code>cgo</code> documentation</a> for more details.
-</p>
-
-<p>
-The minor change is
-the addition of explicit <code>C.complexfloat</code> and <code>C.complexdouble</code> types,
-separate from Go's <code>complex64</code> and <code>complex128</code>.
-Matching the other numeric types, C's complex types and Go's complex type are
-no longer interchangeable.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p>
-The compiler toolchain is mostly unchanged.
-Internally, the most significant change is that the parser is now hand-written
-instead of generated from <a href="/cmd/yacc/">yacc</a>.
-</p>
-
-<p>
-The compiler, linker, and <code>go</code> command have a new flag <code>-msan</code>,
-analogous to <code>-race</code> and only available on linux/amd64,
-that enables interoperation with the <a href="https://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
-Such interoperation is useful mainly for testing a program containing suspect C or C++ code.
-</p>
-
-<p>
-The linker has a new option <code>-libgcc</code> to set the expected location
-of the C compiler support library when linking <a href="/cmd/cgo/"><code>cgo</code></a> code.
-The option is only consulted when using <code>-linkmode=internal</code>,
-and it may be set to <code>none</code> to disable the use of a support library.
-</p>
-
-<p>
-The implementation of <a href="/doc/go1.5#link">build modes started in Go 1.5</a> has been expanded to more systems.
-This release adds support for the <code>c-shared</code> mode on <code>android/386</code>, <code>android/amd64</code>,
-<code>android/arm64</code>, <code>linux/386</code>, and <code>linux/arm64</code>;
-for the <code>shared</code> mode on <code>linux/386</code>, <code>linux/arm</code>, <code>linux/amd64</code>, and <code>linux/ppc64le</code>;
-and for the new <code>pie</code> mode (generating position-independent executables) on
-<code>android/386</code>, <code>android/amd64</code>, <code>android/arm</code>, <code>android/arm64</code>, <code>linux/386</code>,
-<code>linux/amd64</code>, <code>linux/arm</code>, <code>linux/arm64</code>, and <code>linux/ppc64le</code>.
-See the <a href="https://golang.org/s/execmodes">design document</a> for details.
-</p>
-
-<p>
-As a reminder, the linker's <code>-X</code> flag changed in Go 1.5.
-In Go 1.4 and earlier, it took two arguments, as in
-</p>
-
-<pre>
--X importpath.name value
-</pre>
-
-<p>
-Go 1.5 added an alternative syntax using a single argument
-that is itself a <code>name=value</code> pair:
-</p>
-
-<pre>
--X importpath.name=value
-</pre>
-
-<p>
-In Go 1.5 the old syntax was still accepted, after printing a warning
-suggesting use of the new syntax instead.
-Go 1.6 continues to accept the old syntax and print the warning.
-Go 1.7 will remove support for the old syntax.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-The release schedules for the GCC and Go projects do not coincide.
-GCC release 5 contains the Go 1.4 version of gccgo.
-The next release, GCC 6, will have the Go 1.6.1 version of gccgo.
-</p>
-
-<h3 id="go_command">Go command</h3>
-
-<p>
-The <a href="/cmd/go"><code>go</code></a> command's basic operation
-is unchanged, but there are a number of changes worth noting.
-</p>
-
-<p>
-Go 1.5 introduced experimental support for vendoring,
-enabled by setting the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>1</code>.
-Go 1.6 keeps the vendoring support, no longer considered experimental,
-and enables it by default.
-It can be disabled explicitly by setting
-the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>0</code>.
-Go 1.7 will remove support for the environment variable.
-</p>
-
-<p>
-The most likely problem caused by enabling vendoring by default happens
-in source trees containing an existing directory named <code>vendor</code> that
-does not expect to be interpreted according to new vendoring semantics.
-In this case, the simplest fix is to rename the directory to anything other
-than <code>vendor</code> and update any affected import paths.
-</p>
-
-<p>
-For details about vendoring,
-see the documentation for the <a href="/cmd/go/#hdr-Vendor_Directories"><code>go</code> command</a>
-and the <a href="https://golang.org/s/go15vendor">design document</a>.
-</p>
-
-<p>
-There is a new build flag, <code>-msan</code>,
-that compiles Go with support for the LLVM memory sanitizer.
-This is intended mainly for use when linking against C or C++ code
-that is being checked with the memory sanitizer.
-</p>
-
-<h3 id="doc_command">Go doc command</h3>
-
-<p>
-Go 1.5 introduced the
-<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go doc</code></a> command,
-which allows references to packages using only the package name, as in
-<code>go</code> <code>doc</code> <code>http</code>.
-In the event of ambiguity, the Go 1.5 behavior was to use the package
-with the lexicographically earliest import path.
-In Go 1.6, ambiguity is resolved by preferring import paths with
-fewer elements, breaking ties using lexicographic comparison.
-An important effect of this change is that original copies of packages
-are now preferred over vendored copies.
-Successful searches also tend to run faster.
-</p>
-
-<h3 id="vet_command">Go vet command</h3>
-
-<p>
-The <a href="/cmd/vet"><code>go vet</code></a> command now diagnoses
-passing function or method values as arguments to <code>Printf</code>,
-such as when passing <code>f</code> where <code>f()</code> was intended.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise statements
-about performance are difficult to make.
-Some programs may run faster, some slower.
-On average the programs in the Go 1 benchmark suite run a few percent faster in Go 1.6
-than they did in Go 1.5.
-The garbage collector's pauses are even lower than in Go 1.5,
-especially for programs using
-a large amount of memory.
-</p>
-
-<p>
-There have been significant optimizations bringing more than 10% improvements
-to implementations of the
-<a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
-<a href="/pkg/crypto/aes/"><code>crypto/aes</code></a>,
-<a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a>,
-<a href="/pkg/crypto/ecdsa/"><code>crypto/ecdsa</code></a>, and
-<a href="/pkg/sort/"><code>sort</code></a> packages.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="http2">HTTP/2</h3>
-
-<p>
-Go 1.6 adds transparent support in the
-<a href="/pkg/net/http/"><code>net/http</code></a> package
-for the new <a href="https://http2.github.io/">HTTP/2 protocol</a>.
-Go clients and servers will automatically use HTTP/2 as appropriate when using HTTPS.
-There is no exported API specific to details of the HTTP/2 protocol handling,
-just as there is no exported API specific to HTTP/1.1.
-</p>
-
-<p>
-Programs that must disable HTTP/2 can do so by setting
-<a href="/pkg/net/http/#Transport"><code>Transport.TLSNextProto</code></a> (for clients)
-or
-<a href="/pkg/net/http/#Server"><code>Server.TLSNextProto</code></a> (for servers)
-to a non-nil, empty map.
-</p>
-
-<p>
-Programs that must adjust HTTP/2 protocol-specific details can import and use
-<a href="https://golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a>,
-in particular its
-<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureServer">ConfigureServer</a>
-and
-<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureTransport">ConfigureTransport</a>
-functions.
-</p>
-
-<h3 id="runtime">Runtime</h3>
-
-<p>
-The runtime has added lightweight, best-effort detection of concurrent misuse of maps.
-As always, if one goroutine is writing to a map, no other goroutine should be
-reading or writing the map concurrently.
-If the runtime detects this condition, it prints a diagnosis and crashes the program.
-The best way to find out more about the problem is to run the program
-under the
-<a href="https://blog.golang.org/race-detector">race detector</a>,
-which will more reliably identify the race
-and give more detail.
-</p>
-
-<p>
-For program-ending panics, the runtime now by default
-prints only the stack of the running goroutine,
-not all existing goroutines.
-Usually only the current goroutine is relevant to a panic,
-so omitting the others significantly reduces irrelevant output
-in a crash message.
-To see the stacks from all goroutines in crash messages, set the environment variable
-<code>GOTRACEBACK</code> to <code>all</code>
-or call
-<a href="/pkg/runtime/debug/#SetTraceback"><code>debug.SetTraceback</code></a>
-before the crash, and rerun the program.
-See the <a href="/pkg/runtime/#hdr-Environment_Variables">runtime documentation</a> for details.
-</p>
-
-<p>
-<em>Updating</em>:
-Uncaught panics intended to dump the state of the entire program,
-such as when a timeout is detected or when explicitly handling a received signal,
-should now call <code>debug.SetTraceback("all")</code> before panicking.
-Searching for uses of
-<a href="/pkg/os/signal/#Notify"><code>signal.Notify</code></a> may help identify such code.
-</p>
-
-<p>
-On Windows, Go programs in Go 1.5 and earlier forced
-the global Windows timer resolution to 1ms at startup
-by calling <code>timeBeginPeriod(1)</code>.
-Go no longer needs this for good scheduler performance,
-and changing the global timer resolution caused problems on some systems,
-so the call has been removed.
-</p>
-
-<p>
-When using <code>-buildmode=c-archive</code> or
-<code>-buildmode=c-shared</code> to build an archive or a shared
-library, the handling of signals has changed.
-In Go 1.5 the archive or shared library would install a signal handler
-for most signals.
-In Go 1.6 it will only install a signal handler for the
-synchronous signals needed to handle run-time panics in Go code:
-SIGBUS, SIGFPE, SIGSEGV.
-See the <a href="/pkg/os/signal">os/signal</a> package for more
-details.
-</p>
-
-<h3 id="reflect">Reflect</h3>
-
-<p>
-The
-<a href="/pkg/reflect/"><code>reflect</code></a> package has
-<a href="https://golang.org/issue/12367">resolved a long-standing incompatibility</a>
-between the gc and gccgo toolchains
-regarding embedded unexported struct types containing exported fields.
-Code that walks data structures using reflection, especially to implement
-serialization in the spirit
-of the
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages,
-may need to be updated.
-</p>
-
-<p>
-The problem arises when using reflection to walk through
-an embedded unexported struct-typed field
-into an exported field of that struct.
-In this case, <code>reflect</code> had incorrectly reported
-the embedded field as exported, by returning an empty <code>Field.PkgPath</code>.
-Now it correctly reports the field as unexported
-but ignores that fact when evaluating access to exported fields
-contained within the struct.
-</p>
-
-<p>
-<em>Updating</em>:
-Typically, code that previously walked over structs and used
-</p>
-
-<pre>
-f.PkgPath != ""
-</pre>
-
-<p>
-to exclude inaccessible fields
-should now use
-</p>
-
-<pre>
-f.PkgPath != "" &amp;&amp; !f.Anonymous
-</pre>
-
-<p>
-For example, see the changes to the implementations of
-<a href="https://go-review.googlesource.com/#/c/14011/2/src/encoding/json/encode.go"><code>encoding/json</code></a> and
-<a href="https://go-review.googlesource.com/#/c/14012/2/src/encoding/xml/typeinfo.go"><code>encoding/xml</code></a>.
-</p>
-
-<h3 id="sort">Sorting</h3>
-
-<p>
-In the
-<a href="/pkg/sort/"><code>sort</code></a>
-package,
-the implementation of
-<a href="/pkg/sort/#Sort"><code>Sort</code></a>
-has been rewritten to make about 10% fewer calls to the
-<a href="/pkg/sort/#Interface"><code>Interface</code></a>'s
-<code>Less</code> and <code>Swap</code>
-methods, with a corresponding overall time savings.
-The new algorithm does choose a different ordering than before
-for values that compare equal (those pairs for which <code>Less(i,</code> <code>j)</code> and <code>Less(j,</code> <code>i)</code> are false).
-</p>
-
-<p>
-<em>Updating</em>:
-The definition of <code>Sort</code> makes no guarantee about the final order of equal values,
-but the new behavior may still break programs that expect a specific order.
-Such programs should either refine their <code>Less</code> implementations
-to report the desired order
-or should switch to
-<a href="/pkg/sort/#Stable"><code>Stable</code></a>,
-which preserves the original input order
-of equal values.
-</p>
-
-<h3 id="template">Templates</h3>
-
-<p>
-In the
-<a href="/pkg/text/template/">text/template</a> package,
-there are two significant new features to make writing templates easier.
-</p>
-
-<p>
-First, it is now possible to <a href="/pkg/text/template/#hdr-Text_and_spaces">trim spaces around template actions</a>,
-which can make template definitions more readable.
-A minus sign at the beginning of an action says to trim space before the action,
-and a minus sign at the end of an action says to trim space after the action.
-For example, the template
-</p>
-
-<pre>
-{{"{{"}}23 -}}
-   &lt;
-{{"{{"}}- 45}}
-</pre>
-
-<p>
-formats as <code>23&lt;45</code>.
-</p>
-
-<p>
-Second, the new <a href="/pkg/text/template/#hdr-Actions"><code>{{"{{"}}block}}</code> action</a>,
-combined with allowing redefinition of named templates,
-provides a simple way to define pieces of a template that
-can be replaced in different instantiations.
-There is <a href="/pkg/text/template/#example_Template_block">an example</a>
-in the <code>text/template</code> package that demonstrates this new feature.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/tar/"><code>archive/tar</code></a> package's
-implementation corrects many bugs in rare corner cases of the file format.
-One visible change is that the
-<a href="/pkg/archive/tar/#Reader"><code>Reader</code></a> type's
-<a href="/pkg/archive/tar/#Reader.Read"><code>Read</code></a> method
-now presents the content of special file types as being empty,
-returning <code>io.EOF</code> immediately.
-</li>
-
-<li>
-In the <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package, the
-<a href="/pkg/archive/zip/#Reader"><code>Reader</code></a> type now has a
-<a href="/pkg/archive/zip/#Reader.RegisterDecompressor"><code>RegisterDecompressor</code></a> method,
-and the
-<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> type now has a
-<a href="/pkg/archive/zip/#Writer.RegisterCompressor"><code>RegisterCompressor</code></a> method,
-enabling control over compression options for individual zip files.
-These take precedence over the pre-existing global
-<a href="/pkg/archive/zip/#RegisterDecompressor"><code>RegisterDecompressor</code></a> and
-<a href="/pkg/archive/zip/#RegisterCompressor"><code>RegisterCompressor</code></a> functions.
-</li>
-
-<li>
-The <a href="/pkg/bufio/"><code>bufio</code></a> package's
-<a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type now has a
-<a href="/pkg/bufio/#Scanner.Buffer"><code>Buffer</code></a> method,
-to specify an initial buffer and maximum buffer size to use during scanning.
-This makes it possible, when needed, to scan tokens larger than
-<code>MaxScanTokenSize</code>.
-Also for the <code>Scanner</code>, the package now defines the
-<a href="/pkg/bufio/#ErrFinalToken"><code>ErrFinalToken</code></a> error value, for use by
-<a href="/pkg/bufio/#SplitFunc">split functions</a> to abort processing or to return a final empty token.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a> package
-has deprecated its
-<a href="/pkg/compress/flate/#ReadError"><code>ReadError</code></a> and
-<a href="/pkg/compress/flate/#WriteError"><code>WriteError</code></a> error implementations.
-In Go 1.5 they were only rarely returned when an error was encountered;
-now they are never returned, although they remain defined for compatibility.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>, and
-<a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> packages
-now report
-<a href="/pkg/io/#ErrUnexpectedEOF"><code>io.ErrUnexpectedEOF</code></a> for truncated input streams, instead of
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package now
-overwrites the destination buffer in the event of a GCM decryption failure.
-This is to allow the AESNI code to avoid using a temporary buffer.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-has a variety of minor changes.
-It now allows
-<a href="/pkg/crypto/tls/#Listen"><code>Listen</code></a>
-to succeed when the
-<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>
-has a nil <code>Certificates</code>, as long as the <code>GetCertificate</code> callback is set,
-it adds support for RSA with AES-GCM cipher suites,
-and
-it adds a
-<a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>
-to allow clients (in particular, the <a href="/pkg/net/http/"><code>net/http</code></a> package)
-to report a better error when attempting a TLS connection to a non-TLS server.
-</li>
-
-<li>
-The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
-now permits certificates to contain negative serial numbers
-(technically an error, but unfortunately common in practice),
-and it defines a new
-<a href="/pkg/crypto/x509/#InsecureAlgorithmError"><code>InsecureAlgorithmError</code></a>
-to give a better error message when rejecting a certificate
-signed with an insecure algorithm like MD5.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf"><code>debug/dwarf</code></a> and
-<a href="/pkg/debug/elf/"><code>debug/elf</code></a> packages
-together add support for compressed DWARF sections.
-User code needs no updating: the sections are decompressed automatically when read.
-</li>
-
-<li>
-The <a href="/pkg/debug/elf/"><code>debug/elf</code></a> package
-adds support for general compressed ELF sections.
-User code needs no updating: the sections are decompressed automatically when read.
-However, compressed
-<a href="/pkg/debug/elf/#Section"><code>Sections</code></a> do not support random access:
-they have a nil <code>ReaderAt</code> field.
-</li>
-
-<li>
-The <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package
-now exports
-<a href="/pkg/encoding/asn1/#pkg-constants">tag and class constants</a>
-useful for advanced parsing of ASN.1 structures.
-</li>
-
-<li>
-Also in the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
-<a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now rejects various non-standard integer and length encodings.
-</li>
-
-<li>
-The <a href="/pkg/encoding/base64"><code>encoding/base64</code></a> package's
-<a href="/pkg/encoding/base64/#Decoder"><code>Decoder</code></a> has been fixed
-to process the final bytes of its input. Previously it processed as many four-byte tokens as
-possible but ignored the remainder, up to three bytes.
-The <code>Decoder</code> therefore now handles inputs in unpadded encodings (like
-<a href="/pkg/encoding/base64/#RawURLEncoding">RawURLEncoding</a>) correctly,
-but it also rejects inputs in padded encodings that are truncated or end with invalid bytes,
-such as trailing spaces.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-now checks the syntax of a
-<a href="/pkg/encoding/json/#Number"><code>Number</code></a>
-before marshaling it, requiring that it conforms to the JSON specification for numeric values.
-As in previous releases, the zero <code>Number</code> (an empty string) is marshaled as a literal 0 (zero).
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
-<a href="/pkg/encoding/xml/#Marshal"><code>Marshal</code></a>
-function now supports a <code>cdata</code> attribute, such as <code>chardata</code>
-but encoding its argument in one or more <code>&lt;![CDATA[ ... ]]&gt;</code> tags.
-</li>
-
-<li>
-Also in the <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package,
-<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a>'s
-<a href="/pkg/encoding/xml/#Decoder.Token"><code>Token</code></a> method
-now reports an error when encountering EOF before seeing all open tags closed,
-consistent with its general requirement that tags in the input be properly matched.
-To avoid that requirement, use
-<a href="/pkg/encoding/xml/#Decoder.RawToken"><code>RawToken</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/fmt/"><code>fmt</code></a> package now allows
-any integer type as an argument to
-<a href="/pkg/fmt/#Printf"><code>Printf</code></a>'s <code>*</code> width and precision specification.
-In previous releases, the argument to <code>*</code> was required to have type <code>int</code>.
-</li>
-
-<li>
-Also in the <a href="/pkg/fmt/"><code>fmt</code></a> package,
-<a href="/pkg/fmt/#Scanf"><code>Scanf</code></a> can now scan hexadecimal strings using %X, as an alias for %x.
-Both formats accept any mix of upper- and lower-case hexadecimal.
-</li>
-
-<li>
-The <a href="/pkg/image/"><code>image</code></a>
-and
-<a href="/pkg/image/color/"><code>image/color</code></a> packages
-add
-<a href="/pkg/image/#NYCbCrA"><code>NYCbCrA</code></a>
-and
-<a href="/pkg/image/color/#NYCbCrA"><code>NYCbCrA</code></a>
-types, to support Y'CbCr images with non-premultiplied alpha.
-</li>
-
-<li>
-The <a href="/pkg/io/"><code>io</code></a> package's
-<a href="/pkg/io/#MultiWriter"><code>MultiWriter</code></a>
-implementation now implements a <code>WriteString</code> method,
-for use by
-<a href="/pkg/io/#WriteString"><code>WriteString</code></a>.
-</li>
-
-<li>
-In the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Int"><code>Int</code></a> adds
-<a href="/pkg/math/big/#Int.Append"><code>Append</code></a>
-and
-<a href="/pkg/math/big/#Int.Text"><code>Text</code></a>
-methods to give more control over printing.
-</li>
-
-<li>
-Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Float"><code>Float</code></a> now implements
-<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>,
-allowing it to be serialized in a natural form by the
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages.
-</li>
-
-<li>
-Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Float"><code>Float</code></a>'s
-<a href="/pkg/math/big/#Float.Append"><code>Append</code></a> method now supports the special precision argument -1.
-As in
-<a href="/pkg/strconv/#ParseFloat"><code>strconv.ParseFloat</code></a>,
-precision -1 means to use the smallest number of digits necessary such that
-<a href="/pkg/math/big/#Float.Parse"><code>Parse</code></a>
-reading the result into a <code>Float</code> of the same precision
-will yield the original value.
-</li>
-
-<li>
-The <a href="/pkg/math/rand/"><code>math/rand</code></a> package
-adds a
-<a href="/pkg/math/rand/#Read"><code>Read</code></a>
-function, and likewise
-<a href="/pkg/math/rand/#Rand"><code>Rand</code></a> adds a
-<a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> method.
-These make it easier to generate pseudorandom test data.
-Note that, like the rest of the package,
-these should not be used in cryptographic settings;
-for such purposes, use the <a href="/pkg/crypto/rand/"><code>crypto/rand</code></a> package instead.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package's
-<a href="/pkg/net/#ParseMAC"><code>ParseMAC</code></a> function now accepts 20-byte IP-over-InfiniBand (IPoIB) link-layer addresses.
-</li>
-
-
-<li>
-Also in the <a href="/pkg/net/"><code>net</code></a> package,
-there have been a few changes to DNS lookups.
-First, the
-<a href="/pkg/net/#DNSError"><code>DNSError</code></a> error implementation now implements
-<a href="/pkg/net/#Error"><code>Error</code></a>,
-and in particular its new
-<a href="/pkg/net/#DNSError.IsTemporary"><code>IsTemporary</code></a>
-method returns true for DNS server errors.
-Second, DNS lookup functions such as
-<a href="/pkg/net/#LookupAddr"><code>LookupAddr</code></a>
-now return rooted domain names (with a trailing dot)
-on Plan 9 and Windows, to match the behavior of Go on Unix systems.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package has
-a number of minor additions beyond the HTTP/2 support already discussed.
-First, the
-<a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> now sorts its generated directory listings by file name.
-Second, the
-<a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> function now refuses to serve a result
-if the request's URL path contains &ldquo;..&rdquo; (dot-dot) as a path element.
-Programs should typically use <code>FileServer</code> and 
-<a href="/pkg/net/http/#Dir"><code>Dir</code></a>
-instead of calling <code>ServeFile</code> directly.
-Programs that need to serve file content in response to requests for URLs containing dot-dot can 
-still call <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>.
-Third, the
-<a href="/pkg/net/http/#Client"><code>Client</code></a> now allows user code to set the
-<code>Expect:</code> <code>100-continue</code> header (see
-<a href="/pkg/net/http/#Transport"><code>Transport.ExpectContinueTimeout</code></a>).
-Fourth, there are
-<a href="/pkg/net/http/#pkg-constants">five new error codes</a>:
-<code>StatusPreconditionRequired</code> (428),
-<code>StatusTooManyRequests</code> (429),
-<code>StatusRequestHeaderFieldsTooLarge</code> (431), and
-<code>StatusNetworkAuthenticationRequired</code> (511) from RFC 6585,
-as well as the recently-approved
-<code>StatusUnavailableForLegalReasons</code> (451).
-Fifth, the implementation and documentation of
-<a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
-has been substantially changed.
-The <a href="/pkg/net/http/#Hijacker"><code>Hijacker</code></a>
-interface now works correctly on connections that have previously
-been used with <code>CloseNotifier</code>.
-The documentation now describes when <code>CloseNotifier</code>
-is expected to work.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
-there are a few changes related to the handling of a
-<a href="/pkg/net/http/#Request"><code>Request</code></a> data structure with its <code>Method</code> field set to the empty string.
-An empty <code>Method</code> field has always been documented as an alias for <code>"GET"</code>
-and it remains so.
-However, Go 1.6 fixes a few routines that did not treat an empty
-<code>Method</code> the same as an explicit <code>"GET"</code>.
-Most notably, in previous releases
-<a href="/pkg/net/http/#Client"><code>Client</code></a> followed redirects only with
-<code>Method</code> set explicitly to <code>"GET"</code>;
-in Go 1.6 <code>Client</code> also follows redirects for the empty <code>Method</code>.
-Finally,
-<a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a> accepts a <code>method</code> argument that has not been
-documented as allowed to be empty.
-In past releases, passing an empty <code>method</code> argument resulted
-in a <code>Request</code> with an empty <code>Method</code> field.
-In Go 1.6, the resulting <code>Request</code> always has an initialized
-<code>Method</code> field: if its argument is an empty string, <code>NewRequest</code>
-sets the <code>Method</code> field in the returned <code>Request</code> to <code>"GET"</code>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/httptest/"><code>net/http/httptest</code></a> package's
-<a href="/pkg/net/http/httptest/#ResponseRecorder"><code>ResponseRecorder</code></a> now initializes a default Content-Type header
-using the same content-sniffing algorithm as in
-<a href="/pkg/net/http/#Server"><code>http.Server</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/url/"><code>net/url</code></a> package's
-<a href="/pkg/net/url/#Parse"><code>Parse</code></a> is now stricter and more spec-compliant regarding the parsing
-of host names.
-For example, spaces in the host name are no longer accepted.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/url/"><code>net/url</code></a> package,
-the <a href="/pkg/net/url/#Error"><code>Error</code></a> type now implements
-<a href="/pkg/net/#Error"><code>net.Error</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/os/"><code>os</code></a> package's
-<a href="/pkg/os/#IsExist"><code>IsExist</code></a>,
-<a href="/pkg/os/#IsNotExist"><code>IsNotExist</code></a>,
-and
-<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>
-now return correct results when inquiring about an
-<a href="/pkg/os/#SyscallError"><code>SyscallError</code></a>.
-</li>
-
-<li>
-On Unix-like systems, when a write
-to <a href="/pkg/os/#pkg-variables"><code>os.Stdout</code>
-or <code>os.Stderr</code></a> (more precisely, an <code>os.File</code>
-opened for file descriptor 1 or 2) fails due to a broken pipe error,
-the program will raise a <code>SIGPIPE</code> signal.
-By default this will cause the program to exit; this may be changed by
-calling the
-<a href="/pkg/os/signal"><code>os/signal</code></a>
-<a href="/pkg/os/signal/#Notify"><code>Notify</code></a> function
-for <code>syscall.SIGPIPE</code>.
-A write to a broken pipe on a file descriptor other 1 or 2 will simply
-return <code>syscall.EPIPE</code> (possibly wrapped in
-<a href="/pkg/os#PathError"><code>os.PathError</code></a>
-and/or <a href="/pkg/os#SyscallError"><code>os.SyscallError</code></a>)
-to the caller.
-The old behavior of raising an uncatchable <code>SIGPIPE</code> signal
-after 10 consecutive writes to a broken pipe no longer occurs.
-</li>
-
-<li>
-In the <a href="/pkg/os/exec/"><code>os/exec</code></a> package,
-<a href="/pkg/os/exec/#Cmd"><code>Cmd</code></a>'s
-<a href="/pkg/os/exec/#Cmd.Output"><code>Output</code></a> method continues to return an
-<a href="/pkg/os/exec/#ExitError"><code>ExitError</code></a> when a command exits with an unsuccessful status.
-If standard error would otherwise have been discarded,
-the returned <code>ExitError</code> now holds a prefix and suffix
-(currently 32 kB) of the failed command's standard error output,
-for debugging or for inclusion in error messages.
-The <code>ExitError</code>'s
-<a href="/pkg/os/exec/#ExitError.String"><code>String</code></a>
-method does not show the captured standard error;
-programs must retrieve it from the data structure
-separately.
-</li>
-
-<li>
-On Windows, the <a href="/pkg/path/filepath/"><code>path/filepath</code></a> package's
-<a href="/pkg/path/filepath/#Join"><code>Join</code></a> function now correctly handles the case when the base is a relative drive path.
-For example, <code>Join(`c:`,</code> <code>`a`)</code> now
-returns <code>`c:a`</code> instead of <code>`c:\a`</code> as in past releases.
-This may affect code that expects the incorrect result.
-</li>
-
-<li>
-In the <a href="/pkg/regexp/"><code>regexp</code></a> package,
-the
-<a href="/pkg/regexp/#Regexp"><code>Regexp</code></a> type has always been safe for use by
-concurrent goroutines.
-It uses a <a href="/pkg/sync/#Mutex"><code>sync.Mutex</code></a> to protect
-a cache of scratch spaces used during regular expression searches.
-Some high-concurrency servers using the same <code>Regexp</code> from many goroutines
-have seen degraded performance due to contention on that mutex.
-To help such servers, <code>Regexp</code> now has a
-<a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> method,
-which makes a copy of a <code>Regexp</code> that shares most of the structure
-of the original but has its own scratch space cache.
-Two goroutines can use different copies of a <code>Regexp</code>
-without mutex contention.
-A copy does have additional space overhead, so <code>Copy</code>
-should only be used when contention has been observed.
-</li>
-
-<li>
-The <a href="/pkg/strconv/"><code>strconv</code></a> package adds
-<a href="/pkg/strconv/#IsGraphic"><code>IsGraphic</code></a>,
-similar to <a href="/pkg/strconv/#IsPrint"><code>IsPrint</code></a>.
-It also adds
-<a href="/pkg/strconv/#QuoteToGraphic"><code>QuoteToGraphic</code></a>,
-<a href="/pkg/strconv/#QuoteRuneToGraphic"><code>QuoteRuneToGraphic</code></a>,
-<a href="/pkg/strconv/#AppendQuoteToGraphic"><code>AppendQuoteToGraphic</code></a>,
-and
-<a href="/pkg/strconv/#AppendQuoteRuneToGraphic"><code>AppendQuoteRuneToGraphic</code></a>,
-analogous to
-<a href="/pkg/strconv/#QuoteToASCII"><code>QuoteToASCII</code></a>,
-<a href="/pkg/strconv/#QuoteRuneToASCII"><code>QuoteRuneToASCII</code></a>,
-and so on.
-The <code>ASCII</code> family escapes all space characters except ASCII space (U+0020).
-In contrast, the <code>Graphic</code> family does not escape any Unicode space characters (category Zs).
-</li>
-
-<li>
-In the <a href="/pkg/testing/"><code>testing</code></a> package,
-when a test calls
-<a href="/pkg/testing/#T.Parallel">t.Parallel</a>,
-that test is paused until all non-parallel tests complete, and then
-that test continues execution with all other parallel tests.
-Go 1.6 changes the time reported for such a test:
-previously the time counted only the parallel execution,
-but now it also counts the time from the start of testing
-until the call to <code>t.Parallel</code>.
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package
-contains two minor changes, in addition to the <a href="#template">major changes</a>
-described above.
-First, it adds a new
-<a href="/pkg/text/template/#ExecError"><code>ExecError</code></a> type
-returned for any error during
-<a href="/pkg/text/template/#Template.Execute"><code>Execute</code></a>
-that does not originate in a <code>Write</code> to the underlying writer.
-Callers can distinguish template usage errors from I/O errors by checking for
-<code>ExecError</code>.
-Second, the
-<a href="/pkg/text/template/#Template.Funcs"><code>Funcs</code></a> method
-now checks that the names used as keys in the
-<a href="/pkg/text/template/#FuncMap"><code>FuncMap</code></a>
-are identifiers that can appear in a template function invocation.
-If not, <code>Funcs</code> panics.
-</li>
-
-<li>
-The <a href="/pkg/time/"><code>time</code></a> package's
-<a href="/pkg/time/#Parse"><code>Parse</code></a> function has always rejected any day of month larger than 31,
-such as January 32.
-In Go 1.6, <code>Parse</code> now also rejects February 29 in non-leap years,
-February 30, February 31, April 31, June 31, September 31, and November 31.
-</li>
-
-</ul>
-

doc/go1compat.html

@@ -1,202 +0,0 @@
-<!--{
-	"Title": "Go 1 and the Future of Go Programs",
-	"Path":  "/doc/go1compat"
-}-->
-
-<h2 id="introduction">Introduction</h2>
-<p>
-The release of Go version 1, Go 1 for short, is a major milestone
-in the development of the language. Go 1 is a stable platform for
-the growth of programs and projects written in Go.
-</p>
-
-<p>
-Go 1 defines two things: first, the specification of the language;
-and second, the specification of a set of core APIs, the "standard
-packages" of the Go library. The Go 1 release includes their
-implementation in the form of two compiler suites (gc and gccgo),
-and the core libraries themselves.
-</p>
-
-<p>
-It is intended that programs written to the Go 1 specification will
-continue to compile and run correctly, unchanged, over the lifetime
-of that specification. At some indefinite point, a Go 2 specification
-may arise, but until that time, Go programs that work today should
-continue to work even as future "point" releases of Go 1 arise (Go
-1.1, Go 1.2, etc.).
-</p>
-
-<p>
-Compatibility is at the source level. Binary compatibility for
-compiled packages is not guaranteed between releases. After a point
-release, Go source will need to be recompiled to link against the
-new release.
-</p>
-
-<p>
-The APIs may grow, acquiring new packages and features, but not in
-a way that breaks existing Go 1 code.
-</p>
-
-<h2 id="expectations">Expectations</h2>
-
-<p>
-Although we expect that the vast majority of programs will maintain
-this compatibility over time, it is impossible to guarantee that
-no future change will break any program. This document is an attempt
-to set expectations for the compatibility of Go 1 software in the
-future. There are a number of ways in which a program that compiles
-and runs today may fail to do so after a future point release. They
-are all unlikely but worth recording.
-</p>
-
-<ul>
-<li>
-Security. A security issue in the specification or implementation
-may come to light whose resolution requires breaking compatibility.
-We reserve the right to address such security issues.
-</li>
-
-<li>
-Unspecified behavior. The Go specification tries to be explicit
-about most properties of the language, but there are some aspects
-that are undefined. Programs that depend on such unspecified behavior
-may break in future releases.
-</li>
-
-<li>
-Specification errors. If it becomes necessary to address an
-inconsistency or incompleteness in the specification, resolving the
-issue could affect the meaning or legality of existing programs.
-We reserve the right to address such issues, including updating the
-implementations. Except for security issues, no incompatible changes
-to the specification would be made.
-</li>
-
-<li>
-Bugs. If a compiler or library has a bug that violates the
-specification, a program that depends on the buggy behavior may
-break if the bug is fixed. We reserve the right to fix such bugs.
-</li>
-
-<li>
-Struct literals. For the addition of features in later point
-releases, it may be necessary to add fields to exported structs in
-the API. Code that uses unkeyed struct literals (such as pkg.T{3,
-"x"}) to create values of these types would fail to compile after
-such a change. However, code that uses keyed literals (pkg.T{A:
-3, B: "x"}) will continue to compile after such a change. We will
-update such data structures in a way that allows keyed struct
-literals to remain compatible, although unkeyed literals may fail
-to compile. (There are also more intricate cases involving nested
-data structures or interfaces, but they have the same resolution.)
-We therefore recommend that composite literals whose type is defined
-in a separate package should use the keyed notation.
-</li>
-
-<li>
-Methods. As with struct fields, it may be necessary to add methods
-to types.
-Under some circumstances, such as when the type is embedded in
-a struct along with another type,
-the addition of the new method may break
-the struct by creating a conflict with an existing method of the other
-embedded type.
-We cannot protect against this rare case and do not guarantee compatibility
-should it arise.
-</li>
-
-<li>
-Dot imports. If a program imports a standard package
-using <code>import . "path"</code>, additional names defined in the
-imported package in future releases may conflict with other names
-defined in the program.  We do not recommend the use of <code>import .</code>
-outside of tests, and using it may cause a program to fail
-to compile in future releases.
-</li>
-
-<li>
-Use of package <code>unsafe</code>. Packages that import
-<a href="/pkg/unsafe/"><code>unsafe</code></a>
-may depend on internal properties of the Go implementation.
-We reserve the right to make changes to the implementation
-that may break such programs.
-</li>
-
-</ul>
-
-<p>
-Of course, for all of these possibilities, should they arise, we
-would endeavor whenever feasible to update the specification,
-compilers, or libraries without affecting existing code.
-</p>
-
-<p>
-These same considerations apply to successive point releases. For
-instance, code that runs under Go 1.2 should be compatible with Go
-1.2.1, Go 1.3, Go 1.4, etc., although not necessarily with Go 1.1
-since it may use features added only in Go 1.2
-</p>
-
-<p>
-Features added between releases, available in the source repository
-but not part of the numbered binary releases, are under active
-development. No promise of compatibility is made for software using
-such features until they have been released.
-</p>
-
-<p>
-Finally, although it is not a correctness issue, it is possible
-that the performance of a program may be affected by
-changes in the implementation of the compilers or libraries upon
-which it depends.
-No guarantee can be made about the performance of a
-given program between releases.
-</p>
-
-<p>
-Although these expectations apply to Go 1 itself, we hope similar
-considerations would be made for the development of externally
-developed software based on Go 1.
-</p>
-
-<h2 id="subrepos">Sub-repositories</h2>
-
-<p>
-Code in sub-repositories of the main go tree, such as
-<a href="//golang.org/x/net">golang.org/x/net</a>,
-may be developed under
-looser compatibility requirements. However, the sub-repositories
-will be tagged as appropriate to identify versions that are compatible
-with the Go 1 point releases.
-</p>
-
-<h2 id="operating_systems">Operating systems</h2>
-
-<p>
-It is impossible to guarantee long-term compatibility with operating
-system interfaces, which are changed by outside parties.
-The <a href="/pkg/syscall/"><code>syscall</code></a> package
-is therefore outside the purview of the guarantees made here.
-As of Go version 1.4, the <code>syscall</code> package is frozen.
-Any evolution of the system call interface must be supported elsewhere,
-such as in the
-<a href="//golang.org/x/sys">go.sys</a> subrepository.
-For details and background, see
-<a href="//golang.org/s/go1.4-syscall">this document</a>.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<p>
-Finally, the Go toolchain (compilers, linkers, build tools, and so
-on) is under active development and may change behavior. This
-means, for instance, that scripts that depend on the location and
-properties of the tools may be broken by a point release.
-</p>
-
-<p>
-These caveats aside, we believe that Go 1 will be a firm foundation
-for the development of Go and its ecosystem.
-</p>

doc/go_spec.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jan 14, 2020",
+	"Subtitle": "Version of Feb 10, 2021",
 	"Path": "/ref/spec"
 }-->
 
@@ -3400,7 +3400,7 @@ A type assertion used in an <a href="#Assignments">assignment</a> or initializat
 v, ok = x.(T)
 v, ok := x.(T)
 var v, ok = x.(T)
-var v, ok T1 = x.(T)
+var v, ok interface{} = x.(T) // dynamic types of v and ok are T and bool
 </pre>
 
 <p>
@@ -3446,7 +3446,7 @@ In a function call, the function value and arguments are evaluated in
 After they are evaluated, the parameters of the call are passed by value to the function
 and the called function begins execution.
 The return parameters of the function are passed by value
-back to the calling function when the function returns.
+back to the caller when the function returns.
 </p>
 
 <p>
@@ -3594,23 +3594,33 @@ replaced by its left operand alone.
 </p>
 
 <pre>
+var a [1024]byte
 var s uint = 33
-var i = 1&lt;&lt;s                  // 1 has type int
-var j int32 = 1&lt;&lt;s            // 1 has type int32; j == 0
-var k = uint64(1&lt;&lt;s)          // 1 has type uint64; k == 1&lt;&lt;33
-var m int = 1.0&lt;&lt;s            // 1.0 has type int; m == 0 if ints are 32bits in size
-var n = 1.0&lt;&lt;s == j           // 1.0 has type int32; n == true
-var o = 1&lt;&lt;s == 2&lt;&lt;s          // 1 and 2 have type int; o == true if ints are 32bits in size
-var p = 1&lt;&lt;s == 1&lt;&lt;33         // illegal if ints are 32bits in size: 1 has type int, but 1&lt;&lt;33 overflows int
-var u = 1.0&lt;&lt;s                // illegal: 1.0 has type float64, cannot shift
-var u1 = 1.0&lt;&lt;s != 0          // illegal: 1.0 has type float64, cannot shift
-var u2 = 1&lt;&lt;s != 1.0          // illegal: 1 has type float64, cannot shift
-var v float32 = 1&lt;&lt;s          // illegal: 1 has type float32, cannot shift
-var w int64 = 1.0&lt;&lt;33         // 1.0&lt;&lt;33 is a constant shift expression
-var x = a[1.0&lt;&lt;s]             // 1.0 has type int; x == a[0] if ints are 32bits in size
-var a = make([]byte, 1.0&lt;&lt;s)  // 1.0 has type int; len(a) == 0 if ints are 32bits in size
-</pre>
 
+// The results of the following examples are given for 64-bit ints.
+var i = 1&lt;&lt;s                   // 1 has type int
+var j int32 = 1&lt;&lt;s             // 1 has type int32; j == 0
+var k = uint64(1&lt;&lt;s)           // 1 has type uint64; k == 1&lt;&lt;33
+var m int = 1.0&lt;&lt;s             // 1.0 has type int; m == 1&lt;&lt;33
+var n = 1.0&lt;&lt;s == j            // 1.0 has type int; n == true
+var o = 1&lt;&lt;s == 2&lt;&lt;s           // 1 and 2 have type int; o == false
+var p = 1&lt;&lt;s == 1&lt;&lt;33          // 1 has type int; p == true
+var u = 1.0&lt;&lt;s                 // illegal: 1.0 has type float64, cannot shift
+var u1 = 1.0&lt;&lt;s != 0           // illegal: 1.0 has type float64, cannot shift
+var u2 = 1&lt;&lt;s != 1.0           // illegal: 1 has type float64, cannot shift
+var v float32 = 1&lt;&lt;s           // illegal: 1 has type float32, cannot shift
+var w int64 = 1.0&lt;&lt;33          // 1.0&lt;&lt;33 is a constant shift expression; w == 1&lt;&lt;33
+var x = a[1.0&lt;&lt;s]              // panics: 1.0 has type int, but 1&lt;&lt;33 overflows array bounds
+var b = make([]byte, 1.0&lt;&lt;s)   // 1.0 has type int; len(b) == 1&lt;&lt;33
+
+// The results of the following examples are given for 32-bit ints,
+// which means the shifts will overflow.
+var mm int = 1.0&lt;&lt;s            // 1.0 has type int; mm == 0
+var oo = 1&lt;&lt;s == 2&lt;&lt;s          // 1 and 2 have type int; oo == true
+var pp = 1&lt;&lt;s == 1&lt;&lt;33         // illegal: 1 has type int, but 1&lt;&lt;33 overflows int
+var xx = a[1.0&lt;&lt;s]             // 1.0 has type int; xx == a[0]
+var bb = make([]byte, 1.0&lt;&lt;s)  // 1.0 has type int; len(bb) == 0
+</pre>
 
 <h4 id="Operator_precedence">Operator precedence</h4>
 <p>
@@ -3646,7 +3656,7 @@ For instance, <code>x / y * z</code> is the same as <code>(x / y) * z</code>.
 x &lt;= f()
 ^a &gt;&gt; b
 f() || g()
-x == y+1 &amp;&amp; &lt;-chanPtr &gt; 0
+x == y+1 &amp;&amp; &lt;-chanInt &gt; 0
 </pre>
 
 

doc/gopher/README

@@ -1,3 +0,0 @@
-The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/)
-The design is licensed under the Creative Commons 3.0 Attributions license.
-Read this article for more details: https://blog.golang.org/gopher

doc/gopher/favicon.svg

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