diff --git a/.hgignore b/.hgignore index f28da84603..a833065f2e 100644 --- a/.hgignore +++ b/.hgignore @@ -23,16 +23,12 @@ _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/cc/y.output @@ -43,7 +39,6 @@ src/cmd/gc/opnames.h src/cmd/gc/y.output src/cmd/go/zdefaultcc.go src/go/doc/headscan -src/runtime/goc2c src/runtime/mkversion src/runtime/z* src/unicode/maketables diff --git a/.hgtags b/.hgtags index 51569d518f..5a5c4aed44 100644 --- a/.hgtags +++ b/.hgtags @@ -132,4 +132,6 @@ f8b50ad4cac4d4c4ecf48324b4f512f65e82cc1c go1.3beta1 3f66a43d5180052e2e1e38d979d1aa5ad05b21f9 go1.3rc2 9895f9e36435468d503eaa74ee217f28d5e28dd4 go1.3 073fc578434bf3e1e22749b559d273c8da728ebb go1.3.1 -073fc578434bf3e1e22749b559d273c8da728ebb release +85518b1d6f8d6e16133b9ed2c9db6807522d37de go1.3.2 +f44017549ff9c3cc5eef74ebe7276cd0dfc066b6 go1.3.3 +f44017549ff9c3cc5eef74ebe7276cd0dfc066b6 release diff --git a/AUTHORS b/AUTHORS index 29aca3dbc4..03e686e751 100644 --- a/AUTHORS +++ b/AUTHORS @@ -13,6 +13,7 @@ Abhinav Gupta Adrian Nos Adrian O'Grady Adrien Bustany +Ahmed Waheed Moanes Akshat Kumar Alan Shreve Albert Strasheim @@ -182,6 +183,7 @@ Gustavo Niemeyer Gwenael Treguier Harley Laue Hector Chu +Hector Martin Cantero Henning Schmiedehausen Henrik Edwards Herbert Georg Fischer @@ -212,6 +214,7 @@ Jeff Hodges Jeff R. Allen Jeff Sickel Jeff Wendling +Jens Frederich Jeremy Jackins Jim McGrath Jimmy Zelinskie @@ -225,6 +228,7 @@ John C Barstow John Graham-Cumming John Howard Palevich John Shahid +John Tuley Jonathan Gold Jonathan Mark Jonathan Rudenberg @@ -236,6 +240,7 @@ Josh Bleecher Snyder Josh Goebel Josh Holland Joshua Chase +JT Olds Jukka-Pekka Kekkonen Julian Phillips Julien Schmidt @@ -290,6 +295,7 @@ Michael Fraenkel Michael Gehring Michael Hoisie Michael Lewis +Michael MacInnis Michael Pearson Michael Stapelberg Michael Teichgräber @@ -355,6 +361,7 @@ Pietro Gagliardi Preetam Jinka Quan Yong Zhai Raif S. Naffah +Red Hat, Inc. Rémy Oudompheng Richard Crowley Richard Eric Gavaletz @@ -371,6 +378,7 @@ Rodrigo Moraes de Oliveira Rodrigo Rafael Monti Kochenburger Roger Pau Monné Roger Peppe +Ron Hashimoto Ron Minnich Ross Light Rowan Worth @@ -413,6 +421,7 @@ Thomas Kappler Timo Savola Timo Truyts Tobias Columbus +Tom Linford Tor Andersson Travis Cline Tudor Golubenco diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 4d2aacafa9..7679f78742 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -38,6 +38,7 @@ Adam Langley Adrian Nos Adrian O'Grady Adrien Bustany +Ahmed Waheed Moanes Akshat Kumar Alan Donovan Alan Shreve @@ -65,6 +66,7 @@ Amrut Joshi Andrea Spadaccini Andreas Jellinghaus Andrei Vieru +Andres Erbsen Andrew Balholm Andrew Bonventre Andrew Bursavich @@ -94,7 +96,7 @@ Arvindh Rajesh Tamilmani Asim Shankar Ato Araki Aulus Egnatius Varialus -Austin Clements +Austin Clements Balazs Lecz Ben Eitzen Ben Fried @@ -158,6 +160,7 @@ Corey Thomasson Cosmos Nicolaou Cristian Staretu Damian Gryski +Damien Neil Dan Callahan Dan Peterson Dan Sinclair @@ -254,9 +257,11 @@ Gustav Paul Gustavo Franco Gustavo Niemeyer Gwenael Treguier +Hana Kim Han-Wen Nienhuys Harley Laue Hector Chu +Hector Martin Cantero Henning Schmiedehausen Henrik Edwards Herbert Georg Fischer @@ -276,6 +281,7 @@ James Fysh James Gray James Meneghello James P. Cooper +James Robinson James Toy James Tucker James Whitehead @@ -297,6 +303,7 @@ Jeff Hodges Jeff R. Allen Jeff Sickel Jeff Wendling +Jens Frederich Jeremiah Harmsen Jeremy Jackins Jeremy Schlatter @@ -317,6 +324,7 @@ John Graham-Cumming John Howard Palevich John Newlin John Shahid +John Tuley Jonathan Allie Jonathan Feinberg Jonathan Gold @@ -337,6 +345,7 @@ Josh Hoak Josh Holland Joshua Chase JP Sugarbroad +JT Olds Jukka-Pekka Kekkonen Julian Phillips Julien Schmidt @@ -409,6 +418,7 @@ Michael Hoisie Michael Hudson-Doyle Michael Kelly Michael Lewis +Michael MacInnis Michael Matloob Michael Pearson Michael Piatek @@ -431,6 +441,7 @@ Mikkel Krautz Miquel Sabaté Solà Moriyoshi Koizumi Môshe van der Sterre +Mrunal Patel Nan Deng Nathan John Youngman Nicholas Katsaros @@ -490,6 +501,7 @@ Preetam Jinka Quan Yong Zhai Raif S. Naffah Raph Levien +Raul Silvera Rémy Oudompheng Richard Crowley Richard Eric Gavaletz @@ -511,6 +523,7 @@ Rodrigo Moraes de Oliveira Rodrigo Rafael Monti Kochenburger Roger Pau Monné Roger Peppe +Ron Hashimoto Ron Minnich Ross Light Rowan Worth @@ -565,6 +578,7 @@ Timo Savola Timo Truyts Tobias Columbus Todd Wang +Tom Linford Tom Szymanski Tor Andersson Travis Cline diff --git a/doc/devel/release.html b/doc/devel/release.html index a8f5963ca7..1a84391345 100644 --- a/doc/devel/release.html +++ b/doc/devel/release.html @@ -27,6 +27,16 @@ go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the r See the change history for details.

+

+go1.3.2 (released 2014/09/25) includes bug fixes to cgo and the crypto/tls packages. +See the change history for details. +

+ +

+go1.3.3 (released 2014/09/30) includes further bug fixes to cgo, the runtime package, and the nacl port. +See the change history for details. +

+

go1.2 (released 2013/12/01)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt index 4fe71b4b9e..ae52562df9 100644 --- a/doc/go1.4.txt +++ b/doc/go1.4.txt @@ -13,23 +13,39 @@ cmd/6l, liblink: use pc-relative addressing for all memory references, so that l cmd/go: import comments (CL 124940043) cmd/go: implement "internal" (CL 120600043) cmd/go: implement "generate" (CL 125580044) +cmd/go: disallow C sources except when using cgo (CL 149720043) +cmd/go: add test -o flag (CL 149070043) +cmd/go: redefine build -a to skip standard library in releases (CL 151730045) +cmd/go: compile and link all _test.go files during 'go test', even in packages where there are no Test functions (CL 150980043) +cmd/go: (via go/build): a GOOS prefix acts as a tag only if preceded by an underscore. this is a breaking change. (CL 147690043) asm: make textflag.h available outside of cmd/ld (CL 128050043) +bufio: handling of empty tokens at EOF changed, may require scanner change (CL 145390043) +compress/flate, compress/gzip, compress/zlib: Reset support (https://codereview.appspot.com/97140043) crypto/tls: add support for ALPN (RFC 7301) (CL 108710046) crypto/tls: support programmatic selection of server certificates (CL 107400043) +flag: it is now an error to set a flag multiple times (CL 156390043) +fmt: print type *map[T]T as &map[k:v] (CL 154870043) encoding/gob: remove unsafe (CL 102680045) misc: deleted editor support; refer to https://code.google.com/p/go-wiki/wiki/IDEsAndTextEditorPlugins instead (CL 105470043) net/http: add Request.BasicAuth method (CL 76540043) net/http: add Transport.DialTLS hook (CL 137940043) net/http/httputil: add ReverseProxy.ErrorLog (CL 132750043) os: implement symlink support for windows (CL 86160044) +reflect: add type.Comparable (CL 144020043) runtime: implement monotonic clocks on windows (CL 108700045) +runtime: memory consumption is reduced by 10-30% (CL 106260045 removes type info from heap, CL 145790043 reduces stack size to 2K (4K on plan 9 and windows)) +runtime: MemStats.Mallocs now counts very small allocations missed in Go 1.3. This may break tests using runtime.ReadMemStats or testing.AllocsPerRun by giving a more accurate answer than Go 1.3 did (CL 143150043). runtime/race: freebsd is supported (CL 107270043) +swig: Due to runtime changes Go 1.4 will require SWIG 3.0.3 (not yet released) +sync/atomic: add Value (CL 136710045) syscall: Setuid, Setgid are disabled on linux platforms. On linux those syscalls operate on the calling thread, not the whole process. This does not match the semantics of other platforms, nor the expectations of the caller, so the operations have been disabled until issue 1435 is resolved (CL 106170043) -syscal: now frozen (CL 129820043) +syscall: now frozen (CL 129820043) testing: add Coverage (CL 98150043) +testing: add TestMain support (CL 148770043) text/scanner: add IsIdentRune field of Scanner. (CL 108030044) +text/template: allow comparison of signed and unsigned integers (CL 149780043) time: use the micro symbol (µ (U+00B5)) to print microsecond duration (CL 105030046) -encoding/asn1: optional elements with a default value will now only be omitted if they have that value (CL 86960045). +encoding/asn1: optional elements with a default value will now only be omitted if they have that value (CL 86960045) go.sys subrepo created: http://golang.org/s/go1.4-syscall diff --git a/doc/go1.html b/doc/go1.html index 5cf5df9296..1665d74e95 100644 --- a/doc/go1.html +++ b/doc/go1.html @@ -2035,4 +2035,4 @@ They are available for many combinations of architecture and operating system Installation details are described on the Getting Started page, while the distributions themselves are listed on the -downloads page. +downloads page. diff --git a/doc/go1compat.html b/doc/go1compat.html index 8ceaf32f97..04a6c1124b 100644 --- a/doc/go1compat.html +++ b/doc/go1compat.html @@ -83,16 +83,16 @@ break if the bug is fixed. We reserve the right to fix such bugs.

  • 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 untagged struct literals (such as pkg.T{3, +the API. Code that uses unkeyed struct literals (such as pkg.T{3, "x"}) to create values of these types would fail to compile after -such a change. However, code that uses tagged literals (pkg.T{A: +such a change. However, code that uses keyed literals (pkg.T{A: 3, B: "x"}) will continue to compile after such a change. We will -update such data structures in a way that allows tagged struct -literals to remain compatible, although untagged literals may fail +update such data structures in a way that allows keyed struct +literals to remain compatible, although unkeyed literals may fail to compile. (There are also more intricate cases involving nested data structures or interfaces, but they have the same resolution.) We therefore recommend that composite literals whose type is defined -in a separate package should use the tagged notation. +in a separate package should use the keyed notation.
  • diff --git a/doc/go_faq.html b/doc/go_faq.html index 4e90d3907e..ec3689aeb0 100644 --- a/doc/go_faq.html +++ b/doc/go_faq.html @@ -889,6 +889,11 @@ type is generic; if you care about how many bits an integer holds, Go encourages you to be explicit.

    +

    +A blog post, title Constants, +explores this topic in more detail. +

    +

    Why are maps built in?

    @@ -971,7 +976,7 @@ It is a handy reference for people doing code reviews for Go projects. How do I submit patches to the Go libraries?

    -The library sources are in go/src. +The library sources are in the src directory of the repository. If you want to make a significant change, please discuss on the mailing list before embarking.

    @@ -1590,30 +1595,40 @@ and uses a variant of the Plan 9 loader to generate ELF/Mach-O/PE binaries.

    -We considered writing gc, 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—you'd need a Go compiler to -set up a Go environment. Gccgo, which came later, makes it possible to -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 go package -and a type checker is in the works.) +We considered using LLVM for gc but we felt it was too large and +slow to meet our performance goals.

    -We also considered using LLVM for gc but we felt it was too large and -slow to meet our performance goals. +We also considered writing gc, 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—you'd need a Go compiler to +set up a Go environment. Gccgo, 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 separate document +explains the reason for this approach. +

    + +

    +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 go package +and a separate type checking +package +has also been written.

    How is the run-time support implemented?

    -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. Gccgo's run-time support uses glibc. -Gc uses a custom library to keep the footprint under +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). +Gccgo's run-time support uses glibc. +Gc uses a custom C 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. @@ -1637,8 +1652,8 @@ A simple C "hello, world" program compiled and linked statically using gcc on Linux is around 750 kB, including an implementation of printf. An equivalent Go program using fmt.Printf -is around 1.2 MB, but -that includes more powerful run-time support. +is around 1.9 MB, but +that includes more powerful run-time support and type information.

    @@ -1646,14 +1661,17 @@ Can I stop these complaints about my unused variable/import?

    The presence of an unused variable may indicate a bug, while -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. +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.

    -When developing code, it's common to create these situations +Still, 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.

    @@ -1695,6 +1713,14 @@ func main() { } +

    +Nowadays, most Go programmers use a tool, +goimports, +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. +

    +

    Performance

    diff --git a/doc/go_spec.html b/doc/go_spec.html index e8bb35f0b0..97effeaa4a 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -577,7 +577,7 @@ Numeric constants represent values of arbitrary precision and do not overflow.

    -Constants may be typed or untyped. +Constants may be typed or untyped. Literal constants, true, false, iota, and certain constant expressions containing only untyped constant operands are untyped. @@ -597,6 +597,17 @@ can be given the types float32, float64, or uint not int32 or string.

    +

    +An untyped constant has a default type which is the type to which the +constant is implicitly converted in contexts where a typed value is required, +for instance, in a short variable declaration +such as i := 0 where there is no explicit type. +The default type of an untyped constant is bool, rune, +int, float64, complex128 or string +respectively, depending on whether it is a boolean, rune, integer, floating-point, +complex, or string constant. +

    +

    There are no constants denoting the IEEE-754 infinity and not-a-number values, but the math package's @@ -636,6 +647,65 @@ of evaluating constant expressions.

    +

    Variables

    + +

    +A variable is a storage location for holding a value. +The set of permissible values is determined by the +variable's type. +

    + +

    +A variable declaration +or, for function parameters and results, the signature +of a function declaration +or function literal reserves +storage for a named variable. + +Calling the built-in function new +or taking the address of a composite literal +allocates storage for a variable at run time. +Such an anonymous variable is referred to via a (possibly implicit) +pointer indirection. +

    + +

    +Structured variables of array, slice, +and struct types have elements and fields that may +be addressed individually. Each such element +acts like a variable. +

    + +

    +The static type (or just type) of a variable is the +type given in its declaration, the type provided in the +new call or composite literal, or the type of +an element of a structured variable. +Variables of interface type also have a distinct dynamic type, +which is the concrete type of the value assigned to the variable at run time +(unless the value is the predeclared identifier nil, +which has no type). +The dynamic type may vary during execution but values stored in interface +variables are always assignable +to the static type of the variable. +

    + +
    +var x interface{}  // x is nil and has static type interface{}
+var v *T           // v has value nil, static type *T
+x = 42             // x has value 42 and dynamic type int
+x = v              // x has value (*T)(nil) and dynamic type *T
+
    + +

    +A variable's value is retrieved by referring to the variable in an +expression; it is the most recent value +assigned to the variable. +If a variable has not yet been assigned a value, its value is the +zero value for its type. +

    + +

    Types

    @@ -661,17 +731,6 @@ interface, slice, map, and channel types—may be constructed using type literals.

    -

    -The static type (or just type) of a variable is the -type defined by its declaration. Variables of interface type -also have a distinct dynamic type, which -is the actual type of the value stored in the variable at run time. -The dynamic type may vary during execution but is always -assignable -to the static type of the interface variable. For non-interface -types, the dynamic type is always the static type. -

    -

    Each type T has an underlying type: If T is one of the predeclared boolean, numeric, or string types, or a type literal, @@ -1027,7 +1086,7 @@ struct {

    Pointer types

    -A pointer type denotes the set of all pointers to variables of a given +A pointer type denotes the set of all pointers to variables of a given type, called the base type of the pointer. The value of an uninitialized pointer is nil.

    @@ -1154,11 +1213,11 @@ interface{}

    Similarly, consider this interface specification, which appears within a type declaration -to define an interface called Lock: +to define an interface called Locker: 

    -type Lock interface {
+type Locker interface {
 	Lock()
 	Unlock()
 }
@@ -1174,28 +1233,35 @@ func (p T) Unlock() { … }

    -they implement the Lock interface as well +they implement the Locker interface as well as the File interface.

    +

    -An interface may use an interface type name T -in place of a method specification. -The effect, called embedding an interface, -is equivalent to enumerating the methods of T explicitly -in the interface. +An interface T may use a (possibly qualified) interface type +name E in place of a method specification. This is called +embedding interface E in T; it adds +all (exported and non-exported) methods of E to the interface +T. 

    -type ReadWrite interface {
+type ReadWriter interface {
 	Read(b Buffer) bool
 	Write(b Buffer) bool
 }
 
 type File interface {
-	ReadWrite  // same as enumerating the methods in ReadWrite
-	Lock       // same as enumerating the methods in Lock
+	ReadWriter  // same as adding the methods of ReadWriter
+	Locker      // same as adding the methods of Locker
 	Close()
 }
+
+type LockedFile interface {
+	Locker
+	File        // illegal: Lock, Unlock not unique
+	Lock()      // illegal: Lock not unique
+}

    @@ -1443,7 +1509,7 @@ is different from []string.

    Assignability

    -A value x is assignable to a variable of type T +A value x is assignable to a variable of type T ("x is assignable to T") in any of these cases:

    @@ -1875,9 +1941,10 @@ func (tz TimeZone) String() string {

    Variable declarations

    -A variable declaration creates a variable, binds an identifier to it and -gives it a type and optionally an initial value. +A variable declaration creates one or more variables, binds corresponding +identifiers to them, and gives each a type and an initial value.

    + 
     VarDecl     = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
 VarSpec     = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
@@ -1898,22 +1965,27 @@ var _, found = entries[name]  // map lookup; only interested in "found"
 
 
    
 If a list of expressions is given, the variables are initialized
-by assigning the expressions to the variables
-in order; all expressions must be consumed and all variables initialized from them.
+with the expressions following the rules for assignments.
 Otherwise, each variable is initialized to its zero value.
 
    
 
 
    
-If the type is present, each variable is given that type.
-Otherwise, the types are deduced from the assignment
-of the expression list.
+If a type is present, each variable is given that type.
+Otherwise, each variable is given the type of the corresponding
+initialization value in the assignment.
+If that value is an untyped constant, it is first
+converted to its default type;
+if it is an untyped boolean value, it is first converted to type bool.
+The predeclared value nil cannot be used to initialize a variable
+with no explicit type.
 
    
 
-
    
-If the type is absent and the corresponding expression evaluates to an
-untyped constant, the type of the declared variable
-is as described in §Assignments.
-
    
+
    +var d = math.Sin(0.5)  // d is int64
+var i = 42             // i is int
+var t, ok = x.(T)      // t is T, ok is bool
+var n = nil            // illegal
+
    
 
 
    
 Implementation restriction: A compiler may make it illegal to declare a variable
@@ -2242,7 +2314,8 @@ For array and slice literals the following rules apply:
 
 
    
 Taking the address of a composite literal
-generates a pointer to a unique instance of the literal's value.
+generates a pointer to a unique variable initialized
+with the literal's value.
 
    
 
     var pointer *Point3D = &Point3D{y: 1000}
@@ -3604,7 +3677,7 @@ then the evaluation of &x does too.
 
 
    
 For an operand x of pointer type *T, the pointer
-indirection *x denotes the value of type T pointed
+indirection *x denotes the variable of type T pointed
 to by x.
 If x is nil, an attempt to evaluate *x
 will cause a run-time panic.
@@ -4311,7 +4384,7 @@ a[i] = 23
 
 
    
 An assignment operation x op=
-y where op is a binary arithmetic operation equivalent
+y where op is a binary arithmetic operation is equivalent
 to x = x op
 y but evaluates x
 only once.  The op= construct is a single token.
@@ -4329,8 +4402,8 @@ i &^= 1<<n
 A tuple assignment assigns the individual elements of a multi-valued
 operation to a list of variables.  There are two forms.  In the
 first, the right hand operand is a single multi-valued expression
-such as a function evaluation or channel or
-map operation or a type assertion.
+such as a function call, a channel or
+map operation, or a type assertion.
 The number of operands on the left
 hand side must match the number of values.  For instance, if
 f is a function returning two values,
@@ -4404,23 +4477,21 @@ to the type of the operand to which it is assigned, with the following special c
 
    
 
 
      
-
    1. 
-	If an untyped constant
-	is assigned to a variable of interface type or the blank identifier,
-	the constant is first converted to type
-	bool, rune, int, float64,
-	complex128 or string respectively, depending on
-	whether the value is a boolean, rune, integer, floating-point, complex, or
-	string constant.
-
      2. 
+
    2. 
+	Any typed value may be assigned to the blank identifier.
+
      3. 
 
-
    3. 
-	
-	If a left-hand side is the blank identifier, any typed or non-constant
-	value except for the predeclared identifier
-	nil
-	may be assigned to it.
-
      4. 
+
    4. 
+	If an untyped constant
+	is assigned to a variable of interface type or the blank identifier,
+	the constant is first converted to its
+	 default type.
+
      5. 
+
+
    5. 
+	If an untyped boolean value is assigned to a variable of interface type or
+	the blank identifier, it is first converted to type bool.
+
      6. 
 
    
 
 
    If statements
    
@@ -4675,6 +4746,7 @@ additionally it may specify an init
 and a post statement, such as an assignment,
 an increment or decrement statement. The init statement may be a
 short variable declaration, but the post statement must not.
+Variables declared by the init statement are re-used in each iteration.
 
    
 
 
    @@ -4801,7 +4873,7 @@ The iteration variables may be declared by the "range" clause using a form of
 short variable declaration
 (:=).
 In this case their types are set to the types of the respective iteration values
-and their scope ends at the end of the "for"
+and their scope is the block of the "for"
 statement; they are re-used in each iteration.
 If the iteration variables are declared outside the "for" statement,
 after execution their values will be those of the last iteration.
@@ -5243,13 +5315,16 @@ Calls of built-in functions are restricted as for
 
    
 
 
    
-Each time the "defer" statement
+Each time a "defer" statement
 executes, the function value and parameters to the call are
 evaluated as usual
-and saved anew but the actual function body is not executed.
-Instead, deferred functions are executed immediately before
+and saved anew but the actual function is not invoked.
+Instead, deferred functions are invoked immediately before
 the surrounding function returns, in the reverse order
 they were deferred.
+If a deferred function value evaluates
+to nil, execution panics
+when the function is invoked, not when the "defer" statement is executed.
 
    
 
 
    
@@ -5379,9 +5454,11 @@ var z complex128
 
    Allocation
    
 
 
    
-The built-in function new takes a type T and
-returns a value of type *T.
-The memory is initialized as described in the section on
+The built-in function new takes a type T,
+allocates storage for a variable of that type
+at run time, and returns a value of type *T
+pointing to it.
+The variable is initialized as described in the section on
 initial values.
 
    
 
@@ -5399,10 +5476,10 @@ new(S)
 
    
 
 
    
-dynamically allocates memory for a variable of type S,
+allocates storage for a variable of type S,
 initializes it (a=0, b=0.0),
 and returns a value of type *S containing the address
-of the memory.
+of the location.
 
    
 
 
    Making slices, maps and channels
    
@@ -5869,10 +5946,12 @@ func main() {
 
 
    The zero value
    
 
    
-When memory is allocated to store a value, either through a declaration
-or a call of make or new,
-and no explicit initialization is provided, the memory is
-given a default initialization.  Each element of such a value is
+When storage is allocated for a variable,
+either through a declaration or a call of new, or when
+a new value is created, either through a composite literal or a call
+of make,
+and no explicit initialization is provided, the variable or value is
+given a default value.  Each element of such a variable or value is
 set to the zero value for its type: false for booleans,
 0 for integers, 0.0 for floats, ""
 for strings, and nil for pointers, functions, interfaces, slices, channels, and maps.
@@ -5916,20 +5995,42 @@ var t T
 
    
 
 
    Package initialization
    
+
 
    
-Within a package, package-level variables are initialized according
-to their dependencies: if a variable x depends on
-a variable y, x will be initialized after
-y.
+Within a package, package-level variables are initialized in
+declaration order but after any of the variables
+they depend on.
+
    
+
+
    
+More precisely, a package-level variable is considered ready for
+initialization if it is not yet initialized and either has
+no initialization expression or
+its initialization expression has no dependencies on uninitialized variables.
+Initialization proceeds by repeatedly initializing the next package-level
+variable that is earliest in declaration order and ready for initialization,
+until there are no variables ready for initialization.
+
    
+
+
    
+If any variables are still uninitialized when this
+process ends, those variables are part of one or more initialization cycles,
+and the program is not valid.
+
    
+
+
    
+The declaration order of variables declared in multiple files is determined
+by the order in which the files are presented to the compiler: Variables
+declared in the first file are declared before any of the variables declared
+in the second file, and so on.
 
    
 
 
    
 Dependency analysis does not rely on the actual values of the
 variables, only on lexical references to them in the source,
-analyzed transitively. For instance, a variable x's
-initialization expression
-may refer to a function whose body refers to variable y;
-if so, x depends on y.
+analyzed transitively. For instance, if a variable x's
+initialization expression refers to a function whose body refers to
+variable y then x depends on y.
 Specifically:
 
    
 
@@ -5962,11 +6063,6 @@ or to a function or method that depends on y.
 Dependency analysis is performed per package; only references referring
 to variables, functions, and methods declared in the current package
 are considered.
-It is an error if variable dependencies form a cycle
-(but dependency cycles containing no variables are permitted).
-If two variables are independent of each other,
-they are initialized in the order they are declared
-in the source, possibly in multiple files, as presented to the compiler.
 
    
 
 
    
@@ -5989,8 +6085,6 @@ func f() int {
 
 
    
 the initialization order is d, b, c, a.
-Since b and c are independent of each other, they are
-initialized in declaration order (b before c).
 
    
 
 
    
@@ -6033,6 +6127,12 @@ the init functions: it will not invoke the next one
 until the previous one has returned.
 
    
 
+
    
+To ensure reproducible initialization behavior, build systems are encouraged
+to present multiple files belonging to the same package in lexical file name
+order to a compiler.
+
    
+
 
 
    Program execution
    
 
    
diff --git a/doc/gopher/biplane.jpg b/doc/gopher/biplane.jpg
new file mode 100644
index 0000000000..d5e666f963
Binary files /dev/null and b/doc/gopher/biplane.jpg differ
diff --git a/doc/install.html b/doc/install.html
index 2de04471c5..d6984c2447 100644
--- a/doc/install.html
+++ b/doc/install.html
@@ -6,14 +6,14 @@
 
    Download the Go distribution
    
 
 
    
-
+
 Download Go
 Click here to visit the downloads page
 
 
    
 
 
    
-Official binary
+Official binary
 distributions are available for the FreeBSD (release 8 and above), Linux, Mac OS X (Snow Leopard
 and above), and Windows operating systems and the 32-bit (386) and
 64-bit (amd64) x86 processor architectures.
@@ -70,7 +70,7 @@ first remove the existing version.
 
    Linux, Mac OS X, and FreeBSD tarballs
    
 
 
    
-Download the archive
+Download the archive
 and extract it into /usr/local, creating a Go tree in
 /usr/local/go. For example:
 
    
@@ -127,7 +127,7 @@ location.
 
    Mac OS X package installer
    
 
 
    
-Download the package file,
+Download the package file,
 open it, and follow the prompts to install the Go tools.
 The package installs the Go distribution to /usr/local/go.
 
    
@@ -150,7 +150,7 @@ MSI installer that configures your installation automatically.
 
    MSI installer
    
 
 
    
-Open the MSI file
+Open the MSI file
 and follow the prompts to install the Go tools.
 By default, the installer puts the Go distribution in c:\Go.
 
    
@@ -164,7 +164,7 @@ command prompts for the change to take effect.
 
    Zip archive
    
 
 
    
-Download the zip file and extract it into the directory of your choice (we suggest c:\Go).
+Download the zip file and extract it into the directory of your choice (we suggest c:\Go).
 
    
 
 
    
@@ -224,19 +224,12 @@ If you see the "hello, world" message then your Go installation is working.
 
 
    
 You're almost done.
-You just need to do a little more setup.
+You just need to set up your environment.
 
    
 
 
    
-
-How to Write Go Code
-Learn how to set up and use the Go tools
-
-
    
-
-
    
-The How to Write Go Code document
-provides essential setup instructions for using the Go tools.
+Read the How to Write Go Code document,
+which provides essential setup instructions for using the Go tools.
 
    
 
 
@@ -277,5 +270,3 @@ The official mailing list for discussion of the Go language is
 Report bugs using the
 Go issue tracker.
 
    
-
-
diff --git a/include/link.h b/include/link.h
index 05d063f767..c80f467580 100644
--- a/include/link.h
+++ b/include/link.h
@@ -205,10 +205,10 @@ enum
 	SELFSECT,
 	SMACHO,	/* Mach-O __nl_symbol_ptr */
 	SMACHOGOT,
+	SWINDOWS,
 	SNOPTRDATA,
 	SINITARR,
 	SDATA,
-	SWINDOWS,
 	SBSS,
 	SNOPTRBSS,
 	STLSBSS,
@@ -376,6 +376,7 @@ struct	Link
 	char*	trimpath;
 	char*	goroot;
 	char*	goroot_final;
+	int32	enforce_data_order;	// for use by assembler
 
 	// hash table of all symbols
 	LSym*	hash[LINKHASH];
@@ -395,7 +396,7 @@ struct	Link
 	LSym*	sym_divu;
 	LSym*	sym_mod;
 	LSym*	sym_modu;
-	LSym*	symmorestack[20];
+	LSym*	symmorestack[2];
 	LSym*	tlsg;
 	LSym*	plan9privates;
 	Prog*	curp;
@@ -474,6 +475,7 @@ struct LinkArch
 	int	D_PARAM;
 	int	D_SCONST;
 	int	D_STATIC;
+	int	D_OREG;
 
 	int	ACALL;
 	int	ADATA;
@@ -547,6 +549,7 @@ 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);
diff --git a/misc/cgo/test/backdoor/backdoor.go b/misc/cgo/test/backdoor/backdoor.go
index 7398772bd2..3a973494bc 100644
--- a/misc/cgo/test/backdoor/backdoor.go
+++ b/misc/cgo/test/backdoor/backdoor.go
@@ -4,5 +4,4 @@
 
 package backdoor
 
-func LockedOSThread() bool // in runtime.c
-func Issue7695(x1, x2, x3, x4, x5, x6, x7, x8 uintptr)
+func LockedOSThread() bool // in thunk.s
diff --git a/misc/cgo/test/backdoor/runtime.c b/misc/cgo/test/backdoor/runtime.c
deleted file mode 100644
index 87ee44eb6f..0000000000
--- a/misc/cgo/test/backdoor/runtime.c
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2011 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// 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;
-
-// This is what a cgo-compiled stub declaration looks like.
-void
-·Issue7695(struct{void *y[8*sizeof(void*)];}p)
-{
-	USED(p);
-}
diff --git a/misc/cgo/test/basic.go b/misc/cgo/test/basic.go
index 79cbf2b9cf..019139d010 100644
--- a/misc/cgo/test/basic.go
+++ b/misc/cgo/test/basic.go
@@ -157,3 +157,8 @@ 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
+}
diff --git a/misc/cgo/test/callback.go b/misc/cgo/test/callback.go
index 281e79494e..44167e6e9e 100644
--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -9,6 +9,10 @@ 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"
 
@@ -207,6 +211,52 @@ 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.
diff --git a/misc/cgo/test/callback_c.c b/misc/cgo/test/callback_c.c
index dcd4ddd4ee..5bb6425340 100644
--- a/misc/cgo/test/callback_c.c
+++ b/misc/cgo/test/callback_c.c
@@ -64,3 +64,19 @@ 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();
+}
+
diff --git a/misc/cgo/test/callback_c_gc.c b/misc/cgo/test/callback_c_gc.c
index 8953b74a67..28a62c6dbc 100644
--- a/misc/cgo/test/callback_c_gc.c
+++ b/misc/cgo/test/callback_c_gc.c
@@ -5,11 +5,15 @@
 // +build gc
 
 #include "_cgo_export.h"
+#include 
+#include 
+#include 
 
 /* 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)
@@ -19,3 +23,58 @@ 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);
+	}
+}
+
diff --git a/misc/cgo/test/callback_c_gccgo.c b/misc/cgo/test/callback_c_gccgo.c
index 0ea7296c62..d367b7b68b 100644
--- a/misc/cgo/test/callback_c_gccgo.c
+++ b/misc/cgo/test/callback_c_gccgo.c
@@ -5,13 +5,66 @@
 // +build gccgo
 
 #include "_cgo_export.h"
+#include 
+#include 
+#include 
 
 /* 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);
+	}
+}
+
diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go
index 3cc83060fc..3b289ba7b5 100644
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -10,50 +10,57 @@ 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 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 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 BenchmarkCgoCall(b *testing.B) { benchCgoCall(b) }
diff --git a/misc/cgo/test/exports.go b/misc/cgo/test/exports.go
index f96c60b004..4fe1703a60 100644
--- a/misc/cgo/test/exports.go
+++ b/misc/cgo/test/exports.go
@@ -5,8 +5,14 @@
 package cgotest
 
 import "C"
+import "runtime"
 
 //export ReturnIntLong
 func ReturnIntLong() (int, C.long) {
 	return 1, 2
 }
+
+//export gc
+func gc() {
+	runtime.GC()
+}
diff --git a/misc/cgo/test/issue7695_test.go b/misc/cgo/test/issue7695_test.go
deleted file mode 100644
index de2fc03d42..0000000000
--- a/misc/cgo/test/issue7695_test.go
+++ /dev/null
@@ -1,30 +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.
-
-// +build ignore
-// This test depends on running C code on Go stacks. Not allowed anymore.
-
-// Demo of deferred C function with untrue prototype
-// breaking stack copying. See golang.org/issue/7695.
-
-package cgotest
-
-import (
-	"testing"
-
-	"./backdoor"
-)
-
-func TestIssue7695(t *testing.T) {
-	defer backdoor.Issue7695(1, 0, 2, 0, 0, 3, 0, 4)
-	recurse(100)
-}
-
-func recurse(n int) {
-	var x [128]int
-	n += x[0]
-	if n > 0 {
-		recurse(n - 1)
-	}
-}
diff --git a/misc/cgo/test/issue7978.go b/misc/cgo/test/issue7978.go
new file mode 100644
index 0000000000..5feed07b95
--- /dev/null
+++ b/misc/cgo/test/issue7978.go
@@ -0,0 +1,103 @@
+// 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 7978.  Stack tracing didn't work during cgo code after calling a Go
+// callback.  Make sure GC works and the stack trace is correct.
+
+package cgotest
+
+/*
+#include 
+
+void issue7978cb(void);
+
+// use ugly atomic variable sync since that doesn't require calling back into
+// Go code or OS dependencies
+static void issue7978c(uint32_t *sync) {
+	while(__sync_fetch_and_add(sync, 0) != 0)
+		;
+	__sync_fetch_and_add(sync, 1);
+	while(__sync_fetch_and_add(sync, 0) != 2)
+		;
+	issue7978cb();
+	__sync_fetch_and_add(sync, 1);
+	while(__sync_fetch_and_add(sync, 0) != 6)
+		;
+}
+*/
+import "C"
+
+import (
+	"os"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+var issue7978sync uint32
+
+func issue7978check(t *testing.T, wantFunc string, badFunc string, depth int) {
+	runtime.GC()
+	buf := make([]byte, 65536)
+	trace := string(buf[:runtime.Stack(buf, true)])
+	for _, goroutine := range strings.Split(trace, "\n\n") {
+		if strings.Contains(goroutine, "test.issue7978go") {
+			trace := strings.Split(goroutine, "\n")
+			// look for the expected function in the stack
+			for i := 0; i < depth; i++ {
+				if badFunc != "" && strings.Contains(trace[1+2*i], badFunc) {
+					t.Errorf("bad stack: found %s in the stack:\n%s", badFunc, goroutine)
+					return
+				}
+				if strings.Contains(trace[1+2*i], wantFunc) {
+					return
+				}
+			}
+			t.Errorf("bad stack: didn't find %s in the stack:\n%s", wantFunc, goroutine)
+			return
+		}
+	}
+	t.Errorf("bad stack: goroutine not found. Full stack dump:\n%s", trace)
+}
+
+func issue7978wait(store uint32, wait uint32) {
+	if store != 0 {
+		atomic.StoreUint32(&issue7978sync, store)
+	}
+	for atomic.LoadUint32(&issue7978sync) != wait {
+		runtime.Gosched()
+	}
+}
+
+//export issue7978cb
+func issue7978cb() {
+	issue7978wait(3, 4)
+}
+
+func issue7978go() {
+	C.issue7978c((*C.uint32_t)(&issue7978sync))
+	issue7978wait(7, 8)
+}
+
+func test7978(t *testing.T) {
+	if os.Getenv("GOTRACEBACK") != "2" {
+		t.Fatalf("GOTRACEBACK must be 2")
+	}
+	issue7978sync = 0
+	go issue7978go()
+	// test in c code, before callback
+	issue7978wait(0, 1)
+	issue7978check(t, "runtime.cgocall_errno(", "", 1)
+	// test in go code, during callback
+	issue7978wait(2, 3)
+	issue7978check(t, "test.issue7978cb(", "test.issue7978go", 3)
+	// test in c code, after callback
+	issue7978wait(4, 5)
+	issue7978check(t, "runtime.cgocall_errno(", "runtime.cgocallback", 1)
+	// test in go code, after return from cgo
+	issue7978wait(6, 7)
+	issue7978check(t, "test.issue7978go(", "", 3)
+	atomic.StoreUint32(&issue7978sync, 8)
+}
diff --git a/misc/cgo/test/issue8517.go b/misc/cgo/test/issue8517.go
new file mode 100644
index 0000000000..4e431df921
--- /dev/null
+++ b/misc/cgo/test/issue8517.go
@@ -0,0 +1,13 @@
+// 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.
+
+// +build !windows
+
+package cgotest
+
+import "testing"
+
+func test8517(t *testing.T) {
+	t.Skip("skipping windows only test")
+}
diff --git a/misc/cgo/test/issue8517_windows.c b/misc/cgo/test/issue8517_windows.c
new file mode 100644
index 0000000000..a0b94c126f
--- /dev/null
+++ b/misc/cgo/test/issue8517_windows.c
@@ -0,0 +1,24 @@
+// 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 "windows.h"
+
+extern void testHandleLeaksCallback();
+
+DWORD WINAPI testHandleLeaksFunc(LPVOID lpThreadParameter)
+{
+	int i;
+	for(i = 0; i < 100; i++) {
+		testHandleLeaksCallback();
+	}
+	return 0;
+}
+
+void testHandleLeaks()
+{
+	HANDLE h;
+	h = CreateThread(NULL, 0, &testHandleLeaksFunc, 0, 0, NULL);
+	WaitForSingleObject(h, INFINITE);
+	CloseHandle(h);
+}
diff --git a/misc/cgo/test/issue8517_windows.go b/misc/cgo/test/issue8517_windows.go
new file mode 100644
index 0000000000..3782631e91
--- /dev/null
+++ b/misc/cgo/test/issue8517_windows.go
@@ -0,0 +1,45 @@
+// 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
+
+//void testHandleLeaks();
+import "C"
+
+import (
+	"syscall"
+	"testing"
+	"unsafe"
+)
+
+var issue8517counter int
+
+var (
+	kernel32              = syscall.MustLoadDLL("kernel32.dll")
+	getProcessHandleCount = kernel32.MustFindProc("GetProcessHandleCount")
+)
+
+func processHandleCount(t *testing.T) int {
+	const current_process = ^uintptr(0)
+	var c uint32
+	r, _, err := getProcessHandleCount.Call(current_process, uintptr(unsafe.Pointer(&c)))
+	if r == 0 {
+		t.Fatal(err)
+	}
+	return int(c)
+}
+
+func test8517(t *testing.T) {
+	c1 := processHandleCount(t)
+	C.testHandleLeaks()
+	c2 := processHandleCount(t)
+	if c1+issue8517counter <= c2 {
+		t.Fatalf("too many handles leaked: issue8517counter=%v c1=%v c2=%v", issue8517counter, c1, c2)
+	}
+}
+
+//export testHandleLeaksCallback
+func testHandleLeaksCallback() {
+	issue8517counter++
+}
diff --git a/misc/cgo/test/issue8694.go b/misc/cgo/test/issue8694.go
new file mode 100644
index 0000000000..643b284f6a
--- /dev/null
+++ b/misc/cgo/test/issue8694.go
@@ -0,0 +1,32 @@
+// 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 
+
+complex float complexFloatSquared(complex float a) { return a*a; }
+complex double complexDoubleSquared(complex double a) { return a*a; }
+*/
+import "C"
+
+import "testing"
+
+func test8694(t *testing.T) {
+	// Really just testing that this compiles, but check answer anyway.
+	x := complex64(2 + 3i)
+	x2 := x * x
+	cx2 := C.complexFloatSquared(x)
+	if cx2 != x2 {
+		t.Errorf("C.complexFloatSquared(%v) = %v, want %v", x, cx2, x2)
+	}
+
+	y := complex128(2 + 3i)
+	y2 := y * y
+	cy2 := C.complexDoubleSquared(y)
+	if cy2 != y2 {
+		t.Errorf("C.complexDoubleSquared(%v) = %v, want %v", y, cy2, y2)
+	}
+}
diff --git a/misc/cgo/test/backdoor/backdoor_gccgo.go b/misc/cgo/test/issue8811.c
similarity index 52%
rename from misc/cgo/test/backdoor/backdoor_gccgo.go
rename to misc/cgo/test/issue8811.c
index 514f76ec5e..584bb39342 100644
--- a/misc/cgo/test/backdoor/backdoor_gccgo.go
+++ b/misc/cgo/test/issue8811.c
@@ -2,10 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// This is the gccgo version of the stub in runtime.c.
+int issue8811Initialized = 0;
 
-// +build gccgo
-
-package backdoor
-
-func Issue7695(x1, x2, x3, x4, x5, x6, x7, x8 uintptr) {}
+void issue8811Init() {
+}
diff --git a/misc/cgo/test/issue8811.go b/misc/cgo/test/issue8811.go
new file mode 100644
index 0000000000..2e217d9356
--- /dev/null
+++ b/misc/cgo/test/issue8811.go
@@ -0,0 +1,22 @@
+// 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
+
+/*
+extern int issue8811Initialized;
+extern void issue8811Init();
+
+void issue8811Execute() {
+	if(!issue8811Initialized)
+		issue8811Init();
+}
+*/
+import "C"
+
+import "testing"
+
+func test8811(t *testing.T) {
+	C.issue8811Execute()
+}
diff --git a/misc/cgo/test/issue8828.go b/misc/cgo/test/issue8828.go
new file mode 100644
index 0000000000..304797c929
--- /dev/null
+++ b/misc/cgo/test/issue8828.go
@@ -0,0 +1,16 @@
+// compile
+
+// 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 8828: compiling a file with -compiler=gccgo fails if a .c file
+// has the same name as compiled directory.
+
+package cgotest
+
+import "./issue8828"
+
+func p() {
+	issue8828.Bar()
+}
diff --git a/misc/cgo/test/issue8828/issue8828.c b/misc/cgo/test/issue8828/issue8828.c
new file mode 100644
index 0000000000..2950f87cfb
--- /dev/null
+++ b/misc/cgo/test/issue8828/issue8828.c
@@ -0,0 +1,7 @@
+// 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.
+
+void foo()
+{
+}
diff --git a/misc/cgo/test/issue8828/trivial.go b/misc/cgo/test/issue8828/trivial.go
new file mode 100644
index 0000000000..e7b9a4e573
--- /dev/null
+++ b/misc/cgo/test/issue8828/trivial.go
@@ -0,0 +1,8 @@
+package issue8828
+
+//void foo();
+import "C"
+
+func Bar() {
+	C.foo()
+}
diff --git a/misc/makerelease/makerelease.go b/misc/makerelease/makerelease.go
index 3094856dd4..9b2373307f 100644
--- a/misc/makerelease/makerelease.go
+++ b/misc/makerelease/makerelease.go
@@ -437,7 +437,8 @@ func (b *Build) Do() error {
 		// Build package.
 		_, err = b.run(work, "candle",
 			"-nologo",
-			"-dVersion="+version,
+			"-dGoVersion="+version,
+			"-dWixGoVersion="+wixVersion(version),
 			"-dArch="+b.Arch,
 			"-dSourceDir=go",
 			installer, appfiles)
@@ -471,6 +472,22 @@ func (b *Build) Do() error {
 	return err
 }
 
+var versionRe = regexp.MustCompile(`^go([0-9]+(\.[0-9]+)*)`)
+
+// The Microsoft installer requires version format major.minor.build
+// (http://msdn.microsoft.com/en-us/library/aa370859%28v=vs.85%29.aspx).
+// Where the major and minor field has a maximum value of 255 and build 65535.
+// The offical Go version format is goMAJOR.MINOR.PATCH at $GOROOT/VERSION.
+// It's based on the Mercurial tag. Remove prefix and suffix to make the
+// installer happy.
+func wixVersion(v string) string {
+	m := versionRe.FindStringSubmatch(v)
+	if m == nil {
+		return "0.0.0"
+	}
+	return m[1]
+}
+
 // extras fetches the go.tools, go.blog, and go-tour repositories,
 // builds them and copies the resulting binaries and static assets
 // to the new GOROOT.
diff --git a/misc/makerelease/windows/installer.wxs b/misc/makerelease/windows/installer.wxs
index b170b98dc4..66e0913ba8 100644
--- a/misc/makerelease/windows/installer.wxs
+++ b/misc/makerelease/windows/installer.wxs
@@ -18,13 +18,12 @@
 
 
-    
 
  s.start {
+		// If we've run out of data but have an error, give the split function
+		// a chance to recover any remaining, possibly empty token.
+		if s.end > s.start || s.err != nil {
 			advance, token, err := s.split(s.buf[s.start:s.end], s.err != nil)
 			if err != nil {
 				s.setErr(err)
diff --git a/src/bufio/scan_test.go b/src/bufio/scan_test.go
index 3ddb25acf9..1454a8113c 100644
--- a/src/bufio/scan_test.go
+++ b/src/bufio/scan_test.go
@@ -419,3 +419,39 @@ func TestScanWordsExcessiveWhiteSpace(t *testing.T) {
 		t.Fatalf("unexpected token: %v", token)
 	}
 }
+
+// Test that empty tokens, including at end of line or end of file, are found by the scanner.
+// Issue 8672: Could miss final empty token.
+
+func commaSplit(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	for i := 0; i < len(data); i++ {
+		if data[i] == ',' {
+			return i + 1, data[:i], nil
+		}
+	}
+	if !atEOF {
+		return 0, nil, nil
+	}
+	return 0, data, nil
+}
+
+func TestEmptyTokens(t *testing.T) {
+	s := NewScanner(strings.NewReader("1,2,3,"))
+	values := []string{"1", "2", "3", ""}
+	s.Split(commaSplit)
+	var i int
+	for i = 0; i < len(values); i++ {
+		if !s.Scan() {
+			break
+		}
+		if s.Text() != values[i] {
+			t.Errorf("%d: expected %q got %q", i, values[i], s.Text())
+		}
+	}
+	if i != len(values) {
+		t.Errorf("got %d fields, expected %d", i, len(values))
+	}
+	if err := s.Err(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/src/bytes/bytes.go b/src/bytes/bytes.go
index 34c22bbfb1..7634707b3c 100644
--- a/src/bytes/bytes.go
+++ b/src/bytes/bytes.go
@@ -267,6 +267,8 @@ func Fields(s []byte) [][]byte {
 // It splits the slice s at each run of code points c satisfying f(c) and
 // returns a slice of subslices of s.  If all code points in s satisfy f(c), or
 // len(s) == 0, an empty slice is returned.
+// FieldsFunc makes no guarantees about the order in which it calls f(c).
+// If f does not return consistent results for a given c, FieldsFunc may crash.
 func FieldsFunc(s []byte, f func(rune) bool) [][]byte {
 	n := 0
 	inField := false
diff --git a/src/bytes/bytes.s b/src/bytes/bytes.s
deleted file mode 100644
index 55103bae05..0000000000
--- a/src/bytes/bytes.s
+++ /dev/null
@@ -1,5 +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.
-
-// This file is here just to make the go tool happy.
diff --git a/src/cmd/5a/lex.c b/src/cmd/5a/lex.c
index 84a17d1557..9c69709479 100644
--- a/src/cmd/5a/lex.c
+++ b/src/cmd/5a/lex.c
@@ -85,6 +85,7 @@ main(int argc, char *argv[])
 	ctxt = linknew(&linkarm);
 	ctxt->diag = yyerror;
 	ctxt->bso = &bstdout;
+	ctxt->enforce_data_order = 1;
 	Binit(&bstdout, 1, OWRITE);
 	listinit5();
 	fmtinstall('L', Lconv);
diff --git a/src/cmd/5c/cgen.c b/src/cmd/5c/cgen.c
index 9be10bf452..5a049ae628 100644
--- a/src/cmd/5c/cgen.c
+++ b/src/cmd/5c/cgen.c
@@ -366,14 +366,12 @@ _cgen(Node *n, Node *nn, int inrel)
 		if(REGARG >= 0)
 			o = reg[REGARG];
 		gargs(r, &nod, &nod1);
-		gpcdata(PCDATA_ArgSize, curarg);
 		if(l->addable < INDEXED) {
 			reglcgen(&nod, l, Z);
 			gopcode(OFUNC, Z, Z, &nod);
 			regfree(&nod);
 		} else
 			gopcode(OFUNC, Z, Z, l);
-		gpcdata(PCDATA_ArgSize, -1);
 		if(REGARG >= 0)
 			if(o != reg[REGARG])
 				reg[REGARG]--;
diff --git a/src/cmd/5c/reg.c b/src/cmd/5c/reg.c
index 2fbe031f44..9024d5f496 100644
--- a/src/cmd/5c/reg.c
+++ b/src/cmd/5c/reg.c
@@ -406,7 +406,7 @@ loop2:
 			rgp->cost = change;
 			nregion++;
 			if(nregion >= NRGN) {
-				warn(Z, "too many regions");
+				fatal(Z, "too many regions");
 				goto brk;
 			}
 			rgp++;
@@ -642,11 +642,8 @@ mkvar(Addr *a, int docon)
 	if(s)
 		if(s->name[0] == '.')
 			goto none;
-	if(nvar >= NVAR) {
-		if(debug['w'] > 1 && s)
-			warn(Z, "variable not optimized: %s", s->name);
-		goto none;
-	}
+	if(nvar >= NVAR)
+		fatal(Z, "variable not optimized: %s", s->name);
 	i = nvar;
 	nvar++;
 	v = &var[i];
diff --git a/src/cmd/5g/gg.h b/src/cmd/5g/gg.h
index 62f73c8659..00914bfa34 100644
--- a/src/cmd/5g/gg.h
+++ b/src/cmd/5g/gg.h
@@ -109,7 +109,6 @@ void	split64(Node*, Node*, Node*);
 void	splitclean(void);
 Node*	ncon(uint32 i);
 void	gtrack(Sym*);
-void	gargsize(int32);
 
 /*
  * obj.c
diff --git a/src/cmd/5g/ggen.c b/src/cmd/5g/ggen.c
index 6174e760c4..53cddb7605 100644
--- a/src/cmd/5g/ggen.c
+++ b/src/cmd/5g/ggen.c
@@ -179,28 +179,12 @@ fixautoused(Prog* p)
 void
 ginscall(Node *f, int proc)
 {
-	int32 arg;
 	Prog *p;
 	Node n1, r, r1, con;
 
 	if(f->type != T)
 		setmaxarg(f->type);
 
-	arg = -1;
-	// Most functions have a fixed-size argument block, so traceback uses that during unwind.
-	// Not all, though: there are some variadic functions in package runtime,
-	// and for those we emit call-specific metadata recorded by caller.
-	// Reflect generates functions with variable argsize (see reflect.methodValueCall/makeFuncStub),
-	// so we do this for all indirect calls as well.
-	if(f->type != T && (f->sym == S || (f->sym != S && f->sym->pkg == runtimepkg) || proc == 1 || proc == 2)) {
-		arg = f->type->argwid;
-		if(proc == 1 || proc == 2)
-			arg += 3*widthptr;
-	}
-
-	if(arg != -1)
-		gargsize(arg);
-
 	switch(proc) {
 	default:
 		fatal("ginscall: bad proc %d", proc);
@@ -297,9 +281,6 @@ ginscall(Node *f, int proc)
 		}
 		break;
 	}
-	
-	if(arg != -1)
-		gargsize(-1);
 }
 
 /*
diff --git a/src/cmd/5g/gsubr.c b/src/cmd/5g/gsubr.c
index ebd2c70a05..06e274e14d 100644
--- a/src/cmd/5g/gsubr.c
+++ b/src/cmd/5g/gsubr.c
@@ -205,16 +205,6 @@ ggloblnod(Node *nam)
 		p->reg |= NOPTR;
 }
 
-void
-gargsize(int32 size)
-{
-	Node n1, n2;
-	
-	nodconst(&n1, types[TINT32], PCDATA_ArgSize);
-	nodconst(&n2, types[TINT32], size);
-	gins(APCDATA, &n1, &n2);
-}
-
 void
 ggloblsym(Sym *s, int32 width, int8 flags)
 {
@@ -371,7 +361,7 @@ regalloc(Node *n, Type *t, Node *o)
 		print("registers allocated at\n");
 		for(i=REGALLOC_R0; i<=REGALLOC_RMAX; i++)
 			print("%d %p\n", i, regpc[i]);
-		yyerror("out of fixed registers");
+		fatal("out of fixed registers");
 		goto err;
 
 	case TFLOAT32:
@@ -384,7 +374,7 @@ regalloc(Node *n, Type *t, Node *o)
 		for(i=REGALLOC_F0; i<=REGALLOC_FMAX; i++)
 			if(reg[i] == 0)
 				goto out;
-		yyerror("out of floating point registers");
+		fatal("out of floating point registers");
 		goto err;
 
 	case TCOMPLEX64:
diff --git a/src/cmd/6a/lex.c b/src/cmd/6a/lex.c
index b50e1622e2..8973d69743 100644
--- a/src/cmd/6a/lex.c
+++ b/src/cmd/6a/lex.c
@@ -101,6 +101,7 @@ main(int argc, char *argv[])
 	ctxt = linknew(thelinkarch);
 	ctxt->diag = yyerror;
 	ctxt->bso = &bstdout;
+	ctxt->enforce_data_order = 1;
 	Binit(&bstdout, 1, OWRITE);
 	listinit6();
 	fmtinstall('L', Lconv);
diff --git a/src/cmd/6c/cgen.c b/src/cmd/6c/cgen.c
index bb09ec05d3..68dd7bb5fa 100644
--- a/src/cmd/6c/cgen.c
+++ b/src/cmd/6c/cgen.c
@@ -945,7 +945,6 @@ cgen(Node *n, Node *nn)
 			return;
 		}
 		gargs(r, &nod, &nod1);
-		gpcdata(PCDATA_ArgSize, curarg);
 		if(l->addable < INDEXED) {
 			reglcgen(&nod, l, nn);
 			nod.op = OREGISTER;
@@ -953,12 +952,9 @@ cgen(Node *n, Node *nn)
 			regfree(&nod);
 		} else
 			gopcode(OFUNC, n->type, Z, l);
-		gpcdata(PCDATA_ArgSize, -1);
 		if(REGARG >= 0 && reg[REGARG])
 			reg[REGARG]--;
 		regret(&nod, n, l->type, 1); // update maxarg if nothing else
-		gpcdata(PCDATA_ArgSize, curarg);
-		gpcdata(PCDATA_ArgSize, -1);
 		if(nn != Z)
 			gmove(&nod, nn);
 		if(nod.op == OREGISTER)
diff --git a/src/cmd/6c/reg.c b/src/cmd/6c/reg.c
index 348d747b72..6f8d3ce14d 100644
--- a/src/cmd/6c/reg.c
+++ b/src/cmd/6c/reg.c
@@ -585,14 +585,11 @@ loop2:
 			}
 			rgp->cost = change;
 			nregion++;
-			if(nregion >= NRGN) {
-				warn(Z, "too many regions");
-				goto brk;
-			}
+			if(nregion >= NRGN)
+				fatal(Z, "too many regions");
 			rgp++;
 		}
 	}
-brk:
 	qsort(region, nregion, sizeof(region[0]), rcmp);
 
 	/*
@@ -808,11 +805,8 @@ mkvar(Reg *r, Addr *a)
 			goto out;
 		v++;
 	}
-	if(nvar >= NVAR) {
-		if(debug['w'] > 1 && s)
-			warn(Z, "variable not optimized: %s", s->name);
-		goto none;
-	}
+	if(nvar >= NVAR)
+		fatal(Z, "variable not optimized: %s", s->name);
 	i = nvar;
 	nvar++;
 	v = &var[i];
diff --git a/src/cmd/6g/gg.h b/src/cmd/6g/gg.h
index 27f6c01fee..fe69d5c968 100644
--- a/src/cmd/6g/gg.h
+++ b/src/cmd/6g/gg.h
@@ -99,7 +99,6 @@ int	sudoaddable(int, Node*, Addr*);
 void	afunclit(Addr*, Node*);
 void	nodfconst(Node*, Type*, Mpflt*);
 void	gtrack(Sym*);
-void	gargsize(vlong);
 void	fixlargeoffset(Node *n);
 
 /*
diff --git a/src/cmd/6g/ggen.c b/src/cmd/6g/ggen.c
index 5a9b8418c4..363620769d 100644
--- a/src/cmd/6g/ggen.c
+++ b/src/cmd/6g/ggen.c
@@ -175,7 +175,6 @@ fixautoused(Prog *p)
 void
 ginscall(Node *f, int proc)
 {
-	int32 arg;
 	Prog *p;
 	Node reg, con;
 	Node r1;
@@ -183,21 +182,6 @@ ginscall(Node *f, int proc)
 	if(f->type != T)
 		setmaxarg(f->type);
 
-	arg = -1;
-	// Most functions have a fixed-size argument block, so traceback uses that during unwind.
-	// Not all, though: there are some variadic functions in package runtime,
-	// and for those we emit call-specific metadata recorded by caller.
-	// Reflect generates functions with variable argsize (see reflect.methodValueCall/makeFuncStub),
-	// so we do this for all indirect calls as well.
-	if(f->type != T && (f->sym == S || (f->sym != S && f->sym->pkg == runtimepkg) || proc == 1 || proc == 2)) {
-		arg = f->type->argwid;
-		if(proc == 1 || proc == 2)
-			arg += 2*widthptr;
-	}
-
-	if(arg != -1)
-		gargsize(arg);
-
 	switch(proc) {
 	default:
 		fatal("ginscall: bad proc %d", proc);
@@ -275,9 +259,6 @@ ginscall(Node *f, int proc)
 		}
 		break;
 	}
-
-	if(arg != -1)
-		gargsize(-1);
 }
 
 /*
@@ -1121,26 +1102,54 @@ clearfat(Node *nl)
 	c = w % 8;	// bytes
 	q = w / 8;	// quads
 
+	if(q < 4) {
+		// Write sequence of MOV 0, off(base) instead of using STOSQ.
+		// The hope is that although the code will be slightly longer,
+		// the MOVs will have no dependencies and pipeline better
+		// than the unrolled STOSQ loop.
+		// NOTE: Must use agen, not igen, so that optimizer sees address
+		// being taken. We are not writing on field boundaries.
+		agenr(nl, &n1, N);
+		n1.op = OINDREG;
+		nodconst(&z, types[TUINT64], 0);
+		while(q-- > 0) {
+			n1.type = z.type;
+			gins(AMOVQ, &z, &n1);
+			n1.xoffset += 8;
+		}
+		if(c >= 4) {
+			nodconst(&z, types[TUINT32], 0);
+			n1.type = z.type;
+			gins(AMOVL, &z, &n1);
+			n1.xoffset += 4;
+			c -= 4;
+		}
+		nodconst(&z, types[TUINT8], 0);
+		while(c-- > 0) {
+			n1.type = z.type;
+			gins(AMOVB, &z, &n1);
+			n1.xoffset++;
+		}
+		regfree(&n1);
+		return;
+	}
+
 	savex(D_DI, &n1, &oldn1, N, types[tptr]);
 	agen(nl, &n1);
 
 	savex(D_AX, &ax, &oldax, N, types[tptr]);
 	gconreg(AMOVL, 0, D_AX);
 
-	if(q > 128 || (q >= 4 && nacl)) {
+	if(q > 128 || nacl) {
 		gconreg(movptr, q, D_CX);
 		gins(AREP, N, N);	// repeat
 		gins(ASTOSQ, N, N);	// STOQ AL,*(DI)+
-	} else if(q >= 4) {
+	} else {
 		p = gins(ADUFFZERO, N, N);
 		p->to.type = D_ADDR;
 		p->to.sym = linksym(pkglookup("duffzero", runtimepkg));
 		// 2 and 128 = magic constants: see ../../runtime/asm_amd64.s
 		p->to.offset = 2*(128-q);
-	} else
-	while(q > 0) {
-		gins(ASTOSQ, N, N);	// STOQ AL,*(DI)+
-		q--;
 	}
 
 	z = ax;
diff --git a/src/cmd/6g/gsubr.c b/src/cmd/6g/gsubr.c
index e1ed3b3b86..5bd9246607 100644
--- a/src/cmd/6g/gsubr.c
+++ b/src/cmd/6g/gsubr.c
@@ -214,16 +214,6 @@ gtrack(Sym *s)
 	p->from.sym = linksym(s);
 }
 
-void
-gargsize(vlong size)
-{
-	Node n1, n2;
-	
-	nodconst(&n1, types[TINT32], PCDATA_ArgSize);
-	nodconst(&n2, types[TINT32], size);
-	gins(APCDATA, &n1, &n2);
-}
-
 void
 ggloblsym(Sym *s, int32 width, int8 flags)
 {
diff --git a/src/cmd/8a/lex.c b/src/cmd/8a/lex.c
index 807e48cb50..6ce6a18abe 100644
--- a/src/cmd/8a/lex.c
+++ b/src/cmd/8a/lex.c
@@ -90,6 +90,7 @@ main(int argc, char *argv[])
 	ctxt = linknew(&link386);
 	ctxt->diag = yyerror;
 	ctxt->bso = &bstdout;
+	ctxt->enforce_data_order = 1;
 	Binit(&bstdout, 1, OWRITE);
 	listinit8();
 	fmtinstall('L', Lconv);
diff --git a/src/cmd/8c/cgen.c b/src/cmd/8c/cgen.c
index 6f0f7c97fe..87e8fdad8b 100644
--- a/src/cmd/8c/cgen.c
+++ b/src/cmd/8c/cgen.c
@@ -938,7 +938,6 @@ cgen(Node *n, Node *nn)
 			return;
 		}
 		gargs(r, &nod, &nod1);
-		gpcdata(PCDATA_ArgSize, curarg);
 		if(l->addable < INDEXED) {
 			reglcgen(&nod, l, nn);
 			nod.op = OREGISTER;
@@ -946,7 +945,6 @@ cgen(Node *n, Node *nn)
 			regfree(&nod);
 		} else
 			gopcode(OFUNC, n->type, Z, l);
-		gpcdata(PCDATA_ArgSize, -1);
 		if(REGARG >= 0 && reg[REGARG])
 			reg[REGARG]--;
 		regret(&nod, n, l->type, 1); // update maxarg if nothing else
diff --git a/src/cmd/8c/reg.c b/src/cmd/8c/reg.c
index e6ba8bcb3e..ea862f3888 100644
--- a/src/cmd/8c/reg.c
+++ b/src/cmd/8c/reg.c
@@ -518,7 +518,7 @@ loop2:
 			rgp->cost = change;
 			nregion++;
 			if(nregion >= NRGN) {
-				warn(Z, "too many regions");
+				fatal(Z, "too many regions");
 				goto brk;
 			}
 			rgp++;
@@ -746,11 +746,8 @@ mkvar(Reg *r, Addr *a)
 			goto out;
 		v++;
 	}
-	if(nvar >= NVAR) {
-		if(debug['w'] > 1 && s)
-			warn(Z, "variable not optimized: %s", s->name);
-		goto none;
-	}
+	if(nvar >= NVAR)
+		fatal(Z, "variable not optimized: %s", s->name);
 	i = nvar;
 	nvar++;
 	v = &var[i];
diff --git a/src/cmd/8g/gg.h b/src/cmd/8g/gg.h
index bdefa93b5b..238f927656 100644
--- a/src/cmd/8g/gg.h
+++ b/src/cmd/8g/gg.h
@@ -114,7 +114,6 @@ void	split64(Node*, Node*, Node*);
 void	splitclean(void);
 void	nswap(Node*, Node*);
 void	gtrack(Sym*);
-void	gargsize(int32);
 /*
  * cplx.c
  */
diff --git a/src/cmd/8g/ggen.c b/src/cmd/8g/ggen.c
index 6038731f7b..6333a60bb8 100644
--- a/src/cmd/8g/ggen.c
+++ b/src/cmd/8g/ggen.c
@@ -157,7 +157,7 @@ void
 clearfat(Node *nl)
 {
 	uint32 w, c, q;
-	Node n1;
+	Node n1, z;
 	Prog *p;
 
 	/* clear a fat object */
@@ -172,6 +172,32 @@ clearfat(Node *nl)
 	c = w % 4;	// bytes
 	q = w / 4;	// quads
 
+	if(q < 4) {
+		// Write sequence of MOV 0, off(base) instead of using STOSL.
+		// The hope is that although the code will be slightly longer,
+		// the MOVs will have no dependencies and pipeline better
+		// than the unrolled STOSL loop.
+		// NOTE: Must use agen, not igen, so that optimizer sees address
+		// being taken. We are not writing on field boundaries.
+		regalloc(&n1, types[tptr], N);
+		agen(nl, &n1);
+		n1.op = OINDREG;
+		nodconst(&z, types[TUINT64], 0);
+		while(q-- > 0) {
+			n1.type = z.type;
+			gins(AMOVL, &z, &n1);
+			n1.xoffset += 4;
+		}
+		nodconst(&z, types[TUINT8], 0);
+		while(c-- > 0) {
+			n1.type = z.type;
+			gins(AMOVB, &z, &n1);
+			n1.xoffset++;
+		}
+		regfree(&n1);
+		return;
+	}
+
 	nodreg(&n1, types[tptr], D_DI);
 	agen(nl, &n1);
 	gconreg(AMOVL, 0, D_AX);
@@ -210,28 +236,12 @@ clearfat(Node *nl)
 void
 ginscall(Node *f, int proc)
 {
-	int32 arg;
 	Prog *p;
 	Node reg, r1, con;
 
 	if(f->type != T)
 		setmaxarg(f->type);
 
-	arg = -1;
-	// Most functions have a fixed-size argument block, so traceback uses that during unwind.
-	// Not all, though: there are some variadic functions in package runtime,
-	// and for those we emit call-specific metadata recorded by caller.
-	// Reflect generates functions with variable argsize (see reflect.methodValueCall/makeFuncStub),
-	// so we do this for all indirect calls as well.
-	if(f->type != T && (f->sym == S || (f->sym != S && f->sym->pkg == runtimepkg) || proc == 1 || proc == 2)) {
-		arg = f->type->argwid;
-		if(proc == 1 || proc == 2)
-			arg += 2*widthptr;
-	}
-
-	if(arg != -1)
-		gargsize(arg);
-
 	switch(proc) {
 	default:
 		fatal("ginscall: bad proc %d", proc);
@@ -293,9 +303,6 @@ ginscall(Node *f, int proc)
 		}
 		break;
 	}
-	
-	if(arg != -1)
-		gargsize(-1);
 }
 
 /*
diff --git a/src/cmd/8g/gsubr.c b/src/cmd/8g/gsubr.c
index 9f923cc9aa..3077e0ad9c 100644
--- a/src/cmd/8g/gsubr.c
+++ b/src/cmd/8g/gsubr.c
@@ -205,16 +205,6 @@ ggloblnod(Node *nam)
 		p->from.scale |= NOPTR;
 }
 
-void
-gargsize(int32 size)
-{
-	Node n1, n2;
-	
-	nodconst(&n1, types[TINT32], PCDATA_ArgSize);
-	nodconst(&n2, types[TINT32], size);
-	gins(APCDATA, &n1, &n2);
-}
-
 void
 ggloblsym(Sym *s, int32 width, int8 flags)
 {
@@ -948,7 +938,7 @@ regalloc(Node *n, Type *t, Node *o)
 		fprint(2, "registers allocated at\n");
 		for(i=D_AX; i<=D_DI; i++)
 			fprint(2, "\t%R\t%#lux\n", i, regpc[i]);
-		yyerror("out of fixed registers");
+		fatal("out of fixed registers");
 		goto err;
 
 	case TFLOAT32:
diff --git a/src/cmd/8l/asm.c b/src/cmd/8l/asm.c
index c135dce709..98c0424037 100644
--- a/src/cmd/8l/asm.c
+++ b/src/cmd/8l/asm.c
@@ -117,13 +117,21 @@ adddynrel(LSym *s, Reloc *r)
 	case 256 + R_386_GOT32:
 		if(targ->type != SDYNIMPORT) {
 			// have symbol
-			// turn MOVL of GOT entry into LEAL of symbol itself
-			if(r->off < 2 || s->p[r->off-2] != 0x8b) {
-				diag("unexpected GOT reloc for non-dynamic symbol %s", targ->name);
+			if(r->off >= 2 && s->p[r->off-2] == 0x8b) {
+				// turn MOVL of GOT entry into LEAL of symbol address, relative to GOT.
+				s->p[r->off-2] = 0x8d;
+				r->type = R_GOTOFF;
 				return;
 			}
-			s->p[r->off-2] = 0x8d;
-			r->type = R_GOTOFF;
+			if(r->off >= 2 && s->p[r->off-2] == 0xff && s->p[r->off-1] == 0xb3) {
+				// turn PUSHL of GOT entry into PUSHL of symbol itself.
+				// use unnecessary SS prefix to keep instruction same length.
+				s->p[r->off-2] = 0x36;
+				s->p[r->off-1] = 0x68;
+				r->type = R_ADDR;
+				return;
+			}
+			diag("unexpected GOT reloc for non-dynamic symbol %s", targ->name);
 			return;
 		}
 		addgotsym(ctxt, targ);
diff --git a/src/cmd/9a/lex.c b/src/cmd/9a/lex.c
index 116618f25a..bd38493d5a 100644
--- a/src/cmd/9a/lex.c
+++ b/src/cmd/9a/lex.c
@@ -100,6 +100,7 @@ main(int argc, char *argv[])
 	ctxt = linknew(thelinkarch);
 	ctxt->diag = yyerror;
 	ctxt->bso = &bstdout;
+	ctxt->enforce_data_order = 1;
 	Binit(&bstdout, 1, OWRITE);
 	listinit9();
 	fmtinstall('L', Lconv);
diff --git a/src/cmd/9c/cgen.c b/src/cmd/9c/cgen.c
index d756af93bb..bd1f7b28f6 100644
--- a/src/cmd/9c/cgen.c
+++ b/src/cmd/9c/cgen.c
@@ -342,20 +342,16 @@ cgen(Node *n, Node *nn)
 		if(REGARG >= 0)
 			o = reg[REGARG];
 		gargs(r, &nod, &nod1);
-		gpcdata(PCDATA_ArgSize, curarg);
 		if(l->addable < INDEXED) {
 			reglcgen(&nod, l, Z);
 			gopcode(OFUNC, Z, Z, &nod);
 			regfree(&nod);
 		} else
 			gopcode(OFUNC, Z, Z, l);
-		gpcdata(PCDATA_ArgSize, -1);
 		if(REGARG>=0)
 			if(o != reg[REGARG])
 				reg[REGARG]--;
 		regret(&nod, n, l->type, 1); // update maxarg if nothing else
-		gpcdata(PCDATA_ArgSize, curarg);
-		gpcdata(PCDATA_ArgSize, -1);
 		if(nn != Z)
 			gopcode(OAS, &nod, Z, nn);
 		if(nod.op == OREGISTER)
diff --git a/src/cmd/9c/reg.c b/src/cmd/9c/reg.c
index 38bb2e9def..81a7c7fe4a 100644
--- a/src/cmd/9c/reg.c
+++ b/src/cmd/9c/reg.c
@@ -378,14 +378,11 @@ loop2:
 			}
 			rgp->cost = change;
 			nregion++;
-			if(nregion >= NRGN) {
-				warn(Z, "too many regions");
-				goto brk;
-			}
+			if(nregion >= NRGN)
+				fatal(Z, "too many regions");
 			rgp++;
 		}
 	}
-brk:
 	qsort(region, nregion, sizeof(region[0]), rcmp);
 
 	/*
@@ -591,11 +588,8 @@ mkvar(Addr *a, int docon)
 	if(s)
 		if(s->name[0] == '.')
 			goto none;
-	if(nvar >= NVAR) {
-		if(debug['w'] > 1 && s)
-			warn(Z, "variable not optimized: %s", s->name);
-		goto none;
-	}
+	if(nvar >= NVAR)
+		fatal(Z, "variable not optimized: %s", s->name);
 	i = nvar;
 	nvar++;
 	v = &var[i];
diff --git a/src/cmd/9g/gg.h b/src/cmd/9g/gg.h
index 2eb516b403..703fbd0a87 100644
--- a/src/cmd/9g/gg.h
+++ b/src/cmd/9g/gg.h
@@ -94,7 +94,6 @@ int	sudoaddable(int, Node*, Addr*);
 void	afunclit(Addr*, Node*);
 void	nodfconst(Node*, Type*, Mpflt*);
 void	gtrack(Sym*);
-void	gargsize(vlong);
 void	fixlargeoffset(Node *n);
 
 /*
diff --git a/src/cmd/9g/ggen.c b/src/cmd/9g/ggen.c
index 708a9392c9..c41d8eb414 100644
--- a/src/cmd/9g/ggen.c
+++ b/src/cmd/9g/ggen.c
@@ -191,7 +191,6 @@ ginsBL(Node *reg, Node *f)
 void
 ginscall(Node *f, int proc)
 {
-	int32 arg;
 	Prog *p;
 	Node reg, con, reg2;
 	Node r1;
@@ -199,21 +198,6 @@ ginscall(Node *f, int proc)
 	if(f->type != T)
 		setmaxarg(f->type);
 
-	arg = -1;
-	// Most functions have a fixed-size argument block, so traceback uses that during unwind.
-	// Not all, though: there are some variadic functions in package runtime,
-	// and for those we emit call-specific metadata recorded by caller.
-	// Reflect generates functions with variable argsize (see reflect.methodValueCall/makeFuncStub),
-	// so we do this for all indirect calls as well.
-	if(f->type != T && (f->sym == S || (f->sym != S && f->sym->pkg == runtimepkg) || proc == 1 || proc == 2)) {
-		arg = f->type->argwid;
-		if(proc == 1 || proc == 2)
-			arg += 3*widthptr;
-	}
-
-	if(arg != -1)
-		gargsize(arg);
-
 	switch(proc) {
 	default:
 		fatal("ginscall: bad proc %d", proc);
@@ -303,9 +287,6 @@ ginscall(Node *f, int proc)
 		}
 		break;
 	}
-
-	if(arg != -1)
-		gargsize(-1);
 }
 
 /*
diff --git a/src/cmd/9g/gsubr.c b/src/cmd/9g/gsubr.c
index a84056bbef..d8b62b1da2 100644
--- a/src/cmd/9g/gsubr.c
+++ b/src/cmd/9g/gsubr.c
@@ -216,16 +216,6 @@ gtrack(Sym *s)
 	p->from.sym = linksym(s);
 }
 
-void
-gargsize(vlong size)
-{
-	Node n1, n2;
-	
-	nodconst(&n1, types[TINT32], PCDATA_ArgSize);
-	nodconst(&n2, types[TINT32], size);
-	gins(APCDATA, &n1, &n2);
-}
-
 void
 ggloblsym(Sym *s, int32 width, int8 flags)
 {
diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index fb0e984f72..5a8c876033 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -377,7 +377,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		}
 	}
 	if w.context != nil && file == fmt.Sprintf("zruntime_defs_%s_%s.go", w.context.GOOS, w.context.GOARCH) {
-		// Just enough to keep the api checker happy.
+		// Just enough to keep the api checker happy. Keep sorted.
 		src := "package runtime; type (" +
 			" _defer struct{};" +
 			" _func struct{};" +
@@ -388,6 +388,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" chantype struct{};" +
 			" context struct{};" + // windows
 			" eface struct{};" +
+			" epollevent struct{};" +
 			" funcval struct{};" +
 			" g struct{};" +
 			" gobuf struct{};" +
@@ -395,20 +396,21 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" iface struct{};" +
 			" interfacetype struct{};" +
 			" itab struct{};" +
+			" keventt struct{};" +
 			" m struct{};" +
 			" maptype struct{};" +
 			" mcache struct{};" +
 			" mspan struct{};" +
 			" mutex struct{};" +
 			" note struct{};" +
+			" p struct{};" +
+			" parfor struct{};" +
 			" slicetype struct{};" +
 			" stkframe struct{};" +
 			" sudog struct{};" +
+			" timespec struct{};" +
 			" waitq struct{};" +
 			" wincallbackcontext struct{};" +
-			" keventt struct{};" +
-			" timespec struct{};" +
-			" epollevent struct{};" +
 			"); " +
 			"const (" +
 			" cb_max = 2000;" +
@@ -422,6 +424,52 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" _Genqueue = 7;" +
 			" _Gcopystack = 8;" +
 			" _NSIG = 32;" +
+			" _FlagNoScan = iota;" +
+			" _FlagNoZero;" +
+			" _TinySize;" +
+			" _TinySizeClass;" +
+			" _MaxSmallSize;" +
+			" _PageShift;" +
+			" _PageSize;" +
+			" _PageMask;" +
+			" _BitsPerPointer;" +
+			" _BitsMask;" +
+			" _PointersPerByte;" +
+			" _MaxGCMask;" +
+			" _BitsDead;" +
+			" _BitsPointer;" +
+			" _MSpanInUse;" +
+			" _ConcurrentSweep;" +
+			" _KindBool;" +
+			" _KindInt;" +
+			" _KindInt8;" +
+			" _KindInt16;" +
+			" _KindInt32;" +
+			" _KindInt64;" +
+			" _KindUint;" +
+			" _KindUint8;" +
+			" _KindUint16;" +
+			" _KindUint32;" +
+			" _KindUint64;" +
+			" _KindUintptr;" +
+			" _KindFloat32;" +
+			" _KindFloat64;" +
+			" _KindComplex64;" +
+			" _KindComplex128;" +
+			" _KindArray;" +
+			" _KindChan;" +
+			" _KindFunc;" +
+			" _KindInterface;" +
+			" _KindMap;" +
+			" _KindPtr;" +
+			" _KindSlice;" +
+			" _KindString;" +
+			" _KindStruct;" +
+			" _KindUnsafePointer;" +
+			" _KindDirectIface;" +
+			" _KindGCProg;" +
+			" _KindNoPointers;" +
+			" _KindMask;" +
 			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
@@ -449,6 +497,11 @@ func contains(list []string, s string) bool {
 	return false
 }
 
+// The package cache doesn't operate correctly in rare (so far artificial)
+// circumstances (issue 8425). Disable before debugging non-obvious errors
+// from the type-checker.
+const usePkgCache = true
+
 var (
 	pkgCache = map[string]*types.Package{} // map tagKey to package
 	pkgTags  = map[string][]string{}       // map import dir to list of relevant tags
@@ -510,11 +563,13 @@ func (w *Walker) Import(name string) (pkg *types.Package) {
 	// If we've already done an import with the same set
 	// of relevant tags, reuse the result.
 	var key string
-	if tags, ok := pkgTags[dir]; ok {
-		key = tagKey(dir, context, tags)
-		if pkg := pkgCache[key]; pkg != nil {
-			w.imported[name] = pkg
-			return pkg
+	if usePkgCache {
+		if tags, ok := pkgTags[dir]; ok {
+			key = tagKey(dir, context, tags)
+			if pkg := pkgCache[key]; pkg != nil {
+				w.imported[name] = pkg
+				return pkg
+			}
 		}
 	}
 
@@ -527,9 +582,11 @@ func (w *Walker) Import(name string) (pkg *types.Package) {
 	}
 
 	// Save tags list first time we see a directory.
-	if _, ok := pkgTags[dir]; !ok {
-		pkgTags[dir] = info.AllTags
-		key = tagKey(dir, context, info.AllTags)
+	if usePkgCache {
+		if _, ok := pkgTags[dir]; !ok {
+			pkgTags[dir] = info.AllTags
+			key = tagKey(dir, context, info.AllTags)
+		}
 	}
 
 	filenames := append(append([]string{}, info.GoFiles...), info.CgoFiles...)
@@ -582,7 +639,9 @@ func (w *Walker) Import(name string) (pkg *types.Package) {
 		log.Fatalf("error typechecking package %s: %s (%s)", name, err, ctxt)
 	}
 
-	pkgCache[key] = pkg
+	if usePkgCache {
+		pkgCache[key] = pkg
+	}
 
 	w.imported[name] = pkg
 	return
diff --git a/src/cmd/cc/bv.c b/src/cmd/cc/bv.c
deleted file mode 100644
index 51b7f4076f..0000000000
--- a/src/cmd/cc/bv.c
+++ /dev/null
@@ -1,45 +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 
-#include "cc.h"
-
-enum {
-	WORDSIZE = sizeof(uint32),
-	WORDBITS = 32,
-};
-
-uintptr
-bvsize(uintptr n)
-{
-	return ((n + WORDBITS - 1) / WORDBITS) * WORDSIZE;
-}
-
-Bvec*
-bvalloc(int32 n)
-{
-	Bvec *bv;
-	uintptr nbytes;
-
-	if(n < 0)
-		fatal(Z, "bvalloc: initial size is negative\n");
-	nbytes = sizeof(Bvec) + bvsize(n);
-	bv = malloc(nbytes);
-	if(bv == nil)
-		fatal(Z, "bvalloc: malloc failed\n");
-	memset(bv, 0, nbytes);
-	bv->n = n;
-	return bv;
-}
-
-void
-bvset(Bvec *bv, int32 i)
-{
-	uint32 mask;
-
-	if(i < 0 || i >= bv->n)
-		fatal(Z, "bvset: index %d is out of bounds with length %d\n", i, bv->n);
-	mask = 1 << (i % WORDBITS);
-	bv->b[i / WORDBITS] |= mask;
-}
diff --git a/src/cmd/cc/cc.h b/src/cmd/cc/cc.h
index 1dae5acd90..9530f5cf66 100644
--- a/src/cmd/cc/cc.h
+++ b/src/cmd/cc/cc.h
@@ -761,12 +761,6 @@ Bits	blsh(uint);
 int	beq(Bits, Bits);
 int	bset(Bits, uint);
 
-/*
- *	bv.c
- */
-Bvec*	bvalloc(int32 n);
-void	bvset(Bvec *bv, int32 i);
-
 /*
  * dpchk.c
  */
diff --git a/src/cmd/cc/dcl.c b/src/cmd/cc/dcl.c
index 292717d688..117508fd6d 100644
--- a/src/cmd/cc/dcl.c
+++ b/src/cmd/cc/dcl.c
@@ -30,6 +30,9 @@
 
 #include 
 #include "cc.h"
+#include "../ld/textflag.h"
+
+static int haspointers(Type*);
 
 Node*
 dodecl(void (*f)(int,Type*,Sym*), int c, Type *t, Node *n)
@@ -123,7 +126,8 @@ loop:
 		if(dataflag) {
 			s->dataflag = dataflag;
 			dataflag = 0;
-		}
+		} else if(s->type != T && !haspointers(s->type))
+			s->dataflag = NOPTR;
 		firstbit = 0;
 		n->sym = s;
 		n->type = s->type;
@@ -568,9 +572,8 @@ haspointers(Type *t)
 		return 0;
 	case TARRAY:
 		return haspointers(t->link);
-	case TFUNC:
 	case TIND:
-		return 1;
+		return t->link->etype != TFUNC;
 	default:
 		return 0;
 	}
diff --git a/src/cmd/cc/godefs.c b/src/cmd/cc/godefs.c
index d3ab52fde4..d9f67f0ae5 100644
--- a/src/cmd/cc/godefs.c
+++ b/src/cmd/cc/godefs.c
@@ -353,8 +353,10 @@ godefvar(Sym *s)
 		case CSTATIC:
 		case CEXTERN:
 		case CGLOBL:
-			if(strchr(s->name, '$') != nil)	 // TODO(lvd)
-			    break;
+			if(strchr(s->name, '$') != nil)
+				break;
+			if(strncmp(s->name, "go.weak.", 8) == 0)
+				break;
 			Bprint(&outbuf, "var %U\t", s->name);
 			printtypename(t);
 			Bprint(&outbuf, "\n");
diff --git a/src/cmd/cc/lex.c b/src/cmd/cc/lex.c
index 55fc36b1e0..7c9f718c09 100644
--- a/src/cmd/cc/lex.c
+++ b/src/cmd/cc/lex.c
@@ -31,6 +31,7 @@
 #include	
 #include	"cc.h"
 #include	"y.tab.h"
+#include	"../ld/textflag.h"
 
 #ifndef	CPP
 #define	CPP	"cpp"
@@ -1317,6 +1318,7 @@ cinit(void)
 	t->width = 0;
 	symstring = slookup(".string");
 	symstring->class = CSTATIC;
+	symstring->dataflag = NOPTR;
 	symstring->type = t;
 
 	t = typ(TARRAY, types[TCHAR]);
diff --git a/src/cmd/cc/pgen.c b/src/cmd/cc/pgen.c
index 869e377dfe..2687e05a91 100644
--- a/src/cmd/cc/pgen.c
+++ b/src/cmd/cc/pgen.c
@@ -31,30 +31,6 @@
 #include "gc.h"
 #include "../../runtime/funcdata.h"
 
-enum { BitsPerPointer = 2 };
-
-static void dumpgcargs(Type *fn, Sym *sym);
-
-static Sym*
-makefuncdatasym(char *namefmt, int64 funcdatakind)
-{
-	Node nod;
-	Sym *sym;
-	static int32 nsym;
-	static char namebuf[40];
-
-	snprint(namebuf, sizeof(namebuf), namefmt, nsym++);
-	sym = slookup(namebuf);
-	sym->class = CSTATIC;
-	memset(&nod, 0, sizeof nod);
-	nod.op = ONAME;
-	nod.sym = sym;
-	nod.class = CSTATIC;
-	gins(AFUNCDATA, nodconst(funcdatakind), &nod);
-	linksym(sym)->type = SRODATA;
-	return sym;
-}
-
 int
 hasdotdotdot(Type *t)
 {
@@ -109,9 +85,6 @@ codgen(Node *n, Node *nn)
 {
 	Prog *sp;
 	Node *n1, nod, nod1;
-	Sym *gcargs;
-	Sym *gclocals;
-	int isvarargs;
 
 	cursafe = 0;
 	curarg = 0;
@@ -134,16 +107,6 @@ codgen(Node *n, Node *nn)
 	p->from.sym->cfunc = 1;
 	sp = p;
 
-	/*
-	 * generate funcdata symbol for this function.
-	 * data is filled in at the end of codgen().
-	 */
-	isvarargs = hasdotdotdot(thisfn);
-	gcargs = nil;
-	if(!isvarargs)
-		gcargs = makefuncdatasym("gcargs·%d", FUNCDATA_ArgsPointerMaps);
-	gclocals = makefuncdatasym("gclocals·%d", FUNCDATA_LocalsPointerMaps);
-
 	/*
 	 * isolate first argument
 	 */
@@ -178,22 +141,6 @@ codgen(Node *n, Node *nn)
 	if(thechar=='6' || thechar=='7')	/* [sic] */
 		maxargsafe = xround(maxargsafe, 8);
 	sp->to.offset += maxargsafe;
-
-	if(!isvarargs)
-		dumpgcargs(thisfn, gcargs);
-
-	// TODO(rsc): "stkoff" is not right. It does not account for
-	// the possibility of data stored in .safe variables.
-	// Unfortunately those move up and down just like
-	// the argument frame (and in fact dovetail with it)
-	// so the number we need is not available or even
-	// well-defined. Probably we need to make the safe
-	// area its own section.
-	// That said, we've been using stkoff for months
-	// and nothing too terrible has happened.
-	gextern(gclocals, nodconst(-stkoff), 0, 4); // locals
-	gclocals->type = typ(0, T);
-	gclocals->type->width = 4;
 }
 
 void
@@ -673,113 +620,3 @@ bcomplex(Node *n, Node *c)
 	boolgen(n, 1, Z);
 	return 0;
 }
-
-// Updates the bitvector with a set bit for each pointer containing
-// value in the type description starting at offset.
-static void
-walktype1(Type *t, int32 offset, Bvec *bv, int param)
-{
-	Type *t1;
-	int32 o;
-	int32 widthptr;
-
-	widthptr = ewidth[TIND];
-	switch(t->etype) {
-	case TCHAR:
-	case TUCHAR:
-	case TSHORT:
-	case TUSHORT:
-	case TINT:
-	case TUINT:
-	case TLONG:
-	case TULONG:
-	case TVLONG:
-	case TUVLONG:
-	case TFLOAT:
-	case TDOUBLE:
-		// non-pointer types
-		for(o = 0; o < t->width; o++)
-			bvset(bv, ((offset + t->offset + o) / widthptr) * BitsPerPointer); // 1 = live scalar
-		break;
-
-	case TIND:
-	pointer:
-		// pointer types
-		if((offset + t->offset) % widthptr != 0)
-			yyerror("unaligned pointer");
-		bvset(bv, ((offset + t->offset) / widthptr)*BitsPerPointer + 1); // 2 = live ptr
-		break;
-
-	case TARRAY:
-		if(param)	// unlike Go, C passes arrays by reference
-			goto pointer;
-		// array in struct or union is an actual array
-		for(o = 0; o < t->width; o += t->link->width)
-			walktype1(t->link, offset+o, bv, 0);
-		break;
-
-	case TSTRUCT:
-		// build map recursively
-		for(t1 = t->link; t1 != T; t1 = t1->down)
-			walktype1(t1, offset, bv, 0);
-		break;
-
-	case TUNION:
-		walktype1(t->link, offset, bv, 0);
-		break;
-
-	default:
-		yyerror("can't handle arg type %s\n", tnames[t->etype]);
-	}
-}
-
-// Compute a bit vector to describe the pointer containing locations
-// in the argument list.  Adds the data to gcsym and returns the offset
-// of end of the bit vector.
-static void
-dumpgcargs(Type *fn, Sym *sym)
-{
-	Bvec *bv;
-	Type *t;
-	int32 i;
-	int32 argbytes;
-	int32 symoffset, argoffset;
-
-	// Dump the length of the bitmap array.  This value is always one for
-	// functions written in C.
-	symoffset = 0;
-	gextern(sym, nodconst(1), symoffset, 4);
-	symoffset += 4;
-	argbytes = (argsize(1) + ewidth[TIND] - 1);
-	bv = bvalloc((argbytes  / ewidth[TIND]) * BitsPerPointer);
-	argoffset = 0;
-	if(hasdotdotdot(thisfn))
-		argoffset = align(0, fn->link, Aarg0, nil);
-	if(argoffset > 0) {
-		// The C calling convention returns structs by copying them to a
-		// location pointed to by a hidden first argument.  This first
-		// argument is a pointer.
-		if(argoffset != ewidth[TIND])
-			yyerror("passbyptr arg not the right size");
-		bvset(bv, 1); // 2 = live ptr
-	}
-	for(t = fn->down; t != T; t = t->down) {
-		if(t->etype == TVOID)
-			continue;
-		argoffset = align(argoffset, t, Aarg1, nil);
-		walktype1(t, argoffset, bv, 1);
-		argoffset = align(argoffset, t, Aarg2, nil);
-	}
-	// Dump the length of the bitmap.
-	gextern(sym, nodconst(bv->n), symoffset, 4);
-	symoffset += 4;
-	// Dump the words of the bitmap.
-	for(i = 0; i < bv->n; i += 32) {
-		gextern(sym, nodconst(bv->b[i/32]), symoffset, 4);
-		symoffset += 4;
-	}
-	free(bv);
-	// Finalize the gc symbol.
-	sym->type = typ(0, T);
-	sym->type->width = symoffset;
-}
diff --git a/src/cmd/cc/y.tab.c b/src/cmd/cc/y.tab.c
index 8588515ab9..94932efe58 100644
--- a/src/cmd/cc/y.tab.c
+++ b/src/cmd/cc/y.tab.c
@@ -1,21 +1,24 @@
-/* A Bison parser, made by GNU Bison 2.7.12-4996.  */
+/* A Bison parser, made by GNU Bison 2.3.  */
 
-/* Bison implementation for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see .  */
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -26,7 +29,7 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-   
+
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
@@ -44,7 +47,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.7.12-4996"
+#define YYBISON_VERSION "2.3"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -52,54 +55,11 @@
 /* Pure parsers.  */
 #define YYPURE 0
 
-/* Push parsers.  */
-#define YYPUSH 0
-
-/* Pull parsers.  */
-#define YYPULL 1
+/* Using locations.  */
+#define YYLSP_NEEDED 0
 
 
 
-
-/* Copy the first part of user declarations.  */
-/* Line 371 of yacc.c  */
-#line 31 "cc.y"
-
-#include 
-#include 	/* if we don't, bison will, and cc.h re-#defines getc */
-#include "cc.h"
-
-/* Line 371 of yacc.c  */
-#line 74 "y.tab.c"
-
-# ifndef YY_NULL
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULL nullptr
-#  else
-#   define YY_NULL 0
-#  endif
-# endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* In a future release of Bison, this section will be replaced
-   by #include "y.tab.h".  */
-#ifndef YY_YY_Y_TAB_H_INCLUDED
-# define YY_YY_Y_TAB_H_INCLUDED
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -256,12 +216,37 @@ extern int yydebug;
 
 
 
+
+/* Copy the first part of user declarations.  */
+#line 31 "cc.y"
+
+#include 
+#include 	/* if we don't, bison will, and cc.h re-#defines getc */
+#include "cc.h"
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
-{
-/* Line 387 of yacc.c  */
 #line 36 "cc.y"
-
+{
 	Node*	node;
 	Sym*	sym;
 	Type*	type;
@@ -285,38 +270,22 @@ typedef union YYSTYPE
 	int32	lval;
 	double	dval;
 	vlong	vval;
-
-
-/* Line 387 of yacc.c  */
-#line 292 "y.tab.c"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
+}
+/* Line 193 of yacc.c.  */
+#line 276 "y.tab.c"
+	YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
-extern YYSTYPE yylval;
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
 
 /* Copy the second part of user declarations.  */
 
-/* Line 390 of yacc.c  */
-#line 320 "y.tab.c"
+
+/* Line 216 of yacc.c.  */
+#line 289 "y.tab.c"
 
 #ifdef short
 # undef short
@@ -369,45 +338,36 @@ typedef short int yytype_int16;
 # if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include  /* INFRINGES ON USER NAME SPACE */
-#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 #  endif
 # endif
 # ifndef YY_
-#  define YY_(Msgid) Msgid
-# endif
-#endif
-
-#ifndef __attribute__
-/* This feature is available in gcc versions 2.5 and later.  */
-# if (! defined __GNUC__ || __GNUC__ < 2 \
-      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
-#  define __attribute__(Spec) /* empty */
+#  define YY_(msgid) msgid
 # endif
 #endif
 
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
-# define YYUSE(E) ((void) (E))
+# define YYUSE(e) ((void) (e))
 #else
-# define YYUSE(E) /* empty */
+# define YYUSE(e) /* empty */
 #endif
 
-
 /* Identity function, used to suppress warnings about constant conditions.  */
 #ifndef lint
-# define YYID(N) (N)
+# define YYID(n) (n)
 #else
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static int
-YYID (int yyi)
+YYID (int i)
 #else
 static int
-YYID (yyi)
-    int yyi;
+YYID (i)
+    int i;
 #endif
 {
-  return yyi;
+  return i;
 }
 #endif
 
@@ -428,12 +388,11 @@ YYID (yyi)
 #    define alloca _alloca
 #   else
 #    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 #     include  /* INFRINGES ON USER NAME SPACE */
-      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
-#     ifndef EXIT_SUCCESS
-#      define EXIT_SUCCESS 0
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
 #     endif
 #    endif
 #   endif
@@ -456,24 +415,24 @@ YYID (yyi)
 #  ifndef YYSTACK_ALLOC_MAXIMUM
 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 #  endif
-#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+#  if (defined __cplusplus && ! defined _STDLIB_H \
        && ! ((defined YYMALLOC || defined malloc) \
 	     && (defined YYFREE || defined free)))
 #   include  /* INFRINGES ON USER NAME SPACE */
-#   ifndef EXIT_SUCCESS
-#    define EXIT_SUCCESS 0
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
 #   endif
 #  endif
 #  ifndef YYMALLOC
 #   define YYMALLOC malloc
-#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 #   endif
 #  endif
 #  ifndef YYFREE
 #   define YYFREE free
-#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
+#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 void free (void *); /* INFRINGES ON USER NAME SPACE */
 #   endif
@@ -489,9 +448,9 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  yytype_int16 yyss_alloc;
-  YYSTYPE yyvs_alloc;
-};
+  yytype_int16 yyss;
+  YYSTYPE yyvs;
+  };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
@@ -502,19 +461,35 @@ union yyalloc
      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
       + YYSTACK_GAP_MAXIMUM)
 
-# define YYCOPY_NEEDED 1
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (YYID (0))
+#  endif
+# endif
 
 /* Relocate STACK from its old location to the new one.  The
    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
+# define YYSTACK_RELOCATE(Stack)					\
     do									\
       {									\
 	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
-	Stack = &yyptr->Stack_alloc;					\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 	yyptr += yynewbytes / sizeof (*yyptr);				\
       }									\
@@ -522,26 +497,6 @@ union yyalloc
 
 #endif
 
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(Dst, Src, Count) \
-      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
-#  else
-#   define YYCOPY(Dst, Src, Count)              \
-      do                                        \
-        {                                       \
-          YYSIZE_T yyi;                         \
-          for (yyi = 0; yyi < (Count); yyi++)   \
-            (Dst)[yyi] = (Src)[yyi];            \
-        }                                       \
-      while (YYID (0))
-#  endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  2
 /* YYLAST -- Last index in YYTABLE.  */
@@ -737,16 +692,16 @@ static const yytype_uint16 yyrline[] =
      794,   798,   802,   803,   810,   817,   824,   831,   838,   845,
      852,   859,   860,   863,   873,   891,   901,   919,   922,   925,
      926,   933,   932,   955,   959,   962,   967,   972,   978,   986,
-     992,   998,  1004,  1012,  1020,  1027,  1033,  1032,  1044,  1052,
-    1058,  1057,  1069,  1077,  1086,  1090,  1085,  1107,  1106,  1115,
-    1121,  1122,  1128,  1131,  1137,  1138,  1139,  1142,  1143,  1149,
-    1150,  1153,  1157,  1161,  1162,  1165,  1166,  1167,  1168,  1169,
-    1170,  1171,  1172,  1173,  1176,  1177,  1178,  1179,  1180,  1181,
-    1182,  1185,  1186,  1187,  1190,  1205,  1217,  1218
+     992,   998,  1004,  1012,  1020,  1027,  1033,  1032,  1044,  1053,
+    1059,  1058,  1070,  1078,  1087,  1091,  1086,  1108,  1107,  1116,
+    1122,  1123,  1129,  1132,  1138,  1139,  1140,  1143,  1144,  1150,
+    1151,  1154,  1158,  1162,  1163,  1166,  1167,  1168,  1169,  1170,
+    1171,  1172,  1173,  1174,  1177,  1178,  1179,  1180,  1181,  1182,
+    1183,  1186,  1187,  1188,  1191,  1206,  1218,  1219
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE || 0
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
@@ -764,16 +719,16 @@ static const char *const yytname[] =
   "LTYPEDEF", "LTYPESTR", "LUNION", "LUNSIGNED", "LWHILE", "LVOID",
   "LENUM", "LSIGNED", "LCONSTNT", "LVOLATILE", "LSET", "LSIGNOF",
   "LRESTRICT", "LINLINE", "')'", "']'", "'{'", "'}'", "'!'", "'~'",
-  "$accept", "prog", "xdecl", "$@1", "$@2", "xdlist", "$@3", "xdecor",
-  "xdecor2", "adecl", "adlist", "$@4", "pdecl", "pdlist", "edecl", "$@5",
-  "$@6", "zedlist", "edlist", "edecor", "abdecor", "abdecor1", "abdecor2",
+  "$accept", "prog", "xdecl", "@1", "@2", "xdlist", "@3", "xdecor",
+  "xdecor2", "adecl", "adlist", "@4", "pdecl", "pdlist", "edecl", "@5",
+  "@6", "zedlist", "edlist", "edecor", "abdecor", "abdecor1", "abdecor2",
   "abdecor3", "init", "qual", "qlist", "ilist", "zarglist", "arglist",
-  "block", "slist", "labels", "label", "stmnt", "forexpr", "ulstmnt",
-  "$@7", "$@8", "zcexpr", "zexpr", "lexpr", "cexpr", "expr", "xuexpr",
-  "uexpr", "pexpr", "string", "lstring", "zelist", "elist", "sbody", "@9",
-  "zctlist", "types", "tlist", "ctlist", "complex", "$@10", "$@11", "$@12",
-  "$@13", "$@14", "gctnlist", "zgnlist", "gctname", "gcnlist", "gcname",
-  "enum", "tname", "cname", "gname", "name", "tag", "ltag", YY_NULL
+  "block", "slist", "labels", "label", "stmnt", "forexpr", "ulstmnt", "@7",
+  "@8", "zcexpr", "zexpr", "lexpr", "cexpr", "expr", "xuexpr", "uexpr",
+  "pexpr", "string", "lstring", "zelist", "elist", "sbody", "@9",
+  "zctlist", "types", "tlist", "ctlist", "complex", "@10", "@11", "@12",
+  "@13", "@14", "gctnlist", "zgnlist", "gctname", "gcnlist", "gcname",
+  "enum", "tname", "cname", "gname", "name", "tag", "ltag", 0
 };
 #endif
 
@@ -855,8 +810,8 @@ static const yytype_uint8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1
 };
 
-/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
-   Performed when YYTABLE doesn't specify something else to do.  Zero
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
@@ -981,7 +936,8 @@ static const yytype_int16 yypgoto[] =
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
 #define YYTABLE_NINF -205
 static const yytype_int16 yytable[] =
 {
@@ -1106,12 +1062,6 @@ static const yytype_int16 yytable[] =
      178,   179,   180,   181,   182,   183,   184,   185,   186
 };
 
-#define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-331)))
-
-#define yytable_value_is_error(Yytable_value) \
-  YYID (0)
-
 static const yytype_int16 yycheck[] =
 {
        1,    27,    14,    91,   131,    17,    30,    58,    20,    33,
@@ -1295,50 +1245,78 @@ static const yytype_uint8 yystos[] =
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  However,
-   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
-   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
-   discussed.  */
+   Once GCC version 2 has supplanted version 1, this can go.  */
 
 #define YYFAIL		goto yyerrlab
-#if defined YYFAIL
-  /* This is here to suppress warnings from the GCC cpp's
-     -Wunused-macros.  Normally we don't worry about that warning, but
-     some users do, and we want to make it easy for users to remove
-     YYFAIL uses, which will produce warnings from Bison 2.5.  */
-#endif
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      yytoken = YYTRANSLATE (yychar);				\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
       yyerror (YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
 while (YYID (0))
 
-/* Error token number */
+
 #define YYTERROR	1
 #define YYERRCODE	256
 
 
-/* This macro is provided for backward compatibility. */
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (YYID (0))
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
 #ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+	      (Loc).first_line, (Loc).first_column,	\
+	      (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
 #endif
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
+
 #ifdef YYLEX_PARAM
 # define YYLEX yylex (YYLEX_PARAM)
 #else
@@ -1388,8 +1366,6 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep)
     YYSTYPE const * const yyvaluep;
 #endif
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
@@ -1398,7 +1374,11 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 # else
   YYUSE (yyoutput);
 # endif
-  YYUSE (yytype);
+  switch (yytype)
+    {
+      default:
+	break;
+    }
 }
 
 
@@ -1435,20 +1415,17 @@ yy_symbol_print (yyoutput, yytype, yyvaluep)
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 #else
 static void
-yy_stack_print (yybottom, yytop)
-    yytype_int16 *yybottom;
-    yytype_int16 *yytop;
+yy_stack_print (bottom, top)
+    yytype_int16 *bottom;
+    yytype_int16 *top;
 #endif
 {
   YYFPRINTF (stderr, "Stack now");
-  for (; yybottom <= yytop; yybottom++)
-    {
-      int yybot = *yybottom;
-      YYFPRINTF (stderr, " %d", yybot);
-    }
+  for (; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
   YYFPRINTF (stderr, "\n");
 }
 
@@ -1482,11 +1459,11 @@ yy_reduce_print (yyvsp, yyrule)
   /* The symbols being reduced.  */
   for (yyi = 0; yyi < yynrhs; yyi++)
     {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      fprintf (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 		       &(yyvsp[(yyi + 1) - (yynrhs)])
 		       		       );
-      YYFPRINTF (stderr, "\n");
+      fprintf (stderr, "\n");
     }
 }
 
@@ -1523,6 +1500,7 @@ int yydebug;
 # define YYMAXDEPTH 10000
 #endif
 
+
 
 #if YYERROR_VERBOSE
 
@@ -1625,145 +1603,115 @@ yytnamerr (char *yyres, const char *yystr)
 }
 # endif
 
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
-   about the unexpected token YYTOKEN for the state stack whose top is
-   YYSSP.
-
-   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
-   not large enough to hold the message.  In that case, also set
-   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
-   required number of bytes is too large to store.  */
-static int
-yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
-                yytype_int16 *yyssp, int yytoken)
+/* Copy into YYRESULT an error message about the unexpected token
+   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+   including the terminating null byte.  If YYRESULT is null, do not
+   copy anything; just return the number of bytes that would be
+   copied.  As a special case, return 0 if an ordinary "syntax error"
+   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+   size calculation.  */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
 {
-  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
-  YYSIZE_T yysize = yysize0;
-  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-  /* Internationalized format string. */
-  const char *yyformat = YY_NULL;
-  /* Arguments of yyformat. */
-  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-  /* Number of reported tokens (one for the "unexpected", one per
-     "expected"). */
-  int yycount = 0;
+  int yyn = yypact[yystate];
 
-  /* There are many possibilities here to consider:
-     - Assume YYFAIL is not used.  It's too flawed to consider.  See
-       
-       for details.  YYERROR is fine as it does not invoke this
-       function.
-     - If this state is a consistent state with a default action, then
-       the only way this function was invoked is if the default action
-       is an error action.  In that case, don't check for expected
-       tokens because there are none.
-     - The only way there can be no lookahead present (in yychar) is if
-       this state is a consistent state with a default action.  Thus,
-       detecting the absence of a lookahead is sufficient to determine
-       that there is no unexpected or expected token to report.  In that
-       case, just report a simple "syntax error".
-     - Don't assume there isn't a lookahead just because this state is a
-       consistent state with a default action.  There might have been a
-       previous inconsistent state, consistent state with a non-default
-       action, or user semantic action that manipulated yychar.
-     - Of course, the expected token list depends on states to have
-       correct lookahead information, and it depends on the parser not
-       to perform extra reductions after fetching a lookahead from the
-       scanner and before detecting a syntax error.  Thus, state merging
-       (from LALR or IELR) and default reductions corrupt the expected
-       token list.  However, the list is correct for canonical LR with
-       one exception: it will still contain any token that will not be
-       accepted due to an error action in a later state.
-  */
-  if (yytoken != YYEMPTY)
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 0;
+  else
     {
-      int yyn = yypact[*yyssp];
-      yyarg[yycount++] = yytname[yytoken];
-      if (!yypact_value_is_default (yyn))
-        {
-          /* Start YYX at -YYN if negative to avoid negative indexes in
-             YYCHECK.  In other words, skip the first -YYN actions for
-             this state because they are default actions.  */
-          int yyxbegin = yyn < 0 ? -yyn : 0;
-          /* Stay within bounds of both yycheck and yytname.  */
-          int yychecklim = YYLAST - yyn + 1;
-          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-          int yyx;
+      int yytype = YYTRANSLATE (yychar);
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      int yysize_overflow = 0;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+      int yyx;
 
-          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
-                && !yytable_value_is_error (yytable[yyx + yyn]))
-              {
-                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
-                  {
-                    yycount = 1;
-                    yysize = yysize0;
-                    break;
-                  }
-                yyarg[yycount++] = yytname[yyx];
-                {
-                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
-                  if (! (yysize <= yysize1
-                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-                    return 2;
-                  yysize = yysize1;
-                }
-              }
-        }
+# if 0
+      /* This is so xgettext sees the translatable formats that are
+	 constructed on the fly.  */
+      YY_("syntax error, unexpected %s");
+      YY_("syntax error, unexpected %s, expecting %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+      char *yyfmt;
+      char const *yyf;
+      static char const yyunexpected[] = "syntax error, unexpected %s";
+      static char const yyexpecting[] = ", expecting %s";
+      static char const yyor[] = " or %s";
+      char yyformat[sizeof yyunexpected
+		    + sizeof yyexpecting - 1
+		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+		       * (sizeof yyor - 1))];
+      char const *yyprefix = yyexpecting;
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+	 YYCHECK.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yycount = 1;
+
+      yyarg[0] = yytname[yytype];
+      yyfmt = yystpcpy (yyformat, yyunexpected);
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+	  {
+	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+	      {
+		yycount = 1;
+		yysize = yysize0;
+		yyformat[sizeof yyunexpected - 1] = '\0';
+		break;
+	      }
+	    yyarg[yycount++] = yytname[yyx];
+	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+	    yysize_overflow |= (yysize1 < yysize);
+	    yysize = yysize1;
+	    yyfmt = yystpcpy (yyfmt, yyprefix);
+	    yyprefix = yyor;
+	  }
+
+      yyf = YY_(yyformat);
+      yysize1 = yysize + yystrlen (yyf);
+      yysize_overflow |= (yysize1 < yysize);
+      yysize = yysize1;
+
+      if (yysize_overflow)
+	return YYSIZE_MAXIMUM;
+
+      if (yyresult)
+	{
+	  /* Avoid sprintf, as that infringes on the user's name space.
+	     Don't have undefined behavior even if the translation
+	     produced a string with the wrong number of "%s"s.  */
+	  char *yyp = yyresult;
+	  int yyi = 0;
+	  while ((*yyp = *yyf) != '\0')
+	    {
+	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		{
+		  yyp += yytnamerr (yyp, yyarg[yyi++]);
+		  yyf += 2;
+		}
+	      else
+		{
+		  yyp++;
+		  yyf++;
+		}
+	    }
+	}
+      return yysize;
     }
-
-  switch (yycount)
-    {
-# define YYCASE_(N, S)                      \
-      case N:                               \
-        yyformat = S;                       \
-      break
-      YYCASE_(0, YY_("syntax error"));
-      YYCASE_(1, YY_("syntax error, unexpected %s"));
-      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
-      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
-      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
-      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
-    }
-
-  {
-    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
-    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
-      return 2;
-    yysize = yysize1;
-  }
-
-  if (*yymsg_alloc < yysize)
-    {
-      *yymsg_alloc = 2 * yysize;
-      if (! (yysize <= *yymsg_alloc
-             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
-        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
-      return 1;
-    }
-
-  /* Avoid sprintf, as that infringes on the user's name space.
-     Don't have undefined behavior even if the translation
-     produced a string with the wrong number of "%s"s.  */
-  {
-    char *yyp = *yymsg;
-    int yyi = 0;
-    while ((*yyp = *yyformat) != '\0')
-      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
-        {
-          yyp += yytnamerr (yyp, yyarg[yyi++]);
-          yyformat += 2;
-        }
-      else
-        {
-          yyp++;
-          yyformat++;
-        }
-  }
-  return 0;
 }
 #endif /* YYERROR_VERBOSE */
+
 
 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
@@ -1788,31 +1736,44 @@ yydestruct (yymsg, yytype, yyvaluep)
     yymsg = "Deleting";
   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
-  YYUSE (yytype);
+  switch (yytype)
+    {
+
+      default:
+	break;
+    }
 }
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
 
 
 
-
-/* The lookahead symbol.  */
+/* The look-ahead symbol.  */
 int yychar;
 
-
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
+/* The semantic value of the look-ahead symbol.  */
+YYSTYPE yylval;
 
 /* Number of syntax errors so far.  */
 int yynerrs;
 
 
+
 /*----------.
 | yyparse.  |
 `----------*/
@@ -1839,37 +1800,14 @@ yyparse ()
 #endif
 #endif
 {
-    int yystate;
-    /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus;
-
-    /* The stacks and their tools:
-       `yyss': related to states.
-       `yyvs': related to semantic values.
-
-       Refer to the stacks through separate pointers, to allow yyoverflow
-       to reallocate them elsewhere.  */
-
-    /* The state stack.  */
-    yytype_int16 yyssa[YYINITDEPTH];
-    yytype_int16 *yyss;
-    yytype_int16 *yyssp;
-
-    /* The semantic value stack.  */
-    YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs;
-    YYSTYPE *yyvsp;
-
-    YYSIZE_T yystacksize;
-
+  
+  int yystate;
   int yyn;
   int yyresult;
-  /* Lookahead token as an internal (translated) token number.  */
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
   int yytoken = 0;
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-
 #if YYERROR_VERBOSE
   /* Buffer for error messages, and its allocated size.  */
   char yymsgbuf[128];
@@ -1877,22 +1815,54 @@ yyparse ()
   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+
+
 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
   /* The number of symbols on the RHS of the reduced rule.
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;
 
-  yyssp = yyss = yyssa;
-  yyvsp = yyvs = yyvsa;
-  yystacksize = YYINITDEPTH;
-
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
-  yychar = YYEMPTY; /* Cause a token to be read.  */
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+
   goto yysetstate;
 
 /*------------------------------------------------------------.
@@ -1919,6 +1889,7 @@ yyparse ()
 	YYSTYPE *yyvs1 = yyvs;
 	yytype_int16 *yyss1 = yyss;
 
+
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
 	   conditional around just the two extra args, but that might
@@ -1926,6 +1897,7 @@ yyparse ()
 	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
+
 		    &yystacksize);
 
 	yyss = yyss1;
@@ -1948,8 +1920,9 @@ yyparse ()
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
 	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss_alloc, yyss);
-	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+
 #  undef YYSTACK_RELOCATE
 	if (yyss1 != yyssa)
 	  YYSTACK_FREE (yyss1);
@@ -1960,6 +1933,7 @@ yyparse ()
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 
+
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
 
@@ -1969,9 +1943,6 @@ yyparse ()
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
-  if (yystate == YYFINAL)
-    YYACCEPT;
-
   goto yybackup;
 
 /*-----------.
@@ -1980,16 +1951,16 @@ yyparse ()
 yybackup:
 
   /* Do appropriate processing given the current state.  Read a
-     lookahead token if we need one and don't already have one.  */
+     look-ahead token if we need one and don't already have one.  */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
   yyn = yypact[yystate];
-  if (yypact_value_is_default (yyn))
+  if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
@@ -2015,27 +1986,29 @@ yybackup:
   yyn = yytable[yyn];
   if (yyn <= 0)
     {
-      if (yytable_value_is_error (yyn))
-        goto yyerrlab;
+      if (yyn == 0 || yyn == YYTABLE_NINF)
+	goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
 
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 
-  /* Shift the lookahead token.  */
+  /* Shift the look-ahead token.  */
   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
-  /* Discard the shifted token.  */
-  yychar = YYEMPTY;
+  /* Discard the shifted token unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
 
   yystate = yyn;
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
 
   goto yynewstate;
 
@@ -2072,7 +2045,6 @@ yyreduce:
   switch (yyn)
     {
         case 4:
-/* Line 1787 of yacc.c  */
 #line 109 "cc.y"
     {
 		dodecl(xdecl, lastclass, lasttype, Z);
@@ -2080,7 +2052,6 @@ yyreduce:
     break;
 
   case 6:
-/* Line 1787 of yacc.c  */
 #line 114 "cc.y"
     {
 		lastdcl = T;
@@ -2098,7 +2069,6 @@ yyreduce:
     break;
 
   case 7:
-/* Line 1787 of yacc.c  */
 #line 128 "cc.y"
     {
 		argmark((yyvsp[(2) - (4)].node), 1);
@@ -2106,7 +2076,6 @@ yyreduce:
     break;
 
   case 8:
-/* Line 1787 of yacc.c  */
 #line 132 "cc.y"
     {
 		Node *n;
@@ -2120,7 +2089,6 @@ yyreduce:
     break;
 
   case 9:
-/* Line 1787 of yacc.c  */
 #line 144 "cc.y"
     {
 		dodecl(xdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
@@ -2128,7 +2096,6 @@ yyreduce:
     break;
 
   case 10:
-/* Line 1787 of yacc.c  */
 #line 148 "cc.y"
     {
 		(yyvsp[(1) - (1)].node) = dodecl(xdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
@@ -2136,7 +2103,6 @@ yyreduce:
     break;
 
   case 11:
-/* Line 1787 of yacc.c  */
 #line 152 "cc.y"
     {
 		doinit((yyvsp[(1) - (4)].node)->sym, (yyvsp[(1) - (4)].node)->type, 0L, (yyvsp[(4) - (4)].node));
@@ -2144,7 +2110,6 @@ yyreduce:
     break;
 
   case 14:
-/* Line 1787 of yacc.c  */
 #line 160 "cc.y"
     {
 		(yyval.node) = new(OIND, (yyvsp[(3) - (3)].node), Z);
@@ -2153,7 +2118,6 @@ yyreduce:
     break;
 
   case 16:
-/* Line 1787 of yacc.c  */
 #line 168 "cc.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
@@ -2161,7 +2125,6 @@ yyreduce:
     break;
 
   case 17:
-/* Line 1787 of yacc.c  */
 #line 172 "cc.y"
     {
 		(yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
@@ -2169,7 +2132,6 @@ yyreduce:
     break;
 
   case 18:
-/* Line 1787 of yacc.c  */
 #line 176 "cc.y"
     {
 		(yyval.node) = new(OARRAY, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
@@ -2177,7 +2139,6 @@ yyreduce:
     break;
 
   case 19:
-/* Line 1787 of yacc.c  */
 #line 185 "cc.y"
     {
 		(yyval.node) = dodecl(adecl, lastclass, lasttype, Z);
@@ -2185,7 +2146,6 @@ yyreduce:
     break;
 
   case 20:
-/* Line 1787 of yacc.c  */
 #line 189 "cc.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
@@ -2193,7 +2153,6 @@ yyreduce:
     break;
 
   case 21:
-/* Line 1787 of yacc.c  */
 #line 195 "cc.y"
     {
 		dodecl(adecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
@@ -2202,7 +2161,6 @@ yyreduce:
     break;
 
   case 22:
-/* Line 1787 of yacc.c  */
 #line 200 "cc.y"
     {
 		(yyvsp[(1) - (1)].node) = dodecl(adecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
@@ -2210,7 +2168,6 @@ yyreduce:
     break;
 
   case 23:
-/* Line 1787 of yacc.c  */
 #line 204 "cc.y"
     {
 		int32 w;
@@ -2222,7 +2179,6 @@ yyreduce:
     break;
 
   case 24:
-/* Line 1787 of yacc.c  */
 #line 212 "cc.y"
     {
 		(yyval.node) = (yyvsp[(1) - (3)].node);
@@ -2235,7 +2191,6 @@ yyreduce:
     break;
 
   case 27:
-/* Line 1787 of yacc.c  */
 #line 229 "cc.y"
     {
 		dodecl(pdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
@@ -2243,7 +2198,6 @@ yyreduce:
     break;
 
   case 29:
-/* Line 1787 of yacc.c  */
 #line 239 "cc.y"
     {
 		lasttype = (yyvsp[(1) - (1)].type);
@@ -2251,7 +2205,6 @@ yyreduce:
     break;
 
   case 31:
-/* Line 1787 of yacc.c  */
 #line 244 "cc.y"
     {
 		lasttype = (yyvsp[(2) - (2)].type);
@@ -2259,7 +2212,6 @@ yyreduce:
     break;
 
   case 33:
-/* Line 1787 of yacc.c  */
 #line 250 "cc.y"
     {
 		lastfield = 0;
@@ -2268,7 +2220,6 @@ yyreduce:
     break;
 
   case 35:
-/* Line 1787 of yacc.c  */
 #line 258 "cc.y"
     {
 		dodecl(edecl, CXXX, lasttype, (yyvsp[(1) - (1)].node));
@@ -2276,7 +2227,6 @@ yyreduce:
     break;
 
   case 37:
-/* Line 1787 of yacc.c  */
 #line 265 "cc.y"
     {
 		lastbit = 0;
@@ -2285,7 +2235,6 @@ yyreduce:
     break;
 
   case 38:
-/* Line 1787 of yacc.c  */
 #line 270 "cc.y"
     {
 		(yyval.node) = new(OBIT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2293,7 +2242,6 @@ yyreduce:
     break;
 
   case 39:
-/* Line 1787 of yacc.c  */
 #line 274 "cc.y"
     {
 		(yyval.node) = new(OBIT, Z, (yyvsp[(2) - (2)].node));
@@ -2301,7 +2249,6 @@ yyreduce:
     break;
 
   case 40:
-/* Line 1787 of yacc.c  */
 #line 282 "cc.y"
     {
 		(yyval.node) = (Z);
@@ -2309,7 +2256,6 @@ yyreduce:
     break;
 
   case 42:
-/* Line 1787 of yacc.c  */
 #line 289 "cc.y"
     {
 		(yyval.node) = new(OIND, (Z), Z);
@@ -2318,7 +2264,6 @@ yyreduce:
     break;
 
   case 43:
-/* Line 1787 of yacc.c  */
 #line 294 "cc.y"
     {
 		(yyval.node) = new(OIND, (yyvsp[(3) - (3)].node), Z);
@@ -2327,7 +2272,6 @@ yyreduce:
     break;
 
   case 46:
-/* Line 1787 of yacc.c  */
 #line 303 "cc.y"
     {
 		(yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
@@ -2335,7 +2279,6 @@ yyreduce:
     break;
 
   case 47:
-/* Line 1787 of yacc.c  */
 #line 307 "cc.y"
     {
 		(yyval.node) = new(OARRAY, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
@@ -2343,7 +2286,6 @@ yyreduce:
     break;
 
   case 48:
-/* Line 1787 of yacc.c  */
 #line 313 "cc.y"
     {
 		(yyval.node) = new(OFUNC, (Z), Z);
@@ -2351,7 +2293,6 @@ yyreduce:
     break;
 
   case 49:
-/* Line 1787 of yacc.c  */
 #line 317 "cc.y"
     {
 		(yyval.node) = new(OARRAY, (Z), (yyvsp[(2) - (3)].node));
@@ -2359,7 +2300,6 @@ yyreduce:
     break;
 
   case 50:
-/* Line 1787 of yacc.c  */
 #line 321 "cc.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
@@ -2367,7 +2307,6 @@ yyreduce:
     break;
 
   case 52:
-/* Line 1787 of yacc.c  */
 #line 328 "cc.y"
     {
 		(yyval.node) = new(OINIT, invert((yyvsp[(2) - (3)].node)), Z);
@@ -2375,7 +2314,6 @@ yyreduce:
     break;
 
   case 53:
-/* Line 1787 of yacc.c  */
 #line 334 "cc.y"
     {
 		(yyval.node) = new(OARRAY, (yyvsp[(2) - (3)].node), Z);
@@ -2383,7 +2321,6 @@ yyreduce:
     break;
 
   case 54:
-/* Line 1787 of yacc.c  */
 #line 338 "cc.y"
     {
 		(yyval.node) = new(OELEM, Z, Z);
@@ -2392,7 +2329,6 @@ yyreduce:
     break;
 
   case 57:
-/* Line 1787 of yacc.c  */
 #line 347 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
@@ -2400,7 +2336,6 @@ yyreduce:
     break;
 
   case 59:
-/* Line 1787 of yacc.c  */
 #line 352 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
@@ -2408,7 +2343,6 @@ yyreduce:
     break;
 
   case 62:
-/* Line 1787 of yacc.c  */
 #line 360 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
@@ -2416,7 +2350,6 @@ yyreduce:
     break;
 
   case 63:
-/* Line 1787 of yacc.c  */
 #line 365 "cc.y"
     {
 		(yyval.node) = Z;
@@ -2424,7 +2357,6 @@ yyreduce:
     break;
 
   case 64:
-/* Line 1787 of yacc.c  */
 #line 369 "cc.y"
     {
 		(yyval.node) = invert((yyvsp[(1) - (1)].node));
@@ -2432,7 +2364,6 @@ yyreduce:
     break;
 
   case 66:
-/* Line 1787 of yacc.c  */
 #line 377 "cc.y"
     {
 		(yyval.node) = new(OPROTO, (yyvsp[(2) - (2)].node), Z);
@@ -2441,7 +2372,6 @@ yyreduce:
     break;
 
   case 67:
-/* Line 1787 of yacc.c  */
 #line 382 "cc.y"
     {
 		(yyval.node) = new(OPROTO, (yyvsp[(2) - (2)].node), Z);
@@ -2450,7 +2380,6 @@ yyreduce:
     break;
 
   case 68:
-/* Line 1787 of yacc.c  */
 #line 387 "cc.y"
     {
 		(yyval.node) = new(ODOTDOT, Z, Z);
@@ -2458,7 +2387,6 @@ yyreduce:
     break;
 
   case 69:
-/* Line 1787 of yacc.c  */
 #line 391 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2466,7 +2394,6 @@ yyreduce:
     break;
 
   case 70:
-/* Line 1787 of yacc.c  */
 #line 397 "cc.y"
     {
 		(yyval.node) = invert((yyvsp[(2) - (3)].node));
@@ -2478,7 +2405,6 @@ yyreduce:
     break;
 
   case 71:
-/* Line 1787 of yacc.c  */
 #line 406 "cc.y"
     {
 		(yyval.node) = Z;
@@ -2486,7 +2412,6 @@ yyreduce:
     break;
 
   case 72:
-/* Line 1787 of yacc.c  */
 #line 410 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
@@ -2494,7 +2419,6 @@ yyreduce:
     break;
 
   case 73:
-/* Line 1787 of yacc.c  */
 #line 414 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
@@ -2502,7 +2426,6 @@ yyreduce:
     break;
 
   case 75:
-/* Line 1787 of yacc.c  */
 #line 421 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
@@ -2510,7 +2433,6 @@ yyreduce:
     break;
 
   case 76:
-/* Line 1787 of yacc.c  */
 #line 427 "cc.y"
     {
 		(yyval.node) = new(OCASE, (yyvsp[(2) - (3)].node), Z);
@@ -2518,7 +2440,6 @@ yyreduce:
     break;
 
   case 77:
-/* Line 1787 of yacc.c  */
 #line 431 "cc.y"
     {
 		(yyval.node) = new(OCASE, Z, Z);
@@ -2526,7 +2447,6 @@ yyreduce:
     break;
 
   case 78:
-/* Line 1787 of yacc.c  */
 #line 435 "cc.y"
     {
 		(yyval.node) = new(OLABEL, dcllabel((yyvsp[(1) - (2)].sym), 1), Z);
@@ -2534,7 +2454,6 @@ yyreduce:
     break;
 
   case 79:
-/* Line 1787 of yacc.c  */
 #line 441 "cc.y"
     {
 		(yyval.node) = Z;
@@ -2542,7 +2461,6 @@ yyreduce:
     break;
 
   case 81:
-/* Line 1787 of yacc.c  */
 #line 446 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
@@ -2550,7 +2468,6 @@ yyreduce:
     break;
 
   case 83:
-/* Line 1787 of yacc.c  */
 #line 453 "cc.y"
     {
 		(yyval.node) = (yyvsp[(2) - (2)].node);
@@ -2558,7 +2475,6 @@ yyreduce:
     break;
 
   case 85:
-/* Line 1787 of yacc.c  */
 #line 459 "cc.y"
     {
 		markdcl();
@@ -2566,7 +2482,6 @@ yyreduce:
     break;
 
   case 86:
-/* Line 1787 of yacc.c  */
 #line 463 "cc.y"
     {
 		(yyval.node) = revertdcl();
@@ -2578,7 +2493,6 @@ yyreduce:
     break;
 
   case 87:
-/* Line 1787 of yacc.c  */
 #line 471 "cc.y"
     {
 		(yyval.node) = new(OIF, (yyvsp[(3) - (5)].node), new(OLIST, (yyvsp[(5) - (5)].node), Z));
@@ -2588,7 +2502,6 @@ yyreduce:
     break;
 
   case 88:
-/* Line 1787 of yacc.c  */
 #line 477 "cc.y"
     {
 		(yyval.node) = new(OIF, (yyvsp[(3) - (7)].node), new(OLIST, (yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)));
@@ -2600,13 +2513,11 @@ yyreduce:
     break;
 
   case 89:
-/* Line 1787 of yacc.c  */
 #line 484 "cc.y"
     { markdcl(); }
     break;
 
   case 90:
-/* Line 1787 of yacc.c  */
 #line 485 "cc.y"
     {
 		(yyval.node) = revertdcl();
@@ -2621,7 +2532,6 @@ yyreduce:
     break;
 
   case 91:
-/* Line 1787 of yacc.c  */
 #line 496 "cc.y"
     {
 		(yyval.node) = new(OWHILE, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
@@ -2629,7 +2539,6 @@ yyreduce:
     break;
 
   case 92:
-/* Line 1787 of yacc.c  */
 #line 500 "cc.y"
     {
 		(yyval.node) = new(ODWHILE, (yyvsp[(5) - (7)].node), (yyvsp[(2) - (7)].node));
@@ -2637,7 +2546,6 @@ yyreduce:
     break;
 
   case 93:
-/* Line 1787 of yacc.c  */
 #line 504 "cc.y"
     {
 		(yyval.node) = new(ORETURN, (yyvsp[(2) - (3)].node), Z);
@@ -2646,7 +2554,6 @@ yyreduce:
     break;
 
   case 94:
-/* Line 1787 of yacc.c  */
 #line 509 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -2664,7 +2571,6 @@ yyreduce:
     break;
 
   case 95:
-/* Line 1787 of yacc.c  */
 #line 523 "cc.y"
     {
 		(yyval.node) = new(OBREAK, Z, Z);
@@ -2672,7 +2578,6 @@ yyreduce:
     break;
 
   case 96:
-/* Line 1787 of yacc.c  */
 #line 527 "cc.y"
     {
 		(yyval.node) = new(OCONTINUE, Z, Z);
@@ -2680,7 +2585,6 @@ yyreduce:
     break;
 
   case 97:
-/* Line 1787 of yacc.c  */
 #line 531 "cc.y"
     {
 		(yyval.node) = new(OGOTO, dcllabel((yyvsp[(2) - (3)].sym), 0), Z);
@@ -2688,7 +2592,6 @@ yyreduce:
     break;
 
   case 98:
-/* Line 1787 of yacc.c  */
 #line 535 "cc.y"
     {
 		(yyval.node) = new(OUSED, (yyvsp[(3) - (5)].node), Z);
@@ -2696,7 +2599,6 @@ yyreduce:
     break;
 
   case 99:
-/* Line 1787 of yacc.c  */
 #line 539 "cc.y"
     {
 		(yyval.node) = new(OPREFETCH, (yyvsp[(3) - (5)].node), Z);
@@ -2704,7 +2606,6 @@ yyreduce:
     break;
 
   case 100:
-/* Line 1787 of yacc.c  */
 #line 543 "cc.y"
     {
 		(yyval.node) = new(OSET, (yyvsp[(3) - (5)].node), Z);
@@ -2712,7 +2613,6 @@ yyreduce:
     break;
 
   case 101:
-/* Line 1787 of yacc.c  */
 #line 548 "cc.y"
     {
 		(yyval.node) = Z;
@@ -2720,7 +2620,6 @@ yyreduce:
     break;
 
   case 103:
-/* Line 1787 of yacc.c  */
 #line 554 "cc.y"
     {
 		(yyval.node) = Z;
@@ -2728,7 +2627,6 @@ yyreduce:
     break;
 
   case 105:
-/* Line 1787 of yacc.c  */
 #line 561 "cc.y"
     {
 		(yyval.node) = new(OCAST, (yyvsp[(1) - (1)].node), Z);
@@ -2737,7 +2635,6 @@ yyreduce:
     break;
 
   case 107:
-/* Line 1787 of yacc.c  */
 #line 569 "cc.y"
     {
 		(yyval.node) = new(OCOMMA, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2745,7 +2642,6 @@ yyreduce:
     break;
 
   case 109:
-/* Line 1787 of yacc.c  */
 #line 576 "cc.y"
     {
 		(yyval.node) = new(OMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2753,7 +2649,6 @@ yyreduce:
     break;
 
   case 110:
-/* Line 1787 of yacc.c  */
 #line 580 "cc.y"
     {
 		(yyval.node) = new(ODIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2761,7 +2656,6 @@ yyreduce:
     break;
 
   case 111:
-/* Line 1787 of yacc.c  */
 #line 584 "cc.y"
     {
 		(yyval.node) = new(OMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2769,7 +2663,6 @@ yyreduce:
     break;
 
   case 112:
-/* Line 1787 of yacc.c  */
 #line 588 "cc.y"
     {
 		(yyval.node) = new(OADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2777,7 +2670,6 @@ yyreduce:
     break;
 
   case 113:
-/* Line 1787 of yacc.c  */
 #line 592 "cc.y"
     {
 		(yyval.node) = new(OSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2785,7 +2677,6 @@ yyreduce:
     break;
 
   case 114:
-/* Line 1787 of yacc.c  */
 #line 596 "cc.y"
     {
 		(yyval.node) = new(OASHR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2793,7 +2684,6 @@ yyreduce:
     break;
 
   case 115:
-/* Line 1787 of yacc.c  */
 #line 600 "cc.y"
     {
 		(yyval.node) = new(OASHL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2801,7 +2691,6 @@ yyreduce:
     break;
 
   case 116:
-/* Line 1787 of yacc.c  */
 #line 604 "cc.y"
     {
 		(yyval.node) = new(OLT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2809,7 +2698,6 @@ yyreduce:
     break;
 
   case 117:
-/* Line 1787 of yacc.c  */
 #line 608 "cc.y"
     {
 		(yyval.node) = new(OGT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2817,7 +2705,6 @@ yyreduce:
     break;
 
   case 118:
-/* Line 1787 of yacc.c  */
 #line 612 "cc.y"
     {
 		(yyval.node) = new(OLE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2825,7 +2712,6 @@ yyreduce:
     break;
 
   case 119:
-/* Line 1787 of yacc.c  */
 #line 616 "cc.y"
     {
 		(yyval.node) = new(OGE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2833,7 +2719,6 @@ yyreduce:
     break;
 
   case 120:
-/* Line 1787 of yacc.c  */
 #line 620 "cc.y"
     {
 		(yyval.node) = new(OEQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2841,7 +2726,6 @@ yyreduce:
     break;
 
   case 121:
-/* Line 1787 of yacc.c  */
 #line 624 "cc.y"
     {
 		(yyval.node) = new(ONE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2849,7 +2733,6 @@ yyreduce:
     break;
 
   case 122:
-/* Line 1787 of yacc.c  */
 #line 628 "cc.y"
     {
 		(yyval.node) = new(OAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2857,7 +2740,6 @@ yyreduce:
     break;
 
   case 123:
-/* Line 1787 of yacc.c  */
 #line 632 "cc.y"
     {
 		(yyval.node) = new(OXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2865,7 +2747,6 @@ yyreduce:
     break;
 
   case 124:
-/* Line 1787 of yacc.c  */
 #line 636 "cc.y"
     {
 		(yyval.node) = new(OOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2873,7 +2754,6 @@ yyreduce:
     break;
 
   case 125:
-/* Line 1787 of yacc.c  */
 #line 640 "cc.y"
     {
 		(yyval.node) = new(OANDAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2881,7 +2761,6 @@ yyreduce:
     break;
 
   case 126:
-/* Line 1787 of yacc.c  */
 #line 644 "cc.y"
     {
 		(yyval.node) = new(OOROR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2889,7 +2768,6 @@ yyreduce:
     break;
 
   case 127:
-/* Line 1787 of yacc.c  */
 #line 648 "cc.y"
     {
 		(yyval.node) = new(OCOND, (yyvsp[(1) - (5)].node), new(OLIST, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)));
@@ -2897,7 +2775,6 @@ yyreduce:
     break;
 
   case 128:
-/* Line 1787 of yacc.c  */
 #line 652 "cc.y"
     {
 		(yyval.node) = new(OAS, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2905,7 +2782,6 @@ yyreduce:
     break;
 
   case 129:
-/* Line 1787 of yacc.c  */
 #line 656 "cc.y"
     {
 		(yyval.node) = new(OASADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2913,7 +2789,6 @@ yyreduce:
     break;
 
   case 130:
-/* Line 1787 of yacc.c  */
 #line 660 "cc.y"
     {
 		(yyval.node) = new(OASSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2921,7 +2796,6 @@ yyreduce:
     break;
 
   case 131:
-/* Line 1787 of yacc.c  */
 #line 664 "cc.y"
     {
 		(yyval.node) = new(OASMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2929,7 +2803,6 @@ yyreduce:
     break;
 
   case 132:
-/* Line 1787 of yacc.c  */
 #line 668 "cc.y"
     {
 		(yyval.node) = new(OASDIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2937,7 +2810,6 @@ yyreduce:
     break;
 
   case 133:
-/* Line 1787 of yacc.c  */
 #line 672 "cc.y"
     {
 		(yyval.node) = new(OASMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2945,7 +2817,6 @@ yyreduce:
     break;
 
   case 134:
-/* Line 1787 of yacc.c  */
 #line 676 "cc.y"
     {
 		(yyval.node) = new(OASASHL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2953,7 +2824,6 @@ yyreduce:
     break;
 
   case 135:
-/* Line 1787 of yacc.c  */
 #line 680 "cc.y"
     {
 		(yyval.node) = new(OASASHR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2961,7 +2831,6 @@ yyreduce:
     break;
 
   case 136:
-/* Line 1787 of yacc.c  */
 #line 684 "cc.y"
     {
 		(yyval.node) = new(OASAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2969,7 +2838,6 @@ yyreduce:
     break;
 
   case 137:
-/* Line 1787 of yacc.c  */
 #line 688 "cc.y"
     {
 		(yyval.node) = new(OASXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2977,7 +2845,6 @@ yyreduce:
     break;
 
   case 138:
-/* Line 1787 of yacc.c  */
 #line 692 "cc.y"
     {
 		(yyval.node) = new(OASOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -2985,7 +2852,6 @@ yyreduce:
     break;
 
   case 140:
-/* Line 1787 of yacc.c  */
 #line 699 "cc.y"
     {
 		(yyval.node) = new(OCAST, (yyvsp[(5) - (5)].node), Z);
@@ -2996,7 +2862,6 @@ yyreduce:
     break;
 
   case 141:
-/* Line 1787 of yacc.c  */
 #line 706 "cc.y"
     {
 		(yyval.node) = new(OSTRUCT, (yyvsp[(6) - (7)].node), Z);
@@ -3006,7 +2871,6 @@ yyreduce:
     break;
 
   case 143:
-/* Line 1787 of yacc.c  */
 #line 715 "cc.y"
     {
 		(yyval.node) = new(OIND, (yyvsp[(2) - (2)].node), Z);
@@ -3014,7 +2878,6 @@ yyreduce:
     break;
 
   case 144:
-/* Line 1787 of yacc.c  */
 #line 719 "cc.y"
     {
 		(yyval.node) = new(OADDR, (yyvsp[(2) - (2)].node), Z);
@@ -3022,7 +2885,6 @@ yyreduce:
     break;
 
   case 145:
-/* Line 1787 of yacc.c  */
 #line 723 "cc.y"
     {
 		(yyval.node) = new(OPOS, (yyvsp[(2) - (2)].node), Z);
@@ -3030,7 +2892,6 @@ yyreduce:
     break;
 
   case 146:
-/* Line 1787 of yacc.c  */
 #line 727 "cc.y"
     {
 		(yyval.node) = new(ONEG, (yyvsp[(2) - (2)].node), Z);
@@ -3038,7 +2899,6 @@ yyreduce:
     break;
 
   case 147:
-/* Line 1787 of yacc.c  */
 #line 731 "cc.y"
     {
 		(yyval.node) = new(ONOT, (yyvsp[(2) - (2)].node), Z);
@@ -3046,7 +2906,6 @@ yyreduce:
     break;
 
   case 148:
-/* Line 1787 of yacc.c  */
 #line 735 "cc.y"
     {
 		(yyval.node) = new(OCOM, (yyvsp[(2) - (2)].node), Z);
@@ -3054,7 +2913,6 @@ yyreduce:
     break;
 
   case 149:
-/* Line 1787 of yacc.c  */
 #line 739 "cc.y"
     {
 		(yyval.node) = new(OPREINC, (yyvsp[(2) - (2)].node), Z);
@@ -3062,7 +2920,6 @@ yyreduce:
     break;
 
   case 150:
-/* Line 1787 of yacc.c  */
 #line 743 "cc.y"
     {
 		(yyval.node) = new(OPREDEC, (yyvsp[(2) - (2)].node), Z);
@@ -3070,7 +2927,6 @@ yyreduce:
     break;
 
   case 151:
-/* Line 1787 of yacc.c  */
 #line 747 "cc.y"
     {
 		(yyval.node) = new(OSIZE, (yyvsp[(2) - (2)].node), Z);
@@ -3078,7 +2934,6 @@ yyreduce:
     break;
 
   case 152:
-/* Line 1787 of yacc.c  */
 #line 751 "cc.y"
     {
 		(yyval.node) = new(OSIGN, (yyvsp[(2) - (2)].node), Z);
@@ -3086,7 +2941,6 @@ yyreduce:
     break;
 
   case 153:
-/* Line 1787 of yacc.c  */
 #line 757 "cc.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
@@ -3094,7 +2948,6 @@ yyreduce:
     break;
 
   case 154:
-/* Line 1787 of yacc.c  */
 #line 761 "cc.y"
     {
 		(yyval.node) = new(OSIZE, Z, Z);
@@ -3104,7 +2957,6 @@ yyreduce:
     break;
 
   case 155:
-/* Line 1787 of yacc.c  */
 #line 767 "cc.y"
     {
 		(yyval.node) = new(OSIGN, Z, Z);
@@ -3114,7 +2966,6 @@ yyreduce:
     break;
 
   case 156:
-/* Line 1787 of yacc.c  */
 #line 773 "cc.y"
     {
 		(yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), Z);
@@ -3126,7 +2977,6 @@ yyreduce:
     break;
 
   case 157:
-/* Line 1787 of yacc.c  */
 #line 781 "cc.y"
     {
 		(yyval.node) = new(OIND, new(OADD, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)), Z);
@@ -3134,7 +2984,6 @@ yyreduce:
     break;
 
   case 158:
-/* Line 1787 of yacc.c  */
 #line 785 "cc.y"
     {
 		(yyval.node) = new(ODOT, new(OIND, (yyvsp[(1) - (3)].node), Z), Z);
@@ -3143,7 +2992,6 @@ yyreduce:
     break;
 
   case 159:
-/* Line 1787 of yacc.c  */
 #line 790 "cc.y"
     {
 		(yyval.node) = new(ODOT, (yyvsp[(1) - (3)].node), Z);
@@ -3152,7 +3000,6 @@ yyreduce:
     break;
 
   case 160:
-/* Line 1787 of yacc.c  */
 #line 795 "cc.y"
     {
 		(yyval.node) = new(OPOSTINC, (yyvsp[(1) - (2)].node), Z);
@@ -3160,7 +3007,6 @@ yyreduce:
     break;
 
   case 161:
-/* Line 1787 of yacc.c  */
 #line 799 "cc.y"
     {
 		(yyval.node) = new(OPOSTDEC, (yyvsp[(1) - (2)].node), Z);
@@ -3168,7 +3014,6 @@ yyreduce:
     break;
 
   case 163:
-/* Line 1787 of yacc.c  */
 #line 804 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3179,7 +3024,6 @@ yyreduce:
     break;
 
   case 164:
-/* Line 1787 of yacc.c  */
 #line 811 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3190,7 +3034,6 @@ yyreduce:
     break;
 
   case 165:
-/* Line 1787 of yacc.c  */
 #line 818 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3201,7 +3044,6 @@ yyreduce:
     break;
 
   case 166:
-/* Line 1787 of yacc.c  */
 #line 825 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3212,7 +3054,6 @@ yyreduce:
     break;
 
   case 167:
-/* Line 1787 of yacc.c  */
 #line 832 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3223,7 +3064,6 @@ yyreduce:
     break;
 
   case 168:
-/* Line 1787 of yacc.c  */
 #line 839 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3234,7 +3074,6 @@ yyreduce:
     break;
 
   case 169:
-/* Line 1787 of yacc.c  */
 #line 846 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3245,7 +3084,6 @@ yyreduce:
     break;
 
   case 170:
-/* Line 1787 of yacc.c  */
 #line 853 "cc.y"
     {
 		(yyval.node) = new(OCONST, Z, Z);
@@ -3256,7 +3094,6 @@ yyreduce:
     break;
 
   case 173:
-/* Line 1787 of yacc.c  */
 #line 864 "cc.y"
     {
 		(yyval.node) = new(OSTRING, Z, Z);
@@ -3270,7 +3107,6 @@ yyreduce:
     break;
 
   case 174:
-/* Line 1787 of yacc.c  */
 #line 874 "cc.y"
     {
 		char *s;
@@ -3290,7 +3126,6 @@ yyreduce:
     break;
 
   case 175:
-/* Line 1787 of yacc.c  */
 #line 892 "cc.y"
     {
 		(yyval.node) = new(OLSTRING, Z, Z);
@@ -3304,7 +3139,6 @@ yyreduce:
     break;
 
   case 176:
-/* Line 1787 of yacc.c  */
 #line 902 "cc.y"
     {
 		char *s;
@@ -3324,7 +3158,6 @@ yyreduce:
     break;
 
   case 177:
-/* Line 1787 of yacc.c  */
 #line 919 "cc.y"
     {
 		(yyval.node) = Z;
@@ -3332,7 +3165,6 @@ yyreduce:
     break;
 
   case 180:
-/* Line 1787 of yacc.c  */
 #line 927 "cc.y"
     {
 		(yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
@@ -3340,7 +3172,6 @@ yyreduce:
     break;
 
   case 181:
-/* Line 1787 of yacc.c  */
 #line 933 "cc.y"
     {
 		(yyval.tyty).t1 = strf;
@@ -3357,7 +3188,6 @@ yyreduce:
     break;
 
   case 182:
-/* Line 1787 of yacc.c  */
 #line 946 "cc.y"
     {
 		(yyval.type) = strf;
@@ -3369,7 +3199,6 @@ yyreduce:
     break;
 
   case 183:
-/* Line 1787 of yacc.c  */
 #line 955 "cc.y"
     {
 		lastclass = CXXX;
@@ -3378,7 +3207,6 @@ yyreduce:
     break;
 
   case 185:
-/* Line 1787 of yacc.c  */
 #line 963 "cc.y"
     {
 		(yyval.tycl).t = (yyvsp[(1) - (1)].type);
@@ -3387,7 +3215,6 @@ yyreduce:
     break;
 
   case 186:
-/* Line 1787 of yacc.c  */
 #line 968 "cc.y"
     {
 		(yyval.tycl).t = simplet((yyvsp[(1) - (1)].lval));
@@ -3396,7 +3223,6 @@ yyreduce:
     break;
 
   case 187:
-/* Line 1787 of yacc.c  */
 #line 973 "cc.y"
     {
 		(yyval.tycl).t = simplet((yyvsp[(1) - (1)].lval));
@@ -3406,7 +3232,6 @@ yyreduce:
     break;
 
   case 188:
-/* Line 1787 of yacc.c  */
 #line 979 "cc.y"
     {
 		(yyval.tycl).t = (yyvsp[(1) - (2)].type);
@@ -3418,7 +3243,6 @@ yyreduce:
     break;
 
   case 189:
-/* Line 1787 of yacc.c  */
 #line 987 "cc.y"
     {
 		(yyval.tycl).t = simplet(typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval)));
@@ -3428,7 +3252,6 @@ yyreduce:
     break;
 
   case 190:
-/* Line 1787 of yacc.c  */
 #line 993 "cc.y"
     {
 		(yyval.tycl).t = (yyvsp[(2) - (3)].type);
@@ -3438,7 +3261,6 @@ yyreduce:
     break;
 
   case 191:
-/* Line 1787 of yacc.c  */
 #line 999 "cc.y"
     {
 		(yyval.tycl).t = simplet((yyvsp[(2) - (2)].lval));
@@ -3448,7 +3270,6 @@ yyreduce:
     break;
 
   case 192:
-/* Line 1787 of yacc.c  */
 #line 1005 "cc.y"
     {
 		(yyval.tycl).t = simplet(typebitor((yyvsp[(2) - (3)].lval), (yyvsp[(3) - (3)].lval)));
@@ -3458,7 +3279,6 @@ yyreduce:
     break;
 
   case 193:
-/* Line 1787 of yacc.c  */
 #line 1013 "cc.y"
     {
 		(yyval.type) = (yyvsp[(1) - (1)].tycl).t;
@@ -3468,7 +3288,6 @@ yyreduce:
     break;
 
   case 194:
-/* Line 1787 of yacc.c  */
 #line 1021 "cc.y"
     {
 		lasttype = (yyvsp[(1) - (1)].tycl).t;
@@ -3477,7 +3296,6 @@ yyreduce:
     break;
 
   case 195:
-/* Line 1787 of yacc.c  */
 #line 1028 "cc.y"
     {
 		dotag((yyvsp[(2) - (2)].sym), TSTRUCT, 0);
@@ -3486,7 +3304,6 @@ yyreduce:
     break;
 
   case 196:
-/* Line 1787 of yacc.c  */
 #line 1033 "cc.y"
     {
 		dotag((yyvsp[(2) - (2)].sym), TSTRUCT, autobn);
@@ -3494,7 +3311,6 @@ yyreduce:
     break;
 
   case 197:
-/* Line 1787 of yacc.c  */
 #line 1037 "cc.y"
     {
 		(yyval.type) = (yyvsp[(2) - (4)].sym)->suetag;
@@ -3506,9 +3322,9 @@ yyreduce:
     break;
 
   case 198:
-/* Line 1787 of yacc.c  */
 #line 1045 "cc.y"
     {
+		diag(Z, "struct must have tag");
 		taggen++;
 		sprint(symb, "_%d_", taggen);
 		(yyval.type) = dotag(lookup(), TSTRUCT, autobn);
@@ -3518,8 +3334,7 @@ yyreduce:
     break;
 
   case 199:
-/* Line 1787 of yacc.c  */
-#line 1053 "cc.y"
+#line 1054 "cc.y"
     {
 		dotag((yyvsp[(2) - (2)].sym), TUNION, 0);
 		(yyval.type) = (yyvsp[(2) - (2)].sym)->suetag;
@@ -3527,16 +3342,14 @@ yyreduce:
     break;
 
   case 200:
-/* Line 1787 of yacc.c  */
-#line 1058 "cc.y"
+#line 1059 "cc.y"
     {
 		dotag((yyvsp[(2) - (2)].sym), TUNION, autobn);
 	}
     break;
 
   case 201:
-/* Line 1787 of yacc.c  */
-#line 1062 "cc.y"
+#line 1063 "cc.y"
     {
 		(yyval.type) = (yyvsp[(2) - (4)].sym)->suetag;
 		if((yyval.type)->link != T)
@@ -3547,8 +3360,7 @@ yyreduce:
     break;
 
   case 202:
-/* Line 1787 of yacc.c  */
-#line 1070 "cc.y"
+#line 1071 "cc.y"
     {
 		taggen++;
 		sprint(symb, "_%d_", taggen);
@@ -3559,8 +3371,7 @@ yyreduce:
     break;
 
   case 203:
-/* Line 1787 of yacc.c  */
-#line 1078 "cc.y"
+#line 1079 "cc.y"
     {
 		dotag((yyvsp[(2) - (2)].sym), TENUM, 0);
 		(yyval.type) = (yyvsp[(2) - (2)].sym)->suetag;
@@ -3571,16 +3382,14 @@ yyreduce:
     break;
 
   case 204:
-/* Line 1787 of yacc.c  */
-#line 1086 "cc.y"
+#line 1087 "cc.y"
     {
 		dotag((yyvsp[(2) - (2)].sym), TENUM, autobn);
 	}
     break;
 
   case 205:
-/* Line 1787 of yacc.c  */
-#line 1090 "cc.y"
+#line 1091 "cc.y"
     {
 		en.tenum = T;
 		en.cenum = T;
@@ -3588,8 +3397,7 @@ yyreduce:
     break;
 
   case 206:
-/* Line 1787 of yacc.c  */
-#line 1095 "cc.y"
+#line 1096 "cc.y"
     {
 		(yyval.type) = (yyvsp[(2) - (7)].sym)->suetag;
 		if((yyval.type)->link != T)
@@ -3604,8 +3412,7 @@ yyreduce:
     break;
 
   case 207:
-/* Line 1787 of yacc.c  */
-#line 1107 "cc.y"
+#line 1108 "cc.y"
     {
 		en.tenum = T;
 		en.cenum = T;
@@ -3613,186 +3420,158 @@ yyreduce:
     break;
 
   case 208:
-/* Line 1787 of yacc.c  */
-#line 1112 "cc.y"
+#line 1113 "cc.y"
     {
 		(yyval.type) = en.tenum;
 	}
     break;
 
   case 209:
-/* Line 1787 of yacc.c  */
-#line 1116 "cc.y"
+#line 1117 "cc.y"
     {
 		(yyval.type) = tcopy((yyvsp[(1) - (1)].sym)->type);
 	}
     break;
 
   case 211:
-/* Line 1787 of yacc.c  */
-#line 1123 "cc.y"
+#line 1124 "cc.y"
     {
 		(yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval));
 	}
     break;
 
   case 212:
-/* Line 1787 of yacc.c  */
-#line 1128 "cc.y"
+#line 1129 "cc.y"
     {
 		(yyval.lval) = 0;
 	}
     break;
 
   case 213:
-/* Line 1787 of yacc.c  */
-#line 1132 "cc.y"
+#line 1133 "cc.y"
     {
 		(yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval));
 	}
     break;
 
   case 218:
-/* Line 1787 of yacc.c  */
-#line 1144 "cc.y"
+#line 1145 "cc.y"
     {
 		(yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval));
 	}
     break;
 
   case 221:
-/* Line 1787 of yacc.c  */
-#line 1154 "cc.y"
+#line 1155 "cc.y"
     {
 		doenum((yyvsp[(1) - (1)].sym), Z);
 	}
     break;
 
   case 222:
-/* Line 1787 of yacc.c  */
-#line 1158 "cc.y"
+#line 1159 "cc.y"
     {
 		doenum((yyvsp[(1) - (3)].sym), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 225:
-/* Line 1787 of yacc.c  */
-#line 1165 "cc.y"
+#line 1166 "cc.y"
     { (yyval.lval) = BCHAR; }
     break;
 
   case 226:
-/* Line 1787 of yacc.c  */
-#line 1166 "cc.y"
+#line 1167 "cc.y"
     { (yyval.lval) = BSHORT; }
     break;
 
   case 227:
-/* Line 1787 of yacc.c  */
-#line 1167 "cc.y"
+#line 1168 "cc.y"
     { (yyval.lval) = BINT; }
     break;
 
   case 228:
-/* Line 1787 of yacc.c  */
-#line 1168 "cc.y"
+#line 1169 "cc.y"
     { (yyval.lval) = BLONG; }
     break;
 
   case 229:
-/* Line 1787 of yacc.c  */
-#line 1169 "cc.y"
+#line 1170 "cc.y"
     { (yyval.lval) = BSIGNED; }
     break;
 
   case 230:
-/* Line 1787 of yacc.c  */
-#line 1170 "cc.y"
+#line 1171 "cc.y"
     { (yyval.lval) = BUNSIGNED; }
     break;
 
   case 231:
-/* Line 1787 of yacc.c  */
-#line 1171 "cc.y"
+#line 1172 "cc.y"
     { (yyval.lval) = BFLOAT; }
     break;
 
   case 232:
-/* Line 1787 of yacc.c  */
-#line 1172 "cc.y"
+#line 1173 "cc.y"
     { (yyval.lval) = BDOUBLE; }
     break;
 
   case 233:
-/* Line 1787 of yacc.c  */
-#line 1173 "cc.y"
+#line 1174 "cc.y"
     { (yyval.lval) = BVOID; }
     break;
 
   case 234:
-/* Line 1787 of yacc.c  */
-#line 1176 "cc.y"
+#line 1177 "cc.y"
     { (yyval.lval) = BAUTO; }
     break;
 
   case 235:
-/* Line 1787 of yacc.c  */
-#line 1177 "cc.y"
+#line 1178 "cc.y"
     { (yyval.lval) = BSTATIC; }
     break;
 
   case 236:
-/* Line 1787 of yacc.c  */
-#line 1178 "cc.y"
+#line 1179 "cc.y"
     { (yyval.lval) = BEXTERN; }
     break;
 
   case 237:
-/* Line 1787 of yacc.c  */
-#line 1179 "cc.y"
+#line 1180 "cc.y"
     { (yyval.lval) = BTYPEDEF; }
     break;
 
   case 238:
-/* Line 1787 of yacc.c  */
-#line 1180 "cc.y"
+#line 1181 "cc.y"
     { (yyval.lval) = BTYPESTR; }
     break;
 
   case 239:
-/* Line 1787 of yacc.c  */
-#line 1181 "cc.y"
+#line 1182 "cc.y"
     { (yyval.lval) = BREGISTER; }
     break;
 
   case 240:
-/* Line 1787 of yacc.c  */
-#line 1182 "cc.y"
+#line 1183 "cc.y"
     { (yyval.lval) = 0; }
     break;
 
   case 241:
-/* Line 1787 of yacc.c  */
-#line 1185 "cc.y"
+#line 1186 "cc.y"
     { (yyval.lval) = BCONSTNT; }
     break;
 
   case 242:
-/* Line 1787 of yacc.c  */
-#line 1186 "cc.y"
+#line 1187 "cc.y"
     { (yyval.lval) = BVOLATILE; }
     break;
 
   case 243:
-/* Line 1787 of yacc.c  */
-#line 1187 "cc.y"
+#line 1188 "cc.y"
     { (yyval.lval) = 0; }
     break;
 
   case 244:
-/* Line 1787 of yacc.c  */
-#line 1191 "cc.y"
+#line 1192 "cc.y"
     {
 		(yyval.node) = new(ONAME, Z, Z);
 		if((yyvsp[(1) - (1)].sym)->class == CLOCAL)
@@ -3809,8 +3588,7 @@ yyreduce:
     break;
 
   case 245:
-/* Line 1787 of yacc.c  */
-#line 1206 "cc.y"
+#line 1207 "cc.y"
     {
 		(yyval.node) = new(ONAME, Z, Z);
 		(yyval.node)->sym = (yyvsp[(1) - (1)].sym);
@@ -3824,21 +3602,10 @@ yyreduce:
     break;
 
 
-/* Line 1787 of yacc.c  */
-#line 3829 "y.tab.c"
+/* Line 1267 of yacc.c.  */
+#line 3607 "y.tab.c"
       default: break;
     }
-  /* User semantic actions sometimes alter yychar, and that requires
-     that yytoken be updated with the new translation.  We take the
-     approach of translating immediately before every use of yytoken.
-     One alternative is translating here after every semantic action,
-     but that translation would be missed if the semantic action invokes
-     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
-     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
-     incorrect destructor might then be invoked immediately.  In the
-     case of YYERROR or YYBACKUP, subsequent parser actions might lead
-     to an incorrect destructor call or verbose syntax error message
-     before the lookahead is translated.  */
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
   YYPOPSTACK (yylen);
@@ -3847,6 +3614,7 @@ yyreduce:
 
   *++yyvsp = yyval;
 
+
   /* Now `shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
@@ -3866,10 +3634,6 @@ yyreduce:
 | yyerrlab -- here on detecting error |
 `------------------------------------*/
 yyerrlab:
-  /* Make sure we have latest lookahead translation.  See comments at
-     user semantic actions for why this is necessary.  */
-  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
-
   /* If not already recovering from an error, report this error.  */
   if (!yyerrstatus)
     {
@@ -3877,36 +3641,37 @@ yyerrlab:
 #if ! YYERROR_VERBOSE
       yyerror (YY_("syntax error"));
 #else
-# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
-                                        yyssp, yytoken)
       {
-        char const *yymsgp = YY_("syntax error");
-        int yysyntax_error_status;
-        yysyntax_error_status = YYSYNTAX_ERROR;
-        if (yysyntax_error_status == 0)
-          yymsgp = yymsg;
-        else if (yysyntax_error_status == 1)
-          {
-            if (yymsg != yymsgbuf)
-              YYSTACK_FREE (yymsg);
-            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
-            if (!yymsg)
-              {
-                yymsg = yymsgbuf;
-                yymsg_alloc = sizeof yymsgbuf;
-                yysyntax_error_status = 2;
-              }
-            else
-              {
-                yysyntax_error_status = YYSYNTAX_ERROR;
-                yymsgp = yymsg;
-              }
-          }
-        yyerror (yymsgp);
-        if (yysyntax_error_status == 2)
-          goto yyexhaustedlab;
+	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+	  {
+	    YYSIZE_T yyalloc = 2 * yysize;
+	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
+	    if (yymsg != yymsgbuf)
+	      YYSTACK_FREE (yymsg);
+	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+	    if (yymsg)
+	      yymsg_alloc = yyalloc;
+	    else
+	      {
+		yymsg = yymsgbuf;
+		yymsg_alloc = sizeof yymsgbuf;
+	      }
+	  }
+
+	if (0 < yysize && yysize <= yymsg_alloc)
+	  {
+	    (void) yysyntax_error (yymsg, yystate, yychar);
+	    yyerror (yymsg);
+	  }
+	else
+	  {
+	    yyerror (YY_("syntax error"));
+	    if (yysize != 0)
+	      goto yyexhaustedlab;
+	  }
       }
-# undef YYSYNTAX_ERROR
 #endif
     }
 
@@ -3914,7 +3679,7 @@ yyerrlab:
 
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
 	 error, discard it.  */
 
       if (yychar <= YYEOF)
@@ -3931,7 +3696,7 @@ yyerrlab:
 	}
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
   goto yyerrlab1;
 
@@ -3965,7 +3730,7 @@ yyerrlab1:
   for (;;)
     {
       yyn = yypact[yystate];
-      if (!yypact_value_is_default (yyn))
+      if (yyn != YYPACT_NINF)
 	{
 	  yyn += YYTERROR;
 	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
@@ -3988,9 +3753,10 @@ yyerrlab1:
       YY_STACK_PRINT (yyss, yyssp);
     }
 
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
   *++yyvsp = yylval;
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
 
 
   /* Shift the error token.  */
@@ -4014,7 +3780,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
-#if !defined yyoverflow || YYERROR_VERBOSE
+#ifndef yyoverflow
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
@@ -4025,14 +3791,9 @@ yyexhaustedlab:
 #endif
 
 yyreturn:
-  if (yychar != YYEMPTY)
-    {
-      /* Make sure we have latest lookahead translation.  See comments at
-         user semantic actions for why this is necessary.  */
-      yytoken = YYTRANSLATE (yychar);
-      yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval);
-    }
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
   /* Do not reclaim the symbols of the rule which action triggered
      this YYABORT or YYACCEPT.  */
   YYPOPSTACK (yylen);
@@ -4056,6 +3817,6 @@ yyreturn:
 }
 
 
-/* Line 2050 of yacc.c  */
-#line 1219 "cc.y"
+#line 1220 "cc.y"
+
 
diff --git a/src/cmd/cc/y.tab.h b/src/cmd/cc/y.tab.h
index b26d659ef4..32daca9b67 100644
--- a/src/cmd/cc/y.tab.h
+++ b/src/cmd/cc/y.tab.h
@@ -1,21 +1,24 @@
-/* A Bison parser, made by GNU Bison 2.7.12-4996.  */
+/* A Bison parser, made by GNU Bison 2.3.  */
 
-/* Bison interface for Yacc-like parsers in C
-   
-      Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
-   
-   This program is free software: you can redistribute it and/or modify
+/* Skeleton interface for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-   
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see .  */
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -26,20 +29,10 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-   
+
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_YY_Y_TAB_H_INCLUDED
-# define YY_YY_Y_TAB_H_INCLUDED
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -196,12 +189,11 @@ extern int yydebug;
 
 
 
+
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
-{
-/* Line 2053 of yacc.c  */
 #line 36 "cc.y"
-
+{
 	Node*	node;
 	Sym*	sym;
 	Type*	type;
@@ -225,30 +217,14 @@ typedef union YYSTYPE
 	int32	lval;
 	double	dval;
 	vlong	vval;
-
-
-/* Line 2053 of yacc.c  */
-#line 232 "y.tab.h"
-} YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
+}
+/* Line 1529 of yacc.c.  */
+#line 223 "y.tab.h"
+	YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 extern YYSTYPE yylval;
 
-#ifdef YYPARSE_PARAM
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void *YYPARSE_PARAM);
-#else
-int yyparse ();
-#endif
-#else /* ! YYPARSE_PARAM */
-#if defined __STDC__ || defined __cplusplus
-int yyparse (void);
-#else
-int yyparse ();
-#endif
-#endif /* ! YYPARSE_PARAM */
-
-#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
diff --git a/src/cmd/cgo/ast.go b/src/cmd/cgo/ast.go
index 6c5a160866..10e2278a1d 100644
--- a/src/cmd/cgo/ast.go
+++ b/src/cmd/cgo/ast.go
@@ -308,6 +308,9 @@ func (f *File) walk(x interface{}, context string, visit func(*File, interface{}
 		if n.High != nil {
 			f.walk(&n.High, "expr", visit)
 		}
+		if n.Max != nil {
+			f.walk(&n.Max, "expr", visit)
+		}
 	case *ast.TypeAssertExpr:
 		f.walk(&n.X, "expr", visit)
 		f.walk(&n.Type, "type", visit)
diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 6586531ada..d92bed9bf0 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -44,6 +44,7 @@ func (p *Package) writeDefs() {
 	fmt.Fprintf(fm, "int main() { return 0; }\n")
 	if *importRuntimeCgo {
 		fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*, int), void *a, int c) { }\n")
+		fmt.Fprintf(fm, "char* _cgo_topofstack(void) { return (char*)0; }\n")
 	} else {
 		// If we're not importing runtime/cgo, we *are* runtime/cgo,
 		// which provides crosscall2.  We just need a prototype.
@@ -129,6 +130,7 @@ func (p *Package) writeDefs() {
 			fmt.Fprintf(fc, `extern void *%s __asm__("%s.%s");`, n.Mangle, gccgoSymbolPrefix, n.Mangle)
 			fmt.Fprintf(&gccgoInit, "\t%s = %s%s;\n", n.Mangle, amp, n.C)
 		} else {
+			fmt.Fprintf(fc, "#pragma dataflag NOPTR /* C pointer, not heap pointer */ \n")
 			fmt.Fprintf(fc, "void *·%s = %s%s;\n", n.Mangle, amp, n.C)
 		}
 		fmt.Fprintf(fc, "\n")
@@ -397,6 +399,7 @@ func (p *Package) writeDefsFunc(fc, fgo2 *os.File, n *Name) {
 	// C wrapper calls into gcc, passing a pointer to the argument frame.
 	fmt.Fprintf(fc, "#pragma cgo_import_static %s\n", cname)
 	fmt.Fprintf(fc, "void %s(void*);\n", cname)
+	fmt.Fprintf(fc, "#pragma dataflag NOPTR\n")
 	fmt.Fprintf(fc, "void *·%s = %s;\n", cname, cname)
 
 	nret := 0
@@ -517,9 +520,13 @@ func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
 	// Use packed attribute to force no padding in this struct in case
 	// gcc has different packing requirements.
 	fmt.Fprintf(fgcc, "\t%s %v *a = v;\n", ctype, p.packedAttribute())
+	if n.FuncType.Result != nil {
+		// Save the stack top for use below.
+		fmt.Fprintf(fgcc, "\tchar *stktop = _cgo_topofstack();\n")
+	}
 	fmt.Fprintf(fgcc, "\t")
 	if t := n.FuncType.Result; t != nil {
-		fmt.Fprintf(fgcc, "a->r = ")
+		fmt.Fprintf(fgcc, "__typeof__(a->r) r = ")
 		if c := t.C.String(); c[len(c)-1] == '*' {
 			fmt.Fprint(fgcc, "(__typeof__(a->r)) ")
 		}
@@ -542,6 +549,13 @@ func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
 		fmt.Fprintf(fgcc, "a->p%d", i)
 	}
 	fmt.Fprintf(fgcc, ");\n")
+	if n.FuncType.Result != nil {
+		// The cgo call may have caused a stack copy (via a callback).
+		// Adjust the return value pointer appropriately.
+		fmt.Fprintf(fgcc, "\ta = (void*)((char*)a + (_cgo_topofstack() - stktop));\n")
+		// Save the return value.
+		fmt.Fprintf(fgcc, "\ta->r = r;\n")
+	}
 	if n.AddError {
 		fmt.Fprintf(fgcc, "\treturn errno;\n")
 	}
@@ -1129,6 +1143,8 @@ __cgo_size_assert(__cgo_long_long, 8)
 __cgo_size_assert(float, 4)
 __cgo_size_assert(double, 8)
 
+extern char* _cgo_topofstack(void);
+
 #include 
 #include 
 `
@@ -1151,20 +1167,31 @@ void *_CMalloc(size_t);
 const cProlog = `
 #include "runtime.h"
 #include "cgocall.h"
+#include "textflag.h"
 
+#pragma dataflag NOPTR
 static void *cgocall_errno = runtime·cgocall_errno;
+#pragma dataflag NOPTR
 void *·_cgo_runtime_cgocall_errno = &cgocall_errno;
 
+#pragma dataflag NOPTR
 static void *runtime_gostring = runtime·gostring;
+#pragma dataflag NOPTR
 void *·_cgo_runtime_gostring = &runtime_gostring;
 
+#pragma dataflag NOPTR
 static void *runtime_gostringn = runtime·gostringn;
+#pragma dataflag NOPTR
 void *·_cgo_runtime_gostringn = &runtime_gostringn;
 
+#pragma dataflag NOPTR
 static void *runtime_gobytes = runtime·gobytes;
+#pragma dataflag NOPTR
 void *·_cgo_runtime_gobytes = &runtime_gobytes;
 
+#pragma dataflag NOPTR
 static void *runtime_cmalloc = runtime·cmalloc;
+#pragma dataflag NOPTR
 void *·_cgo_runtime_cmalloc = &runtime_cmalloc;
 
 void ·_Cerrno(void*, int32);
diff --git a/src/cmd/dist/build.c b/src/cmd/dist/build.c
index 5e8dfee783..8fd2e998a4 100644
--- a/src/cmd/dist/build.c
+++ b/src/cmd/dist/build.c
@@ -918,6 +918,8 @@ install(char *dir)
 			bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos), 0);
 		copyfile(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/cmd/ld/textflag.h", goroot), 0);
+		copyfile(bpathf(&b, "%s/pkg/%s_%s/funcdata.h", goroot, goos, goarch),
+			bpathf(&b1, "%s/src/runtime/funcdata.h", goroot), 0);
 	}
 
 	// Generate any missing files; regenerate existing ones.
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index c21a316397..d22e099557 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -253,6 +253,8 @@ ok:
 				aggr = "alg";
 			else if(streq(fields.p[1], "Panic"))
 				aggr = "panic";
+			else if(streq(fields.p[1], "Stack"))
+				aggr = "stack";
 		}
 		if(hasprefix(lines.p[i], "}"))
 			aggr = nil;
@@ -334,16 +336,20 @@ mkzsys(char *dir, char *file)
 
 static char *runtimedefs[] = {
 	"defs.c",
+	"malloc.c",
+	"mcache.c",
+	"mgc0.c",
 	"proc.c",
 	"parfor.c",
+	"stack.c",
 };
 
 // mkzruntimedefs writes zruntime_defs_$GOOS_$GOARCH.h,
 // which contains Go struct definitions equivalent to the C ones.
 // Mostly we just write the output of 6c -q to the file.
 // However, we run it on multiple files, so we have to delete
-// the duplicated definitions, and we don't care about the funcs
-// and consts, so we delete those too.
+// the duplicated definitions, and we don't care about the funcs,
+// so we delete those too.
 // 
 void
 mkzruntimedefs(char *dir, char *file)
diff --git a/src/cmd/gc/align.c b/src/cmd/gc/align.c
index b809640e42..6e5d149c75 100644
--- a/src/cmd/gc/align.c
+++ b/src/cmd/gc/align.c
@@ -119,8 +119,10 @@ dowidth(Type *t)
 	if(t->width == -2) {
 		lno = lineno;
 		lineno = t->lineno;
-		if(!t->broke)
+		if(!t->broke) {
+			t->broke = 1;
 			yyerror("invalid recursive type %T", t);
+		}
 		t->width = 0;
 		lineno = lno;
 		return;
diff --git a/src/cmd/gc/builtin.c b/src/cmd/gc/builtin.c
index 60b7c2f977..5fbb4f0cf3 100644
--- a/src/cmd/gc/builtin.c
+++ b/src/cmd/gc/builtin.c
@@ -83,6 +83,14 @@ char *runtimeimport =
 	"func @\"\".chanrecv2 (@\"\".chanType·2 *byte, @\"\".hchan·3 <-chan any, @\"\".elem·4 *any) (? bool)\n"
 	"func @\"\".chansend1 (@\"\".chanType·1 *byte, @\"\".hchan·2 chan<- any, @\"\".elem·3 *any)\n"
 	"func @\"\".closechan (@\"\".hchan·1 any)\n"
+	"func @\"\".writebarrierptr (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+	"func @\"\".writebarrierstring (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+	"func @\"\".writebarrierslice (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+	"func @\"\".writebarrieriface (@\"\".dst·1 *any, @\"\".src·2 any)\n"
+	"func @\"\".writebarrierfat2 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n"
+	"func @\"\".writebarrierfat3 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n"
+	"func @\"\".writebarrierfat4 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n"
+	"func @\"\".writebarrierfat (@\"\".typ·1 *byte, @\"\".dst·2 *any, @\"\".src·3 *any)\n"
 	"func @\"\".selectnbsend (@\"\".chanType·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (? bool)\n"
 	"func @\"\".selectnbrecv (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".hchan·4 <-chan any) (? bool)\n"
 	"func @\"\".selectnbrecv2 (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".received·4 *bool, @\"\".hchan·5 <-chan any) (? bool)\n"
diff --git a/src/cmd/gc/dcl.c b/src/cmd/gc/dcl.c
index 73c2581beb..dfcf47520a 100644
--- a/src/cmd/gc/dcl.c
+++ b/src/cmd/gc/dcl.c
@@ -488,6 +488,10 @@ colasdefn(NodeList *left, Node *defn)
 	NodeList *l;
 	Node *n;
 
+	for(l=left; l; l=l->next)
+		if(l->n->sym != S)
+			l->n->sym->flags |= SymUniq;
+
 	nnew = 0;
 	nerr = 0;
 	for(l=left; l; l=l->next) {
@@ -499,6 +503,13 @@ colasdefn(NodeList *left, Node *defn)
 			nerr++;
 			continue;
 		}
+		if((n->sym->flags & SymUniq) == 0) {
+			yyerrorl(defn->lineno, "%S repeated on left side of :=", n->sym);
+			n->diag++;
+			nerr++;
+			continue;
+		}
+		n->sym->flags &= ~SymUniq;
 		if(n->sym->block == block)
 			continue;
 
@@ -547,6 +558,9 @@ ifacedcl(Node *n)
 	if(n->op != ODCLFIELD || n->right == N)
 		fatal("ifacedcl");
 
+	if(isblank(n->left))
+		yyerror("methods must have a unique non-blank name");
+
 	dclcontext = PPARAM;
 	markdcl();
 	funcdepth++;
diff --git a/src/cmd/gc/fmt.c b/src/cmd/gc/fmt.c
index 98556a658f..89d2a14046 100644
--- a/src/cmd/gc/fmt.c
+++ b/src/cmd/gc/fmt.c
@@ -810,6 +810,13 @@ stmtfmt(Fmt *f, Node *n)
 		break;
 
 	case OASOP:
+		if(n->implicit) {
+			if(n->etype == OADD)
+				fmtprint(f, "%N++", n->left);
+			else
+				fmtprint(f, "%N--", n->left);
+			break;
+		}
 		fmtprint(f, "%N %#O= %N", n->left, n->etype, n->right);
 		break;
 
@@ -1108,16 +1115,11 @@ exprfmt(Fmt *f, Node *n, int prec)
 
 	case ONAME:
 		// Special case: name used as local variable in export.
-		switch(n->class&~PHEAP){
-		case PAUTO:
-		case PPARAM:
-		case PPARAMOUT:
-			// _ becomes ~b%d internally; print as _ for export
-			if(fmtmode == FExp && n->sym && n->sym->name[0] == '~' && n->sym->name[1] == 'b')
-				return fmtprint(f, "_");
-			if(fmtmode == FExp && n->sym && !isblank(n) && n->vargen > 0)
-				return fmtprint(f, "%S·%d", n->sym, n->vargen);
-		}
+		// _ becomes ~b%d internally; print as _ for export
+		if(fmtmode == FExp && n->sym && n->sym->name[0] == '~' && n->sym->name[1] == 'b')
+			return fmtprint(f, "_");
+		if(fmtmode == FExp && n->sym && !isblank(n) && n->vargen > 0)
+			return fmtprint(f, "%S·%d", n->sym, n->vargen);
 
 		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
 		// but for export, this should be rendered as (*pkg.T).meth.
diff --git a/src/cmd/gc/gen.c b/src/cmd/gc/gen.c
index 86acd88259..c7c9fcdaff 100644
--- a/src/cmd/gc/gen.c
+++ b/src/cmd/gc/gen.c
@@ -54,9 +54,6 @@ addrescapes(Node *n)
 		if(n->class == PAUTO && n->esc == EscNever)
 			break;
 
-		if(debug['N'] && n->esc != EscUnknown)
-			fatal("without escape analysis, only PAUTO's should have esc: %N", n);
-
 		switch(n->class) {
 		case PPARAMREF:
 			addrescapes(n->defn);
@@ -91,8 +88,7 @@ addrescapes(Node *n)
 			snprint(buf, sizeof buf, "&%S", n->sym);
 			n->heapaddr->sym = lookup(buf);
 			n->heapaddr->orig->sym = n->heapaddr->sym;
-			if(!debug['N'])
-				n->esc = EscHeap;
+			n->esc = EscHeap;
 			if(debug['m'])
 				print("%L: moved to heap: %N\n", n->lineno, n);
 			curfn = oldfn;
@@ -585,7 +581,7 @@ cgen_dcl(Node *n)
 	if(!(n->class & PHEAP))
 		return;
 	if(compiling_runtime)
-		fatal("%N escapes to heap, not allowed in runtime.", n);
+		yyerror("%N escapes to heap, not allowed in runtime.", n);
 	if(n->alloc == nil)
 		n->alloc = callnew(n->type);
 	cgen_as(n->heapaddr, n->alloc);
@@ -735,14 +731,10 @@ cgen_as(Node *nl, Node *nr)
 		return;
 	}
 
-	if(nr == N || isnil(nr)) {
-		// externals and heaps should already be clear
-		if(nr == N) {
-			if(nl->class == PEXTERN)
-				return;
-			if(nl->class & PHEAP)
-				return;
-		}
+	if(nr == N || iszero(nr)) {
+		// heaps should already be clear
+		if(nr == N && (nl->class & PHEAP))
+			return;
 
 		tl = nl->type;
 		if(tl == T)
diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h
index 12c1e98539..965a0550d3 100644
--- a/src/cmd/gc/go.h
+++ b/src/cmd/gc/go.h
@@ -283,6 +283,7 @@ struct	Node
 	uchar	addrtaken;	// address taken, even if not moved to heap
 	uchar	dupok;	// duplicate definitions ok (for func)
 	uchar	wrapper;	// is method wrapper (for func)
+	uchar	reslice;	// this is a reslice x = x[0:y] or x = append(x, ...)
 	schar	likely; // likeliness of if statement
 	uchar	hasbreak;	// has break statement
 	uchar	needzero; // if it contains pointers, needs to be zeroed on function entry
@@ -973,6 +974,7 @@ EXTERN	int	funcdepth;
 EXTERN	int	typecheckok;
 EXTERN	int	compiling_runtime;
 EXTERN	int	compiling_wrappers;
+EXTERN	int	use_writebarrier;
 EXTERN	int	pure_go;
 EXTERN	char*	flag_installsuffix;
 EXTERN	int	flag_race;
@@ -1284,6 +1286,7 @@ LSym*	linksym(Sym*);
  *	order.c
  */
 void	order(Node *fn);
+void	orderstmtinplace(Node **stmt);
 
 /*
  *	range.c
@@ -1372,6 +1375,7 @@ int	isnilinter(Type *t);
 int	isptrto(Type *t, int et);
 int	isslice(Type *t);
 int	istype(Type *t, int et);
+int	iszero(Node *n);
 void	linehist(char *file, int32 off, int relative);
 NodeList*	list(NodeList *l, Node *n);
 NodeList*	list1(Node *n);
@@ -1464,6 +1468,7 @@ void	walkstmt(Node **np);
 void	walkstmtlist(NodeList *l);
 Node*	conv(Node*, Type*);
 int	candiscard(Node*);
+int	needwritebarrier(Node*, Node*);
 Node*	outervalue(Node*);
 void	usefield(Node*);
 
diff --git a/src/cmd/gc/go.y b/src/cmd/gc/go.y
index b16f64b5d6..68fccc1ad1 100644
--- a/src/cmd/gc/go.y
+++ b/src/cmd/gc/go.y
@@ -460,11 +460,13 @@ simple_stmt:
 |	expr LINC
 	{
 		$$ = nod(OASOP, $1, nodintconst(1));
+		$$->implicit = 1;
 		$$->etype = OADD;
 	}
 |	expr LDEC
 	{
 		$$ = nod(OASOP, $1, nodintconst(1));
+		$$->implicit = 1;
 		$$->etype = OSUB;
 	}
 
diff --git a/src/cmd/gc/lex.c b/src/cmd/gc/lex.c
index b8252a225e..2303b442cd 100644
--- a/src/cmd/gc/lex.c
+++ b/src/cmd/gc/lex.c
@@ -312,6 +312,8 @@ main(int argc, char *argv[])
 	flagcount("u", "reject unsafe code", &safemode);
 	flagcount("v", "increase debug verbosity", &debug['v']);
 	flagcount("w", "debug type checking", &debug['w']);
+	use_writebarrier = 1;
+	flagcount("wb", "enable write barrier", &use_writebarrier);
 	flagcount("x", "debug lexer", &debug['x']);
 	flagcount("y", "debug declarations in canned imports (with -d)", &debug['y']);
 	if(thechar == '6')
@@ -479,8 +481,12 @@ main(int argc, char *argv[])
 	}
 
 	// Phase 5: Escape analysis.
-	if(!debug['N'])
-		escapes(xtop);
+	// Required for moving heap allocations onto stack,
+	// which in turn is required by the closure implementation,
+	// which stores the addresses of stack variables into the closure.
+	// If the closure does not escape, it needs to be on the stack
+	// or else the stack copier will not update it.
+	escapes(xtop);
 	
 	// Escape analysis moved escaped values off stack.
 	// Move large values off stack too.
diff --git a/src/cmd/gc/mparith2.c b/src/cmd/gc/mparith2.c
index 5cf98c62c6..fd9f591cea 100644
--- a/src/cmd/gc/mparith2.c
+++ b/src/cmd/gc/mparith2.c
@@ -656,7 +656,7 @@ mpdivmodfixfix(Mpint *q, Mpint *r, Mpint *n, Mpint *d)
 }
 
 static int
-iszero(Mpint *a)
+mpiszero(Mpint *a)
 {
 	long *a1;
 	int i;
@@ -687,7 +687,7 @@ mpdivfract(Mpint *a, Mpint *b)
 		for(j=0; jright.
 static void
 ordermapassign(Node *n, Order *order)
 {
@@ -451,7 +454,8 @@ ordermapassign(Node *n, Order *order)
 
 	case OAS:
 		order->out = list(order->out, n);
-		if(n->left->op == OINDEXMAP && !isaddrokay(n->right)) {
+		// We call writebarrierfat only for values > 4 pointers long. See walk.c.
+		if((n->left->op == OINDEXMAP || (needwritebarrier(n->left, n->right) && n->left->type->width > 4*widthptr)) && !isaddrokay(n->right)) {
 			m = n->left;
 			n->left = ordertemp(m->type, order, 0);
 			a = nod(OAS, m, n->left);
@@ -1028,11 +1032,21 @@ orderexpr(Node **np, Order *order)
 		orderexprinplace(&n->right, order);
 		break;
 	
-	case OCALLFUNC:
-	case OCALLMETH:
-	case OCALLINTER:
 	case OAPPEND:
+	case OCALLFUNC:
+	case OCALLINTER:
+	case OCALLMETH:
+	case OCAP:
 	case OCOMPLEX:
+	case OCOPY:
+	case OIMAG:
+	case OLEN:
+	case OMAKECHAN:
+	case OMAKEMAP:
+	case OMAKESLICE:
+	case ONEW:
+	case OREAL:
+	case ORECOVER:
 		ordercall(n, order);
 		n = ordercopyexpr(n, n->type, order, 0);
 		break;
diff --git a/src/cmd/gc/pgen.c b/src/cmd/gc/pgen.c
index 2d4795ac1f..259cec85a3 100644
--- a/src/cmd/gc/pgen.c
+++ b/src/cmd/gc/pgen.c
@@ -14,6 +14,7 @@
 #include	"../../runtime/funcdata.h"
 
 static void allocauto(Prog* p);
+static void emitptrargsmap(void);
 
 static Sym*
 makefuncdatasym(char *namefmt, int64 funcdatakind)
@@ -173,9 +174,17 @@ compile(Node *fn)
 
 	lno = setlineno(fn);
 
+	curfn = fn;
+	dowidth(curfn->type);
+
 	if(fn->nbody == nil) {
-		if(pure_go || strncmp(fn->nname->sym->name, "init·", 6) == 0)
+		if(pure_go || strncmp(fn->nname->sym->name, "init·", 6) == 0) {
 			yyerror("missing function body", fn);
+			goto ret;
+		}
+		if(debug['A'])
+			goto ret;
+		emitptrargsmap();
 		goto ret;
 	}
 
@@ -184,9 +193,6 @@ compile(Node *fn)
 	// set up domain for labels
 	clearlabels();
 
-	curfn = fn;
-	dowidth(curfn->type);
-
 	if(curfn->type->outnamed) {
 		// add clearing of the output parameters
 		t = structfirst(&save, getoutarg(curfn->type));
@@ -329,6 +335,43 @@ ret:
 	lineno = lno;
 }
 
+static void
+emitptrargsmap(void)
+{
+	int nptr, nbitmap, j, off;
+	vlong xoffset;
+	Bvec *bv;
+	Sym *sym;
+	
+	sym = lookup(smprint("%s.args_stackmap", curfn->nname->sym->name));
+
+	nptr = curfn->type->argwid / widthptr;
+	bv = bvalloc(nptr*2);
+	nbitmap = 1;
+	if(curfn->type->outtuple > 0)
+		nbitmap = 2;
+	off = duint32(sym, 0, nbitmap);
+	off = duint32(sym, off, bv->n);
+	if(curfn->type->thistuple > 0) {
+		xoffset = 0;
+		twobitwalktype1(getthisx(curfn->type), &xoffset, bv);
+	}
+	if(curfn->type->intuple > 0) {
+		xoffset = 0;
+		twobitwalktype1(getinargx(curfn->type), &xoffset, bv);
+	}
+	for(j = 0; j < bv->n; j += 32)
+		off = duint32(sym, off, bv->b[j/32]);
+	if(curfn->type->outtuple > 0) {
+		xoffset = 0;
+		twobitwalktype1(getoutargx(curfn->type), &xoffset, bv);
+		for(j = 0; j < bv->n; j += 32)
+			off = duint32(sym, off, bv->b[j/32]);
+	}
+	ggloblsym(sym, off, RODATA);
+	free(bv);
+}
+
 // Sort the list of stack variables. Autos after anything else,
 // within autos, unused after used, within used, things with
 // pointers first, zeroed things first, and then decreasing size.
diff --git a/src/cmd/gc/racewalk.c b/src/cmd/gc/racewalk.c
index 27581702cc..c9e27fe560 100644
--- a/src/cmd/gc/racewalk.c
+++ b/src/cmd/gc/racewalk.c
@@ -208,6 +208,26 @@ racewalknode(Node **np, NodeList **init, int wr, int skip)
 		goto ret;
 
 	case OCALLFUNC:
+		// Instrument dst argument of runtime.writebarrier* calls
+		// as we do not instrument runtime code.
+		if(n->left->sym != S && n->left->sym->pkg == runtimepkg && strncmp(n->left->sym->name, "writebarrier", 12) == 0) {
+			// Find the dst argument.
+			// The list can be reordered, so it's not necessary just the first or the second element.
+			for(l = n->list; l; l = l->next) {
+				if(strcmp(n->left->sym->name, "writebarrierfat") == 0) {
+					if(l->n->left->xoffset == widthptr)
+						break;
+				} else {
+					if(l->n->left->xoffset == 0)
+						break;
+				}
+			}
+			if(l == nil)
+				fatal("racewalk: writebarrier no arg");
+			if(l->n->right->op != OADDR)
+				fatal("racewalk: writebarrier bad arg");
+			callinstr(&l->n->right->left, init, 1, 0);
+		}
 		racewalknode(&n->left, init, 0, 0);
 		goto ret;
 
diff --git a/src/cmd/gc/reflect.c b/src/cmd/gc/reflect.c
index 31e449e760..b2ff2fbc5e 100644
--- a/src/cmd/gc/reflect.c
+++ b/src/cmd/gc/reflect.c
@@ -716,9 +716,10 @@ static int
 dcommontype(Sym *s, int ot, Type *t)
 {
 	int i, alg, sizeofAlg, gcprog;
-	Sym *sptr, *algsym, *zero, *gcprog0, *gcprog1;
+	Sym *sptr, *algsym, *zero, *gcprog0, *gcprog1, *sbits;
 	uint8 gcmask[16];
 	static Sym *algarray;
+	uint64 x1, x2;
 	char *p;
 	
 	if(ot != 0)
@@ -727,12 +728,12 @@ dcommontype(Sym *s, int ot, Type *t)
 	sizeofAlg = 2*widthptr;
 	if(algarray == nil)
 		algarray = pkglookup("algarray", runtimepkg);
+	dowidth(t);
 	alg = algtype(t);
 	algsym = S;
 	if(alg < 0)
 		algsym = dalgsym(t);
 
-	dowidth(t);
 	if(t->sym != nil && !isptr[t->etype])
 		sptr = dtypesym(ptrto(t));
 	else
@@ -804,8 +805,26 @@ dcommontype(Sym *s, int ot, Type *t)
 		ot = dsymptr(s, ot, gcprog1, 0);
 	} else {
 		gengcmask(t, gcmask);
-		for(i = 0; i < 2*widthptr; i++)
-			ot = duint8(s, ot, gcmask[i]);
+		x1 = 0;
+		for(i=0; i<8; i++)
+			x1 = x1<<8 | gcmask[i];
+		if(widthptr == 4) {
+			p = smprint("gcbits.%#016llux", x1);
+		} else {
+			x2 = 0;
+			for(i=0; i<8; i++)
+				x2 = x2<<8 | gcmask[i+8];
+			p = smprint("gcbits.%#016llux%016llux", x1, x2);
+		}
+		sbits = pkglookup(p, runtimepkg);
+		if((sbits->flags & SymUniq) == 0) {
+			sbits->flags |= SymUniq;
+			for(i = 0; i < 2*widthptr; i++)
+				duint8(sbits, i, gcmask[i]);
+			ggloblsym(sbits, 2*widthptr, DUPOK|RODATA);
+		}
+		ot = dsymptr(s, ot, sbits, 0);
+		ot = duintptr(s, ot, 0);
 	}
 	p = smprint("%-uT", t);
 	//print("dcommontype: %s\n", p);
diff --git a/src/cmd/gc/runtime.go b/src/cmd/gc/runtime.go
index 128fd1a31c..86afe67f17 100644
--- a/src/cmd/gc/runtime.go
+++ b/src/cmd/gc/runtime.go
@@ -107,6 +107,20 @@ func chanrecv2(chanType *byte, hchan <-chan any, elem *any) bool
 func chansend1(chanType *byte, hchan chan<- any, elem *any)
 func closechan(hchan any)
 
+// *byte is really *runtime.Type
+func writebarrierptr(dst *any, src any)
+func writebarrierstring(dst *any, src any)
+func writebarrierslice(dst *any, src any)
+func writebarrieriface(dst *any, src any)
+
+// The unused *byte argument makes sure that src is 2-pointer-aligned,
+// which is the maximum alignment on NaCl amd64p32
+// (and possibly on 32-bit systems if we start 64-bit aligning uint64s).
+func writebarrierfat2(dst *any, _ *byte, src any)
+func writebarrierfat3(dst *any, _ *byte, src any)
+func writebarrierfat4(dst *any, _ *byte, src any)
+func writebarrierfat(typ *byte, dst *any, src *any)
+
 func selectnbsend(chanType *byte, hchan chan<- any, elem *any) bool
 func selectnbrecv(chanType *byte, elem *any, hchan <-chan any) bool
 func selectnbrecv2(chanType *byte, elem *any, received *bool, hchan <-chan any) bool
diff --git a/src/cmd/gc/sinit.c b/src/cmd/gc/sinit.c
index 59804cd8d0..8ad7ae7abb 100644
--- a/src/cmd/gc/sinit.c
+++ b/src/cmd/gc/sinit.c
@@ -17,7 +17,6 @@ enum
 	InitPending = 2,
 };
 
-static int iszero(Node*);
 static void initplan(Node*);
 static NodeList *initlist;
 static void init2(Node*, NodeList**);
@@ -207,7 +206,7 @@ init2(Node *n, NodeList **out)
 	
 	if(n->op == OCLOSURE)
 		init2list(n->closure->nbody, out);
-	if(n->op == ODOTMETH)
+	if(n->op == ODOTMETH || n->op == OCALLPART)
 		init2(n->type->nname, out);
 }
 
@@ -633,11 +632,14 @@ structlit(int ctxt, int pass, Node *n, Node *var, NodeList **init)
 		a = nod(ODOT, var, newname(index->sym));
 		a = nod(OAS, a, value);
 		typecheck(&a, Etop);
-		walkexpr(&a, init);
 		if(pass == 1) {
+			walkexpr(&a, init);	// add any assignments in r to top
 			if(a->op != OAS)
 				fatal("structlit: not as");
 			a->dodata = 2;
+		} else {
+			orderstmtinplace(&a);
+			walkstmt(&a);
 		}
 		*init = list(*init, a);
 	}
@@ -693,11 +695,14 @@ arraylit(int ctxt, int pass, Node *n, Node *var, NodeList **init)
 		a = nod(OINDEX, var, index);
 		a = nod(OAS, a, value);
 		typecheck(&a, Etop);
-		walkexpr(&a, init);	// add any assignments in r to top
 		if(pass == 1) {
+			walkexpr(&a, init);
 			if(a->op != OAS)
-				fatal("structlit: not as");
+				fatal("arraylit: not as");
 			a->dodata = 2;
+		} else {
+			orderstmtinplace(&a);
+			walkstmt(&a);
 		}
 		*init = list(*init, a);
 	}
@@ -807,7 +812,8 @@ slicelit(int ctxt, Node *n, Node *var, NodeList **init)
 	// make slice out of heap (5)
 	a = nod(OAS, var, nod(OSLICE, vauto, nod(OKEY, N, N)));
 	typecheck(&a, Etop);
-	walkexpr(&a, init);
+	orderstmtinplace(&a);
+	walkstmt(&a);
 	*init = list(*init, a);
 
 	// put dynamics into slice (6)
@@ -839,7 +845,8 @@ slicelit(int ctxt, Node *n, Node *var, NodeList **init)
 		// build list of var[c] = expr
 		a = nod(OAS, a, value);
 		typecheck(&a, Etop);
-		walkexpr(&a, init);
+		orderstmtinplace(&a);
+		walkstmt(&a);
 		*init = list(*init, a);
 	}
 }
@@ -1060,7 +1067,7 @@ anylit(int ctxt, Node *n, Node *var, NodeList **init)
 		if(t->etype != TSTRUCT)
 			fatal("anylit: not struct");
 
-		if(simplename(var)) {
+		if(simplename(var) && count(n->list) > 4) {
 
 			if(ctxt == 0) {
 				// lay out static data
@@ -1083,7 +1090,7 @@ anylit(int ctxt, Node *n, Node *var, NodeList **init)
 		}
 
 		// initialize of not completely specified
-		if(count(n->list) < structcount(t)) {
+		if(simplename(var) || count(n->list) < structcount(t)) {
 			a = nod(OAS, var, N);
 			typecheck(&a, Etop);
 			walkexpr(&a, init);
@@ -1100,7 +1107,7 @@ anylit(int ctxt, Node *n, Node *var, NodeList **init)
 			break;
 		}
 
-		if(simplename(var)) {
+		if(simplename(var) && count(n->list) > 4) {
 
 			if(ctxt == 0) {
 				// lay out static data
@@ -1123,7 +1130,7 @@ anylit(int ctxt, Node *n, Node *var, NodeList **init)
 		}
 
 		// initialize of not completely specified
-		if(count(n->list) < t->bound) {
+		if(simplename(var) || count(n->list) < t->bound) {
 			a = nod(OAS, var, N);
 			typecheck(&a, Etop);
 			walkexpr(&a, init);
@@ -1348,7 +1355,6 @@ no:
 	return 0;
 }
 
-static int iszero(Node*);
 static int isvaluelit(Node*);
 static InitEntry* entry(InitPlan*);
 static void addvalue(InitPlan*, vlong, Node*, Node*);
@@ -1432,7 +1438,7 @@ addvalue(InitPlan *p, vlong xoffset, Node *key, Node *n)
 	e->expr = n;
 }
 
-static int
+int
 iszero(Node *n)
 {
 	NodeList *l;
diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 93600c688b..c3bc5af3b8 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -529,7 +529,8 @@ algtype1(Type *t, Type **bad)
 	
 	if(bad)
 		*bad = T;
-
+	if(t->broke)
+		return AMEM;
 	if(t->noalg)
 		return ANOEQ;
 
@@ -3466,7 +3467,7 @@ smagic(Magic *m)
 	p = m->w-1;
 	ad = m->sd;
 	if(m->sd < 0)
-		ad = -m->sd;
+		ad = -(uvlong)m->sd;
 
 	// bad denominators
 	if(ad == 0 || ad == 1 || ad == two31) {
diff --git a/src/cmd/gc/typecheck.c b/src/cmd/gc/typecheck.c
index 746feb4d1b..714c662681 100644
--- a/src/cmd/gc/typecheck.c
+++ b/src/cmd/gc/typecheck.c
@@ -33,7 +33,7 @@ static void	stringtoarraylit(Node**);
 static Node*	resolve(Node*);
 static void	checkdefergo(Node*);
 static int	checkmake(Type*, char*, Node*);
-static int	checksliceindex(Node*, Type*);
+static int	checksliceindex(Node*, Node*, Type*);
 static int	checksliceconst(Node*, Node*);
 
 static	NodeList*	typecheckdefstack;
@@ -311,6 +311,7 @@ typecheck1(Node **np, int top)
 	Type *t, *tp, *missing, *have, *badtype;
 	Val v;
 	char *why, *desc, descbuf[64];
+	vlong x;
 	
 	n = *np;
 
@@ -408,7 +409,10 @@ reswitch:
 				v = toint(l->val);
 				break;
 			default:
-				yyerror("invalid array bound %N", l);
+				if(l->type != T && isint[l->type->etype] && l->op != OLITERAL)
+					yyerror("non-constant array bound %N", l);
+				else
+					yyerror("invalid array bound %N", l);
 				goto error;
 			}
 			t->bound = mpgetfix(v.u.xval);
@@ -597,6 +601,10 @@ reswitch:
 		}
 		if(t->etype != TIDEAL && !eqtype(l->type, r->type)) {
 			defaultlit2(&l, &r, 1);
+			if(n->op == OASOP && n->implicit) {
+				yyerror("invalid operation: %N (non-numeric type %T)", n, l->type);
+				goto error;
+			}
 			yyerror("invalid operation: %N (mismatched types %T and %T)", n, l->type, r->type);
 			goto error;
 		}
@@ -733,10 +741,6 @@ reswitch:
 		l = n->left;
 		if((t = l->type) == T)
 			goto error;
-		// top&Eindir means this is &x in *&x.  (or the arg to built-in print)
-		// n->etype means code generator flagged it as non-escaping.
-		if(debug['N'] && !(top & Eindir) && !n->etype)
-			addrescapes(n->left);
 		n->type = ptrto(t);
 		goto ret;
 
@@ -892,11 +896,12 @@ reswitch:
 				break;
 			}
 			if(isconst(n->right, CTINT)) {
-				if(mpgetfix(n->right->val.u.xval) < 0)
+				x = mpgetfix(n->right->val.u.xval);
+				if(x < 0)
 					yyerror("invalid %s index %N (index must be non-negative)", why, n->right);
-				else if(isfixedarray(t) && t->bound > 0 && mpgetfix(n->right->val.u.xval) >= t->bound)
+				else if(isfixedarray(t) && t->bound > 0 && x >= t->bound)
 					yyerror("invalid array index %N (out of bounds for %d-element array)", n->right, t->bound);
-				else if(isconst(n->left, CTSTR) && mpgetfix(n->right->val.u.xval) >= n->left->val.u.sval->len)
+				else if(isconst(n->left, CTSTR) && x >= n->left->val.u.sval->len)
 					yyerror("invalid string index %N (out of bounds for %d-byte string)", n->right, n->left->val.u.sval->len);
 				else if(mpcmpfixfix(n->right->val.u.xval, maxintval[TINT]) > 0)
 					yyerror("invalid %s index %N (index too large)", why, n->right);
@@ -996,9 +1001,9 @@ reswitch:
 			yyerror("cannot slice %N (type %T)", l, t);
 			goto error;
 		}
-		if((lo = n->right->left) != N && checksliceindex(lo, tp) < 0)
+		if((lo = n->right->left) != N && checksliceindex(l, lo, tp) < 0)
 			goto error;
-		if((hi = n->right->right) != N && checksliceindex(hi, tp) < 0)
+		if((hi = n->right->right) != N && checksliceindex(l, hi, tp) < 0)
 			goto error;
 		if(checksliceconst(lo, hi) < 0)
 			goto error;
@@ -1045,11 +1050,11 @@ reswitch:
 			yyerror("cannot slice %N (type %T)", l, t);
 			goto error;
 		}
-		if((lo = n->right->left) != N && checksliceindex(lo, tp) < 0)
+		if((lo = n->right->left) != N && checksliceindex(l, lo, tp) < 0)
 			goto error;
-		if((mid = n->right->right->left) != N && checksliceindex(mid, tp) < 0)
+		if((mid = n->right->right->left) != N && checksliceindex(l, mid, tp) < 0)
 			goto error;
-		if((hi = n->right->right->right) != N && checksliceindex(hi, tp) < 0)
+		if((hi = n->right->right->right) != N && checksliceindex(l, hi, tp) < 0)
 			goto error;
 		if(checksliceconst(lo, hi) < 0 || checksliceconst(lo, mid) < 0 || checksliceconst(mid, hi) < 0)
 			goto error;
@@ -1819,7 +1824,7 @@ out:
 }
 
 static int
-checksliceindex(Node *r, Type *tp)
+checksliceindex(Node *l, Node *r, Type *tp)
 {
 	Type *t;
 
@@ -1836,6 +1841,9 @@ checksliceindex(Node *r, Type *tp)
 		} else if(tp != nil && tp->bound > 0 && mpgetfix(r->val.u.xval) > tp->bound) {
 			yyerror("invalid slice index %N (out of bounds for %d-element array)", r, tp->bound);
 			return -1;
+		} else if(isconst(l, CTSTR) && mpgetfix(r->val.u.xval) > l->val.u.sval->len) {
+			yyerror("invalid slice index %N (out of bounds for %d-byte string)", r, l->val.u.sval->len);
+			return -1;
 		} else if(mpcmpfixfix(r->val.u.xval, maxintval[TINT]) > 0) {
 			yyerror("invalid slice index %N (index too large)", r);
 			return -1;
@@ -2116,18 +2124,19 @@ lookdot(Node *n, Type *t, int dostrcmp)
 		if(!eqtype(rcvr, tt)) {
 			if(rcvr->etype == tptr && eqtype(rcvr->type, tt)) {
 				checklvalue(n->left, "call pointer method on");
-				if(debug['N'])
-					addrescapes(n->left);
 				n->left = nod(OADDR, n->left, N);
 				n->left->implicit = 1;
 				typecheck(&n->left, Etype|Erv);
-			} else if(tt->etype == tptr && eqtype(tt->type, rcvr)) {
+			} else if(tt->etype == tptr && rcvr->etype != tptr && eqtype(tt->type, rcvr)) {
 				n->left = nod(OIND, n->left, N);
 				n->left->implicit = 1;
 				typecheck(&n->left, Etype|Erv);
-			} else if(tt->etype == tptr && tt->type->etype == tptr && eqtype(derefall(tt), rcvr)) {
+			} else if(tt->etype == tptr && tt->type->etype == tptr && eqtype(derefall(tt), derefall(rcvr))) {
 				yyerror("calling method %N with receiver %lN requires explicit dereference", n->right, n->left);
 				while(tt->etype == tptr) {
+					// Stop one level early for method with pointer receiver.
+					if(rcvr->etype == tptr && tt->type->etype != tptr)
+						break;
 					n->left = nod(OIND, n->left, N);
 					n->left->implicit = 1;
 					typecheck(&n->left, Etype|Erv);
@@ -2808,6 +2817,33 @@ checkassignlist(NodeList *l)
 		checkassign(l->n);
 }
 
+// Check whether l and r are the same side effect-free expression,
+// so that it is safe to reuse one instead of computing both.
+static int
+samesafeexpr(Node *l, Node *r)
+{
+	if(l->op != r->op || !eqtype(l->type, r->type))
+		return 0;
+	
+	switch(l->op) {
+	case ONAME:
+	case OCLOSUREVAR:
+		return l == r;
+	
+	case ODOT:
+	case ODOTPTR:
+		return l->right != nil && r->right != nil && l->right->sym == r->right->sym && samesafeexpr(l->left, r->left);
+	
+	case OIND:
+		return samesafeexpr(l->left, r->left);
+	
+	case OINDEX:
+		return samesafeexpr(l->left, r->left) && samesafeexpr(l->right, r->right);
+	}
+	
+	return 0;
+}
+
 /*
  * type check assignment.
  * if this assignment is the definition of a var on the left side,
@@ -2845,6 +2881,29 @@ typecheckas(Node *n)
 	n->typecheck = 1;
 	if(n->left->typecheck == 0)
 		typecheck(&n->left, Erv | Easgn);
+	
+	// Recognize slices being updated in place, for better code generation later.
+	// Don't rewrite if using race detector, to avoid needing to teach race detector
+	// about this optimization.
+	if(n->left && n->left->op != OINDEXMAP && n->right && !flag_race) {
+		switch(n->right->op) {
+		case OSLICE:
+		case OSLICE3:
+		case OSLICESTR:
+			// For x = x[0:y], x can be updated in place, without touching pointer.
+			if(samesafeexpr(n->left, n->right->left) && (n->right->right->left == N || iszero(n->right->right->left)))
+				n->right->reslice = 1;
+			break;
+		
+		case OAPPEND:
+			// For x = append(x, ...), x can be updated in place when there is capacity,
+			// without touching the pointer; otherwise the emitted code to growslice
+			// can take care of updating the pointer, and only in that case.
+			if(n->right->list != nil && samesafeexpr(n->left, n->right->list->n))
+				n->right->reslice = 1;
+			break;
+		}
+	}
 }
 
 static void
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index d1d4c72462..2520343bfd 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -8,6 +8,8 @@
 #include	"../ld/textflag.h"
 
 static	Node*	walkprint(Node*, NodeList**, int);
+static	Node*	writebarrierfn(char*, Type*, Type*);
+static	Node*	applywritebarrier(Node*, NodeList**);
 static	Node*	mapfn(char*, Type*);
 static	Node*	mapfndel(char*, Type*);
 static	Node*	ascompatee1(int, Node*, Node*, NodeList**);
@@ -135,6 +137,8 @@ walkstmt(Node **np)
 	n = *np;
 	if(n == N)
 		return;
+	if(n->dodata == 2) // don't walk, generated by anylit.
+		return;
 
 	setlineno(n);
 
@@ -633,6 +637,7 @@ walkexpr(Node **np, NodeList **init)
 			r = convas(nod(OAS, n->left, n->right), init);
 			r->dodata = n->dodata;
 			n = r;
+			n = applywritebarrier(n, init);
 		}
 
 		goto ret;
@@ -644,6 +649,8 @@ walkexpr(Node **np, NodeList **init)
 		walkexprlistsafe(n->rlist, init);
 		ll = ascompatee(OAS, n->list, n->rlist, init);
 		ll = reorder3(ll);
+		for(lr = ll; lr != nil; lr = lr->next)
+			lr->n = applywritebarrier(lr->n, init);
 		n = liststmt(ll);
 		goto ret;
 
@@ -656,6 +663,8 @@ walkexpr(Node **np, NodeList **init)
 		walkexpr(&r, init);
 
 		ll = ascompatet(n->op, n->list, &r->type, 0, init);
+		for(lr = ll; lr != nil; lr = lr->next)
+			lr->n = applywritebarrier(lr->n, init);
 		n = liststmt(concat(list1(r), ll));
 		goto ret;
 
@@ -1381,7 +1390,12 @@ walkexpr(Node **np, NodeList **init)
 	case OMAPLIT:
 	case OSTRUCTLIT:
 	case OPTRLIT:
-		// XXX TODO do we need to clear var?
+		// NOTE(rsc): Race detector cannot handle seeing
+		// a STRUCTLIT or ARRAYLIT representing a zero value,
+		// so make a temporary for those always in race mode.
+		// Otherwise, leave zero values in place.
+		if(iszero(n) && !flag_race)
+			goto ret;
 		var = temp(n->type);
 		anylit(0, n, var, init);
 		n = var;
@@ -1481,8 +1495,13 @@ ascompatee(int op, NodeList *nl, NodeList *nr, NodeList **init)
 static int
 fncall(Node *l, Type *rt)
 {
+	Node r;
+
 	if(l->ullman >= UINF || l->op == OINDEXMAP)
 		return 1;
+	memset(&r, 0, sizeof r);
+	if(needwritebarrier(l, &r))
+		return 1;
 	if(eqtype(l->type, rt))
 		return 0;
 	return 1;
@@ -1533,8 +1552,10 @@ ascompatet(int op, NodeList *nl, Type **nr, int fp, NodeList **init)
 		a = nod(OAS, l, nodarg(r, fp));
 		a = convas(a, init);
 		ullmancalc(a);
-		if(a->ullman >= UINF)
+		if(a->ullman >= UINF) {
+			dump("ascompatet ucount", a);
 			ucount++;
+		}
 		nn = list(nn, a);
 		r = structnext(&saver);
 	}
@@ -1932,6 +1953,161 @@ callnew(Type *t)
 	return mkcall1(fn, ptrto(t), nil, typename(t));
 }
 
+static int
+isstack(Node *n)
+{
+	while(n->op == ODOT || n->op == OPAREN || n->op == OCONVNOP || n->op == OINDEX && isfixedarray(n->left->type))
+		n = n->left;
+	
+	switch(n->op) {
+	case OINDREG:
+		// OINDREG only ends up in walk if it's indirect of SP.
+		return 1;
+
+	case ONAME:
+		switch(n->class) {
+		case PAUTO:
+		case PPARAM:
+		case PPARAMOUT:
+			return 1;
+		}
+		break;
+	}
+	
+	return 0;
+}
+
+static int
+isglobal(Node *n)
+{
+	while(n->op == ODOT || n->op == OPAREN || n->op == OCONVNOP || n->op == OINDEX && isfixedarray(n->left->type))
+		n = n->left;
+	
+	switch(n->op) {
+	case ONAME:
+		switch(n->class) {
+		case PEXTERN:
+			return 1;
+		}
+		break;
+	}
+	
+	return 0;
+}
+
+// Do we need a write barrier for the assignment l = r?
+int
+needwritebarrier(Node *l, Node *r)
+{
+	if(!use_writebarrier)
+		return 0;
+
+	if(l == N || isblank(l))
+		return 0;
+
+	// No write barrier for write of non-pointers.
+	dowidth(l->type);
+	if(!haspointers(l->type))
+		return 0;
+
+	// No write barrier for write to stack.
+	if(isstack(l))
+		return 0;
+
+	// No write barrier for implicit or explicit zeroing.
+	if(r == N || iszero(r))
+		return 0;
+
+	// No write barrier for initialization to constant.
+	if(r->op == OLITERAL)
+		return 0;
+
+	// No write barrier for storing static (read-only) data.
+	if(r->op == ONAME && strncmp(r->sym->name, "statictmp_", 10) == 0)
+		return 0;
+
+	// No write barrier for storing address of stack values,
+	// which are guaranteed only to be written to the stack.
+	if(r->op == OADDR && isstack(r->left))
+		return 0;
+
+	// No write barrier for storing address of global, which
+	// is live no matter what.
+	if(r->op == OADDR && isglobal(r->left))
+		return 0;
+
+	// No write barrier for reslice: x = x[0:y] or x = append(x, ...).
+	// Both are compiled to modify x directly.
+	// In the case of append, a write barrier may still be needed
+	// if the underlying array grows, but the append code can
+	// generate the write barrier directly in that case.
+	// (It does not yet, but the cost of the write barrier will be
+	// small compared to the cost of the allocation.)
+	if(r->reslice) {
+		switch(r->op) {
+		case OSLICE:
+		case OSLICE3:
+		case OSLICESTR:
+		case OAPPEND:
+			break;
+		default:
+			dump("bad reslice-l", l);
+			dump("bad reslice-r", r);
+			break;
+		}
+		return 0;
+	}
+
+	// Otherwise, be conservative and use write barrier.
+	return 1;
+}
+
+// TODO(rsc): Perhaps componentgen should run before this.
+static Node*
+applywritebarrier(Node *n, NodeList **init)
+{
+	Node *l, *r;
+	Type *t;
+
+	if(n->left && n->right && needwritebarrier(n->left, n->right)) {
+		t = n->left->type;
+		l = nod(OADDR, n->left, N);
+		l->etype = 1; // addr does not escape
+		if(t->width == widthptr) {
+			n = mkcall1(writebarrierfn("writebarrierptr", t, n->right->type), T, init,
+				l, n->right);
+		} else if(t->etype == TSTRING) {
+			n = mkcall1(writebarrierfn("writebarrierstring", t, n->right->type), T, init,
+				l, n->right);
+		} else if(isslice(t)) {
+			n = mkcall1(writebarrierfn("writebarrierslice", t, n->right->type), T, init,
+				l, n->right);
+		} else if(isinter(t)) {
+			n = mkcall1(writebarrierfn("writebarrieriface", t, n->right->type), T, init,
+				l, n->right);
+		} else if(t->width == 2*widthptr) {
+			n = mkcall1(writebarrierfn("writebarrierfat2", t, n->right->type), T, init,
+				l, nodnil(), n->right);
+		} else if(t->width == 3*widthptr) {
+			n = mkcall1(writebarrierfn("writebarrierfat3", t, n->right->type), T, init,
+				l, nodnil(), n->right);
+		} else if(t->width == 4*widthptr) {
+			n = mkcall1(writebarrierfn("writebarrierfat4", t, n->right->type), T, init,
+				l, nodnil(), n->right);
+		} else {
+			r = n->right;
+			while(r->op == OCONVNOP)
+				r = r->left;
+			r = nod(OADDR, r, N);
+			r->etype = 1; // addr does not escape
+			//warnl(n->lineno, "writebarrierfat %T %N", t, r);
+			n = mkcall1(writebarrierfn("writebarrierfat", t, r->left->type), T, init,
+				typename(t), l, r);
+		}
+	}
+	return n;
+}
+
 static Node*
 convas(Node *n, NodeList **init)
 {
@@ -1971,11 +2147,10 @@ convas(Node *n, NodeList **init)
 		goto out;
 	}
 
-	if(eqtype(lt, rt))
-		goto out;
-
-	n->right = assignconv(n->right, lt, "assignment");
-	walkexpr(&n->right, init);
+	if(!eqtype(lt, rt)) {
+		n->right = assignconv(n->right, lt, "assignment");
+		walkexpr(&n->right, init);
+	}
 
 out:
 	ullmancalc(n);
@@ -2369,7 +2544,7 @@ paramstoheap(Type **argin, int out)
 
 		// generate allocation & copying code
 		if(compiling_runtime)
-			fatal("%N escapes to heap, not allowed in runtime.", v);
+			yyerror("%N escapes to heap, not allowed in runtime.", v);
 		if(v->alloc == nil)
 			v->alloc = callnew(v->type);
 		nn = list(nn, nod(OAS, v->heapaddr, v->alloc));
@@ -2526,6 +2701,17 @@ mapfndel(char *name, Type *t)
 	return fn;
 }
 
+static Node*
+writebarrierfn(char *name, Type *l, Type *r)
+{
+	Node *fn;
+
+	fn = syslook(name, 1);
+	argtype(fn, l);
+	argtype(fn, r);
+	return fn;
+}
+
 static Node*
 addstr(Node *n, NodeList **init)
 {
diff --git a/src/cmd/gc/y.tab.c b/src/cmd/gc/y.tab.c
index 47beae03b6..f464126ac9 100644
--- a/src/cmd/gc/y.tab.c
+++ b/src/cmd/gc/y.tab.c
@@ -663,37 +663,37 @@ static const yytype_uint16 yyrline[] =
      263,   264,   271,   271,   284,   288,   289,   293,   298,   304,
      308,   312,   316,   322,   328,   334,   339,   343,   347,   353,
      359,   363,   367,   373,   377,   383,   384,   388,   394,   403,
-     409,   427,   432,   444,   460,   465,   472,   492,   510,   519,
-     538,   537,   552,   551,   583,   586,   593,   592,   603,   609,
-     616,   623,   634,   640,   643,   651,   650,   661,   667,   679,
-     683,   688,   678,   709,   708,   721,   724,   730,   733,   745,
-     749,   744,   767,   766,   782,   783,   787,   791,   795,   799,
-     803,   807,   811,   815,   819,   823,   827,   831,   835,   839,
-     843,   847,   851,   855,   860,   866,   867,   871,   882,   886,
-     890,   894,   899,   903,   913,   917,   922,   930,   934,   935,
-     946,   950,   954,   958,   962,   970,   971,   977,   984,   990,
-     997,  1000,  1007,  1013,  1030,  1037,  1038,  1045,  1046,  1065,
-    1066,  1069,  1072,  1076,  1087,  1096,  1102,  1105,  1108,  1115,
-    1116,  1122,  1135,  1150,  1158,  1170,  1175,  1181,  1182,  1183,
-    1184,  1185,  1186,  1192,  1193,  1194,  1195,  1201,  1202,  1203,
-    1204,  1205,  1211,  1212,  1215,  1218,  1219,  1220,  1221,  1222,
-    1225,  1226,  1239,  1243,  1248,  1253,  1258,  1262,  1263,  1266,
-    1272,  1279,  1285,  1292,  1298,  1309,  1324,  1353,  1391,  1416,
-    1434,  1443,  1446,  1454,  1458,  1462,  1469,  1475,  1480,  1492,
-    1495,  1506,  1507,  1513,  1514,  1520,  1524,  1530,  1531,  1537,
-    1541,  1547,  1570,  1575,  1581,  1587,  1594,  1603,  1612,  1627,
-    1633,  1638,  1642,  1649,  1662,  1663,  1669,  1675,  1678,  1682,
-    1688,  1691,  1700,  1703,  1704,  1708,  1709,  1715,  1716,  1717,
-    1718,  1719,  1721,  1720,  1735,  1741,  1745,  1749,  1753,  1757,
-    1762,  1781,  1787,  1795,  1799,  1805,  1809,  1815,  1819,  1825,
-    1829,  1838,  1842,  1846,  1850,  1856,  1859,  1867,  1868,  1870,
-    1871,  1874,  1877,  1880,  1883,  1886,  1889,  1892,  1895,  1898,
-    1901,  1904,  1907,  1910,  1913,  1919,  1923,  1927,  1931,  1935,
-    1939,  1959,  1966,  1977,  1978,  1979,  1982,  1983,  1986,  1990,
-    2000,  2004,  2008,  2012,  2016,  2020,  2024,  2030,  2036,  2044,
-    2052,  2058,  2065,  2081,  2103,  2107,  2113,  2116,  2119,  2123,
-    2133,  2137,  2156,  2164,  2165,  2177,  2178,  2181,  2185,  2191,
-    2195,  2201,  2205
+     409,   427,   432,   444,   460,   466,   474,   494,   512,   521,
+     540,   539,   554,   553,   585,   588,   595,   594,   605,   611,
+     618,   625,   636,   642,   645,   653,   652,   663,   669,   681,
+     685,   690,   680,   711,   710,   723,   726,   732,   735,   747,
+     751,   746,   769,   768,   784,   785,   789,   793,   797,   801,
+     805,   809,   813,   817,   821,   825,   829,   833,   837,   841,
+     845,   849,   853,   857,   862,   868,   869,   873,   884,   888,
+     892,   896,   901,   905,   915,   919,   924,   932,   936,   937,
+     948,   952,   956,   960,   964,   972,   973,   979,   986,   992,
+     999,  1002,  1009,  1015,  1032,  1039,  1040,  1047,  1048,  1067,
+    1068,  1071,  1074,  1078,  1089,  1098,  1104,  1107,  1110,  1117,
+    1118,  1124,  1137,  1152,  1160,  1172,  1177,  1183,  1184,  1185,
+    1186,  1187,  1188,  1194,  1195,  1196,  1197,  1203,  1204,  1205,
+    1206,  1207,  1213,  1214,  1217,  1220,  1221,  1222,  1223,  1224,
+    1227,  1228,  1241,  1245,  1250,  1255,  1260,  1264,  1265,  1268,
+    1274,  1281,  1287,  1294,  1300,  1311,  1326,  1355,  1393,  1418,
+    1436,  1445,  1448,  1456,  1460,  1464,  1471,  1477,  1482,  1494,
+    1497,  1508,  1509,  1515,  1516,  1522,  1526,  1532,  1533,  1539,
+    1543,  1549,  1572,  1577,  1583,  1589,  1596,  1605,  1614,  1629,
+    1635,  1640,  1644,  1651,  1664,  1665,  1671,  1677,  1680,  1684,
+    1690,  1693,  1702,  1705,  1706,  1710,  1711,  1717,  1718,  1719,
+    1720,  1721,  1723,  1722,  1737,  1743,  1747,  1751,  1755,  1759,
+    1764,  1783,  1789,  1797,  1801,  1807,  1811,  1817,  1821,  1827,
+    1831,  1840,  1844,  1848,  1852,  1858,  1861,  1869,  1870,  1872,
+    1873,  1876,  1879,  1882,  1885,  1888,  1891,  1894,  1897,  1900,
+    1903,  1906,  1909,  1912,  1915,  1921,  1925,  1929,  1933,  1937,
+    1941,  1961,  1968,  1979,  1980,  1981,  1984,  1985,  1988,  1992,
+    2002,  2006,  2010,  2014,  2018,  2022,  2026,  2032,  2038,  2046,
+    2054,  2060,  2067,  2083,  2105,  2109,  2115,  2118,  2121,  2125,
+    2135,  2139,  2158,  2166,  2167,  2179,  2180,  2183,  2187,  2193,
+    2197,  2203,  2207
 };
 #endif
 
@@ -2781,20 +2781,22 @@ yyreduce:
 #line 461 "go.y"
     {
 		(yyval.node) = nod(OASOP, (yyvsp[(1) - (2)].node), nodintconst(1));
+		(yyval.node)->implicit = 1;
 		(yyval.node)->etype = OADD;
 	}
     break;
 
   case 55:
-#line 466 "go.y"
+#line 467 "go.y"
     {
 		(yyval.node) = nod(OASOP, (yyvsp[(1) - (2)].node), nodintconst(1));
+		(yyval.node)->implicit = 1;
 		(yyval.node)->etype = OSUB;
 	}
     break;
 
   case 56:
-#line 473 "go.y"
+#line 475 "go.y"
     {
 		Node *n, *nn;
 
@@ -2817,7 +2819,7 @@ yyreduce:
     break;
 
   case 57:
-#line 493 "go.y"
+#line 495 "go.y"
     {
 		Node *n;
 
@@ -2838,7 +2840,7 @@ yyreduce:
     break;
 
   case 58:
-#line 511 "go.y"
+#line 513 "go.y"
     {
 		// will be converted to OCASE
 		// right will point to next case
@@ -2850,7 +2852,7 @@ yyreduce:
     break;
 
   case 59:
-#line 520 "go.y"
+#line 522 "go.y"
     {
 		Node *n, *nn;
 
@@ -2869,14 +2871,14 @@ yyreduce:
     break;
 
   case 60:
-#line 538 "go.y"
+#line 540 "go.y"
     {
 		markdcl();
 	}
     break;
 
   case 61:
-#line 542 "go.y"
+#line 544 "go.y"
     {
 		if((yyvsp[(3) - (4)].list) == nil)
 			(yyval.node) = nod(OEMPTY, N, N);
@@ -2887,7 +2889,7 @@ yyreduce:
     break;
 
   case 62:
-#line 552 "go.y"
+#line 554 "go.y"
     {
 		// If the last token read by the lexer was consumed
 		// as part of the case, clear it (parser has cleared yychar).
@@ -2901,7 +2903,7 @@ yyreduce:
     break;
 
   case 63:
-#line 563 "go.y"
+#line 565 "go.y"
     {
 		int last;
 
@@ -2923,28 +2925,28 @@ yyreduce:
     break;
 
   case 64:
-#line 583 "go.y"
+#line 585 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 65:
-#line 587 "go.y"
+#line 589 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node));
 	}
     break;
 
   case 66:
-#line 593 "go.y"
+#line 595 "go.y"
     {
 		markdcl();
 	}
     break;
 
   case 67:
-#line 597 "go.y"
+#line 599 "go.y"
     {
 		(yyval.list) = (yyvsp[(3) - (4)].list);
 		popdcl();
@@ -2952,7 +2954,7 @@ yyreduce:
     break;
 
   case 68:
-#line 604 "go.y"
+#line 606 "go.y"
     {
 		(yyval.node) = nod(ORANGE, N, (yyvsp[(4) - (4)].node));
 		(yyval.node)->list = (yyvsp[(1) - (4)].list);
@@ -2961,7 +2963,7 @@ yyreduce:
     break;
 
   case 69:
-#line 610 "go.y"
+#line 612 "go.y"
     {
 		(yyval.node) = nod(ORANGE, N, (yyvsp[(4) - (4)].node));
 		(yyval.node)->list = (yyvsp[(1) - (4)].list);
@@ -2971,7 +2973,7 @@ yyreduce:
     break;
 
   case 70:
-#line 617 "go.y"
+#line 619 "go.y"
     {
 		(yyval.node) = nod(ORANGE, N, (yyvsp[(2) - (2)].node));
 		(yyval.node)->etype = 0; // := flag
@@ -2979,7 +2981,7 @@ yyreduce:
     break;
 
   case 71:
-#line 624 "go.y"
+#line 626 "go.y"
     {
 		// init ; test ; incr
 		if((yyvsp[(5) - (5)].node) != N && (yyvsp[(5) - (5)].node)->colas != 0)
@@ -2993,7 +2995,7 @@ yyreduce:
     break;
 
   case 72:
-#line 635 "go.y"
+#line 637 "go.y"
     {
 		// normal test
 		(yyval.node) = nod(OFOR, N, N);
@@ -3002,7 +3004,7 @@ yyreduce:
     break;
 
   case 74:
-#line 644 "go.y"
+#line 646 "go.y"
     {
 		(yyval.node) = (yyvsp[(1) - (2)].node);
 		(yyval.node)->nbody = concat((yyval.node)->nbody, (yyvsp[(2) - (2)].list));
@@ -3010,14 +3012,14 @@ yyreduce:
     break;
 
   case 75:
-#line 651 "go.y"
+#line 653 "go.y"
     {
 		markdcl();
 	}
     break;
 
   case 76:
-#line 655 "go.y"
+#line 657 "go.y"
     {
 		(yyval.node) = (yyvsp[(3) - (3)].node);
 		popdcl();
@@ -3025,7 +3027,7 @@ yyreduce:
     break;
 
   case 77:
-#line 662 "go.y"
+#line 664 "go.y"
     {
 		// test
 		(yyval.node) = nod(OIF, N, N);
@@ -3034,7 +3036,7 @@ yyreduce:
     break;
 
   case 78:
-#line 668 "go.y"
+#line 670 "go.y"
     {
 		// init ; test
 		(yyval.node) = nod(OIF, N, N);
@@ -3045,14 +3047,14 @@ yyreduce:
     break;
 
   case 79:
-#line 679 "go.y"
+#line 681 "go.y"
     {
 		markdcl();
 	}
     break;
 
   case 80:
-#line 683 "go.y"
+#line 685 "go.y"
     {
 		if((yyvsp[(3) - (3)].node)->ntest == N)
 			yyerror("missing condition in if statement");
@@ -3060,14 +3062,14 @@ yyreduce:
     break;
 
   case 81:
-#line 688 "go.y"
+#line 690 "go.y"
     {
 		(yyvsp[(3) - (5)].node)->nbody = (yyvsp[(5) - (5)].list);
 	}
     break;
 
   case 82:
-#line 692 "go.y"
+#line 694 "go.y"
     {
 		Node *n;
 		NodeList *nn;
@@ -3085,14 +3087,14 @@ yyreduce:
     break;
 
   case 83:
-#line 709 "go.y"
+#line 711 "go.y"
     {
 		markdcl();
 	}
     break;
 
   case 84:
-#line 713 "go.y"
+#line 715 "go.y"
     {
 		if((yyvsp[(4) - (5)].node)->ntest == N)
 			yyerror("missing condition in if statement");
@@ -3102,28 +3104,28 @@ yyreduce:
     break;
 
   case 85:
-#line 721 "go.y"
+#line 723 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 86:
-#line 725 "go.y"
+#line 727 "go.y"
     {
 		(yyval.list) = concat((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].list));
 	}
     break;
 
   case 87:
-#line 730 "go.y"
+#line 732 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 88:
-#line 734 "go.y"
+#line 736 "go.y"
     {
 		NodeList *node;
 		
@@ -3135,14 +3137,14 @@ yyreduce:
     break;
 
   case 89:
-#line 745 "go.y"
+#line 747 "go.y"
     {
 		markdcl();
 	}
     break;
 
   case 90:
-#line 749 "go.y"
+#line 751 "go.y"
     {
 		Node *n;
 		n = (yyvsp[(3) - (3)].node)->ntest;
@@ -3153,7 +3155,7 @@ yyreduce:
     break;
 
   case 91:
-#line 757 "go.y"
+#line 759 "go.y"
     {
 		(yyval.node) = (yyvsp[(3) - (7)].node);
 		(yyval.node)->op = OSWITCH;
@@ -3164,14 +3166,14 @@ yyreduce:
     break;
 
   case 92:
-#line 767 "go.y"
+#line 769 "go.y"
     {
 		typesw = nod(OXXX, typesw, N);
 	}
     break;
 
   case 93:
-#line 771 "go.y"
+#line 773 "go.y"
     {
 		(yyval.node) = nod(OSELECT, N, N);
 		(yyval.node)->lineno = typesw->lineno;
@@ -3181,154 +3183,154 @@ yyreduce:
     break;
 
   case 95:
-#line 784 "go.y"
+#line 786 "go.y"
     {
 		(yyval.node) = nod(OOROR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 96:
-#line 788 "go.y"
+#line 790 "go.y"
     {
 		(yyval.node) = nod(OANDAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 97:
-#line 792 "go.y"
+#line 794 "go.y"
     {
 		(yyval.node) = nod(OEQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 98:
-#line 796 "go.y"
+#line 798 "go.y"
     {
 		(yyval.node) = nod(ONE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 99:
-#line 800 "go.y"
+#line 802 "go.y"
     {
 		(yyval.node) = nod(OLT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 100:
-#line 804 "go.y"
+#line 806 "go.y"
     {
 		(yyval.node) = nod(OLE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 101:
-#line 808 "go.y"
+#line 810 "go.y"
     {
 		(yyval.node) = nod(OGE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 102:
-#line 812 "go.y"
+#line 814 "go.y"
     {
 		(yyval.node) = nod(OGT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 103:
-#line 816 "go.y"
+#line 818 "go.y"
     {
 		(yyval.node) = nod(OADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 104:
-#line 820 "go.y"
+#line 822 "go.y"
     {
 		(yyval.node) = nod(OSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 105:
-#line 824 "go.y"
+#line 826 "go.y"
     {
 		(yyval.node) = nod(OOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 106:
-#line 828 "go.y"
+#line 830 "go.y"
     {
 		(yyval.node) = nod(OXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 107:
-#line 832 "go.y"
+#line 834 "go.y"
     {
 		(yyval.node) = nod(OMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 108:
-#line 836 "go.y"
+#line 838 "go.y"
     {
 		(yyval.node) = nod(ODIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 109:
-#line 840 "go.y"
+#line 842 "go.y"
     {
 		(yyval.node) = nod(OMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 110:
-#line 844 "go.y"
+#line 846 "go.y"
     {
 		(yyval.node) = nod(OAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 111:
-#line 848 "go.y"
+#line 850 "go.y"
     {
 		(yyval.node) = nod(OANDNOT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 112:
-#line 852 "go.y"
+#line 854 "go.y"
     {
 		(yyval.node) = nod(OLSH, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 113:
-#line 856 "go.y"
+#line 858 "go.y"
     {
 		(yyval.node) = nod(ORSH, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 114:
-#line 861 "go.y"
+#line 863 "go.y"
     {
 		(yyval.node) = nod(OSEND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 116:
-#line 868 "go.y"
+#line 870 "go.y"
     {
 		(yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 117:
-#line 872 "go.y"
+#line 874 "go.y"
     {
 		if((yyvsp[(2) - (2)].node)->op == OCOMPLIT) {
 			// Special case for &T{...}: turn into (*T){...}.
@@ -3342,28 +3344,28 @@ yyreduce:
     break;
 
   case 118:
-#line 883 "go.y"
+#line 885 "go.y"
     {
 		(yyval.node) = nod(OPLUS, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 119:
-#line 887 "go.y"
+#line 889 "go.y"
     {
 		(yyval.node) = nod(OMINUS, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 120:
-#line 891 "go.y"
+#line 893 "go.y"
     {
 		(yyval.node) = nod(ONOT, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 121:
-#line 895 "go.y"
+#line 897 "go.y"
     {
 		yyerror("the bitwise complement operator is ^");
 		(yyval.node) = nod(OCOM, (yyvsp[(2) - (2)].node), N);
@@ -3371,28 +3373,28 @@ yyreduce:
     break;
 
   case 122:
-#line 900 "go.y"
+#line 902 "go.y"
     {
 		(yyval.node) = nod(OCOM, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 123:
-#line 904 "go.y"
+#line 906 "go.y"
     {
 		(yyval.node) = nod(ORECV, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 124:
-#line 914 "go.y"
+#line 916 "go.y"
     {
 		(yyval.node) = nod(OCALL, (yyvsp[(1) - (3)].node), N);
 	}
     break;
 
   case 125:
-#line 918 "go.y"
+#line 920 "go.y"
     {
 		(yyval.node) = nod(OCALL, (yyvsp[(1) - (5)].node), N);
 		(yyval.node)->list = (yyvsp[(3) - (5)].list);
@@ -3400,7 +3402,7 @@ yyreduce:
     break;
 
   case 126:
-#line 923 "go.y"
+#line 925 "go.y"
     {
 		(yyval.node) = nod(OCALL, (yyvsp[(1) - (6)].node), N);
 		(yyval.node)->list = (yyvsp[(3) - (6)].list);
@@ -3409,14 +3411,14 @@ yyreduce:
     break;
 
   case 127:
-#line 931 "go.y"
+#line 933 "go.y"
     {
 		(yyval.node) = nodlit((yyvsp[(1) - (1)].val));
 	}
     break;
 
   case 129:
-#line 936 "go.y"
+#line 938 "go.y"
     {
 		if((yyvsp[(1) - (3)].node)->op == OPACK) {
 			Sym *s;
@@ -3430,35 +3432,35 @@ yyreduce:
     break;
 
   case 130:
-#line 947 "go.y"
+#line 949 "go.y"
     {
 		(yyval.node) = nod(ODOTTYPE, (yyvsp[(1) - (5)].node), (yyvsp[(4) - (5)].node));
 	}
     break;
 
   case 131:
-#line 951 "go.y"
+#line 953 "go.y"
     {
 		(yyval.node) = nod(OTYPESW, N, (yyvsp[(1) - (5)].node));
 	}
     break;
 
   case 132:
-#line 955 "go.y"
+#line 957 "go.y"
     {
 		(yyval.node) = nod(OINDEX, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
 	}
     break;
 
   case 133:
-#line 959 "go.y"
+#line 961 "go.y"
     {
 		(yyval.node) = nod(OSLICE, (yyvsp[(1) - (6)].node), nod(OKEY, (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node)));
 	}
     break;
 
   case 134:
-#line 963 "go.y"
+#line 965 "go.y"
     {
 		if((yyvsp[(5) - (8)].node) == N)
 			yyerror("middle index required in 3-index slice");
@@ -3469,7 +3471,7 @@ yyreduce:
     break;
 
   case 136:
-#line 972 "go.y"
+#line 974 "go.y"
     {
 		// conversion
 		(yyval.node) = nod(OCALL, (yyvsp[(1) - (5)].node), N);
@@ -3478,7 +3480,7 @@ yyreduce:
     break;
 
   case 137:
-#line 978 "go.y"
+#line 980 "go.y"
     {
 		(yyval.node) = (yyvsp[(3) - (5)].node);
 		(yyval.node)->right = (yyvsp[(1) - (5)].node);
@@ -3488,7 +3490,7 @@ yyreduce:
     break;
 
   case 138:
-#line 985 "go.y"
+#line 987 "go.y"
     {
 		(yyval.node) = (yyvsp[(3) - (5)].node);
 		(yyval.node)->right = (yyvsp[(1) - (5)].node);
@@ -3497,7 +3499,7 @@ yyreduce:
     break;
 
   case 139:
-#line 991 "go.y"
+#line 993 "go.y"
     {
 		yyerror("cannot parenthesize type in composite literal");
 		(yyval.node) = (yyvsp[(5) - (7)].node);
@@ -3507,7 +3509,7 @@ yyreduce:
     break;
 
   case 141:
-#line 1000 "go.y"
+#line 1002 "go.y"
     {
 		// composite expression.
 		// make node early so we get the right line number.
@@ -3516,14 +3518,14 @@ yyreduce:
     break;
 
   case 142:
-#line 1008 "go.y"
+#line 1010 "go.y"
     {
 		(yyval.node) = nod(OKEY, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 143:
-#line 1014 "go.y"
+#line 1016 "go.y"
     {
 		// These nodes do not carry line numbers.
 		// Since a composite literal commonly spans several lines,
@@ -3543,7 +3545,7 @@ yyreduce:
     break;
 
   case 144:
-#line 1031 "go.y"
+#line 1033 "go.y"
     {
 		(yyval.node) = (yyvsp[(2) - (4)].node);
 		(yyval.node)->list = (yyvsp[(3) - (4)].list);
@@ -3551,7 +3553,7 @@ yyreduce:
     break;
 
   case 146:
-#line 1039 "go.y"
+#line 1041 "go.y"
     {
 		(yyval.node) = (yyvsp[(2) - (4)].node);
 		(yyval.node)->list = (yyvsp[(3) - (4)].list);
@@ -3559,7 +3561,7 @@ yyreduce:
     break;
 
   case 148:
-#line 1047 "go.y"
+#line 1049 "go.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
 		
@@ -3579,21 +3581,21 @@ yyreduce:
     break;
 
   case 152:
-#line 1073 "go.y"
+#line 1075 "go.y"
     {
 		(yyval.i) = LBODY;
 	}
     break;
 
   case 153:
-#line 1077 "go.y"
+#line 1079 "go.y"
     {
 		(yyval.i) = '{';
 	}
     break;
 
   case 154:
-#line 1088 "go.y"
+#line 1090 "go.y"
     {
 		if((yyvsp[(1) - (1)].sym) == S)
 			(yyval.node) = N;
@@ -3603,21 +3605,21 @@ yyreduce:
     break;
 
   case 155:
-#line 1097 "go.y"
+#line 1099 "go.y"
     {
 		(yyval.node) = dclname((yyvsp[(1) - (1)].sym));
 	}
     break;
 
   case 156:
-#line 1102 "go.y"
+#line 1104 "go.y"
     {
 		(yyval.node) = N;
 	}
     break;
 
   case 158:
-#line 1109 "go.y"
+#line 1111 "go.y"
     {
 		(yyval.sym) = (yyvsp[(1) - (1)].sym);
 		// during imports, unqualified non-exported identifiers are from builtinpkg
@@ -3627,14 +3629,14 @@ yyreduce:
     break;
 
   case 160:
-#line 1117 "go.y"
+#line 1119 "go.y"
     {
 		(yyval.sym) = S;
 	}
     break;
 
   case 161:
-#line 1123 "go.y"
+#line 1125 "go.y"
     {
 		Pkg *p;
 
@@ -3650,7 +3652,7 @@ yyreduce:
     break;
 
   case 162:
-#line 1136 "go.y"
+#line 1138 "go.y"
     {
 		Pkg *p;
 
@@ -3666,7 +3668,7 @@ yyreduce:
     break;
 
   case 163:
-#line 1151 "go.y"
+#line 1153 "go.y"
     {
 		(yyval.node) = oldname((yyvsp[(1) - (1)].sym));
 		if((yyval.node)->pack != N)
@@ -3675,7 +3677,7 @@ yyreduce:
     break;
 
   case 165:
-#line 1171 "go.y"
+#line 1173 "go.y"
     {
 		yyerror("final argument in variadic function missing type");
 		(yyval.node) = nod(ODDD, typenod(typ(TINTER)), N);
@@ -3683,35 +3685,35 @@ yyreduce:
     break;
 
   case 166:
-#line 1176 "go.y"
+#line 1178 "go.y"
     {
 		(yyval.node) = nod(ODDD, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 172:
-#line 1187 "go.y"
+#line 1189 "go.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
 	}
     break;
 
   case 176:
-#line 1196 "go.y"
+#line 1198 "go.y"
     {
 		(yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 181:
-#line 1206 "go.y"
+#line 1208 "go.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
 	}
     break;
 
   case 191:
-#line 1227 "go.y"
+#line 1229 "go.y"
     {
 		if((yyvsp[(1) - (3)].node)->op == OPACK) {
 			Sym *s;
@@ -3725,14 +3727,14 @@ yyreduce:
     break;
 
   case 192:
-#line 1240 "go.y"
+#line 1242 "go.y"
     {
 		(yyval.node) = nod(OTARRAY, (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
 	}
     break;
 
   case 193:
-#line 1244 "go.y"
+#line 1246 "go.y"
     {
 		// array literal of nelem
 		(yyval.node) = nod(OTARRAY, nod(ODDD, N, N), (yyvsp[(4) - (4)].node));
@@ -3740,7 +3742,7 @@ yyreduce:
     break;
 
   case 194:
-#line 1249 "go.y"
+#line 1251 "go.y"
     {
 		(yyval.node) = nod(OTCHAN, (yyvsp[(2) - (2)].node), N);
 		(yyval.node)->etype = Cboth;
@@ -3748,7 +3750,7 @@ yyreduce:
     break;
 
   case 195:
-#line 1254 "go.y"
+#line 1256 "go.y"
     {
 		(yyval.node) = nod(OTCHAN, (yyvsp[(3) - (3)].node), N);
 		(yyval.node)->etype = Csend;
@@ -3756,21 +3758,21 @@ yyreduce:
     break;
 
   case 196:
-#line 1259 "go.y"
+#line 1261 "go.y"
     {
 		(yyval.node) = nod(OTMAP, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
 	}
     break;
 
   case 199:
-#line 1267 "go.y"
+#line 1269 "go.y"
     {
 		(yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 200:
-#line 1273 "go.y"
+#line 1275 "go.y"
     {
 		(yyval.node) = nod(OTCHAN, (yyvsp[(3) - (3)].node), N);
 		(yyval.node)->etype = Crecv;
@@ -3778,7 +3780,7 @@ yyreduce:
     break;
 
   case 201:
-#line 1280 "go.y"
+#line 1282 "go.y"
     {
 		(yyval.node) = nod(OTSTRUCT, N, N);
 		(yyval.node)->list = (yyvsp[(3) - (5)].list);
@@ -3787,7 +3789,7 @@ yyreduce:
     break;
 
   case 202:
-#line 1286 "go.y"
+#line 1288 "go.y"
     {
 		(yyval.node) = nod(OTSTRUCT, N, N);
 		fixlbrace((yyvsp[(2) - (3)].i));
@@ -3795,7 +3797,7 @@ yyreduce:
     break;
 
   case 203:
-#line 1293 "go.y"
+#line 1295 "go.y"
     {
 		(yyval.node) = nod(OTINTER, N, N);
 		(yyval.node)->list = (yyvsp[(3) - (5)].list);
@@ -3804,7 +3806,7 @@ yyreduce:
     break;
 
   case 204:
-#line 1299 "go.y"
+#line 1301 "go.y"
     {
 		(yyval.node) = nod(OTINTER, N, N);
 		fixlbrace((yyvsp[(2) - (3)].i));
@@ -3812,7 +3814,7 @@ yyreduce:
     break;
 
   case 205:
-#line 1310 "go.y"
+#line 1312 "go.y"
     {
 		(yyval.node) = (yyvsp[(2) - (3)].node);
 		if((yyval.node) == N)
@@ -3828,7 +3830,7 @@ yyreduce:
     break;
 
   case 206:
-#line 1325 "go.y"
+#line 1327 "go.y"
     {
 		Node *t;
 
@@ -3860,7 +3862,7 @@ yyreduce:
     break;
 
   case 207:
-#line 1354 "go.y"
+#line 1356 "go.y"
     {
 		Node *rcvr, *t;
 
@@ -3899,7 +3901,7 @@ yyreduce:
     break;
 
   case 208:
-#line 1392 "go.y"
+#line 1394 "go.y"
     {
 		Sym *s;
 		Type *t;
@@ -3927,7 +3929,7 @@ yyreduce:
     break;
 
   case 209:
-#line 1417 "go.y"
+#line 1419 "go.y"
     {
 		(yyval.node) = methodname1(newname((yyvsp[(4) - (8)].sym)), (yyvsp[(2) - (8)].list)->n->right); 
 		(yyval.node)->type = functype((yyvsp[(2) - (8)].list)->n, (yyvsp[(6) - (8)].list), (yyvsp[(8) - (8)].list));
@@ -3946,7 +3948,7 @@ yyreduce:
     break;
 
   case 210:
-#line 1435 "go.y"
+#line 1437 "go.y"
     {
 		(yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1);
 		(yyval.node) = nod(OTFUNC, N, N);
@@ -3956,14 +3958,14 @@ yyreduce:
     break;
 
   case 211:
-#line 1443 "go.y"
+#line 1445 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 212:
-#line 1447 "go.y"
+#line 1449 "go.y"
     {
 		(yyval.list) = (yyvsp[(2) - (3)].list);
 		if((yyval.list) == nil)
@@ -3972,21 +3974,21 @@ yyreduce:
     break;
 
   case 213:
-#line 1455 "go.y"
+#line 1457 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 214:
-#line 1459 "go.y"
+#line 1461 "go.y"
     {
 		(yyval.list) = list1(nod(ODCLFIELD, N, (yyvsp[(1) - (1)].node)));
 	}
     break;
 
   case 215:
-#line 1463 "go.y"
+#line 1465 "go.y"
     {
 		(yyvsp[(2) - (3)].list) = checkarglist((yyvsp[(2) - (3)].list), 0);
 		(yyval.list) = (yyvsp[(2) - (3)].list);
@@ -3994,14 +3996,14 @@ yyreduce:
     break;
 
   case 216:
-#line 1470 "go.y"
+#line 1472 "go.y"
     {
 		closurehdr((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 217:
-#line 1476 "go.y"
+#line 1478 "go.y"
     {
 		(yyval.node) = closurebody((yyvsp[(3) - (4)].list));
 		fixlbrace((yyvsp[(2) - (4)].i));
@@ -4009,21 +4011,21 @@ yyreduce:
     break;
 
   case 218:
-#line 1481 "go.y"
+#line 1483 "go.y"
     {
 		(yyval.node) = closurebody(nil);
 	}
     break;
 
   case 219:
-#line 1492 "go.y"
+#line 1494 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 220:
-#line 1496 "go.y"
+#line 1498 "go.y"
     {
 		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(2) - (3)].list));
 		if(nsyntaxerrors == 0)
@@ -4035,56 +4037,56 @@ yyreduce:
     break;
 
   case 222:
-#line 1508 "go.y"
+#line 1510 "go.y"
     {
 		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list));
 	}
     break;
 
   case 224:
-#line 1515 "go.y"
+#line 1517 "go.y"
     {
 		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list));
 	}
     break;
 
   case 225:
-#line 1521 "go.y"
+#line 1523 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 226:
-#line 1525 "go.y"
+#line 1527 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 228:
-#line 1532 "go.y"
+#line 1534 "go.y"
     {
 		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list));
 	}
     break;
 
   case 229:
-#line 1538 "go.y"
+#line 1540 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 230:
-#line 1542 "go.y"
+#line 1544 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 231:
-#line 1548 "go.y"
+#line 1550 "go.y"
     {
 		NodeList *l;
 
@@ -4110,7 +4112,7 @@ yyreduce:
     break;
 
   case 232:
-#line 1571 "go.y"
+#line 1573 "go.y"
     {
 		(yyvsp[(1) - (2)].node)->val = (yyvsp[(2) - (2)].val);
 		(yyval.list) = list1((yyvsp[(1) - (2)].node));
@@ -4118,7 +4120,7 @@ yyreduce:
     break;
 
   case 233:
-#line 1576 "go.y"
+#line 1578 "go.y"
     {
 		(yyvsp[(2) - (4)].node)->val = (yyvsp[(4) - (4)].val);
 		(yyval.list) = list1((yyvsp[(2) - (4)].node));
@@ -4127,7 +4129,7 @@ yyreduce:
     break;
 
   case 234:
-#line 1582 "go.y"
+#line 1584 "go.y"
     {
 		(yyvsp[(2) - (3)].node)->right = nod(OIND, (yyvsp[(2) - (3)].node)->right, N);
 		(yyvsp[(2) - (3)].node)->val = (yyvsp[(3) - (3)].val);
@@ -4136,7 +4138,7 @@ yyreduce:
     break;
 
   case 235:
-#line 1588 "go.y"
+#line 1590 "go.y"
     {
 		(yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N);
 		(yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val);
@@ -4146,7 +4148,7 @@ yyreduce:
     break;
 
   case 236:
-#line 1595 "go.y"
+#line 1597 "go.y"
     {
 		(yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N);
 		(yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val);
@@ -4156,7 +4158,7 @@ yyreduce:
     break;
 
   case 237:
-#line 1604 "go.y"
+#line 1606 "go.y"
     {
 		Node *n;
 
@@ -4168,7 +4170,7 @@ yyreduce:
     break;
 
   case 238:
-#line 1613 "go.y"
+#line 1615 "go.y"
     {
 		Pkg *pkg;
 
@@ -4184,14 +4186,14 @@ yyreduce:
     break;
 
   case 239:
-#line 1628 "go.y"
+#line 1630 "go.y"
     {
 		(yyval.node) = embedded((yyvsp[(1) - (1)].sym), localpkg);
 	}
     break;
 
   case 240:
-#line 1634 "go.y"
+#line 1636 "go.y"
     {
 		(yyval.node) = nod(ODCLFIELD, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
 		ifacedcl((yyval.node));
@@ -4199,14 +4201,14 @@ yyreduce:
     break;
 
   case 241:
-#line 1639 "go.y"
+#line 1641 "go.y"
     {
 		(yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(1) - (1)].sym)));
 	}
     break;
 
   case 242:
-#line 1643 "go.y"
+#line 1645 "go.y"
     {
 		(yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(2) - (3)].sym)));
 		yyerror("cannot parenthesize embedded type");
@@ -4214,7 +4216,7 @@ yyreduce:
     break;
 
   case 243:
-#line 1650 "go.y"
+#line 1652 "go.y"
     {
 		// without func keyword
 		(yyvsp[(2) - (4)].list) = checkarglist((yyvsp[(2) - (4)].list), 1);
@@ -4225,7 +4227,7 @@ yyreduce:
     break;
 
   case 245:
-#line 1664 "go.y"
+#line 1666 "go.y"
     {
 		(yyval.node) = nod(ONONAME, N, N);
 		(yyval.node)->sym = (yyvsp[(1) - (2)].sym);
@@ -4234,7 +4236,7 @@ yyreduce:
     break;
 
   case 246:
-#line 1670 "go.y"
+#line 1672 "go.y"
     {
 		(yyval.node) = nod(ONONAME, N, N);
 		(yyval.node)->sym = (yyvsp[(1) - (2)].sym);
@@ -4243,56 +4245,56 @@ yyreduce:
     break;
 
   case 248:
-#line 1679 "go.y"
+#line 1681 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 249:
-#line 1683 "go.y"
+#line 1685 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 250:
-#line 1688 "go.y"
+#line 1690 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 251:
-#line 1692 "go.y"
+#line 1694 "go.y"
     {
 		(yyval.list) = (yyvsp[(1) - (2)].list);
 	}
     break;
 
   case 252:
-#line 1700 "go.y"
+#line 1702 "go.y"
     {
 		(yyval.node) = N;
 	}
     break;
 
   case 254:
-#line 1705 "go.y"
+#line 1707 "go.y"
     {
 		(yyval.node) = liststmt((yyvsp[(1) - (1)].list));
 	}
     break;
 
   case 256:
-#line 1710 "go.y"
+#line 1712 "go.y"
     {
 		(yyval.node) = N;
 	}
     break;
 
   case 262:
-#line 1721 "go.y"
+#line 1723 "go.y"
     {
 		(yyvsp[(1) - (2)].node) = nod(OLABEL, (yyvsp[(1) - (2)].node), N);
 		(yyvsp[(1) - (2)].node)->sym = dclstack;  // context, for goto restrictions
@@ -4300,7 +4302,7 @@ yyreduce:
     break;
 
   case 263:
-#line 1726 "go.y"
+#line 1728 "go.y"
     {
 		NodeList *l;
 
@@ -4313,7 +4315,7 @@ yyreduce:
     break;
 
   case 264:
-#line 1736 "go.y"
+#line 1738 "go.y"
     {
 		// will be converted to OFALL
 		(yyval.node) = nod(OXFALL, N, N);
@@ -4322,35 +4324,35 @@ yyreduce:
     break;
 
   case 265:
-#line 1742 "go.y"
+#line 1744 "go.y"
     {
 		(yyval.node) = nod(OBREAK, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 266:
-#line 1746 "go.y"
+#line 1748 "go.y"
     {
 		(yyval.node) = nod(OCONTINUE, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 267:
-#line 1750 "go.y"
+#line 1752 "go.y"
     {
 		(yyval.node) = nod(OPROC, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 268:
-#line 1754 "go.y"
+#line 1756 "go.y"
     {
 		(yyval.node) = nod(ODEFER, (yyvsp[(2) - (2)].node), N);
 	}
     break;
 
   case 269:
-#line 1758 "go.y"
+#line 1760 "go.y"
     {
 		(yyval.node) = nod(OGOTO, (yyvsp[(2) - (2)].node), N);
 		(yyval.node)->sym = dclstack;  // context, for goto restrictions
@@ -4358,7 +4360,7 @@ yyreduce:
     break;
 
   case 270:
-#line 1763 "go.y"
+#line 1765 "go.y"
     {
 		(yyval.node) = nod(ORETURN, N, N);
 		(yyval.node)->list = (yyvsp[(2) - (2)].list);
@@ -4378,7 +4380,7 @@ yyreduce:
     break;
 
   case 271:
-#line 1782 "go.y"
+#line 1784 "go.y"
     {
 		(yyval.list) = nil;
 		if((yyvsp[(1) - (1)].node) != N)
@@ -4387,7 +4389,7 @@ yyreduce:
     break;
 
   case 272:
-#line 1788 "go.y"
+#line 1790 "go.y"
     {
 		(yyval.list) = (yyvsp[(1) - (3)].list);
 		if((yyvsp[(3) - (3)].node) != N)
@@ -4396,189 +4398,189 @@ yyreduce:
     break;
 
   case 273:
-#line 1796 "go.y"
+#line 1798 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 274:
-#line 1800 "go.y"
+#line 1802 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 275:
-#line 1806 "go.y"
+#line 1808 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 276:
-#line 1810 "go.y"
+#line 1812 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 277:
-#line 1816 "go.y"
+#line 1818 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 278:
-#line 1820 "go.y"
+#line 1822 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 279:
-#line 1826 "go.y"
+#line 1828 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 280:
-#line 1830 "go.y"
+#line 1832 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 281:
-#line 1839 "go.y"
+#line 1841 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 282:
-#line 1843 "go.y"
+#line 1845 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 283:
-#line 1847 "go.y"
+#line 1849 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 284:
-#line 1851 "go.y"
+#line 1853 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 285:
-#line 1856 "go.y"
+#line 1858 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 286:
-#line 1860 "go.y"
+#line 1862 "go.y"
     {
 		(yyval.list) = (yyvsp[(1) - (2)].list);
 	}
     break;
 
   case 291:
-#line 1874 "go.y"
+#line 1876 "go.y"
     {
 		(yyval.node) = N;
 	}
     break;
 
   case 293:
-#line 1880 "go.y"
+#line 1882 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 295:
-#line 1886 "go.y"
+#line 1888 "go.y"
     {
 		(yyval.node) = N;
 	}
     break;
 
   case 297:
-#line 1892 "go.y"
+#line 1894 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 299:
-#line 1898 "go.y"
+#line 1900 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 301:
-#line 1904 "go.y"
+#line 1906 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 303:
-#line 1910 "go.y"
+#line 1912 "go.y"
     {
 		(yyval.val).ctype = CTxxx;
 	}
     break;
 
   case 305:
-#line 1920 "go.y"
+#line 1922 "go.y"
     {
 		importimport((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].val).u.sval);
 	}
     break;
 
   case 306:
-#line 1924 "go.y"
+#line 1926 "go.y"
     {
 		importvar((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].type));
 	}
     break;
 
   case 307:
-#line 1928 "go.y"
+#line 1930 "go.y"
     {
 		importconst((yyvsp[(2) - (5)].sym), types[TIDEAL], (yyvsp[(4) - (5)].node));
 	}
     break;
 
   case 308:
-#line 1932 "go.y"
+#line 1934 "go.y"
     {
 		importconst((yyvsp[(2) - (6)].sym), (yyvsp[(3) - (6)].type), (yyvsp[(5) - (6)].node));
 	}
     break;
 
   case 309:
-#line 1936 "go.y"
+#line 1938 "go.y"
     {
 		importtype((yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].type));
 	}
     break;
 
   case 310:
-#line 1940 "go.y"
+#line 1942 "go.y"
     {
 		if((yyvsp[(2) - (4)].node) == N) {
 			dclcontext = PEXTERN;  // since we skip the funcbody below
@@ -4599,7 +4601,7 @@ yyreduce:
     break;
 
   case 311:
-#line 1960 "go.y"
+#line 1962 "go.y"
     {
 		(yyval.sym) = (yyvsp[(1) - (1)].sym);
 		structpkg = (yyval.sym)->pkg;
@@ -4607,7 +4609,7 @@ yyreduce:
     break;
 
   case 312:
-#line 1967 "go.y"
+#line 1969 "go.y"
     {
 		(yyval.type) = pkgtype((yyvsp[(1) - (1)].sym));
 		importsym((yyvsp[(1) - (1)].sym), OTYPE);
@@ -4615,14 +4617,14 @@ yyreduce:
     break;
 
   case 318:
-#line 1987 "go.y"
+#line 1989 "go.y"
     {
 		(yyval.type) = pkgtype((yyvsp[(1) - (1)].sym));
 	}
     break;
 
   case 319:
-#line 1991 "go.y"
+#line 1993 "go.y"
     {
 		// predefined name like uint8
 		(yyvsp[(1) - (1)].sym) = pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg);
@@ -4635,49 +4637,49 @@ yyreduce:
     break;
 
   case 320:
-#line 2001 "go.y"
+#line 2003 "go.y"
     {
 		(yyval.type) = aindex(N, (yyvsp[(3) - (3)].type));
 	}
     break;
 
   case 321:
-#line 2005 "go.y"
+#line 2007 "go.y"
     {
 		(yyval.type) = aindex(nodlit((yyvsp[(2) - (4)].val)), (yyvsp[(4) - (4)].type));
 	}
     break;
 
   case 322:
-#line 2009 "go.y"
+#line 2011 "go.y"
     {
 		(yyval.type) = maptype((yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)].type));
 	}
     break;
 
   case 323:
-#line 2013 "go.y"
+#line 2015 "go.y"
     {
 		(yyval.type) = tostruct((yyvsp[(3) - (4)].list));
 	}
     break;
 
   case 324:
-#line 2017 "go.y"
+#line 2019 "go.y"
     {
 		(yyval.type) = tointerface((yyvsp[(3) - (4)].list));
 	}
     break;
 
   case 325:
-#line 2021 "go.y"
+#line 2023 "go.y"
     {
 		(yyval.type) = ptrto((yyvsp[(2) - (2)].type));
 	}
     break;
 
   case 326:
-#line 2025 "go.y"
+#line 2027 "go.y"
     {
 		(yyval.type) = typ(TCHAN);
 		(yyval.type)->type = (yyvsp[(2) - (2)].type);
@@ -4686,7 +4688,7 @@ yyreduce:
     break;
 
   case 327:
-#line 2031 "go.y"
+#line 2033 "go.y"
     {
 		(yyval.type) = typ(TCHAN);
 		(yyval.type)->type = (yyvsp[(3) - (4)].type);
@@ -4695,7 +4697,7 @@ yyreduce:
     break;
 
   case 328:
-#line 2037 "go.y"
+#line 2039 "go.y"
     {
 		(yyval.type) = typ(TCHAN);
 		(yyval.type)->type = (yyvsp[(3) - (3)].type);
@@ -4704,7 +4706,7 @@ yyreduce:
     break;
 
   case 329:
-#line 2045 "go.y"
+#line 2047 "go.y"
     {
 		(yyval.type) = typ(TCHAN);
 		(yyval.type)->type = (yyvsp[(3) - (3)].type);
@@ -4713,14 +4715,14 @@ yyreduce:
     break;
 
   case 330:
-#line 2053 "go.y"
+#line 2055 "go.y"
     {
 		(yyval.type) = functype(nil, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list));
 	}
     break;
 
   case 331:
-#line 2059 "go.y"
+#line 2061 "go.y"
     {
 		(yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(2) - (3)].type)));
 		if((yyvsp[(1) - (3)].sym))
@@ -4730,7 +4732,7 @@ yyreduce:
     break;
 
   case 332:
-#line 2066 "go.y"
+#line 2068 "go.y"
     {
 		Type *t;
 	
@@ -4747,7 +4749,7 @@ yyreduce:
     break;
 
   case 333:
-#line 2082 "go.y"
+#line 2084 "go.y"
     {
 		Sym *s;
 		Pkg *p;
@@ -4770,49 +4772,49 @@ yyreduce:
     break;
 
   case 334:
-#line 2104 "go.y"
+#line 2106 "go.y"
     {
 		(yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (5)].sym)), typenod(functype(fakethis(), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list))));
 	}
     break;
 
   case 335:
-#line 2108 "go.y"
+#line 2110 "go.y"
     {
 		(yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type)));
 	}
     break;
 
   case 336:
-#line 2113 "go.y"
+#line 2115 "go.y"
     {
 		(yyval.list) = nil;
 	}
     break;
 
   case 338:
-#line 2120 "go.y"
+#line 2122 "go.y"
     {
 		(yyval.list) = (yyvsp[(2) - (3)].list);
 	}
     break;
 
   case 339:
-#line 2124 "go.y"
+#line 2126 "go.y"
     {
 		(yyval.list) = list1(nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type))));
 	}
     break;
 
   case 340:
-#line 2134 "go.y"
+#line 2136 "go.y"
     {
 		(yyval.node) = nodlit((yyvsp[(1) - (1)].val));
 	}
     break;
 
   case 341:
-#line 2138 "go.y"
+#line 2140 "go.y"
     {
 		(yyval.node) = nodlit((yyvsp[(2) - (2)].val));
 		switch((yyval.node)->val.ctype){
@@ -4834,7 +4836,7 @@ yyreduce:
     break;
 
   case 342:
-#line 2157 "go.y"
+#line 2159 "go.y"
     {
 		(yyval.node) = oldname(pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg));
 		if((yyval.node)->op != OLITERAL)
@@ -4843,7 +4845,7 @@ yyreduce:
     break;
 
   case 344:
-#line 2166 "go.y"
+#line 2168 "go.y"
     {
 		if((yyvsp[(2) - (5)].node)->val.ctype == CTRUNE && (yyvsp[(4) - (5)].node)->val.ctype == CTINT) {
 			(yyval.node) = (yyvsp[(2) - (5)].node);
@@ -4857,42 +4859,42 @@ yyreduce:
     break;
 
   case 347:
-#line 2182 "go.y"
+#line 2184 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 348:
-#line 2186 "go.y"
+#line 2188 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 349:
-#line 2192 "go.y"
+#line 2194 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 350:
-#line 2196 "go.y"
+#line 2198 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
     break;
 
   case 351:
-#line 2202 "go.y"
+#line 2204 "go.y"
     {
 		(yyval.list) = list1((yyvsp[(1) - (1)].node));
 	}
     break;
 
   case 352:
-#line 2206 "go.y"
+#line 2208 "go.y"
     {
 		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
 	}
@@ -4900,7 +4902,7 @@ yyreduce:
 
 
 /* Line 1267 of yacc.c.  */
-#line 4905 "y.tab.c"
+#line 4907 "y.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -5114,7 +5116,7 @@ yyreturn:
 }
 
 
-#line 2210 "go.y"
+#line 2212 "go.y"
 
 
 static void
diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 45b5bc3233..49b84709e2 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -57,6 +57,7 @@ and test commands:
 
 	-a
 		force rebuilding of packages that are already up-to-date.
+		In Go releases, does not apply to the standard library.
 	-n
 		print the commands but do not run them.
 	-p n
@@ -284,6 +285,11 @@ func runBuild(cmd *Command, args []string) {
 		}
 	}
 
+	depMode := modeBuild
+	if buildI {
+		depMode = modeInstall
+	}
+
 	if *buildO != "" {
 		if len(pkgs) > 1 {
 			fatalf("go build: cannot use -o with multiple packages")
@@ -292,17 +298,13 @@ func runBuild(cmd *Command, args []string) {
 		}
 		p := pkgs[0]
 		p.target = "" // must build - not up to date
-		a := b.action(modeInstall, modeBuild, p)
+		a := b.action(modeInstall, depMode, p)
 		a.target = *buildO
 		b.do(a)
 		return
 	}
 
 	a := &action{}
-	depMode := modeBuild
-	if buildI {
-		depMode = modeInstall
-	}
 	for _, p := range packages(args) {
 		a.deps = append(a.deps, b.action(modeBuild, depMode, p))
 	}
@@ -504,8 +506,13 @@ func goFilesPackage(gofiles []string) *Package {
 	}
 	ctxt.ReadDir = func(string) ([]os.FileInfo, error) { return dirent, nil }
 
-	if !filepath.IsAbs(dir) {
-		dir = filepath.Join(cwd, dir)
+	var err error
+	if dir == "" {
+		dir = cwd
+	}
+	dir, err = filepath.Abs(dir)
+	if err != nil {
+		fatalf("%s", err)
 	}
 
 	bp, err := ctxt.ImportDir(dir, 0)
@@ -824,12 +831,17 @@ func (b *builder) build(a *action) (err error) {
 		}
 	}
 
-	var gofiles, cfiles, sfiles, objects, cgoObjects []string
+	var gofiles, cfiles, sfiles, objects, cgoObjects, pcCFLAGS, pcLDFLAGS []string
 
 	gofiles = append(gofiles, a.p.GoFiles...)
 	cfiles = append(cfiles, a.p.CFiles...)
 	sfiles = append(sfiles, a.p.SFiles...)
 
+	if a.p.usesCgo() || a.p.usesSwig() {
+		if pcCFLAGS, pcLDFLAGS, err = b.getPkgConfigFlags(a.p); err != nil {
+			return
+		}
+	}
 	// Run cgo.
 	if a.p.usesCgo() {
 		// In a package using cgo, cgo compiles the C, C++ and assembly files with gcc.
@@ -860,7 +872,7 @@ func (b *builder) build(a *action) (err error) {
 		if a.cgo != nil && a.cgo.target != "" {
 			cgoExe = a.cgo.target
 		}
-		outGo, outObj, err := b.cgo(a.p, cgoExe, obj, gccfiles, a.p.CXXFiles, a.p.MFiles)
+		outGo, outObj, err := b.cgo(a.p, cgoExe, obj, pcCFLAGS, pcLDFLAGS, gccfiles, a.p.CXXFiles, a.p.MFiles)
 		if err != nil {
 			return err
 		}
@@ -873,9 +885,18 @@ func (b *builder) build(a *action) (err error) {
 		// In a package using SWIG, any .c or .s files are
 		// compiled with gcc.
 		gccfiles := append(cfiles, sfiles...)
+		cxxfiles, mfiles := a.p.CXXFiles, a.p.MFiles
 		cfiles = nil
 		sfiles = nil
-		outGo, outObj, err := b.swig(a.p, obj, gccfiles, a.p.CXXFiles, a.p.MFiles)
+
+		// Don't build c/c++ files twice if cgo is enabled (mainly for pkg-config).
+		if a.p.usesCgo() {
+			cxxfiles = nil
+			gccfiles = nil
+			mfiles = nil
+		}
+
+		outGo, outObj, err := b.swig(a.p, obj, pcCFLAGS, gccfiles, cxxfiles, mfiles)
 		if err != nil {
 			return err
 		}
@@ -1019,6 +1040,34 @@ func (b *builder) build(a *action) (err error) {
 	return nil
 }
 
+// Calls pkg-config if needed and returns the cflags/ldflags needed to build the package.
+func (b *builder) getPkgConfigFlags(p *Package) (cflags, ldflags []string, err error) {
+	if pkgs := p.CgoPkgConfig; len(pkgs) > 0 {
+		var out []byte
+		out, err = b.runOut(p.Dir, p.ImportPath, nil, "pkg-config", "--cflags", pkgs)
+		if err != nil {
+			b.showOutput(p.Dir, "pkg-config --cflags "+strings.Join(pkgs, " "), string(out))
+			b.print(err.Error() + "\n")
+			err = errPrintedOutput
+			return
+		}
+		if len(out) > 0 {
+			cflags = strings.Fields(string(out))
+		}
+		out, err = b.runOut(p.Dir, p.ImportPath, nil, "pkg-config", "--libs", pkgs)
+		if err != nil {
+			b.showOutput(p.Dir, "pkg-config --libs "+strings.Join(pkgs, " "), string(out))
+			b.print(err.Error() + "\n")
+			err = errPrintedOutput
+			return
+		}
+		if len(out) > 0 {
+			ldflags = strings.Fields(string(out))
+		}
+	}
+	return
+}
+
 // install is the action for installing a single package or executable.
 func (b *builder) install(a *action) (err error) {
 	defer func() {
@@ -1426,6 +1475,14 @@ func (b *builder) runOut(dir string, desc string, env []string, cmdargs ...inter
 			continue
 		}
 
+		// err can be something like 'exit status 1'.
+		// Add information about what program was running.
+		// Note that if buf.Bytes() is non-empty, the caller usually
+		// shows buf.Bytes() and does not print err at all, so the
+		// prefix here does not make most output any more verbose.
+		if err != nil {
+			err = errors.New(cmdline[0] + ": " + err.Error())
+		}
 		return buf.Bytes(), err
 	}
 }
@@ -1588,7 +1645,7 @@ func (gcToolchain) gc(b *builder, p *Package, archive, obj string, importArgs []
 	extFiles := len(p.CgoFiles) + len(p.CFiles) + len(p.CXXFiles) + len(p.MFiles) + len(p.SFiles) + len(p.SysoFiles) + len(p.SwigFiles) + len(p.SwigCXXFiles)
 	if p.Standard {
 		switch p.ImportPath {
-		case "os", "runtime/pprof", "sync", "time":
+		case "bytes", "net", "os", "runtime/pprof", "sync", "time":
 			extFiles++
 		}
 	}
@@ -1795,7 +1852,7 @@ func (gccgoToolchain) linker() string {
 }
 
 func (gccgoToolchain) gc(b *builder, p *Package, archive, obj string, importArgs []string, gofiles []string) (ofile string, output []byte, err error) {
-	out := p.Name + ".o"
+	out := "_go_.o"
 	ofile = obj + out
 	gcargs := []string{"-g"}
 	gcargs = append(gcargs, b.gccArchArgs()...)
@@ -2100,36 +2157,16 @@ var (
 	cgoLibGccFileOnce sync.Once
 )
 
-func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles, gxxfiles, mfiles []string) (outGo, outObj []string, err error) {
+func (b *builder) cgo(p *Package, cgoExe, obj string, pcCFLAGS, pcLDFLAGS, gccfiles, gxxfiles, mfiles []string) (outGo, outObj []string, err error) {
 	cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, cgoLDFLAGS := b.cflags(p, true)
 	_, cgoexeCFLAGS, _, _ := b.cflags(p, false)
-
+	cgoCPPFLAGS = append(cgoCPPFLAGS, pcCFLAGS...)
+	cgoLDFLAGS = append(cgoLDFLAGS, pcLDFLAGS...)
 	// If we are compiling Objective-C code, then we need to link against libobjc
 	if len(mfiles) > 0 {
 		cgoLDFLAGS = append(cgoLDFLAGS, "-lobjc")
 	}
 
-	if pkgs := p.CgoPkgConfig; len(pkgs) > 0 {
-		out, err := b.runOut(p.Dir, p.ImportPath, nil, "pkg-config", "--cflags", pkgs)
-		if err != nil {
-			b.showOutput(p.Dir, "pkg-config --cflags "+strings.Join(pkgs, " "), string(out))
-			b.print(err.Error() + "\n")
-			return nil, nil, errPrintedOutput
-		}
-		if len(out) > 0 {
-			cgoCPPFLAGS = append(cgoCPPFLAGS, strings.Fields(string(out))...)
-		}
-		out, err = b.runOut(p.Dir, p.ImportPath, nil, "pkg-config", "--libs", pkgs)
-		if err != nil {
-			b.showOutput(p.Dir, "pkg-config --libs "+strings.Join(pkgs, " "), string(out))
-			b.print(err.Error() + "\n")
-			return nil, nil, errPrintedOutput
-		}
-		if len(out) > 0 {
-			cgoLDFLAGS = append(cgoLDFLAGS, strings.Fields(string(out))...)
-		}
-	}
-
 	// Allows including _cgo_export.h from .[ch] files in the package.
 	cgoCPPFLAGS = append(cgoCPPFLAGS, "-I", obj)
 
@@ -2206,6 +2243,14 @@ func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles, gxxfiles, mfiles
 			strings.HasSuffix(f, ".so"),
 			strings.HasSuffix(f, ".dll"):
 			continue
+		// Remove any -fsanitize=foo flags.
+		// Otherwise the compiler driver thinks that we are doing final link
+		// and links sanitizer runtime into the object file. But we are not doing
+		// the final link, we will link the resulting object file again. And
+		// so the program ends up with two copies of sanitizer runtime.
+		// See issue 8788 for details.
+		case strings.HasPrefix(f, "-fsanitize="):
+			continue
 		default:
 			bareLDFLAGS = append(bareLDFLAGS, f)
 		}
@@ -2344,7 +2389,7 @@ func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles, gxxfiles, mfiles
 // Run SWIG on all SWIG input files.
 // TODO: Don't build a shared library, once SWIG emits the necessary
 // pragmas for external linking.
-func (b *builder) swig(p *Package, obj string, gccfiles, gxxfiles, mfiles []string) (outGo, outObj []string, err error) {
+func (b *builder) swig(p *Package, obj string, pcCFLAGS, gccfiles, gxxfiles, mfiles []string) (outGo, outObj []string, err error) {
 	cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, _ := b.cflags(p, true)
 	cflags := stringList(cgoCPPFLAGS, cgoCFLAGS)
 	cxxflags := stringList(cgoCPPFLAGS, cgoCXXFLAGS)
@@ -2385,7 +2430,7 @@ func (b *builder) swig(p *Package, obj string, gccfiles, gxxfiles, mfiles []stri
 	}
 
 	for _, f := range p.SwigFiles {
-		goFile, objFile, gccObjFile, err := b.swigOne(p, f, obj, false, intgosize)
+		goFile, objFile, gccObjFile, err := b.swigOne(p, f, obj, pcCFLAGS, false, intgosize)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -2400,7 +2445,7 @@ func (b *builder) swig(p *Package, obj string, gccfiles, gxxfiles, mfiles []stri
 		}
 	}
 	for _, f := range p.SwigCXXFiles {
-		goFile, objFile, gccObjFile, err := b.swigOne(p, f, obj, true, intgosize)
+		goFile, objFile, gccObjFile, err := b.swigOne(p, f, obj, pcCFLAGS, true, intgosize)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -2479,13 +2524,13 @@ func (b *builder) swigIntSize(obj string) (intsize string, err error) {
 }
 
 // Run SWIG on one SWIG input file.
-func (b *builder) swigOne(p *Package, file, obj string, cxx bool, intgosize string) (outGo, outObj, objGccObj string, err error) {
+func (b *builder) swigOne(p *Package, file, obj string, pcCFLAGS []string, cxx bool, intgosize string) (outGo, outObj, objGccObj string, err error) {
 	cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, _ := b.cflags(p, true)
 	var cflags []string
 	if cxx {
-		cflags = stringList(cgoCPPFLAGS, cgoCXXFLAGS)
+		cflags = stringList(cgoCPPFLAGS, pcCFLAGS, cgoCXXFLAGS)
 	} else {
-		cflags = stringList(cgoCPPFLAGS, cgoCFLAGS)
+		cflags = stringList(cgoCPPFLAGS, pcCFLAGS, cgoCFLAGS)
 	}
 
 	n := 5 // length of ".swig"
@@ -2511,6 +2556,13 @@ func (b *builder) swigOne(p *Package, file, obj string, cxx bool, intgosize stri
 		"-o", obj + gccBase + gccExt,
 		"-outdir", obj,
 	}
+
+	for _, f := range cflags {
+		if len(f) > 3 && f[:2] == "-I" {
+			args = append(args, f)
+		}
+	}
+
 	if gccgo {
 		args = append(args, "-gccgo")
 		if pkgpath := gccgoPkgpath(p); pkgpath != "" {
diff --git a/src/cmd/go/doc.go b/src/cmd/go/doc.go
index 0d4e263891..314c69bd8c 100644
--- a/src/cmd/go/doc.go
+++ b/src/cmd/go/doc.go
@@ -76,6 +76,7 @@ and test commands:
 
 	-a
 		force rebuilding of packages that are already up-to-date.
+		In Go releases, does not apply to the standard library.
 	-n
 		print the commands but do not run them.
 	-p n
@@ -384,28 +385,29 @@ syntax of package template.  The default output is equivalent to -f
 '{{.ImportPath}}'. The struct being passed to the template is:
 
     type Package struct {
-        Dir        string // directory containing package sources
-        ImportPath string // import path of package in dir
-        Name       string // package name
-        Doc        string // package documentation string
-        Target     string // install path
-        Goroot     bool   // is this package in the Go root?
-        Standard   bool   // is this package part of the standard Go library?
-        Stale      bool   // would 'go install' do anything for this package?
-        Root       string // Go root or Go path dir containing this package
+        Dir           string // directory containing package sources
+        ImportPath    string // import path of package in dir
+        ImportComment string // path in import comment on package statement
+        Name          string // package name
+        Doc           string // package documentation string
+        Target        string // install path
+        Goroot        bool   // is this package in the Go root?
+        Standard      bool   // is this package part of the standard Go library?
+        Stale         bool   // would 'go install' do anything for this package?
+        Root          string // Go root or Go path dir containing this package
 
         // Source files
-        GoFiles  []string       // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
-        CgoFiles []string       // .go sources files that import "C"
+        GoFiles        []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
+        CgoFiles       []string // .go sources files that import "C"
         IgnoredGoFiles []string // .go sources ignored due to build constraints
-        CFiles   []string       // .c source files
-        CXXFiles []string       // .cc, .cxx and .cpp source files
-        MFiles   []string       // .m source files
-        HFiles   []string       // .h, .hh, .hpp and .hxx source files
-        SFiles   []string       // .s source files
-        SwigFiles []string      // .swig files
-        SwigCXXFiles []string   // .swigcxx files
-        SysoFiles []string      // .syso object files to add to archive
+        CFiles         []string // .c source files
+        CXXFiles       []string // .cc, .cxx and .cpp source files
+        MFiles         []string // .m source files
+        HFiles         []string // .h, .hh, .hpp and .hxx source files
+        SFiles         []string // .s source files
+        SwigFiles      []string // .swig files
+        SwigCXXFiles   []string // .swigcxx files
+        SysoFiles      []string // .syso object files to add to archive
 
         // Cgo directives
         CgoCFLAGS    []string // cgo: flags for C compiler
@@ -524,16 +526,23 @@ non-test installation.
 
 In addition to the build flags, the flags handled by 'go test' itself are:
 
-	-c  Compile the test binary to pkg.test but do not run it.
-	    (Where pkg is the last element of the package's import path.)
+	-c
+		Compile the test binary to pkg.test but do not run it
+		(where pkg is the last element of the package's import path).
+		The file name can be changed with the -o flag.
+
+	-exec xprog
+	    Run the test binary using xprog. The behavior is the same as
+	    in 'go run'. See 'go help run' for details.
 
 	-i
 	    Install packages that are dependencies of the test.
 	    Do not run the test.
 
-	-exec xprog
-	    Run the test binary using xprog. The behavior is the same as
-	    in 'go run'. See 'go help run' for details.
+	-o file
+		Compile the test binary to the named file.
+		The test still runs (unless -c or -i is specified).
+
 
 The test binary also accepts flags that control execution of the test; these
 flags are also accessible by 'go test'.  See 'go help testflag' for details.
@@ -910,7 +919,8 @@ single directory, the command is applied to a single synthesized
 package made up of exactly those files, ignoring any build constraints
 in those files and ignoring any other files in the directory.
 
-File names that begin with "." or "_" are ignored by the go tool.
+Directory and file names that begin with "." or "_" are ignored
+by the go tool, as are directories named "testdata".
 
 
 Description of testing flags
@@ -942,6 +952,7 @@ control the execution of any test:
 	-blockprofile block.out
 	    Write a goroutine blocking profile to the specified file
 	    when all tests are complete.
+	    Writes test binary as -c would.
 
 	-blockprofilerate n
 	    Control the detail provided in goroutine blocking profiles by
@@ -973,8 +984,7 @@ control the execution of any test:
 	    Sets -cover.
 
 	-coverprofile cover.out
-	    Write a coverage profile to the specified file after all tests
-	    have passed.
+	    Write a coverage profile to the file after all tests have passed.
 	    Sets -cover.
 
 	-cpu 1,2,4
@@ -984,10 +994,11 @@ control the execution of any test:
 
 	-cpuprofile cpu.out
 	    Write a CPU profile to the specified file before exiting.
+	    Writes test binary as -c would.
 
 	-memprofile mem.out
-	    Write a memory profile to the specified file after all tests
-	    have passed.
+	    Write a memory profile to the file after all tests have passed.
+	    Writes test binary as -c would.
 
 	-memprofilerate n
 	    Enable more precise (and expensive) memory profiles by setting
diff --git a/src/cmd/go/generate.go b/src/cmd/go/generate.go
index 167758207e..4227abbe7c 100644
--- a/src/cmd/go/generate.go
+++ b/src/cmd/go/generate.go
@@ -169,6 +169,7 @@ func (g *Generator) run() (ok bool) {
 			if e != stop {
 				panic(e)
 			}
+			setExitStatus(1)
 		}
 	}()
 	g.dir, g.file = filepath.Split(g.path)
@@ -267,7 +268,8 @@ Words:
 var stop = fmt.Errorf("error in generation")
 
 // errorf logs an error message prefixed with the file and line number.
-// It then exits the program because generation stops at the first error.
+// It then exits the program (with exit status 1) because generation stops
+// at the first error.
 func (g *Generator) errorf(format string, args ...interface{}) {
 	fmt.Fprintf(os.Stderr, "%s:%d: %s\n", shortPath(g.path), g.lineNum,
 		fmt.Sprintf(format, args...))
diff --git a/src/cmd/go/get.go b/src/cmd/go/get.go
index a34286f540..2640339414 100644
--- a/src/cmd/go/get.go
+++ b/src/cmd/go/get.go
@@ -266,6 +266,18 @@ func downloadPackage(p *Package) error {
 			return err
 		}
 		repo = "" // should be unused; make distinctive
+
+		// Double-check where it came from.
+		if *getU && vcs.remoteRepo != nil {
+			dir := filepath.Join(p.build.SrcRoot, rootPath)
+			if remote, err := vcs.remoteRepo(vcs, dir); err == nil {
+				if rr, err := repoRootForImportPath(p.ImportPath); err == nil {
+					if remote != rr.repo {
+						return fmt.Errorf("%s is from %s, should be from %s", dir, remote, rr.repo)
+					}
+				}
+			}
+		}
 	} else {
 		// Analyze the import path to determine the version control system,
 		// repository, and the import path for the root of the repository.
diff --git a/src/cmd/go/go_windows_test.go b/src/cmd/go/go_windows_test.go
new file mode 100644
index 0000000000..53d695cccc
--- /dev/null
+++ b/src/cmd/go/go_windows_test.go
@@ -0,0 +1,55 @@
+// 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
+
+import (
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestAbsolutePath(t *testing.T) {
+	tmp, err := ioutil.TempDir("", "TestAbsolutePath")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+
+	file := filepath.Join(tmp, "a.go")
+	err = ioutil.WriteFile(file, []byte{}, 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := filepath.Join(tmp, "dir")
+	err = os.Mkdir(dir, 0777)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chdir(wd)
+
+	// Chdir so current directory and a.go reside on the same drive.
+	err = os.Chdir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	noVolume := file[len(filepath.VolumeName(file)):]
+	wrongPath := filepath.Join(dir, noVolume)
+	output, err := exec.Command("go", "build", noVolume).CombinedOutput()
+	if err == nil {
+		t.Fatal("build should fail")
+	}
+	if strings.Contains(string(output), wrongPath) {
+		t.Fatalf("wrong output found: %v %v", err, string(output))
+	}
+}
diff --git a/src/cmd/go/help.go b/src/cmd/go/help.go
index d6651d179b..201f0e2d79 100644
--- a/src/cmd/go/help.go
+++ b/src/cmd/go/help.go
@@ -81,7 +81,8 @@ single directory, the command is applied to a single synthesized
 package made up of exactly those files, ignoring any build constraints
 in those files and ignoring any other files in the directory.
 
-File names that begin with "." or "_" are ignored by the go tool.
+Directory and file names that begin with "." or "_" are ignored
+by the go tool, as are directories named "testdata".
 	`,
 }
 
diff --git a/src/cmd/go/list.go b/src/cmd/go/list.go
index 0ead435023..fbf96167fe 100644
--- a/src/cmd/go/list.go
+++ b/src/cmd/go/list.go
@@ -30,28 +30,29 @@ syntax of package template.  The default output is equivalent to -f
 '{{.ImportPath}}'. The struct being passed to the template is:
 
     type Package struct {
-        Dir        string // directory containing package sources
-        ImportPath string // import path of package in dir
-        Name       string // package name
-        Doc        string // package documentation string
-        Target     string // install path
-        Goroot     bool   // is this package in the Go root?
-        Standard   bool   // is this package part of the standard Go library?
-        Stale      bool   // would 'go install' do anything for this package?
-        Root       string // Go root or Go path dir containing this package
+        Dir           string // directory containing package sources
+        ImportPath    string // import path of package in dir
+        ImportComment string // path in import comment on package statement
+        Name          string // package name
+        Doc           string // package documentation string
+        Target        string // install path
+        Goroot        bool   // is this package in the Go root?
+        Standard      bool   // is this package part of the standard Go library?
+        Stale         bool   // would 'go install' do anything for this package?
+        Root          string // Go root or Go path dir containing this package
 
         // Source files
-        GoFiles  []string       // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
-        CgoFiles []string       // .go sources files that import "C"
+        GoFiles        []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
+        CgoFiles       []string // .go sources files that import "C"
         IgnoredGoFiles []string // .go sources ignored due to build constraints
-        CFiles   []string       // .c source files
-        CXXFiles []string       // .cc, .cxx and .cpp source files
-        MFiles   []string       // .m source files
-        HFiles   []string       // .h, .hh, .hpp and .hxx source files
-        SFiles   []string       // .s source files
-        SwigFiles []string      // .swig files
-        SwigCXXFiles []string   // .swigcxx files
-        SysoFiles []string      // .syso object files to add to archive
+        CFiles         []string // .c source files
+        CXXFiles       []string // .cc, .cxx and .cpp source files
+        MFiles         []string // .m source files
+        HFiles         []string // .h, .hh, .hpp and .hxx source files
+        SFiles         []string // .s source files
+        SwigFiles      []string // .swig files
+        SwigCXXFiles   []string // .swigcxx files
+        SysoFiles      []string // .syso object files to add to archive
 
         // Cgo directives
         CgoCFLAGS    []string // cgo: flags for C compiler
diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index 63875aed5a..e17326442c 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -14,6 +14,7 @@ import (
 	"os"
 	pathpkg "path"
 	"path/filepath"
+	"runtime"
 	"sort"
 	"strings"
 	"time"
@@ -25,16 +26,17 @@ type Package struct {
 	// Note: These fields are part of the go command's public API.
 	// See list.go.  It is okay to add fields, but not to change or
 	// remove existing ones.  Keep in sync with list.go
-	Dir         string `json:",omitempty"` // directory containing package sources
-	ImportPath  string `json:",omitempty"` // import path of package in dir
-	Name        string `json:",omitempty"` // package name
-	Doc         string `json:",omitempty"` // package documentation string
-	Target      string `json:",omitempty"` // install path
-	Goroot      bool   `json:",omitempty"` // is this package found in the Go root?
-	Standard    bool   `json:",omitempty"` // is this package part of the standard Go library?
-	Stale       bool   `json:",omitempty"` // would 'go install' do anything for this package?
-	Root        string `json:",omitempty"` // Go root or Go path dir containing this package
-	ConflictDir string `json:",omitempty"` // Dir is hidden by this other directory
+	Dir           string `json:",omitempty"` // directory containing package sources
+	ImportPath    string `json:",omitempty"` // import path of package in dir
+	ImportComment string `json:",omitempty"` // path in import comment on package statement
+	Name          string `json:",omitempty"` // package name
+	Doc           string `json:",omitempty"` // package documentation string
+	Target        string `json:",omitempty"` // install path
+	Goroot        bool   `json:",omitempty"` // is this package found in the Go root?
+	Standard      bool   `json:",omitempty"` // is this package part of the standard Go library?
+	Stale         bool   `json:",omitempty"` // would 'go install' do anything for this package?
+	Root          string `json:",omitempty"` // Go root or Go path dir containing this package
+	ConflictDir   string `json:",omitempty"` // Dir is hidden by this other directory
 
 	// Source files
 	GoFiles        []string `json:",omitempty"` // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
@@ -103,6 +105,7 @@ func (p *Package) copyBuild(pp *build.Package) {
 
 	p.Dir = pp.Dir
 	p.ImportPath = pp.ImportPath
+	p.ImportComment = pp.ImportComment
 	p.Name = pp.Name
 	p.Doc = pp.Doc
 	p.Root = pp.Root
@@ -614,6 +617,16 @@ func (p *Package) load(stk *importStack, bp *build.Package, err error) *Package
 	}
 	p.Target = p.target
 
+	// Check for C code compiled with Plan 9 C compiler.
+	// No longer allowed except in runtime and runtime/cgo, for now.
+	if len(p.CFiles) > 0 && !p.usesCgo() && (!p.Standard || p.ImportPath != "runtime") {
+		p.Error = &PackageError{
+			ImportStack: stk.copy(),
+			Err:         fmt.Sprintf("C source files not allowed when not using cgo: %s", strings.Join(p.CFiles, " ")),
+		}
+		return p
+	}
+
 	// In the absence of errors lower in the dependency tree,
 	// check for case-insensitive collisions of import paths.
 	if len(p.DepsErrors) == 0 {
@@ -675,6 +688,12 @@ func computeStale(pkgs ...*Package) {
 	}
 }
 
+// The runtime version string takes one of two forms:
+// "go1.X[.Y]" for Go releases, and "devel +hash" at tip.
+// Determine whether we are in a released copy by
+// inspecting the version.
+var isGoRelease = strings.HasPrefix(runtime.Version(), "go1")
+
 // isStale reports whether package p needs to be rebuilt.
 func isStale(p *Package, topRoot map[string]bool) bool {
 	if p.Standard && (p.ImportPath == "unsafe" || buildContext.Compiler == "gccgo") {
@@ -695,7 +714,16 @@ func isStale(p *Package, topRoot map[string]bool) bool {
 		return false
 	}
 
-	if buildA || p.target == "" || p.Stale {
+	// If we are running a release copy of Go, do not rebuild the standard packages.
+	// They may not be writable anyway, but they are certainly not changing.
+	// This makes 'go build -a' skip the standard packages when using an official release.
+	// See issue 4106 and issue 8290.
+	pkgBuildA := buildA
+	if p.Standard && isGoRelease {
+		pkgBuildA = false
+	}
+
+	if pkgBuildA || p.target == "" || p.Stale {
 		return true
 	}
 
diff --git a/src/cmd/go/test.bash b/src/cmd/go/test.bash
index 13886e158b..652ef3b5b6 100755
--- a/src/cmd/go/test.bash
+++ b/src/cmd/go/test.bash
@@ -4,18 +4,22 @@
 # license that can be found in the LICENSE file.
 
 set -e
-go build -o testgo
+go build -tags testgo -o testgo
 go() {
 	echo TEST ERROR: ran go, not testgo: go "$@" >&2
 	exit 2
 }
 
 started=false
+testdesc=""
+nl="
+"
 TEST() {
 	if $started; then
 		stop
 	fi
 	echo TEST: "$@"
+	testdesc="$@"
 	started=true
 	ok=true
 }
@@ -29,6 +33,7 @@ stop() {
 		echo PASS
 	else
 		echo FAIL
+		testfail="$testfail	$testdesc$nl"
 		allok=false
 	fi
 }
@@ -55,12 +60,63 @@ if ! grep -q "^$fn:" $d/err.out; then
 fi
 rm -r $d
 
+TEST 'program name in crash messages'
+linker=$(./testgo env GOCHAR)l
+d=$(TMPDIR=/var/tmp mktemp -d -t testgoXXX)
+./testgo build -ldflags -crash_for_testing $(./testgo env GOROOT)/test/helloworld.go 2>$d/err.out || true
+if ! grep -q "/tool/.*/$linker" $d/err.out; then
+	echo "missing linker name in error message"
+	cat $d/err.out
+	ok=false
+fi
+rm -r $d
+
+TEST broken tests without Test functions all fail
+d=$(mktemp -d -t testgoXXX)
+./testgo test ./testdata/src/badtest/... >$d/err 2>&1 || true
+if grep -q '^ok' $d/err; then
+	echo test passed unexpectedly:
+	grep '^ok' $d/err
+	ok=false
+elif ! grep -q 'FAIL.*badtest/badexec' $d/err || ! grep -q 'FAIL.*badtest/badsyntax' $d/err || ! grep -q 'FAIL.*badtest/badvar' $d/err; then
+	echo test did not run everything
+	cat $d/err
+	ok=false
+fi
+rm -rf $d
+
+TEST 'go build -a in dev branch'
+./testgo install math || ok=false # should be up to date already but just in case
+d=$(TMPDIR=/var/tmp mktemp -d -t testgoXXX)
+if ! TESTGO_IS_GO_RELEASE=0 ./testgo build -v -a math 2>$d/err.out; then
+	cat $d/err.out
+	ok=false
+elif ! grep -q runtime $d/err.out; then
+	echo "testgo build -a math in dev branch DID NOT build runtime, but should have"
+	cat $d/err.out
+	ok=false
+fi
+rm -r $d
+
+TEST 'go build -a in release branch'
+./testgo install math || ok=false # should be up to date already but just in case
+d=$(TMPDIR=/var/tmp mktemp -d -t testgoXXX)
+if ! TESTGO_IS_GO_RELEASE=1 ./testgo build -v -a math 2>$d/err.out; then
+	cat $d/err.out
+	ok=false
+elif grep -q runtime $d/err.out; then
+	echo "testgo build -a math in dev branch DID build runtime, but should NOT have"
+	cat $d/err.out
+	ok=false
+fi
+rm -r $d
+
 # Test local (./) imports.
 testlocal() {
 	local="$1"
 	TEST local imports $2 '(easy)'
-	./testgo build -o hello "testdata/$local/easy.go"
-	./hello >hello.out
+	./testgo build -o hello "testdata/$local/easy.go" || ok=false
+	./hello >hello.out || ok=false
 	if ! grep -q '^easysub\.Hello' hello.out; then
 		echo "testdata/$local/easy.go did not generate expected output"
 		cat hello.out
@@ -68,8 +124,8 @@ testlocal() {
 	fi
 	
 	TEST local imports $2 '(easysub)'
-	./testgo build -o hello "testdata/$local/easysub/main.go"
-	./hello >hello.out
+	./testgo build -o hello "testdata/$local/easysub/main.go" || ok=false
+	./hello >hello.out || ok=false
 	if ! grep -q '^easysub\.Hello' hello.out; then
 		echo "testdata/$local/easysub/main.go did not generate expected output"
 		cat hello.out
@@ -77,8 +133,8 @@ testlocal() {
 	fi
 	
 	TEST local imports $2 '(hard)'
-	./testgo build -o hello "testdata/$local/hard.go"
-	./hello >hello.out
+	./testgo build -o hello "testdata/$local/hard.go" || ok=false
+	./hello >hello.out || ok=false
 	if ! grep -q '^sub\.Hello' hello.out || ! grep -q '^subsub\.Hello' hello.out ; then
 		echo "testdata/$local/hard.go did not generate expected output"
 		cat hello.out
@@ -121,6 +177,56 @@ if ! ./testgo build -v ./testdata/testinternal2; then
 	ok=false
 fi
 
+# Test that 'go get -u' reports moved packages.
+testmove() {
+	vcs=$1
+	url=$2
+	base=$3
+	config=$4
+
+	TEST go get -u notices $vcs package that moved
+	d=$(mktemp -d -t testgoXXX)
+	mkdir -p $d/src
+	if ! GOPATH=$d ./testgo get -d $url; then
+		echo 'go get -d $url failed'
+		ok=false
+	elif ! GOPATH=$d ./testgo get -d -u $url; then
+		echo 'go get -d -u $url failed'
+		ok=false
+	else
+		set +e
+		case "$vcs" in
+		svn)
+			# SVN doesn't believe in text files so we can't just edit the config.
+			# Check out a different repo into the wrong place.
+			rm -rf $d/src/code.google.com/p/rsc-svn
+			GOPATH=$d ./testgo get -d -u code.google.com/p/rsc-svn2/trunk
+			mv $d/src/code.google.com/p/rsc-svn2 $d/src/code.google.com/p/rsc-svn
+			;;
+		*)
+			echo '1,$s;'"$base"';'"$base"'XXX;
+w
+q' | ed $d/src/$config >/dev/null 2>&1
+		esac
+		set -e
+
+		if GOPATH=$d ./testgo get -d -u $url 2>$d/err; then
+			echo "go get -d -u $url succeeded with wrong remote repo"
+			cat $d/err
+			ok=false
+		elif ! grep 'should be from' $d/err >/dev/null; then
+			echo "go get -d -u $url failed for wrong reason"
+			cat $d/err
+			ok=false
+		fi
+	fi
+	rm -rf $d
+}
+
+testmove hg rsc.io/x86/x86asm x86 rsc.io/x86/.hg/hgrc
+testmove git rsc.io/pdf pdf rsc.io/pdf/.git/config
+testmove svn code.google.com/p/rsc-svn/trunk - -
+
 export GOPATH=$(pwd)/testdata/importcom
 TEST 'import comment - match'
 if ! ./testgo build ./testdata/importcom/works.go; then
@@ -157,6 +263,20 @@ fi
 rm -f ./testdata/err
 unset GOPATH
 
+export GOPATH=$(pwd)/testdata/src
+TEST disallowed C source files
+export GOPATH=$(pwd)/testdata
+if ./testgo build badc 2>testdata/err; then
+	echo 'go build badc succeeded'
+	ok=false
+elif ! grep 'C source files not allowed' testdata/err >/dev/null; then
+	echo 'go test did not say C source files not allowed:'
+	cat testdata/err
+	ok=false
+fi
+rm -f ./testdata/err
+unset GOPATH
+
 TEST error message for syntax error in test go file says FAIL
 export GOPATH=$(pwd)/testdata
 if ./testgo test syntaxerror 2>testdata/err; then
@@ -303,20 +423,20 @@ TEST godoc installs into GOBIN
 d=$(mktemp -d -t testgoXXX)
 export GOPATH=$d
 mkdir $d/gobin
-GOBIN=$d/gobin ./testgo get code.google.com/p/go.tools/cmd/godoc
+GOBIN=$d/gobin ./testgo get code.google.com/p/go.tools/cmd/godoc || ok=false
 if [ ! -x $d/gobin/godoc ]; then
 	echo did not install godoc to '$GOBIN'
-	GOBIN=$d/gobin ./testgo list -f 'Target: {{.Target}}' code.google.com/p/go.tools/cmd/godoc
+	GOBIN=$d/gobin ./testgo list -f 'Target: {{.Target}}' code.google.com/p/go.tools/cmd/godoc || true
 	ok=false
 fi
 
 TEST godoc installs into GOROOT
 GOROOT=$(./testgo env GOROOT)
 rm -f $GOROOT/bin/godoc
-./testgo install code.google.com/p/go.tools/cmd/godoc
+./testgo install code.google.com/p/go.tools/cmd/godoc || ok=false
 if [ ! -x $GOROOT/bin/godoc ]; then
 	echo did not install godoc to '$GOROOT/bin'
-	./testgo list -f 'Target: {{.Target}}' code.google.com/p/go.tools/cmd/godoc
+	./testgo list -f 'Target: {{.Target}}' code.google.com/p/go.tools/cmd/godoc || true
 	ok=false
 fi
 
@@ -324,36 +444,36 @@ TEST cmd/fix installs into tool
 GOOS=$(./testgo env GOOS)
 GOARCH=$(./testgo env GOARCH)
 rm -f $GOROOT/pkg/tool/${GOOS}_${GOARCH}/fix
-./testgo install cmd/fix
+./testgo install cmd/fix || ok=false
 if [ ! -x $GOROOT/pkg/tool/${GOOS}_${GOARCH}/fix ]; then
 	echo 'did not install cmd/fix to $GOROOT/pkg/tool'
-	GOBIN=$d/gobin ./testgo list -f 'Target: {{.Target}}' cmd/fix
+	GOBIN=$d/gobin ./testgo list -f 'Target: {{.Target}}' cmd/fix || true
 	ok=false
 fi
 rm -f $GOROOT/pkg/tool/${GOOS}_${GOARCH}/fix
-GOBIN=$d/gobin ./testgo install cmd/fix
+GOBIN=$d/gobin ./testgo install cmd/fix || ok=false
 if [ ! -x $GOROOT/pkg/tool/${GOOS}_${GOARCH}/fix ]; then
 	echo 'did not install cmd/fix to $GOROOT/pkg/tool with $GOBIN set'
-	GOBIN=$d/gobin ./testgo list -f 'Target: {{.Target}}' cmd/fix
+	GOBIN=$d/gobin ./testgo list -f 'Target: {{.Target}}' cmd/fix || true
 	ok=false
 fi
 
 TEST gopath program installs into GOBIN
 mkdir $d/src/progname
 echo 'package main; func main() {}' >$d/src/progname/p.go
-GOBIN=$d/gobin ./testgo install progname
+GOBIN=$d/gobin ./testgo install progname || ok=false
 if [ ! -x $d/gobin/progname ]; then
 	echo 'did not install progname to $GOBIN/progname'
-	./testgo list -f 'Target: {{.Target}}' cmd/api
+	./testgo list -f 'Target: {{.Target}}' cmd/api || true
 	ok=false
 fi
 rm -f $d/gobin/progname $d/bin/progname
 
 TEST gopath program installs into GOPATH/bin
-./testgo install progname
+./testgo install progname || ok=false
 if [ ! -x $d/bin/progname ]; then
 	echo 'did not install progname to $GOPATH/bin/progname'
-	./testgo list -f 'Target: {{.Target}}' progname
+	./testgo list -f 'Target: {{.Target}}' progname || true
 	ok=false
 fi
 
@@ -382,7 +502,7 @@ fi
 
 # ensure that output of 'go list' is consistent between runs
 TEST go list is consistent
-./testgo list std > test_std.list
+./testgo list std > test_std.list || ok=false
 if ! ./testgo list std | cmp -s test_std.list - ; then
 	echo "go list std ordering is inconsistent"
 	ok=false
@@ -456,7 +576,7 @@ func main() {
 	println(extern)
 }
 EOF
-./testgo run -ldflags '-X main.extern "hello world"' $d/main.go 2>hello.out
+./testgo run -ldflags '-X main.extern "hello world"' $d/main.go 2>hello.out || ok=false
 if ! grep -q '^hello world' hello.out; then
 	echo "ldflags -X main.extern 'hello world' failed. Output:"
 	cat hello.out
@@ -472,6 +592,30 @@ if [ ! -x strings.test ]; then
 fi
 rm -f strings.prof strings.test
 
+TEST go test -cpuprofile -o controls binary location
+./testgo test -cpuprofile strings.prof -o mystrings.test strings || ok=false
+if [ ! -x mystrings.test ]; then
+	echo "go test -cpuprofile -o mystrings.test did not create mystrings.test"
+	ok=false
+fi
+rm -f strings.prof mystrings.test
+
+TEST go test -c -o controls binary location
+./testgo test -c -o mystrings.test strings || ok=false
+if [ ! -x mystrings.test ]; then
+	echo "go test -c -o mystrings.test did not create mystrings.test"
+	ok=false
+fi
+rm -f mystrings.test
+
+TEST go test -o writes binary
+./testgo test -o mystrings.test strings || ok=false
+if [ ! -x mystrings.test ]; then
+	echo "go test -o mystrings.test did not create mystrings.test"
+	ok=false
+fi
+rm -f mystrings.test
+
 TEST symlinks do not confuse go list '(issue 4568)'
 old=$(pwd)
 tmp=$(cd /tmp && pwd -P)
@@ -594,28 +738,36 @@ TEST shadowing logic
 export GOPATH=$(pwd)/testdata/shadow/root1:$(pwd)/testdata/shadow/root2
 
 # The math in root1 is not "math" because the standard math is.
+set +e
 cdir=$(./testgo list -f '({{.ImportPath}}) ({{.ConflictDir}})' ./testdata/shadow/root1/src/math)
+set -e
 if [ "$cdir" != "(_$(pwd)/testdata/shadow/root1/src/math) ($GOROOT/src/math)" ]; then
 	echo shadowed math is not shadowed: "$cdir"
 	ok=false
 fi
 
 # The foo in root1 is "foo".
+set +e
 cdir=$(./testgo list -f '({{.ImportPath}}) ({{.ConflictDir}})' ./testdata/shadow/root1/src/foo)
+set -e
 if [ "$cdir" != "(foo) ()" ]; then
 	echo unshadowed foo is shadowed: "$cdir"
 	ok=false
 fi
 
 # The foo in root2 is not "foo" because the foo in root1 got there first.
+set +e
 cdir=$(./testgo list -f '({{.ImportPath}}) ({{.ConflictDir}})' ./testdata/shadow/root2/src/foo)
+set -e
 if [ "$cdir" != "(_$(pwd)/testdata/shadow/root2/src/foo) ($(pwd)/testdata/shadow/root1/src/foo)" ]; then
 	echo shadowed foo is not shadowed: "$cdir"
 	ok=false
 fi
 
 # The error for go install should mention the conflicting directory.
-err=$(! ./testgo install ./testdata/shadow/root2/src/foo 2>&1)
+set +e
+err=$(./testgo install ./testdata/shadow/root2/src/foo 2>&1)
+set -e
 if [ "$err" != "go install: no install location for $(pwd)/testdata/shadow/root2/src/foo: hidden by $(pwd)/testdata/shadow/root1/src/foo" ]; then
 	echo wrong shadowed install error: "$err"
 	ok=false
@@ -804,30 +956,46 @@ echo '
 package foo
 func F() {}
 ' >$d/src/x/y/foo/foo.go
+checkbar() {
+	desc="$1"
+	sleep 1
+	touch $d/src/x/y/foo/foo.go
+	if ! ./testgo build -v -i x/y/bar &> $d/err; then
+		echo build -i "$1" failed
+		cat $d/err
+		ok=false
+	elif ! grep x/y/foo $d/err >/dev/null; then
+		echo first build -i "$1" did not build x/y/foo
+		cat $d/err
+		ok=false
+	fi
+	if ! ./testgo build -v -i x/y/bar &> $d/err; then
+		echo second build -i "$1" failed
+		cat $d/err
+		ok=false
+	elif grep x/y/foo $d/err >/dev/null; then
+		echo second build -i "$1" built x/y/foo
+		cat $d/err
+		ok=false
+	fi
+}
+
 echo '
 package bar
 import "x/y/foo"
 func F() { foo.F() }
 ' >$d/src/x/y/bar/bar.go
-if ! ./testgo build -v -i x/y/bar &> $d/err; then
-	echo build -i failed
-	cat $d/err
-	ok=false
-elif ! grep x/y/foo $d/err >/dev/null; then
-	echo first build -i did not build x/y/foo
-	cat $d/err
-	ok=false
-fi
-if ! ./testgo build -v -i x/y/bar &> $d/err; then
-	echo second build -i failed
-	cat $d/err
-	ok=false
-elif grep x/y/foo $d/err >/dev/null; then
-	echo second build -i built x/y/foo
-	cat $d/err
-	ok=false
-fi
-rm -rf $d
+checkbar pkg
+
+TEST build -i installs dependencies for command
+echo '
+package main
+import "x/y/foo"
+func main() { foo.F() }
+' >$d/src/x/y/bar/bar.go
+checkbar cmd
+
+rm -rf $d bar
 unset GOPATH
 
 TEST 'go build in test-only directory fails with a good error'
@@ -862,7 +1030,7 @@ fi
 
 TEST 'go test xtestonly works'
 export GOPATH=$(pwd)/testdata
-./testgo clean -i xtestonly
+./testgo clean -i xtestonly || ok=false
 if ! ./testgo test xtestonly >/dev/null; then
 	echo "go test xtestonly failed"
 	ok=false
@@ -905,6 +1073,32 @@ elif ! grep "$GOARCH test3.go p xyzp/test3.go/123" testdata/std.out > /dev/null;
 	ok=false
 fi
 
+TEST go get works with vanity wildcards
+d=$(mktemp -d -t testgoXXX)
+export GOPATH=$d
+if ! ./testgo get -u rsc.io/pdf/...; then
+	ok=false
+elif [ ! -x $d/bin/pdfpasswd ]; then
+	echo did not build rsc.io/pdf/pdfpasswd
+	ok=false
+fi
+unset GOPATH
+rm -rf $d
+
+TEST go vet with external tests
+d=$(mktemp -d -t testgoXXX)
+export GOPATH=$(pwd)/testdata
+if ./testgo vet vetpkg >$d/err 2>&1; then
+	echo "go vet vetpkg passes incorrectly"
+	ok=false
+elif ! grep -q 'missing argument for Printf' $d/err; then
+	echo "go vet vetpkg did not find missing argument for Printf"
+	cat $d/err
+	ok=false
+fi
+unset GOPATH
+rm -rf $d
+
 # clean up
 if $started; then stop; fi
 rm -rf testdata/bin testdata/bin1
@@ -913,6 +1107,7 @@ rm -f testgo
 if $allok; then
 	echo PASS
 else
-	echo FAIL
+	echo FAIL:
+	echo "$testfail"
 	exit 1
 fi
diff --git a/src/cmd/go/test.go b/src/cmd/go/test.go
index a602469e44..c81e40639e 100644
--- a/src/cmd/go/test.go
+++ b/src/cmd/go/test.go
@@ -6,6 +6,7 @@ package main
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"go/ast"
 	"go/build"
@@ -48,7 +49,7 @@ It prints a summary of the test results in the format:
 followed by detailed output for each failed package.
 
 'Go test' recompiles each package along with any files with names matching
-the file pattern "*_test.go". 
+the file pattern "*_test.go".
 Files whose names begin with "_" (including "_test.go") or "." are ignored.
 These additional files can contain test functions, benchmark functions, and
 example functions.  See 'go help testfunc' for more.
@@ -65,16 +66,23 @@ non-test installation.
 
 In addition to the build flags, the flags handled by 'go test' itself are:
 
-	-c  Compile the test binary to pkg.test but do not run it.
-	    (Where pkg is the last element of the package's import path.)
+	-c
+		Compile the test binary to pkg.test but do not run it
+		(where pkg is the last element of the package's import path).
+		The file name can be changed with the -o flag.
+
+	-exec xprog
+	    Run the test binary using xprog. The behavior is the same as
+	    in 'go run'. See 'go help run' for details.
 
 	-i
 	    Install packages that are dependencies of the test.
 	    Do not run the test.
 
-	-exec xprog
-	    Run the test binary using xprog. The behavior is the same as
-	    in 'go run'. See 'go help run' for details.
+	-o file
+		Compile the test binary to the named file.
+		The test still runs (unless -c or -i is specified).
+
 
 The test binary also accepts flags that control execution of the test; these
 flags are also accessible by 'go test'.  See 'go help testflag' for details.
@@ -122,6 +130,7 @@ control the execution of any test:
 	-blockprofile block.out
 	    Write a goroutine blocking profile to the specified file
 	    when all tests are complete.
+	    Writes test binary as -c would.
 
 	-blockprofilerate n
 	    Control the detail provided in goroutine blocking profiles by
@@ -153,8 +162,7 @@ control the execution of any test:
 	    Sets -cover.
 
 	-coverprofile cover.out
-	    Write a coverage profile to the specified file after all tests
-	    have passed.
+	    Write a coverage profile to the file after all tests have passed.
 	    Sets -cover.
 
 	-cpu 1,2,4
@@ -164,10 +172,11 @@ control the execution of any test:
 
 	-cpuprofile cpu.out
 	    Write a CPU profile to the specified file before exiting.
+	    Writes test binary as -c would.
 
 	-memprofile mem.out
-	    Write a memory profile to the specified file after all tests
-	    have passed.
+	    Write a memory profile to the file after all tests have passed.
+	    Writes test binary as -c would.
 
 	-memprofilerate n
 	    Enable more precise (and expensive) memory profiles by setting
@@ -274,10 +283,10 @@ var (
 	testCoverMode    string     // -covermode flag
 	testCoverPaths   []string   // -coverpkg flag
 	testCoverPkgs    []*Package // -coverpkg flag
+	testO            string     // -o flag
 	testProfile      bool       // some profiling flag
 	testNeedBinary   bool       // profile needs to keep binary around
 	testV            bool       // -v flag
-	testFiles        []string   // -file flag(s)  TODO: not respected
 	testTimeout      string     // -timeout flag
 	testArgs         []string
 	testBench        bool
@@ -291,6 +300,7 @@ var testMainDeps = map[string]bool{
 	// Dependencies for testmain.
 	"testing": true,
 	"regexp":  true,
+	"os":      true,
 }
 
 func runTest(cmd *Command, args []string) {
@@ -308,6 +318,9 @@ func runTest(cmd *Command, args []string) {
 	if testC && len(pkgs) != 1 {
 		fatalf("cannot use -c flag with multiple packages")
 	}
+	if testO != "" && len(pkgs) != 1 {
+		fatalf("cannot use -o flag with multiple packages")
+	}
 	if testProfile && len(pkgs) != 1 {
 		fatalf("cannot use test profile flag with multiple packages")
 	}
@@ -522,6 +535,13 @@ func contains(x []string, s string) bool {
 	return false
 }
 
+var windowsBadWords = []string{
+	"install",
+	"patch",
+	"setup",
+	"update",
+}
+
 func (b *builder) test(p *Package) (buildAction, runAction, printAction *action, err error) {
 	if len(p.TestGoFiles)+len(p.XTestGoFiles) == 0 {
 		build := b.action(modeBuild, modeBuild, p)
@@ -687,7 +707,7 @@ func (b *builder) test(p *Package) (buildAction, runAction, printAction *action,
 		omitDWARF:  !testC && !testNeedBinary,
 	}
 
-	// The generated main also imports testing and regexp.
+	// The generated main also imports testing, regexp, and os.
 	stk.push("testmain")
 	for dep := range testMainDeps {
 		if dep == ptest.ImportPath {
@@ -723,11 +743,13 @@ func (b *builder) test(p *Package) (buildAction, runAction, printAction *action,
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	if t.ImportTest || ptest.coverMode != "" {
+	if len(ptest.GoFiles) > 0 {
 		pmain.imports = append(pmain.imports, ptest)
+		t.ImportTest = true
 	}
-	if t.ImportXtest {
+	if pxtest != nil {
 		pmain.imports = append(pmain.imports, pxtest)
+		t.ImportXtest = true
 	}
 
 	if ptest != p && localCover {
@@ -779,17 +801,54 @@ func (b *builder) test(p *Package) (buildAction, runAction, printAction *action,
 	a.objdir = testDir + string(filepath.Separator)
 	a.objpkg = filepath.Join(testDir, "main.a")
 	a.target = filepath.Join(testDir, testBinary) + exeSuffix
-	pmainAction := a
+	if goos == "windows" {
+		// There are many reserved words on Windows that,
+		// if used in the name of an executable, cause Windows
+		// to try to ask for extra permissions.
+		// The word list includes setup, install, update, and patch,
+		// but it does not appear to be defined anywhere.
+		// We have run into this trying to run the
+		// go.codereview/patch tests.
+		// For package names containing those words, use test.test.exe
+		// instead of pkgname.test.exe.
+		// Note that this file name is only used in the Go command's
+		// temporary directory. If the -c or other flags are
+		// given, the code below will still use pkgname.test.exe.
+		// There are two user-visible effects of this change.
+		// First, you can actually run 'go test' in directories that
+		// have names that Windows thinks are installer-like,
+		// without getting a dialog box asking for more permissions.
+		// Second, in the Windows process listing during go test,
+		// the test shows up as test.test.exe, not pkgname.test.exe.
+		// That second one is a drawback, but it seems a small
+		// price to pay for the test running at all.
+		// If maintaining the list of bad words is too onerous,
+		// we could just do this always on Windows.
+		for _, bad := range windowsBadWords {
+			if strings.Contains(testBinary, bad) {
+				a.target = filepath.Join(testDir, "test.test") + exeSuffix
+				break
+			}
+		}
+	}
+	buildAction = a
 
 	if testC || testNeedBinary {
 		// -c or profiling flag: create action to copy binary to ./test.out.
-		runAction = &action{
-			f:      (*builder).install,
-			deps:   []*action{pmainAction},
-			p:      pmain,
-			target: filepath.Join(cwd, testBinary+exeSuffix),
+		target := filepath.Join(cwd, testBinary+exeSuffix)
+		if testO != "" {
+			target = testO
+			if !filepath.IsAbs(target) {
+				target = filepath.Join(cwd, target)
+			}
 		}
-		pmainAction = runAction // in case we are running the test
+		buildAction = &action{
+			f:      (*builder).install,
+			deps:   []*action{buildAction},
+			p:      pmain,
+			target: target,
+		}
+		runAction = buildAction // make sure runAction != nil even if not running test
 	}
 	if testC {
 		printAction = &action{p: p, deps: []*action{runAction}} // nop
@@ -797,7 +856,7 @@ func (b *builder) test(p *Package) (buildAction, runAction, printAction *action,
 		// run test
 		runAction = &action{
 			f:          (*builder).runTest,
-			deps:       []*action{pmainAction},
+			deps:       []*action{buildAction},
 			p:          p,
 			ignoreFail: true,
 		}
@@ -813,7 +872,7 @@ func (b *builder) test(p *Package) (buildAction, runAction, printAction *action,
 		}
 	}
 
-	return pmainAction, runAction, printAction, nil
+	return buildAction, runAction, printAction, nil
 }
 
 func testImportStack(top string, p *Package, target string) []string {
@@ -1057,6 +1116,31 @@ func (b *builder) notest(a *action) error {
 	return nil
 }
 
+// isTestMain tells whether fn is a TestMain(m *testing.M) function.
+func isTestMain(fn *ast.FuncDecl) bool {
+	if fn.Name.String() != "TestMain" ||
+		fn.Type.Results != nil && len(fn.Type.Results.List) > 0 ||
+		fn.Type.Params == nil ||
+		len(fn.Type.Params.List) != 1 ||
+		len(fn.Type.Params.List[0].Names) > 1 {
+		return false
+	}
+	ptr, ok := fn.Type.Params.List[0].Type.(*ast.StarExpr)
+	if !ok {
+		return false
+	}
+	// We can't easily check that the type is *testing.M
+	// because we don't know how testing has been imported,
+	// but at least check that it's *M or *something.M.
+	if name, ok := ptr.X.(*ast.Ident); ok && name.Name == "M" {
+		return true
+	}
+	if sel, ok := ptr.X.(*ast.SelectorExpr); ok && sel.Sel.Name == "M" {
+		return true
+	}
+	return false
+}
+
 // isTest tells whether name looks like a test (or benchmark, according to prefix).
 // It is a Test (say) if there is a character after Test that is not a lower-case letter.
 // We don't want TesticularCancer.
@@ -1113,6 +1197,7 @@ type testFuncs struct {
 	Tests       []testFunc
 	Benchmarks  []testFunc
 	Examples    []testFunc
+	TestMain    *testFunc
 	Package     *Package
 	ImportTest  bool
 	NeedTest    bool
@@ -1168,6 +1253,12 @@ func (t *testFuncs) load(filename, pkg string, doImport, seen *bool) error {
 		}
 		name := n.Name.String()
 		switch {
+		case isTestMain(n):
+			if t.TestMain != nil {
+				return errors.New("multiple definitions of TestMain")
+			}
+			t.TestMain = &testFunc{pkg, name, ""}
+			*doImport, *seen = true, true
 		case isTest(name, "Test"):
 			t.Tests = append(t.Tests, testFunc{pkg, name, ""})
 			*doImport, *seen = true, true
@@ -1200,6 +1291,9 @@ var testmainTmpl = template.Must(template.New("main").Parse(`
 package main
 
 import (
+{{if not .TestMain}}
+	"os"
+{{end}}
 	"regexp"
 	"testing"
 
@@ -1294,7 +1388,12 @@ func main() {
 		CoveredPackages: {{printf "%q" .Covered}},
 	})
 {{end}}
-	testing.Main(matchString, tests, benchmarks, examples)
+	m := testing.MainStart(matchString, tests, benchmarks, examples)
+{{with .TestMain}}
+	{{.Package}}.{{.Name}}(m)
+{{else}}
+	os.Exit(m.Run())
+{{end}}
 }
 
 `))
diff --git a/src/cmd/go/testdata/src/badc/x.c b/src/cmd/go/testdata/src/badc/x.c
new file mode 100644
index 0000000000..f6cbf6924d
--- /dev/null
+++ b/src/cmd/go/testdata/src/badc/x.c
@@ -0,0 +1 @@
+// C code!
diff --git a/src/cmd/go/testdata/src/badc/x.go b/src/cmd/go/testdata/src/badc/x.go
new file mode 100644
index 0000000000..bfa1de28bd
--- /dev/null
+++ b/src/cmd/go/testdata/src/badc/x.go
@@ -0,0 +1 @@
+package badc
diff --git a/src/cmd/go/testdata/src/badtest/badexec/x_test.go b/src/cmd/go/testdata/src/badtest/badexec/x_test.go
new file mode 100644
index 0000000000..12f5051712
--- /dev/null
+++ b/src/cmd/go/testdata/src/badtest/badexec/x_test.go
@@ -0,0 +1,5 @@
+package badexec
+
+func init() {
+	panic("badexec")
+}
diff --git a/src/cmd/go/testdata/src/badtest/badsyntax/x.go b/src/cmd/go/testdata/src/badtest/badsyntax/x.go
new file mode 100644
index 0000000000..c8a5407a5a
--- /dev/null
+++ b/src/cmd/go/testdata/src/badtest/badsyntax/x.go
@@ -0,0 +1 @@
+package badsyntax
diff --git a/src/cmd/go/testdata/src/badtest/badsyntax/x_test.go b/src/cmd/go/testdata/src/badtest/badsyntax/x_test.go
new file mode 100644
index 0000000000..5be10745d9
--- /dev/null
+++ b/src/cmd/go/testdata/src/badtest/badsyntax/x_test.go
@@ -0,0 +1,3 @@
+package badsyntax
+
+func func func func func!
diff --git a/src/cmd/go/testdata/src/badtest/badvar/x.go b/src/cmd/go/testdata/src/badtest/badvar/x.go
new file mode 100644
index 0000000000..fdd46c4c72
--- /dev/null
+++ b/src/cmd/go/testdata/src/badtest/badvar/x.go
@@ -0,0 +1 @@
+package badvar
diff --git a/src/cmd/go/testdata/src/badtest/badvar/x_test.go b/src/cmd/go/testdata/src/badtest/badvar/x_test.go
new file mode 100644
index 0000000000..c67df01c5c
--- /dev/null
+++ b/src/cmd/go/testdata/src/badtest/badvar/x_test.go
@@ -0,0 +1,5 @@
+package badvar_test
+
+func f() {
+	_ = notdefined
+}
diff --git a/src/cmd/go/testdata/src/vetpkg/a_test.go b/src/cmd/go/testdata/src/vetpkg/a_test.go
new file mode 100644
index 0000000000..9b64e8e1a2
--- /dev/null
+++ b/src/cmd/go/testdata/src/vetpkg/a_test.go
@@ -0,0 +1 @@
+package p_test
diff --git a/src/cmd/go/testdata/src/vetpkg/b.go b/src/cmd/go/testdata/src/vetpkg/b.go
new file mode 100644
index 0000000000..99e18f63dc
--- /dev/null
+++ b/src/cmd/go/testdata/src/vetpkg/b.go
@@ -0,0 +1,7 @@
+package p
+
+import "fmt"
+
+func f() {
+	fmt.Printf("%d")
+}
diff --git a/src/cmd/go/testflag.go b/src/cmd/go/testflag.go
index 73f311e5f6..6da74b9967 100644
--- a/src/cmd/go/testflag.go
+++ b/src/cmd/go/testflag.go
@@ -65,9 +65,9 @@ type testFlagSpec struct {
 var testFlagDefn = []*testFlagSpec{
 	// local.
 	{name: "c", boolVar: &testC},
-	{name: "file", multiOK: true},
 	{name: "cover", boolVar: &testCover},
 	{name: "coverpkg"},
+	{name: "o"},
 
 	// build flags.
 	{name: "a", boolVar: &buildA},
@@ -153,6 +153,9 @@ func testFlags(args []string) (packageNames, passToTest []string) {
 		// bool flags.
 		case "a", "c", "i", "n", "x", "v", "race", "cover", "work":
 			setBoolFlag(f.boolVar, value)
+		case "o":
+			testO = value
+			testNeedBinary = true
 		case "p":
 			setIntFlag(&buildP, value)
 		case "exec":
@@ -184,8 +187,6 @@ func testFlags(args []string) (packageNames, passToTest []string) {
 			buildContext.BuildTags = strings.Fields(value)
 		case "compiler":
 			buildCompiler{}.Set(value)
-		case "file":
-			testFiles = append(testFiles, value)
 		case "bench":
 			// record that we saw the flag; don't care about the value
 			testBench = true
diff --git a/src/cmd/go/testgo.go b/src/cmd/go/testgo.go
new file mode 100644
index 0000000000..01923f74bd
--- /dev/null
+++ b/src/cmd/go/testgo.go
@@ -0,0 +1,21 @@
+// 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 file contains extra hooks for testing the go command.
+// It is compiled into the Go binary only when building the
+// test copy; it does not get compiled into the standard go
+// command, so these testing hooks are not present in the
+// go command that everyone uses.
+
+// +build testgo
+
+package main
+
+import "os"
+
+func init() {
+	if v := os.Getenv("TESTGO_IS_GO_RELEASE"); v != "" {
+		isGoRelease = v == "1"
+	}
+}
diff --git a/src/cmd/go/vcs.go b/src/cmd/go/vcs.go
index d07948e64c..0834a7d192 100644
--- a/src/cmd/go/vcs.go
+++ b/src/cmd/go/vcs.go
@@ -33,6 +33,8 @@ type vcsCmd struct {
 
 	scheme  []string
 	pingCmd string
+
+	remoteRepo func(v *vcsCmd, rootDir string) (remoteRepo string, err error)
 }
 
 // A tagCmd describes a command to list available tags
@@ -81,8 +83,17 @@ var vcsHg = &vcsCmd{
 	tagSyncCmd:     "update -r {tag}",
 	tagSyncDefault: "update default",
 
-	scheme:  []string{"https", "http", "ssh"},
-	pingCmd: "identify {scheme}://{repo}",
+	scheme:     []string{"https", "http", "ssh"},
+	pingCmd:    "identify {scheme}://{repo}",
+	remoteRepo: hgRemoteRepo,
+}
+
+func hgRemoteRepo(vcsHg *vcsCmd, rootDir string) (remoteRepo string, err error) {
+	out, err := vcsHg.runOutput(rootDir, "paths default")
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
 }
 
 // vcsGit describes how to use Git.
@@ -104,8 +115,38 @@ var vcsGit = &vcsCmd{
 	tagSyncCmd:     "checkout {tag}",
 	tagSyncDefault: "checkout master",
 
-	scheme:  []string{"git", "https", "http", "git+ssh"},
-	pingCmd: "ls-remote {scheme}://{repo}",
+	scheme:     []string{"git", "https", "http", "git+ssh"},
+	pingCmd:    "ls-remote {scheme}://{repo}",
+	remoteRepo: gitRemoteRepo,
+}
+
+func gitRemoteRepo(vcsGit *vcsCmd, rootDir string) (remoteRepo string, err error) {
+	outb, err := vcsGit.runOutput(rootDir, "remote -v")
+	if err != nil {
+		return "", err
+	}
+	out := string(outb)
+
+	// Expect:
+	// origin	https://github.com/rsc/pdf (fetch)
+	// origin	https://github.com/rsc/pdf (push)
+	// use first line only.
+
+	if !strings.HasPrefix(out, "origin\t") {
+		return "", fmt.Errorf("unable to parse output of git remote -v")
+	}
+	out = strings.TrimPrefix(out, "origin\t")
+	i := strings.Index(out, "\n")
+	if i < 0 {
+		return "", fmt.Errorf("unable to parse output of git remote -v")
+	}
+	out = out[:i]
+	i = strings.LastIndex(out, " ")
+	if i < 0 {
+		return "", fmt.Errorf("unable to parse output of git remote -v")
+	}
+	out = out[:i]
+	return strings.TrimSpace(string(out)), nil
 }
 
 // vcsBzr describes how to use Bazaar.
@@ -138,8 +179,34 @@ var vcsSvn = &vcsCmd{
 	// There is no tag command in subversion.
 	// The branch information is all in the path names.
 
-	scheme:  []string{"https", "http", "svn", "svn+ssh"},
-	pingCmd: "info {scheme}://{repo}",
+	scheme:     []string{"https", "http", "svn", "svn+ssh"},
+	pingCmd:    "info {scheme}://{repo}",
+	remoteRepo: svnRemoteRepo,
+}
+
+func svnRemoteRepo(vcsSvn *vcsCmd, rootDir string) (remoteRepo string, err error) {
+	outb, err := vcsSvn.runOutput(rootDir, "info")
+	if err != nil {
+		return "", err
+	}
+	out := string(outb)
+
+	// Expect:
+	// ...
+	// Repository Root: 
+	// ...
+
+	i := strings.Index(out, "\nRepository Root: ")
+	if i < 0 {
+		return "", fmt.Errorf("unable to parse output of svn info")
+	}
+	out = out[i+len("\nRepository Root: "):]
+	i = strings.Index(out, "\n")
+	if i < 0 {
+		return "", fmt.Errorf("unable to parse output of svn info")
+	}
+	out = out[:i]
+	return strings.TrimSpace(string(out)), nil
 }
 
 func (v *vcsCmd) String() string {
@@ -361,7 +428,14 @@ var httpPrefixRE = regexp.MustCompile(`^https?:`)
 func repoRootForImportPath(importPath string) (*repoRoot, error) {
 	rr, err := repoRootForImportPathStatic(importPath, "")
 	if err == errUnknownSite {
-		rr, err = repoRootForImportDynamic(importPath)
+		// If there are wildcards, look up the thing before the wildcard,
+		// hoping it applies to the wildcarded parts too.
+		// This makes 'go get rsc.io/pdf/...' work in a fresh GOPATH.
+		lookup := strings.TrimSuffix(importPath, "/...")
+		if i := strings.Index(lookup, "/.../"); i >= 0 {
+			lookup = lookup[:i]
+		}
+		rr, err = repoRootForImportDynamic(lookup)
 
 		// repoRootForImportDynamic returns error detail
 		// that is irrelevant if the user didn't intend to use a
@@ -465,11 +539,11 @@ func repoRootForImportPathStatic(importPath, scheme string) (*repoRoot, error) {
 func repoRootForImportDynamic(importPath string) (*repoRoot, error) {
 	slash := strings.Index(importPath, "/")
 	if slash < 0 {
-		return nil, errors.New("import path doesn't contain a slash")
+		return nil, errors.New("import path does not contain a slash")
 	}
 	host := importPath[:slash]
 	if !strings.Contains(host, ".") {
-		return nil, errors.New("import path doesn't contain a hostname")
+		return nil, errors.New("import path does not begin with hostname")
 	}
 	urlStr, body, err := httpsOrHTTP(importPath)
 	if err != nil {
diff --git a/src/cmd/go/vet.go b/src/cmd/go/vet.go
index ffb4318373..de7befc611 100644
--- a/src/cmd/go/vet.go
+++ b/src/cmd/go/vet.go
@@ -4,6 +4,8 @@
 
 package main
 
+import "path/filepath"
+
 func init() {
 	addBuildFlagsNX(cmdVet)
 }
@@ -28,10 +30,21 @@ See also: go fmt, go fix.
 }
 
 func runVet(cmd *Command, args []string) {
-	for _, pkg := range packages(args) {
-		// Use pkg.gofiles instead of pkg.Dir so that
-		// the command only applies to this package,
-		// not to packages in subdirectories.
-		run(tool("vet"), relPaths(stringList(pkg.gofiles, pkg.sfiles)))
+	for _, p := range packages(args) {
+		// Vet expects to be given a set of files all from the same package.
+		// Run once for package p and once for package p_test.
+		if len(p.GoFiles)+len(p.CgoFiles)+len(p.TestGoFiles) > 0 {
+			runVetFiles(p, stringList(p.GoFiles, p.CgoFiles, p.TestGoFiles, p.SFiles))
+		}
+		if len(p.XTestGoFiles) > 0 {
+			runVetFiles(p, stringList(p.XTestGoFiles))
+		}
 	}
 }
+
+func runVetFiles(p *Package, files []string) {
+	for i := range files {
+		files[i] = filepath.Join(p.Dir, files[i])
+	}
+	run(tool("vet"), relPaths(files))
+}
diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index f322a2b0a0..81da21ff10 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -87,13 +87,13 @@ func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error
 		return err
 	}
 
-	file, adjust, err := parse(fileSet, filename, src, stdin)
+	file, sourceAdj, indentAdj, err := parse(fileSet, filename, src, stdin)
 	if err != nil {
 		return err
 	}
 
 	if rewrite != nil {
-		if adjust == nil {
+		if sourceAdj == nil {
 			file = rewrite(file)
 		} else {
 			fmt.Fprintf(os.Stderr, "warning: rewrite ignored for incomplete programs\n")
@@ -106,15 +106,10 @@ func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error
 		simplify(file)
 	}
 
-	var buf bytes.Buffer
-	err = (&printer.Config{Mode: printerMode, Tabwidth: tabWidth}).Fprint(&buf, fileSet, file)
+	res, err := format(fileSet, file, sourceAdj, indentAdj, src, printer.Config{Mode: printerMode, Tabwidth: tabWidth})
 	if err != nil {
 		return err
 	}
-	res := buf.Bytes()
-	if adjust != nil {
-		res = adjust(src, res)
-	}
 
 	if !bytes.Equal(src, res) {
 		// formatting has changed
@@ -240,19 +235,29 @@ func diff(b1, b2 []byte) (data []byte, err error) {
 
 }
 
-// parse parses src, which was read from filename,
-// as a Go source file or statement list.
-func parse(fset *token.FileSet, filename string, src []byte, stdin bool) (*ast.File, func(orig, src []byte) []byte, error) {
+// ----------------------------------------------------------------------------
+// Support functions
+//
+// The functions parse, format, and isSpace below are identical to the
+// respective functions in src/go/format/format.go - keep them in sync!
+//
+// TODO(gri) Factor out this functionality, eventually.
+
+// parse parses src, which was read from the named file,
+// as a Go source file, declaration, or statement list.
+func parse(fset *token.FileSet, filename string, src []byte, fragmentOk bool) (
+	file *ast.File,
+	sourceAdj func(src []byte, indent int) []byte,
+	indentAdj int,
+	err error,
+) {
 	// Try as whole source file.
-	file, err := parser.ParseFile(fset, filename, src, parserMode)
-	if err == nil {
-		return file, nil, nil
-	}
-	// If the error is that the source file didn't begin with a
-	// package line and this is standard input, fall through to
+	file, err = parser.ParseFile(fset, filename, src, parserMode)
+	// If there's no error, return.  If the error is that the source file didn't begin with a
+	// package line and source fragments are ok, fall through to
 	// try as a source fragment.  Stop and return on any other error.
-	if !stdin || !strings.Contains(err.Error(), "expected 'package'") {
-		return nil, nil, err
+	if err == nil || !fragmentOk || !strings.Contains(err.Error(), "expected 'package'") {
+		return
 	}
 
 	// If this is a declaration list, make it a source file
@@ -262,19 +267,19 @@ func parse(fset *token.FileSet, filename string, src []byte, stdin bool) (*ast.F
 	psrc := append([]byte("package p;"), src...)
 	file, err = parser.ParseFile(fset, filename, psrc, parserMode)
 	if err == nil {
-		adjust := func(orig, src []byte) []byte {
+		sourceAdj = func(src []byte, indent int) []byte {
 			// Remove the package clause.
 			// Gofmt has turned the ; into a \n.
-			src = src[len("package p\n"):]
-			return matchSpace(orig, src)
+			src = src[indent+len("package p\n"):]
+			return bytes.TrimSpace(src)
 		}
-		return file, adjust, nil
+		return
 	}
 	// If the error is that the source file didn't begin with a
 	// declaration, fall through to try as a statement list.
 	// Stop and return on any other error.
 	if !strings.Contains(err.Error(), "expected declaration") {
-		return nil, nil, err
+		return
 	}
 
 	// If this is a statement list, make it a source file
@@ -285,65 +290,98 @@ func parse(fset *token.FileSet, filename string, src []byte, stdin bool) (*ast.F
 	fsrc := append(append([]byte("package p; func _() {"), src...), '\n', '}')
 	file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
 	if err == nil {
-		adjust := func(orig, src []byte) []byte {
+		sourceAdj = func(src []byte, indent int) []byte {
+			// Cap adjusted indent to zero.
+			if indent < 0 {
+				indent = 0
+			}
 			// Remove the wrapping.
 			// Gofmt has turned the ; into a \n\n.
-			src = src[len("package p\n\nfunc _() {"):]
-			src = src[:len(src)-len("\n}\n")]
-			// Gofmt has also indented the function body one level.
-			// Remove that indent.
-			src = bytes.Replace(src, []byte("\n\t"), []byte("\n"), -1)
-			return matchSpace(orig, src)
+			// There will be two non-blank lines with indent, hence 2*indent.
+			src = src[2*indent+len("package p\n\nfunc _() {"):]
+			src = src[:len(src)-(indent+len("\n}\n"))]
+			return bytes.TrimSpace(src)
 		}
-		return file, adjust, nil
+		// Gofmt has also indented the function body one level.
+		// Adjust that with indentAdj.
+		indentAdj = -1
 	}
 
-	// Failed, and out of options.
-	return nil, nil, err
+	// Succeeded, or out of options.
+	return
 }
 
-func cutSpace(b []byte) (before, middle, after []byte) {
-	i := 0
-	for i < len(b) && (b[i] == ' ' || b[i] == '\t' || b[i] == '\n') {
-		i++
+// format formats the given package file originally obtained from src
+// and adjusts the result based on the original source via sourceAdj
+// and indentAdj.
+func format(
+	fset *token.FileSet,
+	file *ast.File,
+	sourceAdj func(src []byte, indent int) []byte,
+	indentAdj int,
+	src []byte,
+	cfg printer.Config,
+) ([]byte, error) {
+	if sourceAdj == nil {
+		// Complete source file.
+		var buf bytes.Buffer
+		err := cfg.Fprint(&buf, fset, file)
+		if err != nil {
+			return nil, err
+		}
+		return buf.Bytes(), nil
 	}
-	j := len(b)
-	for j > 0 && (b[j-1] == ' ' || b[j-1] == '\t' || b[j-1] == '\n') {
-		j--
+
+	// Partial source file.
+	// Determine and prepend leading space.
+	i, j := 0, 0
+	for j < len(src) && isSpace(src[j]) {
+		if src[j] == '\n' {
+			i = j + 1 // byte offset of last line in leading space
+		}
+		j++
 	}
-	if i <= j {
-		return b[:i], b[i:j], b[j:]
+	var res []byte
+	res = append(res, src[:i]...)
+
+	// Determine and prepend indentation of first code line.
+	// Spaces are ignored unless there are no tabs,
+	// in which case spaces count as one tab.
+	indent := 0
+	hasSpace := false
+	for _, b := range src[i:j] {
+		switch b {
+		case ' ':
+			hasSpace = true
+		case '\t':
+			indent++
+		}
 	}
-	return nil, nil, b[j:]
+	if indent == 0 && hasSpace {
+		indent = 1
+	}
+	for i := 0; i < indent; i++ {
+		res = append(res, '\t')
+	}
+
+	// Format the source.
+	// Write it without any leading and trailing space.
+	cfg.Indent = indent + indentAdj
+	var buf bytes.Buffer
+	err := cfg.Fprint(&buf, fset, file)
+	if err != nil {
+		return nil, err
+	}
+	res = append(res, sourceAdj(buf.Bytes(), cfg.Indent)...)
+
+	// Determine and append trailing space.
+	i = len(src)
+	for i > 0 && isSpace(src[i-1]) {
+		i--
+	}
+	return append(res, src[i:]...), nil
 }
 
-// matchSpace reformats src to use the same space context as orig.
-// 1) If orig begins with blank lines, matchSpace inserts them at the beginning of src.
-// 2) matchSpace copies the indentation of the first non-blank line in orig
-//    to every non-blank line in src.
-// 3) matchSpace copies the trailing space from orig and uses it in place
-//   of src's trailing space.
-func matchSpace(orig []byte, src []byte) []byte {
-	before, _, after := cutSpace(orig)
-	i := bytes.LastIndex(before, []byte{'\n'})
-	before, indent := before[:i+1], before[i+1:]
-
-	_, src, _ = cutSpace(src)
-
-	var b bytes.Buffer
-	b.Write(before)
-	for len(src) > 0 {
-		line := src
-		if i := bytes.IndexByte(line, '\n'); i >= 0 {
-			line, src = line[:i+1], line[i+1:]
-		} else {
-			src = nil
-		}
-		if len(line) > 0 && line[0] != '\n' { // not blank
-			b.Write(indent)
-		}
-		b.Write(line)
-	}
-	b.Write(after)
-	return b.Bytes()
+func isSpace(b byte) bool {
+	return b == ' ' || b == '\t' || b == '\n' || b == '\r'
 }
diff --git a/src/cmd/gofmt/long_test.go b/src/cmd/gofmt/long_test.go
index 108278b336..237b86021b 100644
--- a/src/cmd/gofmt/long_test.go
+++ b/src/cmd/gofmt/long_test.go
@@ -32,7 +32,7 @@ var (
 )
 
 func gofmt(fset *token.FileSet, filename string, src *bytes.Buffer) error {
-	f, _, err := parse(fset, filename, src.Bytes(), false)
+	f, _, _, err := parse(fset, filename, src.Bytes(), false)
 	if err != nil {
 		return err
 	}
@@ -60,7 +60,7 @@ func testFile(t *testing.T, b1, b2 *bytes.Buffer, filename string) {
 
 	// exclude files w/ syntax errors (typically test cases)
 	fset := token.NewFileSet()
-	if _, _, err = parse(fset, filename, b1.Bytes(), false); err != nil {
+	if _, _, _, err = parse(fset, filename, b1.Bytes(), false); err != nil {
 		if *verbose {
 			fmt.Fprintf(os.Stderr, "ignoring %s\n", err)
 		}
diff --git a/src/cmd/gofmt/testdata/stdin6.golden b/src/cmd/gofmt/testdata/stdin6.golden
new file mode 100644
index 0000000000..ffcea8011b
--- /dev/null
+++ b/src/cmd/gofmt/testdata/stdin6.golden
@@ -0,0 +1,19 @@
+	//gofmt -stdin
+
+	if err != nil {
+		source := strings.NewReader(`line 1.
+line 2.
+`)
+		return source
+	}
+
+	f := func(hat, tail string) {
+
+		fmt.Println(hat+`
+foo
+
+
+`+tail,
+			"more",
+			"and more")
+	}
diff --git a/src/cmd/gofmt/testdata/stdin6.input b/src/cmd/gofmt/testdata/stdin6.input
new file mode 100644
index 0000000000..78330020c6
--- /dev/null
+++ b/src/cmd/gofmt/testdata/stdin6.input
@@ -0,0 +1,21 @@
+	//gofmt -stdin
+
+	if err != nil {
+		source := strings.NewReader(`line 1.
+line 2.
+`)
+		return source
+	}
+
+	f:=func(  hat, tail string){
+
+
+
+		   fmt.  Println  (   hat+   `
+foo
+
+
+`+ tail  ,
+ "more" ,
+		"and more"   )
+	}
diff --git a/src/cmd/gofmt/testdata/stdin7.golden b/src/cmd/gofmt/testdata/stdin7.golden
new file mode 100644
index 0000000000..bbac7133c8
--- /dev/null
+++ b/src/cmd/gofmt/testdata/stdin7.golden
@@ -0,0 +1,19 @@
+															//gofmt -stdin
+
+															if err != nil {
+																source := strings.NewReader(`line 1.
+line 2.
+`)
+																return source
+															}
+
+															f := func(hat, tail string) {
+
+																fmt.Println(hat+`
+		foo
+
+
+	`+tail,
+																	"more",
+																	"and more")
+															}
diff --git a/src/cmd/gofmt/testdata/stdin7.input b/src/cmd/gofmt/testdata/stdin7.input
new file mode 100644
index 0000000000..fd772a3c4e
--- /dev/null
+++ b/src/cmd/gofmt/testdata/stdin7.input
@@ -0,0 +1,21 @@
+															//gofmt -stdin
+
+															if err != nil {
+								source := strings.NewReader(`line 1.
+line 2.
+`)
+								return source
+							}
+
+							f:=func(  hat, tail string){
+
+
+
+								   fmt.  Println  (   hat+   `
+		foo
+
+
+	`+ tail  ,
+						 "more" ,
+								"and more"   )
+							}
diff --git a/src/cmd/internal/rsc.io/arm/armasm/Makefile b/src/cmd/internal/rsc.io/arm/armasm/Makefile
new file mode 100644
index 0000000000..a3f57001f6
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/Makefile
@@ -0,0 +1,2 @@
+tables.go: ../armmap/map.go ../arm.csv 
+	go run ../armmap/map.go -fmt=decoder ../arm.csv >_tables.go && gofmt _tables.go >tables.go && rm _tables.go
diff --git a/src/cmd/internal/rsc.io/arm/armasm/decode.go b/src/cmd/internal/rsc.io/arm/armasm/decode.go
new file mode 100644
index 0000000000..6b4d73841b
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/decode.go
@@ -0,0 +1,567 @@
+// 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 armasm
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+// An instFormat describes the format of an instruction encoding.
+// An instruction with 32-bit value x matches the format if x&mask == value
+// and the condition matches.
+// The condition matches if x>>28 == 0xF && value>>28==0xF
+// or if x>>28 != 0xF and value>>28 == 0.
+// If x matches the format, then the rest of the fields describe how to interpret x.
+// The opBits describe bits that should be extracted from x and added to the opcode.
+// For example opBits = 0x1234 means that the value
+//	(2 bits at offset 1) followed by (4 bits at offset 3)
+// should be added to op.
+// Finally the args describe how to decode the instruction arguments.
+// args is stored as a fixed-size array; if there are fewer than len(args) arguments,
+// args[i] == 0 marks the end of the argument list.
+type instFormat struct {
+	mask     uint32
+	value    uint32
+	priority int8
+	op       Op
+	opBits   uint64
+	args     instArgs
+}
+
+type instArgs [4]instArg
+
+var (
+	errMode    = fmt.Errorf("unsupported execution mode")
+	errShort   = fmt.Errorf("truncated instruction")
+	errUnknown = fmt.Errorf("unknown instruction")
+)
+
+var decoderCover []bool
+
+// Decode decodes the leading bytes in src as a single instruction.
+func Decode(src []byte, mode Mode) (inst Inst, err error) {
+	if mode != ModeARM {
+		return Inst{}, errMode
+	}
+	if len(src) < 4 {
+		return Inst{}, errShort
+	}
+
+	if decoderCover == nil {
+		decoderCover = make([]bool, len(instFormats))
+	}
+
+	x := binary.LittleEndian.Uint32(src)
+
+	// The instFormat table contains both conditional and unconditional instructions.
+	// Considering only the top 4 bits, the conditional instructions use mask=0, value=0,
+	// while the unconditional instructions use mask=f, value=f.
+	// Prepare a version of x with the condition cleared to 0 in conditional instructions
+	// and then assume mask=f during matching.
+	const condMask = 0xf0000000
+	xNoCond := x
+	if x&condMask != condMask {
+		xNoCond &^= condMask
+	}
+	var priority int8
+Search:
+	for i := range instFormats {
+		f := &instFormats[i]
+		if xNoCond&(f.mask|condMask) != f.value || f.priority <= priority {
+			continue
+		}
+		delta := uint32(0)
+		deltaShift := uint(0)
+		for opBits := f.opBits; opBits != 0; opBits >>= 16 {
+			n := uint(opBits & 0xFF)
+			off := uint((opBits >> 8) & 0xFF)
+			delta |= (x >> off) & (1<> 8) & (1<<4 - 1))
+	case arg_R_12:
+		return Reg((x >> 12) & (1<<4 - 1))
+	case arg_R_16:
+		return Reg((x >> 16) & (1<<4 - 1))
+
+	case arg_R_12_nzcv:
+		r := Reg((x >> 12) & (1<<4 - 1))
+		if r == R15 {
+			return APSR_nzcv
+		}
+		return r
+
+	case arg_R_16_WB:
+		mode := AddrLDM
+		if (x>>21)&1 != 0 {
+			mode = AddrLDM_WB
+		}
+		return Mem{Base: Reg((x >> 16) & (1<<4 - 1)), Mode: mode}
+
+	case arg_R_rotate:
+		Rm := Reg(x & (1<<4 - 1))
+		typ, count := decodeShift(x)
+		// ROR #0 here means ROR #0, but decodeShift rewrites to RRX #1.
+		if typ == RotateRightExt {
+			return Reg(Rm)
+		}
+		return RegShift{Rm, typ, uint8(count)}
+
+	case arg_R_shift_R:
+		Rm := Reg(x & (1<<4 - 1))
+		Rs := Reg((x >> 8) & (1<<4 - 1))
+		typ := Shift((x >> 5) & (1<<2 - 1))
+		return RegShiftReg{Rm, typ, Rs}
+
+	case arg_R_shift_imm:
+		Rm := Reg(x & (1<<4 - 1))
+		typ, count := decodeShift(x)
+		if typ == ShiftLeft && count == 0 {
+			return Reg(Rm)
+		}
+		return RegShift{Rm, typ, uint8(count)}
+
+	case arg_R1_0:
+		return Reg((x & (1<<4 - 1)))
+	case arg_R1_12:
+		return Reg(((x >> 12) & (1<<4 - 1)))
+	case arg_R2_0:
+		return Reg((x & (1<<4 - 1)) | 1)
+	case arg_R2_12:
+		return Reg(((x >> 12) & (1<<4 - 1)) | 1)
+
+	case arg_SP:
+		return SP
+
+	case arg_Sd_Dd:
+		v := (x >> 12) & (1<<4 - 1)
+		vx := (x >> 22) & 1
+		sz := (x >> 8) & 1
+		if sz != 0 {
+			return D0 + Reg(vx<<4+v)
+		} else {
+			return S0 + Reg(v<<1+vx)
+		}
+
+	case arg_Dd_Sd:
+		return decodeArg(arg_Sd_Dd, x^(1<<8))
+
+	case arg_Sd:
+		v := (x >> 12) & (1<<4 - 1)
+		vx := (x >> 22) & 1
+		return S0 + Reg(v<<1+vx)
+
+	case arg_Sm_Dm:
+		v := (x >> 0) & (1<<4 - 1)
+		vx := (x >> 5) & 1
+		sz := (x >> 8) & 1
+		if sz != 0 {
+			return D0 + Reg(vx<<4+v)
+		} else {
+			return S0 + Reg(v<<1+vx)
+		}
+
+	case arg_Sm:
+		v := (x >> 0) & (1<<4 - 1)
+		vx := (x >> 5) & 1
+		return S0 + Reg(v<<1+vx)
+
+	case arg_Dn_half:
+		v := (x >> 16) & (1<<4 - 1)
+		vx := (x >> 7) & 1
+		return RegX{D0 + Reg(vx<<4+v), int((x >> 21) & 1)}
+
+	case arg_Sn_Dn:
+		v := (x >> 16) & (1<<4 - 1)
+		vx := (x >> 7) & 1
+		sz := (x >> 8) & 1
+		if sz != 0 {
+			return D0 + Reg(vx<<4+v)
+		} else {
+			return S0 + Reg(v<<1+vx)
+		}
+
+	case arg_Sn:
+		v := (x >> 16) & (1<<4 - 1)
+		vx := (x >> 7) & 1
+		return S0 + Reg(v<<1+vx)
+
+	case arg_const:
+		v := x & (1<<8 - 1)
+		rot := (x >> 8) & (1<<4 - 1) * 2
+		if rot > 0 && v&3 == 0 {
+			// could rotate less
+			return ImmAlt{uint8(v), uint8(rot)}
+		}
+		if rot >= 24 && ((v<<(32-rot))&0xFF)>>(32-rot) == v {
+			// could wrap around to rot==0.
+			return ImmAlt{uint8(v), uint8(rot)}
+		}
+		return Imm(v>>rot | v<<(32-rot))
+
+	case arg_endian:
+		return Endian((x >> 9) & 1)
+
+	case arg_fbits:
+		return Imm((16 << ((x >> 7) & 1)) - ((x&(1<<4-1))<<1 | (x>>5)&1))
+
+	case arg_fp_0:
+		return Imm(0)
+
+	case arg_imm24:
+		return Imm(x & (1<<24 - 1))
+
+	case arg_imm5:
+		return Imm((x >> 7) & (1<<5 - 1))
+
+	case arg_imm5_32:
+		x = (x >> 7) & (1<<5 - 1)
+		if x == 0 {
+			x = 32
+		}
+		return Imm(x)
+
+	case arg_imm5_nz:
+		x = (x >> 7) & (1<<5 - 1)
+		if x == 0 {
+			return nil
+		}
+		return Imm(x)
+
+	case arg_imm_4at16_12at0:
+		return Imm((x>>16)&(1<<4-1)<<12 | x&(1<<12-1))
+
+	case arg_imm_12at8_4at0:
+		return Imm((x>>8)&(1<<12-1)<<4 | x&(1<<4-1))
+
+	case arg_imm_vfp:
+		x = (x>>16)&(1<<4-1)<<4 | x&(1<<4-1)
+		return Imm(x)
+
+	case arg_label24:
+		imm := (x & (1<<24 - 1)) << 2
+		return PCRel(int32(imm<<6) >> 6)
+
+	case arg_label24H:
+		h := (x >> 24) & 1
+		imm := (x&(1<<24-1))<<2 | h<<1
+		return PCRel(int32(imm<<6) >> 6)
+
+	case arg_label_m_12:
+		d := int32(x & (1<<12 - 1))
+		return Mem{Base: PC, Mode: AddrOffset, Offset: int16(-d)}
+
+	case arg_label_p_12:
+		d := int32(x & (1<<12 - 1))
+		return Mem{Base: PC, Mode: AddrOffset, Offset: int16(d)}
+
+	case arg_label_pm_12:
+		d := int32(x & (1<<12 - 1))
+		u := (x >> 23) & 1
+		if u == 0 {
+			d = -d
+		}
+		return Mem{Base: PC, Mode: AddrOffset, Offset: int16(d)}
+
+	case arg_label_pm_4_4:
+		d := int32((x>>8)&(1<<4-1)<<4 | x&(1<<4-1))
+		u := (x >> 23) & 1
+		if u == 0 {
+			d = -d
+		}
+		return PCRel(d)
+
+	case arg_lsb_width:
+		lsb := (x >> 7) & (1<<5 - 1)
+		msb := (x >> 16) & (1<<5 - 1)
+		if msb < lsb || msb >= 32 {
+			return nil
+		}
+		return Imm(msb + 1 - lsb)
+
+	case arg_mem_R:
+		Rn := Reg((x >> 16) & (1<<4 - 1))
+		return Mem{Base: Rn, Mode: AddrOffset}
+
+	case arg_mem_R_pm_R_postindex:
+		// Treat [],+/- like [,+/-{,}]{!}
+		// by forcing shift bits to <<0 and P=0, W=0 (postindex=true).
+		return decodeArg(arg_mem_R_pm_R_shift_imm_W, x&^((1<<7-1)<<5|1<<24|1<<21))
+
+	case arg_mem_R_pm_R_W:
+		// Treat [,+/-]{!} like [,+/-{,}]{!}
+		// by forcing shift bits to <<0.
+		return decodeArg(arg_mem_R_pm_R_shift_imm_W, x&^((1<<7-1)<<5))
+
+	case arg_mem_R_pm_R_shift_imm_offset:
+		// Treat [],+/-{,} like [,+/-{,}]{!}
+		// by forcing P=1, W=0 (index=false, wback=false).
+		return decodeArg(arg_mem_R_pm_R_shift_imm_W, x&^(1<<21)|1<<24)
+
+	case arg_mem_R_pm_R_shift_imm_postindex:
+		// Treat [],+/-{,} like [,+/-{,}]{!}
+		// by forcing P=0, W=0 (postindex=true).
+		return decodeArg(arg_mem_R_pm_R_shift_imm_W, x&^(1<<24|1<<21))
+
+	case arg_mem_R_pm_R_shift_imm_W:
+		Rn := Reg((x >> 16) & (1<<4 - 1))
+		Rm := Reg(x & (1<<4 - 1))
+		typ, count := decodeShift(x)
+		u := (x >> 23) & 1
+		w := (x >> 21) & 1
+		p := (x >> 24) & 1
+		if p == 0 && w == 1 {
+			return nil
+		}
+		sign := int8(+1)
+		if u == 0 {
+			sign = -1
+		}
+		mode := AddrMode(uint8(p<<1) | uint8(w^1))
+		return Mem{Base: Rn, Mode: mode, Sign: sign, Index: Rm, Shift: typ, Count: count}
+
+	case arg_mem_R_pm_imm12_offset:
+		// Treat [,#+/-] like [{,#+/-}]{!}
+		// by forcing P=1, W=0 (index=false, wback=false).
+		return decodeArg(arg_mem_R_pm_imm12_W, x&^(1<<21)|1<<24)
+
+	case arg_mem_R_pm_imm12_postindex:
+		// Treat [],#+/- like [{,#+/-}]{!}
+		// by forcing P=0, W=0 (postindex=true).
+		return decodeArg(arg_mem_R_pm_imm12_W, x&^(1<<24|1<<21))
+
+	case arg_mem_R_pm_imm12_W:
+		Rn := Reg((x >> 16) & (1<<4 - 1))
+		u := (x >> 23) & 1
+		w := (x >> 21) & 1
+		p := (x >> 24) & 1
+		if p == 0 && w == 1 {
+			return nil
+		}
+		sign := int8(+1)
+		if u == 0 {
+			sign = -1
+		}
+		imm := int16(x & (1<<12 - 1))
+		mode := AddrMode(uint8(p<<1) | uint8(w^1))
+		return Mem{Base: Rn, Mode: mode, Offset: int16(sign) * imm}
+
+	case arg_mem_R_pm_imm8_postindex:
+		// Treat [],#+/- like [{,#+/-}]{!}
+		// by forcing P=0, W=0 (postindex=true).
+		return decodeArg(arg_mem_R_pm_imm8_W, x&^(1<<24|1<<21))
+
+	case arg_mem_R_pm_imm8_W:
+		Rn := Reg((x >> 16) & (1<<4 - 1))
+		u := (x >> 23) & 1
+		w := (x >> 21) & 1
+		p := (x >> 24) & 1
+		if p == 0 && w == 1 {
+			return nil
+		}
+		sign := int8(+1)
+		if u == 0 {
+			sign = -1
+		}
+		imm := int16((x>>8)&(1<<4-1)<<4 | x&(1<<4-1))
+		mode := AddrMode(uint8(p<<1) | uint8(w^1))
+		return Mem{Base: Rn, Mode: mode, Offset: int16(sign) * imm}
+
+	case arg_mem_R_pm_imm8at0_offset:
+		Rn := Reg((x >> 16) & (1<<4 - 1))
+		u := (x >> 23) & 1
+		sign := int8(+1)
+		if u == 0 {
+			sign = -1
+		}
+		imm := int16(x&(1<<8-1)) << 2
+		return Mem{Base: Rn, Mode: AddrOffset, Offset: int16(sign) * imm}
+
+	case arg_option:
+		return Imm(x & (1<<4 - 1))
+
+	case arg_registers:
+		return RegList(x & (1<<16 - 1))
+
+	case arg_registers2:
+		x &= 1<<16 - 1
+		n := 0
+		for i := 0; i < 16; i++ {
+			if x>>uint(i)&1 != 0 {
+				n++
+			}
+		}
+		if n < 2 {
+			return nil
+		}
+		return RegList(x)
+
+	case arg_registers1:
+		Rt := (x >> 12) & (1<<4 - 1)
+		return RegList(1 << Rt)
+
+	case arg_satimm4:
+		return Imm((x >> 16) & (1<<4 - 1))
+
+	case arg_satimm5:
+		return Imm((x >> 16) & (1<<5 - 1))
+
+	case arg_satimm4m1:
+		return Imm((x>>16)&(1<<4-1) + 1)
+
+	case arg_satimm5m1:
+		return Imm((x>>16)&(1<<5-1) + 1)
+
+	case arg_widthm1:
+		return Imm((x>>16)&(1<<5-1) + 1)
+
+	}
+}
+
+// decodeShift decodes the shift-by-immediate encoded in x.
+func decodeShift(x uint32) (Shift, uint8) {
+	count := (x >> 7) & (1<<5 - 1)
+	typ := Shift((x >> 5) & (1<<2 - 1))
+	switch typ {
+	case ShiftRight, ShiftRightSigned:
+		if count == 0 {
+			count = 32
+		}
+	case RotateRight:
+		if count == 0 {
+			typ = RotateRightExt
+			count = 1
+		}
+	}
+	return typ, uint8(count)
+}
diff --git a/src/cmd/internal/rsc.io/arm/armasm/decode_test.go b/src/cmd/internal/rsc.io/arm/armasm/decode_test.go
new file mode 100644
index 0000000000..25a345a882
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/decode_test.go
@@ -0,0 +1,69 @@
+// 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 armasm
+
+import (
+	"encoding/hex"
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestDecode(t *testing.T) {
+	data, err := ioutil.ReadFile("testdata/decode.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := string(data)
+	for strings.Contains(all, "\t\t") {
+		all = strings.Replace(all, "\t\t", "\t", -1)
+	}
+	for _, line := range strings.Split(all, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		f := strings.SplitN(line, "\t", 4)
+		i := strings.Index(f[0], "|")
+		if i < 0 {
+			t.Errorf("parsing %q: missing | separator", f[0])
+			continue
+		}
+		if i%2 != 0 {
+			t.Errorf("parsing %q: misaligned | separator", f[0])
+		}
+		size := i / 2
+		code, err := hex.DecodeString(f[0][:i] + f[0][i+1:])
+		if err != nil {
+			t.Errorf("parsing %q: %v", f[0], err)
+			continue
+		}
+		mode, err := strconv.Atoi(f[1])
+		if err != nil {
+			t.Errorf("invalid mode %q in: %s", f[1], line)
+			continue
+		}
+		syntax, asm := f[2], f[3]
+		inst, err := Decode(code, Mode(mode))
+		var out string
+		if err != nil {
+			out = "error: " + err.Error()
+		} else {
+			switch syntax {
+			case "gnu":
+				out = GNUSyntax(inst)
+			case "plan9":
+				out = Plan9Syntax(inst, 0, nil, nil)
+			default:
+				t.Errorf("unknown syntax %q", syntax)
+				continue
+			}
+		}
+		if out != asm || inst.Len != size {
+			t.Errorf("Decode(%s) [%s] = %s, %d, want %s, %d", f[0], syntax, out, inst.Len, asm, size)
+		}
+	}
+}
diff --git a/src/cmd/internal/rsc.io/arm/armasm/ext_test.go b/src/cmd/internal/rsc.io/arm/armasm/ext_test.go
new file mode 100644
index 0000000000..b0bd855970
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/ext_test.go
@@ -0,0 +1,614 @@
+// 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.
+
+// Support for testing against external disassembler program.
+// Copied and simplified from rsc.io/x86/x86asm/ext_test.go.
+
+package armasm
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/hex"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"math/rand"
+	"os"
+	"os/exec"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+var (
+	printTests = flag.Bool("printtests", false, "print test cases that exercise new code paths")
+	dumpTest   = flag.Bool("dump", false, "dump all encodings")
+	mismatch   = flag.Bool("mismatch", false, "log allowed mismatches")
+	longTest   = flag.Bool("long", false, "long test")
+	keep       = flag.Bool("keep", false, "keep object files around")
+	debug      = false
+)
+
+// A ExtInst represents a single decoded instruction parsed
+// from an external disassembler's output.
+type ExtInst struct {
+	addr uint32
+	enc  [4]byte
+	nenc int
+	text string
+}
+
+func (r ExtInst) String() string {
+	return fmt.Sprintf("%#x: % x: %s", r.addr, r.enc, r.text)
+}
+
+// An ExtDis is a connection between an external disassembler and a test.
+type ExtDis struct {
+	Arch     Mode
+	Dec      chan ExtInst
+	File     *os.File
+	Size     int
+	KeepFile bool
+	Cmd      *exec.Cmd
+}
+
+// Run runs the given command - the external disassembler - and returns
+// a buffered reader of its standard output.
+func (ext *ExtDis) Run(cmd ...string) (*bufio.Reader, error) {
+	if *keep {
+		log.Printf("%s\n", strings.Join(cmd, " "))
+	}
+	ext.Cmd = exec.Command(cmd[0], cmd[1:]...)
+	out, err := ext.Cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("stdoutpipe: %v", err)
+	}
+	if err := ext.Cmd.Start(); err != nil {
+		return nil, fmt.Errorf("exec: %v", err)
+	}
+
+	b := bufio.NewReaderSize(out, 1<<20)
+	return b, nil
+}
+
+// Wait waits for the command started with Run to exit.
+func (ext *ExtDis) Wait() error {
+	return ext.Cmd.Wait()
+}
+
+// testExtDis tests a set of byte sequences against an external disassembler.
+// The disassembler is expected to produce the given syntax and be run
+// in the given architecture mode (16, 32, or 64-bit).
+// The extdis function must start the external disassembler
+// and then parse its output, sending the parsed instructions on ext.Dec.
+// The generate function calls its argument f once for each byte sequence
+// to be tested. The generate function itself will be called twice, and it must
+// make the same sequence of calls to f each time.
+// When a disassembly does not match the internal decoding,
+// allowedMismatch determines whether this mismatch should be
+// allowed, or else considered an error.
+func testExtDis(
+	t *testing.T,
+	syntax string,
+	arch Mode,
+	extdis func(ext *ExtDis) error,
+	generate func(f func([]byte)),
+	allowedMismatch func(text string, size int, inst *Inst, dec ExtInst) bool,
+) {
+	start := time.Now()
+	ext := &ExtDis{
+		Dec:  make(chan ExtInst),
+		Arch: arch,
+	}
+	errc := make(chan error)
+
+	// First pass: write instructions to input file for external disassembler.
+	file, f, size, err := writeInst(generate)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ext.Size = size
+	ext.File = f
+	defer func() {
+		f.Close()
+		if !*keep {
+			os.Remove(file)
+		}
+	}()
+
+	// Second pass: compare disassembly against our decodings.
+	var (
+		totalTests  = 0
+		totalSkips  = 0
+		totalErrors = 0
+
+		errors = make([]string, 0, 100) // sampled errors, at most cap
+	)
+	go func() {
+		errc <- extdis(ext)
+	}()
+	generate(func(enc []byte) {
+		dec, ok := <-ext.Dec
+		if !ok {
+			t.Errorf("decoding stream ended early")
+			return
+		}
+		inst, text := disasm(syntax, arch, pad(enc))
+		totalTests++
+		if *dumpTest {
+			fmt.Printf("%x -> %s [%d]\n", enc[:len(enc)], dec.text, dec.nenc)
+		}
+		if text != dec.text || inst.Len != dec.nenc {
+			suffix := ""
+			if allowedMismatch(text, size, &inst, dec) {
+				totalSkips++
+				if !*mismatch {
+					return
+				}
+				suffix += " (allowed mismatch)"
+			}
+			totalErrors++
+			if len(errors) >= cap(errors) {
+				j := rand.Intn(totalErrors)
+				if j >= cap(errors) {
+					return
+				}
+				errors = append(errors[:j], errors[j+1:]...)
+			}
+			errors = append(errors, fmt.Sprintf("decode(%x) = %q, %d, want %q, %d%s", enc, text, inst.Len, dec.text, dec.nenc, suffix))
+		}
+	})
+
+	if *mismatch {
+		totalErrors -= totalSkips
+	}
+
+	for _, b := range errors {
+		t.Log(b)
+	}
+
+	if totalErrors > 0 {
+		t.Fail()
+	}
+	t.Logf("%d test cases, %d expected mismatches, %d failures; %.0f cases/second", totalTests, totalSkips, totalErrors, float64(totalTests)/time.Since(start).Seconds())
+
+	if err := <-errc; err != nil {
+		t.Fatal("external disassembler: %v", err)
+	}
+
+}
+
+const start = 0x8000 // start address of text
+
+// writeInst writes the generated byte sequences to a new file
+// starting at offset start. That file is intended to be the input to
+// the external disassembler.
+func writeInst(generate func(func([]byte))) (file string, f *os.File, size int, err error) {
+	f, err = ioutil.TempFile("", "armasm")
+	if err != nil {
+		return
+	}
+
+	file = f.Name()
+
+	f.Seek(start, 0)
+	w := bufio.NewWriter(f)
+	defer w.Flush()
+	size = 0
+	generate(func(x []byte) {
+		if len(x) > 4 {
+			x = x[:4]
+		}
+		if debug {
+			fmt.Printf("%#x: %x%x\n", start+size, x, zeros[len(x):])
+		}
+		w.Write(x)
+		w.Write(zeros[len(x):])
+		size += len(zeros)
+	})
+	return file, f, size, nil
+}
+
+var zeros = []byte{0, 0, 0, 0}
+
+// pad pads the code sequenc with pops.
+func pad(enc []byte) []byte {
+	if len(enc) < 4 {
+		enc = append(enc[:len(enc):len(enc)], zeros[:4-len(enc)]...)
+	}
+	return enc
+}
+
+// disasm returns the decoded instruction and text
+// for the given source bytes, using the given syntax and mode.
+func disasm(syntax string, mode Mode, src []byte) (inst Inst, text string) {
+	// If printTests is set, we record the coverage value
+	// before and after, and we write out the inputs for which
+	// coverage went up, in the format expected in testdata/decode.text.
+	// This produces a fairly small set of test cases that exercise nearly
+	// all the code.
+	var cover float64
+	if *printTests {
+		cover -= coverage()
+	}
+
+	inst, err := Decode(src, mode)
+	if err != nil {
+		text = "error: " + err.Error()
+	} else {
+		text = inst.String()
+		switch syntax {
+		//case "arm":
+		//	text = ARMSyntax(inst)
+		case "gnu":
+			text = GNUSyntax(inst)
+		//case "plan9":
+		//	text = Plan9Syntax(inst, 0, nil)
+		default:
+			text = "error: unknown syntax " + syntax
+		}
+	}
+
+	if *printTests {
+		cover += coverage()
+		if cover > 0 {
+			max := len(src)
+			if max > 4 && inst.Len <= 4 {
+				max = 4
+			}
+			fmt.Printf("%x|%x\t%d\t%s\t%s\n", src[:inst.Len], src[inst.Len:max], mode, syntax, text)
+		}
+	}
+
+	return
+}
+
+// coverage returns a floating point number denoting the
+// test coverage until now. The number increases when new code paths are exercised,
+// both in the Go program and in the decoder byte code.
+func coverage() float64 {
+	/*
+		testing.Coverage is not in the main distribution.
+		The implementation, which must go in package testing, is:
+
+		// Coverage reports the current code coverage as a fraction in the range [0, 1].
+		func Coverage() float64 {
+			var n, d int64
+			for _, counters := range cover.Counters {
+				for _, c := range counters {
+					if c > 0 {
+						n++
+					}
+					d++
+				}
+			}
+			if d == 0 {
+				return 0
+			}
+			return float64(n) / float64(d)
+		}
+	*/
+
+	var f float64
+	f += testing.Coverage()
+	f += decodeCoverage()
+	return f
+}
+
+func decodeCoverage() float64 {
+	n := 0
+	for _, t := range decoderCover {
+		if t {
+			n++
+		}
+	}
+	return float64(1+n) / float64(1+len(decoderCover))
+}
+
+// Helpers for writing disassembler output parsers.
+
+// hasPrefix reports whether any of the space-separated words in the text s
+// begins with any of the given prefixes.
+func hasPrefix(s string, prefixes ...string) bool {
+	for _, prefix := range prefixes {
+		for s := s; s != ""; {
+			if strings.HasPrefix(s, prefix) {
+				return true
+			}
+			i := strings.Index(s, " ")
+			if i < 0 {
+				break
+			}
+			s = s[i+1:]
+		}
+	}
+	return false
+}
+
+// contains reports whether the text s contains any of the given substrings.
+func contains(s string, substrings ...string) bool {
+	for _, sub := range substrings {
+		if strings.Contains(s, sub) {
+			return true
+		}
+	}
+	return false
+}
+
+// isHex reports whether b is a hexadecimal character (0-9A-Fa-f).
+func isHex(b byte) bool { return b == '0' || unhex[b] > 0 }
+
+// parseHex parses the hexadecimal byte dump in hex,
+// appending the parsed bytes to raw and returning the updated slice.
+// The returned bool signals whether any invalid hex was found.
+// Spaces and tabs between bytes are okay but any other non-hex is not.
+func parseHex(hex []byte, raw []byte) ([]byte, bool) {
+	hex = trimSpace(hex)
+	for j := 0; j < len(hex); {
+		for hex[j] == ' ' || hex[j] == '\t' {
+			j++
+		}
+		if j >= len(hex) {
+			break
+		}
+		if j+2 > len(hex) || !isHex(hex[j]) || !isHex(hex[j+1]) {
+			return nil, false
+		}
+		raw = append(raw, unhex[hex[j]]<<4|unhex[hex[j+1]])
+		j += 2
+	}
+	return raw, true
+}
+
+var unhex = [256]byte{
+	'0': 0,
+	'1': 1,
+	'2': 2,
+	'3': 3,
+	'4': 4,
+	'5': 5,
+	'6': 6,
+	'7': 7,
+	'8': 8,
+	'9': 9,
+	'A': 10,
+	'B': 11,
+	'C': 12,
+	'D': 13,
+	'E': 14,
+	'F': 15,
+	'a': 10,
+	'b': 11,
+	'c': 12,
+	'd': 13,
+	'e': 14,
+	'f': 15,
+}
+
+// index is like bytes.Index(s, []byte(t)) but avoids the allocation.
+func index(s []byte, t string) int {
+	i := 0
+	for {
+		j := bytes.IndexByte(s[i:], t[0])
+		if j < 0 {
+			return -1
+		}
+		i = i + j
+		if i+len(t) > len(s) {
+			return -1
+		}
+		for k := 1; k < len(t); k++ {
+			if s[i+k] != t[k] {
+				goto nomatch
+			}
+		}
+		return i
+	nomatch:
+		i++
+	}
+}
+
+// fixSpace rewrites runs of spaces, tabs, and newline characters into single spaces in s.
+// If s must be rewritten, it is rewritten in place.
+func fixSpace(s []byte) []byte {
+	s = trimSpace(s)
+	for i := 0; i < len(s); i++ {
+		if s[i] == '\t' || s[i] == '\n' || i > 0 && s[i] == ' ' && s[i-1] == ' ' {
+			goto Fix
+		}
+	}
+	return s
+
+Fix:
+	b := s
+	w := 0
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c == '\t' || c == '\n' {
+			c = ' '
+		}
+		if c == ' ' && w > 0 && b[w-1] == ' ' {
+			continue
+		}
+		b[w] = c
+		w++
+	}
+	if w > 0 && b[w-1] == ' ' {
+		w--
+	}
+	return b[:w]
+}
+
+// trimSpace trims leading and trailing space from s, returning a subslice of s.
+func trimSpace(s []byte) []byte {
+	j := len(s)
+	for j > 0 && (s[j-1] == ' ' || s[j-1] == '\t' || s[j-1] == '\n') {
+		j--
+	}
+	i := 0
+	for i < j && (s[i] == ' ' || s[i] == '\t') {
+		i++
+	}
+	return s[i:j]
+}
+
+// pcrel matches instructions using relative addressing mode.
+var (
+	pcrel = regexp.MustCompile(`^((?:.* )?(?:b|bl)x?(?:eq|ne|cs|cc|mi|pl|vs|vc|hi|ls|ge|lt|gt|le)?) 0x([0-9a-f]+)$`)
+)
+
+// Generators.
+//
+// The test cases are described as functions that invoke a callback repeatedly,
+// with a new input sequence each time. These helpers make writing those
+// a little easier.
+
+// condCases generates conditional instructions.
+func condCases(t *testing.T) func(func([]byte)) {
+	return func(try func([]byte)) {
+		// All the strides are relatively prime to 2 and therefore to 2²⁸,
+		// so we will not repeat any instructions until we have tried all 2²⁸.
+		// Using a stride other than 1 is meant to visit the instructions in a
+		// pseudorandom order, which gives better variety in the set of
+		// test cases chosen by -printtests.
+		stride := uint32(10007)
+		n := 1 << 28 / 7
+		if testing.Short() {
+			stride = 100003
+			n = 1 << 28 / 1001
+		} else if *longTest {
+			stride = 200000033
+			n = 1 << 28
+		}
+		x := uint32(0)
+		for i := 0; i < n; i++ {
+			enc := (x%15)<<28 | x&(1<<28-1)
+			try([]byte{byte(enc), byte(enc >> 8), byte(enc >> 16), byte(enc >> 24)})
+			x += stride
+		}
+	}
+}
+
+// uncondCases generates unconditional instructions.
+func uncondCases(t *testing.T) func(func([]byte)) {
+	return func(try func([]byte)) {
+		condCases(t)(func(enc []byte) {
+			enc[3] |= 0xF0
+			try(enc)
+		})
+	}
+}
+
+func countBits(x uint32) int {
+	n := 0
+	for ; x != 0; x >>= 1 {
+		n += int(x & 1)
+	}
+	return n
+}
+
+func expandBits(x, m uint32) uint32 {
+	var out uint32
+	for i := uint(0); i < 32; i++ {
+		out >>= 1
+		if m&1 != 0 {
+			out |= (x & 1) << 31
+			x >>= 1
+		}
+		m >>= 1
+	}
+	return out
+}
+
+func tryCondMask(mask, val uint32, try func([]byte)) {
+	n := countBits(^mask)
+	bits := uint32(0)
+	for i := 0; i < 1<> 8), byte(x >> 16), byte(x >> 24)})
+	}
+}
+
+// vfpCases generates VFP instructions.
+func vfpCases(t *testing.T) func(func([]byte)) {
+	const (
+		vfpmask uint32 = 0xFF00FE10
+		vfp     uint32 = 0x0E009A00
+	)
+	return func(try func([]byte)) {
+		tryCondMask(0xff00fe10, 0x0e009a00, try) // standard VFP instruction space
+		tryCondMask(0xffc00f7f, 0x0e000b10, try) // VFP MOV core reg to/from float64 half
+		tryCondMask(0xffe00f7f, 0x0e000a10, try) // VFP MOV core reg to/from float32
+		tryCondMask(0xffef0fff, 0x0ee10a10, try) // VFP MOV core reg to/from cond codes
+	}
+}
+
+// hexCases generates the cases written in hexadecimal in the encoded string.
+// Spaces in 'encoded' separate entire test cases, not individual bytes.
+func hexCases(t *testing.T, encoded string) func(func([]byte)) {
+	return func(try func([]byte)) {
+		for _, x := range strings.Fields(encoded) {
+			src, err := hex.DecodeString(x)
+			if err != nil {
+				t.Errorf("parsing %q: %v", x, err)
+			}
+			try(src)
+		}
+	}
+}
+
+// testdataCases generates the test cases recorded in testdata/decode.txt.
+// It only uses the inputs; it ignores the answers recorded in that file.
+func testdataCases(t *testing.T) func(func([]byte)) {
+	var codes [][]byte
+	data, err := ioutil.ReadFile("testdata/decode.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		f := strings.Fields(line)[0]
+		i := strings.Index(f, "|")
+		if i < 0 {
+			t.Errorf("parsing %q: missing | separator", f)
+			continue
+		}
+		if i%2 != 0 {
+			t.Errorf("parsing %q: misaligned | separator", f)
+		}
+		code, err := hex.DecodeString(f[:i] + f[i+1:])
+		if err != nil {
+			t.Errorf("parsing %q: %v", f, err)
+			continue
+		}
+		codes = append(codes, code)
+	}
+
+	return func(try func([]byte)) {
+		for _, code := range codes {
+			try(code)
+		}
+	}
+}
+
+func caller(skip int) string {
+	pc, _, _, _ := runtime.Caller(skip)
+	f := runtime.FuncForPC(pc)
+	name := "?"
+	if f != nil {
+		name = f.Name()
+		if i := strings.LastIndex(name, "."); i >= 0 {
+			name = name[i+1:]
+		}
+	}
+	return name
+}
diff --git a/src/cmd/internal/rsc.io/arm/armasm/gnu.go b/src/cmd/internal/rsc.io/arm/armasm/gnu.go
new file mode 100644
index 0000000000..1a97a5a844
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/gnu.go
@@ -0,0 +1,164 @@
+// 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 armasm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+)
+
+var saveDot = strings.NewReplacer(
+	".F16", "_dot_F16",
+	".F32", "_dot_F32",
+	".F64", "_dot_F64",
+	".S32", "_dot_S32",
+	".U32", "_dot_U32",
+	".FXS", "_dot_S",
+	".FXU", "_dot_U",
+	".32", "_dot_32",
+)
+
+// GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils.
+// This form typically matches the syntax defined in the ARM Reference Manual.
+func GNUSyntax(inst Inst) string {
+	var buf bytes.Buffer
+	op := inst.Op.String()
+	op = saveDot.Replace(op)
+	op = strings.Replace(op, ".", "", -1)
+	op = strings.Replace(op, "_dot_", ".", -1)
+	op = strings.ToLower(op)
+	buf.WriteString(op)
+	sep := " "
+	for i, arg := range inst.Args {
+		if arg == nil {
+			break
+		}
+		text := gnuArg(&inst, i, arg)
+		if text == "" {
+			continue
+		}
+		buf.WriteString(sep)
+		sep = ", "
+		buf.WriteString(text)
+	}
+	return buf.String()
+}
+
+func gnuArg(inst *Inst, argIndex int, arg Arg) string {
+	switch inst.Op &^ 15 {
+	case LDRD_EQ, LDREXD_EQ, STRD_EQ:
+		if argIndex == 1 {
+			// second argument in consecutive pair not printed
+			return ""
+		}
+	case STREXD_EQ:
+		if argIndex == 2 {
+			// second argument in consecutive pair not printed
+			return ""
+		}
+	}
+
+	switch arg := arg.(type) {
+	case Imm:
+		switch inst.Op &^ 15 {
+		case BKPT_EQ:
+			return fmt.Sprintf("%#04x", uint32(arg))
+		case SVC_EQ:
+			return fmt.Sprintf("%#08x", uint32(arg))
+		}
+		return fmt.Sprintf("#%d", int32(arg))
+
+	case ImmAlt:
+		return fmt.Sprintf("#%d, %d", arg.Val, arg.Rot)
+
+	case Mem:
+		R := gnuArg(inst, -1, arg.Base)
+		X := ""
+		if arg.Sign != 0 {
+			X = ""
+			if arg.Sign < 0 {
+				X = "-"
+			}
+			X += gnuArg(inst, -1, arg.Index)
+			if arg.Shift == ShiftLeft && arg.Count == 0 {
+				// nothing
+			} else if arg.Shift == RotateRightExt {
+				X += ", rrx"
+			} else {
+				X += fmt.Sprintf(", %s #%d", strings.ToLower(arg.Shift.String()), arg.Count)
+			}
+		} else {
+			X = fmt.Sprintf("#%d", arg.Offset)
+		}
+
+		switch arg.Mode {
+		case AddrOffset:
+			if X == "#0" {
+				return fmt.Sprintf("[%s]", R)
+			}
+			return fmt.Sprintf("[%s, %s]", R, X)
+		case AddrPreIndex:
+			return fmt.Sprintf("[%s, %s]!", R, X)
+		case AddrPostIndex:
+			return fmt.Sprintf("[%s], %s", R, X)
+		case AddrLDM:
+			if X == "#0" {
+				return R
+			}
+		case AddrLDM_WB:
+			if X == "#0" {
+				return R + "!"
+			}
+		}
+		return fmt.Sprintf("[%s Mode(%d) %s]", R, int(arg.Mode), X)
+
+	case PCRel:
+		return fmt.Sprintf(".%+#x", int32(arg)+4)
+
+	case Reg:
+		switch inst.Op &^ 15 {
+		case LDREX_EQ:
+			if argIndex == 0 {
+				return fmt.Sprintf("r%d", int32(arg))
+			}
+		}
+		switch arg {
+		case R10:
+			return "sl"
+		case R11:
+			return "fp"
+		case R12:
+			return "ip"
+		}
+
+	case RegList:
+		var buf bytes.Buffer
+		fmt.Fprintf(&buf, "{")
+		sep := ""
+		for i := 0; i < 16; i++ {
+			if arg&(1<= Op(len(opstr)) || opstr[op] == "" {
+		return fmt.Sprintf("Op(%d)", int(op))
+	}
+	return opstr[op]
+}
+
+// An Inst is a single instruction.
+type Inst struct {
+	Op   Op     // Opcode mnemonic
+	Enc  uint32 // Raw encoding bits.
+	Len  int    // Length of encoding in bytes.
+	Args Args   // Instruction arguments, in ARM manual order.
+}
+
+func (i Inst) String() string {
+	var buf bytes.Buffer
+	buf.WriteString(i.Op.String())
+	for j, arg := range i.Args {
+		if arg == nil {
+			break
+		}
+		if j == 0 {
+			buf.WriteString(" ")
+		} else {
+			buf.WriteString(", ")
+		}
+		buf.WriteString(arg.String())
+	}
+	return buf.String()
+}
+
+// An Args holds the instruction arguments.
+// If an instruction has fewer than 4 arguments,
+// the final elements in the array are nil.
+type Args [4]Arg
+
+// An Arg is a single instruction argument, one of these types:
+// Endian, Imm, Mem, PCRel, Reg, RegList, RegShift, RegShiftReg.
+type Arg interface {
+	IsArg()
+	String() string
+}
+
+type Float32Imm float32
+
+func (Float32Imm) IsArg() {}
+
+func (f Float32Imm) String() string {
+	return fmt.Sprintf("#%v", float32(f))
+}
+
+type Float64Imm float32
+
+func (Float64Imm) IsArg() {}
+
+func (f Float64Imm) String() string {
+	return fmt.Sprintf("#%v", float64(f))
+}
+
+// An Imm is an integer constant.
+type Imm uint32
+
+func (Imm) IsArg() {}
+
+func (i Imm) String() string {
+	return fmt.Sprintf("#%#x", uint32(i))
+}
+
+// A ImmAlt is an alternate encoding of an integer constant.
+type ImmAlt struct {
+	Val uint8
+	Rot uint8
+}
+
+func (ImmAlt) IsArg() {}
+
+func (i ImmAlt) Imm() Imm {
+	v := uint32(i.Val)
+	r := uint(i.Rot)
+	return Imm(v>>r | v<<(32-r))
+}
+
+func (i ImmAlt) String() string {
+	return fmt.Sprintf("#%#x, %d", i.Val, i.Rot)
+}
+
+// A Label is a text (code) address.
+type Label uint32
+
+func (Label) IsArg() {}
+
+func (i Label) String() string {
+	return fmt.Sprintf("%#x", uint32(i))
+}
+
+// A Reg is a single register.
+// The zero value denotes R0, not the absence of a register.
+type Reg uint8
+
+const (
+	R0 Reg = iota
+	R1
+	R2
+	R3
+	R4
+	R5
+	R6
+	R7
+	R8
+	R9
+	R10
+	R11
+	R12
+	R13
+	R14
+	R15
+
+	S0
+	S1
+	S2
+	S3
+	S4
+	S5
+	S6
+	S7
+	S8
+	S9
+	S10
+	S11
+	S12
+	S13
+	S14
+	S15
+	S16
+	S17
+	S18
+	S19
+	S20
+	S21
+	S22
+	S23
+	S24
+	S25
+	S26
+	S27
+	S28
+	S29
+	S30
+	S31
+
+	D0
+	D1
+	D2
+	D3
+	D4
+	D5
+	D6
+	D7
+	D8
+	D9
+	D10
+	D11
+	D12
+	D13
+	D14
+	D15
+	D16
+	D17
+	D18
+	D19
+	D20
+	D21
+	D22
+	D23
+	D24
+	D25
+	D26
+	D27
+	D28
+	D29
+	D30
+	D31
+
+	APSR
+	APSR_nzcv
+	FPSCR
+
+	SP = R13
+	LR = R14
+	PC = R15
+)
+
+func (Reg) IsArg() {}
+
+func (r Reg) String() string {
+	switch r {
+	case APSR:
+		return "APSR"
+	case APSR_nzcv:
+		return "APSR_nzcv"
+	case FPSCR:
+		return "FPSCR"
+	case SP:
+		return "SP"
+	case PC:
+		return "PC"
+	case LR:
+		return "LR"
+	}
+	if R0 <= r && r <= R15 {
+		return fmt.Sprintf("R%d", int(r-R0))
+	}
+	if S0 <= r && r <= S31 {
+		return fmt.Sprintf("S%d", int(r-S0))
+	}
+	if D0 <= r && r <= D31 {
+		return fmt.Sprintf("D%d", int(r-D0))
+	}
+	return fmt.Sprintf("Reg(%d)", int(r))
+}
+
+// A RegX represents a fraction of a multi-value register.
+// The Index field specifies the index number,
+// but the size of the fraction is not specified.
+// It must be inferred from the instruction and the register type.
+// For example, in a VMOV instruction, RegX{D5, 1} represents
+// the top 32 bits of the 64-bit D5 register.
+type RegX struct {
+	Reg   Reg
+	Index int
+}
+
+func (RegX) IsArg() {}
+
+func (r RegX) String() string {
+	return fmt.Sprintf("%s[%d]", r.Reg, r.Index)
+}
+
+// A RegList is a register list.
+// Bits at indexes x = 0 through 15 indicate whether the corresponding Rx register is in the list.
+type RegList uint16
+
+func (RegList) IsArg() {}
+
+func (r RegList) String() string {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "{")
+	sep := ""
+	for i := 0; i < 16; i++ {
+		if r&(1<= 4 {
+		raw := binary.LittleEndian.Uint32(dec.enc[:4])
+
+		// word 21FFF0B5.
+		// the manual is clear that this is pre-indexed mode (with !) but libopcodes generates post-index (without !).
+		if raw&0x01200000 == 0x01200000 && strings.Replace(text, "!", "", -1) == dec.text {
+			return true
+		}
+
+		// word C100543E: libopcodes says tst, but no evidence for that.
+		if strings.HasPrefix(dec.text, "tst") && raw&0x0ff00000 != 0x03100000 && raw&0x0ff00000 != 0x01100000 {
+			return true
+		}
+
+		// word C3203CE8: libopcodes says teq, but no evidence for that.
+		if strings.HasPrefix(dec.text, "teq") && raw&0x0ff00000 != 0x03300000 && raw&0x0ff00000 != 0x01300000 {
+			return true
+		}
+
+		// word D14C552E: libopcodes says cmp but no evidence for that.
+		if strings.HasPrefix(dec.text, "cmp") && raw&0x0ff00000 != 0x03500000 && raw&0x0ff00000 != 0x01500000 {
+			return true
+		}
+
+		// word 2166AA4A: libopcodes says cmn but no evidence for that.
+		if strings.HasPrefix(dec.text, "cmn") && raw&0x0ff00000 != 0x03700000 && raw&0x0ff00000 != 0x01700000 {
+			return true
+		}
+
+		// word E70AEEEF: libopcodes says str but no evidence for that.
+		if strings.HasPrefix(dec.text, "str") && len(dec.text) >= 5 && (dec.text[3] == ' ' || dec.text[5] == ' ') && raw&0x0e500018 != 0x06000000 && raw&0x0e500000 != 0x0400000 {
+			return true
+		}
+
+		// word B0AF48F4: libopcodes says strd but P=0,W=1 which is unpredictable.
+		if hasPrefix(dec.text, "ldr", "str") && raw&0x01200000 == 0x00200000 {
+			return true
+		}
+
+		// word B6CC1C76: libopcodes inexplicably says 'uxtab16lt r1, ip, r6, ROR #24' instead of 'uxtab16lt r1, ip, r6, ror #24'
+		if strings.ToLower(dec.text) == text {
+			return true
+		}
+
+		// word F410FDA1: libopcodes says PLDW but the manual is clear that PLDW is F5/F7, not F4.
+		// word F7D0FB17: libopcodes says PLDW but the manual is clear that PLDW has 0x10 clear
+		if hasPrefix(dec.text, "pld") && raw&0xfd000010 != 0xf5000000 {
+			return true
+		}
+
+		// word F650FE14: libopcodes says PLI but the manual is clear that PLI has 0x10 clear
+		if hasPrefix(dec.text, "pli") && raw&0xff000010 != 0xf6000000 {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Instructions known to libopcodes (or xed) but not to us.
+// Most of these are floating point coprocessor instructions.
+var unsupported = strings.Fields(`
+	abs
+	acs
+	adf
+	aes
+	asn
+	atn
+	cdp
+	cf
+	cmf
+	cnf
+	cos
+	cps
+	crc32
+	dvf
+	eret
+	exp
+	fadd
+	fcmp
+	fcpy
+	fcvt
+	fdiv
+	fdv
+	fix
+	fld
+	flt
+	fmac
+	fmd
+	fml
+	fmr
+	fms
+	fmul
+	fmx
+	fneg
+	fnm
+	frd
+	fsit
+	fsq
+	fst
+	fsu
+	fto
+	fui
+	hlt
+	hvc
+	lda
+	ldc
+	ldf
+	lfm
+	lgn
+	log
+	mar
+	mcr
+	mcrr
+	mia
+	mnf
+	mra
+	mrc
+	mrrc
+	mrs
+	msr
+	msr
+	muf
+	mvf
+	nrm
+	pol
+	pow
+	rdf
+	rfc
+	rfe
+	rfs
+	rmf
+	rnd
+	rpw
+	rsf
+	sdiv
+	sev
+	sfm
+	sha1
+	sha256
+	sin
+	smc
+	sqt
+	srs
+	stc
+	stf
+	stl
+	suf
+	tan
+	udf
+	udiv
+	urd
+	vfma
+	vfms
+	vfnma
+	vfnms
+	vrint
+	wfc
+	wfs
+`)
diff --git a/src/cmd/internal/rsc.io/arm/armasm/objdumpext_test.go b/src/cmd/internal/rsc.io/arm/armasm/objdumpext_test.go
new file mode 100644
index 0000000000..d88c67fc05
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/objdumpext_test.go
@@ -0,0 +1,260 @@
+// 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.
+
+// Copied and simplified from rsc.io/x86/x86asm/objdumpext_test.go.
+
+package armasm
+
+import (
+	"bytes"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const objdumpPath = "/usr/local/bin/arm-linux-elf-objdump"
+
+func testObjdumpARM(t *testing.T, generate func(func([]byte))) {
+	testObjdumpArch(t, generate, ModeARM)
+}
+
+func testObjdumpArch(t *testing.T, generate func(func([]byte)), arch Mode) {
+	if testing.Short() {
+		t.Skip("skipping objdump test in short mode")
+	}
+
+	if _, err := os.Stat(objdumpPath); err != nil {
+		t.Fatal(err)
+	}
+
+	testExtDis(t, "gnu", arch, objdump, generate, allowedMismatchObjdump)
+}
+
+func objdump(ext *ExtDis) error {
+	// File already written with instructions; add ELF header.
+	if ext.Arch == ModeARM {
+		if err := writeELF32(ext.File, ext.Size); err != nil {
+			return err
+		}
+	} else {
+		panic("unknown arch")
+	}
+
+	b, err := ext.Run(objdumpPath, "-d", "-z", ext.File.Name())
+	if err != nil {
+		return err
+	}
+
+	var (
+		nmatch  int
+		reading bool
+		next    uint32 = start
+		addr    uint32
+		encbuf  [4]byte
+		enc     []byte
+		text    string
+	)
+	flush := func() {
+		if addr == next {
+			if m := pcrel.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				text = fmt.Sprintf("%s .%+#x", m[1], int32(uint32(targ)-addr-uint32(len(enc))))
+			}
+			if strings.HasPrefix(text, "stmia") {
+				text = "stm" + text[5:]
+			}
+			if strings.HasPrefix(text, "stmfd") {
+				text = "stmdb" + text[5:]
+			}
+			if strings.HasPrefix(text, "ldmfd") {
+				text = "ldm" + text[5:]
+			}
+			text = strings.Replace(text, "#0.0", "#0", -1)
+			if text == "undefined" && len(enc) == 4 {
+				text = "error: unknown instruction"
+				enc = nil
+			}
+			if len(enc) == 4 {
+				// prints as word but we want to record bytes
+				enc[0], enc[3] = enc[3], enc[0]
+				enc[1], enc[2] = enc[2], enc[1]
+			}
+			ext.Dec <- ExtInst{addr, encbuf, len(enc), text}
+			encbuf = [4]byte{}
+			enc = nil
+			next += 4
+		}
+	}
+	var textangle = []byte("<.text>:")
+	for {
+		line, err := b.ReadSlice('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return fmt.Errorf("reading objdump output: %v", err)
+		}
+		if bytes.Contains(line, textangle) {
+			reading = true
+			continue
+		}
+		if !reading {
+			continue
+		}
+		if debug {
+			os.Stdout.Write(line)
+		}
+		if enc1 := parseContinuation(line, encbuf[:len(enc)]); enc1 != nil {
+			enc = enc1
+			continue
+		}
+		flush()
+		nmatch++
+		addr, enc, text = parseLine(line, encbuf[:0])
+		if addr > next {
+			return fmt.Errorf("address out of sync expected <= %#x at %q in:\n%s", next, line, line)
+		}
+	}
+	flush()
+	if next != start+uint32(ext.Size) {
+		return fmt.Errorf("not enough results found [%d %d]", next, start+ext.Size)
+	}
+	if err := ext.Wait(); err != nil {
+		return fmt.Errorf("exec: %v", err)
+	}
+
+	return nil
+}
+
+var (
+	undefined      = []byte("")
+	unpredictable  = []byte("")
+	illegalShifter = []byte("")
+)
+
+func parseLine(line []byte, encstart []byte) (addr uint32, enc []byte, text string) {
+	oline := line
+	i := index(line, ":\t")
+	if i < 0 {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	x, err := strconv.ParseUint(string(trimSpace(line[:i])), 16, 32)
+	if err != nil {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	addr = uint32(x)
+	line = line[i+2:]
+	i = bytes.IndexByte(line, '\t')
+	if i < 0 {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	enc, ok := parseHex(line[:i], encstart)
+	if !ok {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	line = trimSpace(line[i:])
+	if bytes.Contains(line, undefined) {
+		text = "undefined"
+		return
+	}
+	if bytes.Contains(line, illegalShifter) {
+		text = "undefined"
+		return
+	}
+	if false && bytes.Contains(line, unpredictable) {
+		text = "unpredictable"
+		return
+	}
+	if i := bytes.IndexByte(line, ';'); i >= 0 {
+		line = trimSpace(line[:i])
+	}
+	text = string(fixSpace(line))
+	return
+}
+
+func parseContinuation(line []byte, enc []byte) []byte {
+	i := index(line, ":\t")
+	if i < 0 {
+		return nil
+	}
+	line = line[i+1:]
+	enc, _ = parseHex(line, enc)
+	return enc
+}
+
+// writeELF32 writes an ELF32 header to the file,
+// describing a text segment that starts at start
+// and extends for size bytes.
+func writeELF32(f *os.File, size int) error {
+	f.Seek(0, 0)
+	var hdr elf.Header32
+	var prog elf.Prog32
+	var sect elf.Section32
+	var buf bytes.Buffer
+	binary.Write(&buf, binary.LittleEndian, &hdr)
+	off1 := buf.Len()
+	binary.Write(&buf, binary.LittleEndian, &prog)
+	off2 := buf.Len()
+	binary.Write(&buf, binary.LittleEndian, §)
+	off3 := buf.Len()
+	buf.Reset()
+	data := byte(elf.ELFDATA2LSB)
+	hdr = elf.Header32{
+		Ident:     [16]byte{0x7F, 'E', 'L', 'F', 1, data, 1},
+		Type:      2,
+		Machine:   uint16(elf.EM_ARM),
+		Version:   1,
+		Entry:     start,
+		Phoff:     uint32(off1),
+		Shoff:     uint32(off2),
+		Flags:     0x05000002,
+		Ehsize:    uint16(off1),
+		Phentsize: uint16(off2 - off1),
+		Phnum:     1,
+		Shentsize: uint16(off3 - off2),
+		Shnum:     3,
+		Shstrndx:  2,
+	}
+	binary.Write(&buf, binary.LittleEndian, &hdr)
+	prog = elf.Prog32{
+		Type:   1,
+		Off:    start,
+		Vaddr:  start,
+		Paddr:  start,
+		Filesz: uint32(size),
+		Memsz:  uint32(size),
+		Flags:  5,
+		Align:  start,
+	}
+	binary.Write(&buf, binary.LittleEndian, &prog)
+	binary.Write(&buf, binary.LittleEndian, §) // NULL section
+	sect = elf.Section32{
+		Name:      1,
+		Type:      uint32(elf.SHT_PROGBITS),
+		Addr:      start,
+		Off:       start,
+		Size:      uint32(size),
+		Flags:     uint32(elf.SHF_ALLOC | elf.SHF_EXECINSTR),
+		Addralign: 4,
+	}
+	binary.Write(&buf, binary.LittleEndian, §) // .text
+	sect = elf.Section32{
+		Name:      uint32(len("\x00.text\x00")),
+		Type:      uint32(elf.SHT_STRTAB),
+		Addr:      0,
+		Off:       uint32(off2 + (off3-off2)*3),
+		Size:      uint32(len("\x00.text\x00.shstrtab\x00")),
+		Addralign: 1,
+	}
+	binary.Write(&buf, binary.LittleEndian, §)
+	buf.WriteString("\x00.text\x00.shstrtab\x00")
+	f.Write(buf.Bytes())
+	return nil
+}
diff --git a/src/cmd/internal/rsc.io/arm/armasm/plan9x.go b/src/cmd/internal/rsc.io/arm/armasm/plan9x.go
new file mode 100644
index 0000000000..952c5190b6
--- /dev/null
+++ b/src/cmd/internal/rsc.io/arm/armasm/plan9x.go
@@ -0,0 +1,211 @@
+// 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 armasm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// Plan9Syntax returns the Go assembler syntax for the instruction.
+// The syntax was originally defined by Plan 9.
+// The pc is the program counter of the instruction, used for expanding
+// PC-relative addresses into absolute ones.
+// The symname function queries the symbol table for the program
+// being disassembled. Given a target address it returns the name and base
+// address of the symbol containing the target, if any; otherwise it returns "", 0.
+// The reader r should read from the text segment using text addresses
+// as offsets; it is used to display pc-relative loads as constant loads.
+func Plan9Syntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text io.ReaderAt) string {
+	if symname == nil {
+		symname = func(uint64) (string, uint64) { return "", 0 }
+	}
+
+	var args []string
+	for _, a := range inst.Args {
+		if a == nil {
+			break
+		}
+		args = append(args, plan9Arg(&inst, pc, symname, a))
+	}
+
+	op := inst.Op.String()
+
+	switch inst.Op &^ 15 {
+	case LDR_EQ, LDRB_EQ, LDRH_EQ:
+		// Check for RET
+		reg, _ := inst.Args[0].(Reg)
+		mem, _ := inst.Args[1].(Mem)
+		if inst.Op&^15 == LDR_EQ && reg == R15 && mem.Base == SP && mem.Sign == 0 && mem.Mode == AddrPostIndex {
+			return fmt.Sprintf("RET%s #%d", op[3:], mem.Offset)
+		}
+
+		// Check for PC-relative load.
+		if mem.Base == PC && mem.Sign == 0 && mem.Mode == AddrOffset && text != nil {
+			addr := uint32(pc) + 8 + uint32(mem.Offset)
+			buf := make([]byte, 4)
+			switch inst.Op &^ 15 {
+			case LDRB_EQ:
+				if _, err := text.ReadAt(buf[:1], int64(addr)); err != nil {
+					break
+				}
+				args[1] = fmt.Sprintf("$%#x", buf[0])
+
+			case LDRH_EQ:
+				if _, err := text.ReadAt(buf[:2], int64(addr)); err != nil {
+					break
+				}
+				args[1] = fmt.Sprintf("$%#x", binary.LittleEndian.Uint16(buf))
+
+			case LDR_EQ:
+				if _, err := text.ReadAt(buf, int64(addr)); err != nil {
+					break
+				}
+				x := binary.LittleEndian.Uint32(buf)
+				if s, base := symname(uint64(x)); s != "" && uint64(x) == base {
+					args[1] = fmt.Sprintf("$%s(SB)", s)
+				} else {
+					args[1] = fmt.Sprintf("$%#x", x)
+				}
+			}
+		}
+	}
+
+	// Move addressing mode into opcode suffix.
+	suffix := ""
+	switch inst.Op &^ 15 {
+	case LDR_EQ, LDRB_EQ, LDRH_EQ, STR_EQ, STRB_EQ, STRH_EQ:
+		mem, _ := inst.Args[1].(Mem)
+		switch mem.Mode {
+		case AddrOffset, AddrLDM:
+			// no suffix
+		case AddrPreIndex, AddrLDM_WB:
+			suffix = ".W"
+		case AddrPostIndex:
+			suffix = ".P"
+		}
+		off := ""
+		if mem.Offset != 0 {
+			off = fmt.Sprintf("%#x", mem.Offset)
+		}
+		base := fmt.Sprintf("(R%d)", int(mem.Base))
+		index := ""
+		if mem.Sign != 0 {
+			sign := ""
+			if mem.Sign < 0 {
+				sign = ""
+			}
+			shift := ""
+			if mem.Count != 0 {
+				shift = fmt.Sprintf("%s%d", plan9Shift[mem.Shift], mem.Count)
+			}
+			index = fmt.Sprintf("(%sR%d%s)", sign, int(mem.Index), shift)
+		}
+		args[1] = off + base + index
+	}
+
+	// Reverse args, placing dest last.
+	for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 {
+		args[i], args[j] = args[j], args[i]
+	}
+
+	switch inst.Op &^ 15 {
+	case MOV_EQ:
+		op = "MOVW" + op[3:]
+
+	case LDR_EQ:
+		op = "MOVW" + op[3:] + suffix
+	case LDRB_EQ:
+		op = "MOVB" + op[4:] + suffix
+	case LDRH_EQ:
+		op = "MOVH" + op[4:] + suffix
+
+	case STR_EQ:
+		op = "MOVW" + op[3:] + suffix
+		args[0], args[1] = args[1], args[0]
+	case STRB_EQ:
+		op = "MOVB" + op[4:] + suffix
+		args[0], args[1] = args[1], args[0]
+	case STRH_EQ:
+		op = "MOVH" + op[4:] + suffix
+		args[0], args[1] = args[1], args[0]
+	}
+
+	if args != nil {
+		op += " " + strings.Join(args, ", ")
+	}
+
+	return op
+}
+
+// assembler syntax for the various shifts.
+// @x> is a lie; the assembler uses @> 0
+// instead of @x> 1, but i wanted to be clear that it
+// was a different operation (rotate right extended, not rotate right).
+var plan9Shift = []string{"<<", ">>", "->", "@>", "@x>"}
+
+func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg Arg) string {
+	switch a := arg.(type) {
+	case Endian:
+
+	case Imm:
+		return fmt.Sprintf("$%d", int(a))
+
+	case Mem:
+
+	case PCRel:
+		addr := uint32(pc) + 8 + uint32(a)
+		if s, base := symname(uint64(addr)); s != "" && uint64(addr) == base {
+			return fmt.Sprintf("%s(SB)", s)
+		}
+		return fmt.Sprintf("%#x", addr)
+
+	case Reg:
+		if a < 16 {
+			return fmt.Sprintf("R%d", int(a))
+		}
+
+	case RegList:
+		var buf bytes.Buffer
+		start := -2
+		end := -2
+		fmt.Fprintf(&buf, "[")
+		flush := func() {
+			if start >= 0 {
+				if buf.Len() > 1 {
+					fmt.Fprintf(&buf, ",")
+				}
+				if start == end {
+					fmt.Fprintf(&buf, "R%d", start)
+				} else {
+					fmt.Fprintf(&buf, "R%d-R%d", start, end)
+				}
+			}
+		}
+		for i := 0; i < 16; i++ {
+			if a&(1< ,,# cond:4|0|0|1|0|1|0|1|S|Rn:4|Rd:4|imm12:12
+	{0x0fe00090, 0x00a00010, 4, ADC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_R}},                  // ADC{S} ,,,  cond:4|0|0|0|0|1|0|1|S|Rn:4|Rd:4|Rs:4|0|type:2|1|Rm:4
+	{0x0fe00010, 0x00a00000, 2, ADC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_imm}},                // ADC{S} ,,{,} cond:4|0|0|0|0|1|0|1|S|Rn:4|Rd:4|imm5:5|type:2|0|Rm:4
+	{0x0fe00000, 0x02800000, 2, ADD_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_const}},                      // ADD{S} ,,# cond:4|0|0|1|0|1|0|0|S|Rn:4|Rd:4|imm12:12
+	{0x0fe00090, 0x00800010, 4, ADD_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_R}},                  // ADD{S} ,,,  cond:4|0|0|0|0|1|0|0|S|Rn:4|Rd:4|Rs:4|0|type:2|1|Rm:4
+	{0x0fe00010, 0x00800000, 2, ADD_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_imm}},                // ADD{S} ,,{,} cond:4|0|0|0|0|1|0|0|S|Rn:4|Rd:4|imm5:5|type:2|0|Rm:4
+	{0x0fef0000, 0x028d0000, 2, ADD_EQ, 0x14011c04, instArgs{arg_R_12, arg_SP, arg_const}},                        // ADD{S} ,SP,# cond:4|0|0|1|0|1|0|0|S|1|1|0|1|Rd:4|imm12:12
+	{0x0fef0010, 0x008d0000, 2, ADD_EQ, 0x14011c04, instArgs{arg_R_12, arg_SP, arg_R_shift_imm}},                  // ADD{S} ,SP,{,} cond:4|0|0|0|0|1|0|0|S|1|1|0|1|Rd:4|imm5:5|type:2|0|Rm:4
+	{0x0fe00000, 0x02000000, 2, AND_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_const}},                      // AND{S} ,,# cond:4|0|0|1|0|0|0|0|S|Rn:4|Rd:4|imm12:12
+	{0x0fe00090, 0x00000010, 4, AND_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_R}},                  // AND{S} ,,,  cond:4|0|0|0|0|0|0|0|S|Rn:4|Rd:4|Rs:4|0|type:2|1|Rm:4
+	{0x0fe00010, 0x00000000, 2, AND_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_imm}},                // AND{S} ,,{,} cond:4|0|0|0|0|0|0|0|S|Rn:4|Rd:4|imm5:5|type:2|0|Rm:4
+	{0x0fef0070, 0x01a00040, 4, ASR_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_0, arg_imm5_32}},                     // ASR{S} ,,# cond:4|0|0|0|1|1|0|1|S|0|0|0|0|Rd:4|imm5:5|1|0|0|Rm:4
+	{0x0fef00f0, 0x01a00050, 4, ASR_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_0, arg_R_8}},                         // ASR{S} ,, cond:4|0|0|0|1|1|0|1|S|0|0|0|0|Rd:4|Rm:4|0|1|0|1|Rn:4
+	{0x0f000000, 0x0a000000, 4, B_EQ, 0x1c04, instArgs{arg_label24}},                                              // B  cond:4|1|0|1|0|imm24:24
+	{0x0fe0007f, 0x07c0001f, 4, BFC_EQ, 0x1c04, instArgs{arg_R_12, arg_imm5, arg_lsb_width}},                      // BFC ,#,# cond:4|0|1|1|1|1|1|0|msb:5|Rd:4|lsb:5|0|0|1|1|1|1|1
+	{0x0fe00070, 0x07c00010, 2, BFI_EQ, 0x1c04, instArgs{arg_R_12, arg_R_0, arg_imm5, arg_lsb_width}},             // BFI ,,#,# cond:4|0|1|1|1|1|1|0|msb:5|Rd:4|lsb:5|0|0|1|Rn:4
+	{0x0fe00000, 0x03c00000, 2, BIC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_const}},                      // BIC{S} ,,# cond:4|0|0|1|1|1|1|0|S|Rn:4|Rd:4|imm12:12
+	{0x0fe00090, 0x01c00010, 4, BIC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_R}},                  // BIC{S} ,,,  cond:4|0|0|0|1|1|1|0|S|Rn:4|Rd:4|Rs:4|0|type:2|1|Rm:4
+	{0x0fe00010, 0x01c00000, 2, BIC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_imm}},                // BIC{S} ,,{,} cond:4|0|0|0|1|1|1|0|S|Rn:4|Rd:4|imm5:5|type:2|0|Rm:4
+	{0x0ff000f0, 0x01200070, 4, BKPT_EQ, 0x1c04, instArgs{arg_imm_12at8_4at0}},                                    // BKPT # cond:4|0|0|0|1|0|0|1|0|imm12:12|0|1|1|1|imm4:4
+	{0x0f000000, 0x0b000000, 4, BL_EQ, 0x1c04, instArgs{arg_label24}},                                             // BL  cond:4|1|0|1|1|imm24:24
+	{0xfe000000, 0xfa000000, 4, BLX, 0x0, instArgs{arg_label24H}},                                                 // BLX  1|1|1|1|1|0|1|H|imm24:24
+	{0x0ffffff0, 0x012fff30, 4, BLX_EQ, 0x1c04, instArgs{arg_R_0}},                                                // BLX  cond:4|0|0|0|1|0|0|1|0|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|0|0|1|1|Rm:4
+	{0x0ff000f0, 0x012fff30, 3, BLX_EQ, 0x1c04, instArgs{arg_R_0}},                                                // BLX  cond:4|0|0|0|1|0|0|1|0|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|0|0|1|1|Rm:4
+	{0x0ffffff0, 0x012fff10, 4, BX_EQ, 0x1c04, instArgs{arg_R_0}},                                                 // BX  cond:4|0|0|0|1|0|0|1|0|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|0|0|0|1|Rm:4
+	{0x0ff000f0, 0x012fff10, 3, BX_EQ, 0x1c04, instArgs{arg_R_0}},                                                 // BX  cond:4|0|0|0|1|0|0|1|0|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|0|0|0|1|Rm:4
+	{0x0ffffff0, 0x012fff20, 4, BXJ_EQ, 0x1c04, instArgs{arg_R_0}},                                                // BXJ  cond:4|0|0|0|1|0|0|1|0|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|0|0|1|0|Rm:4
+	{0x0ff000f0, 0x012fff20, 3, BXJ_EQ, 0x1c04, instArgs{arg_R_0}},                                                // BXJ  cond:4|0|0|0|1|0|0|1|0|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|0|0|1|0|Rm:4
+	{0xffffffff, 0xf57ff01f, 4, CLREX, 0x0, instArgs{}},                                                           // CLREX 1|1|1|1|0|1|0|1|0|1|1|1|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(0)|(0)|(0)|(0)|0|0|0|1|(1)|(1)|(1)|(1)
+	{0xfff000f0, 0xf57ff01f, 3, CLREX, 0x0, instArgs{}},                                                           // CLREX 1|1|1|1|0|1|0|1|0|1|1|1|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(1)|(0)|(0)|(0)|(0)|0|0|0|1|(1)|(1)|(1)|(1)
+	{0x0fff0ff0, 0x016f0f10, 4, CLZ_EQ, 0x1c04, instArgs{arg_R_12, arg_R_0}},                                      // CLZ , cond:4|0|0|0|1|0|1|1|0|(1)|(1)|(1)|(1)|Rd:4|(1)|(1)|(1)|(1)|0|0|0|1|Rm:4
+	{0x0ff000f0, 0x016f0f10, 3, CLZ_EQ, 0x1c04, instArgs{arg_R_12, arg_R_0}},                                      // CLZ , cond:4|0|0|0|1|0|1|1|0|(1)|(1)|(1)|(1)|Rd:4|(1)|(1)|(1)|(1)|0|0|0|1|Rm:4
+	{0x0ff0f000, 0x03700000, 4, CMN_EQ, 0x1c04, instArgs{arg_R_16, arg_const}},                                    // CMN ,# cond:4|0|0|1|1|0|1|1|1|Rn:4|(0)|(0)|(0)|(0)|imm12:12
+	{0x0ff00000, 0x03700000, 3, CMN_EQ, 0x1c04, instArgs{arg_R_16, arg_const}},                                    // CMN ,# cond:4|0|0|1|1|0|1|1|1|Rn:4|(0)|(0)|(0)|(0)|imm12:12
+	{0x0ff0f090, 0x01700010, 4, CMN_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_R}},                                // CMN ,,  cond:4|0|0|0|1|0|1|1|1|Rn:4|(0)|(0)|(0)|(0)|Rs:4|0|type:2|1|Rm:4
+	{0x0ff00090, 0x01700010, 3, CMN_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_R}},                                // CMN ,,  cond:4|0|0|0|1|0|1|1|1|Rn:4|(0)|(0)|(0)|(0)|Rs:4|0|type:2|1|Rm:4
+	{0x0ff0f010, 0x01700000, 4, CMN_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_imm}},                              // CMN ,{,} cond:4|0|0|0|1|0|1|1|1|Rn:4|(0)|(0)|(0)|(0)|imm5:5|type:2|0|Rm:4
+	{0x0ff00010, 0x01700000, 3, CMN_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_imm}},                              // CMN ,{,} cond:4|0|0|0|1|0|1|1|1|Rn:4|(0)|(0)|(0)|(0)|imm5:5|type:2|0|Rm:4
+	{0x0ff0f000, 0x03500000, 4, CMP_EQ, 0x1c04, instArgs{arg_R_16, arg_const}},                                    // CMP ,# cond:4|0|0|1|1|0|1|0|1|Rn:4|(0)|(0)|(0)|(0)|imm12:12
+	{0x0ff00000, 0x03500000, 3, CMP_EQ, 0x1c04, instArgs{arg_R_16, arg_const}},                                    // CMP ,# cond:4|0|0|1|1|0|1|0|1|Rn:4|(0)|(0)|(0)|(0)|imm12:12
+	{0x0ff0f090, 0x01500010, 4, CMP_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_R}},                                // CMP ,,  cond:4|0|0|0|1|0|1|0|1|Rn:4|(0)|(0)|(0)|(0)|Rs:4|0|type:2|1|Rm:4
+	{0x0ff00090, 0x01500010, 3, CMP_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_R}},                                // CMP ,,  cond:4|0|0|0|1|0|1|0|1|Rn:4|(0)|(0)|(0)|(0)|Rs:4|0|type:2|1|Rm:4
+	{0x0ff0f010, 0x01500000, 4, CMP_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_imm}},                              // CMP ,{,} cond:4|0|0|0|1|0|1|0|1|Rn:4|(0)|(0)|(0)|(0)|imm5:5|type:2|0|Rm:4
+	{0x0ff00010, 0x01500000, 3, CMP_EQ, 0x1c04, instArgs{arg_R_16, arg_R_shift_imm}},                              // CMP ,{,} cond:4|0|0|0|1|0|1|0|1|Rn:4|(0)|(0)|(0)|(0)|imm5:5|type:2|0|Rm:4
+	{0x0ffffff0, 0x0320f0f0, 4, DBG_EQ, 0x1c04, instArgs{arg_option}},                                             // DBG #