go1.2.2

R=rsc, bradfitz
CC=golang-codereviews, golang-dev
https://golang.org/cl/95010046

.hgignore

@@ -2,13 +2,13 @@ syntax:glob
 .DS_Store
 .git
 .gitignore
-*.[5689ao]
-*.a[5689o]
+*.[568ao]
+*.a[568o]
 *.so
 *.pyc
 ._*
 .nfs.*
-[5689a].out
+[568a].out
 *~
 *.orig
 *.rej
@@ -23,14 +23,17 @@ _test
 _testmain.go
 build.out
 test.out
+doc/tmpltohtml
 doc/articles/wiki/*.bin
-include/plan9/libc_plan9.h
 misc/cgo/life/run.out
 misc/cgo/stdio/run.out
 misc/cgo/testso/main
 misc/dashboard/builder/builder
+misc/goplay/goplay
+misc/osx/*.pkg
+misc/osx/*.dmg
 src/cmd/?a/y.output
-src/liblink/anames?.c
+src/cmd/?l/enam.c
 src/cmd/cc/y.output
 src/cmd/cgo/zdefaultcc.go
 src/cmd/dist/dist.dSYM
@@ -38,11 +41,12 @@ src/cmd/gc/mkbuiltin1
 src/cmd/gc/opnames.h
 src/cmd/gc/y.output
 src/cmd/go/zdefaultcc.go
-src/go/doc/headscan
-src/runtime/mkversion
-src/runtime/z*
-src/unicode/maketables
-src/*.*/
+src/pkg/go/doc/headscan
+src/pkg/runtime/goc2c
+src/pkg/runtime/mkversion
+src/pkg/runtime/z*
+src/pkg/unicode/maketables
+src/pkg/*.*/
 test/pass.out
 test/run.out
 test/times.out

.hgtags

@@ -119,20 +119,3 @@ dc5e410f0b4c32ab11dc992593a2bcf5f607381b weekly
 e570c2daeaca10663d36d6dee7f8d1d76e8f7b92 go1.1
 a7bd9a33067b3537351276e0178a045748ad046a go1.1.1
 414057ac1f1fc850957088e4c5e95cdbccd2d594 go1.1.2
-45475ec7eab1c588fc4210b34d5901b15ca1e479 go1.2rc2
-7422495a6bf9d5e84828ee466406293be84f565a go1.2rc3
-94af58f9fd71feda5c316d791ed11aaf015f9e82 go1.2rc4
-b3d5a20b070a92da2458c5788694d1359b353f4a go1.2rc5
-87dea3f5ebe7510998c84dbeeec89382b7d42f9c go1.2
-0ddbdc3c7ce27e66508fe58ab81ff29324786026 go1.2.1
-9c4fdd8369ca4483fbed1cb8e67f02643ca10f79 go1.2.2
-f8b50ad4cac4d4c4ecf48324b4f512f65e82cc1c go1.3beta1
-9e1652c32289c164126b6171f024afad5665fc9e go1.3beta2
-9d5451df4e53acc58a848005b7ec3a24c4b6050c go1.3rc1
-3f66a43d5180052e2e1e38d979d1aa5ad05b21f9 go1.3rc2
-9895f9e36435468d503eaa74ee217f28d5e28dd4 go1.3
-073fc578434bf3e1e22749b559d273c8da728ebb go1.3.1
-85518b1d6f8d6e16133b9ed2c9db6807522d37de go1.3.2
-f44017549ff9c3cc5eef74ebe7276cd0dfc066b6 go1.3.3
-f44017549ff9c3cc5eef74ebe7276cd0dfc066b6 release
-1fdfd7dfaedb1b7702141617e621ab7328a236a1 go1.4beta1

AUTHORS

@@ -12,52 +12,39 @@ Aaron France <aaron.l.france@gmail.com>
 Abhinav Gupta <abhinav.g90@gmail.com>
 Adrian Nos <nos.adrian@gmail.com>
 Adrian O'Grady <elpollouk@gmail.com>
-Adrien Bustany <adrien-xx-google@bustany.org>
-Ahmed Waheed Moanes <oneofone@gmail.com>
 Akshat Kumar <seed@mail.nanosouffle.net>
-Alan Shreve <alan@inconshreveable.com>
 Albert Strasheim <fullung@gmail.com>
-Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Alex A Skinner <alex@lx.lc>
 Alex Brainman <alex.brainman@gmail.com>
 Alex Jin <toalexjin@gmail.com>
-Alexander Larsson <alexander.larsson@gmail.com>
 Alexander Orlov <alexander.orlov@loxal.net>
 Alexander Reece <awreece@gmail.com>
 Alexander Surma <surma@surmair.de>
-Alexander Zhavnerchik <alex.vizor@gmail.com>
 Alexandre Normand <alexandre.normand@gmail.com>
 Alexei Sholik <alcosholik@gmail.com>
 Alexey Borzenkov <snaury@gmail.com>
-Alexey Palazhchenko <alexey.palazhchenko@gmail.com>
 Amir Mohammad Saied <amir@gluegadget.com>
 Amrut Joshi <amrut.joshi@gmail.com>
 Andrei Vieru <euvieru@gmail.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
-Andrew Bursavich <abursavich@gmail.com>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Lutomirski <andy@luto.us>
 Andrew Pritchard <awpritchard@gmail.com>
 Andrew Radev <andrey.radev@gmail.com>
 Andrew Skiba <skibaa@gmail.com>
-Andrew Szeto <andrew@jabagawee.com>
 Andrew Wilkins <axwalk@gmail.com>
 Andrey Mirtchovski <mirtchovski@gmail.com>
 Andriy Lytvynov <lytvynov.a.v@gmail.com>
 Andy Davis <andy@bigandian.com>
-Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Anh Hai Trinh <anh.hai.trinh@gmail.com>
 Anschel Schaffer-Cohen <anschelsc@gmail.com>
 Anthony Eufemio <anthony.eufemio@gmail.com>
 Anthony Martin <ality@pbrane.org>
 Anthony Starks <ajstarks@gmail.com>
-Apisak Darakananda <pongad@gmail.com>
-Aram Hăvărneanu <aram@mgk.ro>
 Arnaud Ysmal <arnaud.ysmal@gmail.com>
-Arne Hormann <arnehormann@gmail.com>
 Aron Nopanen <aron.nopanen@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
 Ato Araki <ato.araki@gmail.com>
@@ -65,25 +52,19 @@ Aulus Egnatius Varialus <varialus@gmail.com>
 Ben Olive <sionide21@gmail.com>
 Benjamin Black <b@b3k.us>
 Benny Siegert <bsiegert@gmail.com>
-Benoit Sigoure <tsunanet@gmail.com>
 Berengar Lehr <berengar.lehr@gmx.de>
-Billie Harold Cleek <bhcleek@gmail.com>
 Bjorn Tillenius <bjorn@tillenius.me>
 Bjorn Tipling <bjorn.tipling@gmail.com>
 Blake Mizerany <blake.mizerany@gmail.com>
 Bobby Powers <bobbypowers@gmail.com>
-Brendan Daniel Tracey <tracey.brendan@gmail.com>
 Brian Dellisanti <briandellisanti@gmail.com>
 Brian G. Merrell <bgmerrell@gmail.com>
 Brian Gitonga Marete <marete@toshnix.com>
 Brian Ketelsen <bketelsen@gmail.com>
 Caine Tighe <arctanofyourface@gmail.com>
 Caleb Spare <cespare@gmail.com>
-Carl Chatfield <carlchatfield@gmail.com>
 Carlos Castillo <cookieo9@gmail.com>
-Case Nelson <case.nelson@gmail.com>
 Casey Marshall <casey.marshall@gmail.com>
-Cezar Sá Espinola <cezarsa@gmail.com>
 ChaiShushan <chaishushan@gmail.com>
 Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
@@ -92,10 +73,8 @@ Chris Farmiloe <chrisfarms@gmail.com>
 Chris Howey <howeyc@gmail.com>
 Chris Jones <chris@cjones.org>
 Chris Lennert <calennert@gmail.com>
-Chris McGee <sirnewton_01@yahoo.ca> <newton688@gmail.com>
 Christian Himpel <chressie@googlemail.com>
 Christine Hansmann <chhansmann@gmail.com>
-Christoffer Buchholz <christoffer.buchholz@gmail.com>
 Christoph Hack <christoph@tux21b.org>
 Christopher Cahoon <chris.cahoon@gmail.com>
 Christopher Nielsen <m4dh4tt3r@gmail.com>
@@ -104,34 +83,25 @@ Christopher Wedgwood <cw@f00f.org>
 Clement Skau <clementskau@gmail.com>
 Conrad Meyer <cemeyer@cs.washington.edu>
 Corey Thomasson <cthom.lists@gmail.com>
-Cristian Staretu <unclejacksons@gmail.com>
 Damian Gryski <dgryski@gmail.com>
 Dan Callahan <dan.callahan@gmail.com>
 Dan Peterson <dpiddy@gmail.com>
 Dan Sinclair <dan.sinclair@gmail.com>
 Daniel Fleischman <danielfleischman@gmail.com>
 Daniel Krech <eikeon@eikeon.com>
-Daniel Lidén <daniel.liden.87@gmail.com>
 Daniel Morsing <daniel.morsing@gmail.com>
 Daniel Theophanes <kardianos@gmail.com>
 Darren Elwood <darren@textnode.com>
 Dave Cheney <dave@cheney.net>
 David Bürgin <676c7473@gmail.com>
-David Calavera <david.calavera@gmail.com>
 David du Colombier <0intro@gmail.com>
 David Forsythe <dforsythe@gmail.com>
 David G. Andersen <dave.andersen@gmail.com>
 David Jakob Fritz <david.jakob.fritz@gmail.com>
-David Leon Gil <coruus@gmail.com>
-David Thomas <davidthomas426@gmail.com>
 David Titarenco <david.titarenco@gmail.com>
 Dean Prichard <dean.prichard@gmail.com>
-Denis Brandolini <denis.brandolini@gmail.com>
-Derek Parker <parkerderek86@gmail.com>
 Devon H. O'Dell <devon.odell@gmail.com>
-Dhiru Kholia <dhiru.kholia@gmail.com>
 Dimitri Tcaciuc <dtcaciuc@gmail.com>
-Dmitri Shuralyov <shurcooL@gmail.com>
 Dmitriy Shelenin <deemok@googlemail.com> <deemok@gmail.com>
 Dmitry Chestnykh <dchest@gmail.com>
 Dominik Honnef <dominik.honnef@gmail.com>
@@ -151,51 +121,36 @@ Eric Clark <zerohp@gmail.com>
 Eric Milliken <emilliken@gmail.com>
 Eric Roshan-Eisner <eric.d.eisner@gmail.com>
 Erik St. Martin <alakriti@gmail.com>
-Erik Westrup <erik.westrup@gmail.com>
 Esko Luontola <esko.luontola@gmail.com>
 Evan Shaw <chickencha@gmail.com>
 Ewan Chou <coocood@gmail.com>
-Fabrizio Milo <mistobaan@gmail.com>
 Fan Hongjian <fan.howard@gmail.com>
-Fastly, Inc.
-Fatih Arslan <fatih@arslan.io>
 Fazlul Shahriar <fshahriar@gmail.com>
-Felix Geisendörfer <haimuiba@gmail.com>
 Firmansyah Adiputra <frm.adiputra@gmail.com>
 Florian Uekermann <florian@uekermann-online.de>
 Florian Weimer <fw@deneb.enyo.de>
 Francisco Souza <franciscossouza@gmail.com>
 Frederick Kelly Mayle III <frederickmayle@gmail.com>
-Fredrik Enestad <fredrik.enestad@soundtrackyourbrand.com>
 Frithjof Schulze <schulze@math.uni-hannover.de> <sfrithjof@gmail.com>
-Gabriel Aszalos <gabriel.aszalos@gmail.com>
 Gary Burd <gary@beagledreams.com>
-Gautham Thambidorai <gautham.dorai@gmail.com>
 Georg Reinke <guelfey@gmail.com>
 Gerasimos Dimitriadis <gedimitr@gmail.com>
 Gideon Jan-Wessel Redelinghuys <gjredelinghuys@gmail.com>
 Giles Lean <giles.lean@pobox.com>
 Google Inc.
-Gordon Klaus <gordon.klaus@gmail.com>
-Graham King <graham4king@gmail.com>
 Graham Miller <graham.miller@gmail.com>
 Greg Ward <greg@gerg.ca>
-Guillaume J. Charmes <guillaume@charmes.net>
 Gustav Paul <gustav.paul@gmail.com>
 Gustavo Niemeyer <gustavo@niemeyer.net>
 Gwenael Treguier <gwenn.kahz@gmail.com>
 Harley Laue <losinggeneration@gmail.com>
 Hector Chu <hectorchu@gmail.com>
-Hector Martin Cantero <hector@marcansoft.com>
-Henning Schmiedehausen <henning@schmiedehausen.org>
-Henrik Edwards <henrik.edwards@gmail.com>
 Herbert Georg Fischer <herbert.fischer@gmail.com>
 Hong Ruiqi <hongruiqi@gmail.com>
 Icarus Sparry <golang@icarus.freeuk.com>
 Ingo Oeser <nightlyone@googlemail.com>
 Isaac Wagner <ibw@isaacwagner.me>
 Jakob Borg <jakob@nym.se>
-Jakub Ryszard Czarnowicz <j.czarnowicz@gmail.com>
 James David Chalfant <james.chalfant@gmail.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
@@ -210,28 +165,21 @@ Jan Newmarch <jan.newmarch@gmail.com>
 Jan Ziak <0xe2.0x9a.0x9b@gmail.com>
 Jani Monoses <jani.monoses@ubuntu.com>
 Jaroslavas Počepko <jp@webmaster.ms>
-Jason Del Ponte <delpontej@gmail.com>
 Jason Travis <infomaniac7@gmail.com>
-Jay Weisskopf <jay@jayschwa.net>
 Jeff Hodges <jeff@somethingsimilar.com>
 Jeff R. Allen <jra@nella.org>
 Jeff Sickel <jas@corpus-callosum.com>
 Jeff Wendling <jeff@spacemonkey.com>
-Jens Frederich <jfrederich@gmail.com>
 Jeremy Jackins <jeremyjackins@gmail.com>
 Jim McGrath <jimmc2@gmail.com>
 Jimmy Zelinskie <jimmyzelinskie@gmail.com>
 Jingcheng Zhang <diogin@gmail.com>
 Joakim Sernbrant <serbaut@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
-Joe Shaw <joe@joeshaw.org>
-Joel Stemmer <stemmertech@gmail.com>
 John Asmuth <jasmuth@gmail.com>
-John C Barstow <jbowtie@amathaine.com>
 John Graham-Cumming <jgc@jgc.org> <jgrahamc@gmail.com>
 John Howard Palevich <jack.palevich@gmail.com>
 John Shahid <jvshahid@gmail.com>
-John Tuley <john@tuley.org>
 Jonathan Gold <jgold.bg@gmail.com>
 Jonathan Mark <jhmark@xenops.com>
 Jonathan Rudenberg <jonathan@titanous.com>
@@ -242,8 +190,6 @@ Joseph Holsten <joseph@josephholsten.com>
 Josh Bleecher Snyder <josharian@gmail.com>
 Josh Goebel <dreamer3@gmail.com>
 Josh Holland <jrh@joshh.co.uk>
-Joshua Chase <jcjoshuachase@gmail.com>
-JT Olds <jtolds@xnet5.com>
 Jukka-Pekka Kekkonen <karatepekka@gmail.com>
 Julian Phillips <julian@quantumfyre.co.uk>
 Julien Schmidt <google@julienschmidt.com>
@@ -252,80 +198,55 @@ Kamil Kisiel <kamil@kamilkisiel.net> <kamil.kisiel@gmail.com>
 Katrina Owen <katrina.owen@gmail.com>
 Kei Son <hey.calmdown@gmail.com>
 Keith Rarick <kr@xph.us>
-Kelsey Hightower <kelsey.hightower@gmail.com>
-Kelvin Foo Chuan Lyi <vmirage@gmail.com>
 Ken Friedenbach <kenliz@cruzio.com>
 Ken Rockot <ken@oz.gs>
 Kevin Ballard <kevin@sb.org>
 Kyle Consalus <consalus@gmail.com>
-Kyle Isom <kyle@gokyle.net>
 Kyle Lemons <kyle@kylelemons.net>
 L Campbell <unpantsu@gmail.com>
 Lai Jiangshan <eag0628@gmail.com>
-Linaro Limited
 Lorenzo Stoakes <lstoakes@gmail.com>
 Luca Greco <luca.greco@alcacoop.it>
 Lucio De Re <lucio.dere@gmail.com>
 Luit van Drongelen <luitvd@gmail.com>
-Luka Zakrajšek <tr00.g33k@gmail.com>
-Luke Curley <qpingu@gmail.com>
-Manuel Mendez <mmendez534@gmail.com>
-Marc Weistroff <marc@weistroff.net>
 Marco Hennings <marco.hennings@freiheit.com>
-Mark Theunissen <mark.theunissen@gmail.com>
 Marko Juhani Silokunnas <marko.silokunnas@gmail.com>
-Marko Tiikkaja <marko@joh.to>
-Markover Inc. DBA Poptip
 Markus Duft <markus.duft@salomon.at>
 Markus Sonderegger <marraison@gmail.com>
-Markus Zimmermann <zimmski@gmail.com>
 Martin Neubauer <m.ne@gmx.net>
-Martin Olsson <martin@minimum.se>
 Mateusz Czapliński <czapkofan@gmail.com>
 Mathieu Lonjaret <mathieu.lonjaret@gmail.com>
 Mats Lidell <mats.lidell@cag.se>
-Matt Aimonetti <mattaimonetti@gmail.com>
 Matt Jibson <matt.jibson@gmail.com>
 Matt Joiner <anacrolix@gmail.com>
 Matt Reiferson <mreiferson@gmail.com>
 Matthew Cottingham <mattcottingham@gmail.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
-Maxim Khitrov <max@mxcrypt.com>
 Micah Stetson <micah.stetson@gmail.com>
 Michael Chaten <mchaten@gmail.com>
 Michael Elkins <michael.elkins@gmail.com>
-Michael Fraenkel <michael.fraenkel@gmail.com>
-Michael Gehring <mg@ebfe.org> <gnirheg.leahcim@gmail.com>
+Michael Gehring <mg@ebfe.org>
 Michael Hoisie <hoisie@gmail.com>
 Michael Lewis <mikelikespie@gmail.com>
-Michael MacInnis <Michael.P.MacInnis@gmail.com>
-Michael Pearson <mipearson@gmail.com>
 Michael Stapelberg <michael@stapelberg.de>
 Michael Teichgräber <mteichgraeber@gmx.de>
 Michał Derkacz <ziutek@lnet.pl>
 Miek Gieben <miek@miek.nl>
-Mihai Borobocea <MihaiBorobocea@gmail.com>
 Mikael Tillenius <mikti42@gmail.com>
-Mike Andrews <mra@xoba.com>
 Mike Rosset <mike.rosset@gmail.com>
-Mikhail Panchenko <m@mihasya.com>
 Miki Tebeka <miki.tebeka@gmail.com>
 Mikio Hara <mikioh.mikioh@gmail.com>
 Mikkel Krautz <mikkel@krautz.dk>
 Miquel Sabaté Solà <mikisabate@gmail.com>
-Moov Corporation
 Moriyoshi Koizumi <mozo@mozo.jp>
 Môshe van der Sterre <moshevds@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nathan John Youngman <nj@nathany.com>
-Nathan P Finch <nate.finch@gmail.com>
 ngmoco, LLC
-Nicholas Katsaros <nick@nickkatsaros.com>
 Nicholas Presta <nick@nickpresta.ca> <nick1presta@gmail.com>
 Nicholas Sullivan <nicholas.sullivan@gmail.com>
 Nicholas Waples <nwaples@gmail.com>
 Nick Craig-Wood <nick@craig-wood.com> <nickcw@gmail.com>
-Nicolas Kaiser <nikai@nikai.net>
 Nicolas Owens <mischief@offblast.org>
 Nigel Kerr <nigel.kerr@gmail.com>
 Noah Campbell <noahcampbell@gmail.com>
@@ -340,34 +261,24 @@ Pascal S. de Kloe <pascal@quies.net>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
-Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
 Patrick Smith <pat42smith@gmail.com>
-Paul A Querna <paul.querna@gmail.com>
-Paul Hammond <paul@paulhammond.org>
 Paul Lalonde <paul.a.lalonde@gmail.com>
 Paul Sbarra <Sbarra.Paul@gmail.com>
 Paul van Brouwershaven <paul@vanbrouwershaven.com>
-Pavel Zinovkin <pavel.zinovkin@gmail.com>
-Percy Wegmann <ox.to.a.cart@gmail.com>
 Petar Maymounkov <petarm@gmail.com>
 Peter Armitage <peter.armitage@gmail.com>
 Peter Froehlich <peter.hans.froehlich@gmail.com>
 Peter Kleiweg <pkleiweg@xs4all.nl>
 Peter Mundy <go.peter.90@gmail.com>
 Péter Surányi <speter.go1@gmail.com>
-Péter Szilágyi <peterke@gmail.com>
 Peter Waller <peter.waller@gmail.com>
 Peter Williams <pwil3058@gmail.com>
 Philip K. Warren <pkwarren@gmail.com>
 Pieter Droogendijk <pieter@binky.org.uk>
-Pietro Gagliardi <pietro10@mac.com>
-Preetam Jinka <pj@preet.am>
 Quan Yong Zhai <qyzhai@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
-Red Hat, Inc.
 Rémy Oudompheng <oudomphe@phare.normalesup.org>
-Richard Crowley <r@rcrowley.org>
 Richard Eric Gavaletz <gavaletz@gmail.com>
 Richard Musiol <mail@richard-musiol.de>
 Rick Arnold <rickarnoldjr@gmail.com>
@@ -382,13 +293,10 @@ Rodrigo Moraes de Oliveira <rodrigo.moraes@gmail.com>
 Rodrigo Rafael Monti Kochenburger <divoxx@gmail.com>
 Roger Pau Monné <royger@gmail.com>
 Roger Peppe <rogpeppe@gmail.com>
-Ron Hashimoto <mail@h2so5.net>
 Ron Minnich <rminnich@gmail.com>
 Ross Light <rlight2@gmail.com>
-Rowan Worth <sqweek@gmail.com>
 Ryan Hitchman <hitchmanr@gmail.com>
 Ryan Slade <ryanslade@gmail.com>
-S.Çağlar Onur <caglar@10ur.org>
 Sanjay Menakuru <balasanjay@gmail.com>
 Scott Ferguson <scottwferg@gmail.com>
 Scott Lawrence <bytbox@gmail.com>
@@ -401,34 +309,25 @@ Shane Hansen <shanemhansen@gmail.com>
 Shawn Smith <shawn.p.smith@gmail.com>
 Shenghou Ma <minux.ma@gmail.com>
 Shivakumar GN <shivakumar.gn@gmail.com>
-Simon Whitehead <chemnova@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Spring Mc <heresy.mc@gmail.com>
-StalkR <stalkr@stalkr.net>
 Stefan Nilsson <snilsson@nada.kth.se> <trolleriprofessorn@gmail.com>
 Stéphane Travostino <stephane.travostino@gmail.com>
 Stephen McQuay <stephen@mcquay.me>
 Stephen Weinberg <stephen@q5comm.com>
 Steve McCoy <mccoyst@gmail.com>
 Steven Elliot Harris <seharris@gmail.com>
-Steven Hartland <steven.hartland@multiplay.co.uk>
 Sven Almgren <sven@tras.se>
 Szabolcs Nagy <nsz@port70.net>
 Tad Glines <tad.glines@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
 Taru Karttunen <taruti@taruti.net>
-Tetsuo Kiso <tetsuokiso9@gmail.com>
-Thiago Fransosi Farina <thiago.farina@gmail.com>
 Thomas Alan Copeland <talan.copeland@gmail.com>
 Thomas Kappler <tkappler@gmail.com>
 Timo Savola <timo.savola@gmail.com>
-Timo Truyts <alkaloid.btx@gmail.com>
 Tobias Columbus <tobias.columbus@gmail.com>
-Tom Linford <tomlinford@gmail.com>
 Tor Andersson <tor.andersson@gmail.com>
-Travis Cline <travis.cline@gmail.com>
-Tudor Golubenco <tudor.g@gmail.com>
 Tw <tw19881113@gmail.com>
 Tyler Bunnell <tylerbunnell@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
@@ -443,8 +342,6 @@ Volker Dobler <dr.volker.dobler@gmail.com>
 Wei Guangjing <vcc.163@gmail.com>
 Willem van der Schyff <willemvds@gmail.com>
 William Josephson <wjosephson@gmail.com>
-William Orr <will@worrbase.com> <ay1244@gmail.com>
-Xia Bin <snyh@snyh.org>
 Xing Xing <mikespook@gmail.com>
 Yasuhiro Matsumoto <mattn.jp@gmail.com>
 Yissakhar Z. Beck <yissakhar.beck@gmail.com>
@@ -455,4 +352,3 @@ Yuusei Kuwana <kuwana@kumama.org>
 Yuval Pavel Zholkover <paulzhol@gmail.com>
 Ziad Hatahet <hatahet@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
-申习之 <bronze1man@gmail.com>

CONTRIBUTORS

@@ -37,66 +37,52 @@ Abhinav Gupta <abhinav.g90@gmail.com>
 Adam Langley <agl@golang.org>
 Adrian Nos <nos.adrian@gmail.com>
 Adrian O'Grady <elpollouk@gmail.com>
-Adrien Bustany <adrien-xx-google@bustany.org>
-Ahmed Waheed Moanes <oneofone@gmail.com>
 Akshat Kumar <seed@mail.nanosouffle.net>
 Alan Donovan <adonovan@google.com>
-Alan Shreve <alan@inconshreveable.com>
 Albert Strasheim <fullung@gmail.com>
-Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Alex A Skinner <alex@lx.lc>
 Alex Brainman <alex.brainman@gmail.com>
 Alex Bramley <abramley@google.com>
 Alex Jin <toalexjin@gmail.com>
-Alexander Larsson <alexander.larsson@gmail.com>
 Alexander Orlov <alexander.orlov@loxal.net>
 Alexander Reece <awreece@gmail.com>
 Alexander Surma <surma@surmair.de>
-Alexander Zhavnerchik <alex.vizor@gmail.com>
 Alexandre Normand <alexandre.normand@gmail.com>
 Alexandru Moșoi <brtzsnr@gmail.com>
 Alexei Sholik <alcosholik@gmail.com>
 Alexey Borzenkov <snaury@gmail.com>
-Alexey Palazhchenko <alexey.palazhchenko@gmail.com>
 Alexis Imperial-Legrand <ail@google.com>
 Amir Mohammad Saied <amir@gluegadget.com>
 Amrut Joshi <amrut.joshi@gmail.com>
 Andrea Spadaccini <spadaccio@google.com>
 Andreas Jellinghaus <andreas@ionisiert.de> <anj@google.com>
 Andrei Vieru <euvieru@gmail.com>
-Andres Erbsen <andreser@google.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
-Andrew Bursavich <abursavich@gmail.com>
 Andrew Gerrand <adg@golang.org>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Lutomirski <andy@luto.us>
 Andrew Pritchard <awpritchard@gmail.com>
 Andrew Radev <andrey.radev@gmail.com>
 Andrew Skiba <skibaa@gmail.com>
-Andrew Szeto <andrew@jabagawee.com>
 Andrew Wilkins <axwalk@gmail.com>
 Andrey Mirtchovski <mirtchovski@gmail.com>
 Andriy Lytvynov <lytvynov.a.v@gmail.com>
 Andy Davis <andy@bigandian.com>
-Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Anh Hai Trinh <anh.hai.trinh@gmail.com>
 Anschel Schaffer-Cohen <anschelsc@gmail.com>
 Anthony Eufemio <anthony.eufemio@gmail.com>
 Anthony Martin <ality@pbrane.org>
 Anthony Starks <ajstarks@gmail.com>
-Apisak Darakananda <pongad@gmail.com>
-Aram Hăvărneanu <aram@mgk.ro>
 Arnaud Ysmal <arnaud.ysmal@gmail.com>
-Arne Hormann <arnehormann@gmail.com>
 Aron Nopanen <aron.nopanen@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
 Asim Shankar <asimshankar@gmail.com>
 Ato Araki <ato.araki@gmail.com>
 Aulus Egnatius Varialus <varialus@gmail.com>
-Austin Clements <austin@google.com> <aclements@csail.mit.edu>
+Austin Clements <aclements@csail.mit.edu>
 Balazs Lecz <leczb@google.com>
 Ben Eitzen <eitzenb@golang.org>
 Ben Fried <ben.fried@gmail.com>
@@ -104,36 +90,28 @@ Ben Lynn <benlynn@gmail.com>
 Ben Olive <sionide21@gmail.com>
 Benjamin Black <b@b3k.us>
 Benny Siegert <bsiegert@gmail.com>
-Benoit Sigoure <tsunanet@gmail.com>
 Berengar Lehr <Berengar.Lehr@gmx.de>
 Bill Neubauer <wcn@golang.org> <wcn@google.com> <bill.neubauer@gmail.com>
 Bill Thiede <couchmoney@gmail.com>
-Billie Harold Cleek <bhcleek@gmail.com>
 Bjorn Tillenius <bjorn@tillenius.me>
 Bjorn Tipling <bjorn.tipling@gmail.com>
 Blake Mizerany <blake.mizerany@gmail.com>
 Bobby Powers <bobbypowers@gmail.com>
 Brad Fitzpatrick <bradfitz@golang.org> <bradfitz@gmail.com>
 Brad Garcia <bgarcia@golang.org>
-Brendan Daniel Tracey <tracey.brendan@gmail.com>
 Brendan O'Dea <bod@golang.org>
 Brian Dellisanti <briandellisanti@gmail.com>
 Brian G. Merrell <bgmerrell@gmail.com>
 Brian Gitonga Marete <marete@toshnix.com>
 Brian Ketelsen <bketelsen@gmail.com>
 Brian Slesinsky <skybrian@google.com>
-Burcu Dogan <jbd@google.com>
 Caine Tighe <arctanofyourface@gmail.com>
 Caleb Spare <cespare@gmail.com>
-Carl Chatfield <carlchatfield@gmail.com>
 Carl Mastrangelo <notcarl@google.com>
 Carl Shapiro <cshapiro@google.com> <cshapiro@golang.org>
 Carlos Castillo <cookieo9@gmail.com>
 Cary Hull <chull@google.com>
-Case Nelson <case.nelson@gmail.com>
 Casey Marshall <casey.marshall@gmail.com>
-Catalin Patulea <catalinp@google.com>
-Cezar Sá Espinola <cezarsa@gmail.com>
 ChaiShushan <chaishushan@gmail.com>
 Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
@@ -144,10 +122,8 @@ Chris Hundt <hundt@google.com>
 Chris Jones <chris@cjones.org> <chris.jones.yar@gmail.com>
 Chris Lennert <calennert@gmail.com>
 Chris Manghane <cmang@golang.org>
-Chris McGee <sirnewton_01@yahoo.ca> <newton688@gmail.com>
 Christian Himpel <chressie@googlemail.com> <chressie@gmail.com>
 Christine Hansmann <chhansmann@gmail.com>
-Christoffer Buchholz <christoffer.buchholz@gmail.com>
 Christoph Hack <christoph@tux21b.org>
 Christopher Cahoon <chris.cahoon@gmail.com>
 Christopher Nielsen <m4dh4tt3r@gmail.com>
@@ -159,15 +135,12 @@ Colby Ranger <cranger@google.com>
 Conrad Meyer <cemeyer@cs.washington.edu>
 Corey Thomasson <cthom.lists@gmail.com>
 Cosmos Nicolaou <cnicolaou@google.com>
-Cristian Staretu <unclejacksons@gmail.com>
 Damian Gryski <dgryski@gmail.com>
-Damien Neil <dneil@google.com>
 Dan Callahan <dan.callahan@gmail.com>
 Dan Peterson <dpiddy@gmail.com>
 Dan Sinclair <dan.sinclair@gmail.com>
 Daniel Fleischman <danielfleischman@gmail.com>
 Daniel Krech <eikeon@eikeon.com>
-Daniel Lidén <daniel.liden.87@gmail.com>
 Daniel Morsing <daniel.morsing@gmail.com>
 Daniel Nadasi <dnadasi@google.com>
 Daniel Theophanes <kardianos@gmail.com>
@@ -177,28 +150,19 @@ Dave Cheney <dave@cheney.net>
 Dave Day <djd@golang.org>
 Dave Grijalva <dgrijalva@ngmoco.com>
 David Anderson <danderson@google.com>
-David Barnett <dbarnett@google.com>
 David Bürgin <676c7473@gmail.com>
-David Calavera <david.calavera@gmail.com>
-David Covert <davidhcovert@gmail.com>
-David Crawshaw <david.crawshaw@zentus.com> <crawshaw@google.com> <crawshaw@golang.org>
+David Crawshaw <david.crawshaw@zentus.com> <crawshaw@google.com>
 David du Colombier <0intro@gmail.com>
 David Forsythe <dforsythe@gmail.com>
 David G. Andersen <dave.andersen@gmail.com>
 David Jakob Fritz <david.jakob.fritz@gmail.com>
-David Leon Gil <coruus@gmail.com>
 David McLeish <davemc@google.com>
 David Presotto <presotto@gmail.com>
 David Symonds <dsymonds@golang.org>
-David Thomas <davidthomas426@gmail.com>
 David Titarenco <david.titarenco@gmail.com>
 Dean Prichard <dean.prichard@gmail.com>
-Denis Brandolini <denis.brandolini@gmail.com>
-Derek Parker <parkerderek86@gmail.com>
 Devon H. O'Dell <devon.odell@gmail.com>
-Dhiru Kholia <dhiru.kholia@gmail.com>
 Dimitri Tcaciuc <dtcaciuc@gmail.com>
-Dmitri Shuralyov <shurcooL@gmail.com>
 Dmitriy Shelenin <deemok@googlemail.com> <deemok@gmail.com>
 Dmitriy Vyukov <dvyukov@google.com>
 Dmitry Chestnykh <dchest@gmail.com>
@@ -206,7 +170,6 @@ Dominik Honnef <dominik.honnef@gmail.com>
 Donovan Hide <donovanhide@gmail.com>
 Drew Hintz <adhintz@google.com>
 Duncan Holm <mail@frou.org>
-Dustin Long <dustmop@gmail.com>
 Dustin Sallings <dsallings@gmail.com>
 Dustin Shields-Cloues <dcloues@gmail.com>
 Eden Li <eden.li@gmail.com>
@@ -220,17 +183,12 @@ Eric Clark <zerohp@gmail.com>
 Eric Milliken <emilliken@gmail.com>
 Eric Roshan-Eisner <eric.d.eisner@gmail.com>
 Erik St. Martin <alakriti@gmail.com>
-Erik Westrup <erik.westrup@gmail.com>
 Esko Luontola <esko.luontola@gmail.com>
-Evan Kroske <evankroske@google.com>
 Evan Martin <evan.martin@gmail.com>
 Evan Shaw <chickencha@gmail.com>
 Ewan Chou <coocood@gmail.com>
-Fabrizio Milo <mistobaan@gmail.com>
 Fan Hongjian <fan.howard@gmail.com>
-Fatih Arslan <fatih@arslan.io>
 Fazlul Shahriar <fshahriar@gmail.com>
-Felix Geisendörfer <haimuiba@gmail.com>
 Firmansyah Adiputra <frm.adiputra@gmail.com>
 Florian Uekermann <florian@uekermann-online.de> <f1@uekermann-online.de>
 Florian Weimer <fw@deneb.enyo.de>
@@ -238,34 +196,23 @@ Folke Behrens <folke@google.com>
 Francesc Campoy <campoy@golang.org>
 Francisco Souza <franciscossouza@gmail.com>
 Frederick Kelly Mayle III <frederickmayle@gmail.com>
-Fredrik Enestad <fredrik.enestad@soundtrackyourbrand.com>
 Frithjof Schulze <schulze@math.uni-hannover.de> <sfrithjof@gmail.com>
 Fumitoshi Ukai <ukai@google.com>
 Gaal Yahas <gaal@google.com>
-Gabriel Aszalos <gabriel.aszalos@gmail.com>
 Gary Burd <gary@beagledreams.com> <gary.burd@gmail.com>
-Gautham Thambidorai <gautham.dorai@gmail.com>
 Georg Reinke <guelfey@gmail.com>
 Gerasimos Dimitriadis <gedimitr@gmail.com>
 Gideon Jan-Wessel Redelinghuys <gjredelinghuys@gmail.com>
 Giles Lean <giles.lean@pobox.com>
-Glenn Lewis <gmlewis@google.com>
-Gordon Klaus <gordon.klaus@gmail.com>
-Graham King <graham4king@gmail.com>
 Graham Miller <graham.miller@gmail.com>
 Greg Ward <greg@gerg.ca>
-Guillaume J. Charmes <guillaume@charmes.net>
 Gustav Paul <gustav.paul@gmail.com>
 Gustavo Franco <gustavorfranco@gmail.com>
 Gustavo Niemeyer <gustavo@niemeyer.net> <n13m3y3r@gmail.com>
 Gwenael Treguier <gwenn.kahz@gmail.com>
-Hana Kim <hyangah@gmail.com>
 Han-Wen Nienhuys <hanwen@google.com>
 Harley Laue <losinggeneration@gmail.com>
 Hector Chu <hectorchu@gmail.com>
-Hector Martin Cantero <hector@marcansoft.com>
-Henning Schmiedehausen <henning@schmiedehausen.org>
-Henrik Edwards <henrik.edwards@gmail.com>
 Herbert Georg Fischer <herbert.fischer@gmail.com>
 Hong Ruiqi <hongruiqi@gmail.com>
 Hossein Sheikh Attar <hattar@google.com>
@@ -276,14 +223,12 @@ Isaac Wagner <ibw@isaacwagner.me>
 Ivan Krasin <krasin@golang.org>
 Jacob Baskin <jbaskin@google.com>
 Jakob Borg <jakob@nym.se>
-Jakub Ryszard Czarnowicz <j.czarnowicz@gmail.com>
 James Aguilar <jaguilar@google.com>
 James David Chalfant <james.chalfant@gmail.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
 James Meneghello <rawrz0r@gmail.com>
 James P. Cooper <jamespcooper@gmail.com>
-James Robinson <jamesr@google.com> <jamesr.gatech@gmail.com>
 James Toy <nil@opensesame.st>
 James Tucker <raggi@google.com>
 James Whitehead <jnwhiteh@gmail.com>
@@ -297,16 +242,12 @@ Jan Newmarch <jan.newmarch@gmail.com>
 Jan Ziak <0xe2.0x9a.0x9b@gmail.com>
 Jani Monoses <jani.monoses@ubuntu.com> <jani.monoses@gmail.com>
 Jaroslavas Počepko <jp@webmaster.ms>
-Jason Del Ponte <delpontej@gmail.com>
 Jason Travis <infomaniac7@gmail.com>
-Jay Weisskopf <jay@jayschwa.net>
 Jean-Marc Eurin <jmeurin@google.com>
-Jed Denlea <jed@fastly.com>
 Jeff Hodges <jeff@somethingsimilar.com>
 Jeff R. Allen <jra@nella.org> <jeff.allen@gmail.com>
 Jeff Sickel <jas@corpus-callosum.com>
 Jeff Wendling <jeff@spacemonkey.com>
-Jens Frederich <jfrederich@gmail.com>
 Jeremiah Harmsen <jeremiah@google.com>
 Jeremy Jackins <jeremyjackins@gmail.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
@@ -315,19 +256,14 @@ Jimmy Zelinskie <jimmyzelinskie@gmail.com>
 Jingcheng Zhang <diogin@gmail.com>
 Joakim Sernbrant <serbaut@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
-Joe Shaw <joe@joeshaw.org>
 Joel Sing <jsing@google.com>
-Joel Stemmer <stemmertech@gmail.com>
 Johan Euphrosine <proppy@google.com>
 John Asmuth <jasmuth@gmail.com>
 John Beisley <huin@google.com>
-John C Barstow <jbowtie@amathaine.com>
 John DeNero <denero@google.com>
 John Graham-Cumming <jgc@jgc.org> <jgrahamc@gmail.com>
 John Howard Palevich <jack.palevich@gmail.com>
-John Newlin <jnewlin@google.com>
 John Shahid <jvshahid@gmail.com>
-John Tuley <john@tuley.org>
 Jonathan Allie <jonallie@google.com>
 Jonathan Feinberg <feinberg@google.com>
 Jonathan Gold <jgold.bg@gmail.com>
@@ -346,21 +282,16 @@ Josh Bleecher Snyder <josharian@gmail.com>
 Josh Goebel <dreamer3@gmail.com>
 Josh Hoak <jhoak@google.com>
 Josh Holland <jrh@joshh.co.uk>
-Joshua Chase <jcjoshuachase@gmail.com>
 JP Sugarbroad <jpsugar@google.com>
-JT Olds <jtolds@xnet5.com>
 Jukka-Pekka Kekkonen <karatepekka@gmail.com>
 Julian Phillips <julian@quantumfyre.co.uk>
 Julien Schmidt <google@julienschmidt.com>
 Kai Backman <kaib@golang.org>
 Kamil Kisiel <kamil@kamilkisiel.net> <kamil.kisiel@gmail.com>
 Katrina Owen <katrina.owen@gmail.com>
-Kay Zhu <kayzhu@google.com>
 Kei Son <hey.calmdown@gmail.com>
 Keith Randall <khr@golang.org>
 Keith Rarick <kr@xph.us>
-Kelsey Hightower <kelsey.hightower@gmail.com>
-Kelvin Foo Chuan Lyi <vmirage@gmail.com>
 Ken Friedenbach <kenliz@cruzio.com>
 Ken Rockot <ken@oz.gs> <ken.rockot@gmail.com>
 Ken Thompson <ken@golang.org>
@@ -368,7 +299,6 @@ Kevin Ballard <kevin@sb.org>
 Kevin Klues <klueska@gmail.com> <klueska@google.com>
 Kirklin McDonald <kirklin.mcdonald@gmail.com>
 Kyle Consalus <consalus@gmail.com>
-Kyle Isom <kyle@gokyle.net>
 Kyle Lemons <kyle@kylelemons.net> <kevlar@google.com>
 L Campbell <unpantsu@gmail.com>
 Lai Jiangshan <eag0628@gmail.com>
@@ -378,29 +308,19 @@ Louis Kruger <louisk@google.com>
 Luca Greco <luca.greco@alcacoop.it>
 Lucio De Re <lucio.dere@gmail.com>
 Luit van Drongelen <luitvd@gmail.com>
-Luka Zakrajšek <tr00.g33k@gmail.com>
-Luke Curley <qpingu@gmail.com>
 Luuk van Dijk <lvd@golang.org> <lvd@google.com>
-Manoj Dayaram <platform-dev@moovweb.com> <manoj.dayaram@moovweb.com>
 Manu Garg <manugarg@google.com>
-Manuel Mendez <mmendez534@gmail.com>
-Marc Weistroff <marc@weistroff.net>
 Marcel van Lohuizen <mpvl@golang.org>
 Marco Hennings <marco.hennings@freiheit.com>
-Mark Theunissen <mark.theunissen@gmail.com>
 Mark Zavislak <zavislak@google.com>
 Marko Juhani Silokunnas <marko.silokunnas@gmail.com>
 Marko Mikulicic <mkm@google.com>
-Marko Tiikkaja <marko@joh.to>
 Markus Duft <markus.duft@salomon.at>
 Markus Sonderegger <marraison@gmail.com>
-Markus Zimmermann <zimmski@gmail.com>
 Martin Neubauer <m.ne@gmx.net>
-Martin Olsson <martin@minimum.se>
 Mateusz Czapliński <czapkofan@gmail.com>
 Mathieu Lonjaret <mathieu.lonjaret@gmail.com>
 Mats Lidell <mats.lidell@cag.se> <mats.lidell@gmail.com>
-Matt Aimonetti <mattaimonetti@gmail.com>
 Matt Brown <mdbrown@google.com>
 Matt Jibson <matt.jibson@gmail.com>
 Matt Joiner <anacrolix@gmail.com>
@@ -409,21 +329,15 @@ Matt Reiferson <mreiferson@gmail.com>
 Matthew Cottingham <mattcottingham@gmail.com>
 Matthew Dempsky <mdempsky@google.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
-Maxim Khitrov <max@mxcrypt.com>
 Maxim Pimenov <mpimenov@google.com>
 Maxim Ushakov <ushakov@google.com>
 Micah Stetson <micah.stetson@gmail.com>
 Michael Chaten <mchaten@gmail.com>
 Michael Elkins <michael.elkins@gmail.com>
-Michael Fraenkel <michael.fraenkel@gmail.com>
-Michael Gehring <mg@ebfe.org> <gnirheg.leahcim@gmail.com>
+Michael Gehring <mg@ebfe.org>
 Michael Hoisie <hoisie@gmail.com>
-Michael Hudson-Doyle <michael.hudson@linaro.org>
-Michael Kelly <mjk@google.com>
 Michael Lewis <mikelikespie@gmail.com>
-Michael MacInnis <Michael.P.MacInnis@gmail.com>
 Michael Matloob <matloob@google.com>
-Michael Pearson <mipearson@gmail.com>
 Michael Piatek <piatek@google.com>
 Michael Shields <mshields@google.com>
 Michael Stapelberg <michael@stapelberg.de> <mstplbrg@googlemail.com>
@@ -431,29 +345,22 @@ Michael T. Jones <mtj@google.com> <michael.jones@gmail.com>
 Michael Teichgräber <mteichgraeber@gmx.de> <mt4swm@googlemail.com>
 Michał Derkacz <ziutek@lnet.pl>
 Miek Gieben <miek@miek.nl> <remigius.gieben@gmail.com>
-Mihai Borobocea <MihaiBorobocea@gmail.com>
 Mikael Tillenius <mikti42@gmail.com>
-Mike Andrews <mra@xoba.com>
 Mike Rosset <mike.rosset@gmail.com>
 Mike Samuel <mikesamuel@gmail.com>
 Mike Solomon <msolo@gmail.com>
-Mikhail Panchenko <m@mihasya.com>
 Miki Tebeka <miki.tebeka@gmail.com>
 Mikio Hara <mikioh.mikioh@gmail.com>
 Mikkel Krautz <mikkel@krautz.dk> <krautz@gmail.com>
 Miquel Sabaté Solà <mikisabate@gmail.com>
 Moriyoshi Koizumi <mozo@mozo.jp>
 Môshe van der Sterre <moshevds@gmail.com>
-Mrunal Patel <mrunalp@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nathan John Youngman <nj@nathany.com>
-Nathan P Finch <nate.finch@gmail.com>
-Nicholas Katsaros <nick@nickkatsaros.com>
 Nicholas Presta <nick@nickpresta.ca> <nick1presta@gmail.com>
 Nicholas Sullivan <nicholas.sullivan@gmail.com>
 Nicholas Waples <nwaples@gmail.com>
 Nick Craig-Wood <nick@craig-wood.com> <nickcw@gmail.com>
-Nicolas Kaiser <nikai@nikai.net>
 Nicolas Owens <mischief@offblast.org>
 Nigel Kerr <nigel.kerr@gmail.com>
 Nigel Tao <nigeltao@golang.org>
@@ -469,49 +376,35 @@ Pascal S. de Kloe <pascal@quies.net>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
-Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
-Patrick Riley <pfr@google.com>
 Patrick Smith <pat42smith@gmail.com>
-Paul A Querna <paul.querna@gmail.com>
 Paul Borman <borman@google.com>
 Paul Chang <paulchang@google.com>
-Paul Hammond <paul@paulhammond.org>
 Paul Lalonde <paul.a.lalonde@gmail.com>
-Paul Nasrat <pnasrat@google.com>
 Paul Sbarra <Sbarra.Paul@gmail.com>
 Paul van Brouwershaven <paul@vanbrouwershaven.com>
-Pavel Zinovkin <pavel.zinovkin@gmail.com>
 Pawel Szczur <filemon@google.com>
-Percy Wegmann <ox.to.a.cart@gmail.com>
 Petar Maymounkov <petarm@gmail.com>
 Peter Armitage <peter.armitage@gmail.com>
-Peter Collingbourne <pcc@google.com>
 Peter Froehlich <peter.hans.froehlich@gmail.com>
 Peter Kleiweg <pkleiweg@xs4all.nl>
 Peter McKenzie <petermck@google.com>
 Peter Mundy <go.peter.90@gmail.com>
 Péter Surányi <speter.go1@gmail.com>
 Péter Szabó <pts@google.com>
-Péter Szilágyi <peterke@gmail.com>
 Peter Waller <peter.waller@gmail.com>
 Peter Weinberger <pjw@golang.org>
 Peter Williams <pwil3058@gmail.com>
 Phil Pennock <pdp@golang.org>
 Philip K. Warren <pkwarren@gmail.com>
 Pieter Droogendijk <pieter@binky.org.uk>
-Pietro Gagliardi <pietro10@mac.com>
-Preetam Jinka <pj@preet.am>
 Quan Yong Zhai <qyzhai@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
 Raph Levien <raph@google.com>
-Raul Silvera <rsilvera@google.com>
 Rémy Oudompheng <oudomphe@phare.normalesup.org> <remyoudompheng@gmail.com>
-Richard Crowley <r@rcrowley.org>
 Richard Eric Gavaletz <gavaletz@gmail.com>
 Richard Musiol <mail@richard-musiol.de> <neelance@gmail.com>
 Rick Arnold <rickarnoldjr@gmail.com>
-Rick Hudson <rlh@golang.org>
 Risto Jaakko Saarelma <rsaarelm@gmail.com>
 Rob Pike <r@golang.org>
 Robert Daniel Kortschak <dan.kortschak@adelaide.edu.au>
@@ -520,30 +413,24 @@ Robert Figueiredo <robfig@gmail.com>
 Robert Griesemer <gri@golang.org>
 Robert Hencke <robert.hencke@gmail.com>
 Robert Obryk <robryk@gmail.com>
-Robert Sesek <rsesek@google.com>
 Robert Snedegar <roberts@google.com>
 Robin Eklind <r.eklind.87@gmail.com>
 Rodrigo Moraes de Oliveira <rodrigo.moraes@gmail.com>
 Rodrigo Rafael Monti Kochenburger <divoxx@gmail.com>
 Roger Pau Monné <royger@gmail.com>
 Roger Peppe <rogpeppe@gmail.com>
-Ron Hashimoto <mail@h2so5.net>
 Ron Minnich <rminnich@gmail.com>
 Ross Light <rlight2@gmail.com>
-Rowan Worth <sqweek@gmail.com>
-Rui Ueyama <ruiu@google.com>
 Russ Cox <rsc@golang.org>
 Ryan Barrett <ryanb@google.com>
 Ryan Hitchman <hitchmanr@gmail.com>
 Ryan Slade <ryanslade@gmail.com>
-S.Çağlar Onur <caglar@10ur.org>
 Sam Thorogood <thorogood@google.com> <sam.thorogood@gmail.com>
 Sameer Ajmani <sameer@golang.org> <ajmani@gmail.com>
 Sanjay Menakuru <balasanjay@gmail.com>
 Scott Ferguson <scottwferg@gmail.com>
 Scott Lawrence <bytbox@gmail.com>
 Scott Schwartz <scotts@golang.org>
-Sean Burford <sburford@google.com>
 Sebastien Binet	<seb.binet@gmail.com>
 Sébastien Paolacci <sebastien.paolacci@gmail.com>
 Sergei Skorobogatov <skorobo@rambler.ru>
@@ -552,12 +439,10 @@ Sergio Luis O. B. Correia <sergio@correia.cc>
 Shane Hansen <shanemhansen@gmail.com>
 Shawn Ledbetter <sledbetter@google.com>
 Shawn Smith <shawn.p.smith@gmail.com>
-Shenghou Ma <minux@golang.org> <minux.ma@gmail.com>
+Shenghou Ma <minux.ma@gmail.com>
 Shivakumar GN <shivakumar.gn@gmail.com>
-Simon Whitehead <chemnova@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Spring Mc <heresy.mc@gmail.com>
-StalkR <stalkr@stalkr.net>
 Stefan Nilsson <snilsson@nada.kth.se> <trolleriprofessorn@gmail.com>
 Stéphane Travostino <stephane.travostino@gmail.com>
 Stephen Ma <stephenm@golang.org>
@@ -565,7 +450,6 @@ Stephen McQuay <stephen@mcquay.me>
 Stephen Weinberg <stephen@q5comm.com>
 Steve McCoy <mccoyst@gmail.com>
 Steven Elliot Harris <seharris@gmail.com>
-Steven Hartland <steven.hartland@multiplay.co.uk>
 Sugu Sougoumarane <ssougou@gmail.com>
 Sven Almgren <sven@tras.se>
 Szabolcs Nagy <nsz@port70.net>
@@ -573,21 +457,15 @@ Tad Glines <tad.glines@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
 Taru Karttunen <taruti@taruti.net>
-Tetsuo Kiso <tetsuokiso9@gmail.com>
-Thiago Fransosi Farina <thiago.farina@gmail.com> <tfarina@chromium.org>
 Thomas Alan Copeland <talan.copeland@gmail.com>
 Thomas Habets <habets@google.com>
 Thomas Kappler <tkappler@gmail.com>
 Timo Savola <timo.savola@gmail.com>
-Timo Truyts <alkaloid.btx@gmail.com>
 Tobias Columbus <tobias.columbus@gmail.com> <tobias.columbus@googlemail.com>
 Todd Wang <toddwang@gmail.com>
-Tom Linford <tomlinford@gmail.com>
 Tom Szymanski <tgs@google.com>
 Tor Andersson <tor.andersson@gmail.com>
-Travis Cline <travis.cline@gmail.com>
 Trevor Strohman <trevor.strohman@gmail.com>
-Tudor Golubenco <tudor.g@gmail.com>
 Tw <tw19881113@gmail.com>
 Tyler Bunnell <tylerbunnell@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
@@ -606,10 +484,7 @@ Will Norris <willnorris@google.com>
 Willem van der Schyff <willemvds@gmail.com>
 William Chan <willchan@chromium.org>
 William Josephson <wjosephson@gmail.com>
-William Orr <will@worrbase.com> <ay1244@gmail.com>
-Xia Bin <snyh@snyh.org>
 Xing Xing <mikespook@gmail.com>
-Yan Zou <yzou@google.com>
 Yasuhiro Matsumoto <mattn.jp@gmail.com>
 Yissakhar Z. Beck <yissakhar.beck@gmail.com>
 Yongjian Xu <i3dmaster@gmail.com>
@@ -620,4 +495,3 @@ Yuval Pavel Zholkover <paulzhol@gmail.com>
 Yves Junqueira <yves.junqueira@gmail.com>
 Ziad Hatahet <hatahet@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
-申习之 <bronze1man@gmail.com>

VERSION

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

api/except.txt

@@ -5,10 +5,6 @@ pkg syscall (darwin-amd64), func Fchflags(string, int) error
 pkg syscall (darwin-amd64-cgo), func Fchflags(string, int) error
 pkg syscall (freebsd-386), func Fchflags(string, int) error
 pkg syscall (freebsd-amd64), func Fchflags(string, int) error
-pkg syscall (freebsd-arm), func Fchflags(string, int) error
-pkg syscall (freebsd-arm-cgo), func Fchflags(string, int) error
-pkg syscall (netbsd-arm), func Fchflags(string, int) error
-pkg syscall (netbsd-arm-cgo), func Fchflags(string, int) error
 pkg testing, func RegisterCover(Cover)
 pkg text/template/parse, type DotNode bool
 pkg text/template/parse, type Node interface { Copy, String, Type }
@@ -18,313 +14,3 @@ pkg syscall (darwin-386), const ImplementsGetwd = false
 pkg syscall (darwin-386-cgo), const ImplementsGetwd = false
 pkg syscall (darwin-amd64), const ImplementsGetwd = false
 pkg syscall (darwin-amd64-cgo), const ImplementsGetwd = false
-pkg syscall (openbsd-386), const BIOCGRTIMEOUT = 1074283118
-pkg syscall (openbsd-386), const BIOCSRTIMEOUT = 2148024941
-pkg syscall (openbsd-386), const RTF_FMASK = 63496
-pkg syscall (openbsd-386), const RTM_VERSION = 4
-pkg syscall (openbsd-386), const SIOCBRDGDADDR = 2150132039
-pkg syscall (openbsd-386), const SIOCBRDGGPARAM = 3224922456
-pkg syscall (openbsd-386), const SIOCBRDGSADDR = 3223873860
-pkg syscall (openbsd-386), const SYS_CLOCK_GETRES = 234
-pkg syscall (openbsd-386), const SYS_CLOCK_GETTIME = 232
-pkg syscall (openbsd-386), const SYS_CLOCK_SETTIME = 233
-pkg syscall (openbsd-386), const SYS_FHSTATFS = 309
-pkg syscall (openbsd-386), const SYS_FSTAT = 292
-pkg syscall (openbsd-386), const SYS_FSTATAT = 316
-pkg syscall (openbsd-386), const SYS_FSTATFS = 308
-pkg syscall (openbsd-386), const SYS_FUTIMENS = 327
-pkg syscall (openbsd-386), const SYS_FUTIMES = 206
-pkg syscall (openbsd-386), const SYS_GETDIRENTRIES = 312
-pkg syscall (openbsd-386), const SYS_GETDIRENTRIES ideal-int
-pkg syscall (openbsd-386), const SYS_GETFSSTAT = 306
-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_LSTAT = 293
-pkg syscall (openbsd-386), const SYS_NANOSLEEP = 240
-pkg syscall (openbsd-386), const SYS_SELECT = 93
-pkg syscall (openbsd-386), const SYS_SETITIMER = 83
-pkg syscall (openbsd-386), const SYS_SETTIMEOFDAY = 122
-pkg syscall (openbsd-386), const SYS_STAT = 291
-pkg syscall (openbsd-386), const SYS_STATFS = 307
-pkg syscall (openbsd-386), const SYS_UTIMENSAT = 326
-pkg syscall (openbsd-386), const SYS_UTIMES = 138
-pkg syscall (openbsd-386), const SYS_WAIT4 = 7
-pkg syscall (openbsd-386), const SYS___THRSLEEP = 300
-pkg syscall (openbsd-386), const SizeofIfData = 208
-pkg syscall (openbsd-386), const SizeofIfMsghdr = 232
-pkg syscall (openbsd-386), const SizeofRtMetrics = 48
-pkg syscall (openbsd-386), const SizeofRtMsghdr = 88
-pkg syscall (openbsd-386), const TIOCGTSTAMP = 1074295899
-pkg syscall (openbsd-386), type Dirent struct, Fileno uint32
-pkg syscall (openbsd-386), type FdSet struct, Bits [32]int32
-pkg syscall (openbsd-386), type Kevent_t struct, Data int32
-pkg syscall (openbsd-386), type Mclpool struct, Grown uint32
-pkg syscall (openbsd-386), type RtMetrics struct, Expire uint32
-pkg syscall (openbsd-386), type Stat_t struct, Ino uint32
-pkg syscall (openbsd-386), type Stat_t struct, Lspare0 int32
-pkg syscall (openbsd-386), type Stat_t struct, Lspare1 int32
-pkg syscall (openbsd-386), type Stat_t struct, Qspare [2]int64
-pkg syscall (openbsd-386), type Statfs_t struct, F_ctime uint32
-pkg syscall (openbsd-386), type Statfs_t struct, F_spare [3]uint32
-pkg syscall (openbsd-386), type Timespec struct, Sec int32
-pkg syscall (openbsd-386), type Timeval struct, Sec int32
-pkg syscall (openbsd-386-cgo), const BIOCGRTIMEOUT = 1074283118
-pkg syscall (openbsd-386-cgo), const BIOCSRTIMEOUT = 2148024941
-pkg syscall (openbsd-386-cgo), const RTF_FMASK = 63496
-pkg syscall (openbsd-386-cgo), const RTM_VERSION = 4
-pkg syscall (openbsd-386-cgo), const SIOCBRDGDADDR = 2150132039
-pkg syscall (openbsd-386-cgo), const SIOCBRDGGPARAM = 3224922456
-pkg syscall (openbsd-386-cgo), const SIOCBRDGSADDR = 3223873860
-pkg syscall (openbsd-386-cgo), const SYS_CLOCK_GETRES = 234
-pkg syscall (openbsd-386-cgo), const SYS_CLOCK_GETTIME = 232
-pkg syscall (openbsd-386-cgo), const SYS_CLOCK_SETTIME = 233
-pkg syscall (openbsd-386-cgo), const SYS_FHSTATFS = 309
-pkg syscall (openbsd-386-cgo), const SYS_FSTAT = 292
-pkg syscall (openbsd-386-cgo), const SYS_FSTATAT = 316
-pkg syscall (openbsd-386-cgo), const SYS_FSTATFS = 308
-pkg syscall (openbsd-386-cgo), const SYS_FUTIMENS = 327
-pkg syscall (openbsd-386-cgo), const SYS_FUTIMES = 206
-pkg syscall (openbsd-386-cgo), const SYS_GETDIRENTRIES = 312
-pkg syscall (openbsd-386-cgo), const SYS_GETDIRENTRIES ideal-int
-pkg syscall (openbsd-386-cgo), const SYS_GETFSSTAT = 306
-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_LSTAT = 293
-pkg syscall (openbsd-386-cgo), const SYS_NANOSLEEP = 240
-pkg syscall (openbsd-386-cgo), const SYS_SELECT = 93
-pkg syscall (openbsd-386-cgo), const SYS_SETITIMER = 83
-pkg syscall (openbsd-386-cgo), const SYS_SETTIMEOFDAY = 122
-pkg syscall (openbsd-386-cgo), const SYS_STAT = 291
-pkg syscall (openbsd-386-cgo), const SYS_STATFS = 307
-pkg syscall (openbsd-386-cgo), const SYS_UTIMENSAT = 326
-pkg syscall (openbsd-386-cgo), const SYS_UTIMES = 138
-pkg syscall (openbsd-386-cgo), const SYS_WAIT4 = 7
-pkg syscall (openbsd-386-cgo), const SYS___THRSLEEP = 300
-pkg syscall (openbsd-386-cgo), const SizeofIfData = 208
-pkg syscall (openbsd-386-cgo), const SizeofIfMsghdr = 232
-pkg syscall (openbsd-386-cgo), const SizeofRtMetrics = 48
-pkg syscall (openbsd-386-cgo), const SizeofRtMsghdr = 88
-pkg syscall (openbsd-386-cgo), const TIOCGTSTAMP = 1074295899
-pkg syscall (openbsd-386-cgo), type Dirent struct, Fileno uint32
-pkg syscall (openbsd-386-cgo), type FdSet struct, Bits [32]int32
-pkg syscall (openbsd-386-cgo), type Kevent_t struct, Data int32
-pkg syscall (openbsd-386-cgo), type Mclpool struct, Grown uint32
-pkg syscall (openbsd-386-cgo), type RtMetrics struct, Expire uint32
-pkg syscall (openbsd-386-cgo), type Stat_t struct, Ino uint32
-pkg syscall (openbsd-386-cgo), type Stat_t struct, Lspare0 int32
-pkg syscall (openbsd-386-cgo), type Stat_t struct, Lspare1 int32
-pkg syscall (openbsd-386-cgo), type Stat_t struct, Qspare [2]int64
-pkg syscall (openbsd-386-cgo), type Statfs_t struct, F_ctime uint32
-pkg syscall (openbsd-386-cgo), type Statfs_t struct, F_spare [3]uint32
-pkg syscall (openbsd-386-cgo), type Timespec struct, Sec int32
-pkg syscall (openbsd-386-cgo), type Timeval struct, Sec int32
-pkg syscall (openbsd-amd64), const CCR0_FLUSH = 16
-pkg syscall (openbsd-amd64), const CCR0_FLUSH ideal-int
-pkg syscall (openbsd-amd64), const CPUID_CFLUSH = 524288
-pkg syscall (openbsd-amd64), const CPUID_CFLUSH ideal-int
-pkg syscall (openbsd-amd64), const EFER_LMA = 1024
-pkg syscall (openbsd-amd64), const EFER_LMA ideal-int
-pkg syscall (openbsd-amd64), const EFER_LME = 256
-pkg syscall (openbsd-amd64), const EFER_LME ideal-int
-pkg syscall (openbsd-amd64), const EFER_NXE = 2048
-pkg syscall (openbsd-amd64), const EFER_NXE ideal-int
-pkg syscall (openbsd-amd64), const EFER_SCE = 1
-pkg syscall (openbsd-amd64), const EFER_SCE ideal-int
-pkg syscall (openbsd-amd64), const PMC5_PIPELINE_FLUSH = 21
-pkg syscall (openbsd-amd64), const PMC5_PIPELINE_FLUSH ideal-int
-pkg syscall (openbsd-amd64), const RTF_FMASK = 63496
-pkg syscall (openbsd-amd64), const RTM_VERSION = 4
-pkg syscall (openbsd-amd64), const SIOCBRDGDADDR = 2150132039
-pkg syscall (openbsd-amd64), const SIOCBRDGSADDR = 3223873860
-pkg syscall (openbsd-amd64), const SYS_CLOCK_GETRES = 234
-pkg syscall (openbsd-amd64), const SYS_CLOCK_GETTIME = 232
-pkg syscall (openbsd-amd64), const SYS_CLOCK_SETTIME = 233
-pkg syscall (openbsd-amd64), const SYS_FHSTATFS = 309
-pkg syscall (openbsd-amd64), const SYS_FSTAT = 292
-pkg syscall (openbsd-amd64), const SYS_FSTATAT = 316
-pkg syscall (openbsd-amd64), const SYS_FSTATFS = 308
-pkg syscall (openbsd-amd64), const SYS_FUTIMENS = 327
-pkg syscall (openbsd-amd64), const SYS_FUTIMES = 206
-pkg syscall (openbsd-amd64), const SYS_GETDIRENTRIES = 312
-pkg syscall (openbsd-amd64), const SYS_GETDIRENTRIES ideal-int
-pkg syscall (openbsd-amd64), const SYS_GETFSSTAT = 306
-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_LSTAT = 293
-pkg syscall (openbsd-amd64), const SYS_NANOSLEEP = 240
-pkg syscall (openbsd-amd64), const SYS_SELECT = 93
-pkg syscall (openbsd-amd64), const SYS_SETITIMER = 83
-pkg syscall (openbsd-amd64), const SYS_SETTIMEOFDAY = 122
-pkg syscall (openbsd-amd64), const SYS_STAT = 291
-pkg syscall (openbsd-amd64), const SYS_STATFS = 307
-pkg syscall (openbsd-amd64), const SYS_UTIMENSAT = 326
-pkg syscall (openbsd-amd64), const SYS_UTIMES = 138
-pkg syscall (openbsd-amd64), const SYS_WAIT4 = 7
-pkg syscall (openbsd-amd64), const SYS___THRSLEEP = 300
-pkg syscall (openbsd-amd64), const SizeofRtMetrics = 48
-pkg syscall (openbsd-amd64), const SizeofRtMsghdr = 88
-pkg syscall (openbsd-amd64), type Dirent struct, Fileno uint32
-pkg syscall (openbsd-amd64), type FdSet struct, Bits [32]int32
-pkg syscall (openbsd-amd64), type Kevent_t struct, Data int32
-pkg syscall (openbsd-amd64), type Kevent_t struct, Ident uint32
-pkg syscall (openbsd-amd64), type Mclpool struct, Grown uint32
-pkg syscall (openbsd-amd64), type RtMetrics struct, Expire uint32
-pkg syscall (openbsd-amd64), type Stat_t struct, Ino uint32
-pkg syscall (openbsd-amd64), type Stat_t struct, Lspare0 int32
-pkg syscall (openbsd-amd64), type Stat_t struct, Lspare1 int32
-pkg syscall (openbsd-amd64), type Stat_t struct, Qspare [2]int64
-pkg syscall (openbsd-amd64), type Statfs_t struct, F_ctime uint32
-pkg syscall (openbsd-amd64), type Statfs_t struct, F_spare [3]uint32
-pkg syscall (openbsd-amd64), type Statfs_t struct, Pad_cgo_1 [4]uint8
-pkg syscall (openbsd-amd64), type Timespec struct, Pad_cgo_0 [4]uint8
-pkg syscall (openbsd-amd64), type Timespec struct, Sec int32
-pkg syscall (openbsd-amd64-cgo), const CCR0_FLUSH = 16
-pkg syscall (openbsd-amd64-cgo), const CCR0_FLUSH ideal-int
-pkg syscall (openbsd-amd64-cgo), const CPUID_CFLUSH = 524288
-pkg syscall (openbsd-amd64-cgo), const CPUID_CFLUSH ideal-int
-pkg syscall (openbsd-amd64-cgo), const EFER_LMA = 1024
-pkg syscall (openbsd-amd64-cgo), const EFER_LMA ideal-int
-pkg syscall (openbsd-amd64-cgo), const EFER_LME = 256
-pkg syscall (openbsd-amd64-cgo), const EFER_LME ideal-int
-pkg syscall (openbsd-amd64-cgo), const EFER_NXE = 2048
-pkg syscall (openbsd-amd64-cgo), const EFER_NXE ideal-int
-pkg syscall (openbsd-amd64-cgo), const EFER_SCE = 1
-pkg syscall (openbsd-amd64-cgo), const EFER_SCE ideal-int
-pkg syscall (openbsd-amd64-cgo), const PMC5_PIPELINE_FLUSH = 21
-pkg syscall (openbsd-amd64-cgo), const PMC5_PIPELINE_FLUSH ideal-int
-pkg syscall (openbsd-amd64-cgo), const RTF_FMASK = 63496
-pkg syscall (openbsd-amd64-cgo), const RTM_VERSION = 4
-pkg syscall (openbsd-amd64-cgo), const SIOCBRDGDADDR = 2150132039
-pkg syscall (openbsd-amd64-cgo), const SIOCBRDGSADDR = 3223873860
-pkg syscall (openbsd-amd64-cgo), const SYS_CLOCK_GETRES = 234
-pkg syscall (openbsd-amd64-cgo), const SYS_CLOCK_GETTIME = 232
-pkg syscall (openbsd-amd64-cgo), const SYS_CLOCK_SETTIME = 233
-pkg syscall (openbsd-amd64-cgo), const SYS_FHSTATFS = 309
-pkg syscall (openbsd-amd64-cgo), const SYS_FSTAT = 292
-pkg syscall (openbsd-amd64-cgo), const SYS_FSTATAT = 316
-pkg syscall (openbsd-amd64-cgo), const SYS_FSTATFS = 308
-pkg syscall (openbsd-amd64-cgo), const SYS_FUTIMENS = 327
-pkg syscall (openbsd-amd64-cgo), const SYS_FUTIMES = 206
-pkg syscall (openbsd-amd64-cgo), const SYS_GETDIRENTRIES = 312
-pkg syscall (openbsd-amd64-cgo), const SYS_GETDIRENTRIES ideal-int
-pkg syscall (openbsd-amd64-cgo), const SYS_GETFSSTAT = 306
-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_LSTAT = 293
-pkg syscall (openbsd-amd64-cgo), const SYS_NANOSLEEP = 240
-pkg syscall (openbsd-amd64-cgo), const SYS_SELECT = 93
-pkg syscall (openbsd-amd64-cgo), const SYS_SETITIMER = 83
-pkg syscall (openbsd-amd64-cgo), const SYS_SETTIMEOFDAY = 122
-pkg syscall (openbsd-amd64-cgo), const SYS_STAT = 291
-pkg syscall (openbsd-amd64-cgo), const SYS_STATFS = 307
-pkg syscall (openbsd-amd64-cgo), const SYS_UTIMENSAT = 326
-pkg syscall (openbsd-amd64-cgo), const SYS_UTIMES = 138
-pkg syscall (openbsd-amd64-cgo), const SYS_WAIT4 = 7
-pkg syscall (openbsd-amd64-cgo), const SYS___THRSLEEP = 300
-pkg syscall (openbsd-amd64-cgo), const SizeofRtMetrics = 48
-pkg syscall (openbsd-amd64-cgo), const SizeofRtMsghdr = 88
-pkg syscall (openbsd-amd64-cgo), type Dirent struct, Fileno uint32
-pkg syscall (openbsd-amd64-cgo), type FdSet struct, Bits [32]int32
-pkg syscall (openbsd-amd64-cgo), type Kevent_t struct, Data int32
-pkg syscall (openbsd-amd64-cgo), type Kevent_t struct, Ident uint32
-pkg syscall (openbsd-amd64-cgo), type Mclpool struct, Grown uint32
-pkg syscall (openbsd-amd64-cgo), type RtMetrics struct, Expire uint32
-pkg syscall (openbsd-amd64-cgo), type Stat_t struct, Ino uint32
-pkg syscall (openbsd-amd64-cgo), type Stat_t struct, Lspare0 int32
-pkg syscall (openbsd-amd64-cgo), type Stat_t struct, Lspare1 int32
-pkg syscall (openbsd-amd64-cgo), type Stat_t struct, Qspare [2]int64
-pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, F_ctime uint32
-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 unicode, const Version = "6.2.0"
-pkg syscall (freebsd-386), const AF_MAX = 38
-pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-386), const ELAST = 94
-pkg syscall (freebsd-386), const O_CLOEXEC = 0
-pkg syscall (freebsd-386-cgo), const AF_MAX = 38
-pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-386-cgo), const ELAST = 94
-pkg syscall (freebsd-386-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-amd64), const AF_MAX = 38
-pkg syscall (freebsd-amd64), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-amd64), const ELAST = 94
-pkg syscall (freebsd-amd64), const O_CLOEXEC = 0
-pkg syscall (freebsd-amd64-cgo), const AF_MAX = 38
-pkg syscall (freebsd-amd64-cgo), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-amd64-cgo), const ELAST = 94
-pkg syscall (freebsd-amd64-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm), const AF_MAX = 38
-pkg syscall (freebsd-arm), const BIOCGRTIMEOUT = 1074545262
-pkg syscall (freebsd-arm), const BIOCSRTIMEOUT = 2148287085
-pkg syscall (freebsd-arm), const ELAST = 94
-pkg syscall (freebsd-arm), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm), const SIOCAIFADDR = 2151967019
-pkg syscall (freebsd-arm), const SIOCGIFSTATUS = 3274991931
-pkg syscall (freebsd-arm), const SIOCSIFPHYADDR = 2151967046
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET = 537
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT = 536
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET = 535
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT = 534
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET = 515
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT = 533
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SizeofBpfHdr = 24
-pkg syscall (freebsd-arm), const SizeofIfData = 88
-pkg syscall (freebsd-arm), const SizeofIfMsghdr = 104
-pkg syscall (freebsd-arm), const SizeofSockaddrDatalink = 56
-pkg syscall (freebsd-arm), const SizeofSockaddrUnix = 108
-pkg syscall (freebsd-arm), const TIOCTIMESTAMP = 1074558041
-pkg syscall (freebsd-arm), type BpfHdr struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type Stat_t struct, Pad_cgo_0 [4]uint8
-pkg syscall (freebsd-arm-cgo), const AF_MAX = 38
-pkg syscall (freebsd-arm-cgo), const BIOCGRTIMEOUT = 1074545262
-pkg syscall (freebsd-arm-cgo), const BIOCSRTIMEOUT = 2148287085
-pkg syscall (freebsd-arm-cgo), const ELAST = 94
-pkg syscall (freebsd-arm-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm-cgo), const SIOCAIFADDR = 2151967019
-pkg syscall (freebsd-arm-cgo), const SIOCGIFSTATUS = 3274991931
-pkg syscall (freebsd-arm-cgo), const SIOCSIFPHYADDR = 2151967046
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET = 537
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT = 536
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET = 535
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT = 534
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET = 515
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT = 533
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SizeofBpfHdr = 24
-pkg syscall (freebsd-arm-cgo), const SizeofIfData = 88
-pkg syscall (freebsd-arm-cgo), const SizeofIfMsghdr = 104
-pkg syscall (freebsd-arm-cgo), const SizeofSockaddrDatalink = 56
-pkg syscall (freebsd-arm-cgo), const SizeofSockaddrUnix = 108
-pkg syscall (freebsd-arm-cgo), const TIOCTIMESTAMP = 1074558041
-pkg syscall (freebsd-arm-cgo), type BpfHdr struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Pad_cgo_0 [4]uint8
-pkg syscall (netbsd-arm), const SizeofIfData = 132
-pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
-pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
-pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
-pkg unicode, const Version = "6.3.0"

api/next.txt

@@ -1,141 +0,0 @@
-pkg debug/goobj, const SBSS = 21
-pkg debug/goobj, const SBSS SymKind
-pkg debug/goobj, const SCONST = 31
-pkg debug/goobj, const SCONST SymKind
-pkg debug/goobj, const SDATA = 19
-pkg debug/goobj, const SDATA SymKind
-pkg debug/goobj, const SDYNIMPORT = 32
-pkg debug/goobj, const SDYNIMPORT SymKind
-pkg debug/goobj, const SELFROSECT = 12
-pkg debug/goobj, const SELFROSECT SymKind
-pkg debug/goobj, const SELFRXSECT = 2
-pkg debug/goobj, const SELFRXSECT SymKind
-pkg debug/goobj, const SELFSECT = 14
-pkg debug/goobj, const SELFSECT SymKind
-pkg debug/goobj, const SFILE = 29
-pkg debug/goobj, const SFILE SymKind
-pkg debug/goobj, const SFILEPATH = 30
-pkg debug/goobj, const SFILEPATH SymKind
-pkg debug/goobj, const SFUNCTAB = 8
-pkg debug/goobj, const SFUNCTAB SymKind
-pkg debug/goobj, const SGOFUNC = 6
-pkg debug/goobj, const SGOFUNC SymKind
-pkg debug/goobj, const SGOSTRING = 5
-pkg debug/goobj, const SGOSTRING SymKind
-pkg debug/goobj, const SHOSTOBJ = 33
-pkg debug/goobj, const SHOSTOBJ SymKind
-pkg debug/goobj, const SINITARR = 18
-pkg debug/goobj, const SINITARR SymKind
-pkg debug/goobj, const SMACHO = 15
-pkg debug/goobj, const SMACHO SymKind
-pkg debug/goobj, const SMACHOGOT = 16
-pkg debug/goobj, const SMACHOGOT SymKind
-pkg debug/goobj, const SMACHOINDIRECTGOT = 28
-pkg debug/goobj, const SMACHOINDIRECTGOT SymKind
-pkg debug/goobj, const SMACHOINDIRECTPLT = 27
-pkg debug/goobj, const SMACHOINDIRECTPLT SymKind
-pkg debug/goobj, const SMACHOPLT = 13
-pkg debug/goobj, const SMACHOPLT SymKind
-pkg debug/goobj, const SMACHOSYMSTR = 25
-pkg debug/goobj, const SMACHOSYMSTR SymKind
-pkg debug/goobj, const SMACHOSYMTAB = 26
-pkg debug/goobj, const SMACHOSYMTAB SymKind
-pkg debug/goobj, const SNOPTRBSS = 22
-pkg debug/goobj, const SNOPTRBSS SymKind
-pkg debug/goobj, const SNOPTRDATA = 17
-pkg debug/goobj, const SNOPTRDATA SymKind
-pkg debug/goobj, const SPCLNTAB = 11
-pkg debug/goobj, const SPCLNTAB SymKind
-pkg debug/goobj, const SRODATA = 7
-pkg debug/goobj, const SRODATA SymKind
-pkg debug/goobj, const SSTRING = 4
-pkg debug/goobj, const SSTRING SymKind
-pkg debug/goobj, const SSYMTAB = 10
-pkg debug/goobj, const SSYMTAB SymKind
-pkg debug/goobj, const STEXT = 1
-pkg debug/goobj, const STEXT SymKind
-pkg debug/goobj, const STLSBSS = 23
-pkg debug/goobj, const STLSBSS SymKind
-pkg debug/goobj, const STYPE = 3
-pkg debug/goobj, const STYPE SymKind
-pkg debug/goobj, const STYPELINK = 9
-pkg debug/goobj, const STYPELINK SymKind
-pkg debug/goobj, const SWINDOWS = 20
-pkg debug/goobj, const SWINDOWS SymKind
-pkg debug/goobj, const SXREF = 24
-pkg debug/goobj, const SXREF SymKind
-pkg debug/goobj, func Parse(io.ReadSeeker, string) (*Package, error)
-pkg debug/goobj, method (Sym) String() string
-pkg debug/goobj, method (SymID) String() string
-pkg debug/goobj, method (SymKind) String() string
-pkg debug/goobj, type Data struct
-pkg debug/goobj, type Data struct, Offset int64
-pkg debug/goobj, type Data struct, Size int64
-pkg debug/goobj, type Func struct
-pkg debug/goobj, type Func struct, Args int
-pkg debug/goobj, type Func struct, File []string
-pkg debug/goobj, type Func struct, Frame int
-pkg debug/goobj, type Func struct, FuncData []FuncData
-pkg debug/goobj, type Func struct, Leaf bool
-pkg debug/goobj, type Func struct, NoSplit bool
-pkg debug/goobj, type Func struct, PCData []Data
-pkg debug/goobj, type Func struct, PCFile Data
-pkg debug/goobj, type Func struct, PCLine Data
-pkg debug/goobj, type Func struct, PCSP Data
-pkg debug/goobj, type Func struct, Var []Var
-pkg debug/goobj, type FuncData struct
-pkg debug/goobj, type FuncData struct, Offset int64
-pkg debug/goobj, type FuncData struct, Sym SymID
-pkg debug/goobj, type Package struct
-pkg debug/goobj, type Package struct, ImportPath string
-pkg debug/goobj, type Package struct, Imports []string
-pkg debug/goobj, type Package struct, MaxVersion int
-pkg debug/goobj, type Package struct, Syms []*Sym
-pkg debug/goobj, type Reloc struct
-pkg debug/goobj, type Reloc struct, Add int
-pkg debug/goobj, type Reloc struct, Offset int
-pkg debug/goobj, type Reloc struct, Size int
-pkg debug/goobj, type Reloc struct, Sym SymID
-pkg debug/goobj, type Reloc struct, Type int
-pkg debug/goobj, type Sym struct
-pkg debug/goobj, type Sym struct, Data Data
-pkg debug/goobj, type Sym struct, DupOK bool
-pkg debug/goobj, type Sym struct, Func *Func
-pkg debug/goobj, type Sym struct, Kind SymKind
-pkg debug/goobj, type Sym struct, Reloc []Reloc
-pkg debug/goobj, type Sym struct, Size int
-pkg debug/goobj, type Sym struct, Type SymID
-pkg debug/goobj, type Sym struct, embedded SymID
-pkg debug/goobj, type SymID struct
-pkg debug/goobj, type SymID struct, Name string
-pkg debug/goobj, type SymID struct, Version int
-pkg debug/goobj, type SymKind int
-pkg debug/goobj, type Var struct
-pkg debug/goobj, type Var struct, Kind int
-pkg debug/goobj, type Var struct, Name string
-pkg debug/goobj, type Var struct, Offset int
-pkg debug/goobj, type Var struct, Type SymID
-pkg unicode, const Version = "7.0.0"
-pkg unicode, var Bassa_Vah *RangeTable
-pkg unicode, var Caucasian_Albanian *RangeTable
-pkg unicode, var Duployan *RangeTable
-pkg unicode, var Elbasan *RangeTable
-pkg unicode, var Grantha *RangeTable
-pkg unicode, var Khojki *RangeTable
-pkg unicode, var Khudawadi *RangeTable
-pkg unicode, var Linear_A *RangeTable
-pkg unicode, var Mahajani *RangeTable
-pkg unicode, var Manichaean *RangeTable
-pkg unicode, var Mende_Kikakui *RangeTable
-pkg unicode, var Modi *RangeTable
-pkg unicode, var Mro *RangeTable
-pkg unicode, var Nabataean *RangeTable
-pkg unicode, var Old_North_Arabian *RangeTable
-pkg unicode, var Old_Permic *RangeTable
-pkg unicode, var Pahawh_Hmong *RangeTable
-pkg unicode, var Palmyrene *RangeTable
-pkg unicode, var Pau_Cin_Hau *RangeTable
-pkg unicode, var Psalter_Pahlavi *RangeTable
-pkg unicode, var Siddham *RangeTable
-pkg unicode, var Tirhuta *RangeTable
-pkg unicode, var Warang_Citi *RangeTable

doc/Makefile

@@ -0,0 +1,32 @@
+# Copyright 2009 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.
+
+RAWHTML=\
+	articles/defer_panic_recover.rawhtml\
+	articles/error_handling.rawhtml\
+	articles/slices_usage_and_internals.rawhtml\
+	articles/laws_of_reflection.rawhtml\
+	articles/c_go_cgo.rawhtml\
+	articles/concurrency_patterns.rawhtml\
+	articles/godoc_documenting_go_code.rawhtml\
+	articles/gobs_of_data.rawhtml\
+	articles/json_and_go.rawhtml\
+	articles/json_rpc_tale_of_interfaces.rawhtml\
+	articles/image_draw.rawhtml\
+	articles/image_package.rawhtml\
+	effective_go.rawhtml\
+	go1.rawhtml\
+
+all: $(RAWHTML)
+
+%.rawhtml: %.html
+	godoc -url /doc/$< >$@
+
+clean:
+	rm -f $(RAWHTML)
+
+compare:
+	for i in $(RAWHTML); do \
+		godoc -url /doc/$${i/.rawhtml/.html} | diff -u $$i -; \
+	done

doc/articles/go_command.html

@@ -99,7 +99,7 @@ deduce where to obtain the source code.</p>
 in a known way from the import path.  Specifically, the first choice
 is <code>$GOPATH/src/&lt;import-path&gt;</code>.  If <code>$GOPATH</code> is
 unset, the go command will fall back to storing source code alongside the
-standard Go packages, in <code>$GOROOT/src/&lt;import-path&gt;</code>.
+standard Go packages, in <code>$GOROOT/src/pkg/&lt;import-path&gt;</code>.
 If <code>$GOPATH</code> is set to a list of paths, the go command tries
 <code>&lt;dir&gt;/src/&lt;import-path&gt;</code> for each of the directories in
 that list.</p>

doc/articles/race_detector.html

@@ -1,389 +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>
-</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>
-
-<h2 id="Supported_Systems">Supported Systems</h2>
-
-<p>
-The race detector runs on <code>darwin/amd64</code>, <code>freebsd/amd64</code>,
-<code>linux/amd64</code>, and <code>windows/amd64</code>.
-</p>
-
-<h2 id="Runtime_Overheads">Runtime Overhead</h2>
-
-<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>

doc/articles/wiki/Makefile

@@ -0,0 +1,10 @@
+# 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.
+
+all: index.html
+
+CLEANFILES:=get.bin final-test.bin a.out
+
+clean:
+	rm -f $(CLEANFILES)

doc/articles/wiki/final.go

@@ -5,19 +5,12 @@
 package main
 
 import (
-	"flag"
 	"html/template"
 	"io/ioutil"
-	"log"
-	"net"
 	"net/http"
 	"regexp"
 )
 
-var (
-	addr = flag.Bool("addr", false, "find open address and print to final-port.txt")
-)
-
 type Page struct {
 	Title string
 	Body  []byte
@@ -88,24 +81,8 @@ func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.Handl
 }
 
 func main() {
-	flag.Parse()
 	http.HandleFunc("/view/", makeHandler(viewHandler))
 	http.HandleFunc("/edit/", makeHandler(editHandler))
 	http.HandleFunc("/save/", makeHandler(saveHandler))
-
-	if *addr {
-		l, err := net.Listen("tcp", "127.0.0.1:0")
-		if err != nil {
-			log.Fatal(err)
-		}
-		err = ioutil.WriteFile("final-port.txt", []byte(l.Addr().String()), 0644)
-		if err != nil {
-			log.Fatal(err)
-		}
-		s := &http.Server{}
-		s.Serve(l)
-		return
-	}
-
 	http.ListenAndServe(":8080", nil)
 }

doc/articles/wiki/index.html

@@ -466,7 +466,7 @@ header to the HTTP response.
 <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:
+<code>main</code>, let's implement the the handler:
 </p>
 
 {{code "doc/articles/wiki/final-template.go" `/^func saveHandler/` `/^}/`}}

doc/articles/wiki/test.bash

@@ -7,12 +7,10 @@ set -e
 wiki_pid=
 cleanup() {
 	kill $wiki_pid
-	rm -f test_*.out Test.txt final.bin final-port.txt a.out get.bin
+	rm -f test_*.out Test.txt final-test.bin final-test.go a.out get.bin
 }
 trap cleanup 0 INT
 
-rm -f get.bin final.bin a.out
-
 # If called with -all, check that all code snippets compile.
 if [ "$1" == "-all" ]; then
 	for fn in *.go; do
@@ -21,25 +19,13 @@ if [ "$1" == "-all" ]; then
 fi
 
 go build -o get.bin get.go
-go build -o final.bin final.go
-(./final.bin --addr) &
+addr=$(./get.bin -addr)
+sed s/:8080/$addr/ < final.go > final-test.go
+go build -o final-test.bin final-test.go
+(./final-test.bin) &
 wiki_pid=$!
 
-l=0
-while [ ! -f ./final-port.txt ]
-do
-	l=$(($l+1))
-	if [ "$l" -gt 5 ]
-	then
-		echo "port not available within 5 seconds"
-		exit 1
-		break
-	fi
-	sleep 1
-done
-
-addr=$(cat final-port.txt)
-./get.bin http://$addr/edit/Test > test_edit.out
+./get.bin --wait_for_port=5s http://$addr/edit/Test > test_edit.out
 diff -u test_edit.out test_edit.good
 ./get.bin -post=body=some%20content http://$addr/save/Test > test_save.out
 diff -u test_save.out test_view.good # should be the same as viewing

doc/asm.html

@@ -8,11 +8,7 @@
 <p>
 This document is a quick outline of the unusual form of assembly language used by the <code>gc</code>
 suite of Go compilers (<code>6g</code>, <code>8g</code>, etc.).
-The document is not comprehensive.
-</p>
-
-<p>
-The assembler is based on the input to the Plan 9 assemblers, which is documented in detail
+It is based on the input to the Plan 9 assemblers, which is documented in detail
 <a href="http://plan9.bell-labs.com/sys/doc/asm.html">on the Plan 9 site</a>.
 If you plan to write assembly language, you should read that document although much of it is Plan 9-specific.
 This document provides a summary of the syntax and
@@ -74,8 +70,6 @@ The <code>FUNCDATA</code> and <code>PCDATA</code> directives contain information
 for use by the garbage collector; they are introduced by the compiler.
 </p> 
 
-<!-- Commenting out because the feature is gone but it's popular and may come back.
-
 <p>
 To see what gets put in the binary after linking, add the <code>-a</code> flag to the linker:
 </p>
@@ -104,7 +98,6 @@ codeblk [0x2000,0x1d059) at offset 0x1000
 ...
 </pre>
 
--->
 
 <h3 id="symbols">Symbols</h3>
 
@@ -117,9 +110,6 @@ All user-defined symbols other than jump labels are written as offsets to these
 <p>
 The <code>SB</code> pseudo-register can be thought of as the origin of memory, so the symbol <code>foo(SB)</code>
 is the name <code>foo</code> as an address in memory.
-This form is used to name global functions and data.
-Adding <code>&lt;&gt;</code> to the name, as in <code>foo&lt;&gt;(SB)</code>, makes the name
-visible only in the current source file, like a top-level <code>static</code> declaration in a C file.
 </p>
 
 <p>
@@ -131,11 +121,8 @@ Thus <code>0(FP)</code> is the first argument to the function,
 When referring to a function argument this way, it is conventional to place the name
 at the beginning, as in <code>first_arg+0(FP)</code> and <code>second_arg+8(FP)</code>.
 Some of the assemblers enforce this convention, rejecting plain <code>0(FP)</code> and <code>8(FP)</code>.
-For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the argument names
+For assembly functions with Go prototypes, <code>go vet</code> will check that the argument names
 and offsets match.
-On 32-bit systems, the low and high 32 bits of a 64-bit value are distinguished by adding
-a <code>_lo</code> or <code>_hi</code> suffix to the name, as in <code>arg_lo+0(FP)</code> or <code>arg_hi+4(FP)</code>.
-If a Go prototype does not name its result, the expected assembly name is <code>ret</code>.
 </p>
 
 <p>
@@ -155,7 +142,7 @@ hardware's <code>SP</code> register.
 <p>
 Instructions, registers, and assembler directives are always in UPPER CASE to remind you
 that assembly programming is a fraught endeavor.
-(Exception: the <code>g</code> register renaming on ARM.)
+(Exceptions: the <code>m</code> and <code>g</code> register renamings on ARM.)
 </p>
 
 <p>
@@ -207,13 +194,11 @@ TEXT runtime·profileloop(SB),NOSPLIT,$8
 
 <p>
 In the general case, the frame size is followed by an argument size, separated by a minus sign.
-(It's not a subtraction, just idiosyncratic syntax.)
+(It's not an subtraction, just idiosyncratic syntax.)
 The frame size <code>$24-8</code> states that the function has a 24-byte frame
 and is called with 8 bytes of argument, which live on the caller's frame.
 If <code>NOSPLIT</code> is not specified for the <code>TEXT</code>,
 the argument size must be provided.
-For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the
-argument size is correct.
 </p>
 
 <p>
@@ -224,20 +209,19 @@ simple name <code>profileloop</code>.
 </p>
 
 <p>
-Global data symbols are defined by a sequence of initializing
-<code>DATA</code> directives followed by a <code>GLOBL</code> directive.
-Each <code>DATA</code> directive initializes a section of the
-corresponding memory.
-The memory not explicitly initialized is zeroed.
-The general form of the <code>DATA</code> directive is
+For <code>DATA</code> directives, the symbol is followed by a slash and the number
+of bytes the memory associated with the symbol occupies.
+The arguments are optional flags and the data itself.
+For instance,
+</p>
 
 <pre>
-DATA	symbol+offset(SB)/width, value
+DATA  runtime·isplan9(SB)/4, $1
 </pre>
 
 <p>
-which initializes the symbol memory at the given offset and width with the given value.
-The <code>DATA</code> directives for a given symbol must be written with increasing offsets.
+declares the local symbol <code>runtime·isplan9</code> of size 4 and value 1.
+Again the symbol has the middle dot and is offset from <code>SB</code>.
 </p>
 
 <p>
@@ -246,26 +230,15 @@ The arguments are optional flags and the size of the data being declared as a gl
 which will have initial value all zeros unless a <code>DATA</code> directive
 has initialized it.
 The <code>GLOBL</code> directive must follow any corresponding <code>DATA</code> directives.
-</p>
-
-<p>
-For example,
+This example
 </p>
 
 <pre>
-DATA divtab&lt;&gt;+0x00(SB)/4, $0xf4f8fcff
-DATA divtab&lt;&gt;+0x04(SB)/4, $0xe6eaedf0
-...
-DATA divtab&lt;&gt;+0x3c(SB)/4, $0x81828384
-GLOBL divtab&lt;&gt;(SB), RODATA, $64
-
-GLOBL runtime·tlsoffset(SB), NOPTR, $4
+GLOBL runtime·tlsoffset(SB),$4
 </pre>
 
 <p>
-declares and initializes <code>divtab&lt;&gt;</code>, a read-only 64-byte table of 4-byte integer values,
-and declares <code>runtime·tlsoffset</code>, a 4-byte, implicitly zeroed variable that
-contains no pointers.
+declares <code>runtime·tlsoffset</code> to have size 4.
 </p>
 
 <p>
@@ -273,7 +246,7 @@ There may be one or two arguments to the directives.
 If there are two, the first is a bit mask of flags,
 which can be written as numeric expressions, added or or-ed together,
 or can be set symbolically for easier absorption by a human.
-Their values, defined in the standard <code>#include</code>  file <code>textflag.h</code>, are:
+Their values, defined in the file <code>src/cmd/ld/textflag.h</code>, are:
 </p>
 
 <ul>
@@ -319,80 +292,6 @@ This is a wrapper function and should not count as disabling <code>recover</code
 </li>
 </ul>
 
-<h3 id="runtime">Runtime Coordination</h3>
-
-<p>
-For garbage collection to run correctly, the runtime must know the
-location of pointers in all global data and in most stack frames.
-The Go compiler emits this information when compiling Go source files,
-but assembly programs must define it explicitly.
-</p>
-
-<p>
-A data symbol marked with the <code>NOPTR</code> flag (see above)
-is treated as containing no pointers to runtime-allocated data.
-A data symbol with the <code>RODATA</code> flag
-is allocated in read-only memory and is therefore treated
-as implicitly marked <code>NOPTR</code>.
-A data symbol with a total size smaller than a pointer
-is also treated as implicitly marked <code>NOPTR</code>.
-It is not possible to define a symbol containing pointers in an assembly source file;
-such a symbol must be defined in a Go source file instead.
-Assembly source can still refer to the symbol by name
-even without <code>DATA</code> and <code>GLOBL</code> directives.
-A good general rule of thumb is to define all non-<code>RODATA</code>
-symbols in Go instead of in assembly.
-</p>
-
-<p>
-Each function also needs annotations giving the location of
-live pointers in its arguments, results, and local stack frame.
-For an assembly function with no pointer results and
-either no local stack frame or no function calls,
-the only requirement is to define a Go prototype for the function
-in a Go source file in the same package.
-For more complex situations, explicit annotation is needed.
-These annotations use pseudo-instructions defined in the standard
-<code>#include</code> file <code>funcdata.h</code>.
-</p>
-
-<p>
-If a function has no arguments and no results,
-the pointer information can be omitted.
-This is indicated by an argument size annotation of <code>$<i>n</i>-0</code>
-on the <code>TEXT</code> instruction.
-Otherwise, pointer information must be provided by
-a Go prototype for the function in a Go source file,
-even for assembly functions not called directly from Go.
-(The prototype will also let <code>go</code> <code>vet</code> check the argument references.)
-At the start of the function, the arguments are assumed
-to be initialized but the results are assumed uninitialized.
-If the results will hold live pointers during a call instruction,
-the function should start by zeroing the results and then 
-executing the pseudo-instruction <code>GO_RESULTS_INITIALIZED</code>.
-This instruction records that the results are now initialized
-and should be scanned during stack movement and garbage collection.
-It is typically easier to arrange that assembly functions do not
-return pointers or do not contain call instructions;
-no assembly functions in the standard library use
-<code>GO_RESULTS_INITIALIZED</code>.
-</p>
-
-<p>
-If a function has no local stack frame,
-the pointer information can be omitted.
-This is indicated by a local frame size annotation of <code>$0-<i>n</i></code>
-on the <code>TEXT</code> instruction.
-The pointer information can also be omitted if the
-function contains no call instructions.
-Otherwise, the local stack frame must not contain pointers,
-and the assembly must confirm this fact by executing the 
-pseudo-instruction <code>NO_LOCAL_POINTERS</code>.
-Because stack resizing is implemented by moving the stack,
-the stack pointer may change during any function call:
-even pointers to stack data must not be kept in local variables.
-</p>
-
 <h2 id="architectures">Architecture-specific details</h2>
 
 <p>
@@ -438,7 +337,7 @@ Here follows some descriptions of key Go-specific details for the supported arch
 <h3 id="x86">32-bit Intel 386</h3>
 
 <p>
-The runtime pointer to the <code>g</code> structure is maintained
+The runtime pointers to the <code>m</code> and <code>g</code> structures are maintained
 through the value of an otherwise unused (as far as Go is concerned) register in the MMU.
 A OS-dependent macro <code>get_tls</code> is defined for the assembler if the source includes
 an architecture-dependent header file, like this:
@@ -450,15 +349,14 @@ an architecture-dependent header file, like this:
 
 <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.
+with a pointer to a pair of words representing the <code>g</code> and <code>m</code> pointers.
 The sequence to load <code>g</code> and <code>m</code> using <code>CX</code> looks like this:
 </p>
 
 <pre>
 get_tls(CX)
-MOVL	g(CX), AX     // Move g into AX.
-MOVL	g_m(AX), BX   // Move g->m into BX.
+MOVL	g(CX), AX	// Move g into AX.
+MOVL	m(CX), BX	// Move m into BX.
 </pre>
 
 <h3 id="amd64">64-bit Intel 386 (a.k.a. amd64)</h3>
@@ -471,21 +369,22 @@ pointers is the same as on the 386, except it uses <code>MOVQ</code> rather than
 
 <pre>
 get_tls(CX)
-MOVQ	g(CX), AX     // Move g into AX.
-MOVQ	g_m(AX), BX   // Move g->m into BX.
+MOVQ	g(CX), AX	// Move g into AX.
+MOVQ	m(CX), BX	// Move m into BX.
 </pre>
 
 <h3 id="arm">ARM</h3>
 
 <p>
-The registers <code>R10</code> and <code>R11</code>
+The registers <code>R9</code>, <code>R10</code>, and <code>R11</code>
 are reserved by the compiler and linker.
 </p>
 
 <p>
-<code>R10</code> points to the <code>g</code> (goroutine) structure.
-Within assembler source code, this pointer must be referred to as <code>g</code>;
-the name <code>R10</code> is not recognized.
+<code>R9</code> and <code>R10</code> point to the <code>m</code> (machine) and <code>g</code>
+(goroutine) structures, respectively.
+Within assembler source code, these pointers must be referred to as <code>m</code> and <code>g</code>;
+the names <code>R9</code> and <code>R10</code> are not recognized.
 </p>
 
 <p>
@@ -528,10 +427,13 @@ Here's how the 386 runtime defines the 64-bit atomic load function.
 // so actually
 // void atomicload64(uint64 *res, uint64 volatile *addr);
 TEXT runtime·atomicload64(SB), NOSPLIT, $0-8
-	MOVL	ptr+0(FP), AX
-	LEAL	ret_lo+4(FP), BX
-	BYTE $0x0f; BYTE $0x6f; BYTE $0x00	// MOVQ (%EAX), %MM0
-	BYTE $0x0f; BYTE $0x7f; BYTE $0x03	// MOVQ %MM0, 0(%EBX)
-	BYTE $0x0F; BYTE $0x77			// EMMS
+	MOVL	4(SP), BX
+	MOVL	8(SP), AX
+	// MOVQ (%EAX), %MM0
+	BYTE $0x0f; BYTE $0x6f; BYTE $0x00
+	// MOVQ %MM0, 0(%EBX)
+	BYTE $0x0f; BYTE $0x7f; BYTE $0x03
+	// EMMS
+	BYTE $0x0F; BYTE $0x77
 	RET
 </pre>

doc/cmd.html

@@ -62,10 +62,10 @@ details.
 </tr>
 
 <tr>
-<td><a href="//godoc.org/code.google.com/p/go.tools/cmd/cover/">cover</a></td>
+<td><a href="http://godoc.org/code.google.com/p/go.tools/cmd/cover/">cover</a></td>
 <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
 <td>Cover is a program for creating and analyzing the coverage profiles
-generated by <code>"go test -coverprofile"</code>.</td>
+generated by <code>"go test -coverprofile"</code>.
 </tr>
 
 <tr>
@@ -83,13 +83,13 @@ gofmt</a> command with more general options.</td>
 </tr>
 
 <tr>
-<td><a href="//godoc.org/code.google.com/p/go.tools/cmd/godoc/">godoc</a></td>
+<td><a href="http://godoc.org/code.google.com/p/go.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="//godoc.org/code.google.com/p/go.tools/cmd/vet/">vet</a></td>
+<td><a href="http://godoc.org/code.google.com/p/go.tools/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>

doc/code.html

@@ -18,7 +18,7 @@ It explains the simplest way to get up and running with your Go installation.
 
 <p>
 A similar explanation is available as a
-<a href="//www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>.
+<a href="http://www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>.
 </p>
 
 
@@ -508,7 +508,7 @@ revision control system such as Git or Mercurial. The <code>go</code> tool uses
 this property to automatically fetch packages from remote repositories.
 For instance, the examples described in this document are also kept in a
 Mercurial repository hosted at Google Code,
-<code><a href="//code.google.com/p/go.example">code.google.com/p/go.example</a></code>.
+<code><a href="http://code.google.com/p/go.example">code.google.com/p/go.example</a></code>.
 If you include the repository URL in the package's import path,
 <code>go get</code> will fetch, build, and install it automatically:
 </p>
@@ -569,8 +569,8 @@ import "code.google.com/p/go.example/newmath"
 <p>
 This convention is the easiest way to make your Go packages available for
 others to use.
-The <a href="//code.google.com/p/go-wiki/wiki/Projects">Go Wiki</a>
-and <a href="//godoc.org/">godoc.org</a>
+The <a href="http://code.google.com/p/go-wiki/wiki/Projects">Go Wiki</a>
+and <a href="http://godoc.org/">godoc.org</a>
 provide lists of external Go projects.
 </p>
 
@@ -584,7 +584,7 @@ For more information on using remote repositories with the <code>go</code> tool,
 
 <p>
 Subscribe to the
-<a href="//groups.google.com/group/golang-announce">golang-announce</a>
+<a href="http://groups.google.com/group/golang-announce">golang-announce</a>
 mailing list to be notified when a new stable version of Go is released.
 </p>
 
@@ -594,7 +594,7 @@ clear, idiomatic Go code.
 </p>
 
 <p>
-Take <a href="//tour.golang.org/">A Tour of Go</a> to learn the language
+Take <a href="http://tour.golang.org/">A Tour of Go</a> to learn the language
 proper.
 </p>
 
@@ -613,10 +613,10 @@ For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
 
 <p>
 The official mailing list for discussion of the Go language is
-<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+<a href="http://groups.google.com/group/golang-nuts">Go Nuts</a>.
 </p>
 
 <p>
 Report bugs using the
-<a href="//code.google.com/p/go/issues/list">Go issue tracker</a>.
+<a href="http://code.google.com/p/go/issues/list">Go issue tracker</a>.
 </p>

doc/codewalk/sharemem.xml

@@ -171,7 +171,7 @@ and/or writes to a shared map.
 
 <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.
+primitives to share memory through commmunication.
 <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

doc/contrib.html

@@ -9,7 +9,7 @@
 
 <p>
 Go is an open source project developed by a team at
-<a href="//google.com/">Google</a> and many
+<a href="http://google.com/">Google</a> and many
 <a href="/CONTRIBUTORS">contributors</a> from the open source community.
 </p>
 
@@ -17,13 +17,13 @@ Go is an open source project developed by a team at
 Go is distributed under a <a href="/LICENSE">BSD-style license</a>.
 </p>
 
-<h3 id="announce"><a href="//groups.google.com/group/golang-announce">Announcements Mailing List</a></h3>
+<h3 id="announce"><a href="http://groups.google.com/group/golang-announce">Announcements Mailing List</a></h3>
 <p>
 A low traffic mailing list for important announcements, such as new releases.
 </p>
 <p>
 We encourage all Go users to subscribe to
-<a href="//groups.google.com/group/golang-announce">golang-announce</a>.
+<a href="http://groups.google.com/group/golang-announce">golang-announce</a>.
 </p>
 
 
@@ -37,13 +37,16 @@ We encourage all Go users to subscribe to
 A guide for updating your code to work with Go 1.
 </p>
 
-<h4 id="release notes"><a href="/doc/go1.1">Go 1.1 Release Notes</a></h4>
+<h4 id="go1.1notes"><a href="/doc/go1.1">Go 1.1 Release Notes</a></h4>
 <p>
-A list of significant changes in Go 1.1, with instructions for updating
-your code where necessary.
-Each point release includes a similar document appropriate for that
-release: <a href="/doc/go1.2">Go 1.2</a>, <a href="/doc/go1.3">Go 1.3</a>,
-and so on.
+A list of significant changes in Go 1.1, with instructions for updating your
+code where necessary.
+</p>
+
+<h4 id="go1.2notes"><a href="/doc/go1.2">Go 1.2 Release Notes</a></h4>
+<p>
+A list of significant changes in Go 1.2, with instructions for updating your
+code where necessary.
 </p>
 
 <h3 id="go1compat"><a href="/doc/go1compat">Go 1 and the Future of Go Programs</a></h3>
@@ -58,36 +61,29 @@ Go 1 matures.
 <h3 id="source"><a href="https://code.google.com/p/go/source">Source Code</a></h3>
 <p>Check out the Go source code.</p>
 
-<h3 id="golang-dev"><a href="https://groups.google.com/group/golang-dev">Developer</a> and
-<a href="https://groups.google.com/group/golang-codereviews">Code Review Mailing List</a></h3>
-<p>The <a href="https://groups.google.com/group/golang-dev">golang-dev</a>
-mailing list is for discussing code changes to the Go project.
-The <a href="https://groups.google.com/group/golang-codereviews">golang-codereviews</a>
-mailing list is for actual reviewing of the code changes (CLs).</p>
-
+<h3 id="golang-dev"><a href="http://groups.google.com/group/golang-dev">Developer Mailing List</a></h3>
+<p>The <a href="http://groups.google.com/group/golang-dev">golang-dev</a>
+mailing list is for discussing and reviewing code for the Go project.</p>
 <p>For general discussion of Go programming, see <a
-href="https://groups.google.com/group/golang-nuts">golang-nuts</a>.</p>
+href="http://groups.google.com/group/golang-nuts">golang-nuts</a>.</p>
 
-<h3 id="golang-checkins"><a href="https://groups.google.com/group/golang-checkins">Checkins Mailing List</a></h3>
+<h3 id="golang-checkins"><a href="http://groups.google.com/group/golang-checkins">Checkins Mailing List</a></h3>
 <p>A mailing list that receives a message summarizing each checkin to the Go repository.</p>
 
-<h3 id="golang-bugs"><a href="https://groups.google.com/group/golang-bugs">Bugs Mailing List</a></h3>
-<p>A mailing list that receives each update to the Go <a href="//golang.org/issue">issue tracker</a>.</p>
-
-<h3 id="build_status"><a href="//build.golang.org/">Build Status</a></h3>
+<h3 id="build_status"><a href="http://build.golang.org/">Build Status</a></h3>
 <p>View the status of Go builds across the supported operating
 systems and architectures.</p>
 
 
 <h2 id="howto">How you can help</h2>
 
-<h3><a href="https://code.google.com/p/go/issues">Reporting issues</a></h3>
+<h3><a href="http://code.google.com/p/go/issues">Reporting issues</a></h3>
 
 <p>
 If you spot bugs, mistakes, or inconsistencies in the Go project's code or
 documentation, please let us know by
-<a href="https://code.google.com/p/go/issues/entry">filing a ticket</a>
-on our <a href="https://code.google.com/p/go/issues">issue tracker</a>.
+<a href="http://code.google.com/p/go/issues/entry">filing a ticket</a>
+on our <a href="http://code.google.com/p/go/issues">issue tracker</a>.
 (Of course, you should check it's not an existing issue before creating
 a new one.)
 </p>
@@ -106,8 +102,8 @@ To get started, read these <a href="/doc/contribute.html">contribution
 guidelines</a> for information on design, testing, and our code review process.
 </p>
 <p>
-Check <a href="https://code.google.com/p/go/issues">the tracker</a> for 
+Check <a href="http://code.google.com/p/go/issues">the tracker</a> for 
 open issues that interest you. Those labeled
-<a href="https://code.google.com/p/go/issues/list?q=status=HelpWanted">HelpWanted</a>
+<a href="http://code.google.com/p/go/issues/list?q=status=HelpWanted">HelpWanted</a>
 are particularly in need of outside help.
 </p>

doc/contribute.html

@@ -22,7 +22,7 @@ you're working on if you want it to become part of the main repository.
 
 <p>
 Before undertaking to write something new for the Go project, send
-mail to the <a href="https://groups.google.com/group/golang-nuts">mailing
+mail to the <a href="http://groups.google.com/group/golang-nuts">mailing
 list</a> to discuss what you plan to do.  This gives everyone a
 chance to validate the design, helps prevent duplication of effort,
 and ensures that the idea fits inside the goals for the language
@@ -45,14 +45,10 @@ tree to make sure the changes don't break other packages or programs:
 </p>
 
 <pre>
-$ cd go/src
-$ ./all.bash
+cd $GOROOT/src
+./all.bash    # On Windows, run all.bat
 </pre>
 
-<p>
-(To build under Windows use <code>all.bat</code>.)
-</p>
-
 <p>
 After running for a while, the command should print "<code>ALL TESTS PASSED</code>".
 </p>
@@ -99,11 +95,11 @@ command.
 
 <h3>Configure the extension</h3>
 
-<p>Edit <code>.hg/hgrc</code> in the root of your Go checkout to add:</p>
+<p>Edit <code>$GOROOT/.hg/hgrc</code> to add:</p>
 
 <pre>
 [extensions]
-codereview = /path/to/go/lib/codereview/codereview.py
+codereview = $GOROOT/lib/codereview/codereview.py
 
 [ui]
 username = Your Name &lt;you@server.dom&gt;
@@ -114,16 +110,6 @@ The <code>username</code> information will not be used unless
 you are a committer (see below), but Mercurial complains if it is missing.
 </p>
 
-<p>
-As the codereview extension is only enabled for your Go checkout, the remainder of this document assumes you
-are inside the go directory when issuing commands.
-</p>
-
-<p>To contribute to subrepositories, edit the <code>.hg/hgrc</code> for each
-subrepository in the same way. For example, add the codereview extension to
-<code>code.google.com/p/go.tools/.hg/hgrc</code>.
-</p>
-
 <h3>Understanding the extension</h3>
 
 <p>After adding the code review extension, you can run</p>
@@ -140,10 +126,16 @@ $ hg help change
 </pre>
 
 <p>
-Windows users may need to perform extra steps to get the code review
+As the codereview extension is only enabled for your checkout
+in <code>$GOROOT</code>, the remainder of this document assumes you
+are inside <code>$GOROOT</code> when issuing commands.
+</p>
+
+<p>
+Windows users may need to perform extra steps to get the code review 
 extension working. See the
-<a href="https://code.google.com/p/go-wiki/wiki/CodeReview">CodeReview page</a>
-on the <a href="https://code.google.com/p/go-wiki/wiki">Go Wiki</a> for details.
+<a href="https://code.google.com/p/go-wiki/wiki/CodeReview">CodeReview page</a> 
+on the <a href="http://code.google.com/p/go-wiki/wiki">Go Wiki</a> for details.
 </p>
 
 <h3>Log in to the code review site.</h3>
@@ -154,7 +146,7 @@ The code review server uses a Google Account to authenticate.
 <a href="https://www.google.com/accounts/Login?hl=en&amp;continue=http://www.google.com/">sign in at google.com</a>,
 you can use it to sign in to the code review server.)
 The email address you use on the Code Review site
-will be recorded in the <a href="https://code.google.com/p/go/source/list">Mercurial change log</a>
+will be recorded in the <a href="http://code.google.com/p/go/source/list">Mercurial change log</a>
 and in the <a href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file.
 You can <a href="https://www.google.com/accounts/NewAccount">create a Google Account</a>
 associated with any address where you receive email.
@@ -163,6 +155,7 @@ application-specific password and use that when prompted for a password.
 </p>
 
 <pre>
+$ cd $GOROOT
 $ hg code-login
 Email (login for uploading to codereview.appspot.com): rsc@golang.org
 Password for rsc@golang.org:
@@ -172,7 +165,7 @@ Saving authentication cookies to /Users/rsc/.codereview_upload_cookies_coderevie
 
 <h3>Configure your account settings.</h3>
 
-<p>Edit your <a href="https://codereview.appspot.com/settings">code review settings</a>.
+<p>Edit your <a href="http://codereview.appspot.com/settings">code review settings</a>.
 Grab a nickname.
 Many people prefer to set the Context option to
 &ldquo;Whole file&rdquo; to see more context when reviewing changes.
@@ -234,9 +227,9 @@ Description:
 	&lt;enter description here&gt;
 
 Files:
-	src/math/sin.go
-	src/math/tan.go
-	src/regexp/regexp.go
+	src/pkg/math/sin.go
+	src/pkg/math/tan.go
+	src/pkg/regexp/regexp.go
 </pre>
 
 <p>
@@ -247,7 +240,7 @@ These can be code review nicknames or arbitrary email addresses.
 Unless explicitly told otherwise, such as in the discussion leading
 up to sending in the change list, leave the reviewer field blank.
 This means that the
-<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
+<a href="http://groups.google.com/group/golang-dev">golang-dev@googlegroups.com</a>
 mailing list will be used as the reviewer.
 </p>
 
@@ -277,7 +270,7 @@ After editing, the template might now read:
 # Lines beginning with # are ignored.
 # Multi-line values should be indented.
 
-Reviewer: golang-codereviews@googlegroups.com
+Reviewer: golang-dev@googlegroups.com
 CC: math-nuts@swtch.com
 
 Description:
@@ -287,17 +280,17 @@ Description:
 	Fixes issue 159.
 
 Files:
-	src/math/sin.go
-	src/math/tan.go
+	src/pkg/math/sin.go
+	src/pkg/math/tan.go
 </pre>
 
 <p>
 The special sentence &ldquo;Fixes issue 159.&rdquo; associates
-the change with issue 159 in the <a href="https://code.google.com/p/go/issues/list">Go issue tracker</a>.
+the change with issue 159 in the <a href="http://code.google.com/p/go/issues/list">Go issue tracker</a>.
 When this change is eventually submitted, the issue
 tracker will automatically mark the issue as fixed.
 (These conventions are described in detail by the
-<a href="https://code.google.com/p/support/wiki/IssueTracker#Integration_with_version_control">Google Project Hosting Issue Tracker documentation</a>.)
+<a href="http://code.google.com/p/support/wiki/IssueTracker#Integration_with_version_control">Google Project Hosting Issue Tracker documentation</a>.)
 </p>
 
 <p>
@@ -309,93 +302,9 @@ which <code>hg change</code> will print, something like:
 </p>
 
 <pre>
-CL created: https://codereview.appspot.com/99999
+CL created: http://codereview.appspot.com/99999
 </pre>
 
-<h3>Mail the change for review</h3>
-
-<p>
-Creating or uploading the change uploads a copy of the diff to the code review server,
-but it does not notify anyone about it. To do that, you need to run <code>hg mail</code>
-(see below).
-</p>
-
-<p>To send out a change for review, run <code>hg mail</code> using the change list number
-assigned during <code>hg change</code>:</p>
-
-<pre>
-$ hg mail 99999
-</pre>
-
-<p>You can add to the <code>Reviewer:</code> and <code>CC:</code> lines
-using the <code>-r</code> or <code>--cc</code> options.
-In the above example, we could have left the <code>Reviewer</code> and <code>CC</code>
-lines blank and then run:
-</p>
-
-<pre>
-$ hg mail -r golang-codereviews@googlegroups.com --cc math-nuts@swtch.com 99999
-</pre>
-
-<p>to achieve the same effect.</p>
-
-<p>Note that <code>-r</code> and <code>--cc</code> cannot be spelled <code>--r</code> or <code>-cc</code>.</p>
-
-<p>
-If your change relates to an open issue, please add a comment to the issue
-announcing your proposed fix, including a link to your CL.
-</p>
-
-<h3>Reviewing code</h3>
-
-<p>
-Running <code>hg mail</code> will send an email to you and the reviewers
-asking them to visit the issue's URL and make comments on the change.
-When done, the reviewer clicks &ldquo;Publish and Mail comments&rdquo;
-to send comments back.
-</p>
-
-
-<h3>Revise and upload</h3>
-
-<p>
-When you have revised the code and are ready for another round of review,
-you can upload your change and send mail asking the reviewers to
-please take another look (<code>PTAL</code>). Use the change list number
-assigned during <code>hg change</code>
-</p>
-
-<pre>
-$ hg mail 99999
-</pre>
-
-
-<p>
-Or to upload your change without sending a notification, run
-</p>
-
-<pre>
-$ hg upload 99999
-</pre>
-
-<p>
-You will probably revise your code in response to the reviewer comments.
-You might also visit the code review web page and reply to the comments,
-letting the reviewer know that you've addressed them or explain why you
-haven't.  When you're done replying, click &ldquo;Publish and Mail comments&rdquo;
-to send the line-by-line replies and any other comments.
-</p>
-
-<p>
-The reviewer can comment on the new copy, and the process repeats.
-The reviewer approves the change by replying with a mail that says
-<code>LGTM</code>: looks good to me.
-</p>
-
-<p>
-You can see a list of your pending changes by running <code>hg pending</code> (<code>hg p</code> for short).
-</p>
-
 <h3>Adding or removing files from an existing change</h3>
 
 <p>
@@ -457,11 +366,11 @@ adding changesets
 adding manifests
 adding file changes
 added 1 changeset with 2 changes to 2 files
-getting src/flag/flag.go
+getting src/pkg/flag/flag.go
 couldn't find merge tool hgmerge
-merging src/flag/flag_test.go
+merging src/pkg/flag/flag_test.go
 warning: conflicts during merge.
-<i>merging src/flag/flag_test.go failed!</i>
+<i>merging src/pkg/flag/flag_test.go failed!</i>
 1 file updated, 0 files merged, 0 files removed, 1 file unresolved
 use 'hg resolve' to retry unresolved file merges
 $
@@ -473,7 +382,7 @@ Mercurial failed to merge your changes with the independent change.
 When this happens, Mercurial leaves both edits in the file,
 marked by <code>&lt;&lt;&lt;&lt;&lt;&lt;&lt;</code> and
 <code>&gt;&gt;&gt;&gt;&gt;&gt;&gt;</code>.
-It is now your job to edit the file to combine them.
+it is now your job to edit the file to combine them.
 Continuing the example, searching for those strings in <code>flag_test.go</code>
 might turn up:
 </p>
@@ -517,6 +426,88 @@ changes, but you may still need to run
 <code>hg resolve -m</code> to mark the conflict resolved.
 </p>
 
+<h3>Mail the change for review</h3>
+
+<p>
+Creating or uploading the change uploads a copy of the diff to the code review server,
+but it does not notify anyone about it. To do that, you need to run <code>hg mail</code>
+(see below).
+</p>
+
+<p>To send out a change for review, run <code>hg mail</code> using the change list number
+assigned during <code>hg change</code>:</p>
+
+<pre>
+$ hg mail 99999
+</pre>
+
+<p>You can add to the <code>Reviewer:</code> and <code>CC:</code> lines
+using the <code>-r</code> or <code>--cc</code> options.
+In the above example, we could have left the <code>Reviewer</code> and <code>CC</code>
+lines blank and then run:
+</p>
+
+<pre>
+$ hg mail -r golang-dev@googlegroups.com --cc math-nuts@swtch.com 99999
+</pre>
+
+<p>to achieve the same effect.</p>
+
+<p>Note that <code>-r</code> and <code>--cc</code> cannot be spelled <code>--r</code> or <code>-cc</code>.</p>
+
+<p>
+If your change relates to an open issue, please add a comment to the issue
+announcing your proposed fix, including a link to your CL.
+</p>
+
+<h3>Reviewing code</h3>
+
+<p>
+Running <code>hg mail</code> will send an email to you and the reviewers
+asking them to visit the issue's URL and make comments on the change.
+When done, the reviewer clicks &ldquo;Publish and Mail comments&rdquo;
+to send comments back.
+</p>
+
+
+<h3>Revise and upload</h3>
+
+<p>
+You will probably revise your code in response to the reviewer comments. When
+you have done this, you can upload your change to the code review server
+without sending a notification by running <code>hg upload</code> using the change
+list number assigned during <code>hg change</code>
+</p>
+
+<pre>
+$ hg upload 99999
+</pre>
+
+<p>
+When you have revised the code and are ready for another round of review, run
+</p>
+
+<pre>
+$ hg mail 99999
+</pre>
+
+<p>again to upload the latest copy and send mail asking the reviewers to please take another look
+(<code>PTAL</code>).
+You might also visit the code review web page and reply to the comments,
+letting the reviewer know that you've addressed them or explain why you
+haven't.  When you're done replying, click &ldquo;Publish and Mail comments&rdquo;
+to send the line-by-line replies and any other comments.
+</p>
+<p>
+The reviewer can comment on the new copy, and the process repeats.
+The reviewer approves the change by replying with a mail that says
+<code>LGTM</code>: looks good to me.
+</p>
+
+<p>
+You can see a list of your pending changes by running <code>hg pending</code> (<code>hg p</code> for short).
+</p>
+
 <h3>Reviewing code by others</h3>
 
 <p>
@@ -606,18 +597,11 @@ $ hg submit 99999
 local repository out of date; must sync before submit
 </pre>
 
-<h3>More information</h3>
-
-<p>
-In addition to the information here, the Go community maintains a <a href="https://code.google.com/p/go-wiki/wiki/CodeReview">CodeReview</a> wiki page.
-Feel free to contribute to this page as you learn the review process.
-</p>
-
 <h2 id="copyright">Copyright</h2>
 
 <p>Files in the Go repository don't list author names,
 both to avoid clutter and to avoid having to keep the lists up to date.
-Instead, your name will appear in the <a href="https://code.google.com/p/go/source/list">Mercurial change log</a>
+Instead, your name will appear in the <a href="http://code.google.com/p/go/source/list">Mercurial change log</a>
 and in the <a href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file
 and perhaps the <a href="/AUTHORS"><code>AUTHORS</code></a> file.
 </p>
@@ -632,15 +616,13 @@ In order for them to do that, you need to have completed one of the
 contributor license agreements:
 <ul>
 <li>
-If you are the copyright holder, you will need to agree to the
-<a href="https://developers.google.com/open-source/cla/individual">individual
+If you are the copyright holder, you will need to agree to
+the <a href="http://code.google.com/legal/individual-cla-v1.0.html">individual
 contributor license agreement</a>, which can be completed online.
 </li>
 <li>
 If your organization is the copyright holder, the organization
-will need to agree to the
-<a href="https://developers.google.com/open-source/cla/corporate">corporate
-contributor license agreement</a>.
+will need to agree to the <a href="http://code.google.com/legal/corporate-cla-v1.0.html">corporate contributor license agreement</a>.
 (If the copyright holder for your code has already completed the
 agreement in connection with another Google open source project,
 it does not need to be completed again.)
@@ -654,7 +636,7 @@ This rigmarole needs to be done only for your first submission.
 <p>Code that you contribute should use the standard copyright header:</p>
 
 <pre>
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 </pre>

doc/debugging_with_gdb.html

@@ -9,23 +9,6 @@ Besides this overview you might want to consult the
 <a href="http://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
 </i></p>
 
-<p>
-GDB does not understand Go programs well.
-The stack management, threading, and runtime contain aspects that differ
-enough from the execution model GDB expects that they can confuse
-the debugger, even when the program is compiled with gccgo.
-As a consequence, although GDB can be useful in some situations, it is
-not a reliable debugger for Go programs, particularly heavily concurrent ones.
-Moreover, it is not a priority for the Go project to address these issues, which
-are difficult.
-In short, the instructions below should be taken only as a guide to how
-to use GDB when it works, not as a guarantee of success.
-</p>
-
-<p>
-In time, a more Go-centric debugging architecture may be required.
-</p>
-
 <h2 id="Introduction">Introduction</h2>
 
 <p>
@@ -36,8 +19,8 @@ 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 build -ldflags "-w" prog.go</code>).
+Pass the <code>'-s'</code> flag to the linker to omit the debug information
+(for example, <code>go build -ldflags "-s" prog.go</code>).
 </p>
 
 <p>
@@ -120,7 +103,7 @@ For example:
 
 <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
+href="/src/pkg/runtime/runtime-gdb.py">src/pkg/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
@@ -153,7 +136,7 @@ the form <code>pkg.(*MyType).Meth</code>.
 <p>
 In this tutorial we will inspect the binary of the
 <a href="/pkg/regexp/">regexp</a> package's unit tests. To build the binary,
-change to <code>$GOROOT/src/regexp</code> and run <code>go test -c</code>.
+change to <code>$GOROOT/src/pkg/regexp</code> and run <code>go test -c</code>.
 This should produce an executable file named <code>regexp.test</code>.
 </p>
 
@@ -172,7 +155,7 @@ License GPLv  3+: GNU GPL version 3 or later &lt;http://gnu.org/licenses/gpl.htm
 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...
+Reading symbols from  /home/user/go/src/pkg/regexp/regexp.test...
 done.
 Loading Go Runtime support.
 (gdb) 
@@ -180,7 +163,7 @@ Loading Go Runtime support.
 
 <p>
 The message <code>"Loading Go Runtime support"</code> means that GDB loaded the
-extension from <code>$GOROOT/src/runtime/runtime-gdb.py</code>.
+extension from <code>$GOROOT/src/pkg/runtime/runtime-gdb.py</code>.
 </p>
 
 <p>
@@ -199,7 +182,7 @@ it by hand by telling gdb (assuming you have the go sources in
 </p>
 
 <pre>
-(gdb) <b>source ~/go/src/runtime/runtime-gdb.py</b>
+(gdb) <b>source ~/go/src/pkg/runtime/runtime-gdb.py</b>
 Loading Go Runtime support.
 </pre>
 
@@ -259,7 +242,7 @@ Set a breakpoint at the <code>TestFind</code> function:
 
 <pre>
 (gdb) <b>b 'regexp.TestFind'</b>
-Breakpoint 1 at 0x424908: file /home/user/go/src/regexp/find_test.go, line 148.
+Breakpoint 1 at 0x424908: file /home/user/go/src/pkg/regexp/find_test.go, line 148.
 </pre>
 
 <p>
@@ -268,9 +251,9 @@ Run the program:
 
 <pre>
 (gdb) <b>run</b>
-Starting program: /home/user/go/src/regexp/regexp.test
+Starting program: /home/user/go/src/pkg/regexp/regexp.test
 
-Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
+Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/pkg/regexp/find_test.go:148
 148	func TestFind(t *testing.T) {
 </pre>
 
@@ -297,9 +280,9 @@ Look at the stack trace for where we’ve paused the program:
 
 <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
+#0  regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/pkg/regexp/find_test.go:148
+#1  0x000000000042f60b in testing.tRunner (t=0xf8404a89c0, test=0x573720) at /home/user/go/src/pkg/testing/testing.go:156
+#2  0x000000000040df64 in runtime.initdone () at /home/user/go/src/pkg/runtime/proc.c:242
 #3  0x000000f8404a89c0 in ?? ()
 #4  0x0000000000573720 in ?? ()
 #5  0x0000000000000000 in ?? ()
@@ -311,18 +294,18 @@ The other goroutine, number 1, is stuck in <code>runtime.gosched</code>, blocked
 
 <pre>
 (gdb) <b>goroutine 1 bt</b>
-#0  0x000000000040facb in runtime.gosched () at /home/user/go/src/runtime/proc.c:873
+#0  0x000000000040facb in runtime.gosched () at /home/user/go/src/pkg/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
+ at  /home/user/go/src/pkg/runtime/chan.c:342
+#2  0x0000000000403299 in runtime.chanrecv1 (t=void, c=void) at/home/user/go/src/pkg/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
+ 0x7ffff7f9ef60, tests=  []testing.InternalTest = {...}) at /home/user/go/src/pkg/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
+at /home/user/go/src/pkg/testing/testing.go:168
+#5  0x0000000000400dc1 in main.main () at /home/user/go/src/pkg/regexp/_testmain.go:98
+#6  0x00000000004022e7 in runtime.mainstart () at /home/user/go/src/pkg/runtime/amd64/asm.s:78
+#7  0x000000000040ea6f in runtime.initdone () at /home/user/go/src/pkg/runtime/proc.c:243
 #8  0x0000000000000000 in ?? ()
 </pre>
 
@@ -333,7 +316,7 @@ The stack frame shows we’re currently executing the <code>regexp.TestFind</cod
 <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); 
+ rip = 0x425530 in regexp.TestFind (/home/user/go/src/pkg/regexp/find_test.go:148); 
     saved rip 0x430233
  called by frame at 0x7ffff7f9ffa8
  source language minimal.
@@ -410,7 +393,7 @@ We can step into the <code>String</code>function call with <code>"s"</code>:
 
 <pre>
 (gdb) <b>s</b>
-regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/regexp/regexp.go:97
+regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/pkg/regexp/regexp.go:97
 97      func (re *Regexp) String() string {
 </pre>
 
@@ -421,12 +404,12 @@ Get a stack trace to see where we are:
 <pre>
 (gdb) <b>bt</b>
 #0  regexp.(*Regexp).String (re=0xf84068d070, noname=void)
-    at /home/user/go/src/regexp/regexp.go:97
+    at /home/user/go/src/pkg/regexp/regexp.go:97
 #1  0x0000000000425615 in regexp.TestFind (t=0xf840688b60)
-    at /home/user/go/src/regexp/find_test.go:151
+    at /home/user/go/src/pkg/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
+    at /home/user/go/src/pkg/testing/testing.go:156
+#3  0x000000000040ea6f in runtime.initdone () at /home/user/go/src/pkg/runtime/proc.c:243
 ....
 </pre>
 

doc/devel/release.html

@@ -3,7 +3,7 @@
 }-->
 
 <p>This page summarizes the changes between official stable releases of Go.
-The <a href="//code.google.com/p/go/source/list">Mercurial change log</a>
+The <a href="http://code.google.com/p/go/source/list">Mercurial change log</a>
 has the full details.</p>
 
 <p>To update to a specific release, use:</p>
@@ -13,30 +13,6 @@ hg pull
 hg update <i>tag</i>
 </pre>
 
-<h2 id="go1.3">go1.3 (released 2014/06/18)</h2>
-
-<p>
-Go 1.3 is a major release of Go.
-Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.3.minor">Minor revisions</h3>
-
-<p>
-go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=073fc578434bf3e1e22749b559d273c8da728ebb">change history</a> for details.
-</p>
-
-<p>
-go1.3.2 (released 2014/09/25) includes bug fixes to cgo and the crypto/tls packages.
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=go1.3.2">change history</a> for details.
-</p>
-
-<p>
-go1.3.3 (released 2014/09/30) includes further bug fixes to cgo, the runtime package, and the nacl port. 
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=go1.3.3">change history</a> for details.
-</p>
-
 <h2 id="go1.2">go1.2 (released 2013/12/01)</h2>
 
 <p>
@@ -48,13 +24,14 @@ Read the <a href="/doc/go1.2">Go 1.2 Release Notes</a> for more information.
 
 <p>
 go1.2.1 (released 2014/03/02) includes bug fixes to the <code>runtime</code>, <code>net</code>, and <code>database/sql</code> packages.
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.2&r=7ada9e760ce34e78aee5b476c9621556d0fa5d31">change history</a> for details.
+See the <a href="https://code.google.com/p/go/source/list?name=release-branch.go1.2&r=7ada9e760ce34e78aee5b476c9621556d0fa5d31">change history</a> for details.
 </p>
 
 <p>
 go1.2.2 (released 2014/05/05) includes a
-<a href="//code.google.com/p/go/source/detail?r=bda3619e7a2c&repo=tools">security fix</a>
+<a href="https://code.google.com/p/go/source/detail?r=bda3619e7a2c&repo=tools">security fix</a>
 that affects the tour binary included in the binary distributions (thanks to Guillaume T).
+This point release only affects binary distributions; no code in the main repository has changed. 
 </p>
 
 <h2 id="go1.1">go1.1 (released 2013/05/13)</h2>
@@ -68,18 +45,18 @@ Read the <a href="/doc/go1.1">Go 1.1 Release Notes</a> for more information.
 
 <p>
 go1.1.1 (released 2013/06/13) includes several compiler and runtime bug fixes.
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.1&r=43c4a41d24382a56a90e924800c681e435d9e399">change history</a> for details.
+See the <a href="https://code.google.com/p/go/source/list?name=release-branch.go1.1&r=43c4a41d24382a56a90e924800c681e435d9e399">change history</a> for details.
 </p>
 
 <p>
 go1.1.2 (released 2013/08/13) includes fixes to the <code>gc</code> compiler
 and <code>cgo</code>, and the <code>bufio</code>, <code>runtime</code>,
 <code>syscall</code>, and <code>time</code> packages.
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.1&r=a6a9792f94acd4ff686b2bc57383d163608b91cf">change history</a> for details.
+See the <a href="https://code.google.com/p/go/source/list?name=release-branch.go1.1&r=a6a9792f94acd4ff686b2bc57383d163608b91cf">change history</a> for details.
 If you use package syscall's <code>Getrlimit</code> and <code>Setrlimit</code>
 functions under Linux on the ARM or 386 architectures, please note change
-<a href="//golang.org/change/55ac276af5a7">55ac276af5a7</a>
-that fixes <a href="//golang.org/issue/5949">issue 5949</a>.
+<a href="http://golang.org/change/55ac276af5a7">55ac276af5a7</a>
+that fixes <a href="http://golang.org/issue/5949">issue 5949</a>.
 </p>
 
 <h2 id="go1">go1 (released 2012/03/28)</h2>
@@ -105,17 +82,17 @@ The go1 release corresponds to
 
 <p>
 go1.0.1 (released 2012/04/25) was issued to
-<a href="//golang.org/change/a890477d3dfb">fix</a> an
-<a href="//golang.org/issue/3545">escape analysis bug</a>
-that can lead to memory corruption.
+<a href="https://code.google.com/p/go/source/detail?r=a890477d3dfb">fix</a> an
+<a href="https://code.google.com/p/go/issues/detail?id=3545">escape analysis
+bug</a> that can lead to memory corruption.
 It also includes several minor code and documentation fixes.
 </p>
 
 <p>
 go1.0.2 (released 2012/06/13) was issued to fix two bugs in the implementation
 of maps using struct or array keys: 
-<a href="//golang.org/issue/3695">issue 3695</a> and
-<a href="//golang.org/issue/3573">issue 3573</a>.
+<a href="http://code.google.com/p/go/issues/detail?id=3695">issue 3695</a> and
+<a href="http://code.google.com/p/go/issues/detail?id=3573">issue 3573</a>.
 It also includes many minor code and documentation fixes.
 </p>
 
@@ -124,7 +101,7 @@ go1.0.3 (released 2012/09/21) includes minor code and documentation fixes.
 </p>
 
 <p>
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1">go1 release branch history</a> for the complete list of changes.
+See the <a href="http://code.google.com/p/go/source/list?name=release-branch.go1">go1 release branch history</a> for the complete list of changes.
 </p>
 
 <h2 id="r60">r60 (released 2011/09/07)</h2>
@@ -136,7 +113,7 @@ This section highlights the most significant changes in this release.
 For a more detailed summary, see the
 <a href="weekly.html#2011-08-17">weekly release notes</a>.
 For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r60">Mercurial change list</a>.
+<a href="http://code.google.com/p/go/source/list?r=release-branch.r60">Mercurial change list</a>.
 </p>
 
 <h3 id="r60.lang">Language</h3>
@@ -206,26 +183,26 @@ more accessible.
 
 <p>
 r60.1 includes a 
-<a href="//golang.org/change/1824581bf62d">linker
+<a href="http://code.google.com/p/go/source/detail?r=1824581bf62d">linker
 fix</a>, a pair of
-<a href="//golang.org/change/9ef4429c2c64">goplay</a>
-<a href="//golang.org/change/d42ed8c3098e">fixes</a>,
+<a href="http://code.google.com/p/go/source/detail?r=9ef4429c2c64">goplay</a>
+<a href="http://code.google.com/p/go/source/detail?r=d42ed8c3098e">fixes</a>,
 and a <code>json</code> package
-<a href="//golang.org/change/d5e97874fe84">fix</a> and
+<a href="http://code.google.com/p/go/source/detail?r=d5e97874fe84">fix</a> and
 a new
-<a href="//golang.org/change/4f0e6269213f">struct tag
+<a href="http://code.google.com/p/go/source/detail?r=4f0e6269213f">struct tag
 option</a>.
 </p>
 
 <p>
 r60.2
-<a href="//golang.org/change/ff19536042ac">fixes</a>
+<a href="http://code.google.com/p/go/source/detail?r=ff19536042ac">fixes</a>
 a memory leak involving maps.
 </p>
 
 <p>
 r60.3 fixes a
-<a href="//golang.org/change/01fa62f5e4e5">reflect bug</a>.
+<a href="http://code.google.com/p/go/source/detail?r=01fa62f5e4e5">reflect bug</a>.
 </p>
 
 <h2 id="r59">r59 (released 2011/08/01)</h2>
@@ -237,7 +214,7 @@ This section highlights the most significant changes in this release.
 For a more detailed summary, see the
 <a href="weekly.html#2011-07-07">weekly release notes</a>.
 For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r59">Mercurial change list</a>.
+<a href="http://code.google.com/p/go/source/list?r=release-branch.r59">Mercurial change list</a>.
 </p>
 
 <h3 id="r59.lang">Language</h3>
@@ -247,7 +224,7 @@ This release includes a language change that restricts the use of
 <code>goto</code>.  In essence, a <code>goto</code> statement outside a block
 cannot jump to a label inside that block. Your code may require changes if it
 uses <code>goto</code>.
-See <a href="//golang.org/change/dc6d3cf9279d">this
+See <a href="http://code.google.com/p/go/source/detail?r=dc6d3cf9279d">this
 changeset</a> for how the new rule affected the Go tree.
 </p>
 
@@ -345,13 +322,13 @@ This section highlights the most significant changes in this release.
 For a more detailed summary, see the
 <a href="weekly.html#2011-06-09">weekly release notes</a>.
 For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r58">Mercurial change list</a>.
+<a href="http://code.google.com/p/go/source/list?r=release-branch.r58">Mercurial change list</a>.
 </p>
 
 <h3 id="r58.lang">Language</h3>
 
 <p>
-This release fixes a <a href="//golang.org/change/b720749486e1">use of uninitialized memory in programs that misuse <code>goto</code></a>.
+This release fixes a <a href="http://code.google.com/p/go/source/detail?r=b720749486e1">use of uninitialized memory in programs that misuse <code>goto</code></a>.
 </p>
 
 <h3 id="r58.pkg">Packages</h3>
@@ -410,8 +387,8 @@ the Go tree (and avoid writing Makefiles).
 <h3 id="r58.minor">Minor revisions</h3>
 
 <p>r58.1 adds 
-<a href="//golang.org/change/293c25943586">build</a> and
-<a href="//golang.org/change/bf17e96b6582">runtime</a>
+<a href="http://code.google.com/p/go/source/detail?r=293c25943586">build</a> and
+<a href="http://code.google.com/p/go/source/detail?r=bf17e96b6582">runtime</a>
 changes to make Go run on OS X 10.7 Lion.
 </p>
 
@@ -425,7 +402,7 @@ This section highlights the most significant changes in this release.
 For a more detailed summary, see the
 <a href="weekly.html#2011-04-27">weekly release notes</a>.
 For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r57">Mercurial change list</a>.
+<a href="http://code.google.com/p/go/source/list?r=release-branch.r57">Mercurial change list</a>.
 </p>
 
 <p>The new <a href="/cmd/gofix">gofix</a> tool finds Go programs that use old APIs and rewrites them to use
@@ -436,7 +413,7 @@ future changes to the libraries.
 Gofix can’t
 handle all situations perfectly, so read and test the changes it makes before
 committing them.
-See <a href="//blog.golang.org/2011/04/introducing-gofix.html">the gofix blog post</a> for more
+See <a href="http://blog.golang.org/2011/04/introducing-gofix.html">the gofix blog post</a> for more
 information.</p>
 
 <h3 id="r57.lang">Language</h3>
@@ -482,7 +459,7 @@ For clients, there are new
 <a href="/pkg/http/#Client">Client</a> and <a href="/pkg/http/#Transport">Transport</a>
 abstractions that give more control over HTTP details such as headers sent
 and redirections followed.  These abstractions make it easy to implement
-custom clients that add functionality such as <a href="//code.google.com/p/goauth2/source/browse/oauth/oauth.go">OAuth2</a>.
+custom clients that add functionality such as <a href="http://code.google.com/p/goauth2/source/browse/oauth/oauth.go">OAuth2</a>.
 For servers, <a href="/pkg/http/#ResponseWriter">ResponseWriter</a>
 has dropped its non-essential methods.
 The Hijack and Flush methods are no longer required;
@@ -526,7 +503,7 @@ implements all the possible value methods.
 Instead of a type switch on a Value <code>v</code>, switch on <code>v.Kind()</code>.
 Typeof and NewValue are now called <a href="/pkg/reflect/#Type.TypeOf">TypeOf</a> and <a href="/pkg/reflect/#Value.ValueOf">ValueOf</a>
 To create a writable Value, use <code>New(t).Elem()</code> instead of <code>Zero(t)</code>.
-See <a href="//golang.org/change/843855f3c026">the change description</a>
+See <a href="http://code.google.com/p/go/source/detail?r=843855f3c026">the change description</a>
 for the full details.
 The new API allows a more efficient implementation of Value
 that avoids many of the allocations required by the previous API.
@@ -562,8 +539,8 @@ For other uses, see the <a href="/pkg/runtime/pprof/">runtime/pprof</a> document
 
 <h3 id="r57.minor">Minor revisions</h3>
 
-<p>r57.1 fixes a <a href="//golang.org/change/ff2bc62726e7145eb2ecc1e0f076998e4a8f86f0">nil pointer dereference in http.FormFile</a>.</p>
-<p>r57.2 fixes a <a href="//golang.org/change/063b0ff67d8277df03c956208abc068076818dae">use of uninitialized memory in programs that misuse <code>goto</code></a>.</p>
+<p>r57.1 fixes a <a href="http://code.google.com/p/go/source/detail?r=ff2bc62726e7145eb2ecc1e0f076998e4a8f86f0">nil pointer dereference in http.FormFile</a>.</p>
+<p>r57.2 fixes a <a href="http://code.google.com/p/go/source/detail?r=063b0ff67d8277df03c956208abc068076818dae">use of uninitialized memory in programs that misuse <code>goto</code></a>.</p>
 
 <h2 id="r56">r56 (released 2011/03/16)</h2>
 

doc/devel/weekly.html

@@ -5,7 +5,7 @@
 <p>This page summarizes the changes between tagged weekly snapshots of Go.
 Such snapshots are no longer created. This page remains as a historical reference only.</p>
 
-<p>For recent information, see the <a href="//code.google.com/p/go/source/list">Mercurial change log</a> and <a href="//groups.google.com/group/golang-dev/">development mailing list</a>.</p>
+<p>For recent information, see the <a href="http://code.google.com/p/go/source/list">Mercurial change log</a> and <a href="http://groups.google.com/group/golang-dev/">development mailing list</a>.</p>
 
 <h2 id="2012-03-27">2012-03-27 (<a href="release.html#go1">Go 1</a>)</h2>
 

doc/docs.html

@@ -33,20 +33,20 @@ libraries.
 
 <img class="gopher" src="/doc/gopher/doc.png"/>
 
-<h3 id="go_tour"><a href="//tour.golang.org/">A Tour of Go</a></h3>
+<h3 id="go_tour"><a href="http://tour.golang.org/">A Tour of Go</a></h3>
 <p>
 An interactive introduction to Go in three sections.
 The first section covers basic syntax and data structures; the second discusses
 methods and interfaces; and the third introduces Go's concurrency primitives.
 Each section concludes with a few exercises so you can practice what you've
-learned. You can <a href="//tour.golang.org/">take the tour online</a> or
-<a href="//code.google.com/p/go-tour/">install it locally</a>.
+learned. You can <a href="http://tour.golang.org/">take the tour online</a> or
+<a href="http://code.google.com/p/go-tour/">install it locally</a>.
 </p>
 
 <h3 id="code"><a href="code.html">How to write Go code</a></h3>
 <p>
 Also available as a
-<a href="//www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>, this doc
+<a href="http://www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>, this doc
 explains how to use the <a href="/cmd/go/">go command</a> to fetch, build, and
 install packages, commands, and run tests.
 </p>
@@ -97,13 +97,10 @@ one goroutine can be guaranteed to observe values produced by writes to the
 same variable in a different goroutine.
 </p>
 
-<h3 id="release"><a href="/doc/devel/release.html">Release History</a></h3>
-<p>A summary of the changes between Go releases.</p>
-
 
 <h2 id="articles">Articles</h2>
 
-<h3 id="blog"><a href="//blog.golang.org/">The Go Blog</a></h3>
+<h3 id="blog"><a href="http://blog.golang.org/">The Go Blog</a></h3>
 <p>The official blog of the Go project, featuring news and in-depth articles by
 the Go team and guests.</p>
 
@@ -146,9 +143,7 @@ Guided tours of Go programs.
 <li><a href="/doc/gdb">Debugging Go Code with GDB</a></li>
 <li><a href="/blog/godoc-documenting-go-code">Godoc: documenting Go code</a> - writing good documentation for <a href="/cmd/godoc/">godoc</a>.</li>
 <li><a href="/blog/profiling-go-programs">Profiling Go Programs</a></li>
-<li><a href="/doc/articles/race_detector.html">Data Race Detector</a> - a manual for the data race detector.</li>
-<li><a href="/blog/race-detector">Introducing the Go Race Detector</a> - an introduction to the race detector.</li>
-<li><a href="/doc/asm">A Quick Guide to Go's Assembler</a> - an introduction to the assembler used by Go.</li>
+<li><a href="/blog/race-detector">Data Race Detector</a> - testing Go programs for race conditions.</li>
 </ul>
 
 <h4 id="articles_more">More</h4>
@@ -169,17 +164,17 @@ interfaces, reflection, and concurrency. Builds a toy web crawler to
 demonstrate these.
 </p>
 
-<h3 id="go_code_that_grows"><a href="//vimeo.com/53221560">Code that grows with grace</a></h3>
+<h3 id="go_code_that_grows"><a href="http://vimeo.com/53221560">Code that grows with grace</a></h3>
 <p>
 One of Go's key design goals is code adaptability; that it should be easy to take a simple design and build upon it in a clean and natural way. In this talk Andrew Gerrand describes a simple "chat roulette" server that matches pairs of incoming TCP connections, and then use Go's concurrency mechanisms, interfaces, and standard library to extend it with a web interface and other features. While the function of the program changes dramatically, Go's flexibility preserves the original design as it grows.
 </p>
 
-<h3 id="go_concurrency_patterns"><a href="//www.youtube.com/watch?v=f6kdp27TYZs">Go Concurrency Patterns</a></h3>
+<h3 id="go_concurrency_patterns"><a href="http://www.youtube.com/watch?v=f6kdp27TYZs">Go Concurrency Patterns</a></h3>
 <p>
 Concurrency is the key to designing high performance network services. Go's concurrency primitives (goroutines and channels) provide a simple and efficient means of expressing concurrent execution. In this talk we see how tricky concurrency problems can be solved gracefully with simple Go code.
 </p>
 
-<h3 id="advanced_go_concurrency_patterns"><a href="//www.youtube.com/watch?v=QDDwwePbDtw">Advanced Go Concurrency Patterns</a></h3>
+<h3 id="advanced_go_concurrency_patterns"><a href="http://www.youtube.com/watch?v=QDDwwePbDtw">Advanced Go Concurrency Patterns</a></h3>
 <p>
 This talk expands on the <i>Go Concurrency Patterns</i> talk to dive deeper into Go's concurrency primitives.
 </p>

doc/effective_go.html

@@ -28,7 +28,7 @@ will be easy for other Go programmers to understand.
 <p>
 This document gives tips for writing clear, idiomatic Go code.
 It augments the <a href="/ref/spec">language specification</a>,
-the <a href="//tour.golang.org/">Tour of Go</a>,
+the <a href="http://tour.golang.org/">Tour of Go</a>,
 and <a href="/doc/code.html">How to Write Go Code</a>,
 all of which you
 should read first.
@@ -37,14 +37,14 @@ should read first.
 <h3 id="examples">Examples</h3>
 
 <p>
-The <a href="/src/">Go package sources</a>
+The <a href="/src/pkg/">Go package sources</a>
 are intended to serve not
 only as the core library but also as examples of how to
 use the language.
 Moreover, many of the packages contain working, self-contained
 executable examples you can run directly from the
-<a href="//golang.org">golang.org</a> web site, such as
-<a href="//golang.org/pkg/strings/#example_Map">this one</a> (if
+<a href="http://golang.org">golang.org</a> web site, such as
+<a href="http://golang.org/pkg/strings/#example_Map">this one</a> (if
 necessary, click on the word "Example" to open it up).
 If you have a question about how to approach a problem or how something
 might be implemented, the documentation, code and examples in the
@@ -214,7 +214,7 @@ not be used.
 One adjustment <code>godoc</code> does do is to display indented
 text in a fixed-width font, suitable for program snippets.
 The package comment for the
-<a href="/pkg/fmt/"><code>fmt</code> package</a> uses this to good effect.
+<a href="http://golang.org/pkg/fmt/"><code>fmt</code> package</a> uses this to good effect.
 </p>
 
 <p>
@@ -288,7 +288,7 @@ var (
 </pre>
 
 <p>
-Grouping can also indicate relationships between items,
+Even for private names, grouping can also indicate relationships between items,
 such as the fact that a set of variables is protected by a mutex.
 </p>
 
@@ -344,13 +344,13 @@ determines just which package is being used.
 <p>
 Another convention is that the package name is the base name of
 its source directory;
-the package in <code>src/encoding/base64</code>
+the package in <code>src/pkg/encoding/base64</code>
 is imported as <code>"encoding/base64"</code> but has name <code>base64</code>,
 not <code>encoding_base64</code> and not <code>encodingBase64</code>.
 </p>
 
 <p>
-The importer of a package will use the name to refer to its contents,
+The importer of a package will use the name to refer to its contents.
 so exported names in the package can use that fact
 to avoid stutter.
 (Don't use the <code>import .</code> notation, which can simplify
@@ -701,7 +701,6 @@ for _, value := range array {
 
 <p>
 The blank identifier has many uses, as described in <a href="#blank">a later section</a>.
-</p>
 
 <p>
 For strings, the <code>range</code> does more work for you, breaking out individual
@@ -710,7 +709,7 @@ Erroneous encodings consume one byte and produce the
 replacement rune U+FFFD.
 (The name (with associated builtin type) <code>rune</code> is Go terminology for a
 single Unicode code point.
-See <a href="/ref/spec#Rune_literals">the language specification</a>
+See <a href="http://golang.org/ref/spec#Rune_literals">the language specification</a>
 for details.)
 The loop
 </p>
@@ -850,7 +849,7 @@ func Compare(a, b []byte) int {
 }
 </pre>
 
-<h3 id="type_switch">Type switch</h3>
+<h2 id="type_switch">Type switch</h2>
 
 <p>
 A switch can also be used to discover the dynamic type of an interface
@@ -1386,9 +1385,8 @@ func (file *File) Read(buf []byte) (n int, err error)
 </pre>
 <p>
 The method returns the number of bytes read and an error value, if
-any.
-To read into the first 32 bytes of a larger buffer
-<code>buf</code>, <i>slice</i> (here used as a verb) the buffer.
+any.  To read into the first 32 bytes of a larger buffer
+<code>b</code>, <i>slice</i> (here used as a verb) the buffer.
 </p>
 <pre>
     n, err := f.Read(buf[0:32])
@@ -1489,7 +1487,7 @@ If the slices might grow or shrink, they should be allocated independently
 to avoid overwriting the next line; if not, it can be more efficient to construct
 the object with a single allocation.
 For reference, here are sketches of the two methods.
-First, a line at a time:
+First, a line a time:
 </p>
 
 <pre>
@@ -2056,22 +2054,10 @@ We pass the address of a <code>ByteSlice</code>
 because only <code>*ByteSlice</code> satisfies <code>io.Writer</code>.
 The rule about pointers vs. values for receivers is that value methods
 can be invoked on pointers and values, but pointer methods can only be
-invoked on pointers.
+invoked on pointers.  This is because pointer methods can modify the
+receiver; invoking them on a copy of the value would cause those
+modifications to be discarded.
 </p>
-
-<p>
-This rule arises because pointer methods can modify the receiver; invoking
-them on a value would cause the method to receive a copy of the value, so
-any modifications would be discarded.
-The language therefore disallows this mistake.
-There is a handy exception, though. When the value is addressable, the
-language takes care of the common case of invoking a pointer method on a
-value by inserting the address operator automatically.
-In our example, the variable <code>b</code> is addressable, so we can call
-its <code>Write</code> method with just <code>b.Write</code>. The compiler
-will rewrite that to <code>(&amp;b).Write</code> for us.
-</p>
-
 <p>
 By the way, the idea of using <code>Write</code> on a slice of bytes
 is central to the implementation of <code>bytes.Buffer</code>.
@@ -2187,7 +2173,6 @@ A one-case type switch would do, but so would a <em>type assertion</em>.
 A type assertion takes an interface value and extracts from it a value of the specified explicit type.
 The syntax borrows from the clause opening a type switch, but with an explicit
 type rather than the <code>type</code> keyword:
-</p>
 
 <pre>
 value.(typeName)
@@ -2478,8 +2463,6 @@ It has uses beyond those we've seen already.
 <p>
 The use of a blank identifier in a <code>for</code> <code>range</code> loop is a
 special case of a general situation: multiple assignment.
-</p>
-
 <p>
 If an assignment requires multiple values on the left side,
 but one of the values will not be used by the program,
@@ -2954,19 +2937,26 @@ means waiting until some receiver has retrieved a value.
 <p>
 A buffered channel can be used like a semaphore, for instance to
 limit throughput.  In this example, incoming requests are passed
-to <code>handle</code>, which sends a value into the channel, processes
-the request, and then receives a value from the channel
-to ready the &ldquo;semaphore&rdquo; for the next consumer.
+to <code>handle</code>, which receives a value from the channel, processes
+the request, and then sends a value back to the channel
+to ready the "semaphore" for the next consumer.
 The capacity of the channel buffer limits the number of
-simultaneous calls to <code>process</code>.
+simultaneous calls to <code>process</code>,
+so during initialization we prime the channel by filling it to capacity.
 </p>
 <pre>
 var sem = make(chan int, MaxOutstanding)
 
 func handle(r *Request) {
-    sem &lt;- 1    // Wait for active queue to drain.
-    process(r)  // May take a long time.
-    &lt;-sem       // Done; enable next request to run.
+    &lt;-sem          // Wait for active queue to drain.
+    process(r)     // May take a long time.
+    sem &lt;- 1       // Done; enable next request to run.
+}
+
+func init() {
+    for i := 0; i &lt; MaxOutstanding; i++ {
+        sem &lt;- 1
+    }
 }
 
 func Serve(queue chan *Request) {
@@ -2978,9 +2968,10 @@ func Serve(queue chan *Request) {
 </pre>
 
 <p>
-Once <code>MaxOutstanding</code> handlers are executing <code>process</code>,
-any more will block trying to send into the filled channel buffer,
-until one of the existing handlers finishes and receives from the buffer.
+Because data synchronization occurs on a receive from a channel
+(that is, the send "happens before" the receive; see
+<a href="/ref/mem">The Go Memory Model</a>),
+acquisition of the semaphore must be on a channel receive, not a send.
 </p>
 
 <p>
@@ -2997,10 +2988,10 @@ Here's an obvious solution, but beware it has a bug we'll fix subsequently:
 <pre>
 func Serve(queue chan *Request) {
     for req := range queue {
-        sem &lt;- 1
+        &lt;-sem
         go func() {
             process(req) // Buggy; see explanation below.
-            &lt;-sem
+            sem &lt;- 1
         }()
     }
 }</pre>
@@ -3018,10 +3009,10 @@ to the closure in the goroutine:
 <pre>
 func Serve(queue chan *Request) {
     for req := range queue {
-        sem &lt;- 1
+        &lt;-sem
         go func(req *Request) {
             process(req)
-            &lt;-sem
+            sem &lt;- 1
         }(req)
     }
 }</pre>
@@ -3036,11 +3027,11 @@ name, as in this example:
 <pre>
 func Serve(queue chan *Request) {
     for req := range queue {
+        &lt;-sem
         req := req // Create new instance of req for the goroutine.
-        sem &lt;- 1
         go func() {
             process(req)
-            &lt;-sem
+            sem &lt;- 1
         }()
     }
 }</pre>
@@ -3214,7 +3205,7 @@ Although the concurrency features of Go can make some problems easy
 to structure as parallel computations, Go is a concurrent language,
 not a parallel one, and not all parallelization problems fit Go's model.
 For a discussion of the distinction, see the talk cited in
-<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">this
+<a href="http://blog.golang.org/2013/01/concurrency-is-not-parallelism.html">this
 blog post</a>.
 
 <h3 id="leaky_buffer">A leaky buffer</h3>
@@ -3287,18 +3278,9 @@ the garbage collector for bookkeeping.
 
 <p>
 Library routines must often return some sort of error indication to
-the caller.
-As mentioned earlier, Go's multivalue return makes it
+the caller.  As mentioned earlier, Go's multivalue return makes it
 easy to return a detailed error description alongside the normal
-return value.
-It is good style to use this feature to provide detailed error information.
-For example, as we'll see, <code>os.Open</code> doesn't
-just return a <code>nil</code> pointer on failure, it also returns an
-error value that describes what went wrong.
-</p>
-
-<p>
-By convention, errors have type <code>error</code>,
+return value.  By convention, errors have type <code>error</code>,
 a simple built-in interface.
 </p>
 <pre>
@@ -3310,12 +3292,7 @@ type error interface {
 A library writer is free to implement this interface with a
 richer model under the covers, making it possible not only
 to see the error but also to provide some context.
-As mentioned, alongside the usual <code>*os.File</code>
-return value, <code>os.Open</code> also returns an
-error value.
-If the file is opened successfully, the error will be <code>nil</code>,
-but when there is a problem, it will hold an
-<code>os.PathError</code>:
+For example, <code>os.Open</code> returns an <code>os.PathError</code>.
 </p>
 <pre>
 // PathError records an error and the operation and

doc/gccgo_contribute.html

@@ -30,7 +30,7 @@ contribution rules</a>.
 
 <p>
 The master sources for the gccgo frontend may be found at
-<a href="//code.google.com/p/gofrontend">http://code.google.com/p/gofrontend</a>.
+<a href="http://code.google.com/p/gofrontend">http://code.google.com/p/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
@@ -40,7 +40,7 @@ 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="//code.google.com/p/go">the main Go repository</a>
+from <a href="http://code.google.com/p/go">the main Go repository</a>
 is mirrored to the <code>gcc/testsuite/go.test/test</code> directory
 in the GCC repository.
 </p>
@@ -65,7 +65,7 @@ from <code>gcc/go/gofrontend</code> to <code>gcc/go</code>.
 
 <p>
 The run-time library for gccgo is mostly the same as the library
-in <a href="//code.google.com/p/go">the main Go repository</a>.
+in <a href="http://code.google.com/p/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
@@ -73,7 +73,7 @@ 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.
+in <code>src/pkg/runtime</code> in the main Go repository.
 </p>
 
 <h2>Testing</h2>

doc/gccgo_install.html

@@ -42,10 +42,6 @@ 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>
-
 <h2 id="Source_code">Source code</h2>
 
 <p>
@@ -295,9 +291,9 @@ first one that it finds.
 
 <ul>
 <li><code><var>FILE</var>.gox</code>
+<li><code><var>FILE</var>.o</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>
@@ -526,4 +522,4 @@ port is for x86. The goal is to extend the port to most of the
 <a href="http://www.rtems.org/wiki/index.php/SupportedCPUs">
 architectures supported by <code>RTEMS</code></a>. For more information on the port,
 as well as instructions on how to install it, please see this
-<a href="http://www.rtems.org/wiki/index.php/GCCGoRTEMS"><code>RTEMS</code> Wiki page</a>.
+<a href="http://www.rtems.com/wiki/index.php/GCCGoRTEMS"><code>RTEMS</code> Wiki page</a>.

doc/go1.1.html

@@ -304,7 +304,7 @@ The race detector is documented in <a href="/doc/articles/race_detector.html">a
 
 <p>
 Due to the change of the <a href="#int"><code>int</code></a> to 64 bits and
-a new internal <a href="//golang.org/s/go11func">representation of functions</a>,
+a new internal <a href="http://golang.org/s/go11func">representation of functions</a>,
 the arrangement of function arguments on the stack has changed in the gc tool chain.
 Functions written in assembly will need to be revised at least
 to adjust frame pointer offsets.

doc/go1.2.html

@@ -63,7 +63,7 @@ The implementation may inject extra tests into the compiled program to enforce t
 
 <p>
 Further details are in the
-<a href="//golang.org/s/go12nil">design document</a>.
+<a href="http://golang.org/s/go12nil">design document</a>.
 </p>
 
 <p>
@@ -115,7 +115,7 @@ It is possible that future releases of Go may introduce default values for these
 
 <p>
 Further details are in the
-<a href="//golang.org/s/go12slice">design document</a>.
+<a href="http://golang.org/s/go12slice">design document</a>.
 </p>
 
 <p>
@@ -199,7 +199,7 @@ compiler to build any pieces of the linked-to library that are written in C++;
 <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.
+<a href="http://code.google.com/p/go.tools">go.tools</a> subrepository.
 </p>
 
 <p>
@@ -218,7 +218,7 @@ 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>
+The binary distributions available from <a href="http://golang.org">golang.org</a>
 include these binaries, so users of these distributions are unaffected.
 </p>
 
@@ -448,7 +448,7 @@ The new interfaces are called
 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>.
+and a separate <a href="http://golang.org/s/go12encoding">design document</a>.
 </p>
 
 <h3 id="fmt_indexed_arguments">The fmt package</h3>

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 tool chain that results in
-faster builds, especially for large projects,
-significant performance improvements across the board,
-and support for DragonFly BSD, Solaris, Plan 9 and Google's Native Client architecture (NaCl).
-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 tool chain, the assemblers now use the
-same command-line flag parsing rules as the Go flag package, a departure
-from the traditional Unix flag parsing.
-This may affect scripts that invoke the tool directly.
-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/code.google.com/p/go.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/code.google.com/p/go.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="http://plan9.bell-labs.com/magic/man2html/6/a.out">a.out</a> object files.
-</p>
-
-<h3 id="major_library_changes">Major changes to the library</h3>
-
-<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>mutipart/form-data</code>.
-Prior to Go 1.3 it would silently fail and return <code>nil</code>.
-Code that relies on the previous behavior should be updated.
-</li>
-
-<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,818 +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
-and contains only one tiny language change,
-a possibly breaking change to the compiler,
-a backwards-compatible simple form of <code>for</code>-<code>range</code> loop.
-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 AMD64 on Plan 9.
-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 k, v := range x {
-	...
-}
-</pre>
-
-<p>
-and
-</p>
-
-<pre>
-for k := 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="http://code.google.com/p/go.mobile">go.mobile</a> repository.
-A brief description of the plans for this experimental port are available
-<a href="/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>
-Up 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="/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 to 2048 bytes from 8192 bytes.
-TODO: It may be bumped to 4096 for the release.
-</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="http://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="http://golang.org/s/go14customimport">the design document</a>.
-</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="http://godoc.org/code.google.com/p/go.tools/cmd/stringer">stringer</a>
-tool in the <code>go.tools</code> repository.
-</p>
-
-<p>
-For more information, see the 
-<a href="http://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 sub-repositories such as <code>go.tools</code>.
-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 the runtime changes in this release, Go 1.4 will require SWIG 3.0.3.
-At time of writing that has not yet been released, but we expect it to be by
-Go 1.4's release date.
-TODO
-</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="https://code.google.com/p/go-wiki/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="http://golang.org/s/go1.4-syscall">a
-separate document</a>.
-</p>
-
-<p>
-A new subrepository, <a href="http://code.google.com/p/go.sys">go.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="http://godoc.org/code.google.com/p/go.sys/unix">Unix</a>,
-<a href="http://godoc.org/code.google.com/p/go.sys/windows">Windows</a> and
-<a href="http://godoc.org/code.google.com/p/go.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>go.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/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.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-now supports ALPN as defined in <a href="http://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/crypo/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>
-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>
-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/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.
-</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.html

@@ -486,7 +486,7 @@ into subdirectories. For instance, <code>utf8</code> and
 <code>utf16</code> now occupy subdirectories of <code>unicode</code>.
 Also, <a href="#subrepo">some packages</a> have moved into
 subrepositories of
-<a href="//code.google.com/p/go"><code>code.google.com/p/go</code></a>
+<a href="http://code.google.com/p/go"><code>code.google.com/p/go</code></a>
 while <a href="#deleted">others</a> have been deleted outright.
 </p>
 
@@ -565,7 +565,7 @@ by hand.
 <p>
 Because they are not standardized, the packages under the <code>exp</code> directory will not be available in the
 standard Go 1 release distributions, although they will be available in source code form
-in <a href="//code.google.com/p/go/">the repository</a> for
+in <a href="http://code.google.com/p/go/">the repository</a> for
 developers who wish to use them.
 </p>
 
@@ -651,7 +651,7 @@ and also the command <code>gotry</code>.
 <em>Updating</em>:
 Code that uses <code>container/vector</code> should be updated to use
 slices directly.  See
-<a href="//code.google.com/p/go-wiki/wiki/SliceTricks">the Go
+<a href="http://code.google.com/p/go-wiki/wiki/SliceTricks">the Go
 Language Community Wiki</a> for some suggestions.
 Code that uses the other packages (there should be almost zero) will need to be rethought.
 </p>
@@ -660,7 +660,7 @@ Code that uses the other packages (there should be almost zero) will need to be
 
 <p>
 Go 1 has moved a number of packages into other repositories, usually sub-repositories of
-<a href="//code.google.com/p/go/">the main Go repository</a>.
+<a href="http://code.google.com/p/go/">the main Go repository</a>.
 This table lists the old and new import paths:
 
 <table class="codetable" frame="border" summary="Sub-repositories">
@@ -1695,7 +1695,7 @@ The compiler will catch code using the old interface.
 The <a href="/pkg/regexp/"><code>regexp</code></a> package has been rewritten.
 It has the same interface but the specification of the regular expressions
 it supports has changed from the old "egrep" form to that of
-<a href="//code.google.com/p/re2/">RE2</a>.
+<a href="http://code.google.com/p/re2/">RE2</a>.
 </p>
 
 <p>
@@ -1912,7 +1912,7 @@ package <a href="/pkg/reflect/"><code>reflect</code></a>.
 <em>Updating</em>:
 Code using these functions must be rewritten to use
 package <a href="/pkg/reflect/"><code>reflect</code></a>.
-The changes to <a href="//golang.org/change/2646dc956207">encoding/gob</a> and the <a href="//code.google.com/p/goprotobuf/source/detail?r=5340ad310031">protocol buffer library</a>
+The changes to <a href="http://code.google.com/p/go/source/detail?r=2646dc956207">encoding/gob</a> and the <a href="http://code.google.com/p/goprotobuf/source/detail?r=5340ad310031">protocol buffer library</a>
 may be helpful as examples.
 </p>
 
@@ -2035,4 +2035,4 @@ They are available for many combinations of architecture and operating system
 Installation details are described on the
 <a href="/doc/install">Getting Started</a> page, while
 the distributions themselves are listed on the
-<a href="https://golang.org/dl/">downloads page</a>.
+<a href="http://code.google.com/p/go/downloads/list">downloads page</a>.

doc/go1compat.html

@@ -83,16 +83,16 @@ break if the bug is fixed. We reserve the right to fix such bugs.
 <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,
+the API. Code that uses untagged 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:
+such a change. However, code that uses tagged 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
+update such data structures in a way that allows tagged struct
+literals to remain compatible, although untagged 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.
+in a separate package should use the tagged notation.
 </li>
 
 <li>
@@ -104,14 +104,6 @@ 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>
@@ -153,28 +145,13 @@ developed software based on Go 1.
 
 <p>
 Code in sub-repositories of the main go tree, such as
-<a href="//code.google.com/p/go.net">code.google.com/p/go.net</a>,
+<a href="http://code.google.com/p/go.net">code.google.com/p/go.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="http://godoc.org/code.google.com/p/go.sys">go.sys</a> subrepository.
-For details and background, see
-<a href="https://golang.org/s/go1.4-syscall">this document</a>.
-</p>
-
 <h2 id="tools">Tools</h2>
 
 <p>

doc/go_faq.html

@@ -57,7 +57,7 @@ software on multicore machines.
 
 <p>
 A much more expansive answer to this question is available in the article,
-<a href="//talks.golang.org/2012/splash.article">Go at Google:
+<a href="http://talks.golang.org/2012/splash.article">Go at Google:
 Language Design in the Service of Software Engineering</a>.
 
 <h3 id="What_is_the_status_of_the_project">
@@ -66,7 +66,7 @@ What is the status of the project?</h3>
 <p>
 Go became a public open source project on November 10, 2009.
 After a couple of years of very active design and development, stability was called for and
-Go 1 was <a href="//blog.golang.org/2012/03/go-version-1-is-released.html">released</a>
+Go 1 was <a href="http://blog.golang.org/2012/03/go-version-1-is-released.html">released</a>
 on March 28, 2012.
 Go 1, which includes a <a href="/ref/spec">language specification</a>,
 <a href="/pkg/">standard libraries</a>,
@@ -163,7 +163,7 @@ language was called for.
 </p>
 
 <p>
-The article <a href="//talks.golang.org/2012/splash.article">Go at Google</a>
+The article <a href="http://talks.golang.org/2012/splash.article">Go at Google</a>
 discusses the background and motivation behind the design of the Go language,
 as well as providing more detail about many of the answers presented in this FAQ.
 </p>
@@ -221,7 +221,7 @@ easier to understand what happens when things combine.
 <p>
 Yes. There are now several Go programs deployed in
 production inside Google.  A public example is the server behind
-<a href="//golang.org">golang.org</a>.
+<a href="http://golang.org">http://golang.org</a>.
 It's just the <a href="/cmd/godoc"><code>godoc</code></a>
 document server running in a production configuration on
 <a href="https://developers.google.com/appengine/">Google App Engine</a>.
@@ -260,7 +260,7 @@ Does Go support Google's protocol buffers?</h3>
 <p>
 A separate open source project provides the necessary compiler plugin and library.
 It is available at
-<a href="//code.google.com/p/goprotobuf/">code.google.com/p/goprotobuf/</a>
+<a href="http://code.google.com/p/goprotobuf/">http://code.google.com/p/goprotobuf/</a>
 </p>
 
 
@@ -270,9 +270,9 @@ Can I translate the Go home page into another language?</h3>
 <p>
 Absolutely. We encourage developers to make Go Language sites in their own languages.
 However, if you choose to add the Google logo or branding to your site
-(it does not appear on <a href="//golang.org/">golang.org</a>),
+(it does not appear on <a href="http://golang.org/">golang.org</a>),
 you will need to abide by the guidelines at
-<a href="//www.google.com/permissions/guidelines.html">www.google.com/permissions/guidelines.html</a>
+<a href="http://www.google.com/permissions/guidelines.html">http://www.google.com/permissions/guidelines.html</a>
 </p>
 
 <h2 id="Design">Design</h2>
@@ -426,20 +426,18 @@ When a coroutine blocks, such as by calling a blocking system call,
 the run-time automatically moves other coroutines on the same operating
 system thread to a different, runnable thread so they won't be blocked.
 The programmer sees none of this, which is the point.
-The result, which we call goroutines, can be very cheap: they have little
-overhead beyond the memory for the stack, which is just a few kilobytes.
+The result, which we call goroutines, can be very cheap: unless they spend a lot of time
+in long-running system calls, they cost little more than the memory
+for the stack, which is just a few kilobytes.
 </p>
 
 <p>
-To make the stacks small, Go's run-time uses resizable, bounded stacks.  A newly
+To make the stacks small, Go's run-time uses segmented stacks.  A newly
 minted goroutine is given a few kilobytes, which is almost always enough.
-When it isn't, the run-time grows (and shrinks) the memory for storing
-the stack automatically, allowing many goroutines to live in a modest
-amount of memory.
-The CPU overhead averages about three cheap instructions per function call.
+When it isn't, the run-time allocates (and frees) extension segments automatically.
+The overhead averages about three cheap instructions per function call.
 It is practical to create hundreds of thousands of goroutines in the same
-address space.
-If goroutines were just threads, system resources would
+address space.  If goroutines were just threads, system resources would
 run out at a much smaller number.
 </p>
 
@@ -448,7 +446,7 @@ Why are map operations not defined to be atomic?</h3>
 
 <p>
 After long discussion it was decided that the typical use of maps did not require
-safe access from multiple goroutines, and in those cases where it did, the map was
+safe access from multiple threads, and in those cases where it did, the map was
 probably part of some larger data structure or computation that was already
 synchronized.  Therefore requiring that all map operations grab a mutex would slow
 down most programs and add safety to few.  This was not an easy decision,
@@ -466,7 +464,7 @@ Will you accept my language change?</h3>
 
 <p>
 People often suggest improvements to the language—the
-<a href="//groups.google.com/group/golang-nuts">mailing list</a>
+<a href="http://groups.google.com/group/golang-nuts">mailing list</a>
 contains a rich history of such discussions—but very few of these changes have
 been accepted.
 </p>
@@ -484,7 +482,7 @@ to start talking about what that might be.
 <p>
 Even if your proposal is compatible with the Go 1 spec, it might
 not be in the spirit of Go's design goals.
-The article <i><a href="//talks.golang.org/2012/splash.article">Go
+The article <i><a href="http://talks.golang.org/2012/splash.article">Go
 at Google: Language Design in the Service of Software Engineering</a></i>
 explains Go's origins and the motivation behind its design.
 </p>
@@ -889,11 +887,6 @@ type is generic; if you care about how many bits an integer holds, Go
 encourages you to be explicit.
 </p>
 
-<p>
-A blog post, title <a href="http://blog.golang.org/constants">Constants</a>,
-explores this topic in more detail.
-</p>
-
 <h3 id="builtin_maps">
 Why are maps built in?</h3>
 <p>
@@ -945,9 +938,9 @@ How are libraries documented?</h3>
 There is a program, <code>godoc</code>, written in Go, that extracts
 package documentation from the source code. It can be used on the
 command line or on the web. An instance is running at
-<a href="/pkg/">golang.org/pkg/</a>.
+<a href="http://golang.org/pkg/">http://golang.org/pkg/</a>.
 In fact, <code>godoc</code> implements the full site at
-<a href="/">golang.org/</a>.
+<a href="http://golang.org/">http://golang.org/</a>.
 </p>
 
 <h3 id="Is_there_a_Go_programming_style_guide">
@@ -964,19 +957,11 @@ compendium of do's and don'ts that allows interpretation.
 All the Go code in the repository has been run through <code>gofmt</code>.
 </p>
 
-<p>
-The document titled
-<a href="//golang.org/s/comments">Go Code Review Comments</a>
-is a collection of very short essays about details of Go idiom that are often
-missed by programmers.
-It is a handy reference for people doing code reviews for Go projects.
-</p>
-
 <h3 id="How_do_I_submit_patches_to_the_Go_libraries">
 How do I submit patches to the Go libraries?</h3>
 
 <p>
-The library sources are in the <code>src</code> directory of the repository.
+The library sources are in <code>go/src/pkg</code>.
 If you want to make a significant change, please discuss on the mailing list before embarking.
 </p>
 
@@ -991,14 +976,14 @@ Why does the project use Mercurial and not git?</h3>
 
 <p>
 The Go project, hosted by Google Code at
-<a href="//code.google.com/p/go">code.google.com/p/go</a>,
+<a href="http://code.google.com/p/go">code.google.com/p/go</a>,
 uses Mercurial as its version control system.
 When the project launched,
 Google Code supported only Subversion and Mercurial.
 Mercurial was a better choice because of its plugin mechanism
 that allowed us to create the "codereview" plugin to connect
 the project to the excellent code review tools at
-<a href="//codereview.appspot.com">codereview.appspot.com</a>.
+<a href="http://codereview.appspot.com">codereview.appspot.com</a>.
 </p>
 
 <p>
@@ -1115,7 +1100,7 @@ error but the situation can still be confusing, because sometimes a
 <a href="#different_method_sets">pointer
 is necessary to satisfy an interface</a>.
 The insight is that although a pointer to a concrete type can satisfy
-an interface, with one exception <em>a pointer to an interface can never satisfy an interface</em>.
+an interface, with one exception <em>a pointer to an interface can never satisfy a interface</em>.
 </p>
 
 <p>
@@ -1309,7 +1294,7 @@ Do not communicate by sharing memory. Instead, share memory by communicating.
 </p>
 
 <p>
-See the <a href="/doc/codewalk/sharemem/">Share Memory By Communicating</a> code walk and its <a href="//blog.golang.org/2010/07/share-memory-by-communicating.html">associated article</a> for a detailed discussion of this concept.
+See the <a href="/doc/codewalk/sharemem/">Share Memory By Communicating</a> code walk and its <a href="http://blog.golang.org/2010/07/share-memory-by-communicating.html">associated article</a> for a detailed discussion of this concept.
 </p>
 
 <h3 id="Why_no_multi_CPU">
@@ -1326,7 +1311,7 @@ run-time support to utilize more than one OS thread.
 Programs that perform parallel computation should benefit from an increase in
 <code>GOMAXPROCS</code>.
 However, be aware that
-<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">concurrency
+<a href="http://blog.golang.org/2013/01/concurrency-is-not-parallelism.html">concurrency
 is not parallelism</a>.
 </p>
 
@@ -1356,14 +1341,14 @@ to speed it up.
 </p>
 
 <p>
-Go's goroutine scheduler is not as good as it needs to be. In the future, it
+Go's goroutine scheduler is not as good as it needs to be. In future, it
 should recognize such cases and optimize its use of OS threads. For now,
 <code>GOMAXPROCS</code> should be set on a per-application basis.
 </p>
 
 <p>
 For more detail on this topic see the talk entitled,
-<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">Concurrency
+<a href="http://blog.golang.org/2013/01/concurrency-is-not-parallelism.html">Concurrency
 is not Parallelism</a>.
 
 <h2 id="Functions_methods">Functions and Methods</h2>
@@ -1442,7 +1427,7 @@ each closure shares that single variable. When the closure runs, it prints the
 value of <code>v</code> at the time <code>fmt.Println</code> is executed,
 but <code>v</code> may have been modified since the goroutine was launched.
 To help detect this and other problems before they happen, run
-<a href="/cmd/go/#hdr-Run_go_tool_vet_on_packages"><code>go vet</code></a>.
+<a href="http://golang.org/cmd/go/#hdr-Run_go_tool_vet_on_packages"><code>go vet</code></a>.
 </p>
 
 <p>
@@ -1576,7 +1561,7 @@ table-driven, iterating over a list of inputs and outputs defined
 in a data structure (Go has excellent support for data structure literals).
 The work to write a good test and good error messages will then be amortized over many
 test cases. The standard Go library is full of illustrative examples, such as in
-<a href="/src/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
+<a href="/src/pkg/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
 </p>
 
 
@@ -1595,46 +1580,35 @@ and uses a variant of the Plan 9 loader to generate ELF/Mach-O/PE binaries.
 </p>
 
 <p>
-We considered using LLVM for <code>gc</code> but we felt it was too large and
-slow to meet our performance goals.
-</p>
-
-<p>
-We also considered writing <code>gc</code>, the original Go compiler, in Go itself but
+We considered writing <code>gc</code>, the original Go compiler, in Go itself but
 elected not to do so because of the difficulties of bootstrapping and
 especially of open source distribution&mdash;you'd need a Go compiler to
 set up a Go environment. <code>Gccgo</code>, which came later, makes it possible to
-consider writing a compiler in Go.
-A plan to do that by machine translation of the existing compiler is under development.
-<a href="http://golang.org/s/go13compiler">A separate document</a>
-explains the reason for this approach.
+consider writing a compiler in Go, which might well happen.
+(Go would be a
+fine language in which to implement a compiler; a native lexer and
+parser are already available in the <a href="/pkg/go/"><code>go</code></a> package
+and a type checker is in the works.)
 </p>
 
 <p>
-That plan aside,
-Go is a
-fine language in which to implement a self-hosting compiler: a native lexer and
-parser are already available in the <a href="/pkg/go/"><code>go</code></a> package
-and a separate type checking
-<a href="http://godoc.org/code.google.com/p/go.tools/go/types">package</a>
-has also been written.
+We also considered using LLVM for <code>gc</code> but we felt it was too large and
+slow to meet our performance goals.
 </p>
 
 <h3 id="How_is_the_run_time_support_implemented">
 How is the run-time support implemented?</h3>
 
 <p>
-Again due to bootstrapping issues, the run-time code was originally written mostly in C (with a
-tiny bit of assembler) although much of it has been translated to Go since then
-and one day all of it might be (except for the assembler bits).
-<code>Gccgo</code>'s run-time support uses <code>glibc</code>.
-<code>Gc</code> uses a custom C library to keep the footprint under
+Again due to bootstrapping issues, the run-time code is mostly in C (with a
+tiny bit of assembler) although Go is capable of implementing most of
+it now. <code>Gccgo</code>'s run-time support uses <code>glibc</code>.
+<code>Gc</code> uses a custom library to keep the footprint under
 control; it is
 compiled with a version of the Plan 9 C compiler that supports
-resizable stacks for goroutines.
-The <code>gccgo</code> compiler implements these on Linux only,
-using a technique called segmented stacks,
-supported by recent modifications to the gold linker.
+segmented stacks for goroutines.
+The <code>gccgo</code> compiler implements segmented
+stacks on Linux only, supported by recent modifications to the gold linker.
 </p>
 
 <h3 id="Why_is_my_trivial_program_such_a_large_binary">
@@ -1652,8 +1626,8 @@ A simple C "hello, world" program compiled and linked statically using gcc
 on Linux is around 750 kB,
 including an implementation of <code>printf</code>.
 An equivalent Go program using <code>fmt.Printf</code>
-is around 1.9 MB, but
-that includes more powerful run-time support and type information.
+is around 1.2 MB, but
+that includes more powerful run-time support.
 </p>
 
 <h3 id="unused_variables_and_imports">
@@ -1661,17 +1635,14 @@ Can I stop these complaints about my unused variable/import?</h3>
 
 <p>
 The presence of an unused variable may indicate a bug, while
-unused imports just slow down compilation,
-an effect that can become substantial as a program accumulates
-code and programmers over time.
-For these reasons, Go refuses to compile programs with unused
-variables or imports,
-trading short-term convenience for long-term build speed and
-program clarity.
+unused imports just slow down compilation.
+Accumulate enough unused imports in your code tree and
+things can get very slow.
+For these reasons, Go allows neither.
 </p>
 
 <p>
-Still, when developing code, it's common to create these situations
+When developing code, it's common to create these situations
 temporarily and it can be annoying to have to edit them out before the
 program will compile.
 </p>
@@ -1713,14 +1684,6 @@ func main() {
 }
 </pre>
 
-<p>
-Nowadays, most Go programmers use a tool,
-<a href="http://godoc.org/code.google.com/p/go.tools/cmd/goimports">goimports</a>,
-which automatically rewrites a Go source file to have the correct imports,
-eliminating the unused imports issue in practice.
-This program is easily connected to most editors to run automatically when a Go source file is written.
-</p>
-
 <h2 id="Performance">Performance</h2>
 
 <h3 id="Why_does_Go_perform_badly_on_benchmark_x">
@@ -1762,7 +1725,7 @@ In any case, Go can often be very competitive.
 There has been significant improvement in the performance of many programs
 as the language and tools have developed.
 See the blog post about
-<a href="//blog.golang.org/2011/06/profiling-go-programs.html">profiling
+<a href="http://blog.golang.org/2011/06/profiling-go-programs.html">profiling
 Go programs</a> for an informative example.
 
 <h2 id="change_from_c">Changes from C</h2>
@@ -1921,7 +1884,7 @@ considerable control over memory layout and allocation, much more than
 is typical in garbage-collected languages. A careful programmer can reduce
 the garbage collection overhead dramatically by using the language well;
 see the article about
-<a href="//blog.golang.org/2011/06/profiling-go-programs.html">profiling
+<a href="http://blog.golang.org/2011/06/profiling-go-programs.html">profiling
 Go programs</a> for a worked example, including a demonstration of Go's
 profiling tools.
 </p>

doc/go_mem.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Memory Model",
-	"Subtitle": "Version of May 31, 2014",
+	"Subtitle": "Version of March 6, 2012",
 	"Path": "/ref/mem"
 }-->
 
@@ -21,29 +21,6 @@ reads of a variable in one goroutine can be guaranteed to
 observe values produced by writes to the same variable in a different goroutine.
 </p>
 
-
-<h2>Advice</h2>
-
-<p>
-Programs that modify data being simultaneously accessed by multiple goroutines
-must serialize such access.
-</p>
-
-<p>
-To serialize access, protect the data with channel operations or other synchronization primitives
-such as those in the <a href="/pkg/sync/"><code>sync</code></a>
-and <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> packages.
-</p>
-
-<p>
-If you must read the rest of this document to understand the behavior of your program,
-you are being too clever.
-</p>
-
-<p>
-Don't be clever.
-</p>
-
 <h2>Happens Before</h2>
 
 <p>
@@ -297,41 +274,6 @@ then the program would not be guaranteed to print
 crash, or do something else.)
 </p>
 
-<p class="rule">
-The <i>k</i>th receive on a channel with capacity <i>C</i> happens before the <i>k</i>+<i>C</i>th send from that channel completes.
-</p>
-
-<p>
-This rule generalizes the previous rule to buffered channels.
-It allows a counting semaphore to be modeled by a buffered channel:
-the number of items in the channel corresponds to the number of active uses,
-the capacity of the channel corresponds to the maximum number of simultaneous uses,
-sending an item acquires the semaphore, and receiving an item releases
-the semaphore.
-This is a common idiom for limiting concurrency.
-</p>
-
-<p>
-This program starts a goroutine for every entry in the work list, but the
-goroutines coordinate using the <code>limit</code> channel to ensure
-that at most three are running work functions at a time.
-</p>
-
-<pre>
-var limit = make(chan int, 3)
-
-func main() {
-	for _, w := range work {
-		go func() {
-			limit <- 1
-			w()
-			<-limit
-		}()
-	}
-	select{}
-}
-</pre>
-
 <h3>Locks</h3>
 
 <p>

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: http://blog.golang.org/gopher

doc/help.html

@@ -20,11 +20,11 @@ Need help with Go? Try these resources.
 <h3 id="wiki"><a href="/wiki">The Go Wiki</a></h3>
 <p>A wiki maintained by the Go community.</p>
 
-<h3 id="mailinglist"><a href="//groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
+<h3 id="mailinglist"><a href="http://groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
 <p>
-Search the <a href="//groups.google.com/group/golang-nuts">golang-nuts</a>
+Search the <a href="http://groups.google.com/group/golang-nuts">golang-nuts</a>
 archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
-<a href="//code.google.com/p/go-wiki/wiki">wiki</a> before posting.
+<a href="http://code.google.com/p/go-wiki/wiki">wiki</a> before posting.
 </p>
 
 <h3 id="irc"><a href="irc:irc.freenode.net/go-nuts">Go IRC Channel</a></h3>
@@ -37,9 +37,9 @@ Go IRC channel.</p>
 <h3 id="plus"><a href="https://plus.google.com/101406623878176903605/posts">The Go Programming Language at Google+</a></h3>
 <p>The Go project's Google+ page.</p>
 
-<h3 id="twitter"><a href="//twitter.com/golang">@golang at Twitter</a></h3>
+<h3 id="twitter"><a href="http://twitter.com/golang">@golang at Twitter</a></h3>
 <p>The Go project's official Twitter account.</p>
-<p>Tweeting about your problem with the <code>#golang</code> hashtag usually
+<p>Tweeting your about problem with the <code>#golang</code> hashtag usually
 generates some helpful responses.</p>
 
 <h3 id="go_user_groups"><a href="/wiki/GoUserGroups">Go User Groups</a></h3>

doc/install-source.html

@@ -69,8 +69,8 @@ goroutines, such as stacks that grow and shrink on demand.
 </p>
 
 <p>
-The compilers can target the DragonFly BSD, FreeBSD, Linux, NetBSD, OpenBSD,
-OS X (Darwin), Plan 9, Solaris and Windows operating systems.
+The compilers can target the FreeBSD, Linux, NetBSD, OpenBSD, OS X (Darwin), Plan 9,
+and Windows operating systems.
 The full set of supported combinations is listed in the discussion of
 <a href="#environment">environment variables</a> below.
 </p>
@@ -81,7 +81,7 @@ The full set of supported combinations is listed in the discussion of
 
 <p>
 The Go tool chain is written in C. To build it, you need a C compiler installed. 
-Please refer to the <a href="//golang.org/wiki/InstallFromSource#Install_C_tools">InstallFromSource</a>
+Please refer to the <a href="http://code.google.com/p/go-wiki/wiki/InstallFromSource#Install_C_tools">InstallFromSource</a>
 page on the Go community Wiki for operating system specific instructions.
 </p>
 
@@ -95,7 +95,7 @@ have an <code>hg</code> command.)
 <p>
 If you do not have a working Mercurial installation,
 follow the instructions on the
-<a href="http://mercurial.selenic.com/downloads">Mercurial downloads</a> page.
+<a href="http://mercurial.selenic.com/downloads/">Mercurial downloads</a> page.
 </p>
 
 <p>
@@ -176,10 +176,6 @@ architecture, and root directory used during the install.
 <p>
 For more information about ways to control the build, see the discussion of
 <a href="#environment">environment variables</a> below.
-<code>all.bash</code> (or <code>all.bat</code>) runs important tests for Go,
-which can take more time than simply building Go. If you do not want to run
-the test suite use <code>make.bash</code> (or <code>make.bat</code>)
-instead.
 </p>
 </div>
 
@@ -283,16 +279,16 @@ You can access the latter commands with
 The usual community resources such as
 <code>#go-nuts</code> on the <a href="http://freenode.net/">Freenode</a> IRC server
 and the
-<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>
+<a href="http://groups.google.com/group/golang-nuts">Go Nuts</a>
 mailing list have active developers that can help you with problems
 with your installation or your development work.
 For those who wish to keep up to date,
-there is another mailing list, <a href="//groups.google.com/group/golang-checkins">golang-checkins</a>,
+there is another mailing list, <a href="http://groups.google.com/group/golang-checkins">golang-checkins</a>,
 that receives a message summarizing each checkin to the Go repository.
 </p>
 
 <p>
-Bugs can be reported using the <a href="//code.google.com/p/go/issues/list">Go issue tracker</a>.
+Bugs can be reported using the <a href="http://code.google.com/p/go/issues/list">Go issue tracker</a>.
 </p>
 
 
@@ -306,7 +302,7 @@ The Go project maintains a stable tag in its Mercurial repository:
 <p>
 The <code>release</code> tag refers to the current stable release of Go.
 Most Go users should use this version. New releases are announced on the
-<a href="//groups.google.com/group/golang-announce">golang-announce</a>
+<a href="http://groups.google.com/group/golang-announce">golang-announce</a>
 mailing list.
 </p>
 
@@ -358,9 +354,9 @@ These default to the values of <code>$GOHOSTOS</code> and
 
 <p>
 Choices for <code>$GOOS</code> are
-<code>darwin</code> (Mac OS X 10.6 and above), <code>dragonfly</code>, <code>freebsd</code>,
+<code>darwin</code> (Mac OS X 10.6 and above), <code>freebsd</code>,
 <code>linux</code>, <code>netbsd</code>, <code>openbsd</code>, 
-<code>plan9</code>, <code>solaris</code> and <code>windows</code>.
+<code>plan9</code>, and <code>windows</code>.
 Choices for <code>$GOARCH</code> are
 <code>amd64</code> (64-bit x86, the most mature port),
 <code>386</code> (32-bit x86), and <code>arm</code> (32-bit ARM).
@@ -376,12 +372,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>darwin</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
-<td></td><td><code>dragonfly</code></td> <td><code>386</code></td>
-</tr>
-<tr>
-<td></td><td><code>dragonfly</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
 <td></td><td><code>freebsd</code></td> <td><code>386</code></td>
 </tr>
 <tr>
@@ -421,9 +411,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>plan9</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
-<td></td><td><code>solaris</code></td> <td><code>amd64</code></td>
-</tr>
-<tr>
 <td></td><td><code>windows</code></td> <td><code>386</code></td>
 </tr>
 <tr>
@@ -457,7 +444,7 @@ installs all commands there.
 </p>
 
 <li><code>$GO386</code> (for <code>386</code> only, default is auto-detected
-if built on either <code>386</code> or <code>amd64</code>, <code>387</code> otherwise)
+if built natively, <code>387</code> if not)
 <p>
 This controls the code generated by 8g to use either the 387 floating-point unit
 (set to <code>387</code>) or SSE2 instructions (set to <code>sse2</code>) for
@@ -482,8 +469,8 @@ should target. If you are compiling on the target system, its value will be auto
 <p>
 If in doubt, leave this variable unset, and adjust it if required
 when you first run the Go executable.
-The <a href="//golang.org/wiki/GoArm">GoARM</a> page
-on the <a href="//golang.org/wiki">Go community wiki</a>
+The <a href="http://code.google.com/p/go-wiki/wiki/GoArm">GoARM</a> page
+on the <a href="http://code.google.com/p/go-wiki/w/list">Go community wiki</a>
 contains further details regarding Go's ARM support.
 </p>
 

doc/install.html

@@ -6,15 +6,15 @@
 <h2 id="download">Download the Go distribution</h2>
 
 <p>
-<a href="https://golang.org/dl/" id="start" class="download" target="_blank">
+<a href="http://code.google.com/p/go/downloads" id="start" class="download" target="_blank">
 <span class="big">Download Go</span>
 <span class="desc">Click here to visit the downloads page</span>
 </a>
 </p>
 
 <p>
-<a href="https://golang.org/dl/" target="_blank">Official binary
-distributions</a> are available for the FreeBSD (release 8 and above), Linux, Mac OS X (Snow Leopard
+<a href="http://code.google.com/p/go/downloads" target="_blank">Official binary
+distributions</a> are available for the FreeBSD, Linux, Mac OS X (Snow Leopard
 and above), and Windows operating systems and the 32-bit (<code>386</code>) and
 64-bit (<code>amd64</code>) x86 processor architectures.
 </p>
@@ -39,15 +39,15 @@ proceeding. If your OS or architecture is not on the list, it's possible that
 
 <table class="codetable" frame="border" summary="requirements">
 <tr>
-<th align="center">Operating system</th>
-<th align="center">Architectures</th>
-<th align="center">Notes</th>
+<th align="middle">Operating system</th>
+<th align="middle">Architectures</th>
+<th align="middle">Notes</th>
 </tr>
 <tr><td colspan="3"><hr></td></tr>
-<tr><td>FreeBSD 8 or later</td> <td>amd64, 386, arm</td> <td>Debian GNU/kFreeBSD not supported; FreeBSD/ARM needs FreeBSD 10 or later</td></tr>
+<tr><td>FreeBSD 7 or later</td> <td>amd64, 386, arm</td> <td>Debian GNU/kFreeBSD not supported; FreeBSD/ARM needs FreeBSD 10 or later</td></tr>
 <tr><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm</td> <td>CentOS/RHEL 5.x not supported; no binary distribution for ARM yet</td></tr>
 <tr><td>Mac OS X 10.6 or later</td> <td>amd64, 386</td> <td>use the gcc<sup>&#8224;</sup> that comes with Xcode<sup>&#8225;</sup></td></tr>
-<tr><td>Windows XP or later</td> <td>amd64, 386</td> <td>use MinGW gcc<sup>&#8224;</sup>. No need for cgywin or msys.</td></tr>
+<tr><td>Windows 2000 or later</td> <td>amd64, 386</td> <td>use mingw gcc<sup>&#8224;</sup>; cygwin or msys is not needed</td></tr>
 </table>
 
 <p>
@@ -70,19 +70,18 @@ first <a href="#uninstall">remove the existing version</a>.
 <h3 id="tarball">Linux, Mac OS X, and FreeBSD tarballs</h3>
 
 <p>
-<a href="https://golang.org/dl/">Download the archive</a>
+<a href="http://code.google.com/p/go/downloads/list?q=OpSys-FreeBSD+OR+OpSys-Linux+OR+OpSys-OSX+Type-Archive">Download the archive</a>
 and extract it into <code>/usr/local</code>, creating a Go tree in
 <code>/usr/local/go</code>. For example:
 </p>
 
 <pre>
-tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz
+tar -C /usr/local -xzf go1.2.1.linux-amd64.tar.gz
 </pre>
 
 <p>
-Choose the archive file appropriate for your installation.
-For instance, if you are installing Go version 1.2.1 for 64-bit x86 on Linux,
-the archive you want is called <code>go1.2.1.linux-amd64.tar.gz</code>.
+The name of the archive may differ, depending on the version of Go you are
+installing and your system's operating system and processor architecture.
 </p>
 
 <p>
@@ -127,7 +126,7 @@ location.
 <h3 id="osx">Mac OS X package installer</h3>
 
 <p>
-<a href="https://golang.org/dl/">Download the package file</a>,
+<a href="http://code.google.com/p/go/downloads/list?q=OpSys-OSX+Type-Installer">Download the package file</a>,
 open it, and follow the prompts to install the Go tools.
 The package installs the Go distribution to <code>/usr/local/go</code>.
 </p>
@@ -150,7 +149,7 @@ MSI installer that configures your installation automatically.
 <h4 id="windows_msi">MSI installer</h4>
 
 <p>
-Open the <a href="https://golang.org/dl/">MSI file</a>
+Open the <a href="http://code.google.com/p/go/downloads/list?q=OpSys-Windows+Type%3DInstaller">MSI file</a>
 and follow the prompts to install the Go tools.
 By default, the installer puts the Go distribution in <code>c:\Go</code>.
 </p>
@@ -164,7 +163,7 @@ command prompts for the change to take effect.
 <h4 id="windows_zip">Zip archive</h4>
 
 <p>
-<a href="https://golang.org/dl/">Download the zip file</a> and extract it into the directory of your choice (we suggest <code>c:\Go</code>).
+<a href="http://code.google.com/p/go/downloads/list?q=OpSys-Windows+Type%3DArchive">Download the zip file</a> and extract it into the directory of your choice (we suggest <code>c:\Go</code>).
 </p>
 
 <p>
@@ -224,12 +223,19 @@ If you see the "hello, world" message then your Go installation is working.
 
 <p>
 You're almost done.
-You just need to set up your environment.
+You just need to do a little more setup.
 </p>
 
 <p>
-Read the <a href="/doc/code.html">How to Write Go Code</a> document,
-which provides <b>essential setup instructions</b> for using the Go tools.
+<a href="/doc/code.html" class="download" id="start">
+<span class="big">How to Write Go Code</span>
+<span class="desc">Learn how to set up and use the Go tools</span>
+</a>
+</p>
+
+<p>
+The <a href="/doc/code.html">How to Write Go Code</a> document
+provides <b>essential setup instructions</b> for using the Go tools.
 </p>
 
 
@@ -263,10 +269,12 @@ For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
 
 <p>
 The official mailing list for discussion of the Go language is
-<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+<a href="http://groups.google.com/group/golang-nuts">Go Nuts</a>.
 </p>
 
 <p>
 Report bugs using the
-<a href="//golang.org/issue">Go issue tracker</a>.
+<a href="http://code.google.com/p/go/issues/list">Go issue tracker</a>.
 </p>
+
+

doc/root.html

@@ -26,7 +26,7 @@ Hello, 世界
 <div class="buttons">
 <a class="run" href="#" title="Run this code [shift-enter]">Run</a>
 <a class="share" href="#" title="Share this code">Share</a>
-<a class="tour" href="//tour.golang.org/" title="Learn Go from your browser">Tour</a>
+<a class="tour" href="http://tour.golang.org/" title="Learn Go from your browser">Tour</a>
 </div>
 <div class="toys">
 <select>
@@ -78,7 +78,7 @@ Linux, Mac OS X, Windows, and more.
 
 <div id="blog">
 <div class="rootHeading">Featured articles</div>
-<div class="read"><a href="//blog.golang.org/">Read more</a></div>
+<div class="read"><a href="http://blog.golang.org/">Read more</a></div>
 </div>
 
 </div>
@@ -124,7 +124,7 @@ window.initFuncs.push(function() {
 			"outputEl":      "#learn .output",
 			"runEl":         "#learn .run",
 			"shareEl":       "#learn .share",
-			"shareRedirect": "//play.golang.org/p/",
+			"shareRedirect": "http://play.golang.org/p/",
 			"toysEl":        "#learn .toys select"
 		});
 	} else {
@@ -133,13 +133,14 @@ window.initFuncs.push(function() {
 
 	// Load blog feed.
 	$('<script/>').attr('text', 'text/javascript')
-		.attr('src', '//blog.golang.org/.json?jsonp=feedLoaded')
+		.attr('src', 'http://blog.golang.org/.json?jsonp=feedLoaded')
 		.appendTo('body');
 
 	// Set the video at random.
 	var videos = [
 		{h: 241, s: "//www.youtube.com/embed/ytEkHepK08c"}, // Tour of Go
 		{h: 241, s: "//www.youtube.com/embed/f6kdp27TYZs"}, // Concurrency Patterns
+		{h: 233, s: "//player.vimeo.com/video/53221560"},   // Grows with grace
 		{h: 233, s: "//player.vimeo.com/video/69237265"}    // Simple environment
 	];
 	var v = videos[Math.floor(Math.random()*videos.length)];

doc/tos.html

@@ -5,7 +5,7 @@
 <p>
 The Go website (the "Website") is hosted by Google.
 By using and/or visiting the Website, you consent to be bound by Google's general
-<a href="//www.google.com/intl/en/policies/terms/">Terms of Service</a>
+<a href="http://www.google.com/intl/en/policies/terms/">Terms of Service</a>
 and Google's general
-<a href="//www.google.com/intl/en/privacy/privacy-policy.html">Privacy Policy</a>.
+<a href="http://www.google.com/intl/en/privacy/privacy-policy.html">Privacy Policy</a>.
 </p>

include/bio.h

@@ -33,6 +33,8 @@ extern "C" {
 AUTOLIB(bio)
 #endif
 
+#include <fcntl.h>	/* for O_RDONLY, O_WRONLY */
+
 typedef	struct	Biobuf	Biobuf;
 
 enum
@@ -73,7 +75,7 @@ struct	Biobuf
  * next few bytes in little-endian order.
  */
 #define	BGETC(bp)\
-	((bp)->icount?(int)((bp)->ebuf[(bp)->icount++]):Bgetc((bp)))
+	((bp)->icount?(bp)->ebuf[(bp)->icount++]:Bgetc((bp)))
 #define	BGETLE2(bp)\
 	((bp)->icount<=-2?((bp)->icount+=2,((bp)->ebuf[(bp)->icount-2])|((bp)->ebuf[(bp)->icount-1]<<8)):Bgetle2((bp)))
 #define	BGETLE4(bp)\
@@ -129,14 +131,6 @@ int	Bungetc(Biobuf*);
 int	Bungetrune(Biobuf*);
 long	Bwrite(Biobuf*, void*, long);
 int	Bvprint(Biobuf*, char*, va_list);
-/*c2go
-int	BGETC(Biobuf*);
-int	BGETLE2(Biobuf*);
-int	BGETLE4(Biobuf*);
-int	BPUTC(Biobuf*, int);
-int	BPUTLE2(Biobuf*, int);
-int	BPUTLE4(Biobuf*, int);
-*/
 
 #if defined(__cplusplus)
 }

include/bootexec.h

@@ -0,0 +1,169 @@
+// Inferno libmach/bootexec.h
+// http://code.google.com/p/inferno-os/source/browse/utils/libmach/bootexec.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.
+//	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
+//	Portions Copyright © 1997-1999 Vita Nuova Limited.
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
+//	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+struct coffsect
+{
+	char	name[8];
+	uint32	phys;
+	uint32	virt;
+	uint32	size;
+	uint32	fptr;
+	uint32	fptrreloc;
+	uint32	fptrlineno;
+	uint32	nrelocnlineno;
+	uint32	flags;
+};
+
+/*
+ * proprietary exec headers, needed to bootstrap various machines
+ */
+struct mipsexec
+{
+	short	mmagic;		/* (0x160) mips magic number */
+	short	nscns;		/* (unused) number of sections */
+	int32	timdat;		/* (unused) time & date stamp */
+	int32	symptr;		/* offset to symbol table */
+	int32	nsyms;		/* size of symbol table */
+	short	opthdr;		/* (0x38) sizeof(optional hdr) */
+	short	pcszs;		/* flags */
+	short	amagic;		/* see above */
+	short	vstamp;		/* version stamp */
+	int32	tsize;		/* text size in bytes */
+	int32	dsize;		/* initialized data */
+	int32	bsize;		/* uninitialized data */
+	int32	mentry;		/* entry pt.				*/
+	int32	text_start;	/* base of text used for this file	*/
+	int32	data_start;	/* base of data used for this file	*/
+	int32	bss_start;	/* base of bss used for this file	*/
+	int32	gprmask;	/* general purpose register mask	*/
+union{
+	int32	cprmask[4];	/* co-processor register masks		*/
+	int32	pcsize;
+};
+	int32	gp_value;	/* the gp value used for this object    */
+};
+
+struct mips4kexec
+{
+	struct mipsexec	h;
+	struct coffsect	itexts;
+	struct coffsect idatas;
+	struct coffsect ibsss;
+};
+
+struct sparcexec
+{
+	short	sjunk;		/* dynamic bit and version number */
+	short	smagic;		/* 0407 */
+	uint32	stext;
+	uint32	sdata;
+	uint32	sbss;
+	uint32	ssyms;
+	uint32	sentry;
+	uint32	strsize;
+	uint32	sdrsize;
+};
+
+struct nextexec
+{
+/* UNUSED
+	struct	nexthdr{
+		uint32	nmagic;
+		uint32	ncputype;
+		uint32	ncpusubtype;
+		uint32	nfiletype;
+		uint32	ncmds;
+		uint32	nsizeofcmds;
+		uint32	nflags;
+	};
+
+	struct nextcmd{
+		uint32	cmd;
+		uint32	cmdsize;
+		uchar	segname[16];
+		uint32	vmaddr;
+		uint32	vmsize;
+		uint32	fileoff;
+		uint32	filesize;
+		uint32	maxprot;
+		uint32	initprot;
+		uint32	nsects;
+		uint32	flags;
+	}textc;
+	struct nextsect{
+		char	sectname[16];
+		char	segname[16];
+		uint32	addr;
+		uint32	size;
+		uint32	offset;
+		uint32	align;
+		uint32	reloff;
+		uint32	nreloc;
+		uint32	flags;
+		uint32	reserved1;
+		uint32	reserved2;
+	}texts;
+	struct nextcmd	datac;
+	struct nextsect	datas;
+	struct nextsect	bsss;
+	struct nextsym{
+		uint32	cmd;
+		uint32	cmdsize;
+		uint32	symoff;
+		uint32	nsyms;
+		uint32	spoff;
+		uint32	pcoff;
+	}symc;
+*/
+};
+
+struct i386exec
+{
+/* UNUSED
+	struct	i386coff{
+		uint32	isectmagic;
+		uint32	itime;
+		uint32	isyms;
+		uint32	insyms;
+		uint32	iflags;
+	};
+	struct	i386hdr{
+		uint32	imagic;
+		uint32	itextsize;
+		uint32	idatasize;
+		uint32	ibsssize;
+		uint32	ientry;
+		uint32	itextstart;
+		uint32	idatastart;
+	};
+	struct coffsect	itexts;
+	struct coffsect idatas;
+	struct coffsect ibsss;
+	struct coffsect icomments;
+*/
+};

include/link.h

@@ -1,650 +0,0 @@
-// Derived from Inferno utils/6l/l.h and related files.
-// http://code.google.com/p/inferno-os/source/browse/utils/6l/l.h
-//
-//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
-//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
-//	Portions Copyright © 1997-1999 Vita Nuova Limited
-//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
-//	Portions Copyright © 2004,2006 Bruce Ellis
-//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
-//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-typedef	struct	Addr	Addr;
-typedef	struct	Prog	Prog;
-typedef	struct	LSym	LSym;
-typedef	struct	Reloc	Reloc;
-typedef	struct	Auto	Auto;
-typedef	struct	Hist	Hist;
-typedef	struct	Link	Link;
-typedef	struct	Plist	Plist;
-typedef	struct	LinkArch	LinkArch;
-typedef	struct	Library	Library;
-
-typedef	struct	Pcln	Pcln;
-typedef	struct	Pcdata	Pcdata;
-typedef	struct	Pciter	Pciter;
-
-// prevent incompatible type signatures between liblink and 8l on Plan 9
-#pragma incomplete struct Node
-
-struct	Addr
-{
-	vlong	offset;
-
-	union
-	{
-		char	sval[8];
-		float64	dval;
-		Prog*	branch;	// for 5g, 6g, 8g, 9g
-	} u;
-
-	LSym*	sym;
-	LSym*	gotype;
-	short	type;
-	uint8	index;
-	int8	scale;
-	int8	reg;	// for 5l, 9l
-	int8	name; // for 5l, 9l
-	int8	class;	// for 5l, 9l
-	uint8	etype; // for 5g, 6g, 8g
-	int32	offset2;	// for 5l, 8l
-	struct Node*	node; // for 5g, 6g, 8g
-	int64	width; // for 5g, 6g, 8g
-};
-
-struct	Reloc
-{
-	int32	off;
-	uchar	siz;
-	uchar	done;
-	int32	type;
-	int64	add;
-	int64	xadd;
-	LSym*	sym;
-	LSym*	xsym;
-};
-
-struct	Prog
-{
-	vlong	pc;
-	int32	lineno;
-	Prog*	link;
-	short	as;
-	uchar	scond; // arm only; condition codes
-
-	// operands
-	Addr	from;
-	uchar	reg; // arm, power64 only (e.g., ADD from, reg, to);
-		     // also used for ADATA width on arm, power64
-	Addr	from3; // power64 only (e.g., RLWM/FMADD from, reg, from3, to)
-	Addr	to;
-	
-	// for 5g, 6g, 8g internal use
-	void*	opt;
-
-	// for 5l, 6l, 8l internal use
-	Prog*	forwd;
-	Prog*	pcond;
-	Prog*	comefrom;	// 6l, 8l
-	Prog*	pcrel;	// 5l
-	int32	spadj;
-	uint16	mark;
-	uint16	optab;	// 5l, 9l
-	uchar	back;	// 6l, 8l
-	uchar	ft;	/* 6l, 8l oclass cache */
-	uchar	tt;	// 6l, 8l
-	uchar	isize;	// 6l, 8l
-
-	char	width;	/* fake for DATA */
-	char	mode;	/* 16, 32, or 64 in 6l, 8l; internal use in 5g, 6g, 8g */
-	
-	/*c2go uchar TEXTFLAG; */
-};
-
-// prevent incompatible type signatures between liblink and 8l on Plan 9
-#pragma incomplete struct Section
-
-struct	LSym
-{
-	char*	name;
-	char*	extname;	// name used in external object files
-	short	type;
-	short	version;
-	uchar	dupok;
-	uchar	cfunc;
-	uchar	external;
-	uchar	nosplit;
-	uchar	reachable;
-	uchar	cgoexport;
-	uchar	special;
-	uchar	stkcheck;
-	uchar	hide;
-	uchar	leaf;	// arm only
-	uchar	fnptr;	// arm only
-	uchar	seenglobl;
-	uchar	onlist;	// on the textp or datap lists
-	int16	symid;	// for writing .5/.6/.8 files
-	int32	dynid;
-	int32	sig;
-	int32	plt;
-	int32	got;
-	int32	align;	// if non-zero, required alignment in bytes
-	int32	elfsym;
-	int32	args;	// size of stack frame incoming arguments area
-	int32	locals;	// size of stack frame locals area (arm only?)
-	vlong	value;
-	vlong	size;
-	LSym*	hash;	// in hash table
-	LSym*	allsym;	// in all symbol list
-	LSym*	next;	// in text or data list
-	LSym*	sub;	// in SSUB list
-	LSym*	outer;	// container of sub
-	LSym*	gotype;
-	LSym*	reachparent;
-	LSym*	queue;
-	char*	file;
-	char*	dynimplib;
-	char*	dynimpvers;
-	struct Section*	sect;
-	
-	// STEXT
-	Auto*	autom;
-	Prog*	text;
-	Prog*	etext;
-	Pcln*	pcln;
-
-	// SDATA, SBSS
-	uchar*	p;
-	int	np;
-	int32	maxp;
-	Reloc*	r;
-	int32	nr;
-	int32	maxr;
-};
-
-// LSym.type
-enum
-{
-	Sxxx,
-
-	/* order here is order in output file */
-	/* readonly, executable */
-	STEXT,
-	SELFRXSECT,
-	
-	/* readonly, non-executable */
-	STYPE,
-	SSTRING,
-	SGOSTRING,
-	SGOFUNC,
-	SRODATA,
-	SFUNCTAB,
-	STYPELINK,
-	SSYMTAB, // TODO: move to unmapped section
-	SPCLNTAB,
-	SELFROSECT,
-	
-	/* writable, non-executable */
-	SMACHOPLT,
-	SELFSECT,
-	SMACHO,	/* Mach-O __nl_symbol_ptr */
-	SMACHOGOT,
-	SWINDOWS,
-	SNOPTRDATA,
-	SINITARR,
-	SDATA,
-	SBSS,
-	SNOPTRBSS,
-	STLSBSS,
-
-	/* not mapped */
-	SXREF,
-	SMACHOSYMSTR,
-	SMACHOSYMTAB,
-	SMACHOINDIRECTPLT,
-	SMACHOINDIRECTGOT,
-	SFILE,
-	SFILEPATH,
-	SCONST,
-	SDYNIMPORT,
-	SHOSTOBJ,
-
-	SSUB = 1<<8,	/* sub-symbol, linked from parent via ->sub list */
-	SMASK = SSUB - 1,
-	SHIDDEN = 1<<9, // hidden or local symbol
-};
-
-// Reloc.type
-enum
-{
-	R_ADDR = 1,
-	R_ADDRPOWER, // relocation for loading 31-bit address using addis and addi/ld/st for Power
-	R_SIZE,
-	R_CALL, // relocation for direct PC-relative call
-	R_CALLARM, // relocation for ARM direct call
-	R_CALLIND, // marker for indirect call (no actual relocating necessary)
-	R_CALLPOWER, // relocation for Power direct call
-	R_CONST,
-	R_PCREL,
-	R_TLS,
-	R_TLS_LE, // TLS local exec offset from TLS segment register
-	R_TLS_IE, // TLS initial exec offset from TLS base pointer
-	R_GOTOFF,
-	R_PLT0,
-	R_PLT1,
-	R_PLT2,
-	R_USEFIELD,
-};
-
-// Auto.type
-enum
-{
-	A_AUTO = 1,
-	A_PARAM,
-};
-
-struct	Auto
-{
-	LSym*	asym;
-	Auto*	link;
-	int32	aoffset;
-	int16	type;
-	LSym*	gotype;
-};
-
-enum
-{
-	LINKHASH = 100003,
-};
-
-struct	Hist
-{
-	Hist*	link;
-	char*	name;
-	int32	line;
-	int32	offset;
-};
-
-struct	Plist
-{
-	LSym*	name;
-	Prog*	firstpc;
-	int	recur;
-	Plist*	link;
-};
-
-struct	Library
-{
-	char *objref;	// object where we found the reference
-	char *srcref;	// src file where we found the reference
-	char *file;	// object file
-	char *pkg;	// import path
-};
-
-struct Pcdata
-{
-	uchar *p;
-	int n;
-	int m;
-};
-
-struct Pcln
-{
-	Pcdata pcsp;
-	Pcdata pcfile;
-	Pcdata pcline;
-	Pcdata *pcdata;
-	int npcdata;
-	LSym **funcdata;
-	int64 *funcdataoff;
-	int nfuncdata;
-	
-	LSym **file;
-	int nfile;
-	int mfile;
-
-	LSym *lastfile;
-	int lastindex;
-};
-
-// Pcdata iterator.
-//	for(pciterinit(ctxt, &it, &pcd); !it.done; pciternext(&it)) { it.value holds in [it.pc, it.nextpc) }
-struct Pciter
-{
-	Pcdata d;
-	uchar *p;
-	uint32 pc;
-	uint32 nextpc;
-	uint32 pcscale;
-	int32 value;
-	int start;
-	int done;
-};
-
-void	pciterinit(Link*, Pciter*, Pcdata*);
-void	pciternext(Pciter*);
-
-// symbol version, incremented each time a file is loaded.
-// version==1 is reserved for savehist.
-enum
-{
-	HistVersion = 1,
-};
-
-// Link holds the context for writing object code from a compiler
-// to be linker input or for reading that input into the linker.
-struct	Link
-{
-	int32	thechar; // '5' (arm), '6' (amd64), etc.
-	char*	thestring; // full name of architecture ("arm", "amd64", ..)
-	int32	goarm; // for arm only, GOARM setting
-	int	headtype;
-
-	LinkArch*	arch;
-	int32	(*ignore)(char*);	// do not emit names satisfying this function
-	int32	debugasm;	// -S flag in compiler
-	int32	debugline;	// -L flag in compiler
-	int32	debughist;	// -O flag in linker
-	int32	debugread;	// -W flag in linker
-	int32	debugvlog;	// -v flag in linker
-	int32	debugstack;	// -K flag in linker
-	int32	debugzerostack;	// -Z flag in linker
-	int32	debugdivmod;	// -M flag in 5l
-	int32	debugfloat;	// -F flag in 5l
-	int32	debugpcln;	// -O flag in linker
-	int32	flag_shared;	// -shared flag in linker
-	int32	iself;
-	Biobuf*	bso;	// for -v flag
-	char*	pathname;
-	int32	windows;
-	char*	trimpath;
-	char*	goroot;
-	char*	goroot_final;
-	int32	enforce_data_order;	// for use by assembler
-
-	// hash table of all symbols
-	LSym*	hash[LINKHASH];
-	LSym*	allsym;
-	int32	nsymbol;
-
-	// file-line history
-	Hist*	hist;
-	Hist*	ehist;
-	
-	// all programs
-	Plist*	plist;
-	Plist*	plast;
-	
-	// code generation
-	LSym*	sym_div;
-	LSym*	sym_divu;
-	LSym*	sym_mod;
-	LSym*	sym_modu;
-	LSym*	symmorestack[2];
-	LSym*	tlsg;
-	LSym*	plan9privates;
-	Prog*	curp;
-	Prog*	printp;
-	Prog*	blitrl;
-	Prog*	elitrl;
-	int	rexflag;
-	int	rep; // for nacl
-	int	repn; // for nacl
-	int	lock; // for nacl
-	int	asmode;
-	uchar*	andptr;
-	uchar	and[100];
-	int64	instoffset;
-	int32	autosize;
-	int32	armsize;
-
-	// for reading input files (during linker)
-	vlong	pc;
-	char**	libdir;
-	int32	nlibdir;
-	int32	maxlibdir;
-	Library*	library;
-	int	libraryp;
-	int	nlibrary;
-	int	tlsoffset;
-	void	(*diag)(char*, ...);
-	int	mode;
-	Auto*	curauto;
-	Auto*	curhist;
-	LSym*	cursym;
-	int	version;
-	LSym*	textp;
-	LSym*	etextp;
-	int32	histdepth;
-	int32	nhistfile;
-	LSym*	filesyms;
-};
-
-enum {
-	LittleEndian = 0x04030201,
-	BigEndian = 0x01020304,
-};
-
-// LinkArch is the definition of a single architecture.
-struct LinkArch
-{
-	char*	name; // "arm", "amd64", and so on
-	int	thechar;	// '5', '6', and so on
-	int32	endian; // LittleEndian or BigEndian
-
-	void	(*addstacksplit)(Link*, LSym*);
-	void	(*assemble)(Link*, LSym*);
-	int	(*datasize)(Prog*);
-	void	(*follow)(Link*, LSym*);
-	int	(*iscall)(Prog*);
-	int	(*isdata)(Prog*);
-	Prog*	(*prg)(void);
-	void	(*progedit)(Link*, Prog*);
-	void	(*settextflag)(Prog*, int);
-	int	(*symtype)(Addr*);
-	int	(*textflag)(Prog*);
-
-	int	minlc;
-	int	ptrsize;
-	int	regsize;
-	
-	// TODO: Give these the same values on all systems.
-	int	D_ADDR;
-	int	D_AUTO;
-	int	D_BRANCH;
-	int	D_CONST;
-	int	D_EXTERN;
-	int	D_FCONST;
-	int	D_NONE;
-	int	D_PARAM;
-	int	D_SCONST;
-	int	D_STATIC;
-	int	D_OREG;
-
-	int	ACALL;
-	int	ADATA;
-	int	AEND;
-	int	AFUNCDATA;
-	int	AGLOBL;
-	int	AJMP;
-	int	ANOP;
-	int	APCDATA;
-	int	ARET;
-	int	ATEXT;
-	int	ATYPE;
-	int	AUSEFIELD;
-};
-
-/* executable header types */
-enum {
-	Hunknown = 0,
-	Hdarwin,
-	Hdragonfly,
-	Helf,
-	Hfreebsd,
-	Hlinux,
-	Hnacl,
-	Hnetbsd,
-	Hopenbsd,
-	Hplan9,
-	Hsolaris,
-	Hwindows,
-};
-
-enum
-{
-	LinkAuto = 0,
-	LinkInternal,
-	LinkExternal,
-};
-
-extern	uchar	fnuxi8[8];
-extern	uchar	fnuxi4[4];
-extern	uchar	inuxi1[1];
-extern	uchar	inuxi2[2];
-extern	uchar	inuxi4[4];
-extern	uchar	inuxi8[8];
-
-// asm5.c
-void	span5(Link *ctxt, LSym *s);
-int	chipfloat5(Link *ctxt, float64 e);
-int	chipzero5(Link *ctxt, float64 e);
-
-// asm6.c
-void	span6(Link *ctxt, LSym *s);
-
-// asm8.c
-void	span8(Link *ctxt, LSym *s);
-
-// asm9.c
-void	span9(Link *ctxt, LSym *s);
-
-// data.c
-vlong	addaddr(Link *ctxt, LSym *s, LSym *t);
-vlong	addaddrplus(Link *ctxt, LSym *s, LSym *t, vlong add);
-vlong	addaddrplus4(Link *ctxt, LSym *s, LSym *t, vlong add);
-vlong	addpcrelplus(Link *ctxt, LSym *s, LSym *t, vlong add);
-Reloc*	addrel(LSym *s);
-vlong	addsize(Link *ctxt, LSym *s, LSym *t);
-vlong	adduint16(Link *ctxt, LSym *s, uint16 v);
-vlong	adduint32(Link *ctxt, LSym *s, uint32 v);
-vlong	adduint64(Link *ctxt, LSym *s, uint64 v);
-vlong	adduint8(Link *ctxt, LSym *s, uint8 v);
-vlong	adduintxx(Link *ctxt, LSym *s, uint64 v, int wid);
-void	mangle(char *file);
-void	savedata(Link *ctxt, LSym *s, Prog *p, char *pn);
-void	savedata1(Link *ctxt, LSym *s, Prog *p, char *pn, int enforce_order);
-vlong	setaddr(Link *ctxt, LSym *s, vlong off, LSym *t);
-vlong	setaddrplus(Link *ctxt, LSym *s, vlong off, LSym *t, vlong add);
-vlong	setuint16(Link *ctxt, LSym *s, vlong r, uint16 v);
-vlong	setuint32(Link *ctxt, LSym *s, vlong r, uint32 v);
-vlong	setuint64(Link *ctxt, LSym *s, vlong r, uint64 v);
-vlong	setuint8(Link *ctxt, LSym *s, vlong r, uint8 v);
-vlong	setuintxx(Link *ctxt, LSym *s, vlong off, uint64 v, vlong wid);
-void	symgrow(Link *ctxt, LSym *s, vlong siz);
-
-// go.c
-void	double2ieee(uint64 *ieee, double native);
-void*	emallocz(long n);
-void*	erealloc(void *p, long n);
-char*	estrdup(char *p);
-char*	expandpkg(char *t0, char *pkg);
-
-// ld.c
-void	addhist(Link *ctxt, int32 line, int type);
-void	addlib(Link *ctxt, char *src, char *obj, char *path);
-void	addlibpath(Link *ctxt, char *srcref, char *objref, char *file, char *pkg);
-void	collapsefrog(Link *ctxt, LSym *s);
-void	copyhistfrog(Link *ctxt, char *buf, int nbuf);
-int	find1(int32 l, int c);
-void	linkgetline(Link *ctxt, int32 line, LSym **f, int32 *l);
-void	histtoauto(Link *ctxt);
-void	mkfwd(LSym*);
-void	nuxiinit(LinkArch*);
-void	savehist(Link *ctxt, int32 line, int32 off);
-Prog*	copyp(Link*, Prog*);
-Prog*	appendp(Link*, Prog*);
-vlong	atolwhex(char*);
-
-// list[5689].c
-void	listinit5(void);
-void	listinit6(void);
-void	listinit8(void);
-void	listinit9(void);
-
-// obj.c
-int	linklinefmt(Link *ctxt, Fmt *fp);
-void	linklinehist(Link *ctxt, int lineno, char *f, int offset);
-Plist*	linknewplist(Link *ctxt);
-void	linkprfile(Link *ctxt, int32 l);
-
-// objfile.c
-void	ldobjfile(Link *ctxt, Biobuf *b, char *pkg, int64 len, char *path);
-void	writeobj(Link *ctxt, Biobuf *b);
-
-// pass.c
-Prog*	brchain(Link *ctxt, Prog *p);
-Prog*	brloop(Link *ctxt, Prog *p);
-void	linkpatch(Link *ctxt, LSym *sym);
-
-// pcln.c
-void	linkpcln(Link*, LSym*);
-
-// sym.c
-LSym*	linklookup(Link *ctxt, char *name, int v);
-Link*	linknew(LinkArch*);
-LSym*	linknewsym(Link *ctxt, char *symb, int v);
-LSym*	linkrlookup(Link *ctxt, char *name, int v);
-int	linksymfmt(Fmt *f);
-int	headtype(char*);
-char*	headstr(int);
-
-extern	char*	anames5[];
-extern	char*	anames6[];
-extern	char*	anames8[];
-extern	char*	anames9[];
-
-extern	char*	cnames5[];
-extern	char*	cnames9[];
-
-extern	char*	dnames5[];
-extern	char*	dnames6[];
-extern	char*	dnames8[];
-extern	char*	dnames9[];
-
-extern	LinkArch	link386;
-extern	LinkArch	linkamd64;
-extern	LinkArch	linkamd64p32;
-extern	LinkArch	linkarm;
-extern	LinkArch	linkpower64;
-extern	LinkArch	linkpower64le;
-
-#pragma	varargck	type	"A"	int
-#pragma	varargck	type	"D"	Addr*
-#pragma	varargck	type	"lD"	Addr*
-#pragma	varargck	type	"P"	Prog*
-#pragma	varargck	type	"R"	int
-#pragma	varargck	type	"^"	int // for 5l/9l, C_* classes (liblink internal)
-
-// TODO(ality): remove this workaround.
-//   It's here because Pconv in liblink/list?.c references %L.
-#pragma	varargck	type	"L"	int32

include/mach.h

@@ -0,0 +1,411 @@
+// Inferno libmach/a.out.h and libmach/mach.h
+// http://code.google.com/p/inferno-os/source/browse/utils/libmach/a.out.h
+// http://code.google.com/p/inferno-os/source/browse/utils/libmach/mach.h
+//
+// 	Copyright © 1994-1999 Lucent Technologies Inc.
+// 	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
+// 	Portions Copyright © 1997-1999 Vita Nuova Limited.
+// 	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
+// 	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
+//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/*
+ *	Architecture-dependent application data
+ */
+
+typedef	struct	Exec	Exec;
+struct	Exec
+{
+	int32	magic;		/* magic number */
+	int32	text;	 	/* size of text segment */
+	int32	data;	 	/* size of initialized data */
+	int32	bss;	  	/* size of uninitialized data */
+	int32	syms;	 	/* size of symbol table */
+	int32	entry;	 	/* entry point */
+	int32	spsz;		/* size of pc/sp offset table */
+	int32	pcsz;		/* size of pc/line number table */
+};
+
+#define HDR_MAGIC	0x00008000		/* header expansion */
+
+#define	_MAGIC(f, b)	((f)|((((4*(b))+0)*(b))+7))
+#define	A_MAGIC		_MAGIC(0, 8)		/* 68020 */
+#define	I_MAGIC		_MAGIC(0, 11)		/* intel 386 */
+#define	J_MAGIC		_MAGIC(0, 12)		/* intel 960 (retired) */
+#define	K_MAGIC		_MAGIC(0, 13)		/* sparc */
+#define	V_MAGIC		_MAGIC(0, 16)		/* mips 3000 BE */
+#define	X_MAGIC		_MAGIC(0, 17)		/* att dsp 3210 (retired) */
+#define	M_MAGIC		_MAGIC(0, 18)		/* mips 4000 BE */
+#define	D_MAGIC		_MAGIC(0, 19)		/* amd 29000 (retired) */
+#define	E_MAGIC		_MAGIC(0, 20)		/* arm */
+#define	Q_MAGIC		_MAGIC(0, 21)		/* powerpc */
+#define	N_MAGIC		_MAGIC(0, 22)		/* mips 4000 LE */
+#define	L_MAGIC		_MAGIC(0, 23)		/* dec alpha */
+#define	P_MAGIC		_MAGIC(0, 24)		/* mips 3000 LE */
+#define	U_MAGIC		_MAGIC(0, 25)		/* sparc64 */
+#define	S_MAGIC		_MAGIC(HDR_MAGIC, 26)	/* amd64 */
+#define	T_MAGIC		_MAGIC(HDR_MAGIC, 27)	/* powerpc64 */
+
+#define	MIN_MAGIC	8
+#define	MAX_MAGIC	27			/* <= 90 */
+
+#define	DYN_MAGIC	0x80000000		/* dlm */
+
+typedef	struct	Sym	Sym;
+struct	Sym
+{
+	vlong	value;
+	uint	sig;
+	char	type;
+	char	*name;
+	vlong	gotype;
+	int	sequence;	// order in file
+};
+
+
+/*
+ *	Supported architectures:
+ *		mips,
+ *		68020,
+ *		i386,
+ *		amd64,
+ *		sparc,
+ *		sparc64,
+ *		mips2 (R4000)
+ *		arm
+ *		powerpc,
+ *		powerpc64
+ *		alpha
+ */
+enum
+{
+	MMIPS,			/* machine types */
+	MSPARC,
+	M68020,
+	MI386,
+	MI960,			/* retired */
+	M3210,			/* retired */
+	MMIPS2,
+	NMIPS2,
+	M29000,			/* retired */
+	MARM,
+	MPOWER,
+	MALPHA,
+	NMIPS,
+	MSPARC64,
+	MAMD64,
+	MPOWER64,
+				/* types of executables */
+	FNONE = 0,		/* unidentified */
+	FMIPS,			/* v.out */
+	FMIPSB,			/* mips bootable */
+	FSPARC,			/* k.out */
+	FSPARCB,		/* Sparc bootable */
+	F68020,			/* 2.out */
+	F68020B,		/* 68020 bootable */
+	FNEXTB,			/* Next bootable */
+	FI386,			/* 8.out */
+	FI386B,			/* I386 bootable */
+	FI960,			/* retired */
+	FI960B,			/* retired */
+	F3210,			/* retired */
+	FMIPS2BE,		/* 4.out */
+	F29000,			/* retired */
+	FARM,			/* 5.out */
+	FARMB,			/* ARM bootable */
+	FPOWER,			/* q.out */
+	FPOWERB,		/* power pc bootable */
+	FMIPS2LE,		/* 0.out */
+	FALPHA,			/* 7.out */
+	FALPHAB,		/* DEC Alpha bootable */
+	FMIPSLE,		/* 3k little endian */
+	FSPARC64,		/* u.out */
+	FAMD64,			/* 6.out */
+	FAMD64B,		/* 6.out bootable */
+	FPOWER64,		/* 9.out */
+	FPOWER64B,		/* 9.out bootable */
+	FWINPE,			/* windows PE executable */
+
+	ANONE = 0,		/* dissembler types */
+	AMIPS,
+	AMIPSCO,		/* native mips */
+	ASPARC,
+	ASUNSPARC,		/* native sun */
+	A68020,
+	AI386,
+	AI8086,			/* oh god */
+	AI960,			/* retired */
+	A29000,			/* retired */
+	AARM,
+	APOWER,
+	AALPHA,
+	ASPARC64,
+	AAMD64,
+	APOWER64,
+				/* object file types */
+	Obj68020 = 0,		/* .2 */
+	ObjSparc,		/* .k */
+	ObjMips,		/* .v */
+	Obj386,			/* .8 */
+	Obj960,			/* retired */
+	Obj3210,		/* retired */
+	ObjMips2,		/* .4 */
+	Obj29000,		/* retired */
+	ObjArm,			/* .5 */
+	ObjPower,		/* .q */
+	ObjMips2le,		/* .0 */
+	ObjAlpha,		/* .7 */
+	ObjSparc64,		/* .u */
+	ObjAmd64,		/* .6 */
+	ObjSpim,		/* .0 */
+	ObjPower64,		/* .9 */
+	Maxobjtype,
+
+	CNONE  = 0,		/* symbol table classes */
+	CAUTO,
+	CPARAM,
+	CSTAB,
+	CTEXT,
+	CDATA,
+	CANY,			/* to look for any class */
+};
+
+typedef	struct	Map	Map;
+typedef	struct	Symbol	Symbol;
+typedef	struct	Reglist	Reglist;
+typedef	struct	Mach	Mach;
+typedef	struct	Machdata Machdata;
+typedef	struct	Seg	Seg;
+
+typedef int Maprw(Map *m, Seg *s, uvlong addr, void *v, uint n, int isread);
+
+struct Seg {
+	char	*name;		/* the segment name */
+	int	fd;		/* file descriptor */
+	int	inuse;		/* in use - not in use */
+	int	cache;		/* should cache reads? */
+	uvlong	b;		/* base */
+	uvlong	e;		/* end */
+	vlong	f;		/* offset within file */
+	Maprw	*rw;		/* read/write fn for seg */
+};
+
+/*
+ * 	Structure to map a segment to data
+ */
+struct Map {
+	int	pid;
+	int	tid;
+	int	nsegs;	/* number of segments */
+	Seg	seg[1];	/* actually n of these */
+};
+
+/*
+ *	Internal structure describing a symbol table entry
+ */
+struct Symbol {
+	void 	*handle;		/* used internally - owning func */
+	struct {
+		char	*name;
+		vlong	value;		/* address or stack offset */
+		char	type;		/* as in a.out.h */
+		char	class;		/* as above */
+		int	index;		/* in findlocal, globalsym, textsym */
+	};
+};
+
+/*
+ *	machine register description
+ */
+struct Reglist {
+	char	*rname;			/* register name */
+	short	roffs;			/* offset in u-block */
+	char	rflags;			/* INTEGER/FLOAT, WRITABLE */
+	char	rformat;		/* print format: 'x', 'X', 'f', '8', '3', 'Y', 'W' */
+};
+
+enum {					/* bits in rflags field */
+	RINT	= (0<<0),
+	RFLT	= (1<<0),
+	RRDONLY	= (1<<1),
+};
+
+/*
+ *	Machine-dependent data is stored in two structures:
+ *		Mach  - miscellaneous general parameters
+ *		Machdata - jump vector of service functions used by debuggers
+ *
+ *	Mach is defined in ?.c and set in executable.c
+ *
+ *	Machdata is defined in ?db.c
+ *		and set in the debugger startup.
+ */
+struct Mach{
+	char	*name;
+	int	mtype;			/* machine type code */
+	Reglist *reglist;		/* register set */
+	int32	regsize;		/* sizeof registers in bytes */
+	int32	fpregsize;		/* sizeof fp registers in bytes */
+	char	*pc;			/* pc name */
+	char	*sp;			/* sp name */
+	char	*link;			/* link register name */
+	char	*sbreg;			/* static base register name */
+	uvlong	sb;			/* static base register value */
+	int	pgsize;			/* page size */
+	uvlong	kbase;			/* kernel base address */
+	uvlong	ktmask;			/* ktzero = kbase & ~ktmask */
+	uvlong	utop;			/* user stack top */
+	int	pcquant;		/* quantization of pc */
+	int	szaddr;			/* sizeof(void*) */
+	int	szreg;			/* sizeof(register) */
+	int	szfloat;		/* sizeof(float) */
+	int	szdouble;		/* sizeof(double) */
+};
+
+extern	Mach	*mach;			/* Current machine */
+
+typedef uvlong	(*Rgetter)(Map*, char*);
+typedef	void	(*Tracer)(Map*, uvlong, uvlong, Symbol*);
+
+struct	Machdata {		/* Machine-dependent debugger support */
+	uchar	bpinst[4];			/* break point instr. */
+	short	bpsize;				/* size of break point instr. */
+
+	ushort	(*swab)(ushort);		/* ushort to local byte order */
+	uint32	(*swal)(uint32);			/* uint32 to local byte order */
+	uvlong	(*swav)(uvlong);		/* uvlong to local byte order */
+	int	(*ctrace)(Map*, uvlong, uvlong, uvlong, Tracer); /* C traceback */
+	uvlong	(*findframe)(Map*, uvlong, uvlong, uvlong, uvlong);/* frame finder */
+	char*	(*excep)(Map*, Rgetter);	/* last exception */
+	uint32	(*bpfix)(uvlong);		/* breakpoint fixup */
+	int	(*sftos)(char*, int, void*);	/* single precision float */
+	int	(*dftos)(char*, int, void*);	/* double precision float */
+	int	(*foll)(Map*, uvlong, Rgetter, uvlong*);/* follow set */
+	int	(*das)(Map*, uvlong, char, char*, int);	/* symbolic disassembly */
+	int	(*hexinst)(Map*, uvlong, char*, int); 	/* hex disassembly */
+	int	(*instsize)(Map*, uvlong);	/* instruction size */
+};
+
+/*
+ *	Common a.out header describing all architectures
+ */
+typedef struct Fhdr
+{
+	char	*name;		/* identifier of executable */
+	uchar	type;		/* file type - see codes above */
+	uchar	hdrsz;		/* header size */
+	uchar	_magic;		/* _MAGIC() magic */
+	uchar	spare;
+	int32	magic;		/* magic number */
+	uvlong	txtaddr;	/* text address */
+	vlong	txtoff;		/* start of text in file */
+	uvlong	dataddr;	/* start of data segment */
+	vlong	datoff;		/* offset to data seg in file */
+	vlong	symoff;		/* offset of symbol table in file */
+	uvlong	entry;		/* entry point */
+	vlong	sppcoff;	/* offset of sp-pc table in file */
+	vlong	lnpcoff;	/* offset of line number-pc table in file */
+	int32	txtsz;		/* text size */
+	int32	datsz;		/* size of data seg */
+	int32	bsssz;		/* size of bss */
+	int32	symsz;		/* size of symbol table */
+	int32	sppcsz;		/* size of sp-pc table */
+	int32	lnpcsz;		/* size of line number-pc table */
+} Fhdr;
+
+extern	int	asstype;	/* dissembler type - machdata.c */
+extern	Machdata *machdata;	/* jump vector - machdata.c */
+
+int		beieee80ftos(char*, int, void*);
+int		beieeesftos(char*, int, void*);
+int		beieeedftos(char*, int, void*);
+ushort		beswab(ushort);
+uint32		beswal(uint32);
+uvlong		beswav(uvlong);
+uvlong		ciscframe(Map*, uvlong, uvlong, uvlong, uvlong);
+int		cisctrace(Map*, uvlong, uvlong, uvlong, Tracer);
+int		crackhdr(int fd, Fhdr*);
+uvlong		file2pc(char*, int32);
+int		fileelem(Sym**, uchar *, char*, int);
+int32		fileline(char*, int, uvlong);
+int		filesym(int, char*, int);
+int		findlocal(Symbol*, char*, Symbol*);
+int		findseg(Map*, char*);
+int		findsym(uvlong, int, Symbol *);
+int		fnbound(uvlong, uvlong*);
+int		fpformat(Map*, Reglist*, char*, int, int);
+int		get1(Map*, uvlong, uchar*, int);
+int		get2(Map*, uvlong, ushort*);
+int		get4(Map*, uvlong, uint32*);
+int		get8(Map*, uvlong, uvlong*);
+int		geta(Map*, uvlong, uvlong*);
+int		getauto(Symbol*, int, int, Symbol*);
+Sym*		getsym(int);
+int		globalsym(Symbol *, int);
+char*		_hexify(char*, uint32, int);
+int		ieeesftos(char*, int, uint32);
+int		ieeedftos(char*, int, uint32, uint32);
+int		isar(Biobuf*);
+int		leieee80ftos(char*, int, void*);
+int		leieeesftos(char*, int, void*);
+int		leieeedftos(char*, int, void*);
+ushort		leswab(ushort);
+uint32		leswal(uint32);
+uvlong		leswav(uvlong);
+uvlong		line2addr(int32, uvlong, uvlong);
+Map*		loadmap(Map*, int, Fhdr*);
+int		localaddr(Map*, char*, char*, uvlong*, Rgetter);
+int		localsym(Symbol*, int);
+int		lookup(char*, char*, Symbol*);
+void		machbytype(int);
+int		machbyname(char*);
+int		nextar(Biobuf*, int, char*);
+Map*		newmap(Map*, int);
+void		objtraverse(void(*)(Sym*, void*), void*);
+int		objtype(Biobuf*, char**);
+uvlong		pc2sp(uvlong);
+int32		pc2line(uvlong);
+int		put1(Map*, uvlong, uchar*, int);
+int		put2(Map*, uvlong, ushort);
+int		put4(Map*, uvlong, uint32);
+int		put8(Map*, uvlong, uvlong);
+int		puta(Map*, uvlong, uvlong);
+int		readar(Biobuf*, int, vlong, int);
+int		readobj(Biobuf*, int);
+uvlong		riscframe(Map*, uvlong, uvlong, uvlong, uvlong);
+int		risctrace(Map*, uvlong, uvlong, uvlong, Tracer);
+int		setmap(Map*, int, uvlong, uvlong, vlong, char*, Maprw *rw);
+Sym*		symbase(int32*);
+int		syminit(int, Fhdr*);
+int		symoff(char*, int, uvlong, int);
+void		textseg(uvlong, Fhdr*);
+int		textsym(Symbol*, int);
+void		unusemap(Map*, int);
+
+Map*		attachproc(int pid, Fhdr *fp);
+int		ctlproc(int pid, char *msg);
+void		detachproc(Map *m);
+int		procnotes(int pid, char ***pnotes);
+char*		proctextfile(int pid);
+int		procthreadpids(int pid, int *tid, int ntid);
+char*	procstatus(int);
+
+Maprw	fdrw;

include/plan9/386/u.h

@@ -13,5 +13,3 @@ typedef	uint	uint32;
 typedef	vlong	int64;
 typedef	uvlong	uint64;
 typedef	int	intptr;
-typedef	float	float32;
-typedef	double	float64;

include/plan9/amd64/u.h

@@ -13,5 +13,3 @@ typedef	uint	uint32;
 typedef	vlong	int64;
 typedef	uvlong	uint64;
 typedef	vlong	intptr;
-typedef	float	float32;
-typedef	double	float64;

include/plan9/bio.h

@@ -1,8 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "../bio.h"
-
-#define fmtcharstod charstod
-#define lseek seek

include/plan9/fmt.h

@@ -1,64 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "../fmt.h"
-
-#pragma	varargck	argpos	fmtprint	2
-#pragma	varargck	argpos	fprint		2
-#pragma	varargck	argpos	print		1
-#pragma	varargck	argpos	runeseprint	3
-#pragma	varargck	argpos	runesmprint	1
-#pragma	varargck	argpos	runesnprint	3
-#pragma	varargck	argpos	runesprint	2
-#pragma	varargck	argpos	seprint		3
-#pragma	varargck	argpos	smprint		1
-#pragma	varargck	argpos	snprint		3
-#pragma	varargck	argpos	sprint		2
-
-#pragma	varargck	type	"lld"	vlong
-#pragma	varargck	type	"llo"	vlong
-#pragma	varargck	type	"llx"	vlong
-#pragma	varargck	type	"llb"	vlong
-#pragma	varargck	type	"lld"	uvlong
-#pragma	varargck	type	"llo"	uvlong
-#pragma	varargck	type	"llx"	uvlong
-#pragma	varargck	type	"llb"	uvlong
-#pragma	varargck	type	"ld"	long
-#pragma	varargck	type	"lo"	long
-#pragma	varargck	type	"lx"	long
-#pragma	varargck	type	"lb"	long
-#pragma	varargck	type	"ld"	ulong
-#pragma	varargck	type	"lo"	ulong
-#pragma	varargck	type	"lx"	ulong
-#pragma	varargck	type	"lb"	ulong
-#pragma	varargck	type	"d"	int
-#pragma	varargck	type	"o"	int
-#pragma	varargck	type	"x"	int
-#pragma	varargck	type	"c"	int
-#pragma	varargck	type	"C"	int
-#pragma	varargck	type	"b"	int
-#pragma	varargck	type	"d"	uint
-#pragma	varargck	type	"x"	uint
-#pragma	varargck	type	"c"	uint
-#pragma	varargck	type	"C"	uint
-#pragma	varargck	type	"b"	uint
-#pragma	varargck	type	"f"	double
-#pragma	varargck	type	"e"	double
-#pragma	varargck	type	"g"	double
-#pragma	varargck	type	"s"	char*
-#pragma	varargck	type	"q"	char*
-#pragma	varargck	type	"S"	Rune*
-#pragma	varargck	type	"Q"	Rune*
-#pragma	varargck	type	"r"	void
-#pragma	varargck	type	"%"	void
-#pragma	varargck	type	"n"	int*
-#pragma	varargck	type	"p"	uintptr
-#pragma	varargck	type	"p"	void*
-#pragma	varargck	flag	','
-#pragma	varargck	flag	' '
-#pragma	varargck	flag	'h'
-#pragma	varargck	type	"<"	void*
-#pragma	varargck	type	"["	void*
-#pragma	varargck	type	"H"	void*
-#pragma	varargck	type	"lH"	void*

include/plan9/libc.h

@@ -2,10 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+#include "/sys/include/libc.h"
 #include "/sys/include/ctype.h"
-#include "fmt.h"
-#include "utf.h"
-#include "libc_plan9.h"
 
 char*	getgoos(void);
 char*	getgoarch(void);
@@ -28,6 +26,3 @@ void	flagprint(int);
 // The libraries use size_t to avoid -Wconversion warnings from GCC
 // when calling standard library functions like memcpy.
 typedef unsigned long size_t;
-
-// math.h
-#define HUGE_VAL 1.79769313486231e+308

include/plan9/mach.h

@@ -1,5 +1,5 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2012 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.
 
-#include "../utf.h"
+#include "../mach.h"

include/plan9/mklibc.rc

@@ -1,8 +0,0 @@
-#!/bin/rc
-
-pattern='/umuldiv/d
-	/rune routines/,/^\/\*/d
-	/print routines/,/^\/\*/d
-	/error string for/,/^\/\*/d'
-
-sed -e $pattern /sys/include/libc.h | awk '/^enum/ && !n++, /^};/ {next}1'

include/plan9/stdarg.h

@@ -1,3 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.

include/plan9/ureg_amd64.h

@@ -1,7 +1,5 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2012 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.
 
-int errno;
-
-#define ERANGE 1001
+#include "/amd64/include/ureg.h"

include/plan9/ureg_arm.h

@@ -1,5 +1,5 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
+// Copyright 2012 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.
 
-#include "abs_amd64.s"
+#include "/arm/include/ureg.h"

include/plan9/ureg_x86.h

@@ -1,7 +1,5 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
+// Copyright 2012 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.
 
-void foo()
-{
-}
+#include "/386/include/ureg.h"

include/u.h

@@ -40,7 +40,6 @@ extern "C" {
 #endif
 #define _BSD_SOURCE 1
 #define _NETBSD_SOURCE 1	/* NetBSD */
-#define _DEFAULT_SOURCE 1	/* glibc > 2.19 */
 #define _SVID_SOURCE 1
 #if !defined(__APPLE__) && !defined(__OpenBSD__)
 #	define _XOPEN_SOURCE 1000
@@ -189,8 +188,6 @@ typedef u32int uint32;
 typedef s64int int64;
 typedef u64int uint64;
 
-typedef float float32;
-typedef double float64;
 
 #undef _NEEDUCHAR
 #undef _NEEDUSHORT

include/ureg_amd64.h

@@ -1,12 +1,11 @@
-// cmd/9c/list.c from Vita Nuova.
+// Inferno utils/libmach/ureg6.h
+// http://code.google.com/p/inferno-os/source/browse/utils/libmach/ureg6.h
 //
-//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
-//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
-//	Portions Copyright © 1997-1999 Vita Nuova Limited
-//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
-//	Portions Copyright © 2004,2006 Bruce Ellis
-//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Copyright © 1994-1999 Lucent Technologies Inc.
+//	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
+//	Portions Copyright © 1997-1999 Vita Nuova Limited.
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
+//	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
 //	Portions Copyright © 2009 The Go Authors.  All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -27,11 +26,33 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#define EXTERN
-#include "gc.h"
+struct Ureg {
+	u64int	ax;
+	u64int	bx;
+	u64int	cx;
+	u64int	dx;
+	u64int	si;
+	u64int	di;
+	u64int	bp;
+	u64int	r8;
+	u64int	r9;
+	u64int	r10;
+	u64int	r11;
+	u64int	r12;
+	u64int	r13;
+	u64int	r14;
+	u64int	r15;
 
-void
-listinit(void)
-{
-	listinit9();
-}
+	u16int	ds;
+	u16int	es;
+	u16int	fs;
+	u16int	gs;
+
+	u64int	type;
+	u64int	error;		/* error code (or zero) */
+	u64int	ip;		/* pc */
+	u64int	cs;		/* old context */
+	u64int	flags;		/* old flags */
+	u64int	sp;		/* sp */
+	u64int	ss;		/* old stack segment */
+};

include/ureg_arm.h

@@ -1,13 +1,11 @@
-// Inferno utils/5l/list.h
-// http://code.google.com/p/inferno-os/source/browse/utils/5l/list.c
+// Inferno utils/libmach/ureg5.h
+// http://code.google.com/p/inferno-os/source/browse/utils/libmach/ureg5.h
 //
-//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
-//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
-//	Portions Copyright © 1997-1999 Vita Nuova Limited
-//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
-//	Portions Copyright © 2004,2006 Bruce Ellis
-//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Copyright © 1994-1999 Lucent Technologies Inc.
+//	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
+//	Portions Copyright © 1997-1999 Vita Nuova Limited.
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
+//	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
 //	Portions Copyright © 2009 The Go Authors.  All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -28,13 +26,24 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-// Printing.
-
-#include "l.h"
-#include "../ld/lib.h"
-
-void
-listinit(void)
-{
-	listinit9();
-}
+struct Ureg {
+	uint	r0;
+	uint	r1;
+	uint	r2;
+	uint	r3;
+	uint	r4;
+	uint	r5;
+	uint	r6;
+	uint	r7;
+	uint	r8;
+	uint	r9;
+	uint	r10;
+	uint	r11;
+	uint	r12;
+	uint	r13;
+	uint	r14;
+	uint	link;
+	uint	type;
+	uint	psr;
+	uint	pc;
+};

include/ureg_x86.h

@@ -0,0 +1,53 @@
+// Inferno utils/libmach/ureg8.h
+// http://code.google.com/p/inferno-os/source/browse/utils/libmach/ureg8.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.
+//	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
+//	Portions Copyright © 1997-1999 Vita Nuova Limited.
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
+//	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
+//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+struct Ureg
+{
+	uint32	di;		/* general registers */
+	uint32	si;		/* ... */
+	uint32	bp;		/* ... */
+	uint32	nsp;
+	uint32	bx;		/* ... */
+	uint32	dx;		/* ... */
+	uint32	cx;		/* ... */
+	uint32	ax;		/* ... */
+	uint32	gs;		/* data segments */
+	uint32	fs;		/* ... */
+	uint32	es;		/* ... */
+	uint32	ds;		/* ... */
+	uint32	trap;		/* trap type */
+	uint32	ecode;		/* error code (or zero) */
+	uint32	pc;		/* pc */
+	uint32	cs;		/* old context */
+	uint32	flags;		/* old flags */
+	union {
+		uint32	usp;
+		uint32	sp;
+	};
+	uint32	ss;		/* old stack segment */
+};

lib/codereview/codereview.cfg

@@ -1,2 +1 @@
-defaultcc: golang-codereviews@googlegroups.com
-contributors: http://go.googlecode.com/hg/CONTRIBUTORS
+defaultcc: golang-dev@googlegroups.com

lib/codereview/codereview.py

@@ -75,7 +75,6 @@ real_rollback = None
 releaseBranch = None
 server = "codereview.appspot.com"
 server_url_base = None
-testing = None
 
 #######################################################################
 # Normally I would split this into multiple files, but it simplifies
@@ -278,7 +277,7 @@ class CL(object):
 			s += "\tAuthor: " + cl.copied_from + "\n"
 		if not quick:
 			s += "\tReviewer: " + JoinComma(cl.reviewer) + "\n"
-			for (who, line, _) in cl.lgtm:
+			for (who, line) in cl.lgtm:
 				s += "\t\t" + who + ": " + line + "\n"
 			s += "\tCC: " + JoinComma(cl.cc) + "\n"
 		s += "\tFiles:\n"
@@ -307,14 +306,14 @@ class CL(object):
 		dir = CodeReviewDir(ui, repo)
 		os.unlink(dir + "/cl." + self.name)
 
-	def Subject(self, ui, repo):
+	def Subject(self):
 		s = line1(self.desc)
 		if len(s) > 60:
 			s = s[0:55] + "..."
 		if self.name != "new":
 			s = "code review %s: %s" % (self.name, s)
 		typecheck(s, str)
-		return branch_prefix(ui, repo) + s
+		return s
 
 	def Upload(self, ui, repo, send_mail=False, gofmt=True, gofmt_just_warn=False, creating=False, quiet=False):
 		if not self.files and not creating:
@@ -323,7 +322,6 @@ class CL(object):
 			CheckFormat(ui, repo, self.files, just_warn=gofmt_just_warn)
 		set_status("uploading CL metadata + diffs")
 		os.chdir(repo.root)
-
 		form_fields = [
 			("content_upload", "1"),
 			("reviewers", JoinComma(self.reviewer)),
@@ -359,8 +357,7 @@ class CL(object):
 			form_fields.append(("subject", "diff -r " + vcs.base_rev + " " + ui.expandpath("default")))
 		else:
 			# First upload sets the subject for the CL itself.
-			form_fields.append(("subject", self.Subject(ui, repo)))
-		
+			form_fields.append(("subject", self.Subject()))
 		ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
 		response_body = MySend("/upload", body, content_type=ctype)
 		patchset = None
@@ -370,8 +367,6 @@ class CL(object):
 			msg = lines[0]
 			patchset = lines[1].strip()
 			patches = [x.split(" ", 1) for x in lines[2:]]
-		else:
-			print >>sys.stderr, "Server says there is nothing to upload (probably wrong):\n" + msg
 		if response_body.startswith("Issue updated.") and quiet:
 			pass
 		else:
@@ -389,8 +384,6 @@ class CL(object):
 		if vcs:
 			set_status("uploading base files")
 			vcs.UploadBaseFiles(issue, rpc, patches, patchset, upload_options, files)
-		if patchset != "1":
-			MySend("/" + issue + "/upload_complete/" + patchset, payload="")
 		if send_mail:
 			set_status("sending mail")
 			MySend("/" + issue + "/mail", payload="")
@@ -407,15 +400,11 @@ class CL(object):
 		pmsg += "\n"
 		repourl = ui.expandpath("default")
 		if not self.mailed:
-			pmsg += "I'd like you to review this change to"
-			branch = repo[None].branch()
-			if branch.startswith("dev."):
-				pmsg += " the " + branch + " branch of"
-			pmsg += "\n" + repourl + "\n"
+			pmsg += "I'd like you to review this change to\n" + repourl + "\n"
 		else:
 			pmsg += "Please take another look.\n"
 		typecheck(pmsg, str)
-		PostMessage(ui, self.name, pmsg, subject=self.Subject(ui, repo))
+		PostMessage(ui, self.name, pmsg, subject=self.Subject())
 		self.mailed = True
 		self.Flush(ui, repo)
 
@@ -504,15 +493,9 @@ def CutDomain(s):
 	return s
 
 def JoinComma(l):
-	seen = {}
-	uniq = []
 	for s in l:
 		typecheck(s, str)
-		if s not in seen:
-			seen[s] = True
-			uniq.append(s)
-			
-	return ", ".join(uniq)
+	return ", ".join(l)
 
 def ExceptionDetail():
 	s = str(sys.exc_info()[0])
@@ -573,7 +556,7 @@ def LoadCL(ui, repo, name, web=True):
 			if m.get('approval', False) == True or m.get('disapproval', False) == True:
 				who = re.sub('@.*', '', m.get('sender', ''))
 				text = re.sub("\n(.|\n)*", '', m.get('text', ''))
-				cl.lgtm.append((who, text, m.get('approval', False)))
+				cl.lgtm.append((who, text))
 
 	set_status("loaded CL " + name)
 	return cl, ''
@@ -855,7 +838,7 @@ def CommandLineCL(ui, repo, pats, opts, op="verb", defaultcc=None):
 		cl.reviewer = Add(cl.reviewer, SplitCommaSpace(opts.get('reviewer')))
 	if opts.get('cc'):
 		cl.cc = Add(cl.cc, SplitCommaSpace(opts.get('cc')))
-	if defaultcc and not cl.private:
+	if defaultcc:
 		cl.cc = Add(cl.cc, defaultcc)
 	if cl.name == "new":
 		if opts.get('message'):
@@ -1341,7 +1324,7 @@ def change(ui, repo, *pats, **opts):
 	else:
 		name = "new"
 		cl = CL("new")
-		if not workbranch(repo[None].branch()):
+		if repo[None].branch() != "default":
 			raise hg_util.Abort("cannot create CL outside default branch; switch with 'hg update default'")
 		dirty[cl] = True
 		files = ChangedFiles(ui, repo, pats, taken=Taken(ui, repo))
@@ -1442,7 +1425,7 @@ def clpatch(ui, repo, clname, **opts):
 	Submitting an imported patch will keep the original author's
 	name as the Author: line but add your own name to a Committer: line.
 	"""
-	if not workbranch(repo[None].branch()):
+	if repo[None].branch() != "default":
 		raise hg_util.Abort("cannot run hg clpatch outside default branch")
 	err = clpatch_or_undo(ui, repo, clname, opts, mode="clpatch")
 	if err:
@@ -1456,7 +1439,7 @@ def undo(ui, repo, clname, **opts):
 	After creating the CL, opens the CL text for editing so that
 	you can add the reason for the undo to the description.
 	"""
-	if not workbranch(repo[None].branch()):
+	if repo[None].branch() != "default":
 		raise hg_util.Abort("cannot run hg undo outside default branch")
 	err = clpatch_or_undo(ui, repo, clname, opts, mode="undo")
 	if err:
@@ -1854,7 +1837,7 @@ def mail(ui, repo, *pats, **opts):
 		# This makes sure that it appears in the 
 		# codereview.appspot.com/user/defaultcc
 		# page, so that it doesn't get dropped on the floor.
-		if not defaultcc or cl.private:
+		if not defaultcc:
 			raise hg_util.Abort("no reviewers listed in CL")
 		cl.cc = Sub(cl.cc, defaultcc)
 		cl.reviewer = defaultcc
@@ -1918,13 +1901,6 @@ def pending(ui, repo, *pats, **opts):
 def need_sync():
 	raise hg_util.Abort("local repository out of date; must sync before submit")
 
-def branch_prefix(ui, repo):
-	prefix = ""
-	branch = repo[None].branch()
-	if branch.startswith("dev."):
-		prefix = "[" + branch + "] "
-	return prefix
-
 @hgcommand
 def submit(ui, repo, *pats, **opts):
 	"""submit change to remote repository
@@ -1952,25 +1928,16 @@ def submit(ui, repo, *pats, **opts):
 	typecheck(userline, str)
 
 	about = ""
-
-	if not cl.lgtm and not opts.get('tbr') and needLGTM(cl):
-		raise hg_util.Abort("this CL has not been LGTM'ed")
-	if cl.lgtm:
-		about += "LGTM=" + JoinComma([CutDomain(who) for (who, line, approval) in cl.lgtm if approval]) + "\n"
-	reviewer = cl.reviewer
+	if cl.reviewer:
+		about += "R=" + JoinComma([CutDomain(s) for s in cl.reviewer]) + "\n"
 	if opts.get('tbr'):
 		tbr = SplitCommaSpace(opts.get('tbr'))
-		for name in tbr:
-			if name.startswith('golang-'):
-				raise hg_util.Abort("--tbr requires a person, not a mailing list")
 		cl.reviewer = Add(cl.reviewer, tbr)
 		about += "TBR=" + JoinComma([CutDomain(s) for s in tbr]) + "\n"
-	if reviewer:
-		about += "R=" + JoinComma([CutDomain(s) for s in reviewer]) + "\n"
 	if cl.cc:
 		about += "CC=" + JoinComma([CutDomain(s) for s in cl.cc]) + "\n"
 
-	if not cl.reviewer and needLGTM(cl):
+	if not cl.reviewer:
 		raise hg_util.Abort("no reviewers listed in CL")
 
 	if not cl.local:
@@ -1994,7 +1961,7 @@ def submit(ui, repo, *pats, **opts):
 		cl.Mail(ui, repo)
 
 	# submit changes locally
-	message = branch_prefix(ui, repo) + cl.desc.rstrip() + "\n\n" + about
+	message = cl.desc.rstrip() + "\n\n" + about
 	typecheck(message, str)
 
 	set_status("pushing " + cl.name + " to remote server")
@@ -2004,22 +1971,12 @@ def submit(ui, repo, *pats, **opts):
 	
 	old_heads = len(hg_heads(ui, repo).split())
 
-	# Normally we commit listing the specific files in the CL.
-	# If there are no changed files other than those in the CL, however,
-	# let hg build the list, because then committing a merge works.
-	# (You cannot name files for a merge commit, even if you name
-	# all the files that would be committed by not naming any.)
-	files = ['path:'+f for f in cl.files]
-	if ChangedFiles(ui, repo, []) == cl.files:
-		files = []
-
 	global commit_okay
 	commit_okay = True
-	ret = hg_commit(ui, repo, *files, message=message, user=userline)
+	ret = hg_commit(ui, repo, *['path:'+f for f in cl.files], message=message, user=userline)
 	commit_okay = False
 	if ret:
 		raise hg_util.Abort("nothing changed")
-
 	node = repo["-1"].node()
 	# push to remote; if it fails for any reason, roll back
 	try:
@@ -2078,21 +2035,6 @@ def submit(ui, repo, *pats, **opts):
 			return err
 	return 0
 
-def needLGTM(cl):
-	rev = cl.reviewer
-	isGobot = 'gobot' in rev or 'gobot@swtch.com' in rev or 'gobot@golang.org' in rev
-	
-	# A+C CLs generated by addca do not need LGTM
-	if cl.desc.startswith('A+C:') and 'Generated by a+c.' in cl.desc and isGobot:
-		return False
-	
-	# CLs modifying only go1.x.txt do not need LGTM
-	if len(cl.files) == 1 and cl.files[0].startswith('doc/go1.') and cl.files[0].endswith('.txt'):
-		return False
-	
-	# Other CLs need LGTM
-	return True
-
 #######################################################################
 # hg sync
 
@@ -2311,14 +2253,6 @@ def norollback(*pats, **opts):
 
 codereview_init = False
 
-def uisetup(ui):
-	global testing
-	testing = ui.config("codereview", "testing")
-	# Disable the Mercurial commands that might change the repository.
-	# Only commands in this extension are supposed to do that.
-	ui.setconfig("hooks", "pre-commit.codereview", precommithook) # runs before 'hg commit'
-	ui.setconfig("hooks", "precommit.codereview", precommithook) # catches all cases
-
 def reposetup(ui, repo):
 	global codereview_disabled
 	global defaultcc
@@ -2361,12 +2295,16 @@ def reposetup(ui, repo):
 		return
 
 	remote = ui.config("paths", "default", "")
-	if remote.find("://") < 0 and not testing:
+	if remote.find("://") < 0:
 		raise hg_util.Abort("codereview: default path '%s' is not a URL" % (remote,))
 
 	InstallMatch(ui, repo)
 	RietveldSetup(ui, repo)
 
+	# Disable the Mercurial commands that might change the repository.
+	# Only commands in this extension are supposed to do that.
+	ui.setconfig("hooks", "precommit.codereview", precommithook)
+
 	# Rollback removes an existing commit.  Don't do that either.
 	global real_rollback
 	real_rollback = repo.rollback
@@ -2464,10 +2402,7 @@ def IsRietveldSubmitted(ui, clname, hex):
 		return False
 	for msg in dict.get("messages", []):
 		text = msg.get("text", "")
-		regex = '\*\*\* Submitted as [^*]*?r=([0-9a-f]+)[^ ]* \*\*\*'
-		if testing:
-			regex = '\*\*\* Submitted as ([0-9a-f]+) \*\*\*'
-		m = re.match(regex, text)
+		m = re.match('\*\*\* Submitted as [^*]*?r=([0-9a-f]+)[^ ]* \*\*\*', text)
 		if m is not None and len(m.group(1)) >= 8 and hex.startswith(m.group(1)):
 			return True
 	return False
@@ -2572,8 +2507,6 @@ def MySend1(request_path, payload=None,
 			tries += 1
 			args = dict(kwargs)
 			url = "https://%s%s" % (self.host, request_path)
-			if testing:
-				url = url.replace("https://", "http://")
 			if args:
 				url += "?" + urllib.urlencode(args)
 			req = self._CreateRequest(url=url, data=payload)
@@ -2686,9 +2619,8 @@ def RietveldSetup(ui, repo):
 		email = x
 
 	server_url_base = "https://" + server + "/"
-	if testing:
-		server_url_base = server_url_base.replace("https://", "http://")
 
+	testing = ui.config("codereview", "testing")
 	force_google_account = ui.configbool("codereview", "force_google_account", False)
 
 	upload_options = opt()
@@ -2702,6 +2634,7 @@ def RietveldSetup(ui, repo):
 	upload_options.message = None
 	upload_options.issue = None
 	upload_options.download_base = False
+	upload_options.revision = None
 	upload_options.send_mail = False
 	upload_options.vcs = None
 	upload_options.server = server
@@ -2714,7 +2647,7 @@ def RietveldSetup(ui, repo):
 	rpc = None
 	
 	global releaseBranch
-	tags = repo.branchmap().keys()
+	tags = repo.branchtags().keys()
 	if 'release-branch.go10' in tags:
 		# NOTE(rsc): This tags.sort is going to get the wrong
 		# answer when comparing release-branch.go9 with
@@ -2725,9 +2658,6 @@ def RietveldSetup(ui, repo):
 		if t.startswith('release-branch.go'):
 			releaseBranch = t			
 
-def workbranch(name):
-	return name == "default" or name.startswith('dev.')
-
 #######################################################################
 # http://codereview.appspot.com/static/upload.py, heavily edited.
 
@@ -2968,10 +2898,7 @@ class AbstractRpcServer(object):
 		# This is a dummy value to allow us to identify when we're successful.
 		continue_location = "http://localhost/"
 		args = {"continue": continue_location, "auth": auth_token}
-		reqUrl = "https://%s/_ah/login?%s" % (self.host, urllib.urlencode(args))
-		if testing:
-			reqUrl = reqUrl.replace("https://", "http://")
-		req = self._CreateRequest(reqUrl)
+		req = self._CreateRequest("https://%s/_ah/login?%s" % (self.host, urllib.urlencode(args)))
 		try:
 			response = self.opener.open(req)
 		except urllib2.HTTPError, e:
@@ -3062,8 +2989,6 @@ class AbstractRpcServer(object):
 				tries += 1
 				args = dict(kwargs)
 				url = "https://%s%s" % (self.host, request_path)
-				if testing:
-					url = url.replace("https://", "http://")
 				if args:
 					url += "?" + urllib.urlencode(args)
 				req = self._CreateRequest(url=url, data=payload)
@@ -3488,28 +3413,18 @@ class MercurialVCS(VersionControlSystem):
 		cwd = os.path.normpath(os.getcwd())
 		assert cwd.startswith(self.repo_dir)
 		self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
-		mqparent, err = RunShellWithReturnCode(['hg', 'log', '--rev', 'qparent', '--template={node}'])
-		if not err and mqparent != "":
-			self.base_rev = mqparent
+		if self.options.revision:
+			self.base_rev = self.options.revision
 		else:
-			out = RunShell(["hg", "parents", "-q", "--template={node} {branch}"], silent_ok=True).strip()
-			if not out:
-				# No revisions; use 0 to mean a repository with nothing.
-				out = "0:0 default"
-			
-			# Find parent along current branch.
-			branch = repo[None].branch()
-			base = ""
-			for line in out.splitlines():
-				fields = line.strip().split(' ')
-				if fields[1] == branch:
-					base = fields[0]
-					break
-			if base == "":
-				# Use the first parent
-				base = out.strip().split(' ')[0]
-			self.base_rev = base
-
+			mqparent, err = RunShellWithReturnCode(['hg', 'log', '--rev', 'qparent', '--template={node}'])
+			if not err and mqparent != "":
+				self.base_rev = mqparent
+			else:
+				out = RunShell(["hg", "parents", "-q"], silent_ok=True).strip()
+				if not out:
+					# No revisions; use 0 to mean a repository with nothing.
+					out = "0:0"
+				self.base_rev = out.split(':')[1].strip()
 	def _GetRelPath(self, filename):
 		"""Get relative path of a file according to the current directory,
 		given its logical path in the repo."""
@@ -3603,17 +3518,11 @@ class MercurialVCS(VersionControlSystem):
 			if use_hg_shell:
 				base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath], silent_ok=True)
 			else:
-                                try:
-                                        base_content = str(self.repo[base_rev][oldrelpath].data())
-                                except Exception:
-                                        pass
+				base_content = str(self.repo[base_rev][oldrelpath].data())
 			is_binary = "\0" in base_content  # Mercurial's heuristic
 		if status != "R":
-                        try:
-                                new_content = open(relpath, "rb").read()
-                                is_binary = is_binary or "\0" in new_content
-                        except Exception:
-                                pass
+			new_content = open(relpath, "rb").read()
+			is_binary = is_binary or "\0" in new_content
 		if is_binary and base_content and use_hg_shell:
 			# Fetch again without converting newlines
 			base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath],

lib/codereview/test.sh

@@ -7,7 +7,7 @@
 # Assumes a local Rietveld is running using the App Engine SDK
 # at http://localhost:7777/
 #
-# dev_appserver.py --port 7777 $HOME/pub/rietveld
+# dev_appserver.py -p 7777 $HOME/pub/rietveld
 
 codereview_script=$(pwd)/codereview.py
 server=localhost:7777
@@ -57,7 +57,6 @@ username=Grace R Emlin <gre@golang.org>
 [extensions]
 codereview=$codereview_script
 [codereview]
-testing=true
 server=$server
 " >>$clone1/.hg/hgrc
 cp $clone1/.hg/hgrc $clone2/.hg/hgrc
@@ -79,7 +78,7 @@ echo 'Grace R Emlin <gre@golang.org>' >CONTRIBUTORS
 must hg add lib/codereview/codereview.cfg CONTRIBUTORS
 
 status First submit.
-must hg submit --tbr gre@golang.org -m codereview \
+must hg submit -r gre@golang.org -m codereview \
 	lib/codereview/codereview.cfg CONTRIBUTORS
 
 status Should see change in other client.
@@ -94,8 +93,8 @@ test_clpatch() {
 	# Clpatch will check.
 	
 	cd $clone1
-	# dev_appserver.py used to crash with UTF-8 input.
-	if true; then
+	# Tried to use UTF-8 here to test that, but dev_appserver.py crashes.  Ha ha.
+	if false; then
 		status Using UTF-8.
 		name="Grácè T Emlïn <test@example.com>"
 	else
@@ -104,20 +103,20 @@ test_clpatch() {
 	fi
 	echo "$name" >>CONTRIBUTORS
 	cat .hg/hgrc | sed "s/Grace.*/$name/" >/tmp/x && mv /tmp/x .hg/hgrc
-	echo "
+	echo '
 Reviewer: gre@golang.org
 Description:
 	CONTRIBUTORS: add $name
 Files:
 	CONTRIBUTORS
-"	| must hg change -i
+'	| must hg change -i
 	num=$(hg pending | sed 1q | tr -d :)
 	
 	status Patch CL.
 	cd $clone2
 	must hg clpatch $num
 	must [ "$num" = "$(firstcl)" ]
-	must hg submit --tbr gre@golang.org $num
+	must hg submit $num
 	
 	status Issue should be open with no reviewers.
 	must curl http://$server/api/$num >/tmp/x
@@ -161,7 +160,7 @@ Reviewer: gre@golang.org
 Description: file1
 Files: file1
 	' | must hg change -i
-	must hg submit --tbr gre@golang.org $(firstcl)
+	must hg submit $(firstcl)
 	
 	cd $clone2
 	echo file2 >file2
@@ -171,9 +170,9 @@ Reviewer: gre@golang.org
 Description: file2
 Files: file2
 	' | must hg change -i
-	must not hg submit --tbr gre@golang.org $(firstcl)
+	must not hg submit $(firstcl)
 	must hg sync
-	must hg submit --tbr gre@golang.org $(firstcl)
+	must hg submit $(firstcl)
 }
 
 test_restrict() {

lib/time/update.bash

@@ -6,9 +6,11 @@
 # This script rebuilds the time zone files using files
 # downloaded from the ICANN/IANA distribution.
 
+# NOTE: As of Oct, 2013, the C files will not build on Macs but will build on Linux.
+
 # Versions to use.
-CODE=2014d
-DATA=2014d
+CODE=2013g
+DATA=2013g
 
 set -e
 rm -rf work

misc/IntelliJIDEA/Go.xml

@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    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.
+
+Copy this custom language definition & configuration file to
+        * Mac             : ~/Library/Preferences/IntelliJIdea10/filetypes/
+        * Linux & Windows : ~/.IntelliJIdea10/config/filetypes/
+-->
+
+<filetype binary="false" default_extension="" description="Go" name="Go">
+    <highlighting>
+        <options>
+            <option name="LINE_COMMENT" value="//"/>
+            <option name="COMMENT_START" value="/*"/>
+            <option name="COMMENT_END" value="*/"/>
+            <option name="HEX_PREFIX" value="0x"/>
+            <option name="NUM_POSTFIXES" value=""/>
+            <option name="HAS_BRACKETS" value="true"/>
+            <option name="HAS_BRACES" value="true"/>
+            <option name="HAS_PARENS" value="true"/>
+            <option name="HAS_STRING_ESCAPES" value="true"/>
+        </options>
+        <keywords ignore_case="false">
+            <keyword name="break"/>
+            <keyword name="case"/>
+            <keyword name="chan"/>
+            <keyword name="const"/>
+            <keyword name="continue"/>
+            <keyword name="default"/>
+            <keyword name="defer"/>
+            <keyword name="else"/>
+            <keyword name="fallthrough"/>
+            <keyword name="for"/>
+            <keyword name="func"/>
+            <keyword name="go"/>
+            <keyword name="goto"/>
+            <keyword name="if"/>
+            <keyword name="import"/>
+            <keyword name="interface"/>
+            <keyword name="map"/>
+            <keyword name="package"/>
+            <keyword name="range"/>
+            <keyword name="return"/>
+            <keyword name="select"/>
+            <keyword name="struct"/>
+            <keyword name="switch"/>
+            <keyword name="type"/>
+            <keyword name="var"/>
+        </keywords>
+        <keywords2>
+            <keyword name="bool"/>
+            <keyword name="byte"/>
+            <keyword name="complex64"/>
+            <keyword name="complex128"/>
+            <keyword name="float32"/>
+            <keyword name="float64"/>
+            <keyword name="int"/>
+            <keyword name="int8"/>
+            <keyword name="int16"/>
+            <keyword name="int32"/>
+            <keyword name="int64"/>
+            <keyword name="string"/>
+            <keyword name="uint"/>
+            <keyword name="uint8"/>
+            <keyword name="uint16"/>
+            <keyword name="uint32"/>
+            <keyword name="uint64"/>
+            <keyword name="uintptr"/>
+        </keywords2>
+        <keywords3>
+            <keyword name="append"/>
+            <keyword name="cap"/>
+            <keyword name="close"/>
+            <keyword name="complex"/>
+            <keyword name="copy"/>
+            <keyword name="delete"/>
+            <keyword name="imag"/>
+            <keyword name="len"/>
+            <keyword name="make"/>
+            <keyword name="new"/>
+            <keyword name="panic"/>
+            <keyword name="print"/>
+            <keyword name="println"/>
+            <keyword name="real"/>
+            <keyword name="recover"/>
+        </keywords3>
+        <keywords4>
+            <keyword name="false"/>
+            <keyword name="iota"/>
+            <keyword name="nil"/>
+            <keyword name="true"/>
+        </keywords4>
+    </highlighting>
+    <extensionMap>
+        <mapping ext="go"/>
+    </extensionMap>
+</filetype>

misc/android/README

@@ -1,11 +0,0 @@
-Android
-=======
-
-For details on developing Go for Android, see the documentation in the
-go.mobile subrepository:
-
-	https://code.google.com/p/go/source/browse/README?repo=mobile
-
-To run the standard library tests, see androidtest.bash. Run it as
-
-	CC_FOR_TARGET=.../ndk-gcc GOARCH=arm GOARM=7 ./androidtest.bash

misc/android/go_android_exec.go

@@ -1,96 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This program can be used as go_android_GOARCH_exec by the Go tool.
-// It executes binaries on an android device using adb.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-func run(args ...string) string {
-	buf := new(bytes.Buffer)
-	cmd := exec.Command("adb", args...)
-	cmd.Stdout = io.MultiWriter(os.Stdout, buf)
-	cmd.Stderr = os.Stderr
-	log.Printf("adb %s", strings.Join(args, " "))
-	err := cmd.Run()
-	if err != nil {
-		log.Fatalf("adb %s: %v", strings.Join(args, " "), err)
-	}
-	return buf.String()
-}
-
-func main() {
-	log.SetFlags(0)
-	log.SetPrefix("go_android_exec: ")
-
-	// Determine thepackage by examining the current working
-	// directory, which will look something like
-	// "$GOROOT/src/mime/multipart". We extract everything
-	// after the $GOROOT to run on the same relative directory
-	// on the target device.
-	//
-	// TODO(crawshaw): Pick useful subdir when we are not
-	// inside a GOROOT, e.g. we are in a GOPATH.
-	cwd, err := os.Getwd()
-	if err != nil {
-		log.Fatal(err)
-	}
-	subdir, err := filepath.Rel(runtime.GOROOT(), cwd)
-	if err != nil {
-		log.Fatal(err)
-	}
-	subdir = filepath.ToSlash(subdir)
-
-	// Binary names can conflict.
-	// E.g. template.test from the {html,text}/template packages.
-	binName := filepath.Base(os.Args[1])
-	deviceGoroot := "/data/local/tmp/goroot"
-	deviceBin := fmt.Sprintf("%s/%s-%d", deviceGoroot, binName, os.Getpid())
-
-	// The push of the binary happens in parallel with other tests.
-	// Unfortunately, a simultaneous call to adb shell hold open
-	// file descriptors, so it is necessary to push then move to
-	// avoid a "text file busy" error on execution.
-	// https://code.google.com/p/android/issues/detail?id=65857
-	run("push", os.Args[1], deviceBin+"-tmp")
-	run("shell", "cp '"+deviceBin+"-tmp' '"+deviceBin+"'")
-	run("shell", "rm '"+deviceBin+"-tmp'")
-
-	// The adb shell command will return an exit code of 0 regardless
-	// of the command run. E.g.
-	//	$ adb shell false
-	//	$ echo $?
-	//	0
-	// https://code.google.com/p/android/issues/detail?id=3254
-	// So we append the exitcode to the output and parse it from there.
-	const exitstr = "exitcode="
-	cmd := `export TMPDIR="/data/local/tmp"` +
-		`; export GOROOT="` + deviceGoroot + `"` +
-		`; cd "$GOROOT/` + subdir + `"` +
-		"; '" + deviceBin + "' " + strings.Join(os.Args[2:], " ") +
-		"; echo -n " + exitstr + "$?"
-	output := run("shell", cmd)
-	run("shell", "rm '"+deviceBin+"'") // cleanup
-	output = output[strings.LastIndex(output, "\n")+1:]
-	if !strings.HasPrefix(output, exitstr) {
-		log.Fatalf("no exit code: %q", output)
-	}
-	code, err := strconv.Atoi(output[len(exitstr):])
-	if err != nil {
-		log.Fatalf("bad exit code: %v", err)
-	}
-	os.Exit(code)
-}

misc/bash/go

@@ -0,0 +1,250 @@
+# install in /etc/bash_completion.d/ or your personal directory
+
+complete -f -X '!*.8' 8l
+complete -f -X '!*.6' 6l
+complete -f -X '!*.5' 5l
+complete -f -X '!*.go' 8g 6g 5g gofmt gccgo
+
+_go_importpath()
+{
+  echo "$(compgen -W "$(go list all) all std" -- "$1")"
+}
+
+_go()
+{
+  # TODO: Only allow flags before other arguments. run already does
+  # this.
+
+  local cur=`_get_cword`
+  local prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+  local cmd="${COMP_WORDS[1]}"
+
+  local cmds="build clean doc fix fmt get
+    install list run test tool version vet"
+  local addhelp="gopath importpath remote
+    testflag testfunc"
+  local other="help"
+
+  if [ "$COMP_CWORD" == 1 ]; then
+    for opt in $cmds; do
+      if [[ "$opt" == "$cmd" ]]; then
+        COMPREPLY=("$opt")
+        return
+      fi
+    done
+  fi
+
+  case "$cmd" in
+    'build')
+      case "$prev" in
+        '-o')
+          _filedir
+          ;;
+        '-p')
+          ;;
+        *)
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "-a -n -o -p -v -x" -- "$cur"))
+          else
+            local found=0
+            for ((i=0; i < ${#COMP_WORDS[@]}; i++)); do
+              case "$i" in
+                0|1|"$COMP_CWORD")
+                  continue
+                  ;;
+              esac
+              local opt="${COMP_WORDS[i]}"
+              if [[ "$opt" != -* ]]; then
+                if [[ "$opt" == *.go && -f "$opt" ]]; then
+                  found=1
+                  break
+                else
+                  found=2
+                  break
+                fi
+              fi
+            done
+            case "$found" in
+              0)
+                _filedir go
+                COMPREPLY+=(`_go_importpath "$cur"`)
+                ;;
+              1)
+                _filedir go
+                ;;
+              2)
+                COMPREPLY=(`_go_importpath "$cur"`)
+                ;;
+            esac
+          fi
+          ;;
+      esac
+      ;;
+    'clean')
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=($(compgen -W "-i -r -n -x" -- "$cur"))
+      else
+        COMPREPLY=(`_go_importpath "$cur"`)
+      fi
+      ;;
+    'doc')
+      COMPREPLY=(`_go_importpath "$cur"`)
+      ;;
+    'fix')
+      COMPREPLY=(`_go_importpath "$cur"`)
+      ;;
+    'fmt')
+      COMPREPLY=(`_go_importpath "$cur"`)
+      ;;
+    'get')
+      case "$prev" in
+        '-p')
+          ;;
+        *)
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "-a -d -fix -n -p -u -v -x" -- "$cur"))
+          else
+            COMPREPLY=(`_go_importpath "$cur"`)
+          fi
+          ;;
+      esac
+      ;;
+    'install')
+      case "$prev" in
+        '-p')
+          ;;
+        *)
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "-a -n -p -v -x" -- "$cur"))
+          else
+            COMPREPLY=(`_go_importpath "$cur"`)
+          fi
+          ;;
+      esac
+      ;;
+    'list')
+      case "$prev" in
+        '-f')
+          ;;
+        *)
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "-e -f -json" -- "$cur"))
+          else
+            COMPREPLY=(`_go_importpath "$cur"`)
+          fi
+          ;;
+      esac
+      ;;
+    'run')
+      if [[ "$cur" == -* && "$prev" != *.go ]]; then
+        COMPREPLY=($(compgen -W "-a -n -x" -- "$cur"))
+      else
+        _filedir
+      fi
+      ;;
+    'test') # TODO: Support for testflags.
+      case "$prev" in
+        '-file')
+          _filedir go
+          ;;
+        '-p')
+          ;;
+        *)
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "-c -file -i -p -x" -- "$cur"))
+          else
+            COMPREPLY=(`_go_importpath "$cur"`)
+          fi
+          ;;
+        esac
+      ;;
+    'tool')
+      if [ "$COMP_CWORD" == 2 ]; then
+        COMPREPLY=($(compgen -W "$(go tool)" -- "$cur"))
+      else
+        case "${COMP_WORDS[2]}" in
+          [568]a) # TODO: Implement something.
+            #_go_tool_568a
+            ;;
+          [568]c) # TODO: Implement something.
+            #_go_tool_568c
+            ;;
+          [568]g) # TODO: Implement something.
+            #_go_tool_568g
+            ;;
+          [568]l) # TODO: Implement something.
+            #_go_tool_568l
+            ;;
+          'api') # TODO: Implement something.
+            #_go_tool_api
+            ;;
+          'cgo') # TODO: Implement something.
+            #_go_tool_cgo
+            ;;
+          'cov') # TODO: Implement something.
+            #_go_tool_cov
+            ;;
+          'dist') # TODO: Implement something.
+            #_go_tool_dist
+            ;;
+          'ebnflint') # TODO: Implement something.
+            #_go_tool_ebnflint
+            ;;
+          'fix') # TODO: Implement something.
+            #_go_tool_fix
+            ;;
+          'gotype') # TODO: Implement something.
+            #_go_tool_gotype
+            ;;
+          'nm') # TODO: Implement something.
+            #_go_tool_nm
+            ;;
+          'pack') # TODO: Implement something.
+            #_go_tool_pack
+            ;;
+          'pprof') # TODO: Implement something.
+            #_go_tool_pprof
+            ;;
+          'prof') # TODO: Implement something.
+            #_go_tool_prof
+            ;;
+          'vet') # TODO: Implement something.
+            #_go_tool_vet
+            ;;
+          'yacc') # TODO: Implement something.
+            #_go_tool_yacc
+            ;;
+        esac
+        if [[ "$cur" == -* ]]; then
+          COMPREPLY=($(compgen -W "${COMPREPLY[*]} -h" -- "$cur"))
+        fi
+      fi
+      ;;
+    'version')
+      ;;
+    'vet')
+      if [[ "$cur" == -* ]]; then
+        :
+      else
+        COMPREPLY=(`_go_importpath "$cur"`)
+      fi
+      ;;
+    'help')
+      if [ "$COMP_CWORD" == 2 ]; then
+        COMPREPLY=($(compgen -W "$cmds $addhelp" -- "$cur"))
+      fi
+      ;;
+    *)
+      if [ "$COMP_CWORD" == 1 ]; then
+        COMPREPLY=($(compgen -W "$cmds $other" -- "$cur"))
+      else
+        _filedir
+      fi
+      ;;
+  esac
+}
+
+complete $filenames -F _go go
+
+# vim:ts=2 sw=2 et syn=sh

misc/bbedit/Go.plist

@@ -0,0 +1,104 @@
+// Copyright 2009 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.
+{
+	BBEditDocumentType = "CodelessLanguageModule";
+	BBLMColorsSyntax = YES;
+	BBLMIsCaseSensitive = YES;
+	BBLMKeywordList = (
+		append,
+		bool,
+		break,
+		byte,
+		cap,
+		case,
+		chan,
+		close,
+		complex,
+		complex128,
+		complex64,
+		const,
+		continue,
+		copy,
+		default,
+		defer,
+		delete,
+		else,
+		error,
+		fallthrough,
+		false,
+		float32,
+		float64,
+		for,
+		func,         
+		go,
+		goto,
+		if,
+		iota,
+		imag,
+		import,
+		int,
+		int16,
+		int32,
+		int64,
+		int8,
+		interface,
+		len,
+		make,
+		map,
+		new,
+		nil,
+		package,
+		panic,
+		print,
+		println,
+		range,
+		real,
+		recover,
+		return,
+		rune,
+		select,
+		string,
+		struct,
+		switch,
+		true,
+		type,
+		uint,
+		uint16,
+		uint32,
+		uint64,
+		uint8,
+		uintptr,
+		var,
+	);
+	BBLMLanguageCode = go;
+	"BBLMLanguageDisplayName" = "Go";
+	BBLMScansFunctions = YES;
+	BBLMSuffixMap = (
+		{
+			BBLMLanguageSuffix = ".go";
+		},
+	);
+	"Language Features" = {
+		"Close Block Comments" = "*/";
+		"Close Parameter Lists" = ")";
+		"Close Statement Blocks" = "}";
+		"Close Strings 1" = "`";
+		"Close Strings 2" = "\"";
+		"End-of-line Ends Strings 1" = YES;
+		"End-of-line Ends Strings 2" = YES;
+		"Escape Char in Strings 1" = "\\";
+		"Escape Char in Strings 2" = "\\";
+		"Identifier and Keyword Characters" = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+		"Open Block Comments" = "/*";
+		"Open Line Comments" = "//";
+		"Open Parameter Lists" = "(";
+		"Open Statement Blocks" = "{";
+		"Open Strings 1" = "`";
+		"Open Strings 2" = "\"";
+		"Prefix for Functions" = "func";
+		"Prefix for Procedures" = "func";
+		"Terminator for Prototypes 1" = ";";
+		"Terminator for Prototypes 2" = "";
+	};
+}

misc/benchcmp

@@ -1,5 +1,124 @@
-#!/bin/bash
+#!/bin/sh
+# 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.
 
-echo 'misc/benchcmp has moved:' >&2
-echo '	go get -u code.google.com/p/go.tools/cmd/benchcmp' >&2
-exit 2
+case "$1" in
+-*)	
+	echo 'usage: benchcmp old.txt new.txt' >&2
+	echo >&2
+	echo 'Each input file should be from:' >&2
+	echo '	go test -test.run=NONE -test.bench=. > [old,new].txt' >&2
+	echo >&2
+	echo 'Benchcmp compares the first and last for each benchmark.' >&2
+	echo >&2
+	echo 'If -test.benchmem=true is added to the "go test" command' >&2
+	echo 'benchcmp will also compare memory allocations.' >&2
+	exit 2
+esac
+
+awk '
+BEGIN {
+	n = 0
+}
+
+$1 ~ /Benchmark/ && $4 == "ns/op" {
+	if(old[$1]) {
+		if(!saw[$1]++) {
+			name[n++] = $1
+			if(length($1) > len)
+				len = length($1)
+		}
+		new[$1] = $3
+		if($6 == "MB/s")
+			newmb[$1] = $5
+
+		# allocs/op might be at $8 or $10 depending on if
+		# SetBytes was used or not.
+		# B/op might be at $6 or $8, it should be immediately
+		# followed by allocs/op
+		if($8 == "allocs/op") {
+			newbytes[$1] = $5
+			newalloc[$1] = $7
+		}
+		if($10 == "allocs/op") {
+			newbytes[$1] = $7
+			newalloc[$1] = $9
+		}
+	} else {
+		old[$1] = $3
+		if($6 == "MB/s")
+			oldmb[$1] = $5
+		if($8 == "allocs/op") {
+			oldbytes[$1] = $5
+			oldalloc[$1] = $7
+		}
+		if($10 == "allocs/op") {
+			oldbytes[$1] = $7
+			oldalloc[$1] = $9
+		}
+	}
+}
+
+END {
+	if(n == 0) {
+		print "benchcmp: no repeated benchmarks" >"/dev/stderr"
+		exit 1
+	}
+
+	printf("%-*s %12s %12s  %7s\n", len, "benchmark", "old ns/op", "new ns/op", "delta")
+
+	# print ns/op
+	for(i=0; i<n; i++) {
+		what = name[i]
+		printf("%-*s %12d %12d  %6s%%\n", len, what, old[what], new[what],
+			sprintf("%+.2f", 100*new[what]/old[what]-100))
+	}
+
+	# print mb/s
+	anymb = 0
+	for(i=0; i<n; i++) {
+		what = name[i]
+		if(!(what in newmb))
+			continue
+		if(anymb++ == 0)
+			printf("\n%-*s %12s %12s  %7s\n", len, "benchmark", "old MB/s", "new MB/s", "speedup")
+		printf("%-*s %12s %12s  %6sx\n", len, what,
+			sprintf("%.2f", oldmb[what]),
+			sprintf("%.2f", newmb[what]),
+			sprintf("%.2f", newmb[what]/oldmb[what]))
+	}
+
+	# print allocs
+	anyalloc = 0
+	for(i=0; i<n; i++) {
+		what = name[i]
+		if(!(what in newalloc))
+			continue
+		if(anyalloc++ == 0)
+			printf("\n%-*s %12s %12s  %7s\n", len, "benchmark", "old allocs", "new allocs", "delta")
+		if(oldalloc[what] == 0)
+			delta="n/a"
+		else
+			delta=sprintf("%.2f", 100*newalloc[what]/oldalloc[what]-100)
+		printf("%-*s %12d %12d  %6s%%\n", len, what,
+			oldalloc[what], newalloc[what], delta)
+	}
+
+	# print alloc bytes
+	anybytes = 0
+	for(i=0; i<n; i++) {
+		what = name[i]
+		if(!(what in newbytes))
+			continue
+		if(anybytes++ == 0)
+			printf("\n%-*s %12s %12s  %7s\n", len, "benchmark", "old bytes", "new bytes", "delta")
+		if(oldbytes[what] == 0)
+			delta="n/a"
+		else
+			delta=sprintf("%.2f", 100*newbytes[what]/oldbytes[what]-100)
+		printf("%-*s %12d %12d  %6s%%\n", len, what,
+			oldbytes[what], newbytes[what], delta)
+	}
+}
+' "$@"

misc/cgo/errors/err3.go

@@ -1,18 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-typedef struct foo foo_t;
-typedef struct bar bar_t;
-
-foo_t *foop;
-*/
-import "C"
-
-func main() {
-	x := (*C.bar_t)(nil)
-	C.foop = x // ERROR HERE
-}

misc/cgo/errors/issue7757.go

@@ -1,14 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-void foo() {}
-*/
-import "C"
-
-func main() {
-	C.foo = C.foo // ERROR HERE
-}

misc/cgo/errors/issue8442.go

@@ -1,17 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// Issue 8442.  Cgo output unhelpful error messages for
-// invalid C preambles.
-
-/*
-void issue8442foo(UNDEF*); // ERROR HERE
-*/
-import "C"
-
-func main() {
-	C.issue8442foo(nil)
-}

misc/cgo/errors/test.bash

@@ -26,9 +26,6 @@ check() {
 
 check err1.go
 check err2.go
-check err3.go
-check issue7757.go
-check issue8442.go
 
 rm -rf errs _obj
 exit 0

misc/cgo/nocgo/nocgo.go

@@ -1,22 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test that -static works when not using cgo.  This test is in
-// misc/cgo to take advantage of the testing framework support for
-// when -static is expected to work.
-
-package nocgo
-
-func NoCgo() int {
-	c := make(chan int)
-
-	// The test is run with external linking, which means that
-	// goroutines will be created via the runtime/cgo package.
-	// Make sure that works.
-	go func() {
-		c <- 42
-	}()
-
-	return <-c
-}

misc/cgo/nocgo/nocgo_test.go

@@ -1,14 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package nocgo
-
-import "testing"
-
-func TestNop(t *testing.T) {
-	i := NoCgo()
-	if i != 42 {
-		t.Errorf("got %d, want %d", i, 42)
-	}
-}

misc/cgo/test/backdoor/backdoor.go

@@ -4,4 +4,4 @@
 
 package backdoor
 
-func LockedOSThread() bool // in thunk.s
+func LockedOSThread() bool // in runtime.c

misc/cgo/test/backdoor/runtime.c

@@ -0,0 +1,25 @@
+// 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.
+
+// Expose some runtime functions for testing.
+// Must be in a non-cgo-using package so that
+// the go command compiles this file with 6c, not gcc.
+
+// +build gc
+
+typedef char bool;
+
+bool runtime·lockedOSThread(void);
+
+static void
+FLUSH(void*)
+{
+}
+
+void
+·LockedOSThread(bool b)
+{
+	b = runtime·lockedOSThread();
+	FLUSH(&b);
+}

misc/cgo/test/backdoor/thunk.s

@@ -1,16 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Assembly to get into package runtime without using exported symbols.
-
-// +build amd64 amd64p32 arm 386
-
-#include "textflag.h"
-
-#ifdef GOARCH_arm
-#define JMP B
-#endif
-
-TEXT ·LockedOSThread(SB),NOSPLIT,$0-0
-	JMP	runtime·lockedOSThread(SB)

misc/cgo/test/basic.go

@@ -157,8 +157,3 @@ func testUnsignedInt(t *testing.T) {
 		t.Errorf("Incorrect unsigned int - got %x, want %x", a, b)
 	}
 }
-
-// Static (build-time) test that syntax traversal visits all operands of s[i:j:k].
-func sliceOperands(array [2000]int) {
-	_ = array[C.KILO:C.KILO:C.KILO] // no type error
-}

misc/cgo/test/buildid_linux.go

@@ -1,77 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package cgotest
-
-// Test that we have no more than one build ID.  In the past we used
-// to generate a separate build ID for each package using cgo, and the
-// linker concatenated them all.  We don't want that--we only want
-// one.
-
-import (
-	"bytes"
-	"debug/elf"
-	"os"
-	"testing"
-)
-
-func testBuildID(t *testing.T) {
-	f, err := elf.Open("/proc/self/exe")
-	if err != nil {
-		if os.IsNotExist(err) {
-			t.Skip("no /proc/self/exe")
-		}
-		t.Fatalf("opening /proc/self/exe: ", err)
-	}
-	defer f.Close()
-
-	c := 0
-	for i, s := range f.Sections {
-		if s.Type != elf.SHT_NOTE {
-			continue
-		}
-
-		d, err := s.Data()
-		if err != nil {
-			t.Logf("reading data of note section %d: %v", i, err)
-			continue
-		}
-
-		for len(d) > 0 {
-
-			// ELF standards differ as to the sizes in
-			// note sections.  Both the GNU linker and
-			// gold always generate 32-bit sizes, so that
-			// is what we assume here.
-
-			if len(d) < 12 {
-				t.Logf("note section %d too short (%d < 12)", i, len(d))
-				continue
-			}
-
-			namesz := f.ByteOrder.Uint32(d)
-			descsz := f.ByteOrder.Uint32(d[4:])
-			typ := f.ByteOrder.Uint32(d[8:])
-
-			an := (namesz + 3) &^ 3
-			ad := (descsz + 3) &^ 3
-
-			if int(12+an+ad) > len(d) {
-				t.Logf("note section %d too short for header (%d < 12 + align(%d,4) + align(%d,4))", i, len(d), namesz, descsz)
-				continue
-			}
-
-			// 3 == NT_GNU_BUILD_ID
-			if typ == 3 && namesz == 4 && bytes.Equal(d[12:16], []byte("GNU\000")) {
-				c++
-			}
-
-			d = d[12+an+ad:]
-		}
-	}
-
-	if c > 1 {
-		t.Errorf("found %d build ID notes", c)
-	}
-}

misc/cgo/test/callback.go

@@ -9,21 +9,16 @@ void callback(void *f);
 void callGoFoo(void);
 void callGoStackCheck(void);
 void callPanic(void);
-void callCgoAllocate(void);
-int callGoReturnVal(void);
-int returnAfterGrow(void);
-int returnAfterGrowFromGo(void);
 */
 import "C"
 
 import (
+	"./backdoor"
 	"path"
 	"runtime"
 	"strings"
 	"testing"
 	"unsafe"
-
-	"./backdoor"
 )
 
 // nestedCall calls into C, back into Go, and finally to f.
@@ -157,13 +152,11 @@ func testCallbackCallers(t *testing.T) {
 	n := 0
 	name := []string{
 		"test.goCallback",
-		"runtime.call16",
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
 		"runtime.cgocallback_gofunc",
-		"asmcgocall",
-		"runtime.asmcgocall_errno",
-		"runtime.cgocall_errno",
+		"runtime.asmcgocall",
+		"runtime.cgocall",
 		"test._Cfunc_callback",
 		"test.nestedCall",
 		"test.testCallbackCallers",
@@ -188,12 +181,8 @@ func testCallbackCallers(t *testing.T) {
 		if strings.HasPrefix(fname, "_") {
 			fname = path.Base(f.Name()[1:])
 		}
-		namei := ""
-		if i < len(name) {
-			namei = name[i]
-		}
-		if fname != namei {
-			t.Errorf("stk[%d] = %q, want %q", i, fname, namei)
+		if fname != name[i] {
+			t.Errorf("expected function name %s, got %s", name[i], fname)
 		}
 	}
 }
@@ -211,52 +200,6 @@ func testPanicFromC(t *testing.T) {
 	C.callPanic()
 }
 
-func testAllocateFromC(t *testing.T) {
-	C.callCgoAllocate() // crashes or exits on failure
-}
-
-// Test that C code can return a value if it calls a Go function that
-// causes a stack copy.
-func testReturnAfterGrow(t *testing.T) {
-	// Use a new goroutine so that we get a small stack.
-	c := make(chan int)
-	go func() {
-		c <- int(C.returnAfterGrow())
-	}()
-	if got, want := <-c, 123456; got != want {
-		t.Errorf("got %d want %d", got, want)
-	}
-}
-
-// Test that we can return a value from Go->C->Go if the Go code
-// causes a stack copy.
-func testReturnAfterGrowFromGo(t *testing.T) {
-	// Use a new goroutine so that we get a small stack.
-	c := make(chan int)
-	go func() {
-		c <- int(C.returnAfterGrowFromGo())
-	}()
-	if got, want := <-c, 129*128/2; got != want {
-		t.Errorf("got %d want %d", got, want)
-	}
-}
-
-//export goReturnVal
-func goReturnVal() (r C.int) {
-	// Force a stack copy.
-	var f func(int) int
-	f = func(i int) int {
-		var buf [256]byte
-		use(buf[:])
-		if i == 0 {
-			return 0
-		}
-		return i + f(i-1)
-	}
-	r = C.int(f(128))
-	return
-}
-
 func testCallbackStack(t *testing.T) {
 	// Make cgo call and callback with different amount of stack stack available.
 	// We do not do any explicit checks, just ensure that it does not crash.

misc/cgo/test/callback_c.c

@@ -64,19 +64,3 @@ callGoStackCheck(void)
 	extern void goStackCheck(void);
 	goStackCheck();
 }
-
-int
-returnAfterGrow(void)
-{
-	extern int goReturnVal(void);
-	goReturnVal();
-	return 123456;
-}
-
-int
-returnAfterGrowFromGo(void)
-{
-	extern int goReturnVal(void);
-	return goReturnVal();
-}
-

misc/cgo/test/callback_c_gc.c

@@ -5,15 +5,11 @@
 // +build gc
 
 #include "_cgo_export.h"
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
 
 /* Test calling panic from C.  This is what SWIG does.  */
 
 extern void crosscall2(void (*fn)(void *, int), void *, int);
 extern void _cgo_panic(void *, int);
-extern void _cgo_allocate(void *, int);
 
 void
 callPanic(void)
@@ -23,58 +19,3 @@ callPanic(void)
 	crosscall2(_cgo_panic, &a, sizeof a);
 	*(int*)1 = 1;
 }
-
-/* Test calling cgo_allocate from C. This is what SWIG does. */
-
-typedef struct List List;
-struct List
-{
-	List *next;
-	int x;
-};
-
-void
-callCgoAllocate(void)
-{
-	int i;
-	struct { size_t n; void *ret; } a;
-	List *l, *head, **tail;
-
-	// Make sure this doesn't crash.
-	// And make sure it returns non-nil.
-	a.n = 0;
-	a.ret = 0;
-	crosscall2(_cgo_allocate, &a, sizeof a);
-	if(a.ret == 0) {
-		fprintf(stderr, "callCgoAllocate: alloc 0 returned nil\n");
-		exit(2);
-	}
-	
-	head = 0;
-	tail = &head;
-	for(i=0; i<100; i++) {
-		a.n = sizeof *l;
-		crosscall2(_cgo_allocate, &a, sizeof a);
-		l = a.ret;
-		l->x = i;
-		l->next = 0;
-		*tail = l;
-		tail = &l->next;
-	}
-	
-	gc();
-	
-	l = head;
-	for(i=0; i<100; i++) {
-		if(l->x != i) {
-			fprintf(stderr, "callCgoAllocate: lost memory\n");
-			exit(2);
-		}
-		l = l->next;
-	}
-	if(l != 0) {
-		fprintf(stderr, "callCgoAllocate: lost memory\n");
-		exit(2);
-	}
-}
-

misc/cgo/test/callback_c_gccgo.c

@@ -5,66 +5,13 @@
 // +build gccgo
 
 #include "_cgo_export.h"
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
 
 /* Test calling panic from C.  This is what SWIG does.  */
 
 extern void _cgo_panic(const char *);
-extern void *_cgo_allocate(size_t);
 
 void
 callPanic(void)
 {
 	_cgo_panic("panic from C");
 }
-
-/* Test calling cgo_allocate from C. This is what SWIG does. */
-
-typedef struct List List;
-struct List
-{
-	List *next;
-	int x;
-};
-
-void
-callCgoAllocate(void)
-{
-	int i;
-	List *l, *head, **tail;
-	
-	// Make sure this doesn't crash.
-	// And make sure it returns non-nil.
-	if(_cgo_allocate(0) == 0) {
-		fprintf(stderr, "callCgoAllocate: alloc 0 returned nil\n");
-		exit(2);
-	}
-
-	head = 0;
-	tail = &head;
-	for(i=0; i<100; i++) {
-		l = _cgo_allocate(sizeof *l);
-		l->x = i;
-		l->next = 0;
-		*tail = l;
-		tail = &l->next;
-	}
-	
-	gc();
-	
-	l = head;
-	for(i=0; i<100; i++) {
-		if(l->x != i) {
-			fprintf(stderr, "callCgoAllocate: lost memory\n");
-			exit(2);
-		}
-		l = l->next;
-	}
-	if(l != 0) {
-		fprintf(stderr, "callCgoAllocate: lost memory\n");
-		exit(2);
-	}
-}
-

misc/cgo/test/cgo_linux_test.go

@@ -6,6 +6,4 @@ package cgotest
 
 import "testing"
 
-func TestSetgid(t *testing.T)  { testSetgid(t) }
-func Test6997(t *testing.T)    { test6997(t) }
-func TestBuildID(t *testing.T) { testBuildID(t) }
+func TestSetgid(t *testing.T) { testSetgid(t) }

misc/cgo/test/cgo_test.go

@@ -10,58 +10,45 @@ import "testing"
 // so that they can use cgo (import "C").
 // These wrappers are here for gotest to find.
 
-func TestAlign(t *testing.T)                 { testAlign(t) }
-func TestConst(t *testing.T)                 { testConst(t) }
-func TestEnum(t *testing.T)                  { testEnum(t) }
-func TestAtol(t *testing.T)                  { testAtol(t) }
-func TestErrno(t *testing.T)                 { testErrno(t) }
-func TestMultipleAssign(t *testing.T)        { testMultipleAssign(t) }
-func TestUnsignedInt(t *testing.T)           { testUnsignedInt(t) }
-func TestCallback(t *testing.T)              { testCallback(t) }
-func TestCallbackGC(t *testing.T)            { testCallbackGC(t) }
-func TestCallbackPanic(t *testing.T)         { testCallbackPanic(t) }
-func TestCallbackPanicLoop(t *testing.T)     { testCallbackPanicLoop(t) }
-func TestCallbackPanicLocked(t *testing.T)   { testCallbackPanicLocked(t) }
-func TestPanicFromC(t *testing.T)            { testPanicFromC(t) }
-func TestAllocateFromC(t *testing.T)         { testAllocateFromC(t) }
-func TestZeroArgCallback(t *testing.T)       { testZeroArgCallback(t) }
-func TestBlocking(t *testing.T)              { testBlocking(t) }
-func Test1328(t *testing.T)                  { test1328(t) }
-func TestParallelSleep(t *testing.T)         { testParallelSleep(t) }
-func TestSetEnv(t *testing.T)                { testSetEnv(t) }
-func TestHelpers(t *testing.T)               { testHelpers(t) }
-func TestLibgcc(t *testing.T)                { testLibgcc(t) }
-func Test1635(t *testing.T)                  { test1635(t) }
-func TestPrintf(t *testing.T)                { testPrintf(t) }
-func Test4029(t *testing.T)                  { test4029(t) }
-func TestBoolAlign(t *testing.T)             { testBoolAlign(t) }
-func Test3729(t *testing.T)                  { test3729(t) }
-func Test3775(t *testing.T)                  { test3775(t) }
-func TestCthread(t *testing.T)               { testCthread(t) }
-func TestCallbackCallers(t *testing.T)       { testCallbackCallers(t) }
-func Test5227(t *testing.T)                  { test5227(t) }
-func TestCflags(t *testing.T)                { testCflags(t) }
-func Test5337(t *testing.T)                  { test5337(t) }
-func Test5548(t *testing.T)                  { test5548(t) }
-func Test5603(t *testing.T)                  { test5603(t) }
-func Test6833(t *testing.T)                  { test6833(t) }
-func Test3250(t *testing.T)                  { test3250(t) }
-func TestCallbackStack(t *testing.T)         { testCallbackStack(t) }
-func TestFpVar(t *testing.T)                 { testFpVar(t) }
-func Test4339(t *testing.T)                  { test4339(t) }
-func Test6390(t *testing.T)                  { test6390(t) }
-func Test5986(t *testing.T)                  { test5986(t) }
-func Test7665(t *testing.T)                  { test7665(t) }
-func TestNaming(t *testing.T)                { testNaming(t) }
-func Test7560(t *testing.T)                  { test7560(t) }
-func Test5242(t *testing.T)                  { test5242(t) }
-func Test8092(t *testing.T)                  { test8092(t) }
-func Test7978(t *testing.T)                  { test7978(t) }
-func Test8694(t *testing.T)                  { test8694(t) }
-func Test8517(t *testing.T)                  { test8517(t) }
-func Test8811(t *testing.T)                  { test8811(t) }
-func TestReturnAfterGrow(t *testing.T)       { testReturnAfterGrow(t) }
-func TestReturnAfterGrowFromGo(t *testing.T) { testReturnAfterGrowFromGo(t) }
-func Test9026(t *testing.T)                  { test9026(t) }
+func TestAlign(t *testing.T)               { testAlign(t) }
+func TestConst(t *testing.T)               { testConst(t) }
+func TestEnum(t *testing.T)                { testEnum(t) }
+func TestAtol(t *testing.T)                { testAtol(t) }
+func TestErrno(t *testing.T)               { testErrno(t) }
+func TestMultipleAssign(t *testing.T)      { testMultipleAssign(t) }
+func TestUnsignedInt(t *testing.T)         { testUnsignedInt(t) }
+func TestCallback(t *testing.T)            { testCallback(t) }
+func TestCallbackGC(t *testing.T)          { testCallbackGC(t) }
+func TestCallbackPanic(t *testing.T)       { testCallbackPanic(t) }
+func TestCallbackPanicLoop(t *testing.T)   { testCallbackPanicLoop(t) }
+func TestCallbackPanicLocked(t *testing.T) { testCallbackPanicLocked(t) }
+func TestPanicFromC(t *testing.T)          { testPanicFromC(t) }
+func TestZeroArgCallback(t *testing.T)     { testZeroArgCallback(t) }
+func TestBlocking(t *testing.T)            { testBlocking(t) }
+func Test1328(t *testing.T)                { test1328(t) }
+func TestParallelSleep(t *testing.T)       { testParallelSleep(t) }
+func TestSetEnv(t *testing.T)              { testSetEnv(t) }
+func TestHelpers(t *testing.T)             { testHelpers(t) }
+func TestLibgcc(t *testing.T)              { testLibgcc(t) }
+func Test1635(t *testing.T)                { test1635(t) }
+func TestPrintf(t *testing.T)              { testPrintf(t) }
+func Test4029(t *testing.T)                { test4029(t) }
+func TestBoolAlign(t *testing.T)           { testBoolAlign(t) }
+func Test3729(t *testing.T)                { test3729(t) }
+func Test3775(t *testing.T)                { test3775(t) }
+func TestCthread(t *testing.T)             { testCthread(t) }
+func TestCallbackCallers(t *testing.T)     { testCallbackCallers(t) }
+func Test5227(t *testing.T)                { test5227(t) }
+func TestCflags(t *testing.T)              { testCflags(t) }
+func Test5337(t *testing.T)                { test5337(t) }
+func Test5548(t *testing.T)                { test5548(t) }
+func Test5603(t *testing.T)                { test5603(t) }
+func Test3250(t *testing.T)                { test3250(t) }
+func TestCallbackStack(t *testing.T)       { testCallbackStack(t) }
+func TestFpVar(t *testing.T)               { testFpVar(t) }
+func Test4339(t *testing.T)                { test4339(t) }
+func Test6390(t *testing.T)                { test6390(t) }
+func Test5986(t *testing.T)                { test5986(t) }
+func TestNaming(t *testing.T)              { testNaming(t) }
 
 func BenchmarkCgoCall(b *testing.B) { benchCgoCall(b) }

misc/cgo/test/exports.go

@@ -5,14 +5,8 @@
 package cgotest
 
 import "C"
-import "runtime"
 
 //export ReturnIntLong
 func ReturnIntLong() (int, C.long) {
 	return 1, 2
 }
-
-//export gc
-func gc() {
-	runtime.GC()
-}

misc/cgo/test/issue5242.go

@@ -1,31 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 5242.  Cgo incorrectly computed the alignment of structs
-// with no Go accessible fields as 0, and then panicked on
-// modulo-by-zero computations.
-
-package cgotest
-
-/*
-typedef struct {
-} foo;
-
-typedef struct {
-	int x : 1;
-} bar;
-
-int issue5242(foo f, bar b) {
-	return 5242;
-}
-*/
-import "C"
-
-import "testing"
-
-func test5242(t *testing.T) {
-	if got := C.issue5242(C.foo{}, C.bar{}); got != 5242 {
-		t.Errorf("got %v", got)
-	}
-}

misc/cgo/test/issue5548.go

@@ -14,14 +14,13 @@ import "C"
 //export issue5548FromC
 func issue5548FromC(s string, i int) int {
 	if len(s) == 4 && s == "test" && i == 42 {
-		return 12345
+		return 1
 	}
-	println("got", len(s), i)
-	return 9876
+	return 0
 }
 
 func test5548(t *testing.T) {
-	if x := C.issue5548_in_c(); x != 12345 {
-		t.Errorf("issue5548_in_c = %d, want %d", x, 12345)
+	if C.issue5548_in_c() == 0 {
+		t.Fail()
 	}
 }

misc/cgo/test/issue6833.go

@@ -1,27 +0,0 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package cgotest
-
-/*
-extern unsigned long long issue6833Func(unsigned int, unsigned long long);
-*/
-import "C"
-
-import "testing"
-
-//export GoIssue6833Func
-func GoIssue6833Func(aui uint, aui64 uint64) uint64 {
-	return aui64 + uint64(aui)
-}
-
-func test6833(t *testing.T) {
-	ui := 7
-	ull := uint64(0x4000300020001000)
-	v := uint64(C.issue6833Func(C.uint(ui), C.ulonglong(ull)))
-	exp := uint64(ui) + ull
-	if v != exp {
-		t.Errorf("issue6833Func() returns %x, expected %x", v, exp)
-	}
-}

misc/cgo/test/issue6833_c.c

@@ -1,10 +0,0 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "_cgo_export.h"
- 
-unsigned long long
-issue6833Func(unsigned int aui, unsigned long long aull) {
-	return GoIssue6833Func(aui, aull);
-}

misc/cgo/test/issue6997_linux.c

@@ -1,26 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include <pthread.h>
-#include <stdio.h>
-#include <unistd.h>
-
-static pthread_t thread;
-
-static void* threadfunc(void* dummy) {
-	while(1) {
-		sleep(1);
-	}
-}
-
-int StartThread() {
-	return pthread_create(&thread, NULL, &threadfunc, NULL);
-}
-
-int CancelThread() {
-	void *r;
-	pthread_cancel(thread);
-	pthread_join(thread, &r);
-	return (r == PTHREAD_CANCELED);
-}

misc/cgo/test/issue6997_linux.go

@@ -1,40 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test that pthread_cancel works as expected
-// (NPTL uses SIGRTMIN to implement thread cancellation)
-// See http://golang.org/issue/6997
-package cgotest
-
-/*
-#cgo CFLAGS: -pthread
-#cgo LDFLAGS: -pthread
-extern int StartThread();
-extern int CancelThread();
-*/
-import "C"
-
-import "testing"
-import "time"
-
-func test6997(t *testing.T) {
-	r := C.StartThread()
-	if r != 0 {
-		t.Error("pthread_create failed")
-	}
-	c := make(chan C.int)
-	go func() {
-		time.Sleep(500 * time.Millisecond)
-		c <- C.CancelThread()
-	}()
-
-	select {
-	case r = <-c:
-		if r == 0 {
-			t.Error("pthread finished but wasn't cancelled??")
-		}
-	case <-time.After(30 * time.Second):
-		t.Error("hung in pthread_cancel/pthread_join")
-	}
-}

misc/cgo/test/issue7234_test.go

@@ -1,21 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package cgotest
-
-import "testing"
-
-// This test actually doesn't have anything to do with cgo.  It is a
-// test of http://golang.org/issue/7234, a compiler/linker bug in
-// handling string constants when using -linkmode=external.  The test
-// is in this directory because we routinely test -linkmode=external
-// here.
-
-var v7234 = [...]string{"runtime/cgo"}
-
-func TestIssue7234(t *testing.T) {
-	if v7234[0] != "runtime/cgo" {
-		t.Errorf("bad string constant %q", v7234[0])
-	}
-}

misc/cgo/test/issue7560.go

@@ -1,44 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package cgotest
-
-/*
-#include <stdint.h>
-
-typedef struct {
-	char x;
-	long y;
-} __attribute__((__packed__)) misaligned;
-
-int
-offset7560(void)
-{
-	return (uintptr_t)&((misaligned*)0)->y;
-}
-*/
-import "C"
-
-import (
-	"reflect"
-	"testing"
-)
-
-func test7560(t *testing.T) {
-	// some mingw don't implement __packed__ correctly.
-	if C.offset7560() != 1 {
-		t.Skip("C compiler did not pack struct")
-	}
-
-	// C.misaligned should have x but then a padding field to get to the end of the struct.
-	// There should not be a field named 'y'.
-	var v C.misaligned
-	rt := reflect.TypeOf(&v).Elem()
-	if rt.NumField() != 2 || rt.Field(0).Name != "x" || rt.Field(1).Name != "_" {
-		t.Errorf("unexpected fields in C.misaligned:\n")
-		for i := 0; i < rt.NumField(); i++ {
-			t.Logf("%+v\n", rt.Field(i))
-		}
-	}
-}