From f098a29630c48543df6c476cfa574ab013cfaaa6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 6 Aug 2014 16:22:52 -0400
Subject: [PATCH 001/423] runtime: use better hash for non-empty interface

The implementation 'return 0' results in too many collisions.

LGTM=khr
R=golang-codereviews, adonovan, khr
CC=golang-codereviews, iant, khr, r
https://golang.org/cl/125720044
---
 src/pkg/runtime/alg.go    | 17 ++++++++++++++++-
 src/pkg/runtime/iface.goc | 38 --------------------------------------
 src/pkg/runtime/runtime.h | 28 +++++++++++++---------------
 3 files changed, 29 insertions(+), 54 deletions(-)

diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index 000d4a18b7..e2917dabb6 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -111,7 +111,22 @@ func nohash(a unsafe.Pointer, s uintptr, h uintptr) uintptr {
 func interhash(a *interface {
 	f()
 }, s uintptr, h uintptr) uintptr {
-	return 0
+	tab := (*iface)(unsafe.Pointer(a)).tab
+	if tab == nil {
+		return h
+	}
+	t := tab._type
+	fn := goalg(t.alg).hash
+	if **(**uintptr)(unsafe.Pointer(&fn)) == nohashcode {
+		// calling nohash will panic too,
+		// but we can print a better error.
+		panic(errorString("hash of unhashable type " + *t._string))
+	}
+	if uintptr(t.size) <= ptrSize {
+		return c1 * fn(unsafe.Pointer(&(*eface)(unsafe.Pointer(a)).data), uintptr(t.size), h^c0)
+	} else {
+		return c1 * fn((*eface)(unsafe.Pointer(a)).data, uintptr(t.size), h^c0)
+	}
 }
 
 func nilinterhash(a *interface{}, s uintptr, h uintptr) uintptr {
diff --git a/src/pkg/runtime/iface.goc b/src/pkg/runtime/iface.goc
index ec89746470..89c116e127 100644
--- a/src/pkg/runtime/iface.goc
+++ b/src/pkg/runtime/iface.goc
@@ -475,44 +475,6 @@ func assertE2E2(inter *InterfaceType, e Eface) (ret Eface, ok bool) {
 	ok = e.type != nil;
 }
 
-static uintptr
-ifacehash1(void *data, Type *t, uintptr h)
-{
-	Alg *alg;
-	uintptr size;
-	Eface err;
-
-	if(t == nil)
-		return 0;
-
-	alg = t->alg;
-	size = t->size;
-	if(alg->hash->fn == (void(*)())runtime·nohash) {
-		// calling nohash will panic too,
-		// but we can print a better error.
-		runtime·newErrorString(runtime·catstring(runtime·gostringnocopy((byte*)"hash of unhashable type "), *t->string), &err);
-		runtime·panic(err);
-	}
-	if(size <= sizeof(data))
-		return ((uintptr(*)(void**,uintptr,uintptr))alg->hash)(&data, size, h);
-	else
-		return ((uintptr(*)(void*,uintptr,uintptr))alg->hash)(data, size, h);
-}
-
-uintptr
-runtime·ifacehash(Iface a, uintptr h)
-{
-	if(a.tab == nil)
-		return h;
-	return ifacehash1(a.data, a.tab->type, h);
-}
-
-uintptr
-runtime·efacehash(Eface a, uintptr h)
-{
-	return ifacehash1(a.data, a.type, h);
-}
-
 static bool
 ifaceeq1(void *data1, void *data2, Type *t)
 {
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index e6354d7e9c..1d1618b0d6 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -651,19 +651,19 @@ enum {
 };
 void	runtime·hashinit(void);
 
-uintptr	runtime·memhash(void*, uintptr, uintptr);
-uintptr	runtime·nohash(void*, uintptr, uintptr);
-uintptr	runtime·strhash(void*, uintptr, uintptr);
-uintptr	runtime·interhash(void*, uintptr, uintptr);
-uintptr	runtime·nilinterhash(void*, uintptr, uintptr);
-uintptr	runtime·f32hash(void*, uintptr, uintptr);
-uintptr	runtime·f64hash(void*, uintptr, uintptr);
-uintptr	runtime·c64hash(void*, uintptr, uintptr);
-uintptr	runtime·c128hash(void*, uintptr, uintptr);
-uintptr	runtime·aeshash(void*, uintptr, uintptr);
-uintptr	runtime·aeshash32(void*, uintptr, uintptr);
-uintptr	runtime·aeshash64(void*, uintptr, uintptr);
-uintptr	runtime·aeshashstr(void*, uintptr, uintptr);
+void	runtime·memhash(void*, uintptr, uintptr, uintptr);
+void	runtime·nohash(void*, uintptr, uintptr, uintptr);
+void	runtime·strhash(void*, uintptr, uintptr, uintptr);
+void	runtime·interhash(void*, uintptr, uintptr, uintptr);
+void	runtime·nilinterhash(void*, uintptr, uintptr, uintptr);
+void	runtime·f32hash(void*, uintptr, uintptr, uintptr);
+void	runtime·f64hash(void*, uintptr, uintptr, uintptr);
+void	runtime·c64hash(void*, uintptr, uintptr, uintptr);
+void	runtime·c128hash(void*, uintptr, uintptr, uintptr);
+void	runtime·aeshash(void*, uintptr, uintptr, uintptr);
+void	runtime·aeshash32(void*, uintptr, uintptr, uintptr);
+void	runtime·aeshash64(void*, uintptr, uintptr, uintptr);
+void	runtime·aeshashstr(void*, uintptr, uintptr, uintptr);
 
 void	runtime·memequal(bool*, uintptr, void*, void*);
 void	runtime·noequal(bool*, uintptr, void*, void*);
@@ -876,8 +876,6 @@ void	runtime·mallocinit(void);
 void	runtime·chaninit(void);
 bool	runtime·ifaceeq_c(Iface, Iface);
 bool	runtime·efaceeq_c(Eface, Eface);
-uintptr	runtime·ifacehash(Iface, uintptr);
-uintptr	runtime·efacehash(Eface, uintptr);
 void*	runtime·malloc(uintptr size);
 void	runtime·runpanic(Panic*);
 uintptr	runtime·getcallersp(void*);

From ea3ac6ba75c5b7496b29117687b0859ad40f3f39 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 6 Aug 2014 13:42:00 -0700
Subject: [PATCH 002/423] runtime: shorten hash declarations

LGTM=iant
R=dvyukov, iant
CC=golang-codereviews
https://golang.org/cl/117680044
---
 src/cmd/api/goapi.go   |  2 +-
 src/pkg/runtime/alg.go | 34 ++++++++++++++++------------------
 2 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 932b5520f4..fe3c257a55 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -378,7 +378,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.
-		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{}; type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{};"
+		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{}; type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{}; type iface struct{}; type eface struct{}"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)
diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index e2917dabb6..251374a946 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -42,9 +42,9 @@ const nacl = GOOS == "nacl"
 var use_aeshash bool
 
 // in asm_*.s
-func aeshash(p unsafe.Pointer, s uintptr, h uintptr) uintptr
+func aeshash(p unsafe.Pointer, s, h uintptr) uintptr
 
-func memhash(p unsafe.Pointer, s uintptr, h uintptr) uintptr {
+func memhash(p unsafe.Pointer, s, h uintptr) uintptr {
 	if !nacl && use_aeshash {
 		return aeshash(p, s, h)
 	}
@@ -58,7 +58,7 @@ func memhash(p unsafe.Pointer, s uintptr, h uintptr) uintptr {
 	return h
 }
 
-func strhash(a *string, s uintptr, h uintptr) uintptr {
+func strhash(a *string, s, h uintptr) uintptr {
 	return memhash((*stringStruct)(unsafe.Pointer(a)).str, uintptr(len(*a)), h)
 }
 
@@ -67,7 +67,7 @@ func strhash(a *string, s uintptr, h uintptr) uintptr {
 // To avoid long hash chains, we assign a random number
 // as the hash value for a NaN.
 
-func f32hash(a *float32, s uintptr, h uintptr) uintptr {
+func f32hash(a *float32, s, h uintptr) uintptr {
 	f := *a
 	switch {
 	case f == 0:
@@ -79,7 +79,7 @@ func f32hash(a *float32, s uintptr, h uintptr) uintptr {
 	}
 }
 
-func f64hash(a *float64, s uintptr, h uintptr) uintptr {
+func f64hash(a *float64, s, h uintptr) uintptr {
 	f := *a
 	switch {
 	case f == 0:
@@ -94,24 +94,22 @@ func f64hash(a *float64, s uintptr, h uintptr) uintptr {
 	}
 }
 
-func c64hash(a *complex64, s uintptr, h uintptr) uintptr {
+func c64hash(a *complex64, s, h uintptr) uintptr {
 	x := (*[2]float32)(unsafe.Pointer(a))
 	return f32hash(&x[1], 4, f32hash(&x[0], 4, h))
 }
 
-func c128hash(a *complex128, s uintptr, h uintptr) uintptr {
+func c128hash(a *complex128, s, h uintptr) uintptr {
 	x := (*[2]float64)(unsafe.Pointer(a))
 	return f64hash(&x[1], 4, f64hash(&x[0], 4, h))
 }
 
-func nohash(a unsafe.Pointer, s uintptr, h uintptr) uintptr {
+func nohash(a unsafe.Pointer, s, h uintptr) uintptr {
 	panic(errorString("hash of unhashable type"))
 }
 
-func interhash(a *interface {
-	f()
-}, s uintptr, h uintptr) uintptr {
-	tab := (*iface)(unsafe.Pointer(a)).tab
+func interhash(a *iface, s, h uintptr) uintptr {
+	tab := a.tab
 	if tab == nil {
 		return h
 	}
@@ -123,14 +121,14 @@ func interhash(a *interface {
 		panic(errorString("hash of unhashable type " + *t._string))
 	}
 	if uintptr(t.size) <= ptrSize {
-		return c1 * fn(unsafe.Pointer(&(*eface)(unsafe.Pointer(a)).data), uintptr(t.size), h^c0)
+		return c1 * fn(unsafe.Pointer(&a.data), uintptr(t.size), h^c0)
 	} else {
-		return c1 * fn((*eface)(unsafe.Pointer(a)).data, uintptr(t.size), h^c0)
+		return c1 * fn(a.data, uintptr(t.size), h^c0)
 	}
 }
 
-func nilinterhash(a *interface{}, s uintptr, h uintptr) uintptr {
-	t := (*eface)(unsafe.Pointer(a))._type
+func nilinterhash(a *eface, s, h uintptr) uintptr {
+	t := a._type
 	if t == nil {
 		return h
 	}
@@ -141,9 +139,9 @@ func nilinterhash(a *interface{}, s uintptr, h uintptr) uintptr {
 		panic(errorString("hash of unhashable type " + *t._string))
 	}
 	if uintptr(t.size) <= ptrSize {
-		return c1 * fn(unsafe.Pointer(&(*eface)(unsafe.Pointer(a)).data), uintptr(t.size), h^c0)
+		return c1 * fn(unsafe.Pointer(&a.data), uintptr(t.size), h^c0)
 	} else {
-		return c1 * fn((*eface)(unsafe.Pointer(a)).data, uintptr(t.size), h^c0)
+		return c1 * fn(a.data, uintptr(t.size), h^c0)
 	}
 }
 

From 1338f327b2deb81ba81107b5033d1b10e97e3abe Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 6 Aug 2014 16:45:06 -0400
Subject: [PATCH 003/423] cmd/go: implement 'internal' convention

See golang.org/s/go14internal for design.

LGTM=r
R=r, adg
CC=golang-codereviews
https://golang.org/cl/120600043
---
 src/cmd/go/pkg.go                             | 65 +++++++++++++++++--
 src/cmd/go/test.bash                          | 16 +++++
 src/cmd/go/testdata/testinternal/p.go         |  3 +
 src/cmd/go/testdata/testinternal2/p.go        |  3 +
 .../testinternal2/x/y/z/internal/w/w.go       |  1 +
 5 files changed, 83 insertions(+), 5 deletions(-)
 create mode 100644 src/cmd/go/testdata/testinternal/p.go
 create mode 100644 src/cmd/go/testdata/testinternal2/p.go
 create mode 100644 src/cmd/go/testdata/testinternal2/x/y/z/internal/w/w.go

diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index d45df265b9..d0dbefed01 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -244,6 +244,9 @@ func loadImport(path string, srcDir string, stk *importStack, importPos []token.
 		importPath = dirToImportPath(filepath.Join(srcDir, path))
 	}
 	if p := packageCache[importPath]; p != nil {
+		if perr := disallowInternal(srcDir, p, stk); perr != p {
+			return perr
+		}
 		return reusePackage(p, stk)
 	}
 
@@ -270,6 +273,10 @@ func loadImport(path string, srcDir string, stk *importStack, importPos []token.
 		p.Error.Pos = pos.String()
 	}
 
+	if perr := disallowInternal(srcDir, p, stk); perr != p {
+		return perr
+	}
+
 	return p
 }
 
@@ -298,6 +305,54 @@ func reusePackage(p *Package, stk *importStack) *Package {
 	return p
 }
 
+// disallowInternal checks that srcDir is allowed to import p.
+// If the import is allowed, disallowInternal returns the original package p.
+// If not, it returns a new package containing just an appropriate error.
+func disallowInternal(srcDir string, p *Package, stk *importStack) *Package {
+	// golang.org/s/go14internal:
+	// An import of a path containing the element “internal”
+	// is disallowed if the importing code is outside the tree
+	// rooted at the parent of the “internal” directory.
+	//
+	// ... For Go 1.4, we will implement the rule first for $GOROOT, but not $GOPATH.
+
+	// Only applies to $GOROOT.
+	if !p.Standard {
+		return p
+	}
+
+	// The stack includes p.ImportPath.
+	// If that's the only thing on the stack, we started
+	// with a name given on the command line, not an
+	// import. Anything listed on the command line is fine.
+	if len(*stk) == 1 {
+		return p
+	}
+
+	// Check for "internal" element: four cases depending on begin of string and/or end of string.
+	if p.ImportPath != "internal" &&
+		!strings.HasPrefix(p.ImportPath, "internal/") &&
+		!strings.HasSuffix(p.ImportPath, "/internal") &&
+		!strings.Contains(p.ImportPath, "/internal/") {
+		return p
+	}
+
+	// Internal is present. Check directory.
+	parent := filepath.Dir(p.Dir)
+	if hasPathPrefix(srcDir, parent) {
+		return p
+	}
+
+	// Internal is present, and srcDir is outside parent's tree. Not allowed.
+	perr := *p
+	perr.Error = &PackageError{
+		ImportStack: stk.copy(),
+		Err:         "use of internal package not allowed",
+	}
+	perr.Incomplete = true
+	return &perr
+}
+
 type targetDir int
 
 const (
@@ -482,7 +537,7 @@ func (p *Package) load(stk *importStack, bp *build.Package, err error) *Package
 
 	// Build list of imported packages and full dependency list.
 	imports := make([]*Package, 0, len(p.Imports))
-	deps := make(map[string]bool)
+	deps := make(map[string]*Package)
 	for i, path := range importPaths {
 		if path == "C" {
 			continue
@@ -502,10 +557,10 @@ func (p *Package) load(stk *importStack, bp *build.Package, err error) *Package
 			path = p1.ImportPath
 			importPaths[i] = path
 		}
-		deps[path] = true
+		deps[path] = p1
 		imports = append(imports, p1)
-		for _, dep := range p1.Deps {
-			deps[dep] = true
+		for _, dep := range p1.deps {
+			deps[dep.ImportPath] = dep
 		}
 		if p1.Incomplete {
 			p.Incomplete = true
@@ -519,7 +574,7 @@ func (p *Package) load(stk *importStack, bp *build.Package, err error) *Package
 	}
 	sort.Strings(p.Deps)
 	for _, dep := range p.Deps {
-		p1 := packageCache[dep]
+		p1 := deps[dep]
 		if p1 == nil {
 			panic("impossible: missing entry in package cache for " + dep + " imported by " + p.ImportPath)
 		}
diff --git a/src/cmd/go/test.bash b/src/cmd/go/test.bash
index c62f629405..e5ba12b1df 100755
--- a/src/cmd/go/test.bash
+++ b/src/cmd/go/test.bash
@@ -105,6 +105,22 @@ cp -R testdata/local "testdata/$bad"
 testlocal "$bad" 'with bad characters in path'
 rm -rf "testdata/$bad"
 
+TEST 'internal packages in $GOROOT are respected'
+if ./testgo build -v ./testdata/testinternal >testdata/std.out 2>&1; then
+	echo "go build ./testdata/testinternal succeeded incorrectly"
+	ok=false
+elif ! grep 'use of internal package not allowed' testdata/std.out >/dev/null; then
+	echo "wrong error message for testdata/testinternal"
+	cat std.out
+	ok=false
+fi
+
+TEST 'internal packages outside $GOROOT are not respected'
+if ! ./testgo build -v ./testdata/testinternal2; then
+	echo "go build ./testdata/testinternal2 failed"
+	ok=false
+fi
+
 TEST error message for syntax error in test go file says FAIL
 export GOPATH=$(pwd)/testdata
 if ./testgo test syntaxerror 2>testdata/err; then
diff --git a/src/cmd/go/testdata/testinternal/p.go b/src/cmd/go/testdata/testinternal/p.go
new file mode 100644
index 0000000000..e3558a53b2
--- /dev/null
+++ b/src/cmd/go/testdata/testinternal/p.go
@@ -0,0 +1,3 @@
+package p
+
+import _ "net/http/internal"
diff --git a/src/cmd/go/testdata/testinternal2/p.go b/src/cmd/go/testdata/testinternal2/p.go
new file mode 100644
index 0000000000..c594f5c5e9
--- /dev/null
+++ b/src/cmd/go/testdata/testinternal2/p.go
@@ -0,0 +1,3 @@
+package p
+
+import _ "./x/y/z/internal/w"
diff --git a/src/cmd/go/testdata/testinternal2/x/y/z/internal/w/w.go b/src/cmd/go/testdata/testinternal2/x/y/z/internal/w/w.go
new file mode 100644
index 0000000000..a796c0b5f4
--- /dev/null
+++ b/src/cmd/go/testdata/testinternal2/x/y/z/internal/w/w.go
@@ -0,0 +1 @@
+package w

From 5fbcdb26613a819ba693ee3933f6e283e139630b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 6 Aug 2014 16:47:54 -0400
Subject: [PATCH 004/423] runtime: use better hash for floating point inputs

Hashing on the bytes instead of the words does
a (much) better job of using all the bits, so that
maps of floats have linear performance.

LGTM=khr
R=golang-codereviews, khr
CC=adonovan, golang-codereviews
https://golang.org/cl/126720044
---
 src/pkg/runtime/alg.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index 251374a946..f2bb202c68 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -75,7 +75,7 @@ func f32hash(a *float32, s, h uintptr) uintptr {
 	case f != f:
 		return c1 * (c0 ^ h ^ uintptr(fastrand2())) // any kind of NaN
 	default:
-		return c1 * (c0 ^ h ^ uintptr(*(*uint32)(unsafe.Pointer(a))))
+		return memhash(unsafe.Pointer(a), 4, h)
 	}
 }
 
@@ -86,11 +86,8 @@ func f64hash(a *float64, s, h uintptr) uintptr {
 		return c1 * (c0 ^ h) // +0, -0
 	case f != f:
 		return c1 * (c0 ^ h ^ uintptr(fastrand2())) // any kind of NaN
-	case ptrSize == 4:
-		x := (*[2]uintptr)(unsafe.Pointer(a))
-		return c1 * (c0 ^ h ^ (x[1] * c1) ^ x[0])
 	default:
-		return c1 * (c0 ^ h ^ *(*uintptr)(unsafe.Pointer(a)))
+		return memhash(unsafe.Pointer(a), 8, h)
 	}
 }
 

From 161ba662b19ca0ed367883c6d9233fc00c10654f Mon Sep 17 00:00:00 2001
From: Alan Donovan <adonovan@google.com>
Date: Wed, 6 Aug 2014 17:02:55 -0400
Subject: [PATCH 005/423] test/mapnan.go: add regression test for non-empty
 interfaces.

LGTM=rsc, khr
R=rsc, khr, bradfitz
CC=golang-codereviews
https://golang.org/cl/126720043
---
 test/map.go       |   2 +-
 test/maplinear.go | 143 ++++++++++++++++++++++++++++++++++++++++++++++
 test/mapnan.go    |  56 ------------------
 3 files changed, 144 insertions(+), 57 deletions(-)
 create mode 100644 test/maplinear.go
 delete mode 100644 test/mapnan.go

diff --git a/test/map.go b/test/map.go
index 485e743fe4..2c1cf8a140 100644
--- a/test/map.go
+++ b/test/map.go
@@ -5,7 +5,7 @@
 // license that can be found in the LICENSE file.
 
 // Test maps, almost exhaustively.
-// NaN complexity test is in mapnan.go.
+// Complexity (linearity) test is in maplinear.go.
 
 package main
 
diff --git a/test/maplinear.go b/test/maplinear.go
new file mode 100644
index 0000000000..56e50951af
--- /dev/null
+++ b/test/maplinear.go
@@ -0,0 +1,143 @@
+// +build darwin linux
+// run
+
+// 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.
+
+// Test that maps don't go quadratic for NaNs and other values.
+
+package main
+
+import (
+	"fmt"
+	"math"
+	"time"
+)
+
+// checkLinear asserts that the running time of f(n) is in O(n).
+// tries is the initial number of iterations.
+func checkLinear(typ string, tries int, f func(n int)) {
+	// Depending on the machine and OS, this test might be too fast
+	// to measure with accurate enough granularity. On failure,
+	// make it run longer, hoping that the timing granularity
+	// is eventually sufficient.
+
+	timeF := func(n int) time.Duration {
+		t1 := time.Now()
+		f(n)
+		return time.Since(t1)
+	}
+
+	t0 := time.Now()
+
+	n := tries
+	fails := 0
+	for {
+		t1 := timeF(n)
+		t2 := timeF(2 * n)
+
+		// should be 2x (linear); allow up to 3x
+		if t2 < 3*t1 {
+			if false {
+				fmt.Println(typ, "\t", time.Since(t0))
+			}
+			return
+		}
+		fails++
+		if fails == 6 {
+			panic(fmt.Sprintf("%s: too slow: %d inserts: %v; %d inserts: %v\n",
+				typ, n, t1, 2*n, t2))
+		}
+		if fails < 4 {
+			n *= 2
+		}
+	}
+}
+
+type I interface {
+	f()
+}
+
+type C int
+
+func (C) f() {}
+
+func main() {
+	// NaNs. ~31ms on a 1.6GHz Zeon.
+	checkLinear("NaN", 30000, func(n int) {
+		m := map[float64]int{}
+		nan := math.NaN()
+		for i := 0; i < n; i++ {
+			m[nan] = 1
+		}
+		if len(m) != n {
+			panic("wrong size map after nan insertion")
+		}
+	})
+
+	// ~6ms on a 1.6GHz Zeon.
+	checkLinear("eface", 10000, func(n int) {
+		m := map[interface{}]int{}
+		for i := 0; i < n; i++ {
+			m[i] = 1
+		}
+	})
+
+	// ~7ms on a 1.6GHz Zeon.
+	// Regression test for CL 119360043.
+	checkLinear("iface", 10000, func(n int) {
+		m := map[I]int{}
+		for i := 0; i < n; i++ {
+			m[C(i)] = 1
+		}
+	})
+
+	// ~6ms on a 1.6GHz Zeon.
+	checkLinear("int", 10000, func(n int) {
+		m := map[int]int{}
+		for i := 0; i < n; i++ {
+			m[i] = 1
+		}
+	})
+
+	// ~18ms on a 1.6GHz Zeon.
+	checkLinear("string", 10000, func(n int) {
+		m := map[string]int{}
+		for i := 0; i < n; i++ {
+			m[fmt.Sprint(i)] = 1
+		}
+	})
+
+	// ~6ms on a 1.6GHz Zeon.
+	checkLinear("float32", 10000, func(n int) {
+		m := map[float32]int{}
+		for i := 0; i < n; i++ {
+			m[float32(i)] = 1
+		}
+	})
+
+	// ~6ms on a 1.6GHz Zeon.
+	checkLinear("float64", 10000, func(n int) {
+		m := map[float64]int{}
+		for i := 0; i < n; i++ {
+			m[float64(i)] = 1
+		}
+	})
+
+	// ~22ms on a 1.6GHz Zeon.
+	checkLinear("complex64", 10000, func(n int) {
+		m := map[complex64]int{}
+		for i := 0; i < n; i++ {
+			m[complex(float32(i), float32(i))] = 1
+		}
+	})
+
+	// ~32ms on a 1.6GHz Zeon.
+	checkLinear("complex128", 10000, func(n int) {
+		m := map[complex128]int{}
+		for i := 0; i < n; i++ {
+			m[complex(float64(i), float64(i))] = 1
+		}
+	})
+}
diff --git a/test/mapnan.go b/test/mapnan.go
deleted file mode 100644
index f081cab01d..0000000000
--- a/test/mapnan.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// +build darwin linux
-// run
-
-// 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.
-
-// Test that NaNs in maps don't go quadratic.
-
-package main
-
-import (
-	"fmt"
-	"math"
-	"time"
-)
-
-func main() {
-
-	// Test that NaNs in maps don't go quadratic.
-	t := func(n int) time.Duration {
-		t1 := time.Now()
-		m := map[float64]int{}
-		nan := math.NaN()
-		for i := 0; i < n; i++ {
-			m[nan] = 1
-		}
-		if len(m) != n {
-			panic("wrong size map after nan insertion")
-		}
-		return time.Since(t1)
-	}
-
-	// Depending on the machine and OS, this test might be too fast
-	// to measure with accurate enough granularity. On failure,
-	// make it run longer, hoping that the timing granularity
-	// is eventually sufficient.
-
-	n := 30000 // ~8ms user time on a Mid 2011 MacBook Air (1.8 GHz Core i7)
-	fails := 0
-	for {
-		t1 := t(n)
-		t2 := t(2 * n)
-		// should be 2x (linear); allow up to 3x
-		if t2 < 3*t1 {
-			return
-		}
-		fails++
-		if fails == 6 {
-			panic(fmt.Sprintf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2))
-		}
-		if fails < 4 {
-			n *= 2
-		}
-	}
-}

From e359bea8ad0b381c1b28dd7c74ca17e17a7f3324 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 6 Aug 2014 14:33:57 -0700
Subject: [PATCH 006/423] runtime: clean up naming of mcallable functions.

Introduce the mFunction type to represent an mcall/onM-able function.
Name such functions using _m.

LGTM=bradfitz
R=bradfitz
CC=golang-codereviews
https://golang.org/cl/121320043
---
 src/pkg/runtime/malloc.c  |  6 +++---
 src/pkg/runtime/malloc.go | 12 ++++++------
 src/pkg/runtime/mgc0.c    |  2 +-
 src/pkg/runtime/mprof.goc |  2 +-
 src/pkg/runtime/print.go  | 10 ++++++----
 src/pkg/runtime/stubs.go  | 30 +++++++++++++++++++-----------
 6 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index d56d0dcf31..951117622f 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -514,7 +514,7 @@ throw:
 }
 
 void
-runtime·setFinalizer(void)
+runtime·setFinalizer_m(void)
 {
 	Eface obj, finalizer;
 
@@ -531,13 +531,13 @@ runtime·setFinalizer(void)
 
 // mcallable cache refill
 void 
-runtime·mcacheRefill(void)
+runtime·mcacheRefill_m(void)
 {
 	runtime·MCache_Refill(g->m->mcache, (int32)g->m->scalararg[0]);
 }
 
 void
-runtime·largeAlloc(void)
+runtime·largeAlloc_m(void)
 {
 	uintptr npages, size;
 	MSpan *s;
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index dedcea94a6..81769573c9 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -114,7 +114,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			v := s.freelist
 			if v == nil {
 				mp.scalararg[0] = tinySizeClass
-				onM(&mcacheRefill)
+				onM(&mcacheRefill_m)
 				s = c.alloc[tinySizeClass]
 				v = s.freelist
 			}
@@ -143,7 +143,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			v := s.freelist
 			if v == nil {
 				mp.scalararg[0] = uint(sizeclass)
-				onM(&mcacheRefill)
+				onM(&mcacheRefill_m)
 				s = c.alloc[sizeclass]
 				v = s.freelist
 			}
@@ -162,7 +162,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 	} else {
 		mp.scalararg[0] = uint(size)
 		mp.scalararg[1] = uint(flags)
-		onM(&largeAlloc)
+		onM(&largeAlloc_m)
 		s = (*mspan)(mp.ptrarg[0])
 		mp.ptrarg[0] = nil
 		x = unsafe.Pointer(uintptr(s.start << pageShift))
@@ -272,7 +272,7 @@ func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 	}
 	mp.scalararg[0] = uint(size)
 	mp.ptrarg[0] = x
-	onM(&mprofMalloc)
+	onM(&mprofMalloc_m)
 }
 
 // force = 1 - do GC regardless of current heap usage
@@ -341,7 +341,7 @@ func gogc(force int32) {
 		} else {
 			mp.scalararg[1] = 0
 		}
-		onM(&mgc2)
+		onM(&gc_m)
 	}
 
 	// all done
@@ -426,6 +426,6 @@ func SetFinalizer(obj interface{}, finalizer interface{}) {
 	mp.ptrarg[1] = e.data
 	mp.ptrarg[2] = unsafe.Pointer(ftyp)
 	mp.ptrarg[3] = f.data
-	onM(&setFinalizer)
+	onM(&setFinalizer_m)
 	releasem(mp)
 }
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index e7955151ce..01e055cf04 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1369,7 +1369,7 @@ mgc(G *gp)
 }
 
 void
-runtime·mgc2(void)
+runtime·gc_m(void)
 {
 	struct gc_args a;
 	G *gp;
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index 69187f2a74..053781193e 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -142,7 +142,7 @@ runtime·MProf_Malloc(void *p, uintptr size)
 
 // Called by malloc to record a profiled block.
 void
-runtime·mprofMalloc(void)
+runtime·mprofMalloc_m(void)
 {
 	uintptr stk[32];
 	Bucket *b;
diff --git a/src/pkg/runtime/print.go b/src/pkg/runtime/print.go
index 904af5d333..4b94417c6e 100644
--- a/src/pkg/runtime/print.go
+++ b/src/pkg/runtime/print.go
@@ -10,10 +10,12 @@ import (
 
 // these 4 functions are complicated enough that we will share
 // the print logic with the C printf.
-var printstring_m byte
-var printuint_m byte
-var printhex_m byte
-var printfloat_m byte
+var (
+	printstring_m,
+	printuint_m,
+	printhex_m,
+	printfloat_m mFunction
+)
 
 func printstring(s string) {
 	mp := acquirem()
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 30638d1af8..8a2fc8a97e 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -44,21 +44,29 @@ func roundup(p unsafe.Pointer, n uintptr) unsafe.Pointer {
 func acquirem() *m
 func releasem(mp *m)
 
-// in asm_*.s
-func mcall(fn *byte)
-func onM(fn *byte)
+// An mFunction represents a C function that runs on the M stack.  It
+// can be called from Go using mcall or onM.  Through the magic of
+// linking, an mFunction variable and the corresponding C code entry
+// point live at the same address.
+type mFunction byte
 
-// C routines that run on the M stack.  Call these like
-//   mcall(&mcacheRefill)
+// in asm_*.s
+func mcall(fn *mFunction)
+func onM(fn *mFunction)
+
+// C functions that run on the M stack.  Call these like
+//   mcall(&mcacheRefill_m)
 // Arguments should be passed in m->scalararg[x] and
 // m->ptrarg[x].  Return values can be passed in those
 // same slots.
-var mcacheRefill byte
-var largeAlloc byte
-var mprofMalloc byte
-var mgc2 byte
-var setFinalizer byte
-var markallocated_m byte
+var (
+	mcacheRefill_m,
+	largeAlloc_m,
+	mprofMalloc_m,
+	gc_m,
+	setFinalizer_m,
+	markallocated_m mFunction
+)
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s

From 7bcaff70ed92156eb98841ecac3fb5e234822ea3 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Wed, 6 Aug 2014 14:43:50 -0700
Subject: [PATCH 007/423] debug/dwarf: fix typos in comment for UnspecifiedType

LGTM=iant, bradfitz
R=bradfitz, iant
CC=golang-codereviews
https://golang.org/cl/120700043
---
 src/pkg/debug/dwarf/type.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/debug/dwarf/type.go b/src/pkg/debug/dwarf/type.go
index e59737b0a4..b64333ecc5 100644
--- a/src/pkg/debug/dwarf/type.go
+++ b/src/pkg/debug/dwarf/type.go
@@ -88,7 +88,7 @@ type AddrType struct {
 	BasicType
 }
 
-// A UnspecifiedType represents implicit, unknown, ambiguous or nonexistent type.
+// An UnspecifiedType represents an implicit, unknown, ambiguous or nonexistent type.
 type UnspecifiedType struct {
 	BasicType
 }

From fef54b22f8ee7a57a5ba04a6a02244a10f90e904 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 6 Aug 2014 17:59:30 -0400
Subject: [PATCH 008/423] cmd/go: revise disallowInternal

This fixes two problems: x/internal/y/z was using parent = x/internal/y instead of x,
and hasPathPrefix only looks at /, not \ for Windows.

LGTM=bradfitz
R=bradfitz
CC=golang-codereviews
https://golang.org/cl/121280045
---
 src/cmd/go/pkg.go | 35 ++++++++++++++++++++++++++++-------
 1 file changed, 28 insertions(+), 7 deletions(-)

diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index d0dbefed01..be691a6bc9 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -330,16 +330,18 @@ func disallowInternal(srcDir string, p *Package, stk *importStack) *Package {
 	}
 
 	// Check for "internal" element: four cases depending on begin of string and/or end of string.
-	if p.ImportPath != "internal" &&
-		!strings.HasPrefix(p.ImportPath, "internal/") &&
-		!strings.HasSuffix(p.ImportPath, "/internal") &&
-		!strings.Contains(p.ImportPath, "/internal/") {
+	i, ok := findInternal(p.ImportPath)
+	if !ok {
 		return p
 	}
 
-	// Internal is present. Check directory.
-	parent := filepath.Dir(p.Dir)
-	if hasPathPrefix(srcDir, parent) {
+	// Internal is present.
+	// Map import path back to directory corresponding to parent of internal.
+	if i > 0 {
+		i-- // rewind over slash in ".../internal"
+	}
+	parent := p.Dir[:i+len(p.Dir)-len(p.ImportPath)]
+	if hasPathPrefix(filepath.ToSlash(srcDir), filepath.ToSlash(parent)) {
 		return p
 	}
 
@@ -353,6 +355,25 @@ func disallowInternal(srcDir string, p *Package, stk *importStack) *Package {
 	return &perr
 }
 
+// findInternal looks for the final "internal" path element in the given import path.
+// If there isn't one, findInternal returns ok=false.
+// Otherwise, findInternal returns ok=true and the index of the "internal".
+func findInternal(path string) (index int, ok bool) {
+	// Four cases, depending on internal at start/end of string or not.
+	// The order matters: we must return the index of the final element,
+	// because the final one produces the most restrictive requirement
+	// on the importer.
+	switch {
+	case strings.HasSuffix(path, "/internal"):
+		return len(path) - len("internal"), true
+	case strings.Contains(path, "/internal/"):
+		return strings.LastIndex(path, "/internal/") + 1, true
+	case path == "internal", strings.HasPrefix(path, "internal/"):
+		return 0, true
+	}
+	return 0, false
+}
+
 type targetDir int
 
 const (

From b91aea55366d3f72c6f16a2cb5651b4e3aa5fb0c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 6 Aug 2014 18:00:06 -0400
Subject: [PATCH 009/423] encoding/xml: add InputOffset method to Decoder

Among other things, this allows users to match the decoded
pieces with the original XML, which can be necessary for
implementing standards like XML signatures.

Fixes #8484.

LGTM=bradfitz
R=bradfitz
CC=golang-codereviews
https://golang.org/cl/122960043
---
 src/pkg/encoding/xml/xml.go      | 11 +++++++++++
 src/pkg/encoding/xml/xml_test.go | 31 +++++++++++++++++++++++++++----
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/src/pkg/encoding/xml/xml.go b/src/pkg/encoding/xml/xml.go
index b473cb8458..a4cd4e29e0 100644
--- a/src/pkg/encoding/xml/xml.go
+++ b/src/pkg/encoding/xml/xml.go
@@ -29,6 +29,7 @@ import (
 type SyntaxError struct {
 	Msg  string
 	Line int
+	Byte int64 // byte offset from start of stream
 }
 
 func (e *SyntaxError) Error() string {
@@ -196,6 +197,7 @@ type Decoder struct {
 	ns             map[string]string
 	err            error
 	line           int
+	offset         int64
 	unmarshalDepth int
 }
 
@@ -859,9 +861,17 @@ func (d *Decoder) getc() (b byte, ok bool) {
 	if b == '\n' {
 		d.line++
 	}
+	d.offset++
 	return b, true
 }
 
+// InputOffset returns the input stream byte offset of the current decoder position.
+// The offset gives the location of the end of the most recently returned token
+// and the beginning of the next token.
+func (d *Decoder) InputOffset() int64 {
+	return d.offset
+}
+
 // Return saved offset.
 // If we did ungetc (nextByte >= 0), have to back up one.
 func (d *Decoder) savedOffset() int {
@@ -891,6 +901,7 @@ func (d *Decoder) ungetc(b byte) {
 		d.line--
 	}
 	d.nextByte = int(b)
+	d.offset--
 }
 
 var entity = map[string]int{
diff --git a/src/pkg/encoding/xml/xml_test.go b/src/pkg/encoding/xml/xml_test.go
index 7723ab1c9f..be995c0d52 100644
--- a/src/pkg/encoding/xml/xml_test.go
+++ b/src/pkg/encoding/xml/xml_test.go
@@ -170,7 +170,7 @@ var xmlInput = []string{
 func TestRawToken(t *testing.T) {
 	d := NewDecoder(strings.NewReader(testInput))
 	d.Entity = testEntity
-	testRawToken(t, d, rawTokens)
+	testRawToken(t, d, testInput, rawTokens)
 }
 
 const nonStrictInput = `
@@ -225,7 +225,7 @@ var nonStrictTokens = []Token{
 func TestNonStrictRawToken(t *testing.T) {
 	d := NewDecoder(strings.NewReader(nonStrictInput))
 	d.Strict = false
-	testRawToken(t, d, nonStrictTokens)
+	testRawToken(t, d, nonStrictInput, nonStrictTokens)
 }
 
 type downCaser struct {
@@ -254,7 +254,7 @@ func TestRawTokenAltEncoding(t *testing.T) {
 		}
 		return &downCaser{t, input.(io.ByteReader)}, nil
 	}
-	testRawToken(t, d, rawTokensAltEncoding)
+	testRawToken(t, d, testInputAltEncoding, rawTokensAltEncoding)
 }
 
 func TestRawTokenAltEncodingNoConverter(t *testing.T) {
@@ -280,9 +280,12 @@ func TestRawTokenAltEncodingNoConverter(t *testing.T) {
 	}
 }
 
-func testRawToken(t *testing.T, d *Decoder, rawTokens []Token) {
+func testRawToken(t *testing.T, d *Decoder, raw string, rawTokens []Token) {
+	lastEnd := int64(0)
 	for i, want := range rawTokens {
+		start := d.InputOffset()
 		have, err := d.RawToken()
+		end := d.InputOffset()
 		if err != nil {
 			t.Fatalf("token %d: unexpected error: %s", i, err)
 		}
@@ -300,6 +303,26 @@ func testRawToken(t *testing.T, d *Decoder, rawTokens []Token) {
 			}
 			t.Errorf("token %d = %s, want %s", i, shave, swant)
 		}
+
+		// Check that InputOffset returned actual token.
+		switch {
+		case start < lastEnd:
+			t.Errorf("token %d: position [%d,%d) for %T is before previous token", i, start, end, have)
+		case start >= end:
+			// Special case: EndElement can be synthesized.
+			if start == end && end == lastEnd {
+				break
+			}
+			t.Errorf("token %d: position [%d,%d) for %T is empty", i, start, end, have)
+		case end > int64(len(raw)):
+			t.Errorf("token %d: position [%d,%d) for %T extends beyond input", i, start, end, have)
+		default:
+			text := raw[start:end]
+			if strings.ContainsAny(text, "<>") && (!strings.HasPrefix(text, "<") || !strings.HasSuffix(text, ">")) {
+				t.Errorf("token %d: misaligned raw token %#q for %T", i, text, have)
+			}
+		}
+		lastEnd = end
 	}
 }
 

From a2d3669ef709c8a703534c113a95a283068ae43d Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Thu, 7 Aug 2014 10:22:10 +1000
Subject: [PATCH 010/423] path/filepath: do not restore original working
 directory twice in test

LGTM=dave
R=golang-codereviews, dave
CC=golang-codereviews
https://golang.org/cl/122910043
---
 src/pkg/path/filepath/path_test.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/pkg/path/filepath/path_test.go b/src/pkg/path/filepath/path_test.go
index 17b53bdf92..8cdc763f1b 100644
--- a/src/pkg/path/filepath/path_test.go
+++ b/src/pkg/path/filepath/path_test.go
@@ -784,12 +784,6 @@ var absTests = []string{
 }
 
 func TestAbs(t *testing.T) {
-	oldwd, err := os.Getwd()
-	if err != nil {
-		t.Fatal("Getwd failed: ", err)
-	}
-	defer os.Chdir(oldwd)
-
 	root, err := ioutil.TempDir("", "TestAbs")
 	if err != nil {
 		t.Fatal("TempDir failed: ", err)

From 7ce3406c8fe1d71d0d595bcd0842bf27f6d1bf32 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Thu, 7 Aug 2014 10:25:50 +1000
Subject: [PATCH 011/423] doc/go1.4.txt: implement monotonic clocks on windows

LGTM=dave
R=golang-codereviews, dave
CC=golang-codereviews
https://golang.org/cl/126760043
---
 doc/go1.4.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index 87904ee7ea..3ea1ca3c52 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -10,6 +10,7 @@ spec: permit for range x (CL 104680043)
 encoding/gob: remove unsafe (CL 102680045)
 misc: deleted editor support; refer to https://code.google.com/p/go-wiki/wiki/IDEsAndTextEditorPlugins instead (CL 105470043)
 os: implement symlink support for windows (CL 86160044)
+runtime: implement monotonic clocks on windows (CL 108700045)
 runtime/race: freebsd is supported (CL 107270043)
 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)
 testing: add Coverage (CL 98150043)

From cdf77676289de7580b1451a3862cc97f620df389 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Thu, 7 Aug 2014 09:28:49 +0900
Subject: [PATCH 012/423] doc/go1.4.txt: add support for ALPN

LGTM=minux
R=r, agl, minux
CC=golang-codereviews
https://golang.org/cl/121340043
---
 doc/go1.4.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index 3ea1ca3c52..20d2a6b7ed 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -7,6 +7,7 @@ Please keep the list sorted (as in sort.Strings of the lines).
 
 spec: permit for range x (CL 104680043)
 
+crypto/tls: add support for ALPN (RFC 7301) (CL 108710046)
 encoding/gob: remove unsafe (CL 102680045)
 misc: deleted editor support; refer to https://code.google.com/p/go-wiki/wiki/IDEsAndTextEditorPlugins instead (CL 105470043)
 os: implement symlink support for windows (CL 86160044)

From 9f07456c138f606350ff73f25a55ab65210e5b38 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Thu, 7 Aug 2014 11:21:32 +1000
Subject: [PATCH 013/423] C: add Paul Nasrat (Google CLA)

TBR=gobot
R=golang-codereviews
CC=golang-codereviews
https://golang.org/cl/125790043
---
 CONTRIBUTORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 1053057b5a..30a2b567db 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -455,6 +455,7 @@ Paul Borman <borman@google.com>
 Paul Chang <paulchang@google.com>
 Paul Hammond <paul@paulhammond.org>
 Paul Lalonde <paul.a.lalonde@gmail.com>
+Paul Nasrat <pnasrat@google.com>
 Paul Sbarra <Sbarra.Paul@gmail.com>
 Paul van Brouwershaven <paul@vanbrouwershaven.com>
 Pavel Zinovkin <pavel.zinovkin@gmail.com>

From cfed26c7ceeaf093d975e0a748d270cd1b716816 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Thu, 7 Aug 2014 11:50:27 +1000
Subject: [PATCH 014/423] misc/nacl: wrap lines in README file

LGTM=dan.kortschak, dave
R=dave, dan.kortschak
CC=golang-codereviews
https://golang.org/cl/121350043
---
 misc/nacl/README | 57 +++++++++++++++++++++++++++++++++++-------------
 1 file changed, 42 insertions(+), 15 deletions(-)

diff --git a/misc/nacl/README b/misc/nacl/README
index 710587dfce..6f149f8ac8 100644
--- a/misc/nacl/README
+++ b/misc/nacl/README
@@ -1,12 +1,14 @@
 Native Client
 =============
 
-This document outlines the basics of building and developing the Go runtime and programs in the Native Client (NaCl) environment.
+This document outlines the basics of building and developing the Go runtime and
+programs in the Native Client (NaCl) environment.
 
 Go 1.3 supports three architectures
 
  * nacl/386 which is standard 386.
- * nacl/amd64p32 which is a 64 bit architecture, where the address space is limited to a 4gb window. 
+ * nacl/amd64p32 which is a 64 bit architecture, where the address space is
+   limited to a 4gb window. 
  * nacl/arm which is 32-bit ARMv7A architecture with 1GB address space.
 
 For background it is recommended that you read http://golang.org/s/go13nacl.
@@ -14,34 +16,48 @@ For background it is recommended that you read http://golang.org/s/go13nacl.
 Prerequisites
 -------------
 
-Native Client programs are executed inside a sandbox, the NaCl runtime. This runtime must be installed before you can use NaCl programs.
+Native Client programs are executed inside a sandbox, the NaCl runtime. This
+runtime must be installed before you can use NaCl programs.
 
-The NaCl distribution comes with an installer which ensures you have access to the latest version of the runtime. The version tracks the Chrome numbering scheme.
+The NaCl distribution comes with an installer which ensures you have access to
+the latest version of the runtime. The version tracks the Chrome numbering
+scheme.
 
 # Download NaCl
 
-Download nacl_sdk.zip file from https://developers.google.com/native-client/dev/sdk/download, and unpack it. I chose /opt/nacl_sdk
+Download nacl_sdk.zip file from
+	https://developers.google.com/native-client/dev/sdk/download
+and unpack it. I chose /opt/nacl_sdk.
 
 # Update
 
-The zip file contains a small skeleton that can be used to download the correct sdk. These are released every 6-8 weeks, in line with Chrome releases.
+The zip file contains a small skeleton that can be used to download the correct
+sdk. These are released every 6-8 weeks, in line with Chrome releases.
 	
 	% cd /opt/nacl_sdk
 	% ./naclsdk update
 
-At this time pepper_33 is the stable version. If naclsdk downloads a later version, please adjust accordingly. As of June 2014, only the canary sdk provides support for nacl/arm.
+At this time pepper_33 is the stable version. If naclsdk downloads a later
+version, please adjust accordingly. As of June 2014, only the canary sdk
+provides support for nacl/arm.
 
-The cmd/go helper scripts expect that the runtime loaders, sel_ldr_{x86_{32,64},arm} and nacl_helper_bootstrap_arm are in your path. I find it easiest to make a symlink from the NaCl distribution to my $GOPATH/bin directory.
+The cmd/go helper scripts expect that the loaders sel_ldr_{x86_{32,64},arm} and
+nacl_helper_bootstrap_arm are in your path. I find it easiest to make a symlink
+from the NaCl distribution to my $GOPATH/bin directory.
 
 	% ln -nfs /opt/nacl_sdk/pepper_33/tools/sel_ldr_x86_32 $GOPATH/bin/sel_ldr_x86_32
 	% ln -nfs /opt/nacl_sdk/pepper_33/tools/sel_ldr_x86_64 $GOPATH/bin/sel_ldr_x86_64
 	% ln -nfs /opt/nacl_sdk/pepper_canary/tools/sel_ldr_arm $GOPATH/bin/sel_ldr_arm
-	% ln -nfs /opt/nacl_sdk/pepper_canary/tools/nacl_helper_bootstrap_arm $GOPATH/bin/nacl_helper_bootstrap_arm # only required for NaCl/ARM.
+
+Additionally, for NaCl/ARM only:
+
+	% ln -nfs /opt/nacl_sdk/pepper_canary/tools/nacl_helper_bootstrap_arm $GOPATH/bin/nacl_helper_bootstrap_arm 
 
 Support scripts
 ---------------
 
-Symlink the two scripts in this directory into your $PATH, just as you did with NaCl sdk above.
+Symlink the two scripts in this directory into your $PATH, just as you did with
+NaCl sdk above.
 
 	% ln -nfs $GOROOT/go/misc/nacl/go_nacl_amd64p32_exec $GOPATH/bin/go_nacl_amd64p32_exec
 	% ln -nfs $GOROOT/go/misc/nacl/go_nacl_386_exec $GOPATH/bin/go_nacl_386_exec
@@ -50,17 +66,28 @@ Symlink the two scripts in this directory into your $PATH, just as you did with
 Building and testing
 --------------------
 
-Building for NaCl is similar to cross compiling for other platforms. However, as it is not possible to ever build in a `native` NaCl environment, the cmd/go tool has been enhanced to allow the full build, all.bash, to be executed, rather than just the compile stage, make.bash.
+Building for NaCl is similar to cross compiling for other platforms. However,
+as it is not possible to ever build in a `native` NaCl environment, the cmd/go
+tool has been enhanced to allow the full build, all.bash, to be executed,
+rather than just the compile stage, make.bash.
 
-The cmd/go tool knows that if GOOS is set to `nacl` it should not try to execute any binaries itself. Instead it passes their execution to a support script which sets up a Native Client environment and invokes the NaCl sandbox.
+The cmd/go tool knows that if GOOS is set to `nacl` it should not try to
+execute any binaries itself. Instead it passes their execution to a support
+script which sets up a Native Client environment and invokes the NaCl sandbox.
 
-The script's name has a special format, go_$GOOS_$GOARCH_exec, so cmd/go can find it.
+The script's name has a special format, go_$GOOS_$GOARCH_exec, so cmd/go can
+find it.
 
-In short, if the support scripts are in place, the cmd/go tool can be used as per normal.
+In short, if the support scripts are in place, the cmd/go tool can be used as
+per normal.
 
 # Build and test Go for NaCl
 
-NaCl does not permit direct file system access. Instead, package syscall provides a simulated file system served by in-memory data. The script nacltest.bash is the NaCl equivalent of all.bash. It builds NaCl with an in-memory file system containing files needed for tests, and then it runs the tests.
+NaCl does not permit direct file system access. Instead, package syscall
+provides a simulated file system served by in-memory data. The script
+nacltest.bash is the NaCl equivalent of all.bash. It builds NaCl with an
+in-memory file system containing files needed for tests, and then it runs the
+tests.
 
 	% cd go/src
 	% env GOARCH=amd64p32 ./nacltest.bash

From af403c08fcb848205466d1e4589f98df1984d0dd Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Thu, 7 Aug 2014 15:42:06 +1000
Subject: [PATCH 015/423] doc: document new ParseMultipartForm behavior

Fixes #8403.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/123860043
---
 doc/go1.3.html | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/go1.3.html b/doc/go1.3.html
index 0d2bda122d..042de1bc7b 100644
--- a/doc/go1.3.html
+++ b/doc/go1.3.html
@@ -521,6 +521,15 @@ field to specify an end-to-end timeout on requests made using the
 client.
 </li>
 
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>
+method will now return an error if the body's <code>Content-Type</code>
+is not <code>mutipart/form-data</code>.
+Prior to Go 1.3 it would silently fail and return <code>nil</code>.
+Code that relies on the previous behavior should be updated.
+</li>
+
 <li> In the <a href="/pkg/net/"><code>net</code></a> package,
 the <a href="/pkg/net/#Dialer"><code>Dialer</code></a> struct now
 has a <code>KeepAlive</code> option to specify a keep-alive period for the connection.

From 192bccbf33b7493b36989921c8a81ece41904aa5 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 7 Aug 2014 12:55:28 +0400
Subject: [PATCH 016/423] runtime: shrink stacks in parallel Shrinkstack does
 not touch normal heap anymore, so we can shink stacks concurrently with
 marking.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, khr, rlh, rsc
https://golang.org/cl/122130043
---
 src/pkg/runtime/mgc0.c | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 01e055cf04..16d616b3f6 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -559,6 +559,8 @@ markroot(ParFor *desc, uint32 i)
 		// needed only to output in traceback
 		if((gp->status == Gwaiting || gp->status == Gsyscall) && gp->waitsince == 0)
 			gp->waitsince = work.tstart;
+		// Shrink a stack if not much of it is being used.
+		runtime·shrinkstack(gp);
 		scanstack(gp);
 		break;
 		
@@ -1391,7 +1393,6 @@ gc(struct gc_args *args)
 	int64 t0, t1, t2, t3, t4;
 	uint64 heap0, heap1, obj;
 	GCStats stats;
-	uint32 i;
 
 	if(runtime·debug.allocfreetrace)
 		runtime·tracegc();
@@ -1514,11 +1515,6 @@ gc(struct gc_args *args)
 			sweep.npausesweep++;
 	}
 
-	// Shrink a stack if not much of it is being used.
-	// TODO: do in a parfor
-	for(i = 0; i < runtime·allglen; i++)
-		runtime·shrinkstack(runtime·allg[i]);
-
 	runtime·MProf_GC();
 	g->m->traceback = 0;
 }

From cd2f8356ce5515c87710bc7ababfee8fdbdee9c3 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 7 Aug 2014 13:04:04 +0400
Subject: [PATCH 017/423] runtime: remove mal/malloc/FlagNoGC/FlagNoInvokeGC
 FlagNoGC is unused now. FlagNoInvokeGC is unneeded as we don't invoke GC on
 g0 and when holding locks anyway. mal/malloc have very few uses and you never
 remember the exact set of flags they use and the difference between them.
 Moreover, eventually we need to give exact types to all allocations,
 something what mal/malloc do not support.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rsc
https://golang.org/cl/117580043
---
 src/pkg/runtime/cgo/callbacks.c |  4 ++--
 src/pkg/runtime/env_posix.c     |  4 ++--
 src/pkg/runtime/heapdump.c      |  2 --
 src/pkg/runtime/malloc.c        | 12 ------------
 src/pkg/runtime/malloc.go       |  5 ++---
 src/pkg/runtime/malloc.h        |  5 +----
 src/pkg/runtime/mgc0.c          |  4 ++--
 src/pkg/runtime/panic.c         |  2 +-
 src/pkg/runtime/parfor.c        |  2 +-
 src/pkg/runtime/proc.c          |  6 +++---
 src/pkg/runtime/runtime.c       |  4 ++--
 src/pkg/runtime/runtime.h       |  3 +--
 src/pkg/runtime/time.goc        |  2 +-
 13 files changed, 18 insertions(+), 37 deletions(-)

diff --git a/src/pkg/runtime/cgo/callbacks.c b/src/pkg/runtime/cgo/callbacks.c
index 5a4889c9b3..954a1cdcc3 100644
--- a/src/pkg/runtime/cgo/callbacks.c
+++ b/src/pkg/runtime/cgo/callbacks.c
@@ -38,8 +38,8 @@ _cgo_allocate_internal(uintptr len, byte *ret)
 {
 	CgoMal *c;
 
-	ret = runtime·mal(len);
-	c = runtime·mal(sizeof(*c));
+	ret = runtime·mallocgc(len, nil, 0);
+	c = runtime·mallocgc(sizeof(*c), nil, 0);
 	c->next = g->m->cgomal;
 	c->alloc = ret;
 	g->m->cgomal = c;
diff --git a/src/pkg/runtime/env_posix.c b/src/pkg/runtime/env_posix.c
index 9b3583ce8b..edd1d3568d 100644
--- a/src/pkg/runtime/env_posix.c
+++ b/src/pkg/runtime/env_posix.c
@@ -50,11 +50,11 @@ syscall·setenv_c(String k, String v)
 	if(_cgo_setenv == nil)
 		return;
 
-	arg[0] = runtime·malloc(k.len + 1);
+	arg[0] = runtime·mallocgc(k.len + 1, nil, 0);
 	runtime·memmove(arg[0], k.str, k.len);
 	arg[0][k.len] = 0;
 
-	arg[1] = runtime·malloc(v.len + 1);
+	arg[1] = runtime·mallocgc(v.len + 1, nil, 0);
 	runtime·memmove(arg[1], v.str, v.len);
 	arg[1][v.len] = 0;
 
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index eec34f2cb7..9e968a250e 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -544,8 +544,6 @@ dumpobjs(void)
 			bitp = (uintptr*)runtime·mheap.arena_start - off/wordsPerBitmapWord - 1;
 			shift = (off % wordsPerBitmapWord) * gcBits;
 			bits = (*bitp >> shift) & bitMask;
-
-			// Skip FlagNoGC allocations (stacks)
 			if(bits != bitAllocated)
 				continue;
 			dumpobj(p, size, makeheapobjbv(p, size));
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 951117622f..be3280e0f1 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -35,12 +35,6 @@ runtime·mallocgc(uintptr size, Type *typ, uint32 flag)
 	return ret;
 }
 
-void*
-runtime·malloc(uintptr size)
-{
-	return runtime·mallocgc(size, nil, FlagNoInvokeGC);
-}
-
 int32
 runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **sp)
 {
@@ -399,12 +393,6 @@ runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat)
 
 // Runtime stubs.
 
-void*
-runtime·mal(uintptr n)
-{
-	return runtime·mallocgc(n, nil, 0);
-}
-
 static void*
 cnew(Type *typ, intgo n)
 {
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 81769573c9..e7f23889af 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -11,8 +11,7 @@ import (
 const (
 	flagNoScan      = 1 << 0 // GC doesn't have to scan object
 	flagNoProfiling = 1 << 1 // must not profile
-	flagNoZero      = 1 << 3 // don't zero memory
-	flagNoInvokeGC  = 1 << 4 // don't invoke GC
+	flagNoZero      = 1 << 2 // don't zero memory
 
 	kindArray      = 17
 	kindFunc       = 19
@@ -198,7 +197,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 
 	releasem(mp)
 
-	if flags&flagNoInvokeGC == 0 && memstats.heap_alloc >= memstats.next_gc {
+	if memstats.heap_alloc >= memstats.next_gc {
 		gogc(0)
 	}
 
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 1e26509bd9..43feef79ed 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -513,7 +513,6 @@ void	runtime·MHeap_MapBits(MHeap *h);
 void	runtime·MHeap_MapSpans(MHeap *h);
 void	runtime·MHeap_Scavenger(void);
 
-void*	runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void*	runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat);
 int32	runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **s);
 void	runtime·gc(int32 force);
@@ -537,9 +536,7 @@ enum
 	// flags to malloc
 	FlagNoScan	= 1<<0,	// GC doesn't have to scan object
 	FlagNoProfiling	= 1<<1,	// must not profile
-	FlagNoGC	= 1<<2,	// must not free or scan for pointers
-	FlagNoZero	= 1<<3, // don't zero memory
-	FlagNoInvokeGC	= 1<<4, // don't invoke GC
+	FlagNoZero	= 1<<2, // don't zero memory
 };
 
 void	runtime·MProf_Malloc(void*, uintptr);
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 16d616b3f6..4637d68bce 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -966,7 +966,7 @@ runtime·MSpan_Sweep(MSpan *s)
 		xbits = *bitp;
 		bits = (xbits>>shift) & bitMask;
 
-		// Non-allocated or FlagNoGC object, ignore.
+		// Non-allocated object, ignore.
 		if(bits == bitBoundary)
 			continue;
 		// Allocated and marked object, reset bits to allocated.
@@ -1659,7 +1659,7 @@ runfinq(void)
 					// all not yet finalized objects are stored in finq.
 					// If we do not mark it as FlagNoScan,
 					// the last finalized object is not collected.
-					frame = runtime·mallocgc(framesz, 0, FlagNoScan|FlagNoInvokeGC);
+					frame = runtime·mallocgc(framesz, 0, FlagNoScan);
 					framecap = framesz;
 				}
 				if(f->fint == nil)
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index af8bb1bc0e..bc685398a6 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -42,7 +42,7 @@ newdefer(int32 siz)
 	if(d == nil) {
 		// deferpool is empty or just a big defer
 		total = runtime·roundupsize(TOTALSIZE(siz));
-		d = runtime·malloc(total);
+		d = runtime·mallocgc(total, nil, 0);
 	}
 	d->siz = siz;
 	d->special = 0;
diff --git a/src/pkg/runtime/parfor.c b/src/pkg/runtime/parfor.c
index 4706e0a43a..1073dfa394 100644
--- a/src/pkg/runtime/parfor.c
+++ b/src/pkg/runtime/parfor.c
@@ -27,7 +27,7 @@ runtime·parforalloc(uint32 nthrmax)
 
 	// The ParFor object is followed by CacheLineSize padding
 	// and then nthrmax ParForThread.
-	desc = (ParFor*)runtime·malloc(sizeof(ParFor) + CacheLineSize + nthrmax * sizeof(ParForThread));
+	desc = (ParFor*)runtime·mallocgc(sizeof(ParFor) + CacheLineSize + nthrmax * sizeof(ParForThread), nil, 0);
 	desc->thr = (ParForThread*)((byte*)(desc+1) + CacheLineSize);
 	desc->nthrmax = nthrmax;
 	return desc;
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 26e687e3b4..137f49f5f0 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -183,7 +183,7 @@ runtime·schedinit(void)
 			n = MaxGomaxprocs;
 		procs = n;
 	}
-	runtime·allp = runtime·malloc((MaxGomaxprocs+1)*sizeof(runtime·allp[0]));
+	runtime·allp = runtime·mallocgc((MaxGomaxprocs+1)*sizeof(runtime·allp[0]), nil, 0);
 	procresize(procs);
 
 	runtime·copystack = runtime·precisestack;
@@ -1926,7 +1926,7 @@ allgadd(G *gp)
 		cap = 4096/sizeof(new[0]);
 		if(cap < 2*allgcap)
 			cap = 2*allgcap;
-		new = runtime·malloc(cap*sizeof(new[0]));
+		new = runtime·mallocgc(cap*sizeof(new[0]), nil, 0);
 		if(new == nil)
 			runtime·throw("runtime: cannot allocate memory");
 		if(runtime·allg != nil)
@@ -2396,7 +2396,7 @@ procresize(int32 new)
 	for(i = 0; i < new; i++) {
 		p = runtime·allp[i];
 		if(p == nil) {
-			p = (P*)runtime·mallocgc(sizeof(*p), 0, FlagNoInvokeGC);
+			p = (P*)runtime·mallocgc(sizeof(*p), 0, 0);
 			p->id = i;
 			p->status = Pgcstop;
 			runtime·atomicstorep(&runtime·allp[i], p);
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 31b853c87a..98c9edda41 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -111,7 +111,7 @@ runtime·goargs(void)
 	if(Windows)
 		return;
 
-	s = runtime·malloc(argc*sizeof s[0]);
+	s = runtime·mallocgc(argc*sizeof s[0], nil, 0);
 	for(i=0; i<argc; i++)
 		s[i] = runtime·gostringnocopy(argv[i]);
 	os·Args.array = (byte*)s;
@@ -128,7 +128,7 @@ runtime·goenvs_unix(void)
 	for(n=0; argv[argc+1+n] != 0; n++)
 		;
 
-	s = runtime·malloc(n*sizeof s[0]);
+	s = runtime·mallocgc(n*sizeof s[0], nil, 0);
 	for(i=0; i<n; i++)
 		s[i] = runtime·gostringnocopy(argv[argc+1+i]);
 	syscall·envs.array = (byte*)s;
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 1d1618b0d6..1687b85c44 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -829,7 +829,6 @@ int32	runtime·snprintf(byte*, int32, int8*, ...);
 byte*	runtime·mchr(byte*, byte, byte*);
 int32	runtime·mcmp(byte*, byte*, uintptr);
 void	runtime·memmove(void*, void*, uintptr);
-void*	runtime·mal(uintptr);
 String	runtime·catstring(String, String);
 String	runtime·gostring(byte*);
 String  runtime·gostringn(byte*, intgo);
@@ -876,7 +875,7 @@ void	runtime·mallocinit(void);
 void	runtime·chaninit(void);
 bool	runtime·ifaceeq_c(Iface, Iface);
 bool	runtime·efaceeq_c(Eface, Eface);
-void*	runtime·malloc(uintptr size);
+void*	runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void	runtime·runpanic(Panic*);
 uintptr	runtime·getcallersp(void*);
 int32	runtime·mcount(void);
diff --git a/src/pkg/runtime/time.goc b/src/pkg/runtime/time.goc
index 791e4eb02b..10b8cea0ab 100644
--- a/src/pkg/runtime/time.goc
+++ b/src/pkg/runtime/time.goc
@@ -125,7 +125,7 @@ addtimer(Timer *t)
 		n = 16;
 		if(n <= timers.cap)
 			n = timers.cap*3 / 2;
-		nt = runtime·malloc(n*sizeof nt[0]);
+		nt = runtime·mallocgc(n*sizeof nt[0], nil, 0);
 		runtime·memmove(nt, timers.t, timers.len*sizeof nt[0]);
 		timers.t = nt;
 		timers.cap = n;

From c5b2c370c635c9c1e512fab4b38416c35b7a45ce Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 7 Aug 2014 13:28:10 +0400
Subject: [PATCH 018/423] runtime: fix plan9/windows build Fix few remaining
 cases after cl/117580043.

TBR=dfc
R=golang-codereviews
CC=dave, golang-codereviews
https://golang.org/cl/124850043
---
 src/pkg/runtime/callback_windows.c | 2 +-
 src/pkg/runtime/env_plan9.c        | 2 +-
 src/pkg/runtime/os_plan9.c         | 4 ++--
 src/pkg/runtime/os_windows.c       | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/callback_windows.c b/src/pkg/runtime/callback_windows.c
index 285678fbac..97b75e1d2c 100644
--- a/src/pkg/runtime/callback_windows.c
+++ b/src/pkg/runtime/callback_windows.c
@@ -60,7 +60,7 @@ runtime·compilecallback(Eface fn, bool cleanstack)
 	}
 	if(n >= cb_max)
 		runtime·throw("too many callback functions");
-	c = runtime·mal(sizeof *c);
+	c = runtime·mallocgc(sizeof *c, nil, 0);
 	c->gobody = fn.data;
 	c->argsize = argsize;
 	c->cleanstack = cleanstack;
diff --git a/src/pkg/runtime/env_plan9.c b/src/pkg/runtime/env_plan9.c
index f732c9f294..b6e98514f3 100644
--- a/src/pkg/runtime/env_plan9.c
+++ b/src/pkg/runtime/env_plan9.c
@@ -33,7 +33,7 @@ runtime·getenv(int8 *s)
 		runtime·memclr(b, sizeof b);
 		p = b;
 	}else
-		p = runtime·malloc(n+1);
+		p = runtime·mallocgc(n+1, nil, 0);
 	r = runtime·pread(fd, p, n, 0);
 	runtime·close(fd);
 	if(r < 0)
diff --git a/src/pkg/runtime/os_plan9.c b/src/pkg/runtime/os_plan9.c
index 02723fd9e4..98e449251a 100644
--- a/src/pkg/runtime/os_plan9.c
+++ b/src/pkg/runtime/os_plan9.c
@@ -20,11 +20,11 @@ runtime·mpreinit(M *mp)
 	// Initialize stack and goroutine for note handling.
 	mp->gsignal = runtime·malg(32*1024);
 	mp->gsignal->m = mp;
-	mp->notesig = (int8*)runtime·malloc(ERRMAX*sizeof(int8));
+	mp->notesig = (int8*)runtime·mallocgc(ERRMAX*sizeof(int8), nil, 0);
 
 	// Initialize stack for handling strings from the
 	// errstr system call, as used in package syscall.
-	mp->errstr = (byte*)runtime·malloc(ERRMAX*sizeof(byte));
+	mp->errstr = (byte*)runtime·mallocgc(ERRMAX*sizeof(byte), nil, 0);
 }
 
 // Called to initialize a new m (including the bootstrap m).
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 1dc0780ba9..79dc2960f9 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -143,7 +143,7 @@ runtime·goenvs(void)
 	for(p=env; *p; n++)
 		p += runtime·findnullw(p)+1;
 
-	s = runtime·malloc(n*sizeof s[0]);
+	s = runtime·mallocgc(n*sizeof s[0], nil, 0);
 
 	p = env;
 	for(i=0; i<n; i++) {

From aac7f1a0d68984f3c776e90f775a7de9649f1a12 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 7 Aug 2014 13:34:30 +0400
Subject: [PATCH 019/423] runtime: convert markallocated from C to Go

benchmark                      old ns/op     new ns/op     delta
BenchmarkMalloc8               28.7          22.4          -21.95%
BenchmarkMalloc16              44.8          33.8          -24.55%
BenchmarkMallocTypeInfo8       49.0          32.9          -32.86%
BenchmarkMallocTypeInfo16      46.7          35.8          -23.34%
BenchmarkMallocLargeStruct     907           901           -0.66%
BenchmarkGobDecode             13235542      12036851      -9.06%
BenchmarkGobEncode             10639699      9539155       -10.34%
BenchmarkJSONEncode            25193036      21898922      -13.08%
BenchmarkJSONDecode            96104044      89464904      -6.91%

Fixes #8452.

LGTM=khr
R=golang-codereviews, bradfitz, rsc, dave, khr
CC=golang-codereviews
https://golang.org/cl/122090043
---
 src/pkg/runtime/malloc.go | 130 ++++++++++++++++++++++++++++++++++++--
 src/pkg/runtime/malloc.h  |   1 -
 src/pkg/runtime/mgc0.c    | 129 ++++++-------------------------------
 src/pkg/runtime/stubs.go  |  11 +++-
 src/pkg/runtime/stubs.goc |  10 +++
 5 files changed, 161 insertions(+), 120 deletions(-)

diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index e7f23889af..73dc9f20d6 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -9,6 +9,8 @@ import (
 )
 
 const (
+	debugMalloc = false
+
 	flagNoScan      = 1 << 0 // GC doesn't have to scan object
 	flagNoProfiling = 1 << 1 // must not profile
 	flagNoZero      = 1 << 2 // don't zero memory
@@ -29,6 +31,22 @@ const (
 	pageShift = 13
 	pageSize  = 1 << pageShift
 	pageMask  = pageSize - 1
+
+	wordsPerBitmapWord = ptrSize * 8 / 4
+	gcBits             = 4
+	bitsPerPointer     = 2
+	bitsMask           = 1<<bitsPerPointer - 1
+	pointersPerByte    = 8 / bitsPerPointer
+	bitPtrMask         = bitsMask << 2
+	maxGCMask          = 0 // disabled because wastes several bytes of memory
+	bitsDead           = 0
+	bitsPointer        = 2
+
+	bitMiddle    = 0
+	bitBoundary  = 1
+	bitAllocated = 2
+	bitMarked    = 3
+	bitMask      = bitMiddle | bitBoundary | bitAllocated | bitMarked
 )
 
 // All zero-sized allocations return a pointer to this byte.
@@ -168,14 +186,112 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		size = uintptr(s.elemsize)
 	}
 
-	// TODO: write markallocated in Go
-	mp.ptrarg[0] = x
-	mp.scalararg[0] = uint(size)
-	mp.scalararg[1] = uint(size0)
-	mp.ptrarg[1] = unsafe.Pointer(typ)
-	mp.scalararg[2] = uint(flags & flagNoScan)
-	onM(&markallocated_m)
+	// From here till marked label marking the object as allocated
+	// and storing type info in the GC bitmap.
+	arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
+	off := (uintptr(x) - arena_start) / ptrSize
+	xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
+	shift := (off % wordsPerBitmapWord) * gcBits
+	if debugMalloc && (((*xbits)>>shift)&bitMask) != bitBoundary {
+		gothrow("bad bits in markallocated")
+	}
 
+	var ti, te uintptr
+	var ptrmask *uint8
+	if flags&flagNoScan != 0 {
+		// bitsDead in the first quadruple means don't scan.
+		if size == ptrSize {
+			*xbits = (*xbits & ^((bitBoundary | bitPtrMask) << shift)) | ((bitAllocated + (bitsDead << 2)) << shift)
+		} else {
+			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+			*xbitsb = bitAllocated + (bitsDead << 2)
+		}
+		goto marked
+	}
+	if size == ptrSize {
+		// It's one word and it has pointers, it must be a pointer.
+		*xbits = (*xbits & ^((bitBoundary | bitPtrMask) << shift)) | ((bitAllocated | (bitsPointer << 2)) << shift)
+		goto marked
+	}
+	if typ != nil && (uintptr(typ.gc[0])|uintptr(typ.gc[1])) != 0 && uintptr(typ.size) > ptrSize {
+		if typ.kind&kindGCProg != 0 {
+			nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
+			masksize := nptr
+			if masksize%2 != 0 {
+				masksize *= 2 // repeated
+			}
+			masksize = masksize * pointersPerByte / 8 // 4 bits per word
+			masksize++                                // unroll flag in the beginning
+			if masksize > maxGCMask && typ.gc[1] != 0 {
+				// If the mask is too large, unroll the program directly
+				// into the GC bitmap. It's 7 times slower than copying
+				// from the pre-unrolled mask, but saves 1/16 of type size
+				// memory for the mask.
+				mp.ptrarg[0] = x
+				mp.ptrarg[1] = unsafe.Pointer(typ)
+				mp.scalararg[0] = uint(size)
+				mp.scalararg[1] = uint(size0)
+				onM(&unrollgcproginplace_m)
+				goto marked
+			}
+			ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
+			// Check whether the program is already unrolled.
+			if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
+				mp.ptrarg[0] = unsafe.Pointer(typ)
+				onM(&unrollgcprog_m)
+			}
+			ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
+		} else {
+			ptrmask = (*uint8)(unsafe.Pointer(&typ.gc[0])) // embed mask
+		}
+		if size == 2*ptrSize {
+			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+			*xbitsb = *ptrmask | bitAllocated
+			goto marked
+		}
+		te = uintptr(typ.size) / ptrSize
+		// If the type occupies odd number of words, its mask is repeated.
+		if te%2 == 0 {
+			te /= 2
+		}
+	}
+	if size == 2*ptrSize {
+		xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+		*xbitsb = (bitsPointer << 2) | (bitsPointer << 6) | bitAllocated
+		goto marked
+	}
+	// Copy pointer bitmask into the bitmap.
+	for i := uintptr(0); i < size0; i += 2 * ptrSize {
+		v := uint8((bitsPointer << 2) | (bitsPointer << 6))
+		if ptrmask != nil {
+			v = *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
+			ti++
+			if ti == te {
+				ti = 0
+			}
+		}
+		if i == 0 {
+			v |= bitAllocated
+		}
+		if i+ptrSize == size0 {
+			v &= ^uint8(bitPtrMask << 4)
+		}
+
+		off := (uintptr(x) + i - arena_start) / ptrSize
+		xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
+		shift := (off % wordsPerBitmapWord) * gcBits
+		xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+		*xbitsb = v
+	}
+	if size0%(2*ptrSize) == 0 && size0 < size {
+		// Mark the word after last object's word as bitsDead.
+		off := (uintptr(x) + size0 - arena_start) / ptrSize
+		xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
+		shift := (off % wordsPerBitmapWord) * gcBits
+		xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+		*xbitsb = bitsDead << 2
+	}
+marked:
 	mp.mallocing = 0
 
 	if raceenabled {
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 43feef79ed..4b16c55536 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -517,7 +517,6 @@ void*	runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat);
 int32	runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **s);
 void	runtime·gc(int32 force);
 uintptr	runtime·sweepone(void);
-void	runtime·markallocated(void *v, uintptr size, uintptr size0, Type* typ, bool scan);
 void	runtime·markspan(void *v, uintptr size, uintptr n, bool leftover);
 void	runtime·unmarkspan(void *v, uintptr size);
 void	runtime·purgecachedstats(MCache*);
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 4637d68bce..8998a871ae 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1741,7 +1741,7 @@ runtime·wakefing(void)
 	return res;
 }
 
-// Recursively GC program in prog.
+// Recursively unrolls GC program in prog.
 // mask is where to store the result.
 // ppos is a pointer to position in mask, in bits.
 // sparse says to generate 4-bits per word mask for heap (2-bits for data/bss otherwise).
@@ -1833,11 +1833,20 @@ unrollglobgcprog(byte *prog, uintptr size)
 	return mask;
 }
 
-static void
-unrollgcproginplace(void *v, uintptr size, uintptr size0, Type *typ)
+void
+runtime·unrollgcproginplace_m(void)
 {
-	uintptr *b, off, shift, pos;
+	uintptr size, size0, *b, off, shift, pos;
 	byte *arena_start, *prog;
+	Type *typ;
+	void *v;
+
+	v = g->m->ptrarg[0];
+	typ = g->m->ptrarg[1];
+	size = g->m->scalararg[0];
+	size0 = g->m->scalararg[1];
+	g->m->ptrarg[0] = nil;
+	g->m->ptrarg[1] = nil;
 
 	pos = 0;
 	prog = (byte*)typ->gc[1];
@@ -1859,14 +1868,18 @@ unrollgcproginplace(void *v, uintptr size, uintptr size0, Type *typ)
 }
 
 // Unrolls GC program in typ->gc[1] into typ->gc[0]
-static void
-unrollgcprog(Type *typ)
+void
+runtime·unrollgcprog_m(void)
 {
 	static Lock lock;
+	Type *typ;
 	byte *mask, *prog;
 	uintptr pos;
 	uint32 x;
 
+	typ = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+
 	runtime·lock(&lock);
 	mask = (byte*)typ->gc[0];
 	if(mask[0] == 0) {
@@ -1887,110 +1900,6 @@ unrollgcprog(Type *typ)
 	runtime·unlock(&lock);
 }
 
-void
-runtime·markallocated(void *v, uintptr size, uintptr size0, Type *typ, bool scan)
-{
-	uintptr *b, off, shift, i, ti, te, nptr, masksize;
-	byte *arena_start, x;
-	bool *ptrmask;
-
-	arena_start = runtime·mheap.arena_start;
-	off = (uintptr*)v - (uintptr*)arena_start;
-	b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-	shift = (off % wordsPerBitmapWord) * gcBits;
-	if(Debug && (((*b)>>shift)&bitMask) != bitBoundary) {
-		runtime·printf("runtime: bad bits in markallocated (%p) b=%p[%p]\n", v, b, *b);
-		runtime·throw("bad bits in markallocated");
-	}
-
-	if(!scan) {
-		// BitsDead in the first quadruple means don't scan.
-		if(size == PtrSize)
-			*b = (*b & ~((bitBoundary|bitPtrMask)<<shift)) | ((bitAllocated+(BitsDead<<2))<<shift);
-		else
-			((byte*)b)[shift/8] = bitAllocated+(BitsDead<<2);
-		return;
-	}
-	if(size == PtrSize) {
-		// It's one word and it has pointers, it must be a pointer.
-		*b = (*b & ~((bitBoundary|bitPtrMask)<<shift)) | ((bitAllocated | (BitsPointer<<2))<<shift);
-		return;
-	}
-	ti = te = 0;
-	ptrmask = nil;
-	if(typ != nil && (typ->gc[0]|typ->gc[1]) != 0 && typ->size > PtrSize) {
-		if(typ->kind&KindGCProg) {
-			nptr = ROUND(typ->size, PtrSize)/PtrSize;
-			masksize = nptr;
-			if(masksize%2)
-				masksize *= 2;	// repeated twice
-			masksize = masksize*PointersPerByte/8;	// 4 bits per word
-			masksize++;	// unroll flag in the beginning
-			if(masksize > MaxGCMask && typ->gc[1] != 0) {
-				// If the mask is too large, unroll the program directly
-				// into the GC bitmap. It's 7 times slower than copying
-				// from the pre-unrolled mask, but saves 1/16 of type size
-				// memory for the mask.
-				unrollgcproginplace(v, size, size0, typ);
-				return;
-			}
-			ptrmask = (byte*)typ->gc[0];
-			// check whether the program is already unrolled
-			if((runtime·atomicload((uint32*)ptrmask)&0xff) == 0)
-				unrollgcprog(typ);
-			ptrmask++;  // skip the unroll flag byte
-		} else
-			ptrmask = (byte*)&typ->gc[0];  // embed mask
-		if(size == 2*PtrSize) {
-			((byte*)b)[shift/8] = ptrmask[0] | bitAllocated;
-			return;
-		}
-		te = typ->size/PtrSize;
-		// if the type occupies odd number of words, its mask is repeated twice
-		if((te%2) == 0)
-			te /= 2;
-	}
-	if(size == 2*PtrSize) {
-		((byte*)b)[shift/8] = (BitsPointer<<2) | (BitsPointer<<6) | bitAllocated;
-		return;
-	}
-	// Copy pointer bitmask into the bitmap.
-	for(i=0; i<size0; i+=2*PtrSize) {
-		x = (BitsPointer<<2) | (BitsPointer<<6);
-		if(ptrmask != nil) {
-			x = ptrmask[ti++];
-			if(ti == te)
-				ti = 0;
-		}
-		off = (uintptr*)((byte*)v + i) - (uintptr*)arena_start;
-		b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
-		if(i == 0)
-			x |= bitAllocated;
-		if(i+PtrSize == size0)
-			x &= ~(bitPtrMask<<4);
-		((byte*)b)[shift/8] = x;
-	}
-	if(size0 == i && size0 < size) {
-		// mark the word after last object's word as BitsDead
-		off = (uintptr*)((byte*)v + size0) - (uintptr*)arena_start;
-		b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
-		((byte*)b)[shift/8] = 0;
-	}
-}
-
-void
-runtime·markallocated_m(void)
-{
-	M *mp;
-
-	mp = g->m;
-	runtime·markallocated(mp->ptrarg[0], mp->scalararg[0], mp->scalararg[1], mp->ptrarg[1], mp->scalararg[2] == 0);
-	mp->ptrarg[0] = nil;
-	mp->ptrarg[1] = nil;
-}
-
 // mark the span of memory at v as having n blocks of the given size.
 // if leftover is true, there is left over space at the end of the span.
 void
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 8a2fc8a97e..fee18f0470 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -65,7 +65,9 @@ var (
 	mprofMalloc_m,
 	gc_m,
 	setFinalizer_m,
-	markallocated_m mFunction
+	markallocated_m,
+	unrollgcprog_m,
+	unrollgcproginplace_m mFunction
 )
 
 // memclr clears n bytes starting at ptr.
@@ -87,7 +89,12 @@ const (
 	concurrentSweep  = true
 )
 
-// in asm_*.s
+// Atomic operations to read/write a pointer.
+// in stubs.goc
+func goatomicloadp(p unsafe.Pointer) unsafe.Pointer     // return *p
+func goatomicstorep(p unsafe.Pointer, v unsafe.Pointer) // *p = v
+
+// in stubs.goc
 // if *p == x { *p = y; return true } else { return false }, atomically
 //go:noescape
 func gocas(p *uint32, x uint32, y uint32) bool
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index c64e73de05..42a4bf1434 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -48,6 +48,16 @@ func gonanotime() (r int64) {
 	r = runtime·nanotime();
 }
 
+#pragma textflag NOSPLIT
+func goatomicloadp(p **byte) (v *byte) {
+	v = runtime·atomicloadp(p);
+}
+
+#pragma textflag NOSPLIT
+func goatomicstorep(p **byte, v *byte) {
+	runtime·atomicstorep(p, v);
+}
+
 #pragma textflag NOSPLIT
 func runtime·gocas(p *uint32, x uint32, y uint32) (ret bool) {
 	ret = runtime·cas(p, x, y);

From 689995a73e7a03038e977b5080666b561173e2b6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 7 Aug 2014 08:17:41 -0400
Subject: [PATCH 020/423] cmd/gc: remove ignored debugging arguments in Fconv
 print

LGTM=dave
R=golang-codereviews, dave
CC=golang-codereviews
https://golang.org/cl/123880043
---
 src/cmd/gc/mparith1.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/gc/mparith1.c b/src/cmd/gc/mparith1.c
index 1519caec7a..d33a81e09d 100644
--- a/src/cmd/gc/mparith1.c
+++ b/src/cmd/gc/mparith1.c
@@ -591,7 +591,7 @@ Fconv(Fmt *fp)
 			d = mpgetflt(fvp);
 			if(d >= 0 && (fp->flags & FmtSign))
 				fmtprint(fp, "+");
-			return fmtprint(fp, "%g", d, exp, fvp);
+			return fmtprint(fp, "%g", d);
 		}
 		
 		// very out of range. compute decimal approximation by hand.

From 6cee4d3e8f52d4ab5ba2f97ca58f11d5e4c29fd4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 7 Aug 2014 08:58:25 -0400
Subject: [PATCH 021/423] os: in Getwd, $PWD override syscall.Getwd

This makes os.Getwd mimic C getwd on OS X,
and possibly other systems. The change on OS X
was a regression from 1.2 to 1.3.

Fixes #8400.

LGTM=bradfitz
R=iant, bradfitz
CC=golang-codereviews
https://golang.org/cl/118970043
---
 src/pkg/os/getwd.go   | 23 +++++++++++------------
 src/pkg/os/os_test.go |  9 +++++++--
 2 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/pkg/os/getwd.go b/src/pkg/os/getwd.go
index a72edeaee6..eacb414660 100644
--- a/src/pkg/os/getwd.go
+++ b/src/pkg/os/getwd.go
@@ -23,22 +23,12 @@ var useSyscallwd = func(error) bool { return true }
 // reached via multiple paths (due to symbolic links),
 // Getwd may return any one of them.
 func Getwd() (dir string, err error) {
-	// If the operating system provides a Getwd call, use it.
-	if syscall.ImplementsGetwd {
-		s, e := syscall.Getwd()
-		if useSyscallwd(e) {
-			return s, NewSyscallError("getwd", e)
-		}
-	}
-
-	// Otherwise, we're trying to find our way back to ".".
+	// Clumsy but widespread kludge:
+	// if $PWD is set and matches ".", use it.
 	dot, err := Stat(".")
 	if err != nil {
 		return "", err
 	}
-
-	// Clumsy but widespread kludge:
-	// if $PWD is set and matches ".", use it.
 	dir = Getenv("PWD")
 	if len(dir) > 0 && dir[0] == '/' {
 		d, err := Stat(dir)
@@ -47,6 +37,15 @@ func Getwd() (dir string, err error) {
 		}
 	}
 
+	// If the operating system provides a Getwd call, use it.
+	// Otherwise, we're trying to find our way back to ".".
+	if syscall.ImplementsGetwd {
+		s, e := syscall.Getwd()
+		if useSyscallwd(e) {
+			return s, NewSyscallError("getwd", e)
+		}
+	}
+
 	// Apply same kludge but to cached dir instead of $PWD.
 	getwdCache.Lock()
 	dir = getwdCache.dir
diff --git a/src/pkg/os/os_test.go b/src/pkg/os/os_test.go
index 2811f29f34..0224c9b01d 100644
--- a/src/pkg/os/os_test.go
+++ b/src/pkg/os/os_test.go
@@ -811,8 +811,8 @@ func TestChdirAndGetwd(t *testing.T) {
 		t.Fatalf("Open .: %s", err)
 	}
 	// These are chosen carefully not to be symlinks on a Mac
-	// (unlike, say, /var, /etc, and /tmp).
-	dirs := []string{"/", "/usr/bin"}
+	// (unlike, say, /var, /etc), except /tmp, which we handle below.
+	dirs := []string{"/", "/usr/bin", "/tmp"}
 	// /usr/bin does not usually exist on Plan 9 or Android.
 	switch runtime.GOOS {
 	case "android":
@@ -820,6 +820,7 @@ func TestChdirAndGetwd(t *testing.T) {
 	case "plan9":
 		dirs = []string{"/", "/usr"}
 	}
+	oldwd := Getenv("PWD")
 	for mode := 0; mode < 2; mode++ {
 		for _, d := range dirs {
 			if mode == 0 {
@@ -833,7 +834,11 @@ func TestChdirAndGetwd(t *testing.T) {
 				err = fd1.Chdir()
 				fd1.Close()
 			}
+			if d == "/tmp" {
+				Setenv("PWD", "/tmp")
+			}
 			pwd, err1 := Getwd()
+			Setenv("PWD", oldwd)
 			err2 := fd.Chdir()
 			if err2 != nil {
 				// We changed the current directory and cannot go back.

From e03bce158fba5f13dd7f2f0a86a40eb14958300b Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Thu, 7 Aug 2014 09:00:02 -0400
Subject: [PATCH 022/423] cmd/cc, runtime: eliminate use of the unnamed
 substructure C extension

Eliminating use of this extension makes it easier to port the Go runtime
to other compilers. This CL also disables the extension in cc to prevent
accidental use.

LGTM=rsc, khr
R=rsc, aram, khr, dvyukov
CC=axwalk, golang-codereviews
https://golang.org/cl/106790044
---
 src/cmd/cc/dcl.c                   |   9 +-
 src/pkg/runtime/callback_windows.c |   8 +-
 src/pkg/runtime/chan.goc           |  54 ++--
 src/pkg/runtime/chan.h             |   2 +-
 src/pkg/runtime/defs_plan9_386.h   |   5 +-
 src/pkg/runtime/heapdump.c         |   4 +-
 src/pkg/runtime/iface.goc          |  14 +-
 src/pkg/runtime/malloc.c           |  12 +-
 src/pkg/runtime/malloc.h           |  10 +-
 src/pkg/runtime/mcache.c           |  12 +-
 src/pkg/runtime/mcentral.c         |  30 +--
 src/pkg/runtime/mgc0.c             |  20 +-
 src/pkg/runtime/mheap.c            |  38 +--
 src/pkg/runtime/mprof.goc          |  66 ++---
 src/pkg/runtime/mprof.h            |   6 +-
 src/pkg/runtime/netpoll.goc        |  36 +--
 src/pkg/runtime/proc.c             | 144 +++++-----
 src/pkg/runtime/runtime.h          |   4 +-
 src/pkg/runtime/sema.goc           |  32 +--
 src/pkg/runtime/sigqueue.goc       |  10 +-
 src/pkg/runtime/time.goc           |  24 +-
 src/pkg/runtime/type.h             |  12 +-
 src/pkg/runtime/vlrt_386.c         | 412 ++++++++++++++---------------
 src/pkg/runtime/vlrt_arm.c         |  27 +-
 24 files changed, 481 insertions(+), 510 deletions(-)

diff --git a/src/cmd/cc/dcl.c b/src/cmd/cc/dcl.c
index a7a9426865..051a6c0a74 100644
--- a/src/cmd/cc/dcl.c
+++ b/src/cmd/cc/dcl.c
@@ -1481,12 +1481,9 @@ edecl(int c, Type *t, Sym *s)
 {
 	Type *t1;
 
-	if(s == S) {
-		if(!typesu[t->etype])
-			diag(Z, "unnamed structure element must be struct/union");
-		if(c != CXXX)
-			diag(Z, "unnamed structure element cannot have class");
-	} else
+	if(s == S)
+		diag(Z, "unnamed structure elements not supported");
+	else
 		if(c != CXXX)
 			diag(Z, "structure element cannot have class: %s", s->name);
 	t1 = t;
diff --git a/src/pkg/runtime/callback_windows.c b/src/pkg/runtime/callback_windows.c
index 97b75e1d2c..f1283a85d6 100644
--- a/src/pkg/runtime/callback_windows.c
+++ b/src/pkg/runtime/callback_windows.c
@@ -11,7 +11,7 @@
 
 typedef	struct	Callbacks	Callbacks;
 struct	Callbacks {
-	Lock;
+	Lock			lock;
 	WinCallbackContext*	ctxt[cb_max];
 	int32			n;
 };
@@ -44,13 +44,13 @@ runtime·compilecallback(Eface fn, bool cleanstack)
 		argsize += sizeof(uintptr);
 	}
 
-	runtime·lock(&cbs);
+	runtime·lock(&cbs.lock);
 	if(runtime·cbctxts == nil)
 		runtime·cbctxts = &(cbs.ctxt[0]);
 	n = cbs.n;
 	for(i=0; i<n; i++) {
 		if(cbs.ctxt[i]->gobody == fn.data && cbs.ctxt[i]->cleanstack == cleanstack) {
-			runtime·unlock(&cbs);
+			runtime·unlock(&cbs.lock);
 			// runtime·callbackasm is just a series of CALL instructions
 			// (each is 5 bytes long), and we want callback to arrive at
 			// correspondent call instruction instead of start of
@@ -70,7 +70,7 @@ runtime·compilecallback(Eface fn, bool cleanstack)
 		c->restorestack = 0;
 	cbs.ctxt[n] = c;
 	cbs.n++;
-	runtime·unlock(&cbs);
+	runtime·unlock(&cbs.lock);
 
 	// as before
 	return (byte*)runtime·callbackasm + n * 5;
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index b3520b60fc..7ddfab3f99 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -136,7 +136,7 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 		mysg.releasetime = -1;
 	}
 
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 	if(raceenabled)
 		runtime·racereadpc(c, pc, chansend);
 	if(c->closed)
@@ -149,7 +149,7 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 	if(sg != nil) {
 		if(raceenabled)
 			racesync(c, sg);
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 
 		gp = sg->g;
 		gp->param = sg;
@@ -162,7 +162,7 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 	}
 
 	if(!block) {
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		return false;
 	}
 
@@ -171,10 +171,10 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 	mysg.selectdone = nil;
 	g->param = nil;
 	enqueue(&c->sendq, &mysg);
-	runtime·parkunlock(c, "chan send");
+	runtime·parkunlock(&c->lock, "chan send");
 
 	if(g->param == nil) {
-		runtime·lock(c);
+		runtime·lock(&c->lock);
 		if(!c->closed)
 			runtime·throw("chansend: spurious wakeup");
 		goto closed;
@@ -191,16 +191,16 @@ asynch:
 
 	if(c->qcount >= c->dataqsiz) {
 		if(!block) {
-			runtime·unlock(c);
+			runtime·unlock(&c->lock);
 			return false;
 		}
 		mysg.g = g;
 		mysg.elem = nil;
 		mysg.selectdone = nil;
 		enqueue(&c->sendq, &mysg);
-		runtime·parkunlock(c, "chan send");
+		runtime·parkunlock(&c->lock, "chan send");
 
-		runtime·lock(c);
+		runtime·lock(&c->lock);
 		goto asynch;
 	}
 
@@ -217,18 +217,18 @@ asynch:
 	sg = dequeue(&c->recvq);
 	if(sg != nil) {
 		gp = sg->g;
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		if(sg->releasetime)
 			sg->releasetime = runtime·cputicks();
 		runtime·ready(gp);
 	} else
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 	if(mysg.releasetime > 0)
 		runtime·blockevent(mysg.releasetime - t0, 2);
 	return true;
 
 closed:
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 	runtime·panicstring("send on closed channel");
 	return false;  // not reached
 }
@@ -262,7 +262,7 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 		mysg.releasetime = -1;
 	}
 
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 	if(c->dataqsiz > 0)
 		goto asynch;
 
@@ -273,7 +273,7 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 	if(sg != nil) {
 		if(raceenabled)
 			racesync(c, sg);
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 
 		if(ep != nil)
 			c->elemtype->alg->copy(c->elemsize, ep, sg->elem);
@@ -289,7 +289,7 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 	}
 
 	if(!block) {
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		return false;
 	}
 
@@ -298,10 +298,10 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 	mysg.selectdone = nil;
 	g->param = nil;
 	enqueue(&c->recvq, &mysg);
-	runtime·parkunlock(c, "chan receive");
+	runtime·parkunlock(&c->lock, "chan receive");
 
 	if(g->param == nil) {
-		runtime·lock(c);
+		runtime·lock(&c->lock);
 		if(!c->closed)
 			runtime·throw("chanrecv: spurious wakeup");
 		goto closed;
@@ -319,7 +319,7 @@ asynch:
 			goto closed;
 
 		if(!block) {
-			runtime·unlock(c);
+			runtime·unlock(&c->lock);
 			if(received != nil)
 				*received = false;
 			return false;
@@ -328,9 +328,9 @@ asynch:
 		mysg.elem = nil;
 		mysg.selectdone = nil;
 		enqueue(&c->recvq, &mysg);
-		runtime·parkunlock(c, "chan receive");
+		runtime·parkunlock(&c->lock, "chan receive");
 
-		runtime·lock(c);
+		runtime·lock(&c->lock);
 		goto asynch;
 	}
 
@@ -349,12 +349,12 @@ asynch:
 	sg = dequeue(&c->sendq);
 	if(sg != nil) {
 		gp = sg->g;
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		if(sg->releasetime)
 			sg->releasetime = runtime·cputicks();
 		runtime·ready(gp);
 	} else
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 
 	if(received != nil)
 		*received = true;
@@ -369,7 +369,7 @@ closed:
 		*received = false;
 	if(raceenabled)
 		runtime·raceacquire(c);
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 	if(mysg.releasetime > 0)
 		runtime·blockevent(mysg.releasetime - t0, 2);
 	return true;
@@ -617,7 +617,7 @@ sellock(Select *sel)
 		c0 = sel->lockorder[i];
 		if(c0 && c0 != c) {
 			c = sel->lockorder[i];
-			runtime·lock(c);
+			runtime·lock(&c->lock);
 		}
 	}
 }
@@ -645,7 +645,7 @@ selunlock(Select *sel)
 		c = sel->lockorder[i];
 		if(i>0 && sel->lockorder[i-1] == c)
 			continue;  // will unlock it on the next iteration
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 	}
 }
 
@@ -1067,9 +1067,9 @@ closechan(Hchan *c, void *pc)
 	if(c == nil)
 		runtime·panicstring("close of nil channel");
 
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 	if(c->closed) {
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		runtime·panicstring("close of closed channel");
 	}
 
@@ -1104,7 +1104,7 @@ closechan(Hchan *c, void *pc)
 		runtime·ready(gp);
 	}
 
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 }
 
 func reflect·chanlen(c *Hchan) (len int) {
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index 043ef7d21c..e6e6bacd32 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -38,7 +38,7 @@ struct	Hchan
 	uintgo	recvx;			// receive index
 	WaitQ	recvq;			// list of recv waiters
 	WaitQ	sendq;			// list of send waiters
-	Lock;
+	Lock	lock;
 };
 
 // Buffer follows Hchan immediately in memory.
diff --git a/src/pkg/runtime/defs_plan9_386.h b/src/pkg/runtime/defs_plan9_386.h
index bde299dee1..a762b85899 100644
--- a/src/pkg/runtime/defs_plan9_386.h
+++ b/src/pkg/runtime/defs_plan9_386.h
@@ -21,9 +21,6 @@ struct Ureg
 	uint32	pc;		/* pc */
 	uint32	cs;		/* old context */
 	uint32	flags;		/* old flags */
-	union {
-		uint32	usp;
-		uint32	sp;
-	};
+	uint32	sp;
 	uint32	ss;		/* old stack segment */
 };
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 9e968a250e..b002feb1c2 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -515,7 +515,7 @@ dumproots(void)
 				if(sp->kind != KindSpecialFinalizer)
 					continue;
 				spf = (SpecialFinalizer*)sp;
-				p = (byte*)((s->start << PageShift) + spf->offset);
+				p = (byte*)((s->start << PageShift) + spf->special.offset);
 				dumpfinalizer(p, spf->fn, spf->fint, spf->ot);
 			}
 		}
@@ -695,7 +695,7 @@ dumpmemprof(void)
 			if(sp->kind != KindSpecialProfile)
 				continue;
 			spp = (SpecialProfile*)sp;
-			p = (byte*)((s->start << PageShift) + spp->offset);
+			p = (byte*)((s->start << PageShift) + spp->special.offset);
 			dumpint(TagAllocSample);
 			dumpint((uintptr)p);
 			dumpint((uintptr)spp->b);
diff --git a/src/pkg/runtime/iface.goc b/src/pkg/runtime/iface.goc
index 89c116e127..719d115880 100644
--- a/src/pkg/runtime/iface.goc
+++ b/src/pkg/runtime/iface.goc
@@ -42,7 +42,7 @@ itab(InterfaceType *inter, Type *type, int32 canfail)
 	}
 
 	// compiler has provided some good hash codes for us.
-	h = inter->hash;
+	h = inter->typ.hash;
 	h += 17 * type->hash;
 	// TODO(rsc): h += 23 * x->mhash ?
 	h %= nelem(hash);
@@ -98,7 +98,7 @@ search:
 				throw:
 					// didn't find method
 					runtime·newTypeAssertionError(
-						nil, type->string, inter->string,
+						nil, type->string, inter->typ.string,
 						iname, &err);
 					if(locked)
 						runtime·unlock(&ifacelock);
@@ -231,7 +231,7 @@ assertI2Tret(Type *t, Iface i, byte *ret)
 	}
 	if(tab->type != t) {
 		runtime·newTypeAssertionError(
-			tab->inter->string, tab->type->string, t->string,
+			tab->inter->typ.string, tab->type->string, t->string,
 			nil, &err);
 		runtime·panic(err);
 	}
@@ -332,7 +332,7 @@ func assertI2E(inter *InterfaceType, i Iface) (ret Eface) {
 	if(tab == nil) {
 		// explicit conversions require non-nil interface value.
 		runtime·newTypeAssertionError(
-			nil, nil, inter->string,
+			nil, nil, inter->typ.string,
 			nil, &err);
 		runtime·panic(err);
 	}
@@ -377,7 +377,7 @@ runtime·ifaceI2I(InterfaceType *inter, Iface i, Iface *ret)
 	if(tab == nil) {
 		// explicit conversions require non-nil interface value.
 		runtime·newTypeAssertionError(
-			nil, nil, inter->string,
+			nil, nil, inter->typ.string,
 			nil, &err);
 		runtime·panic(err);
 	}
@@ -414,7 +414,7 @@ runtime·ifaceE2I(InterfaceType *inter, Eface e, Iface *ret)
 	if(t == nil) {
 		// explicit conversions require non-nil interface value.
 		runtime·newTypeAssertionError(
-			nil, nil, inter->string,
+			nil, nil, inter->typ.string,
 			nil, &err);
 		runtime·panic(err);
 	}
@@ -462,7 +462,7 @@ func assertE2E(inter *InterfaceType, e Eface) (ret Eface) {
 	if(t == nil) {
 		// explicit conversions require non-nil interface value.
 		runtime·newTypeAssertionError(
-			nil, nil, inter->string,
+			nil, nil, inter->typ.string,
 			nil, &err);
 		runtime·panic(err);
 	}
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index be3280e0f1..8b9447dad6 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -45,9 +45,9 @@ runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **sp)
 	g->m->mcache->local_nlookup++;
 	if (sizeof(void*) == 4 && g->m->mcache->local_nlookup >= (1<<30)) {
 		// purge cache stats to prevent overflow
-		runtime·lock(&runtime·mheap);
+		runtime·lock(&runtime·mheap.lock);
 		runtime·purgecachedstats(g->m->mcache);
-		runtime·unlock(&runtime·mheap);
+		runtime·unlock(&runtime·mheap.lock);
 	}
 
 	s = runtime·MHeap_LookupMaybe(&runtime·mheap, v);
@@ -341,7 +341,7 @@ runtime·MHeap_SysAlloc(MHeap *h, uintptr n)
 
 static struct
 {
-	Lock;
+	Lock	lock;
 	byte*	pos;
 	byte*	end;
 } persistent;
@@ -370,19 +370,19 @@ runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat)
 		align = 8;
 	if(size >= PersistentAllocMaxBlock)
 		return runtime·SysAlloc(size, stat);
-	runtime·lock(&persistent);
+	runtime·lock(&persistent.lock);
 	persistent.pos = (byte*)ROUND((uintptr)persistent.pos, align);
 	if(persistent.pos + size > persistent.end) {
 		persistent.pos = runtime·SysAlloc(PersistentAllocChunk, &mstats.other_sys);
 		if(persistent.pos == nil) {
-			runtime·unlock(&persistent);
+			runtime·unlock(&persistent.lock);
 			runtime·throw("runtime: cannot allocate memory");
 		}
 		persistent.end = persistent.pos + PersistentAllocChunk;
 	}
 	p = persistent.pos;
 	persistent.pos += size;
-	runtime·unlock(&persistent);
+	runtime·unlock(&persistent.lock);
 	if(stat != &mstats.other_sys) {
 		// reaccount the allocation against provided stat
 		runtime·xadd64(stat, size);
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 4b16c55536..593e9b885b 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -370,7 +370,7 @@ struct Special
 typedef struct SpecialFinalizer SpecialFinalizer;
 struct SpecialFinalizer
 {
-	Special;
+	Special		special;
 	FuncVal*	fn;
 	uintptr		nret;
 	Type*		fint;
@@ -382,7 +382,7 @@ typedef struct Bucket Bucket; // from mprof.h
 typedef struct SpecialProfile SpecialProfile;
 struct SpecialProfile
 {
-	Special;
+	Special	special;
 	Bucket*	b;
 };
 
@@ -438,7 +438,7 @@ void	runtime·MSpanList_Remove(MSpan *span);	// from whatever list it is in
 // Central list of free objects of a given size.
 struct MCentral
 {
-	Lock;
+	Lock  lock;
 	int32 sizeclass;
 	MSpan nonempty;	// list of spans with a free object
 	MSpan empty;	// list of spans with no free objects (or cached in an MCache)
@@ -454,7 +454,7 @@ bool	runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, ML
 // but all the other global data is here too.
 struct MHeap
 {
-	Lock;
+	Lock  lock;
 	MSpan free[MaxMHeapList];	// free lists of given length
 	MSpan freelarge;		// free lists length >= MaxMHeapList
 	MSpan busy[MaxMHeapList];	// busy lists of large objects of given length
@@ -483,7 +483,7 @@ struct MHeap
 	// spaced CacheLineSize bytes apart, so that each MCentral.Lock
 	// gets its own cache line.
 	struct {
-		MCentral;
+		MCentral mcentral;
 		byte pad[CacheLineSize];
 	} central[NumSizeClasses];
 
diff --git a/src/pkg/runtime/mcache.c b/src/pkg/runtime/mcache.c
index 665173bff5..e17bd2144f 100644
--- a/src/pkg/runtime/mcache.c
+++ b/src/pkg/runtime/mcache.c
@@ -22,9 +22,9 @@ runtime·allocmcache(void)
 	MCache *c;
 	int32 i;
 
-	runtime·lock(&runtime·mheap);
+	runtime·lock(&runtime·mheap.lock);
 	c = runtime·FixAlloc_Alloc(&runtime·mheap.cachealloc);
-	runtime·unlock(&runtime·mheap);
+	runtime·unlock(&runtime·mheap.lock);
 	runtime·memclr((byte*)c, sizeof(*c));
 	for(i = 0; i < NumSizeClasses; i++)
 		c->alloc[i] = &emptymspan;
@@ -45,10 +45,10 @@ freemcache(MCache *c)
 	runtime·MCache_ReleaseAll(c);
 	runtime·stackcache_clear(c);
 	runtime·gcworkbuffree(c->gcworkbuf);
-	runtime·lock(&runtime·mheap);
+	runtime·lock(&runtime·mheap.lock);
 	runtime·purgecachedstats(c);
 	runtime·FixAlloc_Free(&runtime·mheap.cachealloc, c);
-	runtime·unlock(&runtime·mheap);
+	runtime·unlock(&runtime·mheap.lock);
 }
 
 static void
@@ -85,7 +85,7 @@ runtime·MCache_Refill(MCache *c, int32 sizeclass)
 		s->incache = false;
 
 	// Get a new cached span from the central lists.
-	s = runtime·MCentral_CacheSpan(&runtime·mheap.central[sizeclass]);
+	s = runtime·MCentral_CacheSpan(&runtime·mheap.central[sizeclass].mcentral);
 	if(s == nil)
 		runtime·throw("out of memory");
 	if(s->freelist == nil) {
@@ -106,7 +106,7 @@ runtime·MCache_ReleaseAll(MCache *c)
 	for(i=0; i<NumSizeClasses; i++) {
 		s = c->alloc[i];
 		if(s != &emptymspan) {
-			runtime·MCentral_UncacheSpan(&runtime·mheap.central[i], s);
+			runtime·MCentral_UncacheSpan(&runtime·mheap.central[i].mcentral, s);
 			c->alloc[i] = &emptymspan;
 		}
 	}
diff --git a/src/pkg/runtime/mcentral.c b/src/pkg/runtime/mcentral.c
index 3f64b5ed23..6b2de02c42 100644
--- a/src/pkg/runtime/mcentral.c
+++ b/src/pkg/runtime/mcentral.c
@@ -37,14 +37,14 @@ runtime·MCentral_CacheSpan(MCentral *c)
 	int32 cap, n;
 	uint32 sg;
 
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 	sg = runtime·mheap.sweepgen;
 retry:
 	for(s = c->nonempty.next; s != &c->nonempty; s = s->next) {
 		if(s->sweepgen == sg-2 && runtime·cas(&s->sweepgen, sg-2, sg-1)) {
-			runtime·unlock(c);
+			runtime·unlock(&c->lock);
 			runtime·MSpan_Sweep(s);
-			runtime·lock(c);
+			runtime·lock(&c->lock);
 			// the span could have been moved to heap, retry
 			goto retry;
 		}
@@ -63,9 +63,9 @@ retry:
 			runtime·MSpanList_Remove(s);
 			// swept spans are at the end of the list
 			runtime·MSpanList_InsertBack(&c->empty, s);
-			runtime·unlock(c);
+			runtime·unlock(&c->lock);
 			runtime·MSpan_Sweep(s);
-			runtime·lock(c);
+			runtime·lock(&c->lock);
 			// the span could be moved to nonempty or heap, retry
 			goto retry;
 		}
@@ -80,7 +80,7 @@ retry:
 
 	// Replenish central list if empty.
 	if(!MCentral_Grow(c)) {
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		return nil;
 	}
 	goto retry;
@@ -95,7 +95,7 @@ havespan:
 	runtime·MSpanList_Remove(s);
 	runtime·MSpanList_InsertBack(&c->empty, s);
 	s->incache = true;
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 	return s;
 }
 
@@ -105,7 +105,7 @@ runtime·MCentral_UncacheSpan(MCentral *c, MSpan *s)
 {
 	int32 cap, n;
 
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 
 	s->incache = false;
 
@@ -118,7 +118,7 @@ runtime·MCentral_UncacheSpan(MCentral *c, MSpan *s)
 		runtime·MSpanList_Remove(s);
 		runtime·MSpanList_Insert(&c->nonempty, s);
 	}
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 }
 
 // Free n objects from a span s back into the central free list c.
@@ -130,7 +130,7 @@ runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *
 {
 	if(s->incache)
 		runtime·throw("freespan into cached span");
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 
 	// Move to nonempty if necessary.
 	if(s->freelist == nil) {
@@ -150,7 +150,7 @@ runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *
 	runtime·atomicstore(&s->sweepgen, runtime·mheap.sweepgen);
 
 	if(s->ref != 0) {
-		runtime·unlock(c);
+		runtime·unlock(&c->lock);
 		return false;
 	}
 
@@ -158,7 +158,7 @@ runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *
 	runtime·MSpanList_Remove(s);
 	s->needzero = 1;
 	s->freelist = nil;
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 	runtime·unmarkspan((byte*)(s->start<<PageShift), s->npages<<PageShift);
 	runtime·MHeap_Free(&runtime·mheap, s, 0);
 	return true;
@@ -174,14 +174,14 @@ MCentral_Grow(MCentral *c)
 	byte *p;
 	MSpan *s;
 
-	runtime·unlock(c);
+	runtime·unlock(&c->lock);
 	npages = runtime·class_to_allocnpages[c->sizeclass];
 	size = runtime·class_to_size[c->sizeclass];
 	n = (npages << PageShift) / size;
 	s = runtime·MHeap_Alloc(&runtime·mheap, npages, c->sizeclass, 0, 1);
 	if(s == nil) {
 		// TODO(rsc): Log out of memory
-		runtime·lock(c);
+		runtime·lock(&c->lock);
 		return false;
 	}
 
@@ -198,7 +198,7 @@ MCentral_Grow(MCentral *c)
 	*tailp = nil;
 	runtime·markspan((byte*)(s->start<<PageShift), size, n, size*n < (s->npages<<PageShift));
 
-	runtime·lock(c);
+	runtime·lock(&c->lock);
 	runtime·MSpanList_Insert(&c->nonempty, s);
 	return true;
 }
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 8998a871ae..d7e5d89f01 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -539,7 +539,7 @@ markroot(ParFor *desc, uint32 i)
 				// retain everything it points to.
 				spf = (SpecialFinalizer*)sp;
 				// A finalizer can be set for an inner byte of an object, find object beginning.
-				p = (void*)((s->start << PageShift) + spf->offset/s->elemsize*s->elemsize);
+				p = (void*)((s->start << PageShift) + spf->special.offset/s->elemsize*s->elemsize);
 				scanblock(p, s->elemsize, nil);
 				scanblock((void*)&spf->fn, PtrSize, ScanConservatively);
 			}
@@ -1043,7 +1043,7 @@ runtime·MSpan_Sweep(MSpan *s)
 		c->local_nsmallfree[cl] += nfree;
 		c->local_cachealloc -= nfree * size;
 		runtime·xadd64(&mstats.next_gc, -(uint64)(nfree * size * (runtime·gcpercent + 100)/100));
-		res = runtime·MCentral_FreeSpan(&runtime·mheap.central[cl], s, nfree, head.next, end);
+		res = runtime·MCentral_FreeSpan(&runtime·mheap.central[cl].mcentral, s, nfree, head.next, end);
 		// MCentral_FreeSpan updates sweepgen
 	}
 	return res;
@@ -1308,10 +1308,10 @@ runtime·gc(int32 force)
 		return;
 
 	if(runtime·gcpercent == GcpercentUnknown) {	// first time through
-		runtime·lock(&runtime·mheap);
+		runtime·lock(&runtime·mheap.lock);
 		if(runtime·gcpercent == GcpercentUnknown)
 			runtime·gcpercent = runtime·readgogc();
-		runtime·unlock(&runtime·mheap);
+		runtime·unlock(&runtime·mheap.lock);
 	}
 	if(runtime·gcpercent < 0)
 		return;
@@ -1560,7 +1560,7 @@ runtime∕debug·readGCStats(Slice *pauses)
 
 	// Pass back: pauses, last gc (absolute time), number of gc, total pause ns.
 	p = (uint64*)pauses->array;
-	runtime·lock(&runtime·mheap);
+	runtime·lock(&runtime·mheap.lock);
 	n = mstats.numgc;
 	if(n > nelem(mstats.pause_ns))
 		n = nelem(mstats.pause_ns);
@@ -1575,7 +1575,7 @@ runtime∕debug·readGCStats(Slice *pauses)
 	p[n] = mstats.last_gc;
 	p[n+1] = mstats.numgc;
 	p[n+2] = mstats.pause_total_ns;	
-	runtime·unlock(&runtime·mheap);
+	runtime·unlock(&runtime·mheap.lock);
 	pauses->len = n+3;
 }
 
@@ -1583,14 +1583,14 @@ int32
 runtime·setgcpercent(int32 in) {
 	int32 out;
 
-	runtime·lock(&runtime·mheap);
+	runtime·lock(&runtime·mheap.lock);
 	if(runtime·gcpercent == GcpercentUnknown)
 		runtime·gcpercent = runtime·readgogc();
 	out = runtime·gcpercent;
 	if(in < 0)
 		in = -1;
 	runtime·gcpercent = in;
-	runtime·unlock(&runtime·mheap);
+	runtime·unlock(&runtime·mheap.lock);
 	return out;
 }
 
@@ -1670,11 +1670,11 @@ runfinq(void)
 				} else if(((InterfaceType*)f->fint)->mhdr.len == 0) {
 					// convert to empty interface
 					ef = (Eface*)frame;
-					ef->type = f->ot;
+					ef->type = &f->ot->typ;
 					ef->data = f->arg;
 				} else {
 					// convert to interface with methods, via empty interface.
-					ef1.type = f->ot;
+					ef1.type = &f->ot->typ;
 					ef1.data = f->arg;
 					if(!runtime·ifaceE2I2((InterfaceType*)f->fint, ef1, (Iface*)frame))
 						runtime·throw("invalid type conversion in runfinq");
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index c7043bb143..908d668462 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -70,7 +70,7 @@ runtime·MHeap_Init(MHeap *h)
 	runtime·MSpanList_Init(&h->freelarge);
 	runtime·MSpanList_Init(&h->busylarge);
 	for(i=0; i<nelem(h->central); i++)
-		runtime·MCentral_Init(&h->central[i], i);
+		runtime·MCentral_Init(&h->central[i].mcentral, i);
 }
 
 void
@@ -106,9 +106,9 @@ retry:
 			runtime·MSpanList_Remove(s);
 			// swept spans are at the end of the list
 			runtime·MSpanList_InsertBack(list, s);
-			runtime·unlock(h);
+			runtime·unlock(&h->lock);
 			n += runtime·MSpan_Sweep(s);
-			runtime·lock(h);
+			runtime·lock(&h->lock);
 			if(n >= npages)
 				return n;
 			// the span could have been moved elsewhere
@@ -153,7 +153,7 @@ MHeap_Reclaim(MHeap *h, uintptr npage)
 	}
 
 	// Now sweep everything that is not yet swept.
-	runtime·unlock(h);
+	runtime·unlock(&h->lock);
 	for(;;) {
 		n = runtime·sweepone();
 		if(n == -1)  // all spans are swept
@@ -162,7 +162,7 @@ MHeap_Reclaim(MHeap *h, uintptr npage)
 		if(reclaimed >= npage)
 			break;
 	}
-	runtime·lock(h);
+	runtime·lock(&h->lock);
 }
 
 // Allocate a new span of npage pages from the heap for GC'd memory
@@ -174,7 +174,7 @@ mheap_alloc(MHeap *h, uintptr npage, int32 sizeclass, bool large)
 
 	if(g != g->m->g0)
 		runtime·throw("mheap_alloc not on M stack");
-	runtime·lock(h);
+	runtime·lock(&h->lock);
 
 	// To prevent excessive heap growth, before allocating n pages
 	// we need to sweep and reclaim at least n pages.
@@ -207,7 +207,7 @@ mheap_alloc(MHeap *h, uintptr npage, int32 sizeclass, bool large)
 				runtime·MSpanList_InsertBack(&h->busylarge, s);
 		}
 	}
-	runtime·unlock(h);
+	runtime·unlock(&h->lock);
 	return s;
 }
 
@@ -259,7 +259,7 @@ runtime·MHeap_AllocStack(MHeap *h, uintptr npage)
 
 	if(g != g->m->g0)
 		runtime·throw("mheap_allocstack not on M stack");
-	runtime·lock(h);
+	runtime·lock(&h->lock);
 	s = MHeap_AllocSpanLocked(h, npage);
 	if(s != nil) {
 		s->state = MSpanStack;
@@ -267,7 +267,7 @@ runtime·MHeap_AllocStack(MHeap *h, uintptr npage)
 		s->ref = 0;
 		mstats.stacks_inuse += s->npages<<PageShift;
 	}
-	runtime·unlock(h);
+	runtime·unlock(&h->lock);
 	return s;
 }
 
@@ -460,7 +460,7 @@ mheap_free(MHeap *h, MSpan *s, int32 acct)
 {
 	if(g != g->m->g0)
 		runtime·throw("mheap_free not on M stack");
-	runtime·lock(h);
+	runtime·lock(&h->lock);
 	mstats.heap_alloc += g->m->mcache->local_cachealloc;
 	g->m->mcache->local_cachealloc = 0;
 	if(acct) {
@@ -468,7 +468,7 @@ mheap_free(MHeap *h, MSpan *s, int32 acct)
 		mstats.heap_objects--;
 	}
 	MHeap_FreeSpanLocked(h, s);
-	runtime·unlock(h);
+	runtime·unlock(&h->lock);
 }
 
 static void
@@ -504,10 +504,10 @@ runtime·MHeap_FreeStack(MHeap *h, MSpan *s)
 	if(g != g->m->g0)
 		runtime·throw("mheap_freestack not on M stack");
 	s->needzero = 1;
-	runtime·lock(h);
+	runtime·lock(&h->lock);
 	mstats.stacks_inuse -= s->npages<<PageShift;
 	MHeap_FreeSpanLocked(h, s);
-	runtime·unlock(h);
+	runtime·unlock(&h->lock);
 }
 
 static void
@@ -626,9 +626,9 @@ scavenge(int32 k, uint64 now, uint64 limit)
 static void
 scavenge_m(G *gp)
 {
-	runtime·lock(&runtime·mheap);
+	runtime·lock(&runtime·mheap.lock);
 	scavenge(g->m->scalararg[0], g->m->scalararg[1], g->m->scalararg[2]);
-	runtime·unlock(&runtime·mheap);
+	runtime·unlock(&runtime·mheap.lock);
 	runtime·gogo(&gp->sched);
 }
 
@@ -865,12 +865,12 @@ runtime·addfinalizer(void *p, FuncVal *f, uintptr nret, Type *fint, PtrType *ot
 	runtime·lock(&runtime·mheap.speciallock);
 	s = runtime·FixAlloc_Alloc(&runtime·mheap.specialfinalizeralloc);
 	runtime·unlock(&runtime·mheap.speciallock);
-	s->kind = KindSpecialFinalizer;
+	s->special.kind = KindSpecialFinalizer;
 	s->fn = f;
 	s->nret = nret;
 	s->fint = fint;
 	s->ot = ot;
-	if(addspecial(p, s))
+	if(addspecial(p, &s->special))
 		return true;
 
 	// There was an old finalizer
@@ -903,9 +903,9 @@ runtime·setprofilebucket(void *p, Bucket *b)
 	runtime·lock(&runtime·mheap.speciallock);
 	s = runtime·FixAlloc_Alloc(&runtime·mheap.specialprofilealloc);
 	runtime·unlock(&runtime·mheap.speciallock);
-	s->kind = KindSpecialProfile;
+	s->special.kind = KindSpecialProfile;
 	s->b = b;
-	if(!addspecial(p, s))
+	if(!addspecial(p, &s->special))
 		runtime·throw("setprofilebucket: profile already set");
 }
 
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index 053781193e..6a028c31f3 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -92,20 +92,20 @@ MProf_GC(void)
 	Bucket *b;
 
 	for(b=mbuckets; b; b=b->allnext) {
-		b->allocs += b->prev_allocs;
-		b->frees += b->prev_frees;
-		b->alloc_bytes += b->prev_alloc_bytes;
-		b->free_bytes += b->prev_free_bytes;
+		b->data.mp.allocs += b->data.mp.prev_allocs;
+		b->data.mp.frees += b->data.mp.prev_frees;
+		b->data.mp.alloc_bytes += b->data.mp.prev_alloc_bytes;
+		b->data.mp.free_bytes += b->data.mp.prev_free_bytes;
 
-		b->prev_allocs = b->recent_allocs;
-		b->prev_frees = b->recent_frees;
-		b->prev_alloc_bytes = b->recent_alloc_bytes;
-		b->prev_free_bytes = b->recent_free_bytes;
+		b->data.mp.prev_allocs = b->data.mp.recent_allocs;
+		b->data.mp.prev_frees = b->data.mp.recent_frees;
+		b->data.mp.prev_alloc_bytes = b->data.mp.recent_alloc_bytes;
+		b->data.mp.prev_free_bytes = b->data.mp.recent_free_bytes;
 
-		b->recent_allocs = 0;
-		b->recent_frees = 0;
-		b->recent_alloc_bytes = 0;
-		b->recent_free_bytes = 0;
+		b->data.mp.recent_allocs = 0;
+		b->data.mp.recent_frees = 0;
+		b->data.mp.recent_alloc_bytes = 0;
+		b->data.mp.recent_free_bytes = 0;
 	}
 }
 
@@ -129,8 +129,8 @@ runtime·MProf_Malloc(void *p, uintptr size)
 	nstk = runtime·callers(1, stk, nelem(stk));
 	runtime·lock(&proflock);
 	b = stkbucket(MProf, size, stk, nstk, true);
-	b->recent_allocs++;
-	b->recent_alloc_bytes += size;
+	b->data.mp.recent_allocs++;
+	b->data.mp.recent_alloc_bytes += size;
 	runtime·unlock(&proflock);
 
 	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
@@ -160,8 +160,8 @@ runtime·mprofMalloc_m(void)
 		nstk = runtime·gcallers(g->m->curg, 1, stk, nelem(stk));
 	runtime·lock(&proflock);
 	b = stkbucket(MProf, size, stk, nstk, true);
-	b->recent_allocs++;
-	b->recent_alloc_bytes += size;
+	b->data.mp.recent_allocs++;
+	b->data.mp.recent_alloc_bytes += size;
 	runtime·unlock(&proflock);
 
 	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
@@ -177,11 +177,11 @@ runtime·MProf_Free(Bucket *b, uintptr size, bool freed)
 {
 	runtime·lock(&proflock);
 	if(freed) {
-		b->recent_frees++;
-		b->recent_free_bytes += size;
+		b->data.mp.recent_frees++;
+		b->data.mp.recent_free_bytes += size;
 	} else {
-		b->prev_frees++;
-		b->prev_free_bytes += size;
+		b->data.mp.prev_frees++;
+		b->data.mp.prev_free_bytes += size;
 	}
 	runtime·unlock(&proflock);
 }
@@ -221,8 +221,8 @@ runtime·blockevent(int64 cycles, int32 skip)
 	nstk = runtime·callers(skip, stk, nelem(stk));
 	runtime·lock(&proflock);
 	b = stkbucket(BProf, 0, stk, nstk, true);
-	b->count++;
-	b->cycles += cycles;
+	b->data.bp.count++;
+	b->data.bp.cycles += cycles;
 	runtime·unlock(&proflock);
 }
 
@@ -242,10 +242,10 @@ record(Record *r, Bucket *b)
 {
 	int32 i;
 
-	r->alloc_bytes = b->alloc_bytes;
-	r->free_bytes = b->free_bytes;
-	r->alloc_objects = b->allocs;
-	r->free_objects = b->frees;
+	r->alloc_bytes = b->data.mp.alloc_bytes;
+	r->free_bytes = b->data.mp.free_bytes;
+	r->alloc_objects = b->data.mp.allocs;
+	r->free_objects = b->data.mp.frees;
 	for(i=0; i<b->nstk && i<nelem(r->stk); i++)
 		r->stk[i] = b->stk[i];
 	for(; i<nelem(r->stk); i++)
@@ -261,9 +261,9 @@ func MemProfile(p Slice, include_inuse_zero bool) (n int, ok bool) {
 	n = 0;
 	clear = true;
 	for(b=mbuckets; b; b=b->allnext) {
-		if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
+		if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
 			n++;
-		if(b->allocs != 0 || b->frees != 0)
+		if(b->data.mp.allocs != 0 || b->data.mp.frees != 0)
 			clear = false;
 	}
 	if(clear) {
@@ -275,7 +275,7 @@ func MemProfile(p Slice, include_inuse_zero bool) (n int, ok bool) {
 		MProf_GC();
 		n = 0;
 		for(b=mbuckets; b; b=b->allnext)
-			if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
+			if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
 				n++;
 	}
 	ok = false;
@@ -283,7 +283,7 @@ func MemProfile(p Slice, include_inuse_zero bool) (n int, ok bool) {
 		ok = true;
 		r = (Record*)p.array;
 		for(b=mbuckets; b; b=b->allnext)
-			if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
+			if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
 				record(r++, b);
 	}
 	runtime·unlock(&proflock);
@@ -296,7 +296,7 @@ runtime·iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, u
 
 	runtime·lock(&proflock);
 	for(b=mbuckets; b; b=b->allnext) {
-		callback(b, b->nstk, b->stk, b->size, b->allocs, b->frees);
+		callback(b, b->nstk, b->stk, b->size, b->data.mp.allocs, b->data.mp.frees);
 	}
 	runtime·unlock(&proflock);
 }
@@ -323,8 +323,8 @@ func BlockProfile(p Slice) (n int, ok bool) {
 		ok = true;
 		r = (BRecord*)p.array;
 		for(b=bbuckets; b; b=b->allnext, r++) {
-			r->count = b->count;
-			r->cycles = b->cycles;
+			r->count = b->data.bp.count;
+			r->cycles = b->data.bp.cycles;
 			for(i=0; i<b->nstk && i<nelem(r->stk); i++)
 				r->stk[i] = b->stk[i];
 			for(; i<nelem(r->stk); i++)
diff --git a/src/pkg/runtime/mprof.h b/src/pkg/runtime/mprof.h
index de5e707d60..5e9f3b55a4 100644
--- a/src/pkg/runtime/mprof.h
+++ b/src/pkg/runtime/mprof.h
@@ -42,13 +42,13 @@ struct Bucket
 			uintptr	recent_alloc_bytes;
 			uintptr	recent_free_bytes;
 
-		};
+		} mp;
 		struct  // typ == BProf
 		{
 			int64	count;
 			int64	cycles;
-		};
-	};
+		} bp;
+	} data;
 	uintptr	hash;	// hash of size + stk
 	uintptr	size;
 	uintptr	nstk;
diff --git a/src/pkg/runtime/netpoll.goc b/src/pkg/runtime/netpoll.goc
index 7b3d16d02d..eb7f8878cb 100644
--- a/src/pkg/runtime/netpoll.goc
+++ b/src/pkg/runtime/netpoll.goc
@@ -48,7 +48,7 @@ struct PollDesc
 	// pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO rediness notification)
 	// proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
 	// in a lock-free way by all operations.
-	Lock;		// protectes the following fields
+	Lock	lock;		// protectes the following fields
 	uintptr	fd;
 	bool	closing;
 	uintptr	seq;	// protects from stale timers and ready notifications
@@ -63,7 +63,7 @@ struct PollDesc
 
 static struct
 {
-	Lock;
+	Lock		lock;
 	PollDesc*	first;
 	// PollDesc objects must be type-stable,
 	// because we can get ready notification from epoll/kqueue
@@ -95,7 +95,7 @@ func runtime_pollServerInit() {
 
 func runtime_pollOpen(fd uintptr) (pd *PollDesc, errno int) {
 	pd = allocPollDesc();
-	runtime·lock(pd);
+	runtime·lock(&pd->lock);
 	if(pd->wg != nil && pd->wg != READY)
 		runtime·throw("runtime_pollOpen: blocked write on free descriptor");
 	if(pd->rg != nil && pd->rg != READY)
@@ -107,7 +107,7 @@ func runtime_pollOpen(fd uintptr) (pd *PollDesc, errno int) {
 	pd->rd = 0;
 	pd->wg = nil;
 	pd->wd = 0;
-	runtime·unlock(pd);
+	runtime·unlock(&pd->lock);
 
 	errno = runtime·netpollopen(fd, pd);
 }
@@ -120,10 +120,10 @@ func runtime_pollClose(pd *PollDesc) {
 	if(pd->rg != nil && pd->rg != READY)
 		runtime·throw("runtime_pollClose: blocked read on closing descriptor");
 	runtime·netpollclose(pd->fd);
-	runtime·lock(&pollcache);
+	runtime·lock(&pollcache.lock);
 	pd->link = pollcache.first;
 	pollcache.first = pd;
-	runtime·unlock(&pollcache);
+	runtime·unlock(&pollcache.lock);
 }
 
 func runtime_pollReset(pd *PollDesc, mode int) (err int) {
@@ -164,9 +164,9 @@ func runtime_pollWaitCanceled(pd *PollDesc, mode int) {
 func runtime_pollSetDeadline(pd *PollDesc, d int64, mode int) {
 	G *rg, *wg;
 
-	runtime·lock(pd);
+	runtime·lock(&pd->lock);
 	if(pd->closing) {
-		runtime·unlock(pd);
+		runtime·unlock(&pd->lock);
 		return;
 	}
 	pd->seq++;  // invalidate current timers
@@ -218,7 +218,7 @@ func runtime_pollSetDeadline(pd *PollDesc, d int64, mode int) {
 		rg = netpollunblock(pd, 'r', false);
 	if(pd->wd < 0)
 		wg = netpollunblock(pd, 'w', false);
-	runtime·unlock(pd);
+	runtime·unlock(&pd->lock);
 	if(rg)
 		runtime·ready(rg);
 	if(wg)
@@ -228,7 +228,7 @@ func runtime_pollSetDeadline(pd *PollDesc, d int64, mode int) {
 func runtime_pollUnblock(pd *PollDesc) {
 	G *rg, *wg;
 
-	runtime·lock(pd);
+	runtime·lock(&pd->lock);
 	if(pd->closing)
 		runtime·throw("runtime_pollUnblock: already closing");
 	pd->closing = true;
@@ -244,7 +244,7 @@ func runtime_pollUnblock(pd *PollDesc) {
 		runtime·deltimer(&pd->wt);
 		pd->wt.fv = nil;
 	}
-	runtime·unlock(pd);
+	runtime·unlock(&pd->lock);
 	if(rg)
 		runtime·ready(rg);
 	if(wg)
@@ -272,13 +272,13 @@ runtime·netpollclosing(PollDesc *pd)
 void
 runtime·netpolllock(PollDesc *pd)
 {
-	runtime·lock(pd);
+	runtime·lock(&pd->lock);
 }
 
 void
 runtime·netpollunlock(PollDesc *pd)
 {
-	runtime·unlock(pd);
+	runtime·unlock(&pd->lock);
 }
 
 // make pd ready, newly runnable goroutines (if any) are enqueued info gpp list
@@ -396,10 +396,10 @@ deadlineimpl(int64 now, Eface arg, bool read, bool write)
 	// If it's stale, ignore the timer event.
 	seq = (uintptr)arg.type;
 	rg = wg = nil;
-	runtime·lock(pd);
+	runtime·lock(&pd->lock);
 	if(seq != pd->seq) {
 		// The descriptor was reused or timers were reset.
-		runtime·unlock(pd);
+		runtime·unlock(&pd->lock);
 		return;
 	}
 	if(read) {
@@ -416,7 +416,7 @@ deadlineimpl(int64 now, Eface arg, bool read, bool write)
 		runtime·atomicstorep(&pd->wt.fv, nil);  // full memory barrier between store to wd and load of wg in netpollunblock
 		wg = netpollunblock(pd, 'w', false);
 	}
-	runtime·unlock(pd);
+	runtime·unlock(&pd->lock);
 	if(rg)
 		runtime·ready(rg);
 	if(wg)
@@ -447,7 +447,7 @@ allocPollDesc(void)
 	PollDesc *pd;
 	uint32 i, n;
 
-	runtime·lock(&pollcache);
+	runtime·lock(&pollcache.lock);
 	if(pollcache.first == nil) {
 		n = PollBlockSize/sizeof(*pd);
 		if(n == 0)
@@ -462,6 +462,6 @@ allocPollDesc(void)
 	}
 	pd = pollcache.first;
 	pollcache.first = pd->link;
-	runtime·unlock(&pollcache);
+	runtime·unlock(&pollcache.lock);
 	return pd;
 }
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 137f49f5f0..cef41d95f2 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -26,7 +26,7 @@
 
 typedef struct Sched Sched;
 struct Sched {
-	Lock;
+	Lock	lock;
 
 	uint64	goidgen;
 
@@ -371,7 +371,7 @@ mcommoninit(M *mp)
 
 	mp->fastrand = 0x49f6428aUL + mp->id + runtime·cputicks();
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	mp->id = runtime·sched.mcount++;
 	checkmcount();
 	runtime·mpreinit(mp);
@@ -382,7 +382,7 @@ mcommoninit(M *mp)
 	// runtime·NumCgoCall() iterates over allm w/o schedlock,
 	// so we need to publish it safely.
 	runtime·atomicstorep(&runtime·allm, mp);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 }
 
 // Mark gp ready to run.
@@ -411,7 +411,7 @@ runtime·gcprocs(void)
 
 	// Figure out how many CPUs to use during GC.
 	// Limited by gomaxprocs, number of actual CPUs, and MaxGcproc.
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	n = runtime·gomaxprocs;
 	if(n > runtime·ncpu)
 		n = runtime·ncpu;
@@ -419,7 +419,7 @@ runtime·gcprocs(void)
 		n = MaxGcproc;
 	if(n > runtime·sched.nmidle+1) // one M is currently running
 		n = runtime·sched.nmidle+1;
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	return n;
 }
 
@@ -428,14 +428,14 @@ needaddgcproc(void)
 {
 	int32 n;
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	n = runtime·gomaxprocs;
 	if(n > runtime·ncpu)
 		n = runtime·ncpu;
 	if(n > MaxGcproc)
 		n = MaxGcproc;
 	n -= runtime·sched.nmidle+1; // one M is currently running
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	return n > 0;
 }
 
@@ -445,7 +445,7 @@ runtime·helpgc(int32 nproc)
 	M *mp;
 	int32 n, pos;
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	pos = 0;
 	for(n = 1; n < nproc; n++) {  // one M is currently running
 		if(runtime·allp[pos]->mcache == g->m->mcache)
@@ -458,7 +458,7 @@ runtime·helpgc(int32 nproc)
 		pos++;
 		runtime·notewakeup(&mp->park);
 	}
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 }
 
 // Similar to stoptheworld but best-effort and can be called several times.
@@ -497,7 +497,7 @@ runtime·stoptheworld(void)
 	P *p;
 	bool wait;
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	runtime·sched.stopwait = runtime·gomaxprocs;
 	runtime·atomicstore((uint32*)&runtime·sched.gcwaiting, 1);
 	preemptall();
@@ -517,7 +517,7 @@ runtime·stoptheworld(void)
 		runtime·sched.stopwait--;
 	}
 	wait = runtime·sched.stopwait > 0;
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 
 	// wait for remaining P's to stop voluntarily
 	if(wait) {
@@ -557,7 +557,7 @@ runtime·starttheworld(void)
 	gp = runtime·netpoll(false);  // non-blocking
 	injectglist(gp);
 	add = needaddgcproc();
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	if(newprocs) {
 		procresize(newprocs);
 		newprocs = 0;
@@ -581,7 +581,7 @@ runtime·starttheworld(void)
 		runtime·sched.sysmonwait = false;
 		runtime·notewakeup(&runtime·sched.sysmonnote);
 	}
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 
 	while(p1) {
 		p = p1;
@@ -964,9 +964,9 @@ stopm(void)
 	}
 
 retry:
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	mput(g->m);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	runtime·notesleep(&g->m->park);
 	runtime·noteclear(&g->m->park);
 	if(g->m->helpgc) {
@@ -993,18 +993,18 @@ startm(P *p, bool spinning)
 	M *mp;
 	void (*fn)(void);
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	if(p == nil) {
 		p = pidleget();
 		if(p == nil) {
-			runtime·unlock(&runtime·sched);
+			runtime·unlock(&runtime·sched.lock);
 			if(spinning)
 				runtime·xadd(&runtime·sched.nmspinning, -1);
 			return;
 		}
 	}
 	mp = mget();
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	if(mp == nil) {
 		fn = nil;
 		if(spinning)
@@ -1037,28 +1037,28 @@ handoffp(P *p)
 		startm(p, true);
 		return;
 	}
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	if(runtime·sched.gcwaiting) {
 		p->status = Pgcstop;
 		if(--runtime·sched.stopwait == 0)
 			runtime·notewakeup(&runtime·sched.stopnote);
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		return;
 	}
 	if(runtime·sched.runqsize) {
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		startm(p, false);
 		return;
 	}
 	// If this is the last running P and nobody is polling network,
 	// need to wakeup another M to poll network.
 	if(runtime·sched.npidle == runtime·gomaxprocs-1 && runtime·atomicload64(&runtime·sched.lastpoll) != 0) {
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		startm(p, false);
 		return;
 	}
 	pidleput(p);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 }
 
 // Tries to add one more P to execute G's.
@@ -1130,11 +1130,11 @@ gcstopm(void)
 		runtime·xadd(&runtime·sched.nmspinning, -1);
 	}
 	p = releasep();
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	p->status = Pgcstop;
 	if(--runtime·sched.stopwait == 0)
 		runtime·notewakeup(&runtime·sched.stopnote);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	stopm();
 }
 
@@ -1187,9 +1187,9 @@ top:
 		return gp;
 	// global runq
 	if(runtime·sched.runqsize) {
-		runtime·lock(&runtime·sched);
+		runtime·lock(&runtime·sched.lock);
 		gp = globrunqget(g->m->p, 0);
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		if(gp)
 			return gp;
 	}
@@ -1223,19 +1223,19 @@ top:
 	}
 stop:
 	// return P and block
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	if(runtime·sched.gcwaiting) {
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		goto top;
 	}
 	if(runtime·sched.runqsize) {
 		gp = globrunqget(g->m->p, 0);
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		return gp;
 	}
 	p = releasep();
 	pidleput(p);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	if(g->m->spinning) {
 		g->m->spinning = false;
 		runtime·xadd(&runtime·sched.nmspinning, -1);
@@ -1244,9 +1244,9 @@ stop:
 	for(i = 0; i < runtime·gomaxprocs; i++) {
 		p = runtime·allp[i];
 		if(p && p->runqhead != p->runqtail) {
-			runtime·lock(&runtime·sched);
+			runtime·lock(&runtime·sched.lock);
 			p = pidleget();
-			runtime·unlock(&runtime·sched);
+			runtime·unlock(&runtime·sched.lock);
 			if(p) {
 				acquirep(p);
 				goto top;
@@ -1263,9 +1263,9 @@ stop:
 		gp = runtime·netpoll(true);  // block until new work is available
 		runtime·atomicstore64(&runtime·sched.lastpoll, runtime·nanotime());
 		if(gp) {
-			runtime·lock(&runtime·sched);
+			runtime·lock(&runtime·sched.lock);
 			p = pidleget();
-			runtime·unlock(&runtime·sched);
+			runtime·unlock(&runtime·sched.lock);
 			if(p) {
 				acquirep(p);
 				injectglist(gp->schedlink);
@@ -1308,14 +1308,14 @@ injectglist(G *glist)
 
 	if(glist == nil)
 		return;
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	for(n = 0; glist; n++) {
 		gp = glist;
 		glist = gp->schedlink;
 		gp->status = Grunnable;
 		globrunqput(gp);
 	}
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 
 	for(; n && runtime·sched.npidle; n--)
 		startm(nil, false);
@@ -1351,9 +1351,9 @@ top:
 	// This is a fancy way to say tick%61==0,
 	// it uses 2 MUL instructions instead of a single DIV and so is faster on modern processors.
 	if(tick - (((uint64)tick*0x4325c53fu)>>36)*61 == 0 && runtime·sched.runqsize > 0) {
-		runtime·lock(&runtime·sched);
+		runtime·lock(&runtime·sched.lock);
 		gp = globrunqget(g->m->p, 1);
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		if(gp)
 			resetspinning();
 	}
@@ -1459,9 +1459,9 @@ runtime·gosched0(G *gp)
 {
 	gp->status = Grunnable;
 	dropg();
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	globrunqput(gp);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 
 	schedule();
 }
@@ -1551,12 +1551,12 @@ void
 	}
 
 	if(runtime·atomicload(&runtime·sched.sysmonwait)) {  // TODO: fast atomic
-		runtime·lock(&runtime·sched);
+		runtime·lock(&runtime·sched.lock);
 		if(runtime·atomicload(&runtime·sched.sysmonwait)) {
 			runtime·atomicstore(&runtime·sched.sysmonwait, 0);
 			runtime·notewakeup(&runtime·sched.sysmonnote);
 		}
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 	}
 
@@ -1564,12 +1564,12 @@ void
 	g->m->p->m = nil;
 	runtime·atomicstore(&g->m->p->status, Psyscall);
 	if(runtime·sched.gcwaiting) {
-		runtime·lock(&runtime·sched);
+		runtime·lock(&runtime·sched.lock);
 		if (runtime·sched.stopwait > 0 && runtime·cas(&g->m->p->status, Psyscall, Pgcstop)) {
 			if(--runtime·sched.stopwait == 0)
 				runtime·notewakeup(&runtime·sched.stopnote);
 		}
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 	}
 
@@ -1685,13 +1685,13 @@ exitsyscallfast(void)
 	// Try to get any other idle P.
 	g->m->p = nil;
 	if(runtime·sched.pidle) {
-		runtime·lock(&runtime·sched);
+		runtime·lock(&runtime·sched.lock);
 		p = pidleget();
 		if(p && runtime·atomicload(&runtime·sched.sysmonwait)) {
 			runtime·atomicstore(&runtime·sched.sysmonwait, 0);
 			runtime·notewakeup(&runtime·sched.sysmonnote);
 		}
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		if(p) {
 			acquirep(p);
 			return true;
@@ -1709,7 +1709,7 @@ exitsyscall0(G *gp)
 
 	gp->status = Grunnable;
 	dropg();
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	p = pidleget();
 	if(p == nil)
 		globrunqput(gp);
@@ -1717,7 +1717,7 @@ exitsyscall0(G *gp)
 		runtime·atomicstore(&runtime·sched.sysmonwait, 0);
 		runtime·notewakeup(&runtime·sched.sysmonnote);
 	}
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	if(p) {
 		acquirep(p);
 		execute(gp);  // Never returns.
@@ -2069,13 +2069,13 @@ runtime·gomaxprocsfunc(int32 n)
 
 	if(n > MaxGomaxprocs)
 		n = MaxGomaxprocs;
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	ret = runtime·gomaxprocs;
 	if(n <= 0 || n == ret) {
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		return ret;
 	}
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 
 	runtime·semacquire(&runtime·worldsema, false);
 	g->m->gcing = 1;
@@ -2192,7 +2192,7 @@ runtime·badreflectcall(void) // called from assembly
 }
 
 static struct {
-	Lock;
+	Lock lock;
 	void (*fn)(uintptr*, int32);
 	int32 hz;
 	uintptr pcbuf[100];
@@ -2300,9 +2300,9 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 	   ((uint8*)runtime·gogo <= pc && pc < (uint8*)runtime·gogo + RuntimeGogoBytes))
 		traceback = false;
 
-	runtime·lock(&prof);
+	runtime·lock(&prof.lock);
 	if(prof.fn == nil) {
-		runtime·unlock(&prof);
+		runtime·unlock(&prof.lock);
 		mp->mallocing--;
 		return;
 	}
@@ -2341,7 +2341,7 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 		}
 	}
 	prof.fn(prof.pcbuf, n);
-	runtime·unlock(&prof);
+	runtime·unlock(&prof.lock);
 	mp->mallocing--;
 }
 
@@ -2366,13 +2366,13 @@ runtime·setcpuprofilerate(void (*fn)(uintptr*, int32), int32 hz)
 	// it would deadlock.
 	runtime·resetcpuprofiler(0);
 
-	runtime·lock(&prof);
+	runtime·lock(&prof.lock);
 	prof.fn = fn;
 	prof.hz = hz;
-	runtime·unlock(&prof);
-	runtime·lock(&runtime·sched);
+	runtime·unlock(&prof.lock);
+	runtime·lock(&runtime·sched.lock);
 	runtime·sched.profilehz = hz;
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 
 	if(hz != 0)
 		runtime·resetcpuprofiler(hz);
@@ -2510,11 +2510,11 @@ releasep(void)
 static void
 incidlelocked(int32 v)
 {
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	runtime·sched.nmidlelocked += v;
 	if(v > 0)
 		checkdead();
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 }
 
 // Check for deadlock situation.
@@ -2583,16 +2583,16 @@ sysmon(void)
 		runtime·usleep(delay);
 		if(runtime·debug.schedtrace <= 0 &&
 			(runtime·sched.gcwaiting || runtime·atomicload(&runtime·sched.npidle) == runtime·gomaxprocs)) {  // TODO: fast atomic
-			runtime·lock(&runtime·sched);
+			runtime·lock(&runtime·sched.lock);
 			if(runtime·atomicload(&runtime·sched.gcwaiting) || runtime·atomicload(&runtime·sched.npidle) == runtime·gomaxprocs) {
 				runtime·atomicstore(&runtime·sched.sysmonwait, 1);
-				runtime·unlock(&runtime·sched);
+				runtime·unlock(&runtime·sched.lock);
 				runtime·notesleep(&runtime·sched.sysmonnote);
 				runtime·noteclear(&runtime·sched.sysmonnote);
 				idle = 0;
 				delay = 20;
 			} else
-				runtime·unlock(&runtime·sched);
+				runtime·unlock(&runtime·sched.lock);
 		}
 		// poll network if not polled for more than 10ms
 		lastpoll = runtime·atomicload64(&runtime·sched.lastpoll);
@@ -2757,7 +2757,7 @@ runtime·schedtrace(bool detailed)
 	if(starttime == 0)
 		starttime = now;
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	runtime·printf("SCHED %Dms: gomaxprocs=%d idleprocs=%d threads=%d spinningthreads=%d idlethreads=%d runqueue=%d",
 		(now-starttime)/1000000, runtime·gomaxprocs, runtime·sched.npidle, runtime·sched.mcount,
 		runtime·sched.nmspinning, runtime·sched.nmidle, runtime·sched.runqsize);
@@ -2793,7 +2793,7 @@ runtime·schedtrace(bool detailed)
 		}
 	}
 	if(!detailed) {
-		runtime·unlock(&runtime·sched);
+		runtime·unlock(&runtime·sched.lock);
 		return;
 	}
 	for(mp = runtime·allm; mp; mp = mp->alllink) {
@@ -2825,7 +2825,7 @@ runtime·schedtrace(bool detailed)
 			lockedm ? lockedm->id : -1);
 	}
 	runtime·unlock(&allglock);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 }
 
 // Put mp on midle list.
@@ -2981,9 +2981,9 @@ runqputslow(P *p, G *gp, uint32 h, uint32 t)
 	for(i=0; i<n; i++)
 		batch[i]->schedlink = batch[i+1];
 	// Now put the batch on global queue.
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	globrunqputbatch(batch[0], batch[n], n+1);
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	return true;
 }
 
@@ -3146,11 +3146,11 @@ runtime·setmaxthreads(int32 in)
 {
 	int32 out;
 
-	runtime·lock(&runtime·sched);
+	runtime·lock(&runtime·sched.lock);
 	out = runtime·sched.maxmcount;
 	runtime·sched.maxmcount = in;
 	checkmcount();
-	runtime·unlock(&runtime·sched);
+	runtime·unlock(&runtime·sched.lock);
 	return out;
 }
 
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 1687b85c44..b85198f480 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -375,7 +375,7 @@ struct	M
 
 struct P
 {
-	Lock;
+	Lock	lock;
 
 	int32	id;
 	uint32	status;		// one of Pidle/Prunning/...
@@ -506,7 +506,7 @@ enum {
 
 struct	Timers
 {
-	Lock;
+	Lock	lock;
 	G	*timerproc;
 	bool		sleeping;
 	bool		rescheduling;
diff --git a/src/pkg/runtime/sema.goc b/src/pkg/runtime/sema.goc
index c1e8e4e18b..59a890c3e2 100644
--- a/src/pkg/runtime/sema.goc
+++ b/src/pkg/runtime/sema.goc
@@ -36,7 +36,7 @@ struct SemaWaiter
 typedef struct SemaRoot SemaRoot;
 struct SemaRoot
 {
-	Lock;
+	Lock		lock;
 	SemaWaiter*	head;
 	SemaWaiter*	tail;
 	// Number of waiters. Read w/o the lock.
@@ -48,7 +48,7 @@ struct SemaRoot
 
 struct semtable
 {
-	SemaRoot;
+	SemaRoot root;
 	uint8 pad[CacheLineSize-sizeof(SemaRoot)];
 };
 #pragma dataflag NOPTR /* mark semtable as 'no pointers', hiding from garbage collector */
@@ -57,7 +57,7 @@ static struct semtable semtable[SEMTABLESZ];
 static SemaRoot*
 semroot(uint32 *addr)
 {
-	return &semtable[((uintptr)addr >> 3) % SEMTABLESZ];
+	return &semtable[((uintptr)addr >> 3) % SEMTABLESZ].root;
 }
 
 static void
@@ -125,19 +125,19 @@ runtime·semacquire(uint32 volatile *addr, bool profile)
 		s.releasetime = -1;
 	}
 	for(;;) {
-		runtime·lock(root);
+		runtime·lock(&root->lock);
 		// Add ourselves to nwait to disable "easy case" in semrelease.
 		runtime·xadd(&root->nwait, 1);
 		// Check cansemacquire to avoid missed wakeup.
 		if(cansemacquire(addr)) {
 			runtime·xadd(&root->nwait, -1);
-			runtime·unlock(root);
+			runtime·unlock(&root->lock);
 			return;
 		}
 		// Any semrelease after the cansemacquire knows we're waiting
 		// (we set nwait above), so go to sleep.
 		semqueue(root, addr, &s);
-		runtime·parkunlock(root, "semacquire");
+		runtime·parkunlock(&root->lock, "semacquire");
 		if(cansemacquire(addr)) {
 			if(t0)
 				runtime·blockevent(s.releasetime - t0, 3);
@@ -162,11 +162,11 @@ runtime·semrelease(uint32 volatile *addr)
 		return;
 
 	// Harder case: search for a waiter and wake it.
-	runtime·lock(root);
+	runtime·lock(&root->lock);
 	if(runtime·atomicload(&root->nwait) == 0) {
 		// The count is already consumed by another goroutine,
 		// so no need to wake up another goroutine.
-		runtime·unlock(root);
+		runtime·unlock(&root->lock);
 		return;
 	}
 	for(s = root->head; s; s = s->next) {
@@ -176,7 +176,7 @@ runtime·semrelease(uint32 volatile *addr)
 			break;
 		}
 	}
-	runtime·unlock(root);
+	runtime·unlock(&root->lock);
 	if(s) {
 		if(s->releasetime)
 			s->releasetime = runtime·cputicks();
@@ -206,7 +206,7 @@ func runtime_Semrelease(addr *uint32) {
 typedef struct SyncSema SyncSema;
 struct SyncSema
 {
-	Lock;
+	Lock		lock;
 	SemaWaiter*	head;
 	SemaWaiter*	tail;
 };
@@ -233,7 +233,7 @@ func runtime_Syncsemacquire(s *SyncSema) {
 		w.releasetime = -1;
 	}
 
-	runtime·lock(s);
+	runtime·lock(&s->lock);
 	if(s->head && s->head->nrelease > 0) {
 		// have pending release, consume it
 		wake = nil;
@@ -244,7 +244,7 @@ func runtime_Syncsemacquire(s *SyncSema) {
 			if(s->head == nil)
 				s->tail = nil;
 		}
-		runtime·unlock(s);
+		runtime·unlock(&s->lock);
 		if(wake)
 			runtime·ready(wake->g);
 	} else {
@@ -254,7 +254,7 @@ func runtime_Syncsemacquire(s *SyncSema) {
 		else
 			s->tail->next = &w;
 		s->tail = &w;
-		runtime·parkunlock(s, "semacquire");
+		runtime·parkunlock(&s->lock, "semacquire");
 		if(t0)
 			runtime·blockevent(w.releasetime - t0, 2);
 	}
@@ -269,7 +269,7 @@ func runtime_Syncsemrelease(s *SyncSema, n uint32) {
 	w.next = nil;
 	w.releasetime = 0;
 
-	runtime·lock(s);
+	runtime·lock(&s->lock);
 	while(w.nrelease > 0 && s->head && s->head->nrelease < 0) {
 		// have pending acquire, satisfy it
 		wake = s->head;
@@ -288,7 +288,7 @@ func runtime_Syncsemrelease(s *SyncSema, n uint32) {
 		else
 			s->tail->next = &w;
 		s->tail = &w;
-		runtime·parkunlock(s, "semarelease");
+		runtime·parkunlock(&s->lock, "semarelease");
 	} else
-		runtime·unlock(s);
+		runtime·unlock(&s->lock);
 }
diff --git a/src/pkg/runtime/sigqueue.goc b/src/pkg/runtime/sigqueue.goc
index 376e77a2e4..fa0eb51a1c 100644
--- a/src/pkg/runtime/sigqueue.goc
+++ b/src/pkg/runtime/sigqueue.goc
@@ -33,7 +33,7 @@ package runtime
 
 #pragma textflag NOPTR
 static struct {
-	Note;
+	Note note;
 	uint32 mask[(NSIG+31)/32];
 	uint32 wanted[(NSIG+31)/32];
 	uint32 recv[(NSIG+31)/32];
@@ -72,7 +72,7 @@ runtime·sigsend(int32 s)
 					new = HASSIGNAL;
 				if(runtime·cas(&sig.state, old, new)) {
 					if (old == HASWAITER)
-						runtime·notewakeup(&sig);
+						runtime·notewakeup(&sig.note);
 					break;
 				}
 			}
@@ -108,8 +108,8 @@ func signal_recv() (m uint32) {
 				new = HASWAITER;
 			if(runtime·cas(&sig.state, old, new)) {
 				if (new == HASWAITER) {
-					runtime·notetsleepg(&sig, -1);
-					runtime·noteclear(&sig);
+					runtime·notetsleepg(&sig.note, -1);
+					runtime·noteclear(&sig.note);
 				}
 				break;
 			}
@@ -139,7 +139,7 @@ func signal_enable(s uint32) {
 		// to use for initialization.  It does not pass
 		// signal information in m.
 		sig.inuse = true;	// enable reception of signals; cannot disable
-		runtime·noteclear(&sig);
+		runtime·noteclear(&sig.note);
 		return;
 	}
 	
diff --git a/src/pkg/runtime/time.goc b/src/pkg/runtime/time.goc
index 10b8cea0ab..fa25671e6e 100644
--- a/src/pkg/runtime/time.goc
+++ b/src/pkg/runtime/time.goc
@@ -92,9 +92,9 @@ runtime·tsleep(int64 ns, int8 *reason)
 	t.period = 0;
 	t.fv = &readyv;
 	t.arg.data = g;
-	runtime·lock(&timers);
+	runtime·lock(&timers.lock);
 	addtimer(&t);
-	runtime·parkunlock(&timers, reason);
+	runtime·parkunlock(&timers.lock, reason);
 }
 
 static FuncVal timerprocv = {timerproc};
@@ -102,9 +102,9 @@ static FuncVal timerprocv = {timerproc};
 void
 runtime·addtimer(Timer *t)
 {
-	runtime·lock(&timers);
+	runtime·lock(&timers.lock);
 	addtimer(t);
-	runtime·unlock(&timers);
+	runtime·unlock(&timers.lock);
 }
 
 // Add a timer to the heap and start or kick the timer proc
@@ -165,14 +165,14 @@ runtime·deltimer(Timer *t)
 	i = t->i;
 	USED(i);
 
-	runtime·lock(&timers);
+	runtime·lock(&timers.lock);
 
 	// t may not be registered anymore and may have
 	// a bogus i (typically 0, if generated by Go).
 	// Verify it before proceeding.
 	i = t->i;
 	if(i < 0 || i >= timers.len || timers.t[i] != t) {
-		runtime·unlock(&timers);
+		runtime·unlock(&timers.lock);
 		return false;
 	}
 
@@ -188,7 +188,7 @@ runtime·deltimer(Timer *t)
 	}
 	if(debug)
 		dumptimers("deltimer");
-	runtime·unlock(&timers);
+	runtime·unlock(&timers.lock);
 	return true;
 }
 
@@ -205,7 +205,7 @@ timerproc(void)
 	Eface arg;
 
 	for(;;) {
-		runtime·lock(&timers);
+		runtime·lock(&timers.lock);
 		timers.sleeping = false;
 		now = runtime·nanotime();
 		for(;;) {
@@ -230,7 +230,7 @@ timerproc(void)
 			}
 			f = (void*)t->fv->fn;
 			arg = t->arg;
-			runtime·unlock(&timers);
+			runtime·unlock(&timers.lock);
 			if(raceenabled)
 				runtime·raceacquire(t);
 			f(now, arg);
@@ -242,20 +242,20 @@ timerproc(void)
 			arg.data = nil;
 			USED(&arg);
 
-			runtime·lock(&timers);
+			runtime·lock(&timers.lock);
 		}
 		if(delta < 0) {
 			// No timers left - put goroutine to sleep.
 			timers.rescheduling = true;
 			g->isbackground = true;
-			runtime·parkunlock(&timers, "timer goroutine (idle)");
+			runtime·parkunlock(&timers.lock, "timer goroutine (idle)");
 			g->isbackground = false;
 			continue;
 		}
 		// At least one timer pending.  Sleep until then.
 		timers.sleeping = true;
 		runtime·noteclear(&timers.waitnote);
-		runtime·unlock(&timers);
+		runtime·unlock(&timers.lock);
 		runtime·notetsleepg(&timers.waitnote, delta);
 	}
 }
diff --git a/src/pkg/runtime/type.h b/src/pkg/runtime/type.h
index 2eda291aed..1da37323eb 100644
--- a/src/pkg/runtime/type.h
+++ b/src/pkg/runtime/type.h
@@ -66,14 +66,14 @@ struct IMethod
 
 struct InterfaceType
 {
-	Type;
+	Type  typ;
 	Slice mhdr;
 	IMethod m[];
 };
 
 struct MapType
 {
-	Type;
+	Type typ;
 	Type *key;
 	Type *elem;
 	Type *bucket;		// internal type representing a hash bucket
@@ -87,20 +87,20 @@ struct MapType
 
 struct ChanType
 {
-	Type;
+	Type typ;
 	Type *elem;
 	uintptr dir;
 };
 
 struct SliceType
 {
-	Type;
+	Type typ;
 	Type *elem;
 };
 
 struct FuncType
 {
-	Type;
+	Type typ;
 	bool dotdotdot;
 	Slice in;
 	Slice out;
@@ -108,6 +108,6 @@ struct FuncType
 
 struct PtrType
 {
-	Type;
+	Type typ;
 	Type *elem;
 };
diff --git a/src/pkg/runtime/vlrt_386.c b/src/pkg/runtime/vlrt_386.c
index ace1beb4cc..bda67b1575 100644
--- a/src/pkg/runtime/vlrt_386.c
+++ b/src/pkg/runtime/vlrt_386.c
@@ -42,25 +42,15 @@ typedef	signed char	schar;
 
 #define	SIGN(n)	(1UL<<(n-1))
 
-typedef	struct	Vlong	Vlong;
-struct	Vlong
+typedef	union	Vlong	Vlong;
+union	Vlong
 {
-	union
+	long long	v;
+	struct
 	{
-		long long	v;
-		struct
-		{
-			ulong	lo;
-			ulong	hi;
-		};
-		struct
-		{
-			ushort	lols;
-			ushort	loms;
-			ushort	hils;
-			ushort	hims;
-		};
-	};
+		ulong	lo;
+		ulong	hi;
+	}		v2;
 };
 
 void	runtime·abort(void);
@@ -68,15 +58,15 @@ void	runtime·abort(void);
 void
 _d2v(Vlong *y, double d)
 {
-	union { double d; struct Vlong; } x;
+	union { double d; Vlong vl; } x;
 	ulong xhi, xlo, ylo, yhi;
 	int sh;
 
 	x.d = d;
 
-	xhi = (x.hi & 0xfffff) | 0x100000;
-	xlo = x.lo;
-	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+	xhi = (x.vl.v2.hi & 0xfffff) | 0x100000;
+	xlo = x.vl.v2.lo;
+	sh = 1075 - ((x.vl.v2.hi >> 20) & 0x7ff);
 
 	ylo = 0;
 	yhi = 0;
@@ -109,7 +99,7 @@ _d2v(Vlong *y, double d)
 			yhi = d;	/* causes something awful */
 		}
 	}
-	if(x.hi & SIGN(32)) {
+	if(x.vl.v2.hi & SIGN(32)) {
 		if(ylo != 0) {
 			ylo = -ylo;
 			yhi = ~yhi;
@@ -117,8 +107,8 @@ _d2v(Vlong *y, double d)
 			yhi = -yhi;
 	}
 
-	y->hi = yhi;
-	y->lo = ylo;
+	y->v2.hi = yhi;
+	y->v2.lo = ylo;
 }
 
 void
@@ -131,15 +121,15 @@ _f2v(Vlong *y, float f)
 double
 _v2d(Vlong x)
 {
-	if(x.hi & SIGN(32)) {
-		if(x.lo) {
-			x.lo = -x.lo;
-			x.hi = ~x.hi;
+	if(x.v2.hi & SIGN(32)) {
+		if(x.v2.lo) {
+			x.v2.lo = -x.v2.lo;
+			x.v2.hi = ~x.v2.hi;
 		} else
-			x.hi = -x.hi;
-		return -((long)x.hi*4294967296. + x.lo);
+			x.v2.hi = -x.v2.hi;
+		return -((long)x.v2.hi*4294967296. + x.v2.lo);
 	}
-	return (long)x.hi*4294967296. + x.lo;
+	return (long)x.v2.hi*4294967296. + x.v2.lo;
 }
 
 float
@@ -157,10 +147,10 @@ slowdodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
 	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
 	int i;
 
-	numhi = num.hi;
-	numlo = num.lo;
-	denhi = den.hi;
-	denlo = den.lo;
+	numhi = num.v2.hi;
+	numlo = num.v2.lo;
+	denhi = den.v2.hi;
+	denlo = den.v2.lo;
 
 	/*
 	 * get a divide by zero
@@ -204,12 +194,12 @@ slowdodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
 	}
 
 	if(q) {
-		q->lo = quolo;
-		q->hi = quohi;
+		q->v2.lo = quolo;
+		q->v2.hi = quohi;
 	}
 	if(r) {
-		r->lo = numlo;
-		r->hi = numhi;
+		r->v2.lo = numlo;
+		r->v2.hi = numhi;
 	}
 }
 
@@ -219,46 +209,46 @@ dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
 	ulong n;
 	Vlong x, q, r;
 
-	if(den.hi > num.hi || (den.hi == num.hi && den.lo > num.lo)){
+	if(den.v2.hi > num.v2.hi || (den.v2.hi == num.v2.hi && den.v2.lo > num.v2.lo)){
 		if(qp) {
-			qp->hi = 0;
-			qp->lo = 0;
+			qp->v2.hi = 0;
+			qp->v2.lo = 0;
 		}
 		if(rp) {
-			rp->hi = num.hi;
-			rp->lo = num.lo;
+			rp->v2.hi = num.v2.hi;
+			rp->v2.lo = num.v2.lo;
 		}
 		return;
 	}
 
-	if(den.hi != 0){
-		q.hi = 0;
-		n = num.hi/den.hi;
-		if(_mul64by32(&x, den, n) || x.hi > num.hi || (x.hi == num.hi && x.lo > num.lo))
+	if(den.v2.hi != 0){
+		q.v2.hi = 0;
+		n = num.v2.hi/den.v2.hi;
+		if(_mul64by32(&x, den, n) || x.v2.hi > num.v2.hi || (x.v2.hi == num.v2.hi && x.v2.lo > num.v2.lo))
 			slowdodiv(num, den, &q, &r);
 		else {
-			q.lo = n;
+			q.v2.lo = n;
 			r.v = num.v - x.v;
 		}
 	} else {
-		if(num.hi >= den.lo){
-			if(den.lo == 0)
+		if(num.v2.hi >= den.v2.lo){
+			if(den.v2.lo == 0)
 				runtime·panicdivide();
-			q.hi = n = num.hi/den.lo;
-			num.hi -= den.lo*n;
+			q.v2.hi = n = num.v2.hi/den.v2.lo;
+			num.v2.hi -= den.v2.lo*n;
 		} else {
-			q.hi = 0;
+			q.v2.hi = 0;
 		}
-		q.lo = _div64by32(num, den.lo, &r.lo);
-		r.hi = 0;
+		q.v2.lo = _div64by32(num, den.v2.lo, &r.v2.lo);
+		r.v2.hi = 0;
 	}
 	if(qp) {
-		qp->lo = q.lo;
-		qp->hi = q.hi;
+		qp->v2.lo = q.v2.lo;
+		qp->v2.hi = q.v2.hi;
 	}
 	if(rp) {
-		rp->lo = r.lo;
-		rp->hi = r.hi;
+		rp->v2.lo = r.v2.lo;
+		rp->v2.hi = r.v2.hi;
 	}
 }
 
@@ -266,11 +256,11 @@ void
 _divvu(Vlong *q, Vlong n, Vlong d)
 {
 
-	if(n.hi == 0 && d.hi == 0) {
-		if(d.lo == 0)
+	if(n.v2.hi == 0 && d.v2.hi == 0) {
+		if(d.v2.lo == 0)
 			runtime·panicdivide();
-		q->hi = 0;
-		q->lo = n.lo / d.lo;
+		q->v2.hi = 0;
+		q->v2.lo = n.v2.lo / d.v2.lo;
 		return;
 	}
 	dodiv(n, d, q, 0);
@@ -286,11 +276,11 @@ void
 _modvu(Vlong *r, Vlong n, Vlong d)
 {
 
-	if(n.hi == 0 && d.hi == 0) {
-		if(d.lo == 0)
+	if(n.v2.hi == 0 && d.v2.hi == 0) {
+		if(d.v2.lo == 0)
 			runtime·panicdivide();
-		r->hi = 0;
-		r->lo = n.lo % d.lo;
+		r->v2.hi = 0;
+		r->v2.lo = n.v2.lo % d.v2.lo;
 		return;
 	}
 	dodiv(n, d, 0, r);
@@ -306,12 +296,12 @@ static void
 vneg(Vlong *v)
 {
 
-	if(v->lo == 0) {
-		v->hi = -v->hi;
+	if(v->v2.lo == 0) {
+		v->v2.hi = -v->v2.hi;
 		return;
 	}
-	v->lo = -v->lo;
-	v->hi = ~v->hi;
+	v->v2.lo = -v->v2.lo;
+	v->v2.hi = ~v->v2.hi;
 }
 
 void
@@ -319,24 +309,24 @@ _divv(Vlong *q, Vlong n, Vlong d)
 {
 	long nneg, dneg;
 
-	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
-		if((long)n.lo == -0x80000000 && (long)d.lo == -1) {
+	if(n.v2.hi == (((long)n.v2.lo)>>31) && d.v2.hi == (((long)d.v2.lo)>>31)) {
+		if((long)n.v2.lo == -0x80000000 && (long)d.v2.lo == -1) {
 			// special case: 32-bit -0x80000000 / -1 causes divide error,
 			// but it's okay in this 64-bit context.
-			q->lo = 0x80000000;
-			q->hi = 0;
+			q->v2.lo = 0x80000000;
+			q->v2.hi = 0;
 			return;
 		}
-		if(d.lo == 0)
+		if(d.v2.lo == 0)
 			runtime·panicdivide();
-		q->lo = (long)n.lo / (long)d.lo;
-		q->hi = ((long)q->lo) >> 31;
+		q->v2.lo = (long)n.v2.lo / (long)d.v2.lo;
+		q->v2.hi = ((long)q->v2.lo) >> 31;
 		return;
 	}
-	nneg = n.hi >> 31;
+	nneg = n.v2.hi >> 31;
 	if(nneg)
 		vneg(&n);
-	dneg = d.hi >> 31;
+	dneg = d.v2.hi >> 31;
 	if(dneg)
 		vneg(&d);
 	dodiv(n, d, q, 0);
@@ -355,24 +345,24 @@ _modv(Vlong *r, Vlong n, Vlong d)
 {
 	long nneg, dneg;
 
-	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
-		if((long)n.lo == -0x80000000 && (long)d.lo == -1) {
+	if(n.v2.hi == (((long)n.v2.lo)>>31) && d.v2.hi == (((long)d.v2.lo)>>31)) {
+		if((long)n.v2.lo == -0x80000000 && (long)d.v2.lo == -1) {
 			// special case: 32-bit -0x80000000 % -1 causes divide error,
 			// but it's okay in this 64-bit context.
-			r->lo = 0;
-			r->hi = 0;
+			r->v2.lo = 0;
+			r->v2.hi = 0;
 			return;
 		}
-		if(d.lo == 0)
+		if(d.v2.lo == 0)
 			runtime·panicdivide();
-		r->lo = (long)n.lo % (long)d.lo;
-		r->hi = ((long)r->lo) >> 31;
+		r->v2.lo = (long)n.v2.lo % (long)d.v2.lo;
+		r->v2.hi = ((long)r->v2.lo) >> 31;
 		return;
 	}
-	nneg = n.hi >> 31;
+	nneg = n.v2.hi >> 31;
 	if(nneg)
 		vneg(&n);
-	dneg = d.hi >> 31;
+	dneg = d.v2.hi >> 31;
 	if(dneg)
 		vneg(&d);
 	dodiv(n, d, 0, r);
@@ -391,24 +381,24 @@ _rshav(Vlong *r, Vlong a, int b)
 {
 	long t;
 
-	t = a.hi;
+	t = a.v2.hi;
 	if(b >= 32) {
-		r->hi = t>>31;
+		r->v2.hi = t>>31;
 		if(b >= 64) {
 			/* this is illegal re C standard */
-			r->lo = t>>31;
+			r->v2.lo = t>>31;
 			return;
 		}
-		r->lo = t >> (b-32);
+		r->v2.lo = t >> (b-32);
 		return;
 	}
 	if(b <= 0) {
-		r->hi = t;
-		r->lo = a.lo;
+		r->v2.hi = t;
+		r->v2.lo = a.v2.lo;
 		return;
 	}
-	r->hi = t >> b;
-	r->lo = (t << (32-b)) | (a.lo >> b);
+	r->v2.hi = t >> b;
+	r->v2.lo = (t << (32-b)) | (a.v2.lo >> b);
 }
 
 void
@@ -416,24 +406,24 @@ _rshlv(Vlong *r, Vlong a, int b)
 {
 	ulong t;
 
-	t = a.hi;
+	t = a.v2.hi;
 	if(b >= 32) {
-		r->hi = 0;
+		r->v2.hi = 0;
 		if(b >= 64) {
 			/* this is illegal re C standard */
-			r->lo = 0;
+			r->v2.lo = 0;
 			return;
 		}
-		r->lo = t >> (b-32);
+		r->v2.lo = t >> (b-32);
 		return;
 	}
 	if(b <= 0) {
-		r->hi = t;
-		r->lo = a.lo;
+		r->v2.hi = t;
+		r->v2.lo = a.v2.lo;
 		return;
 	}
-	r->hi = t >> b;
-	r->lo = (t << (32-b)) | (a.lo >> b);
+	r->v2.hi = t >> b;
+	r->v2.lo = (t << (32-b)) | (a.v2.lo >> b);
 }
 
 #pragma textflag NOSPLIT
@@ -442,89 +432,89 @@ _lshv(Vlong *r, Vlong a, int b)
 {
 	ulong t;
 
-	t = a.lo;
+	t = a.v2.lo;
 	if(b >= 32) {
-		r->lo = 0;
+		r->v2.lo = 0;
 		if(b >= 64) {
 			/* this is illegal re C standard */
-			r->hi = 0;
+			r->v2.hi = 0;
 			return;
 		}
-		r->hi = t << (b-32);
+		r->v2.hi = t << (b-32);
 		return;
 	}
 	if(b <= 0) {
-		r->lo = t;
-		r->hi = a.hi;
+		r->v2.lo = t;
+		r->v2.hi = a.v2.hi;
 		return;
 	}
-	r->lo = t << b;
-	r->hi = (t >> (32-b)) | (a.hi << b);
+	r->v2.lo = t << b;
+	r->v2.hi = (t >> (32-b)) | (a.v2.hi << b);
 }
 
 void
 _andv(Vlong *r, Vlong a, Vlong b)
 {
-	r->hi = a.hi & b.hi;
-	r->lo = a.lo & b.lo;
+	r->v2.hi = a.v2.hi & b.v2.hi;
+	r->v2.lo = a.v2.lo & b.v2.lo;
 }
 
 void
 _orv(Vlong *r, Vlong a, Vlong b)
 {
-	r->hi = a.hi | b.hi;
-	r->lo = a.lo | b.lo;
+	r->v2.hi = a.v2.hi | b.v2.hi;
+	r->v2.lo = a.v2.lo | b.v2.lo;
 }
 
 void
 _xorv(Vlong *r, Vlong a, Vlong b)
 {
-	r->hi = a.hi ^ b.hi;
-	r->lo = a.lo ^ b.lo;
+	r->v2.hi = a.v2.hi ^ b.v2.hi;
+	r->v2.lo = a.v2.lo ^ b.v2.lo;
 }
 
 void
 _vpp(Vlong *l, Vlong *r)
 {
 
-	l->hi = r->hi;
-	l->lo = r->lo;
-	r->lo++;
-	if(r->lo == 0)
-		r->hi++;
+	l->v2.hi = r->v2.hi;
+	l->v2.lo = r->v2.lo;
+	r->v2.lo++;
+	if(r->v2.lo == 0)
+		r->v2.hi++;
 }
 
 void
 _vmm(Vlong *l, Vlong *r)
 {
 
-	l->hi = r->hi;
-	l->lo = r->lo;
-	if(r->lo == 0)
-		r->hi--;
-	r->lo--;
+	l->v2.hi = r->v2.hi;
+	l->v2.lo = r->v2.lo;
+	if(r->v2.lo == 0)
+		r->v2.hi--;
+	r->v2.lo--;
 }
 
 void
 _ppv(Vlong *l, Vlong *r)
 {
 
-	r->lo++;
-	if(r->lo == 0)
-		r->hi++;
-	l->hi = r->hi;
-	l->lo = r->lo;
+	r->v2.lo++;
+	if(r->v2.lo == 0)
+		r->v2.hi++;
+	l->v2.hi = r->v2.hi;
+	l->v2.lo = r->v2.lo;
 }
 
 void
 _mmv(Vlong *l, Vlong *r)
 {
 
-	if(r->lo == 0)
-		r->hi--;
-	r->lo--;
-	l->hi = r->hi;
-	l->lo = r->lo;
+	if(r->v2.lo == 0)
+		r->v2.hi--;
+	r->v2.lo--;
+	l->v2.hi = r->v2.hi;
+	l->v2.lo = r->v2.lo;
 }
 
 void
@@ -532,67 +522,67 @@ _vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
 {
 	Vlong t, u;
 
-	u.lo = 0;
-	u.hi = 0;
+	u.v2.lo = 0;
+	u.v2.hi = 0;
 	switch(type) {
 	default:
 		runtime·abort();
 		break;
 
 	case 1:	/* schar */
-		t.lo = *(schar*)lv;
-		t.hi = t.lo >> 31;
+		t.v2.lo = *(schar*)lv;
+		t.v2.hi = t.v2.lo >> 31;
 		fn(&u, t, rv);
-		*(schar*)lv = u.lo;
+		*(schar*)lv = u.v2.lo;
 		break;
 
 	case 2:	/* uchar */
-		t.lo = *(uchar*)lv;
-		t.hi = 0;
+		t.v2.lo = *(uchar*)lv;
+		t.v2.hi = 0;
 		fn(&u, t, rv);
-		*(uchar*)lv = u.lo;
+		*(uchar*)lv = u.v2.lo;
 		break;
 
 	case 3:	/* short */
-		t.lo = *(short*)lv;
-		t.hi = t.lo >> 31;
+		t.v2.lo = *(short*)lv;
+		t.v2.hi = t.v2.lo >> 31;
 		fn(&u, t, rv);
-		*(short*)lv = u.lo;
+		*(short*)lv = u.v2.lo;
 		break;
 
 	case 4:	/* ushort */
-		t.lo = *(ushort*)lv;
-		t.hi = 0;
+		t.v2.lo = *(ushort*)lv;
+		t.v2.hi = 0;
 		fn(&u, t, rv);
-		*(ushort*)lv = u.lo;
+		*(ushort*)lv = u.v2.lo;
 		break;
 
 	case 9:	/* int */
-		t.lo = *(int*)lv;
-		t.hi = t.lo >> 31;
+		t.v2.lo = *(int*)lv;
+		t.v2.hi = t.v2.lo >> 31;
 		fn(&u, t, rv);
-		*(int*)lv = u.lo;
+		*(int*)lv = u.v2.lo;
 		break;
 
 	case 10:	/* uint */
-		t.lo = *(uint*)lv;
-		t.hi = 0;
+		t.v2.lo = *(uint*)lv;
+		t.v2.hi = 0;
 		fn(&u, t, rv);
-		*(uint*)lv = u.lo;
+		*(uint*)lv = u.v2.lo;
 		break;
 
 	case 5:	/* long */
-		t.lo = *(long*)lv;
-		t.hi = t.lo >> 31;
+		t.v2.lo = *(long*)lv;
+		t.v2.hi = t.v2.lo >> 31;
 		fn(&u, t, rv);
-		*(long*)lv = u.lo;
+		*(long*)lv = u.v2.lo;
 		break;
 
 	case 6:	/* ulong */
-		t.lo = *(ulong*)lv;
-		t.hi = 0;
+		t.v2.lo = *(ulong*)lv;
+		t.v2.hi = 0;
 		fn(&u, t, rv);
-		*(ulong*)lv = u.lo;
+		*(ulong*)lv = u.v2.lo;
 		break;
 
 	case 7:	/* vlong */
@@ -610,8 +600,8 @@ _p2v(Vlong *ret, void *p)
 	long t;
 
 	t = (ulong)p;
-	ret->lo = t;
-	ret->hi = 0;
+	ret->v2.lo = t;
+	ret->v2.hi = 0;
 }
 
 void
@@ -620,8 +610,8 @@ _sl2v(Vlong *ret, long sl)
 	long t;
 
 	t = sl;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret->v2.lo = t;
+	ret->v2.hi = t >> 31;
 }
 
 void
@@ -630,8 +620,8 @@ _ul2v(Vlong *ret, ulong ul)
 	long t;
 
 	t = ul;
-	ret->lo = t;
-	ret->hi = 0;
+	ret->v2.lo = t;
+	ret->v2.hi = 0;
 }
 
 void
@@ -640,8 +630,8 @@ _si2v(Vlong *ret, int si)
 	long t;
 
 	t = si;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret->v2.lo = t;
+	ret->v2.hi = t >> 31;
 }
 
 void
@@ -650,8 +640,8 @@ _ui2v(Vlong *ret, uint ui)
 	long t;
 
 	t = ui;
-	ret->lo = t;
-	ret->hi = 0;
+	ret->v2.lo = t;
+	ret->v2.hi = 0;
 }
 
 void
@@ -660,8 +650,8 @@ _sh2v(Vlong *ret, long sh)
 	long t;
 
 	t = (sh << 16) >> 16;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret->v2.lo = t;
+	ret->v2.hi = t >> 31;
 }
 
 void
@@ -670,8 +660,8 @@ _uh2v(Vlong *ret, ulong ul)
 	long t;
 
 	t = ul & 0xffff;
-	ret->lo = t;
-	ret->hi = 0;
+	ret->v2.lo = t;
+	ret->v2.hi = 0;
 }
 
 void
@@ -680,8 +670,8 @@ _sc2v(Vlong *ret, long uc)
 	long t;
 
 	t = (uc << 24) >> 24;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret->v2.lo = t;
+	ret->v2.hi = t >> 31;
 }
 
 void
@@ -690,8 +680,8 @@ _uc2v(Vlong *ret, ulong ul)
 	long t;
 
 	t = ul & 0xff;
-	ret->lo = t;
-	ret->hi = 0;
+	ret->v2.lo = t;
+	ret->v2.hi = 0;
 }
 
 long
@@ -699,7 +689,7 @@ _v2sc(Vlong rv)
 {
 	long t;
 
-	t = rv.lo & 0xff;
+	t = rv.v2.lo & 0xff;
 	return (t << 24) >> 24;
 }
 
@@ -707,7 +697,7 @@ long
 _v2uc(Vlong rv)
 {
 
-	return rv.lo & 0xff;
+	return rv.v2.lo & 0xff;
 }
 
 long
@@ -715,7 +705,7 @@ _v2sh(Vlong rv)
 {
 	long t;
 
-	t = rv.lo & 0xffff;
+	t = rv.v2.lo & 0xffff;
 	return (t << 16) >> 16;
 }
 
@@ -723,107 +713,107 @@ long
 _v2uh(Vlong rv)
 {
 
-	return rv.lo & 0xffff;
+	return rv.v2.lo & 0xffff;
 }
 
 long
 _v2sl(Vlong rv)
 {
 
-	return rv.lo;
+	return rv.v2.lo;
 }
 
 long
 _v2ul(Vlong rv)
 {
 
-	return rv.lo;
+	return rv.v2.lo;
 }
 
 long
 _v2si(Vlong rv)
 {
 
-	return rv.lo;
+	return rv.v2.lo;
 }
 
 long
 _v2ui(Vlong rv)
 {
 
-	return rv.lo;
+	return rv.v2.lo;
 }
 
 int
 _testv(Vlong rv)
 {
-	return rv.lo || rv.hi;
+	return rv.v2.lo || rv.v2.hi;
 }
 
 int
 _eqv(Vlong lv, Vlong rv)
 {
-	return lv.lo == rv.lo && lv.hi == rv.hi;
+	return lv.v2.lo == rv.v2.lo && lv.v2.hi == rv.v2.hi;
 }
 
 int
 _nev(Vlong lv, Vlong rv)
 {
-	return lv.lo != rv.lo || lv.hi != rv.hi;
+	return lv.v2.lo != rv.v2.lo || lv.v2.hi != rv.v2.hi;
 }
 
 int
 _ltv(Vlong lv, Vlong rv)
 {
-	return (long)lv.hi < (long)rv.hi ||
-		(lv.hi == rv.hi && lv.lo < rv.lo);
+	return (long)lv.v2.hi < (long)rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo < rv.v2.lo);
 }
 
 int
 _lev(Vlong lv, Vlong rv)
 {
-	return (long)lv.hi < (long)rv.hi ||
-		(lv.hi == rv.hi && lv.lo <= rv.lo);
+	return (long)lv.v2.hi < (long)rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo <= rv.v2.lo);
 }
 
 int
 _gtv(Vlong lv, Vlong rv)
 {
-	return (long)lv.hi > (long)rv.hi ||
-		(lv.hi == rv.hi && lv.lo > rv.lo);
+	return (long)lv.v2.hi > (long)rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo > rv.v2.lo);
 }
 
 int
 _gev(Vlong lv, Vlong rv)
 {
-	return (long)lv.hi > (long)rv.hi ||
-		(lv.hi == rv.hi && lv.lo >= rv.lo);
+	return (long)lv.v2.hi > (long)rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo >= rv.v2.lo);
 }
 
 int
 _lov(Vlong lv, Vlong rv)
 {
-	return lv.hi < rv.hi ||
-		(lv.hi == rv.hi && lv.lo < rv.lo);
+	return lv.v2.hi < rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo < rv.v2.lo);
 }
 
 int
 _lsv(Vlong lv, Vlong rv)
 {
-	return lv.hi < rv.hi ||
-		(lv.hi == rv.hi && lv.lo <= rv.lo);
+	return lv.v2.hi < rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo <= rv.v2.lo);
 }
 
 int
 _hiv(Vlong lv, Vlong rv)
 {
-	return lv.hi > rv.hi ||
-		(lv.hi == rv.hi && lv.lo > rv.lo);
+	return lv.v2.hi > rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo > rv.v2.lo);
 }
 
 int
 _hsv(Vlong lv, Vlong rv)
 {
-	return lv.hi > rv.hi ||
-		(lv.hi == rv.hi && lv.lo >= rv.lo);
+	return lv.v2.hi > rv.v2.hi ||
+		(lv.v2.hi == rv.v2.hi && lv.v2.lo >= rv.v2.lo);
 }
diff --git a/src/pkg/runtime/vlrt_arm.c b/src/pkg/runtime/vlrt_arm.c
index 016fd7a357..48ae08be32 100644
--- a/src/pkg/runtime/vlrt_arm.c
+++ b/src/pkg/runtime/vlrt_arm.c
@@ -40,21 +40,8 @@ typedef signed char     schar;
 typedef struct  Vlong   Vlong;
 struct  Vlong
 {
-	union
-	{
-		struct
-		{
-			ulong   lo;
-			ulong   hi;
-		};
-		struct
-		{
-			ushort lols;
-			ushort loms;
-			ushort hils;
-			ushort hims;
-		};
-	};
+	ulong   lo;
+	ulong   hi;
 };
 
 void    runtime·abort(void);
@@ -82,15 +69,15 @@ _subv(Vlong *r, Vlong a, Vlong b)
 void
 _d2v(Vlong *y, double d)
 {
-	union { double d; struct Vlong; } x;
+	union { double d; Vlong vl; } x;
 	ulong xhi, xlo, ylo, yhi;
 	int sh;
 
 	x.d = d;
 
-	xhi = (x.hi & 0xfffff) | 0x100000;
-	xlo = x.lo;
-	sh = 1075 - ((x.hi >> 20) & 0x7ff);
+	xhi = (x.vl.hi & 0xfffff) | 0x100000;
+	xlo = x.vl.lo;
+	sh = 1075 - ((x.vl.hi >> 20) & 0x7ff);
 
 	ylo = 0;
 	yhi = 0;
@@ -123,7 +110,7 @@ _d2v(Vlong *y, double d)
 			yhi = d;        /* causes something awful */
 		}
 	}
-	if(x.hi & SIGN(32)) {
+	if(x.vl.hi & SIGN(32)) {
 		if(ylo != 0) {
 			ylo = -ylo;
 			yhi = ~yhi;

From fad69a7b77a7996b0308bdbcd559b78b32046bb3 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Thu, 7 Aug 2014 23:24:32 +1000
Subject: [PATCH 023/423] cmd/fix: mention -help instead of the non-existent -?
 flag

Update #8314

TBR=r
R=golang-codereviews
CC=golang-codereviews
https://golang.org/cl/123890043
---
 src/cmd/fix/doc.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/fix/doc.go b/src/cmd/fix/doc.go
index 5de3e08c59..0570169576 100644
--- a/src/cmd/fix/doc.go
+++ b/src/cmd/fix/doc.go
@@ -27,7 +27,7 @@ rewrites are idempotent, so that it is safe to apply fix to updated
 or partially updated code even without using the -r flag.
 
 Fix prints the full list of fixes it can apply in its help output;
-to see them, run go tool fix -?.
+to see them, run go tool fix -help.
 
 Fix does not make backup copies of the files that it edits.
 Instead, use a version control system's ``diff'' functionality to inspect

From 08033f9816e1e33092c93c050dc34514d8e3e926 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 7 Aug 2014 12:33:06 -0400
Subject: [PATCH 024/423] cmd/addr2line, cmd/nm: factor object reading into
 cmd/internal/objfile

To do in another CL: make cmd/objdump use cmd/internal/objfile too.

There is a package placement decision in this CL:
cmd/internal/objfile instead of internal/objfile.
I chose to put internal under cmd to make clear (and enforce)
that no standard library packages should use this
(it's a bit dependency-heavy).

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/123910043
---
 src/cmd/addr2line/main.go                 | 159 +--------------------
 src/cmd/{nm => internal/objfile}/elf.go   |  48 +++++--
 src/cmd/{nm => internal/objfile}/goobj.go |  35 +++--
 src/cmd/{nm => internal/objfile}/macho.go |  53 +++++--
 src/cmd/internal/objfile/objfile.go       |  72 ++++++++++
 src/cmd/internal/objfile/pe.go            | 161 ++++++++++++++++++++++
 src/cmd/internal/objfile/plan9obj.go      | 100 ++++++++++++++
 src/cmd/nm/nm.go                          |  57 ++------
 src/cmd/nm/nm_test.go                     |   4 +-
 src/cmd/nm/pe.go                          |  98 -------------
 src/cmd/nm/plan9obj.go                    |  48 -------
 11 files changed, 448 insertions(+), 387 deletions(-)
 rename src/cmd/{nm => internal/objfile}/elf.go (52%)
 rename src/cmd/{nm => internal/objfile}/goobj.go (72%)
 rename src/cmd/{nm => internal/objfile}/macho.go (55%)
 create mode 100644 src/cmd/internal/objfile/objfile.go
 create mode 100644 src/cmd/internal/objfile/pe.go
 create mode 100644 src/cmd/internal/objfile/plan9obj.go
 delete mode 100644 src/cmd/nm/pe.go
 delete mode 100644 src/cmd/nm/plan9obj.go

diff --git a/src/cmd/addr2line/main.go b/src/cmd/addr2line/main.go
index 3802f764f9..267f4170a8 100644
--- a/src/cmd/addr2line/main.go
+++ b/src/cmd/addr2line/main.go
@@ -19,17 +19,14 @@ package main
 
 import (
 	"bufio"
-	"debug/elf"
-	"debug/gosym"
-	"debug/macho"
-	"debug/pe"
-	"debug/plan9obj"
 	"flag"
 	"fmt"
 	"log"
 	"os"
 	"strconv"
 	"strings"
+
+	"cmd/internal/objfile"
 )
 
 func printUsage(w *os.File) {
@@ -60,18 +57,12 @@ func main() {
 		usage()
 	}
 
-	f, err := os.Open(flag.Arg(0))
+	f, err := objfile.Open(flag.Arg(0))
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	textStart, symtab, pclntab, err := loadTables(f)
-	if err != nil {
-		log.Fatalf("reading %s: %v", flag.Arg(0), err)
-	}
-
-	pcln := gosym.NewLineTable(pclntab, textStart)
-	tab, err := gosym.NewTable(symtab, pcln)
+	tab, err := f.PCLineTable()
 	if err != nil {
 		log.Fatalf("reading %s: %v", flag.Arg(0), err)
 	}
@@ -102,145 +93,3 @@ func main() {
 	}
 	stdout.Flush()
 }
-
-func loadTables(f *os.File) (textStart uint64, symtab, pclntab []byte, err error) {
-	if obj, err := elf.NewFile(f); err == nil {
-		if sect := obj.Section(".text"); sect != nil {
-			textStart = sect.Addr
-		}
-		if sect := obj.Section(".gosymtab"); sect != nil {
-			if symtab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		if sect := obj.Section(".gopclntab"); sect != nil {
-			if pclntab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		return textStart, symtab, pclntab, nil
-	}
-
-	if obj, err := macho.NewFile(f); err == nil {
-		if sect := obj.Section("__text"); sect != nil {
-			textStart = sect.Addr
-		}
-		if sect := obj.Section("__gosymtab"); sect != nil {
-			if symtab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		if sect := obj.Section("__gopclntab"); sect != nil {
-			if pclntab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		return textStart, symtab, pclntab, nil
-	}
-
-	if obj, err := pe.NewFile(f); err == nil {
-		var imageBase uint64
-		switch oh := obj.OptionalHeader.(type) {
-		case *pe.OptionalHeader32:
-			imageBase = uint64(oh.ImageBase)
-		case *pe.OptionalHeader64:
-			imageBase = oh.ImageBase
-		default:
-			return 0, nil, nil, fmt.Errorf("pe file format not recognized")
-		}
-		if sect := obj.Section(".text"); sect != nil {
-			textStart = imageBase + uint64(sect.VirtualAddress)
-		}
-		if pclntab, err = loadPETable(obj, "pclntab", "epclntab"); err != nil {
-			return 0, nil, nil, err
-		}
-		if symtab, err = loadPETable(obj, "symtab", "esymtab"); err != nil {
-			return 0, nil, nil, err
-		}
-		return textStart, symtab, pclntab, nil
-	}
-
-	if obj, err := plan9obj.NewFile(f); err == nil {
-		textStart = obj.LoadAddress + obj.HdrSize
-		if pclntab, err = loadPlan9Table(obj, "pclntab", "epclntab"); err != nil {
-			return 0, nil, nil, err
-		}
-		if symtab, err = loadPlan9Table(obj, "symtab", "esymtab"); err != nil {
-			return 0, nil, nil, err
-		}
-		return textStart, symtab, pclntab, nil
-	}
-
-	return 0, nil, nil, fmt.Errorf("unrecognized binary format")
-}
-
-func findPESymbol(f *pe.File, name string) (*pe.Symbol, error) {
-	for _, s := range f.Symbols {
-		if s.Name != name {
-			continue
-		}
-		if s.SectionNumber <= 0 {
-			return nil, fmt.Errorf("symbol %s: invalid section number %d", name, s.SectionNumber)
-		}
-		if len(f.Sections) < int(s.SectionNumber) {
-			return nil, fmt.Errorf("symbol %s: section number %d is larger than max %d", name, s.SectionNumber, len(f.Sections))
-		}
-		return s, nil
-	}
-	return nil, fmt.Errorf("no %s symbol found", name)
-}
-
-func loadPETable(f *pe.File, sname, ename string) ([]byte, error) {
-	ssym, err := findPESymbol(f, sname)
-	if err != nil {
-		return nil, err
-	}
-	esym, err := findPESymbol(f, ename)
-	if err != nil {
-		return nil, err
-	}
-	if ssym.SectionNumber != esym.SectionNumber {
-		return nil, fmt.Errorf("%s and %s symbols must be in the same section", sname, ename)
-	}
-	sect := f.Sections[ssym.SectionNumber-1]
-	data, err := sect.Data()
-	if err != nil {
-		return nil, err
-	}
-	return data[ssym.Value:esym.Value], nil
-}
-
-func findPlan9Symbol(f *plan9obj.File, name string) (*plan9obj.Sym, error) {
-	syms, err := f.Symbols()
-	if err != nil {
-		return nil, err
-	}
-	for _, s := range syms {
-		if s.Name != name {
-			continue
-		}
-		return &s, nil
-	}
-	return nil, fmt.Errorf("no %s symbol found", name)
-}
-
-func loadPlan9Table(f *plan9obj.File, sname, ename string) ([]byte, error) {
-	ssym, err := findPlan9Symbol(f, sname)
-	if err != nil {
-		return nil, err
-	}
-	esym, err := findPlan9Symbol(f, ename)
-	if err != nil {
-		return nil, err
-	}
-	sect := f.Section("text")
-	if sect == nil {
-		return nil, err
-	}
-	data, err := sect.Data()
-	if err != nil {
-		return nil, err
-	}
-	textStart := f.LoadAddress + f.HdrSize
-	return data[ssym.Value-textStart : esym.Value-textStart], nil
-}
diff --git a/src/cmd/nm/elf.go b/src/cmd/internal/objfile/elf.go
similarity index 52%
rename from src/cmd/nm/elf.go
rename to src/cmd/internal/objfile/elf.go
index 5aaa194dd1..8495fa7532 100644
--- a/src/cmd/nm/elf.go
+++ b/src/cmd/internal/objfile/elf.go
@@ -4,24 +4,29 @@
 
 // Parsing of ELF executables (Linux, FreeBSD, and so on).
 
-package main
+package objfile
 
 import (
 	"debug/elf"
 	"os"
 )
 
-func elfSymbols(f *os.File) []Sym {
-	p, err := elf.NewFile(f)
-	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
-	}
+type elfFile struct {
+	elf *elf.File
+}
 
-	elfSyms, err := p.Symbols()
+func openElf(r *os.File) (rawFile, error) {
+	f, err := elf.NewFile(r)
 	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
+		return nil, err
+	}
+	return &elfFile{f}, nil
+}
+
+func (f *elfFile) symbols() ([]Sym, error) {
+	elfSyms, err := f.elf.Symbols()
+	if err != nil {
+		return nil, err
 	}
 
 	var syms []Sym
@@ -34,10 +39,10 @@ func elfSymbols(f *os.File) []Sym {
 			sym.Code = 'B'
 		default:
 			i := int(s.Section)
-			if i < 0 || i >= len(p.Sections) {
+			if i < 0 || i >= len(f.elf.Sections) {
 				break
 			}
-			sect := p.Sections[i]
+			sect := f.elf.Sections[i]
 			switch sect.Flags & (elf.SHF_WRITE | elf.SHF_ALLOC | elf.SHF_EXECINSTR) {
 			case elf.SHF_ALLOC | elf.SHF_EXECINSTR:
 				sym.Code = 'T'
@@ -53,5 +58,22 @@ func elfSymbols(f *os.File) []Sym {
 		syms = append(syms, sym)
 	}
 
-	return syms
+	return syms, nil
+}
+
+func (f *elfFile) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
+	if sect := f.elf.Section(".text"); sect != nil {
+		textStart = sect.Addr
+	}
+	if sect := f.elf.Section(".gosymtab"); sect != nil {
+		if symtab, err = sect.Data(); err != nil {
+			return 0, nil, nil, err
+		}
+	}
+	if sect := f.elf.Section(".gopclntab"); sect != nil {
+		if pclntab, err = sect.Data(); err != nil {
+			return 0, nil, nil, err
+		}
+	}
+	return textStart, symtab, pclntab, nil
 }
diff --git a/src/cmd/nm/goobj.go b/src/cmd/internal/objfile/goobj.go
similarity index 72%
rename from src/cmd/nm/goobj.go
rename to src/cmd/internal/objfile/goobj.go
index b0de51db9c..a4f49ebe44 100644
--- a/src/cmd/nm/goobj.go
+++ b/src/cmd/internal/objfile/goobj.go
@@ -4,7 +4,7 @@
 
 // Parsing of Go intermediate object files and archives.
 
-package main
+package objfile
 
 import (
 	"debug/goobj"
@@ -12,6 +12,18 @@ import (
 	"os"
 )
 
+type goobjFile struct {
+	goobj *goobj.Package
+}
+
+func openGoobj(r *os.File) (rawFile, error) {
+	f, err := goobj.Parse(r, `""`)
+	if err != nil {
+		return nil, err
+	}
+	return &goobjFile{f}, nil
+}
+
 func goobjName(id goobj.SymID) string {
 	if id.Version == 0 {
 		return id.Name
@@ -19,17 +31,11 @@ func goobjName(id goobj.SymID) string {
 	return fmt.Sprintf("%s<%d>", id.Name, id.Version)
 }
 
-func goobjSymbols(f *os.File) []Sym {
-	pkg, err := goobj.Parse(f, `""`)
-	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
-	}
-
+func (f *goobjFile) symbols() ([]Sym, error) {
 	seen := make(map[goobj.SymID]bool)
 
 	var syms []Sym
-	for _, s := range pkg.Syms {
+	for _, s := range f.goobj.Syms {
 		seen[s.SymID] = true
 		sym := Sym{Addr: uint64(s.Data.Offset), Name: goobjName(s.SymID), Size: int64(s.Size), Type: s.Type.Name, Code: '?'}
 		switch s.Kind {
@@ -50,7 +56,7 @@ func goobjSymbols(f *os.File) []Sym {
 		syms = append(syms, sym)
 	}
 
-	for _, s := range pkg.Syms {
+	for _, s := range f.goobj.Syms {
 		for _, r := range s.Reloc {
 			if !seen[r.Sym] {
 				seen[r.Sym] = true
@@ -64,5 +70,12 @@ func goobjSymbols(f *os.File) []Sym {
 		}
 	}
 
-	return syms
+	return syms, nil
+}
+
+// pcln does not make sense for Go object files, because each
+// symbol has its own individual pcln table, so there is no global
+// space of addresses to map.
+func (f *goobjFile) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
+	return 0, nil, nil, fmt.Errorf("pcln not available in go object file")
 }
diff --git a/src/cmd/nm/macho.go b/src/cmd/internal/objfile/macho.go
similarity index 55%
rename from src/cmd/nm/macho.go
rename to src/cmd/internal/objfile/macho.go
index c60bde55b4..f845792ffa 100644
--- a/src/cmd/nm/macho.go
+++ b/src/cmd/internal/objfile/macho.go
@@ -4,36 +4,42 @@
 
 // Parsing of Mach-O executables (OS X).
 
-package main
+package objfile
 
 import (
 	"debug/macho"
+	"fmt"
 	"os"
 	"sort"
 )
 
-func machoSymbols(f *os.File) []Sym {
-	p, err := macho.NewFile(f)
-	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
-	}
+type machoFile struct {
+	macho *macho.File
+}
 
-	if p.Symtab == nil {
-		errorf("%s: no symbol table", f.Name())
-		return nil
+func openMacho(r *os.File) (rawFile, error) {
+	f, err := macho.NewFile(r)
+	if err != nil {
+		return nil, err
+	}
+	return &machoFile{f}, nil
+}
+
+func (f *machoFile) symbols() ([]Sym, error) {
+	if f.macho.Symtab == nil {
+		return nil, fmt.Errorf("missing symbol table")
 	}
 
 	// Build sorted list of addresses of all symbols.
 	// We infer the size of a symbol by looking at where the next symbol begins.
 	var addrs []uint64
-	for _, s := range p.Symtab.Syms {
+	for _, s := range f.macho.Symtab.Syms {
 		addrs = append(addrs, s.Value)
 	}
 	sort.Sort(uint64s(addrs))
 
 	var syms []Sym
-	for _, s := range p.Symtab.Syms {
+	for _, s := range f.macho.Symtab.Syms {
 		sym := Sym{Name: s.Name, Addr: s.Value, Code: '?'}
 		i := sort.Search(len(addrs), func(x int) bool { return addrs[x] > s.Value })
 		if i < len(addrs) {
@@ -41,8 +47,8 @@ func machoSymbols(f *os.File) []Sym {
 		}
 		if s.Sect == 0 {
 			sym.Code = 'U'
-		} else if int(s.Sect) <= len(p.Sections) {
-			sect := p.Sections[s.Sect-1]
+		} else if int(s.Sect) <= len(f.macho.Sections) {
+			sect := f.macho.Sections[s.Sect-1]
 			switch sect.Seg {
 			case "__TEXT":
 				sym.Code = 'R'
@@ -59,7 +65,24 @@ func machoSymbols(f *os.File) []Sym {
 		syms = append(syms, sym)
 	}
 
-	return syms
+	return syms, nil
+}
+
+func (f *machoFile) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
+	if sect := f.macho.Section("__text"); sect != nil {
+		textStart = sect.Addr
+	}
+	if sect := f.macho.Section("__gosymtab"); sect != nil {
+		if symtab, err = sect.Data(); err != nil {
+			return 0, nil, nil, err
+		}
+	}
+	if sect := f.macho.Section("__gopclntab"); sect != nil {
+		if pclntab, err = sect.Data(); err != nil {
+			return 0, nil, nil, err
+		}
+	}
+	return textStart, symtab, pclntab, nil
 }
 
 type uint64s []uint64
diff --git a/src/cmd/internal/objfile/objfile.go b/src/cmd/internal/objfile/objfile.go
new file mode 100644
index 0000000000..09fa63e60b
--- /dev/null
+++ b/src/cmd/internal/objfile/objfile.go
@@ -0,0 +1,72 @@
+// 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 objfile implements portable access to OS-specific executable files.
+package objfile
+
+import (
+	"debug/gosym"
+	"fmt"
+	"os"
+)
+
+type rawFile interface {
+	symbols() (syms []Sym, err error)
+	pcln() (textStart uint64, symtab, pclntab []byte, err error)
+}
+
+// A File is an opened executable file.
+type File struct {
+	r   *os.File
+	raw rawFile
+}
+
+// A Sym is a symbol defined in an executable file.
+type Sym struct {
+	Name string // symbol name
+	Addr uint64 // virtual address of symbol
+	Size int64  // size in bytes
+	Code rune   // nm code (T for text, D for data, and so on)
+	Type string // XXX?
+}
+
+var openers = []func(*os.File) (rawFile, error){
+	openElf,
+	openGoobj,
+	openMacho,
+	openPE,
+	openPlan9,
+}
+
+// Open opens the named file.
+// The caller must call f.Close when the file is no longer needed.
+func Open(name string) (*File, error) {
+	r, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	for _, try := range openers {
+		if raw, err := try(r); err == nil {
+			return &File{r, raw}, nil
+		}
+	}
+	r.Close()
+	return nil, fmt.Errorf("open %s: unrecognized object file", name)
+}
+
+func (f *File) Close() error {
+	return f.r.Close()
+}
+
+func (f *File) Symbols() ([]Sym, error) {
+	return f.raw.symbols()
+}
+
+func (f *File) PCLineTable() (*gosym.Table, error) {
+	textStart, symtab, pclntab, err := f.raw.pcln()
+	if err != nil {
+		return nil, err
+	}
+	return gosym.NewTable(symtab, gosym.NewLineTable(pclntab, textStart))
+}
diff --git a/src/cmd/internal/objfile/pe.go b/src/cmd/internal/objfile/pe.go
new file mode 100644
index 0000000000..492766d9a2
--- /dev/null
+++ b/src/cmd/internal/objfile/pe.go
@@ -0,0 +1,161 @@
+// 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.
+
+// Parsing of PE executables (Microsoft Windows).
+
+package objfile
+
+import (
+	"debug/pe"
+	"fmt"
+	"os"
+	"sort"
+)
+
+type peFile struct {
+	pe *pe.File
+}
+
+func openPE(r *os.File) (rawFile, error) {
+	f, err := pe.NewFile(r)
+	if err != nil {
+		return nil, err
+	}
+	switch f.OptionalHeader.(type) {
+	case *pe.OptionalHeader32, *pe.OptionalHeader64:
+		// ok
+	default:
+		return nil, fmt.Errorf("unrecognized PE format")
+	}
+	return &peFile{f}, nil
+}
+
+func (f *peFile) symbols() ([]Sym, error) {
+	// Build sorted list of addresses of all symbols.
+	// We infer the size of a symbol by looking at where the next symbol begins.
+	var addrs []uint64
+
+	var imageBase uint64
+	switch oh := f.pe.OptionalHeader.(type) {
+	case *pe.OptionalHeader32:
+		imageBase = uint64(oh.ImageBase)
+	case *pe.OptionalHeader64:
+		imageBase = oh.ImageBase
+	}
+
+	var syms []Sym
+	for _, s := range f.pe.Symbols {
+		const (
+			N_UNDEF = 0  // An undefined (extern) symbol
+			N_ABS   = -1 // An absolute symbol (e_value is a constant, not an address)
+			N_DEBUG = -2 // A debugging symbol
+		)
+		sym := Sym{Name: s.Name, Addr: uint64(s.Value), Code: '?'}
+		switch s.SectionNumber {
+		case N_UNDEF:
+			sym.Code = 'U'
+		case N_ABS:
+			sym.Code = 'C'
+		case N_DEBUG:
+			sym.Code = '?'
+		default:
+			if s.SectionNumber < 0 || len(f.pe.Sections) < int(s.SectionNumber) {
+				return nil, fmt.Errorf("invalid section number in symbol table")
+			}
+			sect := f.pe.Sections[s.SectionNumber-1]
+			const (
+				text  = 0x20
+				data  = 0x40
+				bss   = 0x80
+				permX = 0x20000000
+				permR = 0x40000000
+				permW = 0x80000000
+			)
+			ch := sect.Characteristics
+			switch {
+			case ch&text != 0:
+				sym.Code = 'T'
+			case ch&data != 0:
+				if ch&permW == 0 {
+					sym.Code = 'R'
+				} else {
+					sym.Code = 'D'
+				}
+			case ch&bss != 0:
+				sym.Code = 'B'
+			}
+			sym.Addr += imageBase + uint64(sect.VirtualAddress)
+		}
+		syms = append(syms, sym)
+		addrs = append(addrs, sym.Addr)
+	}
+
+	sort.Sort(uint64s(addrs))
+	for i := range syms {
+		j := sort.Search(len(addrs), func(x int) bool { return addrs[x] > syms[i].Addr })
+		if j < len(addrs) {
+			syms[i].Size = int64(addrs[j] - syms[i].Addr)
+		}
+	}
+
+	return syms, nil
+}
+
+func (f *peFile) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
+	var imageBase uint64
+	switch oh := f.pe.OptionalHeader.(type) {
+	case *pe.OptionalHeader32:
+		imageBase = uint64(oh.ImageBase)
+	case *pe.OptionalHeader64:
+		imageBase = oh.ImageBase
+	default:
+		return 0, nil, nil, fmt.Errorf("pe file format not recognized")
+	}
+	if sect := f.pe.Section(".text"); sect != nil {
+		textStart = imageBase + uint64(sect.VirtualAddress)
+	}
+	if pclntab, err = loadPETable(f.pe, "pclntab", "epclntab"); err != nil {
+		return 0, nil, nil, err
+	}
+	if symtab, err = loadPETable(f.pe, "symtab", "esymtab"); err != nil {
+		return 0, nil, nil, err
+	}
+	return textStart, symtab, pclntab, nil
+}
+
+func findPESymbol(f *pe.File, name string) (*pe.Symbol, error) {
+	for _, s := range f.Symbols {
+		if s.Name != name {
+			continue
+		}
+		if s.SectionNumber <= 0 {
+			return nil, fmt.Errorf("symbol %s: invalid section number %d", name, s.SectionNumber)
+		}
+		if len(f.Sections) < int(s.SectionNumber) {
+			return nil, fmt.Errorf("symbol %s: section number %d is larger than max %d", name, s.SectionNumber, len(f.Sections))
+		}
+		return s, nil
+	}
+	return nil, fmt.Errorf("no %s symbol found", name)
+}
+
+func loadPETable(f *pe.File, sname, ename string) ([]byte, error) {
+	ssym, err := findPESymbol(f, sname)
+	if err != nil {
+		return nil, err
+	}
+	esym, err := findPESymbol(f, ename)
+	if err != nil {
+		return nil, err
+	}
+	if ssym.SectionNumber != esym.SectionNumber {
+		return nil, fmt.Errorf("%s and %s symbols must be in the same section", sname, ename)
+	}
+	sect := f.Sections[ssym.SectionNumber-1]
+	data, err := sect.Data()
+	if err != nil {
+		return nil, err
+	}
+	return data[ssym.Value:esym.Value], nil
+}
diff --git a/src/cmd/internal/objfile/plan9obj.go b/src/cmd/internal/objfile/plan9obj.go
new file mode 100644
index 0000000000..3fe05ec03b
--- /dev/null
+++ b/src/cmd/internal/objfile/plan9obj.go
@@ -0,0 +1,100 @@
+// 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.
+
+// Parsing of Plan 9 a.out executables.
+
+package objfile
+
+import (
+	"debug/plan9obj"
+	"fmt"
+	"os"
+	"sort"
+)
+
+type plan9File struct {
+	plan9 *plan9obj.File
+}
+
+func openPlan9(r *os.File) (rawFile, error) {
+	f, err := plan9obj.NewFile(r)
+	if err != nil {
+		return nil, err
+	}
+	return &plan9File{f}, nil
+}
+
+func (f *plan9File) symbols() ([]Sym, error) {
+	plan9Syms, err := f.plan9.Symbols()
+	if err != nil {
+		return nil, err
+	}
+
+	// Build sorted list of addresses of all symbols.
+	// We infer the size of a symbol by looking at where the next symbol begins.
+	var addrs []uint64
+	for _, s := range plan9Syms {
+		addrs = append(addrs, s.Value)
+	}
+	sort.Sort(uint64s(addrs))
+
+	var syms []Sym
+
+	for _, s := range plan9Syms {
+		sym := Sym{Addr: s.Value, Name: s.Name, Code: rune(s.Type)}
+		i := sort.Search(len(addrs), func(x int) bool { return addrs[x] > s.Value })
+		if i < len(addrs) {
+			sym.Size = int64(addrs[i] - s.Value)
+		}
+		syms = append(syms, sym)
+	}
+
+	return syms, nil
+}
+
+func (f *plan9File) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
+	textStart = f.plan9.LoadAddress + f.plan9.HdrSize
+	if pclntab, err = loadPlan9Table(f.plan9, "pclntab", "epclntab"); err != nil {
+		return 0, nil, nil, err
+	}
+	if symtab, err = loadPlan9Table(f.plan9, "symtab", "esymtab"); err != nil {
+		return 0, nil, nil, err
+	}
+	return textStart, symtab, pclntab, nil
+}
+
+func findPlan9Symbol(f *plan9obj.File, name string) (*plan9obj.Sym, error) {
+	syms, err := f.Symbols()
+	if err != nil {
+		return nil, err
+	}
+	for _, s := range syms {
+		if s.Name != name {
+			continue
+		}
+		return &s, nil
+	}
+	return nil, fmt.Errorf("no %s symbol found", name)
+}
+
+func loadPlan9Table(f *plan9obj.File, sname, ename string) ([]byte, error) {
+	ssym, err := findPlan9Symbol(f, sname)
+	if err != nil {
+		return nil, err
+	}
+	esym, err := findPlan9Symbol(f, ename)
+	if err != nil {
+		return nil, err
+	}
+	sect := f.Section("text")
+	if sect == nil {
+		return nil, err
+	}
+	data, err := sect.Data()
+	if err != nil {
+		return nil, err
+	}
+	textStart := f.LoadAddress + f.HdrSize
+	return data[ssym.Value-textStart : esym.Value-textStart], nil
+}
diff --git a/src/cmd/nm/nm.go b/src/cmd/nm/nm.go
index a4036184e4..3089e481be 100644
--- a/src/cmd/nm/nm.go
+++ b/src/cmd/nm/nm.go
@@ -6,13 +6,13 @@ package main
 
 import (
 	"bufio"
-	"bytes"
 	"flag"
 	"fmt"
-	"io"
 	"log"
 	"os"
 	"sort"
+
+	"cmd/internal/objfile"
 )
 
 func usage() {
@@ -85,55 +85,22 @@ func errorf(format string, args ...interface{}) {
 	exitCode = 1
 }
 
-type Sym struct {
-	Addr uint64
-	Size int64
-	Code rune
-	Name string
-	Type string
-}
-
-var parsers = []struct {
-	prefix []byte
-	parse  func(*os.File) []Sym
-}{
-	{[]byte("!<arch>\n"), goobjSymbols},
-	{[]byte("go object "), goobjSymbols},
-	{[]byte("\x7FELF"), elfSymbols},
-	{[]byte("\xFE\xED\xFA\xCE"), machoSymbols},
-	{[]byte("\xFE\xED\xFA\xCF"), machoSymbols},
-	{[]byte("\xCE\xFA\xED\xFE"), machoSymbols},
-	{[]byte("\xCF\xFA\xED\xFE"), machoSymbols},
-	{[]byte("MZ"), peSymbols},
-	{[]byte("\x00\x00\x01\xEB"), plan9Symbols}, // 386
-	{[]byte("\x00\x00\x04\x07"), plan9Symbols}, // mips
-	{[]byte("\x00\x00\x06\x47"), plan9Symbols}, // arm
-	{[]byte("\x00\x00\x8A\x97"), plan9Symbols}, // amd64
-}
-
 func nm(file string) {
-	f, err := os.Open(file)
+	f, err := objfile.Open(file)
 	if err != nil {
 		errorf("%v", err)
 		return
 	}
 	defer f.Close()
 
-	buf := make([]byte, 16)
-	io.ReadFull(f, buf)
-	f.Seek(0, 0)
-
-	var syms []Sym
-	for _, p := range parsers {
-		if bytes.HasPrefix(buf, p.prefix) {
-			syms = p.parse(f)
-			goto HaveSyms
-		}
+	syms, err := f.Symbols()
+	if err != nil {
+		errorf("reading %s: %v", file, err)
+	}
+	if len(syms) == 0 {
+		errorf("reading %s: no symbols", file)
 	}
-	errorf("%v: unknown file format", file)
-	return
 
-HaveSyms:
 	switch *sortOrder {
 	case "address":
 		sort.Sort(byAddr(syms))
@@ -165,19 +132,19 @@ HaveSyms:
 	w.Flush()
 }
 
-type byAddr []Sym
+type byAddr []objfile.Sym
 
 func (x byAddr) Len() int           { return len(x) }
 func (x byAddr) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 func (x byAddr) Less(i, j int) bool { return x[i].Addr < x[j].Addr }
 
-type byName []Sym
+type byName []objfile.Sym
 
 func (x byName) Len() int           { return len(x) }
 func (x byName) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 func (x byName) Less(i, j int) bool { return x[i].Name < x[j].Name }
 
-type bySize []Sym
+type bySize []objfile.Sym
 
 func (x bySize) Len() int           { return len(x) }
 func (x bySize) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
diff --git a/src/cmd/nm/nm_test.go b/src/cmd/nm/nm_test.go
index 74773877f3..f447e8e491 100644
--- a/src/cmd/nm/nm_test.go
+++ b/src/cmd/nm/nm_test.go
@@ -77,7 +77,7 @@ func TestNM(t *testing.T) {
 		"elf/testdata/gcc-amd64-linux-exec",
 		"macho/testdata/gcc-386-darwin-exec",
 		"macho/testdata/gcc-amd64-darwin-exec",
-		"pe/testdata/gcc-amd64-mingw-exec",
+		// "pe/testdata/gcc-amd64-mingw-exec", // no symbols!
 		"pe/testdata/gcc-386-mingw-exec",
 		"plan9obj/testdata/amd64-plan9-exec",
 		"plan9obj/testdata/386-plan9-exec",
@@ -87,7 +87,7 @@ func TestNM(t *testing.T) {
 		cmd := exec.Command(testnmpath, exepath)
 		out, err := cmd.CombinedOutput()
 		if err != nil {
-			t.Fatalf("go tool nm %v: %v\n%s", exepath, err, string(out))
+			t.Errorf("go tool nm %v: %v\n%s", exepath, err, string(out))
 		}
 	}
 
diff --git a/src/cmd/nm/pe.go b/src/cmd/nm/pe.go
deleted file mode 100644
index 52d05e51d0..0000000000
--- a/src/cmd/nm/pe.go
+++ /dev/null
@@ -1,98 +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.
-
-// Parsing of PE executables (Microsoft Windows).
-
-package main
-
-import (
-	"debug/pe"
-	"os"
-	"sort"
-)
-
-func peSymbols(f *os.File) []Sym {
-	p, err := pe.NewFile(f)
-	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
-	}
-
-	// Build sorted list of addresses of all symbols.
-	// We infer the size of a symbol by looking at where the next symbol begins.
-	var addrs []uint64
-
-	var imageBase uint64
-	switch oh := p.OptionalHeader.(type) {
-	case *pe.OptionalHeader32:
-		imageBase = uint64(oh.ImageBase)
-	case *pe.OptionalHeader64:
-		imageBase = oh.ImageBase
-	default:
-		errorf("parsing %s: file format not recognized", f.Name())
-		return nil
-	}
-
-	var syms []Sym
-	for _, s := range p.Symbols {
-		const (
-			N_UNDEF = 0  // An undefined (extern) symbol
-			N_ABS   = -1 // An absolute symbol (e_value is a constant, not an address)
-			N_DEBUG = -2 // A debugging symbol
-		)
-		sym := Sym{Name: s.Name, Addr: uint64(s.Value), Code: '?'}
-		switch s.SectionNumber {
-		case N_UNDEF:
-			sym.Code = 'U'
-		case N_ABS:
-			sym.Code = 'C'
-		case N_DEBUG:
-			sym.Code = '?'
-		default:
-			if s.SectionNumber < 0 {
-				errorf("parsing %s: invalid section number %d", f.Name(), s.SectionNumber)
-				return nil
-			}
-			if len(p.Sections) < int(s.SectionNumber) {
-				errorf("parsing %s: section number %d is large then max %d", f.Name(), s.SectionNumber, len(p.Sections))
-				return nil
-			}
-			sect := p.Sections[s.SectionNumber-1]
-			const (
-				text  = 0x20
-				data  = 0x40
-				bss   = 0x80
-				permX = 0x20000000
-				permR = 0x40000000
-				permW = 0x80000000
-			)
-			ch := sect.Characteristics
-			switch {
-			case ch&text != 0:
-				sym.Code = 'T'
-			case ch&data != 0:
-				if ch&permW == 0 {
-					sym.Code = 'R'
-				} else {
-					sym.Code = 'D'
-				}
-			case ch&bss != 0:
-				sym.Code = 'B'
-			}
-			sym.Addr += imageBase + uint64(sect.VirtualAddress)
-		}
-		syms = append(syms, sym)
-		addrs = append(addrs, sym.Addr)
-	}
-
-	sort.Sort(uint64s(addrs))
-	for i := range syms {
-		j := sort.Search(len(addrs), func(x int) bool { return addrs[x] > syms[i].Addr })
-		if j < len(addrs) {
-			syms[i].Size = int64(addrs[j] - syms[i].Addr)
-		}
-	}
-
-	return syms
-}
diff --git a/src/cmd/nm/plan9obj.go b/src/cmd/nm/plan9obj.go
deleted file mode 100644
index 006c66ebfd..0000000000
--- a/src/cmd/nm/plan9obj.go
+++ /dev/null
@@ -1,48 +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.
-
-// Parsing of Plan 9 a.out executables.
-
-package main
-
-import (
-	"debug/plan9obj"
-	"os"
-	"sort"
-)
-
-func plan9Symbols(f *os.File) []Sym {
-	p, err := plan9obj.NewFile(f)
-	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
-	}
-
-	plan9Syms, err := p.Symbols()
-	if err != nil {
-		errorf("parsing %s: %v", f.Name(), err)
-		return nil
-	}
-
-	// Build sorted list of addresses of all symbols.
-	// We infer the size of a symbol by looking at where the next symbol begins.
-	var addrs []uint64
-	for _, s := range plan9Syms {
-		addrs = append(addrs, s.Value)
-	}
-	sort.Sort(uint64s(addrs))
-
-	var syms []Sym
-
-	for _, s := range plan9Syms {
-		sym := Sym{Addr: s.Value, Name: s.Name, Code: rune(s.Type)}
-		i := sort.Search(len(addrs), func(x int) bool { return addrs[x] > s.Value })
-		if i < len(addrs) {
-			sym.Size = int64(addrs[i] - s.Value)
-		}
-		syms = append(syms, sym)
-	}
-
-	return syms
-}

From d078d483ce87b4311f79e988a0b609d3c53d3cb4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 7 Aug 2014 12:33:19 -0400
Subject: [PATCH 025/423] go/build: look in $GOROOT/src/cmd/foo/bar for import
 cmd/foo/bar

This lets us have non-main packages like cmd/internal or cmd/nm/internal/whatever.

The src/pkg migration (see golang.org/s/go14mainrepo) will allow this
as a natural side effect. The explicit change here just allows use of the
effect a little sooner.

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/117630043
---
 src/pkg/go/build/build.go      |  7 ++++++-
 src/pkg/go/build/build_test.go | 10 ++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/pkg/go/build/build.go b/src/pkg/go/build/build.go
index 09730d6351..6db0275032 100644
--- a/src/pkg/go/build/build.go
+++ b/src/pkg/go/build/build.go
@@ -521,7 +521,12 @@ func (ctxt *Context) Import(path string, srcDir string, mode ImportMode) (*Packa
 
 		// Determine directory from import path.
 		if ctxt.GOROOT != "" {
-			dir := ctxt.joinPath(ctxt.GOROOT, "src", "pkg", path)
+			var dir string
+			if strings.HasPrefix(path, "cmd/") {
+				dir = ctxt.joinPath(ctxt.GOROOT, "src", path)
+			} else {
+				dir = ctxt.joinPath(ctxt.GOROOT, "src", "pkg", path)
+			}
 			isDir := ctxt.isDir(dir)
 			binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(ctxt.GOROOT, pkga))
 			if isDir || binaryOnly {
diff --git a/src/pkg/go/build/build_test.go b/src/pkg/go/build/build_test.go
index f0d243cd53..0040101134 100644
--- a/src/pkg/go/build/build_test.go
+++ b/src/pkg/go/build/build_test.go
@@ -193,3 +193,13 @@ func TestMatchFile(t *testing.T) {
 		}
 	}
 }
+
+func TestImportCmd(t *testing.T) {
+	p, err := Import("cmd/internal/objfile", "", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasSuffix(filepath.ToSlash(p.Dir), "src/cmd/internal/objfile") {
+		t.Fatalf("Import cmd/internal/objfile returned Dir=%q, want %q", filepath.ToSlash(p.Dir), ".../src/cmd/internal/objfile")
+	}
+}

From cc063592b0307552af9fd80f03be6276838e52f9 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 7 Aug 2014 21:39:32 +0400
Subject: [PATCH 026/423] encoding/gob: make benchmarks parallel There are lots
 of internal synchronization in gob, so it makes sense to have parallel
 benchmarks. Also add a benchmark with slices and interfaces.

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/115960043
---
 src/pkg/encoding/gob/timing_test.go | 57 +++++++++++++++++++----------
 1 file changed, 38 insertions(+), 19 deletions(-)

diff --git a/src/pkg/encoding/gob/timing_test.go b/src/pkg/encoding/gob/timing_test.go
index acfb065b12..29c9b858b6 100644
--- a/src/pkg/encoding/gob/timing_test.go
+++ b/src/pkg/encoding/gob/timing_test.go
@@ -19,33 +19,52 @@ type Bench struct {
 	D []byte
 }
 
-func benchmarkEndToEnd(r io.Reader, w io.Writer, b *testing.B) {
-	b.StopTimer()
-	enc := NewEncoder(w)
-	dec := NewDecoder(r)
-	bench := &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		if enc.Encode(bench) != nil {
-			panic("encode error")
+func benchmarkEndToEnd(b *testing.B, v interface{}, pipe func() (r io.Reader, w io.Writer, err error)) {
+	b.RunParallel(func(pb *testing.PB) {
+		r, w, err := pipe()
+		if err != nil {
+			b.Fatal("can't get pipe:", err)
 		}
-		if dec.Decode(bench) != nil {
-			panic("decode error")
+		enc := NewEncoder(w)
+		dec := NewDecoder(r)
+		for pb.Next() {
+			if err := enc.Encode(v); err != nil {
+				b.Fatal("encode error:", err)
+			}
+			if err := dec.Decode(v); err != nil {
+				b.Fatal("decode error:", err)
+			}
 		}
-	}
+	})
 }
 
 func BenchmarkEndToEndPipe(b *testing.B) {
-	r, w, err := os.Pipe()
-	if err != nil {
-		b.Fatal("can't get pipe:", err)
-	}
-	benchmarkEndToEnd(r, w, b)
+	v := &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
+	benchmarkEndToEnd(b, v, func() (r io.Reader, w io.Writer, err error) {
+		r, w, err = os.Pipe()
+		return
+	})
 }
 
 func BenchmarkEndToEndByteBuffer(b *testing.B) {
-	var buf bytes.Buffer
-	benchmarkEndToEnd(&buf, &buf, b)
+	v := &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
+	benchmarkEndToEnd(b, v, func() (r io.Reader, w io.Writer, err error) {
+		var buf bytes.Buffer
+		return &buf, &buf, nil
+	})
+}
+
+func BenchmarkEndToEndSliceByteBuffer(b *testing.B) {
+	v := &Bench{7, 3.2, "now is the time", nil}
+	Register(v)
+	arr := make([]interface{}, 100)
+	for i := range arr {
+		arr[i] = v
+	}
+	benchmarkEndToEnd(b, &arr, func() (r io.Reader, w io.Writer, err error) {
+		var buf bytes.Buffer
+		return &buf, &buf, nil
+	})
 }
 
 func TestCountEncodeMallocs(t *testing.T) {

From 3d7e3691207fd9dabfe12a560ecac473e7e59737 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Thu, 7 Aug 2014 12:33:20 -0700
Subject: [PATCH 027/423] runtime: test distribution of interface hashes.

LGTM=dvyukov
R=dvyukov, khr
CC=golang-codereviews
https://golang.org/cl/121030043
---
 src/pkg/runtime/alg.go         | 10 ++++++
 src/pkg/runtime/export_test.go |  2 ++
 src/pkg/runtime/hash_test.go   | 60 ++++++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+)

diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index f2bb202c68..ea4156f1ed 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -163,3 +163,13 @@ func int32Hash(i uint32, seed uintptr) uintptr {
 func int64Hash(i uint64, seed uintptr) uintptr {
 	return goalg(&algarray[alg_MEM64]).hash(noescape(unsafe.Pointer(&i)), 8, seed)
 }
+
+func efaceHash(i interface{}, seed uintptr) uintptr {
+	return goalg(&algarray[alg_NILINTER]).hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
+}
+
+func ifaceHash(i interface {
+	F()
+}, seed uintptr) uintptr {
+	return goalg(&algarray[alg_INTER]).hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
+}
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 01b47e17af..32c34aade6 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -76,6 +76,8 @@ var StringHash = stringHash
 var BytesHash = bytesHash
 var Int32Hash = int32Hash
 var Int64Hash = int64Hash
+var EfaceHash = efaceHash
+var IfaceHash = ifaceHash
 
 var HashLoad = &hashLoad
 
diff --git a/src/pkg/runtime/hash_test.go b/src/pkg/runtime/hash_test.go
index 1c11e0538d..41fff98eb0 100644
--- a/src/pkg/runtime/hash_test.go
+++ b/src/pkg/runtime/hash_test.go
@@ -344,6 +344,64 @@ func (k *Int64Key) name() string {
 	return "int64"
 }
 
+type EfaceKey struct {
+	i interface{}
+}
+
+func (k *EfaceKey) clear() {
+	k.i = nil
+}
+func (k *EfaceKey) random(r *rand.Rand) {
+	k.i = uint64(r.Int63())
+}
+func (k *EfaceKey) bits() int {
+	// use 64 bits.  This tests inlined interfaces
+	// on 64-bit targets and indirect interfaces on
+	// 32-bit targets.
+	return 64
+}
+func (k *EfaceKey) flipBit(i int) {
+	k.i = k.i.(uint64) ^ uint64(1)<<uint(i)
+}
+func (k *EfaceKey) hash() uintptr {
+	return EfaceHash(k.i, 0)
+}
+func (k *EfaceKey) name() string {
+	return "Eface"
+}
+
+type IfaceKey struct {
+	i interface {
+		F()
+	}
+}
+type fInter uint64
+
+func (x fInter) F() {
+}
+
+func (k *IfaceKey) clear() {
+	k.i = nil
+}
+func (k *IfaceKey) random(r *rand.Rand) {
+	k.i = fInter(r.Int63())
+}
+func (k *IfaceKey) bits() int {
+	// use 64 bits.  This tests inlined interfaces
+	// on 64-bit targets and indirect interfaces on
+	// 32-bit targets.
+	return 64
+}
+func (k *IfaceKey) flipBit(i int) {
+	k.i = k.i.(fInter) ^ fInter(1)<<uint(i)
+}
+func (k *IfaceKey) hash() uintptr {
+	return IfaceHash(k.i, 0)
+}
+func (k *IfaceKey) name() string {
+	return "Iface"
+}
+
 // Flipping a single bit of a key should flip each output bit with 50% probability.
 func TestSmhasherAvalanche(t *testing.T) {
 	if !HaveGoodHash() {
@@ -360,6 +418,8 @@ func TestSmhasherAvalanche(t *testing.T) {
 	avalancheTest1(t, &BytesKey{make([]byte, 200)})
 	avalancheTest1(t, &Int32Key{})
 	avalancheTest1(t, &Int64Key{})
+	avalancheTest1(t, &EfaceKey{})
+	avalancheTest1(t, &IfaceKey{})
 }
 func avalancheTest1(t *testing.T, k Key) {
 	const REP = 100000

From 7fdb0292a5e322c302b5ab685d8ee2623a69608a Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 7 Aug 2014 12:38:39 -0700
Subject: [PATCH 028/423] cmd/go: pass --build-id=none when generating a cgo .o

Some systems, like Ubuntu, pass --build-id when linking.  The
effect is to put a note in the output file.  This is not
useful when generating an object file with the -r option, as
it eventually causes multiple build ID notes in the final
executable, all but one of which are for tiny portions of the
file and are therefore useless.

Disable that by passing an explicit --build-id=none when
linking with -r on systems that might do this.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/119460043
---
 misc/cgo/test/buildid_linux.go  | 77 +++++++++++++++++++++++++++++++++
 misc/cgo/test/cgo_linux_test.go |  5 ++-
 src/cmd/go/build.go             | 18 +++++++-
 3 files changed, 97 insertions(+), 3 deletions(-)
 create mode 100644 misc/cgo/test/buildid_linux.go

diff --git a/misc/cgo/test/buildid_linux.go b/misc/cgo/test/buildid_linux.go
new file mode 100644
index 0000000000..a3a86edfca
--- /dev/null
+++ b/misc/cgo/test/buildid_linux.go
@@ -0,0 +1,77 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cgotest
+
+// Test that we have no more than one build ID.  In the past we used
+// to generate a separate build ID for each package using cgo, and the
+// linker concatenated them all.  We don't want that--we only want
+// one.
+
+import (
+	"bytes"
+	"debug/elf"
+	"os"
+	"testing"
+)
+
+func testBuildID(t *testing.T) {
+	f, err := elf.Open("/proc/self/exe")
+	if err != nil {
+		if os.IsNotExist(err) {
+			t.Skip("no /proc/self/exe")
+		}
+		t.Fatalf("opening /proc/self/exe: ", err)
+	}
+	defer f.Close()
+
+	c := 0
+	for i, s := range f.Sections {
+		if s.Type != elf.SHT_NOTE {
+			continue
+		}
+
+		d, err := s.Data()
+		if err != nil {
+			t.Logf("reading data of note section %d: %v", i, err)
+			continue
+		}
+
+		for len(d) > 0 {
+
+			// ELF standards differ as to the sizes in
+			// note sections.  Both the GNU linker and
+			// gold always generate 32-bit sizes, so that
+			// is what we assume here.
+
+			if len(d) < 12 {
+				t.Logf("note section %d too short (%d < 12)", i, len(d))
+				continue
+			}
+
+			namesz := f.ByteOrder.Uint32(d)
+			descsz := f.ByteOrder.Uint32(d[4:])
+			typ := f.ByteOrder.Uint32(d[8:])
+
+			an := (namesz + 3) &^ 3
+			ad := (descsz + 3) &^ 3
+
+			if int(12+an+ad) > len(d) {
+				t.Logf("note section %d too short for header (%d < 12 + align(%d,4) + align(%d,4))", i, len(d), namesz, descsz)
+				continue
+			}
+
+			// 3 == NT_GNU_BUILD_ID
+			if typ == 3 && namesz == 4 && bytes.Equal(d[12:16], []byte("GNU\000")) {
+				c++
+			}
+
+			d = d[12+an+ad:]
+		}
+	}
+
+	if c > 1 {
+		t.Errorf("found %d build ID notes", c)
+	}
+}
diff --git a/misc/cgo/test/cgo_linux_test.go b/misc/cgo/test/cgo_linux_test.go
index 0a405c7a3b..4fe0db1b2b 100644
--- a/misc/cgo/test/cgo_linux_test.go
+++ b/misc/cgo/test/cgo_linux_test.go
@@ -6,5 +6,6 @@ package cgotest
 
 import "testing"
 
-func TestSetgid(t *testing.T) { testSetgid(t) }
-func Test6997(t *testing.T)   { test6997(t) }
+func TestSetgid(t *testing.T)  { testSetgid(t) }
+func Test6997(t *testing.T)    { test6997(t) }
+func TestBuildID(t *testing.T) { testBuildID(t) }
diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index fa9262c0f0..b39364ed89 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -2312,7 +2312,23 @@ func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles, gxxfiles, mfiles
 			nonGccObjs = append(nonGccObjs, f)
 		}
 	}
-	if err := b.gccld(p, ofile, stringList(bareLDFLAGS, "-Wl,-r", "-nostdlib", staticLibs), gccObjs); err != nil {
+	ldflags := stringList(bareLDFLAGS, "-Wl,-r", "-nostdlib", staticLibs)
+
+	// Some systems, such as Ubuntu, always add --build-id to
+	// every link, but we don't want a build ID since we are
+	// producing an object file.  On some of those system a plain
+	// -r (not -Wl,-r) will turn off --build-id, but clang 3.0
+	// doesn't support a plain -r.  I don't know how to turn off
+	// --build-id when using clang other than passing a trailing
+	// --build-id=none.  So that is what we do, but only on
+	// systems likely to support it, which is to say, systems that
+	// normally use gold or the GNU linker.
+	switch goos {
+	case "android", "dragonfly", "freebsd", "linux", "netbsd", "openbsd":
+		ldflags = append(ldflags, "-Wl,--build-id=none")
+	}
+
+	if err := b.gccld(p, ofile, ldflags, gccObjs); err != nil {
 		return nil, nil, err
 	}
 

From a3c0ca54b01284af40e684422a739d41b4cb9cfe Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 7 Aug 2014 12:45:01 -0700
Subject: [PATCH 029/423] go/parser: don't do method receiver checks at
 parse-time

The ast and printer don't care, and go/types can provide
a better error message.

This change requires an update to the tests for go/types
(go.tools repo). CL forthcoming.

Fixes #8493.

LGTM=adonovan
R=rsc, adonovan
CC=golang-codereviews
https://golang.org/cl/123010044
---
 src/pkg/go/parser/parser.go | 32 +-------------------------------
 1 file changed, 1 insertion(+), 31 deletions(-)

diff --git a/src/pkg/go/parser/parser.go b/src/pkg/go/parser/parser.go
index 8291f3f42d..4d6f36258c 100644
--- a/src/pkg/go/parser/parser.go
+++ b/src/pkg/go/parser/parser.go
@@ -2307,36 +2307,6 @@ func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.Gen
 	}
 }
 
-func (p *parser) parseReceiver(scope *ast.Scope) *ast.FieldList {
-	if p.trace {
-		defer un(trace(p, "Receiver"))
-	}
-
-	par := p.parseParameters(scope, false)
-
-	// must have exactly one receiver
-	if par.NumFields() != 1 {
-		p.errorExpected(par.Opening, "exactly one receiver")
-		par.List = []*ast.Field{{Type: &ast.BadExpr{From: par.Opening, To: par.Closing + 1}}}
-		return par
-	}
-
-	// recv type must be of the form ["*"] identifier, possibly using parentheses
-	recv := par.List[0]
-	base := unparen(deref(unparen(recv.Type)))
-	if _, isIdent := base.(*ast.Ident); !isIdent {
-		if _, isBad := base.(*ast.BadExpr); !isBad {
-			// only report error if it's a new one
-			p.errorExpected(base.Pos(), "(unqualified) identifier")
-		}
-		par.List = []*ast.Field{
-			{Type: &ast.BadExpr{From: recv.Pos(), To: p.safePos(recv.End())}},
-		}
-	}
-
-	return par
-}
-
 func (p *parser) parseFuncDecl() *ast.FuncDecl {
 	if p.trace {
 		defer un(trace(p, "FunctionDecl"))
@@ -2348,7 +2318,7 @@ func (p *parser) parseFuncDecl() *ast.FuncDecl {
 
 	var recv *ast.FieldList
 	if p.tok == token.LPAREN {
-		recv = p.parseReceiver(scope)
+		recv = p.parseParameters(scope, false)
 	}
 
 	ident := p.parseIdent()

From 3a3f8993ced61bf103e77d229722d0ce33fd0090 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 7 Aug 2014 23:47:01 +0400
Subject: [PATCH 030/423] runtime: fix nacl/amd64p32 build C compiler does not
 support unnamed fields.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/124870043
---
 src/pkg/runtime/defs_nacl_amd64p32.h   | 2 +-
 src/pkg/runtime/signal_nacl_amd64p32.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/defs_nacl_amd64p32.h b/src/pkg/runtime/defs_nacl_amd64p32.h
index 8d3068bf87..45663d40af 100644
--- a/src/pkg/runtime/defs_nacl_amd64p32.h
+++ b/src/pkg/runtime/defs_nacl_amd64p32.h
@@ -79,7 +79,7 @@ struct ExcContext
 	union {
 		ExcRegs386	regs;
 		ExcRegsAmd64	regs64;
-	};
+	} regs;
 };
 
 struct ExcPortableContext
diff --git a/src/pkg/runtime/signal_nacl_amd64p32.h b/src/pkg/runtime/signal_nacl_amd64p32.h
index c58593a291..f62305cb52 100644
--- a/src/pkg/runtime/signal_nacl_amd64p32.h
+++ b/src/pkg/runtime/signal_nacl_amd64p32.h
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SIG_REGS(ctxt) (((ExcContext*)(ctxt))->regs64)
+#define SIG_REGS(ctxt) (((ExcContext*)(ctxt))->regs.regs64)
 
 #define SIG_RAX(info, ctxt) (SIG_REGS(ctxt).rax)
 #define SIG_RBX(info, ctxt) (SIG_REGS(ctxt).rbx)

From 5ecbdb049bc9f33be49e1fd2e7279b6d84f801d2 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 7 Aug 2014 13:51:29 -0700
Subject: [PATCH 031/423] cmd/go: don't pass --buildid=none on FreeBSD

According to the FreeBSD builder, it doesn't work.

TBR=bradfitz
CC=golang-codereviews
https://golang.org/cl/121400043
---
 src/cmd/go/build.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index b39364ed89..88c2e29490 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -2324,7 +2324,7 @@ func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles, gxxfiles, mfiles
 	// systems likely to support it, which is to say, systems that
 	// normally use gold or the GNU linker.
 	switch goos {
-	case "android", "dragonfly", "freebsd", "linux", "netbsd", "openbsd":
+	case "android", "dragonfly", "linux", "netbsd", "openbsd":
 		ldflags = append(ldflags, "-Wl,--build-id=none")
 	}
 

From 483cb6192133e737d5179e3fb579321288ed04c7 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Thu, 7 Aug 2014 13:58:42 -0700
Subject: [PATCH 032/423] runtime: convert interface routines from C to Go.

LGTM=dvyukov
R=golang-codereviews, dave, bradfitz, dvyukov, khr
CC=golang-codereviews
https://golang.org/cl/98510044
---
 src/cmd/api/goapi.go           |   2 +-
 src/pkg/reflect/asm_386.s      |   6 +
 src/pkg/reflect/asm_amd64.s    |   6 +
 src/pkg/reflect/asm_amd64p32.s |   6 +
 src/pkg/reflect/asm_arm.s      |   6 +
 src/pkg/runtime/alg.goc        |   3 +
 src/pkg/runtime/iface.go       | 469 +++++++++++++++++++++++++++++++++
 src/pkg/runtime/iface.goc      | 404 ++--------------------------
 src/pkg/runtime/stubs.go       |   9 +-
 src/pkg/runtime/stubs.goc      |  14 +
 10 files changed, 535 insertions(+), 390 deletions(-)
 create mode 100644 src/pkg/runtime/iface.go

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index fe3c257a55..38bf9592f2 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -378,7 +378,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.
-		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{}; type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{}; type iface struct{}; type eface struct{}"
+		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{}; type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{}; type iface struct{}; type eface struct{}; type interfacetype struct{}; type itab struct{}"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)
diff --git a/src/pkg/reflect/asm_386.s b/src/pkg/reflect/asm_386.s
index 18b348adc1..a538624083 100644
--- a/src/pkg/reflect/asm_386.s
+++ b/src/pkg/reflect/asm_386.s
@@ -46,3 +46,9 @@ TEXT ·maplen(SB),NOSPLIT,$0-0
 	JMP	runtime·reflect_maplen(SB)
 TEXT ·ismapkey(SB),NOSPLIT,$0-0
 	JMP	runtime·reflect_ismapkey(SB)
+TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_ifaceE2I(SB)
+TEXT ·unsafe_New(SB),NOSPLIT,$0-0
+	JMP	runtime·newobject(SB)
+TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
+	JMP	runtime·newarray(SB)
diff --git a/src/pkg/reflect/asm_amd64.s b/src/pkg/reflect/asm_amd64.s
index 9a9eed02aa..12a8879b79 100644
--- a/src/pkg/reflect/asm_amd64.s
+++ b/src/pkg/reflect/asm_amd64.s
@@ -46,3 +46,9 @@ TEXT ·maplen(SB),NOSPLIT,$0-0
 	JMP	runtime·reflect_maplen(SB)
 TEXT ·ismapkey(SB),NOSPLIT,$0-0
 	JMP	runtime·reflect_ismapkey(SB)
+TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_ifaceE2I(SB)
+TEXT ·unsafe_New(SB),NOSPLIT,$0-0
+	JMP	runtime·newobject(SB)
+TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
+	JMP	runtime·newarray(SB)
diff --git a/src/pkg/reflect/asm_amd64p32.s b/src/pkg/reflect/asm_amd64p32.s
index 18b348adc1..a538624083 100644
--- a/src/pkg/reflect/asm_amd64p32.s
+++ b/src/pkg/reflect/asm_amd64p32.s
@@ -46,3 +46,9 @@ TEXT ·maplen(SB),NOSPLIT,$0-0
 	JMP	runtime·reflect_maplen(SB)
 TEXT ·ismapkey(SB),NOSPLIT,$0-0
 	JMP	runtime·reflect_ismapkey(SB)
+TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_ifaceE2I(SB)
+TEXT ·unsafe_New(SB),NOSPLIT,$0-0
+	JMP	runtime·newobject(SB)
+TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
+	JMP	runtime·newarray(SB)
diff --git a/src/pkg/reflect/asm_arm.s b/src/pkg/reflect/asm_arm.s
index 1db6b9b9d4..69e4ab4888 100644
--- a/src/pkg/reflect/asm_arm.s
+++ b/src/pkg/reflect/asm_arm.s
@@ -46,3 +46,9 @@ TEXT ·maplen(SB),NOSPLIT,$-4-0
 	B	runtime·reflect_maplen(SB)
 TEXT ·ismapkey(SB),NOSPLIT,$-4-0
 	B	runtime·reflect_ismapkey(SB)
+TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
+	B	runtime·reflect_ifaceE2I(SB)
+TEXT ·unsafe_New(SB),NOSPLIT,$0-0
+	B	runtime·newobject(SB)
+TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
+	B	runtime·newarray(SB)
diff --git a/src/pkg/runtime/alg.goc b/src/pkg/runtime/alg.goc
index 70c877ebbb..6207ae526c 100644
--- a/src/pkg/runtime/alg.goc
+++ b/src/pkg/runtime/alg.goc
@@ -308,6 +308,7 @@ runtime·nilintercopy(uintptr s, void *a, void *b)
 }
 
 extern uintptr runtime·nohashcode;
+extern uintptr runtime·noequalcode;
 
 void
 runtime·noequal(bool *eq, uintptr s, void *a, void *b)
@@ -371,6 +372,8 @@ void
 runtime·hashinit(void)
 {
 	runtime·nohashcode = (uintptr)runtime·nohash;
+	runtime·noequalcode = (uintptr)runtime·noequal;
+
         if(NaCl)
                 return;
 
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
new file mode 100644
index 0000000000..d3428e5a9c
--- /dev/null
+++ b/src/pkg/runtime/iface.go
@@ -0,0 +1,469 @@
+// 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 runtime
+
+import (
+	"unsafe"
+)
+
+const (
+	hashSize = 1009
+)
+
+var (
+	ifaceLock lock // lock for accessing hash
+	hash      [hashSize]*itab
+)
+
+// fInterface is our standard non-empty interface.  We use it instead
+// of interface{f()} in function prototypes because gofmt insists on
+// putting lots of newlines in the otherwise concise interface{f()}.
+type fInterface interface {
+	f()
+}
+
+func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
+	if len(inter.mhdr) == 0 {
+		gothrow("internal error - misuse of itab")
+	}
+
+	// easy case
+	x := typ.x
+	if x == nil {
+		if canfail {
+			return nil
+		}
+		i := (*imethod)(add(unsafe.Pointer(inter), unsafe.Sizeof(interfacetype{})))
+		panic(&TypeAssertionError{"", *typ._string, *inter.typ._string, *i.name})
+	}
+
+	// compiler has provided some good hash codes for us.
+	h := inter.typ.hash
+	h += 17 * typ.hash
+	// TODO(rsc): h += 23 * x.mhash ?
+	h %= hashSize
+
+	// look twice - once without lock, once with.
+	// common case will be no lock contention.
+	var m *itab
+	var locked int
+	for locked = 0; locked < 2; locked++ {
+		if locked != 0 {
+			golock(&ifaceLock)
+		}
+		for m = (*itab)(goatomicloadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
+			if m.inter == inter && m._type == typ {
+				if m.bad != 0 {
+					m = nil
+					if !canfail {
+						// this can only happen if the conversion
+						// was already done once using the , ok form
+						// and we have a cached negative result.
+						// the cached result doesn't record which
+						// interface function was missing, so jump
+						// down to the interface check, which will
+						// do more work but give a better error.
+						goto search
+					}
+				}
+				if locked != 0 {
+					gounlock(&ifaceLock)
+				}
+				return m
+			}
+		}
+	}
+
+	m = (*itab)(gopersistentalloc(unsafe.Sizeof(itab{}) + uintptr(len(inter.mhdr))*ptrSize))
+	m.inter = inter
+	m._type = typ
+
+search:
+	// both inter and typ have method sorted by name,
+	// and interface names are unique,
+	// so can iterate over both in lock step;
+	// the loop is O(ni+nt) not O(ni*nt).
+	ni := len(inter.mhdr)
+	nt := len(x.mhdr)
+	j := 0
+	for k := 0; k < ni; k++ {
+		i := (*imethod)(add(unsafe.Pointer(inter), unsafe.Sizeof(interfacetype{})+uintptr(k)*unsafe.Sizeof(imethod{})))
+		iname := i.name
+		ipkgpath := i.pkgpath
+		itype := i._type
+		for ; j < nt; j++ {
+			t := (*method)(add(unsafe.Pointer(x), unsafe.Sizeof(uncommontype{})+uintptr(j)*unsafe.Sizeof(method{})))
+			if t.mtyp == itype && t.name == iname && t.pkgpath == ipkgpath {
+				if m != nil {
+					f := (*func())(add(unsafe.Pointer(m), unsafe.Sizeof(itab{})+uintptr(k)*ptrSize))
+					*f = t.ifn
+				}
+				goto nextimethod
+			}
+		}
+		// didn't find method
+		if !canfail {
+			if locked != 0 {
+				gounlock(&ifaceLock)
+			}
+			panic(&TypeAssertionError{"", *typ._string, *inter.typ._string, *iname})
+		}
+		m.bad = 1
+		break
+	nextimethod:
+	}
+	if locked == 0 {
+		gothrow("invalid itab locking")
+	}
+	m.link = hash[h]
+	goatomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))
+	gounlock(&ifaceLock)
+	if m.bad != 0 {
+		return nil
+	}
+	return m
+}
+
+func typ2Itab(t *_type, inter *interfacetype, cache **itab) *itab {
+	tab := getitab(inter, t, false)
+	goatomicstorep(unsafe.Pointer(cache), unsafe.Pointer(tab))
+	return tab
+}
+
+func convT2E(t *_type, elem unsafe.Pointer) (e interface{}) {
+	size := uintptr(t.size)
+	ep := (*eface)(unsafe.Pointer(&e))
+	if size <= ptrSize {
+		ep._type = t
+		memmove(unsafe.Pointer(&ep.data), elem, size)
+	} else {
+		x := newobject(t)
+		// TODO: We allocate a zeroed object only to overwrite it with
+		// actual data.  Figure out how to avoid zeroing.  Also below in convT2I.
+		memmove(x, elem, size)
+		ep._type = t
+		ep.data = x
+	}
+	return
+}
+
+func convT2I(t *_type, inter *interfacetype, cache **itab, elem unsafe.Pointer) (i fInterface) {
+	tab := (*itab)(goatomicloadp(unsafe.Pointer(cache)))
+	if tab == nil {
+		tab = getitab(inter, t, false)
+		goatomicstorep(unsafe.Pointer(cache), unsafe.Pointer(tab))
+	}
+	size := uintptr(t.size)
+	pi := (*iface)(unsafe.Pointer(&i))
+	if size <= ptrSize {
+		pi.tab = tab
+		memmove(unsafe.Pointer(&pi.data), elem, size)
+	} else {
+		x := newobject(t)
+		memmove(x, elem, size)
+		pi.tab = tab
+		pi.data = x
+	}
+	return
+}
+
+// TODO: give these routines a pointer to the result area instead of writing
+// extra data in the outargs section.  Then we can get rid of go:nosplit.
+//go:nosplit
+func assertI2T(t *_type, i fInterface) (r struct{}) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		panic(&TypeAssertionError{"", "", *t._string, ""})
+	}
+	if tab._type != t {
+		panic(&TypeAssertionError{*tab.inter.typ._string, *tab._type._string, *t._string, ""})
+	}
+	size := uintptr(t.size)
+	if size <= ptrSize {
+		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ip.data), size)
+	} else {
+		memmove(unsafe.Pointer(&r), ip.data, size)
+	}
+	return
+}
+
+//go:nosplit
+func assertI2T2(t *_type, i fInterface) (r byte) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	size := uintptr(t.size)
+	ok := (*bool)(add(unsafe.Pointer(&r), size))
+	tab := ip.tab
+	if tab == nil || tab._type != t {
+		*ok = false
+		memclr(unsafe.Pointer(&r), size)
+		return
+	}
+	*ok = true
+	if size <= ptrSize {
+		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ip.data), size)
+	} else {
+		memmove(unsafe.Pointer(&r), ip.data, size)
+	}
+	return
+}
+
+func assertI2TOK(t *_type, i fInterface) bool {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	return tab != nil && tab._type == t
+}
+
+//go:nosplit
+func assertE2T(t *_type, e interface{}) (r struct{}) {
+	ep := (*eface)(unsafe.Pointer(&e))
+	if ep._type == nil {
+		panic(&TypeAssertionError{"", "", *t._string, ""})
+	}
+	if ep._type != t {
+		panic(&TypeAssertionError{"", *ep._type._string, *t._string, ""})
+	}
+	size := uintptr(t.size)
+	if size <= ptrSize {
+		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ep.data), size)
+	} else {
+		memmove(unsafe.Pointer(&r), ep.data, size)
+	}
+	return
+}
+
+//go:nosplit
+func assertE2T2(t *_type, e interface{}) (r byte) {
+	ep := (*eface)(unsafe.Pointer(&e))
+	size := uintptr(t.size)
+	ok := (*bool)(add(unsafe.Pointer(&r), size))
+	if ep._type != t {
+		*ok = false
+		memclr(unsafe.Pointer(&r), size)
+		return
+	}
+	*ok = true
+	if size <= ptrSize {
+		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ep.data), size)
+	} else {
+		memmove(unsafe.Pointer(&r), ep.data, size)
+	}
+	return
+}
+
+func assertE2TOK(t *_type, e interface{}) bool {
+	ep := (*eface)(unsafe.Pointer(&e))
+	return t == ep._type
+}
+
+func convI2E(i fInterface) (r interface{}) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		return
+	}
+	rp := (*eface)(unsafe.Pointer(&r))
+	rp._type = tab._type
+	rp.data = ip.data
+	return
+}
+
+func assertI2E(inter *interfacetype, i fInterface) (r interface{}) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		// explicit conversions require non-nil interface value.
+		panic(&TypeAssertionError{"", "", *inter.typ._string, ""})
+	}
+	rp := (*eface)(unsafe.Pointer(&r))
+	rp._type = tab._type
+	rp.data = ip.data
+	return
+}
+
+func assertI2E2(inter *interfacetype, i fInterface) (r interface{}, ok bool) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		return
+	}
+	rp := (*eface)(unsafe.Pointer(&r))
+	rp._type = tab._type
+	rp.data = ip.data
+	ok = true
+	return
+}
+
+func convI2I(inter *interfacetype, i fInterface) (r fInterface) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		return
+	}
+	rp := (*iface)(unsafe.Pointer(&r))
+	if tab.inter == inter {
+		rp.tab = tab
+		rp.data = ip.data
+		return
+	}
+	rp.tab = getitab(inter, tab._type, false)
+	rp.data = ip.data
+	return
+}
+
+func assertI2I(inter *interfacetype, i fInterface) (r fInterface) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		// explicit conversions require non-nil interface value.
+		panic(&TypeAssertionError{"", "", *inter.typ._string, ""})
+	}
+	rp := (*iface)(unsafe.Pointer(&r))
+	if tab.inter == inter {
+		rp.tab = tab
+		rp.data = ip.data
+		return
+	}
+	rp.tab = getitab(inter, tab._type, false)
+	rp.data = ip.data
+	return
+}
+
+func assertI2I2(inter *interfacetype, i fInterface) (r fInterface, ok bool) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		return
+	}
+	rp := (*iface)(unsafe.Pointer(&r))
+	if tab.inter == inter {
+		rp.tab = tab
+		rp.data = ip.data
+		ok = true
+		return
+	}
+	tab = getitab(inter, tab._type, true)
+	if tab == nil {
+		rp.data = nil
+		rp.tab = nil
+		ok = false
+		return
+	}
+	rp.tab = tab
+	rp.data = ip.data
+	ok = true
+	return
+}
+
+func assertE2I(inter *interfacetype, e interface{}) (r fInterface) {
+	ep := (*eface)(unsafe.Pointer(&e))
+	t := ep._type
+	if t == nil {
+		// explicit conversions require non-nil interface value.
+		panic(&TypeAssertionError{"", "", *inter.typ._string, ""})
+	}
+	rp := (*iface)(unsafe.Pointer(&r))
+	rp.tab = getitab(inter, t, false)
+	rp.data = ep.data
+	return
+}
+
+func assertE2I2(inter *interfacetype, e interface{}) (r fInterface, ok bool) {
+	ep := (*eface)(unsafe.Pointer(&e))
+	t := ep._type
+	if t == nil {
+		return
+	}
+	tab := getitab(inter, t, true)
+	if tab == nil {
+		return
+	}
+	rp := (*iface)(unsafe.Pointer(&r))
+	rp.tab = tab
+	rp.data = ep.data
+	ok = true
+	return
+}
+
+func reflect_ifaceE2I(inter *interfacetype, e interface{}, dst *fInterface) {
+	*dst = assertE2I(inter, e)
+}
+
+func assertE2E(inter *interfacetype, e interface{}) interface{} {
+	ep := (*eface)(unsafe.Pointer(&e))
+	if ep._type == nil {
+		// explicit conversions require non-nil interface value.
+		panic(&TypeAssertionError{"", "", *inter.typ._string, ""})
+	}
+	return e
+}
+
+func assertE2E2(inter *interfacetype, e interface{}) (interface{}, bool) {
+	ep := (*eface)(unsafe.Pointer(&e))
+	if ep._type == nil {
+		return nil, false
+	}
+	return e, true
+}
+
+func efaceeq(e1 interface{}, e2 interface{}) bool {
+	p1 := (*eface)(unsafe.Pointer(&e1))
+	p2 := (*eface)(unsafe.Pointer(&e2))
+	t := p1._type
+	if t != p2._type {
+		return false
+	}
+	if t == nil {
+		return true
+	}
+
+	if *(*uintptr)(unsafe.Pointer(&t.alg.equal)) == noequalcode {
+		panic(errorString("comparing uncomparable type " + *t._string))
+	}
+	size := uintptr(t.size)
+	if size <= ptrSize {
+		return goeq(t.alg, unsafe.Pointer(&p1.data), unsafe.Pointer(&p2.data), size)
+	}
+	return goeq(t.alg, p1.data, p2.data, size)
+}
+
+func ifaceeq(i1 fInterface, i2 fInterface) bool {
+	p1 := (*iface)(unsafe.Pointer(&i1))
+	p2 := (*iface)(unsafe.Pointer(&i2))
+	tab := p1.tab
+	if tab != p2.tab {
+		return false
+	}
+	if tab == nil {
+		return true
+	}
+	t := tab._type
+	if *(*uintptr)(unsafe.Pointer(&t.alg.equal)) == noequalcode {
+		panic(errorString("comparing uncomparable type " + *t._string))
+	}
+	size := uintptr(t.size)
+	if size <= ptrSize {
+		return goeq(t.alg, unsafe.Pointer(&p1.data), unsafe.Pointer(&p2.data), size)
+	}
+	return goeq(t.alg, p1.data, p2.data, size)
+}
+
+func ifacethash(i fInterface) uint32 {
+	ip := (*iface)(unsafe.Pointer(&i))
+	tab := ip.tab
+	if tab == nil {
+		return 0
+	}
+	return tab._type.hash
+}
+
+func efacethash(e interface{}) uint32 {
+	ep := (*eface)(unsafe.Pointer(&e))
+	t := ep._type
+	if t == nil {
+		return 0
+	}
+	return t.hash
+}
diff --git a/src/pkg/runtime/iface.goc b/src/pkg/runtime/iface.goc
index 719d115880..a2e968fafa 100644
--- a/src/pkg/runtime/iface.goc
+++ b/src/pkg/runtime/iface.goc
@@ -10,9 +10,10 @@ package runtime
 #include "malloc.h"
 #include "../../cmd/ld/textflag.h"
 
-static	Itab*	hash[1009];
-static	Lock	ifacelock;
+extern	Itab*	runtime·hash[1009];
+extern	Lock	runtime·ifaceLock;
 
+// TODO: delete this when no longer used (ifaceE2I2 is all that's left)
 static Itab*
 itab(InterfaceType *inter, Type *type, int32 canfail)
 {
@@ -45,14 +46,14 @@ itab(InterfaceType *inter, Type *type, int32 canfail)
 	h = inter->typ.hash;
 	h += 17 * type->hash;
 	// TODO(rsc): h += 23 * x->mhash ?
-	h %= nelem(hash);
+	h %= nelem(runtime·hash);
 
 	// look twice - once without lock, once with.
 	// common case will be no lock contention.
 	for(locked=0; locked<2; locked++) {
 		if(locked)
-			runtime·lock(&ifacelock);
-		for(m=runtime·atomicloadp(&hash[h]); m!=nil; m=m->link) {
+			runtime·lock(&runtime·ifaceLock);
+		for(m=runtime·atomicloadp(&runtime·hash[h]); m!=nil; m=m->link) {
 			if(m->inter == inter && m->type == type) {
 				if(m->bad) {
 					m = nil;
@@ -68,7 +69,7 @@ itab(InterfaceType *inter, Type *type, int32 canfail)
 					}
 				}
 				if(locked)
-					runtime·unlock(&ifacelock);
+					runtime·unlock(&runtime·ifaceLock);
 				return m;
 			}
 		}
@@ -101,7 +102,7 @@ search:
 						nil, type->string, inter->typ.string,
 						iname, &err);
 					if(locked)
-						runtime·unlock(&ifacelock);
+						runtime·unlock(&runtime·ifaceLock);
 					runtime·panic(err);
 					return nil;	// not reached
 				}
@@ -118,9 +119,9 @@ search:
 out:
 	if(!locked)
 		runtime·panicstring("invalid itab locking");
-	m->link = hash[h];
-	runtime·atomicstorep(&hash[h], m);
-	runtime·unlock(&ifacelock);
+	m->link = runtime·hash[h];
+	runtime·atomicstorep(&runtime·hash[h], m);
+	runtime·unlock(&runtime·ifaceLock);
 	if(m->bad)
 		return nil;
 	return m;
@@ -133,295 +134,16 @@ runtime·iterate_itabs(void (*callback)(Itab*))
 	int32 i;
 	Itab *tab;
 
-	for(i = 0; i < nelem(hash); i++) {
-		for(tab = hash[i]; tab != nil; tab = tab->link) {
+	for(i = 0; i < nelem(runtime·hash); i++) {
+		for(tab = runtime·hash[i]; tab != nil; tab = tab->link) {
 			callback(tab);
 		}
 	}
 }
 
-static void
-copyin(Type *t, void *src, void **dst)
-{
-	uintptr size;
-	void *p;
-	Alg *alg;
-
-	size = t->size;
-	alg = t->alg;
-
-	if(size <= sizeof(*dst))
-		alg->copy(size, dst, src);
-	else {
-		p = runtime·cnew(t);
-		alg->copy(size, p, src);
-		*dst = p;
-	}
-}
-
-static void
-copyout(Type *t, void **src, void *dst)
-{
-	uintptr size;
-	Alg *alg;
-
-	size = t->size;
-	alg = t->alg;
-
-	if(size <= sizeof(*src))
-		alg->copy(size, dst, src);
-	else
-		alg->copy(size, dst, *src);
-}
-
-#pragma textflag NOSPLIT
-func typ2Itab(t *Type, inter *InterfaceType, cache **Itab) (tab *Itab) {
-	tab = itab(inter, t, 0);
-	runtime·atomicstorep(cache, tab);
-}
-
-#pragma textflag NOSPLIT
-func convT2I(t *Type, inter *InterfaceType, cache **Itab, elem *byte) (ret Iface) {
-	Itab *tab;
-
-	tab = runtime·atomicloadp(cache);
-	if(!tab) {
-		tab = itab(inter, t, 0);
-		runtime·atomicstorep(cache, tab);
-	}
-	ret.tab = tab;
-	copyin(t, elem, &ret.data);
-}
-
-#pragma textflag NOSPLIT
-func convT2E(t *Type, elem *byte) (ret Eface) {
-	ret.type = t;
-	copyin(t, elem, &ret.data);
-}
-
-static void assertI2Tret(Type *t, Iface i, byte *ret);
-
-/*
- * NOTE: Cannot use 'func' here, because we have to declare
- * a return value, the only types we have are at least 1 byte large,
- * goc2c will zero the return value, and the actual return value
- * might have size 0 bytes, in which case the zeroing of the
- * 1 or more bytes would be wrong.
- * Using C lets us control (avoid) the initial zeroing.
- */
-#pragma textflag NOSPLIT
-void
-runtime·assertI2T(Type *t, Iface i, GoOutput retbase)
-{
-	assertI2Tret(t, i, (byte*)&retbase);
-}
-
-static void
-assertI2Tret(Type *t, Iface i, byte *ret)
-{
-	Itab *tab;
-	Eface err;
-
-	tab = i.tab;
-	if(tab == nil) {
-		runtime·newTypeAssertionError(
-			nil, nil, t->string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	if(tab->type != t) {
-		runtime·newTypeAssertionError(
-			tab->inter->typ.string, tab->type->string, t->string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	copyout(t, &i.data, ret);
-}
-
-#pragma textflag NOSPLIT
-func assertI2T2(t *Type, i Iface) (ret byte, ...) {
-	bool *ok;
-	int32 wid;
-
-	wid = t->size;
-	ok = (bool*)(&ret + wid);
-
-	if(i.tab == nil || i.tab->type != t) {
-		*ok = false;
-		runtime·memclr(&ret, wid);
-		return;
-	}
-
-	*ok = true;
-	copyout(t, &i.data, &ret);
-}
-
-func assertI2TOK(t *Type, i Iface) (ok bool) {
-	ok = i.tab!=nil && i.tab->type==t;
-}
-
-static void assertE2Tret(Type *t, Eface e, byte *ret);
-
-/*
- * NOTE: Cannot use 'func' here. See assertI2T above.
- */
-#pragma textflag NOSPLIT
-void
-runtime·assertE2T(Type *t, Eface e, GoOutput retbase)
-{
-	assertE2Tret(t, e, (byte*)&retbase);
-}
-
-static void
-assertE2Tret(Type *t, Eface e, byte *ret)
-{
-	Eface err;
-
-	if(e.type == nil) {
-		runtime·newTypeAssertionError(
-			nil, nil, t->string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	if(e.type != t) {
-		runtime·newTypeAssertionError(
-			nil, e.type->string, t->string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	copyout(t, &e.data, ret);
-}
-
-#pragma textflag NOSPLIT
-func assertE2T2(t *Type, e Eface) (ret byte, ...) {
-	bool *ok;
-	int32 wid;
-
-	wid = t->size;
-	ok = (bool*)(&ret + wid);
-
-	if(t != e.type) {
-		*ok = false;
-		runtime·memclr(&ret, wid);
-		return;
-	}
-
-	*ok = true;
-	copyout(t, &e.data, &ret);
-}
-
-func assertE2TOK(t *Type, e Eface) (ok bool) {
-	ok = t==e.type;
-}
-
-func convI2E(i Iface) (ret Eface) {
-	Itab *tab;
-
-	ret.data = i.data;
-	if((tab = i.tab) == nil)
-		ret.type = nil;
-	else
-		ret.type = tab->type;
-}
-
-func assertI2E(inter *InterfaceType, i Iface) (ret Eface) {
-	Itab *tab;
-	Eface err;
-
-	tab = i.tab;
-	if(tab == nil) {
-		// explicit conversions require non-nil interface value.
-		runtime·newTypeAssertionError(
-			nil, nil, inter->typ.string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	ret.data = i.data;
-	ret.type = tab->type;
-}
-
-func assertI2E2(inter *InterfaceType, i Iface) (ret Eface, ok bool) {
-	Itab *tab;
-
-	USED(inter);
-	tab = i.tab;
-	if(tab == nil) {
-		ret.type = nil;
-		ok = 0;
-	} else {
-		ret.type = tab->type;
-		ok = 1;
-	}
-	ret.data = i.data;
-}
-
-func convI2I(inter *InterfaceType, i Iface) (ret Iface) {
-	Itab *tab;
-
-	ret.data = i.data;
-	if((tab = i.tab) == nil)
-		ret.tab = nil;
-	else if(tab->inter == inter)
-		ret.tab = tab;
-	else
-		ret.tab = itab(inter, tab->type, 0);
-}
-
-void
-runtime·ifaceI2I(InterfaceType *inter, Iface i, Iface *ret)
-{
-	Itab *tab;
-	Eface err;
-
-	tab = i.tab;
-	if(tab == nil) {
-		// explicit conversions require non-nil interface value.
-		runtime·newTypeAssertionError(
-			nil, nil, inter->typ.string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	ret->data = i.data;
-	ret->tab = itab(inter, tab->type, 0);
-}
-
-func assertI2I(inter *InterfaceType, i Iface) (ret Iface) {
-	runtime·ifaceI2I(inter, i, &ret);
-}
-
-func assertI2I2(inter *InterfaceType, i Iface) (ret Iface, ok bool) {
-	Itab *tab;
-
-	tab = i.tab;
-	if(tab != nil && (tab->inter == inter || (tab = itab(inter, tab->type, 1)) != nil)) {
-		ret.data = i.data;
-		ret.tab = tab;
-		ok = 1;
-	} else {
-		ret.data = 0;
-		ret.tab = 0;
-		ok = 0;
-	}
-}
-
-void
-runtime·ifaceE2I(InterfaceType *inter, Eface e, Iface *ret)
-{
-	Type *t;
-	Eface err;
-
-	t = e.type;
-	if(t == nil) {
-		// explicit conversions require non-nil interface value.
-		runtime·newTypeAssertionError(
-			nil, nil, inter->typ.string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	ret->data = e.data;
-	ret->tab = itab(inter, t, 0);
-}
-
+// Still in C because it is called from C for finalizers.  This will
+// get converted to Go in a separate CL.  This is the last user of
+// the C version of itab().
 bool
 runtime·ifaceE2I2(InterfaceType *inter, Eface e, Iface *ret)
 {
@@ -432,49 +154,6 @@ runtime·ifaceE2I2(InterfaceType *inter, Eface e, Iface *ret)
 	return true;
 }
 
-func reflect·ifaceE2I(inter *InterfaceType, e Eface, dst *Iface) {
-	runtime·ifaceE2I(inter, e, dst);
-}
-
-func assertE2I(inter *InterfaceType, e Eface) (ret Iface) {
-	runtime·ifaceE2I(inter, e, &ret);
-}
-
-func assertE2I2(inter *InterfaceType, e Eface) (ret Iface, ok bool) {
-	if(e.type == nil) {
-		ok = 0;
-		ret.data = nil;
-		ret.tab = nil;
-	} else if((ret.tab = itab(inter, e.type, 1)) == nil) {
-		ok = 0;
-		ret.data = nil;
-	} else {
-		ok = 1;
-		ret.data = e.data;
-	}
-}
-
-func assertE2E(inter *InterfaceType, e Eface) (ret Eface) {
-	Type *t;
-	Eface err;
-
-	t = e.type;
-	if(t == nil) {
-		// explicit conversions require non-nil interface value.
-		runtime·newTypeAssertionError(
-			nil, nil, inter->typ.string,
-			nil, &err);
-		runtime·panic(err);
-	}
-	ret = e;
-}
-
-func assertE2E2(inter *InterfaceType, e Eface) (ret Eface, ok bool) {
-	USED(inter);
-	ret = e;
-	ok = e.type != nil;
-}
-
 static bool
 ifaceeq1(void *data1, void *data2, Type *t)
 {
@@ -520,54 +199,3 @@ runtime·efaceeq_c(Eface e1, Eface e2)
 		return true;
 	return ifaceeq1(e1.data, e2.data, e1.type);
 }
-
-func ifaceeq(i1 Iface, i2 Iface) (ret bool) {
-	ret = runtime·ifaceeq_c(i1, i2);
-}
-
-func efaceeq(e1 Eface, e2 Eface) (ret bool) {
-	ret = runtime·efaceeq_c(e1, e2);
-}
-
-func ifacethash(i1 Iface) (ret uint32) {
-	Itab *tab;
-
-	ret = 0;
-	tab = i1.tab;
-	if(tab != nil)
-		ret = tab->type->hash;
-}
-
-func efacethash(e1 Eface) (ret uint32) {
-	Type *t;
-
-	ret = 0;
-	t = e1.type;
-	if(t != nil)
-		ret = t->hash;
-}
-
-func reflect·unsafe_Typeof(e Eface) (ret Eface) {
-	if(e.type == nil) {
-		ret.type = nil;
-		ret.data = nil;
-	} else {
-		ret = *(Eface*)(e.type);
-	}
-}
-
-func reflect·unsafe_New(t *Type) (ret *byte) {
-	ret = runtime·cnew(t);
-}
-
-func reflect·unsafe_NewArray(t *Type, n int) (ret *byte) {
-	ret = runtime·cnewarray(t, n);
-}
-
-func reflect·typelinks() (ret Slice) {
-	extern Type *typelink[], *etypelink[];
-	static int32 first = 1;
-	ret.array = (byte*)typelink;
-	ret.len = etypelink - typelink;
-	ret.cap = ret.len;
-}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index fee18f0470..77eece9433 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -72,6 +72,7 @@ var (
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
+//go:noescape
 func memclr(ptr unsafe.Pointer, n uintptr)
 
 func racemalloc(p unsafe.Pointer, size uintptr)
@@ -79,6 +80,7 @@ func tracealloc(p unsafe.Pointer, size uintptr, typ *_type)
 
 // memmove copies n bytes from "from" to "to".
 // in memmove_*.s
+//go:noescape
 func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 
 // in asm_*.s
@@ -124,8 +126,9 @@ var hashLoad = loadFactor
 //go:noescape
 func gomemeq(a, b unsafe.Pointer, size uintptr) bool
 
-// Code pointer for the nohash algorithm. Used for producing better error messages.
+// Code pointers for the nohash/noequal algorithms. Used for producing better error messages.
 var nohashcode uintptr
+var noequalcode uintptr
 
 // Go version of runtime.throw.
 // in panic.c
@@ -159,3 +162,7 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 	x := uintptr(p)
 	return unsafe.Pointer(x ^ 0)
 }
+
+// gopersistentalloc allocates a permanent (not garbage collected)
+// memory region of size n.  Use wisely!
+func gopersistentalloc(n uintptr) unsafe.Pointer
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index 42a4bf1434..8a043c63b0 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -89,3 +89,17 @@ func GCMask(x Eface) (mask Slice) {
 	runtime·getgcmask(x.data, x.type, &mask.array, &mask.len);
 	mask.cap = mask.len;
 }
+
+#pragma textflag NOSPLIT
+func gopersistentalloc(size uintptr) (x *void) {
+	// TODO: used only for itabs for now.  Need to make &mstats.other_sys arg parameterized.
+	x = runtime·persistentalloc(size, 0, &mstats.other_sys);
+}
+
+#pragma textflag NOSPLIT
+func reflect·typelinks() (ret Slice) {
+        extern Type *typelink[], *etypelink[];
+        ret.array = (byte*)typelink;
+        ret.len = etypelink - typelink;
+        ret.cap = ret.len;
+}

From 12666cb91d619d85c32a4fb2308ba4c1dd235741 Mon Sep 17 00:00:00 2001
From: Adam Langley <agl@golang.org>
Date: Thu, 7 Aug 2014 14:22:15 -0700
Subject: [PATCH 033/423] doc: add note about crypto/tls cert selection
 callback.

CC=golang-codereviews
https://golang.org/cl/123950043
---
 doc/go1.4.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index 20d2a6b7ed..e480d9bcd5 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -8,6 +8,7 @@ Please keep the list sorted (as in sort.Strings of the lines).
 spec: permit for range x (CL 104680043)
 
 crypto/tls: add support for ALPN (RFC 7301) (CL 108710046)
+crypto/tls: support programmatic selection of server certificates (CL 107400043)
 encoding/gob: remove unsafe (CL 102680045)
 misc: deleted editor support; refer to https://code.google.com/p/go-wiki/wiki/IDEsAndTextEditorPlugins instead (CL 105470043)
 os: implement symlink support for windows (CL 86160044)

From 7aa4e5ac5fb3894e0eaf99fbc3704c32d934b199 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Thu, 7 Aug 2014 14:52:55 -0700
Subject: [PATCH 034/423] runtime: convert equality functions to Go

LGTM=rsc
R=rsc, khr
CC=golang-codereviews
https://golang.org/cl/121330043
---
 src/cmd/gc/builtin.c            |  13 +-
 src/cmd/gc/order.c              |  13 ++
 src/cmd/gc/reflect.c            |   9 +-
 src/cmd/gc/runtime.go           |  14 +--
 src/cmd/gc/subr.c               |  66 +++++-----
 src/cmd/gc/walk.c               |  61 ++--------
 src/pkg/runtime/alg.go          | 100 +++++++++++++++
 src/pkg/runtime/alg.goc         | 210 ++++++--------------------------
 src/pkg/runtime/asm_386.s       |  43 +------
 src/pkg/runtime/asm_amd64.s     |  43 +------
 src/pkg/runtime/asm_amd64p32.s  |  43 +------
 src/pkg/runtime/asm_arm.s       |  54 +-------
 src/pkg/runtime/hashmap.go      |  37 +++---
 src/pkg/runtime/hashmap_fast.go |  12 +-
 src/pkg/runtime/iface.go        |  42 -------
 src/pkg/runtime/iface.goc       |  46 -------
 src/pkg/runtime/runtime.h       |  26 ++--
 src/pkg/runtime/stubs.go        |  13 +-
 18 files changed, 266 insertions(+), 579 deletions(-)

diff --git a/src/cmd/gc/builtin.c b/src/cmd/gc/builtin.c
index 4808269b7f..eba9199544 100644
--- a/src/cmd/gc/builtin.c
+++ b/src/cmd/gc/builtin.c
@@ -64,7 +64,6 @@ char *runtimeimport =
 	"func @\"\".efaceeq (@\"\".i1·2 any, @\"\".i2·3 any) (@\"\".ret·1 bool)\n"
 	"func @\"\".ifacethash (@\"\".i1·2 any) (@\"\".ret·1 uint32)\n"
 	"func @\"\".efacethash (@\"\".i1·2 any) (@\"\".ret·1 uint32)\n"
-	"func @\"\".equal (@\"\".typ·2 *byte, @\"\".x1·3 any, @\"\".x2·4 any) (@\"\".ret·1 bool)\n"
 	"func @\"\".makemap (@\"\".mapType·2 *byte, @\"\".hint·3 int64) (@\"\".hmap·1 map[any]any)\n"
 	"func @\"\".mapaccess1 (@\"\".mapType·2 *byte, @\"\".hmap·3 map[any]any, @\"\".key·4 *any) (@\"\".val·1 *any)\n"
 	"func @\"\".mapaccess1_fast32 (@\"\".mapType·2 *byte, @\"\".hmap·3 map[any]any, @\"\".key·4 any) (@\"\".val·1 *any)\n"
@@ -96,12 +95,12 @@ char *runtimeimport =
 	"func @\"\".makeslice (@\"\".typ·2 *byte, @\"\".nel·3 int64, @\"\".cap·4 int64) (@\"\".ary·1 []any)\n"
 	"func @\"\".growslice (@\"\".typ·2 *byte, @\"\".old·3 []any, @\"\".n·4 int64) (@\"\".ary·1 []any)\n"
 	"func @\"\".memmove (@\"\".to·1 *any, @\"\".frm·2 *any, @\"\".length·3 uintptr)\n"
-	"func @\"\".memequal (@\"\".eq·1 *bool, @\"\".size·2 uintptr, @\"\".x·3 *any, @\"\".y·4 *any)\n"
-	"func @\"\".memequal8 (@\"\".eq·1 *bool, @\"\".size·2 uintptr, @\"\".x·3 *any, @\"\".y·4 *any)\n"
-	"func @\"\".memequal16 (@\"\".eq·1 *bool, @\"\".size·2 uintptr, @\"\".x·3 *any, @\"\".y·4 *any)\n"
-	"func @\"\".memequal32 (@\"\".eq·1 *bool, @\"\".size·2 uintptr, @\"\".x·3 *any, @\"\".y·4 *any)\n"
-	"func @\"\".memequal64 (@\"\".eq·1 *bool, @\"\".size·2 uintptr, @\"\".x·3 *any, @\"\".y·4 *any)\n"
-	"func @\"\".memequal128 (@\"\".eq·1 *bool, @\"\".size·2 uintptr, @\"\".x·3 *any, @\"\".y·4 *any)\n"
+	"func @\"\".memequal (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
+	"func @\"\".memequal8 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
+	"func @\"\".memequal16 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
+	"func @\"\".memequal32 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
+	"func @\"\".memequal64 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
+	"func @\"\".memequal128 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
 	"func @\"\".int64div (? int64, ? int64) (? int64)\n"
 	"func @\"\".uint64div (? uint64, ? uint64) (? uint64)\n"
 	"func @\"\".int64mod (? int64, ? int64) (? int64)\n"
diff --git a/src/cmd/gc/order.c b/src/cmd/gc/order.c
index 30dbc7dacc..728defe7c3 100644
--- a/src/cmd/gc/order.c
+++ b/src/cmd/gc/order.c
@@ -1055,6 +1055,19 @@ orderexpr(Node **np, Order *order)
 		orderexpr(&n->left, order);
 		n = ordercopyexpr(n, n->type, order, 1);
 		break;
+
+	case OEQ:
+	case ONE:
+		orderexpr(&n->left, order);
+		orderexpr(&n->right, order);
+		t = n->left->type;
+		if(t->etype == TSTRUCT || isfixedarray(t)) {
+			// for complex comparisons, we need both args to be
+			// addressable so we can pass them to the runtime.
+			orderaddrtemp(&n->left, order);
+			orderaddrtemp(&n->right, order);
+		}
+		break;
 	}
 	
 	lineno = lno;
diff --git a/src/cmd/gc/reflect.c b/src/cmd/gc/reflect.c
index 8170c15b62..6b3cd66bb6 100644
--- a/src/cmd/gc/reflect.c
+++ b/src/cmd/gc/reflect.c
@@ -1239,7 +1239,7 @@ static Sym*
 dalgsym(Type *t)
 {
 	int ot;
-	Sym *s, *hash, *hashfunc, *eq;
+	Sym *s, *hash, *hashfunc, *eq, *eqfunc;
 	char buf[100];
 
 	// dalgsym is only called for a type that needs an algorithm table,
@@ -1251,15 +1251,18 @@ dalgsym(Type *t)
 	eq = typesymprefix(".eq", t);
 	geneq(eq, t);
 
-	// make Go func (a closure) for calling the hash function from Go
+	// make Go funcs (closures) for calling hash and equal from Go
 	hashfunc = typesymprefix(".hashfunc", t);
 	dsymptr(hashfunc, 0, hash, 0);
 	ggloblsym(hashfunc, widthptr, DUPOK|RODATA);
+	eqfunc = typesymprefix(".eqfunc", t);
+	dsymptr(eqfunc, 0, eq, 0);
+	ggloblsym(eqfunc, widthptr, DUPOK|RODATA);
 
 	// ../../pkg/runtime/runtime.h:/Alg
 	ot = 0;
 	ot = dsymptr(s, ot, hashfunc, 0);
-	ot = dsymptr(s, ot, eq, 0);
+	ot = dsymptr(s, ot, eqfunc, 0);
 	ot = dsymptr(s, ot, pkglookup("memprint", runtimepkg), 0);
 	switch(t->width) {
 	default:
diff --git a/src/cmd/gc/runtime.go b/src/cmd/gc/runtime.go
index 0257c3c7d6..7617eddd60 100644
--- a/src/cmd/gc/runtime.go
+++ b/src/cmd/gc/runtime.go
@@ -84,8 +84,6 @@ func efaceeq(i1 any, i2 any) (ret bool)
 func ifacethash(i1 any) (ret uint32)
 func efacethash(i1 any) (ret uint32)
 
-func equal(typ *byte, x1, x2 any) (ret bool)
-
 // *byte is really *runtime.Type
 func makemap(mapType *byte, hint int64) (hmap map[any]any)
 func mapaccess1(mapType *byte, hmap map[any]any, key *any) (val *any)
@@ -124,12 +122,12 @@ func makeslice(typ *byte, nel int64, cap int64) (ary []any)
 func growslice(typ *byte, old []any, n int64) (ary []any)
 func memmove(to *any, frm *any, length uintptr)
 
-func memequal(eq *bool, size uintptr, x, y *any)
-func memequal8(eq *bool, size uintptr, x, y *any)
-func memequal16(eq *bool, size uintptr, x, y *any)
-func memequal32(eq *bool, size uintptr, x, y *any)
-func memequal64(eq *bool, size uintptr, x, y *any)
-func memequal128(eq *bool, size uintptr, x, y *any)
+func memequal(x, y *any, size uintptr) bool
+func memequal8(x, y *any, size uintptr) bool
+func memequal16(x, y *any, size uintptr) bool
+func memequal32(x, y *any, size uintptr) bool
+func memequal64(x, y *any, size uintptr) bool
+func memequal128(x, y *any, size uintptr) bool
 
 // only used on 32-bit
 func int64div(int64, int64) int64
diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 0195f3d629..cd6c609567 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -2856,18 +2856,19 @@ genhash(Sym *sym, Type *t)
 }
 
 // Return node for
-//	if p.field != q.field { *eq = false; return }
+//	if p.field != q.field { return false }
 static Node*
-eqfield(Node *p, Node *q, Node *field, Node *eq)
+eqfield(Node *p, Node *q, Node *field)
 {
-	Node *nif, *nx, *ny;
+	Node *nif, *nx, *ny, *r;
 
 	nx = nod(OXDOT, p, field);
 	ny = nod(OXDOT, q, field);
 	nif = nod(OIF, N, N);
 	nif->ntest = nod(ONE, nx, ny);
-	nif->nbody = list(nif->nbody, nod(OAS, nod(OIND, eq, N), nodbool(0)));
-	nif->nbody = list(nif->nbody, nod(ORETURN, N, N));
+	r = nod(ORETURN, N, N);
+	r->list = list(r->list, nodbool(0));
+	nif->nbody = list(nif->nbody, r);
 	return nif;
 }
 
@@ -2896,11 +2897,11 @@ eqmemfunc(vlong size, Type *type)
 }
 
 // Return node for
-//	if memequal(size, &p.field, &q.field, eq); !*eq { return }
+//	if !memequal(&p.field, &q.field, size) { return false }
 static Node*
-eqmem(Node *p, Node *q, Node *field, vlong size, Node *eq)
+eqmem(Node *p, Node *q, Node *field, vlong size)
 {
-	Node *nif, *nx, *ny, *call;
+	Node *nif, *nx, *ny, *call, *r;
 
 	nx = nod(OADDR, nod(OXDOT, p, field), N);
 	nx->etype = 1;  // does not escape
@@ -2910,15 +2911,16 @@ eqmem(Node *p, Node *q, Node *field, vlong size, Node *eq)
 	typecheck(&ny, Erv);
 
 	call = nod(OCALL, eqmemfunc(size, nx->type->type), N);
-	call->list = list(call->list, eq);
-	call->list = list(call->list, nodintconst(size));
 	call->list = list(call->list, nx);
 	call->list = list(call->list, ny);
+	call->list = list(call->list, nodintconst(size));
 
 	nif = nod(OIF, N, N);
 	nif->ninit = list(nif->ninit, call);
-	nif->ntest = nod(ONOT, nod(OIND, eq, N), N);
-	nif->nbody = list(nif->nbody, nod(ORETURN, N, N));
+	nif->ntest = nod(ONOT, call, N);
+	r = nod(ORETURN, N, N);
+	r->list = list(r->list, nodbool(0));
+	nif->nbody = list(nif->nbody, r);
 	return nif;
 }
 
@@ -2928,7 +2930,7 @@ eqmem(Node *p, Node *q, Node *field, vlong size, Node *eq)
 void
 geneq(Sym *sym, Type *t)
 {
-	Node *n, *fn, *np, *neq, *nq, *tfn, *nif, *ni, *nx, *ny, *nrange;
+	Node *n, *fn, *np, *nq, *tfn, *nif, *ni, *nx, *ny, *nrange, *r;
 	Type *t1, *first;
 	int old_safemode;
 	int64 size;
@@ -2941,24 +2943,23 @@ geneq(Sym *sym, Type *t)
 	dclcontext = PEXTERN;
 	markdcl();
 
-	// func sym(eq *bool, s uintptr, p, q *T)
+	// func sym(p, q *T, s uintptr) bool
 	fn = nod(ODCLFUNC, N, N);
 	fn->nname = newname(sym);
 	fn->nname->class = PFUNC;
 	tfn = nod(OTFUNC, N, N);
 	fn->nname->ntype = tfn;
 
-	n = nod(ODCLFIELD, newname(lookup("eq")), typenod(ptrto(types[TBOOL])));
-	tfn->list = list(tfn->list, n);
-	neq = n->left;
-	n = nod(ODCLFIELD, newname(lookup("s")), typenod(types[TUINTPTR]));
-	tfn->list = list(tfn->list, n);
 	n = nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)));
 	tfn->list = list(tfn->list, n);
 	np = n->left;
 	n = nod(ODCLFIELD, newname(lookup("q")), typenod(ptrto(t)));
 	tfn->list = list(tfn->list, n);
 	nq = n->left;
+	n = nod(ODCLFIELD, newname(lookup("s")), typenod(types[TUINTPTR]));
+	tfn->list = list(tfn->list, n);
+	n = nod(ODCLFIELD, N, typenod(types[TBOOL]));
+	tfn->rlist = list(tfn->rlist, n);
 
 	funchdr(fn);
 
@@ -2984,7 +2985,7 @@ geneq(Sym *sym, Type *t)
 		colasdefn(nrange->list, nrange);
 		ni = nrange->list->n;
 		
-		// if p[i] != q[i] { *eq = false; return }
+		// if p[i] != q[i] { return false }
 		nx = nod(OINDEX, np, ni);
 		nx->bounded = 1;
 		ny = nod(OINDEX, nq, ni);
@@ -2992,13 +2993,11 @@ geneq(Sym *sym, Type *t)
 
 		nif = nod(OIF, N, N);
 		nif->ntest = nod(ONE, nx, ny);
-		nif->nbody = list(nif->nbody, nod(OAS, nod(OIND, neq, N), nodbool(0)));
-		nif->nbody = list(nif->nbody, nod(ORETURN, N, N));
+		r = nod(ORETURN, N, N);
+		r->list = list(r->list, nodbool(0));
+		nif->nbody = list(nif->nbody, r);
 		nrange->nbody = list(nrange->nbody, nif);
 		fn->nbody = list(fn->nbody, nrange);
-
-		// *eq = true;
-		fn->nbody = list(fn->nbody, nod(OAS, nod(OIND, neq, N), nodbool(1)));
 		break;
 
 	case TSTRUCT:
@@ -3023,16 +3022,16 @@ geneq(Sym *sym, Type *t)
 			// cross-package unexported fields.
 			if(first != T) {
 				if(first->down == t1) {
-					fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym), neq));
+					fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym)));
 				} else if(first->down->down == t1) {
-					fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym), neq));
+					fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym)));
 					first = first->down;
 					if(!isblanksym(first->sym))
-						fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym), neq));
+						fn->nbody = list(fn->nbody, eqfield(np, nq, newname(first->sym)));
 				} else {
 					// More than two fields: use memequal.
 					size = offend - first->width; // first->width is offset
-					fn->nbody = list(fn->nbody, eqmem(np, nq, newname(first->sym), size, neq));
+					fn->nbody = list(fn->nbody, eqmem(np, nq, newname(first->sym), size));
 				}
 				first = T;
 			}
@@ -3042,14 +3041,17 @@ geneq(Sym *sym, Type *t)
 				continue;
 
 			// Check this field, which is not just memory.
-			fn->nbody = list(fn->nbody, eqfield(np, nq, newname(t1->sym), neq));
+			fn->nbody = list(fn->nbody, eqfield(np, nq, newname(t1->sym)));
 		}
 
-		// *eq = true;
-		fn->nbody = list(fn->nbody, nod(OAS, nod(OIND, neq, N), nodbool(1)));
 		break;
 	}
 
+	// return true
+	r = nod(ORETURN, N, N);
+	r->list = list(r->list, nodbool(1));
+	fn->nbody = list(fn->nbody, r);
+
 	if(debug['r'])
 		dumplist("geneq body", fn->nbody);
 
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index be929e99ed..e50b917709 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -3013,10 +3013,10 @@ eqfor(Type *t)
 	n = newname(sym);
 	n->class = PFUNC;
 	ntype = nod(OTFUNC, N, N);
-	ntype->list = list(ntype->list, nod(ODCLFIELD, N, typenod(ptrto(types[TBOOL]))));
+	ntype->list = list(ntype->list, nod(ODCLFIELD, N, typenod(ptrto(t))));
+	ntype->list = list(ntype->list, nod(ODCLFIELD, N, typenod(ptrto(t))));
 	ntype->list = list(ntype->list, nod(ODCLFIELD, N, typenod(types[TUINTPTR])));
-	ntype->list = list(ntype->list, nod(ODCLFIELD, N, typenod(ptrto(t))));
-	ntype->list = list(ntype->list, nod(ODCLFIELD, N, typenod(ptrto(t))));
+	ntype->rlist = list(ntype->rlist, nod(ODCLFIELD, N, typenod(types[TBOOL])));
 	typecheck(&ntype, Etype);
 	n->type = ntype->type;
 	return n;
@@ -3037,10 +3037,9 @@ countfield(Type *t)
 static void
 walkcompare(Node **np, NodeList **init)
 {
-	Node *n, *l, *r, *fn, *call, *a, *li, *ri, *expr;
+	Node *n, *l, *r, *call, *a, *li, *ri, *expr;
 	int andor, i;
 	Type *t, *t1;
-	static Node *tempbool;
 	
 	n = *np;
 	
@@ -3058,8 +3057,9 @@ walkcompare(Node **np, NodeList **init)
 		break;
 	}
 	
-	if(!islvalue(n->left) || !islvalue(n->right))
-		goto hard;
+	if(!islvalue(n->left) || !islvalue(n->right)) {
+		fatal("arguments of comparison must be lvalues");
+	}
 
 	l = temp(ptrto(t));
 	a = nod(OAS, l, nod(OADDR, n->left, N));
@@ -3118,57 +3118,16 @@ walkcompare(Node **np, NodeList **init)
 		goto ret;
 	}
 
-	// Chose not to inline, but still have addresses.
-	// Call equality function directly.
-	// The equality function requires a bool pointer for
-	// storing its address, because it has to be callable
-	// from C, and C can't access an ordinary Go return value.
-	// To avoid creating many temporaries, cache one per function.
-	if(tempbool == N || tempbool->curfn != curfn)
-		tempbool = temp(types[TBOOL]);
-	
+	// Chose not to inline.  Call equality function directly.
 	call = nod(OCALL, eqfor(t), N);
-	a = nod(OADDR, tempbool, N);
-	a->etype = 1;  // does not escape
-	call->list = list(call->list, a);
-	call->list = list(call->list, nodintconst(t->width));
 	call->list = list(call->list, l);
 	call->list = list(call->list, r);
-	typecheck(&call, Etop);
-	walkstmt(&call);
-	*init = list(*init, call);
-
-	// tempbool cannot be used directly as multiple comparison
-	// expressions may exist in the same statement. Create another
-	// temporary to hold the value (its address is not taken so it can
-	// be optimized away).
-	r = temp(types[TBOOL]);
-	a = nod(OAS, r, tempbool);
-	typecheck(&a, Etop);
-	walkstmt(&a);
-	*init = list(*init, a);
-
+	call->list = list(call->list, nodintconst(t->width));
+	r = call;
 	if(n->op != OEQ)
 		r = nod(ONOT, r, N);
 	goto ret;
 
-hard:
-	// Cannot take address of one or both of the operands.
-	// Instead, pass directly to runtime helper function.
-	// Easier on the stack than passing the address
-	// of temporary variables, because we are better at reusing
-	// the argument space than temporary variable space.
-	fn = syslook("equal", 1);
-	l = n->left;
-	r = n->right;
-	argtype(fn, n->left->type);
-	argtype(fn, n->left->type);
-	r = mkcall1(fn, n->type, init, typename(n->left->type), l, r);
-	if(n->op == ONE) {
-		r = nod(ONOT, r, N);
-	}
-	goto ret;
-
 ret:
 	typecheck(&r, Erv);
 	walkexpr(&r, init);
diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index ea4156f1ed..409f0fa0c5 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -142,6 +142,106 @@ func nilinterhash(a *eface, s, h uintptr) uintptr {
 	}
 }
 
+func memequal(p, q unsafe.Pointer, size uintptr) bool {
+	if p == q {
+		return true
+	}
+	return memeq(p, q, size)
+}
+
+func memequal0(p, q unsafe.Pointer, size uintptr) bool {
+	return true
+}
+func memequal8(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*int8)(p) == *(*int8)(q)
+}
+func memequal16(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*int16)(p) == *(*int16)(q)
+}
+func memequal32(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*int32)(p) == *(*int32)(q)
+}
+func memequal64(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*int64)(p) == *(*int64)(q)
+}
+func memequal128(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*[2]int64)(p) == *(*[2]int64)(q)
+}
+func f32equal(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*float32)(p) == *(*float32)(q)
+}
+func f64equal(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*float64)(p) == *(*float64)(q)
+}
+func c64equal(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*complex64)(p) == *(*complex64)(q)
+}
+func c128equal(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*complex128)(p) == *(*complex128)(q)
+}
+func strequal(p, q unsafe.Pointer, size uintptr) bool {
+	return *(*string)(p) == *(*string)(q)
+}
+func interequal(p, q unsafe.Pointer, size uintptr) bool {
+	return ifaceeq(*(*interface {
+		f()
+	})(p), *(*interface {
+		f()
+	})(q))
+}
+func nilinterequal(p, q unsafe.Pointer, size uintptr) bool {
+	return efaceeq(*(*interface{})(p), *(*interface{})(q))
+}
+func efaceeq(p, q interface{}) bool {
+	x := (*eface)(unsafe.Pointer(&p))
+	y := (*eface)(unsafe.Pointer(&q))
+	t := x._type
+	if t != y._type {
+		return false
+	}
+	if t == nil {
+		return true
+	}
+	eq := goalg(t.alg).equal
+	if **(**uintptr)(unsafe.Pointer(&eq)) == noequalcode {
+		// calling noequal will panic too,
+		// but we can print a better error.
+		panic(errorString("comparing uncomparable type " + *t._string))
+	}
+	if uintptr(t.size) <= ptrSize {
+		return eq(noescape(unsafe.Pointer(&x.data)), noescape(unsafe.Pointer(&y.data)), uintptr(t.size))
+	}
+	return eq(x.data, y.data, uintptr(t.size))
+}
+func ifaceeq(p, q interface {
+	f()
+}) bool {
+	x := (*iface)(unsafe.Pointer(&p))
+	y := (*iface)(unsafe.Pointer(&q))
+	xtab := x.tab
+	if xtab != y.tab {
+		return false
+	}
+	if xtab == nil {
+		return true
+	}
+	t := xtab._type
+	eq := goalg(t.alg).equal
+	if **(**uintptr)(unsafe.Pointer(&eq)) == noequalcode {
+		// calling noequal will panic too,
+		// but we can print a better error.
+		panic(errorString("comparing uncomparable type " + *t._string))
+	}
+	if uintptr(t.size) <= ptrSize {
+		return eq(noescape(unsafe.Pointer(&x.data)), noescape(unsafe.Pointer(&y.data)), uintptr(t.size))
+	}
+	return eq(x.data, y.data, uintptr(t.size))
+}
+
+func noequal(p, q unsafe.Pointer, size uintptr) bool {
+	panic(errorString("comparing uncomparable types"))
+}
+
 // Testing adapters for hash quality tests (see hash_test.go)
 func haveGoodHash() bool {
 	return use_aeshash
diff --git a/src/pkg/runtime/alg.goc b/src/pkg/runtime/alg.goc
index 6207ae526c..f9e8892929 100644
--- a/src/pkg/runtime/alg.goc
+++ b/src/pkg/runtime/alg.goc
@@ -9,16 +9,6 @@ package runtime
 
 bool runtime·use_aeshash;
 
-void
-runtime·memequal(bool *eq, uintptr s, void *a, void *b)
-{
-	if(a == b) {
-		*eq = 1;
-		return;
-	}
-	*eq = runtime·memeq(a, b, s);
-}
-
 void
 runtime·memprint(uintptr s, void *a)
 {
@@ -52,15 +42,6 @@ runtime·memcopy(uintptr s, void *a, void *b)
 	runtime·memmove(a, b, s);
 }
 
-void
-runtime·memequal0(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	USED(a);
-	USED(b);
-	*eq = true;
-}
-
 void
 runtime·memcopy0(uintptr s, void *a, void *b)
 {
@@ -69,13 +50,6 @@ runtime·memcopy0(uintptr s, void *a, void *b)
 	USED(b);
 }
 
-void
-runtime·memequal8(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = *(uint8*)a == *(uint8*)b;
-}
-
 void
 runtime·memcopy8(uintptr s, void *a, void *b)
 {
@@ -87,13 +61,6 @@ runtime·memcopy8(uintptr s, void *a, void *b)
 	*(uint8*)a = *(uint8*)b;
 }
 
-void
-runtime·memequal16(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = *(uint16*)a == *(uint16*)b;
-}
-
 void
 runtime·memcopy16(uintptr s, void *a, void *b)
 {
@@ -105,13 +72,6 @@ runtime·memcopy16(uintptr s, void *a, void *b)
 	*(uint16*)a = *(uint16*)b;
 }
 
-void
-runtime·memequal32(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = *(uint32*)a == *(uint32*)b;
-}
-
 void
 runtime·memcopy32(uintptr s, void *a, void *b)
 {
@@ -123,13 +83,6 @@ runtime·memcopy32(uintptr s, void *a, void *b)
 	*(uint32*)a = *(uint32*)b;
 }
 
-void
-runtime·memequal64(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = *(uint64*)a == *(uint64*)b;
-}
-
 void
 runtime·memcopy64(uintptr s, void *a, void *b)
 {
@@ -141,13 +94,6 @@ runtime·memcopy64(uintptr s, void *a, void *b)
 	*(uint64*)a = *(uint64*)b;
 }
 
-void
-runtime·memequal128(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = ((uint64*)a)[0] == ((uint64*)b)[0] && ((uint64*)a)[1] == ((uint64*)b)[1];
-}
-
 void
 runtime·memcopy128(uintptr s, void *a, void *b)
 {
@@ -161,42 +107,6 @@ runtime·memcopy128(uintptr s, void *a, void *b)
 	((uint64*)a)[1] = ((uint64*)b)[1];
 }
 
-void
-runtime·f32equal(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = *(float32*)a == *(float32*)b;
-}
-
-void
-runtime·f64equal(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = *(float64*)a == *(float64*)b;
-}
-
-void
-runtime·c64equal(bool *eq, uintptr s, void *a, void *b)
-{	
-	Complex64 *ca, *cb;
-	
-	USED(s);
-	ca = a;
-	cb = b;
-	*eq = ca->real == cb->real && ca->imag == cb->imag;
-}
-
-void
-runtime·c128equal(bool *eq, uintptr s, void *a, void *b)
-{	
-	Complex128 *ca, *cb;
-	
-	USED(s);
-	ca = a;
-	cb = b;
-	*eq = ca->real == cb->real && ca->imag == cb->imag;
-}
-
 void
 runtime·algslicecopy(uintptr s, void *a, void *b)
 {
@@ -212,27 +122,6 @@ runtime·algslicecopy(uintptr s, void *a, void *b)
 	((Slice*)a)->cap = ((Slice*)b)->cap;
 }
 
-void
-runtime·strequal(bool *eq, uintptr s, void *a, void *b)
-{
-	intgo alen;
-	byte *s1, *s2;
-
-	USED(s);
-	alen = ((String*)a)->len;
-	if(alen != ((String*)b)->len) {
-		*eq = false;
-		return;
-	}
-	s1 = ((String*)a)->str;
-	s2 = ((String*)b)->str;
-	if(s1 == s2) {
-		*eq = true;
-		return;
-	}
-	*eq = runtime·memeq(s1, s2, alen);
-}
-
 void
 runtime·strprint(uintptr s, void *a)
 {
@@ -260,13 +149,6 @@ runtime·interprint(uintptr s, void *a)
 	runtime·printiface_c(*(Iface*)a);
 }
 
-void
-runtime·interequal(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = runtime·ifaceeq_c(*(Iface*)a, *(Iface*)b);
-}
-
 void
 runtime·intercopy(uintptr s, void *a, void *b)
 {
@@ -287,13 +169,6 @@ runtime·nilinterprint(uintptr s, void *a)
 	runtime·printeface_c(*(Eface*)a);
 }
 
-void
-runtime·nilinterequal(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	*eq = runtime·efaceeq_c(*(Eface*)a, *(Eface*)b);
-}
-
 void
 runtime·nilintercopy(uintptr s, void *a, void *b)
 {
@@ -310,16 +185,6 @@ runtime·nilintercopy(uintptr s, void *a, void *b)
 extern uintptr runtime·nohashcode;
 extern uintptr runtime·noequalcode;
 
-void
-runtime·noequal(bool *eq, uintptr s, void *a, void *b)
-{
-	USED(s);
-	USED(a);
-	USED(b);
-	USED(eq);
-	runtime·panicstring("comparing uncomparable types");
-}
-
 static FuncVal memhashfunc = {(void*)runtime·memhash};
 static FuncVal nohashfunc = {(void*)runtime·nohash};
 static FuncVal strhashfunc = {(void*)runtime·strhash};
@@ -335,31 +200,48 @@ static FuncVal aeshash32func = {(void*)runtime·aeshash32};
 static FuncVal aeshash64func = {(void*)runtime·aeshash64};
 static FuncVal aeshashstrfunc = {(void*)runtime·aeshashstr};
 
+static FuncVal memequalfunc = {(void*)runtime·memequal};
+static FuncVal noequalfunc = {(void*)runtime·noequal};
+static FuncVal strequalfunc = {(void*)runtime·strequal};
+static FuncVal interequalfunc = {(void*)runtime·interequal};
+static FuncVal nilinterequalfunc = {(void*)runtime·nilinterequal};
+static FuncVal f32equalfunc = {(void*)runtime·f32equal};
+static FuncVal f64equalfunc = {(void*)runtime·f64equal};
+static FuncVal c64equalfunc = {(void*)runtime·c64equal};
+static FuncVal c128equalfunc = {(void*)runtime·c128equal};
+static FuncVal memequal0func = {(void*)runtime·memequal0};
+static FuncVal memequal8func = {(void*)runtime·memequal8};
+static FuncVal memequal16func = {(void*)runtime·memequal16};
+static FuncVal memequal32func = {(void*)runtime·memequal32};
+static FuncVal memequal64func = {(void*)runtime·memequal64};
+static FuncVal memequal128func = {(void*)runtime·memequal128};
+
+
 Alg
 runtime·algarray[] =
 {
-[AMEM]		{ &memhashfunc, runtime·memequal, runtime·memprint, runtime·memcopy },
-[ANOEQ]		{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy },
-[ASTRING]	{ &strhashfunc, runtime·strequal, runtime·strprint, runtime·strcopy },
-[AINTER]	{ &interhashfunc, runtime·interequal, runtime·interprint, runtime·intercopy },
-[ANILINTER]	{ &nilinterhashfunc, runtime·nilinterequal, runtime·nilinterprint, runtime·nilintercopy },
-[ASLICE]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·algslicecopy },
-[AFLOAT32]	{ &f32hashfunc, runtime·f32equal, runtime·memprint, runtime·memcopy },
-[AFLOAT64]	{ &f64hashfunc, runtime·f64equal, runtime·memprint, runtime·memcopy },
-[ACPLX64]	{ &c64hashfunc, runtime·c64equal, runtime·memprint, runtime·memcopy },
-[ACPLX128]	{ &c128hashfunc, runtime·c128equal, runtime·memprint, runtime·memcopy },
-[AMEM0]		{ &memhashfunc, runtime·memequal0, runtime·memprint, runtime·memcopy0 },
-[AMEM8]		{ &memhashfunc, runtime·memequal8, runtime·memprint, runtime·memcopy8 },
-[AMEM16]	{ &memhashfunc, runtime·memequal16, runtime·memprint, runtime·memcopy16 },
-[AMEM32]	{ &memhashfunc, runtime·memequal32, runtime·memprint, runtime·memcopy32 },
-[AMEM64]	{ &memhashfunc, runtime·memequal64, runtime·memprint, runtime·memcopy64 },
-[AMEM128]	{ &memhashfunc, runtime·memequal128, runtime·memprint, runtime·memcopy128 },
-[ANOEQ0]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy0 },
-[ANOEQ8]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy8 },
-[ANOEQ16]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy16 },
-[ANOEQ32]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy32 },
-[ANOEQ64]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy64 },
-[ANOEQ128]	{ &nohashfunc, runtime·noequal, runtime·memprint, runtime·memcopy128 },
+[AMEM]		{ &memhashfunc, &memequalfunc, runtime·memprint, runtime·memcopy },
+[ANOEQ]		{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy },
+[ASTRING]	{ &strhashfunc, &strequalfunc, runtime·strprint, runtime·strcopy },
+[AINTER]	{ &interhashfunc, &interequalfunc, runtime·interprint, runtime·intercopy },
+[ANILINTER]	{ &nilinterhashfunc, &nilinterequalfunc, runtime·nilinterprint, runtime·nilintercopy },
+[ASLICE]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·algslicecopy },
+[AFLOAT32]	{ &f32hashfunc, &f32equalfunc, runtime·memprint, runtime·memcopy },
+[AFLOAT64]	{ &f64hashfunc, &f64equalfunc, runtime·memprint, runtime·memcopy },
+[ACPLX64]	{ &c64hashfunc, &c64equalfunc, runtime·memprint, runtime·memcopy },
+[ACPLX128]	{ &c128hashfunc, &c128equalfunc, runtime·memprint, runtime·memcopy },
+[AMEM0]		{ &memhashfunc, &memequal0func, runtime·memprint, runtime·memcopy0 },
+[AMEM8]		{ &memhashfunc, &memequal8func, runtime·memprint, runtime·memcopy8 },
+[AMEM16]	{ &memhashfunc, &memequal16func, runtime·memprint, runtime·memcopy16 },
+[AMEM32]	{ &memhashfunc, &memequal32func, runtime·memprint, runtime·memcopy32 },
+[AMEM64]	{ &memhashfunc, &memequal64func, runtime·memprint, runtime·memcopy64 },
+[AMEM128]	{ &memhashfunc, &memequal128func, runtime·memprint, runtime·memcopy128 },
+[ANOEQ0]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy0 },
+[ANOEQ8]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy8 },
+[ANOEQ16]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy16 },
+[ANOEQ32]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy32 },
+[ANOEQ64]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy64 },
+[ANOEQ128]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy128 },
 };
 
 // Runtime helpers.
@@ -406,20 +288,6 @@ runtime·hashinit(void)
 	}
 }
 
-// func equal(t *Type, x T, y T) (ret bool)
-#pragma textflag NOSPLIT
-void
-runtime·equal(Type *t, ...)
-{
-	byte *x, *y;
-	bool *ret;
-	
-	x = (byte*)ROUND((uintptr)(&t+1), t->align);
-	y = x + t->size;
-	ret = (bool*)ROUND((uintptr)(y+t->size), Structrnd);
-	t->alg->equal(ret, t->size, x, y);
-}
-
 // Testing adapter for memclr
 func memclrBytes(s Slice) {
 	runtime·memclr(s.array, s.len);
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index d2c6e30469..0607bc8021 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -1149,13 +1149,7 @@ DATA shifts<>+0xfc(SB)/4, $0xff0f0e0d
 
 GLOBL shifts<>(SB),RODATA,$256
 
-TEXT runtime·memeq(SB),NOSPLIT,$0-12
-	MOVL	a+0(FP), SI
-	MOVL	b+4(FP), DI
-	MOVL	count+8(FP), BX
-	JMP	runtime·memeqbody(SB)
-
-TEXT runtime·gomemeq(SB),NOSPLIT,$0-13
+TEXT runtime·memeq(SB),NOSPLIT,$0-13
 	MOVL	a+0(FP), SI
 	MOVL	b+4(FP), DI
 	MOVL	size+8(FP), BX
@@ -2266,38 +2260,3 @@ TEXT runtime·fastrand2(SB), NOSPLIT, $0-4
 	MOVL	DX, m_fastrand(AX)
 	MOVL	DX, ret+0(FP)
 	RET
-
-// The goeq trampoline is necessary while we have
-// both Go and C calls to alg functions.  Once we move all call
-// sites to Go, we can redo the eq functions to use the
-// Go calling convention and remove this.
-
-// convert call to:
-//   func (alg unsafe.Pointer, p, q unsafe.Pointer, size uintptr) bool
-// to:
-//   func (eq *bool, size uintptr, p, q unsafe.Pointer)
-TEXT runtime·goeq(SB), NOSPLIT, $16-17
-	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_goeq<>(SB)
-	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_goeq<>(SB)
-	MOVL	alg+0(FP), AX
-	MOVL	alg_equal(AX), AX
-	MOVL	p+4(FP), CX
-	MOVL	q+8(FP), DX
-	MOVL	size+12(FP), DI
-	LEAL	ret+16(FP), SI
-	MOVL	SI, 0(SP)
-	MOVL	DI, 4(SP)
-	MOVL	CX, 8(SP)
-	MOVL	DX, 12(SP)
-	PCDATA  $PCDATA_StackMapIndex, $0
-	CALL	*AX
-	RET
-
-DATA gcargs_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_goeq<>+0x04(SB)/4, $10  // 5 args
-DATA gcargs_goeq<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsPointer<<4))
-GLOBL gcargs_goeq<>(SB),RODATA,$12
-
-DATA gclocals_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gclocals_goeq<>+0x04(SB)/4, $0  // 0 locals
-GLOBL gclocals_goeq<>(SB),RODATA,$8
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 19e9f1d3a2..0fd21d1795 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -1117,13 +1117,7 @@ DATA shifts<>+0xf0(SB)/8, $0x0807060504030201
 DATA shifts<>+0xf8(SB)/8, $0xff0f0e0d0c0b0a09
 GLOBL shifts<>(SB),RODATA,$256
 
-TEXT runtime·memeq(SB),NOSPLIT,$0-24
-	MOVQ	a+0(FP), SI
-	MOVQ	b+8(FP), DI
-	MOVQ	count+16(FP), BX
-	JMP	runtime·memeqbody(SB)
-
-TEXT runtime·gomemeq(SB),NOSPLIT,$0-25
+TEXT runtime·memeq(SB),NOSPLIT,$0-25
 	MOVQ	a+0(FP), SI
 	MOVQ	b+8(FP), DI
 	MOVQ	size+16(FP), BX
@@ -2305,38 +2299,3 @@ TEXT runtime·fastrand2(SB), NOSPLIT, $0-4
 	MOVL	DX, m_fastrand(AX)
 	MOVL	DX, ret+0(FP)
 	RET
-
-// goeq trampoline is necessary while we have
-// both Go and C calls to alg functions.  Once we move all call
-// sites to Go, we can redo the eq function to use the
-// Go calling convention and remove this.
-
-// convert call to:
-//   func (alg unsafe.Pointer, p, q unsafe.Pointer, size uintptr) bool
-// to:
-//   func (eq *bool, size uintptr, p, q unsafe.Pointer)
-TEXT runtime·goeq(SB), NOSPLIT, $32-33
-	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_goeq<>(SB)
-	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_goeq<>(SB)
-	MOVQ	alg+0(FP), AX
-	MOVQ	alg_equal(AX), AX
-	MOVQ	p+8(FP), CX
-	MOVQ	q+16(FP), DX
-	MOVQ	size+24(FP), DI
-	LEAQ	ret+32(FP), SI
-	MOVQ	SI, 0(SP)
-	MOVQ	DI, 8(SP)
-	MOVQ	CX, 16(SP)
-	MOVQ	DX, 24(SP)
-	PCDATA  $PCDATA_StackMapIndex, $0
-	CALL	*AX
-	RET
-
-DATA gcargs_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_goeq<>+0x04(SB)/4, $10  // 5 args
-DATA gcargs_goeq<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsPointer<<4))
-GLOBL gcargs_goeq<>(SB),RODATA,$12
-
-DATA gclocals_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gclocals_goeq<>+0x04(SB)/4, $0  // 0 locals
-GLOBL gclocals_goeq<>(SB),RODATA,$8
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index f2a1f2a0bc..69e050f90d 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -775,13 +775,7 @@ TEXT runtime·aeshash32(SB),NOSPLIT,$0-24
 TEXT runtime·aeshash64(SB),NOSPLIT,$0-24
 	RET
 
-TEXT runtime·memeq(SB),NOSPLIT,$0-12
-	MOVL	a+0(FP), SI
-	MOVL	b+4(FP), DI
-	MOVL	count+8(FP), BX
-	JMP	runtime·memeqbody(SB)
-
-TEXT runtime·gomemeq(SB),NOSPLIT,$0-17
+TEXT runtime·memeq(SB),NOSPLIT,$0-17
 	MOVL	a+0(FP), SI
 	MOVL	b+4(FP), DI
 	MOVL	size+8(FP), BX
@@ -1180,38 +1174,3 @@ TEXT runtime·fastrand2(SB), NOSPLIT, $0-4
 	MOVL	DX, m_fastrand(AX)
 	MOVL	DX, ret+0(FP)
 	RET
-
-// The goeq trampoline is necessary while we have
-// both Go and C calls to alg functions.  Once we move all call
-// sites to Go, we can redo the eq functions to use the
-// Go calling convention and remove this.
-
-// convert call to:
-//   func (alg unsafe.Pointer, p, q unsafe.Pointer, size uintptr) bool
-// to:
-//   func (eq *bool, size uintptr, p, q unsafe.Pointer)
-TEXT runtime·goeq(SB), NOSPLIT, $16-17
-	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_goeq<>(SB)
-	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_goeq<>(SB)
-	MOVL	alg+0(FP), AX
-	MOVL	alg_equal(AX), AX
-	MOVL	p+4(FP), CX
-	MOVL	q+8(FP), DX
-	MOVL	size+12(FP), DI
-	LEAL	ret+16(FP), SI
-	MOVL	SI, 0(SP)
-	MOVL	DI, 4(SP)
-	MOVL	CX, 8(SP)
-	MOVL	DX, 12(SP)
-	PCDATA  $PCDATA_StackMapIndex, $0
-	CALL	*AX
-	RET
-
-DATA gcargs_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_goeq<>+0x04(SB)/4, $10  // 5 args
-DATA gcargs_goeq<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsPointer<<4))
-GLOBL gcargs_goeq<>(SB),RODATA,$12
-
-DATA gclocals_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gclocals_goeq<>+0x04(SB)/4, $0  // 0 locals
-GLOBL gclocals_goeq<>(SB),RODATA,$8
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 406a426078..324b27b18f 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -703,24 +703,7 @@ TEXT runtime·aeshashstr(SB),NOSPLIT,$-4-0
 	MOVW	$0, R0
 	MOVW	(R0), R1
 
-TEXT runtime·memeq(SB),NOSPLIT,$-4-12
-	MOVW	a+0(FP), R1
-	MOVW	b+4(FP), R2
-	MOVW	n+8(FP), R3
-	ADD	R1, R3, R6
-	MOVW	$1, R0
-_next:
-	CMP	R1, R6
-	RET.EQ
-	MOVBU.P	1(R1), R4
-	MOVBU.P	1(R2), R5
-	CMP	R4, R5
-	BEQ	_next
-
-	MOVW	$0, R0
-	RET
-
-TEXT runtime·gomemeq(SB),NOSPLIT,$-4-13
+TEXT runtime·memeq(SB),NOSPLIT,$-4-13
 	MOVW	a+0(FP), R1
 	MOVW	b+4(FP), R2
 	MOVW	size+8(FP), R3
@@ -1268,38 +1251,3 @@ TEXT runtime·fastrand2(SB), NOSPLIT, $-4-4
 	MOVW	R0, m_fastrand(R1)
 	MOVW	R0, ret+0(FP)
 	RET
-
-// The goeq trampoline is necessary while we have
-// both Go and C calls to alg functions.  Once we move all call
-// sites to Go, we can redo the eq functions to use the
-// Go calling convention and remove this.
-
-// convert call to:
-//   func (alg unsafe.Pointer, p, q unsafe.Pointer, size uintptr) bool
-// to:
-//   func (eq *bool, size uintptr, p, q unsafe.Pointer)
-TEXT runtime·goeq(SB), NOSPLIT, $16-17
-	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_goeq<>(SB)
-	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_goeq<>(SB)
-	MOVW	alg+0(FP), R0
-	MOVW	alg_equal(R0), R0
-	MOVW	p+4(FP), R1
-	MOVW	q+8(FP), R2
-	MOVW	size+12(FP), R3
-	ADD	$40, R13, R4
-	MOVW	R4, 4(R13)
-	MOVW	R3, 8(R13)
-	MOVW	R2, 12(R13)
-	MOVW	R1, 16(R13)
-	PCDATA  $PCDATA_StackMapIndex, $0
-	BL	(R0)
-	RET
-
-DATA gcargs_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_goeq<>+0x04(SB)/4, $10  // 5 args
-DATA gcargs_goeq<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsPointer<<4))
-GLOBL gcargs_goeq<>(SB),RODATA,$12
-
-DATA gclocals_goeq<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gclocals_goeq<>+0x04(SB)/4, $0  // 0 locals
-GLOBL gclocals_goeq<>(SB),RODATA,$8
diff --git a/src/pkg/runtime/hashmap.go b/src/pkg/runtime/hashmap.go
index 6706290974..9dcf48242f 100644
--- a/src/pkg/runtime/hashmap.go
+++ b/src/pkg/runtime/hashmap.go
@@ -243,7 +243,8 @@ func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero)
 	}
-	hash := goalg(t.key.alg).hash(key, uintptr(t.key.size), uintptr(h.hash0))
+	alg := goalg(t.key.alg)
+	hash := alg.hash(key, uintptr(t.key.size), uintptr(h.hash0))
 	m := uintptr(1)<<h.B - 1
 	b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
 	if c := h.oldbuckets; c != nil {
@@ -265,7 +266,7 @@ func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 			if t.indirectkey != 0 {
 				k = *((*unsafe.Pointer)(k))
 			}
-			if goeq(t.key.alg, key, k, uintptr(t.key.size)) {
+			if alg.equal(key, k, uintptr(t.key.size)) {
 				v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
 				if t.indirectvalue != 0 {
 					v = *((*unsafe.Pointer)(v))
@@ -291,7 +292,8 @@ func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero), false
 	}
-	hash := goalg(t.key.alg).hash(key, uintptr(t.key.size), uintptr(h.hash0))
+	alg := goalg(t.key.alg)
+	hash := alg.hash(key, uintptr(t.key.size), uintptr(h.hash0))
 	m := uintptr(1)<<h.B - 1
 	b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
 	if c := h.oldbuckets; c != nil {
@@ -313,7 +315,7 @@ func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)
 			if t.indirectkey != 0 {
 				k = *((*unsafe.Pointer)(k))
 			}
-			if goeq(t.key.alg, key, k, uintptr(t.key.size)) {
+			if alg.equal(key, k, uintptr(t.key.size)) {
 				v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
 				if t.indirectvalue != 0 {
 					v = *((*unsafe.Pointer)(v))
@@ -333,7 +335,8 @@ func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe
 	if h == nil || h.count == 0 {
 		return nil, nil
 	}
-	hash := goalg(t.key.alg).hash(key, uintptr(t.key.size), uintptr(h.hash0))
+	alg := goalg(t.key.alg)
+	hash := alg.hash(key, uintptr(t.key.size), uintptr(h.hash0))
 	m := uintptr(1)<<h.B - 1
 	b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
 	if c := h.oldbuckets; c != nil {
@@ -355,7 +358,7 @@ func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe
 			if t.indirectkey != 0 {
 				k = *((*unsafe.Pointer)(k))
 			}
-			if goeq(t.key.alg, key, k, uintptr(t.key.size)) {
+			if alg.equal(key, k, uintptr(t.key.size)) {
 				v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
 				if t.indirectvalue != 0 {
 					v = *((*unsafe.Pointer)(v))
@@ -383,7 +386,8 @@ func mapassign1(t *maptype, h *hmap, key unsafe.Pointer, val unsafe.Pointer) {
 		raceReadObjectPC(t.elem, val, callerpc, pc)
 	}
 
-	hash := goalg(t.key.alg).hash(key, uintptr(t.key.size), uintptr(h.hash0))
+	alg := goalg(t.key.alg)
+	hash := alg.hash(key, uintptr(t.key.size), uintptr(h.hash0))
 
 	if h.buckets == nil {
 		if checkgc {
@@ -421,7 +425,7 @@ again:
 			if t.indirectkey != 0 {
 				k2 = *((*unsafe.Pointer)(k2))
 			}
-			if !goeq(t.key.alg, key, k2, uintptr(t.key.size)) {
+			if !alg.equal(key, k2, uintptr(t.key.size)) {
 				continue
 			}
 			// already have a mapping for key.  Update it.
@@ -492,7 +496,8 @@ func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 	if h == nil || h.count == 0 {
 		return
 	}
-	hash := goalg(t.key.alg).hash(key, uintptr(t.key.size), uintptr(h.hash0))
+	alg := goalg(t.key.alg)
+	hash := alg.hash(key, uintptr(t.key.size), uintptr(h.hash0))
 	bucket := hash & (uintptr(1)<<h.B - 1)
 	if h.oldbuckets != nil {
 		growWork(t, h, bucket)
@@ -512,7 +517,7 @@ func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 			if t.indirectkey != 0 {
 				k2 = *((*unsafe.Pointer)(k2))
 			}
-			if !goeq(t.key.alg, key, k2, uintptr(t.key.size)) {
+			if !alg.equal(key, k2, uintptr(t.key.size)) {
 				continue
 			}
 			memclr(k, uintptr(t.keysize))
@@ -595,6 +600,7 @@ func mapiternext(it *hiter) {
 	b := it.bptr
 	i := it.i
 	checkBucket := it.checkBucket
+	alg := goalg(t.key.alg)
 
 next:
 	if b == nil {
@@ -645,10 +651,10 @@ next:
 				if t.indirectkey != 0 {
 					k2 = *((*unsafe.Pointer)(k2))
 				}
-				if goeq(t.key.alg, k2, k2, uintptr(t.key.size)) {
+				if alg.equal(k2, k2, uintptr(t.key.size)) {
 					// If the item in the oldbucket is not destined for
 					// the current new bucket in the iteration, skip it.
-					hash := goalg(t.key.alg).hash(k2, uintptr(t.key.size), uintptr(h.hash0))
+					hash := alg.hash(k2, uintptr(t.key.size), uintptr(h.hash0))
 					if hash&(uintptr(1)<<it.B-1) != checkBucket {
 						continue
 					}
@@ -682,7 +688,7 @@ next:
 				if t.indirectkey != 0 {
 					k2 = *((*unsafe.Pointer)(k2))
 				}
-				if goeq(t.key.alg, k2, k2, uintptr(t.key.size)) {
+				if alg.equal(k2, k2, uintptr(t.key.size)) {
 					// Check the current hash table for the data.
 					// This code handles the case where the key
 					// has been deleted, updated, or deleted and reinserted.
@@ -758,6 +764,7 @@ func growWork(t *maptype, h *hmap, bucket uintptr) {
 func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
 	b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
 	newbit := uintptr(1) << (h.B - 1)
+	alg := goalg(t.key.alg)
 	if !evacuated(b) {
 		// TODO: reuse overflow buckets instead of using new ones, if there
 		// is no iterator using the old buckets.  (If !oldIterator.)
@@ -788,9 +795,9 @@ func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
 				}
 				// Compute hash to make our evacuation decision (whether we need
 				// to send this key/value to bucket x or bucket y).
-				hash := goalg(t.key.alg).hash(k2, uintptr(t.key.size), uintptr(h.hash0))
+				hash := alg.hash(k2, uintptr(t.key.size), uintptr(h.hash0))
 				if h.flags&iterator != 0 {
-					if !goeq(t.key.alg, k2, k2, uintptr(t.key.size)) {
+					if !alg.equal(k2, k2, uintptr(t.key.size)) {
 						// If key != key (NaNs), then the hash could be (and probably
 						// will be) entirely different from the old hash.  Moreover,
 						// it isn't reproducible.  Reproducibility is required in the
diff --git a/src/pkg/runtime/hashmap_fast.go b/src/pkg/runtime/hashmap_fast.go
index 989ae032bd..c1b71d6d86 100644
--- a/src/pkg/runtime/hashmap_fast.go
+++ b/src/pkg/runtime/hashmap_fast.go
@@ -209,7 +209,7 @@ func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
 				if k.len != key.len {
 					continue
 				}
-				if k.str == key.str || gomemeq(k.str, key.str, uintptr(key.len)) {
+				if k.str == key.str || memeq(k.str, key.str, uintptr(key.len)) {
 					return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+i*uintptr(t.valuesize))
 				}
 			}
@@ -247,7 +247,7 @@ func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
 		}
 		if keymaybe != bucketCnt {
 			k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+keymaybe*2*ptrSize))
-			if gomemeq(k.str, key.str, uintptr(key.len)) {
+			if memeq(k.str, key.str, uintptr(key.len)) {
 				return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+keymaybe*uintptr(t.valuesize))
 			}
 		}
@@ -277,7 +277,7 @@ dohash:
 			if k.len != key.len {
 				continue
 			}
-			if k.str == key.str || gomemeq(k.str, key.str, uintptr(key.len)) {
+			if k.str == key.str || memeq(k.str, key.str, uintptr(key.len)) {
 				return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+i*uintptr(t.valuesize))
 			}
 		}
@@ -313,7 +313,7 @@ func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
 				if k.len != key.len {
 					continue
 				}
-				if k.str == key.str || gomemeq(k.str, key.str, uintptr(key.len)) {
+				if k.str == key.str || memeq(k.str, key.str, uintptr(key.len)) {
 					return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+i*uintptr(t.valuesize)), true
 				}
 			}
@@ -349,7 +349,7 @@ func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
 		}
 		if keymaybe != bucketCnt {
 			k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+keymaybe*2*ptrSize))
-			if gomemeq(k.str, key.str, uintptr(key.len)) {
+			if memeq(k.str, key.str, uintptr(key.len)) {
 				return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+keymaybe*uintptr(t.valuesize)), true
 			}
 		}
@@ -379,7 +379,7 @@ dohash:
 			if k.len != key.len {
 				continue
 			}
-			if k.str == key.str || gomemeq(k.str, key.str, uintptr(key.len)) {
+			if k.str == key.str || memeq(k.str, key.str, uintptr(key.len)) {
 				return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*ptrSize+i*uintptr(t.valuesize)), true
 			}
 		}
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index d3428e5a9c..9bd6fc7617 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -408,48 +408,6 @@ func assertE2E2(inter *interfacetype, e interface{}) (interface{}, bool) {
 	return e, true
 }
 
-func efaceeq(e1 interface{}, e2 interface{}) bool {
-	p1 := (*eface)(unsafe.Pointer(&e1))
-	p2 := (*eface)(unsafe.Pointer(&e2))
-	t := p1._type
-	if t != p2._type {
-		return false
-	}
-	if t == nil {
-		return true
-	}
-
-	if *(*uintptr)(unsafe.Pointer(&t.alg.equal)) == noequalcode {
-		panic(errorString("comparing uncomparable type " + *t._string))
-	}
-	size := uintptr(t.size)
-	if size <= ptrSize {
-		return goeq(t.alg, unsafe.Pointer(&p1.data), unsafe.Pointer(&p2.data), size)
-	}
-	return goeq(t.alg, p1.data, p2.data, size)
-}
-
-func ifaceeq(i1 fInterface, i2 fInterface) bool {
-	p1 := (*iface)(unsafe.Pointer(&i1))
-	p2 := (*iface)(unsafe.Pointer(&i2))
-	tab := p1.tab
-	if tab != p2.tab {
-		return false
-	}
-	if tab == nil {
-		return true
-	}
-	t := tab._type
-	if *(*uintptr)(unsafe.Pointer(&t.alg.equal)) == noequalcode {
-		panic(errorString("comparing uncomparable type " + *t._string))
-	}
-	size := uintptr(t.size)
-	if size <= ptrSize {
-		return goeq(t.alg, unsafe.Pointer(&p1.data), unsafe.Pointer(&p2.data), size)
-	}
-	return goeq(t.alg, p1.data, p2.data, size)
-}
-
 func ifacethash(i fInterface) uint32 {
 	ip := (*iface)(unsafe.Pointer(&i))
 	tab := ip.tab
diff --git a/src/pkg/runtime/iface.goc b/src/pkg/runtime/iface.goc
index a2e968fafa..2ac7405905 100644
--- a/src/pkg/runtime/iface.goc
+++ b/src/pkg/runtime/iface.goc
@@ -153,49 +153,3 @@ runtime·ifaceE2I2(InterfaceType *inter, Eface e, Iface *ret)
 	ret->data = e.data;
 	return true;
 }
-
-static bool
-ifaceeq1(void *data1, void *data2, Type *t)
-{
-	uintptr size;
-	Alg *alg;
-	Eface err;
-	bool eq;
-
-	alg = t->alg;
-	size = t->size;
-
-	if(alg->equal == runtime·noequal) {
-		// calling noequal will panic too,
-		// but we can print a better error.
-		runtime·newErrorString(runtime·catstring(runtime·gostringnocopy((byte*)"comparing uncomparable type "), *t->string), &err);
-		runtime·panic(err);
-	}
-
-	eq = 0;
-	if(size <= sizeof(data1))
-		alg->equal(&eq, size, &data1, &data2);
-	else
-		alg->equal(&eq, size, data1, data2);
-	return eq;
-}
-
-bool
-runtime·ifaceeq_c(Iface i1, Iface i2)
-{
-	if(i1.tab != i2.tab)
-		return false;
-	if(i1.tab == nil)
-		return true;
-	return ifaceeq1(i1.data, i2.data, i1.tab->type);
-}
-
-bool
-runtime·efaceeq_c(Eface e1, Eface e2)
-{
-	if(e1.type != e2.type)
-		return false;
-	if(e1.type == nil)
-		return true;
-	return ifaceeq1(e1.data, e2.data, e1.type);
-}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index b85198f480..62100a783a 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -634,7 +634,7 @@ typedef	struct	Alg		Alg;
 struct	Alg
 {
 	FuncVal* hash;
-	void	(*equal)(bool*, uintptr, void*, void*);
+	FuncVal* equal;
 	void	(*print)(uintptr, void*);
 	void	(*copy)(uintptr, void*, void*);
 };
@@ -665,13 +665,21 @@ void	runtime·aeshash32(void*, uintptr, uintptr, uintptr);
 void	runtime·aeshash64(void*, uintptr, uintptr, uintptr);
 void	runtime·aeshashstr(void*, uintptr, uintptr, uintptr);
 
-void	runtime·memequal(bool*, uintptr, void*, void*);
-void	runtime·noequal(bool*, uintptr, void*, void*);
-void	runtime·strequal(bool*, uintptr, void*, void*);
-void	runtime·interequal(bool*, uintptr, void*, void*);
-void	runtime·nilinterequal(bool*, uintptr, void*, void*);
-
-bool	runtime·memeq(void*, void*, uintptr);
+void	runtime·memequal(void*, void*, uintptr, bool);
+void	runtime·noequal(void*, void*, uintptr, bool);
+void	runtime·strequal(void*, void*, uintptr, bool);
+void	runtime·interequal(void*, void*, uintptr, bool);
+void	runtime·nilinterequal(void*, void*, uintptr, bool);
+void	runtime·f32equal(void*, void*, uintptr, bool);
+void	runtime·f64equal(void*, void*, uintptr, bool);
+void	runtime·c64equal(void*, void*, uintptr, bool);
+void	runtime·c128equal(void*, void*, uintptr, bool);
+void	runtime·memequal0(void*, void*, uintptr, bool);
+void	runtime·memequal8(void*, void*, uintptr, bool);
+void	runtime·memequal16(void*, void*, uintptr, bool);
+void	runtime·memequal32(void*, void*, uintptr, bool);
+void	runtime·memequal64(void*, void*, uintptr, bool);
+void	runtime·memequal128(void*, void*, uintptr, bool);
 
 void	runtime·memprint(uintptr, void*);
 void	runtime·strprint(uintptr, void*);
@@ -873,8 +881,6 @@ MCache*	runtime·allocmcache(void);
 void	runtime·freemcache(MCache*);
 void	runtime·mallocinit(void);
 void	runtime·chaninit(void);
-bool	runtime·ifaceeq_c(Iface, Iface);
-bool	runtime·efaceeq_c(Eface, Eface);
 void*	runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void	runtime·runpanic(Panic*);
 uintptr	runtime·getcallersp(void*);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 77eece9433..9c18434d5d 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -111,20 +111,12 @@ func starttheworld()
 func stoptheworld()
 func clearpools()
 
-// in asm_*.s
-//go:noescape
-func gohash(a *alg, p unsafe.Pointer, size uintptr, seed uintptr) uintptr
-
-// in asm_*.s
-//go:noescape
-func goeq(alg *alg, p, q unsafe.Pointer, size uintptr) bool
-
 // exported value for testing
 var hashLoad = loadFactor
 
 // in asm_*.s
 //go:noescape
-func gomemeq(a, b unsafe.Pointer, size uintptr) bool
+func memeq(a, b unsafe.Pointer, size uintptr) bool
 
 // Code pointers for the nohash/noequal algorithms. Used for producing better error messages.
 var nohashcode uintptr
@@ -147,6 +139,9 @@ type goalgtype struct {
 	// function for hashing objects of this type
 	// (ptr to object, size, seed) -> hash
 	hash func(unsafe.Pointer, uintptr, uintptr) uintptr
+	// function for comparing objects of this type
+	// (ptr to object A, ptr to object B, size) -> ==?
+	equal func(unsafe.Pointer, unsafe.Pointer, uintptr) bool
 }
 
 func goalg(a *alg) *goalgtype {

From 750bf48a5a5d2f7d0e00752544800ac09453b65f Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 7 Aug 2014 15:05:20 -0700
Subject: [PATCH 035/423] cmd/go: don't pass --buildid=none on OpenBSD

According to the OpenBSD builder, it doesn't work.

TBR=bradfitz
CC=golang-codereviews
https://golang.org/cl/126830043
---
 src/cmd/go/build.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 88c2e29490..00df6b2915 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -2324,7 +2324,7 @@ func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles, gxxfiles, mfiles
 	// systems likely to support it, which is to say, systems that
 	// normally use gold or the GNU linker.
 	switch goos {
-	case "android", "dragonfly", "linux", "netbsd", "openbsd":
+	case "android", "dragonfly", "linux", "netbsd":
 		ldflags = append(ldflags, "-Wl,--build-id=none")
 	}
 

From 10c2f56bf968884db3883a0c0b2a20f964a0ad4c Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Fri, 8 Aug 2014 08:56:40 +1000
Subject: [PATCH 036/423] cmd/go: download test dependencies of all named
 packages

Fixes #8181.

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/123870043
---
 src/cmd/go/get.go    |  4 +++-
 src/cmd/go/test.bash | 11 +++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/get.go b/src/cmd/go/get.go
index e708fcf779..a34286f540 100644
--- a/src/cmd/go/get.go
+++ b/src/cmd/go/get.go
@@ -151,7 +151,9 @@ func download(arg string, stk *importStack, getTestDeps bool) {
 	}
 
 	// Only process each package once.
-	if downloadCache[arg] {
+	// (Unless we're fetching test dependencies for this package,
+	// in which case we want to process it again.)
+	if downloadCache[arg] && !getTestDeps {
 		return
 	}
 	downloadCache[arg] = true
diff --git a/src/cmd/go/test.bash b/src/cmd/go/test.bash
index e5ba12b1df..411ef1863f 100755
--- a/src/cmd/go/test.bash
+++ b/src/cmd/go/test.bash
@@ -543,6 +543,17 @@ TEST go get cover
 unset GOPATH
 rm -rf $d
 
+TEST go get -t "code.google.com/p/go-get-issue-8181/{a,b}"
+d=$(TMPDIR=/var/tmp mktemp -d -t testgoXXX)
+export GOPATH=$d
+if ./testgo get -t code.google.com/p/go-get-issue-8181/{a,b}; then
+	./testgo list ... | grep go.tools/godoc > /dev/null || ok=false
+else
+	ok=false
+fi
+unset GOPATH
+rm -rf $d
+
 TEST shadowing logic
 export GOPATH=$(pwd)/testdata/shadow/root1:$(pwd)/testdata/shadow/root2
 

From f3fa0bbd1f011c7436f21a18ee08f719a15b02b8 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Fri, 8 Aug 2014 08:57:18 +1000
Subject: [PATCH 037/423] flag: mention -h in docs

Fixes #8314.

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/125820043
---
 src/pkg/flag/flag.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/pkg/flag/flag.go b/src/pkg/flag/flag.go
index fa7760550c..de2d91f8b1 100644
--- a/src/pkg/flag/flag.go
+++ b/src/pkg/flag/flag.go
@@ -73,7 +73,8 @@ import (
 	"time"
 )
 
-// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined.
+// ErrHelp is the error returned if the -help or -h flag is invoked
+// but no such flag is defined.
 var ErrHelp = errors.New("flag: help requested")
 
 // -- bool Value
@@ -788,7 +789,7 @@ func (f *FlagSet) parseOne() (bool, error) {
 // Parse parses flag definitions from the argument list, which should not
 // include the command name.  Must be called after all flags in the FlagSet
 // are defined and before flags are accessed by the program.
-// The return value will be ErrHelp if -help was set but not defined.
+// The return value will be ErrHelp if -help or -h were set but not defined.
 func (f *FlagSet) Parse(arguments []string) error {
 	f.parsed = true
 	f.args = arguments

From 77a8dcab03c1bf8efa5cafaa2d9dc0a9f7a3dcf6 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Fri, 8 Aug 2014 08:57:41 +1000
Subject: [PATCH 038/423] encoding/json: document coercion of invalid UTF-8
 characters

Fixes #8342.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/122180043
---
 src/pkg/encoding/json/encode.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/encoding/json/encode.go b/src/pkg/encoding/json/encode.go
index 741ddd89cb..5341a3a01b 100644
--- a/src/pkg/encoding/json/encode.go
+++ b/src/pkg/encoding/json/encode.go
@@ -40,8 +40,8 @@ import (
 //
 // Floating point, integer, and Number values encode as JSON numbers.
 //
-// String values encode as JSON strings. InvalidUTF8Error will be returned
-// if an invalid UTF-8 sequence is encountered.
+// String values encode as JSON strings coerced to valid UTF-8,
+// replacing invalid bytes with the Unicode replacement rune.
 // The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e"
 // to keep some browsers from misinterpreting JSON output as HTML.
 // Ampersand "&" is also escaped to "\u0026" for the same reason.

From 6fb2a05ac9f6b4063f1c952df069871e9e6796d9 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Fri, 8 Aug 2014 10:09:31 +1000
Subject: [PATCH 039/423] os: simplify windows Getwd (fixes build)

Current version of Getwd calls Stat that
calls Getwd therefore infinite recursion.

LGTM=minux
R=golang-codereviews, minux
CC=golang-codereviews
https://golang.org/cl/119600043
---
 src/pkg/os/getwd.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/pkg/os/getwd.go b/src/pkg/os/getwd.go
index eacb414660..d5da53b34b 100644
--- a/src/pkg/os/getwd.go
+++ b/src/pkg/os/getwd.go
@@ -5,6 +5,7 @@
 package os
 
 import (
+	"runtime"
 	"sync"
 	"syscall"
 )
@@ -23,6 +24,10 @@ var useSyscallwd = func(error) bool { return true }
 // reached via multiple paths (due to symbolic links),
 // Getwd may return any one of them.
 func Getwd() (dir string, err error) {
+	if runtime.GOOS == "windows" {
+		return syscall.Getwd()
+	}
+
 	// Clumsy but widespread kludge:
 	// if $PWD is set and matches ".", use it.
 	dot, err := Stat(".")

From be96e52cce0723dac8288f8ef7ea5565492dc679 Mon Sep 17 00:00:00 2001
From: Shenghou Ma <minux@golang.org>
Date: Thu, 7 Aug 2014 21:48:34 -0400
Subject: [PATCH 040/423] misc/nacl/testzip.proto: include cmd/internal/* to
 fix build

LGTM=adg, dave
R=golang-codereviews, adg, dave
CC=golang-codereviews
https://golang.org/cl/123050043
---
 misc/nacl/testzip.proto | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/misc/nacl/testzip.proto b/misc/nacl/testzip.proto
index 57c2e1b08a..596f50303c 100644
--- a/misc/nacl/testzip.proto
+++ b/misc/nacl/testzip.proto
@@ -10,6 +10,8 @@ usr	src=../misc/nacl/testdata
 go	src=..
 	src
 		cmd
+			internal
+				+
 			gofmt
 				testdata
 					+

From 40b94405463415f6ba5d2decc0cd51eb61c67b65 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Fri, 8 Aug 2014 16:19:45 +1000
Subject: [PATCH 041/423] debug/pe/testdata: make sure gcc-amd64-mingw-exec has
 symbols

as per rsc request

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/123970043
---
 src/pkg/debug/pe/file_test.go                 |  31 +++++++++++-------
 .../debug/pe/testdata/gcc-amd64-mingw-exec    | Bin 37376 -> 273083 bytes
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/pkg/debug/pe/file_test.go b/src/pkg/debug/pe/file_test.go
index ddbb271744..0d73969bca 100644
--- a/src/pkg/debug/pe/file_test.go
+++ b/src/pkg/debug/pe/file_test.go
@@ -125,9 +125,9 @@ var fileTests = []fileTest{
 	},
 	{
 		"testdata/gcc-amd64-mingw-exec",
-		FileHeader{0x8664, 0x9, 0x53472993, 0x0, 0x0, 0xf0, 0x22f},
+		FileHeader{0x8664, 0x11, 0x53e4364f, 0x39600, 0x6fc, 0xf0, 0x27},
 		&OptionalHeader64{
-			0x20b, 0x2, 0x16, 0x6a00, 0x2400, 0x1600, 0x14e0, 0x1000, 0x400000, 0x1000, 0x200, 0x4, 0x0, 0x0, 0x0, 0x5, 0x2, 0x0, 0x11000, 0x400, 0x1841e, 0x3, 0x0, 0x200000, 0x1000, 0x100000, 0x1000, 0x0, 0x10,
+			0x20b, 0x2, 0x16, 0x6a00, 0x2400, 0x1600, 0x14e0, 0x1000, 0x400000, 0x1000, 0x200, 0x4, 0x0, 0x0, 0x0, 0x5, 0x2, 0x0, 0x45000, 0x600, 0x46f19, 0x3, 0x0, 0x200000, 0x1000, 0x100000, 0x1000, 0x0, 0x10,
 			[16]DataDirectory{
 				{0x0, 0x0},
 				{0xe000, 0x990},
@@ -145,18 +145,25 @@ var fileTests = []fileTest{
 				{0x0, 0x0},
 				{0x0, 0x0},
 				{0x0, 0x0},
-			},
-		},
+			}},
 		[]*SectionHeader{
-			{".text", 0x6860, 0x1000, 0x6a00, 0x400, 0x0, 0x0, 0x0, 0x0, 0x60500020},
-			{".data", 0xe0, 0x8000, 0x200, 0x6e00, 0x0, 0x0, 0x0, 0x0, 0xc0500040},
-			{".rdata", 0x6b0, 0x9000, 0x800, 0x7000, 0x0, 0x0, 0x0, 0x0, 0x40600040},
-			{".pdata", 0x498, 0xa000, 0x600, 0x7800, 0x0, 0x0, 0x0, 0x0, 0x40300040},
-			{".xdata", 0x488, 0xb000, 0x600, 0x7e00, 0x0, 0x0, 0x0, 0x0, 0x40300040},
+			{".text", 0x6860, 0x1000, 0x6a00, 0x600, 0x0, 0x0, 0x0, 0x0, 0x60500020},
+			{".data", 0xe0, 0x8000, 0x200, 0x7000, 0x0, 0x0, 0x0, 0x0, 0xc0500040},
+			{".rdata", 0x6b0, 0x9000, 0x800, 0x7200, 0x0, 0x0, 0x0, 0x0, 0x40600040},
+			{".pdata", 0x498, 0xa000, 0x600, 0x7a00, 0x0, 0x0, 0x0, 0x0, 0x40300040},
+			{".xdata", 0x488, 0xb000, 0x600, 0x8000, 0x0, 0x0, 0x0, 0x0, 0x40300040},
 			{".bss", 0x1410, 0xc000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0600080},
-			{".idata", 0x990, 0xe000, 0xa00, 0x8400, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
-			{".CRT", 0x68, 0xf000, 0x200, 0x8e00, 0x0, 0x0, 0x0, 0x0, 0xc0400040},
-			{".tls", 0x48, 0x10000, 0x200, 0x9000, 0x0, 0x0, 0x0, 0x0, 0xc0600040},
+			{".idata", 0x990, 0xe000, 0xa00, 0x8600, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
+			{".CRT", 0x68, 0xf000, 0x200, 0x9000, 0x0, 0x0, 0x0, 0x0, 0xc0400040},
+			{".tls", 0x48, 0x10000, 0x200, 0x9200, 0x0, 0x0, 0x0, 0x0, 0xc0600040},
+			{".debug_aranges", 0x600, 0x11000, 0x600, 0x9400, 0x0, 0x0, 0x0, 0x0, 0x42500040},
+			{".debug_info", 0x1316e, 0x12000, 0x13200, 0x9a00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
+			{".debug_abbrev", 0x2ccb, 0x26000, 0x2e00, 0x1cc00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
+			{".debug_line", 0x3c4d, 0x29000, 0x3e00, 0x1fa00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
+			{".debug_frame", 0x18b8, 0x2d000, 0x1a00, 0x23800, 0x0, 0x0, 0x0, 0x0, 0x42400040},
+			{".debug_str", 0x396, 0x2f000, 0x400, 0x25200, 0x0, 0x0, 0x0, 0x0, 0x42100040},
+			{".debug_loc", 0x13240, 0x30000, 0x13400, 0x25600, 0x0, 0x0, 0x0, 0x0, 0x42100040},
+			{".debug_ranges", 0xa70, 0x44000, 0xc00, 0x38a00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
 		},
 		[]*Symbol{},
 	},
diff --git a/src/pkg/debug/pe/testdata/gcc-amd64-mingw-exec b/src/pkg/debug/pe/testdata/gcc-amd64-mingw-exec
index 78d4e5fed98b09866e047db6a670b9721c03badb..ce6feb6b7b6a4ca1fc5da067254d8acfd49f3377 100644
GIT binary patch
literal 273083
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%0AedQtksLh-3vF)aKB#82`mVMf
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
UH-q8}zsA~0CpNQknsE*9e|)qGcmMzZ

delta 101
zcmdmeRiI%B(}Xr5PKL>v?!gRD@PR>}Y2pk^E&)ac1{MYexfaHWw+}J0OrFQ6&X_m(
y7?3QO{0>M~OcrBOXRMoS$K=o0GPw`P?wh=gNqzEGCPAiz1DhWf2rw>U>jMBxyBw_m


From 21f7d83ffd3633869e9861efbe99f035daeb2201 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Fri, 8 Aug 2014 16:20:20 +0900
Subject: [PATCH 042/423] cmd/go: fix build in airplane mode

LGTM=iant
R=golang-codereviews, adg, iant
CC=golang-codereviews
https://golang.org/cl/122190043
---
 src/cmd/go/vcs_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/cmd/go/vcs_test.go b/src/cmd/go/vcs_test.go
index f9bf75fef1..3097c4d1c5 100644
--- a/src/cmd/go/vcs_test.go
+++ b/src/cmd/go/vcs_test.go
@@ -12,6 +12,9 @@ import (
 // Test that RepoRootForImportPath creates the correct RepoRoot for a given importPath.
 // TODO(cmang): Add tests for SVN and BZR.
 func TestRepoRootForImportPath(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test to avoid external network")
+	}
 	switch runtime.GOOS {
 	case "nacl", "android":
 		t.Skipf("no networking available on %s", runtime.GOOS)

From f7832df7695c1e5930b2c8ed5e02d529d00f21a4 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 8 Aug 2014 12:48:34 +0400
Subject: [PATCH 043/423] encoding/gob: fix data races in benchmarks All
 goroutines decode into the same value.

LGTM=r
R=r, abursavich
CC=golang-codereviews
https://golang.org/cl/123930043
---
 src/pkg/encoding/gob/timing_test.go | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/src/pkg/encoding/gob/timing_test.go b/src/pkg/encoding/gob/timing_test.go
index 29c9b858b6..ec55c4d63d 100644
--- a/src/pkg/encoding/gob/timing_test.go
+++ b/src/pkg/encoding/gob/timing_test.go
@@ -19,12 +19,13 @@ type Bench struct {
 	D []byte
 }
 
-func benchmarkEndToEnd(b *testing.B, v interface{}, pipe func() (r io.Reader, w io.Writer, err error)) {
+func benchmarkEndToEnd(b *testing.B, ctor func() interface{}, pipe func() (r io.Reader, w io.Writer, err error)) {
 	b.RunParallel(func(pb *testing.PB) {
 		r, w, err := pipe()
 		if err != nil {
 			b.Fatal("can't get pipe:", err)
 		}
+		v := ctor()
 		enc := NewEncoder(w)
 		dec := NewDecoder(r)
 		for pb.Next() {
@@ -39,29 +40,33 @@ func benchmarkEndToEnd(b *testing.B, v interface{}, pipe func() (r io.Reader, w
 }
 
 func BenchmarkEndToEndPipe(b *testing.B) {
-	v := &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
-	benchmarkEndToEnd(b, v, func() (r io.Reader, w io.Writer, err error) {
+	benchmarkEndToEnd(b, func() interface{} {
+		return &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
+	}, func() (r io.Reader, w io.Writer, err error) {
 		r, w, err = os.Pipe()
 		return
 	})
 }
 
 func BenchmarkEndToEndByteBuffer(b *testing.B) {
-	v := &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
-	benchmarkEndToEnd(b, v, func() (r io.Reader, w io.Writer, err error) {
+	benchmarkEndToEnd(b, func() interface{} {
+		return &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)}
+	}, func() (r io.Reader, w io.Writer, err error) {
 		var buf bytes.Buffer
 		return &buf, &buf, nil
 	})
 }
 
 func BenchmarkEndToEndSliceByteBuffer(b *testing.B) {
-	v := &Bench{7, 3.2, "now is the time", nil}
-	Register(v)
-	arr := make([]interface{}, 100)
-	for i := range arr {
-		arr[i] = v
-	}
-	benchmarkEndToEnd(b, &arr, func() (r io.Reader, w io.Writer, err error) {
+	benchmarkEndToEnd(b, func() interface{} {
+		v := &Bench{7, 3.2, "now is the time", nil}
+		Register(v)
+		arr := make([]interface{}, 100)
+		for i := range arr {
+			arr[i] = v
+		}
+		return &arr
+	}, func() (r io.Reader, w io.Writer, err error) {
 		var buf bytes.Buffer
 		return &buf, &buf, nil
 	})

From a83bbc9c488fb5b5405a5d1dc13a32d588a2fccd Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 8 Aug 2014 11:20:45 -0400
Subject: [PATCH 044/423] syscall: ignore EINVAL/ENOENT from readdirent on OS X
 10.10

On OS X 10.10 Yosemite, if you have a directory that can be returned
in a single getdirentries64 call (for example, a directory with one file),
and you read from the directory at EOF twice, you get EOF both times:
        fd = open("dir")
        getdirentries64(fd) returns data
        getdirentries64(fd) returns 0 (EOF)
        getdirentries64(fd) returns 0 (EOF)

But if you remove the file in the middle between the two calls, the
second call returns an error instead.
        fd = open("dir")
        getdirentries64(fd) returns data
        getdirentries64(fd) returns 0 (EOF)
        remove("dir/file")
        getdirentries64(fd) returns ENOENT/EINVAL

Whether you get ENOENT or EINVAL depends on exactly what was
in the directory. It is deterministic, just data-dependent.

This only happens in small directories. A directory containing more data
than fits in a 4k getdirentries64 call will return EOF correctly.
(It's not clear if the criteria is that the directory be split across multiple
getdirentries64 calls or that it be split across multiple file system blocks.)

We could change package os to avoid the second read at EOF,
and maybe we should, but that's a bit involved.
For now, treat the EINVAL/ENOENT as EOF.

With this CL, all.bash passes on my MacBook Air running
OS X 10.10 (14A299l) and Xcode 6 beta 5 (6A279r).

I tried filing an issue with Apple using "Feedback Assistant", but it was
unable to send the report and lost it.

C program reproducing the issue, also at http://swtch.com/~rsc/readdirbug.c:

#include <stdio.h>
#include <dirent.h>
#include <unistd.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

static void test(int);

int
main(void)
{
        int fd, n;
        DIR *dir;
        struct dirent *dp;
        struct stat st;
        char buf[10000];
        long basep;
        int saw;

        if(stat("/tmp/readdirbug", &st) >= 0) {
                fprintf(stderr, "please rm -r /tmp/readdirbug and run again\n");
                exit(1);
        }

        fprintf(stderr, "mkdir /tmp/readdirbug\n");
        if(mkdir("/tmp/readdirbug", 0777) < 0) {
                perror("mkdir /tmp/readdirbug");
                exit(1);
        }

        fprintf(stderr, "create /tmp/readdirbug/file1\n");
        if((fd = creat("/tmp/readdirbug/file1", 0666)) < 0) {
                perror("create /tmp/readdirbug/file1");
                exit(1);
        }
        close(fd);

        test(0);
        test(1);

        fprintf(stderr, "ok - everything worked\n");
}

static void
test(int doremove)
{
        DIR *dir;
        struct dirent *dp;
        int numeof;

        fprintf(stderr, "\n");
        fprintf(stderr, "opendir /tmp/readdirbug\n");
        dir = opendir("/tmp/readdirbug");
        if(dir == 0) {
                perror("open /tmp/readdirbug");
                exit(1);
        }

        numeof = 0;
        for(;;) {
                errno = 0;
                dp = readdir(dir);
                if(dp != 0) {
                        fprintf(stderr, "readdir: found %s\n", dp->d_name);
                        continue;
                }
                if(errno != 0) {
                        perror("readdir");
                        exit(1);
                }
                fprintf(stderr, "readdir: EOF\n");
                if(++numeof == 3)
                        break;
                if(doremove) {
                        fprintf(stderr, "rm /tmp/readdirbug/file1\n");
                        if(remove("/tmp/readdirbug/file1") < 0) {
                                perror("remove");
                                exit(1);
                        }
                }
        }
        fprintf(stderr, "closedir\n");
        closedir(dir);
}

Fixes #8423.

LGTM=bradfitz, r
R=golang-codereviews, bradfitz, dsymonds, dave, r
CC=golang-codereviews, iant
https://golang.org/cl/119530044
---
 src/pkg/syscall/syscall_bsd.go | 35 +++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/pkg/syscall/syscall_bsd.go b/src/pkg/syscall/syscall_bsd.go
index af563910b1..2556fa8746 100644
--- a/src/pkg/syscall/syscall_bsd.go
+++ b/src/pkg/syscall/syscall_bsd.go
@@ -68,7 +68,40 @@ func ReadDirent(fd int, buf []byte) (n int, err error) {
 	// actual system call is getdirentries64, 64 is a good guess.
 	// TODO(rsc): Can we use a single global basep for all calls?
 	var base = (*uintptr)(unsafe.Pointer(new(uint64)))
-	return Getdirentries(fd, buf, base)
+	n, err = Getdirentries(fd, buf, base)
+
+	// On OS X 10.10 Yosemite, if you have a directory that can be returned
+	// in a single getdirentries64 call (for example, a directory with one file),
+	// and you read from the directory at EOF twice, you get EOF both times:
+	//	fd = open("dir")
+	//	getdirentries64(fd) // returns data
+	//	getdirentries64(fd) // returns 0 (EOF)
+	//	getdirentries64(fd) // returns 0 (EOF)
+	//
+	// But if you remove the file in the middle between the two calls, the
+	// second call returns an error instead.
+	//	fd = open("dir")
+	//	getdirentries64(fd) // returns data
+	//	getdirentries64(fd) // returns 0 (EOF)
+	//	remove("dir/file")
+	//	getdirentries64(fd) // returns ENOENT/EINVAL
+	//
+	// Whether you get ENOENT or EINVAL depends on exactly what was
+	// in the directory. It is deterministic, just data-dependent.
+	//
+	// This only happens in small directories. A directory containing more data
+	// than fits in a 4k getdirentries64 call will return EOF correctly.
+	// (It's not clear if the criteria is that the directory be split across multiple
+	// getdirentries64 calls or that it be split across multiple file system blocks.)
+	//
+	// We could change package os to avoid the second read at EOF,
+	// and maybe we should, but that's a bit involved.
+	// For now, treat the EINVAL/ENOENT as EOF.
+	if runtime.GOOS == "darwin" && (err == EINVAL || err == ENOENT) {
+		err = nil
+	}
+
+	return
 }
 
 // Wait status is 7 bits at bottom, either 0 (exited),

From d6d7170de414c16a7ea0125b5a458272557227b6 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 8 Aug 2014 20:13:57 +0400
Subject: [PATCH 045/423] runtime: fix data race in stackalloc Stack shrinking
 happens during mark phase, and it assumes that it owns stackcache in mcache.
 Stack cache flushing also happens during mark phase, and it accesses
 stackcache's w/o any synchronization. This leads to stackcache corruption:
 http://goperfd.appspot.com/log/309af5571dfd7e1817259b9c9cf9bcf9b2c27610

LGTM=khr
R=khr
CC=golang-codereviews, rsc
https://golang.org/cl/126870043
---
 src/pkg/runtime/stack.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 0a806e8fab..772080af55 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -223,9 +223,11 @@ runtime·stackalloc(G *gp, uint32 n)
 			n2 >>= 1;
 		}
 		c = g->m->mcache;
-		if(c == nil) {
-			// This can happen in the guts of exitsyscall or
+		if(c == nil || g->m->gcing || g->m->helpgc) {
+			// c == nil can happen in the guts of exitsyscall or
 			// procresize. Just get a stack from the global pool.
+			// Also don't touch stackcache during gc
+			// as it's flushed concurrently.
 			runtime·lock(&stackpoolmu);
 			x = poolalloc(order);
 			runtime·unlock(&stackpoolmu);
@@ -285,7 +287,7 @@ runtime·stackfree(G *gp, void *v, Stktop *top)
 		}
 		x = (MLink*)v;
 		c = g->m->mcache;
-		if(c == nil) {
+		if(c == nil || g->m->gcing || g->m->helpgc) {
 			runtime·lock(&stackpoolmu);
 			poolfree(x, order);
 			runtime·unlock(&stackpoolmu);

From 28cf62ed8565b481b94326321793614b544dfc17 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 8 Aug 2014 20:15:52 +0400
Subject: [PATCH 046/423] runtime: mark functions as static where possible

Update #8092

LGTM=dvyukov
R=golang-codereviews, minux, dvyukov
CC=golang-codereviews
https://golang.org/cl/122250043
---
 src/pkg/runtime/cpuprof.goc | 2 +-
 src/pkg/runtime/mheap.c     | 2 +-
 src/pkg/runtime/proc.c      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/cpuprof.goc b/src/pkg/runtime/cpuprof.goc
index faaea29435..cd4b210e23 100644
--- a/src/pkg/runtime/cpuprof.goc
+++ b/src/pkg/runtime/cpuprof.goc
@@ -314,7 +314,7 @@ flushlog(Profile *p)
 
 // getprofile blocks until the next block of profiling data is available
 // and returns it as a []byte.  It is called from the writing goroutine.
-Slice
+static Slice
 getprofile(Profile *p)
 {
 	uint32 i, j, n;
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 908d668462..186fd48d47 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -211,7 +211,7 @@ mheap_alloc(MHeap *h, uintptr npage, int32 sizeclass, bool large)
 	return s;
 }
 
-void
+static void
 mheap_alloc_m(G *gp)
 {
 	MHeap *h;
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index cef41d95f2..443bdda100 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1384,7 +1384,7 @@ top:
 // appropriate time. After calling dropg and arranging for gp to be
 // readied later, the caller can do other work but eventually should
 // call schedule to restart the scheduling of goroutines on this m.
-void
+static void
 dropg(void)
 {
 	if(g->m->lockedg == nil) {

From 44106a088077da9e32bf038beff4a42cd8b88a7a Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 8 Aug 2014 20:52:11 +0400
Subject: [PATCH 047/423] runtime: bump MaxGcprocs to 32 There was a number of
 improvements related to GC parallelization: 1. Parallel roots/stacks
 scanning. 2. Parallel stack shrinking. 3. Per-thread workbuf caches. 4.
 Workset reduction. Currently 32 threads work well. go.benchmarks:garbage
 benchmark on 2 x Intel Xeon E5-2690 (16 HT cores)

1 thread/1 processor:
time=16405255
cputime=16386223
gc-pause-one=546793975
gc-pause-total=3280763

2 threads/1 processor:
time=9043497
cputime=18075822
gc-pause-one=331116489
gc-pause-total=2152257

4 threads/1 processor:
time=4882030
cputime=19421337
gc-pause-one=174543105
gc-pause-total=1134530

8 threads/1 processor:
time=4134757
cputime=20097075
gc-pause-one=158680588
gc-pause-total=1015555

16 threads/1 processor + HT:
time=2006706
cputime=31960509
gc-pause-one=75425744
gc-pause-total=460097

16 threads/2 processors:
time=1513373
cputime=23805571
gc-pause-one=56630946
gc-pause-total=345448

32 threads/2 processors + HT:
time=1199312
cputime=37592764
gc-pause-one=48945064
gc-pause-total=278986

LGTM=rlh
R=golang-codereviews, tracey.brendan, rlh
CC=golang-codereviews, khr, rsc
https://golang.org/cl/123920043
---
 src/pkg/runtime/malloc.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 593e9b885b..556d6d4c03 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -141,8 +141,8 @@ enum
 	// Max number of threads to run garbage collection.
 	// 2, 3, and 4 are all plausible maximums depending
 	// on the hardware details of the machine.  The garbage
-	// collector scales well to 8 cpus.
-	MaxGcproc = 8,
+	// collector scales well to 32 cpus.
+	MaxGcproc = 32,
 };
 
 // Maximum memory allocation size, a hint for callers.

From f69f45c5383044c503add49d12659e14c1496491 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 8 Aug 2014 10:43:44 -0700
Subject: [PATCH 048/423] test: add another test case that gccgo crashed on

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/124020044
---
 test/fixedbugs/bug490.go | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 test/fixedbugs/bug490.go

diff --git a/test/fixedbugs/bug490.go b/test/fixedbugs/bug490.go
new file mode 100644
index 0000000000..7d05f3945c
--- /dev/null
+++ b/test/fixedbugs/bug490.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.
+
+// The gccgo compiler used to crash building a comparison between an
+// interface and an empty struct literal.
+
+package p
+ 
+type S struct{}
+
+func F(v interface{}) bool {
+	return v == S{}
+}

From 298c623e8caadf68198ba7bc4e6b128cb87983d7 Mon Sep 17 00:00:00 2001
From: Joel Stemmer <stemmertech@gmail.com>
Date: Fri, 8 Aug 2014 12:42:20 -0700
Subject: [PATCH 049/423] time: Fix missing colon when formatting time zone
 offsets with seconds

When formatting time zone offsets with seconds using the stdISO8601Colon
and stdNumColon layouts, the colon was missing between the hour and minute
parts.

Fixes #8497.

LGTM=r
R=golang-codereviews, iant, gobot, r
CC=golang-codereviews
https://golang.org/cl/126840043
---
 src/pkg/time/format.go      |  2 +-
 src/pkg/time/format_test.go | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/pkg/time/format.go b/src/pkg/time/format.go
index 14b1250cb0..04e79f32dc 100644
--- a/src/pkg/time/format.go
+++ b/src/pkg/time/format.go
@@ -556,7 +556,7 @@ func (t Time) Format(layout string) string {
 				b = append(b, '+')
 			}
 			b = appendUint(b, uint(zone/60), '0')
-			if std == stdISO8601ColonTZ || std == stdNumColonTZ {
+			if std == stdISO8601ColonTZ || std == stdNumColonTZ || std == stdISO8601ColonSecondsTZ || std == stdNumColonSecondsTZ {
 				b = append(b, ':')
 			}
 			b = appendUint(b, uint(zone%60), '0')
diff --git a/src/pkg/time/format_test.go b/src/pkg/time/format_test.go
index 3bc8f42946..a7c6d55b2f 100644
--- a/src/pkg/time/format_test.go
+++ b/src/pkg/time/format_test.go
@@ -502,10 +502,11 @@ func TestParseSecondsInTimeZone(t *testing.T) {
 }
 
 func TestFormatSecondsInTimeZone(t *testing.T) {
-	d := Date(1871, 9, 17, 20, 4, 26, 0, FixedZone("LMT", -(34*60+8)))
-	timestr := d.Format("2006-01-02T15:04:05Z070000")
-	expected := "1871-09-17T20:04:26-003408"
-	if timestr != expected {
-		t.Errorf("Got %s, want %s", timestr, expected)
+	for _, test := range secondsTimeZoneOffsetTests {
+		d := Date(1871, 1, 1, 5, 33, 2, 0, FixedZone("LMT", test.expectedoffset))
+		timestr := d.Format(test.format)
+		if timestr != test.value {
+			t.Errorf("Format = %s, want %s", timestr, test.value)
+		}
 	}
 }

From f0bfd7b03793a0b1018f2fe66e17bdc1e83b6357 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Fri, 8 Aug 2014 12:42:36 -0700
Subject: [PATCH 050/423] A+C: Joel Stemmer (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/127800043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index c97790c7fa..6061e8e4cf 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -213,6 +213,7 @@ Jimmy Zelinskie <jimmyzelinskie@gmail.com>
 Jingcheng Zhang <diogin@gmail.com>
 Joakim Sernbrant <serbaut@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
+Joel Stemmer <stemmertech@gmail.com>
 John Asmuth <jasmuth@gmail.com>
 John C Barstow <jbowtie@amathaine.com>
 John Graham-Cumming <jgc@jgc.org> <jgrahamc@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 30a2b567db..5386691e51 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -301,6 +301,7 @@ Jingcheng Zhang <diogin@gmail.com>
 Joakim Sernbrant <serbaut@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
 Joel Sing <jsing@google.com>
+Joel Stemmer <stemmertech@gmail.com>
 Johan Euphrosine <proppy@google.com>
 John Asmuth <jasmuth@gmail.com>
 John Beisley <huin@google.com>

From 5a17aaa830a5951d2dc24aabb6c267d224a6b697 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Fri, 8 Aug 2014 14:54:04 -0700
Subject: [PATCH 051/423] doc/go1.4.txt: go.sys subrepo created

CC=golang-codereviews
https://golang.org/cl/124050043
---
 doc/go1.4.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index e480d9bcd5..198529434a 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -19,3 +19,5 @@ testing: add Coverage (CL 98150043)
 text/scanner: add IsIdentRune field of Scanner. (CL 108030044)
 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).
+
+go.sys subrepo created: http://golang.org/s/go1.4-syscall

From eae9fee3bf8c58c7403bcd103050ef2196fdfed1 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Aug 2014 13:53:38 -0400
Subject: [PATCH 052/423] cmd/link: fix zig-zag decoding

The >>1 shift needs to happen before converting to int32, otherwise
large values will decode with an incorrect sign bit.

The <<31 shift can happen before or after, but before is consistent
with liblink and the go12symtab doc.

Bug demo at http://play.golang.org/p/jLrhPUakIu

LGTM=rsc
R=golang-codereviews, minux, rsc
CC=golang-codereviews
https://golang.org/cl/119630043
---
 src/cmd/link/pclntab.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/link/pclntab.go b/src/cmd/link/pclntab.go
index b0b19ad53c..a950895aa5 100644
--- a/src/cmd/link/pclntab.go
+++ b/src/cmd/link/pclntab.go
@@ -437,7 +437,7 @@ func (it *PCIter) Next() {
 		return
 	}
 	it.start = false
-	sv := int32(uv)>>1 ^ int32(uv)<<31>>31
+	sv := int32(uv>>1) ^ int32(uv<<31)>>31
 	it.Value += sv
 
 	// pc delta

From 5b63ce4e1929914da33a0a53a0a2868b3fb092d2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 11 Aug 2014 15:24:36 -0400
Subject: [PATCH 053/423] cmd/6g, cmd/8g: fix, test byte-sized magic multiply
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Credit to Rémy for finding and writing test case.

Fixes #8325.

LGTM=r
R=golang-codereviews, r
CC=dave, golang-codereviews, iant, remyoudompheng
https://golang.org/cl/124950043
---
 src/cmd/6g/ggen.c           |  2 +-
 src/cmd/6g/peep.c           |  5 +++++
 src/cmd/8g/ggen.c           |  2 +-
 src/cmd/8g/peep.c           |  5 +++++
 test/fixedbugs/issue8325.go | 31 +++++++++++++++++++++++++++++++
 5 files changed, 43 insertions(+), 2 deletions(-)
 create mode 100644 test/fixedbugs/issue8325.go

diff --git a/src/cmd/6g/ggen.c b/src/cmd/6g/ggen.c
index c385798f2e..9665d831b3 100644
--- a/src/cmd/6g/ggen.c
+++ b/src/cmd/6g/ggen.c
@@ -943,7 +943,7 @@ cgen_hmul(Node *nl, Node *nr, Node *res)
 	if(t->width == 1) {
 		// byte multiply behaves differently.
 		nodreg(&ax, t, D_AH);
-		nodreg(&dx, t, D_DL);
+		nodreg(&dx, t, D_DX);
 		gmove(&ax, &dx);
 	}
 	nodreg(&dx, t, D_DX);
diff --git a/src/cmd/6g/peep.c b/src/cmd/6g/peep.c
index 0f27204434..24617836fe 100644
--- a/src/cmd/6g/peep.c
+++ b/src/cmd/6g/peep.c
@@ -838,6 +838,11 @@ copyu(Prog *p, Adr *v, Adr *s)
 static int
 copyas(Adr *a, Adr *v)
 {
+	if(D_AL <= a->type && a->type <= D_R15B)
+		fatal("use of byte register");
+	if(D_AL <= v->type && v->type <= D_R15B)
+		fatal("use of byte register");
+
 	if(a->type != v->type)
 		return 0;
 	if(regtyp(v))
diff --git a/src/cmd/8g/ggen.c b/src/cmd/8g/ggen.c
index 2285a04e61..5e31404806 100644
--- a/src/cmd/8g/ggen.c
+++ b/src/cmd/8g/ggen.c
@@ -991,7 +991,7 @@ cgen_hmul(Node *nl, Node *nr, Node *res)
 	if(t->width == 1) {
 		// byte multiply behaves differently.
 		nodreg(&ax, t, D_AH);
-		nodreg(&dx, t, D_DL);
+		nodreg(&dx, t, D_DX);
 		gmove(&ax, &dx);
 	}
 	nodreg(&dx, t, D_DX);
diff --git a/src/cmd/8g/peep.c b/src/cmd/8g/peep.c
index d88987f954..35129a7c46 100644
--- a/src/cmd/8g/peep.c
+++ b/src/cmd/8g/peep.c
@@ -636,6 +636,11 @@ copyu(Prog *p, Adr *v, Adr *s)
 static int
 copyas(Adr *a, Adr *v)
 {
+	if(D_AL <= a->type && a->type <= D_R15B)
+		fatal("use of byte register");
+	if(D_AL <= v->type && v->type <= D_R15B)
+		fatal("use of byte register");
+
 	if(a->type != v->type)
 		return 0;
 	if(regtyp(v))
diff --git a/test/fixedbugs/issue8325.go b/test/fixedbugs/issue8325.go
new file mode 100644
index 0000000000..e22fd319db
--- /dev/null
+++ b/test/fixedbugs/issue8325.go
@@ -0,0 +1,31 @@
+// run
+
+// 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 8325: corrupted byte operations during optimization
+// pass.
+
+package main
+
+const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+func main() {
+	var bytes = []byte{10, 20, 30, 40, 50}
+
+	for i, b := range bytes {
+		bytes[i] = alphanum[b%byte(len(alphanum))]
+	}
+
+	for _, b := range bytes {
+		switch {
+		case '0' <= b && b <= '9',
+			'A' <= b && b <= 'Z':
+		default:
+			println("found a bad character", string(b))
+			panic("BUG")
+		}
+
+	}
+}

From 988516ec46ae3ca753bcfcfdf88254f9a9d35ec1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 11 Aug 2014 16:54:34 -0400
Subject: [PATCH 054/423] A+C: Andrew Bursavich (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/124120043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 6061e8e4cf..46e85a24f8 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -35,6 +35,7 @@ Amrut Joshi <amrut.joshi@gmail.com>
 Andrei Vieru <euvieru@gmail.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
+Andrew Bursavich <abursavich@gmail.com>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Lutomirski <andy@luto.us>
 Andrew Pritchard <awpritchard@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 5386691e51..0cd3bcd5a9 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -66,6 +66,7 @@ Andreas Jellinghaus <andreas@ionisiert.de> <anj@google.com>
 Andrei Vieru <euvieru@gmail.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
+Andrew Bursavich <abursavich@gmail.com>
 Andrew Gerrand <adg@golang.org>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Lutomirski <andy@luto.us>

From 2a37efbe1e25d30a4a998fc7ddad6d10c7df74da Mon Sep 17 00:00:00 2001
From: Shenghou Ma <minux@golang.org>
Date: Mon, 11 Aug 2014 16:56:36 -0400
Subject: [PATCH 055/423] misc/nacl/testzip.proto: add fewer files to the zip

LGTM=bradfitz, rsc
R=rsc, iant, bradfitz
CC=golang-codereviews
https://golang.org/cl/126940043
---
 misc/nacl/testzip.proto | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/misc/nacl/testzip.proto b/misc/nacl/testzip.proto
index 596f50303c..29581dcfb3 100644
--- a/misc/nacl/testzip.proto
+++ b/misc/nacl/testzip.proto
@@ -11,7 +11,8 @@ go	src=..
 	src
 		cmd
 			internal
-				+
+				objfile
+					objfile.go
 			gofmt
 				testdata
 					+

From 4769f87e0d39cbcce5309ff79c82465629798d15 Mon Sep 17 00:00:00 2001
From: Shenghou Ma <minux@golang.org>
Date: Mon, 11 Aug 2014 17:10:23 -0400
Subject: [PATCH 056/423] runtime: no need to set R9 to m for runtime.sigpanic
 anymore

Replaces CL 123980043 which I created on the dev.power64 branch.

LGTM=rsc
R=rsc, iant
CC=golang-codereviews
https://golang.org/cl/123120043
---
 src/pkg/runtime/signal_arm.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/pkg/runtime/signal_arm.c b/src/pkg/runtime/signal_arm.c
index 1f9a2325d1..3571cf3ac6 100644
--- a/src/pkg/runtime/signal_arm.c
+++ b/src/pkg/runtime/signal_arm.c
@@ -76,7 +76,6 @@ runtime·sighandler(int32 sig, Siginfo *info, void *ctxt, G *gp)
 			SIG_LR(info, ctxt) = gp->sigpc;
 		// In case we are panicking from external C code
 		SIG_R10(info, ctxt) = (uintptr)gp;
-		SIG_R9(info, ctxt) = (uintptr)g->m;
 		SIG_PC(info, ctxt) = (uintptr)runtime·sigpanic;
 		return;
 	}

From b5674a2b728d174bbd30be8e655b003528056d9f Mon Sep 17 00:00:00 2001
From: Shenghou Ma <minux@golang.org>
Date: Mon, 11 Aug 2014 17:11:31 -0400
Subject: [PATCH 057/423] cmd/8g: fix build

Fixes #8510.

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/129720043
---
 src/cmd/8g/peep.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/8g/peep.c b/src/cmd/8g/peep.c
index 35129a7c46..91a91d20db 100644
--- a/src/cmd/8g/peep.c
+++ b/src/cmd/8g/peep.c
@@ -636,9 +636,9 @@ copyu(Prog *p, Adr *v, Adr *s)
 static int
 copyas(Adr *a, Adr *v)
 {
-	if(D_AL <= a->type && a->type <= D_R15B)
+	if(D_AL <= a->type && a->type <= D_BL)
 		fatal("use of byte register");
-	if(D_AL <= v->type && v->type <= D_R15B)
+	if(D_AL <= v->type && v->type <= D_BL)
 		fatal("use of byte register");
 
 	if(a->type != v->type)

From 897f7a31fa040584f2c76d7901b9ef3257ca218f Mon Sep 17 00:00:00 2001
From: Chris Manghane <cmang@golang.org>
Date: Mon, 11 Aug 2014 16:11:55 -0700
Subject: [PATCH 058/423] cmd/gc: comma-ok assignments produce untyped bool as
 2nd result

LGTM=rsc
R=gri, rsc
CC=golang-codereviews
https://golang.org/cl/127950043
---
 src/cmd/gc/order.c          |  5 ++++-
 src/cmd/gc/typecheck.c      |  2 +-
 src/cmd/gc/walk.c           | 14 +++++++++++++-
 test/fixedbugs/issue8475.go | 25 +++++++++++++++++++++++++
 test/named1.go              |  8 ++++----
 5 files changed, 47 insertions(+), 7 deletions(-)
 create mode 100644 test/fixedbugs/issue8475.go

diff --git a/src/cmd/gc/order.c b/src/cmd/gc/order.c
index 728defe7c3..59231a0f1c 100644
--- a/src/cmd/gc/order.c
+++ b/src/cmd/gc/order.c
@@ -593,7 +593,10 @@ orderstmt(Node *n, Order *order)
 		orderexpr(&n->rlist->n->left, order);  // arg to recv
 		ch = n->rlist->n->left->type;
 		tmp1 = ordertemp(ch->type, order, haspointers(ch->type));
-		tmp2 = ordertemp(types[TBOOL], order, 0);
+		if(!isblank(n->list->next->n))
+			tmp2 = ordertemp(n->list->next->n->type, order, 0);
+		else
+			tmp2 = ordertemp(types[TBOOL], order, 0);
 		order->out = list(order->out, n);
 		r = nod(OAS, n->list->n, tmp1);
 		typecheck(&r, Etop);
diff --git a/src/cmd/gc/typecheck.c b/src/cmd/gc/typecheck.c
index 92e9ad5215..c295cf6d21 100644
--- a/src/cmd/gc/typecheck.c
+++ b/src/cmd/gc/typecheck.c
@@ -2965,7 +2965,7 @@ typecheckas2(Node *n)
 			if(l->defn == n)
 				l->type = r->type;
 			l = n->list->next->n;
-			if(l->type != T)
+			if(l->type != T && l->type->etype != TBOOL)
 				checkassignto(types[TBOOL], l);
 			if(l->defn == n && l->ntype == N)
 				l->type = types[TBOOL];
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index e50b917709..7ae75e5617 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -673,7 +673,7 @@ walkexpr(Node **np, NodeList **init)
 			n1 = nod(OADDR, n->list->n, N);
 		n1->etype = 1; // addr does not escape
 		fn = chanfn("chanrecv2", 2, r->left->type);
-		r = mkcall1(fn, types[TBOOL], init, typename(r->left->type), r->left, n1);
+		r = mkcall1(fn, n->list->next->n->type, init, typename(r->left->type), r->left, n1);
 		n = nod(OAS, n->list->next->n, r);
 		typecheck(&n, Etop);
 		goto ret;
@@ -723,6 +723,12 @@ walkexpr(Node **np, NodeList **init)
 		var->typecheck = 1;
 		fn = mapfn(p, t);
 		r = mkcall1(fn, getoutargx(fn->type), init, typename(t), r->left, key);
+
+		// mapaccess2* returns a typed bool, but due to spec changes,
+		// the boolean result of i.(T) is now untyped so we make it the
+		// same type as the variable on the lhs.
+		if(!isblank(n->list->next->n))
+			r->type->type->down->type = n->list->next->n->type;
 		n->rlist = list1(r);
 		n->op = OAS2FUNC;
 		n->list->n = var;
@@ -770,6 +776,12 @@ walkexpr(Node **np, NodeList **init)
 			*p = '\0';
 			
 			fn = syslook(buf, 1);
+
+			// runtime.assert(E|I)2TOK returns a typed bool, but due
+			// to spec changes, the boolean result of i.(T) is now untyped
+			// so we make it the same type as the variable on the lhs.
+			if(!isblank(n->list->next->n))
+				fn->type->type->down->type->type = n->list->next->n->type;
 			ll = list1(typename(r->type));
 			ll = list(ll, r->left);
 			argtype(fn, r->left->type);
diff --git a/test/fixedbugs/issue8475.go b/test/fixedbugs/issue8475.go
new file mode 100644
index 0000000000..e69794534c
--- /dev/null
+++ b/test/fixedbugs/issue8475.go
@@ -0,0 +1,25 @@
+// build
+
+// 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 8745: comma-ok assignments should produce untyped bool as 2nd result.
+
+package main
+
+type mybool bool
+
+func main() {
+	var ok mybool
+	_ = ok
+
+	var i interface{}
+	_, ok = i.(int)
+
+	var m map[int]int
+	_, ok = m[0]
+
+	var c chan int
+	_, ok = <-c
+}
diff --git a/test/named1.go b/test/named1.go
index 62b874c5cb..febad64ece 100644
--- a/test/named1.go
+++ b/test/named1.go
@@ -41,21 +41,21 @@ func main() {
 	asBool(1 != 2) // ok now
 	asBool(i < j)  // ok now
 
-	_, b = m[2] // ERROR "cannot .* bool.*type Bool"
+	_, b = m[2] // ok now
 
 	var inter interface{}
-	_, b = inter.(Map) // ERROR "cannot .* bool.*type Bool"
+	_, b = inter.(Map) // ok now
 	_ = b
 
 	var minter interface {
 		M()
 	}
-	_, b = minter.(Map) // ERROR "cannot .* bool.*type Bool"
+	_, b = minter.(Map) // ok now
 	_ = b
 
 	_, bb := <-c
 	asBool(bb) // ERROR "cannot use.*type bool.*as type Bool"
-	_, b = <-c // ERROR "cannot .* bool.*type Bool"
+	_, b = <-c // ok now
 	_ = b
 
 	asString(String(slice)) // ok

From f46f3432a60edafdcd6ec9925550859167812cd6 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Tue, 12 Aug 2014 09:27:39 +1000
Subject: [PATCH 059/423] compress/{gzip,zlib}: mention that Close flushes

Our other CloseFlushers (archive/tar, compress/flate) do mention this.

The original change was accidentally submitted to the release branch:
        https://golang.org/cl/117430043/

TBR=rsc
R=r, rsc
CC=golang-codereviews
https://golang.org/cl/124130043
---
 src/pkg/compress/gzip/gzip.go   | 3 ++-
 src/pkg/compress/zlib/writer.go | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/pkg/compress/gzip/gzip.go b/src/pkg/compress/gzip/gzip.go
index 3a0bf54e1b..5131d128e4 100644
--- a/src/pkg/compress/gzip/gzip.go
+++ b/src/pkg/compress/gzip/gzip.go
@@ -245,7 +245,8 @@ func (z *Writer) Flush() error {
 	return z.err
 }
 
-// Close closes the Writer. It does not close the underlying io.Writer.
+// Close closes the Writer, flushing any unwritten data to the underlying
+// io.Writer, but does not close the underlying io.Writer.
 func (z *Writer) Close() error {
 	if z.err != nil {
 		return z.err
diff --git a/src/pkg/compress/zlib/writer.go b/src/pkg/compress/zlib/writer.go
index fac7e15a7e..3b4313a8be 100644
--- a/src/pkg/compress/zlib/writer.go
+++ b/src/pkg/compress/zlib/writer.go
@@ -174,7 +174,8 @@ func (z *Writer) Flush() error {
 	return z.err
 }
 
-// Calling Close does not close the wrapped io.Writer originally passed to NewWriter.
+// Close closes the Writer, flushing any unwritten data to the underlying
+// io.Writer, but does not close the underlying io.Writer.
 func (z *Writer) Close() error {
 	if !z.wroteHeader {
 		z.err = z.writeHeader()

From fce63888cecd22dfc01bf1b6dcb5a1429aecbc17 Mon Sep 17 00:00:00 2001
From: Andres Erbsen <andreser@google.com>
Date: Mon, 11 Aug 2014 16:40:42 -0700
Subject: [PATCH 060/423] crypto/tls: implement tls-unique channel binding (RFC
 5929 section 3). Tested against GnuTLS and Python.

LGTM=agl
R=golang-codereviews, agl, ashankar
CC=agl, golang-codereviews
https://golang.org/cl/117100043
---
 src/pkg/crypto/tls/common.go           |  8 +++++
 src/pkg/crypto/tls/conn.go             |  6 ++++
 src/pkg/crypto/tls/handshake_client.go | 14 ++++----
 src/pkg/crypto/tls/handshake_server.go | 14 ++++----
 src/pkg/crypto/tls/tls_test.go         | 45 ++++++++++++++++++++++++++
 5 files changed, 75 insertions(+), 12 deletions(-)

diff --git a/src/pkg/crypto/tls/common.go b/src/pkg/crypto/tls/common.go
index 2b59136e65..f926d57728 100644
--- a/src/pkg/crypto/tls/common.go
+++ b/src/pkg/crypto/tls/common.go
@@ -165,6 +165,14 @@ type ConnectionState struct {
 	ServerName                 string                // server name requested by client, if any (server side only)
 	PeerCertificates           []*x509.Certificate   // certificate chain presented by remote peer
 	VerifiedChains             [][]*x509.Certificate // verified chains built from PeerCertificates
+
+	// TLSUnique contains the "tls-unique" channel binding value (see RFC
+	// 5929, section 3). For resumed sessions this value will be nil
+	// because resumption does not include enough context (see
+	// https://secure-resumption.com/#channelbindings). This will change in
+	// future versions of Go once the TLS master-secret fix has been
+	// standardized and implemented.
+	TLSUnique []byte
 }
 
 // ClientAuthType declares the policy the server will follow for
diff --git a/src/pkg/crypto/tls/conn.go b/src/pkg/crypto/tls/conn.go
index 8f7d2c144f..ba8e4c22b7 100644
--- a/src/pkg/crypto/tls/conn.go
+++ b/src/pkg/crypto/tls/conn.go
@@ -42,6 +42,9 @@ type Conn struct {
 	verifiedChains [][]*x509.Certificate
 	// serverName contains the server name indicated by the client, if any.
 	serverName string
+	// firstFinished contains the first Finished hash sent during the
+	// handshake. This is the "tls-unique" channel binding value.
+	firstFinished [12]byte
 
 	clientProtocol         string
 	clientProtocolFallback bool
@@ -994,6 +997,9 @@ func (c *Conn) ConnectionState() ConnectionState {
 		state.PeerCertificates = c.peerCertificates
 		state.VerifiedChains = c.verifiedChains
 		state.ServerName = c.serverName
+		if !c.didResume {
+			state.TLSUnique = c.firstFinished[:]
+		}
 	}
 
 	return state
diff --git a/src/pkg/crypto/tls/handshake_client.go b/src/pkg/crypto/tls/handshake_client.go
index 694a9a217f..3d9ef9b14e 100644
--- a/src/pkg/crypto/tls/handshake_client.go
+++ b/src/pkg/crypto/tls/handshake_client.go
@@ -187,10 +187,10 @@ NextCipherSuite:
 		if err := hs.readSessionTicket(); err != nil {
 			return err
 		}
-		if err := hs.readFinished(); err != nil {
+		if err := hs.readFinished(c.firstFinished[:]); err != nil {
 			return err
 		}
-		if err := hs.sendFinished(); err != nil {
+		if err := hs.sendFinished(nil); err != nil {
 			return err
 		}
 	} else {
@@ -200,13 +200,13 @@ NextCipherSuite:
 		if err := hs.establishKeys(); err != nil {
 			return err
 		}
-		if err := hs.sendFinished(); err != nil {
+		if err := hs.sendFinished(c.firstFinished[:]); err != nil {
 			return err
 		}
 		if err := hs.readSessionTicket(); err != nil {
 			return err
 		}
-		if err := hs.readFinished(); err != nil {
+		if err := hs.readFinished(nil); err != nil {
 			return err
 		}
 	}
@@ -530,7 +530,7 @@ func (hs *clientHandshakeState) processServerHello() (bool, error) {
 	return false, nil
 }
 
-func (hs *clientHandshakeState) readFinished() error {
+func (hs *clientHandshakeState) readFinished(out []byte) error {
 	c := hs.c
 
 	c.readRecord(recordTypeChangeCipherSpec)
@@ -555,6 +555,7 @@ func (hs *clientHandshakeState) readFinished() error {
 		return errors.New("tls: server's Finished message was incorrect")
 	}
 	hs.finishedHash.Write(serverFinished.marshal())
+	copy(out, verify)
 	return nil
 }
 
@@ -586,7 +587,7 @@ func (hs *clientHandshakeState) readSessionTicket() error {
 	return nil
 }
 
-func (hs *clientHandshakeState) sendFinished() error {
+func (hs *clientHandshakeState) sendFinished(out []byte) error {
 	c := hs.c
 
 	c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
@@ -605,6 +606,7 @@ func (hs *clientHandshakeState) sendFinished() error {
 	finished.verifyData = hs.finishedHash.clientSum(hs.masterSecret)
 	hs.finishedHash.Write(finished.marshal())
 	c.writeRecord(recordTypeHandshake, finished.marshal())
+	copy(out, finished.verifyData)
 	return nil
 }
 
diff --git a/src/pkg/crypto/tls/handshake_server.go b/src/pkg/crypto/tls/handshake_server.go
index 39eeb363cd..684ab288f0 100644
--- a/src/pkg/crypto/tls/handshake_server.go
+++ b/src/pkg/crypto/tls/handshake_server.go
@@ -57,10 +57,10 @@ func (c *Conn) serverHandshake() error {
 		if err := hs.establishKeys(); err != nil {
 			return err
 		}
-		if err := hs.sendFinished(); err != nil {
+		if err := hs.sendFinished(c.firstFinished[:]); err != nil {
 			return err
 		}
-		if err := hs.readFinished(); err != nil {
+		if err := hs.readFinished(nil); err != nil {
 			return err
 		}
 		c.didResume = true
@@ -73,13 +73,13 @@ func (c *Conn) serverHandshake() error {
 		if err := hs.establishKeys(); err != nil {
 			return err
 		}
-		if err := hs.readFinished(); err != nil {
+		if err := hs.readFinished(c.firstFinished[:]); err != nil {
 			return err
 		}
 		if err := hs.sendSessionTicket(); err != nil {
 			return err
 		}
-		if err := hs.sendFinished(); err != nil {
+		if err := hs.sendFinished(nil); err != nil {
 			return err
 		}
 	}
@@ -483,7 +483,7 @@ func (hs *serverHandshakeState) establishKeys() error {
 	return nil
 }
 
-func (hs *serverHandshakeState) readFinished() error {
+func (hs *serverHandshakeState) readFinished(out []byte) error {
 	c := hs.c
 
 	c.readRecord(recordTypeChangeCipherSpec)
@@ -523,6 +523,7 @@ func (hs *serverHandshakeState) readFinished() error {
 	}
 
 	hs.finishedHash.Write(clientFinished.marshal())
+	copy(out, verify)
 	return nil
 }
 
@@ -552,7 +553,7 @@ func (hs *serverHandshakeState) sendSessionTicket() error {
 	return nil
 }
 
-func (hs *serverHandshakeState) sendFinished() error {
+func (hs *serverHandshakeState) sendFinished(out []byte) error {
 	c := hs.c
 
 	c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
@@ -563,6 +564,7 @@ func (hs *serverHandshakeState) sendFinished() error {
 	c.writeRecord(recordTypeHandshake, finished.marshal())
 
 	c.cipherSuite = hs.suite.id
+	copy(out, finished.verifyData)
 
 	return nil
 }
diff --git a/src/pkg/crypto/tls/tls_test.go b/src/pkg/crypto/tls/tls_test.go
index f8c94ff35d..e82579eee9 100644
--- a/src/pkg/crypto/tls/tls_test.go
+++ b/src/pkg/crypto/tls/tls_test.go
@@ -5,6 +5,7 @@
 package tls
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"net"
@@ -235,3 +236,47 @@ func testConnReadNonzeroAndEOF(t *testing.T, delay time.Duration) error {
 	}
 	return nil
 }
+
+func TestTLSUniqueMatches(t *testing.T) {
+	ln := newLocalListener(t)
+	defer ln.Close()
+
+	serverTLSUniques := make(chan []byte)
+	go func() {
+		for i := 0; i < 2; i++ {
+			sconn, err := ln.Accept()
+			if err != nil {
+				t.Fatal(err)
+			}
+			serverConfig := *testConfig
+			srv := Server(sconn, &serverConfig)
+			if err := srv.Handshake(); err != nil {
+				t.Fatal(err)
+			}
+			serverTLSUniques <- srv.ConnectionState().TLSUnique
+		}
+	}()
+
+	clientConfig := *testConfig
+	clientConfig.ClientSessionCache = NewLRUClientSessionCache(1)
+	conn, err := Dial("tcp", ln.Addr().String(), &clientConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(conn.ConnectionState().TLSUnique, <-serverTLSUniques) {
+		t.Error("client and server channel bindings differ")
+	}
+	conn.Close()
+
+	conn, err = Dial("tcp", ln.Addr().String(), &clientConfig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	if !conn.ConnectionState().DidResume {
+		t.Error("second session did not use resumption")
+	}
+	if !bytes.Equal(conn.ConnectionState().TLSUnique, <-serverTLSUniques) {
+		t.Error("client and server channel bindings differ when session resumption is used")
+	}
+}

From 03e6a88ef04abd5916cd54d5255e7f6d6c78789f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Aug 2014 16:49:13 -0700
Subject: [PATCH 061/423] cmd/cgo: iterate over names in deterministic order

This makes GCC behavior (and cgo build failures) deterministic.

Fixes #8487.

Ran this shell command on linux/amd64 (Ubuntu 12.04) before and
after this change:

    for x in `seq 100`; do
      go tool cgo -debug-gcc=true issue8441.go 2>&1 | md5sum
    done | sort | uniq -c

Before:
    67 2cdcb8c7c4e290f7d9009abc581b83dd  -
    10 9a55390df94f7cec6d810f3e20590789  -
    10 acfad22140d43d9b9517bbc5dfc3c0df  -
    13 c337f8fee2304b3a8e3158a4362d8698  -

After:
    100 785c316cbcbcd50896695050e2fa23c1  -

LGTM=minux, iant
R=golang-codereviews, bradfitz, minux, iant
CC=golang-codereviews
https://golang.org/cl/126990043
---
 src/cmd/cgo/gcc.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 841c848332..aa28060ea7 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -229,7 +229,8 @@ func (p *Package) guessKinds(f *File) []*Name {
 	// Determine kinds for names we already know about,
 	// like #defines or 'struct foo', before bothering with gcc.
 	var names, needType []*Name
-	for _, n := range f.Name {
+	for _, key := range nameKeys(f.Name) {
+		n := f.Name[key]
 		// If we've already found this name as a #define
 		// and we can translate it as a constant value, do so.
 		if n.Define != "" {

From 31a996edb6303fdcd0e6c1816174b0b24a10b1f6 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Mon, 11 Aug 2014 22:10:17 -0700
Subject: [PATCH 062/423] cmd/cgo: fix default alignment for empty structs

Fixes #5242.

LGTM=iant
R=iant
CC=golang-codereviews
https://golang.org/cl/125120043
---
 misc/cgo/test/cgo_test.go  |  1 +
 misc/cgo/test/issue5242.go | 31 +++++++++++++++++++++++++++++++
 src/cmd/cgo/gcc.go         |  3 +++
 3 files changed, 35 insertions(+)
 create mode 100644 misc/cgo/test/issue5242.go

diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go
index eb237725a4..3c6d5cb59e 100644
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -53,5 +53,6 @@ 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 BenchmarkCgoCall(b *testing.B) { benchCgoCall(b) }
diff --git a/misc/cgo/test/issue5242.go b/misc/cgo/test/issue5242.go
new file mode 100644
index 0000000000..fe0a6321c1
--- /dev/null
+++ b/misc/cgo/test/issue5242.go
@@ -0,0 +1,31 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Issue 5242.  Cgo incorrectly computed the alignment of structs
+// with no Go accessible fields as 0, and then panicked on
+// modulo-by-zero computations.
+
+package cgotest
+
+/*
+typedef struct {
+} foo;
+
+typedef struct {
+	int x : 1;
+} bar;
+
+int issue5242(foo f, bar b) {
+	return 5242;
+}
+*/
+import "C"
+
+import "testing"
+
+func test5242(t *testing.T) {
+	if got := C.issue5242(C.foo{}, C.bar{}); got != 5242 {
+		t.Errorf("got %v", got)
+	}
+}
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index aa28060ea7..b79725ab01 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -1534,6 +1534,9 @@ func (c *typeConv) pad(fld []*ast.Field, size int64) []*ast.Field {
 
 // Struct conversion: return Go and (6g) C syntax for type.
 func (c *typeConv) Struct(dt *dwarf.StructType, pos token.Pos) (expr *ast.StructType, csyntax string, align int64) {
+	// Minimum alignment for a struct is 1 byte.
+	align = 1
+
 	var buf bytes.Buffer
 	buf.WriteString("struct {")
 	fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field

From 444b928405444dcba8c0c008f44e8d21b9402547 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Aug 2014 07:13:52 -0700
Subject: [PATCH 063/423] run.bash: run misc/cgo/testgodefs/test.bash

misc/cgo/testgodefs was added by revision d1cf884a594f, but not
add to run.bash.

LGTM=iant
R=iant
CC=golang-codereviews
https://golang.org/cl/129760044
---
 src/run.bash | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/run.bash b/src/run.bash
index d13161e9de..b5f061d885 100755
--- a/src/run.bash
+++ b/src/run.bash
@@ -162,7 +162,7 @@ android-arm | dragonfly-386 | dragonfly-amd64 | freebsd-386 | freebsd-amd64 | fr
 esac
 ) || exit $?
 
-# This tests cgo -godefs. That mode is not supported,
+# This tests cgo -cdefs. That mode is not supported,
 # so it's okay if it doesn't work on some systems.
 # In particular, it works badly with clang on OS X.
 [ "$CGO_ENABLED" != 1 ] || [ "$GOOS" == darwin ] ||
@@ -170,6 +170,11 @@ esac
 ./test.bash || exit 1
 ) || exit $?
 
+[ "$CGO_ENABLED" != 1 ] || [ "$GOOS" == darwin ] ||
+(xcd ../misc/cgo/testgodefs
+./test.bash || exit 1
+) || exit $?
+
 [ "$CGO_ENABLED" != 1 ] ||
 [ "$GOHOSTOS" == windows ] ||
 (xcd ../misc/cgo/testso

From 881fbf9a7dad13555286400697892072383a63c9 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Tue, 12 Aug 2014 07:48:34 -0700
Subject: [PATCH 064/423] A+C: Thiago Fransosi Farina (individual CLA)

Generated by a+c.

LGTM=bradfitz
R=bradfitz
CC=golang-codereviews
https://golang.org/cl/125960043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 46e85a24f8..9aa3419715 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -401,6 +401,7 @@ Taj Khattra <taj.khattra@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
 Taru Karttunen <taruti@taruti.net>
 Tetsuo Kiso <tetsuokiso9@gmail.com>
+Thiago Fransosi Farina <thiago.farina@gmail.com>
 Thomas Alan Copeland <talan.copeland@gmail.com>
 Thomas Kappler <tkappler@gmail.com>
 Timo Savola <timo.savola@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 0cd3bcd5a9..2dbf02d4af 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -550,6 +550,7 @@ Taj Khattra <taj.khattra@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
 Taru Karttunen <taruti@taruti.net>
 Tetsuo Kiso <tetsuokiso9@gmail.com>
+Thiago Fransosi Farina <thiago.farina@gmail.com> <tfarina@chromium.org>
 Thomas Alan Copeland <talan.copeland@gmail.com>
 Thomas Habets <habets@google.com>
 Thomas Kappler <tkappler@gmail.com>

From e4d4787581f0e00af743ae2eb41daf0e28003d23 Mon Sep 17 00:00:00 2001
From: Thiago Fransosi Farina <thiago.farina@gmail.com>
Date: Tue, 12 Aug 2014 07:49:10 -0700
Subject: [PATCH 065/423] dist: Make vaddn private to buf.c

This function does not have a declaration/prototype in a.h, and it is used only
in buf.c, so it is local to it and thus can be marked as private by adding
'static' to it.

LGTM=iant
R=rsc, iant
CC=golang-codereviews
https://golang.org/cl/122300043
---
 src/cmd/dist/buf.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/dist/buf.c b/src/cmd/dist/buf.c
index 45fb1954d3..2ddc6be752 100644
--- a/src/cmd/dist/buf.c
+++ b/src/cmd/dist/buf.c
@@ -202,7 +202,7 @@ vadd(Vec *v, char *p)
 }
 
 // vaddn adds a string consisting of the n bytes at p to the vector.
-void
+static void
 vaddn(Vec *v, char *p, int n)
 {
 	char *q;

From 11016f62d83435c352261fe250ae36660c50c17f Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 12 Aug 2014 12:55:12 -0700
Subject: [PATCH 066/423] cmd/cgo: make C function pointers non-assignable

Fixes #7757.
Fixes #8488.

LGTM=iant
R=iant
CC=golang-codereviews
https://golang.org/cl/118690044
---
 misc/cgo/errors/issue7757.go | 14 ++++++++++++++
 misc/cgo/errors/test.bash    |  1 +
 src/cmd/cgo/gcc.go           |  8 +++++++-
 src/cmd/cgo/out.go           |  2 +-
 4 files changed, 23 insertions(+), 2 deletions(-)
 create mode 100644 misc/cgo/errors/issue7757.go

diff --git a/misc/cgo/errors/issue7757.go b/misc/cgo/errors/issue7757.go
new file mode 100644
index 0000000000..5eafd22e8a
--- /dev/null
+++ b/misc/cgo/errors/issue7757.go
@@ -0,0 +1,14 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+/*
+void foo() {}
+*/
+import "C"
+
+func main() {
+	C.foo = C.foo // ERROR HERE
+}
diff --git a/misc/cgo/errors/test.bash b/misc/cgo/errors/test.bash
index f0f60c8445..e5bf47a0dd 100755
--- a/misc/cgo/errors/test.bash
+++ b/misc/cgo/errors/test.bash
@@ -27,6 +27,7 @@ check() {
 check err1.go
 check err2.go
 check err3.go
+check issue7757.go
 
 rm -rf errs _obj
 exit 0
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index b79725ab01..26def654d0 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -650,7 +650,13 @@ func (p *Package) rewriteRef(f *File) {
 					f.Name[fpName] = name
 				}
 				r.Name = name
-				expr = ast.NewIdent(name.Mangle)
+				// Rewrite into call to _Cgo_ptr to prevent assignments.  The _Cgo_ptr
+				// function is defined in out.go and simply returns its argument. See
+				// issue 7757.
+				expr = &ast.CallExpr{
+					Fun:  &ast.Ident{NamePos: (*r.Expr).Pos(), Name: "_Cgo_ptr"},
+					Args: []ast.Expr{ast.NewIdent(name.Mangle)},
+				}
 			} else if r.Name.Kind == "type" {
 				// Okay - might be new(T)
 				expr = r.Name.Type.Go
diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 1ef78b757c..6322e0604a 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -64,7 +64,7 @@ func (p *Package) writeDefs() {
 	if !*gccgo && *importRuntimeCgo {
 		fmt.Fprintf(fgo2, "import _ \"runtime/cgo\"\n\n")
 	}
-	fmt.Fprintf(fgo2, "type _ unsafe.Pointer\n\n")
+	fmt.Fprintf(fgo2, "func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }\n\n")
 	if *importSyscall {
 		fmt.Fprintf(fgo2, "func _Cerrno(dst *error, x int32) { *dst = syscall.Errno(x) }\n")
 	}

From fe7b29f5fd5be75484ce7ea89c2b63d96f9baa14 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Wed, 13 Aug 2014 01:02:01 +0400
Subject: [PATCH 067/423] runtime/pprof: fix data race It's unclear why we do
 this broken double-checked locking. The mutex is not held for the whole
 duration of CPU profiling. Fixes #8365.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/116290043
---
 src/pkg/runtime/pprof/pprof.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/pkg/runtime/pprof/pprof.go b/src/pkg/runtime/pprof/pprof.go
index 26aa0b8be5..236de54f38 100644
--- a/src/pkg/runtime/pprof/pprof.go
+++ b/src/pkg/runtime/pprof/pprof.go
@@ -574,12 +574,6 @@ func StartCPUProfile(w io.Writer) error {
 	// each client to specify the frequency, we hard code it.
 	const hz = 100
 
-	// Avoid queueing behind StopCPUProfile.
-	// Could use TryLock instead if we had it.
-	if cpu.profiling {
-		return fmt.Errorf("cpu profiling already in use")
-	}
-
 	cpu.Lock()
 	defer cpu.Unlock()
 	if cpu.done == nil {

From 1837419f302da9b36055bf12b6a7f92c420cb32b Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Wed, 13 Aug 2014 01:03:32 +0400
Subject: [PATCH 068/423] runtime: remove FlagNoProfile Turns out to be unused
 as well.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews, khr
https://golang.org/cl/127170044
---
 src/pkg/runtime/malloc.go | 19 ++++++++-----------
 src/pkg/runtime/malloc.h  |  3 +--
 2 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 73dc9f20d6..71c0a4ecd7 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -11,9 +11,8 @@ import (
 const (
 	debugMalloc = false
 
-	flagNoScan      = 1 << 0 // GC doesn't have to scan object
-	flagNoProfiling = 1 << 1 // must not profile
-	flagNoZero      = 1 << 2 // don't zero memory
+	flagNoScan = 1 << 0 // GC doesn't have to scan object
+	flagNoZero = 1 << 1 // don't zero memory
 
 	kindArray      = 17
 	kindFunc       = 19
@@ -300,14 +299,12 @@ marked:
 	if debug.allocfreetrace != 0 {
 		tracealloc(x, size, typ)
 	}
-	if flags&flagNoProfiling == 0 {
-		rate := MemProfileRate
-		if rate > 0 {
-			if size < uintptr(rate) && int32(size) < c.next_sample {
-				c.next_sample -= int32(size)
-			} else {
-				profilealloc(mp, x, size)
-			}
+
+	if rate := MemProfileRate; rate > 0 {
+		if size < uintptr(rate) && int32(size) < c.next_sample {
+			c.next_sample -= int32(size)
+		} else {
+			profilealloc(mp, x, size)
 		}
 	}
 
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 556d6d4c03..4612dddb16 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -534,8 +534,7 @@ enum
 {
 	// flags to malloc
 	FlagNoScan	= 1<<0,	// GC doesn't have to scan object
-	FlagNoProfiling	= 1<<1,	// must not profile
-	FlagNoZero	= 1<<2, // don't zero memory
+	FlagNoZero	= 1<<1, // don't zero memory
 };
 
 void	runtime·MProf_Malloc(void*, uintptr);

From 67e1d40031d66bc2b67f422a17af0fea7e60effd Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Tue, 12 Aug 2014 14:35:27 -0700
Subject: [PATCH 069/423] crypto/rand: use getrandom system call on Linux

Adds internal/syscall package.

Fixes #8520

LGTM=r, agl
R=agl, rsc, r
CC=golang-codereviews, iant
https://golang.org/cl/123260044
---
 src/pkg/crypto/rand/rand_linux.go           | 39 +++++++++++++++
 src/pkg/crypto/rand/rand_unix.go            | 11 ++++-
 src/pkg/go/build/deps_test.go               |  2 +-
 src/pkg/internal/syscall/getrandom_linux.go | 55 +++++++++++++++++++++
 4 files changed, 105 insertions(+), 2 deletions(-)
 create mode 100644 src/pkg/crypto/rand/rand_linux.go
 create mode 100644 src/pkg/internal/syscall/getrandom_linux.go

diff --git a/src/pkg/crypto/rand/rand_linux.go b/src/pkg/crypto/rand/rand_linux.go
new file mode 100644
index 0000000000..8cb59c75df
--- /dev/null
+++ b/src/pkg/crypto/rand/rand_linux.go
@@ -0,0 +1,39 @@
+// 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 rand
+
+import (
+	"internal/syscall"
+	"sync"
+)
+
+func init() {
+	altGetRandom = getRandomLinux
+}
+
+var (
+	once       sync.Once
+	useSyscall bool
+)
+
+func pickStrategy() {
+	// Test whether we should use the system call or /dev/urandom.
+	// We'll fall back to urandom if:
+	// - the kernel is too old (before 3.17)
+	// - the machine has no entropy available (early boot + no hardware
+	//   entropy source?) and we want to avoid blocking later.
+	var buf [1]byte
+	n, err := syscall.GetRandom(buf[:], syscall.GRND_NONBLOCK)
+	useSyscall = n == 1 && err == nil
+}
+
+func getRandomLinux(p []byte) (ok bool) {
+	once.Do(pickStrategy)
+	if !useSyscall {
+		return false
+	}
+	n, err := syscall.GetRandom(p, 0)
+	return n == len(p) && err == nil
+}
diff --git a/src/pkg/crypto/rand/rand_unix.go b/src/pkg/crypto/rand/rand_unix.go
index 1e741fda19..62d0fbdb35 100644
--- a/src/pkg/crypto/rand/rand_unix.go
+++ b/src/pkg/crypto/rand/rand_unix.go
@@ -20,6 +20,8 @@ import (
 	"time"
 )
 
+const urandomDevice = "/dev/urandom"
+
 // Easy implementation: read from /dev/urandom.
 // This is sufficient on Linux, OS X, and FreeBSD.
 
@@ -27,7 +29,7 @@ func init() {
 	if runtime.GOOS == "plan9" {
 		Reader = newReader(nil)
 	} else {
-		Reader = &devReader{name: "/dev/urandom"}
+		Reader = &devReader{name: urandomDevice}
 	}
 }
 
@@ -38,7 +40,14 @@ type devReader struct {
 	mu   sync.Mutex
 }
 
+// altGetRandom if non-nil specifies an OS-specific function to get
+// urandom-style randomness.
+var altGetRandom func([]byte) (ok bool)
+
 func (r *devReader) Read(b []byte) (n int, err error) {
+	if altGetRandom != nil && r.name == urandomDevice && altGetRandom(b) {
+		return len(b), nil
+	}
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.f == nil {
diff --git a/src/pkg/go/build/deps_test.go b/src/pkg/go/build/deps_test.go
index 99b985b51d..2a7173ba4c 100644
--- a/src/pkg/go/build/deps_test.go
+++ b/src/pkg/go/build/deps_test.go
@@ -279,7 +279,7 @@ var pkgDeps = map[string][]string{
 	// Random byte, number generation.
 	// This would be part of core crypto except that it imports
 	// math/big, which imports fmt.
-	"crypto/rand": {"L4", "CRYPTO", "OS", "math/big", "syscall"},
+	"crypto/rand": {"L4", "CRYPTO", "OS", "math/big", "syscall", "internal/syscall"},
 
 	// Mathematical crypto: dependencies on fmt (L4) and math/big.
 	// We could avoid some of the fmt, but math/big imports fmt anyway.
diff --git a/src/pkg/internal/syscall/getrandom_linux.go b/src/pkg/internal/syscall/getrandom_linux.go
new file mode 100644
index 0000000000..1c586ec9b7
--- /dev/null
+++ b/src/pkg/internal/syscall/getrandom_linux.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 syscall
+
+import (
+	"runtime"
+	"sync/atomic"
+	stdsyscall "syscall"
+	"unsafe"
+)
+
+var randomTrap = map[string]uintptr{
+	"amd64": 318,
+	"386":   355,
+}[runtime.GOARCH]
+
+var randomUnsupported int32 // atomic
+
+// GetRandomFlag is a flag supported by the getrandom system call.
+type GetRandomFlag uintptr
+
+const (
+	// GRND_NONBLOCK means return EAGAIN rather than blocking.
+	GRND_NONBLOCK GetRandomFlag = 0x0001
+
+	// GRND_RANDOM means use the /dev/random pool instead of /dev/urandom.
+	GRND_RANDOM GetRandomFlag = 0x0002
+)
+
+// GetRandom calls the Linux getrandom system call.
+// See https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=c6e9d6f38894798696f23c8084ca7edbf16ee895
+func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
+	if randomTrap == 0 {
+		return 0, stdsyscall.ENOSYS
+	}
+	if len(p) == 0 {
+		return 0, nil
+	}
+	if atomic.LoadInt32(&randomUnsupported) != 0 {
+		return 0, stdsyscall.ENOSYS
+	}
+	r1, _, errno := stdsyscall.Syscall(randomTrap,
+		uintptr(unsafe.Pointer(&p[0])),
+		uintptr(len(p)),
+		uintptr(flags))
+	if errno != 0 {
+		if errno == stdsyscall.ENOSYS {
+			atomic.StoreInt32(&randomUnsupported, 1)
+		}
+		return 0, errno
+	}
+	return int(r1), nil
+}

From f497885c6343808b47811981ae42c2e816005163 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Wed, 13 Aug 2014 07:39:52 +1000
Subject: [PATCH 070/423] doc: document go1.3.1

LGTM=r
R=r, rsc
CC=golang-codereviews
https://golang.org/cl/126060043
---
 doc/devel/release.html | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/devel/release.html b/doc/devel/release.html
index 0824463f4c..c1d364c723 100644
--- a/doc/devel/release.html
+++ b/doc/devel/release.html
@@ -20,6 +20,13 @@ Go 1.3 is a major release of Go.
 Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
 </p>
 
+<h3 id="go1.3.minor">Minor revisions</h3>
+
+<p>
+go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=40272ab1339ab2fb9e7160483e5e5d42d6b7e810">change history</a> for details.
+</p>
+
 <h2 id="go1.2">go1.2 (released 2013/12/01)</h2>
 
 <p>

From 0c6146711c184b711c9d2d664056380e149fa714 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 12 Aug 2014 17:41:03 -0400
Subject: [PATCH 071/423] cmd/go, go/build: implement import comment checking

See golang.org/s/go14customimport for design.

Added case to deps_test to allow go/build to import regexp.
Not a new dependency, because go/build already imports go/doc
which imports regexp.

Fixes #7453.

LGTM=r
R=r, josharian
CC=golang-codereviews
https://golang.org/cl/124940043
---
 src/cmd/go/pkg.go                             |   5 +-
 src/cmd/go/test.bash                          |  36 ++++
 src/cmd/go/testdata/importcom/bad.go          |   3 +
 src/cmd/go/testdata/importcom/conflict.go     |   3 +
 src/cmd/go/testdata/importcom/src/bad/bad.go  |   1 +
 .../go/testdata/importcom/src/conflict/a.go   |   1 +
 .../go/testdata/importcom/src/conflict/b.go   |   1 +
 .../go/testdata/importcom/src/works/x/x.go    |   1 +
 .../go/testdata/importcom/src/works/x/x1.go   |   1 +
 .../go/testdata/importcom/src/wrongplace/x.go |   1 +
 src/cmd/go/testdata/importcom/works.go        |   3 +
 src/cmd/go/testdata/importcom/wrongplace.go   |   3 +
 src/pkg/go/build/build.go                     | 161 ++++++++++++++++--
 13 files changed, 206 insertions(+), 14 deletions(-)
 create mode 100644 src/cmd/go/testdata/importcom/bad.go
 create mode 100644 src/cmd/go/testdata/importcom/conflict.go
 create mode 100644 src/cmd/go/testdata/importcom/src/bad/bad.go
 create mode 100644 src/cmd/go/testdata/importcom/src/conflict/a.go
 create mode 100644 src/cmd/go/testdata/importcom/src/conflict/b.go
 create mode 100644 src/cmd/go/testdata/importcom/src/works/x/x.go
 create mode 100644 src/cmd/go/testdata/importcom/src/works/x/x1.go
 create mode 100644 src/cmd/go/testdata/importcom/src/wrongplace/x.go
 create mode 100644 src/cmd/go/testdata/importcom/works.go
 create mode 100644 src/cmd/go/testdata/importcom/wrongplace.go

diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index be691a6bc9..eb8c451783 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -261,11 +261,14 @@ func loadImport(path string, srcDir string, stk *importStack, importPos []token.
 	//
 	// TODO: After Go 1, decide when to pass build.AllowBinary here.
 	// See issue 3268 for mistakes to avoid.
-	bp, err := buildContext.Import(path, srcDir, 0)
+	bp, err := buildContext.Import(path, srcDir, build.ImportComment)
 	bp.ImportPath = importPath
 	if gobin != "" {
 		bp.BinDir = gobin
 	}
+	if err == nil && !isLocal && bp.ImportComment != "" && bp.ImportComment != path {
+		err = fmt.Errorf("directory %s contains package %q", bp.Dir, bp.ImportComment)
+	}
 	p.load(stk, bp, err)
 	if p.Error != nil && len(importPos) > 0 {
 		pos := importPos[0]
diff --git a/src/cmd/go/test.bash b/src/cmd/go/test.bash
index 411ef1863f..93a7c67c18 100755
--- a/src/cmd/go/test.bash
+++ b/src/cmd/go/test.bash
@@ -121,6 +121,42 @@ if ! ./testgo build -v ./testdata/testinternal2; then
 	ok=false
 fi
 
+export GOPATH=$(pwd)/testdata/importcom
+TEST 'import comment - match'
+if ! ./testgo build ./testdata/importcom/works.go; then
+	echo 'go build ./testdata/importcom/works.go failed'
+	ok=false
+fi
+TEST 'import comment - mismatch'
+if ./testgo build ./testdata/importcom/wrongplace.go 2>testdata/err; then
+	echo 'go build ./testdata/importcom/wrongplace.go suceeded'
+	ok=false
+elif ! grep 'wrongplace contains package "my/x"' testdata/err >/dev/null; then
+	echo 'go build did not mention incorrect import:'
+	cat testdata/err
+	ok=false
+fi
+TEST 'import comment - syntax error'
+if ./testgo build ./testdata/importcom/bad.go 2>testdata/err; then
+	echo 'go build ./testdata/importcom/bad.go suceeded'
+	ok=false
+elif ! grep 'cannot parse import comment' testdata/err >/dev/null; then
+	echo 'go build did not mention syntax error:'
+	cat testdata/err
+	ok=false
+fi
+TEST 'import comment - conflict'
+if ./testgo build ./testdata/importcom/conflict.go 2>testdata/err; then
+	echo 'go build ./testdata/importcom/conflict.go suceeded'
+	ok=false
+elif ! grep 'found import comments' testdata/err >/dev/null; then
+	echo 'go build did not mention comment conflict:'
+	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
diff --git a/src/cmd/go/testdata/importcom/bad.go b/src/cmd/go/testdata/importcom/bad.go
new file mode 100644
index 0000000000..e104c2e992
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/bad.go
@@ -0,0 +1,3 @@
+package p
+
+import "bad"
diff --git a/src/cmd/go/testdata/importcom/conflict.go b/src/cmd/go/testdata/importcom/conflict.go
new file mode 100644
index 0000000000..995556c511
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/conflict.go
@@ -0,0 +1,3 @@
+package p
+
+import "conflict"
diff --git a/src/cmd/go/testdata/importcom/src/bad/bad.go b/src/cmd/go/testdata/importcom/src/bad/bad.go
new file mode 100644
index 0000000000..bc51fd3fde
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/src/bad/bad.go
@@ -0,0 +1 @@
+package bad // import
diff --git a/src/cmd/go/testdata/importcom/src/conflict/a.go b/src/cmd/go/testdata/importcom/src/conflict/a.go
new file mode 100644
index 0000000000..2d67703511
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/src/conflict/a.go
@@ -0,0 +1 @@
+package conflict // import "a"
diff --git a/src/cmd/go/testdata/importcom/src/conflict/b.go b/src/cmd/go/testdata/importcom/src/conflict/b.go
new file mode 100644
index 0000000000..8fcfb3c8bd
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/src/conflict/b.go
@@ -0,0 +1 @@
+package conflict /* import "b" */
diff --git a/src/cmd/go/testdata/importcom/src/works/x/x.go b/src/cmd/go/testdata/importcom/src/works/x/x.go
new file mode 100644
index 0000000000..044c6eca80
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/src/works/x/x.go
@@ -0,0 +1 @@
+package x // import "works/x"
diff --git a/src/cmd/go/testdata/importcom/src/works/x/x1.go b/src/cmd/go/testdata/importcom/src/works/x/x1.go
new file mode 100644
index 0000000000..2449b29df5
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/src/works/x/x1.go
@@ -0,0 +1 @@
+package x // important! not an import comment
diff --git a/src/cmd/go/testdata/importcom/src/wrongplace/x.go b/src/cmd/go/testdata/importcom/src/wrongplace/x.go
new file mode 100644
index 0000000000..b89849da78
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/src/wrongplace/x.go
@@ -0,0 +1 @@
+package x // import "my/x"
diff --git a/src/cmd/go/testdata/importcom/works.go b/src/cmd/go/testdata/importcom/works.go
new file mode 100644
index 0000000000..31b55d08a3
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/works.go
@@ -0,0 +1,3 @@
+package p
+
+import _ "works/x"
diff --git a/src/cmd/go/testdata/importcom/wrongplace.go b/src/cmd/go/testdata/importcom/wrongplace.go
new file mode 100644
index 0000000000..e2535e01ae
--- /dev/null
+++ b/src/cmd/go/testdata/importcom/wrongplace.go
@@ -0,0 +1,3 @@
+package p
+
+import "wrongplace"
diff --git a/src/pkg/go/build/build.go b/src/pkg/go/build/build.go
index 6db0275032..1a133041e8 100644
--- a/src/pkg/go/build/build.go
+++ b/src/pkg/go/build/build.go
@@ -23,6 +23,7 @@ import (
 	"strconv"
 	"strings"
 	"unicode"
+	"unicode/utf8"
 )
 
 // A Context specifies the supporting context for a build.
@@ -337,22 +338,29 @@ const (
 	// If AllowBinary is set, Import can be satisfied by a compiled
 	// package object without corresponding sources.
 	AllowBinary
+
+	// If ImportComment is set, parse import comments on package statements.
+	// Import returns an error if it finds a comment it cannot understand
+	// or finds conflicting comments in multiple source files.
+	// See golang.org/s/go14customimport for more information.
+	ImportComment
 )
 
 // A Package describes the Go package found in a directory.
 type Package struct {
-	Dir         string   // directory containing package sources
-	Name        string   // package name
-	Doc         string   // documentation synopsis
-	ImportPath  string   // import path of package ("" if unknown)
-	Root        string   // root of Go tree where this package lives
-	SrcRoot     string   // package source root directory ("" if unknown)
-	PkgRoot     string   // package install root directory ("" if unknown)
-	BinDir      string   // command install directory ("" if unknown)
-	Goroot      bool     // package found in Go root
-	PkgObj      string   // installed .a file
-	AllTags     []string // tags that can influence file selection in this directory
-	ConflictDir string   // this directory shadows Dir in $GOPATH
+	Dir           string   // directory containing package sources
+	Name          string   // package name
+	ImportComment string   // path in import comment on package statement
+	Doc           string   // documentation synopsis
+	ImportPath    string   // import path of package ("" if unknown)
+	Root          string   // root of Go tree where this package lives
+	SrcRoot       string   // package source root directory ("" if unknown)
+	PkgRoot       string   // package install root directory ("" if unknown)
+	BinDir        string   // command install directory ("" if unknown)
+	Goroot        bool     // package found in Go root
+	PkgObj        string   // installed .a file
+	AllTags       []string // tags that can influence file selection in this directory
+	ConflictDir   string   // this directory shadows Dir in $GOPATH
 
 	// Source files
 	GoFiles        []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
@@ -597,7 +605,7 @@ Found:
 	}
 
 	var Sfiles []string // files with ".S" (capital S)
-	var firstFile string
+	var firstFile, firstCommentFile string
 	imported := make(map[string][]token.Position)
 	testImported := make(map[string][]token.Position)
 	xTestImported := make(map[string][]token.Position)
@@ -684,6 +692,22 @@ Found:
 			p.Doc = doc.Synopsis(pf.Doc.Text())
 		}
 
+		if mode&ImportComment != 0 {
+			qcom, line := findImportComment(data)
+			if line != 0 {
+				com, err := strconv.Unquote(qcom)
+				if err != nil {
+					return p, fmt.Errorf("%s:%d: cannot parse import comment", filename, line)
+				}
+				if p.ImportComment == "" {
+					p.ImportComment = com
+					firstCommentFile = name
+				} else if p.ImportComment != com {
+					return p, fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir)
+				}
+			}
+		}
+
 		// Record imports and information about cgo.
 		isCgo := false
 		for _, decl := range pf.Decls {
@@ -764,6 +788,117 @@ Found:
 	return p, pkgerr
 }
 
+func findImportComment(data []byte) (s string, line int) {
+	// expect keyword package
+	word, data := parseWord(data)
+	if string(word) != "package" {
+		return "", 0
+	}
+
+	// expect package name
+	_, data = parseWord(data)
+
+	// now ready for import comment, a // or /* */ comment
+	// beginning and ending on the current line.
+	for len(data) > 0 && (data[0] == ' ' || data[0] == '\t' || data[0] == '\r') {
+		data = data[1:]
+	}
+
+	var comment []byte
+	switch {
+	case bytes.HasPrefix(data, slashSlash):
+		i := bytes.Index(data, newline)
+		if i < 0 {
+			i = len(data)
+		}
+		comment = data[2:i]
+	case bytes.HasPrefix(data, slashStar):
+		data = data[2:]
+		i := bytes.Index(data, starSlash)
+		if i < 0 {
+			// malformed comment
+			return "", 0
+		}
+		comment = data[:i]
+		if bytes.Contains(comment, newline) {
+			return "", 0
+		}
+	}
+	comment = bytes.TrimSpace(comment)
+
+	// split comment into `import`, `"pkg"`
+	word, arg := parseWord(comment)
+	if string(word) != "import" {
+		return "", 0
+	}
+
+	line = 1 + bytes.Count(data[:cap(data)-cap(arg)], newline)
+	return strings.TrimSpace(string(arg)), line
+}
+
+var (
+	slashSlash = []byte("//")
+	slashStar  = []byte("/*")
+	starSlash  = []byte("*/")
+	newline    = []byte("\n")
+)
+
+// skipSpaceOrComment returns data with any leading spaces or comments removed.
+func skipSpaceOrComment(data []byte) []byte {
+	for len(data) > 0 {
+		switch data[0] {
+		case ' ', '\t', '\r', '\n':
+			data = data[1:]
+			continue
+		case '/':
+			if bytes.HasPrefix(data, slashSlash) {
+				i := bytes.Index(data, newline)
+				if i < 0 {
+					return nil
+				}
+				data = data[i+1:]
+				continue
+			}
+			if bytes.HasPrefix(data, slashStar) {
+				data = data[2:]
+				i := bytes.Index(data, starSlash)
+				if i < 0 {
+					return nil
+				}
+				data = data[i+2:]
+				continue
+			}
+		}
+		break
+	}
+	return data
+}
+
+// parseWord skips any leading spaces or comments in data
+// and then parses the beginning of data as an identifier or keyword,
+// returning that word and what remains after the word.
+func parseWord(data []byte) (word, rest []byte) {
+	data = skipSpaceOrComment(data)
+
+	// Parse past leading word characters.
+	rest = data
+	for {
+		r, size := utf8.DecodeRune(rest)
+		if unicode.IsLetter(r) || '0' <= r && r <= '9' || r == '_' {
+			rest = rest[size:]
+			continue
+		}
+		break
+	}
+
+	word = data[:len(data)-len(rest)]
+	if len(word) == 0 {
+		return nil, nil
+	}
+
+	return word, rest
+}
+
 // MatchFile reports whether the file with the given name in the given directory
 // matches the context and would be included in a Package created by ImportDir
 // of that directory.

From 9abf0b6e9f7d1ae1a5f6e500ee58122d4b40f776 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 12 Aug 2014 17:41:16 -0400
Subject: [PATCH 072/423] cmd/ld: handle large link base addresses

codeblk and datblk were truncating their
arguments to int32. Don't do that.

LGTM=dvyukov, rminnich
R=iant, dvyukov, rminnich
CC=golang-codereviews
https://golang.org/cl/126050043
---
 src/cmd/ld/data.c | 12 ++++++------
 src/cmd/ld/lib.h  |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/cmd/ld/data.c b/src/cmd/ld/data.c
index 96eadd479a..c0dc3d05f2 100644
--- a/src/cmd/ld/data.c
+++ b/src/cmd/ld/data.c
@@ -425,10 +425,10 @@ dynreloc(void)
 }
 
 static void
-blk(LSym *start, int32 addr, int32 size)
+blk(LSym *start, int64 addr, int64 size)
 {
 	LSym *sym;
-	int32 eaddr;
+	int64 eaddr;
 	uchar *p, *ep;
 
 	for(sym = start; sym != nil; sym = sym->next)
@@ -467,10 +467,10 @@ blk(LSym *start, int32 addr, int32 size)
 }
 
 void
-codeblk(int32 addr, int32 size)
+codeblk(int64 addr, int64 size)
 {
 	LSym *sym;
-	int32 eaddr, n;
+	int64 eaddr, n;
 	uchar *q;
 
 	if(debug['a'])
@@ -527,10 +527,10 @@ codeblk(int32 addr, int32 size)
 }
 
 void
-datblk(int32 addr, int32 size)
+datblk(int64 addr, int64 size)
 {
 	LSym *sym;
-	int32 i, eaddr;
+	int64 i, eaddr;
 	uchar *p, *ep;
 	char *typ, *rsname;
 	Reloc *r;
diff --git a/src/cmd/ld/lib.h b/src/cmd/ld/lib.h
index 4094dfa6b1..dd23990234 100644
--- a/src/cmd/ld/lib.h
+++ b/src/cmd/ld/lib.h
@@ -184,11 +184,11 @@ uint32	be32(uchar *b);
 uint64	be64(uchar *b);
 void	callgraph(void);
 void	cflush(void);
-void	codeblk(int32 addr, int32 size);
+void	codeblk(int64 addr, int64 size);
 vlong	cpos(void);
 void	cseek(vlong p);
 void	cwrite(void *buf, int n);
-void	datblk(int32 addr, int32 size);
+void	datblk(int64 addr, int64 size);
 int	datcmp(LSym *s1, LSym *s2);
 vlong	datoff(vlong addr);
 void	deadcode(void);

From 160b2461b66c13f1014243f06a401bb1477b46dc Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Tue, 12 Aug 2014 15:28:45 -0700
Subject: [PATCH 073/423] syscall: freeze the package Add a clause to the doc
 comment for the package and a paragraph in the compatibility document
 explaining the situation.

LGTM=bradfitz, adg, rsc
R=golang-codereviews, adg, bradfitz, minux, rsc
CC=golang-codereviews
https://golang.org/cl/129820043
---
 doc/go1compat.html         | 14 ++++++++++++++
 src/pkg/syscall/syscall.go |  7 +++++++
 2 files changed, 21 insertions(+)

diff --git a/doc/go1compat.html b/doc/go1compat.html
index d10b9af294..2c8d214840 100644
--- a/doc/go1compat.html
+++ b/doc/go1compat.html
@@ -152,6 +152,20 @@ will be tagged as appropriate to identify versions that are compatible
 with the Go 1 point releases.
 </p>
 
+<h2 id="operating_systems">Operating systems</h2>
+
+<p>
+It is impossible to guarantee long-term compatibility with operating
+system interfaces, which are changed by outside parties.
+The <a href="/pkg/syscall/"><code>syscall</code></a> package
+is therefore outside the purview of the guarantees made here.
+As of Go version 1.4, the <code>syscall</code> package is frozen.
+Any evolution of the system call interface must be supported elsewhere,
+such as in the <code>go.sys</code> subrepository.
+For details and background, see
+<a href="https://golang.org/s/go1.4-syscall">this document</a>.
+</p>
+
 <h2 id="tools">Tools</h2>
 
 <p>
diff --git a/src/pkg/syscall/syscall.go b/src/pkg/syscall/syscall.go
index f7473fd5aa..3fd95798f3 100644
--- a/src/pkg/syscall/syscall.go
+++ b/src/pkg/syscall/syscall.go
@@ -17,6 +17,13 @@
 // These calls return err == nil to indicate success; otherwise
 // err is an operating system error describing the failure.
 // On most systems, that error has type syscall.Errno.
+//
+// NOTE: This package is locked down. Code outside the standard
+// Go repository should be migrated to use the corresponding
+// package in the go.sys subrepository. That is also where updates
+// required by new systems or versions should be applied.
+// See https://golang.org/s/go1.4-syscall for more information.
+//
 package syscall
 
 // StringByteSlice is deprecated. Use ByteSliceFromString instead.

From b049dc3074704856305bf12f421144b04d6844f9 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Tue, 12 Aug 2014 15:45:35 -0700
Subject: [PATCH 074/423] doc/compat1.html: link to go.sys You talked me into
 it. This and other links should be updated once the new import paths for the
 subrepos are established.

LGTM=minux
R=golang-codereviews, minux
CC=golang-codereviews
https://golang.org/cl/124260043
---
 doc/go1compat.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1compat.html b/doc/go1compat.html
index 2c8d214840..8ceaf32f97 100644
--- a/doc/go1compat.html
+++ b/doc/go1compat.html
@@ -161,7 +161,8 @@ The <a href="/pkg/syscall/"><code>syscall</code></a> package
 is therefore outside the purview of the guarantees made here.
 As of Go version 1.4, the <code>syscall</code> package is frozen.
 Any evolution of the system call interface must be supported elsewhere,
-such as in the <code>go.sys</code> subrepository.
+such as in the
+<a href="http://godoc.org/code.google.com/p/go.sys">go.sys</a> subrepository.
 For details and background, see
 <a href="https://golang.org/s/go1.4-syscall">this document</a>.
 </p>

From 9aa1e9afda4921fa1bb37e2733b4b84b5c468d48 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 12 Aug 2014 19:51:20 -0400
Subject: [PATCH 075/423] runtime: avoid using address as constant in amd64
 assembly

This allows changing the addressing mode for constant
global addresses to use pc-relative addressing.

LGTM=rminnich, iant
R=golang-codereviews, rminnich, iant
CC=golang-codereviews
https://golang.org/cl/129830043
---
 src/pkg/runtime/asm_amd64.s | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 0fd21d1795..d94df0bf8d 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -92,7 +92,8 @@ ok:
 	CALL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
-	PUSHQ	$runtime·main·f(SB)		// entry
+	MOVQ	$runtime·main·f(SB), BP		// entry
+	PUSHQ	BP
 	PUSHQ	$0			// arg size
 	ARGSIZE(16)
 	CALL	runtime·newproc(SB)
@@ -209,7 +210,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-8
 
 	// save our state in g->sched.  Pretend to
 	// be switchtoM if the G stack is scanned.
-	MOVQ	$runtime·switchtoM(SB), (g_sched+gobuf_pc)(AX)
+	MOVQ	$runtime·switchtoM(SB), BP
+	MOVQ	BP, (g_sched+gobuf_pc)(AX)
 	MOVQ	SP, (g_sched+gobuf_sp)(AX)
 	MOVQ	AX, (g_sched+gobuf_g)(AX)
 
@@ -302,7 +304,8 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
 	
 	// Save our own state as the PC and SP to restore
 	// if this goroutine needs to be restarted.
-	MOVQ	$runtime·newstackcall(SB), (g_sched+gobuf_pc)(AX)
+	MOVQ	$runtime·newstackcall(SB), BP
+	MOVQ	BP, (g_sched+gobuf_pc)(AX)
 	MOVQ	SP, (g_sched+gobuf_sp)(AX)
 
 	// Set up morestack arguments to call f on a new stack.
@@ -1002,7 +1005,8 @@ aessmall:
 	// a page boundary, so we can load it directly.
 	MOVOU	(AX), X1
 	ADDQ	CX, CX
-	PAND	masks<>(SB)(CX*8), X1
+	MOVQ	$masks<>(SB), BP
+	PAND	(BP)(CX*8), X1
 	JMP	partial
 highpartial:
 	// address ends in 1111xxxx.  Might be up against
@@ -1010,7 +1014,8 @@ highpartial:
 	// Then shift bytes down using pshufb.
 	MOVOU	-16(AX)(CX*1), X1
 	ADDQ	CX, CX
-	PSHUFB	shifts<>(SB)(CX*8), X1
+	MOVQ	$shifts<>(SB), BP
+	PSHUFB	(BP)(CX*8), X1
 partial:
 	// incorporate partial block into hash
 	AESENC	X3, X0

From 3763a395b227baba3a82d07c33c0a0ffd233f86f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 12 Aug 2014 19:52:04 -0400
Subject: [PATCH 076/423] cmd/go: adjust import comment error

Fixes #7453.

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/127210043
---
 src/cmd/go/pkg.go    | 2 +-
 src/cmd/go/test.bash | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index eb8c451783..1af33f037a 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -267,7 +267,7 @@ func loadImport(path string, srcDir string, stk *importStack, importPos []token.
 		bp.BinDir = gobin
 	}
 	if err == nil && !isLocal && bp.ImportComment != "" && bp.ImportComment != path {
-		err = fmt.Errorf("directory %s contains package %q", bp.Dir, bp.ImportComment)
+		err = fmt.Errorf("code in directory %s expects import %q", bp.Dir, bp.ImportComment)
 	}
 	p.load(stk, bp, err)
 	if p.Error != nil && len(importPos) > 0 {
diff --git a/src/cmd/go/test.bash b/src/cmd/go/test.bash
index 93a7c67c18..2bb929fb03 100755
--- a/src/cmd/go/test.bash
+++ b/src/cmd/go/test.bash
@@ -131,7 +131,7 @@ TEST 'import comment - mismatch'
 if ./testgo build ./testdata/importcom/wrongplace.go 2>testdata/err; then
 	echo 'go build ./testdata/importcom/wrongplace.go suceeded'
 	ok=false
-elif ! grep 'wrongplace contains package "my/x"' testdata/err >/dev/null; then
+elif ! grep 'wrongplace expects import "my/x"' testdata/err >/dev/null; then
 	echo 'go build did not mention incorrect import:'
 	cat testdata/err
 	ok=false

From ce35994d4e8411a24833e4db3ddbfc6962eea467 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 12 Aug 2014 19:53:11 -0400
Subject: [PATCH 077/423] cmd/6c, cmd/6g: avoid address-as-constant in amd64
 instructions

This allows implementing address-of-global
as a pc-relative address instead of as a
32-bit integer constant.

LGTM=rminnich, iant
R=golang-codereviews, rminnich, iant
CC=golang-codereviews
https://golang.org/cl/128070045
---
 src/cmd/6c/sgen.c  | 5 +----
 src/cmd/6g/cgen.c  | 7 +------
 src/cmd/6g/gsubr.c | 5 +----
 3 files changed, 3 insertions(+), 14 deletions(-)

diff --git a/src/cmd/6c/sgen.c b/src/cmd/6c/sgen.c
index ba1c1f652d..c048e784d4 100644
--- a/src/cmd/6c/sgen.c
+++ b/src/cmd/6c/sgen.c
@@ -124,10 +124,7 @@ xcom(Node *n)
 		break;
 
 	case ONAME:
-		if(flag_largemodel)
-			n->addable = 9;
-		else
-			n->addable = 10;
+		n->addable = 9;
 		if(n->class == CPARAM || n->class == CAUTO)
 			n->addable = 11;
 		break;
diff --git a/src/cmd/6g/cgen.c b/src/cmd/6g/cgen.c
index 4dd505b086..bff2350621 100644
--- a/src/cmd/6g/cgen.c
+++ b/src/cmd/6g/cgen.c
@@ -752,12 +752,7 @@ agenr(Node *n, Node *a, Node *res)
 			regalloc(&n3, types[tptr], res);
 			p1 = gins(ALEAQ, N, &n3);
 			datastring(nl->val.u.sval->s, nl->val.u.sval->len, &p1->from);
-			if(flag_largemodel) {
-				gins(AADDQ, &n2, &n3);
-			} else {
-				p1->from.scale = 1;
-				p1->from.index = n2.val.u.reg;
-			}
+			gins(AADDQ, &n2, &n3);
 			goto indexdone;
 		}
 
diff --git a/src/cmd/6g/gsubr.c b/src/cmd/6g/gsubr.c
index f3464b7e1c..4ac2e92079 100644
--- a/src/cmd/6g/gsubr.c
+++ b/src/cmd/6g/gsubr.c
@@ -598,11 +598,8 @@ ismem(Node *n)
 	case ONAME:
 	case OPARAM:
 	case OCLOSUREVAR:
-		return 1;
 	case OADDR:
-		if(flag_largemodel)
-			return 1;
-		break;
+		return 1;
 	}
 	return 0;
 }

From 8bca148a3e81631126b8d74e18c6cdb203313217 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Tue, 12 Aug 2014 17:04:45 -0700
Subject: [PATCH 078/423] all: copy cmd/ld/textflag.h into pkg/GOOS_GOARCH The
 file is used by assembly code to define symbols like NOSPLIT. Having it
 hidden inside the cmd directory makes it hard to access outside the standard
 repository. Solution: As with a couple of other files used by cgo, copy the
 file into the pkg directory and add a -I argument to the assembler to access
 it. Thus one can write just         #include "textflag.h" in .s files.

The names in runtime are not updated because in the boot sequence the
file has not been copied yet when runtime is built. All other .s files
in the repository are updated.

Changes to doc/asm.html, src/cmd/dist/build.c, and src/cmd/go/build.go
are hand-made. The rest are just the renaming done by a global
substitution. (Yay sam).

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/128050043
---
 doc/asm.html                              | 2 +-
 src/cmd/dist/build.c                      | 5 ++++-
 src/cmd/go/build.go                       | 4 +++-
 src/cmd/link/testdata/autosection.s       | 2 +-
 src/cmd/link/testdata/layout.s            | 2 +-
 src/pkg/crypto/aes/asm_amd64.s            | 2 +-
 src/pkg/crypto/md5/md5block_386.s         | 2 +-
 src/pkg/crypto/md5/md5block_amd64.s       | 2 +-
 src/pkg/crypto/md5/md5block_amd64p32.s    | 2 +-
 src/pkg/crypto/md5/md5block_arm.s         | 2 +-
 src/pkg/crypto/rc4/rc4_386.s              | 2 +-
 src/pkg/crypto/rc4/rc4_amd64.s            | 2 +-
 src/pkg/crypto/rc4/rc4_amd64p32.s         | 2 +-
 src/pkg/crypto/rc4/rc4_arm.s              | 2 +-
 src/pkg/crypto/sha1/sha1block_386.s       | 2 +-
 src/pkg/crypto/sha1/sha1block_amd64.s     | 2 +-
 src/pkg/crypto/sha1/sha1block_amd64p32.s  | 2 +-
 src/pkg/crypto/sha1/sha1block_arm.s       | 2 +-
 src/pkg/crypto/sha256/sha256block_amd64.s | 2 +-
 src/pkg/crypto/sha512/sha512block_amd64.s | 2 +-
 src/pkg/hash/crc32/crc32_amd64.s          | 2 +-
 src/pkg/hash/crc32/crc32_amd64p32.s       | 2 +-
 src/pkg/math/abs_386.s                    | 2 +-
 src/pkg/math/abs_amd64.s                  | 2 +-
 src/pkg/math/abs_arm.s                    | 2 +-
 src/pkg/math/asin_386.s                   | 2 +-
 src/pkg/math/asin_amd64.s                 | 2 +-
 src/pkg/math/asin_arm.s                   | 2 +-
 src/pkg/math/atan2_386.s                  | 2 +-
 src/pkg/math/atan2_amd64.s                | 2 +-
 src/pkg/math/atan2_arm.s                  | 2 +-
 src/pkg/math/atan_386.s                   | 2 +-
 src/pkg/math/atan_amd64.s                 | 2 +-
 src/pkg/math/atan_arm.s                   | 2 +-
 src/pkg/math/big/arith_386.s              | 2 +-
 src/pkg/math/big/arith_amd64.s            | 2 +-
 src/pkg/math/big/arith_amd64p32.s         | 2 +-
 src/pkg/math/big/arith_arm.s              | 2 +-
 src/pkg/math/dim_386.s                    | 2 +-
 src/pkg/math/dim_amd64.s                  | 2 +-
 src/pkg/math/dim_arm.s                    | 2 +-
 src/pkg/math/exp2_386.s                   | 2 +-
 src/pkg/math/exp2_amd64.s                 | 2 +-
 src/pkg/math/exp2_arm.s                   | 2 +-
 src/pkg/math/exp_386.s                    | 2 +-
 src/pkg/math/exp_amd64.s                  | 2 +-
 src/pkg/math/exp_arm.s                    | 2 +-
 src/pkg/math/expm1_386.s                  | 2 +-
 src/pkg/math/expm1_amd64.s                | 2 +-
 src/pkg/math/expm1_arm.s                  | 2 +-
 src/pkg/math/floor_386.s                  | 2 +-
 src/pkg/math/floor_amd64.s                | 2 +-
 src/pkg/math/floor_arm.s                  | 2 +-
 src/pkg/math/frexp_386.s                  | 2 +-
 src/pkg/math/frexp_amd64.s                | 2 +-
 src/pkg/math/frexp_arm.s                  | 2 +-
 src/pkg/math/hypot_386.s                  | 2 +-
 src/pkg/math/hypot_amd64.s                | 2 +-
 src/pkg/math/hypot_arm.s                  | 2 +-
 src/pkg/math/ldexp_386.s                  | 2 +-
 src/pkg/math/ldexp_amd64.s                | 2 +-
 src/pkg/math/ldexp_arm.s                  | 2 +-
 src/pkg/math/log10_386.s                  | 2 +-
 src/pkg/math/log10_amd64.s                | 2 +-
 src/pkg/math/log10_arm.s                  | 2 +-
 src/pkg/math/log1p_386.s                  | 2 +-
 src/pkg/math/log1p_amd64.s                | 2 +-
 src/pkg/math/log1p_arm.s                  | 2 +-
 src/pkg/math/log_386.s                    | 2 +-
 src/pkg/math/log_amd64.s                  | 2 +-
 src/pkg/math/log_arm.s                    | 2 +-
 src/pkg/math/mod_386.s                    | 2 +-
 src/pkg/math/mod_amd64.s                  | 2 +-
 src/pkg/math/mod_arm.s                    | 2 +-
 src/pkg/math/modf_386.s                   | 2 +-
 src/pkg/math/modf_amd64.s                 | 2 +-
 src/pkg/math/modf_arm.s                   | 2 +-
 src/pkg/math/remainder_386.s              | 2 +-
 src/pkg/math/remainder_amd64.s            | 2 +-
 src/pkg/math/remainder_arm.s              | 2 +-
 src/pkg/math/sin_386.s                    | 2 +-
 src/pkg/math/sin_amd64.s                  | 2 +-
 src/pkg/math/sin_arm.s                    | 2 +-
 src/pkg/math/sincos_386.s                 | 2 +-
 src/pkg/math/sincos_amd64.s               | 2 +-
 src/pkg/math/sincos_arm.s                 | 2 +-
 src/pkg/math/sqrt_386.s                   | 2 +-
 src/pkg/math/sqrt_amd64.s                 | 2 +-
 src/pkg/math/sqrt_arm.s                   | 2 +-
 src/pkg/math/tan_386.s                    | 2 +-
 src/pkg/math/tan_amd64.s                  | 2 +-
 src/pkg/math/tan_arm.s                    | 2 +-
 src/pkg/os/signal/sig.s                   | 2 +-
 src/pkg/reflect/asm_386.s                 | 2 +-
 src/pkg/reflect/asm_amd64.s               | 2 +-
 src/pkg/reflect/asm_amd64p32.s            | 2 +-
 src/pkg/reflect/asm_arm.s                 | 2 +-
 src/pkg/sync/atomic/asm_386.s             | 2 +-
 src/pkg/sync/atomic/asm_amd64.s           | 2 +-
 src/pkg/sync/atomic/asm_amd64p32.s        | 2 +-
 src/pkg/sync/atomic/asm_arm.s             | 2 +-
 src/pkg/sync/atomic/asm_freebsd_arm.s     | 2 +-
 src/pkg/sync/atomic/asm_linux_arm.s       | 2 +-
 src/pkg/sync/atomic/asm_nacl_arm.s        | 2 +-
 src/pkg/sync/atomic/asm_netbsd_arm.s      | 2 +-
 src/pkg/syscall/asm_darwin_386.s          | 2 +-
 src/pkg/syscall/asm_darwin_amd64.s        | 2 +-
 src/pkg/syscall/asm_dragonfly_386.s       | 2 +-
 src/pkg/syscall/asm_dragonfly_amd64.s     | 2 +-
 src/pkg/syscall/asm_freebsd_386.s         | 2 +-
 src/pkg/syscall/asm_freebsd_amd64.s       | 2 +-
 src/pkg/syscall/asm_freebsd_arm.s         | 2 +-
 src/pkg/syscall/asm_linux_386.s           | 2 +-
 src/pkg/syscall/asm_linux_amd64.s         | 2 +-
 src/pkg/syscall/asm_linux_arm.s           | 2 +-
 src/pkg/syscall/asm_nacl_386.s            | 2 +-
 src/pkg/syscall/asm_nacl_amd64p32.s       | 2 +-
 src/pkg/syscall/asm_nacl_arm.s            | 2 +-
 src/pkg/syscall/asm_netbsd_386.s          | 2 +-
 src/pkg/syscall/asm_netbsd_amd64.s        | 2 +-
 src/pkg/syscall/asm_netbsd_arm.s          | 2 +-
 src/pkg/syscall/asm_openbsd_386.s         | 2 +-
 src/pkg/syscall/asm_openbsd_amd64.s       | 2 +-
 src/pkg/syscall/asm_plan9_386.s           | 2 +-
 src/pkg/syscall/asm_plan9_amd64.s         | 2 +-
 src/pkg/syscall/time_nacl_386.s           | 2 +-
 src/pkg/syscall/time_nacl_amd64p32.s      | 2 +-
 src/pkg/syscall/time_nacl_arm.s           | 2 +-
 128 files changed, 133 insertions(+), 128 deletions(-)

diff --git a/doc/asm.html b/doc/asm.html
index f4ef1e62f2..943347216e 100644
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -253,7 +253,7 @@ There may be one or two arguments to the directives.
 If there are two, the first is a bit mask of flags,
 which can be written as numeric expressions, added or or-ed together,
 or can be set symbolically for easier absorption by a human.
-Their values, defined in the file <code>src/cmd/ld/textflag.h</code>, are:
+Their values, defined in the standard <code>#include</code>  file <code>textflag.h</code>, are:
 </p>
 
 <ul>
diff --git a/src/cmd/dist/build.c b/src/cmd/dist/build.c
index a994367351..2e857559b8 100644
--- a/src/cmd/dist/build.c
+++ b/src/cmd/dist/build.c
@@ -1115,12 +1115,15 @@ install(char *dir)
 
 nobuild:
 	// In package runtime, we install runtime.h and cgocall.h too,
-	// for use by cgo compilation.
+	// for use by cgo compilation. For assembler source, we also
+	// copy cmd/ld/textflag.h.
 	if(streq(dir, "pkg/runtime")) {
 		copy(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot), 0);
 		copy(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot), 0);
+		copy(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
+			bpathf(&b1, "%s/src/cmd/ld/textflag.h", goroot), 0);
 	}
 
 
diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 00df6b2915..591eb1620a 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -1613,8 +1613,10 @@ func (gcToolchain) gc(b *builder, p *Package, archive, obj string, importArgs []
 }
 
 func (gcToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
+	// Add -I pkg/GOOS_GOARCH so #include "textflag.h" works in .s files.
+	inc := filepath.Join(goroot, "pkg", fmt.Sprintf("%s_%s", goos, goarch))
 	sfile = mkAbs(p.Dir, sfile)
-	return b.run(p.Dir, p.ImportPath, nil, tool(archChar+"a"), "-trimpath", b.work, "-I", obj, "-o", ofile, "-D", "GOOS_"+goos, "-D", "GOARCH_"+goarch, sfile)
+	return b.run(p.Dir, p.ImportPath, nil, tool(archChar+"a"), "-trimpath", b.work, "-I", obj, "-I", inc, "-o", ofile, "-D", "GOOS_"+goos, "-D", "GOARCH_"+goarch, sfile)
 }
 
 func (gcToolchain) pkgpath(basedir string, p *Package) string {
diff --git a/src/cmd/link/testdata/autosection.s b/src/cmd/link/testdata/autosection.s
index 8a579b7027..fd9e94da4e 100644
--- a/src/cmd/link/testdata/autosection.s
+++ b/src/cmd/link/testdata/autosection.s
@@ -4,7 +4,7 @@
 
 // Test of section-named symbols.
 
-#include "../../ld/textflag.h"
+#include "textflag.h"
 
 TEXT start(SB),7,$0
 	MOVQ $autotab(SB),AX
diff --git a/src/cmd/link/testdata/layout.s b/src/cmd/link/testdata/layout.s
index 0d492c5af2..c3e55ef49a 100644
--- a/src/cmd/link/testdata/layout.s
+++ b/src/cmd/link/testdata/layout.s
@@ -5,7 +5,7 @@
 // Test of section assignment in layout.go.
 // Each symbol should end up in the section named by the symbol name prefix (up to the underscore).
 
-#include "../../ld/textflag.h"
+#include "textflag.h"
 
 TEXT text_start(SB),7,$0
 	MOVQ $rodata_sym(SB), AX
diff --git a/src/pkg/crypto/aes/asm_amd64.s b/src/pkg/crypto/aes/asm_amd64.s
index 5c22881e98..6a6e6ac4b9 100644
--- a/src/pkg/crypto/aes/asm_amd64.s
+++ b/src/pkg/crypto/aes/asm_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func hasAsm() bool
 // returns whether AES-NI is supported
diff --git a/src/pkg/crypto/md5/md5block_386.s b/src/pkg/crypto/md5/md5block_386.s
index e5c27ac9aa..8e426d148f 100644
--- a/src/pkg/crypto/md5/md5block_386.s
+++ b/src/pkg/crypto/md5/md5block_386.s
@@ -6,7 +6,7 @@
 // #defines generating 8a assembly, and adjusted for 386,
 // by the Go Authors.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // MD5 optimized for AMD64.
 //
diff --git a/src/pkg/crypto/md5/md5block_amd64.s b/src/pkg/crypto/md5/md5block_amd64.s
index 178e49cd8e..a3ae7d97b2 100644
--- a/src/pkg/crypto/md5/md5block_amd64.s
+++ b/src/pkg/crypto/md5/md5block_amd64.s
@@ -5,7 +5,7 @@
 // Translated from Perl generating GNU assembly into
 // #defines generating 6a assembly by the Go Authors.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // MD5 optimized for AMD64.
 //
diff --git a/src/pkg/crypto/md5/md5block_amd64p32.s b/src/pkg/crypto/md5/md5block_amd64p32.s
index a78a3f6100..d918a67c51 100644
--- a/src/pkg/crypto/md5/md5block_amd64p32.s
+++ b/src/pkg/crypto/md5/md5block_amd64p32.s
@@ -9,7 +9,7 @@
 // replace BP with R11, reloaded before use at return.
 // replace R15 with R11.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // MD5 optimized for AMD64.
 //
diff --git a/src/pkg/crypto/md5/md5block_arm.s b/src/pkg/crypto/md5/md5block_arm.s
index e644bfcd61..3b26e549b9 100644
--- a/src/pkg/crypto/md5/md5block_arm.s
+++ b/src/pkg/crypto/md5/md5block_arm.s
@@ -4,7 +4,7 @@
 //
 // ARM version of md5block.go
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Register definitions
 table = 0	// Pointer to MD5 constants table
diff --git a/src/pkg/crypto/rc4/rc4_386.s b/src/pkg/crypto/rc4/rc4_386.s
index b04fc1fb83..54221036ba 100644
--- a/src/pkg/crypto/rc4/rc4_386.s
+++ b/src/pkg/crypto/rc4/rc4_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func xorKeyStream(dst, src *byte, n int, state *[256]byte, i, j *uint8)
 TEXT ·xorKeyStream(SB),NOSPLIT,$0
diff --git a/src/pkg/crypto/rc4/rc4_amd64.s b/src/pkg/crypto/rc4/rc4_amd64.s
index e3234b6c7e..57d941c8f3 100644
--- a/src/pkg/crypto/rc4/rc4_amd64.s
+++ b/src/pkg/crypto/rc4/rc4_amd64.s
@@ -2,7 +2,7 @@
 //	http://www.zorinaq.com/papers/rc4-amd64.html
 //	http://www.zorinaq.com/papers/rc4-amd64.tar.bz2
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Local modifications:
 //
diff --git a/src/pkg/crypto/rc4/rc4_amd64p32.s b/src/pkg/crypto/rc4/rc4_amd64p32.s
index 27d8495071..970b34e08e 100644
--- a/src/pkg/crypto/rc4/rc4_amd64p32.s
+++ b/src/pkg/crypto/rc4/rc4_amd64p32.s
@@ -2,7 +2,7 @@
 //	http://www.zorinaq.com/papers/rc4-amd64.html
 //	http://www.zorinaq.com/papers/rc4-amd64.tar.bz2
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Local modifications:
 //
diff --git a/src/pkg/crypto/rc4/rc4_arm.s b/src/pkg/crypto/rc4/rc4_arm.s
index b9ac72301c..51be3bf95b 100644
--- a/src/pkg/crypto/rc4/rc4_arm.s
+++ b/src/pkg/crypto/rc4/rc4_arm.s
@@ -4,7 +4,7 @@
 
 // +build !nacl
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Registers
 dst = 0
diff --git a/src/pkg/crypto/sha1/sha1block_386.s b/src/pkg/crypto/sha1/sha1block_386.s
index 688851c31e..a0adabc3c3 100644
--- a/src/pkg/crypto/sha1/sha1block_386.s
+++ b/src/pkg/crypto/sha1/sha1block_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // SHA1 block routine. See sha1block.go for Go equivalent.
 //
diff --git a/src/pkg/crypto/sha1/sha1block_amd64.s b/src/pkg/crypto/sha1/sha1block_amd64.s
index 8ffb9d5d68..4319df63e1 100644
--- a/src/pkg/crypto/sha1/sha1block_amd64.s
+++ b/src/pkg/crypto/sha1/sha1block_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // SHA1 block routine. See sha1block.go for Go equivalent.
 //
diff --git a/src/pkg/crypto/sha1/sha1block_amd64p32.s b/src/pkg/crypto/sha1/sha1block_amd64p32.s
index 3c589d94fe..d93fbf1ed3 100644
--- a/src/pkg/crypto/sha1/sha1block_amd64p32.s
+++ b/src/pkg/crypto/sha1/sha1block_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // SHA1 block routine. See sha1block.go for Go equivalent.
 //
diff --git a/src/pkg/crypto/sha1/sha1block_arm.s b/src/pkg/crypto/sha1/sha1block_arm.s
index 5917e8b24b..f11f33dc33 100644
--- a/src/pkg/crypto/sha1/sha1block_arm.s
+++ b/src/pkg/crypto/sha1/sha1block_arm.s
@@ -4,7 +4,7 @@
 //
 // ARM version of md5block.go
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // SHA1 block routine. See sha1block.go for Go equivalent.
 //
diff --git a/src/pkg/crypto/sha256/sha256block_amd64.s b/src/pkg/crypto/sha256/sha256block_amd64.s
index 95aebbe762..868eaed489 100644
--- a/src/pkg/crypto/sha256/sha256block_amd64.s
+++ b/src/pkg/crypto/sha256/sha256block_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // SHA256 block routine. See sha256block.go for Go equivalent.
 //
diff --git a/src/pkg/crypto/sha512/sha512block_amd64.s b/src/pkg/crypto/sha512/sha512block_amd64.s
index 344d8d2c3e..2e10233de1 100644
--- a/src/pkg/crypto/sha512/sha512block_amd64.s
+++ b/src/pkg/crypto/sha512/sha512block_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // SHA512 block routine. See sha512block.go for Go equivalent.
 //
diff --git a/src/pkg/hash/crc32/crc32_amd64.s b/src/pkg/hash/crc32/crc32_amd64.s
index 95dc8bf41b..30b0d0691c 100644
--- a/src/pkg/hash/crc32/crc32_amd64.s
+++ b/src/pkg/hash/crc32/crc32_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func castagnoliSSE42(crc uint32, p []byte) uint32
 TEXT ·castagnoliSSE42(SB),NOSPLIT,$0
diff --git a/src/pkg/hash/crc32/crc32_amd64p32.s b/src/pkg/hash/crc32/crc32_amd64p32.s
index e34f208677..b6770eba3e 100644
--- a/src/pkg/hash/crc32/crc32_amd64p32.s
+++ b/src/pkg/hash/crc32/crc32_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func castagnoliSSE42(crc uint32, p []byte) uint32
 TEXT ·castagnoliSSE42(SB),NOSPLIT,$0
diff --git a/src/pkg/math/abs_386.s b/src/pkg/math/abs_386.s
index 3490cf66c7..f30a439c26 100644
--- a/src/pkg/math/abs_386.s
+++ b/src/pkg/math/abs_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Abs(x float64) float64
 TEXT ·Abs(SB),NOSPLIT,$0
diff --git a/src/pkg/math/abs_amd64.s b/src/pkg/math/abs_amd64.s
index 779c8f5484..0424eb5fad 100644
--- a/src/pkg/math/abs_amd64.s
+++ b/src/pkg/math/abs_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Abs(x float64) float64
 TEXT ·Abs(SB),NOSPLIT,$0
diff --git a/src/pkg/math/abs_arm.s b/src/pkg/math/abs_arm.s
index b5117ab39c..bfa77eb491 100644
--- a/src/pkg/math/abs_arm.s
+++ b/src/pkg/math/abs_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Abs(SB),NOSPLIT,$0
 	MOVW	x_lo+0(FP), R0
diff --git a/src/pkg/math/asin_386.s b/src/pkg/math/asin_386.s
index 2c1d270948..4f34e123ef 100644
--- a/src/pkg/math/asin_386.s
+++ b/src/pkg/math/asin_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Asin(x float64) float64
 TEXT ·Asin(SB),NOSPLIT,$0
diff --git a/src/pkg/math/asin_amd64.s b/src/pkg/math/asin_amd64.s
index ea48104ac6..1a43d489b5 100644
--- a/src/pkg/math/asin_amd64.s
+++ b/src/pkg/math/asin_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Asin(SB),NOSPLIT,$0
 	JMP ·asin(SB)
diff --git a/src/pkg/math/asin_arm.s b/src/pkg/math/asin_arm.s
index b90526003e..8fe03b61d8 100644
--- a/src/pkg/math/asin_arm.s
+++ b/src/pkg/math/asin_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Asin(SB),NOSPLIT,$0
 	B ·asin(SB)
diff --git a/src/pkg/math/atan2_386.s b/src/pkg/math/atan2_386.s
index fb649316a0..31a74e7262 100644
--- a/src/pkg/math/atan2_386.s
+++ b/src/pkg/math/atan2_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Atan2(y, x float64) float64	// =atan(y/x)
 TEXT ·Atan2(SB),NOSPLIT,$0
diff --git a/src/pkg/math/atan2_amd64.s b/src/pkg/math/atan2_amd64.s
index f7a5a11d46..fc471f76c5 100644
--- a/src/pkg/math/atan2_amd64.s
+++ b/src/pkg/math/atan2_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Atan2(SB),NOSPLIT,$0
 	JMP ·atan2(SB)
diff --git a/src/pkg/math/atan2_arm.s b/src/pkg/math/atan2_arm.s
index 24bff2c03d..06c12ecbc4 100644
--- a/src/pkg/math/atan2_arm.s
+++ b/src/pkg/math/atan2_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Atan2(SB),NOSPLIT,$0
 	B ·atan2(SB)
diff --git a/src/pkg/math/atan_386.s b/src/pkg/math/atan_386.s
index aad8ffcec7..f3976b1d35 100644
--- a/src/pkg/math/atan_386.s
+++ b/src/pkg/math/atan_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Atan(x float64) float64
 TEXT ·Atan(SB),NOSPLIT,$0
diff --git a/src/pkg/math/atan_amd64.s b/src/pkg/math/atan_amd64.s
index fc4a91b0de..b801ae99d2 100644
--- a/src/pkg/math/atan_amd64.s
+++ b/src/pkg/math/atan_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Atan(SB),NOSPLIT,$0
 	JMP ·atan(SB)
diff --git a/src/pkg/math/atan_arm.s b/src/pkg/math/atan_arm.s
index defa93a1ed..d190a8bb0c 100644
--- a/src/pkg/math/atan_arm.s
+++ b/src/pkg/math/atan_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Atan(SB),NOSPLIT,$0
 	B ·atan(SB)
diff --git a/src/pkg/math/big/arith_386.s b/src/pkg/math/big/arith_386.s
index 15b036c657..1b47c898f9 100644
--- a/src/pkg/math/big/arith_386.s
+++ b/src/pkg/math/big/arith_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // This file provides fast assembly versions for the elementary
 // arithmetic operations on vectors implemented in arith.go.
diff --git a/src/pkg/math/big/arith_amd64.s b/src/pkg/math/big/arith_amd64.s
index e2113a7e3a..56c4cb050e 100644
--- a/src/pkg/math/big/arith_amd64.s
+++ b/src/pkg/math/big/arith_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // This file provides fast assembly versions for the elementary
 // arithmetic operations on vectors implemented in arith.go.
diff --git a/src/pkg/math/big/arith_amd64p32.s b/src/pkg/math/big/arith_amd64p32.s
index 227870a005..908dbbdc58 100644
--- a/src/pkg/math/big/arith_amd64p32.s
+++ b/src/pkg/math/big/arith_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·mulWW(SB),NOSPLIT,$0
 	JMP ·mulWW_g(SB)
diff --git a/src/pkg/math/big/arith_arm.s b/src/pkg/math/big/arith_arm.s
index 8d36761c4c..a4c51c2127 100644
--- a/src/pkg/math/big/arith_arm.s
+++ b/src/pkg/math/big/arith_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // This file provides fast assembly versions for the elementary
 // arithmetic operations on vectors implemented in arith.go.
diff --git a/src/pkg/math/dim_386.s b/src/pkg/math/dim_386.s
index f715114c43..c8194fed83 100644
--- a/src/pkg/math/dim_386.s
+++ b/src/pkg/math/dim_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Dim(SB),NOSPLIT,$0
 	JMP ·dim(SB)
diff --git a/src/pkg/math/dim_amd64.s b/src/pkg/math/dim_amd64.s
index 38423ef028..622cc3fbad 100644
--- a/src/pkg/math/dim_amd64.s
+++ b/src/pkg/math/dim_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define PosInf 0x7FF0000000000000
 #define NaN    0x7FF8000000000001
diff --git a/src/pkg/math/dim_arm.s b/src/pkg/math/dim_arm.s
index 162f08cda5..be66950687 100644
--- a/src/pkg/math/dim_arm.s
+++ b/src/pkg/math/dim_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Dim(SB),NOSPLIT,$0
 	B ·dim(SB)
diff --git a/src/pkg/math/exp2_386.s b/src/pkg/math/exp2_386.s
index 71959d94dd..7d11920c2d 100644
--- a/src/pkg/math/exp2_386.s
+++ b/src/pkg/math/exp2_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Exp2(x float64) float64
 TEXT ·Exp2(SB),NOSPLIT,$0
diff --git a/src/pkg/math/exp2_amd64.s b/src/pkg/math/exp2_amd64.s
index 77a53dad4e..903c835896 100644
--- a/src/pkg/math/exp2_amd64.s
+++ b/src/pkg/math/exp2_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Exp2(SB),NOSPLIT,$0
 	JMP ·exp2(SB)
diff --git a/src/pkg/math/exp2_arm.s b/src/pkg/math/exp2_arm.s
index fe51f25226..58283cd082 100644
--- a/src/pkg/math/exp2_arm.s
+++ b/src/pkg/math/exp2_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Exp2(SB),NOSPLIT,$0
 	B ·exp2(SB)
diff --git a/src/pkg/math/exp_386.s b/src/pkg/math/exp_386.s
index af2d680d55..6a478a5e60 100644
--- a/src/pkg/math/exp_386.s
+++ b/src/pkg/math/exp_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Exp(x float64) float64
 TEXT ·Exp(SB),NOSPLIT,$0
diff --git a/src/pkg/math/exp_amd64.s b/src/pkg/math/exp_amd64.s
index 070b45264a..d9cf8fd86c 100644
--- a/src/pkg/math/exp_amd64.s
+++ b/src/pkg/math/exp_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // The method is based on a paper by Naoki Shibata: "Efficient evaluation
 // methods of elementary functions suitable for SIMD computation", Proc.
diff --git a/src/pkg/math/exp_arm.s b/src/pkg/math/exp_arm.s
index 130b502ac1..ce36d03caa 100644
--- a/src/pkg/math/exp_arm.s
+++ b/src/pkg/math/exp_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Exp(SB),NOSPLIT,$0
 	B ·exp(SB)
diff --git a/src/pkg/math/expm1_386.s b/src/pkg/math/expm1_386.s
index b268c58c63..a48ca8a58a 100644
--- a/src/pkg/math/expm1_386.s
+++ b/src/pkg/math/expm1_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Expm1(x float64) float64
 TEXT ·Expm1(SB),NOSPLIT,$0
diff --git a/src/pkg/math/expm1_amd64.s b/src/pkg/math/expm1_amd64.s
index 66a75b3d55..b7d5a3be01 100644
--- a/src/pkg/math/expm1_amd64.s
+++ b/src/pkg/math/expm1_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Expm1(SB),NOSPLIT,$0
 	JMP ·expm1(SB)
diff --git a/src/pkg/math/expm1_arm.s b/src/pkg/math/expm1_arm.s
index 838744447f..5f80d872f3 100644
--- a/src/pkg/math/expm1_arm.s
+++ b/src/pkg/math/expm1_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Expm1(SB),NOSPLIT,$0
 	B ·expm1(SB)
diff --git a/src/pkg/math/floor_386.s b/src/pkg/math/floor_386.s
index 37d5a4559f..31c9b174d6 100644
--- a/src/pkg/math/floor_386.s
+++ b/src/pkg/math/floor_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Ceil(x float64) float64
 TEXT ·Ceil(SB),NOSPLIT,$0
diff --git a/src/pkg/math/floor_amd64.s b/src/pkg/math/floor_amd64.s
index 2fd31c4fae..67b7cdec04 100644
--- a/src/pkg/math/floor_amd64.s
+++ b/src/pkg/math/floor_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define Big		0x4330000000000000 // 2**52
 
diff --git a/src/pkg/math/floor_arm.s b/src/pkg/math/floor_arm.s
index cb3b98e95c..59091765b3 100644
--- a/src/pkg/math/floor_arm.s
+++ b/src/pkg/math/floor_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Floor(SB),NOSPLIT,$0
 	B	·floor(SB)
diff --git a/src/pkg/math/frexp_386.s b/src/pkg/math/frexp_386.s
index c6d0a80eda..5bff7e2156 100644
--- a/src/pkg/math/frexp_386.s
+++ b/src/pkg/math/frexp_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Frexp(f float64) (frac float64, exp int)
 TEXT ·Frexp(SB),NOSPLIT,$0
diff --git a/src/pkg/math/frexp_amd64.s b/src/pkg/math/frexp_amd64.s
index 03d1012433..93a321039b 100644
--- a/src/pkg/math/frexp_amd64.s
+++ b/src/pkg/math/frexp_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Frexp(SB),NOSPLIT,$0
 	JMP ·frexp(SB)
diff --git a/src/pkg/math/frexp_arm.s b/src/pkg/math/frexp_arm.s
index 9d40ae46a6..7842eca59b 100644
--- a/src/pkg/math/frexp_arm.s
+++ b/src/pkg/math/frexp_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Frexp(SB),NOSPLIT,$0
 	B ·frexp(SB)
diff --git a/src/pkg/math/hypot_386.s b/src/pkg/math/hypot_386.s
index eec1bf5548..d321f465b4 100644
--- a/src/pkg/math/hypot_386.s
+++ b/src/pkg/math/hypot_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Hypot(p, q float64) float64
 TEXT ·Hypot(SB),NOSPLIT,$0
diff --git a/src/pkg/math/hypot_amd64.s b/src/pkg/math/hypot_amd64.s
index 5c0ff4dd83..a68eebc8ca 100644
--- a/src/pkg/math/hypot_amd64.s
+++ b/src/pkg/math/hypot_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define PosInf 0x7FF0000000000000
 #define NaN 0x7FF8000000000001
diff --git a/src/pkg/math/hypot_arm.s b/src/pkg/math/hypot_arm.s
index 2562aa8306..9c8abca130 100644
--- a/src/pkg/math/hypot_arm.s
+++ b/src/pkg/math/hypot_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Hypot(SB),NOSPLIT,$0
 	B ·hypot(SB)
diff --git a/src/pkg/math/ldexp_386.s b/src/pkg/math/ldexp_386.s
index baf377ead6..ac8e8ba540 100644
--- a/src/pkg/math/ldexp_386.s
+++ b/src/pkg/math/ldexp_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Ldexp(frac float64, exp int) float64
 TEXT ·Ldexp(SB),NOSPLIT,$0
diff --git a/src/pkg/math/ldexp_amd64.s b/src/pkg/math/ldexp_amd64.s
index c7fc226efa..6063a64807 100644
--- a/src/pkg/math/ldexp_amd64.s
+++ b/src/pkg/math/ldexp_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Ldexp(SB),NOSPLIT,$0
 	JMP ·ldexp(SB)
diff --git a/src/pkg/math/ldexp_arm.s b/src/pkg/math/ldexp_arm.s
index 16744ea57d..fcffa2e0fa 100644
--- a/src/pkg/math/ldexp_arm.s
+++ b/src/pkg/math/ldexp_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Ldexp(SB),NOSPLIT,$0
 	B ·ldexp(SB)
diff --git a/src/pkg/math/log10_386.s b/src/pkg/math/log10_386.s
index 4ae069da62..2897f3c155 100644
--- a/src/pkg/math/log10_386.s
+++ b/src/pkg/math/log10_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Log10(x float64) float64
 TEXT ·Log10(SB),NOSPLIT,$0
diff --git a/src/pkg/math/log10_amd64.s b/src/pkg/math/log10_amd64.s
index b9ae832689..8382ba7ae5 100644
--- a/src/pkg/math/log10_amd64.s
+++ b/src/pkg/math/log10_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Log10(SB),NOSPLIT,$0
 	JMP ·log10(SB)
diff --git a/src/pkg/math/log10_arm.s b/src/pkg/math/log10_arm.s
index fa7580f6fb..dbcb8351cf 100644
--- a/src/pkg/math/log10_arm.s
+++ b/src/pkg/math/log10_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Log10(SB),NOSPLIT,$0
 	B ·log10(SB)
diff --git a/src/pkg/math/log1p_386.s b/src/pkg/math/log1p_386.s
index 3b30fd5b7f..1c2d683a8f 100644
--- a/src/pkg/math/log1p_386.s
+++ b/src/pkg/math/log1p_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Log1p(x float64) float64
 TEXT ·Log1p(SB),NOSPLIT,$0
diff --git a/src/pkg/math/log1p_amd64.s b/src/pkg/math/log1p_amd64.s
index 48c24f41f2..1e58fb110d 100644
--- a/src/pkg/math/log1p_amd64.s
+++ b/src/pkg/math/log1p_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Log1p(SB),NOSPLIT,$0
 	JMP ·log1p(SB)
diff --git a/src/pkg/math/log1p_arm.s b/src/pkg/math/log1p_arm.s
index fd2740d0dd..95d5496788 100644
--- a/src/pkg/math/log1p_arm.s
+++ b/src/pkg/math/log1p_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Log1p(SB),NOSPLIT,$0
 	B ·log1p(SB)
diff --git a/src/pkg/math/log_386.s b/src/pkg/math/log_386.s
index 21a0633b19..ff998afb47 100644
--- a/src/pkg/math/log_386.s
+++ b/src/pkg/math/log_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Log(x float64) float64
 TEXT ·Log(SB),NOSPLIT,$0
diff --git a/src/pkg/math/log_amd64.s b/src/pkg/math/log_amd64.s
index dffc5aec88..84c60ab4de 100644
--- a/src/pkg/math/log_amd64.s
+++ b/src/pkg/math/log_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define HSqrt2 7.07106781186547524401e-01 // sqrt(2)/2
 #define Ln2Hi  6.93147180369123816490e-01 // 0x3fe62e42fee00000
diff --git a/src/pkg/math/log_arm.s b/src/pkg/math/log_arm.s
index 28448aeefc..e21d0366e9 100644
--- a/src/pkg/math/log_arm.s
+++ b/src/pkg/math/log_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Log(SB),NOSPLIT,$0
 	B ·log(SB)
diff --git a/src/pkg/math/mod_386.s b/src/pkg/math/mod_386.s
index 9b3b6bd06f..10ad98be3e 100644
--- a/src/pkg/math/mod_386.s
+++ b/src/pkg/math/mod_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Mod(x, y float64) float64
 TEXT ·Mod(SB),NOSPLIT,$0
diff --git a/src/pkg/math/mod_amd64.s b/src/pkg/math/mod_amd64.s
index bef83fcf7f..f99dbe2931 100644
--- a/src/pkg/math/mod_amd64.s
+++ b/src/pkg/math/mod_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Mod(SB),NOSPLIT,$0
 	JMP ·mod(SB)
diff --git a/src/pkg/math/mod_arm.s b/src/pkg/math/mod_arm.s
index 1f51588f8d..5afb3594dd 100644
--- a/src/pkg/math/mod_arm.s
+++ b/src/pkg/math/mod_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Mod(SB),NOSPLIT,$0
 	B ·mod(SB)
diff --git a/src/pkg/math/modf_386.s b/src/pkg/math/modf_386.s
index 07a0dc5cfe..3debd3b95d 100644
--- a/src/pkg/math/modf_386.s
+++ b/src/pkg/math/modf_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Modf(f float64) (int float64, frac float64)
 TEXT ·Modf(SB),NOSPLIT,$0
diff --git a/src/pkg/math/modf_amd64.s b/src/pkg/math/modf_amd64.s
index 05feb4bf90..701cf72a3b 100644
--- a/src/pkg/math/modf_amd64.s
+++ b/src/pkg/math/modf_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Modf(SB),NOSPLIT,$0
 	JMP ·modf(SB)
diff --git a/src/pkg/math/modf_arm.s b/src/pkg/math/modf_arm.s
index e6bd26d53b..ea3c8dc74f 100644
--- a/src/pkg/math/modf_arm.s
+++ b/src/pkg/math/modf_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Modf(SB),NOSPLIT,$0
 	B ·modf(SB)
diff --git a/src/pkg/math/remainder_386.s b/src/pkg/math/remainder_386.s
index bbe13a0d92..318fa2c465 100644
--- a/src/pkg/math/remainder_386.s
+++ b/src/pkg/math/remainder_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Remainder(x, y float64) float64
 TEXT ·Remainder(SB),NOSPLIT,$0
diff --git a/src/pkg/math/remainder_amd64.s b/src/pkg/math/remainder_amd64.s
index e5e23c7ce3..f7fda99d85 100644
--- a/src/pkg/math/remainder_amd64.s
+++ b/src/pkg/math/remainder_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Remainder(SB),NOSPLIT,$0
 	JMP ·remainder(SB)
diff --git a/src/pkg/math/remainder_arm.s b/src/pkg/math/remainder_arm.s
index 8728afe931..1ae597a60e 100644
--- a/src/pkg/math/remainder_arm.s
+++ b/src/pkg/math/remainder_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Remainder(SB),NOSPLIT,$0
 	B ·remainder(SB)
diff --git a/src/pkg/math/sin_386.s b/src/pkg/math/sin_386.s
index 09271c0355..ccc8e64bee 100644
--- a/src/pkg/math/sin_386.s
+++ b/src/pkg/math/sin_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Cos(x float64) float64
 TEXT ·Cos(SB),NOSPLIT,$0
diff --git a/src/pkg/math/sin_amd64.s b/src/pkg/math/sin_amd64.s
index 008bf4be58..0c33cecef3 100644
--- a/src/pkg/math/sin_amd64.s
+++ b/src/pkg/math/sin_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Sin(SB),NOSPLIT,$0
 	JMP	·sin(SB)
diff --git a/src/pkg/math/sin_arm.s b/src/pkg/math/sin_arm.s
index a057b4fc9d..467af3dead 100644
--- a/src/pkg/math/sin_arm.s
+++ b/src/pkg/math/sin_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Sin(SB),NOSPLIT,$0
 	B	·sin(SB)
diff --git a/src/pkg/math/sincos_386.s b/src/pkg/math/sincos_386.s
index bf964b1681..83af5016ef 100644
--- a/src/pkg/math/sincos_386.s
+++ b/src/pkg/math/sincos_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Sincos(x float64) (sin, cos float64)
 TEXT ·Sincos(SB),NOSPLIT,$0
diff --git a/src/pkg/math/sincos_amd64.s b/src/pkg/math/sincos_amd64.s
index bccc1ade12..dae636b248 100644
--- a/src/pkg/math/sincos_amd64.s
+++ b/src/pkg/math/sincos_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // The method is based on a paper by Naoki Shibata: "Efficient evaluation
 // methods of elementary functions suitable for SIMD computation", Proc.
diff --git a/src/pkg/math/sincos_arm.s b/src/pkg/math/sincos_arm.s
index b6866af54f..9fe048248b 100644
--- a/src/pkg/math/sincos_arm.s
+++ b/src/pkg/math/sincos_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Sincos(SB),NOSPLIT,$0
 	B ·sincos(SB)
diff --git a/src/pkg/math/sqrt_386.s b/src/pkg/math/sqrt_386.s
index 2d0c786d0c..5234a1e881 100644
--- a/src/pkg/math/sqrt_386.s
+++ b/src/pkg/math/sqrt_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Sqrt(x float64) float64	
 TEXT ·Sqrt(SB),NOSPLIT,$0
diff --git a/src/pkg/math/sqrt_amd64.s b/src/pkg/math/sqrt_amd64.s
index 1508944c90..443d83fe35 100644
--- a/src/pkg/math/sqrt_amd64.s
+++ b/src/pkg/math/sqrt_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Sqrt(x float64) float64
 TEXT ·Sqrt(SB),NOSPLIT,$0
diff --git a/src/pkg/math/sqrt_arm.s b/src/pkg/math/sqrt_arm.s
index f731ee976d..4f9dc2e038 100644
--- a/src/pkg/math/sqrt_arm.s
+++ b/src/pkg/math/sqrt_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Sqrt(x float64) float64	
 TEXT ·Sqrt(SB),NOSPLIT,$0
diff --git a/src/pkg/math/tan_386.s b/src/pkg/math/tan_386.s
index 2320326e37..f1bdae1536 100644
--- a/src/pkg/math/tan_386.s
+++ b/src/pkg/math/tan_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // func Tan(x float64) float64
 TEXT ·Tan(SB),NOSPLIT,$0
diff --git a/src/pkg/math/tan_amd64.s b/src/pkg/math/tan_amd64.s
index 9fa5f148ef..39aa08061c 100644
--- a/src/pkg/math/tan_amd64.s
+++ b/src/pkg/math/tan_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Tan(SB),NOSPLIT,$0
 	JMP ·tan(SB)
diff --git a/src/pkg/math/tan_arm.s b/src/pkg/math/tan_arm.s
index 68fea318da..36c7c128f6 100644
--- a/src/pkg/math/tan_arm.s
+++ b/src/pkg/math/tan_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·Tan(SB),NOSPLIT,$0
 	B ·tan(SB)
diff --git a/src/pkg/os/signal/sig.s b/src/pkg/os/signal/sig.s
index f860924aa0..d54c284b5e 100644
--- a/src/pkg/os/signal/sig.s
+++ b/src/pkg/os/signal/sig.s
@@ -6,7 +6,7 @@
 
 // +build amd64 amd64p32 arm 386
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #ifdef GOARCH_arm
 #define JMP B
diff --git a/src/pkg/reflect/asm_386.s b/src/pkg/reflect/asm_386.s
index a538624083..8c84bba43b 100644
--- a/src/pkg/reflect/asm_386.s
+++ b/src/pkg/reflect/asm_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // makeFuncStub is the code half of the function returned by MakeFunc.
 // See the comment on the declaration of makeFuncStub in makefunc.go
diff --git a/src/pkg/reflect/asm_amd64.s b/src/pkg/reflect/asm_amd64.s
index 12a8879b79..195928bff9 100644
--- a/src/pkg/reflect/asm_amd64.s
+++ b/src/pkg/reflect/asm_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // makeFuncStub is the code half of the function returned by MakeFunc.
 // See the comment on the declaration of makeFuncStub in makefunc.go
diff --git a/src/pkg/reflect/asm_amd64p32.s b/src/pkg/reflect/asm_amd64p32.s
index a538624083..8c84bba43b 100644
--- a/src/pkg/reflect/asm_amd64p32.s
+++ b/src/pkg/reflect/asm_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // makeFuncStub is the code half of the function returned by MakeFunc.
 // See the comment on the declaration of makeFuncStub in makefunc.go
diff --git a/src/pkg/reflect/asm_arm.s b/src/pkg/reflect/asm_arm.s
index 69e4ab4888..fafc6f313e 100644
--- a/src/pkg/reflect/asm_arm.s
+++ b/src/pkg/reflect/asm_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // makeFuncStub is jumped to by the code generated by MakeFunc.
 // See the comment on the declaration of makeFuncStub in makefunc.go
diff --git a/src/pkg/sync/atomic/asm_386.s b/src/pkg/sync/atomic/asm_386.s
index 807c2f873b..740dfe76ba 100644
--- a/src/pkg/sync/atomic/asm_386.s
+++ b/src/pkg/sync/atomic/asm_386.s
@@ -4,7 +4,7 @@
 
 // +build !race
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·SwapInt32(SB),NOSPLIT,$0-12
 	JMP	·SwapUint32(SB)
diff --git a/src/pkg/sync/atomic/asm_amd64.s b/src/pkg/sync/atomic/asm_amd64.s
index 77afa129ed..6e53ebedd2 100644
--- a/src/pkg/sync/atomic/asm_amd64.s
+++ b/src/pkg/sync/atomic/asm_amd64.s
@@ -4,7 +4,7 @@
 
 // +build !race
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·SwapInt32(SB),NOSPLIT,$0-20
 	JMP	·SwapUint32(SB)
diff --git a/src/pkg/sync/atomic/asm_amd64p32.s b/src/pkg/sync/atomic/asm_amd64p32.s
index b24ae7a59e..d77cc2c088 100644
--- a/src/pkg/sync/atomic/asm_amd64p32.s
+++ b/src/pkg/sync/atomic/asm_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·SwapInt32(SB),NOSPLIT,$0-12
 	JMP	·SwapUint32(SB)
diff --git a/src/pkg/sync/atomic/asm_arm.s b/src/pkg/sync/atomic/asm_arm.s
index 7c8620a51b..47639a80ea 100644
--- a/src/pkg/sync/atomic/asm_arm.s
+++ b/src/pkg/sync/atomic/asm_arm.s
@@ -4,7 +4,7 @@
 
 // +build !race
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // ARM atomic operations, for use by asm_$(GOOS)_arm.s.
 
diff --git a/src/pkg/sync/atomic/asm_freebsd_arm.s b/src/pkg/sync/atomic/asm_freebsd_arm.s
index db37f73bc4..06b975e897 100644
--- a/src/pkg/sync/atomic/asm_freebsd_arm.s
+++ b/src/pkg/sync/atomic/asm_freebsd_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // FreeBSD/ARM atomic operations.
 // TODO(minux): this only supports ARMv6K or higher.
diff --git a/src/pkg/sync/atomic/asm_linux_arm.s b/src/pkg/sync/atomic/asm_linux_arm.s
index 27be57aa1d..bfcfd79779 100644
--- a/src/pkg/sync/atomic/asm_linux_arm.s
+++ b/src/pkg/sync/atomic/asm_linux_arm.s
@@ -4,7 +4,7 @@
 
 // +build !race
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Linux/ARM atomic operations.
 
diff --git a/src/pkg/sync/atomic/asm_nacl_arm.s b/src/pkg/sync/atomic/asm_nacl_arm.s
index 084ab71f82..76f6233364 100644
--- a/src/pkg/sync/atomic/asm_nacl_arm.s
+++ b/src/pkg/sync/atomic/asm_nacl_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // NaCl/ARM atomic operations.
 // NaCl/ARM explicitly targets ARMv7A.
diff --git a/src/pkg/sync/atomic/asm_netbsd_arm.s b/src/pkg/sync/atomic/asm_netbsd_arm.s
index 64f4dbe714..dbe80898fd 100644
--- a/src/pkg/sync/atomic/asm_netbsd_arm.s
+++ b/src/pkg/sync/atomic/asm_netbsd_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // NetBSD/ARM atomic operations.
 // TODO(minux): this only supports ARMv6K or higher.
diff --git a/src/pkg/syscall/asm_darwin_386.s b/src/pkg/syscall/asm_darwin_386.s
index 9b4dfa81df..dfe94fb526 100644
--- a/src/pkg/syscall/asm_darwin_386.s
+++ b/src/pkg/syscall/asm_darwin_386.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for 386, Darwin
diff --git a/src/pkg/syscall/asm_darwin_amd64.s b/src/pkg/syscall/asm_darwin_amd64.s
index 19ea05be72..d6f1c96f5f 100644
--- a/src/pkg/syscall/asm_darwin_amd64.s
+++ b/src/pkg/syscall/asm_darwin_amd64.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for AMD64, Darwin
diff --git a/src/pkg/syscall/asm_dragonfly_386.s b/src/pkg/syscall/asm_dragonfly_386.s
index d24216fddc..37d655fba9 100644
--- a/src/pkg/syscall/asm_dragonfly_386.s
+++ b/src/pkg/syscall/asm_dragonfly_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for 386, FreeBSD
diff --git a/src/pkg/syscall/asm_dragonfly_amd64.s b/src/pkg/syscall/asm_dragonfly_amd64.s
index 31d107490a..c8434f96b7 100644
--- a/src/pkg/syscall/asm_dragonfly_amd64.s
+++ b/src/pkg/syscall/asm_dragonfly_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for AMD64, DragonFly
diff --git a/src/pkg/syscall/asm_freebsd_386.s b/src/pkg/syscall/asm_freebsd_386.s
index 91a46b1062..f50b5a09bf 100644
--- a/src/pkg/syscall/asm_freebsd_386.s
+++ b/src/pkg/syscall/asm_freebsd_386.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for 386, FreeBSD
diff --git a/src/pkg/syscall/asm_freebsd_amd64.s b/src/pkg/syscall/asm_freebsd_amd64.s
index 7abb36828a..58cbfe1a99 100644
--- a/src/pkg/syscall/asm_freebsd_amd64.s
+++ b/src/pkg/syscall/asm_freebsd_amd64.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for AMD64, FreeBSD
diff --git a/src/pkg/syscall/asm_freebsd_arm.s b/src/pkg/syscall/asm_freebsd_arm.s
index c01ce6febf..5eb40334b9 100644
--- a/src/pkg/syscall/asm_freebsd_arm.s
+++ b/src/pkg/syscall/asm_freebsd_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for ARM, FreeBSD
diff --git a/src/pkg/syscall/asm_linux_386.s b/src/pkg/syscall/asm_linux_386.s
index 30b22073df..05cf89aa22 100644
--- a/src/pkg/syscall/asm_linux_386.s
+++ b/src/pkg/syscall/asm_linux_386.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System calls for 386, Linux
diff --git a/src/pkg/syscall/asm_linux_amd64.s b/src/pkg/syscall/asm_linux_amd64.s
index 995b60ecd0..514693283b 100644
--- a/src/pkg/syscall/asm_linux_amd64.s
+++ b/src/pkg/syscall/asm_linux_amd64.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System calls for AMD64, Linux
diff --git a/src/pkg/syscall/asm_linux_arm.s b/src/pkg/syscall/asm_linux_arm.s
index a28bc6cfc0..014fa618f6 100644
--- a/src/pkg/syscall/asm_linux_arm.s
+++ b/src/pkg/syscall/asm_linux_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System calls for arm, Linux
diff --git a/src/pkg/syscall/asm_nacl_386.s b/src/pkg/syscall/asm_nacl_386.s
index de7c3cc5da..3c86decd39 100644
--- a/src/pkg/syscall/asm_nacl_386.s
+++ b/src/pkg/syscall/asm_nacl_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "../runtime/syscall_nacl.h"
 
 //
diff --git a/src/pkg/syscall/asm_nacl_amd64p32.s b/src/pkg/syscall/asm_nacl_amd64p32.s
index de030ec806..b91e09bd6d 100644
--- a/src/pkg/syscall/asm_nacl_amd64p32.s
+++ b/src/pkg/syscall/asm_nacl_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "../runtime/syscall_nacl.h"
 
 //
diff --git a/src/pkg/syscall/asm_nacl_arm.s b/src/pkg/syscall/asm_nacl_arm.s
index ffc48ceaa8..cc4b9cd2d6 100644
--- a/src/pkg/syscall/asm_nacl_arm.s
+++ b/src/pkg/syscall/asm_nacl_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "../runtime/syscall_nacl.h"
 
 //
diff --git a/src/pkg/syscall/asm_netbsd_386.s b/src/pkg/syscall/asm_netbsd_386.s
index 40b30b4053..c58263254a 100644
--- a/src/pkg/syscall/asm_netbsd_386.s
+++ b/src/pkg/syscall/asm_netbsd_386.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for 386, NetBSD
diff --git a/src/pkg/syscall/asm_netbsd_amd64.s b/src/pkg/syscall/asm_netbsd_amd64.s
index 94ad0284ad..8285382ce2 100644
--- a/src/pkg/syscall/asm_netbsd_amd64.s
+++ b/src/pkg/syscall/asm_netbsd_amd64.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for AMD64, NetBSD
diff --git a/src/pkg/syscall/asm_netbsd_arm.s b/src/pkg/syscall/asm_netbsd_arm.s
index 2c0d65401a..b061180491 100644
--- a/src/pkg/syscall/asm_netbsd_arm.s
+++ b/src/pkg/syscall/asm_netbsd_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for ARM, NetBSD
diff --git a/src/pkg/syscall/asm_openbsd_386.s b/src/pkg/syscall/asm_openbsd_386.s
index 7dd2e373f7..17fbb65c80 100644
--- a/src/pkg/syscall/asm_openbsd_386.s
+++ b/src/pkg/syscall/asm_openbsd_386.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for 386, OpenBSD
diff --git a/src/pkg/syscall/asm_openbsd_amd64.s b/src/pkg/syscall/asm_openbsd_amd64.s
index e127bf220c..fe61482cd5 100644
--- a/src/pkg/syscall/asm_openbsd_amd64.s
+++ b/src/pkg/syscall/asm_openbsd_amd64.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for AMD64, OpenBSD
diff --git a/src/pkg/syscall/asm_plan9_386.s b/src/pkg/syscall/asm_plan9_386.s
index f8c07c407a..aaa8b9a692 100644
--- a/src/pkg/syscall/asm_plan9_386.s
+++ b/src/pkg/syscall/asm_plan9_386.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for 386, Plan 9
diff --git a/src/pkg/syscall/asm_plan9_amd64.s b/src/pkg/syscall/asm_plan9_amd64.s
index 220ea68002..22dc5f9576 100644
--- a/src/pkg/syscall/asm_plan9_amd64.s
+++ b/src/pkg/syscall/asm_plan9_amd64.s
@@ -5,7 +5,7 @@
 // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
 // so that go vet can check that they are correct.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 //
 // System call support for Plan 9
diff --git a/src/pkg/syscall/time_nacl_386.s b/src/pkg/syscall/time_nacl_386.s
index b5a22d31b5..c0c89dccc0 100644
--- a/src/pkg/syscall/time_nacl_386.s
+++ b/src/pkg/syscall/time_nacl_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·startTimer(SB),NOSPLIT,$0
 	JMP time·startTimer(SB)
diff --git a/src/pkg/syscall/time_nacl_amd64p32.s b/src/pkg/syscall/time_nacl_amd64p32.s
index b5a22d31b5..c0c89dccc0 100644
--- a/src/pkg/syscall/time_nacl_amd64p32.s
+++ b/src/pkg/syscall/time_nacl_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·startTimer(SB),NOSPLIT,$0
 	JMP time·startTimer(SB)
diff --git a/src/pkg/syscall/time_nacl_arm.s b/src/pkg/syscall/time_nacl_arm.s
index 99baaf59b6..4f4b4d89ae 100644
--- a/src/pkg/syscall/time_nacl_arm.s
+++ b/src/pkg/syscall/time_nacl_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT ·startTimer(SB),NOSPLIT,$0
 	B time·startTimer(SB)

From 00b75a237af6ec8cdf227c18a5e6afe701bd61a0 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Wed, 13 Aug 2014 14:00:10 +1000
Subject: [PATCH 079/423] misc/makerelease: exit with nonzero status code on
 error

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/129040043
---
 misc/makerelease/makerelease.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/misc/makerelease/makerelease.go b/misc/makerelease/makerelease.go
index f67cd5414c..1f60f87045 100644
--- a/misc/makerelease/makerelease.go
+++ b/misc/makerelease/makerelease.go
@@ -154,6 +154,7 @@ func main() {
 			log.Fatalln("setupOAuthClient:", err)
 		}
 	}
+	ok := true
 	for _, targ := range flag.Args() {
 		var b Build
 		if m := fileRe.FindStringSubmatch(targ); m != nil {
@@ -205,8 +206,12 @@ func main() {
 		}
 		if err := b.Do(); err != nil {
 			log.Printf("%s: %v", targ, err)
+			ok = false
 		}
 	}
+	if !ok {
+		os.Exit(1)
+	}
 }
 
 type Build struct {

From c31eb979421236ac51cdb21870483d70d47b84cc Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Wed, 13 Aug 2014 14:54:54 +1000
Subject: [PATCH 080/423] tag go1.3.1

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/125170044
---
 .hgtags | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.hgtags b/.hgtags
index aaa5234b52..51569d518f 100644
--- a/.hgtags
+++ b/.hgtags
@@ -131,4 +131,5 @@ f8b50ad4cac4d4c4ecf48324b4f512f65e82cc1c go1.3beta1
 9d5451df4e53acc58a848005b7ec3a24c4b6050c go1.3rc1
 3f66a43d5180052e2e1e38d979d1aa5ad05b21f9 go1.3rc2
 9895f9e36435468d503eaa74ee217f28d5e28dd4 go1.3
-9895f9e36435468d503eaa74ee217f28d5e28dd4 release
+073fc578434bf3e1e22749b559d273c8da728ebb go1.3.1
+073fc578434bf3e1e22749b559d273c8da728ebb release

From 392bc8985e6b4b33603bfb9b546d301d3857a3cb Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Wed, 13 Aug 2014 23:20:39 +1000
Subject: [PATCH 081/423] doc: remove the "the" in "the the" in the release
 notes

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/128170043
---
 doc/devel/release.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/devel/release.html b/doc/devel/release.html
index c1d364c723..8dec005e71 100644
--- a/doc/devel/release.html
+++ b/doc/devel/release.html
@@ -23,7 +23,7 @@ Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
 <h3 id="go1.3.minor">Minor revisions</h3>
 
 <p>
-go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
+go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
 See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=40272ab1339ab2fb9e7160483e5e5d42d6b7e810">change history</a> for details.
 </p>
 

From aa549ce449a0edccea03b7f4912ee3f9fa9b9b38 Mon Sep 17 00:00:00 2001
From: Thiago Fransosi Farina <thiago.farina@gmail.com>
Date: Wed, 13 Aug 2014 06:47:30 -0700
Subject: [PATCH 082/423] cmd/dist: Reuse streq whenever possible.

Basically this cleanup replaces all the usage usages of strcmp() == 0,
found by the following command line:

$ grep -R strcmp cmd/dist | grep "0"

LGTM=iant
R=iant
CC=golang-codereviews
https://golang.org/cl/123330043
---
 src/cmd/dist/plan9.c   |  6 +++---
 src/cmd/dist/unix.c    | 16 ++++++++--------
 src/cmd/dist/windows.c |  4 ++--
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/cmd/dist/plan9.c b/src/cmd/dist/plan9.c
index 8d492ebc67..e4bf251475 100644
--- a/src/cmd/dist/plan9.c
+++ b/src/cmd/dist/plan9.c
@@ -23,7 +23,7 @@ bprintf(Buf *b, char *fmt, ...)
 {
 	va_list arg;
 	char buf[4096];
-	
+
 	breset(b);
 	va_start(arg, fmt);
 	vsnprintf(buf, sizeof buf, fmt, arg);
@@ -572,10 +572,10 @@ bool
 hassuffix(char *p, char *suffix)
 {
 	int np, ns;
-	
+
 	np = strlen(p);
 	ns = strlen(suffix);
-	return np >= ns && strcmp(p+np-ns, suffix) == 0;
+	return np >= ns && streq(p+np-ns, suffix);
 }
 
 // hasprefix reports whether p begins with prefix.
diff --git a/src/cmd/dist/unix.c b/src/cmd/dist/unix.c
index 8b943a2d95..4a78684b44 100644
--- a/src/cmd/dist/unix.c
+++ b/src/cmd/dist/unix.c
@@ -431,7 +431,7 @@ xremoveall(char *p)
 	}
 	
 	bfree(&b);
-	vfree(&dir);	
+	vfree(&dir);
 }
 
 // xreaddir replaces dst with a list of the names of the files in dir.
@@ -441,13 +441,13 @@ xreaddir(Vec *dst, char *dir)
 {
 	DIR *d;
 	struct dirent *dp;
-	
+
 	vreset(dst);
 	d = opendir(dir);
 	if(d == nil)
 		fatal("opendir %s: %s", dir, strerror(errno));
 	while((dp = readdir(d)) != nil) {
-		if(strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
+		if(streq(dp->d_name, ".") || streq(dp->d_name, ".."))
 			continue;
 		vadd(dst, dp->d_name);
 	}
@@ -461,7 +461,7 @@ xworkdir(void)
 {
 	Buf b;
 	char *p;
-	
+
 	binit(&b);
 
 	xgetenv(&b, "TMPDIR");
@@ -546,10 +546,10 @@ bool
 hassuffix(char *p, char *suffix)
 {
 	int np, ns;
-	
+
 	np = strlen(p);
 	ns = strlen(suffix);
-	return np >= ns && strcmp(p+np-ns, suffix) == 0;
+	return np >= ns && streq(p+np-ns, suffix);
 }
 
 // hasprefix reports whether p begins with prefix.
@@ -712,7 +712,7 @@ main(int argc, char **argv)
 			fatal("unknown architecture: %s", u.machine);
 	}
 
-	if(strcmp(gohostarch, "arm") == 0)
+	if(streq(gohostarch, "arm"))
 		maxnbg = 1;
 
 	// The OS X 10.6 linker does not support external linking mode.
@@ -724,7 +724,7 @@ main(int argc, char **argv)
 	//
 	// Roughly, OS X 10.N shows up as uname release (N+4),
 	// so OS X 10.6 is uname version 10 and OS X 10.8 is uname version 12.
-	if(strcmp(gohostos, "darwin") == 0) {
+	if(streq(gohostos, "darwin")) {
 		if(uname(&u) < 0)
 			fatal("uname: %s", strerror(errno));
 		osx = atoi(u.release) - 4;
diff --git a/src/cmd/dist/windows.c b/src/cmd/dist/windows.c
index 2839c4bc51..1102adff5e 100644
--- a/src/cmd/dist/windows.c
+++ b/src/cmd/dist/windows.c
@@ -770,10 +770,10 @@ bool
 hassuffix(char *p, char *suffix)
 {
 	int np, ns;
-	
+
 	np = strlen(p);
 	ns = strlen(suffix);
-	return np >= ns && strcmp(p+np-ns, suffix) == 0;
+	return np >= ns && streq(p+np-ns, suffix);
 }
 
 bool

From 187d0f672029e0fa0106024dd2f554b247aa7aff Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Wed, 13 Aug 2014 20:42:55 +0400
Subject: [PATCH 083/423] runtime: keep objects in free lists marked as
 allocated. Restore https://golang.org/cl/41040043 after GC rewrite. Original
 description: On the plus side, we don't need to change the bits on malloc and
 free. On the downside, we need to mark objects in the free lists during GC.
 But the free lists are small at GC time, so it should be a net win.

benchmark             old ns/op     new ns/op     delta
BenchmarkMalloc8      21.9          20.4          -6.85%
BenchmarkMalloc16     31.1          29.6          -4.82%

LGTM=khr
R=khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/122280043
---
 src/pkg/runtime/heapdump.c |  22 +++--
 src/pkg/runtime/malloc.go  | 186 ++++++++++++++++++-------------------
 src/pkg/runtime/mgc0.c     |  53 +++++------
 src/pkg/runtime/mgc0.h     |   8 +-
 4 files changed, 136 insertions(+), 133 deletions(-)

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index b002feb1c2..e5032783a8 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -525,11 +525,17 @@ dumproots(void)
 	runtime·iterate_finq(finq_callback);
 }
 
+// Bit vector of free marks.	
+// Needs to be as big as the largest number of objects per span.	
+#pragma dataflag NOPTR
+static byte free[PageSize/8];	
+
 static void
 dumpobjs(void)
 {
-	uintptr i, j, size, n, off, shift, *bitp, bits;
+	uintptr i, j, size, n;
 	MSpan *s;
+	MLink *l;
 	byte *p;
 
 	for(i = 0; i < runtime·mheap.nspan; i++) {
@@ -539,13 +545,15 @@ dumpobjs(void)
 		p = (byte*)(s->start << PageShift);
 		size = s->elemsize;
 		n = (s->npages << PageShift) / size;
+		if(n > nelem(free))	
+			runtime·throw("free array doesn't have enough entries");	
+		for(l = s->freelist; l != nil; l = l->next)
+			free[((byte*)l - p) / size] = true;	
 		for(j = 0; j < n; j++, p += size) {
-			off = (uintptr*)p - (uintptr*)runtime·mheap.arena_start;
-			bitp = (uintptr*)runtime·mheap.arena_start - off/wordsPerBitmapWord - 1;
-			shift = (off % wordsPerBitmapWord) * gcBits;
-			bits = (*bitp >> shift) & bitMask;
-			if(bits != bitAllocated)
-				continue;
+			if(free[j]) {	
+				free[j] = false;	
+				continue;	
+			}
 			dumpobj(p, size, makeheapobjbv(p, size));
 		}
 	}
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 71c0a4ecd7..76c06f314b 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -41,11 +41,9 @@ const (
 	bitsDead           = 0
 	bitsPointer        = 2
 
-	bitMiddle    = 0
-	bitBoundary  = 1
-	bitAllocated = 2
-	bitMarked    = 3
-	bitMask      = bitMiddle | bitBoundary | bitAllocated | bitMarked
+	bitBoundary = 1
+	bitMarked   = 2
+	bitMask     = bitBoundary | bitMarked
 )
 
 // All zero-sized allocations return a pointer to this byte.
@@ -185,110 +183,108 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		size = uintptr(s.elemsize)
 	}
 
-	// From here till marked label marking the object as allocated
-	// and storing type info in the GC bitmap.
-	arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
-	off := (uintptr(x) - arena_start) / ptrSize
-	xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
-	shift := (off % wordsPerBitmapWord) * gcBits
-	if debugMalloc && (((*xbits)>>shift)&bitMask) != bitBoundary {
-		gothrow("bad bits in markallocated")
+	if flags&flagNoScan != 0 {
+		// All objects are pre-marked as noscan.
+		goto marked
 	}
 
-	var ti, te uintptr
-	var ptrmask *uint8
-	if flags&flagNoScan != 0 {
-		// bitsDead in the first quadruple means don't scan.
-		if size == ptrSize {
-			*xbits = (*xbits & ^((bitBoundary | bitPtrMask) << shift)) | ((bitAllocated + (bitsDead << 2)) << shift)
-		} else {
-			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = bitAllocated + (bitsDead << 2)
+	// From here till marked label marking the object as allocated
+	// and storing type info in the GC bitmap.
+	{
+		arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
+		off := (uintptr(x) - arena_start) / ptrSize
+		xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
+		shift := (off % wordsPerBitmapWord) * gcBits
+		if debugMalloc && ((*xbits>>shift)&(bitMask|bitPtrMask)) != bitBoundary {
+			println("runtime: bits =", (*xbits>>shift)&(bitMask|bitPtrMask))
+			gothrow("bad bits in markallocated")
 		}
-		goto marked
-	}
-	if size == ptrSize {
-		// It's one word and it has pointers, it must be a pointer.
-		*xbits = (*xbits & ^((bitBoundary | bitPtrMask) << shift)) | ((bitAllocated | (bitsPointer << 2)) << shift)
-		goto marked
-	}
-	if typ != nil && (uintptr(typ.gc[0])|uintptr(typ.gc[1])) != 0 && uintptr(typ.size) > ptrSize {
-		if typ.kind&kindGCProg != 0 {
-			nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
-			masksize := nptr
-			if masksize%2 != 0 {
-				masksize *= 2 // repeated
+
+		var ti, te uintptr
+		var ptrmask *uint8
+		if size == ptrSize {
+			// It's one word and it has pointers, it must be a pointer.
+			*xbits |= (bitsPointer << 2) << shift
+			goto marked
+		}
+		if typ != nil && (uintptr(typ.gc[0])|uintptr(typ.gc[1])) != 0 && uintptr(typ.size) > ptrSize {
+			if typ.kind&kindGCProg != 0 {
+				nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
+				masksize := nptr
+				if masksize%2 != 0 {
+					masksize *= 2 // repeated
+				}
+				masksize = masksize * pointersPerByte / 8 // 4 bits per word
+				masksize++                                // unroll flag in the beginning
+				if masksize > maxGCMask && typ.gc[1] != 0 {
+					// If the mask is too large, unroll the program directly
+					// into the GC bitmap. It's 7 times slower than copying
+					// from the pre-unrolled mask, but saves 1/16 of type size
+					// memory for the mask.
+					mp.ptrarg[0] = x
+					mp.ptrarg[1] = unsafe.Pointer(typ)
+					mp.scalararg[0] = uint(size)
+					mp.scalararg[1] = uint(size0)
+					onM(&unrollgcproginplace_m)
+					goto marked
+				}
+				ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
+				// Check whether the program is already unrolled.
+				if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
+					mp.ptrarg[0] = unsafe.Pointer(typ)
+					onM(&unrollgcprog_m)
+				}
+				ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
+			} else {
+				ptrmask = (*uint8)(unsafe.Pointer(&typ.gc[0])) // embed mask
 			}
-			masksize = masksize * pointersPerByte / 8 // 4 bits per word
-			masksize++                                // unroll flag in the beginning
-			if masksize > maxGCMask && typ.gc[1] != 0 {
-				// If the mask is too large, unroll the program directly
-				// into the GC bitmap. It's 7 times slower than copying
-				// from the pre-unrolled mask, but saves 1/16 of type size
-				// memory for the mask.
-				mp.ptrarg[0] = x
-				mp.ptrarg[1] = unsafe.Pointer(typ)
-				mp.scalararg[0] = uint(size)
-				mp.scalararg[1] = uint(size0)
-				onM(&unrollgcproginplace_m)
+			if size == 2*ptrSize {
+				xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+				*xbitsb = *ptrmask | bitBoundary
 				goto marked
 			}
-			ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
-			// Check whether the program is already unrolled.
-			if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
-				mp.ptrarg[0] = unsafe.Pointer(typ)
-				onM(&unrollgcprog_m)
+			te = uintptr(typ.size) / ptrSize
+			// If the type occupies odd number of words, its mask is repeated.
+			if te%2 == 0 {
+				te /= 2
 			}
-			ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
-		} else {
-			ptrmask = (*uint8)(unsafe.Pointer(&typ.gc[0])) // embed mask
 		}
 		if size == 2*ptrSize {
 			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = *ptrmask | bitAllocated
+			*xbitsb = (bitsPointer << 2) | (bitsPointer << 6) | bitBoundary
 			goto marked
 		}
-		te = uintptr(typ.size) / ptrSize
-		// If the type occupies odd number of words, its mask is repeated.
-		if te%2 == 0 {
-			te /= 2
-		}
-	}
-	if size == 2*ptrSize {
-		xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-		*xbitsb = (bitsPointer << 2) | (bitsPointer << 6) | bitAllocated
-		goto marked
-	}
-	// Copy pointer bitmask into the bitmap.
-	for i := uintptr(0); i < size0; i += 2 * ptrSize {
-		v := uint8((bitsPointer << 2) | (bitsPointer << 6))
-		if ptrmask != nil {
-			v = *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
-			ti++
-			if ti == te {
-				ti = 0
+		// Copy pointer bitmask into the bitmap.
+		for i := uintptr(0); i < size0; i += 2 * ptrSize {
+			v := uint8((bitsPointer << 2) | (bitsPointer << 6))
+			if ptrmask != nil {
+				v = *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
+				ti++
+				if ti == te {
+					ti = 0
+				}
+			}
+			if i == 0 {
+				v |= bitBoundary
+			}
+			if i+ptrSize == size0 {
+				v &^= uint8(bitPtrMask << 4)
 			}
-		}
-		if i == 0 {
-			v |= bitAllocated
-		}
-		if i+ptrSize == size0 {
-			v &= ^uint8(bitPtrMask << 4)
-		}
 
-		off := (uintptr(x) + i - arena_start) / ptrSize
-		xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
-		shift := (off % wordsPerBitmapWord) * gcBits
-		xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-		*xbitsb = v
-	}
-	if size0%(2*ptrSize) == 0 && size0 < size {
-		// Mark the word after last object's word as bitsDead.
-		off := (uintptr(x) + size0 - arena_start) / ptrSize
-		xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
-		shift := (off % wordsPerBitmapWord) * gcBits
-		xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-		*xbitsb = bitsDead << 2
+			off := (uintptr(x) + i - arena_start) / ptrSize
+			xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
+			shift := (off % wordsPerBitmapWord) * gcBits
+			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+			*xbitsb = v
+		}
+		if size0%(2*ptrSize) == 0 && size0 < size {
+			// Mark the word after last object's word as bitsDead.
+			off := (uintptr(x) + size0 - arena_start) / ptrSize
+			xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
+			shift := (off % wordsPerBitmapWord) * gcBits
+			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
+			*xbitsb = bitsDead << 2
+		}
 	}
 marked:
 	mp.mallocing = 0
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index d7e5d89f01..05b84386be 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -318,7 +318,7 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				bits = cached;
 				cached >>= gcBits;
 				ncached--;
-				if(i != 0 && (bits&bitMask) != bitMiddle)
+				if(i != 0 && (bits&bitBoundary) != 0)
 					break; // reached beginning of the next object
 				bits = (bits>>2)&BitsMask;
 				if(bits == BitsDead)
@@ -403,13 +403,13 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 			shift = (off % wordsPerBitmapWord) * gcBits;
 			xbits = *bitp;
 			bits = (xbits >> shift) & bitMask;
-			if(bits == bitMiddle) {
+			if((bits&bitBoundary) == 0) {
 				// Not a beginning of a block, check if we have block boundary in xbits.
 				while(shift > 0) {
 					obj -= PtrSize;
 					shift -= gcBits;
 					bits = (xbits >> shift) & bitMask;
-					if(bits != bitMiddle)
+					if((bits&bitBoundary) != 0)
 						goto havebits;
 				}
 				// Otherwise consult span table to find the block beginning.
@@ -426,7 +426,8 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 					p = p+idx*size;
 				}
 				if(p == obj) {
-					runtime·printf("runtime: failed to find block beginning for %p s->limit=%p\n", p, s->limit);
+					runtime·printf("runtime: failed to find block beginning for %p s=%p s->limit=%p\n",
+						p, s->start*PageSize, s->limit);
 					runtime·throw("failed to find block beginning");
 				}
 				obj = p;
@@ -436,8 +437,8 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 		havebits:
 			// Now we have bits, bitp, and shift correct for
 			// obj pointing at the base of the object.
-			// Only care about allocated and not marked.
-			if(bits != bitAllocated)
+			// Only care about not marked objects.
+			if((bits&bitMarked) != 0)
 				continue;
 			if(work.nproc == 1)
 				*bitp |= bitMarked<<shift;
@@ -445,12 +446,12 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				for(;;) {
 					xbits = *bitp;
 					bits = (xbits>>shift) & bitMask;
-					if(bits != bitAllocated)
+					if((bits&bitMarked) != 0)
 						break;
 					if(runtime·casp((void**)bitp, (void*)xbits, (void*)(xbits|(bitMarked<<shift))))
 						break;
 				}
-				if(bits != bitAllocated)
+				if((bits&bitMarked) != 0)
 					continue;
 			}
 			if(((xbits>>(shift+2))&BitsMask) == BitsDead)
@@ -892,7 +893,7 @@ runtime·MSpan_Sweep(MSpan *s)
 	byte *p;
 	MCache *c;
 	byte *arena_start;
-	MLink head, *end;
+	MLink head, *end, *link;
 	Special *special, **specialp, *y;
 	bool res, sweepgenset;
 
@@ -922,6 +923,14 @@ runtime·MSpan_Sweep(MSpan *s)
 	c = g->m->mcache;
 	sweepgenset = false;
 
+	// Mark any free objects in this span so we don't collect them.
+	for(link = s->freelist; link != nil; link = link->next) {
+		off = (uintptr*)link - (uintptr*)arena_start;
+		bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
+		shift = (off % wordsPerBitmapWord) * gcBits;
+		*bitp |= bitMarked<<shift;
+	}
+
 	// Unlink & free special records for any objects we're about to free.
 	specialp = &s->specials;
 	special = *specialp;
@@ -932,7 +941,7 @@ runtime·MSpan_Sweep(MSpan *s)
 		bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
 		shift = (off % wordsPerBitmapWord) * gcBits;
 		bits = (*bitp>>shift) & bitMask;
-		if(bits == bitAllocated) {
+		if((bits&bitMarked) == 0) {
 			// Find the exact byte for which the special was setup
 			// (as opposed to object beginning).
 			p = (byte*)(s->start << PageShift) + special->offset;
@@ -946,10 +955,6 @@ runtime·MSpan_Sweep(MSpan *s)
 			}
 		} else {
 			// object is still live: keep special record
-			if(bits != bitMarked) {
-				runtime·printf("runtime: bad bits for special object %p: %d\n", p, (int32)bits);
-				runtime·throw("runtime: bad bits for special object");
-			}
 			specialp = &special->next;
 			special = *specialp;
 		}
@@ -966,20 +971,17 @@ runtime·MSpan_Sweep(MSpan *s)
 		xbits = *bitp;
 		bits = (xbits>>shift) & bitMask;
 
-		// Non-allocated object, ignore.
-		if(bits == bitBoundary)
-			continue;
 		// Allocated and marked object, reset bits to allocated.
-		if(bits == bitMarked) {
-			*bitp = (xbits & ~(bitMarked<<shift)) | (bitAllocated<<shift);
+		if((bits&bitMarked) != 0) {
+			*bitp &= ~(bitMarked<<shift);
 			continue;
 		}
 		// At this point we know that we are looking at garbage object
 		// that needs to be collected.
 		if(runtime·debug.allocfreetrace)
 			runtime·tracefree(p, size);
-		// Reset to boundary.
-		*bitp = (xbits & ~(bitAllocated<<shift)) | (bitBoundary<<shift);
+		// Reset to allocated+noscan.
+		*bitp = (xbits & ~((bitMarked|(BitsMask<<2))<<shift)) | ((uintptr)BitsDead<<(shift+2));
 		if(cl == 0) {
 			// Free large span.
 			runtime·unmarkspan(p, s->npages<<PageShift);
@@ -1857,13 +1859,13 @@ runtime·unrollgcproginplace_m(void)
 	off = (uintptr*)v - (uintptr*)arena_start;
 	b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
 	shift = (off % wordsPerBitmapWord) * gcBits;
-	*b |= bitAllocated<<shift;
+	*b |= bitBoundary<<shift;
 	// Mark word after last as BitsDead.
 	if(size0 < size) {
 		off = (uintptr*)((byte*)v + size0) - (uintptr*)arena_start;
 		b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
 		shift = (off % wordsPerBitmapWord) * gcBits;
-		*b &= ~(bitPtrMask<<shift) | (BitsDead<<(shift+2));
+		*b &= ~(bitPtrMask<<shift) | ((uintptr)BitsDead<<(shift+2));
 	}
 }
 
@@ -1931,7 +1933,7 @@ runtime·markspan(void *v, uintptr size, uintptr n, bool leftover)
 			b0 = b;
 			x = 0;
 		}
-		x |= bitBoundary<<shift;
+		x |= (bitBoundary<<shift) | ((uintptr)BitsDead<<(shift+2));
 	}
 	*b0 = x;
 }
@@ -1958,8 +1960,7 @@ runtime·unmarkspan(void *v, uintptr n)
 	// one span, so no other goroutines are changing these
 	// bitmap words.
 	n /= wordsPerBitmapWord;
-	while(n-- > 0)
-		*b-- = 0;
+	runtime·memclr((byte*)(b - n + 1), n*PtrSize);
 }
 
 void
diff --git a/src/pkg/runtime/mgc0.h b/src/pkg/runtime/mgc0.h
index 3b1c5ba8cf..893819c128 100644
--- a/src/pkg/runtime/mgc0.h
+++ b/src/pkg/runtime/mgc0.h
@@ -70,10 +70,8 @@ enum {
 // the off/16+1'th word before mheap.arena_start.  (On a 32-bit system,
 // the only difference is that the divisor is 8.)
 
-#define bitMiddle	((uintptr)0) // middle of an object
-#define bitBoundary	((uintptr)1) // boundary on a non-allocated object
-#define bitAllocated	((uintptr)2) // boundary on an allocated object
-#define bitMarked	((uintptr)3) // boundary on an allocated and marked object
+#define bitBoundary	((uintptr)1) // boundary of an object
+#define bitMarked	((uintptr)2) // marked object
 
-#define bitMask		((uintptr)bitMiddle|bitBoundary|bitAllocated|bitMarked)
+#define bitMask		((uintptr)bitBoundary|bitMarked)
 #define bitPtrMask	((uintptr)BitsMask<<2)

From 078a9cbc6cf539074ae975debc5d5396352d16b7 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 13 Aug 2014 11:16:30 -0700
Subject: [PATCH 084/423] cmd/cgo, debug/dwarf: fix translation of zero-size
 arrays

In cgo, now that recursive calls to typeConv.Type() always work,
we can more robustly calculate the array sizes based on the size
of our element type.

Also, in debug/dwarf, the decision to call zeroType is made
based on a type's usage	within a particular struct, but dwarf.Type
values are cached in typeCache, so the modification might affect
uses of the type in other structs.  Current compilers don't appear
to share DWARF type entries for "[]foo" and "[0]foo", but they also
don't consistently share type entries in other cases.  Arguably
modifying the types is an improvement in some cases, but varying
translated types according to compiler whims seems like a bad idea.

Lastly, also in debug/dwarf, zeroType only needs to rewrite the
top-level dimension, and only if the rest of the array size is
non-zero.

Fixes #8428.

LGTM=iant
R=iant
CC=golang-codereviews
https://golang.org/cl/127980043
---
 misc/cgo/test/issue8428.go  | 48 +++++++++++++++++++++++++++
 src/cmd/cgo/gcc.go          | 65 ++++++++++++++++++-------------------
 src/pkg/debug/dwarf/type.go | 52 ++++++++++++++++-------------
 3 files changed, 108 insertions(+), 57 deletions(-)
 create mode 100644 misc/cgo/test/issue8428.go

diff --git a/misc/cgo/test/issue8428.go b/misc/cgo/test/issue8428.go
new file mode 100644
index 0000000000..f5b0ee4974
--- /dev/null
+++ b/misc/cgo/test/issue8428.go
@@ -0,0 +1,48 @@
+// 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
+
+// Issue 8428.  Cgo inconsistently translated zero size arrays.
+
+/*
+struct issue8428one {
+	char b;
+	char rest[];
+};
+
+struct issue8428two {
+	void *p;
+	char b;
+	char rest[0];
+};
+
+struct issue8428three {
+	char w[1][2][3][0];
+	char x[2][3][0][1];
+	char y[3][0][1][2];
+	char z[0][1][2][3];
+};
+*/
+import "C"
+
+import "unsafe"
+
+var _ = C.struct_issue8428one{
+	b:    C.char(0),
+	rest: [0]C.char{},
+}
+
+var _ = C.struct_issue8428two{
+	p:    unsafe.Pointer(nil),
+	b:    C.char(0),
+	rest: [0]C.char{},
+}
+
+var _ = C.struct_issue8428three{
+	w: [1][2][3][0]C.char{},
+	x: [2][3][0][1]C.char{},
+	y: [3][0][1][2]C.char{},
+	z: [0][1][2][3]C.char{},
+}
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 26def654d0..482b35197c 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -1075,12 +1075,6 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		return t
 	}
 
-	// clang won't generate DW_AT_byte_size for pointer types,
-	// so we have to fix it here.
-	if dt, ok := base(dtype).(*dwarf.PtrType); ok && dt.ByteSize == -1 {
-		dt.ByteSize = c.ptrSize
-	}
-
 	t := new(Type)
 	t.Size = dtype.Size() // note: wrong for array of pointers, corrected below
 	t.Align = -1
@@ -1104,12 +1098,20 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 			t.Go = c.Opaque(t.Size)
 			break
 		}
+		count := dt.Count
+		if count == -1 {
+			// Indicates flexible array member, which Go doesn't support.
+			// Translate to zero-length array instead.
+			count = 0
+		}
 		sub := c.Type(dt.Type, pos)
 		t.Align = sub.Align
 		t.Go = &ast.ArrayType{
-			Len: c.intExpr(dt.Count),
+			Len: c.intExpr(count),
 			Elt: sub.Go,
 		}
+		// Recalculate t.Size now that we know sub.Size.
+		t.Size = count * sub.Size
 		t.C.Set("__typeof__(%s[%d])", sub.C, dt.Count)
 
 	case *dwarf.BoolType:
@@ -1210,6 +1212,11 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		}
 
 	case *dwarf.PtrType:
+		// Clang doesn't emit DW_AT_byte_size for pointer types.
+		if t.Size != c.ptrSize && t.Size != -1 {
+			fatalf("%s: unexpected: %d-byte pointer type - %s", lineno(pos), t.Size, dtype)
+		}
+		t.Size = c.ptrSize
 		t.Align = c.ptrSize
 
 		if _, ok := base(dt.Type).(*dwarf.VoidType); ok {
@@ -1381,34 +1388,24 @@ func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
 		}
 	}
 
-	if t.Size <= 0 {
-		// Clang does not record the size of a pointer in its DWARF entry,
-		// so if dtype is an array, the call to dtype.Size at the top of the function
-		// computed the size as the array length * 0 = 0.
-		// The type switch called Type (this function) recursively on the pointer
-		// entry, and the code near the top of the function updated the size to
-		// be correct, so calling dtype.Size again will produce the correct value.
-		t.Size = dtype.Size()
-		if t.Size < 0 {
-			// Unsized types are [0]byte, unless they're typedefs of other types
-			// or structs with tags.
-			// if so, use the name we've already defined.
-			t.Size = 0
-			switch dt := dtype.(type) {
-			case *dwarf.TypedefType:
-				// ok
-			case *dwarf.StructType:
-				if dt.StructName != "" {
-					break
-				}
-				t.Go = c.Opaque(0)
-			default:
-				t.Go = c.Opaque(0)
+	if t.Size < 0 {
+		// Unsized types are [0]byte, unless they're typedefs of other types
+		// or structs with tags.
+		// if so, use the name we've already defined.
+		t.Size = 0
+		switch dt := dtype.(type) {
+		case *dwarf.TypedefType:
+			// ok
+		case *dwarf.StructType:
+			if dt.StructName != "" {
+				break
 			}
-			if t.C.Empty() {
-				t.C.Set("void")
-			}
-			return t
+			t.Go = c.Opaque(0)
+		default:
+			t.Go = c.Opaque(0)
+		}
+		if t.C.Empty() {
+			t.C.Set("void")
 		}
 	}
 
diff --git a/src/pkg/debug/dwarf/type.go b/src/pkg/debug/dwarf/type.go
index b64333ecc5..fa40b2bef1 100644
--- a/src/pkg/debug/dwarf/type.go
+++ b/src/pkg/debug/dwarf/type.go
@@ -118,7 +118,12 @@ func (t *ArrayType) String() string {
 	return "[" + strconv.FormatInt(t.Count, 10) + "]" + t.Type.String()
 }
 
-func (t *ArrayType) Size() int64 { return t.Count * t.Type.Size() }
+func (t *ArrayType) Size() int64 {
+	if t.Count == -1 {
+		return 0
+	}
+	return t.Count * t.Type.Size()
+}
 
 // A VoidType represents the C void type.
 type VoidType struct {
@@ -369,7 +374,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 		t.StrideBitSize, _ = e.Val(AttrStrideSize).(int64)
 
 		// Accumulate dimensions,
-		ndim := 0
+		var dims []int64
 		for kid := next(); kid != nil; kid = next() {
 			// TODO(rsc): Can also be TagEnumerationType
 			// but haven't seen that in the wild yet.
@@ -381,26 +386,24 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 					count, ok = kid.Val(AttrUpperBound).(int64)
 					if ok {
 						count++ // Length is one more than upper bound.
-					} else {
+					} else if len(dims) == 0 {
 						count = -1 // As in x[].
 					}
 				}
-				if ndim == 0 {
-					t.Count = count
-				} else {
-					// Multidimensional array.
-					// Create new array type underneath this one.
-					t.Type = &ArrayType{Type: t.Type, Count: count}
-				}
-				ndim++
+				dims = append(dims, count)
 			case TagEnumerationType:
 				err = DecodeError{name, kid.Offset, "cannot handle enumeration type as array bound"}
 				goto Error
 			}
 		}
-		if ndim == 0 {
+		if len(dims) == 0 {
 			// LLVM generates this for x[].
-			t.Count = -1
+			dims = []int64{-1}
+		}
+
+		t.Count = dims[0]
+		for i := len(dims) - 1; i >= 1; i-- {
+			t.Type = &ArrayType{Type: t.Type, Count: dims[i]}
 		}
 
 	case TagBaseType:
@@ -476,7 +479,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 		t.StructName, _ = e.Val(AttrName).(string)
 		t.Incomplete = e.Val(AttrDeclaration) != nil
 		t.Field = make([]*StructField, 0, 8)
-		var lastFieldType Type
+		var lastFieldType *Type
 		var lastFieldBitOffset int64
 		for kid := next(); kid != nil; kid = next() {
 			if kid.Tag == TagMember {
@@ -518,7 +521,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off
 					// (DWARF writes out 0-length arrays as if they were 1-length arrays.)
 					zeroArray(lastFieldType)
 				}
-				lastFieldType = f.Type
+				lastFieldType = &f.Type
 				lastFieldBitOffset = bito
 			}
 		}
@@ -667,13 +670,16 @@ Error:
 	return nil, err
 }
 
-func zeroArray(t Type) {
-	for {
-		at, ok := t.(*ArrayType)
-		if !ok {
-			break
-		}
-		at.Count = 0
-		t = at.Type
+func zeroArray(t *Type) {
+	if t == nil {
+		return
 	}
+	at, ok := (*t).(*ArrayType)
+	if !ok || at.Type.Size() == 0 {
+		return
+	}
+	// Make a copy to avoid invalidating typeCache.
+	tt := *at
+	tt.Count = 0
+	*t = &tt
 }

From e9bbcea81d90890a04155d81300b59a71a47472d Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Wed, 13 Aug 2014 12:53:50 -0700
Subject: [PATCH 085/423] text/scanner: improve documentation

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/123390043
---
 src/pkg/text/scanner/scanner.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/pkg/text/scanner/scanner.go b/src/pkg/text/scanner/scanner.go
index 25b2c9e02a..5199ee4fc7 100644
--- a/src/pkg/text/scanner/scanner.go
+++ b/src/pkg/text/scanner/scanner.go
@@ -66,6 +66,12 @@ func (pos Position) String() string {
 //
 //	ScanIdents | ScanInts | SkipComments
 //
+// With the exceptions of comments, which are skipped if SkipComments is
+// set, unrecognized tokens are not ignored. Instead, the scanner simply
+// returns the respective individual characters (or possibly sub-tokens).
+// For instance, if the mode is ScanIdents (not ScanStrings), the string
+// "foo" is scanned as the token sequence '"' Ident '"'.
+//
 const (
 	ScanIdents     = 1 << -Ident
 	ScanInts       = 1 << -Int

From 937f0d59fcdeec593640c4b14725aa85ea50c59b Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Wed, 13 Aug 2014 14:56:58 -0700
Subject: [PATCH 086/423] doc/go1.4.txt: cmd/go changes, syscall

CC=golang-codereviews
https://golang.org/cl/129130043
---
 doc/go1.4.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index 198529434a..60e4bd9e68 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -7,6 +7,10 @@ Please keep the list sorted (as in sort.Strings of the lines).
 
 spec: permit for range x (CL 104680043)
 
+cmd/go: import comments (CL 124940043)
+cmd/go: implement "internal" (CL 120600043)
+
+asm: make textflag.h available outside of cmd/ld (CL 128050043)
 crypto/tls: add support for ALPN (RFC 7301) (CL 108710046)
 crypto/tls: support programmatic selection of server certificates (CL 107400043)
 encoding/gob: remove unsafe (CL 102680045)
@@ -15,6 +19,7 @@ os: implement symlink support for windows (CL 86160044)
 runtime: implement monotonic clocks on windows (CL 108700045)
 runtime/race: freebsd is supported (CL 107270043)
 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)
 testing: add Coverage (CL 98150043)
 text/scanner: add IsIdentRune field of Scanner. (CL 108030044)
 time: use the micro symbol (µ (U+00B5)) to print microsecond duration (CL 105030046)

From ba30c082c026b5ef029e5d855a90ea56ef9487ec Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 14 Aug 2014 09:21:58 -0700
Subject: [PATCH 087/423] cmd/cgo: check for compiler errors in the C preamble

E.g., here's the new "go build" output:

$ go build misc/cgo/errors/issue8442.go
# command-line-arguments
could not determine kind of name for C.issue8442foo

gcc errors for preamble:
misc/cgo/errors/issue8442.go:11:19: error: unknown type name 'UNDEF'

Fixes #8442.

LGTM=iant
R=iant, alex.brainman
CC=golang-codereviews
https://golang.org/cl/129160043
---
 misc/cgo/errors/issue8442.go | 17 +++++++++++++++++
 misc/cgo/errors/test.bash    |  1 +
 src/cmd/cgo/gcc.go           | 15 ++++++++++++---
 3 files changed, 30 insertions(+), 3 deletions(-)
 create mode 100644 misc/cgo/errors/issue8442.go

diff --git a/misc/cgo/errors/issue8442.go b/misc/cgo/errors/issue8442.go
new file mode 100644
index 0000000000..45daf8e59e
--- /dev/null
+++ b/misc/cgo/errors/issue8442.go
@@ -0,0 +1,17 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+// Issue 8442.  Cgo output unhelpful error messages for
+// invalid C preambles.
+
+/*
+void issue8442foo(UNDEF*); // ERROR HERE
+*/
+import "C"
+
+func main() {
+	C.issue8442foo(nil)
+}
diff --git a/misc/cgo/errors/test.bash b/misc/cgo/errors/test.bash
index e5bf47a0dd..c96264389c 100755
--- a/misc/cgo/errors/test.bash
+++ b/misc/cgo/errors/test.bash
@@ -28,6 +28,7 @@ check err1.go
 check err2.go
 check err3.go
 check issue7757.go
+check issue8442.go
 
 rm -rf errs _obj
 exit 0
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 482b35197c..d77d56c22a 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -332,6 +332,7 @@ func (p *Package) guessKinds(f *File) []*Name {
 	const (
 		notType = 1 << iota
 		notConst
+		notDeclared
 	)
 	for _, line := range strings.Split(stderr, "\n") {
 		if !strings.Contains(line, ": error:") {
@@ -366,7 +367,7 @@ func (p *Package) guessKinds(f *File) []*Name {
 			completed = true
 
 		case "not-declared":
-			error_(token.NoPos, "%s", strings.TrimSpace(line[c2+1:]))
+			sniff[i] |= notDeclared
 		case "not-type":
 			sniff[i] |= notType
 		case "not-const":
@@ -375,12 +376,12 @@ func (p *Package) guessKinds(f *File) []*Name {
 	}
 
 	if !completed {
-		fatalf("%s did not produce error at completed:1\non input:\n%s", p.gccBaseCmd()[0], b.Bytes())
+		fatalf("%s did not produce error at completed:1\non input:\n%s\nfull error output:\n%s", p.gccBaseCmd()[0], b.Bytes(), stderr)
 	}
 
 	for i, n := range names {
 		switch sniff[i] {
-		case 0:
+		default:
 			error_(token.NoPos, "could not determine kind of name for C.%s", fixGo(n.Go))
 		case notType:
 			n.Kind = "const"
@@ -391,6 +392,14 @@ func (p *Package) guessKinds(f *File) []*Name {
 		}
 	}
 	if nerrors > 0 {
+		// Check if compiling the preamble by itself causes any errors,
+		// because the messages we've printed out so far aren't helpful
+		// to users debugging preamble mistakes.  See issue 8442.
+		preambleErrors := p.gccErrors([]byte(f.Preamble))
+		if len(preambleErrors) > 0 {
+			error_(token.NoPos, "\n%s errors for preamble:\n%s", p.gccBaseCmd()[0], preambleErrors)
+		}
+
 		fatalf("unresolved names")
 	}
 

From 0c32bd6262e2ddaead83ea3e8486b48fb6967532 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 14 Aug 2014 21:38:24 +0400
Subject: [PATCH 088/423] runtime: mark objects with non-atomic operations

On the go.benchmarks/garbage benchmark with GOMAXPROCS=16:
                   old ns/op     new ns/op     delta
time               1392254       1353170       -2.81%
cputime            21995751      21373999      -2.83%
gc-pause-one       15044812      13050524      -13.26%
gc-pause-total     213636        185317        -13.26%

LGTM=rlh
R=golang-codereviews, rlh
CC=golang-codereviews, khr, rsc
https://golang.org/cl/123380043
---
 src/pkg/runtime/mgc0.c | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 05b84386be..6e307bfce4 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -213,7 +213,7 @@ static struct {
 static void
 scanblock(byte *b, uintptr n, byte *ptrmask)
 {
-	byte *obj, *p, *arena_start, *arena_used, **wp, *scanbuf[8];
+	byte *obj, *p, *arena_start, *arena_used, **wp, *scanbuf[8], bits8;
 	uintptr i, nobj, size, idx, *bitp, bits, xbits, shift, x, off, cached, scanbufpos;
 	intptr ncached;
 	Workbuf *wbuf;
@@ -440,16 +440,27 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 			// Only care about not marked objects.
 			if((bits&bitMarked) != 0)
 				continue;
-			if(work.nproc == 1)
-				*bitp |= bitMarked<<shift;
+			// If obj size is greater than 8, then each byte of GC bitmap
+			// contains info for at most one object. In such case we use
+			// non-atomic byte store to mark the object. This can lead
+			// to double enqueue of the object for scanning, but scanning
+			// is an idempotent operation, so it is OK. This cannot lead
+			// to bitmap corruption because the single marked bit is the
+			// only thing that can change in the byte.
+			// For 8-byte objects we use non-atomic store, if the other
+			// quadruple is already marked. Otherwise we resort to CAS
+			// loop for marking.
+			bits8 = xbits>>(shift&~7);
+			if((bits8&(bitMask|(bitMask<<gcBits))) != (bitBoundary|(bitBoundary<<gcBits)))
+				((uint8*)bitp)[shift/8] = bits8 | (bitMarked<<(shift&7));
 			else {
 				for(;;) {
+					if(runtime·casp((void**)bitp, (void*)xbits, (void*)(xbits|(bitMarked<<shift))))
+						break;
 					xbits = *bitp;
 					bits = (xbits>>shift) & bitMask;
 					if((bits&bitMarked) != 0)
 						break;
-					if(runtime·casp((void**)bitp, (void*)xbits, (void*)(xbits|(bitMarked<<shift))))
-						break;
 				}
 				if((bits&bitMarked) != 0)
 					continue;

From 0235f6854c0c327025f6e0321c64f04595c6ba36 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Fri, 15 Aug 2014 08:46:16 +0900
Subject: [PATCH 089/423] doc: make it point to correct go1.3.1 change history

LGTM=minux, adg
R=golang-codereviews, minux, adg
CC=golang-codereviews
https://golang.org/cl/129180043
---
 doc/devel/release.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/devel/release.html b/doc/devel/release.html
index 8dec005e71..a8f5963ca7 100644
--- a/doc/devel/release.html
+++ b/doc/devel/release.html
@@ -24,7 +24,7 @@ Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
 
 <p>
 go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
-See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=40272ab1339ab2fb9e7160483e5e5d42d6b7e810">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=073fc578434bf3e1e22749b559d273c8da728ebb">change history</a> for details.
 </p>
 
 <h2 id="go1.2">go1.2 (released 2013/12/01)</h2>

From a18a3603795064cf45496f97da628308b2dc9700 Mon Sep 17 00:00:00 2001
From: Egon Elbre <egonelbre@gmail.com>
Date: Fri, 15 Aug 2014 16:37:19 +1000
Subject: [PATCH 090/423] net: fix CNAME resolving on Windows

Fixes #8492

LGTM=alex.brainman
R=golang-codereviews, alex.brainman
CC=golang-codereviews
https://golang.org/cl/122200043
---
 src/pkg/net/lookup_windows.go             |  79 ++++++-
 src/pkg/net/lookup_windows_test.go        | 243 ++++++++++++++++++++++
 src/pkg/syscall/syscall_windows.go        |   1 +
 src/pkg/syscall/zsyscall_windows_386.go   |   9 +-
 src/pkg/syscall/zsyscall_windows_amd64.go |   9 +-
 src/pkg/syscall/ztypes_windows.go         |  12 ++
 6 files changed, 341 insertions(+), 12 deletions(-)
 create mode 100644 src/pkg/net/lookup_windows_test.go

diff --git a/src/pkg/net/lookup_windows.go b/src/pkg/net/lookup_windows.go
index 130364231d..6a925b0a7a 100644
--- a/src/pkg/net/lookup_windows.go
+++ b/src/pkg/net/lookup_windows.go
@@ -210,14 +210,21 @@ func lookupCNAME(name string) (cname string, err error) {
 	defer releaseThread()
 	var r *syscall.DNSRecord
 	e := syscall.DnsQuery(name, syscall.DNS_TYPE_CNAME, 0, nil, &r, nil)
+	// windows returns DNS_INFO_NO_RECORDS if there are no CNAME-s
+	if errno, ok := e.(syscall.Errno); ok && errno == syscall.DNS_INFO_NO_RECORDS {
+		// if there are no aliases, the canonical name is the input name
+		if name == "" || name[len(name)-1] != '.' {
+			return name + ".", nil
+		}
+		return name, nil
+	}
 	if e != nil {
 		return "", os.NewSyscallError("LookupCNAME", e)
 	}
 	defer syscall.DnsRecordListFree(r, 1)
-	if r != nil && r.Type == syscall.DNS_TYPE_CNAME {
-		v := (*syscall.DNSPTRData)(unsafe.Pointer(&r.Data[0]))
-		cname = syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]) + "."
-	}
+
+	resolved := resolveCNAME(syscall.StringToUTF16Ptr(name), r)
+	cname = syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(resolved))[:]) + "."
 	return
 }
 
@@ -236,8 +243,9 @@ func lookupSRV(service, proto, name string) (cname string, addrs []*SRV, err err
 		return "", nil, os.NewSyscallError("LookupSRV", e)
 	}
 	defer syscall.DnsRecordListFree(r, 1)
+
 	addrs = make([]*SRV, 0, 10)
-	for p := r; p != nil && p.Type == syscall.DNS_TYPE_SRV; p = p.Next {
+	for _, p := range validRecs(r, syscall.DNS_TYPE_SRV, target) {
 		v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0]))
 		addrs = append(addrs, &SRV{syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:]), v.Port, v.Priority, v.Weight})
 	}
@@ -254,8 +262,9 @@ func lookupMX(name string) (mx []*MX, err error) {
 		return nil, os.NewSyscallError("LookupMX", e)
 	}
 	defer syscall.DnsRecordListFree(r, 1)
+
 	mx = make([]*MX, 0, 10)
-	for p := r; p != nil && p.Type == syscall.DNS_TYPE_MX; p = p.Next {
+	for _, p := range validRecs(r, syscall.DNS_TYPE_MX, name) {
 		v := (*syscall.DNSMXData)(unsafe.Pointer(&p.Data[0]))
 		mx = append(mx, &MX{syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.NameExchange))[:]) + ".", v.Preference})
 	}
@@ -272,8 +281,9 @@ func lookupNS(name string) (ns []*NS, err error) {
 		return nil, os.NewSyscallError("LookupNS", e)
 	}
 	defer syscall.DnsRecordListFree(r, 1)
+
 	ns = make([]*NS, 0, 10)
-	for p := r; p != nil && p.Type == syscall.DNS_TYPE_NS; p = p.Next {
+	for _, p := range validRecs(r, syscall.DNS_TYPE_NS, name) {
 		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
 		ns = append(ns, &NS{syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]) + "."})
 	}
@@ -289,9 +299,10 @@ func lookupTXT(name string) (txt []string, err error) {
 		return nil, os.NewSyscallError("LookupTXT", e)
 	}
 	defer syscall.DnsRecordListFree(r, 1)
+
 	txt = make([]string, 0, 10)
-	if r != nil && r.Type == syscall.DNS_TYPE_TEXT {
-		d := (*syscall.DNSTXTData)(unsafe.Pointer(&r.Data[0]))
+	for _, p := range validRecs(r, syscall.DNS_TYPE_TEXT, name) {
+		d := (*syscall.DNSTXTData)(unsafe.Pointer(&p.Data[0]))
 		for _, v := range (*[1 << 10]*uint16)(unsafe.Pointer(&(d.StringArray[0])))[:d.StringCount] {
 			s := syscall.UTF16ToString((*[1 << 20]uint16)(unsafe.Pointer(v))[:])
 			txt = append(txt, s)
@@ -313,10 +324,58 @@ func lookupAddr(addr string) (name []string, err error) {
 		return nil, os.NewSyscallError("LookupAddr", e)
 	}
 	defer syscall.DnsRecordListFree(r, 1)
+
 	name = make([]string, 0, 10)
-	for p := r; p != nil && p.Type == syscall.DNS_TYPE_PTR; p = p.Next {
+	for _, p := range validRecs(r, syscall.DNS_TYPE_PTR, arpa) {
 		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
 		name = append(name, syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]))
 	}
 	return name, nil
 }
+
+const dnsSectionMask = 0x0003
+
+// returns only results applicable to name and resolves CNAME entries
+func validRecs(r *syscall.DNSRecord, dnstype uint16, name string) []*syscall.DNSRecord {
+	cname := syscall.StringToUTF16Ptr(name)
+	if dnstype != syscall.DNS_TYPE_CNAME {
+		cname = resolveCNAME(cname, r)
+	}
+	rec := make([]*syscall.DNSRecord, 0, 10)
+	for p := r; p != nil; p = p.Next {
+		if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer {
+			continue
+		}
+		if p.Type != dnstype {
+			continue
+		}
+		if !syscall.DnsNameCompare(cname, p.Name) {
+			continue
+		}
+		rec = append(rec, p)
+	}
+	return rec
+}
+
+// returns the last CNAME in chain
+func resolveCNAME(name *uint16, r *syscall.DNSRecord) *uint16 {
+	// limit cname resolving to 10 in case of a infinite CNAME loop
+Cname:
+	for cnameloop := 0; cnameloop < 10; cnameloop++ {
+		for p := r; p != nil; p = p.Next {
+			if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer {
+				continue
+			}
+			if p.Type != syscall.DNS_TYPE_CNAME {
+				continue
+			}
+			if !syscall.DnsNameCompare(name, p.Name) {
+				continue
+			}
+			name = (*syscall.DNSPTRData)(unsafe.Pointer(&r.Data[0])).Host
+			continue Cname
+		}
+		break
+	}
+	return name
+}
diff --git a/src/pkg/net/lookup_windows_test.go b/src/pkg/net/lookup_windows_test.go
new file mode 100644
index 0000000000..7495b5b578
--- /dev/null
+++ b/src/pkg/net/lookup_windows_test.go
@@ -0,0 +1,243 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package net
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var nslookupTestServers = []string{"mail.golang.com", "gmail.com"}
+
+func toJson(v interface{}) string {
+	data, _ := json.Marshal(v)
+	return string(data)
+}
+
+func TestLookupMX(t *testing.T) {
+	if testing.Short() || !*testExternal {
+		t.Skip("skipping test to avoid external network")
+	}
+	for _, server := range nslookupTestServers {
+		mx, err := LookupMX(server)
+		if err != nil {
+			t.Errorf("failed %s: %s", server, err)
+			continue
+		}
+		if len(mx) == 0 {
+			t.Errorf("no results")
+			continue
+		}
+		expected, err := nslookupMX(server)
+		if err != nil {
+			t.Logf("skipping failed nslookup %s test: %s", server, err)
+		}
+		sort.Sort(byPrefAndHost(expected))
+		sort.Sort(byPrefAndHost(mx))
+		if !reflect.DeepEqual(expected, mx) {
+			t.Errorf("different results %s:\texp:%v\tgot:%v", server, toJson(expected), toJson(mx))
+		}
+	}
+}
+
+func TestLookupCNAME(t *testing.T) {
+	if testing.Short() || !*testExternal {
+		t.Skip("skipping test to avoid external network")
+	}
+	for _, server := range nslookupTestServers {
+		cname, err := LookupCNAME(server)
+		if err != nil {
+			t.Errorf("failed %s: %s", server, err)
+			continue
+		}
+		if cname == "" {
+			t.Errorf("no result %s", server)
+		}
+		expected, err := nslookupCNAME(server)
+		if err != nil {
+			t.Logf("skipping failed nslookup %s test: %s", server, err)
+			continue
+		}
+		if expected != cname {
+			t.Errorf("different results %s:\texp:%v\tgot:%v", server, expected, cname)
+		}
+	}
+}
+
+func TestLookupNS(t *testing.T) {
+	if testing.Short() || !*testExternal {
+		t.Skip("skipping test to avoid external network")
+	}
+	for _, server := range nslookupTestServers {
+		ns, err := LookupNS(server)
+		if err != nil {
+			t.Errorf("failed %s: %s", server, err)
+			continue
+		}
+		if len(ns) == 0 {
+			t.Errorf("no results")
+			continue
+		}
+		expected, err := nslookupNS(server)
+		if err != nil {
+			t.Logf("skipping failed nslookup %s test: %s", server, err)
+			continue
+		}
+		sort.Sort(byHost(expected))
+		sort.Sort(byHost(ns))
+		if !reflect.DeepEqual(expected, ns) {
+			t.Errorf("different results %s:\texp:%v\tgot:%v", toJson(server), toJson(expected), ns)
+		}
+	}
+}
+
+func TestLookupTXT(t *testing.T) {
+	if testing.Short() || !*testExternal {
+		t.Skip("skipping test to avoid external network")
+	}
+	for _, server := range nslookupTestServers {
+		txt, err := LookupTXT(server)
+		if err != nil {
+			t.Errorf("failed %s: %s", server, err)
+			continue
+		}
+		if len(txt) == 0 {
+			t.Errorf("no results")
+			continue
+		}
+		expected, err := nslookupTXT(server)
+		if err != nil {
+			t.Logf("skipping failed nslookup %s test: %s", server, err)
+			continue
+		}
+		sort.Strings(expected)
+		sort.Strings(txt)
+		if !reflect.DeepEqual(expected, txt) {
+			t.Errorf("different results %s:\texp:%v\tgot:%v", server, toJson(expected), toJson(txt))
+		}
+	}
+}
+
+type byPrefAndHost []*MX
+
+func (s byPrefAndHost) Len() int { return len(s) }
+func (s byPrefAndHost) Less(i, j int) bool {
+	if s[i].Pref != s[j].Pref {
+		return s[i].Pref < s[j].Pref
+	}
+	return s[i].Host < s[j].Host
+}
+func (s byPrefAndHost) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+type byHost []*NS
+
+func (s byHost) Len() int           { return len(s) }
+func (s byHost) Less(i, j int) bool { return s[i].Host < s[j].Host }
+func (s byHost) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func fqdn(s string) string {
+	if len(s) == 0 || s[len(s)-1] != '.' {
+		return s + "."
+	}
+	return s
+}
+
+func nslookup(qtype, name string) (string, error) {
+	var out bytes.Buffer
+	var err bytes.Buffer
+	cmd := exec.Command("nslookup", "-querytype="+qtype, name)
+	cmd.Stdout = &out
+	cmd.Stderr = &err
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+	r := strings.Replace(out.String(), "\r\n", "\n", -1)
+	// nslookup stderr output contains also debug information such as
+	// "Non-authoritative answer" and it doesn't return the correct errcode
+	if strings.Contains(err.String(), "can't find") {
+		return r, errors.New(err.String())
+	}
+	return r, nil
+}
+
+func nslookupMX(name string) (mx []*MX, err error) {
+	var r string
+	if r, err = nslookup("mx", name); err != nil {
+		return
+	}
+	mx = make([]*MX, 0, 10)
+	// linux nslookup syntax
+	// golang.org      mail exchanger = 2 alt1.aspmx.l.google.com.
+	rx := regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+mail exchanger\s*=\s*([0-9]+)\s*([a-z0-9.\-]+)$`)
+	for _, ans := range rx.FindAllStringSubmatch(r, -1) {
+		pref, _ := strconv.Atoi(ans[2])
+		mx = append(mx, &MX{fqdn(ans[3]), uint16(pref)})
+	}
+	// windows nslookup syntax
+	// gmail.com       MX preference = 30, mail exchanger = alt3.gmail-smtp-in.l.google.com
+	rx = regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+MX preference\s*=\s*([0-9]+)\s*,\s*mail exchanger\s*=\s*([a-z0-9.\-]+)$`)
+	for _, ans := range rx.FindAllStringSubmatch(r, -1) {
+		pref, _ := strconv.Atoi(ans[2])
+		mx = append(mx, &MX{fqdn(ans[3]), uint16(pref)})
+	}
+	return
+}
+
+func nslookupNS(name string) (ns []*NS, err error) {
+	var r string
+	if r, err = nslookup("ns", name); err != nil {
+		return
+	}
+	ns = make([]*NS, 0, 10)
+	// golang.org      nameserver = ns1.google.com.
+	rx := regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+nameserver\s*=\s*([a-z0-9.\-]+)$`)
+	for _, ans := range rx.FindAllStringSubmatch(r, -1) {
+		ns = append(ns, &NS{fqdn(ans[2])})
+	}
+	return
+}
+
+func nslookupCNAME(name string) (cname string, err error) {
+	var r string
+	if r, err = nslookup("cname", name); err != nil {
+		return
+	}
+	// mail.golang.com canonical name = golang.org.
+	rx := regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+canonical name\s*=\s*([a-z0-9.\-]+)$`)
+	// assumes the last CNAME is the correct one
+	last := name
+	for _, ans := range rx.FindAllStringSubmatch(r, -1) {
+		last = ans[2]
+	}
+	return fqdn(last), nil
+}
+
+func nslookupTXT(name string) (txt []string, err error) {
+	var r string
+	if r, err = nslookup("txt", name); err != nil {
+		return
+	}
+	txt = make([]string, 0, 10)
+	// linux
+	// golang.org      text = "v=spf1 redirect=_spf.google.com"
+
+	// windows
+	// golang.org      text =
+	//
+	//    "v=spf1 redirect=_spf.google.com"
+	rx := regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+text\s*=\s*"(.*)"$`)
+	for _, ans := range rx.FindAllStringSubmatch(r, -1) {
+		txt = append(txt, ans[2])
+	}
+	return
+}
diff --git a/src/pkg/syscall/syscall_windows.go b/src/pkg/syscall/syscall_windows.go
index 1fe1ae0fab..32a7aed001 100644
--- a/src/pkg/syscall/syscall_windows.go
+++ b/src/pkg/syscall/syscall_windows.go
@@ -549,6 +549,7 @@ const socket_error = uintptr(^uint32(0))
 //sys	GetProtoByName(name string) (p *Protoent, err error) [failretval==nil] = ws2_32.getprotobyname
 //sys	DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) = dnsapi.DnsQuery_W
 //sys	DnsRecordListFree(rl *DNSRecord, freetype uint32) = dnsapi.DnsRecordListFree
+//sys	DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) = dnsapi.DnsNameCompare_W
 //sys	GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) = ws2_32.GetAddrInfoW
 //sys	FreeAddrInfoW(addrinfo *AddrinfoW) = ws2_32.FreeAddrInfoW
 //sys	GetIfEntry(pIfRow *MibIfRow) (errcode error) = iphlpapi.GetIfEntry
diff --git a/src/pkg/syscall/zsyscall_windows_386.go b/src/pkg/syscall/zsyscall_windows_386.go
index d55211ee75..1f44750b7f 100644
--- a/src/pkg/syscall/zsyscall_windows_386.go
+++ b/src/pkg/syscall/zsyscall_windows_386.go
@@ -1,4 +1,4 @@
-// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go syscall_windows_386.go
+// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go
 // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
 package syscall
@@ -139,6 +139,7 @@ var (
 	procgetprotobyname                     = modws2_32.NewProc("getprotobyname")
 	procDnsQuery_W                         = moddnsapi.NewProc("DnsQuery_W")
 	procDnsRecordListFree                  = moddnsapi.NewProc("DnsRecordListFree")
+	procDnsNameCompare_W                   = moddnsapi.NewProc("DnsNameCompare_W")
 	procGetAddrInfoW                       = modws2_32.NewProc("GetAddrInfoW")
 	procFreeAddrInfoW                      = modws2_32.NewProc("FreeAddrInfoW")
 	procGetIfEntry                         = modiphlpapi.NewProc("GetIfEntry")
@@ -1634,6 +1635,12 @@ func DnsRecordListFree(rl *DNSRecord, freetype uint32) {
 	return
 }
 
+func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
+	r0, _, _ := Syscall(procDnsNameCompare_W.Addr(), 2, uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)), 0)
+	same = r0 != 0
+	return
+}
+
 func GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) {
 	r0, _, _ := Syscall6(procGetAddrInfoW.Addr(), 4, uintptr(unsafe.Pointer(nodename)), uintptr(unsafe.Pointer(servicename)), uintptr(unsafe.Pointer(hints)), uintptr(unsafe.Pointer(result)), 0, 0)
 	if r0 != 0 {
diff --git a/src/pkg/syscall/zsyscall_windows_amd64.go b/src/pkg/syscall/zsyscall_windows_amd64.go
index 47affab73d..1f44750b7f 100644
--- a/src/pkg/syscall/zsyscall_windows_amd64.go
+++ b/src/pkg/syscall/zsyscall_windows_amd64.go
@@ -1,4 +1,4 @@
-// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go syscall_windows_amd64.go
+// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go
 // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
 package syscall
@@ -139,6 +139,7 @@ var (
 	procgetprotobyname                     = modws2_32.NewProc("getprotobyname")
 	procDnsQuery_W                         = moddnsapi.NewProc("DnsQuery_W")
 	procDnsRecordListFree                  = moddnsapi.NewProc("DnsRecordListFree")
+	procDnsNameCompare_W                   = moddnsapi.NewProc("DnsNameCompare_W")
 	procGetAddrInfoW                       = modws2_32.NewProc("GetAddrInfoW")
 	procFreeAddrInfoW                      = modws2_32.NewProc("FreeAddrInfoW")
 	procGetIfEntry                         = modiphlpapi.NewProc("GetIfEntry")
@@ -1634,6 +1635,12 @@ func DnsRecordListFree(rl *DNSRecord, freetype uint32) {
 	return
 }
 
+func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
+	r0, _, _ := Syscall(procDnsNameCompare_W.Addr(), 2, uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)), 0)
+	same = r0 != 0
+	return
+}
+
 func GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) {
 	r0, _, _ := Syscall6(procGetAddrInfoW.Addr(), 4, uintptr(unsafe.Pointer(nodename)), uintptr(unsafe.Pointer(servicename)), uintptr(unsafe.Pointer(hints)), uintptr(unsafe.Pointer(result)), 0, 0)
 	if r0 != 0 {
diff --git a/src/pkg/syscall/ztypes_windows.go b/src/pkg/syscall/ztypes_windows.go
index 8b3625f146..1363da01a8 100644
--- a/src/pkg/syscall/ztypes_windows.go
+++ b/src/pkg/syscall/ztypes_windows.go
@@ -689,6 +689,18 @@ const (
 	DNS_TYPE_NBSTAT  = 0xff01
 )
 
+const (
+	DNS_INFO_NO_RECORDS = 0x251D
+)
+
+const (
+	// flags inside DNSRecord.Dw
+	DnsSectionQuestion   = 0x0000
+	DnsSectionAnswer     = 0x0001
+	DnsSectionAuthority  = 0x0002
+	DnsSectionAdditional = 0x0003
+)
+
 type DNSSRVData struct {
 	Target   *uint16
 	Priority uint16

From fb0b923f6731a029b30a91f8ff74f88cc8e96f67 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 15 Aug 2014 20:51:44 +0400
Subject: [PATCH 091/423] misc/nacl: add debugging instructions

LGTM=dave, minux
R=golang-codereviews, dave, minux
CC=golang-codereviews, rsc
https://golang.org/cl/122570043
---
 misc/nacl/README | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/misc/nacl/README b/misc/nacl/README
index 6f149f8ac8..2044b356b6 100644
--- a/misc/nacl/README
+++ b/misc/nacl/README
@@ -37,7 +37,7 @@ sdk. These are released every 6-8 weeks, in line with Chrome releases.
 	% cd /opt/nacl_sdk
 	% ./naclsdk update
 
-At this time pepper_33 is the stable version. If naclsdk downloads a later
+At this time pepper_34 is the stable version. If naclsdk downloads a later
 version, please adjust accordingly. As of June 2014, only the canary sdk
 provides support for nacl/arm.
 
@@ -45,8 +45,8 @@ The cmd/go helper scripts expect that the loaders sel_ldr_{x86_{32,64},arm} and
 nacl_helper_bootstrap_arm are in your path. I find it easiest to make a symlink
 from the NaCl distribution to my $GOPATH/bin directory.
 
-	% ln -nfs /opt/nacl_sdk/pepper_33/tools/sel_ldr_x86_32 $GOPATH/bin/sel_ldr_x86_32
-	% ln -nfs /opt/nacl_sdk/pepper_33/tools/sel_ldr_x86_64 $GOPATH/bin/sel_ldr_x86_64
+	% ln -nfs /opt/nacl_sdk/pepper_34/tools/sel_ldr_x86_32 $GOPATH/bin/sel_ldr_x86_32
+	% ln -nfs /opt/nacl_sdk/pepper_34/tools/sel_ldr_x86_64 $GOPATH/bin/sel_ldr_x86_64
 	% ln -nfs /opt/nacl_sdk/pepper_canary/tools/sel_ldr_arm $GOPATH/bin/sel_ldr_arm
 
 Additionally, for NaCl/ARM only:
@@ -92,3 +92,31 @@ tests.
 	% cd go/src
 	% env GOARCH=amd64p32 ./nacltest.bash
 
+Debugging
+---------
+
+Assuming that you have built nacl/amd64p32 binary ./mybin and can run as:
+
+	% sel_ldr_x86_64 -l /dev/null -S -e ./mybin
+
+Create the nacl manifest file mybin.manifest with the following contents:
+
+	{ "program": { "x86-64": { "url": "mybin" } } }
+
+url is the path to the binary relative to the manifest file.
+Then, run the program as:
+
+	% sel_ldr_x86_64 -g -l /dev/null -S -e ./mybin
+
+The -g flag instructs the loader to stop at startup. Then, in another console:
+
+	% /opt/nacl_sdk/pepper_34/toolchain/linux_x86_glibc/bin/x86_64-nacl-gdb
+	% nacl-manifest mybin.manifest
+	% target remote :4014
+
+If you see that the program is stopped in _rt0_amd64p32_nacl, then symbols are
+loaded successfully and you can type 'c' to start the program.
+Next time you can automate it as:
+
+	% /opt/nacl_sdk/pepper_34/toolchain/linux_x86_glibc/bin/x86_64-nacl-gdb \
+		-ex 'nacl-manifest mybin.manifest' -ex 'target remote :4014'

From 7f40e5e6e5b446a83577fa25a6bc0359b86d7c3a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 15 Aug 2014 11:33:31 -0700
Subject: [PATCH 092/423] cmd/gc: disallow pointer constants

Fixes #7760.

LGTM=iant
R=iant, remyoudompheng
CC=golang-codereviews
https://golang.org/cl/130720043
---
 src/cmd/gc/const.c          |  8 ++++++--
 test/fixedbugs/issue7760.go | 25 +++++++++++++++++++++++++
 2 files changed, 31 insertions(+), 2 deletions(-)
 create mode 100644 test/fixedbugs/issue7760.go

diff --git a/src/cmd/gc/const.c b/src/cmd/gc/const.c
index c01784a81b..e418b9c561 100644
--- a/src/cmd/gc/const.c
+++ b/src/cmd/gc/const.c
@@ -1566,7 +1566,6 @@ isgoconst(Node *n)
 	case ORSH:
 	case OSUB:
 	case OXOR:
-	case OCONV:
 	case OIOTA:
 	case OCOMPLEX:
 	case OREAL:
@@ -1574,7 +1573,12 @@ isgoconst(Node *n)
 		if(isgoconst(n->left) && (n->right == N || isgoconst(n->right)))
 			return 1;
 		break;
-	
+
+	case OCONV:
+		if(okforconst[n->type->etype] && isgoconst(n->left))
+			return 1;
+		break;
+
 	case OLEN:
 	case OCAP:
 		l = n->left;
diff --git a/test/fixedbugs/issue7760.go b/test/fixedbugs/issue7760.go
new file mode 100644
index 0000000000..cccae48910
--- /dev/null
+++ b/test/fixedbugs/issue7760.go
@@ -0,0 +1,25 @@
+// errorcheck
+
+// 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.
+
+// Verify that pointers can't be used as constants.
+
+package main
+
+import "unsafe"
+
+type myPointer unsafe.Pointer
+
+const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant"
+const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant"
+
+const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+
+const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+
+const _ = []byte("") // ERROR "is not (a )?constant"
+const _ = []rune("") // ERROR "is not (a )?constant"

From c5e648d684312b979e243077f909a798adbf6e5b Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 15 Aug 2014 22:36:12 +0400
Subject: [PATCH 093/423] runtime: fix getgcmask bv.data is an array of uint32s
 but the code was using offsets computed for an array of bytes. Add a test for
 stack GC info. Fixes #8531.

LGTM=rsc
R=golang-codereviews
CC=golang-codereviews, khr, rsc
https://golang.org/cl/124450043
---
 src/pkg/runtime/gcinfo_test.go | 56 +++++++++++++++++++++++-----------
 src/pkg/runtime/mgc0.c         |  2 +-
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/src/pkg/runtime/gcinfo_test.go b/src/pkg/runtime/gcinfo_test.go
index 6afa9a4e2b..892484ea6f 100644
--- a/src/pkg/runtime/gcinfo_test.go
+++ b/src/pkg/runtime/gcinfo_test.go
@@ -12,24 +12,30 @@ import (
 
 // TestGCInfo tests that various objects in heap, data and bss receive correct GC pointer type info.
 func TestGCInfo(t *testing.T) {
-	verifyGCInfo(t, "bss ScalarPtr", &bssScalarPtr, infoScalarPtr)
-	verifyGCInfo(t, "bss PtrScalar", &bssPtrScalar, infoPtrScalar)
-	verifyGCInfo(t, "bss Complex", &bssComplex, infoComplex())
-	verifyGCInfo(t, "bss string", &bssString, infoString)
-	verifyGCInfo(t, "bss eface", &bssEface, infoEface)
+	verifyGCInfo(t, "bss ScalarPtr", &bssScalarPtr, nonStackInfo(infoScalarPtr))
+	verifyGCInfo(t, "bss PtrScalar", &bssPtrScalar, nonStackInfo(infoPtrScalar))
+	verifyGCInfo(t, "bss Complex", &bssComplex, nonStackInfo(infoComplex()))
+	verifyGCInfo(t, "bss string", &bssString, nonStackInfo(infoString))
+	verifyGCInfo(t, "bss eface", &bssEface, nonStackInfo(infoEface))
 
-	verifyGCInfo(t, "data ScalarPtr", &dataScalarPtr, infoScalarPtr)
-	verifyGCInfo(t, "data PtrScalar", &dataPtrScalar, infoPtrScalar)
-	verifyGCInfo(t, "data Complex", &dataComplex, infoComplex())
-	verifyGCInfo(t, "data string", &dataString, infoString)
-	verifyGCInfo(t, "data eface", &dataEface, infoEface)
+	verifyGCInfo(t, "data ScalarPtr", &dataScalarPtr, nonStackInfo(infoScalarPtr))
+	verifyGCInfo(t, "data PtrScalar", &dataPtrScalar, nonStackInfo(infoPtrScalar))
+	verifyGCInfo(t, "data Complex", &dataComplex, nonStackInfo(infoComplex()))
+	verifyGCInfo(t, "data string", &dataString, nonStackInfo(infoString))
+	verifyGCInfo(t, "data eface", &dataEface, nonStackInfo(infoEface))
+
+	verifyGCInfo(t, "stack ScalarPtr", new(ScalarPtr), infoScalarPtr)
+	verifyGCInfo(t, "stack PtrScalar", new(PtrScalar), infoPtrScalar)
+	verifyGCInfo(t, "stack Complex", new(Complex), infoComplex())
+	verifyGCInfo(t, "stack string", new(string), infoString)
+	verifyGCInfo(t, "stack eface", new(interface{}), infoEface)
 
 	for i := 0; i < 3; i++ {
-		verifyGCInfo(t, "heap ScalarPtr", escape(new(ScalarPtr)), infoScalarPtr)
-		verifyGCInfo(t, "heap PtrScalar", escape(new(PtrScalar)), infoPtrScalar)
-		verifyGCInfo(t, "heap Complex", escape(new(Complex)), infoComplex())
-		verifyGCInfo(t, "heap string", escape(new(string)), infoString)
-		verifyGCInfo(t, "heap eface", escape(new(interface{})), infoEface)
+		verifyGCInfo(t, "heap ScalarPtr", escape(new(ScalarPtr)), nonStackInfo(infoScalarPtr))
+		verifyGCInfo(t, "heap PtrScalar", escape(new(PtrScalar)), nonStackInfo(infoPtrScalar))
+		verifyGCInfo(t, "heap Complex", escape(new(Complex)), nonStackInfo(infoComplex()))
+		verifyGCInfo(t, "heap string", escape(new(string)), nonStackInfo(infoString))
+		verifyGCInfo(t, "heap eface", escape(new(interface{})), nonStackInfo(infoEface))
 	}
 
 }
@@ -46,6 +52,20 @@ func verifyGCInfo(t *testing.T, name string, p interface{}, mask0 []byte) {
 	}
 }
 
+func nonStackInfo(mask []byte) []byte {
+	// BitsDead is replaced with BitsScalar everywhere except stacks.
+	mask1 := make([]byte, len(mask))
+	mw := false
+	for i, v := range mask {
+		if !mw && v == BitsDead {
+			v = BitsScalar
+		}
+		mw = !mw && v == BitsMultiWord
+		mask1[i] = v
+	}
+	return mask1
+}
+
 var gcinfoSink interface{}
 
 func escape(p interface{}) interface{} {
@@ -106,20 +126,20 @@ func infoComplex() []byte {
 		return []byte{
 			BitsPointer, BitsScalar, BitsScalar, BitsScalar,
 			BitsScalar, BitsScalar, BitsMultiWord, BitsSlice,
-			BitsScalar, BitsScalar, BitsScalar, BitsScalar,
+			BitsDead, BitsScalar, BitsScalar, BitsScalar,
 			BitsScalar, BitsMultiWord, BitsString,
 		}
 	case "amd64":
 		return []byte{
 			BitsPointer, BitsScalar, BitsScalar, BitsScalar,
-			BitsMultiWord, BitsSlice, BitsScalar, BitsScalar,
+			BitsMultiWord, BitsSlice, BitsDead, BitsScalar,
 			BitsScalar, BitsScalar, BitsMultiWord, BitsString,
 		}
 	case "amd64p32":
 		return []byte{
 			BitsPointer, BitsScalar, BitsScalar, BitsScalar,
 			BitsScalar, BitsScalar, BitsMultiWord, BitsSlice,
-			BitsScalar, BitsScalar, BitsScalar, BitsScalar,
+			BitsDead, BitsScalar, BitsScalar, BitsDead,
 			BitsScalar, BitsScalar, BitsMultiWord, BitsString,
 		}
 	default:
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 6e307bfce4..59dfd51e65 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -2087,7 +2087,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
 			off = (p+i-frame.varp+size)/PtrSize;
-			bits = (bv.data[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
+			bits = (bv.data[off*BitsPerPointer/32] >> ((off*BitsPerPointer)%32))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
 	}

From 4edcbe0d40ec54e92cf7e8d662e11635e173b933 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Fri, 15 Aug 2014 11:41:12 -0700
Subject: [PATCH 094/423] fmt: fix size returned on fast path of ReadRune Fixes
 #8512.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/130090043
---
 src/pkg/fmt/scan.go      |  1 +
 src/pkg/fmt/scan_test.go | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/src/pkg/fmt/scan.go b/src/pkg/fmt/scan.go
index 8a337e479d..d7befeae43 100644
--- a/src/pkg/fmt/scan.go
+++ b/src/pkg/fmt/scan.go
@@ -360,6 +360,7 @@ func (r *readRune) ReadRune() (rr rune, size int, err error) {
 	}
 	if r.buf[0] < utf8.RuneSelf { // fast check for common ASCII case
 		rr = rune(r.buf[0])
+		size = 1 // Known to be 1.
 		return
 	}
 	var n int
diff --git a/src/pkg/fmt/scan_test.go b/src/pkg/fmt/scan_test.go
index d903f0c3ff..541e12df21 100644
--- a/src/pkg/fmt/scan_test.go
+++ b/src/pkg/fmt/scan_test.go
@@ -842,6 +842,38 @@ func TestLineByLineFscanf(t *testing.T) {
 	}
 }
 
+// TestScanStateCount verifies the correct byte count is returned. Issue 8512.
+
+// runeScanner implements the Scanner interface for TestScanStateCount.
+type runeScanner struct {
+	rune rune
+	size int
+}
+
+func (rs *runeScanner) Scan(state ScanState, verb rune) error {
+	r, size, err := state.ReadRune()
+	rs.rune = r
+	rs.size = size
+	return err
+}
+
+func TestScanStateCount(t *testing.T) {
+	var a, b, c runeScanner
+	n, err := Sscanf("12➂", "%c%c%c", &a, &b, &c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != 3 {
+		t.Fatalf("expected 3 items consumed, got %d")
+	}
+	if a.rune != '1' || b.rune != '2' || c.rune != '➂' {
+		t.Errorf("bad scan rune: %q %q %q should be '1' '2' '➂'", a.rune, b.rune, c.rune)
+	}
+	if a.size != 1 || b.size != 1 || c.size != 3 {
+		t.Errorf("bad scan size: %q %q %q should be 1 1 3", a.size, b.size, c.size)
+	}
+}
+
 // RecursiveInt accepts a string matching %d.%d.%d....
 // and parses it into a linked list.
 // It allows us to benchmark recursive descent style scanners.

From ab0b0d903168de23aaa76d3122f99856d24a4407 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Fri, 15 Aug 2014 12:35:01 -0700
Subject: [PATCH 095/423] cmd/go: fix a couple of errors found by "go vet"

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/127410043
---
 src/cmd/go/build.go    | 2 +-
 src/cmd/go/vcs_test.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 591eb1620a..fd92ca2783 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -885,7 +885,7 @@ func (b *builder) build(a *action) (err error) {
 	}
 
 	if len(gofiles) == 0 {
-		return &build.NoGoError{a.p.Dir}
+		return &build.NoGoError{Dir: a.p.Dir}
 	}
 
 	// If we're doing coverage, preprocess the .go files and put them in the work directory
diff --git a/src/cmd/go/vcs_test.go b/src/cmd/go/vcs_test.go
index 3097c4d1c5..14d681ba6a 100644
--- a/src/cmd/go/vcs_test.go
+++ b/src/cmd/go/vcs_test.go
@@ -109,7 +109,7 @@ func TestRepoRootForImportPath(t *testing.T) {
 
 		if want == nil {
 			if err == nil {
-				t.Errorf("RepoRootForImport(%q): Error expected but not received")
+				t.Errorf("RepoRootForImport(%q): Error expected but not received", test.path)
 			}
 			continue
 		}

From 40182102e3a6caffb3b01de90b6a7c04276d0465 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 15 Aug 2014 15:18:39 -0700
Subject: [PATCH 096/423] A+C: Henning Schmiedehausen (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/130140043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 9aa3419715..893c7945f3 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -179,6 +179,7 @@ Gustavo Niemeyer <gustavo@niemeyer.net>
 Gwenael Treguier <gwenn.kahz@gmail.com>
 Harley Laue <losinggeneration@gmail.com>
 Hector Chu <hectorchu@gmail.com>
+Henning Schmiedehausen <henning@schmiedehausen.org>
 Henrik Edwards <henrik.edwards@gmail.com>
 Herbert Georg Fischer <herbert.fischer@gmail.com>
 Hong Ruiqi <hongruiqi@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 2dbf02d4af..8ccecfee5d 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -254,6 +254,7 @@ Gwenael Treguier <gwenn.kahz@gmail.com>
 Han-Wen Nienhuys <hanwen@google.com>
 Harley Laue <losinggeneration@gmail.com>
 Hector Chu <hectorchu@gmail.com>
+Henning Schmiedehausen <henning@schmiedehausen.org>
 Henrik Edwards <henrik.edwards@gmail.com>
 Herbert Georg Fischer <herbert.fischer@gmail.com>
 Hong Ruiqi <hongruiqi@gmail.com>

From 7eba885ba5fa2b077b95e32e4ba435aa340d0957 Mon Sep 17 00:00:00 2001
From: Henning Schmiedehausen <henning@schmiedehausen.org>
Date: Fri, 15 Aug 2014 15:19:02 -0700
Subject: [PATCH 097/423] cmd/dist: goc2c ignores GOROOT_FINAL

When building golang, the environment variable GOROOT_FINAL can be set
to indicate a different installation location from the build
location. This works fine, except that the goc2c build step embeds
line numbers in the resulting c source files that refer to the build
location, no the install location.

This would not be a big deal, except that in turn the linker uses the
location of runtime/string.goc to embed the gdb script in the
resulting binary and as a net result, the debugger now complains that
the script is outside its load path (it has the install location
configured).

See https://code.google.com/p/go/issues/detail?id=8524 for the full
description.

Fixes #8524.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/128230046
---
 src/cmd/dist/a.h     | 2 +-
 src/cmd/dist/build.c | 8 ++++++--
 src/cmd/dist/goc2c.c | 8 +++++---
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/cmd/dist/a.h b/src/cmd/dist/a.h
index 6222e50604..2500f038c8 100644
--- a/src/cmd/dist/a.h
+++ b/src/cmd/dist/a.h
@@ -109,7 +109,7 @@ void	mkzexperiment(char*, char*);
 void	mkzdefaultcc(char*, char*);
 
 // goc2c.c
-void	goc2c(char*, char*);
+void	goc2c(char*, char*, char*);
 
 // main.c
 extern int vflag;
diff --git a/src/cmd/dist/build.c b/src/cmd/dist/build.c
index 2e857559b8..11fecbfad6 100644
--- a/src/cmd/dist/build.c
+++ b/src/cmd/dist/build.c
@@ -640,7 +640,7 @@ install(char *dir)
 {
 	char *name, *p, *elem, *prefix, *exe;
 	bool islib, ispkg, isgo, stale, ispackcmd;
-	Buf b, b1, path;
+	Buf b, b1, path, final_path, final_name;
 	Vec compile, files, link, go, missing, clean, lib, extra;
 	Time ttarg, t;
 	int i, j, k, n, doclean, targ;
@@ -655,6 +655,8 @@ install(char *dir)
 	binit(&b);
 	binit(&b1);
 	binit(&path);
+	binit(&final_path);
+	binit(&final_name);
 	vinit(&compile);
 	vinit(&files);
 	vinit(&link);
@@ -667,6 +669,7 @@ install(char *dir)
 
 	// path = full path to dir.
 	bpathf(&path, "%s/src/%s", goroot, dir);
+	bpathf(&final_path, "%s/src/%s", goroot_final, dir);
 	name = lastelem(dir);
 
 	// For misc/prof, copy into the tool directory and we're done.
@@ -939,9 +942,10 @@ install(char *dir)
 				continue;
 			// b = path/zp but with _goos_goarch.c instead of .goc
 			bprintf(&b, "%s%sz%s", bstr(&path), slash, lastelem(p));
+			bprintf(&final_name, "%s%s%s", bstr(&final_path), slash, lastelem(p));
 			b.len -= 4;
 			bwritef(&b, "_%s_%s.c", goos, goarch);
-			goc2c(p, bstr(&b));
+			goc2c(p, bstr(&final_name), bstr(&b));
 			vadd(&files, bstr(&b));
 		}
 		vuniq(&files);
diff --git a/src/cmd/dist/goc2c.c b/src/cmd/dist/goc2c.c
index 38627657ec..a24fbfe204 100644
--- a/src/cmd/dist/goc2c.c
+++ b/src/cmd/dist/goc2c.c
@@ -66,6 +66,7 @@ static int gcc;
 
 /* File and line number */
 static const char *file;
+static const char *final_file;
 static unsigned int lineno;
 
 /* List of names and types.  */
@@ -474,7 +475,7 @@ read_func_header(char **name, struct params **params, int *paramwid, struct para
 			if (lastline == lineno-1)
 				bwritef(output, "\n");
 			else
-				bwritef(output, "\n#line %d \"%s\"\n", lineno, file);
+				bwritef(output, "\n#line %d \"%s\"\n", lineno, final_file);
 			lastline = lineno;
 		}
 		bwritef(output, "%s ", token);
@@ -658,7 +659,7 @@ write_func_header(char *package, char *name,
 		write_gcc_func_header(package, name, params, rets);
 	else
 		write_6g_func_header(package, name, params, paramwid, rets);
-	bwritef(output, "#line %d \"%s\"\n", lineno, file);
+	bwritef(output, "#line %d \"%s\"\n", lineno, final_file);
 }
 
 /* Write out a function trailer.  */
@@ -772,7 +773,7 @@ process_file(void)
 }
 
 void
-goc2c(char *goc, char *c)
+goc2c(char *goc, char *goc_final, char *c)
 {
 	int i;
 	Buf in, out;
@@ -781,6 +782,7 @@ goc2c(char *goc, char *c)
 	binit(&out);
 	
 	file = goc;
+	final_file = goc_final;
 	readfile(&in, goc);
 
 	// TODO: set gcc=1 when using gcc

From a7295523336cd5af59e50442071471402f3966c9 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Fri, 15 Aug 2014 17:47:02 -0700
Subject: [PATCH 098/423] crypto/x509: SystemRootsError style tweaks, document
 in Verify

In retrospect this should've been a variable instead of a type,
but oh well.

LGTM=agl
R=agl
CC=golang-codereviews
https://golang.org/cl/129250044
---
 src/pkg/crypto/x509/verify.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/pkg/crypto/x509/verify.go b/src/pkg/crypto/x509/verify.go
index 5fd8e37174..ec1981423d 100644
--- a/src/pkg/crypto/x509/verify.go
+++ b/src/pkg/crypto/x509/verify.go
@@ -116,10 +116,9 @@ func (e UnknownAuthorityError) Error() string {
 }
 
 // SystemRootsError results when we fail to load the system root certificates.
-type SystemRootsError struct {
-}
+type SystemRootsError struct{}
 
-func (e SystemRootsError) Error() string {
+func (SystemRootsError) Error() string {
 	return "x509: failed to load system roots and no roots provided"
 }
 
@@ -206,6 +205,9 @@ func (c *Certificate) isValid(certType int, currentChain []*Certificate, opts *V
 // needed. If successful, it returns one or more chains where the first
 // element of the chain is c and the last element is from opts.Roots.
 //
+// If opts.Roots is nil and system roots are unavailable the returned error
+// will be of type SystemRootsError.
+//
 // WARNING: this doesn't do any revocation checking.
 func (c *Certificate) Verify(opts VerifyOptions) (chains [][]*Certificate, err error) {
 	// Use Windows's own verification and chain building.

From 41d75933d79bc094a5e522bf67e6e182cbd65450 Mon Sep 17 00:00:00 2001
From: Shenghou Ma <minux@golang.org>
Date: Sat, 16 Aug 2014 14:04:15 +1000
Subject: [PATCH 099/423] cmd/ld: fix operator precedence

LGTM=rsc
R=gobot, dave
CC=golang-codereviews, iant, rsc
https://golang.org/cl/114420043
---
 src/cmd/ld/data.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/ld/data.c b/src/cmd/ld/data.c
index c0dc3d05f2..1919123b49 100644
--- a/src/cmd/ld/data.c
+++ b/src/cmd/ld/data.c
@@ -145,7 +145,7 @@ relocsym(LSym *s)
 			diag("%s: invalid relocation %d+%d not in [%d,%d)", s->name, off, siz, 0, s->np);
 			continue;
 		}
-		if(r->sym != S && (r->sym->type & SMASK == 0 || r->sym->type & SMASK == SXREF)) {
+		if(r->sym != S && ((r->sym->type & SMASK) == 0 || (r->sym->type & SMASK) == SXREF)) {
 			diag("%s: not defined", r->sym->name);
 			continue;
 		}

From 78cc89ce6740057bfbf9da211102c75659f83c89 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Sat, 16 Aug 2014 14:10:35 +1000
Subject: [PATCH 100/423] cmd/ld: fix operator precedence

Fixes #8480.

This CL reapplies CL 114420043. This attempt doesn't blow up when encountering hidden symbols.

LGTM=minux
R=minux
CC=golang-codereviews
https://golang.org/cl/128310043
---
 src/cmd/ld/data.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/ld/data.c b/src/cmd/ld/data.c
index 1919123b49..f76ac0129c 100644
--- a/src/cmd/ld/data.c
+++ b/src/cmd/ld/data.c
@@ -145,7 +145,7 @@ relocsym(LSym *s)
 			diag("%s: invalid relocation %d+%d not in [%d,%d)", s->name, off, siz, 0, s->np);
 			continue;
 		}
-		if(r->sym != S && ((r->sym->type & SMASK) == 0 || (r->sym->type & SMASK) == SXREF)) {
+		if(r->sym != S && ((r->sym->type & (SMASK | SHIDDEN)) == 0 || (r->sym->type & SMASK) == SXREF)) {
 			diag("%s: not defined", r->sym->name);
 			continue;
 		}

From c6fe53a230e70bbb7a5582afe96cacf174eb0335 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sat, 16 Aug 2014 09:07:55 +0400
Subject: [PATCH 101/423] runtime: mark with non-atomic operations when
 GOMAXPROCS=1 Perf builders show 3-5% GC pause increase with GOMAXPROCS=1 when
 marking with atomic ops:
 http://goperfd.appspot.com/perfdetail?commit=a8a6e765d6a87f7ccb71fd85a60eb5a821151f85&commit0=3b864e02b987171e05e2e9d0840b85b5b6476386&kind=builder&builder=linux-amd64&benchmark=http

LGTM=rlh
R=golang-codereviews, rlh
CC=dave, golang-codereviews, khr, rsc
https://golang.org/cl/128340043
---
 src/pkg/runtime/mgc0.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 59dfd51e65..f46d329017 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -451,7 +451,8 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 			// quadruple is already marked. Otherwise we resort to CAS
 			// loop for marking.
 			bits8 = xbits>>(shift&~7);
-			if((bits8&(bitMask|(bitMask<<gcBits))) != (bitBoundary|(bitBoundary<<gcBits)))
+			if((bits8&(bitMask|(bitMask<<gcBits))) != (bitBoundary|(bitBoundary<<gcBits)) ||
+				work.nproc == 1)
 				((uint8*)bitp)[shift/8] = bits8 | (bitMarked<<(shift&7));
 			else {
 				for(;;) {

From 30940cfad6c45d40bec377aeacc10f6964e75b76 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 18 Aug 2014 16:33:39 +0400
Subject: [PATCH 102/423] runtime: don't acquirem on malloc fast path Mallocgc
 must be atomic wrt GC, but for performance reasons don't acquirem/releasem on
 fast path. The code does not have split stack checks, so it can't be
 preempted by GC. Functions like roundup/add are inlined. And onM/racemalloc
 are nosplit. Also add debug code that checks these assumptions.

benchmark                     old ns/op     new ns/op     delta
BenchmarkMalloc8              20.5          17.2          -16.10%
BenchmarkMalloc16             29.5          27.0          -8.47%
BenchmarkMallocTypeInfo8      31.5          27.6          -12.38%
BenchmarkMallocTypeInfo16     34.7          30.9          -10.95%

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/123100043
---
 src/cmd/api/goapi.go      |  5 ++-
 src/pkg/runtime/malloc.go | 67 ++++++++++++++++++++++++++++++++-------
 src/pkg/runtime/race.c    |  2 ++
 src/pkg/runtime/stubs.go  |  1 +
 src/pkg/runtime/stubs.goc |  5 +++
 5 files changed, 67 insertions(+), 13 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 38bf9592f2..e0d17c9564 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -378,7 +378,10 @@ 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.
-		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{}; type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{}; type iface struct{}; type eface struct{}; type interfacetype struct{}; type itab struct{}"
+		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{};" +
+			" type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{};" +
+			" type iface struct{}; type eface struct{}; type interfacetype struct{}; type itab struct{};" +
+			" type mcache struct{}"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 76c06f314b..f116efaba4 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -59,14 +59,25 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 	if size == 0 {
 		return unsafe.Pointer(&zeroObject)
 	}
-	mp := acquirem()
-	if mp.mallocing != 0 {
-		gothrow("malloc/free - deadlock")
-	}
-	mp.mallocing = 1
 	size0 := size
 
-	c := mp.mcache
+	// This function must be atomic wrt GC, but for performance reasons
+	// we don't acquirem/releasem on fast path. The code below does not have
+	// split stack checks, so it can't be preempted by GC.
+	// Functions like roundup/add are inlined. And onM/racemalloc are nosplit.
+	// If debugMalloc = true, these assumptions are checked below.
+	if debugMalloc {
+		mp := acquirem()
+		if mp.mallocing != 0 {
+			gothrow("malloc deadlock")
+		}
+		mp.mallocing = 1
+		if mp.curg != nil {
+			mp.curg.stackguard0 = ^uint(0xfff) | 0xbad
+		}
+	}
+
+	c := gomcache()
 	var s *mspan
 	var x unsafe.Pointer
 	if size <= maxSmallSize {
@@ -118,8 +129,18 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 					x = tiny
 					c.tiny = (*byte)(add(x, size))
 					c.tinysize -= uint(size1)
-					mp.mallocing = 0
-					releasem(mp)
+					if debugMalloc {
+						mp := acquirem()
+						if mp.mallocing == 0 {
+							gothrow("bad malloc")
+						}
+						mp.mallocing = 0
+						if mp.curg != nil {
+							mp.curg.stackguard0 = mp.curg.stackguard
+						}
+						releasem(mp)
+						releasem(mp)
+					}
 					return x
 				}
 			}
@@ -127,8 +148,10 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			s = c.alloc[tinySizeClass]
 			v := s.freelist
 			if v == nil {
+				mp := acquirem()
 				mp.scalararg[0] = tinySizeClass
 				onM(&mcacheRefill_m)
+				releasem(mp)
 				s = c.alloc[tinySizeClass]
 				v = s.freelist
 			}
@@ -156,8 +179,10 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			s = c.alloc[sizeclass]
 			v := s.freelist
 			if v == nil {
+				mp := acquirem()
 				mp.scalararg[0] = uint(sizeclass)
 				onM(&mcacheRefill_m)
+				releasem(mp)
 				s = c.alloc[sizeclass]
 				v = s.freelist
 			}
@@ -174,11 +199,13 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		}
 		c.local_cachealloc += int(size)
 	} else {
+		mp := acquirem()
 		mp.scalararg[0] = uint(size)
 		mp.scalararg[1] = uint(flags)
 		onM(&largeAlloc_m)
 		s = (*mspan)(mp.ptrarg[0])
 		mp.ptrarg[0] = nil
+		releasem(mp)
 		x = unsafe.Pointer(uintptr(s.start << pageShift))
 		size = uintptr(s.elemsize)
 	}
@@ -221,18 +248,22 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 					// into the GC bitmap. It's 7 times slower than copying
 					// from the pre-unrolled mask, but saves 1/16 of type size
 					// memory for the mask.
+					mp := acquirem()
 					mp.ptrarg[0] = x
 					mp.ptrarg[1] = unsafe.Pointer(typ)
 					mp.scalararg[0] = uint(size)
 					mp.scalararg[1] = uint(size0)
 					onM(&unrollgcproginplace_m)
+					releasem(mp)
 					goto marked
 				}
 				ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
 				// Check whether the program is already unrolled.
 				if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
+					mp := acquirem()
 					mp.ptrarg[0] = unsafe.Pointer(typ)
 					onM(&unrollgcprog_m)
+					releasem(mp)
 				}
 				ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
 			} else {
@@ -287,11 +318,23 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		}
 	}
 marked:
-	mp.mallocing = 0
-
 	if raceenabled {
 		racemalloc(x, size)
 	}
+
+	if debugMalloc {
+		mp := acquirem()
+		if mp.mallocing == 0 {
+			gothrow("bad malloc")
+		}
+		mp.mallocing = 0
+		if mp.curg != nil {
+			mp.curg.stackguard0 = mp.curg.stackguard
+		}
+		releasem(mp)
+		releasem(mp)
+	}
+
 	if debug.allocfreetrace != 0 {
 		tracealloc(x, size, typ)
 	}
@@ -300,12 +343,12 @@ marked:
 		if size < uintptr(rate) && int32(size) < c.next_sample {
 			c.next_sample -= int32(size)
 		} else {
+			mp := acquirem()
 			profilealloc(mp, x, size)
+			releasem(mp)
 		}
 	}
 
-	releasem(mp)
-
 	if memstats.heap_alloc >= memstats.next_gc {
 		gogc(0)
 	}
diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index 12cc6a0dd8..fa04a39310 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -11,6 +11,7 @@
 #include "race.h"
 #include "type.h"
 #include "typekind.h"
+#include "../../cmd/ld/textflag.h"
 
 // Race runtime functions called via runtime·racecall.
 void __tsan_init(void);
@@ -106,6 +107,7 @@ runtime·racemapshadow(void *addr, uintptr size)
 	runtime·racecall(__tsan_map_shadow, addr, size);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racemalloc(void *p, uintptr sz)
 {
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 9c18434d5d..a4ef9d3d55 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -43,6 +43,7 @@ func roundup(p unsafe.Pointer, n uintptr) unsafe.Pointer {
 // in stubs.goc
 func acquirem() *m
 func releasem(mp *m)
+func gomcache() *mcache
 
 // An mFunction represents a C function that runs on the M stack.  It
 // can be called from Go using mcall or onM.  Through the magic of
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index 8a043c63b0..e646b55181 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -83,6 +83,11 @@ func runtime·releasem(mp *M) {
 	}
 }
 
+#pragma textflag NOSPLIT
+func runtime·gomcache() (ret *MCache) {
+	ret = g->m->mcache;
+}
+
 // For testing.
 // TODO: find a better place for this.
 func GCMask(x Eface) (mask Slice) {

From 101c00a44f1ebb27b670f17bfb80ab315ef2a429 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 18 Aug 2014 16:42:24 +0400
Subject: [PATCH 103/423] runtime: fix dump of data/bss Fixes #8530.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rsc
https://golang.org/cl/124440043
---
 src/pkg/runtime/heapdump.c |  6 ++---
 src/pkg/runtime/mgc0.c     | 45 ++++++++++++++++----------------------
 src/pkg/runtime/proc.c     |  1 +
 src/pkg/runtime/runtime.h  |  3 +++
 4 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index e5032783a8..aa817fceec 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -23,8 +23,6 @@ extern byte data[];
 extern byte edata[];
 extern byte bss[];
 extern byte ebss[];
-extern byte gcdata[];
-extern byte gcbss[];
 
 enum {
 	FieldKindEol = 0,
@@ -497,13 +495,13 @@ dumproots(void)
 	dumpint(TagData);
 	dumpint((uintptr)data);
 	dumpmemrange(data, edata - data);
-	dumpfields((BitVector){(edata - data)*8, (uint32*)gcdata});
+	dumpfields((BitVector){(edata - data)*8, (uint32*)runtime·gcdatamask});
 
 	// bss segment
 	dumpint(TagBss);
 	dumpint((uintptr)bss);
 	dumpmemrange(bss, ebss - bss);
-	dumpfields((BitVector){(ebss - bss)*8, (uint32*)gcbss});
+	dumpfields((BitVector){(ebss - bss)*8, (uint32*)runtime·gcbssmask});
 
 	// MSpan.types
 	allspans = runtime·mheap.allspans;
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index f46d329017..5389538eae 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -78,10 +78,9 @@ enum {
 };
 
 #define ScanConservatively ((byte*)1)
-#define GcpercentUnknown (-2)
 
 // Initialized from $GOGC.  GOGC=off means no gc.
-extern int32 runtime·gcpercent = GcpercentUnknown;
+extern int32 runtime·gcpercent;
 
 static FuncVal* poolcleanup;
 
@@ -172,6 +171,8 @@ static FinBlock	*finc;		// cache of free blocks
 static FinBlock	*allfin;	// list of all blocks
 bool	runtime·fingwait;
 bool	runtime·fingwake;
+byte*	runtime·gcdatamask;
+byte*	runtime·gcbssmask;
 
 static Lock	gclock;
 
@@ -200,8 +201,6 @@ static struct {
 	volatile uint32	ndone;
 	Note	alldone;
 	ParFor*	markfor;
-	byte*	gcdata;
-	byte*	gcbss;
 } work;
 
 // scanblock scans a block of n bytes starting at pointer b for references
@@ -517,11 +516,11 @@ markroot(ParFor *desc, uint32 i)
 	// Note: if you add a case here, please also update heapdump.c:dumproots.
 	switch(i) {
 	case RootData:
-		scanblock(data, edata - data, work.gcdata);
+		scanblock(data, edata - data, runtime·gcdatamask);
 		break;
 
 	case RootBss:
-		scanblock(bss, ebss - bss, work.gcbss);
+		scanblock(bss, ebss - bss, runtime·gcbssmask);
 		break;
 
 	case RootFinalizers:
@@ -1300,6 +1299,18 @@ runtime·readgogc(void)
 	return runtime·atoi(p);
 }
 
+void
+runtime·gcinit(void)
+{
+	if(sizeof(Workbuf) != WorkbufSize)
+		runtime·throw("runtime: size of Workbuf is suboptimal");
+
+	work.markfor = runtime·parforalloc(MaxGcproc);
+	runtime·gcpercent = runtime·readgogc();
+	runtime·gcdatamask = unrollglobgcprog(gcdata, edata - data);
+	runtime·gcbssmask = unrollglobgcprog(gcbss, ebss - bss);
+}
+
 // force = 1 - do GC regardless of current heap usage
 // force = 2 - go GC and eager sweep
 void
@@ -1308,8 +1319,6 @@ runtime·gc(int32 force)
 	struct gc_args a;
 	int32 i;
 
-	if(sizeof(Workbuf) != WorkbufSize)
-		runtime·throw("runtime: size of Workbuf is suboptimal");
 	// The gc is turned off (via enablegc) until
 	// the bootstrap has completed.
 	// Also, malloc gets called in the guts
@@ -1321,12 +1330,6 @@ runtime·gc(int32 force)
 	if(!mstats.enablegc || g == g->m->g0 || g->m->locks > 0 || runtime·panicking)
 		return;
 
-	if(runtime·gcpercent == GcpercentUnknown) {	// first time through
-		runtime·lock(&runtime·mheap.lock);
-		if(runtime·gcpercent == GcpercentUnknown)
-			runtime·gcpercent = runtime·readgogc();
-		runtime·unlock(&runtime·mheap.lock);
-	}
 	if(runtime·gcpercent < 0)
 		return;
 
@@ -1415,14 +1418,6 @@ gc(struct gc_args *args)
 	t0 = args->start_time;
 	work.tstart = args->start_time; 
 
-	if(work.gcdata == nil) {
-		work.gcdata = unrollglobgcprog(gcdata, edata - data);
-		work.gcbss = unrollglobgcprog(gcbss, ebss - bss);
-	}
-
-	if(work.markfor == nil)
-		work.markfor = runtime·parforalloc(MaxGcproc);
-
 	t1 = 0;
 	if(runtime·debug.gctrace)
 		t1 = runtime·nanotime();
@@ -1598,8 +1593,6 @@ runtime·setgcpercent(int32 in) {
 	int32 out;
 
 	runtime·lock(&runtime·mheap.lock);
-	if(runtime·gcpercent == GcpercentUnknown)
-		runtime·gcpercent = runtime·readgogc();
 	out = runtime·gcpercent;
 	if(in < 0)
 		in = -1;
@@ -2027,7 +2020,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
 			off = (p+i-data)/PtrSize;
-			bits = (work.gcdata[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
+			bits = (runtime·gcdatamask[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
 		return;
@@ -2039,7 +2032,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
 			off = (p+i-bss)/PtrSize;
-			bits = (work.gcbss[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
+			bits = (runtime·gcbssmask[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
 		return;
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 443bdda100..a3e0f4bc52 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -158,6 +158,7 @@ runtime·schedinit(void)
 	runtime·symtabinit();
 	runtime·stackinit();
 	runtime·mallocinit();
+	runtime·gcinit();
 	runtime·chaninit();
 	mcommoninit(g->m);
 	
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 62100a783a..0aeba39da8 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -779,6 +779,8 @@ extern	uint32	runtime·cpuid_ecx;
 extern	uint32	runtime·cpuid_edx;
 extern	DebugVars	runtime·debug;
 extern	uintptr	runtime·maxstacksize;
+extern	byte*	runtime·gcdatamask;
+extern	byte*	runtime·gcbssmask;
 
 /*
  * common functions and data
@@ -880,6 +882,7 @@ void	runtime·shrinkstack(G*);
 MCache*	runtime·allocmcache(void);
 void	runtime·freemcache(MCache*);
 void	runtime·mallocinit(void);
+void	runtime·gcinit(void);
 void	runtime·chaninit(void);
 void*	runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void	runtime·runpanic(Panic*);

From e0df11d57e7bffa9af6cad8b480fac37bc59fbf1 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 18 Aug 2014 16:52:31 +0400
Subject: [PATCH 104/423] runtime: implement transfer cache Currently we do the
 following dance after sweeping a span: 1. lock mcentral 2. remove the span
 from a list 3. unlock mcentral 4. unmark span 5. lock mheap 6. insert the
 span into heap 7. unlock mheap 8. lock mcentral 9. observe empty list 10.
 unlock mcentral 11. lock mheap 12. grab the span 13. unlock mheap 14. mark
 span 15. lock mcentral 16. insert the span into empty list 17. unlock
 mcentral

This change short-circuits this sequence to nothing,
that is, we just cache and use the span after sweeping.

This gives us functionality similar (even better) to tcmalloc's transfer cache.

benchmark            old ns/op     new ns/op     delta
BenchmarkMalloc8     22.2          19.5          -12.16%
BenchmarkMalloc16    31.0          26.6          -14.19%

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/119550043
---
 src/pkg/runtime/malloc.h   |  4 +-
 src/pkg/runtime/mcentral.c | 86 +++++++++++++++++++++-----------------
 src/pkg/runtime/mgc0.c     | 12 ++++--
 src/pkg/runtime/mheap.c    |  2 +-
 4 files changed, 59 insertions(+), 45 deletions(-)

diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 4612dddb16..963e71c42f 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -423,7 +423,7 @@ struct MSpan
 
 void	runtime·MSpan_Init(MSpan *span, PageID start, uintptr npages);
 void	runtime·MSpan_EnsureSwept(MSpan *span);
-bool	runtime·MSpan_Sweep(MSpan *span);
+bool	runtime·MSpan_Sweep(MSpan *span, bool preserve);
 
 // Every MSpan is in one doubly-linked list,
 // either one of the MHeap's free lists or one of the
@@ -447,7 +447,7 @@ struct MCentral
 void	runtime·MCentral_Init(MCentral *c, int32 sizeclass);
 MSpan*	runtime·MCentral_CacheSpan(MCentral *c);
 void	runtime·MCentral_UncacheSpan(MCentral *c, MSpan *s);
-bool	runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *end);
+bool	runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *end, bool preserve);
 
 // Main malloc heap.
 // The heap itself is the "free[]" and "large" arrays,
diff --git a/src/pkg/runtime/mcentral.c b/src/pkg/runtime/mcentral.c
index 6b2de02c42..fe6bcfeb13 100644
--- a/src/pkg/runtime/mcentral.c
+++ b/src/pkg/runtime/mcentral.c
@@ -9,16 +9,12 @@
 // The MCentral doesn't actually contain the list of free objects; the MSpan does.
 // Each MCentral is two lists of MSpans: those with free objects (c->nonempty)
 // and those that are completely allocated (c->empty).
-//
-// TODO(rsc): tcmalloc uses a "transfer cache" to split the list
-// into sections of class_to_transfercount[sizeclass] objects
-// so that it is faster to move those lists between MCaches and MCentrals.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 
-static bool MCentral_Grow(MCentral *c);
+static MSpan* MCentral_Grow(MCentral *c);
 
 // Initialize a single central free list.
 void
@@ -42,17 +38,20 @@ runtime·MCentral_CacheSpan(MCentral *c)
 retry:
 	for(s = c->nonempty.next; s != &c->nonempty; s = s->next) {
 		if(s->sweepgen == sg-2 && runtime·cas(&s->sweepgen, sg-2, sg-1)) {
+			runtime·MSpanList_Remove(s);
+			runtime·MSpanList_InsertBack(&c->empty, s);
 			runtime·unlock(&c->lock);
-			runtime·MSpan_Sweep(s);
-			runtime·lock(&c->lock);
-			// the span could have been moved to heap, retry
-			goto retry;
+			runtime·MSpan_Sweep(s, true);
+			goto havespan;
 		}
 		if(s->sweepgen == sg-1) {
 			// the span is being swept by background sweeper, skip
 			continue;
 		}
 		// we have a nonempty span that does not require sweeping, allocate from it
+		runtime·MSpanList_Remove(s);
+		runtime·MSpanList_InsertBack(&c->empty, s);
+		runtime·unlock(&c->lock);
 		goto havespan;
 	}
 
@@ -64,9 +63,12 @@ retry:
 			// swept spans are at the end of the list
 			runtime·MSpanList_InsertBack(&c->empty, s);
 			runtime·unlock(&c->lock);
-			runtime·MSpan_Sweep(s);
+			runtime·MSpan_Sweep(s, true);
+			if(s->freelist != nil)
+				goto havespan;
 			runtime·lock(&c->lock);
-			// the span could be moved to nonempty or heap, retry
+			// the span is still empty after sweep
+			// it is already in the empty list, so just retry
 			goto retry;
 		}
 		if(s->sweepgen == sg-1) {
@@ -77,25 +79,26 @@ retry:
 		// all subsequent ones must also be either swept or in process of sweeping
 		break;
 	}
+	runtime·unlock(&c->lock);
 
 	// Replenish central list if empty.
-	if(!MCentral_Grow(c)) {
-		runtime·unlock(&c->lock);
+	s = MCentral_Grow(c);
+	if(s == nil)
 		return nil;
-	}
-	goto retry;
+	runtime·lock(&c->lock);
+	runtime·MSpanList_InsertBack(&c->empty, s);
+	runtime·unlock(&c->lock);
 
 havespan:
+	// At this point s is a non-empty span, queued at the end of the empty list,
+	// c is unlocked.
 	cap = (s->npages << PageShift) / s->elemsize;
 	n = cap - s->ref;
 	if(n == 0)
 		runtime·throw("empty span");
 	if(s->freelist == nil)
 		runtime·throw("freelist empty");
-	runtime·MSpanList_Remove(s);
-	runtime·MSpanList_InsertBack(&c->empty, s);
 	s->incache = true;
-	runtime·unlock(&c->lock);
 	return s;
 }
 
@@ -125,24 +128,39 @@ runtime·MCentral_UncacheSpan(MCentral *c, MSpan *s)
 // Called during sweep.
 // Returns true if the span was returned to heap.  Sets sweepgen to
 // the latest generation.
+// If preserve=true, don't return the span to heap nor relink in MCentral lists;
+// caller takes care of it.
 bool
-runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *end)
+runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *end, bool preserve)
 {
+	bool wasempty;
+
 	if(s->incache)
 		runtime·throw("freespan into cached span");
+
+	// Add the objects back to s's free list.
+	wasempty = s->freelist == nil;
+	end->next = s->freelist;
+	s->freelist = start;
+	s->ref -= n;
+
+	if(preserve) {
+		// preserve is set only when called from MCentral_CacheSpan above,
+		// the span must be in the empty list.
+		if(s->next == nil)
+			runtime·throw("can't preserve unlinked span");
+		runtime·atomicstore(&s->sweepgen, runtime·mheap.sweepgen);
+		return false;
+	}
+
 	runtime·lock(&c->lock);
 
 	// Move to nonempty if necessary.
-	if(s->freelist == nil) {
+	if(wasempty) {
 		runtime·MSpanList_Remove(s);
 		runtime·MSpanList_Insert(&c->nonempty, s);
 	}
 
-	// Add the objects back to s's free list.
-	end->next = s->freelist;
-	s->freelist = start;
-	s->ref -= n;
-	
 	// delay updating sweepgen until here.  This is the signal that
 	// the span may be used in an MCache, so it must come after the
 	// linked list operations above (actually, just after the
@@ -164,9 +182,8 @@ runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *
 	return true;
 }
 
-// Fetch a new span from the heap and
-// carve into objects for the free list.
-static bool
+// Fetch a new span from the heap and carve into objects for the free list.
+static MSpan*
 MCentral_Grow(MCentral *c)
 {
 	uintptr size, npages, i, n;
@@ -174,16 +191,12 @@ MCentral_Grow(MCentral *c)
 	byte *p;
 	MSpan *s;
 
-	runtime·unlock(&c->lock);
 	npages = runtime·class_to_allocnpages[c->sizeclass];
 	size = runtime·class_to_size[c->sizeclass];
 	n = (npages << PageShift) / size;
 	s = runtime·MHeap_Alloc(&runtime·mheap, npages, c->sizeclass, 0, 1);
-	if(s == nil) {
-		// TODO(rsc): Log out of memory
-		runtime·lock(&c->lock);
-		return false;
-	}
+	if(s == nil)
+		return nil;
 
 	// Carve span into sequence of blocks.
 	tailp = &s->freelist;
@@ -197,8 +210,5 @@ MCentral_Grow(MCentral *c)
 	}
 	*tailp = nil;
 	runtime·markspan((byte*)(s->start<<PageShift), size, n, size*n < (s->npages<<PageShift));
-
-	runtime·lock(&c->lock);
-	runtime·MSpanList_Insert(&c->nonempty, s);
-	return true;
+	return s;
 }
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 5389538eae..ef44d7f786 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -884,7 +884,7 @@ runtime·MSpan_EnsureSwept(MSpan *s)
 	if(runtime·atomicload(&s->sweepgen) == sg)
 		return;
 	if(runtime·cas(&s->sweepgen, sg-2, sg-1)) {
-		runtime·MSpan_Sweep(s);
+		runtime·MSpan_Sweep(s, false);
 		return;
 	}
 	// unfortunate condition, and we don't have efficient means to wait
@@ -895,8 +895,10 @@ runtime·MSpan_EnsureSwept(MSpan *s)
 // Sweep frees or collects finalizers for blocks not marked in the mark phase.
 // It clears the mark bits in preparation for the next GC round.
 // Returns true if the span was returned to heap.
+// If preserve=true, don't return it to heap nor relink in MCentral lists;
+// caller takes care of it.
 bool
-runtime·MSpan_Sweep(MSpan *s)
+runtime·MSpan_Sweep(MSpan *s, bool preserve)
 {
 	int32 cl, n, npages, nfree;
 	uintptr size, off, *bitp, shift, xbits, bits;
@@ -995,6 +997,8 @@ runtime·MSpan_Sweep(MSpan *s)
 		*bitp = (xbits & ~((bitMarked|(BitsMask<<2))<<shift)) | ((uintptr)BitsDead<<(shift+2));
 		if(cl == 0) {
 			// Free large span.
+			if(preserve)
+				runtime·throw("can't preserve large span");
 			runtime·unmarkspan(p, s->npages<<PageShift);
 			s->needzero = 1;
 			// important to set sweepgen before returning it to heap
@@ -1056,7 +1060,7 @@ runtime·MSpan_Sweep(MSpan *s)
 		c->local_nsmallfree[cl] += nfree;
 		c->local_cachealloc -= nfree * size;
 		runtime·xadd64(&mstats.next_gc, -(uint64)(nfree * size * (runtime·gcpercent + 100)/100));
-		res = runtime·MCentral_FreeSpan(&runtime·mheap.central[cl].mcentral, s, nfree, head.next, end);
+		res = runtime·MCentral_FreeSpan(&runtime·mheap.central[cl].mcentral, s, nfree, head.next, end, preserve);
 		// MCentral_FreeSpan updates sweepgen
 	}
 	return res;
@@ -1129,7 +1133,7 @@ runtime·sweepone(void)
 		if(s->sweepgen != sg-2 || !runtime·cas(&s->sweepgen, sg-2, sg-1))
 			continue;
 		npages = s->npages;
-		if(!runtime·MSpan_Sweep(s))
+		if(!runtime·MSpan_Sweep(s, false))
 			npages = 0;
 		g->m->locks--;
 		return npages;
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 186fd48d47..46cf80007b 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -107,7 +107,7 @@ retry:
 			// swept spans are at the end of the list
 			runtime·MSpanList_InsertBack(list, s);
 			runtime·unlock(&h->lock);
-			n += runtime·MSpan_Sweep(s);
+			n += runtime·MSpan_Sweep(s, false);
 			runtime·lock(&h->lock);
 			if(n >= npages)
 				return n;

From 1a8c00ea213f4f5487735a5bb958114c09b55f29 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 18 Aug 2014 11:19:05 -0700
Subject: [PATCH 105/423] internal/syscall: add support for getrandom on arm

Added in linux commit eb6452537b28

LGTM=agl
R=agl
CC=golang-codereviews
https://golang.org/cl/130170043
---
 src/pkg/internal/syscall/getrandom_linux.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/pkg/internal/syscall/getrandom_linux.go b/src/pkg/internal/syscall/getrandom_linux.go
index 1c586ec9b7..944bab3f5d 100644
--- a/src/pkg/internal/syscall/getrandom_linux.go
+++ b/src/pkg/internal/syscall/getrandom_linux.go
@@ -12,8 +12,9 @@ import (
 )
 
 var randomTrap = map[string]uintptr{
-	"amd64": 318,
 	"386":   355,
+	"amd64": 318,
+	"arm":   384,
 }[runtime.GOARCH]
 
 var randomUnsupported int32 // atomic

From 159926236c922ad2f19464552068003db9208e62 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 18 Aug 2014 22:21:55 +0400
Subject: [PATCH 106/423] runtime: add more cases to GC info test

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews, khr, rlh, rsc
https://golang.org/cl/125420043
---
 src/pkg/runtime/gcinfo_test.go | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/gcinfo_test.go b/src/pkg/runtime/gcinfo_test.go
index 892484ea6f..16764c9487 100644
--- a/src/pkg/runtime/gcinfo_test.go
+++ b/src/pkg/runtime/gcinfo_test.go
@@ -16,26 +16,33 @@ func TestGCInfo(t *testing.T) {
 	verifyGCInfo(t, "bss PtrScalar", &bssPtrScalar, nonStackInfo(infoPtrScalar))
 	verifyGCInfo(t, "bss Complex", &bssComplex, nonStackInfo(infoComplex()))
 	verifyGCInfo(t, "bss string", &bssString, nonStackInfo(infoString))
+	verifyGCInfo(t, "bss slice", &bssSlice, nonStackInfo(infoSlice))
 	verifyGCInfo(t, "bss eface", &bssEface, nonStackInfo(infoEface))
+	verifyGCInfo(t, "bss iface", &bssIface, nonStackInfo(infoIface))
 
 	verifyGCInfo(t, "data ScalarPtr", &dataScalarPtr, nonStackInfo(infoScalarPtr))
 	verifyGCInfo(t, "data PtrScalar", &dataPtrScalar, nonStackInfo(infoPtrScalar))
 	verifyGCInfo(t, "data Complex", &dataComplex, nonStackInfo(infoComplex()))
 	verifyGCInfo(t, "data string", &dataString, nonStackInfo(infoString))
+	verifyGCInfo(t, "data slice", &dataSlice, nonStackInfo(infoSlice))
 	verifyGCInfo(t, "data eface", &dataEface, nonStackInfo(infoEface))
+	verifyGCInfo(t, "data iface", &dataIface, nonStackInfo(infoIface))
 
 	verifyGCInfo(t, "stack ScalarPtr", new(ScalarPtr), infoScalarPtr)
 	verifyGCInfo(t, "stack PtrScalar", new(PtrScalar), infoPtrScalar)
 	verifyGCInfo(t, "stack Complex", new(Complex), infoComplex())
 	verifyGCInfo(t, "stack string", new(string), infoString)
+	verifyGCInfo(t, "stack slice", new([]string), infoSlice)
 	verifyGCInfo(t, "stack eface", new(interface{}), infoEface)
+	verifyGCInfo(t, "stack iface", new(Iface), infoIface)
 
-	for i := 0; i < 3; i++ {
+	for i := 0; i < 10; i++ {
 		verifyGCInfo(t, "heap ScalarPtr", escape(new(ScalarPtr)), nonStackInfo(infoScalarPtr))
 		verifyGCInfo(t, "heap PtrScalar", escape(new(PtrScalar)), nonStackInfo(infoPtrScalar))
 		verifyGCInfo(t, "heap Complex", escape(new(Complex)), nonStackInfo(infoComplex()))
 		verifyGCInfo(t, "heap string", escape(new(string)), nonStackInfo(infoString))
 		verifyGCInfo(t, "heap eface", escape(new(interface{})), nonStackInfo(infoEface))
+		verifyGCInfo(t, "heap iface", escape(new(Iface)), nonStackInfo(infoIface))
 	}
 
 }
@@ -147,21 +154,36 @@ func infoComplex() []byte {
 	}
 }
 
+type Iface interface {
+	f()
+}
+
+type IfaceImpl int
+
+func (IfaceImpl) f() {
+}
+
 var (
 	// BSS
 	bssScalarPtr ScalarPtr
 	bssPtrScalar PtrScalar
 	bssComplex   Complex
 	bssString    string
+	bssSlice     []string
 	bssEface     interface{}
+	bssIface     Iface
 
 	// DATA
 	dataScalarPtr             = ScalarPtr{q: 1}
 	dataPtrScalar             = PtrScalar{w: 1}
 	dataComplex               = Complex{w: 1}
 	dataString                = "foo"
+	dataSlice                 = []string{"foo"}
 	dataEface     interface{} = 42
+	dataIface     Iface       = IfaceImpl(42)
 
 	infoString = []byte{BitsMultiWord, BitsString}
+	infoSlice  = []byte{BitsMultiWord, BitsSlice, BitsDead}
 	infoEface  = []byte{BitsMultiWord, BitsEface}
+	infoIface  = []byte{BitsMultiWord, BitsIface}
 )

From 65d8cb985f790f272e4f0827f4fab75e223a15b6 Mon Sep 17 00:00:00 2001
From: Marcel van Lohuizen <mpvl@golang.org>
Date: Mon, 18 Aug 2014 20:26:10 +0200
Subject: [PATCH 107/423] unicode: strconv: regexp: Upgrade to Unicode 7.0.0.

LGTM=r, bradfitz
R=r, bradfitz
CC=golang-codereviews
https://golang.org/cl/127470043
---
 api/except.txt                 |    1 +
 api/next.txt                   |   24 +
 src/pkg/regexp/syntax/parse.go |    2 +-
 src/pkg/strconv/isprint.go     |  196 +++--
 src/pkg/unicode/maketables.go  |    2 +-
 src/pkg/unicode/script_test.go |   27 +-
 src/pkg/unicode/tables.go      | 1248 ++++++++++++++++++++++++--------
 7 files changed, 1124 insertions(+), 376 deletions(-)

diff --git a/api/except.txt b/api/except.txt
index 1a8296635d..6e40e1844e 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -327,3 +327,4 @@ pkg syscall (netbsd-arm), const SizeofIfData = 132
 pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
 pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
 pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
+pkg unicode, const Version = "6.3.0"
diff --git a/api/next.txt b/api/next.txt
index 5e49b3f94f..e8570a6f2b 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -115,3 +115,27 @@ pkg debug/goobj, type Var struct, Kind int
 pkg debug/goobj, type Var struct, Name string
 pkg debug/goobj, type Var struct, Offset int
 pkg debug/goobj, type Var struct, Type SymID
+pkg unicode, const Version = "7.0.0"
+pkg unicode, var Bassa_Vah *RangeTable
+pkg unicode, var Caucasian_Albanian *RangeTable
+pkg unicode, var Duployan *RangeTable
+pkg unicode, var Elbasan *RangeTable
+pkg unicode, var Grantha *RangeTable
+pkg unicode, var Khojki *RangeTable
+pkg unicode, var Khudawadi *RangeTable
+pkg unicode, var Linear_A *RangeTable
+pkg unicode, var Mahajani *RangeTable
+pkg unicode, var Manichaean *RangeTable
+pkg unicode, var Mende_Kikakui *RangeTable
+pkg unicode, var Modi *RangeTable
+pkg unicode, var Mro *RangeTable
+pkg unicode, var Nabataean *RangeTable
+pkg unicode, var Old_North_Arabian *RangeTable
+pkg unicode, var Old_Permic *RangeTable
+pkg unicode, var Pahawh_Hmong *RangeTable
+pkg unicode, var Palmyrene *RangeTable
+pkg unicode, var Pau_Cin_Hau *RangeTable
+pkg unicode, var Psalter_Pahlavi *RangeTable
+pkg unicode, var Siddham *RangeTable
+pkg unicode, var Tirhuta *RangeTable
+pkg unicode, var Warang_Citi *RangeTable
diff --git a/src/pkg/regexp/syntax/parse.go b/src/pkg/regexp/syntax/parse.go
index cb25dca395..08f8d307ae 100644
--- a/src/pkg/regexp/syntax/parse.go
+++ b/src/pkg/regexp/syntax/parse.go
@@ -1639,7 +1639,7 @@ const (
 	// minimum and maximum runes involved in folding.
 	// checked during test.
 	minFold = 0x0041
-	maxFold = 0x1044f
+	maxFold = 0x118df
 )
 
 // appendFoldedRange returns the result of appending the range lo-hi
diff --git a/src/pkg/strconv/isprint.go b/src/pkg/strconv/isprint.go
index 91f1795356..ba0adbdbb5 100644
--- a/src/pkg/strconv/isprint.go
+++ b/src/pkg/strconv/isprint.go
@@ -7,16 +7,15 @@
 
 package strconv
 
-// (470+136+60)*2 + (218)*4 = 2204 bytes
+// (468+138+67)*2 + (326)*4 = 2650 bytes
 
 var isPrint16 = []uint16{
 	0x0020, 0x007e,
 	0x00a1, 0x0377,
-	0x037a, 0x037e,
-	0x0384, 0x0527,
-	0x0531, 0x0556,
+	0x037a, 0x037f,
+	0x0384, 0x0556,
 	0x0559, 0x058a,
-	0x058f, 0x05c7,
+	0x058d, 0x05c7,
 	0x05d0, 0x05ea,
 	0x05f0, 0x05f4,
 	0x0606, 0x061b,
@@ -27,7 +26,7 @@ var isPrint16 = []uint16{
 	0x0800, 0x082d,
 	0x0830, 0x085b,
 	0x085e, 0x085e,
-	0x08a0, 0x08ac,
+	0x08a0, 0x08b2,
 	0x08e4, 0x098c,
 	0x098f, 0x0990,
 	0x0993, 0x09b2,
@@ -72,18 +71,17 @@ var isPrint16 = []uint16{
 	0x0bd0, 0x0bd0,
 	0x0bd7, 0x0bd7,
 	0x0be6, 0x0bfa,
-	0x0c01, 0x0c39,
+	0x0c00, 0x0c39,
 	0x0c3d, 0x0c4d,
 	0x0c55, 0x0c59,
 	0x0c60, 0x0c63,
 	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7f,
-	0x0c82, 0x0cb9,
+	0x0c78, 0x0cb9,
 	0x0cbc, 0x0ccd,
 	0x0cd5, 0x0cd6,
 	0x0cde, 0x0ce3,
 	0x0ce6, 0x0cf2,
-	0x0d02, 0x0d3a,
+	0x0d01, 0x0d3a,
 	0x0d3d, 0x0d4e,
 	0x0d57, 0x0d57,
 	0x0d60, 0x0d63,
@@ -94,6 +92,7 @@ var isPrint16 = []uint16{
 	0x0dc0, 0x0dc6,
 	0x0dca, 0x0dca,
 	0x0dcf, 0x0ddf,
+	0x0de6, 0x0def,
 	0x0df2, 0x0df4,
 	0x0e01, 0x0e3a,
 	0x0e3f, 0x0e5b,
@@ -120,7 +119,7 @@ var isPrint16 = []uint16{
 	0x1380, 0x1399,
 	0x13a0, 0x13f4,
 	0x1400, 0x169c,
-	0x16a0, 0x16f0,
+	0x16a0, 0x16f8,
 	0x1700, 0x1714,
 	0x1720, 0x1736,
 	0x1740, 0x1753,
@@ -133,8 +132,7 @@ var isPrint16 = []uint16{
 	0x1820, 0x1877,
 	0x1880, 0x18aa,
 	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
+	0x1900, 0x192b,
 	0x1930, 0x193b,
 	0x1940, 0x1940,
 	0x1944, 0x196d,
@@ -147,6 +145,7 @@ var isPrint16 = []uint16{
 	0x1a7f, 0x1a89,
 	0x1a90, 0x1a99,
 	0x1aa0, 0x1aad,
+	0x1ab0, 0x1abe,
 	0x1b00, 0x1b4b,
 	0x1b50, 0x1b7c,
 	0x1b80, 0x1bf3,
@@ -154,8 +153,8 @@ var isPrint16 = []uint16{
 	0x1c3b, 0x1c49,
 	0x1c4d, 0x1c7f,
 	0x1cc0, 0x1cc7,
-	0x1cd0, 0x1cf6,
-	0x1d00, 0x1de6,
+	0x1cd0, 0x1cf9,
+	0x1d00, 0x1df5,
 	0x1dfc, 0x1f15,
 	0x1f18, 0x1f1d,
 	0x1f20, 0x1f45,
@@ -168,21 +167,23 @@ var isPrint16 = []uint16{
 	0x2030, 0x205e,
 	0x2070, 0x2071,
 	0x2074, 0x209c,
-	0x20a0, 0x20ba,
+	0x20a0, 0x20bd,
 	0x20d0, 0x20f0,
 	0x2100, 0x2189,
-	0x2190, 0x23f3,
+	0x2190, 0x23fa,
 	0x2400, 0x2426,
 	0x2440, 0x244a,
-	0x2460, 0x2b4c,
-	0x2b50, 0x2b59,
+	0x2460, 0x2b73,
+	0x2b76, 0x2b95,
+	0x2b98, 0x2bb9,
+	0x2bbd, 0x2bd1,
 	0x2c00, 0x2cf3,
 	0x2cf9, 0x2d27,
 	0x2d2d, 0x2d2d,
 	0x2d30, 0x2d67,
 	0x2d6f, 0x2d70,
 	0x2d7f, 0x2d96,
-	0x2da0, 0x2e3b,
+	0x2da0, 0x2e42,
 	0x2e80, 0x2ef3,
 	0x2f00, 0x2fd5,
 	0x2ff0, 0x2ffb,
@@ -196,11 +197,10 @@ var isPrint16 = []uint16{
 	0xa000, 0xa48c,
 	0xa490, 0xa4c6,
 	0xa4d0, 0xa62b,
-	0xa640, 0xa697,
-	0xa69f, 0xa6f7,
-	0xa700, 0xa793,
-	0xa7a0, 0xa7aa,
-	0xa7f8, 0xa82b,
+	0xa640, 0xa6f7,
+	0xa700, 0xa7ad,
+	0xa7b0, 0xa7b1,
+	0xa7f7, 0xa82b,
 	0xa830, 0xa839,
 	0xa840, 0xa877,
 	0xa880, 0xa8c4,
@@ -209,17 +209,16 @@ var isPrint16 = []uint16{
 	0xa900, 0xa953,
 	0xa95f, 0xa97c,
 	0xa980, 0xa9d9,
-	0xa9de, 0xa9df,
-	0xaa00, 0xaa36,
+	0xa9de, 0xaa36,
 	0xaa40, 0xaa4d,
 	0xaa50, 0xaa59,
-	0xaa5c, 0xaa7b,
-	0xaa80, 0xaac2,
+	0xaa5c, 0xaac2,
 	0xaadb, 0xaaf6,
 	0xab01, 0xab06,
 	0xab09, 0xab0e,
 	0xab11, 0xab16,
-	0xab20, 0xab2e,
+	0xab20, 0xab5f,
+	0xab64, 0xab65,
 	0xabc0, 0xabed,
 	0xabf0, 0xabf9,
 	0xac00, 0xd7a3,
@@ -235,7 +234,7 @@ var isPrint16 = []uint16{
 	0xfd92, 0xfdc7,
 	0xfdf0, 0xfdfd,
 	0xfe00, 0xfe19,
-	0xfe20, 0xfe26,
+	0xfe20, 0xfe2d,
 	0xfe30, 0xfe6b,
 	0xfe70, 0xfefc,
 	0xff01, 0xffbe,
@@ -252,15 +251,12 @@ var isNotPrint16 = []uint16{
 	0x038b,
 	0x038d,
 	0x03a2,
+	0x0530,
 	0x0560,
 	0x0588,
 	0x0590,
 	0x06dd,
 	0x083f,
-	0x08a1,
-	0x08ff,
-	0x0978,
-	0x0980,
 	0x0984,
 	0x09a9,
 	0x09b1,
@@ -294,10 +290,10 @@ var isNotPrint16 = []uint16{
 	0x0c0d,
 	0x0c11,
 	0x0c29,
-	0x0c34,
 	0x0c45,
 	0x0c49,
 	0x0c57,
+	0x0c80,
 	0x0c84,
 	0x0c8d,
 	0x0c91,
@@ -345,7 +341,9 @@ var isNotPrint16 = []uint16{
 	0x170d,
 	0x176d,
 	0x1771,
+	0x191f,
 	0x1a5f,
+	0x1cf7,
 	0x1f58,
 	0x1f5a,
 	0x1f5c,
@@ -355,7 +353,7 @@ var isNotPrint16 = []uint16{
 	0x1fdc,
 	0x1ff5,
 	0x208f,
-	0x2700,
+	0x2bc9,
 	0x2c2f,
 	0x2c5f,
 	0x2d26,
@@ -372,9 +370,12 @@ var isNotPrint16 = []uint16{
 	0x318f,
 	0x321f,
 	0x32ff,
+	0xa69e,
 	0xa78f,
 	0xa9ce,
+	0xa9ff,
 	0xab27,
+	0xab2f,
 	0xfb37,
 	0xfb3d,
 	0xfb3f,
@@ -392,21 +393,31 @@ var isPrint32 = []uint32{
 	0x010080, 0x0100fa,
 	0x010100, 0x010102,
 	0x010107, 0x010133,
-	0x010137, 0x01018a,
+	0x010137, 0x01018c,
 	0x010190, 0x01019b,
+	0x0101a0, 0x0101a0,
 	0x0101d0, 0x0101fd,
 	0x010280, 0x01029c,
 	0x0102a0, 0x0102d0,
+	0x0102e0, 0x0102fb,
 	0x010300, 0x010323,
 	0x010330, 0x01034a,
+	0x010350, 0x01037a,
 	0x010380, 0x0103c3,
 	0x0103c8, 0x0103d5,
 	0x010400, 0x01049d,
 	0x0104a0, 0x0104a9,
+	0x010500, 0x010527,
+	0x010530, 0x010563,
+	0x01056f, 0x01056f,
+	0x010600, 0x010736,
+	0x010740, 0x010755,
+	0x010760, 0x010767,
 	0x010800, 0x010805,
 	0x010808, 0x010838,
 	0x01083c, 0x01083c,
-	0x01083f, 0x01085f,
+	0x01083f, 0x01089e,
+	0x0108a7, 0x0108af,
 	0x010900, 0x01091b,
 	0x01091f, 0x010939,
 	0x01093f, 0x01093f,
@@ -417,32 +428,72 @@ var isPrint32 = []uint32{
 	0x010a38, 0x010a3a,
 	0x010a3f, 0x010a47,
 	0x010a50, 0x010a58,
-	0x010a60, 0x010a7f,
+	0x010a60, 0x010a9f,
+	0x010ac0, 0x010ae6,
+	0x010aeb, 0x010af6,
 	0x010b00, 0x010b35,
 	0x010b39, 0x010b55,
 	0x010b58, 0x010b72,
-	0x010b78, 0x010b7f,
+	0x010b78, 0x010b91,
+	0x010b99, 0x010b9c,
+	0x010ba9, 0x010baf,
 	0x010c00, 0x010c48,
 	0x010e60, 0x010e7e,
 	0x011000, 0x01104d,
 	0x011052, 0x01106f,
-	0x011080, 0x0110c1,
+	0x01107f, 0x0110c1,
 	0x0110d0, 0x0110e8,
 	0x0110f0, 0x0110f9,
 	0x011100, 0x011143,
+	0x011150, 0x011176,
 	0x011180, 0x0111c8,
-	0x0111d0, 0x0111d9,
+	0x0111cd, 0x0111cd,
+	0x0111d0, 0x0111da,
+	0x0111e1, 0x0111f4,
+	0x011200, 0x01123d,
+	0x0112b0, 0x0112ea,
+	0x0112f0, 0x0112f9,
+	0x011301, 0x01130c,
+	0x01130f, 0x011310,
+	0x011313, 0x011339,
+	0x01133c, 0x011344,
+	0x011347, 0x011348,
+	0x01134b, 0x01134d,
+	0x011357, 0x011357,
+	0x01135d, 0x011363,
+	0x011366, 0x01136c,
+	0x011370, 0x011374,
+	0x011480, 0x0114c7,
+	0x0114d0, 0x0114d9,
+	0x011580, 0x0115b5,
+	0x0115b8, 0x0115c9,
+	0x011600, 0x011644,
+	0x011650, 0x011659,
 	0x011680, 0x0116b7,
 	0x0116c0, 0x0116c9,
-	0x012000, 0x01236e,
-	0x012400, 0x012462,
-	0x012470, 0x012473,
+	0x0118a0, 0x0118f2,
+	0x0118ff, 0x0118ff,
+	0x011ac0, 0x011af8,
+	0x012000, 0x012398,
+	0x012400, 0x012474,
 	0x013000, 0x01342e,
 	0x016800, 0x016a38,
+	0x016a40, 0x016a69,
+	0x016a6e, 0x016a6f,
+	0x016ad0, 0x016aed,
+	0x016af0, 0x016af5,
+	0x016b00, 0x016b45,
+	0x016b50, 0x016b77,
+	0x016b7d, 0x016b8f,
 	0x016f00, 0x016f44,
 	0x016f50, 0x016f7e,
 	0x016f8f, 0x016f9f,
 	0x01b000, 0x01b001,
+	0x01bc00, 0x01bc6a,
+	0x01bc70, 0x01bc7c,
+	0x01bc80, 0x01bc88,
+	0x01bc90, 0x01bc99,
+	0x01bc9c, 0x01bc9f,
 	0x01d000, 0x01d0f5,
 	0x01d100, 0x01d126,
 	0x01d129, 0x01d172,
@@ -458,6 +509,8 @@ var isPrint32 = []uint32{
 	0x01d54a, 0x01d6a5,
 	0x01d6a8, 0x01d7cb,
 	0x01d7ce, 0x01d7ff,
+	0x01e800, 0x01e8c4,
+	0x01e8c7, 0x01e8d6,
 	0x01ee00, 0x01ee24,
 	0x01ee27, 0x01ee3b,
 	0x01ee42, 0x01ee42,
@@ -469,28 +522,30 @@ var isPrint32 = []uint32{
 	0x01f000, 0x01f02b,
 	0x01f030, 0x01f093,
 	0x01f0a0, 0x01f0ae,
-	0x01f0b1, 0x01f0be,
-	0x01f0c1, 0x01f0df,
-	0x01f100, 0x01f10a,
+	0x01f0b1, 0x01f0f5,
+	0x01f100, 0x01f10c,
 	0x01f110, 0x01f16b,
 	0x01f170, 0x01f19a,
 	0x01f1e6, 0x01f202,
 	0x01f210, 0x01f23a,
 	0x01f240, 0x01f248,
 	0x01f250, 0x01f251,
-	0x01f300, 0x01f320,
-	0x01f330, 0x01f37c,
-	0x01f380, 0x01f393,
-	0x01f3a0, 0x01f3ca,
-	0x01f3e0, 0x01f3f0,
-	0x01f400, 0x01f4fc,
-	0x01f500, 0x01f53d,
-	0x01f540, 0x01f543,
-	0x01f550, 0x01f567,
-	0x01f5fb, 0x01f640,
-	0x01f645, 0x01f64f,
-	0x01f680, 0x01f6c5,
+	0x01f300, 0x01f32c,
+	0x01f330, 0x01f37d,
+	0x01f380, 0x01f3ce,
+	0x01f3d4, 0x01f3f7,
+	0x01f400, 0x01f54a,
+	0x01f550, 0x01f642,
+	0x01f645, 0x01f6cf,
+	0x01f6e0, 0x01f6ec,
+	0x01f6f0, 0x01f6f3,
 	0x01f700, 0x01f773,
+	0x01f780, 0x01f7d4,
+	0x01f800, 0x01f80b,
+	0x01f810, 0x01f847,
+	0x01f850, 0x01f859,
+	0x01f860, 0x01f887,
+	0x01f890, 0x01f8ad,
 	0x020000, 0x02a6d6,
 	0x02a700, 0x02b734,
 	0x02b740, 0x02b81d,
@@ -503,7 +558,6 @@ var isNotPrint32 = []uint16{ // add 0x10000 to each entry
 	0x0027,
 	0x003b,
 	0x003e,
-	0x031f,
 	0x039e,
 	0x0809,
 	0x0836,
@@ -513,6 +567,15 @@ var isNotPrint32 = []uint16{ // add 0x10000 to each entry
 	0x0a18,
 	0x10bd,
 	0x1135,
+	0x1212,
+	0x1304,
+	0x1329,
+	0x1331,
+	0x1334,
+	0x246f,
+	0x6a5f,
+	0x6b5a,
+	0x6b62,
 	0xd455,
 	0xd49d,
 	0xd4ad,
@@ -552,11 +615,10 @@ var isNotPrint32 = []uint16{ // add 0x10000 to each entry
 	0xee8a,
 	0xeea4,
 	0xeeaa,
+	0xf0c0,
 	0xf0d0,
 	0xf12f,
-	0xf336,
-	0xf3c5,
-	0xf43f,
-	0xf441,
-	0xf4f8,
+	0xf4ff,
+	0xf57a,
+	0xf5a4,
 }
diff --git a/src/pkg/unicode/maketables.go b/src/pkg/unicode/maketables.go
index 8116ab8a41..5de98c3b47 100644
--- a/src/pkg/unicode/maketables.go
+++ b/src/pkg/unicode/maketables.go
@@ -40,7 +40,7 @@ func main() {
 var dataURL = flag.String("data", "", "full URL for UnicodeData.txt; defaults to --url/UnicodeData.txt")
 var casefoldingURL = flag.String("casefolding", "", "full URL for CaseFolding.txt; defaults to --url/CaseFolding.txt")
 var url = flag.String("url",
-	"http://www.unicode.org/Public/6.3.0/ucd/",
+	"http://www.unicode.org/Public/7.0.0/ucd/",
 	"URL of Unicode database directory")
 var tablelist = flag.String("tables",
 	"all",
diff --git a/src/pkg/unicode/script_test.go b/src/pkg/unicode/script_test.go
index e2ba0011ac..795cb4e171 100644
--- a/src/pkg/unicode/script_test.go
+++ b/src/pkg/unicode/script_test.go
@@ -14,14 +14,15 @@ type T struct {
 	script string
 }
 
-// Hand-chosen tests from Unicode 5.1.0, 6.0.0 and 6.2.0 mostly to discover when new
-// scripts and categories arise.
+// Hand-chosen tests from Unicode 5.1.0, 6.0.0, 6.2.0, 6.3.0 and 7.0.0 mostly to
+// discover when new scripts and categories arise.
 var inTest = []T{
 	{0x06e2, "Arabic"},
 	{0x0567, "Armenian"},
 	{0x10b20, "Avestan"},
 	{0x1b37, "Balinese"},
 	{0xa6af, "Bamum"},
+	{0x16ada, "Bassa_Vah"},
 	{0x1be1, "Batak"},
 	{0x09c2, "Bengali"},
 	{0x3115, "Bopomofo"},
@@ -31,6 +32,7 @@ var inTest = []T{
 	{0x11011, "Brahmi"},
 	{0x156d, "Canadian_Aboriginal"},
 	{0x102a9, "Carian"},
+	{0x10563, "Caucasian_Albanian"},
 	{0x11111, "Chakma"},
 	{0xaa4d, "Cham"},
 	{0x13c2, "Cherokee"},
@@ -42,11 +44,14 @@ var inTest = []T{
 	{0xa663, "Cyrillic"},
 	{0x10430, "Deseret"},
 	{0x094a, "Devanagari"},
+	{0x1BC00, "Duployan"},
 	{0x13001, "Egyptian_Hieroglyphs"},
+	{0x10500, "Elbasan"},
 	{0x1271, "Ethiopic"},
 	{0x10fc, "Georgian"},
 	{0x2c40, "Glagolitic"},
 	{0x10347, "Gothic"},
+	{0x11303, "Grantha"},
 	{0x03ae, "Greek"},
 	{0x0abf, "Gujarati"},
 	{0x0a24, "Gurmukhi"},
@@ -66,40 +71,56 @@ var inTest = []T{
 	{0xa928, "Kayah_Li"},
 	{0x10a11, "Kharoshthi"},
 	{0x17c6, "Khmer"},
+	{0x11211, "Khojki"},
+	{0x112df, "Khudawadi"},
 	{0x0eaa, "Lao"},
 	{0x1d79, "Latin"},
 	{0x1c10, "Lepcha"},
 	{0x1930, "Limbu"},
+	{0x10755, "Linear_A"},
 	{0x1003c, "Linear_B"},
 	{0xa4e1, "Lisu"},
 	{0x10290, "Lycian"},
 	{0x10930, "Lydian"},
+	{0x11173, "Mahajani"},
 	{0x0d42, "Malayalam"},
 	{0x0843, "Mandaic"},
+	{0x10ac8, "Manichaean"},
 	{0xabd0, "Meetei_Mayek"},
+	{0x1e800, "Mende_Kikakui"},
 	{0x1099f, "Meroitic_Hieroglyphs"},
 	{0x109a0, "Meroitic_Cursive"},
 	{0x16f00, "Miao"},
+	{0x11611, "Modi"},
 	{0x1822, "Mongolian"},
+	{0x16a60, "Mro"},
 	{0x104c, "Myanmar"},
+	{0x10880, "Nabataean"},
 	{0x19c3, "New_Tai_Lue"},
 	{0x07f8, "Nko"},
 	{0x169b, "Ogham"},
 	{0x1c6a, "Ol_Chiki"},
 	{0x10310, "Old_Italic"},
+	{0x10a80, "Old_North_Arabian"},
+	{0x10350, "Old_Permic"},
 	{0x103c9, "Old_Persian"},
 	{0x10a6f, "Old_South_Arabian"},
 	{0x10c20, "Old_Turkic"},
 	{0x0b3e, "Oriya"},
 	{0x10491, "Osmanya"},
+	{0x16b2b, "Pahawh_Hmong"},
+	{0x10876, "Palmyrene"},
+	{0x11ACE, "Pau_Cin_Hau"},
 	{0xa860, "Phags_Pa"},
 	{0x10918, "Phoenician"},
+	{0x10baf, "Psalter_Pahlavi"},
 	{0xa949, "Rejang"},
 	{0x16c0, "Runic"},
 	{0x081d, "Samaritan"},
 	{0xa892, "Saurashtra"},
 	{0x111a0, "Sharada"},
 	{0x10463, "Shavian"},
+	{0x115c1, "Siddham"},
 	{0x0dbd, "Sinhala"},
 	{0x110d0, "Sora_Sompeng"},
 	{0x1ba3, "Sundanese"},
@@ -117,8 +138,10 @@ var inTest = []T{
 	{0x0e46, "Thai"},
 	{0x0f36, "Tibetan"},
 	{0x2d55, "Tifinagh"},
+	{0x114d9, "Tirhuta"},
 	{0x10388, "Ugaritic"},
 	{0xa60e, "Vai"},
+	{0x118ff, "Warang_Citi"},
 	{0xa216, "Yi"},
 }
 
diff --git a/src/pkg/unicode/tables.go b/src/pkg/unicode/tables.go
index 5670d1c5b1..8b77dd6036 100644
--- a/src/pkg/unicode/tables.go
+++ b/src/pkg/unicode/tables.go
@@ -3,13 +3,13 @@
 // license that can be found in the LICENSE file.
 
 // Generated by running
-//	maketables --tables=all --data=http://www.unicode.org/Public/6.3.0/ucd/UnicodeData.txt --casefolding=http://www.unicode.org/Public/6.3.0/ucd/CaseFolding.txt
+//	maketables --tables=all --data=http://www.unicode.org/Public/7.0.0/ucd/UnicodeData.txt --casefolding=http://www.unicode.org/Public/7.0.0/ucd/CaseFolding.txt
 // DO NOT EDIT
 
 package unicode
 
 // Version is the Unicode edition from which the tables are derived.
-const Version = "6.3.0"
+const Version = "7.0.0"
 
 // Categories is the set of Unicode category tables.
 var Categories = map[string]*RangeTable{
@@ -56,7 +56,7 @@ var _C = &RangeTable{
 		{0x0001, 0x001f, 1},
 		{0x007f, 0x009f, 1},
 		{0x00ad, 0x0600, 1363},
-		{0x0601, 0x0604, 1},
+		{0x0601, 0x0605, 1},
 		{0x061c, 0x06dd, 193},
 		{0x070f, 0x180e, 4351},
 		{0x200b, 0x200f, 1},
@@ -68,8 +68,9 @@ var _C = &RangeTable{
 		{0xfffa, 0xfffb, 1},
 	},
 	R32: []Range32{
-		{0x110bd, 0x1d173, 49334},
-		{0x1d174, 0x1d17a, 1},
+		{0x110bd, 0x1bca0, 44003},
+		{0x1bca1, 0x1bca3, 1},
+		{0x1d173, 0x1d17a, 1},
 		{0xe0001, 0xe0020, 31},
 		{0xe0021, 0xe007f, 1},
 		{0xf0000, 0xffffd, 1},
@@ -89,7 +90,7 @@ var _Cc = &RangeTable{
 var _Cf = &RangeTable{
 	R16: []Range16{
 		{0x00ad, 0x0600, 1363},
-		{0x0601, 0x0604, 1},
+		{0x0601, 0x0605, 1},
 		{0x061c, 0x06dd, 193},
 		{0x070f, 0x180e, 4351},
 		{0x200b, 0x200f, 1},
@@ -100,8 +101,9 @@ var _Cf = &RangeTable{
 		{0xfffa, 0xfffb, 1},
 	},
 	R32: []Range32{
-		{0x110bd, 0x1d173, 49334},
-		{0x1d174, 0x1d17a, 1},
+		{0x110bd, 0x1bca0, 44003},
+		{0x1bca1, 0x1bca3, 1},
+		{0x1d173, 0x1d17a, 1},
 		{0xe0001, 0xe0020, 31},
 		{0xe0021, 0xe007f, 1},
 	},
@@ -138,13 +140,13 @@ var _L = &RangeTable{
 		{0x0370, 0x0374, 1},
 		{0x0376, 0x0377, 1},
 		{0x037a, 0x037d, 1},
-		{0x0386, 0x0388, 2},
-		{0x0389, 0x038a, 1},
+		{0x037f, 0x0386, 7},
+		{0x0388, 0x038a, 1},
 		{0x038c, 0x038e, 2},
 		{0x038f, 0x03a1, 1},
 		{0x03a3, 0x03f5, 1},
 		{0x03f7, 0x0481, 1},
-		{0x048a, 0x0527, 1},
+		{0x048a, 0x052f, 1},
 		{0x0531, 0x0556, 1},
 		{0x0559, 0x0561, 8},
 		{0x0562, 0x0587, 1},
@@ -168,13 +170,11 @@ var _L = &RangeTable{
 		{0x081a, 0x0824, 10},
 		{0x0828, 0x0840, 24},
 		{0x0841, 0x0858, 1},
-		{0x08a0, 0x08a2, 2},
-		{0x08a3, 0x08ac, 1},
+		{0x08a0, 0x08b2, 1},
 		{0x0904, 0x0939, 1},
 		{0x093d, 0x0950, 19},
 		{0x0958, 0x0961, 1},
-		{0x0971, 0x0977, 1},
-		{0x0979, 0x097f, 1},
+		{0x0971, 0x0980, 1},
 		{0x0985, 0x098c, 1},
 		{0x098f, 0x0990, 1},
 		{0x0993, 0x09a8, 1},
@@ -226,8 +226,7 @@ var _L = &RangeTable{
 		{0x0c06, 0x0c0c, 1},
 		{0x0c0e, 0x0c10, 1},
 		{0x0c12, 0x0c28, 1},
-		{0x0c2a, 0x0c33, 1},
-		{0x0c35, 0x0c39, 1},
+		{0x0c2a, 0x0c39, 1},
 		{0x0c3d, 0x0c58, 27},
 		{0x0c59, 0x0c60, 7},
 		{0x0c61, 0x0c85, 36},
@@ -306,6 +305,7 @@ var _L = &RangeTable{
 		{0x166f, 0x167f, 1},
 		{0x1681, 0x169a, 1},
 		{0x16a0, 0x16ea, 1},
+		{0x16f1, 0x16f8, 1},
 		{0x1700, 0x170c, 1},
 		{0x170e, 0x1711, 1},
 		{0x1720, 0x1731, 1},
@@ -318,7 +318,7 @@ var _L = &RangeTable{
 		{0x1880, 0x18a8, 1},
 		{0x18aa, 0x18b0, 6},
 		{0x18b1, 0x18f5, 1},
-		{0x1900, 0x191c, 1},
+		{0x1900, 0x191e, 1},
 		{0x1950, 0x196d, 1},
 		{0x1970, 0x1974, 1},
 		{0x1980, 0x19ab, 1},
@@ -406,14 +406,14 @@ var _L = &RangeTable{
 		{0xa610, 0xa61f, 1},
 		{0xa62a, 0xa62b, 1},
 		{0xa640, 0xa66e, 1},
-		{0xa67f, 0xa697, 1},
+		{0xa67f, 0xa69d, 1},
 		{0xa6a0, 0xa6e5, 1},
 		{0xa717, 0xa71f, 1},
 		{0xa722, 0xa788, 1},
 		{0xa78b, 0xa78e, 1},
-		{0xa790, 0xa793, 1},
-		{0xa7a0, 0xa7aa, 1},
-		{0xa7f8, 0xa801, 1},
+		{0xa790, 0xa7ad, 1},
+		{0xa7b0, 0xa7b1, 1},
+		{0xa7f7, 0xa801, 1},
 		{0xa803, 0xa805, 1},
 		{0xa807, 0xa80a, 1},
 		{0xa80c, 0xa822, 1},
@@ -425,13 +425,16 @@ var _L = &RangeTable{
 		{0xa930, 0xa946, 1},
 		{0xa960, 0xa97c, 1},
 		{0xa984, 0xa9b2, 1},
-		{0xa9cf, 0xaa00, 49},
-		{0xaa01, 0xaa28, 1},
+		{0xa9cf, 0xa9e0, 17},
+		{0xa9e1, 0xa9e4, 1},
+		{0xa9e6, 0xa9ef, 1},
+		{0xa9fa, 0xa9fe, 1},
+		{0xaa00, 0xaa28, 1},
 		{0xaa40, 0xaa42, 1},
 		{0xaa44, 0xaa4b, 1},
 		{0xaa60, 0xaa76, 1},
-		{0xaa7a, 0xaa80, 6},
-		{0xaa81, 0xaaaf, 1},
+		{0xaa7a, 0xaa7e, 4},
+		{0xaa7f, 0xaaaf, 1},
 		{0xaab1, 0xaab5, 4},
 		{0xaab6, 0xaab9, 3},
 		{0xaaba, 0xaabd, 1},
@@ -444,6 +447,9 @@ var _L = &RangeTable{
 		{0xab11, 0xab16, 1},
 		{0xab20, 0xab26, 1},
 		{0xab28, 0xab2e, 1},
+		{0xab30, 0xab5a, 1},
+		{0xab5c, 0xab5f, 1},
+		{0xab64, 0xab65, 1},
 		{0xabc0, 0xabe2, 1},
 		{0xac00, 0xd7a3, 1},
 		{0xd7b0, 0xd7c6, 1},
@@ -484,19 +490,27 @@ var _L = &RangeTable{
 		{0x10080, 0x100fa, 1},
 		{0x10280, 0x1029c, 1},
 		{0x102a0, 0x102d0, 1},
-		{0x10300, 0x1031e, 1},
+		{0x10300, 0x1031f, 1},
 		{0x10330, 0x10340, 1},
 		{0x10342, 0x10349, 1},
+		{0x10350, 0x10375, 1},
 		{0x10380, 0x1039d, 1},
 		{0x103a0, 0x103c3, 1},
 		{0x103c8, 0x103cf, 1},
 		{0x10400, 0x1049d, 1},
+		{0x10500, 0x10527, 1},
+		{0x10530, 0x10563, 1},
+		{0x10600, 0x10736, 1},
+		{0x10740, 0x10755, 1},
+		{0x10760, 0x10767, 1},
 		{0x10800, 0x10805, 1},
 		{0x10808, 0x1080a, 2},
 		{0x1080b, 0x10835, 1},
 		{0x10837, 0x10838, 1},
 		{0x1083c, 0x1083f, 3},
 		{0x10840, 0x10855, 1},
+		{0x10860, 0x10876, 1},
+		{0x10880, 0x1089e, 1},
 		{0x10900, 0x10915, 1},
 		{0x10920, 0x10939, 1},
 		{0x10980, 0x109b7, 1},
@@ -506,24 +520,61 @@ var _L = &RangeTable{
 		{0x10a15, 0x10a17, 1},
 		{0x10a19, 0x10a33, 1},
 		{0x10a60, 0x10a7c, 1},
+		{0x10a80, 0x10a9c, 1},
+		{0x10ac0, 0x10ac7, 1},
+		{0x10ac9, 0x10ae4, 1},
 		{0x10b00, 0x10b35, 1},
 		{0x10b40, 0x10b55, 1},
 		{0x10b60, 0x10b72, 1},
+		{0x10b80, 0x10b91, 1},
 		{0x10c00, 0x10c48, 1},
 		{0x11003, 0x11037, 1},
 		{0x11083, 0x110af, 1},
 		{0x110d0, 0x110e8, 1},
 		{0x11103, 0x11126, 1},
-		{0x11183, 0x111b2, 1},
+		{0x11150, 0x11172, 1},
+		{0x11176, 0x11183, 13},
+		{0x11184, 0x111b2, 1},
 		{0x111c1, 0x111c4, 1},
-		{0x11680, 0x116aa, 1},
-		{0x12000, 0x1236e, 1},
+		{0x111da, 0x11200, 38},
+		{0x11201, 0x11211, 1},
+		{0x11213, 0x1122b, 1},
+		{0x112b0, 0x112de, 1},
+		{0x11305, 0x1130c, 1},
+		{0x1130f, 0x11310, 1},
+		{0x11313, 0x11328, 1},
+		{0x1132a, 0x11330, 1},
+		{0x11332, 0x11333, 1},
+		{0x11335, 0x11339, 1},
+		{0x1133d, 0x1135d, 32},
+		{0x1135e, 0x11361, 1},
+		{0x11480, 0x114af, 1},
+		{0x114c4, 0x114c5, 1},
+		{0x114c7, 0x11580, 185},
+		{0x11581, 0x115ae, 1},
+		{0x11600, 0x1162f, 1},
+		{0x11644, 0x11680, 60},
+		{0x11681, 0x116aa, 1},
+		{0x118a0, 0x118df, 1},
+		{0x118ff, 0x11ac0, 449},
+		{0x11ac1, 0x11af8, 1},
+		{0x12000, 0x12398, 1},
 		{0x13000, 0x1342e, 1},
 		{0x16800, 0x16a38, 1},
+		{0x16a40, 0x16a5e, 1},
+		{0x16ad0, 0x16aed, 1},
+		{0x16b00, 0x16b2f, 1},
+		{0x16b40, 0x16b43, 1},
+		{0x16b63, 0x16b77, 1},
+		{0x16b7d, 0x16b8f, 1},
 		{0x16f00, 0x16f44, 1},
 		{0x16f50, 0x16f93, 67},
 		{0x16f94, 0x16f9f, 1},
 		{0x1b000, 0x1b001, 1},
+		{0x1bc00, 0x1bc6a, 1},
+		{0x1bc70, 0x1bc7c, 1},
+		{0x1bc80, 0x1bc88, 1},
+		{0x1bc90, 0x1bc99, 1},
 		{0x1d400, 0x1d454, 1},
 		{0x1d456, 0x1d49c, 1},
 		{0x1d49e, 0x1d49f, 1},
@@ -554,6 +605,7 @@ var _L = &RangeTable{
 		{0x1d78a, 0x1d7a8, 1},
 		{0x1d7aa, 0x1d7c2, 1},
 		{0x1d7c4, 0x1d7cb, 1},
+		{0x1e800, 0x1e8c4, 1},
 		{0x1ee00, 0x1ee03, 1},
 		{0x1ee05, 0x1ee1f, 1},
 		{0x1ee21, 0x1ee22, 1},
@@ -637,7 +689,7 @@ var _Ll = &RangeTable{
 		{0x0461, 0x0481, 2},
 		{0x048b, 0x04bf, 2},
 		{0x04c2, 0x04ce, 2},
-		{0x04cf, 0x0527, 2},
+		{0x04cf, 0x052f, 2},
 		{0x0561, 0x0587, 1},
 		{0x1d00, 0x1d2b, 1},
 		{0x1d6b, 0x1d77, 1},
@@ -684,7 +736,7 @@ var _Ll = &RangeTable{
 		{0x2d00, 0x2d25, 1},
 		{0x2d27, 0x2d2d, 6},
 		{0xa641, 0xa66d, 2},
-		{0xa681, 0xa697, 2},
+		{0xa681, 0xa69b, 2},
 		{0xa723, 0xa72f, 2},
 		{0xa730, 0xa731, 1},
 		{0xa733, 0xa771, 2},
@@ -693,14 +745,18 @@ var _Ll = &RangeTable{
 		{0xa77f, 0xa787, 2},
 		{0xa78c, 0xa78e, 2},
 		{0xa791, 0xa793, 2},
-		{0xa7a1, 0xa7a9, 2},
-		{0xa7fa, 0xfb00, 21254},
-		{0xfb01, 0xfb06, 1},
+		{0xa794, 0xa795, 1},
+		{0xa797, 0xa7a9, 2},
+		{0xa7fa, 0xab30, 822},
+		{0xab31, 0xab5a, 1},
+		{0xab64, 0xab65, 1},
+		{0xfb00, 0xfb06, 1},
 		{0xfb13, 0xfb17, 1},
 		{0xff41, 0xff5a, 1},
 	},
 	R32: []Range32{
 		{0x10428, 0x1044f, 1},
+		{0x118c0, 0x118df, 1},
 		{0x1d41a, 0x1d433, 1},
 		{0x1d44e, 0x1d454, 1},
 		{0x1d456, 0x1d467, 1},
@@ -765,15 +821,20 @@ var _Lm = &RangeTable{
 		{0xa015, 0xa4f8, 1251},
 		{0xa4f9, 0xa4fd, 1},
 		{0xa60c, 0xa67f, 115},
+		{0xa69c, 0xa69d, 1},
 		{0xa717, 0xa71f, 1},
 		{0xa770, 0xa788, 24},
 		{0xa7f8, 0xa7f9, 1},
-		{0xa9cf, 0xaa70, 161},
-		{0xaadd, 0xaaf3, 22},
-		{0xaaf4, 0xff70, 21628},
-		{0xff9e, 0xff9f, 1},
+		{0xa9cf, 0xa9e6, 23},
+		{0xaa70, 0xaadd, 109},
+		{0xaaf3, 0xaaf4, 1},
+		{0xab5c, 0xab5f, 1},
+		{0xff70, 0xff9e, 46},
+		{0xff9f, 0xff9f, 1},
 	},
 	R32: []Range32{
+		{0x16b40, 0x16b40, 1},
+		{0x16b41, 0x16b43, 1},
 		{0x16f93, 0x16f9f, 1},
 	},
 }
@@ -800,13 +861,11 @@ var _Lo = &RangeTable{
 		{0x07cb, 0x07ea, 1},
 		{0x0800, 0x0815, 1},
 		{0x0840, 0x0858, 1},
-		{0x08a0, 0x08a2, 2},
-		{0x08a3, 0x08ac, 1},
+		{0x08a0, 0x08b2, 1},
 		{0x0904, 0x0939, 1},
 		{0x093d, 0x0950, 19},
 		{0x0958, 0x0961, 1},
-		{0x0972, 0x0977, 1},
-		{0x0979, 0x097f, 1},
+		{0x0972, 0x0980, 1},
 		{0x0985, 0x098c, 1},
 		{0x098f, 0x0990, 1},
 		{0x0993, 0x09a8, 1},
@@ -858,8 +917,7 @@ var _Lo = &RangeTable{
 		{0x0c06, 0x0c0c, 1},
 		{0x0c0e, 0x0c10, 1},
 		{0x0c12, 0x0c28, 1},
-		{0x0c2a, 0x0c33, 1},
-		{0x0c35, 0x0c39, 1},
+		{0x0c2a, 0x0c39, 1},
 		{0x0c3d, 0x0c58, 27},
 		{0x0c59, 0x0c60, 7},
 		{0x0c61, 0x0c85, 36},
@@ -935,6 +993,7 @@ var _Lo = &RangeTable{
 		{0x166f, 0x167f, 1},
 		{0x1681, 0x169a, 1},
 		{0x16a0, 0x16ea, 1},
+		{0x16f1, 0x16f8, 1},
 		{0x1700, 0x170c, 1},
 		{0x170e, 0x1711, 1},
 		{0x1720, 0x1731, 1},
@@ -948,7 +1007,7 @@ var _Lo = &RangeTable{
 		{0x1880, 0x18a8, 1},
 		{0x18aa, 0x18b0, 6},
 		{0x18b1, 0x18f5, 1},
-		{0x1900, 0x191c, 1},
+		{0x1900, 0x191e, 1},
 		{0x1950, 0x196d, 1},
 		{0x1970, 0x1974, 1},
 		{0x1980, 0x19ab, 1},
@@ -996,7 +1055,8 @@ var _Lo = &RangeTable{
 		{0xa62a, 0xa62b, 1},
 		{0xa66e, 0xa6a0, 50},
 		{0xa6a1, 0xa6e5, 1},
-		{0xa7fb, 0xa801, 1},
+		{0xa7f7, 0xa7fb, 4},
+		{0xa7fc, 0xa801, 1},
 		{0xa803, 0xa805, 1},
 		{0xa807, 0xa80a, 1},
 		{0xa80c, 0xa822, 1},
@@ -1008,13 +1068,16 @@ var _Lo = &RangeTable{
 		{0xa930, 0xa946, 1},
 		{0xa960, 0xa97c, 1},
 		{0xa984, 0xa9b2, 1},
+		{0xa9e0, 0xa9e4, 1},
+		{0xa9e7, 0xa9ef, 1},
+		{0xa9fa, 0xa9fe, 1},
 		{0xaa00, 0xaa28, 1},
 		{0xaa40, 0xaa42, 1},
 		{0xaa44, 0xaa4b, 1},
 		{0xaa60, 0xaa6f, 1},
 		{0xaa71, 0xaa76, 1},
-		{0xaa7a, 0xaa80, 6},
-		{0xaa81, 0xaaaf, 1},
+		{0xaa7a, 0xaa7e, 4},
+		{0xaa7f, 0xaaaf, 1},
 		{0xaab1, 0xaab5, 4},
 		{0xaab6, 0xaab9, 3},
 		{0xaaba, 0xaabd, 1},
@@ -1065,19 +1128,27 @@ var _Lo = &RangeTable{
 		{0x10080, 0x100fa, 1},
 		{0x10280, 0x1029c, 1},
 		{0x102a0, 0x102d0, 1},
-		{0x10300, 0x1031e, 1},
+		{0x10300, 0x1031f, 1},
 		{0x10330, 0x10340, 1},
 		{0x10342, 0x10349, 1},
+		{0x10350, 0x10375, 1},
 		{0x10380, 0x1039d, 1},
 		{0x103a0, 0x103c3, 1},
 		{0x103c8, 0x103cf, 1},
 		{0x10450, 0x1049d, 1},
+		{0x10500, 0x10527, 1},
+		{0x10530, 0x10563, 1},
+		{0x10600, 0x10736, 1},
+		{0x10740, 0x10755, 1},
+		{0x10760, 0x10767, 1},
 		{0x10800, 0x10805, 1},
 		{0x10808, 0x1080a, 2},
 		{0x1080b, 0x10835, 1},
 		{0x10837, 0x10838, 1},
 		{0x1083c, 0x1083f, 3},
 		{0x10840, 0x10855, 1},
+		{0x10860, 0x10876, 1},
+		{0x10880, 0x1089e, 1},
 		{0x10900, 0x10915, 1},
 		{0x10920, 0x10939, 1},
 		{0x10980, 0x109b7, 1},
@@ -1087,24 +1158,60 @@ var _Lo = &RangeTable{
 		{0x10a15, 0x10a17, 1},
 		{0x10a19, 0x10a33, 1},
 		{0x10a60, 0x10a7c, 1},
+		{0x10a80, 0x10a9c, 1},
+		{0x10ac0, 0x10ac7, 1},
+		{0x10ac9, 0x10ae4, 1},
 		{0x10b00, 0x10b35, 1},
 		{0x10b40, 0x10b55, 1},
 		{0x10b60, 0x10b72, 1},
+		{0x10b80, 0x10b91, 1},
 		{0x10c00, 0x10c48, 1},
 		{0x11003, 0x11037, 1},
 		{0x11083, 0x110af, 1},
 		{0x110d0, 0x110e8, 1},
 		{0x11103, 0x11126, 1},
-		{0x11183, 0x111b2, 1},
+		{0x11150, 0x11172, 1},
+		{0x11176, 0x11183, 13},
+		{0x11184, 0x111b2, 1},
 		{0x111c1, 0x111c4, 1},
-		{0x11680, 0x116aa, 1},
-		{0x12000, 0x1236e, 1},
+		{0x111da, 0x11200, 38},
+		{0x11201, 0x11211, 1},
+		{0x11213, 0x1122b, 1},
+		{0x112b0, 0x112de, 1},
+		{0x11305, 0x1130c, 1},
+		{0x1130f, 0x11310, 1},
+		{0x11313, 0x11328, 1},
+		{0x1132a, 0x11330, 1},
+		{0x11332, 0x11333, 1},
+		{0x11335, 0x11339, 1},
+		{0x1133d, 0x1135d, 32},
+		{0x1135e, 0x11361, 1},
+		{0x11480, 0x114af, 1},
+		{0x114c4, 0x114c5, 1},
+		{0x114c7, 0x11580, 185},
+		{0x11581, 0x115ae, 1},
+		{0x11600, 0x1162f, 1},
+		{0x11644, 0x11680, 60},
+		{0x11681, 0x116aa, 1},
+		{0x118ff, 0x11ac0, 449},
+		{0x11ac1, 0x11af8, 1},
+		{0x12000, 0x12398, 1},
 		{0x13000, 0x1342e, 1},
 		{0x16800, 0x16a38, 1},
+		{0x16a40, 0x16a5e, 1},
+		{0x16ad0, 0x16aed, 1},
+		{0x16b00, 0x16b2f, 1},
+		{0x16b63, 0x16b77, 1},
+		{0x16b7d, 0x16b8f, 1},
 		{0x16f00, 0x16f44, 1},
 		{0x16f50, 0x1b000, 16560},
-		{0x1b001, 0x1ee00, 15871},
-		{0x1ee01, 0x1ee03, 1},
+		{0x1b001, 0x1bc00, 3071},
+		{0x1bc01, 0x1bc6a, 1},
+		{0x1bc70, 0x1bc7c, 1},
+		{0x1bc80, 0x1bc88, 1},
+		{0x1bc90, 0x1bc99, 1},
+		{0x1e800, 0x1e8c4, 1},
+		{0x1ee00, 0x1ee03, 1},
 		{0x1ee05, 0x1ee1f, 1},
 		{0x1ee21, 0x1ee22, 1},
 		{0x1ee24, 0x1ee27, 3},
@@ -1185,8 +1292,9 @@ var _Lu = &RangeTable{
 		{0x0244, 0x0246, 1},
 		{0x0248, 0x024e, 2},
 		{0x0370, 0x0372, 2},
-		{0x0376, 0x0386, 16},
-		{0x0388, 0x038a, 1},
+		{0x0376, 0x037f, 9},
+		{0x0386, 0x0388, 2},
+		{0x0389, 0x038a, 1},
 		{0x038c, 0x038e, 2},
 		{0x038f, 0x0391, 2},
 		{0x0392, 0x03a1, 1},
@@ -1200,7 +1308,7 @@ var _Lu = &RangeTable{
 		{0x0460, 0x0480, 2},
 		{0x048a, 0x04c0, 2},
 		{0x04c1, 0x04cd, 2},
-		{0x04d0, 0x0526, 2},
+		{0x04d0, 0x052e, 2},
 		{0x0531, 0x0556, 1},
 		{0x10a0, 0x10c5, 1},
 		{0x10c7, 0x10cd, 6},
@@ -1239,18 +1347,21 @@ var _Lu = &RangeTable{
 		{0x2ceb, 0x2ced, 2},
 		{0x2cf2, 0xa640, 31054},
 		{0xa642, 0xa66c, 2},
-		{0xa680, 0xa696, 2},
+		{0xa680, 0xa69a, 2},
 		{0xa722, 0xa72e, 2},
 		{0xa732, 0xa76e, 2},
 		{0xa779, 0xa77d, 2},
 		{0xa77e, 0xa786, 2},
 		{0xa78b, 0xa78d, 2},
 		{0xa790, 0xa792, 2},
-		{0xa7a0, 0xa7aa, 2},
+		{0xa796, 0xa7aa, 2},
+		{0xa7ab, 0xa7ad, 1},
+		{0xa7b0, 0xa7b1, 1},
 		{0xff21, 0xff3a, 1},
 	},
 	R32: []Range32{
 		{0x10400, 0x10427, 1},
+		{0x118a0, 0x118bf, 1},
 		{0x1d400, 0x1d419, 1},
 		{0x1d434, 0x1d44d, 1},
 		{0x1d468, 0x1d481, 1},
@@ -1309,8 +1420,7 @@ var _M = &RangeTable{
 		{0x0825, 0x0827, 1},
 		{0x0829, 0x082d, 1},
 		{0x0859, 0x085b, 1},
-		{0x08e4, 0x08fe, 1},
-		{0x0900, 0x0903, 1},
+		{0x08e4, 0x0903, 1},
 		{0x093a, 0x093c, 1},
 		{0x093e, 0x094f, 1},
 		{0x0951, 0x0957, 1},
@@ -1346,21 +1456,21 @@ var _M = &RangeTable{
 		{0x0bbf, 0x0bc2, 1},
 		{0x0bc6, 0x0bc8, 1},
 		{0x0bca, 0x0bcd, 1},
-		{0x0bd7, 0x0c01, 42},
-		{0x0c02, 0x0c03, 1},
+		{0x0bd7, 0x0c00, 41},
+		{0x0c01, 0x0c03, 1},
 		{0x0c3e, 0x0c44, 1},
 		{0x0c46, 0x0c48, 1},
 		{0x0c4a, 0x0c4d, 1},
 		{0x0c55, 0x0c56, 1},
 		{0x0c62, 0x0c63, 1},
-		{0x0c82, 0x0c83, 1},
+		{0x0c81, 0x0c83, 1},
 		{0x0cbc, 0x0cbe, 2},
 		{0x0cbf, 0x0cc4, 1},
 		{0x0cc6, 0x0cc8, 1},
 		{0x0cca, 0x0ccd, 1},
 		{0x0cd5, 0x0cd6, 1},
 		{0x0ce2, 0x0ce3, 1},
-		{0x0d02, 0x0d03, 1},
+		{0x0d01, 0x0d03, 1},
 		{0x0d3e, 0x0d44, 1},
 		{0x0d46, 0x0d48, 1},
 		{0x0d4a, 0x0d4d, 1},
@@ -1411,8 +1521,9 @@ var _M = &RangeTable{
 		{0x1a17, 0x1a1b, 1},
 		{0x1a55, 0x1a5e, 1},
 		{0x1a60, 0x1a7c, 1},
-		{0x1a7f, 0x1b00, 129},
-		{0x1b01, 0x1b04, 1},
+		{0x1a7f, 0x1ab0, 49},
+		{0x1ab1, 0x1abe, 1},
+		{0x1b00, 0x1b04, 1},
 		{0x1b34, 0x1b44, 1},
 		{0x1b6b, 0x1b73, 1},
 		{0x1b80, 0x1b82, 1},
@@ -1423,7 +1534,8 @@ var _M = &RangeTable{
 		{0x1cd4, 0x1ce8, 1},
 		{0x1ced, 0x1cf2, 5},
 		{0x1cf3, 0x1cf4, 1},
-		{0x1dc0, 0x1de6, 1},
+		{0x1cf8, 0x1cf9, 1},
+		{0x1dc0, 0x1df5, 1},
 		{0x1dfc, 0x1dff, 1},
 		{0x20d0, 0x20f0, 1},
 		{0x2cef, 0x2cf1, 1},
@@ -1444,9 +1556,11 @@ var _M = &RangeTable{
 		{0xa947, 0xa953, 1},
 		{0xa980, 0xa983, 1},
 		{0xa9b3, 0xa9c0, 1},
-		{0xaa29, 0xaa36, 1},
+		{0xa9e5, 0xaa29, 68},
+		{0xaa2a, 0xaa36, 1},
 		{0xaa43, 0xaa4c, 9},
 		{0xaa4d, 0xaa7b, 46},
+		{0xaa7c, 0xaa7d, 1},
 		{0xaab0, 0xaab2, 2},
 		{0xaab3, 0xaab4, 1},
 		{0xaab7, 0xaab8, 1},
@@ -1458,32 +1572,54 @@ var _M = &RangeTable{
 		{0xabec, 0xabed, 1},
 		{0xfb1e, 0xfe00, 738},
 		{0xfe01, 0xfe0f, 1},
-		{0xfe20, 0xfe26, 1},
+		{0xfe20, 0xfe2d, 1},
 	},
 	R32: []Range32{
-		{0x101fd, 0x10a01, 2052},
-		{0x10a02, 0x10a03, 1},
+		{0x101fd, 0x102e0, 227},
+		{0x10376, 0x1037a, 1},
+		{0x10a01, 0x10a03, 1},
 		{0x10a05, 0x10a06, 1},
 		{0x10a0c, 0x10a0f, 1},
 		{0x10a38, 0x10a3a, 1},
-		{0x10a3f, 0x11000, 1473},
+		{0x10a3f, 0x10ae5, 166},
+		{0x10ae6, 0x11000, 1306},
 		{0x11001, 0x11002, 1},
 		{0x11038, 0x11046, 1},
-		{0x11080, 0x11082, 1},
+		{0x1107f, 0x11082, 1},
 		{0x110b0, 0x110ba, 1},
 		{0x11100, 0x11102, 1},
 		{0x11127, 0x11134, 1},
-		{0x11180, 0x11182, 1},
+		{0x11173, 0x11180, 13},
+		{0x11181, 0x11182, 1},
 		{0x111b3, 0x111c0, 1},
+		{0x1122c, 0x11237, 1},
+		{0x112df, 0x112ea, 1},
+		{0x11301, 0x11303, 1},
+		{0x1133c, 0x1133e, 2},
+		{0x1133f, 0x11344, 1},
+		{0x11347, 0x11348, 1},
+		{0x1134b, 0x1134d, 1},
+		{0x11357, 0x11362, 11},
+		{0x11363, 0x11366, 3},
+		{0x11367, 0x1136c, 1},
+		{0x11370, 0x11374, 1},
+		{0x114b0, 0x114c3, 1},
+		{0x115af, 0x115b5, 1},
+		{0x115b8, 0x115c0, 1},
+		{0x11630, 0x11640, 1},
 		{0x116ab, 0x116b7, 1},
+		{0x16af0, 0x16af4, 1},
+		{0x16b30, 0x16b36, 1},
 		{0x16f51, 0x16f7e, 1},
 		{0x16f8f, 0x16f92, 1},
+		{0x1bc9d, 0x1bc9e, 1},
 		{0x1d165, 0x1d169, 1},
 		{0x1d16d, 0x1d172, 1},
 		{0x1d17b, 0x1d182, 1},
 		{0x1d185, 0x1d18b, 1},
 		{0x1d1aa, 0x1d1ad, 1},
 		{0x1d242, 0x1d244, 1},
+		{0x1e8d0, 0x1e8d6, 1},
 		{0xe0100, 0xe01ef, 1},
 	},
 }
@@ -1562,8 +1698,7 @@ var _Mc = &RangeTable{
 		{0x1b43, 0x1b44, 1},
 		{0x1b82, 0x1ba1, 31},
 		{0x1ba6, 0x1ba7, 1},
-		{0x1baa, 0x1bac, 2},
-		{0x1bad, 0x1be7, 58},
+		{0x1baa, 0x1be7, 61},
 		{0x1bea, 0x1bec, 1},
 		{0x1bee, 0x1bf2, 4},
 		{0x1bf3, 0x1c24, 49},
@@ -1583,24 +1718,45 @@ var _Mc = &RangeTable{
 		{0xaa2f, 0xaa30, 1},
 		{0xaa33, 0xaa34, 1},
 		{0xaa4d, 0xaa7b, 46},
-		{0xaaeb, 0xaaee, 3},
-		{0xaaef, 0xaaf5, 6},
-		{0xabe3, 0xabe4, 1},
-		{0xabe6, 0xabe7, 1},
-		{0xabe9, 0xabea, 1},
-		{0xabec, 0xabec, 1},
+		{0xaa7d, 0xaaeb, 110},
+		{0xaaee, 0xaaef, 1},
+		{0xaaf5, 0xabe3, 238},
+		{0xabe4, 0xabe6, 2},
+		{0xabe7, 0xabe9, 2},
+		{0xabea, 0xabec, 2},
 	},
 	R32: []Range32{
-		{0x11000, 0x11000, 1},
-		{0x11002, 0x11082, 128},
-		{0x110b0, 0x110b2, 1},
+		{0x11000, 0x11002, 2},
+		{0x11082, 0x110b0, 46},
+		{0x110b1, 0x110b2, 1},
 		{0x110b7, 0x110b8, 1},
 		{0x1112c, 0x11182, 86},
 		{0x111b3, 0x111b5, 1},
 		{0x111bf, 0x111c0, 1},
-		{0x116ac, 0x116ae, 2},
-		{0x116af, 0x116b6, 7},
-		{0x16f51, 0x16f7e, 1},
+		{0x1122c, 0x1122e, 1},
+		{0x11232, 0x11233, 1},
+		{0x11235, 0x112e0, 171},
+		{0x112e1, 0x112e2, 1},
+		{0x11302, 0x11303, 1},
+		{0x1133e, 0x1133f, 1},
+		{0x11341, 0x11344, 1},
+		{0x11347, 0x11348, 1},
+		{0x1134b, 0x1134d, 1},
+		{0x11357, 0x11362, 11},
+		{0x11363, 0x114b0, 333},
+		{0x114b1, 0x114b2, 1},
+		{0x114b9, 0x114bb, 2},
+		{0x114bc, 0x114be, 1},
+		{0x114c1, 0x115af, 238},
+		{0x115b0, 0x115b1, 1},
+		{0x115b8, 0x115bb, 1},
+		{0x115be, 0x11630, 114},
+		{0x11631, 0x11632, 1},
+		{0x1163b, 0x1163c, 1},
+		{0x1163e, 0x116ac, 110},
+		{0x116ae, 0x116af, 1},
+		{0x116b6, 0x16f51, 22683},
+		{0x16f52, 0x16f7e, 1},
 		{0x1d165, 0x1d166, 1},
 		{0x1d16d, 0x1d172, 1},
 	},
@@ -1609,7 +1765,8 @@ var _Mc = &RangeTable{
 var _Me = &RangeTable{
 	R16: []Range16{
 		{0x0488, 0x0489, 1},
-		{0x20dd, 0x20e0, 1},
+		{0x1abe, 0x20dd, 1567},
+		{0x20de, 0x20e0, 1},
 		{0x20e2, 0x20e4, 1},
 		{0xa670, 0xa672, 1},
 	},
@@ -1639,8 +1796,7 @@ var _Mn = &RangeTable{
 		{0x0825, 0x0827, 1},
 		{0x0829, 0x082d, 1},
 		{0x0859, 0x085b, 1},
-		{0x08e4, 0x08fe, 1},
-		{0x0900, 0x0902, 1},
+		{0x08e4, 0x0902, 1},
 		{0x093a, 0x093c, 2},
 		{0x0941, 0x0948, 1},
 		{0x094d, 0x0951, 4},
@@ -1667,16 +1823,17 @@ var _Mn = &RangeTable{
 		{0x0b4d, 0x0b56, 9},
 		{0x0b62, 0x0b63, 1},
 		{0x0b82, 0x0bc0, 62},
-		{0x0bcd, 0x0c3e, 113},
-		{0x0c3f, 0x0c40, 1},
+		{0x0bcd, 0x0c00, 51},
+		{0x0c3e, 0x0c40, 1},
 		{0x0c46, 0x0c48, 1},
 		{0x0c4a, 0x0c4d, 1},
 		{0x0c55, 0x0c56, 1},
 		{0x0c62, 0x0c63, 1},
-		{0x0cbc, 0x0cbf, 3},
-		{0x0cc6, 0x0ccc, 6},
-		{0x0ccd, 0x0ce2, 21},
-		{0x0ce3, 0x0d41, 94},
+		{0x0c81, 0x0cbc, 59},
+		{0x0cbf, 0x0cc6, 7},
+		{0x0ccc, 0x0ccd, 1},
+		{0x0ce2, 0x0ce3, 1},
+		{0x0d01, 0x0d41, 64},
 		{0x0d42, 0x0d44, 1},
 		{0x0d4d, 0x0d62, 21},
 		{0x0d63, 0x0dca, 103},
@@ -1728,8 +1885,9 @@ var _Mn = &RangeTable{
 		{0x1a60, 0x1a62, 2},
 		{0x1a65, 0x1a6c, 1},
 		{0x1a73, 0x1a7c, 1},
-		{0x1a7f, 0x1b00, 129},
-		{0x1b01, 0x1b03, 1},
+		{0x1a7f, 0x1ab0, 49},
+		{0x1ab1, 0x1abd, 1},
+		{0x1b00, 0x1b03, 1},
 		{0x1b34, 0x1b36, 2},
 		{0x1b37, 0x1b3a, 1},
 		{0x1b3c, 0x1b42, 6},
@@ -1737,17 +1895,18 @@ var _Mn = &RangeTable{
 		{0x1b80, 0x1b81, 1},
 		{0x1ba2, 0x1ba5, 1},
 		{0x1ba8, 0x1ba9, 1},
-		{0x1bab, 0x1be6, 59},
-		{0x1be8, 0x1be9, 1},
-		{0x1bed, 0x1bef, 2},
-		{0x1bf0, 0x1bf1, 1},
+		{0x1bab, 0x1bad, 1},
+		{0x1be6, 0x1be8, 2},
+		{0x1be9, 0x1bed, 4},
+		{0x1bef, 0x1bf1, 1},
 		{0x1c2c, 0x1c33, 1},
 		{0x1c36, 0x1c37, 1},
 		{0x1cd0, 0x1cd2, 1},
 		{0x1cd4, 0x1ce0, 1},
 		{0x1ce2, 0x1ce8, 1},
 		{0x1ced, 0x1cf4, 7},
-		{0x1dc0, 0x1de6, 1},
+		{0x1cf8, 0x1cf9, 1},
+		{0x1dc0, 0x1df5, 1},
 		{0x1dfc, 0x1dff, 1},
 		{0x20d0, 0x20dc, 1},
 		{0x20e1, 0x20e5, 4},
@@ -1770,13 +1929,13 @@ var _Mn = &RangeTable{
 		{0xa980, 0xa982, 1},
 		{0xa9b3, 0xa9b6, 3},
 		{0xa9b7, 0xa9b9, 1},
-		{0xa9bc, 0xaa29, 109},
-		{0xaa2a, 0xaa2e, 1},
+		{0xa9bc, 0xa9e5, 41},
+		{0xaa29, 0xaa2e, 1},
 		{0xaa31, 0xaa32, 1},
 		{0xaa35, 0xaa36, 1},
 		{0xaa43, 0xaa4c, 9},
-		{0xaab0, 0xaab2, 2},
-		{0xaab3, 0xaab4, 1},
+		{0xaa7c, 0xaab0, 52},
+		{0xaab2, 0xaab4, 1},
 		{0xaab7, 0xaab8, 1},
 		{0xaabe, 0xaabf, 1},
 		{0xaac1, 0xaaec, 43},
@@ -1784,33 +1943,58 @@ var _Mn = &RangeTable{
 		{0xabe5, 0xabe8, 3},
 		{0xabed, 0xfb1e, 20273},
 		{0xfe00, 0xfe0f, 1},
-		{0xfe20, 0xfe26, 1},
+		{0xfe20, 0xfe2d, 1},
 	},
 	R32: []Range32{
-		{0x101fd, 0x10a01, 2052},
-		{0x10a02, 0x10a03, 1},
+		{0x101fd, 0x102e0, 227},
+		{0x10376, 0x1037a, 1},
+		{0x10a01, 0x10a03, 1},
 		{0x10a05, 0x10a06, 1},
 		{0x10a0c, 0x10a0f, 1},
 		{0x10a38, 0x10a3a, 1},
-		{0x10a3f, 0x11001, 1474},
+		{0x10a3f, 0x10ae5, 166},
+		{0x10ae6, 0x11001, 1307},
 		{0x11038, 0x11046, 1},
-		{0x11080, 0x11081, 1},
+		{0x1107f, 0x11081, 1},
 		{0x110b3, 0x110b6, 1},
 		{0x110b9, 0x110ba, 1},
 		{0x11100, 0x11102, 1},
 		{0x11127, 0x1112b, 1},
 		{0x1112d, 0x11134, 1},
-		{0x11180, 0x11181, 1},
-		{0x111b6, 0x111be, 1},
-		{0x116ab, 0x116ad, 2},
-		{0x116b0, 0x116b5, 1},
-		{0x116b7, 0x16f8f, 22744},
-		{0x16f90, 0x16f92, 1},
+		{0x11173, 0x11180, 13},
+		{0x11181, 0x111b6, 53},
+		{0x111b7, 0x111be, 1},
+		{0x1122f, 0x11231, 1},
+		{0x11234, 0x11236, 2},
+		{0x11237, 0x112df, 168},
+		{0x112e3, 0x112ea, 1},
+		{0x11301, 0x1133c, 59},
+		{0x11340, 0x11366, 38},
+		{0x11367, 0x1136c, 1},
+		{0x11370, 0x11374, 1},
+		{0x114b3, 0x114b8, 1},
+		{0x114ba, 0x114bf, 5},
+		{0x114c0, 0x114c2, 2},
+		{0x114c3, 0x115b2, 239},
+		{0x115b3, 0x115b5, 1},
+		{0x115bc, 0x115bd, 1},
+		{0x115bf, 0x115c0, 1},
+		{0x11633, 0x1163a, 1},
+		{0x1163d, 0x1163f, 2},
+		{0x11640, 0x116ab, 107},
+		{0x116ad, 0x116b0, 3},
+		{0x116b1, 0x116b5, 1},
+		{0x116b7, 0x16af0, 21561},
+		{0x16af1, 0x16af4, 1},
+		{0x16b30, 0x16b36, 1},
+		{0x16f8f, 0x16f92, 1},
+		{0x1bc9d, 0x1bc9e, 1},
 		{0x1d167, 0x1d169, 1},
 		{0x1d17b, 0x1d182, 1},
 		{0x1d185, 0x1d18b, 1},
 		{0x1d1aa, 0x1d1ad, 1},
 		{0x1d242, 0x1d244, 1},
+		{0x1e8d0, 0x1e8d6, 1},
 		{0xe0100, 0xe01ef, 1},
 	},
 }
@@ -1836,6 +2020,7 @@ var _N = &RangeTable{
 		{0x0c78, 0x0c7e, 1},
 		{0x0ce6, 0x0cef, 1},
 		{0x0d66, 0x0d75, 1},
+		{0x0de6, 0x0def, 1},
 		{0x0e50, 0x0e59, 1},
 		{0x0ed0, 0x0ed9, 1},
 		{0x0f20, 0x0f33, 1},
@@ -1877,6 +2062,7 @@ var _N = &RangeTable{
 		{0xa8d0, 0xa8d9, 1},
 		{0xa900, 0xa909, 1},
 		{0xa9d0, 0xa9d9, 1},
+		{0xa9f0, 0xa9f9, 1},
 		{0xaa50, 0xaa59, 1},
 		{0xabf0, 0xabf9, 1},
 		{0xff10, 0xff19, 1},
@@ -1884,27 +2070,42 @@ var _N = &RangeTable{
 	R32: []Range32{
 		{0x10107, 0x10133, 1},
 		{0x10140, 0x10178, 1},
-		{0x1018a, 0x10320, 406},
-		{0x10321, 0x10323, 1},
+		{0x1018a, 0x1018b, 1},
+		{0x102e1, 0x102fb, 1},
+		{0x10320, 0x10323, 1},
 		{0x10341, 0x1034a, 9},
 		{0x103d1, 0x103d5, 1},
 		{0x104a0, 0x104a9, 1},
 		{0x10858, 0x1085f, 1},
+		{0x10879, 0x1087f, 1},
+		{0x108a7, 0x108af, 1},
 		{0x10916, 0x1091b, 1},
 		{0x10a40, 0x10a47, 1},
 		{0x10a7d, 0x10a7e, 1},
+		{0x10a9d, 0x10a9f, 1},
+		{0x10aeb, 0x10aef, 1},
 		{0x10b58, 0x10b5f, 1},
 		{0x10b78, 0x10b7f, 1},
+		{0x10ba9, 0x10baf, 1},
 		{0x10e60, 0x10e7e, 1},
 		{0x11052, 0x1106f, 1},
 		{0x110f0, 0x110f9, 1},
 		{0x11136, 0x1113f, 1},
 		{0x111d0, 0x111d9, 1},
+		{0x111e1, 0x111f4, 1},
+		{0x112f0, 0x112f9, 1},
+		{0x114d0, 0x114d9, 1},
+		{0x11650, 0x11659, 1},
 		{0x116c0, 0x116c9, 1},
-		{0x12400, 0x12462, 1},
+		{0x118e0, 0x118f2, 1},
+		{0x12400, 0x1246e, 1},
+		{0x16a60, 0x16a69, 1},
+		{0x16b50, 0x16b59, 1},
+		{0x16b5b, 0x16b61, 1},
 		{0x1d360, 0x1d371, 1},
 		{0x1d7ce, 0x1d7ff, 1},
-		{0x1f100, 0x1f10a, 1},
+		{0x1e8c7, 0x1e8cf, 1},
+		{0x1f100, 0x1f10c, 1},
 	},
 	LatinOffset: 4,
 }
@@ -1924,6 +2125,7 @@ var _Nd = &RangeTable{
 		{0x0c66, 0x0c6f, 1},
 		{0x0ce6, 0x0cef, 1},
 		{0x0d66, 0x0d6f, 1},
+		{0x0de6, 0x0def, 1},
 		{0x0e50, 0x0e59, 1},
 		{0x0ed0, 0x0ed9, 1},
 		{0x0f20, 0x0f29, 1},
@@ -1943,6 +2145,7 @@ var _Nd = &RangeTable{
 		{0xa8d0, 0xa8d9, 1},
 		{0xa900, 0xa909, 1},
 		{0xa9d0, 0xa9d9, 1},
+		{0xa9f0, 0xa9f9, 1},
 		{0xaa50, 0xaa59, 1},
 		{0xabf0, 0xabf9, 1},
 		{0xff10, 0xff19, 1},
@@ -1953,7 +2156,13 @@ var _Nd = &RangeTable{
 		{0x110f0, 0x110f9, 1},
 		{0x11136, 0x1113f, 1},
 		{0x111d0, 0x111d9, 1},
+		{0x112f0, 0x112f9, 1},
+		{0x114d0, 0x114d9, 1},
+		{0x11650, 0x11659, 1},
 		{0x116c0, 0x116c9, 1},
+		{0x118e0, 0x118e9, 1},
+		{0x16a60, 0x16a69, 1},
+		{0x16b50, 0x16b59, 1},
 		{0x1d7ce, 0x1d7ff, 1},
 	},
 	LatinOffset: 1,
@@ -1973,7 +2182,7 @@ var _Nl = &RangeTable{
 		{0x10140, 0x10174, 1},
 		{0x10341, 0x1034a, 9},
 		{0x103d1, 0x103d5, 1},
-		{0x12400, 0x12462, 1},
+		{0x12400, 0x1246e, 1},
 	},
 }
 
@@ -2010,18 +2219,28 @@ var _No = &RangeTable{
 	R32: []Range32{
 		{0x10107, 0x10133, 1},
 		{0x10175, 0x10178, 1},
-		{0x1018a, 0x10320, 406},
-		{0x10321, 0x10323, 1},
+		{0x1018a, 0x1018b, 1},
+		{0x102e1, 0x102fb, 1},
+		{0x10320, 0x10323, 1},
 		{0x10858, 0x1085f, 1},
+		{0x10879, 0x1087f, 1},
+		{0x108a7, 0x108af, 1},
 		{0x10916, 0x1091b, 1},
 		{0x10a40, 0x10a47, 1},
 		{0x10a7d, 0x10a7e, 1},
+		{0x10a9d, 0x10a9f, 1},
+		{0x10aeb, 0x10aef, 1},
 		{0x10b58, 0x10b5f, 1},
 		{0x10b78, 0x10b7f, 1},
+		{0x10ba9, 0x10baf, 1},
 		{0x10e60, 0x10e7e, 1},
 		{0x11052, 0x11065, 1},
+		{0x111e1, 0x111f4, 1},
+		{0x118ea, 0x118f2, 1},
+		{0x16b5b, 0x16b61, 1},
 		{0x1d360, 0x1d371, 1},
-		{0x1f100, 0x1f10a, 1},
+		{0x1e8c7, 0x1e8cf, 1},
+		{0x1f100, 0x1f10c, 1},
 	},
 	LatinOffset: 3,
 }
@@ -2104,7 +2323,7 @@ var _P = &RangeTable{
 		{0x2cfe, 0x2cff, 1},
 		{0x2d70, 0x2e00, 144},
 		{0x2e01, 0x2e2e, 1},
-		{0x2e30, 0x2e3b, 1},
+		{0x2e30, 0x2e42, 1},
 		{0x3001, 0x3003, 1},
 		{0x3008, 0x3011, 1},
 		{0x3014, 0x301f, 1},
@@ -2144,17 +2363,29 @@ var _P = &RangeTable{
 	R32: []Range32{
 		{0x10100, 0x10102, 1},
 		{0x1039f, 0x103d0, 49},
-		{0x10857, 0x1091f, 200},
-		{0x1093f, 0x10a50, 273},
-		{0x10a51, 0x10a58, 1},
-		{0x10a7f, 0x10b39, 186},
-		{0x10b3a, 0x10b3f, 1},
+		{0x1056f, 0x10857, 744},
+		{0x1091f, 0x1093f, 32},
+		{0x10a50, 0x10a58, 1},
+		{0x10a7f, 0x10af0, 113},
+		{0x10af1, 0x10af6, 1},
+		{0x10b39, 0x10b3f, 1},
+		{0x10b99, 0x10b9c, 1},
 		{0x11047, 0x1104d, 1},
 		{0x110bb, 0x110bc, 1},
 		{0x110be, 0x110c1, 1},
 		{0x11140, 0x11143, 1},
+		{0x11174, 0x11175, 1},
 		{0x111c5, 0x111c8, 1},
-		{0x12470, 0x12473, 1},
+		{0x111cd, 0x11238, 107},
+		{0x11239, 0x1123d, 1},
+		{0x114c6, 0x115c1, 251},
+		{0x115c2, 0x115c9, 1},
+		{0x11641, 0x11643, 1},
+		{0x12470, 0x12474, 1},
+		{0x16a6e, 0x16a6f, 1},
+		{0x16af5, 0x16b37, 66},
+		{0x16b38, 0x16b3b, 1},
+		{0x16b44, 0x1bc9f, 20827},
 	},
 	LatinOffset: 11,
 }
@@ -2177,10 +2408,11 @@ var _Pd = &RangeTable{
 		{0x2011, 0x2015, 1},
 		{0x2e17, 0x2e1a, 3},
 		{0x2e3a, 0x2e3b, 1},
-		{0x301c, 0x3030, 20},
-		{0x30a0, 0xfe31, 52625},
-		{0xfe32, 0xfe58, 38},
-		{0xfe63, 0xff0d, 170},
+		{0x2e40, 0x301c, 476},
+		{0x3030, 0x30a0, 112},
+		{0xfe31, 0xfe32, 1},
+		{0xfe58, 0xfe63, 11},
+		{0xff0d, 0xff0d, 1},
 	},
 }
 
@@ -2202,7 +2434,7 @@ var _Pe = &RangeTable{
 		{0x3009, 0x3011, 2},
 		{0x3015, 0x301b, 2},
 		{0x301e, 0x301f, 1},
-		{0xfd3f, 0xfe18, 217},
+		{0xfd3e, 0xfe18, 218},
 		{0xfe36, 0xfe44, 2},
 		{0xfe48, 0xfe5a, 18},
 		{0xfe5c, 0xfe5e, 2},
@@ -2307,7 +2539,9 @@ var _Po = &RangeTable{
 		{0x2e1f, 0x2e2a, 11},
 		{0x2e2b, 0x2e2e, 1},
 		{0x2e30, 0x2e39, 1},
-		{0x3001, 0x3003, 1},
+		{0x2e3c, 0x2e3f, 1},
+		{0x2e41, 0x3001, 448},
+		{0x3002, 0x3003, 1},
 		{0x303d, 0x30fb, 190},
 		{0xa4fe, 0xa4ff, 1},
 		{0xa60d, 0xa60f, 1},
@@ -2346,17 +2580,29 @@ var _Po = &RangeTable{
 		{0x10100, 0x10100, 1},
 		{0x10101, 0x10102, 1},
 		{0x1039f, 0x103d0, 49},
-		{0x10857, 0x1091f, 200},
-		{0x1093f, 0x10a50, 273},
-		{0x10a51, 0x10a58, 1},
-		{0x10a7f, 0x10b39, 186},
-		{0x10b3a, 0x10b3f, 1},
+		{0x1056f, 0x10857, 744},
+		{0x1091f, 0x1093f, 32},
+		{0x10a50, 0x10a58, 1},
+		{0x10a7f, 0x10af0, 113},
+		{0x10af1, 0x10af6, 1},
+		{0x10b39, 0x10b3f, 1},
+		{0x10b99, 0x10b9c, 1},
 		{0x11047, 0x1104d, 1},
 		{0x110bb, 0x110bc, 1},
 		{0x110be, 0x110c1, 1},
 		{0x11140, 0x11143, 1},
+		{0x11174, 0x11175, 1},
 		{0x111c5, 0x111c8, 1},
-		{0x12470, 0x12473, 1},
+		{0x111cd, 0x11238, 107},
+		{0x11239, 0x1123d, 1},
+		{0x114c6, 0x115c1, 251},
+		{0x115c2, 0x115c9, 1},
+		{0x11641, 0x11643, 1},
+		{0x12470, 0x12474, 1},
+		{0x16a6e, 0x16a6f, 1},
+		{0x16af5, 0x16b37, 66},
+		{0x16b38, 0x16b3b, 1},
+		{0x16b44, 0x1bc9f, 20827},
 	},
 	LatinOffset: 8,
 }
@@ -2377,9 +2623,10 @@ var _Ps = &RangeTable{
 		{0x29d8, 0x29da, 2},
 		{0x29fc, 0x2e22, 1062},
 		{0x2e24, 0x2e28, 2},
-		{0x3008, 0x3010, 2},
+		{0x2e42, 0x3008, 454},
+		{0x300a, 0x3010, 2},
 		{0x3014, 0x301a, 2},
-		{0x301d, 0xfd3e, 52513},
+		{0x301d, 0xfd3f, 52514},
 		{0xfe17, 0xfe35, 30},
 		{0xfe37, 0xfe43, 2},
 		{0xfe47, 0xfe59, 18},
@@ -2410,7 +2657,8 @@ var _S = &RangeTable{
 		{0x02f0, 0x02ff, 1},
 		{0x0375, 0x0384, 15},
 		{0x0385, 0x03f6, 113},
-		{0x0482, 0x058f, 269},
+		{0x0482, 0x058d, 267},
+		{0x058e, 0x058f, 1},
 		{0x0606, 0x0608, 1},
 		{0x060b, 0x060e, 3},
 		{0x060f, 0x06de, 207},
@@ -2446,7 +2694,7 @@ var _S = &RangeTable{
 		{0x2044, 0x2052, 14},
 		{0x207a, 0x207c, 1},
 		{0x208a, 0x208c, 1},
-		{0x20a0, 0x20ba, 1},
+		{0x20a0, 0x20bd, 1},
 		{0x2100, 0x2101, 1},
 		{0x2103, 0x2106, 1},
 		{0x2108, 0x2109, 1},
@@ -2461,19 +2709,21 @@ var _S = &RangeTable{
 		{0x214f, 0x2190, 65},
 		{0x2191, 0x2307, 1},
 		{0x230c, 0x2328, 1},
-		{0x232b, 0x23f3, 1},
+		{0x232b, 0x23fa, 1},
 		{0x2400, 0x2426, 1},
 		{0x2440, 0x244a, 1},
 		{0x249c, 0x24e9, 1},
-		{0x2500, 0x26ff, 1},
-		{0x2701, 0x2767, 1},
+		{0x2500, 0x2767, 1},
 		{0x2794, 0x27c4, 1},
 		{0x27c7, 0x27e5, 1},
 		{0x27f0, 0x2982, 1},
 		{0x2999, 0x29d7, 1},
 		{0x29dc, 0x29fb, 1},
-		{0x29fe, 0x2b4c, 1},
-		{0x2b50, 0x2b59, 1},
+		{0x29fe, 0x2b73, 1},
+		{0x2b76, 0x2b95, 1},
+		{0x2b98, 0x2bb9, 1},
+		{0x2bbd, 0x2bc8, 1},
+		{0x2bca, 0x2bd1, 1},
 		{0x2ce5, 0x2cea, 1},
 		{0x2e80, 0x2e99, 1},
 		{0x2e9b, 0x2ef3, 1},
@@ -2502,8 +2752,8 @@ var _S = &RangeTable{
 		{0xa828, 0xa82b, 1},
 		{0xa836, 0xa839, 1},
 		{0xaa77, 0xaa79, 1},
-		{0xfb29, 0xfbb2, 137},
-		{0xfbb3, 0xfbc1, 1},
+		{0xab5b, 0xfb29, 20430},
+		{0xfbb2, 0xfbc1, 1},
 		{0xfdfc, 0xfdfd, 1},
 		{0xfe62, 0xfe64, 2},
 		{0xfe65, 0xfe66, 1},
@@ -2519,8 +2769,14 @@ var _S = &RangeTable{
 	R32: []Range32{
 		{0x10137, 0x1013f, 1},
 		{0x10179, 0x10189, 1},
-		{0x10190, 0x1019b, 1},
-		{0x101d0, 0x101fc, 1},
+		{0x1018c, 0x10190, 4},
+		{0x10191, 0x1019b, 1},
+		{0x101a0, 0x101d0, 48},
+		{0x101d1, 0x101fc, 1},
+		{0x10877, 0x10878, 1},
+		{0x10ac8, 0x16b3c, 24692},
+		{0x16b3d, 0x16b3f, 1},
+		{0x16b45, 0x1bc9c, 20823},
 		{0x1d000, 0x1d0f5, 1},
 		{0x1d100, 0x1d126, 1},
 		{0x1d129, 0x1d164, 1},
@@ -2540,9 +2796,9 @@ var _S = &RangeTable{
 		{0x1f000, 0x1f02b, 1},
 		{0x1f030, 0x1f093, 1},
 		{0x1f0a0, 0x1f0ae, 1},
-		{0x1f0b1, 0x1f0be, 1},
+		{0x1f0b1, 0x1f0bf, 1},
 		{0x1f0c1, 0x1f0cf, 1},
-		{0x1f0d1, 0x1f0df, 1},
+		{0x1f0d1, 0x1f0f5, 1},
 		{0x1f110, 0x1f12e, 1},
 		{0x1f130, 0x1f16b, 1},
 		{0x1f170, 0x1f19a, 1},
@@ -2550,24 +2806,25 @@ var _S = &RangeTable{
 		{0x1f210, 0x1f23a, 1},
 		{0x1f240, 0x1f248, 1},
 		{0x1f250, 0x1f251, 1},
-		{0x1f300, 0x1f320, 1},
-		{0x1f330, 0x1f335, 1},
-		{0x1f337, 0x1f37c, 1},
-		{0x1f380, 0x1f393, 1},
-		{0x1f3a0, 0x1f3c4, 1},
-		{0x1f3c6, 0x1f3ca, 1},
-		{0x1f3e0, 0x1f3f0, 1},
-		{0x1f400, 0x1f43e, 1},
-		{0x1f440, 0x1f442, 2},
-		{0x1f443, 0x1f4f7, 1},
-		{0x1f4f9, 0x1f4fc, 1},
-		{0x1f500, 0x1f53d, 1},
-		{0x1f540, 0x1f543, 1},
-		{0x1f550, 0x1f567, 1},
-		{0x1f5fb, 0x1f640, 1},
-		{0x1f645, 0x1f64f, 1},
-		{0x1f680, 0x1f6c5, 1},
+		{0x1f300, 0x1f32c, 1},
+		{0x1f330, 0x1f37d, 1},
+		{0x1f380, 0x1f3ce, 1},
+		{0x1f3d4, 0x1f3f7, 1},
+		{0x1f400, 0x1f4fe, 1},
+		{0x1f500, 0x1f54a, 1},
+		{0x1f550, 0x1f579, 1},
+		{0x1f57b, 0x1f5a3, 1},
+		{0x1f5a5, 0x1f642, 1},
+		{0x1f645, 0x1f6cf, 1},
+		{0x1f6e0, 0x1f6ec, 1},
+		{0x1f6f0, 0x1f6f3, 1},
 		{0x1f700, 0x1f773, 1},
+		{0x1f780, 0x1f7d4, 1},
+		{0x1f800, 0x1f80b, 1},
+		{0x1f810, 0x1f847, 1},
+		{0x1f850, 0x1f859, 1},
+		{0x1f860, 0x1f887, 1},
+		{0x1f890, 0x1f8ad, 1},
 	},
 	LatinOffset: 10,
 }
@@ -2581,7 +2838,7 @@ var _Sc = &RangeTable{
 		{0x09fb, 0x0af1, 246},
 		{0x0bf9, 0x0e3f, 582},
 		{0x17db, 0x20a0, 2245},
-		{0x20a1, 0x20ba, 1},
+		{0x20a1, 0x20bd, 1},
 		{0xa838, 0xfdfc, 21956},
 		{0xfe69, 0xff04, 155},
 		{0xffe0, 0xffe1, 1},
@@ -2611,7 +2868,8 @@ var _Sk = &RangeTable{
 		{0xa700, 0xa716, 1},
 		{0xa720, 0xa721, 1},
 		{0xa789, 0xa78a, 1},
-		{0xfbb2, 0xfbc1, 1},
+		{0xab5b, 0xfbb2, 20567},
+		{0xfbb3, 0xfbc1, 1},
 		{0xff3e, 0xff40, 2},
 		{0xffe3, 0xffe3, 1},
 	},
@@ -2679,7 +2937,8 @@ var _So = &RangeTable{
 	R16: []Range16{
 		{0x00a6, 0x00a9, 3},
 		{0x00ae, 0x00b0, 2},
-		{0x0482, 0x060e, 396},
+		{0x0482, 0x058d, 267},
+		{0x058e, 0x060e, 128},
 		{0x060f, 0x06de, 207},
 		{0x06e9, 0x06fd, 20},
 		{0x06fe, 0x07f6, 248},
@@ -2728,7 +2987,7 @@ var _So = &RangeTable{
 		{0x232b, 0x237b, 1},
 		{0x237d, 0x239a, 1},
 		{0x23b4, 0x23db, 1},
-		{0x23e2, 0x23f3, 1},
+		{0x23e2, 0x23fa, 1},
 		{0x2400, 0x2426, 1},
 		{0x2440, 0x244a, 1},
 		{0x249c, 0x24e9, 1},
@@ -2736,13 +2995,16 @@ var _So = &RangeTable{
 		{0x25b8, 0x25c0, 1},
 		{0x25c2, 0x25f7, 1},
 		{0x2600, 0x266e, 1},
-		{0x2670, 0x26ff, 1},
-		{0x2701, 0x2767, 1},
+		{0x2670, 0x2767, 1},
 		{0x2794, 0x27bf, 1},
 		{0x2800, 0x28ff, 1},
 		{0x2b00, 0x2b2f, 1},
 		{0x2b45, 0x2b46, 1},
-		{0x2b50, 0x2b59, 1},
+		{0x2b4d, 0x2b73, 1},
+		{0x2b76, 0x2b95, 1},
+		{0x2b98, 0x2bb9, 1},
+		{0x2bbd, 0x2bc8, 1},
+		{0x2bca, 0x2bd1, 1},
 		{0x2ce5, 0x2cea, 1},
 		{0x2e80, 0x2e99, 1},
 		{0x2e9b, 0x2ef3, 1},
@@ -2777,8 +3039,14 @@ var _So = &RangeTable{
 		{0x10137, 0x10137, 1},
 		{0x10138, 0x1013f, 1},
 		{0x10179, 0x10189, 1},
-		{0x10190, 0x1019b, 1},
-		{0x101d0, 0x101fc, 1},
+		{0x1018c, 0x10190, 4},
+		{0x10191, 0x1019b, 1},
+		{0x101a0, 0x101d0, 48},
+		{0x101d1, 0x101fc, 1},
+		{0x10877, 0x10878, 1},
+		{0x10ac8, 0x16b3c, 24692},
+		{0x16b3d, 0x16b3f, 1},
+		{0x16b45, 0x1bc9c, 20823},
 		{0x1d000, 0x1d0f5, 1},
 		{0x1d100, 0x1d126, 1},
 		{0x1d129, 0x1d164, 1},
@@ -2792,9 +3060,9 @@ var _So = &RangeTable{
 		{0x1f000, 0x1f02b, 1},
 		{0x1f030, 0x1f093, 1},
 		{0x1f0a0, 0x1f0ae, 1},
-		{0x1f0b1, 0x1f0be, 1},
+		{0x1f0b1, 0x1f0bf, 1},
 		{0x1f0c1, 0x1f0cf, 1},
-		{0x1f0d1, 0x1f0df, 1},
+		{0x1f0d1, 0x1f0f5, 1},
 		{0x1f110, 0x1f12e, 1},
 		{0x1f130, 0x1f16b, 1},
 		{0x1f170, 0x1f19a, 1},
@@ -2802,24 +3070,25 @@ var _So = &RangeTable{
 		{0x1f210, 0x1f23a, 1},
 		{0x1f240, 0x1f248, 1},
 		{0x1f250, 0x1f251, 1},
-		{0x1f300, 0x1f320, 1},
-		{0x1f330, 0x1f335, 1},
-		{0x1f337, 0x1f37c, 1},
-		{0x1f380, 0x1f393, 1},
-		{0x1f3a0, 0x1f3c4, 1},
-		{0x1f3c6, 0x1f3ca, 1},
-		{0x1f3e0, 0x1f3f0, 1},
-		{0x1f400, 0x1f43e, 1},
-		{0x1f440, 0x1f442, 2},
-		{0x1f443, 0x1f4f7, 1},
-		{0x1f4f9, 0x1f4fc, 1},
-		{0x1f500, 0x1f53d, 1},
-		{0x1f540, 0x1f543, 1},
-		{0x1f550, 0x1f567, 1},
-		{0x1f5fb, 0x1f640, 1},
-		{0x1f645, 0x1f64f, 1},
-		{0x1f680, 0x1f6c5, 1},
+		{0x1f300, 0x1f32c, 1},
+		{0x1f330, 0x1f37d, 1},
+		{0x1f380, 0x1f3ce, 1},
+		{0x1f3d4, 0x1f3f7, 1},
+		{0x1f400, 0x1f4fe, 1},
+		{0x1f500, 0x1f54a, 1},
+		{0x1f550, 0x1f579, 1},
+		{0x1f57b, 0x1f5a3, 1},
+		{0x1f5a5, 0x1f642, 1},
+		{0x1f645, 0x1f6cf, 1},
+		{0x1f6e0, 0x1f6ec, 1},
+		{0x1f6f0, 0x1f6f3, 1},
 		{0x1f700, 0x1f773, 1},
+		{0x1f780, 0x1f7d4, 1},
+		{0x1f800, 0x1f80b, 1},
+		{0x1f810, 0x1f847, 1},
+		{0x1f850, 0x1f859, 1},
+		{0x1f860, 0x1f887, 1},
+		{0x1f890, 0x1f8ad, 1},
 	},
 	LatinOffset: 2,
 }
@@ -2911,7 +3180,7 @@ var (
 )
 
 // Generated by running
-//	maketables --scripts=all --url=http://www.unicode.org/Public/6.3.0/ucd/
+//	maketables --scripts=all --url=http://www.unicode.org/Public/7.0.0/ucd/
 // DO NOT EDIT
 
 // Scripts is the set of Unicode script tables.
@@ -2921,6 +3190,7 @@ var Scripts = map[string]*RangeTable{
 	"Avestan":                Avestan,
 	"Balinese":               Balinese,
 	"Bamum":                  Bamum,
+	"Bassa_Vah":              Bassa_Vah,
 	"Batak":                  Batak,
 	"Bengali":                Bengali,
 	"Bopomofo":               Bopomofo,
@@ -2930,6 +3200,7 @@ var Scripts = map[string]*RangeTable{
 	"Buhid":                  Buhid,
 	"Canadian_Aboriginal":    Canadian_Aboriginal,
 	"Carian":                 Carian,
+	"Caucasian_Albanian":     Caucasian_Albanian,
 	"Chakma":                 Chakma,
 	"Cham":                   Cham,
 	"Cherokee":               Cherokee,
@@ -2940,11 +3211,14 @@ var Scripts = map[string]*RangeTable{
 	"Cyrillic":               Cyrillic,
 	"Deseret":                Deseret,
 	"Devanagari":             Devanagari,
+	"Duployan":               Duployan,
 	"Egyptian_Hieroglyphs":   Egyptian_Hieroglyphs,
+	"Elbasan":                Elbasan,
 	"Ethiopic":               Ethiopic,
 	"Georgian":               Georgian,
 	"Glagolitic":             Glagolitic,
 	"Gothic":                 Gothic,
+	"Grantha":                Grantha,
 	"Greek":                  Greek,
 	"Gujarati":               Gujarati,
 	"Gurmukhi":               Gurmukhi,
@@ -2964,40 +3238,56 @@ var Scripts = map[string]*RangeTable{
 	"Kayah_Li":               Kayah_Li,
 	"Kharoshthi":             Kharoshthi,
 	"Khmer":                  Khmer,
+	"Khojki":                 Khojki,
+	"Khudawadi":              Khudawadi,
 	"Lao":                    Lao,
 	"Latin":                  Latin,
 	"Lepcha":                 Lepcha,
 	"Limbu":                  Limbu,
+	"Linear_A":               Linear_A,
 	"Linear_B":               Linear_B,
 	"Lisu":                   Lisu,
 	"Lycian":                 Lycian,
 	"Lydian":                 Lydian,
+	"Mahajani":               Mahajani,
 	"Malayalam":              Malayalam,
 	"Mandaic":                Mandaic,
+	"Manichaean":             Manichaean,
 	"Meetei_Mayek":           Meetei_Mayek,
+	"Mende_Kikakui":          Mende_Kikakui,
 	"Meroitic_Cursive":       Meroitic_Cursive,
 	"Meroitic_Hieroglyphs":   Meroitic_Hieroglyphs,
 	"Miao":                   Miao,
+	"Modi":                   Modi,
 	"Mongolian":              Mongolian,
+	"Mro":                    Mro,
 	"Myanmar":                Myanmar,
+	"Nabataean":              Nabataean,
 	"New_Tai_Lue":            New_Tai_Lue,
 	"Nko":                    Nko,
 	"Ogham":                  Ogham,
 	"Ol_Chiki":               Ol_Chiki,
 	"Old_Italic":             Old_Italic,
+	"Old_North_Arabian":      Old_North_Arabian,
+	"Old_Permic":             Old_Permic,
 	"Old_Persian":            Old_Persian,
 	"Old_South_Arabian":      Old_South_Arabian,
 	"Old_Turkic":             Old_Turkic,
 	"Oriya":                  Oriya,
 	"Osmanya":                Osmanya,
+	"Pahawh_Hmong":           Pahawh_Hmong,
+	"Palmyrene":              Palmyrene,
+	"Pau_Cin_Hau":            Pau_Cin_Hau,
 	"Phags_Pa":               Phags_Pa,
 	"Phoenician":             Phoenician,
+	"Psalter_Pahlavi":        Psalter_Pahlavi,
 	"Rejang":                 Rejang,
 	"Runic":                  Runic,
 	"Samaritan":              Samaritan,
 	"Saurashtra":             Saurashtra,
 	"Sharada":                Sharada,
 	"Shavian":                Shavian,
+	"Siddham":                Siddham,
 	"Sinhala":                Sinhala,
 	"Sora_Sompeng":           Sora_Sompeng,
 	"Sundanese":              Sundanese,
@@ -3015,8 +3305,10 @@ var Scripts = map[string]*RangeTable{
 	"Thai":                   Thai,
 	"Tibetan":                Tibetan,
 	"Tifinagh":               Tifinagh,
+	"Tirhuta":                Tirhuta,
 	"Ugaritic":               Ugaritic,
 	"Vai":                    Vai,
+	"Warang_Citi":            Warang_Citi,
 	"Yi":                     Yi,
 }
 
@@ -3025,7 +3317,6 @@ var _Arabic = &RangeTable{
 		{0x0600, 0x0604, 1},
 		{0x0606, 0x060b, 1},
 		{0x060d, 0x061a, 1},
-		{0x061c, 0x061c, 1},
 		{0x061e, 0x061e, 1},
 		{0x0620, 0x063f, 1},
 		{0x0641, 0x064a, 1},
@@ -3034,14 +3325,13 @@ var _Arabic = &RangeTable{
 		{0x0671, 0x06dc, 1},
 		{0x06de, 0x06ff, 1},
 		{0x0750, 0x077f, 1},
-		{0x08a0, 0x08a0, 1},
-		{0x08a2, 0x08ac, 1},
-		{0x08e4, 0x08fe, 1},
+		{0x08a0, 0x08b2, 1},
+		{0x08e4, 0x08ff, 1},
 		{0xfb50, 0xfbc1, 1},
 		{0xfbd3, 0xfd3d, 1},
 		{0xfd50, 0xfd8f, 1},
 		{0xfd92, 0xfdc7, 1},
-		{0xfdf0, 0xfdfc, 1},
+		{0xfdf0, 0xfdfd, 1},
 		{0xfe70, 0xfe74, 1},
 		{0xfe76, 0xfefc, 1},
 	},
@@ -3090,7 +3380,7 @@ var _Armenian = &RangeTable{
 		{0x0559, 0x055f, 1},
 		{0x0561, 0x0587, 1},
 		{0x058a, 0x058a, 1},
-		{0x058f, 0x058f, 1},
+		{0x058d, 0x058f, 1},
 		{0xfb13, 0xfb17, 1},
 	},
 }
@@ -3119,6 +3409,14 @@ var _Bamum = &RangeTable{
 	},
 }
 
+var _Bassa_Vah = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x16ad0, 0x16aed, 1},
+		{0x16af0, 0x16af5, 1},
+	},
+}
+
 var _Batak = &RangeTable{
 	R16: []Range16{
 		{0x1bc0, 0x1bf3, 1},
@@ -3128,7 +3426,7 @@ var _Batak = &RangeTable{
 
 var _Bengali = &RangeTable{
 	R16: []Range16{
-		{0x0981, 0x0983, 1},
+		{0x0980, 0x0983, 1},
 		{0x0985, 0x098c, 1},
 		{0x098f, 0x0990, 1},
 		{0x0993, 0x09a8, 1},
@@ -3158,6 +3456,7 @@ var _Brahmi = &RangeTable{
 	R32: []Range32{
 		{0x11000, 0x1104d, 1},
 		{0x11052, 0x1106f, 1},
+		{0x1107f, 0x1107f, 1},
 	},
 }
 
@@ -3194,6 +3493,14 @@ var _Carian = &RangeTable{
 	},
 }
 
+var _Caucasian_Albanian = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10530, 0x10563, 1},
+		{0x1056f, 0x1056f, 1},
+	},
+}
+
 var _Chakma = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
@@ -3234,8 +3541,9 @@ var _Common = &RangeTable{
 		{0x0385, 0x0385, 1},
 		{0x0387, 0x0387, 1},
 		{0x0589, 0x0589, 1},
+		{0x0605, 0x0605, 1},
 		{0x060c, 0x060c, 1},
-		{0x061b, 0x061b, 1},
+		{0x061b, 0x061c, 1},
 		{0x061f, 0x061f, 1},
 		{0x0640, 0x0640, 1},
 		{0x0660, 0x0669, 1},
@@ -3258,21 +3566,23 @@ var _Common = &RangeTable{
 		{0x2066, 0x2070, 1},
 		{0x2074, 0x207e, 1},
 		{0x2080, 0x208e, 1},
-		{0x20a0, 0x20ba, 1},
+		{0x20a0, 0x20bd, 1},
 		{0x2100, 0x2125, 1},
 		{0x2127, 0x2129, 1},
 		{0x212c, 0x2131, 1},
 		{0x2133, 0x214d, 1},
 		{0x214f, 0x215f, 1},
 		{0x2189, 0x2189, 1},
-		{0x2190, 0x23f3, 1},
+		{0x2190, 0x23fa, 1},
 		{0x2400, 0x2426, 1},
 		{0x2440, 0x244a, 1},
-		{0x2460, 0x26ff, 1},
-		{0x2701, 0x27ff, 1},
-		{0x2900, 0x2b4c, 1},
-		{0x2b50, 0x2b59, 1},
-		{0x2e00, 0x2e3b, 1},
+		{0x2460, 0x27ff, 1},
+		{0x2900, 0x2b73, 1},
+		{0x2b76, 0x2b95, 1},
+		{0x2b98, 0x2bb9, 1},
+		{0x2bbd, 0x2bc8, 1},
+		{0x2bca, 0x2bd1, 1},
+		{0x2e00, 0x2e42, 1},
 		{0x2ff0, 0x2ffb, 1},
 		{0x3000, 0x3004, 1},
 		{0x3006, 0x3006, 1},
@@ -3291,9 +3601,10 @@ var _Common = &RangeTable{
 		{0xa700, 0xa721, 1},
 		{0xa788, 0xa78a, 1},
 		{0xa830, 0xa839, 1},
+		{0xa92e, 0xa92e, 1},
 		{0xa9cf, 0xa9cf, 1},
+		{0xab5b, 0xab5b, 1},
 		{0xfd3e, 0xfd3f, 1},
-		{0xfdfd, 0xfdfd, 1},
 		{0xfe10, 0xfe19, 1},
 		{0xfe30, 0xfe52, 1},
 		{0xfe54, 0xfe66, 1},
@@ -3314,6 +3625,8 @@ var _Common = &RangeTable{
 		{0x10137, 0x1013f, 1},
 		{0x10190, 0x1019b, 1},
 		{0x101d0, 0x101fc, 1},
+		{0x102e1, 0x102fb, 1},
+		{0x1bca0, 0x1bca3, 1},
 		{0x1d000, 0x1d0f5, 1},
 		{0x1d100, 0x1d126, 1},
 		{0x1d129, 0x1d166, 1},
@@ -3347,10 +3660,10 @@ var _Common = &RangeTable{
 		{0x1f000, 0x1f02b, 1},
 		{0x1f030, 0x1f093, 1},
 		{0x1f0a0, 0x1f0ae, 1},
-		{0x1f0b1, 0x1f0be, 1},
+		{0x1f0b1, 0x1f0bf, 1},
 		{0x1f0c1, 0x1f0cf, 1},
-		{0x1f0d1, 0x1f0df, 1},
-		{0x1f100, 0x1f10a, 1},
+		{0x1f0d1, 0x1f0f5, 1},
+		{0x1f100, 0x1f10c, 1},
 		{0x1f110, 0x1f12e, 1},
 		{0x1f130, 0x1f16b, 1},
 		{0x1f170, 0x1f19a, 1},
@@ -3359,24 +3672,25 @@ var _Common = &RangeTable{
 		{0x1f210, 0x1f23a, 1},
 		{0x1f240, 0x1f248, 1},
 		{0x1f250, 0x1f251, 1},
-		{0x1f300, 0x1f320, 1},
-		{0x1f330, 0x1f335, 1},
-		{0x1f337, 0x1f37c, 1},
-		{0x1f380, 0x1f393, 1},
-		{0x1f3a0, 0x1f3c4, 1},
-		{0x1f3c6, 0x1f3ca, 1},
-		{0x1f3e0, 0x1f3f0, 1},
-		{0x1f400, 0x1f43e, 1},
-		{0x1f440, 0x1f440, 1},
-		{0x1f442, 0x1f4f7, 1},
-		{0x1f4f9, 0x1f4fc, 1},
-		{0x1f500, 0x1f53d, 1},
-		{0x1f540, 0x1f543, 1},
-		{0x1f550, 0x1f567, 1},
-		{0x1f5fb, 0x1f640, 1},
-		{0x1f645, 0x1f64f, 1},
-		{0x1f680, 0x1f6c5, 1},
+		{0x1f300, 0x1f32c, 1},
+		{0x1f330, 0x1f37d, 1},
+		{0x1f380, 0x1f3ce, 1},
+		{0x1f3d4, 0x1f3f7, 1},
+		{0x1f400, 0x1f4fe, 1},
+		{0x1f500, 0x1f54a, 1},
+		{0x1f550, 0x1f579, 1},
+		{0x1f57b, 0x1f5a3, 1},
+		{0x1f5a5, 0x1f642, 1},
+		{0x1f645, 0x1f6cf, 1},
+		{0x1f6e0, 0x1f6ec, 1},
+		{0x1f6f0, 0x1f6f3, 1},
 		{0x1f700, 0x1f773, 1},
+		{0x1f780, 0x1f7d4, 1},
+		{0x1f800, 0x1f80b, 1},
+		{0x1f810, 0x1f847, 1},
+		{0x1f850, 0x1f859, 1},
+		{0x1f860, 0x1f887, 1},
+		{0x1f890, 0x1f8ad, 1},
 		{0xe0001, 0xe0001, 1},
 		{0xe0020, 0xe007f, 1},
 	},
@@ -3394,9 +3708,9 @@ var _Coptic = &RangeTable{
 var _Cuneiform = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
-		{0x12000, 0x1236e, 1},
-		{0x12400, 0x12462, 1},
-		{0x12470, 0x12473, 1},
+		{0x12000, 0x12398, 1},
+		{0x12400, 0x1246e, 1},
+		{0x12470, 0x12474, 1},
 	},
 }
 
@@ -3415,11 +3729,11 @@ var _Cypriot = &RangeTable{
 var _Cyrillic = &RangeTable{
 	R16: []Range16{
 		{0x0400, 0x0484, 1},
-		{0x0487, 0x0527, 1},
+		{0x0487, 0x052f, 1},
 		{0x1d2b, 0x1d2b, 1},
 		{0x1d78, 0x1d78, 1},
 		{0x2de0, 0x2dff, 1},
-		{0xa640, 0xa697, 1},
+		{0xa640, 0xa69d, 1},
 		{0xa69f, 0xa69f, 1},
 	},
 }
@@ -3435,12 +3749,22 @@ var _Devanagari = &RangeTable{
 	R16: []Range16{
 		{0x0900, 0x0950, 1},
 		{0x0953, 0x0963, 1},
-		{0x0966, 0x0977, 1},
-		{0x0979, 0x097f, 1},
+		{0x0966, 0x097f, 1},
 		{0xa8e0, 0xa8fb, 1},
 	},
 }
 
+var _Duployan = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x1bc00, 0x1bc6a, 1},
+		{0x1bc70, 0x1bc7c, 1},
+		{0x1bc80, 0x1bc88, 1},
+		{0x1bc90, 0x1bc99, 1},
+		{0x1bc9c, 0x1bc9f, 1},
+	},
+}
+
 var _Egyptian_Hieroglyphs = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
@@ -3448,6 +3772,13 @@ var _Egyptian_Hieroglyphs = &RangeTable{
 	},
 }
 
+var _Elbasan = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10500, 0x10527, 1},
+	},
+}
+
 var _Ethiopic = &RangeTable{
 	R16: []Range16{
 		{0x1200, 0x1248, 1},
@@ -3512,11 +3843,32 @@ var _Gothic = &RangeTable{
 	},
 }
 
+var _Grantha = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11301, 0x11303, 1},
+		{0x11305, 0x1130c, 1},
+		{0x1130f, 0x11310, 1},
+		{0x11313, 0x11328, 1},
+		{0x1132a, 0x11330, 1},
+		{0x11332, 0x11333, 1},
+		{0x11335, 0x11339, 1},
+		{0x1133c, 0x11344, 1},
+		{0x11347, 0x11348, 1},
+		{0x1134b, 0x1134d, 1},
+		{0x11357, 0x11357, 1},
+		{0x1135d, 0x11363, 1},
+		{0x11366, 0x1136c, 1},
+		{0x11370, 0x11374, 1},
+	},
+}
+
 var _Greek = &RangeTable{
 	R16: []Range16{
 		{0x0370, 0x0373, 1},
 		{0x0375, 0x0377, 1},
 		{0x037a, 0x037d, 1},
+		{0x037f, 0x037f, 1},
 		{0x0384, 0x0384, 1},
 		{0x0386, 0x0386, 1},
 		{0x0388, 0x038a, 1},
@@ -3545,9 +3897,11 @@ var _Greek = &RangeTable{
 		{0x1ff2, 0x1ff4, 1},
 		{0x1ff6, 0x1ffe, 1},
 		{0x2126, 0x2126, 1},
+		{0xab65, 0xab65, 1},
 	},
 	R32: []Range32{
-		{0x10140, 0x1018a, 1},
+		{0x10140, 0x1018c, 1},
+		{0x101a0, 0x101a0, 1},
 		{0x1d200, 0x1d245, 1},
 	},
 }
@@ -3678,22 +4032,25 @@ var _Inherited = &RangeTable{
 		{0x064b, 0x0655, 1},
 		{0x0670, 0x0670, 1},
 		{0x0951, 0x0952, 1},
+		{0x1ab0, 0x1abe, 1},
 		{0x1cd0, 0x1cd2, 1},
 		{0x1cd4, 0x1ce0, 1},
 		{0x1ce2, 0x1ce8, 1},
 		{0x1ced, 0x1ced, 1},
 		{0x1cf4, 0x1cf4, 1},
-		{0x1dc0, 0x1de6, 1},
+		{0x1cf8, 0x1cf9, 1},
+		{0x1dc0, 0x1df5, 1},
 		{0x1dfc, 0x1dff, 1},
 		{0x200c, 0x200d, 1},
 		{0x20d0, 0x20f0, 1},
 		{0x302a, 0x302d, 1},
 		{0x3099, 0x309a, 1},
 		{0xfe00, 0xfe0f, 1},
-		{0xfe20, 0xfe26, 1},
+		{0xfe20, 0xfe2d, 1},
 	},
 	R32: []Range32{
 		{0x101fd, 0x101fd, 1},
+		{0x102e0, 0x102e0, 1},
 		{0x1d167, 0x1d169, 1},
 		{0x1d17b, 0x1d182, 1},
 		{0x1d185, 0x1d18b, 1},
@@ -3735,7 +4092,7 @@ var _Kaithi = &RangeTable{
 
 var _Kannada = &RangeTable{
 	R16: []Range16{
-		{0x0c82, 0x0c83, 1},
+		{0x0c81, 0x0c83, 1},
 		{0x0c85, 0x0c8c, 1},
 		{0x0c8e, 0x0c90, 1},
 		{0x0c92, 0x0ca8, 1},
@@ -3769,7 +4126,8 @@ var _Katakana = &RangeTable{
 
 var _Kayah_Li = &RangeTable{
 	R16: []Range16{
-		{0xa900, 0xa92f, 1},
+		{0xa900, 0xa92d, 1},
+		{0xa92f, 0xa92f, 1},
 	},
 }
 
@@ -3796,6 +4154,22 @@ var _Khmer = &RangeTable{
 	},
 }
 
+var _Khojki = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11200, 0x11211, 1},
+		{0x11213, 0x1123d, 1},
+	},
+}
+
+var _Khudawadi = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x112b0, 0x112ea, 1},
+		{0x112f0, 0x112f9, 1},
+	},
+}
+
 var _Lao = &RangeTable{
 	R16: []Range16{
 		{0x0e81, 0x0e82, 1},
@@ -3845,9 +4219,12 @@ var _Latin = &RangeTable{
 		{0x2c60, 0x2c7f, 1},
 		{0xa722, 0xa787, 1},
 		{0xa78b, 0xa78e, 1},
-		{0xa790, 0xa793, 1},
-		{0xa7a0, 0xa7aa, 1},
-		{0xa7f8, 0xa7ff, 1},
+		{0xa790, 0xa7ad, 1},
+		{0xa7b0, 0xa7b1, 1},
+		{0xa7f7, 0xa7ff, 1},
+		{0xab30, 0xab5a, 1},
+		{0xab5c, 0xab5f, 1},
+		{0xab64, 0xab64, 1},
 		{0xfb00, 0xfb06, 1},
 		{0xff21, 0xff3a, 1},
 		{0xff41, 0xff5a, 1},
@@ -3865,7 +4242,7 @@ var _Lepcha = &RangeTable{
 
 var _Limbu = &RangeTable{
 	R16: []Range16{
-		{0x1900, 0x191c, 1},
+		{0x1900, 0x191e, 1},
 		{0x1920, 0x192b, 1},
 		{0x1930, 0x193b, 1},
 		{0x1940, 0x1940, 1},
@@ -3873,6 +4250,15 @@ var _Limbu = &RangeTable{
 	},
 }
 
+var _Linear_A = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10600, 0x10736, 1},
+		{0x10740, 0x10755, 1},
+		{0x10760, 0x10767, 1},
+	},
+}
+
 var _Linear_B = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
@@ -3907,9 +4293,16 @@ var _Lydian = &RangeTable{
 	},
 }
 
+var _Mahajani = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11150, 0x11176, 1},
+	},
+}
+
 var _Malayalam = &RangeTable{
 	R16: []Range16{
-		{0x0d02, 0x0d03, 1},
+		{0x0d01, 0x0d03, 1},
 		{0x0d05, 0x0d0c, 1},
 		{0x0d0e, 0x0d10, 1},
 		{0x0d12, 0x0d3a, 1},
@@ -3930,6 +4323,14 @@ var _Mandaic = &RangeTable{
 	},
 }
 
+var _Manichaean = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10ac0, 0x10ae6, 1},
+		{0x10aeb, 0x10af6, 1},
+	},
+}
+
 var _Meetei_Mayek = &RangeTable{
 	R16: []Range16{
 		{0xaae0, 0xaaf6, 1},
@@ -3938,6 +4339,14 @@ var _Meetei_Mayek = &RangeTable{
 	},
 }
 
+var _Mende_Kikakui = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x1e800, 0x1e8c4, 1},
+		{0x1e8c7, 0x1e8d6, 1},
+	},
+}
+
 var _Meroitic_Cursive = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
@@ -3962,6 +4371,14 @@ var _Miao = &RangeTable{
 	},
 }
 
+var _Modi = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11600, 0x11644, 1},
+		{0x11650, 0x11659, 1},
+	},
+}
+
 var _Mongolian = &RangeTable{
 	R16: []Range16{
 		{0x1800, 0x1801, 1},
@@ -3973,10 +4390,28 @@ var _Mongolian = &RangeTable{
 	},
 }
 
+var _Mro = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x16a40, 0x16a5e, 1},
+		{0x16a60, 0x16a69, 1},
+		{0x16a6e, 0x16a6f, 1},
+	},
+}
+
 var _Myanmar = &RangeTable{
 	R16: []Range16{
 		{0x1000, 0x109f, 1},
-		{0xaa60, 0xaa7b, 1},
+		{0xa9e0, 0xa9fe, 1},
+		{0xaa60, 0xaa7f, 1},
+	},
+}
+
+var _Nabataean = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10880, 0x1089e, 1},
+		{0x108a7, 0x108af, 1},
 	},
 }
 
@@ -4010,8 +4445,21 @@ var _Ol_Chiki = &RangeTable{
 var _Old_Italic = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
-		{0x10300, 0x1031e, 1},
-		{0x10320, 0x10323, 1},
+		{0x10300, 0x10323, 1},
+	},
+}
+
+var _Old_North_Arabian = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10a80, 0x10a9f, 1},
+	},
+}
+
+var _Old_Permic = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10350, 0x1037a, 1},
 	},
 }
 
@@ -4064,6 +4512,31 @@ var _Osmanya = &RangeTable{
 	},
 }
 
+var _Pahawh_Hmong = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x16b00, 0x16b45, 1},
+		{0x16b50, 0x16b59, 1},
+		{0x16b5b, 0x16b61, 1},
+		{0x16b63, 0x16b77, 1},
+		{0x16b7d, 0x16b8f, 1},
+	},
+}
+
+var _Palmyrene = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10860, 0x1087f, 1},
+	},
+}
+
+var _Pau_Cin_Hau = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11ac0, 0x11af8, 1},
+	},
+}
+
 var _Phags_Pa = &RangeTable{
 	R16: []Range16{
 		{0xa840, 0xa877, 1},
@@ -4078,6 +4551,15 @@ var _Phoenician = &RangeTable{
 	},
 }
 
+var _Psalter_Pahlavi = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x10b80, 0x10b91, 1},
+		{0x10b99, 0x10b9c, 1},
+		{0x10ba9, 0x10baf, 1},
+	},
+}
+
 var _Rejang = &RangeTable{
 	R16: []Range16{
 		{0xa930, 0xa953, 1},
@@ -4088,7 +4570,7 @@ var _Rejang = &RangeTable{
 var _Runic = &RangeTable{
 	R16: []Range16{
 		{0x16a0, 0x16ea, 1},
-		{0x16ee, 0x16f0, 1},
+		{0x16ee, 0x16f8, 1},
 	},
 }
 
@@ -4110,7 +4592,8 @@ var _Sharada = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
 		{0x11180, 0x111c8, 1},
-		{0x111d0, 0x111d9, 1},
+		{0x111cd, 0x111cd, 1},
+		{0x111d0, 0x111da, 1},
 	},
 }
 
@@ -4121,6 +4604,14 @@ var _Shavian = &RangeTable{
 	},
 }
 
+var _Siddham = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11580, 0x115b5, 1},
+		{0x115b8, 0x115c9, 1},
+	},
+}
+
 var _Sinhala = &RangeTable{
 	R16: []Range16{
 		{0x0d82, 0x0d83, 1},
@@ -4133,8 +4624,12 @@ var _Sinhala = &RangeTable{
 		{0x0dcf, 0x0dd4, 1},
 		{0x0dd6, 0x0dd6, 1},
 		{0x0dd8, 0x0ddf, 1},
+		{0x0de6, 0x0def, 1},
 		{0x0df2, 0x0df4, 1},
 	},
+	R32: []Range32{
+		{0x111e1, 0x111f4, 1},
+	},
 }
 
 var _Sora_Sompeng = &RangeTable{
@@ -4236,12 +4731,11 @@ var _Tamil = &RangeTable{
 
 var _Telugu = &RangeTable{
 	R16: []Range16{
-		{0x0c01, 0x0c03, 1},
+		{0x0c00, 0x0c03, 1},
 		{0x0c05, 0x0c0c, 1},
 		{0x0c0e, 0x0c10, 1},
 		{0x0c12, 0x0c28, 1},
-		{0x0c2a, 0x0c33, 1},
-		{0x0c35, 0x0c39, 1},
+		{0x0c2a, 0x0c39, 1},
 		{0x0c3d, 0x0c44, 1},
 		{0x0c46, 0x0c48, 1},
 		{0x0c4a, 0x0c4d, 1},
@@ -4286,6 +4780,14 @@ var _Tifinagh = &RangeTable{
 	},
 }
 
+var _Tirhuta = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x11480, 0x114c7, 1},
+		{0x114d0, 0x114d9, 1},
+	},
+}
+
 var _Ugaritic = &RangeTable{
 	R16: []Range16{},
 	R32: []Range32{
@@ -4300,6 +4802,14 @@ var _Vai = &RangeTable{
 	},
 }
 
+var _Warang_Citi = &RangeTable{
+	R16: []Range16{},
+	R32: []Range32{
+		{0x118a0, 0x118f2, 1},
+		{0x118ff, 0x118ff, 1},
+	},
+}
+
 var _Yi = &RangeTable{
 	R16: []Range16{
 		{0xa000, 0xa48c, 1},
@@ -4314,6 +4824,7 @@ var (
 	Avestan                = _Avestan                // Avestan is the set of Unicode characters in script Avestan.
 	Balinese               = _Balinese               // Balinese is the set of Unicode characters in script Balinese.
 	Bamum                  = _Bamum                  // Bamum is the set of Unicode characters in script Bamum.
+	Bassa_Vah              = _Bassa_Vah              // Bassa_Vah is the set of Unicode characters in script Bassa_Vah.
 	Batak                  = _Batak                  // Batak is the set of Unicode characters in script Batak.
 	Bengali                = _Bengali                // Bengali is the set of Unicode characters in script Bengali.
 	Bopomofo               = _Bopomofo               // Bopomofo is the set of Unicode characters in script Bopomofo.
@@ -4323,6 +4834,7 @@ var (
 	Buhid                  = _Buhid                  // Buhid is the set of Unicode characters in script Buhid.
 	Canadian_Aboriginal    = _Canadian_Aboriginal    // Canadian_Aboriginal is the set of Unicode characters in script Canadian_Aboriginal.
 	Carian                 = _Carian                 // Carian is the set of Unicode characters in script Carian.
+	Caucasian_Albanian     = _Caucasian_Albanian     // Caucasian_Albanian is the set of Unicode characters in script Caucasian_Albanian.
 	Chakma                 = _Chakma                 // Chakma is the set of Unicode characters in script Chakma.
 	Cham                   = _Cham                   // Cham is the set of Unicode characters in script Cham.
 	Cherokee               = _Cherokee               // Cherokee is the set of Unicode characters in script Cherokee.
@@ -4333,11 +4845,14 @@ var (
 	Cyrillic               = _Cyrillic               // Cyrillic is the set of Unicode characters in script Cyrillic.
 	Deseret                = _Deseret                // Deseret is the set of Unicode characters in script Deseret.
 	Devanagari             = _Devanagari             // Devanagari is the set of Unicode characters in script Devanagari.
+	Duployan               = _Duployan               // Duployan is the set of Unicode characters in script Duployan.
 	Egyptian_Hieroglyphs   = _Egyptian_Hieroglyphs   // Egyptian_Hieroglyphs is the set of Unicode characters in script Egyptian_Hieroglyphs.
+	Elbasan                = _Elbasan                // Elbasan is the set of Unicode characters in script Elbasan.
 	Ethiopic               = _Ethiopic               // Ethiopic is the set of Unicode characters in script Ethiopic.
 	Georgian               = _Georgian               // Georgian is the set of Unicode characters in script Georgian.
 	Glagolitic             = _Glagolitic             // Glagolitic is the set of Unicode characters in script Glagolitic.
 	Gothic                 = _Gothic                 // Gothic is the set of Unicode characters in script Gothic.
+	Grantha                = _Grantha                // Grantha is the set of Unicode characters in script Grantha.
 	Greek                  = _Greek                  // Greek is the set of Unicode characters in script Greek.
 	Gujarati               = _Gujarati               // Gujarati is the set of Unicode characters in script Gujarati.
 	Gurmukhi               = _Gurmukhi               // Gurmukhi is the set of Unicode characters in script Gurmukhi.
@@ -4357,40 +4872,56 @@ var (
 	Kayah_Li               = _Kayah_Li               // Kayah_Li is the set of Unicode characters in script Kayah_Li.
 	Kharoshthi             = _Kharoshthi             // Kharoshthi is the set of Unicode characters in script Kharoshthi.
 	Khmer                  = _Khmer                  // Khmer is the set of Unicode characters in script Khmer.
+	Khojki                 = _Khojki                 // Khojki is the set of Unicode characters in script Khojki.
+	Khudawadi              = _Khudawadi              // Khudawadi is the set of Unicode characters in script Khudawadi.
 	Lao                    = _Lao                    // Lao is the set of Unicode characters in script Lao.
 	Latin                  = _Latin                  // Latin is the set of Unicode characters in script Latin.
 	Lepcha                 = _Lepcha                 // Lepcha is the set of Unicode characters in script Lepcha.
 	Limbu                  = _Limbu                  // Limbu is the set of Unicode characters in script Limbu.
+	Linear_A               = _Linear_A               // Linear_A is the set of Unicode characters in script Linear_A.
 	Linear_B               = _Linear_B               // Linear_B is the set of Unicode characters in script Linear_B.
 	Lisu                   = _Lisu                   // Lisu is the set of Unicode characters in script Lisu.
 	Lycian                 = _Lycian                 // Lycian is the set of Unicode characters in script Lycian.
 	Lydian                 = _Lydian                 // Lydian is the set of Unicode characters in script Lydian.
+	Mahajani               = _Mahajani               // Mahajani is the set of Unicode characters in script Mahajani.
 	Malayalam              = _Malayalam              // Malayalam is the set of Unicode characters in script Malayalam.
 	Mandaic                = _Mandaic                // Mandaic is the set of Unicode characters in script Mandaic.
+	Manichaean             = _Manichaean             // Manichaean is the set of Unicode characters in script Manichaean.
 	Meetei_Mayek           = _Meetei_Mayek           // Meetei_Mayek is the set of Unicode characters in script Meetei_Mayek.
+	Mende_Kikakui          = _Mende_Kikakui          // Mende_Kikakui is the set of Unicode characters in script Mende_Kikakui.
 	Meroitic_Cursive       = _Meroitic_Cursive       // Meroitic_Cursive is the set of Unicode characters in script Meroitic_Cursive.
 	Meroitic_Hieroglyphs   = _Meroitic_Hieroglyphs   // Meroitic_Hieroglyphs is the set of Unicode characters in script Meroitic_Hieroglyphs.
 	Miao                   = _Miao                   // Miao is the set of Unicode characters in script Miao.
+	Modi                   = _Modi                   // Modi is the set of Unicode characters in script Modi.
 	Mongolian              = _Mongolian              // Mongolian is the set of Unicode characters in script Mongolian.
+	Mro                    = _Mro                    // Mro is the set of Unicode characters in script Mro.
 	Myanmar                = _Myanmar                // Myanmar is the set of Unicode characters in script Myanmar.
+	Nabataean              = _Nabataean              // Nabataean is the set of Unicode characters in script Nabataean.
 	New_Tai_Lue            = _New_Tai_Lue            // New_Tai_Lue is the set of Unicode characters in script New_Tai_Lue.
 	Nko                    = _Nko                    // Nko is the set of Unicode characters in script Nko.
 	Ogham                  = _Ogham                  // Ogham is the set of Unicode characters in script Ogham.
 	Ol_Chiki               = _Ol_Chiki               // Ol_Chiki is the set of Unicode characters in script Ol_Chiki.
 	Old_Italic             = _Old_Italic             // Old_Italic is the set of Unicode characters in script Old_Italic.
+	Old_North_Arabian      = _Old_North_Arabian      // Old_North_Arabian is the set of Unicode characters in script Old_North_Arabian.
+	Old_Permic             = _Old_Permic             // Old_Permic is the set of Unicode characters in script Old_Permic.
 	Old_Persian            = _Old_Persian            // Old_Persian is the set of Unicode characters in script Old_Persian.
 	Old_South_Arabian      = _Old_South_Arabian      // Old_South_Arabian is the set of Unicode characters in script Old_South_Arabian.
 	Old_Turkic             = _Old_Turkic             // Old_Turkic is the set of Unicode characters in script Old_Turkic.
 	Oriya                  = _Oriya                  // Oriya is the set of Unicode characters in script Oriya.
 	Osmanya                = _Osmanya                // Osmanya is the set of Unicode characters in script Osmanya.
+	Pahawh_Hmong           = _Pahawh_Hmong           // Pahawh_Hmong is the set of Unicode characters in script Pahawh_Hmong.
+	Palmyrene              = _Palmyrene              // Palmyrene is the set of Unicode characters in script Palmyrene.
+	Pau_Cin_Hau            = _Pau_Cin_Hau            // Pau_Cin_Hau is the set of Unicode characters in script Pau_Cin_Hau.
 	Phags_Pa               = _Phags_Pa               // Phags_Pa is the set of Unicode characters in script Phags_Pa.
 	Phoenician             = _Phoenician             // Phoenician is the set of Unicode characters in script Phoenician.
+	Psalter_Pahlavi        = _Psalter_Pahlavi        // Psalter_Pahlavi is the set of Unicode characters in script Psalter_Pahlavi.
 	Rejang                 = _Rejang                 // Rejang is the set of Unicode characters in script Rejang.
 	Runic                  = _Runic                  // Runic is the set of Unicode characters in script Runic.
 	Samaritan              = _Samaritan              // Samaritan is the set of Unicode characters in script Samaritan.
 	Saurashtra             = _Saurashtra             // Saurashtra is the set of Unicode characters in script Saurashtra.
 	Sharada                = _Sharada                // Sharada is the set of Unicode characters in script Sharada.
 	Shavian                = _Shavian                // Shavian is the set of Unicode characters in script Shavian.
+	Siddham                = _Siddham                // Siddham is the set of Unicode characters in script Siddham.
 	Sinhala                = _Sinhala                // Sinhala is the set of Unicode characters in script Sinhala.
 	Sora_Sompeng           = _Sora_Sompeng           // Sora_Sompeng is the set of Unicode characters in script Sora_Sompeng.
 	Sundanese              = _Sundanese              // Sundanese is the set of Unicode characters in script Sundanese.
@@ -4408,13 +4939,15 @@ var (
 	Thai                   = _Thai                   // Thai is the set of Unicode characters in script Thai.
 	Tibetan                = _Tibetan                // Tibetan is the set of Unicode characters in script Tibetan.
 	Tifinagh               = _Tifinagh               // Tifinagh is the set of Unicode characters in script Tifinagh.
+	Tirhuta                = _Tirhuta                // Tirhuta is the set of Unicode characters in script Tirhuta.
 	Ugaritic               = _Ugaritic               // Ugaritic is the set of Unicode characters in script Ugaritic.
 	Vai                    = _Vai                    // Vai is the set of Unicode characters in script Vai.
+	Warang_Citi            = _Warang_Citi            // Warang_Citi is the set of Unicode characters in script Warang_Citi.
 	Yi                     = _Yi                     // Yi is the set of Unicode characters in script Yi.
 )
 
 // Generated by running
-//	maketables --props=all --url=http://www.unicode.org/Public/6.3.0/ucd/
+//	maketables --props=all --url=http://www.unicode.org/Public/7.0.0/ucd/
 // DO NOT EDIT
 
 // Properties is the set of Unicode property tables.
@@ -4486,6 +5019,7 @@ var _Dash = &RangeTable{
 		{0x2e17, 0x2e17, 1},
 		{0x2e1a, 0x2e1a, 1},
 		{0x2e3a, 0x2e3b, 1},
+		{0x2e40, 0x2e40, 1},
 		{0x301c, 0x301c, 1},
 		{0x3030, 0x3030, 1},
 		{0x30a0, 0x30a0, 1},
@@ -4583,6 +5117,7 @@ var _Diacritic = &RangeTable{
 		{0x1939, 0x193b, 1},
 		{0x1a75, 0x1a7c, 1},
 		{0x1a7f, 0x1a7f, 1},
+		{0x1ab0, 0x1abd, 1},
 		{0x1b34, 0x1b34, 1},
 		{0x1b44, 0x1b44, 1},
 		{0x1b6b, 0x1b73, 1},
@@ -4592,8 +5127,10 @@ var _Diacritic = &RangeTable{
 		{0x1cd0, 0x1ce8, 1},
 		{0x1ced, 0x1ced, 1},
 		{0x1cf4, 0x1cf4, 1},
+		{0x1cf8, 0x1cf9, 1},
 		{0x1d2c, 0x1d6a, 1},
 		{0x1dc4, 0x1dcf, 1},
+		{0x1df5, 0x1df5, 1},
 		{0x1dfd, 0x1dff, 1},
 		{0x1fbd, 0x1fbd, 1},
 		{0x1fbf, 0x1fc1, 1},
@@ -4609,6 +5146,7 @@ var _Diacritic = &RangeTable{
 		{0xa66f, 0xa66f, 1},
 		{0xa67c, 0xa67d, 1},
 		{0xa67f, 0xa67f, 1},
+		{0xa69c, 0xa69d, 1},
 		{0xa6f0, 0xa6f1, 1},
 		{0xa717, 0xa721, 1},
 		{0xa788, 0xa788, 1},
@@ -4619,12 +5157,14 @@ var _Diacritic = &RangeTable{
 		{0xa953, 0xa953, 1},
 		{0xa9b3, 0xa9b3, 1},
 		{0xa9c0, 0xa9c0, 1},
-		{0xaa7b, 0xaa7b, 1},
+		{0xa9e5, 0xa9e5, 1},
+		{0xaa7b, 0xaa7d, 1},
 		{0xaabf, 0xaac2, 1},
 		{0xaaf6, 0xaaf6, 1},
+		{0xab5b, 0xab5f, 1},
 		{0xabec, 0xabed, 1},
 		{0xfb1e, 0xfb1e, 1},
-		{0xfe20, 0xfe26, 1},
+		{0xfe20, 0xfe2d, 1},
 		{0xff3e, 0xff3e, 1},
 		{0xff40, 0xff40, 1},
 		{0xff70, 0xff70, 1},
@@ -4632,16 +5172,30 @@ var _Diacritic = &RangeTable{
 		{0xffe3, 0xffe3, 1},
 	},
 	R32: []Range32{
+		{0x102e0, 0x102e0, 1},
+		{0x10ae5, 0x10ae6, 1},
 		{0x110b9, 0x110ba, 1},
 		{0x11133, 0x11134, 1},
+		{0x11173, 0x11173, 1},
 		{0x111c0, 0x111c0, 1},
+		{0x11235, 0x11236, 1},
+		{0x112e9, 0x112ea, 1},
+		{0x1133c, 0x1133c, 1},
+		{0x1134d, 0x1134d, 1},
+		{0x11366, 0x1136c, 1},
+		{0x11370, 0x11374, 1},
+		{0x114c2, 0x114c3, 1},
+		{0x115bf, 0x115c0, 1},
+		{0x1163f, 0x1163f, 1},
 		{0x116b6, 0x116b7, 1},
+		{0x16af0, 0x16af4, 1},
 		{0x16f8f, 0x16f9f, 1},
 		{0x1d167, 0x1d169, 1},
 		{0x1d16d, 0x1d172, 1},
 		{0x1d17b, 0x1d182, 1},
 		{0x1d185, 0x1d18b, 1},
 		{0x1d1aa, 0x1d1ad, 1},
+		{0x1e8d0, 0x1e8d6, 1},
 	},
 	LatinOffset: 6,
 }
@@ -4666,11 +5220,17 @@ var _Extender = &RangeTable{
 		{0xa015, 0xa015, 1},
 		{0xa60c, 0xa60c, 1},
 		{0xa9cf, 0xa9cf, 1},
+		{0xa9e6, 0xa9e6, 1},
 		{0xaa70, 0xaa70, 1},
 		{0xaadd, 0xaadd, 1},
 		{0xaaf3, 0xaaf4, 1},
 		{0xff70, 0xff70, 1},
 	},
+	R32: []Range32{
+		{0x1135d, 0x1135d, 1},
+		{0x115c6, 0x115c8, 1},
+		{0x16b42, 0x16b43, 1},
+	},
 	LatinOffset: 1,
 }
 
@@ -4798,8 +5358,7 @@ var _Other_Alphabetic = &RangeTable{
 		{0x0825, 0x0827, 1},
 		{0x0829, 0x082c, 1},
 		{0x08e4, 0x08e9, 1},
-		{0x08f0, 0x08fe, 1},
-		{0x0900, 0x0903, 1},
+		{0x08f0, 0x0903, 1},
 		{0x093a, 0x093b, 1},
 		{0x093e, 0x094c, 1},
 		{0x094e, 0x094f, 1},
@@ -4834,19 +5393,19 @@ var _Other_Alphabetic = &RangeTable{
 		{0x0bc6, 0x0bc8, 1},
 		{0x0bca, 0x0bcc, 1},
 		{0x0bd7, 0x0bd7, 1},
-		{0x0c01, 0x0c03, 1},
+		{0x0c00, 0x0c03, 1},
 		{0x0c3e, 0x0c44, 1},
 		{0x0c46, 0x0c48, 1},
 		{0x0c4a, 0x0c4c, 1},
 		{0x0c55, 0x0c56, 1},
 		{0x0c62, 0x0c63, 1},
-		{0x0c82, 0x0c83, 1},
+		{0x0c81, 0x0c83, 1},
 		{0x0cbe, 0x0cc4, 1},
 		{0x0cc6, 0x0cc8, 1},
 		{0x0cca, 0x0ccc, 1},
 		{0x0cd5, 0x0cd6, 1},
 		{0x0ce2, 0x0ce3, 1},
-		{0x0d02, 0x0d03, 1},
+		{0x0d01, 0x0d03, 1},
 		{0x0d3e, 0x0d44, 1},
 		{0x0d46, 0x0d48, 1},
 		{0x0d4a, 0x0d4c, 1},
@@ -4899,6 +5458,7 @@ var _Other_Alphabetic = &RangeTable{
 		{0x1be7, 0x1bf1, 1},
 		{0x1c24, 0x1c35, 1},
 		{0x1cf2, 0x1cf3, 1},
+		{0x1de7, 0x1df4, 1},
 		{0x24b6, 0x24e9, 1},
 		{0x2de0, 0x2dff, 1},
 		{0xa674, 0xa67b, 1},
@@ -4923,6 +5483,7 @@ var _Other_Alphabetic = &RangeTable{
 		{0xfb1e, 0xfb1e, 1},
 	},
 	R32: []Range32{
+		{0x10376, 0x1037a, 1},
 		{0x10a01, 0x10a03, 1},
 		{0x10a05, 0x10a06, 1},
 		{0x10a0c, 0x10a0f, 1},
@@ -4934,8 +5495,27 @@ var _Other_Alphabetic = &RangeTable{
 		{0x11127, 0x11132, 1},
 		{0x11180, 0x11182, 1},
 		{0x111b3, 0x111bf, 1},
+		{0x1122c, 0x11234, 1},
+		{0x11237, 0x11237, 1},
+		{0x112df, 0x112e8, 1},
+		{0x11301, 0x11303, 1},
+		{0x1133e, 0x11344, 1},
+		{0x11347, 0x11348, 1},
+		{0x1134b, 0x1134c, 1},
+		{0x11357, 0x11357, 1},
+		{0x11362, 0x11363, 1},
+		{0x114b0, 0x114c1, 1},
+		{0x115af, 0x115b5, 1},
+		{0x115b8, 0x115be, 1},
+		{0x11630, 0x1163e, 1},
+		{0x11640, 0x11640, 1},
 		{0x116ab, 0x116b5, 1},
+		{0x16b30, 0x16b36, 1},
 		{0x16f51, 0x16f7e, 1},
+		{0x1bc9e, 0x1bc9e, 1},
+		{0x1f130, 0x1f149, 1},
+		{0x1f150, 0x1f169, 1},
+		{0x1f170, 0x1f189, 1},
 	},
 }
 
@@ -4976,6 +5556,11 @@ var _Other_Grapheme_Extend = &RangeTable{
 		{0xff9e, 0xff9f, 1},
 	},
 	R32: []Range32{
+		{0x1133e, 0x1133e, 1},
+		{0x11357, 0x11357, 1},
+		{0x114b0, 0x114b0, 1},
+		{0x114bd, 0x114bd, 1},
+		{0x115af, 0x115af, 1},
 		{0x1d165, 0x1d165, 1},
 		{0x1d16e, 0x1d172, 1},
 	},
@@ -5017,8 +5602,10 @@ var _Other_Lowercase = &RangeTable{
 		{0x2170, 0x217f, 1},
 		{0x24d0, 0x24e9, 1},
 		{0x2c7c, 0x2c7d, 1},
+		{0xa69c, 0xa69d, 1},
 		{0xa770, 0xa770, 1},
 		{0xa7f8, 0xa7f9, 1},
+		{0xab5c, 0xab5f, 1},
 	},
 	LatinOffset: 2,
 }
@@ -5170,6 +5757,11 @@ var _Other_Uppercase = &RangeTable{
 		{0x2160, 0x216f, 1},
 		{0x24b6, 0x24cf, 1},
 	},
+	R32: []Range32{
+		{0x1f130, 0x1f149, 1},
+		{0x1f150, 0x1f169, 1},
+		{0x1f170, 0x1f189, 1},
+	},
 }
 
 var _Pattern_Syntax = &RangeTable{
@@ -5225,6 +5817,7 @@ var _Quotation_Mark = &RangeTable{
 		{0x00bb, 0x00bb, 1},
 		{0x2018, 0x201f, 1},
 		{0x2039, 0x203a, 1},
+		{0x2e42, 0x2e42, 1},
 		{0x300c, 0x300f, 1},
 		{0x301d, 0x301f, 1},
 		{0xfe41, 0xfe44, 1},
@@ -5248,8 +5841,6 @@ var _STerm = &RangeTable{
 		{0x0021, 0x0021, 1},
 		{0x002e, 0x002e, 1},
 		{0x003f, 0x003f, 1},
-		{0x055c, 0x055c, 1},
-		{0x055e, 0x055e, 1},
 		{0x0589, 0x0589, 1},
 		{0x061f, 0x061f, 1},
 		{0x06d4, 0x06d4, 1},
@@ -5272,6 +5863,7 @@ var _STerm = &RangeTable{
 		{0x203c, 0x203d, 1},
 		{0x2047, 0x2049, 1},
 		{0x2e2e, 0x2e2e, 1},
+		{0x2e3c, 0x2e3c, 1},
 		{0x3002, 0x3002, 1},
 		{0xa4ff, 0xa4ff, 1},
 		{0xa60e, 0xa60f, 1},
@@ -5297,6 +5889,17 @@ var _STerm = &RangeTable{
 		{0x110be, 0x110c1, 1},
 		{0x11141, 0x11143, 1},
 		{0x111c5, 0x111c6, 1},
+		{0x111cd, 0x111cd, 1},
+		{0x11238, 0x11239, 1},
+		{0x1123b, 0x1123c, 1},
+		{0x115c2, 0x115c3, 1},
+		{0x115c9, 0x115c9, 1},
+		{0x11641, 0x11642, 1},
+		{0x16a6e, 0x16a6f, 1},
+		{0x16af5, 0x16af5, 1},
+		{0x16b37, 0x16b38, 1},
+		{0x16b44, 0x16b44, 1},
+		{0x1bc9f, 0x1bc9f, 1},
 	},
 	LatinOffset: 3,
 }
@@ -5368,6 +5971,7 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x1361, 0x1368, 1},
 		{0x166d, 0x166e, 1},
 		{0x16eb, 0x16ed, 1},
+		{0x1735, 0x1736, 1},
 		{0x17d4, 0x17d6, 1},
 		{0x17da, 0x17da, 1},
 		{0x1802, 0x1805, 1},
@@ -5381,6 +5985,8 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x203c, 0x203d, 1},
 		{0x2047, 0x2049, 1},
 		{0x2e2e, 0x2e2e, 1},
+		{0x2e3c, 0x2e3c, 1},
+		{0x2e41, 0x2e41, 1},
 		{0x3001, 0x3002, 1},
 		{0xa4fe, 0xa4ff, 1},
 		{0xa60d, 0xa60f, 1},
@@ -5408,12 +6014,25 @@ var _Terminal_Punctuation = &RangeTable{
 		{0x103d0, 0x103d0, 1},
 		{0x10857, 0x10857, 1},
 		{0x1091f, 0x1091f, 1},
+		{0x10a56, 0x10a57, 1},
+		{0x10af0, 0x10af5, 1},
 		{0x10b3a, 0x10b3f, 1},
+		{0x10b99, 0x10b9c, 1},
 		{0x11047, 0x1104d, 1},
 		{0x110be, 0x110c1, 1},
 		{0x11141, 0x11143, 1},
 		{0x111c5, 0x111c6, 1},
-		{0x12470, 0x12473, 1},
+		{0x111cd, 0x111cd, 1},
+		{0x11238, 0x1123c, 1},
+		{0x115c2, 0x115c5, 1},
+		{0x115c9, 0x115c9, 1},
+		{0x11641, 0x11642, 1},
+		{0x12470, 0x12474, 1},
+		{0x16a6e, 0x16a6f, 1},
+		{0x16af5, 0x16af5, 1},
+		{0x16b37, 0x16b39, 1},
+		{0x16b44, 0x16b44, 1},
+		{0x1bc9f, 0x1bc9f, 1},
 	},
 	LatinOffset: 5,
 }
@@ -5500,7 +6119,7 @@ var (
 )
 
 // Generated by running
-//	maketables --data=http://www.unicode.org/Public/6.3.0/ucd/UnicodeData.txt --casefolding=http://www.unicode.org/Public/6.3.0/ucd/CaseFolding.txt
+//	maketables --data=http://www.unicode.org/Public/7.0.0/ucd/UnicodeData.txt --casefolding=http://www.unicode.org/Public/7.0.0/ucd/CaseFolding.txt
 // DO NOT EDIT
 
 // CaseRanges is the table describing case mappings for all letters with
@@ -5598,13 +6217,16 @@ var _CaseRanges = []CaseRange{
 	{0x0256, 0x0257, d{-205, 0, -205}},
 	{0x0259, 0x0259, d{-202, 0, -202}},
 	{0x025B, 0x025B, d{-203, 0, -203}},
+	{0x025C, 0x025C, d{42319, 0, 42319}},
 	{0x0260, 0x0260, d{-205, 0, -205}},
+	{0x0261, 0x0261, d{42315, 0, 42315}},
 	{0x0263, 0x0263, d{-207, 0, -207}},
 	{0x0265, 0x0265, d{42280, 0, 42280}},
 	{0x0266, 0x0266, d{42308, 0, 42308}},
 	{0x0268, 0x0268, d{-209, 0, -209}},
 	{0x0269, 0x0269, d{-211, 0, -211}},
 	{0x026B, 0x026B, d{10743, 0, 10743}},
+	{0x026C, 0x026C, d{42305, 0, 42305}},
 	{0x026F, 0x026F, d{-211, 0, -211}},
 	{0x0271, 0x0271, d{10749, 0, 10749}},
 	{0x0272, 0x0272, d{-213, 0, -213}},
@@ -5612,15 +6234,18 @@ var _CaseRanges = []CaseRange{
 	{0x027D, 0x027D, d{10727, 0, 10727}},
 	{0x0280, 0x0280, d{-218, 0, -218}},
 	{0x0283, 0x0283, d{-218, 0, -218}},
+	{0x0287, 0x0287, d{42282, 0, 42282}},
 	{0x0288, 0x0288, d{-218, 0, -218}},
 	{0x0289, 0x0289, d{-69, 0, -69}},
 	{0x028A, 0x028B, d{-217, 0, -217}},
 	{0x028C, 0x028C, d{-71, 0, -71}},
 	{0x0292, 0x0292, d{-219, 0, -219}},
+	{0x029E, 0x029E, d{42258, 0, 42258}},
 	{0x0345, 0x0345, d{84, 0, 84}},
 	{0x0370, 0x0373, d{UpperLower, UpperLower, UpperLower}},
 	{0x0376, 0x0377, d{UpperLower, UpperLower, UpperLower}},
 	{0x037B, 0x037D, d{130, 0, 130}},
+	{0x037F, 0x037F, d{0, 116, 0}},
 	{0x0386, 0x0386, d{0, 38, 0}},
 	{0x0388, 0x038A, d{0, 37, 0}},
 	{0x038C, 0x038C, d{0, 64, 0}},
@@ -5644,6 +6269,7 @@ var _CaseRanges = []CaseRange{
 	{0x03F0, 0x03F0, d{-86, 0, -86}},
 	{0x03F1, 0x03F1, d{-80, 0, -80}},
 	{0x03F2, 0x03F2, d{7, 0, 7}},
+	{0x03F3, 0x03F3, d{-116, 0, -116}},
 	{0x03F4, 0x03F4, d{0, -60, 0}},
 	{0x03F5, 0x03F5, d{-96, 0, -96}},
 	{0x03F7, 0x03F8, d{UpperLower, UpperLower, UpperLower}},
@@ -5659,7 +6285,7 @@ var _CaseRanges = []CaseRange{
 	{0x04C0, 0x04C0, d{0, 15, 0}},
 	{0x04C1, 0x04CE, d{UpperLower, UpperLower, UpperLower}},
 	{0x04CF, 0x04CF, d{-15, 0, -15}},
-	{0x04D0, 0x0527, d{UpperLower, UpperLower, UpperLower}},
+	{0x04D0, 0x052F, d{UpperLower, UpperLower, UpperLower}},
 	{0x0531, 0x0556, d{0, 48, 0}},
 	{0x0561, 0x0586, d{-48, 0, -48}},
 	{0x10A0, 0x10C5, d{0, 7264, 0}},
@@ -5757,7 +6383,7 @@ var _CaseRanges = []CaseRange{
 	{0x2D27, 0x2D27, d{-7264, 0, -7264}},
 	{0x2D2D, 0x2D2D, d{-7264, 0, -7264}},
 	{0xA640, 0xA66D, d{UpperLower, UpperLower, UpperLower}},
-	{0xA680, 0xA697, d{UpperLower, UpperLower, UpperLower}},
+	{0xA680, 0xA69B, d{UpperLower, UpperLower, UpperLower}},
 	{0xA722, 0xA72F, d{UpperLower, UpperLower, UpperLower}},
 	{0xA732, 0xA76F, d{UpperLower, UpperLower, UpperLower}},
 	{0xA779, 0xA77C, d{UpperLower, UpperLower, UpperLower}},
@@ -5766,12 +6392,19 @@ var _CaseRanges = []CaseRange{
 	{0xA78B, 0xA78C, d{UpperLower, UpperLower, UpperLower}},
 	{0xA78D, 0xA78D, d{0, -42280, 0}},
 	{0xA790, 0xA793, d{UpperLower, UpperLower, UpperLower}},
-	{0xA7A0, 0xA7A9, d{UpperLower, UpperLower, UpperLower}},
+	{0xA796, 0xA7A9, d{UpperLower, UpperLower, UpperLower}},
 	{0xA7AA, 0xA7AA, d{0, -42308, 0}},
+	{0xA7AB, 0xA7AB, d{0, -42319, 0}},
+	{0xA7AC, 0xA7AC, d{0, -42315, 0}},
+	{0xA7AD, 0xA7AD, d{0, -42305, 0}},
+	{0xA7B0, 0xA7B0, d{0, -42258, 0}},
+	{0xA7B1, 0xA7B1, d{0, -42282, 0}},
 	{0xFF21, 0xFF3A, d{0, 32, 0}},
 	{0xFF41, 0xFF5A, d{-32, 0, -32}},
 	{0x10400, 0x10427, d{0, 40, 0}},
 	{0x10428, 0x1044F, d{-40, 0, -40}},
+	{0x118A0, 0x118BF, d{0, 32, 0}},
+	{0x118C0, 0x118DF, d{-32, 0, -32}},
 }
 var properties = [MaxLatin1 + 1]uint8{
 	0x00: pC,       // '\x00'
@@ -6181,8 +6814,8 @@ var foldLl = &RangeTable{
 		{0x0248, 0x024e, 2},
 		{0x0345, 0x0370, 43},
 		{0x0372, 0x0376, 4},
-		{0x0386, 0x0388, 2},
-		{0x0389, 0x038a, 1},
+		{0x037f, 0x0386, 7},
+		{0x0388, 0x038a, 1},
 		{0x038c, 0x038e, 2},
 		{0x038f, 0x0391, 2},
 		{0x0392, 0x03a1, 1},
@@ -6195,7 +6828,7 @@ var foldLl = &RangeTable{
 		{0x0460, 0x0480, 2},
 		{0x048a, 0x04c0, 2},
 		{0x04c1, 0x04cd, 2},
-		{0x04d0, 0x0526, 2},
+		{0x04d0, 0x052e, 2},
 		{0x0531, 0x0556, 1},
 		{0x10a0, 0x10c5, 1},
 		{0x10c7, 0x10cd, 6},
@@ -6230,18 +6863,21 @@ var foldLl = &RangeTable{
 		{0x2ceb, 0x2ced, 2},
 		{0x2cf2, 0xa640, 31054},
 		{0xa642, 0xa66c, 2},
-		{0xa680, 0xa696, 2},
+		{0xa680, 0xa69a, 2},
 		{0xa722, 0xa72e, 2},
 		{0xa732, 0xa76e, 2},
 		{0xa779, 0xa77d, 2},
 		{0xa77e, 0xa786, 2},
 		{0xa78b, 0xa78d, 2},
 		{0xa790, 0xa792, 2},
-		{0xa7a0, 0xa7aa, 2},
+		{0xa796, 0xa7aa, 2},
+		{0xa7ab, 0xa7ad, 1},
+		{0xa7b0, 0xa7b1, 1},
 		{0xff21, 0xff3a, 1},
 	},
 	R32: []Range32{
 		{0x10400, 0x10427, 1},
+		{0x118a0, 0x118bf, 1},
 	},
 	LatinOffset: 3,
 }
@@ -6297,30 +6933,31 @@ var foldLu = &RangeTable{
 		{0x0250, 0x0254, 1},
 		{0x0256, 0x0257, 1},
 		{0x0259, 0x025b, 2},
-		{0x0260, 0x0263, 3},
-		{0x0265, 0x0266, 1},
-		{0x0268, 0x0269, 1},
-		{0x026b, 0x026f, 4},
+		{0x025c, 0x0260, 4},
+		{0x0261, 0x0265, 2},
+		{0x0266, 0x0268, 2},
+		{0x0269, 0x026b, 2},
+		{0x026c, 0x026f, 3},
 		{0x0271, 0x0272, 1},
 		{0x0275, 0x027d, 8},
 		{0x0280, 0x0283, 3},
-		{0x0288, 0x028c, 1},
-		{0x0292, 0x0345, 179},
-		{0x0371, 0x0373, 2},
-		{0x0377, 0x037b, 4},
+		{0x0287, 0x028c, 1},
+		{0x0292, 0x029e, 12},
+		{0x0345, 0x0371, 44},
+		{0x0373, 0x037b, 4},
 		{0x037c, 0x037d, 1},
 		{0x03ac, 0x03af, 1},
 		{0x03b1, 0x03ce, 1},
 		{0x03d0, 0x03d1, 1},
 		{0x03d5, 0x03d7, 1},
 		{0x03d9, 0x03ef, 2},
-		{0x03f0, 0x03f2, 1},
+		{0x03f0, 0x03f3, 1},
 		{0x03f5, 0x03fb, 3},
 		{0x0430, 0x045f, 1},
 		{0x0461, 0x0481, 2},
 		{0x048b, 0x04bf, 2},
 		{0x04c2, 0x04ce, 2},
-		{0x04cf, 0x0527, 2},
+		{0x04cf, 0x052f, 2},
 		{0x0561, 0x0586, 1},
 		{0x1d79, 0x1d7d, 4},
 		{0x1e01, 0x1e95, 2},
@@ -6349,18 +6986,19 @@ var foldLu = &RangeTable{
 		{0x2d01, 0x2d25, 1},
 		{0x2d27, 0x2d2d, 6},
 		{0xa641, 0xa66d, 2},
-		{0xa681, 0xa697, 2},
+		{0xa681, 0xa69b, 2},
 		{0xa723, 0xa72f, 2},
 		{0xa733, 0xa76f, 2},
 		{0xa77a, 0xa77c, 2},
 		{0xa77f, 0xa787, 2},
 		{0xa78c, 0xa791, 5},
-		{0xa793, 0xa7a1, 14},
-		{0xa7a3, 0xa7a9, 2},
+		{0xa793, 0xa797, 4},
+		{0xa799, 0xa7a9, 2},
 		{0xff41, 0xff5a, 1},
 	},
 	R32: []Range32{
 		{0x10428, 0x1044f, 1},
+		{0x118c0, 0x118df, 1},
 	},
 	LatinOffset: 4,
 }
@@ -6385,7 +7023,7 @@ var foldMn = &RangeTable{
 // If there is no entry for a script name, there are no such points.
 var FoldScript = map[string]*RangeTable{}
 
-// Range entries: 3471 16-bit, 832 32-bit, 4303 total.
-// Range bytes: 20826 16-bit, 9984 32-bit, 30810 total.
+// Range entries: 3532 16-bit, 1204 32-bit, 4736 total.
+// Range bytes: 21192 16-bit, 14448 32-bit, 35640 total.
 
 // Fold orbit bytes: 63 pairs, 252 bytes

From 523aa932881e72ccc83f25d441b2e535c1048296 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Mon, 18 Aug 2014 13:26:28 -0700
Subject: [PATCH 108/423] runtime: move panicindex/panicslice to Go.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/130210043
---
 src/pkg/runtime/panic.c  | 12 ------------
 src/pkg/runtime/panic.go | 13 +++++++++++++
 2 files changed, 13 insertions(+), 12 deletions(-)
 create mode 100644 src/pkg/runtime/panic.go

diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index bc685398a6..d0284f9c20 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -459,18 +459,6 @@ runtime·dopanic(int32 unused)
 	runtime·exit(2);
 }
 
-void
-runtime·panicindex(void)
-{
-	runtime·panicstring("index out of range");
-}
-
-void
-runtime·panicslice(void)
-{
-	runtime·panicstring("slice bounds out of range");
-}
-
 void
 runtime·throwreturn(void)
 {
diff --git a/src/pkg/runtime/panic.go b/src/pkg/runtime/panic.go
new file mode 100644
index 0000000000..ac0c6b77ee
--- /dev/null
+++ b/src/pkg/runtime/panic.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.
+
+package runtime
+
+func panicindex() {
+	panic(errorString("index out of range"))
+}
+
+func panicslice() {
+	panic(errorString("slice bounds out of range"))
+}

From 6d248cec56dd56f3ddb92bd587b5c4ac2f9919b1 Mon Sep 17 00:00:00 2001
From: "Jeff R. Allen" <jra@nella.org>
Date: Mon, 18 Aug 2014 14:41:28 -0700
Subject: [PATCH 109/423] bzip2: improve performance

Improve performance of move-to-front by using cache-friendly
copies instead of doubly-linked list. Simplify so that the
underlying slice is the object. Remove the n=0 special case,
      which was actually slower with the copy approach.

benchmark                 old ns/op     new ns/op     delta
BenchmarkDecodeDigits     26429714      23859699      -9.72%
BenchmarkDecodeTwain      76684510      67591946      -11.86%

benchmark                 old MB/s     new MB/s     speedup
BenchmarkDecodeDigits     1.63         1.81         1.11x
BenchmarkDecodeTwain      1.63         1.85         1.13x

Updates #6754.

LGTM=adg, agl, josharian
R=adg, agl, josharian
CC=golang-codereviews
https://golang.org/cl/131840043
---
 src/pkg/compress/bzip2/bzip2_test.go    | 38 ++++++++++++
 src/pkg/compress/bzip2/move_to_front.go | 79 ++++++-------------------
 2 files changed, 55 insertions(+), 62 deletions(-)

diff --git a/src/pkg/compress/bzip2/bzip2_test.go b/src/pkg/compress/bzip2/bzip2_test.go
index 6b8711b811..fb79d089eb 100644
--- a/src/pkg/compress/bzip2/bzip2_test.go
+++ b/src/pkg/compress/bzip2/bzip2_test.go
@@ -216,6 +216,44 @@ func TestOutOfRangeSelector(t *testing.T) {
 	ioutil.ReadAll(decompressor)
 }
 
+func TestMTF(t *testing.T) {
+	mtf := newMTFDecoderWithRange(5)
+
+	// 0 1 2 3 4
+	expect := byte(1)
+	x := mtf.Decode(1)
+	if x != expect {
+		t.Errorf("expected %v, got %v", expect, x)
+	}
+
+	// 1 0 2 3 4
+	x = mtf.Decode(0)
+	if x != expect {
+		t.Errorf("expected %v, got %v", expect, x)
+	}
+
+	// 1 0 2 3 4
+	expect = byte(0)
+	x = mtf.Decode(1)
+	if x != expect {
+		t.Errorf("expected %v, got %v", expect, x)
+	}
+
+	// 0 1 2 3 4
+	expect = byte(4)
+	x = mtf.Decode(4)
+	if x != expect {
+		t.Errorf("expected %v, got %v", expect, x)
+	}
+
+	// 4 0 1 2 3
+	expect = byte(0)
+	x = mtf.Decode(1)
+	if x != expect {
+		t.Errorf("expected %v, got %v", expect, x)
+	}
+}
+
 var bufferOverrunBase64 string = `
 QlpoNTFBWSZTWTzyiGcACMP/////////////////////////////////3/7f3///
 ////4N/fCZODak2Xo44GIHZgkGzDRbFAuwAAKoFV7T6AO6qwA6APb6s2rOoAkAAD
diff --git a/src/pkg/compress/bzip2/move_to_front.go b/src/pkg/compress/bzip2/move_to_front.go
index b7e75a700a..526dfb34cc 100644
--- a/src/pkg/compress/bzip2/move_to_front.go
+++ b/src/pkg/compress/bzip2/move_to_front.go
@@ -11,88 +11,43 @@ package bzip2
 // index into that list. When a symbol is referenced, it's moved to the front
 // of the list. Thus, a repeated symbol ends up being encoded with many zeros,
 // as the symbol will be at the front of the list after the first access.
-type moveToFrontDecoder struct {
-	// Rather than actually keep the list in memory, the symbols are stored
-	// as a circular, double linked list with the symbol indexed by head
-	// at the front of the list.
-	symbols [256]byte
-	next    [256]uint8
-	prev    [256]uint8
-	head    uint8
-	len     int
-}
+type moveToFrontDecoder []byte
 
 // newMTFDecoder creates a move-to-front decoder with an explicit initial list
 // of symbols.
-func newMTFDecoder(symbols []byte) *moveToFrontDecoder {
+func newMTFDecoder(symbols []byte) moveToFrontDecoder {
 	if len(symbols) > 256 {
 		panic("too many symbols")
 	}
-
-	m := new(moveToFrontDecoder)
-	copy(m.symbols[:], symbols)
-	m.len = len(symbols)
-	m.threadLinkedList()
-	return m
+	return moveToFrontDecoder(symbols)
 }
 
 // newMTFDecoderWithRange creates a move-to-front decoder with an initial
 // symbol list of 0...n-1.
-func newMTFDecoderWithRange(n int) *moveToFrontDecoder {
+func newMTFDecoderWithRange(n int) moveToFrontDecoder {
 	if n > 256 {
 		panic("newMTFDecoderWithRange: cannot have > 256 symbols")
 	}
 
-	m := new(moveToFrontDecoder)
+	m := make([]byte, n)
 	for i := 0; i < n; i++ {
-		m.symbols[byte(i)] = byte(i)
+		m[i] = byte(i)
 	}
-	m.len = n
-	m.threadLinkedList()
-	return m
+	return moveToFrontDecoder(m)
 }
 
-// threadLinkedList creates the initial linked-list pointers.
-func (m *moveToFrontDecoder) threadLinkedList() {
-	if m.len == 0 {
-		return
-	}
-
-	m.prev[0] = uint8(m.len - 1)
-
-	for i := byte(0); int(i) < m.len-1; i++ {
-		m.next[i] = uint8(i + 1)
-		m.prev[i+1] = uint8(i)
-	}
-
-	m.next[m.len-1] = 0
-}
-
-func (m *moveToFrontDecoder) Decode(n int) (b byte) {
-	// Most of the time, n will be zero so it's worth dealing with this
-	// simple case.
-	if n == 0 {
-		return m.symbols[m.head]
-	}
-
-	i := m.head
-	for j := 0; j < n; j++ {
-		i = m.next[i]
-	}
-	b = m.symbols[i]
-
-	m.next[m.prev[i]] = m.next[i]
-	m.prev[m.next[i]] = m.prev[i]
-	m.next[i] = m.head
-	m.prev[i] = m.prev[m.head]
-	m.next[m.prev[m.head]] = i
-	m.prev[m.head] = i
-	m.head = i
-
+func (m moveToFrontDecoder) Decode(n int) (b byte) {
+	// Implement move-to-front with a simple copy. This approach
+	// beats more sophisticated approaches in benchmarking, probably
+	// because it has high locality of reference inside of a
+	// single cache line (most move-to-front operations have n < 64).
+	b = m[n]
+	copy(m[1:], m[:n])
+	m[0] = b
 	return
 }
 
 // First returns the symbol at the front of the list.
-func (m *moveToFrontDecoder) First() byte {
-	return m.symbols[m.head]
+func (m moveToFrontDecoder) First() byte {
+	return m[0]
 }

From 326f48eb9cfcdaf7433756361b465df5b889dd46 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Tue, 19 Aug 2014 08:52:52 +1000
Subject: [PATCH 110/423] fmt: print byte stringers correctly

type T byte
func (T) String() string { return "X" }

fmt.Sprintf("%s", []T{97, 98, 99, 100}) == "abcd"
fmt.Sprintf("%x", []T{97, 98, 99, 100}) == "61626364"
fmt.Sprintf("%v", []T{97, 98, 99, 100}) == "[X X X X]"

This change makes the last case print correctly.
Before, it would have been "[97 98 99 100]".

Fixes #8360.

LGTM=r
R=r, dan.kortschak
CC=golang-codereviews
https://golang.org/cl/129330043
---
 src/pkg/fmt/fmt_test.go | 29 +++++++++++++++++++++++++++++
 src/pkg/fmt/print.go    | 10 ++++++++--
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/pkg/fmt/fmt_test.go b/src/pkg/fmt/fmt_test.go
index 89227cce80..8c577949a1 100644
--- a/src/pkg/fmt/fmt_test.go
+++ b/src/pkg/fmt/fmt_test.go
@@ -108,6 +108,20 @@ func (p *P) String() string {
 var barray = [5]renamedUint8{1, 2, 3, 4, 5}
 var bslice = barray[:]
 
+type byteStringer byte
+
+func (byteStringer) String() string { return "X" }
+
+var byteStringerSlice = []byteStringer{97, 98, 99, 100}
+
+type byteFormatter byte
+
+func (byteFormatter) Format(f State, _ rune) {
+	Fprint(f, "X")
+}
+
+var byteFormatterSlice = []byteFormatter{97, 98, 99, 100}
+
 var b byte
 
 var fmtTests = []struct {
@@ -629,6 +643,21 @@ var fmtTests = []struct {
 	{"%+010.2f", -104.66 + 440.51i, "(-000104.66+000440.51i)"},
 	{"%+010.2f", +104.66 - 440.51i, "(+000104.66-000440.51i)"},
 	{"%+010.2f", -104.66 - 440.51i, "(-000104.66-000440.51i)"},
+
+	// []T where type T is a byte with a Stringer method.
+	{"%v", byteStringerSlice, "[X X X X]"},
+	{"%s", byteStringerSlice, "abcd"},
+	{"%q", byteStringerSlice, "\"abcd\""},
+	{"%x", byteStringerSlice, "61626364"},
+	{"%#v", byteStringerSlice, "[]fmt_test.byteStringer{0x61, 0x62, 0x63, 0x64}"},
+
+	// And the same for Formatter.
+	{"%v", byteFormatterSlice, "[X X X X]"},
+	{"%s", byteFormatterSlice, "abcd"},
+	{"%q", byteFormatterSlice, "\"abcd\""},
+	{"%x", byteFormatterSlice, "61626364"},
+	// This next case seems wrong, but the docs say the Formatter wins here.
+	{"%#v", byteFormatterSlice, "[]fmt_test.byteFormatter{X, X, X, X}"},
 }
 
 // zeroFill generates zero-filled strings of the specified width. The length
diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go
index 302661f4c8..679c577dbd 100644
--- a/src/pkg/fmt/print.go
+++ b/src/pkg/fmt/print.go
@@ -832,6 +832,8 @@ func (p *pp) printValue(value reflect.Value, verb rune, plus, goSyntax bool, dep
 	return p.printReflectValue(value, verb, plus, goSyntax, depth)
 }
 
+var byteType = reflect.TypeOf(byte(0))
+
 // printReflectValue is the fallback for both printArg and printValue.
 // It uses reflect to print the value.
 func (p *pp) printReflectValue(value reflect.Value, verb rune, plus, goSyntax bool, depth int) (wasString bool) {
@@ -925,8 +927,12 @@ BigSwitch:
 			wasString = p.printValue(value, verb, plus, goSyntax, depth+1)
 		}
 	case reflect.Array, reflect.Slice:
-		// Byte slices are special.
-		if typ := f.Type(); typ.Elem().Kind() == reflect.Uint8 {
+		// Byte slices are special:
+		// - Handle []byte (== []uint8) with fmtBytes.
+		// - Handle []T, where T is a named byte type, with fmtBytes only
+		//   for the s, q, an x verbs. For other verbs, T might be a
+		//   Stringer, so we use printValue to print each element.
+		if typ := f.Type(); typ.Elem().Kind() == reflect.Uint8 && (typ.Elem() == byteType || verb == 's' || verb == 'q' || verb == 'x') {
 			var bytes []byte
 			if f.Kind() == reflect.Slice {
 				bytes = f.Bytes()

From afb6221bf79d7ed59e4a859f147bbed2ea2c3617 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Tue, 19 Aug 2014 10:52:50 +1000
Subject: [PATCH 111/423] cmd/6g: fix undefined behavior in reg.c

Update #8527

Fixes, cmd/6g/reg.c:847:24: runtime error: left shift of 1 by 31 places cannot be represented in type 'int'

LGTM=minux, rsc
R=minux, rsc
CC=dvyukov, golang-codereviews
https://golang.org/cl/129290043
---
 src/cmd/6g/reg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/6g/reg.c b/src/cmd/6g/reg.c
index 02945fb401..5e3a198186 100644
--- a/src/cmd/6g/reg.c
+++ b/src/cmd/6g/reg.c
@@ -844,7 +844,7 @@ prop(Reg *r, Bits ref, Bits cal)
 					if(v == v1 || ((cal.b[j/32]>>(j&31))&1) == 0) {
 						for(; v1 != nil; v1 = v1->nextinnode) {
 							j = v1 - var;
-							cal.b[j/32] |= 1<<(j&31);
+							cal.b[j/32] |= 1UL<<(j&31);
 						}
 					}
 				}

From d89cd2485784a4b458cc5ac12aba11994fd379c7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 18 Aug 2014 21:06:42 -0400
Subject: [PATCH 112/423] runtime: avoid $sym(SB) as constant

The change to pc-relative addressing will make this illegal.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews, r
https://golang.org/cl/129890043
---
 src/pkg/runtime/race_amd64.s | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/race_amd64.s b/src/pkg/runtime/race_amd64.s
index 210f5d4ad7..30281d224b 100644
--- a/src/pkg/runtime/race_amd64.s
+++ b/src/pkg/runtime/race_amd64.s
@@ -144,9 +144,11 @@ TEXT	racecalladdr<>(SB), NOSPLIT, $0-0
 	CMPQ	RARG1, runtime·racearenaend(SB)
 	JB	racecalladdr_call
 racecalladdr_data:
-	CMPQ	RARG1, $noptrdata(SB)
+	MOVQ	$noptrdata(SB), R13
+	CMPQ	RARG1, R13
 	JB	racecalladdr_ret
-	CMPQ	RARG1, $enoptrbss(SB)
+	MOVQ	$enoptrbss(SB), R13
+	CMPQ	RARG1, R13
 	JAE	racecalladdr_ret
 racecalladdr_call:
 	MOVQ	AX, AX		// w/o this 6a miscompiles this function

From ca85d572d64e6d038ac8216a39a05980320c8a03 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 18 Aug 2014 21:06:56 -0400
Subject: [PATCH 113/423] liblink: use pc-relative addressing for all memory
 references in amd64 code

LGTM=rminnich, iant
R=golang-codereviews, rminnich, iant
CC=golang-codereviews, r
https://golang.org/cl/125140043
---
 src/cmd/6l/asm.c   | 17 +++++++++++++----
 src/cmd/ld/data.c  | 10 +++++++---
 src/liblink/asm6.c | 29 ++++++++---------------------
 3 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/cmd/6l/asm.c b/src/cmd/6l/asm.c
index e251e32ca9..c7f6c65d00 100644
--- a/src/cmd/6l/asm.c
+++ b/src/cmd/6l/asm.c
@@ -290,7 +290,6 @@ elfreloc1(Reloc *r, vlong sectoff)
 		break;
 		
 	case R_CALL:
-	case R_PCREL:
 		if(r->siz == 4) {
 			if(r->xsym->type == SDYNIMPORT)
 				VPUT(R_X86_64_GOTPCREL | (uint64)elfsym<<32);
@@ -299,7 +298,14 @@ elfreloc1(Reloc *r, vlong sectoff)
 		} else
 			return -1;
 		break;
-	
+
+	case R_PCREL:
+		if(r->siz == 4) {
+			VPUT(R_X86_64_PC32 | (uint64)elfsym<<32);
+		} else
+			return -1;
+		break;
+
 	case R_TLS:
 		if(r->siz == 4) {
 			if(flag_shared)
@@ -323,7 +329,7 @@ machoreloc1(Reloc *r, vlong sectoff)
 	
 	rs = r->xsym;
 
-	if(rs->type == SHOSTOBJ) {
+	if(rs->type == SHOSTOBJ || r->type == R_PCREL) {
 		if(rs->dynid < 0) {
 			diag("reloc %d to non-macho symbol %s type=%d", r->type, rs->name, rs->type);
 			return -1;
@@ -345,10 +351,13 @@ machoreloc1(Reloc *r, vlong sectoff)
 		v |= MACHO_X86_64_RELOC_UNSIGNED<<28;
 		break;
 	case R_CALL:
-	case R_PCREL:
 		v |= 1<<24; // pc-relative bit
 		v |= MACHO_X86_64_RELOC_BRANCH<<28;
 		break;
+	case R_PCREL:
+		// NOTE: Only works with 'external' relocation. Forced above.
+		v |= 1<<24; // pc-relative bit
+		v |= MACHO_X86_64_RELOC_SIGNED<<28;
 	}
 	
 	switch(r->siz) {
diff --git a/src/cmd/ld/data.c b/src/cmd/ld/data.c
index f76ac0129c..a988e807e6 100644
--- a/src/cmd/ld/data.c
+++ b/src/cmd/ld/data.c
@@ -281,9 +281,13 @@ relocsym(LSym *s)
 					if(thechar == '6')
 						o = 0;
 				} else if(HEADTYPE == Hdarwin) {
-					if(rs->type != SHOSTOBJ)
-						o += symaddr(rs) - rs->sect->vaddr;
-					o -= r->off; // WTF?
+					if(r->type == R_CALL) {
+						if(rs->type != SHOSTOBJ)
+							o += symaddr(rs) - rs->sect->vaddr;
+						o -= r->off; // relative to section offset, not symbol
+					} else {
+						o += r->siz;
+					}
 				} else {
 					diag("unhandled pcrel relocation for %s", headstring);
 				}
diff --git a/src/liblink/asm6.c b/src/liblink/asm6.c
index fa329777d0..e25c85053a 100644
--- a/src/liblink/asm6.c
+++ b/src/liblink/asm6.c
@@ -1932,10 +1932,7 @@ oclass(Link *ctxt, Addr *a)
 				switch(a->index) {
 				case D_EXTERN:
 				case D_STATIC:
-					if(ctxt->flag_shared || ctxt->headtype == Hnacl)
-						return Yiauto;
-					else
-						return Yi32;	/* TO DO: Yi64 */
+					return Yiauto; // use pc-relative addressing
 				case D_AUTO:
 				case D_PARAM:
 					return Yiauto;
@@ -2290,15 +2287,12 @@ vaddr(Link *ctxt, Addr *a, Reloc *r)
 		r->sym = s;
 		r->add = v;
 		v = 0;
-		if(ctxt->flag_shared || ctxt->headtype == Hnacl) {
-			if(s->type == STLSBSS) {
-				r->xadd = r->add - r->siz;
-				r->type = R_TLS;
-				r->xsym = s;
-			} else
-				r->type = R_PCREL;
-		} else
-			r->type = R_ADDR;
+		r->type = R_PCREL;
+		if(s->type == STLSBSS) {
+			r->xadd = r->add - r->siz;
+			r->type = R_TLS;
+			r->xsym = s;
+		}
 		break;
 	
 	case D_INDIR+D_TLS:
@@ -2333,13 +2327,6 @@ asmandsz(Link *ctxt, Addr *a, int r, int rex, int m64)
 			switch(t) {
 			default:
 				goto bad;
-			case D_STATIC:
-			case D_EXTERN:
-				if(ctxt->flag_shared || ctxt->headtype == Hnacl)
-					goto bad;
-				t = D_NONE;
-				v = vaddr(ctxt, a, &rel);
-				break;
 			case D_AUTO:
 			case D_PARAM:
 				t = D_SP;
@@ -2399,7 +2386,7 @@ asmandsz(Link *ctxt, Addr *a, int r, int rex, int m64)
 
 	ctxt->rexflag |= (regrex[t] & Rxb) | rex;
 	if(t == D_NONE || (D_CS <= t && t <= D_GS) || t == D_TLS) {
-		if((ctxt->flag_shared || ctxt->headtype == Hnacl) && t == D_NONE && (a->type == D_STATIC || a->type == D_EXTERN) || ctxt->asmode != 64) {
+		if(t == D_NONE && (a->type == D_STATIC || a->type == D_EXTERN) || ctxt->asmode != 64) {
 			*ctxt->andptr++ = (0 << 6) | (5 << 0) | (r << 3);
 			goto putrelv;
 		}

From 2e2beb567cb2a59a8b54d8f2cd3fbd8eb1116013 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 18 Aug 2014 21:07:11 -0400
Subject: [PATCH 114/423] doc/go1.4: mention pc-relative addressing on amd64

CC=golang-codereviews
https://golang.org/cl/124580043
---
 doc/go1.4.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index 60e4bd9e68..b3ba7480d6 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -7,6 +7,7 @@ Please keep the list sorted (as in sort.Strings of the lines).
 
 spec: permit for range x (CL 104680043)
 
+cmd/6l, liblink: use pc-relative addressing for all memory references, so that linking Go binaries at high addresses works (CL 125140043). This cuts the maximum size of a Go binary's text+data+bss from 4GB to 2GB.
 cmd/go: import comments (CL 124940043)
 cmd/go: implement "internal" (CL 120600043)
 

From 1806a5732b373e5a9048765db533bcb33952a067 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 18 Aug 2014 21:13:11 -0400
Subject: [PATCH 115/423] cmd/gc, runtime: refactor interface inlining decision
 into compiler

We need to change the interface value representation for
concurrent garbage collection, so that there is no ambiguity
about whether the data word holds a pointer or scalar.

This CL does NOT make any representation changes.

Instead, it removes representation assumptions from
various pieces of code throughout the tree.
The isdirectiface function in cmd/gc/subr.c is now
the only place that decides that policy.
The policy propagates out from there in the reflect
metadata, as a new flag in the internal kind value.

A follow-up CL will change the representation by
changing the isdirectiface function. If that CL causes
problems, it will be easy to roll back.

Update #8405.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews, r
https://golang.org/cl/129090043
---
 src/cmd/gc/go.h                      |  1 +
 src/cmd/gc/reflect.c                 |  4 +-
 src/cmd/gc/subr.c                    | 39 +++++++++++++++
 src/cmd/gc/walk.c                    |  7 +--
 src/pkg/database/sql/convert_test.go | 37 +++++++++-----
 src/pkg/reflect/all_test.go          |  3 ++
 src/pkg/reflect/type.go              | 21 +++++---
 src/pkg/reflect/value.go             | 74 ++++++++++++++++++----------
 src/pkg/runtime/alg.go               |  8 +--
 src/pkg/runtime/heapdump.c           |  4 +-
 src/pkg/runtime/iface.go             | 12 ++---
 src/pkg/runtime/malloc.c             |  8 +--
 src/pkg/runtime/malloc.go            |  9 ----
 src/pkg/runtime/mgc0.c               |  6 +--
 src/pkg/runtime/stack.c              |  4 +-
 src/pkg/runtime/typekind.go          | 44 +++++++++++++++++
 src/pkg/runtime/typekind.h           |  3 +-
 test/live.go                         | 51 ++++++++++---------
 18 files changed, 230 insertions(+), 105 deletions(-)
 create mode 100644 src/pkg/runtime/typekind.go

diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h
index c3da5f636a..6affd08dc1 100644
--- a/src/cmd/gc/go.h
+++ b/src/cmd/gc/go.h
@@ -1363,6 +1363,7 @@ int	is64(Type *t);
 int	isbadimport(Strlit *s);
 int	isblank(Node *n);
 int	isblanksym(Sym *s);
+int	isdirectiface(Type*);
 int	isfixedarray(Type *t);
 int	isideal(Type *t);
 int	isinter(Type *t);
diff --git a/src/cmd/gc/reflect.c b/src/cmd/gc/reflect.c
index 6b3cd66bb6..66efac07d0 100644
--- a/src/cmd/gc/reflect.c
+++ b/src/cmd/gc/reflect.c
@@ -378,7 +378,7 @@ methods(Type *t)
 
 	// type stored in interface word
 	it = t;
-	if(it->width > widthptr)
+	if(!isdirectiface(it))
 		it = ptrto(t);
 
 	// make list of methods for t,
@@ -785,6 +785,8 @@ dcommontype(Sym *s, int ot, Type *t)
 		i = KindSlice;
 	if(!haspointers(t))
 		i |= KindNoPointers;
+	if(isdirectiface(t))
+		i |= KindDirectIface;
 	if(gcprog)
 		i |= KindGCProg;
 	ot = duint8(s, ot, i);  // kind
diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index cd6c609567..325614e6bc 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -3794,3 +3794,42 @@ checknil(Node *x, NodeList **init)
 	n->typecheck = 1;
 	*init = list(*init, n);
 }
+
+/*
+ * Can this type be stored directly in an interface word?
+ */
+int
+isdirectiface(Type *t)
+{
+	// Setting IfacePointerOnly = 1 changes the
+	// interface representation so that the data word
+	// in an interface value must always be a pointer.
+	// Setting it to 0 uses the original representation,
+	// where the data word can hold a pointer or any
+	// non-pointer value no bigger than a pointer.
+	enum {
+		IfacePointerOnly = 0,
+	};
+
+	if(IfacePointerOnly) {
+		switch(t->etype) {
+		case TPTR32:
+		case TPTR64:
+		case TCHAN:
+		case TMAP:
+		case TFUNC:
+		case TUNSAFEPTR:
+			return 1;
+		case TARRAY:
+			// Array of 1 direct iface type can be direct.
+			return t->bound == 1 && isdirectiface(t->type);
+		case TSTRUCT:
+			// Struct with 1 field of direct iface type can be direct.
+			return t->type != T && t->type->down == T && isdirectiface(t->type->type);
+		}
+		return 0;
+	}
+	
+	dowidth(t);
+	return t->width <= widthptr;
+}
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index 7ae75e5617..f3886cf73a 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -834,9 +834,7 @@ walkexpr(Node **np, NodeList **init)
 		walkexpr(&n->left, init);
 
 		// Optimize convT2E as a two-word copy when T is uintptr-shaped.
-		if(!isinter(n->left->type) && isnilinter(n->type) &&
-		   (n->left->type->width == widthptr) &&
-		   isint[simsimtype(n->left->type)]) {
+		if(isnilinter(n->type) && isdirectiface(n->left->type) && n->left->type->width == widthptr && isint[simsimtype(n->left->type)]) {
 			l = nod(OEFACE, typename(n->left->type), n->left);
 			l->type = n->type;
 			l->typecheck = n->typecheck;
@@ -884,8 +882,7 @@ walkexpr(Node **np, NodeList **init)
 			l->addable = 1;
 			ll = list(ll, l);
 
-			if(n->left->type->width == widthptr &&
-		   	   isint[simsimtype(n->left->type)]) {
+			if(isdirectiface(n->left->type) && n->left->type->width == widthptr && isint[simsimtype(n->left->type)]) {
 				/* For pointer types, we can make a special form of optimization
 				 *
 				 * These statements are put onto the expression init list:
diff --git a/src/pkg/database/sql/convert_test.go b/src/pkg/database/sql/convert_test.go
index 6e24830128..98af9fb64c 100644
--- a/src/pkg/database/sql/convert_test.go
+++ b/src/pkg/database/sql/convert_test.go
@@ -283,6 +283,26 @@ func TestValueConverters(t *testing.T) {
 
 // Tests that assigning to RawBytes doesn't allocate (and also works).
 func TestRawBytesAllocs(t *testing.T) {
+	var tests = []struct {
+		name string
+		in   interface{}
+		want string
+	}{
+		{"uint64", uint64(12345678), "12345678"},
+		{"uint32", uint32(1234), "1234"},
+		{"uint16", uint16(12), "12"},
+		{"uint8", uint8(1), "1"},
+		{"uint", uint(123), "123"},
+		{"int", int(123), "123"},
+		{"int8", int8(1), "1"},
+		{"int16", int16(12), "12"},
+		{"int32", int32(1234), "1234"},
+		{"int64", int64(12345678), "12345678"},
+		{"float32", float32(1.5), "1.5"},
+		{"float64", float64(64), "64"},
+		{"bool", false, "false"},
+	}
+
 	buf := make(RawBytes, 10)
 	test := func(name string, in interface{}, want string) {
 		if err := convertAssign(&buf, in); err != nil {
@@ -301,20 +321,11 @@ func TestRawBytesAllocs(t *testing.T) {
 			t.Fatalf("%s: got %q (len %d); want %q (len %d)", name, buf, len(buf), want, len(want))
 		}
 	}
+
 	n := testing.AllocsPerRun(100, func() {
-		test("uint64", uint64(12345678), "12345678")
-		test("uint32", uint32(1234), "1234")
-		test("uint16", uint16(12), "12")
-		test("uint8", uint8(1), "1")
-		test("uint", uint(123), "123")
-		test("int", int(123), "123")
-		test("int8", int8(1), "1")
-		test("int16", int16(12), "12")
-		test("int32", int32(1234), "1234")
-		test("int64", int64(12345678), "12345678")
-		test("float32", float32(1.5), "1.5")
-		test("float64", float64(64), "64")
-		test("bool", false, "false")
+		for _, tt := range tests {
+			test(tt.name, tt.in, tt.want)
+		}
 	})
 
 	// The numbers below are only valid for 64-bit interface word sizes,
diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
index f122711731..d9781699e0 100644
--- a/src/pkg/reflect/all_test.go
+++ b/src/pkg/reflect/all_test.go
@@ -3213,6 +3213,9 @@ func checkSameType(t *testing.T, x, y interface{}) {
 }
 
 func TestArrayOf(t *testing.T) {
+	// TODO(rsc): Finish ArrayOf and enable-test.
+	t.Skip("ArrayOf is not finished (and not exported)")
+
 	// check construction and use of type not in binary
 	type T int
 	at := ArrayOf(10, TypeOf(T(1)))
diff --git a/src/pkg/reflect/type.go b/src/pkg/reflect/type.go
index d7d4974597..47aecd0023 100644
--- a/src/pkg/reflect/type.go
+++ b/src/pkg/reflect/type.go
@@ -383,12 +383,11 @@ type Method struct {
 	Index int   // index for Type.Method
 }
 
-// High bit says whether type has
-// embedded pointers,to help garbage collector.
 const (
-	kindMask       = 0x3f
-	kindGCProg     = 0x40
-	kindNoPointers = 0x80
+	kindDirectIface = 1 << 5
+	kindGCProg      = 1 << 6 // Type.gc points to GC program
+	kindNoPointers  = 1 << 7
+	kindMask        = (1 << 5) - 1
 )
 
 func (k Kind) String() string {
@@ -1503,6 +1502,7 @@ func (gc *gcProg) appendProg(t *rtype) {
 	var prog []byte
 	if t.kind&kindGCProg != 0 {
 		// Ensure that the runtime has unrolled GC program.
+		// TODO(rsc): Do not allocate.
 		unsafe_New(t)
 		// The program is stored in t.gc[0], skip unroll flag.
 		prog = (*[1 << 30]byte)(unsafe.Pointer(t.gc[0]))[1:]
@@ -1652,6 +1652,8 @@ func SliceOf(t Type) Type {
 //
 // TODO(rsc): Unexported for now. Export once the alg field is set correctly
 // for the type. This may require significant work.
+//
+// TODO(rsc): TestArrayOf is also disabled. Re-enable.
 func arrayOf(count int, elem Type) Type {
 	typ := elem.(*rtype)
 	slice := SliceOf(elem)
@@ -1676,6 +1678,7 @@ func arrayOf(count int, elem Type) Type {
 	prototype := *(**arrayType)(unsafe.Pointer(&iarray))
 	array := new(arrayType)
 	*array = *prototype
+	// TODO: Set extra kind bits correctly.
 	array.string = &s
 	array.hash = fnv1(typ.hash, '[')
 	for n := uint32(count); n > 0; n >>= 8 {
@@ -1692,6 +1695,7 @@ func arrayOf(count int, elem Type) Type {
 	array.fieldAlign = typ.fieldAlign
 	// TODO: array.alg
 	// TODO: array.gc
+	// TODO:
 	array.uncommonType = nil
 	array.ptrToThis = nil
 	array.zero = unsafe.Pointer(&make([]byte, array.size)[0])
@@ -1763,7 +1767,7 @@ func funcLayout(t *rtype, rcvr *rtype) (frametype *rtype, argSize, retOffset uin
 		// Reflect uses the "interface" calling convention for
 		// methods, where receivers take one word of argument
 		// space no matter how big they actually are.
-		if rcvr.size > ptrSize {
+		if !isDirectIface(rcvr) {
 			// we pass a pointer to the receiver.
 			gc.append(bitsPointer)
 		} else if rcvr.pointers() {
@@ -1813,3 +1817,8 @@ func funcLayout(t *rtype, rcvr *rtype) (frametype *rtype, argSize, retOffset uin
 	layoutCache.Unlock()
 	return x, argSize, retOffset
 }
+
+// isDirectIface reports whether t is stored directly in an interface value.
+func isDirectIface(t *rtype) bool {
+	return t.kind&kindDirectIface != 0
+}
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index 576cbc3984..dda852a3ec 100644
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -82,7 +82,7 @@ type Value struct {
 	// This repeats typ.Kind() except for method values.
 	// The remaining 23+ bits give a method number for method values.
 	// If flag.kind() != Func, code can assume that flagMethod is unset.
-	// If typ.size > ptrSize, code can assume that flagIndir is set.
+	// If !isDirectIface(typ), code can assume that flagIndir is set.
 	flag
 
 	// A method value represents a curried method invocation
@@ -128,7 +128,10 @@ func packEface(v Value) interface{} {
 	e := (*emptyInterface)(unsafe.Pointer(&i))
 	// First, fill in the data portion of the interface.
 	switch {
-	case t.size > ptrSize:
+	case !isDirectIface(t):
+		if v.flag&flagIndir == 0 {
+			panic("bad indir")
+		}
 		// Value is indirect, and so is the interface we're making.
 		ptr := v.ptr
 		if v.flag&flagAddr != 0 {
@@ -172,7 +175,7 @@ func unpackEface(i interface{}) Value {
 		return Value{}
 	}
 	f := flag(t.Kind()) << flagKindShift
-	if t.size > ptrSize {
+	if !isDirectIface(t) {
 		return Value{t, unsafe.Pointer(e.word), 0, f | flagIndir}
 	}
 	if t.pointers() {
@@ -607,8 +610,8 @@ func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer) {
 		off += -off & uintptr(typ.align-1)
 		addr := unsafe.Pointer(uintptr(ptr) + off)
 		v := Value{typ, nil, 0, flag(typ.Kind()) << flagKindShift}
-		if typ.size > ptrSize {
-			// value does not fit in word.
+		if !isDirectIface(typ) {
+			// value cannot be inlined in interface data.
 			// Must make a copy, because f might keep a reference to it,
 			// and we cannot let f keep a reference to the stack frame
 			// after this function returns, not even a read-only reference.
@@ -714,7 +717,7 @@ func storeRcvr(v Value, p unsafe.Pointer) {
 		iface := (*nonEmptyInterface)(v.ptr)
 		*(*unsafe.Pointer)(p) = unsafe.Pointer(iface.word)
 	} else if v.flag&flagIndir != 0 {
-		if t.size > ptrSize {
+		if !isDirectIface(t) {
 			*(*unsafe.Pointer)(p) = v.ptr
 		} else if t.pointers() {
 			*(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr)
@@ -987,7 +990,13 @@ func (v Value) Index(i int) Value {
 			val = unsafe.Pointer(uintptr(v.ptr) + offset)
 		case typ.pointers():
 			if offset != 0 {
-				panic("can't Index(i) with i!=0 on ptrLike value")
+				// This is an array stored inline in an interface value.
+				// And the array element type has pointers.
+				// Since the inline storage space is only a single word,
+				// this implies we must be holding an array of length 1
+				// with an element type that is a single pointer.
+				// If the offset is not 0, something has gone wrong.
+				panic("reflect: internal error: unexpected array index")
 			}
 			val = v.ptr
 		case bigEndian:
@@ -1014,14 +1023,13 @@ func (v Value) Index(i int) Value {
 		return Value{typ, val, 0, fl}
 
 	case String:
-		fl := v.flag&flagRO | flag(Uint8<<flagKindShift)
+		fl := v.flag&flagRO | flag(Uint8<<flagKindShift) | flagIndir
 		s := (*stringHeader)(v.ptr)
 		if i < 0 || i >= s.Len {
 			panic("reflect: string index out of range")
 		}
-		b := uintptr(0)
-		*(*byte)(unsafe.Pointer(&b)) = *(*byte)(unsafe.Pointer(uintptr(s.Data) + uintptr(i)))
-		return Value{uint8Type, nil, b, fl}
+		p := unsafe.Pointer(uintptr(s.Data) + uintptr(i))
+		return Value{uint8Type, p, 0, fl}
 	}
 	panic(&ValueError{"reflect.Value.Index", k})
 }
@@ -1209,7 +1217,7 @@ func (v Value) MapIndex(key Value) Value {
 	typ := tt.elem
 	fl := (v.flag | key.flag) & flagRO
 	fl |= flag(typ.Kind()) << flagKindShift
-	if typ.size > ptrSize {
+	if !isDirectIface(typ) {
 		// Copy result so future changes to the map
 		// won't change the underlying value.
 		c := unsafe_New(typ)
@@ -1249,7 +1257,7 @@ func (v Value) MapKeys() []Value {
 			// we can do about it.
 			break
 		}
-		if keyType.size > ptrSize {
+		if !isDirectIface(keyType) {
 			// Copy result so future changes to the map
 			// won't change the underlying value.
 			c := unsafe_New(keyType)
@@ -1448,7 +1456,7 @@ func (v Value) recv(nb bool) (val Value, ok bool) {
 	t := tt.elem
 	val = Value{t, nil, 0, flag(t.Kind()) << flagKindShift}
 	var p unsafe.Pointer
-	if t.size > ptrSize {
+	if !isDirectIface(t) {
 		p = unsafe_New(t)
 		val.ptr = p
 		val.flag |= flagIndir
@@ -2190,7 +2198,7 @@ func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
 		t := tt.elem
 		p := runcases[chosen].val
 		fl := flag(t.Kind()) << flagKindShift
-		if t.size > ptrSize {
+		if !isDirectIface(t) {
 			recv = Value{t, p, 0, fl | flagIndir}
 		} else if t.pointers() {
 			recv = Value{t, *(*unsafe.Pointer)(p), 0, fl}
@@ -2291,7 +2299,7 @@ func Zero(typ Type) Value {
 	}
 	t := typ.common()
 	fl := flag(t.Kind()) << flagKindShift
-	if t.size <= ptrSize {
+	if isDirectIface(t) {
 		return Value{t, nil, 0, fl}
 	}
 	return Value{t, unsafe_New(typ.(*rtype)), 0, fl | flagIndir}
@@ -2450,10 +2458,18 @@ func convertOp(dst, src *rtype) func(Value, Type) Value {
 // where t is a signed or unsigned int type.
 func makeInt(f flag, bits uint64, t Type) Value {
 	typ := t.common()
-	if typ.size > ptrSize {
-		// Assume ptrSize >= 4, so this must be uint64.
+	if !isDirectIface(typ) {
 		ptr := unsafe_New(typ)
-		*(*uint64)(unsafe.Pointer(ptr)) = bits
+		switch typ.size {
+		case 1:
+			*(*uint8)(unsafe.Pointer(ptr)) = uint8(bits)
+		case 2:
+			*(*uint16)(unsafe.Pointer(ptr)) = uint16(bits)
+		case 4:
+			*(*uint32)(unsafe.Pointer(ptr)) = uint32(bits)
+		case 8:
+			*(*uint64)(unsafe.Pointer(ptr)) = bits
+		}
 		return Value{typ, ptr, 0, f | flagIndir | flag(typ.Kind())<<flagKindShift}
 	}
 	var s uintptr
@@ -2474,10 +2490,14 @@ func makeInt(f flag, bits uint64, t Type) Value {
 // where t is a float32 or float64 type.
 func makeFloat(f flag, v float64, t Type) Value {
 	typ := t.common()
-	if typ.size > ptrSize {
-		// Assume ptrSize >= 4, so this must be float64.
+	if !isDirectIface(typ) {
 		ptr := unsafe_New(typ)
-		*(*float64)(unsafe.Pointer(ptr)) = v
+		switch typ.size {
+		case 4:
+			*(*float32)(unsafe.Pointer(ptr)) = float32(v)
+		case 8:
+			*(*float64)(unsafe.Pointer(ptr)) = v
+		}
 		return Value{typ, ptr, 0, f | flagIndir | flag(typ.Kind())<<flagKindShift}
 	}
 
@@ -2495,7 +2515,7 @@ func makeFloat(f flag, v float64, t Type) Value {
 // where t is a complex64 or complex128 type.
 func makeComplex(f flag, v complex128, t Type) Value {
 	typ := t.common()
-	if typ.size > ptrSize {
+	if !isDirectIface(typ) {
 		ptr := unsafe_New(typ)
 		switch typ.size {
 		case 8:
@@ -2506,9 +2526,13 @@ func makeComplex(f flag, v complex128, t Type) Value {
 		return Value{typ, ptr, 0, f | flagIndir | flag(typ.Kind())<<flagKindShift}
 	}
 
-	// Assume ptrSize <= 8 so this must be complex64.
 	var s uintptr
-	*(*complex64)(unsafe.Pointer(&s)) = complex64(v)
+	switch typ.size {
+	case 8:
+		*(*complex64)(unsafe.Pointer(&s)) = complex64(v)
+	case 16:
+		*(*complex128)(unsafe.Pointer(&s)) = v
+	}
 	return Value{typ, nil, s, f | flag(typ.Kind())<<flagKindShift}
 }
 
diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index 409f0fa0c5..650f684950 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -117,7 +117,7 @@ func interhash(a *iface, s, h uintptr) uintptr {
 		// but we can print a better error.
 		panic(errorString("hash of unhashable type " + *t._string))
 	}
-	if uintptr(t.size) <= ptrSize {
+	if isDirectIface(t) {
 		return c1 * fn(unsafe.Pointer(&a.data), uintptr(t.size), h^c0)
 	} else {
 		return c1 * fn(a.data, uintptr(t.size), h^c0)
@@ -135,7 +135,7 @@ func nilinterhash(a *eface, s, h uintptr) uintptr {
 		// but we can print a better error.
 		panic(errorString("hash of unhashable type " + *t._string))
 	}
-	if uintptr(t.size) <= ptrSize {
+	if isDirectIface(t) {
 		return c1 * fn(unsafe.Pointer(&a.data), uintptr(t.size), h^c0)
 	} else {
 		return c1 * fn(a.data, uintptr(t.size), h^c0)
@@ -208,7 +208,7 @@ func efaceeq(p, q interface{}) bool {
 		// but we can print a better error.
 		panic(errorString("comparing uncomparable type " + *t._string))
 	}
-	if uintptr(t.size) <= ptrSize {
+	if isDirectIface(t) {
 		return eq(noescape(unsafe.Pointer(&x.data)), noescape(unsafe.Pointer(&y.data)), uintptr(t.size))
 	}
 	return eq(x.data, y.data, uintptr(t.size))
@@ -232,7 +232,7 @@ func ifaceeq(p, q interface {
 		// but we can print a better error.
 		panic(errorString("comparing uncomparable type " + *t._string))
 	}
-	if uintptr(t.size) <= ptrSize {
+	if isDirectIface(t) {
 		return eq(noescape(unsafe.Pointer(&x.data)), noescape(unsafe.Pointer(&y.data)), uintptr(t.size))
 	}
 	return eq(x.data, y.data, uintptr(t.size))
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index aa817fceec..babb32fe5a 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -196,7 +196,7 @@ dumptype(Type *t)
 		write((byte*)".", 1);
 		write(t->x->name->str, t->x->name->len);
 	}
-	dumpbool(t->size > PtrSize || (t->kind & KindNoPointers) == 0);
+	dumpbool((t->kind & KindDirectIface) == 0 || (t->kind & KindNoPointers) == 0);
 	dumpfields((BitVector){0, nil});
 }
 
@@ -584,7 +584,7 @@ itab_callback(Itab *tab)
 	dumpint(TagItab);
 	dumpint((uintptr)tab);
 	t = tab->type;
-	dumpbool(t->size > PtrSize || (t->kind & KindNoPointers) == 0);
+	dumpbool((t->kind & KindDirectIface) == 0 || (t->kind & KindNoPointers) == 0);
 }
 
 static void
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index 9bd6fc7617..60dfb49dbe 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -135,7 +135,7 @@ func typ2Itab(t *_type, inter *interfacetype, cache **itab) *itab {
 func convT2E(t *_type, elem unsafe.Pointer) (e interface{}) {
 	size := uintptr(t.size)
 	ep := (*eface)(unsafe.Pointer(&e))
-	if size <= ptrSize {
+	if isDirectIface(t) {
 		ep._type = t
 		memmove(unsafe.Pointer(&ep.data), elem, size)
 	} else {
@@ -157,7 +157,7 @@ func convT2I(t *_type, inter *interfacetype, cache **itab, elem unsafe.Pointer)
 	}
 	size := uintptr(t.size)
 	pi := (*iface)(unsafe.Pointer(&i))
-	if size <= ptrSize {
+	if isDirectIface(t) {
 		pi.tab = tab
 		memmove(unsafe.Pointer(&pi.data), elem, size)
 	} else {
@@ -182,7 +182,7 @@ func assertI2T(t *_type, i fInterface) (r struct{}) {
 		panic(&TypeAssertionError{*tab.inter.typ._string, *tab._type._string, *t._string, ""})
 	}
 	size := uintptr(t.size)
-	if size <= ptrSize {
+	if isDirectIface(t) {
 		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ip.data), size)
 	} else {
 		memmove(unsafe.Pointer(&r), ip.data, size)
@@ -202,7 +202,7 @@ func assertI2T2(t *_type, i fInterface) (r byte) {
 		return
 	}
 	*ok = true
-	if size <= ptrSize {
+	if isDirectIface(t) {
 		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ip.data), size)
 	} else {
 		memmove(unsafe.Pointer(&r), ip.data, size)
@@ -226,7 +226,7 @@ func assertE2T(t *_type, e interface{}) (r struct{}) {
 		panic(&TypeAssertionError{"", *ep._type._string, *t._string, ""})
 	}
 	size := uintptr(t.size)
-	if size <= ptrSize {
+	if isDirectIface(t) {
 		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ep.data), size)
 	} else {
 		memmove(unsafe.Pointer(&r), ep.data, size)
@@ -245,7 +245,7 @@ func assertE2T2(t *_type, e interface{}) (r byte) {
 		return
 	}
 	*ok = true
-	if size <= ptrSize {
+	if isDirectIface(t) {
 		memmove(unsafe.Pointer(&r), unsafe.Pointer(&ep.data), size)
 	} else {
 		memmove(unsafe.Pointer(&r), ep.data, size)
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 8b9447dad6..f4143669e7 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -459,7 +459,7 @@ setFinalizer(Eface obj, Eface finalizer)
 	}
 	if(finalizer.type != nil) {
 		runtime·createfing();
-		if(finalizer.type->kind != KindFunc)
+		if((finalizer.type->kind&KindMask) != KindFunc)
 			goto badfunc;
 		ft = (FuncType*)finalizer.type;
 		if(ft->dotdotdot || ft->in.len != 1)
@@ -467,12 +467,12 @@ setFinalizer(Eface obj, Eface finalizer)
 		fint = *(Type**)ft->in.array;
 		if(fint == obj.type) {
 			// ok - same type
-		} else if(fint->kind == KindPtr && (fint->x == nil || fint->x->name == nil || obj.type->x == nil || obj.type->x->name == nil) && ((PtrType*)fint)->elem == ((PtrType*)obj.type)->elem) {
+		} else if((fint->kind&KindMask) == KindPtr && (fint->x == nil || fint->x->name == nil || obj.type->x == nil || obj.type->x->name == nil) && ((PtrType*)fint)->elem == ((PtrType*)obj.type)->elem) {
 			// ok - not same type, but both pointers,
 			// one or the other is unnamed, and same element type, so assignable.
-		} else if(fint->kind == KindInterface && ((InterfaceType*)fint)->mhdr.len == 0) {
+		} else if((fint->kind&KindMask) == KindInterface && ((InterfaceType*)fint)->mhdr.len == 0) {
 			// ok - satisfies empty interface
-		} else if(fint->kind == KindInterface && runtime·ifaceE2I2((InterfaceType*)fint, obj, &iface)) {
+		} else if((fint->kind&KindMask) == KindInterface && runtime·ifaceE2I2((InterfaceType*)fint, obj, &iface)) {
 			// ok - satisfies non-empty interface
 		} else
 			goto badfunc;
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index f116efaba4..ce7e062109 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -14,15 +14,6 @@ const (
 	flagNoScan = 1 << 0 // GC doesn't have to scan object
 	flagNoZero = 1 << 1 // don't zero memory
 
-	kindArray      = 17
-	kindFunc       = 19
-	kindInterface  = 20
-	kindPtr        = 22
-	kindStruct     = 25
-	kindMask       = 1<<6 - 1
-	kindGCProg     = 1 << 6
-	kindNoPointers = 1 << 7
-
 	maxTinySize   = 16
 	tinySizeClass = 2
 	maxSmallSize  = 32 << 10
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index ef44d7f786..3583d77d19 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -367,7 +367,7 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				iface = (Iface*)(b+i);
 				if(iface->tab != nil) {
 					typ = iface->tab->type;
-					if(typ->size > PtrSize || !(typ->kind&KindNoPointers))
+					if(!(typ->kind&KindDirectIface) || !(typ->kind&KindNoPointers))
 						obj = iface->data;
 				}
 				break;
@@ -375,7 +375,7 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				eface = (Eface*)(b+i);
 				typ = eface->type;
 				if(typ != nil) {
-					if(typ->size > PtrSize || !(typ->kind&KindNoPointers))
+					if(!(typ->kind&KindDirectIface) || !(typ->kind&KindNoPointers))
 						obj = eface->data;
 				}
 				break;
@@ -1675,7 +1675,7 @@ runfinq(void)
 				}
 				if(f->fint == nil)
 					runtime·throw("missing type in runfinq");
-				if(f->fint->kind == KindPtr) {
+				if((f->fint->kind&KindMask) == KindPtr) {
 					// direct use of pointer
 					*(void**)frame = f->arg;
 				} else if(((InterfaceType*)f->fint)->mhdr.len == 0) {
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 772080af55..b4e992e658 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -585,7 +585,7 @@ adjustpointers(byte **scanp, BitVector *bv, AdjustInfo *adjinfo, Func *f)
 				break;
 			case BitsEface:
 				t = (Type*)scanp[i];
-				if(t != nil && (t->size > PtrSize || (t->kind & KindNoPointers) == 0)) {
+				if(t != nil && ((t->kind & KindDirectIface) == 0 || (t->kind & KindNoPointers) == 0)) {
 					p = scanp[i+1];
 					if(minp <= p && p < maxp) {
 						if(StackDebug >= 3)
@@ -602,7 +602,7 @@ adjustpointers(byte **scanp, BitVector *bv, AdjustInfo *adjinfo, Func *f)
 				if(tab != nil) {
 					t = tab->type;
 					//runtime·printf("          type=%p\n", t);
-					if(t->size > PtrSize || (t->kind & KindNoPointers) == 0) {
+					if((t->kind & KindDirectIface) == 0 || (t->kind & KindNoPointers) == 0) {
 						p = scanp[i+1];
 						if(minp <= p && p < maxp) {
 							if(StackDebug >= 3)
diff --git a/src/pkg/runtime/typekind.go b/src/pkg/runtime/typekind.go
new file mode 100644
index 0000000000..5985536289
--- /dev/null
+++ b/src/pkg/runtime/typekind.go
@@ -0,0 +1,44 @@
+// 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 runtime
+
+const (
+	kindBool = 1 + iota
+	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 = 1 << 5
+	kindGCProg      = 1 << 6 // Type.gc points to GC program
+	kindNoPointers  = 1 << 7
+	kindMask        = (1 << 5) - 1
+)
+
+// isDirectIface reports whether t is stored directly in an interface value.
+func isDirectIface(t *_type) bool {
+	return t.kind&kindDirectIface != 0
+}
diff --git a/src/pkg/runtime/typekind.h b/src/pkg/runtime/typekind.h
index bf6ade08d6..7c611e8ba6 100644
--- a/src/pkg/runtime/typekind.h
+++ b/src/pkg/runtime/typekind.h
@@ -33,8 +33,9 @@ enum {
 	KindStruct,
 	KindUnsafePointer,
 
+	KindDirectIface = 1<<5,
 	KindGCProg = 1<<6,	// Type.gc points to GC program
 	KindNoPointers = 1<<7,
-	KindMask = (1<<6)-1,
+	KindMask = (1<<5)-1,
 };
 
diff --git a/test/live.go b/test/live.go
index 6ac1d6a464..1c01f8dc49 100644
--- a/test/live.go
+++ b/test/live.go
@@ -118,7 +118,10 @@ var i9 interface{}
 func f9() bool {
 	g8()
 	x := i9
-	return x != 99
+	// using complex number in comparison so that
+	// there is always a convT2E, no matter what the
+	// interface rules are.
+	return x != 99.0i // ERROR "live at call to convT2E: x"
 }
 
 // liveness formerly confused by UNDEF followed by RET,
@@ -184,7 +187,7 @@ func f11c() *int {
 
 func f12() *int {
 	if b {
-		select{}
+		select {}
 	} else {
 		return nil
 	}
@@ -215,7 +218,7 @@ func f15() {
 	var x string
 	_ = &x
 	x = g15() // ERROR "live at call to g15: x"
-	print(x) // ERROR "live at call to printstring: x"
+	print(x)  // ERROR "live at call to printstring: x"
 }
 
 func g15() string
@@ -287,7 +290,7 @@ var ch chan *byte
 func f19() {
 	// dest temporary for channel receive.
 	var z *byte
-	
+
 	if b {
 		z = <-ch // ERROR "live at call to chanrecv1: autotmp_[0-9]+$"
 	}
@@ -348,21 +351,21 @@ func f25(b bool) {
 	var x string
 	_ = &x
 	x = g15() // ERROR "live at call to g15: x"
-	print(x) // ERROR "live at call to printstring: x"
+	print(x)  // ERROR "live at call to printstring: x"
 } // ERROR "live at call to deferreturn: x"
 
 func g25()
-	
+
 // non-escaping ... slices passed to function call should die on return,
 // so that the temporaries do not stack and do not cause ambiguously
 // live variables.
 
 func f26(b bool) {
 	if b {
-		print26(1,2,3) // ERROR "live at call to print26: autotmp_[0-9]+$"
+		print26((*int)(nil), (*int)(nil), (*int)(nil)) // ERROR "live at call to print26: autotmp_[0-9]+$"
 	}
-	print26(4,5,6) // ERROR "live at call to print26: autotmp_[0-9]+$"
-	print26(7,8,9) // ERROR "live at call to print26: autotmp_[0-9]+$"
+	print26((*int)(nil), (*int)(nil), (*int)(nil)) // ERROR "live at call to print26: autotmp_[0-9]+$"
+	print26((*int)(nil), (*int)(nil), (*int)(nil)) // ERROR "live at call to print26: autotmp_[0-9]+$"
 	println()
 }
 
@@ -374,10 +377,10 @@ func print26(...interface{})
 func f27(b bool) {
 	x := 0
 	if b {
-		call27(func() {x++}) // ERROR "live at call to call27: autotmp_[0-9]+$"
+		call27(func() { x++ }) // ERROR "live at call to call27: autotmp_[0-9]+$"
 	}
-	call27(func() {x++}) // ERROR "live at call to call27: autotmp_[0-9]+$"
-	call27(func() {x++}) // ERROR "live at call to call27: autotmp_[0-9]+$"
+	call27(func() { x++ }) // ERROR "live at call to call27: autotmp_[0-9]+$"
+	call27(func() { x++ }) // ERROR "live at call to call27: autotmp_[0-9]+$"
 	println()
 }
 
@@ -386,10 +389,10 @@ func f27(b bool) {
 func f27defer(b bool) {
 	x := 0
 	if b {
-		defer call27(func() {x++}) // ERROR "live at call to deferproc: autotmp_[0-9]+$" "live at call to deferreturn: autotmp_[0-9]+$"
+		defer call27(func() { x++ }) // ERROR "live at call to deferproc: autotmp_[0-9]+$" "live at call to deferreturn: autotmp_[0-9]+$"
 	}
-	defer call27(func() {x++}) // ERROR "live at call to deferproc: autotmp_[0-9]+ autotmp_[0-9]+$" "live at call to deferreturn: autotmp_[0-9]+ autotmp_[0-9]+$" "ambiguously live"
-	println() // ERROR "live at call to printnl: autotmp_[0-9]+ autotmp_[0-9]+$"
+	defer call27(func() { x++ }) // ERROR "live at call to deferproc: autotmp_[0-9]+ autotmp_[0-9]+$" "live at call to deferreturn: autotmp_[0-9]+ autotmp_[0-9]+$" "ambiguously live"
+	println()                    // ERROR "live at call to printnl: autotmp_[0-9]+ autotmp_[0-9]+$"
 } // ERROR "live at call to deferreturn: autotmp_[0-9]+ autotmp_[0-9]+$"
 
 // and newproc (go) escapes to the heap
@@ -397,9 +400,9 @@ func f27defer(b bool) {
 func f27go(b bool) {
 	x := 0
 	if b {
-		go call27(func() {x++}) // ERROR "live at call to newobject: &x" "live at call to newproc: &x$"
+		go call27(func() { x++ }) // ERROR "live at call to newobject: &x" "live at call to newproc: &x$"
 	}
-	go call27(func() {x++}) // ERROR "live at call to newobject: &x"
+	go call27(func() { x++ }) // ERROR "live at call to newobject: &x"
 	println()
 }
 
@@ -412,11 +415,11 @@ var s1, s2, s3, s4, s5, s6, s7, s8, s9, s10 string
 
 func f28(b bool) {
 	if b {
-		print(s1+s2+s3+s4+s5+s6+s7+s8+s9+s10) // ERROR "live at call to concatstrings: autotmp_[0-9]+$" "live at call to printstring: autotmp_[0-9]+$"
+		print(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) // ERROR "live at call to concatstrings: autotmp_[0-9]+$" "live at call to printstring: autotmp_[0-9]+$"
 	}
-	print(s1+s2+s3+s4+s5+s6+s7+s8+s9+s10) // ERROR "live at call to concatstrings: autotmp_[0-9]+$" "live at call to printstring: autotmp_[0-9]+$"
-	print(s1+s2+s3+s4+s5+s6+s7+s8+s9+s10) // ERROR "live at call to concatstrings: autotmp_[0-9]+$" "live at call to printstring: autotmp_[0-9]+$"
-}	
+	print(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) // ERROR "live at call to concatstrings: autotmp_[0-9]+$" "live at call to printstring: autotmp_[0-9]+$"
+	print(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) // ERROR "live at call to concatstrings: autotmp_[0-9]+$" "live at call to printstring: autotmp_[0-9]+$"
+}
 
 // map iterator should die on end of range loop
 
@@ -584,13 +587,13 @@ func f39a() (x []int) {
 
 func f39b() (x [10]*int) {
 	x = [10]*int{new(int)} // ERROR "live at call to newobject: x"
-	println() // ERROR "live at call to printnl: x"
+	println()              // ERROR "live at call to printnl: x"
 	return x
 }
 
 func f39c() (x [10]*int) {
 	x = [10]*int{new(int)} // ERROR "live at call to newobject: x"
-	println() // ERROR "live at call to printnl: x"
+	println()              // ERROR "live at call to printnl: x"
 	return
 }
 
@@ -603,7 +606,7 @@ type T40 struct {
 
 func newT40() *T40 {
 	ret := T40{ // ERROR "live at call to makemap: &ret"
-		make(map[int]int), 
+		make(map[int]int),
 	}
 	return &ret
 }

From a6feaf3affcc83f77af1a2ad8c9418befcdec6ef Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Mon, 18 Aug 2014 18:14:54 -0700
Subject: [PATCH 116/423] liblink: fix encoding of ASETPC in 6a, 8a

It was incorrectly encoded as ASETLS.

LGTM=ruiu, rsc
R=rsc, ruiu
CC=golang-codereviews
https://golang.org/cl/126400043
---
 src/liblink/asm6.c | 2 +-
 src/liblink/asm8.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/liblink/asm6.c b/src/liblink/asm6.c
index e25c85053a..576f349750 100644
--- a/src/liblink/asm6.c
+++ b/src/liblink/asm6.c
@@ -1302,7 +1302,7 @@ static Optab optab[] =
 	{ ASETNE,	yscond,	Pm, {0x95,(00)} },
 	{ ASETOC,	yscond,	Pm, {0x91,(00)} },
 	{ ASETOS,	yscond,	Pm, {0x90,(00)} },
-	{ ASETPC,	yscond,	Pm, {0x96,(00)} },
+	{ ASETPC,	yscond,	Pm, {0x9b,(00)} },
 	{ ASETPL,	yscond,	Pm, {0x99,(00)} },
 	{ ASETPS,	yscond,	Pm, {0x9a,(00)} },
 	{ ASHLB,	yshb,	Pb, {0xd0,(04),0xc0,(04),0xd2,(04)} },
diff --git a/src/liblink/asm8.c b/src/liblink/asm8.c
index f40b92bf84..6035017b2c 100644
--- a/src/liblink/asm8.c
+++ b/src/liblink/asm8.c
@@ -813,7 +813,7 @@ static Optab optab[] =
 	{ ASETNE,	yscond,	Pm, {0x95,(00)} },
 	{ ASETOC,	yscond,	Pm, {0x91,(00)} },
 	{ ASETOS,	yscond,	Pm, {0x90,(00)} },
-	{ ASETPC,	yscond,	Pm, {0x96,(00)} },
+	{ ASETPC,	yscond,	Pm, {0x9b,(00)} },
 	{ ASETPL,	yscond,	Pm, {0x99,(00)} },
 	{ ASETPS,	yscond,	Pm, {0x9a,(00)} },
 	{ ACDQ,		ynone,	Px, {0x99} },

From 3e9c7a8a1d8de6384777eb8a27aa07c4dd34482e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 18 Aug 2014 22:12:51 -0400
Subject: [PATCH 117/423] runtime: fix windows/amd64 build after pc-relative 6l
 change

TBR=iant
CC=golang-codereviews
https://golang.org/cl/131900043
---
 src/pkg/runtime/sys_windows_amd64.s | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/sys_windows_amd64.s b/src/pkg/runtime/sys_windows_amd64.s
index 6dc13e293d..73b1ba6d8c 100644
--- a/src/pkg/runtime/sys_windows_amd64.s
+++ b/src/pkg/runtime/sys_windows_amd64.s
@@ -228,7 +228,8 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	ADDQ	$8, SP
 
 	// determine index into runtime·cbctxts table
-	SUBQ	$runtime·callbackasm(SB), AX
+	MOVQ	$runtime·callbackasm(SB), DX
+	SUBQ	DX, AX
 	MOVQ	$0, DX
 	MOVQ	$5, CX	// divide by 5 because each call instruction in runtime·callbacks is 5 bytes long
 	DIVL	CX,

From bdb2f976d369112f68a1288eea1a8c1f54366fba Mon Sep 17 00:00:00 2001
From: Evan Kroske <evankroske@google.com>
Date: Mon, 18 Aug 2014 20:40:12 -0700
Subject: [PATCH 118/423] net/http: correct error message for incorrect Body
 length

Fixes #8140.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/131900044
---
 src/pkg/net/http/requestwrite_test.go | 4 ++--
 src/pkg/net/http/transfer.go          | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pkg/net/http/requestwrite_test.go b/src/pkg/net/http/requestwrite_test.go
index 997010c2b2..7a6bd58786 100644
--- a/src/pkg/net/http/requestwrite_test.go
+++ b/src/pkg/net/http/requestwrite_test.go
@@ -280,7 +280,7 @@ var reqWriteTests = []reqWriteTest{
 			ContentLength: 10, // but we're going to send only 5 bytes
 		},
 		Body:      []byte("12345"),
-		WantError: errors.New("http: Request.ContentLength=10 with Body length 5"),
+		WantError: errors.New("http: ContentLength=10 with Body length 5"),
 	},
 
 	// Request with a ContentLength of 4 but an 8 byte body.
@@ -294,7 +294,7 @@ var reqWriteTests = []reqWriteTest{
 			ContentLength: 4, // but we're going to try to send 8 bytes
 		},
 		Body:      []byte("12345678"),
-		WantError: errors.New("http: Request.ContentLength=4 with Body length 8"),
+		WantError: errors.New("http: ContentLength=4 with Body length 8"),
 	},
 
 	// Request with a 5 ContentLength and nil body.
diff --git a/src/pkg/net/http/transfer.go b/src/pkg/net/http/transfer.go
index c9be871595..51b1dcb30b 100644
--- a/src/pkg/net/http/transfer.go
+++ b/src/pkg/net/http/transfer.go
@@ -228,7 +228,7 @@ func (t *transferWriter) WriteBody(w io.Writer) error {
 	}
 
 	if !t.ResponseToHEAD && t.ContentLength != -1 && t.ContentLength != ncopy {
-		return fmt.Errorf("http: Request.ContentLength=%d with Body length %d",
+		return fmt.Errorf("http: ContentLength=%d with Body length %d",
 			t.ContentLength, ncopy)
 	}
 

From 0fee63351d0a41fc979e4480460e5aa76903bab6 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Tue, 19 Aug 2014 14:24:14 +1000
Subject: [PATCH 119/423] html/template: don't panic on second execution of
 unescapable template

Fixes #8431.

LGTM=r
R=golang-codereviews, r, minux
CC=golang-codereviews
https://golang.org/cl/130830043
---
 src/pkg/html/template/escape.go      |  3 ++-
 src/pkg/html/template/escape_test.go |  5 ++++
 src/pkg/html/template/template.go    | 36 +++++++++++++++++-----------
 3 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/src/pkg/html/template/escape.go b/src/pkg/html/template/escape.go
index 4e379828d4..3ba3747f6f 100644
--- a/src/pkg/html/template/escape.go
+++ b/src/pkg/html/template/escape.go
@@ -34,6 +34,7 @@ func escapeTemplates(tmpl *Template, names ...string) error {
 			// Prevent execution of unsafe templates.
 			for _, name := range names {
 				if t := tmpl.set[name]; t != nil {
+					t.escapeErr = err
 					t.text.Tree = nil
 					t.Tree = nil
 				}
@@ -44,7 +45,7 @@ func escapeTemplates(tmpl *Template, names ...string) error {
 	e.commit()
 	for _, name := range names {
 		if t := tmpl.set[name]; t != nil {
-			t.escaped = true
+			t.escapeErr = escapeOK
 			t.Tree = t.text.Tree
 		}
 	}
diff --git a/src/pkg/html/template/escape_test.go b/src/pkg/html/template/escape_test.go
index 3ccf93ece0..5509b836f9 100644
--- a/src/pkg/html/template/escape_test.go
+++ b/src/pkg/html/template/escape_test.go
@@ -994,6 +994,11 @@ func TestErrors(t *testing.T) {
 			t.Errorf("input=%q: error\n\t%q\ndoes not contain expected string\n\t%q", test.input, got, test.err)
 			continue
 		}
+		// Check that we get the same error if we call Execute again.
+		if err := tmpl.Execute(buf, nil); err == nil || err.Error() != got {
+			t.Errorf("input=%q: unexpected error on second call %q", test.input, err)
+
+		}
 	}
 }
 
diff --git a/src/pkg/html/template/template.go b/src/pkg/html/template/template.go
index d389658979..538837cc5c 100644
--- a/src/pkg/html/template/template.go
+++ b/src/pkg/html/template/template.go
@@ -17,7 +17,8 @@ import (
 // Template is a specialized Template from "text/template" that produces a safe
 // HTML document fragment.
 type Template struct {
-	escaped bool
+	// Sticky error if escaping fails.
+	escapeErr error
 	// We could embed the text/template field, but it's safer not to because
 	// we need to keep our version of the name space and the underlying
 	// template's in sync.
@@ -27,6 +28,9 @@ type Template struct {
 	*nameSpace // common to all associated templates
 }
 
+// escapeOK is a sentinel value used to indicate valid escaping.
+var escapeOK = fmt.Errorf("template escaped correctly")
+
 // nameSpace is the data structure shared by all templates in an association.
 type nameSpace struct {
 	mu  sync.Mutex
@@ -51,11 +55,12 @@ func (t *Template) Templates() []*Template {
 func (t *Template) escape() error {
 	t.nameSpace.mu.Lock()
 	defer t.nameSpace.mu.Unlock()
-	if !t.escaped {
+	if t.escapeErr == nil {
 		if err := escapeTemplates(t, t.Name()); err != nil {
 			return err
 		}
-		t.escaped = true
+	} else if t.escapeErr != escapeOK {
+		return t.escapeErr
 	}
 	return nil
 }
@@ -97,13 +102,16 @@ func (t *Template) lookupAndEscapeTemplate(name string) (tmpl *Template, err err
 	if tmpl == nil {
 		return nil, fmt.Errorf("html/template: %q is undefined", name)
 	}
+	if tmpl.escapeErr != nil && tmpl.escapeErr != escapeOK {
+		return nil, tmpl.escapeErr
+	}
 	if tmpl.text.Tree == nil || tmpl.text.Root == nil {
 		return nil, fmt.Errorf("html/template: %q is an incomplete template", name)
 	}
 	if t.text.Lookup(name) == nil {
 		panic("html/template internal error: template escaping out of sync")
 	}
-	if tmpl != nil && !tmpl.escaped {
+	if tmpl.escapeErr == nil {
 		err = escapeTemplates(tmpl, name)
 	}
 	return tmpl, err
@@ -119,7 +127,7 @@ func (t *Template) lookupAndEscapeTemplate(name string) (tmpl *Template, err err
 // other than space, comments, and template definitions.)
 func (t *Template) Parse(src string) (*Template, error) {
 	t.nameSpace.mu.Lock()
-	t.escaped = false
+	t.escapeErr = nil
 	t.nameSpace.mu.Unlock()
 	ret, err := t.text.Parse(src)
 	if err != nil {
@@ -137,7 +145,7 @@ func (t *Template) Parse(src string) (*Template, error) {
 			tmpl = t.new(name)
 		}
 		// Restore our record of this text/template to its unescaped original state.
-		tmpl.escaped = false
+		tmpl.escapeErr = nil
 		tmpl.text = v
 		tmpl.Tree = v.Tree
 	}
@@ -151,7 +159,7 @@ func (t *Template) Parse(src string) (*Template, error) {
 func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) {
 	t.nameSpace.mu.Lock()
 	defer t.nameSpace.mu.Unlock()
-	if t.escaped {
+	if t.escapeErr != nil {
 		return nil, fmt.Errorf("html/template: cannot AddParseTree to %q after it has executed", t.Name())
 	}
 	text, err := t.text.AddParseTree(name, tree)
@@ -159,7 +167,7 @@ func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error
 		return nil, err
 	}
 	ret := &Template{
-		false,
+		nil,
 		text,
 		text.Tree,
 		t.nameSpace,
@@ -179,7 +187,7 @@ func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error
 func (t *Template) Clone() (*Template, error) {
 	t.nameSpace.mu.Lock()
 	defer t.nameSpace.mu.Unlock()
-	if t.escaped {
+	if t.escapeErr != nil {
 		return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
 	}
 	textClone, err := t.text.Clone()
@@ -187,7 +195,7 @@ func (t *Template) Clone() (*Template, error) {
 		return nil, err
 	}
 	ret := &Template{
-		false,
+		nil,
 		textClone,
 		textClone.Tree,
 		&nameSpace{
@@ -197,12 +205,12 @@ func (t *Template) Clone() (*Template, error) {
 	for _, x := range textClone.Templates() {
 		name := x.Name()
 		src := t.set[name]
-		if src == nil || src.escaped {
+		if src == nil || src.escapeErr != nil {
 			return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
 		}
 		x.Tree = x.Tree.Copy()
 		ret.set[name] = &Template{
-			false,
+			nil,
 			x,
 			x.Tree,
 			ret.nameSpace,
@@ -214,7 +222,7 @@ func (t *Template) Clone() (*Template, error) {
 // New allocates a new HTML template with the given name.
 func New(name string) *Template {
 	tmpl := &Template{
-		false,
+		nil,
 		template.New(name),
 		nil,
 		&nameSpace{
@@ -237,7 +245,7 @@ func (t *Template) New(name string) *Template {
 // new is the implementation of New, without the lock.
 func (t *Template) new(name string) *Template {
 	tmpl := &Template{
-		false,
+		nil,
 		t.text.New(name),
 		nil,
 		t.nameSpace,

From e4f3db3852e9178ac4c764fe753301d07a3269c8 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Tue, 19 Aug 2014 14:41:52 +1000
Subject: [PATCH 120/423] runtime: apply KindMask before comparison

Fixes windows build.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/127510043
---
 src/pkg/runtime/callback_windows.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/callback_windows.c b/src/pkg/runtime/callback_windows.c
index f1283a85d6..5c6975af29 100644
--- a/src/pkg/runtime/callback_windows.c
+++ b/src/pkg/runtime/callback_windows.c
@@ -29,7 +29,7 @@ runtime·compilecallback(Eface fn, bool cleanstack)
 	int32 argsize, i, n;
 	WinCallbackContext *c;
 
-	if(fn.type == nil || fn.type->kind != KindFunc)
+	if(fn.type == nil || (fn.type->kind&KindMask) != KindFunc)
 		runtime·panicstring("compilecallback: not a function");
 	ft = (FuncType*)fn.type;
 	if(ft->out.len != 1)

From 2de65cad54da0f7fe3ff6aafb3cd70ad36146e2b Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Tue, 19 Aug 2014 14:59:56 +1000
Subject: [PATCH 121/423] os: make SameFile handle paths like c:a.txt properly

Fixes #8490.

LGTM=r, rsc
R=golang-codereviews, rsc, bradfitz, r
CC=golang-codereviews
https://golang.org/cl/127740043
---
 src/pkg/os/file_windows.go      |  6 ++--
 src/pkg/os/os_windows_test.go   | 54 +++++++++++++++++++++++++++++++++
 src/pkg/os/stat_windows.go      |  6 ++--
 src/pkg/syscall/exec_windows.go | 15 +++++----
 4 files changed, 69 insertions(+), 12 deletions(-)

diff --git a/src/pkg/os/file_windows.go b/src/pkg/os/file_windows.go
index d3aa03b2fb..e78d4abf64 100644
--- a/src/pkg/os/file_windows.go
+++ b/src/pkg/os/file_windows.go
@@ -117,8 +117,10 @@ func openDir(name string) (file *File, err error) {
 	}
 	d.path = name
 	if !isAbs(d.path) {
-		cwd, _ := Getwd()
-		d.path = cwd + `\` + d.path
+		d.path, e = syscall.FullPath(d.path)
+		if e != nil {
+			return nil, e
+		}
 	}
 	f := newFile(r, name)
 	f.dirinfo = d
diff --git a/src/pkg/os/os_windows_test.go b/src/pkg/os/os_windows_test.go
index af7332f0f2..fd96713eac 100644
--- a/src/pkg/os/os_windows_test.go
+++ b/src/pkg/os/os_windows_test.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"syscall"
+	"testing"
 )
 
 func init() {
@@ -25,3 +26,56 @@ func init() {
 		supportsSymlinks = false
 	}
 }
+
+func TestSameWindowsFile(t *testing.T) {
+	temp, err := ioutil.TempDir("", "TestSameWindowsFile")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(temp)
+
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = os.Chdir(temp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chdir(wd)
+
+	f, err := os.Create("a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+
+	ia1, err := os.Stat("a")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	path, err := filepath.Abs("a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ia2, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !os.SameFile(ia1, ia2) {
+		t.Errorf("files should be same")
+	}
+
+	p := filepath.VolumeName(path) + filepath.Base(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ia3, err := os.Stat(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !os.SameFile(ia1, ia3) {
+		t.Errorf("files should be same")
+	}
+}
diff --git a/src/pkg/os/stat_windows.go b/src/pkg/os/stat_windows.go
index 3222060448..f396c1db31 100644
--- a/src/pkg/os/stat_windows.go
+++ b/src/pkg/os/stat_windows.go
@@ -87,8 +87,10 @@ func Lstat(name string) (fi FileInfo, err error) {
 	}
 	fs.path = name
 	if !isAbs(fs.path) {
-		cwd, _ := Getwd()
-		fs.path = cwd + `\` + fs.path
+		fs.path, e = syscall.FullPath(fs.path)
+		if e != nil {
+			return nil, e
+		}
 	}
 	return fs, nil
 }
diff --git a/src/pkg/syscall/exec_windows.go b/src/pkg/syscall/exec_windows.go
index 82abc0715e..936aeb577b 100644
--- a/src/pkg/syscall/exec_windows.go
+++ b/src/pkg/syscall/exec_windows.go
@@ -129,9 +129,8 @@ func SetNonblock(fd Handle, nonblocking bool) (err error) {
 	return nil
 }
 
-// getFullPath retrieves the full path of the specified file.
-// Just a wrapper for Windows GetFullPathName api.
-func getFullPath(name string) (path string, err error) {
+// FullPath retrieves the full path of the specified file.
+func FullPath(name string) (path string, err error) {
 	p, err := UTF16PtrFromString(name)
 	if err != nil {
 		return "", err
@@ -160,7 +159,7 @@ func isSlash(c uint8) bool {
 }
 
 func normalizeDir(dir string) (name string, err error) {
-	ndir, err := getFullPath(dir)
+	ndir, err := FullPath(dir)
 	if err != nil {
 		return "", err
 	}
@@ -199,9 +198,9 @@ func joinExeDirAndFName(dir, p string) (name string, err error) {
 				return "", err
 			}
 			if volToUpper(int(p[0])) == volToUpper(int(d[0])) {
-				return getFullPath(d + "\\" + p[2:])
+				return FullPath(d + "\\" + p[2:])
 			} else {
-				return getFullPath(p)
+				return FullPath(p)
 			}
 		}
 	} else {
@@ -211,9 +210,9 @@ func joinExeDirAndFName(dir, p string) (name string, err error) {
 			return "", err
 		}
 		if isSlash(p[0]) {
-			return getFullPath(d[:2] + p)
+			return FullPath(d[:2] + p)
 		} else {
-			return getFullPath(d + "\\" + p)
+			return FullPath(d + "\\" + p)
 		}
 	}
 	// we shouldn't be here

From 30ef2c7debeeb9f5bcab8cd2c60a8587f35bc0ae Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 11:46:05 +0400
Subject: [PATCH 122/423] runtime: fix memstats Newly allocated memory is
 subtracted from inuse, while it was never added to inuse. Span leftovers are
 subtracted from both inuse and idle, while they were never added. Fixes
 #8544. Fixes #8430.

LGTM=khr, cookieo9
R=golang-codereviews, khr, cookieo9
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/130200044
---
 src/pkg/runtime/malloc.h       |  1 +
 src/pkg/runtime/malloc_test.go | 22 +++++++++++++++++++---
 src/pkg/runtime/mheap.c        | 24 ++++++++++++++----------
 3 files changed, 34 insertions(+), 13 deletions(-)

diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 963e71c42f..a700956b0c 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -283,6 +283,7 @@ struct MStats
 #define mstats runtime·memstats
 extern MStats mstats;
 void	runtime·updatememstats(GCStats *stats);
+void	runtime·ReadMemStats(MStats *stats);
 
 // Size classes.  Computed and initialized by InitSizes.
 //
diff --git a/src/pkg/runtime/malloc_test.go b/src/pkg/runtime/malloc_test.go
index 252760a07e..211d78dc8a 100644
--- a/src/pkg/runtime/malloc_test.go
+++ b/src/pkg/runtime/malloc_test.go
@@ -16,10 +16,26 @@ func TestMemStats(t *testing.T) {
 	// Test that MemStats has sane values.
 	st := new(MemStats)
 	ReadMemStats(st)
-	if st.HeapSys == 0 || st.StackSys == 0 || st.MSpanSys == 0 || st.MCacheSys == 0 ||
-		st.BuckHashSys == 0 || st.GCSys == 0 || st.OtherSys == 0 {
-		t.Fatalf("Zero sys value: %+v", *st)
+
+	// Everything except HeapReleased, because it indeed can be 0.
+	if st.Alloc == 0 || st.TotalAlloc == 0 || st.Sys == 0 || st.Lookups == 0 ||
+		st.Mallocs == 0 || st.Frees == 0 || st.HeapAlloc == 0 || st.HeapSys == 0 ||
+		st.HeapIdle == 0 || st.HeapInuse == 0 || st.HeapObjects == 0 || st.StackInuse == 0 ||
+		st.StackSys == 0 || st.MSpanInuse == 0 || st.MSpanSys == 0 || st.MCacheInuse == 0 ||
+		st.MCacheSys == 0 || st.BuckHashSys == 0 || st.GCSys == 0 || st.OtherSys == 0 ||
+		st.NextGC == 0 || st.NumGC == 0 {
+		t.Fatalf("Zero value: %+v", *st)
 	}
+
+	if st.Alloc > 1e10 || st.TotalAlloc > 1e11 || st.Sys > 1e10 || st.Lookups > 1e10 ||
+		st.Mallocs > 1e10 || st.Frees > 1e10 || st.HeapAlloc > 1e10 || st.HeapSys > 1e10 ||
+		st.HeapIdle > 1e10 || st.HeapInuse > 1e10 || st.HeapObjects > 1e10 || st.StackInuse > 1e10 ||
+		st.StackSys > 1e10 || st.MSpanInuse > 1e10 || st.MSpanSys > 1e10 || st.MCacheInuse > 1e10 ||
+		st.MCacheSys > 1e10 || st.BuckHashSys > 1e10 || st.GCSys > 1e10 || st.OtherSys > 1e10 ||
+		st.NextGC > 1e10 || st.NumGC > 1e9 {
+		t.Fatalf("Insanely high value (overflow?): %+v", *st)
+	}
+
 	if st.Sys != st.HeapSys+st.StackSys+st.MSpanSys+st.MCacheSys+
 		st.BuckHashSys+st.GCSys+st.OtherSys {
 		t.Fatalf("Bad sys value: %+v", *st)
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 46cf80007b..599872423a 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -17,7 +17,7 @@
 #include "malloc.h"
 
 static MSpan *MHeap_AllocSpanLocked(MHeap*, uintptr);
-static void MHeap_FreeSpanLocked(MHeap*, MSpan*);
+static void MHeap_FreeSpanLocked(MHeap*, MSpan*, bool, bool);
 static bool MHeap_Grow(MHeap*, uintptr);
 static MSpan *MHeap_AllocLarge(MHeap*, uintptr);
 static MSpan *BestFit(MSpan*, uintptr, MSpan*);
@@ -326,7 +326,7 @@ HaveSpan:
 		t->needzero = s->needzero;
 		s->state = MSpanStack; // prevent coalescing with s
 		t->state = MSpanStack;
-		MHeap_FreeSpanLocked(h, t);
+		MHeap_FreeSpanLocked(h, t, false, false);
 		t->unusedsince = s->unusedsince; // preserve age (TODO: wrong: t is possibly merged and/or deallocated at this point)
 		s->state = MSpanFree;
 	}
@@ -413,7 +413,7 @@ MHeap_Grow(MHeap *h, uintptr npage)
 	h->spans[p + s->npages - 1] = s;
 	runtime·atomicstore(&s->sweepgen, h->sweepgen);
 	s->state = MSpanInUse;
-	MHeap_FreeSpanLocked(h, s);
+	MHeap_FreeSpanLocked(h, s, false, true);
 	return true;
 }
 
@@ -467,7 +467,7 @@ mheap_free(MHeap *h, MSpan *s, int32 acct)
 		mstats.heap_alloc -= s->npages<<PageShift;
 		mstats.heap_objects--;
 	}
-	MHeap_FreeSpanLocked(h, s);
+	MHeap_FreeSpanLocked(h, s, true, true);
 	runtime·unlock(&h->lock);
 }
 
@@ -506,12 +506,12 @@ runtime·MHeap_FreeStack(MHeap *h, MSpan *s)
 	s->needzero = 1;
 	runtime·lock(&h->lock);
 	mstats.stacks_inuse -= s->npages<<PageShift;
-	MHeap_FreeSpanLocked(h, s);
+	MHeap_FreeSpanLocked(h, s, true, true);
 	runtime·unlock(&h->lock);
 }
 
 static void
-MHeap_FreeSpanLocked(MHeap *h, MSpan *s)
+MHeap_FreeSpanLocked(MHeap *h, MSpan *s, bool acctinuse, bool acctidle)
 {
 	MSpan *t;
 	PageID p;
@@ -532,8 +532,10 @@ MHeap_FreeSpanLocked(MHeap *h, MSpan *s)
 		runtime·throw("MHeap_FreeSpanLocked - invalid span state");
 		break;
 	}
-	mstats.heap_inuse -= s->npages<<PageShift;
-	mstats.heap_idle += s->npages<<PageShift;
+	if(acctinuse)
+		mstats.heap_inuse -= s->npages<<PageShift;
+	if(acctidle)
+		mstats.heap_idle += s->npages<<PageShift;
 	s->state = MSpanFree;
 	runtime·MSpanList_Remove(s);
 	// Stamp newly unused spans. The scavenger will use that
@@ -606,6 +608,7 @@ scavenge(int32 k, uint64 now, uint64 limit)
 {
 	uint32 i;
 	uintptr sumreleased;
+	MStats stats;
 	MHeap *h;
 	
 	h = &runtime·mheap;
@@ -615,11 +618,12 @@ scavenge(int32 k, uint64 now, uint64 limit)
 	sumreleased += scavengelist(&h->freelarge, now, limit);
 
 	if(runtime·debug.gctrace > 0) {
+		runtime·ReadMemStats(&stats);
 		if(sumreleased > 0)
 			runtime·printf("scvg%d: %D MB released\n", k, (uint64)sumreleased>>20);
 		runtime·printf("scvg%d: inuse: %D, idle: %D, sys: %D, released: %D, consumed: %D (MB)\n",
-			k, mstats.heap_inuse>>20, mstats.heap_idle>>20, mstats.heap_sys>>20,
-			mstats.heap_released>>20, (mstats.heap_sys - mstats.heap_released)>>20);
+			k, stats.heap_inuse>>20, stats.heap_idle>>20, stats.heap_sys>>20,
+			stats.heap_released>>20, (stats.heap_sys - stats.heap_released)>>20);
 	}
 }
 

From b3d5a695a6ad56fa33455eedf8d502a1a90a51ac Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 11:46:19 +0400
Subject: [PATCH 123/423] runtime: improve diagnostics of non-copyable frames

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/124560043
---
 src/pkg/runtime/stack.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index b4e992e658..3bd96ff314 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -476,6 +476,9 @@ copyabletopsegment(G *gp)
 	if(StackDebug >= 1 && cinfo.frames != -1)
 		runtime·printf("copystack: %d copyable frames\n", cinfo.frames);
 
+	if(cinfo.frames == -1)
+		return -1;
+
 	// Check to make sure all Defers are copyable
 	for(d = gp->defer; d != nil; d = d->link) {
 		if(cinfo.stk <= (byte*)d && (byte*)d < cinfo.base) {
@@ -490,8 +493,11 @@ copyabletopsegment(G *gp)
 		if(fn == nil) // See issue 8047
 			continue;
 		f = runtime·findfunc((uintptr)fn->fn);
-		if(f == nil)
+		if(f == nil) {
+			if(StackDebug >= 1)
+				runtime·printf("copystack: no func for deferred pc %p\n", fn->fn);
 			return -1;
+		}
 
 		// Check to make sure we have an args pointer map for the defer's args.
 		// We only need the args map, but we check
@@ -499,11 +505,17 @@ copyabletopsegment(G *gp)
 		// isn't provided it means the ptr map came from C and
 		// C (particularly, cgo) lies to us.  See issue 7695.
 		stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
-		if(stackmap == nil || stackmap->n <= 0)
+		if(stackmap == nil || stackmap->n <= 0) {
+			if(StackDebug >= 1)
+				runtime·printf("copystack: no arg info for deferred %s\n", runtime·funcname(f));
 			return -1;
+		}
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
-		if(stackmap == nil || stackmap->n <= 0)
+		if(stackmap == nil || stackmap->n <= 0) {
+			if(StackDebug >= 1)
+				runtime·printf("copystack: no local info for deferred %s\n", runtime·funcname(f));
 			return -1;
+		}
 
 		if(cinfo.stk <= (byte*)fn && (byte*)fn < cinfo.base) {
 			// FuncVal is on the stack.  Again, its copyableness

From 53056c37c2e3720666742f516ef148432313e28a Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 11:49:36 +0400
Subject: [PATCH 124/423] cmd/gc: fix heap buffer overflow Fixes #8528.

LGTM=rsc
R=rsc, r, iant, bradfitz
CC=golang-codereviews
https://golang.org/cl/128230045
---
 src/cmd/gc/bv.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cmd/gc/bv.c b/src/cmd/gc/bv.c
index 0e8f8d4739..cfd1cd2811 100644
--- a/src/cmd/gc/bv.c
+++ b/src/cmd/gc/bv.c
@@ -108,6 +108,9 @@ bvnext(Bvec *bv, int32 i)
 {
 	uint32 w;
 
+	if(i >= bv->n)
+		return -1;
+
 	// Jump i ahead to next word with bits.
 	if((bv->b[i>>WORDSHIFT]>>(i&WORDMASK)) == 0) {
 		i &= ~WORDMASK;
@@ -117,7 +120,7 @@ bvnext(Bvec *bv, int32 i)
 	}
 	if(i >= bv->n)
 		return -1;
-	
+
 	// Find 1 bit.
 	w = bv->b[i>>WORDSHIFT]>>(i&WORDMASK);
 	while((w&1) == 0) {

From 5d40742728cac9fa351c03d21598937b27b398a7 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 11:49:59 +0400
Subject: [PATCH 125/423] runtime: convert Gosched to Go

LGTM=rlh, khr
R=golang-codereviews, rlh, bradfitz, khr
CC=golang-codereviews, rsc
https://golang.org/cl/127490043
---
 src/pkg/runtime/extern.go |  4 ----
 src/pkg/runtime/proc.c    | 14 ++++----------
 src/pkg/runtime/proc.go   | 11 +++++++++++
 src/pkg/runtime/runtime.h |  2 +-
 src/pkg/runtime/stack.c   |  2 +-
 src/pkg/runtime/stubs.go  |  3 ++-
 6 files changed, 19 insertions(+), 17 deletions(-)
 create mode 100644 src/pkg/runtime/proc.go

diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index 57f09aaf7d..533cb431b9 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -73,10 +73,6 @@ of the run-time system.
 */
 package runtime
 
-// Gosched yields the processor, allowing other goroutines to run.  It does not
-// suspend the current goroutine, so execution resumes automatically.
-func Gosched()
-
 // Goexit terminates the goroutine that calls it.  No other goroutine is affected.
 // Goexit runs all deferred calls before terminating the goroutine.
 //
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index a3e0f4bc52..2510a421a8 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1449,15 +1449,15 @@ park0(G *gp)
 void
 runtime·gosched(void)
 {
-	if(g->status != Grunning)
-		runtime·throw("bad g status");
-	runtime·mcall(runtime·gosched0);
+	runtime·mcall(runtime·gosched_m);
 }
 
 // runtime·gosched continuation on g0.
 void
-runtime·gosched0(G *gp)
+runtime·gosched_m(G *gp)
 {
+	if(gp->status != Grunning)
+		runtime·throw("bad g status");
 	gp->status = Grunnable;
 	dropg();
 	runtime·lock(&runtime·sched.lock);
@@ -2055,12 +2055,6 @@ runtime·Breakpoint(void)
 	runtime·breakpoint();
 }
 
-void
-runtime·Gosched(void)
-{
-	runtime·gosched();
-}
-
 // Implementation of runtime.GOMAXPROCS.
 // delete when scheduler is even stronger
 int32
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
new file mode 100644
index 0000000000..1b586e8c62
--- /dev/null
+++ b/src/pkg/runtime/proc.go
@@ -0,0 +1,11 @@
+// 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 runtime
+
+// Gosched yields the processor, allowing other goroutines to run.  It does not
+// suspend the current goroutine, so execution resumes automatically.
+func Gosched() {
+	mcall(&gosched_m)
+}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 0aeba39da8..0dc60b286b 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -919,7 +919,7 @@ void	runtime·newextram(void);
 void	runtime·exit(int32);
 void	runtime·breakpoint(void);
 void	runtime·gosched(void);
-void	runtime·gosched0(G*);
+void	runtime·gosched_m(G*);
 void	runtime·schedtrace(bool);
 void	runtime·park(bool(*)(G*, void*), void*, int8*);
 void	runtime·parkunlock(Lock*, int8*);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 3bd96ff314..f7d41f44d4 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -903,7 +903,7 @@ runtime·newstack(void)
 		}
 		// Act like goroutine called runtime.Gosched.
 		gp->status = oldstatus;
-		runtime·gosched0(gp);	// never return
+		runtime·gosched_m(gp);	// never return
 	}
 
 	// If every frame on the top segment is copyable, allocate a bigger segment
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index a4ef9d3d55..39244ef9df 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -68,7 +68,8 @@ var (
 	setFinalizer_m,
 	markallocated_m,
 	unrollgcprog_m,
-	unrollgcproginplace_m mFunction
+	unrollgcproginplace_m,
+	gosched_m mFunction
 )
 
 // memclr clears n bytes starting at ptr.

From 266d350f5e0a47dd831684eb60b69a6409ca0085 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 11:53:20 +0400
Subject: [PATCH 126/423] runtime: fix MemStats on 32-bits Int64's do not fit
 into uintptr's.

LGTM=khr
R=golang-codereviews, khr, rsc
CC=golang-codereviews, rlh
https://golang.org/cl/128380043
---
 src/pkg/runtime/gc_test.go | 4 ++++
 src/pkg/runtime/malloc.go  | 7 ++++---
 src/pkg/runtime/mgc0.c     | 4 ++--
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/gc_test.go b/src/pkg/runtime/gc_test.go
index 073d9fa758..383af5be3d 100644
--- a/src/pkg/runtime/gc_test.go
+++ b/src/pkg/runtime/gc_test.go
@@ -164,6 +164,10 @@ func TestGcLastTime(t *testing.T) {
 	if t0 > last || last > t1 {
 		t.Fatalf("bad last GC time: got %v, want [%v, %v]", last, t0, t1)
 	}
+	pause := ms.PauseNs[(ms.NumGC+255)%256]
+	if pause == 0 || pause > 10e9 {
+		t.Fatalf("bad last GC pause: got %v, want [0, 10e9]", pause)
+	}
 }
 
 var hugeSink interface{}
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index ce7e062109..84c69abde7 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -477,11 +477,12 @@ func gogc(force int32) {
 			startTime = gonanotime()
 		}
 		// switch to g0, call gc, then switch back
-		mp.scalararg[0] = uint(startTime)
+		mp.scalararg[0] = uint(uint32(startTime)) // low 32 bits
+		mp.scalararg[1] = uint(startTime >> 32)   // high 32 bits
 		if force >= 2 {
-			mp.scalararg[1] = 1 // eagersweep
+			mp.scalararg[2] = 1 // eagersweep
 		} else {
-			mp.scalararg[1] = 0
+			mp.scalararg[2] = 0
 		}
 		onM(&gc_m)
 	}
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 3583d77d19..60a6181fc9 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1401,8 +1401,8 @@ runtime·gc_m(void)
 	gp->status = Gwaiting;
 	gp->waitreason = "garbage collection";
 
-	a.start_time = g->m->scalararg[0];
-	a.eagersweep = g->m->scalararg[1];
+	a.start_time = (uint64)(g->m->scalararg[0]) | ((uint64)(g->m->scalararg[1]) << 32);
+	a.eagersweep = g->m->scalararg[2];
 	gc(&a);
 
 	gp->status = Grunning;

From 9198ed4bd6ec7b7dd37aa2797e96f15ddbb1e6cd Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 14:24:03 +0400
Subject: [PATCH 127/423] runtime: allow copying of onM frame Currently
 goroutines in onM can't be copied/shrunk (including the very goroutine that
 triggers GC). Special case onM to allow copying.

LGTM=daniel.morsing, khr
R=golang-codereviews, daniel.morsing, khr, rsc
CC=golang-codereviews, rlh
https://golang.org/cl/124550043
---
 src/pkg/runtime/stack.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index f7d41f44d4..f21d544f33 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -399,6 +399,7 @@ struct CopyableInfo {
 };
 
 void runtime·main(void);
+void runtime·switchtoM(void(*)(void));
 
 static bool
 checkframecopy(Stkframe *frame, void *arg)
@@ -424,6 +425,13 @@ checkframecopy(Stkframe *frame, void *arg)
 		cinfo->frames++;
 		return false; // stop traceback
 	}
+	if(f->entry == (uintptr)runtime·switchtoM) {
+		// A special routine at the bottom of stack of a goroutine that does onM call.
+		// We will allow it to be copied even though we don't
+		// have full GC info for it (because it is written in asm).
+		cinfo->frames++;
+		return true;
+	}
 	if(frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil) {
@@ -648,7 +656,8 @@ adjustframe(Stkframe *frame, void *arg)
 	f = frame->fn;
 	if(StackDebug >= 2)
 		runtime·printf("    adjusting %s frame=[%p,%p] pc=%p continpc=%p\n", runtime·funcname(f), frame->sp, frame->fp, frame->pc, frame->continpc);
-	if(f->entry == (uintptr)runtime·main)
+	if(f->entry == (uintptr)runtime·main ||
+		f->entry == (uintptr)runtime·switchtoM)
 		return true;
 	targetpc = frame->continpc;
 	if(targetpc == 0) {

From fb44fb6cb7fdadced51db03403b9f5d93fefa5a5 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 15:59:42 +0400
Subject: [PATCH 128/423] runtime: always pass type to mallocgc when allocating
 scannable memory We allocate scannable memory w/o type only in few places in
 runtime. All these cases are not-performance critical (e.g. G or finq args
 buffer), and in long term they all need to go away. It's not worth it to have
 special code for this case in mallocgc. So use special fake "notype" type for
 such allocations.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/127450044
---
 src/pkg/runtime/malloc.c  |  9 ++++
 src/pkg/runtime/malloc.go | 88 +++++++++++++++++----------------------
 src/pkg/runtime/mgc0.go   |  9 ++++
 3 files changed, 57 insertions(+), 49 deletions(-)

diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index f4143669e7..ca8ebf5dd6 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -21,7 +21,10 @@ MHeap runtime·mheap;
 #pragma dataflag NOPTR
 MStats runtime·memstats;
 
+static Type* notype;
+
 void runtime·cmallocgc(uintptr size, Type *typ, uint32 flag, void **ret);
+void runtime·gc_notype_ptr(Eface*);
 
 void*
 runtime·mallocgc(uintptr size, Type *typ, uint32 flag)
@@ -31,6 +34,8 @@ runtime·mallocgc(uintptr size, Type *typ, uint32 flag)
 	// Call into the Go version of mallocgc.
 	// TODO: maybe someday we can get rid of this.  It is
 	// probably the only location where we run Go code on the M stack.
+	if((flag&FlagNoScan) == 0 && typ == nil)
+		typ = notype;
 	runtime·cmallocgc(size, typ, flag, &ret);
 	return ret;
 }
@@ -124,6 +129,7 @@ runtime·mallocinit(void)
 	uintptr limit;
 	uint64 i;
 	bool reserved;
+	Eface notype_eface;
 
 	p = nil;
 	p_size = 0;
@@ -251,6 +257,9 @@ runtime·mallocinit(void)
 	// Initialize the rest of the allocator.	
 	runtime·MHeap_Init(&runtime·mheap);
 	g->m->mcache = runtime·allocmcache();
+
+	runtime·gc_notype_ptr(&notype_eface);
+	notype = notype_eface.type;
 }
 
 void*
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 84c69abde7..152b3b6b68 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -225,66 +225,56 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			*xbits |= (bitsPointer << 2) << shift
 			goto marked
 		}
-		if typ != nil && (uintptr(typ.gc[0])|uintptr(typ.gc[1])) != 0 && uintptr(typ.size) > ptrSize {
-			if typ.kind&kindGCProg != 0 {
-				nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
-				masksize := nptr
-				if masksize%2 != 0 {
-					masksize *= 2 // repeated
-				}
-				masksize = masksize * pointersPerByte / 8 // 4 bits per word
-				masksize++                                // unroll flag in the beginning
-				if masksize > maxGCMask && typ.gc[1] != 0 {
-					// If the mask is too large, unroll the program directly
-					// into the GC bitmap. It's 7 times slower than copying
-					// from the pre-unrolled mask, but saves 1/16 of type size
-					// memory for the mask.
-					mp := acquirem()
-					mp.ptrarg[0] = x
-					mp.ptrarg[1] = unsafe.Pointer(typ)
-					mp.scalararg[0] = uint(size)
-					mp.scalararg[1] = uint(size0)
-					onM(&unrollgcproginplace_m)
-					releasem(mp)
-					goto marked
-				}
-				ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
-				// Check whether the program is already unrolled.
-				if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
-					mp := acquirem()
-					mp.ptrarg[0] = unsafe.Pointer(typ)
-					onM(&unrollgcprog_m)
-					releasem(mp)
-				}
-				ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
-			} else {
-				ptrmask = (*uint8)(unsafe.Pointer(&typ.gc[0])) // embed mask
+		if typ.kind&kindGCProg != 0 {
+			nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
+			masksize := nptr
+			if masksize%2 != 0 {
+				masksize *= 2 // repeated
 			}
-			if size == 2*ptrSize {
-				xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-				*xbitsb = *ptrmask | bitBoundary
+			masksize = masksize * pointersPerByte / 8 // 4 bits per word
+			masksize++                                // unroll flag in the beginning
+			if masksize > maxGCMask && typ.gc[1] != 0 {
+				// If the mask is too large, unroll the program directly
+				// into the GC bitmap. It's 7 times slower than copying
+				// from the pre-unrolled mask, but saves 1/16 of type size
+				// memory for the mask.
+				mp := acquirem()
+				mp.ptrarg[0] = x
+				mp.ptrarg[1] = unsafe.Pointer(typ)
+				mp.scalararg[0] = uint(size)
+				mp.scalararg[1] = uint(size0)
+				onM(&unrollgcproginplace_m)
+				releasem(mp)
 				goto marked
 			}
-			te = uintptr(typ.size) / ptrSize
-			// If the type occupies odd number of words, its mask is repeated.
-			if te%2 == 0 {
-				te /= 2
+			ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
+			// Check whether the program is already unrolled.
+			if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
+				mp := acquirem()
+				mp.ptrarg[0] = unsafe.Pointer(typ)
+				onM(&unrollgcprog_m)
+				releasem(mp)
 			}
+			ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
+		} else {
+			ptrmask = (*uint8)(unsafe.Pointer(&typ.gc[0])) // embed mask
 		}
 		if size == 2*ptrSize {
 			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = (bitsPointer << 2) | (bitsPointer << 6) | bitBoundary
+			*xbitsb = *ptrmask | bitBoundary
 			goto marked
 		}
+		te = uintptr(typ.size) / ptrSize
+		// If the type occupies odd number of words, its mask is repeated.
+		if te%2 == 0 {
+			te /= 2
+		}
 		// Copy pointer bitmask into the bitmap.
 		for i := uintptr(0); i < size0; i += 2 * ptrSize {
-			v := uint8((bitsPointer << 2) | (bitsPointer << 6))
-			if ptrmask != nil {
-				v = *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
-				ti++
-				if ti == te {
-					ti = 0
-				}
+			v := *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
+			ti++
+			if ti == te {
+				ti = 0
 			}
 			if i == 0 {
 				v |= bitBoundary
diff --git a/src/pkg/runtime/mgc0.go b/src/pkg/runtime/mgc0.go
index 624485d18b..496725f6a7 100644
--- a/src/pkg/runtime/mgc0.go
+++ b/src/pkg/runtime/mgc0.go
@@ -19,6 +19,15 @@ func gc_itab_ptr(ret *interface{}) {
 	*ret = (*itab)(nil)
 }
 
+// Type used for "conservative" allocations in C code.
+type notype [8]*byte
+
+// Called from C. Returns the Go type used for C allocations w/o type.
+func gc_notype_ptr(ret *interface{}) {
+	var x notype
+	*ret = x
+}
+
 func timenow() (sec int64, nsec int32)
 
 func gc_unixnanotime(now *int64) {

From ff3fa1b32dba4448bed45282b1038a4f8e9c23dc Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 17:38:00 +0400
Subject: [PATCH 129/423] runtime: make the GC bitmap a byte array Half the
 code in the garbage collector accesses the bitmap as an array of bytes
 instead of as an array of uintptrs. This is tricky to do correctly in a
 portable fashion, it breaks on big-endian systems. Make the bitmap a byte
 array. Simplifies markallocated, scanblock and span sweep along the way, as
 we don't need to recalculate bitmap position for each word.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/125250043
---
 src/pkg/runtime/asm_386.s    |   8 ++
 src/pkg/runtime/asm_amd64.s  |   8 ++
 src/pkg/runtime/atomic_arm.c |  16 +++
 src/pkg/runtime/heapdump.c   |  11 +-
 src/pkg/runtime/malloc.go    |  22 ++--
 src/pkg/runtime/mgc0.c       | 225 +++++++++++++++++++----------------
 src/pkg/runtime/mgc0.h       |   2 +-
 src/pkg/runtime/runtime.h    |   1 +
 8 files changed, 168 insertions(+), 125 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 0607bc8021..16e3f3136a 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -619,6 +619,14 @@ TEXT runtime·atomicstore64(SB), NOSPLIT, $0-12
 	XADDL	AX, (SP)
 	RET
 
+// void	runtime·atomicor8(byte volatile*, byte);
+TEXT runtime·atomicor8(SB), NOSPLIT, $0-8
+	MOVL	ptr+0(FP), AX
+	MOVB	val+4(FP), BX
+	LOCK
+	ORB	BX, (AX)
+	RET
+
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. pop the caller
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index d94df0bf8d..6446b5d832 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -702,6 +702,14 @@ TEXT runtime·atomicstore64(SB), NOSPLIT, $0-16
 	XCHGQ	AX, 0(BX)
 	RET
 
+// void	runtime·atomicor8(byte volatile*, byte);
+TEXT runtime·atomicor8(SB), NOSPLIT, $0-16
+	MOVQ	ptr+0(FP), AX
+	MOVB	val+8(FP), BX
+	LOCK
+	ORB	BX, (AX)
+	RET
+
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. pop the caller
diff --git a/src/pkg/runtime/atomic_arm.c b/src/pkg/runtime/atomic_arm.c
index d914475c7f..537bf18331 100644
--- a/src/pkg/runtime/atomic_arm.c
+++ b/src/pkg/runtime/atomic_arm.c
@@ -167,3 +167,19 @@ runtime·atomicstore64(uint64 volatile *addr, uint64 v)
 	*addr = v;
 	runtime·unlock(LOCK(addr));
 }
+
+#pragma textflag NOSPLIT
+void
+runtime·atomicor8(byte volatile *addr, byte v)
+{
+	uint32 *addr32, old, word, shift;
+
+	// Align down to 4 bytes and use 32-bit CAS.
+	addr32 = (uint32*)((uintptr)addr & ~3);
+	word = ((uint32)v) << (((uintptr)addr & 3) * 8);
+	for(;;) {
+		old = *addr32;
+		if(runtime·cas(addr32, old, old|word))
+			break;
+	}
+}
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index babb32fe5a..63d80b8d0e 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -820,7 +820,8 @@ dumpbvtypes(BitVector *bv, byte *base)
 static BitVector
 makeheapobjbv(byte *p, uintptr size)
 {
-	uintptr off, shift, *bitp, bits, nptr, i;
+	uintptr off, nptr, i;
+	byte shift, *bitp, bits;
 	bool mw;
 
 	// Extend the temp buffer if necessary.
@@ -838,13 +839,13 @@ makeheapobjbv(byte *p, uintptr size)
 	mw = false;
 	for(i = 0; i < nptr; i++) {
 		off = (uintptr*)(p + i*PtrSize) - (uintptr*)runtime·mheap.arena_start;
-		bitp = (uintptr*)runtime·mheap.arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
-		bits = (*bitp >> (shift + 2)) & 3;
+		bitp = runtime·mheap.arena_start - off/wordsPerBitmapByte - 1;
+		shift = (off % wordsPerBitmapByte) * gcBits;
+		bits = (*bitp >> (shift + 2)) & BitsMask;
 		if(!mw && bits == BitsDead)
 			break;  // end of heap object
 		mw = !mw && bits == BitsMultiWord;
-		tmpbuf[i*BitsPerPointer/8] &= ~(3<<((i*BitsPerPointer)%8));
+		tmpbuf[i*BitsPerPointer/8] &= ~(BitsMask<<((i*BitsPerPointer)%8));
 		tmpbuf[i*BitsPerPointer/8] |= bits<<((i*BitsPerPointer)%8);
 	}
 	return (BitVector){i*BitsPerPointer, (uint32*)tmpbuf};
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 152b3b6b68..8ee460755f 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -22,8 +22,8 @@ const (
 	pageSize  = 1 << pageShift
 	pageMask  = pageSize - 1
 
-	wordsPerBitmapWord = ptrSize * 8 / 4
 	gcBits             = 4
+	wordsPerBitmapByte = 8 / gcBits
 	bitsPerPointer     = 2
 	bitsMask           = 1<<bitsPerPointer - 1
 	pointersPerByte    = 8 / bitsPerPointer
@@ -211,8 +211,8 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 	{
 		arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
 		off := (uintptr(x) - arena_start) / ptrSize
-		xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
-		shift := (off % wordsPerBitmapWord) * gcBits
+		xbits := (*uint8)(unsafe.Pointer(arena_start - off/wordsPerBitmapByte - 1))
+		shift := (off % wordsPerBitmapByte) * gcBits
 		if debugMalloc && ((*xbits>>shift)&(bitMask|bitPtrMask)) != bitBoundary {
 			println("runtime: bits =", (*xbits>>shift)&(bitMask|bitPtrMask))
 			gothrow("bad bits in markallocated")
@@ -260,8 +260,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			ptrmask = (*uint8)(unsafe.Pointer(&typ.gc[0])) // embed mask
 		}
 		if size == 2*ptrSize {
-			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = *ptrmask | bitBoundary
+			*xbits = *ptrmask | bitBoundary
 			goto marked
 		}
 		te = uintptr(typ.size) / ptrSize
@@ -283,19 +282,12 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 				v &^= uint8(bitPtrMask << 4)
 			}
 
-			off := (uintptr(x) + i - arena_start) / ptrSize
-			xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
-			shift := (off % wordsPerBitmapWord) * gcBits
-			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = v
+			*xbits = v
+			xbits = (*byte)(add(unsafe.Pointer(xbits), ^uintptr(0)))
 		}
 		if size0%(2*ptrSize) == 0 && size0 < size {
 			// Mark the word after last object's word as bitsDead.
-			off := (uintptr(x) + size0 - arena_start) / ptrSize
-			xbits := (*uintptr)(unsafe.Pointer(arena_start - off/wordsPerBitmapWord*ptrSize - ptrSize))
-			shift := (off % wordsPerBitmapWord) * gcBits
-			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = bitsDead << 2
+			*xbits = bitsDead << 2
 		}
 	}
 marked:
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 60a6181fc9..14743c2838 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -212,8 +212,8 @@ static struct {
 static void
 scanblock(byte *b, uintptr n, byte *ptrmask)
 {
-	byte *obj, *p, *arena_start, *arena_used, **wp, *scanbuf[8], bits8;
-	uintptr i, nobj, size, idx, *bitp, bits, xbits, shift, x, off, cached, scanbufpos;
+	byte *obj, *p, *arena_start, *arena_used, **wp, *scanbuf[8], *ptrbitp, *bitp, bits, xbits, shift, cached;
+	uintptr i, nobj, size, idx, x, off, scanbufpos;
 	intptr ncached;
 	Workbuf *wbuf;
 	String *str;
@@ -237,6 +237,10 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 	for(i = 0; i < nelem(scanbuf); i++)
 		scanbuf[i] = nil;
 
+	ptrbitp = nil;
+	cached = 0;
+	ncached = 0;
+
 	// ptrmask can have 3 possible values:
 	// 1. nil - obtain pointer mask from GC bitmap.
 	// 2. ScanConservatively - don't use any mask, scan conservatively.
@@ -295,8 +299,15 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 			}
 			ptrmask = ScanConservatively;
 		}
-		cached = 0;
-		ncached = 0;
+		// Find bits of the beginning of the object.
+		if(ptrmask == nil) {
+			off = (uintptr*)b - (uintptr*)arena_start;
+			ptrbitp = arena_start - off/wordsPerBitmapByte - 1;
+			shift = (off % wordsPerBitmapByte) * gcBits;
+			cached = *ptrbitp >> shift;
+			cached &= ~bitBoundary;
+			ncached = (8 - shift)/gcBits;
+		}
 		for(i = 0; i < n; i += PtrSize) {
 			obj = nil;
 			// Find bits for this word.
@@ -308,16 +319,13 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				// Consult GC bitmap.
 				if(ncached <= 0) {
 					// Refill cache.
-					off = (uintptr*)(b+i) - (uintptr*)arena_start;
-					bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-					shift = (off % wordsPerBitmapWord) * gcBits;
-					cached = *bitp >> shift;
-					ncached = (PtrSize*8 - shift)/gcBits;
+					cached = *--ptrbitp;
+					ncached = 2;
 				}
 				bits = cached;
 				cached >>= gcBits;
 				ncached--;
-				if(i != 0 && (bits&bitBoundary) != 0)
+				if((bits&bitBoundary) != 0)
 					break; // reached beginning of the next object
 				bits = (bits>>2)&BitsMask;
 				if(bits == BitsDead)
@@ -336,11 +344,9 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 			// Find the next pair of bits.
 			if(ptrmask == nil) {
 				if(ncached <= 0) {
-					off = (uintptr*)(b+i+PtrSize) - (uintptr*)arena_start;
-					bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-					shift = (off % wordsPerBitmapWord) * gcBits;
-					cached = *bitp >> shift;
-					ncached = (PtrSize*8 - shift)/gcBits;
+					// Refill cache.
+					cached = *--ptrbitp;
+					ncached = 2;
 				}
 				bits = (cached>>2)&BitsMask;
 			} else
@@ -383,8 +389,14 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 
 			if(bits == BitsSlice) {
 				i += 2*PtrSize;
-				cached >>= 2*gcBits;
-				ncached -= 2;
+				if(ncached == 2)
+					ncached = 0;
+				else if(ptrmask == nil) {
+					// Refill cache and consume one quadruple.
+					cached = *--ptrbitp;
+					cached >>= gcBits;
+					ncached = 1;
+				}
 			} else {
 				i += PtrSize;
 				cached >>= gcBits;
@@ -398,20 +410,12 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				continue;
 			// Mark the object.
 			off = (uintptr*)obj - (uintptr*)arena_start;
-			bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-			shift = (off % wordsPerBitmapWord) * gcBits;
+			bitp = arena_start - off/wordsPerBitmapByte - 1;
+			shift = (off % wordsPerBitmapByte) * gcBits;
 			xbits = *bitp;
 			bits = (xbits >> shift) & bitMask;
 			if((bits&bitBoundary) == 0) {
-				// Not a beginning of a block, check if we have block boundary in xbits.
-				while(shift > 0) {
-					obj -= PtrSize;
-					shift -= gcBits;
-					bits = (xbits >> shift) & bitMask;
-					if((bits&bitBoundary) != 0)
-						goto havebits;
-				}
-				// Otherwise consult span table to find the block beginning.
+				// Not a beginning of a block, consult span table to find the block beginning.
 				k = (uintptr)obj>>PageShift;
 				x = k;
 				x -= (uintptr)arena_start>>PageShift;
@@ -433,7 +437,6 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				goto markobj;
 			}
 
-		havebits:
 			// Now we have bits, bitp, and shift correct for
 			// obj pointing at the base of the object.
 			// Only care about not marked objects.
@@ -449,22 +452,12 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 			// For 8-byte objects we use non-atomic store, if the other
 			// quadruple is already marked. Otherwise we resort to CAS
 			// loop for marking.
-			bits8 = xbits>>(shift&~7);
-			if((bits8&(bitMask|(bitMask<<gcBits))) != (bitBoundary|(bitBoundary<<gcBits)) ||
+			if((xbits&(bitMask|(bitMask<<gcBits))) != (bitBoundary|(bitBoundary<<gcBits)) ||
 				work.nproc == 1)
-				((uint8*)bitp)[shift/8] = bits8 | (bitMarked<<(shift&7));
-			else {
-				for(;;) {
-					if(runtime·casp((void**)bitp, (void*)xbits, (void*)(xbits|(bitMarked<<shift))))
-						break;
-					xbits = *bitp;
-					bits = (xbits>>shift) & bitMask;
-					if((bits&bitMarked) != 0)
-						break;
-				}
-				if((bits&bitMarked) != 0)
-					continue;
-			}
+				*bitp = xbits | (bitMarked<<shift);
+			else
+				runtime·atomicor8(bitp, bitMarked<<shift);
+
 			if(((xbits>>(shift+2))&BitsMask) == BitsDead)
 				continue;  // noscan object
 
@@ -901,9 +894,9 @@ bool
 runtime·MSpan_Sweep(MSpan *s, bool preserve)
 {
 	int32 cl, n, npages, nfree;
-	uintptr size, off, *bitp, shift, xbits, bits;
+	uintptr size, off, step;
 	uint32 sweepgen;
-	byte *p;
+	byte *p, *bitp, shift, xbits, bits;
 	MCache *c;
 	byte *arena_start;
 	MLink head, *end, *link;
@@ -939,8 +932,8 @@ runtime·MSpan_Sweep(MSpan *s, bool preserve)
 	// Mark any free objects in this span so we don't collect them.
 	for(link = s->freelist; link != nil; link = link->next) {
 		off = (uintptr*)link - (uintptr*)arena_start;
-		bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
+		bitp = arena_start - off/wordsPerBitmapByte - 1;
+		shift = (off % wordsPerBitmapByte) * gcBits;
 		*bitp |= bitMarked<<shift;
 	}
 
@@ -951,8 +944,8 @@ runtime·MSpan_Sweep(MSpan *s, bool preserve)
 		// A finalizer can be set for an inner byte of an object, find object beginning.
 		p = (byte*)(s->start << PageShift) + special->offset/size*size;
 		off = (uintptr*)p - (uintptr*)arena_start;
-		bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
+		bitp = arena_start - off/wordsPerBitmapByte - 1;
+		shift = (off % wordsPerBitmapByte) * gcBits;
 		bits = (*bitp>>shift) & bitMask;
 		if((bits&bitMarked) == 0) {
 			// Find the exact byte for which the special was setup
@@ -977,10 +970,27 @@ runtime·MSpan_Sweep(MSpan *s, bool preserve)
 	// This thread owns the span now, so it can manipulate
 	// the block bitmap without atomic operations.
 	p = (byte*)(s->start << PageShift);
+	// Find bits for the beginning of the span.
+	off = (uintptr*)p - (uintptr*)arena_start;
+	bitp = arena_start - off/wordsPerBitmapByte - 1;
+	shift = 0;
+	step = size/(PtrSize*wordsPerBitmapByte);
+	// Rewind to the previous quadruple as we move to the next
+	// in the beginning of the loop.
+	bitp += step;
+	if(step == 0) {
+		// 8-byte objects.
+		bitp++;
+		shift = gcBits;
+	}
 	for(; n > 0; n--, p += size) {
-		off = (uintptr*)p - (uintptr*)arena_start;
-		bitp = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
+		bitp -= step;
+		if(step == 0) {
+			if(shift != 0)
+				bitp--;
+			shift = gcBits - shift;
+		}
+
 		xbits = *bitp;
 		bits = (xbits>>shift) & bitMask;
 
@@ -1759,8 +1769,8 @@ runtime·wakefing(void)
 static byte*
 unrollgcprog1(byte *mask, byte *prog, uintptr *ppos, bool inplace, bool sparse)
 {
-	uintptr *b, off, shift, pos, siz, i;
-	byte *arena_start, *prog1, v;
+	uintptr pos, siz, i, off;
+	byte *arena_start, *prog1, v, *bitp, shift;
 
 	arena_start = runtime·mheap.arena_start;
 	pos = *ppos;
@@ -1777,11 +1787,11 @@ unrollgcprog1(byte *mask, byte *prog, uintptr *ppos, bool inplace, bool sparse)
 				if(inplace) {
 					// Store directly into GC bitmap.
 					off = (uintptr*)(mask+pos) - (uintptr*)arena_start;
-					b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-					shift = (off % wordsPerBitmapWord) * gcBits;
-					if((shift%8)==0)
-						((byte*)b)[shift/8] = 0;
-					((byte*)b)[shift/8] |= v<<((shift%8)+2);
+					bitp = arena_start - off/wordsPerBitmapByte - 1;
+					shift = (off % wordsPerBitmapByte) * gcBits;
+					if(shift==0)
+						*bitp = 0;
+					*bitp |= v<<(shift+2);
 					pos += PtrSize;
 				} else if(sparse) {
 					// 4-bits per word
@@ -1847,8 +1857,8 @@ unrollglobgcprog(byte *prog, uintptr size)
 void
 runtime·unrollgcproginplace_m(void)
 {
-	uintptr size, size0, *b, off, shift, pos;
-	byte *arena_start, *prog;
+	uintptr size, size0, pos, off;
+	byte *arena_start, *prog, *bitp, shift;
 	Type *typ;
 	void *v;
 
@@ -1866,15 +1876,15 @@ runtime·unrollgcproginplace_m(void)
 	// Mark first word as bitAllocated.
 	arena_start = runtime·mheap.arena_start;
 	off = (uintptr*)v - (uintptr*)arena_start;
-	b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-	shift = (off % wordsPerBitmapWord) * gcBits;
-	*b |= bitBoundary<<shift;
+	bitp = arena_start - off/wordsPerBitmapByte - 1;
+	shift = (off % wordsPerBitmapByte) * gcBits;
+	*bitp |= bitBoundary<<shift;
 	// Mark word after last as BitsDead.
 	if(size0 < size) {
 		off = (uintptr*)((byte*)v + size0) - (uintptr*)arena_start;
-		b = (uintptr*)arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
-		*b &= ~(bitPtrMask<<shift) | ((uintptr)BitsDead<<(shift+2));
+		bitp = arena_start - off/wordsPerBitmapByte - 1;
+		shift = (off % wordsPerBitmapByte) * gcBits;
+		*bitp &= ~(bitPtrMask<<shift) | ((uintptr)BitsDead<<(shift+2));
 	}
 }
 
@@ -1916,60 +1926,67 @@ runtime·unrollgcprog_m(void)
 void
 runtime·markspan(void *v, uintptr size, uintptr n, bool leftover)
 {
-	uintptr *b, *b0, off, shift, x;
-	byte *p;
+	uintptr i, off, step;
+	byte *b;
 
 	if((byte*)v+size*n > (byte*)runtime·mheap.arena_used || (byte*)v < runtime·mheap.arena_start)
 		runtime·throw("markspan: bad pointer");
 
-	p = v;
-	if(leftover)	// mark a boundary just past end of last block too
-		n++;
+	// Find bits of the beginning of the span.
+	off = (uintptr*)v - (uintptr*)runtime·mheap.arena_start;  // word offset
+	b = runtime·mheap.arena_start - off/wordsPerBitmapByte - 1;
+	if((off%wordsPerBitmapByte) != 0)
+		runtime·throw("markspan: unaligned length");
 
-	b0 = nil;
-	x = 0;
-	for(; n-- > 0; p += size) {
-		// Okay to use non-atomic ops here, because we control
-		// the entire span, and each bitmap word has bits for only
-		// one span, so no other goroutines are changing these
-		// bitmap words.
-		off = (uintptr*)p - (uintptr*)runtime·mheap.arena_start;  // word offset
-		b = (uintptr*)runtime·mheap.arena_start - off/wordsPerBitmapWord - 1;
-		shift = (off % wordsPerBitmapWord) * gcBits;
-		if(b0 != b) {
-			if(b0 != nil)
-				*b0 = x;
-			b0 = b;
-			x = 0;
-		}
-		x |= (bitBoundary<<shift) | ((uintptr)BitsDead<<(shift+2));
+	// Okay to use non-atomic ops here, because we control
+	// the entire span, and each bitmap byte has bits for only
+	// one span, so no other goroutines are changing these bitmap words.
+
+	if(size == PtrSize) {
+		// Possible only on 64-bits (minimal size class is 8 bytes).
+		// Poor man's memset(0x11).
+		if(0x11 != ((bitBoundary+BitsDead)<<gcBits) + (bitBoundary+BitsDead))
+			runtime·throw("markspan: bad bits");
+		if((n%(wordsPerBitmapByte*PtrSize)) != 0)
+			runtime·throw("markspan: unaligned length");
+		b = b - n/wordsPerBitmapByte + 1;	// find first byte
+		if(((uintptr)b%PtrSize) != 0)
+			runtime·throw("markspan: unaligned pointer");
+		for(i = 0; i != n; i += wordsPerBitmapByte*PtrSize, b += PtrSize)
+			*(uintptr*)b = (uintptr)0x1111111111111111ULL;  // bitBoundary+BitsDead
+		return;
 	}
-	*b0 = x;
+
+	if(leftover)
+		n++;	// mark a boundary just past end of last block too
+	step = size/(PtrSize*wordsPerBitmapByte);
+	for(i = 0; i != n; i++, b -= step)
+		*b = bitBoundary|(BitsDead<<2);
 }
 
 // unmark the span of memory at v of length n bytes.
 void
 runtime·unmarkspan(void *v, uintptr n)
 {
-	uintptr *p, *b, off;
+	uintptr off;
+	byte *b;
 
 	if((byte*)v+n > (byte*)runtime·mheap.arena_used || (byte*)v < runtime·mheap.arena_start)
 		runtime·throw("markspan: bad pointer");
 
-	p = v;
-	off = p - (uintptr*)runtime·mheap.arena_start;  // word offset
-	if((off % wordsPerBitmapWord) != 0)
+	off = (uintptr*)v - (uintptr*)runtime·mheap.arena_start;  // word offset
+	if((off % (PtrSize*wordsPerBitmapByte)) != 0)
 		runtime·throw("markspan: unaligned pointer");
-	b = (uintptr*)runtime·mheap.arena_start - off/wordsPerBitmapWord - 1;
+	b = runtime·mheap.arena_start - off/wordsPerBitmapByte - 1;
 	n /= PtrSize;
-	if(n%wordsPerBitmapWord != 0)
+	if(n%(PtrSize*wordsPerBitmapByte) != 0)
 		runtime·throw("unmarkspan: unaligned length");
 	// Okay to use non-atomic ops here, because we control
 	// the entire span, and each bitmap word has bits for only
 	// one span, so no other goroutines are changing these
 	// bitmap words.
-	n /= wordsPerBitmapWord;
-	runtime·memclr((byte*)(b - n + 1), n*PtrSize);
+	n /= wordsPerBitmapByte;
+	runtime·memclr(b - n + 1, n);
 }
 
 void
@@ -1983,7 +2000,7 @@ runtime·MHeap_MapBits(MHeap *h)
 	};
 	uintptr n;
 
-	n = (h->arena_used - h->arena_start) / wordsPerBitmapWord;
+	n = (h->arena_used - h->arena_start) / (PtrSize*wordsPerBitmapByte);
 	n = ROUND(n, bitmapChunk);
 	n = ROUND(n, PhysPageSize);
 	if(h->bitmap_mapped >= n)
@@ -2011,8 +2028,8 @@ void
 runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 {
 	Stkframe frame;
-	uintptr i, n, off, bits, shift, *b;
-	byte *base;
+	uintptr i, n, off;
+	byte *base, bits, shift, *b;
 
 	*mask = nil;
 	*len = 0;
@@ -2047,8 +2064,8 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
 			off = (uintptr*)(base+i) - (uintptr*)runtime·mheap.arena_start;
-			b = (uintptr*)runtime·mheap.arena_start - off/wordsPerBitmapWord - 1;
-			shift = (off % wordsPerBitmapWord) * gcBits;
+			b = runtime·mheap.arena_start - off/wordsPerBitmapByte - 1;
+			shift = (off % wordsPerBitmapByte) * gcBits;
 			bits = (*b >> (shift+2))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
diff --git a/src/pkg/runtime/mgc0.h b/src/pkg/runtime/mgc0.h
index 893819c128..7449398b9f 100644
--- a/src/pkg/runtime/mgc0.h
+++ b/src/pkg/runtime/mgc0.h
@@ -8,8 +8,8 @@ enum {
 	ScanStackByFrames = 1,
 
 	// Four bits per word (see #defines below).
-	wordsPerBitmapWord = sizeof(void*)*8/4,
 	gcBits = 4,
+	wordsPerBitmapByte = 8/gcBits,
 
 	// GC type info programs.
 	// The programs allow to store type info required for GC in a compact form.
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 0dc60b286b..867da3f46a 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -913,6 +913,7 @@ void	runtime·atomicstore64(uint64 volatile*, uint64);
 uint64	runtime·atomicload64(uint64 volatile*);
 void*	runtime·atomicloadp(void* volatile*);
 void	runtime·atomicstorep(void* volatile*, void*);
+void	runtime·atomicor8(byte volatile*, byte);
 
 void	runtime·setg(G*);
 void	runtime·newextram(void);

From c6442c994a1976a2fecd01af1d26c925eb03c8a1 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Tue, 19 Aug 2014 08:07:58 -0700
Subject: [PATCH 130/423] cmd/6a, cmd/8a: document AJxx condition codes

LGTM=ruiu, rsc
R=rsc, ruiu
CC=golang-codereviews
https://golang.org/cl/130870043
---
 src/cmd/6a/lex.c | 34 +++++++++++++++++-----------------
 src/cmd/8a/lex.c | 34 +++++++++++++++++-----------------
 2 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/cmd/6a/lex.c b/src/cmd/6a/lex.c
index 167e6b6c17..b50e1622e2 100644
--- a/src/cmd/6a/lex.c
+++ b/src/cmd/6a/lex.c
@@ -435,49 +435,49 @@ struct
 	"IRETQ",	LTYPE0,	AIRETQ,
 	"IRETW",	LTYPE0,	AIRETW,
 
-	"JOS",		LTYPER,	AJOS,
+	"JOS",		LTYPER,	AJOS,	/* overflow set (OF = 1) */
 	"JO",		LTYPER,	AJOS,	/* alternate */
-	"JOC",		LTYPER,	AJOC,
+	"JOC",		LTYPER,	AJOC,	/* overflow clear (OF = 0) */
 	"JNO",		LTYPER,	AJOC,	/* alternate */
-	"JCS",		LTYPER,	AJCS,
+	"JCS",		LTYPER,	AJCS,	/* carry set (CF = 1) */
 	"JB",		LTYPER,	AJCS,	/* alternate */
 	"JC",		LTYPER,	AJCS,	/* alternate */
 	"JNAE",		LTYPER,	AJCS,	/* alternate */
 	"JLO",		LTYPER,	AJCS,	/* alternate */
-	"JCC",		LTYPER,	AJCC,
+	"JCC",		LTYPER,	AJCC,	/* carry clear (CF = 0) */
 	"JAE",		LTYPER,	AJCC,	/* alternate */
 	"JNB",		LTYPER,	AJCC,	/* alternate */
 	"JNC",		LTYPER,	AJCC,	/* alternate */
 	"JHS",		LTYPER,	AJCC,	/* alternate */
-	"JEQ",		LTYPER,	AJEQ,
+	"JEQ",		LTYPER,	AJEQ,	/* equal (ZF = 1) */
 	"JE",		LTYPER,	AJEQ,	/* alternate */
 	"JZ",		LTYPER,	AJEQ,	/* alternate */
-	"JNE",		LTYPER,	AJNE,
+	"JNE",		LTYPER,	AJNE,	/* not equal (ZF = 0) */
 	"JNZ",		LTYPER,	AJNE,	/* alternate */
-	"JLS",		LTYPER,	AJLS,
+	"JLS",		LTYPER,	AJLS,	/* lower or same (unsigned) (CF = 1 || ZF = 1) */
 	"JBE",		LTYPER,	AJLS,	/* alternate */
 	"JNA",		LTYPER,	AJLS,	/* alternate */
-	"JHI",		LTYPER,	AJHI,
+	"JHI",		LTYPER,	AJHI,	/* higher (unsigned) (CF = 0 && ZF = 0) */
 	"JA",		LTYPER,	AJHI,	/* alternate */
 	"JNBE",		LTYPER,	AJHI,	/* alternate */
-	"JMI",		LTYPER,	AJMI,
+	"JMI",		LTYPER,	AJMI,	/* negative (minus) (SF = 1) */
 	"JS",		LTYPER,	AJMI,	/* alternate */
-	"JPL",		LTYPER,	AJPL,
+	"JPL",		LTYPER,	AJPL,	/* non-negative (plus) (SF = 0) */
 	"JNS",		LTYPER,	AJPL,	/* alternate */
-	"JPS",		LTYPER,	AJPS,
+	"JPS",		LTYPER,	AJPS,	/* parity set (PF = 1) */
 	"JP",		LTYPER,	AJPS,	/* alternate */
 	"JPE",		LTYPER,	AJPS,	/* alternate */
-	"JPC",		LTYPER,	AJPC,
+	"JPC",		LTYPER,	AJPC,	/* parity clear (PF = 0) */
 	"JNP",		LTYPER,	AJPC,	/* alternate */
 	"JPO",		LTYPER,	AJPC,	/* alternate */
-	"JLT",		LTYPER,	AJLT,
+	"JLT",		LTYPER,	AJLT,	/* less than (signed) (SF != OF) */
 	"JL",		LTYPER,	AJLT,	/* alternate */
 	"JNGE",		LTYPER,	AJLT,	/* alternate */
-	"JGE",		LTYPER,	AJGE,
+	"JGE",		LTYPER,	AJGE,	/* greater than or equal (signed) (SF = OF) */
 	"JNL",		LTYPER,	AJGE,	/* alternate */
-	"JLE",		LTYPER,	AJLE,
+	"JLE",		LTYPER,	AJLE,	/* less than or equal (signed) (ZF = 1 || SF != OF) */
 	"JNG",		LTYPER,	AJLE,	/* alternate */
-	"JGT",		LTYPER,	AJGT,
+	"JGT",		LTYPER,	AJGT,	/* greater than (signed) (ZF = 0 && SF = OF) */
 	"JG",		LTYPER,	AJGT,	/* alternate */
 	"JNLE",		LTYPER,	AJGT,	/* alternate */
 	"JCXZL",	LTYPER,	AJCXZL,
@@ -612,7 +612,7 @@ struct
 	"SCASL",	LTYPE0,	ASCASL,
 	"SCASQ",	LTYPE0,	ASCASQ,
 	"SCASW",	LTYPE0,	ASCASW,
-	"SETCC",	LTYPE1,	ASETCC,
+	"SETCC",	LTYPE1,	ASETCC,	/* see JCC etc above for condition codes */
 	"SETCS",	LTYPE1,	ASETCS,
 	"SETEQ",	LTYPE1,	ASETEQ,
 	"SETGE",	LTYPE1,	ASETGE,
diff --git a/src/cmd/8a/lex.c b/src/cmd/8a/lex.c
index 32c099b75a..807e48cb50 100644
--- a/src/cmd/8a/lex.c
+++ b/src/cmd/8a/lex.c
@@ -352,49 +352,49 @@ struct
 	"IRETL",	LTYPE0,	AIRETL,
 	"IRETW",	LTYPE0,	AIRETW,
 
-	"JOS",		LTYPER,	AJOS,
+	"JOS",		LTYPER,	AJOS,	/* overflow set (OF = 1) */
 	"JO",		LTYPER,	AJOS,	/* alternate */
-	"JOC",		LTYPER,	AJOC,
+	"JOC",		LTYPER,	AJOC,	/* overflow clear (OF = 0) */
 	"JNO",		LTYPER,	AJOC,	/* alternate */
-	"JCS",		LTYPER,	AJCS,
+	"JCS",		LTYPER,	AJCS,	/* carry set (CF = 1) */
 	"JB",		LTYPER,	AJCS,	/* alternate */
 	"JC",		LTYPER,	AJCS,	/* alternate */
 	"JNAE",		LTYPER,	AJCS,	/* alternate */
 	"JLO",		LTYPER,	AJCS,	/* alternate */
-	"JCC",		LTYPER,	AJCC,
+	"JCC",		LTYPER,	AJCC,	/* carry clear (CF = 0) */
 	"JAE",		LTYPER,	AJCC,	/* alternate */
 	"JNB",		LTYPER,	AJCC,	/* alternate */
 	"JNC",		LTYPER,	AJCC,	/* alternate */
 	"JHS",		LTYPER,	AJCC,	/* alternate */
-	"JEQ",		LTYPER,	AJEQ,
+	"JEQ",		LTYPER,	AJEQ,	/* equal (ZF = 1) */
 	"JE",		LTYPER,	AJEQ,	/* alternate */
 	"JZ",		LTYPER,	AJEQ,	/* alternate */
-	"JNE",		LTYPER,	AJNE,
+	"JNE",		LTYPER,	AJNE,	/* not equal (ZF = 0) */
 	"JNZ",		LTYPER,	AJNE,	/* alternate */
-	"JLS",		LTYPER,	AJLS,
+	"JLS",		LTYPER,	AJLS,	/* lower or same (unsigned) (CF = 1 || ZF = 1) */
 	"JBE",		LTYPER,	AJLS,	/* alternate */
 	"JNA",		LTYPER,	AJLS,	/* alternate */
-	"JHI",		LTYPER,	AJHI,
+	"JHI",		LTYPER,	AJHI,	/* higher (unsigned) (CF = 0 && ZF = 0) */
 	"JA",		LTYPER,	AJHI,	/* alternate */
 	"JNBE",		LTYPER,	AJHI,	/* alternate */
-	"JMI",		LTYPER,	AJMI,
+	"JMI",		LTYPER,	AJMI,	/* negative (minus) (SF = 1) */
 	"JS",		LTYPER,	AJMI,	/* alternate */
-	"JPL",		LTYPER,	AJPL,
+	"JPL",		LTYPER,	AJPL,	/* non-negative (plus) (SF = 0) */
 	"JNS",		LTYPER,	AJPL,	/* alternate */
-	"JPS",		LTYPER,	AJPS,
+	"JPS",		LTYPER,	AJPS,	/* parity set (PF = 1) */
 	"JP",		LTYPER,	AJPS,	/* alternate */
 	"JPE",		LTYPER,	AJPS,	/* alternate */
-	"JPC",		LTYPER,	AJPC,
+	"JPC",		LTYPER,	AJPC,	/* parity clear (PF = 0) */
 	"JNP",		LTYPER,	AJPC,	/* alternate */
 	"JPO",		LTYPER,	AJPC,	/* alternate */
-	"JLT",		LTYPER,	AJLT,
+	"JLT",		LTYPER,	AJLT,	/* less than (signed) (SF != OF) */
 	"JL",		LTYPER,	AJLT,	/* alternate */
 	"JNGE",		LTYPER,	AJLT,	/* alternate */
-	"JGE",		LTYPER,	AJGE,
+	"JGE",		LTYPER,	AJGE,	/* greater than or equal (signed) (SF = OF) */
 	"JNL",		LTYPER,	AJGE,	/* alternate */
-	"JLE",		LTYPER,	AJLE,
+	"JLE",		LTYPER,	AJLE,	/* less than or equal (signed) (ZF = 1 || SF != OF) */
 	"JNG",		LTYPER,	AJLE,	/* alternate */
-	"JGT",		LTYPER,	AJGT,
+	"JGT",		LTYPER,	AJGT,	/* greater than (signed) (ZF = 0 && SF = OF) */
 	"JG",		LTYPER,	AJGT,	/* alternate */
 	"JNLE",		LTYPER,	AJGT,	/* alternate */
 
@@ -493,7 +493,7 @@ struct
 	"SCASB",	LTYPE0,	ASCASB,
 	"SCASL",	LTYPE0,	ASCASL,
 	"SCASW",	LTYPE0,	ASCASW,
-	"SETCC",	LTYPE1,	ASETCC,
+	"SETCC",	LTYPE1,	ASETCC,	/* see JCC etc above for condition codes */
 	"SETCS",	LTYPE1,	ASETCS,
 	"SETEQ",	LTYPE1,	ASETEQ,
 	"SETGE",	LTYPE1,	ASETGE,

From 8c25e08fbdf3511394f5ea5fc69c3ff988a61a5a Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 19 Aug 2014 19:32:27 +0400
Subject: [PATCH 131/423] runtime: fix TestGcLastTime on windows Intended to
 fix: http://build.golang.org/log/d6718ea67541b8c6be2bb14bcbc4e1c4261f67d7

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews
https://golang.org/cl/127520043
---
 src/pkg/runtime/gc_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/gc_test.go b/src/pkg/runtime/gc_test.go
index 383af5be3d..816fc89b04 100644
--- a/src/pkg/runtime/gc_test.go
+++ b/src/pkg/runtime/gc_test.go
@@ -165,7 +165,8 @@ func TestGcLastTime(t *testing.T) {
 		t.Fatalf("bad last GC time: got %v, want [%v, %v]", last, t0, t1)
 	}
 	pause := ms.PauseNs[(ms.NumGC+255)%256]
-	if pause == 0 || pause > 10e9 {
+	// Due to timer granularity pause can actually be 0 on windows.
+	if (pause == 0 && runtime.GOOS != "windows") || pause > 10e9 {
 		t.Fatalf("bad last GC pause: got %v, want [0, 10e9]", pause)
 	}
 }

From 339a24da6611487308b497a2ba7506c5451c637f Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Tue, 19 Aug 2014 08:50:35 -0700
Subject: [PATCH 132/423] runtime: fix typo in comment

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/125500043
---
 src/pkg/runtime/asm_386.s      | 2 +-
 src/pkg/runtime/asm_amd64.s    | 2 +-
 src/pkg/runtime/asm_amd64p32.s | 2 +-
 src/pkg/runtime/asm_arm.s      | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 16e3f3136a..638d1c5134 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -1167,7 +1167,7 @@ TEXT runtime·memeq(SB),NOSPLIT,$0-13
 
 // eqstring tests whether two strings are equal.
 // See runtime_test.go:eqstring_generic for
-// equivlaent Go code.
+// equivalent Go code.
 TEXT runtime·eqstring(SB),NOSPLIT,$0-17
 	MOVL	s1len+4(FP), AX
 	MOVL	s2len+12(FP), BX
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 6446b5d832..87c23168f6 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -1140,7 +1140,7 @@ TEXT runtime·memeq(SB),NOSPLIT,$0-25
 
 // eqstring tests whether two strings are equal.
 // See runtime_test.go:eqstring_generic for
-// equivlaent Go code.
+// equivalent Go code.
 TEXT runtime·eqstring(SB),NOSPLIT,$0-33
 	MOVQ	s1len+8(FP), AX
 	MOVQ	s2len+24(FP), BX
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 69e050f90d..71ea4f385a 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -785,7 +785,7 @@ TEXT runtime·memeq(SB),NOSPLIT,$0-17
 
 // eqstring tests whether two strings are equal.
 // See runtime_test.go:eqstring_generic for
-// equivlaent Go code.
+// equivalent Go code.
 TEXT runtime·eqstring(SB),NOSPLIT,$0-17
 	MOVL	s1len+4(FP), AX
 	MOVL	s2len+12(FP), BX
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 324b27b18f..3e0b13e699 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -724,7 +724,7 @@ _next2:
 
 // eqstring tests whether two strings are equal.
 // See runtime_test.go:eqstring_generic for
-// equivlaent Go code.
+// equivalent Go code.
 TEXT runtime·eqstring(SB),NOSPLIT,$-4-17
 	MOVW	s1len+4(FP), R0
 	MOVW	s2len+12(FP), R1

From e38fa9164894b2610a41b335a56e3b6494a3cef6 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Tue, 19 Aug 2014 18:45:05 -0700
Subject: [PATCH 133/423] net/http: fix TimeoutHandler data races; hold lock
 longer

The existing lock needed to be held longer. If a timeout occured
while writing (but after the guarded timeout check), the writes
would clobber a future connection's buffer.

Also remove a harmless warning by making Write also set the
flag that headers were sent (implicitly), so we don't try to
write headers later (a no-op + warning) on timeout after we've
started writing.

Fixes #8414
Fixes #8209

LGTM=ruiu, adg
R=adg, ruiu
CC=golang-codereviews
https://golang.org/cl/123610043
---
 src/pkg/net/http/serve_test.go | 77 ++++++++++++++++++++++++++++++++++
 src/pkg/net/http/server.go     |  9 ++--
 2 files changed, 81 insertions(+), 5 deletions(-)

diff --git a/src/pkg/net/http/serve_test.go b/src/pkg/net/http/serve_test.go
index 2a3fc307be..ee4f204995 100644
--- a/src/pkg/net/http/serve_test.go
+++ b/src/pkg/net/http/serve_test.go
@@ -15,6 +15,7 @@ import (
 	"io"
 	"io/ioutil"
 	"log"
+	"math/rand"
 	"net"
 	. "net/http"
 	"net/http/httptest"
@@ -1188,6 +1189,82 @@ func TestTimeoutHandler(t *testing.T) {
 	}
 }
 
+// See issues 8209 and 8414.
+func TestTimeoutHandlerRace(t *testing.T) {
+	defer afterTest(t)
+
+	delayHi := HandlerFunc(func(w ResponseWriter, r *Request) {
+		ms, _ := strconv.Atoi(r.URL.Path[1:])
+		if ms == 0 {
+			ms = 1
+		}
+		for i := 0; i < ms; i++ {
+			w.Write([]byte("hi"))
+			time.Sleep(time.Millisecond)
+		}
+	})
+
+	ts := httptest.NewServer(TimeoutHandler(delayHi, 20*time.Millisecond, ""))
+	defer ts.Close()
+
+	var wg sync.WaitGroup
+	gate := make(chan bool, 10)
+	n := 50
+	if testing.Short() {
+		n = 10
+		gate = make(chan bool, 3)
+	}
+	for i := 0; i < n; i++ {
+		gate <- true
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-gate }()
+			res, err := Get(fmt.Sprintf("%s/%d", ts.URL, rand.Intn(50)))
+			if err == nil {
+				io.Copy(ioutil.Discard, res.Body)
+				res.Body.Close()
+			}
+		}()
+	}
+	wg.Wait()
+}
+
+// See issues 8209 and 8414.
+func TestTimeoutHandlerRaceHeader(t *testing.T) {
+	defer afterTest(t)
+
+	delay204 := HandlerFunc(func(w ResponseWriter, r *Request) {
+		w.WriteHeader(204)
+	})
+
+	ts := httptest.NewServer(TimeoutHandler(delay204, time.Nanosecond, ""))
+	defer ts.Close()
+
+	var wg sync.WaitGroup
+	gate := make(chan bool, 50)
+	n := 500
+	if testing.Short() {
+		n = 10
+	}
+	for i := 0; i < n; i++ {
+		gate <- true
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-gate }()
+			res, err := Get(ts.URL)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			defer res.Body.Close()
+			io.Copy(ioutil.Discard, res.Body)
+		}()
+	}
+	wg.Wait()
+}
+
 // Verifies we don't path.Clean() on the wrong parts in redirects.
 func TestRedirectMunging(t *testing.T) {
 	req, _ := NewRequest("GET", "http://example.com/", nil)
diff --git a/src/pkg/net/http/server.go b/src/pkg/net/http/server.go
index eae097eb8e..203037e9f5 100644
--- a/src/pkg/net/http/server.go
+++ b/src/pkg/net/http/server.go
@@ -1916,9 +1916,9 @@ func (tw *timeoutWriter) Header() Header {
 
 func (tw *timeoutWriter) Write(p []byte) (int, error) {
 	tw.mu.Lock()
-	timedOut := tw.timedOut
-	tw.mu.Unlock()
-	if timedOut {
+	defer tw.mu.Unlock()
+	tw.wroteHeader = true // implicitly at least
+	if tw.timedOut {
 		return 0, ErrHandlerTimeout
 	}
 	return tw.w.Write(p)
@@ -1926,12 +1926,11 @@ func (tw *timeoutWriter) Write(p []byte) (int, error) {
 
 func (tw *timeoutWriter) WriteHeader(code int) {
 	tw.mu.Lock()
+	defer tw.mu.Unlock()
 	if tw.timedOut || tw.wroteHeader {
-		tw.mu.Unlock()
 		return
 	}
 	tw.wroteHeader = true
-	tw.mu.Unlock()
 	tw.w.WriteHeader(code)
 }
 

From b95ed834801517f79f4d1c4331d765769f5e5360 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Wed, 20 Aug 2014 13:17:45 +1000
Subject: [PATCH 134/423] syscall: replace zsyscall_windows_*.go files with a
 single file

zsyscall_windows_386.go and zsyscall_windows_amd64.go contain same bytes

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/124640043
---
 src/pkg/syscall/mkall.sh                      |    2 +-
 src/pkg/syscall/mkall_windows.bat             |   10 +-
 ...all_windows_386.go => zsyscall_windows.go} |    0
 src/pkg/syscall/zsyscall_windows_amd64.go     | 1846 -----------------
 4 files changed, 3 insertions(+), 1855 deletions(-)
 rename src/pkg/syscall/{zsyscall_windows_386.go => zsyscall_windows.go} (100%)
 delete mode 100644 src/pkg/syscall/zsyscall_windows_amd64.go

diff --git a/src/pkg/syscall/mkall.sh b/src/pkg/syscall/mkall.sh
index 886db133cb..9cb82a608d 100755
--- a/src/pkg/syscall/mkall.sh
+++ b/src/pkg/syscall/mkall.sh
@@ -244,7 +244,7 @@ esac
 	case "$GOOS" in
 	windows)
 		echo "GOOS= GOARCH= go build mksyscall_windows.go"
-		echo "./mksyscall_windows syscall_windows.go security_windows.go syscall_$GOOSARCH.go |gofmt >zsyscall_$GOOSARCH.go"
+		echo "./mksyscall_windows syscall_windows.go security_windows.go |gofmt >zsyscall_windows.go"
 		echo "rm -f ./mksyscall_windows"
 		;;
 	*)
diff --git a/src/pkg/syscall/mkall_windows.bat b/src/pkg/syscall/mkall_windows.bat
index a4a3f16748..9c91a1064d 100644
--- a/src/pkg/syscall/mkall_windows.bat
+++ b/src/pkg/syscall/mkall_windows.bat
@@ -8,14 +8,8 @@ echo mkall_windows.bat must be run from src\pkg\syscall directory
 goto :end
 :dirok
 
-if "%1"=="386" goto :paramok
-if "%1"=="amd64" goto :paramok
-echo parameters must be 386 or amd64
-goto :end
-:paramok
-
 go build mksyscall_windows.go
-.\mksyscall_windows syscall_windows.go security_windows.go syscall_windows_%1.go |gofmt >zsyscall_windows_%1.go
+.\mksyscall_windows syscall_windows.go security_windows.go |gofmt >zsyscall_windows.go
 del mksyscall_windows.exe
 
-:end
\ No newline at end of file
+:end
diff --git a/src/pkg/syscall/zsyscall_windows_386.go b/src/pkg/syscall/zsyscall_windows.go
similarity index 100%
rename from src/pkg/syscall/zsyscall_windows_386.go
rename to src/pkg/syscall/zsyscall_windows.go
diff --git a/src/pkg/syscall/zsyscall_windows_amd64.go b/src/pkg/syscall/zsyscall_windows_amd64.go
deleted file mode 100644
index 1f44750b7f..0000000000
--- a/src/pkg/syscall/zsyscall_windows_amd64.go
+++ /dev/null
@@ -1,1846 +0,0 @@
-// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go
-// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package syscall
-
-import "unsafe"
-
-var (
-	modkernel32 = NewLazyDLL("kernel32.dll")
-	modadvapi32 = NewLazyDLL("advapi32.dll")
-	modshell32  = NewLazyDLL("shell32.dll")
-	modmswsock  = NewLazyDLL("mswsock.dll")
-	modcrypt32  = NewLazyDLL("crypt32.dll")
-	modws2_32   = NewLazyDLL("ws2_32.dll")
-	moddnsapi   = NewLazyDLL("dnsapi.dll")
-	modiphlpapi = NewLazyDLL("iphlpapi.dll")
-	modsecur32  = NewLazyDLL("secur32.dll")
-	modnetapi32 = NewLazyDLL("netapi32.dll")
-	moduserenv  = NewLazyDLL("userenv.dll")
-
-	procGetLastError                       = modkernel32.NewProc("GetLastError")
-	procLoadLibraryW                       = modkernel32.NewProc("LoadLibraryW")
-	procFreeLibrary                        = modkernel32.NewProc("FreeLibrary")
-	procGetProcAddress                     = modkernel32.NewProc("GetProcAddress")
-	procGetVersion                         = modkernel32.NewProc("GetVersion")
-	procFormatMessageW                     = modkernel32.NewProc("FormatMessageW")
-	procExitProcess                        = modkernel32.NewProc("ExitProcess")
-	procCreateFileW                        = modkernel32.NewProc("CreateFileW")
-	procReadFile                           = modkernel32.NewProc("ReadFile")
-	procWriteFile                          = modkernel32.NewProc("WriteFile")
-	procSetFilePointer                     = modkernel32.NewProc("SetFilePointer")
-	procCloseHandle                        = modkernel32.NewProc("CloseHandle")
-	procGetStdHandle                       = modkernel32.NewProc("GetStdHandle")
-	procFindFirstFileW                     = modkernel32.NewProc("FindFirstFileW")
-	procFindNextFileW                      = modkernel32.NewProc("FindNextFileW")
-	procFindClose                          = modkernel32.NewProc("FindClose")
-	procGetFileInformationByHandle         = modkernel32.NewProc("GetFileInformationByHandle")
-	procGetCurrentDirectoryW               = modkernel32.NewProc("GetCurrentDirectoryW")
-	procSetCurrentDirectoryW               = modkernel32.NewProc("SetCurrentDirectoryW")
-	procCreateDirectoryW                   = modkernel32.NewProc("CreateDirectoryW")
-	procRemoveDirectoryW                   = modkernel32.NewProc("RemoveDirectoryW")
-	procDeleteFileW                        = modkernel32.NewProc("DeleteFileW")
-	procMoveFileW                          = modkernel32.NewProc("MoveFileW")
-	procGetComputerNameW                   = modkernel32.NewProc("GetComputerNameW")
-	procSetEndOfFile                       = modkernel32.NewProc("SetEndOfFile")
-	procGetSystemTimeAsFileTime            = modkernel32.NewProc("GetSystemTimeAsFileTime")
-	procGetTimeZoneInformation             = modkernel32.NewProc("GetTimeZoneInformation")
-	procCreateIoCompletionPort             = modkernel32.NewProc("CreateIoCompletionPort")
-	procGetQueuedCompletionStatus          = modkernel32.NewProc("GetQueuedCompletionStatus")
-	procPostQueuedCompletionStatus         = modkernel32.NewProc("PostQueuedCompletionStatus")
-	procCancelIo                           = modkernel32.NewProc("CancelIo")
-	procCancelIoEx                         = modkernel32.NewProc("CancelIoEx")
-	procCreateProcessW                     = modkernel32.NewProc("CreateProcessW")
-	procOpenProcess                        = modkernel32.NewProc("OpenProcess")
-	procTerminateProcess                   = modkernel32.NewProc("TerminateProcess")
-	procGetExitCodeProcess                 = modkernel32.NewProc("GetExitCodeProcess")
-	procGetStartupInfoW                    = modkernel32.NewProc("GetStartupInfoW")
-	procGetCurrentProcess                  = modkernel32.NewProc("GetCurrentProcess")
-	procGetProcessTimes                    = modkernel32.NewProc("GetProcessTimes")
-	procDuplicateHandle                    = modkernel32.NewProc("DuplicateHandle")
-	procWaitForSingleObject                = modkernel32.NewProc("WaitForSingleObject")
-	procGetTempPathW                       = modkernel32.NewProc("GetTempPathW")
-	procCreatePipe                         = modkernel32.NewProc("CreatePipe")
-	procGetFileType                        = modkernel32.NewProc("GetFileType")
-	procCryptAcquireContextW               = modadvapi32.NewProc("CryptAcquireContextW")
-	procCryptReleaseContext                = modadvapi32.NewProc("CryptReleaseContext")
-	procCryptGenRandom                     = modadvapi32.NewProc("CryptGenRandom")
-	procGetEnvironmentStringsW             = modkernel32.NewProc("GetEnvironmentStringsW")
-	procFreeEnvironmentStringsW            = modkernel32.NewProc("FreeEnvironmentStringsW")
-	procGetEnvironmentVariableW            = modkernel32.NewProc("GetEnvironmentVariableW")
-	procSetEnvironmentVariableW            = modkernel32.NewProc("SetEnvironmentVariableW")
-	procSetFileTime                        = modkernel32.NewProc("SetFileTime")
-	procGetFileAttributesW                 = modkernel32.NewProc("GetFileAttributesW")
-	procSetFileAttributesW                 = modkernel32.NewProc("SetFileAttributesW")
-	procGetFileAttributesExW               = modkernel32.NewProc("GetFileAttributesExW")
-	procGetCommandLineW                    = modkernel32.NewProc("GetCommandLineW")
-	procCommandLineToArgvW                 = modshell32.NewProc("CommandLineToArgvW")
-	procLocalFree                          = modkernel32.NewProc("LocalFree")
-	procSetHandleInformation               = modkernel32.NewProc("SetHandleInformation")
-	procFlushFileBuffers                   = modkernel32.NewProc("FlushFileBuffers")
-	procGetFullPathNameW                   = modkernel32.NewProc("GetFullPathNameW")
-	procGetLongPathNameW                   = modkernel32.NewProc("GetLongPathNameW")
-	procGetShortPathNameW                  = modkernel32.NewProc("GetShortPathNameW")
-	procCreateFileMappingW                 = modkernel32.NewProc("CreateFileMappingW")
-	procMapViewOfFile                      = modkernel32.NewProc("MapViewOfFile")
-	procUnmapViewOfFile                    = modkernel32.NewProc("UnmapViewOfFile")
-	procFlushViewOfFile                    = modkernel32.NewProc("FlushViewOfFile")
-	procVirtualLock                        = modkernel32.NewProc("VirtualLock")
-	procVirtualUnlock                      = modkernel32.NewProc("VirtualUnlock")
-	procTransmitFile                       = modmswsock.NewProc("TransmitFile")
-	procReadDirectoryChangesW              = modkernel32.NewProc("ReadDirectoryChangesW")
-	procCertOpenSystemStoreW               = modcrypt32.NewProc("CertOpenSystemStoreW")
-	procCertOpenStore                      = modcrypt32.NewProc("CertOpenStore")
-	procCertEnumCertificatesInStore        = modcrypt32.NewProc("CertEnumCertificatesInStore")
-	procCertAddCertificateContextToStore   = modcrypt32.NewProc("CertAddCertificateContextToStore")
-	procCertCloseStore                     = modcrypt32.NewProc("CertCloseStore")
-	procCertGetCertificateChain            = modcrypt32.NewProc("CertGetCertificateChain")
-	procCertFreeCertificateChain           = modcrypt32.NewProc("CertFreeCertificateChain")
-	procCertCreateCertificateContext       = modcrypt32.NewProc("CertCreateCertificateContext")
-	procCertFreeCertificateContext         = modcrypt32.NewProc("CertFreeCertificateContext")
-	procCertVerifyCertificateChainPolicy   = modcrypt32.NewProc("CertVerifyCertificateChainPolicy")
-	procRegOpenKeyExW                      = modadvapi32.NewProc("RegOpenKeyExW")
-	procRegCloseKey                        = modadvapi32.NewProc("RegCloseKey")
-	procRegQueryInfoKeyW                   = modadvapi32.NewProc("RegQueryInfoKeyW")
-	procRegEnumKeyExW                      = modadvapi32.NewProc("RegEnumKeyExW")
-	procRegQueryValueExW                   = modadvapi32.NewProc("RegQueryValueExW")
-	procGetCurrentProcessId                = modkernel32.NewProc("GetCurrentProcessId")
-	procGetConsoleMode                     = modkernel32.NewProc("GetConsoleMode")
-	procWriteConsoleW                      = modkernel32.NewProc("WriteConsoleW")
-	procReadConsoleW                       = modkernel32.NewProc("ReadConsoleW")
-	procCreateToolhelp32Snapshot           = modkernel32.NewProc("CreateToolhelp32Snapshot")
-	procProcess32FirstW                    = modkernel32.NewProc("Process32FirstW")
-	procProcess32NextW                     = modkernel32.NewProc("Process32NextW")
-	procDeviceIoControl                    = modkernel32.NewProc("DeviceIoControl")
-	procCreateSymbolicLinkW                = modkernel32.NewProc("CreateSymbolicLinkW")
-	procCreateHardLinkW                    = modkernel32.NewProc("CreateHardLinkW")
-	procWSAStartup                         = modws2_32.NewProc("WSAStartup")
-	procWSACleanup                         = modws2_32.NewProc("WSACleanup")
-	procWSAIoctl                           = modws2_32.NewProc("WSAIoctl")
-	procsocket                             = modws2_32.NewProc("socket")
-	procsetsockopt                         = modws2_32.NewProc("setsockopt")
-	procgetsockopt                         = modws2_32.NewProc("getsockopt")
-	procbind                               = modws2_32.NewProc("bind")
-	procconnect                            = modws2_32.NewProc("connect")
-	procgetsockname                        = modws2_32.NewProc("getsockname")
-	procgetpeername                        = modws2_32.NewProc("getpeername")
-	proclisten                             = modws2_32.NewProc("listen")
-	procshutdown                           = modws2_32.NewProc("shutdown")
-	procclosesocket                        = modws2_32.NewProc("closesocket")
-	procAcceptEx                           = modmswsock.NewProc("AcceptEx")
-	procGetAcceptExSockaddrs               = modmswsock.NewProc("GetAcceptExSockaddrs")
-	procWSARecv                            = modws2_32.NewProc("WSARecv")
-	procWSASend                            = modws2_32.NewProc("WSASend")
-	procWSARecvFrom                        = modws2_32.NewProc("WSARecvFrom")
-	procWSASendTo                          = modws2_32.NewProc("WSASendTo")
-	procgethostbyname                      = modws2_32.NewProc("gethostbyname")
-	procgetservbyname                      = modws2_32.NewProc("getservbyname")
-	procntohs                              = modws2_32.NewProc("ntohs")
-	procgetprotobyname                     = modws2_32.NewProc("getprotobyname")
-	procDnsQuery_W                         = moddnsapi.NewProc("DnsQuery_W")
-	procDnsRecordListFree                  = moddnsapi.NewProc("DnsRecordListFree")
-	procDnsNameCompare_W                   = moddnsapi.NewProc("DnsNameCompare_W")
-	procGetAddrInfoW                       = modws2_32.NewProc("GetAddrInfoW")
-	procFreeAddrInfoW                      = modws2_32.NewProc("FreeAddrInfoW")
-	procGetIfEntry                         = modiphlpapi.NewProc("GetIfEntry")
-	procGetAdaptersInfo                    = modiphlpapi.NewProc("GetAdaptersInfo")
-	procSetFileCompletionNotificationModes = modkernel32.NewProc("SetFileCompletionNotificationModes")
-	procWSAEnumProtocolsW                  = modws2_32.NewProc("WSAEnumProtocolsW")
-	procTranslateNameW                     = modsecur32.NewProc("TranslateNameW")
-	procGetUserNameExW                     = modsecur32.NewProc("GetUserNameExW")
-	procNetUserGetInfo                     = modnetapi32.NewProc("NetUserGetInfo")
-	procNetGetJoinInformation              = modnetapi32.NewProc("NetGetJoinInformation")
-	procNetApiBufferFree                   = modnetapi32.NewProc("NetApiBufferFree")
-	procLookupAccountSidW                  = modadvapi32.NewProc("LookupAccountSidW")
-	procLookupAccountNameW                 = modadvapi32.NewProc("LookupAccountNameW")
-	procConvertSidToStringSidW             = modadvapi32.NewProc("ConvertSidToStringSidW")
-	procConvertStringSidToSidW             = modadvapi32.NewProc("ConvertStringSidToSidW")
-	procGetLengthSid                       = modadvapi32.NewProc("GetLengthSid")
-	procCopySid                            = modadvapi32.NewProc("CopySid")
-	procOpenProcessToken                   = modadvapi32.NewProc("OpenProcessToken")
-	procGetTokenInformation                = modadvapi32.NewProc("GetTokenInformation")
-	procGetUserProfileDirectoryW           = moduserenv.NewProc("GetUserProfileDirectoryW")
-)
-
-func GetLastError() (lasterr error) {
-	r0, _, _ := Syscall(procGetLastError.Addr(), 0, 0, 0, 0)
-	if r0 != 0 {
-		lasterr = Errno(r0)
-	}
-	return
-}
-
-func LoadLibrary(libname string) (handle Handle, err error) {
-	var _p0 *uint16
-	_p0, err = UTF16PtrFromString(libname)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(procLoadLibraryW.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	handle = Handle(r0)
-	if handle == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func FreeLibrary(handle Handle) (err error) {
-	r1, _, e1 := Syscall(procFreeLibrary.Addr(), 1, uintptr(handle), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetProcAddress(module Handle, procname string) (proc uintptr, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(procname)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(procGetProcAddress.Addr(), 2, uintptr(module), uintptr(unsafe.Pointer(_p0)), 0)
-	proc = uintptr(r0)
-	if proc == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetVersion() (ver uint32, err error) {
-	r0, _, e1 := Syscall(procGetVersion.Addr(), 0, 0, 0, 0)
-	ver = uint32(r0)
-	if ver == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func FormatMessage(flags uint32, msgsrc uint32, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) {
-	var _p0 *uint16
-	if len(buf) > 0 {
-		_p0 = &buf[0]
-	}
-	r0, _, e1 := Syscall9(procFormatMessageW.Addr(), 7, uintptr(flags), uintptr(msgsrc), uintptr(msgid), uintptr(langid), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(args)), 0, 0)
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func ExitProcess(exitcode uint32) {
-	Syscall(procExitProcess.Addr(), 1, uintptr(exitcode), 0, 0)
-	return
-}
-
-func CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile int32) (handle Handle, err error) {
-	r0, _, e1 := Syscall9(procCreateFileW.Addr(), 7, uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile), 0, 0)
-	handle = Handle(r0)
-	if handle == InvalidHandle {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
-	var _p0 *byte
-	if len(buf) > 0 {
-		_p0 = &buf[0]
-	}
-	r1, _, e1 := Syscall6(procReadFile.Addr(), 5, uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
-	var _p0 *byte
-	if len(buf) > 0 {
-		_p0 = &buf[0]
-	}
-	r1, _, e1 := Syscall6(procWriteFile.Addr(), 5, uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, err error) {
-	r0, _, e1 := Syscall6(procSetFilePointer.Addr(), 4, uintptr(handle), uintptr(lowoffset), uintptr(unsafe.Pointer(highoffsetptr)), uintptr(whence), 0, 0)
-	newlowoffset = uint32(r0)
-	if newlowoffset == 0xffffffff {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CloseHandle(handle Handle) (err error) {
-	r1, _, e1 := Syscall(procCloseHandle.Addr(), 1, uintptr(handle), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetStdHandle(stdhandle int) (handle Handle, err error) {
-	r0, _, e1 := Syscall(procGetStdHandle.Addr(), 1, uintptr(stdhandle), 0, 0)
-	handle = Handle(r0)
-	if handle == InvalidHandle {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) {
-	r0, _, e1 := Syscall(procFindFirstFileW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(data)), 0)
-	handle = Handle(r0)
-	if handle == InvalidHandle {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func findNextFile1(handle Handle, data *win32finddata1) (err error) {
-	r1, _, e1 := Syscall(procFindNextFileW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(data)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func FindClose(handle Handle) (err error) {
-	r1, _, e1 := Syscall(procFindClose.Addr(), 1, uintptr(handle), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (err error) {
-	r1, _, e1 := Syscall(procGetFileInformationByHandle.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(data)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, err error) {
-	r0, _, e1 := Syscall(procGetCurrentDirectoryW.Addr(), 2, uintptr(buflen), uintptr(unsafe.Pointer(buf)), 0)
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetCurrentDirectory(path *uint16) (err error) {
-	r1, _, e1 := Syscall(procSetCurrentDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) {
-	r1, _, e1 := Syscall(procCreateDirectoryW.Addr(), 2, uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(sa)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func RemoveDirectory(path *uint16) (err error) {
-	r1, _, e1 := Syscall(procRemoveDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func DeleteFile(path *uint16) (err error) {
-	r1, _, e1 := Syscall(procDeleteFileW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func MoveFile(from *uint16, to *uint16) (err error) {
-	r1, _, e1 := Syscall(procMoveFileW.Addr(), 2, uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetComputerName(buf *uint16, n *uint32) (err error) {
-	r1, _, e1 := Syscall(procGetComputerNameW.Addr(), 2, uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(n)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetEndOfFile(handle Handle) (err error) {
-	r1, _, e1 := Syscall(procSetEndOfFile.Addr(), 1, uintptr(handle), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetSystemTimeAsFileTime(time *Filetime) {
-	Syscall(procGetSystemTimeAsFileTime.Addr(), 1, uintptr(unsafe.Pointer(time)), 0, 0)
-	return
-}
-
-func GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) {
-	r0, _, e1 := Syscall(procGetTimeZoneInformation.Addr(), 1, uintptr(unsafe.Pointer(tzi)), 0, 0)
-	rc = uint32(r0)
-	if rc == 0xffffffff {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error) {
-	r0, _, e1 := Syscall6(procCreateIoCompletionPort.Addr(), 4, uintptr(filehandle), uintptr(cphandle), uintptr(key), uintptr(threadcnt), 0, 0)
-	handle = Handle(r0)
-	if handle == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error) {
-	r1, _, e1 := Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(cphandle), uintptr(unsafe.Pointer(qty)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(overlapped)), uintptr(timeout), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error) {
-	r1, _, e1 := Syscall6(procPostQueuedCompletionStatus.Addr(), 4, uintptr(cphandle), uintptr(qty), uintptr(key), uintptr(unsafe.Pointer(overlapped)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CancelIo(s Handle) (err error) {
-	r1, _, e1 := Syscall(procCancelIo.Addr(), 1, uintptr(s), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CancelIoEx(s Handle, o *Overlapped) (err error) {
-	r1, _, e1 := Syscall(procCancelIoEx.Addr(), 2, uintptr(s), uintptr(unsafe.Pointer(o)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) {
-	var _p0 uint32
-	if inheritHandles {
-		_p0 = 1
-	} else {
-		_p0 = 0
-	}
-	r1, _, e1 := Syscall12(procCreateProcessW.Addr(), 10, uintptr(unsafe.Pointer(appName)), uintptr(unsafe.Pointer(commandLine)), uintptr(unsafe.Pointer(procSecurity)), uintptr(unsafe.Pointer(threadSecurity)), uintptr(_p0), uintptr(creationFlags), uintptr(unsafe.Pointer(env)), uintptr(unsafe.Pointer(currentDir)), uintptr(unsafe.Pointer(startupInfo)), uintptr(unsafe.Pointer(outProcInfo)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle Handle, err error) {
-	var _p0 uint32
-	if inheritHandle {
-		_p0 = 1
-	} else {
-		_p0 = 0
-	}
-	r0, _, e1 := Syscall(procOpenProcess.Addr(), 3, uintptr(da), uintptr(_p0), uintptr(pid))
-	handle = Handle(r0)
-	if handle == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func TerminateProcess(handle Handle, exitcode uint32) (err error) {
-	r1, _, e1 := Syscall(procTerminateProcess.Addr(), 2, uintptr(handle), uintptr(exitcode), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetExitCodeProcess(handle Handle, exitcode *uint32) (err error) {
-	r1, _, e1 := Syscall(procGetExitCodeProcess.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(exitcode)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetStartupInfo(startupInfo *StartupInfo) (err error) {
-	r1, _, e1 := Syscall(procGetStartupInfoW.Addr(), 1, uintptr(unsafe.Pointer(startupInfo)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetCurrentProcess() (pseudoHandle Handle, err error) {
-	r0, _, e1 := Syscall(procGetCurrentProcess.Addr(), 0, 0, 0, 0)
-	pseudoHandle = Handle(r0)
-	if pseudoHandle == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error) {
-	r1, _, e1 := Syscall6(procGetProcessTimes.Addr(), 5, uintptr(handle), uintptr(unsafe.Pointer(creationTime)), uintptr(unsafe.Pointer(exitTime)), uintptr(unsafe.Pointer(kernelTime)), uintptr(unsafe.Pointer(userTime)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error) {
-	var _p0 uint32
-	if bInheritHandle {
-		_p0 = 1
-	} else {
-		_p0 = 0
-	}
-	r1, _, e1 := Syscall9(procDuplicateHandle.Addr(), 7, uintptr(hSourceProcessHandle), uintptr(hSourceHandle), uintptr(hTargetProcessHandle), uintptr(unsafe.Pointer(lpTargetHandle)), uintptr(dwDesiredAccess), uintptr(_p0), uintptr(dwOptions), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, err error) {
-	r0, _, e1 := Syscall(procWaitForSingleObject.Addr(), 2, uintptr(handle), uintptr(waitMilliseconds), 0)
-	event = uint32(r0)
-	if event == 0xffffffff {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetTempPath(buflen uint32, buf *uint16) (n uint32, err error) {
-	r0, _, e1 := Syscall(procGetTempPathW.Addr(), 2, uintptr(buflen), uintptr(unsafe.Pointer(buf)), 0)
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (err error) {
-	r1, _, e1 := Syscall6(procCreatePipe.Addr(), 4, uintptr(unsafe.Pointer(readhandle)), uintptr(unsafe.Pointer(writehandle)), uintptr(unsafe.Pointer(sa)), uintptr(size), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetFileType(filehandle Handle) (n uint32, err error) {
-	r0, _, e1 := Syscall(procGetFileType.Addr(), 1, uintptr(filehandle), 0, 0)
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) {
-	r1, _, e1 := Syscall6(procCryptAcquireContextW.Addr(), 5, uintptr(unsafe.Pointer(provhandle)), uintptr(unsafe.Pointer(container)), uintptr(unsafe.Pointer(provider)), uintptr(provtype), uintptr(flags), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CryptReleaseContext(provhandle Handle, flags uint32) (err error) {
-	r1, _, e1 := Syscall(procCryptReleaseContext.Addr(), 2, uintptr(provhandle), uintptr(flags), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) {
-	r1, _, e1 := Syscall(procCryptGenRandom.Addr(), 3, uintptr(provhandle), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetEnvironmentStrings() (envs *uint16, err error) {
-	r0, _, e1 := Syscall(procGetEnvironmentStringsW.Addr(), 0, 0, 0, 0)
-	envs = (*uint16)(unsafe.Pointer(r0))
-	if envs == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func FreeEnvironmentStrings(envs *uint16) (err error) {
-	r1, _, e1 := Syscall(procFreeEnvironmentStringsW.Addr(), 1, uintptr(unsafe.Pointer(envs)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) {
-	r0, _, e1 := Syscall(procGetEnvironmentVariableW.Addr(), 3, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(size))
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetEnvironmentVariable(name *uint16, value *uint16) (err error) {
-	r1, _, e1 := Syscall(procSetEnvironmentVariableW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error) {
-	r1, _, e1 := Syscall6(procSetFileTime.Addr(), 4, uintptr(handle), uintptr(unsafe.Pointer(ctime)), uintptr(unsafe.Pointer(atime)), uintptr(unsafe.Pointer(wtime)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetFileAttributes(name *uint16) (attrs uint32, err error) {
-	r0, _, e1 := Syscall(procGetFileAttributesW.Addr(), 1, uintptr(unsafe.Pointer(name)), 0, 0)
-	attrs = uint32(r0)
-	if attrs == INVALID_FILE_ATTRIBUTES {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetFileAttributes(name *uint16, attrs uint32) (err error) {
-	r1, _, e1 := Syscall(procSetFileAttributesW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(attrs), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetFileAttributesEx(name *uint16, level uint32, info *byte) (err error) {
-	r1, _, e1 := Syscall(procGetFileAttributesExW.Addr(), 3, uintptr(unsafe.Pointer(name)), uintptr(level), uintptr(unsafe.Pointer(info)))
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetCommandLine() (cmd *uint16) {
-	r0, _, _ := Syscall(procGetCommandLineW.Addr(), 0, 0, 0, 0)
-	cmd = (*uint16)(unsafe.Pointer(r0))
-	return
-}
-
-func CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, err error) {
-	r0, _, e1 := Syscall(procCommandLineToArgvW.Addr(), 2, uintptr(unsafe.Pointer(cmd)), uintptr(unsafe.Pointer(argc)), 0)
-	argv = (*[8192]*[8192]uint16)(unsafe.Pointer(r0))
-	if argv == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func LocalFree(hmem Handle) (handle Handle, err error) {
-	r0, _, e1 := Syscall(procLocalFree.Addr(), 1, uintptr(hmem), 0, 0)
-	handle = Handle(r0)
-	if handle != 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error) {
-	r1, _, e1 := Syscall(procSetHandleInformation.Addr(), 3, uintptr(handle), uintptr(mask), uintptr(flags))
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func FlushFileBuffers(handle Handle) (err error) {
-	r1, _, e1 := Syscall(procFlushFileBuffers.Addr(), 1, uintptr(handle), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) {
-	r0, _, e1 := Syscall6(procGetFullPathNameW.Addr(), 4, uintptr(unsafe.Pointer(path)), uintptr(buflen), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(fname)), 0, 0)
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) {
-	r0, _, e1 := Syscall(procGetLongPathNameW.Addr(), 3, uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(buf)), uintptr(buflen))
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) {
-	r0, _, e1 := Syscall(procGetShortPathNameW.Addr(), 3, uintptr(unsafe.Pointer(longpath)), uintptr(unsafe.Pointer(shortpath)), uintptr(buflen))
-	n = uint32(r0)
-	if n == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) {
-	r0, _, e1 := Syscall6(procCreateFileMappingW.Addr(), 6, uintptr(fhandle), uintptr(unsafe.Pointer(sa)), uintptr(prot), uintptr(maxSizeHigh), uintptr(maxSizeLow), uintptr(unsafe.Pointer(name)))
-	handle = Handle(r0)
-	if handle == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error) {
-	r0, _, e1 := Syscall6(procMapViewOfFile.Addr(), 5, uintptr(handle), uintptr(access), uintptr(offsetHigh), uintptr(offsetLow), uintptr(length), 0)
-	addr = uintptr(r0)
-	if addr == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func UnmapViewOfFile(addr uintptr) (err error) {
-	r1, _, e1 := Syscall(procUnmapViewOfFile.Addr(), 1, uintptr(addr), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func FlushViewOfFile(addr uintptr, length uintptr) (err error) {
-	r1, _, e1 := Syscall(procFlushViewOfFile.Addr(), 2, uintptr(addr), uintptr(length), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func VirtualLock(addr uintptr, length uintptr) (err error) {
-	r1, _, e1 := Syscall(procVirtualLock.Addr(), 2, uintptr(addr), uintptr(length), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func VirtualUnlock(addr uintptr, length uintptr) (err error) {
-	r1, _, e1 := Syscall(procVirtualUnlock.Addr(), 2, uintptr(addr), uintptr(length), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) {
-	r1, _, e1 := Syscall9(procTransmitFile.Addr(), 7, uintptr(s), uintptr(handle), uintptr(bytesToWrite), uintptr(bytsPerSend), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(transmitFileBuf)), uintptr(flags), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
-	var _p0 uint32
-	if watchSubTree {
-		_p0 = 1
-	} else {
-		_p0 = 0
-	}
-	r1, _, e1 := Syscall9(procReadDirectoryChangesW.Addr(), 8, uintptr(handle), uintptr(unsafe.Pointer(buf)), uintptr(buflen), uintptr(_p0), uintptr(mask), uintptr(unsafe.Pointer(retlen)), uintptr(unsafe.Pointer(overlapped)), uintptr(completionRoutine), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) {
-	r0, _, e1 := Syscall(procCertOpenSystemStoreW.Addr(), 2, uintptr(hprov), uintptr(unsafe.Pointer(name)), 0)
-	store = Handle(r0)
-	if store == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) {
-	r0, _, e1 := Syscall6(procCertOpenStore.Addr(), 5, uintptr(storeProvider), uintptr(msgAndCertEncodingType), uintptr(cryptProv), uintptr(flags), uintptr(para), 0)
-	handle = Handle(r0)
-	if handle == InvalidHandle {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) {
-	r0, _, e1 := Syscall(procCertEnumCertificatesInStore.Addr(), 2, uintptr(store), uintptr(unsafe.Pointer(prevContext)), 0)
-	context = (*CertContext)(unsafe.Pointer(r0))
-	if context == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) {
-	r1, _, e1 := Syscall6(procCertAddCertificateContextToStore.Addr(), 4, uintptr(store), uintptr(unsafe.Pointer(certContext)), uintptr(addDisposition), uintptr(unsafe.Pointer(storeContext)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertCloseStore(store Handle, flags uint32) (err error) {
-	r1, _, e1 := Syscall(procCertCloseStore.Addr(), 2, uintptr(store), uintptr(flags), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) {
-	r1, _, e1 := Syscall9(procCertGetCertificateChain.Addr(), 8, uintptr(engine), uintptr(unsafe.Pointer(leaf)), uintptr(unsafe.Pointer(time)), uintptr(additionalStore), uintptr(unsafe.Pointer(para)), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(chainCtx)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertFreeCertificateChain(ctx *CertChainContext) {
-	Syscall(procCertFreeCertificateChain.Addr(), 1, uintptr(unsafe.Pointer(ctx)), 0, 0)
-	return
-}
-
-func CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) {
-	r0, _, e1 := Syscall(procCertCreateCertificateContext.Addr(), 3, uintptr(certEncodingType), uintptr(unsafe.Pointer(certEncoded)), uintptr(encodedLen))
-	context = (*CertContext)(unsafe.Pointer(r0))
-	if context == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertFreeCertificateContext(ctx *CertContext) (err error) {
-	r1, _, e1 := Syscall(procCertFreeCertificateContext.Addr(), 1, uintptr(unsafe.Pointer(ctx)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) {
-	r1, _, e1 := Syscall6(procCertVerifyCertificateChainPolicy.Addr(), 4, uintptr(policyOID), uintptr(unsafe.Pointer(chain)), uintptr(unsafe.Pointer(para)), uintptr(unsafe.Pointer(status)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) {
-	r0, _, _ := Syscall6(procRegOpenKeyExW.Addr(), 5, uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(options), uintptr(desiredAccess), uintptr(unsafe.Pointer(result)), 0)
-	if r0 != 0 {
-		regerrno = Errno(r0)
-	}
-	return
-}
-
-func RegCloseKey(key Handle) (regerrno error) {
-	r0, _, _ := Syscall(procRegCloseKey.Addr(), 1, uintptr(key), 0, 0)
-	if r0 != 0 {
-		regerrno = Errno(r0)
-	}
-	return
-}
-
-func RegQueryInfoKey(key Handle, class *uint16, classLen *uint32, reserved *uint32, subkeysLen *uint32, maxSubkeyLen *uint32, maxClassLen *uint32, valuesLen *uint32, maxValueNameLen *uint32, maxValueLen *uint32, saLen *uint32, lastWriteTime *Filetime) (regerrno error) {
-	r0, _, _ := Syscall12(procRegQueryInfoKeyW.Addr(), 12, uintptr(key), uintptr(unsafe.Pointer(class)), uintptr(unsafe.Pointer(classLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(subkeysLen)), uintptr(unsafe.Pointer(maxSubkeyLen)), uintptr(unsafe.Pointer(maxClassLen)), uintptr(unsafe.Pointer(valuesLen)), uintptr(unsafe.Pointer(maxValueNameLen)), uintptr(unsafe.Pointer(maxValueLen)), uintptr(unsafe.Pointer(saLen)), uintptr(unsafe.Pointer(lastWriteTime)))
-	if r0 != 0 {
-		regerrno = Errno(r0)
-	}
-	return
-}
-
-func RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) {
-	r0, _, _ := Syscall9(procRegEnumKeyExW.Addr(), 8, uintptr(key), uintptr(index), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(class)), uintptr(unsafe.Pointer(classLen)), uintptr(unsafe.Pointer(lastWriteTime)), 0)
-	if r0 != 0 {
-		regerrno = Errno(r0)
-	}
-	return
-}
-
-func RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) {
-	r0, _, _ := Syscall6(procRegQueryValueExW.Addr(), 6, uintptr(key), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(valtype)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(buflen)))
-	if r0 != 0 {
-		regerrno = Errno(r0)
-	}
-	return
-}
-
-func getCurrentProcessId() (pid uint32) {
-	r0, _, _ := Syscall(procGetCurrentProcessId.Addr(), 0, 0, 0, 0)
-	pid = uint32(r0)
-	return
-}
-
-func GetConsoleMode(console Handle, mode *uint32) (err error) {
-	r1, _, e1 := Syscall(procGetConsoleMode.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(mode)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) {
-	r1, _, e1 := Syscall6(procWriteConsoleW.Addr(), 5, uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(towrite), uintptr(unsafe.Pointer(written)), uintptr(unsafe.Pointer(reserved)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) {
-	r1, _, e1 := Syscall6(procReadConsoleW.Addr(), 5, uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(toread), uintptr(unsafe.Pointer(read)), uintptr(unsafe.Pointer(inputControl)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) {
-	r0, _, e1 := Syscall(procCreateToolhelp32Snapshot.Addr(), 2, uintptr(flags), uintptr(processId), 0)
-	handle = Handle(r0)
-	if handle == InvalidHandle {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) {
-	r1, _, e1 := Syscall(procProcess32FirstW.Addr(), 2, uintptr(snapshot), uintptr(unsafe.Pointer(procEntry)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) {
-	r1, _, e1 := Syscall(procProcess32NextW.Addr(), 2, uintptr(snapshot), uintptr(unsafe.Pointer(procEntry)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error) {
-	r1, _, e1 := Syscall9(procDeviceIoControl.Addr(), 8, uintptr(handle), uintptr(ioControlCode), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferSize), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferSize), uintptr(unsafe.Pointer(bytesReturned)), uintptr(unsafe.Pointer(overlapped)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) {
-	r1, _, e1 := Syscall(procCreateSymbolicLinkW.Addr(), 3, uintptr(unsafe.Pointer(symlinkfilename)), uintptr(unsafe.Pointer(targetfilename)), uintptr(flags))
-	if r1&0xff == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) {
-	r1, _, e1 := Syscall(procCreateHardLinkW.Addr(), 3, uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(existingfilename)), uintptr(reserved))
-	if r1&0xff == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WSAStartup(verreq uint32, data *WSAData) (sockerr error) {
-	r0, _, _ := Syscall(procWSAStartup.Addr(), 2, uintptr(verreq), uintptr(unsafe.Pointer(data)), 0)
-	if r0 != 0 {
-		sockerr = Errno(r0)
-	}
-	return
-}
-
-func WSACleanup() (err error) {
-	r1, _, e1 := Syscall(procWSACleanup.Addr(), 0, 0, 0, 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WSAIoctl(s Handle, iocc uint32, inbuf *byte, cbif uint32, outbuf *byte, cbob uint32, cbbr *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
-	r1, _, e1 := Syscall9(procWSAIoctl.Addr(), 9, uintptr(s), uintptr(iocc), uintptr(unsafe.Pointer(inbuf)), uintptr(cbif), uintptr(unsafe.Pointer(outbuf)), uintptr(cbob), uintptr(unsafe.Pointer(cbbr)), uintptr(unsafe.Pointer(overlapped)), uintptr(completionRoutine))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func socket(af int32, typ int32, protocol int32) (handle Handle, err error) {
-	r0, _, e1 := Syscall(procsocket.Addr(), 3, uintptr(af), uintptr(typ), uintptr(protocol))
-	handle = Handle(r0)
-	if handle == InvalidHandle {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) {
-	r1, _, e1 := Syscall6(procsetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(optlen), 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) {
-	r1, _, e1 := Syscall6(procgetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(unsafe.Pointer(optlen)), 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func bind(s Handle, name unsafe.Pointer, namelen int32) (err error) {
-	r1, _, e1 := Syscall(procbind.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func connect(s Handle, name unsafe.Pointer, namelen int32) (err error) {
-	r1, _, e1 := Syscall(procconnect.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) {
-	r1, _, e1 := Syscall(procgetsockname.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) {
-	r1, _, e1 := Syscall(procgetpeername.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func listen(s Handle, backlog int32) (err error) {
-	r1, _, e1 := Syscall(proclisten.Addr(), 2, uintptr(s), uintptr(backlog), 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func shutdown(s Handle, how int32) (err error) {
-	r1, _, e1 := Syscall(procshutdown.Addr(), 2, uintptr(s), uintptr(how), 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func Closesocket(s Handle) (err error) {
-	r1, _, e1 := Syscall(procclosesocket.Addr(), 1, uintptr(s), 0, 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) {
-	r1, _, e1 := Syscall9(procAcceptEx.Addr(), 8, uintptr(ls), uintptr(as), uintptr(unsafe.Pointer(buf)), uintptr(rxdatalen), uintptr(laddrlen), uintptr(raddrlen), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(overlapped)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) {
-	Syscall9(procGetAcceptExSockaddrs.Addr(), 8, uintptr(unsafe.Pointer(buf)), uintptr(rxdatalen), uintptr(laddrlen), uintptr(raddrlen), uintptr(unsafe.Pointer(lrsa)), uintptr(unsafe.Pointer(lrsalen)), uintptr(unsafe.Pointer(rrsa)), uintptr(unsafe.Pointer(rrsalen)), 0)
-	return
-}
-
-func WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (err error) {
-	r1, _, e1 := Syscall9(procWSARecv.Addr(), 7, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)), 0, 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) {
-	r1, _, e1 := Syscall9(procWSASend.Addr(), 7, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)), 0, 0)
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (err error) {
-	r1, _, e1 := Syscall9(procWSARecvFrom.Addr(), 9, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32, overlapped *Overlapped, croutine *byte) (err error) {
-	r1, _, e1 := Syscall9(procWSASendTo.Addr(), 9, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(to)), uintptr(tolen), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
-	if r1 == socket_error {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetHostByName(name string) (h *Hostent, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(procgethostbyname.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	h = (*Hostent)(unsafe.Pointer(r0))
-	if h == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetServByName(name string, proto string) (s *Servent, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	var _p1 *byte
-	_p1, err = BytePtrFromString(proto)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(procgetservbyname.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
-	s = (*Servent)(unsafe.Pointer(r0))
-	if s == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func Ntohs(netshort uint16) (u uint16) {
-	r0, _, _ := Syscall(procntohs.Addr(), 1, uintptr(netshort), 0, 0)
-	u = uint16(r0)
-	return
-}
-
-func GetProtoByName(name string) (p *Protoent, err error) {
-	var _p0 *byte
-	_p0, err = BytePtrFromString(name)
-	if err != nil {
-		return
-	}
-	r0, _, e1 := Syscall(procgetprotobyname.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0)
-	p = (*Protoent)(unsafe.Pointer(r0))
-	if p == nil {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) {
-	var _p0 *uint16
-	_p0, status = UTF16PtrFromString(name)
-	if status != nil {
-		return
-	}
-	r0, _, _ := Syscall6(procDnsQuery_W.Addr(), 6, uintptr(unsafe.Pointer(_p0)), uintptr(qtype), uintptr(options), uintptr(unsafe.Pointer(extra)), uintptr(unsafe.Pointer(qrs)), uintptr(unsafe.Pointer(pr)))
-	if r0 != 0 {
-		status = Errno(r0)
-	}
-	return
-}
-
-func DnsRecordListFree(rl *DNSRecord, freetype uint32) {
-	Syscall(procDnsRecordListFree.Addr(), 2, uintptr(unsafe.Pointer(rl)), uintptr(freetype), 0)
-	return
-}
-
-func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
-	r0, _, _ := Syscall(procDnsNameCompare_W.Addr(), 2, uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)), 0)
-	same = r0 != 0
-	return
-}
-
-func GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) {
-	r0, _, _ := Syscall6(procGetAddrInfoW.Addr(), 4, uintptr(unsafe.Pointer(nodename)), uintptr(unsafe.Pointer(servicename)), uintptr(unsafe.Pointer(hints)), uintptr(unsafe.Pointer(result)), 0, 0)
-	if r0 != 0 {
-		sockerr = Errno(r0)
-	}
-	return
-}
-
-func FreeAddrInfoW(addrinfo *AddrinfoW) {
-	Syscall(procFreeAddrInfoW.Addr(), 1, uintptr(unsafe.Pointer(addrinfo)), 0, 0)
-	return
-}
-
-func GetIfEntry(pIfRow *MibIfRow) (errcode error) {
-	r0, _, _ := Syscall(procGetIfEntry.Addr(), 1, uintptr(unsafe.Pointer(pIfRow)), 0, 0)
-	if r0 != 0 {
-		errcode = Errno(r0)
-	}
-	return
-}
-
-func GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) {
-	r0, _, _ := Syscall(procGetAdaptersInfo.Addr(), 2, uintptr(unsafe.Pointer(ai)), uintptr(unsafe.Pointer(ol)), 0)
-	if r0 != 0 {
-		errcode = Errno(r0)
-	}
-	return
-}
-
-func SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) {
-	r1, _, e1 := Syscall(procSetFileCompletionNotificationModes.Addr(), 2, uintptr(handle), uintptr(flags), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) {
-	r0, _, e1 := Syscall(procWSAEnumProtocolsW.Addr(), 3, uintptr(unsafe.Pointer(protocols)), uintptr(unsafe.Pointer(protocolBuffer)), uintptr(unsafe.Pointer(bufferLength)))
-	n = int32(r0)
-	if n == -1 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint32, translatedName *uint16, nSize *uint32) (err error) {
-	r1, _, e1 := Syscall6(procTranslateNameW.Addr(), 5, uintptr(unsafe.Pointer(accName)), uintptr(accNameFormat), uintptr(desiredNameFormat), uintptr(unsafe.Pointer(translatedName)), uintptr(unsafe.Pointer(nSize)), 0)
-	if r1&0xff == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) {
-	r1, _, e1 := Syscall(procGetUserNameExW.Addr(), 3, uintptr(nameFormat), uintptr(unsafe.Pointer(nameBuffre)), uintptr(unsafe.Pointer(nSize)))
-	if r1&0xff == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) {
-	r0, _, _ := Syscall6(procNetUserGetInfo.Addr(), 4, uintptr(unsafe.Pointer(serverName)), uintptr(unsafe.Pointer(userName)), uintptr(level), uintptr(unsafe.Pointer(buf)), 0, 0)
-	if r0 != 0 {
-		neterr = Errno(r0)
-	}
-	return
-}
-
-func NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) {
-	r0, _, _ := Syscall(procNetGetJoinInformation.Addr(), 3, uintptr(unsafe.Pointer(server)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(bufType)))
-	if r0 != 0 {
-		neterr = Errno(r0)
-	}
-	return
-}
-
-func NetApiBufferFree(buf *byte) (neterr error) {
-	r0, _, _ := Syscall(procNetApiBufferFree.Addr(), 1, uintptr(unsafe.Pointer(buf)), 0, 0)
-	if r0 != 0 {
-		neterr = Errno(r0)
-	}
-	return
-}
-
-func LookupAccountSid(systemName *uint16, sid *SID, name *uint16, nameLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) {
-	r1, _, e1 := Syscall9(procLookupAccountSidW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(refdDomainName)), uintptr(unsafe.Pointer(refdDomainNameLen)), uintptr(unsafe.Pointer(use)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func LookupAccountName(systemName *uint16, accountName *uint16, sid *SID, sidLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) {
-	r1, _, e1 := Syscall9(procLookupAccountNameW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(accountName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sidLen)), uintptr(unsafe.Pointer(refdDomainName)), uintptr(unsafe.Pointer(refdDomainNameLen)), uintptr(unsafe.Pointer(use)), 0, 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func ConvertSidToStringSid(sid *SID, stringSid **uint16) (err error) {
-	r1, _, e1 := Syscall(procConvertSidToStringSidW.Addr(), 2, uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(stringSid)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func ConvertStringSidToSid(stringSid *uint16, sid **SID) (err error) {
-	r1, _, e1 := Syscall(procConvertStringSidToSidW.Addr(), 2, uintptr(unsafe.Pointer(stringSid)), uintptr(unsafe.Pointer(sid)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetLengthSid(sid *SID) (len uint32) {
-	r0, _, _ := Syscall(procGetLengthSid.Addr(), 1, uintptr(unsafe.Pointer(sid)), 0, 0)
-	len = uint32(r0)
-	return
-}
-
-func CopySid(destSidLen uint32, destSid *SID, srcSid *SID) (err error) {
-	r1, _, e1 := Syscall(procCopySid.Addr(), 3, uintptr(destSidLen), uintptr(unsafe.Pointer(destSid)), uintptr(unsafe.Pointer(srcSid)))
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func OpenProcessToken(h Handle, access uint32, token *Token) (err error) {
-	r1, _, e1 := Syscall(procOpenProcessToken.Addr(), 3, uintptr(h), uintptr(access), uintptr(unsafe.Pointer(token)))
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetTokenInformation(t Token, infoClass uint32, info *byte, infoLen uint32, returnedLen *uint32) (err error) {
-	r1, _, e1 := Syscall6(procGetTokenInformation.Addr(), 5, uintptr(t), uintptr(infoClass), uintptr(unsafe.Pointer(info)), uintptr(infoLen), uintptr(unsafe.Pointer(returnedLen)), 0)
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}
-
-func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) {
-	r1, _, e1 := Syscall(procGetUserProfileDirectoryW.Addr(), 3, uintptr(t), uintptr(unsafe.Pointer(dir)), uintptr(unsafe.Pointer(dirLen)))
-	if r1 == 0 {
-		if e1 != 0 {
-			err = error(e1)
-		} else {
-			err = EINVAL
-		}
-	}
-	return
-}

From ddce7c35f46ad4644d6f6e48817daf7a92804144 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Wed, 20 Aug 2014 12:58:01 +0400
Subject: [PATCH 135/423] runtime: add atomicor8 for amd64p32

LGTM=khr
R=golang-codereviews, daniel.morsing, khr, rsc
CC=golang-codereviews, khr, rlh
https://golang.org/cl/131950043
---
 src/pkg/runtime/asm_amd64p32.s | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 71ea4f385a..3e84d95d3f 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -660,6 +660,14 @@ TEXT runtime·atomicstore64(SB), NOSPLIT, $0-16
 	XCHGQ	AX, 0(BX)
 	RET
 
+// void	runtime·atomicor8(byte volatile*, byte);
+TEXT runtime·atomicor8(SB), NOSPLIT, $0-8
+	MOVL	ptr+0(FP), BX
+	MOVB	val+4(FP), AX
+	LOCK
+	ORB	AX, 0(BX)
+	RET
+
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. pop the caller

From 68f91aea57a81bdaab9da045c5ff09cc825da857 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 20 Aug 2014 14:02:11 -0700
Subject: [PATCH 136/423] runtime: convert memclrBytes to Go

LGTM=khr
R=khr
CC=golang-codereviews
https://golang.org/cl/131980043
---
 src/pkg/runtime/alg.go         | 6 ++++++
 src/pkg/runtime/alg.goc        | 5 -----
 src/pkg/runtime/export_test.go | 5 +----
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index 650f684950..ff296b692e 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -273,3 +273,9 @@ func ifaceHash(i interface {
 }, seed uintptr) uintptr {
 	return goalg(&algarray[alg_INTER]).hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
 }
+
+// Testing adapter for memclr
+func memclrBytes(b []byte) {
+	s := (*sliceStruct)(unsafe.Pointer(&b))
+	memclr(s.array, uintptr(s.len))
+}
diff --git a/src/pkg/runtime/alg.goc b/src/pkg/runtime/alg.goc
index f9e8892929..aa0c79d476 100644
--- a/src/pkg/runtime/alg.goc
+++ b/src/pkg/runtime/alg.goc
@@ -287,8 +287,3 @@ runtime·hashinit(void)
 		}
 	}
 }
-
-// Testing adapter for memclr
-func memclrBytes(s Slice) {
-	runtime·memclr(s.array, s.len);
-}
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 32c34aade6..adbc1e9955 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -78,13 +78,10 @@ var Int32Hash = int32Hash
 var Int64Hash = int64Hash
 var EfaceHash = efaceHash
 var IfaceHash = ifaceHash
+var MemclrBytes = memclrBytes
 
 var HashLoad = &hashLoad
 
-func memclrBytes(b []byte)
-
-var MemclrBytes = memclrBytes
-
 func gogoBytes() int32
 
 var GogoBytes = gogoBytes

From cccd66c6c446fb2d4f2ee74259898d0acb8ec803 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Wed, 20 Aug 2014 14:36:28 -0700
Subject: [PATCH 137/423] runtime: remove unused variable

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/128230047
---
 src/pkg/runtime/atomic_arm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/atomic_arm.c b/src/pkg/runtime/atomic_arm.c
index 537bf18331..0cb823bb48 100644
--- a/src/pkg/runtime/atomic_arm.c
+++ b/src/pkg/runtime/atomic_arm.c
@@ -172,7 +172,7 @@ runtime·atomicstore64(uint64 volatile *addr, uint64 v)
 void
 runtime·atomicor8(byte volatile *addr, byte v)
 {
-	uint32 *addr32, old, word, shift;
+	uint32 *addr32, old, word;
 
 	// Align down to 4 bytes and use 32-bit CAS.
 	addr32 = (uint32*)((uintptr)addr & ~3);

From 04487d5612cd3adc7dde217e736b73fb37af1ee5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Oudompheng?= <oudomphe@phare.normalesup.org>
Date: Thu, 21 Aug 2014 08:07:42 +0200
Subject: [PATCH 138/423] runtime: convert MemProfile, BlockProfile,
 ThreadCreateProfile to Go.

LGTM=khr
R=golang-codereviews, bradfitz, khr
CC=golang-codereviews
https://golang.org/cl/123680043
---
 src/pkg/runtime/debug.go  |  31 -------
 src/pkg/runtime/mprof.go  | 166 ++++++++++++++++++++++++++++++++++++++
 src/pkg/runtime/mprof.goc | 156 +++++------------------------------
 3 files changed, 188 insertions(+), 165 deletions(-)
 create mode 100644 src/pkg/runtime/mprof.go

diff --git a/src/pkg/runtime/debug.go b/src/pkg/runtime/debug.go
index d82afb08ec..393598c28a 100644
--- a/src/pkg/runtime/debug.go
+++ b/src/pkg/runtime/debug.go
@@ -75,20 +75,6 @@ func (r *MemProfileRecord) Stack() []uintptr {
 	return r.Stack0[0:]
 }
 
-// MemProfile returns n, the number of records in the current memory profile.
-// If len(p) >= n, MemProfile copies the profile into p and returns n, true.
-// If len(p) < n, MemProfile does not change p and returns n, false.
-//
-// If inuseZero is true, the profile includes allocation records
-// where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.
-// These are sites where memory was allocated, but it has all
-// been released back to the runtime.
-//
-// Most clients should use the runtime/pprof package or
-// the testing package's -test.memprofile flag instead
-// of calling MemProfile directly.
-func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool)
-
 // A StackRecord describes a single execution stack.
 type StackRecord struct {
 	Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
@@ -105,14 +91,6 @@ func (r *StackRecord) Stack() []uintptr {
 	return r.Stack0[0:]
 }
 
-// ThreadCreateProfile returns n, the number of records in the thread creation profile.
-// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
-// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
-//
-// Most clients should use the runtime/pprof package instead
-// of calling ThreadCreateProfile directly.
-func ThreadCreateProfile(p []StackRecord) (n int, ok bool)
-
 // GoroutineProfile returns n, the number of records in the active goroutine stack profile.
 // If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
 // If len(p) < n, GoroutineProfile does not change p and returns n, false.
@@ -156,15 +134,6 @@ type BlockProfileRecord struct {
 	StackRecord
 }
 
-// BlockProfile returns n, the number of records in the current blocking profile.
-// If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
-// If len(p) < n, BlockProfile does not change p and returns n, false.
-//
-// Most clients should use the runtime/pprof package or
-// the testing package's -test.blockprofile flag instead
-// of calling BlockProfile directly.
-func BlockProfile(p []BlockProfileRecord) (n int, ok bool)
-
 // Stack formats a stack trace of the calling goroutine into buf
 // and returns the number of bytes written to buf.
 // If all is true, Stack formats stack traces of all other goroutines
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
new file mode 100644
index 0000000000..057e3dee1c
--- /dev/null
+++ b/src/pkg/runtime/mprof.go
@@ -0,0 +1,166 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import (
+	"unsafe"
+)
+
+// Malloc profiling.
+// Patterned after tcmalloc's algorithms; shorter code.
+
+// NOTE(rsc): Everything here could use cas if contention became an issue.
+var proflock lock
+
+// All memory allocations are local and do not escape outside of the profiler.
+// The profiler is forbidden from referring to garbage-collected memory.
+
+var (
+	mbuckets *bucket // memory profile buckets
+	bbuckets *bucket // blocking profile buckets
+)
+
+// MemProfile returns n, the number of records in the current memory profile.
+// If len(p) >= n, MemProfile copies the profile into p and returns n, true.
+// If len(p) < n, MemProfile does not change p and returns n, false.
+//
+// If inuseZero is true, the profile includes allocation records
+// where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.
+// These are sites where memory was allocated, but it has all
+// been released back to the runtime.
+//
+// Most clients should use the runtime/pprof package or
+// the testing package's -test.memprofile flag instead
+// of calling MemProfile directly.
+func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
+	golock(&proflock)
+	clear := true
+	for b := mbuckets; b != nil; b = b.allnext {
+		if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
+			n++
+		}
+		if b.data.mp.allocs != 0 || b.data.mp.frees != 0 {
+			clear = false
+		}
+	}
+	if clear {
+		// Absolutely no data, suggesting that a garbage collection
+		// has not yet happened. In order to allow profiling when
+		// garbage collection is disabled from the beginning of execution,
+		// accumulate stats as if a GC just happened, and recount buckets.
+		mprof_GC()
+		mprof_GC()
+		n = 0
+		for b := mbuckets; b != nil; b = b.allnext {
+			if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
+				n++
+			}
+		}
+	}
+	if n <= len(p) {
+		ok = true
+		idx := 0
+		for b := mbuckets; b != nil; b = b.allnext {
+			if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
+				record(&p[idx], b)
+				idx++
+			}
+		}
+	}
+	gounlock(&proflock)
+	return
+}
+
+func mprof_GC() {
+	for b := mbuckets; b != nil; b = b.allnext {
+		b.data.mp.allocs += b.data.mp.prev_allocs
+		b.data.mp.frees += b.data.mp.prev_frees
+		b.data.mp.alloc_bytes += b.data.mp.prev_alloc_bytes
+		b.data.mp.free_bytes += b.data.mp.prev_free_bytes
+
+		b.data.mp.prev_allocs = b.data.mp.recent_allocs
+		b.data.mp.prev_frees = b.data.mp.recent_frees
+		b.data.mp.prev_alloc_bytes = b.data.mp.recent_alloc_bytes
+		b.data.mp.prev_free_bytes = b.data.mp.recent_free_bytes
+
+		b.data.mp.recent_allocs = 0
+		b.data.mp.recent_frees = 0
+		b.data.mp.recent_alloc_bytes = 0
+		b.data.mp.recent_free_bytes = 0
+	}
+}
+
+// Write b's data to r.
+func record(r *MemProfileRecord, b *bucket) {
+	r.AllocBytes = int64(b.data.mp.alloc_bytes)
+	r.FreeBytes = int64(b.data.mp.free_bytes)
+	r.AllocObjects = int64(b.data.mp.allocs)
+	r.FreeObjects = int64(b.data.mp.frees)
+	for i := 0; uint(i) < b.nstk && i < len(r.Stack0); i++ {
+		r.Stack0[i] = *(*uintptr)(add(unsafe.Pointer(&b.stk), uintptr(i)*ptrSize))
+	}
+	for i := b.nstk; i < uint(len(r.Stack0)); i++ {
+		r.Stack0[i] = 0
+	}
+}
+
+// BlockProfile returns n, the number of records in the current blocking profile.
+// If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
+// If len(p) < n, BlockProfile does not change p and returns n, false.
+//
+// Most clients should use the runtime/pprof package or
+// the testing package's -test.blockprofile flag instead
+// of calling BlockProfile directly.
+func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
+	golock(&proflock)
+	for b := bbuckets; b != nil; b = b.allnext {
+		n++
+	}
+	if n <= len(p) {
+		ok = true
+		idx := 0
+		for b := bbuckets; b != nil; b = b.allnext {
+			bp := (*_4_)(unsafe.Pointer(&b.data))
+			p[idx].Count = int64(bp.count)
+			p[idx].Cycles = int64(bp.cycles)
+			i := 0
+			for uint(i) < b.nstk && i < len(p[idx].Stack0) {
+				p[idx].Stack0[i] = *(*uintptr)(add(unsafe.Pointer(&b.stk), uintptr(i)*ptrSize))
+				i++
+			}
+			for i < len(p[idx].Stack0) {
+				p[idx].Stack0[i] = 0
+				i++
+			}
+			idx++
+		}
+	}
+	gounlock(&proflock)
+	return
+}
+
+// ThreadCreateProfile returns n, the number of records in the thread creation profile.
+// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
+// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
+//
+// Most clients should use the runtime/pprof package instead
+// of calling ThreadCreateProfile directly.
+func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
+	first := (*m)(goatomicloadp(unsafe.Pointer(&allm)))
+	for mp := first; mp != nil; mp = mp.alllink {
+		n++
+	}
+	if n <= len(p) {
+		ok = true
+		i := 0
+		for mp := first; mp != nil; mp = mp.alllink {
+			for s := range mp.createstack {
+				p[i].Stack0[s] = uintptr(mp.createstack[s])
+			}
+			i++
+		}
+	}
+	return
+}
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index 6a028c31f3..3d8d790cdd 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -14,7 +14,7 @@ package runtime
 #include "type.h"
 
 // NOTE(rsc): Everything here could use cas if contention became an issue.
-static Lock proflock;
+extern Lock runtime·proflock;
 
 // All memory allocations are local and do not escape outside of the profiler.
 // The profiler is forbidden from referring to garbage-collected memory.
@@ -25,8 +25,8 @@ enum {
 	BuckHashSize = 179999,
 };
 static Bucket **buckhash;
-static Bucket *mbuckets;  // memory profile buckets
-static Bucket *bbuckets;  // blocking profile buckets
+extern Bucket *runtime·mbuckets;  // memory profile buckets
+extern Bucket *runtime·bbuckets;  // blocking profile buckets
 static uintptr bucketmem;
 
 // Return the bucket for stk[0:nstk], allocating new bucket if needed.
@@ -77,11 +77,11 @@ stkbucket(int32 typ, uintptr size, uintptr *stk, int32 nstk, bool alloc)
 	b->next = buckhash[i];
 	buckhash[i] = b;
 	if(typ == MProf) {
-		b->allnext = mbuckets;
-		mbuckets = b;
+		b->allnext = runtime·mbuckets;
+		runtime·mbuckets = b;
 	} else {
-		b->allnext = bbuckets;
-		bbuckets = b;
+		b->allnext = runtime·bbuckets;
+		runtime·bbuckets = b;
 	}
 	return b;
 }
@@ -91,7 +91,7 @@ MProf_GC(void)
 {
 	Bucket *b;
 
-	for(b=mbuckets; b; b=b->allnext) {
+	for(b=runtime·mbuckets; b; b=b->allnext) {
 		b->data.mp.allocs += b->data.mp.prev_allocs;
 		b->data.mp.frees += b->data.mp.prev_frees;
 		b->data.mp.alloc_bytes += b->data.mp.prev_alloc_bytes;
@@ -113,9 +113,9 @@ MProf_GC(void)
 void
 runtime·MProf_GC(void)
 {
-	runtime·lock(&proflock);
+	runtime·lock(&runtime·proflock);
 	MProf_GC();
-	runtime·unlock(&proflock);
+	runtime·unlock(&runtime·proflock);
 }
 
 // Called by malloc to record a profiled block.
@@ -127,11 +127,11 @@ runtime·MProf_Malloc(void *p, uintptr size)
 	int32 nstk;
 
 	nstk = runtime·callers(1, stk, nelem(stk));
-	runtime·lock(&proflock);
+	runtime·lock(&runtime·proflock);
 	b = stkbucket(MProf, size, stk, nstk, true);
 	b->data.mp.recent_allocs++;
 	b->data.mp.recent_alloc_bytes += size;
-	runtime·unlock(&proflock);
+	runtime·unlock(&runtime·proflock);
 
 	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
 	// This reduces potential contention and chances of deadlocks.
@@ -158,11 +158,11 @@ runtime·mprofMalloc_m(void)
 		nstk = runtime·callers(1, stk, nelem(stk));
 	else
 		nstk = runtime·gcallers(g->m->curg, 1, stk, nelem(stk));
-	runtime·lock(&proflock);
+	runtime·lock(&runtime·proflock);
 	b = stkbucket(MProf, size, stk, nstk, true);
 	b->data.mp.recent_allocs++;
 	b->data.mp.recent_alloc_bytes += size;
-	runtime·unlock(&proflock);
+	runtime·unlock(&runtime·proflock);
 
 	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
 	// This reduces potential contention and chances of deadlocks.
@@ -175,7 +175,7 @@ runtime·mprofMalloc_m(void)
 void
 runtime·MProf_Free(Bucket *b, uintptr size, bool freed)
 {
-	runtime·lock(&proflock);
+	runtime·lock(&runtime·proflock);
 	if(freed) {
 		b->data.mp.recent_frees++;
 		b->data.mp.recent_free_bytes += size;
@@ -183,7 +183,7 @@ runtime·MProf_Free(Bucket *b, uintptr size, bool freed)
 		b->data.mp.prev_frees++;
 		b->data.mp.prev_free_bytes += size;
 	}
-	runtime·unlock(&proflock);
+	runtime·unlock(&runtime·proflock);
 }
 
 int64 runtime·blockprofilerate;  // in CPU ticks
@@ -219,74 +219,11 @@ runtime·blockevent(int64 cycles, int32 skip)
 		return;
 
 	nstk = runtime·callers(skip, stk, nelem(stk));
-	runtime·lock(&proflock);
+	runtime·lock(&runtime·proflock);
 	b = stkbucket(BProf, 0, stk, nstk, true);
 	b->data.bp.count++;
 	b->data.bp.cycles += cycles;
-	runtime·unlock(&proflock);
-}
-
-// Go interface to profile data.  (Declared in debug.go)
-
-// Must match MemProfileRecord in debug.go.
-typedef struct Record Record;
-struct Record {
-	int64 alloc_bytes, free_bytes;
-	int64 alloc_objects, free_objects;
-	uintptr stk[32];
-};
-
-// Write b's data to r.
-static void
-record(Record *r, Bucket *b)
-{
-	int32 i;
-
-	r->alloc_bytes = b->data.mp.alloc_bytes;
-	r->free_bytes = b->data.mp.free_bytes;
-	r->alloc_objects = b->data.mp.allocs;
-	r->free_objects = b->data.mp.frees;
-	for(i=0; i<b->nstk && i<nelem(r->stk); i++)
-		r->stk[i] = b->stk[i];
-	for(; i<nelem(r->stk); i++)
-		r->stk[i] = 0;
-}
-
-func MemProfile(p Slice, include_inuse_zero bool) (n int, ok bool) {
-	Bucket *b;
-	Record *r;
-	bool clear;
-
-	runtime·lock(&proflock);
-	n = 0;
-	clear = true;
-	for(b=mbuckets; b; b=b->allnext) {
-		if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
-			n++;
-		if(b->data.mp.allocs != 0 || b->data.mp.frees != 0)
-			clear = false;
-	}
-	if(clear) {
-		// Absolutely no data, suggesting that a garbage collection
-		// has not yet happened. In order to allow profiling when
-		// garbage collection is disabled from the beginning of execution,
-		// accumulate stats as if a GC just happened, and recount buckets.
-		MProf_GC();
-		MProf_GC();
-		n = 0;
-		for(b=mbuckets; b; b=b->allnext)
-			if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
-				n++;
-	}
-	ok = false;
-	if(n <= p.len) {
-		ok = true;
-		r = (Record*)p.array;
-		for(b=mbuckets; b; b=b->allnext)
-			if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
-				record(r++, b);
-	}
-	runtime·unlock(&proflock);
+	runtime·unlock(&runtime·proflock);
 }
 
 void
@@ -294,45 +231,15 @@ runtime·iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, u
 {
 	Bucket *b;
 
-	runtime·lock(&proflock);
-	for(b=mbuckets; b; b=b->allnext) {
+	runtime·lock(&runtime·proflock);
+	for(b=runtime·mbuckets; b; b=b->allnext) {
 		callback(b, b->nstk, b->stk, b->size, b->data.mp.allocs, b->data.mp.frees);
 	}
-	runtime·unlock(&proflock);
+	runtime·unlock(&runtime·proflock);
 }
 
-// Must match BlockProfileRecord in debug.go.
-typedef struct BRecord BRecord;
-struct BRecord {
-	int64 count;
-	int64 cycles;
-	uintptr stk[32];
-};
+// Go interface to profile data.  (Declared in debug.go)
 
-func BlockProfile(p Slice) (n int, ok bool) {
-	Bucket *b;
-	BRecord *r;
-	int32 i;
-
-	runtime·lock(&proflock);
-	n = 0;
-	for(b=bbuckets; b; b=b->allnext)
-		n++;
-	ok = false;
-	if(n <= p.len) {
-		ok = true;
-		r = (BRecord*)p.array;
-		for(b=bbuckets; b; b=b->allnext, r++) {
-			r->count = b->data.bp.count;
-			r->cycles = b->data.bp.cycles;
-			for(i=0; i<b->nstk && i<nelem(r->stk); i++)
-				r->stk[i] = b->stk[i];
-			for(; i<nelem(r->stk); i++)
-				r->stk[i] = 0;			
-		}
-	}
-	runtime·unlock(&proflock);
-}
 
 // Must match StackRecord in debug.go.
 typedef struct TRecord TRecord;
@@ -340,25 +247,6 @@ struct TRecord {
 	uintptr stk[32];
 };
 
-func ThreadCreateProfile(p Slice) (n int, ok bool) {
-	TRecord *r;
-	M *first, *mp;
-	
-	first = runtime·atomicloadp(&runtime·allm);
-	n = 0;
-	for(mp=first; mp; mp=mp->alllink)
-		n++;
-	ok = false;
-	if(n <= p.len) {
-		ok = true;
-		r = (TRecord*)p.array;
-		for(mp=first; mp; mp=mp->alllink) {
-			runtime·memmove(r->stk, mp->createstack, sizeof r->stk);
-			r++;
-		}
-	}
-}
-
 func Stack(b Slice, all bool) (n int) {
 	uintptr pc, sp;
 	

From e249b0ffeeb36957adfde2b3ec3ab0eabea8e3ba Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 11:43:58 +0400
Subject: [PATCH 139/423] cmd/api: add missing runtime struct Fixes build.

TBR=khr
R=golang-codereviews
CC=golang-codereviews, khr
https://golang.org/cl/130390044
---
 src/cmd/api/goapi.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index e0d17c9564..5933f32563 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -381,7 +381,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{};" +
 			" type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{};" +
 			" type iface struct{}; type eface struct{}; type interfacetype struct{}; type itab struct{};" +
-			" type mcache struct{}"
+			" type mcache struct{}; type bucket struct{}"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)

From a0dbbeae6785ed7fd15feb4feb4975eded83c191 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 11:46:53 +0400
Subject: [PATCH 140/423] runtime: fix deadlock when gctrace Calling
 ReadMemStats which does stoptheworld on m0 holding locks was not a good idea.
 Stoptheworld holding locks is a recipe for deadlocks (added check for this).
 Stoptheworld on g0 may or may not work (added check for this as well). As far
 as I understand scavenger will print incorrect numbers now, as stack usage is
 not subtracted from heap. But it's better than deadlocking.

LGTM=khr
R=golang-codereviews, rsc, khr
CC=golang-codereviews, rlh
https://golang.org/cl/124670043
---
 src/pkg/runtime/heapdump.c | 2 +-
 src/pkg/runtime/malloc.go  | 6 ++++++
 src/pkg/runtime/mheap.c    | 8 ++++----
 src/pkg/runtime/proc.c     | 8 ++++++++
 4 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 63d80b8d0e..a2d12ad603 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -748,7 +748,6 @@ runtime∕debug·WriteHeapDump(uintptr fd)
 	// Stop the world.
 	runtime·semacquire(&runtime·worldsema, false);
 	g->m->gcing = 1;
-	g->m->locks++;
 	runtime·stoptheworld();
 
 	// Update stats so we can dump them.
@@ -774,6 +773,7 @@ runtime∕debug·WriteHeapDump(uintptr fd)
 
 	// Start up the world again.
 	g->m->gcing = 0;
+	g->m->locks++;
 	runtime·semrelease(&runtime·worldsema);
 	runtime·starttheworld();
 	g->m->locks--;
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 8ee460755f..578fbd1c2d 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -413,6 +413,7 @@ func gogc(force int32) {
 		return
 	}
 	releasem(mp)
+	mp = nil
 
 	if panicking != 0 {
 		return
@@ -441,7 +442,11 @@ func gogc(force int32) {
 	startTime := gonanotime()
 	mp = acquirem()
 	mp.gcing = 1
+	releasem(mp)
 	stoptheworld()
+	if mp != acquirem() {
+		gothrow("gogc: rescheduled")
+	}
 
 	clearpools()
 
@@ -474,6 +479,7 @@ func gogc(force int32) {
 	semrelease(&worldsema)
 	starttheworld()
 	releasem(mp)
+	mp = nil
 
 	// now that gc is done, kick off finalizer thread if needed
 	if !concurrentSweep {
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 599872423a..8e6190ce1a 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -608,7 +608,6 @@ scavenge(int32 k, uint64 now, uint64 limit)
 {
 	uint32 i;
 	uintptr sumreleased;
-	MStats stats;
 	MHeap *h;
 	
 	h = &runtime·mheap;
@@ -618,12 +617,13 @@ scavenge(int32 k, uint64 now, uint64 limit)
 	sumreleased += scavengelist(&h->freelarge, now, limit);
 
 	if(runtime·debug.gctrace > 0) {
-		runtime·ReadMemStats(&stats);
 		if(sumreleased > 0)
 			runtime·printf("scvg%d: %D MB released\n", k, (uint64)sumreleased>>20);
+		// TODO(dvyukov): these stats are incorrect as we don't subtract stack usage from heap.
+		// But we can't call ReadMemStats on g0 holding locks.
 		runtime·printf("scvg%d: inuse: %D, idle: %D, sys: %D, released: %D, consumed: %D (MB)\n",
-			k, stats.heap_inuse>>20, stats.heap_idle>>20, stats.heap_sys>>20,
-			stats.heap_released>>20, (stats.heap_sys - stats.heap_released)>>20);
+			k, mstats.heap_inuse>>20, mstats.heap_idle>>20, mstats.heap_sys>>20,
+			mstats.heap_released>>20, (mstats.heap_sys - mstats.heap_released)>>20);
 	}
 }
 
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 2510a421a8..8584cb6f6a 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -498,6 +498,14 @@ runtime·stoptheworld(void)
 	P *p;
 	bool wait;
 
+	// If we hold a lock, then we won't be able to stop another M
+	// that is blocked trying to acquire the lock.
+	if(g->m->locks > 0)
+		runtime·throw("stoptheworld: holding locks");
+	// There is no evidence that stoptheworld on g0 does not work,
+	// we just don't do it today.
+	if(g == g->m->g0)
+		runtime·throw("stoptheworld: on g0");
 	runtime·lock(&runtime·sched.lock);
 	runtime·sched.stopwait = runtime·gomaxprocs;
 	runtime·atomicstore((uint32*)&runtime·sched.gcwaiting, 1);

From 99e9bac8c42ccc950315dff1ee6933d7de180026 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 11:55:05 +0400
Subject: [PATCH 141/423] runtime: init GC later Init GC later as it needs to
 read GOGC env var. Fixes #8562.

LGTM=daniel.morsing, rsc
R=golang-codereviews, daniel.morsing, rsc
CC=golang-codereviews, khr, rlh
https://golang.org/cl/130990043
---
 src/pkg/runtime/env_posix.c |  2 ++
 src/pkg/runtime/proc.c      |  6 +-----
 src/pkg/runtime/runtime.c   | 34 +++++++++++++---------------------
 3 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/src/pkg/runtime/env_posix.c b/src/pkg/runtime/env_posix.c
index edd1d3568d..8bc3ffb0a2 100644
--- a/src/pkg/runtime/env_posix.c
+++ b/src/pkg/runtime/env_posix.c
@@ -22,6 +22,8 @@ runtime·getenv(int8 *s)
 	bs = (byte*)s;
 	len = runtime·findnull(bs);
 	envv = (String*)syscall·envs.array;
+	if(envv == nil)
+		runtime·throw("getenv before env init");
 	envc = syscall·envs.len;
 	for(i=0; i<envc; i++){
 		if(envv[i].len <= len)
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 8584cb6f6a..1e0cd38a06 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -158,7 +158,6 @@ runtime·schedinit(void)
 	runtime·symtabinit();
 	runtime·stackinit();
 	runtime·mallocinit();
-	runtime·gcinit();
 	runtime·chaninit();
 	mcommoninit(g->m);
 	
@@ -168,13 +167,10 @@ runtime·schedinit(void)
 	// need to allocated memory.
 	runtime·newErrorCString(0, &i);
 	
-	// Initialize the cached gotraceback value, since
-	// gotraceback calls getenv, which mallocs on Plan 9.
-	runtime·gotraceback(nil);
-
 	runtime·goargs();
 	runtime·goenvs();
 	runtime·parsedebugvars();
+	runtime·gcinit();
 
 	runtime·sched.lastpoll = runtime·nanotime();
 	procs = 1;
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 98c9edda41..275fffb347 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -12,7 +12,7 @@
 // The cached value is a uint32 in which the low bit
 // is the "crash" setting and the top 31 bits are the
 // gotraceback value.
-static uint32 traceback_cache = ~(uint32)0;
+static uint32 traceback_cache = 2<<1;
 
 // The GOTRACEBACK environment variable controls the
 // behavior of a Go program that is crashing and exiting.
@@ -23,29 +23,13 @@ static uint32 traceback_cache = ~(uint32)0;
 int32
 runtime·gotraceback(bool *crash)
 {
-	byte *p;
-	uint32 x;
-
 	if(crash != nil)
 		*crash = false;
 	if(g->m->traceback != 0)
 		return g->m->traceback;
-	x = runtime·atomicload(&traceback_cache);
-	if(x == ~(uint32)0) {
-		p = runtime·getenv("GOTRACEBACK");
-		if(p == nil)
-			p = (byte*)"";
-		if(p[0] == '\0')
-			x = 1<<1;
-		else if(runtime·strcmp(p, (byte*)"crash") == 0)
-			x = (2<<1) | 1;
-		else
-			x = runtime·atoi(p)<<1;	
-		runtime·atomicstore(&traceback_cache, x);
-	}
 	if(crash != nil)
-		*crash = x&1;
-	return x>>1;
+		*crash = traceback_cache&1;
+	return traceback_cache>>1;
 }
 
 int32
@@ -134,8 +118,6 @@ runtime·goenvs_unix(void)
 	syscall·envs.array = (byte*)s;
 	syscall·envs.len = n;
 	syscall·envs.cap = n;
-
-	traceback_cache = ~(uint32)0;
 }
 
 int32
@@ -354,6 +336,16 @@ runtime·parsedebugvars(void)
 			break;
 		p++;
 	}
+
+	p = runtime·getenv("GOTRACEBACK");
+	if(p == nil)
+		p = (byte*)"";
+	if(p[0] == '\0')
+		traceback_cache = 1<<1;
+	else if(runtime·strcmp(p, (byte*)"crash") == 0)
+		traceback_cache = (2<<1) | 1;
+	else
+		traceback_cache = runtime·atoi(p)<<1;	
 }
 
 // Poor mans 64-bit division.

From 1f5800673bd95a9f912262134d651a319ab6224b Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 12:34:26 +0400
Subject: [PATCH 142/423] cmd/gc: fix undefined behavior
 UndefinedBehaviorSanitizer claims it is UB in C:
 src/cmd/gc/racewalk.c:422:37: runtime error: member access within null
 pointer of type 'Node' (aka 'struct Node') src/cmd/gc/racewalk.c:423:37:
 runtime error: member access within null pointer of type 'Node' (aka 'struct
 Node')

LGTM=rsc
R=dave, rsc
CC=golang-codereviews
https://golang.org/cl/125570043
---
 src/cmd/gc/racewalk.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cmd/gc/racewalk.c b/src/cmd/gc/racewalk.c
index 285bd78a25..27581702cc 100644
--- a/src/cmd/gc/racewalk.c
+++ b/src/cmd/gc/racewalk.c
@@ -419,8 +419,10 @@ racewalknode(Node **np, NodeList **init, int wr, int skip)
 ret:
 	if(n->op != OBLOCK)  // OBLOCK is handled above in a special way.
 		racewalklist(n->list, init);
-	racewalknode(&n->ntest, &n->ntest->ninit, 0, 0);
-	racewalknode(&n->nincr, &n->nincr->ninit, 0, 0);
+	if(n->ntest != N)
+		racewalknode(&n->ntest, &n->ntest->ninit, 0, 0);
+	if(n->nincr != N)
+		racewalknode(&n->nincr, &n->nincr->ninit, 0, 0);
 	racewalklist(n->nbody, nil);
 	racewalklist(n->nelse, nil);
 	racewalklist(n->rlist, nil);

From 6b112c24db0a3c6ddd373c2001129f11f7d9e7f1 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Thu, 21 Aug 2014 17:53:45 +0900
Subject: [PATCH 143/423] net: fix typo

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/128500043
---
 src/pkg/net/sockopt_bsd.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/net/sockopt_bsd.go b/src/pkg/net/sockopt_bsd.go
index 77d51d7376..2d36a55953 100644
--- a/src/pkg/net/sockopt_bsd.go
+++ b/src/pkg/net/sockopt_bsd.go
@@ -17,7 +17,7 @@ func setDefaultSockopts(s, family, sotype int, ipv6only bool) error {
 		// On DragonFly BSD, we adjust the ephemeral port
 		// range because unlike other BSD systems its default
 		// port range doesn't conform to IANA recommendation
-		// as described in RFC 6355 and is pretty narrow.
+		// as described in RFC 6056 and is pretty narrow.
 		switch family {
 		case syscall.AF_INET:
 			syscall.SetsockoptInt(s, syscall.IPPROTO_IP, syscall.IP_PORTRANGE, syscall.IP_PORTRANGE_HIGH)

From 684de0411878ba02c4e949d9c88a0cb8ff0d6a44 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 20:41:09 +0400
Subject: [PATCH 144/423] runtime: convert common scheduler functions to Go
 These are required for chans, semaphores, timers, etc.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/123640043
---
 src/cmd/api/goapi.go           |  2 +-
 src/cmd/gc/select.c            |  1 +
 src/pkg/runtime/asm_386.s      |  6 +++
 src/pkg/runtime/asm_amd64.s    |  6 +++
 src/pkg/runtime/asm_amd64p32.s |  7 ++++
 src/pkg/runtime/asm_arm.s      |  6 +++
 src/pkg/runtime/chan.goc       | 16 ++++----
 src/pkg/runtime/chan.h         |  1 +
 src/pkg/runtime/heapdump.c     |  4 +-
 src/pkg/runtime/malloc.h       |  4 ++
 src/pkg/runtime/mgc0.c         |  9 +++--
 src/pkg/runtime/netpoll.goc    |  2 +-
 src/pkg/runtime/proc.c         | 53 +++++++++++++++----------
 src/pkg/runtime/proc.go        | 71 ++++++++++++++++++++++++++++++++++
 src/pkg/runtime/runtime.h      |  8 ++--
 src/pkg/runtime/sema.goc       |  6 +--
 src/pkg/runtime/stack.c        |  4 +-
 src/pkg/runtime/stubs.go       |  8 +++-
 src/pkg/runtime/stubs.goc      |  5 +++
 src/pkg/runtime/time.goc       |  6 +--
 20 files changed, 175 insertions(+), 50 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 5933f32563..d7b16a0c4f 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -381,7 +381,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{};" +
 			" type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{};" +
 			" type iface struct{}; type eface struct{}; type interfacetype struct{}; type itab struct{};" +
-			" type mcache struct{}; type bucket struct{}"
+			" type mcache struct{}; type bucket struct{}; type sudog struct{}; type g struct{}"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)
diff --git a/src/cmd/gc/select.c b/src/cmd/gc/select.c
index 7168e6b806..cbc199698d 100644
--- a/src/cmd/gc/select.c
+++ b/src/cmd/gc/select.c
@@ -339,6 +339,7 @@ selecttype(int32 size)
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("link")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("releasetime")), typenod(types[TUINT64])));
+	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("nrelease")), typenod(types[TINT32])));
 	typecheck(&sudog, Etype);
 	sudog->type->noalg = 1;
 	sudog->type->local = 1;
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 638d1c5134..741832b4da 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -869,6 +869,12 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-4
 	MOVL	DX, 4(DI)
 	RET
 
+TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
+	RDTSC
+	MOVL    AX, ret+0(FP)
+	MOVL    DX, ret+4(FP)
+	RET
+
 TEXT runtime·ldt0setup(SB),NOSPLIT,$16-0
 	// set up ldt 7 to point at tls0
 	// ldt 1 would be fine on Linux, but on OS X, 7 is as low as we can go.
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 87c23168f6..9fcb2318b9 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -953,6 +953,12 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 	ADDQ	DX, AX
 	RET
 
+TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
+	RDTSC
+	MOVL    AX, ret+0(FP)
+	MOVL    DX, ret+4(FP)
+	RET
+
 TEXT runtime·stackguard(SB),NOSPLIT,$0-16
 	MOVQ	SP, DX
 	MOVQ	DX, sp+0(FP)
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 3e84d95d3f..5c6a73ab99 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -754,6 +754,13 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 	ADDQ	DX, AX
 	RET
 
+TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
+	RDTSC
+	SHLQ    $32, DX
+	ADDQ    DX, AX
+	MOVQ    AX, ret+0(FP)
+	RET
+
 TEXT runtime·stackguard(SB),NOSPLIT,$0-8
 	MOVL	SP, DX
 	MOVL	DX, sp+0(FP)
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 3e0b13e699..4e46767223 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -651,6 +651,12 @@ TEXT runtime·abort(SB),NOSPLIT,$-4-0
 	MOVW	$0, R0
 	MOVW	(R0), R1
 
+TEXT runtime·gocputicks(SB),NOSPLIT,$4-8
+	ADD     $8, SP, R0
+	MOVW    R0, 0(SP)
+	BL      runtime·cputicks(SB)
+	RET
+
 // bool armcas(int32 *val, int32 old, int32 new)
 // Atomically:
 //	if(*val == old){
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 7ddfab3f99..2ef1c8566e 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -119,7 +119,7 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 		USED(t);
 		if(!block)
 			return false;
-		runtime·park(nil, nil, "chan send (nil chan)");
+		runtime·park(nil, nil, runtime·gostringnocopy((byte*)"chan send (nil chan)"));
 		return false;  // not reached
 	}
 
@@ -171,7 +171,7 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 	mysg.selectdone = nil;
 	g->param = nil;
 	enqueue(&c->sendq, &mysg);
-	runtime·parkunlock(&c->lock, "chan send");
+	runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan send"));
 
 	if(g->param == nil) {
 		runtime·lock(&c->lock);
@@ -198,7 +198,7 @@ asynch:
 		mysg.elem = nil;
 		mysg.selectdone = nil;
 		enqueue(&c->sendq, &mysg);
-		runtime·parkunlock(&c->lock, "chan send");
+		runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan send"));
 
 		runtime·lock(&c->lock);
 		goto asynch;
@@ -251,7 +251,7 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 		USED(t);
 		if(!block)
 			return false;
-		runtime·park(nil, nil, "chan receive (nil chan)");
+		runtime·park(nil, nil, runtime·gostringnocopy((byte*)"chan receive (nil chan)"));
 		return false;  // not reached
 	}
 
@@ -298,7 +298,7 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 	mysg.selectdone = nil;
 	g->param = nil;
 	enqueue(&c->recvq, &mysg);
-	runtime·parkunlock(&c->lock, "chan receive");
+	runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan receive"));
 
 	if(g->param == nil) {
 		runtime·lock(&c->lock);
@@ -328,7 +328,7 @@ asynch:
 		mysg.elem = nil;
 		mysg.selectdone = nil;
 		enqueue(&c->recvq, &mysg);
-		runtime·parkunlock(&c->lock, "chan receive");
+		runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan receive"));
 
 		runtime·lock(&c->lock);
 		goto asynch;
@@ -658,7 +658,7 @@ selparkcommit(G *gp, void *sel)
 }
 
 func block() {
-	runtime·park(nil, nil, "select (no cases)");	// forever
+	runtime·park(nil, nil, runtime·gostringnocopy((byte*)"select (no cases)"));	// forever
 }
 
 static void* selectgo(Select**);
@@ -826,7 +826,7 @@ loop:
 	}
 
 	g->param = nil;
-	runtime·park(selparkcommit, sel, "select");
+	runtime·park(selparkcommit, sel, runtime·gostringnocopy((byte*)"select"));
 
 	sellock(sel);
 	sg = g->param;
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index e6e6bacd32..5ac39cab88 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -18,6 +18,7 @@ struct	SudoG
 	SudoG*	link;
 	byte*	elem;		// data element
 	int64	releasetime;
+	int32	nrelease;	// -1 for acquire
 };
 
 struct	WaitQ
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index a2d12ad603..3fc54aedbc 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -408,7 +408,7 @@ dumpgoroutine(G *gp)
 	dumpbool(gp->issystem);
 	dumpbool(gp->isbackground);
 	dumpint(gp->waitsince);
-	dumpcstr(gp->waitreason);
+	dumpstr(gp->waitreason);
 	dumpint((uintptr)gp->sched.ctxt);
 	dumpint((uintptr)gp->m);
 	dumpint((uintptr)gp->defer);
@@ -760,7 +760,7 @@ runtime∕debug·WriteHeapDump(uintptr fd)
 
 	// Call dump routine on M stack.
 	g->status = Gwaiting;
-	g->waitreason = "dumping heap";
+	g->waitreason = runtime·gostringnocopy((byte*)"dumping heap");
 	runtime·mcall(mdump);
 
 	// Reset dump file.
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index a700956b0c..4485100098 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -318,6 +318,8 @@ struct StackFreeList
 	uintptr size; // total size of stacks in list
 };
 
+typedef struct SudoG SudoG;
+
 // Per-thread (in Go, per-P) cache for small objects.
 // No locking needed because it is per-thread (per-P).
 struct MCache
@@ -335,6 +337,8 @@ struct MCache
 
 	StackFreeList stackcache[NumStackOrders];
 
+	SudoG*	sudogcache;
+
 	void*	gcworkbuf;
 
 	// Local allocator stats, flushed during GC.
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 14743c2838..2d378e2aa3 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -107,6 +107,7 @@ runtime·clearpools(void)
 		if(c != nil) {
 			c->tiny = nil;
 			c->tinysize = 0;
+			c->sudogcache = nil;
 		}
 		// clear defer pools
 		for(i=0; i<nelem(p->deferpool); i++)
@@ -1110,7 +1111,7 @@ bgsweep(void)
 		}
 		sweep.parked = true;
 		g->isbackground = true;
-		runtime·parkunlock(&gclock, "GC sweep wait");
+		runtime·parkunlock(&gclock, runtime·gostringnocopy((byte*)"GC sweep wait"));
 		g->isbackground = false;
 	}
 }
@@ -1374,7 +1375,7 @@ runtime·gc(int32 force)
 		// switch to g0, call gc(&a), then switch back
 		g->param = &a;
 		g->status = Gwaiting;
-		g->waitreason = "garbage collection";
+		g->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
 		runtime·mcall(mgc);
 	}
 
@@ -1409,7 +1410,7 @@ runtime·gc_m(void)
 
 	gp = g->m->curg;
 	gp->status = Gwaiting;
-	gp->waitreason = "garbage collection";
+	gp->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
 
 	a.start_time = (uint64)(g->m->scalararg[0]) | ((uint64)(g->m->scalararg[1]) << 32);
 	a.eagersweep = g->m->scalararg[2];
@@ -1663,7 +1664,7 @@ runfinq(void)
 		if(fb == nil) {
 			runtime·fingwait = true;
 			g->isbackground = true;
-			runtime·parkunlock(&finlock, "finalizer wait");
+			runtime·parkunlock(&finlock, runtime·gostringnocopy((byte*)"finalizer wait"));
 			g->isbackground = false;
 			continue;
 		}
diff --git a/src/pkg/runtime/netpoll.goc b/src/pkg/runtime/netpoll.goc
index eb7f8878cb..bbb3d06e9a 100644
--- a/src/pkg/runtime/netpoll.goc
+++ b/src/pkg/runtime/netpoll.goc
@@ -346,7 +346,7 @@ netpollblock(PollDesc *pd, int32 mode, bool waitio)
 	// this is necessary because runtime_pollUnblock/runtime_pollSetDeadline/deadlineimpl
 	// do the opposite: store to closing/rd/wd, membarrier, load of rg/wg
 	if(waitio || checkerr(pd, mode) == 0)
-		runtime·park((bool(*)(G*, void*))blockcommit, gpp, "IO wait");
+		runtime·park((bool(*)(G*, void*))blockcommit, gpp, runtime·gostringnocopy((byte*)"IO wait"));
 	// be careful to not lose concurrent READY notification
 	old = runtime·xchgp(gpp, nil);
 	if(old > WAIT)
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 1e0cd38a06..5ff38fb692 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -113,7 +113,7 @@ static uint32 retake(int64);
 static void incidlelocked(int32);
 static void checkdead(void);
 static void exitsyscall0(G*);
-static void park0(G*);
+void runtime·park_m(G*);
 static void goexit0(G*);
 static void gfput(P*, G*);
 static G* gfget(P*);
@@ -265,7 +265,7 @@ runtime·main(void)
 	// let the other goroutine finish printing the panic trace.
 	// Once it does, it will exit. See issue 3934.
 	if(runtime·panicking)
-		runtime·park(nil, nil, "panicwait");
+		runtime·park(nil, nil, runtime·gostringnocopy((byte*)"panicwait"));
 
 	runtime·exit(0);
 	for(;;)
@@ -275,30 +275,30 @@ runtime·main(void)
 void
 runtime·goroutineheader(G *gp)
 {
-	int8 *status;
+	String status;
 	int64 waitfor;
 
 	switch(gp->status) {
 	case Gidle:
-		status = "idle";
+		status = runtime·gostringnocopy((byte*)"idle");
 		break;
 	case Grunnable:
-		status = "runnable";
+		status = runtime·gostringnocopy((byte*)"runnable");
 		break;
 	case Grunning:
-		status = "running";
+		status = runtime·gostringnocopy((byte*)"running");
 		break;
 	case Gsyscall:
-		status = "syscall";
+		status = runtime·gostringnocopy((byte*)"syscall");
 		break;
 	case Gwaiting:
-		if(gp->waitreason)
+		if(gp->waitreason.str != nil)
 			status = gp->waitreason;
 		else
-			status = "waiting";
+			status = runtime·gostringnocopy((byte*)"waiting");
 		break;
 	default:
-		status = "???";
+		status = runtime·gostringnocopy((byte*)"???");
 		break;
 	}
 
@@ -307,7 +307,7 @@ runtime·goroutineheader(G *gp)
 	if((gp->status == Gwaiting || gp->status == Gsyscall) && gp->waitsince != 0)
 		waitfor = (runtime·nanotime() - gp->waitsince) / (60LL*1000*1000*1000);
 
-	runtime·printf("goroutine %D [%s", gp->goid, status);
+	runtime·printf("goroutine %D [%S", gp->goid, status);
 	if(waitfor >= 1)
 		runtime·printf(", %D minutes", waitfor);
 	if(gp->lockedm != nil)
@@ -401,6 +401,16 @@ runtime·ready(G *gp)
 		g->stackguard0 = StackPreempt;
 }
 
+void
+runtime·ready_m(void)
+{
+	G *gp;
+
+	gp = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	runtime·ready(gp);
+}
+
 int32
 runtime·gcprocs(void)
 {
@@ -1401,18 +1411,18 @@ dropg(void)
 // Puts the current goroutine into a waiting state and calls unlockf.
 // If unlockf returns false, the goroutine is resumed.
 void
-runtime·park(bool(*unlockf)(G*, void*), void *lock, int8 *reason)
+runtime·park(bool(*unlockf)(G*, void*), void *lock, String reason)
 {
 	if(g->status != Grunning)
 		runtime·throw("bad g status");
 	g->m->waitlock = lock;
 	g->m->waitunlockf = unlockf;
 	g->waitreason = reason;
-	runtime·mcall(park0);
+	runtime·mcall(runtime·park_m);
 }
 
-static bool
-parkunlock(G *gp, void *lock)
+bool
+runtime·parkunlock_c(G *gp, void *lock)
 {
 	USED(gp);
 	runtime·unlock(lock);
@@ -1422,14 +1432,14 @@ parkunlock(G *gp, void *lock)
 // Puts the current goroutine into a waiting state and unlocks the lock.
 // The goroutine can be made runnable again by calling runtime·ready(gp).
 void
-runtime·parkunlock(Lock *lock, int8 *reason)
+runtime·parkunlock(Lock *lock, String reason)
 {
-	runtime·park(parkunlock, lock, reason);
+	runtime·park(runtime·parkunlock_c, lock, reason);
 }
 
 // runtime·park continuation on g0.
-static void
-park0(G *gp)
+void
+runtime·park_m(G *gp)
 {
 	bool ok;
 
@@ -1499,7 +1509,8 @@ goexit0(G *gp)
 	gp->panic = nil; // non-nil for Goexit during panic. points at stack-allocated data.
 	gp->writenbuf = 0;
 	gp->writebuf = nil;
-	gp->waitreason = nil;
+	gp->waitreason.str = nil;
+	gp->waitreason.len = 0;
 	gp->param = nil;
 	
 	dropg();
@@ -2819,7 +2830,7 @@ runtime·schedtrace(bool detailed)
 		gp = runtime·allg[gi];
 		mp = gp->m;
 		lockedm = gp->lockedm;
-		runtime·printf("  G%D: status=%d(%s) m=%d lockedm=%d\n",
+		runtime·printf("  G%D: status=%d(%S) m=%d lockedm=%d\n",
 			gp->goid, gp->status, gp->waitreason, mp ? mp->id : -1,
 			lockedm ? lockedm->id : -1);
 	}
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 1b586e8c62..7a3864f3bc 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -4,8 +4,79 @@
 
 package runtime
 
+import "unsafe"
+
+const (
+	gStatusidle = iota
+	gStatusRunnable
+	gStatusRunning
+	gStatusSyscall
+	gStatusWaiting
+	gStatusMoribundUnused
+	gStatusDead
+)
+
+var parkunlock_c byte
+
 // Gosched yields the processor, allowing other goroutines to run.  It does not
 // suspend the current goroutine, so execution resumes automatically.
 func Gosched() {
 	mcall(&gosched_m)
 }
+
+// Puts the current goroutine into a waiting state and calls unlockf.
+// If unlockf returns false, the goroutine is resumed.
+func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
+	mp := acquirem()
+	gp := mp.curg
+	if gp.status != gStatusRunning {
+		gothrow("gopark: bad g status")
+	}
+	mp.waitlock = lock
+	mp.waitunlockf = *(*func(*g, unsafe.Pointer) uint8)(unsafe.Pointer(&unlockf))
+	gp.waitreason = reason
+	releasem(mp)
+	// can't do anything that might move the G between Ms here.
+	mcall(&park_m)
+}
+
+// Puts the current goroutine into a waiting state and unlocks the lock.
+// The goroutine can be made runnable again by calling goready(gp).
+func goparkunlock(lock *lock, reason string) {
+	gopark(unsafe.Pointer(&parkunlock_c), unsafe.Pointer(lock), reason)
+}
+
+func goready(gp *g) {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(gp)
+	onM(&ready_m)
+	releasem(mp)
+}
+
+func goblockevent(cycles int64, skip int32) {
+	// TODO: convert to Go when we do mprof.goc
+	mp := acquirem()
+	mp.scalararg[0] = uint(uint32(cycles))
+	mp.scalararg[1] = uint(cycles >> 32)
+	mp.scalararg[2] = uint(skip)
+	onM(&blockevent_m)
+	releasem(mp)
+}
+
+//go:nosplit
+func acquireSudog() *sudog {
+	c := gomcache()
+	s := c.sudogcache
+	if s != nil {
+		c.sudogcache = s.link
+		return s
+	}
+	return new(sudog)
+}
+
+//go:nosplit
+func releaseSudog(s *sudog) {
+	c := gomcache()
+	s.link = c.sudogcache
+	c.sudogcache = s
+}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 867da3f46a..2c004b4eab 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -267,7 +267,7 @@ struct	G
 	int16	status;
 	int64	goid;
 	int64	waitsince;	// approx time when the G become blocked
-	int8*	waitreason;	// if status==Gwaiting
+	String	waitreason;	// if status==Gwaiting
 	G*	schedlink;
 	bool	ispanic;
 	bool	issystem;	// do not output in stack dump
@@ -922,9 +922,9 @@ void	runtime·breakpoint(void);
 void	runtime·gosched(void);
 void	runtime·gosched_m(G*);
 void	runtime·schedtrace(bool);
-void	runtime·park(bool(*)(G*, void*), void*, int8*);
-void	runtime·parkunlock(Lock*, int8*);
-void	runtime·tsleep(int64, int8*);
+void	runtime·park(bool(*)(G*, void*), void*, String);
+void	runtime·parkunlock(Lock*, String);
+void	runtime·tsleep(int64, String);
 M*	runtime·newm(void);
 void	runtime·goexit(void);
 void	runtime·asmcgocall(void (*fn)(void*), void*);
diff --git a/src/pkg/runtime/sema.goc b/src/pkg/runtime/sema.goc
index 59a890c3e2..7b1f8f2ed3 100644
--- a/src/pkg/runtime/sema.goc
+++ b/src/pkg/runtime/sema.goc
@@ -137,7 +137,7 @@ runtime·semacquire(uint32 volatile *addr, bool profile)
 		// Any semrelease after the cansemacquire knows we're waiting
 		// (we set nwait above), so go to sleep.
 		semqueue(root, addr, &s);
-		runtime·parkunlock(&root->lock, "semacquire");
+		runtime·parkunlock(&root->lock, runtime·gostringnocopy((byte*)"semacquire"));
 		if(cansemacquire(addr)) {
 			if(t0)
 				runtime·blockevent(s.releasetime - t0, 3);
@@ -254,7 +254,7 @@ func runtime_Syncsemacquire(s *SyncSema) {
 		else
 			s->tail->next = &w;
 		s->tail = &w;
-		runtime·parkunlock(&s->lock, "semacquire");
+		runtime·parkunlock(&s->lock, runtime·gostringnocopy((byte*)"semacquire"));
 		if(t0)
 			runtime·blockevent(w.releasetime - t0, 2);
 	}
@@ -288,7 +288,7 @@ func runtime_Syncsemrelease(s *SyncSema, n uint32) {
 		else
 			s->tail->next = &w;
 		s->tail = &w;
-		runtime·parkunlock(&s->lock, "semarelease");
+		runtime·parkunlock(&s->lock, runtime·gostringnocopy((byte*)"semarelease"));
 	} else
 		runtime·unlock(&s->lock);
 }
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index f21d544f33..aeb5fb7211 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -343,7 +343,7 @@ runtime·oldstack(void)
 	gp->sched.ret = g->m->cret;
 	g->m->cret = 0; // drop reference
 	gp->status = Gwaiting;
-	gp->waitreason = "stack unsplit";
+	gp->waitreason = runtime·gostringnocopy((byte*)"stack unsplit");
 
 	if(argsize > 0) {
 		sp -= argsize;
@@ -860,7 +860,7 @@ runtime·newstack(void)
 	g->m->morebuf.lr = (uintptr)nil;
 	g->m->morebuf.sp = (uintptr)nil;
 	gp->status = Gwaiting;
-	gp->waitreason = "stack growth";
+	gp->waitreason = runtime·gostringnocopy((byte*)"stack growth");
 	newstackcall = framesize==1;
 	if(newstackcall)
 		framesize = 0;
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 39244ef9df..f3ac783aca 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -41,6 +41,7 @@ func roundup(p unsafe.Pointer, n uintptr) unsafe.Pointer {
 }
 
 // in stubs.goc
+func getg() *g
 func acquirem() *m
 func releasem(mp *m)
 func gomcache() *mcache
@@ -69,7 +70,10 @@ var (
 	markallocated_m,
 	unrollgcprog_m,
 	unrollgcproginplace_m,
-	gosched_m mFunction
+	gosched_m,
+	ready_m,
+	park_m,
+	blockevent_m mFunction
 )
 
 // memclr clears n bytes starting at ptr.
@@ -163,3 +167,5 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 // gopersistentalloc allocates a permanent (not garbage collected)
 // memory region of size n.  Use wisely!
 func gopersistentalloc(n uintptr) unsafe.Pointer
+
+func gocputicks() int64
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index e646b55181..74762dab8a 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -68,6 +68,11 @@ func runtime·gocasx(p *uintptr, x uintptr, y uintptr) (ret bool) {
 	ret = runtime·casp((void**)p, (void*)x, (void*)y);
 }
 
+#pragma textflag NOSPLIT
+func runtime·getg() (ret *G) {
+	ret = g;
+}
+
 #pragma textflag NOSPLIT
 func runtime·acquirem() (ret *M) {
 	ret = g->m;
diff --git a/src/pkg/runtime/time.goc b/src/pkg/runtime/time.goc
index fa25671e6e..f9126bd76a 100644
--- a/src/pkg/runtime/time.goc
+++ b/src/pkg/runtime/time.goc
@@ -36,7 +36,7 @@ func runtimeNano() (ns int64) {
 
 // Sleep puts the current goroutine to sleep for at least ns nanoseconds.
 func Sleep(ns int64) {
-	runtime·tsleep(ns, "sleep");
+	runtime·tsleep(ns, runtime·gostringnocopy((byte*)"sleep"));
 }
 
 // startTimer adds t to the timer heap.
@@ -81,7 +81,7 @@ static FuncVal readyv = {(void(*)(void))ready};
 
 // Put the current goroutine to sleep for ns nanoseconds.
 void
-runtime·tsleep(int64 ns, int8 *reason)
+runtime·tsleep(int64 ns, String reason)
 {
 	Timer t;
 
@@ -248,7 +248,7 @@ timerproc(void)
 			// No timers left - put goroutine to sleep.
 			timers.rescheduling = true;
 			g->isbackground = true;
-			runtime·parkunlock(&timers.lock, "timer goroutine (idle)");
+			runtime·parkunlock(&timers.lock, runtime·gostringnocopy((byte*)"timer goroutine (idle)"));
 			g->isbackground = false;
 			continue;
 		}

From 31e4ad5846d21cb5db1cc52a38a89acc915701b5 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 21:10:30 +0400
Subject: [PATCH 145/423] runtime: remove now arg from timer callback Cleanup
 before converting to Go. Fortunately nobody using it, because it is
 incorrect: monotonic runtime time instead of claimed real time.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rsc
https://golang.org/cl/129480043
---
 src/pkg/runtime/netpoll.goc   | 21 ++++++++++-----------
 src/pkg/runtime/time.goc      |  8 +++-----
 src/pkg/time/internal_test.go |  2 +-
 src/pkg/time/sleep.go         |  6 +++---
 4 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/src/pkg/runtime/netpoll.goc b/src/pkg/runtime/netpoll.goc
index bbb3d06e9a..e8ae84f127 100644
--- a/src/pkg/runtime/netpoll.goc
+++ b/src/pkg/runtime/netpoll.goc
@@ -74,9 +74,9 @@ static struct
 
 static bool	netpollblock(PollDesc*, int32, bool);
 static G*	netpollunblock(PollDesc*, int32, bool);
-static void	deadline(int64, Eface);
-static void	readDeadline(int64, Eface);
-static void	writeDeadline(int64, Eface);
+static void	deadline(Eface);
+static void	readDeadline(Eface);
+static void	writeDeadline(Eface);
 static PollDesc*	allocPollDesc(void);
 static intgo	checkerr(PollDesc *pd, int32 mode);
 
@@ -384,13 +384,12 @@ netpollunblock(PollDesc *pd, int32 mode, bool ioready)
 }
 
 static void
-deadlineimpl(int64 now, Eface arg, bool read, bool write)
+deadlineimpl(Eface arg, bool read, bool write)
 {
 	PollDesc *pd;
 	uint32 seq;
 	G *rg, *wg;
 
-	USED(now);
 	pd = (PollDesc*)arg.data;
 	// This is the seq when the timer was set.
 	// If it's stale, ignore the timer event.
@@ -424,21 +423,21 @@ deadlineimpl(int64 now, Eface arg, bool read, bool write)
 }
 
 static void
-deadline(int64 now, Eface arg)
+deadline(Eface arg)
 {
-	deadlineimpl(now, arg, true, true);
+	deadlineimpl(arg, true, true);
 }
 
 static void
-readDeadline(int64 now, Eface arg)
+readDeadline(Eface arg)
 {
-	deadlineimpl(now, arg, true, false);
+	deadlineimpl(arg, true, false);
 }
 
 static void
-writeDeadline(int64 now, Eface arg)
+writeDeadline(Eface arg)
 {
-	deadlineimpl(now, arg, false, true);
+	deadlineimpl(arg, false, true);
 }
 
 static PollDesc*
diff --git a/src/pkg/runtime/time.goc b/src/pkg/runtime/time.goc
index f9126bd76a..1d6346233c 100644
--- a/src/pkg/runtime/time.goc
+++ b/src/pkg/runtime/time.goc
@@ -70,10 +70,8 @@ static void siftdown(int32);
 
 // Ready the goroutine e.data.
 static void
-ready(int64 now, Eface e)
+ready(Eface e)
 {
-	USED(now);
-
 	runtime·ready(e.data);
 }
 
@@ -201,7 +199,7 @@ timerproc(void)
 {
 	int64 delta, now;
 	Timer *t;
-	void (*f)(int64, Eface);
+	void (*f)(Eface);
 	Eface arg;
 
 	for(;;) {
@@ -233,7 +231,7 @@ timerproc(void)
 			runtime·unlock(&timers.lock);
 			if(raceenabled)
 				runtime·raceacquire(t);
-			f(now, arg);
+			f(arg);
 
 			// clear f and arg to avoid leak while sleeping for next timer
 			f = nil;
diff --git a/src/pkg/time/internal_test.go b/src/pkg/time/internal_test.go
index f09d30507f..b02292ea16 100644
--- a/src/pkg/time/internal_test.go
+++ b/src/pkg/time/internal_test.go
@@ -12,7 +12,7 @@ func init() {
 var Interrupt = interrupt
 var DaysIn = daysIn
 
-func empty(now int64, arg interface{}) {}
+func empty(arg interface{}) {}
 
 // Test that a runtimeTimer with a duration so large it overflows
 // does not cause other timers to hang.
diff --git a/src/pkg/time/sleep.go b/src/pkg/time/sleep.go
index 6a03f417bd..0fd7c9328e 100644
--- a/src/pkg/time/sleep.go
+++ b/src/pkg/time/sleep.go
@@ -17,7 +17,7 @@ type runtimeTimer struct {
 	i      int32
 	when   int64
 	period int64
-	f      func(int64, interface{}) // NOTE: must not be closure
+	f      func(interface{}) // NOTE: must not be closure
 	arg    interface{}
 }
 
@@ -83,7 +83,7 @@ func (t *Timer) Reset(d Duration) bool {
 	return active
 }
 
-func sendTime(now int64, c interface{}) {
+func sendTime(c interface{}) {
 	// Non-blocking send of time on c.
 	// Used in NewTimer, it cannot block anyway (buffer).
 	// Used in NewTicker, dropping sends on the floor is
@@ -117,6 +117,6 @@ func AfterFunc(d Duration, f func()) *Timer {
 	return t
 }
 
-func goFunc(now int64, arg interface{}) {
+func goFunc(arg interface{}) {
 	go arg.(func())()
 }

From ae875e040c6200c9bfae0df9f17d4620abc9e707 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 21 Aug 2014 21:10:45 +0400
Subject: [PATCH 146/423] runtime: convert lfstack to Go It is called from Go
 only in tests.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/125610043
---
 src/pkg/runtime/export_test.go             | 27 ++++++++++++++++++----
 src/pkg/runtime/{lfstack.goc => lfstack.c} | 16 +++++++++----
 2 files changed, 34 insertions(+), 9 deletions(-)
 rename src/pkg/runtime/{lfstack.goc => lfstack.c} (86%)

diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index adbc1e9955..4ca5a7354f 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -6,6 +6,8 @@
 
 package runtime
 
+import "unsafe"
+
 var Fadd64 = fadd64
 var Fsub64 = fsub64
 var Fmul64 = fmul64
@@ -31,11 +33,28 @@ type LFNode struct {
 	Pushcnt uintptr
 }
 
-func lfstackpush_go(head *uint64, node *LFNode)
-func lfstackpop_go(head *uint64) *LFNode
+var (
+	lfstackpush_m,
+	lfstackpop_m mFunction
+)
 
-var LFStackPush = lfstackpush_go
-var LFStackPop = lfstackpop_go
+func LFStackPush(head *uint64, node *LFNode) {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(head)
+	mp.ptrarg[1] = unsafe.Pointer(node)
+	onM(&lfstackpush_m)
+	releasem(mp)
+}
+
+func LFStackPop(head *uint64) *LFNode {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(head)
+	onM(&lfstackpop_m)
+	node := (*LFNode)(unsafe.Pointer(mp.ptrarg[0]))
+	mp.ptrarg[0] = nil
+	releasem(mp)
+	return node
+}
 
 type ParFor struct {
 	body    *byte
diff --git a/src/pkg/runtime/lfstack.goc b/src/pkg/runtime/lfstack.c
similarity index 86%
rename from src/pkg/runtime/lfstack.goc
rename to src/pkg/runtime/lfstack.c
index f7b8effa07..57e0af2829 100644
--- a/src/pkg/runtime/lfstack.goc
+++ b/src/pkg/runtime/lfstack.c
@@ -3,8 +3,8 @@
 // license that can be found in the LICENSE file.
 
 // Lock-free stack.
+// The following code runs only on g0 stack.
 
-package runtime
 #include "runtime.h"
 #include "arch_GOARCH.h"
 
@@ -72,10 +72,16 @@ runtime·lfstackpop(uint64 *head)
 	}
 }
 
-func lfstackpush_go(head *uint64, node *LFNode) {
-	runtime·lfstackpush(head, node);
+void
+runtime·lfstackpush_m(void)
+{
+	runtime·lfstackpush(g->m->ptrarg[0], g->m->ptrarg[1]);
+	g->m->ptrarg[0] = nil;
+	g->m->ptrarg[1] = nil;
 }
 
-func lfstackpop_go(head *uint64) (node *LFNode) {
-	node = runtime·lfstackpop(head);
+void
+runtime·lfstackpop_m(void)
+{
+	g->m->ptrarg[0] = runtime·lfstackpop(g->m->ptrarg[0]);
 }

From b2cc08b18ddb98ab232432bc87f08dbfb64f3a43 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Thu, 21 Aug 2014 10:15:19 -0700
Subject: [PATCH 147/423] A+C: Mark Theunissen (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/126500044
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 893c7945f3..fe0bdf9895 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -260,6 +260,7 @@ Luke Curley <qpingu@gmail.com>
 Manuel Mendez <mmendez534@gmail.com>
 Marc Weistroff <marc@weistroff.net>
 Marco Hennings <marco.hennings@freiheit.com>
+Mark Theunissen <mark.theunissen@gmail.com>
 Marko Juhani Silokunnas <marko.silokunnas@gmail.com>
 Marko Tiikkaja <marko@joh.to>
 Markover Inc. DBA Poptip
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 8ccecfee5d..b6b8d03a11 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -371,6 +371,7 @@ Manuel Mendez <mmendez534@gmail.com>
 Marc Weistroff <marc@weistroff.net>
 Marcel van Lohuizen <mpvl@golang.org>
 Marco Hennings <marco.hennings@freiheit.com>
+Mark Theunissen <mark.theunissen@gmail.com>
 Mark Zavislak <zavislak@google.com>
 Marko Juhani Silokunnas <marko.silokunnas@gmail.com>
 Marko Mikulicic <mkm@google.com>

From 1a1d43239e42184694d0207ffad9bbb77d8e8f76 Mon Sep 17 00:00:00 2001
From: Mark Theunissen <mark.theunissen@gmail.com>
Date: Thu, 21 Aug 2014 10:16:34 -0700
Subject: [PATCH 148/423] net/http/httputil: Pass a Logger to ReverseProxy,
 allowing the user to control logging.

Fixes #8553.

LGTM=bradfitz
R=golang-codereviews, dave, bradfitz
CC=golang-codereviews
https://golang.org/cl/132750043
---
 src/pkg/net/http/httputil/reverseproxy.go | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/pkg/net/http/httputil/reverseproxy.go b/src/pkg/net/http/httputil/reverseproxy.go
index 48ada5f5fd..ab46370180 100644
--- a/src/pkg/net/http/httputil/reverseproxy.go
+++ b/src/pkg/net/http/httputil/reverseproxy.go
@@ -40,6 +40,12 @@ type ReverseProxy struct {
 	// response body.
 	// If zero, no periodic flushing is done.
 	FlushInterval time.Duration
+
+	// ErrorLog specifies an optional logger for errors
+	// that occur when attempting to proxy the request.
+	// If nil, logging goes to os.Stderr via the log package's
+	// standard logger.
+	ErrorLog *log.Logger
 }
 
 func singleJoiningSlash(a, b string) string {
@@ -138,7 +144,7 @@ func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 
 	res, err := transport.RoundTrip(outreq)
 	if err != nil {
-		log.Printf("http: proxy error: %v", err)
+		p.logf("http: proxy error: %v", err)
 		rw.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -171,6 +177,14 @@ func (p *ReverseProxy) copyResponse(dst io.Writer, src io.Reader) {
 	io.Copy(dst, src)
 }
 
+func (p *ReverseProxy) logf(format string, args ...interface{}) {
+	if p.ErrorLog != nil {
+		p.ErrorLog.Printf(format, args...)
+	} else {
+		log.Printf(format, args...)
+	}
+}
+
 type writeFlusher interface {
 	io.Writer
 	http.Flusher

From d27dfd2152efd34d0603fdb105b1aaeb0f8b492e Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Thu, 21 Aug 2014 10:16:49 -0700
Subject: [PATCH 149/423] cmd/api: reduce stutter in runtime type stubs

LGTM=khr
R=khr
CC=dvyukov, golang-codereviews
https://golang.org/cl/132770044
---
 src/cmd/api/goapi.go | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index d7b16a0c4f..07f007fdfb 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -378,10 +378,12 @@ 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.
-		src := "package runtime; type maptype struct{}; type _type struct{}; type alg struct{};" +
-			" type mspan struct{}; type m struct{}; type lock struct{}; type slicetype struct{};" +
-			" type iface struct{}; type eface struct{}; type interfacetype struct{}; type itab struct{};" +
-			" type mcache struct{}; type bucket struct{}; type sudog struct{}; type g struct{}"
+		src := "package runtime; type (" +
+			" maptype struct{}; _type struct{}; alg struct{};" +
+			" mspan struct{}; m struct{}; lock struct{}; slicetype struct{};" +
+			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
+			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
+			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)

From b9cd8f08c7d75d1b0163121d545a54c37f04c3cc Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Thu, 21 Aug 2014 10:34:02 -0700
Subject: [PATCH 150/423] A+C: Alberto Donizetti (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/125660043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index fe0bdf9895..44be520446 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -16,6 +16,7 @@ Adrien Bustany <adrien-xx-google@bustany.org>
 Akshat Kumar <seed@mail.nanosouffle.net>
 Alan Shreve <alan@inconshreveable.com>
 Albert Strasheim <fullung@gmail.com>
+Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Alex A Skinner <alex@lx.lc>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index b6b8d03a11..73a404dd0f 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -42,6 +42,7 @@ Akshat Kumar <seed@mail.nanosouffle.net>
 Alan Donovan <adonovan@google.com>
 Alan Shreve <alan@inconshreveable.com>
 Albert Strasheim <fullung@gmail.com>
+Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Alex A Skinner <alex@lx.lc>

From 5e70140521ac2e5c004de8cd61321d3a51619ae6 Mon Sep 17 00:00:00 2001
From: Alberto Donizetti <alb.donizetti@gmail.com>
Date: Thu, 21 Aug 2014 10:35:43 -0700
Subject: [PATCH 151/423] time: removed from tests now obsolete assumption
 about Australian tz abbreviations

Australian timezones abbreviation for standard and daylight saving time were recently
changed from EST for both to AEST and AEDT in the icann tz database (see changelog
on www.iana.org/time-zones).

A test in the time package was written to check that the ParseInLocation function
understand that Feb EST and Aug EST are different time zones, even though they are
both called EST. This is no longer the case, and the Date function now returns
AEST or AEDT for australian tz on every Linux system with an up to date tz database
(and this makes the test fail).

Since I wasn't able to find another country that 1) uses daylight saving and 2) has
the same abbreviation for both on tzdata, I changed the test to make sure that
ParseInLocation does not get confused when it parses, in different locations, two
dates with the same abbreviation (this was suggested in the mailing list).

Fixes #8547.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/130920043
---
 src/pkg/time/format_test.go | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/src/pkg/time/format_test.go b/src/pkg/time/format_test.go
index a7c6d55b2f..ecc5c8f28a 100644
--- a/src/pkg/time/format_test.go
+++ b/src/pkg/time/format_test.go
@@ -183,39 +183,45 @@ func TestParse(t *testing.T) {
 	}
 }
 
-func TestParseInSydney(t *testing.T) {
-	loc, err := LoadLocation("Australia/Sydney")
+func TestParseInLocation(t *testing.T) {
+	// Check that Parse (and ParseInLocation) understand that
+	// Feb 01 AST (Arabia Standard Time) and Feb 01 AST (Atlantic Standard Time)
+	// are in different time zones even though both are called AST
+
+	baghdad, err := LoadLocation("Asia/Baghdad")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	// Check that Parse (and ParseInLocation) understand
-	// that Feb EST and Aug EST are different time zones in Sydney
-	// even though both are called EST.
-	t1, err := ParseInLocation("Jan 02 2006 MST", "Feb 01 2013 EST", loc)
+	t1, err := ParseInLocation("Jan 02 2006 MST", "Feb 01 2013 AST", baghdad)
 	if err != nil {
 		t.Fatal(err)
 	}
-	t2 := Date(2013, February, 1, 00, 00, 00, 0, loc)
+	t2 := Date(2013, February, 1, 00, 00, 00, 0, baghdad)
 	if t1 != t2 {
-		t.Fatalf("ParseInLocation(Feb 01 2013 EST, Sydney) = %v, want %v", t1, t2)
+		t.Fatalf("ParseInLocation(Feb 01 2013 AST, Baghdad) = %v, want %v", t1, t2)
 	}
 	_, offset := t1.Zone()
-	if offset != 11*60*60 {
-		t.Fatalf("ParseInLocation(Feb 01 2013 EST, Sydney).Zone = _, %d, want _, %d", offset, 11*60*60)
+	if offset != 3*60*60 {
+		t.Fatalf("ParseInLocation(Feb 01 2013 AST, Baghdad).Zone = _, %d, want _, %d", offset, 3*60*60)
 	}
 
-	t1, err = ParseInLocation("Jan 02 2006 MST", "Aug 01 2013 EST", loc)
+	blancSablon, err := LoadLocation("America/Blanc-Sablon")
 	if err != nil {
 		t.Fatal(err)
 	}
-	t2 = Date(2013, August, 1, 00, 00, 00, 0, loc)
+
+	t1, err = ParseInLocation("Jan 02 2006 MST", "Feb 01 2013 AST", blancSablon)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t2 = Date(2013, February, 1, 00, 00, 00, 0, blancSablon)
 	if t1 != t2 {
-		t.Fatalf("ParseInLocation(Aug 01 2013 EST, Sydney) = %v, want %v", t1, t2)
+		t.Fatalf("ParseInLocation(Feb 01 2013 AST, Blanc-Sablon) = %v, want %v", t1, t2)
 	}
 	_, offset = t1.Zone()
-	if offset != 10*60*60 {
-		t.Fatalf("ParseInLocation(Aug 01 2013 EST, Sydney).Zone = _, %d, want _, %d", offset, 10*60*60)
+	if offset != -4*60*60 {
+		t.Fatalf("ParseInLocation(Feb 01 2013 AST, Blanc-Sablon).Zone = _, %d, want _, %d", offset, -4*60*60)
 	}
 }
 

From a9cef4952f86cd00fbe16090e8aa61c6b3ef152a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Oudompheng?= <oudomphe@phare.normalesup.org>
Date: Thu, 21 Aug 2014 22:34:00 +0200
Subject: [PATCH 152/423] runtime: give an explicit name to profiling Bucket
 sub-structs.

Fixes compilation of runtime on Solaris where the inner struct
was not called "_4_".

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/129460043
---
 src/pkg/runtime/mprof.go | 2 +-
 src/pkg/runtime/mprof.h  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 057e3dee1c..7c90c21c98 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -122,7 +122,7 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 		ok = true
 		idx := 0
 		for b := bbuckets; b != nil; b = b.allnext {
-			bp := (*_4_)(unsafe.Pointer(&b.data))
+			bp := (*bprofrecord)(unsafe.Pointer(&b.data))
 			p[idx].Count = int64(bp.count)
 			p[idx].Cycles = int64(bp.cycles)
 			i := 0
diff --git a/src/pkg/runtime/mprof.h b/src/pkg/runtime/mprof.h
index 5e9f3b55a4..a8cf1513e8 100644
--- a/src/pkg/runtime/mprof.h
+++ b/src/pkg/runtime/mprof.h
@@ -13,7 +13,7 @@ struct Bucket
 	// this one is fine because it does not contain pointers.
 	union
 	{
-		struct  // typ == MProf
+		struct MProfRecord // typ == MProf
 		{
 			// The following complex 3-stage scheme of stats accumulation
 			// is required to obtain a consistent picture of mallocs and frees
@@ -43,7 +43,7 @@ struct Bucket
 			uintptr	recent_free_bytes;
 
 		} mp;
-		struct  // typ == BProf
+		struct BProfRecord // typ == BProf
 		{
 			int64	count;
 			int64	cycles;

From 32a092a885c48a8a8798380ded7bf57f0a991a26 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 21 Aug 2014 14:54:27 -0700
Subject: [PATCH 153/423] cmd/gofmt: remove testdata/*.gofmt files

This files were added accidentally and are
not required for running the tests (they
are produced by failing tests for easier
debugging).

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/131030044
---
 src/cmd/gofmt/testdata/stdin1.golden.gofmt |  3 ---
 src/cmd/gofmt/testdata/stdin1.input.gofmt  |  3 ---
 src/cmd/gofmt/testdata/stdin2.golden.gofmt | 10 ----------
 src/cmd/gofmt/testdata/stdin2.input.gofmt  | 11 -----------
 src/cmd/gofmt/testdata/stdin3.golden.gofmt |  7 -------
 src/cmd/gofmt/testdata/stdin3.input.gofmt  |  7 -------
 src/cmd/gofmt/testdata/stdin4.golden.gofmt |  3 ---
 src/cmd/gofmt/testdata/stdin4.input.gofmt  |  3 ---
 8 files changed, 47 deletions(-)
 delete mode 100644 src/cmd/gofmt/testdata/stdin1.golden.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin1.input.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin2.golden.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin2.input.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin3.golden.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin3.input.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin4.golden.gofmt
 delete mode 100644 src/cmd/gofmt/testdata/stdin4.input.gofmt

diff --git a/src/cmd/gofmt/testdata/stdin1.golden.gofmt b/src/cmd/gofmt/testdata/stdin1.golden.gofmt
deleted file mode 100644
index 1f888877d0..0000000000
--- a/src/cmd/gofmt/testdata/stdin1.golden.gofmt
+++ /dev/null
@@ -1,3 +0,0 @@
-	if x {
-	y
-}
diff --git a/src/cmd/gofmt/testdata/stdin1.input.gofmt b/src/cmd/gofmt/testdata/stdin1.input.gofmt
deleted file mode 100644
index 1f888877d0..0000000000
--- a/src/cmd/gofmt/testdata/stdin1.input.gofmt
+++ /dev/null
@@ -1,3 +0,0 @@
-	if x {
-	y
-}
diff --git a/src/cmd/gofmt/testdata/stdin2.golden.gofmt b/src/cmd/gofmt/testdata/stdin2.golden.gofmt
deleted file mode 100644
index 85e8003008..0000000000
--- a/src/cmd/gofmt/testdata/stdin2.golden.gofmt
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-
-var x int
-
-func f() {
-	y := z
-}
-
-
diff --git a/src/cmd/gofmt/testdata/stdin2.input.gofmt b/src/cmd/gofmt/testdata/stdin2.input.gofmt
deleted file mode 100644
index 7eb1b54fec..0000000000
--- a/src/cmd/gofmt/testdata/stdin2.input.gofmt
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-var x int
-
-func f() {
-	y := z
-	/* this is a comment */
-	// this is a comment too
-}
-
-
diff --git a/src/cmd/gofmt/testdata/stdin3.golden.gofmt b/src/cmd/gofmt/testdata/stdin3.golden.gofmt
deleted file mode 100644
index b4d1d4663e..0000000000
--- a/src/cmd/gofmt/testdata/stdin3.golden.gofmt
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-		/* note: no newline at end of file */
-		for i := 0; i < 10; i++ {
-			s += i
-		}
-	
\ No newline at end of file
diff --git a/src/cmd/gofmt/testdata/stdin3.input.gofmt b/src/cmd/gofmt/testdata/stdin3.input.gofmt
deleted file mode 100644
index b4d1d4663e..0000000000
--- a/src/cmd/gofmt/testdata/stdin3.input.gofmt
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-		/* note: no newline at end of file */
-		for i := 0; i < 10; i++ {
-			s += i
-		}
-	
\ No newline at end of file
diff --git a/src/cmd/gofmt/testdata/stdin4.golden.gofmt b/src/cmd/gofmt/testdata/stdin4.golden.gofmt
deleted file mode 100644
index 5f73435517..0000000000
--- a/src/cmd/gofmt/testdata/stdin4.golden.gofmt
+++ /dev/null
@@ -1,3 +0,0 @@
-	// comment
-
-	i := 0
diff --git a/src/cmd/gofmt/testdata/stdin4.input.gofmt b/src/cmd/gofmt/testdata/stdin4.input.gofmt
deleted file mode 100644
index 5f73435517..0000000000
--- a/src/cmd/gofmt/testdata/stdin4.input.gofmt
+++ /dev/null
@@ -1,3 +0,0 @@
-	// comment
-
-	i := 0

From ca2db2067fb23e794d496c11fe4cd39142f0ce28 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Thu, 21 Aug 2014 15:44:03 -0700
Subject: [PATCH 154/423] A+C: Fatih Arslan (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/130430043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 44be520446..115850bced 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -154,6 +154,7 @@ Evan Shaw <chickencha@gmail.com>
 Ewan Chou <coocood@gmail.com>
 Fabrizio Milo <mistobaan@gmail.com>
 Fan Hongjian <fan.howard@gmail.com>
+Fatih Arslan <fatih@arslan.io>
 Fazlul Shahriar <fshahriar@gmail.com>
 Felix Geisendörfer <haimuiba@gmail.com>
 Firmansyah Adiputra <frm.adiputra@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 73a404dd0f..5115ac2178 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -223,6 +223,7 @@ Evan Shaw <chickencha@gmail.com>
 Ewan Chou <coocood@gmail.com>
 Fabrizio Milo <mistobaan@gmail.com>
 Fan Hongjian <fan.howard@gmail.com>
+Fatih Arslan <fatih@arslan.io>
 Fazlul Shahriar <fshahriar@gmail.com>
 Felix Geisendörfer <haimuiba@gmail.com>
 Firmansyah Adiputra <frm.adiputra@gmail.com>

From f129370b3e5d53a384281503f658b3a5b115fbd5 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Fri, 22 Aug 2014 09:10:33 +1000
Subject: [PATCH 155/423] cmd/ld: fix undefined behaviour in pcln.c

Update #8527

Fixes, src/cmd/6l/../ld/pcln.c:93:18: runtime error: left shift of negative value -2

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/127440043
---
 src/cmd/ld/pcln.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/ld/pcln.c b/src/cmd/ld/pcln.c
index 4c2ffa78e1..17f4f992fc 100644
--- a/src/cmd/ld/pcln.c
+++ b/src/cmd/ld/pcln.c
@@ -90,7 +90,7 @@ renumberfiles(Link *ctxt, LSym **files, int nfiles, Pcdata *d)
 		}
 		dv = val - newval;
 		newval = val;
-		v = (uint32)(dv<<1) ^ (uint32)(int32)(dv>>31);
+		v = ((uint32)dv<<1) ^ (uint32)(int32)(dv>>31);
 		addvarint(&out, v);
 
 		// pc delta

From bc64c078259b97392c2a9d5ee6bda75ae3971579 Mon Sep 17 00:00:00 2001
From: Andrew Gerrand <adg@golang.org>
Date: Fri, 22 Aug 2014 09:53:44 +1000
Subject: [PATCH 156/423] sync: be more explicit in WaitGroup docs

Fixes #8543.

LGTM=dvyukov, r
R=rsc, r
CC=dvyukov, golang-codereviews
https://golang.org/cl/123580043
---
 src/pkg/sync/waitgroup.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/pkg/sync/waitgroup.go b/src/pkg/sync/waitgroup.go
index 4c64dca393..92cc57d2cc 100644
--- a/src/pkg/sync/waitgroup.go
+++ b/src/pkg/sync/waitgroup.go
@@ -37,10 +37,13 @@ type WaitGroup struct {
 // If the counter becomes zero, all goroutines blocked on Wait are released.
 // If the counter goes negative, Add panics.
 //
-// Note that calls with positive delta must happen before the call to Wait,
-// or else Wait may wait for too small a group. Typically this means the calls
-// to Add should execute before the statement creating the goroutine or
-// other event to be waited for. See the WaitGroup example.
+// Note that calls with a positive delta that occur when the counter is zero
+// must happen before a Wait. Calls with a negative delta, or calls with a
+// positive delta that start when the counter is greater than zero, may happen
+// at any time.
+// Typically this means the calls to Add should execute before the statement
+// creating the goroutine or other event to be waited for.
+// See the WaitGroup example.
 func (wg *WaitGroup) Add(delta int) {
 	if raceenabled {
 		_ = wg.m.state // trigger nil deref early

From 67812a7cd90c22d9b121f747ad27c4f527767ad5 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 21 Aug 2014 17:25:13 -0700
Subject: [PATCH 157/423] cmd/gofmt: make test files self-describing

1) Interpret a comment of the form

//gofmt <flags>

in test files to drive the respective
gofmt command. Eliminates the need to
enumerate all test files in the test
harness.

2) Added -update flag to make it easier
to update test cases.

LGTM=josharian
R=golang-codereviews, josharian
CC=golang-codereviews
https://golang.org/cl/130440043
---
 src/cmd/gofmt/gofmt_test.go              | 123 +++++++++++++++--------
 src/cmd/gofmt/testdata/composites.golden |   2 +
 src/cmd/gofmt/testdata/composites.input  |   2 +
 src/cmd/gofmt/testdata/crlf.golden       |   1 +
 src/cmd/gofmt/testdata/crlf.input        |   1 +
 src/cmd/gofmt/testdata/emptydecl.golden  |   4 +
 src/cmd/gofmt/testdata/emptydecl.input   |   4 +
 src/cmd/gofmt/testdata/ranges.golden     |   2 +
 src/cmd/gofmt/testdata/ranges.input      |   2 +
 src/cmd/gofmt/testdata/rewrite1.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite1.input    |   2 +
 src/cmd/gofmt/testdata/rewrite2.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite2.input    |   2 +
 src/cmd/gofmt/testdata/rewrite3.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite3.input    |   2 +
 src/cmd/gofmt/testdata/rewrite4.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite4.input    |   2 +
 src/cmd/gofmt/testdata/rewrite5.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite5.input    |   2 +
 src/cmd/gofmt/testdata/rewrite6.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite6.input    |   2 +
 src/cmd/gofmt/testdata/rewrite7.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite7.input    |   2 +
 src/cmd/gofmt/testdata/rewrite8.golden   |   2 +
 src/cmd/gofmt/testdata/rewrite8.input    |   2 +
 src/cmd/gofmt/testdata/slices1.golden    |   2 +
 src/cmd/gofmt/testdata/slices1.input     |   2 +
 src/cmd/gofmt/testdata/slices2.golden    |   2 +
 src/cmd/gofmt/testdata/slices2.input     |   2 +
 src/cmd/gofmt/testdata/stdin1.golden     |   2 +
 src/cmd/gofmt/testdata/stdin1.input      |   2 +
 src/cmd/gofmt/testdata/stdin2.golden     |   2 +-
 src/cmd/gofmt/testdata/stdin2.input      |   2 +-
 src/cmd/gofmt/testdata/stdin3.golden     |   1 +
 src/cmd/gofmt/testdata/stdin3.input      |   1 +
 src/cmd/gofmt/testdata/stdin4.golden     |   2 +
 src/cmd/gofmt/testdata/stdin4.input      |   2 +
 37 files changed, 150 insertions(+), 45 deletions(-)

diff --git a/src/cmd/gofmt/gofmt_test.go b/src/cmd/gofmt/gofmt_test.go
index ca44f3dcf7..d1edb7bcc1 100644
--- a/src/cmd/gofmt/gofmt_test.go
+++ b/src/cmd/gofmt/gofmt_test.go
@@ -6,18 +6,60 @@ package main
 
 import (
 	"bytes"
+	"flag"
 	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strings"
 	"testing"
+	"text/scanner"
 )
 
-func runTest(t *testing.T, in, out, flags string) {
+var update = flag.Bool("update", false, "update .golden files")
+
+// gofmtFlags looks for a comment of the form
+//
+//	//gofmt flags
+//
+// within the first maxLines lines of the given file,
+// and returns the flags string, if any. Otherwise it
+// returns the empty string.
+func gofmtFlags(filename string, maxLines int) string {
+	f, err := os.Open(filename)
+	if err != nil {
+		return "" // ignore errors - they will be found later
+	}
+	defer f.Close()
+
+	// initialize scanner
+	var s scanner.Scanner
+	s.Init(f)
+	s.Error = func(*scanner.Scanner, string) {}       // ignore errors
+	s.Mode = scanner.GoTokens &^ scanner.SkipComments // want comments
+
+	// look for //gofmt comment
+	for s.Line <= maxLines {
+		switch s.Scan() {
+		case scanner.Comment:
+			const prefix = "//gofmt "
+			if t := s.TokenText(); strings.HasPrefix(t, prefix) {
+				return strings.TrimSpace(t[len(prefix):])
+			}
+		case scanner.EOF:
+			return ""
+		}
+
+	}
+
+	return ""
+}
+
+func runTest(t *testing.T, in, out string) {
 	// process flags
 	*simplifyAST = false
 	*rewriteRule = ""
 	stdin := false
-	for _, flag := range strings.Split(flags, " ") {
+	for _, flag := range strings.Split(gofmtFlags(in, 20), " ") {
 		elts := strings.SplitN(flag, "=", 2)
 		name := elts[0]
 		value := ""
@@ -56,6 +98,17 @@ func runTest(t *testing.T, in, out, flags string) {
 	}
 
 	if got := buf.Bytes(); !bytes.Equal(got, expected) {
+		if *update {
+			if in != out {
+				if err := ioutil.WriteFile(out, got, 0666); err != nil {
+					t.Error(err)
+				}
+				return
+			}
+			// in == out: don't accidentally destroy input
+			t.Errorf("WARNING: -update did not rewrite input file %s", in)
+		}
+
 		t.Errorf("(gofmt %s) != %s (see %s.gofmt)", in, out, in)
 		d, err := diff(expected, got)
 		if err == nil {
@@ -67,53 +120,37 @@ func runTest(t *testing.T, in, out, flags string) {
 	}
 }
 
-var tests = []struct {
-	in, flags string
-}{
-	{"gofmt.go", ""},
-	{"gofmt_test.go", ""},
-	{"testdata/composites.input", "-s"},
-	{"testdata/slices1.input", "-s"},
-	{"testdata/slices2.input", "-s"},
-	{"testdata/ranges.input", "-s"},
-	{"testdata/old.input", ""},
-	{"testdata/rewrite1.input", "-r=Foo->Bar"},
-	{"testdata/rewrite2.input", "-r=int->bool"},
-	{"testdata/rewrite3.input", "-r=x->x"},
-	{"testdata/rewrite4.input", "-r=(x)->x"},
-	{"testdata/rewrite5.input", "-r=x+x->2*x"},
-	{"testdata/rewrite6.input", "-r=fun(x)->Fun(x)"},
-	{"testdata/rewrite7.input", "-r=fun(x...)->Fun(x)"},
-	{"testdata/rewrite8.input", "-r=interface{}->int"},
-	{"testdata/stdin*.input", "-stdin"},
-	{"testdata/comments.input", ""},
-	{"testdata/import.input", ""},
-	{"testdata/crlf.input", ""},        // test case for issue 3961; see also TestCRLF
-	{"testdata/typeswitch.input", ""},  // test case for issue 4470
-	{"testdata/emptydecl.input", "-s"}, // test case for issue 7631
-}
-
+// TestRewrite processes testdata/*.input files and compares them to the
+// corresponding testdata/*.golden files. The gofmt flags used to process
+// a file must be provided via a comment of the form
+//
+//	//gofmt flags
+//
+// in the processed file within the first 20 lines, if any.
 func TestRewrite(t *testing.T) {
-	for _, test := range tests {
-		match, err := filepath.Glob(test.in)
-		if err != nil {
-			t.Error(err)
-			continue
+	// determine input files
+	match, err := filepath.Glob("testdata/*.input")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// add larger examples
+	match = append(match, "gofmt.go", "gofmt_test.go")
+
+	for _, in := range match {
+		out := in // for files where input and output are identical
+		if strings.HasSuffix(in, ".input") {
+			out = in[:len(in)-len(".input")] + ".golden"
 		}
-		for _, in := range match {
-			out := in
-			if strings.HasSuffix(in, ".input") {
-				out = in[:len(in)-len(".input")] + ".golden"
-			}
-			runTest(t, in, out, test.flags)
-			if in != out {
-				// Check idempotence.
-				runTest(t, out, out, test.flags)
-			}
+		runTest(t, in, out)
+		if in != out {
+			// Check idempotence.
+			runTest(t, out, out)
 		}
 	}
 }
 
+// Test case for issue 3961.
 func TestCRLF(t *testing.T) {
 	const input = "testdata/crlf.input"   // must contain CR/LF's
 	const golden = "testdata/crlf.golden" // must not contain any CR's
diff --git a/src/cmd/gofmt/testdata/composites.golden b/src/cmd/gofmt/testdata/composites.golden
index b2825e732a..fc9c98e625 100644
--- a/src/cmd/gofmt/testdata/composites.golden
+++ b/src/cmd/gofmt/testdata/composites.golden
@@ -1,3 +1,5 @@
+//gofmt -s
+
 package P
 
 type T struct {
diff --git a/src/cmd/gofmt/testdata/composites.input b/src/cmd/gofmt/testdata/composites.input
index 7210dafc96..fc7598af99 100644
--- a/src/cmd/gofmt/testdata/composites.input
+++ b/src/cmd/gofmt/testdata/composites.input
@@ -1,3 +1,5 @@
+//gofmt -s
+
 package P
 
 type T struct {
diff --git a/src/cmd/gofmt/testdata/crlf.golden b/src/cmd/gofmt/testdata/crlf.golden
index 57679f770f..193dbacc72 100644
--- a/src/cmd/gofmt/testdata/crlf.golden
+++ b/src/cmd/gofmt/testdata/crlf.golden
@@ -2,6 +2,7 @@
 	Source containing CR/LF line endings.
 	The gofmt'ed output must only have LF
 	line endings.
+	Test case for issue 3961.
 */
 package main
 
diff --git a/src/cmd/gofmt/testdata/crlf.input b/src/cmd/gofmt/testdata/crlf.input
index 61a1aa0b4e..ae7e14dbf1 100644
--- a/src/cmd/gofmt/testdata/crlf.input
+++ b/src/cmd/gofmt/testdata/crlf.input
@@ -2,6 +2,7 @@
 	Source containing CR/LF line endings.
 	The gofmt'ed output must only have LF
 	line endings.
+	Test case for issue 3961.
 */
 package main
 
diff --git a/src/cmd/gofmt/testdata/emptydecl.golden b/src/cmd/gofmt/testdata/emptydecl.golden
index 9fe62c9738..33d6435e0a 100644
--- a/src/cmd/gofmt/testdata/emptydecl.golden
+++ b/src/cmd/gofmt/testdata/emptydecl.golden
@@ -1,3 +1,7 @@
+//gofmt -s
+
+// Test case for issue 7631.
+
 package main
 
 // Keep this declaration
diff --git a/src/cmd/gofmt/testdata/emptydecl.input b/src/cmd/gofmt/testdata/emptydecl.input
index d1cab00ef7..4948a61f0d 100644
--- a/src/cmd/gofmt/testdata/emptydecl.input
+++ b/src/cmd/gofmt/testdata/emptydecl.input
@@ -1,3 +1,7 @@
+//gofmt -s
+
+// Test case for issue 7631.
+
 package main
 
 // Keep this declaration
diff --git a/src/cmd/gofmt/testdata/ranges.golden b/src/cmd/gofmt/testdata/ranges.golden
index 42168526d1..506b3a035a 100644
--- a/src/cmd/gofmt/testdata/ranges.golden
+++ b/src/cmd/gofmt/testdata/ranges.golden
@@ -1,3 +1,5 @@
+//gofmt -s
+
 // Test cases for range simplification.
 package p
 
diff --git a/src/cmd/gofmt/testdata/ranges.input b/src/cmd/gofmt/testdata/ranges.input
index 4b02d51752..df5f8333c2 100644
--- a/src/cmd/gofmt/testdata/ranges.input
+++ b/src/cmd/gofmt/testdata/ranges.input
@@ -1,3 +1,5 @@
+//gofmt -s
+
 // Test cases for range simplification.
 package p
 
diff --git a/src/cmd/gofmt/testdata/rewrite1.golden b/src/cmd/gofmt/testdata/rewrite1.golden
index d9beb37058..3ee5373a79 100644
--- a/src/cmd/gofmt/testdata/rewrite1.golden
+++ b/src/cmd/gofmt/testdata/rewrite1.golden
@@ -1,3 +1,5 @@
+//gofmt -r=Foo->Bar
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite1.input b/src/cmd/gofmt/testdata/rewrite1.input
index bdb894320d..a84c8f7816 100644
--- a/src/cmd/gofmt/testdata/rewrite1.input
+++ b/src/cmd/gofmt/testdata/rewrite1.input
@@ -1,3 +1,5 @@
+//gofmt -r=Foo->Bar
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite2.golden b/src/cmd/gofmt/testdata/rewrite2.golden
index 64c67ffa67..f980e03530 100644
--- a/src/cmd/gofmt/testdata/rewrite2.golden
+++ b/src/cmd/gofmt/testdata/rewrite2.golden
@@ -1,3 +1,5 @@
+//gofmt -r=int->bool
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite2.input b/src/cmd/gofmt/testdata/rewrite2.input
index 21171447a1..489be4e07d 100644
--- a/src/cmd/gofmt/testdata/rewrite2.input
+++ b/src/cmd/gofmt/testdata/rewrite2.input
@@ -1,3 +1,5 @@
+//gofmt -r=int->bool
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite3.golden b/src/cmd/gofmt/testdata/rewrite3.golden
index 0d16d16011..261a220c65 100644
--- a/src/cmd/gofmt/testdata/rewrite3.golden
+++ b/src/cmd/gofmt/testdata/rewrite3.golden
@@ -1,3 +1,5 @@
+//gofmt -r=x->x
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite3.input b/src/cmd/gofmt/testdata/rewrite3.input
index 0d16d16011..261a220c65 100644
--- a/src/cmd/gofmt/testdata/rewrite3.input
+++ b/src/cmd/gofmt/testdata/rewrite3.input
@@ -1,3 +1,5 @@
+//gofmt -r=x->x
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite4.golden b/src/cmd/gofmt/testdata/rewrite4.golden
index 8dfc81a074..b05547b4bf 100644
--- a/src/cmd/gofmt/testdata/rewrite4.golden
+++ b/src/cmd/gofmt/testdata/rewrite4.golden
@@ -1,3 +1,5 @@
+//gofmt -r=(x)->x
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
diff --git a/src/cmd/gofmt/testdata/rewrite4.input b/src/cmd/gofmt/testdata/rewrite4.input
index 164cc0451f..0817099209 100644
--- a/src/cmd/gofmt/testdata/rewrite4.input
+++ b/src/cmd/gofmt/testdata/rewrite4.input
@@ -1,3 +1,5 @@
+//gofmt -r=(x)->x
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
diff --git a/src/cmd/gofmt/testdata/rewrite5.golden b/src/cmd/gofmt/testdata/rewrite5.golden
index 5a448a63d3..9beb34aee7 100644
--- a/src/cmd/gofmt/testdata/rewrite5.golden
+++ b/src/cmd/gofmt/testdata/rewrite5.golden
@@ -1,3 +1,5 @@
+//gofmt -r=x+x->2*x
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite5.input b/src/cmd/gofmt/testdata/rewrite5.input
index 0d759e69b6..d7a6122d07 100644
--- a/src/cmd/gofmt/testdata/rewrite5.input
+++ b/src/cmd/gofmt/testdata/rewrite5.input
@@ -1,3 +1,5 @@
+//gofmt -r=x+x->2*x
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite6.golden b/src/cmd/gofmt/testdata/rewrite6.golden
index e565dbdd97..48ec9aa0df 100644
--- a/src/cmd/gofmt/testdata/rewrite6.golden
+++ b/src/cmd/gofmt/testdata/rewrite6.golden
@@ -1,3 +1,5 @@
+//gofmt -r=fun(x)->Fun(x)
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite6.input b/src/cmd/gofmt/testdata/rewrite6.input
index 8c088b3e87..b085a84fef 100644
--- a/src/cmd/gofmt/testdata/rewrite6.input
+++ b/src/cmd/gofmt/testdata/rewrite6.input
@@ -1,3 +1,5 @@
+//gofmt -r=fun(x)->Fun(x)
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite7.golden b/src/cmd/gofmt/testdata/rewrite7.golden
index 29babad9f9..8386a0b2a3 100644
--- a/src/cmd/gofmt/testdata/rewrite7.golden
+++ b/src/cmd/gofmt/testdata/rewrite7.golden
@@ -1,3 +1,5 @@
+//gofmt -r=fun(x...)->Fun(x)
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite7.input b/src/cmd/gofmt/testdata/rewrite7.input
index 073e2a3e6f..c1984708e7 100644
--- a/src/cmd/gofmt/testdata/rewrite7.input
+++ b/src/cmd/gofmt/testdata/rewrite7.input
@@ -1,3 +1,5 @@
+//gofmt -r=fun(x...)->Fun(x)
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite8.golden b/src/cmd/gofmt/testdata/rewrite8.golden
index cfc452b031..62f0419dfb 100644
--- a/src/cmd/gofmt/testdata/rewrite8.golden
+++ b/src/cmd/gofmt/testdata/rewrite8.golden
@@ -1,3 +1,5 @@
+//gofmt -r=interface{}->int
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/rewrite8.input b/src/cmd/gofmt/testdata/rewrite8.input
index 235efa91cc..7964c5c75c 100644
--- a/src/cmd/gofmt/testdata/rewrite8.input
+++ b/src/cmd/gofmt/testdata/rewrite8.input
@@ -1,3 +1,5 @@
+//gofmt -r=interface{}->int
+
 // 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.
diff --git a/src/cmd/gofmt/testdata/slices1.golden b/src/cmd/gofmt/testdata/slices1.golden
index 6633a5e001..04bc16f216 100644
--- a/src/cmd/gofmt/testdata/slices1.golden
+++ b/src/cmd/gofmt/testdata/slices1.golden
@@ -1,3 +1,5 @@
+//gofmt -s
+
 // Test cases for slice expression simplification.
 package p
 
diff --git a/src/cmd/gofmt/testdata/slices1.input b/src/cmd/gofmt/testdata/slices1.input
index 27e9cb8fef..1f25c43ccb 100644
--- a/src/cmd/gofmt/testdata/slices1.input
+++ b/src/cmd/gofmt/testdata/slices1.input
@@ -1,3 +1,5 @@
+//gofmt -s
+
 // Test cases for slice expression simplification.
 package p
 
diff --git a/src/cmd/gofmt/testdata/slices2.golden b/src/cmd/gofmt/testdata/slices2.golden
index 433788e1ee..ab657004e6 100644
--- a/src/cmd/gofmt/testdata/slices2.golden
+++ b/src/cmd/gofmt/testdata/slices2.golden
@@ -1,3 +1,5 @@
+//gofmt -s
+
 // Test cases for slice expression simplification.
 // Because of a dot import, these slices must remain untouched.
 package p
diff --git a/src/cmd/gofmt/testdata/slices2.input b/src/cmd/gofmt/testdata/slices2.input
index 433788e1ee..ab657004e6 100644
--- a/src/cmd/gofmt/testdata/slices2.input
+++ b/src/cmd/gofmt/testdata/slices2.input
@@ -1,3 +1,5 @@
+//gofmt -s
+
 // Test cases for slice expression simplification.
 // Because of a dot import, these slices must remain untouched.
 package p
diff --git a/src/cmd/gofmt/testdata/stdin1.golden b/src/cmd/gofmt/testdata/stdin1.golden
index ff8b0b7ab4..9e4dcd20fe 100644
--- a/src/cmd/gofmt/testdata/stdin1.golden
+++ b/src/cmd/gofmt/testdata/stdin1.golden
@@ -1,3 +1,5 @@
+	//gofmt -stdin
+
 	if x {
 		y
 	}
diff --git a/src/cmd/gofmt/testdata/stdin1.input b/src/cmd/gofmt/testdata/stdin1.input
index ff8b0b7ab4..9e4dcd20fe 100644
--- a/src/cmd/gofmt/testdata/stdin1.input
+++ b/src/cmd/gofmt/testdata/stdin1.input
@@ -1,3 +1,5 @@
+	//gofmt -stdin
+
 	if x {
 		y
 	}
diff --git a/src/cmd/gofmt/testdata/stdin2.golden b/src/cmd/gofmt/testdata/stdin2.golden
index 7eb1b54fec..57df355403 100644
--- a/src/cmd/gofmt/testdata/stdin2.golden
+++ b/src/cmd/gofmt/testdata/stdin2.golden
@@ -1,4 +1,4 @@
-
+//gofmt -stdin
 
 var x int
 
diff --git a/src/cmd/gofmt/testdata/stdin2.input b/src/cmd/gofmt/testdata/stdin2.input
index 99defd2d10..69d6bdd682 100644
--- a/src/cmd/gofmt/testdata/stdin2.input
+++ b/src/cmd/gofmt/testdata/stdin2.input
@@ -1,4 +1,4 @@
-
+//gofmt -stdin
 
 var x int
 
diff --git a/src/cmd/gofmt/testdata/stdin3.golden b/src/cmd/gofmt/testdata/stdin3.golden
index 1bf2f5a483..d6da0e417a 100644
--- a/src/cmd/gofmt/testdata/stdin3.golden
+++ b/src/cmd/gofmt/testdata/stdin3.golden
@@ -1,3 +1,4 @@
+		//gofmt -stdin
 
 		/* note: no newline at end of file */
 		for i := 0; i < 10; i++ {
diff --git a/src/cmd/gofmt/testdata/stdin3.input b/src/cmd/gofmt/testdata/stdin3.input
index d963bd0d21..ab46c1063b 100644
--- a/src/cmd/gofmt/testdata/stdin3.input
+++ b/src/cmd/gofmt/testdata/stdin3.input
@@ -1,3 +1,4 @@
+		//gofmt -stdin
 
 		/* note: no newline at end of file */
 		for i := 0; i < 10; i++ { s += i }
diff --git a/src/cmd/gofmt/testdata/stdin4.golden b/src/cmd/gofmt/testdata/stdin4.golden
index 5f73435517..0c7acace5d 100644
--- a/src/cmd/gofmt/testdata/stdin4.golden
+++ b/src/cmd/gofmt/testdata/stdin4.golden
@@ -1,3 +1,5 @@
+	//gofmt -stdin
+
 	// comment
 
 	i := 0
diff --git a/src/cmd/gofmt/testdata/stdin4.input b/src/cmd/gofmt/testdata/stdin4.input
index f02a54fb1a..1fc73f31e5 100644
--- a/src/cmd/gofmt/testdata/stdin4.input
+++ b/src/cmd/gofmt/testdata/stdin4.input
@@ -1,3 +1,5 @@
+	//gofmt -stdin
+
 	// comment
 	
 	i := 0

From e6f0b746677fbca7b5dbeeb1777cc13b81a31918 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Fri, 22 Aug 2014 17:14:42 +1000
Subject: [PATCH 158/423] path/filepath: make Abs handle paths like c:a.txt
 properly

Fixes #8145.

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/126440043
---
 src/pkg/path/filepath/path.go         |  4 ++++
 src/pkg/path/filepath/path_plan9.go   |  4 ++++
 src/pkg/path/filepath/path_test.go    | 15 +++++++++++++++
 src/pkg/path/filepath/path_unix.go    |  4 ++++
 src/pkg/path/filepath/path_windows.go |  5 +++++
 5 files changed, 32 insertions(+)

diff --git a/src/pkg/path/filepath/path.go b/src/pkg/path/filepath/path.go
index 71603cc594..7fa3b9b56a 100644
--- a/src/pkg/path/filepath/path.go
+++ b/src/pkg/path/filepath/path.go
@@ -231,6 +231,10 @@ func EvalSymlinks(path string) (string, error) {
 // working directory to turn it into an absolute path.  The absolute
 // path name for a given file is not guaranteed to be unique.
 func Abs(path string) (string, error) {
+	return abs(path)
+}
+
+func unixAbs(path string) (string, error) {
 	if IsAbs(path) {
 		return Clean(path), nil
 	}
diff --git a/src/pkg/path/filepath/path_plan9.go b/src/pkg/path/filepath/path_plan9.go
index 12e85aae00..ee8912d58e 100644
--- a/src/pkg/path/filepath/path_plan9.go
+++ b/src/pkg/path/filepath/path_plan9.go
@@ -28,3 +28,7 @@ func splitList(path string) []string {
 	}
 	return strings.Split(path, string(ListSeparator))
 }
+
+func abs(path string) (string, error) {
+	return unixAbs(path)
+}
diff --git a/src/pkg/path/filepath/path_test.go b/src/pkg/path/filepath/path_test.go
index 8cdc763f1b..399284b97d 100644
--- a/src/pkg/path/filepath/path_test.go
+++ b/src/pkg/path/filepath/path_test.go
@@ -628,6 +628,8 @@ var winisabstests = []IsAbsTest{
 	{`\`, false},
 	{`\Windows`, false},
 	{`c:a\b`, false},
+	{`c:\a\b`, true},
+	{`c:/a/b`, true},
 	{`\\host\share\foo`, true},
 	{`//host/share/foo/bar`, true},
 }
@@ -807,6 +809,19 @@ func TestAbs(t *testing.T) {
 		}
 	}
 
+	if runtime.GOOS == "windows" {
+		vol := filepath.VolumeName(root)
+		var extra []string
+		for _, path := range absTests {
+			if strings.Index(path, "$") != -1 {
+				continue
+			}
+			path = vol + path
+			extra = append(extra, path)
+		}
+		absTests = append(absTests, extra...)
+	}
+
 	err = os.Chdir(absTestDirs[0])
 	if err != nil {
 		t.Fatal("chdir failed: ", err)
diff --git a/src/pkg/path/filepath/path_unix.go b/src/pkg/path/filepath/path_unix.go
index 7aba0ab5b9..4e7d0d1b42 100644
--- a/src/pkg/path/filepath/path_unix.go
+++ b/src/pkg/path/filepath/path_unix.go
@@ -30,3 +30,7 @@ func splitList(path string) []string {
 	}
 	return strings.Split(path, string(ListSeparator))
 }
+
+func abs(path string) (string, error) {
+	return unixAbs(path)
+}
diff --git a/src/pkg/path/filepath/path_windows.go b/src/pkg/path/filepath/path_windows.go
index e99997257d..ec50f6b264 100644
--- a/src/pkg/path/filepath/path_windows.go
+++ b/src/pkg/path/filepath/path_windows.go
@@ -6,6 +6,7 @@ package filepath
 
 import (
 	"strings"
+	"syscall"
 )
 
 func isSlash(c uint8) bool {
@@ -103,3 +104,7 @@ func splitList(path string) []string {
 
 	return list
 }
+
+func abs(path string) (string, error) {
+	return syscall.FullPath(path)
+}

From 0065cbe5d015aa155c2a3e91d8c17f6474fef5e8 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 22 Aug 2014 11:46:10 +0400
Subject: [PATCH 159/423] syscall: fix nacl build Timer callback does not
 accept now as first arg anymore.

LGTM=dave
R=golang-codereviews, dave
CC=golang-codereviews
https://golang.org/cl/126530043
---
 src/pkg/syscall/net_nacl.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/syscall/net_nacl.go b/src/pkg/syscall/net_nacl.go
index b9488f48d1..f85b2e1f72 100644
--- a/src/pkg/syscall/net_nacl.go
+++ b/src/pkg/syscall/net_nacl.go
@@ -21,7 +21,7 @@ type runtimeTimer struct {
 	i      int32
 	when   int64
 	period int64
-	f      func(int64, interface{}) // NOTE: must not be closure
+	f      func(interface{}) // NOTE: must not be closure
 	arg    interface{}
 }
 
@@ -49,7 +49,7 @@ func (t *timer) stop() {
 	stopTimer(&t.r)
 }
 
-func timerExpired(now int64, i interface{}) {
+func timerExpired(i interface{}) {
 	t := i.(*timer)
 	go func() {
 		t.q.Lock()

From 84b70df44c0092d1ce395cf22049d1e3af194c12 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Fri, 22 Aug 2014 18:36:01 +1000
Subject: [PATCH 160/423] misc/nacl: fix build

Add gofmt.go and gofmt_test.go as they are part of the test data set.

See CL 130440043.

LGTM=dvyukov
R=golang-codereviews, dvyukov
CC=golang-codereviews
https://golang.org/cl/132820044
---
 misc/nacl/testzip.proto | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/misc/nacl/testzip.proto b/misc/nacl/testzip.proto
index 29581dcfb3..89e1e1193a 100644
--- a/misc/nacl/testzip.proto
+++ b/misc/nacl/testzip.proto
@@ -14,6 +14,8 @@ go	src=..
 				objfile
 					objfile.go
 			gofmt
+				gofmt.go
+				gofmt_test.go
 				testdata
 					+
 			link

From 3d3d5390834629a73b745900eb1a0aeda94d927d Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Fri, 22 Aug 2014 22:21:41 +1000
Subject: [PATCH 161/423] path, path/filepath: remove dead code

Fixes #8503.

Thanks to no.smile.face for the original report.

LGTM=bradfitz, r, ruiu
R=bradfitz, ruiu, r
CC=golang-codereviews
https://golang.org/cl/132730043
---
 src/pkg/path/filepath/path.go |  7 -------
 src/pkg/path/path.go          | 10 +---------
 2 files changed, 1 insertion(+), 16 deletions(-)

diff --git a/src/pkg/path/filepath/path.go b/src/pkg/path/filepath/path.go
index 7fa3b9b56a..d37fc9dfc8 100644
--- a/src/pkg/path/filepath/path.go
+++ b/src/pkg/path/filepath/path.go
@@ -452,13 +452,6 @@ func Dir(path string) string {
 		i--
 	}
 	dir := Clean(path[len(vol) : i+1])
-	last := len(dir) - 1
-	if last > 0 && os.IsPathSeparator(dir[last]) {
-		dir = dir[:last]
-	}
-	if dir == "" {
-		dir = "."
-	}
 	return vol + dir
 }
 
diff --git a/src/pkg/path/path.go b/src/pkg/path/path.go
index bdb85c6b92..98a6d52922 100644
--- a/src/pkg/path/path.go
+++ b/src/pkg/path/path.go
@@ -206,13 +206,5 @@ func IsAbs(path string) bool {
 // slash.
 func Dir(path string) string {
 	dir, _ := Split(path)
-	dir = Clean(dir)
-	last := len(dir) - 1
-	if last > 0 && dir[last] == '/' {
-		dir = dir[:last]
-	}
-	if dir == "" {
-		dir = "."
-	}
-	return dir
+	return Clean(dir)
 }

From 0be59730fd9339f9c79601ce19a5323828e634c3 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 22 Aug 2014 08:41:32 -0700
Subject: [PATCH 162/423] runtime: add Go symtab implementation

LGTM=khr
R=khr, dvyukov, dave
CC=golang-codereviews, rsc
https://golang.org/cl/124300044
---
 src/pkg/runtime/extern.go                |  31 -----
 src/pkg/runtime/runtime.h                |   2 +-
 src/pkg/runtime/{symtab.goc => symtab.c} |  53 ++++----
 src/pkg/runtime/symtab.go                | 153 +++++++++++++++++++++++
 4 files changed, 176 insertions(+), 63 deletions(-)
 rename src/pkg/runtime/{symtab.goc => symtab.c} (87%)
 create mode 100644 src/pkg/runtime/symtab.go

diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index 533cb431b9..a5bea7e46d 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -97,37 +97,6 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool)
 // It returns the number of entries written to pc.
 func Callers(skip int, pc []uintptr) int
 
-type Func struct {
-	opaque struct{} // unexported field to disallow conversions
-}
-
-// FuncForPC returns a *Func describing the function that contains the
-// given program counter address, or else nil.
-func FuncForPC(pc uintptr) *Func
-
-// Name returns the name of the function.
-func (f *Func) Name() string {
-	return funcname_go(f)
-}
-
-// Entry returns the entry address of the function.
-func (f *Func) Entry() uintptr {
-	return funcentry_go(f)
-}
-
-// FileLine returns the file name and line number of the
-// source code corresponding to the program counter pc.
-// The result will not be accurate if pc is not a program
-// counter within f.
-func (f *Func) FileLine(pc uintptr) (file string, line int) {
-	return funcline_go(f, pc)
-}
-
-// implemented in symtab.c
-func funcline_go(*Func, uintptr) (string, int)
-func funcname_go(*Func) string
-func funcentry_go(*Func) uintptr
-
 func getgoroot() string
 
 // GOROOT returns the root of the Go tree.
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 2c004b4eab..d38eb454b7 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -447,7 +447,7 @@ enum
 // Layout of in-memory per-function information prepared by linker
 // See http://golang.org/s/go12symtab.
 // Keep in sync with linker and with ../../libmach/sym.c
-// and with package debug/gosym.
+// and with package debug/gosym and with symtab.go in package runtime.
 struct	Func
 {
 	uintptr	entry;	// start pc
diff --git a/src/pkg/runtime/symtab.goc b/src/pkg/runtime/symtab.c
similarity index 87%
rename from src/pkg/runtime/symtab.goc
rename to src/pkg/runtime/symtab.c
index 961b78d5fc..fd0d3c1928 100644
--- a/src/pkg/runtime/symtab.goc
+++ b/src/pkg/runtime/symtab.c
@@ -5,7 +5,6 @@
 // Runtime symbol table parsing.
 // See http://golang.org/s/go12symtab for an overview.
 
-package runtime
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
@@ -23,9 +22,14 @@ struct Ftab
 extern byte pclntab[];
 
 static Ftab *ftab;
-static uintptr nftab;
+extern uintptr runtime·nftab;
 static uint32 *filetab;
-static uint32 nfiletab;
+extern uint32 runtime·nfiletab;
+
+extern uintptr runtime·pclntab;
+extern uintptr runtime·ftab0;
+extern uintptr runtime·filetab0;
+extern uint32 runtime·pcquantum;
 
 static String end = { (uint8*)"end", 3 };
 
@@ -43,22 +47,27 @@ runtime·symtabinit(void)
 		runtime·throw("invalid function symbol table\n");
 	}
 
-	nftab = *(uintptr*)(pclntab+8);
+	runtime·nftab = *(uintptr*)(pclntab+8);
 	ftab = (Ftab*)(pclntab+8+sizeof(void*));
-	for(i=0; i<nftab; i++) {
-		// NOTE: ftab[nftab].entry is legal; it is the address beyond the final function.
+	for(i=0; i<runtime·nftab; i++) {
+		// NOTE: ftab[runtime·nftab].entry is legal; it is the address beyond the final function.
 		if(ftab[i].entry > ftab[i+1].entry) {
 			f1 = (Func*)(pclntab + ftab[i].funcoff);
 			f2 = (Func*)(pclntab + ftab[i+1].funcoff);
-			runtime·printf("function symbol table not sorted by program counter: %p %s > %p %s", ftab[i].entry, runtime·funcname(f1), ftab[i+1].entry, i+1 == nftab ? "end" : runtime·funcname(f2));
+			runtime·printf("function symbol table not sorted by program counter: %p %s > %p %s", ftab[i].entry, runtime·funcname(f1), ftab[i+1].entry, i+1 == runtime·nftab ? "end" : runtime·funcname(f2));
 			for(j=0; j<=i; j++)
 				runtime·printf("\t%p %s\n", ftab[j].entry, runtime·funcname((Func*)(pclntab + ftab[j].funcoff)));
 			runtime·throw("invalid runtime symbol table");
 		}
 	}
 	
-	filetab = (uint32*)(pclntab + *(uint32*)&ftab[nftab].funcoff);
-	nfiletab = filetab[0];
+	filetab = (uint32*)(pclntab + *(uint32*)&ftab[runtime·nftab].funcoff);
+	runtime·nfiletab = filetab[0];
+
+	runtime·pcquantum = PCQuantum;
+	runtime·pclntab = (uintptr)pclntab;
+	runtime·ftab0 = (uintptr)ftab;
+	runtime·filetab0 = (uintptr)filetab;
 }
 
 static uint32
@@ -187,7 +196,7 @@ funcline(Func *f, uintptr targetpc, String *file, bool strict)
 	*file = unknown;
 	fileno = pcvalue(f, f->pcfile, targetpc, strict);
 	line = pcvalue(f, f->pcln, targetpc, strict);
-	if(fileno == -1 || line == -1 || fileno >= nfiletab) {
+	if(fileno == -1 || line == -1 || fileno >= runtime·nfiletab) {
 		// runtime·printf("looking for %p in %S got file=%d line=%d\n", targetpc, *f->name, fileno, line);
 		return 0;
 	}
@@ -228,34 +237,20 @@ runtime·funcarglen(Func *f, uintptr targetpc)
 	return runtime·pcdatavalue(f, PCDATA_ArgSize, targetpc-PCQuantum);
 }
 
-func funcline_go(f *Func, targetpc uintptr) (retfile String, retline int) {
-	// Pass strict=false here, because anyone can call this function,
-	// and they might just be wrong about targetpc belonging to f.
-	retline = funcline(f, targetpc, &retfile, false);
-}
-
-func funcname_go(f *Func) (ret String) {
-	ret = runtime·gostringnocopy((uint8*)runtime·funcname(f));
-}
-
-func funcentry_go(f *Func) (ret uintptr) {
-	ret = f->entry;
-}
-
 Func*
 runtime·findfunc(uintptr addr)
 {
 	Ftab *f;
 	int32 nf, n;
 
-	if(nftab == 0)
+	if(runtime·nftab == 0)
 		return nil;
-	if(addr < ftab[0].entry || addr >= ftab[nftab].entry)
+	if(addr < ftab[0].entry || addr >= ftab[runtime·nftab].entry)
 		return nil;
 
 	// binary search to find func with entry <= addr.
 	f = ftab;
-	nf = nftab;
+	nf = runtime·nftab;
 	while(nf > 0) {
 		n = nf/2;
 		if(f[n].entry <= addr && addr < f[n+1].entry)
@@ -276,10 +271,6 @@ runtime·findfunc(uintptr addr)
 	return nil;
 }
 
-func FuncForPC(pc uintptr) (ret *Func) {
-	ret = runtime·findfunc(pc);
-}
-
 static bool
 hasprefix(String s, int8 *p)
 {
diff --git a/src/pkg/runtime/symtab.go b/src/pkg/runtime/symtab.go
new file mode 100644
index 0000000000..1d2033f10f
--- /dev/null
+++ b/src/pkg/runtime/symtab.go
@@ -0,0 +1,153 @@
+// 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 runtime
+
+import "unsafe"
+
+// FuncForPC returns a *Func describing the function that contains the
+// given program counter address, or else nil.
+func FuncForPC(pc uintptr) *Func {
+	if nftab == 0 {
+		return nil
+	}
+
+	if pc < ftabi(0).entry || pc >= ftabi(nftab).entry {
+		return nil
+	}
+
+	// binary search to find func with entry <= pc.
+	lo := uintptr(0)
+	nf := nftab
+	for nf > 0 {
+		n := nf / 2
+		f := ftabi(lo + n)
+		if f.entry <= pc && pc < ftabi(lo+n+1).entry {
+			return (*Func)(unsafe.Pointer(pclntab + f.funcoff))
+		} else if pc < f.entry {
+			nf = n
+		} else {
+			lo += n + 1
+			nf -= n + 1
+		}
+	}
+
+	gothrow("FuncForPC: binary search failed")
+	return nil
+}
+
+// Name returns the name of the function.
+func (f *Func) Name() string {
+	return cstringToGo(pclntab + uintptr(f.nameoff))
+}
+
+// Entry returns the entry address of the function.
+func (f *Func) Entry() uintptr {
+	return f.entry
+}
+
+// FileLine returns the file name and line number of the
+// source code corresponding to the program counter pc.
+// The result will not be accurate if pc is not a program
+// counter within f.
+func (f *Func) FileLine(pc uintptr) (file string, line int) {
+	fileno := f.pcvalue(f.pcfile, pc)
+	if fileno == -1 || fileno >= int32(nfiletab) {
+		return "?", 0
+	}
+	line = int(f.pcvalue(f.pcln, pc))
+	if line == -1 {
+		return "?", 0
+	}
+	file = cstringToGo(pclntab + uintptr(filetabi(uintptr(fileno))))
+	return file, line
+}
+
+// Return associated data value for targetpc in func f.
+func (f *Func) pcvalue(off int32, targetpc uintptr) int32 {
+	if off == 0 {
+		return -1
+	}
+	p := pclntab + uintptr(off)
+	pc := f.entry
+	val := int32(-1)
+	for step(&p, &pc, &val, pc == f.entry) {
+		if targetpc < pc {
+			return val
+		}
+	}
+	return -1
+}
+
+// step advances to the next pc, value pair in the encoded table.
+func step(p *uintptr, pc *uintptr, val *int32, first bool) bool {
+	uvdelta := readvarint(p)
+	if uvdelta == 0 && !first {
+		return false
+	}
+	if uvdelta&1 != 0 {
+		uvdelta = ^(uvdelta >> 1)
+	} else {
+		uvdelta >>= 1
+	}
+	vdelta := int32(uvdelta)
+	pcdelta := readvarint(p) * pcquantum
+	*pc += uintptr(pcdelta)
+	*val += vdelta
+	return true
+}
+
+// readvarint reads a varint from *p and advances *p.
+func readvarint(pp *uintptr) uint32 {
+	var v, shift uint32
+	p := *pp
+	for {
+		b := *(*byte)(unsafe.Pointer(p))
+		p++
+		v |= (uint32(b) & 0x7F) << shift
+		if b&0x80 == 0 {
+			break
+		}
+		shift += 7
+	}
+	*pp = p
+	return v
+}
+
+// Populated by runtime·symtabinit during bootstrapping. Treat as immutable.
+var (
+	pclntab   uintptr // address of pclntab
+	ftab0     uintptr // address of first ftab entry
+	nftab     uintptr
+	filetab0  uintptr // address of first filetab entry
+	nfiletab  uint32
+	pcquantum uint32
+)
+
+type Func struct {
+	entry   uintptr // start pc
+	nameoff int32   // function name
+
+	args  int32 // in/out args size
+	frame int32 // legacy frame size; use pcsp if possible
+
+	pcsp      int32
+	pcfile    int32
+	pcln      int32
+	npcdata   int32
+	nfuncdata int32
+}
+
+type ftab struct {
+	entry   uintptr
+	funcoff uintptr
+}
+
+func ftabi(i uintptr) (f ftab) {
+	return *(*ftab)(unsafe.Pointer(ftab0 + i*unsafe.Sizeof(f)))
+}
+
+func filetabi(i uintptr) (f uint32) {
+	return *(*uint32)(unsafe.Pointer(filetab0 + i*unsafe.Sizeof(f)))
+}

From 9368d6ccbfe57bc54b433b22b2008d3c4faf086d Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <shurcooL@gmail.com>
Date: Fri, 22 Aug 2014 10:18:00 -0700
Subject: [PATCH 163/423] cmd/gofmt: fix error on partial Go code ending with
 line comment.

Fix issue by always appending newline after user input, before
the closing curly bracket. The adjust func is modified to remove
this new newline.

Add test case (it fails before CL, passes after).

Fixes #8411.

LGTM=gri
R=golang-codereviews, bradfitz, josharian, gri
CC=golang-codereviews
https://golang.org/cl/124700043
---
 src/cmd/gofmt/gofmt.go               | 4 ++--
 src/cmd/gofmt/testdata/stdin5.golden | 3 +++
 src/cmd/gofmt/testdata/stdin5.input  | 3 +++
 3 files changed, 8 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/gofmt/testdata/stdin5.golden
 create mode 100644 src/cmd/gofmt/testdata/stdin5.input

diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index 576cae5228..f7d30d8405 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -277,14 +277,14 @@ func parse(fset *token.FileSet, filename string, src []byte, stdin bool) (*ast.F
 	// into a function body.  This handles expressions too.
 	// Insert using a ;, not a newline, so that the line numbers
 	// in fsrc match the ones in src.
-	fsrc := append(append([]byte("package p; func _() {"), src...), '}')
+	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 {
 			// Remove the wrapping.
 			// Gofmt has turned the ; into a \n\n.
 			src = src[len("package p\n\nfunc _() {"):]
-			src = src[:len(src)-len("}\n")]
+			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)
diff --git a/src/cmd/gofmt/testdata/stdin5.golden b/src/cmd/gofmt/testdata/stdin5.golden
new file mode 100644
index 0000000000..31ce6b2485
--- /dev/null
+++ b/src/cmd/gofmt/testdata/stdin5.golden
@@ -0,0 +1,3 @@
+//gofmt -stdin
+
+i := 5 // Line comment without newline.
\ No newline at end of file
diff --git a/src/cmd/gofmt/testdata/stdin5.input b/src/cmd/gofmt/testdata/stdin5.input
new file mode 100644
index 0000000000..0a7c97d180
--- /dev/null
+++ b/src/cmd/gofmt/testdata/stdin5.input
@@ -0,0 +1,3 @@
+//gofmt -stdin
+
+i  :=5// Line comment without newline.
\ No newline at end of file

From f4485784f05908051e7ec1732a27f53241f48fc4 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 22 Aug 2014 21:27:25 +0400
Subject: [PATCH 164/423] runtime: please vet The current code is correct, but
 vet does not understand it: asm_amd64.s:963: [amd64] invalid MOVL of
 ret+0(FP); int64 is 8-byte value asm_amd64.s:964: [amd64] invalid offset
 ret+4(FP); expected ret+0(FP)

LGTM=minux
R=golang-codereviews, minux
CC=golang-codereviews
https://golang.org/cl/125200044
---
 src/pkg/runtime/asm_amd64.s | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 9fcb2318b9..3b63c56a35 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -955,8 +955,9 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 
 TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
 	RDTSC
-	MOVL    AX, ret+0(FP)
-	MOVL    DX, ret+4(FP)
+	SHLQ    $32, DX
+	ADDQ    DX, AX
+	MOVQ    AX, ret+0(FP)
 	RET
 
 TEXT runtime·stackguard(SB),NOSPLIT,$0-16

From afb2260491e6427fa9b2e7fc629dac736113cfa6 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 22 Aug 2014 22:13:01 +0400
Subject: [PATCH 165/423] runtime: convert note to Go Note is required for
 timers and heap scavenger.

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr, rlh
https://golang.org/cl/128620043
---
 src/cmd/api/goapi.go           |  1 +
 src/pkg/runtime/export_test.go |  1 -
 src/pkg/runtime/lock_futex.c   | 26 ++++++++++++++++++++++++++
 src/pkg/runtime/lock_sema.c    | 29 +++++++++++++++++++++++++++++
 src/pkg/runtime/proc.c         | 25 +++++++++++++++++++++++++
 src/pkg/runtime/runtime.h      |  1 +
 src/pkg/runtime/stubs.go       | 27 ++++++++++++++++++++++++++-
 7 files changed, 108 insertions(+), 2 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 07f007fdfb..7117254e53 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -383,6 +383,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" mspan struct{}; m struct{}; lock struct{}; slicetype struct{};" +
 			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
 			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
+			" note struct{};" +
 			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 4ca5a7354f..9d25cafebb 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -19,7 +19,6 @@ var Fintto64 = fintto64
 var F64toint = f64toint
 
 func entersyscall()
-func exitsyscall()
 func golockedOSThread() bool
 func stackguard() (sp, limit uintptr)
 
diff --git a/src/pkg/runtime/lock_futex.c b/src/pkg/runtime/lock_futex.c
index 7fc2d5547d..2f4de03104 100644
--- a/src/pkg/runtime/lock_futex.c
+++ b/src/pkg/runtime/lock_futex.c
@@ -125,6 +125,16 @@ runtime·notewakeup(Note *n)
 	runtime·futexwakeup((uint32*)&n->key, 1);
 }
 
+void
+runtime·notewakeup_m(void)
+{
+	Note *n;
+
+	n = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	runtime·notewakeup(n);
+}
+
 void
 runtime·notesleep(Note *n)
 {
@@ -199,3 +209,19 @@ runtime·notetsleepg(Note *n, int64 ns)
 	runtime·exitsyscall();
 	return res;
 }
+
+void
+runtime·notetsleepg_m(void)
+{
+	Note *n;
+	int64 ns;
+
+	n = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	ns = g->m->scalararg[0] + ((int64)g->m->scalararg[1] << 32);
+
+	runtime·entersyscallblock_m(pc, sp);
+	notetsleep(n, ns, 0, 0);
+	// caller will call exitsyscall on g stack
+	runtime·gogo(&g->m->curg->sched);
+}
diff --git a/src/pkg/runtime/lock_sema.c b/src/pkg/runtime/lock_sema.c
index a4274e6555..98eea91d5f 100644
--- a/src/pkg/runtime/lock_sema.c
+++ b/src/pkg/runtime/lock_sema.c
@@ -147,6 +147,16 @@ runtime·notewakeup(Note *n)
 	}
 }
 
+void
+runtime·notewakeup_m(void)
+{
+	Note *n;
+
+	n = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	runtime·notewakeup(n);
+}
+
 void
 runtime·notesleep(Note *n)
 {
@@ -264,3 +274,22 @@ runtime·notetsleepg(Note *n, int64 ns)
 	runtime·exitsyscall();
 	return res;
 }
+
+void
+runtime·notetsleepg_m(void)
+{
+	Note *n;
+	int64 ns;
+
+	n = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	ns = g->m->scalararg[0] + ((int64)g->m->scalararg[1] << 32);
+
+	if(g->m->waitsema == 0)
+		g->m->waitsema = runtime·semacreate();
+
+	runtime·entersyscallblock_m();
+	notetsleep(n, ns, 0, nil);
+	// caller will call exitsyscall on g stack
+	runtime·gogo(&g->m->curg->sched);
+}
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 5ff38fb692..df85042340 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1630,6 +1630,31 @@ void
 	g->m->locks--;
 }
 
+// The same as runtime·entersyscallblock(), but called on g0 stack.
+void
+runtime·entersyscallblock_m(void)
+{
+	G *gp;
+
+	gp = g->m->curg;
+	// sched.{g,pc,sp,lr} are already set by mcall.
+	gp->stackguard0 = StackPreempt;  // we are on g0, the goroutine must not touch its stack until exitsyscall
+	gp->sched.ret = 0;
+	gp->sched.ctxt = 0;
+	gp->syscallsp = gp->sched.sp;
+	gp->syscallpc = gp->sched.pc;
+	gp->syscallstack = gp->stackbase;
+	gp->syscallguard = gp->stackguard;
+	gp->status = Gsyscall;
+	if(gp->syscallsp < gp->syscallguard-StackGuard || gp->syscallstack < gp->syscallsp) {
+		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
+		//	gp->syscallsp, gp->syscallguard-StackGuard, gp->syscallstack);
+		runtime·throw("entersyscall_m");
+	}
+
+	handoffp(releasep());
+}
+
 // The goroutine g exited its system call.
 // Arrange for it to run on a cpu again.
 // This is called only from the go syscall library, not
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index d38eb454b7..35574f4cd6 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -931,6 +931,7 @@ void	runtime·asmcgocall(void (*fn)(void*), void*);
 void	runtime·entersyscall(void);
 void	runtime·entersyscallblock(void);
 void	runtime·exitsyscall(void);
+void	runtime·entersyscallblock_m(void);
 G*	runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
 bool	runtime·sigsend(int32 sig);
 int32	runtime·callers(int32, uintptr*, int32);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index f3ac783aca..a31589ca86 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -73,7 +73,9 @@ var (
 	gosched_m,
 	ready_m,
 	park_m,
-	blockevent_m mFunction
+	blockevent_m,
+	notewakeup_m,
+	notetsleepg_m mFunction
 )
 
 // memclr clears n bytes starting at ptr.
@@ -169,3 +171,26 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 func gopersistentalloc(n uintptr) unsafe.Pointer
 
 func gocputicks() int64
+
+func gonoteclear(n *note) {
+	n.key = 0
+}
+
+func gonotewakeup(n *note) {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(n)
+	onM(&notewakeup_m)
+	releasem(mp)
+}
+
+func gonotetsleepg(n *note, t int64) {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(n)
+	mp.scalararg[0] = uint(uint32(t)) // low 32 bits
+	mp.scalararg[1] = uint(t >> 32)   // high 32 bits
+	releasem(mp)
+	mcall(&notetsleepg_m)
+	exitsyscall()
+}
+
+func exitsyscall()

From d2165672ca8f9bf02389f02ad211ec34394cb722 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 22 Aug 2014 22:22:16 +0400
Subject: [PATCH 166/423] runtime: fix futex notes

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/126540043
---
 src/pkg/runtime/lock_futex.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/lock_futex.c b/src/pkg/runtime/lock_futex.c
index 2f4de03104..27a866a731 100644
--- a/src/pkg/runtime/lock_futex.c
+++ b/src/pkg/runtime/lock_futex.c
@@ -220,7 +220,7 @@ runtime·notetsleepg_m(void)
 	g->m->ptrarg[0] = nil;
 	ns = g->m->scalararg[0] + ((int64)g->m->scalararg[1] << 32);
 
-	runtime·entersyscallblock_m(pc, sp);
+	runtime·entersyscallblock_m();
 	notetsleep(n, ns, 0, 0);
 	// caller will call exitsyscall on g stack
 	runtime·gogo(&g->m->curg->sched);

From 6ed58c296280575cc817d614bee0b19744e1ee55 Mon Sep 17 00:00:00 2001
From: Daniel Morsing <daniel.morsing@gmail.com>
Date: Sat, 23 Aug 2014 15:42:30 +0100
Subject: [PATCH 167/423] runtime: run newproc1 on M stack.

This makes newproc invisible to the GC. This is a pretty simple change since parts of newproc already depends on being run on the M stack.

LGTM=dvyukov
R=golang-codereviews, dvyukov
CC=golang-codereviews, khr
https://golang.org/cl/129520043
---
 src/pkg/runtime/proc.c | 31 ++++++++++++++++++++++++++++---
 src/pkg/runtime/race.c |  8 +++++++-
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index df85042340..dbe47d2af7 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1861,13 +1861,31 @@ runtime·malg(int32 stacksize)
 	return newg;
 }
 
+static void
+newproc_m(void)
+{
+	byte *argp;
+	void *callerpc;
+	FuncVal *fn;
+	int32 siz;
+	G *spawng;
+
+	siz = g->m->scalararg[0];
+	callerpc = (void*)g->m->scalararg[1];	
+	argp = g->m->ptrarg[0];
+	fn = (FuncVal*)g->m->ptrarg[1];
+
+	runtime·newproc1(fn, argp, siz, 0, callerpc);
+	g->m->ptrarg[0] = nil;
+	g->m->ptrarg[1] = nil;
+}
+
 // Create a new g running fn with siz bytes of arguments.
 // Put it on the queue of g's waiting to run.
 // The compiler turns a go statement into a call to this.
 // Cannot split the stack because it assumes that the arguments
 // are available sequentially after &fn; they would not be
-// copied if a stack split occurred.  It's OK for this to call
-// functions that split the stack.
+// copied if a stack split occurred.
 #pragma textflag NOSPLIT
 void
 runtime·newproc(int32 siz, FuncVal* fn, ...)
@@ -1878,7 +1896,14 @@ runtime·newproc(int32 siz, FuncVal* fn, ...)
 		argp = (byte*)(&fn+2);  // skip caller's saved LR
 	else
 		argp = (byte*)(&fn+1);
-	runtime·newproc1(fn, argp, siz, 0, runtime·getcallerpc(&siz));
+
+	g->m->locks++;
+	g->m->scalararg[0] = siz;
+	g->m->scalararg[1] = (uintptr)runtime·getcallerpc(&siz);
+	g->m->ptrarg[0] = argp;
+	g->m->ptrarg[1] = fn;
+	runtime·onM(newproc_m);
+	g->m->locks--;
 }
 
 // Create a new g running fn with narg bytes of arguments starting
diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index fa04a39310..6a4d2803c1 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -118,8 +118,14 @@ uintptr
 runtime·racegostart(void *pc)
 {
 	uintptr racectx;
+	G *spawng;
 
-	runtime·racecall(__tsan_go_start, g->racectx, &racectx, pc);
+	if(g->m->curg != nil)
+		spawng = g->m->curg;
+	else
+		spawng = g;
+
+	runtime·racecall(__tsan_go_start, spawng->racectx, &racectx, pc);
 	return racectx;
 }
 

From 71ecd16bf5c7a43849b5a3ad874ca8bd0accd302 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sat, 23 Aug 2014 21:11:57 +0400
Subject: [PATCH 168/423] runtime: remove unused var

LGTM=bradfitz
R=daniel.morsing, bradfitz
CC=golang-codereviews
https://golang.org/cl/130500044
---
 src/pkg/runtime/proc.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index dbe47d2af7..6767622846 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1868,7 +1868,6 @@ newproc_m(void)
 	void *callerpc;
 	FuncVal *fn;
 	int32 siz;
-	G *spawng;
 
 	siz = g->m->scalararg[0];
 	callerpc = (void*)g->m->scalararg[1];	

From 950ad4fa2bfb4539ebac21d7a32aa23da59376a7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 23 Aug 2014 19:24:44 -0400
Subject: [PATCH 169/423] cmd/gc: change interface representation: only
 pointers in data word

Note that there are various cleanups that can be made if we keep
this change, but I do not want to start making changes that
depend on this one until the 1.4 cycle closes.

Fixes #8405.

LGTM=r
R=golang-codereviews, adg, r, bradfitz
CC=golang-codereviews, iant
https://golang.org/cl/130240043
---
 src/cmd/gc/subr.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 325614e6bc..081c373a88 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -3808,7 +3808,7 @@ isdirectiface(Type *t)
 	// where the data word can hold a pointer or any
 	// non-pointer value no bigger than a pointer.
 	enum {
-		IfacePointerOnly = 0,
+		IfacePointerOnly = 1,
 	};
 
 	if(IfacePointerOnly) {

From 32b3a48ea8f29f0f5ee93714567eb24a660f3b07 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Sat, 23 Aug 2014 23:38:31 +0000
Subject: [PATCH 170/423] runtime: convert float64toint64, float64touint64 to
 Go

This is a very dumb translation to keep the code as close to the original C as possible.

LGTM=rsc
R=khr, minux, rsc, josharian
CC=golang-codereviews
https://golang.org/cl/126490043
---
 src/pkg/runtime/vlrt.go    | 91 ++++++++++++++++++++++++++++++++++++++
 src/pkg/runtime/vlrt_arm.c | 12 -----
 2 files changed, 91 insertions(+), 12 deletions(-)
 create mode 100644 src/pkg/runtime/vlrt.go

diff --git a/src/pkg/runtime/vlrt.go b/src/pkg/runtime/vlrt.go
new file mode 100644
index 0000000000..64154fce08
--- /dev/null
+++ b/src/pkg/runtime/vlrt.go
@@ -0,0 +1,91 @@
+// Inferno's libkern/vlrt-arm.c
+// http://code.google.com/p/inferno-os/source/browse/libkern/vlrt-arm.c
+//
+//         Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//         Revisions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).  All rights reserved.
+//         Portions Copyright 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// +build arm
+
+package runtime
+
+import "unsafe"
+
+func float64toint64(d float64, y uint64) {
+	_d2v(&y, d)
+}
+
+func float64touint64(d float64, y uint64) {
+	_d2v(&y, d)
+}
+
+const (
+	sign64 = 1 << (64 - 1)
+)
+
+func _d2v(y *uint64, d float64) {
+	x := *(*uint64)(unsafe.Pointer(&d))
+
+	xhi := uint32(x>>32)&0xfffff | 0x100000
+	xlo := uint32(x)
+	sh := 1075 - int32(uint32(x>>52)&0x7ff)
+
+	var ylo, yhi uint32
+	if sh >= 0 {
+		sh := uint32(sh)
+		/* v = (hi||lo) >> sh */
+		if sh < 32 {
+			if sh == 0 {
+				ylo = xlo
+				yhi = xhi
+			} else {
+				ylo = xlo>>sh | xhi<<(32-sh)
+				yhi = xhi >> sh
+			}
+		} else {
+			if sh == 32 {
+				ylo = xhi
+			} else if sh < 64 {
+				ylo = xhi >> (sh - 32)
+			}
+		}
+	} else {
+		/* v = (hi||lo) << -sh */
+		sh := uint32(-sh)
+		if sh <= 11 {
+			ylo = xlo << sh
+			yhi = xhi<<sh | xlo>>(32-sh)
+		} else {
+			/* overflow */
+			yhi = uint32(d) /* causes something awful */
+		}
+	}
+	if x&sign64 != 0 {
+		if ylo != 0 {
+			ylo = -ylo
+			yhi = ^yhi
+		} else {
+			yhi = -yhi
+		}
+	}
+
+	*y = uint64(yhi)<<32 | uint64(ylo)
+}
diff --git a/src/pkg/runtime/vlrt_arm.c b/src/pkg/runtime/vlrt_arm.c
index 48ae08be32..5e7807f455 100644
--- a/src/pkg/runtime/vlrt_arm.c
+++ b/src/pkg/runtime/vlrt_arm.c
@@ -128,18 +128,6 @@ _f2v(Vlong *y, float f)
 	_d2v(y, f);
 }
 
-void
-runtime·float64toint64(double d, Vlong y)
-{
-	_d2v(&y, d);
-}
-
-void
-runtime·float64touint64(double d, Vlong y)
-{
-	_d2v(&y, d);
-}
-
 double
 _ul2d(ulong u)
 {

From 5b70b7121968233cd953eba4d77b768400086d9c Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Sat, 23 Aug 2014 21:52:17 -0400
Subject: [PATCH 171/423] undo CL 130240043 / b09f70c301a5
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This change broke divmod.go on all arm platforms.

««« original CL description
cmd/gc: change interface representation: only pointers in data word

Note that there are various cleanups that can be made if we keep
this change, but I do not want to start making changes that
depend on this one until the 1.4 cycle closes.

Fixes #8405.

LGTM=r
R=golang-codereviews, adg, r, bradfitz
CC=golang-codereviews, iant
https://golang.org/cl/130240043
»»»

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/133810043
---
 src/cmd/gc/subr.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 081c373a88..325614e6bc 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -3808,7 +3808,7 @@ isdirectiface(Type *t)
 	// where the data word can hold a pointer or any
 	// non-pointer value no bigger than a pointer.
 	enum {
-		IfacePointerOnly = 1,
+		IfacePointerOnly = 0,
 	};
 
 	if(IfacePointerOnly) {

From 48452a276d63639f54d3ce1a8d36663e26949526 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 23 Aug 2014 23:01:59 -0400
Subject: [PATCH 172/423] runtime: adjust errorCString definition to avoid
 allocation

The low-level implementation of divide on ARM assumes that
it can panic with an error created by newErrorCString without
allocating. If we make interface data words require pointer values,
the current definition would require an allocation when stored
in an interface. Changing the definition to use unsafe.Pointer
instead of uintptr avoids the allocation. This change is okay
because the field really is a pointer (to a C string in rodata).

Update #8405.

This should make CL 133830043 safe to try again.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=dave, golang-codereviews, r
https://golang.org/cl/133820043
---
 src/pkg/runtime/error.go | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/pkg/runtime/error.go b/src/pkg/runtime/error.go
index 12fd09eaf9..f379fc443a 100644
--- a/src/pkg/runtime/error.go
+++ b/src/pkg/runtime/error.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 // The Error interface identifies a run time error.
 type Error interface {
 	error
@@ -75,17 +77,19 @@ func newErrorString(s string, ret *interface{}) {
 }
 
 // An errorCString represents a runtime error described by a single C string.
-// Not "type errorCString uintptr" because of http://golang.org/issue/7084.
-type errorCString struct{ cstr uintptr }
+// Not "type errorCString unsafe.Pointer" because of http://golang.org/issue/7084.
+// Not uintptr because we want to avoid an allocation if interfaces can't hold
+// uintptrs directly (and cstr _is_ a pointer).
+type errorCString struct{ cstr unsafe.Pointer }
 
 func (e errorCString) RuntimeError() {}
 
 func (e errorCString) Error() string {
-	return "runtime error: " + cstringToGo(e.cstr)
+	return "runtime error: " + cstringToGo(uintptr(e.cstr))
 }
 
 // For calling from C.
-func newErrorCString(s uintptr, ret *interface{}) {
+func newErrorCString(s unsafe.Pointer, ret *interface{}) {
 	*ret = errorCString{s}
 }
 

From 98bebcc90a4e50e3fd458585744829f2065f2b09 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sun, 24 Aug 2014 11:47:06 +0400
Subject: [PATCH 173/423] runtime: convert parfor to Go

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr
https://golang.org/cl/132100043
---
 src/pkg/runtime/export_test.go | 54 ++++++++++++++++++++++++++++------
 src/pkg/runtime/parfor.c       | 45 ++++++++++++++++++++++++++--
 2 files changed, 87 insertions(+), 12 deletions(-)

diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 9d25cafebb..f75b742b61 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -66,18 +66,54 @@ type ParFor struct {
 	wait    bool
 }
 
-func newParFor(nthrmax uint32) *ParFor
-func parForSetup(desc *ParFor, nthr, n uint32, ctx *byte, wait bool, body func(*ParFor, uint32))
-func parForDo(desc *ParFor)
-func parForIters(desc *ParFor, tid uintptr) (uintptr, uintptr)
+var (
+	newparfor_m,
+	parforsetup_m,
+	parfordo_m,
+	parforiters_m mFunction
+)
 
-var NewParFor = newParFor
-var ParForSetup = parForSetup
-var ParForDo = parForDo
+func NewParFor(nthrmax uint32) *ParFor {
+	mp := acquirem()
+	mp.scalararg[0] = uint(nthrmax)
+	onM(&newparfor_m)
+	desc := (*ParFor)(mp.ptrarg[0])
+	mp.ptrarg[0] = nil
+	releasem(mp)
+	return desc
+}
+
+func ParForSetup(desc *ParFor, nthr, n uint32, ctx *byte, wait bool, body func(*ParFor, uint32)) {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(desc)
+	mp.ptrarg[1] = unsafe.Pointer(ctx)
+	mp.ptrarg[2] = **(**unsafe.Pointer)(unsafe.Pointer(&body))
+	mp.scalararg[0] = uint(nthr)
+	mp.scalararg[1] = uint(n)
+	mp.scalararg[2] = 0
+	if wait {
+		mp.scalararg[2] = 1
+	}
+	onM(&parforsetup_m)
+	releasem(mp)
+}
+
+func ParForDo(desc *ParFor) {
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(desc)
+	onM(&parfordo_m)
+	releasem(mp)
+}
 
 func ParForIters(desc *ParFor, tid uint32) (uint32, uint32) {
-	begin, end := parForIters(desc, uintptr(tid))
-	return uint32(begin), uint32(end)
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(desc)
+	mp.scalararg[0] = uint(tid)
+	onM(&parforiters_m)
+	begin := uint32(mp.scalararg[0])
+	end := uint32(mp.scalararg[1])
+	releasem(mp)
+	return begin, end
 }
 
 //go:noescape
diff --git a/src/pkg/runtime/parfor.c b/src/pkg/runtime/parfor.c
index 1073dfa394..6023193b5c 100644
--- a/src/pkg/runtime/parfor.c
+++ b/src/pkg/runtime/parfor.c
@@ -192,8 +192,47 @@ exit:
 
 // For testing from Go.
 void
-runtime·parforiters(ParFor *desc, uintptr tid, uintptr *start, uintptr *end)
+runtime·newparfor_m(void)
 {
-	*start = (uint32)desc->thr[tid].pos;
-	*end = (uint32)(desc->thr[tid].pos>>32);
+	g->m->ptrarg[0] = runtime·parforalloc(g->m->scalararg[0]);
+}
+
+void
+runtime·parforsetup_m(void)
+{
+	ParFor *desc;
+	void *ctx;
+	void (*body)(ParFor*, uint32);
+
+	desc = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	ctx = g->m->ptrarg[1];
+	g->m->ptrarg[1] = nil;
+	body = g->m->ptrarg[2];
+	g->m->ptrarg[2] = nil;
+
+	runtime·parforsetup(desc, g->m->scalararg[0], g->m->scalararg[1], ctx, g->m->scalararg[2], body);
+}
+
+void
+runtime·parfordo_m(void)
+{
+	ParFor *desc;
+
+	desc = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	runtime·parfordo(desc);
+}
+
+void
+runtime·parforiters_m(void)
+{
+	ParFor *desc;
+	uintptr tid;
+
+	desc = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	tid = g->m->scalararg[0];
+	g->m->scalararg[0] = desc->thr[tid].pos;
+	g->m->scalararg[1] = desc->thr[tid].pos>>32;
 }

From 651d0cf204da51eddec88c32c039d750ef7edbbd Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sun, 24 Aug 2014 11:50:37 +0400
Subject: [PATCH 174/423] runtime: convert sigqueue to Go

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr
https://golang.org/cl/132090043
---
 src/pkg/runtime/runtime.h                    |  1 +
 src/pkg/runtime/{sigqueue.goc => sigqueue.c} | 66 +++++++++++++-------
 src/pkg/runtime/sigqueue.go                  | 42 +++++++++++++
 3 files changed, 85 insertions(+), 24 deletions(-)
 rename src/pkg/runtime/{sigqueue.goc => sigqueue.c} (84%)
 create mode 100644 src/pkg/runtime/sigqueue.go

diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 35574f4cd6..dcce369a5c 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -781,6 +781,7 @@ extern	DebugVars	runtime·debug;
 extern	uintptr	runtime·maxstacksize;
 extern	byte*	runtime·gcdatamask;
 extern	byte*	runtime·gcbssmask;
+extern	Note	runtime·signote;
 
 /*
  * common functions and data
diff --git a/src/pkg/runtime/sigqueue.goc b/src/pkg/runtime/sigqueue.c
similarity index 84%
rename from src/pkg/runtime/sigqueue.goc
rename to src/pkg/runtime/sigqueue.c
index fa0eb51a1c..e5617bde7d 100644
--- a/src/pkg/runtime/sigqueue.goc
+++ b/src/pkg/runtime/sigqueue.c
@@ -24,22 +24,26 @@
 // unnecessary rechecks of sig.mask, but must not lead to missed signals
 // nor deadlocks.
 
-package runtime
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "cgocall.h"
 #include "../../cmd/ld/textflag.h"
 
-#pragma textflag NOPTR
-static struct {
-	Note note;
+typedef struct Sig Sig;
+struct Sig {
 	uint32 mask[(NSIG+31)/32];
 	uint32 wanted[(NSIG+31)/32];
 	uint32 recv[(NSIG+31)/32];
 	uint32 state;
 	bool inuse;
-} sig;
+	bool afterwait;
+};
+
+#pragma dataflag NOPTR
+static Sig sig;
+
+Note runtime·signote;
 
 enum {
 	HASWAITER = 1,
@@ -72,7 +76,7 @@ runtime·sigsend(int32 s)
 					new = HASSIGNAL;
 				if(runtime·cas(&sig.state, old, new)) {
 					if (old == HASWAITER)
-						runtime·notewakeup(&sig.note);
+						runtime·notewakeup(&runtime·signote);
 					break;
 				}
 			}
@@ -84,16 +88,23 @@ runtime·sigsend(int32 s)
 
 // Called to receive the next queued signal.
 // Must only be called from a single goroutine at a time.
-func signal_recv() (m uint32) {
+void
+runtime·signal_recv_m(void)
+{
 	uint32 i, old, new;
-	
+
+	if(sig.afterwait) {
+		sig.afterwait = false;
+		goto update;
+	}
 	for(;;) {
 		// Serve from local copy if there are bits left.
 		for(i=0; i<NSIG; i++) {
 			if(sig.recv[i/32]&(1U<<(i&31))) {
 				sig.recv[i/32] ^= 1U<<(i&31);
-				m = i;
-				goto done;
+				g->m->scalararg[0] = true;
+				g->m->scalararg[1] = i;
+				return;
 			}
 		}
 
@@ -108,41 +119,43 @@ func signal_recv() (m uint32) {
 				new = HASWAITER;
 			if(runtime·cas(&sig.state, old, new)) {
 				if (new == HASWAITER) {
-					runtime·notetsleepg(&sig.note, -1);
-					runtime·noteclear(&sig.note);
+					sig.afterwait = true;
+					g->m->scalararg[0] = false;
+					g->m->scalararg[1] = 0;
+					return;
 				}
 				break;
 			}
 		}
 
 		// Get a new local copy.
+	update:
 		for(i=0; i<nelem(sig.mask); i++) {
 			for(;;) {
-				m = sig.mask[i];
-				if(runtime·cas(&sig.mask[i], m, 0))
+				old = sig.mask[i];
+				if(runtime·cas(&sig.mask[i], old, 0))
 					break;
 			}
-			sig.recv[i] = m;
+			sig.recv[i] = old;
 		}
 	}
-
-done:;
-	// goc requires that we fall off the end of functions
-	// that return values instead of using our own return
-	// statements.
 }
 
 // Must only be called from a single goroutine at a time.
-func signal_enable(s uint32) {
+void
+runtime·signal_enable_m(void)
+{
+	uint32 s;
+
 	if(!sig.inuse) {
 		// The first call to signal_enable is for us
 		// to use for initialization.  It does not pass
 		// signal information in m.
 		sig.inuse = true;	// enable reception of signals; cannot disable
-		runtime·noteclear(&sig.note);
+		runtime·noteclear(&runtime·signote);
 		return;
 	}
-	
+	s = g->m->scalararg[0];
 	if(s >= nelem(sig.wanted)*32)
 		return;
 	sig.wanted[s/32] |= 1U<<(s&31);
@@ -150,7 +163,12 @@ func signal_enable(s uint32) {
 }
 
 // Must only be called from a single goroutine at a time.
-func signal_disable(s uint32) {
+void
+runtime·signal_disable_m(void)
+{
+	uint32 s;
+
+	s = g->m->scalararg[0];
 	if(s >= nelem(sig.wanted)*32)
 		return;
 	sig.wanted[s/32] &= ~(1U<<(s&31));
diff --git a/src/pkg/runtime/sigqueue.go b/src/pkg/runtime/sigqueue.go
new file mode 100644
index 0000000000..5976e57352
--- /dev/null
+++ b/src/pkg/runtime/sigqueue.go
@@ -0,0 +1,42 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file implements runtime support for signal handling.
+
+package runtime
+
+func signal_recv() (m uint32) {
+	for {
+		mp := acquirem()
+		onM(&signal_recv_m)
+		ok := mp.scalararg[0] != 0
+		m = uint32(mp.scalararg[1])
+		releasem(mp)
+		if ok {
+			return
+		}
+		gonotetsleepg(&signote, -1)
+		gonoteclear(&signote)
+	}
+}
+
+func signal_enable(s uint32) {
+	mp := acquirem()
+	mp.scalararg[0] = uint(s)
+	onM(&signal_enable_m)
+	releasem(mp)
+}
+
+func signal_disable(s uint32) {
+	mp := acquirem()
+	mp.scalararg[0] = uint(s)
+	onM(&signal_disable_m)
+	releasem(mp)
+}
+
+var (
+	signal_recv_m,
+	signal_enable_m,
+	signal_disable_m mFunction
+)

From b91223edd19590b4ac79ae14b66b8d5a80825e36 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sun, 24 Aug 2014 12:04:51 +0400
Subject: [PATCH 175/423] runtime: cache unrolled GC bitmask Cache unrolled GC
 bitmask for types up to 64/32K on 64/32-bit systems, this corresponds to up
 to 4K cached bitmask. Perf builders say that 2% of time is spent in
 unrollgcproginplace_m/unrollgcprog1 on http benchmark:
 http://goperfd.appspot.com/log/f42045f45bf61a0da53b724a7c8567824a0ad6c9

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr, rlh
https://golang.org/cl/122680043
---
 src/pkg/runtime/malloc.go | 2 +-
 src/pkg/runtime/mgc0.h    | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 578fbd1c2d..ffe571a18a 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -28,7 +28,7 @@ const (
 	bitsMask           = 1<<bitsPerPointer - 1
 	pointersPerByte    = 8 / bitsPerPointer
 	bitPtrMask         = bitsMask << 2
-	maxGCMask          = 0 // disabled because wastes several bytes of memory
+	maxGCMask          = 64
 	bitsDead           = 0
 	bitsPointer        = 2
 
diff --git a/src/pkg/runtime/mgc0.h b/src/pkg/runtime/mgc0.h
index 7449398b9f..a7292effd3 100644
--- a/src/pkg/runtime/mgc0.h
+++ b/src/pkg/runtime/mgc0.h
@@ -55,7 +55,8 @@ enum {
 	BitsIface	= 2,
 	BitsEface	= 3,
 
-	MaxGCMask	= 0,	// disabled because wastes several bytes of memory
+	// 64 bytes cover objects of size 1024/512 on 64/32 bits, respectively.
+	MaxGCMask	= 64,
 };
 
 // Bits in per-word bitmap.

From 7f223e3b3ba732c287db5a57b5091784baa9b86f Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sun, 24 Aug 2014 12:05:07 +0400
Subject: [PATCH 176/423] runtime: fix races on mheap.allspans

This is based on the crash dump provided by Alan
and on mental experiments:

sweep 0 74
fatal error: gc: unswept span
runtime stack:
runtime.throw(0x9df60d)
markroot(0xc208002000, 0x3)
runtime.parfordo(0xc208002000)
runtime.gchelper()

I think that when we moved all stacks into heap,
we introduced a bunch of bad data races. This was later
worsened by parallel stack shrinking.

Observation 1: exitsyscall can allocate a stack from heap at any time (including during STW).
Observation 2: parallel stack shrinking can (surprisingly) grow heap during marking.
Consider that we steadily grow stacks of a number of goroutines from 8K to 16K.
And during GC they all can be shrunk back to 8K. Shrinking will allocate lots of 8K
stacks, and we do not necessary have that many in heap at this moment. So shrinking
can grow heap as well.

Consequence: any access to mheap.allspans in GC (and otherwise) must take heap lock.
This is not true in several places.

Fix this by protecting accesses to mheap.allspans and introducing allspans cache for marking,
similar to what we use for sweeping.

LGTM=rsc
R=golang-codereviews, rsc
CC=adonovan, golang-codereviews, khr, rlh
https://golang.org/cl/126510043
---
 src/pkg/runtime/malloc.h |  2 +-
 src/pkg/runtime/mgc0.c   | 68 +++++++++++++++++++++++++---------------
 src/pkg/runtime/mheap.c  |  2 +-
 3 files changed, 45 insertions(+), 27 deletions(-)

diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 4485100098..48ec026005 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -465,7 +465,7 @@ struct MHeap
 	MSpan busy[MaxMHeapList];	// busy lists of large objects of given length
 	MSpan busylarge;		// busy lists of large objects length >= MaxMHeapList
 	MSpan **allspans;		// all spans out there
-	MSpan **sweepspans;		// copy of allspans referenced by sweeper
+	MSpan **gcspans;		// copy of allspans referenced by GC marker or sweeper
 	uint32	nspan;
 	uint32	nspancap;
 	uint32	sweepgen;		// sweep generation, see comment in MSpan
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 2d378e2aa3..2a476fae4d 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -202,6 +202,10 @@ static struct {
 	volatile uint32	ndone;
 	Note	alldone;
 	ParFor*	markfor;
+
+	// Copy of mheap.allspans for marker or sweeper.
+	MSpan**	spans;
+	uint32	nspan;
 } work;
 
 // scanblock scans a block of n bytes starting at pointer b for references
@@ -500,8 +504,7 @@ static void
 markroot(ParFor *desc, uint32 i)
 {
 	FinBlock *fb;
-	MHeap *h;
-	MSpan **allspans, *s;
+	MSpan *s;
 	uint32 spanidx, sg;
 	G *gp;
 	void *p;
@@ -524,14 +527,12 @@ markroot(ParFor *desc, uint32 i)
 
 	case RootSpans:
 		// mark MSpan.specials
-		h = &runtime·mheap;
-		sg = h->sweepgen;
-		allspans = h->allspans;
-		for(spanidx=0; spanidx<runtime·mheap.nspan; spanidx++) {
+		sg = runtime·mheap.sweepgen;
+		for(spanidx=0; spanidx<work.nspan; spanidx++) {
 			Special *sp;
 			SpecialFinalizer *spf;
 
-			s = allspans[spanidx];
+			s = work.spans[spanidx];
 			if(s->state != MSpanInUse)
 				continue;
 			if(s->sweepgen != sg) {
@@ -1084,9 +1085,7 @@ static struct
 	G*	g;
 	bool	parked;
 
-	MSpan**	spans;
-	uint32	nspan;
-	uint32	spanidx;
+	uint32	spanidx;	// background sweeper position
 
 	uint32	nbgsweep;
 	uint32	npausesweep;
@@ -1131,12 +1130,12 @@ runtime·sweepone(void)
 	sg = runtime·mheap.sweepgen;
 	for(;;) {
 		idx = runtime·xadd(&sweep.spanidx, 1) - 1;
-		if(idx >= sweep.nspan) {
+		if(idx >= work.nspan) {
 			runtime·mheap.sweepdone = true;
 			g->m->locks--;
 			return -1;
 		}
-		s = sweep.spans[idx];
+		s = work.spans[idx];
 		if(s->state != MSpanInUse) {
 			s->sweepgen = sg;
 			continue;
@@ -1259,6 +1258,7 @@ runtime·updatememstats(GCStats *stats)
 	cachestats();
 
 	// Scan all spans and count number of alive objects.
+	runtime·lock(&runtime·mheap.lock);
 	for(i = 0; i < runtime·mheap.nspan; i++) {
 		s = runtime·mheap.allspans[i];
 		if(s->state != MSpanInUse)
@@ -1272,6 +1272,7 @@ runtime·updatememstats(GCStats *stats)
 			mstats.alloc += s->ref*s->elemsize;
 		}
 	}
+	runtime·unlock(&runtime·mheap.lock);
 
 	// Aggregate by size class.
 	smallfree = 0;
@@ -1441,6 +1442,24 @@ gc(struct gc_args *args)
 	while(runtime·sweepone() != -1)
 		sweep.npausesweep++;
 
+	// Cache runtime.mheap.allspans in work.spans to avoid conflicts with
+	// resizing/freeing allspans.
+	// New spans can be created while GC progresses, but they are not garbage for
+	// this round:
+	//  - new stack spans can be created even while the world is stopped.
+	//  - new malloc spans can be created during the concurrent sweep
+
+	// Even if this is stop-the-world, a concurrent exitsyscall can allocate a stack from heap.
+	runtime·lock(&runtime·mheap.lock);
+	// Free the old cached sweep array if necessary.
+	if(work.spans != nil && work.spans != runtime·mheap.allspans)
+		runtime·SysFree(work.spans, work.nspan*sizeof(work.spans[0]), &mstats.other_sys);
+	// Cache the current array for marking.
+	runtime·mheap.gcspans = runtime·mheap.allspans;
+	work.spans = runtime·mheap.allspans;
+	work.nspan = runtime·mheap.nspan;
+	runtime·unlock(&runtime·mheap.lock);
+
 	work.nwait = 0;
 	work.ndone = 0;
 	work.nproc = runtime·gcprocs();
@@ -1500,28 +1519,27 @@ gc(struct gc_args *args)
 			mstats.numgc, work.nproc, (t1-t0)/1000, (t2-t1)/1000, (t3-t2)/1000, (t4-t3)/1000,
 			heap0>>20, heap1>>20, obj,
 			mstats.nmalloc, mstats.nfree,
-			sweep.nspan, sweep.nbgsweep, sweep.npausesweep,
+			work.nspan, sweep.nbgsweep, sweep.npausesweep,
 			stats.nhandoff, stats.nhandoffcnt,
 			work.markfor->nsteal, work.markfor->nstealcnt,
 			stats.nprocyield, stats.nosyield, stats.nsleep);
 		sweep.nbgsweep = sweep.npausesweep = 0;
 	}
 
-	// We cache current runtime·mheap.allspans array in sweep.spans,
-	// because the former can be resized and freed.
-	// Otherwise we would need to take heap lock every time
-	// we want to convert span index to span pointer.
-
-	// Free the old cached array if necessary.
-	if(sweep.spans && sweep.spans != runtime·mheap.allspans)
-		runtime·SysFree(sweep.spans, sweep.nspan*sizeof(sweep.spans[0]), &mstats.other_sys);
-	// Cache the current array.
-	runtime·mheap.sweepspans = runtime·mheap.allspans;
+	// See the comment in the beginning of this function as to why we need the following.
+	// Even if this is still stop-the-world, a concurrent exitsyscall can allocate a stack from heap.
+	runtime·lock(&runtime·mheap.lock);
+	// Free the old cached mark array if necessary.
+	if(work.spans != nil && work.spans != runtime·mheap.allspans)
+		runtime·SysFree(work.spans, work.nspan*sizeof(work.spans[0]), &mstats.other_sys);
+	// Cache the current array for sweeping.
+	runtime·mheap.gcspans = runtime·mheap.allspans;
 	runtime·mheap.sweepgen += 2;
 	runtime·mheap.sweepdone = false;
-	sweep.spans = runtime·mheap.allspans;
-	sweep.nspan = runtime·mheap.nspan;
+	work.spans = runtime·mheap.allspans;
+	work.nspan = runtime·mheap.nspan;
 	sweep.spanidx = 0;
+	runtime·unlock(&runtime·mheap.lock);
 
 	// Temporary disable concurrent sweep, because we see failures on builders.
 	if(ConcurrentSweep && !args->eagersweep) {
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 8e6190ce1a..59be0e093c 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -43,7 +43,7 @@ RecordSpan(void *vh, byte *p)
 			runtime·memmove(all, h->allspans, h->nspancap*sizeof(all[0]));
 			// Don't free the old array if it's referenced by sweep.
 			// See the comment in mgc0.c.
-			if(h->allspans != runtime·mheap.sweepspans)
+			if(h->allspans != runtime·mheap.gcspans)
 				runtime·SysFree(h->allspans, h->nspancap*sizeof(all[0]), &mstats.other_sys);
 		}
 		h->allspans = all;

From 9a1e142bbc3209f8899a729ec857a1c8838bf9f4 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sun, 24 Aug 2014 12:31:03 +0400
Subject: [PATCH 177/423] runtime: convert channel operations to Go, part 1
 (chansend1).

LGTM=dvyukov
R=dvyukov, khr
CC=golang-codereviews
https://golang.org/cl/127460044
---
 src/cmd/api/goapi.go                |   1 +
 src/cmd/gc/select.c                 |   1 +
 src/pkg/reflect/asm_386.s           |   2 +
 src/pkg/reflect/asm_amd64.s         |   2 +
 src/pkg/reflect/asm_amd64p32.s      |   2 +
 src/pkg/reflect/asm_arm.s           |   2 +
 src/pkg/runtime/chan.go             | 278 ++++++++++++++++++++++++++++
 src/pkg/runtime/chan.goc            |  77 --------
 src/pkg/runtime/chan.h              |  13 --
 src/pkg/runtime/chan_test.go        |  32 ++++
 src/pkg/runtime/mprof.goc           |  11 +-
 src/pkg/runtime/pprof/pprof_test.go |   2 +-
 src/pkg/runtime/proc.c              |   1 -
 src/pkg/runtime/runtime.h           |  15 +-
 src/pkg/runtime/stack.c             |  22 ++-
 src/pkg/runtime/stubs.go            |  12 ++
 16 files changed, 378 insertions(+), 95 deletions(-)
 create mode 100644 src/pkg/runtime/chan.go

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 7117254e53..2900a27ceb 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -383,6 +383,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" mspan struct{}; m struct{}; lock struct{}; slicetype struct{};" +
 			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
 			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
+			" hchan struct{}; chantype struct{}; waitq struct{};" +
 			" note struct{};" +
 			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
diff --git a/src/cmd/gc/select.c b/src/cmd/gc/select.c
index cbc199698d..a8caefbb53 100644
--- a/src/cmd/gc/select.c
+++ b/src/cmd/gc/select.c
@@ -340,6 +340,7 @@ selecttype(int32 size)
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("releasetime")), typenod(types[TUINT64])));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("nrelease")), typenod(types[TINT32])));
+	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("waitlink")), typenod(ptrto(types[TUINT8]))));
 	typecheck(&sudog, Etype);
 	sudog->type->noalg = 1;
 	sudog->type->local = 1;
diff --git a/src/pkg/reflect/asm_386.s b/src/pkg/reflect/asm_386.s
index 8c84bba43b..933908f206 100644
--- a/src/pkg/reflect/asm_386.s
+++ b/src/pkg/reflect/asm_386.s
@@ -52,3 +52,5 @@ TEXT ·unsafe_New(SB),NOSPLIT,$0-0
 	JMP	runtime·newobject(SB)
 TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
 	JMP	runtime·newarray(SB)
+TEXT ·makechan(SB),NOSPLIT,$0-0
+	JMP	runtime·makechan(SB)
diff --git a/src/pkg/reflect/asm_amd64.s b/src/pkg/reflect/asm_amd64.s
index 195928bff9..85de6ea827 100644
--- a/src/pkg/reflect/asm_amd64.s
+++ b/src/pkg/reflect/asm_amd64.s
@@ -52,3 +52,5 @@ TEXT ·unsafe_New(SB),NOSPLIT,$0-0
 	JMP	runtime·newobject(SB)
 TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
 	JMP	runtime·newarray(SB)
+TEXT ·makechan(SB),NOSPLIT,$0-0
+	JMP	runtime·makechan(SB)
diff --git a/src/pkg/reflect/asm_amd64p32.s b/src/pkg/reflect/asm_amd64p32.s
index 8c84bba43b..933908f206 100644
--- a/src/pkg/reflect/asm_amd64p32.s
+++ b/src/pkg/reflect/asm_amd64p32.s
@@ -52,3 +52,5 @@ TEXT ·unsafe_New(SB),NOSPLIT,$0-0
 	JMP	runtime·newobject(SB)
 TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
 	JMP	runtime·newarray(SB)
+TEXT ·makechan(SB),NOSPLIT,$0-0
+	JMP	runtime·makechan(SB)
diff --git a/src/pkg/reflect/asm_arm.s b/src/pkg/reflect/asm_arm.s
index fafc6f313e..e621b169b1 100644
--- a/src/pkg/reflect/asm_arm.s
+++ b/src/pkg/reflect/asm_arm.s
@@ -52,3 +52,5 @@ TEXT ·unsafe_New(SB),NOSPLIT,$0-0
 	B	runtime·newobject(SB)
 TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
 	B	runtime·newarray(SB)
+TEXT ·makechan(SB),NOSPLIT,$0-0
+	B	runtime·makechan(SB)
diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
new file mode 100644
index 0000000000..67427e960e
--- /dev/null
+++ b/src/pkg/runtime/chan.go
@@ -0,0 +1,278 @@
+// 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 runtime
+
+// This file contains the implementation of Go channels
+// and select statements.
+
+import "unsafe"
+
+const (
+	maxAlign  = 8
+	hchanSize = unsafe.Sizeof(hchan{})
+	debugChan = false
+)
+
+// TODO: make hchan.buf an unsafe.Pointer, not a *uint8
+
+func makechan(t *chantype, size int64) *hchan {
+	elem := t.elem
+
+	// compiler checks this but be safe.
+	if elem.size >= 1<<16 {
+		gothrow("makechan: invalid channel element type")
+	}
+	if hchanSize%maxAlign != 0 || elem.align > maxAlign {
+		gothrow("makechan: bad alignment")
+	}
+	if size < 0 || int64(uintptr(size)) != size || (elem.size > 0 && uintptr(size) > (maxMem-hchanSize)/uintptr(elem.size)) {
+		panic("makechan: size out of range")
+	}
+
+	var c *hchan
+	if elem.kind&kindNoPointers != 0 || size == 0 {
+		// allocate memory in one call
+		c = (*hchan)(gomallocgc(hchanSize+uintptr(size)*uintptr(elem.size), nil, flagNoScan))
+		if size > 0 && elem.size != 0 {
+			c.buf = (*uint8)(add(unsafe.Pointer(c), hchanSize))
+		} else {
+			c.buf = (*uint8)(unsafe.Pointer(c)) // race detector uses this location for synchronization
+		}
+	} else {
+		c = new(hchan)
+		c.buf = (*uint8)(newarray(elem, uintptr(size)))
+	}
+	c.elemsize = uint16(elem.size)
+	c.elemtype = elem
+	c.dataqsiz = uint(size)
+
+	if debugChan {
+		println("makechan: chan=", c, "; elemsize=", elem.size, "; elemalg=", elem.alg, "; dataqsiz=", size)
+	}
+	return c
+}
+
+// chanbuf(c, i) is pointer to the i'th slot in the buffer.
+func chanbuf(c *hchan, i uint) unsafe.Pointer {
+	return add(unsafe.Pointer(c.buf), uintptr(i)*uintptr(c.elemsize))
+}
+
+// entry point for c <- x from compiled code
+//go:nosplit
+func chansend1(t *chantype, c *hchan, elem unsafe.Pointer) {
+	chansend(t, c, elem, true, gogetcallerpc(unsafe.Pointer(&t)))
+}
+
+/*
+ * generic single channel send/recv
+ * If block is not nil,
+ * then the protocol will not
+ * sleep but return if it could
+ * not complete.
+ *
+ * sleep can wake up with g.param == nil
+ * when a channel involved in the sleep has
+ * been closed.  it is easiest to loop and re-run
+ * the operation; we'll see that it's now closed.
+ */
+func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
+	if raceenabled {
+		fn := chansend
+		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		raceReadObjectPC(t.elem, ep, callerpc, pc)
+	}
+
+	if c == nil {
+		if !block {
+			return false
+		}
+		gopark(nil, nil, "chan send (nil chan)")
+		return false // not reached
+	}
+
+	if debugChan {
+		println("chansend: chan=", c)
+	}
+
+	var t0 int64
+	if blockprofilerate > 0 {
+		t0 = gocputicks()
+	}
+
+	golock(&c.lock)
+	if raceenabled {
+		fn := chansend
+		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		racereadpc(unsafe.Pointer(c), pc, callerpc)
+	}
+	if c.closed != 0 {
+		gounlock(&c.lock)
+		panic("send on closed channel")
+	}
+
+	if c.dataqsiz == 0 { // synchronous channel
+		sg := c.recvq.dequeue()
+		if sg != nil { // found a waiting receiver
+			if raceenabled {
+				racesync(c, sg)
+			}
+			gounlock(&c.lock)
+
+			recvg := sg.g
+			recvg.param = unsafe.Pointer(sg)
+			if sg.elem != nil {
+				memmove(unsafe.Pointer(sg.elem), ep, uintptr(c.elemsize))
+			}
+			if sg.releasetime != 0 {
+				// Yes, this is ugly.  On 64-bit sg.releasetime has type
+				// int.  On 32-bit it has type int64.  There's no easy way
+				// to assign to both types in Go.  At some point we'll
+				// write the Go types directly instead of generating them
+				// via the C types.  At that point, this nastiness goes away.
+				*(*int64)(unsafe.Pointer(&sg.releasetime)) = gocputicks()
+			}
+			goready(recvg)
+			return true
+		}
+
+		if !block {
+			gounlock(&c.lock)
+			return false
+		}
+
+		// no receiver available: block on this channel.
+		gp := getg()
+		mysg := acquireSudog()
+		if t0 != 0 {
+			mysg.releasetime = -1
+		}
+		mysg.elem = (*uint8)(ep)
+		mysg.waitlink = nil
+		gp.waiting = mysg
+		mysg.g = gp
+		mysg.selectdone = nil
+		gp.param = nil
+		c.sendq.enqueue(mysg)
+		goparkunlock(&c.lock, "chan send")
+
+		// someone woke us up.
+		if gp.param == nil {
+			if c.closed == 0 {
+				gothrow("chansend: spurious wakeup")
+			}
+			panic("send on closed channel")
+		}
+		if mysg.releasetime > 0 {
+			goblockevent(int64(mysg.releasetime)-t0, 3)
+		}
+		if mysg != gp.waiting {
+			gothrow("G waiting list is corrupted!")
+		}
+		gp.waiting = nil
+		releaseSudog(mysg)
+		return true
+	}
+
+	// asynchronous channel
+	// wait for some space to write our data
+	var t1 int64
+	for c.qcount >= c.dataqsiz {
+		if !block {
+			gounlock(&c.lock)
+			return false
+		}
+		gp := getg()
+		mysg := acquireSudog()
+		if t0 != 0 {
+			mysg.releasetime = -1
+		}
+		mysg.g = gp
+		mysg.elem = nil
+		mysg.selectdone = nil
+		c.sendq.enqueue(mysg)
+		goparkunlock(&c.lock, "chan send")
+
+		// someone woke us up - try again
+		if mysg.releasetime != 0 {
+			t1 = int64(mysg.releasetime)
+		}
+		releaseSudog(mysg)
+		golock(&c.lock)
+		if c.closed != 0 {
+			gounlock(&c.lock)
+			panic("send on closed channel")
+		}
+	}
+
+	// write our data into the channel buffer
+	if raceenabled {
+		raceacquire(chanbuf(c, c.sendx))
+		racerelease(chanbuf(c, c.sendx))
+	}
+	memmove(chanbuf(c, c.sendx), ep, uintptr(c.elemsize))
+	c.sendx++
+	if c.sendx == c.dataqsiz {
+		c.sendx = 0
+	}
+	c.qcount++
+
+	// wake up a waiting receiver
+	sg := c.recvq.dequeue()
+	if sg != nil {
+		recvg := sg.g
+		gounlock(&c.lock)
+		if sg.releasetime != 0 {
+			*(*int64)(unsafe.Pointer(&sg.releasetime)) = gocputicks()
+		}
+		goready(recvg)
+	} else {
+		gounlock(&c.lock)
+	}
+	if t1 > 0 {
+		goblockevent(t1-t0, 3)
+	}
+	return true
+}
+
+func (q *waitq) enqueue(sgp *sudog) {
+	sgp.link = nil
+	if q.first == nil {
+		q.first = sgp
+		q.last = sgp
+		return
+	}
+	q.last.link = sgp
+	q.last = sgp
+}
+
+func (q *waitq) dequeue() *sudog {
+	for {
+		sgp := q.first
+		if sgp == nil {
+			return nil
+		}
+		q.first = sgp.link
+		if q.last == sgp {
+			q.last = nil
+		}
+
+		// if sgp participates in a select and is already signaled, ignore it
+		if sgp.selectdone != nil {
+			// claim the right to signal
+			if *sgp.selectdone != 0 || !gocas(sgp.selectdone, 0, 1) {
+				continue
+			}
+		}
+
+		return sgp
+	}
+}
+
+func racesync(c *hchan, sg *sudog) {
+	racerelease(chanbuf(c, 0))
+	raceacquireg(sg.g, chanbuf(c, 0))
+	racereleaseg(sg.g, chanbuf(c, 0))
+	raceacquire(chanbuf(c, 0))
+}
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 2ef1c8566e..7f6373dc81 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -18,78 +18,6 @@ static	SudoG*	dequeue(WaitQ*);
 static	void	enqueue(WaitQ*, SudoG*);
 static	void	racesync(Hchan*, SudoG*);
 
-static	Type	hchanType;
-static	String	hchanStr;
-
-void
-runtime·chaninit(void)
-{
-	int32 i, off;
-	byte *mask;
-
-	// Generate (bare minimum) type descriptor for Hchan.
-	hchanType.size = sizeof(Hchan);
-	hchanStr = runtime·gostringnocopy((byte*)"chan");
-	hchanType.string = &hchanStr;
-	// Hchan has only one interesting pointer -- buf.
-	off = offsetof(Hchan, buf)/PtrSize*gcBits;
-	if(off%8)
-		runtime·throw("makechan: unaligned buffer");
-	if(off+8 >= sizeof(hchanType.gc)*8)
-		runtime·throw("makechan: gc mask does not fit");
-	mask = (byte*)hchanType.gc;
-	for(i = 0; i < off/8; i++)
-		mask[i] = (BitsScalar<<2) | (BitsScalar<<6);
-	mask[off/8] = (BitsPointer<<2) | (BitsDead<<6);
-}
-
-static Hchan*
-makechan(ChanType *t, int64 hint)
-{
-	Hchan *c;
-	Type *elem;
-
-	elem = t->elem;
-
-	// compiler checks this but be safe.
-	if(elem->size >= (1<<16))
-		runtime·throw("makechan: invalid channel element type");
-	if((sizeof(*c)%MAXALIGN) != 0 || elem->align > MAXALIGN)
-		runtime·throw("makechan: bad alignment");
-
-	if(hint < 0 || (intgo)hint != hint || (elem->size > 0 && hint > (MaxMem - sizeof(*c)) / elem->size))
-		runtime·panicstring("makechan: size out of range");
-
-	if((elem->kind&KindNoPointers) || hint == 0) {
-		// allocate memory in one call
-		c = (Hchan*)runtime·mallocgc(sizeof(*c) + hint*elem->size, nil, FlagNoScan);
-		if(hint > 0 && elem->size != 0)
-			c->buf = (byte*)(c+1);
-		else
-			c->buf = (byte*)c;  // race detector uses this location for synchronization
-	} else {
-		c = (Hchan*)runtime·cnew(&hchanType);
-		c->buf = runtime·cnewarray(elem, hint);
-	}
-	c->elemsize = elem->size;
-	c->elemtype = elem;
-	c->dataqsiz = hint;
-
-	if(debug)
-		runtime·printf("makechan: chan=%p; elemsize=%D; elemalg=%p; dataqsiz=%D\n",
-			c, (int64)elem->size, elem->alg, (int64)c->dataqsiz);
-
-	return c;
-}
-
-func reflect·makechan(t *ChanType, size uint64) (c *Hchan) {
-	c = makechan(t, size);
-}
-
-func makechan(t *ChanType, size int64) (c *Hchan) {
-	c = makechan(t, size);
-}
-
 /*
  * generic single channel send/recv
  * if the bool pointer is nil,
@@ -375,11 +303,6 @@ closed:
 	return true;
 }
 
-#pragma textflag NOSPLIT
-func chansend1(t *ChanType, c *Hchan, elem *byte) {
-	chansend(t, c, elem, true, runtime·getcallerpc(&t));
-}
-
 #pragma textflag NOSPLIT
 func chanrecv1(t *ChanType, c *Hchan, elem *byte) {
 	chanrecv(t, c, elem, true, nil);
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index 5ac39cab88..5ebbcfd4da 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -5,22 +5,9 @@
 #define	MAXALIGN	8
 
 typedef	struct	WaitQ	WaitQ;
-typedef	struct	SudoG	SudoG;
 typedef	struct	Select	Select;
 typedef	struct	Scase	Scase;
 
-// Known to compiler.
-// Changes here must also be made in src/cmd/gc/select.c's selecttype.
-struct	SudoG
-{
-	G*	g;
-	uint32*	selectdone;
-	SudoG*	link;
-	byte*	elem;		// data element
-	int64	releasetime;
-	int32	nrelease;	// -1 for acquire
-};
-
 struct	WaitQ
 {
 	SudoG*	first;
diff --git a/src/pkg/runtime/chan_test.go b/src/pkg/runtime/chan_test.go
index 9ffdc07dc7..bb0f28655d 100644
--- a/src/pkg/runtime/chan_test.go
+++ b/src/pkg/runtime/chan_test.go
@@ -430,6 +430,38 @@ func TestMultiConsumer(t *testing.T) {
 	}
 }
 
+func TestShrinkStackDuringBlockedSend(t *testing.T) {
+	// make sure that channel operations still work when we are
+	// blocked on a channel send and we shrink the stack.
+	// NOTE: this test probably won't fail unless stack.c:StackDebug
+	// is set to >= 1.
+	const n = 10
+	c := make(chan int)
+	done := make(chan struct{})
+
+	go func() {
+		for i := 0; i < n; i++ {
+			c <- i
+			// use lots of stack, briefly.
+			stackGrowthRecursive(20)
+		}
+		done <- struct{}{}
+	}()
+
+	for i := 0; i < n; i++ {
+		x := <-c
+		if x != i {
+			t.Errorf("bad channel read: want %d, got %d", i, x)
+		}
+		// Waste some time so sender can finish using lots of stack
+		// and block in channel send.
+		time.Sleep(1 * time.Millisecond)
+		// trigger GC which will shrink the stack of the sender.
+		runtime.GC()
+	}
+	<-done
+}
+
 func BenchmarkChanNonblocking(b *testing.B) {
 	myc := make(chan int)
 	b.RunParallel(func(pb *testing.PB) {
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index 3d8d790cdd..57596b2231 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -218,7 +218,10 @@ runtime·blockevent(int64 cycles, int32 skip)
 	if(rate <= 0 || (rate > cycles && runtime·fastrand1()%rate > cycles))
 		return;
 
-	nstk = runtime·callers(skip, stk, nelem(stk));
+	if(g->m->curg == nil || g->m->curg == g)
+		nstk = runtime·callers(skip, stk, nelem(stk));
+	else
+		nstk = runtime·gcallers(g->m->curg, skip, stk, nelem(stk));
 	runtime·lock(&runtime·proflock);
 	b = stkbucket(BProf, 0, stk, nstk, true);
 	b->data.bp.count++;
@@ -226,6 +229,12 @@ runtime·blockevent(int64 cycles, int32 skip)
 	runtime·unlock(&runtime·proflock);
 }
 
+void
+runtime·blockevent_m(void)
+{
+	runtime·blockevent(g->m->scalararg[0] + ((int64)g->m->scalararg[1]<<32), g->m->scalararg[2]);
+}
+
 void
 runtime·iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr))
 {
diff --git a/src/pkg/runtime/pprof/pprof_test.go b/src/pkg/runtime/pprof/pprof_test.go
index aba538e755..9ab211c2da 100644
--- a/src/pkg/runtime/pprof/pprof_test.go
+++ b/src/pkg/runtime/pprof/pprof_test.go
@@ -287,7 +287,7 @@ func TestBlockProfile(t *testing.T) {
 `},
 		{"chan send", blockChanSend, `
 [0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime\.chansend1\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.goc:[0-9]+
+#	0x[0-9,a-f]+	runtime\.chansend1\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.blockChanSend\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 `},
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 6767622846..722f44bb1b 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -158,7 +158,6 @@ runtime·schedinit(void)
 	runtime·symtabinit();
 	runtime·stackinit();
 	runtime·mallocinit();
-	runtime·chaninit();
 	mcommoninit(g->m);
 	
 	// Initialize the itable value for newErrorCString,
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index dcce369a5c..f12e50cbfb 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -63,6 +63,7 @@ typedef	uint8			byte;
 typedef	struct	Func		Func;
 typedef	struct	G		G;
 typedef	struct	Gobuf		Gobuf;
+typedef	struct	SudoG		SudoG;
 typedef	struct	Lock		Lock;
 typedef	struct	M		M;
 typedef	struct	P		P;
@@ -217,6 +218,18 @@ struct	Gobuf
 	uintreg	ret;
 	uintptr	lr;
 };
+// Known to compiler.
+// Changes here must also be made in src/cmd/gc/select.c's selecttype.
+struct	SudoG
+{
+	G*	g;
+	uint32*	selectdone;
+	SudoG*	link;
+	byte*	elem;		// data element
+	int64	releasetime;
+	int32	nrelease;	// -1 for acquire
+	SudoG*	waitlink;	// G.waiting list
+};
 struct	GCStats
 {
 	// the struct must consist of only uint64's,
@@ -285,6 +298,7 @@ struct	G
 	uintptr	sigpc;
 	uintptr	gopc;		// pc of go statement that created this goroutine
 	uintptr	racectx;
+	SudoG   *waiting;	// sudog structures this G is waiting on (that have a valid elem ptr)
 	uintptr	end[];
 };
 
@@ -884,7 +898,6 @@ MCache*	runtime·allocmcache(void);
 void	runtime·freemcache(MCache*);
 void	runtime·mallocinit(void);
 void	runtime·gcinit(void);
-void	runtime·chaninit(void);
 void*	runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void	runtime·runpanic(Panic*);
 uintptr	runtime·getcallersp(void*);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index aeb5fb7211..fc11d98c9b 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -268,8 +268,10 @@ runtime·stackfree(G *gp, void *v, Stktop *top)
 	n = (uintptr)(top+1) - (uintptr)v;
 	if(n & (n-1))
 		runtime·throw("stack not a power of 2");
-	if(StackDebug >= 1)
+	if(StackDebug >= 1) {
 		runtime·printf("stackfree %p %d\n", v, (int32)n);
+		runtime·memclr(v, n); // for testing, clobber stack data
+	}
 	gp->stacksize -= n;
 	if(runtime·debug.efence || StackFromSystem) {
 		if(runtime·debug.efence || StackFaultOnFree)
@@ -753,6 +755,21 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 	}
 }
 
+static void
+adjustsudogs(G *gp, AdjustInfo *adjinfo)
+{
+	SudoG *s;
+	byte *e;
+
+	// the data elements pointed to by a SudoG structure
+	// might be in the stack.
+	for(s = gp->waiting; s != nil; s = s->waitlink) {
+		e = s->elem;
+		if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
+			s->elem = e + adjinfo->delta;
+	}
+}
+
 // Copies the top stack segment of gp to a new stack segment of a
 // different size.  The top segment must contain nframes frames.
 static void
@@ -791,6 +808,7 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	// adjust other miscellaneous things that have pointers into stacks.
 	adjustctxt(gp, &adjinfo);
 	adjustdefers(gp, &adjinfo);
+	adjustsudogs(gp, &adjinfo);
 	
 	// copy the stack (including Stktop) to the new location
 	runtime·memmove(newbase - used, oldbase - used, used);
@@ -1069,6 +1087,8 @@ runtime·shrinkstack(G *gp)
 	if(gp->m != nil && gp->m->libcallsp != 0)
 		return;
 #endif
+	if(StackDebug > 0)
+		runtime·printf("shrinking stack %D->%D\n", (uint64)oldsize, (uint64)newsize);
 	nframes = copyabletopsegment(gp);
 	if(nframes == -1)
 		return;
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index a31589ca86..e7d7c38bf1 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -30,6 +30,18 @@ func racereadrangepc(addr unsafe.Pointer, len int, callpc, pc uintptr)
 //go:noescape
 func racewriterangepc(addr unsafe.Pointer, len int, callpc, pc uintptr)
 
+//go:noescape
+func raceacquire(addr unsafe.Pointer)
+
+//go:noescape
+func racerelease(addr unsafe.Pointer)
+
+//go:noescape
+func raceacquireg(gp *g, addr unsafe.Pointer)
+
+//go:noescape
+func racereleaseg(gp *g, addr unsafe.Pointer)
+
 // Should be a built-in for unsafe.Pointer?
 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
 	return unsafe.Pointer(uintptr(p) + x)

From a6950fe0f9c23fe681109db746038092b5a04728 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sun, 24 Aug 2014 12:41:23 +0400
Subject: [PATCH 178/423] runtime: convert synchronous semaphores to Go

LGTM=rsc
R=golang-codereviews, khr, rsc
CC=golang-codereviews, rlh
https://golang.org/cl/130340043
---
 src/pkg/runtime/sema.go  | 117 +++++++++++++++++++++++++++++++++++++++
 src/pkg/runtime/sema.goc |  90 ------------------------------
 src/pkg/runtime/thunk.s  |  21 +++++++
 src/pkg/sync/runtime.go  |   8 ++-
 4 files changed, 144 insertions(+), 92 deletions(-)
 create mode 100644 src/pkg/runtime/sema.go
 create mode 100644 src/pkg/runtime/thunk.s

diff --git a/src/pkg/runtime/sema.go b/src/pkg/runtime/sema.go
new file mode 100644
index 0000000000..ac855f9d8c
--- /dev/null
+++ b/src/pkg/runtime/sema.go
@@ -0,0 +1,117 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Semaphore implementation exposed to Go.
+// Intended use is provide a sleep and wakeup
+// primitive that can be used in the contended case
+// of other synchronization primitives.
+// Thus it targets the same goal as Linux's futex,
+// but it has much simpler semantics.
+//
+// That is, don't think of these as semaphores.
+// Think of them as a way to implement sleep and wakeup
+// such that every sleep is paired with a single wakeup,
+// even if, due to races, the wakeup happens before the sleep.
+//
+// See Mullender and Cox, ``Semaphores in Plan 9,''
+// http://swtch.com/semaphore.pdf
+
+package runtime
+
+import "unsafe"
+
+// Synchronous semaphore for sync.Cond.
+type syncSema struct {
+	lock lock
+	head *sudog
+	tail *sudog
+}
+
+// Syncsemacquire waits for a pairing syncsemrelease on the same semaphore s.
+func syncsemacquire(s *syncSema) {
+	golock(&s.lock)
+	if s.head != nil && s.head.nrelease > 0 {
+		// Have pending release, consume it.
+		var wake *sudog
+		s.head.nrelease--
+		if s.head.nrelease == 0 {
+			wake = s.head
+			s.head = wake.link
+			if s.head == nil {
+				s.tail = nil
+			}
+		}
+		gounlock(&s.lock)
+		if wake != nil {
+			goready(wake.g)
+		}
+	} else {
+		// Enqueue itself.
+		w := acquireSudog()
+		w.g = getg()
+		w.nrelease = -1
+		w.link = nil
+		w.releasetime = 0
+		t0 := int64(0)
+		if blockprofilerate > 0 {
+			t0 = gocputicks()
+			w.releasetime = -1
+		}
+		if s.tail == nil {
+			s.head = w
+		} else {
+			s.tail.link = w
+		}
+		s.tail = w
+		goparkunlock(&s.lock, "semacquire")
+		if t0 != 0 {
+			goblockevent(int64(w.releasetime)-t0, 2)
+		}
+		releaseSudog(w)
+	}
+}
+
+// Syncsemrelease waits for n pairing syncsemacquire on the same semaphore s.
+func syncsemrelease(s *syncSema, n uint32) {
+	golock(&s.lock)
+	for n > 0 && s.head != nil && s.head.nrelease < 0 {
+		// Have pending acquire, satisfy it.
+		wake := s.head
+		s.head = wake.link
+		if s.head == nil {
+			s.tail = nil
+		}
+		if wake.releasetime != 0 {
+			// TODO: Remove use of unsafe here.
+			releasetimep := (*int64)(unsafe.Pointer(&wake.releasetime))
+			*releasetimep = gocputicks()
+		}
+		goready(wake.g)
+		n--
+	}
+	if n > 0 {
+		// enqueue itself
+		w := acquireSudog()
+		w.g = getg()
+		w.nrelease = int32(n)
+		w.link = nil
+		w.releasetime = 0
+		if s.tail == nil {
+			s.head = w
+		} else {
+			s.tail.link = w
+		}
+		s.tail = w
+		goparkunlock(&s.lock, "semarelease")
+	} else {
+		gounlock(&s.lock)
+	}
+}
+
+func syncsemcheck(sz uintptr) {
+	if sz != unsafe.Sizeof(syncSema{}) {
+		print("runtime: bad syncSema size - sync=", sz, " runtime=", unsafe.Sizeof(syncSema{}), "\n")
+		gothrow("bad syncSema size")
+	}
+}
diff --git a/src/pkg/runtime/sema.goc b/src/pkg/runtime/sema.goc
index 7b1f8f2ed3..7724566a1e 100644
--- a/src/pkg/runtime/sema.goc
+++ b/src/pkg/runtime/sema.goc
@@ -202,93 +202,3 @@ func runtime_Semacquire(addr *uint32) {
 func runtime_Semrelease(addr *uint32) {
 	runtime·semrelease(addr);
 }
-
-typedef struct SyncSema SyncSema;
-struct SyncSema
-{
-	Lock		lock;
-	SemaWaiter*	head;
-	SemaWaiter*	tail;
-};
-
-func runtime_Syncsemcheck(size uintptr) {
-	if(size != sizeof(SyncSema)) {
-		runtime·printf("bad SyncSema size: sync:%D runtime:%D\n", (int64)size, (int64)sizeof(SyncSema));
-		runtime·throw("bad SyncSema size");
-	}
-}
-
-// Syncsemacquire waits for a pairing Syncsemrelease on the same semaphore s.
-func runtime_Syncsemacquire(s *SyncSema) {
-	SemaWaiter w, *wake;
-	int64 t0;
-
-	w.g = g;
-	w.nrelease = -1;
-	w.next = nil;
-	w.releasetime = 0;
-	t0 = 0;
-	if(runtime·blockprofilerate > 0) {
-		t0 = runtime·cputicks();
-		w.releasetime = -1;
-	}
-
-	runtime·lock(&s->lock);
-	if(s->head && s->head->nrelease > 0) {
-		// have pending release, consume it
-		wake = nil;
-		s->head->nrelease--;
-		if(s->head->nrelease == 0) {
-			wake = s->head;
-			s->head = wake->next;
-			if(s->head == nil)
-				s->tail = nil;
-		}
-		runtime·unlock(&s->lock);
-		if(wake)
-			runtime·ready(wake->g);
-	} else {
-		// enqueue itself
-		if(s->tail == nil)
-			s->head = &w;
-		else
-			s->tail->next = &w;
-		s->tail = &w;
-		runtime·parkunlock(&s->lock, runtime·gostringnocopy((byte*)"semacquire"));
-		if(t0)
-			runtime·blockevent(w.releasetime - t0, 2);
-	}
-}
-
-// Syncsemrelease waits for n pairing Syncsemacquire on the same semaphore s.
-func runtime_Syncsemrelease(s *SyncSema, n uint32) {
-	SemaWaiter w, *wake;
-
-	w.g = g;
-	w.nrelease = (int32)n;
-	w.next = nil;
-	w.releasetime = 0;
-
-	runtime·lock(&s->lock);
-	while(w.nrelease > 0 && s->head && s->head->nrelease < 0) {
-		// have pending acquire, satisfy it
-		wake = s->head;
-		s->head = wake->next;
-		if(s->head == nil)
-			s->tail = nil;
-		if(wake->releasetime)
-			wake->releasetime = runtime·cputicks();
-		runtime·ready(wake->g);
-		w.nrelease--;
-	}
-	if(w.nrelease > 0) {
-		// enqueue itself
-		if(s->tail == nil)
-			s->head = &w;
-		else
-			s->tail->next = &w;
-		s->tail = &w;
-		runtime·parkunlock(&s->lock, runtime·gostringnocopy((byte*)"semarelease"));
-	} else
-		runtime·unlock(&s->lock);
-}
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
new file mode 100644
index 0000000000..2a48f5ff23
--- /dev/null
+++ b/src/pkg/runtime/thunk.s
@@ -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 exposes various internal runtime functions to other packages in std lib.
+
+#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
+
+#ifdef GOARCH_arm
+#define JMP B
+#endif
+
+TEXT sync·runtime_Syncsemacquire(SB),NOSPLIT,$0-0
+	JMP	runtime·syncsemacquire(SB)
+
+TEXT sync·runtime_Syncsemrelease(SB),NOSPLIT,$0-0
+	JMP	runtime·syncsemrelease(SB)
+
+TEXT sync·runtime_Syncsemcheck(SB),NOSPLIT,$0-0
+	JMP	runtime·syncsemcheck(SB)
diff --git a/src/pkg/sync/runtime.go b/src/pkg/sync/runtime.go
index 3bf47ea52a..3b866303a9 100644
--- a/src/pkg/sync/runtime.go
+++ b/src/pkg/sync/runtime.go
@@ -19,8 +19,12 @@ func runtime_Semacquire(s *uint32)
 // library and should not be used directly.
 func runtime_Semrelease(s *uint32)
 
-// Opaque representation of SyncSema in runtime/sema.goc.
-type syncSema [3]uintptr
+// Approximation of syncSema in runtime/sema.go.
+type syncSema struct {
+	lock uintptr
+	head unsafe.Pointer
+	tail unsafe.Pointer
+}
 
 // Syncsemacquire waits for a pairing Syncsemrelease on the same semaphore s.
 func runtime_Syncsemacquire(s *syncSema)

From 22af2b8ee0194f952262a63e69ef1e9c5a638ac8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 24 Aug 2014 14:04:10 -0400
Subject: [PATCH 179/423] runtime: fix arm build

TBR=dvyukov
CC=golang-codereviews
https://golang.org/cl/131150043
---
 src/pkg/runtime/asm_arm.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 4e46767223..07b99262bb 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -652,8 +652,8 @@ TEXT runtime·abort(SB),NOSPLIT,$-4-0
 	MOVW	(R0), R1
 
 TEXT runtime·gocputicks(SB),NOSPLIT,$4-8
-	ADD     $8, SP, R0
-	MOVW    R0, 0(SP)
+	MOVW	$ret_lo+0(FP), R0
+	MOVW	R0, 4(R13)
 	BL      runtime·cputicks(SB)
 	RET
 

From cbf351a0f29338ed2ff307729a1b3acacbb110db Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Sun, 24 Aug 2014 11:33:32 -0700
Subject: [PATCH 180/423] doc/go1.4.txt: go generate

CC=golang-codereviews
https://golang.org/cl/132890043
---
 doc/go1.4.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index b3ba7480d6..8cabeb4eb6 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -10,6 +10,7 @@ spec: permit for range x (CL 104680043)
 cmd/6l, liblink: use pc-relative addressing for all memory references, so that linking Go binaries at high addresses works (CL 125140043). This cuts the maximum size of a Go binary's text+data+bss from 4GB to 2GB.
 cmd/go: import comments (CL 124940043)
 cmd/go: implement "internal" (CL 120600043)
+cmd/go: implement "generate" (CL 125580044)
 
 asm: make textflag.h available outside of cmd/ld (CL 128050043)
 crypto/tls: add support for ALPN (RFC 7301) (CL 108710046)

From 41fc05d02357b8681b7a5adfbaedf315328d309e Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Sun, 24 Aug 2014 11:34:12 -0700
Subject: [PATCH 181/423] cmd/go: add go generate First cut.

Works well enough to support yacc via
        https://golang.org/cl/125620044.

LGTM=alex.brainman, rsc
R=rsc, alex.brainman
CC=golang-codereviews
https://golang.org/cl/125580044
---
 src/cmd/go/doc.go                     |  93 ++++++-
 src/cmd/go/generate.go                | 340 ++++++++++++++++++++++++++
 src/cmd/go/main.go                    |   1 +
 src/cmd/go/test.bash                  |  27 ++
 src/cmd/go/testdata/generate/test1.go |  13 +
 src/cmd/go/testdata/generate/test2.go |  10 +
 src/cmd/go/testdata/generate/test3.go |   9 +
 7 files changed, 491 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/go/generate.go
 create mode 100644 src/cmd/go/testdata/generate/test1.go
 create mode 100644 src/cmd/go/testdata/generate/test2.go
 create mode 100644 src/cmd/go/testdata/generate/test3.go

diff --git a/src/cmd/go/doc.go b/src/cmd/go/doc.go
index 4778048b52..19fe5cd3ef 100644
--- a/src/cmd/go/doc.go
+++ b/src/cmd/go/doc.go
@@ -19,6 +19,7 @@ The commands are:
     env         print Go environment information
     fix         run go tool fix on packages
     fmt         run gofmt on package sources
+    generate    generate Go files by processing source
     get         download and install packages and dependencies
     install     compile and install packages and dependencies
     list        list packages
@@ -219,6 +220,94 @@ To run gofmt with specific options, run gofmt itself.
 See also: go fix, go vet.
 
 
+Generate Go files by processing source
+
+Usage:
+
+	go generate [-run regexp] [file.go... | packages]
+
+Generate runs commands described by directives within existing
+files. Those commands can run any process but the intent is to
+create or update Go source files, for instance by running yacc.
+
+Go generate is never run automatically by go build, go get, go test,
+and so on. It must be run explicitly.
+
+Directives are written as a whole-line comment of the form
+
+	//go:generate command argument...
+
+(note: no space in "//go") where command is the generator to be
+run, corresponding to an executable file that can be run locally.
+It must either be in the shell path (gofmt), a fully qualified path
+(/usr/you/bin/mytool), or a command alias, described below.
+
+The arguments are space-separated tokens or double-quoted strings
+passed to the generator as individual arguments when it is run.
+
+Quoted strings use Go syntax and are evaluated before execution; a
+quoted string appears a single argument to the generator.
+
+Go generate sets several variables when it runs the generator:
+
+	$GOFILE
+		The base name of the file.
+	$GOPACKAGE
+		The name of the package of the file containing the directive.
+
+Other than variable substition and quoted-string evaluation, no
+special processing such as "globbing" is performed on the command
+line.
+
+As a last step before running the command, any invocations of any
+environment variables with alphanumeric names, such as $GOFILE or
+$HOME, are expanded throughout the command line. The syntax for
+variable expansion is $NAME on all operating systems.  Due to the
+order of evaluation, variables are expanded even inside quoted
+strings. If the variable NAME is not set, $NAME expands to the
+empty string.
+
+A directive of the form,
+
+	//go:generate -command xxx args...
+
+specifies, for the remainder of this source file only, that the
+string xxx represents the command identified by the arguments. This
+can be used to create aliases or to handle multiword generators.
+For example,
+
+	//go:generate -command yacc go tool yacc
+
+specifies that the command "yacc" represents the generator
+"go tool yacc".
+
+Generate processes packages in the order given on the command line,
+one at a time. If the command line lists .go files, they are treated
+as a single package. Within a package, generate processes the
+source files in a package in file name order, one at a time. Within
+a source file, generate runs generators in the order they appear
+in the file, one at a time.
+
+If any generator returns an error exit status, "go generate" skips
+all further processing for that package.
+
+The generator is run in the package's source directory.
+
+Go generate accepts one specific flag:
+
+	-run=""
+		if non-empty, specifies a regular expression to
+		select directives whose command matches the expression.
+
+It also accepts the standard build flags -v, -n, and -x.
+The -v flag prints the names of packages and files as they are
+processed.
+The -n flag prints commands that would be executed.
+The -x flag prints commands as they are executed.
+
+For more about specifying packages, see 'go help packages'.
+
+
 Download and install packages and dependencies
 
 Usage:
@@ -750,10 +839,10 @@ will result in the following request(s):
 
 If that page contains the meta tag
 
-	<meta name="go-import" content="example.org git https://code.example/r/p/exproj">
+	<meta name="go-import" content="example.org git https://code.org/r/p/exproj">
 
 the go tool will verify that https://example.org/?go-get=1 contains the
-same meta tag and then git clone https://code.example/r/p/exproj into
+same meta tag and then git clone https://code.org/r/p/exproj into
 GOPATH/src/example.org.
 
 New downloaded packages are written to the first directory
diff --git a/src/cmd/go/generate.go b/src/cmd/go/generate.go
new file mode 100644
index 0000000000..34b10314d2
--- /dev/null
+++ b/src/cmd/go/generate.go
@@ -0,0 +1,340 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+var cmdGenerate = &Command{
+	Run:       runGenerate,
+	UsageLine: "generate [-run regexp] [file.go... | packages]",
+	Short:     "generate Go files by processing source",
+	Long: `
+Generate runs commands described by directives within existing
+files. Those commands can run any process but the intent is to
+create or update Go source files, for instance by running yacc.
+
+Go generate is never run automatically by go build, go get, go test,
+and so on. It must be run explicitly.
+
+Directives are written as a whole-line comment of the form
+
+	//go:generate command argument...
+
+(note: no space in "//go") where command is the generator to be
+run, corresponding to an executable file that can be run locally.
+It must either be in the shell path (gofmt), a fully qualified path
+(/usr/you/bin/mytool), or a command alias, described below.
+
+The arguments are space-separated tokens or double-quoted strings
+passed to the generator as individual arguments when it is run.
+
+Quoted strings use Go syntax and are evaluated before execution; a
+quoted string appears a single argument to the generator.
+
+Go generate sets several variables when it runs the generator:
+
+	$GOFILE
+		The base name of the file.
+	$GOPACKAGE
+		The name of the package of the file containing the directive.
+
+Other than variable substition and quoted-string evaluation, no
+special processing such as "globbing" is performed on the command
+line.
+
+As a last step before running the command, any invocations of any
+environment variables with alphanumeric names, such as $GOFILE or
+$HOME, are expanded throughout the command line. The syntax for
+variable expansion is $NAME on all operating systems.  Due to the
+order of evaluation, variables are expanded even inside quoted
+strings. If the variable NAME is not set, $NAME expands to the
+empty string.
+
+A directive of the form,
+
+	//go:generate -command xxx args...
+
+specifies, for the remainder of this source file only, that the
+string xxx represents the command identified by the arguments. This
+can be used to create aliases or to handle multiword generators.
+For example,
+
+	//go:generate -command yacc go tool yacc
+
+specifies that the command "yacc" represents the generator
+"go tool yacc".
+
+Generate processes packages in the order given on the command line,
+one at a time. If the command line lists .go files, they are treated
+as a single package. Within a package, generate processes the
+source files in a package in file name order, one at a time. Within
+a source file, generate runs generators in the order they appear
+in the file, one at a time.
+
+If any generator returns an error exit status, "go generate" skips
+all further processing for that package.
+
+The generator is run in the package's source directory.
+
+Go generate accepts one specific flag:
+
+	-run=""
+		if non-empty, specifies a regular expression to
+		select directives whose command matches the expression.
+
+It also accepts the standard build flags -v, -n, and -x.
+The -v flag prints the names of packages and files as they are
+processed.
+The -n flag prints commands that would be executed.
+The -x flag prints commands as they are executed.
+
+For more about specifying packages, see 'go help packages'.
+	`,
+}
+
+var generateRunFlag string // generate -run flag
+
+func init() {
+	addBuildFlags(cmdGenerate)
+	cmdGenerate.Flag.StringVar(&generateRunFlag, "run", "", "")
+}
+
+func runGenerate(cmd *Command, args []string) {
+	// Even if the arguments are .go files, this loop suffices.
+	for _, pkg := range packages(args) {
+		for _, file := range pkg.gofiles {
+			if !generate(pkg.Name, file) {
+				break
+			}
+		}
+	}
+}
+
+// generate runs the generation directives for a single file.
+func generate(pkg, absFile string) bool {
+	fd, err := os.Open(absFile)
+	if err != nil {
+		log.Fatalf("generate: %s", err)
+	}
+	defer fd.Close()
+	g := &Generator{
+		r:        fd,
+		path:     absFile,
+		pkg:      pkg,
+		commands: make(map[string][]string),
+	}
+	return g.run()
+}
+
+// A Generator represents the state of a single Go source file
+// being scanned for generator commands.
+type Generator struct {
+	r        io.Reader
+	path     string // full rooted path name.
+	dir      string // full rooted directory of file.
+	file     string // base name of file.
+	pkg      string
+	commands map[string][]string
+	lineNum  int
+}
+
+// run runs the generators in the current file.
+func (g *Generator) run() (ok bool) {
+	// Processing below here calls g.errorf on failure, which does panic(stop).
+	// If we encouter an error, we abort the package.
+	defer func() {
+		e := recover()
+		if e != nil {
+			ok = false
+			if e != stop {
+				panic(e)
+			}
+		}
+	}()
+	g.dir, g.file = filepath.Split(g.path)
+	g.dir = filepath.Clean(g.dir) // No final separator please.
+	if buildV {
+		fmt.Fprintf(os.Stderr, "%s\n", shortPath(g.path))
+	}
+
+	s := bufio.NewScanner(g.r)
+	for s.Scan() {
+		g.lineNum++
+		if !bytes.HasPrefix(s.Bytes(), []byte("//go:generate ")) && !bytes.HasPrefix(s.Bytes(), []byte("//go:generate\t")) {
+			continue
+		}
+		words := g.split(s.Text())
+		if len(words) == 0 {
+			g.errorf("no arguments to directive")
+		}
+		if words[0] == "-command" {
+			g.setShorthand(words)
+			continue
+		}
+		// Run the command line.
+		if buildN || buildX {
+			fmt.Fprintf(os.Stderr, "%s\n", strings.Join(words, " "))
+		}
+		if buildN {
+			continue
+		}
+		g.exec(words)
+	}
+	if s.Err() != nil {
+		g.errorf("error reading %s: %s", shortPath(g.path), s.Err())
+	}
+	return true
+}
+
+// split breaks the line into words, evaluating quoted
+// strings and evaluating environment variables.
+// The initial //go:generate element is dropped.
+func (g *Generator) split(line string) []string {
+	// Parse line, obeying quoted strings.
+	var words []string
+	line = line[len("//go:generate "):]
+	// One (possibly quoted) word per iteration.
+Words:
+	for {
+		line = strings.TrimLeft(line, " \t")
+		if len(line) == 0 {
+			break
+		}
+		if line[0] == '"' {
+			for i := 1; i < len(line); i++ {
+				c := line[i] // Only looking for ASCII so this is OK.
+				switch c {
+				case '\\':
+					if i+1 == len(line) {
+						g.errorf("bad backslash")
+					}
+					i++ // Absorb next byte (If it's a multibyte we'll get an error in Unquote).
+				case '"':
+					word, err := strconv.Unquote(line[0 : i+1])
+					if err != nil {
+						g.errorf("bad quoted string")
+					}
+					words = append(words, word)
+					line = line[i+1:]
+					// Check the next character is space or end of line.
+					if len(line) > 0 && line[0] != ' ' && line[0] != '\t' {
+						g.errorf("expect space after quoted argument")
+					}
+					continue Words
+				}
+			}
+			g.errorf("mismatched quoted string")
+		}
+		i := strings.IndexAny(line, " \t")
+		if i < 0 {
+			i = len(line)
+		}
+		words = append(words, line[0:i])
+		line = line[i:]
+	}
+	// Substitute command if required.
+	if len(words) > 0 && g.commands[words[0]] != nil {
+		// Replace 0th word by command substitution.
+		words = append(g.commands[words[0]], words[1:]...)
+	}
+	// Substitute environment variables.
+	for i, word := range words {
+		words[i] = g.expandEnv(word)
+	}
+	return 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.
+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...))
+	panic(stop)
+}
+
+// expandEnv expands any $XXX invocations in word.
+func (g *Generator) expandEnv(word string) string {
+	if !strings.ContainsRune(word, '$') {
+		return word
+	}
+	var buf bytes.Buffer
+	var w int
+	var r rune
+	for i := 0; i < len(word); i += w {
+		r, w = utf8.DecodeRuneInString(word[i:])
+		if r != '$' {
+			buf.WriteRune(r)
+			continue
+		}
+		w += g.identLength(word[i+w:])
+		envVar := word[i+1 : i+w]
+		var sub string
+		switch envVar {
+		case "GOFILE":
+			sub = g.file
+		case "GOPACKAGE":
+			sub = g.pkg
+		default:
+			sub = os.Getenv(envVar)
+		}
+		buf.WriteString(sub)
+	}
+	return buf.String()
+}
+
+// identLength returns the length of the identifier beginning the string.
+func (g *Generator) identLength(word string) int {
+	for i, r := range word {
+		if r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) {
+			continue
+		}
+		return i
+	}
+	return len(word)
+}
+
+// setShorthand installs a new shorthand as defined by a -command directive.
+func (g *Generator) setShorthand(words []string) {
+	// Create command shorthand.
+	if len(words) == 1 {
+		g.errorf("no command specified for -command")
+	}
+	command := words[1]
+	if g.commands[command] != nil {
+		g.errorf("command %q defined multiply defined", command)
+	}
+	g.commands[command] = words[2:len(words):len(words)] // force later append to make copy
+}
+
+// exec runs the command specified by the argument. The first word is
+// the command name itself.
+func (g *Generator) exec(words []string) {
+	cmd := exec.Command(words[0], words[1:]...)
+	// Standard in and out of generator should be the usual.
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	// Run the command in the package directory.
+	cmd.Dir = g.dir
+	cmd.Env = mergeEnvLists([]string{"GOFILE=" + g.file, "GOPACKAGE=" + g.pkg}, os.Environ())
+	err := cmd.Run()
+	if err != nil {
+		g.errorf("running %q: %s", words[0], err)
+	}
+}
diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go
index 5b1194aaa3..eb69606def 100644
--- a/src/cmd/go/main.go
+++ b/src/cmd/go/main.go
@@ -79,6 +79,7 @@ var commands = []*Command{
 	cmdEnv,
 	cmdFix,
 	cmdFmt,
+	cmdGenerate,
 	cmdGet,
 	cmdInstall,
 	cmdList,
diff --git a/src/cmd/go/test.bash b/src/cmd/go/test.bash
index 2bb929fb03..24640e2723 100755
--- a/src/cmd/go/test.bash
+++ b/src/cmd/go/test.bash
@@ -878,6 +878,33 @@ elif ! grep 'File with non-runnable example was built.' testdata/std.out > /dev/
 	ok=false
 fi
 
+TEST 'go generate handles simple command'
+if ! ./testgo generate ./testdata/generate/test1.go > testdata/std.out; then
+	echo "go test ./testdata/generate/test1.go failed to run"
+	ok=false
+elif ! grep 'Success' testdata/std.out > /dev/null; then
+	echo "go test ./testdata/generate/test1.go generated wrong output"
+	ok=false
+fi
+
+TEST 'go generate handles command alias'
+if ! ./testgo generate ./testdata/generate/test2.go > testdata/std.out; then
+	echo "go test ./testdata/generate/test2.go failed to run"
+	ok=false
+elif ! grep 'Now is the time for all good men' testdata/std.out > /dev/null; then
+	echo "go test ./testdata/generate/test2.go generated wrong output"
+	ok=false
+fi
+
+TEST 'go generate variable substitution'
+if ! ./testgo generate ./testdata/generate/test3.go > testdata/std.out; then
+	echo "go test ./testdata/generate/test3.go failed to run"
+	ok=false
+elif ! grep "$GOARCH test3.go p xyzp/test3.go/123" testdata/std.out > /dev/null; then
+	echo "go test ./testdata/generate/test3.go generated wrong output"
+	ok=false
+fi
+
 # clean up
 if $started; then stop; fi
 rm -rf testdata/bin testdata/bin1
diff --git a/src/cmd/go/testdata/generate/test1.go b/src/cmd/go/testdata/generate/test1.go
new file mode 100644
index 0000000000..1f05734f04
--- /dev/null
+++ b/src/cmd/go/testdata/generate/test1.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.
+
+// Simple test for go generate.
+
+// We include a build tag that go generate should ignore.
+
+// +build ignore
+
+//go:generate echo Success
+
+package p
diff --git a/src/cmd/go/testdata/generate/test2.go b/src/cmd/go/testdata/generate/test2.go
new file mode 100644
index 0000000000..ef1a3d9515
--- /dev/null
+++ b/src/cmd/go/testdata/generate/test2.go
@@ -0,0 +1,10 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that go generate handles command aliases.
+
+//go:generate -command run echo Now is the time
+//go:generate run for all good men
+
+package p
diff --git a/src/cmd/go/testdata/generate/test3.go b/src/cmd/go/testdata/generate/test3.go
new file mode 100644
index 0000000000..41ffb7ea87
--- /dev/null
+++ b/src/cmd/go/testdata/generate/test3.go
@@ -0,0 +1,9 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test go generate variable substitution.
+
+//go:generate echo $GOARCH $GOFILE $GOPACKAGE xyz$GOPACKAGE/$GOFILE/123
+
+package p

From 7dc25960b470fa34845d2c1257a9113a9133d7a4 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Sun, 24 Aug 2014 11:34:45 -0700
Subject: [PATCH 182/423] cmd/yacc: remove Makefile and build expr using go
 generate It now serves as an example for go generate as well as for yacc.

NOTE: Depends on go generate, which is not yet checked in.
This is a proof of concept of the approach.
That is https://golang.org/cl/125580044.

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/125620044
---
 src/cmd/yacc/Makefile          | 12 ------------
 src/cmd/yacc/expr/README       | 20 ++++++++++++++++++++
 src/cmd/yacc/{ => expr}/expr.y |  5 -----
 src/cmd/yacc/expr/main.go      | 15 +++++++++++++++
 4 files changed, 35 insertions(+), 17 deletions(-)
 delete mode 100644 src/cmd/yacc/Makefile
 create mode 100644 src/cmd/yacc/expr/README
 rename src/cmd/yacc/{ => expr}/expr.y (96%)
 create mode 100644 src/cmd/yacc/expr/main.go

diff --git a/src/cmd/yacc/Makefile b/src/cmd/yacc/Makefile
deleted file mode 100644
index f8c8169bd1..0000000000
--- a/src/cmd/yacc/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-# Copyright 2009 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-TARG=expr$(shell go env GOEXE)
-
-$(TARG): yacc.go expr.y
-	go run yacc.go -p expr expr.y
-	go build -o $(TARG) y.go
-
-clean:
-	rm -f y.go y.output $(TARG)
diff --git a/src/cmd/yacc/expr/README b/src/cmd/yacc/expr/README
new file mode 100644
index 0000000000..302ef57a7d
--- /dev/null
+++ b/src/cmd/yacc/expr/README
@@ -0,0 +1,20 @@
+This directory contains a simple program demonstrating how to use
+the Go version of yacc.
+
+To build it:
+
+	$ go generate
+	$ go build
+
+or
+
+	$ go generate
+	$ go run expr.go
+
+The file main.go contains the "go generate" command to run yacc to
+create expr.go from expr.y. It also has the package doc comment,
+as godoc will not scan the .y file.
+
+The actual implementation is in expr.y.
+
+The program is not installed in the binary distributions of Go.
diff --git a/src/cmd/yacc/expr.y b/src/cmd/yacc/expr/expr.y
similarity index 96%
rename from src/cmd/yacc/expr.y
rename to src/cmd/yacc/expr/expr.y
index 77e9259dae..09451949ff 100644
--- a/src/cmd/yacc/expr.y
+++ b/src/cmd/yacc/expr/expr.y
@@ -11,11 +11,6 @@
 
 %{
 
-// This tag will be copied to the generated file to prevent that file
-// confusing a future build.
-
-// +build ignore
-
 package main
 
 import (
diff --git a/src/cmd/yacc/expr/main.go b/src/cmd/yacc/expr/main.go
new file mode 100644
index 0000000000..8d5b6911f0
--- /dev/null
+++ b/src/cmd/yacc/expr/main.go
@@ -0,0 +1,15 @@
+// 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 holds the go generate command to run yacc on the grammar in expr.y.
+// To build expr:
+//	% go generate
+//	% go build
+
+//go:generate -command yacc go tool yacc
+//go:generate yacc -o expr.go -p "expr" expr.y
+
+// Expr is a simple expression evaluator that serves as a working example of
+// how to use Go's yacc implemenation.
+package main

From 6c67dd90f7734f86f0118005930f2520ef08392d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 24 Aug 2014 20:28:29 -0400
Subject: [PATCH 183/423] runtime: remove some overuse of
 uintptr/unsafe.Pointer

Now 'go vet runtime' only shows:

        malloc.go:200: possible misuse of unsafe.Pointer
        malloc.go:214: possible misuse of unsafe.Pointer
        malloc.go:250: possible misuse of unsafe.Pointer
        stubs.go:167: possible misuse of unsafe.Pointer

Those are all unavoidable.

LGTM=josharian
R=golang-codereviews, dvyukov, josharian
CC=dave, golang-codereviews
https://golang.org/cl/135730043
---
 src/pkg/runtime/error.go  |  2 +-
 src/pkg/runtime/string.go |  4 +--
 src/pkg/runtime/stubs.go  |  3 +-
 src/pkg/runtime/symtab.c  | 26 +++++++++-----
 src/pkg/runtime/symtab.go | 71 ++++++++++++++++++---------------------
 5 files changed, 55 insertions(+), 51 deletions(-)

diff --git a/src/pkg/runtime/error.go b/src/pkg/runtime/error.go
index f379fc443a..0fe882d0fa 100644
--- a/src/pkg/runtime/error.go
+++ b/src/pkg/runtime/error.go
@@ -85,7 +85,7 @@ type errorCString struct{ cstr unsafe.Pointer }
 func (e errorCString) RuntimeError() {}
 
 func (e errorCString) Error() string {
-	return "runtime error: " + cstringToGo(uintptr(e.cstr))
+	return "runtime error: " + cstringToGo(e.cstr)
 }
 
 // For calling from C.
diff --git a/src/pkg/runtime/string.go b/src/pkg/runtime/string.go
index c5b0917482..983125f0ce 100644
--- a/src/pkg/runtime/string.go
+++ b/src/pkg/runtime/string.go
@@ -148,10 +148,10 @@ type stringStruct struct {
 	len int
 }
 
-func cstringToGo(str uintptr) (s string) {
+func cstringToGo(str unsafe.Pointer) (s string) {
 	i := 0
 	for ; ; i++ {
-		if *(*byte)(unsafe.Pointer(str + uintptr(i))) == 0 {
+		if *(*byte)(unsafe.Pointer(uintptr(str) + uintptr(i))) == 0 {
 			break
 		}
 	}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index e7d7c38bf1..76f6faf53a 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -49,7 +49,8 @@ func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
 
 // n must be a power of 2
 func roundup(p unsafe.Pointer, n uintptr) unsafe.Pointer {
-	return unsafe.Pointer((uintptr(p) + n - 1) &^ (n - 1))
+	delta := -uintptr(p) & (n - 1)
+	return unsafe.Pointer(uintptr(p) + delta)
 }
 
 // in stubs.goc
diff --git a/src/pkg/runtime/symtab.c b/src/pkg/runtime/symtab.c
index fd0d3c1928..613aa942ed 100644
--- a/src/pkg/runtime/symtab.c
+++ b/src/pkg/runtime/symtab.c
@@ -20,15 +20,16 @@ struct Ftab
 };
 
 extern byte pclntab[];
+extern byte epclntab[];
 
 static Ftab *ftab;
-extern uintptr runtime·nftab;
+static uintptr runtime·nftab;
 static uint32 *filetab;
-extern uint32 runtime·nfiletab;
+static uint32 runtime·nfiletab;
 
-extern uintptr runtime·pclntab;
-extern uintptr runtime·ftab0;
-extern uintptr runtime·filetab0;
+extern Slice runtime·pclntab;
+extern Slice runtime·ftabs;
+extern Slice runtime·filetab;
 extern uint32 runtime·pcquantum;
 
 static String end = { (uint8*)"end", 3 };
@@ -65,9 +66,18 @@ runtime·symtabinit(void)
 	runtime·nfiletab = filetab[0];
 
 	runtime·pcquantum = PCQuantum;
-	runtime·pclntab = (uintptr)pclntab;
-	runtime·ftab0 = (uintptr)ftab;
-	runtime·filetab0 = (uintptr)filetab;
+
+	runtime·pclntab.array = (byte*)pclntab;
+	runtime·pclntab.len = (byte*)epclntab - (byte*)pclntab;
+	runtime·pclntab.cap = runtime·pclntab.len;
+
+	runtime·ftabs.array = (byte*)ftab;
+	runtime·ftabs.len = runtime·nftab+1;
+	runtime·ftabs.cap = runtime·ftabs.len;
+
+	runtime·filetab.array = (byte*)filetab;
+	runtime·filetab.len = filetab[0];
+	runtime·filetab.cap = runtime·filetab.len;
 }
 
 static uint32
diff --git a/src/pkg/runtime/symtab.go b/src/pkg/runtime/symtab.go
index 1d2033f10f..e8f45cfc01 100644
--- a/src/pkg/runtime/symtab.go
+++ b/src/pkg/runtime/symtab.go
@@ -9,22 +9,22 @@ import "unsafe"
 // FuncForPC returns a *Func describing the function that contains the
 // given program counter address, or else nil.
 func FuncForPC(pc uintptr) *Func {
-	if nftab == 0 {
+	if len(ftabs) == 0 {
 		return nil
 	}
 
-	if pc < ftabi(0).entry || pc >= ftabi(nftab).entry {
+	if pc < ftabs[0].entry || pc >= ftabs[len(ftabs)-1].entry {
 		return nil
 	}
 
 	// binary search to find func with entry <= pc.
-	lo := uintptr(0)
-	nf := nftab
+	lo := 0
+	nf := len(ftabs) - 1 // last entry is sentinel
 	for nf > 0 {
 		n := nf / 2
-		f := ftabi(lo + n)
-		if f.entry <= pc && pc < ftabi(lo+n+1).entry {
-			return (*Func)(unsafe.Pointer(pclntab + f.funcoff))
+		f := &ftabs[lo+n]
+		if f.entry <= pc && pc < ftabs[lo+n+1].entry {
+			return (*Func)(unsafe.Pointer(&pclntab[f.funcoff]))
 		} else if pc < f.entry {
 			nf = n
 		} else {
@@ -39,7 +39,7 @@ func FuncForPC(pc uintptr) *Func {
 
 // Name returns the name of the function.
 func (f *Func) Name() string {
-	return cstringToGo(pclntab + uintptr(f.nameoff))
+	return cstringToGo(unsafe.Pointer(&pclntab[f.nameoff]))
 }
 
 // Entry returns the entry address of the function.
@@ -52,15 +52,15 @@ func (f *Func) Entry() uintptr {
 // The result will not be accurate if pc is not a program
 // counter within f.
 func (f *Func) FileLine(pc uintptr) (file string, line int) {
-	fileno := f.pcvalue(f.pcfile, pc)
-	if fileno == -1 || fileno >= int32(nfiletab) {
+	fileno := int(f.pcvalue(f.pcfile, pc))
+	if fileno == -1 || fileno >= len(filetab) {
 		return "?", 0
 	}
 	line = int(f.pcvalue(f.pcln, pc))
 	if line == -1 {
 		return "?", 0
 	}
-	file = cstringToGo(pclntab + uintptr(filetabi(uintptr(fileno))))
+	file = cstringToGo(unsafe.Pointer(&pclntab[filetab[fileno]]))
 	return file, line
 }
 
@@ -69,10 +69,15 @@ func (f *Func) pcvalue(off int32, targetpc uintptr) int32 {
 	if off == 0 {
 		return -1
 	}
-	p := pclntab + uintptr(off)
+	p := pclntab[off:]
 	pc := f.entry
 	val := int32(-1)
-	for step(&p, &pc, &val, pc == f.entry) {
+	for {
+		var ok bool
+		p, ok = step(p, &pc, &val, pc == f.entry)
+		if !ok {
+			break
+		}
 		if targetpc < pc {
 			return val
 		}
@@ -81,10 +86,10 @@ func (f *Func) pcvalue(off int32, targetpc uintptr) int32 {
 }
 
 // step advances to the next pc, value pair in the encoded table.
-func step(p *uintptr, pc *uintptr, val *int32, first bool) bool {
-	uvdelta := readvarint(p)
+func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool) {
+	p, uvdelta := readvarint(p)
 	if uvdelta == 0 && !first {
-		return false
+		return nil, false
 	}
 	if uvdelta&1 != 0 {
 		uvdelta = ^(uvdelta >> 1)
@@ -92,36 +97,32 @@ func step(p *uintptr, pc *uintptr, val *int32, first bool) bool {
 		uvdelta >>= 1
 	}
 	vdelta := int32(uvdelta)
-	pcdelta := readvarint(p) * pcquantum
-	*pc += uintptr(pcdelta)
+	p, pcdelta := readvarint(p)
+	*pc += uintptr(pcdelta * pcquantum)
 	*val += vdelta
-	return true
+	return p, true
 }
 
-// readvarint reads a varint from *p and advances *p.
-func readvarint(pp *uintptr) uint32 {
+// readvarint reads a varint from p.
+func readvarint(p []byte) (newp []byte, val uint32) {
 	var v, shift uint32
-	p := *pp
 	for {
-		b := *(*byte)(unsafe.Pointer(p))
-		p++
+		b := p[0]
+		p = p[1:]
 		v |= (uint32(b) & 0x7F) << shift
 		if b&0x80 == 0 {
 			break
 		}
 		shift += 7
 	}
-	*pp = p
-	return v
+	return p, v
 }
 
 // Populated by runtime·symtabinit during bootstrapping. Treat as immutable.
 var (
-	pclntab   uintptr // address of pclntab
-	ftab0     uintptr // address of first ftab entry
-	nftab     uintptr
-	filetab0  uintptr // address of first filetab entry
-	nfiletab  uint32
+	pclntab   []byte
+	ftabs     []ftab
+	filetab   []uint32
 	pcquantum uint32
 )
 
@@ -143,11 +144,3 @@ type ftab struct {
 	entry   uintptr
 	funcoff uintptr
 }
-
-func ftabi(i uintptr) (f ftab) {
-	return *(*ftab)(unsafe.Pointer(ftab0 + i*unsafe.Sizeof(f)))
-}
-
-func filetabi(i uintptr) (f uint32) {
-	return *(*uint32)(unsafe.Pointer(filetab0 + i*unsafe.Sizeof(f)))
-}

From 2a679f8e3a5efc60a7766699faba37e16135eda9 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Sun, 24 Aug 2014 20:31:16 -0400
Subject: [PATCH 184/423] cmd/link: fix testdata generation

Fixes #8494.

LGTM=rsc
R=golang-codereviews, gobot, rsc, evankroske
CC=golang-codereviews
https://golang.org/cl/123040043
---
 src/cmd/link/pclntab_test.go                  |   6 ++++++
 src/cmd/link/testdata/Makefile                |   2 +-
 src/cmd/link/testdata/autosection.6           | Bin 890 -> 850 bytes
 src/cmd/link/testdata/autoweak.6              | Bin 427 -> 387 bytes
 src/cmd/link/testdata/dead.6                  | Bin 1066 -> 836 bytes
 src/cmd/link/testdata/hello.6                 | Bin 273 -> 233 bytes
 src/cmd/link/testdata/layout.6                | Bin 431 -> 391 bytes
 src/cmd/link/testdata/link.hello.darwin.amd64 |  11 ++++-------
 src/cmd/link/testdata/pclntab.6               | Bin 4611 -> 3799 bytes
 9 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/cmd/link/pclntab_test.go b/src/cmd/link/pclntab_test.go
index 5696a0978d..75d432fc5d 100644
--- a/src/cmd/link/pclntab_test.go
+++ b/src/cmd/link/pclntab_test.go
@@ -276,6 +276,12 @@ func checkPCData(t *testing.T, r *SymReader, name string, off, pc, pnum, val int
 // readPCData reads the PCData table offset off
 // to obtain and return the value associated with pc.
 func readPCData(t *testing.T, r *SymReader, name, pcdataname string, pcoff uint32, pc int) (int, bool) {
+	// "If pcsp, pcfile, pcln, or any of the pcdata offsets is zero,
+	// that table is considered missing, and all PCs take value -1."
+	if pcoff == 0 {
+		return -1, true
+	}
+
 	var it PCIter
 	for it.Init(r.p, r.data[pcoff:]); !it.Done; it.Next() {
 		if it.PC <= uint32(pc) && uint32(pc) < it.NextPC {
diff --git a/src/cmd/link/testdata/Makefile b/src/cmd/link/testdata/Makefile
index 3b1b15f731..e9651a03f6 100644
--- a/src/cmd/link/testdata/Makefile
+++ b/src/cmd/link/testdata/Makefile
@@ -9,7 +9,7 @@ ALL=\
 all: $(ALL)
 
 %.6: %.s
-	go tool 6a $*.s
+	GOARCH=amd64 GOOS=darwin go tool 6a -trimpath=$(shell pwd) $*.s
 
 pclntab.s: genpcln.go
 	go run genpcln.go >pclntab.s
diff --git a/src/cmd/link/testdata/autosection.6 b/src/cmd/link/testdata/autosection.6
index bc9d446e1a9f6762a03df806dd8ede7287f1f79b..97e8872bd828a165b9749ed66ca413a170614d46 100644
GIT binary patch
delta 59
zcmeyxc8P6*oOViLiiw4hQBrbpTAD(5YKnqmX}W@enS!B#m63&&p{0V6fuV_lu7SCM
P!9?$5MyZWgmofnW6dn-m

delta 99
zcmcb__KR(ToUVz5xv_z{WwN1(L9#-4YKnqmL6L%?nS!CYm7$rHfrWyRfuV_lu7SCM
zfr9o#&t&y9{m|mnqGJ7`;$;1F{q%hO;-X~z<lGefoXosz{gTw;l9a@fME#9xmofnW
DVrU*Q

diff --git a/src/cmd/link/testdata/autoweak.6 b/src/cmd/link/testdata/autoweak.6
index 636a4d8446743f96cd99991882e9a4d13e41b385..5d74d4e2b56448feed209262e4e3aa8e1eed8674 100644
GIT binary patch
delta 58
zcmZ3@+{`>dPCF$r#l*tMC@DEPElnXjHATU(G+n{KOu^8=%E-dX&{Dz3z|cfN*TCGs
NV4`<2qsYXo*8tvK5K;gD

delta 98
zcmZo>Ud=o~PS?c3+}Oa}GTG3?AXy<iHATU(ph&^cOu^9H%FxWpz(T>uz|cfN*TCGs
zKtX$=XR>;NerR!OQL%neak758etN!saZ$2<a&C%#PG(-Veo1O^NlIc#qW;9S*8l|W
B9hLw9

diff --git a/src/cmd/link/testdata/dead.6 b/src/cmd/link/testdata/dead.6
index bb77aafe864dfd0e9383d0f2d4fb7725158b3cdc..c60b1b6c645942c6c96a07f790eeeebc1e21a354 100644
GIT binary patch
delta 89
zcmZ3*afEGxoOViLiiw4hQBrbpTAD(5YKnqmX}W@enS!B#m63&&p{0V6fuV_lu7SCM
p!9?#8MxKe!Y#Dhbdoj8I$*qh{Kr)WW9Y~&GGGXM|tj^5L2mn-o7Wn`G

delta 318
zcmX@Ywu)ndoUVz5xv_z{WwN1(L9#-4YKnqmL6L%?nS!CYm7$rHfrWyRfuV_lu7SCM
zfr9o#&l2?r{m|mnqGJ7`;$;1F{q%hO;-X~z<lGefoXosz{gTw;l9a@fME!~TY>8I-
f$Aws>lN}kGh*o=q(Vb|uJWM9Us@?3!#LNf)fdOke

diff --git a/src/cmd/link/testdata/hello.6 b/src/cmd/link/testdata/hello.6
index b129dc02999b1282e85bbe0e43ef77ab16ff3abf..67983f1a9f8bfec2d1fac59bcaea3016f3bb3e8c 100644
GIT binary patch
delta 58
zcmbQp^pbIcoOViLiiw4hQBrbpTAD(5YKnqmX}W@enS!B#m63&&p{0V6fuV_lu7SCM
N!9?#8M!t#9v;pns5DWkS

delta 98
zcmaFKIFV_BoUVz5xv_z{WwN1(L9#-4YKnqmL6L%?nS!CYm7$rHfrWyRfuV_lu7SCM
zfr9o#&l2@0{m|mnqGJ7`;$;1F{q%hO;-X~z<lGefoXosz{gTw;l9a@fME!~Tv;iW3
B9Z&!O

diff --git a/src/cmd/link/testdata/layout.6 b/src/cmd/link/testdata/layout.6
index 8cd5bd2cdf0e51890f0bad6b94e43bad60f8895e..db24ef3e55d7386c55da0f1cdbbd105f9a80fa03 100644
GIT binary patch
delta 59
zcmZ3_+|E2fPCF$r#l*tMC@DEPElnXjHATU(G+n{KOu^8=%E-dX&{Dz3z|cfN*TCGs
OV50XPMuEwCjEw;A#1FOr

delta 99
zcmZo?Ue7#1PS?c3+}Oa}GTG3?AXy<iHATU(ph&^cOu^9H%FxWpz(T>uz|cfN*TCGs
zKtX$==N|PK{m|mnqGJ7`;$;1F{q%hO;-X~z<lGefoXosz{gTw;l9a@fME%KZjEw*>
CcO3cv

diff --git a/src/cmd/link/testdata/link.hello.darwin.amd64 b/src/cmd/link/testdata/link.hello.darwin.amd64
index b1f0a93b21..0bd475dd81 100644
--- a/src/cmd/link/testdata/link.hello.darwin.amd64
+++ b/src/cmd/link/testdata/link.hello.darwin.amd64
@@ -6,8 +6,8 @@
 *
 00000060  00 00 00 00 00 00 00 00  19 00 00 00 38 01 00 00  |............8...|
 00000070  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
-00000080  00 10 00 00 00 00 00 00  d6 10 00 00 00 00 00 00  |................|
-00000090  00 00 00 00 00 00 00 00  d6 10 00 00 00 00 00 00  |................|
+00000080  00 10 00 00 00 00 00 00  b0 10 00 00 00 00 00 00  |................|
+00000090  00 00 00 00 00 00 00 00  b0 10 00 00 00 00 00 00  |................|
 000000a0  07 00 00 00 05 00 00 00  03 00 00 00 00 00 00 00  |................|
 000000b0  5f 5f 74 65 78 74 00 00  00 00 00 00 00 00 00 00  |__text..........|
 000000c0  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
@@ -21,7 +21,7 @@
 *
 00000150  5f 5f 66 75 6e 63 74 61  62 00 00 00 00 00 00 00  |__functab.......|
 00000160  5f 5f 54 45 58 54 00 00  00 00 00 00 00 00 00 00  |__TEXT..........|
-00000170  20 20 00 00 00 00 00 00  b6 00 00 00 00 00 00 00  |  ..............|
+00000170  20 20 00 00 00 00 00 00  90 00 00 00 00 00 00 00  |  ..............|
 00000180  20 10 00 00 00 00 00 00  00 00 00 00 00 00 00 00  | ...............|
 *
 000001a0  19 00 00 00 98 00 00 00  5f 5f 44 41 54 41 00 00  |........__DATA..|
@@ -48,10 +48,7 @@
 00001070  00 00 00 00 00 00 00 00  5f 72 74 30 5f 67 6f 00  |........_rt0_go.|
 00001080  02 20 00 04 20 00 06 05  02 05 02 05 02 05 02 02  |. .. ...........|
 00001090  02 02 02 05 02 02 02 01  00 00 00 00 00 00 00 00  |................|
-000010a0  02 00 00 00 88 00 00 00  2f 55 73 65 72 73 2f 72  |......../Users/r|
-000010b0  73 63 2f 67 2f 67 6f 2f  73 72 63 2f 63 6d 64 2f  |sc/g/go/src/cmd/|
-000010c0  6c 69 6e 6b 2f 74 65 73  74 64 61 74 61 2f 68 65  |link/testdata/he|
-000010d0  6c 6c 6f 2e 73 00 00 00  00 00 00 00 00 00 00 00  |llo.s...........|
+000010a0  02 00 00 00 88 00 00 00  68 65 6c 6c 6f 2e 73 00  |........hello.s.|
 *
 00002000  68 65 6c 6c 6f 20 77 6f  72 6c 64 0a              |hello world.|
 0000200c
diff --git a/src/cmd/link/testdata/pclntab.6 b/src/cmd/link/testdata/pclntab.6
index 918411ca5b7badc7ceafc04a152edad88ab05d3e..596daa9b57eb4dc09c1b34d099732fd5370fa7f1 100644
GIT binary patch
delta 239
zcmZoxxh^|FPCF$r#l*tMC@DEPElnXjHATU(G+n{KOu^8=%E-dX&{Dz3z|cfN*TCGs
zV59db=E;&QHl|#ec?G2<OnhmXIjIJE#Sn%CjA004Si%@4Ajak?tfkD8c{vU2khO!Q
xK<1di6dS=9rZ5KFKx42utGRSpC*R@sS4K7mZWr7=U~?w(2(~lwP2MHw2>_B;Lx%tW

delta 1074
zcmcaE+pID{PS?c3+}Oa}GTG3?AXy<iHATU(ph&^cOu^9H%FxWpz(T>uz|cfN*TCGs
zKtX$>=P70u4u%HS$-*o)^<ny<#i>Qb`bEXb`sw=V`TE60$@<B;Df&5?dD;3Usl_EJ
zi6x2pnRx}JB}`GoDNf7GNj1<bCPsNZ$Z(K)3*ywnlpB(!+!B{^M@+ARTw{VuJ*M)_
zEi9#=@Vvk>`6s&p&BBvN7s12RjCdb_JZwaoa#LK&>oEfeWITz{WsJ*s?52Za_a75i
zT4`SL<}waBR$y!#V4pmN*Pmvwfipd!Ixq>AT#3vLFy$n~#$-0Wc6B22<>Wp-PXK7p
BbfN$N


From 75b72b1b27dd74ca9a1ebdba22f545233431a99f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 24 Aug 2014 20:31:45 -0400
Subject: [PATCH 185/423] cmd/gc: re-enable IfacePointerOnly

CL 130240043 did this but broke ARM, because
it made newErrorCString start allocating, so we rolled
it back in CL 133810043.

CL 133820043 removed that allocation.

Try again.

Fixes #8405.

LGTM=bradfitz, dave
R=golang-codereviews, bradfitz
CC=dave, golang-codereviews, r
https://golang.org/cl/133830043
---
 src/cmd/gc/subr.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 325614e6bc..081c373a88 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -3808,7 +3808,7 @@ isdirectiface(Type *t)
 	// where the data word can hold a pointer or any
 	// non-pointer value no bigger than a pointer.
 	enum {
-		IfacePointerOnly = 0,
+		IfacePointerOnly = 1,
 	};
 
 	if(IfacePointerOnly) {

From 527ae57e6532f512dce984245c0c474372e7f62b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 24 Aug 2014 21:16:24 -0400
Subject: [PATCH 186/423] cmd/5g, cmd/8g: registerize small structs and arrays

cmd/6g has been doing this for a long time.

Arrays are still problematic on 5g because the addressing
for t[0] where local var t has type [3]uintptr takes the address of t.
That's issue 8125.

Fixes #8123.

LGTM=josharian
R=josharian, dave
CC=golang-codereviews
https://golang.org/cl/102890046
---
 src/cmd/5g/cgen.c | 73 +++++++++++++++++++++++++++++++++++++++++-
 src/cmd/8g/cgen.c | 80 ++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 147 insertions(+), 6 deletions(-)

diff --git a/src/cmd/5g/cgen.c b/src/cmd/5g/cgen.c
index a42e67bafb..a9c597cdc8 100644
--- a/src/cmd/5g/cgen.c
+++ b/src/cmd/5g/cgen.c
@@ -1635,7 +1635,10 @@ int
 componentgen(Node *nr, Node *nl)
 {
 	Node nodl, nodr, tmp;
+	Type *t;
 	int freel, freer;
+	vlong fldcount;
+	vlong loffset, roffset;
 
 	freel = 0;
 	freer = 0;
@@ -1645,8 +1648,33 @@ componentgen(Node *nr, Node *nl)
 		goto no;
 
 	case TARRAY:
-		if(!isslice(nl->type))
+		t = nl->type;
+
+		// Slices are ok.
+		if(isslice(t))
+			break;
+		// Small arrays are ok.
+		if(t->bound > 0 && t->bound <= 3 && !isfat(t->type))
+			break;
+
+		goto no;
+
+	case TSTRUCT:
+		// Small structs with non-fat types are ok.
+		// Zero-sized structs are treated separately elsewhere.
+		fldcount = 0;
+		for(t=nl->type->type; t; t=t->down) {
+			if(isfat(t->type))
+				goto no;
+			if(t->etype != TFIELD)
+				fatal("componentgen: not a TFIELD: %lT", t);
+			fldcount++;
+		}
+		if(fldcount == 0 || fldcount > 4)
 			goto no;
+
+		break;
+
 	case TSTRING:
 	case TINTER:
 		break;
@@ -1674,6 +1702,7 @@ componentgen(Node *nr, Node *nl)
 		freer = 1;
 	}
 
+	
 	// nl and nr are 'cadable' which basically means they are names (variables) now.
 	// If they are the same variable, don't generate any code, because the
 	// VARDEF we generate will mark the old value as dead incorrectly.
@@ -1683,8 +1712,25 @@ componentgen(Node *nr, Node *nl)
 
 	switch(nl->type->etype) {
 	case TARRAY:
+		// componentgen for arrays.
 		if(nl->op == ONAME)
 			gvardef(nl);
+		t = nl->type;
+		if(!isslice(t)) {
+			nodl.type = t->type;
+			nodr.type = nodl.type;
+			for(fldcount=0; fldcount < t->bound; fldcount++) {
+				if(nr == N)
+					clearslim(&nodl);
+				else
+					gmove(&nodr, &nodl);
+				nodl.xoffset += t->type->width;
+				nodr.xoffset += t->type->width;
+			}
+			goto yes;
+		}
+
+		// componentgen for slices.
 		nodl.xoffset += Array_array;
 		nodl.type = ptrto(nl->type->type);
 
@@ -1759,6 +1805,31 @@ componentgen(Node *nr, Node *nl)
 		gmove(&nodr, &nodl);
 
 		goto yes;
+
+	case TSTRUCT:
+		if(nl->op == ONAME)
+			gvardef(nl);
+		loffset = nodl.xoffset;
+		roffset = nodr.xoffset;
+		// funarg structs may not begin at offset zero.
+		if(nl->type->etype == TSTRUCT && nl->type->funarg && nl->type->type)
+			loffset -= nl->type->type->width;
+		if(nr != N && nr->type->etype == TSTRUCT && nr->type->funarg && nr->type->type)
+			roffset -= nr->type->type->width;
+
+		for(t=nl->type->type; t; t=t->down) {
+			nodl.xoffset = loffset + t->width;
+			nodl.type = t->type;
+
+			if(nr == N)
+				clearslim(&nodl);
+			else {
+				nodr.xoffset = roffset + t->width;
+				nodr.type = nodl.type;
+				gmove(&nodr, &nodl);
+			}
+		}
+		goto yes;
 	}
 
 no:
diff --git a/src/cmd/8g/cgen.c b/src/cmd/8g/cgen.c
index 5988a4328c..bdf728dbbc 100644
--- a/src/cmd/8g/cgen.c
+++ b/src/cmd/8g/cgen.c
@@ -1367,7 +1367,10 @@ int
 componentgen(Node *nr, Node *nl)
 {
 	Node nodl, nodr;
+	Type *t;
 	int freel, freer;
+	vlong fldcount;
+	vlong loffset, roffset;
 
 	freel = 0;
 	freer = 0;
@@ -1377,8 +1380,33 @@ componentgen(Node *nr, Node *nl)
 		goto no;
 
 	case TARRAY:
-		if(!isslice(nl->type))
+		t = nl->type;
+
+		// Slices are ok.
+		if(isslice(t))
+			break;
+		// Small arrays are ok.
+		if(t->bound > 0 && t->bound <= 3 && !isfat(t->type))
+			break;
+
+		goto no;
+
+	case TSTRUCT:
+		// Small structs with non-fat types are ok.
+		// Zero-sized structs are treated separately elsewhere.
+		fldcount = 0;
+		for(t=nl->type->type; t; t=t->down) {
+			if(isfat(t->type))
+				goto no;
+			if(t->etype != TFIELD)
+				fatal("componentgen: not a TFIELD: %lT", t);
+			fldcount++;
+		}
+		if(fldcount == 0 || fldcount > 4)
 			goto no;
+
+		break;
+
 	case TSTRING:
 	case TINTER:
 		break;
@@ -1399,7 +1427,7 @@ componentgen(Node *nr, Node *nl)
 			freer = 1;
 		}
 	}
-
+	
 	// nl and nr are 'cadable' which basically means they are names (variables) now.
 	// If they are the same variable, don't generate any code, because the
 	// VARDEF we generate will mark the old value as dead incorrectly.
@@ -1409,8 +1437,25 @@ componentgen(Node *nr, Node *nl)
 
 	switch(nl->type->etype) {
 	case TARRAY:
+		// componentgen for arrays.
 		if(nl->op == ONAME)
 			gvardef(nl);
+		t = nl->type;
+		if(!isslice(t)) {
+			nodl.type = t->type;
+			nodr.type = nodl.type;
+			for(fldcount=0; fldcount < t->bound; fldcount++) {
+				if(nr == N)
+					clearslim(&nodl);
+				else
+					gmove(&nodr, &nodl);
+				nodl.xoffset += t->type->width;
+				nodr.xoffset += t->type->width;
+			}
+			goto yes;
+		}
+
+		// componentgen for slices.
 		nodl.xoffset += Array_array;
 		nodl.type = ptrto(nl->type->type);
 
@@ -1422,7 +1467,7 @@ componentgen(Node *nr, Node *nl)
 		gmove(&nodr, &nodl);
 
 		nodl.xoffset += Array_nel-Array_array;
-		nodl.type = types[TUINT32];
+		nodl.type = types[simtype[TUINT]];
 
 		if(nr != N) {
 			nodr.xoffset += Array_nel-Array_array;
@@ -1432,7 +1477,7 @@ componentgen(Node *nr, Node *nl)
 		gmove(&nodr, &nodl);
 
 		nodl.xoffset += Array_cap-Array_nel;
-		nodl.type = types[TUINT32];
+		nodl.type = types[simtype[TUINT]];
 
 		if(nr != N) {
 			nodr.xoffset += Array_cap-Array_nel;
@@ -1457,7 +1502,7 @@ componentgen(Node *nr, Node *nl)
 		gmove(&nodr, &nodl);
 
 		nodl.xoffset += Array_nel-Array_array;
-		nodl.type = types[TUINT32];
+		nodl.type = types[simtype[TUINT]];
 
 		if(nr != N) {
 			nodr.xoffset += Array_nel-Array_array;
@@ -1492,6 +1537,31 @@ componentgen(Node *nr, Node *nl)
 		gmove(&nodr, &nodl);
 
 		goto yes;
+
+	case TSTRUCT:
+		if(nl->op == ONAME)
+			gvardef(nl);
+		loffset = nodl.xoffset;
+		roffset = nodr.xoffset;
+		// funarg structs may not begin at offset zero.
+		if(nl->type->etype == TSTRUCT && nl->type->funarg && nl->type->type)
+			loffset -= nl->type->type->width;
+		if(nr != N && nr->type->etype == TSTRUCT && nr->type->funarg && nr->type->type)
+			roffset -= nr->type->type->width;
+
+		for(t=nl->type->type; t; t=t->down) {
+			nodl.xoffset = loffset + t->width;
+			nodl.type = t->type;
+
+			if(nr == N)
+				clearslim(&nodl);
+			else {
+				nodr.xoffset = roffset + t->width;
+				nodr.type = nodl.type;
+				gmove(&nodr, &nodl);
+			}
+		}
+		goto yes;
 	}
 
 no:

From 4af79b6376f8430963470a36f9a6ab1dfe9fdc59 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 24 Aug 2014 21:26:07 -0400
Subject: [PATCH 187/423] cmd/gc: fix build

TBR=dfc
CC=golang-codereviews
https://golang.org/cl/126210047
---
 src/cmd/6g/gg.h | 1 -
 src/cmd/gc/go.h | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/6g/gg.h b/src/cmd/6g/gg.h
index a5da17d61f..27f6c01fee 100644
--- a/src/cmd/6g/gg.h
+++ b/src/cmd/6g/gg.h
@@ -51,7 +51,6 @@ void	allocparams(void);
 void	checklabels(void);
 void	ginscall(Node*, int);
 int	gen_as_init(Node*);
-void	clearslim(Node*);
 
 /*
  * cgen.c
diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h
index 6affd08dc1..61bb7bd6e4 100644
--- a/src/cmd/gc/go.h
+++ b/src/cmd/gc/go.h
@@ -1169,6 +1169,7 @@ void	cgen_callmeth(Node *n, int proc);
 void	cgen_eface(Node* n, Node* res);
 void	cgen_slice(Node* n, Node* res);
 void	clearlabels(void);
+void	clearslim(Node*);
 void	checklabels(void);
 int	dotoffset(Node *n, int64 *oary, Node **nn);
 void	gen(Node *n);

From be2ad1d7f587a235fc69b80f280f5e3702647434 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Sun, 24 Aug 2014 19:07:27 -0700
Subject: [PATCH 188/423] cmd/5g, cmd/6g, cmd/8g: clear Addr node when
 registerizing

Update #8525

Some temporary variables that were fully registerized nevertheless had stack space allocated for them because the Addrs were still marked as having associated nodes.

Distribution of stack space reserved for temporary variables while running make.bash (6g):

BEFORE

40.89%  7026 allocauto: 0 to 0
 7.83%  1346 allocauto: 0 to 24
 7.22%  1241 allocauto: 0 to 8
 6.30%  1082 allocauto: 0 to 16
 4.96%   853 allocauto: 0 to 56
 4.59%   789 allocauto: 0 to 32
 2.97%   510 allocauto: 0 to 40
 2.32%   399 allocauto: 0 to 48
 2.10%   360 allocauto: 0 to 64
 1.91%   328 allocauto: 0 to 72

AFTER

48.49%  8332 allocauto: 0 to 0
 9.52%  1635 allocauto: 0 to 16
 5.28%   908 allocauto: 0 to 48
 4.80%   824 allocauto: 0 to 32
 4.73%   812 allocauto: 0 to 8
 3.38%   581 allocauto: 0 to 24
 2.35%   404 allocauto: 0 to 40
 2.32%   399 allocauto: 0 to 64
 1.65%   284 allocauto: 0 to 56
 1.34%   230 allocauto: 0 to 72

LGTM=rsc
R=rsc
CC=dave, dvyukov, golang-codereviews, minux
https://golang.org/cl/126160043
---
 src/cmd/5g/reg.c | 1 +
 src/cmd/6g/reg.c | 1 +
 src/cmd/8g/reg.c | 1 +
 3 files changed, 3 insertions(+)

diff --git a/src/cmd/5g/reg.c b/src/cmd/5g/reg.c
index d259a232e6..8e49a2d9c8 100644
--- a/src/cmd/5g/reg.c
+++ b/src/cmd/5g/reg.c
@@ -1315,6 +1315,7 @@ void
 addreg(Adr *a, int rn)
 {
 	a->sym = nil;
+	a->node = nil;
 	a->name = D_NONE;
 	a->type = D_REG;
 	a->reg = rn;
diff --git a/src/cmd/6g/reg.c b/src/cmd/6g/reg.c
index 5e3a198186..1f757e1972 100644
--- a/src/cmd/6g/reg.c
+++ b/src/cmd/6g/reg.c
@@ -1191,6 +1191,7 @@ void
 addreg(Adr *a, int rn)
 {
 	a->sym = nil;
+	a->node = nil;
 	a->offset = 0;
 	a->type = rn;
 
diff --git a/src/cmd/8g/reg.c b/src/cmd/8g/reg.c
index a69d124db8..302b273a1b 100644
--- a/src/cmd/8g/reg.c
+++ b/src/cmd/8g/reg.c
@@ -1168,6 +1168,7 @@ void
 addreg(Adr *a, int rn)
 {
 	a->sym = nil;
+	a->node = nil;
 	a->offset = 0;
 	a->type = rn;
 

From ef504623783c0920f7084ae4b7d6bf32c34599b5 Mon Sep 17 00:00:00 2001
From: Sanjay Menakuru <balasanjay@gmail.com>
Date: Sun, 24 Aug 2014 20:27:00 -0700
Subject: [PATCH 189/423] runtime,runtime/debug: Converted some functions from
 goc to Go.

LGTM=khr
R=golang-codereviews, khr
CC=dvyukov, golang-codereviews
https://golang.org/cl/131010044
---
 src/pkg/runtime/debug/garbage.go | 16 ++++--------
 src/pkg/runtime/debug/stubs.go   | 20 +++++++++++++++
 src/pkg/runtime/debug/stubs.s    | 21 ++++++++++++++++
 src/pkg/runtime/malloc.h         |  2 +-
 src/pkg/runtime/mgc0.c           | 10 +++++---
 src/pkg/runtime/proc.c           | 10 +++++---
 src/pkg/runtime/rdebug.go        | 42 ++++++++++++++++++++++++++++++++
 src/pkg/runtime/rdebug.goc       | 27 --------------------
 src/pkg/runtime/runtime.h        |  2 +-
 src/pkg/runtime/stubs.go         |  2 ++
 10 files changed, 106 insertions(+), 46 deletions(-)
 create mode 100644 src/pkg/runtime/debug/stubs.go
 create mode 100644 src/pkg/runtime/debug/stubs.s
 create mode 100644 src/pkg/runtime/rdebug.go
 delete mode 100644 src/pkg/runtime/rdebug.goc

diff --git a/src/pkg/runtime/debug/garbage.go b/src/pkg/runtime/debug/garbage.go
index edb3643871..30994f2196 100644
--- a/src/pkg/runtime/debug/garbage.go
+++ b/src/pkg/runtime/debug/garbage.go
@@ -19,14 +19,6 @@ type GCStats struct {
 	PauseQuantiles []time.Duration
 }
 
-// Implemented in package runtime.
-func readGCStats(*[]time.Duration)
-func enableGC(bool) bool
-func setGCPercent(int) int
-func freeOSMemory()
-func setMaxStack(int) int
-func setMaxThreads(int) int
-
 // ReadGCStats reads statistics about garbage collection into stats.
 // The number of entries in the pause history is system-dependent;
 // stats.Pause slice will be reused if large enough, reallocated otherwise.
@@ -91,9 +83,9 @@ func (x byDuration) Less(i, j int) bool { return x[i] < x[j] }
 // at startup, or 100 if the variable is not set.
 // A negative percentage disables garbage collection.
 func SetGCPercent(percent int) int {
-	old := setGCPercent(percent)
+	old := setGCPercent(int32(percent))
 	runtime.GC()
-	return old
+	return int(old)
 }
 
 // FreeOSMemory forces a garbage collection followed by an
@@ -145,7 +137,9 @@ func SetMaxThreads(threads int) int {
 // that the runtime trigger only a panic, not a crash.
 // SetPanicOnFault applies only to the current goroutine.
 // It returns the previous setting.
-func SetPanicOnFault(enabled bool) bool
+func SetPanicOnFault(enabled bool) bool {
+	return setPanicOnFault(enabled)
+}
 
 // WriteHeapDump writes a description of the heap and the objects in
 // it to the given file descriptor.
diff --git a/src/pkg/runtime/debug/stubs.go b/src/pkg/runtime/debug/stubs.go
new file mode 100644
index 0000000000..8fba6cf34b
--- /dev/null
+++ b/src/pkg/runtime/debug/stubs.go
@@ -0,0 +1,20 @@
+// 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 debug
+
+import (
+	"time"
+)
+
+// Uses assembly to call corresponding runtime-internal functions.
+func setMaxStack(int) int
+func setGCPercent(int32) int32
+func setPanicOnFault(bool) bool
+func setMaxThreads(int) int
+
+// Implemented in package runtime.
+func readGCStats(*[]time.Duration)
+func enableGC(bool) bool
+func freeOSMemory()
diff --git a/src/pkg/runtime/debug/stubs.s b/src/pkg/runtime/debug/stubs.s
new file mode 100644
index 0000000000..d56274f2dc
--- /dev/null
+++ b/src/pkg/runtime/debug/stubs.s
@@ -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.
+
+#include "textflag.h"
+
+#ifdef GOARCH_arm
+#define JMP B
+#endif
+
+TEXT ·setMaxStack(SB),NOSPLIT,$0-0
+  JMP runtime·setMaxStack(SB)
+
+TEXT ·setGCPercent(SB),NOSPLIT,$0-0
+  JMP runtime·setGCPercent(SB)
+
+TEXT ·setPanicOnFault(SB),NOSPLIT,$0-0
+  JMP runtime·setPanicOnFault(SB)
+
+TEXT ·setMaxThreads(SB),NOSPLIT,$0-0
+  JMP runtime·setMaxThreads(SB)
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 48ec026005..fb51a9e5dd 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -586,7 +586,7 @@ void	runtime·gc_m_ptr(Eface*);
 void	runtime·gc_g_ptr(Eface*);
 void	runtime·gc_itab_ptr(Eface*);
 
-int32	runtime·setgcpercent(int32);
+void  runtime·setgcpercent_m(void);
 
 // Value we use to mark dead pointers when GODEBUG=gcdead=1.
 #define PoisonGC ((uintptr)0xf969696969696969ULL)
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 2a476fae4d..ded41510c4 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1621,17 +1621,21 @@ runtime∕debug·readGCStats(Slice *pauses)
 	pauses->len = n+3;
 }
 
-int32
-runtime·setgcpercent(int32 in) {
+void
+runtime·setgcpercent_m(void) {
+	int32 in;
 	int32 out;
 
+	in = (int32)(intptr)g->m->scalararg[0];
+
 	runtime·lock(&runtime·mheap.lock);
 	out = runtime·gcpercent;
 	if(in < 0)
 		in = -1;
 	runtime·gcpercent = in;
 	runtime·unlock(&runtime·mheap.lock);
-	return out;
+
+	g->m->scalararg[0] = (uintptr)(intptr)out;
 }
 
 static void
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 722f44bb1b..44757a8afd 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -3199,17 +3199,21 @@ runtime·topofstack(Func *f)
 		(runtime·externalthreadhandlerp != 0 && f->entry == runtime·externalthreadhandlerp);
 }
 
-int32
-runtime·setmaxthreads(int32 in)
+void
+runtime·setmaxthreads_m(void)
 {
+	int32 in;
 	int32 out;
 
+	in = g->m->scalararg[0];
+
 	runtime·lock(&runtime·sched.lock);
 	out = runtime·sched.maxmcount;
 	runtime·sched.maxmcount = in;
 	checkmcount();
 	runtime·unlock(&runtime·sched.lock);
-	return out;
+
+	g->m->scalararg[0] = out;
 }
 
 static int8 experiment[] = GOEXPERIMENT; // defined in zaexperiment.h
diff --git a/src/pkg/runtime/rdebug.go b/src/pkg/runtime/rdebug.go
new file mode 100644
index 0000000000..3df73ce660
--- /dev/null
+++ b/src/pkg/runtime/rdebug.go
@@ -0,0 +1,42 @@
+// 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 runtime
+
+func setMaxStack(in int) (out int) {
+	out = int(maxstacksize)
+	maxstacksize = uint(in)
+	return out
+}
+
+func setGCPercent(in int32) (out int32) {
+	mp := acquirem()
+	mp.scalararg[0] = uint(int(in))
+	onM(&setgcpercent_m)
+	out = int32(int(mp.scalararg[0]))
+	releasem(mp)
+	return out
+}
+
+func setPanicOnFault(newb bool) (old bool) {
+	new := uint8(0)
+	if newb {
+		new = 1
+	}
+
+	mp := acquirem()
+	old = mp.curg.paniconfault == 1
+	mp.curg.paniconfault = new
+	releasem(mp)
+	return old
+}
+
+func setMaxThreads(in int) (out int) {
+	mp := acquirem()
+	mp.scalararg[0] = uint(in)
+	onM(&setmaxthreads_m)
+	out = int(mp.scalararg[0])
+	releasem(mp)
+	return out
+}
diff --git a/src/pkg/runtime/rdebug.goc b/src/pkg/runtime/rdebug.goc
deleted file mode 100644
index 042b30ace9..0000000000
--- a/src/pkg/runtime/rdebug.goc
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime∕debug
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "stack.h"
-
-func setMaxStack(in int) (out int) {
-	out = runtime·maxstacksize;
-	runtime·maxstacksize = in;
-}
-
-func setGCPercent(in int) (out int) {
-	out = runtime·setgcpercent(in);
-}
-
-func setMaxThreads(in int) (out int) {
-	out = runtime·setmaxthreads(in);
-}
-
-func SetPanicOnFault(enabled bool) (old bool) {
-	old = g->paniconfault;
-	g->paniconfault = enabled;
-}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index f12e50cbfb..c96fc81417 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -981,7 +981,7 @@ void	runtime·crash(void);
 void	runtime·parsedebugvars(void);
 void	_rt0_go(void);
 void*	runtime·funcdata(Func*, int32);
-int32	runtime·setmaxthreads(int32);
+void	runtime·setmaxthreads_m(void);
 G*	runtime·timejump(void);
 void	runtime·iterate_itabs(void (*callback)(Itab*));
 void	runtime·iterate_finq(void (*callback)(FuncVal*, byte*, uintptr, Type*, PtrType*));
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 76f6faf53a..37e768a4ec 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -84,6 +84,8 @@ var (
 	unrollgcprog_m,
 	unrollgcproginplace_m,
 	gosched_m,
+	setgcpercent_m,
+	setmaxthreads_m,
 	ready_m,
 	park_m,
 	blockevent_m,

From 38ce599494be0274f3b9dd3391a60c548420f562 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Mon, 25 Aug 2014 15:59:13 +1000
Subject: [PATCH 190/423] runtime: convert NewCallback and NewCallbackCDecl to
 Go

LGTM=khr
R=khr, remyoudompheng
CC=golang-codereviews
https://golang.org/cl/132820043
---
 src/cmd/api/goapi.go                |  5 +-
 src/cmd/dist/buildruntime.c         |  5 ++
 src/pkg/runtime/callback_windows.c  | 77 ------------------------
 src/pkg/runtime/syscall_windows.go  | 92 +++++++++++++++++++++++++++++
 src/pkg/runtime/syscall_windows.goc |  8 ---
 src/pkg/syscall/asm_windows.s       | 13 ++++
 src/pkg/syscall/asm_windows_386.s   |  7 ---
 src/pkg/syscall/asm_windows_amd64.s |  7 ---
 src/pkg/syscall/syscall_windows.go  | 18 ++++--
 9 files changed, 127 insertions(+), 105 deletions(-)
 delete mode 100644 src/pkg/runtime/callback_windows.c
 create mode 100644 src/pkg/runtime/syscall_windows.go
 create mode 100644 src/pkg/syscall/asm_windows.s
 delete mode 100644 src/pkg/syscall/asm_windows_386.s
 delete mode 100644 src/pkg/syscall/asm_windows_amd64.s

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 2900a27ceb..54c84b4d09 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -384,8 +384,9 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
 			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
 			" hchan struct{}; chantype struct{}; waitq struct{};" +
-			" note struct{};" +
-			")"
+			" note struct{}; wincallbackcontext struct{};" +
+			"); " +
+			"const ( cb_max = 2000 )"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index b16b5756cc..5daa31494b 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -402,6 +402,11 @@ mkzruntimedefs(char *dir, char *file)
 		
 		bwritestr(&out, p);
 	}
+
+	// Some windows specific const.
+	if(streq(goos, "windows")) {
+		bwritestr(&out, bprintf(&b, "const cb_max = %d\n", MAXWINCB));
+	}
 	
 	writefile(&out, file, 0);
 
diff --git a/src/pkg/runtime/callback_windows.c b/src/pkg/runtime/callback_windows.c
deleted file mode 100644
index 5c6975af29..0000000000
--- a/src/pkg/runtime/callback_windows.c
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "runtime.h"
-#include "type.h"
-#include "typekind.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-#include "zasm_GOOS_GOARCH.h"
-
-typedef	struct	Callbacks	Callbacks;
-struct	Callbacks {
-	Lock			lock;
-	WinCallbackContext*	ctxt[cb_max];
-	int32			n;
-};
-
-static	Callbacks	cbs;
-
-WinCallbackContext** runtime·cbctxts; // to simplify access to cbs.ctxt in sys_windows_*.s
-
-// Call back from windows dll into go.
-byte *
-runtime·compilecallback(Eface fn, bool cleanstack)
-{
-	FuncType *ft;
-	Type *t;
-	int32 argsize, i, n;
-	WinCallbackContext *c;
-
-	if(fn.type == nil || (fn.type->kind&KindMask) != KindFunc)
-		runtime·panicstring("compilecallback: not a function");
-	ft = (FuncType*)fn.type;
-	if(ft->out.len != 1)
-		runtime·panicstring("compilecallback: function must have one output parameter");
-	if(((Type**)ft->out.array)[0]->size != sizeof(uintptr))
-		runtime·panicstring("compilecallback: output parameter size is wrong");
-	argsize = 0;
-	for(i=0; i<ft->in.len; i++) {
-		t = ((Type**)ft->in.array)[i];
-		if(t->size > sizeof(uintptr))
-			runtime·panicstring("compilecallback: input parameter size is wrong");
-		argsize += sizeof(uintptr);
-	}
-
-	runtime·lock(&cbs.lock);
-	if(runtime·cbctxts == nil)
-		runtime·cbctxts = &(cbs.ctxt[0]);
-	n = cbs.n;
-	for(i=0; i<n; i++) {
-		if(cbs.ctxt[i]->gobody == fn.data && cbs.ctxt[i]->cleanstack == cleanstack) {
-			runtime·unlock(&cbs.lock);
-			// runtime·callbackasm is just a series of CALL instructions
-			// (each is 5 bytes long), and we want callback to arrive at
-			// correspondent call instruction instead of start of
-			// runtime·callbackasm.
-			return (byte*)runtime·callbackasm + i * 5;
-		}
-	}
-	if(n >= cb_max)
-		runtime·throw("too many callback functions");
-	c = runtime·mallocgc(sizeof *c, nil, 0);
-	c->gobody = fn.data;
-	c->argsize = argsize;
-	c->cleanstack = cleanstack;
-	if(cleanstack && argsize!=0)
-		c->restorestack = argsize;
-	else
-		c->restorestack = 0;
-	cbs.ctxt[n] = c;
-	cbs.n++;
-	runtime·unlock(&cbs.lock);
-
-	// as before
-	return (byte*)runtime·callbackasm + n * 5;
-}
diff --git a/src/pkg/runtime/syscall_windows.go b/src/pkg/runtime/syscall_windows.go
new file mode 100644
index 0000000000..272db62410
--- /dev/null
+++ b/src/pkg/runtime/syscall_windows.go
@@ -0,0 +1,92 @@
+// 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 runtime
+
+import (
+	"unsafe"
+)
+
+type callbacks struct {
+	lock
+	ctxt [cb_max]*wincallbackcontext
+	n    int
+}
+
+func (c *wincallbackcontext) isCleanstack() bool {
+	return c.cleanstack == 1
+}
+
+func (c *wincallbackcontext) setCleanstack(cleanstack bool) {
+	if cleanstack {
+		c.cleanstack = 1
+	} else {
+		c.cleanstack = 0
+	}
+}
+
+var (
+	cbs     callbacks
+	cbctxts **wincallbackcontext = &cbs.ctxt[0] // to simplify access to cbs.ctxt in sys_windows_*.s
+
+	callbackasm byte // type isn't really byte, it's code in runtime
+)
+
+// callbackasmAddr returns address of runtime.callbackasm
+// function adjusted by i.
+// runtime.callbackasm is just a series of CALL instructions
+// (each is 5 bytes long), and we want callback to arrive at
+// correspondent call instruction instead of start of
+// runtime.callbackasm.
+func callbackasmAddr(i int) uintptr {
+	return uintptr(add(unsafe.Pointer(&callbackasm), uintptr(i*5)))
+}
+
+func compileCallback(fn eface, cleanstack bool) (code uintptr) {
+	if fn._type == nil || (fn._type.kind&kindMask) != kindFunc {
+		panic("compilecallback: not a function")
+	}
+	ft := (*functype)(unsafe.Pointer(fn._type))
+	if len(ft.out) != 1 {
+		panic("compilecallback: function must have one output parameter")
+	}
+	uintptrSize := uint(unsafe.Sizeof(uintptr(0)))
+	if t := (**_type)(unsafe.Pointer(&ft.out[0])); (*t).size != uintptrSize {
+		panic("compilecallback: output parameter size is wrong")
+	}
+	argsize := uint(0)
+	for _, t := range (*[1024](*_type))(unsafe.Pointer(&ft.in[0]))[:len(ft.in)] {
+		if (*t).size != uintptrSize {
+			panic("compilecallback: input parameter size is wrong")
+		}
+		argsize += uintptrSize
+	}
+
+	golock(&cbs.lock)
+	defer gounlock(&cbs.lock)
+
+	n := cbs.n
+	for i := 0; i < n; i++ {
+		if cbs.ctxt[i].gobody == fn.data && cbs.ctxt[i].isCleanstack() == cleanstack {
+			return callbackasmAddr(i)
+		}
+	}
+	if n >= cb_max {
+		gothrow("too many callback functions")
+	}
+
+	c := new(wincallbackcontext)
+	c.gobody = fn.data
+	c.argsize = argsize
+	c.setCleanstack(cleanstack)
+	if cleanstack && argsize != 0 {
+		c.restorestack = argsize
+	} else {
+		c.restorestack = 0
+	}
+	cbs.ctxt[n] = c
+	cbs.n++
+
+	return callbackasmAddr(n)
+}
diff --git a/src/pkg/runtime/syscall_windows.goc b/src/pkg/runtime/syscall_windows.goc
index 528245363e..a1665c3b5c 100644
--- a/src/pkg/runtime/syscall_windows.goc
+++ b/src/pkg/runtime/syscall_windows.goc
@@ -36,14 +36,6 @@ func getprocaddress(handle uintptr, procname *uint8) (proc uintptr, err uintptr)
 		err = 0;
 }
 
-func NewCallback(fn Eface) (code uintptr) {
-	code = (uintptr)runtime·compilecallback(fn, true);
-}
-
-func NewCallbackCDecl(fn Eface) (code uintptr) {
-	code = (uintptr)runtime·compilecallback(fn, false);
-}
-
 func Syscall(fn uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
 	LibCall c;
 
diff --git a/src/pkg/syscall/asm_windows.s b/src/pkg/syscall/asm_windows.s
new file mode 100644
index 0000000000..abb6641a25
--- /dev/null
+++ b/src/pkg/syscall/asm_windows.s
@@ -0,0 +1,13 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//
+// System calls for Windows are implemented in ../runtime/syscall_windows.goc
+//
+
+#include "textflag.h"
+
+// func compileCallback(fn interface{}, cleanstack bool) uintptr
+TEXT ·compileCallback(SB),NOSPLIT,$0
+	JMP	runtime·compileCallback(SB)
diff --git a/src/pkg/syscall/asm_windows_386.s b/src/pkg/syscall/asm_windows_386.s
deleted file mode 100644
index 8b52fa9851..0000000000
--- a/src/pkg/syscall/asm_windows_386.s
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//
-// System calls for 386, Windows are implemented in ../runtime/syscall_windows.goc
-//
diff --git a/src/pkg/syscall/asm_windows_amd64.s b/src/pkg/syscall/asm_windows_amd64.s
deleted file mode 100644
index 5813404d17..0000000000
--- a/src/pkg/syscall/asm_windows_amd64.s
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//
-// System calls for amd64, Windows are implemented in ../runtime/syscall_windows.goc
-//
diff --git a/src/pkg/syscall/syscall_windows.go b/src/pkg/syscall/syscall_windows.go
index 32a7aed001..bda8214c3c 100644
--- a/src/pkg/syscall/syscall_windows.go
+++ b/src/pkg/syscall/syscall_windows.go
@@ -105,12 +105,22 @@ func (e Errno) Timeout() bool {
 	return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
 }
 
+// Implemented in asm_windows.s
+func compileCallback(fn interface{}, cleanstack bool) uintptr
+
 // Converts a Go function to a function pointer conforming
-// to the stdcall or cdecl calling convention.  This is useful when
+// to the stdcall calling convention. This is useful when
 // interoperating with Windows code requiring callbacks.
-// Implemented in ../runtime/syscall_windows.goc
-func NewCallback(fn interface{}) uintptr
-func NewCallbackCDecl(fn interface{}) uintptr
+func NewCallback(fn interface{}) uintptr {
+	return compileCallback(fn, true)
+}
+
+// Converts a Go function to a function pointer conforming
+// to the cdecl calling convention. This is useful when
+// interoperating with Windows code requiring callbacks.
+func NewCallbackCDecl(fn interface{}) uintptr {
+	return compileCallback(fn, false)
+}
 
 // windows api calls
 

From 639dc6c794d682dd7efff21107d0e085ed66726c Mon Sep 17 00:00:00 2001
From: Sanjay Menakuru <balasanjay@gmail.com>
Date: Mon, 25 Aug 2014 11:29:53 +0400
Subject: [PATCH 191/423] runtime: Loosen conditions in TestMemstat in an
 attempt to fix the nacl/arm build.

LGTM=dvyukov
R=golang-codereviews, dvyukov
CC=golang-codereviews, khr
https://golang.org/cl/128680043
---
 src/pkg/runtime/malloc_test.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/malloc_test.go b/src/pkg/runtime/malloc_test.go
index 211d78dc8a..b7795aa1d6 100644
--- a/src/pkg/runtime/malloc_test.go
+++ b/src/pkg/runtime/malloc_test.go
@@ -17,10 +17,10 @@ func TestMemStats(t *testing.T) {
 	st := new(MemStats)
 	ReadMemStats(st)
 
-	// Everything except HeapReleased, because it indeed can be 0.
+	// Everything except HeapReleased and HeapIdle, because they indeed can be 0.
 	if st.Alloc == 0 || st.TotalAlloc == 0 || st.Sys == 0 || st.Lookups == 0 ||
 		st.Mallocs == 0 || st.Frees == 0 || st.HeapAlloc == 0 || st.HeapSys == 0 ||
-		st.HeapIdle == 0 || st.HeapInuse == 0 || st.HeapObjects == 0 || st.StackInuse == 0 ||
+		st.HeapInuse == 0 || st.HeapObjects == 0 || st.StackInuse == 0 ||
 		st.StackSys == 0 || st.MSpanInuse == 0 || st.MSpanSys == 0 || st.MCacheInuse == 0 ||
 		st.MCacheSys == 0 || st.BuckHashSys == 0 || st.GCSys == 0 || st.OtherSys == 0 ||
 		st.NextGC == 0 || st.NumGC == 0 {
@@ -40,6 +40,10 @@ func TestMemStats(t *testing.T) {
 		st.BuckHashSys+st.GCSys+st.OtherSys {
 		t.Fatalf("Bad sys value: %+v", *st)
 	}
+
+	if st.HeapIdle+st.HeapInuse != st.HeapSys {
+		t.Fatalf("HeapIdle(%d) + HeapInuse(%d) should be equal to HeapSys(%d), but isn't.", st.HeapIdle, st.HeapInuse, st.HeapSys)
+	}
 }
 
 var mallocSink uintptr

From f6ceefa2bf9a36f60395662aa2122b50eb61f0ac Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 11:55:42 +0400
Subject: [PATCH 192/423] runtime: add fast paths to non-blocking channel
 operations benchmark                      old ns/op     new ns/op     delta
 BenchmarkChanNonblocking       27.8          7.80          -71.94%
 BenchmarkChanNonblocking-2     79.1          3.94          -95.02%
 BenchmarkChanNonblocking-4     71.2          2.04          -97.13%

LGTM=rsc
R=golang-codereviews, rsc, dave
CC=golang-codereviews
https://golang.org/cl/110580043
---
 src/pkg/runtime/chan.go      | 30 ++++++++++++++++++++++-----
 src/pkg/runtime/chan.goc     | 40 ++++++++++++++++++++++++++++++++++--
 src/pkg/runtime/chan.h       |  2 +-
 src/pkg/runtime/chan_test.go | 20 ++++++++++++++++++
 4 files changed, 84 insertions(+), 8 deletions(-)

diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index 67427e960e..f9a540af3d 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -96,17 +96,37 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		println("chansend: chan=", c)
 	}
 
+	if raceenabled {
+		fn := chansend
+		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		racereadpc(unsafe.Pointer(c), pc, callerpc)
+	}
+
+	// Fast path: check for failed non-blocking operation without acquiring the lock.
+	//
+	// After observing that the channel is not closed, we observe that the channel is
+	// not ready for sending. Each of these observations is a single word-sized read
+	// (first c.closed and second c.recvq.first or c.qcount depending on kind of channel).
+	// Because a closed channel cannot transition from 'ready for sending' to
+	// 'not ready for sending', even if the channel is closed between the two observations,
+	// they imply a moment between the two when the channel was both not yet closed
+	// and not ready for sending. We behave as if we observed the channel at that moment,
+	// and report that the send cannot proceed.
+	//
+	// It is okay if the reads are reordered here: if we observe that the channel is not
+	// ready for sending and then observe that it is not closed, that implies that the
+	// channel wasn't closed during the first observation.
+	if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) ||
+		(c.dataqsiz > 0 && c.qcount == c.dataqsiz)) {
+		return false
+	}
+
 	var t0 int64
 	if blockprofilerate > 0 {
 		t0 = gocputicks()
 	}
 
 	golock(&c.lock)
-	if raceenabled {
-		fn := chansend
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(c), pc, callerpc)
-	}
 	if c.closed != 0 {
 		gounlock(&c.lock)
 		panic("send on closed channel")
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 7f6373dc81..4d4f366efa 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -57,6 +57,27 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 		runtime·prints("\n");
 	}
 
+	if(raceenabled)
+		runtime·racereadpc(c, pc, chansend);
+
+	// Fast path: check for failed non-blocking operation without acquiring the lock.
+	//
+	// After observing that the channel is not closed, we observe that the channel is
+	// not ready for sending. Each of these observations is a single word-sized read
+	// (first c.closed and second c.recvq.first or c.qcount depending on kind of channel).
+	// Because a closed channel cannot transition from 'ready for sending' to
+	// 'not ready for sending', even if the channel is closed between the two observations,
+	// they imply a moment between the two when the channel was both not yet closed
+	// and not ready for sending. We behave as if we observed the channel at that moment,
+	// and report that the send cannot proceed.
+	//
+	// It is okay if the reads are reordered here: if we observe that the channel is not
+	// ready for sending and then observe that it is not closed, that implies that the
+	// channel wasn't closed during the first observation.
+	if(!block && !c->closed && ((c->dataqsiz == 0 && c->recvq.first == nil) ||
+		(c->dataqsiz > 0 && c->qcount == c->dataqsiz)))
+		return false;
+
 	t0 = 0;
 	mysg.releasetime = 0;
 	if(runtime·blockprofilerate > 0) {
@@ -65,8 +86,6 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 	}
 
 	runtime·lock(&c->lock);
-	if(raceenabled)
-		runtime·racereadpc(c, pc, chansend);
 	if(c->closed)
 		goto closed;
 
@@ -183,6 +202,23 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 		return false;  // not reached
 	}
 
+	// Fast path: check for failed non-blocking operation without acquiring the lock.
+	//
+	// After observing that the channel is not ready for receiving, we observe that the
+	// channel is not closed. Each of these observations is a single word-sized read
+	// (first c.sendq.first or c.qcount, and second c.closed).
+	// Because a channel cannot be reopened, the later observation of the channel
+	// being not closed implies that it was also not closed at the moment of the
+	// first observation. We behave as if we observed the channel at that moment
+	// and report that the receive cannot proceed.
+	//
+	// The order of operations is important here: reversing the operations can lead to
+	// incorrect behavior when racing with a close.
+	if(!block && ((c->dataqsiz == 0 && c->sendq.first == nil) ||
+		(c->dataqsiz > 0 && runtime·atomicloadp((void**)&c->qcount) == 0)) &&
+		!runtime·atomicload(&c->closed))
+		return false;
+
 	t0 = 0;
 	mysg.releasetime = 0;
 	if(runtime·blockprofilerate > 0) {
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index 5ebbcfd4da..52eb20099d 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -20,7 +20,7 @@ struct	Hchan
 	uintgo	dataqsiz;		// size of the circular q
 	byte*	buf;
 	uint16	elemsize;
-	bool	closed;
+	uint32	closed;
 	Type*	elemtype;		// element type
 	uintgo	sendx;			// send index
 	uintgo	recvx;			// receive index
diff --git a/src/pkg/runtime/chan_test.go b/src/pkg/runtime/chan_test.go
index bb0f28655d..01632892ed 100644
--- a/src/pkg/runtime/chan_test.go
+++ b/src/pkg/runtime/chan_test.go
@@ -198,6 +198,26 @@ func TestChan(t *testing.T) {
 	}
 }
 
+func TestNonblockRecvRace(t *testing.T) {
+	n := 10000
+	if testing.Short() {
+		n = 100
+	}
+	for i := 0; i < n; i++ {
+		c := make(chan int, 1)
+		c <- 1
+		go func() {
+			select {
+			case <-c:
+			default:
+				t.Fatal("chan is not ready")
+			}
+		}()
+		close(c)
+		<-c
+	}
+}
+
 func TestSelfSelect(t *testing.T) {
 	// Ensure that send/recv on the same chan in select
 	// does not crash nor deadlock.

From 8ca564fb3fe0b8d6f4d7c660f9df9c1bbcc0539e Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 11:56:25 +0400
Subject: [PATCH 193/423] runtime: fix block profile for sync semaphores And
 add a test.

LGTM=rsc
R=golang-codereviews
CC=golang-codereviews, khr, rsc
https://golang.org/cl/128670043
---
 src/pkg/runtime/pprof/pprof_test.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/pkg/runtime/pprof/pprof_test.go b/src/pkg/runtime/pprof/pprof_test.go
index 9ab211c2da..45db6c59a7 100644
--- a/src/pkg/runtime/pprof/pprof_test.go
+++ b/src/pkg/runtime/pprof/pprof_test.go
@@ -314,6 +314,12 @@ func TestBlockProfile(t *testing.T) {
 #	0x[0-9,a-f]+	sync\.\(\*Mutex\)\.Lock\+0x[0-9,a-f]+	.*/src/pkg/sync/mutex\.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.blockMutex\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+`},
+		{"cond", blockCond, `
+[0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
+#	0x[0-9,a-f]+	sync\.\(\*Cond\)\.Wait\+0x[0-9,a-f]+	.*/src/pkg/sync/cond\.go:[0-9]+
+#	0x[0-9,a-f]+	runtime/pprof_test\.blockCond\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
+#	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 `},
 	}
 
@@ -401,3 +407,17 @@ func blockMutex() {
 	}()
 	mu.Lock()
 }
+
+func blockCond() {
+	var mu sync.Mutex
+	c := sync.NewCond(&mu)
+	mu.Lock()
+	go func() {
+		time.Sleep(blockDelay)
+		mu.Lock()
+		c.Signal()
+		mu.Unlock()
+	}()
+	c.Wait()
+	mu.Unlock()
+}

From 7b3677bf3c02f79dc51575ef7b05ea2f4372df90 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 12:09:42 +0400
Subject: [PATCH 194/423] runtime: fix block profile for sync semaphores Part
 of cl/128670043 that got lost during submit.

TBR=rsc
R=golang-codereviews
CC=golang-codereviews
https://golang.org/cl/129570043
---
 src/pkg/runtime/sema.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/sema.go b/src/pkg/runtime/sema.go
index ac855f9d8c..1d591ffeba 100644
--- a/src/pkg/runtime/sema.go
+++ b/src/pkg/runtime/sema.go
@@ -66,7 +66,7 @@ func syncsemacquire(s *syncSema) {
 		s.tail = w
 		goparkunlock(&s.lock, "semacquire")
 		if t0 != 0 {
-			goblockevent(int64(w.releasetime)-t0, 2)
+			goblockevent(int64(w.releasetime)-t0, 3)
 		}
 		releaseSudog(w)
 	}

From f595f834be92ee726ddfb0bea223243ebba32eac Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 12:10:24 +0400
Subject: [PATCH 195/423] runtime: refactor CPU profiling Reduce duration of
 critical section, make pcbuf local to function.

LGTM=rsc
R=golang-codereviews
CC=golang-codereviews, rsc
https://golang.org/cl/102600043
---
 src/pkg/runtime/proc.c | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 44757a8afd..31ff4f55de 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2253,7 +2253,6 @@ static struct {
 	Lock lock;
 	void (*fn)(uintptr*, int32);
 	int32 hz;
-	uintptr pcbuf[100];
 } prof;
 
 static void System(void) {}
@@ -2270,6 +2269,7 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 	// Do not use global m in this function, use mp instead.
 	// On windows one m is sending reports about all the g's, so m means a wrong thing.
 	byte m;
+	uintptr stk[100];
 
 	m = 0;
 	USED(m);
@@ -2358,15 +2358,9 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 	   ((uint8*)runtime·gogo <= pc && pc < (uint8*)runtime·gogo + RuntimeGogoBytes))
 		traceback = false;
 
-	runtime·lock(&prof.lock);
-	if(prof.fn == nil) {
-		runtime·unlock(&prof.lock);
-		mp->mallocing--;
-		return;
-	}
 	n = 0;
 	if(traceback)
-		n = runtime·gentraceback((uintptr)pc, (uintptr)sp, (uintptr)lr, gp, 0, prof.pcbuf, nelem(prof.pcbuf), nil, nil, false);
+		n = runtime·gentraceback((uintptr)pc, (uintptr)sp, (uintptr)lr, gp, 0, stk, nelem(stk), nil, nil, false);
 	if(!traceback || n <= 0) {
 		// Normal traceback is impossible or has failed.
 		// See if it falls into several common cases.
@@ -2376,13 +2370,13 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 			// Cgo, we can't unwind and symbolize arbitrary C code,
 			// so instead collect Go stack that leads to the cgo call.
 			// This is especially important on windows, since all syscalls are cgo calls.
-			n = runtime·gentraceback(mp->curg->syscallpc, mp->curg->syscallsp, 0, mp->curg, 0, prof.pcbuf, nelem(prof.pcbuf), nil, nil, false);
+			n = runtime·gentraceback(mp->curg->syscallpc, mp->curg->syscallsp, 0, mp->curg, 0, stk, nelem(stk), nil, nil, false);
 		}
 #ifdef GOOS_windows
 		if(n == 0 && mp->libcallg != nil && mp->libcallpc != 0 && mp->libcallsp != 0) {
 			// Libcall, i.e. runtime syscall on windows.
 			// Collect Go stack that leads to the call.
-			n = runtime·gentraceback(mp->libcallpc, mp->libcallsp, 0, mp->libcallg, 0, prof.pcbuf, nelem(prof.pcbuf), nil, nil, false);
+			n = runtime·gentraceback(mp->libcallpc, mp->libcallsp, 0, mp->libcallg, 0, stk, nelem(stk), nil, nil, false);
 		}
 #endif
 		if(n == 0) {
@@ -2391,15 +2385,20 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 			// "ExternalCode" is better than "etext".
 			if((uintptr)pc > (uintptr)etext)
 				pc = (byte*)ExternalCode + PCQuantum;
-			prof.pcbuf[0] = (uintptr)pc;
+			stk[0] = (uintptr)pc;
 			if(mp->gcing || mp->helpgc)
-				prof.pcbuf[1] = (uintptr)GC + PCQuantum;
+				stk[1] = (uintptr)GC + PCQuantum;
 			else
-				prof.pcbuf[1] = (uintptr)System + PCQuantum;
+				stk[1] = (uintptr)System + PCQuantum;
 		}
 	}
-	prof.fn(prof.pcbuf, n);
-	runtime·unlock(&prof.lock);
+
+	if(prof.fn != nil) {
+		runtime·lock(&prof.lock);
+		if(prof.fn != nil)
+			prof.fn(stk, n);
+		runtime·unlock(&prof.lock);
+	}
 	mp->mallocing--;
 }
 

From 20e97677fd61dbdca128e9628e28327988c39bb4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 25 Aug 2014 07:05:45 -0400
Subject: [PATCH 196/423] cmd/gc: fix order of channel evaluation of receive
 channels

Normally, an expression of the form x.f or *y can be reordered
with function calls and communications.

Select is stricter than normal: each channel expression is evaluated
in source order. If you have case <-x.f and case <-foo(), then if the
evaluation of x.f causes a panic, foo must not have been called.
(This is in contrast to an expression like x.f + foo().)

Enforce this stricter ordering.

Fixes #8336.

LGTM=dvyukov
R=golang-codereviews, dvyukov
CC=golang-codereviews, r
https://golang.org/cl/126570043
---
 src/cmd/gc/order.c          |  8 ++++++++
 test/fixedbugs/issue8336.go | 29 +++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+)
 create mode 100644 test/fixedbugs/issue8336.go

diff --git a/src/cmd/gc/order.c b/src/cmd/gc/order.c
index 59231a0f1c..d11e9828cb 100644
--- a/src/cmd/gc/order.c
+++ b/src/cmd/gc/order.c
@@ -771,6 +771,12 @@ orderstmt(Node *n, Order *order)
 		// Special: clean case temporaries in each block entry.
 		// Select must enter one of its blocks, so there is no
 		// need for a cleaning at the end.
+		// Doubly special: evaluation order for select is stricter
+		// than ordinary expressions. Even something like p.c
+		// has to be hoisted into a temporary, so that it cannot be
+		// reordered after the channel evaluation for a different
+		// case (if p were nil, then the timing of the fault would
+		// give this away).
 		t = marktemp(order);
 		for(l=n->list; l; l=l->next) {
 			if(l->n->op != OXCASE)
@@ -813,6 +819,8 @@ orderstmt(Node *n, Order *order)
 					// r->left == N means 'case <-c'.
 					// c is always evaluated; x and ok are only evaluated when assigned.
 					orderexpr(&r->right->left, order);
+					if(r->right->left->op != ONAME)
+						r->right->left = ordercopyexpr(r->right->left, r->right->left->type, order, 0);
 
 					// Introduce temporary for receive and move actual copy into case body.
 					// avoids problems with target being addressed, as usual.
diff --git a/test/fixedbugs/issue8336.go b/test/fixedbugs/issue8336.go
new file mode 100644
index 0000000000..26bdeabb25
--- /dev/null
+++ b/test/fixedbugs/issue8336.go
@@ -0,0 +1,29 @@
+// run
+
+// 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 8336. Order of evaluation of receive channels in select.
+
+package main
+
+type X struct {
+	c chan int
+}
+
+func main() {
+	defer func() {
+		recover()
+	}()
+	var x *X
+	select {
+	case <-x.c: // should fault and panic before foo is called
+	case <-foo():
+	}
+}
+
+func foo() chan int {
+	println("BUG: foo must not be called")
+	return make(chan int)
+}

From 99080c4b6f29aa6ea988747c43475469e761c8a5 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 17:19:56 +0400
Subject: [PATCH 197/423] runtime: fix chan alignment on 32 bits

LGTM=dave
R=golang-codereviews, dave
CC=golang-codereviews, khr, rsc
https://golang.org/cl/128700043
---
 src/pkg/runtime/chan.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index 52eb20099d..30825eafad 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -21,6 +21,9 @@ struct	Hchan
 	byte*	buf;
 	uint16	elemsize;
 	uint32	closed;
+#ifndef GOARCH_amd64
+	uint32	pad;			// ensures proper alignment of the buffer that follows Hchan in memory
+#endif
 	Type*	elemtype;		// element type
 	uintgo	sendx;			// send index
 	uintgo	recvx;			// receive index

From 846db08936ee89b95d002b6f38e26d84eece6eec Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 18:02:30 +0400
Subject: [PATCH 198/423] runtime: fix plan9 HeapSys accounting

LGTM=0intro
R=0intro
CC=golang-codereviews
https://golang.org/cl/131190043
---
 src/pkg/runtime/mem_plan9.c | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/mem_plan9.c b/src/pkg/runtime/mem_plan9.c
index bbf04c7eda..ea35a1709c 100644
--- a/src/pkg/runtime/mem_plan9.c
+++ b/src/pkg/runtime/mem_plan9.c
@@ -17,8 +17,8 @@ enum
 	Round = PAGESIZE-1
 };
 
-void*
-runtime·SysAlloc(uintptr nbytes, uint64 *stat)
+static void*
+brk(uintptr nbytes)
 {
 	uintptr bl;
 
@@ -31,8 +31,19 @@ runtime·SysAlloc(uintptr nbytes, uint64 *stat)
 	}
 	bloc = (byte*)bl + nbytes;
 	runtime·unlock(&memlock);
-	runtime·xadd64(stat, nbytes);
 	return (void*)bl;
+	
+}
+
+void*
+runtime·SysAlloc(uintptr nbytes, uint64 *stat)
+{
+	void *p;
+
+	p = brk(nbytes);
+	if(p != nil)
+		runtime·xadd64(stat, nbytes);
+	return p;
 }
 
 void
@@ -64,7 +75,10 @@ runtime·SysUsed(void *v, uintptr nbytes)
 void
 runtime·SysMap(void *v, uintptr nbytes, bool reserved, uint64 *stat)
 {
-	USED(v, nbytes, reserved, stat);
+	// SysReserve has already allocated all heap memory,
+	// but has not adjusted stats.
+	USED(v, reserved);
+	runtime·xadd64(stat, nbytes);
 }
 
 void
@@ -78,5 +92,5 @@ runtime·SysReserve(void *v, uintptr nbytes, bool *reserved)
 {
 	USED(v);
 	*reserved = true;
-	return runtime·SysAlloc(nbytes, &mstats.heap_sys);
+	return brk(nbytes);
 }

From ebac0e6f302c52e97a212fab8837a73f31edc884 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 20:12:26 +0400
Subject: [PATCH 199/423] runtime: convert async semaphores to Go

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr
https://golang.org/cl/126210046
---
 src/cmd/gc/select.c              |   1 +
 src/pkg/runtime/arch_386.go      |   9 ++
 src/pkg/runtime/arch_amd64.go    |   9 ++
 src/pkg/runtime/arch_amd64p32.go |   9 ++
 src/pkg/runtime/arch_arm.go      |   9 ++
 src/pkg/runtime/chan.go          |   8 +-
 src/pkg/runtime/chan.goc         |  10 +-
 src/pkg/runtime/proc.go          |   4 +-
 src/pkg/runtime/runtime.h        |   5 +-
 src/pkg/runtime/sema.go          | 165 ++++++++++++++++++++++++-
 src/pkg/runtime/sema.goc         | 204 -------------------------------
 src/pkg/runtime/stubs.go         |   7 +-
 src/pkg/runtime/stubs.goc        |  15 +++
 src/pkg/runtime/thunk.s          |  12 ++
 14 files changed, 242 insertions(+), 225 deletions(-)
 create mode 100644 src/pkg/runtime/arch_386.go
 create mode 100644 src/pkg/runtime/arch_amd64.go
 create mode 100644 src/pkg/runtime/arch_amd64p32.go
 create mode 100644 src/pkg/runtime/arch_arm.go
 delete mode 100644 src/pkg/runtime/sema.goc

diff --git a/src/cmd/gc/select.c b/src/cmd/gc/select.c
index a8caefbb53..8cf9926c17 100644
--- a/src/cmd/gc/select.c
+++ b/src/cmd/gc/select.c
@@ -337,6 +337,7 @@ selecttype(int32 size)
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("g")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("selectdone")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("link")), typenod(ptrto(types[TUINT8]))));
+	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("prev")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(types[TUINT8]))));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("releasetime")), typenod(types[TUINT64])));
 	sudog->list = list(sudog->list, nod(ODCLFIELD, newname(lookup("nrelease")), typenod(types[TINT32])));
diff --git a/src/pkg/runtime/arch_386.go b/src/pkg/runtime/arch_386.go
new file mode 100644
index 0000000000..32eafb549b
--- /dev/null
+++ b/src/pkg/runtime/arch_386.go
@@ -0,0 +1,9 @@
+// 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 runtime
+
+const (
+	cacheLineSize = 64
+)
diff --git a/src/pkg/runtime/arch_amd64.go b/src/pkg/runtime/arch_amd64.go
new file mode 100644
index 0000000000..32eafb549b
--- /dev/null
+++ b/src/pkg/runtime/arch_amd64.go
@@ -0,0 +1,9 @@
+// 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 runtime
+
+const (
+	cacheLineSize = 64
+)
diff --git a/src/pkg/runtime/arch_amd64p32.go b/src/pkg/runtime/arch_amd64p32.go
new file mode 100644
index 0000000000..32eafb549b
--- /dev/null
+++ b/src/pkg/runtime/arch_amd64p32.go
@@ -0,0 +1,9 @@
+// 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 runtime
+
+const (
+	cacheLineSize = 64
+)
diff --git a/src/pkg/runtime/arch_arm.go b/src/pkg/runtime/arch_arm.go
new file mode 100644
index 0000000000..7faeb94049
--- /dev/null
+++ b/src/pkg/runtime/arch_arm.go
@@ -0,0 +1,9 @@
+// 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 runtime
+
+const (
+	cacheLineSize = 32
+)
diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index f9a540af3d..bbf5e7aa83 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -168,7 +168,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		if t0 != 0 {
 			mysg.releasetime = -1
 		}
-		mysg.elem = (*uint8)(ep)
+		mysg.elem = ep
 		mysg.waitlink = nil
 		gp.waiting = mysg
 		mysg.g = gp
@@ -257,13 +257,13 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 }
 
 func (q *waitq) enqueue(sgp *sudog) {
-	sgp.link = nil
+	sgp.next = nil
 	if q.first == nil {
 		q.first = sgp
 		q.last = sgp
 		return
 	}
-	q.last.link = sgp
+	q.last.next = sgp
 	q.last = sgp
 }
 
@@ -273,7 +273,7 @@ func (q *waitq) dequeue() *sudog {
 		if sgp == nil {
 			return nil
 		}
-		q.first = sgp.link
+		q.first = sgp.next
 		if q.last == sgp {
 			q.last = nil
 		}
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 4d4f366efa..7d6ee1be2b 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -1089,7 +1089,7 @@ loop:
 	sgp = q->first;
 	if(sgp == nil)
 		return nil;
-	q->first = sgp->link;
+	q->first = sgp->next;
 	if(q->last == sgp)
 		q->last = nil;
 
@@ -1109,9 +1109,9 @@ dequeueg(WaitQ *q)
 	SudoG **l, *sgp, *prevsgp;
 
 	prevsgp = nil;
-	for(l=&q->first; (sgp=*l) != nil; l=&sgp->link, prevsgp=sgp) {
+	for(l=&q->first; (sgp=*l) != nil; l=&sgp->next, prevsgp=sgp) {
 		if(sgp->g == g) {
-			*l = sgp->link;
+			*l = sgp->next;
 			if(q->last == sgp)
 				q->last = prevsgp;
 			break;
@@ -1122,13 +1122,13 @@ dequeueg(WaitQ *q)
 static void
 enqueue(WaitQ *q, SudoG *sgp)
 {
-	sgp->link = nil;
+	sgp->next = nil;
 	if(q->first == nil) {
 		q->first = sgp;
 		q->last = sgp;
 		return;
 	}
-	q->last->link = sgp;
+	q->last->next = sgp;
 	q->last = sgp;
 }
 
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 7a3864f3bc..1ed6c26eba 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -68,7 +68,7 @@ func acquireSudog() *sudog {
 	c := gomcache()
 	s := c.sudogcache
 	if s != nil {
-		c.sudogcache = s.link
+		c.sudogcache = s.next
 		return s
 	}
 	return new(sudog)
@@ -77,6 +77,6 @@ func acquireSudog() *sudog {
 //go:nosplit
 func releaseSudog(s *sudog) {
 	c := gomcache()
-	s.link = c.sudogcache
+	s.next = c.sudogcache
 	c.sudogcache = s
 }
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index c96fc81417..d7709ae3c1 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -224,8 +224,9 @@ struct	SudoG
 {
 	G*	g;
 	uint32*	selectdone;
-	SudoG*	link;
-	byte*	elem;		// data element
+	SudoG*	next;
+	SudoG*	prev;
+	void*	elem;		// data element
 	int64	releasetime;
 	int32	nrelease;	// -1 for acquire
 	SudoG*	waitlink;	// G.waiting list
diff --git a/src/pkg/runtime/sema.go b/src/pkg/runtime/sema.go
index 1d591ffeba..a9ed7150d8 100644
--- a/src/pkg/runtime/sema.go
+++ b/src/pkg/runtime/sema.go
@@ -21,6 +21,159 @@ package runtime
 
 import "unsafe"
 
+// Asynchronous semaphore for sync.Mutex.
+
+type semaRoot struct {
+	lock
+	head  *sudog
+	tail  *sudog
+	nwait uint32 // Number of waiters. Read w/o the lock.
+}
+
+// Prime to not correlate with any user patterns.
+const semTabSize = 251
+
+var semtable [semTabSize]struct {
+	root semaRoot
+	pad  [cacheLineSize - unsafe.Sizeof(semaRoot{})]byte
+}
+
+// Called from sync/net packages.
+func asyncsemacquire(addr *uint32) {
+	semacquire(addr, true)
+}
+
+func asyncsemrelease(addr *uint32) {
+	semrelease(addr)
+}
+
+// Called from runtime.
+func semacquire(addr *uint32, profile bool) {
+	// Easy case.
+	if cansemacquire(addr) {
+		return
+	}
+
+	// Harder case:
+	//	increment waiter count
+	//	try cansemacquire one more time, return if succeeded
+	//	enqueue itself as a waiter
+	//	sleep
+	//	(waiter descriptor is dequeued by signaler)
+	s := acquireSudog()
+	root := semroot(addr)
+	t0 := int64(0)
+	s.releasetime = 0
+	if profile && blockprofilerate > 0 {
+		t0 = gocputicks()
+		s.releasetime = -1
+	}
+	for {
+		golock(&root.lock)
+		// Add ourselves to nwait to disable "easy case" in semrelease.
+		goxadd(&root.nwait, 1)
+		// Check cansemacquire to avoid missed wakeup.
+		if cansemacquire(addr) {
+			goxadd(&root.nwait, ^uint32(0))
+			gounlock(&root.lock)
+			break
+		}
+		// Any semrelease after the cansemacquire knows we're waiting
+		// (we set nwait above), so go to sleep.
+		root.queue(addr, s)
+		goparkunlock(&root.lock, "semacquire")
+		if cansemacquire(addr) {
+			break
+		}
+	}
+	if s.releasetime > 0 {
+		goblockevent(int64(s.releasetime)-t0, 4)
+	}
+	releaseSudog(s)
+}
+
+func semrelease(addr *uint32) {
+	root := semroot(addr)
+	goxadd(addr, 1)
+
+	// Easy case: no waiters?
+	// This check must happen after the xadd, to avoid a missed wakeup
+	// (see loop in semacquire).
+	if goatomicload(&root.nwait) == 0 {
+		return
+	}
+
+	// Harder case: search for a waiter and wake it.
+	golock(&root.lock)
+	if goatomicload(&root.nwait) == 0 {
+		// The count is already consumed by another goroutine,
+		// so no need to wake up another goroutine.
+		gounlock(&root.lock)
+		return
+	}
+	s := root.head
+	for ; s != nil; s = s.next {
+		if s.elem == unsafe.Pointer(addr) {
+			goxadd(&root.nwait, ^uint32(0))
+			root.dequeue(s)
+			break
+		}
+	}
+	gounlock(&root.lock)
+	if s != nil {
+		if s.releasetime != 0 {
+			// TODO: Remove use of unsafe here.
+			releasetimep := (*int64)(unsafe.Pointer(&s.releasetime))
+			*releasetimep = gocputicks()
+		}
+		goready(s.g)
+	}
+}
+
+func semroot(addr *uint32) *semaRoot {
+	return &semtable[(uintptr(unsafe.Pointer(addr))>>3)%semTabSize].root
+}
+
+func cansemacquire(addr *uint32) bool {
+	for {
+		v := goatomicload(addr)
+		if v == 0 {
+			return false
+		}
+		if gocas(addr, v, v-1) {
+			return true
+		}
+	}
+}
+
+func (root *semaRoot) queue(addr *uint32, s *sudog) {
+	s.g = getg()
+	s.elem = unsafe.Pointer(addr)
+	s.next = nil
+	s.prev = root.tail
+	if root.tail != nil {
+		root.tail.next = s
+	} else {
+		root.head = s
+	}
+	root.tail = s
+}
+
+func (root *semaRoot) dequeue(s *sudog) {
+	if s.next != nil {
+		s.next.prev = s.prev
+	} else {
+		root.tail = s.prev
+	}
+	if s.prev != nil {
+		s.prev.next = s.next
+	} else {
+		root.head = s.next
+	}
+	s.next = nil
+	s.prev = nil
+}
+
 // Synchronous semaphore for sync.Cond.
 type syncSema struct {
 	lock lock
@@ -37,7 +190,7 @@ func syncsemacquire(s *syncSema) {
 		s.head.nrelease--
 		if s.head.nrelease == 0 {
 			wake = s.head
-			s.head = wake.link
+			s.head = wake.next
 			if s.head == nil {
 				s.tail = nil
 			}
@@ -51,7 +204,7 @@ func syncsemacquire(s *syncSema) {
 		w := acquireSudog()
 		w.g = getg()
 		w.nrelease = -1
-		w.link = nil
+		w.next = nil
 		w.releasetime = 0
 		t0 := int64(0)
 		if blockprofilerate > 0 {
@@ -61,7 +214,7 @@ func syncsemacquire(s *syncSema) {
 		if s.tail == nil {
 			s.head = w
 		} else {
-			s.tail.link = w
+			s.tail.next = w
 		}
 		s.tail = w
 		goparkunlock(&s.lock, "semacquire")
@@ -78,7 +231,7 @@ func syncsemrelease(s *syncSema, n uint32) {
 	for n > 0 && s.head != nil && s.head.nrelease < 0 {
 		// Have pending acquire, satisfy it.
 		wake := s.head
-		s.head = wake.link
+		s.head = wake.next
 		if s.head == nil {
 			s.tail = nil
 		}
@@ -95,12 +248,12 @@ func syncsemrelease(s *syncSema, n uint32) {
 		w := acquireSudog()
 		w.g = getg()
 		w.nrelease = int32(n)
-		w.link = nil
+		w.next = nil
 		w.releasetime = 0
 		if s.tail == nil {
 			s.head = w
 		} else {
-			s.tail.link = w
+			s.tail.next = w
 		}
 		s.tail = w
 		goparkunlock(&s.lock, "semarelease")
diff --git a/src/pkg/runtime/sema.goc b/src/pkg/runtime/sema.goc
deleted file mode 100644
index 7724566a1e..0000000000
--- a/src/pkg/runtime/sema.goc
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Semaphore implementation exposed to Go.
-// Intended use is provide a sleep and wakeup
-// primitive that can be used in the contended case
-// of other synchronization primitives.
-// Thus it targets the same goal as Linux's futex,
-// but it has much simpler semantics.
-//
-// That is, don't think of these as semaphores.
-// Think of them as a way to implement sleep and wakeup
-// such that every sleep is paired with a single wakeup,
-// even if, due to races, the wakeup happens before the sleep.
-//
-// See Mullender and Cox, ``Semaphores in Plan 9,''
-// http://swtch.com/semaphore.pdf
-
-package sync
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
-
-typedef struct SemaWaiter SemaWaiter;
-struct SemaWaiter
-{
-	uint32 volatile*	addr;
-	G*	g;
-	int64	releasetime;
-	int32	nrelease;	// -1 for acquire
-	SemaWaiter*	prev;
-	SemaWaiter*	next;
-};
-
-typedef struct SemaRoot SemaRoot;
-struct SemaRoot
-{
-	Lock		lock;
-	SemaWaiter*	head;
-	SemaWaiter*	tail;
-	// Number of waiters. Read w/o the lock.
-	uint32 volatile	nwait;
-};
-
-// Prime to not correlate with any user patterns.
-#define SEMTABLESZ 251
-
-struct semtable
-{
-	SemaRoot root;
-	uint8 pad[CacheLineSize-sizeof(SemaRoot)];
-};
-#pragma dataflag NOPTR /* mark semtable as 'no pointers', hiding from garbage collector */
-static struct semtable semtable[SEMTABLESZ];
-
-static SemaRoot*
-semroot(uint32 *addr)
-{
-	return &semtable[((uintptr)addr >> 3) % SEMTABLESZ].root;
-}
-
-static void
-semqueue(SemaRoot *root, uint32 volatile *addr, SemaWaiter *s)
-{
-	s->g = g;
-	s->addr = addr;
-	s->next = nil;
-	s->prev = root->tail;
-	if(root->tail)
-		root->tail->next = s;
-	else
-		root->head = s;
-	root->tail = s;
-}
-
-static void
-semdequeue(SemaRoot *root, SemaWaiter *s)
-{
-	if(s->next)
-		s->next->prev = s->prev;
-	else
-		root->tail = s->prev;
-	if(s->prev)
-		s->prev->next = s->next;
-	else
-		root->head = s->next;
-	s->prev = nil;
-	s->next = nil;
-}
-
-static int32
-cansemacquire(uint32 *addr)
-{
-	uint32 v;
-
-	while((v = runtime·atomicload(addr)) > 0)
-		if(runtime·cas(addr, v, v-1))
-			return 1;
-	return 0;
-}
-
-void
-runtime·semacquire(uint32 volatile *addr, bool profile)
-{
-	SemaWaiter s;	// Needs to be allocated on stack, otherwise garbage collector could deallocate it
-	SemaRoot *root;
-	int64 t0;
-	
-	// Easy case.
-	if(cansemacquire(addr))
-		return;
-
-	// Harder case:
-	//	increment waiter count
-	//	try cansemacquire one more time, return if succeeded
-	//	enqueue itself as a waiter
-	//	sleep
-	//	(waiter descriptor is dequeued by signaler)
-	root = semroot(addr);
-	t0 = 0;
-	s.releasetime = 0;
-	if(profile && runtime·blockprofilerate > 0) {
-		t0 = runtime·cputicks();
-		s.releasetime = -1;
-	}
-	for(;;) {
-		runtime·lock(&root->lock);
-		// Add ourselves to nwait to disable "easy case" in semrelease.
-		runtime·xadd(&root->nwait, 1);
-		// Check cansemacquire to avoid missed wakeup.
-		if(cansemacquire(addr)) {
-			runtime·xadd(&root->nwait, -1);
-			runtime·unlock(&root->lock);
-			return;
-		}
-		// Any semrelease after the cansemacquire knows we're waiting
-		// (we set nwait above), so go to sleep.
-		semqueue(root, addr, &s);
-		runtime·parkunlock(&root->lock, runtime·gostringnocopy((byte*)"semacquire"));
-		if(cansemacquire(addr)) {
-			if(t0)
-				runtime·blockevent(s.releasetime - t0, 3);
-			return;
-		}
-	}
-}
-
-void
-runtime·semrelease(uint32 volatile *addr)
-{
-	SemaWaiter *s;
-	SemaRoot *root;
-
-	root = semroot(addr);
-	runtime·xadd(addr, 1);
-
-	// Easy case: no waiters?
-	// This check must happen after the xadd, to avoid a missed wakeup
-	// (see loop in semacquire).
-	if(runtime·atomicload(&root->nwait) == 0)
-		return;
-
-	// Harder case: search for a waiter and wake it.
-	runtime·lock(&root->lock);
-	if(runtime·atomicload(&root->nwait) == 0) {
-		// The count is already consumed by another goroutine,
-		// so no need to wake up another goroutine.
-		runtime·unlock(&root->lock);
-		return;
-	}
-	for(s = root->head; s; s = s->next) {
-		if(s->addr == addr) {
-			runtime·xadd(&root->nwait, -1);
-			semdequeue(root, s);
-			break;
-		}
-	}
-	runtime·unlock(&root->lock);
-	if(s) {
-		if(s->releasetime)
-			s->releasetime = runtime·cputicks();
-		runtime·ready(s->g);
-	}
-}
-
-// TODO(dvyukov): move to netpoll.goc once it's used by all OSes.
-void net·runtime_Semacquire(uint32 *addr)
-{
-	runtime·semacquire(addr, true);
-}
-
-void net·runtime_Semrelease(uint32 *addr)
-{
-	runtime·semrelease(addr);
-}
-
-func runtime_Semacquire(addr *uint32) {
-	runtime·semacquire(addr, true);
-}
-
-func runtime_Semrelease(addr *uint32) {
-	runtime·semrelease(addr);
-}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 37e768a4ec..6cabed063e 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -116,7 +116,9 @@ const (
 
 // Atomic operations to read/write a pointer.
 // in stubs.goc
+func goatomicload(p *uint32) uint32                     // return *p
 func goatomicloadp(p unsafe.Pointer) unsafe.Pointer     // return *p
+func goatomicstore(p *uint32, v uint32)                 // *p = v
 func goatomicstorep(p unsafe.Pointer, v unsafe.Pointer) // *p = v
 
 // in stubs.goc
@@ -124,6 +126,9 @@ func goatomicstorep(p unsafe.Pointer, v unsafe.Pointer) // *p = v
 //go:noescape
 func gocas(p *uint32, x uint32, y uint32) bool
 
+//go:noescape
+func goxadd(p *uint32, x uint32) uint32
+
 //go:noescape
 func gocasx(p *uintptr, x uintptr, y uintptr) bool
 
@@ -151,8 +156,6 @@ func gothrow(s string)
 
 func golock(x *lock)
 func gounlock(x *lock)
-func semacquire(*uint32, bool)
-func semrelease(*uint32)
 
 // Return the Go equivalent of the C Alg structure.
 // TODO: at some point Go will hold the truth for the layout
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index 74762dab8a..b30c40286c 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -48,16 +48,31 @@ func gonanotime() (r int64) {
 	r = runtime·nanotime();
 }
 
+#pragma textflag NOSPLIT
+func goatomicload(p *uint32) (v uint32) {
+	v = runtime·atomicload(p);
+}
+
 #pragma textflag NOSPLIT
 func goatomicloadp(p **byte) (v *byte) {
 	v = runtime·atomicloadp(p);
 }
 
+#pragma textflag NOSPLIT
+func goatomicstore(p *uint32, v uint32) {
+	runtime·atomicstore(p, v);
+}
+
 #pragma textflag NOSPLIT
 func goatomicstorep(p **byte, v *byte) {
 	runtime·atomicstorep(p, v);
 }
 
+#pragma textflag NOSPLIT
+func runtime·goxadd(p *uint32, x uint32) (ret uint32) {
+	ret = runtime·xadd(p, x);
+}
+
 #pragma textflag NOSPLIT
 func runtime·gocas(p *uint32, x uint32, y uint32) (ret bool) {
 	ret = runtime·cas(p, x, y);
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 2a48f5ff23..b54d9eded9 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -19,3 +19,15 @@ TEXT sync·runtime_Syncsemrelease(SB),NOSPLIT,$0-0
 
 TEXT sync·runtime_Syncsemcheck(SB),NOSPLIT,$0-0
 	JMP	runtime·syncsemcheck(SB)
+
+TEXT sync·runtime_Semacquire(SB),NOSPLIT,$0-0
+	JMP	runtime·asyncsemacquire(SB)
+
+TEXT sync·runtime_Semrelease(SB),NOSPLIT,$0-0
+	JMP	runtime·asyncsemrelease(SB)
+
+TEXT net·runtime_Semacquire(SB),NOSPLIT,$0-0
+	JMP	runtime·asyncsemacquire(SB)
+
+TEXT net·runtime_Semrelease(SB),NOSPLIT,$0-0
+	JMP	runtime·asyncsemrelease(SB)

From 9601abaf8b3d454f6bf84ba9f5e07c11de16ef14 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 20:25:22 +0400
Subject: [PATCH 200/423] runtime: convert timers to Go

LGTM=rsc
R=golang-codereviews, ruiu, rsc, daniel.morsing
CC=golang-codereviews, khr
https://golang.org/cl/123700044
---
 src/pkg/runtime/mgc0.c      |  10 ++
 src/pkg/runtime/netpoll.goc |  15 ++
 src/pkg/runtime/runtime.h   |  33 ----
 src/pkg/runtime/thunk.s     |  12 ++
 src/pkg/runtime/time.go     | 263 +++++++++++++++++++++++++++
 src/pkg/runtime/time.goc    | 341 ------------------------------------
 src/pkg/syscall/net_nacl.go |   2 +-
 src/pkg/time/sleep.go       |   2 +-
 8 files changed, 302 insertions(+), 376 deletions(-)
 create mode 100644 src/pkg/runtime/time.go
 delete mode 100644 src/pkg/runtime/time.goc

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index ded41510c4..86470c182b 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -2130,3 +2130,13 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		}
 	}
 }
+
+void runtime·gc_unixnanotime(int64 *now);
+
+int64 runtime·unixnanotime(void)
+{
+	int64 now;
+
+	runtime·gc_unixnanotime(&now);
+	return now;
+}
diff --git a/src/pkg/runtime/netpoll.goc b/src/pkg/runtime/netpoll.goc
index e8ae84f127..46e0dfb330 100644
--- a/src/pkg/runtime/netpoll.goc
+++ b/src/pkg/runtime/netpoll.goc
@@ -39,6 +39,21 @@ enum
 	PollBlockSize	= 4*1024,
 };
 
+// time.go defines the layout of this structure.
+// Keep in sync with time.go.
+typedef struct Timer Timer;
+struct Timer
+{
+	intgo	i;
+	int64	when;
+	int64	period;
+	FuncVal	*fv;
+	Eface	arg;
+};
+
+void	runtime·addtimer(Timer*);
+void	runtime·deltimer(Timer*);
+
 struct PollDesc
 {
 	PollDesc* link;	// in pollcache, protected by pollcache.Lock
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index d7709ae3c1..beafc76637 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -92,8 +92,6 @@ typedef	struct	Complex64	Complex64;
 typedef	struct	Complex128	Complex128;
 typedef	struct	LibCall		LibCall;
 typedef	struct	WinCallbackContext	WinCallbackContext;
-typedef	struct	Timers		Timers;
-typedef	struct	Timer		Timer;
 typedef	struct	GCStats		GCStats;
 typedef	struct	LFNode		LFNode;
 typedef	struct	ParFor		ParFor;
@@ -519,35 +517,6 @@ enum {
 };
 #endif
 
-struct	Timers
-{
-	Lock	lock;
-	G	*timerproc;
-	bool		sleeping;
-	bool		rescheduling;
-	Note	waitnote;
-	Timer	**t;
-	int32	len;
-	int32	cap;
-};
-
-// Package time knows the layout of this structure.
-// If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
-// For GOOS=nacl, package syscall knows the layout of this structure.
-// If this struct changes, adjust ../syscall/net_nacl.go:/runtimeTimer.
-struct	Timer
-{
-	int32	i;	// heap index
-
-	// Timer wakes up at when, and then at when+period, ... (period > 0 only)
-	// each time calling f(now, arg) in the timer goroutine, so f must be
-	// a well-behaved function and not block.
-	int64	when;
-	int64	period;
-	FuncVal	*fv;
-	Eface	arg;
-};
-
 // Lock-free stack node.
 struct LFNode
 {
@@ -965,8 +934,6 @@ int64	runtime·cputicks(void);
 int64	runtime·tickspersecond(void);
 void	runtime·blockevent(int64, int32);
 extern int64 runtime·blockprofilerate;
-void	runtime·addtimer(Timer*);
-bool	runtime·deltimer(Timer*);
 G*	runtime·netpoll(bool);
 void	runtime·netpollinit(void);
 int32	runtime·netpollopen(uintptr, PollDesc*);
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index b54d9eded9..1f83438ef4 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -11,6 +11,18 @@
 #define JMP B
 #endif
 
+TEXT time·runtimeNano(SB),NOSPLIT,$0-0
+	JMP     runtime·gonanotime(SB)
+
+TEXT time·Sleep(SB),NOSPLIT,$0-0
+	JMP     runtime·timeSleep(SB)
+
+TEXT time·startTimer(SB),NOSPLIT,$0-0
+	JMP     runtime·startTimer(SB)
+
+TEXT time·stopTimer(SB),NOSPLIT,$0-0
+	JMP     runtime·stopTimer(SB)
+
 TEXT sync·runtime_Syncsemacquire(SB),NOSPLIT,$0-0
 	JMP	runtime·syncsemacquire(SB)
 
diff --git a/src/pkg/runtime/time.go b/src/pkg/runtime/time.go
new file mode 100644
index 0000000000..9430414cea
--- /dev/null
+++ b/src/pkg/runtime/time.go
@@ -0,0 +1,263 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Time-related runtime and pieces of package time.
+
+package runtime
+
+import "unsafe"
+
+// Package time knows the layout of this structure.
+// If this struct changes, adjust ../time/sleep.go:/runtimeTimer and netpoll.goc:/timer.
+// For GOOS=nacl, package syscall knows the layout of this structure.
+// If this struct changes, adjust ../syscall/net_nacl.go:/runtimeTimer.
+type timer struct {
+	i int // heap index
+
+	// Timer wakes up at when, and then at when+period, ... (period > 0 only)
+	// each time calling f(now, arg) in the timer goroutine, so f must be
+	// a well-behaved function and not block.
+	when   int64
+	period int64
+	f      func(interface{})
+	arg    interface{}
+}
+
+var timers struct {
+	lock         lock
+	gp           *g
+	created      bool
+	sleeping     bool
+	rescheduling bool
+	waitnote     note
+	t            []*timer
+}
+
+// Package time APIs.
+// Godoc uses the comments in package time, not these.
+
+// time.now is implemented in assembly.
+
+// Sleep puts the current goroutine to sleep for at least ns nanoseconds.
+func timeSleep(ns int64) {
+	if ns <= 0 {
+		return
+	}
+
+	t := new(timer)
+	t.when = gonanotime() + ns
+	t.f = goroutineReady
+	t.arg = getg()
+	golock(&timers.lock)
+	addtimerLocked(t)
+	goparkunlock(&timers.lock, "sleep")
+}
+
+// startTimer adds t to the timer heap.
+func startTimer(t *timer) {
+	if raceenabled {
+		racerelease(unsafe.Pointer(t))
+	}
+	addtimer(t)
+}
+
+// stopTimer removes t from the timer heap if it is there.
+// It returns true if t was removed, false if t wasn't even there.
+func stopTimer(t *timer) bool {
+	return deltimer(t)
+}
+
+// Go runtime.
+
+// Ready the goroutine arg.
+func goroutineReady(arg interface{}) {
+	goready(arg.(*g))
+}
+
+func addtimer(t *timer) {
+	golock(&timers.lock)
+	addtimerLocked(t)
+	gounlock(&timers.lock)
+}
+
+// Add a timer to the heap and start or kick the timer proc.
+// If the new timer is earlier than any of the others.
+// Timers are locked.
+func addtimerLocked(t *timer) {
+	// when must never be negative; otherwise timerproc will overflow
+	// during its delta calculation and never expire other runtime·timers.
+	if t.when < 0 {
+		t.when = 1<<63 - 1
+	}
+	t.i = len(timers.t)
+	timers.t = append(timers.t, t)
+	siftupTimer(t.i)
+	if t.i == 0 {
+		// siftup moved to top: new earliest deadline.
+		if timers.sleeping {
+			timers.sleeping = false
+			gonotewakeup(&timers.waitnote)
+		}
+		if timers.rescheduling {
+			timers.rescheduling = false
+			goready(timers.gp)
+		}
+	}
+	if !timers.created {
+		timers.created = true
+		go timerproc()
+	}
+}
+
+// Delete timer t from the heap.
+// Do not need to update the timerproc: if it wakes up early, no big deal.
+func deltimer(t *timer) bool {
+	// Dereference t so that any panic happens before the lock is held.
+	// Discard result, because t might be moving in the heap.
+	_ = t.i
+
+	golock(&timers.lock)
+	// t may not be registered anymore and may have
+	// a bogus i (typically 0, if generated by Go).
+	// Verify it before proceeding.
+	i := t.i
+	last := len(timers.t) - 1
+	if i < 0 || i > last || timers.t[i] != t {
+		gounlock(&timers.lock)
+		return false
+	}
+	if i != last {
+		timers.t[i] = timers.t[last]
+		timers.t[i].i = i
+	}
+	timers.t[last] = nil
+	timers.t = timers.t[:last]
+	if i != last {
+		siftupTimer(i)
+		siftdownTimer(i)
+	}
+	gounlock(&timers.lock)
+	return true
+}
+
+// Timerproc runs the time-driven events.
+// It sleeps until the next event in the timers heap.
+// If addtimer inserts a new earlier event, addtimer1 wakes timerproc early.
+func timerproc() {
+	timers.gp = getg()
+	timers.gp.issystem = 1
+	for {
+		golock(&timers.lock)
+		timers.sleeping = false
+		now := gonanotime()
+		delta := int64(-1)
+		for {
+			if len(timers.t) == 0 {
+				delta = -1
+				break
+			}
+			t := timers.t[0]
+			delta = t.when - now
+			if delta > 0 {
+				break
+			}
+			if t.period > 0 {
+				// leave in heap but adjust next time to fire
+				t.when += t.period * (1 + -delta/t.period)
+				siftdownTimer(0)
+			} else {
+				// remove from heap
+				last := len(timers.t) - 1
+				if last > 0 {
+					timers.t[0] = timers.t[last]
+					timers.t[0].i = 0
+				}
+				timers.t[last] = nil
+				timers.t = timers.t[:last]
+				if last > 0 {
+					siftdownTimer(0)
+				}
+				t.i = -1 // mark as removed
+			}
+			f := t.f
+			arg := t.arg
+			gounlock(&timers.lock)
+			if raceenabled {
+				raceacquire(unsafe.Pointer(t))
+			}
+			f(arg)
+			golock(&timers.lock)
+		}
+		if delta < 0 {
+			// No timers left - put goroutine to sleep.
+			timers.rescheduling = true
+			timers.gp.isbackground = 1
+			goparkunlock(&timers.lock, "timer goroutine (idle)")
+			timers.gp.isbackground = 0
+			continue
+		}
+		// At least one timer pending.  Sleep until then.
+		timers.sleeping = true
+		gonoteclear(&timers.waitnote)
+		gounlock(&timers.lock)
+		gonotetsleepg(&timers.waitnote, delta)
+	}
+}
+
+// Heap maintenance algorithms.
+
+func siftupTimer(i int) {
+	t := timers.t
+	when := t[i].when
+	tmp := t[i]
+	for i > 0 {
+		p := (i - 1) / 4 // parent
+		if when >= t[p].when {
+			break
+		}
+		t[i] = t[p]
+		t[i].i = i
+		t[p] = tmp
+		t[p].i = p
+		i = p
+	}
+}
+
+func siftdownTimer(i int) {
+	t := timers.t
+	n := len(t)
+	when := t[i].when
+	tmp := t[i]
+	for {
+		c := i*4 + 1 // left child
+		c3 := c + 2  // mid child
+		if c >= n {
+			break
+		}
+		w := t[c].when
+		if c+1 < n && t[c+1].when < w {
+			w = t[c+1].when
+			c++
+		}
+		if c3 < n {
+			w3 := t[c3].when
+			if c3+1 < n && t[c3+1].when < w3 {
+				w3 = t[c3+1].when
+				c3++
+			}
+			if w3 < w {
+				w = w3
+				c = c3
+			}
+		}
+		if w >= when {
+			break
+		}
+		t[i] = t[c]
+		t[i].i = i
+		t[c] = tmp
+		t[c].i = c
+		i = c
+	}
+}
diff --git a/src/pkg/runtime/time.goc b/src/pkg/runtime/time.goc
deleted file mode 100644
index 1d6346233c..0000000000
--- a/src/pkg/runtime/time.goc
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Time-related runtime and pieces of package time.
-
-package time
-
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "race.h"
-
-enum {
-	debug = 0,
-};
-
-static Timers timers;
-static void addtimer(Timer*);
-static void dumptimers(int8*);
-
-// nacl fake time support. 
-int64 runtime·timens;
-
-// Package time APIs.
-// Godoc uses the comments in package time, not these.
-
-// time.now is implemented in assembly.
-
-// runtimeNano returns the current value of the runtime clock in nanoseconds.
-func runtimeNano() (ns int64) {
-	ns = runtime·nanotime();
-}
-
-// Sleep puts the current goroutine to sleep for at least ns nanoseconds.
-func Sleep(ns int64) {
-	runtime·tsleep(ns, runtime·gostringnocopy((byte*)"sleep"));
-}
-
-// startTimer adds t to the timer heap.
-func startTimer(t *Timer) {
-	if(raceenabled)
-		runtime·racerelease(t);
-	runtime·addtimer(t);
-}
-
-// stopTimer removes t from the timer heap if it is there.
-// It returns true if t was removed, false if t wasn't even there.
-func stopTimer(t *Timer) (stopped bool) {
-	stopped = runtime·deltimer(t);
-}
-
-// C runtime.
-
-void runtime·gc_unixnanotime(int64 *now);
-
-int64 runtime·unixnanotime(void)
-{
-	int64 now;
-
-	runtime·gc_unixnanotime(&now);
-	return now;
-}
-
-static void timerproc(void);
-static void siftup(int32);
-static void siftdown(int32);
-
-// Ready the goroutine e.data.
-static void
-ready(Eface e)
-{
-	runtime·ready(e.data);
-}
-
-static FuncVal readyv = {(void(*)(void))ready};
-
-// Put the current goroutine to sleep for ns nanoseconds.
-void
-runtime·tsleep(int64 ns, String reason)
-{
-	Timer t;
-
-	if(ns <= 0)
-		return;
-
-	t.when = runtime·nanotime() + ns;
-	t.period = 0;
-	t.fv = &readyv;
-	t.arg.data = g;
-	runtime·lock(&timers.lock);
-	addtimer(&t);
-	runtime·parkunlock(&timers.lock, reason);
-}
-
-static FuncVal timerprocv = {timerproc};
-
-void
-runtime·addtimer(Timer *t)
-{
-	runtime·lock(&timers.lock);
-	addtimer(t);
-	runtime·unlock(&timers.lock);
-}
-
-// Add a timer to the heap and start or kick the timer proc
-// if the new timer is earlier than any of the others.
-static void
-addtimer(Timer *t)
-{
-	int32 n;
-	Timer **nt;
-
-	// when must never be negative; otherwise timerproc will overflow
-	// during its delta calculation and never expire other timers.
-	if(t->when < 0)
-		t->when = (1LL<<63)-1;
-
-	if(timers.len >= timers.cap) {
-		// Grow slice.
-		n = 16;
-		if(n <= timers.cap)
-			n = timers.cap*3 / 2;
-		nt = runtime·mallocgc(n*sizeof nt[0], nil, 0);
-		runtime·memmove(nt, timers.t, timers.len*sizeof nt[0]);
-		timers.t = nt;
-		timers.cap = n;
-	}
-	t->i = timers.len++;
-	timers.t[t->i] = t;
-	siftup(t->i);
-	if(t->i == 0) {
-		// siftup moved to top: new earliest deadline.
-		if(timers.sleeping) {
-			timers.sleeping = false;
-			runtime·notewakeup(&timers.waitnote);
-		}
-		if(timers.rescheduling) {
-			timers.rescheduling = false;
-			runtime·ready(timers.timerproc);
-		}
-	}
-	if(timers.timerproc == nil) {
-		timers.timerproc = runtime·newproc1(&timerprocv, nil, 0, 0, addtimer);
-		timers.timerproc->issystem = true;
-	}
-	if(debug)
-		dumptimers("addtimer");
-}
-
-// Delete timer t from the heap.
-// Do not need to update the timerproc:
-// if it wakes up early, no big deal.
-bool
-runtime·deltimer(Timer *t)
-{
-	int32 i;
-
-	// Dereference t so that any panic happens before the lock is held.
-	// Discard result, because t might be moving in the heap.
-	i = t->i;
-	USED(i);
-
-	runtime·lock(&timers.lock);
-
-	// t may not be registered anymore and may have
-	// a bogus i (typically 0, if generated by Go).
-	// Verify it before proceeding.
-	i = t->i;
-	if(i < 0 || i >= timers.len || timers.t[i] != t) {
-		runtime·unlock(&timers.lock);
-		return false;
-	}
-
-	timers.len--;
-	if(i == timers.len) {
-		timers.t[i] = nil;
-	} else {
-		timers.t[i] = timers.t[timers.len];
-		timers.t[timers.len] = nil;
-		timers.t[i]->i = i;
-		siftup(i);
-		siftdown(i);
-	}
-	if(debug)
-		dumptimers("deltimer");
-	runtime·unlock(&timers.lock);
-	return true;
-}
-
-// Timerproc runs the time-driven events.
-// It sleeps until the next event in the timers heap.
-// If addtimer inserts a new earlier event, addtimer
-// wakes timerproc early.
-static void
-timerproc(void)
-{
-	int64 delta, now;
-	Timer *t;
-	void (*f)(Eface);
-	Eface arg;
-
-	for(;;) {
-		runtime·lock(&timers.lock);
-		timers.sleeping = false;
-		now = runtime·nanotime();
-		for(;;) {
-			if(timers.len == 0) {
-				delta = -1;
-				break;
-			}
-			t = timers.t[0];
-			delta = t->when - now;
-			if(delta > 0)
-				break;
-			if(t->period > 0) {
-				// leave in heap but adjust next time to fire
-				t->when += t->period * (1 + -delta/t->period);
-				siftdown(0);
-			} else {
-				// remove from heap
-				timers.t[0] = timers.t[--timers.len];
-				timers.t[0]->i = 0;
-				siftdown(0);
-				t->i = -1;  // mark as removed
-			}
-			f = (void*)t->fv->fn;
-			arg = t->arg;
-			runtime·unlock(&timers.lock);
-			if(raceenabled)
-				runtime·raceacquire(t);
-			f(arg);
-
-			// clear f and arg to avoid leak while sleeping for next timer
-			f = nil;
-			USED(f);
-			arg.type = nil;
-			arg.data = nil;
-			USED(&arg);
-
-			runtime·lock(&timers.lock);
-		}
-		if(delta < 0) {
-			// No timers left - put goroutine to sleep.
-			timers.rescheduling = true;
-			g->isbackground = true;
-			runtime·parkunlock(&timers.lock, runtime·gostringnocopy((byte*)"timer goroutine (idle)"));
-			g->isbackground = false;
-			continue;
-		}
-		// At least one timer pending.  Sleep until then.
-		timers.sleeping = true;
-		runtime·noteclear(&timers.waitnote);
-		runtime·unlock(&timers.lock);
-		runtime·notetsleepg(&timers.waitnote, delta);
-	}
-}
-
-// heap maintenance algorithms.
-
-static void
-siftup(int32 i)
-{
-	int32 p;
-	int64 when;
-	Timer **t, *tmp;
-
-	t = timers.t;
-	when = t[i]->when;
-	tmp = t[i];
-	while(i > 0) {
-		p = (i-1)/4;  // parent
-		if(when >= t[p]->when)
-			break;
-		t[i] = t[p];
-		t[i]->i = i;
-		t[p] = tmp;
-		tmp->i = p;
-		i = p;
-	}
-}
-
-static void
-siftdown(int32 i)
-{
-	int32 c, c3, len;
-	int64 when, w, w3;
-	Timer **t, *tmp;
-
-	t = timers.t;
-	len = timers.len;
-	when = t[i]->when;
-	tmp = t[i];
-	for(;;) {
-		c = i*4 + 1;  // left child
-		c3 = c + 2;  // mid child
-		if(c >= len) {
-			break;
-		}
-		w = t[c]->when;
-		if(c+1 < len && t[c+1]->when < w) {
-			w = t[c+1]->when;
-			c++;
-		}
-		if(c3 < len) {
-			w3 = t[c3]->when;
-			if(c3+1 < len && t[c3+1]->when < w3) {
-				w3 = t[c3+1]->when;
-				c3++;
-			}
-			if(w3 < w) {
-				w = w3;
-				c = c3;
-			}
-		}
-		if(w >= when)
-			break;
-		t[i] = t[c];
-		t[i]->i = i;
-		t[c] = tmp;
-		tmp->i = c;
-		i = c;
-	}
-}
-
-static void
-dumptimers(int8 *msg)
-{
-	Timer *t;
-	int32 i;
-
-	runtime·printf("timers: %s\n", msg);
-	for(i = 0; i < timers.len; i++) {
-		t = timers.t[i];
-		runtime·printf("\t%d\t%p:\ti %d when %D period %D fn %p\n",
-				i, t, t->i, t->when, t->period, t->fv->fn);
-	}
-	runtime·printf("\n");
-}
diff --git a/src/pkg/syscall/net_nacl.go b/src/pkg/syscall/net_nacl.go
index f85b2e1f72..07d52f4525 100644
--- a/src/pkg/syscall/net_nacl.go
+++ b/src/pkg/syscall/net_nacl.go
@@ -18,7 +18,7 @@ import (
 // Really for use by package time, but we cannot import time here.
 
 type runtimeTimer struct {
-	i      int32
+	i      int
 	when   int64
 	period int64
 	f      func(interface{}) // NOTE: must not be closure
diff --git a/src/pkg/time/sleep.go b/src/pkg/time/sleep.go
index 0fd7c9328e..c7b019feb0 100644
--- a/src/pkg/time/sleep.go
+++ b/src/pkg/time/sleep.go
@@ -14,7 +14,7 @@ func runtimeNano() int64
 // Interface to timers implemented in package runtime.
 // Must be in sync with ../runtime/runtime.h:/^struct.Timer$
 type runtimeTimer struct {
-	i      int32
+	i      int
 	when   int64
 	period int64
 	f      func(interface{}) // NOTE: must not be closure

From 4064d5e9a3dce1b88866f1364a94a02f13db6162 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 20:26:32 +0400
Subject: [PATCH 201/423] runtime: add comment Explain why it's safe to
 allocate chans with flagNoScan.

LGTM=rsc
R=golang-codereviews
CC=golang-codereviews, khr, rsc
https://golang.org/cl/125510045
---
 src/pkg/runtime/chan.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index bbf5e7aa83..d3fcc6d13f 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -33,7 +33,11 @@ func makechan(t *chantype, size int64) *hchan {
 
 	var c *hchan
 	if elem.kind&kindNoPointers != 0 || size == 0 {
-		// allocate memory in one call
+		// Allocate memory in one call.
+		// Hchan does not contain pointers interesting for GC in this case:
+		// buf points into the same allocation, elemtype is persistent
+		// and SudoG's are referenced from G so can't be collected.
+		// TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
 		c = (*hchan)(gomallocgc(hchanSize+uintptr(size)*uintptr(elem.size), nil, flagNoScan))
 		if size > 0 && elem.size != 0 {
 			c.buf = (*uint8)(add(unsafe.Pointer(c), hchanSize))

From b83d8bd0b85ff8b60a113bac841bfaf4cce52e3c Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 20:59:52 +0400
Subject: [PATCH 202/423] runtime: remove dedicated scavenger thread A whole
 thread is too much for background scavenger that sleeps all the time anyway.
 We already have sysmon thread that can do this work. Also remove
 g->isbackground and simplify enter/exitsyscall.

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr, rlh
https://golang.org/cl/108640043
---
 src/pkg/runtime/heapdump.c |  2 +-
 src/pkg/runtime/malloc.h   |  2 +-
 src/pkg/runtime/mgc0.c     |  8 ++--
 src/pkg/runtime/mheap.c    | 72 +++-------------------------------
 src/pkg/runtime/proc.c     | 80 +++++++++++++++++++++++++++++++-------
 src/pkg/runtime/runtime.h  |  3 +-
 src/pkg/runtime/time.go    |  2 -
 7 files changed, 77 insertions(+), 92 deletions(-)

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 3fc54aedbc..1a38087c8d 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -406,7 +406,7 @@ dumpgoroutine(G *gp)
 	dumpint(gp->gopc);
 	dumpint(gp->status);
 	dumpbool(gp->issystem);
-	dumpbool(gp->isbackground);
+	dumpbool(false);  // isbackground
 	dumpint(gp->waitsince);
 	dumpstr(gp->waitreason);
 	dumpint((uintptr)gp->sched.ctxt);
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index fb51a9e5dd..f5a2b2a42d 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -516,7 +516,7 @@ MSpan*	runtime·MHeap_LookupMaybe(MHeap *h, void *v);
 void*	runtime·MHeap_SysAlloc(MHeap *h, uintptr n);
 void	runtime·MHeap_MapBits(MHeap *h);
 void	runtime·MHeap_MapSpans(MHeap *h);
-void	runtime·MHeap_Scavenger(void);
+void	runtime·MHeap_Scavenge(int32 k, uint64 now, uint64 limit);
 
 void*	runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat);
 int32	runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **s);
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 86470c182b..d931e31525 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1095,7 +1095,7 @@ static struct
 static void
 bgsweep(void)
 {
-	g->issystem = 1;
+	g->issystem = true;
 	for(;;) {
 		while(runtime·sweepone() != -1) {
 			sweep.nbgsweep++;
@@ -1109,9 +1109,7 @@ bgsweep(void)
 			continue;
 		}
 		sweep.parked = true;
-		g->isbackground = true;
 		runtime·parkunlock(&gclock, runtime·gostringnocopy((byte*)"GC sweep wait"));
-		g->isbackground = false;
 	}
 }
 
@@ -1685,9 +1683,9 @@ runfinq(void)
 		finq = nil;
 		if(fb == nil) {
 			runtime·fingwait = true;
-			g->isbackground = true;
+			g->issystem = true;
 			runtime·parkunlock(&finlock, runtime·gostringnocopy((byte*)"finalizer wait"));
-			g->isbackground = false;
+			g->issystem = false;
 			continue;
 		}
 		runtime·unlock(&finlock);
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 59be0e093c..a447bbc973 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -574,13 +574,6 @@ MHeap_FreeSpanLocked(MHeap *h, MSpan *s, bool acctinuse, bool acctidle)
 		runtime·MSpanList_Insert(&h->freelarge, s);
 }
 
-static void
-forcegchelper(Note *note)
-{
-	runtime·gc(1);
-	runtime·notewakeup(note);
-}
-
 static uintptr
 scavengelist(MSpan *list, uint64 now, uint64 limit)
 {
@@ -603,18 +596,20 @@ scavengelist(MSpan *list, uint64 now, uint64 limit)
 	return sumreleased;
 }
 
-static void
-scavenge(int32 k, uint64 now, uint64 limit)
+void
+runtime·MHeap_Scavenge(int32 k, uint64 now, uint64 limit)
 {
 	uint32 i;
 	uintptr sumreleased;
 	MHeap *h;
 	
 	h = &runtime·mheap;
+	runtime·lock(&h->lock);
 	sumreleased = 0;
 	for(i=0; i < nelem(h->free); i++)
 		sumreleased += scavengelist(&h->free[i], now, limit);
 	sumreleased += scavengelist(&h->freelarge, now, limit);
+	runtime·unlock(&h->lock);
 
 	if(runtime·debug.gctrace > 0) {
 		if(sumreleased > 0)
@@ -630,72 +625,15 @@ scavenge(int32 k, uint64 now, uint64 limit)
 static void
 scavenge_m(G *gp)
 {
-	runtime·lock(&runtime·mheap.lock);
-	scavenge(g->m->scalararg[0], g->m->scalararg[1], g->m->scalararg[2]);
-	runtime·unlock(&runtime·mheap.lock);
+	runtime·MHeap_Scavenge(-1, ~(uintptr)0, 0);
 	runtime·gogo(&gp->sched);
 }
 
-static FuncVal forcegchelperv = {(void(*)(void))forcegchelper};
-
-// Release (part of) unused memory to OS.
-// Goroutine created at startup.
-// Loop forever.
-void
-runtime·MHeap_Scavenger(void)
-{
-	uint64 tick, forcegc, limit;
-	int64 unixnow;
-	int32 k;
-	Note note, *notep;
-
-	g->issystem = true;
-	g->isbackground = true;
-
-	// If we go two minutes without a garbage collection, force one to run.
-	forcegc = 2*60*1e9;
-	// If a span goes unused for 5 minutes after a garbage collection,
-	// we hand it back to the operating system.
-	limit = 5*60*1e9;
-	// Make wake-up period small enough for the sampling to be correct.
-	if(forcegc < limit)
-		tick = forcegc/2;
-	else
-		tick = limit/2;
-
-	for(k=0;; k++) {
-		runtime·noteclear(&note);
-		runtime·notetsleepg(&note, tick);
-
-		unixnow = runtime·unixnanotime();
-		if(unixnow - mstats.last_gc > forcegc) {
-			// The scavenger can not block other goroutines,
-			// otherwise deadlock detector can fire spuriously.
-			// GC blocks other goroutines via the runtime·worldsema.
-			runtime·noteclear(&note);
-			notep = &note;
-			runtime·newproc1(&forcegchelperv, (byte*)&notep, sizeof(notep), 0, runtime·MHeap_Scavenger);
-			runtime·notetsleepg(&note, -1);
-			if(runtime·debug.gctrace > 0)
-				runtime·printf("scvg%d: GC forced\n", k);
-		}
-		g->m->locks++;	// ensure that we are on the same m while filling arguments
-		g->m->scalararg[0] = k;
-		g->m->scalararg[1] = runtime·nanotime();
-		g->m->scalararg[2] = limit;
-		runtime·mcall(scavenge_m);
-		g->m->locks--;
-	}
-}
-
 void
 runtime∕debug·freeOSMemory(void)
 {
 	runtime·gc(2);  // force GC and do eager sweep
 
-	g->m->scalararg[0] = -1;
-	g->m->scalararg[1] = ~(uintptr)0;
-	g->m->scalararg[2] = 0;
 	runtime·mcall(scavenge_m);
 }
 
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 31ff4f55de..ce0f74aa6c 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -130,6 +130,15 @@ static bool exitsyscallfast(void);
 static bool haveexperiment(int8*);
 static void allgadd(G*);
 
+static void forcegchelper(void);
+static struct
+{
+	Lock	lock;
+	G*	g;
+	FuncVal	fv;
+	uint32	idle;
+} forcegc;
+
 extern String runtime·buildVersion;
 
 // The bootstrap sequence is:
@@ -200,8 +209,6 @@ runtime·schedinit(void)
 extern void main·init(void);
 extern void main·main(void);
 
-static FuncVal scavenger = {runtime·MHeap_Scavenger};
-
 static FuncVal initDone = { runtime·unlockOSThread };
 
 // The main goroutine.
@@ -247,7 +254,8 @@ runtime·main(void)
 
 	if(g->m != &runtime·m0)
 		runtime·throw("runtime·main not on m0");
-	runtime·newproc1(&scavenger, nil, 0, 0, runtime·main);
+	forcegc.fv.fn = forcegchelper;
+	forcegc.g = runtime·newproc1(&forcegc.fv, nil, 0, 0, runtime·main);
 	main·init();
 
 	if(g->defer != &d || d.fn != &initDone)
@@ -1619,8 +1627,6 @@ void
 
 	p = releasep();
 	handoffp(p);
-	if(g->isbackground)  // do not consider blocked scavenger for deadlock detection
-		incidlelocked(1);
 
 	// Resave for traceback during blocked call.
 	save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
@@ -1664,9 +1670,6 @@ runtime·exitsyscall(void)
 {
 	g->m->locks++;  // see comment in entersyscall
 
-	if(g->isbackground)  // do not consider blocked scavenger for deadlock detection
-		incidlelocked(-1);
-
 	g->waitsince = 0;
 	if(exitsyscallfast()) {
 		// There's a cpu for us, so we can run.
@@ -2602,7 +2605,7 @@ checkdead(void)
 	runtime·lock(&allglock);
 	for(i = 0; i < runtime·allglen; i++) {
 		gp = runtime·allg[i];
-		if(gp->isbackground)
+		if(gp->issystem)
 			continue;
 		s = gp->status;
 		if(s == Gwaiting)
@@ -2623,10 +2626,23 @@ checkdead(void)
 static void
 sysmon(void)
 {
-	uint32 idle, delay;
-	int64 now, lastpoll, lasttrace;
+	uint32 idle, delay, nscavenge;
+	int64 now, unixnow, lastpoll, lasttrace;
+	int64 forcegcperiod, scavengelimit, lastscavenge, maxsleep;
 	G *gp;
 
+	// If we go two minutes without a garbage collection, force one to run.
+	forcegcperiod = 2*60*1e6;
+	// If a heap span goes unused for 5 minutes after a garbage collection,
+	// we hand it back to the operating system.
+	scavengelimit = 5*60*1e6;
+	lastscavenge = runtime·nanotime();
+	nscavenge = 0;
+	// Make wake-up period small enough for the sampling to be correct.
+	maxsleep = forcegcperiod/2;
+	if(scavengelimit < forcegcperiod)
+		maxsleep = scavengelimit/2;
+
 	lasttrace = 0;
 	idle = 0;  // how many cycles in succession we had not wokeup somebody
 	delay = 0;
@@ -2644,16 +2660,19 @@ sysmon(void)
 			if(runtime·atomicload(&runtime·sched.gcwaiting) || runtime·atomicload(&runtime·sched.npidle) == runtime·gomaxprocs) {
 				runtime·atomicstore(&runtime·sched.sysmonwait, 1);
 				runtime·unlock(&runtime·sched.lock);
-				runtime·notesleep(&runtime·sched.sysmonnote);
+				runtime·notetsleep(&runtime·sched.sysmonnote, maxsleep);
+				runtime·lock(&runtime·sched.lock);
+				runtime·atomicstore(&runtime·sched.sysmonwait, 0);
 				runtime·noteclear(&runtime·sched.sysmonnote);
 				idle = 0;
 				delay = 20;
-			} else
-				runtime·unlock(&runtime·sched.lock);
+			}
+			runtime·unlock(&runtime·sched.lock);
 		}
 		// poll network if not polled for more than 10ms
 		lastpoll = runtime·atomicload64(&runtime·sched.lastpoll);
 		now = runtime·nanotime();
+		unixnow = runtime·unixnanotime();
 		if(lastpoll != 0 && lastpoll + 10*1000*1000 < now) {
 			runtime·cas64(&runtime·sched.lastpoll, lastpoll, now);
 			gp = runtime·netpoll(false);  // non-blocking
@@ -2677,6 +2696,22 @@ sysmon(void)
 		else
 			idle++;
 
+		// check if we need to force a GC
+		if(unixnow - mstats.last_gc > forcegcperiod && runtime·atomicload(&forcegc.idle)) {
+			runtime·lock(&forcegc.lock);
+			forcegc.idle = 0;
+			forcegc.g->schedlink = nil;
+			injectglist(forcegc.g);
+			runtime·unlock(&forcegc.lock);
+		}
+
+		// scavenge heap once in a while
+		if(lastscavenge + scavengelimit/2 < now) {
+			runtime·MHeap_Scavenge(nscavenge, now, scavengelimit);
+			lastscavenge = now;
+			nscavenge++;
+		}
+
 		if(runtime·debug.schedtrace > 0 && lasttrace + runtime·debug.schedtrace*1000000ll <= now) {
 			lasttrace = now;
 			runtime·schedtrace(runtime·debug.scheddetail);
@@ -2751,6 +2786,23 @@ retake(int64 now)
 	return n;
 }
 
+static void
+forcegchelper(void)
+{
+	g->issystem = true;
+	for(;;) {
+		runtime·lock(&forcegc.lock);
+		if(forcegc.idle)
+			runtime·throw("forcegc: phase error");
+		runtime·atomicstore(&forcegc.idle, 1);
+		runtime·parkunlock(&forcegc.lock, runtime·gostringnocopy((byte*)"force gc (idle)"));
+		// this goroutine is explicitly resumed by sysmon
+		if(runtime·debug.gctrace > 0)
+			runtime·printf("GC forced\n");
+		runtime·gc(1);
+	}
+}
+
 // Tell all goroutines that they have been preempted and they should stop.
 // This function is purely best-effort.  It can fail to inform a goroutine if a
 // processor just started running it.
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index beafc76637..df2999bbd9 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -282,8 +282,7 @@ struct	G
 	String	waitreason;	// if status==Gwaiting
 	G*	schedlink;
 	bool	ispanic;
-	bool	issystem;	// do not output in stack dump
-	bool	isbackground;	// ignore in deadlock detector
+	bool	issystem;	// do not output in stack dump, ignore in deadlock detector
 	bool	preempt;	// preemption signal, duplicates stackguard0 = StackPreempt
 	bool	paniconfault;	// panic (instead of crash) on unexpected fault address
 	int8	raceignore;	// ignore race detection events
diff --git a/src/pkg/runtime/time.go b/src/pkg/runtime/time.go
index 9430414cea..97092c655e 100644
--- a/src/pkg/runtime/time.go
+++ b/src/pkg/runtime/time.go
@@ -192,9 +192,7 @@ func timerproc() {
 		if delta < 0 {
 			// No timers left - put goroutine to sleep.
 			timers.rescheduling = true
-			timers.gp.isbackground = 1
 			goparkunlock(&timers.lock, "timer goroutine (idle)")
-			timers.gp.isbackground = 0
 			continue
 		}
 		// At least one timer pending.  Sleep until then.

From 1d2955a2afac04f5d392ecb1ad8b489f28976bf4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 25 Aug 2014 13:31:55 -0400
Subject: [PATCH 203/423] runtime: round channel size in allocation instead of
 using system-specific pad field

Followup to CL 128700043.

LGTM=bradfitz, dvyukov
R=dvyukov, bradfitz
CC=golang-codereviews
https://golang.org/cl/133850043
---
 src/pkg/runtime/chan.go | 4 ++--
 src/pkg/runtime/chan.h  | 3 ---
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index d3fcc6d13f..7a44afacec 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -11,11 +11,11 @@ import "unsafe"
 
 const (
 	maxAlign  = 8
-	hchanSize = unsafe.Sizeof(hchan{})
+	hchanSize = unsafe.Sizeof(hchan{}) + uintptr(-int(unsafe.Sizeof(hchan{}))&(maxAlign-1))
 	debugChan = false
 )
 
-// TODO: make hchan.buf an unsafe.Pointer, not a *uint8
+// TODO(khr): make hchan.buf an unsafe.Pointer, not a *uint8
 
 func makechan(t *chantype, size int64) *hchan {
 	elem := t.elem
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index 30825eafad..52eb20099d 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -21,9 +21,6 @@ struct	Hchan
 	byte*	buf;
 	uint16	elemsize;
 	uint32	closed;
-#ifndef GOARCH_amd64
-	uint32	pad;			// ensures proper alignment of the buffer that follows Hchan in memory
-#endif
 	Type*	elemtype;		// element type
 	uintgo	sendx;			// send index
 	uintgo	recvx;			// receive index

From df52d2ebd12687617da16b78076fc541f2622e33 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 25 Aug 2014 10:32:46 -0700
Subject: [PATCH 204/423] encoding/json: make ,string work when encoding
 pointer fields

It was respected by unmarshal, but not marshal, so they didn't
round-trip.

Fixes #8582

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/132960043
---
 src/pkg/encoding/json/encode.go      |  4 ++--
 src/pkg/encoding/json/encode_test.go | 26 ++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/src/pkg/encoding/json/encode.go b/src/pkg/encoding/json/encode.go
index 5341a3a01b..b63538c922 100644
--- a/src/pkg/encoding/json/encode.go
+++ b/src/pkg/encoding/json/encode.go
@@ -696,12 +696,12 @@ type ptrEncoder struct {
 	elemEnc encoderFunc
 }
 
-func (pe *ptrEncoder) encode(e *encodeState, v reflect.Value, _ bool) {
+func (pe *ptrEncoder) encode(e *encodeState, v reflect.Value, quoted bool) {
 	if v.IsNil() {
 		e.WriteString("null")
 		return
 	}
-	pe.elemEnc(e, v.Elem(), false)
+	pe.elemEnc(e, v.Elem(), quoted)
 }
 
 func newPtrEncoder(t reflect.Type) encoderFunc {
diff --git a/src/pkg/encoding/json/encode_test.go b/src/pkg/encoding/json/encode_test.go
index 2e89a78eb9..eb84cbae14 100644
--- a/src/pkg/encoding/json/encode_test.go
+++ b/src/pkg/encoding/json/encode_test.go
@@ -452,3 +452,29 @@ func TestHTMLEscape(t *testing.T) {
 		t.Errorf("HTMLEscape(&b, []byte(m)) = %s; want %s", b.Bytes(), want.Bytes())
 	}
 }
+
+// golang.org/issue/8582
+func TestEncodePointerString(t *testing.T) {
+	type stringPointer struct {
+		N *int64 `json:"n,string"`
+	}
+	var n int64 = 42
+	b, err := Marshal(stringPointer{N: &n})
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	if got, want := string(b), `{"n":"42"}`; got != want {
+		t.Errorf("Marshal = %s, want %s", got, want)
+	}
+	var back stringPointer
+	err = Unmarshal(b, &back)
+	if err != nil {
+		t.Fatalf("Unmarshal: %v", err)
+	}
+	if back.N == nil {
+		t.Fatalf("Unmarshalled nil N field")
+	}
+	if *back.N != 42 {
+		t.Fatalf("*N = %d; want 42", *back.N)
+	}
+}

From ba8ddc25ca18664484ad852890fcae61b9f98891 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Mon, 25 Aug 2014 11:07:08 -0700
Subject: [PATCH 205/423] cmd/go: add simple test for generate's line parser

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/128710043
---
 src/cmd/go/generate_test.go | 46 +++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 src/cmd/go/generate_test.go

diff --git a/src/cmd/go/generate_test.go b/src/cmd/go/generate_test.go
new file mode 100644
index 0000000000..6be8157636
--- /dev/null
+++ b/src/cmd/go/generate_test.go
@@ -0,0 +1,46 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"reflect"
+	"runtime"
+	"testing"
+)
+
+type splitTest struct {
+	in  string
+	out []string
+}
+
+var splitTests = []splitTest{
+	{"", nil},
+	{"x", []string{"x"}},
+	{" a b\tc ", []string{"a", "b", "c"}},
+	{` " a " `, []string{" a "}},
+	{"$GOFILE", []string{"proc.go"}},
+	{"a $XXNOTDEFINEDXX b", []string{"a", "", "b"}},
+	{"/$XXNOTDEFINED/", []string{"//"}},
+	{"$GOARCH", []string{runtime.GOARCH}},
+	{"yacc -o $GOARCH/yacc_$GOFILE", []string{"go", "tool", "yacc", "-o", runtime.GOARCH + "/yacc_proc.go"}},
+}
+
+func TestGenerateCommandParse(t *testing.T) {
+	g := &Generator{
+		r:        nil, // Unused here.
+		path:     "/usr/ken/sys/proc.go",
+		dir:      "/usr/ken/sys",
+		file:     "proc.go",
+		pkg:      "sys",
+		commands: make(map[string][]string),
+	}
+	g.setShorthand([]string{"-command", "yacc", "go", "tool", "yacc"})
+	for _, test := range splitTests {
+		got := g.split("//go:generate " + test.in)
+		if !reflect.DeepEqual(got, test.out) {
+			t.Errorf("split(%q): got %q expected %q", test.in, got, test.out)
+		}
+	}
+}

From c6f7c176a3a46ff87d72c4b744bbadf02df1890e Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Mon, 25 Aug 2014 11:35:55 -0700
Subject: [PATCH 206/423] cmd/go: add GOOS and GOARCH to generate Fixes test
 failure in build, probably a good idea anyway.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/131210043
---
 src/cmd/go/generate.go      | 17 ++++++++++++++++-
 src/cmd/go/generate_test.go |  3 +++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/cmd/go/generate.go b/src/cmd/go/generate.go
index 34b10314d2..5859e9eefd 100644
--- a/src/cmd/go/generate.go
+++ b/src/cmd/go/generate.go
@@ -13,6 +13,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strconv"
 	"strings"
 	"unicode"
@@ -48,6 +49,10 @@ quoted string appears a single argument to the generator.
 
 Go generate sets several variables when it runs the generator:
 
+	$GOARCH
+		The execution architecture (arm, amd64, etc.)
+	$GOOS
+		The execution operating system (linux, windows, etc.)
 	$GOFILE
 		The base name of the file.
 	$GOPACKAGE
@@ -287,6 +292,10 @@ func (g *Generator) expandEnv(word string) string {
 		envVar := word[i+1 : i+w]
 		var sub string
 		switch envVar {
+		case "GOARCH":
+			sub = runtime.GOARCH
+		case "GOOS":
+			sub = runtime.GOOS
 		case "GOFILE":
 			sub = g.file
 		case "GOPACKAGE":
@@ -332,7 +341,13 @@ func (g *Generator) exec(words []string) {
 	cmd.Stderr = os.Stderr
 	// Run the command in the package directory.
 	cmd.Dir = g.dir
-	cmd.Env = mergeEnvLists([]string{"GOFILE=" + g.file, "GOPACKAGE=" + g.pkg}, os.Environ())
+	env := []string{
+		"GOARCH=" + runtime.GOARCH,
+		"GOOS=" + runtime.GOOS,
+		"GOFILE=" + g.file,
+		"GOPACKAGE=" + g.pkg,
+	}
+	cmd.Env = mergeEnvLists(env, os.Environ())
 	err := cmd.Run()
 	if err != nil {
 		g.errorf("running %q: %s", words[0], err)
diff --git a/src/cmd/go/generate_test.go b/src/cmd/go/generate_test.go
index 6be8157636..881a8fe9b6 100644
--- a/src/cmd/go/generate_test.go
+++ b/src/cmd/go/generate_test.go
@@ -20,7 +20,10 @@ var splitTests = []splitTest{
 	{"x", []string{"x"}},
 	{" a b\tc ", []string{"a", "b", "c"}},
 	{` " a " `, []string{" a "}},
+	{"$GOARCH", []string{runtime.GOARCH}},
+	{"$GOOS", []string{runtime.GOOS}},
 	{"$GOFILE", []string{"proc.go"}},
+	{"$GOPACKAGE", []string{"sys"}},
 	{"a $XXNOTDEFINEDXX b", []string{"a", "", "b"}},
 	{"/$XXNOTDEFINED/", []string{"//"}},
 	{"$GOARCH", []string{runtime.GOARCH}},

From 613383c7651d490aae045eb70cd515b151735766 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 25 Aug 2014 14:38:19 -0400
Subject: [PATCH 207/423] cmd/gc, runtime: treat slices and strings like
 pointers in garbage collection

Before, a slice with cap=0 or a string with len=0 might have its
base pointer pointing beyond the actual slice/string data into
the next block. The collector had to ignore slices and strings with
cap=0 in order to avoid misinterpreting the base pointer.

Now, a slice with cap=0 or a string with len=0 still has a base
pointer pointing into the actual slice/string data, no matter what.
The collector can now always scan the pointer, which means
strings and slices are no longer special.

Fixes #8404.

LGTM=khr, josharian
R=josharian, khr, dvyukov
CC=golang-codereviews
https://golang.org/cl/112570044
---
 src/cmd/5g/cgen.c              |  1 -
 src/cmd/5g/gsubr.c             |  1 -
 src/cmd/6g/cgen.c              |  1 -
 src/cmd/6g/gsubr.c             |  2 -
 src/cmd/8g/cgen.c              |  1 -
 src/cmd/8g/gsubr.c             |  1 -
 src/cmd/gc/fmt.c               |  2 +-
 src/cmd/gc/gen.c               | 55 +++++++++++++++------
 src/cmd/gc/go.h                |  1 -
 src/cmd/gc/plive.c             |  7 +--
 src/cmd/gc/reflect.c           |  8 +--
 src/cmd/gc/subr.c              |  8 ++-
 src/cmd/gc/typecheck.c         | 13 -----
 src/cmd/gc/walk.c              | 12 ++---
 src/pkg/reflect/all_test.go    | 18 +++++++
 src/pkg/reflect/value.go       | 14 +++++-
 src/pkg/runtime/gcinfo_test.go | 50 ++++++++++---------
 src/pkg/runtime/heapdump.c     | 22 +++------
 src/pkg/runtime/malloc.h       |  4 +-
 src/pkg/runtime/mgc0.c         | 60 +++++++----------------
 src/pkg/runtime/mgc0.h         |  4 +-
 src/pkg/runtime/runtime.h      |  2 -
 src/pkg/runtime/stack.c        | 15 +-----
 test/slice3.go                 | 18 ++++---
 test/slicecap.go               | 90 ++++++++++++++++++++++++++++++++++
 25 files changed, 248 insertions(+), 162 deletions(-)
 create mode 100644 test/slicecap.go

diff --git a/src/cmd/5g/cgen.c b/src/cmd/5g/cgen.c
index a9c597cdc8..5fae7a564c 100644
--- a/src/cmd/5g/cgen.c
+++ b/src/cmd/5g/cgen.c
@@ -254,7 +254,6 @@ cgen(Node *n, Node *res)
 	case OOR:
 	case OXOR:
 	case OADD:
-	case OADDPTR:
 	case OMUL:
 		a = optoas(n->op, nl->type);
 		goto sbop;
diff --git a/src/cmd/5g/gsubr.c b/src/cmd/5g/gsubr.c
index 1241a23ea6..5a70fcddaf 100644
--- a/src/cmd/5g/gsubr.c
+++ b/src/cmd/5g/gsubr.c
@@ -1599,7 +1599,6 @@ optoas(int op, Type *t)
 	case CASE(OADD, TINT32):
 	case CASE(OADD, TUINT32):
 	case CASE(OADD, TPTR32):
-	case CASE(OADDPTR, TPTR32):
 		a = AADD;
 		break;
 
diff --git a/src/cmd/6g/cgen.c b/src/cmd/6g/cgen.c
index bff2350621..592e81542c 100644
--- a/src/cmd/6g/cgen.c
+++ b/src/cmd/6g/cgen.c
@@ -247,7 +247,6 @@ cgen(Node *n, Node *res)
 	case OOR:
 	case OXOR:
 	case OADD:
-	case OADDPTR:
 	case OMUL:
 		a = optoas(n->op, nl->type);
 		if(a == AIMULB) {
diff --git a/src/cmd/6g/gsubr.c b/src/cmd/6g/gsubr.c
index 4ac2e92079..a451d7d624 100644
--- a/src/cmd/6g/gsubr.c
+++ b/src/cmd/6g/gsubr.c
@@ -1537,14 +1537,12 @@ optoas(int op, Type *t)
 	case CASE(OADD, TINT32):
 	case CASE(OADD, TUINT32):
 	case CASE(OADD, TPTR32):
-	case CASE(OADDPTR, TPTR32):
 		a = AADDL;
 		break;
 
 	case CASE(OADD, TINT64):
 	case CASE(OADD, TUINT64):
 	case CASE(OADD, TPTR64):
-	case CASE(OADDPTR, TPTR64):
 		a = AADDQ;
 		break;
 
diff --git a/src/cmd/8g/cgen.c b/src/cmd/8g/cgen.c
index bdf728dbbc..f3093bc26e 100644
--- a/src/cmd/8g/cgen.c
+++ b/src/cmd/8g/cgen.c
@@ -242,7 +242,6 @@ cgen(Node *n, Node *res)
 	case OOR:
 	case OXOR:
 	case OADD:
-	case OADDPTR:
 	case OMUL:
 		a = optoas(n->op, nl->type);
 		if(a == AIMULB) {
diff --git a/src/cmd/8g/gsubr.c b/src/cmd/8g/gsubr.c
index 66d5b8d696..9ee418cb78 100644
--- a/src/cmd/8g/gsubr.c
+++ b/src/cmd/8g/gsubr.c
@@ -430,7 +430,6 @@ optoas(int op, Type *t)
 	case CASE(OADD, TINT32):
 	case CASE(OADD, TUINT32):
 	case CASE(OADD, TPTR32):
-	case CASE(OADDPTR, TPTR32):
 		a = AADDL;
 		break;
 
diff --git a/src/cmd/gc/fmt.c b/src/cmd/gc/fmt.c
index 951170aeff..98556a658f 100644
--- a/src/cmd/gc/fmt.c
+++ b/src/cmd/gc/fmt.c
@@ -1153,7 +1153,7 @@ exprfmt(Fmt *f, Node *n, int prec)
 		case Csend:
 			return fmtprint(f, "chan<- %N", n->left);
 		default:
-			if(n->left != N && n->left->op == TCHAN && n->left->sym == S && n->left->etype == Crecv)
+			if(n->left != N && n->left->op == OTCHAN && n->left->sym == S && n->left->etype == Crecv)
 				return fmtprint(f, "chan (%N)", n->left);
 			else
 				return fmtprint(f, "chan %N", n->left);
diff --git a/src/cmd/gc/gen.c b/src/cmd/gc/gen.c
index 908a5e53d9..86acd88259 100644
--- a/src/cmd/gc/gen.c
+++ b/src/cmd/gc/gen.c
@@ -806,7 +806,8 @@ cgen_eface(Node *n, Node *res)
 void
 cgen_slice(Node *n, Node *res)
 {
-	Node src, dst, *cap, *len, *offs, *add, *base;
+	Node src, dst, *cap, *len, *offs, *add, *base, *tmpcap, *tmplen, *cmp, con;
+	Prog *p1, *p2;
 
 	cap = n->list->n;
 	len = n->list->next->n;
@@ -823,6 +824,11 @@ cgen_slice(Node *n, Node *res)
 	// garbage collector can see.
 	
 	base = temp(types[TUINTPTR]);
+	tmplen = temp(types[TINT]);
+	if(n->op != OSLICESTR)
+		tmpcap = temp(types[TINT]);
+	else
+		tmpcap = tmplen;
 
 	if(isnil(n->left)) {
 		tempname(&src, n->left->type);
@@ -837,43 +843,62 @@ cgen_slice(Node *n, Node *res)
 			fatal("slicearr is supposed to work on pointer: %+N\n", n);
 		cgen(&src, base);
 		cgen_checknil(base);
-		if(offs != N) {
-			add = nod(OADD, base, offs);
-			typecheck(&add, Erv);
-			cgen(add, base);
-		}
-	} else if(offs == N) {
-		src.type = types[tptr];
-		cgen(&src, base);
 	} else {
 		src.type = types[tptr];
-		add = nod(OADDPTR, &src, offs);
-		typecheck(&add, Erv);
-		cgen(add, base);
+		cgen(&src, base);
 	}
 	
 	// committed to the update
 	gvardef(res);
 
+	// compute len and cap.
+	// len = n-i, cap = m-i, and offs = i*width.
+	// computing offs last lets the multiply overwrite i.
+	cgen(len, tmplen);
+	if(n->op != OSLICESTR)
+		cgen(cap, tmpcap);
+
+	// if new cap != 0 { base += add }
+	// This avoids advancing base past the end of the underlying array/string,
+	// so that it cannot point at the next object in memory.
+	// If cap == 0, the base doesn't matter except insofar as it is 0 or non-zero.
+	// In essence we are replacing x[i:j:k] where i == j == k
+	// or x[i:j] where i == j == cap(x) with x[0:0:0].
+	if(offs != N) {
+		p1 = gjmp(P);
+		p2 = gjmp(P);
+		patch(p1, pc);
+
+		nodconst(&con, tmpcap->type, 0);
+		cmp = nod(OEQ, tmpcap, &con);
+		typecheck(&cmp, Erv);
+		bgen(cmp, 1, -1, p2);
+
+		add = nod(OADD, base, offs);
+		typecheck(&add, Erv);
+		cgen(add, base);
+
+		patch(p2, pc);
+	}
+
 	// dst.array = src.array  [ + lo *width ]
 	dst = *res;
 	dst.xoffset += Array_array;
 	dst.type = types[tptr];
-	
 	cgen(base, &dst);
 
 	// dst.len = hi [ - lo ]
 	dst = *res;
 	dst.xoffset += Array_nel;
 	dst.type = types[simtype[TUINT]];
-	cgen(len, &dst);
+	cgen(tmplen, &dst);
 
 	if(n->op != OSLICESTR) {
 		// dst.cap = cap [ - lo ]
 		dst = *res;
 		dst.xoffset += Array_cap;
 		dst.type = types[simtype[TUINT]];
-		cgen(cap, &dst);
+		cgen(tmpcap, &dst);
 	}
 }
 
diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h
index 61bb7bd6e4..12c1e98539 100644
--- a/src/cmd/gc/go.h
+++ b/src/cmd/gc/go.h
@@ -447,7 +447,6 @@ enum
 	OSUB,	// x - y
 	OOR,	// x | y
 	OXOR,	// x ^ y
-	OADDPTR,	// ptr + uintptr, inserted by compiler only, used to avoid unsafe type changes during codegen
 	OADDSTR,	// s + "foo"
 	OADDR,	// &x
 	OANDAND,	// b0 && b1
diff --git a/src/cmd/gc/plive.c b/src/cmd/gc/plive.c
index e67b0af757..0ad700e82f 100644
--- a/src/cmd/gc/plive.c
+++ b/src/cmd/gc/plive.c
@@ -1113,8 +1113,7 @@ twobitwalktype1(Type *t, vlong *xoffset, Bvec *bv)
 		// struct { byte *str; intgo len; }
 		if((*xoffset & (widthptr-1)) != 0)
 			fatal("twobitwalktype1: invalid alignment, %T", t);
-		bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 0);
-		bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 1); // 3:0 = multiword:string
+		bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 1); // 2 = live ptr in first slot
 		*xoffset += t->width;
 		break;
 
@@ -1145,9 +1144,7 @@ twobitwalktype1(Type *t, vlong *xoffset, Bvec *bv)
 			// struct { byte *array; uintgo len; uintgo cap; }
 			if((*xoffset & (widthptr-1)) != 0)
 				fatal("twobitwalktype1: invalid TARRAY alignment, %T", t);
-			bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 0);
-			bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 1);
-			bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 2); // 3:1 = multiword/slice
+			bvset(bv, (*xoffset / widthptr) * BitsPerPointer + 1); // 2 = live ptr in first slot
 			*xoffset += t->width;
 		} else
 			for(i = 0; i < t->bound; i++)
diff --git a/src/cmd/gc/reflect.c b/src/cmd/gc/reflect.c
index 66efac07d0..05bf2d6521 100644
--- a/src/cmd/gc/reflect.c
+++ b/src/cmd/gc/reflect.c
@@ -1516,8 +1516,8 @@ gengcprog1(ProgGen *g, Type *t, vlong *xoffset)
 		*xoffset += t->width;
 		break;
 	case TSTRING:
-		proggendata(g, BitsMultiWord);
-		proggendata(g, BitsString);
+		proggendata(g, BitsPointer);
+		proggendata(g, BitsScalar);
 		*xoffset += t->width;
 		break;
 	case TINTER:
@@ -1530,8 +1530,8 @@ gengcprog1(ProgGen *g, Type *t, vlong *xoffset)
 		break;
 	case TARRAY:
 		if(isslice(t)) {
-			proggendata(g, BitsMultiWord);
-			proggendata(g, BitsSlice);
+			proggendata(g, BitsPointer);
+			proggendata(g, BitsScalar);
 			proggendata(g, BitsScalar);
 		} else {
 			t1 = t->type;
diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 081c373a88..d62d55e773 100644
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -656,11 +656,15 @@ maptype(Type *key, Type *val)
 {
 	Type *t;
 	Type *bad;
-	int atype;
+	int atype, mtype;
 
 	if(key != nil) {
 		atype = algtype1(key, &bad);
-		switch(bad == T ? key->etype : bad->etype) {
+		if(bad == T)
+			mtype = key->etype;
+		else
+			mtype = bad->etype;
+		switch(mtype) {
 		default:
 			if(atype == ANOEQ)
 				yyerror("invalid map key type %T", key);
diff --git a/src/cmd/gc/typecheck.c b/src/cmd/gc/typecheck.c
index c295cf6d21..746feb4d1b 100644
--- a/src/cmd/gc/typecheck.c
+++ b/src/cmd/gc/typecheck.c
@@ -525,19 +525,6 @@ reswitch:
 		op = n->etype;
 		goto arith;
 
-	case OADDPTR:
-		ok |= Erv;
-		l = typecheck(&n->left, Erv);
-		r = typecheck(&n->right, Erv);
-		if(l->type == T || r->type == T)
-			goto error;
-		if(l->type->etype != tptr)
-			fatal("bad OADDPTR left type %E for %N", l->type->etype, n->left);
-		if(r->type->etype != TUINTPTR)
-			fatal("bad OADDPTR right type %E for %N", r->type->etype, n->right);
-		n->type = types[tptr];
-		goto ret;
-
 	case OADD:
 	case OAND:
 	case OANDAND:
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index f3886cf73a..c251af660e 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -2875,14 +2875,14 @@ sliceany(Node* n, NodeList **init)
 			lb = N;
 	}
 
-	// dynamic checks convert all bounds to unsigned to save us the bound < 0 comparison
-	// generate
-	//     if hb > bound || lb > hb { panicslice() }
+	// Checking src[lb:hb:cb] or src[lb:hb].
+	// if chk0 || chk1 || chk2 { panicslice() }
 	chk = N;
-	chk0 = N;
-	chk1 = N;
-	chk2 = N;
+	chk0 = N; // cap(src) < cb
+	chk1 = N; // cb < hb for src[lb:hb:cb]; cap(src) < hb for src[lb:hb]
+	chk2 = N; // hb < lb
 
+	// All comparisons are unsigned to avoid testing < 0.
 	bt = types[simtype[TUINT]];
 	if(cb != N && cb->type->width > 4)
 		bt = types[TUINT64];
diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
index d9781699e0..9a2a9f2668 100644
--- a/src/pkg/reflect/all_test.go
+++ b/src/pkg/reflect/all_test.go
@@ -2494,6 +2494,15 @@ func TestSlice(t *testing.T) {
 	if vs != s[3:5] {
 		t.Errorf("s.Slice(3, 5) = %q; expected %q", vs, s[3:5])
 	}
+
+	rv := ValueOf(&xs).Elem()
+	rv = rv.Slice(3, 4)
+	ptr2 := rv.Pointer()
+	rv = rv.Slice(5, 5)
+	ptr3 := rv.Pointer()
+	if ptr3 != ptr2 {
+		t.Errorf("xs.Slice(3,4).Slice3(5,5).Pointer() = %#x, want %#x", ptr3, ptr2)
+	}
 }
 
 func TestSlice3(t *testing.T) {
@@ -2532,6 +2541,15 @@ func TestSlice3(t *testing.T) {
 	s := "hello world"
 	rv = ValueOf(&s).Elem()
 	shouldPanic(func() { rv.Slice3(1, 2, 3) })
+
+	rv = ValueOf(&xs).Elem()
+	rv = rv.Slice3(3, 5, 7)
+	ptr2 := rv.Pointer()
+	rv = rv.Slice3(4, 4, 4)
+	ptr3 := rv.Pointer()
+	if ptr3 != ptr2 {
+		t.Errorf("xs.Slice3(3,5,7).Slice3(4,4,4).Pointer() = %#x, want %#x", ptr3, ptr2)
+	}
 }
 
 func TestSetLenCap(t *testing.T) {
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index dda852a3ec..4394ed0739 100644
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -1746,9 +1746,14 @@ func (v Value) Slice(i, j int) Value {
 
 	// Reinterpret as *sliceHeader to edit.
 	s := (*sliceHeader)(unsafe.Pointer(&x))
-	s.Data = unsafe.Pointer(uintptr(base) + uintptr(i)*typ.elem.Size())
 	s.Len = j - i
 	s.Cap = cap - i
+	if cap-i > 0 {
+		s.Data = unsafe.Pointer(uintptr(base) + uintptr(i)*typ.elem.Size())
+	} else {
+		// do not advance pointer, to avoid pointing beyond end of slice
+		s.Data = base
+	}
 
 	fl := v.flag&flagRO | flagIndir | flag(Slice)<<flagKindShift
 	return Value{typ.common(), unsafe.Pointer(&x), 0, fl}
@@ -1793,9 +1798,14 @@ func (v Value) Slice3(i, j, k int) Value {
 
 	// Reinterpret as *sliceHeader to edit.
 	s := (*sliceHeader)(unsafe.Pointer(&x))
-	s.Data = unsafe.Pointer(uintptr(base) + uintptr(i)*typ.elem.Size())
 	s.Len = j - i
 	s.Cap = k - i
+	if k-i > 0 {
+		s.Data = unsafe.Pointer(uintptr(base) + uintptr(i)*typ.elem.Size())
+	} else {
+		// do not advance pointer, to avoid pointing beyond end of slice
+		s.Data = base
+	}
 
 	fl := v.flag&flagRO | flagIndir | flag(Slice)<<flagKindShift
 	return Value{typ.common(), unsafe.Pointer(&x), 0, fl}
diff --git a/src/pkg/runtime/gcinfo_test.go b/src/pkg/runtime/gcinfo_test.go
index 16764c9487..88f6703f97 100644
--- a/src/pkg/runtime/gcinfo_test.go
+++ b/src/pkg/runtime/gcinfo_test.go
@@ -14,7 +14,7 @@ import (
 func TestGCInfo(t *testing.T) {
 	verifyGCInfo(t, "bss ScalarPtr", &bssScalarPtr, nonStackInfo(infoScalarPtr))
 	verifyGCInfo(t, "bss PtrScalar", &bssPtrScalar, nonStackInfo(infoPtrScalar))
-	verifyGCInfo(t, "bss Complex", &bssComplex, nonStackInfo(infoComplex()))
+	verifyGCInfo(t, "bss BigStruct", &bssBigStruct, nonStackInfo(infoBigStruct()))
 	verifyGCInfo(t, "bss string", &bssString, nonStackInfo(infoString))
 	verifyGCInfo(t, "bss slice", &bssSlice, nonStackInfo(infoSlice))
 	verifyGCInfo(t, "bss eface", &bssEface, nonStackInfo(infoEface))
@@ -22,7 +22,7 @@ func TestGCInfo(t *testing.T) {
 
 	verifyGCInfo(t, "data ScalarPtr", &dataScalarPtr, nonStackInfo(infoScalarPtr))
 	verifyGCInfo(t, "data PtrScalar", &dataPtrScalar, nonStackInfo(infoPtrScalar))
-	verifyGCInfo(t, "data Complex", &dataComplex, nonStackInfo(infoComplex()))
+	verifyGCInfo(t, "data BigStruct", &dataBigStruct, nonStackInfo(infoBigStruct()))
 	verifyGCInfo(t, "data string", &dataString, nonStackInfo(infoString))
 	verifyGCInfo(t, "data slice", &dataSlice, nonStackInfo(infoSlice))
 	verifyGCInfo(t, "data eface", &dataEface, nonStackInfo(infoEface))
@@ -30,7 +30,7 @@ func TestGCInfo(t *testing.T) {
 
 	verifyGCInfo(t, "stack ScalarPtr", new(ScalarPtr), infoScalarPtr)
 	verifyGCInfo(t, "stack PtrScalar", new(PtrScalar), infoPtrScalar)
-	verifyGCInfo(t, "stack Complex", new(Complex), infoComplex())
+	verifyGCInfo(t, "stack BigStruct", new(BigStruct), infoBigStruct())
 	verifyGCInfo(t, "stack string", new(string), infoString)
 	verifyGCInfo(t, "stack slice", new([]string), infoSlice)
 	verifyGCInfo(t, "stack eface", new(interface{}), infoEface)
@@ -39,7 +39,7 @@ func TestGCInfo(t *testing.T) {
 	for i := 0; i < 10; i++ {
 		verifyGCInfo(t, "heap ScalarPtr", escape(new(ScalarPtr)), nonStackInfo(infoScalarPtr))
 		verifyGCInfo(t, "heap PtrScalar", escape(new(PtrScalar)), nonStackInfo(infoPtrScalar))
-		verifyGCInfo(t, "heap Complex", escape(new(Complex)), nonStackInfo(infoComplex()))
+		verifyGCInfo(t, "heap BigStruct", escape(new(BigStruct)), nonStackInfo(infoBigStruct()))
 		verifyGCInfo(t, "heap string", escape(new(string)), nonStackInfo(infoString))
 		verifyGCInfo(t, "heap eface", escape(new(interface{})), nonStackInfo(infoEface))
 		verifyGCInfo(t, "heap iface", escape(new(Iface)), nonStackInfo(infoIface))
@@ -88,8 +88,8 @@ const (
 )
 
 const (
-	BitsString = iota
-	BitsSlice
+	BitsString = iota // unused
+	BitsSlice         // unused
 	BitsIface
 	BitsEface
 )
@@ -116,7 +116,7 @@ type PtrScalar struct {
 
 var infoPtrScalar = []byte{BitsPointer, BitsScalar, BitsPointer, BitsScalar, BitsPointer, BitsScalar}
 
-type Complex struct {
+type BigStruct struct {
 	q *int
 	w byte
 	e [17]byte
@@ -127,27 +127,31 @@ type Complex struct {
 	i string
 }
 
-func infoComplex() []byte {
+func infoBigStruct() []byte {
 	switch runtime.GOARCH {
 	case "386", "arm":
 		return []byte{
-			BitsPointer, BitsScalar, BitsScalar, BitsScalar,
-			BitsScalar, BitsScalar, BitsMultiWord, BitsSlice,
-			BitsDead, BitsScalar, BitsScalar, BitsScalar,
-			BitsScalar, BitsMultiWord, BitsString,
+			BitsPointer,                                                // q *int
+			BitsScalar, BitsScalar, BitsScalar, BitsScalar, BitsScalar, // w byte; e [17]byte
+			BitsPointer, BitsDead, BitsDead, // r []byte
+			BitsScalar, BitsScalar, BitsScalar, BitsScalar, // t int; y uint16; u uint64
+			BitsPointer, BitsDead, // i string
 		}
 	case "amd64":
 		return []byte{
-			BitsPointer, BitsScalar, BitsScalar, BitsScalar,
-			BitsMultiWord, BitsSlice, BitsDead, BitsScalar,
-			BitsScalar, BitsScalar, BitsMultiWord, BitsString,
+			BitsPointer,                        // q *int
+			BitsScalar, BitsScalar, BitsScalar, // w byte; e [17]byte
+			BitsPointer, BitsDead, BitsDead, // r []byte
+			BitsScalar, BitsScalar, BitsScalar, // t int; y uint16; u uint64
+			BitsPointer, BitsDead, // i string
 		}
 	case "amd64p32":
 		return []byte{
-			BitsPointer, BitsScalar, BitsScalar, BitsScalar,
-			BitsScalar, BitsScalar, BitsMultiWord, BitsSlice,
-			BitsDead, BitsScalar, BitsScalar, BitsDead,
-			BitsScalar, BitsScalar, BitsMultiWord, BitsString,
+			BitsPointer,                                                // q *int
+			BitsScalar, BitsScalar, BitsScalar, BitsScalar, BitsScalar, // w byte; e [17]byte
+			BitsPointer, BitsDead, BitsDead, // r []byte
+			BitsScalar, BitsScalar, BitsDead, BitsScalar, BitsScalar, // t int; y uint16; u uint64
+			BitsPointer, BitsDead, // i string
 		}
 	default:
 		panic("unknown arch")
@@ -167,7 +171,7 @@ var (
 	// BSS
 	bssScalarPtr ScalarPtr
 	bssPtrScalar PtrScalar
-	bssComplex   Complex
+	bssBigStruct BigStruct
 	bssString    string
 	bssSlice     []string
 	bssEface     interface{}
@@ -176,14 +180,14 @@ var (
 	// DATA
 	dataScalarPtr             = ScalarPtr{q: 1}
 	dataPtrScalar             = PtrScalar{w: 1}
-	dataComplex               = Complex{w: 1}
+	dataBigStruct             = BigStruct{w: 1}
 	dataString                = "foo"
 	dataSlice                 = []string{"foo"}
 	dataEface     interface{} = 42
 	dataIface     Iface       = IfaceImpl(42)
 
-	infoString = []byte{BitsMultiWord, BitsString}
-	infoSlice  = []byte{BitsMultiWord, BitsSlice, BitsDead}
+	infoString = []byte{BitsPointer, BitsDead}
+	infoSlice  = []byte{BitsPointer, BitsDead, BitsDead}
 	infoEface  = []byte{BitsMultiWord, BitsEface}
 	infoIface  = []byte{BitsMultiWord, BitsIface}
 )
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 1a38087c8d..61f6fc2d95 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -260,16 +260,8 @@ dumpbv(BitVector *bv, uintptr offset)
 			break;
 		case BitsMultiWord:
 			switch(bv->data[(i+BitsPerPointer)/32] >> (i+BitsPerPointer)%32 & 3) {
-			case BitsString:
-				dumpint(FieldKindString);
-				dumpint(offset + i / BitsPerPointer * PtrSize);
-				i += BitsPerPointer;
-				break;
-			case BitsSlice:
-				dumpint(FieldKindSlice);
-				dumpint(offset + i / BitsPerPointer * PtrSize);
-				i += 2 * BitsPerPointer;
-				break;
+			default:
+				runtime·throw("unexpected garbage collection bits");
 			case BitsIface:
 				dumpint(FieldKindIface);
 				dumpint(offset + i / BitsPerPointer * PtrSize);
@@ -495,13 +487,13 @@ dumproots(void)
 	dumpint(TagData);
 	dumpint((uintptr)data);
 	dumpmemrange(data, edata - data);
-	dumpfields((BitVector){(edata - data)*8, (uint32*)runtime·gcdatamask});
+	dumpfields(runtime·gcdatamask);
 
 	// bss segment
 	dumpint(TagBss);
 	dumpint((uintptr)bss);
 	dumpmemrange(bss, ebss - bss);
-	dumpfields((BitVector){(ebss - bss)*8, (uint32*)runtime·gcbssmask});
+	dumpfields(runtime·gcdatamask);
 
 	// MSpan.types
 	allspans = runtime·mheap.allspans;
@@ -802,13 +794,11 @@ dumpbvtypes(BitVector *bv, byte *base)
 		if((bv->data[i/32] >> i%32 & 3) != BitsMultiWord)
 			continue;
 		switch(bv->data[(i+BitsPerPointer)/32] >> (i+BitsPerPointer)%32 & 3) {
-		case BitsString:
+		default:
+			runtime·throw("unexpected garbage collection bits");
 		case BitsIface:
 			i += BitsPerPointer;
 			break;
-		case BitsSlice:
-			i += 2 * BitsPerPointer;
-			break;
 		case BitsEface:
 			dumptype(*(Type**)(base + i / BitsPerPointer * PtrSize));
 			i += BitsPerPointer;
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index f5a2b2a42d..eafabb364a 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -303,7 +303,6 @@ extern	int8	runtime·size_to_class8[1024/8 + 1];
 extern	int8	runtime·size_to_class128[(MaxSmallSize-1024)/128 + 1];
 extern	void	runtime·InitSizes(void);
 
-
 typedef struct MCacheList MCacheList;
 struct MCacheList
 {
@@ -581,6 +580,9 @@ struct StackMap
 // (the index is encoded in PCDATA_StackMapIndex).
 BitVector	runtime·stackmapdata(StackMap *stackmap, int32 n);
 
+extern	BitVector	runtime·gcdatamask;
+extern	BitVector	runtime·gcbssmask;
+
 // defined in mgc0.go
 void	runtime·gc_m_ptr(Eface*);
 void	runtime·gc_g_ptr(Eface*);
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index d931e31525..db89f6036f 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -172,8 +172,8 @@ static FinBlock	*finc;		// cache of free blocks
 static FinBlock	*allfin;	// list of all blocks
 bool	runtime·fingwait;
 bool	runtime·fingwake;
-byte*	runtime·gcdatamask;
-byte*	runtime·gcbssmask;
+BitVector	runtime·gcdatamask;
+BitVector	runtime·gcbssmask;
 
 static Lock	gclock;
 
@@ -187,7 +187,7 @@ static void	gchelperstart(void);
 static void	flushallmcaches(void);
 static bool	scanframe(Stkframe *frame, void *unused);
 static void	scanstack(G *gp);
-static byte*	unrollglobgcprog(byte *prog, uintptr size);
+static BitVector	unrollglobgcprog(byte *prog, uintptr size);
 
 static FuncVal runfinqv = {runfinq};
 static FuncVal bgsweepv = {bgsweep};
@@ -221,8 +221,6 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 	uintptr i, nobj, size, idx, x, off, scanbufpos;
 	intptr ncached;
 	Workbuf *wbuf;
-	String *str;
-	Slice *slice;
 	Iface *iface;
 	Eface *eface;
 	Type *typ;
@@ -346,6 +344,10 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				obj = *(byte**)(b+i);
 				goto markobj;
 			}
+
+			// With those three out of the way, must be multi-word.
+			if(bits != BitsMultiWord)
+				runtime·throw("unexpected garbage collection bits");
 			// Find the next pair of bits.
 			if(ptrmask == nil) {
 				if(ncached <= 0) {
@@ -358,22 +360,8 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				bits = (ptrmask[((i+PtrSize)/PtrSize)/4]>>((((i+PtrSize)/PtrSize)%4)*BitsPerPointer))&BitsMask;
 
 			switch(bits) {
-			case BitsString:
-				str = (String*)(b+i);
-				if(str->len > 0)
-					obj = str->str;
-				break;
-			case BitsSlice:
-				slice = (Slice*)(b+i);
-				if(Debug && slice->cap < slice->len) {
-					g->m->traceback = 2;
-					runtime·printf("bad slice in object %p: %p/%p/%p\n",
-						b, slice->array, slice->len, slice->cap);
-					runtime·throw("bad slice in heap object");
-				}
-				if(slice->cap > 0)
-					obj = slice->array;
-				break;
+			default:
+				runtime·throw("unexpected garbage collection bits");
 			case BitsIface:
 				iface = (Iface*)(b+i);
 				if(iface->tab != nil) {
@@ -392,21 +380,9 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 				break;
 			}
 
-			if(bits == BitsSlice) {
-				i += 2*PtrSize;
-				if(ncached == 2)
-					ncached = 0;
-				else if(ptrmask == nil) {
-					// Refill cache and consume one quadruple.
-					cached = *--ptrbitp;
-					cached >>= gcBits;
-					ncached = 1;
-				}
-			} else {
-				i += PtrSize;
-				cached >>= gcBits;
-				ncached--;
-			}
+			i += PtrSize;
+			cached >>= gcBits;
+			ncached--;
 
 		markobj:
 			// At this point we have extracted the next potential pointer.
@@ -513,11 +489,11 @@ markroot(ParFor *desc, uint32 i)
 	// Note: if you add a case here, please also update heapdump.c:dumproots.
 	switch(i) {
 	case RootData:
-		scanblock(data, edata - data, runtime·gcdatamask);
+		scanblock(data, edata - data, (byte*)runtime·gcdatamask.data);
 		break;
 
 	case RootBss:
-		scanblock(bss, ebss - bss, runtime·gcbssmask);
+		scanblock(bss, ebss - bss, (byte*)runtime·gcbssmask.data);
 		break;
 
 	case RootFinalizers:
@@ -1852,7 +1828,7 @@ unrollgcprog1(byte *mask, byte *prog, uintptr *ppos, bool inplace, bool sparse)
 }
 
 // Unrolls GC program prog for data/bss, returns dense GC mask.
-static byte*
+static BitVector
 unrollglobgcprog(byte *prog, uintptr size)
 {
 	byte *mask;
@@ -1872,7 +1848,7 @@ unrollglobgcprog(byte *prog, uintptr size)
 		runtime·throw("unrollglobgcprog: program does not end with insEnd");
 	if(mask[masksize] != 0xa1)
 		runtime·throw("unrollglobgcprog: overflow");
-	return mask;
+	return (BitVector){masksize*8, (uint32*)mask};
 }
 
 void
@@ -2062,7 +2038,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
 			off = (p+i-data)/PtrSize;
-			bits = (runtime·gcdatamask[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
+			bits = (((byte*)runtime·gcdatamask.data)[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
 		return;
@@ -2074,7 +2050,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
 			off = (p+i-bss)/PtrSize;
-			bits = (runtime·gcbssmask[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
+			bits = (((byte*)runtime·gcbssmask.data)[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
 		return;
diff --git a/src/pkg/runtime/mgc0.h b/src/pkg/runtime/mgc0.h
index a7292effd3..d04b5cab8f 100644
--- a/src/pkg/runtime/mgc0.h
+++ b/src/pkg/runtime/mgc0.h
@@ -50,8 +50,8 @@ enum {
 	BitsMultiWord	= 3,
 	// BitsMultiWord will be set for the first word of a multi-word item.
 	// When it is set, one of the following will be set for the second word.
-	BitsString	= 0,
-	BitsSlice	= 1,
+	// NOT USED ANYMORE: BitsString	= 0,
+	// NOT USED ANYMORE: BitsSlice	= 1,
 	BitsIface	= 2,
 	BitsEface	= 3,
 
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index df2999bbd9..4f63fdf718 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -762,8 +762,6 @@ extern	uint32	runtime·cpuid_ecx;
 extern	uint32	runtime·cpuid_edx;
 extern	DebugVars	runtime·debug;
 extern	uintptr	runtime·maxstacksize;
-extern	byte*	runtime·gcdatamask;
-extern	byte*	runtime·gcbssmask;
 extern	Note	runtime·signote;
 
 /*
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index fc11d98c9b..61205bd478 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -592,19 +592,8 @@ adjustpointers(byte **scanp, BitVector *bv, AdjustInfo *adjinfo, Func *f)
 			break;
 		case BitsMultiWord:
 			switch(bv->data[(i+1) / (32 / BitsPerPointer)] >> ((i+1) * BitsPerPointer & 31) & 3) {
-			case BitsString:
-				// string referents are never on the stack, never need to be adjusted
-				i++; // skip len
-				break;
-			case BitsSlice:
-				p = scanp[i];
-				if(minp <= p && p < maxp) {
-					if(StackDebug >= 3)
-						runtime·printf("adjust slice %p\n", p);
-					scanp[i] = p + delta;
-				}
-				i += 2; // skip len, cap
-				break;
+			default:
+				runtime·throw("unexpected garbage collection bits");
 			case BitsEface:
 				t = (Type*)scanp[i];
 				if(t != nil && ((t->kind & KindDirectIface) == 0 || (t->kind & KindNoPointers) == 0)) {
diff --git a/test/slice3.go b/test/slice3.go
index 3cf34b57e7..857eaf3a09 100644
--- a/test/slice3.go
+++ b/test/slice3.go
@@ -19,10 +19,10 @@ var bout *bufio.Writer
 
 func main() {
 	bout = bufio.NewWriter(os.Stdout)
-	
+
 	fmt.Fprintf(bout, "%s", programTop)
 	fmt.Fprintf(bout, "func main() {\n")
-	
+
 	index := []string{
 		"0",
 		"1",
@@ -38,7 +38,7 @@ func main() {
 		"v10",
 		"v20",
 	}
-	
+
 	parse := func(s string) (n int, isconst bool) {
 		if s == "vminus1" {
 			return -1, false
@@ -69,7 +69,7 @@ func main() {
 						iconst && kconst && iv > kv,
 						iconst && base == "array" && iv > Cap,
 						jconst && base == "array" && jv > Cap,
-						kconst && base == "array" && kv > Cap:				
+						kconst && base == "array" && kv > Cap:
 						continue
 					}
 
@@ -82,7 +82,7 @@ func main() {
 						xlen = jv - iv
 						xcap = kv - iv
 					}
-					fmt.Fprintf(bout, "\tcheckSlice(%q, func() []byte { return %s }, %d, %d, %d)\n", expr, expr, xbase, xlen, xcap)									
+					fmt.Fprintf(bout, "\tcheckSlice(%q, func() []byte { return %s }, %d, %d, %d)\n", expr, expr, xbase, xlen, xcap)
 				}
 			}
 		}
@@ -147,9 +147,13 @@ func checkSlice(desc string, f func() []byte, xbase, xlen, xcap int) {
 		println(desc, "=", base, len, cap, "want panic")
 		return
 	}
-	if base != uintptr(xbase) || len != uintptr(xlen) || cap != uintptr(xcap) {
+	if cap != 0 && base != uintptr(xbase) || base >= 10 || len != uintptr(xlen) || cap != uintptr(xcap) {
 		notOK()
-		println(desc, "=", base, len, cap, "want", xbase, xlen, xcap)
+		if cap == 0 {
+			println(desc, "=", base, len, cap, "want", "0-9", xlen, xcap)
+		} else {
+			println(desc, "=", base, len, cap, "want", xbase, xlen, xcap)
+		}
 	}
 }
 
diff --git a/test/slicecap.go b/test/slicecap.go
new file mode 100644
index 0000000000..dceb7e2cca
--- /dev/null
+++ b/test/slicecap.go
@@ -0,0 +1,90 @@
+// run
+
+// 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 "unsafe"
+
+var (
+	hello = "hello"
+	bytes = []byte{1, 2, 3, 4, 5}
+	ints  = []int32{1, 2, 3, 4, 5}
+
+	five = 5
+
+	ok = true
+)
+
+func notOK() {
+	if ok {
+		println("BUG:")
+		ok = false
+	}
+}
+
+func checkString(desc, s string) {
+	p1 := *(*uintptr)(unsafe.Pointer(&s))
+	p2 := *(*uintptr)(unsafe.Pointer(&hello))
+	if p1-p2 >= 5 {
+		notOK()
+		println("string", desc, "has invalid base")
+	}
+}
+
+func checkBytes(desc string, s []byte) {
+	p1 := *(*uintptr)(unsafe.Pointer(&s))
+	p2 := *(*uintptr)(unsafe.Pointer(&bytes))
+	if p1-p2 >= 5 {
+		println("byte slice", desc, "has invalid base")
+	}
+}
+
+func checkInts(desc string, s []int32) {
+	p1 := *(*uintptr)(unsafe.Pointer(&s))
+	p2 := *(*uintptr)(unsafe.Pointer(&ints))
+	if p1-p2 >= 5*4 {
+		println("int slice", desc, "has invalid base")
+	}
+}
+
+func main() {
+	{
+		x := hello
+		checkString("x", x)
+		checkString("x[5:]", x[5:])
+		checkString("x[five:]", x[five:])
+		checkString("x[5:five]", x[5:five])
+		checkString("x[five:5]", x[five:5])
+		checkString("x[five:five]", x[five:five])
+		checkString("x[1:][2:][2:]", x[1:][2:][2:])
+		y := x[4:]
+		checkString("y[1:]", y[1:])
+	}
+	{
+		x := bytes
+		checkBytes("x", x)
+		checkBytes("x[5:]", x[5:])
+		checkBytes("x[five:]", x[five:])
+		checkBytes("x[5:five]", x[5:five])
+		checkBytes("x[five:5]", x[five:5])
+		checkBytes("x[five:five]", x[five:five])
+		checkBytes("x[1:][2:][2:]", x[1:][2:][2:])
+		y := x[4:]
+		checkBytes("y[1:]", y[1:])
+	}
+	{
+		x := ints
+		checkInts("x", x)
+		checkInts("x[5:]", x[5:])
+		checkInts("x[five:]", x[five:])
+		checkInts("x[5:five]", x[5:five])
+		checkInts("x[five:5]", x[five:5])
+		checkInts("x[five:five]", x[five:five])
+		checkInts("x[1:][2:][2:]", x[1:][2:][2:])
+		y := x[4:]
+		checkInts("y[1:]", y[1:])
+	}
+}

From a6cd73345013af7a6b45447f50352b5c860c46bd Mon Sep 17 00:00:00 2001
From: Adam Langley <agl@golang.org>
Date: Mon, 25 Aug 2014 11:40:10 -0700
Subject: [PATCH 208/423] crypto/cipher: add CFB test vectors.

Fixes #8576.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/136720043
---
 src/pkg/crypto/cipher/cfb_test.go | 77 ++++++++++++++++++++++++++++++-
 1 file changed, 76 insertions(+), 1 deletion(-)

diff --git a/src/pkg/crypto/cipher/cfb_test.go b/src/pkg/crypto/cipher/cfb_test.go
index ec708ab2be..9b544bb211 100644
--- a/src/pkg/crypto/cipher/cfb_test.go
+++ b/src/pkg/crypto/cipher/cfb_test.go
@@ -9,10 +9,85 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
+	"encoding/hex"
 	"testing"
 )
 
-func TestCFB(t *testing.T) {
+// cfbTests contains the test vectors from
+// http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf, section
+// F.3.13.
+var cfbTests = []struct {
+	key, iv, plaintext, ciphertext string
+}{
+	{
+		"2b7e151628aed2a6abf7158809cf4f3c",
+		"000102030405060708090a0b0c0d0e0f",
+		"6bc1bee22e409f96e93d7e117393172a",
+		"3b3fd92eb72dad20333449f8e83cfb4a",
+	},
+	{
+		"2b7e151628aed2a6abf7158809cf4f3c",
+		"3B3FD92EB72DAD20333449F8E83CFB4A",
+		"ae2d8a571e03ac9c9eb76fac45af8e51",
+		"c8a64537a0b3a93fcde3cdad9f1ce58b",
+	},
+	{
+		"2b7e151628aed2a6abf7158809cf4f3c",
+		"C8A64537A0B3A93FCDE3CDAD9F1CE58B",
+		"30c81c46a35ce411e5fbc1191a0a52ef",
+		"26751f67a3cbb140b1808cf187a4f4df",
+	},
+	{
+		"2b7e151628aed2a6abf7158809cf4f3c",
+		"26751F67A3CBB140B1808CF187A4F4DF",
+		"f69f2445df4f9b17ad2b417be66c3710",
+		"c04b05357c5d1c0eeac4c66f9ff7f2e6",
+	},
+}
+
+func TestCFBVectors(t *testing.T) {
+	for i, test := range cfbTests {
+		key, err := hex.DecodeString(test.key)
+		if err != nil {
+			t.Fatal(err)
+		}
+		iv, err := hex.DecodeString(test.iv)
+		if err != nil {
+			t.Fatal(err)
+		}
+		plaintext, err := hex.DecodeString(test.plaintext)
+		if err != nil {
+			t.Fatal(err)
+		}
+		expected, err := hex.DecodeString(test.ciphertext)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		block, err := aes.NewCipher(key)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		ciphertext := make([]byte, len(plaintext))
+		cfb := cipher.NewCFBEncrypter(block, iv)
+		cfb.XORKeyStream(ciphertext, plaintext)
+
+		if !bytes.Equal(ciphertext, expected) {
+			t.Errorf("#%d: wrong output: got %x, expected %x", i, ciphertext, expected)
+		}
+
+		cfbdec := cipher.NewCFBDecrypter(block, iv)
+		plaintextCopy := make([]byte, len(ciphertext))
+		cfbdec.XORKeyStream(plaintextCopy, ciphertext)
+
+		if !bytes.Equal(plaintextCopy, plaintextCopy) {
+			t.Errorf("#%d: wrong plaintext: got %x, expected %x", i, plaintextCopy, plaintext)
+		}
+	}
+}
+
+func TestCFBInverse(t *testing.T) {
 	block, err := aes.NewCipher(commonKey128)
 	if err != nil {
 		t.Error(err)

From 6bddb13bc4f315726aae22ac0342fb044440e8fc Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 25 Aug 2014 11:44:08 -0700
Subject: [PATCH 209/423] net/http: populate Request.Close in ReadRequest

Fixes #8261

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/126620043
---
 src/pkg/net/http/readrequest_test.go | 41 +++++++++++++++++++++++-----
 src/pkg/net/http/request.go          |  1 +
 src/pkg/net/http/transfer.go         |  8 ++++--
 3 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/src/pkg/net/http/readrequest_test.go b/src/pkg/net/http/readrequest_test.go
index ffdd6a892d..e930d99af6 100644
--- a/src/pkg/net/http/readrequest_test.go
+++ b/src/pkg/net/http/readrequest_test.go
@@ -11,6 +11,7 @@ import (
 	"io"
 	"net/url"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -295,14 +296,39 @@ var reqTests = []reqTest{
 		noTrailer,
 		noError,
 	},
+
+	// Connection: close. golang.org/issue/8261
+	{
+		"GET / HTTP/1.1\r\nHost: issue8261.com\r\nConnection: close\r\n\r\n",
+		&Request{
+			Method: "GET",
+			URL: &url.URL{
+				Path: "/",
+			},
+			Header: Header{
+				// This wasn't removed from Go 1.0 to
+				// Go 1.3, so locking it in that we
+				// keep this:
+				"Connection": []string{"close"},
+			},
+			Host:       "issue8261.com",
+			Proto:      "HTTP/1.1",
+			ProtoMajor: 1,
+			ProtoMinor: 1,
+			Close:      true,
+			RequestURI: "/",
+		},
+
+		noBody,
+		noTrailer,
+		noError,
+	},
 }
 
 func TestReadRequest(t *testing.T) {
 	for i := range reqTests {
 		tt := &reqTests[i]
-		var braw bytes.Buffer
-		braw.WriteString(tt.Raw)
-		req, err := ReadRequest(bufio.NewReader(&braw))
+		req, err := ReadRequest(bufio.NewReader(strings.NewReader(tt.Raw)))
 		if err != nil {
 			if err.Error() != tt.Error {
 				t.Errorf("#%d: error %q, want error %q", i, err.Error(), tt.Error)
@@ -311,21 +337,22 @@ func TestReadRequest(t *testing.T) {
 		}
 		rbody := req.Body
 		req.Body = nil
-		diff(t, fmt.Sprintf("#%d Request", i), req, tt.Req)
+		testName := fmt.Sprintf("Test %d (%q)", i, tt.Raw)
+		diff(t, testName, req, tt.Req)
 		var bout bytes.Buffer
 		if rbody != nil {
 			_, err := io.Copy(&bout, rbody)
 			if err != nil {
-				t.Fatalf("#%d. copying body: %v", i, err)
+				t.Fatalf("%s: copying body: %v", testName, err)
 			}
 			rbody.Close()
 		}
 		body := bout.String()
 		if body != tt.Body {
-			t.Errorf("#%d: Body = %q want %q", i, body, tt.Body)
+			t.Errorf("%s: Body = %q want %q", testName, body, tt.Body)
 		}
 		if !reflect.DeepEqual(tt.Trailer, req.Trailer) {
-			t.Errorf("#%d. Trailers differ.\n got: %v\nwant: %v", i, req.Trailer, tt.Trailer)
+			t.Errorf("%s: Trailers differ.\n got: %v\nwant: %v", testName, req.Trailer, tt.Trailer)
 		}
 	}
 }
diff --git a/src/pkg/net/http/request.go b/src/pkg/net/http/request.go
index 131cb6d67e..6372943188 100644
--- a/src/pkg/net/http/request.go
+++ b/src/pkg/net/http/request.go
@@ -635,6 +635,7 @@ func ReadRequest(b *bufio.Reader) (req *Request, err error) {
 		return nil, err
 	}
 
+	req.Close = shouldClose(req.ProtoMajor, req.ProtoMinor, req.Header, false)
 	return req, nil
 }
 
diff --git a/src/pkg/net/http/transfer.go b/src/pkg/net/http/transfer.go
index 51b1dcb30b..520500330b 100644
--- a/src/pkg/net/http/transfer.go
+++ b/src/pkg/net/http/transfer.go
@@ -303,7 +303,7 @@ func readTransfer(msg interface{}, r *bufio.Reader) (err error) {
 		t.StatusCode = rr.StatusCode
 		t.ProtoMajor = rr.ProtoMajor
 		t.ProtoMinor = rr.ProtoMinor
-		t.Close = shouldClose(t.ProtoMajor, t.ProtoMinor, t.Header)
+		t.Close = shouldClose(t.ProtoMajor, t.ProtoMinor, t.Header, true)
 		isResponse = true
 		if rr.Request != nil {
 			t.RequestMethod = rr.Request.Method
@@ -502,7 +502,7 @@ func fixLength(isResponse bool, status int, requestMethod string, header Header,
 // Determine whether to hang up after sending a request and body, or
 // receiving a response and body
 // 'header' is the request headers
-func shouldClose(major, minor int, header Header) bool {
+func shouldClose(major, minor int, header Header, removeCloseHeader bool) bool {
 	if major < 1 {
 		return true
 	} else if major == 1 && minor == 0 {
@@ -514,7 +514,9 @@ func shouldClose(major, minor int, header Header) bool {
 		// TODO: Should split on commas, toss surrounding white space,
 		// and check each field.
 		if strings.ToLower(header.get("Connection")) == "close" {
-			header.Del("Connection")
+			if removeCloseHeader {
+				header.Del("Connection")
+			}
 			return true
 		}
 	}

From 21a4bdef2fa2ae5425c8d309a8e914e3e514c30a Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 23:24:18 +0400
Subject: [PATCH 210/423] runtime: restore nacl timens Deleted in cl/123700044.
 I am not sure whether I need to restore it, or delete rest of the uses...

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/129580043
---
 src/pkg/runtime/time.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/pkg/runtime/time.go b/src/pkg/runtime/time.go
index 97092c655e..c9df3a3643 100644
--- a/src/pkg/runtime/time.go
+++ b/src/pkg/runtime/time.go
@@ -34,6 +34,9 @@ var timers struct {
 	t            []*timer
 }
 
+// nacl fake time support.
+var timens int64
+
 // Package time APIs.
 // Godoc uses the comments in package time, not these.
 

From b2c43438d20bafda5c6fee777342371d1685e5cc Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 25 Aug 2014 23:30:39 +0400
Subject: [PATCH 211/423] runtime: restore scavenger constants Once and for
 all. Broken in cl/108640043. I've messed it before. To test scavenger-related
 changes one needs to alter the constants during final testing. And then it's
 very easy to submit with the altered constants.

LGTM=rsc
R=golang-codereviews
CC=golang-codereviews, rsc
https://golang.org/cl/136720044
---
 src/pkg/runtime/extern.go | 2 ++
 src/pkg/runtime/proc.c    | 9 +++++++--
 src/pkg/runtime/runtime.c | 2 ++
 src/pkg/runtime/runtime.h | 1 +
 4 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index a5bea7e46d..1a2d9c21a2 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -46,6 +46,8 @@ a comma-separated list of name=val pairs. Supported names are:
 	schedtrace: setting schedtrace=X causes the scheduler to emit a single line to standard
 	error every X milliseconds, summarizing the scheduler state.
 
+	scavenge: scavenge=1 enables debugging mode of heap scavenger.
+
 The GOMAXPROCS variable limits the number of operating system threads that
 can execute user-level Go code simultaneously. There is no limit to the number of threads
 that can be blocked in system calls on behalf of Go code; those do not count against
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index ce0f74aa6c..483903d6d9 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2632,10 +2632,15 @@ sysmon(void)
 	G *gp;
 
 	// If we go two minutes without a garbage collection, force one to run.
-	forcegcperiod = 2*60*1e6;
+	forcegcperiod = 2*60*1e9;
 	// If a heap span goes unused for 5 minutes after a garbage collection,
 	// we hand it back to the operating system.
-	scavengelimit = 5*60*1e6;
+	scavengelimit = 5*60*1e9;
+	if(runtime·debug.scavenge > 0) {
+		// Scavenge-a-lot for testing.
+		forcegcperiod = 10*1e6;
+		scavengelimit = 20*1e6;
+	}
 	lastscavenge = runtime·nanotime();
 	nscavenge = 0;
 	// Make wake-up period small enough for the sampling to be correct.
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 275fffb347..b1960088da 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -302,6 +302,7 @@ runtime·tickspersecond(void)
 	return res;
 }
 
+#pragma dataflag NOPTR
 DebugVars	runtime·debug;
 
 static struct {
@@ -314,6 +315,7 @@ static struct {
 	{"gcdead", &runtime·debug.gcdead},
 	{"scheddetail", &runtime·debug.scheddetail},
 	{"schedtrace", &runtime·debug.schedtrace},
+	{"scavenge", &runtime·debug.scavenge},
 };
 
 void
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 4f63fdf718..8d4773b9f7 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -562,6 +562,7 @@ struct DebugVars
 	int32	gcdead;
 	int32	scheddetail;
 	int32	schedtrace;
+	int32	scavenge;
 };
 
 extern bool runtime·precisestack;

From 958a6101eb75747555b2d5596de9ed93a54b83df Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Mon, 25 Aug 2014 13:47:38 -0700
Subject: [PATCH 212/423] cmd/go: clean up a couple of inconsequential nits in
 generate Post-submit glitches caught by reviewers.

LGTM=nightlyone, bradfitz
R=golang-codereviews, nightlyone, bradfitz
CC=golang-codereviews
https://golang.org/cl/126660043
---
 src/cmd/go/generate.go      | 2 +-
 src/cmd/go/generate_test.go | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cmd/go/generate.go b/src/cmd/go/generate.go
index 5859e9eefd..167758207e 100644
--- a/src/cmd/go/generate.go
+++ b/src/cmd/go/generate.go
@@ -161,7 +161,7 @@ type Generator struct {
 // run runs the generators in the current file.
 func (g *Generator) run() (ok bool) {
 	// Processing below here calls g.errorf on failure, which does panic(stop).
-	// If we encouter an error, we abort the package.
+	// If we encounter an error, we abort the package.
 	defer func() {
 		e := recover()
 		if e != nil {
diff --git a/src/cmd/go/generate_test.go b/src/cmd/go/generate_test.go
index 881a8fe9b6..93c0ae66e9 100644
--- a/src/cmd/go/generate_test.go
+++ b/src/cmd/go/generate_test.go
@@ -26,7 +26,6 @@ var splitTests = []splitTest{
 	{"$GOPACKAGE", []string{"sys"}},
 	{"a $XXNOTDEFINEDXX b", []string{"a", "", "b"}},
 	{"/$XXNOTDEFINED/", []string{"//"}},
-	{"$GOARCH", []string{runtime.GOARCH}},
 	{"yacc -o $GOARCH/yacc_$GOFILE", []string{"go", "tool", "yacc", "-o", runtime.GOARCH + "/yacc_proc.go"}},
 }
 

From 2c121b68b1c39f0a36546db2457d34e18c4bf73a Mon Sep 17 00:00:00 2001
From: Caleb Spare <cespare@gmail.com>
Date: Mon, 25 Aug 2014 14:42:27 -0700
Subject: [PATCH 213/423] strings, bytes: document behavior of Replace when old
 is empty

Fixes #8143.

LGTM=r
R=rsc, bradfitz, r
CC=golang-codereviews
https://golang.org/cl/135760043
---
 src/pkg/bytes/bytes.go     | 3 +++
 src/pkg/strings/strings.go | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/pkg/bytes/bytes.go b/src/pkg/bytes/bytes.go
index d8b6f998b3..34c22bbfb1 100644
--- a/src/pkg/bytes/bytes.go
+++ b/src/pkg/bytes/bytes.go
@@ -605,6 +605,9 @@ func Runes(s []byte) []rune {
 
 // Replace returns a copy of the slice s with the first n
 // non-overlapping instances of old replaced by new.
+// If old is empty, it matches at the beginning of the slice
+// and after each UTF-8 sequence, yielding up to k+1 replacements
+// for a k-rune slice.
 // If n < 0, there is no limit on the number of replacements.
 func Replace(s, old, new []byte, n int) []byte {
 	m := 0
diff --git a/src/pkg/strings/strings.go b/src/pkg/strings/strings.go
index 53bcd6b98a..5f19695d3f 100644
--- a/src/pkg/strings/strings.go
+++ b/src/pkg/strings/strings.go
@@ -635,6 +635,9 @@ func TrimSuffix(s, suffix string) string {
 
 // Replace returns a copy of the string s with the first n
 // non-overlapping instances of old replaced by new.
+// If old is empty, it matches at the beginning of the string
+// and after each UTF-8 sequence, yielding up to k+1 replacements
+// for a k-rune string.
 // If n < 0, there is no limit on the number of replacements.
 func Replace(s, old, new string, n int) string {
 	if old == new || n == 0 {

From dff17f4617843bc4c7cbfcdb265cc0fb265c8252 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Mon, 25 Aug 2014 14:56:35 -0700
Subject: [PATCH 214/423] unicode/maketables: add -output flag, buffer output,
 use gofmt Simplify the invocation (and speed it up substantially) in
 preparation for move to go generate.

LGTM=bradfitz, mpvl
R=mpvl, bradfitz, josharian
CC=golang-codereviews
https://golang.org/cl/135790043
---
 src/pkg/unicode/Makefile      |   3 +-
 src/pkg/unicode/maketables.go | 176 ++++++++++++++++++++++------------
 2 files changed, 117 insertions(+), 62 deletions(-)

diff --git a/src/pkg/unicode/Makefile b/src/pkg/unicode/Makefile
index 33b06ca10d..aba12a0710 100644
--- a/src/pkg/unicode/Makefile
+++ b/src/pkg/unicode/Makefile
@@ -6,8 +6,7 @@ maketables: maketables.go
 	go build maketables.go
 
 tables:	maketables
-	./maketables --tables=all > tables.go
-	gofmt -w tables.go
+	./maketables --tables=all -output tables.go
 
 # Downloads from www.unicode.org, so not part
 # of standard test scripts.
diff --git a/src/pkg/unicode/maketables.go b/src/pkg/unicode/maketables.go
index 5de98c3b47..d1c9aa04ae 100644
--- a/src/pkg/unicode/maketables.go
+++ b/src/pkg/unicode/maketables.go
@@ -13,9 +13,11 @@ import (
 	"bufio"
 	"flag"
 	"fmt"
+	"io"
 	"log"
 	"net/http"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"sort"
@@ -26,6 +28,7 @@ import (
 
 func main() {
 	flag.Parse()
+	setupOutput()
 	loadChars() // always needed
 	loadCasefold()
 	printCategories()
@@ -35,6 +38,7 @@ func main() {
 	printLatinProperties()
 	printCasefold()
 	printSizes()
+	flushOutput()
 }
 
 var dataURL = flag.String("data", "", "full URL for UnicodeData.txt; defaults to --url/UnicodeData.txt")
@@ -60,10 +64,62 @@ var test = flag.Bool("test",
 var localFiles = flag.Bool("local",
 	false,
 	"data files have been copied to current directory; for debugging only")
+var outputFile = flag.String("output",
+	"",
+	"output file for generated tables; default stdout")
 
 var scriptRe = regexp.MustCompile(`^([0-9A-F]+)(\.\.[0-9A-F]+)? *; ([A-Za-z_]+)$`)
 var logger = log.New(os.Stderr, "", log.Lshortfile)
 
+var output *bufio.Writer // points to os.Stdout or to "gofmt > outputFile"
+
+func setupOutput() {
+	output = bufio.NewWriter(startGofmt())
+}
+
+// startGofmt connects output to a gofmt process if -output is set.
+func startGofmt() io.Writer {
+	if *outputFile == "" {
+		return os.Stdout
+	}
+	stdout, err := os.Create(*outputFile)
+	if err != nil {
+		logger.Fatal(err)
+	}
+	// Pipe output to gofmt.
+	gofmt := exec.Command("gofmt")
+	fd, err := gofmt.StdinPipe()
+	if err != nil {
+		logger.Fatal(err)
+	}
+	gofmt.Stdout = stdout
+	gofmt.Stderr = os.Stderr
+	err = gofmt.Start()
+	if err != nil {
+		logger.Fatal(err)
+	}
+	return fd
+}
+
+func flushOutput() {
+	err := output.Flush()
+	if err != nil {
+		logger.Fatal(err)
+	}
+}
+
+func printf(format string, args ...interface{}) {
+	fmt.Fprintf(output, format, args...)
+}
+
+func print(args ...interface{}) {
+	fmt.Fprint(output, args...)
+}
+
+func println(args ...interface{}) {
+	fmt.Fprintln(output, args...)
+}
+
 type reader struct {
 	*bufio.Reader
 	fd   *os.File
@@ -245,11 +301,11 @@ func parseCategory(line string) (state State) {
 }
 
 func (char *Char) dump(s string) {
-	fmt.Print(s, " ")
+	print(s, " ")
 	for i := 0; i < len(char.field); i++ {
-		fmt.Printf("%s:%q ", fieldName[i], char.field[i])
+		printf("%s:%q ", fieldName[i], char.field[i])
 	}
-	fmt.Print("\n")
+	print("\n")
 }
 
 func (char *Char) letter(u, l, t string) {
@@ -411,18 +467,18 @@ func printCategories() {
 		fullCategoryTest(list)
 		return
 	}
-	fmt.Printf(progHeader, *tablelist, *dataURL, *casefoldingURL)
+	printf(progHeader, *tablelist, *dataURL, *casefoldingURL)
 
-	fmt.Println("// Version is the Unicode edition from which the tables are derived.")
-	fmt.Printf("const Version = %q\n\n", version())
+	println("// Version is the Unicode edition from which the tables are derived.")
+	printf("const Version = %q\n\n", version())
 
 	if *tablelist == "all" {
-		fmt.Println("// Categories is the set of Unicode category tables.")
-		fmt.Println("var Categories = map[string] *RangeTable {")
+		println("// Categories is the set of Unicode category tables.")
+		println("var Categories = map[string] *RangeTable {")
 		for _, k := range allCategories() {
-			fmt.Printf("\t%q: %s,\n", k, k)
+			printf("\t%q: %s,\n", k, k)
 		}
-		fmt.Print("}\n\n")
+		print("}\n\n")
 	}
 
 	decl := make(sort.StringSlice, len(list))
@@ -486,12 +542,12 @@ func printCategories() {
 			func(code rune) bool { return chars[code].category == name })
 	}
 	decl.Sort()
-	fmt.Println("// These variables have type *RangeTable.")
-	fmt.Println("var (")
+	println("// These variables have type *RangeTable.")
+	println("var (")
 	for _, d := range decl {
-		fmt.Print(d)
+		print(d)
 	}
-	fmt.Print(")\n\n")
+	print(")\n\n")
 }
 
 type Op func(code rune) bool
@@ -499,10 +555,10 @@ type Op func(code rune) bool
 const format = "\t\t{0x%04x, 0x%04x, %d},\n"
 
 func dumpRange(header string, inCategory Op) {
-	fmt.Print(header)
+	print(header)
 	next := rune(0)
 	latinOffset := 0
-	fmt.Print("\tR16: []Range16{\n")
+	print("\tR16: []Range16{\n")
 	// one Range for each iteration
 	count := &range16Count
 	size := 16
@@ -528,7 +584,7 @@ func dumpRange(header string, inCategory Op) {
 		}
 		if next >= rune(len(chars)) {
 			// no more characters
-			fmt.Printf(format, lo, hi, stride)
+			printf(format, lo, hi, stride)
 			break
 		}
 		// set stride
@@ -552,11 +608,11 @@ func dumpRange(header string, inCategory Op) {
 		// next range: start looking where this range ends
 		next = hi + 1
 	}
-	fmt.Print("\t},\n")
+	print("\t},\n")
 	if latinOffset > 0 {
-		fmt.Printf("\tLatinOffset: %d,\n", latinOffset)
+		printf("\tLatinOffset: %d,\n", latinOffset)
 	}
-	fmt.Print("}\n\n")
+	print("}\n\n")
 }
 
 func printRange(lo, hi, stride uint32, size int, count *int) (int, *int) {
@@ -568,17 +624,17 @@ func printRange(lo, hi, stride uint32, size int, count *int) (int, *int) {
 			// No range contains U+FFFF as an instance, so split
 			// the range into two entries. That way we can maintain
 			// the invariant that R32 contains only >= 1<<16.
-			fmt.Printf(format, lo, lo, 1)
+			printf(format, lo, lo, 1)
 			lo = hi
 			stride = 1
 			*count++
 		}
-		fmt.Print("\t},\n")
-		fmt.Print("\tR32: []Range32{\n")
+		print("\t},\n")
+		print("\tR32: []Range32{\n")
 		size = 32
 		count = &range32Count
 	}
-	fmt.Printf(format, lo, hi, stride)
+	printf(format, lo, hi, stride)
 	*count++
 	return size, count
 }
@@ -727,7 +783,7 @@ func printScriptOrProperty(doProps bool) {
 		return
 	}
 
-	fmt.Printf(
+	printf(
 		"// Generated by running\n"+
 			"//	maketables --%s=%s --url=%s\n"+
 			"// DO NOT EDIT\n\n",
@@ -736,16 +792,16 @@ func printScriptOrProperty(doProps bool) {
 		*url)
 	if flaglist == "all" {
 		if doProps {
-			fmt.Println("// Properties is the set of Unicode property tables.")
-			fmt.Println("var Properties = map[string] *RangeTable{")
+			println("// Properties is the set of Unicode property tables.")
+			println("var Properties = map[string] *RangeTable{")
 		} else {
-			fmt.Println("// Scripts is the set of Unicode script tables.")
-			fmt.Println("var Scripts = map[string] *RangeTable{")
+			println("// Scripts is the set of Unicode script tables.")
+			println("var Scripts = map[string] *RangeTable{")
 		}
 		for _, k := range all(table) {
-			fmt.Printf("\t%q: %s,\n", k, k)
+			printf("\t%q: %s,\n", k, k)
 		}
-		fmt.Print("}\n\n")
+		print("}\n\n")
 	}
 
 	decl := make(sort.StringSlice, len(list))
@@ -761,27 +817,27 @@ func printScriptOrProperty(doProps bool) {
 				name, name, name, name)
 		}
 		ndecl++
-		fmt.Printf("var _%s = &RangeTable {\n", name)
+		printf("var _%s = &RangeTable {\n", name)
 		ranges := foldAdjacent(table[name])
-		fmt.Print("\tR16: []Range16{\n")
+		print("\tR16: []Range16{\n")
 		size := 16
 		count := &range16Count
 		for _, s := range ranges {
 			size, count = printRange(s.Lo, s.Hi, s.Stride, size, count)
 		}
-		fmt.Print("\t},\n")
+		print("\t},\n")
 		if off := findLatinOffset(ranges); off > 0 {
-			fmt.Printf("\tLatinOffset: %d,\n", off)
+			printf("\tLatinOffset: %d,\n", off)
 		}
-		fmt.Print("}\n\n")
+		print("}\n\n")
 	}
 	decl.Sort()
-	fmt.Println("// These variables have type *RangeTable.")
-	fmt.Println("var (")
+	println("// These variables have type *RangeTable.")
+	println("var (")
 	for _, d := range decl {
-		fmt.Print(d)
+		print(d)
 	}
-	fmt.Print(")\n\n")
+	print(")\n\n")
 }
 
 func findLatinOffset(ranges []unicode.Range32) int {
@@ -940,7 +996,7 @@ func printCases() {
 		fullCaseTest()
 		return
 	}
-	fmt.Printf(
+	printf(
 		"// Generated by running\n"+
 			"//	maketables --data=%s --casefolding=%s\n"+
 			"// DO NOT EDIT\n\n"+
@@ -966,7 +1022,7 @@ func printCases() {
 		}
 		prevState = state
 	}
-	fmt.Print("}\n")
+	print("}\n")
 }
 
 func printCaseRange(lo, hi *caseState) {
@@ -979,14 +1035,14 @@ func printCaseRange(lo, hi *caseState) {
 	}
 	switch {
 	case hi.point > lo.point && lo.isUpperLower():
-		fmt.Printf("\t{0x%04X, 0x%04X, d{UpperLower, UpperLower, UpperLower}},\n",
+		printf("\t{0x%04X, 0x%04X, d{UpperLower, UpperLower, UpperLower}},\n",
 			lo.point, hi.point)
 	case hi.point > lo.point && lo.isLowerUpper():
 		logger.Fatalf("LowerUpper sequence: should not happen: %U.  If it's real, need to fix To()", lo.point)
-		fmt.Printf("\t{0x%04X, 0x%04X, d{LowerUpper, LowerUpper, LowerUpper}},\n",
+		printf("\t{0x%04X, 0x%04X, d{LowerUpper, LowerUpper, LowerUpper}},\n",
 			lo.point, hi.point)
 	default:
-		fmt.Printf("\t{0x%04X, 0x%04X, d{%d, %d, %d}},\n",
+		printf("\t{0x%04X, 0x%04X, d{%d, %d, %d}},\n",
 			lo.point, hi.point,
 			lo.deltaToUpper, lo.deltaToLower, lo.deltaToTitle)
 	}
@@ -1025,7 +1081,7 @@ func printLatinProperties() {
 	if *test {
 		return
 	}
-	fmt.Println("var properties = [MaxLatin1+1]uint8{")
+	println("var properties = [MaxLatin1+1]uint8{")
 	for code := 0; code <= unicode.MaxLatin1; code++ {
 		var property string
 		switch chars[code].category {
@@ -1054,9 +1110,9 @@ func printLatinProperties() {
 		if code == ' ' {
 			property = "pZ | pp"
 		}
-		fmt.Printf("\t0x%02X: %s, // %q\n", code, property, code)
+		printf("\t0x%02X: %s, // %q\n", code, property, code)
 	}
-	fmt.Printf("}\n\n")
+	printf("}\n\n")
 }
 
 type runeSlice []rune
@@ -1235,15 +1291,15 @@ func printCaseOrbit() {
 		return
 	}
 
-	fmt.Printf("var caseOrbit = []foldPair{\n")
+	printf("var caseOrbit = []foldPair{\n")
 	for i := range chars {
 		c := &chars[i]
 		if c.caseOrbit != 0 {
-			fmt.Printf("\t{0x%04X, 0x%04X},\n", i, c.caseOrbit)
+			printf("\t{0x%04X, 0x%04X},\n", i, c.caseOrbit)
 			foldPairCount++
 		}
 	}
-	fmt.Printf("}\n\n")
+	printf("}\n\n")
 }
 
 func printCatFold(name string, m map[string]map[rune]bool) {
@@ -1288,12 +1344,12 @@ func printCatFold(name string, m map[string]map[rune]bool) {
 		return
 	}
 
-	fmt.Print(comment[name])
-	fmt.Printf("var %s = map[string]*RangeTable{\n", name)
+	print(comment[name])
+	printf("var %s = map[string]*RangeTable{\n", name)
 	for _, name := range allCatFold(m) {
-		fmt.Printf("\t%q: fold%s,\n", name, name)
+		printf("\t%q: fold%s,\n", name, name)
 	}
-	fmt.Printf("}\n\n")
+	printf("}\n\n")
 	for _, name := range allCatFold(m) {
 		class := m[name]
 		dumpRange(
@@ -1310,11 +1366,11 @@ func printSizes() {
 	if *test {
 		return
 	}
-	fmt.Println()
-	fmt.Printf("// Range entries: %d 16-bit, %d 32-bit, %d total.\n", range16Count, range32Count, range16Count+range32Count)
+	println()
+	printf("// Range entries: %d 16-bit, %d 32-bit, %d total.\n", range16Count, range32Count, range16Count+range32Count)
 	range16Bytes := range16Count * 3 * 2
 	range32Bytes := range32Count * 3 * 4
-	fmt.Printf("// Range bytes: %d 16-bit, %d 32-bit, %d total.\n", range16Bytes, range32Bytes, range16Bytes+range32Bytes)
-	fmt.Println()
-	fmt.Printf("// Fold orbit bytes: %d pairs, %d bytes\n", foldPairCount, foldPairCount*2*2)
+	printf("// Range bytes: %d 16-bit, %d 32-bit, %d total.\n", range16Bytes, range32Bytes, range16Bytes+range32Bytes)
+	println()
+	printf("// Fold orbit bytes: %d pairs, %d bytes\n", foldPairCount, foldPairCount*2*2)
 }

From 236cf308c298b49d64d32a76f5ee242a2b3bc1b4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Mon, 25 Aug 2014 15:29:47 -0700
Subject: [PATCH 215/423] cmd/gofmt: don't permit -w with stdin

Also: use 0x644 file permission if a new file
is created (should not happen anymore, though).

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/126610044
---
 src/cmd/gofmt/gofmt.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go
index f7d30d8405..f322a2b0a0 100644
--- a/src/cmd/gofmt/gofmt.go
+++ b/src/cmd/gofmt/gofmt.go
@@ -122,7 +122,7 @@ func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error
 			fmt.Fprintln(out, filename)
 		}
 		if *write {
-			err = ioutil.WriteFile(filename, res, 0)
+			err = ioutil.WriteFile(filename, res, 0644)
 			if err != nil {
 				return err
 			}
@@ -186,6 +186,11 @@ func gofmtMain() {
 	initRewrite()
 
 	if flag.NArg() == 0 {
+		if *write {
+			fmt.Fprintln(os.Stderr, "error: cannot use -w with standard input")
+			exitCode = 2
+			return
+		}
 		if err := processFile("<standard input>", os.Stdin, os.Stdout, true); err != nil {
 			report(err)
 		}

From 4516a60062f54e2b76d9dd53590120d5c368f24c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 25 Aug 2014 18:45:29 -0400
Subject: [PATCH 216/423] liblink: introduce way to avoid pc-relative
 addressing

For Solaris. Sigh.

LGTM=dave
R=aram, iant, dave
CC=golang-codereviews
https://golang.org/cl/129540043
---
 src/liblink/asm6.c | 35 +++++++++++++++++++++++++++++++----
 1 file changed, 31 insertions(+), 4 deletions(-)

diff --git a/src/liblink/asm6.c b/src/liblink/asm6.c
index 576f349750..999507650d 100644
--- a/src/liblink/asm6.c
+++ b/src/liblink/asm6.c
@@ -1535,6 +1535,19 @@ static Optab optab[] =
 static Optab*	opindex[ALAST+1];
 static vlong	vaddr(Link*, Addr*, Reloc*);
 
+// isextern reports whether s describes an external symbol that must avoid pc-relative addressing.
+// This happens on systems like Solaris that call .so functions instead of system calls.
+// It does not seem to be necessary for any other systems. This is probably working
+// around a Solaris-specific bug that should be fixed differently, but we don't know
+// what that bug is. And this does fix it.
+static int
+isextern(LSym *s)
+{
+	// All the Solaris dynamic imports from libc.so begin with "libc·", which
+	// the compiler rewrites to "libc." by the time liblink gets it.
+	return strncmp(s->name, "libc.", 5) == 0;
+}
+
 // single-instruction no-ops of various lengths.
 // constructed by hand and disassembled with gdb to verify.
 // see http://www.agner.org/optimize/optimizing_assembly.pdf for discussion.
@@ -1932,6 +1945,8 @@ oclass(Link *ctxt, Addr *a)
 				switch(a->index) {
 				case D_EXTERN:
 				case D_STATIC:
+					if(a->sym != nil && isextern(a->sym))
+						return Yi32;
 					return Yiauto; // use pc-relative addressing
 				case D_AUTO:
 				case D_PARAM:
@@ -2109,7 +2124,7 @@ oclass(Link *ctxt, Addr *a)
 				return Yi32;	/* unsigned */
 			return Yi64;
 		}
-		return Yi32;	/* TO DO: D_ADDR as Yi64 */
+		return Yi32;
 
 	case D_BRANCH:
 		return Ybr;
@@ -2282,12 +2297,17 @@ vaddr(Link *ctxt, Addr *a, Reloc *r)
 			ctxt->diag("need reloc for %D", a);
 			sysfatal("reloc");
 		}
-		r->siz = 4;	// TODO: 8 for external symbols
+		if(isextern(s)) {
+			r->siz = 4;
+			r->type = R_ADDR;
+		} else {
+			r->siz = 4;
+			r->type = R_PCREL;
+		}
 		r->off = -1;	// caller must fill in
 		r->sym = s;
 		r->add = v;
 		v = 0;
-		r->type = R_PCREL;
 		if(s->type == STLSBSS) {
 			r->xadd = r->add - r->siz;
 			r->type = R_TLS;
@@ -2327,6 +2347,13 @@ asmandsz(Link *ctxt, Addr *a, int r, int rex, int m64)
 			switch(t) {
 			default:
 				goto bad;
+			case D_EXTERN:
+			case D_STATIC:
+				if(!isextern(a->sym))
+					goto bad;
+				t = D_NONE;
+				v = vaddr(ctxt, a, &rel);
+				break;
 			case D_AUTO:
 			case D_PARAM:
 				t = D_SP;
@@ -2386,7 +2413,7 @@ asmandsz(Link *ctxt, Addr *a, int r, int rex, int m64)
 
 	ctxt->rexflag |= (regrex[t] & Rxb) | rex;
 	if(t == D_NONE || (D_CS <= t && t <= D_GS) || t == D_TLS) {
-		if(t == D_NONE && (a->type == D_STATIC || a->type == D_EXTERN) || ctxt->asmode != 64) {
+		if((a->sym == nil || !isextern(a->sym)) && t == D_NONE && (a->type == D_STATIC || a->type == D_EXTERN) || ctxt->asmode != 64) {
 			*ctxt->andptr++ = (0 << 6) | (5 << 0) | (r << 3);
 			goto putrelv;
 		}

From 56916feea3ddbc3c2dedbe3b6a57b6c4a31c567b Mon Sep 17 00:00:00 2001
From: Caleb Spare <cespare@gmail.com>
Date: Mon, 25 Aug 2014 16:42:15 -0700
Subject: [PATCH 217/423] regexp: fix imports in the middle of the license
 header

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/129620043
---
 src/pkg/regexp/onepass.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/pkg/regexp/onepass.go b/src/pkg/regexp/onepass.go
index 7666a80ee5..e6f4285638 100644
--- a/src/pkg/regexp/onepass.go
+++ b/src/pkg/regexp/onepass.go
@@ -1,4 +1,6 @@
 // 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 regexp
 
@@ -9,9 +11,6 @@ import (
 	"unicode"
 )
 
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
 // "One-pass" regexp execution.
 // Some regexps can be analyzed to determine that they never need
 // backtracking: they are guaranteed to run in one pass over the string

From 3c466dfea4db91202ec397502f50d119e0d72d47 Mon Sep 17 00:00:00 2001
From: ChaiShushan <chaishushan@gmail.com>
Date: Mon, 25 Aug 2014 20:01:43 -0700
Subject: [PATCH 218/423] cmd/go: add missing doc for GOOS and GOARCH

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/133900043
---
 src/cmd/go/doc.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/cmd/go/doc.go b/src/cmd/go/doc.go
index 19fe5cd3ef..0d4e263891 100644
--- a/src/cmd/go/doc.go
+++ b/src/cmd/go/doc.go
@@ -250,6 +250,10 @@ quoted string appears a single argument to the generator.
 
 Go generate sets several variables when it runs the generator:
 
+	$GOARCH
+		The execution architecture (arm, amd64, etc.)
+	$GOOS
+		The execution operating system (linux, windows, etc.)
 	$GOFILE
 		The base name of the file.
 	$GOPACKAGE

From 87b452537a599522cb155592f1f24bfc8a956e4c Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 25 Aug 2014 21:38:39 -0700
Subject: [PATCH 219/423] io: document that Readers and Writers must not retain
 buffers

There are both many callers and many implementations of these
interfaces, so make the contract explicit. Callers generally
assume this, and at least the standard library and other
implementations obey this, but it's never stated explicitly,
making it somewhat risky to assume.

LGTM=gri, rsc
R=golang-codereviews, gri
CC=golang-codereviews, r, rsc
https://golang.org/cl/132150043
---
 src/pkg/io/io.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/pkg/io/io.go b/src/pkg/io/io.go
index 022fdb6764..e8bbad537c 100644
--- a/src/pkg/io/io.go
+++ b/src/pkg/io/io.go
@@ -63,7 +63,7 @@ var ErrNoProgress = errors.New("multiple Read calls return no data or error")
 //
 // Implementations of Read are discouraged from returning a
 // zero byte count with a nil error, and callers should treat
-// that situation as a no-op.
+// that situation as a no-op. Implementations must not retain p.
 type Reader interface {
 	Read(p []byte) (n int, err error)
 }
@@ -75,6 +75,8 @@ type Reader interface {
 // and any error encountered that caused the write to stop early.
 // Write must return a non-nil error if it returns n < len(p).
 // Write must not modify the slice data, even temporarily.
+//
+// Implementations must not retain p.
 type Writer interface {
 	Write(p []byte) (n int, err error)
 }
@@ -192,6 +194,8 @@ type WriterTo interface {
 //
 // Clients of ReadAt can execute parallel ReadAt calls on the
 // same input source.
+//
+// Implementations must not retain p.
 type ReaderAt interface {
 	ReadAt(p []byte, off int64) (n int, err error)
 }
@@ -209,6 +213,8 @@ type ReaderAt interface {
 //
 // Clients of WriteAt can execute parallel WriteAt calls on the same
 // destination if the ranges do not overlap.
+//
+// Implementations must not retain p.
 type WriterAt interface {
 	WriteAt(p []byte, off int64) (n int, err error)
 }

From 32c0dce00ea2b641a6b2731aa2a149f4270ba663 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Mon, 25 Aug 2014 21:50:42 -0700
Subject: [PATCH 220/423] net/http: fix data race in test

I can't reproduce the race, but this should fix it.

Fixes #8483

LGTM=dvyukov
R=dvyukov
CC=golang-codereviews
https://golang.org/cl/126610043
---
 src/pkg/net/http/export_test.go    |  6 ++++++
 src/pkg/net/http/transport.go      | 19 +++++++++++++++----
 src/pkg/net/http/transport_test.go | 24 +++++++++++-------------
 3 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/src/pkg/net/http/export_test.go b/src/pkg/net/http/export_test.go
index 960563b240..2c87353554 100644
--- a/src/pkg/net/http/export_test.go
+++ b/src/pkg/net/http/export_test.go
@@ -70,3 +70,9 @@ func ResetCachedEnvironment() {
 }
 
 var DefaultUserAgent = defaultUserAgent
+
+// SetPendingDialHooks sets the hooks that run before and after handling
+// pending dials.
+func SetPendingDialHooks(before, after func()) {
+	prePendingDial, postPendingDial = before, after
+}
diff --git a/src/pkg/net/http/transport.go b/src/pkg/net/http/transport.go
index b1cc632a78..7a229c1b71 100644
--- a/src/pkg/net/http/transport.go
+++ b/src/pkg/net/http/transport.go
@@ -444,6 +444,9 @@ func (t *Transport) dial(network, addr string) (c net.Conn, err error) {
 	return net.Dial(network, addr)
 }
 
+// Testing hooks:
+var prePendingDial, postPendingDial func()
+
 // getConn dials and creates a new persistConn to the target as
 // specified in the connectMethod.  This includes doing a proxy CONNECT
 // and/or setting up TLS.  If this doesn't return an error, the persistConn
@@ -460,9 +463,17 @@ func (t *Transport) getConn(req *Request, cm connectMethod) (*persistConn, error
 	dialc := make(chan dialRes)
 
 	handlePendingDial := func() {
-		if v := <-dialc; v.err == nil {
-			t.putIdleConn(v.pc)
+		if prePendingDial != nil {
+			prePendingDial()
 		}
+		go func() {
+			if v := <-dialc; v.err == nil {
+				t.putIdleConn(v.pc)
+			}
+			if postPendingDial != nil {
+				postPendingDial()
+			}
+		}()
 	}
 
 	cancelc := make(chan struct{})
@@ -484,10 +495,10 @@ func (t *Transport) getConn(req *Request, cm connectMethod) (*persistConn, error
 		// else's dial that they didn't use.
 		// But our dial is still going, so give it away
 		// when it finishes:
-		go handlePendingDial()
+		handlePendingDial()
 		return pc, nil
 	case <-cancelc:
-		go handlePendingDial()
+		handlePendingDial()
 		return nil, errors.New("net/http: request canceled while waiting for connection")
 	}
 }
diff --git a/src/pkg/net/http/transport_test.go b/src/pkg/net/http/transport_test.go
index 964ca0fca5..b55d30ddf9 100644
--- a/src/pkg/net/http/transport_test.go
+++ b/src/pkg/net/http/transport_test.go
@@ -1063,20 +1063,18 @@ func TestTransportConcurrency(t *testing.T) {
 	var wg sync.WaitGroup
 	wg.Add(numReqs)
 
-	tr := &Transport{
-		Dial: func(netw, addr string) (c net.Conn, err error) {
-			// Due to the Transport's "socket late
-			// binding" (see idleConnCh in transport.go),
-			// the numReqs HTTP requests below can finish
-			// with a dial still outstanding.  So count
-			// our dials as work too so the leak checker
-			// doesn't complain at us.
-			wg.Add(1)
-			defer wg.Done()
-			return net.Dial(netw, addr)
-		},
-	}
+	// Due to the Transport's "socket late binding" (see
+	// idleConnCh in transport.go), the numReqs HTTP requests
+	// below can finish with a dial still outstanding.  To keep
+	// the leak checker happy, keep track of pending dials and
+	// wait for them to finish (and be closed or returned to the
+	// idle pool) before we close idle connections.
+	SetPendingDialHooks(func() { wg.Add(1) }, wg.Done)
+	defer SetPendingDialHooks(nil, nil)
+
+	tr := &Transport{}
 	defer tr.CloseIdleConnections()
+
 	c := &Client{Transport: tr}
 	reqs := make(chan string)
 	defer close(reqs)

From 90653d7864818ebfc3a71eaf11c6ee9cdc7c1609 Mon Sep 17 00:00:00 2001
From: Sanjay Menakuru <balasanjay@gmail.com>
Date: Tue, 26 Aug 2014 09:01:52 +0400
Subject: [PATCH 221/423] runtime,sync: Convert procPin and procUnpin functions
 to Go.

LGTM=dvyukov
R=golang-codereviews, dvyukov
CC=golang-codereviews, khr
https://golang.org/cl/132880043
---
 src/pkg/runtime/proc.c       | 20 ++++++++++++++++++++
 src/pkg/runtime/runtime1.goc | 12 ------------
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 483903d6d9..1f687ebc92 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -3292,3 +3292,23 @@ haveexperiment(int8 *name)
 	}
 	return 0;
 }
+
+#pragma textflag NOSPLIT
+void
+sync·runtime_procPin(intptr p)
+{
+	M *mp;
+
+	mp = g->m;
+	// Disable preemption.
+	mp->locks++;
+	p = mp->p->id;
+	FLUSH(&p);
+}
+
+#pragma textflag NOSPLIT
+void
+sync·runtime_procUnpin()
+{
+	g->m->locks--;
+}
diff --git a/src/pkg/runtime/runtime1.goc b/src/pkg/runtime/runtime1.goc
index a95a4f944d..9529d6504b 100644
--- a/src/pkg/runtime/runtime1.goc
+++ b/src/pkg/runtime/runtime1.goc
@@ -114,15 +114,3 @@ func runtime∕pprof·runtime_cyclesPerSecond() (res int64) {
 	res = runtime·tickspersecond();
 }
 
-func sync·runtime_procPin() (p int) {
-	M *mp;
-
-	mp = g->m;
-	// Disable preemption.
-	mp->locks++;
-	p = mp->p->id;
-}
-
-func sync·runtime_procUnpin() {
-	g->m->locks--;
-}

From 0eaea6010ae65bc37f19f6f99ae328eef48abf2d Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Tue, 26 Aug 2014 05:39:04 +0000
Subject: [PATCH 222/423] runtime: convert int64tofloat64, uint64tofloat64 to
 Go

I noticed that 5g doesn't flush the float64 result back to the stack, hence the change in the function signature. I'm wondering if I should also change the signature for the other two functions.

LGTM=rsc
R=minux, josharian, rsc
CC=golang-codereviews
https://golang.org/cl/132990044
---
 src/pkg/runtime/vlrt.go    | 32 ++++++++++++++++++++++++--------
 src/pkg/runtime/vlrt_arm.c | 14 --------------
 2 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/src/pkg/runtime/vlrt.go b/src/pkg/runtime/vlrt.go
index 64154fce08..c346812aec 100644
--- a/src/pkg/runtime/vlrt.go
+++ b/src/pkg/runtime/vlrt.go
@@ -29,18 +29,34 @@ package runtime
 
 import "unsafe"
 
-func float64toint64(d float64, y uint64) {
-	_d2v(&y, d)
-}
-
-func float64touint64(d float64, y uint64) {
-	_d2v(&y, d)
-}
-
 const (
 	sign64 = 1 << (64 - 1)
 )
 
+func float64toint64(d float64) (y uint64) {
+	_d2v(&y, d)
+	return
+}
+
+func float64touint64(d float64) (y uint64) {
+	_d2v(&y, d)
+	return
+}
+
+func int64tofloat64(y int64) float64 {
+	if y < 0 {
+		return -uint64tofloat64(-uint64(y))
+	}
+	return uint64tofloat64(uint64(y))
+}
+
+func uint64tofloat64(y uint64) float64 {
+	hi := float64(uint32(y >> 32))
+	lo := float64(uint32(y))
+	d := hi*(1<<32) + lo
+	return d
+}
+
 func _d2v(y *uint64, d float64) {
 	x := *(*uint64)(unsafe.Pointer(&d))
 
diff --git a/src/pkg/runtime/vlrt_arm.c b/src/pkg/runtime/vlrt_arm.c
index 5e7807f455..b342a3eb86 100644
--- a/src/pkg/runtime/vlrt_arm.c
+++ b/src/pkg/runtime/vlrt_arm.c
@@ -159,20 +159,6 @@ _v2f(Vlong x)
 	return _v2d(x);
 }
 
-void
-runtime·int64tofloat64(Vlong y, double d)
-{
-	d = _v2d(y);
-	USED(&d); // FLUSH
-}
-
-void
-runtime·uint64tofloat64(Vlong y, double d)
-{
-	d = _ul2d(y.hi)*4294967296. + _ul2d(y.lo);
-	USED(&d); // FLUSH
-}
-
 static void
 dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
 {

From 39ffa8be78d2f54220c99b828e5346cabcf1598c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Oudompheng?= <oudomphe@phare.normalesup.org>
Date: Tue, 26 Aug 2014 08:34:46 +0200
Subject: [PATCH 223/423] runtime: convert Stack to Go.

LGTM=khr
R=khr, josharian
CC=golang-codereviews
https://golang.org/cl/129510043
---
 src/pkg/runtime/asm_386.s      |  6 +++++
 src/pkg/runtime/asm_amd64.s    |  6 +++++
 src/pkg/runtime/asm_amd64p32.s |  6 +++++
 src/pkg/runtime/asm_arm.s      |  7 ++++++
 src/pkg/runtime/debug.go       |  6 -----
 src/pkg/runtime/mprof.go       | 41 ++++++++++++++++++++++++++++++++++
 src/pkg/runtime/mprof.goc      | 33 ---------------------------
 src/pkg/runtime/stubs.go       |  6 +++++
 8 files changed, 72 insertions(+), 39 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 741832b4da..198a468efe 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -860,6 +860,12 @@ TEXT runtime·getcallersp(SB), NOSPLIT, $0-4
 	MOVL	sp+0(FP), AX
 	RET
 
+// func gogetcallersp(p unsafe.Pointer) uintptr
+TEXT runtime·gogetcallersp(SB),NOSPLIT,$0-8
+	MOVL	p+0(FP),AX		// addr of first arg
+	MOVL	AX, ret+4(FP)
+	RET
+
 // int64 runtime·cputicks(void), so really
 // void runtime·cputicks(int64 *ticks)
 TEXT runtime·cputicks(SB),NOSPLIT,$0-4
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 3b63c56a35..c53e2d350e 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -946,6 +946,12 @@ TEXT runtime·getcallersp(SB),NOSPLIT,$0-8
 	MOVQ	sp+0(FP), AX
 	RET
 
+// func gogetcallersp(p unsafe.Pointer) uintptr
+TEXT runtime·gogetcallersp(SB),NOSPLIT,$0-16
+	MOVQ	p+0(FP),AX		// addr of first arg
+	MOVQ	AX, ret+8(FP)
+	RET
+
 // int64 runtime·cputicks(void)
 TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 	RDTSC
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 5c6a73ab99..4c039d7767 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -747,6 +747,12 @@ TEXT runtime·getcallersp(SB),NOSPLIT,$0-8
 	MOVL	sp+0(FP), AX
 	RET
 
+// func gogetcallersp(p unsafe.Pointer) uintptr
+TEXT runtime·gogetcallersp(SB),NOSPLIT,$0-12
+	MOVL	p+0(FP),AX		// addr of first arg
+	MOVL	AX, ret+8(FP)
+	RET
+
 // int64 runtime·cputicks(void)
 TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 	RDTSC
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 07b99262bb..551ba0c88c 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -644,6 +644,13 @@ TEXT runtime·getcallersp(SB),NOSPLIT,$-4-4
 	MOVW	$-4(R0), R0
 	RET
 
+// func gogetcallersp(p unsafe.Pointer) uintptr
+TEXT runtime·gogetcallersp(SB),NOSPLIT,$-4-8
+	MOVW	0(FP), R0
+	MOVW	$-4(R0), R0
+	MOVW	R0, ret+4(FP)
+	RET
+
 TEXT runtime·emptyfunc(SB),0,$0-0
 	RET
 
diff --git a/src/pkg/runtime/debug.go b/src/pkg/runtime/debug.go
index 393598c28a..af44a64741 100644
--- a/src/pkg/runtime/debug.go
+++ b/src/pkg/runtime/debug.go
@@ -133,9 +133,3 @@ type BlockProfileRecord struct {
 	Cycles int64
 	StackRecord
 }
-
-// Stack formats a stack trace of the calling goroutine into buf
-// and returns the number of bytes written to buf.
-// If all is true, Stack formats stack traces of all other goroutines
-// into buf after the trace for the current goroutine.
-func Stack(buf []byte, all bool) int
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 7c90c21c98..95ea1297ed 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -141,6 +141,47 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 	return
 }
 
+// Stack formats a stack trace of the calling goroutine into buf
+// and returns the number of bytes written to buf.
+// If all is true, Stack formats stack traces of all other goroutines
+// into buf after the trace for the current goroutine.
+func Stack(buf []byte, all bool) int {
+	sp := gogetcallersp(unsafe.Pointer(&buf))
+	pc := gogetcallerpc(unsafe.Pointer(&buf))
+	mp := acquirem()
+	gp := mp.curg
+	if all {
+		semacquire(&worldsema, false)
+		mp.gcing = 1
+		releasem(mp)
+		stoptheworld()
+		if mp != acquirem() {
+			gothrow("Stack: rescheduled")
+		}
+	}
+
+	n := 0
+	if len(buf) > 0 {
+		gp.writebuf = &buf[0]
+		gp.writenbuf = int32(len(buf))
+		traceback(pc, sp, 0, gp)
+		if all {
+			tracebackothers(gp)
+		}
+		n = len(buf) - int(gp.writenbuf)
+		gp.writebuf = nil
+		gp.writenbuf = 0
+	}
+
+	if all {
+		mp.gcing = 0
+		semrelease(&worldsema)
+		starttheworld()
+	}
+	releasem(mp)
+	return n
+}
+
 // ThreadCreateProfile returns n, the number of records in the thread creation profile.
 // If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
 // If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index 57596b2231..a79081c72f 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -256,39 +256,6 @@ struct TRecord {
 	uintptr stk[32];
 };
 
-func Stack(b Slice, all bool) (n int) {
-	uintptr pc, sp;
-	
-	sp = runtime·getcallersp(&b);
-	pc = (uintptr)runtime·getcallerpc(&b);
-
-	if(all) {
-		runtime·semacquire(&runtime·worldsema, false);
-		g->m->gcing = 1;
-		runtime·stoptheworld();
-	}
-
-	if(b.len == 0)
-		n = 0;
-	else{
-		g->writebuf = (byte*)b.array;
-		g->writenbuf = b.len;
-		runtime·goroutineheader(g);
-		runtime·traceback(pc, sp, 0, g);
-		if(all)
-			runtime·tracebackothers(g);
-		n = b.len - g->writenbuf;
-		g->writebuf = nil;
-		g->writenbuf = 0;
-	}
-	
-	if(all) {
-		g->m->gcing = 0;
-		runtime·semrelease(&runtime·worldsema);
-		runtime·starttheworld();
-	}
-}
-
 static void
 saveg(uintptr pc, uintptr sp, G *gp, TRecord *r)
 {
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 6cabed063e..e3e14caab8 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -18,6 +18,9 @@ const (
 //go:noescape
 func gogetcallerpc(p unsafe.Pointer) uintptr
 
+//go:noescape
+func gogetcallersp(p unsafe.Pointer) uintptr
+
 //go:noescape
 func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
 
@@ -212,3 +215,6 @@ func gonotetsleepg(n *note, t int64) {
 }
 
 func exitsyscall()
+
+func traceback(pc, sp, lr uintptr, gp *g)
+func tracebackothers(gp *g)

From 2511d92ffe52c55ad5d22e585d55aed47c2e24fb Mon Sep 17 00:00:00 2001
From: Oling Cat <olingcat@gmail.com>
Date: Tue, 26 Aug 2014 05:26:48 -0700
Subject: [PATCH 224/423] doc/cmd.html: close a tag.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/130560043
---
 doc/cmd.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/cmd.html b/doc/cmd.html
index 725666f1de..132ea275fa 100644
--- a/doc/cmd.html
+++ b/doc/cmd.html
@@ -65,7 +65,7 @@ details.
 <td><a href="//godoc.org/code.google.com/p/go.tools/cmd/cover/">cover</a></td>
 <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
 <td>Cover is a program for creating and analyzing the coverage profiles
-generated by <code>"go test -coverprofile"</code>.
+generated by <code>"go test -coverprofile"</code>.</td>
 </tr>
 
 <tr>

From e5a06ccd3789aba38d5255be32cec1ff740f306b Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Tue, 26 Aug 2014 12:38:18 -0700
Subject: [PATCH 225/423] runtime: name hi and lo parts of ret in assembly

Makes vet happy.

LGTM=bradfitz
R=dvyukov, bradfitz
CC=golang-codereviews
https://golang.org/cl/131320043
---
 src/pkg/runtime/asm_386.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 198a468efe..2163c913d9 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -877,8 +877,8 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-4
 
 TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
 	RDTSC
-	MOVL    AX, ret+0(FP)
-	MOVL    DX, ret+4(FP)
+	MOVL    AX, ret_lo+0(FP)
+	MOVL    DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·ldt0setup(SB),NOSPLIT,$16-0

From cf55da8374da478ac25696d46791433f2f28ec7e Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Tue, 26 Aug 2014 14:24:04 -0700
Subject: [PATCH 226/423] A+C: Joe Shaw (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/133040043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 115850bced..370b41f5c0 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -217,6 +217,7 @@ Jimmy Zelinskie <jimmyzelinskie@gmail.com>
 Jingcheng Zhang <diogin@gmail.com>
 Joakim Sernbrant <serbaut@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
+Joe Shaw <joe@joeshaw.org>
 Joel Stemmer <stemmertech@gmail.com>
 John Asmuth <jasmuth@gmail.com>
 John C Barstow <jbowtie@amathaine.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 5115ac2178..c102c264ec 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -304,6 +304,7 @@ Jimmy Zelinskie <jimmyzelinskie@gmail.com>
 Jingcheng Zhang <diogin@gmail.com>
 Joakim Sernbrant <serbaut@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
+Joe Shaw <joe@joeshaw.org>
 Joel Sing <jsing@google.com>
 Joel Stemmer <stemmertech@gmail.com>
 Johan Euphrosine <proppy@google.com>

From 62be54a8c029a85bf06742a19bcdb5e86151559d Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Tue, 26 Aug 2014 14:43:03 -0700
Subject: [PATCH 227/423] unicode: use go generate instead of make to create
 tables.go

LGTM=mpvl, rsc
R=mpvl, rsc
CC=golang-codereviews
https://golang.org/cl/135820043
---
 src/pkg/unicode/Makefile  | 15 ---------------
 src/pkg/unicode/letter.go |  3 +++
 2 files changed, 3 insertions(+), 15 deletions(-)
 delete mode 100644 src/pkg/unicode/Makefile

diff --git a/src/pkg/unicode/Makefile b/src/pkg/unicode/Makefile
deleted file mode 100644
index aba12a0710..0000000000
--- a/src/pkg/unicode/Makefile
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2009 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-maketables: maketables.go
-	go build maketables.go
-
-tables:	maketables
-	./maketables --tables=all -output tables.go
-
-# Downloads from www.unicode.org, so not part
-# of standard test scripts.
-testtables: maketables
-	@echo '***' Be sure to make tables and go install first
-	./maketables -test
diff --git a/src/pkg/unicode/letter.go b/src/pkg/unicode/letter.go
index 977bd2b3b0..7fe4241edd 100644
--- a/src/pkg/unicode/letter.go
+++ b/src/pkg/unicode/letter.go
@@ -6,6 +6,9 @@
 // Unicode code points.
 package unicode
 
+// Tables are regenerated each time we update the Unicode version.
+//go:generate go run maketables.go -tables=all -output tables.go
+
 const (
 	MaxRune         = '\U0010FFFF' // Maximum valid Unicode code point.
 	ReplacementChar = '\uFFFD'     // Represents invalid code points.

From 1660ece7695a90e178aa08ef6e413811957791d5 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Tue, 26 Aug 2014 14:45:53 -0700
Subject: [PATCH 228/423] time: use go generate rather than Makefile (windows
 only) Also make genzabbrs.go more self-contained. Also run it (on Linux; does
 that matter?) to update the table.

LGTM=rsc
R=rsc, alex.brainman
CC=golang-codereviews
https://golang.org/cl/128350044
---
 src/pkg/time/Makefile                  |  9 ---------
 src/pkg/time/genzabbrs.go              | 20 +++++++++++++++++---
 src/pkg/time/zoneinfo_abbrs_windows.go | 11 ++++++-----
 src/pkg/time/zoneinfo_windows.go       |  2 ++
 4 files changed, 25 insertions(+), 17 deletions(-)
 delete mode 100644 src/pkg/time/Makefile

diff --git a/src/pkg/time/Makefile b/src/pkg/time/Makefile
deleted file mode 100644
index cba58e4e03..0000000000
--- a/src/pkg/time/Makefile
+++ /dev/null
@@ -1,9 +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.
-
-genzabbrs: genzabbrs.go
-	go build genzabbrs.go
-
-windows: genzabbrs
-	./genzabbrs | gofmt >zoneinfo_abbrs_windows.go
diff --git a/src/pkg/time/genzabbrs.go b/src/pkg/time/genzabbrs.go
index 7c637cb43a..9eb0728a42 100644
--- a/src/pkg/time/genzabbrs.go
+++ b/src/pkg/time/genzabbrs.go
@@ -7,22 +7,26 @@
 //
 // usage:
 //
-// go run genzabbrs.go | gofmt > $GOROOT/src/pkg/time/zoneinfo_abbrs_windows.go
+// go run genzabbrs.go -output zoneinfo_abbrs_windows.go
 //
 
 package main
 
 import (
+	"bytes"
 	"encoding/xml"
+	"flag"
+	"go/format"
 	"io/ioutil"
 	"log"
 	"net/http"
-	"os"
 	"sort"
 	"text/template"
 	"time"
 )
 
+var filename = flag.String("output", "zoneinfo_abbrs_windows.go", "output file name")
+
 // getAbbrs finds timezone abbreviations (standard and daylight saving time)
 // for location l.
 func getAbbrs(l *time.Location) (st, dt string) {
@@ -105,6 +109,7 @@ func readWindowsZones() (zones, error) {
 }
 
 func main() {
+	flag.Parse()
 	zs, err := readWindowsZones()
 	if err != nil {
 		log.Fatal(err)
@@ -117,7 +122,16 @@ func main() {
 		wzURL,
 		zs,
 	}
-	err = template.Must(template.New("prog").Parse(prog)).Execute(os.Stdout, v)
+	var buf bytes.Buffer
+	err = template.Must(template.New("prog").Parse(prog)).Execute(&buf, v)
+	if err != nil {
+		log.Fatal(err)
+	}
+	data, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile(*filename, data, 0644)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/src/pkg/time/zoneinfo_abbrs_windows.go b/src/pkg/time/zoneinfo_abbrs_windows.go
index 80334371fe..df0c10e91c 100644
--- a/src/pkg/time/zoneinfo_abbrs_windows.go
+++ b/src/pkg/time/zoneinfo_abbrs_windows.go
@@ -13,15 +13,16 @@ type abbr struct {
 }
 
 var abbrs = map[string]abbr{
-	"Egypt Standard Time":             {"EET", "EET"},    // Africa/Cairo
+	"Egypt Standard Time":             {"EET", "EEST"},   // Africa/Cairo
 	"Morocco Standard Time":           {"WET", "WEST"},   // Africa/Casablanca
 	"South Africa Standard Time":      {"SAST", "SAST"},  // Africa/Johannesburg
 	"W. Central Africa Standard Time": {"WAT", "WAT"},    // Africa/Lagos
 	"E. Africa Standard Time":         {"EAT", "EAT"},    // Africa/Nairobi
+	"Libya Standard Time":             {"EET", "EET"},    // Africa/Tripoli
 	"Namibia Standard Time":           {"WAT", "WAST"},   // Africa/Windhoek
 	"Alaskan Standard Time":           {"AKST", "AKDT"},  // America/Anchorage
 	"Paraguay Standard Time":          {"PYT", "PYST"},   // America/Asuncion
-	"Bahia Standard Time":             {"BRT", "BRST"},   // America/Bahia
+	"Bahia Standard Time":             {"BRT", "BRT"},    // America/Bahia
 	"SA Pacific Standard Time":        {"COT", "COT"},    // America/Bogota
 	"Argentina Standard Time":         {"ART", "ART"},    // America/Buenos_Aires
 	"Venezuela Standard Time":         {"VET", "VET"},    // America/Caracas
@@ -63,7 +64,6 @@ var abbrs = map[string]abbr{
 	"Nepal Standard Time":             {"NPT", "NPT"},    // Asia/Katmandu
 	"North Asia Standard Time":        {"KRAT", "KRAT"},  // Asia/Krasnoyarsk
 	"Magadan Standard Time":           {"MAGT", "MAGT"},  // Asia/Magadan
-	"E. Europe Standard Time":         {"EET", "EEST"},   // Asia/Nicosia
 	"N. Central Asia Standard Time":   {"NOVT", "NOVT"},  // Asia/Novosibirsk
 	"Myanmar Standard Time":           {"MMT", "MMT"},    // Asia/Rangoon
 	"Arab Standard Time":              {"AST", "AST"},    // Asia/Riyadh
@@ -105,11 +105,12 @@ var abbrs = map[string]abbr{
 	"Romance Standard Time":          {"CET", "CEST"},      // Europe/Paris
 	"Central European Standard Time": {"CET", "CEST"},      // Europe/Warsaw
 	"Mauritius Standard Time":        {"MUT", "MUT"},       // Indian/Mauritius
-	"Samoa Standard Time":            {"WST", "WST"},       // Pacific/Apia
+	"Samoa Standard Time":            {"WST", "WSDT"},      // Pacific/Apia
 	"New Zealand Standard Time":      {"NZST", "NZDT"},     // Pacific/Auckland
-	"Fiji Standard Time":             {"FJT", "FJT"},       // Pacific/Fiji
+	"Fiji Standard Time":             {"FJT", "FJST"},      // Pacific/Fiji
 	"Central Pacific Standard Time":  {"SBT", "SBT"},       // Pacific/Guadalcanal
 	"Hawaiian Standard Time":         {"HST", "HST"},       // Pacific/Honolulu
+	"Line Islands Standard Time":     {"LINT", "LINT"},     // Pacific/Kiritimati
 	"West Pacific Standard Time":     {"PGT", "PGT"},       // Pacific/Port_Moresby
 	"Tonga Standard Time":            {"TOT", "TOT"},       // Pacific/Tongatapu
 }
diff --git a/src/pkg/time/zoneinfo_windows.go b/src/pkg/time/zoneinfo_windows.go
index 6046743e67..02d8e0edcc 100644
--- a/src/pkg/time/zoneinfo_windows.go
+++ b/src/pkg/time/zoneinfo_windows.go
@@ -11,6 +11,8 @@ import (
 	"unsafe"
 )
 
+//go:generate go run genzabbrs.go -output zoneinfo_abbrs_windows.go
+
 // TODO(rsc): Fall back to copy of zoneinfo files.
 
 // BUG(brainman,rsc): On Windows, the operating system does not provide complete

From 9c504696f46295c7d2bbad3da7cb4854227a13b7 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Wed, 27 Aug 2014 15:23:38 +1000
Subject: [PATCH 229/423] cmd/gc: fix undefined behaviour warnings in
 mparith3.c

Update #8527

Fixes two warnings:

src/cmd/gc/mparith3.c:255:10: runtime error: shift exponent 52 is too large for 32-bit type 'int'
src/cmd/gc/mparith3.c:254:14: runtime error: shift exponent 52 is too large for 32-bit type 'int'

LGTM=rsc
R=r, dvyukov, rsc
CC=golang-codereviews
https://golang.org/cl/134940044
---
 src/cmd/gc/mparith3.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/gc/mparith3.c b/src/cmd/gc/mparith3.c
index 95618f1c61..6afd75c023 100644
--- a/src/cmd/gc/mparith3.c
+++ b/src/cmd/gc/mparith3.c
@@ -251,8 +251,8 @@ mpgetfltN(Mpflt *a, int prec, int bias)
 		s = minexp - e;
 		if(s > prec+1)
 			s = prec+1;
-		if((v & ((1<<s)-1)) != 0)
-			v |= 1<<s;
+		if((v & ((1ULL<<s)-1)) != 0)
+			v |= 1ULL<<s;
 		v >>= s;
 		e = minexp;
 	}

From 56f8b297c724e43971b2b35e72bd8be9d5c0ea44 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 11:10:01 -0400
Subject: [PATCH 230/423] CONTRIBUTORS: add Rick Hudson (Google CLA)

TBR=rlh
CC=golang-codereviews
https://golang.org/cl/131410043
---
 CONTRIBUTORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index c102c264ec..bcca6b2158 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -494,6 +494,7 @@ Richard Crowley <r@rcrowley.org>
 Richard Eric Gavaletz <gavaletz@gmail.com>
 Richard Musiol <mail@richard-musiol.de> <neelance@gmail.com>
 Rick Arnold <rickarnoldjr@gmail.com>
+Rick Hudson <rlh@golang.org>
 Risto Jaakko Saarelma <rsaarelm@gmail.com>
 Rob Pike <r@golang.org>
 Robert Daniel Kortschak <dan.kortschak@adelaide.edu.au>

From 0a7c7ac80e7c4ccd2b04b6b65100794adbd72ba5 Mon Sep 17 00:00:00 2001
From: Rick Hudson <rlh@golang.org>
Date: Wed, 27 Aug 2014 11:15:47 -0400
Subject: [PATCH 231/423] runtime: changes to g->atomicstatus (nee status) to
 support concurrent GC

Every change to g->atomicstatus is now done atomically so that we can
ensure that all gs pass through a gc safepoint on demand. This allows
the GC to move from one phase to the next safely. In some phases the
stack will be scanned. This CL only deals with the infrastructure that
allows g->atomicstatus to go from one state to another. Future CLs
will deal with scanning and monitoring what phase the GC is in.

The major change was to moving to using a Gscan bit to indicate that
the status is in a scan state. The only bug fix was in oldstack where
I wasn't moving to a Gcopystack state in order to block scanning until
the new stack was in place. The proc.go file is waiting for an atomic
load instruction.

LGTM=rsc
R=golang-codereviews, dvyukov, josharian, rsc
CC=golang-codereviews, khr
https://golang.org/cl/132960044
---
 src/pkg/runtime/heapdump.c      |  14 +-
 src/pkg/runtime/mgc0.c          |  19 +--
 src/pkg/runtime/mprof.goc       |   2 +-
 src/pkg/runtime/panic.c         |   4 +-
 src/pkg/runtime/proc.c          | 244 ++++++++++++++++++++++++++------
 src/pkg/runtime/proc.go         |  19 ++-
 src/pkg/runtime/runtime.h       |  33 +++--
 src/pkg/runtime/stack.c         |  56 +++++---
 src/pkg/runtime/traceback_arm.c |   2 +-
 src/pkg/runtime/traceback_x86.c |   2 +-
 10 files changed, 308 insertions(+), 87 deletions(-)

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 61f6fc2d95..ea299d0a2e 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -396,7 +396,7 @@ dumpgoroutine(G *gp)
 	dumpint((uintptr)sp);
 	dumpint(gp->goid);
 	dumpint(gp->gopc);
-	dumpint(gp->status);
+	dumpint(runtime·readgstatus(gp));
 	dumpbool(gp->issystem);
 	dumpbool(false);  // isbackground
 	dumpint(gp->waitsince);
@@ -442,14 +442,16 @@ dumpgs(void)
 {
 	G *gp;
 	uint32 i;
+	uint32 status;
 
 	// goroutines & stacks
 	for(i = 0; i < runtime·allglen; i++) {
 		gp = runtime·allg[i];
-		switch(gp->status){
+		status = runtime·readgstatus(gp); // The world is stopped so gp will not be in a scan state.
+		switch(status){
 		default:
-			runtime·printf("unexpected G.status %d\n", gp->status);
-			runtime·throw("mark - bad status");
+			runtime·printf("runtime: unexpected G.status %d\n", status);
+			runtime·throw("dumpgs in STW - bad status");
 		case Gdead:
 			break;
 		case Grunnable:
@@ -730,7 +732,7 @@ mdump(G *gp)
 	flush();
 
 	gp->param = nil;
-	gp->status = Grunning;
+	runtime·casgstatus(gp, Gwaiting, Grunning);
 	runtime·gogo(&gp->sched);
 }
 
@@ -751,7 +753,7 @@ runtime∕debug·WriteHeapDump(uintptr fd)
 	dumpfd = fd;
 
 	// Call dump routine on M stack.
-	g->status = Gwaiting;
+	runtime·casgstatus(g, Grunning, Gwaiting);
 	g->waitreason = runtime·gostringnocopy((byte*)"dumping heap");
 	runtime·mcall(mdump);
 
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index db89f6036f..61961f6471 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -484,6 +484,7 @@ markroot(ParFor *desc, uint32 i)
 	uint32 spanidx, sg;
 	G *gp;
 	void *p;
+	uint32 status;
 
 	USED(&desc);
 	// Note: if you add a case here, please also update heapdump.c:dumproots.
@@ -540,7 +541,8 @@ markroot(ParFor *desc, uint32 i)
 		gp = runtime·allg[i - RootCount];
 		// remember when we've first observed the G blocked
 		// needed only to output in traceback
-		if((gp->status == Gwaiting || gp->status == Gsyscall) && gp->waitsince == 0)
+		status = runtime·readgstatus(gp);
+		if((status == Gwaiting || status == Gsyscall) && gp->waitsince == 0)
 			gp->waitsince = work.tstart;
 		// Shrink a stack if not much of it is being used.
 		runtime·shrinkstack(gp);
@@ -737,13 +739,14 @@ scanstack(G *gp)
 	Stktop *stk;
 	uintptr sp, guard;
 
-	switch(gp->status){
+	switch(runtime·readgstatus(gp)) {
 	default:
-		runtime·printf("unexpected G.status %d (goroutine %p %D)\n", gp->status, gp, gp->goid);
+		runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
 		runtime·throw("mark - bad status");
 	case Gdead:
 		return;
 	case Grunning:
+		runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
 		runtime·throw("mark - world not stopped");
 	case Grunnable:
 	case Gsyscall:
@@ -860,7 +863,7 @@ runtime·MSpan_EnsureSwept(MSpan *s)
 	}
 	// unfortunate condition, and we don't have efficient means to wait
 	while(runtime·atomicload(&s->sweepgen) != sg)
-		runtime·osyield();  
+		runtime·osyield();
 }
 
 // Sweep frees or collects finalizers for blocks not marked in the mark phase.
@@ -1349,7 +1352,7 @@ runtime·gc(int32 force)
 			a.start_time = runtime·nanotime();
 		// switch to g0, call gc(&a), then switch back
 		g->param = &a;
-		g->status = Gwaiting;
+		runtime·casgstatus(g, Grunning, Gwaiting);
 		g->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
 		runtime·mcall(mgc);
 	}
@@ -1373,7 +1376,7 @@ mgc(G *gp)
 {
 	gc(gp->param);
 	gp->param = nil;
-	gp->status = Grunning;
+	runtime·casgstatus(gp, Gwaiting, Grunning);
 	runtime·gogo(&gp->sched);
 }
 
@@ -1384,14 +1387,14 @@ runtime·gc_m(void)
 	G *gp;
 
 	gp = g->m->curg;
-	gp->status = Gwaiting;
+	runtime·casgstatus(gp, Grunning, Gwaiting);
 	gp->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
 
 	a.start_time = (uint64)(g->m->scalararg[0]) | ((uint64)(g->m->scalararg[1]) << 32);
 	a.eagersweep = g->m->scalararg[2];
 	gc(&a);
 
-	gp->status = Grunning;
+	runtime·casgstatus(gp, Gwaiting, Grunning);
 }
 
 static void
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index a79081c72f..a96edee21a 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -288,7 +288,7 @@ func GoroutineProfile(b Slice) (n int, ok bool) {
 			saveg(pc, sp, g, r++);
 			for(i = 0; i < runtime·allglen; i++) {
 				gp = runtime·allg[i];
-				if(gp == g || gp->status == Gdead)
+				if(gp == g || runtime·readgstatus(gp) == Gdead)
 					continue;
 				saveg(~(uintptr)0, ~(uintptr)0, gp, r++);
 			}
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index d0284f9c20..dc3d2e93bf 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -477,6 +477,7 @@ bool
 runtime·canpanic(G *gp)
 {
 	M *m;
+	uint32 status;
 
 	// Note that g is m->gsignal, different from gp.
 	// Note also that g->m can change at preemption, so m can go stale
@@ -490,7 +491,8 @@ runtime·canpanic(G *gp)
 		return false;
 	if(m->locks-m->softfloat != 0 || m->mallocing != 0 || m->throwing != 0 || m->gcing != 0 || m->dying != 0)
 		return false;
-	if(gp->status != Grunning || gp->syscallsp != 0)
+	status = runtime·readgstatus(gp);
+	if((status&~Gscan) != Grunning || gp->syscallsp != 0)
 		return false;
 #ifdef GOOS_windows
 	if(m->libcallsp != 0)
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 1f687ebc92..756f86bd99 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -284,8 +284,10 @@ runtime·goroutineheader(G *gp)
 {
 	String status;
 	int64 waitfor;
+	uint32 gpstatus;
 
-	switch(gp->status) {
+	gpstatus = runtime·readgstatus(gp);
+	switch(gpstatus) {
 	case Gidle:
 		status = runtime·gostringnocopy((byte*)"idle");
 		break;
@@ -304,6 +306,30 @@ runtime·goroutineheader(G *gp)
 		else
 			status = runtime·gostringnocopy((byte*)"waiting");
 		break;
+	case Gscan:
+		status = runtime·gostringnocopy((byte*)"scan");
+		break;
+	case Gscanrunnable:
+		status =  runtime·gostringnocopy((byte*)"scanrunnable");
+		break;
+	case Gscanrunning:
+		status = runtime·gostringnocopy((byte*)"scanrunning");
+		break;
+	case Gscansyscall:
+		status = runtime·gostringnocopy((byte*)"scansyscall");
+		break;
+	case Gscanenqueue:
+		status = runtime·gostringnocopy((byte*)"scanenqueue");
+		break;
+	case Gscanwaiting:
+		if(gp->waitreason.str != nil)
+			status = gp->waitreason;
+		else
+			status = runtime·gostringnocopy((byte*)"scanwaiting");
+		break;
+	case Gcopystack:
+		status = runtime·gostringnocopy((byte*)"copystack");
+		break;
 	default:
 		status = runtime·gostringnocopy((byte*)"???");
 		break;
@@ -311,7 +337,8 @@ runtime·goroutineheader(G *gp)
 
 	// approx time the G is blocked, in minutes
 	waitfor = 0;
-	if((gp->status == Gwaiting || gp->status == Gsyscall) && gp->waitsince != 0)
+	gpstatus = gpstatus&~Gscan; // drop the scan bit
+	if((gpstatus == Gwaiting || gpstatus == Gsyscall) && gp->waitsince != 0)
 		waitfor = (runtime·nanotime() - gp->waitsince) / (60LL*1000*1000*1000);
 
 	runtime·printf("goroutine %D [%S", gp->goid, status);
@@ -322,12 +349,19 @@ runtime·goroutineheader(G *gp)
 	runtime·printf("]:\n");
 }
 
+static void
+dumpgstatus(G* gp)
+{
+	runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
+}
+
 void
 runtime·tracebackothers(G *me)
 {
 	G *gp;
 	int32 traceback;
 	uintptr i;
+	uint32 status;
 
 	traceback = runtime·gotraceback(nil);
 	
@@ -341,13 +375,14 @@ runtime·tracebackothers(G *me)
 	runtime·lock(&allglock);
 	for(i = 0; i < runtime·allglen; i++) {
 		gp = runtime·allg[i];
-		if(gp == me || gp == g->m->curg || gp->status == Gdead)
+		if(gp == me || gp == g->m->curg || runtime·readgstatus(gp) == Gdead)
 			continue;
 		if(gp->issystem && traceback < 2)
 			continue;
 		runtime·printf("\n");
 		runtime·goroutineheader(gp);
-		if(gp->status == Grunning) {
+		status = runtime·readgstatus(gp);
+		if((status&~Gscan) == Grunning){
 			runtime·printf("\tgoroutine running on other thread; stack unavailable\n");
 			runtime·printcreatedby(gp);
 		} else
@@ -360,7 +395,7 @@ static void
 checkmcount(void)
 {
 	// sched lock is held
-	if(runtime·sched.mcount > runtime·sched.maxmcount) {
+	if(runtime·sched.mcount > runtime·sched.maxmcount){
 		runtime·printf("runtime: program exceeds %d-thread limit\n", runtime·sched.maxmcount);
 		runtime·throw("thread exhaustion");
 	}
@@ -393,13 +428,17 @@ mcommoninit(M *mp)
 void
 runtime·ready(G *gp)
 {
+	uint32 status;
+
+	status = runtime·readgstatus(gp);
 	// Mark runnable.
 	g->m->locks++;  // disable preemption because it can be holding p in a local var
-	if(gp->status != Gwaiting) {
-		runtime·printf("goroutine %D has status %d\n", gp->goid, gp->status);
+	if((status&~Gscan) != Gwaiting){
+		dumpgstatus(gp);
 		runtime·throw("bad g->status in ready");
 	}
-	gp->status = Grunnable;
+	// status is Gwaiting or Gscanwaiting, make Grunnable and put on runq
+	runtime·casgstatus(gp, Gwaiting, Grunnable);
 	runqput(g->m->p, gp);
 	if(runtime·atomicload(&runtime·sched.npidle) != 0 && runtime·atomicload(&runtime·sched.nmspinning) == 0)  // TODO: fast atomic
 		wakep();
@@ -503,6 +542,97 @@ runtime·freezetheworld(void)
 	runtime·usleep(1000);
 }
 
+static bool
+isscanstatus(uint32 status)
+{
+	if(status == Gscan)
+		runtime·throw("isscanstatus: Bad status Gscan");
+	return (status&Gscan) == Gscan;
+}
+
+// All reads and writes of g's status go through readgstatus, casgstatus
+// castogscanstatus, casfromgscanstatus.
+uint32
+runtime·readgstatus(G *gp)
+{
+	return runtime·atomicload(&gp->atomicstatus);
+}
+
+// The Gscanstatuses are acting like locks and this releases them.
+// If it proves to be a performance hit we should be able to make these
+// simple atomic stores but for now we are going to throw if
+// we see an inconsistent state.
+void
+runtime·casfromgscanstatus(G *gp, uint32 oldval, uint32 newval)
+{
+	bool success = false;
+
+	// Check that transition is valid.
+	switch(oldval) {
+	case Gscanrunnable:
+	case Gscanwaiting:
+	case Gscanrunning:
+	case Gscansyscall:
+		if(newval == (oldval&~Gscan))
+			success = runtime·cas(&gp->atomicstatus, oldval, newval);
+		break;
+	case Gscanenqueue:
+		if(newval == Gwaiting)
+			success = runtime·cas(&gp->atomicstatus, oldval, newval);
+		break;
+	}	
+	if(!success){
+		runtime·printf("runtime: casfromgscanstatus failed gp=%p, oldval=%d, newval=%d\n",  
+			gp, oldval, newval);
+		dumpgstatus(gp);
+		runtime·throw("casfromgscanstatus: gp->status is not in scan state");
+	}
+}
+
+// This will return false if the gp is not in the expected status and the cas fails. 
+// This acts like a lock acquire while the casfromgstatus acts like a lock release.
+bool
+runtime·castogscanstatus(G *gp, uint32 oldval, uint32 newval)
+{
+	switch(oldval) {
+	case Grunnable:
+	case Gwaiting:
+	case Gsyscall:
+		if(newval == (oldval|Gscan))
+			return runtime·cas(&gp->atomicstatus, oldval, newval);
+		break;
+	case Grunning:
+		if(newval == Gscanrunning || newval == Gscanenqueue)
+			return runtime·cas(&gp->atomicstatus, oldval, newval);
+		break;   
+	}
+
+	runtime·printf("runtime: castogscanstatus oldval=%d newval=%d\n", oldval, newval);
+	runtime·throw("castogscanstatus");
+	return false; // not reached
+}
+
+// If asked to move to or from a Gscanstatus this will throw. Use the castogscanstatus
+// and casfromgscanstatus instead.
+// casgstatus will loop if the g->atomicstatus is in a Gscan status until the routine that 
+// put it in the Gscan state is finished.
+void
+runtime·casgstatus(G *gp, uint32 oldval, uint32 newval)
+{
+	if(isscanstatus(oldval) || isscanstatus(newval) || oldval == newval) {
+		runtime·printf("casgstatus: oldval=%d, newval=%d\n", oldval, newval);
+		runtime·throw("casgstatus: bad incoming values");
+	}
+
+	while(!runtime·cas(&gp->atomicstatus, oldval, newval)) {
+		// loop if gp->atomicstatus is in a  scan state giving
+		// GC time to finish and change the state to oldval.
+	}
+}
+
+// This is used by the GC as well as the routines that do stack dumps. In the case
+// of GC all the routines can be reliably stopped. This is not always the case
+// when the system is in panic or being exited.
 void
 runtime·stoptheworld(void)
 {
@@ -524,7 +654,7 @@ runtime·stoptheworld(void)
 	runtime·atomicstore((uint32*)&runtime·sched.gcwaiting, 1);
 	preemptall();
 	// stop current P
-	g->m->p->status = Pgcstop;
+	g->m->p->status = Pgcstop; // Pgcstop is only diagnostic.
 	runtime·sched.stopwait--;
 	// try to retake all P's in Psyscall status
 	for(i = 0; i < runtime·gomaxprocs; i++) {
@@ -845,7 +975,9 @@ runtime·newextram(void)
 	gp->syscallsp = gp->sched.sp;
 	gp->syscallstack = gp->stackbase;
 	gp->syscallguard = gp->stackguard;
-	gp->status = Gsyscall;
+	// malg returns status as Gidle, change to Gsyscall before adding to allg
+	// where GC will see it.
+	runtime·casgstatus(gp, Gidle, Gsyscall);
 	gp->m = mp;
 	mp->curg = gp;
 	mp->locked = LockInternal;
@@ -1055,7 +1187,7 @@ handoffp(P *p)
 	// no local work, check that there are no spinning/idle M's,
 	// otherwise our help is not required
 	if(runtime·atomicload(&runtime·sched.nmspinning) + runtime·atomicload(&runtime·sched.npidle) == 0 &&  // TODO: fast atomic
-		runtime·cas(&runtime·sched.nmspinning, 0, 1)) {
+		runtime·cas(&runtime·sched.nmspinning, 0, 1)){
 		startm(p, true);
 		return;
 	}
@@ -1100,6 +1232,7 @@ static void
 stoplockedm(void)
 {
 	P *p;
+	uint32 status;
 
 	if(g->m->lockedg == nil || g->m->lockedg->lockedm != g->m)
 		runtime·throw("stoplockedm: inconsistent locking");
@@ -1112,8 +1245,12 @@ stoplockedm(void)
 	// Wait until another thread schedules lockedg again.
 	runtime·notesleep(&g->m->park);
 	runtime·noteclear(&g->m->park);
-	if(g->m->lockedg->status != Grunnable)
+	status = runtime·readgstatus(g->m->lockedg);
+	if((status&~Gscan) != Grunnable){
+		runtime·printf("runtime:stoplockedm: g is not Grunnable or Gscanrunnable");
+		dumpgstatus(g);
 		runtime·throw("stoplockedm: not runnable");
+	}
 	acquirep(g->m->nextp);
 	g->m->nextp = nil;
 }
@@ -1166,12 +1303,8 @@ static void
 execute(G *gp)
 {
 	int32 hz;
-
-	if(gp->status != Grunnable) {
-		runtime·printf("execute: bad g status %d\n", gp->status);
-		runtime·throw("execute: bad g status");
-	}
-	gp->status = Grunning;
+	
+	runtime·casgstatus(gp, Grunnable, Grunning);
 	gp->waitsince = 0;
 	gp->preempt = false;
 	gp->stackguard0 = gp->stackguard;
@@ -1219,7 +1352,7 @@ top:
 	gp = runtime·netpoll(false);  // non-blocking
 	if(gp) {
 		injectglist(gp->schedlink);
-		gp->status = Grunnable;
+		runtime·casgstatus(gp, Gwaiting, Grunnable);
 		return gp;
 	}
 	// If number of spinning M's >= number of busy P's, block.
@@ -1291,7 +1424,7 @@ stop:
 			if(p) {
 				acquirep(p);
 				injectglist(gp->schedlink);
-				gp->status = Grunnable;
+				runtime·casgstatus(gp, Gwaiting, Grunnable);
 				return gp;
 			}
 			injectglist(gp);
@@ -1334,7 +1467,7 @@ injectglist(G *glist)
 	for(n = 0; glist; n++) {
 		gp = glist;
 		glist = gp->schedlink;
-		gp->status = Grunnable;
+		runtime·casgstatus(gp, Gwaiting, Grunnable); 
 		globrunqput(gp);
 	}
 	runtime·unlock(&runtime·sched.lock);
@@ -1420,8 +1553,6 @@ dropg(void)
 void
 runtime·park(bool(*unlockf)(G*, void*), void *lock, String reason)
 {
-	if(g->status != Grunning)
-		runtime·throw("bad g status");
 	g->m->waitlock = lock;
 	g->m->waitunlockf = unlockf;
 	g->waitreason = reason;
@@ -1450,7 +1581,7 @@ runtime·park_m(G *gp)
 {
 	bool ok;
 
-	gp->status = Gwaiting;
+	runtime·casgstatus(gp, Grunning, Gwaiting);
 	dropg();
 
 	if(g->m->waitunlockf) {
@@ -1458,7 +1589,7 @@ runtime·park_m(G *gp)
 		g->m->waitunlockf = nil;
 		g->m->waitlock = nil;
 		if(!ok) {
-			gp->status = Grunnable;
+			runtime·casgstatus(gp, Gwaiting, Grunnable); 
 			execute(gp);  // Schedule it back, never returns.
 		}
 	}
@@ -1477,9 +1608,14 @@ runtime·gosched(void)
 void
 runtime·gosched_m(G *gp)
 {
-	if(gp->status != Grunning)
+	uint32 status;
+
+	status = runtime·readgstatus(gp);
+	if ((status&~Gscan) != Grunning){
+		dumpgstatus(gp);
 		runtime·throw("bad g status");
-	gp->status = Grunnable;
+	}
+	runtime·casgstatus(gp, Grunning, Grunnable);
 	dropg();
 	runtime·lock(&runtime·sched.lock);
 	globrunqput(gp);
@@ -1496,8 +1632,6 @@ runtime·gosched_m(G *gp)
 void
 runtime·goexit(void)
 {
-	if(g->status != Grunning)
-		runtime·throw("bad g status");
 	if(raceenabled)
 		runtime·racegoend();
 	runtime·mcall(goexit0);
@@ -1507,7 +1641,7 @@ runtime·goexit(void)
 static void
 goexit0(G *gp)
 {
-	gp->status = Gdead;
+	runtime·casgstatus(gp, Grunning, Gdead);
 	gp->m = nil;
 	gp->lockedm = nil;
 	g->m->lockedg = nil;
@@ -1519,7 +1653,7 @@ goexit0(G *gp)
 	gp->waitreason.str = nil;
 	gp->waitreason.len = 0;
 	gp->param = nil;
-	
+
 	dropg();
 
 	if(g->m->locked & ~LockExternal) {
@@ -1566,7 +1700,7 @@ void
 	g->syscallpc = g->sched.pc;
 	g->syscallstack = g->stackbase;
 	g->syscallguard = g->stackguard;
-	g->status = Gsyscall;
+	runtime·casgstatus(g, Grunning, Gsyscall);
 	if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
 		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
 		//	g->syscallsp, g->syscallguard-StackGuard, g->syscallstack);
@@ -1618,7 +1752,7 @@ void
 	g->syscallpc = g->sched.pc;
 	g->syscallstack = g->stackbase;
 	g->syscallguard = g->stackguard;
-	g->status = Gsyscall;
+	runtime·casgstatus(g, Grunning, Gsyscall);
 	if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
 		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
 		//	g->syscallsp, g->syscallguard-StackGuard, g->syscallstack);
@@ -1650,7 +1784,7 @@ runtime·entersyscallblock_m(void)
 	gp->syscallpc = gp->sched.pc;
 	gp->syscallstack = gp->stackbase;
 	gp->syscallguard = gp->stackguard;
-	gp->status = Gsyscall;
+	runtime·casgstatus(gp, Grunning, Gsyscall);
 	if(gp->syscallsp < gp->syscallguard-StackGuard || gp->syscallstack < gp->syscallsp) {
 		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
 		//	gp->syscallsp, gp->syscallguard-StackGuard, gp->syscallstack);
@@ -1674,7 +1808,9 @@ runtime·exitsyscall(void)
 	if(exitsyscallfast()) {
 		// There's a cpu for us, so we can run.
 		g->m->p->syscalltick++;
-		g->status = Grunning;
+		// We need to cas the status and scan before resuming...
+		runtime·casgstatus(g, Gsyscall, Grunning);
+
 		// Garbage collector isn't running (since we are),
 		// so okay to clear gcstack and gcsp.
 		g->syscallstack = (uintptr)nil;
@@ -1750,7 +1886,7 @@ exitsyscall0(G *gp)
 {
 	P *p;
 
-	gp->status = Grunnable;
+	runtime·casgstatus(gp, Gsyscall, Grunnable);
 	dropg();
 	runtime·lock(&runtime·sched.lock);
 	p = pidleget();
@@ -1919,7 +2055,6 @@ runtime·newproc1(FuncVal *fn, byte *argp, int32 narg, int32 nret, void *callerp
 	P *p;
 	int32 siz;
 
-//runtime·printf("newproc1 %p %p narg=%d nret=%d\n", fn->fn, argp, narg, nret);
 	if(fn == nil) {
 		g->m->throwing = -1;  // do not dump full stacks
 		runtime·throw("go of nil func value");
@@ -1941,9 +2076,13 @@ runtime·newproc1(FuncVal *fn, byte *argp, int32 narg, int32 nret, void *callerp
 			runtime·throw("invalid stack in newg");
 	} else {
 		newg = runtime·malg(StackMin);
-		allgadd(newg);
+		runtime·casgstatus(newg, Gidle, Gdead);
+		allgadd(newg); // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
 	}
 
+	if(runtime·readgstatus(newg) != Gdead) 
+		runtime·throw("newproc1: new g is not Gdead");
+
 	sp = (byte*)newg->stackbase;
 	sp -= siz;
 	runtime·memmove(sp, argp, narg);
@@ -1959,7 +2098,8 @@ runtime·newproc1(FuncVal *fn, byte *argp, int32 narg, int32 nret, void *callerp
 	newg->sched.g = newg;
 	runtime·gostartcallfn(&newg->sched, fn);
 	newg->gopc = (uintptr)callerpc;
-	newg->status = Grunnable;
+	runtime·casgstatus(newg, Gdead, Grunnable);
+
 	if(p->goidcache == p->goidcacheend) {
 		// Sched.goidgen is the last allocated id,
 		// this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
@@ -1988,6 +2128,9 @@ allgadd(G *gp)
 	G **new;
 	uintptr cap;
 
+	if (runtime·readgstatus(gp) == Gidle) 
+		runtime·throw("allgadd: bad status Gidle");
+
 	runtime·lock(&allglock);
 	if(runtime·allglen >= allgcap) {
 		cap = 4096/sizeof(new[0]);
@@ -2013,6 +2156,9 @@ gfput(P *p, G *gp)
 	uintptr stksize;
 	Stktop *top;
 
+	if (runtime·readgstatus(gp) != Gdead) 
+		runtime·throw("gfput: bad status (not Gdead)");
+
 	if(gp->stackguard - StackGuard != gp->stack0)
 		runtime·throw("invalid stack in gfput");
 	stksize = gp->stackbase + sizeof(Stktop) - gp->stack0;
@@ -2607,13 +2753,18 @@ checkdead(void)
 		gp = runtime·allg[i];
 		if(gp->issystem)
 			continue;
-		s = gp->status;
-		if(s == Gwaiting)
+		s = runtime·readgstatus(gp);
+		switch(s&~Gscan) {
+		case Gwaiting:
 			grunning++;
-		else if(s == Grunnable || s == Grunning || s == Gsyscall) {
+			break;
+		case Grunnable:
+		case Grunning:
+		case Gsyscall:
 			runtime·unlock(&allglock);
 			runtime·printf("runtime: checkdead: find g %D in status %d\n", gp->goid, s);
 			runtime·throw("checkdead: runnable g");
+			break;
 		}
 	}
 	runtime·unlock(&allglock);
@@ -2837,6 +2988,9 @@ preemptall(void)
 // simultaneously executing runtime·newstack.
 // No lock needs to be held.
 // Returns true if preemption request was issued.
+// The actual preemption will happen at some point in the future
+// and will be indicated by the gp->status no longer being
+// Grunning
 static bool
 preemptone(P *p)
 {
@@ -2850,6 +3004,10 @@ preemptone(P *p)
 	if(gp == nil || gp == mp->g0)
 		return false;
 	gp->preempt = true;
+	// Every call in a go routine checks for stack overflow by
+	// comparing the current stack pointer to gp->stackguard0.
+	// Setting gp->stackguard0 to StackPreempt folds
+	// preemption into the normal stack overflow check.
 	gp->stackguard0 = StackPreempt;
 	return true;
 }
@@ -2935,7 +3093,7 @@ runtime·schedtrace(bool detailed)
 		mp = gp->m;
 		lockedm = gp->lockedm;
 		runtime·printf("  G%D: status=%d(%S) m=%d lockedm=%d\n",
-			gp->goid, gp->status, gp->waitreason, mp ? mp->id : -1,
+			gp->goid, runtime·readgstatus(gp), gp->waitreason, mp ? mp->id : -1,
 			lockedm ? lockedm->id : -1);
 	}
 	runtime·unlock(&allglock);
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 1ed6c26eba..de58daa130 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -6,6 +6,9 @@ package runtime
 
 import "unsafe"
 
+// This is not mechanically generated
+// so be very careful and refer to runtime.h
+// for the definitive enum.
 const (
 	gStatusidle = iota
 	gStatusRunnable
@@ -14,6 +17,14 @@ const (
 	gStatusWaiting
 	gStatusMoribundUnused
 	gStatusDead
+	gStatusEnqueue
+	gStatusCopystack
+	gStatusScan         = 0x1000
+	gStatusScanRunnable = gStatusScan + gStatusRunnable
+	gStatusScanRunning  = gStatusScan + gStatusRunning
+	gStatusScanSyscall  = gStatusScan + gStatusSyscall
+	gStatusScanWaiting  = gStatusScan + gStatusWaiting
+	gStatusScanEnqueue  = gStatusScan + gStatusEnqueue
 )
 
 var parkunlock_c byte
@@ -24,12 +35,18 @@ func Gosched() {
 	mcall(&gosched_m)
 }
 
+func readgStatus(gp *g) uint32 {
+	//return atomic.LoadUint32(&gp.atomicstatus) // TODO: add bootstrap code to provide.
+	return gp.atomicstatus
+}
+
 // Puts the current goroutine into a waiting state and calls unlockf.
 // If unlockf returns false, the goroutine is resumed.
 func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
 	mp := acquirem()
 	gp := mp.curg
-	if gp.status != gStatusRunning {
+	status := readgStatus(gp)
+	if status != gStatusRunning && status != gStatusScanRunning {
 		gothrow("gopark: bad g status")
 	}
 	mp.waitlock = lock
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 8d4773b9f7..ae098459fa 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -126,13 +126,25 @@ enum
 	// If you add to this list, add to the list
 	// of "okay during garbage collection" status
 	// in mgc0.c too.
-	Gidle,
-	Grunnable,
-	Grunning,
-	Gsyscall,
-	Gwaiting,
-	Gmoribund_unused,  // currently unused, but hardcoded in gdb scripts
-	Gdead,
+	Gidle,                                 // 0
+	Grunnable,                             // 1 runnable and on a run queue
+	Grunning,                              // 2
+	Gsyscall,                              // 3
+	Gwaiting,                              // 4
+	Gmoribund_unused,                      // 5 currently unused, but hardcoded in gdb scripts
+	Gdead,                                 // 6
+	Genqueue,                              // 7 Only the Gscanenqueue is used.
+	Gcopystack,                            // 8 in this state when newstack is moving the stack
+	// the following encode that the GC is scanning the stack and what to do when it is done 
+	Gscan = 0x1000,                        // atomicstatus&~Gscan = the non-scan state,
+	// Gscanidle =     Gscan + Gidle,      // Not used. Gidle only used with newly malloced gs
+	Gscanrunnable = Gscan + Grunnable,     //  0x1001 When scanning complets make Grunnable (it is already on run queue)
+	Gscanrunning =  Gscan + Grunning,      //  0x1002 Used to tell preemption newstack routine to scan preempted stack.
+	Gscansyscall =  Gscan + Gsyscall,      //  0x1003 When scanning completes make is Gsyscall
+	Gscanwaiting =  Gscan + Gwaiting,      //  0x1004 When scanning completes make it Gwaiting
+	// Gscanmoribund_unused,               //  not possible
+	// Gscandead,                          //  not possible
+	Gscanenqueue = Gscan + Genqueue,       //  When scanning completes make it Grunnable and put on runqueue
 };
 enum
 {
@@ -276,7 +288,7 @@ struct	G
 	uintptr	stack0;
 	uintptr	stacksize;
 	void*	param;		// passed parameter on wakeup
-	int16	status;
+	uint32	atomicstatus;
 	int64	goid;
 	int64	waitsince;	// approx time when the G become blocked
 	String	waitreason;	// if status==Gwaiting
@@ -285,6 +297,8 @@ struct	G
 	bool	issystem;	// do not output in stack dump, ignore in deadlock detector
 	bool	preempt;	// preemption signal, duplicates stackguard0 = StackPreempt
 	bool	paniconfault;	// panic (instead of crash) on unexpected fault address
+	bool    preemptscan;    // preempted g does scan for GC
+	bool    scancheck;      // debug: cleared at begining of scan cycle, set by scan, tested at end of cycle
 	int8	raceignore;	// ignore race detection events
 	M*	m;		// for debuggers, but offset not hard-coded
 	M*	lockedm;
@@ -681,6 +695,9 @@ void	runtime·algslicecopy(uintptr, void*, void*);
 void	runtime·intercopy(uintptr, void*, void*);
 void	runtime·nilintercopy(uintptr, void*, void*);
 
+uint32  runtime·readgstatus(G *gp);
+void    runtime·casgstatus(G*, uint32, uint32);
+
 /*
  * deferred subroutine calls
  */
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 61205bd478..78d1e149e7 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -337,15 +337,20 @@ runtime·oldstack(void)
 			top->gobuf.pc, top->gobuf.sp, top->gobuf.lr, (uintptr)g->m->cret, (uintptr)argsize);
 	}
 
-	// gp->status is usually Grunning, but it could be Gsyscall if a stack overflow
-	// happens during a function call inside entersyscall.
-	oldstatus = gp->status;
-	
 	gp->sched = top->gobuf;
 	gp->sched.ret = g->m->cret;
 	g->m->cret = 0; // drop reference
-	gp->status = Gwaiting;
-	gp->waitreason = runtime·gostringnocopy((byte*)"stack unsplit");
+	// gp->status is usually Grunning, but it could be Gsyscall if a stack overflow
+	// happens during a function call inside entersyscall.
+
+	oldstatus = runtime·readgstatus(gp);
+	oldstatus &= ~Gscan;
+	if(oldstatus != Grunning && oldstatus != Gsyscall) {
+		runtime·printf("runtime: oldstack status=%d\n", oldstatus);
+		runtime·throw("oldstack");
+	}
+	runtime·casgstatus(gp, oldstatus, Gcopystack);
+	gp->waitreason = runtime·gostringnocopy((byte*)"stack unsplit");	
 
 	if(argsize > 0) {
 		sp -= argsize;
@@ -363,8 +368,7 @@ runtime·oldstack(void)
 	gp->stackguard0 = gp->stackguard;
 	gp->panicwrap = top->panicwrap;
 	runtime·stackfree(gp, old, top);
-
-	gp->status = oldstatus;
+	runtime·casgstatus(gp, Gcopystack, oldstatus); // oldstatus is Grunning or Gsyscall
 	runtime·gogo(&gp->sched);
 }
 
@@ -768,6 +772,7 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	uintptr oldsize, used;
 	AdjustInfo adjinfo;
 	Stktop *oldtop, *newtop;
+	uint32 oldstatus;
 
 	if(gp->syscallstack != 0)
 		runtime·throw("can't handle stack copy in syscall yet");
@@ -801,7 +806,12 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	
 	// copy the stack (including Stktop) to the new location
 	runtime·memmove(newbase - used, oldbase - used, used);
-	
+	oldstatus = runtime·readgstatus(gp);
+	oldstatus &= ~Gscan;
+	if (oldstatus == Gwaiting || oldstatus == Grunnable)
+		runtime·casgstatus(gp, oldstatus, Gcopystack); // oldstatus is Gwaiting or Grunnable
+	else
+		runtime·throw("copystack: bad status, not Gwaiting or Grunnable");
 	// Swap out old stack for new one
 	gp->stackbase = (uintptr)newtop;
 	gp->stackguard = (uintptr)newstk + StackGuard;
@@ -810,6 +820,8 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 		gp->stack0 = (uintptr)newstk;
 	gp->sched.sp = (uintptr)(newbase - used);
 
+	runtime·casgstatus(gp, Gcopystack, oldstatus); // oldstatus is Gwaiting or Grunnable
+
 	// free old stack
 	runtime·stackfree(gp, oldstk, oldtop);
 }
@@ -831,6 +843,9 @@ runtime·round2(int32 x)
 // m->moreframesize bytes, copy m->moreargsize bytes to the new frame,
 // and then act as though runtime·lessstack called the function at
 // m->morepc.
+//
+// g->atomicstatus will be Grunning, Gsyscall or Gscanrunning, Gscansyscall upon entry. 
+// If the GC is trying to stop this g then it will set preemptscan to true.
 void
 runtime·newstack(void)
 {
@@ -853,11 +868,13 @@ runtime·newstack(void)
 		runtime·throw("runtime: wrong goroutine in newstack");
 	}
 
+	// The goroutine must be executing in order to call newstack, so the possible states are
+	// Grunning and Gsyscall (and, due to GC, also Gscanrunning and Gscansyscall).	
+
 	// gp->status is usually Grunning, but it could be Gsyscall if a stack overflow
 	// happens during a function call inside entersyscall.
 	gp = g->m->curg;
-	oldstatus = gp->status;
-
+	oldstatus = runtime·readgstatus(gp) & ~Gscan;
 	framesize = g->m->moreframesize;
 	argsize = g->m->moreargsize;
 	moreargp = g->m->moreargp;
@@ -866,7 +883,8 @@ runtime·newstack(void)
 	g->m->morebuf.pc = (uintptr)nil;
 	g->m->morebuf.lr = (uintptr)nil;
 	g->m->morebuf.sp = (uintptr)nil;
-	gp->status = Gwaiting;
+
+	runtime·casgstatus(gp, oldstatus, Gwaiting); // oldstatus is not in a Gscan status
 	gp->waitreason = runtime·gostringnocopy((byte*)"stack growth");
 	newstackcall = framesize==1;
 	if(newstackcall)
@@ -892,6 +910,7 @@ runtime·newstack(void)
 			gp->sched.pc, gp->sched.sp, gp->sched.lr, gp->sched.ctxt);
 	}
 	if(sp < gp->stackguard - StackGuard) {
+		runtime·printf("runtime: gp=%p, gp->status=%d, oldstatus=%d\n ", (void*)gp, runtime·readgstatus(gp), oldstatus);
 		runtime·printf("runtime: split stack overflow: %p < %p\n", sp, gp->stackguard - StackGuard);
 		runtime·throw("runtime: split stack overflow");
 	}
@@ -908,17 +927,18 @@ runtime·newstack(void)
 			runtime·throw("runtime: g is running but p is not");
 		if(oldstatus == Gsyscall && g->m->locks == 0)
 			runtime·throw("runtime: stack growth during syscall");
+
 		// Be conservative about where we preempt.
 		// We are interested in preempting user Go code, not runtime code.
 		if(oldstatus != Grunning || g->m->locks || g->m->mallocing || g->m->gcing || g->m->p->status != Prunning) {
 			// Let the goroutine keep running for now.
 			// gp->preempt is set, so it will be preempted next time.
 			gp->stackguard0 = gp->stackguard;
-			gp->status = oldstatus;
+			runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Gsyscall or Grunning
 			runtime·gogo(&gp->sched);	// never return
 		}
 		// Act like goroutine called runtime.Gosched.
-		gp->status = oldstatus;
+		runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Gsyscall or Grunning
 		runtime·gosched_m(gp);	// never return
 	}
 
@@ -933,6 +953,8 @@ runtime·newstack(void)
 			oldbase = (byte*)gp->stackbase + sizeof(Stktop);
 			oldsize = oldbase - oldstk;
 			newsize = oldsize * 2;
+			// Note that the concurrent GC might be scanning the stack as we try to replace it.
+			// copystack takes care of the appropriate coordination with the stack scanner.
 			copystack(gp, nframes, newsize);
 			if(StackDebug >= 1)
 				runtime·printf("stack grow done\n");
@@ -940,7 +962,7 @@ runtime·newstack(void)
 				runtime·printf("runtime: goroutine stack exceeds %D-byte limit\n", (uint64)runtime·maxstacksize);
 				runtime·throw("stack overflow");
 			}
-			gp->status = oldstatus;
+			runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Gsyscall or Grunning
 			runtime·gogo(&gp->sched);
 		}
 		// TODO: if stack is uncopyable because we're in C code, patch return value at
@@ -1017,7 +1039,7 @@ runtime·newstack(void)
 		runtime·gostartcall(&label, (void(*)(void))gp->sched.pc, gp->sched.ctxt);
 		gp->sched.ctxt = nil;
 	}
-	gp->status = oldstatus;
+	runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Grunning or Gsyscall
 	runtime·gogo(&label);
 
 	*(int32*)345 = 123;	// never return
@@ -1055,7 +1077,7 @@ runtime·shrinkstack(G *gp)
 
 	if(!runtime·copystack)
 		return;
-	if(gp->status == Gdead)
+	if(runtime·readgstatus(gp) == Gdead)
 		return;
 	if(gp->stackbase == 0)
 		runtime·throw("stackbase == 0");
diff --git a/src/pkg/runtime/traceback_arm.c b/src/pkg/runtime/traceback_arm.c
index 778d95a28b..0ae40a6484 100644
--- a/src/pkg/runtime/traceback_arm.c
+++ b/src/pkg/runtime/traceback_arm.c
@@ -327,7 +327,7 @@ runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G *gp)
 {
 	int32 n;
 
-	if(gp->status == Gsyscall) {
+	if((runtime·readgstatus(gp)&~Gscan) == Gsyscall){
 		// Override signal registers if blocked in system call.
 		pc = gp->syscallpc;
 		sp = gp->syscallsp;
diff --git a/src/pkg/runtime/traceback_x86.c b/src/pkg/runtime/traceback_x86.c
index a88e9372db..7c76daf4cf 100644
--- a/src/pkg/runtime/traceback_x86.c
+++ b/src/pkg/runtime/traceback_x86.c
@@ -402,7 +402,7 @@ runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G *gp)
 
 	USED(lr);
 
-	if(gp->status == Gsyscall) {
+	if((runtime·readgstatus(gp)&~Gscan) == Gsyscall){
 		// Override signal registers if blocked in system call.
 		pc = gp->syscallpc;
 		sp = gp->syscallsp;

From 25f6b02ab0db8e22994a3a68f4cb2857b788a63f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 11:32:17 -0400
Subject: [PATCH 232/423] cmd/cc, runtime: convert C compilers to use Go
 calling convention

To date, the C compilers and Go compilers differed only in how
values were returned from functions. This made it difficult to call
Go from C or C from Go if return values were involved. It also made
assembly called from Go and assembly called from C different.

This CL changes the C compiler to use the Go conventions, passing
results on the stack, after the arguments.
[Exception: this does not apply to C ... functions, because you can't
know where on the stack the arguments end.]

By doing this, the CL makes it possible to rewrite C functions into Go
one at a time, without worrying about which languages call that
function or which languages it calls.

This CL also updates all the assembly files in package runtime to use
the new conventions. Argument references of the form 40(SP) have
been rewritten to the form name+10(FP) instead, and there are now
Go func prototypes for every assembly function called from C or Go.
This means that 'go vet runtime' checks effectively every assembly
function, and go vet's output was used to automate the bulk of the
conversion.

Some functions, like seek and nsec on Plan 9, needed to be rewritten.

Many assembly routines called from C were reading arguments
incorrectly, using MOVL instead of MOVQ or vice versa, especially on
the less used systems like openbsd.
These were found by go vet and have been corrected too.
If we're lucky, this may reduce flakiness on those systems.

Tested on:
        darwin/386
        darwin/amd64
        linux/arm
        linux/386
        linux/amd64
If this breaks another system, the bug is almost certainly in the
sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested
by the combination of the above systems.

LGTM=dvyukov, iant
R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant
CC=golang-codereviews, josharian, r
https://golang.org/cl/135830043
---
 src/cmd/5c/cgen.c                       |  34 +-
 src/cmd/5c/gc.h                         |   4 +-
 src/cmd/5c/sgen.c                       |   2 +-
 src/cmd/5c/txt.c                        |  40 +-
 src/cmd/6c/cgen.c                       |  34 +-
 src/cmd/6c/gc.h                         |   4 +-
 src/cmd/6c/sgen.c                       |   2 +-
 src/cmd/6c/txt.c                        |  40 +-
 src/cmd/8c/cgen.c                       |  34 +-
 src/cmd/8c/gc.h                         |   4 +-
 src/cmd/8c/sgen.c                       |   2 +-
 src/cmd/8c/txt.c                        |  40 +-
 src/cmd/api/goapi.go                    |   1 +
 src/cmd/cc/cc.h                         |   2 +-
 src/cmd/cc/dcl.c                        |   3 +-
 src/cmd/cc/pgen.c                       |  44 +-
 src/pkg/runtime/alg.go                  |   3 +
 src/pkg/runtime/asm_386.s               | 143 +++--
 src/pkg/runtime/asm_amd64.s             | 136 ++--
 src/pkg/runtime/asm_amd64p32.s          | 107 ++--
 src/pkg/runtime/asm_arm.s               |  21 +-
 src/pkg/runtime/memclr_plan9_amd64.s    |   4 +-
 src/pkg/runtime/memmove_nacl_amd64p32.s |   2 +-
 src/pkg/runtime/memmove_plan9_386.s     |   2 +-
 src/pkg/runtime/memmove_plan9_amd64.s   |   2 +-
 src/pkg/runtime/os_darwin.go            |  27 +
 src/pkg/runtime/os_dragonfly.go         |  21 +
 src/pkg/runtime/os_freebsd.go           |  20 +
 src/pkg/runtime/os_linux.go             |  22 +
 src/pkg/runtime/os_nacl.go              |  24 +
 src/pkg/runtime/os_netbsd.go            |  23 +
 src/pkg/runtime/os_openbsd.go           |  20 +
 src/pkg/runtime/os_plan9.go             |  24 +
 src/pkg/runtime/os_solaris.go           |  22 +
 src/pkg/runtime/os_windows.go           |  12 +
 src/pkg/runtime/stubs.go                |  45 ++
 src/pkg/runtime/sys_darwin_386.s        |  33 +-
 src/pkg/runtime/sys_darwin_amd64.s      | 159 +++--
 src/pkg/runtime/sys_dragonfly_386.s     |  28 +-
 src/pkg/runtime/sys_dragonfly_amd64.s   | 120 ++--
 src/pkg/runtime/sys_freebsd_386.s       |  26 +-
 src/pkg/runtime/sys_freebsd_amd64.s     | 120 ++--
 src/pkg/runtime/sys_freebsd_arm.s       |  15 +-
 src/pkg/runtime/sys_linux_386.s         | 151 +++--
 src/pkg/runtime/sys_linux_amd64.s       | 159 +++--
 src/pkg/runtime/sys_linux_arm.s         |  33 +-
 src/pkg/runtime/sys_nacl_386.s          |  18 +-
 src/pkg/runtime/sys_nacl_amd64p32.s     | 103 +--
 src/pkg/runtime/sys_nacl_arm.s          |  92 +--
 src/pkg/runtime/sys_netbsd_386.s        |  24 +-
 src/pkg/runtime/sys_netbsd_amd64.s      | 118 ++--
 src/pkg/runtime/sys_netbsd_arm.s        |  19 +-
 src/pkg/runtime/sys_openbsd_386.s       |  44 +-
 src/pkg/runtime/sys_openbsd_amd64.s     | 120 ++--
 src/pkg/runtime/sys_plan9_386.s         |  68 +-
 src/pkg/runtime/sys_plan9_amd64.s       |  44 +-
 src/pkg/runtime/sys_solaris_amd64.s     |   4 +-
 src/pkg/runtime/sys_windows_386.s       |   9 +-
 src/pkg/runtime/sys_windows_amd64.s     |   5 +-
 src/pkg/runtime/vlop_386.s              |   4 +-
 src/pkg/runtime/vlop_arm.s              |  13 +-
 src/pkg/runtime/{vlrt_arm.c => vlrt.c}  | 571 ++++++++++-------
 src/pkg/runtime/vlrt_386.c              | 819 ------------------------
 src/pkg/sync/atomic/asm_linux_arm.s     |  24 +-
 64 files changed, 1961 insertions(+), 1952 deletions(-)
 create mode 100644 src/pkg/runtime/os_darwin.go
 create mode 100644 src/pkg/runtime/os_dragonfly.go
 create mode 100644 src/pkg/runtime/os_freebsd.go
 create mode 100644 src/pkg/runtime/os_linux.go
 create mode 100644 src/pkg/runtime/os_nacl.go
 create mode 100644 src/pkg/runtime/os_netbsd.go
 create mode 100644 src/pkg/runtime/os_openbsd.go
 create mode 100644 src/pkg/runtime/os_plan9.go
 create mode 100644 src/pkg/runtime/os_solaris.go
 create mode 100644 src/pkg/runtime/os_windows.go
 rename src/pkg/runtime/{vlrt_arm.c => vlrt.c} (55%)
 delete mode 100644 src/pkg/runtime/vlrt_386.c

diff --git a/src/cmd/5c/cgen.c b/src/cmd/5c/cgen.c
index 08ed36055a..5ea8eea073 100644
--- a/src/cmd/5c/cgen.c
+++ b/src/cmd/5c/cgen.c
@@ -46,7 +46,7 @@ _cgen(Node *n, Node *nn, int inrel)
 	}
 	if(n == Z || n->type == T)
 		return;
-	if(typesuv[n->type->etype]) {
+	if(typesuv[n->type->etype] && (n->op != OFUNC || nn != Z)) {
 		sugen(n, nn, n->type->width);
 		return;
 	}
@@ -75,7 +75,7 @@ _cgen(Node *n, Node *nn, int inrel)
 	if(r != Z && r->complex >= FNX)
 	switch(o) {
 	default:
-		regret(&nod, r);
+		regret(&nod, r, 0, 0);
 		cgen(r, &nod);
 
 		regsalloc(&nod1, r);
@@ -107,7 +107,7 @@ _cgen(Node *n, Node *nn, int inrel)
 		if(l->addable >= INDEXED && l->complex < FNX) {
 			if(nn != Z || r->addable < INDEXED) {
 				if(r->complex >= FNX && nn == Z)
-					regret(&nod, r);
+					regret(&nod, r, 0, 0);
 				else
 					regalloc(&nod, r, nn);
 				cgen(r, &nod);
@@ -348,7 +348,7 @@ _cgen(Node *n, Node *nn, int inrel)
 			if(l->op != OIND)
 				diag(n, "bad function call");
 
-			regret(&nod, l->left);
+			regret(&nod, l->left, 0, 0);
 			cgen(l->left, &nod);
 			regsalloc(&nod1, l->left);
 			gopcode(OAS, &nod, Z, &nod1);
@@ -377,11 +377,11 @@ _cgen(Node *n, Node *nn, int inrel)
 		if(REGARG >= 0)
 			if(o != reg[REGARG])
 				reg[REGARG]--;
-		if(nn != Z) {
-			regret(&nod, n);
-			gopcode(OAS, &nod, Z, nn);
+		regret(&nod, n, l->type, 1);
+		if(nn != Z)
+			gmove(&nod, nn);
+		if(nod.op == OREGISTER)
 			regfree(&nod);
-		}
 		break;
 
 	case OIND:
@@ -823,7 +823,7 @@ boolgen(Node *n, int true, Node *nn)
 		if(true)
 			o = comrel[relindex(o)];
 		if(l->complex >= FNX && r->complex >= FNX) {
-			regret(&nod, r);
+			regret(&nod, r, 0, 0);
 			cgenrel(r, &nod);
 			regsalloc(&nod1, r);
 			gopcode(OAS, &nod, Z, &nod1);
@@ -957,7 +957,7 @@ sugen(Node *n, Node *nn, int32 w)
 		if(nn != Z && side(nn)) {
 			nod1 = *n;
 			nod1.type = typ(TIND, n->type);
-			regret(&nod2, &nod1);
+			regret(&nod2, &nod1, 0, 0);
 			lcgen(nn, &nod2);
 			regsalloc(&nod0, &nod1);
 			gopcode(OAS, &nod2, Z, &nod0);
@@ -1036,6 +1036,20 @@ sugen(Node *n, Node *nn, int32 w)
 		break;
 
 	case OFUNC:
+		if(!hasdotdotdot(n->left->type)) {
+			cgen(n, Z);
+			if(nn != Z) {
+				curarg -= n->type->width;
+				regret(&nod1, n, n->left->type, 1);
+				if(nn->complex >= FNX) {
+					regsalloc(&nod2, n);
+					cgen(&nod1, &nod2);
+					nod1 = nod2;
+				}
+				cgen(&nod1, nn);
+			}
+			break;
+		}
 		if(nn == Z) {
 			sugen(n, nodrat, w);
 			break;
diff --git a/src/cmd/5c/gc.h b/src/cmd/5c/gc.h
index 166900c3a9..7417b7dbe3 100644
--- a/src/cmd/5c/gc.h
+++ b/src/cmd/5c/gc.h
@@ -210,7 +210,7 @@ void	usedset(Node*, int);
 void	xcom(Node*);
 int	bcomplex(Node*, Node*);
 Prog*	gtext(Sym*, int32);
-vlong	argsize(void);
+vlong	argsize(int);
 
 /*
  * cgen.c
@@ -236,7 +236,7 @@ Node*	nodconst(int32);
 Node*	nod32const(vlong);
 Node*	nodfconst(double);
 void	nodreg(Node*, Node*, int);
-void	regret(Node*, Node*);
+void	regret(Node*, Node*, Type*, int);
 int	tmpreg(void);
 void	regalloc(Node*, Node*, Node*);
 void	regfree(Node*);
diff --git a/src/cmd/5c/sgen.c b/src/cmd/5c/sgen.c
index efcc0437bb..a36612caa5 100644
--- a/src/cmd/5c/sgen.c
+++ b/src/cmd/5c/sgen.c
@@ -36,7 +36,7 @@ gtext(Sym *s, int32 stkoff)
 {
 	int32 a;
 
-	a = argsize();
+	a = argsize(1);
 	if((textflag & NOSPLIT) != 0 && stkoff >= 128)
 		yyerror("stack frame too large for NOSPLIT function");
 
diff --git a/src/cmd/5c/txt.c b/src/cmd/5c/txt.c
index a753510caa..af40220ccb 100644
--- a/src/cmd/5c/txt.c
+++ b/src/cmd/5c/txt.c
@@ -274,15 +274,43 @@ nodreg(Node *n, Node *nn, int reg)
 }
 
 void
-regret(Node *n, Node *nn)
+regret(Node *n, Node *nn, Type *t, int mode)
 {
 	int r;
 
-	r = REGRET;
-	if(typefd[nn->type->etype])
-		r = FREGRET+NREG;
-	nodreg(n, nn, r);
-	reg[r]++;
+	if(mode == 0 || hasdotdotdot(t) || nn->type->width == 0) {
+		r = REGRET;
+		if(typefd[nn->type->etype])
+			r = FREGRET+NREG;
+		nodreg(n, nn, r);
+		reg[r]++;
+		return;
+	}
+	
+	if(mode == 1) {
+		// fetch returned value after call.
+		// already called gargs, so curarg is set.
+		curarg = (curarg+3) & ~3;
+		regaalloc(n, nn);
+		return;
+	}
+	
+	if(mode == 2) {
+		// store value to be returned.
+		// must compute arg offset.
+		if(t->etype != TFUNC)
+			fatal(Z, "bad regret func %T", t);
+		*n = *nn;
+		n->op = ONAME;
+		n->class = CPARAM;
+		n->sym = slookup(".ret");
+		n->complex = nodret->complex;
+		n->xoffset = argsize(0);
+		n->addable = 20;
+		return;
+	}
+	
+	fatal(Z, "bad regret");
 }
 
 int
diff --git a/src/cmd/6c/cgen.c b/src/cmd/6c/cgen.c
index bdef76ff08..b66c6add3e 100644
--- a/src/cmd/6c/cgen.c
+++ b/src/cmd/6c/cgen.c
@@ -51,7 +51,7 @@ cgen(Node *n, Node *nn)
 	}
 	if(n == Z || n->type == T)
 		return;
-	if(typesu[n->type->etype]) {
+	if(typesu[n->type->etype] && (n->op != OFUNC || nn != Z)) {
 		sugen(n, nn, n->type->width);
 		return;
 	}
@@ -88,7 +88,7 @@ cgen(Node *n, Node *nn)
 		if(cond(o) && typesu[l->type->etype])
 			break;
 
-		regret(&nod, r);
+		regret(&nod, r, 0, 0);
 		cgen(r, &nod);
 
 		regsalloc(&nod1, r);
@@ -135,7 +135,7 @@ cgen(Node *n, Node *nn)
 		if(!hardleft) {
 			if(nn != Z || r->addable < INDEXED || hardconst(r)) {
 				if(r->complex >= FNX && nn == Z)
-					regret(&nod, r);
+					regret(&nod, r, 0, 0);
 				else
 					regalloc(&nod, r, nn);
 				cgen(r, &nod);
@@ -929,7 +929,7 @@ cgen(Node *n, Node *nn)
 			if(l->op != OIND)
 				diag(n, "bad function call");
 
-			regret(&nod, l->left);
+			regret(&nod, l->left, 0, 0);
 			cgen(l->left, &nod);
 			regsalloc(&nod1, l->left);
 			gmove(&nod, &nod1);
@@ -956,11 +956,13 @@ cgen(Node *n, Node *nn)
 		gpcdata(PCDATA_ArgSize, -1);
 		if(REGARG >= 0 && reg[REGARG])
 			reg[REGARG]--;
-		if(nn != Z) {
-			regret(&nod, n);
+		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)
 			regfree(&nod);
-		}
 		break;
 
 	case OIND:
@@ -1382,7 +1384,7 @@ boolgen(Node *n, int true, Node *nn)
 		if(true)
 			o = comrel[relindex(o)];
 		if(l->complex >= FNX && r->complex >= FNX) {
-			regret(&nod, r);
+			regret(&nod, r, 0, 0);
 			cgen(r, &nod);
 			regsalloc(&nod1, r);
 			gmove(&nod, &nod1);
@@ -1535,7 +1537,7 @@ sugen(Node *n, Node *nn, int32 w)
 		if(nn != Z && side(nn)) {
 			nod1 = *n;
 			nod1.type = typ(TIND, n->type);
-			regret(&nod2, &nod1);
+			regret(&nod2, &nod1, 0, 0);
 			lcgen(nn, &nod2);
 			regsalloc(&nod0, &nod1);
 			cgen(&nod2, &nod0);
@@ -1617,6 +1619,20 @@ sugen(Node *n, Node *nn, int32 w)
 		break;
 
 	case OFUNC:
+		if(!hasdotdotdot(n->left->type)) {
+			cgen(n, Z);
+			if(nn != Z) {
+				curarg -= n->type->width;
+				regret(&nod1, n, n->left->type, 1);
+				if(nn->complex >= FNX) {
+					regsalloc(&nod2, n);
+					cgen(&nod1, &nod2);
+					nod1 = nod2;
+				}
+				cgen(&nod1, nn);
+			}
+			break;
+		}
 		if(nn == Z) {
 			sugen(n, nodrat, w);
 			break;
diff --git a/src/cmd/6c/gc.h b/src/cmd/6c/gc.h
index bc4e36ccd8..aa9d95d21d 100644
--- a/src/cmd/6c/gc.h
+++ b/src/cmd/6c/gc.h
@@ -210,7 +210,7 @@ void	xcom(Node*);
 void	indx(Node*);
 int	bcomplex(Node*, Node*);
 Prog*	gtext(Sym*, int32);
-vlong	argsize(void);
+vlong	argsize(int);
 
 /*
  * cgen.c
@@ -239,7 +239,7 @@ Node*	nodfconst(double);
 Node*	nodgconst(vlong, Type*);
 int	nodreg(Node*, Node*, int);
 int	isreg(Node*, int);
-void	regret(Node*, Node*);
+void	regret(Node*, Node*, Type*, int);
 void	regalloc(Node*, Node*, Node*);
 void	regfree(Node*);
 void	regialloc(Node*, Node*, Node*);
diff --git a/src/cmd/6c/sgen.c b/src/cmd/6c/sgen.c
index c048e784d4..d99510185e 100644
--- a/src/cmd/6c/sgen.c
+++ b/src/cmd/6c/sgen.c
@@ -36,7 +36,7 @@ gtext(Sym *s, int32 stkoff)
 {
 	vlong v;
 
-	v = ((uvlong)argsize() << 32) | (stkoff & 0xffffffff);
+	v = ((uvlong)argsize(1) << 32) | (stkoff & 0xffffffff);
 	if((textflag & NOSPLIT) && stkoff >= 128)
 		yyerror("stack frame too large for NOSPLIT function");
 
diff --git a/src/cmd/6c/txt.c b/src/cmd/6c/txt.c
index 4d07436c3f..3bdbf410ea 100644
--- a/src/cmd/6c/txt.c
+++ b/src/cmd/6c/txt.c
@@ -351,15 +351,43 @@ nodreg(Node *n, Node *nn, int r)
 }
 
 void
-regret(Node *n, Node *nn)
+regret(Node *n, Node *nn, Type *t, int mode)
 {
 	int r;
+	
+	if(mode == 0 || hasdotdotdot(t) || nn->type->width == 0) {
+		r = REGRET;
+		if(typefd[nn->type->etype])
+			r = FREGRET;
+		nodreg(n, nn, r);
+		reg[r]++;
+		return;
+	}
+	
+	if(mode == 1) {
+		// fetch returned value after call.
+		// already called gargs, so curarg is set.
+		curarg = (curarg+7) & ~7;
+		regaalloc(n, nn);
+		return;
+	}
 
-	r = REGRET;
-	if(typefd[nn->type->etype])
-		r = FREGRET;
-	nodreg(n, nn, r);
-	reg[r]++;
+	if(mode == 2) {
+		// store value to be returned.
+		// must compute arg offset.
+		if(t->etype != TFUNC)
+			fatal(Z, "bad regret func %T", t);
+		*n = *nn;
+		n->op = ONAME;
+		n->class = CPARAM;
+		n->sym = slookup(".ret");
+		n->complex = nodret->complex;
+		n->addable = 20;
+		n->xoffset = argsize(0);
+		return;
+	}
+	
+	fatal(Z, "bad regret");	
 }
 
 void
diff --git a/src/cmd/8c/cgen.c b/src/cmd/8c/cgen.c
index f541022456..8ac8e36009 100644
--- a/src/cmd/8c/cgen.c
+++ b/src/cmd/8c/cgen.c
@@ -49,7 +49,7 @@ cgen(Node *n, Node *nn)
 	}
 	if(n == Z || n->type == T)
 		return;
-	if(typesuv[n->type->etype]) {
+	if(typesuv[n->type->etype] && (n->op != OFUNC || nn != Z)) {
 		sugen(n, nn, n->type->width);
 		return;
 	}
@@ -86,7 +86,7 @@ cgen(Node *n, Node *nn)
 		if(cond(o) && typesuv[l->type->etype])
 			break;
 
-		regret(&nod, r);
+		regret(&nod, r, 0, 0);
 		cgen(r, &nod);
 
 		regsalloc(&nod1, r);
@@ -147,7 +147,7 @@ cgen(Node *n, Node *nn)
 		if(!hardleft) {
 			if(nn != Z || r->addable < INDEXED) {
 				if(r->complex >= FNX && nn == Z)
-					regret(&nod, r);
+					regret(&nod, r, 0, 0);
 				else
 					regalloc(&nod, r, nn);
 				cgen(r, &nod);
@@ -922,7 +922,7 @@ cgen(Node *n, Node *nn)
 			if(l->op != OIND)
 				diag(n, "bad function call");
 
-			regret(&nod, l->left);
+			regret(&nod, l->left, 0, 0);
 			cgen(l->left, &nod);
 			regsalloc(&nod1, l->left);
 			gmove(&nod, &nod1);
@@ -949,12 +949,12 @@ cgen(Node *n, Node *nn)
 		gpcdata(PCDATA_ArgSize, -1);
 		if(REGARG >= 0 && reg[REGARG])
 			reg[REGARG]--;
-		if(nn != Z) {
-			regret(&nod, n);
+		regret(&nod, n, l->type, 1); // update maxarg if nothing else
+		if(nn != Z)
 			gmove(&nod, nn);
+		if(nod.op == OREGISTER)
 			regfree(&nod);
-		} else
-		if(typefd[n->type->etype])
+		if(nn == Z && hasdotdotdot(l->type) && typefd[n->type->etype])
 			gins(AFMOVDP, &fregnode0, &fregnode0);
 		break;
 
@@ -1374,7 +1374,7 @@ boolgen(Node *n, int true, Node *nn)
 		if(true)
 			o = comrel[relindex(o)];
 		if(l->complex >= FNX && r->complex >= FNX) {
-			regret(&nod, r);
+			regret(&nod, r, 0, 0);
 			cgen(r, &nod);
 			regsalloc(&nod1, r);
 			gmove(&nod, &nod1);
@@ -1567,7 +1567,7 @@ sugen(Node *n, Node *nn, int32 w)
 		if(nn != Z && side(nn)) {
 			nod1 = *n;
 			nod1.type = typ(TIND, n->type);
-			regret(&nod2, &nod1);
+			regret(&nod2, &nod1, 0, 0);
 			lcgen(nn, &nod2);
 			regsalloc(&nod0, &nod1);
 			cgen(&nod2, &nod0);
@@ -1649,6 +1649,20 @@ sugen(Node *n, Node *nn, int32 w)
 		break;
 
 	case OFUNC:
+		if(!hasdotdotdot(n->left->type)) {
+			cgen(n, Z);
+			if(nn != Z) {
+				curarg -= n->type->width;
+				regret(&nod1, n, n->left->type, 1);
+				if(nn->complex >= FNX) {
+					regsalloc(&nod2, n);
+					cgen(&nod1, &nod2);
+					nod1 = nod2;
+				}
+				cgen(&nod1, nn);
+			}
+			break;
+		}
 		if(nn == Z) {
 			sugen(n, nodrat, w);
 			break;
diff --git a/src/cmd/8c/gc.h b/src/cmd/8c/gc.h
index 9c4613f562..aa3888d733 100644
--- a/src/cmd/8c/gc.h
+++ b/src/cmd/8c/gc.h
@@ -210,7 +210,7 @@ void	xcom(Node*);
 void	indx(Node*);
 int	bcomplex(Node*, Node*);
 Prog*	gtext(Sym*, int32);
-vlong	argsize(void);
+vlong	argsize(int);
 
 /*
  * cgen.c
@@ -244,7 +244,7 @@ Node*	nodconst(int32);
 Node*	nodfconst(double);
 int	nodreg(Node*, Node*, int);
 int	isreg(Node*, int);
-void	regret(Node*, Node*);
+void	regret(Node*, Node*, Type*, int);
 void	regalloc(Node*, Node*, Node*);
 void	regfree(Node*);
 void	regialloc(Node*, Node*, Node*);
diff --git a/src/cmd/8c/sgen.c b/src/cmd/8c/sgen.c
index 069bbc1fc3..d647010ef7 100644
--- a/src/cmd/8c/sgen.c
+++ b/src/cmd/8c/sgen.c
@@ -35,7 +35,7 @@ gtext(Sym *s, int32 stkoff)
 {
 	int32 a;
 
-	a = argsize();
+	a = argsize(1);
 	if((textflag & NOSPLIT) != 0 && stkoff >= 128)
 		yyerror("stack frame too large for NOSPLIT function");
 
diff --git a/src/cmd/8c/txt.c b/src/cmd/8c/txt.c
index 25082de05d..7f87a0a0d0 100644
--- a/src/cmd/8c/txt.c
+++ b/src/cmd/8c/txt.c
@@ -311,15 +311,43 @@ nodreg(Node *n, Node *nn, int r)
 }
 
 void
-regret(Node *n, Node *nn)
+regret(Node *n, Node *nn, Type *t, int mode)
 {
 	int r;
 
-	r = REGRET;
-	if(typefd[nn->type->etype])
-		r = FREGRET;
-	nodreg(n, nn, r);
-	reg[r]++;
+	if(mode == 0 || hasdotdotdot(t) || nn->type->width == 0) {
+		r = REGRET;
+		if(typefd[nn->type->etype])
+			r = FREGRET;
+		nodreg(n, nn, r);
+		reg[r]++;
+		return;
+	}
+	
+	if(mode == 1) {
+		// fetch returned value after call.
+		// already called gargs, so curarg is set.
+		curarg = (curarg+3) & ~3;
+		regaalloc(n, nn);
+		return;
+	}
+	
+	if(mode == 2) {
+		// store value to be returned.
+		// must compute arg offset.
+		if(t->etype != TFUNC)
+			fatal(Z, "bad regret func %T", t);
+		*n = *nn;
+		n->op = ONAME;
+		n->class = CPARAM;
+		n->sym = slookup(".retx");
+		n->complex = 0;
+		n->addable = 20;
+		n->xoffset = argsize(0);
+		return;
+	}
+	
+	fatal(Z, "bad regret");
 }
 
 void
diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 54c84b4d09..c3ab9c5bcf 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -385,6 +385,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
 			" hchan struct{}; chantype struct{}; waitq struct{};" +
 			" note struct{}; wincallbackcontext struct{};" +
+			" gobuf struct{}; funcval struct{};" +
 			"); " +
 			"const ( cb_max = 2000 )"
 		f, err = parser.ParseFile(fset, filename, src, 0)
diff --git a/src/cmd/cc/cc.h b/src/cmd/cc/cc.h
index c8aac12530..1dae5acd90 100644
--- a/src/cmd/cc/cc.h
+++ b/src/cmd/cc/cc.h
@@ -794,7 +794,7 @@ void	xcom(Node*);
 int32	exreg(Type*);
 int32	align(int32, Type*, int, int32*);
 int32	maxround(int32, int32);
-int	hasdotdotdot(void);
+int	hasdotdotdot(Type*);
 void    linkarchinit(void);
 
 extern	schar	ewidth[];
diff --git a/src/cmd/cc/dcl.c b/src/cmd/cc/dcl.c
index 051a6c0a74..7cda9f924d 100644
--- a/src/cmd/cc/dcl.c
+++ b/src/cmd/cc/dcl.c
@@ -697,7 +697,8 @@ argmark(Node *n, int pass)
 {
 	Type *t;
 
-	autoffset = align(0, thisfn->link, Aarg0, nil);
+	if(hasdotdotdot(thisfn->link))
+		autoffset = align(0, thisfn->link, Aarg0, nil);
 	stkoff = 0;
 	for(; n->left != Z; n = n->left) {
 		if(n->op != OFUNC || n->left->op != ONAME)
diff --git a/src/cmd/cc/pgen.c b/src/cmd/cc/pgen.c
index 0ee13787f0..53410a11a0 100644
--- a/src/cmd/cc/pgen.c
+++ b/src/cmd/cc/pgen.c
@@ -56,24 +56,24 @@ makefuncdatasym(char *namefmt, int64 funcdatakind)
 }
 
 int
-hasdotdotdot(void)
+hasdotdotdot(Type *t)
 {
-	Type *t;
-
-	for(t=thisfn->down; t!=T; t=t->down)
+	for(t=t->down; t!=T; t=t->down)
 		if(t->etype == TDOT)
 			return 1;
 	return 0;
 }
 
 vlong
-argsize(void)
+argsize(int doret)
 {
 	Type *t;
 	int32 s;
 
 //print("t=%T\n", thisfn);
-	s = align(0, thisfn->link, Aarg0, nil);
+	s = 0;
+	if(hasdotdotdot(thisfn))
+		s = align(s, thisfn->link, Aarg0, nil);
 	for(t=thisfn->down; t!=T; t=t->down) {
 		switch(t->etype) {
 		case TVOID:
@@ -93,6 +93,14 @@ argsize(void)
 		s = (s+7) & ~7;
 	else
 		s = (s+3) & ~3;
+	if(doret && thisfn->link->etype != TVOID) {
+		s = align(s, thisfn->link, Aarg1, nil);
+		s = align(s, thisfn->link, Aarg2, nil);
+		if(thechar == '6')
+			s = (s+7) & ~7;
+		else
+			s = (s+3) & ~3;
+	}
 	return s;
 }
 
@@ -129,7 +137,7 @@ codgen(Node *n, Node *nn)
 	 * generate funcdata symbol for this function.
 	 * data is filled in at the end of codgen().
 	 */
-	isvarargs = hasdotdotdot();
+	isvarargs = hasdotdotdot(thisfn);
 	gcargs = nil;
 	if(!isvarargs)
 		gcargs = makefuncdatasym("gcargs·%d", FUNCDATA_ArgsPointerMaps);
@@ -212,7 +220,7 @@ supgen(Node *n)
 void
 gen(Node *n)
 {
-	Node *l, nod;
+	Node *l, nod, nod1;
 	Prog *sp, *spc, *spb;
 	Case *cn;
 	long sbc, scc;
@@ -273,14 +281,26 @@ loop:
 			gbranch(ORETURN);
 			break;
 		}
+		if(typecmplx[n->type->etype] && !hasdotdotdot(thisfn)) {
+			regret(&nod, n, thisfn, 2);
+			sugen(l, &nod, n->type->width);
+			noretval(3);
+			gbranch(ORETURN);
+			break;
+		}
 		if(typecmplx[n->type->etype]) {
 			sugen(l, nodret, n->type->width);
 			noretval(3);
 			gbranch(ORETURN);
 			break;
 		}
-		regret(&nod, n);
+		regret(&nod1, n, thisfn, 2);
+		nod = nod1;
+		if(nod.op != OREGISTER)
+			regalloc(&nod, n, Z);
 		cgen(l, &nod);
+		if(nod1.op != OREGISTER)
+			gmove(&nod, &nod1);
 		regfree(&nod);
 		if(typefd[n->type->etype])
 			noretval(1);
@@ -729,9 +749,11 @@ dumpgcargs(Type *fn, Sym *sym)
 	symoffset = 0;
 	gextern(sym, nodconst(1), symoffset, 4);
 	symoffset += 4;
-	argbytes = (argsize() + ewidth[TIND] - 1);
+	argbytes = (argsize(1) + ewidth[TIND] - 1);
 	bv = bvalloc((argbytes  / ewidth[TIND]) * BitsPerPointer);
-	argoffset = align(0, fn->link, Aarg0, nil);
+	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
diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index ff296b692e..be6eaac230 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -43,6 +43,9 @@ var use_aeshash bool
 
 // in asm_*.s
 func aeshash(p unsafe.Pointer, s, h uintptr) uintptr
+func aeshash32(p unsafe.Pointer, s, h uintptr) uintptr
+func aeshash64(p unsafe.Pointer, s, h uintptr) uintptr
+func aeshashstr(p unsafe.Pointer, s, h uintptr) uintptr
 
 func memhash(p unsafe.Pointer, s, h uintptr) uintptr {
 	if !nacl && use_aeshash {
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 2163c913d9..d52eca3867 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -134,8 +134,8 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 // void gosave(Gobuf*)
 // save state in Gobuf; setjmp
 TEXT runtime·gosave(SB), NOSPLIT, $0-4
-	MOVL	4(SP), AX		// gobuf
-	LEAL	4(SP), BX		// caller's SP
+	MOVL	buf+0(FP), AX		// gobuf
+	LEAL	buf+0(FP), BX		// caller's SP
 	MOVL	BX, gobuf_sp(AX)
 	MOVL	0(SP), BX		// caller's PC
 	MOVL	BX, gobuf_pc(AX)
@@ -149,7 +149,7 @@ TEXT runtime·gosave(SB), NOSPLIT, $0-4
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $0-4
-	MOVL	4(SP), BX		// gobuf
+	MOVL	buf+0(FP), BX		// gobuf
 	MOVL	gobuf_g(BX), DX
 	MOVL	0(DX), CX		// make sure g != nil
 	get_tls(CX)
@@ -174,7 +174,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
 	MOVL	g(CX), AX	// save state in g->sched
 	MOVL	0(SP), BX	// caller's PC
 	MOVL	BX, (g_sched+gobuf_pc)(AX)
-	LEAL	4(SP), BX	// caller's SP
+	LEAL	fn+0(FP), BX	// caller's SP
 	MOVL	BX, (g_sched+gobuf_sp)(AX)
 	MOVL	AX, (g_sched+gobuf_g)(AX)
 
@@ -318,7 +318,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
 	// restore when returning from f.
 	MOVL	0(SP), AX	// our caller's PC
 	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAL	4(SP), AX	// our caller's SP
+	LEAL	fv+0(FP), AX	// our caller's SP
 	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
 	MOVL	g(CX), AX
 	MOVL	AX, (m_morebuf+gobuf_g)(BX)
@@ -334,9 +334,9 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
 	// If it turns out that f needs a larger frame than
 	// the default stack, f's usual stack growth prolog will
 	// allocate a new segment (and recopy the arguments).
-	MOVL	4(SP), AX	// fn
-	MOVL	8(SP), DX	// arg frame
-	MOVL	12(SP), CX	// arg size
+	MOVL	fv+0(FP), AX	// fn
+	MOVL	addr+4(FP), DX	// arg frame
+	MOVL	size+8(FP), CX	// arg size
 
 	MOVL	AX, m_cret(BX)	// f's PC
 	MOVL	DX, m_moreargp(BX)	// f's argument pointer
@@ -481,7 +481,6 @@ TEXT runtime·lessstack(SB), NOSPLIT, $0-0
 	MOVL	$0, 0x1004	// crash if oldstack returns
 	RET
 
-
 // bool cas(int32 *val, int32 old, int32 new)
 // Atomically:
 //	if(*val == old){
@@ -489,16 +488,18 @@ TEXT runtime·lessstack(SB), NOSPLIT, $0-0
 //		return 1;
 //	}else
 //		return 0;
-TEXT runtime·cas(SB), NOSPLIT, $0-12
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
-	MOVL	12(SP), CX
+TEXT runtime·cas(SB), NOSPLIT, $0-13
+	MOVL	ptr+0(FP), BX
+	MOVL	old+4(FP), AX
+	MOVL	new+8(FP), CX
 	LOCK
 	CMPXCHGL	CX, 0(BX)
-	JZ 3(PC)
+	JZ 4(PC)
 	MOVL	$0, AX
+	MOVB	AX, ret+12(FP)
 	RET
 	MOVL	$1, AX
+	MOVB	AX, ret+12(FP)
 	RET
 
 // bool runtime·cas64(uint64 *val, uint64 old, uint64 new)
@@ -509,19 +510,21 @@ TEXT runtime·cas(SB), NOSPLIT, $0-12
 //	} else {
 //		return 0;
 //	}
-TEXT runtime·cas64(SB), NOSPLIT, $0-20
-	MOVL	4(SP), BP
-	MOVL	8(SP), AX
-	MOVL	12(SP), DX
-	MOVL	16(SP), BX
-	MOVL	20(SP), CX
+TEXT runtime·cas64(SB), NOSPLIT, $0-21
+	MOVL	ptr+0(FP), BP
+	MOVL	old_lo+4(FP), AX
+	MOVL	old_hi+8(FP), DX
+	MOVL	new_lo+12(FP), BX
+	MOVL	new_hi+16(FP), CX
 	LOCK
 	CMPXCHG8B	0(BP)
 	JNZ	cas64_fail
 	MOVL	$1, AX
+	MOVB	AX, ret+20(FP)
 	RET
 cas64_fail:
 	MOVL	$0, AX
+	MOVB	AX, ret+20(FP)
 	RET
 
 // bool casp(void **p, void *old, void *new)
@@ -531,45 +534,50 @@ cas64_fail:
 //		return 1;
 //	}else
 //		return 0;
-TEXT runtime·casp(SB), NOSPLIT, $0-12
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
-	MOVL	12(SP), CX
+TEXT runtime·casp(SB), NOSPLIT, $0-13
+	MOVL	ptr+0(FP), BX
+	MOVL	old+4(FP), AX
+	MOVL	new+8(FP), CX
 	LOCK
 	CMPXCHGL	CX, 0(BX)
-	JZ 3(PC)
+	JZ 4(PC)
 	MOVL	$0, AX
+	MOVB	AX, ret+12(FP)
 	RET
 	MOVL	$1, AX
+	MOVB	AX, ret+12(FP)
 	RET
 
 // uint32 xadd(uint32 volatile *val, int32 delta)
 // Atomically:
 //	*val += delta;
 //	return *val;
-TEXT runtime·xadd(SB), NOSPLIT, $0-8
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
+TEXT runtime·xadd(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), BX
+	MOVL	delta+4(FP), AX
 	MOVL	AX, CX
 	LOCK
 	XADDL	AX, 0(BX)
 	ADDL	CX, AX
+	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·xchg(SB), NOSPLIT, $0-8
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
+TEXT runtime·xchg(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), BX
+	MOVL	new+4(FP), AX
 	XCHGL	AX, 0(BX)
+	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·xchgp(SB), NOSPLIT, $0-8
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
+TEXT runtime·xchgp(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), BX
+	MOVL	new+4(FP), AX
 	XCHGL	AX, 0(BX)
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·procyield(SB),NOSPLIT,$0-0
-	MOVL	4(SP), AX
+	MOVL	cycles+0(FP), AX
 again:
 	PAUSE
 	SUBL	$1, AX
@@ -577,23 +585,21 @@ again:
 	RET
 
 TEXT runtime·atomicstorep(SB), NOSPLIT, $0-8
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
+	MOVL	ptr+0(FP), BX
+	MOVL	val+4(FP), AX
 	XCHGL	AX, 0(BX)
 	RET
 
 TEXT runtime·atomicstore(SB), NOSPLIT, $0-8
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
+	MOVL	ptr+0(FP), BX
+	MOVL	val+4(FP), AX
 	XCHGL	AX, 0(BX)
 	RET
 
 // uint64 atomicload64(uint64 volatile* addr);
-// so actually
-// void atomicload64(uint64 *res, uint64 volatile *addr);
-TEXT runtime·atomicload64(SB), NOSPLIT, $0-8
-	MOVL	4(SP), BX
-	MOVL	8(SP), AX
+TEXT runtime·atomicload64(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), AX
+	LEAL	ret_lo+4(FP), BX
 	// MOVQ (%EAX), %MM0
 	BYTE $0x0f; BYTE $0x6f; BYTE $0x00
 	// MOVQ %MM0, 0(%EBX)
@@ -604,7 +610,7 @@ TEXT runtime·atomicload64(SB), NOSPLIT, $0-8
 
 // void runtime·atomicstore64(uint64 volatile* addr, uint64 v);
 TEXT runtime·atomicstore64(SB), NOSPLIT, $0-12
-	MOVL	4(SP), AX
+	MOVL	ptr+0(FP), AX
 	// MOVQ and EMMS were introduced on the Pentium MMX.
 	// MOVQ 0x8(%ESP), %MM0
 	BYTE $0x0f; BYTE $0x6f; BYTE $0x44; BYTE $0x24; BYTE $0x08
@@ -620,7 +626,7 @@ TEXT runtime·atomicstore64(SB), NOSPLIT, $0-12
 	RET
 
 // void	runtime·atomicor8(byte volatile*, byte);
-TEXT runtime·atomicor8(SB), NOSPLIT, $0-8
+TEXT runtime·atomicor8(SB), NOSPLIT, $0-5
 	MOVL	ptr+0(FP), AX
 	MOVB	val+4(FP), BX
 	LOCK
@@ -633,8 +639,8 @@ TEXT runtime·atomicor8(SB), NOSPLIT, $0-8
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
 TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
-	MOVL	4(SP), DX	// fn
-	MOVL	8(SP), BX	// caller sp
+	MOVL	fv+0(FP), DX	// fn
+	MOVL	argp+4(FP), BX	// caller sp
 	LEAL	-4(BX), SP	// caller sp after CALL
 	SUBL	$5, (SP)	// return to CALL again
 	MOVL	0(DX), BX
@@ -804,7 +810,7 @@ havem:
 	RET
 
 // void setg(G*); set g. for use by needm.
-TEXT runtime·setg(SB), NOSPLIT, $0-8
+TEXT runtime·setg(SB), NOSPLIT, $0-4
 	MOVL	gg+0(FP), BX
 #ifdef GOOS_windows
 	CMPL	BX, $0
@@ -839,9 +845,10 @@ TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
 	INT	$3
 	RET
 
-TEXT runtime·getcallerpc(SB),NOSPLIT,$0-4
-	MOVL	x+0(FP),AX		// addr of first arg
+TEXT runtime·getcallerpc(SB),NOSPLIT,$0-8
+	MOVL	argp+0(FP),AX		// addr of first arg
 	MOVL	-4(AX),AX		// get calling pc
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·gogetcallerpc(SB),NOSPLIT,$0-8
@@ -851,13 +858,14 @@ TEXT runtime·gogetcallerpc(SB),NOSPLIT,$0-8
 	RET
 
 TEXT runtime·setcallerpc(SB),NOSPLIT,$0-8
-	MOVL	x+0(FP),AX		// addr of first arg
-	MOVL	x+4(FP), BX
+	MOVL	argp+0(FP),AX		// addr of first arg
+	MOVL	pc+4(FP), BX
 	MOVL	BX, -4(AX)		// set calling pc
 	RET
 
-TEXT runtime·getcallersp(SB), NOSPLIT, $0-4
-	MOVL	sp+0(FP), AX
+TEXT runtime·getcallersp(SB), NOSPLIT, $0-8
+	MOVL	argp+0(FP), AX
+	MOVL	AX, ret+4(FP)
 	RET
 
 // func gogetcallersp(p unsafe.Pointer) uintptr
@@ -868,11 +876,10 @@ TEXT runtime·gogetcallersp(SB),NOSPLIT,$0-8
 
 // int64 runtime·cputicks(void), so really
 // void runtime·cputicks(int64 *ticks)
-TEXT runtime·cputicks(SB),NOSPLIT,$0-4
+TEXT runtime·cputicks(SB),NOSPLIT,$0-8
 	RDTSC
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
@@ -976,7 +983,7 @@ finalize:
 	AESENC	X2, X0
 	AESENC	X3, X0
 	AESENC	X2, X0
-	MOVL	X0, res+12(FP)
+	MOVL	X0, ret+12(FP)
 	RET
 
 TEXT runtime·aeshash32(SB),NOSPLIT,$0-16
@@ -987,7 +994,7 @@ TEXT runtime·aeshash32(SB),NOSPLIT,$0-16
 	AESENC	runtime·aeskeysched+0(SB), X0
 	AESENC	runtime·aeskeysched+16(SB), X0
 	AESENC	runtime·aeskeysched+0(SB), X0
-	MOVL	X0, res+12(FP)
+	MOVL	X0, ret+12(FP)
 	RET
 
 TEXT runtime·aeshash64(SB),NOSPLIT,$0-16
@@ -998,7 +1005,7 @@ TEXT runtime·aeshash64(SB),NOSPLIT,$0-16
 	AESENC	runtime·aeskeysched+0(SB), X0
 	AESENC	runtime·aeskeysched+16(SB), X0
 	AESENC	runtime·aeskeysched+0(SB), X0
-	MOVL	X0, res+12(FP)
+	MOVL	X0, ret+12(FP)
 	RET
 
 // simple mask to get rid of data in the high part of the register.
@@ -1309,12 +1316,12 @@ equal:
 	RET
 
 TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
-	MOVL	s1+0(FP), SI
-	MOVL	s1+4(FP), BX
-	MOVL	s2+8(FP), DI
-	MOVL	s2+12(FP), DX
+	MOVL	s1_base+0(FP), SI
+	MOVL	s1_len+4(FP), BX
+	MOVL	s2_base+8(FP), DI
+	MOVL	s2_len+12(FP), DX
 	CALL	runtime·cmpbody(SB)
-	MOVL	AX, res+16(FP)
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT bytes·Compare(SB),NOSPLIT,$0-28
@@ -1323,7 +1330,7 @@ TEXT bytes·Compare(SB),NOSPLIT,$0-28
 	MOVL	s2+12(FP), DI
 	MOVL	s2+16(FP), DX
 	CALL	runtime·cmpbody(SB)
-	MOVL	AX, res+24(FP)
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT bytes·IndexByte(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index c53e2d350e..70e2225213 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -125,8 +125,8 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 // void gosave(Gobuf*)
 // save state in Gobuf; setjmp
 TEXT runtime·gosave(SB), NOSPLIT, $0-8
-	MOVQ	8(SP), AX		// gobuf
-	LEAQ	8(SP), BX		// caller's SP
+	MOVQ	buf+0(FP), AX		// gobuf
+	LEAQ	buf+0(FP), BX		// caller's SP
 	MOVQ	BX, gobuf_sp(AX)
 	MOVQ	0(SP), BX		// caller's PC
 	MOVQ	BX, gobuf_pc(AX)
@@ -140,7 +140,7 @@ TEXT runtime·gosave(SB), NOSPLIT, $0-8
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $0-8
-	MOVQ	8(SP), BX		// gobuf
+	MOVQ	buf+0(FP), BX		// gobuf
 	MOVQ	gobuf_g(BX), DX
 	MOVQ	0(DX), CX		// make sure g != nil
 	get_tls(CX)
@@ -165,7 +165,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	MOVQ	g(CX), AX	// save state in g->sched
 	MOVQ	0(SP), BX	// caller's PC
 	MOVQ	BX, (g_sched+gobuf_pc)(AX)
-	LEAQ	8(SP), BX	// caller's SP
+	LEAQ	fn+0(FP), BX	// caller's SP
 	MOVQ	BX, (g_sched+gobuf_sp)(AX)
 	MOVQ	AX, (g_sched+gobuf_g)(AX)
 
@@ -297,7 +297,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
 	// restore when returning from f.
 	MOVQ	0(SP), AX	// our caller's PC
 	MOVQ	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAQ	8(SP), AX	// our caller's SP
+	LEAQ	fv+0(FP), AX	// our caller's SP
 	MOVQ	AX, (m_morebuf+gobuf_sp)(BX)
 	MOVQ	g(CX), AX
 	MOVQ	AX, (m_morebuf+gobuf_g)(BX)
@@ -314,9 +314,9 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
 	// If it turns out that f needs a larger frame than
 	// the default stack, f's usual stack growth prolog will
 	// allocate a new segment (and recopy the arguments).
-	MOVQ	8(SP), AX	// fn
-	MOVQ	16(SP), DX	// arg frame
-	MOVL	24(SP), CX	// arg size
+	MOVQ	fv+0(FP), AX	// fn
+	MOVQ	addr+8(FP), DX	// arg frame
+	MOVL	size+16(FP), CX	// arg size
 
 	MOVQ	AX, m_cret(BX)	// f's PC
 	MOVQ	DX, m_moreargp(BX)	// argument frame pointer
@@ -584,16 +584,18 @@ TEXT runtime·morestack48_noctxt(SB),NOSPLIT,$0
 //		return 1;
 //	} else
 //		return 0;
-TEXT runtime·cas(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), BX
-	MOVL	16(SP), AX
-	MOVL	20(SP), CX
+TEXT runtime·cas(SB), NOSPLIT, $0-17
+	MOVQ	ptr+0(FP), BX
+	MOVL	old+8(FP), AX
+	MOVL	new+12(FP), CX
 	LOCK
 	CMPXCHGL	CX, 0(BX)
-	JZ 3(PC)
+	JZ 4(PC)
 	MOVL	$0, AX
+	MOVB	AX, ret+16(FP)
 	RET
 	MOVL	$1, AX
+	MOVB	AX, ret+16(FP)
 	RET
 
 // bool	runtime·cas64(uint64 *val, uint64 old, uint64 new)
@@ -604,17 +606,19 @@ TEXT runtime·cas(SB), NOSPLIT, $0-16
 //	} else {
 //		return 0;
 //	}
-TEXT runtime·cas64(SB), NOSPLIT, $0-24
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
-	MOVQ	24(SP), CX
+TEXT runtime·cas64(SB), NOSPLIT, $0-25
+	MOVQ	ptr+0(FP), BX
+	MOVQ	old+8(FP), AX
+	MOVQ	new+16(FP), CX
 	LOCK
 	CMPXCHGQ	CX, 0(BX)
 	JNZ	cas64_fail
 	MOVL	$1, AX
+	MOVB	AX, ret+24(FP)
 	RET
 cas64_fail:
 	MOVL	$0, AX
+	MOVB	AX, ret+24(FP)
 	RET
 
 // bool casp(void **val, void *old, void *new)
@@ -624,60 +628,67 @@ cas64_fail:
 //		return 1;
 //	} else
 //		return 0;
-TEXT runtime·casp(SB), NOSPLIT, $0-24
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
-	MOVQ	24(SP), CX
+TEXT runtime·casp(SB), NOSPLIT, $0-25
+	MOVQ	ptr+0(FP), BX
+	MOVQ	old+8(FP), AX
+	MOVQ	new+16(FP), CX
 	LOCK
 	CMPXCHGQ	CX, 0(BX)
-	JZ 3(PC)
+	JZ 4(PC)
 	MOVL	$0, AX
+	MOVB	AX, ret+24(FP)
 	RET
 	MOVL	$1, AX
+	MOVB	AX, ret+24(FP)
 	RET
 
 // uint32 xadd(uint32 volatile *val, int32 delta)
 // Atomically:
 //	*val += delta;
 //	return *val;
-TEXT runtime·xadd(SB), NOSPLIT, $0-12
-	MOVQ	8(SP), BX
-	MOVL	16(SP), AX
+TEXT runtime·xadd(SB), NOSPLIT, $0-20
+	MOVQ	ptr+0(FP), BX
+	MOVL	delta+8(FP), AX
 	MOVL	AX, CX
 	LOCK
 	XADDL	AX, 0(BX)
 	ADDL	CX, AX
+	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT runtime·xadd64(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
+TEXT runtime·xadd64(SB), NOSPLIT, $0-24
+	MOVQ	ptr+0(FP), BX
+	MOVQ	delta+8(FP), AX
 	MOVQ	AX, CX
 	LOCK
 	XADDQ	AX, 0(BX)
 	ADDQ	CX, AX
+	MOVQ	AX, ret+16(FP)
 	RET
 
-TEXT runtime·xchg(SB), NOSPLIT, $0-12
-	MOVQ	8(SP), BX
-	MOVL	16(SP), AX
+TEXT runtime·xchg(SB), NOSPLIT, $0-20
+	MOVQ	ptr+0(FP), BX
+	MOVL	new+8(FP), AX
 	XCHGL	AX, 0(BX)
+	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT runtime·xchg64(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
+TEXT runtime·xchg64(SB), NOSPLIT, $0-24
+	MOVQ	ptr+0(FP), BX
+	MOVQ	new+8(FP), AX
 	XCHGQ	AX, 0(BX)
+	MOVQ	AX, ret+16(FP)
 	RET
 
-TEXT runtime·xchgp(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
+TEXT runtime·xchgp(SB), NOSPLIT, $0-24
+	MOVQ	ptr+0(FP), BX
+	MOVQ	new+8(FP), AX
 	XCHGQ	AX, 0(BX)
+	MOVQ	AX, ret+16(FP)
 	RET
 
 TEXT runtime·procyield(SB),NOSPLIT,$0-0
-	MOVL	8(SP), AX
+	MOVL	cycles+0(FP), AX
 again:
 	PAUSE
 	SUBL	$1, AX
@@ -685,25 +696,25 @@ again:
 	RET
 
 TEXT runtime·atomicstorep(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
+	MOVQ	ptr+0(FP), BX
+	MOVQ	val+8(FP), AX
 	XCHGQ	AX, 0(BX)
 	RET
 
 TEXT runtime·atomicstore(SB), NOSPLIT, $0-12
-	MOVQ	8(SP), BX
-	MOVL	16(SP), AX
+	MOVQ	ptr+0(FP), BX
+	MOVL	val+8(FP), AX
 	XCHGL	AX, 0(BX)
 	RET
 
 TEXT runtime·atomicstore64(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), BX
-	MOVQ	16(SP), AX
+	MOVQ	ptr+0(FP), BX
+	MOVQ	val+8(FP), AX
 	XCHGQ	AX, 0(BX)
 	RET
 
 // void	runtime·atomicor8(byte volatile*, byte);
-TEXT runtime·atomicor8(SB), NOSPLIT, $0-16
+TEXT runtime·atomicor8(SB), NOSPLIT, $0-9
 	MOVQ	ptr+0(FP), AX
 	MOVB	val+8(FP), BX
 	LOCK
@@ -716,8 +727,8 @@ TEXT runtime·atomicor8(SB), NOSPLIT, $0-16
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
 TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
-	MOVQ	8(SP), DX	// fn
-	MOVQ	16(SP), BX	// caller sp
+	MOVQ	fv+0(FP), DX	// fn
+	MOVQ	argp+8(FP), BX	// caller sp
 	LEAQ	-8(BX), SP	// caller sp after CALL
 	SUBQ	$5, (SP)	// return to CALL again
 	MOVQ	0(DX), BX
@@ -891,7 +902,7 @@ havem:
 	RET
 
 // void setg(G*); set g. for use by needm.
-TEXT runtime·setg(SB), NOSPLIT, $0-16
+TEXT runtime·setg(SB), NOSPLIT, $0-8
 	MOVQ	gg+0(FP), BX
 #ifdef GOOS_windows
 	CMPQ	BX, $0
@@ -925,9 +936,10 @@ TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
 	INT	$3
 	RET
 
-TEXT runtime·getcallerpc(SB),NOSPLIT,$0-8
-	MOVQ	x+0(FP),AX		// addr of first arg
+TEXT runtime·getcallerpc(SB),NOSPLIT,$0-16
+	MOVQ	argp+0(FP),AX		// addr of first arg
 	MOVQ	-8(AX),AX		// get calling pc
+	MOVQ	AX, ret+8(FP)
 	RET
 
 TEXT runtime·gogetcallerpc(SB),NOSPLIT,$0-16
@@ -937,13 +949,14 @@ TEXT runtime·gogetcallerpc(SB),NOSPLIT,$0-16
 	RET
 
 TEXT runtime·setcallerpc(SB),NOSPLIT,$0-16
-	MOVQ	x+0(FP),AX		// addr of first arg
-	MOVQ	x+8(FP), BX
+	MOVQ	argp+0(FP),AX		// addr of first arg
+	MOVQ	pc+8(FP), BX
 	MOVQ	BX, -8(AX)		// set calling pc
 	RET
 
-TEXT runtime·getcallersp(SB),NOSPLIT,$0-8
-	MOVQ	sp+0(FP), AX
+TEXT runtime·getcallersp(SB),NOSPLIT,$0-16
+	MOVQ	argp+0(FP), AX
+	MOVQ	AX, ret+8(FP)
 	RET
 
 // func gogetcallersp(p unsafe.Pointer) uintptr
@@ -957,6 +970,7 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 	RDTSC
 	SHLQ	$32, DX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
@@ -1057,7 +1071,7 @@ TEXT runtime·aeshash32(SB),NOSPLIT,$0-32
 	AESENC	runtime·aeskeysched+0(SB), X0
 	AESENC	runtime·aeskeysched+16(SB), X0
 	AESENC	runtime·aeskeysched+0(SB), X0
-	MOVQ	X0, res+24(FP)
+	MOVQ	X0, ret+24(FP)
 	RET
 
 TEXT runtime·aeshash64(SB),NOSPLIT,$0-32
@@ -1068,7 +1082,7 @@ TEXT runtime·aeshash64(SB),NOSPLIT,$0-32
 	AESENC	runtime·aeskeysched+0(SB), X0
 	AESENC	runtime·aeskeysched+16(SB), X0
 	AESENC	runtime·aeskeysched+0(SB), X0
-	MOVQ	X0, res+24(FP)
+	MOVQ	X0, ret+24(FP)
 	RET
 
 // simple mask to get rid of data in the high part of the register.
@@ -1266,12 +1280,12 @@ equal:
 	RET
 
 TEXT runtime·cmpstring(SB),NOSPLIT,$0-40
-	MOVQ	s1+0(FP), SI
-	MOVQ	s1+8(FP), BX
-	MOVQ	s2+16(FP), DI
-	MOVQ	s2+24(FP), DX
+	MOVQ	s1_base+0(FP), SI
+	MOVQ	s1_len+8(FP), BX
+	MOVQ	s2_base+16(FP), DI
+	MOVQ	s2_len+24(FP), DX
 	CALL	runtime·cmpbody(SB)
-	MOVQ	AX, res+32(FP)
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT bytes·Compare(SB),NOSPLIT,$0-56
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 4c039d7767..83faff2815 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -103,8 +103,8 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 // void gosave(Gobuf*)
 // save state in Gobuf; setjmp
 TEXT runtime·gosave(SB), NOSPLIT, $0-4
-	MOVL	b+0(FP), AX	// gobuf
-	LEAL	b+0(FP), BX	// caller's SP
+	MOVL	buf+0(FP), AX	// gobuf
+	LEAL	buf+0(FP), BX	// caller's SP
 	MOVL	BX, gobuf_sp(AX)
 	MOVL	0(SP), BX		// caller's PC
 	MOVL	BX, gobuf_pc(AX)
@@ -118,7 +118,7 @@ TEXT runtime·gosave(SB), NOSPLIT, $0-4
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB), NOSPLIT, $0-4
-	MOVL	b+0(FP), BX		// gobuf
+	MOVL	buf+0(FP), BX		// gobuf
 	MOVL	gobuf_g(BX), DX
 	MOVL	0(DX), CX		// make sure g != nil
 	get_tls(CX)
@@ -266,7 +266,7 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 // with the desired args running the desired function.
 //
 // func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
+TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
 	get_tls(CX)
 	MOVL	g(CX), BX
 	MOVL	g_m(BX), BX
@@ -275,7 +275,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
 	// restore when returning from f.
 	MOVL	0(SP), AX	// our caller's PC
 	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAL	8(SP), AX	// our caller's SP
+	LEAL	addr+4(FP), AX	// our caller's SP
 	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
 	MOVL	g(CX), AX
 	MOVL	AX, (m_morebuf+gobuf_g)(BX)
@@ -292,9 +292,9 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
 	// If it turns out that f needs a larger frame than
 	// the default stack, f's usual stack growth prolog will
 	// allocate a new segment (and recopy the arguments).
-	MOVL	8(SP), AX	// fn
-	MOVL	12(SP), DX	// arg frame
-	MOVL	16(SP), CX	// arg size
+	MOVL	fv+0(FP), AX	// fn
+	MOVL	addr+4(FP), DX	// arg frame
+	MOVL	size+8(FP), CX	// arg size
 
 	MOVQ	AX, m_cret(BX)	// f's PC
 	MOVL	DX, m_moreargp(BX)	// argument frame pointer
@@ -548,16 +548,18 @@ TEXT runtime·morestack48_noctxt(SB),NOSPLIT,$0
 //		return 1;
 //	} else
 //		return 0;
-TEXT runtime·cas(SB), NOSPLIT, $0-12
-	MOVL	val+0(FP), BX
+TEXT runtime·cas(SB), NOSPLIT, $0-17
+	MOVL	ptr+0(FP), BX
 	MOVL	old+4(FP), AX
 	MOVL	new+8(FP), CX
 	LOCK
 	CMPXCHGL	CX, 0(BX)
-	JZ 3(PC)
+	JZ 4(PC)
 	MOVL	$0, AX
+	MOVB	AX, ret+16(FP)
 	RET
 	MOVL	$1, AX
+	MOVB	AX, ret+16(FP)
 	RET
 
 // bool	runtime·cas64(uint64 *val, uint64 old, uint64 new)
@@ -568,17 +570,19 @@ TEXT runtime·cas(SB), NOSPLIT, $0-12
 //	} else {
 //		return 0;
 //	}
-TEXT runtime·cas64(SB), NOSPLIT, $0-24
-	MOVL	val+0(FP), BX
+TEXT runtime·cas64(SB), NOSPLIT, $0-25
+	MOVL	ptr+0(FP), BX
 	MOVQ	old+8(FP), AX
 	MOVQ	new+16(FP), CX
 	LOCK
 	CMPXCHGQ	CX, 0(BX)
 	JNZ	cas64_fail
 	MOVL	$1, AX
+	MOVB	AX, ret+24(FP)
 	RET
 cas64_fail:
 	MOVL	$0, AX
+	MOVB	AX, ret+24(FP)
 	RET
 
 // bool casp(void **val, void *old, void *new)
@@ -588,54 +592,60 @@ cas64_fail:
 //		return 1;
 //	} else
 //		return 0;
-TEXT runtime·casp(SB), NOSPLIT, $0-12
-	MOVL	val+0(FP), BX
+TEXT runtime·casp(SB), NOSPLIT, $0-17
+	MOVL	ptr+0(FP), BX
 	MOVL	old+4(FP), AX
 	MOVL	new+8(FP), CX
 	LOCK
 	CMPXCHGL	CX, 0(BX)
-	JZ 3(PC)
+	JZ 4(PC)
 	MOVL	$0, AX
+	MOVB	AX, ret+16(FP)
 	RET
 	MOVL	$1, AX
+	MOVB	AX, ret+16(FP)
 	RET
 
 // uint32 xadd(uint32 volatile *val, int32 delta)
 // Atomically:
 //	*val += delta;
 //	return *val;
-TEXT runtime·xadd(SB), NOSPLIT, $0-8
-	MOVL	val+0(FP), BX
+TEXT runtime·xadd(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), BX
 	MOVL	delta+4(FP), AX
 	MOVL	AX, CX
 	LOCK
 	XADDL	AX, 0(BX)
 	ADDL	CX, AX
+	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·xadd64(SB), NOSPLIT, $0-16
-	MOVL	val+0(FP), BX
+TEXT runtime·xadd64(SB), NOSPLIT, $0-24
+	MOVL	ptr+0(FP), BX
 	MOVQ	delta+8(FP), AX
 	MOVQ	AX, CX
 	LOCK
 	XADDQ	AX, 0(BX)
 	ADDQ	CX, AX
+	MOVQ	AX, ret+16(FP)
 	RET
 
-TEXT runtime·xchg(SB), NOSPLIT, $0-8
-	MOVL	val+0(FP), BX
+TEXT runtime·xchg(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), BX
 	MOVL	new+4(FP), AX
 	XCHGL	AX, 0(BX)
+	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·xchg64(SB), NOSPLIT, $0-16
-	MOVL	val+0(FP), BX
+TEXT runtime·xchg64(SB), NOSPLIT, $0-24
+	MOVL	ptr+0(FP), BX
 	MOVQ	new+8(FP), AX
 	XCHGQ	AX, 0(BX)
+	MOVQ	AX, ret+16(FP)
 	RET
 
 TEXT runtime·procyield(SB),NOSPLIT,$0-0
-	MOVL	val+0(FP), AX
+	MOVL	cycles+0(FP), AX
 again:
 	PAUSE
 	SUBL	$1, AX
@@ -661,7 +671,7 @@ TEXT runtime·atomicstore64(SB), NOSPLIT, $0-16
 	RET
 
 // void	runtime·atomicor8(byte volatile*, byte);
-TEXT runtime·atomicor8(SB), NOSPLIT, $0-8
+TEXT runtime·atomicor8(SB), NOSPLIT, $0-5
 	MOVL	ptr+0(FP), BX
 	MOVB	val+4(FP), AX
 	LOCK
@@ -673,9 +683,9 @@ TEXT runtime·atomicor8(SB), NOSPLIT, $0-8
 // 1. pop the caller
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
-TEXT runtime·jmpdefer(SB), NOSPLIT, $0-16
-	MOVL	fn+0(FP), DX
-	MOVL	callersp+4(FP), BX
+TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
+	MOVL	fv+0(FP), DX
+	MOVL	argp+4(FP), BX
 	LEAL	-8(BX), SP	// caller sp after CALL
 	SUBL	$5, (SP)	// return to CALL again
 	MOVL	0(DX), BX
@@ -695,7 +705,7 @@ TEXT runtime·cgocallback(SB),NOSPLIT,$0-12
 
 // void setg(G*); set g. for use by needm.
 // Not implemented.
-TEXT runtime·setg(SB), NOSPLIT, $0-8
+TEXT runtime·setg(SB), NOSPLIT, $0-4
 	MOVL	0, AX
 	RET
 
@@ -726,9 +736,10 @@ TEXT runtime·memclr(SB),NOSPLIT,$0-8
 	STOSB
 	RET
 
-TEXT runtime·getcallerpc(SB),NOSPLIT,$0-8
-	MOVL	x+0(FP),AX		// addr of first arg
+TEXT runtime·getcallerpc(SB),NOSPLIT,$0-12
+	MOVL	argp+0(FP),AX		// addr of first arg
 	MOVL	-8(AX),AX		// get calling pc
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·gogetcallerpc(SB),NOSPLIT,$0-12
@@ -737,14 +748,15 @@ TEXT runtime·gogetcallerpc(SB),NOSPLIT,$0-12
 	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·setcallerpc(SB),NOSPLIT,$0-16
-	MOVL	x+0(FP),AX		// addr of first arg
+TEXT runtime·setcallerpc(SB),NOSPLIT,$0-8
+	MOVL	argp+0(FP),AX		// addr of first arg
 	MOVL	pc+4(FP), BX		// pc to set
 	MOVQ	BX, -8(AX)		// set calling pc
 	RET
 
-TEXT runtime·getcallersp(SB),NOSPLIT,$0-8
-	MOVL	sp+0(FP), AX
+TEXT runtime·getcallersp(SB),NOSPLIT,$0-12
+	MOVL	argp+0(FP), AX
+	MOVL	AX, ret+8(FP)
 	RET
 
 // func gogetcallersp(p unsafe.Pointer) uintptr
@@ -758,6 +770,7 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-0
 	RDTSC
 	SHLQ	$32, DX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
@@ -784,16 +797,20 @@ GLOBL runtime·tls0(SB), $64
 // write the implementations. Can copy and adjust the ones
 // in asm_amd64.s when the time comes.
 
-TEXT runtime·aeshash(SB),NOSPLIT,$0-24
+TEXT runtime·aeshash(SB),NOSPLIT,$0-20
+	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT runtime·aeshashstr(SB),NOSPLIT,$0-24
+TEXT runtime·aeshashstr(SB),NOSPLIT,$0-20
+	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT runtime·aeshash32(SB),NOSPLIT,$0-24
+TEXT runtime·aeshash32(SB),NOSPLIT,$0-20
+	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT runtime·aeshash64(SB),NOSPLIT,$0-24
+TEXT runtime·aeshash64(SB),NOSPLIT,$0-20
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·memeq(SB),NOSPLIT,$0-17
@@ -925,12 +942,12 @@ equal:
 	RET
 
 TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
-	MOVL	s1+0(FP), SI
-	MOVL	s1+4(FP), BX
-	MOVL	s2+8(FP), DI
-	MOVL	s2+12(FP), DX
+	MOVL	s1_base+0(FP), SI
+	MOVL	s1_len+4(FP), BX
+	MOVL	s2_base+8(FP), DI
+	MOVL	s2_len+12(FP), DX
 	CALL	runtime·cmpbody(SB)
-	MOVL	AX, res+16(FP)
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT bytes·Compare(SB),NOSPLIT,$0-28
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 551ba0c88c..3ced211f89 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -468,7 +468,7 @@ TEXT runtime·lessstack(SB), NOSPLIT, $-4-0
 TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
 	MOVW	0(SP), LR
 	MOVW	$-4(LR), LR	// BL deferreturn
-	MOVW	fn+0(FP), R7
+	MOVW	fv+0(FP), R7
 	MOVW	argp+4(FP), SP
 	MOVW	$-4(SP), SP	// SP is 4 below argp, due to saved LR
 	MOVW	0(R7), R1
@@ -579,9 +579,6 @@ havem:
 	// the earlier calls.
 	//
 	// In the new goroutine, -8(SP) and -4(SP) are unused.
-	MOVW	fn+4(FP), R0
-	MOVW	frame+8(FP), R1
-	MOVW	framesize+12(FP), R2
 	MOVW	m_curg(R8), g
 	MOVW	(g_sched+gobuf_sp)(g), R4 // prepare stack as R4
 	MOVW	(g_sched+gobuf_pc)(g), R5
@@ -616,7 +613,7 @@ havem:
 	RET
 
 // void setg(G*); set g. for use by needm.
-TEXT runtime·setg(SB), NOSPLIT, $0-8
+TEXT runtime·setg(SB), NOSPLIT, $0-4
 	MOVW	gg+0(FP), g
 
 	// Save g to thread-local storage.
@@ -628,6 +625,7 @@ TEXT runtime·setg(SB), NOSPLIT, $0-8
 
 TEXT runtime·getcallerpc(SB),NOSPLIT,$-4-4
 	MOVW	0(SP), R0
+	MOVW	R0, ret+4(FP)
 	RET
 
 TEXT runtime·gogetcallerpc(SB),NOSPLIT,$-4-8
@@ -635,13 +633,14 @@ TEXT runtime·gogetcallerpc(SB),NOSPLIT,$-4-8
 	RET
 
 TEXT runtime·setcallerpc(SB),NOSPLIT,$-4-8
-	MOVW	x+4(FP), R0
+	MOVW	pc+4(FP), R0
 	MOVW	R0, 0(SP)
 	RET
 
 TEXT runtime·getcallersp(SB),NOSPLIT,$-4-4
 	MOVW	0(FP), R0
 	MOVW	$-4(R0), R0
+	MOVW	R0, ret+4(FP)
 	RET
 
 // func gogetcallersp(p unsafe.Pointer) uintptr
@@ -658,12 +657,6 @@ TEXT runtime·abort(SB),NOSPLIT,$-4-0
 	MOVW	$0, R0
 	MOVW	(R0), R1
 
-TEXT runtime·gocputicks(SB),NOSPLIT,$4-8
-	MOVW	$ret_lo+0(FP), R0
-	MOVW	R0, 4(R13)
-	BL      runtime·cputicks(SB)
-	RET
-
 // bool armcas(int32 *val, int32 old, int32 new)
 // Atomically:
 //	if(*val == old){
@@ -1264,3 +1257,7 @@ TEXT runtime·fastrand2(SB), NOSPLIT, $-4-4
 	MOVW	R0, m_fastrand(R1)
 	MOVW	R0, ret+0(FP)
 	RET
+
+TEXT runtime·gocputicks(SB), NOSPLIT, $0
+	B runtime·cputicks(SB)
+
diff --git a/src/pkg/runtime/memclr_plan9_amd64.s b/src/pkg/runtime/memclr_plan9_amd64.s
index 1fabcd5f09..64f3c992ef 100644
--- a/src/pkg/runtime/memclr_plan9_amd64.s
+++ b/src/pkg/runtime/memclr_plan9_amd64.s
@@ -6,8 +6,8 @@
 
 // void runtime·memclr(void*, uintptr)
 TEXT runtime·memclr(SB),NOSPLIT,$0-16
-	MOVQ	addr+0(FP), DI
-	MOVQ	count+8(FP), CX
+	MOVQ	ptr+0(FP), DI
+	MOVQ	n+8(FP), CX
 	MOVQ	CX, BX
 	ANDQ	$7, BX
 	SHRQ	$3, CX
diff --git a/src/pkg/runtime/memmove_nacl_amd64p32.s b/src/pkg/runtime/memmove_nacl_amd64p32.s
index 1b5733112c..ba47e85461 100644
--- a/src/pkg/runtime/memmove_nacl_amd64p32.s
+++ b/src/pkg/runtime/memmove_nacl_amd64p32.s
@@ -6,7 +6,7 @@
 
 TEXT runtime·memmove(SB), NOSPLIT, $0-12
 	MOVL	to+0(FP), DI
-	MOVL	fr+4(FP), SI
+	MOVL	from+4(FP), SI
 	MOVL	n+8(FP), BX
 
 	CMPL	SI, DI
diff --git a/src/pkg/runtime/memmove_plan9_386.s b/src/pkg/runtime/memmove_plan9_386.s
index 5ac5c27d40..4d5f7c6907 100644
--- a/src/pkg/runtime/memmove_plan9_386.s
+++ b/src/pkg/runtime/memmove_plan9_386.s
@@ -27,7 +27,7 @@
 
 TEXT runtime·memmove(SB), NOSPLIT, $0-12
 	MOVL	to+0(FP), DI
-	MOVL	fr+4(FP), SI
+	MOVL	from+4(FP), SI
 	MOVL	n+8(FP), BX
 
 	// REP instructions have a high startup cost, so we handle small sizes
diff --git a/src/pkg/runtime/memmove_plan9_amd64.s b/src/pkg/runtime/memmove_plan9_amd64.s
index 3664e45ae2..035d475ac8 100644
--- a/src/pkg/runtime/memmove_plan9_amd64.s
+++ b/src/pkg/runtime/memmove_plan9_amd64.s
@@ -29,7 +29,7 @@
 TEXT runtime·memmove(SB), NOSPLIT, $0-24
 
 	MOVQ	to+0(FP), DI
-	MOVQ	fr+8(FP), SI
+	MOVQ	from+8(FP), SI
 	MOVQ	n+16(FP), BX
 
 	// REP instructions have a high startup cost, so we handle small sizes
diff --git a/src/pkg/runtime/os_darwin.go b/src/pkg/runtime/os_darwin.go
new file mode 100644
index 0000000000..37ed55cf45
--- /dev/null
+++ b/src/pkg/runtime/os_darwin.go
@@ -0,0 +1,27 @@
+// 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 runtime
+
+import "unsafe"
+
+func bsdthread_create(stk, mm, gg, fn unsafe.Pointer) int32
+func bsdthread_register() int32
+func mach_msg_trap(h unsafe.Pointer, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32
+func mach_reply_port() uint32
+func mach_task_self() uint32
+func mach_thread_self() uint32
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+func sigprocmask(sig int32, new, old unsafe.Pointer)
+func sigaction(mode uint32, new, old unsafe.Pointer)
+func sigaltstack(new, old unsafe.Pointer)
+func sigtramp()
+func setitimer(mode int32, new, old unsafe.Pointer)
+func kqueue() int32
+func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
+func closeonexec(fd int32)
+func mach_semaphore_wait(sema uint32) int32
+func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
+func mach_semaphore_signal(sema uint32) int32
+func mach_semaphore_signal_all(sema uint32) int32
diff --git a/src/pkg/runtime/os_dragonfly.go b/src/pkg/runtime/os_dragonfly.go
new file mode 100644
index 0000000000..ec7ddef533
--- /dev/null
+++ b/src/pkg/runtime/os_dragonfly.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.
+
+package runtime
+
+import "unsafe"
+
+func lwp_create(param unsafe.Pointer) int32
+func sigaltstack(new, old unsafe.Pointer)
+func sigaction(sig int32, new, old unsafe.Pointer)
+func sigprocmask(new, old unsafe.Pointer)
+func setitimer(mode int32, new, old unsafe.Pointer)
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+func getrlimit(kind int32, limit unsafe.Pointer) int32
+func raise(sig int32)
+func kqueue() int32
+func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
+func closeonexec(fd int32)
+func sys_umtx_sleep(addr unsafe.Pointer, val, timeout int32) int32
+func sys_umtx_wakeup(addr unsafe.Pointer, val int32) int32
diff --git a/src/pkg/runtime/os_freebsd.go b/src/pkg/runtime/os_freebsd.go
new file mode 100644
index 0000000000..a973d3f76c
--- /dev/null
+++ b/src/pkg/runtime/os_freebsd.go
@@ -0,0 +1,20 @@
+// 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 runtime
+
+import "unsafe"
+
+func thr_new(param unsafe.Pointer, size int32)
+func sigaltstack(new, old unsafe.Pointer)
+func sigaction(sig int32, new, old unsafe.Pointer)
+func sigprocmask(new, old unsafe.Pointer)
+func setitimer(mode int32, new, old unsafe.Pointer)
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+func getrlimit(kind int32, limit unsafe.Pointer) int32
+func raise(sig int32)
+func kqueue() int32
+func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
+func closeonexec(fd int32)
+func sys_umtx_op(addr unsafe.Pointer, mode int32, val uint32, ptr2, ts unsafe.Pointer) int32
diff --git a/src/pkg/runtime/os_linux.go b/src/pkg/runtime/os_linux.go
new file mode 100644
index 0000000000..fc82382160
--- /dev/null
+++ b/src/pkg/runtime/os_linux.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 runtime
+
+import "unsafe"
+
+func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32
+func clone(flags int32, stk, mm, gg, fn unsafe.Pointer) int32
+func rt_sigaction(sig uintptr, new, old unsafe.Pointer, size uintptr) int32
+func sigaltstack(new, old unsafe.Pointer)
+func setitimer(mode int32, new, old unsafe.Pointer)
+func rtsigprocmask(sig int32, new, old unsafe.Pointer, size int32)
+func getrlimit(kind int32, limit unsafe.Pointer) int32
+func raise(sig int32)
+func epollcreate(size int32) int32
+func epollcreate1(flags int32) int32
+func epollctl(epfd, op, fd int32, ev unsafe.Pointer) int32
+func epollwait(epfd int32, ev unsafe.Pointer, nev, timeout int32) int32
+func closeonexec(fd int32)
+func sched_getaffinity(pid, len uintptr, buf *uintptr) int32
diff --git a/src/pkg/runtime/os_nacl.go b/src/pkg/runtime/os_nacl.go
new file mode 100644
index 0000000000..5b5bcf6a4a
--- /dev/null
+++ b/src/pkg/runtime/os_nacl.go
@@ -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.
+
+package runtime
+
+import "unsafe"
+
+func nacl_exception_stack(p unsafe.Pointer, size int32) int32
+func nacl_exception_handler(fn, arg unsafe.Pointer) int32
+func nacl_sem_create(flag int32) int32
+func nacl_sem_wait(sem int32) int32
+func nacl_sem_post(sem int32) int32
+func nacl_mutex_create(flag int32) int32
+func nacl_mutex_lock(mutex int32) int32
+func nacl_mutex_trylock(mutex int32) int32
+func nacl_mutex_unlock(mutex int32) int32
+func nacl_cond_create(flag int32) int32
+func nacl_cond_wait(cond, n int32) int32
+func nacl_cond_signal(cond int32) int32
+func nacl_cond_broadcast(cond int32) int32
+func nacl_cond_timed_wait_abs(cond, lock int32, ts unsafe.Pointer)
+func nacl_thread_create(fn, stk, tls, xx unsafe.Pointer) int32
+func nacl_nanosleep(ts, extra unsafe.Pointer) int32
diff --git a/src/pkg/runtime/os_netbsd.go b/src/pkg/runtime/os_netbsd.go
new file mode 100644
index 0000000000..5cdf52211d
--- /dev/null
+++ b/src/pkg/runtime/os_netbsd.go
@@ -0,0 +1,23 @@
+// 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 runtime
+
+import "unsafe"
+
+func setitimer(mode int32, new, old unsafe.Pointer)
+func sigaction(sig int32, new, old unsafe.Pointer)
+func sigaltstack(new, old unsafe.Pointer)
+func sigprocmask(mode int32, new, old unsafe.Pointer)
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+func lwp_tramp()
+func raise(sig int32)
+func kqueue() int32
+func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
+func closeonexec(fd int32)
+func getcontext(ctxt unsafe.Pointer)
+func lwp_create(ctxt unsafe.Pointer, flags uintptr, lwpid unsafe.Pointer) int32
+func lwp_park(abstime unsafe.Pointer, unpark int32, hint, unparkhint unsafe.Pointer) int32
+func lwp_unpark(lwp int32, hint unsafe.Pointer) int32
+func lwp_self() int32
diff --git a/src/pkg/runtime/os_openbsd.go b/src/pkg/runtime/os_openbsd.go
new file mode 100644
index 0000000000..6bb6baa62c
--- /dev/null
+++ b/src/pkg/runtime/os_openbsd.go
@@ -0,0 +1,20 @@
+// 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 runtime
+
+import "unsafe"
+
+func setitimer(mode int32, new, old unsafe.Pointer)
+func sigaction(sig int32, new, old unsafe.Pointer)
+func sigaltstack(new, old unsafe.Pointer)
+func sigprocmask(mode int32, new uint32) uint32
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+func raise(sig int32)
+func kqueue() int32
+func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
+func closeonexec(fd int32)
+func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int64
+func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
+func thrwakeup(ident unsafe.Pointer, n int32) int32
diff --git a/src/pkg/runtime/os_plan9.go b/src/pkg/runtime/os_plan9.go
new file mode 100644
index 0000000000..a50211a77b
--- /dev/null
+++ b/src/pkg/runtime/os_plan9.go
@@ -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.
+
+package runtime
+
+import "unsafe"
+
+func pread(fd int32, buf unsafe.Pointer, nbytes int32, offset int64) int32
+func pwrite(fd int32, buf unsafe.Pointer, nbytes int32, offset int64) int32
+func seek(fd int32, offset int64, whence int32) int64
+func exits(msg *byte)
+func brk_(addr unsafe.Pointer) uintptr
+func sleep(ms int32) int32
+func rfork(flags int32, stk, mm, gg, fn unsafe.Pointer) int32
+func plan9_semacquire(addr *uint32, block int32) int32
+func plan9_tsemacquire(addr *uint32, ms int32) int32
+func plan9_semrelease(addr *uint32, count int32) int32
+func notify(fn unsafe.Pointer) int32
+func noted(mode int32) int32
+func nsec(*int64) int64
+func sigtramp(ureg, msg unsafe.Pointer)
+func setfpmasks()
+func errstr() string
diff --git a/src/pkg/runtime/os_solaris.go b/src/pkg/runtime/os_solaris.go
new file mode 100644
index 0000000000..72528c7997
--- /dev/null
+++ b/src/pkg/runtime/os_solaris.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 runtime
+
+import "unsafe"
+
+func setitimer(mode int32, new, old unsafe.Pointer)
+func sigaction(sig int32, new, old unsafe.Pointer)
+func sigaltstack(new, old unsafe.Pointer)
+func sigprocmask(mode int32, new, old unsafe.Pointer)
+func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+func getrlimit(kind int32, limit unsafe.Pointer)
+func asmsysvicall6(fn unsafe.Pointer)
+func miniterrno(fn unsafe.Pointer)
+func raise(sig int32)
+func getcontext(ctxt unsafe.Pointer)
+func tstart_sysvicall(mm unsafe.Pointer) uint32
+func nanotime1() int64
+func usleep1(usec uint32)
+func osyield1()
diff --git a/src/pkg/runtime/os_windows.go b/src/pkg/runtime/os_windows.go
new file mode 100644
index 0000000000..188ca3219e
--- /dev/null
+++ b/src/pkg/runtime/os_windows.go
@@ -0,0 +1,12 @@
+// 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 runtime
+
+import "unsafe"
+
+func asmstdcall(fn unsafe.Pointer)
+func getlasterror() uint32
+func setlasterror(err uint32)
+func usleep1(usec uint32)
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index e3e14caab8..5f396aa009 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -218,3 +218,48 @@ func exitsyscall()
 
 func traceback(pc, sp, lr uintptr, gp *g)
 func tracebackothers(gp *g)
+
+func cgocallback(fn, frame unsafe.Pointer, framesize uintptr)
+func gogo(buf *gobuf)
+func gosave(buf *gobuf)
+func open(name *byte, mode, perm int32) int32
+func read(fd int32, p unsafe.Pointer, n int32) int32
+func write(fd uintptr, p unsafe.Pointer, n int32) int32
+func close(fd int32) int32
+func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
+func jmpdefer(fv *funcval, argp unsafe.Pointer)
+func exit1(code int32)
+func asminit()
+func getcallersp(argp unsafe.Pointer) uintptr
+func cas(ptr *uint32, old, new uint32) bool
+func cas64(ptr *uint64, old, new uint64) bool
+func casp(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
+func xadd(ptr *uint32, delta int32) uint32
+func xadd64(ptr *uint64, delta int64) uint64
+func xchg(ptr *uint32, new uint32) uint32
+func xchg64(ptr *uint64, new uint64) uint64
+func xchgp(ptr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
+func atomicstore(ptr *uint32, val uint32)
+func atomicstore64(ptr *uint64, val uint64)
+func atomicstorep(ptr *unsafe.Pointer, val unsafe.Pointer)
+func atomicload(ptr *uint32) uint32
+func atomicload64(ptr *uint64) uint64
+func atomicloadp(ptr *unsafe.Pointer) unsafe.Pointer
+func atomicor8(ptr *uint8, val uint8)
+func setg(gg *g)
+func exit(code int32)
+func breakpoint()
+func asmcgocall(fn, arg unsafe.Pointer)
+func nanotime() int64
+func usleep(usec uint32)
+func cputicks() int64
+func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer
+func munmap(addr unsafe.Pointer, n uintptr)
+func madvise(addr unsafe.Pointer, n uintptr, flags int32)
+func setcallerpc(argp unsafe.Pointer, pc uintptr)
+func getcallerpc(argp unsafe.Pointer) uintptr
+func newstackcall(fv *funcval, addr unsafe.Pointer, size uint32)
+func procyield(cycles uint32)
+func osyield()
+func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
+func cmpstring(s1, s2 string) int
diff --git a/src/pkg/runtime/sys_darwin_386.s b/src/pkg/runtime/sys_darwin_386.s
index a702d9bfa1..1ec694db68 100644
--- a/src/pkg/runtime/sys_darwin_386.s
+++ b/src/pkg/runtime/sys_darwin_386.s
@@ -28,21 +28,25 @@ TEXT runtime·exit1(SB),NOSPLIT,$0
 TEXT runtime·open(SB),NOSPLIT,$0
 	MOVL	$5, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVL	$6, AX
 	INT	$0x80
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
 	MOVL	$3, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
 	MOVL	$4, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$16
@@ -59,6 +63,7 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 TEXT runtime·mmap(SB),NOSPLIT,$0
 	MOVL	$197, AX
 	INT	$0x80
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
@@ -206,9 +211,8 @@ TEXT time·now(SB),NOSPLIT,$0
 // void nanotime(int64 *nsec)
 TEXT runtime·nanotime(SB),NOSPLIT,$0
 	CALL	runtime·now(SB)
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
@@ -315,7 +319,7 @@ TEXT runtime·usleep(SB),NOSPLIT,$32
 TEXT runtime·bsdthread_create(SB),NOSPLIT,$32
 	MOVL	$360, AX
 	// 0(SP) is where the caller PC would be; kernel skips it
-	MOVL	func+12(FP), BX
+	MOVL	fn+12(FP), BX
 	MOVL	BX, 4(SP)	// func
 	MOVL	mm+4(FP), BX
 	MOVL	BX, 8(SP)	// arg
@@ -325,10 +329,12 @@ TEXT runtime·bsdthread_create(SB),NOSPLIT,$32
 	MOVL	BX, 16(SP)	// pthread
 	MOVL	$0x1000000, 20(SP)	// flags = PTHREAD_START_CUSTOM
 	INT	$0x80
-	JAE	3(PC)
+	JAE	4(PC)
 	NEGL	AX
+	MOVL	AX, ret+16(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+16(FP)
 	RET
 
 // The thread that bsdthread_create creates starts executing here,
@@ -382,10 +388,12 @@ TEXT runtime·bsdthread_register(SB),NOSPLIT,$40
 	MOVL	$0, 20(SP)	// targetconc_ptr
 	MOVL	$0, 24(SP)	// dispatchqueue_offset
 	INT	$0x80
-	JAE	3(PC)
+	JAE	4(PC)
 	NEGL	AX
+	MOVL	AX, ret+0(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // Invoke Mach system call.
@@ -408,16 +416,19 @@ TEXT runtime·sysenter(SB),NOSPLIT,$0
 TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0
 	MOVL	$-31, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+28(FP)
 	RET
 
 TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
 	MOVL	$-26, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+0(FP)
 	RET
 
 TEXT runtime·mach_task_self(SB),NOSPLIT,$0
 	MOVL	$-28, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+0(FP)
 	RET
 
 // Mach provides trap versions of the semaphore ops,
@@ -427,24 +438,28 @@ TEXT runtime·mach_task_self(SB),NOSPLIT,$0
 TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
 	MOVL	$-36, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+4(FP)
 	RET
 
 // uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
 TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
 	MOVL	$-38, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+12(FP)
 	RET
 
 // uint32 mach_semaphore_signal(uint32)
 TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
 	MOVL	$-33, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+4(FP)
 	RET
 
 // uint32 mach_semaphore_signal_all(uint32)
 TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
 	MOVL	$-34, AX
 	CALL	runtime·sysenter(SB)
+	MOVL	AX, ret+4(FP)
 	RET
 
 // setldt(int entry, int address, int limit)
@@ -486,10 +501,12 @@ TEXT runtime·setldt(SB),NOSPLIT,$32
 TEXT runtime·sysctl(SB),NOSPLIT,$0
 	MOVL	$202, AX
 	INT	$0x80
-	JAE	3(PC)
+	JAE	4(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·kqueue(void);
@@ -498,6 +515,7 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
@@ -506,6 +524,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·closeonexec(int32 fd);
diff --git a/src/pkg/runtime/sys_darwin_amd64.s b/src/pkg/runtime/sys_darwin_amd64.s
index 23995db7a8..5f0d9dfa1d 100644
--- a/src/pkg/runtime/sys_darwin_amd64.s
+++ b/src/pkg/runtime/sys_darwin_amd64.s
@@ -16,7 +16,7 @@
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 exit status
+	MOVL	code+0(FP), DI		// arg 1 exit status
 	MOVL	$(0x2000000+1), AX	// syscall entry
 	SYSCALL
 	MOVL	$0xf1, 0xf1  // crash
@@ -25,40 +25,44 @@ TEXT runtime·exit(SB),NOSPLIT,$0
 // Exit this OS thread (like pthread_exit, which eventually
 // calls __bsdthread_terminate).
 TEXT runtime·exit1(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 exit status
+	MOVL	code+0(FP), DI		// arg 1 exit status
 	MOVL	$(0x2000000+361), AX	// syscall entry
 	SYSCALL
 	MOVL	$0xf1, 0xf1  // crash
 	RET
 
 TEXT runtime·open(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 pathname
-	MOVL	16(SP), SI		// arg 2 flags
-	MOVL	20(SP), DX		// arg 3 mode
+	MOVQ	name+0(FP), DI		// arg 1 pathname
+	MOVL	mode+8(FP), SI		// arg 2 flags
+	MOVL	perm+12(FP), DX		// arg 3 mode
 	MOVL	$(0x2000000+5), AX	// syscall entry
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 fd
+	MOVL	fd+0(FP), DI		// arg 1 fd
 	MOVL	$(0x2000000+6), AX	// syscall entry
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVL	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$(0x2000000+3), AX	// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVQ	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$(0x2000000+4), AX	// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$24
@@ -72,17 +76,17 @@ TEXT runtime·raise(SB),NOSPLIT,$24
 	RET
 
 TEXT runtime·setitimer(SB), NOSPLIT, $0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVL	mode+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
 	MOVL	$(0x2000000+83), AX	// syscall entry
 	SYSCALL
 	RET
 
 TEXT runtime·madvise(SB), NOSPLIT, $0
-	MOVQ	8(SP), DI		// arg 1 addr
-	MOVQ	16(SP), SI		// arg 2 len
-	MOVL	24(SP), DX		// arg 3 advice
+	MOVQ	addr+0(FP), DI		// arg 1 addr
+	MOVQ	n+8(FP), SI		// arg 2 len
+	MOVL	flags+16(FP), DX		// arg 3 advice
 	MOVL	$(0x2000000+75), AX	// syscall entry madvise
 	SYSCALL
 	// ignore failure - maybe pages are locked
@@ -99,8 +103,7 @@ TEXT runtime·madvise(SB), NOSPLIT, $0
 #define	gtod_ns_base	0x70
 #define	gtod_sec_base	0x78
 
-// int64 nanotime(void)
-TEXT runtime·nanotime(SB), NOSPLIT, $32
+TEXT nanotime<>(SB), NOSPLIT, $32
 	MOVQ	$0x7fffffe00000, BP	/* comm page base */
 	// Loop trying to take a consistent snapshot
 	// of the time parameters.
@@ -149,9 +152,14 @@ systime:
 	ADDQ	DX, AX
 	RET
 
+TEXT runtime·nanotime(SB),NOSPLIT,$0-8
+	CALL	nanotime<>(SB)
+	MOVQ	AX, ret+0(FP)
+	RET
+
 // func now() (sec int64, nsec int32)
-TEXT time·now(SB),NOSPLIT,$0
-	CALL	runtime·nanotime(SB)
+TEXT time·now(SB),NOSPLIT,$8
+	CALL	nanotime<>(SB)
 
 	// generated code for
 	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
@@ -169,9 +177,9 @@ TEXT time·now(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVL	sig+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
 	MOVL	$(0x2000000+329), AX  // pthread_sigmask (on OS X, sigprocmask==entire process)
 	SYSCALL
 	JCC	2(PC)
@@ -179,11 +187,11 @@ TEXT runtime·sigprocmask(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·sigaction(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 sig
-	MOVQ	16(SP), SI		// arg 2 act
-	MOVQ	24(SP), DX		// arg 3 oact
-	MOVQ	24(SP), CX		// arg 3 oact
-	MOVQ	24(SP), R10		// arg 3 oact
+	MOVL	mode+0(FP), DI		// arg 1 sig
+	MOVQ	new+8(FP), SI		// arg 2 act
+	MOVQ	old+16(FP), DX		// arg 3 oact
+	MOVQ	old+16(FP), CX		// arg 3 oact
+	MOVQ	old+16(FP), R10		// arg 3 oact
 	MOVL	$(0x2000000+46), AX	// syscall entry
 	SYSCALL
 	JCC	2(PC)
@@ -234,19 +242,20 @@ sigtramp_ret:
 	INT $3	// not reached
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 addr
-	MOVQ	16(SP), SI		// arg 2 len
-	MOVL	24(SP), DX		// arg 3 prot
-	MOVL	28(SP), R10		// arg 4 flags
-	MOVL	32(SP), R8		// arg 5 fid
-	MOVL	36(SP), R9		// arg 6 offset
+	MOVQ	addr+0(FP), DI		// arg 1 addr
+	MOVQ	n+8(FP), SI		// arg 2 len
+	MOVL	prot+16(FP), DX		// arg 3 prot
+	MOVL	flags+20(FP), R10		// arg 4 flags
+	MOVL	fd+24(FP), R8		// arg 5 fid
+	MOVL	off+28(FP), R9		// arg 6 offset
 	MOVL	$(0x2000000+197), AX	// syscall entry
 	SYSCALL
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 addr
-	MOVQ	16(SP), SI		// arg 2 len
+	MOVQ	addr+0(FP), DI		// arg 1 addr
+	MOVQ	n+8(FP), SI		// arg 2 len
 	MOVL	$(0x2000000+73), AX	// syscall entry
 	SYSCALL
 	JCC	2(PC)
@@ -293,10 +302,12 @@ TEXT runtime·bsdthread_create(SB),NOSPLIT,$0
 	MOVQ	$0, R9	// paranoia
 	MOVQ	$(0x2000000+360), AX	// bsdthread_create
 	SYSCALL
-	JCC 3(PC)
+	JCC 4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+32(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+32(FP)
 	RET
 
 // The thread that bsdthread_create creates starts executing here,
@@ -346,42 +357,48 @@ TEXT runtime·bsdthread_register(SB),NOSPLIT,$0
 	MOVQ	$0, R9	// dispatchqueue_offset
 	MOVQ	$(0x2000000+366), AX	// bsdthread_register
 	SYSCALL
-	JCC 3(PC)
+	JCC 4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+0(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // Mach system calls use 0x1000000 instead of the BSD's 0x2000000.
 
 // uint32 mach_msg_trap(void*, uint32, uint32, uint32, uint32, uint32, uint32)
 TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVL	16(SP), SI
-	MOVL	20(SP), DX
-	MOVL	24(SP), R10
-	MOVL	28(SP), R8
-	MOVL	32(SP), R9
-	MOVL	36(SP), R11
+	MOVQ	h+0(FP), DI
+	MOVL	op+8(FP), SI
+	MOVL	send_size+12(FP), DX
+	MOVL	rcv_size+16(FP), R10
+	MOVL	rcv_name+20(FP), R8
+	MOVL	timeout+24(FP), R9
+	MOVL	notify+28(FP), R11
 	PUSHQ	R11	// seventh arg, on stack
 	MOVL	$(0x1000000+31), AX	// mach_msg_trap
 	SYSCALL
 	POPQ	R11
+	MOVL	AX, ret+32(FP)
 	RET
 
 TEXT runtime·mach_task_self(SB),NOSPLIT,$0
 	MOVL	$(0x1000000+28), AX	// task_self_trap
 	SYSCALL
+	MOVL	AX, ret+0(FP)
 	RET
 
 TEXT runtime·mach_thread_self(SB),NOSPLIT,$0
 	MOVL	$(0x1000000+27), AX	// thread_self_trap
 	SYSCALL
+	MOVL	AX, ret+0(FP)
 	RET
 
 TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
 	MOVL	$(0x1000000+26), AX	// mach_reply_port
 	SYSCALL
+	MOVL	AX, ret+0(FP)
 	RET
 
 // Mach provides trap versions of the semaphore ops,
@@ -389,32 +406,36 @@ TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
 
 // uint32 mach_semaphore_wait(uint32)
 TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
+	MOVL	sema+0(FP), DI
 	MOVL	$(0x1000000+36), AX	// semaphore_wait_trap
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 // uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
 TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVL	12(SP), SI
-	MOVL	16(SP), DX
+	MOVL	sema+0(FP), DI
+	MOVL	sec+4(FP), SI
+	MOVL	nsec+8(FP), DX
 	MOVL	$(0x1000000+38), AX	// semaphore_timedwait_trap
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 // uint32 mach_semaphore_signal(uint32)
 TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
+	MOVL	sema+0(FP), DI
 	MOVL	$(0x1000000+33), AX	// semaphore_signal_trap
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 // uint32 mach_semaphore_signal_all(uint32)
 TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
+	MOVL	sema+0(FP), DI
 	MOVL	$(0x1000000+34), AX	// semaphore_signal_all_trap
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 // set tls base to DI
@@ -431,18 +452,20 @@ TEXT runtime·settls(SB),NOSPLIT,$32
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVL	16(SP), SI
-	MOVQ	24(SP), DX
-	MOVQ	32(SP), R10
-	MOVQ	40(SP), R8
-	MOVQ	48(SP), R9
+	MOVQ	mib+0(FP), DI
+	MOVL	miblen+8(FP), SI
+	MOVQ	out+16(FP), DX
+	MOVQ	size+24(FP), R10
+	MOVQ	dst+32(FP), R8
+	MOVQ	ndst+40(FP), R9
 	MOVL	$(0x2000000+202), AX	// syscall entry
 	SYSCALL
-	JCC 3(PC)
+	JCC 4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // int32 runtime·kqueue(void);
@@ -454,25 +477,27 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
 TEXT runtime·kevent(SB),NOSPLIT,$0
-	MOVL    8(SP), DI
-	MOVQ    16(SP), SI
-	MOVL    24(SP), DX
-	MOVQ    32(SP), R10
-	MOVL    40(SP), R8
-	MOVQ    48(SP), R9
+	MOVL    fd+0(FP), DI
+	MOVQ    ev1+8(FP), SI
+	MOVL    nev1+16(FP), DX
+	MOVQ    ev2+24(FP), R10
+	MOVL    nev2+32(FP), R8
+	MOVQ    ts+40(FP), R9
 	MOVL	$(0x2000000+363), AX
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd);
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVL    8(SP), DI  // fd
+	MOVL    fd+0(FP), DI  // fd
 	MOVQ    $2, SI  // F_SETFD
 	MOVQ    $1, DX  // FD_CLOEXEC
 	MOVL	$(0x2000000+92), AX  // fcntl
diff --git a/src/pkg/runtime/sys_dragonfly_386.s b/src/pkg/runtime/sys_dragonfly_386.s
index 0b8d219112..bd8c8d8f6d 100644
--- a/src/pkg/runtime/sys_dragonfly_386.s
+++ b/src/pkg/runtime/sys_dragonfly_386.s
@@ -14,6 +14,7 @@ TEXT runtime·sys_umtx_sleep(SB),NOSPLIT,$-4
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·sys_umtx_wakeup(SB),NOSPLIT,$-4
@@ -21,11 +22,13 @@ TEXT runtime·sys_umtx_wakeup(SB),NOSPLIT,$-4
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·lwp_create(SB),NOSPLIT,$-4
 	MOVL	$495, AX		// lwp_create
 	INT	$0x80
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·lwp_start(SB),NOSPLIT,$0
@@ -81,26 +84,31 @@ TEXT runtime·exit1(SB),NOSPLIT,$16
 TEXT runtime·open(SB),NOSPLIT,$-4
 	MOVL	$5, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-4
 	MOVL	$6, AX
 	INT	$0x80
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-4
 	MOVL	$3, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-4
 	MOVL	$4, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$-4
 	MOVL	$194, AX
 	INT	$0x80
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$16
@@ -116,7 +124,7 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$36
-	LEAL	arg0+0(FP), SI
+	LEAL	addr+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - addr
@@ -131,6 +139,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$36
 	STOSL
 	MOVL	$197, AX		// sys_mmap
 	INT	$0x80
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$-4
@@ -185,9 +194,8 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	ADDL	BX, AX
 	ADCL	$0, DX
 
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 
@@ -302,7 +310,7 @@ TEXT runtime·settls(SB),NOSPLIT,$24
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$28
-	LEAL	arg0+0(FP), SI
+	LEAL	mib+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - name
@@ -313,10 +321,12 @@ TEXT runtime·sysctl(SB),NOSPLIT,$28
 	MOVSL				// arg 6 - newlen
 	MOVL	$202, AX		// sys___sysctl
 	INT	$0x80
-	JCC	3(PC)
+	JCC	4(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$-4
@@ -327,9 +337,9 @@ TEXT runtime·osyield(SB),NOSPLIT,$-4
 TEXT runtime·sigprocmask(SB),NOSPLIT,$16
 	MOVL	$0, 0(SP)		// syscall gap
 	MOVL	$3, 4(SP)		// arg 1 - how (SIG_SETMASK)
-	MOVL	args+0(FP), AX
+	MOVL	new+0(FP), AX
 	MOVL	AX, 8(SP)		// arg 2 - set
-	MOVL	args+4(FP), AX
+	MOVL	old+4(FP), AX
 	MOVL	AX, 12(SP)		// arg 3 - oset
 	MOVL	$340, AX		// sys_sigprocmask
 	INT	$0x80
@@ -343,6 +353,7 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
@@ -351,6 +362,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·closeonexec(int32 fd);
diff --git a/src/pkg/runtime/sys_dragonfly_amd64.s b/src/pkg/runtime/sys_dragonfly_amd64.s
index 25d2be3ad8..1c279df9c8 100644
--- a/src/pkg/runtime/sys_dragonfly_amd64.s
+++ b/src/pkg/runtime/sys_dragonfly_amd64.s
@@ -10,28 +10,31 @@
 #include "../../cmd/ld/textflag.h"
 	
 TEXT runtime·sys_umtx_sleep(SB),NOSPLIT,$0
-	MOVQ 8(SP), DI		// arg 1 - ptr
-	MOVL 16(SP), SI		// arg 2 - value
-	MOVL 20(SP), DX		// arg 3 - timeout
+	MOVQ addr+0(FP), DI		// arg 1 - ptr
+	MOVL val+8(FP), SI		// arg 2 - value
+	MOVL timeout+12(FP), DX		// arg 3 - timeout
 	MOVL $469, AX		// umtx_sleep
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·sys_umtx_wakeup(SB),NOSPLIT,$0
-	MOVQ 8(SP), DI		// arg 1 - ptr
-	MOVL 16(SP), SI		// arg 2 - count
+	MOVQ addr+0(FP), DI		// arg 1 - ptr
+	MOVL val+8(FP), SI		// arg 2 - count
 	MOVL $470, AX		// umtx_wakeup
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·lwp_create(SB),NOSPLIT,$0
-	MOVQ 8(SP), DI		// arg 1 - params
+	MOVQ param+0(FP), DI		// arg 1 - params
 	MOVL $495, AX		// lwp_create
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·lwp_start(SB),NOSPLIT,$0
@@ -54,54 +57,59 @@ TEXT runtime·lwp_start(SB),NOSPLIT,$0
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 exit status
+	MOVL	code+0(FP), DI		// arg 1 exit status
 	MOVL	$1, AX
 	SYSCALL
 	MOVL	$0xf1, 0xf1  // crash
 	RET
 
 TEXT runtime·exit1(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 exit status
+	MOVL	code+0(FP), DI		// arg 1 exit status
 	MOVL	$431, AX
 	SYSCALL
 	MOVL	$0xf1, 0xf1  // crash
 	RET
 
 TEXT runtime·open(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 pathname
-	MOVL	16(SP), SI		// arg 2 flags
-	MOVL	20(SP), DX		// arg 3 mode
+	MOVQ	name+0(FP), DI		// arg 1 pathname
+	MOVL	mode+8(FP), SI		// arg 2 flags
+	MOVL	perm+12(FP), DX		// arg 3 mode
 	MOVL	$5, AX
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
+	MOVL	fd+0(FP), DI		// arg 1 fd
 	MOVL	$6, AX
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVL	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$3, AX
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVQ	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$4, AX
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
+	MOVL	kind+0(FP), DI
+	MOVQ	limit+8(FP), SI
 	MOVL	$194, AX
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$16
@@ -115,9 +123,9 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·setitimer(SB), NOSPLIT, $-8
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVL	mode+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
 	MOVL	$83, AX
 	SYSCALL
 	RET
@@ -148,12 +156,13 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·sigaction(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 sig
-	MOVQ	16(SP), SI		// arg 2 act
-	MOVQ	24(SP), DX		// arg 3 oact
+	MOVL	sig+0(FP), DI		// arg 1 sig
+	MOVQ	new+8(FP), SI		// arg 2 act
+	MOVQ	old+16(FP), DX		// arg 3 oact
 	MOVL	$342, AX
 	SYSCALL
 	JCC	2(PC)
@@ -194,23 +203,24 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$64
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - addr
-	MOVQ	16(SP), SI		// arg 2 - len
-	MOVL	24(SP), DX		// arg 3 - prot
-	MOVL	28(SP), R10		// arg 4 - flags
-	MOVL	32(SP), R8		// arg 5 - fd
-	MOVL	36(SP), R9
+	MOVQ	addr+0(FP), DI		// arg 1 - addr
+	MOVQ	n+8(FP), SI		// arg 2 - len
+	MOVL	prot+16(FP), DX		// arg 3 - prot
+	MOVL	flags+20(FP), R10		// arg 4 - flags
+	MOVL	fd+24(FP), R8		// arg 5 - fd
+	MOVL	off+28(FP), R9
 	SUBQ	$16, SP
 	MOVQ	R9, 8(SP)		// arg 7 - offset (passed on stack)
 	MOVQ	$0, R9			// arg 6 - pad
 	MOVL	$197, AX
 	SYSCALL
 	ADDQ	$16, SP
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 addr
-	MOVQ	16(SP), SI		// arg 2 len
+	MOVQ	addr+0(FP), DI		// arg 1 addr
+	MOVQ	n+8(FP), SI		// arg 2 len
 	MOVL	$73, AX
 	SYSCALL
 	JCC	2(PC)
@@ -218,9 +228,9 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVQ	addr+0(FP), DI
+	MOVQ	n+8(FP), SI
+	MOVL	flags+16(FP), DX
 	MOVQ	$75, AX	// madvise
 	SYSCALL
 	// ignore failure - maybe pages are locked
@@ -266,18 +276,20 @@ TEXT runtime·settls(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - name
-	MOVL	16(SP), SI		// arg 2 - namelen
-	MOVQ	24(SP), DX		// arg 3 - oldp
-	MOVQ	32(SP), R10		// arg 4 - oldlenp
-	MOVQ	40(SP), R8		// arg 5 - newp
-	MOVQ	48(SP), R9		// arg 6 - newlen
+	MOVQ	mib+0(FP), DI		// arg 1 - name
+	MOVL	miblen+8(FP), SI		// arg 2 - namelen
+	MOVQ	out+16(FP), DX		// arg 3 - oldp
+	MOVQ	size+24(FP), R10		// arg 4 - oldlenp
+	MOVQ	dst+32(FP), R8		// arg 5 - newp
+	MOVQ	ndst+40(FP), R9		// arg 6 - newlen
 	MOVQ	$202, AX		// sys___sysctl
 	SYSCALL
-	JCC 3(PC)
+	JCC 4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$-4
@@ -287,8 +299,8 @@ TEXT runtime·osyield(SB),NOSPLIT,$-4
 
 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
 	MOVL	$3, DI			// arg 1 - how (SIG_SETMASK)
-	MOVQ	8(SP), SI		// arg 2 - set
-	MOVQ	16(SP), DX		// arg 3 - oset
+	MOVQ	new+0(FP), SI		// arg 2 - set
+	MOVQ	old+8(FP), DX		// arg 3 - oset
 	MOVL	$340, AX		// sys_sigprocmask
 	SYSCALL
 	JAE	2(PC)
@@ -304,25 +316,27 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
 TEXT runtime·kevent(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
-	MOVQ	32(SP), R10
-	MOVL	40(SP), R8
-	MOVQ	48(SP), R9
+	MOVL	fd+0(FP), DI
+	MOVQ	ev1+8(FP), SI
+	MOVL	nev1+16(FP), DX
+	MOVQ	ev2+24(FP), R10
+	MOVL	nev2+32(FP), R8
+	MOVQ	ts+40(FP), R9
 	MOVL	$363, AX
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd);
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVL	8(SP), DI	// fd
+	MOVL	fd+0(FP), DI	// fd
 	MOVQ	$2, SI		// F_SETFD
 	MOVQ	$1, DX		// FD_CLOEXEC
 	MOVL	$92, AX		// fcntl
diff --git a/src/pkg/runtime/sys_freebsd_386.s b/src/pkg/runtime/sys_freebsd_386.s
index d2ce25f994..929572f073 100644
--- a/src/pkg/runtime/sys_freebsd_386.s
+++ b/src/pkg/runtime/sys_freebsd_386.s
@@ -12,6 +12,7 @@
 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$-4
 	MOVL	$454, AX
 	INT	$0x80
+	MOVL	AX, ret+20(FP)
 	RET
 
 TEXT runtime·thr_new(SB),NOSPLIT,$-4
@@ -60,26 +61,31 @@ TEXT runtime·exit1(SB),NOSPLIT,$-4
 TEXT runtime·open(SB),NOSPLIT,$-4
 	MOVL	$5, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-4
 	MOVL	$6, AX
 	INT	$0x80
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-4
 	MOVL	$3, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-4
 	MOVL	$4, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$-4
 	MOVL	$194, AX
 	INT	$0x80
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$16
@@ -98,7 +104,7 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$32
-	LEAL arg0+0(FP), SI
+	LEAL addr+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL
@@ -111,6 +117,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$32
 	STOSL
 	MOVL	$477, AX
 	INT	$0x80
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$-4
@@ -167,9 +174,8 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	ADDL	BX, AX
 	ADCL	$0, DX
 
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 
@@ -314,7 +320,7 @@ TEXT runtime·i386_set_ldt(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$28
-	LEAL	arg0+0(FP), SI
+	LEAL	mib+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - name
@@ -325,10 +331,12 @@ TEXT runtime·sysctl(SB),NOSPLIT,$28
 	MOVSL				// arg 6 - newlen
 	MOVL	$202, AX		// sys___sysctl
 	INT	$0x80
-	JAE	3(PC)
+	JAE	4(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$-4
@@ -339,9 +347,9 @@ TEXT runtime·osyield(SB),NOSPLIT,$-4
 TEXT runtime·sigprocmask(SB),NOSPLIT,$16
 	MOVL	$0, 0(SP)		// syscall gap
 	MOVL	$3, 4(SP)		// arg 1 - how (SIG_SETMASK)
-	MOVL	args+0(FP), AX
+	MOVL	new+0(FP), AX
 	MOVL	AX, 8(SP)		// arg 2 - set
-	MOVL	args+4(FP), AX
+	MOVL	old+4(FP), AX
 	MOVL	AX, 12(SP)		// arg 3 - oset
 	MOVL	$340, AX		// sys_sigprocmask
 	INT	$0x80
@@ -355,6 +363,7 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
@@ -363,6 +372,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·closeonexec(int32 fd);
diff --git a/src/pkg/runtime/sys_freebsd_amd64.s b/src/pkg/runtime/sys_freebsd_amd64.s
index 2c6e33590f..f1198541dc 100644
--- a/src/pkg/runtime/sys_freebsd_amd64.s
+++ b/src/pkg/runtime/sys_freebsd_amd64.s
@@ -35,18 +35,19 @@
 #define SYSCALL MOVQ R10, CX; INT $0x80
 	
 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
-	MOVQ 8(SP), DI
-	MOVL 16(SP), SI
-	MOVL 20(SP), DX
-	MOVQ 24(SP), R10
-	MOVQ 32(SP), R8
+	MOVQ addr+0(FP), DI
+	MOVL mode+8(FP), SI
+	MOVL val+12(FP), DX
+	MOVQ ptr2+16(FP), R10
+	MOVQ ts+24(FP), R8
 	MOVL $454, AX
 	SYSCALL
+	MOVL	AX, ret+32(FP)
 	RET
 
 TEXT runtime·thr_new(SB),NOSPLIT,$0
-	MOVQ 8(SP), DI
-	MOVQ 16(SP), SI
+	MOVQ param+0(FP), DI
+	MOVL size+8(FP), SI
 	MOVL $455, AX
 	SYSCALL
 	RET
@@ -71,54 +72,59 @@ TEXT runtime·thr_start(SB),NOSPLIT,$0
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 exit status
+	MOVL	code+0(FP), DI		// arg 1 exit status
 	MOVL	$1, AX
 	SYSCALL
 	MOVL	$0xf1, 0xf1  // crash
 	RET
 
 TEXT runtime·exit1(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 exit status
+	MOVL	code+0(FP), DI		// arg 1 exit status
 	MOVL	$431, AX
 	SYSCALL
 	MOVL	$0xf1, 0xf1  // crash
 	RET
 
 TEXT runtime·open(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 pathname
-	MOVL	16(SP), SI		// arg 2 flags
-	MOVL	20(SP), DX		// arg 3 mode
+	MOVQ	name+0(FP), DI		// arg 1 pathname
+	MOVL	mode+8(FP), SI		// arg 2 flags
+	MOVL	perm+12(FP), DX		// arg 3 mode
 	MOVL	$5, AX
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
+	MOVL	fd+0(FP), DI		// arg 1 fd
 	MOVL	$6, AX
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVL	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$3, AX
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVQ	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$4, AX
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
+	MOVL	kind+0(FP), DI
+	MOVQ	limit+8(FP), SI
 	MOVL	$194, AX
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$16
@@ -134,9 +140,9 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·setitimer(SB), NOSPLIT, $-8
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVL	mode+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
 	MOVL	$83, AX
 	SYSCALL
 	RET
@@ -169,12 +175,13 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·sigaction(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 sig
-	MOVQ	16(SP), SI		// arg 2 act
-	MOVQ	24(SP), DX		// arg 3 oact
+	MOVL	sig+0(FP), DI		// arg 1 sig
+	MOVQ	new+8(FP), SI		// arg 2 act
+	MOVQ	old+16(FP), DX		// arg 3 oact
 	MOVL	$416, AX
 	SYSCALL
 	JCC	2(PC)
@@ -215,19 +222,20 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$64
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 addr
-	MOVQ	16(SP), SI		// arg 2 len
-	MOVL	24(SP), DX		// arg 3 prot
-	MOVL	28(SP), R10		// arg 4 flags
-	MOVL	32(SP), R8		// arg 5 fid
-	MOVL	36(SP), R9		// arg 6 offset
+	MOVQ	addr+0(FP), DI		// arg 1 addr
+	MOVQ	n+8(FP), SI		// arg 2 len
+	MOVL	prot+16(FP), DX		// arg 3 prot
+	MOVL	flags+20(FP), R10		// arg 4 flags
+	MOVL	fd+24(FP), R8		// arg 5 fid
+	MOVL	off+28(FP), R9		// arg 6 offset
 	MOVL	$477, AX
 	SYSCALL
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 addr
-	MOVQ	16(SP), SI		// arg 2 len
+	MOVQ	addr+0(FP), DI		// arg 1 addr
+	MOVQ	n+8(FP), SI		// arg 2 len
 	MOVL	$73, AX
 	SYSCALL
 	JCC	2(PC)
@@ -235,9 +243,9 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVQ	addr+0(FP), DI
+	MOVQ	n+8(FP), SI
+	MOVL	flags+16(FP), DX
 	MOVQ	$75, AX	// madvise
 	SYSCALL
 	// ignore failure - maybe pages are locked
@@ -281,18 +289,20 @@ TEXT runtime·settls(SB),NOSPLIT,$8
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - name
-	MOVL	16(SP), SI		// arg 2 - namelen
-	MOVQ	24(SP), DX		// arg 3 - oldp
-	MOVQ	32(SP), R10		// arg 4 - oldlenp
-	MOVQ	40(SP), R8		// arg 5 - newp
-	MOVQ	48(SP), R9		// arg 6 - newlen
+	MOVQ	mib+0(FP), DI		// arg 1 - name
+	MOVL	miblen+8(FP), SI		// arg 2 - namelen
+	MOVQ	out+16(FP), DX		// arg 3 - oldp
+	MOVQ	size+24(FP), R10		// arg 4 - oldlenp
+	MOVQ	dst+32(FP), R8		// arg 5 - newp
+	MOVQ	ndst+40(FP), R9		// arg 6 - newlen
 	MOVQ	$202, AX		// sys___sysctl
 	SYSCALL
-	JCC 3(PC)
+	JCC 4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$-4
@@ -302,8 +312,8 @@ TEXT runtime·osyield(SB),NOSPLIT,$-4
 
 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
 	MOVL	$3, DI			// arg 1 - how (SIG_SETMASK)
-	MOVQ	8(SP), SI		// arg 2 - set
-	MOVQ	16(SP), DX		// arg 3 - oset
+	MOVQ	new+0(FP), SI		// arg 2 - set
+	MOVQ	old+8(FP), DX		// arg 3 - oset
 	MOVL	$340, AX		// sys_sigprocmask
 	SYSCALL
 	JAE	2(PC)
@@ -319,25 +329,27 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
 TEXT runtime·kevent(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
-	MOVQ	32(SP), R10
-	MOVL	40(SP), R8
-	MOVQ	48(SP), R9
+	MOVL	fd+0(FP), DI
+	MOVQ	ev1+8(FP), SI
+	MOVL	nev1+16(FP), DX
+	MOVQ	ev2+24(FP), R10
+	MOVL	nev2+32(FP), R8
+	MOVQ	ts+40(FP), R9
 	MOVL	$363, AX
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd);
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVL	8(SP), DI	// fd
+	MOVL	fd+0(FP), DI	// fd
 	MOVQ	$2, SI		// F_SETFD
 	MOVQ	$1, DX		// FD_CLOEXEC
 	MOVL	$92, AX		// fcntl
diff --git a/src/pkg/runtime/sys_freebsd_arm.s b/src/pkg/runtime/sys_freebsd_arm.s
index dbb2583b00..da43871b96 100644
--- a/src/pkg/runtime/sys_freebsd_arm.s
+++ b/src/pkg/runtime/sys_freebsd_arm.s
@@ -48,6 +48,7 @@ TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
 	SWI $0
 	SUB $20, R13
 	// BCS error
+	MOVW	R0, ret+20(FP)
 	RET
 
 TEXT runtime·thr_new(SB),NOSPLIT,$0
@@ -91,6 +92,7 @@ TEXT runtime·open(SB),NOSPLIT,$-8
 	MOVW 8(FP), R2	// arg 3 perm
 	MOVW $SYS_open, R7
 	SWI $0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-8
@@ -99,6 +101,7 @@ TEXT runtime·read(SB),NOSPLIT,$-8
 	MOVW 8(FP), R2	// arg 3 count
 	MOVW $SYS_read, R7
 	SWI $0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-8
@@ -107,12 +110,14 @@ TEXT runtime·write(SB),NOSPLIT,$-8
 	MOVW 8(FP), R2	// arg 3 count
 	MOVW $SYS_write, R7
 	SWI $0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-8
 	MOVW 0(FP), R0	// arg 1 fd
 	MOVW $SYS_close, R7
 	SWI $0
+	MOVW	R0, ret+4(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$-8
@@ -120,6 +125,7 @@ TEXT runtime·getrlimit(SB),NOSPLIT,$-8
 	MOVW 4(FP), R1
 	MOVW $SYS_getrlimit, R7
 	SWI $0
+	MOVW	R0, ret+8(FP)
 	RET
 
 TEXT runtime·raise(SB),NOSPLIT,$8
@@ -178,9 +184,8 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	ADD.S R2, R0
 	ADC R4, R1
 
-	MOVW 0(FP), R3
-	MOVW R0, 0(R3)
-	MOVW R1, 4(R3)
+	MOVW R0, ret_lo+0(FP)
+	MOVW R1, ret_hi+4(FP)
 	RET
 
 TEXT runtime·sigaction(SB),NOSPLIT,$-8
@@ -247,6 +252,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$16
 	SWI $0
 	SUB $4, R13
 	// TODO(dfc) error checking ?
+	MOVW	R0, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
@@ -307,6 +313,7 @@ TEXT runtime·sysctl(SB),NOSPLIT,$0
 	SWI $0
 	SUB.CS $0, R0, R0
 	SUB $20, R13
+	MOVW	R0, ret+24(FP)
 	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$-4
@@ -329,6 +336,7 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	MOVW $SYS_kqueue, R7
 	SWI $0
 	RSB.CS $0, R0
+	MOVW	R0, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
@@ -342,6 +350,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
 	SWI $0
 	RSB.CS $0, R0
 	SUB $20, R13
+	MOVW	R0, ret+24(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd)
diff --git a/src/pkg/runtime/sys_linux_386.s b/src/pkg/runtime/sys_linux_386.s
index 3a8371cdd4..ace5a1802b 100644
--- a/src/pkg/runtime/sys_linux_386.s
+++ b/src/pkg/runtime/sys_linux_386.s
@@ -11,53 +11,58 @@
 
 TEXT runtime·exit(SB),NOSPLIT,$0
 	MOVL	$252, AX	// syscall number
-	MOVL	4(SP), BX
+	MOVL	code+0(FP), BX
 	CALL	*runtime·_vdso(SB)
 	INT $3	// not reached
 	RET
 
 TEXT runtime·exit1(SB),NOSPLIT,$0
 	MOVL	$1, AX	// exit - exit the current os thread
-	MOVL	4(SP), BX
+	MOVL	code+0(FP), BX
 	CALL	*runtime·_vdso(SB)
 	INT $3	// not reached
 	RET
 
 TEXT runtime·open(SB),NOSPLIT,$0
 	MOVL	$5, AX		// syscall - open
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	name+0(FP), BX
+	MOVL	mode+4(FP), CX
+	MOVL	perm+8(FP), DX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVL	$6, AX		// syscall - close
-	MOVL	4(SP), BX
+	MOVL	fd+0(FP), BX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
 	MOVL	$4, AX		// syscall - write
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	fd+0(FP), BX
+	MOVL	p+4(FP), CX
+	MOVL	n+8(FP), DX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
 	MOVL	$3, AX		// syscall - read
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	fd+0(FP), BX
+	MOVL	p+4(FP), CX
+	MOVL	n+8(FP), DX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$0
 	MOVL	$191, AX		// syscall - ugetrlimit
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
+	MOVL	kind+0(FP), BX
+	MOVL	limit+4(FP), CX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$8
@@ -87,20 +92,21 @@ TEXT runtime·raise(SB),NOSPLIT,$12
 	CALL	*runtime·_vdso(SB)
 	RET
 
-TEXT runtime·setitimer(SB),NOSPLIT,$0-24
+TEXT runtime·setitimer(SB),NOSPLIT,$0-12
 	MOVL	$104, AX			// syscall - setitimer
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	mode+0(FP), BX
+	MOVL	new+4(FP), CX
+	MOVL	old+8(FP), DX
 	CALL	*runtime·_vdso(SB)
 	RET
 
-TEXT runtime·mincore(SB),NOSPLIT,$0-24
+TEXT runtime·mincore(SB),NOSPLIT,$0-16
 	MOVL	$218, AX			// syscall - mincore
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	addr+0(FP), BX
+	MOVL	n+4(FP), CX
+	MOVL	dst+8(FP), DX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+12(FP)
 	RET
 
 // func now() (sec int64, nsec int32)
@@ -137,17 +143,16 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	ADDL	BX, AX
 	ADCL	$0, DX
 
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0
 	MOVL	$175, AX		// syscall entry
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
-	MOVL	16(SP), SI
+	MOVL	sig+0(FP), BX
+	MOVL	new+4(FP), CX
+	MOVL	old+8(FP), DX
+	MOVL	size+12(FP), SI
 	CALL	*runtime·_vdso(SB)
 	CMPL	AX, $0xfffff001
 	JLS	2(PC)
@@ -156,11 +161,12 @@ TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0
 
 TEXT runtime·rt_sigaction(SB),NOSPLIT,$0
 	MOVL	$174, AX		// syscall - rt_sigaction
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
-	MOVL	16(SP), SI
+	MOVL	sig+0(FP), BX
+	MOVL	new+4(FP), CX
+	MOVL	old+8(FP), DX
+	MOVL	size+12(FP), SI
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT,$44
@@ -212,24 +218,25 @@ TEXT runtime·sigreturn(SB),NOSPLIT,$0
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
 	MOVL	$192, AX	// mmap2
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
-	MOVL	16(SP), SI
-	MOVL	20(SP), DI
-	MOVL	24(SP), BP
+	MOVL	addr+0(FP), BX
+	MOVL	n+4(FP), CX
+	MOVL	prot+8(FP), DX
+	MOVL	flags+12(FP), SI
+	MOVL	fd+16(FP), DI
+	MOVL	off+20(FP), BP
 	SHRL	$12, BP
 	CALL	*runtime·_vdso(SB)
 	CMPL	AX, $0xfffff001
 	JLS	3(PC)
 	NOTL	AX
 	INCL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
 	MOVL	$91, AX	// munmap
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
+	MOVL	addr+0(FP), BX
+	MOVL	n+4(FP), CX
 	CALL	*runtime·_vdso(SB)
 	CMPL	AX, $0xfffff001
 	JLS	2(PC)
@@ -238,9 +245,9 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
 	MOVL	$219, AX	// madvise
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	addr+0(FP), BX
+	MOVL	n+4(FP), CX
+	MOVL	flags+8(FP), DX
 	CALL	*runtime·_vdso(SB)
 	// ignore failure - maybe pages are locked
 	RET
@@ -249,13 +256,14 @@ TEXT runtime·madvise(SB),NOSPLIT,$0
 //	struct timespec *timeout, int32 *uaddr2, int32 val2);
 TEXT runtime·futex(SB),NOSPLIT,$0
 	MOVL	$240, AX	// futex
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
-	MOVL	16(SP), SI
-	MOVL	20(SP), DI
-	MOVL	24(SP), BP
+	MOVL	addr+0(FP), BX
+	MOVL	op+4(FP), CX
+	MOVL	val+8(FP), DX
+	MOVL	ts+12(FP), SI
+	MOVL	addr2+16(FP), DI
+	MOVL	val3+20(FP), BP
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
@@ -284,11 +292,12 @@ TEXT runtime·clone(SB),NOSPLIT,$0
 
 	// In parent, return.
 	CMPL	AX, $0
-	JEQ	2(PC)
+	JEQ	3(PC)
+	MOVL	AX, ret+20(FP)
 	RET
 
 	// Paranoia: check that SP is as we expect.
-	MOVL	12(SP), BP
+	MOVL	mm+8(FP), BP
 	CMPL	BP, $1234
 	JEQ	2(PC)
 	INT	$3
@@ -299,8 +308,8 @@ TEXT runtime·clone(SB),NOSPLIT,$0
 
 	// In child on new stack.  Reload registers (paranoia).
 	MOVL	0(SP), BX	// m
-	MOVL	4(SP), DX	// g
-	MOVL	8(SP), SI	// fn
+	MOVL	flags+0(FP), DX	// g
+	MOVL	stk+4(FP), SI	// fn
 
 	MOVL	AX, m_procid(BX)	// save tid as m->procid
 
@@ -337,7 +346,6 @@ TEXT runtime·clone(SB),NOSPLIT,$0
 	CALL	SI	// fn()
 	CALL	runtime·exit1(SB)
 	MOVL	$0x1234, 0x1005
-	RET
 
 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
 	MOVL	$186, AX	// sigaltstack
@@ -426,50 +434,55 @@ TEXT runtime·osyield(SB),NOSPLIT,$0
 
 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
 	MOVL	$242, AX		// syscall - sched_getaffinity
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
+	MOVL	pid+0(FP), BX
+	MOVL	len+4(FP), CX
+	MOVL	buf+8(FP), DX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+12(FP)
 	RET
 
 // int32 runtime·epollcreate(int32 size);
 TEXT runtime·epollcreate(SB),NOSPLIT,$0
 	MOVL    $254, AX
-	MOVL	4(SP), BX
+	MOVL	size+0(FP), BX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+4(FP)
 	RET
 
 // int32 runtime·epollcreate1(int32 flags);
 TEXT runtime·epollcreate1(SB),NOSPLIT,$0
 	MOVL    $329, AX
-	MOVL	4(SP), BX
+	MOVL	flags+0(FP), BX
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+4(FP)
 	RET
 
 // int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
 TEXT runtime·epollctl(SB),NOSPLIT,$0
 	MOVL	$255, AX
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
-	MOVL	16(SP), SI
+	MOVL	epfd+0(FP), BX
+	MOVL	op+4(FP), CX
+	MOVL	fd+8(FP), DX
+	MOVL	ev+12(FP), SI
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+16(FP)
 	RET
 
 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
 TEXT runtime·epollwait(SB),NOSPLIT,$0
 	MOVL	$256, AX
-	MOVL	4(SP), BX
-	MOVL	8(SP), CX
-	MOVL	12(SP), DX
-	MOVL	16(SP), SI
+	MOVL	epfd+0(FP), BX
+	MOVL	ev+4(FP), CX
+	MOVL	nev+8(FP), DX
+	MOVL	timeout+12(FP), SI
 	CALL	*runtime·_vdso(SB)
+	MOVL	AX, ret+16(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd);
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
 	MOVL	$55, AX  // fcntl
-	MOVL	4(SP), BX  // fd
+	MOVL	fd+0(FP), BX  // fd
 	MOVL	$2, CX  // F_SETFD
 	MOVL	$1, DX  // FD_CLOEXEC
 	CALL	*runtime·_vdso(SB)
diff --git a/src/pkg/runtime/sys_linux_amd64.s b/src/pkg/runtime/sys_linux_amd64.s
index c402c86164..f263ef35ae 100644
--- a/src/pkg/runtime/sys_linux_amd64.s
+++ b/src/pkg/runtime/sys_linux_amd64.s
@@ -9,53 +9,58 @@
 #include "zasm_GOOS_GOARCH.h"
 #include "../../cmd/ld/textflag.h"
 
-TEXT runtime·exit(SB),NOSPLIT,$0-8
-	MOVL	8(SP), DI
+TEXT runtime·exit(SB),NOSPLIT,$0-4
+	MOVL	code+0(FP), DI
 	MOVL	$231, AX	// exitgroup - force all os threads to exit
 	SYSCALL
 	RET
 
-TEXT runtime·exit1(SB),NOSPLIT,$0-8
-	MOVL	8(SP), DI
+TEXT runtime·exit1(SB),NOSPLIT,$0-4
+	MOVL	code+0(FP), DI
 	MOVL	$60, AX	// exit - exit the current os thread
 	SYSCALL
 	RET
 
-TEXT runtime·open(SB),NOSPLIT,$0-16
-	MOVQ	8(SP), DI
-	MOVL	16(SP), SI
-	MOVL	20(SP), DX
+TEXT runtime·open(SB),NOSPLIT,$0-20
+	MOVQ	name+0(FP), DI
+	MOVL	mode+8(FP), SI
+	MOVL	perm+12(FP), DX
 	MOVL	$2, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT runtime·close(SB),NOSPLIT,$0-16
-	MOVL	8(SP), DI
+TEXT runtime·close(SB),NOSPLIT,$0-12
+	MOVL	fd+0(FP), DI
 	MOVL	$3, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·write(SB),NOSPLIT,$0-24
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
+TEXT runtime·write(SB),NOSPLIT,$0-28
+	MOVQ	fd+0(FP), DI
+	MOVQ	p+8(FP), SI
+	MOVL	n+16(FP), DX
 	MOVL	$1, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
-TEXT runtime·read(SB),NOSPLIT,$0-24
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
+TEXT runtime·read(SB),NOSPLIT,$0-28
+	MOVL	fd+0(FP), DI
+	MOVQ	p+8(FP), SI
+	MOVL	n+16(FP), DX
 	MOVL	$0, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
-TEXT runtime·getrlimit(SB),NOSPLIT,$0-24
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
+TEXT runtime·getrlimit(SB),NOSPLIT,$0-20
+	MOVL	kind+0(FP), DI
+	MOVQ	limit+8(FP), SI
 	MOVL	$97, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$16
@@ -86,19 +91,20 @@ TEXT runtime·raise(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·setitimer(SB),NOSPLIT,$0-24
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVL	mode+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
 	MOVL	$38, AX			// syscall entry
 	SYSCALL
 	RET
 
-TEXT runtime·mincore(SB),NOSPLIT,$0-24
-	MOVQ	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+TEXT runtime·mincore(SB),NOSPLIT,$0-28
+	MOVQ	addr+0(FP), DI
+	MOVQ	n+8(FP), SI
+	MOVQ	dst+16(FP), DX
 	MOVL	$27, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 // func now() (sec int64, nsec int32)
@@ -145,6 +151,7 @@ TEXT runtime·nanotime(SB),NOSPLIT,$16
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 fallback_gtod_nt:
 	LEAQ	0(SP), DI
@@ -158,13 +165,14 @@ fallback_gtod_nt:
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
-TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-32
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
-	MOVL	32(SP), R10
+TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28
+	MOVL	sig+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
+	MOVL	size+24(FP), R10
 	MOVL	$14, AX			// syscall entry
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
@@ -172,13 +180,14 @@ TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-32
 	MOVL	$0xf1, 0xf1  // crash
 	RET
 
-TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-32
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
-	MOVQ	32(SP), R10
+TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-36
+	MOVQ	sig+0(FP), DI
+	MOVQ	new+8(FP), SI
+	MOVQ	old+16(FP), DX
+	MOVQ	size+24(FP), R10
 	MOVL	$13, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+32(FP)
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT,$64
@@ -220,12 +229,12 @@ TEXT runtime·sigreturn(SB),NOSPLIT,$0
 	INT $3	// not reached
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
-	MOVL	28(SP), R10
-	MOVL	32(SP), R8
-	MOVL	36(SP), R9
+	MOVQ	addr+0(FP), DI
+	MOVQ	n+8(FP), SI
+	MOVL	prot+16(FP), DX
+	MOVL	flags+20(FP), R10
+	MOVL	fd+24(FP), R8
+	MOVL	off+28(FP), R9
 
 	MOVL	$9, AX			// mmap
 	SYSCALL
@@ -233,11 +242,12 @@ TEXT runtime·mmap(SB),NOSPLIT,$0
 	JLS	3(PC)
 	NOTQ	AX
 	INCQ	AX
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVQ	16(SP), SI
+	MOVQ	addr+0(FP), DI
+	MOVQ	n+8(FP), SI
 	MOVQ	$11, AX	// munmap
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
@@ -246,9 +256,9 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVQ	addr+0(FP), DI
+	MOVQ	n+8(FP), SI
+	MOVL	flags+16(FP), DX
 	MOVQ	$28, AX	// madvise
 	SYSCALL
 	// ignore failure - maybe pages are locked
@@ -257,17 +267,18 @@ TEXT runtime·madvise(SB),NOSPLIT,$0
 // int64 futex(int32 *uaddr, int32 op, int32 val,
 //	struct timespec *timeout, int32 *uaddr2, int32 val2);
 TEXT runtime·futex(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVL	16(SP), SI
-	MOVL	20(SP), DX
-	MOVQ	24(SP), R10
-	MOVQ	32(SP), R8
-	MOVL	40(SP), R9
+	MOVQ	addr+0(FP), DI
+	MOVL	op+8(FP), SI
+	MOVL	val+12(FP), DX
+	MOVQ	ts+16(FP), R10
+	MOVQ	addr2+24(FP), R8
+	MOVL	val3+32(FP), R9
 	MOVL	$202, AX
 	SYSCALL
+	MOVL	AX, ret+40(FP)
 	RET
 
-// int64 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
+// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
 TEXT runtime·clone(SB),NOSPLIT,$0
 	MOVL	flags+8(SP), DI
 	MOVQ	stack+16(SP), SI
@@ -283,7 +294,8 @@ TEXT runtime·clone(SB),NOSPLIT,$0
 
 	// In parent, return.
 	CMPQ	AX, $0
-	JEQ	2(PC)
+	JEQ	3(PC)
+	MOVL	AX, ret+40(FP)
 	RET
 
 	// In child, on new stack.
@@ -342,50 +354,55 @@ TEXT runtime·osyield(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI
-	MOVL	16(SP), SI
-	MOVQ	24(SP), DX
+	MOVQ	pid+0(FP), DI
+	MOVQ	len+8(FP), SI
+	MOVQ	buf+16(FP), DX
 	MOVL	$204, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·epollcreate(int32 size);
 TEXT runtime·epollcreate(SB),NOSPLIT,$0
-	MOVL    8(SP), DI
+	MOVL    size+0(FP), DI
 	MOVL    $213, AX                        // syscall entry
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 // int32 runtime·epollcreate1(int32 flags);
 TEXT runtime·epollcreate1(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
+	MOVL	flags+0(FP), DI
 	MOVL	$291, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 // int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
 TEXT runtime·epollctl(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVL	12(SP), SI
-	MOVL	16(SP), DX
-	MOVQ	24(SP), R10
+	MOVL	epfd+0(FP), DI
+	MOVL	op+4(FP), SI
+	MOVL	fd+8(FP), DX
+	MOVQ	ev+16(FP), R10
 	MOVL	$233, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
 TEXT runtime·epollwait(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
-	MOVL	28(SP), R10
+	MOVL	epfd+0(FP), DI
+	MOVQ	ev+8(FP), SI
+	MOVL	nev+16(FP), DX
+	MOVL	timeout+20(FP), R10
 	MOVL	$232, AX			// syscall entry
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd);
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVL    8(SP), DI  // fd
+	MOVL    fd+0(FP), DI  // fd
 	MOVQ    $2, SI  // F_SETFD
 	MOVQ    $1, DX  // FD_CLOEXEC
 	MOVL	$72, AX  // fcntl
diff --git a/src/pkg/runtime/sys_linux_arm.s b/src/pkg/runtime/sys_linux_arm.s
index 770b963d24..3221cdf29f 100644
--- a/src/pkg/runtime/sys_linux_arm.s
+++ b/src/pkg/runtime/sys_linux_arm.s
@@ -51,12 +51,14 @@ TEXT runtime·open(SB),NOSPLIT,$0
 	MOVW	8(FP), R2
 	MOVW	$SYS_open, R7
 	SWI	$0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVW	0(FP), R0
 	MOVW	$SYS_close, R7
 	SWI	$0
+	MOVW	R0, ret+4(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
@@ -65,6 +67,7 @@ TEXT runtime·write(SB),NOSPLIT,$0
 	MOVW	8(FP), R2
 	MOVW	$SYS_write, R7
 	SWI	$0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
@@ -73,6 +76,7 @@ TEXT runtime·read(SB),NOSPLIT,$0
 	MOVW	8(FP), R2
 	MOVW	$SYS_read, R7
 	SWI	$0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·getrlimit(SB),NOSPLIT,$0
@@ -80,6 +84,7 @@ TEXT runtime·getrlimit(SB),NOSPLIT,$0
 	MOVW	4(FP), R1
 	MOVW	$SYS_ugetrlimit, R7
 	SWI	$0
+	MOVW	R0, ret+8(FP)
 	RET
 
 TEXT runtime·exit(SB),NOSPLIT,$-4
@@ -119,6 +124,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$0
 	MOVW	$0xfffff001, R6
 	CMP		R6, R0
 	RSB.HI	$0, R0
+	MOVW	R0, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
@@ -155,6 +161,7 @@ TEXT runtime·mincore(SB),NOSPLIT,$0
 	MOVW	8(FP), R2
 	MOVW	$SYS_mincore, R7
 	SWI	$0
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT time·now(SB), NOSPLIT, $32
@@ -172,8 +179,7 @@ TEXT time·now(SB), NOSPLIT, $32
 	MOVW	R2, 8(FP)
 	RET	
 
-// int64 nanotime(void) so really
-// void nanotime(int64 *nsec)
+// int64 nanotime(void)
 TEXT runtime·nanotime(SB),NOSPLIT,$32
 	MOVW	$1, R0  // CLOCK_MONOTONIC
 	MOVW	$8(R13), R1  // timespec
@@ -189,9 +195,8 @@ TEXT runtime·nanotime(SB),NOSPLIT,$32
 	ADD.S	R2, R0
 	ADC	R4, R1
 
-	MOVW	0(FP), R3
-	MOVW	R0, 0(R3)
-	MOVW	R1, 4(R3)
+	MOVW	R0, ret_lo+0(FP)
+	MOVW	R1, ret_hi+4(FP)
 	RET
 
 // int32 futex(int32 *uaddr, int32 op, int32 val,
@@ -205,13 +210,14 @@ TEXT runtime·futex(SB),NOSPLIT,$0
 	MOVW	24(SP), R5
 	MOVW	$SYS_futex, R7
 	SWI	$0
+	MOVW	R0, ret+24(FP)
 	RET
 
 
 // int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
 TEXT runtime·clone(SB),NOSPLIT,$0
 	MOVW	flags+0(FP), R0
-	MOVW	stack+4(FP), R1
+	MOVW	stk+4(FP), R1
 	MOVW	$0, R2	// parent tid ptr
 	MOVW	$0, R3	// tls_val
 	MOVW	$0, R4	// child tid ptr
@@ -234,7 +240,8 @@ TEXT runtime·clone(SB),NOSPLIT,$0
 
 	// In parent, return.
 	CMP	$0, R0
-	BEQ	2(PC)
+	BEQ	3(PC)
+	MOVW	R0, ret+20(FP)
 	RET
 
 	// Paranoia: check that SP is as we expect. Use R13 to avoid linker 'fixup'
@@ -338,6 +345,7 @@ TEXT runtime·rt_sigaction(SB),NOSPLIT,$0
 	MOVW	12(FP), R3
 	MOVW	$SYS_rt_sigaction, R7
 	SWI	$0
+	MOVW	R0, ret+16(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$12
@@ -363,22 +371,24 @@ TEXT cas<>(SB),NOSPLIT,$0
 	MOVW	$0xffff0fc0, PC
 
 TEXT runtime·cas(SB),NOSPLIT,$0
-	MOVW	valptr+0(FP), R2
+	MOVW	ptr+0(FP), R2
 	MOVW	old+4(FP), R0
 casagain:
 	MOVW	new+8(FP), R1
 	BL	cas<>(SB)
 	BCC	cascheck
 	MOVW	$1, R0
+	MOVB	R0, ret+12(FP)
 	RET
 cascheck:
 	// Kernel lies; double-check.
-	MOVW	valptr+0(FP), R2
+	MOVW	ptr+0(FP), R2
 	MOVW	old+4(FP), R0
 	MOVW	0(R2), R3
 	CMP	R0, R3
 	BEQ	casagain
 	MOVW	$0, R0
+	MOVB	R0, ret+12(FP)
 	RET
 
 TEXT runtime·casp(SB),NOSPLIT,$0
@@ -395,6 +405,7 @@ TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
 	MOVW	8(FP), R2
 	MOVW	$SYS_sched_getaffinity, R7
 	SWI	$0
+	MOVW	R0, ret+12(FP)
 	RET
 
 // int32 runtime·epollcreate(int32 size)
@@ -402,6 +413,7 @@ TEXT runtime·epollcreate(SB),NOSPLIT,$0
 	MOVW	0(FP), R0
 	MOVW	$SYS_epoll_create, R7
 	SWI	$0
+	MOVW	R0, ret+4(FP)
 	RET
 
 // int32 runtime·epollcreate1(int32 flags)
@@ -409,6 +421,7 @@ TEXT runtime·epollcreate1(SB),NOSPLIT,$0
 	MOVW	0(FP), R0
 	MOVW	$SYS_epoll_create1, R7
 	SWI	$0
+	MOVW	R0, ret+4(FP)
 	RET
 
 // int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev)
@@ -419,6 +432,7 @@ TEXT runtime·epollctl(SB),NOSPLIT,$0
 	MOVW	12(FP), R3
 	MOVW	$SYS_epoll_ctl, R7
 	SWI	$0
+	MOVW	R0, ret+16(FP)
 	RET
 
 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout)
@@ -429,6 +443,7 @@ TEXT runtime·epollwait(SB),NOSPLIT,$0
 	MOVW	12(FP), R3
 	MOVW	$SYS_epoll_wait, R7
 	SWI	$0
+	MOVW	R0, ret+16(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd)
diff --git a/src/pkg/runtime/sys_nacl_386.s b/src/pkg/runtime/sys_nacl_386.s
index 50dca316df..e460e8efcd 100644
--- a/src/pkg/runtime/sys_nacl_386.s
+++ b/src/pkg/runtime/sys_nacl_386.s
@@ -96,22 +96,23 @@ TEXT runtime·osyield(SB),NOSPLIT,$0
 	NACL_SYSJMP(SYS_sched_yield)
 
 TEXT runtime·mmap(SB),NOSPLIT,$32
-	MOVL	arg1+0(FP), AX
+	MOVL	addr+0(FP), AX
 	MOVL	AX, 0(SP)
-	MOVL	arg2+4(FP), AX
+	MOVL	n+4(FP), AX
 	MOVL	AX, 4(SP)
-	MOVL	arg3+8(FP), AX
+	MOVL	prot+8(FP), AX
 	MOVL	AX, 8(SP)
-	MOVL	arg4+12(FP), AX
+	MOVL	flags+12(FP), AX
 	MOVL	AX, 12(SP)
-	MOVL	arg5+16(FP), AX
+	MOVL	fd+16(FP), AX
 	MOVL	AX, 16(SP)
-	MOVL	arg6+20(FP), AX
+	MOVL	off+20(FP), AX
 	MOVL	AX, 24(SP)
 	MOVL	$0, 28(SP)
 	LEAL	24(SP), AX
 	MOVL	AX, 20(SP)
 	NACL_SYSCALL(SYS_mmap)
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT time·now(SB),NOSPLIT,$20
@@ -150,9 +151,8 @@ TEXT runtime·nanotime(SB),NOSPLIT,$20
 	ADDL	BX, AX
 	ADCL	$0, DX
 
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·setldt(SB),NOSPLIT,$8
diff --git a/src/pkg/runtime/sys_nacl_amd64p32.s b/src/pkg/runtime/sys_nacl_amd64p32.s
index d4e32ffe39..213e12d36d 100644
--- a/src/pkg/runtime/sys_nacl_amd64p32.s
+++ b/src/pkg/runtime/sys_nacl_amd64p32.s
@@ -17,27 +17,27 @@ TEXT runtime·settls(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·exit(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL code+0(FP), DI
 	NACL_SYSJMP(SYS_exit)
 
 TEXT runtime·exit1(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL code+0(FP), DI
 	NACL_SYSJMP(SYS_thread_exit)
 
 TEXT runtime·open(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
+	MOVL name+0(FP), DI
+	MOVL mode+4(FP), SI
+	MOVL perm+8(FP), DX
 	NACL_SYSJMP(SYS_open)
 
 TEXT runtime·close(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL fd+0(FP), DI
 	NACL_SYSJMP(SYS_close)
 
 TEXT runtime·read(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
+	MOVL fd+0(FP), DI
+	MOVL p+4(FP), SI
+	MOVL n+8(FP), DX
 	NACL_SYSJMP(SYS_read)
 
 TEXT syscall·naclWrite(SB), NOSPLIT, $16-20
@@ -51,13 +51,13 @@ TEXT syscall·naclWrite(SB), NOSPLIT, $16-20
 	MOVL AX, ret+16(FP)
 	RET
 
-TEXT runtime·write(SB),NOSPLIT,$16-12
+TEXT runtime·write(SB),NOSPLIT,$16-20
 	// If using fake time and writing to stdout or stderr,
 	// emit playback header before actual data.
 	MOVQ runtime·timens(SB), AX
 	CMPQ AX, $0
 	JEQ write
-	MOVL arg1+0(FP), DI
+	MOVL fd+0(FP), DI
 	CMPL DI, $1
 	JEQ playback
 	CMPL DI, $2
@@ -65,10 +65,11 @@ TEXT runtime·write(SB),NOSPLIT,$16-12
 
 write:
 	// Ordinary write.
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
+	MOVL fd+0(FP), DI
+	MOVL p+4(FP), SI
+	MOVL n+8(FP), DX
 	NACL_SYSCALL(SYS_write)
+	MOVL	AX, ret+16(FP)
 	RET
 
 	// Write with playback header.
@@ -83,7 +84,7 @@ playback:
 	MOVL $(('B'<<24) | ('P'<<16)), 0(SP)
 	BSWAPQ AX
 	MOVQ AX, 4(SP)
-	MOVL arg3+8(FP), DX
+	MOVL n+8(FP), DX
 	BSWAPL DX
 	MOVL DX, 12(SP)
 	MOVL $1, DI // standard output
@@ -93,81 +94,82 @@ playback:
 
 	// Write actual data.
 	MOVL $1, DI // standard output
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
+	MOVL p+4(FP), SI
+	MOVL n+8(FP), DX
 	NACL_SYSCALL(SYS_write)
 
 	// Unlock.
 	MOVL	$0, runtime·writelock(SB)
 
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
+	MOVL p+0(FP), DI
+	MOVL size+4(FP), SI
 	NACL_SYSJMP(SYS_exception_stack)
 
 TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
+	MOVL fn+0(FP), DI
+	MOVL arg+4(FP), SI
 	NACL_SYSJMP(SYS_exception_handler)
 
 TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL flag+0(FP), DI
 	NACL_SYSJMP(SYS_sem_create)
 
 TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL sem+0(FP), DI
 	NACL_SYSJMP(SYS_sem_wait)
 
 TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL sem+0(FP), DI
 	NACL_SYSJMP(SYS_sem_post)
 
 TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL flag+0(FP), DI
 	NACL_SYSJMP(SYS_mutex_create)
 
 TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL mutex+0(FP), DI
 	NACL_SYSJMP(SYS_mutex_lock)
 
 TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL mutex+0(FP), DI
 	NACL_SYSJMP(SYS_mutex_trylock)
 
 TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL mutex+0(FP), DI
 	NACL_SYSJMP(SYS_mutex_unlock)
 
 TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL flag+0(FP), DI
 	NACL_SYSJMP(SYS_cond_create)
 
 TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
+	MOVL cond+0(FP), DI
+	MOVL n+4(FP), SI
 	NACL_SYSJMP(SYS_cond_wait)
 
 TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL cond+0(FP), DI
 	NACL_SYSJMP(SYS_cond_signal)
 
 TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
+	MOVL cond+0(FP), DI
 	NACL_SYSJMP(SYS_cond_broadcast)
 
 TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
+	MOVL cond+0(FP), DI
+	MOVL lock+4(FP), SI
+	MOVL ts+8(FP), DX
 	NACL_SYSJMP(SYS_cond_timed_wait_abs)
 
 TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
-	MOVL arg4+12(FP), CX
+	MOVL fn+0(FP), DI
+	MOVL stk+4(FP), SI
+	MOVL tls+8(FP), DX
+	MOVL xx+12(FP), CX
 	NACL_SYSJMP(SYS_thread_create)
 
 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
@@ -177,26 +179,27 @@ TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 	JMP runtime·mstart(SB)
 
 TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
+	MOVL ts+0(FP), DI
+	MOVL extra+4(FP), SI
 	NACL_SYSJMP(SYS_nanosleep)
 
 TEXT runtime·osyield(SB),NOSPLIT,$0
 	NACL_SYSJMP(SYS_sched_yield)
 
 TEXT runtime·mmap(SB),NOSPLIT,$8
-	MOVL arg1+0(FP), DI
-	MOVL arg2+4(FP), SI
-	MOVL arg3+8(FP), DX
-	MOVL arg4+12(FP), CX
-	MOVL arg5+16(FP), R8
-	MOVL arg6+20(FP), AX
+	MOVL addr+0(FP), DI
+	MOVL n+4(FP), SI
+	MOVL prot+8(FP), DX
+	MOVL flags+12(FP), CX
+	MOVL fd+16(FP), R8
+	MOVL off+20(FP), AX
 	MOVQ AX, 0(SP)
 	MOVL SP, R9
 	NACL_SYSCALL(SYS_mmap)
 	CMPL AX, $-4095
 	JNA 2(PC)
 	NEGL AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT time·now(SB),NOSPLIT,$16
@@ -235,7 +238,8 @@ TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
 TEXT runtime·nanotime(SB),NOSPLIT,$16
 	MOVQ runtime·timens(SB), AX
 	CMPQ AX, $0
-	JEQ 2(PC)
+	JEQ 3(PC)
+	MOVQ	AX, ret+0(FP)
 	RET
 	MOVL $0, DI // real time clock
 	LEAL 0(SP), AX
@@ -248,6 +252,7 @@ TEXT runtime·nanotime(SB),NOSPLIT,$16
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT,$80
diff --git a/src/pkg/runtime/sys_nacl_arm.s b/src/pkg/runtime/sys_nacl_arm.s
index 6a22368507..48b9aaed7c 100644
--- a/src/pkg/runtime/sys_nacl_arm.s
+++ b/src/pkg/runtime/sys_nacl_arm.s
@@ -13,27 +13,27 @@
 	MOVW	$(0x10000 + ((code)<<5)), R8; B (R8)
 
 TEXT runtime·exit(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	code+0(FP), R0
 	NACL_SYSJMP(SYS_exit)
 
 TEXT runtime·exit1(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	code+0(FP), R0
 	NACL_SYSJMP(SYS_thread_exit)
 
 TEXT runtime·open(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+0(FP), R1
-	MOVW	arg3+0(FP), R2
+	MOVW	name+0(FP), R0
+	MOVW	name+0(FP), R1
+	MOVW	name+0(FP), R2
 	NACL_SYSJMP(SYS_open)
 
 TEXT runtime·close(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	fd+0(FP), R0
 	NACL_SYSJMP(SYS_close)
 
 TEXT runtime·read(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
-	MOVW	arg3+8(FP), R2
+	MOVW	fd+0(FP), R0
+	MOVW	p+4(FP), R1
+	MOVW	n+8(FP), R2
 	NACL_SYSJMP(SYS_read)
 
 // func naclWrite(fd int, b []byte) int
@@ -46,77 +46,77 @@ TEXT syscall·naclWrite(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
-	MOVW	arg3+8(FP), R2
+	MOVW	fd+0(FP), R0
+	MOVW	p+4(FP), R1
+	MOVW	n+8(FP), R2
 	NACL_SYSJMP(SYS_write)
 
 TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
+	MOVW	p+0(FP), R0
+	MOVW	size+4(FP), R1
 	NACL_SYSJMP(SYS_exception_stack)
 
 TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
+	MOVW	fn+0(FP), R0
+	MOVW	arg+4(FP), R1
 	NACL_SYSJMP(SYS_exception_handler)
 
 TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	flag+0(FP), R0
 	NACL_SYSJMP(SYS_sem_create)
 
 TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	sem+0(FP), R0
 	NACL_SYSJMP(SYS_sem_wait)
 
 TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	sem+0(FP), R0
 	NACL_SYSJMP(SYS_sem_post)
 
 TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	flag+0(FP), R0
 	NACL_SYSJMP(SYS_mutex_create)
 
 TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	mutex+0(FP), R0
 	NACL_SYSJMP(SYS_mutex_lock)
 
 TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	mutex+0(FP), R0
 	NACL_SYSJMP(SYS_mutex_trylock)
 
 TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	mutex+0(FP), R0
 	NACL_SYSJMP(SYS_mutex_unlock)
 
 TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	flag+0(FP), R0
 	NACL_SYSJMP(SYS_cond_create)
 
 TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
+	MOVW	cond+0(FP), R0
+	MOVW	n+4(FP), R1
 	NACL_SYSJMP(SYS_cond_wait)
 
 TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	cond+0(FP), R0
 	NACL_SYSJMP(SYS_cond_signal)
 
 TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
+	MOVW	cond+0(FP), R0
 	NACL_SYSJMP(SYS_cond_broadcast)
 
 TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
-	MOVW	arg3+8(FP), R2
+	MOVW	cond+0(FP), R0
+	MOVW	lock+4(FP), R1
+	MOVW	ts+8(FP), R2
 	NACL_SYSJMP(SYS_cond_timed_wait_abs)
 
 TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
-	MOVW	arg3+8(FP), R2
-	MOVW	arg4+12(FP), R3
+	MOVW	fn+0(FP), R0
+	MOVW	stk+4(FP), R1
+	MOVW	tls+8(FP), R2
+	MOVW	xx+12(FP), R3
 	NACL_SYSJMP(SYS_thread_create)
 
 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
@@ -128,21 +128,21 @@ TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 	B runtime·mstart(SB)
 
 TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
+	MOVW	ts+0(FP), R0
+	MOVW	extra+4(FP), R1
 	NACL_SYSJMP(SYS_nanosleep)
 
 TEXT runtime·osyield(SB),NOSPLIT,$0
 	NACL_SYSJMP(SYS_sched_yield)
 
 TEXT runtime·mmap(SB),NOSPLIT,$8
-	MOVW	arg1+0(FP), R0
-	MOVW	arg2+4(FP), R1
-	MOVW	arg3+8(FP), R2
-	MOVW	arg4+12(FP), R3
-	MOVW	arg5+16(FP), R4
+	MOVW	addr+0(FP), R0
+	MOVW	n+4(FP), R1
+	MOVW	prot+8(FP), R2
+	MOVW	flags+12(FP), R3
+	MOVW	fd+16(FP), R4
 	// arg6:offset should be passed as a pointer (to int64)
-	MOVW	arg6+20(FP), R5
+	MOVW	off+20(FP), R5
 	MOVW	R5, 4(R13)
 	MOVW	$0, R6
 	MOVW	R6, 8(R13)
@@ -152,6 +152,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$8
 	MOVM.IA.W (R13), [R4, R5]
 	CMP	$-4095, R0
 	RSB.HI	$0, R0
+	MOVW	R0, ret+24(FP)
 	RET
 
 TEXT time·now(SB),NOSPLIT,$16
@@ -188,9 +189,8 @@ TEXT runtime·nanotime(SB),NOSPLIT,$16
 	MOVW	$0, R4
 	ADD.S	R2, R0
 	ADC	R4, R1
-	MOVW	0(FP), R2
-	MOVW	R0, 0(R2)
-	MOVW	R1, 4(R2)
+	MOVW	R0, ret_lo+0(FP)
+	MOVW	R1, ret_hi+4(FP)
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT,$80
diff --git a/src/pkg/runtime/sys_netbsd_386.s b/src/pkg/runtime/sys_netbsd_386.s
index 4a78cb9d2e..cecc389b5f 100644
--- a/src/pkg/runtime/sys_netbsd_386.s
+++ b/src/pkg/runtime/sys_netbsd_386.s
@@ -26,21 +26,25 @@ TEXT runtime·exit1(SB),NOSPLIT,$-4
 TEXT runtime·open(SB),NOSPLIT,$-4
 	MOVL	$5, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-4
 	MOVL	$6, AX
 	INT	$0x80
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-4
 	MOVL	$3, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-4
 	MOVL	$4, AX			// sys_write
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$24
@@ -74,7 +78,7 @@ TEXT runtime·raise(SB),NOSPLIT,$12
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$36
-	LEAL	arg0+0(FP), SI
+	LEAL	addr+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - addr
@@ -89,6 +93,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$36
 	STOSL
 	MOVL	$197, AX		// sys_mmap
 	INT	$0x80
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$-4
@@ -146,9 +151,8 @@ TEXT runtime·nanotime(SB),NOSPLIT,$32
 	ADDL	BX, AX
 	ADCL	CX, DX			// add high bits with carry
 
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·getcontext(SB),NOSPLIT,$-4
@@ -175,7 +179,7 @@ TEXT runtime·sigreturn_tramp(SB),NOSPLIT,$0
 	INT	$0x80
 
 TEXT runtime·sigaction(SB),NOSPLIT,$24
-	LEAL	arg0+0(FP), SI
+	LEAL	sig+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - sig
@@ -232,7 +236,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$44
 // int32 lwp_create(void *context, uintptr flags, void *lwpid);
 TEXT runtime·lwp_create(SB),NOSPLIT,$16
 	MOVL	$0, 0(SP)
-	MOVL	context+0(FP), AX
+	MOVL	ctxt+0(FP), AX
 	MOVL	AX, 4(SP)		// arg 1 - context
 	MOVL	flags+4(FP), AX
 	MOVL	AX, 8(SP)		// arg 2 - flags
@@ -242,6 +246,7 @@ TEXT runtime·lwp_create(SB),NOSPLIT,$16
 	INT	$0x80
 	JCC	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
@@ -312,20 +317,23 @@ TEXT runtime·osyield(SB),NOSPLIT,$-4
 TEXT runtime·lwp_park(SB),NOSPLIT,$-4
 	MOVL	$434, AX		// sys__lwp_park
 	INT	$0x80
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·lwp_unpark(SB),NOSPLIT,$-4
 	MOVL	$321, AX		// sys__lwp_unpark
 	INT	$0x80
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·lwp_self(SB),NOSPLIT,$-4
 	MOVL	$311, AX		// sys__lwp_self
 	INT	$0x80
+	MOVL	AX, ret+0(FP)
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$28
-	LEAL	arg0+0(FP), SI
+	LEAL	mib+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - name
@@ -350,6 +358,7 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
@@ -358,6 +367,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·closeonexec(int32 fd)
diff --git a/src/pkg/runtime/sys_netbsd_amd64.s b/src/pkg/runtime/sys_netbsd_amd64.s
index 13b1cdc2f7..5b46dbe707 100644
--- a/src/pkg/runtime/sys_netbsd_amd64.s
+++ b/src/pkg/runtime/sys_netbsd_amd64.s
@@ -11,13 +11,14 @@
 
 // int32 lwp_create(void *context, uintptr flags, void *lwpid)
 TEXT runtime·lwp_create(SB),NOSPLIT,$0
-	MOVQ	context+0(FP), DI
+	MOVQ	ctxt+0(FP), DI
 	MOVQ	flags+8(FP), SI
 	MOVQ	lwpid+16(FP), DX
 	MOVL	$309, AX		// sys__lwp_create
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
@@ -46,29 +47,32 @@ TEXT runtime·osyield(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·lwp_park(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - abstime
-	MOVL	16(SP), SI		// arg 2 - unpark
-	MOVQ	24(SP), DX		// arg 3 - hint
-	MOVQ	32(SP), R10		// arg 4 - unparkhint
+	MOVQ	abstime+0(FP), DI		// arg 1 - abstime
+	MOVL	unpark+8(FP), SI		// arg 2 - unpark
+	MOVQ	hint+16(FP), DX		// arg 3 - hint
+	MOVQ	unparkhint+24(FP), R10		// arg 4 - unparkhint
 	MOVL	$434, AX		// sys__lwp_park
 	SYSCALL
+	MOVL	AX, ret+32(FP)
 	RET
 
 TEXT runtime·lwp_unpark(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - lwp
-	MOVL	16(SP), SI		// arg 2 - hint
+	MOVL	lwp+0(FP), DI		// arg 1 - lwp
+	MOVQ	hint+8(FP), SI		// arg 2 - hint
 	MOVL	$321, AX		// sys__lwp_unpark
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·lwp_self(SB),NOSPLIT,$0
 	MOVL	$311, AX		// sys__lwp_self
 	SYSCALL
+	MOVL	AX, ret+0(FP)
 	RET
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - exit status
+	MOVL	code+0(FP), DI		// arg 1 - exit status
 	MOVL	$1, AX			// sys_exit
 	SYSCALL
 	MOVL	$0xf1, 0xf1		// crash
@@ -81,33 +85,37 @@ TEXT runtime·exit1(SB),NOSPLIT,$-8
 	RET
 
 TEXT runtime·open(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 pathname
-	MOVL	16(SP), SI		// arg 2 flags
-	MOVL	20(SP), DX		// arg 3 mode
+	MOVQ	name+0(FP), DI		// arg 1 pathname
+	MOVL	mode+8(FP), SI		// arg 2 flags
+	MOVL	perm+12(FP), DX		// arg 3 mode
 	MOVL	$5, AX
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
+	MOVL	fd+0(FP), DI		// arg 1 fd
 	MOVL	$6, AX
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVL	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$3, AX
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - fd
-	MOVQ	16(SP), SI		// arg 2 - buf
-	MOVL	24(SP), DX		// arg 3 - nbyte
+	MOVQ	fd+0(FP), DI		// arg 1 - fd
+	MOVQ	p+8(FP), SI		// arg 2 - buf
+	MOVL	n+16(FP), DX		// arg 3 - nbyte
 	MOVL	$4, AX			// sys_write
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$16
@@ -136,9 +144,9 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·setitimer(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - which
-	MOVQ	16(SP), SI		// arg 2 - itv
-	MOVQ	24(SP), DX		// arg 3 - oitv
+	MOVL	mode+0(FP), DI		// arg 1 - which
+	MOVQ	new+8(FP), SI		// arg 2 - itv
+	MOVQ	old+16(FP), DX		// arg 3 - oitv
 	MOVL	$425, AX		// sys_setitimer
 	SYSCALL
 	RET
@@ -169,10 +177,11 @@ TEXT runtime·nanotime(SB),NOSPLIT,$32
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·getcontext(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 - context
+	MOVQ	ctxt+0(FP), DI		// arg 1 - context
 	MOVL	$307, AX		// sys_getcontext
 	SYSCALL
 	JCC	2(PC)
@@ -180,9 +189,9 @@ TEXT runtime·getcontext(SB),NOSPLIT,$-8
 	RET
 
 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 - how
-	MOVQ	16(SP), SI		// arg 2 - set
-	MOVQ	24(SP), DX		// arg 3 - oset
+	MOVL	mode+0(FP), DI		// arg 1 - how
+	MOVQ	new+8(FP), SI		// arg 2 - set
+	MOVQ	old+16(FP), DX		// arg 3 - oset
 	MOVL	$293, AX		// sys_sigprocmask
 	SYSCALL
 	JCC	2(PC)
@@ -198,9 +207,9 @@ TEXT runtime·sigreturn_tramp(SB),NOSPLIT,$-8
 	SYSCALL
 
 TEXT runtime·sigaction(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - signum
-	MOVQ	16(SP), SI		// arg 2 - nsa
-	MOVQ	24(SP), DX		// arg 3 - osa
+	MOVL	sig+0(FP), DI		// arg 1 - signum
+	MOVQ	new+8(FP), SI		// arg 2 - nsa
+	MOVQ	old+16(FP), DX		// arg 3 - osa
 					// arg 4 - tramp
 	LEAQ	runtime·sigreturn_tramp(SB), R10
 	MOVQ	$2, R8			// arg 5 - vers
@@ -244,23 +253,24 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$64
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - addr
-	MOVQ	16(SP), SI		// arg 2 - len
-	MOVL	24(SP), DX		// arg 3 - prot
-	MOVL	28(SP), R10		// arg 4 - flags
-	MOVL	32(SP), R8		// arg 5 - fd
-	MOVQ	36(SP), R9
+	MOVQ	addr+0(FP), DI		// arg 1 - addr
+	MOVQ	n+8(FP), SI		// arg 2 - len
+	MOVL	prot+16(FP), DX		// arg 3 - prot
+	MOVL	flags+20(FP), R10		// arg 4 - flags
+	MOVL	fd+24(FP), R8		// arg 5 - fd
+	MOVL	off+28(FP), R9
 	SUBQ	$16, SP
 	MOVQ	R9, 8(SP)		// arg 7 - offset (passed on stack)
 	MOVQ	$0, R9			// arg 6 - pad
 	MOVL	$197, AX		// sys_mmap
 	SYSCALL
 	ADDQ	$16, SP
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - addr
-	MOVQ	16(SP), SI		// arg 2 - len
+	MOVQ	addr+0(FP), DI		// arg 1 - addr
+	MOVQ	n+8(FP), SI		// arg 2 - len
 	MOVL	$73, AX			// sys_munmap
 	SYSCALL
 	JCC	2(PC)
@@ -270,8 +280,8 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
 	MOVQ	addr+0(FP), DI		// arg 1 - addr
-	MOVQ	len+8(FP), SI		// arg 2 - len
-	MOVQ	behav+16(FP), DX	// arg 3 - behav
+	MOVQ	n+8(FP), SI		// arg 2 - len
+	MOVL	flags+16(FP), DX	// arg 3 - behav
 	MOVQ	$75, AX			// sys_madvise
 	SYSCALL
 	// ignore failure - maybe pages are locked
@@ -297,18 +307,20 @@ TEXT runtime·settls(SB),NOSPLIT,$8
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - name
-	MOVL	16(SP), SI		// arg 2 - namelen
-	MOVQ	24(SP), DX		// arg 3 - oldp
-	MOVQ	32(SP), R10		// arg 4 - oldlenp
-	MOVQ	40(SP), R8		// arg 5 - newp
-	MOVQ	48(SP), R9		// arg 6 - newlen
+	MOVQ	mib+0(FP), DI		// arg 1 - name
+	MOVL	miblen+8(FP), SI		// arg 2 - namelen
+	MOVQ	out+16(FP), DX		// arg 3 - oldp
+	MOVQ	size+24(FP), R10		// arg 4 - oldlenp
+	MOVQ	dst+32(FP), R8		// arg 5 - newp
+	MOVQ	ndst+40(FP), R9		// arg 6 - newlen
 	MOVQ	$202, AX		// sys___sysctl
 	SYSCALL
-	JCC 3(PC)
+	JCC 4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // int32 runtime·kqueue(void)
@@ -318,25 +330,27 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
 TEXT runtime·kevent(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
-	MOVQ	32(SP), R10
-	MOVL	40(SP), R8
-	MOVQ	48(SP), R9
+	MOVL	fd+0(FP), DI
+	MOVQ	ev1+8(FP), SI
+	MOVL	nev1+16(FP), DX
+	MOVQ	ev2+24(FP), R10
+	MOVL	nev2+32(FP), R8
+	MOVQ	ts+40(FP), R9
 	MOVL	$435, AX
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd)
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVL	8(SP), DI	// fd
+	MOVL	fd+0(FP), DI	// fd
 	MOVQ	$2, SI		// F_SETFD
 	MOVQ	$1, DX		// FD_CLOEXEC
 	MOVL	$92, AX		// fcntl
diff --git a/src/pkg/runtime/sys_netbsd_arm.s b/src/pkg/runtime/sys_netbsd_arm.s
index acf01cf3bb..bf133a2100 100644
--- a/src/pkg/runtime/sys_netbsd_arm.s
+++ b/src/pkg/runtime/sys_netbsd_arm.s
@@ -28,11 +28,13 @@ TEXT runtime·open(SB),NOSPLIT,$-8
 	MOVW 4(FP), R1
 	MOVW 8(FP), R2
 	SWI $0xa00005
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-8
 	MOVW 0(FP), R0
 	SWI $0xa00006
+	MOVW	R0, ret+4(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-8
@@ -40,6 +42,7 @@ TEXT runtime·read(SB),NOSPLIT,$-8
 	MOVW 4(FP), R1
 	MOVW 8(FP), R2
 	SWI $0xa00003
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-4
@@ -47,14 +50,16 @@ TEXT runtime·write(SB),NOSPLIT,$-4
 	MOVW	4(FP), R1	// arg 2 - buf
 	MOVW	8(FP), R2	// arg 3 - nbyte
 	SWI $0xa00004	// sys_write
+	MOVW	R0, ret+12(FP)
 	RET
 
 // int32 lwp_create(void *context, uintptr flags, void *lwpid)
 TEXT runtime·lwp_create(SB),NOSPLIT,$0
-	MOVW context+0(FP), R0
+	MOVW ctxt+0(FP), R0
 	MOVW flags+4(FP), R1
 	MOVW lwpid+8(FP), R2
 	SWI $0xa00135	// sys__lwp_create
+	MOVW	R0, ret+12(FP)
 	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$0
@@ -67,16 +72,19 @@ TEXT runtime·lwp_park(SB),NOSPLIT,$0
 	MOVW 8(FP), R2	// arg 3 - hint
 	MOVW 12(FP), R3	// arg 4 - unparkhint
 	SWI $0xa001b2	// sys__lwp_park
+	MOVW	R0, ret+16(FP)
 	RET
 
 TEXT runtime·lwp_unpark(SB),NOSPLIT,$0
 	MOVW	0(FP), R0	// arg 1 - lwp
 	MOVW	4(FP), R1	// arg 2 - hint
 	SWI $0xa00141 // sys__lwp_unpark
+	MOVW	R0, ret+8(FP)
 	RET
 
 TEXT runtime·lwp_self(SB),NOSPLIT,$0
 	SWI $0xa00137	// sys__lwp_self
+	MOVW	R0, ret+0(FP)
 	RET
 
 TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
@@ -153,9 +161,8 @@ TEXT runtime·nanotime(SB), NOSPLIT, $32
 	ADD.S R2, R0
 	ADC R4, R1
 
-	MOVW 0(FP), R3
-	MOVW R0, 0(R3)
-	MOVW R1, 4(R3)
+	MOVW R0, ret_lo+0(FP)
+	MOVW R1, ret_hi+4(FP)
 	RET
 
 TEXT runtime·getcontext(SB),NOSPLIT,$-4
@@ -249,6 +256,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$12
 	ADD $4, R13 // pass arg 5 and arg 6 on stack
 	SWI $0xa000c5	// sys_mmap
 	SUB $4, R13
+	MOVW	R0, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
@@ -287,12 +295,14 @@ TEXT runtime·sysctl(SB),NOSPLIT,$8
 	ADD $4, R13	// pass arg 5 and 6 on stack
 	SWI $0xa000ca	// sys___sysctl
 	SUB $4, R13
+	MOVW	R0, ret+24(FP)
 	RET
 
 // int32 runtime·kqueue(void)
 TEXT runtime·kqueue(SB),NOSPLIT,$0
 	SWI $0xa00158	// sys_kqueue
 	RSB.CS $0, R0
+	MOVW	R0, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
@@ -309,6 +319,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$8
 	SWI $0xa001b3	// sys___kevent50
 	RSB.CS $0, R0
 	SUB $4, R13
+	MOVW	R0, ret+24(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd)
diff --git a/src/pkg/runtime/sys_openbsd_386.s b/src/pkg/runtime/sys_openbsd_386.s
index a94c4e4a8f..596d45a023 100644
--- a/src/pkg/runtime/sys_openbsd_386.s
+++ b/src/pkg/runtime/sys_openbsd_386.s
@@ -30,21 +30,25 @@ TEXT runtime·exit1(SB),NOSPLIT,$8
 TEXT runtime·open(SB),NOSPLIT,$-4
 	MOVL	$5, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-4
 	MOVL	$6, AX
 	INT	$0x80
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-4
 	MOVL	$3, AX
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-4
 	MOVL	$4, AX			// sys_write
 	INT	$0x80
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$24
@@ -78,7 +82,7 @@ TEXT runtime·raise(SB),NOSPLIT,$12
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$36
-	LEAL	arg0+0(FP), SI
+	LEAL	addr+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - addr
@@ -93,6 +97,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$36
 	STOSL
 	MOVL	$197, AX		// sys_mmap
 	INT	$0x80
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$-4
@@ -151,9 +156,8 @@ TEXT runtime·nanotime(SB),NOSPLIT,$32
 	ADDL	BX, AX
 	ADCL	CX, DX			// add high bits with carry
 
-	MOVL	ret+0(FP), DI
-	MOVL	AX, 0(DI)
-	MOVL	DX, 4(DI)
+	MOVL	AX, ret_lo+0(FP)
+	MOVL	DX, ret_hi+4(FP)
 	RET
 
 TEXT runtime·sigaction(SB),NOSPLIT,$-4
@@ -168,7 +172,7 @@ TEXT runtime·sigprocmask(SB),NOSPLIT,$-4
 	INT	$0x80
 	JAE	2(PC)
 	MOVL	$0xf1, 0xf1		// crash
-	MOVL	AX, oset+0(FP)
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT,$44
@@ -222,22 +226,22 @@ sigtramp_ret:
 TEXT runtime·tfork(SB),NOSPLIT,$12
 
 	// Copy mp, gp and fn from the parent stack onto the child stack.
-	MOVL	params+4(FP), AX
+	MOVL	psize+4(FP), AX
 	MOVL	8(AX), CX		// tf_stack
 	SUBL	$16, CX
 	MOVL	CX, 8(AX)
-	MOVL	mm+12(FP), SI
+	MOVL	mm+8(FP), SI
 	MOVL	SI, 0(CX)
-	MOVL	gg+16(FP), SI
+	MOVL	gg+12(FP), SI
 	MOVL	SI, 4(CX)
-	MOVL	fn+20(FP), SI
+	MOVL	fn+16(FP), SI
 	MOVL	SI, 8(CX)
 	MOVL	$1234, 12(CX)
 
 	MOVL	$0, 0(SP)		// syscall gap
-	MOVL	params+4(FP), AX
+	MOVL	param+0(FP), AX
 	MOVL	AX, 4(SP)		// arg 1 - param
-	MOVL	psize+8(FP), AX
+	MOVL	psize+4(FP), AX
 	MOVL	AX, 8(SP)		// arg 2 - psize
 	MOVL	$8, AX			// sys___tfork
 	INT	$0x80
@@ -245,15 +249,15 @@ TEXT runtime·tfork(SB),NOSPLIT,$12
 	// Return if tfork syscall failed.
 	JCC	5(PC)
 	NEGL	AX
-	MOVL	ret+0(FP), DX
-	MOVL	AX, 0(DX)
+	MOVL	AX, ret_lo+20(FP)
+	MOVL	$-1, ret_hi+24(FP)
 	RET
 
 	// In parent, return.
 	CMPL	AX, $0
 	JEQ	4(PC)
-	MOVL	ret+0(FP), DX
-	MOVL	AX, 0(DX)
+	MOVL	AX, ret_lo+20(FP)
+	MOVL	$0, ret_hi+24(FP)
 	RET
 
 	// Paranoia: check that SP is as we expect.
@@ -333,15 +337,17 @@ TEXT runtime·osyield(SB),NOSPLIT,$-4
 TEXT runtime·thrsleep(SB),NOSPLIT,$-4
 	MOVL	$94, AX			// sys___thrsleep
 	INT	$0x80
+	MOVL	AX, ret+20(FP)
 	RET
 
 TEXT runtime·thrwakeup(SB),NOSPLIT,$-4
 	MOVL	$301, AX		// sys___thrwakeup
 	INT	$0x80
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$28
-	LEAL	arg0+0(FP), SI
+	LEAL	mib+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
 	MOVSL				// arg 1 - name
@@ -352,10 +358,12 @@ TEXT runtime·sysctl(SB),NOSPLIT,$28
 	MOVSL				// arg 6 - newlen
 	MOVL	$202, AX		// sys___sysctl
 	INT	$0x80
-	JCC	3(PC)
+	JCC	4(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·kqueue(void);
@@ -364,6 +372,7 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
@@ -372,6 +381,7 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
 	INT	$0x80
 	JAE	2(PC)
 	NEGL	AX
+	MOVL	AX, ret+24(FP)
 	RET
 
 // int32 runtime·closeonexec(int32 fd);
diff --git a/src/pkg/runtime/sys_openbsd_amd64.s b/src/pkg/runtime/sys_openbsd_amd64.s
index dac90eae10..eb5010164c 100644
--- a/src/pkg/runtime/sys_openbsd_amd64.s
+++ b/src/pkg/runtime/sys_openbsd_amd64.s
@@ -25,13 +25,15 @@ TEXT runtime·tfork(SB),NOSPLIT,$32
 	SYSCALL
 
 	// Return if tfork syscall failed.
-	JCC	3(PC)
+	JCC	4(PC)
 	NEGQ	AX
+	MOVQ	AX, ret+40(FP)
 	RET
 
 	// In parent, return.
 	CMPL	AX, $0
-	JEQ	2(PC)
+	JEQ	3(PC)
+	MOVQ	AX, ret+40(FP)
 	RET
 
 	// Set FS to point at m->tls.
@@ -59,25 +61,27 @@ TEXT runtime·osyield(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·thrsleep(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - ident
-	MOVL	16(SP), SI		// arg 2 - clock_id
-	MOVQ	24(SP), DX		// arg 3 - tp
-	MOVQ	32(SP), R10		// arg 4 - lock
-	MOVQ	40(SP), R8		// arg 5 - abort
+	MOVQ	ident+0(FP), DI		// arg 1 - ident
+	MOVL	clock_id+8(FP), SI		// arg 2 - clock_id
+	MOVQ	tsp+16(FP), DX		// arg 3 - tp
+	MOVQ	lock+24(FP), R10		// arg 4 - lock
+	MOVQ	abort+32(FP), R8		// arg 5 - abort
 	MOVL	$94, AX			// sys___thrsleep
 	SYSCALL
+	MOVL	AX, ret+40(FP)
 	RET
 
 TEXT runtime·thrwakeup(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - ident
-	MOVL	16(SP), SI		// arg 2 - n
+	MOVQ	ident+0(FP), DI		// arg 1 - ident
+	MOVL	n+8(FP), SI		// arg 2 - n
 	MOVL	$301, AX		// sys___thrwakeup
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - exit status
+	MOVL	code+0(FP), DI		// arg 1 - exit status
 	MOVL	$1, AX			// sys_exit
 	SYSCALL
 	MOVL	$0xf1, 0xf1		// crash
@@ -91,33 +95,37 @@ TEXT runtime·exit1(SB),NOSPLIT,$-8
 	RET
 
 TEXT runtime·open(SB),NOSPLIT,$-8
-	MOVQ	8(SP), DI		// arg 1 pathname
-	MOVL	16(SP), SI		// arg 2 flags
-	MOVL	20(SP), DX		// arg 3 mode
+	MOVQ	name+0(FP), DI		// arg 1 pathname
+	MOVL	mode+8(FP), SI		// arg 2 flags
+	MOVL	perm+12(FP), DX		// arg 3 mode
 	MOVL	$5, AX
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
+	MOVL	fd+0(FP), DI		// arg 1 fd
 	MOVL	$6, AX
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·read(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 fd
-	MOVQ	16(SP), SI		// arg 2 buf
-	MOVL	24(SP), DX		// arg 3 count
+	MOVL	fd+0(FP), DI		// arg 1 fd
+	MOVQ	p+8(FP), SI		// arg 2 buf
+	MOVL	n+16(FP), DX		// arg 3 count
 	MOVL	$3, AX
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - fd
-	MOVQ	16(SP), SI		// arg 2 - buf
-	MOVL	24(SP), DX		// arg 3 - nbyte
+	MOVQ	fd+0(FP), DI		// arg 1 - fd
+	MOVQ	p+8(FP), SI		// arg 2 - buf
+	MOVL	n+16(FP), DX		// arg 3 - nbyte
 	MOVL	$4, AX			// sys_write
 	SYSCALL
+	MOVL	AX, ret+24(FP)
 	RET
 
 TEXT runtime·usleep(SB),NOSPLIT,$16
@@ -146,9 +154,9 @@ TEXT runtime·raise(SB),NOSPLIT,$16
 	RET
 
 TEXT runtime·setitimer(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - which
-	MOVQ	16(SP), SI		// arg 2 - itv
-	MOVQ	24(SP), DX		// arg 3 - oitv
+	MOVL	mode+0(FP), DI		// arg 1 - which
+	MOVQ	new+8(FP), SI		// arg 2 - itv
+	MOVQ	old+16(FP), DX		// arg 3 - oitv
 	MOVL	$69, AX			// sys_setitimer
 	SYSCALL
 	RET
@@ -179,12 +187,13 @@ TEXT runtime·nanotime(SB),NOSPLIT,$24
 	// return nsec in AX
 	IMULQ	$1000000000, AX
 	ADDQ	DX, AX
+	MOVQ	AX, ret+0(FP)
 	RET
 
 TEXT runtime·sigaction(SB),NOSPLIT,$-8
-	MOVL	8(SP), DI		// arg 1 - signum
-	MOVQ	16(SP), SI		// arg 2 - nsa
-	MOVQ	24(SP), DX		// arg 3 - osa
+	MOVL	sig+0(FP), DI		// arg 1 - signum
+	MOVQ	new+8(FP), SI		// arg 2 - nsa
+	MOVQ	old+16(FP), DX		// arg 3 - osa
 	MOVL	$46, AX
 	SYSCALL
 	JCC	2(PC)
@@ -192,13 +201,13 @@ TEXT runtime·sigaction(SB),NOSPLIT,$-8
 	RET
 
 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
-	MOVL	8(SP), DI		// arg 1 - how
-	MOVL	12(SP), SI		// arg 2 - set
+	MOVL	mode+0(FP), DI		// arg 1 - how
+	MOVL	new+4(FP), SI		// arg 2 - set
 	MOVL	$48, AX			// sys_sigprocmask
 	SYSCALL
 	JCC	2(PC)
 	MOVL	$0xf1, 0xf1		// crash
-	MOVL	AX, oset+0(FP)		// Return oset
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT,$64
@@ -235,23 +244,24 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$64
 	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - addr
-	MOVQ	16(SP), SI		// arg 2 - len
-	MOVL	24(SP), DX		// arg 3 - prot
-	MOVL	28(SP), R10		// arg 4 - flags
-	MOVL	32(SP), R8		// arg 5 - fd
-	MOVQ	36(SP), R9
+	MOVQ	addr+0(FP), DI		// arg 1 - addr
+	MOVQ	n+8(FP), SI		// arg 2 - len
+	MOVL	prot+16(FP), DX		// arg 3 - prot
+	MOVL	flags+20(FP), R10		// arg 4 - flags
+	MOVL	fd+24(FP), R8		// arg 5 - fd
+	MOVL	off+28(FP), R9
 	SUBQ	$16, SP
 	MOVQ	R9, 8(SP)		// arg 7 - offset (passed on stack)
 	MOVQ	$0, R9			// arg 6 - pad
 	MOVL	$197, AX
 	SYSCALL
 	ADDQ	$16, SP
+	MOVQ	AX, ret+32(FP)
 	RET
 
 TEXT runtime·munmap(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - addr
-	MOVQ	16(SP), SI		// arg 2 - len
+	MOVQ	addr+0(FP), DI		// arg 1 - addr
+	MOVQ	n+8(FP), SI		// arg 2 - len
 	MOVL	$73, AX			// sys_munmap
 	SYSCALL
 	JCC	2(PC)
@@ -260,8 +270,8 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
 
 TEXT runtime·madvise(SB),NOSPLIT,$0
 	MOVQ	addr+0(FP), DI		// arg 1 - addr
-	MOVQ	len+8(FP), SI		// arg 2 - len
-	MOVQ	behav+16(FP), DX	// arg 3 - behav
+	MOVQ	n+8(FP), SI		// arg 2 - len
+	MOVL	flags+16(FP), DX	// arg 3 - behav
 	MOVQ	$75, AX			// sys_madvise
 	SYSCALL
 	// ignore failure - maybe pages are locked
@@ -287,18 +297,20 @@ TEXT runtime·settls(SB),NOSPLIT,$0
 	RET
 
 TEXT runtime·sysctl(SB),NOSPLIT,$0
-	MOVQ	8(SP), DI		// arg 1 - name
-	MOVL	16(SP), SI		// arg 2 - namelen
-	MOVQ	24(SP), DX		// arg 3 - oldp
-	MOVQ	32(SP), R10		// arg 4 - oldlenp
-	MOVQ	40(SP), R8		// arg 5 - newp
-	MOVQ	48(SP), R9		// arg 6 - newlen
+	MOVQ	mib+0(FP), DI		// arg 1 - name
+	MOVL	miblen+8(FP), SI		// arg 2 - namelen
+	MOVQ	out+16(FP), DX		// arg 3 - oldp
+	MOVQ	size+24(FP), R10		// arg 4 - oldlenp
+	MOVQ	dst+32(FP), R8		// arg 5 - newp
+	MOVQ	ndst+40(FP), R9		// arg 6 - newlen
 	MOVQ	$202, AX		// sys___sysctl
 	SYSCALL
-	JCC	3(PC)
+	JCC	4(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 	MOVL	$0, AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // int32 runtime·kqueue(void);
@@ -310,25 +322,27 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
 TEXT runtime·kevent(SB),NOSPLIT,$0
-	MOVL	8(SP), DI
-	MOVQ	16(SP), SI
-	MOVL	24(SP), DX
-	MOVQ	32(SP), R10
-	MOVL	40(SP), R8
-	MOVQ	48(SP), R9
+	MOVL	fd+0(FP), DI
+	MOVQ	ev1+8(FP), SI
+	MOVL	nev1+16(FP), DX
+	MOVQ	ev2+24(FP), R10
+	MOVL	nev2+32(FP), R8
+	MOVQ	ts+40(FP), R9
 	MOVL	$72, AX
 	SYSCALL
 	JCC	2(PC)
 	NEGQ	AX
+	MOVL	AX, ret+48(FP)
 	RET
 
 // void runtime·closeonexec(int32 fd);
 TEXT runtime·closeonexec(SB),NOSPLIT,$0
-	MOVL	8(SP), DI	// fd
+	MOVL	fd+0(FP), DI	// fd
 	MOVQ	$2, SI		// F_SETFD
 	MOVQ	$1, DX		// FD_CLOEXEC
 	MOVL	$92, AX		// fcntl
diff --git a/src/pkg/runtime/sys_plan9_386.s b/src/pkg/runtime/sys_plan9_386.s
index 5e8c7420e2..08d0b32395 100644
--- a/src/pkg/runtime/sys_plan9_386.s
+++ b/src/pkg/runtime/sys_plan9_386.s
@@ -12,31 +12,49 @@ TEXT runtime·setldt(SB),NOSPLIT,$0
 TEXT runtime·open(SB),NOSPLIT,$0
 	MOVL    $14, AX
 	INT     $64
+	MOVL	AX, ret+12(FP)
 	RET
 
 TEXT runtime·pread(SB),NOSPLIT,$0
 	MOVL    $50, AX
 	INT     $64
+	MOVL	AX, ret+20(FP)
 	RET
 
 TEXT runtime·pwrite(SB),NOSPLIT,$0
 	MOVL    $51, AX
 	INT     $64
+	MOVL	AX, ret+20(FP)
 	RET
 
-TEXT runtime·seek(SB),NOSPLIT,$0
+// int32 _seek(int64*, int32, int64, int32)
+TEXT _seek<>(SB),NOSPLIT,$0
 	MOVL	$39, AX
 	INT	$64
-	CMPL	AX, $-1
-	JNE	4(PC)
-	MOVL	a+0(FP), CX
-	MOVL	AX, 0(CX)
-	MOVL	AX, 4(CX)
+	RET
+
+TEXT runtime·seek(SB),NOSPLIT,$24
+	LEAL	ret+16(FP), AX
+	MOVL	fd+0(FP), BX
+	MOVL	offset_lo+4(FP), CX
+	MOVL	offset_hi+8(FP), DX
+	MOVL	whence+12(FP), SI
+	MOVL	AX, 0(SP)
+	MOVL	BX, 4(SP)
+	MOVL	CX, 8(SP)
+	MOVL	DX, 12(SP)
+	MOVL	SI, 16(SP)
+	CALL	_seek<>(SB)
+	CMPL	AX, $0
+	JGE	3(PC)
+	MOVL	$-1, ret_lo+16(FP)
+	MOVL	$-1, ret_hi+20(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVL	$4, AX
 	INT	$64
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·exits(SB),NOSPLIT,$0
@@ -47,50 +65,62 @@ TEXT runtime·exits(SB),NOSPLIT,$0
 TEXT runtime·brk_(SB),NOSPLIT,$0
 	MOVL    $24, AX
 	INT     $64
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·sleep(SB),NOSPLIT,$0
 	MOVL    $17, AX
 	INT     $64
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
 	MOVL	$37, AX
 	INT	$64
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
 	MOVL	$52, AX
 	INT	$64
+	MOVL	AX, ret+8(FP)
 	RET
 
-TEXT runtime·nsec(SB),NOSPLIT,$0
+TEXT nsec<>(SB),NOSPLIT,$0
 	MOVL	$53, AX
 	INT	$64
-	CMPL	AX, $-1
-	JNE	4(PC)
-	MOVL	a+0(FP), CX
-	MOVL	AX, 0(CX)
-	MOVL	AX, 4(CX)
+	RET
+
+TEXT runtime·nsec(SB),NOSPLIT,$8
+	LEAL	ret+4(FP), AX
+	MOVL	AX, 0(SP)
+	CALL	nsec<>(SB)
+	CMPL	AX, $0
+	JGE	3(PC)
+	MOVL	$-1, ret_lo+4(FP)
+	MOVL	$-1, ret_hi+8(FP)
 	RET
 
 TEXT runtime·notify(SB),NOSPLIT,$0
 	MOVL	$28, AX
 	INT	$64
+	MOVL	AX, ret+4(FP)
 	RET
 
 TEXT runtime·noted(SB),NOSPLIT,$0
 	MOVL	$29, AX
 	INT	$64
+	MOVL	AX, ret+4(FP)
 	RET
 	
 TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
 	MOVL	$38, AX
 	INT	$64
+	MOVL	AX, ret+8(FP)
 	RET
 	
 TEXT runtime·rfork(SB),NOSPLIT,$0
-	MOVL    $19, AX // rfork
+	MOVL	$19, AX // rfork
 	MOVL	stack+8(SP), CX
 	MOVL	mm+12(SP), BX	// m
 	MOVL	gg+16(SP), DX	// g
@@ -99,7 +129,8 @@ TEXT runtime·rfork(SB),NOSPLIT,$0
 
 	// In parent, return.
 	CMPL	AX, $0
-	JEQ	2(PC)
+	JEQ	3(PC)
+	MOVL	AX, ret+20(FP)
 	RET
 
 	// set SP to be on the new child stack
@@ -127,6 +158,7 @@ TEXT runtime·rfork(SB),NOSPLIT,$0
 	
 	CALL	SI	// fn()
 	CALL	runtime·exit(SB)
+	MOVL	AX, ret+20(FP)
 	RET
 
 // void sigtramp(void *ureg, int8 *note)
@@ -195,17 +227,17 @@ TEXT runtime·errstr(SB),NOSPLIT,$0
 	MOVL	g(AX), BX
 	MOVL	g_m(BX), BX
 	MOVL	m_errstr(BX), CX
-	MOVL	CX, 4(SP)
-	MOVL	$ERRMAX, 8(SP)
+	MOVL	CX, ret_base+0(FP)
+	MOVL	$ERRMAX, ret_len+4(FP)
 	MOVL	$41, AX
 	INT	$64
 
 	// syscall requires caller-save
-	MOVL	4(SP), CX
+	MOVL	ret_base+0(FP), CX
 
 	// push the argument
 	PUSHL	CX
 	CALL	runtime·findnull(SB)
 	POPL	CX
-	MOVL	AX, 8(SP)
+	MOVL	AX, ret_len+4(FP)
 	RET
diff --git a/src/pkg/runtime/sys_plan9_amd64.s b/src/pkg/runtime/sys_plan9_amd64.s
index 8f4a5c05ec..c8fa444996 100644
--- a/src/pkg/runtime/sys_plan9_amd64.s
+++ b/src/pkg/runtime/sys_plan9_amd64.s
@@ -12,16 +12,19 @@ TEXT runtime·setldt(SB),NOSPLIT,$0
 TEXT runtime·open(SB),NOSPLIT,$0
 	MOVQ	$14, BP
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·pread(SB),NOSPLIT,$0
 	MOVQ	$50, BP
 	SYSCALL
+	MOVL	AX, ret+32(FP)
 	RET
 
 TEXT runtime·pwrite(SB),NOSPLIT,$0
 	MOVQ	$51, BP
 	SYSCALL
+	MOVL	AX, ret+32(FP)
 	RET
 
 // int32 _seek(int64*, int32, int64, int32)
@@ -31,25 +34,26 @@ TEXT _seek<>(SB),NOSPLIT,$0
 	RET
 
 // int64 seek(int32, int64, int32)
-TEXT runtime·seek(SB),NOSPLIT,$56
-	LEAQ	new+48(SP), CX
-	MOVQ	CX, 0(SP)
-	MOVQ	fd+0(FP), CX
-	MOVQ	CX, 8(SP)
-	MOVQ	off+8(FP), CX
+// Convenience wrapper around _seek, the actual system call.
+TEXT runtime·seek(SB),NOSPLIT,$32
+	LEAQ	$ret+24(FP), AX
+	MOVL	fd+0(FP), BX
+	MOVQ	offset+8(FP), CX
+	MOVL	whence+16(FP), DX
+	MOVQ	AX, 0(SP)
+	MOVL	BX, 8(SP)
 	MOVQ	CX, 16(SP)
-	MOVQ	whence+16(FP), CX
-	MOVQ	CX, 24(SP)
+	MOVL	DX, 24(SP)
 	CALL	_seek<>(SB)
 	CMPL	AX, $0
 	JGE	2(PC)
-	MOVQ	$-1, new+48(SP)
-	MOVQ	new+48(SP), AX
+	MOVQ	$-1, ret+24(FP)
 	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVQ	$4, BP
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·exits(SB),NOSPLIT,$0
@@ -60,41 +64,49 @@ TEXT runtime·exits(SB),NOSPLIT,$0
 TEXT runtime·brk_(SB),NOSPLIT,$0
 	MOVQ	$24, BP
 	SYSCALL
+	MOVQ	AX, ret+8(FP)
 	RET
 
 TEXT runtime·sleep(SB),NOSPLIT,$0
 	MOVQ	$17, BP
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
 	MOVQ	$37, BP
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
 	MOVQ	$52, BP
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·nsec(SB),NOSPLIT,$0
 	MOVQ	$53, BP
 	SYSCALL
+	MOVQ	AX, ret+8(FP)
 	RET
 
 TEXT runtime·notify(SB),NOSPLIT,$0
 	MOVQ	$28, BP
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 
 TEXT runtime·noted(SB),NOSPLIT,$0
 	MOVQ	$29, BP
 	SYSCALL
+	MOVL	AX, ret+8(FP)
 	RET
 	
 TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
 	MOVQ	$38, BP
 	SYSCALL
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT runtime·rfork(SB),NOSPLIT,$0
@@ -103,7 +115,8 @@ TEXT runtime·rfork(SB),NOSPLIT,$0
 
 	// In parent, return.
 	CMPQ	AX, $0
-	JEQ	2(PC)
+	JEQ	3(PC)
+	MOVL	AX, ret+40(FP)
 	RET
 
 	// In child on forked stack.
@@ -132,6 +145,7 @@ TEXT runtime·rfork(SB),NOSPLIT,$0
 	
 	CALL	SI	// fn()
 	CALL	runtime·exit(SB)
+	MOVL	AX, ret+40(FP)
 	RET
 
 // This is needed by asm_amd64.s
@@ -208,17 +222,17 @@ TEXT runtime·errstr(SB),NOSPLIT,$0
 	MOVQ	g(AX), BX
 	MOVQ	g_m(BX), BX
 	MOVQ	m_errstr(BX), CX
-	MOVQ	CX, 8(SP)
-	MOVQ	$ERRMAX, 16(SP)
+	MOVQ	CX, ret_base+0(FP)
+	MOVQ	$ERRMAX, ret_len+8(FP)
 	MOVQ	$41, BP
 	SYSCALL
 
 	// syscall requires caller-save
-	MOVQ	8(SP), CX
+	MOVQ	ret_base+0(FP), CX
 
 	// push the argument
 	PUSHQ	CX
 	CALL	runtime·findnull(SB)
 	POPQ	CX
-	MOVQ	AX, 16(SP)
+	MOVQ	AX, ret_len+8(FP)
 	RET
diff --git a/src/pkg/runtime/sys_solaris_amd64.s b/src/pkg/runtime/sys_solaris_amd64.s
index 1b18c8d9eb..60447d3499 100644
--- a/src/pkg/runtime/sys_solaris_amd64.s
+++ b/src/pkg/runtime/sys_solaris_amd64.s
@@ -44,6 +44,7 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$0
 	IMULQ	$1000000000, AX	// multiply into nanoseconds
 	ADDQ	8(SP), AX	// tv_nsec, offset should be stable.
 	ADDQ	$64, SP
+	MOVQ	AX, ret+0(FP)
 	RET
 
 // pipe(3c) wrapper that returns fds in AX, DX.
@@ -137,6 +138,7 @@ TEXT runtime·tstart_sysvicall(SB),NOSPLIT,$0
 	CALL	runtime·mstart(SB)
 
 	XORL	AX, AX			// return 0 == success
+	MOVL	AX, ret+8(FP)
 	RET
 
 // Careful, this is called by __sighndlr, a libc function. We must preserve
@@ -274,7 +276,7 @@ exit:
 // Called from runtime·usleep (Go). Can be called on Go stack, on OS stack,
 // can also be called in cgo callback path without a g->m.
 TEXT runtime·usleep1(SB),NOSPLIT,$0
-	MOVL	us+0(FP), DI
+	MOVL	usec+0(FP), DI
 	MOVQ	$runtime·usleep2(SB), AX // to hide from 6l
 
 	// Execute call on m->g0.
diff --git a/src/pkg/runtime/sys_windows_386.s b/src/pkg/runtime/sys_windows_386.s
index f2c2a4128c..2a1f4f929c 100644
--- a/src/pkg/runtime/sys_windows_386.s
+++ b/src/pkg/runtime/sys_windows_386.s
@@ -7,7 +7,7 @@
 
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall(SB),NOSPLIT,$0
-	MOVL	c+0(FP), BX
+	MOVL	fn+0(FP), BX
 
 	// SetLastError(0).
 	MOVL	$0, 0x34(FS)
@@ -29,7 +29,7 @@ TEXT runtime·asmstdcall(SB),NOSPLIT,$0
 	MOVL	BP, SP
 
 	// Return result.
-	MOVL	c+0(FP), BX
+	MOVL	fn+0(FP), BX
 	MOVL	AX, libcall_r1(BX)
 	MOVL	DX, libcall_r2(BX)
 
@@ -62,6 +62,7 @@ TEXT	runtime·badsignal2(SB),NOSPLIT,$24
 // faster get/set last error
 TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MOVL	0x34(FS), AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 TEXT runtime·setlasterror(SB),NOSPLIT,$0
@@ -301,7 +302,7 @@ TEXT runtime·setldt(SB),NOSPLIT,$0
 
 // Sleep duration is in 100ns units.
 TEXT runtime·usleep1(SB),NOSPLIT,$0
-	MOVL	duration+0(FP), BX
+	MOVL	usec+0(FP), BX
 	MOVL	$runtime·usleep2(SB), AX // to hide from 8l
 
 	// Execute call on m->g0 stack, in case we are not actually
@@ -323,7 +324,7 @@ TEXT runtime·usleep1(SB),NOSPLIT,$0
 	MOVL	SI, m_libcallg(BP)
 	// sp must be the last, because once async cpu profiler finds
 	// all three values to be non-zero, it will use them
-	LEAL	4(SP), SI
+	LEAL	usec+0(FP), SI
 	MOVL	SI, m_libcallsp(BP)
 
 	MOVL	m_g0(BP), SI
diff --git a/src/pkg/runtime/sys_windows_amd64.s b/src/pkg/runtime/sys_windows_amd64.s
index 73b1ba6d8c..60302622cb 100644
--- a/src/pkg/runtime/sys_windows_amd64.s
+++ b/src/pkg/runtime/sys_windows_amd64.s
@@ -87,6 +87,7 @@ TEXT runtime·badsignal2(SB),NOSPLIT,$48
 TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MOVQ	0x30(GS), AX
 	MOVL	0x68(AX), AX
+	MOVL	AX, ret+0(FP)
 	RET
 
 TEXT runtime·setlasterror(SB),NOSPLIT,$0
@@ -323,7 +324,7 @@ TEXT runtime·settls(SB),NOSPLIT,$0
 
 // Sleep duration is in 100ns units.
 TEXT runtime·usleep1(SB),NOSPLIT,$0
-	MOVL	duration+0(FP), BX
+	MOVL	usec+0(FP), BX
 	MOVQ	$runtime·usleep2(SB), AX // to hide from 6l
 
 	// Execute call on m->g0 stack, in case we are not actually
@@ -345,7 +346,7 @@ TEXT runtime·usleep1(SB),NOSPLIT,$0
 	MOVQ	R12, m_libcallg(R13)
 	// sp must be the last, because once async cpu profiler finds
 	// all three values to be non-zero, it will use them
-	LEAQ	8(SP), R12
+	LEAQ	usec+0(FP), R12
 	MOVQ	R12, m_libcallsp(R13)
 
 	MOVQ	m_g0(R13), R14
diff --git a/src/pkg/runtime/vlop_386.s b/src/pkg/runtime/vlop_386.s
index 9783fdc936..f3d792c724 100644
--- a/src/pkg/runtime/vlop_386.s
+++ b/src/pkg/runtime/vlop_386.s
@@ -29,7 +29,7 @@
  * C runtime for 64-bit divide.
  */
 
-// _mul64x32(r *uint64, a uint64, b uint32)
+// _mul64x32(r *uint64, a uint64, b uint32) uint32
 // sets *r = low 64 bits of 96-bit product a*b; returns high 32 bits.
 TEXT _mul64by32(SB), NOSPLIT, $0
 	MOVL	r+0(FP), CX
@@ -43,6 +43,7 @@ TEXT _mul64by32(SB), NOSPLIT, $0
 	ADCL	$0, DX
 	MOVL	BX, 4(CX)
 	MOVL	DX, AX
+	MOVL	AX, ret+16(FP)
 	RET
 
 TEXT _div64by32(SB), NOSPLIT, $0
@@ -51,4 +52,5 @@ TEXT _div64by32(SB), NOSPLIT, $0
 	MOVL	a+4(FP), DX
 	DIVL	b+8(FP)
 	MOVL	DX, 0(CX)
+	MOVL	AX, ret+16(FP)
 	RET
diff --git a/src/pkg/runtime/vlop_arm.s b/src/pkg/runtime/vlop_arm.s
index 02bab3107e..3b5243c3d2 100644
--- a/src/pkg/runtime/vlop_arm.s
+++ b/src/pkg/runtime/vlop_arm.s
@@ -31,18 +31,17 @@ arg=0
 /* replaced use of R10 by R11 because the former can be the data segment base register */
 
 TEXT _mulv(SB), NOSPLIT, $0
-	MOVW	0(FP), R0
-	MOVW	4(FP), R2	/* l0 */
-	MOVW	8(FP), R11	/* h0 */
-	MOVW	12(FP), R4	/* l1 */
-	MOVW	16(FP), R5	/* h1 */
+	MOVW	l0+0(FP), R2	/* l0 */
+	MOVW	h0+4(FP), R11	/* h0 */
+	MOVW	l1+8(FP), R4	/* l1 */
+	MOVW	h1+12(FP), R5	/* h1 */
 	MULLU	R4, R2, (R7,R6)
 	MUL	R11, R4, R8
 	ADD	R8, R7
 	MUL	R2, R5, R8
 	ADD	R8, R7
-	MOVW	R6, 0(R(arg))
-	MOVW	R7, 4(R(arg))
+	MOVW	R6, ret_lo+16(FP)
+	MOVW	R7, ret_hi+20(FP)
 	RET
 
 // trampoline for _sfloat2. passes LR as arg0 and
diff --git a/src/pkg/runtime/vlrt_arm.c b/src/pkg/runtime/vlrt.c
similarity index 55%
rename from src/pkg/runtime/vlrt_arm.c
rename to src/pkg/runtime/vlrt.c
index b342a3eb86..cab74c5fe8 100644
--- a/src/pkg/runtime/vlrt_arm.c
+++ b/src/pkg/runtime/vlrt.c
@@ -1,5 +1,5 @@
-// Inferno's libkern/vlrt-arm.c
-// http://code.google.com/p/inferno-os/source/browse/libkern/vlrt-arm.c
+// Inferno's libkern/vlrt-386.c
+// http://code.google.com/p/inferno-os/source/browse/libkern/vlrt-386.c
 //
 //         Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 //         Revisions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).  All rights reserved.
@@ -23,55 +23,77 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+// +build arm 386
+
 #include "../../cmd/ld/textflag.h"
 
-// declared here to avoid include of runtime.h
+/*
+ * C runtime for 64-bit divide, others.
+ *
+ * TODO(rsc): The simple functions are dregs--8c knows how
+ * to generate the code directly now.  Find and remove.
+ */
+
 void	runtime·panicstring(char*);
 void	runtime·panicdivide(void);
 
-typedef unsigned long   ulong;
-typedef unsigned int    uint;
-typedef unsigned short  ushort;
-typedef unsigned char   uchar;
-typedef signed char     schar;
+typedef	unsigned long	ulong;
+typedef	unsigned int	uint;
+typedef	unsigned short	ushort;
+typedef	unsigned char	uchar;
+typedef	signed char	schar;
 
-#define SIGN(n) (1UL<<(n-1))
+#define	SIGN(n)	(1UL<<(n-1))
 
-typedef struct  Vlong   Vlong;
-struct  Vlong
+typedef	struct	Vlong	Vlong;
+struct	Vlong
 {
-	ulong   lo;
-	ulong   hi;
+	ulong	lo;
+	ulong	hi;
 };
 
-void    runtime·abort(void);
+typedef	union	Vlong64	Vlong64;
+union	Vlong64
+{
+	long long	v;
+	Vlong	v2;
+};
+
+void	runtime·abort(void);
 
 #pragma textflag NOSPLIT
-void
-_addv(Vlong *r, Vlong a, Vlong b)
+Vlong
+_addv(Vlong a, Vlong b)
 {
-	r->lo = a.lo + b.lo;
-	r->hi = a.hi + b.hi;
-	if(r->lo < a.lo)
-		r->hi++;
+	Vlong r;
+
+	r.lo = a.lo + b.lo;
+	r.hi = a.hi + b.hi;
+	if(r.lo < a.lo)
+		r.hi++;
+	return r;
 }
 
 #pragma textflag NOSPLIT
-void
-_subv(Vlong *r, Vlong a, Vlong b)
+Vlong
+_subv(Vlong a, Vlong b)
 {
-	r->lo = a.lo - b.lo;
-	r->hi = a.hi - b.hi;
-	if(r->lo > a.lo)
-		r->hi--;
+	Vlong r;
+
+	r.lo = a.lo - b.lo;
+	r.hi = a.hi - b.hi;
+	if(r.lo > a.lo)
+		r.hi--;
+	return r;
 }
 
-void
-_d2v(Vlong *y, double d)
+Vlong
+_d2v(double d)
 {
 	union { double d; Vlong vl; } x;
 	ulong xhi, xlo, ylo, yhi;
 	int sh;
+	Vlong y;
 
 	x.d = d;
 
@@ -102,12 +124,12 @@ _d2v(Vlong *y, double d)
 	} else {
 		/* v = (hi||lo) << -sh */
 		sh = -sh;
-		if(sh <= 11) {
+		if(sh <= 10) { /* NOTE: sh <= 11 on ARM??? */
 			ylo = xlo << sh;
 			yhi = (xhi << sh) | (xlo >> (32-sh));
 		} else {
 			/* overflow */
-			yhi = d;        /* causes something awful */
+			yhi = d;	/* causes something awful */
 		}
 	}
 	if(x.vl.hi & SIGN(32)) {
@@ -118,14 +140,15 @@ _d2v(Vlong *y, double d)
 			yhi = -yhi;
 	}
 
-	y->hi = yhi;
-	y->lo = ylo;
+	y.hi = yhi;
+	y.lo = ylo;
+	return y;
 }
 
-void
-_f2v(Vlong *y, float f)
+Vlong
+_f2v(float f)
 {
-	_d2v(y, f);
+	return _d2v(f);
 }
 
 double
@@ -150,7 +173,7 @@ _v2d(Vlong x)
 			x.hi = -x.hi;
 		return -(_ul2d(x.hi)*4294967296. + _ul2d(x.lo));
 	}
-	return x.hi*4294967296. + _ul2d(x.lo);
+	return (long)x.hi*4294967296. + x.lo;
 }
 
 float
@@ -159,8 +182,11 @@ _v2f(Vlong x)
 	return _v2d(x);
 }
 
+ulong	_div64by32(Vlong, ulong, ulong*);
+int	_mul64by32(Vlong*, Vlong, ulong);
+
 static void
-dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
+slowdodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
 {
 	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
 	int i;
@@ -221,40 +247,107 @@ dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
 	}
 }
 
-void
-_divvu(Vlong *q, Vlong n, Vlong d)
+#ifdef GOARCH_arm
+static void
+dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
 {
+	slowdodiv(num, den, qp, rp);
+}
+#endif
 
-	if(n.hi == 0 && d.hi == 0) {
-		q->hi = 0;
-		q->lo = n.lo / d.lo;
+#ifdef GOARCH_386
+static void
+dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
+{
+	ulong n;
+	Vlong x, q, r;
+	
+	if(den.hi > num.hi || (den.hi == num.hi && den.lo > num.lo)){
+		if(qp) {
+			qp->hi = 0;
+			qp->lo = 0;
+		}
+		if(rp) {
+			rp->hi = num.hi;
+			rp->lo = num.lo;
+		}
 		return;
 	}
-	dodiv(n, d, q, 0);
-}
 
-void
-runtime·uint64div(Vlong n, Vlong d, Vlong q)
-{
-	_divvu(&q, n, d);
+	if(den.hi != 0){
+		q.hi = 0;
+		n = num.hi/den.hi;
+		if(_mul64by32(&x, den, n) || x.hi > num.hi || (x.hi == num.hi && x.lo > num.lo))
+			slowdodiv(num, den, &q, &r);
+		else {
+			q.lo = n;
+			*(long long*)&r = *(long long*)&num - *(long long*)&x;
+		}
+	} else {
+		if(num.hi >= den.lo){
+			if(den.lo == 0)
+				runtime·panicdivide();
+			q.hi = n = num.hi/den.lo;
+			num.hi -= den.lo*n;
+		} else {
+			q.hi = 0;
+		}
+		q.lo = _div64by32(num, den.lo, &r.lo);
+		r.hi = 0;
+	}
+	if(qp) {
+		qp->lo = q.lo;
+		qp->hi = q.hi;
+	}
+	if(rp) {
+		rp->lo = r.lo;
+		rp->hi = r.hi;
+	}
 }
+#endif
 
-void
-_modvu(Vlong *r, Vlong n, Vlong d)
+Vlong
+_divvu(Vlong n, Vlong d)
 {
+	Vlong q;
 
 	if(n.hi == 0 && d.hi == 0) {
-		r->hi = 0;
-		r->lo = n.lo % d.lo;
-		return;
+		if(d.lo == 0)
+			runtime·panicdivide();
+		q.hi = 0;
+		q.lo = n.lo / d.lo;
+		return q;
 	}
-	dodiv(n, d, 0, r);
+	dodiv(n, d, &q, 0);
+	return q;
 }
 
-void
-runtime·uint64mod(Vlong n, Vlong d, Vlong q)
+Vlong
+runtime·uint64div(Vlong n, Vlong d)
 {
-	_modvu(&q, n, d);
+	return _divvu(n, d);
+}
+
+Vlong
+_modvu(Vlong n, Vlong d)
+{
+	Vlong r;
+
+	if(n.hi == 0 && d.hi == 0) {
+		if(d.lo == 0)
+			runtime·panicdivide();
+		r.hi = 0;
+		r.lo = n.lo % d.lo;
+		return r;
+	}
+	dodiv(n, d, 0, &r);
+	return r;
+}
+
+Vlong
+runtime·uint64mod(Vlong n, Vlong d)
+{
+	return _modvu(n, d);
 }
 
 static void
@@ -269,21 +362,25 @@ vneg(Vlong *v)
 	v->hi = ~v->hi;
 }
 
-void
-_divv(Vlong *q, Vlong n, Vlong d)
+Vlong
+_divv(Vlong n, Vlong d)
 {
 	long nneg, dneg;
+	Vlong q;
 
 	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
 		if((long)n.lo == -0x80000000 && (long)d.lo == -1) {
-			// special case: 32-bit -0x80000000 / -1 causes wrong sign
-			q->lo = 0x80000000;
-			q->hi = 0;
-			return;
+			// special case: 32-bit -0x80000000 / -1 causes divide error,
+			// but it's okay in this 64-bit context.
+			q.lo = 0x80000000;
+			q.hi = 0;
+			return q;
 		}
-		q->lo = (long)n.lo / (long)d.lo;
-		q->hi = ((long)q->lo) >> 31;
-		return;
+		if(d.lo == 0)
+			runtime·panicdivide();
+		q.lo = (long)n.lo / (long)d.lo;
+		q.hi = ((long)q.lo) >> 31;
+		return q;
 	}
 	nneg = n.hi >> 31;
 	if(nneg)
@@ -291,26 +388,37 @@ _divv(Vlong *q, Vlong n, Vlong d)
 	dneg = d.hi >> 31;
 	if(dneg)
 		vneg(&d);
-	dodiv(n, d, q, 0);
+	dodiv(n, d, &q, 0);
 	if(nneg != dneg)
-		vneg(q);
+		vneg(&q);
+	return q;
 }
 
-void
-runtime·int64div(Vlong n, Vlong d, Vlong q)
+Vlong
+runtime·int64div(Vlong n, Vlong d)
 {
-	_divv(&q, n, d);
+	return _divv(n, d);
 }
 
-void
-_modv(Vlong *r, Vlong n, Vlong d)
+Vlong
+_modv(Vlong n, Vlong d)
 {
 	long nneg, dneg;
+	Vlong r;
 
 	if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
-		r->lo = (long)n.lo % (long)d.lo;
-		r->hi = ((long)r->lo) >> 31;
-		return;
+		if((long)n.lo == -0x80000000 && (long)d.lo == -1) {
+			// special case: 32-bit -0x80000000 % -1 causes divide error,
+			// but it's okay in this 64-bit context.
+			r.lo = 0;
+			r.hi = 0;
+			return r;
+		}
+		if(d.lo == 0)
+			runtime·panicdivide();
+		r.lo = (long)n.lo % (long)d.lo;
+		r.hi = ((long)r.lo) >> 31;
+		return r;
 	}
 	nneg = n.hi >> 31;
 	if(nneg)
@@ -318,318 +426,348 @@ _modv(Vlong *r, Vlong n, Vlong d)
 	dneg = d.hi >> 31;
 	if(dneg)
 		vneg(&d);
-	dodiv(n, d, 0, r);
+	dodiv(n, d, 0, &r);
 	if(nneg)
-		vneg(r);
+		vneg(&r);
+	return r;
 }
 
-void
-runtime·int64mod(Vlong n, Vlong d, Vlong q)
+Vlong
+runtime·int64mod(Vlong n, Vlong d)
 {
-	_modv(&q, n, d);
+	return _modv(n, d);
 }
 
-void
-_rshav(Vlong *r, Vlong a, int b)
+Vlong
+_rshav(Vlong a, int b)
 {
 	long t;
+	Vlong r;
 
 	t = a.hi;
 	if(b >= 32) {
-		r->hi = t>>31;
+		r.hi = t>>31;
 		if(b >= 64) {
 			/* this is illegal re C standard */
-			r->lo = t>>31;
-			return;
+			r.lo = t>>31;
+			return r;
 		}
-		r->lo = t >> (b-32);
-		return;
+		r.lo = t >> (b-32);
+		return r;
 	}
 	if(b <= 0) {
-		r->hi = t;
-		r->lo = a.lo;
-		return;
+		r.hi = t;
+		r.lo = a.lo;
+		return r;
 	}
-	r->hi = t >> b;
-	r->lo = (t << (32-b)) | (a.lo >> b);
+	r.hi = t >> b;
+	r.lo = (t << (32-b)) | (a.lo >> b);
+	return r;
 }
 
-void
-_rshlv(Vlong *r, Vlong a, int b)
+Vlong
+_rshlv(Vlong a, int b)
+{
+	ulong t;
+	Vlong r;
+
+	t = a.hi;
+	if(b >= 32) {
+		r.hi = 0;
+		if(b >= 64) {
+			/* this is illegal re C standard */
+			r.lo = 0;
+			return r;
+		}
+		r.lo = t >> (b-32);
+		return r;
+	}
+	if(b <= 0) {
+		r.hi = t;
+		r.lo = a.lo;
+		return r;
+	}
+	r.hi = t >> b;
+	r.lo = (t << (32-b)) | (a.lo >> b);
+	return r;
+}
+
+#pragma textflag NOSPLIT
+Vlong
+_lshv(Vlong a, int b)
 {
 	ulong t;
 
-	t = a.hi;
+	t = a.lo;
 	if(b >= 32) {
-		r->hi = 0;
 		if(b >= 64) {
 			/* this is illegal re C standard */
-			r->lo = 0;
-			return;
+			return (Vlong){0, 0};
 		}
-		r->lo = t >> (b-32);
-		return;
+		return (Vlong){0, t<<(b-32)};
 	}
 	if(b <= 0) {
-		r->hi = t;
-		r->lo = a.lo;
-		return;
+		return (Vlong){t, a.hi};
 	}
-	r->hi = t >> b;
-	r->lo = (t << (32-b)) | (a.lo >> b);
+	return (Vlong){t<<b, (t >> (32-b)) | (a.hi << b)};
 }
 
-#pragma textflag NOSPLIT
-void
-_lshv(Vlong *r, Vlong a, int b)
+Vlong
+_andv(Vlong a, Vlong b)
 {
-	if(b >= 32) {
-		r->lo = 0;
-		if(b >= 64) {
-			/* this is illegal re C standard */
-			r->hi = 0;
-			return;
-		}
-		r->hi = a.lo << (b-32);
-		return;
-	}
-	if(b <= 0) {
-		r->lo = a.lo;
-		r->hi = a.hi;
-		return;
-	}
-	r->lo = a.lo << b;
-	r->hi = (a.lo >> (32-b)) | (a.hi << b);
+	Vlong r;
+
+	r.hi = a.hi & b.hi;
+	r.lo = a.lo & b.lo;
+	return r;
 }
 
-void
-_andv(Vlong *r, Vlong a, Vlong b)
+Vlong
+_orv(Vlong a, Vlong b)
 {
-	r->hi = a.hi & b.hi;
-	r->lo = a.lo & b.lo;
+	Vlong r;
+
+	r.hi = a.hi | b.hi;
+	r.lo = a.lo | b.lo;
+	return r;
 }
 
-void
-_orv(Vlong *r, Vlong a, Vlong b)
+Vlong
+_xorv(Vlong a, Vlong b)
 {
-	r->hi = a.hi | b.hi;
-	r->lo = a.lo | b.lo;
+	Vlong r;
+
+	r.hi = a.hi ^ b.hi;
+	r.lo = a.lo ^ b.lo;
+	return r;
 }
 
-void
-_xorv(Vlong *r, Vlong a, Vlong b)
+Vlong
+_vpp(Vlong *r)
 {
-	r->hi = a.hi ^ b.hi;
-	r->lo = a.lo ^ b.lo;
-}
+	Vlong l;
 
-void
-_vpp(Vlong *l, Vlong *r)
-{
-
-	l->hi = r->hi;
-	l->lo = r->lo;
+	l = *r;
 	r->lo++;
 	if(r->lo == 0)
 		r->hi++;
+	return l;
 }
 
-void
-_vmm(Vlong *l, Vlong *r)
+Vlong
+_vmm(Vlong *r)
 {
+	Vlong l;
 
-	l->hi = r->hi;
-	l->lo = r->lo;
+	l = *r;
 	if(r->lo == 0)
 		r->hi--;
 	r->lo--;
+	return l;
 }
 
-void
-_ppv(Vlong *l, Vlong *r)
+Vlong
+_ppv(Vlong *r)
 {
 
 	r->lo++;
 	if(r->lo == 0)
 		r->hi++;
-	l->hi = r->hi;
-	l->lo = r->lo;
+	return *r;
 }
 
-void
-_mmv(Vlong *l, Vlong *r)
+Vlong
+_mmv(Vlong *r)
 {
 
 	if(r->lo == 0)
 		r->hi--;
 	r->lo--;
-	l->hi = r->hi;
-	l->lo = r->lo;
+	return *r;
 }
 
 #pragma textflag NOSPLIT
-void
-_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
+Vlong
+_vasop(void *lv, Vlong fn(Vlong, Vlong), int type, Vlong rv)
 {
 	Vlong t, u;
 
-	u = *ret;
+	u.lo = 0;
+	u.hi = 0;
 	switch(type) {
 	default:
 		runtime·abort();
 		break;
 
-	case 1: /* schar */
+	case 1:	/* schar */
 		t.lo = *(schar*)lv;
 		t.hi = t.lo >> 31;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(schar*)lv = u.lo;
 		break;
 
-	case 2: /* uchar */
+	case 2:	/* uchar */
 		t.lo = *(uchar*)lv;
 		t.hi = 0;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(uchar*)lv = u.lo;
 		break;
 
-	case 3: /* short */
+	case 3:	/* short */
 		t.lo = *(short*)lv;
 		t.hi = t.lo >> 31;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(short*)lv = u.lo;
 		break;
 
-	case 4: /* ushort */
+	case 4:	/* ushort */
 		t.lo = *(ushort*)lv;
 		t.hi = 0;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(ushort*)lv = u.lo;
 		break;
 
-	case 9: /* int */
+	case 9:	/* int */
 		t.lo = *(int*)lv;
 		t.hi = t.lo >> 31;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(int*)lv = u.lo;
 		break;
 
-	case 10:        /* uint */
+	case 10:	/* uint */
 		t.lo = *(uint*)lv;
 		t.hi = 0;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(uint*)lv = u.lo;
 		break;
 
-	case 5: /* long */
+	case 5:	/* long */
 		t.lo = *(long*)lv;
 		t.hi = t.lo >> 31;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(long*)lv = u.lo;
 		break;
 
-	case 6: /* ulong */
+	case 6:	/* ulong */
 		t.lo = *(ulong*)lv;
 		t.hi = 0;
-		fn(&u, t, rv);
+		u = fn(t, rv);
 		*(ulong*)lv = u.lo;
 		break;
 
-	case 7: /* vlong */
-	case 8: /* uvlong */
-		fn(&u, *(Vlong*)lv, rv);
+	case 7:	/* vlong */
+	case 8:	/* uvlong */
+		if((void*)fn == _lshv || (void*)fn == _rshav || (void*)fn == _rshlv)
+			u = ((Vlong(*)(Vlong,int))fn)(*(Vlong*)lv, *(int*)&rv);
+		else
+			u = fn(*(Vlong*)lv, rv);
 		*(Vlong*)lv = u;
 		break;
 	}
-	*ret = u;
+	return u;
 }
 
-void
-_p2v(Vlong *ret, void *p)
+Vlong
+_p2v(void *p)
 {
 	long t;
+	Vlong ret;
 
 	t = (ulong)p;
-	ret->lo = t;
-	ret->hi = 0;
+	ret.lo = t;
+	ret.hi = 0;
+	return ret;
 }
 
-void
-_sl2v(Vlong *ret, long sl)
+Vlong
+_sl2v(long sl)
 {
 	long t;
+	Vlong ret;
 
 	t = sl;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret.lo = t;
+	ret.hi = t >> 31;
+	return ret;
 }
 
-void
-_ul2v(Vlong *ret, ulong ul)
+Vlong
+_ul2v(ulong ul)
 {
 	long t;
+	Vlong ret;
 
 	t = ul;
-	ret->lo = t;
-	ret->hi = 0;
+	ret.lo = t;
+	ret.hi = 0;
+	return ret;
 }
 
 #pragma textflag NOSPLIT
-void
-_si2v(Vlong *ret, int si)
+Vlong
+_si2v(int si)
 {
-	ret->lo = (long)si;
-	ret->hi = (long)si >> 31;
+	return (Vlong){si, si>>31};
 }
 
-void
-_ui2v(Vlong *ret, uint ui)
+Vlong
+_ui2v(uint ui)
 {
 	long t;
+	Vlong ret;
 
 	t = ui;
-	ret->lo = t;
-	ret->hi = 0;
+	ret.lo = t;
+	ret.hi = 0;
+	return ret;
 }
 
-void
-_sh2v(Vlong *ret, long sh)
+Vlong
+_sh2v(long sh)
 {
 	long t;
+	Vlong ret;
 
 	t = (sh << 16) >> 16;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret.lo = t;
+	ret.hi = t >> 31;
+	return ret;
 }
 
-void
-_uh2v(Vlong *ret, ulong ul)
+Vlong
+_uh2v(ulong ul)
 {
 	long t;
+	Vlong ret;
 
 	t = ul & 0xffff;
-	ret->lo = t;
-	ret->hi = 0;
+	ret.lo = t;
+	ret.hi = 0;
+	return ret;
 }
 
-void
-_sc2v(Vlong *ret, long uc)
+Vlong
+_sc2v(long uc)
 {
 	long t;
+	Vlong ret;
 
 	t = (uc << 24) >> 24;
-	ret->lo = t;
-	ret->hi = t >> 31;
+	ret.lo = t;
+	ret.hi = t >> 31;
+	return ret;
 }
 
-void
-_uc2v(Vlong *ret, ulong ul)
+Vlong
+_uc2v(ulong ul)
 {
 	long t;
+	Vlong ret;
 
 	t = ul & 0xff;
-	ret->lo = t;
-	ret->hi = 0;
+	ret.lo = t;
+	ret.hi = 0;
+	return ret;
 }
 
 long
@@ -682,7 +820,6 @@ _v2ul(Vlong rv)
 long
 _v2si(Vlong rv)
 {
-
 	return rv.lo;
 }
 
diff --git a/src/pkg/runtime/vlrt_386.c b/src/pkg/runtime/vlrt_386.c
deleted file mode 100644
index bda67b1575..0000000000
--- a/src/pkg/runtime/vlrt_386.c
+++ /dev/null
@@ -1,819 +0,0 @@
-// Inferno's libkern/vlrt-386.c
-// http://code.google.com/p/inferno-os/source/browse/libkern/vlrt-386.c
-//
-//         Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
-//         Revisions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).  All rights reserved.
-//         Portions Copyright 2009 The Go Authors. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "../../cmd/ld/textflag.h"
-
-/*
- * C runtime for 64-bit divide, others.
- *
- * TODO(rsc): The simple functions are dregs--8c knows how
- * to generate the code directly now.  Find and remove.
- */
-
-extern void runtime·panicdivide(void);
-
-typedef	unsigned long	ulong;
-typedef	unsigned int	uint;
-typedef	unsigned short	ushort;
-typedef	unsigned char	uchar;
-typedef	signed char	schar;
-
-#define	SIGN(n)	(1UL<<(n-1))
-
-typedef	union	Vlong	Vlong;
-union	Vlong
-{
-	long long	v;
-	struct
-	{
-		ulong	lo;
-		ulong	hi;
-	}		v2;
-};
-
-void	runtime·abort(void);
-
-void
-_d2v(Vlong *y, double d)
-{
-	union { double d; Vlong vl; } x;
-	ulong xhi, xlo, ylo, yhi;
-	int sh;
-
-	x.d = d;
-
-	xhi = (x.vl.v2.hi & 0xfffff) | 0x100000;
-	xlo = x.vl.v2.lo;
-	sh = 1075 - ((x.vl.v2.hi >> 20) & 0x7ff);
-
-	ylo = 0;
-	yhi = 0;
-	if(sh >= 0) {
-		/* v = (hi||lo) >> sh */
-		if(sh < 32) {
-			if(sh == 0) {
-				ylo = xlo;
-				yhi = xhi;
-			} else {
-				ylo = (xlo >> sh) | (xhi << (32-sh));
-				yhi = xhi >> sh;
-			}
-		} else {
-			if(sh == 32) {
-				ylo = xhi;
-			} else
-			if(sh < 64) {
-				ylo = xhi >> (sh-32);
-			}
-		}
-	} else {
-		/* v = (hi||lo) << -sh */
-		sh = -sh;
-		if(sh <= 10) {
-			ylo = xlo << sh;
-			yhi = (xhi << sh) | (xlo >> (32-sh));
-		} else {
-			/* overflow */
-			yhi = d;	/* causes something awful */
-		}
-	}
-	if(x.vl.v2.hi & SIGN(32)) {
-		if(ylo != 0) {
-			ylo = -ylo;
-			yhi = ~yhi;
-		} else
-			yhi = -yhi;
-	}
-
-	y->v2.hi = yhi;
-	y->v2.lo = ylo;
-}
-
-void
-_f2v(Vlong *y, float f)
-{
-
-	_d2v(y, f);
-}
-
-double
-_v2d(Vlong x)
-{
-	if(x.v2.hi & SIGN(32)) {
-		if(x.v2.lo) {
-			x.v2.lo = -x.v2.lo;
-			x.v2.hi = ~x.v2.hi;
-		} else
-			x.v2.hi = -x.v2.hi;
-		return -((long)x.v2.hi*4294967296. + x.v2.lo);
-	}
-	return (long)x.v2.hi*4294967296. + x.v2.lo;
-}
-
-float
-_v2f(Vlong x)
-{
-	return _v2d(x);
-}
-
-ulong	_div64by32(Vlong, ulong, ulong*);
-int	_mul64by32(Vlong*, Vlong, ulong);
-
-static void
-slowdodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
-{
-	ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
-	int i;
-
-	numhi = num.v2.hi;
-	numlo = num.v2.lo;
-	denhi = den.v2.hi;
-	denlo = den.v2.lo;
-
-	/*
-	 * get a divide by zero
-	 */
-	if(denlo==0 && denhi==0) {
-		numlo = numlo / denlo;
-	}
-
-	/*
-	 * set up the divisor and find the number of iterations needed
-	 */
-	if(numhi >= SIGN(32)) {
-		quohi = SIGN(32);
-		quolo = 0;
-	} else {
-		quohi = numhi;
-		quolo = numlo;
-	}
-	i = 0;
-	while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
-		denhi = (denhi<<1) | (denlo>>31);
-		denlo <<= 1;
-		i++;
-	}
-
-	quohi = 0;
-	quolo = 0;
-	for(; i >= 0; i--) {
-		quohi = (quohi<<1) | (quolo>>31);
-		quolo <<= 1;
-		if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
-			t = numlo;
-			numlo -= denlo;
-			if(numlo > t)
-				numhi--;
-			numhi -= denhi;
-			quolo |= 1;
-		}
-		denlo = (denlo>>1) | (denhi<<31);
-		denhi >>= 1;
-	}
-
-	if(q) {
-		q->v2.lo = quolo;
-		q->v2.hi = quohi;
-	}
-	if(r) {
-		r->v2.lo = numlo;
-		r->v2.hi = numhi;
-	}
-}
-
-static void
-dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
-{
-	ulong n;
-	Vlong x, q, r;
-
-	if(den.v2.hi > num.v2.hi || (den.v2.hi == num.v2.hi && den.v2.lo > num.v2.lo)){
-		if(qp) {
-			qp->v2.hi = 0;
-			qp->v2.lo = 0;
-		}
-		if(rp) {
-			rp->v2.hi = num.v2.hi;
-			rp->v2.lo = num.v2.lo;
-		}
-		return;
-	}
-
-	if(den.v2.hi != 0){
-		q.v2.hi = 0;
-		n = num.v2.hi/den.v2.hi;
-		if(_mul64by32(&x, den, n) || x.v2.hi > num.v2.hi || (x.v2.hi == num.v2.hi && x.v2.lo > num.v2.lo))
-			slowdodiv(num, den, &q, &r);
-		else {
-			q.v2.lo = n;
-			r.v = num.v - x.v;
-		}
-	} else {
-		if(num.v2.hi >= den.v2.lo){
-			if(den.v2.lo == 0)
-				runtime·panicdivide();
-			q.v2.hi = n = num.v2.hi/den.v2.lo;
-			num.v2.hi -= den.v2.lo*n;
-		} else {
-			q.v2.hi = 0;
-		}
-		q.v2.lo = _div64by32(num, den.v2.lo, &r.v2.lo);
-		r.v2.hi = 0;
-	}
-	if(qp) {
-		qp->v2.lo = q.v2.lo;
-		qp->v2.hi = q.v2.hi;
-	}
-	if(rp) {
-		rp->v2.lo = r.v2.lo;
-		rp->v2.hi = r.v2.hi;
-	}
-}
-
-void
-_divvu(Vlong *q, Vlong n, Vlong d)
-{
-
-	if(n.v2.hi == 0 && d.v2.hi == 0) {
-		if(d.v2.lo == 0)
-			runtime·panicdivide();
-		q->v2.hi = 0;
-		q->v2.lo = n.v2.lo / d.v2.lo;
-		return;
-	}
-	dodiv(n, d, q, 0);
-}
-
-void
-runtime·uint64div(Vlong n, Vlong d, Vlong q)
-{
-	_divvu(&q, n, d);
-}
-
-void
-_modvu(Vlong *r, Vlong n, Vlong d)
-{
-
-	if(n.v2.hi == 0 && d.v2.hi == 0) {
-		if(d.v2.lo == 0)
-			runtime·panicdivide();
-		r->v2.hi = 0;
-		r->v2.lo = n.v2.lo % d.v2.lo;
-		return;
-	}
-	dodiv(n, d, 0, r);
-}
-
-void
-runtime·uint64mod(Vlong n, Vlong d, Vlong q)
-{
-	_modvu(&q, n, d);
-}
-
-static void
-vneg(Vlong *v)
-{
-
-	if(v->v2.lo == 0) {
-		v->v2.hi = -v->v2.hi;
-		return;
-	}
-	v->v2.lo = -v->v2.lo;
-	v->v2.hi = ~v->v2.hi;
-}
-
-void
-_divv(Vlong *q, Vlong n, Vlong d)
-{
-	long nneg, dneg;
-
-	if(n.v2.hi == (((long)n.v2.lo)>>31) && d.v2.hi == (((long)d.v2.lo)>>31)) {
-		if((long)n.v2.lo == -0x80000000 && (long)d.v2.lo == -1) {
-			// special case: 32-bit -0x80000000 / -1 causes divide error,
-			// but it's okay in this 64-bit context.
-			q->v2.lo = 0x80000000;
-			q->v2.hi = 0;
-			return;
-		}
-		if(d.v2.lo == 0)
-			runtime·panicdivide();
-		q->v2.lo = (long)n.v2.lo / (long)d.v2.lo;
-		q->v2.hi = ((long)q->v2.lo) >> 31;
-		return;
-	}
-	nneg = n.v2.hi >> 31;
-	if(nneg)
-		vneg(&n);
-	dneg = d.v2.hi >> 31;
-	if(dneg)
-		vneg(&d);
-	dodiv(n, d, q, 0);
-	if(nneg != dneg)
-		vneg(q);
-}
-
-void
-runtime·int64div(Vlong n, Vlong d, Vlong q)
-{
-	_divv(&q, n, d);
-}
-
-void
-_modv(Vlong *r, Vlong n, Vlong d)
-{
-	long nneg, dneg;
-
-	if(n.v2.hi == (((long)n.v2.lo)>>31) && d.v2.hi == (((long)d.v2.lo)>>31)) {
-		if((long)n.v2.lo == -0x80000000 && (long)d.v2.lo == -1) {
-			// special case: 32-bit -0x80000000 % -1 causes divide error,
-			// but it's okay in this 64-bit context.
-			r->v2.lo = 0;
-			r->v2.hi = 0;
-			return;
-		}
-		if(d.v2.lo == 0)
-			runtime·panicdivide();
-		r->v2.lo = (long)n.v2.lo % (long)d.v2.lo;
-		r->v2.hi = ((long)r->v2.lo) >> 31;
-		return;
-	}
-	nneg = n.v2.hi >> 31;
-	if(nneg)
-		vneg(&n);
-	dneg = d.v2.hi >> 31;
-	if(dneg)
-		vneg(&d);
-	dodiv(n, d, 0, r);
-	if(nneg)
-		vneg(r);
-}
-
-void
-runtime·int64mod(Vlong n, Vlong d, Vlong q)
-{
-	_modv(&q, n, d);
-}
-
-void
-_rshav(Vlong *r, Vlong a, int b)
-{
-	long t;
-
-	t = a.v2.hi;
-	if(b >= 32) {
-		r->v2.hi = t>>31;
-		if(b >= 64) {
-			/* this is illegal re C standard */
-			r->v2.lo = t>>31;
-			return;
-		}
-		r->v2.lo = t >> (b-32);
-		return;
-	}
-	if(b <= 0) {
-		r->v2.hi = t;
-		r->v2.lo = a.v2.lo;
-		return;
-	}
-	r->v2.hi = t >> b;
-	r->v2.lo = (t << (32-b)) | (a.v2.lo >> b);
-}
-
-void
-_rshlv(Vlong *r, Vlong a, int b)
-{
-	ulong t;
-
-	t = a.v2.hi;
-	if(b >= 32) {
-		r->v2.hi = 0;
-		if(b >= 64) {
-			/* this is illegal re C standard */
-			r->v2.lo = 0;
-			return;
-		}
-		r->v2.lo = t >> (b-32);
-		return;
-	}
-	if(b <= 0) {
-		r->v2.hi = t;
-		r->v2.lo = a.v2.lo;
-		return;
-	}
-	r->v2.hi = t >> b;
-	r->v2.lo = (t << (32-b)) | (a.v2.lo >> b);
-}
-
-#pragma textflag NOSPLIT
-void
-_lshv(Vlong *r, Vlong a, int b)
-{
-	ulong t;
-
-	t = a.v2.lo;
-	if(b >= 32) {
-		r->v2.lo = 0;
-		if(b >= 64) {
-			/* this is illegal re C standard */
-			r->v2.hi = 0;
-			return;
-		}
-		r->v2.hi = t << (b-32);
-		return;
-	}
-	if(b <= 0) {
-		r->v2.lo = t;
-		r->v2.hi = a.v2.hi;
-		return;
-	}
-	r->v2.lo = t << b;
-	r->v2.hi = (t >> (32-b)) | (a.v2.hi << b);
-}
-
-void
-_andv(Vlong *r, Vlong a, Vlong b)
-{
-	r->v2.hi = a.v2.hi & b.v2.hi;
-	r->v2.lo = a.v2.lo & b.v2.lo;
-}
-
-void
-_orv(Vlong *r, Vlong a, Vlong b)
-{
-	r->v2.hi = a.v2.hi | b.v2.hi;
-	r->v2.lo = a.v2.lo | b.v2.lo;
-}
-
-void
-_xorv(Vlong *r, Vlong a, Vlong b)
-{
-	r->v2.hi = a.v2.hi ^ b.v2.hi;
-	r->v2.lo = a.v2.lo ^ b.v2.lo;
-}
-
-void
-_vpp(Vlong *l, Vlong *r)
-{
-
-	l->v2.hi = r->v2.hi;
-	l->v2.lo = r->v2.lo;
-	r->v2.lo++;
-	if(r->v2.lo == 0)
-		r->v2.hi++;
-}
-
-void
-_vmm(Vlong *l, Vlong *r)
-{
-
-	l->v2.hi = r->v2.hi;
-	l->v2.lo = r->v2.lo;
-	if(r->v2.lo == 0)
-		r->v2.hi--;
-	r->v2.lo--;
-}
-
-void
-_ppv(Vlong *l, Vlong *r)
-{
-
-	r->v2.lo++;
-	if(r->v2.lo == 0)
-		r->v2.hi++;
-	l->v2.hi = r->v2.hi;
-	l->v2.lo = r->v2.lo;
-}
-
-void
-_mmv(Vlong *l, Vlong *r)
-{
-
-	if(r->v2.lo == 0)
-		r->v2.hi--;
-	r->v2.lo--;
-	l->v2.hi = r->v2.hi;
-	l->v2.lo = r->v2.lo;
-}
-
-void
-_vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
-{
-	Vlong t, u;
-
-	u.v2.lo = 0;
-	u.v2.hi = 0;
-	switch(type) {
-	default:
-		runtime·abort();
-		break;
-
-	case 1:	/* schar */
-		t.v2.lo = *(schar*)lv;
-		t.v2.hi = t.v2.lo >> 31;
-		fn(&u, t, rv);
-		*(schar*)lv = u.v2.lo;
-		break;
-
-	case 2:	/* uchar */
-		t.v2.lo = *(uchar*)lv;
-		t.v2.hi = 0;
-		fn(&u, t, rv);
-		*(uchar*)lv = u.v2.lo;
-		break;
-
-	case 3:	/* short */
-		t.v2.lo = *(short*)lv;
-		t.v2.hi = t.v2.lo >> 31;
-		fn(&u, t, rv);
-		*(short*)lv = u.v2.lo;
-		break;
-
-	case 4:	/* ushort */
-		t.v2.lo = *(ushort*)lv;
-		t.v2.hi = 0;
-		fn(&u, t, rv);
-		*(ushort*)lv = u.v2.lo;
-		break;
-
-	case 9:	/* int */
-		t.v2.lo = *(int*)lv;
-		t.v2.hi = t.v2.lo >> 31;
-		fn(&u, t, rv);
-		*(int*)lv = u.v2.lo;
-		break;
-
-	case 10:	/* uint */
-		t.v2.lo = *(uint*)lv;
-		t.v2.hi = 0;
-		fn(&u, t, rv);
-		*(uint*)lv = u.v2.lo;
-		break;
-
-	case 5:	/* long */
-		t.v2.lo = *(long*)lv;
-		t.v2.hi = t.v2.lo >> 31;
-		fn(&u, t, rv);
-		*(long*)lv = u.v2.lo;
-		break;
-
-	case 6:	/* ulong */
-		t.v2.lo = *(ulong*)lv;
-		t.v2.hi = 0;
-		fn(&u, t, rv);
-		*(ulong*)lv = u.v2.lo;
-		break;
-
-	case 7:	/* vlong */
-	case 8:	/* uvlong */
-		fn(&u, *(Vlong*)lv, rv);
-		*(Vlong*)lv = u;
-		break;
-	}
-	*ret = u;
-}
-
-void
-_p2v(Vlong *ret, void *p)
-{
-	long t;
-
-	t = (ulong)p;
-	ret->v2.lo = t;
-	ret->v2.hi = 0;
-}
-
-void
-_sl2v(Vlong *ret, long sl)
-{
-	long t;
-
-	t = sl;
-	ret->v2.lo = t;
-	ret->v2.hi = t >> 31;
-}
-
-void
-_ul2v(Vlong *ret, ulong ul)
-{
-	long t;
-
-	t = ul;
-	ret->v2.lo = t;
-	ret->v2.hi = 0;
-}
-
-void
-_si2v(Vlong *ret, int si)
-{
-	long t;
-
-	t = si;
-	ret->v2.lo = t;
-	ret->v2.hi = t >> 31;
-}
-
-void
-_ui2v(Vlong *ret, uint ui)
-{
-	long t;
-
-	t = ui;
-	ret->v2.lo = t;
-	ret->v2.hi = 0;
-}
-
-void
-_sh2v(Vlong *ret, long sh)
-{
-	long t;
-
-	t = (sh << 16) >> 16;
-	ret->v2.lo = t;
-	ret->v2.hi = t >> 31;
-}
-
-void
-_uh2v(Vlong *ret, ulong ul)
-{
-	long t;
-
-	t = ul & 0xffff;
-	ret->v2.lo = t;
-	ret->v2.hi = 0;
-}
-
-void
-_sc2v(Vlong *ret, long uc)
-{
-	long t;
-
-	t = (uc << 24) >> 24;
-	ret->v2.lo = t;
-	ret->v2.hi = t >> 31;
-}
-
-void
-_uc2v(Vlong *ret, ulong ul)
-{
-	long t;
-
-	t = ul & 0xff;
-	ret->v2.lo = t;
-	ret->v2.hi = 0;
-}
-
-long
-_v2sc(Vlong rv)
-{
-	long t;
-
-	t = rv.v2.lo & 0xff;
-	return (t << 24) >> 24;
-}
-
-long
-_v2uc(Vlong rv)
-{
-
-	return rv.v2.lo & 0xff;
-}
-
-long
-_v2sh(Vlong rv)
-{
-	long t;
-
-	t = rv.v2.lo & 0xffff;
-	return (t << 16) >> 16;
-}
-
-long
-_v2uh(Vlong rv)
-{
-
-	return rv.v2.lo & 0xffff;
-}
-
-long
-_v2sl(Vlong rv)
-{
-
-	return rv.v2.lo;
-}
-
-long
-_v2ul(Vlong rv)
-{
-
-	return rv.v2.lo;
-}
-
-long
-_v2si(Vlong rv)
-{
-
-	return rv.v2.lo;
-}
-
-long
-_v2ui(Vlong rv)
-{
-
-	return rv.v2.lo;
-}
-
-int
-_testv(Vlong rv)
-{
-	return rv.v2.lo || rv.v2.hi;
-}
-
-int
-_eqv(Vlong lv, Vlong rv)
-{
-	return lv.v2.lo == rv.v2.lo && lv.v2.hi == rv.v2.hi;
-}
-
-int
-_nev(Vlong lv, Vlong rv)
-{
-	return lv.v2.lo != rv.v2.lo || lv.v2.hi != rv.v2.hi;
-}
-
-int
-_ltv(Vlong lv, Vlong rv)
-{
-	return (long)lv.v2.hi < (long)rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo < rv.v2.lo);
-}
-
-int
-_lev(Vlong lv, Vlong rv)
-{
-	return (long)lv.v2.hi < (long)rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo <= rv.v2.lo);
-}
-
-int
-_gtv(Vlong lv, Vlong rv)
-{
-	return (long)lv.v2.hi > (long)rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo > rv.v2.lo);
-}
-
-int
-_gev(Vlong lv, Vlong rv)
-{
-	return (long)lv.v2.hi > (long)rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo >= rv.v2.lo);
-}
-
-int
-_lov(Vlong lv, Vlong rv)
-{
-	return lv.v2.hi < rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo < rv.v2.lo);
-}
-
-int
-_lsv(Vlong lv, Vlong rv)
-{
-	return lv.v2.hi < rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo <= rv.v2.lo);
-}
-
-int
-_hiv(Vlong lv, Vlong rv)
-{
-	return lv.v2.hi > rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo > rv.v2.lo);
-}
-
-int
-_hsv(Vlong lv, Vlong rv)
-{
-	return lv.v2.hi > rv.v2.hi ||
-		(lv.v2.hi == rv.v2.hi && lv.v2.lo >= rv.v2.lo);
-}
diff --git a/src/pkg/sync/atomic/asm_linux_arm.s b/src/pkg/sync/atomic/asm_linux_arm.s
index bfcfd79779..63f1f9e38e 100644
--- a/src/pkg/sync/atomic/asm_linux_arm.s
+++ b/src/pkg/sync/atomic/asm_linux_arm.s
@@ -121,28 +121,8 @@ TEXT kernelCAS64<>(SB),NOSPLIT,$0-21
 	MOVW	R0, 20(FP)
 	RET
 
-TEXT ·generalCAS64(SB),NOSPLIT,$20-21
-	// bool runtime·cas64(uint64 volatile *addr, uint64 old, uint64 new)
-	MOVW	addr+0(FP), R0
-	// trigger potential paging fault here,
-	// because a fault in runtime.cas64 will hang.
-	MOVW	(R0), R2
-	// make unaligned atomic access panic
-	AND.S	$7, R0, R1
-	BEQ 	2(PC)
-	MOVW	R1, (R1)
-	MOVW	R0, 4(R13)
-	MOVW	old_lo+4(FP), R1
-	MOVW	R1, 8(R13)
-	MOVW	old_hi+8(FP), R1
-	MOVW	R1, 12(R13)
-	MOVW	new_lo+12(FP), R2
-	MOVW	R2, 16(R13)
-	MOVW	new_hi+16(FP), R3
-	MOVW	R3, 20(R13)
-	BL  	runtime·cas64(SB)
-	MOVB	R0, ret+20(FP)
-	RET
+TEXT ·generalCAS64(SB),NOSPLIT,$0-21
+	B  	runtime·cas64(SB)
 
 GLOBL armCAS64(SB), $4
 

From 9a5654abeff85c8ac9b1b43bf7da9aa9f4bdfa15 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Wed, 27 Aug 2014 09:31:32 -0700
Subject: [PATCH 233/423] runtime: restore header to first goroutine in Stack

It appears to have been accidentally lost when converting
Stack from C to Go in https://golang.org/cl/129510043

LGTM=rsc
R=golang-codereviews
CC=golang-codereviews, josharian, khr, remyoudompheng, rsc
https://golang.org/cl/136870043
---
 src/pkg/runtime/mprof.go | 1 +
 src/pkg/runtime/stubs.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 95ea1297ed..5d77c5629c 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -164,6 +164,7 @@ func Stack(buf []byte, all bool) int {
 	if len(buf) > 0 {
 		gp.writebuf = &buf[0]
 		gp.writenbuf = int32(len(buf))
+		goroutineheader(gp)
 		traceback(pc, sp, 0, gp)
 		if all {
 			tracebackothers(gp)
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 5f396aa009..52d0c0e3a5 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -216,6 +216,7 @@ func gonotetsleepg(n *note, t int64) {
 
 func exitsyscall()
 
+func goroutineheader(gp *g)
 func traceback(pc, sp, lr uintptr, gp *g)
 func tracebackothers(gp *g)
 

From fe91006a02b4892d95d1625889632aa4e0fe2b58 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 14:08:26 -0400
Subject: [PATCH 234/423] runtime: give nosplit functions 32 more bytes of
 headroom

The Go calling convention uses more stack space than C.
On 64-bit systems we've been right up against the limit
(128 bytes, so only 16 words) and doing awful things to
our source code to work around it. Instead of continuing
to do awful things, raise the limit to 160 bytes.
I am prepared to raise the limit to 192 bytes if necessary,
but I think this will be enough.

Should fix current link-time stack overflow errors on
        - nacl/arm
        - netbsd/amd64
        - openbsd/amd64
        - solaris/amd64
        - windows/amd64

TBR=r
CC=golang-codereviews, iant
https://golang.org/cl/131450043
---
 src/pkg/runtime/stack.h       |  2 +-
 src/pkg/runtime/stack_test.go |  3 ++-
 test/nosplit.go               | 10 +++++++++-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/stack.h b/src/pkg/runtime/stack.h
index ee5fd351d5..b2de78d898 100644
--- a/src/pkg/runtime/stack.h
+++ b/src/pkg/runtime/stack.h
@@ -94,7 +94,7 @@ enum {
 	// After a stack split check the SP is allowed to be this
 	// many bytes below the stack guard.  This saves an instruction
 	// in the checking sequence for tiny frames.
-	StackSmall = 128,
+	StackSmall = 96,
 
 	// The maximum number of bytes that a chain of NOSPLIT
 	// functions can use.
diff --git a/src/pkg/runtime/stack_test.go b/src/pkg/runtime/stack_test.go
index 08282afd42..956c282136 100644
--- a/src/pkg/runtime/stack_test.go
+++ b/src/pkg/runtime/stack_test.go
@@ -15,7 +15,8 @@ import (
 // See stack.h.
 const (
 	StackGuard = 256
-	StackLimit = 128
+	StackSmall = 96
+	StackLimit = StackGuard - StackSmall
 )
 
 // Test stack split logic by calling functions of every frame size
diff --git a/test/nosplit.go b/test/nosplit.go
index 35aa51017a..39bb3fcb47 100644
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -242,7 +242,7 @@ TestCases:
 			if line == "" {
 				continue
 			}
-			for _, subline := range strings.Split(line, ";") {
+			for i, subline := range strings.Split(line, ";") {
 				subline = strings.TrimSpace(subline)
 				if subline == "" {
 					continue
@@ -255,6 +255,14 @@ TestCases:
 				}
 				name := m[1]
 				size, _ := strconv.Atoi(m[2])
+
+				// CL 131450043 raised the limit from 128 to 160.
+				// Instead of rewriting the test cases above, adjust
+				// the first stack frame to use up the extra 32 bytes.
+				if i == 0 {
+					size += 32
+				}
+
 				if goarch == "amd64" && size%8 == 4 {
 					continue TestCases
 				}

From c548cc2ec8c5c83ba16ab92c1cf8bcc3320ba624 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 14:43:07 -0400
Subject: [PATCH 235/423] runtime: fix windows signal handlers

Windows needs the return result in AX, but runtime.sighandler
no longer stores it in AX. Load it back during the assembly trampoline.

TBR=brainman
CC=golang-codereviews
https://golang.org/cl/133980043
---
 src/pkg/runtime/sys_windows_386.s   | 9 +++++----
 src/pkg/runtime/sys_windows_amd64.s | 9 +++++----
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/pkg/runtime/sys_windows_386.s b/src/pkg/runtime/sys_windows_386.s
index 2a1f4f929c..f9a456a2ca 100644
--- a/src/pkg/runtime/sys_windows_386.s
+++ b/src/pkg/runtime/sys_windows_386.s
@@ -76,10 +76,10 @@ TEXT runtime·setlasterror(SB),NOSPLIT,$0
 // Return 0 for 'not handled', -1 for handled.
 TEXT runtime·sigtramp(SB),NOSPLIT,$0-0
 	MOVL	ptrs+0(FP), CX
-	SUBL	$28, SP
+	SUBL	$32, SP
 
 	// save callee-saved registers
-	MOVL	BX, 12(SP)
+	MOVL	BX, 28(SP)
 	MOVL	BP, 16(SP)
 	MOVL	SI, 20(SP)
 	MOVL	DI, 24(SP)
@@ -103,15 +103,16 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-0
 	MOVL	DX, 8(SP)
 	CALL	runtime·sighandler(SB)
 	// AX is set to report result back to Windows
+	MOVL	12(SP), AX
 
 done:
 	// restore callee-saved registers
 	MOVL	24(SP), DI
 	MOVL	20(SP), SI
 	MOVL	16(SP), BP
-	MOVL	12(SP), BX
+	MOVL	28(SP), BX
 
-	ADDL	$28, SP
+	ADDL	$32, SP
 	// RET 4 (return and pop 4 bytes parameters)
 	BYTE $0xC2; WORD $4
 	RET // unreached; make assembler happy
diff --git a/src/pkg/runtime/sys_windows_amd64.s b/src/pkg/runtime/sys_windows_amd64.s
index 60302622cb..7e59dfc50c 100644
--- a/src/pkg/runtime/sys_windows_amd64.s
+++ b/src/pkg/runtime/sys_windows_amd64.s
@@ -106,7 +106,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-0
 	// DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved
 	// as required by windows callback convention.
 	PUSHFQ
-	SUBQ	$88, SP
+	SUBQ	$96, SP
 	MOVQ	DI, 80(SP)
 	MOVQ	SI, 72(SP)
 	MOVQ	BP, 64(SP)
@@ -114,7 +114,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-0
 	MOVQ	R12, 48(SP)
 	MOVQ	R13, 40(SP)
 	MOVQ	R14, 32(SP)
-	MOVQ	R15, 24(SP)
+	MOVQ	R15, 88(SP)
 
 	MOVQ	0(CX), BX // ExceptionRecord*
 	MOVQ	8(CX), CX // Context*
@@ -135,10 +135,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-0
 	MOVQ	DX, 16(SP)
 	CALL	runtime·sighandler(SB)
 	// AX is set to report result back to Windows
+	MOVL	24(SP), AX
 
 done:
 	// restore registers as required for windows callback
-	MOVQ	24(SP), R15
+	MOVQ	88(SP), R15
 	MOVQ	32(SP), R14
 	MOVQ	40(SP), R13
 	MOVQ	48(SP), R12
@@ -146,7 +147,7 @@ done:
 	MOVQ	64(SP), BP
 	MOVQ	72(SP), SI
 	MOVQ	80(SP), DI
-	ADDQ	$88, SP
+	ADDQ	$96, SP
 	POPFQ
 
 	RET

From 997809c809d9bb1016947d9e0bed7d4753496eeb Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 14:52:25 -0400
Subject: [PATCH 236/423] runtime: fix solaris build

nanotime1 is not a Go function and must not store its result at 0(FP).
That overwrites some data owned by the caller.

TBR=aram
CC=golang-codereviews
https://golang.org/cl/138730043
---
 src/pkg/runtime/sys_solaris_amd64.s | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/sys_solaris_amd64.s b/src/pkg/runtime/sys_solaris_amd64.s
index 60447d3499..8506e9939a 100644
--- a/src/pkg/runtime/sys_solaris_amd64.s
+++ b/src/pkg/runtime/sys_solaris_amd64.s
@@ -18,6 +18,7 @@ TEXT runtime·settls(SB),NOSPLIT,$8
 // Set the TLS errno pointer in M.
 //
 // Called using runtime·asmcgocall from os_solaris.c:/minit.
+// NOT USING GO CALLING CONVENTION.
 TEXT runtime·miniterrno(SB),NOSPLIT,$0
 	// asmcgocall will put first argument into DI.
 	CALL	DI	// SysV ABI so returns in AX
@@ -33,6 +34,7 @@ TEXT runtime·miniterrno(SB),NOSPLIT,$0
 // runtime·nanotime stack.
 //
 // Called using runtime·sysvicall6 from os_solaris.c:/nanotime.
+// NOT USING GO CALLING CONVENTION.
 TEXT runtime·nanotime1(SB),NOSPLIT,$0
 	// need space for the timespec argument.
 	SUBQ	$64, SP	// 16 bytes will do, but who knows in the future?
@@ -44,10 +46,10 @@ TEXT runtime·nanotime1(SB),NOSPLIT,$0
 	IMULQ	$1000000000, AX	// multiply into nanoseconds
 	ADDQ	8(SP), AX	// tv_nsec, offset should be stable.
 	ADDQ	$64, SP
-	MOVQ	AX, ret+0(FP)
 	RET
 
 // pipe(3c) wrapper that returns fds in AX, DX.
+// NOT USING GO CALLING CONVENTION.
 TEXT runtime·pipe1(SB),NOSPLIT,$0
 	SUBQ	$16, SP // 8 bytes will do, but stack has to be 16-byte alligned
 	MOVQ	SP, DI
@@ -67,6 +69,7 @@ TEXT runtime·pipe1(SB),NOSPLIT,$0
 // section 3.2.3.
 //
 // Called by runtime·asmcgocall or runtime·cgocall.
+// NOT USING GO CALLING CONVENTION.
 TEXT runtime·asmsysvicall6(SB),NOSPLIT,$0
 	// asmcgocall will put first argument into DI.
 	PUSHQ	DI			// save for later

From 9e360926972b35d2fd4c8f99f22669417876526b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 17:38:01 -0400
Subject: [PATCH 237/423] runtime: fix plan9 build

sighandler now returns its value on the stack.

TBR=0intro
CC=golang-codereviews
https://golang.org/cl/135900043
---
 src/pkg/runtime/sys_plan9_386.s   | 7 ++++---
 src/pkg/runtime/sys_plan9_amd64.s | 7 ++++---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/sys_plan9_386.s b/src/pkg/runtime/sys_plan9_386.s
index 08d0b32395..e40721d342 100644
--- a/src/pkg/runtime/sys_plan9_386.s
+++ b/src/pkg/runtime/sys_plan9_386.s
@@ -183,11 +183,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0
 	MOVL	BP, SP
 
 	// make room for args and g
-	SUBL	$16, SP
+	SUBL	$24, SP
 
 	// save g
 	MOVL	g(AX), BP
-	MOVL	BP, 12(SP)
+	MOVL	BP, 20(SP)
 
 	// g = m->gsignal
 	MOVL	m_gsignal(BX), DI
@@ -199,10 +199,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0
 	MOVL	BP, 8(SP)
 
 	CALL	runtime·sighandler(SB)
+	MOVL	12(SP), AX
 
 	// restore g
 	get_tls(BX)
-	MOVL	12(SP), BP
+	MOVL	20(SP), BP
 	MOVL	BP, g(BX)
 
 	// call noted(AX)
diff --git a/src/pkg/runtime/sys_plan9_amd64.s b/src/pkg/runtime/sys_plan9_amd64.s
index c8fa444996..d83a57e2ac 100644
--- a/src/pkg/runtime/sys_plan9_amd64.s
+++ b/src/pkg/runtime/sys_plan9_amd64.s
@@ -174,11 +174,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0
 	MOVQ	BP, SP
 
 	// make room for args and g
-	SUBQ	$32, SP
+	SUBQ	$40, SP
 
 	// save g
 	MOVQ	g(AX), BP
-	MOVQ	BP, 24(SP)
+	MOVQ	BP, 32(SP)
 
 	// g = m->gsignal
 	MOVQ	R10, g(AX)
@@ -189,10 +189,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0
 	MOVQ	BP, 16(SP)
 
 	CALL	runtime·sighandler(SB)
+	MOVL	24(SP), AX
 
 	// restore g
 	get_tls(BX)
-	MOVQ	24(SP), R10
+	MOVQ	32(SP), R10
 	MOVQ	R10, g(BX)
 
 	// call noted(AX)

From 2c110a11e046920d98fb8b2cb41bfb99a524450b Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 27 Aug 2014 20:15:05 -0400
Subject: [PATCH 238/423] cmd/{ld,link,objdump}, runtime, debug/gosym: move
 linker-defined symbols into runtime package

Fixes #8092.

LGTM=rsc
R=iant, rsc
CC=golang-codereviews
https://golang.org/cl/126790043
---
 misc/cgo/test/cgo_test.go           |   1 +
 misc/cgo/test/issue8092.go          |  36 +++++++++++
 src/cmd/ld/data.c                   |  92 ++++++++++++++--------------
 src/cmd/ld/lib.c                    |   4 +-
 src/cmd/ld/pcln.c                   |   2 +-
 src/cmd/ld/symtab.c                 |  46 +++++++-------
 src/cmd/link/auto.go                |  40 ++++++------
 src/cmd/link/layout.go              |   6 +-
 src/cmd/link/pclntab.go             |   2 +-
 src/cmd/link/pclntab_test.go        |   2 +-
 src/cmd/link/runtime.go             |   4 +-
 src/cmd/link/testdata/autosection.6 | Bin 850 -> 942 bytes
 src/cmd/link/testdata/autosection.s |  22 +++----
 src/cmd/link/testdata/dead.6        | Bin 836 -> 854 bytes
 src/cmd/link/testdata/dead.s        |   3 +-
 src/cmd/link/testdata/genpcln.go    |   2 +-
 src/cmd/link/testdata/pclntab.6     | Bin 3799 -> 3809 bytes
 src/cmd/link/testdata/pclntab.s     |   2 +-
 src/cmd/objdump/main.go             |   4 +-
 src/pkg/debug/gosym/symtab.go       |   2 +-
 src/pkg/runtime/heapdump.c          |  16 ++---
 src/pkg/runtime/malloc.c            |   4 +-
 src/pkg/runtime/mem_plan9.c         |   4 +-
 src/pkg/runtime/mgc0.c              |  28 ++++-----
 src/pkg/runtime/os_dragonfly.c      |   4 +-
 src/pkg/runtime/os_freebsd.c        |   4 +-
 src/pkg/runtime/os_linux.c          |   4 +-
 src/pkg/runtime/os_solaris.c        |  10 +--
 src/pkg/runtime/os_windows_386.c    |   4 +-
 src/pkg/runtime/os_windows_amd64.c  |   4 +-
 src/pkg/runtime/proc.c              |   4 +-
 src/pkg/runtime/race.c              |  10 +--
 src/pkg/runtime/race_amd64.s        |   4 +-
 src/pkg/runtime/stubs.goc           |   6 +-
 src/pkg/runtime/symtab.c            |  36 +++++------
 src/pkg/runtime/symtab.go           |  10 +--
 36 files changed, 229 insertions(+), 193 deletions(-)
 create mode 100644 misc/cgo/test/issue8092.go

diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go
index 3c6d5cb59e..3cc83060fc 100644
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -54,5 +54,6 @@ 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 BenchmarkCgoCall(b *testing.B) { benchCgoCall(b) }
diff --git a/misc/cgo/test/issue8092.go b/misc/cgo/test/issue8092.go
new file mode 100644
index 0000000000..8a14ce6d7a
--- /dev/null
+++ b/misc/cgo/test/issue8092.go
@@ -0,0 +1,36 @@
+// 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 8092. Test that linker defined symbols (e.g., text, data) don't
+// conflict with C symbols.
+
+package cgotest
+
+/*
+char text[] = "text";
+char data[] = "data";
+char *ctext(void) { return text; }
+char *cdata(void) { return data; }
+*/
+import "C"
+
+import "testing"
+
+func test8092(t *testing.T) {
+	tests := []struct {
+		s    string
+		a, b *C.char
+	}{
+		{"text", &C.text[0], C.ctext()},
+		{"data", &C.data[0], C.cdata()},
+	}
+	for _, test := range tests {
+		if test.a != test.b {
+			t.Errorf("%s: pointer mismatch: %v != %v", test.s, test.a, test.b)
+		}
+		if got := C.GoString(test.a); got != test.s {
+			t.Errorf("%s: points at %#v, want %#v", test.s, got, test.s)
+		}
+	}
+}
diff --git a/src/cmd/ld/data.c b/src/cmd/ld/data.c
index a988e807e6..098403a743 100644
--- a/src/cmd/ld/data.c
+++ b/src/cmd/ld/data.c
@@ -987,8 +987,8 @@ dodata(void)
 	sect->align = maxalign(s, SINITARR-1);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "noptrdata", 0)->sect = sect;
-	linklookup(ctxt, "enoptrdata", 0)->sect = sect;
+	linklookup(ctxt, "runtime.noptrdata", 0)->sect = sect;
+	linklookup(ctxt, "runtime.enoptrdata", 0)->sect = sect;
 	for(; s != nil && s->type < SINITARR; s = s->next) {
 		datsize = aligndatsize(datsize, s);
 		s->sect = sect;
@@ -1018,9 +1018,9 @@ dodata(void)
 	sect->align = maxalign(s, SBSS-1);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "data", 0)->sect = sect;
-	linklookup(ctxt, "edata", 0)->sect = sect;
-	gcdata = linklookup(ctxt, "gcdata", 0);
+	linklookup(ctxt, "runtime.data", 0)->sect = sect;
+	linklookup(ctxt, "runtime.edata", 0)->sect = sect;
+	gcdata = linklookup(ctxt, "runtime.gcdata", 0);
 	proggeninit(&gen, gcdata);
 	for(; s != nil && s->type < SBSS; s = s->next) {
 		if(s->type == SINITARR) {
@@ -1042,9 +1042,9 @@ dodata(void)
 	sect->align = maxalign(s, SNOPTRBSS-1);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "bss", 0)->sect = sect;
-	linklookup(ctxt, "ebss", 0)->sect = sect;
-	gcbss = linklookup(ctxt, "gcbss", 0);
+	linklookup(ctxt, "runtime.bss", 0)->sect = sect;
+	linklookup(ctxt, "runtime.ebss", 0)->sect = sect;
+	gcbss = linklookup(ctxt, "runtime.gcbss", 0);
 	proggeninit(&gen, gcbss);
 	for(; s != nil && s->type < SNOPTRBSS; s = s->next) {
 		s->sect = sect;
@@ -1061,8 +1061,8 @@ dodata(void)
 	sect->align = maxalign(s, SNOPTRBSS);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "noptrbss", 0)->sect = sect;
-	linklookup(ctxt, "enoptrbss", 0)->sect = sect;
+	linklookup(ctxt, "runtime.noptrbss", 0)->sect = sect;
+	linklookup(ctxt, "runtime.enoptrbss", 0)->sect = sect;
 	for(; s != nil && s->type == SNOPTRBSS; s = s->next) {
 		datsize = aligndatsize(datsize, s);
 		s->sect = sect;
@@ -1070,7 +1070,7 @@ dodata(void)
 		growdatsize(&datsize, s);
 	}
 	sect->len = datsize - sect->vaddr;
-	linklookup(ctxt, "end", 0)->sect = sect;
+	linklookup(ctxt, "runtime.end", 0)->sect = sect;
 
 	// 6g uses 4-byte relocation offsets, so the entire segment must fit in 32 bits.
 	if(datsize != (uint32)datsize) {
@@ -1141,8 +1141,8 @@ dodata(void)
 	sect->align = maxalign(s, STYPELINK-1);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = 0;
-	linklookup(ctxt, "rodata", 0)->sect = sect;
-	linklookup(ctxt, "erodata", 0)->sect = sect;
+	linklookup(ctxt, "runtime.rodata", 0)->sect = sect;
+	linklookup(ctxt, "runtime.erodata", 0)->sect = sect;
 	for(; s != nil && s->type < STYPELINK; s = s->next) {
 		datsize = aligndatsize(datsize, s);
 		s->sect = sect;
@@ -1157,8 +1157,8 @@ dodata(void)
 	sect->align = maxalign(s, STYPELINK);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "typelink", 0)->sect = sect;
-	linklookup(ctxt, "etypelink", 0)->sect = sect;
+	linklookup(ctxt, "runtime.typelink", 0)->sect = sect;
+	linklookup(ctxt, "runtime.etypelink", 0)->sect = sect;
 	for(; s != nil && s->type == STYPELINK; s = s->next) {
 		datsize = aligndatsize(datsize, s);
 		s->sect = sect;
@@ -1173,8 +1173,8 @@ dodata(void)
 	sect->align = maxalign(s, SPCLNTAB-1);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "symtab", 0)->sect = sect;
-	linklookup(ctxt, "esymtab", 0)->sect = sect;
+	linklookup(ctxt, "runtime.symtab", 0)->sect = sect;
+	linklookup(ctxt, "runtime.esymtab", 0)->sect = sect;
 	for(; s != nil && s->type < SPCLNTAB; s = s->next) {
 		datsize = aligndatsize(datsize, s);
 		s->sect = sect;
@@ -1189,8 +1189,8 @@ dodata(void)
 	sect->align = maxalign(s, SELFROSECT-1);
 	datsize = rnd(datsize, sect->align);
 	sect->vaddr = datsize;
-	linklookup(ctxt, "pclntab", 0)->sect = sect;
-	linklookup(ctxt, "epclntab", 0)->sect = sect;
+	linklookup(ctxt, "runtime.pclntab", 0)->sect = sect;
+	linklookup(ctxt, "runtime.epclntab", 0)->sect = sect;
 	for(; s != nil && s->type < SELFROSECT; s = s->next) {
 		datsize = aligndatsize(datsize, s);
 		s->sect = sect;
@@ -1243,8 +1243,8 @@ textaddress(void)
 	// and then letting threads copy down, but probably not worth it.
 	sect = segtext.sect;
 	sect->align = funcalign;
-	linklookup(ctxt, "text", 0)->sect = sect;
-	linklookup(ctxt, "etext", 0)->sect = sect;
+	linklookup(ctxt, "runtime.text", 0)->sect = sect;
+	linklookup(ctxt, "runtime.etext", 0)->sect = sect;
 	va = INITTEXT;
 	sect->vaddr = va;
 	for(sym = ctxt->textp; sym != nil; sym = sym->next) {
@@ -1355,32 +1355,32 @@ address(void)
 			sub->value += sym->value;
 	}
 
-	xdefine("text", STEXT, text->vaddr);
-	xdefine("etext", STEXT, text->vaddr + text->len);
-	xdefine("rodata", SRODATA, rodata->vaddr);
-	xdefine("erodata", SRODATA, rodata->vaddr + rodata->len);
-	xdefine("typelink", SRODATA, typelink->vaddr);
-	xdefine("etypelink", SRODATA, typelink->vaddr + typelink->len);
+	xdefine("runtime.text", STEXT, text->vaddr);
+	xdefine("runtime.etext", STEXT, text->vaddr + text->len);
+	xdefine("runtime.rodata", SRODATA, rodata->vaddr);
+	xdefine("runtime.erodata", SRODATA, rodata->vaddr + rodata->len);
+	xdefine("runtime.typelink", SRODATA, typelink->vaddr);
+	xdefine("runtime.etypelink", SRODATA, typelink->vaddr + typelink->len);
 
-	sym = linklookup(ctxt, "gcdata", 0);
-	xdefine("egcdata", SRODATA, symaddr(sym) + sym->size);
-	linklookup(ctxt, "egcdata", 0)->sect = sym->sect;
+	sym = linklookup(ctxt, "runtime.gcdata", 0);
+	xdefine("runtime.egcdata", SRODATA, symaddr(sym) + sym->size);
+	linklookup(ctxt, "runtime.egcdata", 0)->sect = sym->sect;
 
-	sym = linklookup(ctxt, "gcbss", 0);
-	xdefine("egcbss", SRODATA, symaddr(sym) + sym->size);
-	linklookup(ctxt, "egcbss", 0)->sect = sym->sect;
+	sym = linklookup(ctxt, "runtime.gcbss", 0);
+	xdefine("runtime.egcbss", SRODATA, symaddr(sym) + sym->size);
+	linklookup(ctxt, "runtime.egcbss", 0)->sect = sym->sect;
 
-	xdefine("symtab", SRODATA, symtab->vaddr);
-	xdefine("esymtab", SRODATA, symtab->vaddr + symtab->len);
-	xdefine("pclntab", SRODATA, pclntab->vaddr);
-	xdefine("epclntab", SRODATA, pclntab->vaddr + pclntab->len);
-	xdefine("noptrdata", SNOPTRDATA, noptr->vaddr);
-	xdefine("enoptrdata", SNOPTRDATA, noptr->vaddr + noptr->len);
-	xdefine("bss", SBSS, bss->vaddr);
-	xdefine("ebss", SBSS, bss->vaddr + bss->len);
-	xdefine("data", SDATA, data->vaddr);
-	xdefine("edata", SDATA, data->vaddr + data->len);
-	xdefine("noptrbss", SNOPTRBSS, noptrbss->vaddr);
-	xdefine("enoptrbss", SNOPTRBSS, noptrbss->vaddr + noptrbss->len);
-	xdefine("end", SBSS, segdata.vaddr + segdata.len);
+	xdefine("runtime.symtab", SRODATA, symtab->vaddr);
+	xdefine("runtime.esymtab", SRODATA, symtab->vaddr + symtab->len);
+	xdefine("runtime.pclntab", SRODATA, pclntab->vaddr);
+	xdefine("runtime.epclntab", SRODATA, pclntab->vaddr + pclntab->len);
+	xdefine("runtime.noptrdata", SNOPTRDATA, noptr->vaddr);
+	xdefine("runtime.enoptrdata", SNOPTRDATA, noptr->vaddr + noptr->len);
+	xdefine("runtime.bss", SBSS, bss->vaddr);
+	xdefine("runtime.ebss", SBSS, bss->vaddr + bss->len);
+	xdefine("runtime.data", SDATA, data->vaddr);
+	xdefine("runtime.edata", SDATA, data->vaddr + data->len);
+	xdefine("runtime.noptrbss", SNOPTRBSS, noptrbss->vaddr);
+	xdefine("runtime.enoptrbss", SNOPTRBSS, noptrbss->vaddr + noptrbss->len);
+	xdefine("runtime.end", SBSS, segdata.vaddr + segdata.len);
 }
diff --git a/src/cmd/ld/lib.c b/src/cmd/ld/lib.c
index 0a5d8d99f2..a68993715d 100644
--- a/src/cmd/ld/lib.c
+++ b/src/cmd/ld/lib.c
@@ -1349,10 +1349,10 @@ genasmsym(void (*put)(LSym*, char*, int, vlong, vlong, int, LSym*))
 
 	// These symbols won't show up in the first loop below because we
 	// skip STEXT symbols. Normal STEXT symbols are emitted by walking textp.
-	s = linklookup(ctxt, "text", 0);
+	s = linklookup(ctxt, "runtime.text", 0);
 	if(s->type == STEXT)
 		put(s, s->name, 'T', s->value, s->size, s->version, 0);
-	s = linklookup(ctxt, "etext", 0);
+	s = linklookup(ctxt, "runtime.etext", 0);
 	if(s->type == STEXT)
 		put(s, s->name, 'T', s->value, s->size, s->version, 0);
 
diff --git a/src/cmd/ld/pcln.c b/src/cmd/ld/pcln.c
index 17f4f992fc..3cd9e65dad 100644
--- a/src/cmd/ld/pcln.c
+++ b/src/cmd/ld/pcln.c
@@ -119,7 +119,7 @@ pclntab(void)
 	static Pcln zpcln;
 	
 	funcdata_bytes = 0;
-	ftab = linklookup(ctxt, "pclntab", 0);
+	ftab = linklookup(ctxt, "runtime.pclntab", 0);
 	ftab->type = SPCLNTAB;
 	ftab->reachable = 1;
 
diff --git a/src/cmd/ld/symtab.c b/src/cmd/ld/symtab.c
index 1805f97d3a..156270c8fa 100644
--- a/src/cmd/ld/symtab.c
+++ b/src/cmd/ld/symtab.c
@@ -346,36 +346,36 @@ symtab(void)
 
 	// Define these so that they'll get put into the symbol table.
 	// data.c:/^address will provide the actual values.
-	xdefine("text", STEXT, 0);
-	xdefine("etext", STEXT, 0);
-	xdefine("typelink", SRODATA, 0);
-	xdefine("etypelink", SRODATA, 0);
-	xdefine("rodata", SRODATA, 0);
-	xdefine("erodata", SRODATA, 0);
-	xdefine("noptrdata", SNOPTRDATA, 0);
-	xdefine("enoptrdata", SNOPTRDATA, 0);
-	xdefine("data", SDATA, 0);
-	xdefine("edata", SDATA, 0);
-	xdefine("bss", SBSS, 0);
-	xdefine("ebss", SBSS, 0);
-	xdefine("noptrbss", SNOPTRBSS, 0);
-	xdefine("enoptrbss", SNOPTRBSS, 0);
-	xdefine("end", SBSS, 0);
-	xdefine("epclntab", SRODATA, 0);
-	xdefine("esymtab", SRODATA, 0);
+	xdefine("runtime.text", STEXT, 0);
+	xdefine("runtime.etext", STEXT, 0);
+	xdefine("runtime.typelink", SRODATA, 0);
+	xdefine("runtime.etypelink", SRODATA, 0);
+	xdefine("runtime.rodata", SRODATA, 0);
+	xdefine("runtime.erodata", SRODATA, 0);
+	xdefine("runtime.noptrdata", SNOPTRDATA, 0);
+	xdefine("runtime.enoptrdata", SNOPTRDATA, 0);
+	xdefine("runtime.data", SDATA, 0);
+	xdefine("runtime.edata", SDATA, 0);
+	xdefine("runtime.bss", SBSS, 0);
+	xdefine("runtime.ebss", SBSS, 0);
+	xdefine("runtime.noptrbss", SNOPTRBSS, 0);
+	xdefine("runtime.enoptrbss", SNOPTRBSS, 0);
+	xdefine("runtime.end", SBSS, 0);
+	xdefine("runtime.epclntab", SRODATA, 0);
+	xdefine("runtime.esymtab", SRODATA, 0);
 
 	// garbage collection symbols
-	s = linklookup(ctxt, "gcdata", 0);
+	s = linklookup(ctxt, "runtime.gcdata", 0);
 	s->type = SRODATA;
 	s->size = 0;
 	s->reachable = 1;
-	xdefine("egcdata", SRODATA, 0);
+	xdefine("runtime.egcdata", SRODATA, 0);
 
-	s = linklookup(ctxt, "gcbss", 0);
+	s = linklookup(ctxt, "runtime.gcbss", 0);
 	s->type = SRODATA;
 	s->size = 0;
 	s->reachable = 1;
-	xdefine("egcbss", SRODATA, 0);
+	xdefine("runtime.egcbss", SRODATA, 0);
 
 	// pseudo-symbols to mark locations of type, string, and go string data.
 	s = linklookup(ctxt, "type.*", 0);
@@ -396,9 +396,9 @@ symtab(void)
 	s->reachable = 1;
 	symgofunc = s;
 	
-	symtypelink = linklookup(ctxt, "typelink", 0);
+	symtypelink = linklookup(ctxt, "runtime.typelink", 0);
 
-	symt = linklookup(ctxt, "symtab", 0);
+	symt = linklookup(ctxt, "runtime.symtab", 0);
 	symt->type = SSYMTAB;
 	symt->size = 0;
 	symt->reachable = 1;
diff --git a/src/cmd/link/auto.go b/src/cmd/link/auto.go
index 8f0c39f8c0..f9228e8cab 100644
--- a/src/cmd/link/auto.go
+++ b/src/cmd/link/auto.go
@@ -18,26 +18,26 @@ import (
 // linkerDefined lists the symbols supplied by other parts of the linker
 // (runtime.go and layout.go).
 var linkerDefined = map[string]bool{
-	"bss":        true,
-	"data":       true,
-	"ebss":       true,
-	"edata":      true,
-	"efunctab":   true,
-	"end":        true,
-	"enoptrbss":  true,
-	"enoptrdata": true,
-	"erodata":    true,
-	"etext":      true,
-	"etypelink":  true,
-	"functab":    true,
-	"gcbss":      true,
-	"gcdata":     true,
-	"noptrbss":   true,
-	"noptrdata":  true,
-	"pclntab":    true,
-	"rodata":     true,
-	"text":       true,
-	"typelink":   true,
+	"runtime.bss":        true,
+	"runtime.data":       true,
+	"runtime.ebss":       true,
+	"runtime.edata":      true,
+	"runtime.efunctab":   true,
+	"runtime.end":        true,
+	"runtime.enoptrbss":  true,
+	"runtime.enoptrdata": true,
+	"runtime.erodata":    true,
+	"runtime.etext":      true,
+	"runtime.etypelink":  true,
+	"runtime.functab":    true,
+	"runtime.gcbss":      true,
+	"runtime.gcdata":     true,
+	"runtime.noptrbss":   true,
+	"runtime.noptrdata":  true,
+	"runtime.pclntab":    true,
+	"runtime.rodata":     true,
+	"runtime.text":       true,
+	"runtime.typelink":   true,
 }
 
 // isAuto reports whether sym is an automatically-generated data or constant symbol.
diff --git a/src/cmd/link/layout.go b/src/cmd/link/layout.go
index 6477022444..149ebced0f 100644
--- a/src/cmd/link/layout.go
+++ b/src/cmd/link/layout.go
@@ -172,9 +172,9 @@ func (p *Prog) layout() {
 			start = sect.VirtAddr
 			end = sect.VirtAddr + sect.Size
 		}
-		p.defineConst(name, start)
-		p.defineConst("e"+name, end)
+		p.defineConst("runtime."+name, start)
+		p.defineConst("runtime.e"+name, end)
 		progEnd = end
 	}
-	p.defineConst("end", progEnd)
+	p.defineConst("runtime.end", progEnd)
 }
diff --git a/src/cmd/link/pclntab.go b/src/cmd/link/pclntab.go
index a950895aa5..232d586bf2 100644
--- a/src/cmd/link/pclntab.go
+++ b/src/cmd/link/pclntab.go
@@ -183,7 +183,7 @@ func (p *Prog) pclntab() {
 
 	pclntab := &Sym{
 		Sym: &goobj.Sym{
-			SymID: goobj.SymID{Name: "pclntab"},
+			SymID: goobj.SymID{Name: "runtime.pclntab"},
 			Kind:  goobj.SPCLNTAB,
 			Size:  buf.Size(),
 			Reloc: buf.Reloc(),
diff --git a/src/cmd/link/pclntab_test.go b/src/cmd/link/pclntab_test.go
index 75d432fc5d..19953f5797 100644
--- a/src/cmd/link/pclntab_test.go
+++ b/src/cmd/link/pclntab_test.go
@@ -141,7 +141,7 @@ func TestPclntab(t *testing.T) {
 // It returns a symbol reader for pclntab, the offset of the function information
 // within that symbol, and the args and frame values read out of the information.
 func findFunc(t *testing.T, p *Prog, name string) (r *SymReader, off, args, frame int, ok bool) {
-	tabsym := p.Syms[goobj.SymID{Name: "pclntab"}]
+	tabsym := p.Syms[goobj.SymID{Name: "runtime.pclntab"}]
 	if tabsym == nil {
 		t.Errorf("pclntab is missing in binary")
 		return
diff --git a/src/cmd/link/runtime.go b/src/cmd/link/runtime.go
index 5d37015eb1..b0c1ac98a6 100644
--- a/src/cmd/link/runtime.go
+++ b/src/cmd/link/runtime.go
@@ -15,13 +15,13 @@ func (p *Prog) runtime() {
 	// TODO: Implement garbage collection data.
 	p.addSym(&Sym{
 		Sym: &goobj.Sym{
-			SymID: goobj.SymID{Name: "gcdata"},
+			SymID: goobj.SymID{Name: "runtime.gcdata"},
 			Kind:  goobj.SRODATA,
 		},
 	})
 	p.addSym(&Sym{
 		Sym: &goobj.Sym{
-			SymID: goobj.SymID{Name: "gcbss"},
+			SymID: goobj.SymID{Name: "runtime.gcbss"},
 			Kind:  goobj.SRODATA,
 		},
 	})
diff --git a/src/cmd/link/testdata/autosection.6 b/src/cmd/link/testdata/autosection.6
index 97e8872bd828a165b9749ed66ca413a170614d46..386f422cf30200674aa2f8676626bb33a126e79e 100644
GIT binary patch
delta 371
zcmcb_wvK&*T)nY@nWcrHxrM2rWwJteYKnqmX}W@uxq_jIm8p@Hk*R`_fuV_lu7Qbx
z0hb~d14DYgp>a+MBf~!?uHur!q7nus1qKE=k6u;=Ab?VbS=c!E7#R2xOH1-g5|e-u
zB5-~|NfD6$9|-svm>3xN*_Z?vK$uUAor#@^Y2u1MIub>tc_o>-sd^=;6(vB$0s=sV
zP}>+76hJ&Fn3Bl{7^OMk8YbUil;K3k{bZC25QC{qDlP_^HGvVNouewXC?CjM0OrB9
zr$W?h0E!C0)f@n;QGyvW*`G;+Qw7eeVAAANfb$kHsc<4x9%oYJgj+xPEmJB0nnGXx

delta 251
zcmZ3-eu-^@Txv>Uiiw4hQBrbpTAD(5YKnqmX}W@enS!B#m63&&p{0V6fuV_lu7SCM
z0hb~d14DYgp>a+MBf~!?uHur!q7nus1qKGO9SlGKCJwVOaWFA3@FkX(<d-BS0fl)u
zm?pL>u(C3-GO<lu^M{dR@<v7}S+3NQ)QS?Iw1EK71gKdI3=RT7%^Z_|Fv>7;O_pVn
zvtUaqE(WTazzCM8N-fF<@)kgNsSvphK%M{t2UP9=SWakiH<JdV$mBgtnv4RI-!Z8$
Q3Qd+~R%K+H?8%%80RH$jvH$=8

diff --git a/src/cmd/link/testdata/autosection.s b/src/cmd/link/testdata/autosection.s
index fd9e94da4e..e0cb21723e 100644
--- a/src/cmd/link/testdata/autosection.s
+++ b/src/cmd/link/testdata/autosection.s
@@ -16,37 +16,37 @@ GLOBL zero(SB), $8
 GLOBL zeronoptr(SB), NOPTR, $16
 
 // text
-DATA autotab+0x00(SB)/8, $text(SB)
+DATA autotab+0x00(SB)/8, $runtime·text(SB)
 DATA autotab+0x08(SB)/8, $start(SB)
-DATA autotab+0x10(SB)/8, $etext(SB)
+DATA autotab+0x10(SB)/8, $runtime·etext(SB)
 DATA autotab+0x18(SB)/8, $start+16(SB)
 
 // data
-DATA autotab+0x20(SB)/8, $data(SB)
+DATA autotab+0x20(SB)/8, $runtime·data(SB)
 DATA autotab+0x28(SB)/8, $autotab(SB)
-DATA autotab+0x30(SB)/8, $edata(SB)
+DATA autotab+0x30(SB)/8, $runtime·edata(SB)
 DATA autotab+0x38(SB)/8, $nonzero+4(SB)
 
 // bss
-DATA autotab+0x40(SB)/8, $bss(SB)
+DATA autotab+0x40(SB)/8, $runtime·bss(SB)
 DATA autotab+0x48(SB)/8, $zero(SB)
-DATA autotab+0x50(SB)/8, $ebss(SB)
+DATA autotab+0x50(SB)/8, $runtime·ebss(SB)
 DATA autotab+0x58(SB)/8, $zero+8(SB)
 
 // noptrdata
-DATA autotab+0x60(SB)/8, $noptrdata(SB)
+DATA autotab+0x60(SB)/8, $runtime·noptrdata(SB)
 DATA autotab+0x68(SB)/8, $nonzeronoptr(SB)
-DATA autotab+0x70(SB)/8, $enoptrdata(SB)
+DATA autotab+0x70(SB)/8, $runtime·enoptrdata(SB)
 DATA autotab+0x78(SB)/8, $nonzeronoptr+8(SB)
 
 // noptrbss
-DATA autotab+0x80(SB)/8, $noptrbss(SB)
+DATA autotab+0x80(SB)/8, $runtime·noptrbss(SB)
 DATA autotab+0x88(SB)/8, $zeronoptr(SB)
-DATA autotab+0x90(SB)/8, $enoptrbss(SB)
+DATA autotab+0x90(SB)/8, $runtime·enoptrbss(SB)
 DATA autotab+0x98(SB)/8, $zeronoptr+16(SB)
 
 // end
-DATA autotab+0xa0(SB)/8, $end(SB)
+DATA autotab+0xa0(SB)/8, $runtime·end(SB)
 DATA autotab+0xa8(SB)/8, $zeronoptr+16(SB)
 
 GLOBL autotab(SB), $0xb0
diff --git a/src/cmd/link/testdata/dead.6 b/src/cmd/link/testdata/dead.6
index c60b1b6c645942c6c96a07f790eeeebc1e21a354..9540adc1aff7df54fcb89a845b3d6e988c37a23a 100644
GIT binary patch
delta 321
zcmX@Yc8zU<T)nY@nWcrHxrM2rWwJteYKnqmX}W@uxq_jIm8p@Hk*R`_fuV_lu7Qbx
z0hb~d14DYgp>a+MBf~!?uHur!q7nus2L=WWk6u;=Ab0^HJbGn8)L}L@4n773u9U=*
zL_;P91_2H>Ag?5~qQnp=D+iV<NmZyQF#>Y`0|7q+P!$`K0vHR4u`{tUu`}^b+!-z*
z05g&aY@}3CX<kWYZmQm7IYwz_b|%irHjL6a4tSj*l9HO35)XC@&^oYNAVMe(LI`1Z
OlmpaJoA)!eG6Dc+7(lWB

delta 277
zcmcb{c7$z$TzyJniiw4hQBrbpTAD(5YKnqmX}W@enS!B#m63&&p{0V6fuV_lu7SCM
z0hb~d14DYgp>a+MBf~!?uHur!q7nus1qKF%9SlJ50z~Wv5r^5BIG7k1xKa{J5)FY2
z9u77juOzji#1JSe29^Wyj2I>xF$!}EiLo+)AmhZn;e0$06PO?-Ox9tPW@csLo_vu}
vWO5uMySD;P+eA`Q6I0^BRst;nTL}?Du@@m^G}(|*gj2`?YWL=gjIE3Si1RmK

diff --git a/src/cmd/link/testdata/dead.s b/src/cmd/link/testdata/dead.s
index 832ddaff60..86f31360fa 100644
--- a/src/cmd/link/testdata/dead.s
+++ b/src/cmd/link/testdata/dead.s
@@ -17,7 +17,7 @@ TEXT text1(SB),7,$0
 	RET
 
 TEXT text2(SB),7,$0
-	MOVQ $edata(SB),BX
+	MOVQ $runtime·edata(SB),BX
 	RET
 
 DATA data1<>+0(SB)/8, $data2(SB)
@@ -46,4 +46,3 @@ GLOBL dead_data1(SB), $16
 GLOBL dead_data2(SB), $1
 GLOBL dead_data3(SB), $1
 GLOBL dead_funcdata(SB), $8
-
diff --git a/src/cmd/link/testdata/genpcln.go b/src/cmd/link/testdata/genpcln.go
index 684cc07a27..c10eaeae91 100644
--- a/src/cmd/link/testdata/genpcln.go
+++ b/src/cmd/link/testdata/genpcln.go
@@ -107,6 +107,6 @@ func main() {
 	for f := 0; f < 3; f++ {
 		fmt.Printf("\tCALL func%d(SB)\n", f)
 	}
-	fmt.Printf("\tMOVQ $pclntab(SB), AX\n")
+	fmt.Printf("\tMOVQ $runtime·pclntab(SB), AX\n")
 	fmt.Printf("\n\tRET\n")
 }
diff --git a/src/cmd/link/testdata/pclntab.6 b/src/cmd/link/testdata/pclntab.6
index 596daa9b57eb4dc09c1b34d099732fd5370fa7f1..9e7f9afdb044460e718d53c00afda317251c6351 100644
GIT binary patch
delta 103
zcmcaE`%rd*oTjmXnWcrHxrM2rWwJteYKnqmX}W@uxq_jIm8p@Hk*R`_fuV_lu7Sx$
x_ba@@dM_A&06}>4vQF0FGvHI<;A3ErD=N(^$;?gFo1Da_!pzRXHMx_|4**8f7}Ed%

delta 93
zcmaDTdtG*doMuX5iiw4hQBrbpTAD(5YKnqmX}W@enS!B#m63&&p{0V6fuV_lu7UYR
n_ba@DS}z!Y072}StjA}-roh3(z`!>-hfjr>m4#>WWIjItwzd|k

diff --git a/src/cmd/link/testdata/pclntab.s b/src/cmd/link/testdata/pclntab.s
index 22c4ee0dec..12dac70b0c 100644
--- a/src/cmd/link/testdata/pclntab.s
+++ b/src/cmd/link/testdata/pclntab.s
@@ -1746,6 +1746,6 @@ TEXT start(SB),7,$0
 	CALL func0(SB)
 	CALL func1(SB)
 	CALL func2(SB)
-	MOVQ $pclntab(SB), AX
+	MOVQ $runtime·pclntab(SB), AX
 
 	RET
diff --git a/src/cmd/objdump/main.go b/src/cmd/objdump/main.go
index 9922dcc023..42f015be70 100644
--- a/src/cmd/objdump/main.go
+++ b/src/cmd/objdump/main.go
@@ -101,7 +101,7 @@ func main() {
 	keep := syms[:0]
 	for _, sym := range syms {
 		switch sym.Name {
-		case "text", "_text", "etext", "_etext":
+		case "runtime.text", "text", "_text", "runtime.etext", "etext", "_etext":
 			// drop
 		default:
 			keep = append(keep, sym)
@@ -118,7 +118,7 @@ func main() {
 		i := sort.Search(len(syms), func(i int) bool { return syms[i].Addr > addr })
 		if i > 0 {
 			s := syms[i-1]
-			if s.Addr <= addr && addr < s.Addr+uint64(s.Size) && s.Name != "etext" && s.Name != "_etext" {
+			if s.Addr <= addr && addr < s.Addr+uint64(s.Size) && s.Name != "runtime.etext" && s.Name != "etext" && s.Name != "_etext" {
 				return s.Name, s.Addr
 			}
 		}
diff --git a/src/pkg/debug/gosym/symtab.go b/src/pkg/debug/gosym/symtab.go
index 3864e3cb4f..ee18499d11 100644
--- a/src/pkg/debug/gosym/symtab.go
+++ b/src/pkg/debug/gosym/symtab.go
@@ -402,7 +402,7 @@ func NewTable(symtab []byte, pcln *LineTable) (*Table, error) {
 			if n := len(t.Funcs); n > 0 {
 				t.Funcs[n-1].End = sym.Value
 			}
-			if sym.Name == "etext" {
+			if sym.Name == "runtime.etext" || sym.Name == "etext" {
 				continue
 			}
 
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index ea299d0a2e..09d109199b 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -19,10 +19,10 @@
 #include "zaexperiment.h"
 #include "../../cmd/ld/textflag.h"
 
-extern byte data[];
-extern byte edata[];
-extern byte bss[];
-extern byte ebss[];
+extern byte runtime·data[];
+extern byte runtime·edata[];
+extern byte runtime·bss[];
+extern byte runtime·ebss[];
 
 enum {
 	FieldKindEol = 0,
@@ -487,14 +487,14 @@ dumproots(void)
 
 	// data segment
 	dumpint(TagData);
-	dumpint((uintptr)data);
-	dumpmemrange(data, edata - data);
+	dumpint((uintptr)runtime·data);
+	dumpmemrange(runtime·data, runtime·edata - runtime·data);
 	dumpfields(runtime·gcdatamask);
 
 	// bss segment
 	dumpint(TagBss);
-	dumpint((uintptr)bss);
-	dumpmemrange(bss, ebss - bss);
+	dumpint((uintptr)runtime·bss);
+	dumpmemrange(runtime·bss, runtime·ebss - runtime·bss);
 	dumpfields(runtime·gcdatamask);
 
 	// MSpan.types
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index ca8ebf5dd6..913d8ac26b 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -125,7 +125,7 @@ runtime·mallocinit(void)
 {
 	byte *p, *p1;
 	uintptr arena_size, bitmap_size, spans_size, p_size;
-	extern byte end[];
+	extern byte runtime·end[];
 	uintptr limit;
 	uint64 i;
 	bool reserved;
@@ -232,7 +232,7 @@ runtime·mallocinit(void)
 		// So adjust it upward a little bit ourselves: 1/4 MB to get
 		// away from the running binary image and then round up
 		// to a MB boundary.
-		p = (byte*)ROUND((uintptr)end + (1<<18), 1<<20);
+		p = (byte*)ROUND((uintptr)runtime·end + (1<<18), 1<<20);
 		p_size = bitmap_size + spans_size + arena_size + PageSize;
 		p = runtime·SysReserve(p, p_size, &reserved);
 		if(p == nil)
diff --git a/src/pkg/runtime/mem_plan9.c b/src/pkg/runtime/mem_plan9.c
index ea35a1709c..249c6f2255 100644
--- a/src/pkg/runtime/mem_plan9.c
+++ b/src/pkg/runtime/mem_plan9.c
@@ -8,8 +8,8 @@
 #include "malloc.h"
 #include "os_GOOS.h"
 
-extern byte end[];
-static byte *bloc = { end };
+extern byte runtime·end[];
+static byte *bloc = { runtime·end };
 static Lock memlock;
 
 enum
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 61961f6471..68e45a316e 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -158,13 +158,13 @@ struct FinBlock
 	Finalizer fin[1];
 };
 
-extern byte data[];
-extern byte edata[];
-extern byte bss[];
-extern byte ebss[];
+extern byte runtime·data[];
+extern byte runtime·edata[];
+extern byte runtime·bss[];
+extern byte runtime·ebss[];
 
-extern byte gcdata[];
-extern byte gcbss[];
+extern byte runtime·gcdata[];
+extern byte runtime·gcbss[];
 
 static Lock	finlock;	// protects the following variables
 static FinBlock	*finq;		// list of finalizers that are to be executed
@@ -490,11 +490,11 @@ markroot(ParFor *desc, uint32 i)
 	// Note: if you add a case here, please also update heapdump.c:dumproots.
 	switch(i) {
 	case RootData:
-		scanblock(data, edata - data, (byte*)runtime·gcdatamask.data);
+		scanblock(runtime·data, runtime·edata - runtime·data, (byte*)runtime·gcdatamask.data);
 		break;
 
 	case RootBss:
-		scanblock(bss, ebss - bss, (byte*)runtime·gcbssmask.data);
+		scanblock(runtime·bss, runtime·ebss - runtime·bss, (byte*)runtime·gcbssmask.data);
 		break;
 
 	case RootFinalizers:
@@ -1300,8 +1300,8 @@ runtime·gcinit(void)
 
 	work.markfor = runtime·parforalloc(MaxGcproc);
 	runtime·gcpercent = runtime·readgogc();
-	runtime·gcdatamask = unrollglobgcprog(gcdata, edata - data);
-	runtime·gcbssmask = unrollglobgcprog(gcbss, ebss - bss);
+	runtime·gcdatamask = unrollglobgcprog(runtime·gcdata, runtime·edata - runtime·data);
+	runtime·gcbssmask = unrollglobgcprog(runtime·gcbss, runtime·ebss - runtime·bss);
 }
 
 // force = 1 - do GC regardless of current heap usage
@@ -2035,24 +2035,24 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 	*len = 0;
 
 	// data
-	if(p >= data && p < edata) {
+	if(p >= runtime·data && p < runtime·edata) {
 		n = ((PtrType*)t)->elem->size;
 		*len = n/PtrSize;
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
-			off = (p+i-data)/PtrSize;
+			off = (p+i-runtime·data)/PtrSize;
 			bits = (((byte*)runtime·gcdatamask.data)[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
 		return;
 	}
 	// bss
-	if(p >= bss && p < ebss) {
+	if(p >= runtime·bss && p < runtime·ebss) {
 		n = ((PtrType*)t)->elem->size;
 		*len = n/PtrSize;
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
-			off = (p+i-bss)/PtrSize;
+			off = (p+i-runtime·bss)/PtrSize;
 			bits = (((byte*)runtime·gcbssmask.data)[off/PointersPerByte] >> ((off%PointersPerByte)*BitsPerPointer))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
diff --git a/src/pkg/runtime/os_dragonfly.c b/src/pkg/runtime/os_dragonfly.c
index ce5307af07..1132f5741d 100644
--- a/src/pkg/runtime/os_dragonfly.c
+++ b/src/pkg/runtime/os_dragonfly.c
@@ -207,7 +207,7 @@ uintptr
 runtime·memlimit(void)
 {
 	Rlimit rl;
-	extern byte text[], end[];
+	extern byte runtime·text[], runtime·end[];
 	uintptr used;
 	
 	if(runtime·getrlimit(RLIMIT_AS, &rl) != 0)
@@ -218,7 +218,7 @@ runtime·memlimit(void)
 	// Estimate our VM footprint excluding the heap.
 	// Not an exact science: use size of binary plus
 	// some room for thread stacks.
-	used = end - text + (64<<20);
+	used = runtime·end - runtime·text + (64<<20);
 	if(used >= rl.rlim_cur)
 		return 0;
 
diff --git a/src/pkg/runtime/os_freebsd.c b/src/pkg/runtime/os_freebsd.c
index 794578c208..20f71c41e8 100644
--- a/src/pkg/runtime/os_freebsd.c
+++ b/src/pkg/runtime/os_freebsd.c
@@ -215,7 +215,7 @@ uintptr
 runtime·memlimit(void)
 {
 	Rlimit rl;
-	extern byte text[], end[];
+	extern byte runtime·text[], runtime·end[];
 	uintptr used;
 	
 	if(runtime·getrlimit(RLIMIT_AS, &rl) != 0)
@@ -226,7 +226,7 @@ runtime·memlimit(void)
 	// Estimate our VM footprint excluding the heap.
 	// Not an exact science: use size of binary plus
 	// some room for thread stacks.
-	used = end - text + (64<<20);
+	used = runtime·end - runtime·text + (64<<20);
 	if(used >= rl.rlim_cur)
 		return 0;
 
diff --git a/src/pkg/runtime/os_linux.c b/src/pkg/runtime/os_linux.c
index 77754f481c..33c7563743 100644
--- a/src/pkg/runtime/os_linux.c
+++ b/src/pkg/runtime/os_linux.c
@@ -255,7 +255,7 @@ uintptr
 runtime·memlimit(void)
 {
 	Rlimit rl;
-	extern byte text[], end[];
+	extern byte runtime·text[], runtime·end[];
 	uintptr used;
 
 	if(runtime·getrlimit(RLIMIT_AS, &rl) != 0)
@@ -266,7 +266,7 @@ runtime·memlimit(void)
 	// Estimate our VM footprint excluding the heap.
 	// Not an exact science: use size of binary plus
 	// some room for thread stacks.
-	used = end - text + (64<<20);
+	used = runtime·end - runtime·text + (64<<20);
 	if(used >= rl.rlim_cur)
 		return 0;
 
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index fe218cdb81..272e07cdb5 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -9,9 +9,9 @@
 #include "stack.h"
 #include "../../cmd/ld/textflag.h"
 
-#pragma dynexport end _end
-#pragma dynexport etext _etext
-#pragma dynexport edata _edata
+#pragma dynexport runtime·end _end
+#pragma dynexport runtime·etext _etext
+#pragma dynexport runtime·edata _edata
 
 #pragma dynimport libc·___errno ___errno "libc.so"
 #pragma dynimport libc·clock_gettime clock_gettime "libc.so"
@@ -247,7 +247,7 @@ uintptr
 runtime·memlimit(void)
 {
 	Rlimit rl;
-	extern byte text[], end[];
+	extern byte runtime·text[], runtime·end[];
 	uintptr used;
 	
 	if(runtime·getrlimit(RLIMIT_AS, &rl) != 0)
@@ -258,7 +258,7 @@ runtime·memlimit(void)
 	// Estimate our VM footprint excluding the heap.
 	// Not an exact science: use size of binary plus
 	// some room for thread stacks.
-	used = end - text + (64<<20);
+	used = runtime·end - runtime·text + (64<<20);
 	if(used >= rl.rlim_cur)
 		return 0;
 
diff --git a/src/pkg/runtime/os_windows_386.c b/src/pkg/runtime/os_windows_386.c
index 02bc81adbf..15a5ea5d1f 100644
--- a/src/pkg/runtime/os_windows_386.c
+++ b/src/pkg/runtime/os_windows_386.c
@@ -34,7 +34,7 @@ runtime·sighandler(ExceptionRecord *info, Context *r, G *gp)
 {
 	bool crash;
 	uintptr *sp;
-	extern byte text[], etext[];
+	extern byte runtime·text[], runtime·etext[];
 
 	if(info->ExceptionCode == DBG_PRINTEXCEPTION_C) {
 		// This exception is intended to be caught by debuggers.
@@ -51,7 +51,7 @@ runtime·sighandler(ExceptionRecord *info, Context *r, G *gp)
 
 	// Only handle exception if executing instructions in Go binary
 	// (not Windows library code). 
-	if(r->Eip < (uint32)text || (uint32)etext < r->Eip)
+	if(r->Eip < (uint32)runtime·text || (uint32)runtime·etext < r->Eip)
 		return 0;
 
 	switch(info->ExceptionCode) {
diff --git a/src/pkg/runtime/os_windows_amd64.c b/src/pkg/runtime/os_windows_amd64.c
index a7acf1d786..9a69d73c07 100644
--- a/src/pkg/runtime/os_windows_amd64.c
+++ b/src/pkg/runtime/os_windows_amd64.c
@@ -42,7 +42,7 @@ runtime·sighandler(ExceptionRecord *info, Context *r, G *gp)
 {
 	bool crash;
 	uintptr *sp;
-	extern byte text[], etext[];
+	extern byte runtime·text[], runtime·etext[];
 
 	if(info->ExceptionCode == DBG_PRINTEXCEPTION_C) {
 		// This exception is intended to be caught by debuggers.
@@ -59,7 +59,7 @@ runtime·sighandler(ExceptionRecord *info, Context *r, G *gp)
 
 	// Only handle exception if executing instructions in Go binary
 	// (not Windows library code). 
-	if(r->Rip < (uint64)text || (uint64)etext < r->Rip)
+	if(r->Rip < (uint64)runtime·text || (uint64)runtime·etext < r->Rip)
 		return 0;
 
 	switch(info->ExceptionCode) {
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 756f86bd99..a692dfd2cf 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2407,7 +2407,7 @@ static struct {
 static void System(void) {}
 static void ExternalCode(void) {}
 static void GC(void) {}
-extern byte etext[];
+extern byte runtime·etext[];
 
 // Called if we receive a SIGPROF signal.
 void
@@ -2532,7 +2532,7 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 			// If all of the above has failed, account it against abstract "System" or "GC".
 			n = 2;
 			// "ExternalCode" is better than "etext".
-			if((uintptr)pc > (uintptr)etext)
+			if((uintptr)pc > (uintptr)runtime·etext)
 				pc = (byte*)ExternalCode + PCQuantum;
 			stk[0] = (uintptr)pc;
 			if(mp->gcing || mp->helpgc)
diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index 6a4d2803c1..07623be1aa 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -47,8 +47,8 @@ void __tsan_release_merge(void);
 #pragma cgo_import_static __tsan_func_enter
 #pragma cgo_import_static __tsan_func_exit
 
-extern byte noptrdata[];
-extern byte enoptrbss[];
+extern byte runtime·noptrdata[];
+extern byte runtime·enoptrbss[];
   
 // start/end of heap for race_amd64.s
 uintptr runtime·racearenastart;
@@ -70,7 +70,7 @@ isvalidaddr(uintptr addr)
 {
 	if(addr >= runtime·racearenastart && addr < runtime·racearenaend)
 		return true;
-	if(addr >= (uintptr)noptrdata && addr < (uintptr)enoptrbss)
+	if(addr >= (uintptr)runtime·noptrdata && addr < (uintptr)runtime·enoptrbss)
 		return true;
 	return false;
 }
@@ -85,8 +85,8 @@ runtime·raceinit(void)
 		runtime·throw("raceinit: race build must use cgo");
 	runtime·racecall(__tsan_init, &racectx, runtime·racesymbolizethunk);
 	// Round data segment to page boundaries, because it's used in mmap().
-	start = (uintptr)noptrdata & ~(PageSize-1);
-	size = ROUND((uintptr)enoptrbss - start, PageSize);
+	start = (uintptr)runtime·noptrdata & ~(PageSize-1);
+	size = ROUND((uintptr)runtime·enoptrbss - start, PageSize);
 	runtime·racecall(__tsan_map_shadow, start, size);
 	return racectx;
 }
diff --git a/src/pkg/runtime/race_amd64.s b/src/pkg/runtime/race_amd64.s
index 30281d224b..f4e72386d8 100644
--- a/src/pkg/runtime/race_amd64.s
+++ b/src/pkg/runtime/race_amd64.s
@@ -144,10 +144,10 @@ TEXT	racecalladdr<>(SB), NOSPLIT, $0-0
 	CMPQ	RARG1, runtime·racearenaend(SB)
 	JB	racecalladdr_call
 racecalladdr_data:
-	MOVQ	$noptrdata(SB), R13
+	MOVQ	$runtime·noptrdata(SB), R13
 	CMPQ	RARG1, R13
 	JB	racecalladdr_ret
-	MOVQ	$enoptrbss(SB), R13
+	MOVQ	$runtime·enoptrbss(SB), R13
 	CMPQ	RARG1, R13
 	JAE	racecalladdr_ret
 racecalladdr_call:
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index b30c40286c..1cda75e395 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -123,8 +123,8 @@ func gopersistentalloc(size uintptr) (x *void) {
 
 #pragma textflag NOSPLIT
 func reflect·typelinks() (ret Slice) {
-        extern Type *typelink[], *etypelink[];
-        ret.array = (byte*)typelink;
-        ret.len = etypelink - typelink;
+        extern Type *runtime·typelink[], *runtime·etypelink[];
+        ret.array = (byte*)runtime·typelink;
+        ret.len = runtime·etypelink - runtime·typelink;
         ret.cap = ret.len;
 }
diff --git a/src/pkg/runtime/symtab.c b/src/pkg/runtime/symtab.c
index 613aa942ed..802ad5da38 100644
--- a/src/pkg/runtime/symtab.c
+++ b/src/pkg/runtime/symtab.c
@@ -19,15 +19,15 @@ struct Ftab
 	uintptr	funcoff;
 };
 
-extern byte pclntab[];
-extern byte epclntab[];
+extern byte runtime·pclntab[];
+extern byte runtime·epclntab[];
 
 static Ftab *ftab;
 static uintptr runtime·nftab;
 static uint32 *filetab;
 static uint32 runtime·nfiletab;
 
-extern Slice runtime·pclntab;
+extern Slice runtime·pclntable;
 extern Slice runtime·ftabs;
 extern Slice runtime·filetab;
 extern uint32 runtime·pcquantum;
@@ -43,33 +43,33 @@ runtime·symtabinit(void)
 	// See golang.org/s/go12symtab for header: 0xfffffffb,
 	// two zero bytes, a byte giving the PC quantum,
 	// and a byte giving the pointer width in bytes.
-	if(*(uint32*)pclntab != 0xfffffffb || pclntab[4] != 0 || pclntab[5] != 0 || pclntab[6] != PCQuantum || pclntab[7] != sizeof(void*)) {
-		runtime·printf("runtime: function symbol table header: %x %x\n", *(uint32*)pclntab, *(uint32*)(pclntab+4));
+	if(*(uint32*)runtime·pclntab != 0xfffffffb || runtime·pclntab[4] != 0 || runtime·pclntab[5] != 0 || runtime·pclntab[6] != PCQuantum || runtime·pclntab[7] != sizeof(void*)) {
+		runtime·printf("runtime: function symbol table header: %x %x\n", *(uint32*)runtime·pclntab, *(uint32*)(runtime·pclntab+4));
 		runtime·throw("invalid function symbol table\n");
 	}
 
-	runtime·nftab = *(uintptr*)(pclntab+8);
-	ftab = (Ftab*)(pclntab+8+sizeof(void*));
+	runtime·nftab = *(uintptr*)(runtime·pclntab+8);
+	ftab = (Ftab*)(runtime·pclntab+8+sizeof(void*));
 	for(i=0; i<runtime·nftab; i++) {
 		// NOTE: ftab[runtime·nftab].entry is legal; it is the address beyond the final function.
 		if(ftab[i].entry > ftab[i+1].entry) {
-			f1 = (Func*)(pclntab + ftab[i].funcoff);
-			f2 = (Func*)(pclntab + ftab[i+1].funcoff);
+			f1 = (Func*)(runtime·pclntab + ftab[i].funcoff);
+			f2 = (Func*)(runtime·pclntab + ftab[i+1].funcoff);
 			runtime·printf("function symbol table not sorted by program counter: %p %s > %p %s", ftab[i].entry, runtime·funcname(f1), ftab[i+1].entry, i+1 == runtime·nftab ? "end" : runtime·funcname(f2));
 			for(j=0; j<=i; j++)
-				runtime·printf("\t%p %s\n", ftab[j].entry, runtime·funcname((Func*)(pclntab + ftab[j].funcoff)));
+				runtime·printf("\t%p %s\n", ftab[j].entry, runtime·funcname((Func*)(runtime·pclntab + ftab[j].funcoff)));
 			runtime·throw("invalid runtime symbol table");
 		}
 	}
 	
-	filetab = (uint32*)(pclntab + *(uint32*)&ftab[runtime·nftab].funcoff);
+	filetab = (uint32*)(runtime·pclntab + *(uint32*)&ftab[runtime·nftab].funcoff);
 	runtime·nfiletab = filetab[0];
 
 	runtime·pcquantum = PCQuantum;
 
-	runtime·pclntab.array = (byte*)pclntab;
-	runtime·pclntab.len = (byte*)epclntab - (byte*)pclntab;
-	runtime·pclntab.cap = runtime·pclntab.len;
+	runtime·pclntable.array = (byte*)runtime·pclntab;
+	runtime·pclntable.len = (byte*)runtime·epclntab - (byte*)runtime·pclntab;
+	runtime·pclntable.cap = runtime·pclntable.len;
 
 	runtime·ftabs.array = (byte*)ftab;
 	runtime·ftabs.len = runtime·nftab+1;
@@ -155,7 +155,7 @@ pcvalue(Func *f, int32 off, uintptr targetpc, bool strict)
 	// The table ends at a value delta of 0 except in the first pair.
 	if(off == 0)
 		return -1;
-	p = pclntab + off;
+	p = runtime·pclntab + off;
 	pc = f->entry;
 	value = -1;
 
@@ -194,7 +194,7 @@ runtime·funcname(Func *f)
 {
 	if(f == nil || f->nameoff == 0)
 		return nil;
-	return (int8*)(pclntab + f->nameoff);
+	return (int8*)(runtime·pclntab + f->nameoff);
 }
 
 static int32
@@ -210,7 +210,7 @@ funcline(Func *f, uintptr targetpc, String *file, bool strict)
 		// runtime·printf("looking for %p in %S got file=%d line=%d\n", targetpc, *f->name, fileno, line);
 		return 0;
 	}
-	*file = runtime·gostringnocopy(pclntab + filetab[fileno]);
+	*file = runtime·gostringnocopy(runtime·pclntab + filetab[fileno]);
 	return line;
 }
 
@@ -264,7 +264,7 @@ runtime·findfunc(uintptr addr)
 	while(nf > 0) {
 		n = nf/2;
 		if(f[n].entry <= addr && addr < f[n+1].entry)
-			return (Func*)(pclntab + f[n].funcoff);
+			return (Func*)(runtime·pclntab + f[n].funcoff);
 		else if(addr < f[n].entry)
 			nf = n;
 		else {
diff --git a/src/pkg/runtime/symtab.go b/src/pkg/runtime/symtab.go
index e8f45cfc01..880a78d481 100644
--- a/src/pkg/runtime/symtab.go
+++ b/src/pkg/runtime/symtab.go
@@ -24,7 +24,7 @@ func FuncForPC(pc uintptr) *Func {
 		n := nf / 2
 		f := &ftabs[lo+n]
 		if f.entry <= pc && pc < ftabs[lo+n+1].entry {
-			return (*Func)(unsafe.Pointer(&pclntab[f.funcoff]))
+			return (*Func)(unsafe.Pointer(&pclntable[f.funcoff]))
 		} else if pc < f.entry {
 			nf = n
 		} else {
@@ -39,7 +39,7 @@ func FuncForPC(pc uintptr) *Func {
 
 // Name returns the name of the function.
 func (f *Func) Name() string {
-	return cstringToGo(unsafe.Pointer(&pclntab[f.nameoff]))
+	return cstringToGo(unsafe.Pointer(&pclntable[f.nameoff]))
 }
 
 // Entry returns the entry address of the function.
@@ -60,7 +60,7 @@ func (f *Func) FileLine(pc uintptr) (file string, line int) {
 	if line == -1 {
 		return "?", 0
 	}
-	file = cstringToGo(unsafe.Pointer(&pclntab[filetab[fileno]]))
+	file = cstringToGo(unsafe.Pointer(&pclntable[filetab[fileno]]))
 	return file, line
 }
 
@@ -69,7 +69,7 @@ func (f *Func) pcvalue(off int32, targetpc uintptr) int32 {
 	if off == 0 {
 		return -1
 	}
-	p := pclntab[off:]
+	p := pclntable[off:]
 	pc := f.entry
 	val := int32(-1)
 	for {
@@ -120,7 +120,7 @@ func readvarint(p []byte) (newp []byte, val uint32) {
 
 // Populated by runtime·symtabinit during bootstrapping. Treat as immutable.
 var (
-	pclntab   []byte
+	pclntable []byte
 	ftabs     []ftab
 	filetab   []uint32
 	pcquantum uint32

From 43d4f93c91587323d6141dcd4cbcccb0ee8bfab3 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Wed, 27 Aug 2014 18:01:17 -0700
Subject: [PATCH 239/423] cmd/{addr2line,objdump}: fix finding pclntab and
 symtab for pe and plan9obj

Broken by 8b5fc7c59d05.

Update #8092

LGTM=iant, alex.brainman
R=rsc, iant, alex.brainman
CC=golang-codereviews
https://golang.org/cl/138770043
---
 src/cmd/internal/objfile/pe.go       | 17 ++++++++++----
 src/cmd/internal/objfile/plan9obj.go | 17 ++++++++++----
 src/cmd/objdump/main.go              | 34 +++++++++++++++++++++-------
 3 files changed, 52 insertions(+), 16 deletions(-)

diff --git a/src/cmd/internal/objfile/pe.go b/src/cmd/internal/objfile/pe.go
index 492766d9a2..868709eaf9 100644
--- a/src/cmd/internal/objfile/pe.go
+++ b/src/cmd/internal/objfile/pe.go
@@ -115,11 +115,20 @@ func (f *peFile) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
 	if sect := f.pe.Section(".text"); sect != nil {
 		textStart = imageBase + uint64(sect.VirtualAddress)
 	}
-	if pclntab, err = loadPETable(f.pe, "pclntab", "epclntab"); err != nil {
-		return 0, nil, nil, err
+	if pclntab, err = loadPETable(f.pe, "runtime.pclntab", "runtime.epclntab"); err != nil {
+		// We didn't find the symbols, so look for the names used in 1.3 and earlier.
+		// TODO: Remove code looking for the old symbols when we no longer care about 1.3.
+		var err2 error
+		if pclntab, err2 = loadPETable(f.pe, "pclntab", "epclntab"); err2 != nil {
+			return 0, nil, nil, err
+		}
 	}
-	if symtab, err = loadPETable(f.pe, "symtab", "esymtab"); err != nil {
-		return 0, nil, nil, err
+	if symtab, err = loadPETable(f.pe, "runtime.symtab", "runtime.esymtab"); err != nil {
+		// Same as above.
+		var err2 error
+		if symtab, err2 = loadPETable(f.pe, "symtab", "esymtab"); err2 != nil {
+			return 0, nil, nil, err
+		}
 	}
 	return textStart, symtab, pclntab, nil
 }
diff --git a/src/cmd/internal/objfile/plan9obj.go b/src/cmd/internal/objfile/plan9obj.go
index 3fe05ec03b..d2c3d3f3fe 100644
--- a/src/cmd/internal/objfile/plan9obj.go
+++ b/src/cmd/internal/objfile/plan9obj.go
@@ -55,11 +55,20 @@ func (f *plan9File) symbols() ([]Sym, error) {
 
 func (f *plan9File) pcln() (textStart uint64, symtab, pclntab []byte, err error) {
 	textStart = f.plan9.LoadAddress + f.plan9.HdrSize
-	if pclntab, err = loadPlan9Table(f.plan9, "pclntab", "epclntab"); err != nil {
-		return 0, nil, nil, err
+	if pclntab, err = loadPlan9Table(f.plan9, "runtime.pclntab", "runtime.epclntab"); err != nil {
+		// We didn't find the symbols, so look for the names used in 1.3 and earlier.
+		// TODO: Remove code looking for the old symbols when we no longer care about 1.3.
+		var err2 error
+		if pclntab, err2 = loadPlan9Table(f.plan9, "pclntab", "epclntab"); err2 != nil {
+			return 0, nil, nil, err
+		}
 	}
-	if symtab, err = loadPlan9Table(f.plan9, "symtab", "esymtab"); err != nil {
-		return 0, nil, nil, err
+	if symtab, err = loadPlan9Table(f.plan9, "runtime.symtab", "runtime.esymtab"); err != nil {
+		// Same as above.
+		var err2 error
+		if symtab, err2 = loadPlan9Table(f.plan9, "symtab", "esymtab"); err2 != nil {
+			return 0, nil, nil, err
+		}
 	}
 	return textStart, symtab, pclntab, nil
 }
diff --git a/src/cmd/objdump/main.go b/src/cmd/objdump/main.go
index 42f015be70..1e4163296f 100644
--- a/src/cmd/objdump/main.go
+++ b/src/cmd/objdump/main.go
@@ -355,11 +355,20 @@ func loadTables(f *os.File) (textStart uint64, textData, symtab, pclntab []byte,
 			textStart = imageBase + uint64(sect.VirtualAddress)
 			textData, _ = sect.Data()
 		}
-		if pclntab, err = loadPETable(obj, "pclntab", "epclntab"); err != nil {
-			return 0, nil, nil, nil, err
+		if pclntab, err = loadPETable(obj, "runtime.pclntab", "runtime.epclntab"); err != nil {
+			// We didn't find the symbols, so look for the names used in 1.3 and earlier.
+			// TODO: Remove code looking for the old symbols when we no longer care about 1.3.
+			var err2 error
+			if pclntab, err2 = loadPETable(obj, "pclntab", "epclntab"); err2 != nil {
+				return 0, nil, nil, nil, err
+			}
 		}
-		if symtab, err = loadPETable(obj, "symtab", "esymtab"); err != nil {
-			return 0, nil, nil, nil, err
+		if symtab, err = loadPETable(obj, "runtime.symtab", "runtime.esymtab"); err != nil {
+			// Same as above.
+			var err2 error
+			if symtab, err2 = loadPETable(obj, "symtab", "esymtab"); err2 != nil {
+				return 0, nil, nil, nil, err
+			}
 		}
 		return textStart, textData, symtab, pclntab, nil
 	}
@@ -369,11 +378,20 @@ func loadTables(f *os.File) (textStart uint64, textData, symtab, pclntab []byte,
 		if sect := obj.Section("text"); sect != nil {
 			textData, _ = sect.Data()
 		}
-		if pclntab, err = loadPlan9Table(obj, "pclntab", "epclntab"); err != nil {
-			return 0, nil, nil, nil, err
+		if pclntab, err = loadPlan9Table(obj, "runtime.pclntab", "runtime.epclntab"); err != nil {
+			// We didn't find the symbols, so look for the names used in 1.3 and earlier.
+			// TODO: Remove code looking for the old symbols when we no longer care about 1.3.
+			var err2 error
+			if pclntab, err2 = loadPlan9Table(obj, "pclntab", "epclntab"); err2 != nil {
+				return 0, nil, nil, nil, err
+			}
 		}
-		if symtab, err = loadPlan9Table(obj, "symtab", "esymtab"); err != nil {
-			return 0, nil, nil, nil, err
+		if symtab, err = loadPlan9Table(obj, "runtime.symtab", "runtime.esymtab"); err != nil {
+			// Same as above.
+			var err2 error
+			if symtab, err2 = loadPlan9Table(obj, "symtab", "esymtab"); err2 != nil {
+				return 0, nil, nil, nil, err
+			}
 		}
 		return textStart, textData, symtab, pclntab, nil
 	}

From d21638b5ec7210e1597b96db6698471d8141a5b2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 21:59:49 -0400
Subject: [PATCH 240/423] cmd/cc, runtime: preserve C runtime type names in
 generated Go

uintptr or uint64 in the runtime C were turning into uint in the Go,
bool was turning into uint8, and so on. Fix that.

Also delete Go wrappers for C functions.
The C functions can be called directly now
(but still eventually need to be converted to Go).

LGTM=bradfitz, minux, iant
R=golang-codereviews, bradfitz, iant, minux
CC=golang-codereviews, khr, r
https://golang.org/cl/138740043
---
 src/cmd/cc/dcl.c                   |   4 +
 src/cmd/cc/godefs.c                |  53 +++--------
 src/pkg/runtime/arch_386.go        |   3 +
 src/pkg/runtime/arch_amd64.go      |   3 +
 src/pkg/runtime/arch_amd64p32.go   |   3 +
 src/pkg/runtime/arch_arm.go        |   3 +
 src/pkg/runtime/asm_386.s          |   3 +
 src/pkg/runtime/asm_amd64.s        |   3 +
 src/pkg/runtime/asm_amd64p32.s     |   5 +-
 src/pkg/runtime/asm_arm.s          |   7 +-
 src/pkg/runtime/chan.go            |  14 +--
 src/pkg/runtime/export_test.go     |   8 +-
 src/pkg/runtime/hashmap.go         |  66 +++++++-------
 src/pkg/runtime/hashmap_fast.go    |  12 +--
 src/pkg/runtime/iface.go           |  12 +--
 src/pkg/runtime/malloc.go          |  37 ++++----
 src/pkg/runtime/malloc.h           |   6 +-
 src/pkg/runtime/mgc0.c             |   2 +-
 src/pkg/runtime/mheap.c            |  10 +--
 src/pkg/runtime/mprof.go           |  12 +--
 src/pkg/runtime/mprof.goc          |   6 --
 src/pkg/runtime/print.go           |   4 +-
 src/pkg/runtime/proc.go            |  12 +--
 src/pkg/runtime/rdebug.go          |  15 ++--
 src/pkg/runtime/runtime.h          |  15 +---
 src/pkg/runtime/sema.go            |  32 +++----
 src/pkg/runtime/sigqueue.go        |   8 +-
 src/pkg/runtime/slice.go           |   6 +-
 src/pkg/runtime/string.go          |   8 +-
 src/pkg/runtime/stubs.go           | 138 ++++++++++++++---------------
 src/pkg/runtime/stubs.goc          |  51 -----------
 src/pkg/runtime/syscall_windows.go |  12 +--
 src/pkg/runtime/thunk.s            |   2 +-
 src/pkg/runtime/time.go            |  12 +--
 34 files changed, 247 insertions(+), 340 deletions(-)

diff --git a/src/cmd/cc/dcl.c b/src/cmd/cc/dcl.c
index 7cda9f924d..292717d688 100644
--- a/src/cmd/cc/dcl.c
+++ b/src/cmd/cc/dcl.c
@@ -1402,6 +1402,10 @@ xdecl(int c, Type *t, Sym *s)
 		}
 	tmerge(t, s);
 	s->type = t;
+	if(c == CTYPEDEF && (typechlv[t->etype] || typefd[t->etype])) {
+		s->type = copytyp(t);
+		s->type->tag = s;
+	}
 	s->class = c;
 	s->block = 0;
 	s->offset = o;
diff --git a/src/cmd/cc/godefs.c b/src/cmd/cc/godefs.c
index 3755a8fc09..edb8a5e287 100644
--- a/src/cmd/cc/godefs.c
+++ b/src/cmd/cc/godefs.c
@@ -188,60 +188,27 @@ printtypename(Type *t)
 
 	switch(t->etype) {
 	case TINT:
-		Bprint(&outbuf, "int32");
-		break;
 	case TUINT:
-		Bprint(&outbuf, "uint32");
-		break;
 	case TCHAR:
-		Bprint(&outbuf, "int8");
-		break;
 	case TUCHAR:
-		Bprint(&outbuf, "uint8");
-		break;
 	case TSHORT:
-		Bprint(&outbuf, "int16");
-		break;
 	case TUSHORT:
-		Bprint(&outbuf, "uint16");
-		break;
 	case TLONG:
-		// The 32/64-bit ambiguous types (int,uint,uintptr)
-		// are assigned a TLONG/TULONG to distinguish them
-		// from always 32-bit types which get a TINT/TUINT.
-		// (See int_x/uint_x in pkg/runtime/runtime.h.)
-		// For LONG and VLONG types, we generate the
-		// unqualified Go type when appropriate.
-		// This makes it easier to write Go code that
-		// modifies objects with autogenerated-from-C types.
-		if(ewidth[TIND] == 4)
-			Bprint(&outbuf, "int");
-		else
-			Bprint(&outbuf, "int32");
-		break;
 	case TULONG:
-		if(ewidth[TIND] == 4)
-			Bprint(&outbuf, "uint");
-		else
-			Bprint(&outbuf, "uint32");
-		break;
 	case TVLONG:
-		if(ewidth[TIND] == 8)
-			Bprint(&outbuf, "int");
-		else
-			Bprint(&outbuf, "int64");
-		break;
 	case TUVLONG:
-		if(ewidth[TIND] == 8)
-			Bprint(&outbuf, "uint");
-		else
-			Bprint(&outbuf, "uint64");
-		break;
 	case TFLOAT:
-		Bprint(&outbuf, "float32");
-		break;
 	case TDOUBLE:
-		Bprint(&outbuf, "float64");
+		// All names used in the runtime code should be typedefs.
+		if(t->tag != nil) {
+			if(strcmp(t->tag->name, "intgo") == 0)
+				Bprint(&outbuf, "int");
+			else if(strcmp(t->tag->name, "uintgo") == 0)
+				Bprint(&outbuf, "uint");
+			else
+				Bprint(&outbuf, "%s", t->tag->name);
+		} else	
+			Bprint(&outbuf, "C.%T", t);
 		break;
 	case TUNION:
 	case TSTRUCT:
diff --git a/src/pkg/runtime/arch_386.go b/src/pkg/runtime/arch_386.go
index 32eafb549b..287b67e270 100644
--- a/src/pkg/runtime/arch_386.go
+++ b/src/pkg/runtime/arch_386.go
@@ -7,3 +7,6 @@ package runtime
 const (
 	cacheLineSize = 64
 )
+
+type uintreg uint32
+type intptr int32 // TODO(rsc): remove
diff --git a/src/pkg/runtime/arch_amd64.go b/src/pkg/runtime/arch_amd64.go
index 32eafb549b..fe60c70660 100644
--- a/src/pkg/runtime/arch_amd64.go
+++ b/src/pkg/runtime/arch_amd64.go
@@ -7,3 +7,6 @@ package runtime
 const (
 	cacheLineSize = 64
 )
+
+type uintreg uint64
+type intptr int64 // TODO(rsc): remove
diff --git a/src/pkg/runtime/arch_amd64p32.go b/src/pkg/runtime/arch_amd64p32.go
index 32eafb549b..90766b404f 100644
--- a/src/pkg/runtime/arch_amd64p32.go
+++ b/src/pkg/runtime/arch_amd64p32.go
@@ -7,3 +7,6 @@ package runtime
 const (
 	cacheLineSize = 64
 )
+
+type uintreg uint64
+type intptr int32 // TODO(rsc): remove
diff --git a/src/pkg/runtime/arch_arm.go b/src/pkg/runtime/arch_arm.go
index 7faeb94049..23f2711f6d 100644
--- a/src/pkg/runtime/arch_arm.go
+++ b/src/pkg/runtime/arch_arm.go
@@ -7,3 +7,6 @@ package runtime
 const (
 	cacheLineSize = 32
 )
+
+type uintreg uint32
+type intptr int32 // TODO(rsc): remove
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index d52eca3867..25f92d4541 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -502,6 +502,9 @@ TEXT runtime·cas(SB), NOSPLIT, $0-13
 	MOVB	AX, ret+12(FP)
 	RET
 
+TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
+	JMP	runtime·cas(SB)
+
 // bool runtime·cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
 //	if(*val == *old){
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 70e2225213..7e3ff1c55f 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -620,6 +620,9 @@ cas64_fail:
 	MOVL	$0, AX
 	MOVB	AX, ret+24(FP)
 	RET
+	
+TEXT runtime·casuintptr(SB), NOSPLIT, $0-25
+	JMP	runtime·cas64(SB)
 
 // bool casp(void **val, void *old, void *new)
 // Atomically:
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 83faff2815..e08df377e1 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -275,7 +275,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
 	// restore when returning from f.
 	MOVL	0(SP), AX	// our caller's PC
 	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAL	addr+4(FP), AX	// our caller's SP
+	LEAL	fn+0(FP), AX	// our caller's SP
 	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
 	MOVL	g(CX), AX
 	MOVL	AX, (m_morebuf+gobuf_g)(BX)
@@ -562,6 +562,9 @@ TEXT runtime·cas(SB), NOSPLIT, $0-17
 	MOVB	AX, ret+16(FP)
 	RET
 
+TEXT runtime·casuintptr(SB), NOSPLIT, $0-17
+	JMP	runtime·cas(SB)
+
 // bool	runtime·cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
 //	if(*val == *old){
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 3ced211f89..93eb08d84b 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -671,7 +671,7 @@ TEXT runtime·abort(SB),NOSPLIT,$-4-0
 //	TEXT runtime·cas(SB),NOSPLIT,$0
 //		B	runtime·armcas(SB)
 //
-TEXT runtime·armcas(SB),NOSPLIT,$0-12
+TEXT runtime·armcas(SB),NOSPLIT,$0-13
 	MOVW	valptr+0(FP), R1
 	MOVW	old+4(FP), R2
 	MOVW	new+8(FP), R3
@@ -683,11 +683,16 @@ casl:
 	CMP	$0, R0
 	BNE	casl
 	MOVW	$1, R0
+	MOVB	R0, ret+12(FP)
 	RET
 casfail:
 	MOVW	$0, R0
+	MOVB	R0, ret+12(FP)
 	RET
 
+TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
+	JMP	runtime·cas(SB)
+
 TEXT runtime·stackguard(SB),NOSPLIT,$0-8
 	MOVW	R13, R1
 	MOVW	g_stackguard(g), R2
diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index 7a44afacec..e2d5bc180e 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -66,7 +66,7 @@ func chanbuf(c *hchan, i uint) unsafe.Pointer {
 // entry point for c <- x from compiled code
 //go:nosplit
 func chansend1(t *chantype, c *hchan, elem unsafe.Pointer) {
-	chansend(t, c, elem, true, gogetcallerpc(unsafe.Pointer(&t)))
+	chansend(t, c, elem, true, getcallerpc(unsafe.Pointer(&t)))
 }
 
 /*
@@ -127,7 +127,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 
 	var t0 int64
 	if blockprofilerate > 0 {
-		t0 = gocputicks()
+		t0 = cputicks()
 	}
 
 	golock(&c.lock)
@@ -155,7 +155,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 				// to assign to both types in Go.  At some point we'll
 				// write the Go types directly instead of generating them
 				// via the C types.  At that point, this nastiness goes away.
-				*(*int64)(unsafe.Pointer(&sg.releasetime)) = gocputicks()
+				*(*int64)(unsafe.Pointer(&sg.releasetime)) = cputicks()
 			}
 			goready(recvg)
 			return true
@@ -189,7 +189,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 			panic("send on closed channel")
 		}
 		if mysg.releasetime > 0 {
-			goblockevent(int64(mysg.releasetime)-t0, 3)
+			blockevent(int64(mysg.releasetime)-t0, 2)
 		}
 		if mysg != gp.waiting {
 			gothrow("G waiting list is corrupted!")
@@ -248,14 +248,14 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		recvg := sg.g
 		gounlock(&c.lock)
 		if sg.releasetime != 0 {
-			*(*int64)(unsafe.Pointer(&sg.releasetime)) = gocputicks()
+			*(*int64)(unsafe.Pointer(&sg.releasetime)) = cputicks()
 		}
 		goready(recvg)
 	} else {
 		gounlock(&c.lock)
 	}
 	if t1 > 0 {
-		goblockevent(t1-t0, 3)
+		blockevent(t1-t0, 2)
 	}
 	return true
 }
@@ -285,7 +285,7 @@ func (q *waitq) dequeue() *sudog {
 		// if sgp participates in a select and is already signaled, ignore it
 		if sgp.selectdone != nil {
 			// claim the right to signal
-			if *sgp.selectdone != 0 || !gocas(sgp.selectdone, 0, 1) {
+			if *sgp.selectdone != 0 || !cas(sgp.selectdone, 0, 1) {
 				continue
 			}
 		}
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index f75b742b61..df6f11d671 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -75,7 +75,7 @@ var (
 
 func NewParFor(nthrmax uint32) *ParFor {
 	mp := acquirem()
-	mp.scalararg[0] = uint(nthrmax)
+	mp.scalararg[0] = uintptr(nthrmax)
 	onM(&newparfor_m)
 	desc := (*ParFor)(mp.ptrarg[0])
 	mp.ptrarg[0] = nil
@@ -88,8 +88,8 @@ func ParForSetup(desc *ParFor, nthr, n uint32, ctx *byte, wait bool, body func(*
 	mp.ptrarg[0] = unsafe.Pointer(desc)
 	mp.ptrarg[1] = unsafe.Pointer(ctx)
 	mp.ptrarg[2] = **(**unsafe.Pointer)(unsafe.Pointer(&body))
-	mp.scalararg[0] = uint(nthr)
-	mp.scalararg[1] = uint(n)
+	mp.scalararg[0] = uintptr(nthr)
+	mp.scalararg[1] = uintptr(n)
 	mp.scalararg[2] = 0
 	if wait {
 		mp.scalararg[2] = 1
@@ -108,7 +108,7 @@ func ParForDo(desc *ParFor) {
 func ParForIters(desc *ParFor, tid uint32) (uint32, uint32) {
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(desc)
-	mp.scalararg[0] = uint(tid)
+	mp.scalararg[0] = uintptr(tid)
 	onM(&parforiters_m)
 	begin := uint32(mp.scalararg[0])
 	end := uint32(mp.scalararg[1])
diff --git a/src/pkg/runtime/hashmap.go b/src/pkg/runtime/hashmap.go
index 9dcf48242f..1d1e708487 100644
--- a/src/pkg/runtime/hashmap.go
+++ b/src/pkg/runtime/hashmap.go
@@ -162,12 +162,12 @@ func makemap(t *maptype, hint int64) *hmap {
 	}
 
 	// check compiler's and reflect's math
-	if t.key.size > maxKeySize && (t.indirectkey == 0 || t.keysize != uint8(ptrSize)) ||
-		t.key.size <= maxKeySize && (t.indirectkey == 1 || t.keysize != uint8(t.key.size)) {
+	if t.key.size > maxKeySize && (!t.indirectkey || t.keysize != uint8(ptrSize)) ||
+		t.key.size <= maxKeySize && (t.indirectkey || t.keysize != uint8(t.key.size)) {
 		gothrow("key size wrong")
 	}
-	if t.elem.size > maxValueSize && (t.indirectvalue == 0 || t.valuesize != uint8(ptrSize)) ||
-		t.elem.size <= maxValueSize && (t.indirectvalue == 1 || t.valuesize != uint8(t.elem.size)) {
+	if t.elem.size > maxValueSize && (!t.indirectvalue || t.valuesize != uint8(ptrSize)) ||
+		t.elem.size <= maxValueSize && (t.indirectvalue || t.valuesize != uint8(t.elem.size)) {
 		gothrow("value size wrong")
 	}
 
@@ -234,7 +234,7 @@ func makemap(t *maptype, hint int64) *hmap {
 // hold onto it for very long.
 func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess1
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -263,12 +263,12 @@ func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 				continue
 			}
 			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
-			if t.indirectkey != 0 {
+			if t.indirectkey {
 				k = *((*unsafe.Pointer)(k))
 			}
 			if alg.equal(key, k, uintptr(t.key.size)) {
 				v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
-				if t.indirectvalue != 0 {
+				if t.indirectvalue {
 					v = *((*unsafe.Pointer)(v))
 				}
 				return v
@@ -283,7 +283,7 @@ func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 
 func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess2
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -312,12 +312,12 @@ func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)
 				continue
 			}
 			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
-			if t.indirectkey != 0 {
+			if t.indirectkey {
 				k = *((*unsafe.Pointer)(k))
 			}
 			if alg.equal(key, k, uintptr(t.key.size)) {
 				v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
-				if t.indirectvalue != 0 {
+				if t.indirectvalue {
 					v = *((*unsafe.Pointer)(v))
 				}
 				return v, true
@@ -355,12 +355,12 @@ func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe
 				continue
 			}
 			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
-			if t.indirectkey != 0 {
+			if t.indirectkey {
 				k = *((*unsafe.Pointer)(k))
 			}
 			if alg.equal(key, k, uintptr(t.key.size)) {
 				v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
-				if t.indirectvalue != 0 {
+				if t.indirectvalue {
 					v = *((*unsafe.Pointer)(v))
 				}
 				return k, v
@@ -378,7 +378,7 @@ func mapassign1(t *maptype, h *hmap, key unsafe.Pointer, val unsafe.Pointer) {
 		panic("assignment to entry in nil map")
 	}
 	if raceenabled {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapassign1
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racewritepc(unsafe.Pointer(h), callerpc, pc)
@@ -422,7 +422,7 @@ again:
 			}
 			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
 			k2 := k
-			if t.indirectkey != 0 {
+			if t.indirectkey {
 				k2 = *((*unsafe.Pointer)(k2))
 			}
 			if !alg.equal(key, k2, uintptr(t.key.size)) {
@@ -432,7 +432,7 @@ again:
 			memmove(k2, key, uintptr(t.key.size))
 			v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
 			v2 := v
-			if t.indirectvalue != 0 {
+			if t.indirectvalue {
 				v2 = *((*unsafe.Pointer)(v2))
 			}
 			memmove(v2, val, uintptr(t.elem.size))
@@ -463,7 +463,7 @@ again:
 	}
 
 	// store new key/value at insert position
-	if t.indirectkey != 0 {
+	if t.indirectkey {
 		if checkgc {
 			memstats.next_gc = memstats.heap_alloc
 		}
@@ -471,7 +471,7 @@ again:
 		*(*unsafe.Pointer)(insertk) = kmem
 		insertk = kmem
 	}
-	if t.indirectvalue != 0 {
+	if t.indirectvalue {
 		if checkgc {
 			memstats.next_gc = memstats.heap_alloc
 		}
@@ -487,7 +487,7 @@ again:
 
 func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapdelete
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racewritepc(unsafe.Pointer(h), callerpc, pc)
@@ -514,7 +514,7 @@ func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 			}
 			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
 			k2 := k
-			if t.indirectkey != 0 {
+			if t.indirectkey {
 				k2 = *((*unsafe.Pointer)(k2))
 			}
 			if !alg.equal(key, k2, uintptr(t.key.size)) {
@@ -544,7 +544,7 @@ func mapiterinit(t *maptype, h *hmap, it *hiter) {
 	it.bptr = nil
 
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapiterinit
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -579,7 +579,7 @@ func mapiterinit(t *maptype, h *hmap, it *hiter) {
 		if old == old|iterator|oldIterator {
 			break
 		}
-		if gocas(&h.flags, old, old|iterator|oldIterator) {
+		if cas(&h.flags, old, old|iterator|oldIterator) {
 			break
 		}
 	}
@@ -590,7 +590,7 @@ func mapiterinit(t *maptype, h *hmap, it *hiter) {
 func mapiternext(it *hiter) {
 	h := it.h
 	if raceenabled {
-		callerpc := gogetcallerpc(unsafe.Pointer(&it))
+		callerpc := getcallerpc(unsafe.Pointer(&it))
 		fn := mapiternext
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -648,7 +648,7 @@ next:
 				// to the other new bucket (each oldbucket expands to two
 				// buckets during a grow).
 				k2 := k
-				if t.indirectkey != 0 {
+				if t.indirectkey {
 					k2 = *((*unsafe.Pointer)(k2))
 				}
 				if alg.equal(k2, k2, uintptr(t.key.size)) {
@@ -673,11 +673,11 @@ next:
 			}
 			if b.tophash[offi] != evacuatedX && b.tophash[offi] != evacuatedY {
 				// this is the golden data, we can return it.
-				if t.indirectkey != 0 {
+				if t.indirectkey {
 					k = *((*unsafe.Pointer)(k))
 				}
 				it.key = k
-				if t.indirectvalue != 0 {
+				if t.indirectvalue {
 					v = *((*unsafe.Pointer)(v))
 				}
 				it.value = v
@@ -685,7 +685,7 @@ next:
 				// The hash table has grown since the iterator was started.
 				// The golden data for this key is now somewhere else.
 				k2 := k
-				if t.indirectkey != 0 {
+				if t.indirectkey {
 					k2 = *((*unsafe.Pointer)(k2))
 				}
 				if alg.equal(k2, k2, uintptr(t.key.size)) {
@@ -706,7 +706,7 @@ next:
 					// us because when key!=key we can't look it up
 					// successfully in the current table.
 					it.key = k2
-					if t.indirectvalue != 0 {
+					if t.indirectvalue {
 						v = *((*unsafe.Pointer)(v))
 					}
 					it.value = v
@@ -790,7 +790,7 @@ func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
 					gothrow("bad map state")
 				}
 				k2 := k
-				if t.indirectkey != 0 {
+				if t.indirectkey {
 					k2 = *((*unsafe.Pointer)(k2))
 				}
 				// Compute hash to make our evacuation decision (whether we need
@@ -834,12 +834,12 @@ func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
 						xv = add(xk, bucketCnt*uintptr(t.keysize))
 					}
 					x.tophash[xi] = top
-					if t.indirectkey != 0 {
+					if t.indirectkey {
 						*(*unsafe.Pointer)(xk) = k2 // copy pointer
 					} else {
 						memmove(xk, k, uintptr(t.key.size)) // copy value
 					}
-					if t.indirectvalue != 0 {
+					if t.indirectvalue {
 						*(*unsafe.Pointer)(xv) = *(*unsafe.Pointer)(v)
 					} else {
 						memmove(xv, v, uintptr(t.elem.size))
@@ -861,12 +861,12 @@ func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
 						yv = add(yk, bucketCnt*uintptr(t.keysize))
 					}
 					y.tophash[yi] = top
-					if t.indirectkey != 0 {
+					if t.indirectkey {
 						*(*unsafe.Pointer)(yk) = k2
 					} else {
 						memmove(yk, k, uintptr(t.key.size))
 					}
-					if t.indirectvalue != 0 {
+					if t.indirectvalue {
 						*(*unsafe.Pointer)(yv) = *(*unsafe.Pointer)(v)
 					} else {
 						memmove(yv, v, uintptr(t.elem.size))
@@ -941,7 +941,7 @@ func reflect_maplen(h *hmap) int {
 		return 0
 	}
 	if raceenabled {
-		callerpc := gogetcallerpc(unsafe.Pointer(&h))
+		callerpc := getcallerpc(unsafe.Pointer(&h))
 		fn := reflect_maplen
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
diff --git a/src/pkg/runtime/hashmap_fast.go b/src/pkg/runtime/hashmap_fast.go
index c1b71d6d86..7059e22a0b 100644
--- a/src/pkg/runtime/hashmap_fast.go
+++ b/src/pkg/runtime/hashmap_fast.go
@@ -10,7 +10,7 @@ import (
 
 func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess1_fast32
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -54,7 +54,7 @@ func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
 
 func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess2_fast32
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -98,7 +98,7 @@ func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
 
 func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess1_fast64
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -142,7 +142,7 @@ func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
 
 func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess2_fast64
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -186,7 +186,7 @@ func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
 
 func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess1_faststr
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
@@ -290,7 +290,7 @@ dohash:
 
 func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := mapaccess2_faststr
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index 60dfb49dbe..1421efe3ce 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -53,7 +53,7 @@ func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
 		if locked != 0 {
 			golock(&ifaceLock)
 		}
-		for m = (*itab)(goatomicloadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
+		for m = (*itab)(atomicloadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
 			if m.inter == inter && m._type == typ {
 				if m.bad != 0 {
 					m = nil
@@ -76,7 +76,7 @@ func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
 		}
 	}
 
-	m = (*itab)(gopersistentalloc(unsafe.Sizeof(itab{}) + uintptr(len(inter.mhdr))*ptrSize))
+	m = (*itab)(persistentalloc(unsafe.Sizeof(itab{})+uintptr(len(inter.mhdr))*ptrSize, 0, &memstats.other_sys))
 	m.inter = inter
 	m._type = typ
 
@@ -118,7 +118,7 @@ search:
 		gothrow("invalid itab locking")
 	}
 	m.link = hash[h]
-	goatomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))
+	atomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))
 	gounlock(&ifaceLock)
 	if m.bad != 0 {
 		return nil
@@ -128,7 +128,7 @@ search:
 
 func typ2Itab(t *_type, inter *interfacetype, cache **itab) *itab {
 	tab := getitab(inter, t, false)
-	goatomicstorep(unsafe.Pointer(cache), unsafe.Pointer(tab))
+	atomicstorep(unsafe.Pointer(cache), unsafe.Pointer(tab))
 	return tab
 }
 
@@ -150,10 +150,10 @@ func convT2E(t *_type, elem unsafe.Pointer) (e interface{}) {
 }
 
 func convT2I(t *_type, inter *interfacetype, cache **itab, elem unsafe.Pointer) (i fInterface) {
-	tab := (*itab)(goatomicloadp(unsafe.Pointer(cache)))
+	tab := (*itab)(atomicloadp(unsafe.Pointer(cache)))
 	if tab == nil {
 		tab = getitab(inter, t, false)
-		goatomicstorep(unsafe.Pointer(cache), unsafe.Pointer(tab))
+		atomicstorep(unsafe.Pointer(cache), unsafe.Pointer(tab))
 	}
 	size := uintptr(t.size)
 	pi := (*iface)(unsafe.Pointer(&i))
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index ffe571a18a..fb2c037ace 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -37,6 +37,9 @@ const (
 	bitMask     = bitBoundary | bitMarked
 )
 
+// Page number (address>>pageShift)
+type pageID uintptr
+
 // All zero-sized allocations return a pointer to this byte.
 var zeroObject byte
 
@@ -64,7 +67,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		}
 		mp.mallocing = 1
 		if mp.curg != nil {
-			mp.curg.stackguard0 = ^uint(0xfff) | 0xbad
+			mp.curg.stackguard0 = ^uintptr(0xfff) | 0xbad
 		}
 	}
 
@@ -119,7 +122,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 					// The object fits into existing tiny block.
 					x = tiny
 					c.tiny = (*byte)(add(x, size))
-					c.tinysize -= uint(size1)
+					c.tinysize -= uintptr(size1)
 					if debugMalloc {
 						mp := acquirem()
 						if mp.mallocing == 0 {
@@ -156,7 +159,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			// based on amount of remaining free space.
 			if maxTinySize-size > tinysize {
 				c.tiny = (*byte)(add(x, size))
-				c.tinysize = uint(maxTinySize - size)
+				c.tinysize = uintptr(maxTinySize - size)
 			}
 			size = maxTinySize
 		} else {
@@ -171,7 +174,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			v := s.freelist
 			if v == nil {
 				mp := acquirem()
-				mp.scalararg[0] = uint(sizeclass)
+				mp.scalararg[0] = uintptr(sizeclass)
 				onM(&mcacheRefill_m)
 				releasem(mp)
 				s = c.alloc[sizeclass]
@@ -188,11 +191,11 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 				}
 			}
 		}
-		c.local_cachealloc += int(size)
+		c.local_cachealloc += intptr(size)
 	} else {
 		mp := acquirem()
-		mp.scalararg[0] = uint(size)
-		mp.scalararg[1] = uint(flags)
+		mp.scalararg[0] = uintptr(size)
+		mp.scalararg[1] = uintptr(flags)
 		onM(&largeAlloc_m)
 		s = (*mspan)(mp.ptrarg[0])
 		mp.ptrarg[0] = nil
@@ -241,15 +244,15 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 				mp := acquirem()
 				mp.ptrarg[0] = x
 				mp.ptrarg[1] = unsafe.Pointer(typ)
-				mp.scalararg[0] = uint(size)
-				mp.scalararg[1] = uint(size0)
+				mp.scalararg[0] = uintptr(size)
+				mp.scalararg[1] = uintptr(size0)
 				onM(&unrollgcproginplace_m)
 				releasem(mp)
 				goto marked
 			}
 			ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
 			// Check whether the program is already unrolled.
-			if uintptr(goatomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
+			if uintptr(atomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
 				mp := acquirem()
 				mp.ptrarg[0] = unsafe.Pointer(typ)
 				onM(&unrollgcprog_m)
@@ -394,7 +397,7 @@ func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 		}
 		c.next_sample = next
 	}
-	mp.scalararg[0] = uint(size)
+	mp.scalararg[0] = uintptr(size)
 	mp.ptrarg[0] = x
 	onM(&mprofMalloc_m)
 }
@@ -402,7 +405,7 @@ func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 // force = 1 - do GC regardless of current heap usage
 // force = 2 - go GC and eager sweep
 func gogc(force int32) {
-	if memstats.enablegc == 0 {
+	if !memstats.enablegc {
 		return
 	}
 
@@ -421,7 +424,7 @@ func gogc(force int32) {
 	if gcpercent == gcpercentUnknown {
 		golock(&mheap_.lock)
 		if gcpercent == gcpercentUnknown {
-			gcpercent = goreadgogc()
+			gcpercent = readgogc()
 		}
 		gounlock(&mheap_.lock)
 	}
@@ -439,7 +442,7 @@ func gogc(force int32) {
 	}
 
 	// Ok, we're doing it!  Stop everybody else
-	startTime := gonanotime()
+	startTime := nanotime()
 	mp = acquirem()
 	mp.gcing = 1
 	releasem(mp)
@@ -461,11 +464,11 @@ func gogc(force int32) {
 	}
 	for i := 0; i < n; i++ {
 		if i > 0 {
-			startTime = gonanotime()
+			startTime = nanotime()
 		}
 		// switch to g0, call gc, then switch back
-		mp.scalararg[0] = uint(uint32(startTime)) // low 32 bits
-		mp.scalararg[1] = uint(startTime >> 32)   // high 32 bits
+		mp.scalararg[0] = uintptr(uint32(startTime)) // low 32 bits
+		mp.scalararg[1] = uintptr(startTime >> 32)   // high 32 bits
 		if force >= 2 {
 			mp.scalararg[2] = 1 // eagersweep
 		} else {
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index eafabb364a..7a6d0c71d9 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -93,7 +93,7 @@ enum
 	PageSize	= 1<<PageShift,
 	PageMask	= PageSize - 1,
 };
-typedef	uintptr	PageID;		// address >> PageShift
+typedef	uintptr	pageID;		// address >> PageShift
 
 enum
 {
@@ -403,7 +403,7 @@ struct MSpan
 {
 	MSpan	*next;		// in a span linked list
 	MSpan	*prev;		// in a span linked list
-	PageID	start;		// starting page number
+	pageID	start;		// starting page number
 	uintptr	npages;		// number of pages in span
 	MLink	*freelist;	// list of free objects
 	// sweep generation:
@@ -425,7 +425,7 @@ struct MSpan
 	Special	*specials;	// linked list of special records sorted by offset.
 };
 
-void	runtime·MSpan_Init(MSpan *span, PageID start, uintptr npages);
+void	runtime·MSpan_Init(MSpan *span, pageID start, uintptr npages);
 void	runtime·MSpan_EnsureSwept(MSpan *span);
 bool	runtime·MSpan_Sweep(MSpan *span, bool preserve);
 
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 68e45a316e..d70a6373e3 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -225,7 +225,7 @@ scanblock(byte *b, uintptr n, byte *ptrmask)
 	Eface *eface;
 	Type *typ;
 	MSpan *s;
-	PageID k;
+	pageID k;
 	bool keepworking;
 
 	// Cache memory arena parameters in local vars.
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index a447bbc973..8bfb41ac67 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -279,7 +279,7 @@ MHeap_AllocSpanLocked(MHeap *h, uintptr npage)
 {
 	uintptr n;
 	MSpan *s, *t;
-	PageID p;
+	pageID p;
 
 	// Try in fixed-size lists up to max.
 	for(n=npage; n < nelem(h->free); n++) {
@@ -380,7 +380,7 @@ MHeap_Grow(MHeap *h, uintptr npage)
 	uintptr ask;
 	void *v;
 	MSpan *s;
-	PageID p;
+	pageID p;
 
 	// Ask for a big chunk, to reduce the number of mappings
 	// the operating system needs to track; also amortizes
@@ -441,7 +441,7 @@ MSpan*
 runtime·MHeap_LookupMaybe(MHeap *h, void *v)
 {
 	MSpan *s;
-	PageID p, q;
+	pageID p, q;
 
 	if((byte*)v < h->arena_start || (byte*)v >= h->arena_used)
 		return nil;
@@ -514,7 +514,7 @@ static void
 MHeap_FreeSpanLocked(MHeap *h, MSpan *s, bool acctinuse, bool acctidle)
 {
 	MSpan *t;
-	PageID p;
+	pageID p;
 
 	switch(s->state) {
 	case MSpanStack:
@@ -639,7 +639,7 @@ runtime∕debug·freeOSMemory(void)
 
 // Initialize a new span with the given start and npages.
 void
-runtime·MSpan_Init(MSpan *span, PageID start, uintptr npages)
+runtime·MSpan_Init(MSpan *span, pageID start, uintptr npages)
 {
 	span->next = nil;
 	span->prev = nil;
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 5d77c5629c..d20bf2371c 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -98,10 +98,10 @@ func record(r *MemProfileRecord, b *bucket) {
 	r.FreeBytes = int64(b.data.mp.free_bytes)
 	r.AllocObjects = int64(b.data.mp.allocs)
 	r.FreeObjects = int64(b.data.mp.frees)
-	for i := 0; uint(i) < b.nstk && i < len(r.Stack0); i++ {
+	for i := 0; uintptr(i) < b.nstk && i < len(r.Stack0); i++ {
 		r.Stack0[i] = *(*uintptr)(add(unsafe.Pointer(&b.stk), uintptr(i)*ptrSize))
 	}
-	for i := b.nstk; i < uint(len(r.Stack0)); i++ {
+	for i := b.nstk; i < uintptr(len(r.Stack0)); i++ {
 		r.Stack0[i] = 0
 	}
 }
@@ -126,7 +126,7 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 			p[idx].Count = int64(bp.count)
 			p[idx].Cycles = int64(bp.cycles)
 			i := 0
-			for uint(i) < b.nstk && i < len(p[idx].Stack0) {
+			for uintptr(i) < b.nstk && i < len(p[idx].Stack0) {
 				p[idx].Stack0[i] = *(*uintptr)(add(unsafe.Pointer(&b.stk), uintptr(i)*ptrSize))
 				i++
 			}
@@ -146,8 +146,8 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 // If all is true, Stack formats stack traces of all other goroutines
 // into buf after the trace for the current goroutine.
 func Stack(buf []byte, all bool) int {
-	sp := gogetcallersp(unsafe.Pointer(&buf))
-	pc := gogetcallerpc(unsafe.Pointer(&buf))
+	sp := getcallersp(unsafe.Pointer(&buf))
+	pc := getcallerpc(unsafe.Pointer(&buf))
 	mp := acquirem()
 	gp := mp.curg
 	if all {
@@ -190,7 +190,7 @@ func Stack(buf []byte, all bool) int {
 // Most clients should use the runtime/pprof package instead
 // of calling ThreadCreateProfile directly.
 func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
-	first := (*m)(goatomicloadp(unsafe.Pointer(&allm)))
+	first := (*m)(atomicloadp(unsafe.Pointer(&allm)))
 	for mp := first; mp != nil; mp = mp.alllink {
 		n++
 	}
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index a96edee21a..f76aae48c8 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -229,12 +229,6 @@ runtime·blockevent(int64 cycles, int32 skip)
 	runtime·unlock(&runtime·proflock);
 }
 
-void
-runtime·blockevent_m(void)
-{
-	runtime·blockevent(g->m->scalararg[0] + ((int64)g->m->scalararg[1]<<32), g->m->scalararg[2]);
-}
-
 void
 runtime·iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr))
 {
diff --git a/src/pkg/runtime/print.go b/src/pkg/runtime/print.go
index 4b94417c6e..fd79bc8dd6 100644
--- a/src/pkg/runtime/print.go
+++ b/src/pkg/runtime/print.go
@@ -19,7 +19,7 @@ var (
 
 func printstring(s string) {
 	mp := acquirem()
-	mp.scalararg[0] = uint(len(s))
+	mp.scalararg[0] = uintptr(len(s))
 	mp.ptrarg[0] = (*stringStruct)(unsafe.Pointer(&s)).str
 	onM(&printstring_m)
 	releasem(mp)
@@ -34,7 +34,7 @@ func printuint(x uint64) {
 
 func printhex(x uintptr) {
 	mp := acquirem()
-	mp.scalararg[0] = uint(x)
+	mp.scalararg[0] = uintptr(x)
 	onM(&printhex_m)
 	releasem(mp)
 }
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index de58daa130..a201dc6c51 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -50,7 +50,7 @@ func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
 		gothrow("gopark: bad g status")
 	}
 	mp.waitlock = lock
-	mp.waitunlockf = *(*func(*g, unsafe.Pointer) uint8)(unsafe.Pointer(&unlockf))
+	mp.waitunlockf = *(*func(*g, unsafe.Pointer) bool)(unsafe.Pointer(&unlockf))
 	gp.waitreason = reason
 	releasem(mp)
 	// can't do anything that might move the G between Ms here.
@@ -70,16 +70,6 @@ func goready(gp *g) {
 	releasem(mp)
 }
 
-func goblockevent(cycles int64, skip int32) {
-	// TODO: convert to Go when we do mprof.goc
-	mp := acquirem()
-	mp.scalararg[0] = uint(uint32(cycles))
-	mp.scalararg[1] = uint(cycles >> 32)
-	mp.scalararg[2] = uint(skip)
-	onM(&blockevent_m)
-	releasem(mp)
-}
-
 //go:nosplit
 func acquireSudog() *sudog {
 	c := gomcache()
diff --git a/src/pkg/runtime/rdebug.go b/src/pkg/runtime/rdebug.go
index 3df73ce660..eef0f281fd 100644
--- a/src/pkg/runtime/rdebug.go
+++ b/src/pkg/runtime/rdebug.go
@@ -6,27 +6,22 @@ package runtime
 
 func setMaxStack(in int) (out int) {
 	out = int(maxstacksize)
-	maxstacksize = uint(in)
+	maxstacksize = uintptr(in)
 	return out
 }
 
 func setGCPercent(in int32) (out int32) {
 	mp := acquirem()
-	mp.scalararg[0] = uint(int(in))
+	mp.scalararg[0] = uintptr(int(in))
 	onM(&setgcpercent_m)
 	out = int32(int(mp.scalararg[0]))
 	releasem(mp)
 	return out
 }
 
-func setPanicOnFault(newb bool) (old bool) {
-	new := uint8(0)
-	if newb {
-		new = 1
-	}
-
+func setPanicOnFault(new bool) (old bool) {
 	mp := acquirem()
-	old = mp.curg.paniconfault == 1
+	old = mp.curg.paniconfault
 	mp.curg.paniconfault = new
 	releasem(mp)
 	return old
@@ -34,7 +29,7 @@ func setPanicOnFault(newb bool) (old bool) {
 
 func setMaxThreads(in int) (out int) {
 	mp := acquirem()
-	mp.scalararg[0] = uint(in)
+	mp.scalararg[0] = uintptr(in)
 	onM(&setmaxthreads_m)
 	out = int(mp.scalararg[0])
 	releasem(mp)
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index ae098459fa..bb9d108551 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -22,17 +22,10 @@ typedef	int64		intptr;
 typedef	int64		intgo; // Go's int
 typedef	uint64		uintgo; // Go's uint
 #else
-// Normally, "int" == "long int" == 32 bits.
-// However, the C compiler uses this distinction
-// to disambiguate true 32 bit ints (e.g. int32)
-// from 32/64 bit ints (e.g. uintptr) so that it
-// can generate the corresponding go type correctly.
-typedef	signed long int		int32_x;
-typedef	unsigned long int	uint32_x;
-typedef	uint32_x	uintptr;
-typedef	int32_x		intptr;
-typedef	int32_x		intgo; // Go's int
-typedef	uint32_x	uintgo; // Go's uint
+typedef	uint32		uintptr;
+typedef	int32		intptr;
+typedef	int32		intgo; // Go's int
+typedef	uint32		uintgo; // Go's uint
 #endif
 
 #ifdef _64BITREG
diff --git a/src/pkg/runtime/sema.go b/src/pkg/runtime/sema.go
index a9ed7150d8..4674a843ee 100644
--- a/src/pkg/runtime/sema.go
+++ b/src/pkg/runtime/sema.go
@@ -65,16 +65,16 @@ func semacquire(addr *uint32, profile bool) {
 	t0 := int64(0)
 	s.releasetime = 0
 	if profile && blockprofilerate > 0 {
-		t0 = gocputicks()
+		t0 = cputicks()
 		s.releasetime = -1
 	}
 	for {
 		golock(&root.lock)
 		// Add ourselves to nwait to disable "easy case" in semrelease.
-		goxadd(&root.nwait, 1)
+		xadd(&root.nwait, 1)
 		// Check cansemacquire to avoid missed wakeup.
 		if cansemacquire(addr) {
-			goxadd(&root.nwait, ^uint32(0))
+			xadd(&root.nwait, -1)
 			gounlock(&root.lock)
 			break
 		}
@@ -87,25 +87,25 @@ func semacquire(addr *uint32, profile bool) {
 		}
 	}
 	if s.releasetime > 0 {
-		goblockevent(int64(s.releasetime)-t0, 4)
+		blockevent(int64(s.releasetime)-t0, 3)
 	}
 	releaseSudog(s)
 }
 
 func semrelease(addr *uint32) {
 	root := semroot(addr)
-	goxadd(addr, 1)
+	xadd(addr, 1)
 
 	// Easy case: no waiters?
 	// This check must happen after the xadd, to avoid a missed wakeup
 	// (see loop in semacquire).
-	if goatomicload(&root.nwait) == 0 {
+	if atomicload(&root.nwait) == 0 {
 		return
 	}
 
 	// Harder case: search for a waiter and wake it.
 	golock(&root.lock)
-	if goatomicload(&root.nwait) == 0 {
+	if atomicload(&root.nwait) == 0 {
 		// The count is already consumed by another goroutine,
 		// so no need to wake up another goroutine.
 		gounlock(&root.lock)
@@ -114,7 +114,7 @@ func semrelease(addr *uint32) {
 	s := root.head
 	for ; s != nil; s = s.next {
 		if s.elem == unsafe.Pointer(addr) {
-			goxadd(&root.nwait, ^uint32(0))
+			xadd(&root.nwait, -1)
 			root.dequeue(s)
 			break
 		}
@@ -122,9 +122,7 @@ func semrelease(addr *uint32) {
 	gounlock(&root.lock)
 	if s != nil {
 		if s.releasetime != 0 {
-			// TODO: Remove use of unsafe here.
-			releasetimep := (*int64)(unsafe.Pointer(&s.releasetime))
-			*releasetimep = gocputicks()
+			s.releasetime = cputicks()
 		}
 		goready(s.g)
 	}
@@ -136,11 +134,11 @@ func semroot(addr *uint32) *semaRoot {
 
 func cansemacquire(addr *uint32) bool {
 	for {
-		v := goatomicload(addr)
+		v := atomicload(addr)
 		if v == 0 {
 			return false
 		}
-		if gocas(addr, v, v-1) {
+		if cas(addr, v, v-1) {
 			return true
 		}
 	}
@@ -208,7 +206,7 @@ func syncsemacquire(s *syncSema) {
 		w.releasetime = 0
 		t0 := int64(0)
 		if blockprofilerate > 0 {
-			t0 = gocputicks()
+			t0 = cputicks()
 			w.releasetime = -1
 		}
 		if s.tail == nil {
@@ -219,7 +217,7 @@ func syncsemacquire(s *syncSema) {
 		s.tail = w
 		goparkunlock(&s.lock, "semacquire")
 		if t0 != 0 {
-			goblockevent(int64(w.releasetime)-t0, 3)
+			blockevent(int64(w.releasetime)-t0, 2)
 		}
 		releaseSudog(w)
 	}
@@ -236,9 +234,7 @@ func syncsemrelease(s *syncSema, n uint32) {
 			s.tail = nil
 		}
 		if wake.releasetime != 0 {
-			// TODO: Remove use of unsafe here.
-			releasetimep := (*int64)(unsafe.Pointer(&wake.releasetime))
-			*releasetimep = gocputicks()
+			wake.releasetime = cputicks()
 		}
 		goready(wake.g)
 		n--
diff --git a/src/pkg/runtime/sigqueue.go b/src/pkg/runtime/sigqueue.go
index 5976e57352..c51ede0265 100644
--- a/src/pkg/runtime/sigqueue.go
+++ b/src/pkg/runtime/sigqueue.go
@@ -16,21 +16,21 @@ func signal_recv() (m uint32) {
 		if ok {
 			return
 		}
-		gonotetsleepg(&signote, -1)
-		gonoteclear(&signote)
+		notetsleepg(&signote, -1)
+		noteclear(&signote)
 	}
 }
 
 func signal_enable(s uint32) {
 	mp := acquirem()
-	mp.scalararg[0] = uint(s)
+	mp.scalararg[0] = uintptr(s)
 	onM(&signal_enable_m)
 	releasem(mp)
 }
 
 func signal_disable(s uint32) {
 	mp := acquirem()
-	mp.scalararg[0] = uint(s)
+	mp.scalararg[0] = uintptr(s)
 	onM(&signal_disable_m)
 	releasem(mp)
 }
diff --git a/src/pkg/runtime/slice.go b/src/pkg/runtime/slice.go
index e01ea2d7f5..c282125b44 100644
--- a/src/pkg/runtime/slice.go
+++ b/src/pkg/runtime/slice.go
@@ -47,7 +47,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct {
 	}
 
 	if raceenabled {
-		callerpc := gogetcallerpc(unsafe.Pointer(&t))
+		callerpc := getcallerpc(unsafe.Pointer(&t))
 		fn := growslice
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racereadrangepc(old.array, old.len*int(t.elem.size), callerpc, pc)
@@ -104,7 +104,7 @@ func slicecopy(to sliceStruct, fm sliceStruct, width uintptr) int {
 	}
 
 	if raceenabled {
-		callerpc := gogetcallerpc(unsafe.Pointer(&to))
+		callerpc := getcallerpc(unsafe.Pointer(&to))
 		fn := slicecopy
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racewriterangepc(to.array, n*int(width), callerpc, pc)
@@ -132,7 +132,7 @@ func slicestringcopy(to []byte, fm string) int {
 	}
 
 	if raceenabled {
-		callerpc := gogetcallerpc(unsafe.Pointer(&to))
+		callerpc := getcallerpc(unsafe.Pointer(&to))
 		fn := slicestringcopy
 		pc := **(**uintptr)(unsafe.Pointer(&fn))
 		racewriterangepc(unsafe.Pointer(&to[0]), n, callerpc, pc)
diff --git a/src/pkg/runtime/string.go b/src/pkg/runtime/string.go
index 983125f0ce..72b732f844 100644
--- a/src/pkg/runtime/string.go
+++ b/src/pkg/runtime/string.go
@@ -64,7 +64,7 @@ func slicebytetostring(b []byte) string {
 		fn := slicebytetostring
 		racereadrangepc(unsafe.Pointer(&b[0]),
 			len(b),
-			gogetcallerpc(unsafe.Pointer(&b)),
+			getcallerpc(unsafe.Pointer(&b)),
 			**(**uintptr)(unsafe.Pointer(&fn)))
 	}
 	s, c := rawstring(len(b))
@@ -85,7 +85,7 @@ func slicebytetostringtmp(b []byte) string {
 		fn := slicebytetostringtmp
 		racereadrangepc(unsafe.Pointer(&b[0]),
 			len(b),
-			gogetcallerpc(unsafe.Pointer(&b)),
+			getcallerpc(unsafe.Pointer(&b)),
 			**(**uintptr)(unsafe.Pointer(&fn)))
 	}
 	return *(*string)(unsafe.Pointer(&b))
@@ -123,7 +123,7 @@ func slicerunetostring(a []rune) string {
 		fn := slicerunetostring
 		racereadrangepc(unsafe.Pointer(&a[0]),
 			len(a)*int(unsafe.Sizeof(a[0])),
-			gogetcallerpc(unsafe.Pointer(&a)),
+			getcallerpc(unsafe.Pointer(&a)),
 			**(**uintptr)(unsafe.Pointer(&fn)))
 	}
 	var dum [4]byte
@@ -219,7 +219,7 @@ func rawstring(size int) (s string, b []byte) {
 
 	for {
 		ms := maxstring
-		if uintptr(size) <= uintptr(ms) || gocasx((*uintptr)(unsafe.Pointer(&maxstring)), uintptr(ms), uintptr(size)) {
+		if uintptr(size) <= uintptr(ms) || casuintptr((*uintptr)(unsafe.Pointer(&maxstring)), uintptr(ms), uintptr(size)) {
 			return
 		}
 	}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 52d0c0e3a5..1f3cc16e62 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -15,12 +15,6 @@ const (
 	ptrSize = unsafe.Sizeof((*byte)(nil))
 )
 
-//go:noescape
-func gogetcallerpc(p unsafe.Pointer) uintptr
-
-//go:noescape
-func gogetcallersp(p unsafe.Pointer) uintptr
-
 //go:noescape
 func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
 
@@ -91,11 +85,12 @@ var (
 	setmaxthreads_m,
 	ready_m,
 	park_m,
-	blockevent_m,
 	notewakeup_m,
 	notetsleepg_m mFunction
 )
 
+func blockevent(int64, int32)
+
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
 //go:noescape
@@ -117,26 +112,6 @@ const (
 	concurrentSweep  = true
 )
 
-// Atomic operations to read/write a pointer.
-// in stubs.goc
-func goatomicload(p *uint32) uint32                     // return *p
-func goatomicloadp(p unsafe.Pointer) unsafe.Pointer     // return *p
-func goatomicstore(p *uint32, v uint32)                 // *p = v
-func goatomicstorep(p unsafe.Pointer, v unsafe.Pointer) // *p = v
-
-// in stubs.goc
-// if *p == x { *p = y; return true } else { return false }, atomically
-//go:noescape
-func gocas(p *uint32, x uint32, y uint32) bool
-
-//go:noescape
-func goxadd(p *uint32, x uint32) uint32
-
-//go:noescape
-func gocasx(p *uintptr, x uintptr, y uintptr) bool
-
-func goreadgogc() int32
-func gonanotime() int64
 func gosched()
 func starttheworld()
 func stoptheworld()
@@ -187,33 +162,6 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 	return unsafe.Pointer(x ^ 0)
 }
 
-// gopersistentalloc allocates a permanent (not garbage collected)
-// memory region of size n.  Use wisely!
-func gopersistentalloc(n uintptr) unsafe.Pointer
-
-func gocputicks() int64
-
-func gonoteclear(n *note) {
-	n.key = 0
-}
-
-func gonotewakeup(n *note) {
-	mp := acquirem()
-	mp.ptrarg[0] = unsafe.Pointer(n)
-	onM(&notewakeup_m)
-	releasem(mp)
-}
-
-func gonotetsleepg(n *note, t int64) {
-	mp := acquirem()
-	mp.ptrarg[0] = unsafe.Pointer(n)
-	mp.scalararg[0] = uint(uint32(t)) // low 32 bits
-	mp.scalararg[1] = uint(t >> 32)   // high 32 bits
-	releasem(mp)
-	mcall(&notetsleepg_m)
-	exitsyscall()
-}
-
 func exitsyscall()
 
 func goroutineheader(gp *g)
@@ -231,22 +179,6 @@ func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
 func jmpdefer(fv *funcval, argp unsafe.Pointer)
 func exit1(code int32)
 func asminit()
-func getcallersp(argp unsafe.Pointer) uintptr
-func cas(ptr *uint32, old, new uint32) bool
-func cas64(ptr *uint64, old, new uint64) bool
-func casp(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
-func xadd(ptr *uint32, delta int32) uint32
-func xadd64(ptr *uint64, delta int64) uint64
-func xchg(ptr *uint32, new uint32) uint32
-func xchg64(ptr *uint64, new uint64) uint64
-func xchgp(ptr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
-func atomicstore(ptr *uint32, val uint32)
-func atomicstore64(ptr *uint64, val uint64)
-func atomicstorep(ptr *unsafe.Pointer, val unsafe.Pointer)
-func atomicload(ptr *uint32) uint32
-func atomicload64(ptr *uint64) uint64
-func atomicloadp(ptr *unsafe.Pointer) unsafe.Pointer
-func atomicor8(ptr *uint8, val uint8)
 func setg(gg *g)
 func exit(code int32)
 func breakpoint()
@@ -257,10 +189,72 @@ func cputicks() int64
 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer
 func munmap(addr unsafe.Pointer, n uintptr)
 func madvise(addr unsafe.Pointer, n uintptr, flags int32)
-func setcallerpc(argp unsafe.Pointer, pc uintptr)
-func getcallerpc(argp unsafe.Pointer) uintptr
 func newstackcall(fv *funcval, addr unsafe.Pointer, size uint32)
 func procyield(cycles uint32)
 func osyield()
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
 func cmpstring(s1, s2 string) int
+func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer
+func readgogc() int32
+func notetsleepg(n *note, ns int64)
+func notetsleep(n *note, ns int64)
+func notewakeup(n *note)
+func notesleep(n *note)
+func noteclear(n *note)
+
+//go:noescape
+func cas(ptr *uint32, old, new uint32) bool
+
+//go:noescape
+func cas64(ptr *uint64, old, new uint64) bool
+
+//go:noescape
+func casp(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
+
+//go:noescape
+func casuintptr(ptr *uintptr, old, new uintptr) bool
+
+//go:noescape
+func xadd(ptr *uint32, delta int32) uint32
+
+//go:noescape
+func xadd64(ptr *uint64, delta int64) uint64
+
+//go:noescape
+func xchg(ptr *uint32, new uint32) uint32
+
+//go:noescape
+func xchg64(ptr *uint64, new uint64) uint64
+
+//go:noescape
+func xchgp(ptr unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
+
+//go:noescape
+func atomicstore(ptr *uint32, val uint32)
+
+//go:noescape
+func atomicstore64(ptr *uint64, val uint64)
+
+//go:noescape
+func atomicstorep(ptr unsafe.Pointer, val unsafe.Pointer)
+
+//go:noescape
+func atomicload(ptr *uint32) uint32
+
+//go:noescape
+func atomicload64(ptr *uint64) uint64
+
+//go:noescape
+func atomicloadp(ptr unsafe.Pointer) unsafe.Pointer
+
+//go:noescape
+func atomicor8(ptr *uint8, val uint8)
+
+//go:noescape
+func setcallerpc(argp unsafe.Pointer, pc uintptr)
+
+//go:noescape
+func getcallerpc(argp unsafe.Pointer) uintptr
+
+//go:noescape
+func getcallersp(argp unsafe.Pointer) uintptr
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index 1cda75e395..ebf9cc1053 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -32,57 +32,12 @@ func gounlock(p *Lock) {
 	runtime·unlock(p);
 }
 
-#pragma textflag NOSPLIT
-func goreadgogc() (r int32) {
-	r = runtime·readgogc();
-}
-
 // entry point for testing
 // TODO: mcall and run on M stack
 func gostringW(str Slice) (s String) {
 	s = runtime·gostringw((uint16*)str.array);
 }
 
-#pragma textflag NOSPLIT
-func gonanotime() (r int64) {
-	r = runtime·nanotime();
-}
-
-#pragma textflag NOSPLIT
-func goatomicload(p *uint32) (v uint32) {
-	v = runtime·atomicload(p);
-}
-
-#pragma textflag NOSPLIT
-func goatomicloadp(p **byte) (v *byte) {
-	v = runtime·atomicloadp(p);
-}
-
-#pragma textflag NOSPLIT
-func goatomicstore(p *uint32, v uint32) {
-	runtime·atomicstore(p, v);
-}
-
-#pragma textflag NOSPLIT
-func goatomicstorep(p **byte, v *byte) {
-	runtime·atomicstorep(p, v);
-}
-
-#pragma textflag NOSPLIT
-func runtime·goxadd(p *uint32, x uint32) (ret uint32) {
-	ret = runtime·xadd(p, x);
-}
-
-#pragma textflag NOSPLIT
-func runtime·gocas(p *uint32, x uint32, y uint32) (ret bool) {
-	ret = runtime·cas(p, x, y);
-}
-
-#pragma textflag NOSPLIT
-func runtime·gocasx(p *uintptr, x uintptr, y uintptr) (ret bool) {
-	ret = runtime·casp((void**)p, (void*)x, (void*)y);
-}
-
 #pragma textflag NOSPLIT
 func runtime·getg() (ret *G) {
 	ret = g;
@@ -115,12 +70,6 @@ func GCMask(x Eface) (mask Slice) {
 	mask.cap = mask.len;
 }
 
-#pragma textflag NOSPLIT
-func gopersistentalloc(size uintptr) (x *void) {
-	// TODO: used only for itabs for now.  Need to make &mstats.other_sys arg parameterized.
-	x = runtime·persistentalloc(size, 0, &mstats.other_sys);
-}
-
 #pragma textflag NOSPLIT
 func reflect·typelinks() (ret Slice) {
         extern Type *runtime·typelink[], *runtime·etypelink[];
diff --git a/src/pkg/runtime/syscall_windows.go b/src/pkg/runtime/syscall_windows.go
index 272db62410..5ca9735ac6 100644
--- a/src/pkg/runtime/syscall_windows.go
+++ b/src/pkg/runtime/syscall_windows.go
@@ -15,15 +15,11 @@ type callbacks struct {
 }
 
 func (c *wincallbackcontext) isCleanstack() bool {
-	return c.cleanstack == 1
+	return c.cleanstack
 }
 
 func (c *wincallbackcontext) setCleanstack(cleanstack bool) {
-	if cleanstack {
-		c.cleanstack = 1
-	} else {
-		c.cleanstack = 0
-	}
+	c.cleanstack = cleanstack
 }
 
 var (
@@ -51,11 +47,11 @@ func compileCallback(fn eface, cleanstack bool) (code uintptr) {
 	if len(ft.out) != 1 {
 		panic("compilecallback: function must have one output parameter")
 	}
-	uintptrSize := uint(unsafe.Sizeof(uintptr(0)))
+	uintptrSize := unsafe.Sizeof(uintptr(0))
 	if t := (**_type)(unsafe.Pointer(&ft.out[0])); (*t).size != uintptrSize {
 		panic("compilecallback: output parameter size is wrong")
 	}
-	argsize := uint(0)
+	argsize := uintptr(0)
 	for _, t := range (*[1024](*_type))(unsafe.Pointer(&ft.in[0]))[:len(ft.in)] {
 		if (*t).size != uintptrSize {
 			panic("compilecallback: input parameter size is wrong")
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 1f83438ef4..7e7aa84335 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -12,7 +12,7 @@
 #endif
 
 TEXT time·runtimeNano(SB),NOSPLIT,$0-0
-	JMP     runtime·gonanotime(SB)
+	JMP     runtime·nanotime(SB)
 
 TEXT time·Sleep(SB),NOSPLIT,$0-0
 	JMP     runtime·timeSleep(SB)
diff --git a/src/pkg/runtime/time.go b/src/pkg/runtime/time.go
index c9df3a3643..b40952ebc2 100644
--- a/src/pkg/runtime/time.go
+++ b/src/pkg/runtime/time.go
@@ -49,7 +49,7 @@ func timeSleep(ns int64) {
 	}
 
 	t := new(timer)
-	t.when = gonanotime() + ns
+	t.when = nanotime() + ns
 	t.f = goroutineReady
 	t.arg = getg()
 	golock(&timers.lock)
@@ -100,7 +100,7 @@ func addtimerLocked(t *timer) {
 		// siftup moved to top: new earliest deadline.
 		if timers.sleeping {
 			timers.sleeping = false
-			gonotewakeup(&timers.waitnote)
+			notewakeup(&timers.waitnote)
 		}
 		if timers.rescheduling {
 			timers.rescheduling = false
@@ -149,11 +149,11 @@ func deltimer(t *timer) bool {
 // If addtimer inserts a new earlier event, addtimer1 wakes timerproc early.
 func timerproc() {
 	timers.gp = getg()
-	timers.gp.issystem = 1
+	timers.gp.issystem = true
 	for {
 		golock(&timers.lock)
 		timers.sleeping = false
-		now := gonanotime()
+		now := nanotime()
 		delta := int64(-1)
 		for {
 			if len(timers.t) == 0 {
@@ -200,9 +200,9 @@ func timerproc() {
 		}
 		// At least one timer pending.  Sleep until then.
 		timers.sleeping = true
-		gonoteclear(&timers.waitnote)
+		noteclear(&timers.waitnote)
 		gounlock(&timers.lock)
-		gonotetsleepg(&timers.waitnote, delta)
+		notetsleepg(&timers.waitnote, delta)
 	}
 }
 

From 45c819b2daf914a98b15b726c805bbed5ebe30df Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 22:03:32 -0400
Subject: [PATCH 241/423] runtime: fix arm build

TBR=minux
CC=golang-codereviews
https://golang.org/cl/137810043
---
 src/pkg/runtime/asm_arm.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 93eb08d84b..f7b90a692e 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -691,7 +691,7 @@ casfail:
 	RET
 
 TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
-	JMP	runtime·cas(SB)
+	B	runtime·cas(SB)
 
 TEXT runtime·stackguard(SB),NOSPLIT,$0-8
 	MOVW	R13, R1

From 433d64373241634af93ca35f229c1cb26caf9180 Mon Sep 17 00:00:00 2001
From: Dave Cheney <dave@cheney.net>
Date: Thu, 28 Aug 2014 12:41:32 +1000
Subject: [PATCH 242/423] runtime: fix arm5 softfloat build

runtime._sfloat2 now returns the lr value on the stack, not R0.

Credit to Russ Cox for the fix.

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/133120045
---
 src/pkg/runtime/vlop_arm.s | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/vlop_arm.s b/src/pkg/runtime/vlop_arm.s
index 3b5243c3d2..9dfb295e87 100644
--- a/src/pkg/runtime/vlop_arm.s
+++ b/src/pkg/runtime/vlop_arm.s
@@ -47,12 +47,12 @@ TEXT _mulv(SB), NOSPLIT, $0
 // trampoline for _sfloat2. passes LR as arg0 and
 // saves registers R0-R13 and CPSR on the stack. R0-R12 and CPSR flags can
 // be changed by _sfloat2.
-TEXT _sfloat(SB), NOSPLIT, $64-0 // 4 arg + 14*4 saved regs + cpsr
+TEXT _sfloat(SB), NOSPLIT, $68-0 // 4 arg + 14*4 saved regs + cpsr + return value
 	MOVW	R14, 4(R13)
 	MOVW	R0, 8(R13)
 	MOVW	$12(R13), R0
 	MOVM.IA.W	[R1-R12], (R0)
-	MOVW	$68(R13), R1 // correct for frame size
+	MOVW	$72(R13), R1 // correct for frame size
 	MOVW	R1, 60(R13)
 	WORD	$0xe10f1000 // mrs r1, cpsr
 	MOVW	R1, 64(R13)
@@ -78,6 +78,7 @@ TEXT _sfloat(SB), NOSPLIT, $64-0 // 4 arg + 14*4 saved regs + cpsr
 	MOVW	$1, R1
 	MOVW	R1, m_softfloat(R8)
 	BL	runtime·_sfloat2(SB)
+	MOVW	68(R13), R0
 	MOVW	g_m(g), R8
 	MOVW	m_locks(R8), R1
 	SUB	$1, R1

From f9b9ecc5ee1b3ea8212ee801e719fb748dedc20e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 22:50:08 -0400
Subject: [PATCH 243/423] runtime: fix nacl build

The NaCl "system calls" were assumed to have a compatible
return convention with the C compiler, and we were using
tail jumps to those functions. Don't do that anymore.

Correct mistake introduced in newstackcall duringconversion
from (SP) to (FP) notation. (Actually this fix, in asm_amd64p32.s,
slipped into the C compiler change, but update the name to
match what go vet wants.)

Correct computation of caller stack pointer in morestack:
on amd64p32, the saved PC is the size of a uintreg, not uintptr.
This may not matter, since it's been like this for a while,
but uintreg is the correct one. (And on non-NaCl they are the same.)

This will allow the NaCl build to get much farther.
It will probably still not work completely.
There's a bug in 6l that needs fixing too.

TBR=minux
CC=golang-codereviews
https://golang.org/cl/134990043
---
 src/pkg/runtime/asm_amd64p32.s      |  2 +-
 src/pkg/runtime/os_nacl.go          |  2 +-
 src/pkg/runtime/stack.c             |  2 +-
 src/pkg/runtime/sys_nacl_386.s      | 98 ++++++++++++++++++++---------
 src/pkg/runtime/sys_nacl_amd64p32.s | 95 ++++++++++++++++++++--------
 src/pkg/runtime/sys_nacl_arm.s      | 96 ++++++++++++++++++++--------
 6 files changed, 210 insertions(+), 85 deletions(-)

diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index e08df377e1..343edb1eae 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -275,7 +275,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
 	// restore when returning from f.
 	MOVL	0(SP), AX	// our caller's PC
 	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAL	fn+0(FP), AX	// our caller's SP
+	LEAL	fv+0(FP), AX	// our caller's SP
 	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
 	MOVL	g(CX), AX
 	MOVL	AX, (m_morebuf+gobuf_g)(BX)
diff --git a/src/pkg/runtime/os_nacl.go b/src/pkg/runtime/os_nacl.go
index 5b5bcf6a4a..5620c8f796 100644
--- a/src/pkg/runtime/os_nacl.go
+++ b/src/pkg/runtime/os_nacl.go
@@ -19,6 +19,6 @@ func nacl_cond_create(flag int32) int32
 func nacl_cond_wait(cond, n int32) int32
 func nacl_cond_signal(cond int32) int32
 func nacl_cond_broadcast(cond int32) int32
-func nacl_cond_timed_wait_abs(cond, lock int32, ts unsafe.Pointer)
+func nacl_cond_timed_wait_abs(cond, lock int32, ts unsafe.Pointer) int32
 func nacl_thread_create(fn, stk, tls, xx unsafe.Pointer) int32
 func nacl_nanosleep(ts, extra unsafe.Pointer) int32
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 78d1e149e7..0ce869f442 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -899,7 +899,7 @@ runtime·newstack(void)
 	sp = gp->sched.sp;
 	if(thechar == '6' || thechar == '8') {
 		// The call to morestack cost a word.
-		sp -= sizeof(uintptr);
+		sp -= sizeof(uintreg);
 	}
 	if(StackDebug >= 1 || sp < gp->stackguard - StackGuard) {
 		runtime·printf("runtime: newstack framesize=%p argsize=%p sp=%p stack=[%p, %p]\n"
diff --git a/src/pkg/runtime/sys_nacl_386.s b/src/pkg/runtime/sys_nacl_386.s
index e460e8efcd..56fbd618bf 100644
--- a/src/pkg/runtime/sys_nacl_386.s
+++ b/src/pkg/runtime/sys_nacl_386.s
@@ -9,25 +9,30 @@
 #define NACL_SYSCALL(code) \
 	MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
 
-#define NACL_SYSJMP(code) \
-	MOVL $(0x10000 + ((code)<<5)), AX; JMP AX
-
 TEXT runtime·exit(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_exit)
+	NACL_SYSCALL(SYS_exit)
+	JMP 0(PC)
 
 TEXT runtime·exit1(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_thread_exit)
+	NACL_SYSCALL(SYS_thread_exit)
+	RET
 
 TEXT runtime·open(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_open)
+	NACL_SYSCALL(SYS_open)
+	MOVL AX, ret+12(FP)
+	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_close)
+	NACL_SYSCALL(SYS_close)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_read)
+	NACL_SYSCALL(SYS_read)
+	MOVL AX, ret+12(FP)
+	RET
 
-TEXT syscall·naclWrite(SB), NOSPLIT, $12-16
+TEXT syscall·naclWrite(SB), NOSPLIT, $16-16
 	MOVL arg1+0(FP), DI
 	MOVL arg2+4(FP), SI
 	MOVL arg3+8(FP), DX
@@ -39,61 +44,96 @@ TEXT syscall·naclWrite(SB), NOSPLIT, $12-16
 	RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_write)
+	NACL_SYSCALL(SYS_write)
+	MOVL AX, ret+12(FP)
+	RET
 
 TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_exception_stack)
+	NACL_SYSCALL(SYS_exception_stack)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_exception_handler)
+	NACL_SYSCALL(SYS_exception_handler)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_sem_create)
+	NACL_SYSCALL(SYS_sem_create)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_sem_wait)
+	NACL_SYSCALL(SYS_sem_wait)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_sem_post)
+	NACL_SYSCALL(SYS_sem_post)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_mutex_create)
+	NACL_SYSCALL(SYS_mutex_create)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_mutex_lock)
+	NACL_SYSCALL(SYS_mutex_lock)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_mutex_trylock)
+	NACL_SYSCALL(SYS_mutex_trylock)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_mutex_unlock)
+	NACL_SYSCALL(SYS_mutex_unlock)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_cond_create)
+	NACL_SYSCALL(SYS_cond_create)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_cond_wait)
+	NACL_SYSCALL(SYS_cond_wait)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_cond_signal)
+	NACL_SYSCALL(SYS_cond_signal)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_cond_broadcast)
+	NACL_SYSCALL(SYS_cond_broadcast)
+	MOVL AX, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_cond_timed_wait_abs)
+	NACL_SYSCALL(SYS_cond_timed_wait_abs)
+	MOVL AX, ret+12(FP)
+	RET
 
 TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_thread_create)
+	NACL_SYSCALL(SYS_thread_create)
+	MOVL AX, ret+16(FP)
+	RET
 
 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 	JMP runtime·mstart(SB)
 
 TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_nanosleep)
+	NACL_SYSCALL(SYS_nanosleep)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_sched_yield)
+	NACL_SYSCALL(SYS_sched_yield)
+	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$32
 	MOVL	addr+0(FP), AX
@@ -134,7 +174,9 @@ TEXT syscall·now(SB),NOSPLIT,$0
 	JMP time·now(SB)
 
 TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_clock_gettime)
+	NACL_SYSCALL(SYS_clock_gettime)
+	MOVL AX, ret+8(FP)
+	RET
 	
 TEXT runtime·nanotime(SB),NOSPLIT,$20
 	MOVL $0, 0(SP) // real time clock
diff --git a/src/pkg/runtime/sys_nacl_amd64p32.s b/src/pkg/runtime/sys_nacl_amd64p32.s
index 213e12d36d..1fd083718a 100644
--- a/src/pkg/runtime/sys_nacl_amd64p32.s
+++ b/src/pkg/runtime/sys_nacl_amd64p32.s
@@ -9,38 +9,43 @@
 #define NACL_SYSCALL(code) \
 	MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
 
-#define NACL_SYSJMP(code) \
-	MOVL $(0x10000 + ((code)<<5)), AX; JMP AX
-
 TEXT runtime·settls(SB),NOSPLIT,$0
 	MOVL	DI, TLS // really BP
 	RET
 
 TEXT runtime·exit(SB),NOSPLIT,$0
 	MOVL code+0(FP), DI
-	NACL_SYSJMP(SYS_exit)
+	NACL_SYSCALL(SYS_exit)
+	RET
 
 TEXT runtime·exit1(SB),NOSPLIT,$0
 	MOVL code+0(FP), DI
-	NACL_SYSJMP(SYS_thread_exit)
+	NACL_SYSCALL(SYS_thread_exit)
+	RET
 
 TEXT runtime·open(SB),NOSPLIT,$0
 	MOVL name+0(FP), DI
 	MOVL mode+4(FP), SI
 	MOVL perm+8(FP), DX
-	NACL_SYSJMP(SYS_open)
+	NACL_SYSCALL(SYS_open)
+	MOVL AX, ret+16(FP)
+	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVL fd+0(FP), DI
-	NACL_SYSJMP(SYS_close)
+	NACL_SYSCALL(SYS_close)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
 	MOVL fd+0(FP), DI
 	MOVL p+4(FP), SI
 	MOVL n+8(FP), DX
-	NACL_SYSJMP(SYS_read)
+	NACL_SYSCALL(SYS_read)
+	MOVL AX, ret+16(FP)
+	RET
 
-TEXT syscall·naclWrite(SB), NOSPLIT, $16-20
+TEXT syscall·naclWrite(SB), NOSPLIT, $24-20
 	MOVL arg1+0(FP), DI
 	MOVL arg2+4(FP), SI
 	MOVL arg3+8(FP), DX
@@ -48,6 +53,7 @@ TEXT syscall·naclWrite(SB), NOSPLIT, $16-20
 	MOVL SI, 4(SP)
 	MOVL DX, 8(SP)
 	CALL runtime·write(SB)
+	MOVL 16(SP), AX
 	MOVL AX, ret+16(FP)
 	RET
 
@@ -107,70 +113,100 @@ playback:
 TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
 	MOVL p+0(FP), DI
 	MOVL size+4(FP), SI
-	NACL_SYSJMP(SYS_exception_stack)
+	NACL_SYSCALL(SYS_exception_stack)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
 	MOVL fn+0(FP), DI
 	MOVL arg+4(FP), SI
-	NACL_SYSJMP(SYS_exception_handler)
+	NACL_SYSCALL(SYS_exception_handler)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
 	MOVL flag+0(FP), DI
-	NACL_SYSJMP(SYS_sem_create)
+	NACL_SYSCALL(SYS_sem_create)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
 	MOVL sem+0(FP), DI
-	NACL_SYSJMP(SYS_sem_wait)
+	NACL_SYSCALL(SYS_sem_wait)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
 	MOVL sem+0(FP), DI
-	NACL_SYSJMP(SYS_sem_post)
+	NACL_SYSCALL(SYS_sem_post)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
 	MOVL flag+0(FP), DI
-	NACL_SYSJMP(SYS_mutex_create)
+	NACL_SYSCALL(SYS_mutex_create)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
 	MOVL mutex+0(FP), DI
-	NACL_SYSJMP(SYS_mutex_lock)
+	NACL_SYSCALL(SYS_mutex_lock)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
 	MOVL mutex+0(FP), DI
-	NACL_SYSJMP(SYS_mutex_trylock)
+	NACL_SYSCALL(SYS_mutex_trylock)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
 	MOVL mutex+0(FP), DI
-	NACL_SYSJMP(SYS_mutex_unlock)
+	NACL_SYSCALL(SYS_mutex_unlock)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
 	MOVL flag+0(FP), DI
-	NACL_SYSJMP(SYS_cond_create)
+	NACL_SYSCALL(SYS_cond_create)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
 	MOVL cond+0(FP), DI
 	MOVL n+4(FP), SI
-	NACL_SYSJMP(SYS_cond_wait)
+	NACL_SYSCALL(SYS_cond_wait)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
 	MOVL cond+0(FP), DI
-	NACL_SYSJMP(SYS_cond_signal)
+	NACL_SYSCALL(SYS_cond_signal)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
 	MOVL cond+0(FP), DI
-	NACL_SYSJMP(SYS_cond_broadcast)
+	NACL_SYSCALL(SYS_cond_broadcast)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
 	MOVL cond+0(FP), DI
 	MOVL lock+4(FP), SI
 	MOVL ts+8(FP), DX
-	NACL_SYSJMP(SYS_cond_timed_wait_abs)
+	NACL_SYSCALL(SYS_cond_timed_wait_abs)
+	MOVL AX, ret+16(FP)
+	RET
 
 TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
 	MOVL fn+0(FP), DI
 	MOVL stk+4(FP), SI
 	MOVL tls+8(FP), DX
 	MOVL xx+12(FP), CX
-	NACL_SYSJMP(SYS_thread_create)
+	NACL_SYSCALL(SYS_thread_create)
+	MOVL AX, ret+16(FP)
+	RET
 
 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 	NACL_SYSCALL(SYS_tls_get)
@@ -181,10 +217,13 @@ TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
 	MOVL ts+0(FP), DI
 	MOVL extra+4(FP), SI
-	NACL_SYSJMP(SYS_nanosleep)
+	NACL_SYSCALL(SYS_nanosleep)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_sched_yield)
+	NACL_SYSCALL(SYS_sched_yield)
+	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$8
 	MOVL addr+0(FP), DI
@@ -233,7 +272,9 @@ TEXT syscall·now(SB),NOSPLIT,$0
 TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
 	MOVL arg1+0(FP), DI
 	MOVL arg2+4(FP), SI
-	NACL_SYSJMP(SYS_clock_gettime)
+	NACL_SYSCALL(SYS_clock_gettime)
+	MOVL AX, ret+8(FP)
+	RET
 
 TEXT runtime·nanotime(SB),NOSPLIT,$16
 	MOVQ runtime·timens(SB), AX
diff --git a/src/pkg/runtime/sys_nacl_arm.s b/src/pkg/runtime/sys_nacl_arm.s
index 48b9aaed7c..cc18522208 100644
--- a/src/pkg/runtime/sys_nacl_arm.s
+++ b/src/pkg/runtime/sys_nacl_arm.s
@@ -9,32 +9,37 @@
 #define NACL_SYSCALL(code) \
 	MOVW	$(0x10000 + ((code)<<5)), R8; BL (R8)
 
-#define NACL_SYSJMP(code) \
-	MOVW	$(0x10000 + ((code)<<5)), R8; B (R8)
-
 TEXT runtime·exit(SB),NOSPLIT,$0
 	MOVW	code+0(FP), R0
-	NACL_SYSJMP(SYS_exit)
+	NACL_SYSCALL(SYS_exit)
+	RET
 
 TEXT runtime·exit1(SB),NOSPLIT,$0
 	MOVW	code+0(FP), R0
-	NACL_SYSJMP(SYS_thread_exit)
+	NACL_SYSCALL(SYS_thread_exit)
+	RET
 
 TEXT runtime·open(SB),NOSPLIT,$0
 	MOVW	name+0(FP), R0
 	MOVW	name+0(FP), R1
 	MOVW	name+0(FP), R2
-	NACL_SYSJMP(SYS_open)
+	NACL_SYSCALL(SYS_open)
+	MOVW	R0, ret+12(FP)
+	RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
 	MOVW	fd+0(FP), R0
-	NACL_SYSJMP(SYS_close)
+	NACL_SYSCALL(SYS_close)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
 	MOVW	fd+0(FP), R0
 	MOVW	p+4(FP), R1
 	MOVW	n+8(FP), R2
-	NACL_SYSJMP(SYS_read)
+	NACL_SYSCALL(SYS_read)
+	MOVW	R0, ret+12(FP)
+	RET
 
 // func naclWrite(fd int, b []byte) int
 TEXT syscall·naclWrite(SB),NOSPLIT,$0
@@ -49,75 +54,107 @@ TEXT runtime·write(SB),NOSPLIT,$0
 	MOVW	fd+0(FP), R0
 	MOVW	p+4(FP), R1
 	MOVW	n+8(FP), R2
-	NACL_SYSJMP(SYS_write)
+	NACL_SYSCALL(SYS_write)
+	MOVW	R0, ret+12(FP)
+	RET
 
 TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
 	MOVW	p+0(FP), R0
 	MOVW	size+4(FP), R1
-	NACL_SYSJMP(SYS_exception_stack)
+	NACL_SYSCALL(SYS_exception_stack)
+	MOVW	R0, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
 	MOVW	fn+0(FP), R0
 	MOVW	arg+4(FP), R1
-	NACL_SYSJMP(SYS_exception_handler)
+	NACL_SYSCALL(SYS_exception_handler)
+	MOVW	R0, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
 	MOVW	flag+0(FP), R0
-	NACL_SYSJMP(SYS_sem_create)
+	NACL_SYSCALL(SYS_sem_create)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
 	MOVW	sem+0(FP), R0
-	NACL_SYSJMP(SYS_sem_wait)
+	NACL_SYSCALL(SYS_sem_wait)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
 	MOVW	sem+0(FP), R0
-	NACL_SYSJMP(SYS_sem_post)
+	NACL_SYSCALL(SYS_sem_post)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
 	MOVW	flag+0(FP), R0
-	NACL_SYSJMP(SYS_mutex_create)
+	NACL_SYSCALL(SYS_mutex_create)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
 	MOVW	mutex+0(FP), R0
-	NACL_SYSJMP(SYS_mutex_lock)
+	NACL_SYSCALL(SYS_mutex_lock)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
 	MOVW	mutex+0(FP), R0
-	NACL_SYSJMP(SYS_mutex_trylock)
+	NACL_SYSCALL(SYS_mutex_trylock)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
 	MOVW	mutex+0(FP), R0
-	NACL_SYSJMP(SYS_mutex_unlock)
+	NACL_SYSCALL(SYS_mutex_unlock)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
 	MOVW	flag+0(FP), R0
-	NACL_SYSJMP(SYS_cond_create)
+	NACL_SYSCALL(SYS_cond_create)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
 	MOVW	cond+0(FP), R0
 	MOVW	n+4(FP), R1
-	NACL_SYSJMP(SYS_cond_wait)
+	NACL_SYSCALL(SYS_cond_wait)
+	MOVW	R0, ret+8(FP)
+	RET
 
 TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
 	MOVW	cond+0(FP), R0
-	NACL_SYSJMP(SYS_cond_signal)
+	NACL_SYSCALL(SYS_cond_signal)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
 	MOVW	cond+0(FP), R0
-	NACL_SYSJMP(SYS_cond_broadcast)
+	NACL_SYSCALL(SYS_cond_broadcast)
+	MOVW	R0, ret+4(FP)
+	RET
 
 TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
 	MOVW	cond+0(FP), R0
 	MOVW	lock+4(FP), R1
 	MOVW	ts+8(FP), R2
-	NACL_SYSJMP(SYS_cond_timed_wait_abs)
+	NACL_SYSCALL(SYS_cond_timed_wait_abs)
+	MOVW	R0, ret+12(FP)
+	RET
 
 TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
 	MOVW	fn+0(FP), R0
 	MOVW	stk+4(FP), R1
 	MOVW	tls+8(FP), R2
 	MOVW	xx+12(FP), R3
-	NACL_SYSJMP(SYS_thread_create)
+	NACL_SYSCALL(SYS_thread_create)
+	MOVW	R0, ret+16(FP)
+	RET
 
 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 	MOVW	0(R9), R0 // TLS
@@ -130,10 +167,13 @@ TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
 	MOVW	ts+0(FP), R0
 	MOVW	extra+4(FP), R1
-	NACL_SYSJMP(SYS_nanosleep)
+	NACL_SYSCALL(SYS_nanosleep)
+	MOVW	R0, ret+8(FP)
+	RET
 
 TEXT runtime·osyield(SB),NOSPLIT,$0
-	NACL_SYSJMP(SYS_sched_yield)
+	NACL_SYSCALL(SYS_sched_yield)
+	RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$8
 	MOVW	addr+0(FP), R0
@@ -173,7 +213,9 @@ TEXT syscall·now(SB),NOSPLIT,$0
 TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
 	MOVW	arg1+0(FP), R0
 	MOVW	arg2+4(FP), R1
-	NACL_SYSJMP(SYS_clock_gettime)
+	NACL_SYSCALL(SYS_clock_gettime)
+	MOVW	R0, ret+8(FP)
+	RET
 
 // int64 nanotime(void) so really
 // void nanotime(int64 *nsec)

From a9b2651ade68733405cdc296d66d9b9d8ea68bf0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 22:53:28 -0400
Subject: [PATCH 244/423] cmd/5l, cmd/6l, cmd/8l: fix nacl binary corruption
 bug

NaCl requires the addition of a 32-byte "halt sled" at the end
of the text segment. This means that segtext.len is actually
32 bytes shorter than reality. The computation of the file offset
of the end of the data segment did not take this 32 bytes into
account, so if len and len+32 rounded up (by 64k) to different
values, the symbol table overwrote the last page of the data
segment.

The last page of the data segment is usually the C .string
symbols, which contain the strings used in error prints
by the runtime. So when this happens, your program
probably crashes, and then when it does, you get binary
garbage instead of all the usual prints.

The chance of hitting this with a randomly sized text segment
is 32 in 65536, or 1 in 2048.

If you add or remove ANY code while trying to debug this
problem, you're overwhelmingly likely to bump the text
segment one way or the other and make the bug disappear.

Correct all the computations to use segdata.fileoff+segdata.filelen
instead of trying to rederive segdata.fileoff.

This fixes the failure during the nacl/amd64p32 build.

TBR=iant
CC=golang-codereviews
https://golang.org/cl/135050043
---
 src/cmd/5l/asm.c | 4 ++--
 src/cmd/6l/asm.c | 8 ++++----
 src/cmd/8l/asm.c | 8 ++++----
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/cmd/5l/asm.c b/src/cmd/5l/asm.c
index 02b4c78f11..9c1c04e2d4 100644
--- a/src/cmd/5l/asm.c
+++ b/src/cmd/5l/asm.c
@@ -599,10 +599,10 @@ asmb(void)
 			if(iself)
 				goto ElfSym;
 		case Hplan9:
-			symo = HEADR+segtext.len+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			break;
 		ElfSym:
-			symo = rnd(HEADR+segtext.filelen, INITRND)+rnd(HEADR+segrodata.filelen, INITRND)+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			symo = rnd(symo, INITRND);
 			break;
 		}
diff --git a/src/cmd/6l/asm.c b/src/cmd/6l/asm.c
index c7f6c65d00..18b5aa3119 100644
--- a/src/cmd/6l/asm.c
+++ b/src/cmd/6l/asm.c
@@ -698,10 +698,10 @@ asmb(void)
 		case Hplan9:
 		case Helf:
 			debug['s'] = 1;
-			symo = HEADR+segtext.len+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			break;
 		case Hdarwin:
-			symo = rnd(HEADR+segtext.len, INITRND)+rnd(segdata.filelen, INITRND)+machlink;
+			symo = segdata.fileoff+rnd(segdata.filelen, INITRND)+machlink;
 			break;
 		case Hlinux:
 		case Hfreebsd:
@@ -710,11 +710,11 @@ asmb(void)
 		case Hdragonfly:
 		case Hsolaris:
 		case Hnacl:
-			symo = rnd(HEADR+segtext.len, INITRND)+rnd(segrodata.len, INITRND)+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			symo = rnd(symo, INITRND);
 			break;
 		case Hwindows:
-			symo = rnd(HEADR+segtext.filelen, PEFILEALIGN)+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			symo = rnd(symo, PEFILEALIGN);
 			break;
 		}
diff --git a/src/cmd/8l/asm.c b/src/cmd/8l/asm.c
index 114a3eb5d7..c135dce709 100644
--- a/src/cmd/8l/asm.c
+++ b/src/cmd/8l/asm.c
@@ -619,17 +619,17 @@ asmb(void)
 			if(iself)
 				goto Elfsym;
 		case Hplan9:
-			symo = HEADR+segtext.filelen+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			break;
 		case Hdarwin:
-			symo = rnd(HEADR+segtext.filelen, INITRND)+rnd(segdata.filelen, INITRND)+machlink;
+			symo = segdata.fileoff+rnd(segdata.filelen, INITRND)+machlink;
 			break;
 		Elfsym:
-			symo = rnd(HEADR+segtext.filelen, INITRND)+rnd(HEADR+segrodata.filelen, INITRND)+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			symo = rnd(symo, INITRND);
 			break;
 		case Hwindows:
-			symo = rnd(HEADR+segtext.filelen, PEFILEALIGN)+segdata.filelen;
+			symo = segdata.fileoff+segdata.filelen;
 			symo = rnd(symo, PEFILEALIGN);
 			break;
 		}

From 299117eca0f28b6e379c4d5b7e43e2f13cf0cd36 Mon Sep 17 00:00:00 2001
From: Michael Hudson-Doyle <michael.hudson@linaro.org>
Date: Wed, 27 Aug 2014 20:18:56 -0700
Subject: [PATCH 245/423] debug/elf: support arm64 relocations

This adds the minimal support for AArch64/arm64 relocations
needed to get cgo to work (when an isomorphic patch is applied
to gccgo) and a test.

This change uses the "AAarch64" name for the architecture rather
than the more widely accepted "arm64" because that's the name that
the relevant docs from ARM such as

   http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf

all use.

Fixes #8533.

LGTM=iant
R=golang-codereviews, aram, gobot, iant, minux
CC=golang-codereviews
https://golang.org/cl/132000043
---
 src/pkg/debug/elf/elf.go                      | 338 +++++++++++++++---
 src/pkg/debug/elf/file.go                     |  50 ++-
 src/pkg/debug/elf/file_test.go                |   6 +
 .../go-relocation-test-gcc482-aarch64.obj     | Bin 0 -> 3392 bytes
 4 files changed, 350 insertions(+), 44 deletions(-)
 create mode 100644 src/pkg/debug/elf/testdata/go-relocation-test-gcc482-aarch64.obj

diff --git a/src/pkg/debug/elf/elf.go b/src/pkg/debug/elf/elf.go
index d622dae2af..cde296c794 100644
--- a/src/pkg/debug/elf/elf.go
+++ b/src/pkg/debug/elf/elf.go
@@ -11,6 +11,7 @@
  * $FreeBSD: src/sys/i386/include/elf.h,v 1.16 2004/08/02 19:12:17 dfr Exp $
  * $FreeBSD: src/sys/powerpc/include/elf.h,v 1.7 2004/11/02 09:47:01 ssouhlal Exp $
  * $FreeBSD: src/sys/sparc64/include/elf.h,v 1.12 2003/09/25 01:10:26 peter Exp $
+ * "ELF for the ARM® 64-bit Architecture (AArch64)" (ARM IHI 0056B)
  *
  * Copyright (c) 1996-1998 John D. Polstra.  All rights reserved.
  * Copyright (c) 2001 David E. O'Brien
@@ -192,49 +193,50 @@ func (i Type) GoString() string { return stringName(uint32(i), typeStrings, true
 type Machine uint16
 
 const (
-	EM_NONE        Machine = 0  /* Unknown machine. */
-	EM_M32         Machine = 1  /* AT&T WE32100. */
-	EM_SPARC       Machine = 2  /* Sun SPARC. */
-	EM_386         Machine = 3  /* Intel i386. */
-	EM_68K         Machine = 4  /* Motorola 68000. */
-	EM_88K         Machine = 5  /* Motorola 88000. */
-	EM_860         Machine = 7  /* Intel i860. */
-	EM_MIPS        Machine = 8  /* MIPS R3000 Big-Endian only. */
-	EM_S370        Machine = 9  /* IBM System/370. */
-	EM_MIPS_RS3_LE Machine = 10 /* MIPS R3000 Little-Endian. */
-	EM_PARISC      Machine = 15 /* HP PA-RISC. */
-	EM_VPP500      Machine = 17 /* Fujitsu VPP500. */
-	EM_SPARC32PLUS Machine = 18 /* SPARC v8plus. */
-	EM_960         Machine = 19 /* Intel 80960. */
-	EM_PPC         Machine = 20 /* PowerPC 32-bit. */
-	EM_PPC64       Machine = 21 /* PowerPC 64-bit. */
-	EM_S390        Machine = 22 /* IBM System/390. */
-	EM_V800        Machine = 36 /* NEC V800. */
-	EM_FR20        Machine = 37 /* Fujitsu FR20. */
-	EM_RH32        Machine = 38 /* TRW RH-32. */
-	EM_RCE         Machine = 39 /* Motorola RCE. */
-	EM_ARM         Machine = 40 /* ARM. */
-	EM_SH          Machine = 42 /* Hitachi SH. */
-	EM_SPARCV9     Machine = 43 /* SPARC v9 64-bit. */
-	EM_TRICORE     Machine = 44 /* Siemens TriCore embedded processor. */
-	EM_ARC         Machine = 45 /* Argonaut RISC Core. */
-	EM_H8_300      Machine = 46 /* Hitachi H8/300. */
-	EM_H8_300H     Machine = 47 /* Hitachi H8/300H. */
-	EM_H8S         Machine = 48 /* Hitachi H8S. */
-	EM_H8_500      Machine = 49 /* Hitachi H8/500. */
-	EM_IA_64       Machine = 50 /* Intel IA-64 Processor. */
-	EM_MIPS_X      Machine = 51 /* Stanford MIPS-X. */
-	EM_COLDFIRE    Machine = 52 /* Motorola ColdFire. */
-	EM_68HC12      Machine = 53 /* Motorola M68HC12. */
-	EM_MMA         Machine = 54 /* Fujitsu MMA. */
-	EM_PCP         Machine = 55 /* Siemens PCP. */
-	EM_NCPU        Machine = 56 /* Sony nCPU. */
-	EM_NDR1        Machine = 57 /* Denso NDR1 microprocessor. */
-	EM_STARCORE    Machine = 58 /* Motorola Star*Core processor. */
-	EM_ME16        Machine = 59 /* Toyota ME16 processor. */
-	EM_ST100       Machine = 60 /* STMicroelectronics ST100 processor. */
-	EM_TINYJ       Machine = 61 /* Advanced Logic Corp. TinyJ processor. */
-	EM_X86_64      Machine = 62 /* Advanced Micro Devices x86-64 */
+	EM_NONE        Machine = 0   /* Unknown machine. */
+	EM_M32         Machine = 1   /* AT&T WE32100. */
+	EM_SPARC       Machine = 2   /* Sun SPARC. */
+	EM_386         Machine = 3   /* Intel i386. */
+	EM_68K         Machine = 4   /* Motorola 68000. */
+	EM_88K         Machine = 5   /* Motorola 88000. */
+	EM_860         Machine = 7   /* Intel i860. */
+	EM_MIPS        Machine = 8   /* MIPS R3000 Big-Endian only. */
+	EM_S370        Machine = 9   /* IBM System/370. */
+	EM_MIPS_RS3_LE Machine = 10  /* MIPS R3000 Little-Endian. */
+	EM_PARISC      Machine = 15  /* HP PA-RISC. */
+	EM_VPP500      Machine = 17  /* Fujitsu VPP500. */
+	EM_SPARC32PLUS Machine = 18  /* SPARC v8plus. */
+	EM_960         Machine = 19  /* Intel 80960. */
+	EM_PPC         Machine = 20  /* PowerPC 32-bit. */
+	EM_PPC64       Machine = 21  /* PowerPC 64-bit. */
+	EM_S390        Machine = 22  /* IBM System/390. */
+	EM_V800        Machine = 36  /* NEC V800. */
+	EM_FR20        Machine = 37  /* Fujitsu FR20. */
+	EM_RH32        Machine = 38  /* TRW RH-32. */
+	EM_RCE         Machine = 39  /* Motorola RCE. */
+	EM_ARM         Machine = 40  /* ARM. */
+	EM_SH          Machine = 42  /* Hitachi SH. */
+	EM_SPARCV9     Machine = 43  /* SPARC v9 64-bit. */
+	EM_TRICORE     Machine = 44  /* Siemens TriCore embedded processor. */
+	EM_ARC         Machine = 45  /* Argonaut RISC Core. */
+	EM_H8_300      Machine = 46  /* Hitachi H8/300. */
+	EM_H8_300H     Machine = 47  /* Hitachi H8/300H. */
+	EM_H8S         Machine = 48  /* Hitachi H8S. */
+	EM_H8_500      Machine = 49  /* Hitachi H8/500. */
+	EM_IA_64       Machine = 50  /* Intel IA-64 Processor. */
+	EM_MIPS_X      Machine = 51  /* Stanford MIPS-X. */
+	EM_COLDFIRE    Machine = 52  /* Motorola ColdFire. */
+	EM_68HC12      Machine = 53  /* Motorola M68HC12. */
+	EM_MMA         Machine = 54  /* Fujitsu MMA. */
+	EM_PCP         Machine = 55  /* Siemens PCP. */
+	EM_NCPU        Machine = 56  /* Sony nCPU. */
+	EM_NDR1        Machine = 57  /* Denso NDR1 microprocessor. */
+	EM_STARCORE    Machine = 58  /* Motorola Star*Core processor. */
+	EM_ME16        Machine = 59  /* Toyota ME16 processor. */
+	EM_ST100       Machine = 60  /* STMicroelectronics ST100 processor. */
+	EM_TINYJ       Machine = 61  /* Advanced Logic Corp. TinyJ processor. */
+	EM_X86_64      Machine = 62  /* Advanced Micro Devices x86-64 */
+	EM_AARCH64     Machine = 183 /* ARM 64-bit Architecture (AArch64) */
 
 	/* Non-standard or deprecated. */
 	EM_486         Machine = 6      /* Intel i486. */
@@ -774,6 +776,256 @@ var rx86_64Strings = []intName{
 func (i R_X86_64) String() string   { return stringName(uint32(i), rx86_64Strings, false) }
 func (i R_X86_64) GoString() string { return stringName(uint32(i), rx86_64Strings, true) }
 
+// Relocation types for AArch64 (aka arm64)
+type R_AARCH64 int
+
+const (
+	R_AARCH64_NONE                            R_AARCH64 = 0
+	R_AARCH64_P32_ABS32                       R_AARCH64 = 1
+	R_AARCH64_P32_ABS16                       R_AARCH64 = 2
+	R_AARCH64_P32_PREL32                      R_AARCH64 = 3
+	R_AARCH64_P32_PREL16                      R_AARCH64 = 4
+	R_AARCH64_P32_MOVW_UABS_G0                R_AARCH64 = 5
+	R_AARCH64_P32_MOVW_UABS_G0_NC             R_AARCH64 = 6
+	R_AARCH64_P32_MOVW_UABS_G1                R_AARCH64 = 7
+	R_AARCH64_P32_MOVW_SABS_G0                R_AARCH64 = 8
+	R_AARCH64_P32_LD_PREL_LO19                R_AARCH64 = 9
+	R_AARCH64_P32_ADR_PREL_LO21               R_AARCH64 = 10
+	R_AARCH64_P32_ADR_PREL_PG_HI21            R_AARCH64 = 11
+	R_AARCH64_P32_ADD_ABS_LO12_NC             R_AARCH64 = 12
+	R_AARCH64_P32_LDST8_ABS_LO12_NC           R_AARCH64 = 13
+	R_AARCH64_P32_LDST16_ABS_LO12_NC          R_AARCH64 = 14
+	R_AARCH64_P32_LDST32_ABS_LO12_NC          R_AARCH64 = 15
+	R_AARCH64_P32_LDST64_ABS_LO12_NC          R_AARCH64 = 16
+	R_AARCH64_P32_LDST128_ABS_LO12_NC         R_AARCH64 = 17
+	R_AARCH64_P32_TSTBR14                     R_AARCH64 = 18
+	R_AARCH64_P32_CONDBR19                    R_AARCH64 = 19
+	R_AARCH64_P32_JUMP26                      R_AARCH64 = 20
+	R_AARCH64_P32_CALL26                      R_AARCH64 = 21
+	R_AARCH64_P32_GOT_LD_PREL19               R_AARCH64 = 25
+	R_AARCH64_P32_ADR_GOT_PAGE                R_AARCH64 = 26
+	R_AARCH64_P32_LD32_GOT_LO12_NC            R_AARCH64 = 27
+	R_AARCH64_P32_TLSGD_ADR_PAGE21            R_AARCH64 = 81
+	R_AARCH64_P32_TLSGD_ADD_LO12_NC           R_AARCH64 = 82
+	R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21   R_AARCH64 = 103
+	R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC R_AARCH64 = 104
+	R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19    R_AARCH64 = 105
+	R_AARCH64_P32_TLSLE_MOVW_TPREL_G1         R_AARCH64 = 106
+	R_AARCH64_P32_TLSLE_MOVW_TPREL_G0         R_AARCH64 = 107
+	R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC      R_AARCH64 = 108
+	R_AARCH64_P32_TLSLE_ADD_TPREL_HI12        R_AARCH64 = 109
+	R_AARCH64_P32_TLSLE_ADD_TPREL_LO12        R_AARCH64 = 110
+	R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC     R_AARCH64 = 111
+	R_AARCH64_P32_TLSDESC_LD_PREL19           R_AARCH64 = 122
+	R_AARCH64_P32_TLSDESC_ADR_PREL21          R_AARCH64 = 123
+	R_AARCH64_P32_TLSDESC_ADR_PAGE21          R_AARCH64 = 124
+	R_AARCH64_P32_TLSDESC_LD32_LO12_NC        R_AARCH64 = 125
+	R_AARCH64_P32_TLSDESC_ADD_LO12_NC         R_AARCH64 = 126
+	R_AARCH64_P32_TLSDESC_CALL                R_AARCH64 = 127
+	R_AARCH64_P32_COPY                        R_AARCH64 = 180
+	R_AARCH64_P32_GLOB_DAT                    R_AARCH64 = 181
+	R_AARCH64_P32_JUMP_SLOT                   R_AARCH64 = 182
+	R_AARCH64_P32_RELATIVE                    R_AARCH64 = 183
+	R_AARCH64_P32_TLS_DTPMOD                  R_AARCH64 = 184
+	R_AARCH64_P32_TLS_DTPREL                  R_AARCH64 = 185
+	R_AARCH64_P32_TLS_TPREL                   R_AARCH64 = 186
+	R_AARCH64_P32_TLSDESC                     R_AARCH64 = 187
+	R_AARCH64_P32_IRELATIVE                   R_AARCH64 = 188
+	R_AARCH64_NULL                            R_AARCH64 = 256
+	R_AARCH64_ABS64                           R_AARCH64 = 257
+	R_AARCH64_ABS32                           R_AARCH64 = 258
+	R_AARCH64_ABS16                           R_AARCH64 = 259
+	R_AARCH64_PREL64                          R_AARCH64 = 260
+	R_AARCH64_PREL32                          R_AARCH64 = 261
+	R_AARCH64_PREL16                          R_AARCH64 = 262
+	R_AARCH64_MOVW_UABS_G0                    R_AARCH64 = 263
+	R_AARCH64_MOVW_UABS_G0_NC                 R_AARCH64 = 264
+	R_AARCH64_MOVW_UABS_G1                    R_AARCH64 = 265
+	R_AARCH64_MOVW_UABS_G1_NC                 R_AARCH64 = 266
+	R_AARCH64_MOVW_UABS_G2                    R_AARCH64 = 267
+	R_AARCH64_MOVW_UABS_G2_NC                 R_AARCH64 = 268
+	R_AARCH64_MOVW_UABS_G3                    R_AARCH64 = 269
+	R_AARCH64_MOVW_SABS_G0                    R_AARCH64 = 270
+	R_AARCH64_MOVW_SABS_G1                    R_AARCH64 = 271
+	R_AARCH64_MOVW_SABS_G2                    R_AARCH64 = 272
+	R_AARCH64_LD_PREL_LO19                    R_AARCH64 = 273
+	R_AARCH64_ADR_PREL_LO21                   R_AARCH64 = 274
+	R_AARCH64_ADR_PREL_PG_HI21                R_AARCH64 = 275
+	R_AARCH64_ADR_PREL_PG_HI21_NC             R_AARCH64 = 276
+	R_AARCH64_ADD_ABS_LO12_NC                 R_AARCH64 = 277
+	R_AARCH64_LDST8_ABS_LO12_NC               R_AARCH64 = 278
+	R_AARCH64_TSTBR14                         R_AARCH64 = 279
+	R_AARCH64_CONDBR19                        R_AARCH64 = 280
+	R_AARCH64_JUMP26                          R_AARCH64 = 282
+	R_AARCH64_CALL26                          R_AARCH64 = 283
+	R_AARCH64_LDST16_ABS_LO12_NC              R_AARCH64 = 284
+	R_AARCH64_LDST32_ABS_LO12_NC              R_AARCH64 = 285
+	R_AARCH64_LDST64_ABS_LO12_NC              R_AARCH64 = 286
+	R_AARCH64_LDST128_ABS_LO12_NC             R_AARCH64 = 299
+	R_AARCH64_GOT_LD_PREL19                   R_AARCH64 = 309
+	R_AARCH64_ADR_GOT_PAGE                    R_AARCH64 = 311
+	R_AARCH64_LD64_GOT_LO12_NC                R_AARCH64 = 312
+	R_AARCH64_TLSGD_ADR_PAGE21                R_AARCH64 = 513
+	R_AARCH64_TLSGD_ADD_LO12_NC               R_AARCH64 = 514
+	R_AARCH64_TLSIE_MOVW_GOTTPREL_G1          R_AARCH64 = 539
+	R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC       R_AARCH64 = 540
+	R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21       R_AARCH64 = 541
+	R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC     R_AARCH64 = 542
+	R_AARCH64_TLSIE_LD_GOTTPREL_PREL19        R_AARCH64 = 543
+	R_AARCH64_TLSLE_MOVW_TPREL_G2             R_AARCH64 = 544
+	R_AARCH64_TLSLE_MOVW_TPREL_G1             R_AARCH64 = 545
+	R_AARCH64_TLSLE_MOVW_TPREL_G1_NC          R_AARCH64 = 546
+	R_AARCH64_TLSLE_MOVW_TPREL_G0             R_AARCH64 = 547
+	R_AARCH64_TLSLE_MOVW_TPREL_G0_NC          R_AARCH64 = 548
+	R_AARCH64_TLSLE_ADD_TPREL_HI12            R_AARCH64 = 549
+	R_AARCH64_TLSLE_ADD_TPREL_LO12            R_AARCH64 = 550
+	R_AARCH64_TLSLE_ADD_TPREL_LO12_NC         R_AARCH64 = 551
+	R_AARCH64_TLSDESC_LD_PREL19               R_AARCH64 = 560
+	R_AARCH64_TLSDESC_ADR_PREL21              R_AARCH64 = 561
+	R_AARCH64_TLSDESC_ADR_PAGE21              R_AARCH64 = 562
+	R_AARCH64_TLSDESC_LD64_LO12_NC            R_AARCH64 = 563
+	R_AARCH64_TLSDESC_ADD_LO12_NC             R_AARCH64 = 564
+	R_AARCH64_TLSDESC_OFF_G1                  R_AARCH64 = 565
+	R_AARCH64_TLSDESC_OFF_G0_NC               R_AARCH64 = 566
+	R_AARCH64_TLSDESC_LDR                     R_AARCH64 = 567
+	R_AARCH64_TLSDESC_ADD                     R_AARCH64 = 568
+	R_AARCH64_TLSDESC_CALL                    R_AARCH64 = 569
+	R_AARCH64_COPY                            R_AARCH64 = 1024
+	R_AARCH64_GLOB_DAT                        R_AARCH64 = 1025
+	R_AARCH64_JUMP_SLOT                       R_AARCH64 = 1026
+	R_AARCH64_RELATIVE                        R_AARCH64 = 1027
+	R_AARCH64_TLS_DTPMOD64                    R_AARCH64 = 1028
+	R_AARCH64_TLS_DTPREL64                    R_AARCH64 = 1029
+	R_AARCH64_TLS_TPREL64                     R_AARCH64 = 1030
+	R_AARCH64_TLSDESC                         R_AARCH64 = 1031
+	R_AARCH64_IRELATIVE                       R_AARCH64 = 1032
+)
+
+var raarch64Strings = []intName{
+	{0, "R_AARCH64_NONE"},
+	{1, "R_AARCH64_P32_ABS32"},
+	{2, "R_AARCH64_P32_ABS16"},
+	{3, "R_AARCH64_P32_PREL32"},
+	{4, "R_AARCH64_P32_PREL16"},
+	{5, "R_AARCH64_P32_MOVW_UABS_G0"},
+	{6, "R_AARCH64_P32_MOVW_UABS_G0_NC"},
+	{7, "R_AARCH64_P32_MOVW_UABS_G1"},
+	{8, "R_AARCH64_P32_MOVW_SABS_G0"},
+	{9, "R_AARCH64_P32_LD_PREL_LO19"},
+	{10, "R_AARCH64_P32_ADR_PREL_LO21"},
+	{11, "R_AARCH64_P32_ADR_PREL_PG_HI21"},
+	{12, "R_AARCH64_P32_ADD_ABS_LO12_NC"},
+	{13, "R_AARCH64_P32_LDST8_ABS_LO12_NC"},
+	{14, "R_AARCH64_P32_LDST16_ABS_LO12_NC"},
+	{15, "R_AARCH64_P32_LDST32_ABS_LO12_NC"},
+	{16, "R_AARCH64_P32_LDST64_ABS_LO12_NC"},
+	{17, "R_AARCH64_P32_LDST128_ABS_LO12_NC"},
+	{18, "R_AARCH64_P32_TSTBR14"},
+	{19, "R_AARCH64_P32_CONDBR19"},
+	{20, "R_AARCH64_P32_JUMP26"},
+	{21, "R_AARCH64_P32_CALL26"},
+	{25, "R_AARCH64_P32_GOT_LD_PREL19"},
+	{26, "R_AARCH64_P32_ADR_GOT_PAGE"},
+	{27, "R_AARCH64_P32_LD32_GOT_LO12_NC"},
+	{81, "R_AARCH64_P32_TLSGD_ADR_PAGE21"},
+	{82, "R_AARCH64_P32_TLSGD_ADD_LO12_NC"},
+	{103, "R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21"},
+	{104, "R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC"},
+	{105, "R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19"},
+	{106, "R_AARCH64_P32_TLSLE_MOVW_TPREL_G1"},
+	{107, "R_AARCH64_P32_TLSLE_MOVW_TPREL_G0"},
+	{108, "R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC"},
+	{109, "R_AARCH64_P32_TLSLE_ADD_TPREL_HI12"},
+	{110, "R_AARCH64_P32_TLSLE_ADD_TPREL_LO12"},
+	{111, "R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC"},
+	{122, "R_AARCH64_P32_TLSDESC_LD_PREL19"},
+	{123, "R_AARCH64_P32_TLSDESC_ADR_PREL21"},
+	{124, "R_AARCH64_P32_TLSDESC_ADR_PAGE21"},
+	{125, "R_AARCH64_P32_TLSDESC_LD32_LO12_NC"},
+	{126, "R_AARCH64_P32_TLSDESC_ADD_LO12_NC"},
+	{127, "R_AARCH64_P32_TLSDESC_CALL"},
+	{180, "R_AARCH64_P32_COPY"},
+	{181, "R_AARCH64_P32_GLOB_DAT"},
+	{182, "R_AARCH64_P32_JUMP_SLOT"},
+	{183, "R_AARCH64_P32_RELATIVE"},
+	{184, "R_AARCH64_P32_TLS_DTPMOD"},
+	{185, "R_AARCH64_P32_TLS_DTPREL"},
+	{186, "R_AARCH64_P32_TLS_TPREL"},
+	{187, "R_AARCH64_P32_TLSDESC"},
+	{188, "R_AARCH64_P32_IRELATIVE"},
+	{256, "R_AARCH64_NULL"},
+	{257, "R_AARCH64_ABS64"},
+	{258, "R_AARCH64_ABS32"},
+	{259, "R_AARCH64_ABS16"},
+	{260, "R_AARCH64_PREL64"},
+	{261, "R_AARCH64_PREL32"},
+	{262, "R_AARCH64_PREL16"},
+	{263, "R_AARCH64_MOVW_UABS_G0"},
+	{264, "R_AARCH64_MOVW_UABS_G0_NC"},
+	{265, "R_AARCH64_MOVW_UABS_G1"},
+	{266, "R_AARCH64_MOVW_UABS_G1_NC"},
+	{267, "R_AARCH64_MOVW_UABS_G2"},
+	{268, "R_AARCH64_MOVW_UABS_G2_NC"},
+	{269, "R_AARCH64_MOVW_UABS_G3"},
+	{270, "R_AARCH64_MOVW_SABS_G0"},
+	{271, "R_AARCH64_MOVW_SABS_G1"},
+	{272, "R_AARCH64_MOVW_SABS_G2"},
+	{273, "R_AARCH64_LD_PREL_LO19"},
+	{274, "R_AARCH64_ADR_PREL_LO21"},
+	{275, "R_AARCH64_ADR_PREL_PG_HI21"},
+	{276, "R_AARCH64_ADR_PREL_PG_HI21_NC"},
+	{277, "R_AARCH64_ADD_ABS_LO12_NC"},
+	{278, "R_AARCH64_LDST8_ABS_LO12_NC"},
+	{279, "R_AARCH64_TSTBR14"},
+	{280, "R_AARCH64_CONDBR19"},
+	{282, "R_AARCH64_JUMP26"},
+	{283, "R_AARCH64_CALL26"},
+	{284, "R_AARCH64_LDST16_ABS_LO12_NC"},
+	{285, "R_AARCH64_LDST32_ABS_LO12_NC"},
+	{286, "R_AARCH64_LDST64_ABS_LO12_NC"},
+	{299, "R_AARCH64_LDST128_ABS_LO12_NC"},
+	{309, "R_AARCH64_GOT_LD_PREL19"},
+	{311, "R_AARCH64_ADR_GOT_PAGE"},
+	{312, "R_AARCH64_LD64_GOT_LO12_NC"},
+	{513, "R_AARCH64_TLSGD_ADR_PAGE21"},
+	{514, "R_AARCH64_TLSGD_ADD_LO12_NC"},
+	{539, "R_AARCH64_TLSIE_MOVW_GOTTPREL_G1"},
+	{540, "R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC"},
+	{541, "R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21"},
+	{542, "R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC"},
+	{543, "R_AARCH64_TLSIE_LD_GOTTPREL_PREL19"},
+	{544, "R_AARCH64_TLSLE_MOVW_TPREL_G2"},
+	{545, "R_AARCH64_TLSLE_MOVW_TPREL_G1"},
+	{546, "R_AARCH64_TLSLE_MOVW_TPREL_G1_NC"},
+	{547, "R_AARCH64_TLSLE_MOVW_TPREL_G0"},
+	{548, "R_AARCH64_TLSLE_MOVW_TPREL_G0_NC"},
+	{549, "R_AARCH64_TLSLE_ADD_TPREL_HI12"},
+	{550, "R_AARCH64_TLSLE_ADD_TPREL_LO12"},
+	{551, "R_AARCH64_TLSLE_ADD_TPREL_LO12_NC"},
+	{560, "R_AARCH64_TLSDESC_LD_PREL19"},
+	{561, "R_AARCH64_TLSDESC_ADR_PREL21"},
+	{562, "R_AARCH64_TLSDESC_ADR_PAGE21"},
+	{563, "R_AARCH64_TLSDESC_LD64_LO12_NC"},
+	{564, "R_AARCH64_TLSDESC_ADD_LO12_NC"},
+	{565, "R_AARCH64_TLSDESC_OFF_G1"},
+	{566, "R_AARCH64_TLSDESC_OFF_G0_NC"},
+	{567, "R_AARCH64_TLSDESC_LDR"},
+	{568, "R_AARCH64_TLSDESC_ADD"},
+	{569, "R_AARCH64_TLSDESC_CALL"},
+	{1024, "R_AARCH64_COPY"},
+	{1025, "R_AARCH64_GLOB_DAT"},
+	{1026, "R_AARCH64_JUMP_SLOT"},
+	{1027, "R_AARCH64_RELATIVE"},
+	{1028, "R_AARCH64_TLS_DTPMOD64"},
+	{1029, "R_AARCH64_TLS_DTPREL64"},
+	{1030, "R_AARCH64_TLS_TPREL64"},
+	{1031, "R_AARCH64_TLSDESC"},
+	{1032, "R_AARCH64_IRELATIVE"},
+}
+
+func (i R_AARCH64) String() string   { return stringName(uint32(i), raarch64Strings, false) }
+func (i R_AARCH64) GoString() string { return stringName(uint32(i), raarch64Strings, true) }
+
 // Relocation types for Alpha.
 type R_ALPHA int
 
diff --git a/src/pkg/debug/elf/file.go b/src/pkg/debug/elf/file.go
index 7be9deaa5f..c908e7a889 100644
--- a/src/pkg/debug/elf/file.go
+++ b/src/pkg/debug/elf/file.go
@@ -529,6 +529,9 @@ func (f *File) applyRelocations(dst []byte, rels []byte) error {
 	if f.Class == ELFCLASS32 && f.Machine == EM_386 {
 		return f.applyRelocations386(dst, rels)
 	}
+	if f.Class == ELFCLASS64 && f.Machine == EM_AARCH64 {
+		return f.applyRelocationsARM64(dst, rels)
+	}
 
 	return errors.New("not implemented")
 }
@@ -615,6 +618,51 @@ func (f *File) applyRelocations386(dst []byte, rels []byte) error {
 	return nil
 }
 
+func (f *File) applyRelocationsARM64(dst []byte, rels []byte) error {
+	// 24 is the size of Rela64.
+	if len(rels)%24 != 0 {
+		return errors.New("length of relocation section is not a multiple of 24")
+	}
+
+	symbols, _, err := f.getSymbols(SHT_SYMTAB)
+	if err != nil {
+		return err
+	}
+
+	b := bytes.NewReader(rels)
+	var rela Rela64
+
+	for b.Len() > 0 {
+		binary.Read(b, f.ByteOrder, &rela)
+		symNo := rela.Info >> 32
+		t := R_AARCH64(rela.Info & 0xffff)
+
+		if symNo == 0 || symNo > uint64(len(symbols)) {
+			continue
+		}
+		sym := &symbols[symNo-1]
+		if SymType(sym.Info&0xf) != STT_SECTION {
+			// We don't handle non-section relocations for now.
+			continue
+		}
+
+		switch t {
+		case R_AARCH64_ABS64:
+			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
+				continue
+			}
+			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend))
+		case R_AARCH64_ABS32:
+			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
+				continue
+			}
+			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend))
+		}
+	}
+
+	return nil
+}
+
 func (f *File) DWARF() (*dwarf.Data, error) {
 	// There are many other DWARF sections, but these
 	// are the required ones, and the debug/dwarf package
@@ -637,7 +685,7 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 	// If there's a relocation table for .debug_info, we have to process it
 	// now otherwise the data in .debug_info is invalid for x86-64 objects.
 	rela := f.Section(".rela.debug_info")
-	if rela != nil && rela.Type == SHT_RELA && f.Machine == EM_X86_64 {
+	if rela != nil && rela.Type == SHT_RELA && (f.Machine == EM_X86_64 || f.Machine == EM_AARCH64) {
 		data, err := rela.Data()
 		if err != nil {
 			return nil, err
diff --git a/src/pkg/debug/elf/file_test.go b/src/pkg/debug/elf/file_test.go
index 5e4ad5c100..5e5ba52f39 100644
--- a/src/pkg/debug/elf/file_test.go
+++ b/src/pkg/debug/elf/file_test.go
@@ -260,6 +260,12 @@ var relocationTests = []relocationTest{
 			{0, &dwarf.Entry{Offset: 0xb, Tag: dwarf.TagCompileUnit, Children: true, Field: []dwarf.Field{{Attr: dwarf.AttrProducer, Val: "GNU C 4.2.4 (Ubuntu 4.2.4-1ubuntu4)"}, {Attr: dwarf.AttrLanguage, Val: int64(1)}, {Attr: dwarf.AttrName, Val: "go-relocation-test-gcc424.c"}, {Attr: dwarf.AttrCompDir, Val: "/tmp"}, {Attr: dwarf.AttrLowpc, Val: uint64(0x0)}, {Attr: dwarf.AttrHighpc, Val: uint64(0x6)}, {Attr: dwarf.AttrStmtList, Val: int64(0)}}}},
 		},
 	},
+	{
+		"testdata/go-relocation-test-gcc482-aarch64.obj",
+		[]relocationTestEntry{
+			{0, &dwarf.Entry{Offset: 0xb, Tag: dwarf.TagCompileUnit, Children: true, Field: []dwarf.Field{{Attr: dwarf.AttrProducer, Val: "GNU C 4.8.2 -g -fstack-protector"}, {Attr: dwarf.AttrLanguage, Val: int64(1)}, {Attr: dwarf.AttrName, Val: "go-relocation-test-gcc482.c"}, {Attr: dwarf.AttrCompDir, Val: "/tmp"}, {Attr: dwarf.AttrLowpc, Val: uint64(0x0)}, {Attr: dwarf.AttrHighpc, Val: int64(0x24)}, {Attr: dwarf.AttrStmtList, Val: int64(0)}}}},
+		},
+	},
 	{
 		"testdata/go-relocation-test-clang-x86.obj",
 		[]relocationTestEntry{
diff --git a/src/pkg/debug/elf/testdata/go-relocation-test-gcc482-aarch64.obj b/src/pkg/debug/elf/testdata/go-relocation-test-gcc482-aarch64.obj
new file mode 100644
index 0000000000000000000000000000000000000000..849e2644ec79263a958fcabda5b9e731e3cb1842
GIT binary patch
literal 3392
zcmbtW&5ImW5U>8&&BV#hekGb^iD_`v1TvlM5^xhCS$2sry67PUb5KIhOz+H)neMfx
zCvHCc058FVxFGSOqKKlmfS`$oMLY#^mt6FJ@D`CJR=roX^XAQvgBEmG)vrFg`n}iv
z{+ZR6T*m<+2Y!a0CMduIuO}}laS8UqBy3;b`eECH&94r^-LH%AH<~`dYZI?ex3B;9
z{jc7o-^slZw_53u;GHyU)kyydFP{V`sB!}}=af<3+`=vrT&JLzt2Lj&Q4Nj|^Zb!!
zl7m}N8prvC3{4!Z42~|1sFZO&{}DBn%JJVI_stuuk-^<u2fxrl37kpi+0t~;E6tWB
zovB?DPoZ@Vip5h1VFN5;r~Wvi=cWNhLg)01S2|gIvH1K9#VqZ=wLIgXWpo5Ies0>`
zkGYRfDJlZ$NtHx5>2e2P;Z@`=EYRKgr!)o*5-NB(P*2NQ+)Ara-b|Bn9(VF`y;?oK
zxDZx#^ln`Vl_x)}yFLbYlTNdq#I=BCc=ojm!AfvETnrb2ay=-ob@HfsxxAjGd0frY
z3|eVY5Bfr?jVOa1L}~4)nP^YSc{FdYLzLC4&}pPu-XG1iRoLU2*P)cI)4UevSJz`o
zc?IC?%F4;$(1l7j$-75an@N<Vy8rV0iLOHD4{HEm4?gxIBnR9ZPwzQ6FkzYaaw+(t
z@a5?8*n!nQ|3E(oJ6GFzR6(9+nm0tkaYtbuZ{!fxqCA4I(&<2$rCL$eT3qSYFEx|3
z6n&H&RVrD01>Go^p)5-3F@^T9Rx^nu1nWUqP224lXJ9(5Wl=lUFZci6157|mN$mk6
z*%He#A2InNFrP(kV`RGXgm!pYGnhh7b!5HME+BdiFT#yuhhV6w`{0dyO`@GdIsa??
zJjPPaojrmwQA0DBU@lDh7yT3pc28v6V259r3$uMspkdhjpr|A6aRAMa-jURo`MrXe
zos%LL7<`iygKXco&}L)g{xO5cj93zF-;0P1>;E2YJS2&y{&(YL_y0Cxc20y~i^11P
zG0669p>0_Ghg@IgMD=N;cKvq|qny$wii*Z~L2L=YT<QzIiTJSi`y5Z}(<F%#ehZBv
zn|=>De$fO`mi`5%5Ad+(pBU2~@?7-%<9JED%w-ZWd+$)>F$TXO#UQ&^((S!N?hm-o
zZ4SVXpxR4zeOeR4>fhw^qfE&Rvg;eBK9T%<`0G(0$ci^~;?&2mP6!`1VZzl<Mqh~o
zN*lxjg%9uE8#sM+N^j?FX<hD~+DW4IxF?534^ol`yci5z_c=arzLATkR*K=wq6hfn
zW6?9HPZ{%^WBVcG6PB-1ANR$dtHIm`s9%ZoZr&k($uW(iGpD+jbMLcoS=Y0O)7lo2
z@0*J_tvMk+Ch)&X|0~F(Bv$Z`IA9-h!6VjZnA3lmxgQQ2{(Ph>ME0fR3EA%j!=HLP
z!#aIuh{XT0R(I@zGYqRN2>u@H=Pmp@*5x_G|03fJ%l|g(T?=1g{hEbKy$=|-=kuB6
lzsCBv7Jip?^F7L0LMB-!cK*{GXXCPd=y}amE$hej{}%-U_$L4W

literal 0
HcmV?d00001


From 8ecb9a765e02a8b19d8fad2afa65aee2a068b01a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 23:32:49 -0400
Subject: [PATCH 246/423] runtime: rename Lock to Mutex

Mutex is consistent with package sync, and when in the
unexported Go form it avoids having a conflcit between
the type (now mutex) and the function (lock).

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, r
https://golang.org/cl/133140043
---
 src/pkg/runtime/atomic_arm.c       |  4 ++--
 src/pkg/runtime/cgocall.c          |  2 +-
 src/pkg/runtime/chan.go            | 18 +++++++++---------
 src/pkg/runtime/chan.h             |  2 +-
 src/pkg/runtime/cpuprof.goc        |  2 +-
 src/pkg/runtime/export_test.go     |  4 ++--
 src/pkg/runtime/iface.go           | 10 +++++-----
 src/pkg/runtime/iface.goc          |  2 +-
 src/pkg/runtime/lock_futex.c       |  4 ++--
 src/pkg/runtime/lock_sema.c        |  4 ++--
 src/pkg/runtime/malloc.c           |  2 +-
 src/pkg/runtime/malloc.go          |  4 ++--
 src/pkg/runtime/malloc.h           | 12 ++++++------
 src/pkg/runtime/mem_plan9.c        |  2 +-
 src/pkg/runtime/mgc0.c             |  6 +++---
 src/pkg/runtime/mprof.go           | 10 +++++-----
 src/pkg/runtime/mprof.goc          |  4 ++--
 src/pkg/runtime/netpoll.goc        |  6 +++---
 src/pkg/runtime/os_windows.c       |  2 +-
 src/pkg/runtime/panic.c            |  4 ++--
 src/pkg/runtime/print.c            |  2 +-
 src/pkg/runtime/proc.c             | 12 ++++++------
 src/pkg/runtime/proc.go            |  2 +-
 src/pkg/runtime/runtime.c          |  2 +-
 src/pkg/runtime/runtime.h          | 16 ++++++++--------
 src/pkg/runtime/sema.go            | 22 +++++++++++-----------
 src/pkg/runtime/stack.c            |  2 +-
 src/pkg/runtime/stubs.go           |  5 ++---
 src/pkg/runtime/stubs.goc          |  9 ---------
 src/pkg/runtime/syscall_windows.go |  4 ++--
 src/pkg/runtime/time.go            | 22 +++++++++++-----------
 31 files changed, 96 insertions(+), 106 deletions(-)

diff --git a/src/pkg/runtime/atomic_arm.c b/src/pkg/runtime/atomic_arm.c
index 0cb823bb48..c15108e9a0 100644
--- a/src/pkg/runtime/atomic_arm.c
+++ b/src/pkg/runtime/atomic_arm.c
@@ -7,8 +7,8 @@
 #include "../../cmd/ld/textflag.h"
 
 static struct {
-	Lock l;
-	byte pad[CacheLineSize-sizeof(Lock)];
+	Mutex l;
+	byte pad[CacheLineSize-sizeof(Mutex)];
 } locktab[57];
 
 #define LOCK(addr) (&locktab[((uintptr)(addr)>>3)%nelem(locktab)].l)
diff --git a/src/pkg/runtime/cgocall.c b/src/pkg/runtime/cgocall.c
index aa4cf5ee52..145ac7dc19 100644
--- a/src/pkg/runtime/cgocall.c
+++ b/src/pkg/runtime/cgocall.c
@@ -115,7 +115,7 @@ runtime·cgocall(void (*fn)(void*), void *arg)
 	g->m->ncgocall++;
 
 	/*
-	 * Lock g to m to ensure we stay on the same stack if we do a
+	 * Mutex g to m to ensure we stay on the same stack if we do a
 	 * cgo callback. Add entry to defer stack in case of panic.
 	 */
 	runtime·lockOSThread();
diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index e2d5bc180e..fe7e72edc2 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -130,9 +130,9 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		t0 = cputicks()
 	}
 
-	golock(&c.lock)
+	lock(&c.lock)
 	if c.closed != 0 {
-		gounlock(&c.lock)
+		unlock(&c.lock)
 		panic("send on closed channel")
 	}
 
@@ -142,7 +142,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 			if raceenabled {
 				racesync(c, sg)
 			}
-			gounlock(&c.lock)
+			unlock(&c.lock)
 
 			recvg := sg.g
 			recvg.param = unsafe.Pointer(sg)
@@ -162,7 +162,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		}
 
 		if !block {
-			gounlock(&c.lock)
+			unlock(&c.lock)
 			return false
 		}
 
@@ -204,7 +204,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 	var t1 int64
 	for c.qcount >= c.dataqsiz {
 		if !block {
-			gounlock(&c.lock)
+			unlock(&c.lock)
 			return false
 		}
 		gp := getg()
@@ -223,9 +223,9 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 			t1 = int64(mysg.releasetime)
 		}
 		releaseSudog(mysg)
-		golock(&c.lock)
+		lock(&c.lock)
 		if c.closed != 0 {
-			gounlock(&c.lock)
+			unlock(&c.lock)
 			panic("send on closed channel")
 		}
 	}
@@ -246,13 +246,13 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 	sg := c.recvq.dequeue()
 	if sg != nil {
 		recvg := sg.g
-		gounlock(&c.lock)
+		unlock(&c.lock)
 		if sg.releasetime != 0 {
 			*(*int64)(unsafe.Pointer(&sg.releasetime)) = cputicks()
 		}
 		goready(recvg)
 	} else {
-		gounlock(&c.lock)
+		unlock(&c.lock)
 	}
 	if t1 > 0 {
 		blockevent(t1-t0, 2)
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index 52eb20099d..a439fa7c9a 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -26,7 +26,7 @@ struct	Hchan
 	uintgo	recvx;			// receive index
 	WaitQ	recvq;			// list of recv waiters
 	WaitQ	sendq;			// list of send waiters
-	Lock	lock;
+	Mutex	lock;
 };
 
 // Buffer follows Hchan immediately in memory.
diff --git a/src/pkg/runtime/cpuprof.goc b/src/pkg/runtime/cpuprof.goc
index cd4b210e23..8ae06edcb1 100644
--- a/src/pkg/runtime/cpuprof.goc
+++ b/src/pkg/runtime/cpuprof.goc
@@ -102,7 +102,7 @@ struct Profile {
 	bool eod_sent;  // special end-of-data record sent; => flushing
 };
 
-static Lock lk;
+static Mutex lk;
 static Profile *prof;
 
 static void tick(uintptr*, int32);
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index df6f11d671..3068fa34ba 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -19,12 +19,12 @@ var Fintto64 = fintto64
 var F64toint = f64toint
 
 func entersyscall()
-func golockedOSThread() bool
+func lockedOSThread() bool
 func stackguard() (sp, limit uintptr)
 
 var Entersyscall = entersyscall
 var Exitsyscall = exitsyscall
-var LockedOSThread = golockedOSThread
+var LockedOSThread = lockedOSThread
 var Stackguard = stackguard
 
 type LFNode struct {
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index 1421efe3ce..a317628403 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -13,7 +13,7 @@ const (
 )
 
 var (
-	ifaceLock lock // lock for accessing hash
+	ifaceLock mutex // lock for accessing hash
 	hash      [hashSize]*itab
 )
 
@@ -51,7 +51,7 @@ func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
 	var locked int
 	for locked = 0; locked < 2; locked++ {
 		if locked != 0 {
-			golock(&ifaceLock)
+			lock(&ifaceLock)
 		}
 		for m = (*itab)(atomicloadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
 			if m.inter == inter && m._type == typ {
@@ -69,7 +69,7 @@ func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
 					}
 				}
 				if locked != 0 {
-					gounlock(&ifaceLock)
+					unlock(&ifaceLock)
 				}
 				return m
 			}
@@ -106,7 +106,7 @@ search:
 		// didn't find method
 		if !canfail {
 			if locked != 0 {
-				gounlock(&ifaceLock)
+				unlock(&ifaceLock)
 			}
 			panic(&TypeAssertionError{"", *typ._string, *inter.typ._string, *iname})
 		}
@@ -119,7 +119,7 @@ search:
 	}
 	m.link = hash[h]
 	atomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))
-	gounlock(&ifaceLock)
+	unlock(&ifaceLock)
 	if m.bad != 0 {
 		return nil
 	}
diff --git a/src/pkg/runtime/iface.goc b/src/pkg/runtime/iface.goc
index 2ac7405905..440d272382 100644
--- a/src/pkg/runtime/iface.goc
+++ b/src/pkg/runtime/iface.goc
@@ -11,7 +11,7 @@ package runtime
 #include "../../cmd/ld/textflag.h"
 
 extern	Itab*	runtime·hash[1009];
-extern	Lock	runtime·ifaceLock;
+extern	Mutex	runtime·ifaceLock;
 
 // TODO: delete this when no longer used (ifaceE2I2 is all that's left)
 static Itab*
diff --git a/src/pkg/runtime/lock_futex.c b/src/pkg/runtime/lock_futex.c
index 27a866a731..a0fe102cc2 100644
--- a/src/pkg/runtime/lock_futex.c
+++ b/src/pkg/runtime/lock_futex.c
@@ -35,7 +35,7 @@ enum
 // Note that there can be spinning threads during all states - they do not
 // affect mutex's state.
 void
-runtime·lock(Lock *l)
+runtime·lock(Mutex *l)
 {
 	uint32 i, v, wait, spin;
 
@@ -89,7 +89,7 @@ runtime·lock(Lock *l)
 }
 
 void
-runtime·unlock(Lock *l)
+runtime·unlock(Mutex *l)
 {
 	uint32 v;
 
diff --git a/src/pkg/runtime/lock_sema.c b/src/pkg/runtime/lock_sema.c
index 98eea91d5f..71283493ed 100644
--- a/src/pkg/runtime/lock_sema.c
+++ b/src/pkg/runtime/lock_sema.c
@@ -34,7 +34,7 @@ enum
 };
 
 void
-runtime·lock(Lock *l)
+runtime·lock(Mutex *l)
 {
 	uintptr v;
 	uint32 i, spin;
@@ -90,7 +90,7 @@ unlocked:
 }
 
 void
-runtime·unlock(Lock *l)
+runtime·unlock(Mutex *l)
 {
 	uintptr v;
 	M *mp;
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 913d8ac26b..8eeebe4692 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -350,7 +350,7 @@ runtime·MHeap_SysAlloc(MHeap *h, uintptr n)
 
 static struct
 {
-	Lock	lock;
+	Mutex	lock;
 	byte*	pos;
 	byte*	end;
 } persistent;
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index fb2c037ace..ebc45fa2f7 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -422,11 +422,11 @@ func gogc(force int32) {
 		return
 	}
 	if gcpercent == gcpercentUnknown {
-		golock(&mheap_.lock)
+		lock(&mheap_.lock)
 		if gcpercent == gcpercentUnknown {
 			gcpercent = readgogc()
 		}
-		gounlock(&mheap_.lock)
+		unlock(&mheap_.lock)
 	}
 	if gcpercent < 0 {
 		return
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 7a6d0c71d9..0d7cd475d8 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -242,7 +242,7 @@ struct MStats
 	uint64	nfree;  // number of frees
 
 	// Statistics about malloc heap.
-	// protected by mheap.Lock
+	// protected by mheap.lock
 	uint64	heap_alloc;	// bytes allocated and still in use
 	uint64	heap_sys;	// bytes obtained from system
 	uint64	heap_idle;	// bytes in idle spans
@@ -421,7 +421,7 @@ struct MSpan
 	int64   unusedsince;	// First time spotted by GC in MSpanFree state
 	uintptr npreleased;	// number of pages released to the OS
 	byte	*limit;		// end of data in span
-	Lock	specialLock;	// guards specials list
+	Mutex	specialLock;	// guards specials list
 	Special	*specials;	// linked list of special records sorted by offset.
 };
 
@@ -442,7 +442,7 @@ void	runtime·MSpanList_Remove(MSpan *span);	// from whatever list it is in
 // Central list of free objects of a given size.
 struct MCentral
 {
-	Lock  lock;
+	Mutex  lock;
 	int32 sizeclass;
 	MSpan nonempty;	// list of spans with a free object
 	MSpan empty;	// list of spans with no free objects (or cached in an MCache)
@@ -458,7 +458,7 @@ bool	runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, ML
 // but all the other global data is here too.
 struct MHeap
 {
-	Lock  lock;
+	Mutex  lock;
 	MSpan free[MaxMHeapList];	// free lists of given length
 	MSpan freelarge;		// free lists length >= MaxMHeapList
 	MSpan busy[MaxMHeapList];	// busy lists of large objects of given length
@@ -484,7 +484,7 @@ struct MHeap
 
 	// central free lists for small size classes.
 	// the padding makes sure that the MCentrals are
-	// spaced CacheLineSize bytes apart, so that each MCentral.Lock
+	// spaced CacheLineSize bytes apart, so that each MCentral.lock
 	// gets its own cache line.
 	struct {
 		MCentral mcentral;
@@ -495,7 +495,7 @@ struct MHeap
 	FixAlloc cachealloc;	// allocator for MCache*
 	FixAlloc specialfinalizeralloc;	// allocator for SpecialFinalizer*
 	FixAlloc specialprofilealloc;	// allocator for SpecialProfile*
-	Lock speciallock; // lock for sepcial record allocators.
+	Mutex speciallock; // lock for sepcial record allocators.
 
 	// Malloc stats.
 	uint64 largefree;	// bytes freed for large objects (>MaxSmallSize)
diff --git a/src/pkg/runtime/mem_plan9.c b/src/pkg/runtime/mem_plan9.c
index 249c6f2255..8d31bcfe2d 100644
--- a/src/pkg/runtime/mem_plan9.c
+++ b/src/pkg/runtime/mem_plan9.c
@@ -10,7 +10,7 @@
 
 extern byte runtime·end[];
 static byte *bloc = { runtime·end };
-static Lock memlock;
+static Mutex memlock;
 
 enum
 {
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index d70a6373e3..12d45d4baf 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -166,7 +166,7 @@ extern byte runtime·ebss[];
 extern byte runtime·gcdata[];
 extern byte runtime·gcbss[];
 
-static Lock	finlock;	// protects the following variables
+static Mutex	finlock;	// protects the following variables
 static FinBlock	*finq;		// list of finalizers that are to be executed
 static FinBlock	*finc;		// cache of free blocks
 static FinBlock	*allfin;	// list of all blocks
@@ -175,7 +175,7 @@ bool	runtime·fingwake;
 BitVector	runtime·gcdatamask;
 BitVector	runtime·gcbssmask;
 
-static Lock	gclock;
+static Mutex	gclock;
 
 static void	runfinq(void);
 static void	bgsweep(void);
@@ -1892,7 +1892,7 @@ runtime·unrollgcproginplace_m(void)
 void
 runtime·unrollgcprog_m(void)
 {
-	static Lock lock;
+	static Mutex lock;
 	Type *typ;
 	byte *mask, *prog;
 	uintptr pos;
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index d20bf2371c..9ee37d0bee 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -12,7 +12,7 @@ import (
 // Patterned after tcmalloc's algorithms; shorter code.
 
 // NOTE(rsc): Everything here could use cas if contention became an issue.
-var proflock lock
+var proflock mutex
 
 // All memory allocations are local and do not escape outside of the profiler.
 // The profiler is forbidden from referring to garbage-collected memory.
@@ -35,7 +35,7 @@ var (
 // the testing package's -test.memprofile flag instead
 // of calling MemProfile directly.
 func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
-	golock(&proflock)
+	lock(&proflock)
 	clear := true
 	for b := mbuckets; b != nil; b = b.allnext {
 		if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
@@ -69,7 +69,7 @@ func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
 			}
 		}
 	}
-	gounlock(&proflock)
+	unlock(&proflock)
 	return
 }
 
@@ -114,7 +114,7 @@ func record(r *MemProfileRecord, b *bucket) {
 // the testing package's -test.blockprofile flag instead
 // of calling BlockProfile directly.
 func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
-	golock(&proflock)
+	lock(&proflock)
 	for b := bbuckets; b != nil; b = b.allnext {
 		n++
 	}
@@ -137,7 +137,7 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 			idx++
 		}
 	}
-	gounlock(&proflock)
+	unlock(&proflock)
 	return
 }
 
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index f76aae48c8..a340ebdafb 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -14,7 +14,7 @@ package runtime
 #include "type.h"
 
 // NOTE(rsc): Everything here could use cas if contention became an issue.
-extern Lock runtime·proflock;
+extern Mutex runtime·proflock;
 
 // All memory allocations are local and do not escape outside of the profiler.
 // The profiler is forbidden from referring to garbage-collected memory.
@@ -296,7 +296,7 @@ func GoroutineProfile(b Slice) (n int, ok bool) {
 
 // Tracing of alloc/free/gc.
 
-static Lock tracelock;
+static Mutex tracelock;
 
 void
 runtime·tracealloc(void *p, uintptr size, Type *type)
diff --git a/src/pkg/runtime/netpoll.goc b/src/pkg/runtime/netpoll.goc
index 46e0dfb330..446e78eb01 100644
--- a/src/pkg/runtime/netpoll.goc
+++ b/src/pkg/runtime/netpoll.goc
@@ -56,14 +56,14 @@ void	runtime·deltimer(Timer*);
 
 struct PollDesc
 {
-	PollDesc* link;	// in pollcache, protected by pollcache.Lock
+	PollDesc* link;	// in pollcache, protected by pollcache.lock
 
 	// The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations.
 	// This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime.
 	// pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO rediness notification)
 	// proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
 	// in a lock-free way by all operations.
-	Lock	lock;		// protectes the following fields
+	Mutex	lock;		// protects the following fields
 	uintptr	fd;
 	bool	closing;
 	uintptr	seq;	// protects from stale timers and ready notifications
@@ -78,7 +78,7 @@ struct PollDesc
 
 static struct
 {
-	Lock		lock;
+	Mutex		lock;
 	PollDesc*	first;
 	// PollDesc objects must be type-stable,
 	// because we can get ready notification from epoll/kqueue
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 79dc2960f9..aadc30a076 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -485,7 +485,7 @@ runtime·profileloop1(void)
 void
 runtime·resetcpuprofiler(int32 hz)
 {
-	static Lock lock;
+	static Mutex lock;
 	void *timer, *thread;
 	int32 ms;
 	int64 due;
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index dc3d2e93bf..00c780bf55 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -11,7 +11,7 @@
 // Code related to defer, panic and recover.
 
 uint32 runtime·panicking;
-static Lock paniclk;
+static Mutex paniclk;
 
 // Each P holds pool for defers with arg sizes 8, 24, 40, 56 and 72 bytes.
 // Memory block is 40 (24 for 32 bits) bytes larger due to Defer header.
@@ -448,7 +448,7 @@ runtime·dopanic(int32 unused)
 		// Let it print what it needs to print.
 		// Wait forever without chewing up cpu.
 		// It will exit when it's done.
-		static Lock deadlock;
+		static Mutex deadlock;
 		runtime·lock(&deadlock);
 		runtime·lock(&deadlock);
 	}
diff --git a/src/pkg/runtime/print.c b/src/pkg/runtime/print.c
index e2905c2db3..57dfdabb6d 100644
--- a/src/pkg/runtime/print.c
+++ b/src/pkg/runtime/print.c
@@ -6,7 +6,7 @@
 #include "type.h"
 #include "../../cmd/ld/textflag.h"
 
-//static Lock debuglock;
+//static Mutex debuglock;
 
 static void vprintf(int8*, byte*);
 
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index a692dfd2cf..8263202e93 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -26,7 +26,7 @@
 
 typedef struct Sched Sched;
 struct Sched {
-	Lock	lock;
+	Mutex	lock;
 
 	uint64	goidgen;
 
@@ -46,7 +46,7 @@ struct Sched {
 	int32	runqsize;
 
 	// Global cache of dead G's.
-	Lock	gflock;
+	Mutex	gflock;
 	G*	gfree;
 	int32	ngfree;
 
@@ -84,7 +84,7 @@ int8*	runtime·goos;
 int32	runtime·ncpu;
 static int32	newprocs;
 
-static	Lock allglock;	// the following vars are protected by this lock or by stoptheworld
+static	Mutex allglock;	// the following vars are protected by this lock or by stoptheworld
 G**	runtime·allg;
 uintptr runtime·allglen;
 static	uintptr allgcap;
@@ -133,7 +133,7 @@ static void allgadd(G*);
 static void forcegchelper(void);
 static struct
 {
-	Lock	lock;
+	Mutex	lock;
 	G*	g;
 	FuncVal	fv;
 	uint32	idle;
@@ -1570,7 +1570,7 @@ runtime·parkunlock_c(G *gp, void *lock)
 // Puts the current goroutine into a waiting state and unlocks the lock.
 // The goroutine can be made runnable again by calling runtime·ready(gp).
 void
-runtime·parkunlock(Lock *lock, String reason)
+runtime·parkunlock(Mutex *lock, String reason)
 {
 	runtime·park(runtime·parkunlock_c, lock, reason);
 }
@@ -2399,7 +2399,7 @@ runtime·badreflectcall(void) // called from assembly
 }
 
 static struct {
-	Lock lock;
+	Mutex lock;
 	void (*fn)(uintptr*, int32);
 	int32 hz;
 } prof;
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index a201dc6c51..68bad029de 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -59,7 +59,7 @@ func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
 
 // Puts the current goroutine into a waiting state and unlocks the lock.
 // The goroutine can be made runnable again by calling goready(gp).
-func goparkunlock(lock *lock, reason string) {
+func goparkunlock(lock *mutex, reason string) {
 	gopark(unsafe.Pointer(&parkunlock_c), unsafe.Pointer(lock), reason)
 }
 
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index b1960088da..4f6381297d 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -272,7 +272,7 @@ runtime·fastrand1(void)
 	return x;
 }
 
-static Lock ticksLock;
+static Mutex ticksLock;
 static int64 ticks;
 
 int64
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index bb9d108551..72f446f379 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -57,7 +57,7 @@ typedef	struct	Func		Func;
 typedef	struct	G		G;
 typedef	struct	Gobuf		Gobuf;
 typedef	struct	SudoG		SudoG;
-typedef	struct	Lock		Lock;
+typedef	struct	Mutex		Mutex;
 typedef	struct	M		M;
 typedef	struct	P		P;
 typedef	struct	Note		Note;
@@ -160,7 +160,7 @@ enum
 /*
  * structures
  */
-struct	Lock
+struct	Mutex
 {
 	// Futex-based impl treats it as uint32 key,
 	// while sema-based impl as M* waitm.
@@ -394,7 +394,7 @@ struct	M
 
 struct P
 {
-	Lock	lock;
+	Mutex	lock;
 
 	int32	id;
 	uint32	status;		// one of Pidle/Prunning/...
@@ -915,7 +915,7 @@ void	runtime·gosched(void);
 void	runtime·gosched_m(G*);
 void	runtime·schedtrace(bool);
 void	runtime·park(bool(*)(G*, void*), void*, String);
-void	runtime·parkunlock(Lock*, String);
+void	runtime·parkunlock(Mutex*, String);
 void	runtime·tsleep(int64, String);
 M*	runtime·newm(void);
 void	runtime·goexit(void);
@@ -986,10 +986,10 @@ extern uint32 runtime·worldsema;
  * mutual exclusion locks.  in the uncontended case,
  * as fast as spin locks (just a few user-level instructions),
  * but on the contention path they sleep in the kernel.
- * a zeroed Lock is unlocked (no need to initialize each lock).
+ * a zeroed Mutex is unlocked (no need to initialize each lock).
  */
-void	runtime·lock(Lock*);
-void	runtime·unlock(Lock*);
+void	runtime·lock(Mutex*);
+void	runtime·unlock(Mutex*);
 
 /*
  * sleep and wakeup on one-time events.
@@ -1030,7 +1030,7 @@ void	runtime·futexsleep(uint32*, uint32, int64);
 void	runtime·futexwakeup(uint32*, uint32);
 
 /*
- * Lock-free stack.
+ * Mutex-free stack.
  * Initialize uint64 head to 0, compare with 0 to test for emptiness.
  * The stack does not keep pointers to nodes,
  * so they can be garbage collected if there are no other pointers to nodes.
diff --git a/src/pkg/runtime/sema.go b/src/pkg/runtime/sema.go
index 4674a843ee..87ba5463b6 100644
--- a/src/pkg/runtime/sema.go
+++ b/src/pkg/runtime/sema.go
@@ -24,7 +24,7 @@ import "unsafe"
 // Asynchronous semaphore for sync.Mutex.
 
 type semaRoot struct {
-	lock
+	lock  mutex
 	head  *sudog
 	tail  *sudog
 	nwait uint32 // Number of waiters. Read w/o the lock.
@@ -69,13 +69,13 @@ func semacquire(addr *uint32, profile bool) {
 		s.releasetime = -1
 	}
 	for {
-		golock(&root.lock)
+		lock(&root.lock)
 		// Add ourselves to nwait to disable "easy case" in semrelease.
 		xadd(&root.nwait, 1)
 		// Check cansemacquire to avoid missed wakeup.
 		if cansemacquire(addr) {
 			xadd(&root.nwait, -1)
-			gounlock(&root.lock)
+			unlock(&root.lock)
 			break
 		}
 		// Any semrelease after the cansemacquire knows we're waiting
@@ -104,11 +104,11 @@ func semrelease(addr *uint32) {
 	}
 
 	// Harder case: search for a waiter and wake it.
-	golock(&root.lock)
+	lock(&root.lock)
 	if atomicload(&root.nwait) == 0 {
 		// The count is already consumed by another goroutine,
 		// so no need to wake up another goroutine.
-		gounlock(&root.lock)
+		unlock(&root.lock)
 		return
 	}
 	s := root.head
@@ -119,7 +119,7 @@ func semrelease(addr *uint32) {
 			break
 		}
 	}
-	gounlock(&root.lock)
+	unlock(&root.lock)
 	if s != nil {
 		if s.releasetime != 0 {
 			s.releasetime = cputicks()
@@ -174,14 +174,14 @@ func (root *semaRoot) dequeue(s *sudog) {
 
 // Synchronous semaphore for sync.Cond.
 type syncSema struct {
-	lock lock
+	lock mutex
 	head *sudog
 	tail *sudog
 }
 
 // Syncsemacquire waits for a pairing syncsemrelease on the same semaphore s.
 func syncsemacquire(s *syncSema) {
-	golock(&s.lock)
+	lock(&s.lock)
 	if s.head != nil && s.head.nrelease > 0 {
 		// Have pending release, consume it.
 		var wake *sudog
@@ -193,7 +193,7 @@ func syncsemacquire(s *syncSema) {
 				s.tail = nil
 			}
 		}
-		gounlock(&s.lock)
+		unlock(&s.lock)
 		if wake != nil {
 			goready(wake.g)
 		}
@@ -225,7 +225,7 @@ func syncsemacquire(s *syncSema) {
 
 // Syncsemrelease waits for n pairing syncsemacquire on the same semaphore s.
 func syncsemrelease(s *syncSema, n uint32) {
-	golock(&s.lock)
+	lock(&s.lock)
 	for n > 0 && s.head != nil && s.head.nrelease < 0 {
 		// Have pending acquire, satisfy it.
 		wake := s.head
@@ -254,7 +254,7 @@ func syncsemrelease(s *syncSema, n uint32) {
 		s.tail = w
 		goparkunlock(&s.lock, "semarelease")
 	} else {
-		gounlock(&s.lock)
+		unlock(&s.lock)
 	}
 }
 
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 0ce869f442..96f1946db2 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -32,7 +32,7 @@ enum
 //     order = log_2(size/FixedStack)
 // There is a free list for each order.
 static MSpan stackpool[NumStackOrders];
-static Lock stackpoolmu;
+static Mutex stackpoolmu;
 // TODO: one lock per order?
 
 void
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 1f3cc16e62..793cc3acb7 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -132,9 +132,6 @@ var noequalcode uintptr
 // in panic.c
 func gothrow(s string)
 
-func golock(x *lock)
-func gounlock(x *lock)
-
 // Return the Go equivalent of the C Alg structure.
 // TODO: at some point Go will hold the truth for the layout
 // of runtime structures and C will be derived from it (if
@@ -201,6 +198,8 @@ func notetsleep(n *note, ns int64)
 func notewakeup(n *note)
 func notesleep(n *note)
 func noteclear(n *note)
+func lock(lk *mutex)
+func unlock(lk *mutex)
 
 //go:noescape
 func cas(ptr *uint32, old, new uint32) bool
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index ebf9cc1053..af2b155642 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -23,15 +23,6 @@ package runtime
 // These invariants do not hold yet but will be established once we have
 // finished converting runtime support code from C to Go.
 
-#pragma textflag NOSPLIT
-func golock(p *Lock) {
-	runtime·lock(p);
-}
-#pragma textflag NOSPLIT
-func gounlock(p *Lock) {
-	runtime·unlock(p);
-}
-
 // entry point for testing
 // TODO: mcall and run on M stack
 func gostringW(str Slice) (s String) {
diff --git a/src/pkg/runtime/syscall_windows.go b/src/pkg/runtime/syscall_windows.go
index 5ca9735ac6..39d8fed1d4 100644
--- a/src/pkg/runtime/syscall_windows.go
+++ b/src/pkg/runtime/syscall_windows.go
@@ -59,8 +59,8 @@ func compileCallback(fn eface, cleanstack bool) (code uintptr) {
 		argsize += uintptrSize
 	}
 
-	golock(&cbs.lock)
-	defer gounlock(&cbs.lock)
+	lock(&cbs.lock)
+	defer unlock(&cbs.lock)
 
 	n := cbs.n
 	for i := 0; i < n; i++ {
diff --git a/src/pkg/runtime/time.go b/src/pkg/runtime/time.go
index b40952ebc2..102539bf21 100644
--- a/src/pkg/runtime/time.go
+++ b/src/pkg/runtime/time.go
@@ -25,7 +25,7 @@ type timer struct {
 }
 
 var timers struct {
-	lock         lock
+	lock         mutex
 	gp           *g
 	created      bool
 	sleeping     bool
@@ -52,7 +52,7 @@ func timeSleep(ns int64) {
 	t.when = nanotime() + ns
 	t.f = goroutineReady
 	t.arg = getg()
-	golock(&timers.lock)
+	lock(&timers.lock)
 	addtimerLocked(t)
 	goparkunlock(&timers.lock, "sleep")
 }
@@ -79,9 +79,9 @@ func goroutineReady(arg interface{}) {
 }
 
 func addtimer(t *timer) {
-	golock(&timers.lock)
+	lock(&timers.lock)
 	addtimerLocked(t)
-	gounlock(&timers.lock)
+	unlock(&timers.lock)
 }
 
 // Add a timer to the heap and start or kick the timer proc.
@@ -120,14 +120,14 @@ func deltimer(t *timer) bool {
 	// Discard result, because t might be moving in the heap.
 	_ = t.i
 
-	golock(&timers.lock)
+	lock(&timers.lock)
 	// t may not be registered anymore and may have
 	// a bogus i (typically 0, if generated by Go).
 	// Verify it before proceeding.
 	i := t.i
 	last := len(timers.t) - 1
 	if i < 0 || i > last || timers.t[i] != t {
-		gounlock(&timers.lock)
+		unlock(&timers.lock)
 		return false
 	}
 	if i != last {
@@ -140,7 +140,7 @@ func deltimer(t *timer) bool {
 		siftupTimer(i)
 		siftdownTimer(i)
 	}
-	gounlock(&timers.lock)
+	unlock(&timers.lock)
 	return true
 }
 
@@ -151,7 +151,7 @@ func timerproc() {
 	timers.gp = getg()
 	timers.gp.issystem = true
 	for {
-		golock(&timers.lock)
+		lock(&timers.lock)
 		timers.sleeping = false
 		now := nanotime()
 		delta := int64(-1)
@@ -185,12 +185,12 @@ func timerproc() {
 			}
 			f := t.f
 			arg := t.arg
-			gounlock(&timers.lock)
+			unlock(&timers.lock)
 			if raceenabled {
 				raceacquire(unsafe.Pointer(t))
 			}
 			f(arg)
-			golock(&timers.lock)
+			lock(&timers.lock)
 		}
 		if delta < 0 {
 			// No timers left - put goroutine to sleep.
@@ -201,7 +201,7 @@ func timerproc() {
 		// At least one timer pending.  Sleep until then.
 		timers.sleeping = true
 		noteclear(&timers.waitnote)
-		gounlock(&timers.lock)
+		unlock(&timers.lock)
 		notetsleepg(&timers.waitnote, delta)
 	}
 }

From fee7c69c6c091d93c8c709ed562a477fd199bb3b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 23:41:10 -0400
Subject: [PATCH 247/423] =?UTF-8?q?cmd/api:=20fix=20for=20Lock=E2=87=92Mut?=
 =?UTF-8?q?ex=20change?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

TBR=iant
CC=golang-codereviews
https://golang.org/cl/133150043
---
 src/cmd/api/goapi.go               | 2 +-
 src/pkg/runtime/syscall_windows.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index c3ab9c5bcf..56ba74a506 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -380,7 +380,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		// Just enough to keep the api checker happy.
 		src := "package runtime; type (" +
 			" maptype struct{}; _type struct{}; alg struct{};" +
-			" mspan struct{}; m struct{}; lock struct{}; slicetype struct{};" +
+			" mspan struct{}; m struct{}; mutex struct{}; slicetype struct{};" +
 			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
 			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
 			" hchan struct{}; chantype struct{}; waitq struct{};" +
diff --git a/src/pkg/runtime/syscall_windows.go b/src/pkg/runtime/syscall_windows.go
index 39d8fed1d4..0592c57e1d 100644
--- a/src/pkg/runtime/syscall_windows.go
+++ b/src/pkg/runtime/syscall_windows.go
@@ -9,7 +9,7 @@ import (
 )
 
 type callbacks struct {
-	lock
+	lock mutex
 	ctxt [cb_max]*wincallbackcontext
 	n    int
 }

From 948bb9150e962ee77475d2abc6585ecc7ac7f755 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 23:41:27 -0400
Subject: [PATCH 248/423] cmd/cc: translate C Eface type as Go interface{}

This will allow structs containing Efaces in C to be
manipulated as structs containing real interfaces in Go.
The eface struct is still defined for use by Go code.

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/133980044
---
 src/cmd/cc/godefs.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cmd/cc/godefs.c b/src/cmd/cc/godefs.c
index edb8a5e287..20915ca8ca 100644
--- a/src/cmd/cc/godefs.c
+++ b/src/cmd/cc/godefs.c
@@ -218,11 +218,13 @@ printtypename(Type *t)
 			n = s->name;
 		else if(t->tag)
 			n = t->tag->name;
-		if(strcmp(n, "String") == 0){
+		if(strcmp(n, "String") == 0)
 			Bprint(&outbuf, "string");
-		} else if(strcmp(n, "Slice") == 0){
+		else if(strcmp(n, "Slice") == 0)
 			Bprint(&outbuf, "[]byte");
-		} else
+		else if(strcmp(n, "Eface") == 0)
+			Bprint(&outbuf, "interface{}");
+		else
 			Bprint(&outbuf, "%U", n);
 		break;
 	case TFUNC:

From add7b220105ab2734244400aa0585fc80f40001c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 27 Aug 2014 23:41:43 -0400
Subject: [PATCH 249/423] runtime: fix nacl/386 build

I changed all the NACL_SYSJMP to NACL_SYSCALL in
an earlier CL, but I missed the fact that NACL_SYSCALL
will push another return PC on the stack, so that the
arguments will no longer be in the right place.
Since we have to make our own call, we also have to
copy the arguments. Do that.

Fixes nacl/386 build.

TBR=minux
CC=golang-codereviews
https://golang.org/cl/135050044
---
 src/pkg/runtime/sys_nacl_386.s | 124 +++++++++++++++++++++++++++------
 1 file changed, 101 insertions(+), 23 deletions(-)

diff --git a/src/pkg/runtime/sys_nacl_386.s b/src/pkg/runtime/sys_nacl_386.s
index 56fbd618bf..5798b1aede 100644
--- a/src/pkg/runtime/sys_nacl_386.s
+++ b/src/pkg/runtime/sys_nacl_386.s
@@ -9,25 +9,43 @@
 #define NACL_SYSCALL(code) \
 	MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
 
-TEXT runtime·exit(SB),NOSPLIT,$0
+TEXT runtime·exit(SB),NOSPLIT,$4
+	MOVL code+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_exit)
 	JMP 0(PC)
 
-TEXT runtime·exit1(SB),NOSPLIT,$0
+TEXT runtime·exit1(SB),NOSPLIT,$4
+	MOVL code+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_thread_exit)
 	RET
 
-TEXT runtime·open(SB),NOSPLIT,$0
+TEXT runtime·open(SB),NOSPLIT,$12
+	MOVL name+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL mode+4(FP), AX
+	MOVL AX, 4(SP)
+	MOVL perm+8(FP), AX
+	MOVL AX, 8(SP)
 	NACL_SYSCALL(SYS_open)
 	MOVL AX, ret+12(FP)
 	RET
 
-TEXT runtime·close(SB),NOSPLIT,$0
+TEXT runtime·close(SB),NOSPLIT,$4
+	MOVL fd+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_close)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·read(SB),NOSPLIT,$0
+TEXT runtime·read(SB),NOSPLIT,$12
+	MOVL fd+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL p+4(FP), AX
+	MOVL AX, 4(SP)
+	MOVL n+8(FP), AX
+	MOVL AX, 8(SP)
 	NACL_SYSCALL(SYS_read)
 	MOVL AX, ret+12(FP)
 	RET
@@ -43,82 +61,134 @@ TEXT syscall·naclWrite(SB), NOSPLIT, $16-16
 	MOVL AX, ret+16(FP)
 	RET
 
-TEXT runtime·write(SB),NOSPLIT,$0
+TEXT runtime·write(SB),NOSPLIT,$12
+	MOVL fd+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL p+4(FP), AX
+	MOVL AX, 4(SP)
+	MOVL n+8(FP), AX
+	MOVL AX, 8(SP)
 	NACL_SYSCALL(SYS_write)
 	MOVL AX, ret+12(FP)
 	RET
 
-TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
+TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$8
+	MOVL p+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL size+4(FP), AX
+	MOVL AX, 4(SP)
 	NACL_SYSCALL(SYS_exception_stack)
 	MOVL AX, ret+8(FP)
 	RET
 
-TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
+TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$8
+	MOVL fn+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL arg+4(FP), AX
+	MOVL AX, 4(SP)
 	NACL_SYSCALL(SYS_exception_handler)
 	MOVL AX, ret+8(FP)
 	RET
 
-TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
+TEXT runtime·nacl_sem_create(SB),NOSPLIT,$4
+	MOVL flag+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_sem_create)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
+TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$4
+	MOVL sem+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_sem_wait)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
+TEXT runtime·nacl_sem_post(SB),NOSPLIT,$4
+	MOVL sem+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_sem_post)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
+TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$4
+	MOVL flag+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_mutex_create)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
+TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$4
+	MOVL mutex+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_mutex_lock)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
+TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$4
+	MOVL mutex+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_mutex_trylock)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
+TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$4
+	MOVL mutex+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_mutex_unlock)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
+TEXT runtime·nacl_cond_create(SB),NOSPLIT,$4
+	MOVL flag+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_cond_create)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
+TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$8
+	MOVL cond+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL n+4(FP), AX
+	MOVL AX, 4(SP)
 	NACL_SYSCALL(SYS_cond_wait)
 	MOVL AX, ret+8(FP)
 	RET
 
-TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
+TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$4
+	MOVL cond+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_cond_signal)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
+TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$4
+	MOVL cond+0(FP), AX
+	MOVL AX, 0(SP)
 	NACL_SYSCALL(SYS_cond_broadcast)
 	MOVL AX, ret+4(FP)
 	RET
 
-TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
+TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$12
+	MOVL cond+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL lock+4(FP), AX
+	MOVL AX, 4(SP)
+	MOVL ts+8(FP), AX
+	MOVL AX, 8(SP)
 	NACL_SYSCALL(SYS_cond_timed_wait_abs)
 	MOVL AX, ret+12(FP)
 	RET
 
-TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
+TEXT runtime·nacl_thread_create(SB),NOSPLIT,$16
+	MOVL fn+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL stk+4(FP), AX
+	MOVL AX, 4(SP)
+	MOVL tls+8(FP), AX
+	MOVL AX, 8(SP)
+	MOVL xx+12(FP), AX
+	MOVL AX, 12(SP)
 	NACL_SYSCALL(SYS_thread_create)
 	MOVL AX, ret+16(FP)
 	RET
@@ -126,7 +196,11 @@ TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
 TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 	JMP runtime·mstart(SB)
 
-TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
+TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$8
+	MOVL ts+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL extra+4(FP), AX
+	MOVL AX, 4(SP)
 	NACL_SYSCALL(SYS_nanosleep)
 	MOVL AX, ret+8(FP)
 	RET
@@ -173,7 +247,11 @@ TEXT time·now(SB),NOSPLIT,$20
 TEXT syscall·now(SB),NOSPLIT,$0
 	JMP time·now(SB)
 
-TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
+TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$8
+	MOVL arg1+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL arg2+4(FP), AX
+	MOVL AX, 4(SP)
 	NACL_SYSCALL(SYS_clock_gettime)
 	MOVL AX, ret+8(FP)
 	RET

From 98e5a44a88990b4ed8130056c1d1dec4abc4ecaf Mon Sep 17 00:00:00 2001
From: "Jeff R. Allen" <jra@nella.org>
Date: Thu, 28 Aug 2014 15:50:13 +1000
Subject: [PATCH 250/423] png: make the encoder configurable

In order to support different compression levels, make the
encoder type public, and add an Encoder method to it.

Fixes #8499.

LGTM=nigeltao
R=nigeltao, ruiu
CC=golang-codereviews
https://golang.org/cl/129190043
---
 src/pkg/image/png/writer.go      | 52 +++++++++++++++++++++++++++++---
 src/pkg/image/png/writer_test.go | 26 +++++++++++++---
 2 files changed, 68 insertions(+), 10 deletions(-)

diff --git a/src/pkg/image/png/writer.go b/src/pkg/image/png/writer.go
index 5c232b760a..703aeec0a2 100644
--- a/src/pkg/image/png/writer.go
+++ b/src/pkg/image/png/writer.go
@@ -14,7 +14,13 @@ import (
 	"strconv"
 )
 
+// Encoder configures encoding PNG images.
+type Encoder struct {
+	CompressionLevel CompressionLevel
+}
+
 type encoder struct {
+	enc    *Encoder
 	w      io.Writer
 	m      image.Image
 	cb     int
@@ -24,6 +30,15 @@ type encoder struct {
 	tmp    [4 * 256]byte
 }
 
+type CompressionLevel int
+
+const (
+	DefaultCompression CompressionLevel = iota
+	NoCompression
+	BestSpeed
+	BestCompression
+)
+
 // Big-endian.
 func writeUint32(b []uint8, u uint32) {
 	b[0] = uint8(u >> 24)
@@ -255,8 +270,11 @@ func filter(cr *[nFilter][]byte, pr []byte, bpp int) int {
 	return filter
 }
 
-func writeImage(w io.Writer, m image.Image, cb int) error {
-	zw := zlib.NewWriter(w)
+func writeImage(w io.Writer, m image.Image, cb int, level int) error {
+	zw, err := zlib.NewWriterLevel(w, level)
+	if err != nil {
+		return err
+	}
 	defer zw.Close()
 
 	bpp := 0 // Bytes per pixel.
@@ -419,18 +437,41 @@ func (e *encoder) writeIDATs() {
 	}
 	var bw *bufio.Writer
 	bw = bufio.NewWriterSize(e, 1<<15)
-	e.err = writeImage(bw, e.m, e.cb)
+	e.err = writeImage(bw, e.m, e.cb, levelToZlib(e.enc.CompressionLevel))
 	if e.err != nil {
 		return
 	}
 	e.err = bw.Flush()
 }
 
+// This function is required because we want the zero value of
+// Encoder.CompressionLevel to map to zlib.DefaultCompression.
+func levelToZlib(l CompressionLevel) int {
+	switch l {
+	case DefaultCompression:
+		return zlib.DefaultCompression
+	case NoCompression:
+		return zlib.NoCompression
+	case BestSpeed:
+		return zlib.BestSpeed
+	case BestCompression:
+		return zlib.BestCompression
+	default:
+		return zlib.DefaultCompression
+	}
+}
+
 func (e *encoder) writeIEND() { e.writeChunk(nil, "IEND") }
 
-// Encode writes the Image m to w in PNG format. Any Image may be encoded, but
-// images that are not image.NRGBA might be encoded lossily.
+// Encode writes the Image m to w in PNG format. Any Image may be
+// encoded, but images that are not image.NRGBA might be encoded lossily.
 func Encode(w io.Writer, m image.Image) error {
+	var e Encoder
+	return e.Encode(w, m)
+}
+
+// Encode writes the Image m to w in PNG format.
+func (enc *Encoder) Encode(w io.Writer, m image.Image) error {
 	// Obviously, negative widths and heights are invalid. Furthermore, the PNG
 	// spec section 11.2.2 says that zero is invalid. Excessively large images are
 	// also rejected.
@@ -440,6 +481,7 @@ func Encode(w io.Writer, m image.Image) error {
 	}
 
 	var e encoder
+	e.enc = enc
 	e.w = w
 	e.m = m
 
diff --git a/src/pkg/image/png/writer_test.go b/src/pkg/image/png/writer_test.go
index 3116fc9ff9..6a872e2749 100644
--- a/src/pkg/image/png/writer_test.go
+++ b/src/pkg/image/png/writer_test.go
@@ -40,11 +40,7 @@ func encodeDecode(m image.Image) (image.Image, error) {
 	if err != nil {
 		return nil, err
 	}
-	m, err = Decode(&b)
-	if err != nil {
-		return nil, err
-	}
-	return m, nil
+	return Decode(&b)
 }
 
 func TestWriter(t *testing.T) {
@@ -81,6 +77,26 @@ func TestWriter(t *testing.T) {
 	}
 }
 
+func TestWriterLevels(t *testing.T) {
+	m := image.NewNRGBA(image.Rect(0, 0, 100, 100))
+
+	var b1, b2 bytes.Buffer
+	var e1, e2 Encoder
+
+	if err := e1.Encode(&b1, m); err != nil {
+		t.Fatal(err)
+	}
+
+	e2.CompressionLevel = NoCompression
+	if err := e2.Encode(&b2, m); err != nil {
+		t.Fatal(err)
+	}
+
+	if b2.Len() <= b1.Len() {
+		t.Error("DefaultCompression encoding was larger than NoCompression encoding")
+	}
+}
+
 func TestSubImage(t *testing.T) {
 	m0 := image.NewRGBA(image.Rect(0, 0, 256, 256))
 	for y := 0; y < 256; y++ {

From b53b47f5ac9e11fdcd3f704bc2cb0828bdee6958 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Aug 2014 10:36:48 -0400
Subject: [PATCH 251/423] runtime: finish converting iface.goc to iface.go

LGTM=bradfitz, dvyukov
R=golang-codereviews, bradfitz, dvyukov
CC=golang-codereviews, iant, khr
https://golang.org/cl/131510043
---
 src/pkg/runtime/heapdump.c |   5 +-
 src/pkg/runtime/iface.go   |  13 ++++
 src/pkg/runtime/iface.goc  | 155 -------------------------------------
 src/pkg/runtime/runtime.h  |   2 +-
 4 files changed, 18 insertions(+), 157 deletions(-)
 delete mode 100644 src/pkg/runtime/iface.goc

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 09d109199b..fe67e15f35 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -584,7 +584,10 @@ itab_callback(Itab *tab)
 static void
 dumpitabs(void)
 {
-	runtime·iterate_itabs(itab_callback);
+	void (*fn)(Itab*);
+	
+	fn = itab_callback;
+	runtime·iterate_itabs(&fn);
 }
 
 static void
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index a317628403..3180ea4524 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -425,3 +425,16 @@ func efacethash(e interface{}) uint32 {
 	}
 	return t.hash
 }
+
+func iterate_itabs(fn func(*itab)) {
+	for _, h := range hash {
+		for ; h != nil; h = h.link {
+			fn(h)
+		}
+	}
+}
+
+func ifaceE2I2(inter *interfacetype, e interface{}, r *fInterface) (ok bool) {
+	*r, ok = assertE2I2(inter, e)
+	return
+}
diff --git a/src/pkg/runtime/iface.goc b/src/pkg/runtime/iface.goc
deleted file mode 100644
index 440d272382..0000000000
--- a/src/pkg/runtime/iface.goc
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "type.h"
-#include "typekind.h"
-#include "malloc.h"
-#include "../../cmd/ld/textflag.h"
-
-extern	Itab*	runtime·hash[1009];
-extern	Mutex	runtime·ifaceLock;
-
-// TODO: delete this when no longer used (ifaceE2I2 is all that's left)
-static Itab*
-itab(InterfaceType *inter, Type *type, int32 canfail)
-{
-	int32 locked;
-	int32 ni;
-	Method *t, *et;
-	IMethod *i, *ei;
-	uint32 h;
-	String *iname, *ipkgPath;
-	Itab *m;
-	UncommonType *x;
-	Type *itype;
-	Eface err;
-
-	if(inter->mhdr.len == 0)
-		runtime·throw("internal error - misuse of itab");
-
-	locked = 0;
-
-	// easy case
-	x = type->x;
-	if(x == nil) {
-		if(canfail)
-			return nil;
-		iname = inter->m[0].name;
-		goto throw;
-	}
-
-	// compiler has provided some good hash codes for us.
-	h = inter->typ.hash;
-	h += 17 * type->hash;
-	// TODO(rsc): h += 23 * x->mhash ?
-	h %= nelem(runtime·hash);
-
-	// look twice - once without lock, once with.
-	// common case will be no lock contention.
-	for(locked=0; locked<2; locked++) {
-		if(locked)
-			runtime·lock(&runtime·ifaceLock);
-		for(m=runtime·atomicloadp(&runtime·hash[h]); m!=nil; m=m->link) {
-			if(m->inter == inter && m->type == type) {
-				if(m->bad) {
-					m = nil;
-					if(!canfail) {
-						// this can only happen if the conversion
-						// was already done once using the , ok form
-						// and we have a cached negative result.
-						// the cached result doesn't record which
-						// interface function was missing, so jump
-						// down to the interface check, which will
-						// do more work but give a better error.
-						goto search;
-					}
-				}
-				if(locked)
-					runtime·unlock(&runtime·ifaceLock);
-				return m;
-			}
-		}
-	}
-
-	ni = inter->mhdr.len;
-	m = runtime·persistentalloc(sizeof(*m) + ni*sizeof m->fun[0], 0, &mstats.other_sys);
-	m->inter = inter;
-	m->type = type;
-
-search:
-	// both inter and type have method sorted by name,
-	// and interface names are unique,
-	// so can iterate over both in lock step;
-	// the loop is O(ni+nt) not O(ni*nt).
-	i = inter->m;
-	ei = i + inter->mhdr.len;
-	t = x->m;
-	et = t + x->mhdr.len;
-	for(; i < ei; i++) {
-		itype = i->type;
-		iname = i->name;
-		ipkgPath = i->pkgPath;
-		for(;; t++) {
-			if(t >= et) {
-				if(!canfail) {
-				throw:
-					// didn't find method
-					runtime·newTypeAssertionError(
-						nil, type->string, inter->typ.string,
-						iname, &err);
-					if(locked)
-						runtime·unlock(&runtime·ifaceLock);
-					runtime·panic(err);
-					return nil;	// not reached
-				}
-				m->bad = 1;
-				goto out;
-			}
-			if(t->mtyp == itype && t->name == iname && t->pkgPath == ipkgPath)
-				break;
-		}
-		if(m)
-			m->fun[i - inter->m] = t->ifn;
-	}
-
-out:
-	if(!locked)
-		runtime·panicstring("invalid itab locking");
-	m->link = runtime·hash[h];
-	runtime·atomicstorep(&runtime·hash[h], m);
-	runtime·unlock(&runtime·ifaceLock);
-	if(m->bad)
-		return nil;
-	return m;
-}
-
-// call the callback for every itab that is currently allocated.
-void
-runtime·iterate_itabs(void (*callback)(Itab*))
-{
-	int32 i;
-	Itab *tab;
-
-	for(i = 0; i < nelem(runtime·hash); i++) {
-		for(tab = runtime·hash[i]; tab != nil; tab = tab->link) {
-			callback(tab);
-		}
-	}
-}
-
-// Still in C because it is called from C for finalizers.  This will
-// get converted to Go in a separate CL.  This is the last user of
-// the C version of itab().
-bool
-runtime·ifaceE2I2(InterfaceType *inter, Eface e, Iface *ret)
-{
-	ret->tab = itab(inter, e.type, 1);
-	if(ret->tab == nil)
-		return false;
-	ret->data = e.data;
-	return true;
-}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 72f446f379..90cb3cbd7f 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -959,7 +959,7 @@ void	_rt0_go(void);
 void*	runtime·funcdata(Func*, int32);
 void	runtime·setmaxthreads_m(void);
 G*	runtime·timejump(void);
-void	runtime·iterate_itabs(void (*callback)(Itab*));
+void	runtime·iterate_itabs(void (**callback)(Itab*));
 void	runtime·iterate_finq(void (*callback)(FuncVal*, byte*, uintptr, Type*, PtrType*));
 
 #pragma	varargck	argpos	runtime·printf	1

From 6179aca54825867db3ab15bfff28fbda73e49378 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Aug 2014 10:46:59 -0400
Subject: [PATCH 252/423] runtime: convert runtime1.goc, noasm_arm.goc to Go

LGTM=dvyukov
R=golang-codereviews, bradfitz, dvyukov
CC=golang-codereviews, iant, khr
https://golang.org/cl/135070043
---
 src/pkg/runtime/asm_386.s      |   2 +-
 src/pkg/runtime/asm_amd64.s    |   2 +-
 src/pkg/runtime/asm_amd64p32.s |   2 +-
 src/pkg/runtime/debug.go       |  26 ++++++--
 src/pkg/runtime/error.go       |   5 +-
 src/pkg/runtime/extern.go      |  69 +++++++++++++++++++-
 src/pkg/runtime/noasm_arm.go   |  54 +++++++++++++++
 src/pkg/runtime/noasm_arm.goc  |  74 ---------------------
 src/pkg/runtime/runtime.c      |   7 ++
 src/pkg/runtime/runtime1.goc   | 116 ---------------------------------
 src/pkg/runtime/stubs.goc      |   5 ++
 src/pkg/runtime/thunk.s        |   6 ++
 12 files changed, 167 insertions(+), 201 deletions(-)
 create mode 100644 src/pkg/runtime/noasm_arm.go
 delete mode 100644 src/pkg/runtime/noasm_arm.goc
 delete mode 100644 src/pkg/runtime/runtime1.goc

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 25f92d4541..e18d877895 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -1327,7 +1327,7 @@ TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
 	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT bytes·Compare(SB),NOSPLIT,$0-28
+TEXT runtime·cmpbytes(SB),NOSPLIT,$0-28
 	MOVL	s1+0(FP), SI
 	MOVL	s1+4(FP), BX
 	MOVL	s2+12(FP), DI
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 7e3ff1c55f..3dafc83708 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -1291,7 +1291,7 @@ TEXT runtime·cmpstring(SB),NOSPLIT,$0-40
 	MOVQ	AX, ret+32(FP)
 	RET
 
-TEXT bytes·Compare(SB),NOSPLIT,$0-56
+TEXT runtime·cmpbytes(SB),NOSPLIT,$0-56
 	MOVQ	s1+0(FP), SI
 	MOVQ	s1+8(FP), BX
 	MOVQ	s2+24(FP), DI
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 343edb1eae..0a5819b059 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -953,7 +953,7 @@ TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
 	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT bytes·Compare(SB),NOSPLIT,$0-28
+TEXT runtime·cmpbytes(SB),NOSPLIT,$0-28
 	MOVL	s1+0(FP), SI
 	MOVL	s1+4(FP), BX
 	MOVL	s2+12(FP), DI
diff --git a/src/pkg/runtime/debug.go b/src/pkg/runtime/debug.go
index af44a64741..181fac4615 100644
--- a/src/pkg/runtime/debug.go
+++ b/src/pkg/runtime/debug.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 // Breakpoint executes a breakpoint trap.
 func Breakpoint()
 
@@ -21,16 +23,32 @@ func UnlockOSThread()
 // change the current setting.
 // The number of logical CPUs on the local machine can be queried with NumCPU.
 // This call will go away when the scheduler improves.
-func GOMAXPROCS(n int) int
+func GOMAXPROCS(n int) int {
+	return int(gomaxprocsfunc(int32(n)))
+}
+
+func gomaxprocsfunc(int32) int32 // proc.c
 
 // NumCPU returns the number of logical CPUs on the local machine.
-func NumCPU() int
+func NumCPU() int {
+	return int(ncpu)
+}
 
 // NumCgoCall returns the number of cgo calls made by the current process.
-func NumCgoCall() int64
+func NumCgoCall() int64 {
+	var n int64
+	for mp := (*m)(atomicloadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
+		n += int64(mp.ncgocall)
+	}
+	return n
+}
 
 // NumGoroutine returns the number of goroutines that currently exist.
-func NumGoroutine() int
+func NumGoroutine() int {
+	return int(gcount())
+}
+
+func gcount() int32
 
 // MemProfileRate controls the fraction of memory allocations
 // that are recorded and reported in the memory profile.
diff --git a/src/pkg/runtime/error.go b/src/pkg/runtime/error.go
index 0fe882d0fa..54591ee43e 100644
--- a/src/pkg/runtime/error.go
+++ b/src/pkg/runtime/error.go
@@ -97,7 +97,10 @@ type stringer interface {
 	String() string
 }
 
-func typestring(interface{}) string
+func typestring(x interface{}) string {
+	e := (*eface)(unsafe.Pointer(&x))
+	return *e._type._string
+}
 
 // For calling from C.
 // Prints an argument passed to panic.
diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index 1a2d9c21a2..0e48bb9d88 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -75,6 +75,8 @@ of the run-time system.
 */
 package runtime
 
+import "unsafe"
+
 // Goexit terminates the goroutine that calls it.  No other goroutine is affected.
 // Goexit runs all deferred calls before terminating the goroutine.
 //
@@ -84,28 +86,89 @@ package runtime
 // If all other goroutines exit, the program crashes.
 func Goexit()
 
+// We assume that all architectures turn faults and the like
+// into apparent calls to runtime.sigpanic.  If we see a "call"
+// to runtime.sigpanic, we do not back up the PC to find the
+// line number of the CALL instruction, because there is no CALL.
+var sigpanic byte
+
 // Caller reports file and line number information about function invocations on
 // the calling goroutine's stack.  The argument skip is the number of stack frames
 // to ascend, with 0 identifying the caller of Caller.  (For historical reasons the
 // meaning of skip differs between Caller and Callers.) The return values report the
 // program counter, file name, and line number within the file of the corresponding
 // call.  The boolean ok is false if it was not possible to recover the information.
-func Caller(skip int) (pc uintptr, file string, line int, ok bool)
+func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
+	// Ask for two PCs: the one we were asked for
+	// and what it called, so that we can see if it
+	// "called" sigpanic.
+	var rpc [2]uintptr
+	if callers(int32(1+skip-1), &rpc[0], 2) < 2 {
+		return
+	}
+	f := findfunc(rpc[1])
+	if f == nil {
+		// TODO(rsc): Probably a bug?
+		// The C version said "have retpc at least"
+		// but actually returned pc=0.
+		ok = true
+		return
+	}
+	pc = rpc[1]
+	xpc := pc
+	g := findfunc(rpc[0])
+	if xpc > f.entry && (g == nil || g.entry != uintptr(unsafe.Pointer(&sigpanic))) {
+		xpc--
+	}
+	line = int(funcline(f, xpc, &file))
+	ok = true
+	return
+}
+
+func findfunc(uintptr) *_func
+
+//go:noescape
+func funcline(*_func, uintptr, *string) int32
 
 // Callers fills the slice pc with the program counters of function invocations
 // on the calling goroutine's stack.  The argument skip is the number of stack frames
 // to skip before recording in pc, with 0 identifying the frame for Callers itself and
 // 1 identifying the caller of Callers.
 // It returns the number of entries written to pc.
-func Callers(skip int, pc []uintptr) int
+func Callers(skip int, pc []uintptr) int {
+	// runtime.callers uses pc.array==nil as a signal
+	// to print a stack trace.  Pick off 0-length pc here
+	// so that we don't let a nil pc slice get to it.
+	if len(pc) == 0 {
+		return 0
+	}
+	return int(callers(int32(skip), &pc[0], int32(len(pc))))
+}
+
+//go:noescape
+func callers(int32, *uintptr, int32) int32
 
 func getgoroot() string
+func environ() []string
+
+func gogetenv(key string) string {
+	env := environ()
+	if env == nil {
+		gothrow("getenv before env init")
+	}
+	for _, s := range env {
+		if len(s) > len(key) && s[len(key)] == '=' && s[:len(key)] == key {
+			return s[len(key)+1:]
+		}
+	}
+	return ""
+}
 
 // GOROOT returns the root of the Go tree.
 // It uses the GOROOT environment variable, if set,
 // or else the root used during the Go build.
 func GOROOT() string {
-	s := getgoroot()
+	s := gogetenv("GOROOT")
 	if s != "" {
 		return s
 	}
diff --git a/src/pkg/runtime/noasm_arm.go b/src/pkg/runtime/noasm_arm.go
new file mode 100644
index 0000000000..01f4116f2a
--- /dev/null
+++ b/src/pkg/runtime/noasm_arm.go
@@ -0,0 +1,54 @@
+// 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.
+
+// Routines that are implemented in assembly in asm_{amd64,386}.s
+// but are implemented in Go for arm.
+
+package runtime
+
+func cmpstring(s1, s2 string) int {
+	l := len(s1)
+	if l < len(s2) {
+		l = len(s2)
+	}
+	for i := 0; i < l; i++ {
+		c1, c2 := s1[i], s2[i]
+		if c1 < c2 {
+			return -1
+		}
+		if c1 > c2 {
+			return +1
+		}
+	}
+	if len(s1) < len(s2) {
+		return -1
+	}
+	if len(s1) > len(s2) {
+		return +1
+	}
+	return 0
+}
+
+func cmpbytes(s1, s2 []byte) int {
+	l := len(s1)
+	if l < len(s2) {
+		l = len(s2)
+	}
+	for i := 0; i < l; i++ {
+		c1, c2 := s1[i], s2[i]
+		if c1 < c2 {
+			return -1
+		}
+		if c1 > c2 {
+			return +1
+		}
+	}
+	if len(s1) < len(s2) {
+		return -1
+	}
+	if len(s1) > len(s2) {
+		return +1
+	}
+	return 0
+}
diff --git a/src/pkg/runtime/noasm_arm.goc b/src/pkg/runtime/noasm_arm.goc
deleted file mode 100644
index fe3591e8a3..0000000000
--- a/src/pkg/runtime/noasm_arm.goc
+++ /dev/null
@@ -1,74 +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.
-
-// Routines that are implemented in assembly in asm_{amd64,386}.s
-// but are implemented in C for arm.
-
-package runtime
-#include "runtime.h"
-#include "../../cmd/ld/textflag.h"
-
-#pragma textflag NOSPLIT
-func cmpstring(s1 String, s2 String) (v int) {
-	uintgo i, l;
-	byte c1, c2;
-	
-	l = s1.len;
-        if(s2.len < l)
-		l = s2.len;
-        for(i=0; i<l; i++) {
-		c1 = s1.str[i];
-		c2 = s2.str[i];
-		if(c1 < c2) {
-			v = -1;
-			goto done;
-		}
-		if(c1 > c2) {
-			v = +1;
-			goto done;
-		}
-	}
-        if(s1.len < s2.len) {
-		v = -1;
-		goto done;
-	}
-        if(s1.len > s2.len) {
-		v = +1;
-		goto done;
-	}
-        v = 0;
- done:;
-}
-
-#pragma textflag NOSPLIT
-func bytes·Compare(s1 Slice, s2 Slice) (v int) {
-	uintgo i, l;
-	byte c1, c2;
-	
-	l = s1.len;
-        if(s2.len < l)
-		l = s2.len;
-        for(i=0; i<l; i++) {
-		c1 = s1.array[i];
-		c2 = s2.array[i];
-		if(c1 < c2) {
-			v = -1;
-			goto done;
-		}
-		if(c1 > c2) {
-			v = +1;
-			goto done;
-		}
-	}
-        if(s1.len < s2.len) {
-		v = -1;
-		goto done;
-	}
-	if(s1.len > s2.len) {
-		v = +1;
-		goto done;
-	}
-	v = 0;
- done:;
-}
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 4f6381297d..8bef7dc076 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -120,6 +120,12 @@ runtime·goenvs_unix(void)
 	syscall·envs.cap = n;
 }
 
+Slice
+runtime·environ()
+{
+	return syscall·envs;
+}
+
 int32
 runtime·atoi(byte *p)
 {
@@ -275,6 +281,7 @@ runtime·fastrand1(void)
 static Mutex ticksLock;
 static int64 ticks;
 
+// Note: Called by runtime/pprof in addition to runtime code.
 int64
 runtime·tickspersecond(void)
 {
diff --git a/src/pkg/runtime/runtime1.goc b/src/pkg/runtime/runtime1.goc
deleted file mode 100644
index 9529d6504b..0000000000
--- a/src/pkg/runtime/runtime1.goc
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2010 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "type.h"
-
-func GOMAXPROCS(n int) (ret int) {
-	ret = runtime·gomaxprocsfunc(n);
-}
-
-func NumCPU() (ret int) {
-	ret = runtime·ncpu;
-}
-
-func NumCgoCall() (ret int64) {
-	M *mp;
-
-	ret = 0;
-	for(mp=runtime·atomicloadp(&runtime·allm); mp; mp=mp->alllink)
-		ret += mp->ncgocall;
-}
-
-func newParFor(nthrmax uint32) (desc *ParFor) {
-	desc = runtime·parforalloc(nthrmax);
-}
-
-func parForSetup(desc *ParFor, nthr uint32, n uint32, ctx *byte, wait bool, body *byte) {
-	runtime·parforsetup(desc, nthr, n, ctx, wait, *(void(**)(ParFor*, uint32))body);
-}
-
-func parForDo(desc *ParFor) {
-	runtime·parfordo(desc);
-}
-
-func parForIters(desc *ParFor, tid uintptr) (start uintptr, end uintptr) {
-	runtime·parforiters(desc, tid, &start, &end);
-}
-
-func gogoBytes() (x int32) {
-	x = RuntimeGogoBytes;
-}
-
-func typestring(e Eface) (s String) {
-	s = *e.type->string;
-}
-
-func golockedOSThread() (ret bool) {
-	ret = runtime·lockedOSThread();
-}
-
-func NumGoroutine() (ret int) {
-	ret = runtime·gcount();
-}
-
-func getgoroot() (out String) {
-	byte *p;
-
-	p = runtime·getenv("GOROOT");
-	out = runtime·gostringnocopy(p);
-}
-
-/*
- * We assume that all architectures turn faults and the like
- * into apparent calls to runtime.sigpanic.  If we see a "call"
- * to runtime.sigpanic, we do not back up the PC to find the
- * line number of the CALL instruction, because there is no CALL.
- */
-void	runtime·sigpanic(void);
-
-func Caller(skip int) (retpc uintptr, retfile String, retline int, retbool bool) {
-	Func *f, *g;
-	uintptr pc;
-	uintptr rpc[2];
-
-	/*
-	 * Ask for two PCs: the one we were asked for
-	 * and what it called, so that we can see if it
-	 * "called" sigpanic.
-	 */
-	retpc = 0;
-	if(runtime·callers(1+skip-1, rpc, 2) < 2) {
-		retfile = runtime·emptystring;
-		retline = 0;
-		retbool = false;
-	} else if((f = runtime·findfunc(rpc[1])) == nil) {
-		retfile = runtime·emptystring;
-		retline = 0;
-		retbool = true;  // have retpc at least
-	} else {
-		retpc = rpc[1];
-		pc = retpc;
-		g = runtime·findfunc(rpc[0]);
-		if(pc > f->entry && (g == nil || g->entry != (uintptr)runtime·sigpanic))
-			pc--;
-		retline = runtime·funcline(f, pc, &retfile);
-		retbool = true;
-	}
-}
-
-func Callers(skip int, pc Slice) (retn int) {
-	// runtime.callers uses pc.array==nil as a signal
-	// to print a stack trace.  Pick off 0-length pc here
-	// so that we don't let a nil pc slice get to it.
-	if(pc.len == 0)
-		retn = 0;
-	else
-		retn = runtime·callers(skip, (uintptr*)pc.array, pc.len);
-}
-
-func runtime∕pprof·runtime_cyclesPerSecond() (res int64) {
-	res = runtime·tickspersecond();
-}
-
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index af2b155642..f8b2a9f0ad 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -68,3 +68,8 @@ func reflect·typelinks() (ret Slice) {
         ret.len = runtime·etypelink - runtime·typelink;
         ret.cap = ret.len;
 }
+
+// For testing.
+func gogoBytes() (x int32) {
+	x = RuntimeGogoBytes;
+}
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 7e7aa84335..46d0fb28e7 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -43,3 +43,9 @@ TEXT net·runtime_Semacquire(SB),NOSPLIT,$0-0
 
 TEXT net·runtime_Semrelease(SB),NOSPLIT,$0-0
 	JMP	runtime·asyncsemrelease(SB)
+
+TEXT runtime∕pprof·runtime_cyclesPerSecond(SB),NOSPLIT,$0-0
+	JMP	runtime·tickspersecond(SB)
+
+TEXT bytes·Compare(SB),NOSPLIT,$0-0
+	JMP	runtime·cmpbytes(SB)

From af12dc5cd5bd0f81f4473207343771ed61b0bcb0 Mon Sep 17 00:00:00 2001
From: "Jeff R. Allen" <jra@nella.org>
Date: Thu, 28 Aug 2014 08:22:54 -0700
Subject: [PATCH 253/423] mime: Make filename extensions case-insensitive

Fixes #8350.

LGTM=bradfitz
R=golang-codereviews, bradfitz, dave
CC=golang-codereviews
https://golang.org/cl/127380043
---
 src/pkg/mime/type.go         | 52 +++++++++++++++++++++++++-----------
 src/pkg/mime/type_plan9.go   |  2 +-
 src/pkg/mime/type_test.go    | 16 +++++++----
 src/pkg/mime/type_unix.go    |  2 +-
 src/pkg/mime/type_windows.go |  2 +-
 5 files changed, 50 insertions(+), 24 deletions(-)

diff --git a/src/pkg/mime/type.go b/src/pkg/mime/type.go
index 00cff263ba..d1e403f022 100644
--- a/src/pkg/mime/type.go
+++ b/src/pkg/mime/type.go
@@ -11,19 +11,28 @@ import (
 	"sync"
 )
 
-var mimeTypes = map[string]string{
-	".css":  "text/css; charset=utf-8",
-	".gif":  "image/gif",
-	".htm":  "text/html; charset=utf-8",
-	".html": "text/html; charset=utf-8",
-	".jpg":  "image/jpeg",
-	".js":   "application/x-javascript",
-	".pdf":  "application/pdf",
-	".png":  "image/png",
-	".xml":  "text/xml; charset=utf-8",
-}
+var (
+	mimeLock       sync.RWMutex
+	mimeTypes      = map[string]string{}
+	mimeTypesLower = map[string]string{}
+)
 
-var mimeLock sync.RWMutex
+func init() {
+	mimeTypes := map[string]string{
+		".css":  "text/css; charset=utf-8",
+		".gif":  "image/gif",
+		".htm":  "text/html; charset=utf-8",
+		".html": "text/html; charset=utf-8",
+		".jpg":  "image/jpeg",
+		".js":   "application/x-javascript",
+		".pdf":  "application/pdf",
+		".png":  "image/png",
+		".xml":  "text/xml; charset=utf-8",
+	}
+	for ext, typ := range mimeTypes {
+		AddExtensionType(ext, typ)
+	}
+}
 
 var once sync.Once
 
@@ -31,6 +40,8 @@ var once sync.Once
 // The extension ext should begin with a leading dot, as in ".html".
 // When ext has no associated type, TypeByExtension returns "".
 //
+// Extensions are looked up first case-sensitively, then case-insensitively.
+//
 // The built-in table is small but on unix it is augmented by the local
 // system's mime.types file(s) if available under one or more of these
 // names:
@@ -39,7 +50,7 @@ var once sync.Once
 //   /etc/apache2/mime.types
 //   /etc/apache/mime.types
 //
-// Windows system mime types are extracted from registry.
+// Windows system MIME types are extracted from registry.
 //
 // Text types have the charset parameter set to "utf-8" by default.
 func TypeByExtension(ext string) string {
@@ -47,15 +58,21 @@ func TypeByExtension(ext string) string {
 	mimeLock.RLock()
 	typename := mimeTypes[ext]
 	mimeLock.RUnlock()
+	if typename == "" {
+		lower := strings.ToLower(ext)
+		mimeLock.RLock()
+		typename = mimeTypesLower[lower]
+		mimeLock.RUnlock()
+	}
 	return typename
 }
 
 // AddExtensionType sets the MIME type associated with
-// the extension ext to typ.  The extension should begin with
+// the extension ext to typ. The extension should begin with
 // a leading dot, as in ".html".
 func AddExtensionType(ext, typ string) error {
-	if ext == "" || ext[0] != '.' {
-		return fmt.Errorf(`mime: extension "%s" misses dot`, ext)
+	if !strings.HasPrefix(ext, ".") {
+		return fmt.Errorf(`mime: extension %q misses dot`, ext)
 	}
 	once.Do(initMime)
 	return setExtensionType(ext, typ)
@@ -70,8 +87,11 @@ func setExtensionType(extension, mimeType string) error {
 		param["charset"] = "utf-8"
 		mimeType = FormatMediaType(mimeType, param)
 	}
+	extLower := strings.ToLower(extension)
+
 	mimeLock.Lock()
 	mimeTypes[extension] = mimeType
+	mimeTypesLower[extLower] = mimeType
 	mimeLock.Unlock()
 	return nil
 }
diff --git a/src/pkg/mime/type_plan9.go b/src/pkg/mime/type_plan9.go
index b8f0511ee7..8cbf6777f1 100644
--- a/src/pkg/mime/type_plan9.go
+++ b/src/pkg/mime/type_plan9.go
@@ -48,6 +48,6 @@ func initMimeForTests() map[string]string {
 	return map[string]string{
 		".t1":  "application/test",
 		".t2":  "text/test; charset=utf-8",
-		".png": "image/png",
+		".pNg": "image/png",
 	}
 }
diff --git a/src/pkg/mime/type_test.go b/src/pkg/mime/type_test.go
index 07e1cd5dae..3ec86fbb54 100644
--- a/src/pkg/mime/type_test.go
+++ b/src/pkg/mime/type_test.go
@@ -4,7 +4,9 @@
 
 package mime
 
-import "testing"
+import (
+	"testing"
+)
 
 var typeTests = initMimeForTests()
 
@@ -14,16 +16,20 @@ func TestTypeByExtension(t *testing.T) {
 		if val != want {
 			t.Errorf("TypeByExtension(%q) = %q, want %q", ext, val, want)
 		}
-
 	}
 }
 
 func TestCustomExtension(t *testing.T) {
-	custom := "text/xml; charset=iso-8859-1"
-	if error := AddExtensionType(".xml", custom); error != nil {
+	custom := "test/test; charset=iso-8859-1"
+	if error := AddExtensionType(".tesT", custom); error != nil {
 		t.Fatalf("error %s for AddExtension(%s)", error, custom)
 	}
-	if registered := TypeByExtension(".xml"); registered != custom {
+	// test with same capitalization
+	if registered := TypeByExtension(".tesT"); registered != custom {
+		t.Fatalf("registered %s instead of %s", registered, custom)
+	}
+	// test with different capitalization
+	if registered := TypeByExtension(".Test"); registered != custom {
 		t.Fatalf("registered %s instead of %s", registered, custom)
 	}
 }
diff --git a/src/pkg/mime/type_unix.go b/src/pkg/mime/type_unix.go
index 1d394315a4..3e404cf742 100644
--- a/src/pkg/mime/type_unix.go
+++ b/src/pkg/mime/type_unix.go
@@ -53,7 +53,7 @@ func initMime() {
 func initMimeForTests() map[string]string {
 	typeFiles = []string{"testdata/test.types"}
 	return map[string]string{
-		".t1":  "application/test",
+		".T1":  "application/test",
 		".t2":  "text/test; charset=utf-8",
 		".png": "image/png",
 	}
diff --git a/src/pkg/mime/type_windows.go b/src/pkg/mime/type_windows.go
index 180f948d16..ae758d78b3 100644
--- a/src/pkg/mime/type_windows.go
+++ b/src/pkg/mime/type_windows.go
@@ -58,6 +58,6 @@ func initMime() {
 
 func initMimeForTests() map[string]string {
 	return map[string]string{
-		".png": "image/png",
+		".PnG": "image/png",
 	}
 }

From f02232072312d6cb7921ad89256894c4cbd0b63c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Aug 2014 11:45:30 -0400
Subject: [PATCH 254/423] runtime: fix build

'range hash' makes a copy of the hash array in the stack, creating
a very large stack frame. It's just the right amount that it
uses most but not all of the total stack size. If you have a lot
of environment variables, like the builders, then this is too
much and the g0 stack runs out of space.

TBR=bradfitz
CC=golang-codereviews
https://golang.org/cl/132350043
---
 src/pkg/runtime/iface.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index 3180ea4524..57882fb704 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -427,7 +427,7 @@ func efacethash(e interface{}) uint32 {
 }
 
 func iterate_itabs(fn func(*itab)) {
-	for _, h := range hash {
+	for _, h := range &hash {
 		for ; h != nil; h = h.link {
 			fn(h)
 		}

From 2c1fde07ac2a5993a8c758abb3967950afde8406 Mon Sep 17 00:00:00 2001
From: David Crawshaw <david.crawshaw@zentus.com>
Date: Thu, 28 Aug 2014 11:47:54 -0400
Subject: [PATCH 255/423] runtime: fix arm build

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/134030043
---
 src/pkg/runtime/stubs.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 793cc3acb7..364c3e744d 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -190,7 +190,6 @@ func newstackcall(fv *funcval, addr unsafe.Pointer, size uint32)
 func procyield(cycles uint32)
 func osyield()
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
-func cmpstring(s1, s2 string) int
 func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer
 func readgogc() int32
 func notetsleepg(n *note, ns int64)

From 6fb6f4e7f9eea8b724ddde592686d7e9dcdaa41c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alberto=20Garc=C3=ADa=20Hierro?= <alberto@garciahierro.com>
Date: Thu, 28 Aug 2014 08:49:56 -0700
Subject: [PATCH 256/423] database/sql: use slices rather than container/list

Significantly reduces the number of allocations, while also
simplifying the code and increasing performance by a 1-2%.

benchmark                          old ns/op     new ns/op     delta
BenchmarkConcurrentDBExec          13290567      13026236      -1.99%
BenchmarkConcurrentStmtQuery       13249399      13008879      -1.82%
BenchmarkConcurrentStmtExec        8806237       8680182       -1.43%
BenchmarkConcurrentTxQuery         13628379      12756293      -6.40%
BenchmarkConcurrentTxExec          4794800       4722440       -1.51%
BenchmarkConcurrentTxStmtQuery     5040804       5200721       +3.17%
BenchmarkConcurrentTxStmtExec      1366574       1336626       -2.19%
BenchmarkConcurrentRandom          11119120      10926113      -1.74%

benchmark                          old allocs     new allocs     delta
BenchmarkConcurrentDBExec          14191          13684          -3.57%
BenchmarkConcurrentStmtQuery       16020          15514          -3.16%
BenchmarkConcurrentStmtExec        4179           3672           -12.13%
BenchmarkConcurrentTxQuery         16025          15518          -3.16%
BenchmarkConcurrentTxExec          12717          12709          -0.06%
BenchmarkConcurrentTxStmtQuery     15532          15525          -0.05%
BenchmarkConcurrentTxStmtExec      2175           2168           -0.32%
BenchmarkConcurrentRandom          12320          11997          -2.62%

benchmark                          old bytes     new bytes     delta
BenchmarkConcurrentDBExec          2164827       2139760       -1.16%
BenchmarkConcurrentStmtQuery       2418070       2394030       -0.99%
BenchmarkConcurrentStmtExec        1728782       1704371       -1.41%
BenchmarkConcurrentTxQuery         2477144       2452620       -0.99%
BenchmarkConcurrentTxExec          588920        588343        -0.10%
BenchmarkConcurrentTxStmtQuery     790866        796578        +0.72%
BenchmarkConcurrentTxStmtExec      98502         98143         -0.36%
BenchmarkConcurrentRandom          1725906       1710220       -0.91%

LGTM=ruiu, dave, bradfitz
R=golang-codereviews, ruiu, gobot, bradfitz, dave, minux
CC=bradfitz, golang-codereviews
https://golang.org/cl/107020044
---
 src/pkg/database/sql/sql.go      | 99 +++++++++++++++-----------------
 src/pkg/database/sql/sql_test.go | 36 +++++++-----
 2 files changed, 67 insertions(+), 68 deletions(-)

diff --git a/src/pkg/database/sql/sql.go b/src/pkg/database/sql/sql.go
index 690fc80d68..09f75b647a 100644
--- a/src/pkg/database/sql/sql.go
+++ b/src/pkg/database/sql/sql.go
@@ -13,7 +13,6 @@
 package sql
 
 import (
-	"container/list"
 	"database/sql/driver"
 	"errors"
 	"fmt"
@@ -198,8 +197,8 @@ type DB struct {
 	dsn    string
 
 	mu           sync.Mutex // protects following fields
-	freeConn     *list.List // of *driverConn
-	connRequests *list.List // of connRequest
+	freeConn     []*driverConn
+	connRequests []chan *connRequest
 	numOpen      int
 	pendingOpens int
 	// Used to signal the need for new connections
@@ -232,9 +231,6 @@ type driverConn struct {
 	inUse      bool
 	onPut      []func() // code (with db.mu held) run when conn is next returned
 	dbmuClosed bool     // same as closed, but guarded by db.mu, for connIfFree
-	// This is the Element returned by db.freeConn.PushFront(conn).
-	// It's used by connIfFree to remove the conn from the freeConn list.
-	listElem *list.Element
 }
 
 func (dc *driverConn) releaseConn(err error) {
@@ -437,8 +433,6 @@ func Open(driverName, dataSourceName string) (*DB, error) {
 		openerCh: make(chan struct{}, connectionRequestQueueSize),
 		lastPut:  make(map[*driverConn]string),
 	}
-	db.freeConn = list.New()
-	db.connRequests = list.New()
 	go db.connectionOpener()
 	return db, nil
 }
@@ -469,17 +463,13 @@ func (db *DB) Close() error {
 	}
 	close(db.openerCh)
 	var err error
-	fns := make([]func() error, 0, db.freeConn.Len())
-	for db.freeConn.Front() != nil {
-		dc := db.freeConn.Front().Value.(*driverConn)
-		dc.listElem = nil
+	fns := make([]func() error, 0, len(db.freeConn))
+	for _, dc := range db.freeConn {
 		fns = append(fns, dc.closeDBLocked())
-		db.freeConn.Remove(db.freeConn.Front())
 	}
+	db.freeConn = nil
 	db.closed = true
-	for db.connRequests.Front() != nil {
-		req := db.connRequests.Front().Value.(connRequest)
-		db.connRequests.Remove(db.connRequests.Front())
+	for _, req := range db.connRequests {
 		close(req)
 	}
 	db.mu.Unlock()
@@ -527,11 +517,11 @@ func (db *DB) SetMaxIdleConns(n int) {
 		db.maxIdle = db.maxOpen
 	}
 	var closing []*driverConn
-	for db.freeConn.Len() > db.maxIdleConnsLocked() {
-		dc := db.freeConn.Back().Value.(*driverConn)
-		dc.listElem = nil
-		db.freeConn.Remove(db.freeConn.Back())
-		closing = append(closing, dc)
+	idleCount := len(db.freeConn)
+	maxIdle := db.maxIdleConnsLocked()
+	if idleCount > maxIdle {
+		closing = db.freeConn[maxIdle:]
+		db.freeConn = db.freeConn[:maxIdle]
 	}
 	db.mu.Unlock()
 	for _, c := range closing {
@@ -564,7 +554,7 @@ func (db *DB) SetMaxOpenConns(n int) {
 // If there are connRequests and the connection limit hasn't been reached,
 // then tell the connectionOpener to open new connections.
 func (db *DB) maybeOpenNewConnections() {
-	numRequests := db.connRequests.Len() - db.pendingOpens
+	numRequests := len(db.connRequests) - db.pendingOpens
 	if db.maxOpen > 0 {
 		numCanOpen := db.maxOpen - (db.numOpen + db.pendingOpens)
 		if numRequests > numCanOpen {
@@ -616,7 +606,10 @@ func (db *DB) openNewConnection() {
 // connRequest represents one request for a new connection
 // When there are no idle connections available, DB.conn will create
 // a new connRequest and put it on the db.connRequests list.
-type connRequest chan<- interface{} // takes either a *driverConn or an error
+type connRequest struct {
+	conn *driverConn
+	err  error
+}
 
 var errDBClosed = errors.New("sql: database is closed")
 
@@ -630,32 +623,24 @@ func (db *DB) conn() (*driverConn, error) {
 
 	// If db.maxOpen > 0 and the number of open connections is over the limit
 	// and there are no free connection, make a request and wait.
-	if db.maxOpen > 0 && db.numOpen >= db.maxOpen && db.freeConn.Len() == 0 {
+	if db.maxOpen > 0 && db.numOpen >= db.maxOpen && len(db.freeConn) == 0 {
 		// Make the connRequest channel. It's buffered so that the
 		// connectionOpener doesn't block while waiting for the req to be read.
-		ch := make(chan interface{}, 1)
-		req := connRequest(ch)
-		db.connRequests.PushBack(req)
+		req := make(chan *connRequest, 1)
+		db.connRequests = append(db.connRequests, req)
 		db.maybeOpenNewConnections()
 		db.mu.Unlock()
-		ret, ok := <-ch
-		if !ok {
+		ret := <-req
+		if ret == nil {
 			return nil, errDBClosed
 		}
-		switch ret.(type) {
-		case *driverConn:
-			return ret.(*driverConn), nil
-		case error:
-			return nil, ret.(error)
-		default:
-			panic("sql: Unexpected type passed through connRequest.ch")
-		}
+		return ret.conn, ret.err
 	}
 
-	if f := db.freeConn.Front(); f != nil {
-		conn := f.Value.(*driverConn)
-		conn.listElem = nil
-		db.freeConn.Remove(f)
+	if c := len(db.freeConn); c > 0 {
+		conn := db.freeConn[0]
+		copy(db.freeConn, db.freeConn[1:])
+		db.freeConn = db.freeConn[:c-1]
 		conn.inUse = true
 		db.mu.Unlock()
 		return conn, nil
@@ -702,9 +687,15 @@ func (db *DB) connIfFree(wanted *driverConn) (*driverConn, error) {
 	if wanted.inUse {
 		return nil, errConnBusy
 	}
-	if wanted.listElem != nil {
-		db.freeConn.Remove(wanted.listElem)
-		wanted.listElem = nil
+	idx := -1
+	for ii, v := range db.freeConn {
+		if v == wanted {
+			idx = ii
+			break
+		}
+	}
+	if idx >= 0 {
+		db.freeConn = append(db.freeConn[:idx], db.freeConn[idx+1:]...)
 		wanted.inUse = true
 		return wanted, nil
 	}
@@ -793,18 +784,20 @@ func (db *DB) putConn(dc *driverConn, err error) {
 // If a connRequest was fulfilled or the *driverConn was placed in the
 // freeConn list, then true is returned, otherwise false is returned.
 func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
-	if db.connRequests.Len() > 0 {
-		req := db.connRequests.Front().Value.(connRequest)
-		db.connRequests.Remove(db.connRequests.Front())
-		if err != nil {
-			req <- err
-		} else {
+	if c := len(db.connRequests); c > 0 {
+		req := db.connRequests[0]
+		copy(db.connRequests, db.connRequests[1:])
+		db.connRequests = db.connRequests[:c-1]
+		if err == nil {
 			dc.inUse = true
-			req <- dc
+		}
+		req <- &connRequest{
+			conn: dc,
+			err:  err,
 		}
 		return true
-	} else if err == nil && !db.closed && db.maxIdleConnsLocked() > db.freeConn.Len() {
-		dc.listElem = db.freeConn.PushFront(dc)
+	} else if err == nil && !db.closed && db.maxIdleConnsLocked() > len(db.freeConn) {
+		db.freeConn = append(db.freeConn, dc)
 		return true
 	}
 	return false
diff --git a/src/pkg/database/sql/sql_test.go b/src/pkg/database/sql/sql_test.go
index 71c81d6f76..8849c81c4b 100644
--- a/src/pkg/database/sql/sql_test.go
+++ b/src/pkg/database/sql/sql_test.go
@@ -24,7 +24,14 @@ func init() {
 	}
 	freedFrom := make(map[dbConn]string)
 	putConnHook = func(db *DB, c *driverConn) {
-		if c.listElem != nil {
+		idx := -1
+		for i, v := range db.freeConn {
+			if v == c {
+				idx = i
+				break
+			}
+		}
+		if idx >= 0 {
 			// print before panic, as panic may get lost due to conflicting panic
 			// (all goroutines asleep) elsewhere, since we might not unlock
 			// the mutex in freeConn here.
@@ -79,15 +86,14 @@ func closeDB(t testing.TB, db *DB) {
 			t.Errorf("Error closing fakeConn: %v", err)
 		}
 	})
-	for node, i := db.freeConn.Front(), 0; node != nil; node, i = node.Next(), i+1 {
-		dc := node.Value.(*driverConn)
+	for i, dc := range db.freeConn {
 		if n := len(dc.openStmt); n > 0 {
 			// Just a sanity check. This is legal in
 			// general, but if we make the tests clean up
 			// their statements first, then we can safely
 			// verify this is always zero here, and any
 			// other value is a leak.
-			t.Errorf("while closing db, freeConn %d/%d had %d open stmts; want 0", i, db.freeConn.Len(), n)
+			t.Errorf("while closing db, freeConn %d/%d had %d open stmts; want 0", i, len(db.freeConn), n)
 		}
 	}
 	err := db.Close()
@@ -105,10 +111,10 @@ func closeDB(t testing.TB, db *DB) {
 // numPrepares assumes that db has exactly 1 idle conn and returns
 // its count of calls to Prepare
 func numPrepares(t *testing.T, db *DB) int {
-	if n := db.freeConn.Len(); n != 1 {
+	if n := len(db.freeConn); n != 1 {
 		t.Fatalf("free conns = %d; want 1", n)
 	}
-	return (db.freeConn.Front().Value.(*driverConn)).ci.(*fakeConn).numPrepare
+	return db.freeConn[0].ci.(*fakeConn).numPrepare
 }
 
 func (db *DB) numDeps() int {
@@ -133,7 +139,7 @@ func (db *DB) numDepsPollUntil(want int, d time.Duration) int {
 func (db *DB) numFreeConns() int {
 	db.mu.Lock()
 	defer db.mu.Unlock()
-	return db.freeConn.Len()
+	return len(db.freeConn)
 }
 
 func (db *DB) dumpDeps(t *testing.T) {
@@ -650,10 +656,10 @@ func TestQueryRowClosingStmt(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if db.freeConn.Len() != 1 {
+	if len(db.freeConn) != 1 {
 		t.Fatalf("expected 1 free conn")
 	}
-	fakeConn := (db.freeConn.Front().Value.(*driverConn)).ci.(*fakeConn)
+	fakeConn := db.freeConn[0].ci.(*fakeConn)
 	if made, closed := fakeConn.stmtsMade, fakeConn.stmtsClosed; made != closed {
 		t.Errorf("statement close mismatch: made %d, closed %d", made, closed)
 	}
@@ -878,13 +884,13 @@ func TestMaxIdleConns(t *testing.T) {
 		t.Fatal(err)
 	}
 	tx.Commit()
-	if got := db.freeConn.Len(); got != 1 {
+	if got := len(db.freeConn); got != 1 {
 		t.Errorf("freeConns = %d; want 1", got)
 	}
 
 	db.SetMaxIdleConns(0)
 
-	if got := db.freeConn.Len(); got != 0 {
+	if got := len(db.freeConn); got != 0 {
 		t.Errorf("freeConns after set to zero = %d; want 0", got)
 	}
 
@@ -893,7 +899,7 @@ func TestMaxIdleConns(t *testing.T) {
 		t.Fatal(err)
 	}
 	tx.Commit()
-	if got := db.freeConn.Len(); got != 0 {
+	if got := len(db.freeConn); got != 0 {
 		t.Errorf("freeConns = %d; want 0", got)
 	}
 }
@@ -1180,10 +1186,10 @@ func TestCloseConnBeforeStmts(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if db.freeConn.Len() != 1 {
-		t.Fatalf("expected 1 freeConn; got %d", db.freeConn.Len())
+	if len(db.freeConn) != 1 {
+		t.Fatalf("expected 1 freeConn; got %d", len(db.freeConn))
 	}
-	dc := db.freeConn.Front().Value.(*driverConn)
+	dc := db.freeConn[0]
 	if dc.closed {
 		t.Errorf("conn shouldn't be closed")
 	}

From 1e47854d996ffa42ab3dd50e8094b0b3f8b02bb4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Aug 2014 11:51:09 -0400
Subject: [PATCH 257/423] cmd/api: more runtime fixes

This is getting a little annoying, but once the runtime structs are
being defined in Go, these will go away. So it's only a temporary cost.

TBR=bradfitz
CC=golang-codereviews
https://golang.org/cl/135940043
---
 src/cmd/api/goapi.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 56ba74a506..65b9aaa094 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -385,7 +385,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
 			" hchan struct{}; chantype struct{}; waitq struct{};" +
 			" note struct{}; wincallbackcontext struct{};" +
-			" gobuf struct{}; funcval struct{};" +
+			" gobuf struct{}; funcval struct{}; _func struct{};" +
 			"); " +
 			"const ( cb_max = 2000 )"
 		f, err = parser.ParseFile(fset, filename, src, 0)

From f852034eb0e3f1397d5510b900d8c8dbf8b18746 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 28 Aug 2014 08:53:25 -0700
Subject: [PATCH 258/423] spec: move Method expr/value section near selectors

Preparation for fixing issue 5769 (method selectors
do not auto-dereference): The actual fix may require
some cleanups in all these sections, and syntactically,
method expressions and method values are selector
expressions. Moving them next to each other so that
it's easy to see the actual changes (next CL).

No content changes besides the section moves.

LGTM=iant, rsc
R=r, rsc, iant, ken
CC=golang-codereviews
https://golang.org/cl/132300043
---
 doc/go_spec.html | 455 ++++++++++++++++++++++++-----------------------
 1 file changed, 228 insertions(+), 227 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index a32fa457c9..a5edc8646c 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of August 5, 2014",
+	"Subtitle": "Version of August 28, 2014",
 	"Path": "/ref/spec"
 }-->
 
@@ -2537,6 +2537,233 @@ p.M0()  // ((*p).T0).M0()
 </pre>
 
 
+<h3 id="Method_expressions">Method expressions</h3>
+
+<p>
+If <code>M</code> is in the <a href="#Method_sets">method set</a> of type <code>T</code>,
+<code>T.M</code> is a function that is callable as a regular function
+with the same arguments as <code>M</code> prefixed by an additional
+argument that is the receiver of the method.
+</p>
+
+<pre class="ebnf">
+MethodExpr    = ReceiverType "." MethodName .
+ReceiverType  = TypeName | "(" "*" TypeName ")" | "(" ReceiverType ")" .
+</pre>
+
+<p>
+Consider a struct type <code>T</code> with two methods,
+<code>Mv</code>, whose receiver is of type <code>T</code>, and
+<code>Mp</code>, whose receiver is of type <code>*T</code>.
+</p>
+
+<pre>
+type T struct {
+	a int
+}
+func (tv  T) Mv(a int) int         { return 0 }  // value receiver
+func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
+
+var t T
+</pre>
+
+<p>
+The expression
+</p>
+
+<pre>
+T.Mv
+</pre>
+
+<p>
+yields a function equivalent to <code>Mv</code> but
+with an explicit receiver as its first argument; it has signature
+</p>
+
+<pre>
+func(tv T, a int) int
+</pre>
+
+<p>
+That function may be called normally with an explicit receiver, so
+these five invocations are equivalent:
+</p>
+
+<pre>
+t.Mv(7)
+T.Mv(t, 7)
+(T).Mv(t, 7)
+f1 := T.Mv; f1(t, 7)
+f2 := (T).Mv; f2(t, 7)
+</pre>
+
+<p>
+Similarly, the expression
+</p>
+
+<pre>
+(*T).Mp
+</pre>
+
+<p>
+yields a function value representing <code>Mp</code> with signature
+</p>
+
+<pre>
+func(tp *T, f float32) float32
+</pre>
+
+<p>
+For a method with a value receiver, one can derive a function
+with an explicit pointer receiver, so
+</p>
+
+<pre>
+(*T).Mv
+</pre>
+
+<p>
+yields a function value representing <code>Mv</code> with signature
+</p>
+
+<pre>
+func(tv *T, a int) int
+</pre>
+
+<p>
+Such a function indirects through the receiver to create a value
+to pass as the receiver to the underlying method;
+the method does not overwrite the value whose address is passed in
+the function call.
+</p>
+
+<p>
+The final case, a value-receiver function for a pointer-receiver method,
+is illegal because pointer-receiver methods are not in the method set
+of the value type.
+</p>
+
+<p>
+Function values derived from methods are called with function call syntax;
+the receiver is provided as the first argument to the call.
+That is, given <code>f := T.Mv</code>, <code>f</code> is invoked
+as <code>f(t, 7)</code> not <code>t.f(7)</code>.
+To construct a function that binds the receiver, use a
+<a href="#Function_literals">function literal</a> or
+<a href="#Method_values">method value</a>.
+</p>
+
+<p>
+It is legal to derive a function value from a method of an interface type.
+The resulting function takes an explicit receiver of that interface type.
+</p>
+
+<h3 id="Method_values">Method values</h3>
+
+<p>
+If the expression <code>x</code> has static type <code>T</code> and
+<code>M</code> is in the <a href="#Method_sets">method set</a> of type <code>T</code>,
+<code>x.M</code> is called a <i>method value</i>.
+The method value <code>x.M</code> is a function value that is callable
+with the same arguments as a method call of <code>x.M</code>.
+The expression <code>x</code> is evaluated and saved during the evaluation of the
+method value; the saved copy is then used as the receiver in any calls,
+which may be executed later.
+</p>
+
+<p>
+The type <code>T</code> may be an interface or non-interface type.
+</p>
+
+<p>
+As in the discussion of <a href="#Method_expressions">method expressions</a> above,
+consider a struct type <code>T</code> with two methods,
+<code>Mv</code>, whose receiver is of type <code>T</code>, and
+<code>Mp</code>, whose receiver is of type <code>*T</code>.
+</p>
+
+<pre>
+type T struct {
+	a int
+}
+func (tv  T) Mv(a int) int         { return 0 }  // value receiver
+func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
+
+var t T
+var pt *T
+func makeT() T
+</pre>
+
+<p>
+The expression
+</p>
+
+<pre>
+t.Mv
+</pre>
+
+<p>
+yields a function value of type
+</p>
+
+<pre>
+func(int) int
+</pre>
+
+<p>
+These two invocations are equivalent:
+</p>
+
+<pre>
+t.Mv(7)
+f := t.Mv; f(7)
+</pre>
+
+<p>
+Similarly, the expression
+</p>
+
+<pre>
+pt.Mp
+</pre>
+
+<p>
+yields a function value of type
+</p>
+
+<pre>
+func(float32) float32
+</pre>
+
+<p>
+As with <a href="#Selectors">selectors</a>, a reference to a non-interface method with a value receiver
+using a pointer will automatically dereference that pointer: <code>pt.Mv</code> is equivalent to <code>(*pt).Mv</code>.
+</p>
+
+<p>
+As with <a href="#Calls">method calls</a>, a reference to a non-interface method with a pointer receiver
+using an addressable value will automatically take the address of that value: <code>t.Mp</code> is equivalent to <code>(&amp;t).Mp</code>.
+</p>
+
+<pre>
+f := t.Mv; f(7)   // like t.Mv(7)
+f := pt.Mp; f(7)  // like pt.Mp(7)
+f := pt.Mv; f(7)  // like (*pt).Mv(7)
+f := t.Mp; f(7)   // like (&amp;t).Mp(7)
+f := makeT().Mp   // invalid: result of makeT() is not addressable
+</pre>
+
+<p>
+Although the examples above use non-interface types, it is also legal to create a method value
+from a value of interface type.
+</p>
+
+<pre>
+var i interface { M(int) } = myVal
+f := i.M; f(7)  // like i.M(7)
+</pre>
+
+
 <h3 id="Index_expressions">Index expressions</h3>
 
 <p>
@@ -3436,232 +3663,6 @@ channel is closed and empty.
 </p>
 
 
-<h3 id="Method_expressions">Method expressions</h3>
-
-<p>
-If <code>M</code> is in the <a href="#Method_sets">method set</a> of type <code>T</code>,
-<code>T.M</code> is a function that is callable as a regular function
-with the same arguments as <code>M</code> prefixed by an additional
-argument that is the receiver of the method.
-</p>
-
-<pre class="ebnf">
-MethodExpr    = ReceiverType "." MethodName .
-ReceiverType  = TypeName | "(" "*" TypeName ")" | "(" ReceiverType ")" .
-</pre>
-
-<p>
-Consider a struct type <code>T</code> with two methods,
-<code>Mv</code>, whose receiver is of type <code>T</code>, and
-<code>Mp</code>, whose receiver is of type <code>*T</code>.
-</p>
-
-<pre>
-type T struct {
-	a int
-}
-func (tv  T) Mv(a int) int         { return 0 }  // value receiver
-func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
-
-var t T
-</pre>
-
-<p>
-The expression
-</p>
-
-<pre>
-T.Mv
-</pre>
-
-<p>
-yields a function equivalent to <code>Mv</code> but
-with an explicit receiver as its first argument; it has signature
-</p>
-
-<pre>
-func(tv T, a int) int
-</pre>
-
-<p>
-That function may be called normally with an explicit receiver, so
-these five invocations are equivalent:
-</p>
-
-<pre>
-t.Mv(7)
-T.Mv(t, 7)
-(T).Mv(t, 7)
-f1 := T.Mv; f1(t, 7)
-f2 := (T).Mv; f2(t, 7)
-</pre>
-
-<p>
-Similarly, the expression
-</p>
-
-<pre>
-(*T).Mp
-</pre>
-
-<p>
-yields a function value representing <code>Mp</code> with signature
-</p>
-
-<pre>
-func(tp *T, f float32) float32
-</pre>
-
-<p>
-For a method with a value receiver, one can derive a function
-with an explicit pointer receiver, so
-</p>
-
-<pre>
-(*T).Mv
-</pre>
-
-<p>
-yields a function value representing <code>Mv</code> with signature
-</p>
-
-<pre>
-func(tv *T, a int) int
-</pre>
-
-<p>
-Such a function indirects through the receiver to create a value
-to pass as the receiver to the underlying method;
-the method does not overwrite the value whose address is passed in
-the function call.
-</p>
-
-<p>
-The final case, a value-receiver function for a pointer-receiver method,
-is illegal because pointer-receiver methods are not in the method set
-of the value type.
-</p>
-
-<p>
-Function values derived from methods are called with function call syntax;
-the receiver is provided as the first argument to the call.
-That is, given <code>f := T.Mv</code>, <code>f</code> is invoked
-as <code>f(t, 7)</code> not <code>t.f(7)</code>.
-To construct a function that binds the receiver, use a
-<a href="#Function_literals">function literal</a> or
-<a href="#Method_values">method value</a>.
-</p>
-
-<p>
-It is legal to derive a function value from a method of an interface type.
-The resulting function takes an explicit receiver of that interface type.
-</p>
-
-<h3 id="Method_values">Method values</h3>
-
-<p>
-If the expression <code>x</code> has static type <code>T</code> and
-<code>M</code> is in the <a href="#Method_sets">method set</a> of type <code>T</code>,
-<code>x.M</code> is called a <i>method value</i>.
-The method value <code>x.M</code> is a function value that is callable
-with the same arguments as a method call of <code>x.M</code>.
-The expression <code>x</code> is evaluated and saved during the evaluation of the
-method value; the saved copy is then used as the receiver in any calls,
-which may be executed later.
-</p>
-
-<p>
-The type <code>T</code> may be an interface or non-interface type.
-</p>
-
-<p>
-As in the discussion of <a href="#Method_expressions">method expressions</a> above,
-consider a struct type <code>T</code> with two methods,
-<code>Mv</code>, whose receiver is of type <code>T</code>, and
-<code>Mp</code>, whose receiver is of type <code>*T</code>.
-</p>
-
-<pre>
-type T struct {
-	a int
-}
-func (tv  T) Mv(a int) int         { return 0 }  // value receiver
-func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
-
-var t T
-var pt *T
-func makeT() T
-</pre>
-
-<p>
-The expression
-</p>
-
-<pre>
-t.Mv
-</pre>
-
-<p>
-yields a function value of type
-</p>
-
-<pre>
-func(int) int
-</pre>
-
-<p>
-These two invocations are equivalent:
-</p>
-
-<pre>
-t.Mv(7)
-f := t.Mv; f(7)
-</pre>
-
-<p>
-Similarly, the expression
-</p>
-
-<pre>
-pt.Mp
-</pre>
-
-<p>
-yields a function value of type
-</p>
-
-<pre>
-func(float32) float32
-</pre>
-
-<p>
-As with <a href="#Selectors">selectors</a>, a reference to a non-interface method with a value receiver
-using a pointer will automatically dereference that pointer: <code>pt.Mv</code> is equivalent to <code>(*pt).Mv</code>.
-</p>
-
-<p>
-As with <a href="#Calls">method calls</a>, a reference to a non-interface method with a pointer receiver
-using an addressable value will automatically take the address of that value: <code>t.Mp</code> is equivalent to <code>(&amp;t).Mp</code>.
-</p>
-
-<pre>
-f := t.Mv; f(7)   // like t.Mv(7)
-f := pt.Mp; f(7)  // like pt.Mp(7)
-f := pt.Mv; f(7)  // like (*pt).Mv(7)
-f := t.Mp; f(7)   // like (&amp;t).Mp(7)
-f := makeT().Mp   // invalid: result of makeT() is not addressable
-</pre>
-
-<p>
-Although the examples above use non-interface types, it is also legal to create a method value
-from a value of interface type.
-</p>
-
-<pre>
-var i interface { M(int) } = myVal
-f := i.M; f(7)  // like i.M(7)
-</pre>
-
 <h3 id="Conversions">Conversions</h3>
 
 <p>

From 5ea131f442cf1bb1fa9ce1029054838af974f0e8 Mon Sep 17 00:00:00 2001
From: David Crawshaw <david.crawshaw@zentus.com>
Date: Thu, 28 Aug 2014 12:07:52 -0400
Subject: [PATCH 259/423] runtime: compare only until min(len(s1), len(s2))

LGTM=bradfitz
R=rsc, bradfitz
CC=golang-codereviews
https://golang.org/cl/139770043
---
 src/pkg/runtime/noasm_arm.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/noasm_arm.go b/src/pkg/runtime/noasm_arm.go
index 01f4116f2a..dd3ef82676 100644
--- a/src/pkg/runtime/noasm_arm.go
+++ b/src/pkg/runtime/noasm_arm.go
@@ -9,7 +9,7 @@ package runtime
 
 func cmpstring(s1, s2 string) int {
 	l := len(s1)
-	if l < len(s2) {
+	if len(s2) < l {
 		l = len(s2)
 	}
 	for i := 0; i < l; i++ {
@@ -32,7 +32,7 @@ func cmpstring(s1, s2 string) int {
 
 func cmpbytes(s1, s2 []byte) int {
 	l := len(s1)
-	if l < len(s2) {
+	if len(s2) < l {
 		l = len(s2)
 	}
 	for i := 0; i < l; i++ {

From 558bd8e1d90e474c97115dd9d9cd089d19a3650f Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Thu, 28 Aug 2014 11:07:29 -0700
Subject: [PATCH 260/423] database/sql: use a value type instead of a pointer

Follow-up to https://golang.org/cl/107020044/
Also add a little comment.

LGTM=ruiu, josharian
R=josharian, ruiu
CC=golang-codereviews
https://golang.org/cl/139760043
---
 src/pkg/database/sql/sql.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/pkg/database/sql/sql.go b/src/pkg/database/sql/sql.go
index 09f75b647a..63c6dd6816 100644
--- a/src/pkg/database/sql/sql.go
+++ b/src/pkg/database/sql/sql.go
@@ -198,7 +198,7 @@ type DB struct {
 
 	mu           sync.Mutex // protects following fields
 	freeConn     []*driverConn
-	connRequests []chan *connRequest
+	connRequests []chan connRequest
 	numOpen      int
 	pendingOpens int
 	// Used to signal the need for new connections
@@ -626,14 +626,11 @@ func (db *DB) conn() (*driverConn, error) {
 	if db.maxOpen > 0 && db.numOpen >= db.maxOpen && len(db.freeConn) == 0 {
 		// Make the connRequest channel. It's buffered so that the
 		// connectionOpener doesn't block while waiting for the req to be read.
-		req := make(chan *connRequest, 1)
+		req := make(chan connRequest, 1)
 		db.connRequests = append(db.connRequests, req)
 		db.maybeOpenNewConnections()
 		db.mu.Unlock()
 		ret := <-req
-		if ret == nil {
-			return nil, errDBClosed
-		}
 		return ret.conn, ret.err
 	}
 
@@ -786,12 +783,15 @@ func (db *DB) putConn(dc *driverConn, err error) {
 func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
 	if c := len(db.connRequests); c > 0 {
 		req := db.connRequests[0]
+		// This copy is O(n) but in practice faster than a linked list.
+		// TODO: consider compacting it down less often and
+		// moving the base instead?
 		copy(db.connRequests, db.connRequests[1:])
 		db.connRequests = db.connRequests[:c-1]
 		if err == nil {
 			dc.inUse = true
 		}
-		req <- &connRequest{
+		req <- connRequest{
 			conn: dc,
 			err:  err,
 		}

From b155e79f23d66d70f761d73cb7478c5fb59c915c Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Thu, 28 Aug 2014 11:07:46 -0700
Subject: [PATCH 261/423] mime: style, perf, and test updates to
 case-insensitive lookups

Only grab the lock once, don't allocate, add more tests.

LGTM=ruiu
R=ruiu, josharian
CC=golang-codereviews
https://golang.org/cl/139780043
---
 src/pkg/mime/type.go      | 60 +++++++++++++++++++++++++++------------
 src/pkg/mime/type_test.go | 39 ++++++++++++++++++-------
 2 files changed, 71 insertions(+), 28 deletions(-)

diff --git a/src/pkg/mime/type.go b/src/pkg/mime/type.go
index d1e403f022..ffda1f0ce5 100644
--- a/src/pkg/mime/type.go
+++ b/src/pkg/mime/type.go
@@ -13,12 +13,7 @@ import (
 
 var (
 	mimeLock       sync.RWMutex
-	mimeTypes      = map[string]string{}
-	mimeTypesLower = map[string]string{}
-)
-
-func init() {
-	mimeTypes := map[string]string{
+	mimeTypesLower = map[string]string{
 		".css":  "text/css; charset=utf-8",
 		".gif":  "image/gif",
 		".htm":  "text/html; charset=utf-8",
@@ -29,12 +24,21 @@ func init() {
 		".png":  "image/png",
 		".xml":  "text/xml; charset=utf-8",
 	}
-	for ext, typ := range mimeTypes {
-		AddExtensionType(ext, typ)
+	mimeTypes = clone(mimeTypesLower)
+)
+
+func clone(m map[string]string) map[string]string {
+	m2 := make(map[string]string, len(m))
+	for k, v := range m {
+		m2[k] = v
+		if strings.ToLower(k) != k {
+			panic("keys in mimeTypesLower must be lowercase")
+		}
 	}
+	return m2
 }
 
-var once sync.Once
+var once sync.Once // guards initMime
 
 // TypeByExtension returns the MIME type associated with the file extension ext.
 // The extension ext should begin with a leading dot, as in ".html".
@@ -50,21 +54,41 @@ var once sync.Once
 //   /etc/apache2/mime.types
 //   /etc/apache/mime.types
 //
-// Windows system MIME types are extracted from registry.
+// On Windows, MIME types are extracted from the registry.
 //
 // Text types have the charset parameter set to "utf-8" by default.
 func TypeByExtension(ext string) string {
 	once.Do(initMime)
 	mimeLock.RLock()
-	typename := mimeTypes[ext]
-	mimeLock.RUnlock()
-	if typename == "" {
-		lower := strings.ToLower(ext)
-		mimeLock.RLock()
-		typename = mimeTypesLower[lower]
-		mimeLock.RUnlock()
+	defer mimeLock.RUnlock()
+
+	// Case-sensitive lookup.
+	v := mimeTypes[ext]
+	if v != "" {
+		return v
 	}
-	return typename
+
+	// Case-insensitive lookup.
+	// Optimistically assume a short ASCII extension and be
+	// allocation-free in that case.
+	var buf [10]byte
+	lower := buf[:0]
+	const utf8RuneSelf = 0x80 // from utf8 package, but not importing it.
+	for i := 0; i < len(ext); i++ {
+		c := ext[i]
+		if c >= utf8RuneSelf {
+			// Slow path.
+			return mimeTypesLower[strings.ToLower(ext)]
+		}
+		if 'A' <= c && c <= 'Z' {
+			lower = append(lower, c+('a'-'A'))
+		} else {
+			lower = append(lower, c)
+		}
+	}
+	// The conversion from []byte to string doesn't allocate in
+	// a map lookup.
+	return mimeTypesLower[string(lower)]
 }
 
 // AddExtensionType sets the MIME type associated with
diff --git a/src/pkg/mime/type_test.go b/src/pkg/mime/type_test.go
index 3ec86fbb54..d2d254ae9a 100644
--- a/src/pkg/mime/type_test.go
+++ b/src/pkg/mime/type_test.go
@@ -19,17 +19,36 @@ func TestTypeByExtension(t *testing.T) {
 	}
 }
 
-func TestCustomExtension(t *testing.T) {
-	custom := "test/test; charset=iso-8859-1"
-	if error := AddExtensionType(".tesT", custom); error != nil {
-		t.Fatalf("error %s for AddExtension(%s)", error, custom)
+func TestTypeByExtensionCase(t *testing.T) {
+	const custom = "test/test; charset=iso-8859-1"
+	const caps = "test/test; WAS=ALLCAPS"
+	if err := AddExtensionType(".TEST", caps); err != nil {
+		t.Fatalf("error %s for AddExtension(%s)", err, custom)
 	}
-	// test with same capitalization
-	if registered := TypeByExtension(".tesT"); registered != custom {
-		t.Fatalf("registered %s instead of %s", registered, custom)
+	if err := AddExtensionType(".tesT", custom); err != nil {
+		t.Fatalf("error %s for AddExtension(%s)", err, custom)
 	}
-	// test with different capitalization
-	if registered := TypeByExtension(".Test"); registered != custom {
-		t.Fatalf("registered %s instead of %s", registered, custom)
+
+	// case-sensitive lookup
+	if got := TypeByExtension(".tesT"); got != custom {
+		t.Fatalf("for .tesT, got %q; want %q", got, custom)
+	}
+	if got := TypeByExtension(".TEST"); got != caps {
+		t.Fatalf("for .TEST, got %q; want %s", got, caps)
+	}
+
+	// case-insensitive
+	if got := TypeByExtension(".TesT"); got != custom {
+		t.Fatalf("for .TesT, got %q; want %q", got, custom)
+	}
+}
+
+func TestLookupMallocs(t *testing.T) {
+	n := testing.AllocsPerRun(10000, func() {
+		TypeByExtension(".html")
+		TypeByExtension(".HtML")
+	})
+	if n > 0 {
+		t.Errorf("allocs = %v; want 0", n)
 	}
 }

From e66ff2b9080669373704914191abf2ee5f65eb75 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 28 Aug 2014 12:16:06 -0700
Subject: [PATCH 262/423] go/token: implement PositionFor accessors

Package addition.

PositionFor permits access to both, positions
adjusted by //line comments (like the Position
accessors), and unadjusted "raw" positions
unaffected by //line comments.

Raw positions are required for correct formatting
of source code via go/printer which until now had
to manually fix adjusted positions.

Fixes #7702.

LGTM=adonovan
R=adonovan
CC=golang-codereviews
https://golang.org/cl/135110044
---
 src/pkg/go/token/position.go      |  51 ++++++++++-----
 src/pkg/go/token/position_test.go | 101 +++++++++++++++++++++++-------
 2 files changed, 116 insertions(+), 36 deletions(-)

diff --git a/src/pkg/go/token/position.go b/src/pkg/go/token/position.go
index e6f0ae6a67..82d90eeb72 100644
--- a/src/pkg/go/token/position.go
+++ b/src/pkg/go/token/position.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(gri) consider making this a separate package outside the go directory.
-
 package token
 
 import (
@@ -184,6 +182,7 @@ func (f *File) SetLines(lines []int) bool {
 }
 
 // SetLinesForContent sets the line offsets for the given file content.
+// It ignores position-altering //line comments.
 func (f *File) SetLinesForContent(content []byte) {
 	var lines []int
 	line := 0
@@ -255,7 +254,6 @@ func (f *File) Offset(p Pos) int {
 // p must be a Pos value in that file or NoPos.
 //
 func (f *File) Line(p Pos) int {
-	// TODO(gri) this can be implemented much more efficiently
 	return f.Position(p).Line
 }
 
@@ -263,13 +261,16 @@ func searchLineInfos(a []lineInfo, x int) int {
 	return sort.Search(len(a), func(i int) bool { return a[i].Offset > x }) - 1
 }
 
-// info returns the file name, line, and column number for a file offset.
-func (f *File) info(offset int) (filename string, line, column int) {
+// unpack returns the filename and line and column number for a file offset.
+// If adjusted is set, unpack will return the filename and line information
+// possibly adjusted by //line comments; otherwise those comments are ignored.
+//
+func (f *File) unpack(offset int, adjusted bool) (filename string, line, column int) {
 	filename = f.name
 	if i := searchInts(f.lines, offset); i >= 0 {
 		line, column = i+1, offset-f.lines[i]+1
 	}
-	if len(f.infos) > 0 {
+	if adjusted && len(f.infos) > 0 {
 		// almost no files have extra line infos
 		if i := searchLineInfos(f.infos, offset); i >= 0 {
 			alt := &f.infos[i]
@@ -282,26 +283,35 @@ func (f *File) info(offset int) (filename string, line, column int) {
 	return
 }
 
-func (f *File) position(p Pos) (pos Position) {
+func (f *File) position(p Pos, adjusted bool) (pos Position) {
 	offset := int(p) - f.base
 	pos.Offset = offset
-	pos.Filename, pos.Line, pos.Column = f.info(offset)
+	pos.Filename, pos.Line, pos.Column = f.unpack(offset, adjusted)
 	return
 }
 
-// Position returns the Position value for the given file position p;
-// p must be a Pos value in that file or NoPos.
+// PositionFor returns the Position value for the given file position p.
+// If adjusted is set, the position may be adjusted by position-altering
+// //line comments; otherwise those comments are ignored.
+// p must be a Pos value in f or NoPos.
 //
-func (f *File) Position(p Pos) (pos Position) {
+func (f *File) PositionFor(p Pos, adjusted bool) (pos Position) {
 	if p != NoPos {
 		if int(p) < f.base || int(p) > f.base+f.size {
 			panic("illegal Pos value")
 		}
-		pos = f.position(p)
+		pos = f.position(p, adjusted)
 	}
 	return
 }
 
+// Position returns the Position value for the given file position p.
+// Calling f.Position(p) is equivalent to calling f.PositionFor(p, true).
+//
+func (f *File) Position(p Pos) (pos Position) {
+	return f.PositionFor(p, true)
+}
+
 // -----------------------------------------------------------------------------
 // FileSet
 
@@ -427,16 +437,27 @@ func (s *FileSet) File(p Pos) (f *File) {
 	return
 }
 
-// Position converts a Pos in the fileset into a general Position.
-func (s *FileSet) Position(p Pos) (pos Position) {
+// PositionFor converts a Pos p in the fileset into a Position value.
+// If adjusted is set, the position may be adjusted by position-altering
+// //line comments; otherwise those comments are ignored.
+// p must be a Pos value in s or NoPos.
+//
+func (s *FileSet) PositionFor(p Pos, adjusted bool) (pos Position) {
 	if p != NoPos {
 		if f := s.file(p); f != nil {
-			pos = f.position(p)
+			pos = f.position(p, adjusted)
 		}
 	}
 	return
 }
 
+// Position converts a Pos p in the fileset into a Position value.
+// Calling s.Position(p) is equivalent to calling s.PositionFor(p, true).
+//
+func (s *FileSet) Position(p Pos) (pos Position) {
+	return s.PositionFor(p, true)
+}
+
 // -----------------------------------------------------------------------------
 // Helper functions
 
diff --git a/src/pkg/go/token/position_test.go b/src/pkg/go/token/position_test.go
index ef6cfd93c2..d26939ce27 100644
--- a/src/pkg/go/token/position_test.go
+++ b/src/pkg/go/token/position_test.go
@@ -11,18 +11,18 @@ import (
 	"testing"
 )
 
-func checkPos(t *testing.T, msg string, p, q Position) {
-	if p.Filename != q.Filename {
-		t.Errorf("%s: expected filename = %q; got %q", msg, q.Filename, p.Filename)
+func checkPos(t *testing.T, msg string, got, want Position) {
+	if got.Filename != want.Filename {
+		t.Errorf("%s: got filename = %q; want %q", msg, got.Filename, want.Filename)
 	}
-	if p.Offset != q.Offset {
-		t.Errorf("%s: expected offset = %d; got %d", msg, q.Offset, p.Offset)
+	if got.Offset != want.Offset {
+		t.Errorf("%s: got offset = %d; want %d", msg, got.Offset, want.Offset)
 	}
-	if p.Line != q.Line {
-		t.Errorf("%s: expected line = %d; got %d", msg, q.Line, p.Line)
+	if got.Line != want.Line {
+		t.Errorf("%s: got line = %d; want %d", msg, got.Line, want.Line)
 	}
-	if p.Column != q.Column {
-		t.Errorf("%s: expected column = %d; got %d", msg, q.Column, p.Column)
+	if got.Column != want.Column {
+		t.Errorf("%s: got column = %d; want %d", msg, got.Column, want.Column)
 	}
 }
 
@@ -68,7 +68,7 @@ func verifyPositions(t *testing.T, fset *FileSet, f *File, lines []int) {
 		p := f.Pos(offs)
 		offs2 := f.Offset(p)
 		if offs2 != offs {
-			t.Errorf("%s, Offset: expected offset %d; got %d", f.Name(), offs, offs2)
+			t.Errorf("%s, Offset: got offset %d; want %d", f.Name(), offs2, offs)
 		}
 		line, col := linecol(lines, offs)
 		msg := fmt.Sprintf("%s (offs = %d, p = %d)", f.Name(), offs, p)
@@ -93,16 +93,16 @@ func TestPositions(t *testing.T) {
 	for _, test := range tests {
 		// verify consistency of test case
 		if test.source != nil && len(test.source) != test.size {
-			t.Errorf("%s: inconsistent test case: expected file size %d; got %d", test.filename, test.size, len(test.source))
+			t.Errorf("%s: inconsistent test case: got file size %d; want %d", test.filename, len(test.source), test.size)
 		}
 
 		// add file and verify name and size
 		f := fset.AddFile(test.filename, fset.Base()+delta, test.size)
 		if f.Name() != test.filename {
-			t.Errorf("expected filename %q; got %q", test.filename, f.Name())
+			t.Errorf("got filename %q; want %q", f.Name(), test.filename)
 		}
 		if f.Size() != test.size {
-			t.Errorf("%s: expected file size %d; got %d", f.Name(), test.size, f.Size())
+			t.Errorf("%s: got file size %d; want %d", f.Name(), f.Size(), test.size)
 		}
 		if fset.File(f.Pos(0)) != f {
 			t.Errorf("%s: f.Pos(0) was not found in f", f.Name())
@@ -112,12 +112,12 @@ func TestPositions(t *testing.T) {
 		for i, offset := range test.lines {
 			f.AddLine(offset)
 			if f.LineCount() != i+1 {
-				t.Errorf("%s, AddLine: expected line count %d; got %d", f.Name(), i+1, f.LineCount())
+				t.Errorf("%s, AddLine: got line count %d; want %d", f.Name(), f.LineCount(), i+1)
 			}
 			// adding the same offset again should be ignored
 			f.AddLine(offset)
 			if f.LineCount() != i+1 {
-				t.Errorf("%s, AddLine: expected unchanged line count %d; got %d", f.Name(), i+1, f.LineCount())
+				t.Errorf("%s, AddLine: got unchanged line count %d; want %d", f.Name(), f.LineCount(), i+1)
 			}
 			verifyPositions(t, fset, f, test.lines[0:i+1])
 		}
@@ -127,7 +127,7 @@ func TestPositions(t *testing.T) {
 			t.Errorf("%s: SetLines failed", f.Name())
 		}
 		if f.LineCount() != len(test.lines) {
-			t.Errorf("%s, SetLines: expected line count %d; got %d", f.Name(), len(test.lines), f.LineCount())
+			t.Errorf("%s, SetLines: got line count %d; want %d", f.Name(), f.LineCount(), len(test.lines))
 		}
 		verifyPositions(t, fset, f, test.lines)
 
@@ -139,7 +139,7 @@ func TestPositions(t *testing.T) {
 		}
 		f.SetLinesForContent(src)
 		if f.LineCount() != len(test.lines) {
-			t.Errorf("%s, SetLinesForContent: expected line count %d; got %d", f.Name(), len(test.lines), f.LineCount())
+			t.Errorf("%s, SetLinesForContent: got line count %d; want %d", f.Name(), f.LineCount(), len(test.lines))
 		}
 		verifyPositions(t, fset, f, test.lines)
 	}
@@ -177,13 +177,13 @@ func TestFiles(t *testing.T) {
 		j := 0
 		fset.Iterate(func(f *File) bool {
 			if f.Name() != tests[j].filename {
-				t.Errorf("expected filename = %s; got %s", tests[j].filename, f.Name())
+				t.Errorf("got filename = %s; want %s", f.Name(), tests[j].filename)
 			}
 			j++
 			return true
 		})
 		if j != i+1 {
-			t.Errorf("expected %d files; got %d", i+1, j)
+			t.Errorf("got %d files; want %d", j, i+1)
 		}
 	}
 }
@@ -195,7 +195,7 @@ func TestFileSetPastEnd(t *testing.T) {
 		fset.AddFile(test.filename, fset.Base(), test.size)
 	}
 	if f := fset.File(Pos(fset.Base())); f != nil {
-		t.Errorf("expected nil, got %v", f)
+		t.Errorf("got %v, want nil", f)
 	}
 }
 
@@ -209,7 +209,7 @@ func TestFileSetCacheUnlikely(t *testing.T) {
 	for file, pos := range offsets {
 		f := fset.File(Pos(pos))
 		if f.Name() != file {
-			t.Errorf("expecting %q at position %d, got %q", file, pos, f.Name())
+			t.Errorf("got %q at position %d, want %q", f.Name(), pos, file)
 		}
 	}
 }
@@ -236,3 +236,62 @@ func TestFileSetRace(t *testing.T) {
 	}
 	stop.Wait()
 }
+
+func TestPositionFor(t *testing.T) {
+	src := []byte(`
+foo
+b
+ar
+//line :100
+foobar
+//line bar:3
+done
+`)
+
+	const filename = "foo"
+	fset := NewFileSet()
+	f := fset.AddFile(filename, fset.Base(), len(src))
+	f.SetLinesForContent(src)
+
+	// verify position info
+	for i, offs := range f.lines {
+		got1 := f.PositionFor(f.Pos(offs), false)
+		got2 := f.PositionFor(f.Pos(offs), true)
+		got3 := f.Position(f.Pos(offs))
+		want := Position{filename, offs, i + 1, 1}
+		checkPos(t, "1. PositionFor unadjusted", got1, want)
+		checkPos(t, "1. PositionFor adjusted", got2, want)
+		checkPos(t, "1. Position", got3, want)
+	}
+
+	// manually add //line info on lines l1, l2
+	const l1, l2 = 5, 7
+	f.AddLineInfo(f.lines[l1-1], "", 100)
+	f.AddLineInfo(f.lines[l2-1], "bar", 3)
+
+	// unadjusted position info must remain unchanged
+	for i, offs := range f.lines {
+		got1 := f.PositionFor(f.Pos(offs), false)
+		want := Position{filename, offs, i + 1, 1}
+		checkPos(t, "2. PositionFor unadjusted", got1, want)
+	}
+
+	// adjusted position info should have changed
+	for i, offs := range f.lines {
+		got2 := f.PositionFor(f.Pos(offs), true)
+		got3 := f.Position(f.Pos(offs))
+		want := Position{filename, offs, i + 1, 1}
+		// manually compute wanted filename and line
+		line := want.Line
+		if i+1 >= l1 {
+			want.Filename = ""
+			want.Line = line - l1 + 100
+		}
+		if i+1 >= l2 {
+			want.Filename = "bar"
+			want.Line = line - l2 + 3
+		}
+		checkPos(t, "3. PositionFor adjusted", got2, want)
+		checkPos(t, "3. Position", got3, want)
+	}
+}

From c46bcd4d13492d3588638ea3ea4c752166709044 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Thu, 28 Aug 2014 13:23:10 -0700
Subject: [PATCH 263/423] runtime: move finalizer thread to Go.

LGTM=dvyukov
R=golang-codereviews, dvyukov, khr
CC=golang-codereviews
https://golang.org/cl/124630043
---
 src/cmd/cc/godefs.c       |  16 +--
 src/pkg/runtime/iface.go  |   3 +-
 src/pkg/runtime/malloc.c  | 115 ++++---------------
 src/pkg/runtime/malloc.go | 234 ++++++++++++++++++++++++++++++++++++--
 src/pkg/runtime/malloc.h  |  23 ++++
 src/pkg/runtime/mgc0.c    | 186 ++++--------------------------
 src/pkg/runtime/proc.go   |   2 +-
 src/pkg/runtime/stubs.go  |   5 +
 src/pkg/runtime/thunk.s   |   3 +
 9 files changed, 303 insertions(+), 284 deletions(-)

diff --git a/src/cmd/cc/godefs.c b/src/cmd/cc/godefs.c
index 20915ca8ca..1f2a9d7e04 100644
--- a/src/cmd/cc/godefs.c
+++ b/src/cmd/cc/godefs.c
@@ -154,7 +154,6 @@ static void
 printtypename(Type *t)
 {
 	Sym *s;
-	Type *t1;
 	int w;
 	char *n;
 
@@ -228,19 +227,8 @@ printtypename(Type *t)
 			Bprint(&outbuf, "%U", n);
 		break;
 	case TFUNC:
-		Bprint(&outbuf, "func(");
-		for(t1 = t->down; t1 != T; t1 = t1->down) {
-			if(t1->etype == TVOID)
-				break;
-			if(t1 != t->down)
-				Bprint(&outbuf, ", ");
-			printtypename(t1);
-		}
-		Bprint(&outbuf, ")");
-		if(t->link && t->link->etype != TVOID) {
-			Bprint(&outbuf, " ");
-			printtypename(t->link);
-		}
+		// There's no equivalent to a C function in the Go world.
+		Bprint(&outbuf, "unsafe.Pointer");
 		break;
 	case TDOT:
 		Bprint(&outbuf, "...interface{}");
diff --git a/src/pkg/runtime/iface.go b/src/pkg/runtime/iface.go
index 57882fb704..f60b6a79cc 100644
--- a/src/pkg/runtime/iface.go
+++ b/src/pkg/runtime/iface.go
@@ -97,8 +97,7 @@ search:
 			t := (*method)(add(unsafe.Pointer(x), unsafe.Sizeof(uncommontype{})+uintptr(j)*unsafe.Sizeof(method{})))
 			if t.mtyp == itype && t.name == iname && t.pkgpath == ipkgpath {
 				if m != nil {
-					f := (*func())(add(unsafe.Pointer(m), unsafe.Sizeof(itab{})+uintptr(k)*ptrSize))
-					*f = t.ifn
+					*(*unsafe.Pointer)(add(unsafe.Pointer(m), unsafe.Sizeof(itab{})+uintptr(k)*ptrSize)) = t.ifn
 				}
 				goto nextimethod
 			}
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 8eeebe4692..143d9e5e9e 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -423,107 +423,36 @@ runtime·cnewarray(Type *typ, intgo n)
 	return cnew(typ, n);
 }
 
-static void
-setFinalizer(Eface obj, Eface finalizer)
-{
-	byte *base;
-	uintptr size;
-	FuncType *ft;
-	int32 i;
-	uintptr nret;
-	Type *t;
-	Type *fint;
-	PtrType *ot;
-	Iface iface;
-
-	if(obj.type == nil) {
-		runtime·printf("runtime.SetFinalizer: first argument is nil interface\n");
-		goto throw;
-	}
-	if((obj.type->kind&KindMask) != KindPtr) {
-		runtime·printf("runtime.SetFinalizer: first argument is %S, not pointer\n", *obj.type->string);
-		goto throw;
-	}
-	ot = (PtrType*)obj.type;
-	// As an implementation detail we do not run finalizers for zero-sized objects,
-	// because we use &runtime·zerobase for all such allocations.
-	if(ot->elem != nil && ot->elem->size == 0)
-		return;
-	// The following check is required for cases when a user passes a pointer to composite literal,
-	// but compiler makes it a pointer to global. For example:
-	//	var Foo = &Object{}
-	//	func main() {
-	//		runtime.SetFinalizer(Foo, nil)
-	//	}
-	// See issue 7656.
-	if((byte*)obj.data < runtime·mheap.arena_start || runtime·mheap.arena_used <= (byte*)obj.data)
-		return;
-	if(!runtime·mlookup(obj.data, &base, &size, nil) || obj.data != base) {
-		// As an implementation detail we allow to set finalizers for an inner byte
-		// of an object if it could come from tiny alloc (see mallocgc for details).
-		if(ot->elem == nil || (ot->elem->kind&KindNoPointers) == 0 || ot->elem->size >= TinySize) {
-			runtime·printf("runtime.SetFinalizer: pointer not at beginning of allocated block (%p)\n", obj.data);
-			goto throw;
-		}
-	}
-	if(finalizer.type != nil) {
-		runtime·createfing();
-		if((finalizer.type->kind&KindMask) != KindFunc)
-			goto badfunc;
-		ft = (FuncType*)finalizer.type;
-		if(ft->dotdotdot || ft->in.len != 1)
-			goto badfunc;
-		fint = *(Type**)ft->in.array;
-		if(fint == obj.type) {
-			// ok - same type
-		} else if((fint->kind&KindMask) == KindPtr && (fint->x == nil || fint->x->name == nil || obj.type->x == nil || obj.type->x->name == nil) && ((PtrType*)fint)->elem == ((PtrType*)obj.type)->elem) {
-			// ok - not same type, but both pointers,
-			// one or the other is unnamed, and same element type, so assignable.
-		} else if((fint->kind&KindMask) == KindInterface && ((InterfaceType*)fint)->mhdr.len == 0) {
-			// ok - satisfies empty interface
-		} else if((fint->kind&KindMask) == KindInterface && runtime·ifaceE2I2((InterfaceType*)fint, obj, &iface)) {
-			// ok - satisfies non-empty interface
-		} else
-			goto badfunc;
-
-		// compute size needed for return parameters
-		nret = 0;
-		for(i=0; i<ft->out.len; i++) {
-			t = ((Type**)ft->out.array)[i];
-			nret = ROUND(nret, t->align) + t->size;
-		}
-		nret = ROUND(nret, sizeof(void*));
-		ot = (PtrType*)obj.type;
-		if(!runtime·addfinalizer(obj.data, finalizer.data, nret, fint, ot)) {
-			runtime·printf("runtime.SetFinalizer: finalizer already set\n");
-			goto throw;
-		}
-	} else {
-		// NOTE: asking to remove a finalizer when there currently isn't one set is OK.
-		runtime·removefinalizer(obj.data);
-	}
-	return;
-
-badfunc:
-	runtime·printf("runtime.SetFinalizer: cannot pass %S to finalizer %S\n", *obj.type->string, *finalizer.type->string);
-throw:
-	runtime·throw("runtime.SetFinalizer");
-}
-
 void
 runtime·setFinalizer_m(void)
 {
-	Eface obj, finalizer;
+	FuncVal *fn;
+	void *arg;
+	uintptr nret;
+	Type *fint;
+	PtrType *ot;
 
-	obj.type = g->m->ptrarg[0];
-	obj.data = g->m->ptrarg[1];
-	finalizer.type = g->m->ptrarg[2];
-	finalizer.data = g->m->ptrarg[3];
+	fn = g->m->ptrarg[0];
+	arg = g->m->ptrarg[1];
+	nret = g->m->scalararg[0];
+	fint = g->m->ptrarg[2];
+	ot = g->m->ptrarg[3];
 	g->m->ptrarg[0] = nil;
 	g->m->ptrarg[1] = nil;
 	g->m->ptrarg[2] = nil;
 	g->m->ptrarg[3] = nil;
-	setFinalizer(obj, finalizer);
+
+	g->m->scalararg[0] = runtime·addfinalizer(arg, fn, nret, fint, ot);
+}
+
+void
+runtime·removeFinalizer_m(void)
+{
+	void *p;
+
+	p = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	runtime·removefinalizer(p);
 }
 
 // mcallable cache refill
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index ebc45fa2f7..7f344c9164 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -35,6 +35,8 @@ const (
 	bitBoundary = 1
 	bitMarked   = 2
 	bitMask     = bitBoundary | bitMarked
+
+	mSpanInUse = 0
 )
 
 // Page number (address>>pageShift)
@@ -539,27 +541,239 @@ func GC() {
 // If a finalizer must run for a long time, it should do so by starting
 // a new goroutine.
 func SetFinalizer(obj interface{}, finalizer interface{}) {
-	// We do just enough work here to make the mcall type safe.
-	// The rest is done on the M stack.
 	e := (*eface)(unsafe.Pointer(&obj))
-	typ := e._type
-	if typ == nil {
+	etyp := e._type
+	if etyp == nil {
 		gothrow("runtime.SetFinalizer: first argument is nil")
 	}
-	if typ.kind&kindMask != kindPtr {
-		gothrow("runtime.SetFinalizer: first argument is " + *typ._string + ", not pointer")
+	if etyp.kind&kindMask != kindPtr {
+		gothrow("runtime.SetFinalizer: first argument is " + *etyp._string + ", not pointer")
+	}
+	ot := (*ptrtype)(unsafe.Pointer(etyp))
+	if ot.elem == nil {
+		gothrow("nil elem type!")
+	}
+
+	// As an implementation detail we do not run finalizers for zero-sized objects,
+	// because we use &runtime·zerobase for all such allocations.
+	if ot.elem.size == 0 {
+		return
+	}
+
+	// find the containing object
+	_, base, _ := findObject(e.data)
+
+	// The following check is required for cases when a user passes a pointer to composite
+	// literal, but compiler makes it a pointer to global. For example:
+	//	var Foo = &Object{}
+	//	func main() {
+	//		runtime.SetFinalizer(Foo, nil)
+	//	}
+	// See issue 7656.
+	if base == nil {
+		return
+	}
+
+	if e.data != base {
+		// As an implementation detail we allow to set finalizers for an inner byte
+		// of an object if it could come from tiny alloc (see mallocgc for details).
+		if ot.elem == nil || ot.elem.kind&kindNoPointers == 0 || ot.elem.size >= maxTinySize {
+			gothrow("runtime.SetFinalizer: pointer not at beginning of allocated block")
+		}
 	}
 
 	f := (*eface)(unsafe.Pointer(&finalizer))
 	ftyp := f._type
-	if ftyp != nil && ftyp.kind&kindMask != kindFunc {
+	if ftyp == nil {
+		// switch to M stack and remove finalizer
+		mp := acquirem()
+		mp.ptrarg[0] = e.data
+		onM(&removeFinalizer_m)
+		releasem(mp)
+		return
+	}
+
+	if ftyp.kind&kindMask != kindFunc {
 		gothrow("runtime.SetFinalizer: second argument is " + *ftyp._string + ", not a function")
 	}
+	ft := (*functype)(unsafe.Pointer(ftyp))
+	ins := *(*[]*_type)(unsafe.Pointer(&ft.in))
+	if ft.dotdotdot || len(ins) != 1 {
+		gothrow("runtime.SetFinalizer: cannot pass " + *etyp._string + " to finalizer " + *ftyp._string)
+	}
+	fint := ins[0]
+	switch {
+	case fint == etyp:
+		// ok - same type
+		goto okarg
+	case fint.kind&kindMask == kindPtr:
+		if (fint.x == nil || fint.x.name == nil || etyp.x == nil || etyp.x.name == nil) && (*ptrtype)(unsafe.Pointer(fint)).elem == ot.elem {
+			// ok - not same type, but both pointers,
+			// one or the other is unnamed, and same element type, so assignable.
+			goto okarg
+		}
+	case fint.kind&kindMask == kindInterface:
+		ityp := (*interfacetype)(unsafe.Pointer(fint))
+		if len(ityp.mhdr) == 0 {
+			// ok - satisfies empty interface
+			goto okarg
+		}
+		if _, ok := assertE2I2(ityp, obj); ok {
+			goto okarg
+		}
+	}
+	gothrow("runtime.SetFinalizer: cannot pass " + *etyp._string + " to finalizer " + *ftyp._string)
+okarg:
+	// compute size needed for return parameters
+	nret := uintptr(0)
+	for _, t := range *(*[]*_type)(unsafe.Pointer(&ft.out)) {
+		nret = round(nret, uintptr(t.align)) + uintptr(t.size)
+	}
+	nret = round(nret, ptrSize)
+
+	// make sure we have a finalizer goroutine
+	createfing()
+
+	// switch to M stack to add finalizer record
 	mp := acquirem()
-	mp.ptrarg[0] = unsafe.Pointer(typ)
+	mp.ptrarg[0] = f.data
 	mp.ptrarg[1] = e.data
-	mp.ptrarg[2] = unsafe.Pointer(ftyp)
-	mp.ptrarg[3] = f.data
+	mp.scalararg[0] = nret
+	mp.ptrarg[2] = unsafe.Pointer(fint)
+	mp.ptrarg[3] = unsafe.Pointer(ot)
 	onM(&setFinalizer_m)
+	if mp.scalararg[0] != 1 {
+		gothrow("runtime.SetFinalizer: finalizer already set")
+	}
 	releasem(mp)
 }
+
+// round n up to a multiple of a.  a must be a power of 2.
+func round(n, a uintptr) uintptr {
+	return (n + a - 1) &^ (a - 1)
+}
+
+// Look up pointer v in heap.  Return the span containing the object,
+// the start of the object, and the size of the object.  If the object
+// does not exist, return nil, nil, 0.
+func findObject(v unsafe.Pointer) (s *mspan, x unsafe.Pointer, n uintptr) {
+	c := gomcache()
+	c.local_nlookup++
+	if ptrSize == 4 && c.local_nlookup >= 1<<30 {
+		// purge cache stats to prevent overflow
+		lock(&mheap_.lock)
+		purgecachedstats(c)
+		unlock(&mheap_.lock)
+	}
+
+	// find span
+	arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
+	arena_used := uintptr(unsafe.Pointer(mheap_.arena_used))
+	if uintptr(v) < arena_start || uintptr(v) >= arena_used {
+		return
+	}
+	p := uintptr(v) >> pageShift
+	q := p - arena_start>>pageShift
+	s = *(**mspan)(add(unsafe.Pointer(mheap_.spans), q*ptrSize))
+	if s == nil {
+		return
+	}
+	x = unsafe.Pointer(uintptr(s.start) << pageShift)
+
+	if uintptr(v) < uintptr(x) || uintptr(v) >= uintptr(unsafe.Pointer(s.limit)) || s.state != mSpanInUse {
+		s = nil
+		x = nil
+		return
+	}
+
+	n = uintptr(s.elemsize)
+	if s.sizeclass != 0 {
+		x = add(x, (uintptr(v)-uintptr(x))/n*n)
+	}
+	return
+}
+
+var fingCreate uint32
+
+func createfing() {
+	// start the finalizer goroutine exactly once
+	if fingCreate == 0 && cas(&fingCreate, 0, 1) {
+		go runfinq()
+	}
+}
+
+// This is the goroutine that runs all of the finalizers
+func runfinq() {
+	var (
+		frame    unsafe.Pointer
+		framecap uintptr
+	)
+
+	for {
+		lock(&finlock)
+		fb := finq
+		finq = nil
+		if fb == nil {
+			gp := getg()
+			fing = gp
+			fingwait = true
+			gp.issystem = true
+			goparkunlock(&finlock, "finalizer wait")
+			gp.issystem = false
+			continue
+		}
+		unlock(&finlock)
+		if raceenabled {
+			racefingo()
+		}
+		for fb != nil {
+			for i := int32(0); i < fb.cnt; i++ {
+				f := (*finalizer)(add(unsafe.Pointer(&fb.fin), uintptr(i)*unsafe.Sizeof(finalizer{})))
+
+				framesz := unsafe.Sizeof((interface{})(nil)) + uintptr(f.nret)
+				if framecap < framesz {
+					// The frame does not contain pointers interesting for GC,
+					// all not yet finalized objects are stored in finq.
+					// If we do not mark it as FlagNoScan,
+					// the last finalized object is not collected.
+					frame = gomallocgc(framesz, nil, flagNoScan)
+					framecap = framesz
+				}
+
+				if f.fint == nil {
+					gothrow("missing type in runfinq")
+				}
+				switch f.fint.kind & kindMask {
+				case kindPtr:
+					// direct use of pointer
+					*(*unsafe.Pointer)(frame) = f.arg
+				case kindInterface:
+					ityp := (*interfacetype)(unsafe.Pointer(f.fint))
+					// set up with empty interface
+					(*eface)(frame)._type = &f.ot.typ
+					(*eface)(frame).data = f.arg
+					if len(ityp.mhdr) != 0 {
+						// convert to interface with methods
+						// this conversion is guaranteed to succeed - we checked in SetFinalizer
+						*(*fInterface)(frame) = assertE2I(ityp, *(*interface{})(frame))
+					}
+				default:
+					gothrow("bad kind in runfinq")
+				}
+				reflectcall(unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
+
+				// drop finalizer queue references to finalized object
+				f.fn = nil
+				f.arg = nil
+				f.ot = nil
+			}
+			fb.cnt = 0
+			next := fb.next
+			lock(&finlock)
+			fb.next = finc
+			finc = fb
+			unlock(&finlock)
+			fb = next
+		}
+	}
+}
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 0d7cd475d8..19ea846dd1 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -551,9 +551,32 @@ void	runtime·gchelper(void);
 void	runtime·createfing(void);
 G*	runtime·wakefing(void);
 void	runtime·getgcmask(byte*, Type*, byte**, uintptr*);
+
+typedef struct Finalizer Finalizer;
+struct Finalizer
+{
+	FuncVal *fn;	// function to call
+	void *arg;	// ptr to object
+	uintptr nret;	// bytes of return values from fn
+	Type *fint;	// type of first argument of fn
+	PtrType *ot;	// type of ptr to object
+};
+
+typedef struct FinBlock FinBlock;
+struct FinBlock
+{
+	FinBlock *alllink;
+	FinBlock *next;
+	int32 cnt;
+	int32 cap;
+	Finalizer fin[1];
+};
+extern Mutex	runtime·finlock;	// protects the following variables
 extern G*	runtime·fing;
 extern bool	runtime·fingwait;
 extern bool	runtime·fingwake;
+extern FinBlock	*runtime·finq;		// list of finalizers that are to be executed
+extern FinBlock	*runtime·finc;		// cache of free blocks
 
 void	runtime·setprofilebucket(void *p, Bucket *b);
 
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 12d45d4baf..4933712571 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -138,26 +138,6 @@ struct Workbuf
 	byte*	obj[(WorkbufSize-sizeof(LFNode)-sizeof(uintptr))/PtrSize];
 };
 
-typedef struct Finalizer Finalizer;
-struct Finalizer
-{
-	FuncVal *fn;
-	void *arg;
-	uintptr nret;
-	Type *fint;
-	PtrType *ot;
-};
-
-typedef struct FinBlock FinBlock;
-struct FinBlock
-{
-	FinBlock *alllink;
-	FinBlock *next;
-	int32 cnt;
-	int32 cap;
-	Finalizer fin[1];
-};
-
 extern byte runtime·data[];
 extern byte runtime·edata[];
 extern byte runtime·bss[];
@@ -166,18 +146,19 @@ extern byte runtime·ebss[];
 extern byte runtime·gcdata[];
 extern byte runtime·gcbss[];
 
-static Mutex	finlock;	// protects the following variables
-static FinBlock	*finq;		// list of finalizers that are to be executed
-static FinBlock	*finc;		// cache of free blocks
-static FinBlock	*allfin;	// list of all blocks
+Mutex	runtime·finlock;	// protects the following variables
+G*	runtime·fing;		// goroutine that runs finalizers
+FinBlock*	runtime·finq;	// list of finalizers that are to be executed
+FinBlock*	runtime·finc;	// cache of free blocks
 bool	runtime·fingwait;
 bool	runtime·fingwake;
+static FinBlock	*allfin;	// list of all blocks
+
 BitVector	runtime·gcdatamask;
 BitVector	runtime·gcbssmask;
 
 static Mutex	gclock;
 
-static void	runfinq(void);
 static void	bgsweep(void);
 static Workbuf* getempty(Workbuf*);
 static Workbuf* getfull(Workbuf*);
@@ -189,7 +170,6 @@ static bool	scanframe(Stkframe *frame, void *unused);
 static void	scanstack(G *gp);
 static BitVector	unrollglobgcprog(byte *prog, uintptr size);
 
-static FuncVal runfinqv = {runfinq};
 static FuncVal bgsweepv = {bgsweep};
 
 static struct {
@@ -804,28 +784,28 @@ runtime·queuefinalizer(byte *p, FuncVal *fn, uintptr nret, Type *fint, PtrType
 	FinBlock *block;
 	Finalizer *f;
 
-	runtime·lock(&finlock);
-	if(finq == nil || finq->cnt == finq->cap) {
-		if(finc == nil) {
-			finc = runtime·persistentalloc(FinBlockSize, 0, &mstats.gc_sys);
-			finc->cap = (FinBlockSize - sizeof(FinBlock)) / sizeof(Finalizer) + 1;
-			finc->alllink = allfin;
-			allfin = finc;
+	runtime·lock(&runtime·finlock);
+	if(runtime·finq == nil || runtime·finq->cnt == runtime·finq->cap) {
+		if(runtime·finc == nil) {
+			runtime·finc = runtime·persistentalloc(FinBlockSize, 0, &mstats.gc_sys);
+			runtime·finc->cap = (FinBlockSize - sizeof(FinBlock)) / sizeof(Finalizer) + 1;
+			runtime·finc->alllink = allfin;
+			allfin = runtime·finc;
 		}
-		block = finc;
-		finc = block->next;
-		block->next = finq;
-		finq = block;
+		block = runtime·finc;
+		runtime·finc = block->next;
+		block->next = runtime·finq;
+		runtime·finq = block;
 	}
-	f = &finq->fin[finq->cnt];
-	finq->cnt++;
+	f = &runtime·finq->fin[runtime·finq->cnt];
+	runtime·finq->cnt++;
 	f->fn = fn;
 	f->nret = nret;
 	f->fint = fint;
 	f->ot = ot;
 	f->arg = p;
 	runtime·fingwake = true;
-	runtime·unlock(&finlock);
+	runtime·unlock(&runtime·finlock);
 }
 
 void
@@ -1624,141 +1604,19 @@ gchelperstart(void)
 		runtime·throw("gchelper not running on g0 stack");
 }
 
-static void
-runfinq(void)
-{
-	Finalizer *f;
-	FinBlock *fb, *next;
-	byte *frame;
-	uint32 framesz, framecap, i;
-	Eface *ef, ef1;
-
-	// This function blocks for long periods of time, and because it is written in C
-	// we have no liveness information. Zero everything so that uninitialized pointers
-	// do not cause memory leaks.
-	f = nil;
-	fb = nil;
-	next = nil;
-	frame = nil;
-	framecap = 0;
-	framesz = 0;
-	i = 0;
-	ef = nil;
-	ef1.type = nil;
-	ef1.data = nil;
-	
-	// force flush to memory
-	USED(&f);
-	USED(&fb);
-	USED(&next);
-	USED(&framesz);
-	USED(&i);
-	USED(&ef);
-	USED(&ef1);
-
-	for(;;) {
-		runtime·lock(&finlock);
-		fb = finq;
-		finq = nil;
-		if(fb == nil) {
-			runtime·fingwait = true;
-			g->issystem = true;
-			runtime·parkunlock(&finlock, runtime·gostringnocopy((byte*)"finalizer wait"));
-			g->issystem = false;
-			continue;
-		}
-		runtime·unlock(&finlock);
-		if(raceenabled)
-			runtime·racefingo();
-		for(; fb; fb=next) {
-			next = fb->next;
-			for(i=0; i<fb->cnt; i++) {
-				f = &fb->fin[i];
-				framesz = sizeof(Eface) + f->nret;
-				if(framecap < framesz) {
-					// The frame does not contain pointers interesting for GC,
-					// all not yet finalized objects are stored in finq.
-					// If we do not mark it as FlagNoScan,
-					// the last finalized object is not collected.
-					frame = runtime·mallocgc(framesz, 0, FlagNoScan);
-					framecap = framesz;
-				}
-				if(f->fint == nil)
-					runtime·throw("missing type in runfinq");
-				if((f->fint->kind&KindMask) == KindPtr) {
-					// direct use of pointer
-					*(void**)frame = f->arg;
-				} else if(((InterfaceType*)f->fint)->mhdr.len == 0) {
-					// convert to empty interface
-					ef = (Eface*)frame;
-					ef->type = &f->ot->typ;
-					ef->data = f->arg;
-				} else {
-					// convert to interface with methods, via empty interface.
-					ef1.type = &f->ot->typ;
-					ef1.data = f->arg;
-					if(!runtime·ifaceE2I2((InterfaceType*)f->fint, ef1, (Iface*)frame))
-						runtime·throw("invalid type conversion in runfinq");
-				}
-				reflect·call(f->fn, frame, framesz, framesz);
-				f->fn = nil;
-				f->arg = nil;
-				f->ot = nil;
-			}
-			fb->cnt = 0;
-			runtime·lock(&finlock);
-			fb->next = finc;
-			finc = fb;
-			runtime·unlock(&finlock);
-		}
-
-		// Zero everything that's dead, to avoid memory leaks.
-		// See comment at top of function.
-		f = nil;
-		fb = nil;
-		next = nil;
-		i = 0;
-		ef = nil;
-		ef1.type = nil;
-		ef1.data = nil;
-		runtime·gc(1);	// trigger another gc to clean up the finalized objects, if possible
-	}
-}
-
-void
-runtime·createfing(void)
-{
-	if(runtime·fing != nil)
-		return;
-	// Here we use gclock instead of finlock,
-	// because newproc1 can allocate, which can cause on-demand span sweep,
-	// which can queue finalizers, which would deadlock.
-	runtime·lock(&gclock);
-	if(runtime·fing == nil)
-		runtime·fing = runtime·newproc1(&runfinqv, nil, 0, 0, runtime·gc);
-	runtime·unlock(&gclock);
-}
-
-void
-runtime·createfingM(G *gp)
-{
-	runtime·createfing();
-	runtime·gogo(&gp->sched);
-}
-
 G*
 runtime·wakefing(void)
 {
 	G *res;
 
 	res = nil;
-	runtime·lock(&finlock);
+	runtime·lock(&runtime·finlock);
 	if(runtime·fingwait && runtime·fingwake) {
 		runtime·fingwait = false;
 		runtime·fingwake = false;
 		res = runtime·fing;
 	}
-	runtime·unlock(&finlock);
+	runtime·unlock(&runtime·finlock);
 	return res;
 }
 
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 68bad029de..32fe35e28c 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -50,7 +50,7 @@ func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
 		gothrow("gopark: bad g status")
 	}
 	mp.waitlock = lock
-	mp.waitunlockf = *(*func(*g, unsafe.Pointer) bool)(unsafe.Pointer(&unlockf))
+	mp.waitunlockf = unlockf
 	gp.waitreason = reason
 	releasem(mp)
 	// can't do anything that might move the G between Ms here.
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 364c3e744d..f69a0410fa 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -39,6 +39,8 @@ func raceacquireg(gp *g, addr unsafe.Pointer)
 //go:noescape
 func racereleaseg(gp *g, addr unsafe.Pointer)
 
+func racefingo()
+
 // Should be a built-in for unsafe.Pointer?
 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
 	return unsafe.Pointer(uintptr(p) + x)
@@ -77,6 +79,7 @@ var (
 	mprofMalloc_m,
 	gc_m,
 	setFinalizer_m,
+	removeFinalizer_m,
 	markallocated_m,
 	unrollgcprog_m,
 	unrollgcproginplace_m,
@@ -187,6 +190,7 @@ func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uns
 func munmap(addr unsafe.Pointer, n uintptr)
 func madvise(addr unsafe.Pointer, n uintptr, flags int32)
 func newstackcall(fv *funcval, addr unsafe.Pointer, size uint32)
+func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
 func procyield(cycles uint32)
 func osyield()
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
@@ -199,6 +203,7 @@ func notesleep(n *note)
 func noteclear(n *note)
 func lock(lk *mutex)
 func unlock(lk *mutex)
+func purgecachedstats(c *mcache)
 
 //go:noescape
 func cas(ptr *uint32, old, new uint32) bool
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 46d0fb28e7..4d2a49829c 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -49,3 +49,6 @@ TEXT runtime∕pprof·runtime_cyclesPerSecond(SB),NOSPLIT,$0-0
 
 TEXT bytes·Compare(SB),NOSPLIT,$0-0
 	JMP	runtime·cmpbytes(SB)
+
+TEXT runtime·reflectcall(SB), NOSPLIT, $0-0
+	JMP	reflect·call(SB)

From 4dbd0dbf1542274c298f78e969badf8a73e1e53e Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 28 Aug 2014 14:23:25 -0700
Subject: [PATCH 264/423] runtime: fix openbsd/386

In revision 05c3fee13eb3, openbsd/386's tfork implementation was
accidentally changed in one instruction from using the "params"
parameter to using the "psize" parameter.

While here, OpenBSD's __tfork system call returns a pid_t which is an
int32 on all OpenBSD architectures, so change runtime.tfork's return
type from int64 to int32 and update the assembly implementations
accordingly.

LGTM=iant
R=rsc, iant
CC=golang-codereviews, jsing
https://golang.org/cl/133190043
---
 src/pkg/runtime/os_openbsd.c        |  2 +-
 src/pkg/runtime/os_openbsd.go       |  2 +-
 src/pkg/runtime/sys_openbsd_386.s   | 12 +++++-------
 src/pkg/runtime/sys_openbsd_amd64.s |  6 +++---
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index 220091535d..60db7efdd9 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -26,7 +26,7 @@ extern SigTab runtime·sigtab[];
 static Sigset sigset_none;
 static Sigset sigset_all = ~(Sigset)0;
 
-extern int64 runtime·tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
+extern int32 runtime·tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
 extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock, const int32 *abort);
 extern int32 runtime·thrwakeup(void *ident, int32 n);
 
diff --git a/src/pkg/runtime/os_openbsd.go b/src/pkg/runtime/os_openbsd.go
index 6bb6baa62c..4982f903e3 100644
--- a/src/pkg/runtime/os_openbsd.go
+++ b/src/pkg/runtime/os_openbsd.go
@@ -15,6 +15,6 @@ func raise(sig int32)
 func kqueue() int32
 func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
 func closeonexec(fd int32)
-func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int64
+func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32
 func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
 func thrwakeup(ident unsafe.Pointer, n int32) int32
diff --git a/src/pkg/runtime/sys_openbsd_386.s b/src/pkg/runtime/sys_openbsd_386.s
index 596d45a023..d836a1f9ea 100644
--- a/src/pkg/runtime/sys_openbsd_386.s
+++ b/src/pkg/runtime/sys_openbsd_386.s
@@ -226,7 +226,7 @@ sigtramp_ret:
 TEXT runtime·tfork(SB),NOSPLIT,$12
 
 	// Copy mp, gp and fn from the parent stack onto the child stack.
-	MOVL	psize+4(FP), AX
+	MOVL	param+0(FP), AX
 	MOVL	8(AX), CX		// tf_stack
 	SUBL	$16, CX
 	MOVL	CX, 8(AX)
@@ -247,17 +247,15 @@ TEXT runtime·tfork(SB),NOSPLIT,$12
 	INT	$0x80
 
 	// Return if tfork syscall failed.
-	JCC	5(PC)
+	JCC	4(PC)
 	NEGL	AX
-	MOVL	AX, ret_lo+20(FP)
-	MOVL	$-1, ret_hi+24(FP)
+	MOVL	AX, ret+20(FP)
 	RET
 
 	// In parent, return.
 	CMPL	AX, $0
-	JEQ	4(PC)
-	MOVL	AX, ret_lo+20(FP)
-	MOVL	$0, ret_hi+24(FP)
+	JEQ	3(PC)
+	MOVL	AX, ret+20(FP)
 	RET
 
 	// Paranoia: check that SP is as we expect.
diff --git a/src/pkg/runtime/sys_openbsd_amd64.s b/src/pkg/runtime/sys_openbsd_amd64.s
index eb5010164c..e9371c3b63 100644
--- a/src/pkg/runtime/sys_openbsd_amd64.s
+++ b/src/pkg/runtime/sys_openbsd_amd64.s
@@ -11,7 +11,7 @@
 
 #define CLOCK_MONOTONIC	$3
 
-// int64 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
+// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
 TEXT runtime·tfork(SB),NOSPLIT,$32
 
 	// Copy mp, gp and fn off parent stack for use by child.
@@ -27,13 +27,13 @@ TEXT runtime·tfork(SB),NOSPLIT,$32
 	// Return if tfork syscall failed.
 	JCC	4(PC)
 	NEGQ	AX
-	MOVQ	AX, ret+40(FP)
+	MOVL	AX, ret+40(FP)
 	RET
 
 	// In parent, return.
 	CMPL	AX, $0
 	JEQ	3(PC)
-	MOVQ	AX, ret+40(FP)
+	MOVL	AX, ret+40(FP)
 	RET
 
 	// Set FS to point at m->tls.

From 882933f09b35bf4f1791203a6666af99ff9bea54 Mon Sep 17 00:00:00 2001
From: ChaiShushan <chaishushan@gmail.com>
Date: Thu, 28 Aug 2014 14:49:32 -0700
Subject: [PATCH 265/423] image/color/palette: use go generate to create
 palette.go

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/134940043
---
 src/pkg/image/color/palette/gen.go      | 96 +++++++++++++++----------
 src/pkg/image/color/palette/generate.go |  8 +++
 src/pkg/image/color/palette/palette.go  |  3 +-
 3 files changed, 67 insertions(+), 40 deletions(-)
 create mode 100644 src/pkg/image/color/palette/generate.go

diff --git a/src/pkg/image/color/palette/gen.go b/src/pkg/image/color/palette/gen.go
index 4f4d88345a..2b5fdaaf2b 100644
--- a/src/pkg/image/color/palette/gen.go
+++ b/src/pkg/image/color/palette/gen.go
@@ -7,29 +7,49 @@
 package main
 
 // This program generates palette.go. Invoke it as
-//	go run gen.go | gofmt > palette.go
+//	go run gen.go -output palette.go
 
 import (
+	"bytes"
+	"flag"
 	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"log"
 )
 
+var filename = flag.String("output", "palette.go", "output file name")
+
 func main() {
-	fmt.Println(`// Copyright 2013 The Go Authors. All rights reserved.
+	flag.Parse()
+
+	var buf bytes.Buffer
+
+	fmt.Fprintln(&buf, `// 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.`)
-	fmt.Println()
-	fmt.Println("// generated by go run gen.go; DO NOT EDIT")
-	fmt.Println()
-	fmt.Println("// Package palette provides standard color palettes.")
-	fmt.Println("package palette")
-	fmt.Println()
-	fmt.Println(`import "image/color"`)
-	fmt.Println()
-	printPlan9()
-	printWebSafe()
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "// generated by go run gen.go -output palette.go; DO NOT EDIT")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "package palette")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, `import "image/color"`)
+	fmt.Fprintln(&buf)
+	printPlan9(&buf)
+	printWebSafe(&buf)
+
+	data, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile(*filename, data, 0644)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 
-func printPlan9() {
+func printPlan9(w io.Writer) {
 	c, lines := [3]int{}, [256]string{}
 	for r, i := 0, 0; r != 4; r++ {
 		for v := 0; v != 4; v, i = v+1, i+16 {
@@ -58,27 +78,27 @@ func printPlan9() {
 			}
 		}
 	}
-	fmt.Println("// Plan9 is a 256-color palette that partitions the 24-bit RGB space")
-	fmt.Println("// into 4×4×4 subdivision, with 4 shades in each subcube. Compared to the")
-	fmt.Println("// WebSafe, the idea is to reduce the color resolution by dicing the")
-	fmt.Println("// color cube into fewer cells, and to use the extra space to increase the")
-	fmt.Println("// intensity resolution. This results in 16 gray shades (4 gray subcubes with")
-	fmt.Println("// 4 samples in each), 13 shades of each primary and secondary color (3")
-	fmt.Println("// subcubes with 4 samples plus black) and a reasonable selection of colors")
-	fmt.Println("// covering the rest of the color cube. The advantage is better representation")
-	fmt.Println("// of continuous tones.")
-	fmt.Println("//")
-	fmt.Println("// This palette was used in the Plan 9 Operating System, described at")
-	fmt.Println("// http://plan9.bell-labs.com/magic/man2html/6/color")
-	fmt.Println("var Plan9 = []color.Color{")
+	fmt.Fprintln(w, "// Plan9 is a 256-color palette that partitions the 24-bit RGB space")
+	fmt.Fprintln(w, "// into 4×4×4 subdivision, with 4 shades in each subcube. Compared to the")
+	fmt.Fprintln(w, "// WebSafe, the idea is to reduce the color resolution by dicing the")
+	fmt.Fprintln(w, "// color cube into fewer cells, and to use the extra space to increase the")
+	fmt.Fprintln(w, "// intensity resolution. This results in 16 gray shades (4 gray subcubes with")
+	fmt.Fprintln(w, "// 4 samples in each), 13 shades of each primary and secondary color (3")
+	fmt.Fprintln(w, "// subcubes with 4 samples plus black) and a reasonable selection of colors")
+	fmt.Fprintln(w, "// covering the rest of the color cube. The advantage is better representation")
+	fmt.Fprintln(w, "// of continuous tones.")
+	fmt.Fprintln(w, "//")
+	fmt.Fprintln(w, "// This palette was used in the Plan 9 Operating System, described at")
+	fmt.Fprintln(w, "// http://plan9.bell-labs.com/magic/man2html/6/color")
+	fmt.Fprintln(w, "var Plan9 = []color.Color{")
 	for _, line := range lines {
-		fmt.Println(line)
+		fmt.Fprintln(w, line)
 	}
-	fmt.Println("}")
-	fmt.Println()
+	fmt.Fprintln(w, "}")
+	fmt.Fprintln(w)
 }
 
-func printWebSafe() {
+func printWebSafe(w io.Writer) {
 	lines := [6 * 6 * 6]string{}
 	for r := 0; r < 6; r++ {
 		for g := 0; g < 6; g++ {
@@ -88,14 +108,14 @@ func printWebSafe() {
 			}
 		}
 	}
-	fmt.Println("// WebSafe is a 216-color palette that was popularized by early versions")
-	fmt.Println("// of Netscape Navigator. It is also known as the Netscape Color Cube.")
-	fmt.Println("//")
-	fmt.Println("// See http://en.wikipedia.org/wiki/Web_colors#Web-safe_colors for details.")
-	fmt.Println("var WebSafe = []color.Color{")
+	fmt.Fprintln(w, "// WebSafe is a 216-color palette that was popularized by early versions")
+	fmt.Fprintln(w, "// of Netscape Navigator. It is also known as the Netscape Color Cube.")
+	fmt.Fprintln(w, "//")
+	fmt.Fprintln(w, "// See http://en.wikipedia.org/wiki/Web_colors#Web-safe_colors for details.")
+	fmt.Fprintln(w, "var WebSafe = []color.Color{")
 	for _, line := range lines {
-		fmt.Println(line)
+		fmt.Fprintln(w, line)
 	}
-	fmt.Println("}")
-	fmt.Println()
+	fmt.Fprintln(w, "}")
+	fmt.Fprintln(w)
 }
diff --git a/src/pkg/image/color/palette/generate.go b/src/pkg/image/color/palette/generate.go
new file mode 100644
index 0000000000..64c2ec0d9a
--- /dev/null
+++ b/src/pkg/image/color/palette/generate.go
@@ -0,0 +1,8 @@
+// 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.
+
+//go:generate go run gen.go -output palette.go
+
+// Package palette provides standard color palettes.
+package palette
diff --git a/src/pkg/image/color/palette/palette.go b/src/pkg/image/color/palette/palette.go
index f761e5368d..0bf2c8e1aa 100644
--- a/src/pkg/image/color/palette/palette.go
+++ b/src/pkg/image/color/palette/palette.go
@@ -2,9 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// generated by go run gen.go; DO NOT EDIT
+// generated by go run gen.go -output palette.go; DO NOT EDIT
 
-// Package palette provides standard color palettes.
 package palette
 
 import "image/color"

From 5db510f1344daf6b5b8f3150adc941fa68954c36 Mon Sep 17 00:00:00 2001
From: ChaiShushan <chaishushan@gmail.com>
Date: Thu, 28 Aug 2014 14:55:02 -0700
Subject: [PATCH 266/423] strconv: use go generate to create isprint.go

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/132230043
---
 src/pkg/strconv/isprint.go     |  2 +-
 src/pkg/strconv/makeisprint.go | 72 ++++++++++++++++++++++------------
 src/pkg/strconv/quote.go       |  2 +
 3 files changed, 50 insertions(+), 26 deletions(-)

diff --git a/src/pkg/strconv/isprint.go b/src/pkg/strconv/isprint.go
index ba0adbdbb5..80738ed711 100644
--- a/src/pkg/strconv/isprint.go
+++ b/src/pkg/strconv/isprint.go
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // DO NOT EDIT.  GENERATED BY
-//     go run makeisprint.go >x && mv x isprint.go
+//     go run makeisprint.go -output isprint.go
 
 package strconv
 
diff --git a/src/pkg/strconv/makeisprint.go b/src/pkg/strconv/makeisprint.go
index 216159cc02..588d0a00b5 100644
--- a/src/pkg/strconv/makeisprint.go
+++ b/src/pkg/strconv/makeisprint.go
@@ -4,15 +4,26 @@
 
 // +build ignore
 
-// makeisprint generates the tables for strconv's compact isPrint.
+//
+// usage:
+//
+// go run makeisprint.go -output isprint.go
+//
+
 package main
 
 import (
+	"bytes"
+	"flag"
 	"fmt"
-	"os"
+	"go/format"
+	"io/ioutil"
+	"log"
 	"unicode"
 )
 
+var filename = flag.String("output", "isprint.go", "output file name")
+
 var (
 	range16  []uint16
 	except16 []uint16
@@ -110,6 +121,8 @@ func to16(x []uint32) []uint16 {
 }
 
 func main() {
+	flag.Parse()
+
 	rang, except := scan(0, 0xFFFF)
 	range16 = to16(rang)
 	except16 = to16(except)
@@ -117,49 +130,58 @@ func main() {
 
 	for i := rune(0); i <= unicode.MaxRune; i++ {
 		if isPrint(i) != unicode.IsPrint(i) {
-			fmt.Fprintf(os.Stderr, "%U: isPrint=%v, want %v\n", i, isPrint(i), unicode.IsPrint(i))
-			return
+			log.Fatalf("%U: isPrint=%v, want %v\n", i, isPrint(i), unicode.IsPrint(i))
 		}
 	}
 
-	fmt.Printf(`// 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.` + "\n\n")
-	fmt.Printf("// DO NOT EDIT.  GENERATED BY\n")
-	fmt.Printf("//     go run makeisprint.go >x && mv x isprint.go\n\n")
-	fmt.Printf("package strconv\n\n")
+	var buf bytes.Buffer
 
-	fmt.Printf("// (%d+%d+%d)*2 + (%d)*4 = %d bytes\n\n",
+	fmt.Fprintf(&buf, `// 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.`+"\n\n")
+	fmt.Fprintf(&buf, "// DO NOT EDIT.  GENERATED BY\n")
+	fmt.Fprintf(&buf, "//     go run makeisprint.go -output isprint.go\n\n")
+	fmt.Fprintf(&buf, "package strconv\n\n")
+
+	fmt.Fprintf(&buf, "// (%d+%d+%d)*2 + (%d)*4 = %d bytes\n\n",
 		len(range16), len(except16), len(except32),
 		len(range32),
 		(len(range16)+len(except16)+len(except32))*2+
 			(len(range32))*4)
 
-	fmt.Printf("var isPrint16 = []uint16{\n")
+	fmt.Fprintf(&buf, "var isPrint16 = []uint16{\n")
 	for i := 0; i < len(range16); i += 2 {
-		fmt.Printf("\t%#04x, %#04x,\n", range16[i], range16[i+1])
+		fmt.Fprintf(&buf, "\t%#04x, %#04x,\n", range16[i], range16[i+1])
 	}
-	fmt.Printf("}\n\n")
+	fmt.Fprintf(&buf, "}\n\n")
 
-	fmt.Printf("var isNotPrint16 = []uint16{\n")
+	fmt.Fprintf(&buf, "var isNotPrint16 = []uint16{\n")
 	for _, r := range except16 {
-		fmt.Printf("\t%#04x,\n", r)
+		fmt.Fprintf(&buf, "\t%#04x,\n", r)
 	}
-	fmt.Printf("}\n\n")
+	fmt.Fprintf(&buf, "}\n\n")
 
-	fmt.Printf("var isPrint32 = []uint32{\n")
+	fmt.Fprintf(&buf, "var isPrint32 = []uint32{\n")
 	for i := 0; i < len(range32); i += 2 {
-		fmt.Printf("\t%#06x, %#06x,\n", range32[i], range32[i+1])
+		fmt.Fprintf(&buf, "\t%#06x, %#06x,\n", range32[i], range32[i+1])
 	}
-	fmt.Printf("}\n\n")
+	fmt.Fprintf(&buf, "}\n\n")
 
-	fmt.Printf("var isNotPrint32 = []uint16{ // add 0x10000 to each entry\n")
+	fmt.Fprintf(&buf, "var isNotPrint32 = []uint16{ // add 0x10000 to each entry\n")
 	for _, r := range except32 {
 		if r >= 0x20000 {
-			fmt.Fprintf(os.Stderr, "%U too big for isNotPrint32\n", r)
-			return
+			log.Fatalf("%U too big for isNotPrint32\n", r)
 		}
-		fmt.Printf("\t%#04x,\n", r-0x10000)
+		fmt.Fprintf(&buf, "\t%#04x,\n", r-0x10000)
+	}
+	fmt.Fprintf(&buf, "}\n")
+
+	data, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile(*filename, data, 0644)
+	if err != nil {
+		log.Fatal(err)
 	}
-	fmt.Printf("}\n")
 }
diff --git a/src/pkg/strconv/quote.go b/src/pkg/strconv/quote.go
index 8cdfc472f3..4469c688b0 100644
--- a/src/pkg/strconv/quote.go
+++ b/src/pkg/strconv/quote.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:generate go run makeisprint.go -output isprint.go
+
 package strconv
 
 import (

From b50dd6090d2f6f12a8115fea354d384225574eaf Mon Sep 17 00:00:00 2001
From: ChaiShushan <chaishushan@gmail.com>
Date: Thu, 28 Aug 2014 15:04:03 -0700
Subject: [PATCH 267/423] compress/flate: use go generate to create
 fixedhuff.go

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/137750043
---
 src/pkg/compress/flate/fixedhuff.go |  2 +-
 src/pkg/compress/flate/gen.go       | 55 +++++++++++++++++++++--------
 src/pkg/compress/flate/inflate.go   |  2 ++
 3 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/src/pkg/compress/flate/fixedhuff.go b/src/pkg/compress/flate/fixedhuff.go
index 9be3d53495..7df8b9a293 100644
--- a/src/pkg/compress/flate/fixedhuff.go
+++ b/src/pkg/compress/flate/fixedhuff.go
@@ -4,7 +4,7 @@
 
 package flate
 
-// autogenerated by gen.go, DO NOT EDIT
+// autogenerated by go run gen.go -output fixedhuff.go, DO NOT EDIT
 
 var fixedHuffmanDecoder = huffmanDecoder{
 	7,
diff --git a/src/pkg/compress/flate/gen.go b/src/pkg/compress/flate/gen.go
index 1427557f80..6288ecddd0 100644
--- a/src/pkg/compress/flate/gen.go
+++ b/src/pkg/compress/flate/gen.go
@@ -7,14 +7,21 @@
 // This program generates fixedhuff.go
 // Invoke as
 //
-//      go run gen.go |gofmt >fixedhuff.go
+//	go run gen.go -output fixedhuff.go
 
 package main
 
 import (
+	"bytes"
+	"flag"
 	"fmt"
+	"go/format"
+	"io/ioutil"
+	"log"
 )
 
+var filename = flag.String("output", "fixedhuff.go", "output file name")
+
 const maxCodeLen = 16
 
 // Note: the definition of the huffmanDecoder struct is copied from
@@ -113,6 +120,8 @@ func (h *huffmanDecoder) init(bits []int) bool {
 }
 
 func main() {
+	flag.Parse()
+
 	var h huffmanDecoder
 	var bits [288]int
 	initReverseByte()
@@ -129,27 +138,43 @@ func main() {
 		bits[i] = 8
 	}
 	h.init(bits[:])
-	fmt.Println("package flate")
-	fmt.Println()
-	fmt.Println("// autogenerated by gen.go, DO NOT EDIT")
-	fmt.Println()
-	fmt.Println("var fixedHuffmanDecoder = huffmanDecoder{")
-	fmt.Printf("\t%d,\n", h.min)
-	fmt.Println("\t[huffmanNumChunks]uint32{")
+
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf, `// 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.`+"\n\n")
+
+	fmt.Fprintln(&buf, "package flate")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "// autogenerated by go run gen.go -output fixedhuff.go, DO NOT EDIT")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "var fixedHuffmanDecoder = huffmanDecoder{")
+	fmt.Fprintf(&buf, "\t%d,\n", h.min)
+	fmt.Fprintln(&buf, "\t[huffmanNumChunks]uint32{")
 	for i := 0; i < huffmanNumChunks; i++ {
 		if i&7 == 0 {
-			fmt.Printf("\t\t")
+			fmt.Fprintf(&buf, "\t\t")
 		} else {
-			fmt.Printf(" ")
+			fmt.Fprintf(&buf, " ")
 		}
-		fmt.Printf("0x%04x,", h.chunks[i])
+		fmt.Fprintf(&buf, "0x%04x,", h.chunks[i])
 		if i&7 == 7 {
-			fmt.Println()
+			fmt.Fprintln(&buf)
 		}
 	}
-	fmt.Println("\t},")
-	fmt.Println("\tnil, 0,")
-	fmt.Println("}")
+	fmt.Fprintln(&buf, "\t},")
+	fmt.Fprintln(&buf, "\tnil, 0,")
+	fmt.Fprintln(&buf, "}")
+
+	data, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile(*filename, data, 0644)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 
 var reverseByte [256]byte
diff --git a/src/pkg/compress/flate/inflate.go b/src/pkg/compress/flate/inflate.go
index ce4923eca3..769ef42997 100644
--- a/src/pkg/compress/flate/inflate.go
+++ b/src/pkg/compress/flate/inflate.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:generate go run gen.go -output fixedhuff.go
+
 // Package flate implements the DEFLATE compressed data format, described in
 // RFC 1951.  The gzip and zlib packages implement access to DEFLATE-based file
 // formats.

From dc11be8ddadba6897ab6ec5b0578c5f6c3fb8868 Mon Sep 17 00:00:00 2001
From: ChaiShushan <chaishushan@gmail.com>
Date: Thu, 28 Aug 2014 15:04:10 -0700
Subject: [PATCH 268/423] crypto/md5: use go generate to create md5block.go

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/129650043
---
 src/pkg/crypto/md5/gen.go      | 23 +++++++++++++++++++----
 src/pkg/crypto/md5/md5.go      |  2 ++
 src/pkg/crypto/md5/md5block.go |  2 +-
 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/src/pkg/crypto/md5/gen.go b/src/pkg/crypto/md5/gen.go
index 75295e4fcb..8cd0a6358e 100644
--- a/src/pkg/crypto/md5/gen.go
+++ b/src/pkg/crypto/md5/gen.go
@@ -7,7 +7,7 @@
 // This program generates md5block.go
 // Invoke as
 //
-//	go run gen.go [-full] |gofmt >md5block.go
+//	go run gen.go [-full] -output md5block.go
 //
 // The -full flag causes the generated code to do a full
 // (16x) unrolling instead of a 4x unrolling.
@@ -15,18 +15,33 @@
 package main
 
 import (
+	"bytes"
 	"flag"
+	"go/format"
+	"io/ioutil"
 	"log"
-	"os"
 	"strings"
 	"text/template"
 )
 
+var filename = flag.String("output", "md5block.go", "output file name")
+
 func main() {
 	flag.Parse()
 
+	var buf bytes.Buffer
+
 	t := template.Must(template.New("main").Funcs(funcs).Parse(program))
-	if err := t.Execute(os.Stdout, data); err != nil {
+	if err := t.Execute(&buf, data); err != nil {
+		log.Fatal(err)
+	}
+
+	data, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile(*filename, data, 0644)
+	if err != nil {
 		log.Fatal(err)
 	}
 }
@@ -165,7 +180,7 @@ var program = `// Copyright 2013 The Go Authors. All rights reserved.
 // license that can be found in the LICENSE file.
 
 // DO NOT EDIT.
-// Generate with: go run gen.go{{if .Full}} -full{{end}} | gofmt >md5block.go
+// Generate with: go run gen.go{{if .Full}} -full{{end}} -output md5block.go
 
 package md5
 
diff --git a/src/pkg/crypto/md5/md5.go b/src/pkg/crypto/md5/md5.go
index 1a1f35fabc..8c50c6d0bf 100644
--- a/src/pkg/crypto/md5/md5.go
+++ b/src/pkg/crypto/md5/md5.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:generate go run gen.go -full -output md5block.go
+
 // Package md5 implements the MD5 hash algorithm as defined in RFC 1321.
 package md5
 
diff --git a/src/pkg/crypto/md5/md5block.go b/src/pkg/crypto/md5/md5block.go
index e2a1767775..64e1e7c1ef 100644
--- a/src/pkg/crypto/md5/md5block.go
+++ b/src/pkg/crypto/md5/md5block.go
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // DO NOT EDIT.
-// Generate with: go run gen.go -full | gofmt >md5block.go
+// Generate with: go run gen.go -full -output md5block.go
 
 package md5
 

From 13c69f037986ba4a4cb1890822bfd15702a2971e Mon Sep 17 00:00:00 2001
From: Anthony Martin <ality@pbrane.org>
Date: Thu, 28 Aug 2014 16:01:31 -0700
Subject: [PATCH 269/423] cmd/internal/objfile: fix dissassembly of Plan 9
 object files

This is a reapplication of CL 93520045 (changeset 5012df7fac58)
since that was lost during the move to an internal package.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/134020043
---
 src/cmd/internal/objfile/plan9obj.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/cmd/internal/objfile/plan9obj.go b/src/cmd/internal/objfile/plan9obj.go
index d2c3d3f3fe..80744f82a8 100644
--- a/src/cmd/internal/objfile/plan9obj.go
+++ b/src/cmd/internal/objfile/plan9obj.go
@@ -13,6 +13,15 @@ import (
 	"sort"
 )
 
+var validSymType = map[rune]bool{
+	'T': true,
+	't': true,
+	'D': true,
+	'd': true,
+	'B': true,
+	'b': true,
+}
+
 type plan9File struct {
 	plan9 *plan9obj.File
 }
@@ -35,6 +44,9 @@ func (f *plan9File) symbols() ([]Sym, error) {
 	// We infer the size of a symbol by looking at where the next symbol begins.
 	var addrs []uint64
 	for _, s := range plan9Syms {
+		if !validSymType[s.Type] {
+			continue
+		}
 		addrs = append(addrs, s.Value)
 	}
 	sort.Sort(uint64s(addrs))
@@ -42,6 +54,9 @@ func (f *plan9File) symbols() ([]Sym, error) {
 	var syms []Sym
 
 	for _, s := range plan9Syms {
+		if !validSymType[s.Type] {
+			continue
+		}
 		sym := Sym{Addr: s.Value, Name: s.Name, Code: rune(s.Type)}
 		i := sort.Search(len(addrs), func(x int) bool { return addrs[x] > s.Value })
 		if i < len(addrs) {

From b3de7f28a8c111043013cc539421021a32176c33 Mon Sep 17 00:00:00 2001
From: Anthony Martin <ality@pbrane.org>
Date: Thu, 28 Aug 2014 16:02:15 -0700
Subject: [PATCH 270/423] runtime: fix Plan 9 build for new C calling
 convention

LGTM=0intro, rsc
R=rsc, 0intro
CC=golang-codereviews
https://golang.org/cl/132320043
---
 src/pkg/runtime/sys_plan9_386.s   | 27 ++++++++++++++-------------
 src/pkg/runtime/sys_plan9_amd64.s | 29 +++++++++++++++--------------
 2 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/src/pkg/runtime/sys_plan9_386.s b/src/pkg/runtime/sys_plan9_386.s
index e40721d342..43fb367ed9 100644
--- a/src/pkg/runtime/sys_plan9_386.s
+++ b/src/pkg/runtime/sys_plan9_386.s
@@ -217,28 +217,29 @@ TEXT runtime·setfpmasks(SB),NOSPLIT,$0
 
 #define ERRMAX 128	/* from os_plan9.h */
 
-// func errstr() String
+// void errstr(int8 *buf, int32 len)
+TEXT errstr<>(SB),NOSPLIT,$0
+	MOVL    $41, AX
+	INT     $64
+	RET
+
+// func errstr() string
 // Only used by package syscall.
 // Grab error string due to a syscall made
 // in entersyscall mode, without going
 // through the allocator (issue 4994).
 // See ../syscall/asm_plan9_386.s:/·Syscall/
-TEXT runtime·errstr(SB),NOSPLIT,$0
+TEXT runtime·errstr(SB),NOSPLIT,$8-8
 	get_tls(AX)
 	MOVL	g(AX), BX
 	MOVL	g_m(BX), BX
 	MOVL	m_errstr(BX), CX
-	MOVL	CX, ret_base+0(FP)
-	MOVL	$ERRMAX, ret_len+4(FP)
-	MOVL	$41, AX
-	INT	$64
-
-	// syscall requires caller-save
-	MOVL	ret_base+0(FP), CX
-
-	// push the argument
-	PUSHL	CX
+	MOVL	CX, 0(SP)
+	MOVL	$ERRMAX, 4(SP)
+	CALL	errstr<>(SB)
 	CALL	runtime·findnull(SB)
-	POPL	CX
+	MOVL	4(SP), AX
 	MOVL	AX, ret_len+4(FP)
+	MOVL	0(SP), AX
+	MOVL	AX, ret_base+0(FP)
 	RET
diff --git a/src/pkg/runtime/sys_plan9_amd64.s b/src/pkg/runtime/sys_plan9_amd64.s
index d83a57e2ac..ea0bd57b20 100644
--- a/src/pkg/runtime/sys_plan9_amd64.s
+++ b/src/pkg/runtime/sys_plan9_amd64.s
@@ -212,28 +212,29 @@ TEXT runtime·setfpmasks(SB),NOSPLIT,$8
 
 #define ERRMAX 128	/* from os_plan9.h */
 
-// func errstr() String
+// void errstr(int8 *buf, int32 len)
+TEXT errstr<>(SB),NOSPLIT,$0
+	MOVQ    $41, BP
+	SYSCALL
+	RET
+
+// func errstr() string
 // Only used by package syscall.
 // Grab error string due to a syscall made
 // in entersyscall mode, without going
 // through the allocator (issue 4994).
-// See ../syscall/asm_plan9_386.s:/·Syscall/
-TEXT runtime·errstr(SB),NOSPLIT,$0
+// See ../syscall/asm_plan9_amd64.s:/·Syscall/
+TEXT runtime·errstr(SB),NOSPLIT,$16-16
 	get_tls(AX)
 	MOVQ	g(AX), BX
 	MOVQ	g_m(BX), BX
 	MOVQ	m_errstr(BX), CX
-	MOVQ	CX, ret_base+0(FP)
-	MOVQ	$ERRMAX, ret_len+8(FP)
-	MOVQ	$41, BP
-	SYSCALL
-
-	// syscall requires caller-save
-	MOVQ	ret_base+0(FP), CX
-
-	// push the argument
-	PUSHQ	CX
+	MOVQ	CX, 0(SP)
+	MOVQ	$ERRMAX, 8(SP)
+	CALL	errstr<>(SB)
 	CALL	runtime·findnull(SB)
-	POPQ	CX
+	MOVQ	8(SP), AX
 	MOVQ	AX, ret_len+8(FP)
+	MOVQ	0(SP), AX
+	MOVQ	AX, ret_base+0(FP)
 	RET

From 3d128dbf96fdc5a8b6e9eccca8381fc93f685133 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 28 Aug 2014 19:08:09 -0700
Subject: [PATCH 271/423] runtime: remove holes in FUNCDATA tables

Shrinks the text segment size by about 1.5% for the "go", "gofmt",
and "camlistored" commands on linux/amd64.

Before:
$ size go gofmt camlistored
   text	   data	    bss	    dec	    hex	filename
6506842	 136996	 105784	6749622	 66fdb6	go
2376046	  85232	  90984	2552262	 26f1c6	gofmt
17051050	 190256	 130320	17371626	10911ea	camlistored

After:
$ size go gofmt camlistored
   text	   data	    bss	    dec	    hex	filename
6403034	 136996	 105784	6645814	 656836	go
2331118	  85232	  90984	2507334	 264246	gofmt
16842586	 190256	 130320	17163162	105e39a	camlistored

Fixes #8604.

LGTM=rsc
R=golang-codereviews, bradfitz, rsc
CC=golang-codereviews
https://golang.org/cl/137790043
---
 src/pkg/runtime/funcdata.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/funcdata.h b/src/pkg/runtime/funcdata.h
index 1f624b529b..85e82838b7 100644
--- a/src/pkg/runtime/funcdata.h
+++ b/src/pkg/runtime/funcdata.h
@@ -10,9 +10,9 @@
 #define PCDATA_ArgSize 0 /* argument size at CALL instruction */
 #define PCDATA_StackMapIndex 1
 
-#define FUNCDATA_ArgsPointerMaps 2 /* garbage collector blocks */
-#define FUNCDATA_LocalsPointerMaps 3
-#define FUNCDATA_DeadValueMaps 4
+#define FUNCDATA_ArgsPointerMaps 0 /* garbage collector blocks */
+#define FUNCDATA_LocalsPointerMaps 1
+#define FUNCDATA_DeadValueMaps 2
 
 // To be used in assembly.
 #define ARGSIZE(n) PCDATA $PCDATA_ArgSize, $n
@@ -27,9 +27,9 @@
 enum {
 	PCDATA_ArgSize = 0,
 	PCDATA_StackMapIndex = 1,
-	FUNCDATA_ArgsPointerMaps = 2,
-	FUNCDATA_LocalsPointerMaps = 3,
-	FUNCDATA_DeadValueMaps = 4,
+	FUNCDATA_ArgsPointerMaps = 0,
+	FUNCDATA_LocalsPointerMaps = 1,
+	FUNCDATA_DeadValueMaps = 2,
 	ArgsSizeUnknown = 0x80000000,
 };
 */

From f2e7fa9d7711ca91865ef5b54f7a9d13fc30c91a Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Thu, 28 Aug 2014 22:40:57 -0400
Subject: [PATCH 272/423] misc/cgo/test: disable issue 8428 regress test on
 darwin

Clang 3.2 and older (as shipped with OS X Mountain Lion and older)
outputs ambiguous DWARF debug info that makes it impossible for us to
reconstruct accurate type information as required for this test.

Fixes #8611.

LGTM=rsc
R=r, rsc, minux
CC=golang-codereviews
https://golang.org/cl/135990043
---
 misc/cgo/test/issue8428.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/misc/cgo/test/issue8428.go b/misc/cgo/test/issue8428.go
index f5b0ee4974..a3dc5755ce 100644
--- a/misc/cgo/test/issue8428.go
+++ b/misc/cgo/test/issue8428.go
@@ -2,6 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// This test fails on older versions of OS X because they use older buggy
+// versions of Clang that emit ambiguous DWARF info.  See issue 8611.
+// +build !darwin
+
 package cgotest
 
 // Issue 8428.  Cgo inconsistently translated zero size arrays.

From de7fea0d6161c876fca0b0293be3ac6f3e29a759 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Thu, 28 Aug 2014 19:51:21 -0700
Subject: [PATCH 273/423] test: add test that caused gccgo to crash on valid
 code

Update #8612

LGTM=minux
R=golang-codereviews, minux
CC=golang-codereviews
https://golang.org/cl/135170043
---
 test/fixedbugs/issue8612.go | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 test/fixedbugs/issue8612.go

diff --git a/test/fixedbugs/issue8612.go b/test/fixedbugs/issue8612.go
new file mode 100644
index 0000000000..93370cf669
--- /dev/null
+++ b/test/fixedbugs/issue8612.go
@@ -0,0 +1,34 @@
+//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.
+
+// Gccgo had a bug comparing a struct or array value with an interface
+// values, when the struct or array was not addressable.
+
+package p
+
+type A [10]int
+
+type S struct {
+	i int
+}
+
+func F1() S {
+	return S{0}
+}
+
+func F2() A {
+	return A{}
+}
+
+func Cmp(v interface{}) bool {
+	if F1() == v {
+		return true
+	}
+	if F2() == v {
+		return true
+	}
+	return false
+}

From 597b266eafe7d63e9be8da1c1b4813bd2998a11c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 28 Aug 2014 23:26:40 -0400
Subject: [PATCH 274/423] runtime: convert print.c to Go

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/135930043
---
 src/pkg/runtime/alg.goc         |   8 +-
 src/pkg/runtime/mprof.go        |   6 +-
 src/pkg/runtime/os_darwin.c     |  18 +-
 src/pkg/runtime/os_dragonfly.c  |   6 +-
 src/pkg/runtime/os_freebsd.c    |   6 +-
 src/pkg/runtime/panic.c         |   7 +-
 src/pkg/runtime/print.c         | 443 --------------------------------
 src/pkg/runtime/print.go        | 111 --------
 src/pkg/runtime/print1.go       | 338 ++++++++++++++++++++++++
 src/pkg/runtime/proc.c          |   5 +-
 src/pkg/runtime/runtime.h       |  30 +--
 src/pkg/runtime/stubs.go        |   4 +-
 src/pkg/runtime/traceback_arm.c |   2 +-
 src/pkg/runtime/traceback_x86.c |   2 +-
 14 files changed, 387 insertions(+), 599 deletions(-)
 delete mode 100644 src/pkg/runtime/print.c
 delete mode 100644 src/pkg/runtime/print.go
 create mode 100644 src/pkg/runtime/print1.go

diff --git a/src/pkg/runtime/alg.goc b/src/pkg/runtime/alg.goc
index aa0c79d476..0c3b3cd4ff 100644
--- a/src/pkg/runtime/alg.goc
+++ b/src/pkg/runtime/alg.goc
@@ -29,7 +29,7 @@ runtime·memprint(uintptr s, void *a)
 		v = *(uint64*)a;
 		break;
 	}
-	runtime·printint_c(v);
+	runtime·printint(v);
 }
 
 void
@@ -126,7 +126,7 @@ void
 runtime·strprint(uintptr s, void *a)
 {
 	USED(s);
-	runtime·printstring_c(*(String*)a);
+	runtime·printstring(*(String*)a);
 }
 
 void
@@ -146,7 +146,7 @@ void
 runtime·interprint(uintptr s, void *a)
 {
 	USED(s);
-	runtime·printiface_c(*(Iface*)a);
+	runtime·printiface(*(Iface*)a);
 }
 
 void
@@ -166,7 +166,7 @@ void
 runtime·nilinterprint(uintptr s, void *a)
 {
 	USED(s);
-	runtime·printeface_c(*(Eface*)a);
+	runtime·printeface(*(Eface*)a);
 }
 
 void
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 9ee37d0bee..78384f8117 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -162,16 +162,14 @@ func Stack(buf []byte, all bool) int {
 
 	n := 0
 	if len(buf) > 0 {
-		gp.writebuf = &buf[0]
-		gp.writenbuf = int32(len(buf))
+		gp.writebuf = buf
 		goroutineheader(gp)
 		traceback(pc, sp, 0, gp)
 		if all {
 			tracebackothers(gp)
 		}
-		n = len(buf) - int(gp.writenbuf)
+		n = len(buf) - len(gp.writebuf)
 		gp.writebuf = nil
-		gp.writenbuf = 0
 	}
 
 	if all {
diff --git a/src/pkg/runtime/os_darwin.c b/src/pkg/runtime/os_darwin.c
index 84b69b047a..c660fb8c10 100644
--- a/src/pkg/runtime/os_darwin.c
+++ b/src/pkg/runtime/os_darwin.c
@@ -150,7 +150,7 @@ macherror(int32 r, int8 *fn)
 	runtime·prints("mach error ");
 	runtime·prints(fn);
 	runtime·prints(": ");
-	runtime·printint_c(r);
+	runtime·printint(r);
 	runtime·prints("\n");
 	runtime·throw("mach error");
 }
@@ -218,7 +218,7 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 		runtime·prints("send:\t");
 		for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
 			runtime·prints(" ");
-			runtime·printpointer_c((void*)p[i]);
+			runtime·printpointer((void*)p[i]);
 			if(i%8 == 7)
 				runtime·prints("\n\t");
 		}
@@ -231,7 +231,7 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 	if(ret != 0){
 		if(DebugMach){
 			runtime·prints("mach_msg error ");
-			runtime·printint_c(ret);
+			runtime·printint(ret);
 			runtime·prints("\n");
 		}
 		return ret;
@@ -242,7 +242,7 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 		runtime·prints("recv:\t");
 		for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
 			runtime·prints(" ");
-			runtime·printpointer_c((void*)p[i]);
+			runtime·printpointer((void*)p[i]);
 			if(i%8 == 7)
 				runtime·prints("\n\t");
 		}
@@ -253,9 +253,9 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 	if(h->msgh_id != id+Reply){
 		if(DebugMach){
 			runtime·prints("mach_msg reply id mismatch ");
-			runtime·printint_c(h->msgh_id);
+			runtime·printint(h->msgh_id);
 			runtime·prints(" != ");
-			runtime·printint_c(id+Reply);
+			runtime·printint(id+Reply);
 			runtime·prints("\n");
 		}
 		return -303;	// MIG_REPLY_MISMATCH
@@ -272,7 +272,7 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 	&& !(h->msgh_bits & MACH_MSGH_BITS_COMPLEX)){
 		if(DebugMach){
 			runtime·prints("mig result ");
-			runtime·printint_c(c->code);
+			runtime·printint(c->code);
 			runtime·prints("\n");
 		}
 		return c->code;
@@ -281,9 +281,9 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 	if(h->msgh_size != rxsize){
 		if(DebugMach){
 			runtime·prints("mach_msg reply size mismatch ");
-			runtime·printint_c(h->msgh_size);
+			runtime·printint(h->msgh_size);
 			runtime·prints(" != ");
-			runtime·printint_c(rxsize);
+			runtime·printint(rxsize);
 			runtime·prints("\n");
 		}
 		return -307;	// MIG_ARRAY_TOO_LARGE
diff --git a/src/pkg/runtime/os_dragonfly.c b/src/pkg/runtime/os_dragonfly.c
index 1132f5741d..65121d3273 100644
--- a/src/pkg/runtime/os_dragonfly.c
+++ b/src/pkg/runtime/os_dragonfly.c
@@ -63,11 +63,11 @@ runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
 		return;
 
 	runtime·prints("umtx_wait addr=");
-	runtime·printpointer_c(addr);
+	runtime·printpointer(addr);
 	runtime·prints(" val=");
-	runtime·printint_c(val);
+	runtime·printint(val);
 	runtime·prints(" ret=");
-	runtime·printint_c(ret);
+	runtime·printint(ret);
 	runtime·prints("\n");
 	*(int32*)0x1005 = 0x1005;
 }
diff --git a/src/pkg/runtime/os_freebsd.c b/src/pkg/runtime/os_freebsd.c
index 20f71c41e8..d360f6712d 100644
--- a/src/pkg/runtime/os_freebsd.c
+++ b/src/pkg/runtime/os_freebsd.c
@@ -64,11 +64,11 @@ runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
 
 fail:
 	runtime·prints("umtx_wait addr=");
-	runtime·printpointer_c(addr);
+	runtime·printpointer(addr);
 	runtime·prints(" val=");
-	runtime·printint_c(val);
+	runtime·printint(val);
 	runtime·prints(" ret=");
-	runtime·printint_c(ret);
+	runtime·printint(ret);
 	runtime·prints("\n");
 	*(int32*)0x1005 = 0x1005;
 }
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index 00c780bf55..39027a77c2 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -390,8 +390,11 @@ runtime·startpanic(void)
 	switch(g->m->dying) {
 	case 0:
 		g->m->dying = 1;
-		if(g != nil)
-			g->writebuf = nil;
+		if(g != nil) {
+			g->writebuf.array = nil;
+			g->writebuf.len = 0;
+			g->writebuf.cap = 0;
+		}
 		runtime·xadd(&runtime·panicking, 1);
 		runtime·lock(&paniclk);
 		if(runtime·debug.schedtrace > 0 || runtime·debug.scheddetail > 0)
diff --git a/src/pkg/runtime/print.c b/src/pkg/runtime/print.c
deleted file mode 100644
index 57dfdabb6d..0000000000
--- a/src/pkg/runtime/print.c
+++ /dev/null
@@ -1,443 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "runtime.h"
-#include "type.h"
-#include "../../cmd/ld/textflag.h"
-
-//static Mutex debuglock;
-
-static void vprintf(int8*, byte*);
-
-// write to goroutine-local buffer if diverting output,
-// or else standard error.
-static void
-gwrite(void *v, intgo n)
-{
-	if(g == nil || g->writebuf == nil) {
-		runtime·write(2, v, n);
-		return;
-	}
-
-	if(g->writenbuf == 0)
-		return;
-
-	if(n > g->writenbuf)
-		n = g->writenbuf;
-	runtime·memmove(g->writebuf, v, n);
-	g->writebuf += n;
-	g->writenbuf -= n;
-}
-
-void
-runtime·dump(byte *p, int32 n)
-{
-	int32 i;
-
-	for(i=0; i<n; i++) {
-		runtime·printpointer_c((byte*)(p[i]>>4));
-		runtime·printpointer_c((byte*)(p[i]&0xf));
-		if((i&15) == 15)
-			runtime·prints("\n");
-		else
-			runtime·prints(" ");
-	}
-	if(n & 15)
-		runtime·prints("\n");
-}
-
-void
-runtime·prints(int8 *s)
-{
-	gwrite(s, runtime·findnull((byte*)s));
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·printf(int8 *s, ...)
-{
-	byte *arg;
-
-	arg = (byte*)(&s+1);
-	vprintf(s, arg);
-}
-
-#pragma textflag NOSPLIT
-int32
-runtime·snprintf(byte *buf, int32 n, int8 *s, ...)
-{
-	byte *arg;
-	int32 m;
-
-	arg = (byte*)(&s+1);
-	g->writebuf = buf;
-	g->writenbuf = n-1;
-	vprintf(s, arg);
-	*g->writebuf = '\0';
-	m = g->writebuf - buf;
-	g->writenbuf = 0;
-	g->writebuf = nil;
-	return m;
-}
-
-// Very simple printf.  Only for debugging prints.
-// Do not add to this without checking with Rob.
-static void
-vprintf(int8 *s, byte *base)
-{
-	int8 *p, *lp;
-	uintptr arg, siz;
-	byte *v;
-
-	//runtime·lock(&debuglock);
-
-	lp = p = s;
-	arg = (uintptr)base;
-	for(; *p; p++) {
-		if(*p != '%')
-			continue;
-		if(p > lp)
-			gwrite(lp, p-lp);
-		p++;
-		siz = 0;
-		switch(*p) {
-		case 't':
-		case 'c':
-			siz = 1;
-			break;
-		case 'd':	// 32-bit
-		case 'x':
-			arg = ROUND(arg, 4);
-			siz = 4;
-			break;
-		case 'D':	// 64-bit
-		case 'U':
-		case 'X':
-		case 'f':
-			arg = ROUND(arg, sizeof(uintreg));
-			siz = 8;
-			break;
-		case 'C':
-			arg = ROUND(arg, sizeof(uintreg));
-			siz = 16;
-			break;
-		case 'p':	// pointer-sized
-		case 's':
-			arg = ROUND(arg, sizeof(uintptr));
-			siz = sizeof(uintptr);
-			break;
-		case 'S':	// pointer-aligned but bigger
-			arg = ROUND(arg, sizeof(uintptr));
-			siz = sizeof(String);
-			break;
-		case 'a':	// pointer-aligned but bigger
-			arg = ROUND(arg, sizeof(uintptr));
-			siz = sizeof(Slice);
-			break;
-		case 'i':	// pointer-aligned but bigger
-		case 'e':
-			arg = ROUND(arg, sizeof(uintptr));
-			siz = sizeof(Eface);
-			break;
-		}
-		v = (byte*)arg;
-		switch(*p) {
-		case 'a':
-			runtime·printslice_c(*(Slice*)v);
-			break;
-		case 'c':
-			runtime·printbyte_c(*(int8*)v);
-			break;
-		case 'd':
-			runtime·printint_c(*(int32*)v);
-			break;
-		case 'D':
-			runtime·printint_c(*(int64*)v);
-			break;
-		case 'e':
-			runtime·printeface_c(*(Eface*)v);
-			break;
-		case 'f':
-			runtime·printfloat_c(*(float64*)v);
-			break;
-		case 'C':
-			runtime·printcomplex_c(*(Complex128*)v);
-			break;
-		case 'i':
-			runtime·printiface_c(*(Iface*)v);
-			break;
-		case 'p':
-			runtime·printpointer_c(*(void**)v);
-			break;
-		case 's':
-			runtime·prints(*(int8**)v);
-			break;
-		case 'S':
-			runtime·printstring_c(*(String*)v);
-			break;
-		case 't':
-			runtime·printbool_c(*(bool*)v);
-			break;
-		case 'U':
-			runtime·printuint_c(*(uint64*)v);
-			break;
-		case 'x':
-			runtime·printhex_c(*(uint32*)v);
-			break;
-		case 'X':
-			runtime·printhex_c(*(uint64*)v);
-			break;
-		}
-		arg += siz;
-		lp = p+1;
-	}
-	if(p > lp)
-		gwrite(lp, p-lp);
-
-	//runtime·unlock(&debuglock);
-}
-
-static void
-goprintf_m(void)
-{
-	// Can assume s has terminating NUL because only
-	// the Go compiler generates calls to runtime·goprintf, using
-	// string constants, and all the string constants have NULs.
-	vprintf(g->m->ptrarg[0], g->m->ptrarg[1]);
-	g->m->ptrarg[0] = nil;
-	g->m->ptrarg[1] = nil;
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·goprintf(String s, ...)
-{
-	g->m->ptrarg[0] = s.str;
-	g->m->ptrarg[1] = (byte*)(&s+1);
-	runtime·onM(goprintf_m);
-}
-
-void
-runtime·printpc_c(void *p)
-{
-	runtime·prints("PC=");
-	runtime·printhex_c((uint64)runtime·getcallerpc(p));
-}
-
-void
-runtime·printbool_c(bool v)
-{
-	if(v) {
-		gwrite((byte*)"true", 4);
-		return;
-	}
-	gwrite((byte*)"false", 5);
-}
-
-void
-runtime·printbyte_c(int8 c)
-{
-	gwrite(&c, 1);
-}
-
-void
-runtime·printfloat_c(float64 v)
-{
-	byte buf[20];
-	int32 e, s, i, n;
-	float64 h;
-
-	if(ISNAN(v)) {
-		gwrite("NaN", 3);
-		return;
-	}
-	if(v == runtime·posinf) {
-		gwrite("+Inf", 4);
-		return;
-	}
-	if(v == runtime·neginf) {
-		gwrite("-Inf", 4);
-		return;
-	}
-
-	n = 7;	// digits printed
-	e = 0;	// exp
-	s = 0;	// sign
-	if(v == 0) {
-		if(1/v == runtime·neginf)
-			s = 1;
-	} else {
-		// sign
-		if(v < 0) {
-			v = -v;
-			s = 1;
-		}
-
-		// normalize
-		while(v >= 10) {
-			e++;
-			v /= 10;
-		}
-		while(v < 1) {
-			e--;
-			v *= 10;
-		}
-
-		// round
-		h = 5;
-		for(i=0; i<n; i++)
-			h /= 10;
-
-		v += h;
-		if(v >= 10) {
-			e++;
-			v /= 10;
-		}
-	}
-
-	// format +d.dddd+edd
-	buf[0] = '+';
-	if(s)
-		buf[0] = '-';
-	for(i=0; i<n; i++) {
-		s = v;
-		buf[i+2] = s+'0';
-		v -= s;
-		v *= 10.;
-	}
-	buf[1] = buf[2];
-	buf[2] = '.';
-
-	buf[n+2] = 'e';
-	buf[n+3] = '+';
-	if(e < 0) {
-		e = -e;
-		buf[n+3] = '-';
-	}
-
-	buf[n+4] = (e/100) + '0';
-	buf[n+5] = (e/10)%10 + '0';
-	buf[n+6] = (e%10) + '0';
-	gwrite(buf, n+7);
-}
-
-void
-runtime·printcomplex_c(Complex128 v)
-{
-	gwrite("(", 1);
-	runtime·printfloat_c(v.real);
-	runtime·printfloat_c(v.imag);
-	gwrite("i)", 2);
-}
-
-void
-runtime·printuint_c(uint64 v)
-{
-	byte buf[100];
-	int32 i;
-
-	for(i=nelem(buf)-1; i>0; i--) {
-		buf[i] = v%10 + '0';
-		if(v < 10)
-			break;
-		v = v/10;
-	}
-	gwrite(buf+i, nelem(buf)-i);
-}
-
-void
-runtime·printint_c(int64 v)
-{
-	if(v < 0) {
-		gwrite("-", 1);
-		v = -v;
-	}
-	runtime·printuint_c(v);
-}
-
-void
-runtime·printhex_c(uint64 v)
-{
-	static int8 *dig = "0123456789abcdef";
-	byte buf[100];
-	int32 i;
-
-	i=nelem(buf);
-	for(; v>0; v/=16)
-		buf[--i] = dig[v%16];
-	if(i == nelem(buf))
-		buf[--i] = '0';
-	buf[--i] = 'x';
-	buf[--i] = '0';
-	gwrite(buf+i, nelem(buf)-i);
-}
-
-void
-runtime·printpointer_c(void *p)
-{
-	runtime·printhex_c((uintptr)p);
-}
-
-void
-runtime·printstring_c(String v)
-{
-	if(v.len > runtime·maxstring) {
-		gwrite("[string too long]", 17);
-		return;
-	}
-	if(v.len > 0)
-		gwrite(v.str, v.len);
-}
-
-void
-runtime·printslice_c(Slice s)
-{
-	runtime·prints("[");
-	runtime·printint_c(s.len);
-	runtime·prints("/");
-	runtime·printint_c(s.cap);
-	runtime·prints("]");
-	runtime·printpointer_c(s.array);
-}
-
-void
-runtime·printeface_c(Eface e)
-{
-	runtime·printf("(%p,%p)", e.type, e.data);
-}
-
-void
-runtime·printiface_c(Iface i)
-{
-	runtime·printf("(%p,%p)", i.tab, i.data);
-}
-
-void
-runtime·printstring_m(void)
-{
-	String s;
-
-	s.str = g->m->ptrarg[0];
-	g->m->ptrarg[0] = nil;
-	s.len = g->m->scalararg[0];
-	runtime·printstring_c(s);
-}
-
-void
-runtime·printuint_m(void)
-{
-	runtime·printuint_c(*(uint64*)(&g->m->scalararg[0]));
-}
-
-void
-runtime·printhex_m(void)
-{
-	runtime·printhex_c(g->m->scalararg[0]);
-}
-
-void
-runtime·printfloat_m(void)
-{
-	runtime·printfloat_c(*(float64*)(&g->m->scalararg[0]));
-}
diff --git a/src/pkg/runtime/print.go b/src/pkg/runtime/print.go
deleted file mode 100644
index fd79bc8dd6..0000000000
--- a/src/pkg/runtime/print.go
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-
-import (
-	"unsafe"
-)
-
-// these 4 functions are complicated enough that we will share
-// the print logic with the C printf.
-var (
-	printstring_m,
-	printuint_m,
-	printhex_m,
-	printfloat_m mFunction
-)
-
-func printstring(s string) {
-	mp := acquirem()
-	mp.scalararg[0] = uintptr(len(s))
-	mp.ptrarg[0] = (*stringStruct)(unsafe.Pointer(&s)).str
-	onM(&printstring_m)
-	releasem(mp)
-}
-
-func printuint(x uint64) {
-	mp := acquirem()
-	*(*uint64)(unsafe.Pointer(&mp.scalararg[0])) = x
-	onM(&printuint_m)
-	releasem(mp)
-}
-
-func printhex(x uintptr) {
-	mp := acquirem()
-	mp.scalararg[0] = uintptr(x)
-	onM(&printhex_m)
-	releasem(mp)
-}
-
-func printfloat(x float64) {
-	mp := acquirem()
-	*(*float64)(unsafe.Pointer(&mp.scalararg[0])) = x
-	onM(&printfloat_m)
-	releasem(mp)
-}
-
-// all other print functions are expressible as combinations
-// of the above 4 functions.
-func printnl() {
-	printstring("\n")
-}
-
-func printsp() {
-	printstring(" ")
-}
-
-func printbool(b bool) {
-	if b {
-		printstring("true")
-	} else {
-		printstring("false")
-	}
-}
-
-func printpointer(p unsafe.Pointer) {
-	printhex(uintptr(p))
-}
-
-func printint(x int64) {
-	if x < 0 {
-		printstring("-")
-		x = -x
-	}
-	printuint(uint64(x))
-}
-
-func printcomplex(x complex128) {
-	printstring("(")
-	printfloat(real(x))
-	printfloat(imag(x))
-	printstring("i)")
-}
-
-func printiface(i interface {
-	f()
-}) {
-	printstring("(")
-	printhex((*[2]uintptr)(unsafe.Pointer(&i))[0])
-	printstring(",")
-	printhex((*[2]uintptr)(unsafe.Pointer(&i))[1])
-	printstring(")")
-}
-
-func printeface(e interface{}) {
-	printstring("(")
-	printhex((*[2]uintptr)(unsafe.Pointer(&e))[0])
-	printstring(",")
-	printhex((*[2]uintptr)(unsafe.Pointer(&e))[1])
-	printstring(")")
-}
-
-func printslice(b []byte) {
-	printstring("[")
-	printint(int64(len(b)))
-	printstring("/")
-	printint(int64(cap(b)))
-	printstring("]")
-	printhex((*[3]uintptr)(unsafe.Pointer(&b))[0])
-}
diff --git a/src/pkg/runtime/print1.go b/src/pkg/runtime/print1.go
new file mode 100644
index 0000000000..94ba9e4733
--- /dev/null
+++ b/src/pkg/runtime/print1.go
@@ -0,0 +1,338 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+//go:noescape
+func gostring(*byte) string
+
+func bytes(s string) (ret []byte) {
+	rp := (*slice)(unsafe.Pointer(&ret))
+	sp := (*_string)(noescape(unsafe.Pointer(&s)))
+	rp.array = sp.str
+	rp.len = uint(sp.len)
+	rp.cap = uint(sp.len)
+	return
+}
+
+// goprintf is the function call that is actually deferred when you write
+//	defer print(...)
+// It is otherwise unused. In particular it is not used for ordinary prints.
+// Right now a dynamically allocated string that is being passed as an
+// argument is invisible to the garbage collector and might be collected
+// if that argument list is the only reference. For now we ignore that possibility.
+// To fix, we should change to defer a call to vprintf with a pointer to
+// an argument list on the stack, stored in an appropriately typed
+// struct. golang.org/issue/8614.
+//go:nosplit
+func goprintf(s string) {
+	vprintf(s, add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
+}
+
+// printf is only called from C code. It has the same problem as goprintf
+// with strings possibly being collected from underneath.
+// However, the runtime never prints dynamically allocated
+// Go strings using printf. The strings it prints come from the symbol
+// and type tables.
+//go:nosplit
+func printf(s *byte) {
+	vprintf(gostring(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
+}
+
+// sprintf is only called from C code.
+// It has the same problem as goprintf.
+//go:nosplit
+func snprintf(dst *byte, n int32, s *byte) {
+	buf := (*[1 << 30]byte)(unsafe.Pointer(dst))[0:0:n]
+
+	gp := getg()
+	gp.writebuf = buf[0:0 : n-1] // leave room for NUL, this is called from C
+	vprintf(gostring(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
+	buf[len(gp.writebuf)] = '\x00'
+	gp.writebuf = nil
+}
+
+//var debuglock mutex
+
+// write to goroutine-local buffer if diverting output,
+// or else standard error.
+func gwrite(b []byte) {
+	if len(b) == 0 {
+		return
+	}
+	gp := getg()
+	if gp == nil || gp.writebuf == nil {
+		write(2, unsafe.Pointer(&b[0]), int32(len(b)))
+		return
+	}
+
+	n := copy(gp.writebuf[len(gp.writebuf):cap(gp.writebuf)], b)
+	gp.writebuf = gp.writebuf[:len(gp.writebuf)+n]
+}
+
+func prints(s *byte) {
+	b := (*[1 << 30]byte)(unsafe.Pointer(s))
+	for i := 0; ; i++ {
+		if b[i] == 0 {
+			gwrite(b[:i])
+			return
+		}
+	}
+}
+
+func printsp() {
+	print(" ")
+}
+
+func printnl() {
+	print("\n")
+}
+
+// Very simple printf.  Only for debugging prints.
+// Do not add to this without checking with Rob.
+func vprintf(str string, arg unsafe.Pointer) {
+	//lock(&debuglock);
+
+	s := bytes(str)
+	start := 0
+	i := 0
+	for ; i < len(s); i++ {
+		if s[i] != '%' {
+			continue
+		}
+		if i > start {
+			gwrite(s[start:i])
+		}
+		if i++; i >= len(s) {
+			break
+		}
+		var siz uintptr
+		switch s[i] {
+		case 't', 'c':
+			siz = 1
+		case 'd', 'x': // 32-bit
+			arg = roundup(arg, 4)
+			siz = 4
+		case 'D', 'U', 'X', 'f': // 64-bit
+			arg = roundup(arg, unsafe.Sizeof(uintreg(0)))
+			siz = 8
+		case 'C':
+			arg = roundup(arg, unsafe.Sizeof(uintreg(0)))
+			siz = 16
+		case 'p', 's': // pointer-sized
+			arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
+			siz = unsafe.Sizeof(uintptr(0))
+		case 'S': // pointer-aligned but bigger
+			arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
+			siz = unsafe.Sizeof(string(""))
+		case 'a': // pointer-aligned but bigger
+			arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
+			siz = unsafe.Sizeof([]byte{})
+		case 'i', 'e': // pointer-aligned but bigger
+			arg = roundup(arg, unsafe.Sizeof(uintptr(0)))
+			siz = unsafe.Sizeof(interface{}(nil))
+		}
+		switch s[i] {
+		case 'a':
+			printslice(*(*[]byte)(arg))
+		case 'c':
+			printbyte(*(*byte)(arg))
+		case 'd':
+			printint(int64(*(*int32)(arg)))
+		case 'D':
+			printint(int64(*(*int64)(arg)))
+		case 'e':
+			printeface(*(*interface{})(arg))
+		case 'f':
+			printfloat(*(*float64)(arg))
+		case 'C':
+			printcomplex(*(*complex128)(arg))
+		case 'i':
+			printiface(*(*fInterface)(arg))
+		case 'p':
+			printpointer(*(*unsafe.Pointer)(arg))
+		case 's':
+			prints(*(**byte)(arg))
+		case 'S':
+			printstring(*(*string)(arg))
+		case 't':
+			printbool(*(*bool)(arg))
+		case 'U':
+			printuint(*(*uint64)(arg))
+		case 'x':
+			printhex(uint64(*(*uint32)(arg)))
+		case 'X':
+			printhex(*(*uint64)(arg))
+		}
+		arg = add(arg, siz)
+		start = i + 1
+	}
+	if start < i {
+		gwrite(s[start:i])
+	}
+
+	//unlock(&debuglock);
+}
+
+func printpc(p unsafe.Pointer) {
+	print("PC=")
+	printhex(uint64(getcallerpc(p)))
+}
+
+func printbool(v bool) {
+	if v {
+		print("true")
+	} else {
+		print("false")
+	}
+}
+
+func printbyte(c byte) {
+	gwrite((*[1]byte)(unsafe.Pointer(&c))[:])
+}
+
+func printfloat(v float64) {
+	switch {
+	case v != v:
+		print("NaN")
+		return
+	case v+v == v && v > 0:
+		print("+Inf")
+		return
+	case v+v == v && v < 0:
+		print("-Inf")
+		return
+	}
+
+	const n = 7 // digits printed
+	var buf [n + 7]byte
+	buf[0] = '+'
+	e := 0 // exp
+	if v == 0 {
+		if 1/v < 0 {
+			buf[0] = '-'
+		}
+	} else {
+		if v < 0 {
+			v = -v
+			buf[0] = '-'
+		}
+
+		// normalize
+		for v >= 10 {
+			e++
+			v /= 10
+		}
+		for v < 1 {
+			e--
+			v *= 10
+		}
+
+		// round
+		h := 5.0
+		for i := 0; i < n; i++ {
+			h /= 10
+		}
+		v += h
+		if v >= 10 {
+			e++
+			v /= 10
+		}
+	}
+
+	// format +d.dddd+edd
+	for i := 0; i < n; i++ {
+		s := int(v)
+		buf[i+2] = byte(s + '0')
+		v -= float64(s)
+		v *= 10
+	}
+	buf[1] = buf[2]
+	buf[2] = '.'
+
+	buf[n+2] = 'e'
+	buf[n+3] = '+'
+	if e < 0 {
+		e = -e
+		buf[n+3] = '-'
+	}
+
+	buf[n+4] = byte(e/100) + '0'
+	buf[n+5] = byte(e/10)%10 + '0'
+	buf[n+6] = byte(e%10) + '0'
+	gwrite(buf[:])
+}
+
+func printcomplex(c complex128) {
+	print("(", real(c), imag(c), "i)")
+}
+
+func printuint(v uint64) {
+	var buf [100]byte
+	i := len(buf)
+	for i--; i > 0; i-- {
+		buf[i] = byte(v%10 + '0')
+		if v < 10 {
+			break
+		}
+		v /= 10
+	}
+	gwrite(buf[i:])
+}
+
+func printint(v int64) {
+	if v < 0 {
+		print("-")
+		v = -v
+	}
+	printuint(uint64(v))
+}
+
+func printhex(v uint64) {
+	const dig = "0123456789abcdef"
+	var buf [100]byte
+	i := len(buf)
+	for i--; i > 0; i-- {
+		buf[i] = dig[v%16]
+		if v < 16 {
+			break
+		}
+		v /= 16
+	}
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+	gwrite(buf[i:])
+}
+
+func printpointer(p unsafe.Pointer) {
+	printhex(uint64(uintptr(p)))
+}
+
+func printstring(s string) {
+	if uintptr(len(s)) > maxstring {
+		gwrite(bytes("[string too long]"))
+		return
+	}
+	gwrite(bytes(s))
+}
+
+func printslice(s []byte) {
+	sp := (*slice)(unsafe.Pointer(&s))
+	print("[", len(s), "/", cap(s), "]")
+	printpointer(unsafe.Pointer(sp.array))
+}
+
+func printeface(e interface{}) {
+	ep := (*eface)(unsafe.Pointer(&e))
+	print("(", ep._type, ",", ep.data, ")")
+}
+
+func printiface(i fInterface) {
+	ip := (*iface)(unsafe.Pointer(&i))
+	print("(", ip.tab, ",", ip.data, ")")
+}
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 8263202e93..194928373c 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1648,8 +1648,9 @@ goexit0(G *gp)
 	gp->paniconfault = 0;
 	gp->defer = nil; // should be true already but just in case.
 	gp->panic = nil; // non-nil for Goexit during panic. points at stack-allocated data.
-	gp->writenbuf = 0;
-	gp->writebuf = nil;
+	gp->writebuf.array = nil;
+	gp->writebuf.len = 0;
+	gp->writebuf.cap = 0;
 	gp->waitreason.str = nil;
 	gp->waitreason.len = 0;
 	gp->param = nil;
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 90cb3cbd7f..4dfc4f2c42 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -297,7 +297,7 @@ struct	G
 	M*	lockedm;
 	int32	sig;
 	int32	writenbuf;
-	byte*	writebuf;
+	Slice	writebuf;
 	uintptr	sigcode0;
 	uintptr	sigcode1;
 	uintptr	sigpc;
@@ -828,7 +828,7 @@ void	runtime·panicstring(int8*);
 bool	runtime·canpanic(G*);
 void	runtime·prints(int8*);
 void	runtime·printf(int8*, ...);
-int32	runtime·snprintf(byte*, int32, int8*, ...);
+void	runtime·snprintf(byte*, int32, int8*, ...);
 byte*	runtime·mchr(byte*, byte, byte*);
 int32	runtime·mcmp(byte*, byte*, uintptr);
 void	runtime·memmove(void*, void*, uintptr);
@@ -1063,19 +1063,19 @@ void	runtime·madvise(byte*, uintptr, int32);
 void	runtime·memclr(byte*, uintptr);
 void	runtime·setcallerpc(void*, void*);
 void*	runtime·getcallerpc(void*);
-void	runtime·printbool_c(bool);
-void	runtime·printbyte_c(int8);
-void	runtime·printfloat_c(float64);
-void	runtime·printint_c(int64);
-void	runtime·printiface_c(Iface);
-void	runtime·printeface_c(Eface);
-void	runtime·printstring_c(String);
-void	runtime·printpc_c(void*);
-void	runtime·printpointer_c(void*);
-void	runtime·printuint_c(uint64);
-void	runtime·printhex_c(uint64);
-void	runtime·printslice_c(Slice);
-void	runtime·printcomplex_c(Complex128);
+void	runtime·printbool(bool);
+void	runtime·printbyte(int8);
+void	runtime·printfloat(float64);
+void	runtime·printint(int64);
+void	runtime·printiface(Iface);
+void	runtime·printeface(Eface);
+void	runtime·printstring(String);
+void	runtime·printpc(void*);
+void	runtime·printpointer(void*);
+void	runtime·printuint(uint64);
+void	runtime·printhex(uint64);
+void	runtime·printslice(Slice);
+void	runtime·printcomplex(Complex128);
 
 /*
  * runtime go-called
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index f69a0410fa..26126fcf9a 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -173,7 +173,6 @@ func gogo(buf *gobuf)
 func gosave(buf *gobuf)
 func open(name *byte, mode, perm int32) int32
 func read(fd int32, p unsafe.Pointer, n int32) int32
-func write(fd uintptr, p unsafe.Pointer, n int32) int32
 func close(fd int32) int32
 func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
 func jmpdefer(fv *funcval, argp unsafe.Pointer)
@@ -205,6 +204,9 @@ func lock(lk *mutex)
 func unlock(lk *mutex)
 func purgecachedstats(c *mcache)
 
+//go:noescape
+func write(fd uintptr, p unsafe.Pointer, n int32) int32
+
 //go:noescape
 func cas(ptr *uint32, old, new uint32) bool
 
diff --git a/src/pkg/runtime/traceback_arm.c b/src/pkg/runtime/traceback_arm.c
index 0ae40a6484..5e937cbfb6 100644
--- a/src/pkg/runtime/traceback_arm.c
+++ b/src/pkg/runtime/traceback_arm.c
@@ -234,7 +234,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 					}
 					if(i != 0)
 						runtime·prints(", ");
-					runtime·printhex_c(((uintptr*)frame.argp)[i]);
+					runtime·printhex(((uintptr*)frame.argp)[i]);
 				}
 				runtime·prints(")\n");
 				line = runtime·funcline(f, tracepc, &file);
diff --git a/src/pkg/runtime/traceback_x86.c b/src/pkg/runtime/traceback_x86.c
index 7c76daf4cf..f3ba702b9b 100644
--- a/src/pkg/runtime/traceback_x86.c
+++ b/src/pkg/runtime/traceback_x86.c
@@ -270,7 +270,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 					}
 					if(i != 0)
 						runtime·prints(", ");
-					runtime·printhex_c(((uintptr*)frame.argp)[i]);
+					runtime·printhex(((uintptr*)frame.argp)[i]);
 				}
 				runtime·prints(")\n");
 				line = runtime·funcline(f, tracepc, &file);

From b930b433b0cedb9a5ddab9b1de3d30bfd5ddfa60 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Fri, 29 Aug 2014 12:28:31 +0900
Subject: [PATCH 275/423] net: add more cases to lookup API test

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/126450043
---
 src/pkg/net/lookup_test.go | 172 ++++++++++++++++++++++++++++---------
 1 file changed, 133 insertions(+), 39 deletions(-)

diff --git a/src/pkg/net/lookup_test.go b/src/pkg/net/lookup_test.go
index 3355e46948..057e1322b9 100644
--- a/src/pkg/net/lookup_test.go
+++ b/src/pkg/net/lookup_test.go
@@ -15,77 +15,129 @@ import (
 
 var testExternal = flag.Bool("external", true, "allow use of external networks during long test")
 
-func TestGoogleSRV(t *testing.T) {
+var lookupGoogleSRVTests = []struct {
+	service, proto, name string
+	cname, target        string
+}{
+	{
+		"xmpp-server", "tcp", "google.com",
+		".google.com", ".google.com",
+	},
+	{
+		"", "", "_xmpp-server._tcp.google.com", // non-standard back door
+		".google.com", ".google.com",
+	},
+}
+
+func TestLookupGoogleSRV(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("skipping test to avoid external network")
 	}
-	_, addrs, err := LookupSRV("xmpp-server", "tcp", "google.com")
-	if err != nil {
-		t.Errorf("failed: %s", err)
-	}
-	if len(addrs) == 0 {
-		t.Errorf("no results")
-	}
 
-	// Non-standard back door.
-	_, addrs, err = LookupSRV("", "", "_xmpp-server._tcp.google.com")
-	if err != nil {
-		t.Errorf("back door failed: %s", err)
-	}
-	if len(addrs) == 0 {
-		t.Errorf("back door no results")
+	for _, tt := range lookupGoogleSRVTests {
+		cname, srvs, err := LookupSRV(tt.service, tt.proto, tt.name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(srvs) == 0 {
+			t.Error("got no record")
+		}
+		if !strings.Contains(cname, tt.cname) {
+			t.Errorf("got %q; want %q", cname, tt.cname)
+		}
+		for _, srv := range srvs {
+			if !strings.Contains(srv.Target, tt.target) {
+				t.Errorf("got %v; want a record containing %q", srv, tt.target)
+			}
+		}
 	}
 }
 
-func TestGmailMX(t *testing.T) {
+func TestLookupGmailMX(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("skipping test to avoid external network")
 	}
-	mx, err := LookupMX("gmail.com")
+
+	mxs, err := LookupMX("gmail.com")
 	if err != nil {
-		t.Errorf("failed: %s", err)
+		t.Fatal(err)
 	}
-	if len(mx) == 0 {
-		t.Errorf("no results")
+	if len(mxs) == 0 {
+		t.Error("got no record")
+	}
+	for _, mx := range mxs {
+		if !strings.Contains(mx.Host, ".google.com") {
+			t.Errorf("got %v; want a record containing .google.com.", mx)
+		}
 	}
 }
 
-func TestGmailNS(t *testing.T) {
+func TestLookupGmailNS(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("skipping test to avoid external network")
 	}
-	ns, err := LookupNS("gmail.com")
+
+	nss, err := LookupNS("gmail.com")
 	if err != nil {
-		t.Errorf("failed: %s", err)
+		t.Fatal(err)
 	}
-	if len(ns) == 0 {
-		t.Errorf("no results")
+	if len(nss) == 0 {
+		t.Error("got no record")
+	}
+	for _, ns := range nss {
+		if !strings.Contains(ns.Host, ".google.com") {
+			t.Errorf("got %v; want a record containing .google.com.", ns)
+		}
 	}
 }
 
-func TestGmailTXT(t *testing.T) {
+func TestLookupGmailTXT(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("skipping test to avoid external network")
 	}
-	txt, err := LookupTXT("gmail.com")
+
+	txts, err := LookupTXT("gmail.com")
 	if err != nil {
-		t.Errorf("failed: %s", err)
+		t.Fatal(err)
 	}
-	if len(txt) == 0 || len(txt[0]) == 0 {
-		t.Errorf("no results")
+	if len(txts) == 0 {
+		t.Error("got no record")
+	}
+	for _, txt := range txts {
+		if !strings.Contains(txt, "spf") {
+			t.Errorf("got %q; want a spf record", txt)
+		}
 	}
 }
 
-func TestGoogleDNSAddr(t *testing.T) {
+var lookupGooglePublicDNSAddrs = []struct {
+	addr string
+	name string
+}{
+	{"8.8.8.8", ".google.com."},
+	{"8.8.4.4", ".google.com."},
+	{"2001:4860:4860::8888", ".google.com."},
+	{"2001:4860:4860::8844", ".google.com."},
+}
+
+func TestLookupGooglePublicDNSAddr(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("skipping test to avoid external network")
 	}
-	names, err := LookupAddr("8.8.8.8")
-	if err != nil {
-		t.Errorf("failed: %s", err)
-	}
-	if len(names) == 0 {
-		t.Errorf("no results")
+
+	for _, tt := range lookupGooglePublicDNSAddrs {
+		names, err := LookupAddr(tt.addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(names) == 0 {
+			t.Error("got no record")
+		}
+		for _, name := range names {
+			if !strings.HasSuffix(name, tt.name) {
+				t.Errorf("got %q; want a record containing %q", name, tt.name)
+			}
+		}
 	}
 }
 
@@ -93,9 +145,51 @@ func TestLookupIANACNAME(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("skipping test to avoid external network")
 	}
+
 	cname, err := LookupCNAME("www.iana.org")
-	if !strings.HasSuffix(cname, ".icann.org.") || err != nil {
-		t.Errorf(`LookupCNAME("www.iana.org.") = %q, %v, want "*.icann.org.", nil`, cname, err)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasSuffix(cname, ".icann.org.") {
+		t.Errorf("got %q; want a record containing .icann.org.", cname)
+	}
+}
+
+func TestLookupGoogleHost(t *testing.T) {
+	if testing.Short() || !*testExternal {
+		t.Skip("skipping test to avoid external network")
+	}
+
+	addrs, err := LookupHost("google.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(addrs) == 0 {
+		t.Error("got no record")
+	}
+	for _, addr := range addrs {
+		if ParseIP(addr) == nil {
+			t.Errorf("got %q; want a literal ip address", addr)
+		}
+	}
+}
+
+func TestLookupGoogleIP(t *testing.T) {
+	if testing.Short() || !*testExternal {
+		t.Skip("skipping test to avoid external network")
+	}
+
+	ips, err := LookupIP("google.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ips) == 0 {
+		t.Error("got no record")
+	}
+	for _, ip := range ips {
+		if ip.To4() == nil && ip.To16() == nil {
+			t.Errorf("got %v; want an ip address", ip)
+		}
 	}
 }
 

From 6a76bca33ffc83254edb9878679f11f4ba8e1b37 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Thu, 28 Aug 2014 21:35:59 -0700
Subject: [PATCH 276/423] runtime: convert closechan/chanlen/chancap to Go

LGTM=bradfitz, rsc
R=golang-codereviews, bradfitz, rsc
CC=golang-codereviews
https://golang.org/cl/135150043
---
 src/pkg/runtime/chan.go  | 75 ++++++++++++++++++++++++++++++++++++----
 src/pkg/runtime/chan.goc | 75 ----------------------------------------
 src/pkg/runtime/thunk.s  |  9 +++++
 3 files changed, 77 insertions(+), 82 deletions(-)

diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index fe7e72edc2..239c29f9e2 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -150,12 +150,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 				memmove(unsafe.Pointer(sg.elem), ep, uintptr(c.elemsize))
 			}
 			if sg.releasetime != 0 {
-				// Yes, this is ugly.  On 64-bit sg.releasetime has type
-				// int.  On 32-bit it has type int64.  There's no easy way
-				// to assign to both types in Go.  At some point we'll
-				// write the Go types directly instead of generating them
-				// via the C types.  At that point, this nastiness goes away.
-				*(*int64)(unsafe.Pointer(&sg.releasetime)) = cputicks()
+				sg.releasetime = cputicks()
 			}
 			goready(recvg)
 			return true
@@ -248,7 +243,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		recvg := sg.g
 		unlock(&c.lock)
 		if sg.releasetime != 0 {
-			*(*int64)(unsafe.Pointer(&sg.releasetime)) = cputicks()
+			sg.releasetime = cputicks()
 		}
 		goready(recvg)
 	} else {
@@ -260,6 +255,72 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 	return true
 }
 
+func closechan(c *hchan) {
+	if c == nil {
+		panic("close of nil channel")
+	}
+
+	lock(&c.lock)
+	if c.closed != 0 {
+		unlock(&c.lock)
+		panic("close of closed channel")
+	}
+
+	if raceenabled {
+		callerpc := getcallerpc(unsafe.Pointer(&c))
+		fn := closechan
+		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		racewritepc(unsafe.Pointer(c), callerpc, pc)
+		racerelease(unsafe.Pointer(c))
+	}
+
+	c.closed = 1
+
+	// release all readers
+	for {
+		sg := c.recvq.dequeue()
+		if sg == nil {
+			break
+		}
+		gp := sg.g
+		gp.param = nil
+		if sg.releasetime != 0 {
+			sg.releasetime = cputicks()
+		}
+		goready(gp)
+	}
+
+	// release all writers
+	for {
+		sg := c.sendq.dequeue()
+		if sg == nil {
+			break
+		}
+		gp := sg.g
+		gp.param = nil
+		if sg.releasetime != 0 {
+			sg.releasetime = cputicks()
+		}
+		goready(gp)
+	}
+
+	unlock(&c.lock)
+}
+
+func reflect_chanlen(c *hchan) int {
+	if c == nil {
+		return 0
+	}
+	return int(c.qcount)
+}
+
+func reflect_chancap(c *hchan) int {
+	if c == nil {
+		return 0
+	}
+	return int(c.dataqsiz)
+}
+
 func (q *waitq) enqueue(sgp *sudog) {
 	sgp.next = nil
 	if q.first == nil {
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 7d6ee1be2b..a4a0d1d9ba 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -1005,81 +1005,6 @@ func reflect·rselect(cases Slice) (chosen int, recvOK bool) {
 	chosen = (intgo)(uintptr)selectgo(&sel);
 }
 
-static void closechan(Hchan *c, void *pc);
-
-#pragma textflag NOSPLIT
-func closechan(c *Hchan) {
-	closechan(c, runtime·getcallerpc(&c));
-}
-
-#pragma textflag NOSPLIT
-func reflect·chanclose(c *Hchan) {
-	closechan(c, runtime·getcallerpc(&c));
-}
-
-static void
-closechan(Hchan *c, void *pc)
-{
-	SudoG *sg;
-	G* gp;
-
-	if(c == nil)
-		runtime·panicstring("close of nil channel");
-
-	runtime·lock(&c->lock);
-	if(c->closed) {
-		runtime·unlock(&c->lock);
-		runtime·panicstring("close of closed channel");
-	}
-
-	if(raceenabled) {
-		runtime·racewritepc(c, pc, runtime·closechan);
-		runtime·racerelease(c);
-	}
-
-	c->closed = true;
-
-	// release all readers
-	for(;;) {
-		sg = dequeue(&c->recvq);
-		if(sg == nil)
-			break;
-		gp = sg->g;
-		gp->param = nil;
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-	}
-
-	// release all writers
-	for(;;) {
-		sg = dequeue(&c->sendq);
-		if(sg == nil)
-			break;
-		gp = sg->g;
-		gp->param = nil;
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-	}
-
-	runtime·unlock(&c->lock);
-}
-
-func reflect·chanlen(c *Hchan) (len int) {
-	if(c == nil)
-		len = 0;
-	else
-		len = c->qcount;
-}
-
-func reflect·chancap(c *Hchan) (cap int) {
-	if(c == nil)
-		cap = 0;
-	else
-		cap = c->dataqsiz;
-}
-
 static SudoG*
 dequeue(WaitQ *q)
 {
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 4d2a49829c..6093656c6f 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -52,3 +52,12 @@ TEXT bytes·Compare(SB),NOSPLIT,$0-0
 
 TEXT runtime·reflectcall(SB), NOSPLIT, $0-0
 	JMP	reflect·call(SB)
+
+TEXT reflect·chanclose(SB), NOSPLIT, $0-0
+	JMP	runtime·closechan(SB)
+
+TEXT reflect·chanlen(SB), NOSPLIT, $0-0
+	JMP	runtime·reflect_chanlen(SB)
+
+TEXT reflect·chancap(SB), NOSPLIT, $0-0
+	JMP	runtime·reflect_chancap(SB)

From ef64d9ffcc237fde9bcaed1fd00c5036c4f489de Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Thu, 28 Aug 2014 23:26:50 -0700
Subject: [PATCH 277/423] runtime: don't allocate a new string in printf

LGTM=dave
R=rsc, dave
CC=golang-codereviews
https://golang.org/cl/139890043
---
 src/pkg/runtime/print1.go | 2 +-
 src/pkg/runtime/string.c  | 1 +
 src/pkg/runtime/stubs.go  | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/print1.go b/src/pkg/runtime/print1.go
index 94ba9e4733..9df6a621bb 100644
--- a/src/pkg/runtime/print1.go
+++ b/src/pkg/runtime/print1.go
@@ -39,7 +39,7 @@ func goprintf(s string) {
 // and type tables.
 //go:nosplit
 func printf(s *byte) {
-	vprintf(gostring(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
+	vprintf(gostringnocopy(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
 }
 
 // sprintf is only called from C code.
diff --git a/src/pkg/runtime/string.c b/src/pkg/runtime/string.c
index 60a0545a9a..5421b53196 100644
--- a/src/pkg/runtime/string.c
+++ b/src/pkg/runtime/string.c
@@ -90,6 +90,7 @@ runtime·gobytes(byte *p, intgo n)
 	return sl;
 }
 
+#pragma textflag NOSPLIT
 String
 runtime·gostringnocopy(byte *str)
 {
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 26126fcf9a..2014dfbf90 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -203,6 +203,7 @@ func noteclear(n *note)
 func lock(lk *mutex)
 func unlock(lk *mutex)
 func purgecachedstats(c *mcache)
+func gostringnocopy(b *byte) string
 
 //go:noescape
 func write(fd uintptr, p unsafe.Pointer, n int32) int32

From 42486ffc5d435e01ca9491b64d3a52d39de169d7 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 29 Aug 2014 11:08:10 +0400
Subject: [PATCH 278/423] runtime: convert forcegc helper to Go Also fix a
 bunch of bugs: 1. Accesses to last_gc must be atomic (it's int64). 2. last_gc
 still can be 0 during first checks in sysmon, check for 0. 3. forcegc.g can
 be unitialized when sysmon accesses it:         forcegc.g is initialized by
 main goroutine (forcegc.g = newproc1(...)),         and main goroutine is
 unsynchronized with both sysmon and forcegc goroutine.         Initialize
 forcegc.g in the forcegc goroutine itself instead.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rsc
https://golang.org/cl/136770043
---
 src/pkg/runtime/mgc0.c    |  2 +-
 src/pkg/runtime/proc.c    | 44 ++++++++-------------------------------
 src/pkg/runtime/proc.go   | 21 +++++++++++++++++++
 src/pkg/runtime/runtime.h |  9 ++++++++
 4 files changed, 40 insertions(+), 36 deletions(-)

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 4933712571..03eb2d9866 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1450,7 +1450,7 @@ gc(struct gc_args *args)
 	mstats.next_gc = mstats.heap_alloc+mstats.heap_alloc*runtime·gcpercent/100;
 
 	t4 = runtime·nanotime();
-	mstats.last_gc = runtime·unixnanotime();  // must be Unix time to make sense to user
+	runtime·atomicstore64(&mstats.last_gc, runtime·unixnanotime());  // must be Unix time to make sense to user
 	mstats.pause_ns[mstats.numgc%nelem(mstats.pause_ns)] = t4 - t0;
 	mstats.pause_total_ns += t4 - t0;
 	mstats.numgc++;
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 194928373c..66c5d475bb 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -88,6 +88,7 @@ static	Mutex allglock;	// the following vars are protected by this lock or by st
 G**	runtime·allg;
 uintptr runtime·allglen;
 static	uintptr allgcap;
+ForceGCState	runtime·forcegc;
 
 void runtime·mstart(void);
 static void runqput(P*, G*);
@@ -130,15 +131,6 @@ static bool exitsyscallfast(void);
 static bool haveexperiment(int8*);
 static void allgadd(G*);
 
-static void forcegchelper(void);
-static struct
-{
-	Mutex	lock;
-	G*	g;
-	FuncVal	fv;
-	uint32	idle;
-} forcegc;
-
 extern String runtime·buildVersion;
 
 // The bootstrap sequence is:
@@ -254,8 +246,6 @@ runtime·main(void)
 
 	if(g->m != &runtime·m0)
 		runtime·throw("runtime·main not on m0");
-	forcegc.fv.fn = forcegchelper;
-	forcegc.g = runtime·newproc1(&forcegc.fv, nil, 0, 0, runtime·main);
 	main·init();
 
 	if(g->defer != &d || d.fn != &initDone)
@@ -2779,7 +2769,7 @@ static void
 sysmon(void)
 {
 	uint32 idle, delay, nscavenge;
-	int64 now, unixnow, lastpoll, lasttrace;
+	int64 now, unixnow, lastpoll, lasttrace, lastgc;
 	int64 forcegcperiod, scavengelimit, lastscavenge, maxsleep;
 	G *gp;
 
@@ -2854,12 +2844,13 @@ sysmon(void)
 			idle++;
 
 		// check if we need to force a GC
-		if(unixnow - mstats.last_gc > forcegcperiod && runtime·atomicload(&forcegc.idle)) {
-			runtime·lock(&forcegc.lock);
-			forcegc.idle = 0;
-			forcegc.g->schedlink = nil;
-			injectglist(forcegc.g);
-			runtime·unlock(&forcegc.lock);
+		lastgc = runtime·atomicload64(&mstats.last_gc);
+		if(lastgc != 0 && unixnow - lastgc > forcegcperiod && runtime·atomicload(&runtime·forcegc.idle)) {
+			runtime·lock(&runtime·forcegc.lock);
+			runtime·forcegc.idle = 0;
+			runtime·forcegc.g->schedlink = nil;
+			injectglist(runtime·forcegc.g);
+			runtime·unlock(&runtime·forcegc.lock);
 		}
 
 		// scavenge heap once in a while
@@ -2943,23 +2934,6 @@ retake(int64 now)
 	return n;
 }
 
-static void
-forcegchelper(void)
-{
-	g->issystem = true;
-	for(;;) {
-		runtime·lock(&forcegc.lock);
-		if(forcegc.idle)
-			runtime·throw("forcegc: phase error");
-		runtime·atomicstore(&forcegc.idle, 1);
-		runtime·parkunlock(&forcegc.lock, runtime·gostringnocopy((byte*)"force gc (idle)"));
-		// this goroutine is explicitly resumed by sysmon
-		if(runtime·debug.gctrace > 0)
-			runtime·printf("GC forced\n");
-		runtime·gc(1);
-	}
-}
-
 // Tell all goroutines that they have been preempted and they should stop.
 // This function is purely best-effort.  It can fail to inform a goroutine if a
 // processor just started running it.
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 32fe35e28c..6c295c7b18 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -29,6 +29,27 @@ const (
 
 var parkunlock_c byte
 
+// start forcegc helper goroutine
+func init() {
+	go func() {
+		forcegc.g = getg()
+		forcegc.g.issystem = true
+		for {
+			lock(&forcegc.lock)
+			if forcegc.idle != 0 {
+				gothrow("forcegc: phase error")
+			}
+			atomicstore(&forcegc.idle, 1)
+			goparkunlock(&forcegc.lock, "force gc (idle)")
+			// this goroutine is explicitly resumed by sysmon
+			if debug.gctrace > 0 {
+				println("GC forced")
+			}
+			gogc(1)
+		}
+	}()
+}
+
 // Gosched yields the processor, allowing other goroutines to run.  It does not
 // suspend the current goroutine, so execution resumes automatically.
 func Gosched() {
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 4dfc4f2c42..21ccb76b3c 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -92,6 +92,7 @@ typedef	struct	ParForThread	ParForThread;
 typedef	struct	CgoMal		CgoMal;
 typedef	struct	PollDesc	PollDesc;
 typedef	struct	DebugVars	DebugVars;
+typedef struct	ForceGCState	ForceGCState;
 
 /*
  * Per-CPU declaration.
@@ -572,6 +573,13 @@ struct DebugVars
 	int32	scavenge;
 };
 
+struct ForceGCState
+{
+	Mutex	lock;
+	G*	g;
+	uint32	idle;
+};
+
 extern bool runtime·precisestack;
 extern bool runtime·copystack;
 
@@ -774,6 +782,7 @@ extern	uint32	runtime·cpuid_edx;
 extern	DebugVars	runtime·debug;
 extern	uintptr	runtime·maxstacksize;
 extern	Note	runtime·signote;
+extern	ForceGCState	runtime·forcegc;
 
 /*
  * common functions and data

From 9f0b749ba57dc4e922c1d16919cde4b7f9813f58 Mon Sep 17 00:00:00 2001
From: Rui Ueyama <ruiu@google.com>
Date: Fri, 29 Aug 2014 17:17:48 +1000
Subject: [PATCH 279/423] image/png: do not apply filters if level is
 NoCompression

PNG filters are applied to get better compression ratio.
It does not make sense to apply them if we are not going
to compress.

LGTM=nigeltao
R=nigeltao
CC=golang-codereviews
https://golang.org/cl/137830043
---
 src/pkg/image/png/writer.go      |  5 ++++-
 src/pkg/image/png/writer_test.go | 15 +++++++++------
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/pkg/image/png/writer.go b/src/pkg/image/png/writer.go
index 703aeec0a2..b1a70c79d3 100644
--- a/src/pkg/image/png/writer.go
+++ b/src/pkg/image/png/writer.go
@@ -417,7 +417,10 @@ func writeImage(w io.Writer, m image.Image, cb int, level int) error {
 		}
 
 		// Apply the filter.
-		f := filter(&cr, pr, bpp)
+		f := ftNone
+		if level != zlib.NoCompression {
+			f = filter(&cr, pr, bpp)
+		}
 
 		// Write the compressed bytes.
 		if _, err := zw.Write(cr[f]); err != nil {
diff --git a/src/pkg/image/png/writer_test.go b/src/pkg/image/png/writer_test.go
index 6a872e2749..d67a815698 100644
--- a/src/pkg/image/png/writer_test.go
+++ b/src/pkg/image/png/writer_test.go
@@ -81,20 +81,23 @@ func TestWriterLevels(t *testing.T) {
 	m := image.NewNRGBA(image.Rect(0, 0, 100, 100))
 
 	var b1, b2 bytes.Buffer
-	var e1, e2 Encoder
-
-	if err := e1.Encode(&b1, m); err != nil {
+	if err := (&Encoder{}).Encode(&b1, m); err != nil {
 		t.Fatal(err)
 	}
-
-	e2.CompressionLevel = NoCompression
-	if err := e2.Encode(&b2, m); err != nil {
+	noenc := &Encoder{CompressionLevel: NoCompression}
+	if err := noenc.Encode(&b2, m); err != nil {
 		t.Fatal(err)
 	}
 
 	if b2.Len() <= b1.Len() {
 		t.Error("DefaultCompression encoding was larger than NoCompression encoding")
 	}
+	if _, err := Decode(&b1); err != nil {
+		t.Error("cannot decode DefaultCompression")
+	}
+	if _, err := Decode(&b2); err != nil {
+		t.Error("cannot decode NoCompression")
+	}
 }
 
 func TestSubImage(t *testing.T) {

From 73f5010dc68e55abbda56b42a36208d6f2556f76 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 29 Aug 2014 12:44:07 +0400
Subject: [PATCH 280/423] runtime: allow to call stdcall from Go on windows
 I've started with just one function with 8 arguments, but stdcall is called
 from nosplit functions and 8 args overflow nosplit area.

LGTM=aram, alex.brainman
R=golang-codereviews, aram, alex.brainman, dave
CC=golang-codereviews, iant, khr, rsc
https://golang.org/cl/135090043
---
 src/pkg/runtime/mem_windows.c     |  16 +--
 src/pkg/runtime/netpoll_windows.c |  10 +-
 src/pkg/runtime/os_windows.c      | 160 ++++++++++++++++++++++--------
 src/pkg/runtime/os_windows.go     |  11 ++
 src/pkg/runtime/os_windows.h      |  12 ++-
 5 files changed, 149 insertions(+), 60 deletions(-)

diff --git a/src/pkg/runtime/mem_windows.c b/src/pkg/runtime/mem_windows.c
index 77ec6e9262..5eb43b2a93 100644
--- a/src/pkg/runtime/mem_windows.c
+++ b/src/pkg/runtime/mem_windows.c
@@ -29,7 +29,7 @@ void*
 runtime·SysAlloc(uintptr n, uint64 *stat)
 {
 	runtime·xadd64(stat, n);
-	return runtime·stdcall(runtime·VirtualAlloc, 4, nil, n, (uintptr)(MEM_COMMIT|MEM_RESERVE), (uintptr)PAGE_READWRITE);
+	return runtime·stdcall4(runtime·VirtualAlloc, 0, n, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
 }
 
 void
@@ -38,7 +38,7 @@ runtime·SysUnused(void *v, uintptr n)
 	void *r;
 	uintptr small;
 
-	r = runtime·stdcall(runtime·VirtualFree, 3, v, n, (uintptr)MEM_DECOMMIT);
+	r = runtime·stdcall3(runtime·VirtualFree, (uintptr)v, n, MEM_DECOMMIT);
 	if(r != nil)
 		return;
 
@@ -53,7 +53,7 @@ runtime·SysUnused(void *v, uintptr n)
 	// in the worst case, but that's fast enough.
 	while(n > 0) {
 		small = n;
-		while(small >= 4096 && runtime·stdcall(runtime·VirtualFree, 3, v, small, (uintptr)MEM_DECOMMIT) == nil)
+		while(small >= 4096 && runtime·stdcall3(runtime·VirtualFree, (uintptr)v, small, MEM_DECOMMIT) == nil)
 			small = (small / 2) & ~(4096-1);
 		if(small < 4096)
 			runtime·throw("runtime: failed to decommit pages");
@@ -67,7 +67,7 @@ runtime·SysUsed(void *v, uintptr n)
 {
 	void *r;
 
-	r = runtime·stdcall(runtime·VirtualAlloc, 4, v, n, (uintptr)MEM_COMMIT, (uintptr)PAGE_READWRITE);
+	r = runtime·stdcall4(runtime·VirtualAlloc, (uintptr)v, n, MEM_COMMIT, PAGE_READWRITE);
 	if(r != v)
 		runtime·throw("runtime: failed to commit pages");
 }
@@ -78,7 +78,7 @@ runtime·SysFree(void *v, uintptr n, uint64 *stat)
 	uintptr r;
 
 	runtime·xadd64(stat, -(uint64)n);
-	r = (uintptr)runtime·stdcall(runtime·VirtualFree, 3, v, (uintptr)0, (uintptr)MEM_RELEASE);
+	r = (uintptr)runtime·stdcall3(runtime·VirtualFree, (uintptr)v, 0, MEM_RELEASE);
 	if(r == 0)
 		runtime·throw("runtime: failed to release pages");
 }
@@ -96,12 +96,12 @@ runtime·SysReserve(void *v, uintptr n, bool *reserved)
 	*reserved = true;
 	// v is just a hint.
 	// First try at v.
-	v = runtime·stdcall(runtime·VirtualAlloc, 4, v, n, (uintptr)MEM_RESERVE, (uintptr)PAGE_READWRITE);
+	v = runtime·stdcall4(runtime·VirtualAlloc, (uintptr)v, n, MEM_RESERVE, PAGE_READWRITE);
 	if(v != nil)
 		return v;
 	
 	// Next let the kernel choose the address.
-	return runtime·stdcall(runtime·VirtualAlloc, 4, nil, n, (uintptr)MEM_RESERVE, (uintptr)PAGE_READWRITE);
+	return runtime·stdcall4(runtime·VirtualAlloc, 0, n, MEM_RESERVE, PAGE_READWRITE);
 }
 
 void
@@ -112,7 +112,7 @@ runtime·SysMap(void *v, uintptr n, bool reserved, uint64 *stat)
 	USED(reserved);
 
 	runtime·xadd64(stat, n);
-	p = runtime·stdcall(runtime·VirtualAlloc, 4, v, n, (uintptr)MEM_COMMIT, (uintptr)PAGE_READWRITE);
+	p = runtime·stdcall4(runtime·VirtualAlloc, (uintptr)v, n, MEM_COMMIT, PAGE_READWRITE);
 	if(p != v)
 		runtime·throw("runtime: cannot map pages in arena address space");
 }
diff --git a/src/pkg/runtime/netpoll_windows.c b/src/pkg/runtime/netpoll_windows.c
index 4528292125..64da41ad90 100644
--- a/src/pkg/runtime/netpoll_windows.c
+++ b/src/pkg/runtime/netpoll_windows.c
@@ -47,7 +47,7 @@ static uintptr iocphandle = INVALID_HANDLE_VALUE;  // completion port io handle
 void
 runtime·netpollinit(void)
 {
-	iocphandle = (uintptr)runtime·stdcall(runtime·CreateIoCompletionPort, 4, INVALID_HANDLE_VALUE, (uintptr)0, (uintptr)0, (uintptr)DWORD_MAX);
+	iocphandle = (uintptr)runtime·stdcall4(runtime·CreateIoCompletionPort, INVALID_HANDLE_VALUE, 0, 0, DWORD_MAX);
 	if(iocphandle == 0) {
 		runtime·printf("netpoll: failed to create iocp handle (errno=%d)\n", runtime·getlasterror());
 		runtime·throw("netpoll: failed to create iocp handle");
@@ -59,7 +59,7 @@ int32
 runtime·netpollopen(uintptr fd, PollDesc *pd)
 {
 	USED(pd);
-	if(runtime·stdcall(runtime·CreateIoCompletionPort, 4, fd, iocphandle, (uintptr)0, (uintptr)0) == 0)
+	if(runtime·stdcall4(runtime·CreateIoCompletionPort, fd, iocphandle, 0, 0) == 0)
 		return -runtime·getlasterror();
 	return 0;
 }
@@ -103,7 +103,7 @@ retry:
 			n = 8;
 		if(block)
 			g->m->blocked = true;
-		if(runtime·stdcall(runtime·GetQueuedCompletionStatusEx, 6, iocphandle, entries, (uintptr)n, &n, (uintptr)wait, (uintptr)0) == 0) {
+		if(runtime·stdcall6(runtime·GetQueuedCompletionStatusEx, iocphandle, (uintptr)entries, n, (uintptr)&n, wait, 0) == 0) {
 			g->m->blocked = false;
 			errno = runtime·getlasterror();
 			if(!block && errno == WAIT_TIMEOUT)
@@ -116,7 +116,7 @@ retry:
 			op = entries[i].op;
 			errno = 0;
 			qty = 0;
-			if(runtime·stdcall(runtime·WSAGetOverlappedResult, 5, runtime·netpollfd(op->pd), op, &qty, (uintptr)0, (uintptr)&flags) == 0)
+			if(runtime·stdcall5(runtime·WSAGetOverlappedResult, runtime·netpollfd(op->pd), (uintptr)op, (uintptr)&qty, 0, (uintptr)&flags) == 0)
 				errno = runtime·getlasterror();
 			handlecompletion(&gp, op, errno, qty);
 		}
@@ -126,7 +126,7 @@ retry:
 		qty = 0;
 		if(block)
 			g->m->blocked = true;
-		if(runtime·stdcall(runtime·GetQueuedCompletionStatus, 5, iocphandle, &qty, &key, &op, (uintptr)wait) == 0) {
+		if(runtime·stdcall5(runtime·GetQueuedCompletionStatus, iocphandle, (uintptr)&qty, (uintptr)&key, (uintptr)&op, wait) == 0) {
 			g->m->blocked = false;
 			errno = runtime·getlasterror();
 			if(!block && errno == WAIT_TIMEOUT)
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index aadc30a076..43026d6457 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -81,7 +81,7 @@ getproccount(void)
 {
 	SystemInfo info;
 
-	runtime·stdcall(runtime·GetSystemInfo, 1, &info);
+	runtime·stdcall1(runtime·GetSystemInfo, (uintptr)&info);
 	return info.dwNumberOfProcessors;
 }
 
@@ -92,20 +92,20 @@ runtime·osinit(void)
 
 	runtime·externalthreadhandlerp = (uintptr)runtime·externalthreadhandler;
 
-	runtime·stdcall(runtime·AddVectoredExceptionHandler, 2, (uintptr)1, (uintptr)runtime·sigtramp);
-	runtime·stdcall(runtime·SetConsoleCtrlHandler, 2, runtime·ctrlhandler, (uintptr)1);
-	runtime·stdcall(runtime·timeBeginPeriod, 1, (uintptr)1);
+	runtime·stdcall2(runtime·AddVectoredExceptionHandler, 1, (uintptr)runtime·sigtramp);
+	runtime·stdcall2(runtime·SetConsoleCtrlHandler, (uintptr)runtime·ctrlhandler, 1);
+	runtime·stdcall1(runtime·timeBeginPeriod, 1);
 	runtime·ncpu = getproccount();
 	
 	// Windows dynamic priority boosting assumes that a process has different types
 	// of dedicated threads -- GUI, IO, computational, etc. Go processes use
 	// equivalent threads that all do a mix of GUI, IO, computations, etc.
 	// In such context dynamic priority boosting does nothing but harm, so we turn it off.
-	runtime·stdcall(runtime·SetProcessPriorityBoost, 2, (uintptr)-1, (uintptr)1);
+	runtime·stdcall2(runtime·SetProcessPriorityBoost, -1, 1);
 
-	kernel32 = runtime·stdcall(runtime·LoadLibraryA, 1, "kernel32.dll");
+	kernel32 = runtime·stdcall1(runtime·LoadLibraryA, (uintptr)"kernel32.dll");
 	if(kernel32 != nil) {
-		runtime·GetQueuedCompletionStatusEx = runtime·stdcall(runtime·GetProcAddress, 2, kernel32, "GetQueuedCompletionStatusEx");
+		runtime·GetQueuedCompletionStatusEx = runtime·stdcall2(runtime·GetProcAddress, (uintptr)kernel32, (uintptr)"GetQueuedCompletionStatusEx");
 	}
 }
 
@@ -115,15 +115,15 @@ runtime·get_random_data(byte **rnd, int32 *rnd_len)
 	uintptr handle;
 	*rnd = nil;
 	*rnd_len = 0;
-	if(runtime·stdcall(runtime·CryptAcquireContextW, 5, &handle, nil, nil,
-			   (uintptr)1 /* PROV_RSA_FULL */,
-			   (uintptr)0xf0000000U /* CRYPT_VERIFYCONTEXT */) != 0) {
+	if(runtime·stdcall5(runtime·CryptAcquireContextW, (uintptr)&handle, (uintptr)nil, (uintptr)nil,
+			   1 /* PROV_RSA_FULL */,
+			   0xf0000000U /* CRYPT_VERIFYCONTEXT */) != 0) {
 		static byte random_data[HashRandomBytes];
-		if(runtime·stdcall(runtime·CryptGenRandom, 3, handle, (uintptr)HashRandomBytes, random_data)) {
+		if(runtime·stdcall3(runtime·CryptGenRandom, handle, HashRandomBytes, (uintptr)&random_data[0])) {
 			*rnd = random_data;
 			*rnd_len = HashRandomBytes;
 		}
-		runtime·stdcall(runtime·CryptReleaseContext, 2, handle, (uintptr)0);
+		runtime·stdcall2(runtime·CryptReleaseContext, handle, 0);
 	}
 }
 
@@ -137,7 +137,7 @@ runtime·goenvs(void)
 	int32 i, n;
 	uint16 *p;
 
-	env = runtime·stdcall(runtime·GetEnvironmentStringsW, 0);
+	env = runtime·stdcall0(runtime·GetEnvironmentStringsW);
 
 	n = 0;
 	for(p=env; *p; n++)
@@ -154,13 +154,13 @@ runtime·goenvs(void)
 	syscall·envs.len = n;
 	syscall·envs.cap = n;
 
-	runtime·stdcall(runtime·FreeEnvironmentStringsW, 1, env);
+	runtime·stdcall1(runtime·FreeEnvironmentStringsW, (uintptr)env);
 }
 
 void
 runtime·exit(int32 code)
 {
-	runtime·stdcall(runtime·ExitProcess, 1, (uintptr)code);
+	runtime·stdcall1(runtime·ExitProcess, code);
 }
 
 int32
@@ -172,17 +172,17 @@ runtime·write(uintptr fd, void *buf, int32 n)
 	written = 0;
 	switch(fd) {
 	case 1:
-		handle = runtime·stdcall(runtime·GetStdHandle, 1, (uintptr)-11);
+		handle = runtime·stdcall1(runtime·GetStdHandle, -11);
 		break;
 	case 2:
-		handle = runtime·stdcall(runtime·GetStdHandle, 1, (uintptr)-12);
+		handle = runtime·stdcall1(runtime·GetStdHandle, -12);
 		break;
 	default:
 		// assume fd is real windows handle.
 		handle = (void*)fd;
 		break;
 	}
-	runtime·stdcall(runtime·WriteFile, 5, handle, buf, (uintptr)n, &written, (uintptr)0);
+	runtime·stdcall5(runtime·WriteFile, (uintptr)handle, (uintptr)buf, n, (uintptr)&written, 0);
 	return written;
 }
 
@@ -200,7 +200,7 @@ runtime·semasleep(int64 ns)
 		if(ns == 0)
 			ns = 1;
 	}
-	if(runtime·stdcall(runtime·WaitForSingleObject, 2, g->m->waitsema, (uintptr)ns) != 0)
+	if(runtime·stdcall2(runtime·WaitForSingleObject, (uintptr)g->m->waitsema, ns) != 0)
 		return -1;  // timeout
 	return 0;
 }
@@ -208,13 +208,13 @@ runtime·semasleep(int64 ns)
 void
 runtime·semawakeup(M *mp)
 {
-	runtime·stdcall(runtime·SetEvent, 1, mp->waitsema);
+	runtime·stdcall1(runtime·SetEvent, mp->waitsema);
 }
 
 uintptr
 runtime·semacreate(void)
 {
-	return (uintptr)runtime·stdcall(runtime·CreateEvent, 4, (uintptr)0, (uintptr)0, (uintptr)0, (uintptr)0);
+	return (uintptr)runtime·stdcall4(runtime·CreateEvent, 0, 0, 0, 0);
 }
 
 #define STACK_SIZE_PARAM_IS_A_RESERVATION ((uintptr)0x00010000)
@@ -226,9 +226,9 @@ runtime·newosproc(M *mp, void *stk)
 
 	USED(stk);
 
-	thandle = runtime·stdcall(runtime·CreateThread, 6,
-		nil, (uintptr)0x20000, runtime·tstart_stdcall, mp,
-		STACK_SIZE_PARAM_IS_A_RESERVATION, nil);
+	thandle = runtime·stdcall6(runtime·CreateThread,
+		(uintptr)nil, 0x20000, (uintptr)runtime·tstart_stdcall, (uintptr)mp,
+		STACK_SIZE_PARAM_IS_A_RESERVATION, (uintptr)nil);
 	if(thandle == nil) {
 		runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount(), runtime·getlasterror());
 		runtime·throw("runtime.newosproc");
@@ -251,9 +251,7 @@ runtime·minit(void)
 	void *thandle;
 
 	// -1 = current process, -2 = current thread
-	runtime·stdcall(runtime·DuplicateHandle, 7,
-		(uintptr)-1, (uintptr)-2, (uintptr)-1, &thandle,
-		(uintptr)0, (uintptr)0, (uintptr)DUPLICATE_SAME_ACCESS);
+	runtime·stdcall7(runtime·DuplicateHandle, -1, -2, -1, (uintptr)&thandle, 0, 0, DUPLICATE_SAME_ACCESS);
 	runtime·atomicstorep(&g->m->thread, thandle);
 }
 
@@ -318,12 +316,10 @@ time·now(int64 sec, int32 usec)
 
 // Calling stdcall on os stack.
 #pragma textflag NOSPLIT
-void *
-runtime·stdcall(void *fn, int32 count, ...)
+static void*
+stdcall(void *fn)
 {
 	g->m->libcall.fn = fn;
-	g->m->libcall.n = count;
-	g->m->libcall.args = (uintptr*)&count + 1;
 	if(g->m->profilehz != 0) {
 		// leave pc/sp for cpu profiler
 		g->m->libcallg = g;
@@ -337,6 +333,85 @@ runtime·stdcall(void *fn, int32 count, ...)
 	return (void*)g->m->libcall.r1;
 }
 
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall0(void *fn)
+{
+	g->m->libcall.n = 0;
+	g->m->libcall.args = &fn;  // it's unused but must be non-nil, otherwise crashes
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall1(void *fn, uintptr a0)
+{
+	USED(a0);
+	g->m->libcall.n = 1;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall2(void *fn, uintptr a0, uintptr a1)
+{
+	USED(a0, a1);
+	g->m->libcall.n = 2;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall3(void *fn, uintptr a0, uintptr a1, uintptr a2)
+{
+	USED(a0, a1, a2);
+	g->m->libcall.n = 3;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall4(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3)
+{
+	USED(a0, a1, a2, a3);
+	g->m->libcall.n = 4;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall5(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3, uintptr a4)
+{
+	USED(a0, a1, a2, a3, a4);
+	g->m->libcall.n = 5;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall6(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5)
+{
+	USED(a0, a1, a2, a3, a4, a5);
+	g->m->libcall.n = 6;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·stdcall7(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6)
+{
+	USED(a0, a1, a2, a3, a4, a5, a6);
+	g->m->libcall.n = 7;
+	g->m->libcall.args = &a0;
+	return stdcall(fn);
+}
+
 extern void runtime·usleep1(uint32);
 
 #pragma textflag NOSPLIT
@@ -451,7 +526,7 @@ profilem(M *mp)
 	// align Context to 16 bytes
 	r = (Context*)((uintptr)(&rbuf[15]) & ~15);
 	r->ContextFlags = CONTEXT_CONTROL;
-	runtime·stdcall(runtime·GetThreadContext, 2, mp->thread, r);
+	runtime·stdcall2(runtime·GetThreadContext, (uintptr)mp->thread, (uintptr)r);
 	runtime·dosigprof(r, gp, mp);
 }
 
@@ -461,11 +536,10 @@ runtime·profileloop1(void)
 	M *mp, *allm;
 	void *thread;
 
-	runtime·stdcall(runtime·SetThreadPriority, 2,
-		(uintptr)-2, (uintptr)THREAD_PRIORITY_HIGHEST);
+	runtime·stdcall2(runtime·SetThreadPriority, -2, THREAD_PRIORITY_HIGHEST);
 
 	for(;;) {
-		runtime·stdcall(runtime·WaitForSingleObject, 2, profiletimer, (uintptr)-1);
+		runtime·stdcall2(runtime·WaitForSingleObject, (uintptr)profiletimer, -1);
 		allm = runtime·atomicloadp(&runtime·allm);
 		for(mp = allm; mp != nil; mp = mp->alllink) {
 			thread = runtime·atomicloadp(&mp->thread);
@@ -474,10 +548,10 @@ runtime·profileloop1(void)
 			// idle timer thread, idle heap scavenger, etc.
 			if(thread == nil || mp->profilehz == 0 || mp->blocked)
 				continue;
-			runtime·stdcall(runtime·SuspendThread, 1, thread);
+			runtime·stdcall1(runtime·SuspendThread, (uintptr)thread);
 			if(mp->profilehz != 0 && !mp->blocked)
 				profilem(mp);
-			runtime·stdcall(runtime·ResumeThread, 1, thread);
+			runtime·stdcall1(runtime·ResumeThread, (uintptr)thread);
 		}
 	}
 }
@@ -492,11 +566,11 @@ runtime·resetcpuprofiler(int32 hz)
 
 	runtime·lock(&lock);
 	if(profiletimer == nil) {
-		timer = runtime·stdcall(runtime·CreateWaitableTimer, 3, nil, nil, nil);
+		timer = runtime·stdcall3(runtime·CreateWaitableTimer, (uintptr)nil, (uintptr)nil, (uintptr)nil);
 		runtime·atomicstorep(&profiletimer, timer);
-		thread = runtime·stdcall(runtime·CreateThread, 6,
-			nil, nil, runtime·profileloop, nil, nil, nil);
-		runtime·stdcall(runtime·CloseHandle, 1, thread);
+		thread = runtime·stdcall6(runtime·CreateThread,
+			(uintptr)nil, (uintptr)nil, (uintptr)runtime·profileloop, (uintptr)nil, (uintptr)nil, (uintptr)nil);
+		runtime·stdcall1(runtime·CloseHandle, (uintptr)thread);
 	}
 	runtime·unlock(&lock);
 
@@ -508,8 +582,8 @@ runtime·resetcpuprofiler(int32 hz)
 			ms = 1;
 		due = ms * -10000;
 	}
-	runtime·stdcall(runtime·SetWaitableTimer, 6,
-		profiletimer, &due, (uintptr)ms, nil, nil, nil);
+	runtime·stdcall6(runtime·SetWaitableTimer,
+		(uintptr)profiletimer, (uintptr)&due, ms, (uintptr)nil, (uintptr)nil, (uintptr)nil);
 	runtime·atomicstore((uint32*)&g->m->profilehz, hz);
 }
 
diff --git a/src/pkg/runtime/os_windows.go b/src/pkg/runtime/os_windows.go
index 188ca3219e..a1b9594318 100644
--- a/src/pkg/runtime/os_windows.go
+++ b/src/pkg/runtime/os_windows.go
@@ -6,6 +6,17 @@ package runtime
 
 import "unsafe"
 
+type stdFunction *byte
+
+func stdcall0(fn stdFunction) uintptr
+func stdcall1(fn stdFunction, a0 uintptr) uintptr
+func stdcall2(fn stdFunction, a0, a1 uintptr) uintptr
+func stdcall3(fn stdFunction, a0, a1, a2 uintptr) uintptr
+func stdcall4(fn stdFunction, a0, a1, a2, a3 uintptr) uintptr
+func stdcall5(fn stdFunction, a0, a1, a2, a3, a4 uintptr) uintptr
+func stdcall6(fn stdFunction, a0, a1, a2, a3, a4, a5 uintptr) uintptr
+func stdcall7(fn stdFunction, a0, a1, a2, a3, a4, a5, a6 uintptr) uintptr
+
 func asmstdcall(fn unsafe.Pointer)
 func getlasterror() uint32
 func setlasterror(err uint32)
diff --git a/src/pkg/runtime/os_windows.h b/src/pkg/runtime/os_windows.h
index b64fa88736..e1e3cb0e23 100644
--- a/src/pkg/runtime/os_windows.h
+++ b/src/pkg/runtime/os_windows.h
@@ -8,11 +8,15 @@ extern void *runtime·GetQueuedCompletionStatusEx;
 
 // Call a Windows function with stdcall conventions,
 // and switch to os stack during the call.
-#pragma	varargck	countpos	runtime·stdcall	2
-#pragma	varargck	type		runtime·stdcall	void*
-#pragma	varargck	type		runtime·stdcall	uintptr
 void runtime·asmstdcall(void *c);
-void *runtime·stdcall(void *fn, int32 count, ...);
+void *runtime·stdcall0(void *fn);
+void *runtime·stdcall1(void *fn, uintptr a0);
+void *runtime·stdcall2(void *fn, uintptr a0, uintptr a1);
+void *runtime·stdcall3(void *fn, uintptr a0, uintptr a1, uintptr a2);
+void *runtime·stdcall4(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3);
+void *runtime·stdcall5(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3, uintptr a4);
+void *runtime·stdcall6(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5);
+void *runtime·stdcall7(void *fn, uintptr a0, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6);
 
 uint32 runtime·getlasterror(void);
 void runtime·setlasterror(uint32 err);

From e77c2fe31374905b08d51f338803bea88e9c4ec2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aram=20H=C4=83v=C4=83rneanu?= <aram@mgk.ro>
Date: Fri, 29 Aug 2014 12:28:09 +0200
Subject: [PATCH 281/423] runtime: allow sysvicall functions to be called from
 Go

Convert them to Go in the process.

LGTM=dvyukov, dave
R=khr, dvyukov, rsc, dave
CC=golang-codereviews
https://golang.org/cl/131600043
---
 src/pkg/runtime/netpoll_solaris.c | 14 +++---
 src/pkg/runtime/os_solaris.c      | 69 +++++++++++-----------------
 src/pkg/runtime/os_solaris.go     | 75 ++++++++++++++++++++++++++++++-
 src/pkg/runtime/os_solaris.h      | 15 ++++---
 src/pkg/runtime/runtime.h         |  2 +-
 5 files changed, 116 insertions(+), 59 deletions(-)

diff --git a/src/pkg/runtime/netpoll_solaris.c b/src/pkg/runtime/netpoll_solaris.c
index 569aee52d4..d422719cf1 100644
--- a/src/pkg/runtime/netpoll_solaris.c
+++ b/src/pkg/runtime/netpoll_solaris.c
@@ -84,35 +84,31 @@ extern uintptr libc·port_getn;
 int32
 runtime·fcntl(int32 fd, int32 cmd, uintptr arg)
 {
-	return runtime·sysvicall6(libc·fcntl, 3,
-	    (uintptr)fd, (uintptr)cmd, (uintptr)arg);
+	return runtime·sysvicall3(libc·fcntl, (uintptr)fd, (uintptr)cmd, (uintptr)arg);
 }
 
 int32
 runtime·port_create(void)
 {
-	return runtime·sysvicall6(libc·port_create, 0);
+	return runtime·sysvicall0(libc·port_create);
 }
 
 int32
 runtime·port_associate(int32 port, int32 source, uintptr object, int32 events, uintptr user)
 {
-	return runtime·sysvicall6(libc·port_associate,
-	    5, (uintptr)port, (uintptr)source, object, (uintptr)events, user);
+	return runtime·sysvicall5(libc·port_associate, (uintptr)port, (uintptr)source, object, (uintptr)events, user);
 }
 
 int32
 runtime·port_dissociate(int32 port, int32 source, uintptr object)
 {
-	return runtime·sysvicall6(libc·port_dissociate,
-	    3, (uintptr)port, (uintptr)source, object);
+	return runtime·sysvicall3(libc·port_dissociate, (uintptr)port, (uintptr)source, object);
 }
 
 int32
 runtime·port_getn(int32 port, PortEvent *evs, uint32 max, uint32 *nget, Timespec *timeout)
 {
-	return runtime·sysvicall6(libc·port_getn, 5, (uintptr)port,
-	    (uintptr)evs, (uintptr)max, (uintptr)nget, (uintptr)timeout);
+	return runtime·sysvicall5(libc·port_getn, (uintptr)port, (uintptr)evs, (uintptr)max, (uintptr)nget, (uintptr)timeout);
 }
 
 static int32 portfd = -1;
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index 272e07cdb5..0cdfd52c9b 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -97,21 +97,6 @@ extern SigTab runtime·sigtab[];
 static Sigset sigset_none;
 static Sigset sigset_all = { ~(uint32)0, ~(uint32)0, ~(uint32)0, ~(uint32)0, };
 
-// Calling sysvcall on os stack.
-#pragma textflag NOSPLIT
-uintptr
-runtime·sysvicall6(uintptr fn, int32 count, ...)
-{
-	runtime·memclr((byte*)&g->m->scratch, sizeof(g->m->scratch));
-	g->m->libcall.fn = (void*)fn;
-	g->m->libcall.n = (uintptr)count;
-	for(;count; count--)
-		g->m->scratch.v[count - 1] = *((uintptr*)&count + count);
-	g->m->libcall.args = (uintptr*)&g->m->scratch.v[0];
-	runtime·asmcgocall(runtime·asmsysvicall6, &g->m->libcall);
-	return g->m->libcall.r1;
-}
-
 static int32
 getncpu(void) 
 {
@@ -403,37 +388,37 @@ runtime·semawakeup(M *mp)
 int32
 runtime·close(int32 fd)
 {
-	return runtime·sysvicall6(libc·close, 1, (uintptr)fd);
+	return runtime·sysvicall1(libc·close, (uintptr)fd);
 }
 
 void
 runtime·exit(int32 r)
 {
-	runtime·sysvicall6(libc·exit, 1, (uintptr)r);
+	runtime·sysvicall1(libc·exit, (uintptr)r);
 }
 
 /* int32 */ void
 runtime·getcontext(Ucontext* context)
 {
-	runtime·sysvicall6(libc·getcontext, 1, (uintptr)context);
+	runtime·sysvicall1(libc·getcontext, (uintptr)context);
 }
 
 int32
 runtime·getrlimit(int32 res, Rlimit* rlp)
 {
-	return runtime·sysvicall6(libc·getrlimit, 2, (uintptr)res, (uintptr)rlp);
+	return runtime·sysvicall2(libc·getrlimit, (uintptr)res, (uintptr)rlp);
 }
 
 uint8*
 runtime·mmap(byte* addr, uintptr len, int32 prot, int32 flags, int32 fildes, uint32 off)
 {
-	return (uint8*)runtime·sysvicall6(libc·mmap, 6, (uintptr)addr, (uintptr)len, (uintptr)prot, (uintptr)flags, (uintptr)fildes, (uintptr)off);
+	return (uint8*)runtime·sysvicall6(libc·mmap, (uintptr)addr, (uintptr)len, (uintptr)prot, (uintptr)flags, (uintptr)fildes, (uintptr)off);
 }
 
 void
 runtime·munmap(byte* addr, uintptr len)
 {
-	runtime·sysvicall6(libc·munmap, 2, (uintptr)addr, (uintptr)len);
+	runtime·sysvicall2(libc·munmap, (uintptr)addr, (uintptr)len);
 }
 
 extern int64 runtime·nanotime1(void);
@@ -441,7 +426,7 @@ extern int64 runtime·nanotime1(void);
 int64
 runtime·nanotime(void)
 {
-	return runtime·sysvicall6((uintptr)runtime·nanotime1, 0);
+	return runtime·sysvicall0((uintptr)runtime·nanotime1);
 }
 
 void
@@ -459,113 +444,113 @@ time·now(int64 sec, int32 usec)
 int32
 runtime·open(int8* path, int32 oflag, int32 mode)
 {
-	return runtime·sysvicall6(libc·open, 3, (uintptr)path, (uintptr)oflag, (uintptr)mode);
+	return runtime·sysvicall3(libc·open, (uintptr)path, (uintptr)oflag, (uintptr)mode);
 }
 
 int32
 runtime·pthread_attr_destroy(PthreadAttr* attr)
 {
-	return runtime·sysvicall6(libc·pthread_attr_destroy, 1, (uintptr)attr);
+	return runtime·sysvicall1(libc·pthread_attr_destroy, (uintptr)attr);
 }
 
 int32
 runtime·pthread_attr_getstack(PthreadAttr* attr, void** addr, uint64* size)
 {
-	return runtime·sysvicall6(libc·pthread_attr_getstack, 3, (uintptr)attr, (uintptr)addr, (uintptr)size);
+	return runtime·sysvicall3(libc·pthread_attr_getstack, (uintptr)attr, (uintptr)addr, (uintptr)size);
 }
 
 int32
 runtime·pthread_attr_init(PthreadAttr* attr)
 {
-	return runtime·sysvicall6(libc·pthread_attr_init, 1, (uintptr)attr);
+	return runtime·sysvicall1(libc·pthread_attr_init, (uintptr)attr);
 }
 
 int32
 runtime·pthread_attr_setdetachstate(PthreadAttr* attr, int32 state)
 {
-	return runtime·sysvicall6(libc·pthread_attr_setdetachstate, 2, (uintptr)attr, (uintptr)state);
+	return runtime·sysvicall2(libc·pthread_attr_setdetachstate, (uintptr)attr, (uintptr)state);
 }
 
 int32
 runtime·pthread_attr_setstack(PthreadAttr* attr, void* addr, uint64 size)
 {
-	return runtime·sysvicall6(libc·pthread_attr_setstack, 3, (uintptr)attr, (uintptr)addr, (uintptr)size);
+	return runtime·sysvicall3(libc·pthread_attr_setstack, (uintptr)attr, (uintptr)addr, (uintptr)size);
 }
 
 int32
 runtime·pthread_create(Pthread* thread, PthreadAttr* attr, void(*fn)(void), void *arg)
 {
-	return runtime·sysvicall6(libc·pthread_create, 4, (uintptr)thread, (uintptr)attr, (uintptr)fn, (uintptr)arg);
+	return runtime·sysvicall4(libc·pthread_create, (uintptr)thread, (uintptr)attr, (uintptr)fn, (uintptr)arg);
 }
 
 /* int32 */ void
 runtime·raise(int32 sig)
 {
-	runtime·sysvicall6(libc·raise, 1, (uintptr)sig);
+	runtime·sysvicall1(libc·raise, (uintptr)sig);
 }
 
 int32
 runtime·read(int32 fd, void* buf, int32 nbyte)
 {
-	return runtime·sysvicall6(libc·read, 3, (uintptr)fd, (uintptr)buf, (uintptr)nbyte);
+	return runtime·sysvicall3(libc·read, (uintptr)fd, (uintptr)buf, (uintptr)nbyte);
 }
 
 #pragma textflag NOSPLIT
 int32
 runtime·sem_init(SemT* sem, int32 pshared, uint32 value)
 {
-	return runtime·sysvicall6(libc·sem_init, 3, (uintptr)sem, (uintptr)pshared, (uintptr)value);
+	return runtime·sysvicall3(libc·sem_init, (uintptr)sem, (uintptr)pshared, (uintptr)value);
 }
 
 #pragma textflag NOSPLIT
 int32
 runtime·sem_post(SemT* sem)
 {
-	return runtime·sysvicall6(libc·sem_post, 1, (uintptr)sem);
+	return runtime·sysvicall1(libc·sem_post, (uintptr)sem);
 }
 
 #pragma textflag NOSPLIT
 int32
 runtime·sem_reltimedwait_np(SemT* sem, Timespec* timeout)
 {
-	return runtime·sysvicall6(libc·sem_reltimedwait_np, 2, (uintptr)sem, (uintptr)timeout);
+	return runtime·sysvicall2(libc·sem_reltimedwait_np, (uintptr)sem, (uintptr)timeout);
 }
 
 #pragma textflag NOSPLIT
 int32
 runtime·sem_wait(SemT* sem)
 {
-	return runtime·sysvicall6(libc·sem_wait, 1, (uintptr)sem);
+	return runtime·sysvicall1(libc·sem_wait, (uintptr)sem);
 }
 
 /* int32 */ void
 runtime·setitimer(int32 which, Itimerval* value, Itimerval* ovalue)
 {
-	runtime·sysvicall6(libc·setitimer, 3, (uintptr)which, (uintptr)value, (uintptr)ovalue);
+	runtime·sysvicall3(libc·setitimer, (uintptr)which, (uintptr)value, (uintptr)ovalue);
 }
 
 /* int32 */ void
 runtime·sigaction(int32 sig, struct Sigaction* act, struct Sigaction* oact)
 {
-	runtime·sysvicall6(libc·sigaction, 3, (uintptr)sig, (uintptr)act, (uintptr)oact);
+	runtime·sysvicall3(libc·sigaction, (uintptr)sig, (uintptr)act, (uintptr)oact);
 }
 
 /* int32 */ void
 runtime·sigaltstack(Sigaltstack* ss, Sigaltstack* oss)
 {
-	runtime·sysvicall6(libc·sigaltstack, 2, (uintptr)ss, (uintptr)oss);
+	runtime·sysvicall2(libc·sigaltstack, (uintptr)ss, (uintptr)oss);
 }
 
 /* int32 */ void
 runtime·sigprocmask(int32 how, Sigset* set, Sigset* oset)
 {
-	runtime·sysvicall6(libc·sigprocmask, 3, (uintptr)how, (uintptr)set, (uintptr)oset);
+	runtime·sysvicall3(libc·sigprocmask, (uintptr)how, (uintptr)set, (uintptr)oset);
 }
 
 int64
 runtime·sysconf(int32 name)
 {
-	return runtime·sysvicall6(libc·sysconf, 1, (uintptr)name);
+	return runtime·sysvicall1(libc·sysconf, (uintptr)name);
 }
 
 extern void runtime·usleep1(uint32);
@@ -580,7 +565,7 @@ runtime·usleep(uint32 µs)
 int32
 runtime·write(uintptr fd, void* buf, int32 nbyte)
 {
-	return runtime·sysvicall6(libc·write, 3, (uintptr)fd, (uintptr)buf, (uintptr)nbyte);
+	return runtime·sysvicall3(libc·write, (uintptr)fd, (uintptr)buf, (uintptr)nbyte);
 }
 
 extern void runtime·osyield1(void);
@@ -592,7 +577,7 @@ runtime·osyield(void)
 	// Check the validity of m because we might be called in cgo callback
 	// path early enough where there isn't a m available yet.
 	if(g && g->m != nil) {
-		runtime·sysvicall6(libc·sched_yield, 0);
+		runtime·sysvicall0(libc·sched_yield);
 		return;
 	}
 	runtime·osyield1();
diff --git a/src/pkg/runtime/os_solaris.go b/src/pkg/runtime/os_solaris.go
index 72528c7997..7bc42ef52d 100644
--- a/src/pkg/runtime/os_solaris.go
+++ b/src/pkg/runtime/os_solaris.go
@@ -12,7 +12,6 @@ func sigaltstack(new, old unsafe.Pointer)
 func sigprocmask(mode int32, new, old unsafe.Pointer)
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
 func getrlimit(kind int32, limit unsafe.Pointer)
-func asmsysvicall6(fn unsafe.Pointer)
 func miniterrno(fn unsafe.Pointer)
 func raise(sig int32)
 func getcontext(ctxt unsafe.Pointer)
@@ -20,3 +19,77 @@ func tstart_sysvicall(mm unsafe.Pointer) uint32
 func nanotime1() int64
 func usleep1(usec uint32)
 func osyield1()
+
+type libcFunc byte
+
+var asmsysvicall6 libcFunc
+
+//go:nosplit
+func sysvicall0(fn *libcFunc) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 0
+	libcall.args = unsafe.Pointer(fn) // it's unused but must be non-nil, otherwise crashes
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
+
+//go:nosplit
+func sysvicall1(fn *libcFunc, a1 uintptr) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 1
+	libcall.args = noescape(unsafe.Pointer(&a1))
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
+
+//go:nosplit
+func sysvicall2(fn *libcFunc, a1, a2 uintptr) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 2
+	libcall.args = noescape(unsafe.Pointer(&a1))
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
+
+//go:nosplit
+func sysvicall3(fn *libcFunc, a1, a2, a3 uintptr) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 3
+	libcall.args = noescape(unsafe.Pointer(&a1))
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
+
+//go:nosplit
+func sysvicall4(fn *libcFunc, a1, a2, a3, a4 uintptr) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 4
+	libcall.args = noescape(unsafe.Pointer(&a1))
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
+
+//go:nosplit
+func sysvicall5(fn *libcFunc, a1, a2, a3, a4, a5 uintptr) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 5
+	libcall.args = noescape(unsafe.Pointer(&a1))
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
+
+//go:nosplit
+func sysvicall6(fn *libcFunc, a1, a2, a3, a4, a5, a6 uintptr) uintptr {
+	libcall := &getg().m.libcall
+	libcall.fn = unsafe.Pointer(fn)
+	libcall.n = 6
+	libcall.args = noescape(unsafe.Pointer(&a1))
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
+	return libcall.r1
+}
diff --git a/src/pkg/runtime/os_solaris.h b/src/pkg/runtime/os_solaris.h
index f3fae5da2a..355cdf5589 100644
--- a/src/pkg/runtime/os_solaris.h
+++ b/src/pkg/runtime/os_solaris.h
@@ -40,12 +40,15 @@ struct Rlimit {
 };
 int32   runtime·getrlimit(int32, Rlimit*);
 
-// Call a library function with SysV conventions,
-// and switch to os stack during the call.
-#pragma	varargck	countpos	runtime·sysvicall6	2
-#pragma	varargck	type		runtime·sysvicall6	uintptr
-#pragma	varargck	type		runtime·sysvicall6	int32
+// Call an external library function described by {fn, a0, ..., an}, with
+// SysV conventions, switching to os stack during the call, if necessary.
+uintptr	runtime·sysvicall0(uintptr fn);
+uintptr	runtime·sysvicall1(uintptr fn, uintptr a1);
+uintptr	runtime·sysvicall2(uintptr fn, uintptr a1, uintptr a2);
+uintptr	runtime·sysvicall3(uintptr fn, uintptr a1, uintptr a2, uintptr a3);
+uintptr	runtime·sysvicall4(uintptr fn, uintptr a1, uintptr a2, uintptr a3, uintptr a4);
+uintptr	runtime·sysvicall5(uintptr fn, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5);
+uintptr	runtime·sysvicall6(uintptr fn, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6);
 void	runtime·asmsysvicall6(void *c);
-uintptr	runtime·sysvicall6(uintptr fn, int32 count, ...);
 
 void	runtime·miniterrno(void *fn);
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 21ccb76b3c..27b945e979 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -248,7 +248,7 @@ struct	GCStats
 
 struct	LibCall
 {
-	void	(*fn)(void*);
+	void*	fn;
 	uintptr	n;	// number of parameters
 	void*	args;	// parameters
 	uintptr	r1;	// return values

From 6f19fd438e2178d086c4352b439e857bd08051bd Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Aug 2014 10:29:00 -0400
Subject: [PATCH 282/423] runtime: fix sprintf index out of bounds

Breaks on Plan 9, apparently.
The other systems must not run sprintf during all.bash.
I'd write a test but it's all going away.

TBR=r
CC=0intro, golang-codereviews
https://golang.org/cl/133260044
---
 src/pkg/runtime/print1.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/print1.go b/src/pkg/runtime/print1.go
index 9df6a621bb..f19cc1da59 100644
--- a/src/pkg/runtime/print1.go
+++ b/src/pkg/runtime/print1.go
@@ -46,7 +46,7 @@ func printf(s *byte) {
 // It has the same problem as goprintf.
 //go:nosplit
 func snprintf(dst *byte, n int32, s *byte) {
-	buf := (*[1 << 30]byte)(unsafe.Pointer(dst))[0:0:n]
+	buf := (*[1 << 30]byte)(unsafe.Pointer(dst))[0:n:n]
 
 	gp := getg()
 	gp.writebuf = buf[0:0 : n-1] // leave room for NUL, this is called from C

From 9f38b6c9e574c672d646a366c1933c3ff88b8781 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Fri, 29 Aug 2014 18:44:38 +0400
Subject: [PATCH 283/423] runtime: clean up GC code Remove C version of GC.
 Convert freeOSMemory to Go. Restore g0 check in GC. Remove unknownGCPercent
 check in GC, it's initialized explicitly now.

LGTM=rsc
R=golang-codereviews, rsc
CC=golang-codereviews, khr
https://golang.org/cl/139910043
---
 src/pkg/runtime/malloc.go | 26 +++----------
 src/pkg/runtime/malloc.h  |  1 -
 src/pkg/runtime/mgc0.c    | 78 +--------------------------------------
 src/pkg/runtime/mgc0.go   |  5 +++
 src/pkg/runtime/mheap.c   | 13 +------
 src/pkg/runtime/stubs.go  |  4 +-
 src/pkg/runtime/thunk.s   |  3 ++
 7 files changed, 19 insertions(+), 111 deletions(-)

diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 7f344c9164..e95bdbbf97 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -407,33 +407,19 @@ func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 // force = 1 - do GC regardless of current heap usage
 // force = 2 - go GC and eager sweep
 func gogc(force int32) {
-	if !memstats.enablegc {
-		return
-	}
-
-	// TODO: should never happen?  Only C calls malloc while holding a lock?
+	// The gc is turned off (via enablegc) until the bootstrap has completed.
+	// Also, malloc gets called in the guts of a number of libraries that might be
+	// holding locks. To avoid deadlocks during stoptheworld, don't bother
+	// trying to run gc while holding a lock. The next mallocgc without a lock
+	// will do the gc instead.
 	mp := acquirem()
-	if mp.locks > 1 {
+	if gp := getg(); gp == mp.g0 || mp.locks > 1 || !memstats.enablegc || panicking != 0 || gcpercent < 0 {
 		releasem(mp)
 		return
 	}
 	releasem(mp)
 	mp = nil
 
-	if panicking != 0 {
-		return
-	}
-	if gcpercent == gcpercentUnknown {
-		lock(&mheap_.lock)
-		if gcpercent == gcpercentUnknown {
-			gcpercent = readgogc()
-		}
-		unlock(&mheap_.lock)
-	}
-	if gcpercent < 0 {
-		return
-	}
-
 	semacquire(&worldsema, false)
 
 	if force == 0 && memstats.heap_alloc < memstats.next_gc {
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 19ea846dd1..6cd72fb31f 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -519,7 +519,6 @@ void	runtime·MHeap_Scavenge(int32 k, uint64 now, uint64 limit);
 
 void*	runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat);
 int32	runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **s);
-void	runtime·gc(int32 force);
 uintptr	runtime·sweepone(void);
 void	runtime·markspan(void *v, uintptr size, uintptr n, bool leftover);
 void	runtime·unmarkspan(void *v, uintptr size);
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 03eb2d9866..09be02b71e 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1284,82 +1284,6 @@ runtime·gcinit(void)
 	runtime·gcbssmask = unrollglobgcprog(runtime·gcbss, runtime·ebss - runtime·bss);
 }
 
-// force = 1 - do GC regardless of current heap usage
-// force = 2 - go GC and eager sweep
-void
-runtime·gc(int32 force)
-{
-	struct gc_args a;
-	int32 i;
-
-	// The gc is turned off (via enablegc) until
-	// the bootstrap has completed.
-	// Also, malloc gets called in the guts
-	// of a number of libraries that might be
-	// holding locks.  To avoid priority inversion
-	// problems, don't bother trying to run gc
-	// while holding a lock.  The next mallocgc
-	// without a lock will do the gc instead.
-	if(!mstats.enablegc || g == g->m->g0 || g->m->locks > 0 || runtime·panicking)
-		return;
-
-	if(runtime·gcpercent < 0)
-		return;
-
-	runtime·semacquire(&runtime·worldsema, false);
-	if(force==0 && mstats.heap_alloc < mstats.next_gc) {
-		// typically threads which lost the race to grab
-		// worldsema exit here when gc is done.
-		runtime·semrelease(&runtime·worldsema);
-		return;
-	}
-
-	// Ok, we're doing it!  Stop everybody else
-	a.start_time = runtime·nanotime();
-	a.eagersweep = force >= 2;
-	g->m->gcing = 1;
-	runtime·stoptheworld();
-	
-	runtime·clearpools();
-
-	// Run gc on the g0 stack.  We do this so that the g stack
-	// we're currently running on will no longer change.  Cuts
-	// the root set down a bit (g0 stacks are not scanned, and
-	// we don't need to scan gc's internal state).  Also an
-	// enabler for copyable stacks.
-	for(i = 0; i < (runtime·debug.gctrace > 1 ? 2 : 1); i++) {
-		if(i > 0)
-			a.start_time = runtime·nanotime();
-		// switch to g0, call gc(&a), then switch back
-		g->param = &a;
-		runtime·casgstatus(g, Grunning, Gwaiting);
-		g->waitreason = runtime·gostringnocopy((byte*)"garbage collection");
-		runtime·mcall(mgc);
-	}
-
-	// all done
-	g->m->gcing = 0;
-	g->m->locks++;
-	runtime·semrelease(&runtime·worldsema);
-	runtime·starttheworld();
-	g->m->locks--;
-
-	// now that gc is done, kick off finalizer thread if needed
-	if(!ConcurrentSweep) {
-		// give the queued finalizers, if any, a chance to run
-		runtime·gosched();
-	}
-}
-
-static void
-mgc(G *gp)
-{
-	gc(gp->param);
-	gp->param = nil;
-	runtime·casgstatus(gp, Gwaiting, Grunning);
-	runtime·gogo(&gp->sched);
-}
-
 void
 runtime·gc_m(void)
 {
@@ -1502,7 +1426,7 @@ gc(struct gc_args *args)
 	if(ConcurrentSweep && !args->eagersweep) {
 		runtime·lock(&gclock);
 		if(sweep.g == nil)
-			sweep.g = runtime·newproc1(&bgsweepv, nil, 0, 0, runtime·gc);
+			sweep.g = runtime·newproc1(&bgsweepv, nil, 0, 0, gc);
 		else if(sweep.parked) {
 			sweep.parked = false;
 			runtime·ready(sweep.g);
diff --git a/src/pkg/runtime/mgc0.go b/src/pkg/runtime/mgc0.go
index 496725f6a7..275c7ed676 100644
--- a/src/pkg/runtime/mgc0.go
+++ b/src/pkg/runtime/mgc0.go
@@ -34,3 +34,8 @@ func gc_unixnanotime(now *int64) {
 	sec, nsec := timenow()
 	*now = sec*1e9 + int64(nsec)
 }
+
+func freeOSMemory() {
+	gogc(2) // force GC and do eager sweep
+	onM(&scavenge_m)
+}
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 8bfb41ac67..90acd55f9f 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -622,19 +622,10 @@ runtime·MHeap_Scavenge(int32 k, uint64 now, uint64 limit)
 	}
 }
 
-static void
-scavenge_m(G *gp)
+void
+runtime·scavenge_m(void)
 {
 	runtime·MHeap_Scavenge(-1, ~(uintptr)0, 0);
-	runtime·gogo(&gp->sched);
-}
-
-void
-runtime∕debug·freeOSMemory(void)
-{
-	runtime·gc(2);  // force GC and do eager sweep
-
-	runtime·mcall(scavenge_m);
 }
 
 // Initialize a new span with the given start and npages.
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 2014dfbf90..9e5a2cf04a 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -78,6 +78,7 @@ var (
 	largeAlloc_m,
 	mprofMalloc_m,
 	gc_m,
+	scavenge_m,
 	setFinalizer_m,
 	removeFinalizer_m,
 	markallocated_m,
@@ -111,8 +112,7 @@ func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 func fastrand2() uint32
 
 const (
-	gcpercentUnknown = -2
-	concurrentSweep  = true
+	concurrentSweep = true
 )
 
 func gosched()
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 6093656c6f..997a4febc7 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -61,3 +61,6 @@ TEXT reflect·chanlen(SB), NOSPLIT, $0-0
 
 TEXT reflect·chancap(SB), NOSPLIT, $0-0
 	JMP	runtime·reflect_chancap(SB)
+
+TEXT runtime∕debug·freeOSMemory(SB), NOSPLIT, $0-0
+	JMP	runtime·freeOSMemory(SB)

From 1ad1c0bf31d878b32d8b093e84fed7bcc369f9cd Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Fri, 29 Aug 2014 09:54:00 -0700
Subject: [PATCH 284/423] text/template: add back pointer to Nodes for better
 error generation ErrorContext now has all the information it needs from the
 Node, rather than depending on the template that contains it. This makes it
 easier for html/template to generate correct locations in its error messages.

Updated html/template to use this ability where it is easy, which is
not everywhere, but more work can probably push it through.

Fixes #8577.

LGTM=adg
R=golang-codereviews, adg
CC=golang-codereviews
https://golang.org/cl/130620043
---
 src/pkg/html/template/error.go            |  16 +-
 src/pkg/html/template/escape.go           |  75 +++----
 src/pkg/html/template/escape_test.go      |  18 +-
 src/pkg/html/template/template.go         |   4 +-
 src/pkg/html/template/transition.go       |  12 +-
 src/pkg/text/template/parse/node.go       | 252 +++++++++++++++-------
 src/pkg/text/template/parse/parse.go      |  62 +++---
 src/pkg/text/template/parse/parse_test.go |   3 +-
 8 files changed, 273 insertions(+), 169 deletions(-)

diff --git a/src/pkg/html/template/error.go b/src/pkg/html/template/error.go
index 46e49ccf83..8f99e1b962 100644
--- a/src/pkg/html/template/error.go
+++ b/src/pkg/html/template/error.go
@@ -6,12 +6,16 @@ package template
 
 import (
 	"fmt"
+	"text/template/parse"
 )
 
 // Error describes a problem encountered during template Escaping.
 type Error struct {
 	// ErrorCode describes the kind of error.
 	ErrorCode ErrorCode
+	// Node is the node that caused the problem, if known.
+	// If not nil, it overrides Name and Line.
+	Node parse.Node
 	// Name is the name of the template in which the error was encountered.
 	Name string
 	// Line is the line number of the error in the template source or 0.
@@ -182,9 +186,13 @@ const (
 )
 
 func (e *Error) Error() string {
-	if e.Line != 0 {
+	switch {
+	case e.Node != nil:
+		loc, _ := (*parse.Tree)(nil).ErrorContext(e.Node)
+		return fmt.Sprintf("html/template:%s: %s", loc, e.Description)
+	case e.Line != 0:
 		return fmt.Sprintf("html/template:%s:%d: %s", e.Name, e.Line, e.Description)
-	} else if e.Name != "" {
+	case e.Name != "":
 		return fmt.Sprintf("html/template:%s: %s", e.Name, e.Description)
 	}
 	return "html/template: " + e.Description
@@ -192,6 +200,6 @@ func (e *Error) Error() string {
 
 // errorf creates an error given a format string f and args.
 // The template Name still needs to be supplied.
-func errorf(k ErrorCode, line int, f string, args ...interface{}) *Error {
-	return &Error{k, "", line, fmt.Sprintf(f, args...)}
+func errorf(k ErrorCode, node parse.Node, line int, f string, args ...interface{}) *Error {
+	return &Error{k, node, "", line, fmt.Sprintf(f, args...)}
 }
diff --git a/src/pkg/html/template/escape.go b/src/pkg/html/template/escape.go
index 3ba3747f6f..ee01fb12ab 100644
--- a/src/pkg/html/template/escape.go
+++ b/src/pkg/html/template/escape.go
@@ -13,41 +13,33 @@ import (
 	"text/template/parse"
 )
 
-// escapeTemplates rewrites the named templates, which must be
+// escapeTemplate rewrites the named template, which must be
 // associated with t, to guarantee that the output of any of the named
-// templates is properly escaped.  Names should include the names of
-// all templates that might be Executed but need not include helper
-// templates.  If no error is returned, then the named templates have
+// templates is properly escaped.  If no error is returned, then the named templates have
 // been modified.  Otherwise the named templates have been rendered
 // unusable.
-func escapeTemplates(tmpl *Template, names ...string) error {
+func escapeTemplate(tmpl *Template, node parse.Node, name string) error {
 	e := newEscaper(tmpl)
-	for _, name := range names {
-		c, _ := e.escapeTree(context{}, name, 0)
-		var err error
-		if c.err != nil {
-			err, c.err.Name = c.err, name
-		} else if c.state != stateText {
-			err = &Error{ErrEndContext, name, 0, fmt.Sprintf("ends in a non-text context: %v", c)}
-		}
-		if err != nil {
-			// Prevent execution of unsafe templates.
-			for _, name := range names {
-				if t := tmpl.set[name]; t != nil {
-					t.escapeErr = err
-					t.text.Tree = nil
-					t.Tree = nil
-				}
-			}
-			return err
+	c, _ := e.escapeTree(context{}, node, name, 0)
+	var err error
+	if c.err != nil {
+		err, c.err.Name = c.err, name
+	} else if c.state != stateText {
+		err = &Error{ErrEndContext, nil, name, 0, fmt.Sprintf("ends in a non-text context: %v", c)}
+	}
+	if err != nil {
+		// Prevent execution of unsafe templates.
+		if t := tmpl.set[name]; t != nil {
+			t.escapeErr = err
+			t.text.Tree = nil
+			t.Tree = nil
 		}
+		return err
 	}
 	e.commit()
-	for _, name := range names {
-		if t := tmpl.set[name]; t != nil {
-			t.escapeErr = escapeOK
-			t.Tree = t.text.Tree
-		}
+	if t := tmpl.set[name]; t != nil {
+		t.escapeErr = escapeOK
+		t.Tree = t.text.Tree
 	}
 	return nil
 }
@@ -169,7 +161,7 @@ func (e *escaper) escapeAction(c context, n *parse.ActionNode) context {
 		case urlPartUnknown:
 			return context{
 				state: stateError,
-				err:   errorf(ErrAmbigContext, n.Line, "%s appears in an ambiguous URL context", n),
+				err:   errorf(ErrAmbigContext, n, n.Line, "%s appears in an ambiguous URL context", n),
 			}
 		default:
 			panic(c.urlPart.String())
@@ -339,7 +331,7 @@ func escFnsEq(a, b string) bool {
 func newIdentCmd(identifier string, pos parse.Pos) *parse.CommandNode {
 	return &parse.CommandNode{
 		NodeType: parse.NodeCommand,
-		Args:     []parse.Node{parse.NewIdentifier(identifier).SetPos(pos)},
+		Args:     []parse.Node{parse.NewIdentifier(identifier).SetTree(nil).SetPos(pos)}, // TODO: SetTree.
 	}
 }
 
@@ -373,7 +365,7 @@ func nudge(c context) context {
 // join joins the two contexts of a branch template node. The result is an
 // error context if either of the input contexts are error contexts, or if the
 // the input contexts differ.
-func join(a, b context, line int, nodeName string) context {
+func join(a, b context, node parse.Node, nodeName string) context {
 	if a.state == stateError {
 		return a
 	}
@@ -406,14 +398,14 @@ func join(a, b context, line int, nodeName string) context {
 	// ends in an unquoted value state even though the else branch
 	// ends in stateBeforeValue.
 	if c, d := nudge(a), nudge(b); !(c.eq(a) && d.eq(b)) {
-		if e := join(c, d, line, nodeName); e.state != stateError {
+		if e := join(c, d, node, nodeName); e.state != stateError {
 			return e
 		}
 	}
 
 	return context{
 		state: stateError,
-		err:   errorf(ErrBranchEnd, line, "{{%s}} branches end in different contexts: %v, %v", nodeName, a, b),
+		err:   errorf(ErrBranchEnd, node, 0, "{{%s}} branches end in different contexts: %v, %v", nodeName, a, b),
 	}
 }
 
@@ -425,7 +417,7 @@ func (e *escaper) escapeBranch(c context, n *parse.BranchNode, nodeName string)
 		// We check that executing n.List once results in the same context
 		// as executing n.List twice.
 		c1, _ := e.escapeListConditionally(c0, n.List, nil)
-		c0 = join(c0, c1, n.Line, nodeName)
+		c0 = join(c0, c1, n, nodeName)
 		if c0.state == stateError {
 			// Make clear that this is a problem on loop re-entry
 			// since developers tend to overlook that branch when
@@ -436,7 +428,7 @@ func (e *escaper) escapeBranch(c context, n *parse.BranchNode, nodeName string)
 		}
 	}
 	c1 := e.escapeList(c, n.ElseList)
-	return join(c0, c1, n.Line, nodeName)
+	return join(c0, c1, n, nodeName)
 }
 
 // escapeList escapes a list template node.
@@ -488,7 +480,7 @@ func (e *escaper) escapeListConditionally(c context, n *parse.ListNode, filter f
 
 // escapeTemplate escapes a {{template}} call node.
 func (e *escaper) escapeTemplate(c context, n *parse.TemplateNode) context {
-	c, name := e.escapeTree(c, n.Name, n.Line)
+	c, name := e.escapeTree(c, n, n.Name, n.Line)
 	if name != n.Name {
 		e.editTemplateNode(n, name)
 	}
@@ -497,7 +489,7 @@ func (e *escaper) escapeTemplate(c context, n *parse.TemplateNode) context {
 
 // escapeTree escapes the named template starting in the given context as
 // necessary and returns its output context.
-func (e *escaper) escapeTree(c context, name string, line int) (context, string) {
+func (e *escaper) escapeTree(c context, node parse.Node, name string, line int) (context, string) {
 	// Mangle the template name with the input context to produce a reliable
 	// identifier.
 	dname := c.mangle(name)
@@ -513,12 +505,12 @@ func (e *escaper) escapeTree(c context, name string, line int) (context, string)
 		if e.tmpl.set[name] != nil {
 			return context{
 				state: stateError,
-				err:   errorf(ErrNoSuchTemplate, line, "%q is an incomplete or empty template", name),
+				err:   errorf(ErrNoSuchTemplate, node, line, "%q is an incomplete or empty template", name),
 			}, dname
 		}
 		return context{
 			state: stateError,
-			err:   errorf(ErrNoSuchTemplate, line, "no such template %q", name),
+			err:   errorf(ErrNoSuchTemplate, node, line, "no such template %q", name),
 		}, dname
 	}
 	if dname != name {
@@ -550,8 +542,7 @@ func (e *escaper) computeOutCtx(c context, t *template.Template) context {
 	if !ok && c1.state != stateError {
 		return context{
 			state: stateError,
-			// TODO: Find the first node with a line in t.text.Tree.Root
-			err: errorf(ErrOutputContext, 0, "cannot compute output context for template %s", t.Name()),
+			err:   errorf(ErrOutputContext, t.Tree.Root, 0, "cannot compute output context for template %s", t.Name()),
 		}
 	}
 	return c1
@@ -695,7 +686,7 @@ func contextAfterText(c context, s []byte) (context, int) {
 		if j := bytes.IndexAny(s[:i], "\"'<=`"); j >= 0 {
 			return context{
 				state: stateError,
-				err:   errorf(ErrBadHTML, 0, "%q in unquoted attr: %q", s[j:j+1], s[:i]),
+				err:   errorf(ErrBadHTML, nil, 0, "%q in unquoted attr: %q", s[j:j+1], s[:i]),
 			}, len(s)
 		}
 	}
diff --git a/src/pkg/html/template/escape_test.go b/src/pkg/html/template/escape_test.go
index 5509b836f9..ef7b877484 100644
--- a/src/pkg/html/template/escape_test.go
+++ b/src/pkg/html/template/escape_test.go
@@ -861,29 +861,29 @@ func TestErrors(t *testing.T) {
 		// Error cases.
 		{
 			"{{if .Cond}}<a{{end}}",
-			"z:1: {{if}} branches",
+			"z:1:5: {{if}} branches",
 		},
 		{
 			"{{if .Cond}}\n{{else}}\n<a{{end}}",
-			"z:1: {{if}} branches",
+			"z:1:5: {{if}} branches",
 		},
 		{
 			// Missing quote in the else branch.
 			`{{if .Cond}}<a href="foo">{{else}}<a href="bar>{{end}}`,
-			"z:1: {{if}} branches",
+			"z:1:5: {{if}} branches",
 		},
 		{
 			// Different kind of attribute: href implies a URL.
 			"<a {{if .Cond}}href='{{else}}title='{{end}}{{.X}}'>",
-			"z:1: {{if}} branches",
+			"z:1:8: {{if}} branches",
 		},
 		{
 			"\n{{with .X}}<a{{end}}",
-			"z:2: {{with}} branches",
+			"z:2:7: {{with}} branches",
 		},
 		{
 			"\n{{with .X}}<a>{{else}}<a{{end}}",
-			"z:2: {{with}} branches",
+			"z:2:7: {{with}} branches",
 		},
 		{
 			"{{range .Items}}<a{{end}}",
@@ -891,7 +891,7 @@ func TestErrors(t *testing.T) {
 		},
 		{
 			"\n{{range .Items}} x='<a{{end}}",
-			"z:2: on range loop re-entry: {{range}} branches",
+			"z:2:8: on range loop re-entry: {{range}} branches",
 		},
 		{
 			"<a b=1 c={{.H}}",
@@ -903,7 +903,7 @@ func TestErrors(t *testing.T) {
 		},
 		{
 			`<a href="{{if .F}}/foo?a={{else}}/bar/{{end}}{{.H}}">`,
-			"z:1: {{.H}} appears in an ambiguous URL context",
+			"z:1:47: {{.H}} appears in an ambiguous URL context",
 		},
 		{
 			`<a onclick="alert('Hello \`,
@@ -932,7 +932,7 @@ func TestErrors(t *testing.T) {
 		},
 		{
 			`{{template "foo"}}`,
-			"z:1: no such template \"foo\"",
+			"z:1:11: no such template \"foo\"",
 		},
 		{
 			`<div{{template "y"}}>` +
diff --git a/src/pkg/html/template/template.go b/src/pkg/html/template/template.go
index 538837cc5c..ce6170105c 100644
--- a/src/pkg/html/template/template.go
+++ b/src/pkg/html/template/template.go
@@ -56,7 +56,7 @@ func (t *Template) escape() error {
 	t.nameSpace.mu.Lock()
 	defer t.nameSpace.mu.Unlock()
 	if t.escapeErr == nil {
-		if err := escapeTemplates(t, t.Name()); err != nil {
+		if err := escapeTemplate(t, t.text.Root, t.Name()); err != nil {
 			return err
 		}
 	} else if t.escapeErr != escapeOK {
@@ -112,7 +112,7 @@ func (t *Template) lookupAndEscapeTemplate(name string) (tmpl *Template, err err
 		panic("html/template internal error: template escaping out of sync")
 	}
 	if tmpl.escapeErr == nil {
-		err = escapeTemplates(tmpl, name)
+		err = escapeTemplate(tmpl, tmpl.text.Root, name)
 	}
 	return tmpl, err
 }
diff --git a/src/pkg/html/template/transition.go b/src/pkg/html/template/transition.go
index 7f30a7ab8d..b486fcd285 100644
--- a/src/pkg/html/template/transition.go
+++ b/src/pkg/html/template/transition.go
@@ -102,7 +102,7 @@ func tTag(c context, s []byte) (context, int) {
 	if i == j {
 		return context{
 			state: stateError,
-			err:   errorf(ErrBadHTML, 0, "expected space, attr name, or end of tag, but got %q", s[i:]),
+			err:   errorf(ErrBadHTML, nil, 0, "expected space, attr name, or end of tag, but got %q", s[i:]),
 		}, len(s)
 	}
 	switch attrType(string(s[i:j])) {
@@ -245,7 +245,7 @@ func tJS(c context, s []byte) (context, int) {
 		default:
 			return context{
 				state: stateError,
-				err:   errorf(ErrSlashAmbig, 0, "'/' could start a division or regexp: %.32q", s[i:]),
+				err:   errorf(ErrSlashAmbig, nil, 0, "'/' could start a division or regexp: %.32q", s[i:]),
 			}, len(s)
 		}
 	default:
@@ -277,7 +277,7 @@ func tJSDelimited(c context, s []byte) (context, int) {
 			if i == len(s) {
 				return context{
 					state: stateError,
-					err:   errorf(ErrPartialEscape, 0, "unfinished escape sequence in JS string: %q", s),
+					err:   errorf(ErrPartialEscape, nil, 0, "unfinished escape sequence in JS string: %q", s),
 				}, len(s)
 			}
 		case '[':
@@ -299,7 +299,7 @@ func tJSDelimited(c context, s []byte) (context, int) {
 		// into charsets is desired.
 		return context{
 			state: stateError,
-			err:   errorf(ErrPartialCharset, 0, "unfinished JS regexp charset: %q", s),
+			err:   errorf(ErrPartialCharset, nil, 0, "unfinished JS regexp charset: %q", s),
 		}, len(s)
 	}
 
@@ -459,7 +459,7 @@ func tCSSStr(c context, s []byte) (context, int) {
 			if i == len(s) {
 				return context{
 					state: stateError,
-					err:   errorf(ErrPartialEscape, 0, "unfinished escape sequence in CSS string: %q", s),
+					err:   errorf(ErrPartialEscape, nil, 0, "unfinished escape sequence in CSS string: %q", s),
 				}, len(s)
 			}
 		} else {
@@ -489,7 +489,7 @@ func eatAttrName(s []byte, i int) (int, *Error) {
 			// These result in a parse warning in HTML5 and are
 			// indicative of serious problems if seen in an attr
 			// name in a template.
-			return -1, errorf(ErrBadHTML, 0, "%q in attribute name: %.32q", s[j:j+1], s)
+			return -1, errorf(ErrBadHTML, nil, 0, "%q in attribute name: %.32q", s[j:j+1], s)
 		default:
 			// No-op.
 		}
diff --git a/src/pkg/text/template/parse/node.go b/src/pkg/text/template/parse/node.go
index dc6a3bb929..e6d6613250 100644
--- a/src/pkg/text/template/parse/node.go
+++ b/src/pkg/text/template/parse/node.go
@@ -26,8 +26,9 @@ type Node interface {
 	// CopyXxx methods that return *XxxNode.
 	Copy() Node
 	Position() Pos // byte position of start of node in full original input string
-	// Make sure only functions in this package can create Nodes.
-	unexported()
+	// tree returns the containing *Tree.
+	// It is unexported so all implementations of Node are in this package.
+	tree() *Tree
 }
 
 // NodeType identifies the type of a parse tree node.
@@ -41,11 +42,6 @@ func (p Pos) Position() Pos {
 	return p
 }
 
-// unexported keeps Node implementations local to the package.
-// All implementations embed Pos, so this takes care of it.
-func (Pos) unexported() {
-}
-
 // Type returns itself and provides an easy default implementation
 // for embedding in a Node. Embedded in all non-trivial Nodes.
 func (t NodeType) Type() NodeType {
@@ -81,17 +77,22 @@ const (
 type ListNode struct {
 	NodeType
 	Pos
+	tr    *Tree
 	Nodes []Node // The element nodes in lexical order.
 }
 
-func newList(pos Pos) *ListNode {
-	return &ListNode{NodeType: NodeList, Pos: pos}
+func (t *Tree) newList(pos Pos) *ListNode {
+	return &ListNode{tr: t, NodeType: NodeList, Pos: pos}
 }
 
 func (l *ListNode) append(n Node) {
 	l.Nodes = append(l.Nodes, n)
 }
 
+func (l *ListNode) tree() *Tree {
+	return l.tr
+}
+
 func (l *ListNode) String() string {
 	b := new(bytes.Buffer)
 	for _, n := range l.Nodes {
@@ -104,7 +105,7 @@ func (l *ListNode) CopyList() *ListNode {
 	if l == nil {
 		return l
 	}
-	n := newList(l.Pos)
+	n := l.tr.newList(l.Pos)
 	for _, elem := range l.Nodes {
 		n.append(elem.Copy())
 	}
@@ -119,32 +120,38 @@ func (l *ListNode) Copy() Node {
 type TextNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	Text []byte // The text; may span newlines.
 }
 
-func newText(pos Pos, text string) *TextNode {
-	return &TextNode{NodeType: NodeText, Pos: pos, Text: []byte(text)}
+func (t *Tree) newText(pos Pos, text string) *TextNode {
+	return &TextNode{tr: t, NodeType: NodeText, Pos: pos, Text: []byte(text)}
 }
 
 func (t *TextNode) String() string {
 	return fmt.Sprintf(textFormat, t.Text)
 }
 
+func (t *TextNode) tree() *Tree {
+	return t.tr
+}
+
 func (t *TextNode) Copy() Node {
-	return &TextNode{NodeType: NodeText, Text: append([]byte{}, t.Text...)}
+	return &TextNode{tr: t.tr, NodeType: NodeText, Pos: t.Pos, Text: append([]byte{}, t.Text...)}
 }
 
 // PipeNode holds a pipeline with optional declaration
 type PipeNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	Line int             // The line number in the input (deprecated; kept for compatibility)
 	Decl []*VariableNode // Variable declarations in lexical order.
 	Cmds []*CommandNode  // The commands in lexical order.
 }
 
-func newPipeline(pos Pos, line int, decl []*VariableNode) *PipeNode {
-	return &PipeNode{NodeType: NodePipe, Pos: pos, Line: line, Decl: decl}
+func (t *Tree) newPipeline(pos Pos, line int, decl []*VariableNode) *PipeNode {
+	return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Decl: decl}
 }
 
 func (p *PipeNode) append(command *CommandNode) {
@@ -171,6 +178,10 @@ func (p *PipeNode) String() string {
 	return s
 }
 
+func (p *PipeNode) tree() *Tree {
+	return p.tr
+}
+
 func (p *PipeNode) CopyPipe() *PipeNode {
 	if p == nil {
 		return p
@@ -179,7 +190,7 @@ func (p *PipeNode) CopyPipe() *PipeNode {
 	for _, d := range p.Decl {
 		decl = append(decl, d.Copy().(*VariableNode))
 	}
-	n := newPipeline(p.Pos, p.Line, decl)
+	n := p.tr.newPipeline(p.Pos, p.Line, decl)
 	for _, c := range p.Cmds {
 		n.append(c.Copy().(*CommandNode))
 	}
@@ -196,12 +207,13 @@ func (p *PipeNode) Copy() Node {
 type ActionNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	Line int       // The line number in the input (deprecated; kept for compatibility)
 	Pipe *PipeNode // The pipeline in the action.
 }
 
-func newAction(pos Pos, line int, pipe *PipeNode) *ActionNode {
-	return &ActionNode{NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
+func (t *Tree) newAction(pos Pos, line int, pipe *PipeNode) *ActionNode {
+	return &ActionNode{tr: t, NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe}
 }
 
 func (a *ActionNode) String() string {
@@ -209,8 +221,12 @@ func (a *ActionNode) String() string {
 
 }
 
+func (a *ActionNode) tree() *Tree {
+	return a.tr
+}
+
 func (a *ActionNode) Copy() Node {
-	return newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
+	return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
 
 }
 
@@ -218,11 +234,12 @@ func (a *ActionNode) Copy() Node {
 type CommandNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	Args []Node // Arguments in lexical order: Identifier, field, or constant.
 }
 
-func newCommand(pos Pos) *CommandNode {
-	return &CommandNode{NodeType: NodeCommand, Pos: pos}
+func (t *Tree) newCommand(pos Pos) *CommandNode {
+	return &CommandNode{tr: t, NodeType: NodeCommand, Pos: pos}
 }
 
 func (c *CommandNode) append(arg Node) {
@@ -244,11 +261,15 @@ func (c *CommandNode) String() string {
 	return s
 }
 
+func (c *CommandNode) tree() *Tree {
+	return c.tr
+}
+
 func (c *CommandNode) Copy() Node {
 	if c == nil {
 		return c
 	}
-	n := newCommand(c.Pos)
+	n := c.tr.newCommand(c.Pos)
 	for _, c := range c.Args {
 		n.append(c.Copy())
 	}
@@ -259,6 +280,7 @@ func (c *CommandNode) Copy() Node {
 type IdentifierNode struct {
 	NodeType
 	Pos
+	tr    *Tree
 	Ident string // The identifier's name.
 }
 
@@ -275,12 +297,24 @@ func (i *IdentifierNode) SetPos(pos Pos) *IdentifierNode {
 	return i
 }
 
+// SetTree sets the parent tree for the node. NewIdentifier is a public method so we can't modify its signature.
+// Chained for convenience.
+// TODO: fix one day?
+func (i *IdentifierNode) SetTree(t *Tree) *IdentifierNode {
+	i.tr = t
+	return i
+}
+
 func (i *IdentifierNode) String() string {
 	return i.Ident
 }
 
+func (i *IdentifierNode) tree() *Tree {
+	return i.tr
+}
+
 func (i *IdentifierNode) Copy() Node {
-	return NewIdentifier(i.Ident).SetPos(i.Pos)
+	return NewIdentifier(i.Ident).SetTree(i.tr).SetPos(i.Pos)
 }
 
 // VariableNode holds a list of variable names, possibly with chained field
@@ -288,11 +322,12 @@ func (i *IdentifierNode) Copy() Node {
 type VariableNode struct {
 	NodeType
 	Pos
+	tr    *Tree
 	Ident []string // Variable name and fields in lexical order.
 }
 
-func newVariable(pos Pos, ident string) *VariableNode {
-	return &VariableNode{NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
+func (t *Tree) newVariable(pos Pos, ident string) *VariableNode {
+	return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")}
 }
 
 func (v *VariableNode) String() string {
@@ -306,50 +341,58 @@ func (v *VariableNode) String() string {
 	return s
 }
 
+func (v *VariableNode) tree() *Tree {
+	return v.tr
+}
+
 func (v *VariableNode) Copy() Node {
-	return &VariableNode{NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
+	return &VariableNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)}
 }
 
 // DotNode holds the special identifier '.'.
 type DotNode struct {
+	NodeType
 	Pos
+	tr *Tree
 }
 
-func newDot(pos Pos) *DotNode {
-	return &DotNode{Pos: pos}
-}
-
-func (d *DotNode) Type() NodeType {
-	return NodeDot
+func (t *Tree) newDot(pos Pos) *DotNode {
+	return &DotNode{tr: t, NodeType: NodeDot, Pos: pos}
 }
 
 func (d *DotNode) String() string {
 	return "."
 }
 
+func (d *DotNode) tree() *Tree {
+	return d.tr
+}
+
 func (d *DotNode) Copy() Node {
-	return newDot(d.Pos)
+	return d.tr.newDot(d.Pos)
 }
 
 // NilNode holds the special identifier 'nil' representing an untyped nil constant.
 type NilNode struct {
+	NodeType
 	Pos
+	tr *Tree
 }
 
-func newNil(pos Pos) *NilNode {
-	return &NilNode{Pos: pos}
-}
-
-func (n *NilNode) Type() NodeType {
-	return NodeNil
+func (t *Tree) newNil(pos Pos) *NilNode {
+	return &NilNode{tr: t, NodeType: NodeNil, Pos: pos}
 }
 
 func (n *NilNode) String() string {
 	return "nil"
 }
 
+func (n *NilNode) tree() *Tree {
+	return n.tr
+}
+
 func (n *NilNode) Copy() Node {
-	return newNil(n.Pos)
+	return n.tr.newNil(n.Pos)
 }
 
 // FieldNode holds a field (identifier starting with '.').
@@ -358,11 +401,12 @@ func (n *NilNode) Copy() Node {
 type FieldNode struct {
 	NodeType
 	Pos
+	tr    *Tree
 	Ident []string // The identifiers in lexical order.
 }
 
-func newField(pos Pos, ident string) *FieldNode {
-	return &FieldNode{NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
+func (t *Tree) newField(pos Pos, ident string) *FieldNode {
+	return &FieldNode{tr: t, NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period
 }
 
 func (f *FieldNode) String() string {
@@ -373,8 +417,12 @@ func (f *FieldNode) String() string {
 	return s
 }
 
+func (f *FieldNode) tree() *Tree {
+	return f.tr
+}
+
 func (f *FieldNode) Copy() Node {
-	return &FieldNode{NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
+	return &FieldNode{tr: f.tr, NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)}
 }
 
 // ChainNode holds a term followed by a chain of field accesses (identifier starting with '.').
@@ -383,12 +431,13 @@ func (f *FieldNode) Copy() Node {
 type ChainNode struct {
 	NodeType
 	Pos
+	tr    *Tree
 	Node  Node
 	Field []string // The identifiers in lexical order.
 }
 
-func newChain(pos Pos, node Node) *ChainNode {
-	return &ChainNode{NodeType: NodeChain, Pos: pos, Node: node}
+func (t *Tree) newChain(pos Pos, node Node) *ChainNode {
+	return &ChainNode{tr: t, NodeType: NodeChain, Pos: pos, Node: node}
 }
 
 // Add adds the named field (which should start with a period) to the end of the chain.
@@ -414,19 +463,24 @@ func (c *ChainNode) String() string {
 	return s
 }
 
+func (c *ChainNode) tree() *Tree {
+	return c.tr
+}
+
 func (c *ChainNode) Copy() Node {
-	return &ChainNode{NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
+	return &ChainNode{tr: c.tr, NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)}
 }
 
 // BoolNode holds a boolean constant.
 type BoolNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	True bool // The value of the boolean constant.
 }
 
-func newBool(pos Pos, true bool) *BoolNode {
-	return &BoolNode{NodeType: NodeBool, Pos: pos, True: true}
+func (t *Tree) newBool(pos Pos, true bool) *BoolNode {
+	return &BoolNode{tr: t, NodeType: NodeBool, Pos: pos, True: true}
 }
 
 func (b *BoolNode) String() string {
@@ -436,8 +490,12 @@ func (b *BoolNode) String() string {
 	return "false"
 }
 
+func (b *BoolNode) tree() *Tree {
+	return b.tr
+}
+
 func (b *BoolNode) Copy() Node {
-	return newBool(b.Pos, b.True)
+	return b.tr.newBool(b.Pos, b.True)
 }
 
 // NumberNode holds a number: signed or unsigned integer, float, or complex.
@@ -446,6 +504,7 @@ func (b *BoolNode) Copy() Node {
 type NumberNode struct {
 	NodeType
 	Pos
+	tr         *Tree
 	IsInt      bool       // Number has an integral value.
 	IsUint     bool       // Number has an unsigned integral value.
 	IsFloat    bool       // Number has a floating-point value.
@@ -457,8 +516,8 @@ type NumberNode struct {
 	Text       string     // The original textual representation from the input.
 }
 
-func newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
-	n := &NumberNode{NodeType: NodeNumber, Pos: pos, Text: text}
+func (t *Tree) newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) {
+	n := &NumberNode{tr: t, NodeType: NodeNumber, Pos: pos, Text: text}
 	switch typ {
 	case itemCharConstant:
 		rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0])
@@ -559,6 +618,10 @@ func (n *NumberNode) String() string {
 	return n.Text
 }
 
+func (n *NumberNode) tree() *Tree {
+	return n.tr
+}
+
 func (n *NumberNode) Copy() Node {
 	nn := new(NumberNode)
 	*nn = *n // Easy, fast, correct.
@@ -569,53 +632,61 @@ func (n *NumberNode) Copy() Node {
 type StringNode struct {
 	NodeType
 	Pos
+	tr     *Tree
 	Quoted string // The original text of the string, with quotes.
 	Text   string // The string, after quote processing.
 }
 
-func newString(pos Pos, orig, text string) *StringNode {
-	return &StringNode{NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
+func (t *Tree) newString(pos Pos, orig, text string) *StringNode {
+	return &StringNode{tr: t, NodeType: NodeString, Pos: pos, Quoted: orig, Text: text}
 }
 
 func (s *StringNode) String() string {
 	return s.Quoted
 }
 
+func (s *StringNode) tree() *Tree {
+	return s.tr
+}
+
 func (s *StringNode) Copy() Node {
-	return newString(s.Pos, s.Quoted, s.Text)
+	return s.tr.newString(s.Pos, s.Quoted, s.Text)
 }
 
 // endNode represents an {{end}} action.
 // It does not appear in the final parse tree.
 type endNode struct {
+	NodeType
 	Pos
+	tr *Tree
 }
 
-func newEnd(pos Pos) *endNode {
-	return &endNode{Pos: pos}
-}
-
-func (e *endNode) Type() NodeType {
-	return nodeEnd
+func (t *Tree) newEnd(pos Pos) *endNode {
+	return &endNode{tr: t, NodeType: nodeEnd, Pos: pos}
 }
 
 func (e *endNode) String() string {
 	return "{{end}}"
 }
 
+func (e *endNode) tree() *Tree {
+	return e.tr
+}
+
 func (e *endNode) Copy() Node {
-	return newEnd(e.Pos)
+	return e.tr.newEnd(e.Pos)
 }
 
 // elseNode represents an {{else}} action. Does not appear in the final tree.
 type elseNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	Line int // The line number in the input (deprecated; kept for compatibility)
 }
 
-func newElse(pos Pos, line int) *elseNode {
-	return &elseNode{NodeType: nodeElse, Pos: pos, Line: line}
+func (t *Tree) newElse(pos Pos, line int) *elseNode {
+	return &elseNode{tr: t, NodeType: nodeElse, Pos: pos, Line: line}
 }
 
 func (e *elseNode) Type() NodeType {
@@ -626,14 +697,19 @@ func (e *elseNode) String() string {
 	return "{{else}}"
 }
 
+func (e *elseNode) tree() *Tree {
+	return e.tr
+}
+
 func (e *elseNode) Copy() Node {
-	return newElse(e.Pos, e.Line)
+	return e.tr.newElse(e.Pos, e.Line)
 }
 
 // BranchNode is the common representation of if, range, and with.
 type BranchNode struct {
 	NodeType
 	Pos
+	tr       *Tree
 	Line     int       // The line number in the input (deprecated; kept for compatibility)
 	Pipe     *PipeNode // The pipeline to be evaluated.
 	List     *ListNode // What to execute if the value is non-empty.
@@ -658,17 +734,34 @@ func (b *BranchNode) String() string {
 	return fmt.Sprintf("{{%s %s}}%s{{end}}", name, b.Pipe, b.List)
 }
 
+func (b *BranchNode) tree() *Tree {
+	return b.tr
+}
+
+func (b *BranchNode) Copy() Node {
+	switch b.NodeType {
+	case NodeIf:
+		return b.tr.newIf(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	case NodeRange:
+		return b.tr.newRange(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	case NodeWith:
+		return b.tr.newWith(b.Pos, b.Line, b.Pipe, b.List, b.ElseList)
+	default:
+		panic("unknown branch type")
+	}
+}
+
 // IfNode represents an {{if}} action and its commands.
 type IfNode struct {
 	BranchNode
 }
 
-func newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode {
-	return &IfNode{BranchNode{NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+func (t *Tree) newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode {
+	return &IfNode{BranchNode{tr: t, NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
 }
 
 func (i *IfNode) Copy() Node {
-	return newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
+	return i.tr.newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList())
 }
 
 // RangeNode represents a {{range}} action and its commands.
@@ -676,12 +769,12 @@ type RangeNode struct {
 	BranchNode
 }
 
-func newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode {
-	return &RangeNode{BranchNode{NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+func (t *Tree) newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode {
+	return &RangeNode{BranchNode{tr: t, NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
 }
 
 func (r *RangeNode) Copy() Node {
-	return newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
+	return r.tr.newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList())
 }
 
 // WithNode represents a {{with}} action and its commands.
@@ -689,25 +782,26 @@ type WithNode struct {
 	BranchNode
 }
 
-func newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
-	return &WithNode{BranchNode{NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
+func (t *Tree) newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
+	return &WithNode{BranchNode{tr: t, NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
 }
 
 func (w *WithNode) Copy() Node {
-	return newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
+	return w.tr.newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList())
 }
 
 // TemplateNode represents a {{template}} action.
 type TemplateNode struct {
 	NodeType
 	Pos
+	tr   *Tree
 	Line int       // The line number in the input (deprecated; kept for compatibility)
 	Name string    // The name of the template (unquoted).
 	Pipe *PipeNode // The command to evaluate as dot for the template.
 }
 
-func newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode {
-	return &TemplateNode{NodeType: NodeTemplate, Line: line, Pos: pos, Name: name, Pipe: pipe}
+func (t *Tree) newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode {
+	return &TemplateNode{tr: t, NodeType: NodeTemplate, Pos: pos, Line: line, Name: name, Pipe: pipe}
 }
 
 func (t *TemplateNode) String() string {
@@ -717,6 +811,10 @@ func (t *TemplateNode) String() string {
 	return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe)
 }
 
-func (t *TemplateNode) Copy() Node {
-	return newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
+func (t *TemplateNode) tree() *Tree {
+	return t.tr
+}
+
+func (t *TemplateNode) Copy() Node {
+	return t.tr.newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe())
 }
diff --git a/src/pkg/text/template/parse/parse.go b/src/pkg/text/template/parse/parse.go
index 34112fb7b3..af33880c15 100644
--- a/src/pkg/text/template/parse/parse.go
+++ b/src/pkg/text/template/parse/parse.go
@@ -129,9 +129,15 @@ func New(name string, funcs ...map[string]interface{}) *Tree {
 }
 
 // ErrorContext returns a textual representation of the location of the node in the input text.
+// The receiver is only used when the node does not have a pointer to the tree inside,
+// which can occur in old code.
 func (t *Tree) ErrorContext(n Node) (location, context string) {
 	pos := int(n.Position())
-	text := t.text[:pos]
+	tree := n.tree()
+	if tree == nil {
+		tree = t
+	}
+	text := tree.text[:pos]
 	byteNum := strings.LastIndex(text, "\n")
 	if byteNum == -1 {
 		byteNum = pos // On first line.
@@ -144,7 +150,7 @@ func (t *Tree) ErrorContext(n Node) (location, context string) {
 	if len(context) > 20 {
 		context = fmt.Sprintf("%.20s...", context)
 	}
-	return fmt.Sprintf("%s:%d:%d", t.ParseName, lineNum, byteNum), context
+	return fmt.Sprintf("%s:%d:%d", tree.ParseName, lineNum, byteNum), context
 }
 
 // errorf formats the error and terminates processing.
@@ -268,7 +274,7 @@ func IsEmptyTree(n Node) bool {
 // as itemList except it also parses {{define}} actions.
 // It runs to EOF.
 func (t *Tree) parse(treeSet map[string]*Tree) (next Node) {
-	t.Root = newList(t.peek().pos)
+	t.Root = t.newList(t.peek().pos)
 	for t.peek().typ != itemEOF {
 		if t.peek().typ == itemLeftDelim {
 			delim := t.next()
@@ -316,7 +322,7 @@ func (t *Tree) parseDefinition(treeSet map[string]*Tree) {
 //	textOrAction*
 // Terminates at {{end}} or {{else}}, returned separately.
 func (t *Tree) itemList() (list *ListNode, next Node) {
-	list = newList(t.peekNonSpace().pos)
+	list = t.newList(t.peekNonSpace().pos)
 	for t.peekNonSpace().typ != itemEOF {
 		n := t.textOrAction()
 		switch n.Type() {
@@ -334,7 +340,7 @@ func (t *Tree) itemList() (list *ListNode, next Node) {
 func (t *Tree) textOrAction() Node {
 	switch token := t.nextNonSpace(); token.typ {
 	case itemText:
-		return newText(token.pos, token.val)
+		return t.newText(token.pos, token.val)
 	case itemLeftDelim:
 		return t.action()
 	default:
@@ -365,7 +371,7 @@ func (t *Tree) action() (n Node) {
 	}
 	t.backup()
 	// Do not pop variables; they persist until "end".
-	return newAction(t.peek().pos, t.lex.lineNumber(), t.pipeline("command"))
+	return t.newAction(t.peek().pos, t.lex.lineNumber(), t.pipeline("command"))
 }
 
 // Pipeline:
@@ -384,7 +390,7 @@ func (t *Tree) pipeline(context string) (pipe *PipeNode) {
 			tokenAfterVariable := t.peek()
 			if next := t.peekNonSpace(); next.typ == itemColonEquals || (next.typ == itemChar && next.val == ",") {
 				t.nextNonSpace()
-				variable := newVariable(v.pos, v.val)
+				variable := t.newVariable(v.pos, v.val)
 				decl = append(decl, variable)
 				t.vars = append(t.vars, v.val)
 				if next.typ == itemChar && next.val == "," {
@@ -401,7 +407,7 @@ func (t *Tree) pipeline(context string) (pipe *PipeNode) {
 		}
 		break
 	}
-	pipe = newPipeline(pos, t.lex.lineNumber(), decl)
+	pipe = t.newPipeline(pos, t.lex.lineNumber(), decl)
 	for {
 		switch token := t.nextNonSpace(); token.typ {
 		case itemRightDelim, itemRightParen:
@@ -442,7 +448,7 @@ func (t *Tree) parseControl(allowElseIf bool, context string) (pos Pos, line int
 			// TODO: Should we allow else-if in with and range?
 			if t.peek().typ == itemIf {
 				t.next() // Consume the "if" token.
-				elseList = newList(next.Position())
+				elseList = t.newList(next.Position())
 				elseList.append(t.ifControl())
 				// Do not consume the next item - only one {{end}} required.
 				break
@@ -461,7 +467,7 @@ func (t *Tree) parseControl(allowElseIf bool, context string) (pos Pos, line int
 //	{{if pipeline}} itemList {{else}} itemList {{end}}
 // If keyword is past.
 func (t *Tree) ifControl() Node {
-	return newIf(t.parseControl(true, "if"))
+	return t.newIf(t.parseControl(true, "if"))
 }
 
 // Range:
@@ -469,7 +475,7 @@ func (t *Tree) ifControl() Node {
 //	{{range pipeline}} itemList {{else}} itemList {{end}}
 // Range keyword is past.
 func (t *Tree) rangeControl() Node {
-	return newRange(t.parseControl(false, "range"))
+	return t.newRange(t.parseControl(false, "range"))
 }
 
 // With:
@@ -477,14 +483,14 @@ func (t *Tree) rangeControl() Node {
 //	{{with pipeline}} itemList {{else}} itemList {{end}}
 // If keyword is past.
 func (t *Tree) withControl() Node {
-	return newWith(t.parseControl(false, "with"))
+	return t.newWith(t.parseControl(false, "with"))
 }
 
 // End:
 //	{{end}}
 // End keyword is past.
 func (t *Tree) endControl() Node {
-	return newEnd(t.expect(itemRightDelim, "end").pos)
+	return t.newEnd(t.expect(itemRightDelim, "end").pos)
 }
 
 // Else:
@@ -495,9 +501,9 @@ func (t *Tree) elseControl() Node {
 	peek := t.peekNonSpace()
 	if peek.typ == itemIf {
 		// We see "{{else if ... " but in effect rewrite it to {{else}}{{if ... ".
-		return newElse(peek.pos, t.lex.lineNumber())
+		return t.newElse(peek.pos, t.lex.lineNumber())
 	}
-	return newElse(t.expect(itemRightDelim, "else").pos, t.lex.lineNumber())
+	return t.newElse(t.expect(itemRightDelim, "else").pos, t.lex.lineNumber())
 }
 
 // Template:
@@ -523,7 +529,7 @@ func (t *Tree) templateControl() Node {
 		// Do not pop variables; they persist until "end".
 		pipe = t.pipeline("template")
 	}
-	return newTemplate(token.pos, t.lex.lineNumber(), name, pipe)
+	return t.newTemplate(token.pos, t.lex.lineNumber(), name, pipe)
 }
 
 // command:
@@ -531,7 +537,7 @@ func (t *Tree) templateControl() Node {
 // space-separated arguments up to a pipeline character or right delimiter.
 // we consume the pipe character but leave the right delim to terminate the action.
 func (t *Tree) command() *CommandNode {
-	cmd := newCommand(t.peekNonSpace().pos)
+	cmd := t.newCommand(t.peekNonSpace().pos)
 	for {
 		t.peekNonSpace() // skip leading spaces.
 		operand := t.operand()
@@ -568,7 +574,7 @@ func (t *Tree) operand() Node {
 		return nil
 	}
 	if t.peek().typ == itemField {
-		chain := newChain(t.peek().pos, node)
+		chain := t.newChain(t.peek().pos, node)
 		for t.peek().typ == itemField {
 			chain.Add(t.next().val)
 		}
@@ -578,9 +584,9 @@ func (t *Tree) operand() Node {
 		// TODO: Switch to Chains always when we can.
 		switch node.Type() {
 		case NodeField:
-			node = newField(chain.Position(), chain.String())
+			node = t.newField(chain.Position(), chain.String())
 		case NodeVariable:
-			node = newVariable(chain.Position(), chain.String())
+			node = t.newVariable(chain.Position(), chain.String())
 		default:
 			node = chain
 		}
@@ -605,19 +611,19 @@ func (t *Tree) term() Node {
 		if !t.hasFunction(token.val) {
 			t.errorf("function %q not defined", token.val)
 		}
-		return NewIdentifier(token.val).SetPos(token.pos)
+		return NewIdentifier(token.val).SetTree(t).SetPos(token.pos)
 	case itemDot:
-		return newDot(token.pos)
+		return t.newDot(token.pos)
 	case itemNil:
-		return newNil(token.pos)
+		return t.newNil(token.pos)
 	case itemVariable:
 		return t.useVar(token.pos, token.val)
 	case itemField:
-		return newField(token.pos, token.val)
+		return t.newField(token.pos, token.val)
 	case itemBool:
-		return newBool(token.pos, token.val == "true")
+		return t.newBool(token.pos, token.val == "true")
 	case itemCharConstant, itemComplex, itemNumber:
-		number, err := newNumber(token.pos, token.val, token.typ)
+		number, err := t.newNumber(token.pos, token.val, token.typ)
 		if err != nil {
 			t.error(err)
 		}
@@ -633,7 +639,7 @@ func (t *Tree) term() Node {
 		if err != nil {
 			t.error(err)
 		}
-		return newString(token.pos, token.val, s)
+		return t.newString(token.pos, token.val, s)
 	}
 	t.backup()
 	return nil
@@ -660,7 +666,7 @@ func (t *Tree) popVars(n int) {
 // useVar returns a node for a variable reference. It errors if the
 // variable is not defined.
 func (t *Tree) useVar(pos Pos, name string) Node {
-	v := newVariable(pos, name)
+	v := t.newVariable(pos, name)
 	for _, varName := range t.vars {
 		if varName == v.Ident[0] {
 			return v
diff --git a/src/pkg/text/template/parse/parse_test.go b/src/pkg/text/template/parse/parse_test.go
index ba1a18ec54..fa6790bef9 100644
--- a/src/pkg/text/template/parse/parse_test.go
+++ b/src/pkg/text/template/parse/parse_test.go
@@ -77,6 +77,7 @@ func TestNumberParse(t *testing.T) {
 		// because imaginary comes out as a number.
 		var c complex128
 		typ := itemNumber
+		var tree *Tree
 		if test.text[0] == '\'' {
 			typ = itemCharConstant
 		} else {
@@ -85,7 +86,7 @@ func TestNumberParse(t *testing.T) {
 				typ = itemComplex
 			}
 		}
-		n, err := newNumber(0, test.text, typ)
+		n, err := tree.newNumber(0, test.text, typ)
 		ok := test.isInt || test.isUint || test.isFloat || test.isComplex
 		if ok && err != nil {
 			t.Errorf("unexpected error for %q: %s", test.text, err)

From d11bb3b177feb47d20e00246fb915af50773904a Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder <josharian@gmail.com>
Date: Fri, 29 Aug 2014 09:55:33 -0700
Subject: [PATCH 285/423] runtime: implement 64 bit division in Go

LGTM=rsc, dave
R=minux, rsc, remyoudompheng, dave
CC=golang-codereviews
https://golang.org/cl/133790043
---
 src/pkg/runtime/vlop_386.s |   6 +-
 src/pkg/runtime/vlop_arm.s |   9 +++
 src/pkg/runtime/vlrt.c     |  33 +-------
 src/pkg/runtime/vlrt.go    | 155 ++++++++++++++++++++++++++++++++++++-
 4 files changed, 170 insertions(+), 33 deletions(-)

diff --git a/src/pkg/runtime/vlop_386.s b/src/pkg/runtime/vlop_386.s
index f3d792c724..7af67c987a 100644
--- a/src/pkg/runtime/vlop_386.s
+++ b/src/pkg/runtime/vlop_386.s
@@ -29,9 +29,9 @@
  * C runtime for 64-bit divide.
  */
 
-// _mul64x32(r *uint64, a uint64, b uint32) uint32
+// runtime·_mul64x32(r *uint64, a uint64, b uint32) uint32
 // sets *r = low 64 bits of 96-bit product a*b; returns high 32 bits.
-TEXT _mul64by32(SB), NOSPLIT, $0
+TEXT runtime·_mul64by32(SB), NOSPLIT, $0
 	MOVL	r+0(FP), CX
 	MOVL	a+4(FP), AX
 	MULL	b+12(FP)
@@ -46,7 +46,7 @@ TEXT _mul64by32(SB), NOSPLIT, $0
 	MOVL	AX, ret+16(FP)
 	RET
 
-TEXT _div64by32(SB), NOSPLIT, $0
+TEXT runtime·_div64by32(SB), NOSPLIT, $0
 	MOVL	r+12(FP), CX
 	MOVL	a+0(FP), AX
 	MOVL	a+4(FP), DX
diff --git a/src/pkg/runtime/vlop_arm.s b/src/pkg/runtime/vlop_arm.s
index 9dfb295e87..0953deee78 100644
--- a/src/pkg/runtime/vlop_arm.s
+++ b/src/pkg/runtime/vlop_arm.s
@@ -294,3 +294,12 @@ out:
 	MOVW	12(R13), R(s)
 	MOVW	16(R13), R(M)
 	RET
+
+// _mul64by32 and _div64by32 not implemented on arm
+TEXT runtime·_mul64by32(SB), NOSPLIT, $0
+	MOVW	$0, R0
+	MOVW	(R0), R1 // crash
+
+TEXT runtime·_div64by32(SB), NOSPLIT, $0
+	MOVW	$0, R0
+	MOVW	(R0), R1 // crash
diff --git a/src/pkg/runtime/vlrt.c b/src/pkg/runtime/vlrt.c
index cab74c5fe8..d4367c30e6 100644
--- a/src/pkg/runtime/vlrt.c
+++ b/src/pkg/runtime/vlrt.c
@@ -34,7 +34,6 @@
  * to generate the code directly now.  Find and remove.
  */
 
-void	runtime·panicstring(char*);
 void	runtime·panicdivide(void);
 
 typedef	unsigned long	ulong;
@@ -182,8 +181,8 @@ _v2f(Vlong x)
 	return _v2d(x);
 }
 
-ulong	_div64by32(Vlong, ulong, ulong*);
-int	_mul64by32(Vlong*, Vlong, ulong);
+ulong	runtime·_div64by32(Vlong, ulong, ulong*);
+int	runtime·_mul64by32(Vlong*, Vlong, ulong);
 
 static void
 slowdodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
@@ -277,7 +276,7 @@ dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
 	if(den.hi != 0){
 		q.hi = 0;
 		n = num.hi/den.hi;
-		if(_mul64by32(&x, den, n) || x.hi > num.hi || (x.hi == num.hi && x.lo > num.lo))
+		if(runtime·_mul64by32(&x, den, n) || x.hi > num.hi || (x.hi == num.hi && x.lo > num.lo))
 			slowdodiv(num, den, &q, &r);
 		else {
 			q.lo = n;
@@ -292,7 +291,7 @@ dodiv(Vlong num, Vlong den, Vlong *qp, Vlong *rp)
 		} else {
 			q.hi = 0;
 		}
-		q.lo = _div64by32(num, den.lo, &r.lo);
+		q.lo = runtime·_div64by32(num, den.lo, &r.lo);
 		r.hi = 0;
 	}
 	if(qp) {
@@ -322,12 +321,6 @@ _divvu(Vlong n, Vlong d)
 	return q;
 }
 
-Vlong
-runtime·uint64div(Vlong n, Vlong d)
-{
-	return _divvu(n, d);
-}
-
 Vlong
 _modvu(Vlong n, Vlong d)
 {
@@ -344,12 +337,6 @@ _modvu(Vlong n, Vlong d)
 	return r;
 }
 
-Vlong
-runtime·uint64mod(Vlong n, Vlong d)
-{
-	return _modvu(n, d);
-}
-
 static void
 vneg(Vlong *v)
 {
@@ -394,12 +381,6 @@ _divv(Vlong n, Vlong d)
 	return q;
 }
 
-Vlong
-runtime·int64div(Vlong n, Vlong d)
-{
-	return _divv(n, d);
-}
-
 Vlong
 _modv(Vlong n, Vlong d)
 {
@@ -432,12 +413,6 @@ _modv(Vlong n, Vlong d)
 	return r;
 }
 
-Vlong
-runtime·int64mod(Vlong n, Vlong d)
-{
-	return _modv(n, d);
-}
-
 Vlong
 _rshav(Vlong a, int b)
 {
diff --git a/src/pkg/runtime/vlrt.go b/src/pkg/runtime/vlrt.go
index c346812aec..50097edde7 100644
--- a/src/pkg/runtime/vlrt.go
+++ b/src/pkg/runtime/vlrt.go
@@ -23,13 +23,14 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-// +build arm
+// +build arm 386
 
 package runtime
 
 import "unsafe"
 
 const (
+	sign32 = 1 << (32 - 1)
 	sign64 = 1 << (64 - 1)
 )
 
@@ -105,3 +106,155 @@ func _d2v(y *uint64, d float64) {
 
 	*y = uint64(yhi)<<32 | uint64(ylo)
 }
+
+func uint64div(n, d uint64) uint64 {
+	// Check for 32 bit operands
+	if uint32(n>>32) == 0 && uint32(d>>32) == 0 {
+		if uint32(d) == 0 {
+			panicdivide()
+		}
+		return uint64(uint32(n) / uint32(d))
+	}
+	q, _ := dodiv(n, d)
+	return q
+}
+
+func uint64mod(n, d uint64) uint64 {
+	// Check for 32 bit operands
+	if uint32(n>>32) == 0 && uint32(d>>32) == 0 {
+		if uint32(d) == 0 {
+			panicdivide()
+		}
+		return uint64(uint32(n) % uint32(d))
+	}
+	_, r := dodiv(n, d)
+	return r
+}
+
+func int64div(n, d int64) int64 {
+	// Check for 32 bit operands
+	if int64(int32(n)) == n && int64(int32(d)) == d {
+		if int32(n) == -0x80000000 && int32(d) == -1 {
+			// special case: 32-bit -0x80000000 / -1 = -0x80000000,
+			// but 64-bit -0x80000000 / -1 = 0x80000000.
+			return 0x80000000
+		}
+		if int32(d) == 0 {
+			panicdivide()
+		}
+		return int64(int32(n) / int32(d))
+	}
+
+	nneg := n < 0
+	dneg := d < 0
+	if nneg {
+		n = -n
+	}
+	if dneg {
+		d = -d
+	}
+	uq, _ := dodiv(uint64(n), uint64(d))
+	q := int64(uq)
+	if nneg != dneg {
+		q = -q
+	}
+	return q
+}
+
+func int64mod(n, d int64) int64 {
+	// Check for 32 bit operands
+	if int64(int32(n)) == n && int64(int32(d)) == d {
+		if int32(d) == 0 {
+			panicdivide()
+		}
+		return int64(int32(n) % int32(d))
+	}
+
+	nneg := n < 0
+	if nneg {
+		n = -n
+	}
+	if d < 0 {
+		d = -d
+	}
+	_, ur := dodiv(uint64(n), uint64(d))
+	r := int64(ur)
+	if nneg {
+		r = -r
+	}
+	return r
+}
+
+//go:noescape
+func _mul64by32(lo64 *uint64, a uint64, b uint32) (hi32 uint32)
+
+//go:noescape
+func _div64by32(a uint64, b uint32, r *uint32) (q uint32)
+
+func dodiv(n, d uint64) (q, r uint64) {
+	if GOARCH == "arm" {
+		// arm doesn't have a division instruction, so
+		// slowdodiv is the best that we can do.
+		// TODO: revisit for arm64.
+		return slowdodiv(n, d)
+	}
+
+	if d > n {
+		return 0, n
+	}
+
+	if uint32(d>>32) != 0 {
+		t := uint32(n>>32) / uint32(d>>32)
+		var lo64 uint64
+		hi32 := _mul64by32(&lo64, d, t)
+		if hi32 != 0 || lo64 > n {
+			return slowdodiv(n, d)
+		}
+		return uint64(t), n - lo64
+	}
+
+	// d is 32 bit
+	var qhi uint32
+	if uint32(n>>32) >= uint32(d) {
+		if uint32(d) == 0 {
+			panicdivide()
+		}
+		qhi = uint32(n>>32) / uint32(d)
+		n -= uint64(uint32(d)*qhi) << 32
+	} else {
+		qhi = 0
+	}
+
+	var rlo uint32
+	qlo := _div64by32(n, uint32(d), &rlo)
+	return uint64(qhi)<<32 + uint64(qlo), uint64(rlo)
+}
+
+func slowdodiv(n, d uint64) (q, r uint64) {
+	if d == 0 {
+		panicdivide()
+	}
+
+	// Set up the divisor and find the number of iterations needed.
+	capn := n
+	if n >= sign64 {
+		capn = sign64
+	}
+	i := 0
+	for d < capn {
+		d <<= 1
+		i++
+	}
+
+	for ; i >= 0; i-- {
+		q <<= 1
+		if n >= d {
+			n -= d
+			q |= 1
+		}
+		d >>= 1
+	}
+	return q, n
+}
+
+func panicdivide()

From 4af796fb6ee041d2c541f902ba2effbf23978d4a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Aug 2014 13:22:17 -0400
Subject: [PATCH 286/423] cmd/gc: allow runtime to define a hex integer type
 for printing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

As part of the translation of the runtime, we need to rewrite
C printf calls to Go print calls. Consider this C printf:

        runtime·printf("[signal %x code=%p addr=%p pc=%p]\n",
                g->sig, g->sigcode0, g->sigcode1, g->sigpc);

Today the only way to write that in Go is:

        print("[signal ")
        printhex(uint64(g->sig))
        print(" code=")
        printhex(uint64(g->sigcode0))
        print(" addr=")
        printhex(uint64(g->sigcode1))
        print(" pc=")
        printhex(uint64(g->sigpc))
        print("]\n")

(That's nearly exactly what runtime code looked like in C before
I added runtime·printf.)

This CL recognizes the unexported type runtime.hex as an integer
that should be printed in hexadecimal instead of decimal.
It's a little kludgy, but it's restricted to package runtime.
Other packages can define type hex with no effect at all.

Now we can translate that original printf as the more compact:

        print("[signal ", hex(g->sig), " code=", hex(g->sigcode0),
                " addr=", hex(g->sigcode1), " pc=", hex(g->sigpc), "]\n")

LGTM=r, iant
R=r, iant
CC=golang-codereviews
https://golang.org/cl/133220043
---
 src/cmd/gc/builtin.c      | 13 +++++++------
 src/cmd/gc/runtime.go     |  1 +
 src/cmd/gc/walk.c         |  9 ++++++---
 src/pkg/runtime/print1.go |  7 +++++--
 4 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/cmd/gc/builtin.c b/src/cmd/gc/builtin.c
index eba9199544..c5bce2ead3 100644
--- a/src/cmd/gc/builtin.c
+++ b/src/cmd/gc/builtin.c
@@ -14,6 +14,7 @@ char *runtimeimport =
 	"func @\"\".printbool (? bool)\n"
 	"func @\"\".printfloat (? float64)\n"
 	"func @\"\".printint (? int64)\n"
+	"func @\"\".printhex (? uint64)\n"
 	"func @\"\".printuint (? uint64)\n"
 	"func @\"\".printcomplex (? complex128)\n"
 	"func @\"\".printstring (? string)\n"
@@ -95,12 +96,12 @@ char *runtimeimport =
 	"func @\"\".makeslice (@\"\".typ·2 *byte, @\"\".nel·3 int64, @\"\".cap·4 int64) (@\"\".ary·1 []any)\n"
 	"func @\"\".growslice (@\"\".typ·2 *byte, @\"\".old·3 []any, @\"\".n·4 int64) (@\"\".ary·1 []any)\n"
 	"func @\"\".memmove (@\"\".to·1 *any, @\"\".frm·2 *any, @\"\".length·3 uintptr)\n"
-	"func @\"\".memequal (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
-	"func @\"\".memequal8 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
-	"func @\"\".memequal16 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
-	"func @\"\".memequal32 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
-	"func @\"\".memequal64 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
-	"func @\"\".memequal128 (@\"\".x·1 *any, @\"\".y·2 *any, @\"\".size·3 uintptr) (? bool)\n"
+	"func @\"\".memequal (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n"
+	"func @\"\".memequal8 (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n"
+	"func @\"\".memequal16 (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n"
+	"func @\"\".memequal32 (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n"
+	"func @\"\".memequal64 (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n"
+	"func @\"\".memequal128 (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n"
 	"func @\"\".int64div (? int64, ? int64) (? int64)\n"
 	"func @\"\".uint64div (? uint64, ? uint64) (? uint64)\n"
 	"func @\"\".int64mod (? int64, ? int64) (? int64)\n"
diff --git a/src/cmd/gc/runtime.go b/src/cmd/gc/runtime.go
index 7617eddd60..646cb68aa9 100644
--- a/src/cmd/gc/runtime.go
+++ b/src/cmd/gc/runtime.go
@@ -26,6 +26,7 @@ func recover(*int32) interface{}
 func printbool(bool)
 func printfloat(float64)
 func printint(int64)
+func printhex(uint64)
 func printuint(uint64)
 func printcomplex(complex128)
 func printstring(string)
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index c251af660e..26d8011240 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -1837,9 +1837,12 @@ walkprint(Node *nn, NodeList **init, int defer)
 					t = types[TINT64];
 				}
 			} else {
-				if(et == TUINT64)
-					on = syslook("printuint", 0);
-				else
+				if(et == TUINT64) {
+					if(t->sym->pkg == runtimepkg && strcmp(t->sym->name, "hex") == 0)
+						on = syslook("printhex", 0);
+					else
+						on = syslook("printuint", 0);
+				} else
 					on = syslook("printint", 0);
 			}
 		} else if(isfloat[et]) {
diff --git a/src/pkg/runtime/print1.go b/src/pkg/runtime/print1.go
index f19cc1da59..28faa7cbbb 100644
--- a/src/pkg/runtime/print1.go
+++ b/src/pkg/runtime/print1.go
@@ -6,6 +6,10 @@ package runtime
 
 import "unsafe"
 
+// The compiler knows that a print of a value of this type
+// should use printhex instead of printuint (decimal).
+type hex uint64
+
 //go:noescape
 func gostring(*byte) string
 
@@ -178,8 +182,7 @@ func vprintf(str string, arg unsafe.Pointer) {
 }
 
 func printpc(p unsafe.Pointer) {
-	print("PC=")
-	printhex(uint64(getcallerpc(p)))
+	print("PC=", hex(uintptr(p)))
 }
 
 func printbool(v bool) {

From 1d0c89a454093801525f1750b1d54318b59b8a78 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Aug 2014 13:22:31 -0400
Subject: [PATCH 287/423] runtime: run runtime.init

Run it right before main.init.
There is still some runtime initialization that
happens before runtime.init, and some of that
may call into Go code (for example to acquire locks)
so this timing is not perfect, but I believe it is the
best we can do.

This came up because global variables intialized
to func values are done in the generated init code,
not in the linker.

LGTM=dvyukov
R=dvyukov
CC=golang-codereviews, iant, khr, r
https://golang.org/cl/135210043
---
 src/pkg/runtime/proc.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 66c5d475bb..d91a829c15 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -199,6 +199,7 @@ runtime·schedinit(void)
 }
 
 extern void main·init(void);
+extern void runtime·init(void);
 extern void main·main(void);
 
 static FuncVal initDone = { runtime·unlockOSThread };
@@ -246,6 +247,7 @@ runtime·main(void)
 
 	if(g->m != &runtime·m0)
 		runtime·throw("runtime·main not on m0");
+	runtime·init();
 	main·init();
 
 	if(g->defer != &d || d.fn != &initDone)

From 7dc2b3cbd1ecc4d703a403924a77d01c8d01bd5a Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Fri, 29 Aug 2014 10:40:45 -0700
Subject: [PATCH 288/423] text/template/parse: restore pointer-only receivers
 for Type on Dot and Nil Needless except that the api tool complains. We could
 fix that issue instead.

TBR=bradfitz
R=golang-codereviews
CC=golang-codereviews
https://golang.org/cl/133290043
---
 src/pkg/text/template/parse/node.go | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/pkg/text/template/parse/node.go b/src/pkg/text/template/parse/node.go
index e6d6613250..55c37f6dba 100644
--- a/src/pkg/text/template/parse/node.go
+++ b/src/pkg/text/template/parse/node.go
@@ -360,6 +360,13 @@ func (t *Tree) newDot(pos Pos) *DotNode {
 	return &DotNode{tr: t, NodeType: NodeDot, Pos: pos}
 }
 
+func (d *DotNode) Type() NodeType {
+	// Override method on embedded NodeType for API compatibility.
+	// TODO: Not really a problem; could change API without effect but
+	// api tool complains.
+	return NodeDot
+}
+
 func (d *DotNode) String() string {
 	return "."
 }
@@ -383,6 +390,13 @@ func (t *Tree) newNil(pos Pos) *NilNode {
 	return &NilNode{tr: t, NodeType: NodeNil, Pos: pos}
 }
 
+func (n *NilNode) Type() NodeType {
+	// Override method on embedded NodeType for API compatibility.
+	// TODO: Not really a problem; could change API without effect but
+	// api tool complains.
+	return NodeNil
+}
+
 func (n *NilNode) String() string {
 	return "nil"
 }

From 7f2e68e9822ce8736d66035d0a3ed3677c2db459 Mon Sep 17 00:00:00 2001
From: Adam Langley <agl@golang.org>
Date: Fri, 29 Aug 2014 12:36:30 -0700
Subject: [PATCH 289/423] crypto: add Signer

Signer is an interface to support opaque private keys.
These keys typically result from being kept in special hardware
(i.e. a TPM) although sometimes operating systems provide a
similar interface using process isolation for security rather
than hardware boundaries.

This changes provides interfaces for representing them and
alters crypto/tls so that client certificates can use
opaque keys.

LGTM=bradfitz
R=bradfitz
CC=golang-codereviews, jdeprez
https://golang.org/cl/114680043
---
 src/pkg/crypto/crypto.go               | 33 ++++++++++++++++++++++++++
 src/pkg/crypto/ecdsa/ecdsa.go          | 24 +++++++++++++++++++
 src/pkg/crypto/rsa/pss.go              | 15 ++++++++++++
 src/pkg/crypto/rsa/rsa.go              | 19 +++++++++++++++
 src/pkg/crypto/tls/common.go           |  7 +++++-
 src/pkg/crypto/tls/handshake_client.go | 30 ++++++++++++-----------
 src/pkg/go/build/deps_test.go          |  2 +-
 7 files changed, 114 insertions(+), 16 deletions(-)

diff --git a/src/pkg/crypto/crypto.go b/src/pkg/crypto/crypto.go
index 4b03628e69..c3a2364fe2 100644
--- a/src/pkg/crypto/crypto.go
+++ b/src/pkg/crypto/crypto.go
@@ -7,6 +7,7 @@ package crypto
 
 import (
 	"hash"
+	"io"
 	"strconv"
 )
 
@@ -14,6 +15,11 @@ import (
 // package.
 type Hash uint
 
+// HashFunc simply returns the value of h so that Hash implements SignerOpts.
+func (h Hash) HashFunc() Hash {
+	return h
+}
+
 const (
 	MD4       Hash = 1 + iota // import code.google.com/p/go.crypto/md4
 	MD5                       // import crypto/md5
@@ -83,3 +89,30 @@ type PublicKey interface{}
 
 // PrivateKey represents a private key using an unspecified algorithm.
 type PrivateKey interface{}
+
+// Signer is an interface for an opaque private key that can be used for
+// signing operations. For example, an RSA key kept in a hardware module.
+type Signer interface {
+	// Public returns the public key corresponding to the opaque,
+	// private key.
+	Public() PublicKey
+
+	// Sign signs msg with the private key, possibly using entropy from
+	// rand. For an RSA key, the resulting signature should be either a
+	// PKCS#1 v1.5 or PSS signature (as indicated by opts). For an (EC)DSA
+	// key, it should be a DER-serialised, ASN.1 signature structure.
+	//
+	// Hash implements the SignerOpts interface and, in most cases, one can
+	// simply pass in the hash function used as opts. Sign may also attempt
+	// to type assert opts to other types in order to obtain algorithm
+	// specific values. See the documentation in each package for details.
+	Sign(rand io.Reader, msg []byte, opts SignerOpts) (signature []byte, err error)
+}
+
+// SignerOpts contains options for signing with a Signer.
+type SignerOpts interface {
+	// HashFunc returns an identifier for the hash function used to produce
+	// the message passed to Signer.Sign, or else zero to indicate that no
+	// hashing was done.
+	HashFunc() Hash
+}
diff --git a/src/pkg/crypto/ecdsa/ecdsa.go b/src/pkg/crypto/ecdsa/ecdsa.go
index 1bec7437a5..d6135531bf 100644
--- a/src/pkg/crypto/ecdsa/ecdsa.go
+++ b/src/pkg/crypto/ecdsa/ecdsa.go
@@ -13,7 +13,9 @@ package ecdsa
 //     http://www.secg.org/download/aid-780/sec1-v2.pdf
 
 import (
+	"crypto"
 	"crypto/elliptic"
+	"encoding/asn1"
 	"io"
 	"math/big"
 )
@@ -30,6 +32,28 @@ type PrivateKey struct {
 	D *big.Int
 }
 
+type ecdsaSignature struct {
+	R, S *big.Int
+}
+
+// Public returns the public key corresponding to priv.
+func (priv *PrivateKey) Public() crypto.PublicKey {
+	return &priv.PublicKey
+}
+
+// Sign signs msg with priv, reading randomness from rand. This method is
+// intended to support keys where the private part is kept in, for example, a
+// hardware module. Common uses should use the Sign function in this package
+// directly.
+func (priv *PrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.SignerOpts) ([]byte, error) {
+	r, s, err := Sign(rand, priv, msg)
+	if err != nil {
+		return nil, err
+	}
+
+	return asn1.Marshal(ecdsaSignature{r, s})
+}
+
 var one = new(big.Int).SetInt64(1)
 
 // randFieldElement returns a random element of the field underlying the given
diff --git a/src/pkg/crypto/rsa/pss.go b/src/pkg/crypto/rsa/pss.go
index 18eafbc05f..e9f2908250 100644
--- a/src/pkg/crypto/rsa/pss.go
+++ b/src/pkg/crypto/rsa/pss.go
@@ -222,6 +222,17 @@ type PSSOptions struct {
 	// signature. It can either be a number of bytes, or one of the special
 	// PSSSaltLength constants.
 	SaltLength int
+
+	// Hash, if not zero, overrides the hash function passed to SignPSS.
+	// This is the only way to specify the hash function when using the
+	// crypto.Signer interface.
+	Hash crypto.Hash
+}
+
+// HashFunc returns pssOpts.Hash so that PSSOptions implements
+// crypto.SignerOpts.
+func (pssOpts *PSSOptions) HashFunc() crypto.Hash {
+	return pssOpts.Hash
 }
 
 func (opts *PSSOptions) saltLength() int {
@@ -244,6 +255,10 @@ func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte,
 		saltLength = hash.Size()
 	}
 
+	if opts.Hash != 0 {
+		hash = opts.Hash
+	}
+
 	salt := make([]byte, saltLength)
 	if _, err = io.ReadFull(rand, salt); err != nil {
 		return
diff --git a/src/pkg/crypto/rsa/rsa.go b/src/pkg/crypto/rsa/rsa.go
index bce6ba4eba..2702311281 100644
--- a/src/pkg/crypto/rsa/rsa.go
+++ b/src/pkg/crypto/rsa/rsa.go
@@ -6,6 +6,7 @@
 package rsa
 
 import (
+	"crypto"
 	"crypto/rand"
 	"crypto/subtle"
 	"errors"
@@ -58,6 +59,24 @@ type PrivateKey struct {
 	Precomputed PrecomputedValues
 }
 
+// Public returns the public key corresponding to priv.
+func (priv *PrivateKey) Public() crypto.PublicKey {
+	return &priv.PublicKey
+}
+
+// Sign signs msg with priv, reading randomness from rand. If opts is a
+// *PSSOptions then the PSS algorithm will be used, otherwise PKCS#1 v1.5 will
+// be used. This method is intended to support keys where the private part is
+// kept in, for example, a hardware module. Common uses should use the Sign*
+// functions in this package.
+func (priv *PrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.SignerOpts) ([]byte, error) {
+	if pssOpts, ok := opts.(*PSSOptions); ok {
+		return SignPSS(rand, priv, pssOpts.Hash, msg, pssOpts)
+	}
+
+	return SignPKCS1v15(rand, priv, opts.HashFunc(), msg)
+}
+
 type PrecomputedValues struct {
 	Dp, Dq *big.Int // D mod (P-1) (or mod Q-1)
 	Qinv   *big.Int // Q^-1 mod P
diff --git a/src/pkg/crypto/tls/common.go b/src/pkg/crypto/tls/common.go
index f926d57728..776b70c93c 100644
--- a/src/pkg/crypto/tls/common.go
+++ b/src/pkg/crypto/tls/common.go
@@ -487,7 +487,12 @@ func (c *Config) BuildNameToCertificate() {
 // A Certificate is a chain of one or more certificates, leaf first.
 type Certificate struct {
 	Certificate [][]byte
-	PrivateKey  crypto.PrivateKey // supported types: *rsa.PrivateKey, *ecdsa.PrivateKey
+	// PrivateKey contains the private key corresponding to the public key
+	// in Leaf. For a server, this must be a *rsa.PrivateKey or
+	// *ecdsa.PrivateKey. For a client doing client authentication, this
+	// can be any type that implements crypto.Signer (which includes RSA
+	// and ECDSA private keys).
+	PrivateKey crypto.PrivateKey
 	// OCSPStaple contains an optional OCSP response which will be served
 	// to clients that request it.
 	OCSPStaple []byte
diff --git a/src/pkg/crypto/tls/handshake_client.go b/src/pkg/crypto/tls/handshake_client.go
index 3d9ef9b14e..7f662e9c9f 100644
--- a/src/pkg/crypto/tls/handshake_client.go
+++ b/src/pkg/crypto/tls/handshake_client.go
@@ -6,11 +6,11 @@ package tls
 
 import (
 	"bytes"
+	"crypto"
 	"crypto/ecdsa"
 	"crypto/rsa"
 	"crypto/subtle"
 	"crypto/x509"
-	"encoding/asn1"
 	"errors"
 	"fmt"
 	"io"
@@ -345,8 +345,8 @@ func (hs *clientHandshakeState) doFullHandshake() error {
 		}
 
 		// We need to search our list of client certs for one
-		// where SignatureAlgorithm is RSA and the Issuer is in
-		// certReq.certificateAuthorities
+		// where SignatureAlgorithm is acceptable to the server and the
+		// Issuer is in certReq.certificateAuthorities
 	findCert:
 		for i, chain := range c.config.Certificates {
 			if !rsaAvail && !ecdsaAvail {
@@ -373,7 +373,7 @@ func (hs *clientHandshakeState) doFullHandshake() error {
 
 				if len(certReq.certificateAuthorities) == 0 {
 					// they gave us an empty list, so just take the
-					// first RSA cert from c.config.Certificates
+					// first cert from c.config.Certificates
 					chainToSend = &chain
 					break findCert
 				}
@@ -428,22 +428,24 @@ func (hs *clientHandshakeState) doFullHandshake() error {
 			hasSignatureAndHash: c.vers >= VersionTLS12,
 		}
 
-		switch key := c.config.Certificates[0].PrivateKey.(type) {
-		case *ecdsa.PrivateKey:
-			digest, _, hashId := hs.finishedHash.hashForClientCertificate(signatureECDSA)
-			r, s, err := ecdsa.Sign(c.config.rand(), key, digest)
-			if err == nil {
-				signed, err = asn1.Marshal(ecdsaSignature{r, s})
-			}
+		key, ok := chainToSend.PrivateKey.(crypto.Signer)
+		if !ok {
+			c.sendAlert(alertInternalError)
+			return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
+		}
+		switch key.Public().(type) {
+		case *ecdsa.PublicKey:
+			digest, hashFunc, hashId := hs.finishedHash.hashForClientCertificate(signatureECDSA)
+			signed, err = key.Sign(c.config.rand(), digest, hashFunc)
 			certVerify.signatureAndHash.signature = signatureECDSA
 			certVerify.signatureAndHash.hash = hashId
-		case *rsa.PrivateKey:
+		case *rsa.PublicKey:
 			digest, hashFunc, hashId := hs.finishedHash.hashForClientCertificate(signatureRSA)
-			signed, err = rsa.SignPKCS1v15(c.config.rand(), key, hashFunc, digest)
+			signed, err = key.Sign(c.config.rand(), digest, hashFunc)
 			certVerify.signatureAndHash.signature = signatureRSA
 			certVerify.signatureAndHash.hash = hashId
 		default:
-			err = errors.New("unknown private key type")
+			err = fmt.Errorf("tls: unknown client certificate key type: %T", key)
 		}
 		if err != nil {
 			c.sendAlert(alertInternalError)
diff --git a/src/pkg/go/build/deps_test.go b/src/pkg/go/build/deps_test.go
index 2a7173ba4c..b74595ea83 100644
--- a/src/pkg/go/build/deps_test.go
+++ b/src/pkg/go/build/deps_test.go
@@ -284,7 +284,7 @@ var pkgDeps = map[string][]string{
 	// Mathematical crypto: dependencies on fmt (L4) and math/big.
 	// We could avoid some of the fmt, but math/big imports fmt anyway.
 	"crypto/dsa":      {"L4", "CRYPTO", "math/big"},
-	"crypto/ecdsa":    {"L4", "CRYPTO", "crypto/elliptic", "math/big"},
+	"crypto/ecdsa":    {"L4", "CRYPTO", "crypto/elliptic", "math/big", "encoding/asn1"},
 	"crypto/elliptic": {"L4", "CRYPTO", "math/big"},
 	"crypto/rsa":      {"L4", "CRYPTO", "crypto/rand", "math/big"},
 

From 9a75c748367c2ff84de355b136c33760a6b6928a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Aug 2014 16:00:31 -0400
Subject: [PATCH 290/423] runtime: include constants and defs_*_*.h types in
 generated Go defs

I had to rename Kevent and Sigaction to avoid the functions of the
same (lowercase) name.

LGTM=iant, r
R=golang-codereviews, r, iant, aram.h
CC=dvyukov, golang-codereviews, khr
https://golang.org/cl/140740043
---
 src/cmd/cc/godefs.c                    |  4 ++--
 src/cmd/dist/buildruntime.c            | 21 ++++++++++++++++++---
 src/pkg/runtime/defs.c                 |  1 +
 src/pkg/runtime/defs_darwin_386.h      |  8 ++++----
 src/pkg/runtime/defs_darwin_amd64.h    |  8 ++++----
 src/pkg/runtime/defs_dragonfly_386.h   |  4 ++--
 src/pkg/runtime/defs_dragonfly_amd64.h |  4 ++--
 src/pkg/runtime/defs_freebsd_386.h     |  4 ++--
 src/pkg/runtime/defs_freebsd_amd64.h   |  4 ++--
 src/pkg/runtime/defs_freebsd_arm.h     |  4 ++--
 src/pkg/runtime/defs_linux_386.h       |  4 ++--
 src/pkg/runtime/defs_linux_amd64.h     |  4 ++--
 src/pkg/runtime/defs_linux_arm.h       |  4 ++--
 src/pkg/runtime/defs_netbsd_386.h      |  4 ++--
 src/pkg/runtime/defs_netbsd_amd64.h    |  4 ++--
 src/pkg/runtime/defs_netbsd_arm.h      |  4 ++--
 src/pkg/runtime/defs_openbsd_386.h     |  4 ++--
 src/pkg/runtime/defs_openbsd_amd64.h   |  4 ++--
 src/pkg/runtime/defs_solaris_amd64.h   |  4 ++--
 src/pkg/runtime/malloc.go              | 16 +++++++---------
 src/pkg/runtime/netpoll_kqueue.c       |  6 +++---
 src/pkg/runtime/os_darwin.c            |  4 ++--
 src/pkg/runtime/os_darwin.h            |  4 ++--
 src/pkg/runtime/os_dragonfly.c         |  6 +++---
 src/pkg/runtime/os_freebsd.c           |  6 +++---
 src/pkg/runtime/os_linux.c             |  4 ++--
 src/pkg/runtime/os_linux.h             |  4 ++--
 src/pkg/runtime/os_netbsd.c            |  6 +++---
 src/pkg/runtime/os_openbsd.c           |  6 +++---
 src/pkg/runtime/os_solaris.c           |  6 +++---
 src/pkg/runtime/os_solaris.h           |  2 +-
 31 files changed, 91 insertions(+), 77 deletions(-)

diff --git a/src/cmd/cc/godefs.c b/src/cmd/cc/godefs.c
index 1f2a9d7e04..d3ab52fde4 100644
--- a/src/cmd/cc/godefs.c
+++ b/src/cmd/cc/godefs.c
@@ -317,9 +317,9 @@ godefvar(Sym *s)
 	switch(t->etype) {
 	case TENUM:
 		if(!typefd[t->etype])
-			Bprint(&outbuf, "const %U = %lld\n", s->name, s->vconst);
+			Bprint(&outbuf, "const %s = %lld\n", s->name, s->vconst);
 		else
-			Bprint(&outbuf, "const %U = %f\n;", s->name, s->fconst);
+			Bprint(&outbuf, "const %s = %f\n;", s->name, s->fconst);
 		break;
 
 	case TFUNC:
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index 5daa31494b..2396e20c56 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -346,6 +346,10 @@ mkzruntimedefs(char *dir, char *file)
 		"\n"
 	);
 
+	// Do not emit constant definitions for these.
+	vadd(&seen, "true");
+	vadd(&seen, "false");
+	vadd(&seen, "raceenabled");
 	
 	// Run 6c -D GOOS_goos -D GOARCH_goarch -I workdir -q -n -o workdir/runtimedefs
 	// on each of the runtimedefs C files.
@@ -375,15 +379,15 @@ mkzruntimedefs(char *dir, char *file)
 	splitlines(&lines, bstr(&in));
 	for(i=0; i<lines.len; i++) {
 		p = lines.p[i];
-		// Drop comment, func, and const lines.
-		if(hasprefix(p, "//") || hasprefix(p, "const") || hasprefix(p, "func"))
+		// Drop comment and func lines.
+		if(hasprefix(p, "//") || hasprefix(p, "func"))
 			continue;
 		
 		// Note beginning of type or var decl, which can be multiline.
 		// Remove duplicates.  The linear check of seen here makes the
 		// whole processing quadratic in aggregate, but there are only
 		// about 100 declarations, so this is okay (and simple).
-		if(hasprefix(p, "type ") || hasprefix(p, "var ")) {
+		if(hasprefix(p, "type ") || hasprefix(p, "var ") || hasprefix(p, "const ")) {
 			splitfields(&fields, p);
 			if(fields.len < 2)
 				continue;
@@ -394,6 +398,17 @@ mkzruntimedefs(char *dir, char *file)
 			}
 			vadd(&seen, fields.p[1]);
 		}
+
+		// Const lines are printed in original case (usually upper). Add a leading _ as needed.
+		if(hasprefix(p, "const ")) {
+			if('A' <= p[6] && p[6] <= 'Z')
+				bwritestr(&out, "const _");
+			else
+				bwritestr(&out, "const ");
+			bwritestr(&out, p+6);
+			continue;
+		}
+
 		if(skip) {
 			if(hasprefix(p, "}"))
 				skip = 0;
diff --git a/src/pkg/runtime/defs.c b/src/pkg/runtime/defs.c
index 7563344578..b6ed9c8115 100644
--- a/src/pkg/runtime/defs.c
+++ b/src/pkg/runtime/defs.c
@@ -12,3 +12,4 @@
 #include "race.h"
 #include "chan.h"
 #include "mprof.h"
+#include "defs_GOOS_GOARCH.h"
diff --git a/src/pkg/runtime/defs_darwin_386.h b/src/pkg/runtime/defs_darwin_386.h
index 7b210eebf8..0e0b4fbf79 100644
--- a/src/pkg/runtime/defs_darwin_386.h
+++ b/src/pkg/runtime/defs_darwin_386.h
@@ -124,7 +124,7 @@ typedef struct MachHeader MachHeader;
 typedef struct MachNDR MachNDR;
 typedef struct MachPort MachPort;
 typedef struct StackT StackT;
-typedef struct Sigaction Sigaction;
+typedef struct SigactionT SigactionT;
 typedef struct Siginfo Siginfo;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
@@ -142,7 +142,7 @@ typedef struct FloatState32 FloatState32;
 typedef struct ExceptionState32 ExceptionState32;
 typedef struct Mcontext32 Mcontext32;
 typedef struct Ucontext Ucontext;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -182,7 +182,7 @@ struct StackT {
 };
 typedef	byte	Sighandler[4];
 
-struct Sigaction {
+struct SigactionT {
 	byte	__sigaction_u[4];
 	void	*sa_tramp;
 	uint32	sa_mask;
@@ -379,7 +379,7 @@ struct Ucontext {
 	Mcontext32	*uc_mcontext;
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_darwin_amd64.h b/src/pkg/runtime/defs_darwin_amd64.h
index 2d464a9e50..4bf83c1cb9 100644
--- a/src/pkg/runtime/defs_darwin_amd64.h
+++ b/src/pkg/runtime/defs_darwin_amd64.h
@@ -124,7 +124,7 @@ typedef struct MachHeader MachHeader;
 typedef struct MachNDR MachNDR;
 typedef struct MachPort MachPort;
 typedef struct StackT StackT;
-typedef struct Sigaction Sigaction;
+typedef struct SigactionT SigactionT;
 typedef struct Siginfo Siginfo;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
@@ -142,7 +142,7 @@ typedef struct FloatState32 FloatState32;
 typedef struct ExceptionState32 ExceptionState32;
 typedef struct Mcontext32 Mcontext32;
 typedef struct Ucontext Ucontext;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -183,7 +183,7 @@ struct StackT {
 };
 typedef	byte	Sighandler[8];
 
-struct Sigaction {
+struct SigactionT {
 	byte	__sigaction_u[8];
 	void	*sa_tramp;
 	uint32	sa_mask;
@@ -382,7 +382,7 @@ struct Ucontext {
 	Mcontext64	*uc_mcontext;
 };
 
-struct Kevent {
+struct KeventT {
 	uint64	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_dragonfly_386.h b/src/pkg/runtime/defs_dragonfly_386.h
index 696dcd887d..032b23574e 100644
--- a/src/pkg/runtime/defs_dragonfly_386.h
+++ b/src/pkg/runtime/defs_dragonfly_386.h
@@ -94,7 +94,7 @@ typedef struct Ucontext Ucontext;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -185,7 +185,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_dragonfly_amd64.h b/src/pkg/runtime/defs_dragonfly_amd64.h
index 74581cc94c..c37a72e729 100644
--- a/src/pkg/runtime/defs_dragonfly_amd64.h
+++ b/src/pkg/runtime/defs_dragonfly_amd64.h
@@ -94,7 +94,7 @@ typedef struct Ucontext Ucontext;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -195,7 +195,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint64	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_freebsd_386.h b/src/pkg/runtime/defs_freebsd_386.h
index fab9385269..e625079bc7 100644
--- a/src/pkg/runtime/defs_freebsd_386.h
+++ b/src/pkg/runtime/defs_freebsd_386.h
@@ -98,7 +98,7 @@ typedef struct Ucontext Ucontext;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -200,7 +200,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_freebsd_amd64.h b/src/pkg/runtime/defs_freebsd_amd64.h
index c1db91803e..40476f9e4f 100644
--- a/src/pkg/runtime/defs_freebsd_amd64.h
+++ b/src/pkg/runtime/defs_freebsd_amd64.h
@@ -98,7 +98,7 @@ typedef struct Ucontext Ucontext;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -211,7 +211,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint64	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_freebsd_arm.h b/src/pkg/runtime/defs_freebsd_arm.h
index 4fc452e457..927d3a48b5 100644
--- a/src/pkg/runtime/defs_freebsd_arm.h
+++ b/src/pkg/runtime/defs_freebsd_arm.h
@@ -98,7 +98,7 @@ typedef struct Ucontext Ucontext;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -173,7 +173,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_linux_386.h b/src/pkg/runtime/defs_linux_386.h
index 27dae9e82b..2df3f66d80 100644
--- a/src/pkg/runtime/defs_linux_386.h
+++ b/src/pkg/runtime/defs_linux_386.h
@@ -95,7 +95,7 @@ typedef struct Xmmreg Xmmreg;
 typedef struct Fpstate Fpstate;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
-typedef struct Sigaction Sigaction;
+typedef struct SigactionT SigactionT;
 typedef struct Siginfo Siginfo;
 typedef struct Sigaltstack Sigaltstack;
 typedef struct Sigcontext Sigcontext;
@@ -144,7 +144,7 @@ struct Timeval {
 	int32	tv_sec;
 	int32	tv_usec;
 };
-struct Sigaction {
+struct SigactionT {
 	void	*k_sa_handler;
 	uint32	sa_flags;
 	void	*sa_restorer;
diff --git a/src/pkg/runtime/defs_linux_amd64.h b/src/pkg/runtime/defs_linux_amd64.h
index 3e87df68a1..42826c39ee 100644
--- a/src/pkg/runtime/defs_linux_amd64.h
+++ b/src/pkg/runtime/defs_linux_amd64.h
@@ -88,7 +88,7 @@ enum {
 
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
-typedef struct Sigaction Sigaction;
+typedef struct SigactionT SigactionT;
 typedef struct Siginfo Siginfo;
 typedef struct Itimerval Itimerval;
 typedef struct EpollEvent EpollEvent;
@@ -103,7 +103,7 @@ struct Timeval {
 	int64	tv_sec;
 	int64	tv_usec;
 };
-struct Sigaction {
+struct SigactionT {
 	void	*sa_handler;
 	uint64	sa_flags;
 	void	*sa_restorer;
diff --git a/src/pkg/runtime/defs_linux_arm.h b/src/pkg/runtime/defs_linux_arm.h
index 05a17af64b..8c17e3805b 100644
--- a/src/pkg/runtime/defs_linux_arm.h
+++ b/src/pkg/runtime/defs_linux_arm.h
@@ -151,8 +151,8 @@ struct Siginfo {
 	uint8 _sifields[4];
 };
 
-typedef struct Sigaction Sigaction;
-struct Sigaction {
+typedef struct SigactionT SigactionT;
+struct SigactionT {
 	void *sa_handler;
 	uint32 sa_flags;
 	void *sa_restorer;
diff --git a/src/pkg/runtime/defs_netbsd_386.h b/src/pkg/runtime/defs_netbsd_386.h
index 7fd66959f3..fb23611990 100644
--- a/src/pkg/runtime/defs_netbsd_386.h
+++ b/src/pkg/runtime/defs_netbsd_386.h
@@ -91,7 +91,7 @@ typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
 typedef struct McontextT McontextT;
 typedef struct UcontextT UcontextT;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -143,7 +143,7 @@ struct UcontextT {
 	int32	__uc_pad[4];
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	uint32	filter;
 	uint32	flags;
diff --git a/src/pkg/runtime/defs_netbsd_amd64.h b/src/pkg/runtime/defs_netbsd_amd64.h
index 972af165b7..f6ba3db189 100644
--- a/src/pkg/runtime/defs_netbsd_amd64.h
+++ b/src/pkg/runtime/defs_netbsd_amd64.h
@@ -91,7 +91,7 @@ typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
 typedef struct McontextT McontextT;
 typedef struct UcontextT UcontextT;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -147,7 +147,7 @@ struct UcontextT {
 	McontextT	uc_mcontext;
 };
 
-struct Kevent {
+struct KeventT {
 	uint64	ident;
 	uint32	filter;
 	uint32	flags;
diff --git a/src/pkg/runtime/defs_netbsd_arm.h b/src/pkg/runtime/defs_netbsd_arm.h
index c6f5b1c47c..815d54749b 100644
--- a/src/pkg/runtime/defs_netbsd_arm.h
+++ b/src/pkg/runtime/defs_netbsd_arm.h
@@ -91,7 +91,7 @@ typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
 typedef struct McontextT McontextT;
 typedef struct UcontextT UcontextT;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -147,7 +147,7 @@ struct UcontextT {
 	int32	__uc_pad[2];
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	uint32	filter;
 	uint32	flags;
diff --git a/src/pkg/runtime/defs_openbsd_386.h b/src/pkg/runtime/defs_openbsd_386.h
index b8f993e2b8..a63b182a04 100644
--- a/src/pkg/runtime/defs_openbsd_386.h
+++ b/src/pkg/runtime/defs_openbsd_386.h
@@ -89,7 +89,7 @@ typedef struct StackT StackT;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -155,7 +155,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint32	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_openbsd_amd64.h b/src/pkg/runtime/defs_openbsd_amd64.h
index a1ae2ef65c..818ac35207 100644
--- a/src/pkg/runtime/defs_openbsd_amd64.h
+++ b/src/pkg/runtime/defs_openbsd_amd64.h
@@ -89,7 +89,7 @@ typedef struct StackT StackT;
 typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct Itimerval Itimerval;
-typedef struct Kevent Kevent;
+typedef struct KeventT KeventT;
 
 #pragma pack on
 
@@ -166,7 +166,7 @@ struct Itimerval {
 	Timeval	it_value;
 };
 
-struct Kevent {
+struct KeventT {
 	uint64	ident;
 	int16	filter;
 	uint16	flags;
diff --git a/src/pkg/runtime/defs_solaris_amd64.h b/src/pkg/runtime/defs_solaris_amd64.h
index 799724fadc..08727b017e 100644
--- a/src/pkg/runtime/defs_solaris_amd64.h
+++ b/src/pkg/runtime/defs_solaris_amd64.h
@@ -105,7 +105,7 @@ typedef struct Sigaltstack Sigaltstack;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
-typedef struct Sigaction Sigaction;
+typedef struct SigactionT SigactionT;
 typedef struct Fpregset Fpregset;
 typedef struct Mcontext Mcontext;
 typedef struct Ucontext Ucontext;
@@ -149,7 +149,7 @@ struct Siginfo {
 	int32	si_pad;
 	byte	__data[240];
 };
-struct Sigaction {
+struct SigactionT {
 	int32	sa_flags;
 	byte	Pad_cgo_0[4];
 	byte	_funcptr[8];
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index e95bdbbf97..49afc67364 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -22,15 +22,13 @@ const (
 	pageSize  = 1 << pageShift
 	pageMask  = pageSize - 1
 
-	gcBits             = 4
-	wordsPerBitmapByte = 8 / gcBits
-	bitsPerPointer     = 2
-	bitsMask           = 1<<bitsPerPointer - 1
-	pointersPerByte    = 8 / bitsPerPointer
-	bitPtrMask         = bitsMask << 2
-	maxGCMask          = 64
-	bitsDead           = 0
-	bitsPointer        = 2
+	bitsPerPointer  = 2
+	bitsMask        = 1<<bitsPerPointer - 1
+	pointersPerByte = 8 / bitsPerPointer
+	bitPtrMask      = bitsMask << 2
+	maxGCMask       = 64
+	bitsDead        = 0
+	bitsPointer     = 2
 
 	bitBoundary = 1
 	bitMarked   = 2
diff --git a/src/pkg/runtime/netpoll_kqueue.c b/src/pkg/runtime/netpoll_kqueue.c
index 171346cce2..6b7fc869d3 100644
--- a/src/pkg/runtime/netpoll_kqueue.c
+++ b/src/pkg/runtime/netpoll_kqueue.c
@@ -11,7 +11,7 @@
 // Integrated network poller (kqueue-based implementation).
 
 int32	runtime·kqueue(void);
-int32	runtime·kevent(int32, Kevent*, int32, Kevent*, int32, Timespec*);
+int32	runtime·kevent(int32, KeventT*, int32, KeventT*, int32, Timespec*);
 void	runtime·closeonexec(int32);
 
 static int32 kq = -1;
@@ -30,7 +30,7 @@ runtime·netpollinit(void)
 int32
 runtime·netpollopen(uintptr fd, PollDesc *pd)
 {
-	Kevent ev[2];
+	KeventT ev[2];
 	int32 n;
 
 	// Arm both EVFILT_READ and EVFILT_WRITE in edge-triggered mode (EV_CLEAR)
@@ -72,7 +72,7 @@ G*
 runtime·netpoll(bool block)
 {
 	static int32 lasterr;
-	Kevent events[64], *ev;
+	KeventT events[64], *ev;
 	Timespec ts, *tp;
 	int32 n, i, mode;
 	G *gp;
diff --git a/src/pkg/runtime/os_darwin.c b/src/pkg/runtime/os_darwin.c
index c660fb8c10..bf13cdbafe 100644
--- a/src/pkg/runtime/os_darwin.c
+++ b/src/pkg/runtime/os_darwin.c
@@ -488,7 +488,7 @@ runtime·memlimit(void)
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 		
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
@@ -503,7 +503,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	runtime·sigaction(i, nil, &sa);
diff --git a/src/pkg/runtime/os_darwin.h b/src/pkg/runtime/os_darwin.h
index 91a405f214..af9052e9c2 100644
--- a/src/pkg/runtime/os_darwin.h
+++ b/src/pkg/runtime/os_darwin.h
@@ -25,8 +25,8 @@ typedef uint32 Sigset;
 void	runtime·sigprocmask(int32, Sigset*, Sigset*);
 void	runtime·unblocksignals(void);
 
-struct Sigaction;
-void	runtime·sigaction(uintptr, struct Sigaction*, struct Sigaction*);
+struct SigactionT;
+void	runtime·sigaction(uintptr, struct SigactionT*, struct SigactionT*);
 
 struct StackT;
 void	runtime·sigaltstack(struct StackT*, struct StackT*);
diff --git a/src/pkg/runtime/os_dragonfly.c b/src/pkg/runtime/os_dragonfly.c
index 65121d3273..a2a88e4c80 100644
--- a/src/pkg/runtime/os_dragonfly.c
+++ b/src/pkg/runtime/os_dragonfly.c
@@ -240,12 +240,12 @@ typedef struct sigaction {
 	} __sigaction_u;		/* signal handler */
 	int32	sa_flags;		/* see signal options below */
 	Sigset	sa_mask;		/* signal mask to apply */
-} Sigaction;
+} SigactionT;
 
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
@@ -264,7 +264,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	runtime·sigaction(i, nil, &sa);
diff --git a/src/pkg/runtime/os_freebsd.c b/src/pkg/runtime/os_freebsd.c
index d360f6712d..ae959d90bb 100644
--- a/src/pkg/runtime/os_freebsd.c
+++ b/src/pkg/runtime/os_freebsd.c
@@ -248,12 +248,12 @@ typedef struct sigaction {
 	} __sigaction_u;		/* signal handler */
 	int32	sa_flags;		/* see signal options below */
 	Sigset	sa_mask;		/* signal mask to apply */
-} Sigaction;
+} SigactionT;
 
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
@@ -272,7 +272,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	runtime·sigaction(i, nil, &sa);
diff --git a/src/pkg/runtime/os_linux.c b/src/pkg/runtime/os_linux.c
index 33c7563743..d3677f2e6c 100644
--- a/src/pkg/runtime/os_linux.c
+++ b/src/pkg/runtime/os_linux.c
@@ -293,7 +293,7 @@ extern void runtime·sigreturn(void);	// calls rt_sigreturn, only used with SA_R
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTORER;
@@ -319,7 +319,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	if(runtime·rt_sigaction(i, nil, &sa, sizeof(sa.sa_mask)) != 0)
diff --git a/src/pkg/runtime/os_linux.h b/src/pkg/runtime/os_linux.h
index d4b1902c3a..84f516d50c 100644
--- a/src/pkg/runtime/os_linux.h
+++ b/src/pkg/runtime/os_linux.h
@@ -8,8 +8,8 @@
 int32	runtime·futex(uint32*, int32, uint32, Timespec*, uint32*, uint32);
 int32	runtime·clone(int32, void*, M*, G*, void(*)(void));
 
-struct Sigaction;
-int32	runtime·rt_sigaction(uintptr, struct Sigaction*, void*, uintptr);
+struct SigactionT;
+int32	runtime·rt_sigaction(uintptr, struct SigactionT*, void*, uintptr);
 
 void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
 void	runtime·sigpanic(void);
diff --git a/src/pkg/runtime/os_netbsd.c b/src/pkg/runtime/os_netbsd.c
index 0889181a81..8567146ed4 100644
--- a/src/pkg/runtime/os_netbsd.c
+++ b/src/pkg/runtime/os_netbsd.c
@@ -286,12 +286,12 @@ typedef struct sigaction {
 	} _sa_u;			/* signal handler */
 	uint32	sa_mask[4];		/* signal mask to apply */
 	int32	sa_flags;		/* see signal options below */
-} Sigaction;
+} SigactionT;
 
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
@@ -310,7 +310,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	runtime·sigaction(i, nil, &sa);
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index 60db7efdd9..a746385314 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -263,12 +263,12 @@ typedef struct sigaction {
 	} __sigaction_u;		/* signal handler */
 	uint32	sa_mask;		/* signal mask to apply */
 	int32	sa_flags;		/* see signal options below */
-} Sigaction;
+} SigactionT;
 
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
@@ -284,7 +284,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	runtime·sigaction(i, nil, &sa);
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index 0cdfd52c9b..42295aa754 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -267,7 +267,7 @@ extern void runtime·sigtramp(void);
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
@@ -286,7 +286,7 @@ runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 GoSighandler*
 runtime·getsig(int32 i)
 {
-	Sigaction sa;
+	SigactionT sa;
 
 	runtime·memclr((byte*)&sa, sizeof sa);
 	runtime·sigaction(i, nil, &sa);
@@ -530,7 +530,7 @@ runtime·setitimer(int32 which, Itimerval* value, Itimerval* ovalue)
 }
 
 /* int32 */ void
-runtime·sigaction(int32 sig, struct Sigaction* act, struct Sigaction* oact)
+runtime·sigaction(int32 sig, struct SigactionT* act, struct SigactionT* oact)
 {
 	runtime·sysvicall3(libc·sigaction, (uintptr)sig, (uintptr)act, (uintptr)oact);
 }
diff --git a/src/pkg/runtime/os_solaris.h b/src/pkg/runtime/os_solaris.h
index 355cdf5589..20a0027205 100644
--- a/src/pkg/runtime/os_solaris.h
+++ b/src/pkg/runtime/os_solaris.h
@@ -15,7 +15,7 @@ struct sigaction;
 void	runtime·sigpanic(void);
 
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
-void	runtime·sigaction(int32, struct Sigaction*, struct Sigaction*);
+void	runtime·sigaction(int32, struct SigactionT*, struct SigactionT*);
 void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
 void	runtime·sigprocmask(int32, Sigset*, Sigset*);
 void	runtime·unblocksignals(void);

From 3a7f6646cfdc19ca4f33efe48d33eb1731b49ca8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Aug 2014 16:20:48 -0400
Subject: [PATCH 291/423] runtime: convert lock*.c to Go

LGTM=r, iant
R=golang-codereviews, r, iant
CC=dvyukov, golang-codereviews, khr
https://golang.org/cl/139930043
---
 src/pkg/runtime/alg.go               |   4 +-
 src/pkg/runtime/asm_386.s            |   3 +
 src/pkg/runtime/asm_amd64.s          |   3 +
 src/pkg/runtime/asm_amd64p32.s       |   3 +
 src/pkg/runtime/asm_arm.s            |   3 +
 src/pkg/runtime/export_futex_test.go |   3 -
 src/pkg/runtime/export_test.go       |   1 -
 src/pkg/runtime/lock_futex.c         | 227 ---------------------
 src/pkg/runtime/lock_futex.go        | 205 +++++++++++++++++++
 src/pkg/runtime/lock_sema.c          | 295 ---------------------------
 src/pkg/runtime/lock_sema.go         | 264 ++++++++++++++++++++++++
 src/pkg/runtime/os_darwin.go         |   2 +
 src/pkg/runtime/os_dragonfly.go      |   2 +
 src/pkg/runtime/os_freebsd.go        |   2 +
 src/pkg/runtime/os_linux.go          |   2 +
 src/pkg/runtime/os_nacl.go           |   2 +
 src/pkg/runtime/os_netbsd.go         |   2 +
 src/pkg/runtime/os_openbsd.go        |   2 +
 src/pkg/runtime/os_plan9.go          |   4 +
 src/pkg/runtime/os_solaris.go        |   2 +
 src/pkg/runtime/os_windows.go        |   2 +
 src/pkg/runtime/stack.go             | 105 ++++++++++
 src/pkg/runtime/stubs.go             |  23 +--
 23 files changed, 620 insertions(+), 541 deletions(-)
 delete mode 100644 src/pkg/runtime/lock_futex.c
 create mode 100644 src/pkg/runtime/lock_futex.go
 delete mode 100644 src/pkg/runtime/lock_sema.c
 create mode 100644 src/pkg/runtime/lock_sema.go
 create mode 100644 src/pkg/runtime/stack.go

diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index be6eaac230..909612454d 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -7,8 +7,8 @@ package runtime
 import "unsafe"
 
 const (
-	c0 = uintptr((8-uint64(ptrSize))/4*2860486313 + (uint64(ptrSize)-4)/4*33054211828000289)
-	c1 = uintptr((8-uint64(ptrSize))/4*3267000013 + (uint64(ptrSize)-4)/4*23344194077549503)
+	c0 = uintptr((8-ptrSize)/4*2860486313 + (ptrSize-4)/4*33054211828000289)
+	c1 = uintptr((8-ptrSize)/4*3267000013 + (ptrSize-4)/4*23344194077549503)
 )
 
 const (
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index e18d877895..b40b75521a 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -505,6 +505,9 @@ TEXT runtime·cas(SB), NOSPLIT, $0-13
 TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
 	JMP	runtime·cas(SB)
 
+TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-8
+	JMP	runtime·atomicload(SB)
+
 // bool runtime·cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
 //	if(*val == *old){
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 3dafc83708..01ec391153 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -624,6 +624,9 @@ cas64_fail:
 TEXT runtime·casuintptr(SB), NOSPLIT, $0-25
 	JMP	runtime·cas64(SB)
 
+TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-16
+	JMP	runtime·atomicload64(SB)
+
 // bool casp(void **val, void *old, void *new)
 // Atomically:
 //	if(*val == old){
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 0a5819b059..9073144cff 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -565,6 +565,9 @@ TEXT runtime·cas(SB), NOSPLIT, $0-17
 TEXT runtime·casuintptr(SB), NOSPLIT, $0-17
 	JMP	runtime·cas(SB)
 
+TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-12
+	JMP	runtime·atomicload(SB)
+
 // bool	runtime·cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
 //	if(*val == *old){
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index f7b90a692e..702eda61bd 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -693,6 +693,9 @@ casfail:
 TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
 	B	runtime·cas(SB)
 
+TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-8
+	B	runtime·atomicload(SB)
+
 TEXT runtime·stackguard(SB),NOSPLIT,$0-8
 	MOVW	R13, R1
 	MOVW	g_stackguard(g), R2
diff --git a/src/pkg/runtime/export_futex_test.go b/src/pkg/runtime/export_futex_test.go
index 1477828a7d..96281f6509 100644
--- a/src/pkg/runtime/export_futex_test.go
+++ b/src/pkg/runtime/export_futex_test.go
@@ -6,8 +6,5 @@
 
 package runtime
 
-func futexsleep(addr *uint32, val uint32, ns int64)
-func futexwakeup(addr *uint32, val uint32)
-
 var Futexsleep = futexsleep
 var Futexwakeup = futexwakeup
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 3068fa34ba..5579449c4f 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -18,7 +18,6 @@ var Fcmp64 = fcmp64
 var Fintto64 = fintto64
 var F64toint = f64toint
 
-func entersyscall()
 func lockedOSThread() bool
 func stackguard() (sp, limit uintptr)
 
diff --git a/src/pkg/runtime/lock_futex.c b/src/pkg/runtime/lock_futex.c
deleted file mode 100644
index a0fe102cc2..0000000000
--- a/src/pkg/runtime/lock_futex.c
+++ /dev/null
@@ -1,227 +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.
-
-// +build dragonfly freebsd linux
-
-#include "runtime.h"
-#include "stack.h"
-#include "../../cmd/ld/textflag.h"
-
-// This implementation depends on OS-specific implementations of
-//
-//	runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
-//		Atomically,
-//			if(*addr == val) sleep
-//		Might be woken up spuriously; that's allowed.
-//		Don't sleep longer than ns; ns < 0 means forever.
-//
-//	runtime·futexwakeup(uint32 *addr, uint32 cnt)
-//		If any procs are sleeping on addr, wake up at most cnt.
-
-enum
-{
-	MUTEX_UNLOCKED = 0,
-	MUTEX_LOCKED = 1,
-	MUTEX_SLEEPING = 2,
-
-	ACTIVE_SPIN = 4,
-	ACTIVE_SPIN_CNT = 30,
-	PASSIVE_SPIN = 1,
-};
-
-// Possible lock states are MUTEX_UNLOCKED, MUTEX_LOCKED and MUTEX_SLEEPING.
-// MUTEX_SLEEPING means that there is presumably at least one sleeping thread.
-// Note that there can be spinning threads during all states - they do not
-// affect mutex's state.
-void
-runtime·lock(Mutex *l)
-{
-	uint32 i, v, wait, spin;
-
-	if(g->m->locks++ < 0)
-		runtime·throw("runtime·lock: lock count");
-
-	// Speculative grab for lock.
-	v = runtime·xchg((uint32*)&l->key, MUTEX_LOCKED);
-	if(v == MUTEX_UNLOCKED)
-		return;
-
-	// wait is either MUTEX_LOCKED or MUTEX_SLEEPING
-	// depending on whether there is a thread sleeping
-	// on this mutex.  If we ever change l->key from
-	// MUTEX_SLEEPING to some other value, we must be
-	// careful to change it back to MUTEX_SLEEPING before
-	// returning, to ensure that the sleeping thread gets
-	// its wakeup call.
-	wait = v;
-
-	// On uniprocessor's, no point spinning.
-	// On multiprocessors, spin for ACTIVE_SPIN attempts.
-	spin = 0;
-	if(runtime·ncpu > 1)
-		spin = ACTIVE_SPIN;
-
-	for(;;) {
-		// Try for lock, spinning.
-		for(i = 0; i < spin; i++) {
-			while(l->key == MUTEX_UNLOCKED)
-				if(runtime·cas((uint32*)&l->key, MUTEX_UNLOCKED, wait))
-					return;
-			runtime·procyield(ACTIVE_SPIN_CNT);
-		}
-
-		// Try for lock, rescheduling.
-		for(i=0; i < PASSIVE_SPIN; i++) {
-			while(l->key == MUTEX_UNLOCKED)
-				if(runtime·cas((uint32*)&l->key, MUTEX_UNLOCKED, wait))
-					return;
-			runtime·osyield();
-		}
-
-		// Sleep.
-		v = runtime·xchg((uint32*)&l->key, MUTEX_SLEEPING);
-		if(v == MUTEX_UNLOCKED)
-			return;
-		wait = MUTEX_SLEEPING;
-		runtime·futexsleep((uint32*)&l->key, MUTEX_SLEEPING, -1);
-	}
-}
-
-void
-runtime·unlock(Mutex *l)
-{
-	uint32 v;
-
-	v = runtime·xchg((uint32*)&l->key, MUTEX_UNLOCKED);
-	if(v == MUTEX_UNLOCKED)
-		runtime·throw("unlock of unlocked lock");
-	if(v == MUTEX_SLEEPING)
-		runtime·futexwakeup((uint32*)&l->key, 1);
-
-	if(--g->m->locks < 0)
-		runtime·throw("runtime·unlock: lock count");
-	if(g->m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
-		g->stackguard0 = StackPreempt;
-}
-
-// One-time notifications.
-void
-runtime·noteclear(Note *n)
-{
-	n->key = 0;
-}
-
-void
-runtime·notewakeup(Note *n)
-{
-	uint32 old;
-
-	old = runtime·xchg((uint32*)&n->key, 1);
-	if(old != 0) {
-		runtime·printf("notewakeup - double wakeup (%d)\n", old);
-		runtime·throw("notewakeup - double wakeup");
-	}
-	runtime·futexwakeup((uint32*)&n->key, 1);
-}
-
-void
-runtime·notewakeup_m(void)
-{
-	Note *n;
-
-	n = g->m->ptrarg[0];
-	g->m->ptrarg[0] = nil;
-	runtime·notewakeup(n);
-}
-
-void
-runtime·notesleep(Note *n)
-{
-	if(g != g->m->g0)
-		runtime·throw("notesleep not on g0");
-	while(runtime·atomicload((uint32*)&n->key) == 0) {
-		g->m->blocked = true;
-		runtime·futexsleep((uint32*)&n->key, 0, -1);
-		g->m->blocked = false;
-	}
-}
-
-#pragma textflag NOSPLIT
-static bool
-notetsleep(Note *n, int64 ns, int64 deadline, int64 now)
-{
-	// Conceptually, deadline and now are local variables.
-	// They are passed as arguments so that the space for them
-	// does not count against our nosplit stack sequence.
-
-	if(ns < 0) {
-		while(runtime·atomicload((uint32*)&n->key) == 0) {
-			g->m->blocked = true;
-			runtime·futexsleep((uint32*)&n->key, 0, -1);
-			g->m->blocked = false;
-		}
-		return true;
-	}
-
-	if(runtime·atomicload((uint32*)&n->key) != 0)
-		return true;
-
-	deadline = runtime·nanotime() + ns;
-	for(;;) {
-		g->m->blocked = true;
-		runtime·futexsleep((uint32*)&n->key, 0, ns);
-		g->m->blocked = false;
-		if(runtime·atomicload((uint32*)&n->key) != 0)
-			break;
-		now = runtime·nanotime();
-		if(now >= deadline)
-			break;
-		ns = deadline - now;
-	}
-	return runtime·atomicload((uint32*)&n->key) != 0;
-}
-
-bool
-runtime·notetsleep(Note *n, int64 ns)
-{
-	bool res;
-
-	if(g != g->m->g0 && !g->m->gcing)
-		runtime·throw("notetsleep not on g0");
-
-	res = notetsleep(n, ns, 0, 0);
-	return res;
-}
-
-// same as runtime·notetsleep, but called on user g (not g0)
-// calls only nosplit functions between entersyscallblock/exitsyscall
-bool
-runtime·notetsleepg(Note *n, int64 ns)
-{
-	bool res;
-
-	if(g == g->m->g0)
-		runtime·throw("notetsleepg on g0");
-
-	runtime·entersyscallblock();
-	res = notetsleep(n, ns, 0, 0);
-	runtime·exitsyscall();
-	return res;
-}
-
-void
-runtime·notetsleepg_m(void)
-{
-	Note *n;
-	int64 ns;
-
-	n = g->m->ptrarg[0];
-	g->m->ptrarg[0] = nil;
-	ns = g->m->scalararg[0] + ((int64)g->m->scalararg[1] << 32);
-
-	runtime·entersyscallblock_m();
-	notetsleep(n, ns, 0, 0);
-	// caller will call exitsyscall on g stack
-	runtime·gogo(&g->m->curg->sched);
-}
diff --git a/src/pkg/runtime/lock_futex.go b/src/pkg/runtime/lock_futex.go
new file mode 100644
index 0000000000..725962341d
--- /dev/null
+++ b/src/pkg/runtime/lock_futex.go
@@ -0,0 +1,205 @@
+// 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.
+
+// +build dragonfly freebsd linux
+
+package runtime
+
+import "unsafe"
+
+// This implementation depends on OS-specific implementations of
+//
+//	runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
+//		Atomically,
+//			if(*addr == val) sleep
+//		Might be woken up spuriously; that's allowed.
+//		Don't sleep longer than ns; ns < 0 means forever.
+//
+//	runtime·futexwakeup(uint32 *addr, uint32 cnt)
+//		If any procs are sleeping on addr, wake up at most cnt.
+
+const (
+	mutex_unlocked = 0
+	mutex_locked   = 1
+	mutex_sleeping = 2
+
+	active_spin     = 4
+	active_spin_cnt = 30
+	passive_spin    = 1
+)
+
+// Possible lock states are mutex_unlocked, mutex_locked and mutex_sleeping.
+// mutex_sleeping means that there is presumably at least one sleeping thread.
+// Note that there can be spinning threads during all states - they do not
+// affect mutex's state.
+
+func futexsleep(addr *uint32, val uint32, ns int64)
+func futexwakeup(addr *uint32, cnt uint32)
+
+// We use the uintptr mutex.key and note.key as a uint32.
+func key32(p *uintptr) *uint32 {
+	return (*uint32)(unsafe.Pointer(p))
+}
+
+func lock(l *mutex) {
+	gp := getg()
+
+	if gp.m.locks < 0 {
+		gothrow("runtime·lock: lock count")
+	}
+	gp.m.locks++
+
+	// Speculative grab for lock.
+	v := xchg(key32(&l.key), mutex_locked)
+	if v == mutex_unlocked {
+		return
+	}
+
+	// wait is either MUTEX_LOCKED or MUTEX_SLEEPING
+	// depending on whether there is a thread sleeping
+	// on this mutex.  If we ever change l->key from
+	// MUTEX_SLEEPING to some other value, we must be
+	// careful to change it back to MUTEX_SLEEPING before
+	// returning, to ensure that the sleeping thread gets
+	// its wakeup call.
+	wait := v
+
+	// On uniprocessors, no point spinning.
+	// On multiprocessors, spin for ACTIVE_SPIN attempts.
+	spin := 0
+	if ncpu > 1 {
+		spin = active_spin
+	}
+	for {
+		// Try for lock, spinning.
+		for i := 0; i < spin; i++ {
+			for l.key == mutex_unlocked {
+				if cas(key32(&l.key), mutex_unlocked, wait) {
+					return
+				}
+			}
+			procyield(active_spin_cnt)
+		}
+
+		// Try for lock, rescheduling.
+		for i := 0; i < passive_spin; i++ {
+			for l.key == mutex_unlocked {
+				if cas(key32(&l.key), mutex_unlocked, wait) {
+					return
+				}
+			}
+			osyield()
+		}
+
+		// Sleep.
+		v = xchg(key32(&l.key), mutex_sleeping)
+		if v == mutex_unlocked {
+			return
+		}
+		wait = mutex_sleeping
+		futexsleep(key32(&l.key), mutex_sleeping, -1)
+	}
+}
+
+func unlock(l *mutex) {
+	v := xchg(key32(&l.key), mutex_unlocked)
+	if v == mutex_unlocked {
+		gothrow("unlock of unlocked lock")
+	}
+	if v == mutex_sleeping {
+		futexwakeup(key32(&l.key), 1)
+	}
+
+	gp := getg()
+	gp.m.locks--
+	if gp.m.locks < 0 {
+		gothrow("runtime·unlock: lock count")
+	}
+	if gp.m.locks == 0 && gp.preempt { // restore the preemption request in case we've cleared it in newstack
+		gp.stackguard0 = stackPreempt
+	}
+}
+
+// One-time notifications.
+func noteclear(n *note) {
+	n.key = 0
+}
+
+func notewakeup(n *note) {
+	old := xchg(key32(&n.key), 1)
+	if old != 0 {
+		print("notewakeup - double wakeup (", old, ")\n")
+		gothrow("notewakeup - double wakeup")
+	}
+	futexwakeup(key32(&n.key), 1)
+}
+
+func notesleep(n *note) {
+	gp := getg()
+	if gp != gp.m.g0 {
+		gothrow("notesleep not on g0")
+	}
+	for atomicload(key32(&n.key)) == 0 {
+		gp.m.blocked = true
+		futexsleep(key32(&n.key), 0, -1)
+		gp.m.blocked = false
+	}
+}
+
+//go:nosplit
+func notetsleep_internal(n *note, ns int64) bool {
+	gp := getg()
+
+	if ns < 0 {
+		for atomicload(key32(&n.key)) == 0 {
+			gp.m.blocked = true
+			futexsleep(key32(&n.key), 0, -1)
+			gp.m.blocked = false
+		}
+		return true
+	}
+
+	if atomicload(key32(&n.key)) != 0 {
+		return true
+	}
+
+	deadline := nanotime() + ns
+	for {
+		gp.m.blocked = true
+		futexsleep(key32(&n.key), 0, ns)
+		gp.m.blocked = false
+		if atomicload(key32(&n.key)) != 0 {
+			break
+		}
+		now := nanotime()
+		if now >= deadline {
+			break
+		}
+		ns = deadline - now
+	}
+	return atomicload(key32(&n.key)) != 0
+}
+
+func notetsleep(n *note, ns int64) bool {
+	gp := getg()
+	if gp != gp.m.g0 && gp.m.gcing == 0 {
+		gothrow("notetsleep not on g0")
+	}
+
+	return notetsleep_internal(n, ns)
+}
+
+// same as runtime·notetsleep, but called on user g (not g0)
+// calls only nosplit functions between entersyscallblock/exitsyscall
+func notetsleepg(n *note, ns int64) bool {
+	gp := getg()
+	if gp == gp.m.g0 {
+		gothrow("notetsleepg on g0")
+	}
+
+	entersyscallblock()
+	ok := notetsleep_internal(n, ns)
+	exitsyscall()
+	return ok
+}
diff --git a/src/pkg/runtime/lock_sema.c b/src/pkg/runtime/lock_sema.c
deleted file mode 100644
index 71283493ed..0000000000
--- a/src/pkg/runtime/lock_sema.c
+++ /dev/null
@@ -1,295 +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.
-
-// +build darwin nacl netbsd openbsd plan9 solaris windows
-
-#include "runtime.h"
-#include "stack.h"
-#include "../../cmd/ld/textflag.h"
-
-// This implementation depends on OS-specific implementations of
-//
-//	uintptr runtime·semacreate(void)
-//		Create a semaphore, which will be assigned to m->waitsema.
-//		The zero value is treated as absence of any semaphore,
-//		so be sure to return a non-zero value.
-//
-//	int32 runtime·semasleep(int64 ns)
-//		If ns < 0, acquire m->waitsema and return 0.
-//		If ns >= 0, try to acquire m->waitsema for at most ns nanoseconds.
-//		Return 0 if the semaphore was acquired, -1 if interrupted or timed out.
-//
-//	int32 runtime·semawakeup(M *mp)
-//		Wake up mp, which is or will soon be sleeping on mp->waitsema.
-//
-
-enum
-{
-	LOCKED = 1,
-
-	ACTIVE_SPIN = 4,
-	ACTIVE_SPIN_CNT = 30,
-	PASSIVE_SPIN = 1,
-};
-
-void
-runtime·lock(Mutex *l)
-{
-	uintptr v;
-	uint32 i, spin;
-
-	if(g->m->locks++ < 0)
-		runtime·throw("runtime·lock: lock count");
-
-	// Speculative grab for lock.
-	if(runtime·casp((void**)&l->key, nil, (void*)LOCKED))
-		return;
-
-	if(g->m->waitsema == 0)
-		g->m->waitsema = runtime·semacreate();
-
-	// On uniprocessor's, no point spinning.
-	// On multiprocessors, spin for ACTIVE_SPIN attempts.
-	spin = 0;
-	if(runtime·ncpu > 1)
-		spin = ACTIVE_SPIN;
-
-	for(i=0;; i++) {
-		v = (uintptr)runtime·atomicloadp((void**)&l->key);
-		if((v&LOCKED) == 0) {
-unlocked:
-			if(runtime·casp((void**)&l->key, (void*)v, (void*)(v|LOCKED)))
-				return;
-			i = 0;
-		}
-		if(i<spin)
-			runtime·procyield(ACTIVE_SPIN_CNT);
-		else if(i<spin+PASSIVE_SPIN)
-			runtime·osyield();
-		else {
-			// Someone else has it.
-			// l->waitm points to a linked list of M's waiting
-			// for this lock, chained through m->nextwaitm.
-			// Queue this M.
-			for(;;) {
-				g->m->nextwaitm = (void*)(v&~LOCKED);
-				if(runtime·casp((void**)&l->key, (void*)v, (void*)((uintptr)g->m|LOCKED)))
-					break;
-				v = (uintptr)runtime·atomicloadp((void**)&l->key);
-				if((v&LOCKED) == 0)
-					goto unlocked;
-			}
-			if(v&LOCKED) {
-				// Queued.  Wait.
-				runtime·semasleep(-1);
-				i = 0;
-			}
-		}
-	}
-}
-
-void
-runtime·unlock(Mutex *l)
-{
-	uintptr v;
-	M *mp;
-
-	for(;;) {
-		v = (uintptr)runtime·atomicloadp((void**)&l->key);
-		if(v == LOCKED) {
-			if(runtime·casp((void**)&l->key, (void*)LOCKED, nil))
-				break;
-		} else {
-			// Other M's are waiting for the lock.
-			// Dequeue an M.
-			mp = (void*)(v&~LOCKED);
-			if(runtime·casp((void**)&l->key, (void*)v, mp->nextwaitm)) {
-				// Dequeued an M.  Wake it.
-				runtime·semawakeup(mp);
-				break;
-			}
-		}
-	}
-
-	if(--g->m->locks < 0)
-		runtime·throw("runtime·unlock: lock count");
-	if(g->m->locks == 0 && g->preempt)  // restore the preemption request in case we've cleared it in newstack
-		g->stackguard0 = StackPreempt;
-}
-
-// One-time notifications.
-void
-runtime·noteclear(Note *n)
-{
-	n->key = 0;
-}
-
-void
-runtime·notewakeup(Note *n)
-{
-	M *mp;
-
-	do
-		mp = runtime·atomicloadp((void**)&n->key);
-	while(!runtime·casp((void**)&n->key, mp, (void*)LOCKED));
-
-	// Successfully set waitm to LOCKED.
-	// What was it before?
-	if(mp == nil) {
-		// Nothing was waiting.  Done.
-	} else if(mp == (M*)LOCKED) {
-		// Two notewakeups!  Not allowed.
-		runtime·throw("notewakeup - double wakeup");
-	} else {
-		// Must be the waiting m.  Wake it up.
-		runtime·semawakeup(mp);
-	}
-}
-
-void
-runtime·notewakeup_m(void)
-{
-	Note *n;
-
-	n = g->m->ptrarg[0];
-	g->m->ptrarg[0] = nil;
-	runtime·notewakeup(n);
-}
-
-void
-runtime·notesleep(Note *n)
-{
-	if(g != g->m->g0)
-		runtime·throw("notesleep not on g0");
-
-	if(g->m->waitsema == 0)
-		g->m->waitsema = runtime·semacreate();
-	if(!runtime·casp((void**)&n->key, nil, g->m)) {  // must be LOCKED (got wakeup)
-		if(n->key != LOCKED)
-			runtime·throw("notesleep - waitm out of sync");
-		return;
-	}
-	// Queued.  Sleep.
-	g->m->blocked = true;
-	runtime·semasleep(-1);
-	g->m->blocked = false;
-}
-
-#pragma textflag NOSPLIT
-static bool
-notetsleep(Note *n, int64 ns, int64 deadline, M *mp)
-{
-	// Conceptually, deadline and mp are local variables.
-	// They are passed as arguments so that the space for them
-	// does not count against our nosplit stack sequence.
-
-	// Register for wakeup on n->waitm.
-	if(!runtime·casp((void**)&n->key, nil, g->m)) {  // must be LOCKED (got wakeup already)
-		if(n->key != LOCKED)
-			runtime·throw("notetsleep - waitm out of sync");
-		return true;
-	}
-
-	if(ns < 0) {
-		// Queued.  Sleep.
-		g->m->blocked = true;
-		runtime·semasleep(-1);
-		g->m->blocked = false;
-		return true;
-	}
-
-	deadline = runtime·nanotime() + ns;
-	for(;;) {
-		// Registered.  Sleep.
-		g->m->blocked = true;
-		if(runtime·semasleep(ns) >= 0) {
-			g->m->blocked = false;
-			// Acquired semaphore, semawakeup unregistered us.
-			// Done.
-			return true;
-		}
-		g->m->blocked = false;
-
-		// Interrupted or timed out.  Still registered.  Semaphore not acquired.
-		ns = deadline - runtime·nanotime();
-		if(ns <= 0)
-			break;
-		// Deadline hasn't arrived.  Keep sleeping.
-	}
-
-	// Deadline arrived.  Still registered.  Semaphore not acquired.
-	// Want to give up and return, but have to unregister first,
-	// so that any notewakeup racing with the return does not
-	// try to grant us the semaphore when we don't expect it.
-	for(;;) {
-		mp = runtime·atomicloadp((void**)&n->key);
-		if(mp == g->m) {
-			// No wakeup yet; unregister if possible.
-			if(runtime·casp((void**)&n->key, mp, nil))
-				return false;
-		} else if(mp == (M*)LOCKED) {
-			// Wakeup happened so semaphore is available.
-			// Grab it to avoid getting out of sync.
-			g->m->blocked = true;
-			if(runtime·semasleep(-1) < 0)
-				runtime·throw("runtime: unable to acquire - semaphore out of sync");
-			g->m->blocked = false;
-			return true;
-		} else
-			runtime·throw("runtime: unexpected waitm - semaphore out of sync");
-	}
-}
-
-bool
-runtime·notetsleep(Note *n, int64 ns)
-{
-	bool res;
-
-	if(g != g->m->g0 && !g->m->gcing)
-		runtime·throw("notetsleep not on g0");
-
-	if(g->m->waitsema == 0)
-		g->m->waitsema = runtime·semacreate();
-
-	res = notetsleep(n, ns, 0, nil);
-	return res;
-}
-
-// same as runtime·notetsleep, but called on user g (not g0)
-// calls only nosplit functions between entersyscallblock/exitsyscall
-bool
-runtime·notetsleepg(Note *n, int64 ns)
-{
-	bool res;
-
-	if(g == g->m->g0)
-		runtime·throw("notetsleepg on g0");
-
-	if(g->m->waitsema == 0)
-		g->m->waitsema = runtime·semacreate();
-
-	runtime·entersyscallblock();
-	res = notetsleep(n, ns, 0, nil);
-	runtime·exitsyscall();
-	return res;
-}
-
-void
-runtime·notetsleepg_m(void)
-{
-	Note *n;
-	int64 ns;
-
-	n = g->m->ptrarg[0];
-	g->m->ptrarg[0] = nil;
-	ns = g->m->scalararg[0] + ((int64)g->m->scalararg[1] << 32);
-
-	if(g->m->waitsema == 0)
-		g->m->waitsema = runtime·semacreate();
-
-	runtime·entersyscallblock_m();
-	notetsleep(n, ns, 0, nil);
-	// caller will call exitsyscall on g stack
-	runtime·gogo(&g->m->curg->sched);
-}
diff --git a/src/pkg/runtime/lock_sema.go b/src/pkg/runtime/lock_sema.go
new file mode 100644
index 0000000000..e0476f3291
--- /dev/null
+++ b/src/pkg/runtime/lock_sema.go
@@ -0,0 +1,264 @@
+// 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.
+
+// +build darwin nacl netbsd openbsd plan9 solaris windows
+
+package runtime
+
+import "unsafe"
+
+// This implementation depends on OS-specific implementations of
+//
+//	uintptr runtime·semacreate(void)
+//		Create a semaphore, which will be assigned to m->waitsema.
+//		The zero value is treated as absence of any semaphore,
+//		so be sure to return a non-zero value.
+//
+//	int32 runtime·semasleep(int64 ns)
+//		If ns < 0, acquire m->waitsema and return 0.
+//		If ns >= 0, try to acquire m->waitsema for at most ns nanoseconds.
+//		Return 0 if the semaphore was acquired, -1 if interrupted or timed out.
+//
+//	int32 runtime·semawakeup(M *mp)
+//		Wake up mp, which is or will soon be sleeping on mp->waitsema.
+//
+const (
+	locked uintptr = 1
+
+	active_spin     = 4
+	active_spin_cnt = 30
+	passive_spin    = 1
+)
+
+func semacreate() uintptr
+func semasleep(int64) int32
+func semawakeup(mp *m)
+
+func lock(l *mutex) {
+	gp := getg()
+	if gp.m.locks < 0 {
+		gothrow("runtime·lock: lock count")
+	}
+	gp.m.locks++
+
+	// Speculative grab for lock.
+	if casuintptr(&l.key, 0, locked) {
+		return
+	}
+	if gp.m.waitsema == 0 {
+		gp.m.waitsema = semacreate()
+	}
+
+	// On uniprocessor's, no point spinning.
+	// On multiprocessors, spin for ACTIVE_SPIN attempts.
+	spin := 0
+	if ncpu > 1 {
+		spin = active_spin
+	}
+Loop:
+	for i := 0; ; i++ {
+		v := atomicloaduintptr(&l.key)
+		if v&locked == 0 {
+			// Unlocked. Try to lock.
+			if casuintptr(&l.key, v, v|locked) {
+				return
+			}
+			i = 0
+		}
+		if i < spin {
+			procyield(active_spin_cnt)
+		} else if i < spin+passive_spin {
+			osyield()
+		} else {
+			// Someone else has it.
+			// l->waitm points to a linked list of M's waiting
+			// for this lock, chained through m->nextwaitm.
+			// Queue this M.
+			for {
+				gp.m.nextwaitm = (*m)((unsafe.Pointer)(v &^ locked))
+				if casuintptr(&l.key, v, uintptr(unsafe.Pointer(gp.m))|locked) {
+					break
+				}
+				v = atomicloaduintptr(&l.key)
+				if v&locked == 0 {
+					continue Loop
+				}
+			}
+			if v&locked != 0 {
+				// Queued.  Wait.
+				semasleep(-1)
+				i = 0
+			}
+		}
+	}
+}
+
+func unlock(l *mutex) {
+	gp := getg()
+	var mp *m
+	for {
+		v := atomicloaduintptr(&l.key)
+		if v == locked {
+			if casuintptr(&l.key, locked, 0) {
+				break
+			}
+		} else {
+			// Other M's are waiting for the lock.
+			// Dequeue an M.
+			mp = (*m)((unsafe.Pointer)(v &^ locked))
+			if casuintptr(&l.key, v, uintptr(unsafe.Pointer(mp.nextwaitm))) {
+				// Dequeued an M.  Wake it.
+				semawakeup(mp)
+				break
+			}
+		}
+	}
+	gp.m.locks--
+	if gp.m.locks < 0 {
+		gothrow("runtime·unlock: lock count")
+	}
+	if gp.m.locks == 0 && gp.preempt { // restore the preemption request in case we've cleared it in newstack
+		gp.stackguard0 = stackPreempt
+	}
+}
+
+// One-time notifications.
+func noteclear(n *note) {
+	n.key = 0
+}
+
+func notewakeup(n *note) {
+	var v uintptr
+	for {
+		v = atomicloaduintptr(&n.key)
+		if casuintptr(&n.key, v, locked) {
+			break
+		}
+	}
+
+	// Successfully set waitm to locked.
+	// What was it before?
+	switch {
+	case v == 0:
+		// Nothing was waiting. Done.
+	case v == locked:
+		// Two notewakeups!  Not allowed.
+		gothrow("notewakeup - double wakeup")
+	default:
+		// Must be the waiting m.  Wake it up.
+		semawakeup((*m)(unsafe.Pointer(v)))
+	}
+}
+
+func notesleep(n *note) {
+	gp := getg()
+	if gp != gp.m.g0 {
+		gothrow("notesleep not on g0")
+	}
+	if gp.m.waitsema == 0 {
+		gp.m.waitsema = semacreate()
+	}
+	if !casuintptr(&n.key, 0, uintptr(unsafe.Pointer(gp.m))) {
+		// Must be locked (got wakeup).
+		if n.key != locked {
+			gothrow("notesleep - waitm out of sync")
+		}
+		return
+	}
+	// Queued.  Sleep.
+	gp.m.blocked = true
+	semasleep(-1)
+	gp.m.blocked = false
+}
+
+//go:nosplit
+func notetsleep_internal(n *note, ns int64) bool {
+	gp := getg()
+	// Register for wakeup on n->waitm.
+	if !casuintptr(&n.key, 0, uintptr(unsafe.Pointer(gp.m))) {
+		// Must be locked (got wakeup).
+		if n.key != locked {
+			gothrow("notetsleep - waitm out of sync")
+		}
+		return true
+	}
+	if ns < 0 {
+		// Queued.  Sleep.
+		gp.m.blocked = true
+		semasleep(-1)
+		gp.m.blocked = false
+		return true
+	}
+	deadline := nanotime() + ns
+	for {
+		// Registered.  Sleep.
+		gp.m.blocked = true
+		if semasleep(ns) >= 0 {
+			gp.m.blocked = false
+			// Acquired semaphore, semawakeup unregistered us.
+			// Done.
+			return true
+		}
+		gp.m.blocked = false
+		// Interrupted or timed out.  Still registered.  Semaphore not acquired.
+		ns = deadline - nanotime()
+		if ns <= 0 {
+			break
+		}
+		// Deadline hasn't arrived.  Keep sleeping.
+	}
+
+	// Deadline arrived.  Still registered.  Semaphore not acquired.
+	// Want to give up and return, but have to unregister first,
+	// so that any notewakeup racing with the return does not
+	// try to grant us the semaphore when we don't expect it.
+	for {
+		v := atomicloaduintptr(&n.key)
+		switch v {
+		case uintptr(unsafe.Pointer(gp.m)):
+			// No wakeup yet; unregister if possible.
+			if casuintptr(&n.key, v, 0) {
+				return false
+			}
+		case locked:
+			// Wakeup happened so semaphore is available.
+			// Grab it to avoid getting out of sync.
+			gp.m.blocked = true
+			if semasleep(-1) < 0 {
+				gothrow("runtime: unable to acquire - semaphore out of sync")
+			}
+			gp.m.blocked = false
+			return true
+		default:
+			gothrow("runtime: unexpected waitm - semaphore out of sync")
+		}
+	}
+}
+
+func notetsleep(n *note, ns int64) bool {
+	gp := getg()
+	if gp != gp.m.g0 && gp.m.gcing == 0 {
+		gothrow("notetsleep not on g0")
+	}
+	if gp.m.waitsema == 0 {
+		gp.m.waitsema = semacreate()
+	}
+	return notetsleep_internal(n, ns)
+}
+
+// same as runtime·notetsleep, but called on user g (not g0)
+// calls only nosplit functions between entersyscallblock/exitsyscall
+func notetsleepg(n *note, ns int64) bool {
+	gp := getg()
+	if gp == gp.m.g0 {
+		gothrow("notetsleepg on g0")
+	}
+	if gp.m.waitsema == 0 {
+		gp.m.waitsema = semacreate()
+	}
+	entersyscallblock()
+	ok := notetsleep_internal(n, ns)
+	exitsyscall()
+	return ok
+}
diff --git a/src/pkg/runtime/os_darwin.go b/src/pkg/runtime/os_darwin.go
index 37ed55cf45..4eefec1f64 100644
--- a/src/pkg/runtime/os_darwin.go
+++ b/src/pkg/runtime/os_darwin.go
@@ -25,3 +25,5 @@ func mach_semaphore_wait(sema uint32) int32
 func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
 func mach_semaphore_signal(sema uint32) int32
 func mach_semaphore_signal_all(sema uint32) int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_dragonfly.go b/src/pkg/runtime/os_dragonfly.go
index ec7ddef533..3e7fc8d4ee 100644
--- a/src/pkg/runtime/os_dragonfly.go
+++ b/src/pkg/runtime/os_dragonfly.go
@@ -19,3 +19,5 @@ func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 i
 func closeonexec(fd int32)
 func sys_umtx_sleep(addr unsafe.Pointer, val, timeout int32) int32
 func sys_umtx_wakeup(addr unsafe.Pointer, val int32) int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_freebsd.go b/src/pkg/runtime/os_freebsd.go
index a973d3f76c..14d1b7ca9d 100644
--- a/src/pkg/runtime/os_freebsd.go
+++ b/src/pkg/runtime/os_freebsd.go
@@ -18,3 +18,5 @@ func kqueue() int32
 func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
 func closeonexec(fd int32)
 func sys_umtx_op(addr unsafe.Pointer, mode int32, val uint32, ptr2, ts unsafe.Pointer) int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_linux.go b/src/pkg/runtime/os_linux.go
index fc82382160..ba52a31e90 100644
--- a/src/pkg/runtime/os_linux.go
+++ b/src/pkg/runtime/os_linux.go
@@ -20,3 +20,5 @@ func epollctl(epfd, op, fd int32, ev unsafe.Pointer) int32
 func epollwait(epfd int32, ev unsafe.Pointer, nev, timeout int32) int32
 func closeonexec(fd int32)
 func sched_getaffinity(pid, len uintptr, buf *uintptr) int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_nacl.go b/src/pkg/runtime/os_nacl.go
index 5620c8f796..2ab51b8b1d 100644
--- a/src/pkg/runtime/os_nacl.go
+++ b/src/pkg/runtime/os_nacl.go
@@ -22,3 +22,5 @@ func nacl_cond_broadcast(cond int32) int32
 func nacl_cond_timed_wait_abs(cond, lock int32, ts unsafe.Pointer) int32
 func nacl_thread_create(fn, stk, tls, xx unsafe.Pointer) int32
 func nacl_nanosleep(ts, extra unsafe.Pointer) int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_netbsd.go b/src/pkg/runtime/os_netbsd.go
index 5cdf52211d..15607685e2 100644
--- a/src/pkg/runtime/os_netbsd.go
+++ b/src/pkg/runtime/os_netbsd.go
@@ -21,3 +21,5 @@ func lwp_create(ctxt unsafe.Pointer, flags uintptr, lwpid unsafe.Pointer) int32
 func lwp_park(abstime unsafe.Pointer, unpark int32, hint, unparkhint unsafe.Pointer) int32
 func lwp_unpark(lwp int32, hint unsafe.Pointer) int32
 func lwp_self() int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_openbsd.go b/src/pkg/runtime/os_openbsd.go
index 4982f903e3..681bdde82e 100644
--- a/src/pkg/runtime/os_openbsd.go
+++ b/src/pkg/runtime/os_openbsd.go
@@ -18,3 +18,5 @@ func closeonexec(fd int32)
 func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32
 func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
 func thrwakeup(ident unsafe.Pointer, n int32) int32
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_plan9.go b/src/pkg/runtime/os_plan9.go
index a50211a77b..7b215c754c 100644
--- a/src/pkg/runtime/os_plan9.go
+++ b/src/pkg/runtime/os_plan9.go
@@ -22,3 +22,7 @@ func nsec(*int64) int64
 func sigtramp(ureg, msg unsafe.Pointer)
 func setfpmasks()
 func errstr() string
+
+// The size of the note handler frame varies among architectures,
+// but 512 bytes should be enough for every implementation.
+const stackSystem = 512
diff --git a/src/pkg/runtime/os_solaris.go b/src/pkg/runtime/os_solaris.go
index 7bc42ef52d..556c1504bc 100644
--- a/src/pkg/runtime/os_solaris.go
+++ b/src/pkg/runtime/os_solaris.go
@@ -93,3 +93,5 @@ func sysvicall6(fn *libcFunc, a1, a2, a3, a4, a5, a6 uintptr) uintptr {
 	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall))
 	return libcall.r1
 }
+
+const stackSystem = 0
diff --git a/src/pkg/runtime/os_windows.go b/src/pkg/runtime/os_windows.go
index a1b9594318..57bd431f78 100644
--- a/src/pkg/runtime/os_windows.go
+++ b/src/pkg/runtime/os_windows.go
@@ -21,3 +21,5 @@ func asmstdcall(fn unsafe.Pointer)
 func getlasterror() uint32
 func setlasterror(err uint32)
 func usleep1(usec uint32)
+
+const stackSystem = 512 * ptrSize
diff --git a/src/pkg/runtime/stack.go b/src/pkg/runtime/stack.go
new file mode 100644
index 0000000000..ae7e96a005
--- /dev/null
+++ b/src/pkg/runtime/stack.go
@@ -0,0 +1,105 @@
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+/*
+Stack layout parameters.
+Included both by runtime (compiled via 6c) and linkers (compiled via gcc).
+
+The per-goroutine g->stackguard is set to point stackGuard bytes
+above the bottom of the stack.  Each function compares its stack
+pointer against g->stackguard to check for overflow.  To cut one
+instruction from the check sequence for functions with tiny frames,
+the stack is allowed to protrude stackSmall bytes below the stack
+guard.  Functions with large frames don't bother with the check and
+always call morestack.  The sequences are (for amd64, others are
+similar):
+
+	guard = g->stackguard
+	frame = function's stack frame size
+	argsize = size of function arguments (call + return)
+
+	stack frame size <= stackSmall:
+		CMPQ guard, SP
+		JHI 3(PC)
+		MOVQ m->morearg, $(argsize << 32)
+		CALL morestack(SB)
+
+	stack frame size > stackSmall but < stackBig
+		LEAQ (frame-stackSmall)(SP), R0
+		CMPQ guard, R0
+		JHI 3(PC)
+		MOVQ m->morearg, $(argsize << 32)
+		CALL morestack(SB)
+
+	stack frame size >= stackBig:
+		MOVQ m->morearg, $((argsize << 32) | frame)
+		CALL morestack(SB)
+
+The bottom stackGuard - stackSmall bytes are important: there has
+to be enough room to execute functions that refuse to check for
+stack overflow, either because they need to be adjacent to the
+actual caller's frame (deferproc) or because they handle the imminent
+stack overflow (morestack).
+
+For example, deferproc might call malloc, which does one of the
+above checks (without allocating a full frame), which might trigger
+a call to morestack.  This sequence needs to fit in the bottom
+section of the stack.  On amd64, morestack's frame is 40 bytes, and
+deferproc's frame is 56 bytes.  That fits well within the
+stackGuard - stackSmall = 128 bytes at the bottom.
+The linkers explore all possible call traces involving non-splitting
+functions to make sure that this limit cannot be violated.
+*/
+
+const (
+	// stackSystem is a number of additional bytes to add
+	// to each stack below the usual guard area for OS-specific
+	// purposes like signal handling. Used on Windows and on
+	// Plan 9 because they do not use a separate stack.
+	// Defined in os_*.go.
+
+	// The amount of extra stack to allocate beyond the size
+	// needed for the single frame that triggered the split.
+	stackExtra = 2048
+
+	// The minimum stack segment size to allocate.
+	// If the amount needed for the splitting frame + stackExtra
+	// is less than this number, the stack will have this size instead.
+	stackMin           = 8192
+	stackSystemRounded = stackSystem + (-stackSystem & (stackMin - 1))
+	Fixedstack         = stackMin + stackSystemRounded
+
+	// Functions that need frames bigger than this use an extra
+	// instruction to do the stack split check, to avoid overflow
+	// in case SP - framesize wraps below zero.
+	// This value can be no bigger than the size of the unmapped
+	// space at zero.
+	stackBig = 4096
+
+	// The stack guard is a pointer this many bytes above the
+	// bottom of the stack.
+	stackGuard = 256 + stackSystem
+
+	// After a stack split check the SP is allowed to be this
+	// many bytes below the stack guard.  This saves an instruction
+	// in the checking sequence for tiny frames.
+	stackSmall = 96
+
+	// The maximum number of bytes that a chain of NOSPLIT
+	// functions can use.
+	stackLimit = stackGuard - stackSystem - stackSmall
+
+	// The assumed size of the top-of-stack data block.
+	// The actual size can be smaller than this but cannot be larger.
+	// Checked in proc.c's runtime.malg.
+	stackTop = 88
+
+	// Goroutine preemption request.
+	// Stored into g->stackguard0 to cause split stack check failure.
+	// Must be greater than any real sp.
+	// 0xfffffade in hex.
+	stackPreempt = ^uintptr(1313)
+)
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 9e5a2cf04a..90d43ea713 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -11,9 +11,7 @@ import "unsafe"
 // Assembly implementations are in various files, see comments with
 // each function.
 
-const (
-	ptrSize = unsafe.Sizeof((*byte)(nil))
-)
+const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
 
 //go:noescape
 func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
@@ -88,9 +86,7 @@ var (
 	setgcpercent_m,
 	setmaxthreads_m,
 	ready_m,
-	park_m,
-	notewakeup_m,
-	notetsleepg_m mFunction
+	park_m mFunction
 )
 
 func blockevent(int64, int32)
@@ -162,6 +158,8 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
 	return unsafe.Pointer(x ^ 0)
 }
 
+func entersyscall()
+func entersyscallblock()
 func exitsyscall()
 
 func goroutineheader(gp *g)
@@ -195,13 +193,6 @@ func osyield()
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
 func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer
 func readgogc() int32
-func notetsleepg(n *note, ns int64)
-func notetsleep(n *note, ns int64)
-func notewakeup(n *note)
-func notesleep(n *note)
-func noteclear(n *note)
-func lock(lk *mutex)
-func unlock(lk *mutex)
 func purgecachedstats(c *mcache)
 func gostringnocopy(b *byte) string
 
@@ -244,6 +235,9 @@ func atomicstore64(ptr *uint64, val uint64)
 //go:noescape
 func atomicstorep(ptr unsafe.Pointer, val unsafe.Pointer)
 
+//go:noescape
+func atomicstoreuintptr(ptr *uintptr, new uintptr)
+
 //go:noescape
 func atomicload(ptr *uint32) uint32
 
@@ -253,6 +247,9 @@ func atomicload64(ptr *uint64) uint64
 //go:noescape
 func atomicloadp(ptr unsafe.Pointer) unsafe.Pointer
 
+//go:noescape
+func atomicloaduintptr(ptr *uintptr) uintptr
+
 //go:noescape
 func atomicor8(ptr *uint8, val uint8)
 

From 858c57f5bd2170abe71cbbf505966cd648935d00 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 29 Aug 2014 16:41:08 -0400
Subject: [PATCH 292/423] runtime: make allp a static array

It is anyway, just an allocated one.
Giving it a sized type makes Go access nicer.

LGTM=iant
R=dvyukov, iant
CC=golang-codereviews
https://golang.org/cl/139960043
---
 src/pkg/runtime/proc.c    | 6 +-----
 src/pkg/runtime/runtime.h | 8 +++++++-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index d91a829c15..666adfb7db 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -62,10 +62,6 @@ struct Sched {
 
 enum
 {
-	// The max value of GOMAXPROCS.
-	// There are no fundamental restrictions on the value.
-	MaxGomaxprocs = 1<<8,
-
 	// Number of goroutine ids to grab from runtime·sched.goidgen to local per-P cache at once.
 	// 16 seems to provide enough amortization, but other than that it's mostly arbitrary number.
 	GoidCacheBatch = 16,
@@ -80,6 +76,7 @@ G	runtime·g0;	// idle goroutine for m0
 G*	runtime·lastg;
 M*	runtime·allm;
 M*	runtime·extram;
+P*	runtime·allp[MaxGomaxprocs+1];
 int8*	runtime·goos;
 int32	runtime·ncpu;
 static int32	newprocs;
@@ -180,7 +177,6 @@ runtime·schedinit(void)
 			n = MaxGomaxprocs;
 		procs = n;
 	}
-	runtime·allp = runtime·mallocgc((MaxGomaxprocs+1)*sizeof(runtime·allp[0]), nil, 0);
 	procresize(procs);
 
 	runtime·copystack = runtime·precisestack;
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 27b945e979..3f03a4da06 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -422,6 +422,12 @@ struct P
 	byte	pad[64];
 };
 
+enum {
+	// The max value of GOMAXPROCS.
+	// There are no fundamental restrictions on the value.
+	MaxGomaxprocs = 1<<8,
+};
+
 // The m->locked word holds two pieces of state counting active calls to LockOSThread/lockOSThread.
 // The low bit (LockExternal) is a boolean reporting whether any LockOSThread call is active.
 // External locks are not recursive; a second lock is silently ignored.
@@ -768,7 +774,7 @@ extern	G**	runtime·allg;
 extern	uintptr runtime·allglen;
 extern	G*	runtime·lastg;
 extern	M*	runtime·allm;
-extern	P**	runtime·allp;
+extern	P*	runtime·allp[MaxGomaxprocs+1];
 extern	int32	runtime·gomaxprocs;
 extern	uint32	runtime·needextram;
 extern	uint32	runtime·panicking;

From 854dbb7fdcc85ca187e4d91a5a85d392242bb1cb Mon Sep 17 00:00:00 2001
From: Alex A Skinner <alex@lx.lc>
Date: Sat, 30 Aug 2014 07:50:50 +0900
Subject: [PATCH 293/423] net: ensure identical queries are not sent multiple
 times in builtin stub resolver

Prevents non-rooted queries with > ndots dots from being tried twice on error.
Fixes #8616.

Benchmark results on linux/amd64
benchmark                        old ns/op    new ns/op    delta
BenchmarkGoLookupIPNoSuchHost      8212394      4413293  -46.26%

benchmark                       old allocs   new allocs    delta
BenchmarkGoLookupIPNoSuchHost          216          108  -50.00%

benchmark                        old bytes    new bytes    delta
BenchmarkGoLookupIPNoSuchHost        17460         8726  -50.02%

LGTM=iant, mikioh.mikioh
R=golang-codereviews, iant, mikioh.mikioh
CC=golang-codereviews
https://golang.org/cl/137870043
---
 src/pkg/net/dnsclient_unix.go      | 21 +++++++++------------
 src/pkg/net/dnsclient_unix_test.go |  6 ++++++
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/pkg/net/dnsclient_unix.go b/src/pkg/net/dnsclient_unix.go
index eb4b5900de..dc5eed96cc 100644
--- a/src/pkg/net/dnsclient_unix.go
+++ b/src/pkg/net/dnsclient_unix.go
@@ -310,13 +310,10 @@ func lookup(name string, qtype uint16) (cname string, addrs []dnsRR, err error)
 		}
 		// Can try as ordinary name.
 		cname, addrs, err = tryOneName(cfg.dnsConfig, rname, qtype)
-		if err == nil {
+		if rooted || err == nil {
 			return
 		}
 	}
-	if rooted {
-		return
-	}
 
 	// Otherwise, try suffixes.
 	for i := 0; i < len(cfg.dnsConfig.search); i++ {
@@ -330,15 +327,15 @@ func lookup(name string, qtype uint16) (cname string, addrs []dnsRR, err error)
 		}
 	}
 
-	// Last ditch effort: try unsuffixed.
-	rname := name
-	if !rooted {
-		rname += "."
-	}
-	cname, addrs, err = tryOneName(cfg.dnsConfig, rname, qtype)
-	if err == nil {
-		return
+	// Last ditch effort: try unsuffixed only if we haven't already,
+	// that is, name is not rooted and has less than ndots dots.
+	if count(name, '.') < cfg.dnsConfig.ndots {
+		cname, addrs, err = tryOneName(cfg.dnsConfig, name+".", qtype)
+		if err == nil {
+			return
+		}
 	}
+
 	if e, ok := err.(*DNSError); ok {
 		// Show original name passed to lookup, not suffixed one.
 		// In general we might have tried many suffixes; showing
diff --git a/src/pkg/net/dnsclient_unix_test.go b/src/pkg/net/dnsclient_unix_test.go
index 39d82d9961..204c8b7ef7 100644
--- a/src/pkg/net/dnsclient_unix_test.go
+++ b/src/pkg/net/dnsclient_unix_test.go
@@ -217,3 +217,9 @@ func TestReloadResolvConfChange(t *testing.T) {
 	r.SetConf("nameserver 8.8.4.4")
 	r.WantServers([]string{"[8.8.4.4]"})
 }
+
+func BenchmarkGoLookupIPNoSuchHost(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		goLookupIP("some.nonexistent")
+	}
+}

From 21967f2c9aa4732ad5f5a0e3a91868716ac9e2e8 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Sat, 30 Aug 2014 07:52:20 +0900
Subject: [PATCH 294/423] undo CL 107150043 / caa2646daa63
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

preparing for the syscall package freeze.
the change for issue 8218 is only applied to go.sys/unix.

««« original CL description
syscall: implement setresuid(2) and setresgid(2) on OpenBSD/FreeBSD/DragonflyBSD

Fixes #8218.

LGTM=iant
R=golang-codereviews, iant, minux
CC=golang-codereviews
https://golang.org/cl/107150043

»»»

LGTM=r
R=r, iant, golang-codereviews
CC=golang-codereviews
https://golang.org/cl/138840044
---
 src/pkg/syscall/syscall_dragonfly.go        |  2 --
 src/pkg/syscall/syscall_freebsd.go          |  2 --
 src/pkg/syscall/syscall_openbsd.go          |  4 ++--
 src/pkg/syscall/zsyscall_dragonfly_386.go   | 20 --------------------
 src/pkg/syscall/zsyscall_dragonfly_amd64.go | 20 --------------------
 src/pkg/syscall/zsyscall_freebsd_386.go     | 20 --------------------
 src/pkg/syscall/zsyscall_freebsd_amd64.go   | 20 --------------------
 src/pkg/syscall/zsyscall_freebsd_arm.go     | 20 --------------------
 src/pkg/syscall/zsyscall_openbsd_386.go     | 20 --------------------
 src/pkg/syscall/zsyscall_openbsd_amd64.go   | 20 --------------------
 10 files changed, 2 insertions(+), 146 deletions(-)

diff --git a/src/pkg/syscall/syscall_dragonfly.go b/src/pkg/syscall/syscall_dragonfly.go
index b17e77da8a..39c51df7ed 100644
--- a/src/pkg/syscall/syscall_dragonfly.go
+++ b/src/pkg/syscall/syscall_dragonfly.go
@@ -183,8 +183,6 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 //sys	Setpriority(which int, who int, prio int) (err error)
 //sysnb	Setregid(rgid int, egid int) (err error)
 //sysnb	Setreuid(ruid int, euid int) (err error)
-//sysnb	Setresgid(rgid int, egid int, sgid int) (err error)
-//sysnb	Setresuid(ruid int, euid int, suid int) (err error)
 //sysnb	Setrlimit(which int, lim *Rlimit) (err error)
 //sysnb	Setsid() (pid int, err error)
 //sysnb	Settimeofday(tp *Timeval) (err error)
diff --git a/src/pkg/syscall/syscall_freebsd.go b/src/pkg/syscall/syscall_freebsd.go
index 959d46b4d4..3d834f52b5 100644
--- a/src/pkg/syscall/syscall_freebsd.go
+++ b/src/pkg/syscall/syscall_freebsd.go
@@ -205,8 +205,6 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 //sys	Setpriority(which int, who int, prio int) (err error)
 //sysnb	Setregid(rgid int, egid int) (err error)
 //sysnb	Setreuid(ruid int, euid int) (err error)
-//sysnb	Setresgid(rgid int, egid int, sgid int) (err error)
-//sysnb	Setresuid(ruid int, euid int, suid int) (err error)
 //sysnb	Setrlimit(which int, lim *Rlimit) (err error)
 //sysnb	Setsid() (pid int, err error)
 //sysnb	Settimeofday(tp *Timeval) (err error)
diff --git a/src/pkg/syscall/syscall_openbsd.go b/src/pkg/syscall/syscall_openbsd.go
index a46f6ae56e..8d3f825f8f 100644
--- a/src/pkg/syscall/syscall_openbsd.go
+++ b/src/pkg/syscall/syscall_openbsd.go
@@ -182,8 +182,6 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 //sys	Setpriority(which int, who int, prio int) (err error)
 //sysnb	Setregid(rgid int, egid int) (err error)
 //sysnb	Setreuid(ruid int, euid int) (err error)
-//sysnb	Setresgid(rgid int, egid int, sgid int) (err error)
-//sysnb	Setresuid(ruid int, euid int, suid int) (err error)
 //sysnb	Setrlimit(which int, lim *Rlimit) (err error)
 //sysnb	Setsid() (pid int, err error)
 //sysnb	Settimeofday(tp *Timeval) (err error)
@@ -274,6 +272,8 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 // semop
 // setgroups
 // setitimer
+// setresgid
+// setresuid
 // setrtable
 // setsockopt
 // shmat
diff --git a/src/pkg/syscall/zsyscall_dragonfly_386.go b/src/pkg/syscall/zsyscall_dragonfly_386.go
index 94a716fa56..0ec8132326 100644
--- a/src/pkg/syscall/zsyscall_dragonfly_386.go
+++ b/src/pkg/syscall/zsyscall_dragonfly_386.go
@@ -1059,26 +1059,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
diff --git a/src/pkg/syscall/zsyscall_dragonfly_amd64.go b/src/pkg/syscall/zsyscall_dragonfly_amd64.go
index 89c22ed3cc..8c7cce54e7 100644
--- a/src/pkg/syscall/zsyscall_dragonfly_amd64.go
+++ b/src/pkg/syscall/zsyscall_dragonfly_amd64.go
@@ -1059,26 +1059,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
diff --git a/src/pkg/syscall/zsyscall_freebsd_386.go b/src/pkg/syscall/zsyscall_freebsd_386.go
index 61e4888ae8..5befe83c6b 100644
--- a/src/pkg/syscall/zsyscall_freebsd_386.go
+++ b/src/pkg/syscall/zsyscall_freebsd_386.go
@@ -1059,26 +1059,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
diff --git a/src/pkg/syscall/zsyscall_freebsd_amd64.go b/src/pkg/syscall/zsyscall_freebsd_amd64.go
index 5e3afe19ac..ab2eb80c62 100644
--- a/src/pkg/syscall/zsyscall_freebsd_amd64.go
+++ b/src/pkg/syscall/zsyscall_freebsd_amd64.go
@@ -1059,26 +1059,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
diff --git a/src/pkg/syscall/zsyscall_freebsd_arm.go b/src/pkg/syscall/zsyscall_freebsd_arm.go
index da1f2d587f..c1f0f907cd 100644
--- a/src/pkg/syscall/zsyscall_freebsd_arm.go
+++ b/src/pkg/syscall/zsyscall_freebsd_arm.go
@@ -1059,26 +1059,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
diff --git a/src/pkg/syscall/zsyscall_openbsd_386.go b/src/pkg/syscall/zsyscall_openbsd_386.go
index 068a1fba7f..785e7c3b8e 100644
--- a/src/pkg/syscall/zsyscall_openbsd_386.go
+++ b/src/pkg/syscall/zsyscall_openbsd_386.go
@@ -1049,26 +1049,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {
diff --git a/src/pkg/syscall/zsyscall_openbsd_amd64.go b/src/pkg/syscall/zsyscall_openbsd_amd64.go
index 13dc093375..7a8d9b6f1d 100644
--- a/src/pkg/syscall/zsyscall_openbsd_amd64.go
+++ b/src/pkg/syscall/zsyscall_openbsd_amd64.go
@@ -1049,26 +1049,6 @@ func Setreuid(ruid int, euid int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Setresgid(rgid int, egid int, sgid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
-func Setresuid(ruid int, euid int, suid int) (err error) {
-	_, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid))
-	if e1 != 0 {
-		err = e1
-	}
-	return
-}
-
-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
-
 func Setrlimit(which int, lim *Rlimit) (err error) {
 	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 	if e1 != 0 {

From 0b9e4723005b88537b6480e51a45e82a358c9129 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Fri, 29 Aug 2014 16:11:05 -0700
Subject: [PATCH 295/423] runtime: rename Sigaltstack to SigaltstackT

Avoids a conflict between the type and function sigaltstack.

LGTM=crawshaw
R=rsc, crawshaw
CC=golang-codereviews
https://golang.org/cl/138920043
---
 src/pkg/runtime/defs1_linux.go         | 2 +-
 src/pkg/runtime/defs2_linux.go         | 2 +-
 src/pkg/runtime/defs_arm_linux.go      | 2 +-
 src/pkg/runtime/defs_dragonfly.go      | 2 +-
 src/pkg/runtime/defs_dragonfly_386.h   | 4 ++--
 src/pkg/runtime/defs_dragonfly_amd64.h | 4 ++--
 src/pkg/runtime/defs_freebsd.go        | 2 +-
 src/pkg/runtime/defs_freebsd_386.h     | 4 ++--
 src/pkg/runtime/defs_freebsd_amd64.h   | 4 ++--
 src/pkg/runtime/defs_freebsd_arm.h     | 4 ++--
 src/pkg/runtime/defs_linux_386.h       | 6 +++---
 src/pkg/runtime/defs_linux_amd64.h     | 6 +++---
 src/pkg/runtime/defs_linux_arm.h       | 6 +++---
 src/pkg/runtime/defs_netbsd.go         | 2 +-
 src/pkg/runtime/defs_netbsd_386.h      | 4 ++--
 src/pkg/runtime/defs_netbsd_amd64.h    | 4 ++--
 src/pkg/runtime/defs_netbsd_arm.h      | 4 ++--
 src/pkg/runtime/defs_openbsd.go        | 2 +-
 src/pkg/runtime/defs_openbsd_386.h     | 4 ++--
 src/pkg/runtime/defs_openbsd_amd64.h   | 4 ++--
 src/pkg/runtime/defs_solaris.go        | 2 +-
 src/pkg/runtime/defs_solaris_amd64.h   | 4 ++--
 src/pkg/runtime/os_dragonfly.h         | 2 +-
 src/pkg/runtime/os_freebsd.h           | 2 +-
 src/pkg/runtime/os_linux.c             | 2 +-
 src/pkg/runtime/os_linux.h             | 2 +-
 src/pkg/runtime/os_netbsd.h            | 2 +-
 src/pkg/runtime/os_openbsd.h           | 2 +-
 src/pkg/runtime/os_solaris.c           | 2 +-
 src/pkg/runtime/os_solaris.h           | 2 +-
 30 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/src/pkg/runtime/defs1_linux.go b/src/pkg/runtime/defs1_linux.go
index 451817a67a..392cc4ab58 100644
--- a/src/pkg/runtime/defs1_linux.go
+++ b/src/pkg/runtime/defs1_linux.go
@@ -31,7 +31,7 @@ type Fpxreg1 C.struct__fpxreg
 type Xmmreg1 C.struct__xmmreg
 type Fpstate1 C.struct__fpstate
 type Fpreg1 C.struct__fpreg
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Mcontext C.mcontext_t
 type Ucontext C.ucontext_t
 type Sigcontext C.struct_sigcontext
diff --git a/src/pkg/runtime/defs2_linux.go b/src/pkg/runtime/defs2_linux.go
index 60ecc69bb9..980df9ec31 100644
--- a/src/pkg/runtime/defs2_linux.go
+++ b/src/pkg/runtime/defs2_linux.go
@@ -139,7 +139,7 @@ type Timespec C.struct_timespec
 type Timeval C.struct_timeval
 type Sigaction C.struct_kernel_sigaction
 type Siginfo C.siginfo_t
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigcontext C.struct_sigcontext
 type Ucontext C.struct_ucontext
 type Itimerval C.struct_itimerval
diff --git a/src/pkg/runtime/defs_arm_linux.go b/src/pkg/runtime/defs_arm_linux.go
index db0a191542..afd6897e30 100644
--- a/src/pkg/runtime/defs_arm_linux.go
+++ b/src/pkg/runtime/defs_arm_linux.go
@@ -115,7 +115,7 @@ const (
 )
 
 type Timespec C.struct_timespec
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigcontext C.struct_sigcontext
 type Ucontext C.struct_ucontext
 type Timeval C.struct_timeval
diff --git a/src/pkg/runtime/defs_dragonfly.go b/src/pkg/runtime/defs_dragonfly.go
index 8ebc3a9e1a..555b8f5951 100644
--- a/src/pkg/runtime/defs_dragonfly.go
+++ b/src/pkg/runtime/defs_dragonfly.go
@@ -110,7 +110,7 @@ const (
 
 type Rtprio C.struct_rtprio
 type Lwpparams C.struct_lwp_params
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigset C.struct___sigset
 type StackT C.stack_t
 
diff --git a/src/pkg/runtime/defs_dragonfly_386.h b/src/pkg/runtime/defs_dragonfly_386.h
index 032b23574e..f86b9c6b94 100644
--- a/src/pkg/runtime/defs_dragonfly_386.h
+++ b/src/pkg/runtime/defs_dragonfly_386.h
@@ -85,7 +85,7 @@ enum {
 
 typedef struct Rtprio Rtprio;
 typedef struct Lwpparams Lwpparams;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
@@ -109,7 +109,7 @@ struct Lwpparams {
 	int32	*tid1;
 	int32	*tid2;
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	int8	*ss_sp;
 	uint32	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_dragonfly_amd64.h b/src/pkg/runtime/defs_dragonfly_amd64.h
index c37a72e729..671555241d 100644
--- a/src/pkg/runtime/defs_dragonfly_amd64.h
+++ b/src/pkg/runtime/defs_dragonfly_amd64.h
@@ -85,7 +85,7 @@ enum {
 
 typedef struct Rtprio Rtprio;
 typedef struct Lwpparams Lwpparams;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
@@ -109,7 +109,7 @@ struct Lwpparams {
 	int32	*tid1;
 	int32	*tid2;
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	int8	*ss_sp;
 	uint64	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_freebsd.go b/src/pkg/runtime/defs_freebsd.go
index 2832583e06..0253685aac 100644
--- a/src/pkg/runtime/defs_freebsd.go
+++ b/src/pkg/runtime/defs_freebsd.go
@@ -117,7 +117,7 @@ const (
 
 type Rtprio C.struct_rtprio
 type ThrParam C.struct_thr_param
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigset C.struct___sigset
 type StackT C.stack_t
 
diff --git a/src/pkg/runtime/defs_freebsd_386.h b/src/pkg/runtime/defs_freebsd_386.h
index e625079bc7..156dccba48 100644
--- a/src/pkg/runtime/defs_freebsd_386.h
+++ b/src/pkg/runtime/defs_freebsd_386.h
@@ -89,7 +89,7 @@ enum {
 
 typedef struct Rtprio Rtprio;
 typedef struct ThrParam ThrParam;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
@@ -119,7 +119,7 @@ struct ThrParam {
 	Rtprio	*rtp;
 	void	*spare[3];
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	int8	*ss_sp;
 	uint32	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_freebsd_amd64.h b/src/pkg/runtime/defs_freebsd_amd64.h
index 40476f9e4f..4ba8956a2c 100644
--- a/src/pkg/runtime/defs_freebsd_amd64.h
+++ b/src/pkg/runtime/defs_freebsd_amd64.h
@@ -89,7 +89,7 @@ enum {
 
 typedef struct Rtprio Rtprio;
 typedef struct ThrParam ThrParam;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
@@ -120,7 +120,7 @@ struct ThrParam {
 	Rtprio	*rtp;
 	void	*spare[3];
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	int8	*ss_sp;
 	uint64	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_freebsd_arm.h b/src/pkg/runtime/defs_freebsd_arm.h
index 927d3a48b5..17deba68d1 100644
--- a/src/pkg/runtime/defs_freebsd_arm.h
+++ b/src/pkg/runtime/defs_freebsd_arm.h
@@ -89,7 +89,7 @@ enum {
 
 typedef struct Rtprio Rtprio;
 typedef struct ThrParam ThrParam;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
@@ -119,7 +119,7 @@ struct ThrParam {
 	Rtprio	*rtp;
 	void	*spare[3];
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	uint8	*ss_sp;
 	uint32	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_linux_386.h b/src/pkg/runtime/defs_linux_386.h
index 2df3f66d80..d19bb7a00f 100644
--- a/src/pkg/runtime/defs_linux_386.h
+++ b/src/pkg/runtime/defs_linux_386.h
@@ -97,7 +97,7 @@ typedef struct Timespec Timespec;
 typedef struct Timeval Timeval;
 typedef struct SigactionT SigactionT;
 typedef struct Siginfo Siginfo;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Ucontext Ucontext;
 typedef struct Itimerval Itimerval;
@@ -156,7 +156,7 @@ struct Siginfo {
 	int32	si_code;
 	byte	_sifields[116];
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	int32	ss_flags;
 	uint32	ss_size;
@@ -194,7 +194,7 @@ struct Sigcontext {
 struct Ucontext {
 	uint32	uc_flags;
 	Ucontext	*uc_link;
-	Sigaltstack	uc_stack;
+	SigaltstackT	uc_stack;
 	Sigcontext	uc_mcontext;
 	uint32	uc_sigmask;
 };
diff --git a/src/pkg/runtime/defs_linux_amd64.h b/src/pkg/runtime/defs_linux_amd64.h
index 42826c39ee..73fd9947a7 100644
--- a/src/pkg/runtime/defs_linux_amd64.h
+++ b/src/pkg/runtime/defs_linux_amd64.h
@@ -144,7 +144,7 @@ typedef struct Fpxreg1 Fpxreg1;
 typedef struct Xmmreg1 Xmmreg1;
 typedef struct Fpstate1 Fpstate1;
 typedef struct Fpreg1 Fpreg1;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Mcontext Mcontext;
 typedef struct Ucontext Ucontext;
 typedef struct Sigcontext Sigcontext;
@@ -200,7 +200,7 @@ struct Fpreg1 {
 	uint16	significand[4];
 	uint16	exponent;
 };
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	int32	ss_flags;
 	byte	Pad_cgo_0[4];
@@ -214,7 +214,7 @@ struct Mcontext {
 struct Ucontext {
 	uint64	uc_flags;
 	Ucontext	*uc_link;
-	Sigaltstack	uc_stack;
+	SigaltstackT	uc_stack;
 	Mcontext	uc_mcontext;
 	Usigset	uc_sigmask;
 	Fpstate	__fpregs_mem;
diff --git a/src/pkg/runtime/defs_linux_arm.h b/src/pkg/runtime/defs_linux_arm.h
index 8c17e3805b..61bd30d59c 100644
--- a/src/pkg/runtime/defs_linux_arm.h
+++ b/src/pkg/runtime/defs_linux_arm.h
@@ -88,8 +88,8 @@ struct Timespec {
 	int32 tv_nsec;
 };
 
-typedef struct Sigaltstack Sigaltstack;
-struct Sigaltstack {
+typedef struct SigaltstackT SigaltstackT;
+struct SigaltstackT {
 	void *ss_sp;
 	int32 ss_flags;
 	uint32 ss_size;
@@ -124,7 +124,7 @@ typedef struct Ucontext Ucontext;
 struct Ucontext {
 	uint32 uc_flags;
 	Ucontext *uc_link;
-	Sigaltstack uc_stack;
+	SigaltstackT uc_stack;
 	Sigcontext uc_mcontext;
 	uint32 uc_sigmask;
 	int32 __unused[31];
diff --git a/src/pkg/runtime/defs_netbsd.go b/src/pkg/runtime/defs_netbsd.go
index d1c4cbe96c..b27949e423 100644
--- a/src/pkg/runtime/defs_netbsd.go
+++ b/src/pkg/runtime/defs_netbsd.go
@@ -109,7 +109,7 @@ const (
 	EVFILT_WRITE = C.EVFILT_WRITE
 )
 
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigset C.sigset_t
 type Siginfo C.struct__ksiginfo
 
diff --git a/src/pkg/runtime/defs_netbsd_386.h b/src/pkg/runtime/defs_netbsd_386.h
index fb23611990..53d4b30bb7 100644
--- a/src/pkg/runtime/defs_netbsd_386.h
+++ b/src/pkg/runtime/defs_netbsd_386.h
@@ -82,7 +82,7 @@ enum {
 	EVFILT_WRITE	= 0x1,
 };
 
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct Siginfo Siginfo;
 typedef struct StackT StackT;
@@ -95,7 +95,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	uint32	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_netbsd_amd64.h b/src/pkg/runtime/defs_netbsd_amd64.h
index f6ba3db189..6227575c92 100644
--- a/src/pkg/runtime/defs_netbsd_amd64.h
+++ b/src/pkg/runtime/defs_netbsd_amd64.h
@@ -82,7 +82,7 @@ enum {
 	EVFILT_WRITE	= 0x1,
 };
 
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct Siginfo Siginfo;
 typedef struct StackT StackT;
@@ -95,7 +95,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	uint64	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_netbsd_arm.h b/src/pkg/runtime/defs_netbsd_arm.h
index 815d54749b..115fa439a6 100644
--- a/src/pkg/runtime/defs_netbsd_arm.h
+++ b/src/pkg/runtime/defs_netbsd_arm.h
@@ -82,7 +82,7 @@ enum {
 	EVFILT_WRITE	= 0x1,
 };
 
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct Siginfo Siginfo;
 typedef struct StackT StackT;
@@ -95,7 +95,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	uint32	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_openbsd.go b/src/pkg/runtime/defs_openbsd.go
index 4a705796f0..cf4e06d37b 100644
--- a/src/pkg/runtime/defs_openbsd.go
+++ b/src/pkg/runtime/defs_openbsd.go
@@ -106,7 +106,7 @@ const (
 
 type Tfork C.struct___tfork
 
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigcontext C.struct_sigcontext
 type Siginfo C.siginfo_t
 type Sigset C.sigset_t
diff --git a/src/pkg/runtime/defs_openbsd_386.h b/src/pkg/runtime/defs_openbsd_386.h
index a63b182a04..669a35c357 100644
--- a/src/pkg/runtime/defs_openbsd_386.h
+++ b/src/pkg/runtime/defs_openbsd_386.h
@@ -82,7 +82,7 @@ enum {
 };
 
 typedef struct Tfork Tfork;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
 typedef struct StackT StackT;
@@ -99,7 +99,7 @@ struct Tfork {
 	byte	*tf_stack;
 };
 
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	uint32	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_openbsd_amd64.h b/src/pkg/runtime/defs_openbsd_amd64.h
index 818ac35207..9877f8b4c2 100644
--- a/src/pkg/runtime/defs_openbsd_amd64.h
+++ b/src/pkg/runtime/defs_openbsd_amd64.h
@@ -82,7 +82,7 @@ enum {
 };
 
 typedef struct Tfork Tfork;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
 typedef struct StackT StackT;
@@ -99,7 +99,7 @@ struct Tfork {
 	byte	*tf_stack;
 };
 
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	uint64	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/defs_solaris.go b/src/pkg/runtime/defs_solaris.go
index 8dcbb08b7d..ba44e5fd4d 100644
--- a/src/pkg/runtime/defs_solaris.go
+++ b/src/pkg/runtime/defs_solaris.go
@@ -133,7 +133,7 @@ const (
 
 type SemT C.sem_t
 
-type Sigaltstack C.struct_sigaltstack
+type SigaltstackT C.struct_sigaltstack
 type Sigset C.sigset_t
 type StackT C.stack_t
 
diff --git a/src/pkg/runtime/defs_solaris_amd64.h b/src/pkg/runtime/defs_solaris_amd64.h
index 08727b017e..cb1cfeadcc 100644
--- a/src/pkg/runtime/defs_solaris_amd64.h
+++ b/src/pkg/runtime/defs_solaris_amd64.h
@@ -101,7 +101,7 @@ enum {
 };
 
 typedef struct SemT SemT;
-typedef struct Sigaltstack Sigaltstack;
+typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigset Sigset;
 typedef struct StackT StackT;
 typedef struct Siginfo Siginfo;
@@ -126,7 +126,7 @@ struct SemT {
 	uint64	sem_pad2[2];
 };
 
-struct Sigaltstack {
+struct SigaltstackT {
 	byte	*ss_sp;
 	uint64	ss_size;
 	int32	ss_flags;
diff --git a/src/pkg/runtime/os_dragonfly.h b/src/pkg/runtime/os_dragonfly.h
index fddeede85d..4fb71478bf 100644
--- a/src/pkg/runtime/os_dragonfly.h
+++ b/src/pkg/runtime/os_dragonfly.h
@@ -8,7 +8,7 @@ typedef byte* kevent_udata;
 
 int32	runtime·lwp_create(Lwpparams*);
 void	runtime·sigpanic(void);
-void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 struct	sigaction;
 void	runtime·sigaction(int32, struct sigaction*, struct sigaction*);
 void	runtime·sigprocmask(Sigset *, Sigset *);
diff --git a/src/pkg/runtime/os_freebsd.h b/src/pkg/runtime/os_freebsd.h
index 4b2c253308..ec0be3161f 100644
--- a/src/pkg/runtime/os_freebsd.h
+++ b/src/pkg/runtime/os_freebsd.h
@@ -8,7 +8,7 @@ typedef byte* kevent_udata;
 
 int32	runtime·thr_new(ThrParam*, int32);
 void	runtime·sigpanic(void);
-void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 struct	sigaction;
 void	runtime·sigaction(int32, struct sigaction*, struct sigaction*);
 void	runtime·sigprocmask(Sigset *, Sigset *);
diff --git a/src/pkg/runtime/os_linux.c b/src/pkg/runtime/os_linux.c
index d3677f2e6c..34521cc86a 100644
--- a/src/pkg/runtime/os_linux.c
+++ b/src/pkg/runtime/os_linux.c
@@ -332,7 +332,7 @@ runtime·getsig(int32 i)
 void
 runtime·signalstack(byte *p, int32 n)
 {
-	Sigaltstack st;
+	SigaltstackT st;
 
 	st.ss_sp = p;
 	st.ss_size = n;
diff --git a/src/pkg/runtime/os_linux.h b/src/pkg/runtime/os_linux.h
index 84f516d50c..c475d32405 100644
--- a/src/pkg/runtime/os_linux.h
+++ b/src/pkg/runtime/os_linux.h
@@ -11,7 +11,7 @@ int32	runtime·clone(int32, void*, M*, G*, void(*)(void));
 struct SigactionT;
 int32	runtime·rt_sigaction(uintptr, struct SigactionT*, void*, uintptr);
 
-void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 void	runtime·sigpanic(void);
 void runtime·setitimer(int32, Itimerval*, Itimerval*);
 
diff --git a/src/pkg/runtime/os_netbsd.h b/src/pkg/runtime/os_netbsd.h
index 16e9833af5..a7995df92a 100644
--- a/src/pkg/runtime/os_netbsd.h
+++ b/src/pkg/runtime/os_netbsd.h
@@ -16,7 +16,7 @@ void	runtime·sigpanic(void);
 
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
 void	runtime·sigaction(int32, struct sigaction*, struct sigaction*);
-void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 void	runtime·sigprocmask(int32, Sigset*, Sigset*);
 void	runtime·unblocksignals(void);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
diff --git a/src/pkg/runtime/os_openbsd.h b/src/pkg/runtime/os_openbsd.h
index bbfde39e26..955432ebd6 100644
--- a/src/pkg/runtime/os_openbsd.h
+++ b/src/pkg/runtime/os_openbsd.h
@@ -16,7 +16,7 @@ void	runtime·sigpanic(void);
 
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
 void	runtime·sigaction(int32, struct sigaction*, struct sigaction*);
-void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 Sigset	runtime·sigprocmask(int32, Sigset);
 void	runtime·unblocksignals(void);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index 42295aa754..d064384e84 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -536,7 +536,7 @@ runtime·sigaction(int32 sig, struct SigactionT* act, struct SigactionT* oact)
 }
 
 /* int32 */ void
-runtime·sigaltstack(Sigaltstack* ss, Sigaltstack* oss)
+runtime·sigaltstack(SigaltstackT* ss, SigaltstackT* oss)
 {
 	runtime·sysvicall2(libc·sigaltstack, (uintptr)ss, (uintptr)oss);
 }
diff --git a/src/pkg/runtime/os_solaris.h b/src/pkg/runtime/os_solaris.h
index 20a0027205..ba08771cb7 100644
--- a/src/pkg/runtime/os_solaris.h
+++ b/src/pkg/runtime/os_solaris.h
@@ -16,7 +16,7 @@ void	runtime·sigpanic(void);
 
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
 void	runtime·sigaction(int32, struct SigactionT*, struct SigactionT*);
-void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 void	runtime·sigprocmask(int32, Sigset*, Sigset*);
 void	runtime·unblocksignals(void);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);

From 2758cb75f09ac19e12d17c964e4e5b3edaf4842d Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 29 Aug 2014 20:51:26 -0700
Subject: [PATCH 296/423] runtime: fix openbsd build

LGTM=iant
R=iant, minux
CC=golang-codereviews, jsing
https://golang.org/cl/135230043
---
 src/pkg/runtime/defs_openbsd.go      | 4 ++--
 src/pkg/runtime/defs_openbsd_386.h   | 4 ++--
 src/pkg/runtime/defs_openbsd_amd64.h | 4 ++--
 src/pkg/runtime/os_openbsd.c         | 6 +++---
 src/pkg/runtime/os_openbsd.go        | 2 +-
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/pkg/runtime/defs_openbsd.go b/src/pkg/runtime/defs_openbsd.go
index cf4e06d37b..39224c988c 100644
--- a/src/pkg/runtime/defs_openbsd.go
+++ b/src/pkg/runtime/defs_openbsd.go
@@ -104,7 +104,7 @@ const (
 	EVFILT_WRITE = C.EVFILT_WRITE
 )
 
-type Tfork C.struct___tfork
+type TforkT C.struct___tfork
 
 type SigaltstackT C.struct_sigaltstack
 type Sigcontext C.struct_sigcontext
@@ -118,4 +118,4 @@ type Timespec C.struct_timespec
 type Timeval C.struct_timeval
 type Itimerval C.struct_itimerval
 
-type Kevent C.struct_kevent
+type KeventT C.struct_kevent
diff --git a/src/pkg/runtime/defs_openbsd_386.h b/src/pkg/runtime/defs_openbsd_386.h
index 669a35c357..6b77e0084a 100644
--- a/src/pkg/runtime/defs_openbsd_386.h
+++ b/src/pkg/runtime/defs_openbsd_386.h
@@ -81,7 +81,7 @@ enum {
 	EVFILT_WRITE	= -0x2,
 };
 
-typedef struct Tfork Tfork;
+typedef struct TforkT TforkT;
 typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
@@ -93,7 +93,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Tfork {
+struct TforkT {
 	byte	*tf_tcb;
 	int32	*tf_tid;
 	byte	*tf_stack;
diff --git a/src/pkg/runtime/defs_openbsd_amd64.h b/src/pkg/runtime/defs_openbsd_amd64.h
index 9877f8b4c2..761e8e47df 100644
--- a/src/pkg/runtime/defs_openbsd_amd64.h
+++ b/src/pkg/runtime/defs_openbsd_amd64.h
@@ -81,7 +81,7 @@ enum {
 	EVFILT_WRITE	= -0x2,
 };
 
-typedef struct Tfork Tfork;
+typedef struct TforkT TforkT;
 typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
@@ -93,7 +93,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Tfork {
+struct TforkT {
 	byte	*tf_tcb;
 	int32	*tf_tid;
 	byte	*tf_stack;
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index a746385314..dbd12a1282 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -26,7 +26,7 @@ extern SigTab runtime·sigtab[];
 static Sigset sigset_none;
 static Sigset sigset_all = ~(Sigset)0;
 
-extern int32 runtime·tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
+extern int32 runtime·tfork(TforkT *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
 extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock, const int32 *abort);
 extern int32 runtime·thrwakeup(void *ident, int32 n);
 
@@ -130,7 +130,7 @@ runtime·semawakeup(M *mp)
 void
 runtime·newosproc(M *mp, void *stk)
 {
-	Tfork param;
+	TforkT param;
 	Sigset oset;
 	int32 ret;
 
@@ -147,7 +147,7 @@ runtime·newosproc(M *mp, void *stk)
 	param.tf_stack = stk;
 
 	oset = runtime·sigprocmask(SIG_SETMASK, sigset_all);
-	ret = runtime·tfork((byte*)&param, sizeof(param), mp, mp->g0, runtime·mstart);
+	ret = runtime·tfork(&param, sizeof(param), mp, mp->g0, runtime·mstart);
 	runtime·sigprocmask(SIG_SETMASK, oset);
 
 	if(ret < 0) {
diff --git a/src/pkg/runtime/os_openbsd.go b/src/pkg/runtime/os_openbsd.go
index 681bdde82e..d3923aa615 100644
--- a/src/pkg/runtime/os_openbsd.go
+++ b/src/pkg/runtime/os_openbsd.go
@@ -15,7 +15,7 @@ func raise(sig int32)
 func kqueue() int32
 func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
 func closeonexec(fd int32)
-func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32
+func tfork(param *tforkt, psize uintptr, mm, gg, fn unsafe.Pointer) int32
 func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
 func thrwakeup(ident unsafe.Pointer, n int32) int32
 

From 39a021bc0e48b0509706432f4363dd3407385be5 Mon Sep 17 00:00:00 2001
From: Alex A Skinner <alex@lx.lc>
Date: Sat, 30 Aug 2014 13:12:28 +0900
Subject: [PATCH 297/423] net: implement query-response fast failover in
 builtin dns stub resolver

Speed improvements via code cleanup, and changes to make go dns behave more like glibc resolver.  See https://groups.google.com/forum/#!topic/golang-dev/lV-0aHqxVeo

Fixes #6579.

Benchmark results on linux/amd64

benchmark                                  old ns/op    new ns/op    delta
BenchmarkGoLookupIP                          4831903      2572937  -46.75%
BenchmarkGoLookupIPNoSuchHost               10114105      2419641  -76.08%
BenchmarkGoLookupIPWithBrokenNameServer  20007735624   5004490730  -74.99%

benchmark                                 old allocs   new allocs    delta
BenchmarkGoLookupIP                              287          288    0.35%
BenchmarkGoLookupIPNoSuchHost                    204          102  -50.00%
BenchmarkGoLookupIPWithBrokenNameServer          410          358  -12.68%

benchmark                                  old bytes    new bytes    delta
BenchmarkGoLookupIP                            13181        13271    0.68%
BenchmarkGoLookupIPNoSuchHost                  17260         8714  -49.51%
BenchmarkGoLookupIPWithBrokenNameServer        28160        22432  -20.34%

LGTM=mikioh.mikioh
R=golang-codereviews, mikioh.mikioh, bradfitz, josharian, abursavich
CC=golang-codereviews
https://golang.org/cl/128820043
---
 src/pkg/net/dnsclient_unix.go      | 74 +++++++++++++-----------------
 src/pkg/net/dnsclient_unix_test.go | 21 +++++++++
 2 files changed, 54 insertions(+), 41 deletions(-)

diff --git a/src/pkg/net/dnsclient_unix.go b/src/pkg/net/dnsclient_unix.go
index dc5eed96cc..abe7da05cb 100644
--- a/src/pkg/net/dnsclient_unix.go
+++ b/src/pkg/net/dnsclient_unix.go
@@ -169,33 +169,20 @@ func tryOneName(cfg *dnsConfig, name string, qtype uint16) (string, []dnsRR, err
 	}
 	timeout := time.Duration(cfg.timeout) * time.Second
 	var lastErr error
-	for _, server := range cfg.servers {
-		server += ":53"
-		lastErr = &DNSError{
-			Err:       "no answer from DNS server",
-			Name:      name,
-			Server:    server,
-			IsTimeout: true,
-		}
-		for i := 0; i < cfg.attempts; i++ {
+	for i := 0; i < cfg.attempts; i++ {
+		for _, server := range cfg.servers {
+			server = JoinHostPort(server, "53")
 			msg, err := exchange(server, name, qtype, timeout)
 			if err != nil {
-				if nerr, ok := err.(Error); ok && nerr.Timeout() {
-					lastErr = &DNSError{
-						Err:       nerr.Error(),
-						Name:      name,
-						Server:    server,
-						IsTimeout: true,
-					}
-					continue
-
-				}
 				lastErr = &DNSError{
 					Err:    err.Error(),
 					Name:   name,
 					Server: server,
 				}
-				break
+				if nerr, ok := err.(Error); ok && nerr.Timeout() {
+					lastErr.(*DNSError).IsTimeout = true
+				}
+				continue
 			}
 			cname, addrs, err := answer(name, server, msg, qtype)
 			if err == nil || err.(*DNSError).Err == noSuchHost {
@@ -387,31 +374,36 @@ func goLookupIP(name string) (addrs []IP, err error) {
 			return
 		}
 	}
-	var records []dnsRR
-	var cname string
-	var err4, err6 error
-	cname, records, err4 = lookup(name, dnsTypeA)
-	addrs = convertRR_A(records)
-	if cname != "" {
-		name = cname
+	type racer struct {
+		qtype uint16
+		rrs   []dnsRR
+		error
 	}
-	_, records, err6 = lookup(name, dnsTypeAAAA)
-	if err4 != nil && err6 == nil {
-		// Ignore A error because AAAA lookup succeeded.
-		err4 = nil
+	lane := make(chan racer, 1)
+	qtypes := [...]uint16{dnsTypeA, dnsTypeAAAA}
+	for _, qtype := range qtypes {
+		go func(qtype uint16) {
+			_, rrs, err := lookup(name, qtype)
+			lane <- racer{qtype, rrs, err}
+		}(qtype)
 	}
-	if err6 != nil && len(addrs) > 0 {
-		// Ignore AAAA error because A lookup succeeded.
-		err6 = nil
+	var lastErr error
+	for range qtypes {
+		racer := <-lane
+		if racer.error != nil {
+			lastErr = racer.error
+			continue
+		}
+		switch racer.qtype {
+		case dnsTypeA:
+			addrs = append(addrs, convertRR_A(racer.rrs)...)
+		case dnsTypeAAAA:
+			addrs = append(addrs, convertRR_AAAA(racer.rrs)...)
+		}
 	}
-	if err4 != nil {
-		return nil, err4
+	if len(addrs) == 0 && lastErr != nil {
+		return nil, lastErr
 	}
-	if err6 != nil {
-		return nil, err6
-	}
-
-	addrs = append(addrs, convertRR_AAAA(records)...)
 	return addrs, nil
 }
 
diff --git a/src/pkg/net/dnsclient_unix_test.go b/src/pkg/net/dnsclient_unix_test.go
index 204c8b7ef7..bd7129bd13 100644
--- a/src/pkg/net/dnsclient_unix_test.go
+++ b/src/pkg/net/dnsclient_unix_test.go
@@ -218,8 +218,29 @@ func TestReloadResolvConfChange(t *testing.T) {
 	r.WantServers([]string{"[8.8.4.4]"})
 }
 
+func BenchmarkGoLookupIP(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		goLookupIP("www.example.com")
+	}
+}
+
 func BenchmarkGoLookupIPNoSuchHost(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		goLookupIP("some.nonexistent")
 	}
 }
+
+func BenchmarkGoLookupIPWithBrokenNameServer(b *testing.B) {
+	onceLoadConfig.Do(loadDefaultConfig)
+	if cfg.dnserr != nil || cfg.dnsConfig == nil {
+		b.Fatalf("loadConfig failed: %v", cfg.dnserr)
+	}
+	// This looks ugly but it's safe as long as benchmarks are run
+	// sequentially in package testing.
+	orig := cfg.dnsConfig
+	cfg.dnsConfig.servers = append([]string{"203.0.113.254"}, cfg.dnsConfig.servers...) // use TEST-NET-3 block, see RFC 5737
+	for i := 0; i < b.N; i++ {
+		goLookupIP("www.example.com")
+	}
+	cfg.dnsConfig = orig
+}

From 1a976f1576f2220ca78cb7094b2fea3e88a8b4ad Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Aug 2014 00:16:07 -0400
Subject: [PATCH 298/423] undo CL 135230043 / 60812bad3769
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

broke api check everywhere

««« original CL description
runtime: fix openbsd build

LGTM=iant
R=iant, minux
CC=golang-codereviews, jsing
https://golang.org/cl/135230043

»»»

TBR=mdempsky
CC=golang-codereviews
https://golang.org/cl/137010043
---
 src/pkg/runtime/defs_openbsd.go      | 4 ++--
 src/pkg/runtime/defs_openbsd_386.h   | 4 ++--
 src/pkg/runtime/defs_openbsd_amd64.h | 4 ++--
 src/pkg/runtime/os_openbsd.c         | 6 +++---
 src/pkg/runtime/os_openbsd.go        | 2 +-
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/pkg/runtime/defs_openbsd.go b/src/pkg/runtime/defs_openbsd.go
index 39224c988c..cf4e06d37b 100644
--- a/src/pkg/runtime/defs_openbsd.go
+++ b/src/pkg/runtime/defs_openbsd.go
@@ -104,7 +104,7 @@ const (
 	EVFILT_WRITE = C.EVFILT_WRITE
 )
 
-type TforkT C.struct___tfork
+type Tfork C.struct___tfork
 
 type SigaltstackT C.struct_sigaltstack
 type Sigcontext C.struct_sigcontext
@@ -118,4 +118,4 @@ type Timespec C.struct_timespec
 type Timeval C.struct_timeval
 type Itimerval C.struct_itimerval
 
-type KeventT C.struct_kevent
+type Kevent C.struct_kevent
diff --git a/src/pkg/runtime/defs_openbsd_386.h b/src/pkg/runtime/defs_openbsd_386.h
index 6b77e0084a..669a35c357 100644
--- a/src/pkg/runtime/defs_openbsd_386.h
+++ b/src/pkg/runtime/defs_openbsd_386.h
@@ -81,7 +81,7 @@ enum {
 	EVFILT_WRITE	= -0x2,
 };
 
-typedef struct TforkT TforkT;
+typedef struct Tfork Tfork;
 typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
@@ -93,7 +93,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct TforkT {
+struct Tfork {
 	byte	*tf_tcb;
 	int32	*tf_tid;
 	byte	*tf_stack;
diff --git a/src/pkg/runtime/defs_openbsd_amd64.h b/src/pkg/runtime/defs_openbsd_amd64.h
index 761e8e47df..9877f8b4c2 100644
--- a/src/pkg/runtime/defs_openbsd_amd64.h
+++ b/src/pkg/runtime/defs_openbsd_amd64.h
@@ -81,7 +81,7 @@ enum {
 	EVFILT_WRITE	= -0x2,
 };
 
-typedef struct TforkT TforkT;
+typedef struct Tfork Tfork;
 typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
@@ -93,7 +93,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct TforkT {
+struct Tfork {
 	byte	*tf_tcb;
 	int32	*tf_tid;
 	byte	*tf_stack;
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index dbd12a1282..a746385314 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -26,7 +26,7 @@ extern SigTab runtime·sigtab[];
 static Sigset sigset_none;
 static Sigset sigset_all = ~(Sigset)0;
 
-extern int32 runtime·tfork(TforkT *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
+extern int32 runtime·tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
 extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock, const int32 *abort);
 extern int32 runtime·thrwakeup(void *ident, int32 n);
 
@@ -130,7 +130,7 @@ runtime·semawakeup(M *mp)
 void
 runtime·newosproc(M *mp, void *stk)
 {
-	TforkT param;
+	Tfork param;
 	Sigset oset;
 	int32 ret;
 
@@ -147,7 +147,7 @@ runtime·newosproc(M *mp, void *stk)
 	param.tf_stack = stk;
 
 	oset = runtime·sigprocmask(SIG_SETMASK, sigset_all);
-	ret = runtime·tfork(&param, sizeof(param), mp, mp->g0, runtime·mstart);
+	ret = runtime·tfork((byte*)&param, sizeof(param), mp, mp->g0, runtime·mstart);
 	runtime·sigprocmask(SIG_SETMASK, oset);
 
 	if(ret < 0) {
diff --git a/src/pkg/runtime/os_openbsd.go b/src/pkg/runtime/os_openbsd.go
index d3923aa615..681bdde82e 100644
--- a/src/pkg/runtime/os_openbsd.go
+++ b/src/pkg/runtime/os_openbsd.go
@@ -15,7 +15,7 @@ func raise(sig int32)
 func kqueue() int32
 func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
 func closeonexec(fd int32)
-func tfork(param *tforkt, psize uintptr, mm, gg, fn unsafe.Pointer) int32
+func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32
 func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
 func thrwakeup(ident unsafe.Pointer, n int32) int32
 

From d4df63c3e8f37aa6ea033bae8937673460915279 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sat, 30 Aug 2014 08:40:56 +0400
Subject: [PATCH 299/423] runtime: convert type algorithms to Go Actually it
 mostly deletes code -- alg.print and alg.copy go away. There was only one
 usage of alg.print for debug purposes. Alg.copy is used in chan.goc, but
 Keith replaces them with memcopy during conversion, so alg.copy is not needed
 as well. Converting them would be significant amount of work for no visible
 benefit.

LGTM=crawshaw, rsc, khr
R=golang-codereviews, crawshaw, khr
CC=golang-codereviews, rsc
https://golang.org/cl/139930044
---
 src/cmd/gc/reflect.c           |  19 +--
 src/pkg/runtime/alg.go         | 160 ++++++++++++------
 src/pkg/runtime/alg.goc        | 289 ---------------------------------
 src/pkg/runtime/asm_386.s      |   1 -
 src/pkg/runtime/asm_amd64.s    |   1 -
 src/pkg/runtime/asm_amd64p32.s |   1 -
 src/pkg/runtime/asm_arm.s      |   1 -
 src/pkg/runtime/chan.goc       |  30 ++--
 src/pkg/runtime/hashmap.go     |   2 +-
 src/pkg/runtime/runtime.h      |  88 ----------
 src/pkg/runtime/stubs.go       |  17 --
 src/pkg/runtime/type.h         |   2 +-
 12 files changed, 130 insertions(+), 481 deletions(-)
 delete mode 100644 src/pkg/runtime/alg.goc

diff --git a/src/cmd/gc/reflect.c b/src/cmd/gc/reflect.c
index 05bf2d6521..f227054caf 100644
--- a/src/cmd/gc/reflect.c
+++ b/src/cmd/gc/reflect.c
@@ -724,7 +724,7 @@ dcommontype(Sym *s, int ot, Type *t)
 	if(ot != 0)
 		fatal("dcommontype %d", ot);
 
-	sizeofAlg = 4*widthptr;
+	sizeofAlg = 2*widthptr;
 	if(algarray == nil)
 		algarray = pkglookup("algarray", runtimepkg);
 	alg = algtype(t);
@@ -1242,7 +1242,6 @@ dalgsym(Type *t)
 {
 	int ot;
 	Sym *s, *hash, *hashfunc, *eq, *eqfunc;
-	char buf[100];
 
 	// dalgsym is only called for a type that needs an algorithm table,
 	// which implies that the type is comparable (or else it would use ANOEQ).
@@ -1261,24 +1260,10 @@ dalgsym(Type *t)
 	dsymptr(eqfunc, 0, eq, 0);
 	ggloblsym(eqfunc, widthptr, DUPOK|RODATA);
 
-	// ../../pkg/runtime/runtime.h:/Alg
+	// ../../pkg/runtime/alg.go:/typeAlg
 	ot = 0;
 	ot = dsymptr(s, ot, hashfunc, 0);
 	ot = dsymptr(s, ot, eqfunc, 0);
-	ot = dsymptr(s, ot, pkglookup("memprint", runtimepkg), 0);
-	switch(t->width) {
-	default:
-		ot = dsymptr(s, ot, pkglookup("memcopy", runtimepkg), 0);
-		break;
-	case 1:
-	case 2:
-	case 4:
-	case 8:
-	case 16:
-		snprint(buf, sizeof buf, "memcopy%d", (int)t->width*8);
-		ot = dsymptr(s, ot, pkglookup(buf, runtimepkg), 0);
-		break;
-	}
 
 	ggloblsym(s, ot, DUPOK|RODATA);
 	return s;
diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index 909612454d..01fbc931e5 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -11,6 +11,7 @@ const (
 	c1 = uintptr((8-ptrSize)/4*3267000013 + (ptrSize-4)/4*23344194077549503)
 )
 
+// type algorithms - known to compiler
 const (
 	alg_MEM = iota
 	alg_MEM0
@@ -37,9 +38,43 @@ const (
 	alg_max
 )
 
+type typeAlg struct {
+	// function for hashing objects of this type
+	// (ptr to object, size, seed) -> hash
+	hash func(unsafe.Pointer, uintptr, uintptr) uintptr
+	// function for comparing objects of this type
+	// (ptr to object A, ptr to object B, size) -> ==?
+	equal func(unsafe.Pointer, unsafe.Pointer, uintptr) bool
+}
+
+var algarray = [alg_max]typeAlg{
+	alg_MEM:      {memhash, memequal},
+	alg_MEM0:     {memhash, memequal0},
+	alg_MEM8:     {memhash, memequal8},
+	alg_MEM16:    {memhash, memequal16},
+	alg_MEM32:    {memhash, memequal32},
+	alg_MEM64:    {memhash, memequal64},
+	alg_MEM128:   {memhash, memequal128},
+	alg_NOEQ:     {nil, nil},
+	alg_NOEQ0:    {nil, nil},
+	alg_NOEQ8:    {nil, nil},
+	alg_NOEQ16:   {nil, nil},
+	alg_NOEQ32:   {nil, nil},
+	alg_NOEQ64:   {nil, nil},
+	alg_NOEQ128:  {nil, nil},
+	alg_STRING:   {strhash, strequal},
+	alg_INTER:    {interhash, interequal},
+	alg_NILINTER: {nilinterhash, nilinterequal},
+	alg_SLICE:    {nil, nil},
+	alg_FLOAT32:  {f32hash, f32equal},
+	alg_FLOAT64:  {f64hash, f64equal},
+	alg_CPLX64:   {c64hash, c64equal},
+	alg_CPLX128:  {c128hash, c128equal},
+}
+
 const nacl = GOOS == "nacl"
 
-var use_aeshash bool
+var useAeshash bool
 
 // in asm_*.s
 func aeshash(p unsafe.Pointer, s, h uintptr) uintptr
@@ -48,7 +83,7 @@ func aeshash64(p unsafe.Pointer, s, h uintptr) uintptr
 func aeshashstr(p unsafe.Pointer, s, h uintptr) uintptr
 
 func memhash(p unsafe.Pointer, s, h uintptr) uintptr {
-	if !nacl && use_aeshash {
+	if !nacl && useAeshash {
 		return aeshash(p, s, h)
 	}
 
@@ -61,8 +96,8 @@ func memhash(p unsafe.Pointer, s, h uintptr) uintptr {
 	return h
 }
 
-func strhash(a *string, s, h uintptr) uintptr {
-	return memhash((*stringStruct)(unsafe.Pointer(a)).str, uintptr(len(*a)), h)
+func strhash(a unsafe.Pointer, s, h uintptr) uintptr {
+	return memhash((*stringStruct)(a).str, uintptr(len(*(*string)(a))), h)
 }
 
 // NOTE: Because NaN != NaN, a map can contain any
@@ -70,54 +105,49 @@ func strhash(a *string, s, h uintptr) uintptr {
 // To avoid long hash chains, we assign a random number
 // as the hash value for a NaN.
 
-func f32hash(a *float32, s, h uintptr) uintptr {
-	f := *a
+func f32hash(p unsafe.Pointer, s, h uintptr) uintptr {
+	f := *(*float32)(p)
 	switch {
 	case f == 0:
 		return c1 * (c0 ^ h) // +0, -0
 	case f != f:
 		return c1 * (c0 ^ h ^ uintptr(fastrand2())) // any kind of NaN
 	default:
-		return memhash(unsafe.Pointer(a), 4, h)
+		return memhash(p, 4, h)
 	}
 }
 
-func f64hash(a *float64, s, h uintptr) uintptr {
-	f := *a
+func f64hash(p unsafe.Pointer, s, h uintptr) uintptr {
+	f := *(*float64)(p)
 	switch {
 	case f == 0:
 		return c1 * (c0 ^ h) // +0, -0
 	case f != f:
 		return c1 * (c0 ^ h ^ uintptr(fastrand2())) // any kind of NaN
 	default:
-		return memhash(unsafe.Pointer(a), 8, h)
+		return memhash(p, 8, h)
 	}
 }
 
-func c64hash(a *complex64, s, h uintptr) uintptr {
-	x := (*[2]float32)(unsafe.Pointer(a))
-	return f32hash(&x[1], 4, f32hash(&x[0], 4, h))
+func c64hash(p unsafe.Pointer, s, h uintptr) uintptr {
+	x := (*[2]float32)(p)
+	return f32hash(unsafe.Pointer(&x[1]), 4, f32hash(unsafe.Pointer(&x[0]), 4, h))
 }
 
-func c128hash(a *complex128, s, h uintptr) uintptr {
-	x := (*[2]float64)(unsafe.Pointer(a))
-	return f64hash(&x[1], 4, f64hash(&x[0], 4, h))
+func c128hash(p unsafe.Pointer, s, h uintptr) uintptr {
+	x := (*[2]float64)(p)
+	return f64hash(unsafe.Pointer(&x[1]), 8, f64hash(unsafe.Pointer(&x[0]), 8, h))
 }
 
-func nohash(a unsafe.Pointer, s, h uintptr) uintptr {
-	panic(errorString("hash of unhashable type"))
-}
-
-func interhash(a *iface, s, h uintptr) uintptr {
+func interhash(p unsafe.Pointer, s, h uintptr) uintptr {
+	a := (*iface)(p)
 	tab := a.tab
 	if tab == nil {
 		return h
 	}
 	t := tab._type
 	fn := goalg(t.alg).hash
-	if **(**uintptr)(unsafe.Pointer(&fn)) == nohashcode {
-		// calling nohash will panic too,
-		// but we can print a better error.
+	if fn == nil {
 		panic(errorString("hash of unhashable type " + *t._string))
 	}
 	if isDirectIface(t) {
@@ -127,15 +157,14 @@ func interhash(a *iface, s, h uintptr) uintptr {
 	}
 }
 
-func nilinterhash(a *eface, s, h uintptr) uintptr {
+func nilinterhash(p unsafe.Pointer, s, h uintptr) uintptr {
+	a := (*eface)(p)
 	t := a._type
 	if t == nil {
 		return h
 	}
 	fn := goalg(t.alg).hash
-	if **(**uintptr)(unsafe.Pointer(&fn)) == nohashcode {
-		// calling nohash will panic too,
-		// but we can print a better error.
+	if fn == nil {
 		panic(errorString("hash of unhashable type " + *t._string))
 	}
 	if isDirectIface(t) {
@@ -206,9 +235,7 @@ func efaceeq(p, q interface{}) bool {
 		return true
 	}
 	eq := goalg(t.alg).equal
-	if **(**uintptr)(unsafe.Pointer(&eq)) == noequalcode {
-		// calling noequal will panic too,
-		// but we can print a better error.
+	if eq == nil {
 		panic(errorString("comparing uncomparable type " + *t._string))
 	}
 	if isDirectIface(t) {
@@ -230,9 +257,7 @@ func ifaceeq(p, q interface {
 	}
 	t := xtab._type
 	eq := goalg(t.alg).equal
-	if **(**uintptr)(unsafe.Pointer(&eq)) == noequalcode {
-		// calling noequal will panic too,
-		// but we can print a better error.
+	if eq == nil {
 		panic(errorString("comparing uncomparable type " + *t._string))
 	}
 	if isDirectIface(t) {
@@ -241,40 +266,36 @@ func ifaceeq(p, q interface {
 	return eq(x.data, y.data, uintptr(t.size))
 }
 
-func noequal(p, q unsafe.Pointer, size uintptr) bool {
-	panic(errorString("comparing uncomparable types"))
-}
-
 // Testing adapters for hash quality tests (see hash_test.go)
 func haveGoodHash() bool {
-	return use_aeshash
+	return useAeshash
 }
 
 func stringHash(s string, seed uintptr) uintptr {
-	return goalg(&algarray[alg_STRING]).hash(noescape(unsafe.Pointer(&s)), unsafe.Sizeof(s), seed)
+	return algarray[alg_STRING].hash(noescape(unsafe.Pointer(&s)), unsafe.Sizeof(s), seed)
 }
 
 func bytesHash(b []byte, seed uintptr) uintptr {
-	// TODO: use sliceStruct
-	return goalg(&algarray[alg_MEM]).hash(*(*unsafe.Pointer)(unsafe.Pointer(&b)), uintptr(len(b)), seed)
+	s := (*sliceStruct)(unsafe.Pointer(&b))
+	return algarray[alg_MEM].hash(s.array, uintptr(s.len), seed)
 }
 
 func int32Hash(i uint32, seed uintptr) uintptr {
-	return goalg(&algarray[alg_MEM32]).hash(noescape(unsafe.Pointer(&i)), 4, seed)
+	return algarray[alg_MEM32].hash(noescape(unsafe.Pointer(&i)), 4, seed)
 }
 
 func int64Hash(i uint64, seed uintptr) uintptr {
-	return goalg(&algarray[alg_MEM64]).hash(noescape(unsafe.Pointer(&i)), 8, seed)
+	return algarray[alg_MEM64].hash(noescape(unsafe.Pointer(&i)), 8, seed)
 }
 
 func efaceHash(i interface{}, seed uintptr) uintptr {
-	return goalg(&algarray[alg_NILINTER]).hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
+	return algarray[alg_NILINTER].hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
 }
 
 func ifaceHash(i interface {
 	F()
 }, seed uintptr) uintptr {
-	return goalg(&algarray[alg_INTER]).hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
+	return algarray[alg_INTER].hash(noescape(unsafe.Pointer(&i)), unsafe.Sizeof(i), seed)
 }
 
 // Testing adapter for memclr
@@ -282,3 +303,50 @@ func memclrBytes(b []byte) {
 	s := (*sliceStruct)(unsafe.Pointer(&b))
 	memclr(s.array, uintptr(s.len))
 }
+
+// TODO(dvyukov): remove when Type is converted to Go and contains *typeAlg.
+func goalg(a unsafe.Pointer) *typeAlg {
+	return (*typeAlg)(a)
+}
+
+// used in asm_{386,amd64}.s
+const hashRandomBytes = 32
+
+var aeskeysched [hashRandomBytes]byte
+
+//go:noescape
+func get_random_data(rnd *unsafe.Pointer, n *int32)
+
+func init() {
+	if theGoos == "nacl" {
+		return
+	}
+
+	// Install aes hash algorithm if we have the instructions we need
+	if (cpuid_ecx&(1<<25)) != 0 && // aes (aesenc)
+		(cpuid_ecx&(1<<9)) != 0 && // sse3 (pshufb)
+		(cpuid_ecx&(1<<19)) != 0 { // sse4.1 (pinsr{d,q})
+		useAeshash = true
+		algarray[alg_MEM].hash = aeshash
+		algarray[alg_MEM8].hash = aeshash
+		algarray[alg_MEM16].hash = aeshash
+		algarray[alg_MEM32].hash = aeshash32
+		algarray[alg_MEM64].hash = aeshash64
+		algarray[alg_MEM128].hash = aeshash
+		algarray[alg_STRING].hash = aeshashstr
+		// Initialize with random data so hash collisions will be hard to engineer.
+		var rnd unsafe.Pointer
+		var n int32
+		get_random_data(&rnd, &n)
+		if n > hashRandomBytes {
+			n = hashRandomBytes
+		}
+		memmove(unsafe.Pointer(&aeskeysched[0]), rnd, uintptr(n))
+		if n < hashRandomBytes {
+			// Not very random, but better than nothing.
+			for t := nanotime(); n < hashRandomBytes; n++ {
+				aeskeysched[n] = byte(t >> uint(8*(n%8)))
+			}
+		}
+	}
+}
diff --git a/src/pkg/runtime/alg.goc b/src/pkg/runtime/alg.goc
deleted file mode 100644
index 0c3b3cd4ff..0000000000
--- a/src/pkg/runtime/alg.goc
+++ /dev/null
@@ -1,289 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-#include "runtime.h"
-#include "type.h"
-#include "../../cmd/ld/textflag.h"
-
-bool runtime·use_aeshash;
-
-void
-runtime·memprint(uintptr s, void *a)
-{
-	uint64 v;
-
-	v = 0xbadb00b;
-	switch(s) {
-	case 1:
-		v = *(uint8*)a;
-		break;
-	case 2:
-		v = *(uint16*)a;
-		break;
-	case 4:
-		v = *(uint32*)a;
-		break;
-	case 8:
-		v = *(uint64*)a;
-		break;
-	}
-	runtime·printint(v);
-}
-
-void
-runtime·memcopy(uintptr s, void *a, void *b)
-{
-	if(b == nil) {
-		runtime·memclr(a, s);
-		return;
-	}
-	runtime·memmove(a, b, s);
-}
-
-void
-runtime·memcopy0(uintptr s, void *a, void *b)
-{
-	USED(s);
-	USED(a);
-	USED(b);
-}
-
-void
-runtime·memcopy8(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		*(uint8*)a = 0;
-		return;
-	}
-	*(uint8*)a = *(uint8*)b;
-}
-
-void
-runtime·memcopy16(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		*(uint16*)a = 0;
-		return;
-	}
-	*(uint16*)a = *(uint16*)b;
-}
-
-void
-runtime·memcopy32(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		*(uint32*)a = 0;
-		return;
-	}
-	*(uint32*)a = *(uint32*)b;
-}
-
-void
-runtime·memcopy64(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		*(uint64*)a = 0;
-		return;
-	}
-	*(uint64*)a = *(uint64*)b;
-}
-
-void
-runtime·memcopy128(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		((uint64*)a)[0] = 0;
-		((uint64*)a)[1] = 0;
-		return;
-	}
-	((uint64*)a)[0] = ((uint64*)b)[0];
-	((uint64*)a)[1] = ((uint64*)b)[1];
-}
-
-void
-runtime·algslicecopy(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		((Slice*)a)->array = 0;
-		((Slice*)a)->len = 0;
-		((Slice*)a)->cap = 0;
-		return;
-	}
-	((Slice*)a)->array = ((Slice*)b)->array;
-	((Slice*)a)->len = ((Slice*)b)->len;
-	((Slice*)a)->cap = ((Slice*)b)->cap;
-}
-
-void
-runtime·strprint(uintptr s, void *a)
-{
-	USED(s);
-	runtime·printstring(*(String*)a);
-}
-
-void
-runtime·strcopy(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		((String*)a)->str = 0;
-		((String*)a)->len = 0;
-		return;
-	}
-	((String*)a)->str = ((String*)b)->str;
-	((String*)a)->len = ((String*)b)->len;
-}
-
-void
-runtime·interprint(uintptr s, void *a)
-{
-	USED(s);
-	runtime·printiface(*(Iface*)a);
-}
-
-void
-runtime·intercopy(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		((Iface*)a)->tab = 0;
-		((Iface*)a)->data = 0;
-		return;
-	}
-	((Iface*)a)->tab = ((Iface*)b)->tab;
-	((Iface*)a)->data = ((Iface*)b)->data;
-}
-
-void
-runtime·nilinterprint(uintptr s, void *a)
-{
-	USED(s);
-	runtime·printeface(*(Eface*)a);
-}
-
-void
-runtime·nilintercopy(uintptr s, void *a, void *b)
-{
-	USED(s);
-	if(b == nil) {
-		((Eface*)a)->type = 0;
-		((Eface*)a)->data = 0;
-		return;
-	}
-	((Eface*)a)->type = ((Eface*)b)->type;
-	((Eface*)a)->data = ((Eface*)b)->data;
-}
-
-extern uintptr runtime·nohashcode;
-extern uintptr runtime·noequalcode;
-
-static FuncVal memhashfunc = {(void*)runtime·memhash};
-static FuncVal nohashfunc = {(void*)runtime·nohash};
-static FuncVal strhashfunc = {(void*)runtime·strhash};
-static FuncVal interhashfunc = {(void*)runtime·interhash};
-static FuncVal nilinterhashfunc = {(void*)runtime·nilinterhash};
-static FuncVal f32hashfunc = {(void*)runtime·f32hash};
-static FuncVal f64hashfunc = {(void*)runtime·f64hash};
-static FuncVal c64hashfunc = {(void*)runtime·c64hash};
-static FuncVal c128hashfunc = {(void*)runtime·c128hash};
-
-static FuncVal aeshashfunc = {(void*)runtime·aeshash};
-static FuncVal aeshash32func = {(void*)runtime·aeshash32};
-static FuncVal aeshash64func = {(void*)runtime·aeshash64};
-static FuncVal aeshashstrfunc = {(void*)runtime·aeshashstr};
-
-static FuncVal memequalfunc = {(void*)runtime·memequal};
-static FuncVal noequalfunc = {(void*)runtime·noequal};
-static FuncVal strequalfunc = {(void*)runtime·strequal};
-static FuncVal interequalfunc = {(void*)runtime·interequal};
-static FuncVal nilinterequalfunc = {(void*)runtime·nilinterequal};
-static FuncVal f32equalfunc = {(void*)runtime·f32equal};
-static FuncVal f64equalfunc = {(void*)runtime·f64equal};
-static FuncVal c64equalfunc = {(void*)runtime·c64equal};
-static FuncVal c128equalfunc = {(void*)runtime·c128equal};
-static FuncVal memequal0func = {(void*)runtime·memequal0};
-static FuncVal memequal8func = {(void*)runtime·memequal8};
-static FuncVal memequal16func = {(void*)runtime·memequal16};
-static FuncVal memequal32func = {(void*)runtime·memequal32};
-static FuncVal memequal64func = {(void*)runtime·memequal64};
-static FuncVal memequal128func = {(void*)runtime·memequal128};
-
-
-Alg
-runtime·algarray[] =
-{
-[AMEM]		{ &memhashfunc, &memequalfunc, runtime·memprint, runtime·memcopy },
-[ANOEQ]		{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy },
-[ASTRING]	{ &strhashfunc, &strequalfunc, runtime·strprint, runtime·strcopy },
-[AINTER]	{ &interhashfunc, &interequalfunc, runtime·interprint, runtime·intercopy },
-[ANILINTER]	{ &nilinterhashfunc, &nilinterequalfunc, runtime·nilinterprint, runtime·nilintercopy },
-[ASLICE]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·algslicecopy },
-[AFLOAT32]	{ &f32hashfunc, &f32equalfunc, runtime·memprint, runtime·memcopy },
-[AFLOAT64]	{ &f64hashfunc, &f64equalfunc, runtime·memprint, runtime·memcopy },
-[ACPLX64]	{ &c64hashfunc, &c64equalfunc, runtime·memprint, runtime·memcopy },
-[ACPLX128]	{ &c128hashfunc, &c128equalfunc, runtime·memprint, runtime·memcopy },
-[AMEM0]		{ &memhashfunc, &memequal0func, runtime·memprint, runtime·memcopy0 },
-[AMEM8]		{ &memhashfunc, &memequal8func, runtime·memprint, runtime·memcopy8 },
-[AMEM16]	{ &memhashfunc, &memequal16func, runtime·memprint, runtime·memcopy16 },
-[AMEM32]	{ &memhashfunc, &memequal32func, runtime·memprint, runtime·memcopy32 },
-[AMEM64]	{ &memhashfunc, &memequal64func, runtime·memprint, runtime·memcopy64 },
-[AMEM128]	{ &memhashfunc, &memequal128func, runtime·memprint, runtime·memcopy128 },
-[ANOEQ0]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy0 },
-[ANOEQ8]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy8 },
-[ANOEQ16]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy16 },
-[ANOEQ32]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy32 },
-[ANOEQ64]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy64 },
-[ANOEQ128]	{ &nohashfunc, &noequalfunc, runtime·memprint, runtime·memcopy128 },
-};
-
-// Runtime helpers.
-
-// used in asm_{386,amd64}.s
-#pragma dataflag NOPTR
-byte runtime·aeskeysched[HashRandomBytes];
-
-void
-runtime·hashinit(void)
-{
-	runtime·nohashcode = (uintptr)runtime·nohash;
-	runtime·noequalcode = (uintptr)runtime·noequal;
-
-        if(NaCl)
-                return;
-
-	// Install aes hash algorithm if we have the instructions we need
-	if((runtime·cpuid_ecx & (1 << 25)) != 0 &&  // aes (aesenc)
-	   (runtime·cpuid_ecx & (1 << 9)) != 0 &&   // sse3 (pshufb)
-	   (runtime·cpuid_ecx & (1 << 19)) != 0) {  // sse4.1 (pinsr{d,q})
-		byte *rnd;
-		int32 n;
-		runtime·use_aeshash = true;
-		runtime·algarray[AMEM].hash = &aeshashfunc;
-		runtime·algarray[AMEM8].hash = &aeshashfunc;
-		runtime·algarray[AMEM16].hash = &aeshashfunc;
-		runtime·algarray[AMEM32].hash = &aeshash32func;
-		runtime·algarray[AMEM64].hash = &aeshash64func;
-		runtime·algarray[AMEM128].hash = &aeshashfunc;
-		runtime·algarray[ASTRING].hash = &aeshashstrfunc;
-		// Initialize with random data so hash collisions will be hard to engineer.
-		runtime·get_random_data(&rnd, &n);
-		if(n > HashRandomBytes)
-			n = HashRandomBytes;
-		runtime·memmove(runtime·aeskeysched, rnd, n);
-		if(n < HashRandomBytes) {
-			// Not very random, but better than nothing.
-			int64 t = runtime·nanotime();
-			while (n < HashRandomBytes) {
-				runtime·aeskeysched[n++] = (int8)(t >> (8 * (n % 8)));
-			}
-		}
-	}
-}
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index b40b75521a..d80020ccd6 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -92,7 +92,6 @@ ok:
 	MOVL	AX, 4(SP)
 	CALL	runtime·args(SB)
 	CALL	runtime·osinit(SB)
-	CALL	runtime·hashinit(SB)
 	CALL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 01ec391153..bc17c68f3d 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -88,7 +88,6 @@ ok:
 	MOVQ	AX, 8(SP)
 	CALL	runtime·args(SB)
 	CALL	runtime·osinit(SB)
-	CALL	runtime·hashinit(SB)
 	CALL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 9073144cff..82c0d77cdd 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -68,7 +68,6 @@ ok:
 	MOVL	AX, 4(SP)
 	CALL	runtime·args(SB)
 	CALL	runtime·osinit(SB)
-	CALL	runtime·hashinit(SB)
 	CALL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 702eda61bd..f8447d7940 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -64,7 +64,6 @@ nocgo:
 	MOVW	R1, 8(R13)
 	BL	runtime·args(SB)
 	BL	runtime·osinit(SB)
-	BL	runtime·hashinit(SB)
 	BL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index a4a0d1d9ba..383351179d 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -51,12 +51,6 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 		return false;  // not reached
 	}
 
-	if(debug) {
-		runtime·printf("chansend: chan=%p; elem=", c);
-		c->elemtype->alg->print(c->elemsize, ep);
-		runtime·prints("\n");
-	}
-
 	if(raceenabled)
 		runtime·racereadpc(c, pc, chansend);
 
@@ -101,7 +95,7 @@ chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
 		gp = sg->g;
 		gp->param = sg;
 		if(sg->elem != nil)
-			c->elemtype->alg->copy(c->elemsize, sg->elem, ep);
+			runtime·memmove(sg->elem, ep, c->elemsize);
 		if(sg->releasetime)
 			sg->releasetime = runtime·cputicks();
 		runtime·ready(gp);
@@ -156,7 +150,7 @@ asynch:
 		runtime·racerelease(chanbuf(c, c->sendx));
 	}
 
-	c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->sendx), ep);
+	runtime·memmove(chanbuf(c, c->sendx), ep, c->elemsize);
 	if(++c->sendx == c->dataqsiz)
 		c->sendx = 0;
 	c->qcount++;
@@ -240,7 +234,7 @@ chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
 		runtime·unlock(&c->lock);
 
 		if(ep != nil)
-			c->elemtype->alg->copy(c->elemsize, ep, sg->elem);
+			runtime·memmove(ep, sg->elem, c->elemsize);
 		gp = sg->g;
 		gp->param = sg;
 		if(sg->releasetime)
@@ -304,8 +298,8 @@ asynch:
 	}
 
 	if(ep != nil)
-		c->elemtype->alg->copy(c->elemsize, ep, chanbuf(c, c->recvx));
-	c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->recvx), nil);
+		runtime·memmove(ep, chanbuf(c, c->recvx), c->elemsize);
+	runtime·memclr(chanbuf(c, c->recvx), c->elemsize);
 	if(++c->recvx == c->dataqsiz)
 		c->recvx = 0;
 	c->qcount--;
@@ -328,7 +322,7 @@ asynch:
 
 closed:
 	if(ep != nil)
-		c->elemtype->alg->copy(c->elemsize, ep, nil);
+		runtime·memclr(ep, c->elemsize);
 	if(received != nil)
 		*received = false;
 	if(raceenabled)
@@ -842,8 +836,8 @@ asyncrecv:
 	if(cas->receivedp != nil)
 		*cas->receivedp = true;
 	if(cas->sg.elem != nil)
-		c->elemtype->alg->copy(c->elemsize, cas->sg.elem, chanbuf(c, c->recvx));
-	c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->recvx), nil);
+		runtime·memmove(cas->sg.elem, chanbuf(c, c->recvx), c->elemsize);
+	runtime·memclr(chanbuf(c, c->recvx), c->elemsize);
 	if(++c->recvx == c->dataqsiz)
 		c->recvx = 0;
 	c->qcount--;
@@ -866,7 +860,7 @@ asyncsend:
 		runtime·racerelease(chanbuf(c, c->sendx));
 		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, chansend);
 	}
-	c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->sendx), cas->sg.elem);
+	runtime·memmove(chanbuf(c, c->sendx), cas->sg.elem, c->elemsize);
 	if(++c->sendx == c->dataqsiz)
 		c->sendx = 0;
 	c->qcount++;
@@ -895,7 +889,7 @@ syncrecv:
 	if(cas->receivedp != nil)
 		*cas->receivedp = true;
 	if(cas->sg.elem != nil)
-		c->elemtype->alg->copy(c->elemsize, cas->sg.elem, sg->elem);
+		runtime·memmove(cas->sg.elem, sg->elem, c->elemsize);
 	gp = sg->g;
 	gp->param = sg;
 	if(sg->releasetime)
@@ -909,7 +903,7 @@ rclose:
 	if(cas->receivedp != nil)
 		*cas->receivedp = false;
 	if(cas->sg.elem != nil)
-		c->elemtype->alg->copy(c->elemsize, cas->sg.elem, nil);
+		runtime·memclr(cas->sg.elem, c->elemsize);
 	if(raceenabled)
 		runtime·raceacquire(c);
 	goto retc;
@@ -924,7 +918,7 @@ syncsend:
 	if(debug)
 		runtime·printf("syncsend: sel=%p c=%p o=%d\n", sel, c, o);
 	if(sg->elem != nil)
-		c->elemtype->alg->copy(c->elemsize, sg->elem, cas->sg.elem);
+		runtime·memmove(sg->elem, cas->sg.elem, c->elemsize);
 	gp = sg->g;
 	gp->param = sg;
 	if(sg->releasetime)
diff --git a/src/pkg/runtime/hashmap.go b/src/pkg/runtime/hashmap.go
index 1d1e708487..309e26db96 100644
--- a/src/pkg/runtime/hashmap.go
+++ b/src/pkg/runtime/hashmap.go
@@ -896,7 +896,7 @@ func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
 }
 
 func ismapkey(t *_type) bool {
-	return **(**uintptr)(unsafe.Pointer(&t.alg.hash)) != nohashcode
+	return goalg(t.alg).hash != nil
 }
 
 // Reflect stubs.  Called from ../reflect/asm_*.s
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 3f03a4da06..80366a549d 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -606,101 +606,13 @@ enum {
 	Structrnd = sizeof(uintreg),
 };
 
-/*
- * type algorithms - known to compiler
- */
-enum
-{
-	AMEM,
-	AMEM0,
-	AMEM8,
-	AMEM16,
-	AMEM32,
-	AMEM64,
-	AMEM128,
-	ANOEQ,
-	ANOEQ0,
-	ANOEQ8,
-	ANOEQ16,
-	ANOEQ32,
-	ANOEQ64,
-	ANOEQ128,
-	ASTRING,
-	AINTER,
-	ANILINTER,
-	ASLICE,
-	AFLOAT32,
-	AFLOAT64,
-	ACPLX64,
-	ACPLX128,
-	Amax
-};
-typedef	struct	Alg		Alg;
-struct	Alg
-{
-	FuncVal* hash;
-	FuncVal* equal;
-	void	(*print)(uintptr, void*);
-	void	(*copy)(uintptr, void*, void*);
-};
-
-extern	Alg	runtime·algarray[Amax];
-
 byte*	runtime·startup_random_data;
 uint32	runtime·startup_random_data_len;
-void	runtime·get_random_data(byte**, int32*);
 
 enum {
 	// hashinit wants this many random bytes
 	HashRandomBytes = 32
 };
-void	runtime·hashinit(void);
-
-void	runtime·memhash(void*, uintptr, uintptr, uintptr);
-void	runtime·nohash(void*, uintptr, uintptr, uintptr);
-void	runtime·strhash(void*, uintptr, uintptr, uintptr);
-void	runtime·interhash(void*, uintptr, uintptr, uintptr);
-void	runtime·nilinterhash(void*, uintptr, uintptr, uintptr);
-void	runtime·f32hash(void*, uintptr, uintptr, uintptr);
-void	runtime·f64hash(void*, uintptr, uintptr, uintptr);
-void	runtime·c64hash(void*, uintptr, uintptr, uintptr);
-void	runtime·c128hash(void*, uintptr, uintptr, uintptr);
-void	runtime·aeshash(void*, uintptr, uintptr, uintptr);
-void	runtime·aeshash32(void*, uintptr, uintptr, uintptr);
-void	runtime·aeshash64(void*, uintptr, uintptr, uintptr);
-void	runtime·aeshashstr(void*, uintptr, uintptr, uintptr);
-
-void	runtime·memequal(void*, void*, uintptr, bool);
-void	runtime·noequal(void*, void*, uintptr, bool);
-void	runtime·strequal(void*, void*, uintptr, bool);
-void	runtime·interequal(void*, void*, uintptr, bool);
-void	runtime·nilinterequal(void*, void*, uintptr, bool);
-void	runtime·f32equal(void*, void*, uintptr, bool);
-void	runtime·f64equal(void*, void*, uintptr, bool);
-void	runtime·c64equal(void*, void*, uintptr, bool);
-void	runtime·c128equal(void*, void*, uintptr, bool);
-void	runtime·memequal0(void*, void*, uintptr, bool);
-void	runtime·memequal8(void*, void*, uintptr, bool);
-void	runtime·memequal16(void*, void*, uintptr, bool);
-void	runtime·memequal32(void*, void*, uintptr, bool);
-void	runtime·memequal64(void*, void*, uintptr, bool);
-void	runtime·memequal128(void*, void*, uintptr, bool);
-
-void	runtime·memprint(uintptr, void*);
-void	runtime·strprint(uintptr, void*);
-void	runtime·interprint(uintptr, void*);
-void	runtime·nilinterprint(uintptr, void*);
-
-void	runtime·memcopy(uintptr, void*, void*);
-void	runtime·memcopy8(uintptr, void*, void*);
-void	runtime·memcopy16(uintptr, void*, void*);
-void	runtime·memcopy32(uintptr, void*, void*);
-void	runtime·memcopy64(uintptr, void*, void*);
-void	runtime·memcopy128(uintptr, void*, void*);
-void	runtime·strcopy(uintptr, void*, void*);
-void	runtime·algslicecopy(uintptr, void*, void*);
-void	runtime·intercopy(uintptr, void*, void*);
-void	runtime·nilintercopy(uintptr, void*, void*);
 
 uint32  runtime·readgstatus(G *gp);
 void    runtime·casgstatus(G*, uint32, uint32);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 90d43ea713..9ad400639d 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -131,23 +131,6 @@ var noequalcode uintptr
 // in panic.c
 func gothrow(s string)
 
-// Return the Go equivalent of the C Alg structure.
-// TODO: at some point Go will hold the truth for the layout
-// of runtime structures and C will be derived from it (if
-// needed at all).  At that point this function can go away.
-type goalgtype struct {
-	// function for hashing objects of this type
-	// (ptr to object, size, seed) -> hash
-	hash func(unsafe.Pointer, uintptr, uintptr) uintptr
-	// function for comparing objects of this type
-	// (ptr to object A, ptr to object B, size) -> ==?
-	equal func(unsafe.Pointer, unsafe.Pointer, uintptr) bool
-}
-
-func goalg(a *alg) *goalgtype {
-	return (*goalgtype)(unsafe.Pointer(a))
-}
-
 // noescape hides a pointer from escape analysis.  noescape is
 // the identity function but escape analysis doesn't think the
 // output depends on the input.  noescape is inlined and currently
diff --git a/src/pkg/runtime/type.h b/src/pkg/runtime/type.h
index 1da37323eb..de82e886f2 100644
--- a/src/pkg/runtime/type.h
+++ b/src/pkg/runtime/type.h
@@ -21,7 +21,7 @@ struct Type
 	uint8 align;
 	uint8 fieldAlign;
 	uint8 kind;
-	Alg *alg;
+	void* alg;
 	// gc stores type info required for garbage collector.
 	// If (kind&KindGCProg)==0, then gc directly contains sparse GC bitmap
 	// (no indirection), 4 bits per word.

From 0316dafda26619175f35e5e89f1920ebf37c85a3 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Aug 2014 00:54:40 -0400
Subject: [PATCH 300/423] runtime: rename SysAlloc to sysAlloc for Go

Renaming the C SysAlloc will let Go define a prototype without exporting it.
For use in cpuprof.goc's translation to Go.

LGTM=mdempsky
R=golang-codereviews, mdempsky
CC=golang-codereviews, iant
https://golang.org/cl/140060043
---
 src/pkg/runtime/cpuprof.goc     |  2 +-
 src/pkg/runtime/heapdump.c      |  2 +-
 src/pkg/runtime/malloc.c        |  8 ++++----
 src/pkg/runtime/malloc.h        | 14 +++++++-------
 src/pkg/runtime/mem_darwin.c    |  2 +-
 src/pkg/runtime/mem_dragonfly.c |  2 +-
 src/pkg/runtime/mem_freebsd.c   |  2 +-
 src/pkg/runtime/mem_linux.c     |  2 +-
 src/pkg/runtime/mem_nacl.c      |  6 +++---
 src/pkg/runtime/mem_netbsd.c    |  2 +-
 src/pkg/runtime/mem_openbsd.c   |  2 +-
 src/pkg/runtime/mem_plan9.c     |  4 ++--
 src/pkg/runtime/mem_solaris.c   |  2 +-
 src/pkg/runtime/mem_windows.c   |  2 +-
 src/pkg/runtime/mheap.c         |  2 +-
 src/pkg/runtime/mprof.goc       |  2 +-
 src/pkg/runtime/stack.c         |  2 +-
 17 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/pkg/runtime/cpuprof.goc b/src/pkg/runtime/cpuprof.goc
index 8ae06edcb1..0d6d078ffd 100644
--- a/src/pkg/runtime/cpuprof.goc
+++ b/src/pkg/runtime/cpuprof.goc
@@ -137,7 +137,7 @@ runtime·SetCPUProfileRate(intgo hz)
 	runtime·lock(&lk);
 	if(hz > 0) {
 		if(prof == nil) {
-			prof = runtime·SysAlloc(sizeof *prof, &mstats.other_sys);
+			prof = runtime·sysAlloc(sizeof *prof, &mstats.other_sys);
 			if(prof == nil) {
 				runtime·printf("runtime: cpu profiling cannot allocate memory\n");
 				runtime·unlock(&lk);
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index fe67e15f35..29a9ae6476 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -825,7 +825,7 @@ makeheapobjbv(byte *p, uintptr size)
 		if(tmpbuf != nil)
 			runtime·SysFree(tmpbuf, tmpbufsize, &mstats.other_sys);
 		tmpbufsize = nptr*BitsPerPointer/8+1;
-		tmpbuf = runtime·SysAlloc(tmpbufsize, &mstats.other_sys);
+		tmpbuf = runtime·sysAlloc(tmpbufsize, &mstats.other_sys);
 		if(tmpbuf == nil)
 			runtime·throw("heapdump: out of memory");
 	}
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 143d9e5e9e..8210081553 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -320,7 +320,7 @@ runtime·MHeap_SysAlloc(MHeap *h, uintptr n)
 	// try to get memory at a location chosen by the OS
 	// and hope that it is in the range we allocated bitmap for.
 	p_size = ROUND(n, PageSize) + PageSize;
-	p = runtime·SysAlloc(p_size, &mstats.heap_sys);
+	p = runtime·sysAlloc(p_size, &mstats.heap_sys);
 	if(p == nil)
 		return nil;
 
@@ -361,7 +361,7 @@ enum
 	PersistentAllocMaxBlock	= 64<<10,  // VM reservation granularity is 64K on windows
 };
 
-// Wrapper around SysAlloc that can allocate small chunks.
+// Wrapper around sysAlloc that can allocate small chunks.
 // There is no associated free operation.
 // Intended for things like function/type/debug-related persistent data.
 // If align is 0, uses default align (currently 8).
@@ -378,11 +378,11 @@ runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat)
 	} else
 		align = 8;
 	if(size >= PersistentAllocMaxBlock)
-		return runtime·SysAlloc(size, stat);
+		return runtime·sysAlloc(size, stat);
 	runtime·lock(&persistent.lock);
 	persistent.pos = (byte*)ROUND((uintptr)persistent.pos, align);
 	if(persistent.pos + size > persistent.end) {
-		persistent.pos = runtime·SysAlloc(PersistentAllocChunk, &mstats.other_sys);
+		persistent.pos = runtime·sysAlloc(PersistentAllocChunk, &mstats.other_sys);
 		if(persistent.pos == nil) {
 			runtime·unlock(&persistent.lock);
 			runtime·throw("runtime: cannot allocate memory");
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 6cd72fb31f..6994557459 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -160,12 +160,12 @@ struct MLink
 	MLink *next;
 };
 
-// SysAlloc obtains a large chunk of zeroed memory from the
+// sysAlloc obtains a large chunk of zeroed memory from the
 // operating system, typically on the order of a hundred kilobytes
 // or a megabyte.
-// NOTE: SysAlloc returns OS-aligned memory, but the heap allocator
+// NOTE: sysAlloc returns OS-aligned memory, but the heap allocator
 // may use larger alignment, so the caller must be careful to realign the
-// memory obtained by SysAlloc.
+// memory obtained by sysAlloc.
 //
 // SysUnused notifies the operating system that the contents
 // of the memory region are no longer needed and can be reused
@@ -187,16 +187,16 @@ struct MLink
 // reserved, false if it has merely been checked.
 // NOTE: SysReserve returns OS-aligned memory, but the heap allocator
 // may use larger alignment, so the caller must be careful to realign the
-// memory obtained by SysAlloc.
+// memory obtained by sysAlloc.
 //
 // SysMap maps previously reserved address space for use.
 // The reserved argument is true if the address space was really
 // reserved, not merely checked.
 //
-// SysFault marks a (already SysAlloc'd) region to fault
+// SysFault marks a (already sysAlloc'd) region to fault
 // if accessed.  Used only for debugging the runtime.
 
-void*	runtime·SysAlloc(uintptr nbytes, uint64 *stat);
+void*	runtime·sysAlloc(uintptr nbytes, uint64 *stat);
 void	runtime·SysFree(void *v, uintptr nbytes, uint64 *stat);
 void	runtime·SysUnused(void *v, uintptr nbytes);
 void	runtime·SysUsed(void *v, uintptr nbytes);
@@ -205,7 +205,7 @@ void*	runtime·SysReserve(void *v, uintptr nbytes, bool *reserved);
 void	runtime·SysFault(void *v, uintptr nbytes);
 
 // FixAlloc is a simple free-list allocator for fixed size objects.
-// Malloc uses a FixAlloc wrapped around SysAlloc to manages its
+// Malloc uses a FixAlloc wrapped around sysAlloc to manages its
 // MCache and MSpan objects.
 //
 // Memory returned by FixAlloc_Alloc is not zeroed.
diff --git a/src/pkg/runtime/mem_darwin.c b/src/pkg/runtime/mem_darwin.c
index 878c4e1c55..ca0ac72de9 100644
--- a/src/pkg/runtime/mem_darwin.c
+++ b/src/pkg/runtime/mem_darwin.c
@@ -9,7 +9,7 @@
 #include "malloc.h"
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
diff --git a/src/pkg/runtime/mem_dragonfly.c b/src/pkg/runtime/mem_dragonfly.c
index c270332cb9..55410cef64 100644
--- a/src/pkg/runtime/mem_dragonfly.c
+++ b/src/pkg/runtime/mem_dragonfly.c
@@ -14,7 +14,7 @@ enum
 };
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
diff --git a/src/pkg/runtime/mem_freebsd.c b/src/pkg/runtime/mem_freebsd.c
index 586947a2dc..a033bfcdc0 100644
--- a/src/pkg/runtime/mem_freebsd.c
+++ b/src/pkg/runtime/mem_freebsd.c
@@ -14,7 +14,7 @@ enum
 };
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
diff --git a/src/pkg/runtime/mem_linux.c b/src/pkg/runtime/mem_linux.c
index 635594c365..429f820f8b 100644
--- a/src/pkg/runtime/mem_linux.c
+++ b/src/pkg/runtime/mem_linux.c
@@ -58,7 +58,7 @@ mmap_fixed(byte *v, uintptr n, int32 prot, int32 flags, int32 fd, uint32 offset)
 }
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *p;
 
diff --git a/src/pkg/runtime/mem_nacl.c b/src/pkg/runtime/mem_nacl.c
index e2bca40a49..5c5f806324 100644
--- a/src/pkg/runtime/mem_nacl.c
+++ b/src/pkg/runtime/mem_nacl.c
@@ -14,19 +14,19 @@ enum
 };
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
 	v = runtime·mmap(nil, n, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
 	if(v < (void*)4096) {
 		if(Debug)
-			runtime·printf("SysAlloc(%p): %p\n", n, v);
+			runtime·printf("sysAlloc(%p): %p\n", n, v);
 		return nil;
 	}
 	runtime·xadd64(stat, n);
 	if(Debug)
-		runtime·printf("SysAlloc(%p) = %p\n", n, v);
+		runtime·printf("sysAlloc(%p) = %p\n", n, v);
 	return v;
 }
 
diff --git a/src/pkg/runtime/mem_netbsd.c b/src/pkg/runtime/mem_netbsd.c
index 861ae90c7e..cf4b24f920 100644
--- a/src/pkg/runtime/mem_netbsd.c
+++ b/src/pkg/runtime/mem_netbsd.c
@@ -14,7 +14,7 @@ enum
 };
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
diff --git a/src/pkg/runtime/mem_openbsd.c b/src/pkg/runtime/mem_openbsd.c
index 861ae90c7e..cf4b24f920 100644
--- a/src/pkg/runtime/mem_openbsd.c
+++ b/src/pkg/runtime/mem_openbsd.c
@@ -14,7 +14,7 @@ enum
 };
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
diff --git a/src/pkg/runtime/mem_plan9.c b/src/pkg/runtime/mem_plan9.c
index 8d31bcfe2d..aec652995f 100644
--- a/src/pkg/runtime/mem_plan9.c
+++ b/src/pkg/runtime/mem_plan9.c
@@ -36,7 +36,7 @@ brk(uintptr nbytes)
 }
 
 void*
-runtime·SysAlloc(uintptr nbytes, uint64 *stat)
+runtime·sysAlloc(uintptr nbytes, uint64 *stat)
 {
 	void *p;
 
@@ -53,7 +53,7 @@ runtime·SysFree(void *v, uintptr nbytes, uint64 *stat)
 	runtime·lock(&memlock);
 	// from tiny/mem.c
 	// Push pointer back if this is a free
-	// of the most recent SysAlloc.
+	// of the most recent sysAlloc.
 	nbytes += (nbytes + Round) & ~Round;
 	if(bloc == (byte*)v+nbytes)
 		bloc -= nbytes;
diff --git a/src/pkg/runtime/mem_solaris.c b/src/pkg/runtime/mem_solaris.c
index 034222887b..87536f6837 100644
--- a/src/pkg/runtime/mem_solaris.c
+++ b/src/pkg/runtime/mem_solaris.c
@@ -14,7 +14,7 @@ enum
 };
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	void *v;
 
diff --git a/src/pkg/runtime/mem_windows.c b/src/pkg/runtime/mem_windows.c
index 5eb43b2a93..cb1c9de907 100644
--- a/src/pkg/runtime/mem_windows.c
+++ b/src/pkg/runtime/mem_windows.c
@@ -26,7 +26,7 @@ extern void *runtime·VirtualFree;
 extern void *runtime·VirtualProtect;
 
 void*
-runtime·SysAlloc(uintptr n, uint64 *stat)
+runtime·sysAlloc(uintptr n, uint64 *stat)
 {
 	runtime·xadd64(stat, n);
 	return runtime·stdcall4(runtime·VirtualAlloc, 0, n, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 90acd55f9f..9b165d6cad 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -36,7 +36,7 @@ RecordSpan(void *vh, byte *p)
 		cap = 64*1024/sizeof(all[0]);
 		if(cap < h->nspancap*3/2)
 			cap = h->nspancap*3/2;
-		all = (MSpan**)runtime·SysAlloc(cap*sizeof(all[0]), &mstats.other_sys);
+		all = (MSpan**)runtime·sysAlloc(cap*sizeof(all[0]), &mstats.other_sys);
 		if(all == nil)
 			runtime·throw("runtime: cannot allocate memory");
 		if(h->allspans) {
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index a340ebdafb..589863a156 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -38,7 +38,7 @@ stkbucket(int32 typ, uintptr size, uintptr *stk, int32 nstk, bool alloc)
 	Bucket *b;
 
 	if(buckhash == nil) {
-		buckhash = runtime·SysAlloc(BuckHashSize*sizeof buckhash[0], &mstats.buckhash_sys);
+		buckhash = runtime·sysAlloc(BuckHashSize*sizeof buckhash[0], &mstats.buckhash_sys);
 		if(buckhash == nil)
 			runtime·throw("runtime: cannot allocate memory");
 	}
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 96f1946db2..e499b1f8b6 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -206,7 +206,7 @@ runtime·stackalloc(G *gp, uint32 n)
 
 	gp->stacksize += n;
 	if(runtime·debug.efence || StackFromSystem) {
-		v = runtime·SysAlloc(ROUND(n, PageSize), &mstats.stacks_sys);
+		v = runtime·sysAlloc(ROUND(n, PageSize), &mstats.stacks_sys);
 		if(v == nil)
 			runtime·throw("out of memory (stackalloc)");
 		return v;

From 397bdb216f705a3e3221c98904237820d4950042 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Aug 2014 00:56:52 -0400
Subject: [PATCH 301/423] runtime: increase nosplit area to 192

In CL 131450043, which raised it to 160,
I'd raise it to 192 if necessary.
Apparently it is necessary on windows/amd64.

One note for those concerned about the growth:
in the old segmented stack world, we wasted this much
space at the bottom of every stack segment.
In the new contiguous stack world, each goroutine has
only one stack segment, so we only waste this much space
once per goroutine. So even raising the limit further might
still be a net savings.

Fixes windows/amd64 build.

TBR=r
CC=golang-codereviews
https://golang.org/cl/132480043
---
 src/pkg/runtime/stack.go      | 2 +-
 src/pkg/runtime/stack.h       | 4 ++--
 src/pkg/runtime/stack_test.go | 2 +-
 test/nosplit.go               | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/stack.go b/src/pkg/runtime/stack.go
index ae7e96a005..ea27c1fb70 100644
--- a/src/pkg/runtime/stack.go
+++ b/src/pkg/runtime/stack.go
@@ -86,7 +86,7 @@ const (
 	// After a stack split check the SP is allowed to be this
 	// many bytes below the stack guard.  This saves an instruction
 	// in the checking sequence for tiny frames.
-	stackSmall = 96
+	stackSmall = 64
 
 	// The maximum number of bytes that a chain of NOSPLIT
 	// functions can use.
diff --git a/src/pkg/runtime/stack.h b/src/pkg/runtime/stack.h
index b2de78d898..dc9da74887 100644
--- a/src/pkg/runtime/stack.h
+++ b/src/pkg/runtime/stack.h
@@ -47,7 +47,7 @@ above checks (without allocating a full frame), which might trigger
 a call to morestack.  This sequence needs to fit in the bottom
 section of the stack.  On amd64, morestack's frame is 40 bytes, and
 deferproc's frame is 56 bytes.  That fits well within the
-StackGuard - StackSmall = 128 bytes at the bottom.  
+StackGuard - StackSmall bytes at the bottom.  
 The linkers explore all possible call traces involving non-splitting
 functions to make sure that this limit cannot be violated.
  */
@@ -94,7 +94,7 @@ enum {
 	// After a stack split check the SP is allowed to be this
 	// many bytes below the stack guard.  This saves an instruction
 	// in the checking sequence for tiny frames.
-	StackSmall = 96,
+	StackSmall = 64,
 
 	// The maximum number of bytes that a chain of NOSPLIT
 	// functions can use.
diff --git a/src/pkg/runtime/stack_test.go b/src/pkg/runtime/stack_test.go
index 956c282136..2877074f76 100644
--- a/src/pkg/runtime/stack_test.go
+++ b/src/pkg/runtime/stack_test.go
@@ -15,7 +15,7 @@ import (
 // See stack.h.
 const (
 	StackGuard = 256
-	StackSmall = 96
+	StackSmall = 64
 	StackLimit = StackGuard - StackSmall
 )
 
diff --git a/test/nosplit.go b/test/nosplit.go
index 39bb3fcb47..3854f24203 100644
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -256,11 +256,11 @@ TestCases:
 				name := m[1]
 				size, _ := strconv.Atoi(m[2])
 
-				// CL 131450043 raised the limit from 128 to 160.
+				// The limit was originally 128 but is now 192.
 				// Instead of rewriting the test cases above, adjust
 				// the first stack frame to use up the extra 32 bytes.
 				if i == 0 {
-					size += 32
+					size += 192 - 128
 				}
 
 				if goarch == "amd64" && size%8 == 4 {

From 29f9f3ec80237ff0b2eb17f042747c08a10e0a14 Mon Sep 17 00:00:00 2001
From: Kelsey Hightower <kelsey.hightower@gmail.com>
Date: Fri, 29 Aug 2014 22:19:30 -0700
Subject: [PATCH 302/423] net/http: add BasicAuth method to *http.Request

The net/http package supports setting the HTTP Authorization header
using the Basic Authentication Scheme as defined in RFC 2617, but does
not provide support for extracting the username and password from an
authenticated request using the Basic Authentication Scheme.

Add BasicAuth method to *http.Request that returns the username and
password from authenticated requests using the Basic Authentication
Scheme.

Fixes #6779.

LGTM=bradfitz
R=golang-codereviews, josharian, bradfitz, alberto.garcia.hierro, blakesgentry
CC=golang-codereviews
https://golang.org/cl/76540043
---
 src/pkg/net/http/request.go      | 30 ++++++++++++++
 src/pkg/net/http/request_test.go | 70 ++++++++++++++++++++++++++++++++
 2 files changed, 100 insertions(+)

diff --git a/src/pkg/net/http/request.go b/src/pkg/net/http/request.go
index 6372943188..263c26c9bd 100644
--- a/src/pkg/net/http/request.go
+++ b/src/pkg/net/http/request.go
@@ -10,6 +10,7 @@ import (
 	"bufio"
 	"bytes"
 	"crypto/tls"
+	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
@@ -521,6 +522,35 @@ func NewRequest(method, urlStr string, body io.Reader) (*Request, error) {
 	return req, nil
 }
 
+// BasicAuth returns the username and password provided in the request's
+// Authorization header, if the request uses HTTP Basic Authentication.
+// See RFC 2617, Section 2.
+func (r *Request) BasicAuth() (username, password string, ok bool) {
+	auth := r.Header.Get("Authorization")
+	if auth == "" {
+		return
+	}
+	return parseBasicAuth(auth)
+}
+
+// parseBasicAuth parses an HTTP Basic Authentication string.
+// "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" returns ("Aladdin", "open sesame", true).
+func parseBasicAuth(auth string) (username, password string, ok bool) {
+	if !strings.HasPrefix(auth, "Basic ") {
+		return
+	}
+	c, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(auth, "Basic "))
+	if err != nil {
+		return
+	}
+	cs := string(c)
+	s := strings.IndexByte(cs, ':')
+	if s < 0 {
+		return
+	}
+	return cs[:s], cs[s+1:], true
+}
+
 // SetBasicAuth sets the request's Authorization header to use HTTP
 // Basic Authentication with the provided username and password.
 //
diff --git a/src/pkg/net/http/request_test.go b/src/pkg/net/http/request_test.go
index b9fa3c2bfc..759ea4e8b5 100644
--- a/src/pkg/net/http/request_test.go
+++ b/src/pkg/net/http/request_test.go
@@ -7,6 +7,7 @@ package http_test
 import (
 	"bufio"
 	"bytes"
+	"encoding/base64"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -396,6 +397,75 @@ func TestParseHTTPVersion(t *testing.T) {
 	}
 }
 
+type getBasicAuthTest struct {
+	username, password string
+	ok                 bool
+}
+
+type parseBasicAuthTest getBasicAuthTest
+
+type basicAuthCredentialsTest struct {
+	username, password string
+}
+
+var getBasicAuthTests = []struct {
+	username, password string
+	ok                 bool
+}{
+	{"Aladdin", "open sesame", true},
+	{"Aladdin", "open:sesame", true},
+	{"", "", true},
+}
+
+func TestGetBasicAuth(t *testing.T) {
+	for _, tt := range getBasicAuthTests {
+		r, _ := NewRequest("GET", "http://example.com/", nil)
+		r.SetBasicAuth(tt.username, tt.password)
+		username, password, ok := r.BasicAuth()
+		if ok != tt.ok || username != tt.username || password != tt.password {
+			t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok},
+				getBasicAuthTest{tt.username, tt.password, tt.ok})
+		}
+	}
+	// Unauthenticated request.
+	r, _ := NewRequest("GET", "http://example.com/", nil)
+	username, password, ok := r.BasicAuth()
+	if ok {
+		t.Errorf("expected false from BasicAuth when the request is unauthenticated")
+	}
+	want := basicAuthCredentialsTest{"", ""}
+	if username != want.username || password != want.password {
+		t.Errorf("expected credentials: %#v when the request is unauthenticated, got %#v",
+			want, basicAuthCredentialsTest{username, password})
+	}
+}
+
+var parseBasicAuthTests = []struct {
+	header, username, password string
+	ok                         bool
+}{
+	{"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
+	{"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open:sesame")), "Aladdin", "open:sesame", true},
+	{"Basic " + base64.StdEncoding.EncodeToString([]byte(":")), "", "", true},
+	{"Basic" + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false},
+	{base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false},
+	{"Basic ", "", "", false},
+	{"Basic Aladdin:open sesame", "", "", false},
+	{`Digest username="Aladdin"`, "", "", false},
+}
+
+func TestParseBasicAuth(t *testing.T) {
+	for _, tt := range parseBasicAuthTests {
+		r, _ := NewRequest("GET", "http://example.com/", nil)
+		r.Header.Set("Authorization", tt.header)
+		username, password, ok := r.BasicAuth()
+		if ok != tt.ok || username != tt.username || password != tt.password {
+			t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok},
+				getBasicAuthTest{tt.username, tt.password, tt.ok})
+		}
+	}
+}
+
 type logWrites struct {
 	t   *testing.T
 	dst *[]string

From b70bc22cd0b43bfe2021cb99e2a80eb6ab0eff5c Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 29 Aug 2014 23:13:17 -0700
Subject: [PATCH 303/423] runtime: retry fix openbsd build

Tested on linux/amd64 too this time.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=dave, golang-codereviews, iant, rsc
https://golang.org/cl/140050043
---
 src/pkg/runtime/defs_openbsd.go      | 4 ++--
 src/pkg/runtime/defs_openbsd_386.h   | 4 ++--
 src/pkg/runtime/defs_openbsd_amd64.h | 4 ++--
 src/pkg/runtime/os_openbsd.c         | 6 +++---
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/pkg/runtime/defs_openbsd.go b/src/pkg/runtime/defs_openbsd.go
index cf4e06d37b..39224c988c 100644
--- a/src/pkg/runtime/defs_openbsd.go
+++ b/src/pkg/runtime/defs_openbsd.go
@@ -104,7 +104,7 @@ const (
 	EVFILT_WRITE = C.EVFILT_WRITE
 )
 
-type Tfork C.struct___tfork
+type TforkT C.struct___tfork
 
 type SigaltstackT C.struct_sigaltstack
 type Sigcontext C.struct_sigcontext
@@ -118,4 +118,4 @@ type Timespec C.struct_timespec
 type Timeval C.struct_timeval
 type Itimerval C.struct_itimerval
 
-type Kevent C.struct_kevent
+type KeventT C.struct_kevent
diff --git a/src/pkg/runtime/defs_openbsd_386.h b/src/pkg/runtime/defs_openbsd_386.h
index 669a35c357..6b77e0084a 100644
--- a/src/pkg/runtime/defs_openbsd_386.h
+++ b/src/pkg/runtime/defs_openbsd_386.h
@@ -81,7 +81,7 @@ enum {
 	EVFILT_WRITE	= -0x2,
 };
 
-typedef struct Tfork Tfork;
+typedef struct TforkT TforkT;
 typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
@@ -93,7 +93,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Tfork {
+struct TforkT {
 	byte	*tf_tcb;
 	int32	*tf_tid;
 	byte	*tf_stack;
diff --git a/src/pkg/runtime/defs_openbsd_amd64.h b/src/pkg/runtime/defs_openbsd_amd64.h
index 9877f8b4c2..761e8e47df 100644
--- a/src/pkg/runtime/defs_openbsd_amd64.h
+++ b/src/pkg/runtime/defs_openbsd_amd64.h
@@ -81,7 +81,7 @@ enum {
 	EVFILT_WRITE	= -0x2,
 };
 
-typedef struct Tfork Tfork;
+typedef struct TforkT TforkT;
 typedef struct SigaltstackT SigaltstackT;
 typedef struct Sigcontext Sigcontext;
 typedef struct Siginfo Siginfo;
@@ -93,7 +93,7 @@ typedef struct KeventT KeventT;
 
 #pragma pack on
 
-struct Tfork {
+struct TforkT {
 	byte	*tf_tcb;
 	int32	*tf_tid;
 	byte	*tf_stack;
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index a746385314..dbd12a1282 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -26,7 +26,7 @@ extern SigTab runtime·sigtab[];
 static Sigset sigset_none;
 static Sigset sigset_all = ~(Sigset)0;
 
-extern int32 runtime·tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
+extern int32 runtime·tfork(TforkT *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
 extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock, const int32 *abort);
 extern int32 runtime·thrwakeup(void *ident, int32 n);
 
@@ -130,7 +130,7 @@ runtime·semawakeup(M *mp)
 void
 runtime·newosproc(M *mp, void *stk)
 {
-	Tfork param;
+	TforkT param;
 	Sigset oset;
 	int32 ret;
 
@@ -147,7 +147,7 @@ runtime·newosproc(M *mp, void *stk)
 	param.tf_stack = stk;
 
 	oset = runtime·sigprocmask(SIG_SETMASK, sigset_all);
-	ret = runtime·tfork((byte*)&param, sizeof(param), mp, mp->g0, runtime·mstart);
+	ret = runtime·tfork(&param, sizeof(param), mp, mp->g0, runtime·mstart);
 	runtime·sigprocmask(SIG_SETMASK, oset);
 
 	if(ret < 0) {

From cac006ae5a25ac333030b10b3430a4d47c8c9c19 Mon Sep 17 00:00:00 2001
From: Robin Eklind <r.eklind.87@gmail.com>
Date: Sat, 30 Aug 2014 10:27:01 -0700
Subject: [PATCH 304/423] spec: Fix indentation and remove trailing white space
 characters.

LGTM=gri
R=golang-codereviews, bradfitz, gri
CC=golang-codereviews
https://golang.org/cl/133330043
---
 doc/go_spec.html | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index a5edc8646c..eec1cdb7a7 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1034,7 +1034,7 @@ The value of an uninitialized pointer is <code>nil</code>.
 
 <pre class="ebnf">
 PointerType = "*" BaseType .
-BaseType = Type .
+BaseType    = Type .
 </pre>
 
 <pre>
@@ -2118,9 +2118,9 @@ operand only on the left-hand side of an <a href="#Assignments">assignment</a>.
 </p>
 
 <pre class="ebnf">
-Operand    = Literal | OperandName | MethodExpr | "(" Expression ")" .
-Literal    = BasicLit | CompositeLit | FunctionLit .
-BasicLit   = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
+Operand     = Literal | OperandName | MethodExpr | "(" Expression ")" .
+Literal     = BasicLit | CompositeLit | FunctionLit .
+BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
 OperandName = identifier | QualifiedIdent.
 </pre>
 
@@ -3598,7 +3598,7 @@ or an array indexing operation of an addressable array.
 As an exception to the addressability requirement, <code>x</code> may also be a
 (possibly parenthesized)
 <a href="#Composite_literals">composite literal</a>.
-If the evaluation of <code>x</code> would cause a <a href="#Run_time_panics">run-time panic</a>, 
+If the evaluation of <code>x</code> would cause a <a href="#Run_time_panics">run-time panic</a>,
 then the evaluation of <code>&amp;x</code> does too.
 </p>
 
@@ -4052,7 +4052,7 @@ n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order bet
 <p>
 At package level, initialization dependencies override the left-to-right rule
 for individual initialization expressions, but not for operands within each
-expression: 
+expression:
 </p>
 
 <pre>
@@ -5942,7 +5942,7 @@ variable or function.
 <li>
 A reference to a method <code>m</code> is a
 <a href="#Method_values">method value</a> or
-<a href="#Method_expressions">method expression</a> of the form 
+<a href="#Method_expressions">method expression</a> of the form
 <code>t.m</code>, where the (static) type of <code>t</code> is
 not an interface type, and the method <code>m</code> is in the
 <a href="#Method_sets">method set</a> of <code>t</code>.
@@ -5951,7 +5951,7 @@ It is immaterial whether the resulting function value
 </li>
 
 <li>
-A variable, function, or method <code>x</code> depends on a variable 
+A variable, function, or method <code>x</code> depends on a variable
 <code>y</code> if <code>x</code>'s initialization expression or body
 (for functions and methods) contains a reference to <code>y</code>
 or to a function or method that depends on <code>y</code>.
@@ -6003,7 +6003,7 @@ func init() { … }
 </pre>
 
 <p>
-Multiple such functions may be defined, even within a single 
+Multiple such functions may be defined, even within a single
 source file. The <code>init</code> identifier is not
 <a href="#Declarations_and_scope">declared</a> and thus
 <code>init</code> functions cannot be referred to from anywhere

From f4cbaa38aeda16bc37fa991132073a273d16cd43 Mon Sep 17 00:00:00 2001
From: Evan Kroske <evankroske@google.com>
Date: Sat, 30 Aug 2014 10:27:36 -0700
Subject: [PATCH 305/423] go/doc/headscan: update script to count headings with
 an ID attribute

Fixes script used to sanity-check the heading-detection heuristic of go/doc.
Fixes #8467.

LGTM=gri
R=golang-codereviews, gobot, gri
CC=golang-codereviews
https://golang.org/cl/128720043
---
 src/pkg/go/doc/headscan.go | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/pkg/go/doc/headscan.go b/src/pkg/go/doc/headscan.go
index f559347638..1ccaa15819 100644
--- a/src/pkg/go/doc/headscan.go
+++ b/src/pkg/go/doc/headscan.go
@@ -24,6 +24,7 @@ import (
 	"go/token"
 	"os"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 )
@@ -33,10 +34,10 @@ var (
 	verbose = flag.Bool("v", false, "verbose mode")
 )
 
-const (
-	html_h    = "<h3>"
-	html_endh = "</h3>\n"
-)
+// ToHTML in comment.go assigns a (possibly blank) ID to each heading
+var html_h = regexp.MustCompile(`<h3 id="[^"]*">`)
+
+const html_endh = "</h3>\n"
 
 func isGoFile(fi os.FileInfo) bool {
 	return strings.HasSuffix(fi.Name(), ".go") &&
@@ -47,11 +48,11 @@ func appendHeadings(list []string, comment string) []string {
 	var buf bytes.Buffer
 	doc.ToHTML(&buf, comment, nil)
 	for s := buf.String(); ; {
-		i := strings.Index(s, html_h)
-		if i < 0 {
+		loc := html_h.FindStringIndex(s)
+		if len(loc) == 0 {
 			break
 		}
-		i += len(html_h)
+		i := loc[1]
 		j := strings.Index(s, html_endh)
 		if j < 0 {
 			list = append(list, s[i:]) // incorrect HTML

From 07d86b1f2db73c6a0716aec4d4cd62dfacb04a21 Mon Sep 17 00:00:00 2001
From: Evan Kroske <evankroske@google.com>
Date: Sat, 30 Aug 2014 10:34:51 -0700
Subject: [PATCH 306/423] net/url: make Userinfo.String() escape ? and add test
 for shouldEscape
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

See RFC 3986 §3.2.1.
Fixes #6573.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/126560043
---
 src/pkg/net/url/url.go      | 11 ++++----
 src/pkg/net/url/url_test.go | 56 +++++++++++++++++++++++++++++++++++++
 2 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/src/pkg/net/url/url.go b/src/pkg/net/url/url.go
index 75f650a275..0b32cd7c8a 100644
--- a/src/pkg/net/url/url.go
+++ b/src/pkg/net/url/url.go
@@ -64,7 +64,6 @@ func (e EscapeError) Error() string {
 
 // Return true if the specified character should be escaped when
 // appearing in a URL string, according to RFC 3986.
-// When 'all' is true the full range of reserved characters are matched.
 func shouldEscape(c byte, mode encoding) bool {
 	// §2.3 Unreserved characters (alphanum)
 	if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
@@ -86,10 +85,12 @@ func shouldEscape(c byte, mode encoding) bool {
 			// last two as well. That leaves only ? to escape.
 			return c == '?'
 
-		case encodeUserPassword: // §3.2.2
-			// The RFC allows ; : & = + $ , in userinfo, so we must escape only @ and /.
-			// The parsing of userinfo treats : as special so we must escape that too.
-			return c == '@' || c == '/' || c == ':'
+		case encodeUserPassword: // §3.2.1
+			// The RFC allows ';', ':', '&', '=', '+', '$', and ',' in
+			// userinfo, so we must escape only '@', '/', and '?'.
+			// The parsing of userinfo treats ':' as special so we must escape
+			// that too.
+			return c == '@' || c == '/' || c == '?' || c == ':'
 
 		case encodeQueryComponent: // §3.4
 			// The RFC reserves (so we must escape) everything.
diff --git a/src/pkg/net/url/url_test.go b/src/pkg/net/url/url_test.go
index cad758f238..d8b19d805d 100644
--- a/src/pkg/net/url/url_test.go
+++ b/src/pkg/net/url/url_test.go
@@ -279,6 +279,16 @@ var urltests = []URLTest{
 		},
 		"a/b/c",
 	},
+	// escaped '?' in username and password
+	{
+		"http://%3Fam:pa%3Fsword@google.com",
+		&URL{
+			Scheme: "http",
+			User:   UserPassword("?am", "pa?sword"),
+			Host:   "google.com",
+		},
+		"",
+	},
 }
 
 // more useful string for debugging than fmt's struct printer
@@ -903,3 +913,49 @@ func TestParseFailure(t *testing.T) {
 		t.Errorf(`ParseQuery(%q) returned error %q, want something containing %q"`, url, errStr, "%gh")
 	}
 }
+
+type shouldEscapeTest struct {
+	in     byte
+	mode   encoding
+	escape bool
+}
+
+var shouldEscapeTests = []shouldEscapeTest{
+	// Unreserved characters (§2.3)
+	{'a', encodePath, false},
+	{'a', encodeUserPassword, false},
+	{'a', encodeQueryComponent, false},
+	{'a', encodeFragment, false},
+	{'z', encodePath, false},
+	{'A', encodePath, false},
+	{'Z', encodePath, false},
+	{'0', encodePath, false},
+	{'9', encodePath, false},
+	{'-', encodePath, false},
+	{'-', encodeUserPassword, false},
+	{'-', encodeQueryComponent, false},
+	{'-', encodeFragment, false},
+	{'.', encodePath, false},
+	{'_', encodePath, false},
+	{'~', encodePath, false},
+
+	// User information (§3.2.1)
+	{':', encodeUserPassword, true},
+	{'/', encodeUserPassword, true},
+	{'?', encodeUserPassword, true},
+	{'@', encodeUserPassword, true},
+	{'$', encodeUserPassword, false},
+	{'&', encodeUserPassword, false},
+	{'+', encodeUserPassword, false},
+	{',', encodeUserPassword, false},
+	{';', encodeUserPassword, false},
+	{'=', encodeUserPassword, false},
+}
+
+func TestShouldEscape(t *testing.T) {
+	for _, tt := range shouldEscapeTests {
+		if shouldEscape(tt.in, tt.mode) != tt.escape {
+			t.Errorf("shouldEscape(%q, %v) returned %v; expected %v", tt.in, tt.mode, !tt.escape, tt.escape)
+		}
+	}
+}

From 47d6af2f68d43d496f7155d705f269b126f8f108 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 30 Aug 2014 11:03:28 -0700
Subject: [PATCH 307/423] runtime: convert chanrecv to Go

LGTM=rsc, dvyukov
R=golang-codereviews, bradfitz, rsc, dvyukov
CC=golang-codereviews
https://golang.org/cl/136980044
---
 src/pkg/runtime/asm_386.s           |   3 +
 src/pkg/runtime/asm_amd64.s         |   3 +
 src/pkg/runtime/asm_amd64p32.s      |   3 +
 src/pkg/runtime/asm_arm.s           |   3 +
 src/pkg/runtime/chan.go             | 304 +++++++++++++++++++-
 src/pkg/runtime/chan.goc            | 418 +---------------------------
 src/pkg/runtime/pprof/pprof_test.go |   4 +-
 src/pkg/runtime/stubs.go            |   3 +
 src/pkg/runtime/thunk.s             |   6 +
 9 files changed, 329 insertions(+), 418 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index d80020ccd6..35805d63c6 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -507,6 +507,9 @@ TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
 TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-8
 	JMP	runtime·atomicload(SB)
 
+TEXT runtime·atomicloaduint(SB), NOSPLIT, $0-8
+	JMP	runtime·atomicload(SB)
+
 // bool runtime·cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
 //	if(*val == *old){
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index bc17c68f3d..07eec9ebb6 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -626,6 +626,9 @@ TEXT runtime·casuintptr(SB), NOSPLIT, $0-25
 TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-16
 	JMP	runtime·atomicload64(SB)
 
+TEXT runtime·atomicloaduint(SB), NOSPLIT, $0-16
+	JMP	runtime·atomicload64(SB)
+
 // bool casp(void **val, void *old, void *new)
 // Atomically:
 //	if(*val == old){
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 82c0d77cdd..76a6dc2300 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -567,6 +567,9 @@ TEXT runtime·casuintptr(SB), NOSPLIT, $0-17
 TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-12
 	JMP	runtime·atomicload(SB)
 
+TEXT runtime·atomicloaduint(SB), NOSPLIT, $0-12
+	JMP	runtime·atomicload(SB)
+
 // bool	runtime·cas64(uint64 *val, uint64 old, uint64 new)
 // Atomically:
 //	if(*val == *old){
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index f8447d7940..0e87df42b7 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -695,6 +695,9 @@ TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
 TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-8
 	B	runtime·atomicload(SB)
 
+TEXT runtime·atomicloaduint(SB), NOSPLIT, $0-8
+	B	runtime·atomicload(SB)
+
 TEXT runtime·stackguard(SB),NOSPLIT,$0-8
 	MOVW	R13, R1
 	MOVW	g_stackguard(g), R2
diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index 239c29f9e2..5e972983c6 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -35,8 +35,8 @@ func makechan(t *chantype, size int64) *hchan {
 	if elem.kind&kindNoPointers != 0 || size == 0 {
 		// Allocate memory in one call.
 		// Hchan does not contain pointers interesting for GC in this case:
-		// buf points into the same allocation, elemtype is persistent
-		// and SudoG's are referenced from G so can't be collected.
+		// buf points into the same allocation, elemtype is persistent.
+		// SudoG's are referenced from their owning thread so they can't be collected.
 		// TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
 		c = (*hchan)(gomallocgc(hchanSize+uintptr(size)*uintptr(elem.size), nil, flagNoScan))
 		if size > 0 && elem.size != 0 {
@@ -53,7 +53,7 @@ func makechan(t *chantype, size int64) *hchan {
 	c.dataqsiz = uint(size)
 
 	if debugChan {
-		println("makechan: chan=", c, "; elemsize=", elem.size, "; elemalg=", elem.alg, "; dataqsiz=", size)
+		print("makechan: chan=", c, "; elemsize=", elem.size, "; elemalg=", elem.alg, "; dataqsiz=", size, "\n")
 	}
 	return c
 }
@@ -93,11 +93,11 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 			return false
 		}
 		gopark(nil, nil, "chan send (nil chan)")
-		return false // not reached
+		gothrow("unreachable")
 	}
 
 	if debugChan {
-		println("chansend: chan=", c)
+		print("chansend: chan=", c, "\n")
 	}
 
 	if raceenabled {
@@ -164,6 +164,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		// no receiver available: block on this channel.
 		gp := getg()
 		mysg := acquireSudog()
+		mysg.releasetime = 0
 		if t0 != 0 {
 			mysg.releasetime = -1
 		}
@@ -204,6 +205,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		}
 		gp := getg()
 		mysg := acquireSudog()
+		mysg.releasetime = 0
 		if t0 != 0 {
 			mysg.releasetime = -1
 		}
@@ -214,8 +216,8 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 		goparkunlock(&c.lock, "chan send")
 
 		// someone woke us up - try again
-		if mysg.releasetime != 0 {
-			t1 = int64(mysg.releasetime)
+		if mysg.releasetime > 0 {
+			t1 = mysg.releasetime
 		}
 		releaseSudog(mysg)
 		lock(&c.lock)
@@ -303,10 +305,296 @@ func closechan(c *hchan) {
 		}
 		goready(gp)
 	}
-
 	unlock(&c.lock)
 }
 
+// entry points for <- c from compiled code
+//go:nosplit
+func chanrecv1(t *chantype, c *hchan, elem unsafe.Pointer) {
+	chanrecv(t, c, elem, true)
+}
+
+//go:nosplit
+func chanrecv2(t *chantype, c *hchan, elem unsafe.Pointer) (received bool) {
+	_, received = chanrecv(t, c, elem, true)
+	return
+}
+
+// chanrecv receives on channel c and writes the received data to ep.
+// ep may be nil, in which case received data is ignored.
+// If block == false and no elements are available, returns (false, false).
+// Otherwise, if c is closed, zeros *ep and returns (true, false).
+// Otherwise, fills in *ep with an element and returns (true, true).
+func chanrecv(t *chantype, c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
+	// raceenabled: don't need to check ep, as it is always on the stack.
+
+	if debugChan {
+		print("chanrecv: chan=", c, "\n")
+	}
+
+	if c == nil {
+		if !block {
+			return
+		}
+		gopark(nil, nil, "chan receive (nil chan)")
+		gothrow("unreachable")
+	}
+
+	// Fast path: check for failed non-blocking operation without acquiring the lock.
+	//
+	// After observing that the channel is not ready for receiving, we observe that the
+	// channel is not closed. Each of these observations is a single word-sized read
+	// (first c.sendq.first or c.qcount, and second c.closed).
+	// Because a channel cannot be reopened, the later observation of the channel
+	// being not closed implies that it was also not closed at the moment of the
+	// first observation. We behave as if we observed the channel at that moment
+	// and report that the receive cannot proceed.
+	//
+	// The order of operations is important here: reversing the operations can lead to
+	// incorrect behavior when racing with a close.
+	if !block && (c.dataqsiz == 0 && c.sendq.first == nil ||
+		c.dataqsiz > 0 && atomicloaduint(&c.qcount) == 0) &&
+		atomicload(&c.closed) == 0 {
+		return
+	}
+
+	var t0 int64
+	if blockprofilerate > 0 {
+		t0 = cputicks()
+	}
+
+	lock(&c.lock)
+	if c.dataqsiz == 0 { // synchronous channel
+		if c.closed != 0 {
+			return recvclosed(c, ep)
+		}
+
+		sg := c.sendq.dequeue()
+		if sg != nil {
+			if raceenabled {
+				racesync(c, sg)
+			}
+			unlock(&c.lock)
+
+			if ep != nil {
+				memmove(ep, sg.elem, uintptr(c.elemsize))
+			}
+			gp := sg.g
+			gp.param = unsafe.Pointer(sg)
+			if sg.releasetime != 0 {
+				sg.releasetime = cputicks()
+			}
+			goready(gp)
+			selected = true
+			received = true
+			return
+		}
+
+		if !block {
+			unlock(&c.lock)
+			return
+		}
+
+		// no sender available: block on this channel.
+		gp := getg()
+		mysg := acquireSudog()
+		mysg.releasetime = 0
+		if t0 != 0 {
+			mysg.releasetime = -1
+		}
+		mysg.elem = ep
+		mysg.waitlink = nil
+		gp.waiting = mysg
+		mysg.g = gp
+		mysg.selectdone = nil
+		gp.param = nil
+		c.recvq.enqueue(mysg)
+		goparkunlock(&c.lock, "chan receive")
+
+		// someone woke us up
+		gp.waiting = nil
+		if mysg.releasetime > 0 {
+			blockevent(mysg.releasetime-t0, 2)
+		}
+		releaseSudog(mysg)
+
+		if gp.param != nil {
+			// a sender sent us some data. It already wrote to ep.
+			selected = true
+			received = true
+			return
+		}
+
+		lock(&c.lock)
+		if c.closed == 0 {
+			gothrow("chanrecv: spurious wakeup")
+		}
+		return recvclosed(c, ep)
+	}
+
+	// asynchronous channel
+	// wait for some data to appear
+	var t1 int64
+	for c.qcount <= 0 {
+		if c.closed != 0 {
+			selected, received = recvclosed(c, ep)
+			if t1 > 0 {
+				blockevent(t1-t0, 2)
+			}
+			return
+		}
+
+		if !block {
+			unlock(&c.lock)
+			return
+		}
+
+		// wait for someone to send an element
+		gp := getg()
+		mysg := acquireSudog()
+		mysg.releasetime = 0
+		if t0 != 0 {
+			mysg.releasetime = -1
+		}
+		mysg.elem = nil
+		mysg.g = gp
+		mysg.selectdone = nil
+
+		c.recvq.enqueue(mysg)
+		goparkunlock(&c.lock, "chan receive")
+
+		// someone woke us up - try again
+		if mysg.releasetime > 0 {
+			t1 = mysg.releasetime
+		}
+		releaseSudog(mysg)
+		lock(&c.lock)
+	}
+
+	if raceenabled {
+		raceacquire(chanbuf(c, c.recvx))
+		racerelease(chanbuf(c, c.recvx))
+	}
+	if ep != nil {
+		memmove(ep, chanbuf(c, c.recvx), uintptr(c.elemsize))
+	}
+	memclr(chanbuf(c, c.recvx), uintptr(c.elemsize))
+
+	c.recvx++
+	if c.recvx == c.dataqsiz {
+		c.recvx = 0
+	}
+	c.qcount--
+
+	// ping a sender now that there is space
+	sg := c.sendq.dequeue()
+	if sg != nil {
+		gp := sg.g
+		unlock(&c.lock)
+		if sg.releasetime != 0 {
+			sg.releasetime = cputicks()
+		}
+		goready(gp)
+	} else {
+		unlock(&c.lock)
+	}
+
+	if t1 > 0 {
+		blockevent(t1-t0, 2)
+	}
+	selected = true
+	received = true
+	return
+}
+
+// recvclosed is a helper function for chanrecv.  Handles cleanup
+// when the receiver encounters a closed channel.
+// Caller must hold c.lock, recvclosed will release the lock.
+func recvclosed(c *hchan, ep unsafe.Pointer) (selected, recevied bool) {
+	if raceenabled {
+		raceacquire(unsafe.Pointer(c))
+	}
+	unlock(&c.lock)
+	if ep != nil {
+		memclr(ep, uintptr(c.elemsize))
+	}
+	return true, false
+}
+
+// compiler implements
+//
+//	select {
+//	case c <- v:
+//		... foo
+//	default:
+//		... bar
+//	}
+//
+// as
+//
+//	if selectnbsend(c, v) {
+//		... foo
+//	} else {
+//		... bar
+//	}
+//
+func selectnbsend(t *chantype, c *hchan, elem unsafe.Pointer) (selected bool) {
+	return chansend(t, c, elem, false, getcallerpc(unsafe.Pointer(&t)))
+}
+
+// compiler implements
+//
+//	select {
+//	case v = <-c:
+//		... foo
+//	default:
+//		... bar
+//	}
+//
+// as
+//
+//	if selectnbrecv(&v, c) {
+//		... foo
+//	} else {
+//		... bar
+//	}
+//
+func selectnbrecv(t *chantype, elem unsafe.Pointer, c *hchan) (selected bool) {
+	selected, _ = chanrecv(t, c, elem, false)
+	return
+}
+
+// compiler implements
+//
+//	select {
+//	case v, ok = <-c:
+//		... foo
+//	default:
+//		... bar
+//	}
+//
+// as
+//
+//	if c != nil && selectnbrecv2(&v, &ok, c) {
+//		... foo
+//	} else {
+//		... bar
+//	}
+//
+func selectnbrecv2(t *chantype, elem unsafe.Pointer, received *bool, c *hchan) (selected bool) {
+	// TODO(khr): just return 2 values from this function, now that it is in Go.
+	selected, *received = chanrecv(t, c, elem, false)
+	return
+}
+
+func reflect_chansend(t *chantype, c *hchan, elem unsafe.Pointer, nb bool) (selected bool) {
+	return chansend(t, c, elem, !nb, getcallerpc(unsafe.Pointer(&t)))
+}
+
+func reflect_chanrecv(t *chantype, c *hchan, nb bool, elem unsafe.Pointer) (selected bool, received bool) {
+	return chanrecv(t, c, elem, !nb)
+}
+
 func reflect_chanlen(c *hchan) int {
 	if c == nil {
 		return 0
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 383351179d..509f80d9a1 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -18,407 +18,9 @@ static	SudoG*	dequeue(WaitQ*);
 static	void	enqueue(WaitQ*, SudoG*);
 static	void	racesync(Hchan*, SudoG*);
 
-/*
- * generic single channel send/recv
- * if the bool pointer is nil,
- * then the full exchange will
- * occur. if pres is not nil,
- * then the protocol will not
- * sleep but return if it could
- * not complete.
- *
- * sleep can wake up with g->param == nil
- * when a channel involved in the sleep has
- * been closed.  it is easiest to loop and re-run
- * the operation; we'll see that it's now closed.
- */
-static bool
-chansend(ChanType *t, Hchan *c, byte *ep, bool block, void *pc)
-{
-	SudoG *sg;
-	SudoG mysg;
-	G* gp;
-	int64 t0;
-
-	if(raceenabled)
-		runtime·racereadobjectpc(ep, t->elem, runtime·getcallerpc(&t), chansend);
-
-	if(c == nil) {
-		USED(t);
-		if(!block)
-			return false;
-		runtime·park(nil, nil, runtime·gostringnocopy((byte*)"chan send (nil chan)"));
-		return false;  // not reached
-	}
-
-	if(raceenabled)
-		runtime·racereadpc(c, pc, chansend);
-
-	// Fast path: check for failed non-blocking operation without acquiring the lock.
-	//
-	// After observing that the channel is not closed, we observe that the channel is
-	// not ready for sending. Each of these observations is a single word-sized read
-	// (first c.closed and second c.recvq.first or c.qcount depending on kind of channel).
-	// Because a closed channel cannot transition from 'ready for sending' to
-	// 'not ready for sending', even if the channel is closed between the two observations,
-	// they imply a moment between the two when the channel was both not yet closed
-	// and not ready for sending. We behave as if we observed the channel at that moment,
-	// and report that the send cannot proceed.
-	//
-	// It is okay if the reads are reordered here: if we observe that the channel is not
-	// ready for sending and then observe that it is not closed, that implies that the
-	// channel wasn't closed during the first observation.
-	if(!block && !c->closed && ((c->dataqsiz == 0 && c->recvq.first == nil) ||
-		(c->dataqsiz > 0 && c->qcount == c->dataqsiz)))
-		return false;
-
-	t0 = 0;
-	mysg.releasetime = 0;
-	if(runtime·blockprofilerate > 0) {
-		t0 = runtime·cputicks();
-		mysg.releasetime = -1;
-	}
-
-	runtime·lock(&c->lock);
-	if(c->closed)
-		goto closed;
-
-	if(c->dataqsiz > 0)
-		goto asynch;
-
-	sg = dequeue(&c->recvq);
-	if(sg != nil) {
-		if(raceenabled)
-			racesync(c, sg);
-		runtime·unlock(&c->lock);
-
-		gp = sg->g;
-		gp->param = sg;
-		if(sg->elem != nil)
-			runtime·memmove(sg->elem, ep, c->elemsize);
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-		return true;
-	}
-
-	if(!block) {
-		runtime·unlock(&c->lock);
-		return false;
-	}
-
-	mysg.elem = ep;
-	mysg.g = g;
-	mysg.selectdone = nil;
-	g->param = nil;
-	enqueue(&c->sendq, &mysg);
-	runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan send"));
-
-	if(g->param == nil) {
-		runtime·lock(&c->lock);
-		if(!c->closed)
-			runtime·throw("chansend: spurious wakeup");
-		goto closed;
-	}
-
-	if(mysg.releasetime > 0)
-		runtime·blockevent(mysg.releasetime - t0, 2);
-
-	return true;
-
-asynch:
-	if(c->closed)
-		goto closed;
-
-	if(c->qcount >= c->dataqsiz) {
-		if(!block) {
-			runtime·unlock(&c->lock);
-			return false;
-		}
-		mysg.g = g;
-		mysg.elem = nil;
-		mysg.selectdone = nil;
-		enqueue(&c->sendq, &mysg);
-		runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan send"));
-
-		runtime·lock(&c->lock);
-		goto asynch;
-	}
-
-	if(raceenabled) {
-		runtime·raceacquire(chanbuf(c, c->sendx));
-		runtime·racerelease(chanbuf(c, c->sendx));
-	}
-
-	runtime·memmove(chanbuf(c, c->sendx), ep, c->elemsize);
-	if(++c->sendx == c->dataqsiz)
-		c->sendx = 0;
-	c->qcount++;
-
-	sg = dequeue(&c->recvq);
-	if(sg != nil) {
-		gp = sg->g;
-		runtime·unlock(&c->lock);
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-	} else
-		runtime·unlock(&c->lock);
-	if(mysg.releasetime > 0)
-		runtime·blockevent(mysg.releasetime - t0, 2);
-	return true;
-
-closed:
-	runtime·unlock(&c->lock);
-	runtime·panicstring("send on closed channel");
-	return false;  // not reached
-}
-
-
-static bool
-chanrecv(ChanType *t, Hchan* c, byte *ep, bool block, bool *received)
-{
-	SudoG *sg;
-	SudoG mysg;
-	G *gp;
-	int64 t0;
-
-	// raceenabled: don't need to check ep, as it is always on the stack.
-
-	if(debug)
-		runtime·printf("chanrecv: chan=%p\n", c);
-
-	if(c == nil) {
-		USED(t);
-		if(!block)
-			return false;
-		runtime·park(nil, nil, runtime·gostringnocopy((byte*)"chan receive (nil chan)"));
-		return false;  // not reached
-	}
-
-	// Fast path: check for failed non-blocking operation without acquiring the lock.
-	//
-	// After observing that the channel is not ready for receiving, we observe that the
-	// channel is not closed. Each of these observations is a single word-sized read
-	// (first c.sendq.first or c.qcount, and second c.closed).
-	// Because a channel cannot be reopened, the later observation of the channel
-	// being not closed implies that it was also not closed at the moment of the
-	// first observation. We behave as if we observed the channel at that moment
-	// and report that the receive cannot proceed.
-	//
-	// The order of operations is important here: reversing the operations can lead to
-	// incorrect behavior when racing with a close.
-	if(!block && ((c->dataqsiz == 0 && c->sendq.first == nil) ||
-		(c->dataqsiz > 0 && runtime·atomicloadp((void**)&c->qcount) == 0)) &&
-		!runtime·atomicload(&c->closed))
-		return false;
-
-	t0 = 0;
-	mysg.releasetime = 0;
-	if(runtime·blockprofilerate > 0) {
-		t0 = runtime·cputicks();
-		mysg.releasetime = -1;
-	}
-
-	runtime·lock(&c->lock);
-	if(c->dataqsiz > 0)
-		goto asynch;
-
-	if(c->closed)
-		goto closed;
-
-	sg = dequeue(&c->sendq);
-	if(sg != nil) {
-		if(raceenabled)
-			racesync(c, sg);
-		runtime·unlock(&c->lock);
-
-		if(ep != nil)
-			runtime·memmove(ep, sg->elem, c->elemsize);
-		gp = sg->g;
-		gp->param = sg;
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-
-		if(received != nil)
-			*received = true;
-		return true;
-	}
-
-	if(!block) {
-		runtime·unlock(&c->lock);
-		return false;
-	}
-
-	mysg.elem = ep;
-	mysg.g = g;
-	mysg.selectdone = nil;
-	g->param = nil;
-	enqueue(&c->recvq, &mysg);
-	runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan receive"));
-
-	if(g->param == nil) {
-		runtime·lock(&c->lock);
-		if(!c->closed)
-			runtime·throw("chanrecv: spurious wakeup");
-		goto closed;
-	}
-
-	if(received != nil)
-		*received = true;
-	if(mysg.releasetime > 0)
-		runtime·blockevent(mysg.releasetime - t0, 2);
-	return true;
-
-asynch:
-	if(c->qcount <= 0) {
-		if(c->closed)
-			goto closed;
-
-		if(!block) {
-			runtime·unlock(&c->lock);
-			if(received != nil)
-				*received = false;
-			return false;
-		}
-		mysg.g = g;
-		mysg.elem = nil;
-		mysg.selectdone = nil;
-		enqueue(&c->recvq, &mysg);
-		runtime·parkunlock(&c->lock, runtime·gostringnocopy((byte*)"chan receive"));
-
-		runtime·lock(&c->lock);
-		goto asynch;
-	}
-
-	if(raceenabled) {
-		runtime·raceacquire(chanbuf(c, c->recvx));
-		runtime·racerelease(chanbuf(c, c->recvx));
-	}
-
-	if(ep != nil)
-		runtime·memmove(ep, chanbuf(c, c->recvx), c->elemsize);
-	runtime·memclr(chanbuf(c, c->recvx), c->elemsize);
-	if(++c->recvx == c->dataqsiz)
-		c->recvx = 0;
-	c->qcount--;
-
-	sg = dequeue(&c->sendq);
-	if(sg != nil) {
-		gp = sg->g;
-		runtime·unlock(&c->lock);
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-	} else
-		runtime·unlock(&c->lock);
-
-	if(received != nil)
-		*received = true;
-	if(mysg.releasetime > 0)
-		runtime·blockevent(mysg.releasetime - t0, 2);
-	return true;
-
-closed:
-	if(ep != nil)
-		runtime·memclr(ep, c->elemsize);
-	if(received != nil)
-		*received = false;
-	if(raceenabled)
-		runtime·raceacquire(c);
-	runtime·unlock(&c->lock);
-	if(mysg.releasetime > 0)
-		runtime·blockevent(mysg.releasetime - t0, 2);
-	return true;
-}
-
-#pragma textflag NOSPLIT
-func chanrecv1(t *ChanType, c *Hchan, elem *byte) {
-	chanrecv(t, c, elem, true, nil);
-}
-
-// chanrecv2(hchan *chan any, elem *any) (received bool);
-#pragma textflag NOSPLIT
-func chanrecv2(t *ChanType, c *Hchan, elem *byte) (received bool) {
-	chanrecv(t, c, elem, true, &received);
-}
-
-// compiler implements
-//
-//	select {
-//	case c <- v:
-//		... foo
-//	default:
-//		... bar
-//	}
-//
-// as
-//
-//	if selectnbsend(c, v) {
-//		... foo
-//	} else {
-//		... bar
-//	}
-//
-#pragma textflag NOSPLIT
-func selectnbsend(t *ChanType, c *Hchan, elem *byte) (selected bool) {
-	selected = chansend(t, c, elem, false, runtime·getcallerpc(&t));
-}
-
-// compiler implements
-//
-//	select {
-//	case v = <-c:
-//		... foo
-//	default:
-//		... bar
-//	}
-//
-// as
-//
-//	if selectnbrecv(&v, c) {
-//		... foo
-//	} else {
-//		... bar
-//	}
-//
-#pragma textflag NOSPLIT
-func selectnbrecv(t *ChanType, elem *byte, c *Hchan) (selected bool) {
-	selected = chanrecv(t, c, elem, false, nil);
-}
-
-// compiler implements
-//
-//	select {
-//	case v, ok = <-c:
-//		... foo
-//	default:
-//		... bar
-//	}
-//
-// as
-//
-//	if c != nil && selectnbrecv2(&v, &ok, c) {
-//		... foo
-//	} else {
-//		... bar
-//	}
-//
-#pragma textflag NOSPLIT
-func selectnbrecv2(t *ChanType, elem *byte, received *bool, c *Hchan) (selected bool) {
-	selected = chanrecv(t, c, elem, false, received);
-}
-
-#pragma textflag NOSPLIT
-func reflect·chansend(t *ChanType, c *Hchan, elem *byte, nb bool) (selected bool) {
-	selected = chansend(t, c, elem, !nb, runtime·getcallerpc(&t));
-}
-
-func reflect·chanrecv(t *ChanType, c *Hchan, nb bool, elem *byte) (selected bool, received bool) {
-	received = false;
-	selected = chanrecv(t, c, elem, !nb, &received);
-}
+// TODO(khr): temporary placeholders until the rest of this code is moved to Go.
+extern byte runtime·chansend;
+extern byte runtime·chanrecv;
 
 static int64
 selectsize(int32 size)
@@ -731,7 +333,7 @@ loop:
 
 		case CaseSend:
 			if(raceenabled)
-				runtime·racereadpc(c, cas->pc, chansend);
+				runtime·racereadpc(c, cas->pc, &runtime·chansend);
 			if(c->closed)
 				goto sclose;
 			if(c->dataqsiz > 0) {
@@ -817,9 +419,9 @@ loop:
 
 	if(raceenabled) {
 		if(cas->kind == CaseRecv && cas->sg.elem != nil)
-			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, chanrecv);
+			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chanrecv);
 		else if(cas->kind == CaseSend)
-			runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, chansend);
+			runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chansend);
 	}
 
 	selunlock(sel);
@@ -829,7 +431,7 @@ asyncrecv:
 	// can receive from buffer
 	if(raceenabled) {
 		if(cas->sg.elem != nil)
-			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, chanrecv);
+			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chanrecv);
 		runtime·raceacquire(chanbuf(c, c->recvx));
 		runtime·racerelease(chanbuf(c, c->recvx));
 	}
@@ -858,7 +460,7 @@ asyncsend:
 	if(raceenabled) {
 		runtime·raceacquire(chanbuf(c, c->sendx));
 		runtime·racerelease(chanbuf(c, c->sendx));
-		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, chansend);
+		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chansend);
 	}
 	runtime·memmove(chanbuf(c, c->sendx), cas->sg.elem, c->elemsize);
 	if(++c->sendx == c->dataqsiz)
@@ -880,7 +482,7 @@ syncrecv:
 	// can receive from sleeping sender (sg)
 	if(raceenabled) {
 		if(cas->sg.elem != nil)
-			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, chanrecv);
+			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chanrecv);
 		racesync(c, sg);
 	}
 	selunlock(sel);
@@ -911,7 +513,7 @@ rclose:
 syncsend:
 	// can send to sleeping receiver (sg)
 	if(raceenabled) {
-		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, chansend);
+		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chansend);
 		racesync(c, sg);
 	}
 	selunlock(sel);
diff --git a/src/pkg/runtime/pprof/pprof_test.go b/src/pkg/runtime/pprof/pprof_test.go
index 45db6c59a7..99c27ba96c 100644
--- a/src/pkg/runtime/pprof/pprof_test.go
+++ b/src/pkg/runtime/pprof/pprof_test.go
@@ -281,7 +281,7 @@ func TestBlockProfile(t *testing.T) {
 	tests := [...]TestCase{
 		{"chan recv", blockChanRecv, `
 [0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime\.chanrecv1\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.goc:[0-9]+
+#	0x[0-9,a-f]+	runtime\.chanrecv1\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.blockChanRecv\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 `},
@@ -293,7 +293,7 @@ func TestBlockProfile(t *testing.T) {
 `},
 		{"chan close", blockChanClose, `
 [0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime\.chanrecv1\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.goc:[0-9]+
+#	0x[0-9,a-f]+	runtime\.chanrecv1\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.blockChanClose\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 `},
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 9ad400639d..237457f684 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -233,6 +233,9 @@ func atomicloadp(ptr unsafe.Pointer) unsafe.Pointer
 //go:noescape
 func atomicloaduintptr(ptr *uintptr) uintptr
 
+//go:noescape
+func atomicloaduint(ptr *uint) uint
+
 //go:noescape
 func atomicor8(ptr *uint8, val uint8)
 
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 997a4febc7..508f50841a 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -62,5 +62,11 @@ TEXT reflect·chanlen(SB), NOSPLIT, $0-0
 TEXT reflect·chancap(SB), NOSPLIT, $0-0
 	JMP	runtime·reflect_chancap(SB)
 
+TEXT reflect·chansend(SB), NOSPLIT, $0-0
+	JMP	runtime·reflect_chansend(SB)
+
+TEXT reflect·chanrecv(SB), NOSPLIT, $0-0
+	JMP	runtime·reflect_chanrecv(SB)
+
 TEXT runtime∕debug·freeOSMemory(SB), NOSPLIT, $0-0
 	JMP	runtime·freeOSMemory(SB)

From 7006aafdcd3be55d13e987dc9008425111bc7850 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Aug 2014 14:18:41 -0400
Subject: [PATCH 308/423] runtime: preallocate panic errors for index and slice

This avoids allocating at the panic sites.

LGTM=r, khr
R=golang-codereviews, r, khr
CC=dvyukov, golang-codereviews, iant, khr
https://golang.org/cl/136020043
---
 src/pkg/runtime/panic.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/panic.go b/src/pkg/runtime/panic.go
index ac0c6b77ee..9b95f49673 100644
--- a/src/pkg/runtime/panic.go
+++ b/src/pkg/runtime/panic.go
@@ -4,10 +4,14 @@
 
 package runtime
 
+var indexError = error(errorString("index out of range"))
+
 func panicindex() {
-	panic(errorString("index out of range"))
+	panic(indexError)
 }
 
+var sliceError = error(errorString("slice bounds out of range"))
+
 func panicslice() {
-	panic(errorString("slice bounds out of range"))
+	panic(sliceError)
 }

From 2fd62a42b48ffc111aebdc4a191d705248888fc1 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Sat, 30 Aug 2014 22:38:54 +0400
Subject: [PATCH 309/423] runtime/pprof: make CPU profiling tests more robust
 Under the race detector most of the samples go into race runtime, because of
 that freebsd race builder constantly fails on this test.

LGTM=bradfitz, rsc
R=golang-codereviews, bradfitz, rsc
CC=golang-codereviews, minux
https://golang.org/cl/133370043
---
 src/pkg/runtime/pprof/pprof_test.go | 71 ++++++++++++++++++++---------
 1 file changed, 50 insertions(+), 21 deletions(-)

diff --git a/src/pkg/runtime/pprof/pprof_test.go b/src/pkg/runtime/pprof/pprof_test.go
index 99c27ba96c..3c59fe76cb 100644
--- a/src/pkg/runtime/pprof/pprof_test.go
+++ b/src/pkg/runtime/pprof/pprof_test.go
@@ -9,7 +9,6 @@ package pprof_test
 import (
 	"bytes"
 	"fmt"
-	"hash/crc32"
 	"math/big"
 	"os/exec"
 	"regexp"
@@ -22,35 +21,65 @@ import (
 	"unsafe"
 )
 
-func TestCPUProfile(t *testing.T) {
-	buf := make([]byte, 100000)
-	testCPUProfile(t, []string{"crc32.ChecksumIEEE"}, func() {
-		// This loop takes about a quarter second on a 2 GHz laptop.
-		// We only need to get one 100 Hz clock tick, so we've got
-		// a 25x safety buffer.
-		for i := 0; i < 1000; i++ {
-			crc32.ChecksumIEEE(buf)
+func cpuHogger(f func()) {
+	// We only need to get one 100 Hz clock tick, so we've got
+	// a 25x safety buffer.
+	// But do at least 500 iterations (which should take about 100ms),
+	// otherwise TestCPUProfileMultithreaded can fail if only one
+	// thread is scheduled during the 250ms period.
+	t0 := time.Now()
+	for i := 0; i < 500 || time.Since(t0) < 250*time.Millisecond; i++ {
+		f()
+	}
+}
+
+var (
+	salt1 = 0
+	salt2 = 0
+)
+
+// The actual CPU hogging function.
+// Must not call other functions nor access heap/globals in the loop,
+// otherwise under race detector the samples will be in the race runtime.
+func cpuHog1() {
+	foo := salt1
+	for i := 0; i < 1e5; i++ {
+		if foo > 0 {
+			foo *= foo
+		} else {
+			foo *= foo + 1
 		}
+	}
+	salt1 = foo
+}
+
+func cpuHog2() {
+	foo := salt2
+	for i := 0; i < 1e5; i++ {
+		if foo > 0 {
+			foo *= foo
+		} else {
+			foo *= foo + 2
+		}
+	}
+	salt2 = foo
+}
+
+func TestCPUProfile(t *testing.T) {
+	testCPUProfile(t, []string{"runtime/pprof_test.cpuHog1"}, func() {
+		cpuHogger(cpuHog1)
 	})
 }
 
 func TestCPUProfileMultithreaded(t *testing.T) {
-	buf := make([]byte, 100000)
 	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
-	testCPUProfile(t, []string{"crc32.ChecksumIEEE", "crc32.Update"}, func() {
+	testCPUProfile(t, []string{"runtime/pprof_test.cpuHog1", "runtime/pprof_test.cpuHog2"}, func() {
 		c := make(chan int)
 		go func() {
-			for i := 0; i < 2000; i++ {
-				crc32.Update(0, crc32.IEEETable, buf)
-			}
+			cpuHogger(cpuHog1)
 			c <- 1
 		}()
-		// This loop takes about a quarter second on a 2 GHz laptop.
-		// We only need to get one 100 Hz clock tick, so we've got
-		// a 25x safety buffer.
-		for i := 0; i < 2000; i++ {
-			crc32.ChecksumIEEE(buf)
-		}
+		cpuHogger(cpuHog2)
 		<-c
 	})
 }
@@ -110,7 +139,7 @@ func testCPUProfile(t *testing.T, need []string, f func()) {
 	f()
 	StopCPUProfile()
 
-	// Check that profile is well formed and contains ChecksumIEEE.
+	// Check that profile is well formed and contains need.
 	have := make([]uintptr, len(need))
 	parseProfile(t, prof.Bytes(), func(count uintptr, stk []uintptr) {
 		for _, pc := range stk {

From 50199d7b35ef684aef2122b9327b3cf5036b011a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Aug 2014 14:53:47 -0400
Subject: [PATCH 310/423] runtime: translate env*.c to Go

In an earlier CL I wrote a separate Go-only version, but that broke Plan 9,
because the Go-only version assumed a non-Plan 9 system.

Translate the real ones instead.

LGTM=r
R=golang-codereviews, r
CC=0intro, golang-codereviews, iant, khr
https://golang.org/cl/140050044
---
 src/pkg/runtime/cgo/setenv.c      |  2 +-
 src/pkg/runtime/env_plan9.c       | 42 --------------------
 src/pkg/runtime/env_plan9.go      | 58 ++++++++++++++++++++++++++++
 src/pkg/runtime/env_posix.c       | 64 -------------------------------
 src/pkg/runtime/env_posix.go      | 52 +++++++++++++++++++++++++
 src/pkg/runtime/extern.go         | 14 -------
 src/pkg/runtime/stubs.go          |  8 +++-
 src/pkg/runtime/sys_plan9_amd64.s |  2 +-
 src/pkg/runtime/thunk.s           |  3 ++
 9 files changed, 121 insertions(+), 124 deletions(-)
 delete mode 100644 src/pkg/runtime/env_plan9.c
 create mode 100644 src/pkg/runtime/env_plan9.go
 delete mode 100644 src/pkg/runtime/env_posix.c
 create mode 100644 src/pkg/runtime/env_posix.go

diff --git a/src/pkg/runtime/cgo/setenv.c b/src/pkg/runtime/cgo/setenv.c
index 2d03db09f1..ee529904f7 100644
--- a/src/pkg/runtime/cgo/setenv.c
+++ b/src/pkg/runtime/cgo/setenv.c
@@ -7,4 +7,4 @@
 #pragma cgo_import_static x_cgo_setenv
 
 void x_cgo_setenv(char**);
-void (*_cgo_setenv)(char**) = x_cgo_setenv;
+void (*runtime·_cgo_setenv)(char**) = x_cgo_setenv;
diff --git a/src/pkg/runtime/env_plan9.c b/src/pkg/runtime/env_plan9.c
deleted file mode 100644
index b6e98514f3..0000000000
--- a/src/pkg/runtime/env_plan9.c
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2012 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "runtime.h"
-#include "os_GOOS.h"
-
-byte*
-runtime·getenv(int8 *s)
-{
-	int32 fd, n, r;
-	intgo len;
-	byte file[128];
-	byte *p;
-	static byte b[128];
-
-	len = runtime·findnull((byte*)s);
-	if(len > sizeof file-6)
-		return nil;
-
-	runtime·memclr(file, sizeof file);
-	runtime·memmove((void*)file, (void*)"/env/", 5);
-	runtime·memmove((void*)(file+5), (void*)s, len);
-
-	fd = runtime·open((int8*)file, OREAD, 0);
-	if(fd < 0)
-		return nil;
-	n = runtime·seek(fd, 0, 2);
-	if(runtime·strcmp((byte*)s, (byte*)"GOTRACEBACK") == 0){
-		// should not call malloc
-		if(n >= sizeof b)
-			return nil;
-		runtime·memclr(b, sizeof b);
-		p = b;
-	}else
-		p = runtime·mallocgc(n+1, nil, 0);
-	r = runtime·pread(fd, p, n, 0);
-	runtime·close(fd);
-	if(r < 0)
-		return nil;
-	return p;
-}
diff --git a/src/pkg/runtime/env_plan9.go b/src/pkg/runtime/env_plan9.go
new file mode 100644
index 0000000000..85c1c856b0
--- /dev/null
+++ b/src/pkg/runtime/env_plan9.go
@@ -0,0 +1,58 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+func getenv(s *byte) *byte {
+	val := gogetenv(gostringnocopy(s))
+	if val == "" {
+		return nil
+	}
+	// Strings found in environment are NUL-terminated.
+	return &bytes(val)[0]
+}
+
+var tracebackbuf [128]byte
+
+func gogetenv(key string) string {
+	var file [128]byte
+	if len(key) > len(file)-6 {
+		return ""
+	}
+
+	copy(file[:], "/env/")
+	copy(file[5:], key)
+
+	fd := open(&file[0], _OREAD, 0)
+	if fd < 0 {
+		return ""
+	}
+	n := seek(fd, 0, 2)
+
+	var p unsafe.Pointer
+
+	// Be sure not to allocate for $GOTRACEBACK.
+	if key == "GOTRACEBACK" {
+		if n >= 128 {
+			return ""
+		}
+		p = unsafe.Pointer(&tracebackbuf[0])
+	} else {
+		p = gomallocgc(uintptr(n+1), nil, 0)
+	}
+
+	r := pread(fd, p, int32(n), 0)
+	close(fd)
+	if r < 0 {
+		return ""
+	}
+
+	var s string
+	sp := (*_string)(unsafe.Pointer(&s))
+	sp.str = (*byte)(p)
+	sp.len = int(r)
+	return s
+}
diff --git a/src/pkg/runtime/env_posix.c b/src/pkg/runtime/env_posix.c
deleted file mode 100644
index 8bc3ffb0a2..0000000000
--- a/src/pkg/runtime/env_posix.c
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
-
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-
-Slice syscall·envs;
-
-byte*
-runtime·getenv(int8 *s)
-{
-	int32 i, j;
-	intgo len;
-	byte *v, *bs;
-	String* envv;
-	int32 envc;
-
-	bs = (byte*)s;
-	len = runtime·findnull(bs);
-	envv = (String*)syscall·envs.array;
-	if(envv == nil)
-		runtime·throw("getenv before env init");
-	envc = syscall·envs.len;
-	for(i=0; i<envc; i++){
-		if(envv[i].len <= len)
-			continue;
-		v = envv[i].str;
-		for(j=0; j<len; j++)
-			if(bs[j] != v[j])
-				goto nomatch;
-		if(v[len] != '=')
-			goto nomatch;
-		return v+len+1;
-	nomatch:;
-	}
-	return nil;
-}
-
-void (*_cgo_setenv)(byte**);
-
-// Update the C environment if cgo is loaded.
-// Called from syscall.Setenv.
-void
-syscall·setenv_c(String k, String v)
-{
-	byte *arg[2];
-
-	if(_cgo_setenv == nil)
-		return;
-
-	arg[0] = runtime·mallocgc(k.len + 1, nil, 0);
-	runtime·memmove(arg[0], k.str, k.len);
-	arg[0][k.len] = 0;
-
-	arg[1] = runtime·mallocgc(v.len + 1, nil, 0);
-	runtime·memmove(arg[1], v.str, v.len);
-	arg[1][v.len] = 0;
-
-	runtime·asmcgocall((void*)_cgo_setenv, arg);
-}
diff --git a/src/pkg/runtime/env_posix.go b/src/pkg/runtime/env_posix.go
new file mode 100644
index 0000000000..6c04f6cc70
--- /dev/null
+++ b/src/pkg/runtime/env_posix.go
@@ -0,0 +1,52 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
+
+package runtime
+
+import "unsafe"
+
+func environ() []string
+
+func getenv(s *byte) *byte {
+	val := gogetenv(gostringnocopy(s))
+	if val == "" {
+		return nil
+	}
+	// Strings found in environment are NUL-terminated.
+	return &bytes(val)[0]
+}
+
+func gogetenv(key string) string {
+	env := environ()
+	if env == nil {
+		gothrow("getenv before env init")
+	}
+	for _, s := range environ() {
+		if len(s) > len(key) && s[len(key)] == '=' && s[:len(key)] == key {
+			return s[len(key)+1:]
+		}
+	}
+	return ""
+}
+
+var _cgo_setenv uintptr // pointer to C function
+
+// Update the C environment if cgo is loaded.
+// Called from syscall.Setenv.
+func syscall_setenv_c(k string, v string) {
+	if _cgo_setenv == 0 {
+		return
+	}
+	arg := [2]unsafe.Pointer{cstring(k), cstring(v)}
+	asmcgocall(unsafe.Pointer(_cgo_setenv), unsafe.Pointer(&arg))
+}
+
+func cstring(s string) unsafe.Pointer {
+	p := make([]byte, len(s)+1)
+	sp := (*_string)(unsafe.Pointer(&s))
+	memmove(unsafe.Pointer(&p[0]), unsafe.Pointer(sp.str), uintptr(len(s)))
+	return unsafe.Pointer(&p[0])
+}
diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index 0e48bb9d88..6b74c4fc25 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -149,20 +149,6 @@ func Callers(skip int, pc []uintptr) int {
 func callers(int32, *uintptr, int32) int32
 
 func getgoroot() string
-func environ() []string
-
-func gogetenv(key string) string {
-	env := environ()
-	if env == nil {
-		gothrow("getenv before env init")
-	}
-	for _, s := range env {
-		if len(s) > len(key) && s[len(key)] == '=' && s[:len(key)] == key {
-			return s[len(key)+1:]
-		}
-	}
-	return ""
-}
 
 // GOROOT returns the root of the Go tree.
 // It uses the GOROOT environment variable, if set,
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 237457f684..789aa2e9ff 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -152,7 +152,6 @@ func tracebackothers(gp *g)
 func cgocallback(fn, frame unsafe.Pointer, framesize uintptr)
 func gogo(buf *gobuf)
 func gosave(buf *gobuf)
-func open(name *byte, mode, perm int32) int32
 func read(fd int32, p unsafe.Pointer, n int32) int32
 func close(fd int32) int32
 func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
@@ -162,7 +161,6 @@ func asminit()
 func setg(gg *g)
 func exit(code int32)
 func breakpoint()
-func asmcgocall(fn, arg unsafe.Pointer)
 func nanotime() int64
 func usleep(usec uint32)
 func cputicks() int64
@@ -247,3 +245,9 @@ func getcallerpc(argp unsafe.Pointer) uintptr
 
 //go:noescape
 func getcallersp(argp unsafe.Pointer) uintptr
+
+//go:noescape
+func asmcgocall(fn, arg unsafe.Pointer)
+
+//go:noescape
+func open(name *byte, mode, perm int32) int32
diff --git a/src/pkg/runtime/sys_plan9_amd64.s b/src/pkg/runtime/sys_plan9_amd64.s
index ea0bd57b20..257f405c8d 100644
--- a/src/pkg/runtime/sys_plan9_amd64.s
+++ b/src/pkg/runtime/sys_plan9_amd64.s
@@ -36,7 +36,7 @@ TEXT _seek<>(SB),NOSPLIT,$0
 // int64 seek(int32, int64, int32)
 // Convenience wrapper around _seek, the actual system call.
 TEXT runtime·seek(SB),NOSPLIT,$32
-	LEAQ	$ret+24(FP), AX
+	LEAQ	ret+24(FP), AX
 	MOVL	fd+0(FP), BX
 	MOVQ	offset+8(FP), CX
 	MOVL	whence+16(FP), DX
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 508f50841a..75e52c81c1 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -70,3 +70,6 @@ TEXT reflect·chanrecv(SB), NOSPLIT, $0-0
 
 TEXT runtime∕debug·freeOSMemory(SB), NOSPLIT, $0-0
 	JMP	runtime·freeOSMemory(SB)
+
+TEXT syscall·setenv_c(SB), NOSPLIT, $0-0
+	JMP	runtime·syscall_setenv_c(SB)

From 86c4c4f00cc2ab6445ccb333c5b585bfe4a1002f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 30 Aug 2014 14:54:09 -0400
Subject: [PATCH 311/423] cmd/cc: generate error if #pragma pack off does
 anything

We can't translate misaligned things to Go, so start rejecting them in C.

The only one in any build appears to be EpollEvent on linux/amd64.
Fix that.

LGTM=r
R=golang-codereviews, r, dvyukov
CC=golang-codereviews, iant
https://golang.org/cl/137020043
---
 src/cmd/5c/swt.c                   | 9 ++++++---
 src/cmd/6c/swt.c                   | 9 ++++++---
 src/cmd/8c/swt.c                   | 9 ++++++---
 src/pkg/runtime/defs_linux_amd64.h | 2 +-
 src/pkg/runtime/netpoll_epoll.c    | 2 +-
 5 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/src/cmd/5c/swt.c b/src/cmd/5c/swt.c
index d24a5df9b0..f39963b8f2 100644
--- a/src/cmd/5c/swt.c
+++ b/src/cmd/5c/swt.c
@@ -374,10 +374,11 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 {
 	int32 o;
 	Type *v;
-	int w;
+	int w, packw;
 
 	o = i;
 	w = 1;
+	packw = 0;
 	switch(op) {
 	default:
 		diag(Z, "unknown align opcode %d", op);
@@ -388,7 +389,7 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		if(w < 1)
 			w = 1;
 		if(packflg)
-			w = packflg;
+			packw = packflg;
 		break;
 
 	case Ael1:	/* initial align of struct element */
@@ -404,7 +405,7 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		if(w < 1 || w > SZ_LONG)
 			fatal(Z, "align");
 		if(packflg) 
-			w = packflg;
+			packw = packflg;
 		break;
 
 	case Ael2:	/* width of a struct element */
@@ -440,6 +441,8 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		w = SZ_LONG;	/* because of a pun in cc/dcl.c:contig() */
 		break;
 	}
+	if(packw != 0 && xround(o, w) != xround(o, packw))
+		diag(Z, "#pragma pack changes offset of %T", t);
 	o = xround(o, w);
 	if(maxalign != nil && *maxalign < w)
 		*maxalign = w;
diff --git a/src/cmd/6c/swt.c b/src/cmd/6c/swt.c
index d7713648de..6e918eb109 100644
--- a/src/cmd/6c/swt.c
+++ b/src/cmd/6c/swt.c
@@ -250,10 +250,11 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 {
 	int32 o;
 	Type *v;
-	int w;
+	int w, packw;
 
 	o = i;
 	w = 1;
+	packw = 0;
 	switch(op) {
 	default:
 		diag(Z, "unknown align opcode %d", op);
@@ -264,7 +265,7 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		if(w < 1)
 			w = 1;
 		if(packflg)
-			w = packflg;
+			packw = packflg;
 		break;
 
 	case Ael1:	/* initial align of struct element */
@@ -277,7 +278,7 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		if(w < 1 || w > SZ_VLONG)
 			fatal(Z, "align");
 		if(packflg) 
-			w = packflg;
+			packw = packflg;
 		break;
 
 	case Ael2:	/* width of a struct element */
@@ -331,6 +332,8 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		o = align(o, t, Ael2, nil);
 		break;
 	}
+	if(packw != 0 && xround(o, w) != xround(o, packw))
+		diag(Z, "#pragma pack changes offset of %T", t);
 	o = xround(o, w);
 	if(maxalign && *maxalign < w)
 		*maxalign = w;
diff --git a/src/cmd/8c/swt.c b/src/cmd/8c/swt.c
index ae36f84eac..d960519e3b 100644
--- a/src/cmd/8c/swt.c
+++ b/src/cmd/8c/swt.c
@@ -255,10 +255,11 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 {
 	int32 o;
 	Type *v;
-	int w;
+	int w, packw;
 
 	o = i;
 	w = 1;
+	packw = 0;
 	switch(op) {
 	default:
 		diag(Z, "unknown align opcode %d", op);
@@ -269,7 +270,7 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		if(w < 1)
 			w = 1;
 		if(packflg)
-			w = packflg;
+			packw = packflg;
 		break;
 
 	case Ael1:	/* initial align of struct element */
@@ -285,7 +286,7 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		if(w < 1 || w > SZ_LONG)
 			fatal(Z, "align");
 		if(packflg) 
-			w = packflg;
+			packw = packflg;
 		break;
 
 	case Ael2:	/* width of a struct element */
@@ -320,6 +321,8 @@ align(int32 i, Type *t, int op, int32 *maxalign)
 		o = align(o, t, Ael2, nil);
 		break;
 	}
+	if(packw != 0 && xround(o, w) != xround(o, packw))
+		diag(Z, "#pragma pack changes offset of %T", t);
 	o = xround(o, w);
 	if(maxalign && *maxalign < w)
 		*maxalign = w;
diff --git a/src/pkg/runtime/defs_linux_amd64.h b/src/pkg/runtime/defs_linux_amd64.h
index 73fd9947a7..14616dffed 100644
--- a/src/pkg/runtime/defs_linux_amd64.h
+++ b/src/pkg/runtime/defs_linux_amd64.h
@@ -122,7 +122,7 @@ struct Itimerval {
 };
 struct EpollEvent {
 	uint32	events;
-	uint64	data;
+	byte	data[8]; // unaligned uintptr
 };
 
 
diff --git a/src/pkg/runtime/netpoll_epoll.c b/src/pkg/runtime/netpoll_epoll.c
index a0ae7df310..2cf9b3760d 100644
--- a/src/pkg/runtime/netpoll_epoll.c
+++ b/src/pkg/runtime/netpoll_epoll.c
@@ -37,7 +37,7 @@ runtime·netpollopen(uintptr fd, PollDesc *pd)
 	int32 res;
 
 	ev.events = EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET;
-	ev.data = (uint64)pd;
+	*(uintptr*)ev.data = (uintptr)pd;
 	res = runtime·epollctl(epfd, EPOLL_CTL_ADD, (int32)fd, &ev);
 	return -res;
 }

From a287567d3cd108513d337f647a3902d3b7fade34 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sat, 30 Aug 2014 18:15:55 -0700
Subject: [PATCH 312/423] runtime: fix Linux build

Make the definition of the EpollEvent data field consistent
across architectures, adapt the other use of it in
netpoll_epoll for the new definition, and use uint64 rather
than uintptr.

LGTM=dave
R=rsc, dave
CC=golang-codereviews
https://golang.org/cl/137890043
---
 src/pkg/runtime/defs_linux_386.h | 2 +-
 src/pkg/runtime/defs_linux_arm.h | 2 +-
 src/pkg/runtime/netpoll_epoll.c  | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pkg/runtime/defs_linux_386.h b/src/pkg/runtime/defs_linux_386.h
index d19bb7a00f..24a05d862a 100644
--- a/src/pkg/runtime/defs_linux_386.h
+++ b/src/pkg/runtime/defs_linux_386.h
@@ -204,7 +204,7 @@ struct Itimerval {
 };
 struct EpollEvent {
 	uint32	events;
-	uint64	data;
+	byte	data[8]; // to match amd64
 };
 
 
diff --git a/src/pkg/runtime/defs_linux_arm.h b/src/pkg/runtime/defs_linux_arm.h
index 61bd30d59c..50b3c919ed 100644
--- a/src/pkg/runtime/defs_linux_arm.h
+++ b/src/pkg/runtime/defs_linux_arm.h
@@ -163,6 +163,6 @@ typedef struct EpollEvent EpollEvent;
 struct EpollEvent {
 	uint32	events;
 	uint32	_pad;
-	uint64	data;
+	byte	data[8]; // to match amd64
 };
 #pragma pack off
diff --git a/src/pkg/runtime/netpoll_epoll.c b/src/pkg/runtime/netpoll_epoll.c
index 2cf9b3760d..9d6c205155 100644
--- a/src/pkg/runtime/netpoll_epoll.c
+++ b/src/pkg/runtime/netpoll_epoll.c
@@ -37,7 +37,7 @@ runtime·netpollopen(uintptr fd, PollDesc *pd)
 	int32 res;
 
 	ev.events = EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET;
-	*(uintptr*)ev.data = (uintptr)pd;
+	*(uint64*)ev.data = (uint64)(uintptr)pd;
 	res = runtime·epollctl(epfd, EPOLL_CTL_ADD, (int32)fd, &ev);
 	return -res;
 }
@@ -95,7 +95,7 @@ retry:
 		if(ev->events & (EPOLLOUT|EPOLLHUP|EPOLLERR))
 			mode += 'w';
 		if(mode)
-			runtime·netpollready(&gp, (void*)ev->data, mode);
+			runtime·netpollready(&gp, (void*)(uintptr)*(uint64*)ev->data, mode);
 	}
 	if(block && gp == nil)
 		goto retry;

From 686ecd83c04c9904de9457c7b14380cc2c04cff2 Mon Sep 17 00:00:00 2001
From: Nigel Tao <nigeltao@golang.org>
Date: Mon, 1 Sep 2014 10:02:52 +1000
Subject: [PATCH 313/423] image/png: make the CompressionLevel constants
 negative, reserving positive numbers to mean a numeric zlib compression
 level.

LGTM=bradfitz, ruiu
R=bradfitz, ruiu
CC=golang-codereviews, jeff.allen
https://golang.org/cl/138860043
---
 src/pkg/image/png/writer.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/pkg/image/png/writer.go b/src/pkg/image/png/writer.go
index b1a70c79d3..df23270ee9 100644
--- a/src/pkg/image/png/writer.go
+++ b/src/pkg/image/png/writer.go
@@ -33,10 +33,13 @@ type encoder struct {
 type CompressionLevel int
 
 const (
-	DefaultCompression CompressionLevel = iota
-	NoCompression
-	BestSpeed
-	BestCompression
+	DefaultCompression CompressionLevel = 0
+	NoCompression      CompressionLevel = -1
+	BestSpeed          CompressionLevel = -2
+	BestCompression    CompressionLevel = -3
+
+	// Positive CompressionLevel values are reserved to mean a numeric zlib
+	// compression level, although that is not implemented yet.
 )
 
 // Big-endian.

From 310bc98083c57b87df6e8020bfd97e35a8127bf1 Mon Sep 17 00:00:00 2001
From: Dmitri Shuralyov <shurcooL@gmail.com>
Date: Mon, 1 Sep 2014 12:03:23 +1000
Subject: [PATCH 314/423] net/http: fix typo in comment

LGTM=adg
R=golang-codereviews, adg
CC=golang-codereviews
https://golang.org/cl/138960043
---
 src/pkg/net/http/fs.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/net/http/fs.go b/src/pkg/net/http/fs.go
index 146b0026b9..bae902cd29 100644
--- a/src/pkg/net/http/fs.go
+++ b/src/pkg/net/http/fs.go
@@ -403,7 +403,7 @@ func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirec
 		return
 	}
 
-	// serverContent will check modification time
+	// serveContent will check modification time
 	sizeFunc := func() (int64, error) { return d.Size(), nil }
 	serveContent(w, r, d.Name(), d.ModTime(), sizeFunc, f)
 }

From 0bb14d74f1550dca916251ddb6e1703f95be7325 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 31 Aug 2014 22:49:14 -0400
Subject: [PATCH 315/423] cmd/ld: diagnose Go calling C

For example:
go build -ldflags -C cmd/go 2>&1 | awk '{print $NF}' | sort | uniq -c | sort -nr

LGTM=khr
R=khr, josharian
CC=golang-codereviews
https://golang.org/cl/135170044
---
 include/link.h              |  1 +
 src/cmd/cc/pgen.c           |  1 +
 src/cmd/ld/lib.c            | 53 +++++++++++++++++++++++++++++++++++++
 src/cmd/ld/lib.h            |  1 +
 src/cmd/ld/pobj.c           |  2 ++
 src/liblink/objfile.c       | 18 ++++++++++---
 src/pkg/debug/goobj/read.go |  6 +++--
 7 files changed, 76 insertions(+), 6 deletions(-)

diff --git a/include/link.h b/include/link.h
index 2b4de789d5..73f148c14c 100644
--- a/include/link.h
+++ b/include/link.h
@@ -126,6 +126,7 @@ struct	LSym
 	short	type;
 	short	version;
 	uchar	dupok;
+	uchar	cfunc;
 	uchar	external;
 	uchar	nosplit;
 	uchar	reachable;
diff --git a/src/cmd/cc/pgen.c b/src/cmd/cc/pgen.c
index 53410a11a0..99128d4005 100644
--- a/src/cmd/cc/pgen.c
+++ b/src/cmd/cc/pgen.c
@@ -131,6 +131,7 @@ codgen(Node *n, Node *nn)
 	nearln = nn->lineno;
 
 	p = gtext(n1->sym, stkoff);
+	p->from.sym->cfunc = 1;
 	sp = p;
 
 	/*
diff --git a/src/cmd/ld/lib.c b/src/cmd/ld/lib.c
index a68993715d..51e10bb99d 100644
--- a/src/cmd/ld/lib.c
+++ b/src/cmd/ld/lib.c
@@ -1554,3 +1554,56 @@ diag(char *fmt, ...)
 		errorexit();
 	}
 }
+
+void
+checkgo(void)
+{
+	LSym *s;
+	Reloc *r;
+	int i;
+	int changed;
+	
+	if(!debug['C'])
+		return;
+	
+	// TODO(rsc,khr): Eventually we want to get to no Go-called C functions at all,
+	// which would simplify this logic quite a bit.
+
+	// Mark every Go-called C function with cfunc=2, recursively.
+	do {
+		changed = 0;
+		for(s = ctxt->textp; s != nil; s = s->next) {
+			if(s->cfunc == 0 || (s->cfunc == 2 && s->nosplit)) {
+				for(i=0; i<s->nr; i++) {
+					r = &s->r[i];
+					if(r->sym == nil)
+						continue;
+					if((r->type == R_CALL || r->type == R_CALLARM) && r->sym->type == STEXT) {
+						if(r->sym->cfunc == 1) {
+							changed = 1;
+							r->sym->cfunc = 2;
+						}
+					}
+				}
+			}
+		}
+	}while(changed);
+
+	// Complain about Go-called C functions that can split the stack
+	// (that can be preempted for garbage collection or trigger a stack copy).
+	for(s = ctxt->textp; s != nil; s = s->next) {
+		if(s->cfunc == 0 || (s->cfunc == 2 && s->nosplit)) {
+			for(i=0; i<s->nr; i++) {
+				r = &s->r[i];
+				if(r->sym == nil)
+					continue;
+				if((r->type == R_CALL || r->type == R_CALLARM) && r->sym->type == STEXT) {
+					if(s->cfunc == 0 && r->sym->cfunc == 2 && !r->sym->nosplit)
+						print("Go %s calls C %s\n", s->name, r->sym->name);
+					else if(s->cfunc == 2 && s->nosplit && !r->sym->nosplit)
+						print("Go calls C %s calls %s\n", s->name, r->sym->name);
+				}
+			}
+		}
+	}
+}
diff --git a/src/cmd/ld/lib.h b/src/cmd/ld/lib.h
index dd23990234..067ffa0bcc 100644
--- a/src/cmd/ld/lib.h
+++ b/src/cmd/ld/lib.h
@@ -183,6 +183,7 @@ uint16	be16(uchar *b);
 uint32	be32(uchar *b);
 uint64	be64(uchar *b);
 void	callgraph(void);
+void	checkgo(void);
 void	cflush(void);
 void	codeblk(int64 addr, int64 size);
 vlong	cpos(void);
diff --git a/src/cmd/ld/pobj.c b/src/cmd/ld/pobj.c
index d78dacd368..54c5ef2472 100644
--- a/src/cmd/ld/pobj.c
+++ b/src/cmd/ld/pobj.c
@@ -71,6 +71,7 @@ main(int argc, char *argv[])
 	if(thechar == '6')
 		flagcount("8", "assume 64-bit addresses", &debug['8']);
 	flagfn1("B", "info: define ELF NT_GNU_BUILD_ID note", addbuildinfo);
+	flagcount("C", "check Go calls to C code", &debug['C']);
 	flagint64("D", "addr: data address", &INITDAT);
 	flagstr("E", "sym: entry symbol", &INITENTRY);
 	if(thechar == '5')
@@ -162,6 +163,7 @@ main(int argc, char *argv[])
 		mark(linklookup(ctxt, "runtime.read_tls_fallback", 0));
 	}
 
+	checkgo();
 	deadcode();
 	callgraph();
 	paramspace = "SP";	/* (FP) now (SP) on output */
diff --git a/src/liblink/objfile.c b/src/liblink/objfile.c
index 22c9199d5e..dc463d474e 100644
--- a/src/liblink/objfile.c
+++ b/src/liblink/objfile.c
@@ -38,7 +38,8 @@
 //	- type [int]
 //	- name [string]
 //	- version [int]
-//	- dupok [int]
+//	- flags [int]
+//		1 dupok
 //	- size [int]
 //	- gotype [symbol reference]
 //	- p [data block]
@@ -50,7 +51,9 @@
 //	- args [int]
 //	- locals [int]
 //	- nosplit [int]
-//	- leaf [int]
+//	- flags [int]
+//		1 leaf
+//		2 C function
 //	- nlocal [int]
 //	- local [nlocal automatics]
 //	- pcln [pcln table]
@@ -289,6 +292,8 @@ writesym(Link *ctxt, Biobuf *b, LSym *s)
 			Bprint(ctxt->bso, "t=%d ", s->type);
 		if(s->dupok)
 			Bprint(ctxt->bso, "dupok ");
+		if(s->cfunc)
+			Bprint(ctxt->bso, "cfunc ");
 		if(s->nosplit)
 			Bprint(ctxt->bso, "nosplit ");
 		Bprint(ctxt->bso, "size=%lld value=%lld", (vlong)s->size, (vlong)s->value);
@@ -351,7 +356,7 @@ writesym(Link *ctxt, Biobuf *b, LSym *s)
 		wrint(b, s->args);
 		wrint(b, s->locals);
 		wrint(b, s->nosplit);
-		wrint(b, s->leaf);
+		wrint(b, s->leaf | s->cfunc<<1);
 		n = 0;
 		for(a = s->autom; a != nil; a = a->link)
 			n++;
@@ -519,6 +524,7 @@ readsym(Link *ctxt, Biobuf *f, char *pkg, char *pn)
 	if(v != 0 && v != 1)
 		sysfatal("invalid symbol version %d", v);
 	dupok = rdint(f);
+	dupok &= 1;
 	size = rdint(f);
 	
 	if(v != 0)
@@ -573,7 +579,9 @@ readsym(Link *ctxt, Biobuf *f, char *pkg, char *pn)
 		s->args = rdint(f);
 		s->locals = rdint(f);
 		s->nosplit = rdint(f);
-		s->leaf = rdint(f);
+		v = rdint(f);
+		s->leaf = v&1;
+		s->cfunc = v&2;
 		n = rdint(f);
 		for(i=0; i<n; i++) {
 			a = emallocz(sizeof *a);
@@ -629,6 +637,8 @@ readsym(Link *ctxt, Biobuf *f, char *pkg, char *pn)
 			Bprint(ctxt->bso, "t=%d ", s->type);
 		if(s->dupok)
 			Bprint(ctxt->bso, "dupok ");
+		if(s->cfunc)
+			Bprint(ctxt->bso, "cfunc ");
 		if(s->nosplit)
 			Bprint(ctxt->bso, "nosplit ");
 		Bprint(ctxt->bso, "size=%lld value=%lld", (vlong)s->size, (vlong)s->value);
diff --git a/src/pkg/debug/goobj/read.go b/src/pkg/debug/goobj/read.go
index c95fe1e47f..79a83e59a6 100644
--- a/src/pkg/debug/goobj/read.go
+++ b/src/pkg/debug/goobj/read.go
@@ -602,7 +602,8 @@ func (r *objReader) parseObject(prefix []byte) error {
 		s := &Sym{SymID: r.readSymID()}
 		r.p.Syms = append(r.p.Syms, s)
 		s.Kind = SymKind(typ)
-		s.DupOK = r.readInt() != 0
+		flags := r.readInt()
+		s.DupOK = flags&1 != 0
 		s.Size = r.readInt()
 		s.Type = r.readSymID()
 		s.Data = r.readData()
@@ -623,7 +624,8 @@ func (r *objReader) parseObject(prefix []byte) error {
 			s.Func = f
 			f.Args = r.readInt()
 			f.Frame = r.readInt()
-			f.Leaf = r.readInt() != 0
+			flags := r.readInt()
+			f.Leaf = flags&1 != 0
 			f.NoSplit = r.readInt() != 0
 			f.Var = make([]Var, r.readInt())
 			for i := range f.Var {

From 709096f185e8ca00693e189cb41ae7f893812721 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor <iant@golang.org>
Date: Sun, 31 Aug 2014 22:59:43 -0400
Subject: [PATCH 316/423] misc/cgo/testcdefs: comment out test of packed
 structs

The [568]c compilers no longer support packed structs, so
using them with -cdefs no longer works.  Just commenting out
the test, rather than removing it, in case this needs to be
handled.  It may be that -cdefs can go away entirely in the
future, in which case so can this directory.

LGTM=mdempsky
R=rsc, mdempsky
CC=golang-codereviews
https://golang.org/cl/136030043
---
 misc/cgo/testcdefs/cdefstest.go | 3 ++-
 misc/cgo/testcdefs/main.c       | 9 +++++++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/misc/cgo/testcdefs/cdefstest.go b/misc/cgo/testcdefs/cdefstest.go
index 0804083a03..5e613c79e7 100644
--- a/misc/cgo/testcdefs/cdefstest.go
+++ b/misc/cgo/testcdefs/cdefstest.go
@@ -56,4 +56,5 @@ typedef struct timespec {
 import "C"
 
 type CdefsTest C.struct_cdefsTest
-type PackedTest C.struct_packedTest
+
+//type PackedTest C.struct_packedTest
diff --git a/misc/cgo/testcdefs/main.c b/misc/cgo/testcdefs/main.c
index c13a804306..594a431677 100644
--- a/misc/cgo/testcdefs/main.c
+++ b/misc/cgo/testcdefs/main.c
@@ -17,6 +17,8 @@ struct CdefsOrig {
 	int8 **array5[20][20];
 };
 
+// Packed structs are no longer supported for -cdefs.
+/*
 typedef struct PackedOrig PackedOrig;
 #pragma pack on
 struct PackedOrig {
@@ -25,14 +27,15 @@ struct PackedOrig {
 	int64 third;
 };
 #pragma pack off
+*/
 
 void
 main·test(int32 ret)
 {
 	CdefsOrig o;
 	CdefsTest t;
-	PackedOrig po;
-	PackedTest pt;
+	// PackedOrig po;
+	// PackedTest pt;
 	
 	ret = 0;
 	if(sizeof(t.array1) != sizeof(o.array1) || offsetof(CdefsTest, array1[0]) != offsetof(CdefsOrig, array1[0])) {
@@ -55,6 +58,7 @@ main·test(int32 ret)
 		runtime·printf("array5: size, offset = %d, %d, want %d, %d\n", sizeof(t.array5), offsetof(CdefsTest, array5[0][0]), sizeof(o.array5), offsetof(CdefsOrig, array5[0][0]));
 		ret = 1;
 	}
+/*
 	if(sizeof(pt.first) != sizeof(po.first) || offsetof(PackedTest, first) != offsetof(PackedOrig, first)) {
 		runtime·printf("first: size, offset = %d, %d, want %d, %d\n", sizeof(pt.first), offsetof(PackedTest, first), sizeof(po.first), offsetof(PackedOrig, first));
 		ret = 1;
@@ -67,5 +71,6 @@ main·test(int32 ret)
 		runtime·printf("third: size, offset = %d, %d, want %d, %d\n", sizeof(pt.third), offsetof(PackedTest, third), sizeof(po.third), offsetof(PackedOrig, third));
 		ret = 1;
 	}
+*/
 	FLUSH(&ret); // flush return value
 }

From 4dba769b7352b10fa95070f5095b93c4f5908f4d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 00:06:26 -0400
Subject: [PATCH 317/423] runtime: paste mprof.goc into mprof.go as comments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

NO CODE CHANGES HERE

The first conversion was not complete.
This CL doesn't make any actual changes,
but it inserts the missing mprof.goc code
as comments so that the next CL will have
useful diffs.

To make the diffs a bit more useful, removed
all semicolons, ->, and runtime· prefixes as well.

Also corrected order of a few functions in mprof.go
to match original order in mprof.goc.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews, iant, khr, r
https://golang.org/cl/134200043
---
 src/pkg/runtime/mprof.go | 424 +++++++++++++++++++++++++++++++++++----
 1 file changed, 384 insertions(+), 40 deletions(-)

diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 78384f8117..1acfdb9b89 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -17,11 +17,258 @@ var proflock mutex
 // All memory allocations are local and do not escape outside of the profiler.
 // The profiler is forbidden from referring to garbage-collected memory.
 
+/*
+enum { MProf, BProf }  // profile types
+*/
+
+/*
+// Per-call-stack profiling information.
+// Lookup by hashing call stack into a linked-list hash table.
+struct Bucket
+{
+	Bucket	*next	// next in hash list
+	Bucket	*allnext	// next in list of all mbuckets/bbuckets
+	int32	typ
+	// Generally unions can break precise GC,
+	// this one is fine because it does not contain pointers.
+	union
+	{
+		struct MProfRecord // typ == MProf
+		{
+			// The following complex 3-stage scheme of stats accumulation
+			// is required to obtain a consistent picture of mallocs and frees
+			// for some point in time.
+			// The problem is that mallocs come in real time, while frees
+			// come only after a GC during concurrent sweeping. So if we would
+			// naively count them, we would get a skew toward mallocs.
+			//
+			// Mallocs are accounted in recent stats.
+			// Explicit frees are accounted in recent stats.
+			// GC frees are accounted in prev stats.
+			// After GC prev stats are added to final stats and
+			// recent stats are moved into prev stats.
+			uintptr	allocs
+			uintptr	frees
+			uintptr	alloc_bytes
+			uintptr	free_bytes
+
+			uintptr	prev_allocs  // since last but one till last gc
+			uintptr	prev_frees
+			uintptr	prev_alloc_bytes
+			uintptr	prev_free_bytes
+
+			uintptr	recent_allocs  // since last gc till now
+			uintptr	recent_frees
+			uintptr	recent_alloc_bytes
+			uintptr	recent_free_bytes
+
+		} mp
+		struct BProfRecord // typ == BProf
+		{
+			int64	count
+			int64	cycles
+		} bp
+	} data
+	uintptr	hash	// hash of size + stk
+	uintptr	size
+	uintptr	nstk
+	uintptr	stk[1]
+}
+*/
+
 var (
 	mbuckets *bucket // memory profile buckets
 	bbuckets *bucket // blocking profile buckets
 )
 
+/*
+enum {
+	BuckHashSize = 179999,
+}
+static Bucket **buckhash
+static uintptr bucketmem
+*/
+
+/*
+// Return the bucket for stk[0:nstk], allocating new bucket if needed.
+static Bucket*
+stkbucket(int32 typ, uintptr size, uintptr *stk, int32 nstk, bool alloc)
+{
+	int32 i
+	uintptr h
+	Bucket *b
+
+	if(buckhash == nil) {
+		buckhash = sysAlloc(BuckHashSize*sizeof buckhash[0], &mstats.buckhash_sys)
+		if(buckhash == nil)
+			throw("runtime: cannot allocate memory")
+	}
+
+	// Hash stack.
+	h = 0
+	for(i=0 i<nstk i++) {
+		h += stk[i]
+		h += h<<10
+		h ^= h>>6
+	}
+	// hash in size
+	h += size
+	h += h<<10
+	h ^= h>>6
+	// finalize
+	h += h<<3
+	h ^= h>>11
+
+	i = h%BuckHashSize
+	for(b = buckhash[i] b b=b.next)
+		if(b.typ == typ && b.hash == h && b.size == size && b.nstk == nstk &&
+		   mcmp((byte*)b.stk, (byte*)stk, nstk*sizeof stk[0]) == 0)
+			return b
+
+	if(!alloc)
+		return nil
+
+	b = persistentalloc(sizeof *b + nstk*sizeof stk[0], 0, &mstats.buckhash_sys)
+	bucketmem += sizeof *b + nstk*sizeof stk[0]
+	memmove(b.stk, stk, nstk*sizeof stk[0])
+	b.typ = typ
+	b.hash = h
+	b.size = size
+	b.nstk = nstk
+	b.next = buckhash[i]
+	buckhash[i] = b
+	if(typ == MProf) {
+		b.allnext = mbuckets
+		mbuckets = b
+	} else {
+		b.allnext = bbuckets
+		bbuckets = b
+	}
+	return b
+}
+*/
+
+func mprof_GC() {
+	for b := mbuckets; b != nil; b = b.allnext {
+		b.data.mp.allocs += b.data.mp.prev_allocs
+		b.data.mp.frees += b.data.mp.prev_frees
+		b.data.mp.alloc_bytes += b.data.mp.prev_alloc_bytes
+		b.data.mp.free_bytes += b.data.mp.prev_free_bytes
+
+		b.data.mp.prev_allocs = b.data.mp.recent_allocs
+		b.data.mp.prev_frees = b.data.mp.recent_frees
+		b.data.mp.prev_alloc_bytes = b.data.mp.recent_alloc_bytes
+		b.data.mp.prev_free_bytes = b.data.mp.recent_free_bytes
+
+		b.data.mp.recent_allocs = 0
+		b.data.mp.recent_frees = 0
+		b.data.mp.recent_alloc_bytes = 0
+		b.data.mp.recent_free_bytes = 0
+	}
+}
+
+/*
+// Record that a gc just happened: all the 'recent' statistics are now real.
+void
+MProf_GC(void)
+{
+	lock(&proflock)
+	MProf_GC()
+	unlock(&proflock)
+}
+*/
+
+/*
+// Called by malloc to record a profiled block.
+void
+MProf_Malloc(void *p, uintptr size)
+{
+	uintptr stk[32]
+	Bucket *b
+	int32 nstk
+
+	nstk = callers(1, stk, nelem(stk))
+	lock(&proflock)
+	b = stkbucket(MProf, size, stk, nstk, true)
+	b.data.mp.recent_allocs++
+	b.data.mp.recent_alloc_bytes += size
+	unlock(&proflock)
+
+	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
+	// This reduces potential contention and chances of deadlocks.
+	// Since the object must be alive during call to MProf_Malloc,
+	// it's fine to do this non-atomically.
+	setprofilebucket(p, b)
+}
+*/
+
+/*
+void
+MProf_Free(Bucket *b, uintptr size, bool freed)
+{
+	lock(&proflock)
+	if(freed) {
+		b.data.mp.recent_frees++
+		b.data.mp.recent_free_bytes += size
+	} else {
+		b.data.mp.prev_frees++
+		b.data.mp.prev_free_bytes += size
+	}
+	unlock(&proflock)
+}
+*/
+
+/*
+int64 blockprofilerate  // in CPU ticks
+*/
+
+/*
+void
+SetBlockProfileRate(intgo rate)
+{
+	int64 r
+
+	if(rate <= 0)
+		r = 0  // disable profiling
+	else {
+		// convert ns to cycles, use float64 to prevent overflow during multiplication
+		r = (float64)rate*tickspersecond()/(1000*1000*1000)
+		if(r == 0)
+			r = 1
+	}
+	atomicstore64((uint64*)&blockprofilerate, r)
+}
+*/
+
+/*
+void
+blockevent(int64 cycles, int32 skip)
+{
+	int32 nstk
+	int64 rate
+	uintptr stk[32]
+	Bucket *b
+
+	if(cycles <= 0)
+		return
+	rate = atomicload64((uint64*)&blockprofilerate)
+	if(rate <= 0 || (rate > cycles && fastrand1()%rate > cycles))
+		return
+
+	if(g.m.curg == nil || g.m.curg == g)
+		nstk = callers(skip, stk, nelem(stk))
+	else
+		nstk = gcallers(g.m.curg, skip, stk, nelem(stk))
+	lock(&proflock)
+	b = stkbucket(BProf, 0, stk, nstk, true)
+	b.data.bp.count++
+	b.data.bp.cycles += cycles
+	unlock(&proflock)
+}
+*/
+
+// Go interface to profile data.
+
 // MemProfile returns n, the number of records in the current memory profile.
 // If len(p) >= n, MemProfile copies the profile into p and returns n, true.
 // If len(p) < n, MemProfile does not change p and returns n, false.
@@ -73,25 +320,6 @@ func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
 	return
 }
 
-func mprof_GC() {
-	for b := mbuckets; b != nil; b = b.allnext {
-		b.data.mp.allocs += b.data.mp.prev_allocs
-		b.data.mp.frees += b.data.mp.prev_frees
-		b.data.mp.alloc_bytes += b.data.mp.prev_alloc_bytes
-		b.data.mp.free_bytes += b.data.mp.prev_free_bytes
-
-		b.data.mp.prev_allocs = b.data.mp.recent_allocs
-		b.data.mp.prev_frees = b.data.mp.recent_frees
-		b.data.mp.prev_alloc_bytes = b.data.mp.recent_alloc_bytes
-		b.data.mp.prev_free_bytes = b.data.mp.recent_free_bytes
-
-		b.data.mp.recent_allocs = 0
-		b.data.mp.recent_frees = 0
-		b.data.mp.recent_alloc_bytes = 0
-		b.data.mp.recent_free_bytes = 0
-	}
-}
-
 // Write b's data to r.
 func record(r *MemProfileRecord, b *bucket) {
 	r.AllocBytes = int64(b.data.mp.alloc_bytes)
@@ -106,6 +334,20 @@ func record(r *MemProfileRecord, b *bucket) {
 	}
 }
 
+/*
+void
+iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr))
+{
+	Bucket *b
+
+	lock(&proflock)
+	for(b=mbuckets b b=b.allnext) {
+		callback(b, b.nstk, b.stk, b.size, b.data.mp.allocs, b.data.mp.frees)
+	}
+	unlock(&proflock)
+}
+*/
+
 // BlockProfile returns n, the number of records in the current blocking profile.
 // If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
 // If len(p) < n, BlockProfile does not change p and returns n, false.
@@ -141,6 +383,78 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 	return
 }
 
+// ThreadCreateProfile returns n, the number of records in the thread creation profile.
+// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
+// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
+//
+// Most clients should use the runtime/pprof package instead
+// of calling ThreadCreateProfile directly.
+func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
+	first := (*m)(atomicloadp(unsafe.Pointer(&allm)))
+	for mp := first; mp != nil; mp = mp.alllink {
+		n++
+	}
+	if n <= len(p) {
+		ok = true
+		i := 0
+		for mp := first; mp != nil; mp = mp.alllink {
+			for s := range mp.createstack {
+				p[i].Stack0[s] = uintptr(mp.createstack[s])
+			}
+			i++
+		}
+	}
+	return
+}
+
+/*
+func GoroutineProfile(b Slice) (n int, ok bool) {
+	uintptr pc, sp, i
+	TRecord *r
+	G *gp
+
+	sp = getcallersp(&b)
+	pc = (uintptr)getcallerpc(&b)
+
+	ok = false
+	n = gcount()
+	if(n <= b.len) {
+		semacquire(&worldsema, false)
+		g.m.gcing = 1
+		stoptheworld()
+
+		n = gcount()
+		if(n <= b.len) {
+			ok = true
+			r = (TRecord*)b.array
+			saveg(pc, sp, g, r++)
+			for(i = 0 i < allglen i++) {
+				gp = allg[i]
+				if(gp == g || readgstatus(gp) == Gdead)
+					continue
+				saveg(~(uintptr)0, ~(uintptr)0, gp, r++)
+			}
+		}
+
+		g.m.gcing = 0
+		semrelease(&worldsema)
+		starttheworld()
+	}
+}
+*/
+
+/*
+static void
+saveg(uintptr pc, uintptr sp, G *gp, TRecord *r)
+{
+	int32 n
+
+	n = gentraceback(pc, sp, 0, gp, 0, r.stk, nelem(r.stk), nil, nil, false)
+	if(n < nelem(r.stk))
+		r.stk[n] = 0
+}
+*/
+
 // Stack formats a stack trace of the calling goroutine into buf
 // and returns the number of bytes written to buf.
 // If all is true, Stack formats stack traces of all other goroutines
@@ -181,26 +495,56 @@ func Stack(buf []byte, all bool) int {
 	return n
 }
 
-// ThreadCreateProfile returns n, the number of records in the thread creation profile.
-// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
-// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
-//
-// Most clients should use the runtime/pprof package instead
-// of calling ThreadCreateProfile directly.
-func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
-	first := (*m)(atomicloadp(unsafe.Pointer(&allm)))
-	for mp := first; mp != nil; mp = mp.alllink {
-		n++
+/*
+// Tracing of alloc/free/gc.
+
+static Mutex tracelock
+
+void
+tracealloc(void *p, uintptr size, Type *type)
+{
+	lock(&tracelock)
+	g.m.traceback = 2
+	if(type == nil)
+		printf("tracealloc(%p, %p)\n", p, size)
+	else
+		printf("tracealloc(%p, %p, %S)\n", p, size, *type.string)
+	if(g.m.curg == nil || g == g.m.curg) {
+		goroutineheader(g)
+		traceback((uintptr)getcallerpc(&p), (uintptr)getcallersp(&p), 0, g)
+	} else {
+		goroutineheader(g.m.curg)
+		traceback(~(uintptr)0, ~(uintptr)0, 0, g.m.curg)
 	}
-	if n <= len(p) {
-		ok = true
-		i := 0
-		for mp := first; mp != nil; mp = mp.alllink {
-			for s := range mp.createstack {
-				p[i].Stack0[s] = uintptr(mp.createstack[s])
-			}
-			i++
-		}
-	}
-	return
+	printf("\n")
+	g.m.traceback = 0
+	unlock(&tracelock)
 }
+
+void
+tracefree(void *p, uintptr size)
+{
+	lock(&tracelock)
+	g.m.traceback = 2
+	printf("tracefree(%p, %p)\n", p, size)
+	goroutineheader(g)
+	traceback((uintptr)getcallerpc(&p), (uintptr)getcallersp(&p), 0, g)
+	printf("\n")
+	g.m.traceback = 0
+	unlock(&tracelock)
+}
+
+void
+tracegc(void)
+{
+	lock(&tracelock)
+	g.m.traceback = 2
+	printf("tracegc()\n")
+	// running on m.g0 stack show all non-g0 goroutines
+	tracebackothers(g)
+	printf("end tracegc\n")
+	printf("\n")
+	g.m.traceback = 0
+	unlock(&tracelock)
+}
+*/

From 76fb8a5e416d400c4c07b555cad91f860e9ec4bb Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Sun, 31 Aug 2014 21:32:13 -0700
Subject: [PATCH 318/423] archive/zip: add Writer.Flush

This is needed for callers to be able to keep track of the
writing position within a zip file. Otherwise it's not
possible to compute the size of headers, and the TOC isn't
written until the very end.

LGTM=adg
R=adg
CC=golang-codereviews
https://golang.org/cl/134210043
---
 src/pkg/archive/zip/writer.go      |  6 ++++++
 src/pkg/archive/zip/writer_test.go | 19 +++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/src/pkg/archive/zip/writer.go b/src/pkg/archive/zip/writer.go
index 6c9800a78f..170beec0ee 100644
--- a/src/pkg/archive/zip/writer.go
+++ b/src/pkg/archive/zip/writer.go
@@ -34,6 +34,12 @@ func NewWriter(w io.Writer) *Writer {
 	return &Writer{cw: &countWriter{w: bufio.NewWriter(w)}}
 }
 
+// Flush flushes any buffered data to the underlying writer.
+// Calling Flush is not normally necessary; calling Close is sufficient.
+func (w *Writer) Flush() error {
+	return w.cw.w.(*bufio.Writer).Flush()
+}
+
 // Close finishes writing the zip file by writing the central directory.
 // It does not (and can not) close the underlying writer.
 func (w *Writer) Close() error {
diff --git a/src/pkg/archive/zip/writer_test.go b/src/pkg/archive/zip/writer_test.go
index 4bfa870809..184a7d96a7 100644
--- a/src/pkg/archive/zip/writer_test.go
+++ b/src/pkg/archive/zip/writer_test.go
@@ -6,6 +6,7 @@ package zip
 
 import (
 	"bytes"
+	"io"
 	"io/ioutil"
 	"math/rand"
 	"os"
@@ -86,6 +87,24 @@ func TestWriter(t *testing.T) {
 	}
 }
 
+func TestWriterFlush(t *testing.T) {
+	var buf bytes.Buffer
+	w := NewWriter(struct{ io.Writer }{&buf})
+	_, err := w.Create("foo")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if buf.Len() > 0 {
+		t.Fatalf("Unexpected %d bytes already in buffer", buf.Len())
+	}
+	if err := w.Flush(); err != nil {
+		t.Fatal(err)
+	}
+	if buf.Len() == 0 {
+		t.Fatal("No bytes written after Flush")
+	}
+}
+
 func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
 	header := &FileHeader{
 		Name:   wt.Name,

From 933169febb90b2a1551a09b5761fda75be9d964d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 00:40:28 -0400
Subject: [PATCH 319/423] runtime: remove old malloc test programs

These haven't been run in ages.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews, iant, khr, r
https://golang.org/cl/134170043
---
 src/pkg/runtime/malloc1.go    |  26 ------
 src/pkg/runtime/mallocrand.go |  93 ----------------------
 src/pkg/runtime/mallocrep.go  |  72 -----------------
 src/pkg/runtime/mallocrep1.go | 144 ----------------------------------
 4 files changed, 335 deletions(-)
 delete mode 100644 src/pkg/runtime/malloc1.go
 delete mode 100644 src/pkg/runtime/mallocrand.go
 delete mode 100644 src/pkg/runtime/mallocrep.go
 delete mode 100644 src/pkg/runtime/mallocrep1.go

diff --git a/src/pkg/runtime/malloc1.go b/src/pkg/runtime/malloc1.go
deleted file mode 100644
index da92f4c2fb..0000000000
--- a/src/pkg/runtime/malloc1.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// trivial malloc test
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"runtime"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-
-func main() {
-	memstats := new(runtime.MemStats)
-	runtime.Free(runtime.Alloc(1))
-	runtime.ReadMemStats(memstats)
-	if *chatty {
-		fmt.Printf("%+v %v\n", memstats, uint64(0))
-	}
-}
diff --git a/src/pkg/runtime/mallocrand.go b/src/pkg/runtime/mallocrand.go
deleted file mode 100644
index f1bcb89cfa..0000000000
--- a/src/pkg/runtime/mallocrand.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Random malloc test.
-
-package main
-
-import (
-	"flag"
-	"math/rand"
-	"runtime"
-	"unsafe"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-
-var footprint uint64
-var allocated uint64
-
-func bigger() {
-	memstats := new(runtime.MemStats)
-	runtime.ReadMemStats(memstats)
-	if f := memstats.Sys; footprint < f {
-		footprint = f
-		if *chatty {
-			println("Footprint", footprint, " for ", allocated)
-		}
-		if footprint > 1e9 {
-			println("too big")
-			panic("fail")
-		}
-	}
-}
-
-// Prime the data structures by allocating one of
-// each block in order.  After this, there should be
-// little reason to ask for more memory from the OS.
-func prime() {
-	for i := 0; i < 16; i++ {
-		b := runtime.Alloc(1 << uint(i))
-		runtime.Free(b)
-	}
-	for i := uintptr(0); i < 256; i++ {
-		b := runtime.Alloc(i << 12)
-		runtime.Free(b)
-	}
-}
-
-func memset(b *byte, c byte, n uintptr) {
-	np := uintptr(n)
-	for i := uintptr(0); i < np; i++ {
-		*(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b)) + i)) = c
-	}
-}
-
-func main() {
-	flag.Parse()
-	//	prime()
-	var blocks [1]struct {
-		base *byte
-		siz  uintptr
-	}
-	for i := 0; i < 1<<10; i++ {
-		if i%(1<<10) == 0 && *chatty {
-			println(i)
-		}
-		b := rand.Int() % len(blocks)
-		if blocks[b].base != nil {
-			//	println("Free", blocks[b].siz, blocks[b].base)
-			runtime.Free(blocks[b].base)
-			blocks[b].base = nil
-			allocated -= uint64(blocks[b].siz)
-			continue
-		}
-		siz := uintptr(rand.Int() >> (11 + rand.Uint32()%20))
-		base := runtime.Alloc(siz)
-		//	ptr := uintptr(syscall.BytePtr(base))+uintptr(siz/2)
-		//	obj, size, ref, ok := allocator.find(ptr)
-		//	if obj != base || *ref != 0 || !ok {
-		//		println("find", siz, obj, ref, ok)
-		//		panic("fail")
-		//	}
-		blocks[b].base = base
-		blocks[b].siz = siz
-		allocated += uint64(siz)
-		//	println("Alloc", siz, base)
-		memset(base, 0xbb, siz)
-		bigger()
-	}
-}
diff --git a/src/pkg/runtime/mallocrep.go b/src/pkg/runtime/mallocrep.go
deleted file mode 100644
index 03ee71edb4..0000000000
--- a/src/pkg/runtime/mallocrep.go
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Repeated malloc test.
-
-// +build ignore
-
-package main
-
-import (
-	"flag"
-	"runtime"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-
-var oldsys uint64
-var memstats runtime.MemStats
-
-func bigger() {
-	st := &memstats
-	runtime.ReadMemStats(st)
-	if oldsys < st.Sys {
-		oldsys = st.Sys
-		if *chatty {
-			println(st.Sys, " system bytes for ", st.Alloc, " Go bytes")
-		}
-		if st.Sys > 1e9 {
-			println("too big")
-			panic("fail")
-		}
-	}
-}
-
-func main() {
-	runtime.GC()                    // clean up garbage from init
-	runtime.ReadMemStats(&memstats) // first call can do some allocations
-	runtime.MemProfileRate = 0      // disable profiler
-	stacks := memstats.Alloc        // ignore stacks
-	flag.Parse()
-	for i := 0; i < 1<<7; i++ {
-		for j := 1; j <= 1<<22; j <<= 1 {
-			if i == 0 && *chatty {
-				println("First alloc:", j)
-			}
-			if a := memstats.Alloc - stacks; a != 0 {
-				println("no allocations but stats report", a, "bytes allocated")
-				panic("fail")
-			}
-			b := runtime.Alloc(uintptr(j))
-			runtime.ReadMemStats(&memstats)
-			during := memstats.Alloc - stacks
-			runtime.Free(b)
-			runtime.ReadMemStats(&memstats)
-			if a := memstats.Alloc - stacks; a != 0 {
-				println("allocated ", j, ": wrong stats: during=", during, " after=", a, " (want 0)")
-				panic("fail")
-			}
-			bigger()
-		}
-		if i%(1<<10) == 0 && *chatty {
-			println(i)
-		}
-		if i == 0 {
-			if *chatty {
-				println("Primed", i)
-			}
-			//	runtime.frozen = true
-		}
-	}
-}
diff --git a/src/pkg/runtime/mallocrep1.go b/src/pkg/runtime/mallocrep1.go
deleted file mode 100644
index bc33e3a6b4..0000000000
--- a/src/pkg/runtime/mallocrep1.go
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Repeated malloc test.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"runtime"
-	"strconv"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-var reverse = flag.Bool("r", false, "reverse")
-var longtest = flag.Bool("l", false, "long test")
-
-var b []*byte
-var stats = new(runtime.MemStats)
-
-func OkAmount(size, n uintptr) bool {
-	if n < size {
-		return false
-	}
-	if size < 16*8 {
-		if n > size+16 {
-			return false
-		}
-	} else {
-		if n > size*9/8 {
-			return false
-		}
-	}
-	return true
-}
-
-func AllocAndFree(size, count int) {
-	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
-	if *chatty {
-		fmt.Printf("size=%d count=%d ...\n", size, count)
-	}
-	runtime.ReadMemStats(stats)
-	n1 := stats.Alloc
-	for i := 0; i < count; i++ {
-		b[i] = runtime.Alloc(uintptr(size))
-		base, n := runtime.Lookup(b[i])
-		if base != b[i] || !OkAmount(uintptr(size), n) {
-			println("lookup failed: got", base, n, "for", b[i])
-			panic("fail")
-		}
-		runtime.ReadMemStats(stats)
-		if stats.Sys > 1e9 {
-			println("too much memory allocated")
-			panic("fail")
-		}
-	}
-	runtime.ReadMemStats(stats)
-	n2 := stats.Alloc
-	if *chatty {
-		fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
-	}
-	n3 := stats.Alloc
-	for j := 0; j < count; j++ {
-		i := j
-		if *reverse {
-			i = count - 1 - j
-		}
-		alloc := uintptr(stats.Alloc)
-		base, n := runtime.Lookup(b[i])
-		if base != b[i] || !OkAmount(uintptr(size), n) {
-			println("lookup failed: got", base, n, "for", b[i])
-			panic("fail")
-		}
-		runtime.Free(b[i])
-		runtime.ReadMemStats(stats)
-		if stats.Alloc != uint64(alloc-n) {
-			println("free alloc got", stats.Alloc, "expected", alloc-n, "after free of", n)
-			panic("fail")
-		}
-		if stats.Sys > 1e9 {
-			println("too much memory allocated")
-			panic("fail")
-		}
-	}
-	runtime.ReadMemStats(stats)
-	n4 := stats.Alloc
-
-	if *chatty {
-		fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
-	}
-	if n2-n1 != n3-n4 {
-		println("wrong alloc count: ", n2-n1, n3-n4)
-		panic("fail")
-	}
-}
-
-func atoi(s string) int {
-	i, _ := strconv.Atoi(s)
-	return i
-}
-
-func main() {
-	runtime.MemProfileRate = 0 // disable profiler
-	flag.Parse()
-	b = make([]*byte, 10000)
-	if flag.NArg() > 0 {
-		AllocAndFree(atoi(flag.Arg(0)), atoi(flag.Arg(1)))
-		return
-	}
-	maxb := 1 << 22
-	if !*longtest {
-		maxb = 1 << 19
-	}
-	for j := 1; j <= maxb; j <<= 1 {
-		n := len(b)
-		max := uintptr(1 << 28)
-		if !*longtest {
-			max = uintptr(maxb)
-		}
-		if uintptr(j)*uintptr(n) > max {
-			n = int(max / uintptr(j))
-		}
-		if n < 10 {
-			n = 10
-		}
-		for m := 1; m <= n; {
-			AllocAndFree(j, m)
-			if m == n {
-				break
-			}
-			m = 5 * m / 4
-			if m < 4 {
-				m++
-			}
-			if m > n {
-				m = n
-			}
-		}
-	}
-}

From 553378079522ca9f131c62acf9cc0a583c76164b Mon Sep 17 00:00:00 2001
From: Rui Ueyama <ruiu@google.com>
Date: Mon, 1 Sep 2014 17:47:57 +1000
Subject: [PATCH 320/423] strings: use Rabin-Karp algorithm for LastIndex.

benchmark                  old ns/op     new ns/op     delta
BenchmarkSingleMatch       49443         52275         +5.73%
BenchmarkIndex             28.8          27.4          -4.86%
BenchmarkLastIndex         14.5          14.0          -3.45%
BenchmarkLastIndexHard1    3982782       2309200       -42.02%
BenchmarkLastIndexHard2    3985562       2287715       -42.60%
BenchmarkLastIndexHard3    3555259       2282866       -35.79%

LGTM=josharian, nigeltao
R=golang-codereviews, ality, josharian, bradfitz, dave, nigeltao, gobot, nightlyone
CC=golang-codereviews
https://golang.org/cl/102560043
---
 src/pkg/strings/strings.go      | 60 ++++++++++++++++++++++++++-------
 src/pkg/strings/strings_test.go | 19 +++++++++++
 2 files changed, 67 insertions(+), 12 deletions(-)

diff --git a/src/pkg/strings/strings.go b/src/pkg/strings/strings.go
index 5f19695d3f..761f32a068 100644
--- a/src/pkg/strings/strings.go
+++ b/src/pkg/strings/strings.go
@@ -43,13 +43,29 @@ func explode(s string, n int) []string {
 // primeRK is the prime base used in Rabin-Karp algorithm.
 const primeRK = 16777619
 
-// hashstr returns the hash and the appropriate multiplicative
+// hashStr returns the hash and the appropriate multiplicative
 // factor for use in Rabin-Karp algorithm.
-func hashstr(sep string) (uint32, uint32) {
+func hashStr(sep string) (uint32, uint32) {
 	hash := uint32(0)
 	for i := 0; i < len(sep); i++ {
 		hash = hash*primeRK + uint32(sep[i])
+	}
+	var pow, sq uint32 = 1, primeRK
+	for i := len(sep); i > 0; i >>= 1 {
+		if i&1 != 0 {
+			pow *= sq
+		}
+		sq *= sq
+	}
+	return hash, pow
+}
 
+// hashStrRev returns the hash of the reverse of sep and the
+// appropriate multiplicative factor for use in Rabin-Karp algorithm.
+func hashStrRev(sep string) (uint32, uint32) {
+	hash := uint32(0)
+	for i := len(sep) - 1; i >= 0; i-- {
+		hash = hash*primeRK + uint32(sep[i])
 	}
 	var pow, sq uint32 = 1, primeRK
 	for i := len(sep); i > 0; i >>= 1 {
@@ -85,7 +101,8 @@ func Count(s, sep string) int {
 		}
 		return 0
 	}
-	hashsep, pow := hashstr(sep)
+	// Rabin-Karp search
+	hashsep, pow := hashStr(sep)
 	h := uint32(0)
 	for i := 0; i < len(sep); i++ {
 		h = h*primeRK + uint32(s[i])
@@ -139,8 +156,8 @@ func Index(s, sep string) int {
 	case n > len(s):
 		return -1
 	}
-	// Hash sep.
-	hashsep, pow := hashstr(sep)
+	// Rabin-Karp search
+	hashsep, pow := hashStr(sep)
 	var h uint32
 	for i := 0; i < n; i++ {
 		h = h*primeRK + uint32(s[i])
@@ -163,22 +180,41 @@ func Index(s, sep string) int {
 // LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.
 func LastIndex(s, sep string) int {
 	n := len(sep)
-	if n == 0 {
+	switch {
+	case n == 0:
 		return len(s)
-	}
-	c := sep[0]
-	if n == 1 {
+	case n == 1:
 		// special case worth making fast
+		c := sep[0]
 		for i := len(s) - 1; i >= 0; i-- {
 			if s[i] == c {
 				return i
 			}
 		}
 		return -1
+	case n == len(s):
+		if sep == s {
+			return 0
+		}
+		return -1
+	case n > len(s):
+		return -1
 	}
-	// n > 1
-	for i := len(s) - n; i >= 0; i-- {
-		if s[i] == c && s[i:i+n] == sep {
+	// Rabin-Karp search from the end of the string
+	hashsep, pow := hashStrRev(sep)
+	last := len(s) - n
+	var h uint32
+	for i := len(s) - 1; i >= last; i-- {
+		h = h*primeRK + uint32(s[i])
+	}
+	if h == hashsep && s[last:] == sep {
+		return last
+	}
+	for i := last - 1; i >= 0; i-- {
+		h *= primeRK
+		h += uint32(s[i])
+		h -= pow * uint32(s[i+n])
+		if h == hashsep && s[i:i+n] == sep {
 			return i
 		}
 	}
diff --git a/src/pkg/strings/strings_test.go b/src/pkg/strings/strings_test.go
index 27c0314fe8..7bb81ef3ca 100644
--- a/src/pkg/strings/strings_test.go
+++ b/src/pkg/strings/strings_test.go
@@ -168,6 +168,15 @@ func BenchmarkIndex(b *testing.B) {
 	}
 }
 
+func BenchmarkLastIndex(b *testing.B) {
+	if got := Index(benchmarkString, "v"); got != 17 {
+		b.Fatalf("wrong index: expected 17, got=%d", got)
+	}
+	for i := 0; i < b.N; i++ {
+		LastIndex(benchmarkString, "v")
+	}
+}
+
 func BenchmarkIndexByte(b *testing.B) {
 	if got := IndexByte(benchmarkString, 'v'); got != 17 {
 		b.Fatalf("wrong index: expected 17, got=%d", got)
@@ -1087,6 +1096,12 @@ func benchmarkIndexHard(b *testing.B, sep string) {
 	}
 }
 
+func benchmarkLastIndexHard(b *testing.B, sep string) {
+	for i := 0; i < b.N; i++ {
+		LastIndex(benchInputHard, sep)
+	}
+}
+
 func benchmarkCountHard(b *testing.B, sep string) {
 	for i := 0; i < b.N; i++ {
 		Count(benchInputHard, sep)
@@ -1097,6 +1112,10 @@ func BenchmarkIndexHard1(b *testing.B) { benchmarkIndexHard(b, "<>") }
 func BenchmarkIndexHard2(b *testing.B) { benchmarkIndexHard(b, "</pre>") }
 func BenchmarkIndexHard3(b *testing.B) { benchmarkIndexHard(b, "<b>hello world</b>") }
 
+func BenchmarkLastIndexHard1(b *testing.B) { benchmarkLastIndexHard(b, "<>") }
+func BenchmarkLastIndexHard2(b *testing.B) { benchmarkLastIndexHard(b, "</pre>") }
+func BenchmarkLastIndexHard3(b *testing.B) { benchmarkLastIndexHard(b, "<b>hello world</b>") }
+
 func BenchmarkCountHard1(b *testing.B) { benchmarkCountHard(b, "<>") }
 func BenchmarkCountHard2(b *testing.B) { benchmarkCountHard(b, "</pre>") }
 func BenchmarkCountHard3(b *testing.B) { benchmarkCountHard(b, "<b>hello world</b>") }

From f16729781bc7bfe561658f520dcbffa5f81790c2 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Mon, 1 Sep 2014 08:04:33 -0400
Subject: [PATCH 321/423] runtime/race: better handling of atomic operations
 This change fixes the last known false negative of the race detector --
 detection of races between mutating atomic operations and non-atomic
 operations. Race runtime already has functions for precise modelling of
 various atomic operations, so this change just forwards all atomic ops to
 race runtime instead of poor man modeling in sync/atomic package. Performance
 is also improved -- full sync/atomic tests run in 60s instead of 85s now.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rsc
https://golang.org/cl/111310044
---
 src/pkg/runtime/race.c                       |  35 +--
 src/pkg/runtime/race/README                  |   2 +-
 src/pkg/runtime/race/race_darwin_amd64.syso  | Bin 249744 -> 278328 bytes
 src/pkg/runtime/race/race_freebsd_amd64.syso | Bin 261096 -> 294224 bytes
 src/pkg/runtime/race/race_linux_amd64.syso   | Bin 265024 -> 298064 bytes
 src/pkg/runtime/race/race_windows_amd64.syso | Bin 247609 -> 292311 bytes
 src/pkg/runtime/race/testdata/atomic_test.go |   6 +-
 src/pkg/runtime/race_amd64.s                 | 137 ++++++++-
 src/pkg/sync/atomic/doc.go                   |   2 -
 src/pkg/sync/atomic/race.go                  | 276 -------------------
 src/pkg/sync/atomic/race.s                   |   8 +
 11 files changed, 166 insertions(+), 300 deletions(-)
 delete mode 100644 src/pkg/sync/atomic/race.go
 create mode 100644 src/pkg/sync/atomic/race.s

diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index 07623be1aa..a773addb07 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -24,6 +24,8 @@ void __tsan_malloc(void);
 void __tsan_acquire(void);
 void __tsan_release(void);
 void __tsan_release_merge(void);
+void __tsan_go_ignore_sync_begin(void);
+void __tsan_go_ignore_sync_end(void);
 
 // Mimic what cmd/cgo would do.
 #pragma cgo_import_static __tsan_init
@@ -36,6 +38,8 @@ void __tsan_release_merge(void);
 #pragma cgo_import_static __tsan_acquire
 #pragma cgo_import_static __tsan_release
 #pragma cgo_import_static __tsan_release_merge
+#pragma cgo_import_static __tsan_go_ignore_sync_begin
+#pragma cgo_import_static __tsan_go_ignore_sync_end
 
 // These are called from race_amd64.s.
 #pragma cgo_import_static __tsan_read
@@ -47,6 +51,17 @@ void __tsan_release_merge(void);
 #pragma cgo_import_static __tsan_func_enter
 #pragma cgo_import_static __tsan_func_exit
 
+#pragma cgo_import_static __tsan_go_atomic32_load
+#pragma cgo_import_static __tsan_go_atomic64_load
+#pragma cgo_import_static __tsan_go_atomic32_store
+#pragma cgo_import_static __tsan_go_atomic64_store
+#pragma cgo_import_static __tsan_go_atomic32_exchange
+#pragma cgo_import_static __tsan_go_atomic64_exchange
+#pragma cgo_import_static __tsan_go_atomic32_fetch_add
+#pragma cgo_import_static __tsan_go_atomic64_fetch_add
+#pragma cgo_import_static __tsan_go_atomic32_compare_exchange
+#pragma cgo_import_static __tsan_go_atomic64_compare_exchange
+
 extern byte runtime·noptrdata[];
 extern byte runtime·enoptrbss[];
   
@@ -250,32 +265,20 @@ runtime·RaceReleaseMerge(void *addr)
 	runtime·racereleasemerge(addr);
 }
 
-// func RaceSemacquire(s *uint32)
-void
-runtime·RaceSemacquire(uint32 *s)
-{
-	runtime·semacquire(s, false);
-}
-
-// func RaceSemrelease(s *uint32)
-void
-runtime·RaceSemrelease(uint32 *s)
-{
-	runtime·semrelease(s);
-}
-
 // func RaceDisable()
 void
 runtime·RaceDisable(void)
 {
-	g->raceignore++;
+	if(g->raceignore++ == 0)
+		runtime·racecall(__tsan_go_ignore_sync_begin, g->racectx);
 }
 
 // func RaceEnable()
 void
 runtime·RaceEnable(void)
 {
-	g->raceignore--;
+	if(--g->raceignore == 0)
+		runtime·racecall(__tsan_go_ignore_sync_end, g->racectx);
 }
 
 typedef struct SymbolizeContext SymbolizeContext;
diff --git a/src/pkg/runtime/race/README b/src/pkg/runtime/race/README
index 6a4259141e..7f185359fe 100644
--- a/src/pkg/runtime/race/README
+++ b/src/pkg/runtime/race/README
@@ -9,4 +9,4 @@ $ ./buildgo.sh
 
 Tested with gcc 4.6.1 and 4.7.0.  On Windows it's built with 64-bit MinGW.
 
-Current runtime is built on rev 210365.
+Current runtime is built on rev 215000.
diff --git a/src/pkg/runtime/race/race_darwin_amd64.syso b/src/pkg/runtime/race/race_darwin_amd64.syso
index 9061ce0aa119f99a9694e8629c600ae6a68cdc2e..81b48c6c9471cfd8adbb9c7bb725b5ee75e00488 100644
GIT binary patch
literal 278328
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
NJLs$<(i_{q`vdDv2PFUi

delta 79106
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%0DSbx^pVJ~uJqL>1g!~z*JCmo%(?+Q#
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
XiY+{oU4_HwO37;1#`;?nUe^2{Mt5Ou

diff --git a/src/pkg/runtime/race/race_freebsd_amd64.syso b/src/pkg/runtime/race/race_freebsd_amd64.syso
index b25d868f48ef01c4705db3e1bc179ebd8afe4de7..5bbe322299d94b0e9a5cded83a96237a8e742644 100644
GIT binary patch
literal 294224
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

literal 261096
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
JwfsEZ{{vF|0dN2S

diff --git a/src/pkg/runtime/race/race_linux_amd64.syso b/src/pkg/runtime/race/race_linux_amd64.syso
index 8fd77ae58b3d810b98c4177e47419344fab7cecd..49bf08ef38f9377b13c8fe88def10f96baf295d6 100644
GIT binary patch
literal 298064
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
btvs78Z}y9f@%!R2f9GN(?Cm$^???O}z9Qp+

literal 265024
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

diff --git a/src/pkg/runtime/race/race_windows_amd64.syso b/src/pkg/runtime/race/race_windows_amd64.syso
index 3ea80a6657f5f83cd1e50ea78508f5481da13426..a4eae9bdd9161e755c1f919def408c8f11c03c80 100644
GIT binary patch
literal 292311
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%0A$WU4g$%4T9-Knr1=XvG6!TH*Wpu+$^3aK)>T1V
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
V?ku(}y;+F17q``Q)0yhP{{`j&J+uG-

literal 247609
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

diff --git a/src/pkg/runtime/race/testdata/atomic_test.go b/src/pkg/runtime/race/testdata/atomic_test.go
index fc569b96cb..232744b3dd 100644
--- a/src/pkg/runtime/race/testdata/atomic_test.go
+++ b/src/pkg/runtime/race/testdata/atomic_test.go
@@ -225,8 +225,7 @@ func TestNoRaceAtomicStoreCASUint64(t *testing.T) {
 	x = 1
 }
 
-// Races with non-atomic loads are not detected.
-func TestRaceFailingAtomicStoreLoad(t *testing.T) {
+func TestRaceAtomicStoreLoad(t *testing.T) {
 	c := make(chan bool)
 	var a uint64
 	go func() {
@@ -248,8 +247,7 @@ func TestRaceAtomicLoadStore(t *testing.T) {
 	<-c
 }
 
-// Races with non-atomic loads are not detected.
-func TestRaceFailingAtomicAddLoad(t *testing.T) {
+func TestRaceAtomicAddLoad(t *testing.T) {
 	c := make(chan bool)
 	var a uint64
 	go func() {
diff --git a/src/pkg/runtime/race_amd64.s b/src/pkg/runtime/race_amd64.s
index f4e72386d8..a4a9dfeb55 100644
--- a/src/pkg/runtime/race_amd64.s
+++ b/src/pkg/runtime/race_amd64.s
@@ -79,7 +79,7 @@ TEXT	runtime·RaceWrite(SB), NOSPLIT, $0-8
 TEXT	runtime·racewritepc(SB), NOSPLIT, $0-24
 	MOVQ	addr+0(FP), RARG1
 	MOVQ	callpc+8(FP), RARG2
-	MOVQ	cp+16(FP), RARG3
+	MOVQ	pc+16(FP), RARG3
 	// void __tsan_write_pc(ThreadState *thr, void *addr, void *callpc, void *pc);
 	MOVQ	$__tsan_write_pc(SB), AX
 	JMP	racecalladdr<>(SB)
@@ -180,6 +180,141 @@ TEXT	runtime·racefuncexit(SB), NOSPLIT, $0-0
 	MOVQ	$__tsan_func_exit(SB), AX
 	JMP	racecall<>(SB)
 
+// Atomic operations for sync/atomic package.
+
+// Load
+TEXT	sync∕atomic·LoadInt32(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic32_load(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·LoadInt64(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic64_load(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·LoadUint32(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·LoadInt32(SB)
+
+TEXT	sync∕atomic·LoadUint64(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·LoadInt64(SB)
+
+TEXT	sync∕atomic·LoadUintptr(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·LoadInt64(SB)
+
+TEXT	sync∕atomic·LoadPointer(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·LoadInt64(SB)
+
+// Store
+TEXT	sync∕atomic·StoreInt32(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic32_store(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·StoreInt64(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic64_store(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·StoreUint32(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·StoreInt32(SB)
+
+TEXT	sync∕atomic·StoreUint64(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·StoreInt64(SB)
+
+TEXT	sync∕atomic·StoreUintptr(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·StoreInt64(SB)
+
+TEXT	sync∕atomic·StorePointer(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·StoreInt64(SB)
+
+// Swap
+TEXT	sync∕atomic·SwapInt32(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic32_exchange(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·SwapInt64(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic64_exchange(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·SwapUint32(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·SwapInt32(SB)
+
+TEXT	sync∕atomic·SwapUint64(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·SwapInt64(SB)
+
+TEXT	sync∕atomic·SwapUintptr(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·SwapInt64(SB)
+
+TEXT	sync∕atomic·SwapPointer(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·SwapInt64(SB)
+
+// Add
+TEXT	sync∕atomic·AddInt32(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic32_fetch_add(SB), AX
+	CALL	racecallatomic<>(SB)
+	MOVL	add+8(FP), AX	// convert fetch_add to add_fetch
+	ADDL	AX, ret+16(FP)
+	RET
+
+TEXT	sync∕atomic·AddInt64(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic64_fetch_add(SB), AX
+	CALL	racecallatomic<>(SB)
+	MOVQ	add+8(FP), AX	// convert fetch_add to add_fetch
+	ADDQ	AX, ret+16(FP)
+	RET
+
+TEXT	sync∕atomic·AddUint32(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·AddInt32(SB)
+
+TEXT	sync∕atomic·AddUint64(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·AddInt64(SB)
+
+TEXT	sync∕atomic·AddUintptr(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·AddInt64(SB)
+
+TEXT	sync∕atomic·AddPointer(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·AddInt64(SB)
+
+// CompareAndSwap
+TEXT	sync∕atomic·CompareAndSwapInt32(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic32_compare_exchange(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·CompareAndSwapInt64(SB), NOSPLIT, $0-0
+	MOVQ	$__tsan_go_atomic64_compare_exchange(SB), AX
+	CALL	racecallatomic<>(SB)
+	RET
+
+TEXT	sync∕atomic·CompareAndSwapUint32(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·CompareAndSwapInt32(SB)
+
+TEXT	sync∕atomic·CompareAndSwapUint64(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·CompareAndSwapInt64(SB)
+
+TEXT	sync∕atomic·CompareAndSwapUintptr(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·CompareAndSwapInt64(SB)
+
+TEXT	sync∕atomic·CompareAndSwapPointer(SB), NOSPLIT, $0-0
+	JMP	sync∕atomic·CompareAndSwapInt64(SB)
+
+// Generic atomic operation implementation.
+// AX already contains target function.
+TEXT	racecallatomic<>(SB), NOSPLIT, $0-0
+	// Trigger SIGSEGV early.
+	MOVQ	16(SP), R12
+	MOVL	(R12), R12
+	get_tls(R12)
+	MOVQ	g(R12), R14
+	MOVQ	g_racectx(R14), RARG0	// goroutine context
+	MOVQ	8(SP), RARG1	// caller pc
+	MOVQ	(SP), RARG2	// pc
+	LEAQ	16(SP), RARG3	// arguments
+	JMP	racecall<>(SB)
+
 // void runtime·racecall(void(*f)(...), ...)
 // Calls C function f from race runtime and passes up to 4 arguments to it.
 // The arguments are never heap-object-preserving pointers, so we pretend there are no arguments.
diff --git a/src/pkg/sync/atomic/doc.go b/src/pkg/sync/atomic/doc.go
index 17ba72fa17..10fb8c9177 100644
--- a/src/pkg/sync/atomic/doc.go
+++ b/src/pkg/sync/atomic/doc.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !race
-
 // Package atomic provides low-level atomic memory primitives
 // useful for implementing synchronization algorithms.
 //
diff --git a/src/pkg/sync/atomic/race.go b/src/pkg/sync/atomic/race.go
deleted file mode 100644
index 6cbbf12cb6..0000000000
--- a/src/pkg/sync/atomic/race.go
+++ /dev/null
@@ -1,276 +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.
-
-// +build race
-
-package atomic
-
-import (
-	"runtime"
-	"unsafe"
-)
-
-// We use runtime.RaceRead() inside of atomic operations to catch races
-// between atomic and non-atomic operations.  It will also catch races
-// between Mutex.Lock() and mutex overwrite (mu = Mutex{}).  Since we use
-// only RaceRead() we won't catch races with non-atomic loads.
-// Otherwise (if we use RaceWrite()) we will report races
-// between atomic operations (false positives).
-
-var mtx uint32 = 1 // same for all
-
-func SwapInt32(addr *int32, new int32) (old int32) {
-	return int32(SwapUint32((*uint32)(unsafe.Pointer(addr)), uint32(new)))
-}
-
-func SwapUint32(addr *uint32, new uint32) (old uint32) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	old = *addr
-	*addr = new
-	runtime.RaceReleaseMerge(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func SwapInt64(addr *int64, new int64) (old int64) {
-	return int64(SwapUint64((*uint64)(unsafe.Pointer(addr)), uint64(new)))
-}
-
-func SwapUint64(addr *uint64, new uint64) (old uint64) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	old = *addr
-	*addr = new
-	runtime.RaceReleaseMerge(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func SwapUintptr(addr *uintptr, new uintptr) (old uintptr) {
-	return uintptr(SwapPointer((*unsafe.Pointer)(unsafe.Pointer(addr)), unsafe.Pointer(new)))
-}
-
-func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	old = *addr
-	*addr = new
-	runtime.RaceReleaseMerge(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func CompareAndSwapInt32(val *int32, old, new int32) bool {
-	return CompareAndSwapUint32((*uint32)(unsafe.Pointer(val)), uint32(old), uint32(new))
-}
-
-func CompareAndSwapUint32(val *uint32, old, new uint32) (swapped bool) {
-	_ = *val
-	swapped = false
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	if *val == old {
-		*val = new
-		swapped = true
-		runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	}
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func CompareAndSwapInt64(val *int64, old, new int64) bool {
-	return CompareAndSwapUint64((*uint64)(unsafe.Pointer(val)), uint64(old), uint64(new))
-}
-
-func CompareAndSwapUint64(val *uint64, old, new uint64) (swapped bool) {
-	_ = *val
-	swapped = false
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	if *val == old {
-		*val = new
-		swapped = true
-		runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	}
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func CompareAndSwapPointer(val *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool) {
-	_ = *val
-	swapped = false
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	if *val == old {
-		*val = new
-		swapped = true
-		runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	}
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func CompareAndSwapUintptr(val *uintptr, old, new uintptr) (swapped bool) {
-	_ = *val
-	swapped = false
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	if *val == old {
-		*val = new
-		swapped = true
-		runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	}
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func AddInt32(val *int32, delta int32) int32 {
-	return int32(AddUint32((*uint32)(unsafe.Pointer(val)), uint32(delta)))
-}
-
-func AddUint32(val *uint32, delta uint32) (new uint32) {
-	_ = *val
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	*val = *val + delta
-	new = *val
-	runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	runtime.RaceSemrelease(&mtx)
-
-	return
-}
-
-func AddInt64(val *int64, delta int64) int64 {
-	return int64(AddUint64((*uint64)(unsafe.Pointer(val)), uint64(delta)))
-}
-
-func AddUint64(val *uint64, delta uint64) (new uint64) {
-	_ = *val
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	*val = *val + delta
-	new = *val
-	runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	runtime.RaceSemrelease(&mtx)
-
-	return
-}
-
-func AddUintptr(val *uintptr, delta uintptr) (new uintptr) {
-	_ = *val
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(val))
-	runtime.RaceAcquire(unsafe.Pointer(val))
-	*val = *val + delta
-	new = *val
-	runtime.RaceReleaseMerge(unsafe.Pointer(val))
-	runtime.RaceSemrelease(&mtx)
-
-	return
-}
-
-func LoadInt32(addr *int32) int32 {
-	return int32(LoadUint32((*uint32)(unsafe.Pointer(addr))))
-}
-
-func LoadUint32(addr *uint32) (val uint32) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	val = *addr
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func LoadInt64(addr *int64) int64 {
-	return int64(LoadUint64((*uint64)(unsafe.Pointer(addr))))
-}
-
-func LoadUint64(addr *uint64) (val uint64) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	val = *addr
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	val = *addr
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func LoadUintptr(addr *uintptr) (val uintptr) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	runtime.RaceAcquire(unsafe.Pointer(addr))
-	val = *addr
-	runtime.RaceSemrelease(&mtx)
-	return
-}
-
-func StoreInt32(addr *int32, val int32) {
-	StoreUint32((*uint32)(unsafe.Pointer(addr)), uint32(val))
-}
-
-func StoreUint32(addr *uint32, val uint32) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	*addr = val
-	runtime.RaceRelease(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-}
-
-func StoreInt64(addr *int64, val int64) {
-	StoreUint64((*uint64)(unsafe.Pointer(addr)), uint64(val))
-}
-
-func StoreUint64(addr *uint64, val uint64) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	*addr = val
-	runtime.RaceRelease(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-}
-
-func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	*addr = val
-	runtime.RaceRelease(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-}
-
-func StoreUintptr(addr *uintptr, val uintptr) {
-	_ = *addr
-	runtime.RaceSemacquire(&mtx)
-	runtime.RaceRead(unsafe.Pointer(addr))
-	*addr = val
-	runtime.RaceRelease(unsafe.Pointer(addr))
-	runtime.RaceSemrelease(&mtx)
-}
diff --git a/src/pkg/sync/atomic/race.s b/src/pkg/sync/atomic/race.s
new file mode 100644
index 0000000000..4dadc9ed7e
--- /dev/null
+++ b/src/pkg/sync/atomic/race.s
@@ -0,0 +1,8 @@
+// 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 race
+
+// This file is here only to allow external functions.
+// The operations are implemented in src/pkg/runtime/race_amd64.s

From 3de7ba1873b3efb0004d61147cc049dd42d8725d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 10:05:16 -0400
Subject: [PATCH 322/423] runtime: change PC, SP values in Stkframe, Panic,
 Defer from byte* to uintptr

uintptr is better when translating to Go,
and in a few places it's better in C too.

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews, iant, khr
https://golang.org/cl/138980043
---
 src/pkg/runtime/heapdump.c      | 10 +++++-----
 src/pkg/runtime/mgc0.c          | 20 ++++++++++----------
 src/pkg/runtime/panic.c         | 16 ++++++++--------
 src/pkg/runtime/runtime.h       | 16 ++++++++--------
 src/pkg/runtime/stack.c         | 10 +++++-----
 src/pkg/runtime/traceback_arm.c | 12 ++++++------
 src/pkg/runtime/traceback_x86.c | 16 ++++++++--------
 7 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 29a9ae6476..59639c1afe 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -309,7 +309,7 @@ dumpframe(Stkframe *s, void *arg)
 		dumpbvtypes(&child->args, (byte*)s->sp + child->argoff);
 	if(stackmap != nil && stackmap->n > 0) {
 		bv = runtime·stackmapdata(stackmap, pcdata);
-		dumpbvtypes(&bv, s->varp - bv.n / BitsPerPointer * PtrSize);
+		dumpbvtypes(&bv, (byte*)(s->varp - bv.n / BitsPerPointer * PtrSize));
 	} else {
 		bv.n = -1;
 	}
@@ -342,26 +342,26 @@ dumpframe(Stkframe *s, void *arg)
 	// Dump fields in the local vars section
 	if(stackmap == nil) {
 		// No locals information, dump everything.
-		for(off = child->arglen; off < s->varp - (byte*)s->sp; off += PtrSize) {
+		for(off = child->arglen; off < s->varp - s->sp; off += PtrSize) {
 			dumpint(FieldKindPtr);
 			dumpint(off);
 		}
 	} else if(stackmap->n < 0) {
 		// Locals size information, dump just the locals.
 		size = -stackmap->n;
-		for(off = s->varp - size - (byte*)s->sp; off < s->varp - (byte*)s->sp; off += PtrSize) {
+		for(off = s->varp - size - s->sp; off <  s->varp - s->sp; off += PtrSize) {
 			dumpint(FieldKindPtr);
 			dumpint(off);
 		}
 	} else if(stackmap->n > 0) {
 		// Locals bitmap information, scan just the pointers in
 		// locals.
-		dumpbv(&bv, s->varp - bv.n / BitsPerPointer * PtrSize - (byte*)s->sp);
+		dumpbv(&bv, s->varp - bv.n / BitsPerPointer * PtrSize - s->sp);
 	}
 	dumpint(FieldKindEol);
 
 	// Record arg info for parent.
-	child->argoff = s->argp - (byte*)s->fp;
+	child->argoff = s->argp - s->fp;
 	child->arglen = s->arglen;
 	child->sp = (byte*)s->sp;
 	child->depth++;
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 09be02b71e..af5abee192 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -674,16 +674,16 @@ scanframe(Stkframe *frame, void *unused)
 	stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 	if(stackmap == nil) {
 		// No locals information, scan everything.
-		size = frame->varp - (byte*)frame->sp;
+		size = frame->varp - frame->sp;
 		if(Debug > 2)
-			runtime·printf("frame %s unsized locals %p+%p\n", runtime·funcname(f), frame->varp-size, size);
-		scanblock(frame->varp - size, size, ScanConservatively);
+			runtime·printf("frame %s unsized locals %p+%p\n", runtime·funcname(f), (byte*)(frame->varp-size), size);
+		scanblock((byte*)(frame->varp - size), size, ScanConservatively);
 	} else if(stackmap->n < 0) {
 		// Locals size information, scan just the locals.
 		size = -stackmap->n;
 		if(Debug > 2)
-			runtime·printf("frame %s conservative locals %p+%p\n", runtime·funcname(f), frame->varp-size, size);
-		scanblock(frame->varp - size, size, ScanConservatively);
+			runtime·printf("frame %s conservative locals %p+%p\n", runtime·funcname(f), (byte*)(frame->varp-size), size);
+		scanblock((byte*)(frame->varp - size), size, ScanConservatively);
 	} else if(stackmap->n > 0) {
 		// Locals bitmap information, scan just the pointers in locals.
 		if(pcdata < 0 || pcdata >= stackmap->n) {
@@ -694,7 +694,7 @@ scanframe(Stkframe *frame, void *unused)
 		}
 		bv = runtime·stackmapdata(stackmap, pcdata);
 		size = (bv.n * PtrSize) / BitsPerPointer;
-		scanblock(frame->varp - size, bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
+		scanblock((byte*)(frame->varp - size), bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
 	}
 
 	// Scan arguments.
@@ -702,11 +702,11 @@ scanframe(Stkframe *frame, void *unused)
 	stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
 	if(stackmap != nil) {
 		bv = runtime·stackmapdata(stackmap, pcdata);
-		scanblock(frame->argp, bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
+		scanblock((byte*)frame->argp, bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
 	} else {
 		if(Debug > 2)
 			runtime·printf("frame %s conservative args %p+%p\n", runtime·funcname(f), frame->argp, (uintptr)frame->arglen);
-		scanblock(frame->argp, frame->arglen, ScanConservatively);
+		scanblock((byte*)frame->argp, frame->arglen, ScanConservatively);
 	}
 	return true;
 }
@@ -1798,7 +1798,7 @@ getgcmaskcb(Stkframe *frame, void *ctxt)
 	Stkframe *frame0;
 
 	frame0 = ctxt;
-	if(frame0->sp >= (uintptr)frame->varp - frame->sp && frame0->sp < (uintptr)frame->varp) {
+	if(frame0->sp >= frame->varp - frame->sp && frame0->sp < frame->varp) {
 		*frame0 = *frame;
 		return false;
 	}
@@ -1883,7 +1883,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 		*len = n/PtrSize;
 		*mask = runtime·mallocgc(*len, nil, 0);
 		for(i = 0; i < n; i += PtrSize) {
-			off = (p+i-frame.varp+size)/PtrSize;
+			off = (p+i-(byte*)frame.varp+size)/PtrSize;
 			bits = (bv.data[off*BitsPerPointer/32] >> ((off*BitsPerPointer)%32))&BitsMask;
 			(*mask)[i/PtrSize] = bits;
 		}
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index 39027a77c2..ecf4111337 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -85,12 +85,12 @@ runtime·deferproc(int32 siz, FuncVal *fn, ...)
 
 	d = newdefer(siz);
 	d->fn = fn;
-	d->pc = runtime·getcallerpc(&siz);
+	d->pc = (uintptr)runtime·getcallerpc(&siz);
 	if(thechar == '5')
-		d->argp = (byte*)(&fn+2);  // skip caller's saved link register
+		d->argp = (uintptr)(&fn+2);  // skip caller's saved link register
 	else
-		d->argp = (byte*)(&fn+1);
-	runtime·memmove(d->args, d->argp, d->siz);
+		d->argp = (uintptr)(&fn+1);
+	runtime·memmove(d->args, (byte*)d->argp, d->siz);
 
 	// deferproc returns 0 normally.
 	// a deferred func that stops a panic
@@ -119,13 +119,13 @@ void
 runtime·deferreturn(uintptr arg0)
 {
 	Defer *d;
-	byte *argp;
+	uintptr argp;
 	FuncVal *fn;
 
 	d = g->defer;
 	if(d == nil)
 		return;
-	argp = (byte*)&arg0;
+	argp = (uintptr)&arg0;
 	if(d->argp != argp)
 		return;
 
@@ -134,7 +134,7 @@ runtime·deferreturn(uintptr arg0)
 	// won't know the form of the arguments until the jmpdefer can
 	// flip the PC over to fn.
 	g->m->locks++;
-	runtime·memmove(argp, d->args, d->siz);
+	runtime·memmove((byte*)argp, d->args, d->siz);
 	fn = d->fn;
 	g->defer = d->link;
 	freedefer(d);
@@ -213,7 +213,7 @@ runtime·panic(Eface e)
 {
 	Defer *d, dabort;
 	Panic p;
-	void *pc, *argp;
+	uintptr pc, argp;
 
 	runtime·memclr((byte*)&p, sizeof p);
 	p.arg = e;
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 80366a549d..bb0a87c38a 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -624,17 +624,15 @@ struct Defer
 {
 	int32	siz;
 	bool	special;	// not part of defer frame
-	byte*	argp;		// where args were copied from
-	byte*	pc;
+	uintptr	argp;		// where args were copied from
+	uintptr	pc;
 	FuncVal*	fn;
 	Defer*	link;
 	void*	args[1];	// padded to actual size
 };
 
 // argp used in Defer structs when there is no argp.
-// TODO(rsc): Maybe we could use nil instead, but we've always used -1
-// and I don't want to change this days before the Go 1.3 release.
-#define NoArgs ((byte*)-1)
+#define NoArgs ((uintptr)-1)
 
 /*
  * panics
@@ -649,6 +647,8 @@ struct Panic
 	bool	aborted;	// the panic was aborted
 };
 
+typedef struct XXX XXX;
+
 /*
  * stack traces
  */
@@ -661,8 +661,8 @@ struct Stkframe
 	uintptr	lr;	// program counter at caller aka link register
 	uintptr	sp;	// stack pointer at pc
 	uintptr	fp;	// stack pointer at caller aka frame pointer
-	byte*	varp;	// top of local variables
-	byte*	argp;	// pointer to function arguments
+	uintptr	varp;	// top of local variables
+	uintptr	argp;	// pointer to function arguments
 	uintptr	arglen;	// number of bytes at argp
 };
 
@@ -775,7 +775,7 @@ int32	runtime·read(int32, void*, int32);
 int32	runtime·write(uintptr, void*, int32); // use uintptr to accommodate windows.
 int32	runtime·close(int32);
 int32	runtime·mincore(void*, uintptr, byte*);
-void	runtime·jmpdefer(FuncVal*, void*);
+void	runtime·jmpdefer(FuncVal*, uintptr);
 void	runtime·exit1(int32);
 void	runtime·ready(G*);
 byte*	runtime·getenv(int8*);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index e499b1f8b6..e589d8d443 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -419,7 +419,7 @@ checkframecopy(Stkframe *frame, void *arg)
 	if(StackDebug >= 2)
 		runtime·printf("    checking %s frame=[%p,%p] stk=[%p,%p]\n", runtime·funcname(f), frame->sp, frame->fp, cinfo->stk, cinfo->base);
 	// if we're not in the segment any more, return immediately.
-	if(frame->varp < cinfo->stk || frame->varp >= cinfo->base) {
+	if((byte*)frame->varp < cinfo->stk || (byte*)frame->varp >= cinfo->base) {
 		if(StackDebug >= 2)
 			runtime·printf("    <next segment>\n");
 		return false; // stop traceback
@@ -438,7 +438,7 @@ checkframecopy(Stkframe *frame, void *arg)
 		cinfo->frames++;
 		return true;
 	}
-	if(frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
+	if((byte*)frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil) {
 			cinfo->frames = -1;
@@ -501,7 +501,7 @@ copyabletopsegment(G *gp)
 			// For now, this only happens with the Defer in runtime.main.
 			continue;
 		}
-		if(d->argp < cinfo.stk || cinfo.base <= d->argp)
+		if((byte*)d->argp < cinfo.stk || cinfo.base <= (byte*)d->argp)
 			break; // a defer for the next segment
 		fn = d->fn;
 		if(fn == nil) // See issue 8047
@@ -666,7 +666,7 @@ adjustframe(Stkframe *frame, void *arg)
 		pcdata = 0; // in prologue
 
 	// adjust local pointers
-	if(frame->varp != (byte*)frame->sp) {
+	if((byte*)frame->varp != (byte*)frame->sp) {
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil)
 			runtime·throw("no locals info");
@@ -715,7 +715,7 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 			*dp = (Defer*)((byte*)d + adjinfo->delta);
 			continue;
 		}
-		if(d->argp < adjinfo->oldstk || adjinfo->oldbase <= d->argp)
+		if((byte*)d->argp < adjinfo->oldstk || adjinfo->oldbase <= (byte*)d->argp)
 			break; // a defer for the next segment
 		fn = d->fn;
 		if(fn == nil) {
diff --git a/src/pkg/runtime/traceback_arm.c b/src/pkg/runtime/traceback_arm.c
index 5e937cbfb6..18ca89150f 100644
--- a/src/pkg/runtime/traceback_arm.c
+++ b/src/pkg/runtime/traceback_arm.c
@@ -139,7 +139,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 			}
 		}
 
-		frame.varp = (byte*)frame.fp;
+		frame.varp = frame.fp;
 
 		// Derive size of arguments.
 		// Most functions have a fixed-size argument block,
@@ -148,7 +148,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 		// in package runtime and reflect, and for those we use call-specific
 		// metadata recorded by f's caller.
 		if(callback != nil || printing) {
-			frame.argp = (byte*)frame.fp + sizeof(uintptr);
+			frame.argp = frame.fp + sizeof(uintptr);
 			if(f->args != ArgsSizeUnknown)
 				frame.arglen = f->args;
 			else if(flr == nil)
@@ -193,18 +193,18 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 		// returns; everything live at earlier deferprocs is still live at that one.
 		frame.continpc = frame.pc;
 		if(waspanic) {
-			if(panic != nil && panic->defer->argp == (byte*)sparg)
+			if(panic != nil && panic->defer->argp == sparg)
 				frame.continpc = (uintptr)panic->defer->pc;
-			else if(defer != nil && defer->argp == (byte*)sparg)
+			else if(defer != nil && defer->argp == sparg)
 				frame.continpc = (uintptr)defer->pc;
 			else
 				frame.continpc = 0;
 		}
 
 		// Unwind our local panic & defer stacks past this frame.
-		while(panic != nil && (panic->defer == nil || panic->defer->argp == (byte*)sparg || panic->defer->argp == NoArgs))
+		while(panic != nil && (panic->defer == nil || panic->defer->argp == sparg || panic->defer->argp == NoArgs))
 			panic = panic->link;
-		while(defer != nil && (defer->argp == (byte*)sparg || defer->argp == NoArgs))
+		while(defer != nil && (defer->argp == sparg || defer->argp == NoArgs))
 			defer = defer->link;	
 
 		if(skip > 0) {
diff --git a/src/pkg/runtime/traceback_x86.c b/src/pkg/runtime/traceback_x86.c
index f3ba702b9b..ac451240e2 100644
--- a/src/pkg/runtime/traceback_x86.c
+++ b/src/pkg/runtime/traceback_x86.c
@@ -181,7 +181,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 			}
 		}
 		
-		frame.varp = (byte*)frame.fp - sizeof(uintreg);
+		frame.varp = frame.fp - sizeof(uintreg);
 
 		// Derive size of arguments.
 		// Most functions have a fixed-size argument block,
@@ -190,7 +190,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 		// in package runtime and reflect, and for those we use call-specific
 		// metadata recorded by f's caller.
 		if(callback != nil || printing) {
-			frame.argp = (byte*)frame.fp;
+			frame.argp = frame.fp;
 			if(f->args != ArgsSizeUnknown)
 				frame.arglen = f->args;
 			else if(flr == nil)
@@ -228,18 +228,18 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 		// returns; everything live at earlier deferprocs is still live at that one.
 		frame.continpc = frame.pc;
 		if(waspanic) {
-			if(panic != nil && panic->defer->argp == (byte*)sparg)
-				frame.continpc = (uintptr)panic->defer->pc;
-			else if(defer != nil && defer->argp == (byte*)sparg)
-				frame.continpc = (uintptr)defer->pc;
+			if(panic != nil && panic->defer->argp == sparg)
+				frame.continpc = panic->defer->pc;
+			else if(defer != nil && defer->argp == sparg)
+				frame.continpc = defer->pc;
 			else
 				frame.continpc = 0;
 		}
 
 		// Unwind our local panic & defer stacks past this frame.
-		while(panic != nil && (panic->defer == nil || panic->defer->argp == (byte*)sparg || panic->defer->argp == NoArgs))
+		while(panic != nil && (panic->defer == nil || panic->defer->argp == sparg || panic->defer->argp == NoArgs))
 			panic = panic->link;
-		while(defer != nil && (defer->argp == (byte*)sparg || defer->argp == NoArgs))
+		while(defer != nil && (defer->argp == sparg || defer->argp == NoArgs))
 			defer = defer->link;	
 
 		if(skip > 0) {

From f611ae1c75b7696da141e55bf91a0acdcc853bf8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 17:25:10 -0400
Subject: [PATCH 323/423] runtime: include os_*.h in the generated Go structs

Adding the #include to defs.c makes it get processed
by cmd/dist, which writes out Go equivalent for all the
C data structures defined in defs.c.

This in turn makes it necessary to define the Plink type,
used in os_plan9.h, in os_plan9.go. Rename it to _Plink
to avoid being exported.

LGTM=0intro, iant
R=golang-codereviews, iant, 0intro
CC=golang-codereviews, r
https://golang.org/cl/132490043
---
 src/pkg/runtime/defs.c      |  1 +
 src/pkg/runtime/os_plan9.go |  2 ++
 src/pkg/runtime/os_plan9.h  | 10 +++++-----
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/defs.c b/src/pkg/runtime/defs.c
index b6ed9c8115..956bf69867 100644
--- a/src/pkg/runtime/defs.c
+++ b/src/pkg/runtime/defs.c
@@ -13,3 +13,4 @@
 #include "chan.h"
 #include "mprof.h"
 #include "defs_GOOS_GOARCH.h"
+#include "os_GOOS.h"
diff --git a/src/pkg/runtime/os_plan9.go b/src/pkg/runtime/os_plan9.go
index 7b215c754c..4a7b16fd64 100644
--- a/src/pkg/runtime/os_plan9.go
+++ b/src/pkg/runtime/os_plan9.go
@@ -26,3 +26,5 @@ func errstr() string
 // The size of the note handler frame varies among architectures,
 // but 512 bytes should be enough for every implementation.
 const stackSystem = 512
+
+type _Plink uintptr
diff --git a/src/pkg/runtime/os_plan9.h b/src/pkg/runtime/os_plan9.h
index 8bc57262d9..ea853dde85 100644
--- a/src/pkg/runtime/os_plan9.h
+++ b/src/pkg/runtime/os_plan9.h
@@ -59,15 +59,15 @@ enum
 };
 
 typedef struct Tos Tos;
-typedef intptr Plink;
+typedef intptr _Plink;
 
 struct Tos {
 	struct			/* Per process profiling */
 	{
-		Plink	*pp;	/* known to be 0(ptr) */
-		Plink	*next;	/* known to be 4(ptr) */
-		Plink	*last;
-		Plink	*first;
+		_Plink	*pp;	/* known to be 0(ptr) */
+		_Plink	*next;	/* known to be 4(ptr) */
+		_Plink	*last;
+		_Plink	*first;
 		uint32	pid;
 		uint32	what;
 	} prof;

From fa5f86281ef10e5676e6672bed4a7b9e7111afa2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 17:25:26 -0400
Subject: [PATCH 324/423] runtime: change concatstring panic to gothrow

It was a throw originally; it was converted incorrectly.

LGTM=dave
R=khr, dave
CC=golang-codereviews
https://golang.org/cl/139000043
---
 src/pkg/runtime/string.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/string.go b/src/pkg/runtime/string.go
index 72b732f844..e9ea926dff 100644
--- a/src/pkg/runtime/string.go
+++ b/src/pkg/runtime/string.go
@@ -18,7 +18,7 @@ func concatstrings(a []string) string {
 			continue
 		}
 		if l+n < l {
-			panic("string concatenation too long")
+			gothrow("string concatenation too long")
 		}
 		l += n
 		count++

From 60be96217d4192312295c89731ab1239a73235e7 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 17:36:45 -0400
Subject: [PATCH 325/423] runtime: fix windows build

#ifdef'ed out code wasn't updated for argp change.

TBR=iant
CC=golang-codereviews
https://golang.org/cl/139040043
---
 src/pkg/runtime/traceback_x86.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/traceback_x86.c b/src/pkg/runtime/traceback_x86.c
index ac451240e2..169407ac81 100644
--- a/src/pkg/runtime/traceback_x86.c
+++ b/src/pkg/runtime/traceback_x86.c
@@ -132,7 +132,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
 			// Invoke callback so that stack copier sees an uncopyable frame.
 			if(callback != nil) {
 				frame.continpc = frame.pc;
-				frame.argp = nil;
+				frame.argp = 0;
 				frame.arglen = 0;
 				if(!callback(&frame, v))
 					return n;

From 548d0805f738c5f4d5bb7e72334b80c2acff059d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 18:51:12 -0400
Subject: [PATCH 326/423] runtime: convert mprof.goc to mprof.go

The exported Go definitions appearing in mprof.go are
copied verbatim from debug.go.

The unexported Go funcs and types are new.
The C Bucket type used a union and was not a line-for-line translation.

LGTM=remyoudompheng
R=golang-codereviews, remyoudompheng
CC=dvyukov, golang-codereviews, iant, khr, r
https://golang.org/cl/137040043
---
 src/cmd/api/goapi.go        |   2 +-
 src/cmd/dist/buildruntime.c |   3 +-
 src/pkg/runtime/chan.goc    |   1 +
 src/pkg/runtime/debug.go    |  83 -----
 src/pkg/runtime/defs.c      |   1 -
 src/pkg/runtime/extern.go   |   6 +
 src/pkg/runtime/heapdump.c  |   6 +-
 src/pkg/runtime/malloc.go   |   5 +-
 src/pkg/runtime/malloc.h    |   8 +-
 src/pkg/runtime/mgc0.c      |   2 +-
 src/pkg/runtime/mheap.c     |   2 +-
 src/pkg/runtime/mprof.go    | 670 +++++++++++++++++++++---------------
 src/pkg/runtime/mprof.goc   | 347 -------------------
 src/pkg/runtime/mprof.h     |  56 ---
 src/pkg/runtime/proc.c      |   4 +
 src/pkg/runtime/runtime.h   |   2 +-
 src/pkg/runtime/stubs.go    |   4 -
 17 files changed, 414 insertions(+), 788 deletions(-)
 delete mode 100644 src/pkg/runtime/mprof.goc
 delete mode 100644 src/pkg/runtime/mprof.h

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 65b9aaa094..99d41c9d69 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -382,7 +382,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" maptype struct{}; _type struct{}; alg struct{};" +
 			" mspan struct{}; m struct{}; mutex struct{}; slicetype struct{};" +
 			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
-			" mcache struct{}; bucket struct{}; sudog struct{}; g struct{};" +
+			" mcache struct{}; sudog struct{}; g struct{};" +
 			" hchan struct{}; chantype struct{}; waitq struct{};" +
 			" note struct{}; wincallbackcontext struct{};" +
 			" gobuf struct{}; funcval struct{}; _func struct{};" +
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index 2396e20c56..ade91024dc 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -346,10 +346,11 @@ mkzruntimedefs(char *dir, char *file)
 		"\n"
 	);
 
-	// Do not emit constant definitions for these.
+	// Do not emit definitions for these.
 	vadd(&seen, "true");
 	vadd(&seen, "false");
 	vadd(&seen, "raceenabled");
+	vadd(&seen, "allgs");
 	
 	// Run 6c -D GOOS_goos -D GOARCH_goarch -I workdir -q -n -o workdir/runtimedefs
 	// on each of the runtimedefs C files.
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
index 509f80d9a1..f14b58d52a 100644
--- a/src/pkg/runtime/chan.goc
+++ b/src/pkg/runtime/chan.goc
@@ -239,6 +239,7 @@ selectgo(Select **selp)
 	G *gp;
 	byte *as;
 	void *pc;
+	extern uint64 runtime·blockprofilerate;
 
 	sel = *selp;
 
diff --git a/src/pkg/runtime/debug.go b/src/pkg/runtime/debug.go
index 181fac4615..9ccbaedc84 100644
--- a/src/pkg/runtime/debug.go
+++ b/src/pkg/runtime/debug.go
@@ -50,73 +50,6 @@ func NumGoroutine() int {
 
 func gcount() int32
 
-// MemProfileRate controls the fraction of memory allocations
-// that are recorded and reported in the memory profile.
-// The profiler aims to sample an average of
-// one allocation per MemProfileRate bytes allocated.
-//
-// To include every allocated block in the profile, set MemProfileRate to 1.
-// To turn off profiling entirely, set MemProfileRate to 0.
-//
-// The tools that process the memory profiles assume that the
-// profile rate is constant across the lifetime of the program
-// and equal to the current value.  Programs that change the
-// memory profiling rate should do so just once, as early as
-// possible in the execution of the program (for example,
-// at the beginning of main).
-var MemProfileRate int = 512 * 1024
-
-// A MemProfileRecord describes the live objects allocated
-// by a particular call sequence (stack trace).
-type MemProfileRecord struct {
-	AllocBytes, FreeBytes     int64       // number of bytes allocated, freed
-	AllocObjects, FreeObjects int64       // number of objects allocated, freed
-	Stack0                    [32]uintptr // stack trace for this record; ends at first 0 entry
-}
-
-// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
-func (r *MemProfileRecord) InUseBytes() int64 { return r.AllocBytes - r.FreeBytes }
-
-// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
-func (r *MemProfileRecord) InUseObjects() int64 {
-	return r.AllocObjects - r.FreeObjects
-}
-
-// Stack returns the stack trace associated with the record,
-// a prefix of r.Stack0.
-func (r *MemProfileRecord) Stack() []uintptr {
-	for i, v := range r.Stack0 {
-		if v == 0 {
-			return r.Stack0[0:i]
-		}
-	}
-	return r.Stack0[0:]
-}
-
-// A StackRecord describes a single execution stack.
-type StackRecord struct {
-	Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
-}
-
-// Stack returns the stack trace associated with the record,
-// a prefix of r.Stack0.
-func (r *StackRecord) Stack() []uintptr {
-	for i, v := range r.Stack0 {
-		if v == 0 {
-			return r.Stack0[0:i]
-		}
-	}
-	return r.Stack0[0:]
-}
-
-// GoroutineProfile returns n, the number of records in the active goroutine stack profile.
-// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
-// If len(p) < n, GoroutineProfile does not change p and returns n, false.
-//
-// Most clients should use the runtime/pprof package instead
-// of calling GoroutineProfile directly.
-func GoroutineProfile(p []StackRecord) (n int, ok bool)
-
 // CPUProfile returns the next chunk of binary CPU profiling stack trace data,
 // blocking until data is available.  If profiling is turned off and all the profile
 // data accumulated while it was on has been returned, CPUProfile returns nil.
@@ -135,19 +68,3 @@ func CPUProfile() []byte
 // the testing package's -test.cpuprofile flag instead of calling
 // SetCPUProfileRate directly.
 func SetCPUProfileRate(hz int)
-
-// SetBlockProfileRate controls the fraction of goroutine blocking events
-// that are reported in the blocking profile.  The profiler aims to sample
-// an average of one blocking event per rate nanoseconds spent blocked.
-//
-// To include every blocking event in the profile, pass rate = 1.
-// To turn off profiling entirely, pass rate <= 0.
-func SetBlockProfileRate(rate int)
-
-// BlockProfileRecord describes blocking events originated
-// at a particular call sequence (stack trace).
-type BlockProfileRecord struct {
-	Count  int64
-	Cycles int64
-	StackRecord
-}
diff --git a/src/pkg/runtime/defs.c b/src/pkg/runtime/defs.c
index 956bf69867..b0a9b20d7f 100644
--- a/src/pkg/runtime/defs.c
+++ b/src/pkg/runtime/defs.c
@@ -11,6 +11,5 @@
 #include "type.h"
 #include "race.h"
 #include "chan.h"
-#include "mprof.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index 6b74c4fc25..f276a3839d 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -148,6 +148,12 @@ func Callers(skip int, pc []uintptr) int {
 //go:noescape
 func callers(int32, *uintptr, int32) int32
 
+//go:noescape
+func gcallers(*g, int32, *uintptr, int32) int32
+
+//go:noescape
+func gentraceback(uintptr, uintptr, uintptr, *g, int32, *uintptr, int32, unsafe.Pointer, unsafe.Pointer, bool) int32
+
 func getgoroot() string
 
 // GOROOT returns the root of the Go tree.
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 59639c1afe..3d0a23049d 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -686,8 +686,10 @@ dumpmemprof(void)
 	Special *sp;
 	SpecialProfile *spp;
 	byte *p;
-
-	runtime·iterate_memprof(dumpmemprof_callback);
+	void (*fn)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr);
+	
+	fn = dumpmemprof_callback;
+	runtime·iterate_memprof(&fn);
 
 	allspans = runtime·mheap.allspans;
 	for(spanidx=0; spanidx<runtime·mheap.nspan; spanidx++) {
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 49afc67364..5b1825a04c 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -397,9 +397,8 @@ func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 		}
 		c.next_sample = next
 	}
-	mp.scalararg[0] = uintptr(size)
-	mp.ptrarg[0] = x
-	onM(&mprofMalloc_m)
+
+	mProf_Malloc(x, size)
 }
 
 // force = 1 - do GC regardless of current heap usage
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index 6994557459..f328feb172 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -540,10 +540,10 @@ enum
 	FlagNoZero	= 1<<1, // don't zero memory
 };
 
-void	runtime·MProf_Malloc(void*, uintptr);
-void	runtime·MProf_Free(Bucket*, uintptr, bool);
-void	runtime·MProf_GC(void);
-void	runtime·iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr));
+void	runtime·mProf_Malloc(void*, uintptr);
+void	runtime·mProf_Free(Bucket*, uintptr, bool);
+void	runtime·mProf_GC(void);
+void	runtime·iterate_memprof(void (**callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr));
 int32	runtime·gcprocs(void);
 void	runtime·helpgc(int32 nproc);
 void	runtime·gchelper(void);
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index af5abee192..0aacbcebaf 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1438,7 +1438,7 @@ gc(struct gc_args *args)
 			sweep.npausesweep++;
 	}
 
-	runtime·MProf_GC();
+	runtime·mProf_GC();
 	g->m->traceback = 0;
 }
 
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 9b165d6cad..93f33f21cf 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -861,7 +861,7 @@ runtime·freespecial(Special *s, void *p, uintptr size, bool freed)
 		return false; // don't free p until finalizer is done
 	case KindSpecialProfile:
 		sp = (SpecialProfile*)s;
-		runtime·MProf_Free(sp->b, size, freed);
+		runtime·mProf_Free(sp->b, size, freed);
 		runtime·lock(&runtime·mheap.speciallock);
 		runtime·FixAlloc_Free(&runtime·mheap.specialprofilealloc, sp);
 		runtime·unlock(&runtime·mheap.speciallock);
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 1acfdb9b89..8546a341bd 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -2,142 +2,185 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Malloc profiling.
+// Patterned after tcmalloc's algorithms; shorter code.
+
 package runtime
 
 import (
 	"unsafe"
 )
 
-// Malloc profiling.
-// Patterned after tcmalloc's algorithms; shorter code.
-
 // NOTE(rsc): Everything here could use cas if contention became an issue.
 var proflock mutex
 
 // All memory allocations are local and do not escape outside of the profiler.
 // The profiler is forbidden from referring to garbage-collected memory.
 
-/*
-enum { MProf, BProf }  // profile types
-*/
+const (
+	// profile types
+	memProfile bucketType = 1 + iota
+	blockProfile
 
-/*
-// Per-call-stack profiling information.
-// Lookup by hashing call stack into a linked-list hash table.
-struct Bucket
-{
-	Bucket	*next	// next in hash list
-	Bucket	*allnext	// next in list of all mbuckets/bbuckets
-	int32	typ
-	// Generally unions can break precise GC,
-	// this one is fine because it does not contain pointers.
-	union
-	{
-		struct MProfRecord // typ == MProf
-		{
-			// The following complex 3-stage scheme of stats accumulation
-			// is required to obtain a consistent picture of mallocs and frees
-			// for some point in time.
-			// The problem is that mallocs come in real time, while frees
-			// come only after a GC during concurrent sweeping. So if we would
-			// naively count them, we would get a skew toward mallocs.
-			//
-			// Mallocs are accounted in recent stats.
-			// Explicit frees are accounted in recent stats.
-			// GC frees are accounted in prev stats.
-			// After GC prev stats are added to final stats and
-			// recent stats are moved into prev stats.
-			uintptr	allocs
-			uintptr	frees
-			uintptr	alloc_bytes
-			uintptr	free_bytes
+	// size of bucket hash table
+	buckHashSize = 179999
 
-			uintptr	prev_allocs  // since last but one till last gc
-			uintptr	prev_frees
-			uintptr	prev_alloc_bytes
-			uintptr	prev_free_bytes
-
-			uintptr	recent_allocs  // since last gc till now
-			uintptr	recent_frees
-			uintptr	recent_alloc_bytes
-			uintptr	recent_free_bytes
-
-		} mp
-		struct BProfRecord // typ == BProf
-		{
-			int64	count
-			int64	cycles
-		} bp
-	} data
-	uintptr	hash	// hash of size + stk
-	uintptr	size
-	uintptr	nstk
-	uintptr	stk[1]
-}
-*/
-
-var (
-	mbuckets *bucket // memory profile buckets
-	bbuckets *bucket // blocking profile buckets
+	// max depth of stack to record in bucket
+	maxStack = 32
 )
 
-/*
-enum {
-	BuckHashSize = 179999,
+type bucketType int
+
+// A bucket holds per-call-stack profiling information.
+// The representation is a bit sleazy, inherited from C.
+// This struct defines the bucket header. It is followed in
+// memory by the stack words and then the actual record
+// data, either a memRecord or a blockRecord.
+//
+// Per-call-stack profiling information.
+// Lookup by hashing call stack into a linked-list hash table.
+type bucket struct {
+	next    *bucket
+	allnext *bucket
+	typ     bucketType // memBucket or blockBucket
+	hash    uintptr
+	size    uintptr
+	nstk    uintptr
+}
+
+// A memRecord is the bucket data for a bucket of type memProfile,
+// part of the memory profile.
+type memRecord struct {
+	// The following complex 3-stage scheme of stats accumulation
+	// is required to obtain a consistent picture of mallocs and frees
+	// for some point in time.
+	// The problem is that mallocs come in real time, while frees
+	// come only after a GC during concurrent sweeping. So if we would
+	// naively count them, we would get a skew toward mallocs.
+	//
+	// Mallocs are accounted in recent stats.
+	// Explicit frees are accounted in recent stats.
+	// GC frees are accounted in prev stats.
+	// After GC prev stats are added to final stats and
+	// recent stats are moved into prev stats.
+	allocs      uintptr
+	frees       uintptr
+	alloc_bytes uintptr
+	free_bytes  uintptr
+
+	// changes between next-to-last GC and last GC
+	prev_allocs      uintptr
+	prev_frees       uintptr
+	prev_alloc_bytes uintptr
+	prev_free_bytes  uintptr
+
+	// changes since last GC
+	recent_allocs      uintptr
+	recent_frees       uintptr
+	recent_alloc_bytes uintptr
+	recent_free_bytes  uintptr
+}
+
+// A blockRecord is the bucket data for a bucket of type blockProfile,
+// part of the blocking profile.
+type blockRecord struct {
+	count  int64
+	cycles int64
+}
+
+var (
+	mbuckets  *bucket // memory profile buckets
+	bbuckets  *bucket // blocking profile buckets
+	buckhash  *[179999]*bucket
+	bucketmem uintptr
+)
+
+// newBucket allocates a bucket with the given type and number of stack entries.
+func newBucket(typ bucketType, nstk int) *bucket {
+	size := unsafe.Sizeof(bucket{}) + uintptr(nstk)*unsafe.Sizeof(uintptr(0))
+	switch typ {
+	default:
+		gothrow("invalid profile bucket type")
+	case memProfile:
+		size += unsafe.Sizeof(memRecord{})
+	case blockProfile:
+		size += unsafe.Sizeof(blockRecord{})
+	}
+
+	b := (*bucket)(persistentalloc(size, 0, &memstats.buckhash_sys))
+	bucketmem += size
+	b.typ = typ
+	b.nstk = uintptr(nstk)
+	return b
+}
+
+// stk returns the slice in b holding the stack.
+func (b *bucket) stk() []uintptr {
+	stk := (*[maxStack]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
+	return stk[:b.nstk:b.nstk]
+}
+
+// mp returns the memRecord associated with the memProfile bucket b.
+func (b *bucket) mp() *memRecord {
+	if b.typ != memProfile {
+		gothrow("bad use of bucket.mp")
+	}
+	data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
+	return (*memRecord)(data)
+}
+
+// bp returns the blockRecord associated with the blockProfile bucket b.
+func (b *bucket) bp() *blockRecord {
+	if b.typ != blockProfile {
+		gothrow("bad use of bucket.bp")
+	}
+	data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
+	return (*blockRecord)(data)
 }
-static Bucket **buckhash
-static uintptr bucketmem
-*/
 
-/*
 // Return the bucket for stk[0:nstk], allocating new bucket if needed.
-static Bucket*
-stkbucket(int32 typ, uintptr size, uintptr *stk, int32 nstk, bool alloc)
-{
-	int32 i
-	uintptr h
-	Bucket *b
-
-	if(buckhash == nil) {
-		buckhash = sysAlloc(BuckHashSize*sizeof buckhash[0], &mstats.buckhash_sys)
-		if(buckhash == nil)
-			throw("runtime: cannot allocate memory")
+func stkbucket(typ bucketType, size uintptr, stk []uintptr, alloc bool) *bucket {
+	if buckhash == nil {
+		buckhash = (*[buckHashSize]*bucket)(sysAlloc(unsafe.Sizeof(*buckhash), &memstats.buckhash_sys))
+		if buckhash == nil {
+			gothrow("runtime: cannot allocate memory")
+		}
 	}
 
 	// Hash stack.
-	h = 0
-	for(i=0 i<nstk i++) {
-		h += stk[i]
-		h += h<<10
-		h ^= h>>6
+	var h uintptr
+	for _, pc := range stk {
+		h += pc
+		h += h << 10
+		h ^= h >> 6
 	}
 	// hash in size
 	h += size
-	h += h<<10
-	h ^= h>>6
+	h += h << 10
+	h ^= h >> 6
 	// finalize
-	h += h<<3
-	h ^= h>>11
+	h += h << 3
+	h ^= h >> 11
 
-	i = h%BuckHashSize
-	for(b = buckhash[i] b b=b.next)
-		if(b.typ == typ && b.hash == h && b.size == size && b.nstk == nstk &&
-		   mcmp((byte*)b.stk, (byte*)stk, nstk*sizeof stk[0]) == 0)
+	i := int(h % buckHashSize)
+	for b := buckhash[i]; b != nil; b = b.next {
+		if b.typ == typ && b.hash == h && b.size == size && eqslice(b.stk(), stk) {
 			return b
+		}
+	}
 
-	if(!alloc)
+	if !alloc {
 		return nil
+	}
 
-	b = persistentalloc(sizeof *b + nstk*sizeof stk[0], 0, &mstats.buckhash_sys)
-	bucketmem += sizeof *b + nstk*sizeof stk[0]
-	memmove(b.stk, stk, nstk*sizeof stk[0])
-	b.typ = typ
+	// Create new bucket.
+	b := newBucket(typ, len(stk))
+	copy(b.stk(), stk)
 	b.hash = h
 	b.size = size
-	b.nstk = nstk
 	b.next = buckhash[i]
 	buckhash[i] = b
-	if(typ == MProf) {
+	if typ == memProfile {
 		b.allnext = mbuckets
 		mbuckets = b
 	} else {
@@ -146,129 +189,193 @@ stkbucket(int32 typ, uintptr size, uintptr *stk, int32 nstk, bool alloc)
 	}
 	return b
 }
-*/
+
+func sysAlloc(n uintptr, stat *uint64) unsafe.Pointer
+
+func eqslice(x, y []uintptr) bool {
+	if len(x) != len(y) {
+		return false
+	}
+	for i, xi := range x {
+		if xi != y[i] {
+			return false
+		}
+	}
+	return true
+}
 
 func mprof_GC() {
 	for b := mbuckets; b != nil; b = b.allnext {
-		b.data.mp.allocs += b.data.mp.prev_allocs
-		b.data.mp.frees += b.data.mp.prev_frees
-		b.data.mp.alloc_bytes += b.data.mp.prev_alloc_bytes
-		b.data.mp.free_bytes += b.data.mp.prev_free_bytes
+		mp := b.mp()
+		mp.allocs += mp.prev_allocs
+		mp.frees += mp.prev_frees
+		mp.alloc_bytes += mp.prev_alloc_bytes
+		mp.free_bytes += mp.prev_free_bytes
 
-		b.data.mp.prev_allocs = b.data.mp.recent_allocs
-		b.data.mp.prev_frees = b.data.mp.recent_frees
-		b.data.mp.prev_alloc_bytes = b.data.mp.recent_alloc_bytes
-		b.data.mp.prev_free_bytes = b.data.mp.recent_free_bytes
+		mp.prev_allocs = mp.recent_allocs
+		mp.prev_frees = mp.recent_frees
+		mp.prev_alloc_bytes = mp.recent_alloc_bytes
+		mp.prev_free_bytes = mp.recent_free_bytes
 
-		b.data.mp.recent_allocs = 0
-		b.data.mp.recent_frees = 0
-		b.data.mp.recent_alloc_bytes = 0
-		b.data.mp.recent_free_bytes = 0
+		mp.recent_allocs = 0
+		mp.recent_frees = 0
+		mp.recent_alloc_bytes = 0
+		mp.recent_free_bytes = 0
 	}
 }
 
-/*
 // Record that a gc just happened: all the 'recent' statistics are now real.
-void
-MProf_GC(void)
-{
+func mProf_GC() {
 	lock(&proflock)
-	MProf_GC()
+	mprof_GC()
 	unlock(&proflock)
 }
-*/
 
-/*
 // Called by malloc to record a profiled block.
-void
-MProf_Malloc(void *p, uintptr size)
-{
-	uintptr stk[32]
-	Bucket *b
-	int32 nstk
-
-	nstk = callers(1, stk, nelem(stk))
+func mProf_Malloc(p unsafe.Pointer, size uintptr) {
+	var stk [maxStack]uintptr
+	nstk := callers(1, &stk[0], int32(len(stk)))
 	lock(&proflock)
-	b = stkbucket(MProf, size, stk, nstk, true)
-	b.data.mp.recent_allocs++
-	b.data.mp.recent_alloc_bytes += size
+	b := stkbucket(memProfile, size, stk[:nstk], true)
+	mp := b.mp()
+	mp.recent_allocs++
+	mp.recent_alloc_bytes += size
 	unlock(&proflock)
 
 	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
 	// This reduces potential contention and chances of deadlocks.
-	// Since the object must be alive during call to MProf_Malloc,
+	// Since the object must be alive during call to mProf_Malloc,
 	// it's fine to do this non-atomically.
 	setprofilebucket(p, b)
 }
-*/
 
-/*
-void
-MProf_Free(Bucket *b, uintptr size, bool freed)
-{
+func setprofilebucket(p unsafe.Pointer, b *bucket) // mheap.c
+
+// Called when freeing a profiled block.
+func mProf_Free(b *bucket, size uintptr, freed bool) {
 	lock(&proflock)
-	if(freed) {
-		b.data.mp.recent_frees++
-		b.data.mp.recent_free_bytes += size
+	mp := b.mp()
+	if freed {
+		mp.recent_frees++
+		mp.recent_free_bytes += size
 	} else {
-		b.data.mp.prev_frees++
-		b.data.mp.prev_free_bytes += size
+		mp.prev_frees++
+		mp.prev_free_bytes += size
 	}
 	unlock(&proflock)
 }
-*/
 
-/*
-int64 blockprofilerate  // in CPU ticks
-*/
+var blockprofilerate uint64 // in CPU ticks
 
-/*
-void
-SetBlockProfileRate(intgo rate)
-{
-	int64 r
-
-	if(rate <= 0)
-		r = 0  // disable profiling
-	else {
+// SetBlockProfileRate controls the fraction of goroutine blocking events
+// that are reported in the blocking profile.  The profiler aims to sample
+// an average of one blocking event per rate nanoseconds spent blocked.
+//
+// To include every blocking event in the profile, pass rate = 1.
+// To turn off profiling entirely, pass rate <= 0.
+func SetBlockProfileRate(rate int) {
+	var r int64
+	if rate <= 0 {
+		r = 0 // disable profiling
+	} else {
 		// convert ns to cycles, use float64 to prevent overflow during multiplication
-		r = (float64)rate*tickspersecond()/(1000*1000*1000)
-		if(r == 0)
+		r = int64(float64(rate) * float64(tickspersecond()) / (1000 * 1000 * 1000))
+		if r == 0 {
 			r = 1
+		}
 	}
-	atomicstore64((uint64*)&blockprofilerate, r)
+
+	atomicstore64(&blockprofilerate, uint64(r))
 }
-*/
 
-/*
-void
-blockevent(int64 cycles, int32 skip)
-{
-	int32 nstk
-	int64 rate
-	uintptr stk[32]
-	Bucket *b
+func tickspersecond() int64 // runtime.c
+func fastrand1() uint32     // runtime.c
+func readgstatus(*g) uint32 // proc.c
 
-	if(cycles <= 0)
+func blockevent(cycles int64, skip int) {
+	if cycles <= 0 {
 		return
-	rate = atomicload64((uint64*)&blockprofilerate)
-	if(rate <= 0 || (rate > cycles && fastrand1()%rate > cycles))
+	}
+	rate := int64(atomicload64(&blockprofilerate))
+	if rate <= 0 || (rate > cycles && int64(fastrand1())%rate > cycles) {
 		return
-
-	if(g.m.curg == nil || g.m.curg == g)
-		nstk = callers(skip, stk, nelem(stk))
-	else
-		nstk = gcallers(g.m.curg, skip, stk, nelem(stk))
+	}
+	gp := getg()
+	var nstk int
+	var stk [maxStack]uintptr
+	if gp.m.curg == nil || gp.m.curg == gp {
+		nstk = int(callers(int32(skip), &stk[0], int32(len(stk))))
+	} else {
+		nstk = int(gcallers(gp.m.curg, int32(skip), &stk[0], int32(len(stk))))
+	}
 	lock(&proflock)
-	b = stkbucket(BProf, 0, stk, nstk, true)
-	b.data.bp.count++
-	b.data.bp.cycles += cycles
+	b := stkbucket(blockProfile, 0, stk[:nstk], true)
+	b.bp().count++
+	b.bp().cycles += cycles
 	unlock(&proflock)
 }
-*/
 
 // Go interface to profile data.
 
+// A StackRecord describes a single execution stack.
+type StackRecord struct {
+	Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
+}
+
+// Stack returns the stack trace associated with the record,
+// a prefix of r.Stack0.
+func (r *StackRecord) Stack() []uintptr {
+	for i, v := range r.Stack0 {
+		if v == 0 {
+			return r.Stack0[0:i]
+		}
+	}
+	return r.Stack0[0:]
+}
+
+// MemProfileRate controls the fraction of memory allocations
+// that are recorded and reported in the memory profile.
+// The profiler aims to sample an average of
+// one allocation per MemProfileRate bytes allocated.
+//
+// To include every allocated block in the profile, set MemProfileRate to 1.
+// To turn off profiling entirely, set MemProfileRate to 0.
+//
+// The tools that process the memory profiles assume that the
+// profile rate is constant across the lifetime of the program
+// and equal to the current value.  Programs that change the
+// memory profiling rate should do so just once, as early as
+// possible in the execution of the program (for example,
+// at the beginning of main).
+var MemProfileRate int = 512 * 1024
+
+// A MemProfileRecord describes the live objects allocated
+// by a particular call sequence (stack trace).
+type MemProfileRecord struct {
+	AllocBytes, FreeBytes     int64       // number of bytes allocated, freed
+	AllocObjects, FreeObjects int64       // number of objects allocated, freed
+	Stack0                    [32]uintptr // stack trace for this record; ends at first 0 entry
+}
+
+// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
+func (r *MemProfileRecord) InUseBytes() int64 { return r.AllocBytes - r.FreeBytes }
+
+// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
+func (r *MemProfileRecord) InUseObjects() int64 {
+	return r.AllocObjects - r.FreeObjects
+}
+
+// Stack returns the stack trace associated with the record,
+// a prefix of r.Stack0.
+func (r *MemProfileRecord) Stack() []uintptr {
+	for i, v := range r.Stack0 {
+		if v == 0 {
+			return r.Stack0[0:i]
+		}
+	}
+	return r.Stack0[0:]
+}
+
 // MemProfile returns n, the number of records in the current memory profile.
 // If len(p) >= n, MemProfile copies the profile into p and returns n, true.
 // If len(p) < n, MemProfile does not change p and returns n, false.
@@ -285,10 +392,11 @@ func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
 	lock(&proflock)
 	clear := true
 	for b := mbuckets; b != nil; b = b.allnext {
-		if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
+		mp := b.mp()
+		if inuseZero || mp.alloc_bytes != mp.free_bytes {
 			n++
 		}
-		if b.data.mp.allocs != 0 || b.data.mp.frees != 0 {
+		if mp.allocs != 0 || mp.frees != 0 {
 			clear = false
 		}
 	}
@@ -301,7 +409,8 @@ func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
 		mprof_GC()
 		n = 0
 		for b := mbuckets; b != nil; b = b.allnext {
-			if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
+			mp := b.mp()
+			if inuseZero || mp.alloc_bytes != mp.free_bytes {
 				n++
 			}
 		}
@@ -310,7 +419,8 @@ func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
 		ok = true
 		idx := 0
 		for b := mbuckets; b != nil; b = b.allnext {
-			if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
+			mp := b.mp()
+			if inuseZero || mp.alloc_bytes != mp.free_bytes {
 				record(&p[idx], b)
 				idx++
 			}
@@ -322,31 +432,33 @@ func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
 
 // Write b's data to r.
 func record(r *MemProfileRecord, b *bucket) {
-	r.AllocBytes = int64(b.data.mp.alloc_bytes)
-	r.FreeBytes = int64(b.data.mp.free_bytes)
-	r.AllocObjects = int64(b.data.mp.allocs)
-	r.FreeObjects = int64(b.data.mp.frees)
-	for i := 0; uintptr(i) < b.nstk && i < len(r.Stack0); i++ {
-		r.Stack0[i] = *(*uintptr)(add(unsafe.Pointer(&b.stk), uintptr(i)*ptrSize))
-	}
-	for i := b.nstk; i < uintptr(len(r.Stack0)); i++ {
+	mp := b.mp()
+	r.AllocBytes = int64(mp.alloc_bytes)
+	r.FreeBytes = int64(mp.free_bytes)
+	r.AllocObjects = int64(mp.allocs)
+	r.FreeObjects = int64(mp.frees)
+	copy(r.Stack0[:], b.stk())
+	for i := int(b.nstk); i < len(r.Stack0); i++ {
 		r.Stack0[i] = 0
 	}
 }
 
-/*
-void
-iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr))
-{
-	Bucket *b
-
+func iterate_memprof(fn func(*bucket, uintptr, *uintptr, uintptr, uintptr, uintptr)) {
 	lock(&proflock)
-	for(b=mbuckets b b=b.allnext) {
-		callback(b, b.nstk, b.stk, b.size, b.data.mp.allocs, b.data.mp.frees)
+	for b := mbuckets; b != nil; b = b.allnext {
+		mp := b.mp()
+		fn(b, uintptr(b.nstk), &b.stk()[0], b.size, mp.allocs, mp.frees)
 	}
 	unlock(&proflock)
 }
-*/
+
+// BlockProfileRecord describes blocking events originated
+// at a particular call sequence (stack trace).
+type BlockProfileRecord struct {
+	Count  int64
+	Cycles int64
+	StackRecord
+}
 
 // BlockProfile returns n, the number of records in the current blocking profile.
 // If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
@@ -362,21 +474,16 @@ func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
 	}
 	if n <= len(p) {
 		ok = true
-		idx := 0
 		for b := bbuckets; b != nil; b = b.allnext {
-			bp := (*bprofrecord)(unsafe.Pointer(&b.data))
-			p[idx].Count = int64(bp.count)
-			p[idx].Cycles = int64(bp.cycles)
-			i := 0
-			for uintptr(i) < b.nstk && i < len(p[idx].Stack0) {
-				p[idx].Stack0[i] = *(*uintptr)(add(unsafe.Pointer(&b.stk), uintptr(i)*ptrSize))
-				i++
+			bp := b.bp()
+			r := &p[0]
+			r.Count = int64(bp.count)
+			r.Cycles = int64(bp.cycles)
+			i := copy(r.Stack0[:], b.stk())
+			for ; i < len(r.Stack0); i++ {
+				r.Stack0[i] = 0
 			}
-			for i < len(p[idx].Stack0) {
-				p[idx].Stack0[i] = 0
-				i++
-			}
-			idx++
+			p = p[1:]
 		}
 	}
 	unlock(&proflock)
@@ -407,53 +514,54 @@ func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
 	return
 }
 
-/*
-func GoroutineProfile(b Slice) (n int, ok bool) {
-	uintptr pc, sp, i
-	TRecord *r
-	G *gp
+var allgs []*g // proc.c
 
-	sp = getcallersp(&b)
-	pc = (uintptr)getcallerpc(&b)
+// GoroutineProfile returns n, the number of records in the active goroutine stack profile.
+// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
+// If len(p) < n, GoroutineProfile does not change p and returns n, false.
+//
+// Most clients should use the runtime/pprof package instead
+// of calling GoroutineProfile directly.
+func GoroutineProfile(p []StackRecord) (n int, ok bool) {
+	sp := getcallersp(unsafe.Pointer(&p))
+	pc := getcallerpc(unsafe.Pointer(&p))
 
-	ok = false
-	n = gcount()
-	if(n <= b.len) {
+	n = NumGoroutine()
+	if n <= len(p) {
+		gp := getg()
 		semacquire(&worldsema, false)
-		g.m.gcing = 1
+		gp.m.gcing = 1
 		stoptheworld()
 
-		n = gcount()
-		if(n <= b.len) {
+		n = NumGoroutine()
+		if n <= len(p) {
 			ok = true
-			r = (TRecord*)b.array
-			saveg(pc, sp, g, r++)
-			for(i = 0 i < allglen i++) {
-				gp = allg[i]
-				if(gp == g || readgstatus(gp) == Gdead)
+			r := p
+			saveg(pc, sp, gp, &r[0])
+			r = r[1:]
+			for _, gp1 := range allgs {
+				if gp1 == gp || readgstatus(gp1) == _Gdead {
 					continue
-				saveg(~(uintptr)0, ~(uintptr)0, gp, r++)
+				}
+				saveg(^uintptr(0), ^uintptr(0), gp1, &r[0])
+				r = r[1:]
 			}
 		}
 
-		g.m.gcing = 0
+		gp.m.gcing = 0
 		semrelease(&worldsema)
 		starttheworld()
 	}
-}
-*/
 
-/*
-static void
-saveg(uintptr pc, uintptr sp, G *gp, TRecord *r)
-{
-	int32 n
-
-	n = gentraceback(pc, sp, 0, gp, 0, r.stk, nelem(r.stk), nil, nil, false)
-	if(n < nelem(r.stk))
-		r.stk[n] = 0
+	return n, ok
+}
+
+func saveg(pc, sp uintptr, gp *g, r *StackRecord) {
+	n := gentraceback(pc, sp, 0, gp, 0, &r.Stack0[0], int32(len(r.Stack0)), nil, nil, false)
+	if int(n) < len(r.Stack0) {
+		r.Stack0[n] = 0
+	}
 }
-*/
 
 // Stack formats a stack trace of the calling goroutine into buf
 // and returns the number of bytes written to buf.
@@ -495,56 +603,52 @@ func Stack(buf []byte, all bool) int {
 	return n
 }
 
-/*
 // Tracing of alloc/free/gc.
 
-static Mutex tracelock
+var tracelock mutex
 
-void
-tracealloc(void *p, uintptr size, Type *type)
-{
+func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
 	lock(&tracelock)
-	g.m.traceback = 2
-	if(type == nil)
-		printf("tracealloc(%p, %p)\n", p, size)
-	else
-		printf("tracealloc(%p, %p, %S)\n", p, size, *type.string)
-	if(g.m.curg == nil || g == g.m.curg) {
-		goroutineheader(g)
-		traceback((uintptr)getcallerpc(&p), (uintptr)getcallersp(&p), 0, g)
+	gp := getg()
+	gp.m.traceback = 2
+	if typ == nil {
+		print("tracealloc(", p, ", ", hex(size), ")\n")
 	} else {
-		goroutineheader(g.m.curg)
-		traceback(~(uintptr)0, ~(uintptr)0, 0, g.m.curg)
+		print("tracealloc(", p, ", ", hex(size), ", ", *typ._string, ")\n")
 	}
-	printf("\n")
-	g.m.traceback = 0
+	if gp.m.curg == nil || gp == gp.m.curg {
+		goroutineheader(gp)
+		traceback(getcallerpc(unsafe.Pointer(&p)), getcallersp(unsafe.Pointer(&p)), 0, gp)
+	} else {
+		goroutineheader(gp.m.curg)
+		traceback(^uintptr(0), ^uintptr(0), 0, gp.m.curg)
+	}
+	print("\n")
+	gp.m.traceback = 0
 	unlock(&tracelock)
 }
 
-void
-tracefree(void *p, uintptr size)
-{
+func tracefree(p unsafe.Pointer, size uintptr) {
 	lock(&tracelock)
-	g.m.traceback = 2
-	printf("tracefree(%p, %p)\n", p, size)
-	goroutineheader(g)
-	traceback((uintptr)getcallerpc(&p), (uintptr)getcallersp(&p), 0, g)
-	printf("\n")
-	g.m.traceback = 0
+	gp := getg()
+	gp.m.traceback = 2
+	print("tracefree(", p, ", ", hex(size), ")\n")
+	goroutineheader(gp)
+	traceback(getcallerpc(unsafe.Pointer(&p)), getcallersp(unsafe.Pointer(&p)), 0, gp)
+	print("\n")
+	gp.m.traceback = 0
 	unlock(&tracelock)
 }
 
-void
-tracegc(void)
-{
+func tracegc() {
 	lock(&tracelock)
-	g.m.traceback = 2
-	printf("tracegc()\n")
-	// running on m.g0 stack show all non-g0 goroutines
-	tracebackothers(g)
-	printf("end tracegc\n")
-	printf("\n")
-	g.m.traceback = 0
+	gp := getg()
+	gp.m.traceback = 2
+	print("tracegc()\n")
+	// running on m->g0 stack; show all non-g0 goroutines
+	tracebackothers(gp)
+	print("end tracegc\n")
+	print("\n")
+	gp.m.traceback = 0
 	unlock(&tracelock)
 }
-*/
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
deleted file mode 100644
index 589863a156..0000000000
--- a/src/pkg/runtime/mprof.goc
+++ /dev/null
@@ -1,347 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Malloc profiling.
-// Patterned after tcmalloc's algorithms; shorter code.
-
-package runtime
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "mprof.h"
-#include "defs_GOOS_GOARCH.h"
-#include "type.h"
-
-// NOTE(rsc): Everything here could use cas if contention became an issue.
-extern Mutex runtime·proflock;
-
-// All memory allocations are local and do not escape outside of the profiler.
-// The profiler is forbidden from referring to garbage-collected memory.
-
-enum { MProf, BProf };  // profile types
-
-enum {
-	BuckHashSize = 179999,
-};
-static Bucket **buckhash;
-extern Bucket *runtime·mbuckets;  // memory profile buckets
-extern Bucket *runtime·bbuckets;  // blocking profile buckets
-static uintptr bucketmem;
-
-// Return the bucket for stk[0:nstk], allocating new bucket if needed.
-static Bucket*
-stkbucket(int32 typ, uintptr size, uintptr *stk, int32 nstk, bool alloc)
-{
-	int32 i;
-	uintptr h;
-	Bucket *b;
-
-	if(buckhash == nil) {
-		buckhash = runtime·sysAlloc(BuckHashSize*sizeof buckhash[0], &mstats.buckhash_sys);
-		if(buckhash == nil)
-			runtime·throw("runtime: cannot allocate memory");
-	}
-
-	// Hash stack.
-	h = 0;
-	for(i=0; i<nstk; i++) {
-		h += stk[i];
-		h += h<<10;
-		h ^= h>>6;
-	}
-	// hash in size
-	h += size;
-	h += h<<10;
-	h ^= h>>6;
-	// finalize
-	h += h<<3;
-	h ^= h>>11;
-
-	i = h%BuckHashSize;
-	for(b = buckhash[i]; b; b=b->next)
-		if(b->typ == typ && b->hash == h && b->size == size && b->nstk == nstk &&
-		   runtime·mcmp((byte*)b->stk, (byte*)stk, nstk*sizeof stk[0]) == 0)
-			return b;
-
-	if(!alloc)
-		return nil;
-
-	b = runtime·persistentalloc(sizeof *b + nstk*sizeof stk[0], 0, &mstats.buckhash_sys);
-	bucketmem += sizeof *b + nstk*sizeof stk[0];
-	runtime·memmove(b->stk, stk, nstk*sizeof stk[0]);
-	b->typ = typ;
-	b->hash = h;
-	b->size = size;
-	b->nstk = nstk;
-	b->next = buckhash[i];
-	buckhash[i] = b;
-	if(typ == MProf) {
-		b->allnext = runtime·mbuckets;
-		runtime·mbuckets = b;
-	} else {
-		b->allnext = runtime·bbuckets;
-		runtime·bbuckets = b;
-	}
-	return b;
-}
-
-static void
-MProf_GC(void)
-{
-	Bucket *b;
-
-	for(b=runtime·mbuckets; b; b=b->allnext) {
-		b->data.mp.allocs += b->data.mp.prev_allocs;
-		b->data.mp.frees += b->data.mp.prev_frees;
-		b->data.mp.alloc_bytes += b->data.mp.prev_alloc_bytes;
-		b->data.mp.free_bytes += b->data.mp.prev_free_bytes;
-
-		b->data.mp.prev_allocs = b->data.mp.recent_allocs;
-		b->data.mp.prev_frees = b->data.mp.recent_frees;
-		b->data.mp.prev_alloc_bytes = b->data.mp.recent_alloc_bytes;
-		b->data.mp.prev_free_bytes = b->data.mp.recent_free_bytes;
-
-		b->data.mp.recent_allocs = 0;
-		b->data.mp.recent_frees = 0;
-		b->data.mp.recent_alloc_bytes = 0;
-		b->data.mp.recent_free_bytes = 0;
-	}
-}
-
-// Record that a gc just happened: all the 'recent' statistics are now real.
-void
-runtime·MProf_GC(void)
-{
-	runtime·lock(&runtime·proflock);
-	MProf_GC();
-	runtime·unlock(&runtime·proflock);
-}
-
-// Called by malloc to record a profiled block.
-void
-runtime·MProf_Malloc(void *p, uintptr size)
-{
-	uintptr stk[32];
-	Bucket *b;
-	int32 nstk;
-
-	nstk = runtime·callers(1, stk, nelem(stk));
-	runtime·lock(&runtime·proflock);
-	b = stkbucket(MProf, size, stk, nstk, true);
-	b->data.mp.recent_allocs++;
-	b->data.mp.recent_alloc_bytes += size;
-	runtime·unlock(&runtime·proflock);
-
-	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
-	// This reduces potential contention and chances of deadlocks.
-	// Since the object must be alive during call to MProf_Malloc,
-	// it's fine to do this non-atomically.
-	runtime·setprofilebucket(p, b);
-}
-
-// Called by malloc to record a profiled block.
-void
-runtime·mprofMalloc_m(void)
-{
-	uintptr stk[32];
-	Bucket *b;
-	int32 nstk;
-	uintptr size;
-	void *p;
-
-	size = g->m->scalararg[0];
-	p = g->m->ptrarg[0];
-	g->m->ptrarg[0] = nil;
-	
-	if(g->m->curg == nil)
-		nstk = runtime·callers(1, stk, nelem(stk));
-	else
-		nstk = runtime·gcallers(g->m->curg, 1, stk, nelem(stk));
-	runtime·lock(&runtime·proflock);
-	b = stkbucket(MProf, size, stk, nstk, true);
-	b->data.mp.recent_allocs++;
-	b->data.mp.recent_alloc_bytes += size;
-	runtime·unlock(&runtime·proflock);
-
-	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
-	// This reduces potential contention and chances of deadlocks.
-	// Since the object must be alive during call to MProf_Malloc,
-	// it's fine to do this non-atomically.
-	runtime·setprofilebucket(p, b);
-}
-
-// Called when freeing a profiled block.
-void
-runtime·MProf_Free(Bucket *b, uintptr size, bool freed)
-{
-	runtime·lock(&runtime·proflock);
-	if(freed) {
-		b->data.mp.recent_frees++;
-		b->data.mp.recent_free_bytes += size;
-	} else {
-		b->data.mp.prev_frees++;
-		b->data.mp.prev_free_bytes += size;
-	}
-	runtime·unlock(&runtime·proflock);
-}
-
-int64 runtime·blockprofilerate;  // in CPU ticks
-
-void
-runtime·SetBlockProfileRate(intgo rate)
-{
-	int64 r;
-
-	if(rate <= 0)
-		r = 0;  // disable profiling
-	else {
-		// convert ns to cycles, use float64 to prevent overflow during multiplication
-		r = (float64)rate*runtime·tickspersecond()/(1000*1000*1000);
-		if(r == 0)
-			r = 1;
-	}
-	runtime·atomicstore64((uint64*)&runtime·blockprofilerate, r);
-}
-
-void
-runtime·blockevent(int64 cycles, int32 skip)
-{
-	int32 nstk;
-	int64 rate;
-	uintptr stk[32];
-	Bucket *b;
-
-	if(cycles <= 0)
-		return;
-	rate = runtime·atomicload64((uint64*)&runtime·blockprofilerate);
-	if(rate <= 0 || (rate > cycles && runtime·fastrand1()%rate > cycles))
-		return;
-
-	if(g->m->curg == nil || g->m->curg == g)
-		nstk = runtime·callers(skip, stk, nelem(stk));
-	else
-		nstk = runtime·gcallers(g->m->curg, skip, stk, nelem(stk));
-	runtime·lock(&runtime·proflock);
-	b = stkbucket(BProf, 0, stk, nstk, true);
-	b->data.bp.count++;
-	b->data.bp.cycles += cycles;
-	runtime·unlock(&runtime·proflock);
-}
-
-void
-runtime·iterate_memprof(void (*callback)(Bucket*, uintptr, uintptr*, uintptr, uintptr, uintptr))
-{
-	Bucket *b;
-
-	runtime·lock(&runtime·proflock);
-	for(b=runtime·mbuckets; b; b=b->allnext) {
-		callback(b, b->nstk, b->stk, b->size, b->data.mp.allocs, b->data.mp.frees);
-	}
-	runtime·unlock(&runtime·proflock);
-}
-
-// Go interface to profile data.  (Declared in debug.go)
-
-
-// Must match StackRecord in debug.go.
-typedef struct TRecord TRecord;
-struct TRecord {
-	uintptr stk[32];
-};
-
-static void
-saveg(uintptr pc, uintptr sp, G *gp, TRecord *r)
-{
-	int32 n;
-	
-	n = runtime·gentraceback(pc, sp, 0, gp, 0, r->stk, nelem(r->stk), nil, nil, false);
-	if(n < nelem(r->stk))
-		r->stk[n] = 0;
-}
-
-func GoroutineProfile(b Slice) (n int, ok bool) {
-	uintptr pc, sp, i;
-	TRecord *r;
-	G *gp;
-	
-	sp = runtime·getcallersp(&b);
-	pc = (uintptr)runtime·getcallerpc(&b);
-	
-	ok = false;
-	n = runtime·gcount();
-	if(n <= b.len) {
-		runtime·semacquire(&runtime·worldsema, false);
-		g->m->gcing = 1;
-		runtime·stoptheworld();
-
-		n = runtime·gcount();
-		if(n <= b.len) {
-			ok = true;
-			r = (TRecord*)b.array;
-			saveg(pc, sp, g, r++);
-			for(i = 0; i < runtime·allglen; i++) {
-				gp = runtime·allg[i];
-				if(gp == g || runtime·readgstatus(gp) == Gdead)
-					continue;
-				saveg(~(uintptr)0, ~(uintptr)0, gp, r++);
-			}
-		}
-	
-		g->m->gcing = 0;
-		runtime·semrelease(&runtime·worldsema);
-		runtime·starttheworld();
-	}
-}
-
-// Tracing of alloc/free/gc.
-
-static Mutex tracelock;
-
-void
-runtime·tracealloc(void *p, uintptr size, Type *type)
-{
-	runtime·lock(&tracelock);
-	g->m->traceback = 2;
-	if(type == nil)
-		runtime·printf("tracealloc(%p, %p)\n", p, size);
-	else	
-		runtime·printf("tracealloc(%p, %p, %S)\n", p, size, *type->string);
-	if(g->m->curg == nil || g == g->m->curg) {
-		runtime·goroutineheader(g);
-		runtime·traceback((uintptr)runtime·getcallerpc(&p), (uintptr)runtime·getcallersp(&p), 0, g);
-	} else {
-		runtime·goroutineheader(g->m->curg);
-		runtime·traceback(~(uintptr)0, ~(uintptr)0, 0, g->m->curg);
-	}
-	runtime·printf("\n");
-	g->m->traceback = 0;
-	runtime·unlock(&tracelock);
-}
-
-void
-runtime·tracefree(void *p, uintptr size)
-{
-	runtime·lock(&tracelock);
-	g->m->traceback = 2;
-	runtime·printf("tracefree(%p, %p)\n", p, size);
-	runtime·goroutineheader(g);
-	runtime·traceback((uintptr)runtime·getcallerpc(&p), (uintptr)runtime·getcallersp(&p), 0, g);
-	runtime·printf("\n");
-	g->m->traceback = 0;
-	runtime·unlock(&tracelock);
-}
-
-void
-runtime·tracegc(void)
-{
-	runtime·lock(&tracelock);
-	g->m->traceback = 2;
-	runtime·printf("tracegc()\n");
-	// running on m->g0 stack; show all non-g0 goroutines
-	runtime·tracebackothers(g);
-	runtime·printf("end tracegc\n");
-	runtime·printf("\n");
-	g->m->traceback = 0;
-	runtime·unlock(&tracelock);
-}
diff --git a/src/pkg/runtime/mprof.h b/src/pkg/runtime/mprof.h
deleted file mode 100644
index a8cf1513e8..0000000000
--- a/src/pkg/runtime/mprof.h
+++ /dev/null
@@ -1,56 +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.
-
-// Per-call-stack profiling information.
-// Lookup by hashing call stack into a linked-list hash table.
-struct Bucket
-{
-	Bucket	*next;	// next in hash list
-	Bucket	*allnext;	// next in list of all mbuckets/bbuckets
-	int32	typ;
-	// Generally unions can break precise GC,
-	// this one is fine because it does not contain pointers.
-	union
-	{
-		struct MProfRecord // typ == MProf
-		{
-			// The following complex 3-stage scheme of stats accumulation
-			// is required to obtain a consistent picture of mallocs and frees
-			// for some point in time.
-			// The problem is that mallocs come in real time, while frees
-			// come only after a GC during concurrent sweeping. So if we would
-			// naively count them, we would get a skew toward mallocs.
-			//
-			// Mallocs are accounted in recent stats.
-			// Explicit frees are accounted in recent stats.
-			// GC frees are accounted in prev stats.
-			// After GC prev stats are added to final stats and
-			// recent stats are moved into prev stats.
-			uintptr	allocs;
-			uintptr	frees;
-			uintptr	alloc_bytes;
-			uintptr	free_bytes;
-
-			uintptr	prev_allocs;  // since last but one till last gc
-			uintptr	prev_frees;
-			uintptr	prev_alloc_bytes;
-			uintptr	prev_free_bytes;
-
-			uintptr	recent_allocs;  // since last gc till now
-			uintptr	recent_frees;
-			uintptr	recent_alloc_bytes;
-			uintptr	recent_free_bytes;
-
-		} mp;
-		struct BProfRecord // typ == BProf
-		{
-			int64	count;
-			int64	cycles;
-		} bp;
-	} data;
-	uintptr	hash;	// hash of size + stk
-	uintptr	size;
-	uintptr	nstk;
-	uintptr	stk[1];
-};
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 666adfb7db..9143fcf596 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -83,6 +83,7 @@ static int32	newprocs;
 
 static	Mutex allglock;	// the following vars are protected by this lock or by stoptheworld
 G**	runtime·allg;
+Slice	runtime·allgs;
 uintptr runtime·allglen;
 static	uintptr allgcap;
 ForceGCState	runtime·forcegc;
@@ -2131,9 +2132,12 @@ allgadd(G *gp)
 		if(runtime·allg != nil)
 			runtime·memmove(new, runtime·allg, runtime·allglen*sizeof(new[0]));
 		runtime·allg = new;
+		runtime·allgs.array = (void*)runtime·allg;
 		allgcap = cap;
+		runtime·allgs.cap = allgcap;
 	}
 	runtime·allg[runtime·allglen++] = gp;
+	runtime·allgs.len = runtime·allglen;
 	runtime·unlock(&allglock);
 }
 
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index bb0a87c38a..6b909599ba 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -683,6 +683,7 @@ enum
 extern	String	runtime·emptystring;
 extern	uintptr runtime·zerobase;
 extern	G**	runtime·allg;
+extern	Slice	runtime·allgs; // []*G
 extern	uintptr runtime·allglen;
 extern	G*	runtime·lastg;
 extern	M*	runtime·allm;
@@ -868,7 +869,6 @@ void	runtime·usleep(uint32);
 int64	runtime·cputicks(void);
 int64	runtime·tickspersecond(void);
 void	runtime·blockevent(int64, int32);
-extern int64 runtime·blockprofilerate;
 G*	runtime·netpoll(bool);
 void	runtime·netpollinit(void);
 int32	runtime·netpollopen(uintptr, PollDesc*);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 789aa2e9ff..2e5c0481ab 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -74,7 +74,6 @@ func onM(fn *mFunction)
 var (
 	mcacheRefill_m,
 	largeAlloc_m,
-	mprofMalloc_m,
 	gc_m,
 	scavenge_m,
 	setFinalizer_m,
@@ -89,15 +88,12 @@ var (
 	park_m mFunction
 )
 
-func blockevent(int64, int32)
-
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
 //go:noescape
 func memclr(ptr unsafe.Pointer, n uintptr)
 
 func racemalloc(p unsafe.Pointer, size uintptr)
-func tracealloc(p unsafe.Pointer, size uintptr, typ *_type)
 
 // memmove copies n bytes from "from" to "to".
 // in memmove_*.s

From a8c5e87b1e5ef224a10440bff6b79b605570cd3c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 19:42:22 -0400
Subject: [PATCH 327/423] runtime: fix Stack

Fixes #8626.

LGTM=bradfitz
R=golang-codereviews
CC=bradfitz, golang-codereviews, iant, r
https://golang.org/cl/137050043
---
 src/pkg/runtime/mprof.go      |  4 ++--
 src/pkg/runtime/stack_test.go | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 8546a341bd..1734fd8470 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -584,13 +584,13 @@ func Stack(buf []byte, all bool) int {
 
 	n := 0
 	if len(buf) > 0 {
-		gp.writebuf = buf
+		gp.writebuf = buf[0:0:len(buf)]
 		goroutineheader(gp)
 		traceback(pc, sp, 0, gp)
 		if all {
 			tracebackothers(gp)
 		}
-		n = len(buf) - len(gp.writebuf)
+		n = len(gp.writebuf)
 		gp.writebuf = nil
 	}
 
diff --git a/src/pkg/runtime/stack_test.go b/src/pkg/runtime/stack_test.go
index 2877074f76..b3dcbd12a0 100644
--- a/src/pkg/runtime/stack_test.go
+++ b/src/pkg/runtime/stack_test.go
@@ -6,6 +6,7 @@ package runtime_test
 
 import (
 	. "runtime"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -331,3 +332,12 @@ func TestStackCache(t *testing.T) {
 		}
 	}
 }
+
+func TestStackOutput(t *testing.T) {
+	b := make([]byte, 1024)
+	stk := string(b[:Stack(b, false)])
+	if !strings.HasPrefix(stk, "goroutine ") {
+		t.Errorf("Stack (len %d):\n%s", len(stk), stk)
+		t.Errorf("Stack output should begin with \"goroutine \"")
+	}
+}

From 5dd9d582f175701fbf461c2e5ca6bbb1021cbd25 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Tue, 2 Sep 2014 11:54:24 +1000
Subject: [PATCH 328/423] time: update generated zoneinfo_abbrs_windows.go

The file in repo has been updated recently, but all these changes
are gone off the web site now. It seems web site gets updated once
in a while, so we'll update our file occasionally.

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews
https://golang.org/cl/140780043
---
 src/pkg/time/zoneinfo_abbrs_windows.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pkg/time/zoneinfo_abbrs_windows.go b/src/pkg/time/zoneinfo_abbrs_windows.go
index df0c10e91c..51a1a2f66d 100644
--- a/src/pkg/time/zoneinfo_abbrs_windows.go
+++ b/src/pkg/time/zoneinfo_abbrs_windows.go
@@ -13,7 +13,7 @@ type abbr struct {
 }
 
 var abbrs = map[string]abbr{
-	"Egypt Standard Time":             {"EET", "EEST"},   // Africa/Cairo
+	"Egypt Standard Time":             {"EET", "EET"},    // Africa/Cairo
 	"Morocco Standard Time":           {"WET", "WEST"},   // Africa/Casablanca
 	"South Africa Standard Time":      {"SAST", "SAST"},  // Africa/Johannesburg
 	"W. Central Africa Standard Time": {"WAT", "WAT"},    // Africa/Lagos
@@ -22,7 +22,7 @@ var abbrs = map[string]abbr{
 	"Namibia Standard Time":           {"WAT", "WAST"},   // Africa/Windhoek
 	"Alaskan Standard Time":           {"AKST", "AKDT"},  // America/Anchorage
 	"Paraguay Standard Time":          {"PYT", "PYST"},   // America/Asuncion
-	"Bahia Standard Time":             {"BRT", "BRT"},    // America/Bahia
+	"Bahia Standard Time":             {"BRT", "BRST"},   // America/Bahia
 	"SA Pacific Standard Time":        {"COT", "COT"},    // America/Bogota
 	"Argentina Standard Time":         {"ART", "ART"},    // America/Buenos_Aires
 	"Venezuela Standard Time":         {"VET", "VET"},    // America/Caracas
@@ -105,9 +105,9 @@ var abbrs = map[string]abbr{
 	"Romance Standard Time":          {"CET", "CEST"},      // Europe/Paris
 	"Central European Standard Time": {"CET", "CEST"},      // Europe/Warsaw
 	"Mauritius Standard Time":        {"MUT", "MUT"},       // Indian/Mauritius
-	"Samoa Standard Time":            {"WST", "WSDT"},      // Pacific/Apia
+	"Samoa Standard Time":            {"WST", "WST"},       // Pacific/Apia
 	"New Zealand Standard Time":      {"NZST", "NZDT"},     // Pacific/Auckland
-	"Fiji Standard Time":             {"FJT", "FJST"},      // Pacific/Fiji
+	"Fiji Standard Time":             {"FJT", "FJT"},       // Pacific/Fiji
 	"Central Pacific Standard Time":  {"SBT", "SBT"},       // Pacific/Guadalcanal
 	"Hawaiian Standard Time":         {"HST", "HST"},       // Pacific/Honolulu
 	"Line Islands Standard Time":     {"LINT", "LINT"},     // Pacific/Kiritimati

From 649c83530a9c3a71319ed3d2ff53d9ecf2f2fd04 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Mon, 1 Sep 2014 21:55:57 -0400
Subject: [PATCH 329/423] runtime: fix race detector running Go code on g0 of
 non-main thread

It looks like this has just always been broken:
the race detector handles running Go code on g0 of the main thread
and on g0 of any extra threads created by non-Go code, but it does
not handle running Go code on g0 of non-main threads created by Go.
Handle that.

Should fix the race build failures on the dashboard.

We're running into this now because we are running more
and more Go code on g0.

TBR=dvyukov
CC=golang-codereviews
https://golang.org/cl/137910043
---
 src/pkg/runtime/proc.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 9143fcf596..1a82c8e541 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1077,6 +1077,8 @@ newm(void(*fn)(void), P *p)
 	mp = runtime·allocm(p);
 	mp->nextp = p;
 	mp->mstartfn = fn;
+	if(raceenabled)
+		mp->g0->racectx = runtime·racegostart(newm);
 
 	if(runtime·iscgo) {
 		CgoThreadStart ts;

From 20d9cc4bb0dceed4d06338e69b7eea5287650fc7 Mon Sep 17 00:00:00 2001
From: David du Colombier <0intro@gmail.com>
Date: Mon, 1 Sep 2014 23:03:26 -0400
Subject: [PATCH 330/423] runtime: fix gogetenv on Plan 9

LGTM=rsc
R=rsc, ality
CC=golang-codereviews
https://golang.org/cl/137030043
---
 src/pkg/runtime/env_plan9.go | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/src/pkg/runtime/env_plan9.go b/src/pkg/runtime/env_plan9.go
index 85c1c856b0..b6dcb4c1ea 100644
--- a/src/pkg/runtime/env_plan9.go
+++ b/src/pkg/runtime/env_plan9.go
@@ -30,21 +30,11 @@ func gogetenv(key string) string {
 	if fd < 0 {
 		return ""
 	}
-	n := seek(fd, 0, 2)
+	n := seek(fd, 0, 2) - 1
 
-	var p unsafe.Pointer
+	p := make([]byte, n)
 
-	// Be sure not to allocate for $GOTRACEBACK.
-	if key == "GOTRACEBACK" {
-		if n >= 128 {
-			return ""
-		}
-		p = unsafe.Pointer(&tracebackbuf[0])
-	} else {
-		p = gomallocgc(uintptr(n+1), nil, 0)
-	}
-
-	r := pread(fd, p, int32(n), 0)
+	r := pread(fd, unsafe.Pointer(&p[0]), int32(n), 0)
 	close(fd)
 	if r < 0 {
 		return ""
@@ -52,7 +42,7 @@ func gogetenv(key string) string {
 
 	var s string
 	sp := (*_string)(unsafe.Pointer(&s))
-	sp.str = (*byte)(p)
+	sp.str = &p[0]
 	sp.len = int(r)
 	return s
 }

From a19e638db27d6e03c9f0c0220a547f7ebd9e599a Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Mon, 1 Sep 2014 23:06:22 -0400
Subject: [PATCH 331/423] runtime/pprof: adjust cpuHogger so that tests pass on
 windows builders

LGTM=rsc
R=dvyukov, rsc
CC=golang-codereviews
https://golang.org/cl/140110043
---
 src/pkg/runtime/pprof/pprof_test.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pkg/runtime/pprof/pprof_test.go b/src/pkg/runtime/pprof/pprof_test.go
index 3c59fe76cb..dd8f2d0529 100644
--- a/src/pkg/runtime/pprof/pprof_test.go
+++ b/src/pkg/runtime/pprof/pprof_test.go
@@ -23,12 +23,12 @@ import (
 
 func cpuHogger(f func()) {
 	// We only need to get one 100 Hz clock tick, so we've got
-	// a 25x safety buffer.
-	// But do at least 500 iterations (which should take about 100ms),
+	// a 100x safety buffer.
+	// But do at least 2000 iterations (which should take about 400ms),
 	// otherwise TestCPUProfileMultithreaded can fail if only one
-	// thread is scheduled during the 250ms period.
+	// thread is scheduled during the 1 second period.
 	t0 := time.Now()
-	for i := 0; i < 500 || time.Since(t0) < 250*time.Millisecond; i++ {
+	for i := 0; i < 2000 || time.Since(t0) < time.Second; i++ {
 		f()
 	}
 }

From ac49e6735bb3757a16816f7400ce823cd6fc8508 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Tue, 2 Sep 2014 00:14:22 -0400
Subject: [PATCH 332/423] runtime: convert cpuprof from C to Go

LGTM=dvyukov, rsc
R=golang-codereviews, dvyukov, rsc
CC=golang-codereviews
https://golang.org/cl/132440043
---
 src/pkg/runtime/cpuprof.go  | 424 +++++++++++++++++++++++++++++++++++
 src/pkg/runtime/cpuprof.goc | 433 ------------------------------------
 src/pkg/runtime/debug.go    |  19 --
 src/pkg/runtime/proc.c      |  17 +-
 src/pkg/runtime/runtime.h   |   2 +-
 5 files changed, 431 insertions(+), 464 deletions(-)
 create mode 100644 src/pkg/runtime/cpuprof.go
 delete mode 100644 src/pkg/runtime/cpuprof.goc

diff --git a/src/pkg/runtime/cpuprof.go b/src/pkg/runtime/cpuprof.go
new file mode 100644
index 0000000000..540c78de8a
--- /dev/null
+++ b/src/pkg/runtime/cpuprof.go
@@ -0,0 +1,424 @@
+// 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.
+
+// CPU profiling.
+// Based on algorithms and data structures used in
+// http://code.google.com/p/google-perftools/.
+//
+// The main difference between this code and the google-perftools
+// code is that this code is written to allow copying the profile data
+// to an arbitrary io.Writer, while the google-perftools code always
+// writes to an operating system file.
+//
+// The signal handler for the profiling clock tick adds a new stack trace
+// to a hash table tracking counts for recent traces.  Most clock ticks
+// hit in the cache.  In the event of a cache miss, an entry must be
+// evicted from the hash table, copied to a log that will eventually be
+// written as profile data.  The google-perftools code flushed the
+// log itself during the signal handler.  This code cannot do that, because
+// the io.Writer might block or need system calls or locks that are not
+// safe to use from within the signal handler.  Instead, we split the log
+// into two halves and let the signal handler fill one half while a goroutine
+// is writing out the other half.  When the signal handler fills its half, it
+// offers to swap with the goroutine.  If the writer is not done with its half,
+// we lose the stack trace for this clock tick (and record that loss).
+// The goroutine interacts with the signal handler by calling getprofile() to
+// get the next log piece to write, implicitly handing back the last log
+// piece it obtained.
+//
+// The state of this dance between the signal handler and the goroutine
+// is encoded in the Profile.handoff field.  If handoff == 0, then the goroutine
+// is not using either log half and is waiting (or will soon be waiting) for
+// a new piece by calling notesleep(&p->wait).  If the signal handler
+// changes handoff from 0 to non-zero, it must call notewakeup(&p->wait)
+// to wake the goroutine.  The value indicates the number of entries in the
+// log half being handed off.  The goroutine leaves the non-zero value in
+// place until it has finished processing the log half and then flips the number
+// back to zero.  Setting the high bit in handoff means that the profiling is over,
+// and the goroutine is now in charge of flushing the data left in the hash table
+// to the log and returning that data.
+//
+// The handoff field is manipulated using atomic operations.
+// For the most part, the manipulation of handoff is orderly: if handoff == 0
+// then the signal handler owns it and can change it to non-zero.
+// If handoff != 0 then the goroutine owns it and can change it to zero.
+// If that were the end of the story then we would not need to manipulate
+// handoff using atomic operations.  The operations are needed, however,
+// in order to let the log closer set the high bit to indicate "EOF" safely
+// in the situation when normally the goroutine "owns" handoff.
+
+package runtime
+
+import "unsafe"
+
+const (
+	numBuckets      = 1 << 10
+	logSize         = 1 << 17
+	assoc           = 4
+	maxCPUProfStack = 64
+)
+
+type cpuprofEntry struct {
+	count uintptr
+	depth uintptr
+	stack [maxCPUProfStack]uintptr
+}
+
+type cpuProfile struct {
+	on     bool    // profiling is on
+	wait   note    // goroutine waits here
+	count  uintptr // tick count
+	evicts uintptr // eviction count
+	lost   uintptr // lost ticks that need to be logged
+
+	// Active recent stack traces.
+	hash [numBuckets]struct {
+		entry [assoc]cpuprofEntry
+	}
+
+	// Log of traces evicted from hash.
+	// Signal handler has filled log[toggle][:nlog].
+	// Goroutine is writing log[1-toggle][:handoff].
+	log     [2][logSize / 2]uintptr
+	nlog    uintptr
+	toggle  int32
+	handoff uint32
+
+	// Writer state.
+	// Writer maintains its own toggle to avoid races
+	// looking at signal handler's toggle.
+	wtoggle  uint32
+	wholding bool // holding & need to release a log half
+	flushing bool // flushing hash table - profile is over
+	eodSent  bool // special end-of-data record sent; => flushing
+}
+
+var (
+	cpuprofLock mutex
+	cpuprof     *cpuProfile
+
+	eod = [3]uintptr{0, 1, 0}
+)
+
+func setcpuprofilerate(int32) // proc.c
+
+// lostProfileData is a no-op function used in profiles
+// to mark the number of profiling stack traces that were
+// discarded due to slow data writers.
+func lostProfileData() {}
+
+// SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
+// If hz <= 0, SetCPUProfileRate turns off profiling.
+// If the profiler is on, the rate cannot be changed without first turning it off.
+//
+// Most clients should use the runtime/pprof package or
+// the testing package's -test.cpuprofile flag instead of calling
+// SetCPUProfileRate directly.
+func SetCPUProfileRate(hz int) {
+	// Clamp hz to something reasonable.
+	if hz < 0 {
+		hz = 0
+	}
+	if hz > 1000000 {
+		hz = 1000000
+	}
+
+	lock(&cpuprofLock)
+	if hz > 0 {
+		if cpuprof == nil {
+			cpuprof = (*cpuProfile)(sysAlloc(unsafe.Sizeof(cpuProfile{}), &memstats.other_sys))
+			if cpuprof == nil {
+				print("runtime: cpu profiling cannot allocate memory\n")
+				unlock(&cpuprofLock)
+				return
+			}
+		}
+		if cpuprof.on || cpuprof.handoff != 0 {
+			print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
+			unlock(&cpuprofLock)
+			return
+		}
+
+		cpuprof.on = true
+		// pprof binary header format.
+		// http://code.google.com/p/google-perftools/source/browse/trunk/src/profiledata.cc#117
+		p := &cpuprof.log[0]
+		p[0] = 0                 // count for header
+		p[1] = 3                 // depth for header
+		p[2] = 0                 // version number
+		p[3] = uintptr(1e6 / hz) // period (microseconds)
+		p[4] = 0
+		cpuprof.nlog = 5
+		cpuprof.toggle = 0
+		cpuprof.wholding = false
+		cpuprof.wtoggle = 0
+		cpuprof.flushing = false
+		cpuprof.eodSent = false
+		noteclear(&cpuprof.wait)
+
+		setcpuprofilerate(int32(hz))
+	} else if cpuprof != nil && cpuprof.on {
+		setcpuprofilerate(0)
+		cpuprof.on = false
+
+		// Now add is not running anymore, and getprofile owns the entire log.
+		// Set the high bit in prof->handoff to tell getprofile.
+		for {
+			n := cpuprof.handoff
+			if n&0x80000000 != 0 {
+				print("runtime: setcpuprofile(off) twice\n")
+			}
+			if cas(&cpuprof.handoff, n, n|0x80000000) {
+				if n == 0 {
+					// we did the transition from 0 -> nonzero so we wake getprofile
+					notewakeup(&cpuprof.wait)
+				}
+				break
+			}
+		}
+	}
+	unlock(&cpuprofLock)
+}
+
+func cpuproftick(pc *uintptr, n int32) {
+	if n > maxCPUProfStack {
+		n = maxCPUProfStack
+	}
+	s := (*[maxCPUProfStack]uintptr)(unsafe.Pointer(pc))[:n]
+	cpuprof.add(s)
+}
+
+// add adds the stack trace to the profile.
+// It is called from signal handlers and other limited environments
+// and cannot allocate memory or acquire locks that might be
+// held at the time of the signal, nor can it use substantial amounts
+// of stack.  It is allowed to call evict.
+func (p *cpuProfile) add(pc []uintptr) {
+	// Compute hash.
+	h := uintptr(0)
+	for _, x := range pc {
+		h = h<<8 | (h >> (8 * (unsafe.Sizeof(h) - 1)))
+		h += x*31 + x*7 + x*3
+	}
+	p.count++
+
+	// Add to entry count if already present in table.
+	b := &p.hash[h%numBuckets]
+Assoc:
+	for i := range b.entry {
+		e := &b.entry[i]
+		if e.depth != uintptr(len(pc)) {
+			continue
+		}
+		for j := range pc {
+			if e.stack[j] != pc[j] {
+				continue Assoc
+			}
+		}
+		e.count++
+		return
+	}
+
+	// Evict entry with smallest count.
+	var e *cpuprofEntry
+	for i := range b.entry {
+		if e == nil || b.entry[i].count < e.count {
+			e = &b.entry[i]
+		}
+	}
+	if e.count > 0 {
+		if !p.evict(e) {
+			// Could not evict entry.  Record lost stack.
+			p.lost++
+			return
+		}
+		p.evicts++
+	}
+
+	// Reuse the newly evicted entry.
+	e.depth = uintptr(len(pc))
+	e.count = 1
+	for i := range pc {
+		e.stack[i] = pc[i]
+	}
+}
+
+// evict copies the given entry's data into the log, so that
+// the entry can be reused.  evict is called from add, which
+// is called from the profiling signal handler, so it must not
+// allocate memory or block.  It is safe to call flushlog.
+// evict returns true if the entry was copied to the log,
+// false if there was no room available.
+func (p *cpuProfile) evict(e *cpuprofEntry) bool {
+	d := e.depth
+	nslot := d + 2
+	log := &p.log[p.toggle]
+	if p.nlog+nslot > uintptr(len(p.log[0])) {
+		if !p.flushlog() {
+			return false
+		}
+		log = &p.log[p.toggle]
+	}
+
+	q := p.nlog
+	log[q] = e.count
+	q++
+	log[q] = d
+	q++
+	for i := uintptr(0); i < d; i++ {
+		log[q] = e.stack[i]
+		q++
+	}
+	p.nlog = q
+	e.count = 0
+	return true
+}
+
+// flushlog tries to flush the current log and switch to the other one.
+// flushlog is called from evict, called from add, called from the signal handler,
+// so it cannot allocate memory or block.  It can try to swap logs with
+// the writing goroutine, as explained in the comment at the top of this file.
+func (p *cpuProfile) flushlog() bool {
+	if !cas(&p.handoff, 0, uint32(p.nlog)) {
+		return false
+	}
+	notewakeup(&p.wait)
+
+	p.toggle = 1 - p.toggle
+	log := &p.log[p.toggle]
+	q := uintptr(0)
+	if p.lost > 0 {
+		f := lostProfileData
+		lostPC := **(**uintptr)(unsafe.Pointer(&f))
+		log[0] = p.lost
+		log[1] = 1
+		log[2] = lostPC
+		q = 3
+		p.lost = 0
+	}
+	p.nlog = q
+	return true
+}
+
+// getprofile blocks until the next block of profiling data is available
+// and returns it as a []byte.  It is called from the writing goroutine.
+func (p *cpuProfile) getprofile() []byte {
+	if p == nil {
+		return nil
+	}
+
+	if p.wholding {
+		// Release previous log to signal handling side.
+		// Loop because we are racing against SetCPUProfileRate(0).
+		for {
+			n := p.handoff
+			if n == 0 {
+				print("runtime: phase error during cpu profile handoff\n")
+				return nil
+			}
+			if n&0x80000000 != 0 {
+				p.wtoggle = 1 - p.wtoggle
+				p.wholding = false
+				p.flushing = true
+				goto Flush
+			}
+			if cas(&p.handoff, n, 0) {
+				break
+			}
+		}
+		p.wtoggle = 1 - p.wtoggle
+		p.wholding = false
+	}
+
+	if p.flushing {
+		goto Flush
+	}
+
+	if !p.on && p.handoff == 0 {
+		return nil
+	}
+
+	// Wait for new log.
+	notetsleepg(&p.wait, -1)
+	noteclear(&p.wait)
+
+	switch n := p.handoff; {
+	case n == 0:
+		print("runtime: phase error during cpu profile wait\n")
+		return nil
+	case n == 0x80000000:
+		p.flushing = true
+		goto Flush
+	default:
+		n &^= 0x80000000
+
+		// Return new log to caller.
+		p.wholding = true
+
+		return uintptrBytes(p.log[p.wtoggle][:n])
+	}
+
+	// In flush mode.
+	// Add is no longer being called.  We own the log.
+	// Also, p->handoff is non-zero, so flushlog will return false.
+	// Evict the hash table into the log and return it.
+Flush:
+	for i := range p.hash {
+		b := &p.hash[i]
+		for j := range b.entry {
+			e := &b.entry[j]
+			if e.count > 0 && !p.evict(e) {
+				// Filled the log.  Stop the loop and return what we've got.
+				break Flush
+			}
+		}
+	}
+
+	// Return pending log data.
+	if p.nlog > 0 {
+		// Note that we're using toggle now, not wtoggle,
+		// because we're working on the log directly.
+		n := p.nlog
+		p.nlog = 0
+		return uintptrBytes(p.log[p.toggle][:n])
+	}
+
+	// Made it through the table without finding anything to log.
+	if !p.eodSent {
+		// We may not have space to append this to the partial log buf,
+		// so we always return a new slice for the end-of-data marker.
+		p.eodSent = true
+		return uintptrBytes(eod[:])
+	}
+
+	// Finally done.  Clean up and return nil.
+	p.flushing = false
+	if !cas(&p.handoff, p.handoff, 0) {
+		print("runtime: profile flush racing with something\n")
+	}
+	return nil
+}
+
+func uintptrBytes(p []uintptr) (ret []byte) {
+	pp := (*sliceStruct)(unsafe.Pointer(&p))
+	rp := (*sliceStruct)(unsafe.Pointer(&ret))
+
+	rp.array = pp.array
+	rp.len = pp.len * int(unsafe.Sizeof(p[0]))
+	rp.cap = rp.len
+
+	return
+}
+
+// CPUProfile returns the next chunk of binary CPU profiling stack trace data,
+// blocking until data is available.  If profiling is turned off and all the profile
+// data accumulated while it was on has been returned, CPUProfile returns nil.
+// The caller must save the returned data before calling CPUProfile again.
+//
+// Most clients should use the runtime/pprof package or
+// the testing package's -test.cpuprofile flag instead of calling
+// CPUProfile directly.
+func CPUProfile() []byte {
+	return cpuprof.getprofile()
+}
diff --git a/src/pkg/runtime/cpuprof.goc b/src/pkg/runtime/cpuprof.goc
deleted file mode 100644
index 0d6d078ffd..0000000000
--- a/src/pkg/runtime/cpuprof.goc
+++ /dev/null
@@ -1,433 +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.
-
-// CPU profiling.
-// Based on algorithms and data structures used in
-// http://code.google.com/p/google-perftools/.
-//
-// The main difference between this code and the google-perftools
-// code is that this code is written to allow copying the profile data
-// to an arbitrary io.Writer, while the google-perftools code always
-// writes to an operating system file.
-//
-// The signal handler for the profiling clock tick adds a new stack trace
-// to a hash table tracking counts for recent traces.  Most clock ticks
-// hit in the cache.  In the event of a cache miss, an entry must be 
-// evicted from the hash table, copied to a log that will eventually be
-// written as profile data.  The google-perftools code flushed the
-// log itself during the signal handler.  This code cannot do that, because
-// the io.Writer might block or need system calls or locks that are not
-// safe to use from within the signal handler.  Instead, we split the log
-// into two halves and let the signal handler fill one half while a goroutine
-// is writing out the other half.  When the signal handler fills its half, it
-// offers to swap with the goroutine.  If the writer is not done with its half,
-// we lose the stack trace for this clock tick (and record that loss).
-// The goroutine interacts with the signal handler by calling getprofile() to
-// get the next log piece to write, implicitly handing back the last log
-// piece it obtained.
-//
-// The state of this dance between the signal handler and the goroutine
-// is encoded in the Profile.handoff field.  If handoff == 0, then the goroutine
-// is not using either log half and is waiting (or will soon be waiting) for
-// a new piece by calling notesleep(&p->wait).  If the signal handler
-// changes handoff from 0 to non-zero, it must call notewakeup(&p->wait)
-// to wake the goroutine.  The value indicates the number of entries in the
-// log half being handed off.  The goroutine leaves the non-zero value in
-// place until it has finished processing the log half and then flips the number
-// back to zero.  Setting the high bit in handoff means that the profiling is over, 
-// and the goroutine is now in charge of flushing the data left in the hash table
-// to the log and returning that data.  
-//
-// The handoff field is manipulated using atomic operations.
-// For the most part, the manipulation of handoff is orderly: if handoff == 0
-// then the signal handler owns it and can change it to non-zero.  
-// If handoff != 0 then the goroutine owns it and can change it to zero.
-// If that were the end of the story then we would not need to manipulate
-// handoff using atomic operations.  The operations are needed, however,
-// in order to let the log closer set the high bit to indicate "EOF" safely
-// in the situation when normally the goroutine "owns" handoff.
-
-package runtime
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-
-enum
-{
-	HashSize = 1<<10,
-	LogSize = 1<<17,
-	Assoc = 4,
-	MaxStack = 64,
-};
-
-typedef struct Profile Profile;
-typedef struct Bucket Bucket;
-typedef struct Entry Entry;
-
-struct Entry {
-	uintptr count;
-	uintptr depth;
-	uintptr stack[MaxStack];
-};
-
-struct Bucket {
-	Entry entry[Assoc];
-};
-
-struct Profile {
-	bool on;		// profiling is on
-	Note wait;		// goroutine waits here
-	uintptr count;		// tick count
-	uintptr evicts;		// eviction count
-	uintptr lost;		// lost ticks that need to be logged
-
-	// Active recent stack traces.
-	Bucket hash[HashSize];
-
-	// Log of traces evicted from hash.
-	// Signal handler has filled log[toggle][:nlog].
-	// Goroutine is writing log[1-toggle][:handoff].
-	uintptr log[2][LogSize/2];
-	uintptr nlog;
-	int32 toggle;
-	uint32 handoff;
-	
-	// Writer state.
-	// Writer maintains its own toggle to avoid races
-	// looking at signal handler's toggle.
-	uint32 wtoggle;
-	bool wholding;	// holding & need to release a log half
-	bool flushing;	// flushing hash table - profile is over
-	bool eod_sent;  // special end-of-data record sent; => flushing
-};
-
-static Mutex lk;
-static Profile *prof;
-
-static void tick(uintptr*, int32);
-static void add(Profile*, uintptr*, int32);
-static bool evict(Profile*, Entry*);
-static bool flushlog(Profile*);
-
-static uintptr eod[3] = {0, 1, 0};
-
-// LostProfileData is a no-op function used in profiles
-// to mark the number of profiling stack traces that were
-// discarded due to slow data writers.
-static void
-LostProfileData(void)
-{
-}
-
-// SetCPUProfileRate sets the CPU profiling rate.
-// The user documentation is in debug.go.
-void
-runtime·SetCPUProfileRate(intgo hz)
-{
-	uintptr *p;
-	uintptr n;
-
-	// Clamp hz to something reasonable.
-	if(hz < 0)
-		hz = 0;
-	if(hz > 1000000)
-		hz = 1000000;
-
-	runtime·lock(&lk);
-	if(hz > 0) {
-		if(prof == nil) {
-			prof = runtime·sysAlloc(sizeof *prof, &mstats.other_sys);
-			if(prof == nil) {
-				runtime·printf("runtime: cpu profiling cannot allocate memory\n");
-				runtime·unlock(&lk);
-				return;
-			}
-		}
-		if(prof->on || prof->handoff != 0) {
-			runtime·printf("runtime: cannot set cpu profile rate until previous profile has finished.\n");
-			runtime·unlock(&lk);
-			return;
-		}
-
-		prof->on = true;
-		p = prof->log[0];
-		// pprof binary header format.
-		// http://code.google.com/p/google-perftools/source/browse/trunk/src/profiledata.cc#117
-		*p++ = 0;  // count for header
-		*p++ = 3;  // depth for header
-		*p++ = 0;  // version number
-		*p++ = 1000000 / hz;  // period (microseconds)
-		*p++ = 0;
-		prof->nlog = p - prof->log[0];
-		prof->toggle = 0;
-		prof->wholding = false;
-		prof->wtoggle = 0;
-		prof->flushing = false;
-		prof->eod_sent = false;
-		runtime·noteclear(&prof->wait);
-
-		runtime·setcpuprofilerate(tick, hz);
-	} else if(prof != nil && prof->on) {
-		runtime·setcpuprofilerate(nil, 0);
-		prof->on = false;
-
-		// Now add is not running anymore, and getprofile owns the entire log.
-		// Set the high bit in prof->handoff to tell getprofile.
-		for(;;) {
-			n = prof->handoff;
-			if(n&0x80000000)
-				runtime·printf("runtime: setcpuprofile(off) twice");
-			if(runtime·cas(&prof->handoff, n, n|0x80000000))
-				break;
-		}
-		if(n == 0) {
-			// we did the transition from 0 -> nonzero so we wake getprofile
-			runtime·notewakeup(&prof->wait);
-		}
-	}
-	runtime·unlock(&lk);
-}
-
-static void
-tick(uintptr *pc, int32 n)
-{
-	add(prof, pc, n);
-}
-
-// add adds the stack trace to the profile.
-// It is called from signal handlers and other limited environments
-// and cannot allocate memory or acquire locks that might be
-// held at the time of the signal, nor can it use substantial amounts
-// of stack.  It is allowed to call evict.
-static void
-add(Profile *p, uintptr *pc, int32 n)
-{
-	int32 i, j;
-	uintptr h, x;
-	Bucket *b;
-	Entry *e;
-
-	if(n > MaxStack)
-		n = MaxStack;
-	
-	// Compute hash.
-	h = 0;
-	for(i=0; i<n; i++) {
-		h = h<<8 | (h>>(8*(sizeof(h)-1)));
-		x = pc[i];
-		h += x*31 + x*7 + x*3;
-	}
-	p->count++;
-
-	// Add to entry count if already present in table.
-	b = &p->hash[h%HashSize];
-	for(i=0; i<Assoc; i++) {
-		e = &b->entry[i];
-		if(e->depth != n)	
-			continue;
-		for(j=0; j<n; j++)
-			if(e->stack[j] != pc[j])
-				goto ContinueAssoc;
-		e->count++;
-		return;
-	ContinueAssoc:;
-	}
-
-	// Evict entry with smallest count.
-	e = &b->entry[0];
-	for(i=1; i<Assoc; i++)
-		if(b->entry[i].count < e->count)
-			e = &b->entry[i];
-	if(e->count > 0) {
-		if(!evict(p, e)) {
-			// Could not evict entry.  Record lost stack.
-			p->lost++;
-			return;
-		}
-		p->evicts++;
-	}
-	
-	// Reuse the newly evicted entry.
-	e->depth = n;
-	e->count = 1;
-	for(i=0; i<n; i++)
-		e->stack[i] = pc[i];
-}
-
-// evict copies the given entry's data into the log, so that
-// the entry can be reused.  evict is called from add, which
-// is called from the profiling signal handler, so it must not
-// allocate memory or block.  It is safe to call flushLog.
-// evict returns true if the entry was copied to the log,
-// false if there was no room available.
-static bool
-evict(Profile *p, Entry *e)
-{
-	int32 i, d, nslot;
-	uintptr *log, *q;
-	
-	d = e->depth;
-	nslot = d+2;
-	log = p->log[p->toggle];
-	if(p->nlog+nslot > nelem(p->log[0])) {
-		if(!flushlog(p))
-			return false;
-		log = p->log[p->toggle];
-	}
-	
-	q = log+p->nlog;
-	*q++ = e->count;
-	*q++ = d;
-	for(i=0; i<d; i++)
-		*q++ = e->stack[i];
-	p->nlog = q - log;
-	e->count = 0;
-	return true;
-}
-
-// flushlog tries to flush the current log and switch to the other one.
-// flushlog is called from evict, called from add, called from the signal handler,
-// so it cannot allocate memory or block.  It can try to swap logs with
-// the writing goroutine, as explained in the comment at the top of this file.
-static bool
-flushlog(Profile *p)
-{
-	uintptr *log, *q;
-
-	if(!runtime·cas(&p->handoff, 0, p->nlog))
-		return false;
-	runtime·notewakeup(&p->wait);
-
-	p->toggle = 1 - p->toggle;
-	log = p->log[p->toggle];
-	q = log;
-	if(p->lost > 0) {
-		*q++ = p->lost;
-		*q++ = 1;
-		*q++ = (uintptr)LostProfileData;
-		p->lost = 0;
-	}
-	p->nlog = q - log;
-	return true;
-}
-
-// getprofile blocks until the next block of profiling data is available
-// and returns it as a []byte.  It is called from the writing goroutine.
-static Slice
-getprofile(Profile *p)
-{
-	uint32 i, j, n;
-	Slice ret;
-	Bucket *b;
-	Entry *e;
-
-	ret.array = nil;
-	ret.len = 0;
-	ret.cap = 0;
-	
-	if(p == nil)	
-		return ret;
-
-	if(p->wholding) {
-		// Release previous log to signal handling side.
-		// Loop because we are racing against SetCPUProfileRate(0).
-		for(;;) {
-			n = p->handoff;
-			if(n == 0) {
-				runtime·printf("runtime: phase error during cpu profile handoff\n");
-				return ret;
-			}
-			if(n & 0x80000000) {
-				p->wtoggle = 1 - p->wtoggle;
-				p->wholding = false;
-				p->flushing = true;
-				goto flush;
-			}
-			if(runtime·cas(&p->handoff, n, 0))
-				break;
-		}
-		p->wtoggle = 1 - p->wtoggle;
-		p->wholding = false;
-	}
-	
-	if(p->flushing)
-		goto flush;
-	
-	if(!p->on && p->handoff == 0)
-		return ret;
-
-	// Wait for new log.
-	runtime·notetsleepg(&p->wait, -1);
-	runtime·noteclear(&p->wait);
-
-	n = p->handoff;
-	if(n == 0) {
-		runtime·printf("runtime: phase error during cpu profile wait\n");
-		return ret;
-	}
-	if(n == 0x80000000) {
-		p->flushing = true;
-		goto flush;
-	}
-	n &= ~0x80000000;
-
-	// Return new log to caller.
-	p->wholding = true;
-
-	ret.array = (byte*)p->log[p->wtoggle];
-	ret.len = n*sizeof(uintptr);
-	ret.cap = ret.len;
-	return ret;
-
-flush:
-	// In flush mode.
-	// Add is no longer being called.  We own the log.
-	// Also, p->handoff is non-zero, so flushlog will return false.
-	// Evict the hash table into the log and return it.
-	for(i=0; i<HashSize; i++) {
-		b = &p->hash[i];
-		for(j=0; j<Assoc; j++) {
-			e = &b->entry[j];
-			if(e->count > 0 && !evict(p, e)) {
-				// Filled the log.  Stop the loop and return what we've got.
-				goto breakflush;
-			}
-		}
-	}
-breakflush:
-
-	// Return pending log data.
-	if(p->nlog > 0) {
-		// Note that we're using toggle now, not wtoggle,
-		// because we're working on the log directly.
-		ret.array = (byte*)p->log[p->toggle];
-		ret.len = p->nlog*sizeof(uintptr);
-		ret.cap = ret.len;
-		p->nlog = 0;
-		return ret;
-	}
-
-	// Made it through the table without finding anything to log.
-	if(!p->eod_sent) {
-		// We may not have space to append this to the partial log buf,
-		// so we always return a new slice for the end-of-data marker.
-		p->eod_sent = true;
-		ret.array = (byte*)eod;
-		ret.len = sizeof eod;
-		ret.cap = ret.len;
-		return ret;
-	}
-
-	// Finally done.  Clean up and return nil.
-	p->flushing = false;
-	if(!runtime·cas(&p->handoff, p->handoff, 0))
-		runtime·printf("runtime: profile flush racing with something\n");
-	return ret;  // set to nil at top of function
-}
-
-// CPUProfile returns the next cpu profile block as a []byte.
-// The user documentation is in debug.go.
-func CPUProfile() (ret Slice) {
-	ret = getprofile(prof);
-}
diff --git a/src/pkg/runtime/debug.go b/src/pkg/runtime/debug.go
index 9ccbaedc84..ed11fb1b1a 100644
--- a/src/pkg/runtime/debug.go
+++ b/src/pkg/runtime/debug.go
@@ -49,22 +49,3 @@ func NumGoroutine() int {
 }
 
 func gcount() int32
-
-// CPUProfile returns the next chunk of binary CPU profiling stack trace data,
-// blocking until data is available.  If profiling is turned off and all the profile
-// data accumulated while it was on has been returned, CPUProfile returns nil.
-// The caller must save the returned data before calling CPUProfile again.
-//
-// Most clients should use the runtime/pprof package or
-// the testing package's -test.cpuprofile flag instead of calling
-// CPUProfile directly.
-func CPUProfile() []byte
-
-// SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
-// If hz <= 0, SetCPUProfileRate turns off profiling.
-// If the profiler is on, the rate cannot be changed without first turning it off.
-//
-// Most clients should use the runtime/pprof package or
-// the testing package's -test.cpuprofile flag instead of calling
-// SetCPUProfileRate directly.
-func SetCPUProfileRate(hz int)
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 1a82c8e541..d1ebd853bb 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2395,13 +2395,13 @@ runtime·badreflectcall(void) // called from assembly
 
 static struct {
 	Mutex lock;
-	void (*fn)(uintptr*, int32);
 	int32 hz;
 } prof;
 
 static void System(void) {}
 static void ExternalCode(void) {}
 static void GC(void) {}
+extern void runtime·cpuproftick(uintptr*, int32);
 extern byte runtime·etext[];
 
 // Called if we receive a SIGPROF signal.
@@ -2418,7 +2418,7 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 	m = 0;
 	USED(m);
 
-	if(prof.fn == nil || prof.hz == 0)
+	if(prof.hz == 0)
 		return;
 
 	// Profiling runs concurrently with GC, so it must not allocate.
@@ -2537,10 +2537,10 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 		}
 	}
 
-	if(prof.fn != nil) {
+	if(prof.hz != 0) {
 		runtime·lock(&prof.lock);
-		if(prof.fn != nil)
-			prof.fn(stk, n);
+		if(prof.hz != 0)
+			runtime·cpuproftick(stk, n);
 		runtime·unlock(&prof.lock);
 	}
 	mp->mallocing--;
@@ -2548,15 +2548,11 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 
 // Arrange to call fn with a traceback hz times a second.
 void
-runtime·setcpuprofilerate(void (*fn)(uintptr*, int32), int32 hz)
+runtime·setcpuprofilerate(int32 hz)
 {
 	// Force sane arguments.
 	if(hz < 0)
 		hz = 0;
-	if(hz == 0)
-		fn = nil;
-	if(fn == nil)
-		hz = 0;
 
 	// Disable preemption, otherwise we can be rescheduled to another thread
 	// that has profiling enabled.
@@ -2568,7 +2564,6 @@ runtime·setcpuprofilerate(void (*fn)(uintptr*, int32), int32 hz)
 	runtime·resetcpuprofiler(0);
 
 	runtime·lock(&prof.lock);
-	prof.fn = fn;
 	prof.hz = hz;
 	runtime·unlock(&prof.lock);
 	runtime·lock(&runtime·sched.lock);
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 6b909599ba..25303512b2 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -864,7 +864,7 @@ void	runtime·freezetheworld(void);
 void	runtime·unwindstack(G*, byte*);
 void	runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp);
 void	runtime·resetcpuprofiler(int32);
-void	runtime·setcpuprofilerate(void(*)(uintptr*, int32), int32);
+void	runtime·setcpuprofilerate(int32);
 void	runtime·usleep(uint32);
 int64	runtime·cputicks(void);
 int64	runtime·tickspersecond(void);

From 60447c2d951fbaf5fcd16a773d11905abae9478f Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Tue, 2 Sep 2014 20:03:48 +0400
Subject: [PATCH 333/423] runtime: convert clearpools/registerPoolCleanup to Go

LGTM=bradfitz, rsc
R=golang-codereviews, bradfitz, rsc
CC=golang-codereviews, khr
https://golang.org/cl/133240043
---
 src/pkg/runtime/mgc0.c   | 33 ---------------------------------
 src/pkg/runtime/mgc0.go  | 29 +++++++++++++++++++++++++++++
 src/pkg/runtime/stubs.go |  1 -
 src/pkg/runtime/thunk.s  |  3 +++
 4 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 0aacbcebaf..4d75ed5a2e 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -82,39 +82,6 @@ enum {
 // Initialized from $GOGC.  GOGC=off means no gc.
 extern int32 runtime·gcpercent;
 
-static FuncVal* poolcleanup;
-
-void
-sync·runtime_registerPoolCleanup(FuncVal *f)
-{
-	poolcleanup = f;
-}
-
-void
-runtime·clearpools(void)
-{
-	P *p, **pp;
-	MCache *c;
-	int32 i;
-
-	// clear sync.Pool's
-	if(poolcleanup != nil)
-		reflect·call(poolcleanup, nil, 0, 0);
-
-	for(pp=runtime·allp; p=*pp; pp++) {
-		// clear tinyalloc pool
-		c = p->mcache;
-		if(c != nil) {
-			c->tiny = nil;
-			c->tinysize = 0;
-			c->sudogcache = nil;
-		}
-		// clear defer pools
-		for(i=0; i<nelem(p->deferpool); i++)
-			p->deferpool[i] = nil;
-	}
-}
-
 // Holding worldsema grants an M the right to try to stop the world.
 // The procedure is:
 //
diff --git a/src/pkg/runtime/mgc0.go b/src/pkg/runtime/mgc0.go
index 275c7ed676..93af63e63e 100644
--- a/src/pkg/runtime/mgc0.go
+++ b/src/pkg/runtime/mgc0.go
@@ -39,3 +39,32 @@ func freeOSMemory() {
 	gogc(2) // force GC and do eager sweep
 	onM(&scavenge_m)
 }
+
+var poolcleanup func()
+
+func registerPoolCleanup(f func()) {
+	poolcleanup = f
+}
+
+func clearpools() {
+	// clear sync.Pools
+	if poolcleanup != nil {
+		poolcleanup()
+	}
+
+	for _, p := range &allp {
+		if p == nil {
+			break
+		}
+		// clear tinyalloc pool
+		if c := p.mcache; c != nil {
+			c.tiny = nil
+			c.tinysize = 0
+			c.sudogcache = nil
+		}
+		// clear defer pools
+		for i := range p.deferpool {
+			p.deferpool[i] = nil
+		}
+	}
+}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 2e5c0481ab..e057eb0659 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -110,7 +110,6 @@ const (
 func gosched()
 func starttheworld()
 func stoptheworld()
-func clearpools()
 
 // exported value for testing
 var hashLoad = loadFactor
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 75e52c81c1..57943ea997 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -38,6 +38,9 @@ TEXT sync·runtime_Semacquire(SB),NOSPLIT,$0-0
 TEXT sync·runtime_Semrelease(SB),NOSPLIT,$0-0
 	JMP	runtime·asyncsemrelease(SB)
 
+TEXT sync·runtime_registerPoolCleanup(SB),NOSPLIT,$0-0
+	JMP	runtime·registerPoolCleanup(SB)
+
 TEXT net·runtime_Semacquire(SB),NOSPLIT,$0-0
 	JMP	runtime·asyncsemacquire(SB)
 

From 90e2e2b89633770d42f2ff558588dfc53c3288c8 Mon Sep 17 00:00:00 2001
From: Marko Tiikkaja <marko@joh.to>
Date: Tue, 2 Sep 2014 09:08:41 -0700
Subject: [PATCH 334/423] database/sql: Avoid re-preparing statements when all
 connections are busy

Previously, if all connections were busy, we would always
re-prepare the statement on the connection we were assigned from
the pool.  That meant that if all connections were busy most of the
time, the number of prepared statements for each connection would
keep increasing over time.

Instead, after getting a free connection, check to see if the
statement has already been prepared on it, and reuse the statement
handle if so.

LGTM=bradfitz
R=golang-codereviews, gobot, bradfitz
CC=golang-codereviews
https://golang.org/cl/116930043
---
 src/pkg/database/sql/sql.go      | 60 +++++++++++++++++++-------------
 src/pkg/database/sql/sql_test.go | 13 +++----
 2 files changed, 42 insertions(+), 31 deletions(-)

diff --git a/src/pkg/database/sql/sql.go b/src/pkg/database/sql/sql.go
index 63c6dd6816..90f813d823 100644
--- a/src/pkg/database/sql/sql.go
+++ b/src/pkg/database/sql/sql.go
@@ -1326,15 +1326,12 @@ func (s *Stmt) connStmt() (ci *driverConn, releaseConn func(error), si driver.St
 		return ci, releaseConn, s.txsi.si, nil
 	}
 
-	var cs connStmt
-	match := false
 	for i := 0; i < len(s.css); i++ {
 		v := s.css[i]
 		_, err := s.db.connIfFree(v.dc)
 		if err == nil {
-			match = true
-			cs = v
-			break
+			s.mu.Unlock()
+			return v.dc, v.dc.releaseConn, v.si, nil
 		}
 		if err == errConnClosed {
 			// Lazily remove dead conn from our freelist.
@@ -1346,28 +1343,41 @@ func (s *Stmt) connStmt() (ci *driverConn, releaseConn func(error), si driver.St
 	}
 	s.mu.Unlock()
 
-	// Make a new conn if all are busy.
-	// TODO(bradfitz): or wait for one? make configurable later?
-	if !match {
-		dc, err := s.db.conn()
-		if err != nil {
-			return nil, nil, nil, err
-		}
-		dc.Lock()
-		si, err := dc.prepareLocked(s.query)
-		dc.Unlock()
-		if err != nil {
-			s.db.putConn(dc, err)
-			return nil, nil, nil, err
-		}
-		s.mu.Lock()
-		cs = connStmt{dc, si}
-		s.css = append(s.css, cs)
-		s.mu.Unlock()
+	// If all connections are busy, either wait for one to become available (if
+	// we've already hit the maximum number of open connections) or create a
+	// new one.
+	//
+	// TODO(bradfitz): or always wait for one? make configurable later?
+	dc, err := s.db.conn()
+	if err != nil {
+		return nil, nil, nil, err
 	}
 
-	conn := cs.dc
-	return conn, conn.releaseConn, cs.si, nil
+	// Do another pass over the list to see whether this statement has
+	// already been prepared on the connection assigned to us.
+	s.mu.Lock()
+	for _, v := range s.css {
+		if v.dc == dc {
+			s.mu.Unlock()
+			return dc, dc.releaseConn, v.si, nil
+		}
+	}
+	s.mu.Unlock()
+
+	// No luck; we need to prepare the statement on this connection
+	dc.Lock()
+	si, err = dc.prepareLocked(s.query)
+	dc.Unlock()
+	if err != nil {
+		s.db.putConn(dc, err)
+		return nil, nil, nil, err
+	}
+	s.mu.Lock()
+	cs := connStmt{dc, si}
+	s.css = append(s.css, cs)
+	s.mu.Unlock()
+
+	return dc, dc.releaseConn, si, nil
 }
 
 // Query executes a prepared query statement with the given arguments
diff --git a/src/pkg/database/sql/sql_test.go b/src/pkg/database/sql/sql_test.go
index 8849c81c4b..12e5a6fd6f 100644
--- a/src/pkg/database/sql/sql_test.go
+++ b/src/pkg/database/sql/sql_test.go
@@ -1348,6 +1348,11 @@ func TestErrBadConnReconnect(t *testing.T) {
 		return nil
 	})
 
+	// Provide a way to force a re-prepare of a statement on next execution
+	forcePrepare := func(stmt *Stmt) {
+		stmt.css = nil
+	}
+
 	// stmt.Exec
 	stmt1, err := db.Prepare("INSERT|t1|name=?,age=?,dead=?")
 	if err != nil {
@@ -1355,9 +1360,7 @@ func TestErrBadConnReconnect(t *testing.T) {
 	}
 	defer stmt1.Close()
 	// make sure we must prepare the stmt first
-	for _, cs := range stmt1.css {
-		cs.dc.inUse = true
-	}
+	forcePrepare(stmt1)
 
 	stmtExec := func() error {
 		_, err := stmt1.Exec("Gopher", 3, false)
@@ -1373,9 +1376,7 @@ func TestErrBadConnReconnect(t *testing.T) {
 	}
 	defer stmt2.Close()
 	// make sure we must prepare the stmt first
-	for _, cs := range stmt2.css {
-		cs.dc.inUse = true
-	}
+	forcePrepare(stmt2)
 
 	stmtQuery := func() error {
 		rows, err := stmt2.Query()

From 6baf173b6738cb38089bff4bc836b3f54076b32f Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 2 Sep 2014 10:07:02 -0700
Subject: [PATCH 335/423] runtime: move reflect trampolines into thunk file.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/133460043
---
 src/pkg/reflect/asm_386.s      | 29 -------------------------
 src/pkg/reflect/asm_amd64.s    | 29 -------------------------
 src/pkg/reflect/asm_amd64p32.s | 29 -------------------------
 src/pkg/reflect/asm_arm.s      | 29 -------------------------
 src/pkg/runtime/thunk.s        | 39 ++++++++++++++++++++++++++++++++++
 5 files changed, 39 insertions(+), 116 deletions(-)

diff --git a/src/pkg/reflect/asm_386.s b/src/pkg/reflect/asm_386.s
index 933908f206..c028113a0c 100644
--- a/src/pkg/reflect/asm_386.s
+++ b/src/pkg/reflect/asm_386.s
@@ -25,32 +25,3 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$8
 	MOVL	CX, 4(SP)
 	CALL	·callMethod(SB)
 	RET
-
-// Stubs to give reflect package access to runtime services
-// TODO: should probably be done another way.
-TEXT ·makemap(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_makemap(SB)
-TEXT ·mapaccess(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapaccess(SB)
-TEXT ·mapassign(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapassign(SB)
-TEXT ·mapdelete(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapdelete(SB)
-TEXT ·mapiterinit(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiterinit(SB)
-TEXT ·mapiterkey(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiterkey(SB)
-TEXT ·mapiternext(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiternext(SB)
-TEXT ·maplen(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_maplen(SB)
-TEXT ·ismapkey(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_ismapkey(SB)
-TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_ifaceE2I(SB)
-TEXT ·unsafe_New(SB),NOSPLIT,$0-0
-	JMP	runtime·newobject(SB)
-TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
-	JMP	runtime·newarray(SB)
-TEXT ·makechan(SB),NOSPLIT,$0-0
-	JMP	runtime·makechan(SB)
diff --git a/src/pkg/reflect/asm_amd64.s b/src/pkg/reflect/asm_amd64.s
index 85de6ea827..b3c54f0482 100644
--- a/src/pkg/reflect/asm_amd64.s
+++ b/src/pkg/reflect/asm_amd64.s
@@ -25,32 +25,3 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$16
 	MOVQ	CX, 8(SP)
 	CALL	·callMethod(SB)
 	RET
-
-// Stubs to give reflect package access to runtime services
-// TODO: should probably be done another way.
-TEXT ·makemap(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_makemap(SB)
-TEXT ·mapaccess(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapaccess(SB)
-TEXT ·mapassign(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapassign(SB)
-TEXT ·mapdelete(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapdelete(SB)
-TEXT ·mapiterinit(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiterinit(SB)
-TEXT ·mapiterkey(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiterkey(SB)
-TEXT ·mapiternext(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiternext(SB)
-TEXT ·maplen(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_maplen(SB)
-TEXT ·ismapkey(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_ismapkey(SB)
-TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_ifaceE2I(SB)
-TEXT ·unsafe_New(SB),NOSPLIT,$0-0
-	JMP	runtime·newobject(SB)
-TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
-	JMP	runtime·newarray(SB)
-TEXT ·makechan(SB),NOSPLIT,$0-0
-	JMP	runtime·makechan(SB)
diff --git a/src/pkg/reflect/asm_amd64p32.s b/src/pkg/reflect/asm_amd64p32.s
index 933908f206..c028113a0c 100644
--- a/src/pkg/reflect/asm_amd64p32.s
+++ b/src/pkg/reflect/asm_amd64p32.s
@@ -25,32 +25,3 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$8
 	MOVL	CX, 4(SP)
 	CALL	·callMethod(SB)
 	RET
-
-// Stubs to give reflect package access to runtime services
-// TODO: should probably be done another way.
-TEXT ·makemap(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_makemap(SB)
-TEXT ·mapaccess(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapaccess(SB)
-TEXT ·mapassign(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapassign(SB)
-TEXT ·mapdelete(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapdelete(SB)
-TEXT ·mapiterinit(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiterinit(SB)
-TEXT ·mapiterkey(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiterkey(SB)
-TEXT ·mapiternext(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_mapiternext(SB)
-TEXT ·maplen(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_maplen(SB)
-TEXT ·ismapkey(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_ismapkey(SB)
-TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
-	JMP	runtime·reflect_ifaceE2I(SB)
-TEXT ·unsafe_New(SB),NOSPLIT,$0-0
-	JMP	runtime·newobject(SB)
-TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
-	JMP	runtime·newarray(SB)
-TEXT ·makechan(SB),NOSPLIT,$0-0
-	JMP	runtime·makechan(SB)
diff --git a/src/pkg/reflect/asm_arm.s b/src/pkg/reflect/asm_arm.s
index e621b169b1..6bd5d48ec9 100644
--- a/src/pkg/reflect/asm_arm.s
+++ b/src/pkg/reflect/asm_arm.s
@@ -25,32 +25,3 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$8
 	MOVW	R1, 8(R13)
 	BL	·callMethod(SB)
 	RET
-
-// Stubs to give reflect package access to runtime services
-// TODO: should probably be done another way.
-TEXT ·makemap(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_makemap(SB)
-TEXT ·mapaccess(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_mapaccess(SB)
-TEXT ·mapassign(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_mapassign(SB)
-TEXT ·mapdelete(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_mapdelete(SB)
-TEXT ·mapiterinit(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_mapiterinit(SB)
-TEXT ·mapiterkey(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_mapiterkey(SB)
-TEXT ·mapiternext(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_mapiternext(SB)
-TEXT ·maplen(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_maplen(SB)
-TEXT ·ismapkey(SB),NOSPLIT,$-4-0
-	B	runtime·reflect_ismapkey(SB)
-TEXT ·ifaceE2I(SB),NOSPLIT,$0-0
-	B	runtime·reflect_ifaceE2I(SB)
-TEXT ·unsafe_New(SB),NOSPLIT,$0-0
-	B	runtime·newobject(SB)
-TEXT ·unsafe_NewArray(SB),NOSPLIT,$0-0
-	B	runtime·newarray(SB)
-TEXT ·makechan(SB),NOSPLIT,$0-0
-	B	runtime·makechan(SB)
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 57943ea997..eaba5e1489 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -76,3 +76,42 @@ TEXT runtime∕debug·freeOSMemory(SB), NOSPLIT, $0-0
 
 TEXT syscall·setenv_c(SB), NOSPLIT, $0-0
 	JMP	runtime·syscall_setenv_c(SB)
+
+TEXT reflect·makemap(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_makemap(SB)
+
+TEXT reflect·mapaccess(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_mapaccess(SB)
+
+TEXT reflect·mapassign(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_mapassign(SB)
+
+TEXT reflect·mapdelete(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_mapdelete(SB)
+
+TEXT reflect·mapiterinit(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_mapiterinit(SB)
+
+TEXT reflect·mapiterkey(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_mapiterkey(SB)
+
+TEXT reflect·mapiternext(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_mapiternext(SB)
+
+TEXT reflect·maplen(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_maplen(SB)
+
+TEXT reflect·ismapkey(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_ismapkey(SB)
+
+TEXT reflect·ifaceE2I(SB),NOSPLIT,$0-0
+	JMP	runtime·reflect_ifaceE2I(SB)
+
+TEXT reflect·unsafe_New(SB),NOSPLIT,$0-0
+	JMP	runtime·newobject(SB)
+
+TEXT reflect·unsafe_NewArray(SB),NOSPLIT,$0-0
+	JMP	runtime·newarray(SB)
+
+TEXT reflect·makechan(SB),NOSPLIT,$0-0
+	JMP	runtime·makechan(SB)

From 8e89f87158eb364330e4334d7084e290e07c66a8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 2 Sep 2014 14:36:25 -0400
Subject: [PATCH 336/423] cmd/gc: fix runtime print(hex(x))

The code I wrote originally works for trivial functions
that are inlined at a call site in another package,
because that was how I wrote my local test.
Make hex(x) work for non-inlinable functions too.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews, r
https://golang.org/cl/140830043
---
 src/cmd/gc/walk.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index 26d8011240..30c139200b 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -1838,7 +1838,7 @@ walkprint(Node *nn, NodeList **init, int defer)
 				}
 			} else {
 				if(et == TUINT64) {
-					if(t->sym->pkg == runtimepkg && strcmp(t->sym->name, "hex") == 0)
+					if((t->sym->pkg == runtimepkg || compiling_runtime) && strcmp(t->sym->name, "hex") == 0)
 						on = syslook("printhex", 0);
 					else
 						on = syslook("printuint", 0);

From fa2af441f1d7f2daccf40e1e350e8a8bfdcfb9e8 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 2 Sep 2014 15:12:53 -0400
Subject: [PATCH 337/423] runtime: convert traceback*.c to Go

The two converted files were nearly identical.
Instead of continuing that duplication, I merged them
into a single traceback.go.

Tested on arm, amd64, amd64p32, and 386.

LGTM=r
R=golang-codereviews, remyoudompheng, dave, r
CC=dvyukov, golang-codereviews, iant, khr
https://golang.org/cl/134200044
---
 src/cmd/api/goapi.go                 |  31 +-
 src/pkg/runtime/extern.go            |  24 +-
 src/pkg/runtime/heapdump.c           |   4 +-
 src/pkg/runtime/mgc0.c               |   8 +-
 src/pkg/runtime/mprof.go             |  10 +-
 src/pkg/runtime/os_windows_386.go    |  11 +
 src/pkg/runtime/os_windows_amd64.go  |  11 +
 src/pkg/runtime/runtime.h            |   8 +-
 src/pkg/runtime/stack.c              |  12 +-
 src/pkg/runtime/stubs.go             |  20 +-
 src/pkg/runtime/traceback.go         | 504 +++++++++++++++++++++++++++
 src/pkg/runtime/traceback_arm.c      | 363 -------------------
 src/pkg/runtime/traceback_windows.go |  64 ++++
 src/pkg/runtime/traceback_x86.c      | 436 -----------------------
 14 files changed, 668 insertions(+), 838 deletions(-)
 create mode 100644 src/pkg/runtime/os_windows_386.go
 create mode 100644 src/pkg/runtime/os_windows_amd64.go
 create mode 100644 src/pkg/runtime/traceback.go
 delete mode 100644 src/pkg/runtime/traceback_arm.c
 create mode 100644 src/pkg/runtime/traceback_windows.go
 delete mode 100644 src/pkg/runtime/traceback_x86.c

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 99d41c9d69..715e9f6ad8 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -379,13 +379,30 @@ 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.
 		src := "package runtime; type (" +
-			" maptype struct{}; _type struct{}; alg struct{};" +
-			" mspan struct{}; m struct{}; mutex struct{}; slicetype struct{};" +
-			" iface struct{}; eface struct{}; interfacetype struct{}; itab struct{};" +
-			" mcache struct{}; sudog struct{}; g struct{};" +
-			" hchan struct{}; chantype struct{}; waitq struct{};" +
-			" note struct{}; wincallbackcontext struct{};" +
-			" gobuf struct{}; funcval struct{}; _func struct{};" +
+			" _func struct{};" +
+			" _type struct{};" +
+			" alg struct{};" +
+			" chantype struct{};" +
+			" context struct{};" + // windows
+			" eface struct{};" +
+			" funcval struct{};" +
+			" g struct{};" +
+			" gobuf struct{};" +
+			" hchan struct{};" +
+			" iface struct{};" +
+			" interfacetype struct{};" +
+			" itab struct{};" +
+			" m struct{};" +
+			" maptype struct{};" +
+			" mcache struct{};" +
+			" mspan struct{};" +
+			" mutex struct{};" +
+			" note struct{};" +
+			" slicetype struct{};" +
+			" stkframe struct{};" +
+			" sudog struct{};" +
+			" waitq struct{};" +
+			" wincallbackcontext struct{};" +
 			"); " +
 			"const ( cb_max = 2000 )"
 		f, err = parser.ParseFile(fset, filename, src, 0)
diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index f276a3839d..d75d2b4e54 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -86,11 +86,9 @@ import "unsafe"
 // If all other goroutines exit, the program crashes.
 func Goexit()
 
-// We assume that all architectures turn faults and the like
-// into apparent calls to runtime.sigpanic.  If we see a "call"
-// to runtime.sigpanic, we do not back up the PC to find the
-// line number of the CALL instruction, because there is no CALL.
-var sigpanic byte
+// sigpanic is the C function sigpanic.
+// That is, unsafe.Pointer(&sigpanic) is the C function pointer for sigpanic.
+var sigpanic struct{}
 
 // Caller reports file and line number information about function invocations on
 // the calling goroutine's stack.  The argument skip is the number of stack frames
@@ -103,7 +101,7 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
 	// and what it called, so that we can see if it
 	// "called" sigpanic.
 	var rpc [2]uintptr
-	if callers(int32(1+skip-1), &rpc[0], 2) < 2 {
+	if callers(1+skip-1, &rpc[0], 2) < 2 {
 		return
 	}
 	f := findfunc(rpc[1])
@@ -117,6 +115,9 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
 	pc = rpc[1]
 	xpc := pc
 	g := findfunc(rpc[0])
+	// All architectures turn faults into apparent calls to sigpanic.
+	// If we see a call to sigpanic, we do not back up the PC to find
+	// the line number of the call instruction, because there is no call.
 	if xpc > f.entry && (g == nil || g.entry != uintptr(unsafe.Pointer(&sigpanic))) {
 		xpc--
 	}
@@ -142,18 +143,9 @@ func Callers(skip int, pc []uintptr) int {
 	if len(pc) == 0 {
 		return 0
 	}
-	return int(callers(int32(skip), &pc[0], int32(len(pc))))
+	return callers(skip, &pc[0], len(pc))
 }
 
-//go:noescape
-func callers(int32, *uintptr, int32) int32
-
-//go:noescape
-func gcallers(*g, int32, *uintptr, int32) int32
-
-//go:noescape
-func gentraceback(uintptr, uintptr, uintptr, *g, int32, *uintptr, int32, unsafe.Pointer, unsafe.Pointer, bool) int32
-
 func getgoroot() string
 
 // GOROOT returns the root of the Go tree.
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 3d0a23049d..63ffe68066 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -380,6 +380,7 @@ dumpgoroutine(G *gp)
 	ChildInfo child;
 	Defer *d;
 	Panic *p;
+	bool (*fn)(Stkframe*, void*);
 
 	if(gp->syscallstack != (uintptr)nil) {
 		sp = gp->syscallsp;
@@ -413,7 +414,8 @@ dumpgoroutine(G *gp)
 	child.depth = 0;
 	if(!ScanStackByFrames)
 		runtime·throw("need frame info to dump stacks");
-	runtime·gentraceback(pc, sp, lr, gp, 0, nil, 0x7fffffff, dumpframe, &child, false);
+	fn = dumpframe;
+	runtime·gentraceback(pc, sp, lr, gp, 0, nil, 0x7fffffff, &fn, &child, false);
 
 	// dump defer & panic records
 	for(d = gp->defer; d != nil; d = d->link) {
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 4d75ed5a2e..3e22acc524 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -685,6 +685,7 @@ scanstack(G *gp)
 	int32 n;
 	Stktop *stk;
 	uintptr sp, guard;
+	bool (*fn)(Stkframe*, void*);
 
 	switch(runtime·readgstatus(gp)) {
 	default:
@@ -726,7 +727,8 @@ scanstack(G *gp)
 		USED(sp);
 		USED(stk);
 		USED(guard);
-		runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, scanframe, nil, false);
+		fn = scanframe;
+		runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, &fn, nil, false);
 	} else {
 		n = 0;
 		while(stk) {
@@ -1779,6 +1781,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 	Stkframe frame;
 	uintptr i, n, off;
 	byte *base, bits, shift, *b;
+	bool (*cb)(Stkframe*, void*);
 
 	*mask = nil;
 	*len = 0;
@@ -1823,7 +1826,8 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 	// stack
 	frame.fn = nil;
 	frame.sp = (uintptr)p;
-	runtime·gentraceback((uintptr)runtime·getcallerpc(&p), (uintptr)runtime·getcallersp(&p), 0, g, 0, nil, 1000, getgcmaskcb, &frame, false);
+	cb = getgcmaskcb;
+	runtime·gentraceback((uintptr)runtime·getcallerpc(&p), (uintptr)runtime·getcallersp(&p), 0, g, 0, nil, 1000, &cb, &frame, false);
 	if(frame.fn != nil) {
 		Func *f;
 		StackMap *stackmap;
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index 1734fd8470..b421c4f98f 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -234,7 +234,7 @@ func mProf_GC() {
 // Called by malloc to record a profiled block.
 func mProf_Malloc(p unsafe.Pointer, size uintptr) {
 	var stk [maxStack]uintptr
-	nstk := callers(1, &stk[0], int32(len(stk)))
+	nstk := callers(1, &stk[0], len(stk))
 	lock(&proflock)
 	b := stkbucket(memProfile, size, stk[:nstk], true)
 	mp := b.mp()
@@ -304,9 +304,9 @@ func blockevent(cycles int64, skip int) {
 	var nstk int
 	var stk [maxStack]uintptr
 	if gp.m.curg == nil || gp.m.curg == gp {
-		nstk = int(callers(int32(skip), &stk[0], int32(len(stk))))
+		nstk = callers(skip, &stk[0], len(stk))
 	} else {
-		nstk = int(gcallers(gp.m.curg, int32(skip), &stk[0], int32(len(stk))))
+		nstk = gcallers(gp.m.curg, skip, &stk[0], len(stk))
 	}
 	lock(&proflock)
 	b := stkbucket(blockProfile, 0, stk[:nstk], true)
@@ -557,8 +557,8 @@ func GoroutineProfile(p []StackRecord) (n int, ok bool) {
 }
 
 func saveg(pc, sp uintptr, gp *g, r *StackRecord) {
-	n := gentraceback(pc, sp, 0, gp, 0, &r.Stack0[0], int32(len(r.Stack0)), nil, nil, false)
-	if int(n) < len(r.Stack0) {
+	n := gentraceback(pc, sp, 0, gp, 0, &r.Stack0[0], len(r.Stack0), nil, nil, false)
+	if n < len(r.Stack0) {
 		r.Stack0[n] = 0
 	}
 }
diff --git a/src/pkg/runtime/os_windows_386.go b/src/pkg/runtime/os_windows_386.go
new file mode 100644
index 0000000000..86a1906c0c
--- /dev/null
+++ b/src/pkg/runtime/os_windows_386.go
@@ -0,0 +1,11 @@
+// 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 runtime
+
+// contextPC returns the EIP (program counter) register from the context.
+func contextPC(r *context) uintptr { return uintptr(r.eip) }
+
+// contextSP returns the ESP (stack pointer) register from the context.
+func contextSP(r *context) uintptr { return uintptr(r.esp) }
diff --git a/src/pkg/runtime/os_windows_amd64.go b/src/pkg/runtime/os_windows_amd64.go
new file mode 100644
index 0000000000..3f4d4d07cb
--- /dev/null
+++ b/src/pkg/runtime/os_windows_amd64.go
@@ -0,0 +1,11 @@
+// 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 runtime
+
+// contextPC returns the RIP (program counter) register from the context.
+func contextPC(r *context) uintptr { return uintptr(r.rip) }
+
+// contextSP returns the RSP (stack pointer) register from the context.
+func contextSP(r *context) uintptr { return uintptr(r.rsp) }
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 25303512b2..f1b3ee83f3 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -666,7 +666,7 @@ struct Stkframe
 	uintptr	arglen;	// number of bytes at argp
 };
 
-int32	runtime·gentraceback(uintptr, uintptr, uintptr, G*, int32, uintptr*, int32, bool(*)(Stkframe*, void*), void*, bool);
+intgo	runtime·gentraceback(uintptr, uintptr, uintptr, G*, intgo, uintptr*, intgo, bool(**)(Stkframe*, void*), void*, bool);
 void	runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G* gp);
 void	runtime·tracebackothers(G*);
 bool	runtime·haszeroargs(uintptr pc);
@@ -854,8 +854,8 @@ void	runtime·exitsyscall(void);
 void	runtime·entersyscallblock_m(void);
 G*	runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
 bool	runtime·sigsend(int32 sig);
-int32	runtime·callers(int32, uintptr*, int32);
-int32	runtime·gcallers(G*, int32, uintptr*, int32);
+intgo	runtime·callers(intgo, uintptr*, intgo);
+intgo	runtime·gcallers(G*, intgo, uintptr*, intgo);
 int64	runtime·nanotime(void);	// monotonic time
 int64	runtime·unixnanotime(void); // real time, can skip
 void	runtime·dopanic(int32);
@@ -868,7 +868,7 @@ void	runtime·setcpuprofilerate(int32);
 void	runtime·usleep(uint32);
 int64	runtime·cputicks(void);
 int64	runtime·tickspersecond(void);
-void	runtime·blockevent(int64, int32);
+void	runtime·blockevent(int64, intgo);
 G*	runtime·netpoll(bool);
 void	runtime·netpollinit(void);
 int32	runtime·netpollopen(uintptr, PollDesc*);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index e589d8d443..1f51e667f2 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -477,6 +477,7 @@ copyabletopsegment(G *gp)
 	Func *f;
 	FuncVal *fn;
 	StackMap *stackmap;
+	bool (*cb)(Stkframe*, void*);
 
 	if(gp->stackbase == 0)
 		runtime·throw("stackbase == 0");
@@ -486,7 +487,8 @@ copyabletopsegment(G *gp)
 
 	// Check that each frame is copyable.  As a side effect,
 	// count the frames.
-	runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, checkframecopy, &cinfo, false);
+	cb = checkframecopy;
+	runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, &cb, &cinfo, false);
 	if(StackDebug >= 1 && cinfo.frames != -1)
 		runtime·printf("copystack: %d copyable frames\n", cinfo.frames);
 
@@ -680,8 +682,10 @@ adjustframe(Stkframe *frame, void *arg)
 	// adjust inargs and outargs
 	if(frame->arglen != 0) {
 		stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
-		if(stackmap == nil)
+		if(stackmap == nil) {
+			runtime·printf("size %d\n", (int32)frame->arglen);
 			runtime·throw("no arg info");
+		}
 		bv = runtime·stackmapdata(stackmap, pcdata);
 		if(StackDebug >= 3)
 			runtime·printf("      args\n");
@@ -773,6 +777,7 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	AdjustInfo adjinfo;
 	Stktop *oldtop, *newtop;
 	uint32 oldstatus;
+	bool (*cb)(Stkframe*, void*);
 
 	if(gp->syscallstack != 0)
 		runtime·throw("can't handle stack copy in syscall yet");
@@ -797,7 +802,8 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	adjinfo.oldstk = oldstk;
 	adjinfo.oldbase = oldbase;
 	adjinfo.delta = newbase - oldbase;
-	runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, nframes, adjustframe, &adjinfo, false);
+	cb = adjustframe;
+	runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, nframes, &cb, &adjinfo, false);
 	
 	// adjust other miscellaneous things that have pointers into stacks.
 	adjustctxt(gp, &adjinfo);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index e057eb0659..3106a1530e 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -12,6 +12,7 @@ import "unsafe"
 // each function.
 
 const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
+const regSize = 4 << (^uintreg(0) >> 63) // unsafe.Sizeof(uintreg(0)) but an ideal const
 
 //go:noescape
 func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
@@ -141,7 +142,6 @@ func entersyscallblock()
 func exitsyscall()
 
 func goroutineheader(gp *g)
-func traceback(pc, sp, lr uintptr, gp *g)
 func tracebackothers(gp *g)
 
 func cgocallback(fn, frame unsafe.Pointer, framesize uintptr)
@@ -246,3 +246,21 @@ func asmcgocall(fn, arg unsafe.Pointer)
 
 //go:noescape
 func open(name *byte, mode, perm int32) int32
+
+//go:noescape
+func gotraceback(*bool) int32
+
+func funcname(*_func) *byte
+
+func gofuncname(f *_func) string {
+	return gostringnocopy(funcname(f))
+}
+
+const _NoArgs = ^uintptr(0)
+
+var newproc, deferproc, lessstack struct{} // C/assembly functions
+
+func funcspdelta(*_func, uintptr) int32 // symtab.c
+func funcarglen(*_func, uintptr) int32  // symtab.c
+const _ArgsSizeUnknown = -0x80000000    // funcdata.h
+func topofstack(*_func) bool            // proc.c
diff --git a/src/pkg/runtime/traceback.go b/src/pkg/runtime/traceback.go
new file mode 100644
index 0000000000..c6a6c056c1
--- /dev/null
+++ b/src/pkg/runtime/traceback.go
@@ -0,0 +1,504 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+// The code in this file implements stack trace walking for all architectures.
+// The most important fact about a given architecture is whether it uses a link register.
+// On systems with link registers, the prologue for a non-leaf function stores the
+// incoming value of LR at the bottom of the newly allocated stack frame.
+// On systems without link registers, the architecture pushes a return PC during
+// the call instruction, so the return PC ends up above the stack frame.
+// In this file, the return PC is always called LR, no matter how it was found.
+//
+// To date, the opposite of a link register architecture is an x86 architecture.
+// This code may need to change if some other kind of non-link-register
+// architecture comes along.
+//
+// The other important fact is the size of a pointer: on 32-bit systems the LR
+// takes up only 4 bytes on the stack, while on 64-bit systems it takes up 8 bytes.
+// Typically this is ptrSize.
+//
+// As an exception, amd64p32 has ptrSize == 4 but the CALL instruction still
+// stores an 8-byte return PC onto the stack. To accommodate this, we use regSize
+// as the size of the architecture-pushed return PC.
+//
+// usesLR is defined below. ptrSize and regSize are defined in stubs.go.
+
+const usesLR = GOARCH != "amd64" && GOARCH != "amd64p32" && GOARCH != "386"
+
+// jmpdeferPC is the PC at the beginning of the jmpdefer assembly function.
+// The traceback needs to recognize it on link register architectures.
+var jmpdeferPC uintptr
+
+func init() {
+	f := jmpdefer
+	jmpdeferPC = **(**uintptr)(unsafe.Pointer(&f))
+}
+
+// System-specific hook. See traceback_windows.go
+var systraceback func(*_func, *stkframe, *g, bool, func(*stkframe, unsafe.Pointer) bool, unsafe.Pointer) (changed, aborted bool)
+
+// Generic traceback.  Handles runtime stack prints (pcbuf == nil),
+// the runtime.Callers function (pcbuf != nil), as well as the garbage
+// collector (callback != nil).  A little clunky to merge these, but avoids
+// duplicating the code and all its subtlety.
+func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max int, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer, printall bool) int {
+	g := getg()
+	gotraceback := gotraceback(nil)
+	if pc0 == ^uintptr(0) && sp0 == ^uintptr(0) { // Signal to fetch saved values from gp.
+		if gp.syscallstack != 0 {
+			pc0 = gp.syscallpc
+			sp0 = gp.syscallsp
+			if usesLR {
+				lr0 = 0
+			}
+		} else {
+			pc0 = gp.sched.pc
+			sp0 = gp.sched.sp
+			if usesLR {
+				lr0 = gp.sched.lr
+			}
+		}
+	}
+
+	nprint := 0
+	var frame stkframe
+	frame.pc = pc0
+	frame.sp = sp0
+	if usesLR {
+		frame.lr = lr0
+	}
+	waspanic := false
+	wasnewproc := false
+	printing := pcbuf == nil && callback == nil
+	panic := gp._panic
+	_defer := gp._defer
+
+	for _defer != nil && uintptr(_defer.argp) == _NoArgs {
+		_defer = _defer.link
+	}
+	for panic != nil && panic._defer == nil {
+		panic = panic.link
+	}
+
+	// If the PC is zero, it's likely a nil function call.
+	// Start in the caller's frame.
+	if frame.pc == 0 {
+		if usesLR {
+			frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
+			frame.lr = 0
+		} else {
+			frame.pc = uintptr(*(*uintreg)(unsafe.Pointer(frame.sp)))
+			frame.sp += regSize
+		}
+	}
+
+	f := findfunc(frame.pc)
+	if f == nil {
+		if callback != nil {
+			print("runtime: unknown pc ", hex(frame.pc), "\n")
+			gothrow("unknown pc")
+		}
+		return 0
+	}
+	frame.fn = f
+
+	n := 0
+	stk := (*stktop)(unsafe.Pointer(gp.stackbase))
+	for n < max {
+		// Typically:
+		//	pc is the PC of the running function.
+		//	sp is the stack pointer at that program counter.
+		//	fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown.
+		//	stk is the stack containing sp.
+		//	The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp.
+		if frame.pc == uintptr(unsafe.Pointer(&lessstack)) {
+			// Hit top of stack segment.  Unwind to next segment.
+			frame.pc = stk.gobuf.pc
+			frame.sp = stk.gobuf.sp
+			frame.lr = 0
+			frame.fp = 0
+			if printing && showframe(nil, gp) {
+				print("----- stack segment boundary -----\n")
+			}
+			stk = (*stktop)(unsafe.Pointer(stk.stackbase))
+			f = findfunc(frame.pc)
+			if f == nil {
+				print("runtime: unknown pc ", hex(frame.pc), " after stack split\n")
+				if callback != nil {
+					gothrow("unknown pc")
+				}
+			}
+			frame.fn = f
+			continue
+		}
+		f = frame.fn
+
+		// Hook for handling Windows exception handlers. See traceback_windows.go.
+		if systraceback != nil {
+			changed, aborted := systraceback(f, (*stkframe)(noescape(unsafe.Pointer(&frame))), gp, printing, callback, v)
+			if aborted {
+				return n
+			}
+			if changed {
+				continue
+			}
+		}
+
+		// Found an actual function.
+		// Derive frame pointer and link register.
+		if frame.fp == 0 {
+			frame.fp = frame.sp + uintptr(funcspdelta(f, frame.pc))
+			if !usesLR {
+				// On x86, call instruction pushes return PC before entering new function.
+				frame.fp += regSize
+			}
+		}
+		var flr *_func
+		if topofstack(f) {
+			frame.lr = 0
+			flr = nil
+		} else if usesLR && f.entry == jmpdeferPC {
+			// jmpdefer modifies SP/LR/PC non-atomically.
+			// If a profiling interrupt arrives during jmpdefer,
+			// the stack unwind may see a mismatched register set
+			// and get confused. Stop if we see PC within jmpdefer
+			// to avoid that confusion.
+			// See golang.org/issue/8153.
+			if callback != nil {
+				gothrow("traceback_arm: found jmpdefer when tracing with callback")
+			}
+			frame.lr = 0
+		} else {
+			if usesLR {
+				if n == 0 && frame.sp < frame.fp || frame.lr == 0 {
+					frame.lr = *(*uintptr)(unsafe.Pointer(frame.sp))
+				}
+			} else {
+				if frame.lr == 0 {
+					frame.lr = uintptr(*(*uintreg)(unsafe.Pointer(frame.fp - regSize)))
+				}
+			}
+			flr = findfunc(frame.lr)
+			if flr == nil {
+				// This happens if you get a profiling interrupt at just the wrong time.
+				// In that context it is okay to stop early.
+				// But if callback is set, we're doing a garbage collection and must
+				// get everything, so crash loudly.
+				if callback != nil {
+					print("runtime: unexpected return pc for ", gofuncname(f), " called from ", hex(frame.lr), "\n")
+					gothrow("unknown caller pc")
+				}
+			}
+		}
+
+		frame.varp = frame.fp
+		if !usesLR {
+			// On x86, call instruction pushes return PC before entering new function.
+			frame.varp -= regSize
+		}
+
+		// Derive size of arguments.
+		// Most functions have a fixed-size argument block,
+		// so we can use metadata about the function f.
+		// Not all, though: there are some variadic functions
+		// in package runtime and reflect, and for those we use call-specific
+		// metadata recorded by f's caller.
+		if callback != nil || printing {
+			frame.argp = frame.fp
+			if usesLR {
+				frame.argp += ptrSize
+			}
+			if f.args != _ArgsSizeUnknown {
+				frame.arglen = uintptr(f.args)
+			} else if flr == nil {
+				frame.arglen = 0
+			} else if frame.lr == uintptr(unsafe.Pointer(&lessstack)) {
+				frame.arglen = uintptr(stk.argsize)
+			} else {
+				i := funcarglen(flr, frame.lr)
+				if i >= 0 {
+					frame.arglen = uintptr(i)
+				} else {
+					var tmp string
+					if flr != nil {
+						tmp = gofuncname(flr)
+					} else {
+						tmp = "?"
+					}
+					print("runtime: unknown argument frame size for ", gofuncname(f), " called from ", hex(frame.lr), " [", tmp, "]\n")
+					if callback != nil {
+						gothrow("invalid stack")
+					}
+					frame.arglen = 0
+				}
+			}
+		}
+
+		// Determine function SP where deferproc would find its arguments.
+		var sparg uintptr
+		if usesLR {
+			// On link register architectures, that's the standard bottom-of-stack plus 1 word
+			// for the saved LR. If the previous frame was a direct call to newproc/deferproc,
+			// however, the SP is three words lower than normal.
+			// If the function has no frame at all - perhaps it just started, or perhaps
+			// it is a leaf with no local variables - then we cannot possibly find its
+			// SP in a defer, and we might confuse its SP for its caller's SP, so
+			// leave sparg=0 in that case.
+			if frame.fp != frame.sp {
+				sparg = frame.sp + regSize
+				if wasnewproc {
+					sparg += 3 * regSize
+				}
+			}
+		} else {
+			// On x86 that's the standard bottom-of-stack, so SP exactly.
+			// If the previous frame was a direct call to newproc/deferproc, however,
+			// the SP is two words lower than normal.
+			sparg = frame.sp
+			if wasnewproc {
+				sparg += 2 * ptrSize
+			}
+		}
+
+		// Determine frame's 'continuation PC', where it can continue.
+		// Normally this is the return address on the stack, but if sigpanic
+		// is immediately below this function on the stack, then the frame
+		// stopped executing due to a trap, and frame.pc is probably not
+		// a safe point for looking up liveness information. In this panicking case,
+		// the function either doesn't return at all (if it has no defers or if the
+		// defers do not recover) or it returns from one of the calls to
+		// deferproc a second time (if the corresponding deferred func recovers).
+		// It suffices to assume that the most recent deferproc is the one that
+		// returns; everything live at earlier deferprocs is still live at that one.
+		frame.continpc = frame.pc
+		if waspanic {
+			if panic != nil && panic._defer.argp == sparg {
+				frame.continpc = panic._defer.pc
+			} else if _defer != nil && _defer.argp == sparg {
+				frame.continpc = _defer.pc
+			} else {
+				frame.continpc = 0
+			}
+		}
+
+		// Unwind our local panic & defer stacks past this frame.
+		for panic != nil && (panic._defer == nil || panic._defer.argp == sparg || panic._defer.argp == _NoArgs) {
+			panic = panic.link
+		}
+		for _defer != nil && (_defer.argp == sparg || _defer.argp == _NoArgs) {
+			_defer = _defer.link
+		}
+
+		if skip > 0 {
+			skip--
+			goto skipped
+		}
+
+		if pcbuf != nil {
+			(*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = frame.pc
+		}
+		if callback != nil {
+			if !callback((*stkframe)(noescape(unsafe.Pointer(&frame))), v) {
+				return n
+			}
+		}
+		if printing {
+			if printall || showframe(f, gp) {
+				// Print during crash.
+				//	main(0x1, 0x2, 0x3)
+				//		/home/rsc/go/src/runtime/x.go:23 +0xf
+				//
+				tracepc := frame.pc // back up to CALL instruction for funcline.
+				if n > 0 && frame.pc > f.entry && !waspanic {
+					tracepc--
+				}
+				print(gofuncname(f), "(")
+				argp := (*[100]uintptr)(unsafe.Pointer(frame.argp))
+				for i := uintptr(0); i < frame.arglen/ptrSize; i++ {
+					if i >= 10 {
+						print(", ...")
+						break
+					}
+					if i != 0 {
+						print(", ")
+					}
+					print(hex(argp[i]))
+				}
+				print(")\n")
+				var file string
+				line := funcline(f, tracepc, &file)
+				print("\t", file, ":", line)
+				if frame.pc > f.entry {
+					print(" +", hex(frame.pc-f.entry))
+				}
+				if g.m.throwing > 0 && gp == g.m.curg || gotraceback >= 2 {
+					print(" fp=", hex(frame.fp), " sp=", hex(frame.sp))
+				}
+				print("\n")
+				nprint++
+			}
+		}
+		n++
+
+	skipped:
+		waspanic = f.entry == uintptr(unsafe.Pointer(&sigpanic))
+		wasnewproc = f.entry == uintptr(unsafe.Pointer(&newproc)) || f.entry == uintptr(unsafe.Pointer(&deferproc))
+
+		// Do not unwind past the bottom of the stack.
+		if flr == nil {
+			break
+		}
+
+		// Unwind to next frame.
+		frame.fn = flr
+		frame.pc = frame.lr
+		frame.lr = 0
+		frame.sp = frame.fp
+		frame.fp = 0
+
+		// On link register architectures, sighandler saves the LR on stack
+		// before faking a call to sigpanic.
+		if usesLR && waspanic {
+			x := *(*uintptr)(unsafe.Pointer(frame.sp))
+			frame.sp += ptrSize
+			f = findfunc(frame.pc)
+			frame.fn = f
+			if f == nil {
+				frame.pc = x
+			} else if f.frame == 0 {
+				frame.lr = x
+			}
+		}
+	}
+
+	if pcbuf == nil && callback == nil {
+		n = nprint
+	}
+
+	// If callback != nil, we're being called to gather stack information during
+	// garbage collection or stack growth. In that context, require that we used
+	// up the entire defer stack. If not, then there is a bug somewhere and the
+	// garbage collection or stack growth may not have seen the correct picture
+	// of the stack. Crash now instead of silently executing the garbage collection
+	// or stack copy incorrectly and setting up for a mysterious crash later.
+	//
+	// Note that panic != nil is okay here: there can be leftover panics,
+	// because the defers on the panic stack do not nest in frame order as
+	// they do on the defer stack. If you have:
+	//
+	//	frame 1 defers d1
+	//	frame 2 defers d2
+	//	frame 3 defers d3
+	//	frame 4 panics
+	//	frame 4's panic starts running defers
+	//	frame 5, running d3, defers d4
+	//	frame 5 panics
+	//	frame 5's panic starts running defers
+	//	frame 6, running d4, garbage collects
+	//	frame 6, running d2, garbage collects
+	//
+	// During the execution of d4, the panic stack is d4 -> d3, which
+	// is nested properly, and we'll treat frame 3 as resumable, because we
+	// can find d3. (And in fact frame 3 is resumable. If d4 recovers
+	// and frame 5 continues running, d3, d3 can recover and we'll
+	// resume execution in (returning from) frame 3.)
+	//
+	// During the execution of d2, however, the panic stack is d2 -> d3,
+	// which is inverted. The scan will match d2 to frame 2 but having
+	// d2 on the stack until then means it will not match d3 to frame 3.
+	// This is okay: if we're running d2, then all the defers after d2 have
+	// completed and their corresponding frames are dead. Not finding d3
+	// for frame 3 means we'll set frame 3's continpc == 0, which is correct
+	// (frame 3 is dead). At the end of the walk the panic stack can thus
+	// contain defers (d3 in this case) for dead frames. The inversion here
+	// always indicates a dead frame, and the effect of the inversion on the
+	// scan is to hide those dead frames, so the scan is still okay:
+	// what's left on the panic stack are exactly (and only) the dead frames.
+	//
+	// We require callback != nil here because only when callback != nil
+	// do we know that gentraceback is being called in a "must be correct"
+	// context as opposed to a "best effort" context. The tracebacks with
+	// callbacks only happen when everything is stopped nicely.
+	// At other times, such as when gathering a stack for a profiling signal
+	// or when printing a traceback during a crash, everything may not be
+	// stopped nicely, and the stack walk may not be able to complete.
+	// It's okay in those situations not to use up the entire defer stack:
+	// incomplete information then is still better than nothing.
+	if callback != nil && n < max && _defer != nil {
+		if _defer != nil {
+			print("runtime: g", gp.goid, ": leftover defer argp=", hex(_defer.argp), " pc=", hex(_defer.pc), "\n")
+		}
+		if panic != nil {
+			print("runtime: g", gp.goid, ": leftover panic argp=", hex(panic._defer.argp), " pc=", hex(panic._defer.pc), "\n")
+		}
+		for _defer = gp._defer; _defer != nil; _defer = _defer.link {
+			print("\tdefer ", _defer, " argp=", hex(_defer.argp), " pc=", hex(_defer.pc), "\n")
+		}
+		for panic = gp._panic; panic != nil; panic = panic.link {
+			print("\tpanic ", panic, " defer ", panic._defer)
+			if panic._defer != nil {
+				print(" argp=", hex(panic._defer.argp), " pc=", hex(panic._defer.pc))
+			}
+			print("\n")
+		}
+		gothrow("traceback has leftover defers or panics")
+	}
+
+	return n
+}
+
+func showframe(*_func, *g) bool
+
+func printcreatedby(gp *g) {
+	// Show what created goroutine, except main goroutine (goid 1).
+	pc := gp.gopc
+	f := findfunc(pc)
+	if f != nil && showframe(f, gp) && gp.goid != 1 {
+		print("created by ", gofuncname(f), "\n")
+		tracepc := pc // back up to CALL instruction for funcline.
+		if pc > f.entry {
+			tracepc -= _PCQuantum
+		}
+		var file string
+		line := funcline(f, tracepc, &file)
+		print("\t", file, ":", line)
+		if pc > f.entry {
+			print(" +", hex(pc-f.entry))
+		}
+		print("\n")
+	}
+}
+
+func traceback(pc uintptr, sp uintptr, lr uintptr, gp *g) {
+	var n int
+	if readgstatus(gp)&^_Gscan == _Gsyscall {
+		// Override signal registers if blocked in system call.
+		pc = gp.syscallpc
+		sp = gp.syscallsp
+	}
+	// Print traceback. By default, omits runtime frames.
+	// If that means we print nothing at all, repeat forcing all frames printed.
+	n = gentraceback(pc, sp, 0, gp, 0, nil, _TracebackMaxFrames, nil, nil, false)
+	if n == 0 {
+		n = gentraceback(pc, sp, 0, gp, 0, nil, _TracebackMaxFrames, nil, nil, true)
+	}
+	if n == _TracebackMaxFrames {
+		print("...additional frames elided...\n")
+	}
+	printcreatedby(gp)
+}
+
+func callers(skip int, pcbuf *uintptr, m int) int {
+	sp := getcallersp(unsafe.Pointer(&skip))
+	pc := uintptr(getcallerpc(unsafe.Pointer(&skip)))
+	return gentraceback(pc, sp, 0, getg(), skip, pcbuf, m, nil, nil, false)
+}
+
+func gcallers(gp *g, skip int, pcbuf *uintptr, m int) int {
+	return gentraceback(^uintptr(0), ^uintptr(0), 0, gp, skip, pcbuf, m, nil, nil, false)
+}
diff --git a/src/pkg/runtime/traceback_arm.c b/src/pkg/runtime/traceback_arm.c
deleted file mode 100644
index 18ca89150f..0000000000
--- a/src/pkg/runtime/traceback_arm.c
+++ /dev/null
@@ -1,363 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "funcdata.h"
-
-void runtime·sigpanic(void);
-void runtime·newproc(void);
-void runtime·deferproc(void);
-
-int32
-runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip, uintptr *pcbuf, int32 max, bool (*callback)(Stkframe*, void*), void *v, bool printall)
-{
-	int32 i, n, nprint, line, gotraceback;
-	uintptr x, tracepc, sparg;
-	bool waspanic, wasnewproc, printing;
-	Func *f, *flr;
-	Stkframe frame;
-	Stktop *stk;
-	String file;
-	Panic *panic;
-	Defer *defer;
-
-	gotraceback = runtime·gotraceback(nil);
-
-	if(pc0 == ~(uintptr)0 && sp0 == ~(uintptr)0) { // Signal to fetch saved values from gp.
-		if(gp->syscallstack != (uintptr)nil) {
-			pc0 = gp->syscallpc;
-			sp0 = gp->syscallsp;
-			lr0 = 0;
-		} else {
-			pc0 = gp->sched.pc;
-			sp0 = gp->sched.sp;
-			lr0 = gp->sched.lr;
-		}
-	}
-
-	nprint = 0;
-	runtime·memclr((byte*)&frame, sizeof frame);
-	frame.pc = pc0;
-	frame.lr = lr0;
-	frame.sp = sp0;
-	waspanic = false;
-	wasnewproc = false;
-	printing = pcbuf==nil && callback==nil;
-
-	panic = gp->panic;
-	defer = gp->defer;
-
-	while(defer != nil && defer->argp == NoArgs)
-		defer = defer->link;	
-	while(panic != nil && panic->defer == nil)
-		panic = panic->link;
-
-	// If the PC is zero, it's likely a nil function call.
-	// Start in the caller's frame.
-	if(frame.pc == 0) {
-		frame.pc = frame.lr;
-		frame.lr = 0;
-	}
-	
-	f = runtime·findfunc(frame.pc);
-	if(f == nil) {
-		if(callback != nil) {
-			runtime·printf("runtime: unknown pc %p\n", frame.pc);
-			runtime·throw("unknown pc");
-		}
-		return 0;
-	}
-	frame.fn = f;
-
-	n = 0;
-	stk = (Stktop*)gp->stackbase;
-	while(n < max) {
-		// Typically:
-		//	pc is the PC of the running function.
-		//	sp is the stack pointer at that program counter.
-		//	fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown.
-		//	stk is the stack containing sp.
-		//	The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp.
-		
-		if(frame.pc == (uintptr)runtime·lessstack) {
-			// Hit top of stack segment.  Unwind to next segment.
-			frame.pc = stk->gobuf.pc;
-			frame.sp = stk->gobuf.sp;
-			frame.lr = 0;
-			frame.fp = 0;
-			if(printing && runtime·showframe(nil, gp))
-				runtime·printf("----- stack segment boundary -----\n");
-			stk = (Stktop*)stk->stackbase;
-			
-			f = runtime·findfunc(frame.pc);
-			if(f == nil) {
-				runtime·printf("runtime: unknown pc %p after stack split\n", frame.pc);
-				if(callback != nil)
-					runtime·throw("unknown pc");
-			}
-			frame.fn = f;
-			continue;
-		}
-		f = frame.fn;
-		
-		// Found an actual function.
-		// Derive frame pointer and link register.
-		if(frame.fp == 0)
-			frame.fp = frame.sp + runtime·funcspdelta(f, frame.pc);
-		if(runtime·topofstack(f)) {
-			frame.lr = 0;
-			flr = nil;
-		} else if(f->entry == (uintptr)runtime·jmpdefer) {
-			// jmpdefer modifies SP/LR/PC non-atomically.
-			// If a profiling interrupt arrives during jmpdefer,
-			// the stack unwind may see a mismatched register set
-			// and get confused. Stop if we see PC within jmpdefer
-			// to avoid that confusion.
-			// See golang.org/issue/8153.
-			// This check can be deleted if jmpdefer is changed
-			// to restore all three atomically using pop.
-			if(callback != nil)
-				runtime·throw("traceback_arm: found jmpdefer when tracing with callback");
-			frame.lr = 0;
-			flr = nil;
-		} else {
-			if((n == 0 && frame.sp < frame.fp) || frame.lr == 0)
-				frame.lr = *(uintptr*)frame.sp;
-			flr = runtime·findfunc(frame.lr);
-			if(flr == nil) {
-				// This happens if you get a profiling interrupt at just the wrong time.
-				// In that context it is okay to stop early.
-				// But if callback is set, we're doing a garbage collection and must
-				// get everything, so crash loudly.
-				if(callback != nil) {
-					runtime·printf("runtime: unexpected return pc for %s called from %p\n", runtime·funcname(f), frame.lr);
-					runtime·throw("unknown caller pc");
-				}
-			}
-		}
-
-		frame.varp = frame.fp;
-
-		// Derive size of arguments.
-		// Most functions have a fixed-size argument block,
-		// so we can use metadata about the function f.
-		// Not all, though: there are some variadic functions
-		// in package runtime and reflect, and for those we use call-specific
-		// metadata recorded by f's caller.
-		if(callback != nil || printing) {
-			frame.argp = frame.fp + sizeof(uintptr);
-			if(f->args != ArgsSizeUnknown)
-				frame.arglen = f->args;
-			else if(flr == nil)
-				frame.arglen = 0;
-			else if(frame.lr == (uintptr)runtime·lessstack)
-				frame.arglen = stk->argsize;
-			else if((i = runtime·funcarglen(flr, frame.lr)) >= 0)
-				frame.arglen = i;
-			else {
-				runtime·printf("runtime: unknown argument frame size for %s called from %p [%s]\n",
-					runtime·funcname(f), frame.lr, flr ? runtime·funcname(flr) : "?");
-				if(callback != nil)
-					runtime·throw("invalid stack");
-				frame.arglen = 0;
-			}
-		}
-
-		// Determine function SP where deferproc would find its arguments.
-		// On ARM that's just the standard bottom-of-stack plus 1 word for
-		// the saved LR. If the previous frame was a direct call to newproc/deferproc,
-		// however, the SP is three words lower than normal.
-		// If the function has no frame at all - perhaps it just started, or perhaps
-		// it is a leaf with no local variables - then we cannot possibly find its
-		// SP in a defer, and we might confuse its SP for its caller's SP, so
-		// set sparg=0 in that case.
-		sparg = 0;
-		if(frame.fp != frame.sp) {
-			sparg = frame.sp + sizeof(uintreg);
-			if(wasnewproc)
-				sparg += 3*sizeof(uintreg);
-		}
-
-		// Determine frame's 'continuation PC', where it can continue.
-		// Normally this is the return address on the stack, but if sigpanic
-		// is immediately below this function on the stack, then the frame
-		// stopped executing due to a trap, and frame.pc is probably not
-		// a safe point for looking up liveness information. In this panicking case,
-		// the function either doesn't return at all (if it has no defers or if the
-		// defers do not recover) or it returns from one of the calls to 
-		// deferproc a second time (if the corresponding deferred func recovers).
-		// It suffices to assume that the most recent deferproc is the one that
-		// returns; everything live at earlier deferprocs is still live at that one.
-		frame.continpc = frame.pc;
-		if(waspanic) {
-			if(panic != nil && panic->defer->argp == sparg)
-				frame.continpc = (uintptr)panic->defer->pc;
-			else if(defer != nil && defer->argp == sparg)
-				frame.continpc = (uintptr)defer->pc;
-			else
-				frame.continpc = 0;
-		}
-
-		// Unwind our local panic & defer stacks past this frame.
-		while(panic != nil && (panic->defer == nil || panic->defer->argp == sparg || panic->defer->argp == NoArgs))
-			panic = panic->link;
-		while(defer != nil && (defer->argp == sparg || defer->argp == NoArgs))
-			defer = defer->link;	
-
-		if(skip > 0) {
-			skip--;
-			goto skipped;
-		}
-
-		if(pcbuf != nil)
-			pcbuf[n] = frame.pc;
-		if(callback != nil) {
-			if(!callback(&frame, v))
-				return n;
-		}
-		if(printing) {
-			if(printall || runtime·showframe(f, gp)) {
-				// Print during crash.
-				//	main(0x1, 0x2, 0x3)
-				//		/home/rsc/go/src/runtime/x.go:23 +0xf
-				tracepc = frame.pc;	// back up to CALL instruction for funcline.
-				if(n > 0 && frame.pc > f->entry && !waspanic)
-					tracepc -= sizeof(uintptr);
-				runtime·printf("%s(", runtime·funcname(f));
-				for(i = 0; i < frame.arglen/sizeof(uintptr); i++) {
-					if(i >= 10) {
-						runtime·prints(", ...");
-						break;
-					}
-					if(i != 0)
-						runtime·prints(", ");
-					runtime·printhex(((uintptr*)frame.argp)[i]);
-				}
-				runtime·prints(")\n");
-				line = runtime·funcline(f, tracepc, &file);
-				runtime·printf("\t%S:%d", file, line);
-				if(frame.pc > f->entry)
-					runtime·printf(" +%p", (uintptr)(frame.pc - f->entry));
-				if(g->m->throwing > 0 && gp == g->m->curg || gotraceback >= 2)
-					runtime·printf(" fp=%p sp=%p", frame.fp, frame.sp);
-				runtime·printf("\n");
-				nprint++;
-			}
-		}
-		n++;
-		
-	skipped:
-		waspanic = f->entry == (uintptr)runtime·sigpanic;
-		wasnewproc = f->entry == (uintptr)runtime·newproc || f->entry == (uintptr)runtime·deferproc;
-
-		// Do not unwind past the bottom of the stack.
-		if(flr == nil)
-			break;
-
-		// Unwind to next frame.
-		frame.pc = frame.lr;
-		frame.fn = flr;
-		frame.lr = 0;
-		frame.sp = frame.fp;
-		frame.fp = 0;
-	
-		// sighandler saves the lr on stack before faking a call to sigpanic
-		if(waspanic) {
-			x = *(uintptr*)frame.sp;
-			frame.sp += 4;
-			frame.fn = f = runtime·findfunc(frame.pc);
-			if(f == nil)
-				frame.pc = x;
-			else if(f->frame == 0)
-				frame.lr = x;
-		}
-	}
-	
-	if(pcbuf == nil && callback == nil)
-		n = nprint;
-
-	// For rationale, see long comment in traceback_x86.c.
-	if(callback != nil && n < max && defer != nil) {
-		if(defer != nil)
-			runtime·printf("runtime: g%D: leftover defer argp=%p pc=%p\n", gp->goid, defer->argp, defer->pc);
-		if(panic != nil)
-			runtime·printf("runtime: g%D: leftover panic argp=%p pc=%p\n", gp->goid, panic->defer->argp, panic->defer->pc);
-		for(defer = gp->defer; defer != nil; defer = defer->link)
-			runtime·printf("\tdefer %p argp=%p pc=%p\n", defer, defer->argp, defer->pc);
-		for(panic = gp->panic; panic != nil; panic = panic->link) {
-			runtime·printf("\tpanic %p defer %p", panic, panic->defer);
-			if(panic->defer != nil)
-				runtime·printf(" argp=%p pc=%p", panic->defer->argp, panic->defer->pc);
-			runtime·printf("\n");
-		}
-		runtime·throw("traceback has leftover defers or panics");
-	}
-
-	return n;		
-}
-
-void
-runtime·printcreatedby(G *gp)
-{
-	int32 line;
-	uintptr pc, tracepc;
-	Func *f;
-	String file;
-
-	// Show what created goroutine, except main goroutine (goid 1).
-	if((pc = gp->gopc) != 0 && (f = runtime·findfunc(pc)) != nil &&
-		runtime·showframe(f, gp) && gp->goid != 1) {
-		runtime·printf("created by %s\n", runtime·funcname(f));
-		tracepc = pc;	// back up to CALL instruction for funcline.
-		if(pc > f->entry)
-			tracepc -= PCQuantum;
-		line = runtime·funcline(f, tracepc, &file);
-		runtime·printf("\t%S:%d", file, line);
-		if(pc > f->entry)
-			runtime·printf(" +%p", (uintptr)(pc - f->entry));
-		runtime·printf("\n");
-	}
-}
-
-void
-runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G *gp)
-{
-	int32 n;
-
-	if((runtime·readgstatus(gp)&~Gscan) == Gsyscall){
-		// Override signal registers if blocked in system call.
-		pc = gp->syscallpc;
-		sp = gp->syscallsp;
-		lr = 0;
-	}
-
-	// Print traceback. By default, omits runtime frames.
-	// If that means we print nothing at all, repeat forcing all frames printed.
-	n = runtime·gentraceback(pc, sp, lr, gp, 0, nil, TracebackMaxFrames, nil, nil, false);
-	if(n == 0)
-		runtime·gentraceback(pc, sp, lr, gp, 0, nil, TracebackMaxFrames, nil, nil, true);
-	if(n == TracebackMaxFrames)
-		runtime·printf("...additional frames elided...\n");
-	runtime·printcreatedby(gp);
-}
-
-// func caller(n int) (pc uintptr, file string, line int, ok bool)
-int32
-runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
-{
-	uintptr pc, sp;
-	
-	sp = runtime·getcallersp(&skip);
-	pc = (uintptr)runtime·getcallerpc(&skip);
-
-	return runtime·gentraceback(pc, sp, 0, g, skip, pcbuf, m, nil, nil, false);
-}
-
-int32
-runtime·gcallers(G *gp, int32 skip, uintptr *pcbuf, int32 m)
-{
-	return runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, skip, pcbuf, m, nil, nil, false);
-}
diff --git a/src/pkg/runtime/traceback_windows.go b/src/pkg/runtime/traceback_windows.go
new file mode 100644
index 0000000000..206f93c46e
--- /dev/null
+++ b/src/pkg/runtime/traceback_windows.go
@@ -0,0 +1,64 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+// sigtrampPC is the PC at the beginning of the jmpdefer assembly function.
+// The traceback needs to recognize it on link register architectures.
+var sigtrampPC uintptr
+
+var sigtramp struct{} // assembly function
+
+func init() {
+	f := sigtramp
+	sigtrampPC = **(**uintptr)(unsafe.Pointer(&f))
+	systraceback = traceback_windows
+}
+
+func traceback_windows(f *_func, frame *stkframe, gp *g, printing bool, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer) (changed, aborted bool) {
+	// The main traceback thinks it has found a function. Check this.
+
+	// Windows exception handlers run on the actual g stack (there is room
+	// dedicated to this below the usual "bottom of stack"), not on a separate
+	// stack. As a result, we have to be able to unwind past the exception
+	// handler when called to unwind during stack growth inside the handler.
+	// Recognize the frame at the call to sighandler in sigtramp and unwind
+	// using the context argument passed to the call. This is awful.
+	if f != nil && f.entry == sigtrampPC && frame.pc > f.entry {
+		var r *context
+		// Invoke callback so that stack copier sees an uncopyable frame.
+		if callback != nil {
+			frame.continpc = frame.pc
+			frame.argp = 0
+			frame.arglen = 0
+			if !callback(frame, v) {
+				aborted = true
+				return
+			}
+		}
+		r = (*context)(unsafe.Pointer(frame.sp + ptrSize))
+		frame.pc = contextPC(r)
+		frame.sp = contextSP(r)
+		frame.lr = 0
+		frame.fp = 0
+		frame.fn = nil
+		if printing && showframe(nil, gp) {
+			print("----- exception handler -----\n")
+		}
+		f = findfunc(frame.pc)
+		if f == nil {
+			print("runtime: unknown pc ", hex(frame.pc), " after exception handler\n")
+			if callback != nil {
+				gothrow("unknown pc")
+			}
+		}
+		frame.fn = f
+		changed = true
+		return
+	}
+
+	return
+}
diff --git a/src/pkg/runtime/traceback_x86.c b/src/pkg/runtime/traceback_x86.c
deleted file mode 100644
index 169407ac81..0000000000
--- a/src/pkg/runtime/traceback_x86.c
+++ /dev/null
@@ -1,436 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build amd64 amd64p32 386
-
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "funcdata.h"
-#ifdef GOOS_windows
-#include "defs_GOOS_GOARCH.h"
-#endif
-
-void runtime·sigpanic(void);
-void runtime·newproc(void);
-void runtime·deferproc(void);
-
-#ifdef GOOS_windows
-void runtime·sigtramp(void);
-#endif
-
-// This code is also used for the 386 tracebacks.
-// Use uintptr for an appropriate word-sized integer.
-
-// Generic traceback.  Handles runtime stack prints (pcbuf == nil),
-// the runtime.Callers function (pcbuf != nil), as well as the garbage
-// collector (callback != nil).  A little clunky to merge these, but avoids
-// duplicating the code and all its subtlety.
-int32
-runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip, uintptr *pcbuf, int32 max, bool (*callback)(Stkframe*, void*), void *v, bool printall)
-{
-	int32 i, n, nprint, line, gotraceback;
-	uintptr tracepc, sparg;
-	bool waspanic, wasnewproc, printing;
-	Func *f, *flr;
-	Stkframe frame;
-	Stktop *stk;
-	String file;
-	Panic *panic;
-	Defer *defer;
-
-	USED(lr0);
-	
-	gotraceback = runtime·gotraceback(nil);
-	
-	if(pc0 == ~(uintptr)0 && sp0 == ~(uintptr)0) { // Signal to fetch saved values from gp.
-		if(gp->syscallstack != (uintptr)nil) {
-			pc0 = gp->syscallpc;
-			sp0 = gp->syscallsp;
-		} else {
-			pc0 = gp->sched.pc;
-			sp0 = gp->sched.sp;
-		}
-	}
-
-	nprint = 0;
-	runtime·memclr((byte*)&frame, sizeof frame);
-	frame.pc = pc0;
-	frame.sp = sp0;
-	waspanic = false;
-	wasnewproc = false;
-	printing = pcbuf==nil && callback==nil;
-	panic = gp->panic;
-	defer = gp->defer;
-
-	while(defer != nil && defer->argp == NoArgs)
-		defer = defer->link;	
-	while(panic != nil && panic->defer == nil)
-		panic = panic->link;
-
-	// If the PC is zero, it's likely a nil function call.
-	// Start in the caller's frame.
-	if(frame.pc == 0) {
-		frame.pc = *(uintptr*)frame.sp;
-		frame.sp += sizeof(uintreg);
-	}
-	
-	f = runtime·findfunc(frame.pc);
-	if(f == nil) {
-		if(callback != nil) {
-			runtime·printf("runtime: unknown pc %p\n", frame.pc);
-			runtime·throw("unknown pc");
-		}
-		return 0;
-	}
-	frame.fn = f;
-
-	n = 0;
-	stk = (Stktop*)gp->stackbase;
-	while(n < max) {
-		// Typically:
-		//	pc is the PC of the running function.
-		//	sp is the stack pointer at that program counter.
-		//	fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown.
-		//	stk is the stack containing sp.
-		//	The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp.
-	
-		if(frame.pc == (uintptr)runtime·lessstack) {
-			// Hit top of stack segment.  Unwind to next segment.
-			frame.pc = stk->gobuf.pc;
-			frame.sp = stk->gobuf.sp;
-			frame.lr = 0;
-			frame.fp = 0;
-			frame.fn = nil;
-			if(printing && runtime·showframe(nil, gp))
-				runtime·printf("----- stack segment boundary -----\n");
-			stk = (Stktop*)stk->stackbase;
-
-			f = runtime·findfunc(frame.pc);
-			if(f == nil) {
-				runtime·printf("runtime: unknown pc %p after stack split\n", frame.pc);
-				if(callback != nil)
-					runtime·throw("unknown pc");
-			}
-			frame.fn = f;
-			continue;
-		}
-		
-		f = frame.fn;
-
-#ifdef GOOS_windows
-		// Windows exception handlers run on the actual g stack (there is room
-		// dedicated to this below the usual "bottom of stack"), not on a separate
-		// stack. As a result, we have to be able to unwind past the exception
-		// handler when called to unwind during stack growth inside the handler.
-		// Recognize the frame at the call to sighandler in sigtramp and unwind
-		// using the context argument passed to the call. This is awful.
-		if(f != nil && f->entry == (uintptr)runtime·sigtramp && frame.pc > f->entry) {
-			Context *r;
-			
-			// Invoke callback so that stack copier sees an uncopyable frame.
-			if(callback != nil) {
-				frame.continpc = frame.pc;
-				frame.argp = 0;
-				frame.arglen = 0;
-				if(!callback(&frame, v))
-					return n;
-			}
-			r = (Context*)((uintptr*)frame.sp)[1];
-#ifdef GOARCH_amd64
-			frame.pc = r->Rip;
-			frame.sp = r->Rsp;
-#else
-			frame.pc = r->Eip;
-			frame.sp = r->Esp;
-#endif
-			frame.lr = 0;
-			frame.fp = 0;
-			frame.fn = nil;
-			if(printing && runtime·showframe(nil, gp))
-				runtime·printf("----- exception handler -----\n");
-			f = runtime·findfunc(frame.pc);
-			if(f == nil) {
-				runtime·printf("runtime: unknown pc %p after exception handler\n", frame.pc);
-				if(callback != nil)
-					runtime·throw("unknown pc");
-			}
-			frame.fn = f;
-			continue;
-		}
-#endif
-
-		// Found an actual function.
-		// Derive frame pointer and link register.
-		if(frame.fp == 0) {
-			frame.fp = frame.sp + runtime·funcspdelta(f, frame.pc);
-			frame.fp += sizeof(uintreg); // caller PC
-		}
-		if(runtime·topofstack(f)) {
-			frame.lr = 0;
-			flr = nil;
-		} else {
-			if(frame.lr == 0)
-				frame.lr = ((uintreg*)frame.fp)[-1];
-			flr = runtime·findfunc(frame.lr);
-			if(flr == nil) {
-				runtime·printf("runtime: unexpected return pc for %s called from %p\n", runtime·funcname(f), frame.lr);
-				if(callback != nil)
-					runtime·throw("unknown caller pc");
-			}
-		}
-		
-		frame.varp = frame.fp - sizeof(uintreg);
-
-		// Derive size of arguments.
-		// Most functions have a fixed-size argument block,
-		// so we can use metadata about the function f.
-		// Not all, though: there are some variadic functions
-		// in package runtime and reflect, and for those we use call-specific
-		// metadata recorded by f's caller.
-		if(callback != nil || printing) {
-			frame.argp = frame.fp;
-			if(f->args != ArgsSizeUnknown)
-				frame.arglen = f->args;
-			else if(flr == nil)
-				frame.arglen = 0;
-			else if(frame.lr == (uintptr)runtime·lessstack)
-				frame.arglen = stk->argsize;
-			else if((i = runtime·funcarglen(flr, frame.lr)) >= 0)
-				frame.arglen = i;
-			else {
-				runtime·printf("runtime: unknown argument frame size for %s called from %p [%s]\n",
-					runtime·funcname(f), frame.lr, flr ? runtime·funcname(flr) : "?");
-				if(callback != nil)
-					runtime·throw("invalid stack");
-				frame.arglen = 0;
-			}
-		}
-		
-		// Determine function SP where deferproc would find its arguments.
-		// On x86 that's just the standard bottom-of-stack, so SP exactly.
-		// If the previous frame was a direct call to newproc/deferproc, however,
-		// the SP is two words lower than normal.
-		sparg = frame.sp;
-		if(wasnewproc)
-			sparg += 2*sizeof(uintptr);
-
-		// Determine frame's 'continuation PC', where it can continue.
-		// Normally this is the return address on the stack, but if sigpanic
-		// is immediately below this function on the stack, then the frame
-		// stopped executing due to a trap, and frame.pc is probably not
-		// a safe point for looking up liveness information. In this panicking case,
-		// the function either doesn't return at all (if it has no defers or if the
-		// defers do not recover) or it returns from one of the calls to 
-		// deferproc a second time (if the corresponding deferred func recovers).
-		// It suffices to assume that the most recent deferproc is the one that
-		// returns; everything live at earlier deferprocs is still live at that one.
-		frame.continpc = frame.pc;
-		if(waspanic) {
-			if(panic != nil && panic->defer->argp == sparg)
-				frame.continpc = panic->defer->pc;
-			else if(defer != nil && defer->argp == sparg)
-				frame.continpc = defer->pc;
-			else
-				frame.continpc = 0;
-		}
-
-		// Unwind our local panic & defer stacks past this frame.
-		while(panic != nil && (panic->defer == nil || panic->defer->argp == sparg || panic->defer->argp == NoArgs))
-			panic = panic->link;
-		while(defer != nil && (defer->argp == sparg || defer->argp == NoArgs))
-			defer = defer->link;	
-
-		if(skip > 0) {
-			skip--;
-			goto skipped;
-		}
-
-		if(pcbuf != nil)
-			pcbuf[n] = frame.pc;
-		if(callback != nil) {
-			if(!callback(&frame, v))
-				return n;
-		}
-		if(printing) {
-			if(printall || runtime·showframe(f, gp)) {
-				// Print during crash.
-				//	main(0x1, 0x2, 0x3)
-				//		/home/rsc/go/src/runtime/x.go:23 +0xf
-				//		
-				tracepc = frame.pc;	// back up to CALL instruction for funcline.
-				if(n > 0 && frame.pc > f->entry && !waspanic)
-					tracepc--;
-				runtime·printf("%s(", runtime·funcname(f));
-				for(i = 0; i < frame.arglen/sizeof(uintptr); i++) {
-					if(i >= 10) {
-						runtime·prints(", ...");
-						break;
-					}
-					if(i != 0)
-						runtime·prints(", ");
-					runtime·printhex(((uintptr*)frame.argp)[i]);
-				}
-				runtime·prints(")\n");
-				line = runtime·funcline(f, tracepc, &file);
-				runtime·printf("\t%S:%d", file, line);
-				if(frame.pc > f->entry)
-					runtime·printf(" +%p", (uintptr)(frame.pc - f->entry));
-				if(g->m->throwing > 0 && gp == g->m->curg || gotraceback >= 2)
-					runtime·printf(" fp=%p sp=%p", frame.fp, frame.sp);
-				runtime·printf("\n");
-				nprint++;
-			}
-		}
-		n++;
-	
-	skipped:
-		waspanic = f->entry == (uintptr)runtime·sigpanic;
-		wasnewproc = f->entry == (uintptr)runtime·newproc || f->entry == (uintptr)runtime·deferproc;
-
-		// Do not unwind past the bottom of the stack.
-		if(flr == nil)
-			break;
-
-		// Unwind to next frame.
-		frame.fn = flr;
-		frame.pc = frame.lr;
-		frame.lr = 0;
-		frame.sp = frame.fp;
-		frame.fp = 0;
-	}
-	
-	if(pcbuf == nil && callback == nil)
-		n = nprint;
-
-	// If callback != nil, we're being called to gather stack information during
-	// garbage collection or stack growth. In that context, require that we used
-	// up the entire defer stack. If not, then there is a bug somewhere and the
-	// garbage collection or stack growth may not have seen the correct picture
-	// of the stack. Crash now instead of silently executing the garbage collection
-	// or stack copy incorrectly and setting up for a mysterious crash later.
-	//
-	// Note that panic != nil is okay here: there can be leftover panics,
-	// because the defers on the panic stack do not nest in frame order as
-	// they do on the defer stack. If you have:
-	//
-	//	frame 1 defers d1
-	//	frame 2 defers d2
-	//	frame 3 defers d3
-	//	frame 4 panics
-	//	frame 4's panic starts running defers
-	//	frame 5, running d3, defers d4
-	//	frame 5 panics
-	//	frame 5's panic starts running defers
-	//	frame 6, running d4, garbage collects
-	//	frame 6, running d2, garbage collects
-	//
-	// During the execution of d4, the panic stack is d4 -> d3, which
-	// is nested properly, and we'll treat frame 3 as resumable, because we
-	// can find d3. (And in fact frame 3 is resumable. If d4 recovers
-	// and frame 5 continues running, d3, d3 can recover and we'll
-	// resume execution in (returning from) frame 3.)
-	//
-	// During the execution of d2, however, the panic stack is d2 -> d3,
-	// which is inverted. The scan will match d2 to frame 2 but having
-	// d2 on the stack until then means it will not match d3 to frame 3.
-	// This is okay: if we're running d2, then all the defers after d2 have
-	// completed and their corresponding frames are dead. Not finding d3
-	// for frame 3 means we'll set frame 3's continpc == 0, which is correct
-	// (frame 3 is dead). At the end of the walk the panic stack can thus
-	// contain defers (d3 in this case) for dead frames. The inversion here
-	// always indicates a dead frame, and the effect of the inversion on the
-	// scan is to hide those dead frames, so the scan is still okay:
-	// what's left on the panic stack are exactly (and only) the dead frames.
-	//
-	// We require callback != nil here because only when callback != nil
-	// do we know that gentraceback is being called in a "must be correct"
-	// context as opposed to a "best effort" context. The tracebacks with
-	// callbacks only happen when everything is stopped nicely.
-	// At other times, such as when gathering a stack for a profiling signal
-	// or when printing a traceback during a crash, everything may not be
-	// stopped nicely, and the stack walk may not be able to complete.
-	// It's okay in those situations not to use up the entire defer stack:
-	// incomplete information then is still better than nothing.
-	if(callback != nil && n < max && defer != nil) {
-		if(defer != nil)
-			runtime·printf("runtime: g%D: leftover defer argp=%p pc=%p\n", gp->goid, defer->argp, defer->pc);
-		if(panic != nil)
-			runtime·printf("runtime: g%D: leftover panic argp=%p pc=%p\n", gp->goid, panic->defer->argp, panic->defer->pc);
-		for(defer = gp->defer; defer != nil; defer = defer->link)
-			runtime·printf("\tdefer %p argp=%p pc=%p\n", defer, defer->argp, defer->pc);
-		for(panic = gp->panic; panic != nil; panic = panic->link) {
-			runtime·printf("\tpanic %p defer %p", panic, panic->defer);
-			if(panic->defer != nil)
-				runtime·printf(" argp=%p pc=%p", panic->defer->argp, panic->defer->pc);
-			runtime·printf("\n");
-		}
-		runtime·throw("traceback has leftover defers or panics");
-	}
-
-	return n;
-}
-
-void
-runtime·printcreatedby(G *gp)
-{
-	int32 line;
-	uintptr pc, tracepc;
-	Func *f;
-	String file;
-
-	// Show what created goroutine, except main goroutine (goid 1).
-	if((pc = gp->gopc) != 0 && (f = runtime·findfunc(pc)) != nil &&
-		runtime·showframe(f, gp) && gp->goid != 1) {
-		runtime·printf("created by %s\n", runtime·funcname(f));
-		tracepc = pc;	// back up to CALL instruction for funcline.
-		if(pc > f->entry)
-			tracepc -= PCQuantum;
-		line = runtime·funcline(f, tracepc, &file);
-		runtime·printf("\t%S:%d", file, line);
-		if(pc > f->entry)
-			runtime·printf(" +%p", (uintptr)(pc - f->entry));
-		runtime·printf("\n");
-	}
-}
-
-void
-runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G *gp)
-{
-	int32 n;
-
-	USED(lr);
-
-	if((runtime·readgstatus(gp)&~Gscan) == Gsyscall){
-		// Override signal registers if blocked in system call.
-		pc = gp->syscallpc;
-		sp = gp->syscallsp;
-	}
-	
-	// Print traceback. By default, omits runtime frames.
-	// If that means we print nothing at all, repeat forcing all frames printed.
-	n = runtime·gentraceback(pc, sp, 0, gp, 0, nil, TracebackMaxFrames, nil, nil, false);
-	if(n == 0)
-		n = runtime·gentraceback(pc, sp, 0, gp, 0, nil, TracebackMaxFrames, nil, nil, true);
-	if(n == TracebackMaxFrames)
-		runtime·printf("...additional frames elided...\n");
-	runtime·printcreatedby(gp);
-}
-
-int32
-runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
-{
-	uintptr pc, sp;
-
-	sp = runtime·getcallersp(&skip);
-	pc = (uintptr)runtime·getcallerpc(&skip);
-
-	return runtime·gentraceback(pc, sp, 0, g, skip, pcbuf, m, nil, nil, false);
-}
-
-int32
-runtime·gcallers(G *gp, int32 skip, uintptr *pcbuf, int32 m)
-{
-	return runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, skip, pcbuf, m, nil, nil, false);
-}

From 592f0e10d980dcf3ae5ca9109888d7a60b7843a1 Mon Sep 17 00:00:00 2001
From: Adam Langley <agl@golang.org>
Date: Tue, 2 Sep 2014 12:22:57 -0700
Subject: [PATCH 338/423] A+C: David Leon Gil (individual CLA)

Generated by a+c.

R=gobot
CC=golang-codereviews
https://golang.org/cl/134330043
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 370b41f5c0..29aca3dbc4 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -120,6 +120,7 @@ David du Colombier <0intro@gmail.com>
 David Forsythe <dforsythe@gmail.com>
 David G. Andersen <dave.andersen@gmail.com>
 David Jakob Fritz <david.jakob.fritz@gmail.com>
+David Leon Gil <coruus@gmail.com>
 David Thomas <davidthomas426@gmail.com>
 David Titarenco <david.titarenco@gmail.com>
 Dean Prichard <dean.prichard@gmail.com>
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index bcca6b2158..4d2aacafa9 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -182,6 +182,7 @@ David du Colombier <0intro@gmail.com>
 David Forsythe <dforsythe@gmail.com>
 David G. Andersen <dave.andersen@gmail.com>
 David Jakob Fritz <david.jakob.fritz@gmail.com>
+David Leon Gil <coruus@gmail.com>
 David McLeish <davemc@google.com>
 David Presotto <presotto@gmail.com>
 David Symonds <dsymonds@golang.org>

From 86040a091fbc8ba33474b018a1ccb6aa71de90df Mon Sep 17 00:00:00 2001
From: David Leon Gil <coruus@gmail.com>
Date: Tue, 2 Sep 2014 12:23:49 -0700
Subject: [PATCH 339/423] crypto: Add SHA3 functions in go.crypto/sha3 to the
 Hash enum.

Reverse dependency of https://golang.org/cl/130950043/

LGTM=agl
R=golang-codereviews, agl
CC=agl, golang-codereviews
https://golang.org/cl/138800043
---
 src/pkg/crypto/crypto.go | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/pkg/crypto/crypto.go b/src/pkg/crypto/crypto.go
index c3a2364fe2..5a91baca0e 100644
--- a/src/pkg/crypto/crypto.go
+++ b/src/pkg/crypto/crypto.go
@@ -30,6 +30,10 @@ const (
 	SHA512                    // import crypto/sha512
 	MD5SHA1                   // no implementation; MD5+SHA1 used for TLS RSA
 	RIPEMD160                 // import code.google.com/p/go.crypto/ripemd160
+	SHA3_224                  // import code.google.com/p/go.crypto/sha3
+	SHA3_256                  // import code.google.com/p/go.crypto/sha3
+	SHA3_384                  // import code.google.com/p/go.crypto/sha3
+	SHA3_512                  // import code.google.com/p/go.crypto/sha3
 	maxHash
 )
 
@@ -41,6 +45,10 @@ var digestSizes = []uint8{
 	SHA256:    32,
 	SHA384:    48,
 	SHA512:    64,
+	SHA3_224:  28,
+	SHA3_256:  32,
+	SHA3_384:  48,
+	SHA3_512:  64,
 	MD5SHA1:   36,
 	RIPEMD160: 20,
 }

From 1d8fa7fa5db01cde6e764af29d4c2fb80bad9d8c Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 2 Sep 2014 14:13:29 -0700
Subject: [PATCH 340/423] runtime: convert select implementation to Go.

LGTM=rsc
R=golang-codereviews, bradfitz, iant, khr, rsc
CC=golang-codereviews
https://golang.org/cl/139020043
---
 src/cmd/api/goapi.go                |   1 +
 src/cmd/gc/select.c                 |   3 +-
 src/pkg/reflect/value.go            |   4 +-
 src/pkg/runtime/chan.go             |   3 +-
 src/pkg/runtime/chan.goc            | 664 ----------------------------
 src/pkg/runtime/chan.h              |   5 +-
 src/pkg/runtime/pprof/pprof_test.go |   4 +-
 src/pkg/runtime/race.go             |  13 +
 src/pkg/runtime/race0.go            |   2 +
 src/pkg/runtime/select.go           | 645 +++++++++++++++++++++++++++
 src/pkg/runtime/stack.c             |   3 +
 src/pkg/runtime/thunk.s             |   3 +
 12 files changed, 677 insertions(+), 673 deletions(-)
 delete mode 100644 src/pkg/runtime/chan.goc
 create mode 100644 src/pkg/runtime/select.go

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 715e9f6ad8..8dec9e2cc7 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -403,6 +403,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" sudog struct{};" +
 			" waitq struct{};" +
 			" wincallbackcontext struct{};" +
+			" _select struct{}; " +
 			"); " +
 			"const ( cb_max = 2000 )"
 		f, err = parser.ParseFile(fset, filename, src, 0)
diff --git a/src/cmd/gc/select.c b/src/cmd/gc/select.c
index 8cf9926c17..ed23e4318b 100644
--- a/src/cmd/gc/select.c
+++ b/src/cmd/gc/select.c
@@ -347,12 +347,13 @@ selecttype(int32 size)
 	sudog->type->local = 1;
 
 	scase = nod(OTSTRUCT, N, N);
-	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("sg")), sudog));
+	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(types[TUINT8]))));
 	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("chan")), typenod(ptrto(types[TUINT8]))));
 	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("pc")), typenod(types[TUINTPTR])));
 	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("kind")), typenod(types[TUINT16])));
 	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("so")), typenod(types[TUINT16])));
 	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("receivedp")), typenod(ptrto(types[TUINT8]))));
+	scase->list = list(scase->list, nod(ODCLFIELD, newname(lookup("releasetime")), typenod(types[TUINT64])));
 	typecheck(&scase, Etype);
 	scase->type->noalg = 1;
 	scase->type->local = 1;
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index 4394ed0739..76086c561b 100644
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -2073,7 +2073,7 @@ func Copy(dst, src Value) int {
 }
 
 // A runtimeSelect is a single case passed to rselect.
-// This must match ../runtime/chan.c:/runtimeSelect
+// This must match ../runtime/select.go:/runtimeSelect
 type runtimeSelect struct {
 	dir uintptr        // 0, SendDir, or RecvDir
 	typ *rtype         // channel type
@@ -2091,7 +2091,7 @@ func rselect([]runtimeSelect) (chosen int, recvOK bool)
 // A SelectDir describes the communication direction of a select case.
 type SelectDir int
 
-// NOTE: These values must match ../runtime/chan.c:/SelectDir.
+// NOTE: These values must match ../runtime/select.go:/selectDir.
 
 const (
 	_             SelectDir = iota
diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index 5e972983c6..77df169399 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -4,8 +4,7 @@
 
 package runtime
 
-// This file contains the implementation of Go channels
-// and select statements.
+// This file contains the implementation of Go channels.
 
 import "unsafe"
 
diff --git a/src/pkg/runtime/chan.goc b/src/pkg/runtime/chan.goc
deleted file mode 100644
index f14b58d52a..0000000000
--- a/src/pkg/runtime/chan.goc
+++ /dev/null
@@ -1,664 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "type.h"
-#include "race.h"
-#include "malloc.h"
-#include "chan.h"
-#include "mgc0.h"
-#include "typekind.h"
-#include "../../cmd/ld/textflag.h"
-
-static	void	dequeueg(WaitQ*);
-static	SudoG*	dequeue(WaitQ*);
-static	void	enqueue(WaitQ*, SudoG*);
-static	void	racesync(Hchan*, SudoG*);
-
-// TODO(khr): temporary placeholders until the rest of this code is moved to Go.
-extern byte runtime·chansend;
-extern byte runtime·chanrecv;
-
-static int64
-selectsize(int32 size)
-{
-	Select *sel;
-	int64 selsize;
-
-	selsize = sizeof(*sel) +
-		(size-1)*sizeof(sel->scase[0]) +
-		size*sizeof(sel->lockorder[0]) +
-		size*sizeof(sel->pollorder[0]);
-	return ROUND(selsize, Int64Align);
-}
-
-#pragma textflag NOSPLIT
-func newselect(sel *Select, selsize int64, size int32) {
-	if(selsize != selectsize(size)) {
-		runtime·printf("runtime: bad select size %D, want %D\n", selsize, selectsize(size));
-		runtime·throw("bad select size");
-	}
-	sel->tcase = size;
-	sel->ncase = 0;
-	sel->lockorder = (void*)(sel->scase + size);
-	sel->pollorder = (void*)(sel->lockorder + size);
-
-	if(debug)
-		runtime·printf("newselect s=%p size=%d\n", sel, size);
-}
-
-// cut in half to give stack a chance to split
-static void selectsend(Select *sel, Hchan *c, void *pc, void *elem, int32 so);
-
-#pragma textflag NOSPLIT
-func selectsend(sel *Select, c *Hchan, elem *byte) (selected bool) {
-	selected = false;
-
-	// nil cases do not compete
-	if(c != nil)
-		selectsend(sel, c, runtime·getcallerpc(&sel), elem, (byte*)&selected - (byte*)&sel);
-}
-
-static void
-selectsend(Select *sel, Hchan *c, void *pc, void *elem, int32 so)
-{
-	int32 i;
-	Scase *cas;
-
-	i = sel->ncase;
-	if(i >= sel->tcase)
-		runtime·throw("selectsend: too many cases");
-	sel->ncase = i+1;
-	cas = &sel->scase[i];
-
-	cas->pc = pc;
-	cas->chan = c;
-	cas->so = so;
-	cas->kind = CaseSend;
-	cas->sg.elem = elem;
-
-	if(debug)
-		runtime·printf("selectsend s=%p pc=%p chan=%p so=%d\n",
-			sel, cas->pc, cas->chan, cas->so);
-}
-
-// cut in half to give stack a chance to split
-static void selectrecv(Select *sel, Hchan *c, void *pc, void *elem, bool*, int32 so);
-
-#pragma textflag NOSPLIT
-func selectrecv(sel *Select, c *Hchan, elem *byte) (selected bool) {
-	selected = false;
-
-	// nil cases do not compete
-	if(c != nil)
-		selectrecv(sel, c, runtime·getcallerpc(&sel), elem, nil, (byte*)&selected - (byte*)&sel);
-}
-
-#pragma textflag NOSPLIT
-func selectrecv2(sel *Select, c *Hchan, elem *byte, received *bool) (selected bool) {
-	selected = false;
-
-	// nil cases do not compete
-	if(c != nil)
-		selectrecv(sel, c, runtime·getcallerpc(&sel), elem, received, (byte*)&selected - (byte*)&sel);
-}
-
-static void
-selectrecv(Select *sel, Hchan *c, void *pc, void *elem, bool *received, int32 so)
-{
-	int32 i;
-	Scase *cas;
-
-	i = sel->ncase;
-	if(i >= sel->tcase)
-		runtime·throw("selectrecv: too many cases");
-	sel->ncase = i+1;
-	cas = &sel->scase[i];
-	cas->pc = pc;
-	cas->chan = c;
-
-	cas->so = so;
-	cas->kind = CaseRecv;
-	cas->sg.elem = elem;
-	cas->receivedp = received;
-
-	if(debug)
-		runtime·printf("selectrecv s=%p pc=%p chan=%p so=%d\n",
-			sel, cas->pc, cas->chan, cas->so);
-}
-
-// cut in half to give stack a chance to split
-static void selectdefault(Select*, void*, int32);
-
-#pragma textflag NOSPLIT
-func selectdefault(sel *Select) (selected bool) {
-	selected = false;
-	selectdefault(sel, runtime·getcallerpc(&sel), (byte*)&selected - (byte*)&sel);
-}
-
-static void
-selectdefault(Select *sel, void *callerpc, int32 so)
-{
-	int32 i;
-	Scase *cas;
-
-	i = sel->ncase;
-	if(i >= sel->tcase)
-		runtime·throw("selectdefault: too many cases");
-	sel->ncase = i+1;
-	cas = &sel->scase[i];
-	cas->pc = callerpc;
-	cas->chan = nil;
-
-	cas->so = so;
-	cas->kind = CaseDefault;
-
-	if(debug)
-		runtime·printf("selectdefault s=%p pc=%p so=%d\n",
-			sel, cas->pc, cas->so);
-}
-
-static void
-sellock(Select *sel)
-{
-	uint32 i;
-	Hchan *c, *c0;
-
-	c = nil;
-	for(i=0; i<sel->ncase; i++) {
-		c0 = sel->lockorder[i];
-		if(c0 && c0 != c) {
-			c = sel->lockorder[i];
-			runtime·lock(&c->lock);
-		}
-	}
-}
-
-static void
-selunlock(Select *sel)
-{
-	int32 i, n, r;
-	Hchan *c;
-
-	// We must be very careful here to not touch sel after we have unlocked
-	// the last lock, because sel can be freed right after the last unlock.
-	// Consider the following situation.
-	// First M calls runtime·park() in runtime·selectgo() passing the sel.
-	// Once runtime·park() has unlocked the last lock, another M makes
-	// the G that calls select runnable again and schedules it for execution.
-	// When the G runs on another M, it locks all the locks and frees sel.
-	// Now if the first M touches sel, it will access freed memory.
-	n = (int32)sel->ncase;
-	r = 0;
-	// skip the default case
-	if(n>0 && sel->lockorder[0] == nil)
-		r = 1;
-	for(i = n-1; i >= r; i--) {
-		c = sel->lockorder[i];
-		if(i>0 && sel->lockorder[i-1] == c)
-			continue;  // will unlock it on the next iteration
-		runtime·unlock(&c->lock);
-	}
-}
-
-static bool
-selparkcommit(G *gp, void *sel)
-{
-	USED(gp);
-	selunlock(sel);
-	return true;
-}
-
-func block() {
-	runtime·park(nil, nil, runtime·gostringnocopy((byte*)"select (no cases)"));	// forever
-}
-
-static void* selectgo(Select**);
-
-// selectgo(sel *byte);
-//
-// overwrites return pc on stack to signal which case of the select
-// to run, so cannot appear at the top of a split stack.
-#pragma textflag NOSPLIT
-func selectgo(sel *Select) {
-	runtime·setcallerpc(&sel, selectgo(&sel));
-}
-
-static void*
-selectgo(Select **selp)
-{
-	Select *sel;
-	uint32 o, i, j, k, done;
-	int64 t0;
-	Scase *cas, *dfl;
-	Hchan *c;
-	SudoG *sg;
-	G *gp;
-	byte *as;
-	void *pc;
-	extern uint64 runtime·blockprofilerate;
-
-	sel = *selp;
-
-	if(debug)
-		runtime·printf("select: sel=%p\n", sel);
-
-	t0 = 0;
-	if(runtime·blockprofilerate > 0) {
-		t0 = runtime·cputicks();
-		for(i=0; i<sel->ncase; i++)
-			sel->scase[i].sg.releasetime = -1;
-	}
-
-	// The compiler rewrites selects that statically have
-	// only 0 or 1 cases plus default into simpler constructs.
-	// The only way we can end up with such small sel->ncase
-	// values here is for a larger select in which most channels
-	// have been nilled out.  The general code handles those
-	// cases correctly, and they are rare enough not to bother
-	// optimizing (and needing to test).
-
-	// generate permuted order
-	for(i=0; i<sel->ncase; i++)
-		sel->pollorder[i] = i;
-	for(i=1; i<sel->ncase; i++) {
-		o = sel->pollorder[i];
-		j = runtime·fastrand1()%(i+1);
-		sel->pollorder[i] = sel->pollorder[j];
-		sel->pollorder[j] = o;
-	}
-
-	// sort the cases by Hchan address to get the locking order.
-	// simple heap sort, to guarantee n log n time and constant stack footprint.
-	for(i=0; i<sel->ncase; i++) {
-		j = i;
-		c = sel->scase[j].chan;
-		while(j > 0 && sel->lockorder[k=(j-1)/2] < c) {
-			sel->lockorder[j] = sel->lockorder[k];
-			j = k;
-		}
-		sel->lockorder[j] = c;
-	}
-	for(i=sel->ncase; i-->0; ) {
-		c = sel->lockorder[i];
-		sel->lockorder[i] = sel->lockorder[0];
-		j = 0;
-		for(;;) {
-			k = j*2+1;
-			if(k >= i)
-				break;
-			if(k+1 < i && sel->lockorder[k] < sel->lockorder[k+1])
-				k++;
-			if(c < sel->lockorder[k]) {
-				sel->lockorder[j] = sel->lockorder[k];
-				j = k;
-				continue;
-			}
-			break;
-		}
-		sel->lockorder[j] = c;
-	}
-	/*
-	for(i=0; i+1<sel->ncase; i++)
-		if(sel->lockorder[i] > sel->lockorder[i+1]) {
-			runtime·printf("i=%d %p %p\n", i, sel->lockorder[i], sel->lockorder[i+1]);
-			runtime·throw("select: broken sort");
-		}
-	*/
-	sellock(sel);
-
-loop:
-	// pass 1 - look for something already waiting
-	dfl = nil;
-	for(i=0; i<sel->ncase; i++) {
-		o = sel->pollorder[i];
-		cas = &sel->scase[o];
-		c = cas->chan;
-
-		switch(cas->kind) {
-		case CaseRecv:
-			if(c->dataqsiz > 0) {
-				if(c->qcount > 0)
-					goto asyncrecv;
-			} else {
-				sg = dequeue(&c->sendq);
-				if(sg != nil)
-					goto syncrecv;
-			}
-			if(c->closed)
-				goto rclose;
-			break;
-
-		case CaseSend:
-			if(raceenabled)
-				runtime·racereadpc(c, cas->pc, &runtime·chansend);
-			if(c->closed)
-				goto sclose;
-			if(c->dataqsiz > 0) {
-				if(c->qcount < c->dataqsiz)
-					goto asyncsend;
-			} else {
-				sg = dequeue(&c->recvq);
-				if(sg != nil)
-					goto syncsend;
-			}
-			break;
-
-		case CaseDefault:
-			dfl = cas;
-			break;
-		}
-	}
-
-	if(dfl != nil) {
-		selunlock(sel);
-		cas = dfl;
-		goto retc;
-	}
-
-
-	// pass 2 - enqueue on all chans
-	done = 0;
-	for(i=0; i<sel->ncase; i++) {
-		o = sel->pollorder[i];
-		cas = &sel->scase[o];
-		c = cas->chan;
-		sg = &cas->sg;
-		sg->g = g;
-		sg->selectdone = &done;
-
-		switch(cas->kind) {
-		case CaseRecv:
-			enqueue(&c->recvq, sg);
-			break;
-
-		case CaseSend:
-			enqueue(&c->sendq, sg);
-			break;
-		}
-	}
-
-	g->param = nil;
-	runtime·park(selparkcommit, sel, runtime·gostringnocopy((byte*)"select"));
-
-	sellock(sel);
-	sg = g->param;
-
-	// pass 3 - dequeue from unsuccessful chans
-	// otherwise they stack up on quiet channels
-	for(i=0; i<sel->ncase; i++) {
-		cas = &sel->scase[i];
-		if(cas != (Scase*)sg) {
-			c = cas->chan;
-			if(cas->kind == CaseSend)
-				dequeueg(&c->sendq);
-			else
-				dequeueg(&c->recvq);
-		}
-	}
-
-	if(sg == nil)
-		goto loop;
-
-	cas = (Scase*)sg;
-	c = cas->chan;
-
-	if(c->dataqsiz > 0)
-		runtime·throw("selectgo: shouldn't happen");
-
-	if(debug)
-		runtime·printf("wait-return: sel=%p c=%p cas=%p kind=%d\n",
-			sel, c, cas, cas->kind);
-
-	if(cas->kind == CaseRecv) {
-		if(cas->receivedp != nil)
-			*cas->receivedp = true;
-	}
-
-	if(raceenabled) {
-		if(cas->kind == CaseRecv && cas->sg.elem != nil)
-			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chanrecv);
-		else if(cas->kind == CaseSend)
-			runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chansend);
-	}
-
-	selunlock(sel);
-	goto retc;
-
-asyncrecv:
-	// can receive from buffer
-	if(raceenabled) {
-		if(cas->sg.elem != nil)
-			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chanrecv);
-		runtime·raceacquire(chanbuf(c, c->recvx));
-		runtime·racerelease(chanbuf(c, c->recvx));
-	}
-	if(cas->receivedp != nil)
-		*cas->receivedp = true;
-	if(cas->sg.elem != nil)
-		runtime·memmove(cas->sg.elem, chanbuf(c, c->recvx), c->elemsize);
-	runtime·memclr(chanbuf(c, c->recvx), c->elemsize);
-	if(++c->recvx == c->dataqsiz)
-		c->recvx = 0;
-	c->qcount--;
-	sg = dequeue(&c->sendq);
-	if(sg != nil) {
-		gp = sg->g;
-		selunlock(sel);
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-	} else {
-		selunlock(sel);
-	}
-	goto retc;
-
-asyncsend:
-	// can send to buffer
-	if(raceenabled) {
-		runtime·raceacquire(chanbuf(c, c->sendx));
-		runtime·racerelease(chanbuf(c, c->sendx));
-		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chansend);
-	}
-	runtime·memmove(chanbuf(c, c->sendx), cas->sg.elem, c->elemsize);
-	if(++c->sendx == c->dataqsiz)
-		c->sendx = 0;
-	c->qcount++;
-	sg = dequeue(&c->recvq);
-	if(sg != nil) {
-		gp = sg->g;
-		selunlock(sel);
-		if(sg->releasetime)
-			sg->releasetime = runtime·cputicks();
-		runtime·ready(gp);
-	} else {
-		selunlock(sel);
-	}
-	goto retc;
-
-syncrecv:
-	// can receive from sleeping sender (sg)
-	if(raceenabled) {
-		if(cas->sg.elem != nil)
-			runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chanrecv);
-		racesync(c, sg);
-	}
-	selunlock(sel);
-	if(debug)
-		runtime·printf("syncrecv: sel=%p c=%p o=%d\n", sel, c, o);
-	if(cas->receivedp != nil)
-		*cas->receivedp = true;
-	if(cas->sg.elem != nil)
-		runtime·memmove(cas->sg.elem, sg->elem, c->elemsize);
-	gp = sg->g;
-	gp->param = sg;
-	if(sg->releasetime)
-		sg->releasetime = runtime·cputicks();
-	runtime·ready(gp);
-	goto retc;
-
-rclose:
-	// read at end of closed channel
-	selunlock(sel);
-	if(cas->receivedp != nil)
-		*cas->receivedp = false;
-	if(cas->sg.elem != nil)
-		runtime·memclr(cas->sg.elem, c->elemsize);
-	if(raceenabled)
-		runtime·raceacquire(c);
-	goto retc;
-
-syncsend:
-	// can send to sleeping receiver (sg)
-	if(raceenabled) {
-		runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, &runtime·chansend);
-		racesync(c, sg);
-	}
-	selunlock(sel);
-	if(debug)
-		runtime·printf("syncsend: sel=%p c=%p o=%d\n", sel, c, o);
-	if(sg->elem != nil)
-		runtime·memmove(sg->elem, cas->sg.elem, c->elemsize);
-	gp = sg->g;
-	gp->param = sg;
-	if(sg->releasetime)
-		sg->releasetime = runtime·cputicks();
-	runtime·ready(gp);
-
-retc:
-	// return pc corresponding to chosen case.
-	// Set boolean passed during select creation
-	// (at offset selp + cas->so) to true.
-	// If cas->so == 0, this is a reflect-driven select and we
-	// don't need to update the boolean.
-	pc = cas->pc;
-	if(cas->so > 0) {
-		as = (byte*)selp + cas->so;
-		*as = true;
-	}
-	if(cas->sg.releasetime > 0)
-		runtime·blockevent(cas->sg.releasetime - t0, 2);
-	return pc;
-
-sclose:
-	// send on closed channel
-	selunlock(sel);
-	runtime·panicstring("send on closed channel");
-	return nil;  // not reached
-}
-
-// This struct must match ../reflect/value.go:/runtimeSelect.
-typedef struct runtimeSelect runtimeSelect;
-struct runtimeSelect
-{
-	uintptr dir;
-	ChanType *typ;
-	Hchan *ch;
-	byte *val;
-};
-
-// This enum must match ../reflect/value.go:/SelectDir.
-enum SelectDir {
-	SelectSend = 1,
-	SelectRecv,
-	SelectDefault,
-};
-
-func reflect·rselect(cases Slice) (chosen int, recvOK bool) {
-	int32 i;
-	Select *sel;
-	runtimeSelect* rcase, *rc;
-
-	chosen = -1;
-	recvOK = false;
-
-	rcase = (runtimeSelect*)cases.array;
-
-	// FlagNoScan is safe here, because all objects are also referenced from cases.
-	sel = runtime·mallocgc(selectsize(cases.len), 0, FlagNoScan);
-	runtime·newselect(sel, selectsize(cases.len), cases.len);
-	for(i=0; i<cases.len; i++) {
-		rc = &rcase[i];
-		switch(rc->dir) {
-		case SelectDefault:
-			selectdefault(sel, (void*)i, 0);
-			break;
-		case SelectSend:
-			if(rc->ch == nil)
-				break;
-			selectsend(sel, rc->ch, (void*)i, rc->val, 0);
-			break;
-		case SelectRecv:
-			if(rc->ch == nil)
-				break;
-			selectrecv(sel, rc->ch, (void*)i, rc->val, &recvOK, 0);
-			break;
-		}
-	}
-
-	chosen = (intgo)(uintptr)selectgo(&sel);
-}
-
-static SudoG*
-dequeue(WaitQ *q)
-{
-	SudoG *sgp;
-
-loop:
-	sgp = q->first;
-	if(sgp == nil)
-		return nil;
-	q->first = sgp->next;
-	if(q->last == sgp)
-		q->last = nil;
-
-	// if sgp participates in a select and is already signaled, ignore it
-	if(sgp->selectdone != nil) {
-		// claim the right to signal
-		if(*sgp->selectdone != 0 || !runtime·cas(sgp->selectdone, 0, 1))
-			goto loop;
-	}
-
-	return sgp;
-}
-
-static void
-dequeueg(WaitQ *q)
-{
-	SudoG **l, *sgp, *prevsgp;
-
-	prevsgp = nil;
-	for(l=&q->first; (sgp=*l) != nil; l=&sgp->next, prevsgp=sgp) {
-		if(sgp->g == g) {
-			*l = sgp->next;
-			if(q->last == sgp)
-				q->last = prevsgp;
-			break;
-		}
-	}
-}
-
-static void
-enqueue(WaitQ *q, SudoG *sgp)
-{
-	sgp->next = nil;
-	if(q->first == nil) {
-		q->first = sgp;
-		q->last = sgp;
-		return;
-	}
-	q->last->next = sgp;
-	q->last = sgp;
-}
-
-static void
-racesync(Hchan *c, SudoG *sg)
-{
-	runtime·racerelease(chanbuf(c, 0));
-	runtime·raceacquireg(sg->g, chanbuf(c, 0));
-	runtime·racereleaseg(sg->g, chanbuf(c, 0));
-	runtime·raceacquire(chanbuf(c, 0));
-}
diff --git a/src/pkg/runtime/chan.h b/src/pkg/runtime/chan.h
index a439fa7c9a..c34ff1533d 100644
--- a/src/pkg/runtime/chan.h
+++ b/src/pkg/runtime/chan.h
@@ -47,12 +47,13 @@ enum
 // Changes here must also be made in src/cmd/gc/select.c's selecttype.
 struct	Scase
 {
-	SudoG	sg;			// must be first member (cast to Scase)
+	void*	elem;			// data element
 	Hchan*	chan;			// chan
-	byte*	pc;			// return pc
+	uintptr	pc;			// return pc
 	uint16	kind;
 	uint16	so;			// vararg of selected bool
 	bool*	receivedp;		// pointer to received bool (recv2)
+	int64	releasetime;
 };
 
 // Known to compiler.
diff --git a/src/pkg/runtime/pprof/pprof_test.go b/src/pkg/runtime/pprof/pprof_test.go
index dd8f2d0529..df271273ce 100644
--- a/src/pkg/runtime/pprof/pprof_test.go
+++ b/src/pkg/runtime/pprof/pprof_test.go
@@ -328,13 +328,13 @@ func TestBlockProfile(t *testing.T) {
 `},
 		{"select recv async", blockSelectRecvAsync, `
 [0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime\.selectgo\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.goc:[0-9]+
+#	0x[0-9,a-f]+	runtime\.selectgo\+0x[0-9,a-f]+	.*/src/pkg/runtime/select.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.blockSelectRecvAsync\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 `},
 		{"select send sync", blockSelectSendSync, `
 [0-9]+ [0-9]+ @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
-#	0x[0-9,a-f]+	runtime\.selectgo\+0x[0-9,a-f]+	.*/src/pkg/runtime/chan.goc:[0-9]+
+#	0x[0-9,a-f]+	runtime\.selectgo\+0x[0-9,a-f]+	.*/src/pkg/runtime/select.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.blockSelectSendSync\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 #	0x[0-9,a-f]+	runtime/pprof_test\.TestBlockProfile\+0x[0-9,a-f]+	.*/src/pkg/runtime/pprof/pprof_test.go:[0-9]+
 `},
diff --git a/src/pkg/runtime/race.go b/src/pkg/runtime/race.go
index 3707549a3f..df8493e35c 100644
--- a/src/pkg/runtime/race.go
+++ b/src/pkg/runtime/race.go
@@ -45,3 +45,16 @@ func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 		racereadpc(addr, callerpc, pc)
 	}
 }
+
+func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
+	kind := t.kind & kindMask
+	if kind == kindArray || kind == kindStruct {
+		// for composite objects we have to write every address
+		// because a write might happen to any subobject.
+		racewriterangepc(addr, int(t.size), callerpc, pc)
+	} else {
+		// for non-composite objects we can write just the start
+		// address, as any write must write the first byte.
+		racewritepc(addr, callerpc, pc)
+	}
+}
diff --git a/src/pkg/runtime/race0.go b/src/pkg/runtime/race0.go
index f228c6d7b4..2e67ae6a50 100644
--- a/src/pkg/runtime/race0.go
+++ b/src/pkg/runtime/race0.go
@@ -16,3 +16,5 @@ const raceenabled = false
 
 func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 }
+func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
+}
diff --git a/src/pkg/runtime/select.go b/src/pkg/runtime/select.go
new file mode 100644
index 0000000000..31976cd6f8
--- /dev/null
+++ b/src/pkg/runtime/select.go
@@ -0,0 +1,645 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+// This file contains the implementation of Go select statements.
+
+import "unsafe"
+
+const (
+	debugSelect = false
+)
+
+var (
+	chansendpc uintptr
+	chanrecvpc uintptr
+)
+
+func init() {
+	f := chansend
+	chansendpc = **(**uintptr)(unsafe.Pointer(&f))
+	g := chanrecv
+	chanrecvpc = **(**uintptr)(unsafe.Pointer(&g))
+}
+
+func selectsize(size uintptr) uintptr {
+	selsize := unsafe.Sizeof(_select{}) +
+		(size-1)*unsafe.Sizeof(_select{}.scase[0]) +
+		size*unsafe.Sizeof(*_select{}.lockorder) +
+		size*unsafe.Sizeof(*_select{}.pollorder)
+	return round(selsize, _Int64Align)
+}
+
+func newselect(sel *_select, selsize int64, size int32) {
+	if selsize != int64(selectsize(uintptr(size))) {
+		print("runtime: bad select size ", selsize, ", want ", selectsize(uintptr(size)), "\n")
+		gothrow("bad select size")
+	}
+	sel.tcase = uint16(size)
+	sel.ncase = 0
+	sel.lockorder = (**hchan)(add(unsafe.Pointer(&sel.scase), uintptr(size)*unsafe.Sizeof(_select{}.scase[0])))
+	sel.pollorder = (*uint16)(add(unsafe.Pointer(sel.lockorder), uintptr(size)*unsafe.Sizeof(*_select{}.lockorder)))
+
+	if debugSelect {
+		print("newselect s=", sel, " size=", size, "\n")
+	}
+}
+
+//go:nosplit
+func selectsend(sel *_select, c *hchan, elem unsafe.Pointer) (selected bool) {
+	// nil cases do not compete
+	if c != nil {
+		selectsendImpl(sel, c, getcallerpc(unsafe.Pointer(&sel)), elem, uintptr(unsafe.Pointer(&selected))-uintptr(unsafe.Pointer(&sel)))
+	}
+	return
+}
+
+// cut in half to give stack a chance to split
+func selectsendImpl(sel *_select, c *hchan, pc uintptr, elem unsafe.Pointer, so uintptr) {
+	i := sel.ncase
+	if i >= sel.tcase {
+		gothrow("selectsend: too many cases")
+	}
+	sel.ncase = i + 1
+	cas := (*scase)(add(unsafe.Pointer(&sel.scase), uintptr(i)*unsafe.Sizeof(sel.scase[0])))
+
+	cas.pc = pc
+	cas._chan = c
+	cas.so = uint16(so)
+	cas.kind = _CaseSend
+	cas.elem = elem
+
+	if debugSelect {
+		print("selectsend s=", sel, " pc=", hex(cas.pc), " chan=", cas._chan, " so=", cas.so, "\n")
+	}
+}
+
+//go:nosplit
+func selectrecv(sel *_select, c *hchan, elem unsafe.Pointer) (selected bool) {
+	// nil cases do not compete
+	if c != nil {
+		selectrecvImpl(sel, c, getcallerpc(unsafe.Pointer(&sel)), elem, nil, uintptr(unsafe.Pointer(&selected))-uintptr(unsafe.Pointer(&sel)))
+	}
+	return
+}
+
+//go:nosplit
+func selectrecv2(sel *_select, c *hchan, elem unsafe.Pointer, received *bool) (selected bool) {
+	// nil cases do not compete
+	if c != nil {
+		selectrecvImpl(sel, c, getcallerpc(unsafe.Pointer(&sel)), elem, received, uintptr(unsafe.Pointer(&selected))-uintptr(unsafe.Pointer(&sel)))
+	}
+	return
+}
+
+func selectrecvImpl(sel *_select, c *hchan, pc uintptr, elem unsafe.Pointer, received *bool, so uintptr) {
+	i := sel.ncase
+	if i >= sel.tcase {
+		gothrow("selectrecv: too many cases")
+	}
+	sel.ncase = i + 1
+	cas := (*scase)(add(unsafe.Pointer(&sel.scase), uintptr(i)*unsafe.Sizeof(sel.scase[0])))
+	cas.pc = pc
+	cas._chan = c
+	cas.so = uint16(so)
+	cas.kind = _CaseRecv
+	cas.elem = elem
+	cas.receivedp = received
+
+	if debugSelect {
+		print("selectrecv s=", sel, " pc=", hex(cas.pc), " chan=", cas._chan, " so=", cas.so, "\n")
+	}
+}
+
+//go:nosplit
+func selectdefault(sel *_select) (selected bool) {
+	selectdefaultImpl(sel, getcallerpc(unsafe.Pointer(&sel)), uintptr(unsafe.Pointer(&selected))-uintptr(unsafe.Pointer(&sel)))
+	return
+}
+
+func selectdefaultImpl(sel *_select, callerpc uintptr, so uintptr) {
+	i := sel.ncase
+	if i >= sel.tcase {
+		gothrow("selectdefault: too many cases")
+	}
+	sel.ncase = i + 1
+	cas := (*scase)(add(unsafe.Pointer(&sel.scase), uintptr(i)*unsafe.Sizeof(sel.scase[0])))
+	cas.pc = callerpc
+	cas._chan = nil
+	cas.so = uint16(so)
+	cas.kind = _CaseDefault
+
+	if debugSelect {
+		print("selectdefault s=", sel, " pc=", hex(cas.pc), " so=", cas.so, "\n")
+	}
+}
+
+func sellock(sel *_select) {
+	lockslice := sliceStruct{unsafe.Pointer(sel.lockorder), int(sel.ncase), int(sel.ncase)}
+	lockorder := *(*[]*hchan)(unsafe.Pointer(&lockslice))
+	var c *hchan
+	for _, c0 := range lockorder {
+		if c0 != nil && c0 != c {
+			c = c0
+			lock(&c.lock)
+		}
+	}
+}
+
+func selunlock(sel *_select) {
+	// We must be very careful here to not touch sel after we have unlocked
+	// the last lock, because sel can be freed right after the last unlock.
+	// Consider the following situation.
+	// First M calls runtime·park() in runtime·selectgo() passing the sel.
+	// Once runtime·park() has unlocked the last lock, another M makes
+	// the G that calls select runnable again and schedules it for execution.
+	// When the G runs on another M, it locks all the locks and frees sel.
+	// Now if the first M touches sel, it will access freed memory.
+	n := int(sel.ncase)
+	r := 0
+	lockslice := sliceStruct{unsafe.Pointer(sel.lockorder), n, n}
+	lockorder := *(*[]*hchan)(unsafe.Pointer(&lockslice))
+	// skip the default case
+	if n > 0 && lockorder[0] == nil {
+		r = 1
+	}
+	for i := n - 1; i >= r; i-- {
+		c := lockorder[i]
+		if i > 0 && c == lockorder[i-1] {
+			continue // will unlock it on the next iteration
+		}
+		unlock(&c.lock)
+	}
+}
+
+func selparkcommit(gp *g, sel *_select) bool {
+	selunlock(sel)
+	return true
+}
+
+func block() {
+	gopark(nil, nil, "select (no cases)") // forever
+}
+
+// overwrites return pc on stack to signal which case of the select
+// to run, so cannot appear at the top of a split stack.
+//go:nosplit
+func selectgo(sel *_select) {
+	pc, offset := selectgoImpl(sel)
+	*(*bool)(add(unsafe.Pointer(&sel), uintptr(offset))) = true
+	setcallerpc(unsafe.Pointer(&sel), pc)
+}
+
+// selectgoImpl returns scase.pc and scase.so for the select
+// case which fired.
+func selectgoImpl(sel *_select) (uintptr, uint16) {
+	if debugSelect {
+		print("select: sel=", sel, "\n")
+	}
+
+	scaseslice := sliceStruct{unsafe.Pointer(&sel.scase), int(sel.ncase), int(sel.ncase)}
+	scases := *(*[]scase)(unsafe.Pointer(&scaseslice))
+
+	var t0 int64
+	if blockprofilerate > 0 {
+		t0 = cputicks()
+		for i := 0; i < int(sel.ncase); i++ {
+			scases[i].releasetime = -1
+		}
+	}
+
+	// The compiler rewrites selects that statically have
+	// only 0 or 1 cases plus default into simpler constructs.
+	// The only way we can end up with such small sel.ncase
+	// values here is for a larger select in which most channels
+	// have been nilled out.  The general code handles those
+	// cases correctly, and they are rare enough not to bother
+	// optimizing (and needing to test).
+
+	// generate permuted order
+	pollslice := sliceStruct{unsafe.Pointer(sel.pollorder), int(sel.ncase), int(sel.ncase)}
+	pollorder := *(*[]uint16)(unsafe.Pointer(&pollslice))
+	for i := 0; i < int(sel.ncase); i++ {
+		pollorder[i] = uint16(i)
+	}
+	for i := 1; i < int(sel.ncase); i++ {
+		o := pollorder[i]
+		j := int(fastrand2()) % (i + 1)
+		pollorder[i] = pollorder[j]
+		pollorder[j] = o
+	}
+
+	// sort the cases by Hchan address to get the locking order.
+	// simple heap sort, to guarantee n log n time and constant stack footprint.
+	lockslice := sliceStruct{unsafe.Pointer(sel.lockorder), int(sel.ncase), int(sel.ncase)}
+	lockorder := *(*[]*hchan)(unsafe.Pointer(&lockslice))
+	for i := 0; i < int(sel.ncase); i++ {
+		j := i
+		c := scases[j]._chan
+		for j > 0 && lockorder[(j-1)/2].sortkey() < c.sortkey() {
+			k := (j - 1) / 2
+			lockorder[j] = lockorder[k]
+			j = k
+		}
+		lockorder[j] = c
+	}
+	for i := int(sel.ncase) - 1; i >= 0; i-- {
+		c := lockorder[i]
+		lockorder[i] = lockorder[0]
+		j := 0
+		for {
+			k := j*2 + 1
+			if k >= i {
+				break
+			}
+			if k+1 < i && lockorder[k].sortkey() < lockorder[k+1].sortkey() {
+				k++
+			}
+			if c.sortkey() < lockorder[k].sortkey() {
+				lockorder[j] = lockorder[k]
+				j = k
+				continue
+			}
+			break
+		}
+		lockorder[j] = c
+	}
+	/*
+		for i := 0; i+1 < int(sel.ncase); i++ {
+			if lockorder[i].sortkey() > lockorder[i+1].sortkey() {
+				print("i=", i, " x=", lockorder[i], " y=", lockorder[i+1], "\n")
+				gothrow("select: broken sort")
+			}
+		}
+	*/
+
+	// lock all the channels involved in the select
+	sellock(sel)
+
+	var (
+		gp     *g
+		done   uint32
+		sg     *sudog
+		c      *hchan
+		k      *scase
+		sglist *sudog
+		sgnext *sudog
+		fn     func(*g, *_select) bool
+	)
+
+loop:
+	// pass 1 - look for something already waiting
+	var dfl *scase
+	var cas *scase
+	for i := 0; i < int(sel.ncase); i++ {
+		cas = &scases[pollorder[i]]
+		c = cas._chan
+
+		switch cas.kind {
+		case _CaseRecv:
+			if c.dataqsiz > 0 {
+				if c.qcount > 0 {
+					goto asyncrecv
+				}
+			} else {
+				sg = c.sendq.dequeue()
+				if sg != nil {
+					goto syncrecv
+				}
+			}
+			if c.closed != 0 {
+				goto rclose
+			}
+
+		case _CaseSend:
+			if raceenabled {
+				racereadpc(unsafe.Pointer(c), cas.pc, chansendpc)
+			}
+			if c.closed != 0 {
+				goto sclose
+			}
+			if c.dataqsiz > 0 {
+				if c.qcount < c.dataqsiz {
+					goto asyncsend
+				}
+			} else {
+				sg = c.recvq.dequeue()
+				if sg != nil {
+					goto syncsend
+				}
+			}
+
+		case _CaseDefault:
+			dfl = cas
+		}
+	}
+
+	if dfl != nil {
+		selunlock(sel)
+		cas = dfl
+		goto retc
+	}
+
+	// pass 2 - enqueue on all chans
+	gp = getg()
+	done = 0
+	for i := 0; i < int(sel.ncase); i++ {
+		cas = &scases[pollorder[i]]
+		c = cas._chan
+		sg := acquireSudog()
+		sg.g = gp
+		// Note: selectdone is adjusted for stack copies in stack.c:adjustsudogs
+		sg.selectdone = (*uint32)(noescape(unsafe.Pointer(&done)))
+		sg.elem = cas.elem
+		sg.releasetime = 0
+		if t0 != 0 {
+			sg.releasetime = -1
+		}
+		sg.waitlink = gp.waiting
+		gp.waiting = sg
+
+		switch cas.kind {
+		case _CaseRecv:
+			c.recvq.enqueue(sg)
+
+		case _CaseSend:
+			c.sendq.enqueue(sg)
+		}
+	}
+
+	// wait for someone to wake us up
+	gp.param = nil
+	fn = selparkcommit
+	gopark(**(**unsafe.Pointer)(unsafe.Pointer(&fn)), unsafe.Pointer(sel), "select")
+
+	// someone woke us up
+	sellock(sel)
+	sg = (*sudog)(gp.param)
+
+	// pass 3 - dequeue from unsuccessful chans
+	// otherwise they stack up on quiet channels
+	// record the successful case, if any.
+	// We singly-linked up the SudoGs in case order, so when
+	// iterating through the linked list they are in reverse order.
+	cas = nil
+	sglist = gp.waiting
+	gp.waiting = nil
+	for i := int(sel.ncase) - 1; i >= 0; i-- {
+		k = &scases[pollorder[i]]
+		if sglist.releasetime > 0 {
+			k.releasetime = sglist.releasetime
+		}
+		if sg == sglist {
+			cas = k
+		} else {
+			c = k._chan
+			if k.kind == _CaseSend {
+				c.sendq.dequeueg(gp)
+			} else {
+				c.recvq.dequeueg(gp)
+			}
+		}
+		sgnext = sglist.waitlink
+		releaseSudog(sglist)
+		sglist = sgnext
+	}
+
+	if cas == nil {
+		goto loop
+	}
+
+	c = cas._chan
+
+	if c.dataqsiz > 0 {
+		gothrow("selectgo: shouldn't happen")
+	}
+
+	if debugSelect {
+		print("wait-return: sel=", sel, " c=", c, " cas=", cas, " kind=", cas.kind, "\n")
+	}
+
+	if cas.kind == _CaseRecv {
+		if cas.receivedp != nil {
+			*cas.receivedp = true
+		}
+	}
+
+	if raceenabled {
+		if cas.kind == _CaseRecv && cas.elem != nil {
+			raceWriteObjectPC(c.elemtype, cas.elem, cas.pc, chanrecvpc)
+		} else if cas.kind == _CaseSend {
+			raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
+		}
+	}
+
+	selunlock(sel)
+	goto retc
+
+asyncrecv:
+	// can receive from buffer
+	if raceenabled {
+		if cas.elem != nil {
+			raceWriteObjectPC(c.elemtype, cas.elem, cas.pc, chanrecvpc)
+		}
+		raceacquire(chanbuf(c, c.recvx))
+		racerelease(chanbuf(c, c.recvx))
+	}
+	if cas.receivedp != nil {
+		*cas.receivedp = true
+	}
+	if cas.elem != nil {
+		memmove(cas.elem, chanbuf(c, c.recvx), uintptr(c.elemsize))
+	}
+	memclr(chanbuf(c, c.recvx), uintptr(c.elemsize))
+	c.recvx++
+	if c.recvx == c.dataqsiz {
+		c.recvx = 0
+	}
+	c.qcount--
+	sg = c.sendq.dequeue()
+	if sg != nil {
+		gp = sg.g
+		selunlock(sel)
+		if sg.releasetime != 0 {
+			sg.releasetime = cputicks()
+		}
+		goready(gp)
+	} else {
+		selunlock(sel)
+	}
+	goto retc
+
+asyncsend:
+	// can send to buffer
+	if raceenabled {
+		raceacquire(chanbuf(c, c.sendx))
+		racerelease(chanbuf(c, c.sendx))
+		raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
+	}
+	memmove(chanbuf(c, c.sendx), cas.elem, uintptr(c.elemsize))
+	c.sendx++
+	if c.sendx == c.dataqsiz {
+		c.sendx = 0
+	}
+	c.qcount++
+	sg = c.recvq.dequeue()
+	if sg != nil {
+		gp = sg.g
+		selunlock(sel)
+		if sg.releasetime != 0 {
+			sg.releasetime = cputicks()
+		}
+		goready(gp)
+	} else {
+		selunlock(sel)
+	}
+	goto retc
+
+syncrecv:
+	// can receive from sleeping sender (sg)
+	if raceenabled {
+		if cas.elem != nil {
+			raceWriteObjectPC(c.elemtype, cas.elem, cas.pc, chanrecvpc)
+		}
+		racesync(c, sg)
+	}
+	selunlock(sel)
+	if debugSelect {
+		print("syncrecv: sel=", sel, " c=", c, "\n")
+	}
+	if cas.receivedp != nil {
+		*cas.receivedp = true
+	}
+	if cas.elem != nil {
+		memmove(cas.elem, sg.elem, uintptr(c.elemsize))
+	}
+	gp = sg.g
+	gp.param = unsafe.Pointer(sg)
+	if sg.releasetime != 0 {
+		sg.releasetime = cputicks()
+	}
+	goready(gp)
+	goto retc
+
+rclose:
+	// read at end of closed channel
+	selunlock(sel)
+	if cas.receivedp != nil {
+		*cas.receivedp = false
+	}
+	if cas.elem != nil {
+		memclr(cas.elem, uintptr(c.elemsize))
+	}
+	if raceenabled {
+		raceacquire(unsafe.Pointer(c))
+	}
+	goto retc
+
+syncsend:
+	// can send to sleeping receiver (sg)
+	if raceenabled {
+		raceReadObjectPC(c.elemtype, cas.elem, cas.pc, chansendpc)
+		racesync(c, sg)
+	}
+	selunlock(sel)
+	if debugSelect {
+		print("syncsend: sel=", sel, " c=", c, "\n")
+	}
+	if sg.elem != nil {
+		memmove(sg.elem, cas.elem, uintptr(c.elemsize))
+	}
+	gp = sg.g
+	gp.param = unsafe.Pointer(sg)
+	if sg.releasetime != 0 {
+		sg.releasetime = cputicks()
+	}
+	goready(gp)
+
+retc:
+	if cas.releasetime > 0 {
+		blockevent(cas.releasetime-t0, 2)
+	}
+	return cas.pc, cas.so
+
+sclose:
+	// send on closed channel
+	selunlock(sel)
+	panic("send on closed channel")
+}
+
+func (c *hchan) sortkey() uintptr {
+	// TODO(khr): if we have a moving garbage collector, we'll need to
+	// change this function.
+	return uintptr(unsafe.Pointer(c))
+}
+
+// A runtimeSelect is a single case passed to rselect.
+// This must match ../reflect/value.go:/runtimeSelect
+type runtimeSelect struct {
+	dir selectDir
+	typ unsafe.Pointer // channel type (not used here)
+	ch  *hchan         // channel
+	val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
+}
+
+// These values must match ../reflect/value.go:/SelectDir.
+type selectDir int
+
+const (
+	_             selectDir = iota
+	selectSend              // case Chan <- Send
+	selectRecv              // case <-Chan:
+	selectDefault           // default
+)
+
+func reflect_rselect(cases []runtimeSelect) (chosen int, recvOK bool) {
+	// flagNoScan is safe here, because all objects are also referenced from cases.
+	size := selectsize(uintptr(len(cases)))
+	sel := (*_select)(gomallocgc(size, nil, flagNoScan))
+	newselect(sel, int64(size), int32(len(cases)))
+	r := new(bool)
+	for i := range cases {
+		rc := &cases[i]
+		switch rc.dir {
+		case selectDefault:
+			selectdefaultImpl(sel, uintptr(i), 0)
+		case selectSend:
+			if rc.ch == nil {
+				break
+			}
+			selectsendImpl(sel, rc.ch, uintptr(i), rc.val, 0)
+		case selectRecv:
+			if rc.ch == nil {
+				break
+			}
+			selectrecvImpl(sel, rc.ch, uintptr(i), rc.val, r, 0)
+		}
+	}
+
+	pc, _ := selectgoImpl(sel)
+	chosen = int(pc)
+	recvOK = *r
+	return
+}
+
+func (q *waitq) dequeueg(gp *g) {
+	var prevsgp *sudog
+	l := &q.first
+	for {
+		sgp := *l
+		if sgp == nil {
+			return
+		}
+		if sgp.g == gp {
+			*l = sgp.next
+			if q.last == sgp {
+				q.last = prevsgp
+			}
+			return
+		}
+		l = &sgp.next
+		prevsgp = sgp
+	}
+}
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 1f51e667f2..62ec5993a8 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -764,6 +764,9 @@ adjustsudogs(G *gp, AdjustInfo *adjinfo)
 		e = s->elem;
 		if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
 			s->elem = e + adjinfo->delta;
+		e = (byte*)s->selectdone;
+		if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
+			s->selectdone = (uint32*)(e + adjinfo->delta);
 	}
 }
 
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index eaba5e1489..048b7a7236 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -115,3 +115,6 @@ TEXT reflect·unsafe_NewArray(SB),NOSPLIT,$0-0
 
 TEXT reflect·makechan(SB),NOSPLIT,$0-0
 	JMP	runtime·makechan(SB)
+
+TEXT reflect·rselect(SB), NOSPLIT, $0-0
+	JMP	runtime·reflect_rselect(SB)

From 3306d119b07e5b8b51a8ee5502bec859e62a5835 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Tue, 2 Sep 2014 14:33:33 -0700
Subject: [PATCH 341/423] runtime: unify fastrand1 and fastrand2

C and Go calling conventions are now compatible, so we
don't need two versions of this function.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/139080043
---
 src/pkg/runtime/alg.go         |  4 ++--
 src/pkg/runtime/asm_386.s      |  2 +-
 src/pkg/runtime/asm_amd64.s    |  2 +-
 src/pkg/runtime/asm_amd64p32.s |  2 +-
 src/pkg/runtime/asm_arm.s      |  2 +-
 src/pkg/runtime/hashmap.go     |  4 ++--
 src/pkg/runtime/malloc.go      |  2 +-
 src/pkg/runtime/runtime.c      | 13 -------------
 src/pkg/runtime/select.go      |  2 +-
 src/pkg/runtime/stubs.go       |  3 ---
 10 files changed, 10 insertions(+), 26 deletions(-)

diff --git a/src/pkg/runtime/alg.go b/src/pkg/runtime/alg.go
index 01fbc931e5..e9ed59503f 100644
--- a/src/pkg/runtime/alg.go
+++ b/src/pkg/runtime/alg.go
@@ -111,7 +111,7 @@ func f32hash(p unsafe.Pointer, s, h uintptr) uintptr {
 	case f == 0:
 		return c1 * (c0 ^ h) // +0, -0
 	case f != f:
-		return c1 * (c0 ^ h ^ uintptr(fastrand2())) // any kind of NaN
+		return c1 * (c0 ^ h ^ uintptr(fastrand1())) // any kind of NaN
 	default:
 		return memhash(p, 4, h)
 	}
@@ -123,7 +123,7 @@ func f64hash(p unsafe.Pointer, s, h uintptr) uintptr {
 	case f == 0:
 		return c1 * (c0 ^ h) // +0, -0
 	case f != f:
-		return c1 * (c0 ^ h ^ uintptr(fastrand2())) // any kind of NaN
+		return c1 * (c0 ^ h ^ uintptr(fastrand1())) // any kind of NaN
 	default:
 		return memhash(p, 8, h)
 	}
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 35805d63c6..681a1b6819 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -2283,7 +2283,7 @@ TEXT runtime·duffcopy(SB), NOSPLIT, $0-0
 TEXT runtime·timenow(SB), NOSPLIT, $0-0
 	JMP	time·now(SB)
 
-TEXT runtime·fastrand2(SB), NOSPLIT, $0-4
+TEXT runtime·fastrand1(SB), NOSPLIT, $0-4
 	get_tls(CX)
 	MOVL	g(CX), AX
 	MOVL	g_m(AX), AX
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 07eec9ebb6..0121b7d865 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -2335,7 +2335,7 @@ TEXT runtime·duffcopy(SB), NOSPLIT, $0-0
 TEXT runtime·timenow(SB), NOSPLIT, $0-0
 	JMP	time·now(SB)
 
-TEXT runtime·fastrand2(SB), NOSPLIT, $0-4
+TEXT runtime·fastrand1(SB), NOSPLIT, $0-4
 	get_tls(CX)
 	MOVQ	g(CX), AX
 	MOVQ	g_m(AX), AX
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 76a6dc2300..03cf9bd444 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -1208,7 +1208,7 @@ eqret:
 TEXT runtime·timenow(SB), NOSPLIT, $0-0
 	JMP	time·now(SB)
 
-TEXT runtime·fastrand2(SB), NOSPLIT, $0-4
+TEXT runtime·fastrand1(SB), NOSPLIT, $0-4
 	get_tls(CX)
 	MOVL	g(CX), AX
 	MOVL	g_m(AX), AX
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 0e87df42b7..87ea974246 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -1259,7 +1259,7 @@ TEXT runtime·duffcopy(SB), NOSPLIT, $0-0
 	MOVW.P	R0, 4(R2)
 	RET
 
-TEXT runtime·fastrand2(SB), NOSPLIT, $-4-4
+TEXT runtime·fastrand1(SB), NOSPLIT, $-4-4
 	MOVW	g_m(g), R1
 	MOVW	m_fastrand(R1), R0
 	ADD.S	R0, R0
diff --git a/src/pkg/runtime/hashmap.go b/src/pkg/runtime/hashmap.go
index 309e26db96..1bdceab8bb 100644
--- a/src/pkg/runtime/hashmap.go
+++ b/src/pkg/runtime/hashmap.go
@@ -219,7 +219,7 @@ func makemap(t *maptype, hint int64) *hmap {
 	h.count = 0
 	h.B = B
 	h.flags = 0
-	h.hash0 = fastrand2()
+	h.hash0 = fastrand1()
 	h.buckets = buckets
 	h.oldbuckets = nil
 	h.nevacuate = 0
@@ -568,7 +568,7 @@ func mapiterinit(t *maptype, h *hmap, it *hiter) {
 
 	// iterator state
 	it.bucket = 0
-	it.offset = uint8(fastrand2() & (bucketCnt - 1))
+	it.offset = uint8(fastrand1() & (bucketCnt - 1))
 	it.done = false
 	it.bptr = nil
 
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 5b1825a04c..84587a36d6 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -387,7 +387,7 @@ func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
 		if rate > 0x3fffffff { // make 2*rate not overflow
 			rate = 0x3fffffff
 		}
-		next := int32(fastrand2()) % (2 * int32(rate))
+		next := int32(fastrand1()) % (2 * int32(rate))
 		// Subtract the "remainder" of the current allocation.
 		// Otherwise objects that are close in size to sampling rate
 		// will be under-sampled, because we consistently discard this remainder.
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 8bef7dc076..d4999e7465 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -265,19 +265,6 @@ runtime·check(void)
 		runtime·throw("FixedStack is not power-of-2");
 }
 
-uint32
-runtime·fastrand1(void)
-{
-	uint32 x;
-
-	x = g->m->fastrand;
-	x += x;
-	if(x & 0x80000000L)
-		x ^= 0x88888eefUL;
-	g->m->fastrand = x;
-	return x;
-}
-
 static Mutex ticksLock;
 static int64 ticks;
 
diff --git a/src/pkg/runtime/select.go b/src/pkg/runtime/select.go
index 31976cd6f8..dbe0543bf7 100644
--- a/src/pkg/runtime/select.go
+++ b/src/pkg/runtime/select.go
@@ -226,7 +226,7 @@ func selectgoImpl(sel *_select) (uintptr, uint16) {
 	}
 	for i := 1; i < int(sel.ncase); i++ {
 		o := pollorder[i]
-		j := int(fastrand2()) % (i + 1)
+		j := int(fastrand1()) % (i + 1)
 		pollorder[i] = pollorder[j]
 		pollorder[j] = o
 	}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 3106a1530e..cdcf4b3670 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -101,9 +101,6 @@ func racemalloc(p unsafe.Pointer, size uintptr)
 //go:noescape
 func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 
-// in asm_*.s
-func fastrand2() uint32
-
 const (
 	concurrentSweep = true
 )

From b3f224b2801059bf6b2d1b4001ffd8d34c91d19e Mon Sep 17 00:00:00 2001
From: David du Colombier <0intro@gmail.com>
Date: Wed, 3 Sep 2014 00:56:31 +0200
Subject: [PATCH 342/423] runtime: handle empty environment variables on Plan 9

LGTM=bradfitz, rsc
R=rsc, bradfitz
CC=golang-codereviews
https://golang.org/cl/137920044
---
 src/pkg/runtime/env_plan9.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/pkg/runtime/env_plan9.go b/src/pkg/runtime/env_plan9.go
index b6dcb4c1ea..76e9867e03 100644
--- a/src/pkg/runtime/env_plan9.go
+++ b/src/pkg/runtime/env_plan9.go
@@ -31,6 +31,10 @@ func gogetenv(key string) string {
 		return ""
 	}
 	n := seek(fd, 0, 2) - 1
+	if n <= 0 {
+		close(fd)
+		return ""
+	}
 
 	p := make([]byte, n)
 

From d8cbbe68024256ef4ead0a9d4d9d874c28f41a31 Mon Sep 17 00:00:00 2001
From: David du Colombier <0intro@gmail.com>
Date: Wed, 3 Sep 2014 00:56:50 +0200
Subject: [PATCH 343/423] runtime: don't allocate a new string in snprintf

This fixes the Plan 9 build.

Fix issue 8621.

LGTM=iant
R=rsc, mattn.jp, iant
CC=golang-codereviews
https://golang.org/cl/135280043
---
 src/pkg/runtime/print1.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/print1.go b/src/pkg/runtime/print1.go
index 28faa7cbbb..93f83ed26f 100644
--- a/src/pkg/runtime/print1.go
+++ b/src/pkg/runtime/print1.go
@@ -54,7 +54,7 @@ func snprintf(dst *byte, n int32, s *byte) {
 
 	gp := getg()
 	gp.writebuf = buf[0:0 : n-1] // leave room for NUL, this is called from C
-	vprintf(gostring(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
+	vprintf(gostringnocopy(s), add(unsafe.Pointer(&s), unsafe.Sizeof(s)))
 	buf[len(gp.writebuf)] = '\x00'
 	gp.writebuf = nil
 }

From 9aa7d136f52928587a6bd2db320f4f4f2b6b0666 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Tue, 2 Sep 2014 19:18:46 -0400
Subject: [PATCH 344/423] runtime: avoid race with forcegc helper

While we are here, give the gc helper a real function name
that will appear in stack traces.

LGTM=rlh
R=rlh
CC=dvyukov, golang-codereviews
https://golang.org/cl/133470043
---
 src/pkg/runtime/proc.c  |  9 ++++++---
 src/pkg/runtime/proc.go | 34 ++++++++++++++++++----------------
 2 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index d1ebd853bb..9229c53a8c 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2846,9 +2846,12 @@ sysmon(void)
 		lastgc = runtime·atomicload64(&mstats.last_gc);
 		if(lastgc != 0 && unixnow - lastgc > forcegcperiod && runtime·atomicload(&runtime·forcegc.idle)) {
 			runtime·lock(&runtime·forcegc.lock);
-			runtime·forcegc.idle = 0;
-			runtime·forcegc.g->schedlink = nil;
-			injectglist(runtime·forcegc.g);
+			if(runtime·forcegc.g != nil) {
+				// Goroutine may be started but has not initialized g yet.
+				runtime·forcegc.idle = 0;
+				runtime·forcegc.g->schedlink = nil;
+				injectglist(runtime·forcegc.g);
+			}
 			runtime·unlock(&runtime·forcegc.lock);
 		}
 
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 6c295c7b18..d47503e230 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -31,23 +31,25 @@ var parkunlock_c byte
 
 // start forcegc helper goroutine
 func init() {
-	go func() {
-		forcegc.g = getg()
-		forcegc.g.issystem = true
-		for {
-			lock(&forcegc.lock)
-			if forcegc.idle != 0 {
-				gothrow("forcegc: phase error")
-			}
-			atomicstore(&forcegc.idle, 1)
-			goparkunlock(&forcegc.lock, "force gc (idle)")
-			// this goroutine is explicitly resumed by sysmon
-			if debug.gctrace > 0 {
-				println("GC forced")
-			}
-			gogc(1)
+	go forcegchelper()
+}
+
+func forcegchelper() {
+	forcegc.g = getg()
+	forcegc.g.issystem = true
+	for {
+		lock(&forcegc.lock)
+		if forcegc.idle != 0 {
+			gothrow("forcegc: phase error")
 		}
-	}()
+		atomicstore(&forcegc.idle, 1)
+		goparkunlock(&forcegc.lock, "force gc (idle)")
+		// this goroutine is explicitly resumed by sysmon
+		if debug.gctrace > 0 {
+			println("GC forced")
+		}
+		gogc(1)
+	}
 }
 
 // Gosched yields the processor, allowing other goroutines to run.  It does not

From 2c780a35b986dec270640115fb3f28a9e1affeaf Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Wed, 3 Sep 2014 14:17:04 +1000
Subject: [PATCH 345/423] runtime: increase windows prof thread priority sooner

If system is busy burning cpu, it takes long time (about 300ms on
windows builders) to adjust prof thread priority. Once adjusted, prof
thread runs ahead of everyone else, but due to initial slowness, it
does not capture prof snapshots until start-up period is completed.

Change prof thread priority sooner, so it can start captures straight
away.

LGTM=dvyukov
R=golang-codereviews, dvyukov
CC=golang-codereviews
https://golang.org/cl/134360043
---
 src/pkg/runtime/os_windows.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 43026d6457..172fd92285 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -570,6 +570,7 @@ runtime·resetcpuprofiler(int32 hz)
 		runtime·atomicstorep(&profiletimer, timer);
 		thread = runtime·stdcall6(runtime·CreateThread,
 			(uintptr)nil, (uintptr)nil, (uintptr)runtime·profileloop, (uintptr)nil, (uintptr)nil, (uintptr)nil);
+		runtime·stdcall2(runtime·SetThreadPriority, (uintptr)thread, THREAD_PRIORITY_HIGHEST);
 		runtime·stdcall1(runtime·CloseHandle, (uintptr)thread);
 	}
 	runtime·unlock(&lock);

From 0e07f1c99f7ba8f657eaab49bfe106abddbe93a9 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 11:10:38 -0400
Subject: [PATCH 346/423] runtime: introduce, use funcPC to convert Go func to
 PC

This removes the ** unsafe hack.

Real bug fixed at chan.go:101.

LGTM=dave, r, iant
R=golang-codereviews, dave, r, iant
CC=dvyukov, golang-codereviews, khr
https://golang.org/cl/140870044
---
 src/pkg/runtime/chan.go         | 12 +++---------
 src/pkg/runtime/cpuprof.go      |  3 +--
 src/pkg/runtime/export_test.go  |  2 +-
 src/pkg/runtime/hashmap.go      | 24 +++++++-----------------
 src/pkg/runtime/hashmap_fast.go | 24 ++++++------------------
 src/pkg/runtime/proc.go         |  6 ++++++
 src/pkg/runtime/select.go       | 15 +++------------
 src/pkg/runtime/slice.go        | 10 +++-------
 src/pkg/runtime/string.go       |  9 +++------
 9 files changed, 33 insertions(+), 72 deletions(-)

diff --git a/src/pkg/runtime/chan.go b/src/pkg/runtime/chan.go
index 77df169399..91ade4d37e 100644
--- a/src/pkg/runtime/chan.go
+++ b/src/pkg/runtime/chan.go
@@ -82,9 +82,7 @@ func chansend1(t *chantype, c *hchan, elem unsafe.Pointer) {
  */
 func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
 	if raceenabled {
-		fn := chansend
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		raceReadObjectPC(t.elem, ep, callerpc, pc)
+		raceReadObjectPC(t.elem, ep, callerpc, funcPC(chansend))
 	}
 
 	if c == nil {
@@ -100,9 +98,7 @@ func chansend(t *chantype, c *hchan, ep unsafe.Pointer, block bool, callerpc uin
 	}
 
 	if raceenabled {
-		fn := chansend
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(c), pc, callerpc)
+		racereadpc(unsafe.Pointer(c), callerpc, funcPC(chansend))
 	}
 
 	// Fast path: check for failed non-blocking operation without acquiring the lock.
@@ -269,9 +265,7 @@ func closechan(c *hchan) {
 
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&c))
-		fn := closechan
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racewritepc(unsafe.Pointer(c), callerpc, pc)
+		racewritepc(unsafe.Pointer(c), callerpc, funcPC(closechan))
 		racerelease(unsafe.Pointer(c))
 	}
 
diff --git a/src/pkg/runtime/cpuprof.go b/src/pkg/runtime/cpuprof.go
index 540c78de8a..b397eafbe0 100644
--- a/src/pkg/runtime/cpuprof.go
+++ b/src/pkg/runtime/cpuprof.go
@@ -289,8 +289,7 @@ func (p *cpuProfile) flushlog() bool {
 	log := &p.log[p.toggle]
 	q := uintptr(0)
 	if p.lost > 0 {
-		f := lostProfileData
-		lostPC := **(**uintptr)(unsafe.Pointer(&f))
+		lostPC := funcPC(lostProfileData)
 		log[0] = p.lost
 		log[1] = 1
 		log[2] = lostPC
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 5579449c4f..cce9afbef9 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -86,7 +86,7 @@ func ParForSetup(desc *ParFor, nthr, n uint32, ctx *byte, wait bool, body func(*
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(desc)
 	mp.ptrarg[1] = unsafe.Pointer(ctx)
-	mp.ptrarg[2] = **(**unsafe.Pointer)(unsafe.Pointer(&body))
+	mp.ptrarg[2] = unsafe.Pointer(funcPC(body)) // TODO(rsc): Should be a scalar.
 	mp.scalararg[0] = uintptr(nthr)
 	mp.scalararg[1] = uintptr(n)
 	mp.scalararg[2] = 0
diff --git a/src/pkg/runtime/hashmap.go b/src/pkg/runtime/hashmap.go
index 1bdceab8bb..55287f6ff9 100644
--- a/src/pkg/runtime/hashmap.go
+++ b/src/pkg/runtime/hashmap.go
@@ -235,8 +235,7 @@ func makemap(t *maptype, hint int64) *hmap {
 func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess1
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		pc := funcPC(mapaccess1)
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
 		raceReadObjectPC(t.key, key, callerpc, pc)
 	}
@@ -284,8 +283,7 @@ func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess2
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		pc := funcPC(mapaccess2)
 		racereadpc(unsafe.Pointer(h), callerpc, pc)
 		raceReadObjectPC(t.key, key, callerpc, pc)
 	}
@@ -379,8 +377,7 @@ func mapassign1(t *maptype, h *hmap, key unsafe.Pointer, val unsafe.Pointer) {
 	}
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapassign1
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		pc := funcPC(mapassign1)
 		racewritepc(unsafe.Pointer(h), callerpc, pc)
 		raceReadObjectPC(t.key, key, callerpc, pc)
 		raceReadObjectPC(t.elem, val, callerpc, pc)
@@ -488,8 +485,7 @@ again:
 func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapdelete
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		pc := funcPC(mapdelete)
 		racewritepc(unsafe.Pointer(h), callerpc, pc)
 		raceReadObjectPC(t.key, key, callerpc, pc)
 	}
@@ -545,9 +541,7 @@ func mapiterinit(t *maptype, h *hmap, it *hiter) {
 
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapiterinit
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapiterinit))
 	}
 
 	if h == nil || h.count == 0 {
@@ -591,9 +585,7 @@ func mapiternext(it *hiter) {
 	h := it.h
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&it))
-		fn := mapiternext
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapiternext))
 	}
 	t := it.t
 	bucket := it.bucket
@@ -942,9 +934,7 @@ func reflect_maplen(h *hmap) int {
 	}
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&h))
-		fn := reflect_maplen
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(reflect_maplen))
 	}
 	return h.count
 }
diff --git a/src/pkg/runtime/hashmap_fast.go b/src/pkg/runtime/hashmap_fast.go
index 7059e22a0b..8e21e02d64 100644
--- a/src/pkg/runtime/hashmap_fast.go
+++ b/src/pkg/runtime/hashmap_fast.go
@@ -11,9 +11,7 @@ import (
 func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess1_fast32
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess1_fast32))
 	}
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero)
@@ -55,9 +53,7 @@ func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
 func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess2_fast32
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess2_fast32))
 	}
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero), false
@@ -99,9 +95,7 @@ func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
 func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess1_fast64
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess1_fast64))
 	}
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero)
@@ -143,9 +137,7 @@ func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
 func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess2_fast64
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess2_fast64))
 	}
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero), false
@@ -187,9 +179,7 @@ func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
 func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess1_faststr
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess1_faststr))
 	}
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero)
@@ -291,9 +281,7 @@ dohash:
 func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
 	if raceenabled && h != nil {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := mapaccess2_faststr
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadpc(unsafe.Pointer(h), callerpc, pc)
+		racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess2_faststr))
 	}
 	if h == nil || h.count == 0 {
 		return unsafe.Pointer(t.elem.zero), false
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index d47503e230..a36b931b88 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -110,3 +110,9 @@ func releaseSudog(s *sudog) {
 	s.next = c.sudogcache
 	c.sudogcache = s
 }
+
+// funcPC returns the entry PC of the function f.
+// It assumes that f is a func value. Otherwise the behavior is undefined.
+func funcPC(f interface{}) uintptr {
+	return **(**uintptr)(add(unsafe.Pointer(&f), ptrSize))
+}
diff --git a/src/pkg/runtime/select.go b/src/pkg/runtime/select.go
index dbe0543bf7..6d2531e7f8 100644
--- a/src/pkg/runtime/select.go
+++ b/src/pkg/runtime/select.go
@@ -13,17 +13,10 @@ const (
 )
 
 var (
-	chansendpc uintptr
-	chanrecvpc uintptr
+	chansendpc = funcPC(chansend)
+	chanrecvpc = funcPC(chanrecv)
 )
 
-func init() {
-	f := chansend
-	chansendpc = **(**uintptr)(unsafe.Pointer(&f))
-	g := chanrecv
-	chanrecvpc = **(**uintptr)(unsafe.Pointer(&g))
-}
-
 func selectsize(size uintptr) uintptr {
 	selsize := unsafe.Sizeof(_select{}) +
 		(size-1)*unsafe.Sizeof(_select{}.scase[0]) +
@@ -286,7 +279,6 @@ func selectgoImpl(sel *_select) (uintptr, uint16) {
 		k      *scase
 		sglist *sudog
 		sgnext *sudog
-		fn     func(*g, *_select) bool
 	)
 
 loop:
@@ -371,8 +363,7 @@ loop:
 
 	// wait for someone to wake us up
 	gp.param = nil
-	fn = selparkcommit
-	gopark(**(**unsafe.Pointer)(unsafe.Pointer(&fn)), unsafe.Pointer(sel), "select")
+	gopark(unsafe.Pointer(funcPC(selparkcommit)), unsafe.Pointer(sel), "select")
 
 	// someone woke us up
 	sellock(sel)
diff --git a/src/pkg/runtime/slice.go b/src/pkg/runtime/slice.go
index c282125b44..68a225a509 100644
--- a/src/pkg/runtime/slice.go
+++ b/src/pkg/runtime/slice.go
@@ -48,9 +48,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct {
 
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		fn := growslice
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
-		racereadrangepc(old.array, old.len*int(t.elem.size), callerpc, pc)
+		racereadrangepc(old.array, old.len*int(t.elem.size), callerpc, funcPC(growslice))
 	}
 
 	et := t.elem
@@ -105,8 +103,7 @@ func slicecopy(to sliceStruct, fm sliceStruct, width uintptr) int {
 
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&to))
-		fn := slicecopy
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		pc := funcPC(slicecopy)
 		racewriterangepc(to.array, n*int(width), callerpc, pc)
 		racereadrangepc(fm.array, n*int(width), callerpc, pc)
 	}
@@ -133,8 +130,7 @@ func slicestringcopy(to []byte, fm string) int {
 
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&to))
-		fn := slicestringcopy
-		pc := **(**uintptr)(unsafe.Pointer(&fn))
+		pc := funcPC(slicestringcopy)
 		racewriterangepc(unsafe.Pointer(&to[0]), n, callerpc, pc)
 	}
 
diff --git a/src/pkg/runtime/string.go b/src/pkg/runtime/string.go
index e9ea926dff..1cefad9671 100644
--- a/src/pkg/runtime/string.go
+++ b/src/pkg/runtime/string.go
@@ -61,11 +61,10 @@ func concatstring5(a [5]string) string {
 
 func slicebytetostring(b []byte) string {
 	if raceenabled && len(b) > 0 {
-		fn := slicebytetostring
 		racereadrangepc(unsafe.Pointer(&b[0]),
 			len(b),
 			getcallerpc(unsafe.Pointer(&b)),
-			**(**uintptr)(unsafe.Pointer(&fn)))
+			funcPC(slicebytetostring))
 	}
 	s, c := rawstring(len(b))
 	copy(c, b)
@@ -82,11 +81,10 @@ func slicebytetostringtmp(b []byte) string {
 	// m is a string-keyed map and k is a []byte.
 
 	if raceenabled && len(b) > 0 {
-		fn := slicebytetostringtmp
 		racereadrangepc(unsafe.Pointer(&b[0]),
 			len(b),
 			getcallerpc(unsafe.Pointer(&b)),
-			**(**uintptr)(unsafe.Pointer(&fn)))
+			funcPC(slicebytetostringtmp))
 	}
 	return *(*string)(unsafe.Pointer(&b))
 }
@@ -120,11 +118,10 @@ func stringtoslicerune(s string) []rune {
 
 func slicerunetostring(a []rune) string {
 	if raceenabled && len(a) > 0 {
-		fn := slicerunetostring
 		racereadrangepc(unsafe.Pointer(&a[0]),
 			len(a)*int(unsafe.Sizeof(a[0])),
 			getcallerpc(unsafe.Pointer(&a)),
-			**(**uintptr)(unsafe.Pointer(&fn)))
+			funcPC(slicerunetostring))
 	}
 	var dum [4]byte
 	size1 := 0

From 7ba41e99728d9a4545361ddfd834a473b424bbb6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 11:11:16 -0400
Subject: [PATCH 347/423] runtime: convert a few traceback-related functions
 from proc.c to traceback.go

They were in proc.c mainly because there was no portable
traceback source file. As part of converting them to Go,
move to traceback.go.

In order to get access to the PC of _rt0_go,
rename to runtime.rt0_go.

LGTM=r
R=golang-codereviews, r
CC=dvyukov, golang-codereviews, iant, khr
https://golang.org/cl/139110043
---
 src/cmd/api/goapi.go                  |  12 ++-
 src/pkg/runtime/asm_386.s             |   2 +-
 src/pkg/runtime/asm_amd64.s           |   2 +-
 src/pkg/runtime/asm_amd64p32.s        |   2 +-
 src/pkg/runtime/asm_arm.s             |   2 +-
 src/pkg/runtime/proc.c                | 128 +-------------------------
 src/pkg/runtime/rt0_darwin_386.s      |   2 +-
 src/pkg/runtime/rt0_darwin_amd64.s    |   2 +-
 src/pkg/runtime/rt0_dragonfly_386.s   |   2 +-
 src/pkg/runtime/rt0_dragonfly_amd64.s |   2 +-
 src/pkg/runtime/rt0_freebsd_386.s     |   2 +-
 src/pkg/runtime/rt0_freebsd_amd64.s   |   2 +-
 src/pkg/runtime/rt0_freebsd_arm.s     |   4 +-
 src/pkg/runtime/rt0_linux_386.s       |   2 +-
 src/pkg/runtime/rt0_linux_amd64.s     |   2 +-
 src/pkg/runtime/rt0_linux_arm.s       |   2 +-
 src/pkg/runtime/rt0_nacl_386.s        |   2 +-
 src/pkg/runtime/rt0_nacl_amd64p32.s   |   2 +-
 src/pkg/runtime/rt0_nacl_arm.s        |   2 +-
 src/pkg/runtime/rt0_netbsd_386.s      |   2 +-
 src/pkg/runtime/rt0_netbsd_amd64.s    |   2 +-
 src/pkg/runtime/rt0_netbsd_arm.s      |   2 +-
 src/pkg/runtime/rt0_openbsd_386.s     |   2 +-
 src/pkg/runtime/rt0_openbsd_amd64.s   |   2 +-
 src/pkg/runtime/rt0_plan9_386.s       |   2 +-
 src/pkg/runtime/rt0_plan9_amd64.s     |   2 +-
 src/pkg/runtime/rt0_solaris_amd64.s   |   2 +-
 src/pkg/runtime/rt0_windows_386.s     |   2 +-
 src/pkg/runtime/rt0_windows_amd64.s   |   2 +-
 src/pkg/runtime/runtime.h             |   1 -
 src/pkg/runtime/stubs.go              |   4 -
 src/pkg/runtime/traceback.go          | 121 ++++++++++++++++++++++--
 src/pkg/runtime/traceback_windows.go  |   3 +-
 33 files changed, 158 insertions(+), 167 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 8dec9e2cc7..7f7b389be3 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -405,7 +405,17 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" wincallbackcontext struct{};" +
 			" _select struct{}; " +
 			"); " +
-			"const ( cb_max = 2000 )"
+			"const (" +
+			" cb_max = 2000;" +
+			" _Gidle = 1;" +
+			" _Grunnable = 2;" +
+			" _Grunning = 3;" +
+			" _Gsyscall = 4;" +
+			" _Gwaiting = 5;" +
+			" _Gdead = 6;" +
+			" _Genqueue = 7;" +
+			" _Gcopystack = 8;" +
+			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
 			log.Fatalf("incorrect generated file: %s", err)
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 681a1b6819..e99c114ad7 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -6,7 +6,7 @@
 #include "funcdata.h"
 #include "../../cmd/ld/textflag.h"
 
-TEXT _rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
 	MOVL	argc+0(FP), AX
 	MOVL	argv+4(FP), BX
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 0121b7d865..0933fa92c7 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -6,7 +6,7 @@
 #include "funcdata.h"
 #include "../../cmd/ld/textflag.h"
 
-TEXT _rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
 	MOVQ	DI, AX		// argc
 	MOVQ	SI, BX		// argv
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 03cf9bd444..4a391033d1 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -6,7 +6,7 @@
 #include "funcdata.h"
 #include "../../cmd/ld/textflag.h"
 
-TEXT _rt0_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
 	MOVL	argc+0(FP), AX
 	MOVL	argv+4(FP), BX
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 87ea974246..6954bb7c05 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -7,7 +7,7 @@
 #include "../../cmd/ld/textflag.h"
 
 // using frame size $-4 means do not save LR on stack.
-TEXT _rt0_go(SB),NOSPLIT,$-4
+TEXT runtime·rt0_go(SB),NOSPLIT,$-4
 	MOVW	$0xcafebabe, R12
 
 	// copy arguments forward on an even stack
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 9229c53a8c..b85baca14d 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -185,8 +185,6 @@ runtime·schedinit(void)
 	if(p != nil && !runtime·strcmp(p, (byte*)"0"))
 		runtime·copystack = false;
 
-	mstats.enablegc = 1;
-
 	if(runtime·buildVersion.str == nil) {
 		// Condition should never trigger.  This code just serves
 		// to ensure runtime·buildVersion is kept in the resulting binary.
@@ -244,7 +242,10 @@ runtime·main(void)
 
 	if(g->m != &runtime·m0)
 		runtime·throw("runtime·main not on m0");
+
 	runtime·init();
+	mstats.enablegc = 1; // now that runtime is initialized, GC is okay
+
 	main·init();
 
 	if(g->defer != &d || d.fn != &initDone)
@@ -268,118 +269,12 @@ runtime·main(void)
 		*(int32*)runtime·main = 0;
 }
 
-void
-runtime·goroutineheader(G *gp)
-{
-	String status;
-	int64 waitfor;
-	uint32 gpstatus;
-
-	gpstatus = runtime·readgstatus(gp);
-	switch(gpstatus) {
-	case Gidle:
-		status = runtime·gostringnocopy((byte*)"idle");
-		break;
-	case Grunnable:
-		status = runtime·gostringnocopy((byte*)"runnable");
-		break;
-	case Grunning:
-		status = runtime·gostringnocopy((byte*)"running");
-		break;
-	case Gsyscall:
-		status = runtime·gostringnocopy((byte*)"syscall");
-		break;
-	case Gwaiting:
-		if(gp->waitreason.str != nil)
-			status = gp->waitreason;
-		else
-			status = runtime·gostringnocopy((byte*)"waiting");
-		break;
-	case Gscan:
-		status = runtime·gostringnocopy((byte*)"scan");
-		break;
-	case Gscanrunnable:
-		status =  runtime·gostringnocopy((byte*)"scanrunnable");
-		break;
-	case Gscanrunning:
-		status = runtime·gostringnocopy((byte*)"scanrunning");
-		break;
-	case Gscansyscall:
-		status = runtime·gostringnocopy((byte*)"scansyscall");
-		break;
-	case Gscanenqueue:
-		status = runtime·gostringnocopy((byte*)"scanenqueue");
-		break;
-	case Gscanwaiting:
-		if(gp->waitreason.str != nil)
-			status = gp->waitreason;
-		else
-			status = runtime·gostringnocopy((byte*)"scanwaiting");
-		break;
-	case Gcopystack:
-		status = runtime·gostringnocopy((byte*)"copystack");
-		break;
-	default:
-		status = runtime·gostringnocopy((byte*)"???");
-		break;
-	}
-
-	// approx time the G is blocked, in minutes
-	waitfor = 0;
-	gpstatus = gpstatus&~Gscan; // drop the scan bit
-	if((gpstatus == Gwaiting || gpstatus == Gsyscall) && gp->waitsince != 0)
-		waitfor = (runtime·nanotime() - gp->waitsince) / (60LL*1000*1000*1000);
-
-	runtime·printf("goroutine %D [%S", gp->goid, status);
-	if(waitfor >= 1)
-		runtime·printf(", %D minutes", waitfor);
-	if(gp->lockedm != nil)
-		runtime·printf(", locked to thread");
-	runtime·printf("]:\n");
-}
-
 static void
 dumpgstatus(G* gp)
 {
 	runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
 }
 
-void
-runtime·tracebackothers(G *me)
-{
-	G *gp;
-	int32 traceback;
-	uintptr i;
-	uint32 status;
-
-	traceback = runtime·gotraceback(nil);
-	
-	// Show the current goroutine first, if we haven't already.
-	if((gp = g->m->curg) != nil && gp != me) {
-		runtime·printf("\n");
-		runtime·goroutineheader(gp);
-		runtime·traceback(~(uintptr)0, ~(uintptr)0, 0, gp);
-	}
-
-	runtime·lock(&allglock);
-	for(i = 0; i < runtime·allglen; i++) {
-		gp = runtime·allg[i];
-		if(gp == me || gp == g->m->curg || runtime·readgstatus(gp) == Gdead)
-			continue;
-		if(gp->issystem && traceback < 2)
-			continue;
-		runtime·printf("\n");
-		runtime·goroutineheader(gp);
-		status = runtime·readgstatus(gp);
-		if((status&~Gscan) == Grunning){
-			runtime·printf("\tgoroutine running on other thread; stack unavailable\n");
-			runtime·printcreatedby(gp);
-		} else
-			runtime·traceback(~(uintptr)0, ~(uintptr)0, 0, gp);
-	}
-	runtime·unlock(&allglock);
-}
-
 static void
 checkmcount(void)
 {
@@ -3373,23 +3268,6 @@ runtime·testSchedLocalQueueSteal(void)
 	}
 }
 
-extern void runtime·morestack(void);
-uintptr runtime·externalthreadhandlerp;
-
-// Does f mark the top of a goroutine stack?
-bool
-runtime·topofstack(Func *f)
-{
-	return f->entry == (uintptr)runtime·goexit ||
-		f->entry == (uintptr)runtime·mstart ||
-		f->entry == (uintptr)runtime·mcall ||
-		f->entry == (uintptr)runtime·onM ||
-		f->entry == (uintptr)runtime·morestack ||
-		f->entry == (uintptr)runtime·lessstack ||
-		f->entry == (uintptr)_rt0_go ||
-		(runtime·externalthreadhandlerp != 0 && f->entry == runtime·externalthreadhandlerp);
-}
-
 void
 runtime·setmaxthreads_m(void)
 {
diff --git a/src/pkg/runtime/rt0_darwin_386.s b/src/pkg/runtime/rt0_darwin_386.s
index 4f85250c2d..7fe1df4c90 100644
--- a/src/pkg/runtime/rt0_darwin_386.s
+++ b/src/pkg/runtime/rt0_darwin_386.s
@@ -13,4 +13,4 @@ TEXT _rt0_386_darwin(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_darwin_amd64.s b/src/pkg/runtime/rt0_darwin_amd64.s
index 8d2962b03a..ac323c83c2 100644
--- a/src/pkg/runtime/rt0_darwin_amd64.s
+++ b/src/pkg/runtime/rt0_darwin_amd64.s
@@ -11,5 +11,5 @@ TEXT _rt0_amd64_darwin(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
diff --git a/src/pkg/runtime/rt0_dragonfly_386.s b/src/pkg/runtime/rt0_dragonfly_386.s
index b857f60391..9262a0f9e1 100644
--- a/src/pkg/runtime/rt0_dragonfly_386.s
+++ b/src/pkg/runtime/rt0_dragonfly_386.s
@@ -13,4 +13,4 @@ TEXT _rt0_386_dragonfly(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_dragonfly_amd64.s b/src/pkg/runtime/rt0_dragonfly_amd64.s
index fc7e745983..a83b20e228 100644
--- a/src/pkg/runtime/rt0_dragonfly_amd64.s
+++ b/src/pkg/runtime/rt0_dragonfly_amd64.s
@@ -11,5 +11,5 @@ TEXT _rt0_amd64_dragonfly(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
diff --git a/src/pkg/runtime/rt0_freebsd_386.s b/src/pkg/runtime/rt0_freebsd_386.s
index 758f7d2685..242b67df5e 100644
--- a/src/pkg/runtime/rt0_freebsd_386.s
+++ b/src/pkg/runtime/rt0_freebsd_386.s
@@ -13,4 +13,4 @@ TEXT _rt0_386_freebsd(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_freebsd_amd64.s b/src/pkg/runtime/rt0_freebsd_amd64.s
index 3cf7163b5e..729effbdba 100644
--- a/src/pkg/runtime/rt0_freebsd_amd64.s
+++ b/src/pkg/runtime/rt0_freebsd_amd64.s
@@ -11,5 +11,5 @@ TEXT _rt0_amd64_freebsd(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
diff --git a/src/pkg/runtime/rt0_freebsd_arm.s b/src/pkg/runtime/rt0_freebsd_arm.s
index 56219f8999..d50c73c237 100644
--- a/src/pkg/runtime/rt0_freebsd_arm.s
+++ b/src/pkg/runtime/rt0_freebsd_arm.s
@@ -10,9 +10,9 @@ TEXT _rt0_arm_freebsd(SB),NOSPLIT,$-4
 	MOVW	(R13), R0	// argc
 	MOVW	$4(R13), R1		// argv
 	MOVM.DB.W [R0-R1], (R13)
-	B	_rt0_go(SB)
+	B	runtime·rt0_go(SB)
 
 TEXT main(SB),NOSPLIT,$-4
 	MOVM.DB.W [R0-R1], (R13)
-	MOVW	$_rt0_go(SB), R4
+	MOVW	$runtime·rt0_go(SB), R4
 	B		(R4)
diff --git a/src/pkg/runtime/rt0_linux_386.s b/src/pkg/runtime/rt0_linux_386.s
index c6f4159ce3..285aeed73c 100644
--- a/src/pkg/runtime/rt0_linux_386.s
+++ b/src/pkg/runtime/rt0_linux_386.s
@@ -14,7 +14,7 @@ TEXT _rt0_386_linux(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
 
 TEXT _fallback_vdso(SB),NOSPLIT,$0
 	INT	$0x80
diff --git a/src/pkg/runtime/rt0_linux_amd64.s b/src/pkg/runtime/rt0_linux_amd64.s
index a887ced8f0..7f8c795481 100644
--- a/src/pkg/runtime/rt0_linux_amd64.s
+++ b/src/pkg/runtime/rt0_linux_amd64.s
@@ -11,5 +11,5 @@ TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
diff --git a/src/pkg/runtime/rt0_linux_arm.s b/src/pkg/runtime/rt0_linux_arm.s
index 309fa2f79d..21391c7300 100644
--- a/src/pkg/runtime/rt0_linux_arm.s
+++ b/src/pkg/runtime/rt0_linux_arm.s
@@ -56,7 +56,7 @@ TEXT _rt0_arm_linux1(SB),NOSPLIT,$-4
 	SUB	$4, R13 // fake a stack frame for runtime·setup_auxv
 	BL	runtime·setup_auxv(SB)
 	ADD	$4, R13
-	B	_rt0_go(SB)
+	B	runtime·rt0_go(SB)
 
 TEXT bad_abi<>(SB),NOSPLIT,$-4
 	// give diagnosis and exit
diff --git a/src/pkg/runtime/rt0_nacl_386.s b/src/pkg/runtime/rt0_nacl_386.s
index 8b713548fe..e374bf3359 100644
--- a/src/pkg/runtime/rt0_nacl_386.s
+++ b/src/pkg/runtime/rt0_nacl_386.s
@@ -19,4 +19,4 @@ TEXT _rt0_386_nacl(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_nacl_amd64p32.s b/src/pkg/runtime/rt0_nacl_amd64p32.s
index 502d2e2bfc..de08618fc8 100644
--- a/src/pkg/runtime/rt0_nacl_amd64p32.s
+++ b/src/pkg/runtime/rt0_nacl_amd64p32.s
@@ -27,4 +27,4 @@ TEXT main(SB),NOSPLIT,$0
 	// Uncomment for fake time like on Go Playground.
 	//MOVQ	$1257894000000000000, AX
 	//MOVQ	AX, runtime·timens(SB)
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_nacl_arm.s b/src/pkg/runtime/rt0_nacl_arm.s
index df84d5d02b..243cb3375d 100644
--- a/src/pkg/runtime/rt0_nacl_arm.s
+++ b/src/pkg/runtime/rt0_nacl_arm.s
@@ -17,4 +17,4 @@ TEXT _rt0_arm_nacl(SB),NOSPLIT,$-4
 	B	main(SB)
 
 TEXT main(SB),NOSPLIT,$0
-	B	_rt0_go(SB)
+	B	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_netbsd_386.s b/src/pkg/runtime/rt0_netbsd_386.s
index eb348fcee1..f4cc78a1bc 100644
--- a/src/pkg/runtime/rt0_netbsd_386.s
+++ b/src/pkg/runtime/rt0_netbsd_386.s
@@ -13,4 +13,4 @@ TEXT _rt0_386_netbsd(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_netbsd_amd64.s b/src/pkg/runtime/rt0_netbsd_amd64.s
index c8e3fb18c3..e2288dbaed 100644
--- a/src/pkg/runtime/rt0_netbsd_amd64.s
+++ b/src/pkg/runtime/rt0_netbsd_amd64.s
@@ -11,5 +11,5 @@ TEXT _rt0_amd64_netbsd(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
diff --git a/src/pkg/runtime/rt0_netbsd_arm.s b/src/pkg/runtime/rt0_netbsd_arm.s
index 36effc3c51..1f649d97c4 100644
--- a/src/pkg/runtime/rt0_netbsd_arm.s
+++ b/src/pkg/runtime/rt0_netbsd_arm.s
@@ -10,4 +10,4 @@ TEXT _rt0_arm_netbsd(SB),NOSPLIT,$-4
 	MOVW	(R13), R0	// argc
 	MOVW	$4(R13), R1		// argv
 	MOVM.DB.W [R0-R1], (R13)
-	B _rt0_go(SB)
+	B runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_openbsd_386.s b/src/pkg/runtime/rt0_openbsd_386.s
index 9e80f69be2..35439d0d58 100644
--- a/src/pkg/runtime/rt0_openbsd_386.s
+++ b/src/pkg/runtime/rt0_openbsd_386.s
@@ -13,4 +13,4 @@ TEXT _rt0_386_openbsd(SB),NOSPLIT,$8
 	INT	$3
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
diff --git a/src/pkg/runtime/rt0_openbsd_amd64.s b/src/pkg/runtime/rt0_openbsd_amd64.s
index b1ad403b70..a394890f94 100644
--- a/src/pkg/runtime/rt0_openbsd_amd64.s
+++ b/src/pkg/runtime/rt0_openbsd_amd64.s
@@ -11,5 +11,5 @@ TEXT _rt0_amd64_openbsd(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
diff --git a/src/pkg/runtime/rt0_plan9_386.s b/src/pkg/runtime/rt0_plan9_386.s
index a8ae50841d..4aaabfaa45 100644
--- a/src/pkg/runtime/rt0_plan9_386.s
+++ b/src/pkg/runtime/rt0_plan9_386.s
@@ -14,7 +14,7 @@ TEXT _rt0_386_plan9(SB),NOSPLIT,$12
 	MOVL	AX, 0(SP)
 	LEAL	inargv+0(FP), AX
 	MOVL	AX, 4(SP)
-	CALL	_rt0_go(SB)
+	CALL	runtime·rt0_go(SB)
 
 DATA  runtime·isplan9(SB)/4, $1
 GLOBL runtime·isplan9(SB), $4
diff --git a/src/pkg/runtime/rt0_plan9_amd64.s b/src/pkg/runtime/rt0_plan9_amd64.s
index 96d00584df..9f20eef60a 100644
--- a/src/pkg/runtime/rt0_plan9_amd64.s
+++ b/src/pkg/runtime/rt0_plan9_amd64.s
@@ -11,7 +11,7 @@ TEXT _rt0_amd64_plan9(SB),NOSPLIT,$24
 	MOVL	$1, _nprivates(SB)
 	MOVL	inargc-8(FP), DI
 	LEAQ	inargv+0(FP), SI
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
 
 DATA runtime·isplan9(SB)/4, $1
diff --git a/src/pkg/runtime/rt0_solaris_amd64.s b/src/pkg/runtime/rt0_solaris_amd64.s
index 4aca991f08..fd0a79cc9b 100644
--- a/src/pkg/runtime/rt0_solaris_amd64.s
+++ b/src/pkg/runtime/rt0_solaris_amd64.s
@@ -11,7 +11,7 @@ TEXT _rt0_amd64_solaris(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
 
 DATA runtime·issolaris(SB)/4, $1
diff --git a/src/pkg/runtime/rt0_windows_386.s b/src/pkg/runtime/rt0_windows_386.s
index 594e2cd343..d4008ad5dc 100644
--- a/src/pkg/runtime/rt0_windows_386.s
+++ b/src/pkg/runtime/rt0_windows_386.s
@@ -13,7 +13,7 @@ TEXT _rt0_386_windows(SB),NOSPLIT,$12
 	JMP	main(SB)
 
 TEXT main(SB),NOSPLIT,$0
-	JMP	_rt0_go(SB)
+	JMP	runtime·rt0_go(SB)
 
 
 DATA  runtime·iswindows(SB)/4, $1
diff --git a/src/pkg/runtime/rt0_windows_amd64.s b/src/pkg/runtime/rt0_windows_amd64.s
index 32e18b02ba..0b144717ba 100644
--- a/src/pkg/runtime/rt0_windows_amd64.s
+++ b/src/pkg/runtime/rt0_windows_amd64.s
@@ -12,7 +12,7 @@ TEXT _rt0_amd64_windows(SB),NOSPLIT,$-8
 	JMP	AX
 
 TEXT main(SB),NOSPLIT,$-8
-	MOVQ	$_rt0_go(SB), AX
+	MOVQ	$runtime·rt0_go(SB), AX
 	JMP	AX
 
 DATA  runtime·iswindows(SB)/4, $1
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index f1b3ee83f3..3cc6f9a81e 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -882,7 +882,6 @@ void	runtime·netpolllock(PollDesc*);
 void	runtime·netpollunlock(PollDesc*);
 void	runtime·crash(void);
 void	runtime·parsedebugvars(void);
-void	_rt0_go(void);
 void*	runtime·funcdata(Func*, int32);
 void	runtime·setmaxthreads_m(void);
 G*	runtime·timejump(void);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index cdcf4b3670..86dc47f4ab 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -138,9 +138,6 @@ func entersyscall()
 func entersyscallblock()
 func exitsyscall()
 
-func goroutineheader(gp *g)
-func tracebackothers(gp *g)
-
 func cgocallback(fn, frame unsafe.Pointer, framesize uintptr)
 func gogo(buf *gobuf)
 func gosave(buf *gobuf)
@@ -260,4 +257,3 @@ var newproc, deferproc, lessstack struct{} // C/assembly functions
 func funcspdelta(*_func, uintptr) int32 // symtab.c
 func funcarglen(*_func, uintptr) int32  // symtab.c
 const _ArgsSizeUnknown = -0x80000000    // funcdata.h
-func topofstack(*_func) bool            // proc.c
diff --git a/src/pkg/runtime/traceback.go b/src/pkg/runtime/traceback.go
index c6a6c056c1..26d0f5fc92 100644
--- a/src/pkg/runtime/traceback.go
+++ b/src/pkg/runtime/traceback.go
@@ -32,12 +32,7 @@ const usesLR = GOARCH != "amd64" && GOARCH != "amd64p32" && GOARCH != "386"
 
 // jmpdeferPC is the PC at the beginning of the jmpdefer assembly function.
 // The traceback needs to recognize it on link register architectures.
-var jmpdeferPC uintptr
-
-func init() {
-	f := jmpdefer
-	jmpdeferPC = **(**uintptr)(unsafe.Pointer(&f))
-}
+var jmpdeferPC = funcPC(jmpdefer)
 
 // System-specific hook. See traceback_windows.go
 var systraceback func(*_func, *stkframe, *g, bool, func(*stkframe, unsafe.Pointer) bool, unsafe.Pointer) (changed, aborted bool)
@@ -502,3 +497,117 @@ func callers(skip int, pcbuf *uintptr, m int) int {
 func gcallers(gp *g, skip int, pcbuf *uintptr, m int) int {
 	return gentraceback(^uintptr(0), ^uintptr(0), 0, gp, skip, pcbuf, m, nil, nil, false)
 }
+
+var gStatusStrings = [...]string{
+	_Gidle:      "idle",
+	_Grunnable:  "runnable",
+	_Grunning:   "running",
+	_Gsyscall:   "syscall",
+	_Gwaiting:   "waiting",
+	_Gdead:      "dead",
+	_Genqueue:   "enqueue",
+	_Gcopystack: "copystack",
+}
+
+var gScanStatusStrings = [...]string{
+	0:          "scan",
+	_Grunnable: "scanrunnable",
+	_Grunning:  "scanrunning",
+	_Gsyscall:  "scansyscall",
+	_Gwaiting:  "scanwaiting",
+	_Gdead:     "scandead",
+	_Genqueue:  "scanenqueue",
+}
+
+func goroutineheader(gp *g) {
+	gpstatus := readgstatus(gp)
+
+	// Basic string status
+	var status string
+	if 0 <= gpstatus && gpstatus < uint32(len(gStatusStrings)) {
+		status = gStatusStrings[gpstatus]
+	} else if gpstatus&_Gscan != 0 && 0 <= gpstatus&^_Gscan && gpstatus&^_Gscan < uint32(len(gStatusStrings)) {
+		status = gStatusStrings[gpstatus&^_Gscan]
+	} else {
+		status = "???"
+	}
+
+	// Override.
+	if (gpstatus == _Gwaiting || gpstatus == _Gscanwaiting) && gp.waitreason != "" {
+		status = gp.waitreason
+	}
+
+	// approx time the G is blocked, in minutes
+	var waitfor int64
+	gpstatus &^= _Gscan // drop the scan bit
+	if (gpstatus == _Gwaiting || gpstatus == _Gsyscall) && gp.waitsince != 0 {
+		waitfor = (nanotime() - gp.waitsince) / 60e9
+	}
+	print("goroutine ", gp.goid, " [", status)
+	if waitfor >= 1 {
+		print(", ", waitfor, " minutes")
+	}
+	if gp.lockedm != nil {
+		print(", locked to thread")
+	}
+	print("]:\n")
+}
+
+func tracebackothers(me *g) {
+	level := gotraceback(nil)
+
+	// Show the current goroutine first, if we haven't already.
+	g := getg()
+	gp := g.m.curg
+	if gp != nil && gp != me {
+		print("\n")
+		goroutineheader(gp)
+		traceback(^uintptr(0), ^uintptr(0), 0, gp)
+	}
+
+	lock(&allglock)
+	for _, gp := range allgs {
+		if gp == me || gp == g.m.curg || readgstatus(gp) == _Gdead || gp.issystem && level < 2 {
+			continue
+		}
+		print("\n")
+		goroutineheader(gp)
+		if readgstatus(gp)&^_Gscan == _Grunning {
+			print("\tgoroutine running on other thread; stack unavailable\n")
+			printcreatedby(gp)
+		} else {
+			traceback(^uintptr(0), ^uintptr(0), 0, gp)
+		}
+	}
+	unlock(&allglock)
+}
+
+func goexit()
+func mstart()
+func morestack()
+func rt0_go()
+
+var (
+	goexitPC    = funcPC(goexit)
+	mstartPC    = funcPC(mstart)
+	mcallPC     = funcPC(mcall)
+	onMPC       = funcPC(onM)
+	morestackPC = funcPC(morestack)
+	lessstackPC = funcPC(lessstack)
+	rt0_goPC    = funcPC(rt0_go)
+
+	externalthreadhandlerp uintptr // initialized elsewhere
+)
+
+// Does f mark the top of a goroutine stack?
+func topofstack(f *_func) bool {
+	pc := f.entry
+	return pc == goexitPC ||
+		pc == mstartPC ||
+		pc == mcallPC ||
+		pc == onMPC ||
+		pc == morestackPC ||
+		pc == lessstackPC ||
+		pc == rt0_goPC ||
+		externalthreadhandlerp != 0 && pc == externalthreadhandlerp
+}
diff --git a/src/pkg/runtime/traceback_windows.go b/src/pkg/runtime/traceback_windows.go
index 206f93c46e..892bed04ca 100644
--- a/src/pkg/runtime/traceback_windows.go
+++ b/src/pkg/runtime/traceback_windows.go
@@ -13,8 +13,7 @@ var sigtrampPC uintptr
 var sigtramp struct{} // assembly function
 
 func init() {
-	f := sigtramp
-	sigtrampPC = **(**uintptr)(unsafe.Pointer(&f))
+	sigtrampPC = funcPC(sigtramp)
 	systraceback = traceback_windows
 }
 

From 012ceed914a24470207d602deeda3d6642787b4c Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 11:35:22 -0400
Subject: [PATCH 348/423] runtime: make onM and mcall take Go func values

This gives them correct types in Go and also makes it
possible to use them to run Go code on an m stack.

LGTM=iant
R=golang-codereviews, dave, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/137970044
---
 src/pkg/runtime/asm_386.s      | 10 +++++--
 src/pkg/runtime/asm_amd64.s    | 10 +++++--
 src/pkg/runtime/asm_amd64p32.s | 10 +++++--
 src/pkg/runtime/asm_arm.s      | 10 +++++--
 src/pkg/runtime/export_test.go | 28 ++++++++---------
 src/pkg/runtime/heapdump.c     |  5 +++-
 src/pkg/runtime/malloc.go      | 16 +++++-----
 src/pkg/runtime/mcache.c       |  5 +++-
 src/pkg/runtime/mgc0.c         |  7 +++--
 src/pkg/runtime/mgc0.go        |  2 +-
 src/pkg/runtime/mheap.c        |  9 ++++--
 src/pkg/runtime/panic.c        |  4 ++-
 src/pkg/runtime/proc.c         | 32 +++++++++++++++-----
 src/pkg/runtime/proc.go        |  6 ++--
 src/pkg/runtime/rdebug.go      |  4 +--
 src/pkg/runtime/runtime.h      |  4 +--
 src/pkg/runtime/sigqueue.go    | 14 ++++-----
 src/pkg/runtime/stubs.go       | 55 ++++++++++++++++------------------
 18 files changed, 140 insertions(+), 91 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index e99c114ad7..07158ef0fd 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -162,7 +162,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $0-4
 	MOVL	gobuf_pc(BX), BX
 	JMP	BX
 
-// void mcall(void (*fn)(G*))
+// func mcall(fn func(*g))
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
@@ -188,6 +188,8 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
 	MOVL	SI, g(CX)	// g = m->g0
 	MOVL	(g_sched+gobuf_sp)(SI), SP	// sp = m->g0->sched.sp
 	PUSHL	AX
+	MOVL	DI, DX
+	MOVL	0(DI), DI
 	CALL	DI
 	POPL	AX
 	MOVL	$runtime·badmcall2(SB), AX
@@ -202,7 +204,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
 TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
 	RET
 
-// void onM(void (*fn)())
+// func onM(fn func())
 // calls fn() on the M stack.
 // switches to the M stack if not already on it, and
 // switches back when fn() returns.
@@ -227,6 +229,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 
 	// call target function
 	ARGSIZE(0)
+	MOVL	DI, DX
+	MOVL	0(DI), DI
 	CALL	DI
 
 	// switch back to g
@@ -241,6 +245,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 
 onm:
 	// already on m stack, just call directly
+	MOVL	DI, DX
+	MOVL	0(DI), DI
 	CALL	DI
 	RET
 
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 0933fa92c7..1d98fc2652 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -153,7 +153,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $0-8
 	MOVQ	gobuf_pc(BX), BX
 	JMP	BX
 
-// void mcall(void (*fn)(G*))
+// func mcall(fn func(*g))
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
@@ -180,6 +180,8 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 	MOVQ	(g_sched+gobuf_sp)(SI), SP	// sp = m->g0->sched.sp
 	PUSHQ	AX
 	ARGSIZE(8)
+	MOVQ	DI, DX
+	MOVQ	0(DI), DI
 	CALL	DI
 	POPQ	AX
 	MOVQ	$runtime·badmcall2(SB), AX
@@ -194,7 +196,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-8
 TEXT runtime·switchtoM(SB), NOSPLIT, $0-8
 	RET
 
-// void onM(void (*fn)())
+// func onM(fn func())
 // calls fn() on the M stack.
 // switches to the M stack if not already on it, and
 // switches back when fn() returns.
@@ -220,6 +222,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-8
 
 	// call target function
 	ARGSIZE(0)
+	MOVQ	DI, DX
+	MOVQ	0(DI), DI
 	CALL	DI
 
 	// switch back to g
@@ -234,6 +238,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-8
 
 onm:
 	// already on m stack, just call directly
+	MOVQ	DI, DX
+	MOVQ	0(DI), DI
 	CALL	DI
 	RET
 
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 4a391033d1..20069a6c7e 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -131,7 +131,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $0-4
 	MOVL	gobuf_pc(BX), BX
 	JMP	BX
 
-// void mcall(void (*fn)(G*))
+// func mcall(fn func(*g))
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
@@ -158,6 +158,8 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
 	MOVL	(g_sched+gobuf_sp)(SI), SP	// sp = m->g0->sched.sp
 	PUSHQ	AX
 	ARGSIZE(8)
+	MOVL	DI, DX
+	MOVL	0(DI), DI
 	CALL	DI
 	POPQ	AX
 	MOVL	$runtime·badmcall2(SB), AX
@@ -172,7 +174,7 @@ TEXT runtime·mcall(SB), NOSPLIT, $0-4
 TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
 	RET
 
-// void onM(void (*fn)())
+// func onM(fn func())
 // calls fn() on the M stack.
 // switches to the M stack if not already on it, and
 // switches back when fn() returns.
@@ -198,6 +200,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 
 	// call target function
 	ARGSIZE(0)
+	MOVL	DI, DX
+	MOVL	0(DI), DI
 	CALL	DI
 
 	// switch back to g
@@ -212,6 +216,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 
 onm:
 	// already on m stack, just call directly
+	MOVL	DI, DX
+	MOVL	0(DI), DI
 	CALL	DI
 	RET
 
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 6954bb7c05..6e12cf60f3 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -147,7 +147,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $-4-4
 	MOVW	gobuf_pc(R1), R11
 	B	(R11)
 
-// void mcall(void (*fn)(G*))
+// func mcall(fn func(*g))
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
@@ -173,6 +173,8 @@ TEXT runtime·mcall(SB), NOSPLIT, $-4-4
 	MOVW	(g_sched+gobuf_sp)(g), SP
 	SUB	$8, SP
 	MOVW	R1, 4(SP)
+	MOVW	R0, R7
+	MOVW	0(R0), R0
 	BL	(R0)
 	B	runtime·badmcall2(SB)
 	RET
@@ -187,7 +189,7 @@ TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
 	BL	(R0) // clobber lr to ensure push {lr} is kept
 	RET
 
-// void onM(void (*fn)())
+// func onM(fn func())
 // calls fn() on the M stack.
 // switches to the M stack if not already on it, and
 // switches back when fn() returns.
@@ -213,6 +215,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 
 	// call target function
 	ARGSIZE(0)
+	MOVW	R0, R7
+	MOVW	0(R0), R0
 	BL	(R0)
 
 	// switch back to g
@@ -224,6 +228,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 	RET
 
 onm:
+	MOVW	R0, R7
+	MOVW	0(R0), R0
 	BL	(R0)
 	RET
 
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index cce9afbef9..35a4130ee1 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -31,23 +31,21 @@ type LFNode struct {
 	Pushcnt uintptr
 }
 
-var (
-	lfstackpush_m,
-	lfstackpop_m mFunction
-)
+func lfstackpush_m()
+func lfstackpop_m()
 
 func LFStackPush(head *uint64, node *LFNode) {
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(head)
 	mp.ptrarg[1] = unsafe.Pointer(node)
-	onM(&lfstackpush_m)
+	onM(lfstackpush_m)
 	releasem(mp)
 }
 
 func LFStackPop(head *uint64) *LFNode {
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(head)
-	onM(&lfstackpop_m)
+	onM(lfstackpop_m)
 	node := (*LFNode)(unsafe.Pointer(mp.ptrarg[0]))
 	mp.ptrarg[0] = nil
 	releasem(mp)
@@ -65,17 +63,15 @@ type ParFor struct {
 	wait    bool
 }
 
-var (
-	newparfor_m,
-	parforsetup_m,
-	parfordo_m,
-	parforiters_m mFunction
-)
+func newparfor_m()
+func parforsetup_m()
+func parfordo_m()
+func parforiters_m()
 
 func NewParFor(nthrmax uint32) *ParFor {
 	mp := acquirem()
 	mp.scalararg[0] = uintptr(nthrmax)
-	onM(&newparfor_m)
+	onM(newparfor_m)
 	desc := (*ParFor)(mp.ptrarg[0])
 	mp.ptrarg[0] = nil
 	releasem(mp)
@@ -93,14 +89,14 @@ func ParForSetup(desc *ParFor, nthr, n uint32, ctx *byte, wait bool, body func(*
 	if wait {
 		mp.scalararg[2] = 1
 	}
-	onM(&parforsetup_m)
+	onM(parforsetup_m)
 	releasem(mp)
 }
 
 func ParForDo(desc *ParFor) {
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(desc)
-	onM(&parfordo_m)
+	onM(parfordo_m)
 	releasem(mp)
 }
 
@@ -108,7 +104,7 @@ func ParForIters(desc *ParFor, tid uint32) (uint32, uint32) {
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(desc)
 	mp.scalararg[0] = uintptr(tid)
-	onM(&parforiters_m)
+	onM(parforiters_m)
 	begin := uint32(mp.scalararg[0])
 	end := uint32(mp.scalararg[1])
 	releasem(mp)
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 63ffe68066..83c2be2ac7 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -746,6 +746,8 @@ mdump(G *gp)
 void
 runtime∕debug·WriteHeapDump(uintptr fd)
 {
+	void (*fn)(G*);
+
 	// Stop the world.
 	runtime·semacquire(&runtime·worldsema, false);
 	g->m->gcing = 1;
@@ -762,7 +764,8 @@ runtime∕debug·WriteHeapDump(uintptr fd)
 	// Call dump routine on M stack.
 	runtime·casgstatus(g, Grunning, Gwaiting);
 	g->waitreason = runtime·gostringnocopy((byte*)"dumping heap");
-	runtime·mcall(mdump);
+	fn = mdump;
+	runtime·mcall(&fn);
 
 	// Reset dump file.
 	dumpfd = 0;
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 84587a36d6..dbe37c8108 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -144,7 +144,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			if v == nil {
 				mp := acquirem()
 				mp.scalararg[0] = tinySizeClass
-				onM(&mcacheRefill_m)
+				onM(mcacheRefill_m)
 				releasem(mp)
 				s = c.alloc[tinySizeClass]
 				v = s.freelist
@@ -175,7 +175,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			if v == nil {
 				mp := acquirem()
 				mp.scalararg[0] = uintptr(sizeclass)
-				onM(&mcacheRefill_m)
+				onM(mcacheRefill_m)
 				releasem(mp)
 				s = c.alloc[sizeclass]
 				v = s.freelist
@@ -196,7 +196,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		mp := acquirem()
 		mp.scalararg[0] = uintptr(size)
 		mp.scalararg[1] = uintptr(flags)
-		onM(&largeAlloc_m)
+		onM(largeAlloc_m)
 		s = (*mspan)(mp.ptrarg[0])
 		mp.ptrarg[0] = nil
 		releasem(mp)
@@ -246,7 +246,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 				mp.ptrarg[1] = unsafe.Pointer(typ)
 				mp.scalararg[0] = uintptr(size)
 				mp.scalararg[1] = uintptr(size0)
-				onM(&unrollgcproginplace_m)
+				onM(unrollgcproginplace_m)
 				releasem(mp)
 				goto marked
 			}
@@ -255,7 +255,7 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			if uintptr(atomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
 				mp := acquirem()
 				mp.ptrarg[0] = unsafe.Pointer(typ)
-				onM(&unrollgcprog_m)
+				onM(unrollgcprog_m)
 				releasem(mp)
 			}
 			ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
@@ -459,7 +459,7 @@ func gogc(force int32) {
 		} else {
 			mp.scalararg[2] = 0
 		}
-		onM(&gc_m)
+		onM(gc_m)
 	}
 
 	// all done
@@ -571,7 +571,7 @@ func SetFinalizer(obj interface{}, finalizer interface{}) {
 		// switch to M stack and remove finalizer
 		mp := acquirem()
 		mp.ptrarg[0] = e.data
-		onM(&removeFinalizer_m)
+		onM(removeFinalizer_m)
 		releasem(mp)
 		return
 	}
@@ -624,7 +624,7 @@ okarg:
 	mp.scalararg[0] = nret
 	mp.ptrarg[2] = unsafe.Pointer(fint)
 	mp.ptrarg[3] = unsafe.Pointer(ot)
-	onM(&setFinalizer_m)
+	onM(setFinalizer_m)
 	if mp.scalararg[0] != 1 {
 		gothrow("runtime.SetFinalizer: finalizer already set")
 	}
diff --git a/src/pkg/runtime/mcache.c b/src/pkg/runtime/mcache.c
index e17bd2144f..8e98890e8e 100644
--- a/src/pkg/runtime/mcache.c
+++ b/src/pkg/runtime/mcache.c
@@ -65,8 +65,11 @@ freemcache_m(G *gp)
 void
 runtime·freemcache(MCache *c)
 {
+	void (*fn)(G*);
+
 	g->m->ptrarg[0] = c;
-	runtime·mcall(freemcache_m);
+	fn = freemcache_m;
+	runtime·mcall(&fn);
 }
 
 // Gets a span that has a free object in it and assigns it
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 3e22acc524..2ae23e8bf0 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1141,6 +1141,7 @@ runtime·updatememstats(GCStats *stats)
 	int32 i;
 	uint64 smallfree;
 	uint64 *src, *dst;
+	void (*fn)(G*);
 
 	if(stats)
 		runtime·memclr((byte*)stats, sizeof(*stats));
@@ -1177,8 +1178,10 @@ runtime·updatememstats(GCStats *stats)
 	// Flush MCache's to MCentral.
 	if(g == g->m->g0)
 		flushallmcaches();
-	else
-		runtime·mcall(flushallmcaches_m);
+	else {
+		fn = flushallmcaches_m;
+		runtime·mcall(&fn);
+	}
 
 	// Aggregate local stats.
 	cachestats();
diff --git a/src/pkg/runtime/mgc0.go b/src/pkg/runtime/mgc0.go
index 93af63e63e..2d9d76a474 100644
--- a/src/pkg/runtime/mgc0.go
+++ b/src/pkg/runtime/mgc0.go
@@ -37,7 +37,7 @@ func gc_unixnanotime(now *int64) {
 
 func freeOSMemory() {
 	gogc(2) // force GC and do eager sweep
-	onM(&scavenge_m)
+	onM(scavenge_m)
 }
 
 var poolcleanup func()
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 93f33f21cf..0050e96556 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -229,6 +229,7 @@ MSpan*
 runtime·MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, bool large, bool needzero)
 {
 	MSpan *s;
+	void (*fn)(G*);
 
 	// Don't do any operations that lock the heap on the G stack.
 	// It might trigger stack growth, and the stack growth code needs
@@ -240,7 +241,8 @@ runtime·MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, bool large, bool
 		g->m->scalararg[0] = npage;
 		g->m->scalararg[1] = sizeclass;
 		g->m->scalararg[2] = large;
-		runtime·mcall(mheap_alloc_m);
+		fn = mheap_alloc_m;
+		runtime·mcall(&fn);
 		s = g->m->ptrarg[0];
 		g->m->ptrarg[0] = nil;
 	}
@@ -488,13 +490,16 @@ mheap_free_m(G *gp)
 void
 runtime·MHeap_Free(MHeap *h, MSpan *s, int32 acct)
 {
+	void (*fn)(G*);
+
 	if(g == g->m->g0) {
 		mheap_free(h, s, acct);
 	} else {
 		g->m->ptrarg[0] = h;
 		g->m->ptrarg[1] = s;
 		g->m->scalararg[0] = acct;
-		runtime·mcall(mheap_free_m);
+		fn = mheap_free_m;
+		runtime·mcall(&fn);
 	}
 }
 
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index ecf4111337..4b6829e011 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -214,6 +214,7 @@ runtime·panic(Eface e)
 	Defer *d, dabort;
 	Panic p;
 	uintptr pc, argp;
+	void (*fn)(G*);
 
 	runtime·memclr((byte*)&p, sizeof p);
 	p.arg = e;
@@ -266,7 +267,8 @@ runtime·panic(Eface e)
 			// Pass information about recovering frame to recovery.
 			g->sigcode0 = (uintptr)argp;
 			g->sigcode1 = (uintptr)pc;
-			runtime·mcall(recovery);
+			fn = recovery;
+			runtime·mcall(&fn);
 			runtime·throw("recovery failed"); // mcall should not return
 		}
 	}
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index b85baca14d..bc15d822cb 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1439,10 +1439,13 @@ dropg(void)
 void
 runtime·park(bool(*unlockf)(G*, void*), void *lock, String reason)
 {
+	void (*fn)(G*);
+
 	g->m->waitlock = lock;
 	g->m->waitunlockf = unlockf;
 	g->waitreason = reason;
-	runtime·mcall(runtime·park_m);
+	fn = runtime·park_m;
+	runtime·mcall(&fn);
 }
 
 bool
@@ -1487,7 +1490,10 @@ runtime·park_m(G *gp)
 void
 runtime·gosched(void)
 {
-	runtime·mcall(runtime·gosched_m);
+	void (*fn)(G*);
+	
+	fn = runtime·gosched_m;
+	runtime·mcall(&fn);
 }
 
 // runtime·gosched continuation on g0.
@@ -1518,9 +1524,12 @@ runtime·gosched_m(G *gp)
 void
 runtime·goexit(void)
 {
+	void (*fn)(G*);
+
 	if(raceenabled)
 		runtime·racegoend();
-	runtime·mcall(goexit0);
+	fn = goexit0;
+	runtime·mcall(&fn);
 }
 
 // runtime·goexit continuation on g0.
@@ -1689,6 +1698,8 @@ runtime·entersyscallblock_m(void)
 void
 runtime·exitsyscall(void)
 {
+	void (*fn)(G*);
+
 	g->m->locks++;  // see comment in entersyscall
 
 	g->waitsince = 0;
@@ -1716,7 +1727,8 @@ runtime·exitsyscall(void)
 	g->m->locks--;
 
 	// Call the scheduler.
-	runtime·mcall(exitsyscall0);
+	fn = exitsyscall0;
+	runtime·mcall(&fn);
 
 	// Scheduler returned, so we're allowed to run now.
 	// Delete the gcstack information that we left for
@@ -1858,6 +1870,7 @@ runtime·malg(int32 stacksize)
 {
 	G *newg;
 	byte *stk;
+	void (*fn)(G*);
 
 	if(StackTop < sizeof(Stktop)) {
 		runtime·printf("runtime: SizeofStktop=%d, should be >=%d\n", (int32)StackTop, (int32)sizeof(Stktop));
@@ -1874,7 +1887,8 @@ runtime·malg(int32 stacksize)
 			// have to call stackalloc on scheduler stack.
 			newg->stacksize = stacksize;
 			g->param = newg;
-			runtime·mcall(mstackalloc);
+			fn = mstackalloc;
+			runtime·mcall(&fn);
 			stk = g->param;
 			g->param = nil;
 		}
@@ -1915,6 +1929,7 @@ void
 runtime·newproc(int32 siz, FuncVal* fn, ...)
 {
 	byte *argp;
+	void (*mfn)(void);
 
 	if(thechar == '5')
 		argp = (byte*)(&fn+2);  // skip caller's saved LR
@@ -1926,7 +1941,8 @@ runtime·newproc(int32 siz, FuncVal* fn, ...)
 	g->m->scalararg[1] = (uintptr)runtime·getcallerpc(&siz);
 	g->m->ptrarg[0] = argp;
 	g->m->ptrarg[1] = fn;
-	runtime·onM(newproc_m);
+	mfn = newproc_m;
+	runtime·onM(&mfn);
 	g->m->locks--;
 }
 
@@ -2090,6 +2106,7 @@ gfget(P *p)
 {
 	G *gp;
 	byte *stk;
+	void (*fn)(G*);
 
 retry:
 	gp = p->gfree;
@@ -2117,7 +2134,8 @@ retry:
 			} else {
 				gp->stacksize = FixedStack;
 				g->param = gp;
-				runtime·mcall(mstackalloc);
+				fn = mstackalloc;
+				runtime·mcall(&fn);
 				stk = g->param;
 				g->param = nil;
 			}
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index a36b931b88..f060640a26 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -55,7 +55,7 @@ func forcegchelper() {
 // Gosched yields the processor, allowing other goroutines to run.  It does not
 // suspend the current goroutine, so execution resumes automatically.
 func Gosched() {
-	mcall(&gosched_m)
+	mcall(gosched_m)
 }
 
 func readgStatus(gp *g) uint32 {
@@ -77,7 +77,7 @@ func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
 	gp.waitreason = reason
 	releasem(mp)
 	// can't do anything that might move the G between Ms here.
-	mcall(&park_m)
+	mcall(park_m)
 }
 
 // Puts the current goroutine into a waiting state and unlocks the lock.
@@ -89,7 +89,7 @@ func goparkunlock(lock *mutex, reason string) {
 func goready(gp *g) {
 	mp := acquirem()
 	mp.ptrarg[0] = unsafe.Pointer(gp)
-	onM(&ready_m)
+	onM(ready_m)
 	releasem(mp)
 }
 
diff --git a/src/pkg/runtime/rdebug.go b/src/pkg/runtime/rdebug.go
index eef0f281fd..e5e691122c 100644
--- a/src/pkg/runtime/rdebug.go
+++ b/src/pkg/runtime/rdebug.go
@@ -13,7 +13,7 @@ func setMaxStack(in int) (out int) {
 func setGCPercent(in int32) (out int32) {
 	mp := acquirem()
 	mp.scalararg[0] = uintptr(int(in))
-	onM(&setgcpercent_m)
+	onM(setgcpercent_m)
 	out = int32(int(mp.scalararg[0]))
 	releasem(mp)
 	return out
@@ -30,7 +30,7 @@ func setPanicOnFault(new bool) (old bool) {
 func setMaxThreads(in int) (out int) {
 	mp := acquirem()
 	mp.scalararg[0] = uintptr(in)
-	onM(&setmaxthreads_m)
+	onM(setmaxthreads_m)
 	out = int(mp.scalararg[0])
 	releasem(mp)
 	return out
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 3cc6f9a81e..d67d7a0076 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -809,8 +809,8 @@ void	runtime·runpanic(Panic*);
 uintptr	runtime·getcallersp(void*);
 int32	runtime·mcount(void);
 int32	runtime·gcount(void);
-void	runtime·mcall(void(*)(G*));
-void	runtime·onM(void(*)(void));
+void	runtime·mcall(void(**)(G*));
+void	runtime·onM(void(**)(void));
 uint32	runtime·fastrand1(void);
 void	runtime·rewindmorestack(Gobuf*);
 int32	runtime·timediv(int64, int32, int32*);
diff --git a/src/pkg/runtime/sigqueue.go b/src/pkg/runtime/sigqueue.go
index c51ede0265..4643559705 100644
--- a/src/pkg/runtime/sigqueue.go
+++ b/src/pkg/runtime/sigqueue.go
@@ -9,7 +9,7 @@ package runtime
 func signal_recv() (m uint32) {
 	for {
 		mp := acquirem()
-		onM(&signal_recv_m)
+		onM(signal_recv_m)
 		ok := mp.scalararg[0] != 0
 		m = uint32(mp.scalararg[1])
 		releasem(mp)
@@ -24,19 +24,17 @@ func signal_recv() (m uint32) {
 func signal_enable(s uint32) {
 	mp := acquirem()
 	mp.scalararg[0] = uintptr(s)
-	onM(&signal_enable_m)
+	onM(signal_enable_m)
 	releasem(mp)
 }
 
 func signal_disable(s uint32) {
 	mp := acquirem()
 	mp.scalararg[0] = uintptr(s)
-	onM(&signal_disable_m)
+	onM(signal_disable_m)
 	releasem(mp)
 }
 
-var (
-	signal_recv_m,
-	signal_enable_m,
-	signal_disable_m mFunction
-)
+func signal_recv_m()
+func signal_enable_m()
+func signal_disable_m()
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 86dc47f4ab..b002da98b4 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -57,37 +57,34 @@ func acquirem() *m
 func releasem(mp *m)
 func gomcache() *mcache
 
-// An mFunction represents a C function that runs on the M stack.  It
-// can be called from Go using mcall or onM.  Through the magic of
-// linking, an mFunction variable and the corresponding C code entry
-// point live at the same address.
-type mFunction byte
-
 // in asm_*.s
-func mcall(fn *mFunction)
-func onM(fn *mFunction)
+func mcall(func(*g))
+func onM(fn func())
 
-// C functions that run on the M stack.  Call these like
-//   mcall(&mcacheRefill_m)
-// Arguments should be passed in m->scalararg[x] and
-// m->ptrarg[x].  Return values can be passed in those
-// same slots.
-var (
-	mcacheRefill_m,
-	largeAlloc_m,
-	gc_m,
-	scavenge_m,
-	setFinalizer_m,
-	removeFinalizer_m,
-	markallocated_m,
-	unrollgcprog_m,
-	unrollgcproginplace_m,
-	gosched_m,
-	setgcpercent_m,
-	setmaxthreads_m,
-	ready_m,
-	park_m mFunction
-)
+// C functions that run on the M stack.
+// Call using mcall.
+// These functions need to be written to arrange explicitly
+// for the goroutine to continue execution.
+func gosched_m(*g)
+func park_m(*g)
+
+// More C functions that run on the M stack.
+// Call using onM.
+// Arguments should be passed in m->scalararg[x] and m->ptrarg[x].
+// Return values can be passed in those same slots.
+// These functions return to the goroutine when they return.
+func mcacheRefill_m()
+func largeAlloc_m()
+func gc_m()
+func scavenge_m()
+func setFinalizer_m()
+func removeFinalizer_m()
+func markallocated_m()
+func unrollgcprog_m()
+func unrollgcproginplace_m()
+func setgcpercent_m()
+func setmaxthreads_m()
+func ready_m()
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s

From 54138e1ac356d824fe669b593c9ec24d9c7bbd3a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 11:36:14 -0400
Subject: [PATCH 349/423] cmd/cgo, runtime: write cgo stub wrappers in Go, not
 C

LGTM=alex.brainman, iant
R=golang-codereviews, alex.brainman, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/139070043
---
 misc/cgo/test/callback.go      |   7 +-
 src/cmd/cgo/out.go             | 220 ++++++++++++++++++---------------
 src/pkg/runtime/asm_386.s      |  11 +-
 src/pkg/runtime/asm_amd64.s    |  11 +-
 src/pkg/runtime/asm_amd64p32.s |   6 +
 src/pkg/runtime/asm_arm.s      |  11 +-
 src/pkg/runtime/cgocall.c      |  11 +-
 src/pkg/runtime/cgocall.h      |   1 +
 src/pkg/runtime/runtime.h      |   1 +
 9 files changed, 169 insertions(+), 110 deletions(-)

diff --git a/misc/cgo/test/callback.go b/misc/cgo/test/callback.go
index 82ed015bd8..67d271404a 100644
--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -13,12 +13,13 @@ void callPanic(void);
 import "C"
 
 import (
-	"./backdoor"
 	"path"
 	"runtime"
 	"strings"
 	"testing"
 	"unsafe"
+
+	"./backdoor"
 )
 
 // nestedCall calls into C, back into Go, and finally to f.
@@ -155,8 +156,8 @@ func testCallbackCallers(t *testing.T) {
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
 		"runtime.cgocallback_gofunc",
-		"runtime.asmcgocall",
-		"runtime.cgocall",
+		"runtime.asmcgocall_errno",
+		"runtime.cgocall_errno",
 		"test._Cfunc_callback",
 		"test.nestedCall",
 		"test.testCallbackCallers",
diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 6322e0604a..6586531ada 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -58,16 +58,14 @@ func (p *Package) writeDefs() {
 	fmt.Fprintf(fgo2, "// Created by cgo - DO NOT EDIT\n\n")
 	fmt.Fprintf(fgo2, "package %s\n\n", p.PackageName)
 	fmt.Fprintf(fgo2, "import \"unsafe\"\n\n")
-	if *importSyscall {
-		fmt.Fprintf(fgo2, "import \"syscall\"\n\n")
-	}
 	if !*gccgo && *importRuntimeCgo {
 		fmt.Fprintf(fgo2, "import _ \"runtime/cgo\"\n\n")
 	}
-	fmt.Fprintf(fgo2, "func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }\n\n")
 	if *importSyscall {
-		fmt.Fprintf(fgo2, "func _Cerrno(dst *error, x int32) { *dst = syscall.Errno(x) }\n")
+		fmt.Fprintf(fgo2, "import \"syscall\"\n\n")
+		fmt.Fprintf(fgo2, "var _ syscall.Errno\n")
 	}
+	fmt.Fprintf(fgo2, "func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }\n\n")
 
 	typedefNames := make([]string, 0, len(typedef))
 	for name := range typedef {
@@ -87,9 +85,10 @@ func (p *Package) writeDefs() {
 	}
 
 	if *gccgo {
-		fmt.Fprintf(fc, p.cPrologGccgo())
+		fmt.Fprint(fc, p.cPrologGccgo())
 	} else {
-		fmt.Fprintf(fc, cProlog)
+		fmt.Fprint(fc, cProlog)
+		fmt.Fprint(fgo2, goProlog)
 	}
 
 	gccgoSymbolPrefix := p.gccgoSymbolPrefix()
@@ -296,10 +295,6 @@ func (p *Package) structType(n *Name) (string, int64) {
 		fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
 		off += pad
 	}
-	if n.AddError {
-		fmt.Fprint(&buf, "\t\tint e[2*sizeof(void *)/sizeof(int)]; /* error */\n")
-		off += 2 * p.PtrSize
-	}
 	if off == 0 {
 		fmt.Fprintf(&buf, "\t\tchar unused;\n") // avoid empty struct
 	}
@@ -334,19 +329,18 @@ func (p *Package) writeDefsFunc(fc, fgo2 *os.File, n *Name) {
 	}
 
 	// Builtins defined in the C prolog.
-	inProlog := name == "CString" || name == "GoString" || name == "GoStringN" || name == "GoBytes" || name == "_CMalloc"
+	inProlog := builtinDefs[name] != ""
+	cname := fmt.Sprintf("_cgo%s%s", cPrefix, n.Mangle)
+	paramnames := []string(nil)
+	for i, param := range d.Type.Params.List {
+		paramName := fmt.Sprintf("p%d", i)
+		param.Names = []*ast.Ident{ast.NewIdent(paramName)}
+		paramnames = append(paramnames, paramName)
+	}
 
 	if *gccgo {
 		// Gccgo style hooks.
 		fmt.Fprint(fgo2, "\n")
-		cname := fmt.Sprintf("_cgo%s%s", cPrefix, n.Mangle)
-		paramnames := []string(nil)
-		for i, param := range d.Type.Params.List {
-			paramName := fmt.Sprintf("p%d", i)
-			param.Names = []*ast.Ident{ast.NewIdent(paramName)}
-			paramnames = append(paramnames, paramName)
-		}
-
 		conf.Fprint(fgo2, fset, d)
 		fmt.Fprint(fgo2, " {\n")
 		if !inProlog {
@@ -383,7 +377,7 @@ func (p *Package) writeDefsFunc(fc, fgo2 *os.File, n *Name) {
 		fmt.Fprint(fgo2, "}\n")
 
 		// declare the C function.
-		fmt.Fprintf(fgo2, "//extern _cgo%s%s\n", cPrefix, n.Mangle)
+		fmt.Fprintf(fgo2, "//extern %s\n", cname)
 		d.Name = ast.NewIdent(cname)
 		if n.AddError {
 			l := d.Type.Results.List
@@ -394,61 +388,49 @@ func (p *Package) writeDefsFunc(fc, fgo2 *os.File, n *Name) {
 
 		return
 	}
-	conf.Fprint(fgo2, fset, d)
-	fmt.Fprint(fgo2, "\n")
 
 	if inProlog {
+		fmt.Fprint(fgo2, builtinDefs[name])
 		return
 	}
 
-	var argSize int64
-	_, argSize = p.structType(n)
-
 	// C wrapper calls into gcc, passing a pointer to the argument frame.
-	fmt.Fprintf(fc, "#pragma cgo_import_static _cgo%s%s\n", cPrefix, n.Mangle)
-	fmt.Fprintf(fc, "void _cgo%s%s(void*);\n", cPrefix, n.Mangle)
-	fmt.Fprintf(fc, "\n")
-	fmt.Fprintf(fc, "void\n")
-	if argSize == 0 {
-		argSize++
+	fmt.Fprintf(fc, "#pragma cgo_import_static %s\n", cname)
+	fmt.Fprintf(fc, "void %s(void*);\n", cname)
+	fmt.Fprintf(fc, "void *·%s = %s;\n", cname, cname)
+
+	nret := 0
+	if !void {
+		d.Type.Results.List[0].Names = []*ast.Ident{ast.NewIdent("r1")}
+		nret = 1
 	}
-	// TODO(rsc): The struct here should declare pointers only where
-	// there are pointers in the actual argument frame.
-	// This is a workaround for golang.org/issue/6397.
-	fmt.Fprintf(fc, "·%s(struct{", n.Mangle)
-	if n := argSize / p.PtrSize; n > 0 {
-		fmt.Fprintf(fc, "void *y[%d];", n)
-	}
-	if n := argSize % p.PtrSize; n > 0 {
-		fmt.Fprintf(fc, "uint8 x[%d];", n)
-	}
-	fmt.Fprintf(fc, "}p)\n")
-	fmt.Fprintf(fc, "{\n")
-	fmt.Fprintf(fc, "\truntime·cgocall(_cgo%s%s, &p);\n", cPrefix, n.Mangle)
 	if n.AddError {
-		// gcc leaves errno in first word of interface at end of p.
-		// check whether it is zero; if so, turn interface into nil.
-		// if not, turn interface into errno.
-		// Go init function initializes ·_Cerrno with an os.Errno
-		// for us to copy.
-		fmt.Fprintln(fc, `	{
-			int32 e;
-			void **v;
-			v = (void**)(&p+1) - 2;	/* v = final two void* of p */
-			e = *(int32*)v;
-			v[0] = (void*)0xdeadbeef;
-			v[1] = (void*)0xdeadbeef;
-			if(e == 0) {
-				/* nil interface */
-				v[0] = 0;
-				v[1] = 0;
-			} else {
-				·_Cerrno(v, e);	/* fill in v as error for errno e */
-			}
-		}`)
+		d.Type.Results.List[nret].Names = []*ast.Ident{ast.NewIdent("r2")}
 	}
-	fmt.Fprintf(fc, "}\n")
-	fmt.Fprintf(fc, "\n")
+
+	fmt.Fprint(fgo2, "\n")
+	fmt.Fprintf(fgo2, "var %s unsafe.Pointer\n", cname)
+	conf.Fprint(fgo2, fset, d)
+	fmt.Fprint(fgo2, " {\n")
+
+	// NOTE: Using uintptr to hide from escape analysis.
+	arg := "0"
+	if len(paramnames) > 0 {
+		arg = "uintptr(unsafe.Pointer(&p0))"
+	} else if !void {
+		arg = "uintptr(unsafe.Pointer(&r1))"
+	}
+
+	prefix := ""
+	if n.AddError {
+		prefix = "errno := "
+	}
+	fmt.Fprintf(fgo2, "\t%s_cgo_runtime_cgocall_errno(%s, %s)\n", prefix, cname, arg)
+	if n.AddError {
+		fmt.Fprintf(fgo2, "\tif errno != 0 { r2 = syscall.Errno(errno) }\n")
+	}
+	fmt.Fprintf(fgo2, "\treturn\n")
+	fmt.Fprintf(fgo2, "}\n")
 }
 
 // writeOutput creates stubs for a specific source file to be compiled by 6g
@@ -521,7 +503,11 @@ func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
 
 	// Gcc wrapper unpacks the C argument struct
 	// and calls the actual C function.
-	fmt.Fprintf(fgcc, "void\n")
+	if n.AddError {
+		fmt.Fprintf(fgcc, "int\n")
+	} else {
+		fmt.Fprintf(fgcc, "void\n")
+	}
 	fmt.Fprintf(fgcc, "_cgo%s%s(void *v)\n", cPrefix, n.Mangle)
 	fmt.Fprintf(fgcc, "{\n")
 	if n.AddError {
@@ -557,7 +543,7 @@ func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
 	}
 	fmt.Fprintf(fgcc, ");\n")
 	if n.AddError {
-		fmt.Fprintf(fgcc, "\t*(int*)(a->e) = errno;\n")
+		fmt.Fprintf(fgcc, "\treturn errno;\n")
 	}
 	fmt.Fprintf(fgcc, "}\n")
 	fmt.Fprintf(fgcc, "\n")
@@ -1166,46 +1152,74 @@ const cProlog = `
 #include "runtime.h"
 #include "cgocall.h"
 
+static void *cgocall_errno = runtime·cgocall_errno;
+void *·_cgo_runtime_cgocall_errno = &cgocall_errno;
+
+static void *runtime_gostring = runtime·gostring;
+void *·_cgo_runtime_gostring = &runtime_gostring;
+
+static void *runtime_gostringn = runtime·gostringn;
+void *·_cgo_runtime_gostringn = &runtime_gostringn;
+
+static void *runtime_gobytes = runtime·gobytes;
+void *·_cgo_runtime_gobytes = &runtime_gobytes;
+
+static void *runtime_cmalloc = runtime·cmalloc;
+void *·_cgo_runtime_cmalloc = &runtime_cmalloc;
+
 void ·_Cerrno(void*, int32);
+`
 
-void
-·_Cfunc_GoString(int8 *p, String s)
-{
-	s = runtime·gostring((byte*)p);
-	FLUSH(&s);
-}
+const goProlog = `
+var _cgo_runtime_cgocall_errno func(unsafe.Pointer, uintptr) int32
+var _cgo_runtime_cmalloc func(uintptr) unsafe.Pointer
+`
 
-void
-·_Cfunc_GoStringN(int8 *p, int32 l, String s)
-{
-	s = runtime·gostringn((byte*)p, l);
-	FLUSH(&s);
-}
-
-void
-·_Cfunc_GoBytes(int8 *p, int32 l, Slice s)
-{
-	s = runtime·gobytes((byte*)p, l);
-	FLUSH(&s);
-}
-
-void
-·_Cfunc_CString(String s, int8 *p)
-{
-	p = runtime·cmalloc(s.len+1);
-	runtime·memmove((byte*)p, s.str, s.len);
-	p[s.len] = 0;
-	FLUSH(&p);
-}
-
-void
-·_Cfunc__CMalloc(uintptr n, int8 *p)
-{
-	p = runtime·cmalloc(n);
-	FLUSH(&p);
+const goStringDef = `
+var _cgo_runtime_gostring func(*_Ctype_char) string
+func _Cfunc_GoString(p *_Ctype_char) string {
+	return _cgo_runtime_gostring(p)
 }
 `
 
+const goStringNDef = `
+var _cgo_runtime_gostringn func(*_Ctype_char, int) string
+func _Cfunc_GoStringN(p *_Ctype_char, l _Ctype_int) string {
+	return _cgo_runtime_gostringn(p, int(l))
+}
+`
+
+const goBytesDef = `
+var _cgo_runtime_gobytes func(unsafe.Pointer, int) []byte
+func _Cfunc_GoBytes(p unsafe.Pointer, l _Ctype_int) []byte {
+	return _cgo_runtime_gobytes(p, int(l))
+}
+`
+
+const cStringDef = `
+func _Cfunc_CString(s string) *_Ctype_char {
+	p := _cgo_runtime_cmalloc(uintptr(len(s)+1))
+	pp := (*[1<<30]byte)(p)
+	copy(pp[:], s)
+	pp[len(s)] = 0
+	return (*_Ctype_char)(p)
+}
+`
+
+const cMallocDef = `
+func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
+	return _cgo_runtime_cmalloc(uintptr(n))
+}
+`
+
+var builtinDefs = map[string]string{
+	"GoString":  goStringDef,
+	"GoStringN": goStringNDef,
+	"GoBytes":   goBytesDef,
+	"CString":   cStringDef,
+	"_CMalloc":  cMallocDef,
+}
+
 func (p *Package) cPrologGccgo() string {
 	return strings.Replace(cPrologGccgo, "PREFIX", cPrefix, -1)
 }
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 07158ef0fd..8a5fd3fb08 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -680,7 +680,15 @@ TEXT gosave<>(SB),NOSPLIT,$0
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT runtime·asmcgocall(SB),NOSPLIT,$0-8
+TEXT runtime·asmcgocall(SB),NOSPLIT,$12-8
+	MOVL	fn+0(FP), AX
+	MOVL	arg+4(FP), BX
+	MOVL	AX, 0(SP)
+	MOVL	BX, 4(SP)
+	CALL	runtime·asmcgocall_errno(SB)
+	RET
+
+TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 	MOVL	fn+0(FP), AX
 	MOVL	arg+4(FP), BX
 	MOVL	SP, DX
@@ -712,6 +720,7 @@ TEXT runtime·asmcgocall(SB),NOSPLIT,$0-8
 	MOVL	8(SP), DI
 	MOVL	DI, g(CX)
 	MOVL	4(SP), SP
+	MOVL	AX, ret+8(FP)
 	RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 1d98fc2652..0846966f12 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -764,7 +764,15 @@ TEXT gosave<>(SB),NOSPLIT,$0
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT runtime·asmcgocall(SB),NOSPLIT,$0-16
+TEXT runtime·asmcgocall(SB),NOSPLIT,$24-16
+	MOVQ	fn+0(FP), AX
+	MOVQ	arg+8(FP), BX
+	MOVQ	AX, 0(SP)
+	MOVQ	BX, 8(SP)
+	CALL	runtime·asmcgocall_errno(SB)
+	RET
+
+TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-20
 	MOVQ	fn+0(FP), AX
 	MOVQ	arg+8(FP), BX
 	MOVQ	SP, DX
@@ -805,6 +813,7 @@ nosave:
 	MOVQ	48(SP), DI
 	MOVQ	DI, g(CX)
 	MOVQ	40(SP), SP
+	MOVL	AX, ret+16(FP)
 	RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 20069a6c7e..7886861eb2 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -711,6 +711,12 @@ TEXT runtime·asmcgocall(SB),NOSPLIT,$0-8
 	MOVL	0, AX
 	RET
 
+// asmcgocall(void(*fn)(void*), void *arg)
+// Not implemented.
+TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
+	MOVL	0, AX
+	RET
+
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
 // Not implemented.
 TEXT runtime·cgocallback(SB),NOSPLIT,$0-12
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 6e12cf60f3..67763e1b2e 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -493,7 +493,15 @@ TEXT gosave<>(SB),NOSPLIT,$0
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT	runtime·asmcgocall(SB),NOSPLIT,$0-8
+TEXT	runtime·asmcgocall(SB),NOSPLIT,$12-8
+	MOVW	fn+0(FP), R1
+	MOVW	arg+4(FP), R2
+	MOVW	R1, 0(R13)
+	MOVW	R2, 4(R13)
+	BL	runtime·asmcgocall_errno(SB)
+	RET
+
+TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 	MOVW	fn+0(FP), R1
 	MOVW	arg+4(FP), R0
 	MOVW	R13, R2
@@ -521,6 +529,7 @@ TEXT	runtime·asmcgocall(SB),NOSPLIT,$0-8
 	// Restore registers, g, stack pointer.
 	MOVW	20(R13), g
 	MOVW	16(R13), R13
+	MOVW	R0, ret+8(FP)
 	RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
diff --git a/src/pkg/runtime/cgocall.c b/src/pkg/runtime/cgocall.c
index 145ac7dc19..0fd5fbd00c 100644
--- a/src/pkg/runtime/cgocall.c
+++ b/src/pkg/runtime/cgocall.c
@@ -96,8 +96,15 @@ static FuncVal endcgoV = { endcgo };
 
 void
 runtime·cgocall(void (*fn)(void*), void *arg)
+{
+	runtime·cgocall_errno(fn, arg);
+}
+
+int32
+runtime·cgocall_errno(void (*fn)(void*), void *arg)
 {
 	Defer d;
+	int32 errno;
 
 	if(!runtime·iscgo && !Solaris && !Windows)
 		runtime·throw("cgocall unavailable");
@@ -140,13 +147,15 @@ runtime·cgocall(void (*fn)(void*), void *arg)
 	 * the $GOMAXPROCS accounting.
 	 */
 	runtime·entersyscall();
-	runtime·asmcgocall(fn, arg);
+	errno = runtime·asmcgocall_errno(fn, arg);
 	runtime·exitsyscall();
 
 	if(g->defer != &d || d.fn != &endcgoV)
 		runtime·throw("runtime: bad defer entry in cgocallback");
 	g->defer = d.link;
 	endcgo();
+	
+	return errno;
 }
 
 static void
diff --git a/src/pkg/runtime/cgocall.h b/src/pkg/runtime/cgocall.h
index 253661a7e7..c87a9cdc5d 100644
--- a/src/pkg/runtime/cgocall.h
+++ b/src/pkg/runtime/cgocall.h
@@ -7,6 +7,7 @@
  */
 
 void runtime·cgocall(void (*fn)(void*), void*);
+int32 runtime·cgocall_errno(void (*fn)(void*), void*);
 void runtime·cgocallback(void (*fn)(void), void*, uintptr);
 void *runtime·cmalloc(uintptr);
 void runtime·cfree(void*);
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index d67d7a0076..0d25ca6c51 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -848,6 +848,7 @@ void	runtime·tsleep(int64, String);
 M*	runtime·newm(void);
 void	runtime·goexit(void);
 void	runtime·asmcgocall(void (*fn)(void*), void*);
+int32	runtime·asmcgocall_errno(void (*fn)(void*), void*);
 void	runtime·entersyscall(void);
 void	runtime·entersyscallblock(void);
 void	runtime·exitsyscall(void);

From f44073785a99c2b6656156fe42055f81d29f5e1a Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Wed, 3 Sep 2014 08:49:43 -0700
Subject: [PATCH 350/423] runtime: deferproc/deferreturn in Go

LGTM=rsc
R=golang-codereviews, rsc, khr
CC=golang-codereviews
https://golang.org/cl/139900043
---
 src/cmd/api/goapi.go           |   3 +-
 src/pkg/runtime/asm_386.s      |   4 +
 src/pkg/runtime/asm_amd64.s    |   4 +
 src/pkg/runtime/asm_amd64p32.s |   4 +
 src/pkg/runtime/asm_arm.s      |   3 +
 src/pkg/runtime/extern.go      |   9 --
 src/pkg/runtime/malloc.c       |   6 +-
 src/pkg/runtime/malloc.h       |   1 +
 src/pkg/runtime/panic.c        | 219 ++++-----------------------------
 src/pkg/runtime/panic.go       | 199 ++++++++++++++++++++++++++++++
 src/pkg/runtime/stubs.go       |  18 ++-
 src/pkg/runtime/traceback.go   |   4 +-
 src/pkg/runtime/vlrt.go        |   2 -
 13 files changed, 259 insertions(+), 217 deletions(-)

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 7f7b389be3..ce806fc95d 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -379,7 +379,9 @@ 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.
 		src := "package runtime; type (" +
+			" _defer struct{};" +
 			" _func struct{};" +
+			" _select struct{}; " +
 			" _type struct{};" +
 			" alg struct{};" +
 			" chantype struct{};" +
@@ -403,7 +405,6 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" sudog struct{};" +
 			" waitq struct{};" +
 			" wincallbackcontext struct{};" +
-			" _select struct{}; " +
 			"); " +
 			"const (" +
 			" cb_max = 2000;" +
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 8a5fd3fb08..2477726f51 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -2310,3 +2310,7 @@ TEXT runtime·fastrand1(SB), NOSPLIT, $0-4
 	MOVL	DX, m_fastrand(AX)
 	MOVL	DX, ret+0(FP)
 	RET
+
+TEXT runtime·return0(SB), NOSPLIT, $0
+	MOVL	$0, AX
+	RET
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 0846966f12..d7e30de7b4 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -2362,3 +2362,7 @@ TEXT runtime·fastrand1(SB), NOSPLIT, $0-4
 	MOVL	DX, m_fastrand(AX)
 	MOVL	DX, ret+0(FP)
 	RET
+
+TEXT runtime·return0(SB), NOSPLIT, $0
+	MOVL	$0, AX
+	RET
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 7886861eb2..5ff89cf068 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -1232,3 +1232,7 @@ TEXT runtime·fastrand1(SB), NOSPLIT, $0-4
 	MOVL	DX, m_fastrand(AX)
 	MOVL	DX, ret+0(FP)
 	RET
+
+TEXT runtime·return0(SB), NOSPLIT, $0
+	MOVL	$0, AX
+	RET
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 67763e1b2e..26b58cfb17 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -1286,3 +1286,6 @@ TEXT runtime·fastrand1(SB), NOSPLIT, $-4-4
 TEXT runtime·gocputicks(SB), NOSPLIT, $0
 	B runtime·cputicks(SB)
 
+TEXT runtime·return0(SB), NOSPLIT, $0
+	MOVW	$0, R0
+	RET
diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index d75d2b4e54..2ca22d923b 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -77,15 +77,6 @@ package runtime
 
 import "unsafe"
 
-// Goexit terminates the goroutine that calls it.  No other goroutine is affected.
-// Goexit runs all deferred calls before terminating the goroutine.
-//
-// Calling Goexit from the main goroutine terminates that goroutine
-// without func main returning. Since func main has not returned,
-// the program continues execution of other goroutines.
-// If all other goroutines exit, the program crashes.
-func Goexit()
-
 // sigpanic is the C function sigpanic.
 // That is, unsafe.Pointer(&sigpanic) is the C function pointer for sigpanic.
 var sigpanic struct{}
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 8210081553..311cc442c2 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -21,7 +21,7 @@ MHeap runtime·mheap;
 #pragma dataflag NOPTR
 MStats runtime·memstats;
 
-static Type* notype;
+Type* runtime·conservative;
 
 void runtime·cmallocgc(uintptr size, Type *typ, uint32 flag, void **ret);
 void runtime·gc_notype_ptr(Eface*);
@@ -35,7 +35,7 @@ runtime·mallocgc(uintptr size, Type *typ, uint32 flag)
 	// TODO: maybe someday we can get rid of this.  It is
 	// probably the only location where we run Go code on the M stack.
 	if((flag&FlagNoScan) == 0 && typ == nil)
-		typ = notype;
+		typ = runtime·conservative;
 	runtime·cmallocgc(size, typ, flag, &ret);
 	return ret;
 }
@@ -259,7 +259,7 @@ runtime·mallocinit(void)
 	g->m->mcache = runtime·allocmcache();
 
 	runtime·gc_notype_ptr(&notype_eface);
-	notype = notype_eface.type;
+	runtime·conservative = notype_eface.type;
 }
 
 void*
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index f328feb172..d9a2bf84ba 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -528,6 +528,7 @@ void*	runtime·cnewarray(Type*, intgo);
 void	runtime·tracealloc(void*, uintptr, Type*);
 void	runtime·tracefree(void*, uintptr);
 void	runtime·tracegc(void);
+extern Type*	runtime·conservative;
 
 int32	runtime·gcpercent;
 int32	runtime·readgogc(void);
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index 4b6829e011..72078f4343 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -10,182 +10,32 @@
 
 // Code related to defer, panic and recover.
 
+// TODO: remove once code is moved to Go
+extern Defer* runtime·newdefer(int32 siz);
+extern runtime·freedefer(Defer *d);
+
 uint32 runtime·panicking;
 static Mutex paniclk;
 
-// Each P holds pool for defers with arg sizes 8, 24, 40, 56 and 72 bytes.
-// Memory block is 40 (24 for 32 bits) bytes larger due to Defer header.
-// This maps exactly to malloc size classes.
-
-// defer size class for arg size sz
-#define DEFERCLASS(sz) (((sz)+7)>>4)
-// total size of memory block for defer with arg size sz
-#define TOTALSIZE(sz) (sizeof(Defer) - sizeof(((Defer*)nil)->args) + ROUND(sz, sizeof(uintptr)))
-
-// Allocate a Defer, usually using per-P pool.
-// Each defer must be released with freedefer.
-static Defer*
-newdefer(int32 siz)
-{
-	int32 total, sc;
-	Defer *d;
-	P *p;
-
-	d = nil;
-	sc = DEFERCLASS(siz);
-	if(sc < nelem(p->deferpool)) {
-		p = g->m->p;
-		d = p->deferpool[sc];
-		if(d)
-			p->deferpool[sc] = d->link;
-	}
-	if(d == nil) {
-		// deferpool is empty or just a big defer
-		total = runtime·roundupsize(TOTALSIZE(siz));
-		d = runtime·mallocgc(total, nil, 0);
-	}
-	d->siz = siz;
-	d->special = 0;
-	d->link = g->defer;
-	g->defer = d;
-	return d;
-}
-
-// Free the given defer.
-// The defer cannot be used after this call.
-static void
-freedefer(Defer *d)
-{
-	int32 sc;
-	P *p;
-
-	if(d->special)
-		return;
-	sc = DEFERCLASS(d->siz);
-	if(sc < nelem(p->deferpool)) {
-		p = g->m->p;
-		d->link = p->deferpool[sc];
-		p->deferpool[sc] = d;
-		// No need to wipe out pointers in argp/pc/fn/args,
-		// because we empty the pool before GC.
-	}
-}
-
-// Create a new deferred function fn with siz bytes of arguments.
-// The compiler turns a defer statement into a call to this.
-// Cannot split the stack because it assumes that the arguments
-// are available sequentially after &fn; they would not be
-// copied if a stack split occurred.  It's OK for this to call
-// functions that split the stack.
-#pragma textflag NOSPLIT
-uintptr
-runtime·deferproc(int32 siz, FuncVal *fn, ...)
-{
-	Defer *d;
-
-	d = newdefer(siz);
-	d->fn = fn;
-	d->pc = (uintptr)runtime·getcallerpc(&siz);
-	if(thechar == '5')
-		d->argp = (uintptr)(&fn+2);  // skip caller's saved link register
-	else
-		d->argp = (uintptr)(&fn+1);
-	runtime·memmove(d->args, (byte*)d->argp, d->siz);
-
-	// deferproc returns 0 normally.
-	// a deferred func that stops a panic
-	// makes the deferproc return 1.
-	// the code the compiler generates always
-	// checks the return value and jumps to the
-	// end of the function if deferproc returns != 0.
-	return 0;
-}
-
-// Run a deferred function if there is one.
-// The compiler inserts a call to this at the end of any
-// function which calls defer.
-// If there is a deferred function, this will call runtime·jmpdefer,
-// which will jump to the deferred function such that it appears
-// to have been called by the caller of deferreturn at the point
-// just before deferreturn was called.  The effect is that deferreturn
-// is called again and again until there are no more deferred functions.
-// Cannot split the stack because we reuse the caller's frame to
-// call the deferred function.
-
-// The single argument isn't actually used - it just has its address
-// taken so it can be matched against pending defers.
-#pragma textflag NOSPLIT
 void
-runtime·deferreturn(uintptr arg0)
-{
-	Defer *d;
-	uintptr argp;
+runtime·deferproc_m(void) {
+	int32 siz;
 	FuncVal *fn;
-
-	d = g->defer;
-	if(d == nil)
-		return;
-	argp = (uintptr)&arg0;
-	if(d->argp != argp)
-		return;
-
-	// Moving arguments around.
-	// Do not allow preemption here, because the garbage collector
-	// won't know the form of the arguments until the jmpdefer can
-	// flip the PC over to fn.
-	g->m->locks++;
-	runtime·memmove((byte*)argp, d->args, d->siz);
-	fn = d->fn;
-	g->defer = d->link;
-	freedefer(d);
-	g->m->locks--;
-	if(g->m->locks == 0 && g->preempt)
-		g->stackguard0 = StackPreempt;
-	runtime·jmpdefer(fn, argp);
-}
-
-// Ensure that defer arg sizes that map to the same defer size class
-// also map to the same malloc size class.
-void
-runtime·testdefersizes(void)
-{
-	P *p;
-	int32 i, siz, defersc, mallocsc;
-	int32 map[nelem(p->deferpool)];
-
-	for(i=0; i<nelem(p->deferpool); i++)
-		map[i] = -1;
-	for(i=0;; i++) {
-		defersc = DEFERCLASS(i);
-		if(defersc >= nelem(p->deferpool))
-			break;
-		siz = TOTALSIZE(i);
-		mallocsc = runtime·SizeToClass(siz);
-		siz = runtime·class_to_size[mallocsc];
-		// runtime·printf("defer class %d: arg size %d, block size %d(%d)\n", defersc, i, siz, mallocsc);
-		if(map[defersc] < 0) {
-			map[defersc] = mallocsc;
-			continue;
-		}
-		if(map[defersc] != mallocsc) {
-			runtime·printf("bad defer size class: i=%d siz=%d mallocsc=%d/%d\n",
-				i, siz, map[defersc], mallocsc);
-			runtime·throw("bad defer size class");
-		}
-	}
-}
-
-// Run all deferred functions for the current goroutine.
-static void
-rundefer(void)
-{
+	uintptr argp;
+	uintptr callerpc;
 	Defer *d;
 
-	while((d = g->defer) != nil) {
-		g->defer = d->link;
-		reflect·call(d->fn, (byte*)d->args, d->siz, d->siz);
-		freedefer(d);
-	}
+	siz = g->m->scalararg[0];
+	fn = g->m->ptrarg[0];
+	argp = g->m->scalararg[1];
+	callerpc = g->m->scalararg[2];
+	g->m->ptrarg[0] = nil;
+
+	d = runtime·newdefer(siz);
+	d->fn = fn;
+	d->pc = callerpc;
+	d->argp = argp;
+	runtime·memmove(d->args, (void*)argp, siz);
 }
 
 // Print all currently active panics.  Used when crashing.
@@ -252,14 +102,14 @@ runtime·panic(Eface e)
 			runtime·throw("bad defer entry in panic");
 		g->defer = dabort.link;
 
-		freedefer(d);
+		runtime·freedefer(d);
 		if(p.recovered) {
 			g->panic = p.link;
 			// Aborted panics are marked but remain on the g->panic list.
 			// Recovery will unwind the stack frames containing their Panic structs.
 			// Remove them from the list and free the associated defers.
 			while(g->panic && g->panic->aborted) {
-				freedefer(g->panic->defer);
+				runtime·freedefer(g->panic->defer);
 				g->panic = g->panic->link;
 			}
 			if(g->panic == nil)	// must be done with signal
@@ -464,20 +314,6 @@ runtime·dopanic(int32 unused)
 	runtime·exit(2);
 }
 
-void
-runtime·throwreturn(void)
-{
-	// can only happen if compiler is broken
-	runtime·throw("no return at end of a typed function - compiler is broken");
-}
-
-void
-runtime·throwinit(void)
-{
-	// can only happen with linker skew
-	runtime·throw("recursive call during initialization - linker skew");
-}
-
 bool
 runtime·canpanic(G *gp)
 {
@@ -560,16 +396,3 @@ runtime·panicstring(int8 *s)
 	runtime·newErrorCString(s, &err);
 	runtime·panic(err);
 }
-
-void
-runtime·Goexit(void)
-{
-	rundefer();
-	runtime·goexit();
-}
-
-void
-runtime·panicdivide(void)
-{
-	runtime·panicstring("integer divide by zero");
-}
diff --git a/src/pkg/runtime/panic.go b/src/pkg/runtime/panic.go
index 9b95f49673..1e35561d15 100644
--- a/src/pkg/runtime/panic.go
+++ b/src/pkg/runtime/panic.go
@@ -4,6 +4,8 @@
 
 package runtime
 
+import "unsafe"
+
 var indexError = error(errorString("index out of range"))
 
 func panicindex() {
@@ -15,3 +17,200 @@ var sliceError = error(errorString("slice bounds out of range"))
 func panicslice() {
 	panic(sliceError)
 }
+
+var divideError = error(errorString("integer divide by zero"))
+
+func panicdivide() {
+	panic(divideError)
+}
+
+func throwreturn() {
+	gothrow("no return at end of a typed function - compiler is broken")
+}
+
+func throwinit() {
+	gothrow("recursive call during initialization - linker skew")
+}
+
+// Create a new deferred function fn with siz bytes of arguments.
+// The compiler turns a defer statement into a call to this.
+//go:nosplit
+func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
+	// the arguments of fn are in a perilous state.  The stack map
+	// for deferproc does not describe them.  So we can't let garbage
+	// collection or stack copying trigger until we've copied them out
+	// to somewhere safe.  deferproc_m does that.  Until deferproc_m,
+	// we can only call nosplit routines.
+	argp := uintptr(unsafe.Pointer(&fn))
+	argp += unsafe.Sizeof(fn)
+	if GOARCH == "arm" {
+		argp += ptrSize // skip caller's saved link register
+	}
+	mp := acquirem()
+	mp.scalararg[0] = uintptr(siz)
+	mp.ptrarg[0] = unsafe.Pointer(fn)
+	mp.scalararg[1] = argp
+	mp.scalararg[2] = getcallerpc(unsafe.Pointer(&siz))
+
+	if mp.curg != getg() {
+		// go code on the m stack can't defer
+		gothrow("defer on m")
+	}
+
+	onM(deferproc_m)
+
+	releasem(mp)
+
+	// deferproc returns 0 normally.
+	// a deferred func that stops a panic
+	// makes the deferproc return 1.
+	// the code the compiler generates always
+	// checks the return value and jumps to the
+	// end of the function if deferproc returns != 0.
+	return0()
+	// No code can go here - the C return register has
+	// been set and must not be clobbered.
+}
+
+// Each P holds pool for defers with arg sizes 8, 24, 40, 56 and 72 bytes.
+// Memory block is 40 (24 for 32 bits) bytes larger due to Defer header.
+// This maps exactly to malloc size classes.
+
+// defer size class for arg size sz
+func deferclass(siz uintptr) uintptr {
+	return (siz + 7) >> 4
+}
+
+// total size of memory block for defer with arg size sz
+func totaldefersize(siz uintptr) uintptr {
+	return (unsafe.Sizeof(_defer{}) - unsafe.Sizeof(_defer{}.args)) + round(siz, ptrSize)
+}
+
+// Ensure that defer arg sizes that map to the same defer size class
+// also map to the same malloc size class.
+func testdefersizes() {
+	var m [len(p{}.deferpool)]int32
+
+	for i := range m {
+		m[i] = -1
+	}
+	for i := uintptr(0); ; i++ {
+		defersc := deferclass(i)
+		if defersc >= uintptr(len(m)) {
+			break
+		}
+		siz := goroundupsize(totaldefersize(i))
+		if m[defersc] < 0 {
+			m[defersc] = int32(siz)
+			continue
+		}
+		if m[defersc] != int32(siz) {
+			print("bad defer size class: i=", i, " siz=", siz, " defersc=", defersc, "\n")
+			gothrow("bad defer size class")
+		}
+	}
+}
+
+// Allocate a Defer, usually using per-P pool.
+// Each defer must be released with freedefer.
+// Note: runs on M stack
+func newdefer(siz int32) *_defer {
+	var d *_defer
+	sc := deferclass(uintptr(siz))
+	mp := acquirem()
+	if sc < uintptr(len(p{}.deferpool)) {
+		pp := mp.p
+		d = pp.deferpool[sc]
+		if d != nil {
+			pp.deferpool[sc] = d.link
+		}
+	}
+	if d == nil {
+		// deferpool is empty or just a big defer
+		total := goroundupsize(totaldefersize(uintptr(siz)))
+		d = (*_defer)(gomallocgc(total, conservative, 0))
+	}
+	d.siz = siz
+	d.special = false
+	gp := mp.curg
+	d.link = gp._defer
+	gp._defer = d
+	releasem(mp)
+	return d
+}
+
+// Free the given defer.
+// The defer cannot be used after this call.
+func freedefer(d *_defer) {
+	if d.special {
+		return
+	}
+	sc := deferclass(uintptr(d.siz))
+	if sc < uintptr(len(p{}.deferpool)) {
+		mp := acquirem()
+		pp := mp.p
+		d.link = pp.deferpool[sc]
+		pp.deferpool[sc] = d
+		releasem(mp)
+		// No need to wipe out pointers in argp/pc/fn/args,
+		// because we empty the pool before GC.
+	}
+}
+
+// Run a deferred function if there is one.
+// The compiler inserts a call to this at the end of any
+// function which calls defer.
+// If there is a deferred function, this will call runtime·jmpdefer,
+// which will jump to the deferred function such that it appears
+// to have been called by the caller of deferreturn at the point
+// just before deferreturn was called.  The effect is that deferreturn
+// is called again and again until there are no more deferred functions.
+// Cannot split the stack because we reuse the caller's frame to
+// call the deferred function.
+
+// The single argument isn't actually used - it just has its address
+// taken so it can be matched against pending defers.
+//go:nosplit
+func deferreturn(arg0 uintptr) {
+	gp := getg()
+	d := gp._defer
+	if d == nil {
+		return
+	}
+	argp := uintptr(unsafe.Pointer(&arg0))
+	if d.argp != argp {
+		return
+	}
+
+	// Moving arguments around.
+	// Do not allow preemption here, because the garbage collector
+	// won't know the form of the arguments until the jmpdefer can
+	// flip the PC over to fn.
+	mp := acquirem()
+	memmove(unsafe.Pointer(argp), unsafe.Pointer(&d.args), uintptr(d.siz))
+	fn := d.fn
+	gp._defer = d.link
+	freedefer(d)
+	releasem(mp)
+	jmpdefer(fn, argp)
+}
+
+// Goexit terminates the goroutine that calls it.  No other goroutine is affected.
+// Goexit runs all deferred calls before terminating the goroutine.
+//
+// Calling Goexit from the main goroutine terminates that goroutine
+// without func main returning. Since func main has not returned,
+// the program continues execution of other goroutines.
+// If all other goroutines exit, the program crashes.
+func Goexit() {
+	// Run all deferred functions for the current goroutine.
+	gp := getg()
+	for gp._defer != nil {
+		d := gp._defer
+		gp._defer = d.link
+		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz))
+		freedefer(d)
+		// Note: we ignore recovers here because Goexit isn't a panic
+	}
+	goexit()
+}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index b002da98b4..bf83500b5a 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -41,6 +41,7 @@ func racereleaseg(gp *g, addr unsafe.Pointer)
 func racefingo()
 
 // Should be a built-in for unsafe.Pointer?
+//go:nosplit
 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
 	return unsafe.Pointer(uintptr(p) + x)
 }
@@ -85,6 +86,8 @@ func unrollgcproginplace_m()
 func setgcpercent_m()
 func setmaxthreads_m()
 func ready_m()
+func deferproc_m()
+func goexit_m()
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
@@ -126,6 +129,7 @@ func gothrow(s string)
 // output depends on the input.  noescape is inlined and currently
 // compiles down to a single xor instruction.
 // USE CAREFULLY!
+//go:nosplit
 func noescape(p unsafe.Pointer) unsafe.Pointer {
 	x := uintptr(p)
 	return unsafe.Pointer(x ^ 0)
@@ -141,7 +145,9 @@ func gosave(buf *gobuf)
 func read(fd int32, p unsafe.Pointer, n int32) int32
 func close(fd int32) int32
 func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
-func jmpdefer(fv *funcval, argp unsafe.Pointer)
+
+//go:noescape
+func jmpdefer(fv *funcval, argp uintptr)
 func exit1(code int32)
 func asminit()
 func setg(gg *g)
@@ -162,6 +168,7 @@ func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer
 func readgogc() int32
 func purgecachedstats(c *mcache)
 func gostringnocopy(b *byte) string
+func goexit()
 
 //go:noescape
 func write(fd uintptr, p unsafe.Pointer, n int32) int32
@@ -249,8 +256,15 @@ func gofuncname(f *_func) string {
 
 const _NoArgs = ^uintptr(0)
 
-var newproc, deferproc, lessstack struct{} // C/assembly functions
+var newproc, lessstack struct{} // C/assembly functions
 
 func funcspdelta(*_func, uintptr) int32 // symtab.c
 func funcarglen(*_func, uintptr) int32  // symtab.c
 const _ArgsSizeUnknown = -0x80000000    // funcdata.h
+
+// return0 is a stub used to return 0 from deferproc.
+// It is called at the very end of deferproc to signal
+// the calling Go function that it should not jump
+// to deferreturn.
+// in asm_*.s
+func return0()
diff --git a/src/pkg/runtime/traceback.go b/src/pkg/runtime/traceback.go
index 26d0f5fc92..6286c9dac1 100644
--- a/src/pkg/runtime/traceback.go
+++ b/src/pkg/runtime/traceback.go
@@ -33,6 +33,7 @@ const usesLR = GOARCH != "amd64" && GOARCH != "amd64p32" && GOARCH != "386"
 // jmpdeferPC is the PC at the beginning of the jmpdefer assembly function.
 // The traceback needs to recognize it on link register architectures.
 var jmpdeferPC = funcPC(jmpdefer)
+var deferprocPC = funcPC(deferproc)
 
 // System-specific hook. See traceback_windows.go
 var systraceback func(*_func, *stkframe, *g, bool, func(*stkframe, unsafe.Pointer) bool, unsafe.Pointer) (changed, aborted bool)
@@ -342,7 +343,7 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 
 	skipped:
 		waspanic = f.entry == uintptr(unsafe.Pointer(&sigpanic))
-		wasnewproc = f.entry == uintptr(unsafe.Pointer(&newproc)) || f.entry == uintptr(unsafe.Pointer(&deferproc))
+		wasnewproc = f.entry == uintptr(unsafe.Pointer(&newproc)) || f.entry == deferprocPC
 
 		// Do not unwind past the bottom of the stack.
 		if flr == nil {
@@ -582,7 +583,6 @@ func tracebackothers(me *g) {
 	unlock(&allglock)
 }
 
-func goexit()
 func mstart()
 func morestack()
 func rt0_go()
diff --git a/src/pkg/runtime/vlrt.go b/src/pkg/runtime/vlrt.go
index 50097edde7..6370732ca0 100644
--- a/src/pkg/runtime/vlrt.go
+++ b/src/pkg/runtime/vlrt.go
@@ -256,5 +256,3 @@ func slowdodiv(n, d uint64) (q, r uint64) {
 	}
 	return q, n
 }
-
-func panicdivide()

From 56bd176e1d5f0145936128c0dc1f931cc5a84c0b Mon Sep 17 00:00:00 2001
From: Rick Hudson <rlh@golang.org>
Date: Wed, 3 Sep 2014 12:06:36 -0400
Subject: [PATCH 351/423] runtime: Start and stop individual goroutines at gc
 safepoints

Code to bring goroutines to a gc safepoint one at a time,
do some work such as scanning, and restart the
goroutine, and then move on to the next goroutine.
Currently this code does not do much useful work
but this infrastructure will be critical to future
concurrent GC work.

Fixed comments reviewers.

LGTM=rsc
R=golang-codereviews, rsc, dvyukov
CC=golang-codereviews
https://golang.org/cl/131580043
---
 src/pkg/runtime/mgc0.c    |  39 +++++++-
 src/pkg/runtime/proc.c    | 206 ++++++++++++++++++++++++++++++++++++--
 src/pkg/runtime/runtime.h |  19 +++-
 src/pkg/runtime/stack.c   |   8 ++
 4 files changed, 262 insertions(+), 10 deletions(-)

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 2ae23e8bf0..05e555b8a4 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -432,6 +432,7 @@ markroot(ParFor *desc, uint32 i)
 	G *gp;
 	void *p;
 	uint32 status;
+	bool restart;
 
 	USED(&desc);
 	// Note: if you add a case here, please also update heapdump.c:dumproots.
@@ -493,9 +494,15 @@ markroot(ParFor *desc, uint32 i)
 			gp->waitsince = work.tstart;
 		// Shrink a stack if not much of it is being used.
 		runtime·shrinkstack(gp);
+		if(runtime·readgstatus(gp) == Gdead) 
+			gp->gcworkdone = true;
+		else 
+			gp->gcworkdone = false; 
+		restart = runtime·stopg(gp);
 		scanstack(gp);
+		if(restart)
+			runtime·restartg(gp);
 		break;
-		
 	}
 }
 
@@ -687,7 +694,12 @@ scanstack(G *gp)
 	uintptr sp, guard;
 	bool (*fn)(Stkframe*, void*);
 
-	switch(runtime·readgstatus(gp)) {
+	if(runtime·readgstatus(gp)&Gscan == 0) {
+		runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
+		runtime·throw("mark - bad status");
+	}
+
+	switch(runtime·readgstatus(gp)&~Gscan) {
 	default:
 		runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
 		runtime·throw("mark - bad status");
@@ -747,6 +759,29 @@ scanstack(G *gp)
 	}
 }
 
+// The gp has been moved to a gc safepoint. If there is gcphase specific
+// work it is done here. 
+void
+runtime·gcphasework(G *gp)
+{
+	switch(runtime·gcphase) {
+	default:
+		runtime·throw("gcphasework in bad gcphase");
+	case GCoff:
+	case GCquiesce:
+	case GCstw:
+	case GCsweep:
+		// No work for now.
+		break;
+	case GCmark:
+		// Disabled until concurrent GC is implemented
+		// but indicate the scan has been done. 
+		// scanstack(gp);
+		break;
+	}
+	gp->gcworkdone = true;
+}
+
 void
 runtime·queuefinalizer(byte *p, FuncVal *fn, uintptr nret, Type *fint, PtrType *ot)
 {
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index bc15d822cb..53d3d23d1e 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -128,6 +128,7 @@ static bool preemptone(P*);
 static bool exitsyscallfast(void);
 static bool haveexperiment(int8*);
 static void allgadd(G*);
+static void dropg(void);
 
 extern String runtime·buildVersion;
 
@@ -272,7 +273,8 @@ runtime·main(void)
 static void
 dumpgstatus(G* gp)
 {
-	runtime·printf("runtime: gp=%p, goid=%D, gp->atomicstatus=%d\n", gp, gp->goid, runtime·readgstatus(gp));
+	runtime·printf("runtime: gp: gp=%p, goid=%D, gp->atomicstatus=%x\n", gp, gp->goid, runtime·readgstatus(gp));
+	runtime·printf("runtime:  g:  g=%p, goid=%D,  g->atomicstatus=%x\n", g, g->goid, runtime·readgstatus(g));
 }
 
 static void
@@ -508,10 +510,202 @@ runtime·casgstatus(G *gp, uint32 oldval, uint32 newval)
 		runtime·throw("casgstatus: bad incoming values");
 	}
 
+	// loop if gp->atomicstatus is in a scan state giving
+	// GC time to finish and change the state to oldval.
 	while(!runtime·cas(&gp->atomicstatus, oldval, newval)) {
-		// loop if gp->atomicstatus is in a  scan state giving
-		// GC time to finish and change the state to oldval.
+		// Help GC if needed. 
+		if(gp->preemptscan && !gp->gcworkdone && (oldval == Grunning || oldval == Gsyscall)) {
+			gp->preemptscan = false;
+			runtime·gcphasework(gp);
+		}
+	}	
+}
+
+// stopg ensures that gp is stopped at a GC safe point where its stack can be scanned
+// or in the context of a moving collector the pointers can be flipped from pointing 
+// to old object to pointing to new objects. 
+// If stopg returns true, the caller knows gp is at a GC safe point and will remain there until
+// the caller calls restartg.
+// If stopg returns false, the caller is not responsible for calling restartg. This can happen
+// if another thread, either the gp itself or another GC thread is taking the responsibility 
+// to do the GC work related to this thread.
+bool
+runtime·stopg(G *gp)
+{
+	uint32 s;
+
+	for(;;) {
+		if(gp->gcworkdone)
+			return false;
+
+		s = runtime·readgstatus(gp);
+		switch(s) {
+		default:
+			dumpgstatus(gp);
+			runtime·throw("stopg: gp->atomicstatus is not valid");
+
+		case Gdead:
+			return false;
+
+		case Gcopystack:
+			// Loop until a new stack is in place.
+			break;
+
+		case Grunnable:
+		case Gsyscall:
+		case Gwaiting:
+			// Claim goroutine by setting scan bit.
+			if(!runtime·castogscanstatus(gp, s, s|Gscan))
+				break;
+			// In scan state, do work.
+			runtime·gcphasework(gp);
+			return true;
+
+		case Gscanrunnable:
+		case Gscanwaiting:
+		case Gscansyscall:
+			// Goroutine already claimed by another GC helper.
+			return false;
+
+		case Grunning:
+			// Claim goroutine, so we aren't racing with a status
+			// transition away from Grunning.
+			if(!runtime·castogscanstatus(gp, Grunning, Gscanrunning))
+				break;
+
+			// Mark gp for preemption.
+			if(!gp->gcworkdone) {
+				gp->preemptscan = true;
+				gp->preempt = true;
+				gp->stackguard0 = StackPreempt;
+			}
+
+			// Unclaim.
+			runtime·casfromgscanstatus(gp, Gscanrunning, Grunning);
+			return false;
+		}
 	}
+	// Should not be here....
+}
+
+// The GC requests that this routine be moved from a scanmumble state to a mumble state.
+void 
+runtime·restartg (G *gp)
+{
+	uint32 s;
+
+	s = runtime·readgstatus(gp);
+	switch(s) {
+	default:
+		dumpgstatus(gp); 
+		runtime·throw("restartg: unexpected status");
+
+	case Gdead:
+		break;
+
+	case Gscanrunnable:
+	case Gscanwaiting:
+	case Gscansyscall:
+		runtime·casfromgscanstatus(gp, s, s&~Gscan);
+		break;
+
+	case Gscanenqueue:
+		// Scan is now completed.
+		// Goroutine now needs to be made runnable.
+		// We put it on the global run queue; ready blocks on the global scheduler lock.
+		runtime·casfromgscanstatus(gp, Gscanenqueue, Gwaiting);
+		if(gp != g->m->curg)
+			runtime·throw("processing Gscanenqueue on wrong m");
+		dropg();
+		runtime·ready(gp);
+		break;
+	}
+}
+
+static void
+stopscanstart(G* gp)
+{
+	if(g == gp)
+		runtime·throw("GC not moved to G0");
+	if(runtime·stopg(gp)) {
+		if(!isscanstatus(runtime·readgstatus(gp))) {
+			dumpgstatus(gp);
+			runtime·throw("GC not in scan state");
+		}
+		runtime·restartg(gp);
+	}
+}
+
+// Runs on g0 and does the actual work after putting the g back on the run queue.
+static void
+mquiesce(G *gpmaster)
+{
+	G* gp;
+	uint32 i;
+	uint32 status;
+	uint32 activeglen;
+
+	activeglen = runtime·allglen;
+	// enqueue the calling goroutine.
+	runtime·restartg(gpmaster);
+	for(i = 0; i < activeglen; i++) {
+		gp = runtime·allg[i];
+		if(runtime·readgstatus(gp) == Gdead) 
+			gp->gcworkdone = true; // noop scan.
+		else 
+			gp->gcworkdone = false; 
+		stopscanstart(gp); 
+	}
+
+	// Check that the G's gcwork (such as scanning) has been done. If not do it now. 
+	// You can end up doing work here if the page trap on a Grunning Goroutine has
+	// not been sprung or in some race situations. For example a runnable goes dead
+	// and is started up again with a gp->gcworkdone set to false.
+	for(i = 0; i < activeglen; i++) {
+		gp = runtime·allg[i];
+		while (!gp->gcworkdone) {
+			status = runtime·readgstatus(gp);
+			if(status == Gdead) {
+				gp->gcworkdone = true; // scan is a noop
+				break;
+				//do nothing, scan not needed. 
+			}
+			if(status == Grunning && gp->stackguard0 == (uintptr)StackPreempt && runtime·notetsleep(&runtime·sched.stopnote, 100*1000)) // nanosecond arg 
+				runtime·noteclear(&runtime·sched.stopnote);
+			else 
+				stopscanstart(gp);
+		}
+	}
+
+	for(i = 0; i < activeglen; i++) {
+		gp = runtime·allg[i];
+		status = runtime·readgstatus(gp);
+		if(isscanstatus(status)) {
+			runtime·printf("mstopandscang:bottom: post scan bad status gp=%p has status %x\n", gp, status);
+			dumpgstatus(gp);
+		}
+		if(!gp->gcworkdone && status != Gdead) {
+			runtime·printf("mstopandscang:bottom: post scan gp=%p->gcworkdone still false\n", gp);
+			dumpgstatus(gp);
+		}
+	}
+
+	schedule(); // Never returns.
+}
+
+// quiesce moves all the goroutines to a GC safepoint which for now is a at preemption point.
+// If the global runtime·gcphase is GCmark quiesce will ensure that all of the goroutine's stacks
+// have been scanned before it returns.
+void
+runtime·quiesce(G* mastergp)
+{
+	void (*fn)(G*);
+
+	runtime·castogscanstatus(mastergp, Grunning, Gscanenqueue);
+	// Now move this to the g0 (aka m) stack.
+	// g0 will potentially scan this thread and put mastergp on the runqueue 
+	fn = mquiesce;
+	runtime·mcall(&fn);
 }
 
 // This is used by the GC as well as the routines that do stack dumps. In the case
@@ -1503,7 +1697,7 @@ runtime·gosched_m(G *gp)
 	uint32 status;
 
 	status = runtime·readgstatus(gp);
-	if ((status&~Gscan) != Grunning){
+	if((status&~Gscan) != Grunning){
 		dumpgstatus(gp);
 		runtime·throw("bad g status");
 	}
@@ -2031,7 +2225,7 @@ allgadd(G *gp)
 	G **new;
 	uintptr cap;
 
-	if (runtime·readgstatus(gp) == Gidle) 
+	if(runtime·readgstatus(gp) == Gidle) 
 		runtime·throw("allgadd: bad status Gidle");
 
 	runtime·lock(&allglock);
@@ -2062,7 +2256,7 @@ gfput(P *p, G *gp)
 	uintptr stksize;
 	Stktop *top;
 
-	if (runtime·readgstatus(gp) != Gdead) 
+	if(runtime·readgstatus(gp) != Gdead) 
 		runtime·throw("gfput: bad status (not Gdead)");
 
 	if(gp->stackguard - StackGuard != gp->stack0)
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 0d25ca6c51..84a373cd51 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -292,7 +292,7 @@ struct	G
 	bool	preempt;	// preemption signal, duplicates stackguard0 = StackPreempt
 	bool	paniconfault;	// panic (instead of crash) on unexpected fault address
 	bool    preemptscan;    // preempted g does scan for GC
-	bool    scancheck;      // debug: cleared at begining of scan cycle, set by scan, tested at end of cycle
+	bool    gcworkdone;     // debug: cleared at begining of gc work phase cycle, set by gcphasework, tested at end of cycle
 	int8	raceignore;	// ignore race detection events
 	M*	m;		// for debuggers, but offset not hard-coded
 	M*	lockedm;
@@ -579,6 +579,16 @@ struct DebugVars
 	int32	scavenge;
 };
 
+// Indicates to write barrier and sychronization task to preform.
+enum
+{                   // Synchronization            Write barrier
+	GCoff,      // stop and start             nop
+	GCquiesce,  // stop and start             nop
+	GCstw,      // stop the ps                nop
+	GCmark,     // scan the stacks and start  no white to black
+	GCsweep,    // stop and start             nop
+};
+
 struct ForceGCState
 {
 	Mutex	lock;
@@ -586,6 +596,7 @@ struct ForceGCState
 	uint32	idle;
 };
 
+extern uint32 runtime·gcphase;
 extern bool runtime·precisestack;
 extern bool runtime·copystack;
 
@@ -614,8 +625,12 @@ enum {
 	HashRandomBytes = 32
 };
 
-uint32  runtime·readgstatus(G *gp);
+uint32  runtime·readgstatus(G*);
 void    runtime·casgstatus(G*, uint32, uint32);
+void    runtime·quiesce(G*);
+bool    runtime·stopg(G*);
+void    runtime·restartg(G*);
+void    runtime·gcphasework(G*);
 
 /*
  * deferred subroutine calls
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 62ec5993a8..6a57ab08cf 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -936,6 +936,14 @@ runtime·newstack(void)
 			runtime·throw("runtime: g is running but p is not");
 		if(oldstatus == Gsyscall && g->m->locks == 0)
 			runtime·throw("runtime: stack growth during syscall");
+		if(oldstatus == Grunning && gp->preemptscan) {
+			runtime·gcphasework(gp);
+			runtime·casgstatus(gp, Gwaiting, Grunning);
+			gp->stackguard0 = gp->stackguard;
+			gp->preempt = false; 
+			gp->preemptscan = false;        // Tells the GC premption was successful.
+			runtime·gogo(&gp->sched);	// never return 
+		}
 
 		// Be conservative about where we preempt.
 		// We are interested in preempting user Go code, not runtime code.

From 467a6d28be15cfef05870262345201b133dc1a89 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Wed, 3 Sep 2014 20:47:30 +0400
Subject: [PATCH 352/423] runtime: adopt race detector for runtime written in
 Go Ignore memory access on g0/gsignal. See the issue for context and
 explanation. Fixes #8627.

LGTM=khr
R=golang-codereviews, mdempsky, khr
CC=golang-codereviews, rsc
https://golang.org/cl/137070043
---
 src/pkg/runtime/cpuprof.go | 10 +++-------
 src/pkg/runtime/proc.c     |  8 +++++---
 src/pkg/runtime/race.c     | 10 ++++++++++
 3 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/pkg/runtime/cpuprof.go b/src/pkg/runtime/cpuprof.go
index b397eafbe0..4325d7e1c3 100644
--- a/src/pkg/runtime/cpuprof.go
+++ b/src/pkg/runtime/cpuprof.go
@@ -239,9 +239,7 @@ Assoc:
 	// Reuse the newly evicted entry.
 	e.depth = uintptr(len(pc))
 	e.count = 1
-	for i := range pc {
-		e.stack[i] = pc[i]
-	}
+	copy(e.stack[:], pc)
 }
 
 // evict copies the given entry's data into the log, so that
@@ -266,10 +264,8 @@ func (p *cpuProfile) evict(e *cpuprofEntry) bool {
 	q++
 	log[q] = d
 	q++
-	for i := uintptr(0); i < d; i++ {
-		log[q] = e.stack[i]
-		q++
-	}
+	copy(log[q:], e.stack[:d])
+	q += d
 	p.nlog = q
 	e.count = 0
 	return true
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 53d3d23d1e..b159215d1b 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -214,7 +214,11 @@ void
 runtime·main(void)
 {
 	Defer d;
-	
+
+	// Racectx of m0->g0 is used only as the parent of the main goroutine.
+	// It must not be used for anything else.
+	g->m->g0->racectx = 0;
+
 	// Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
 	// Using decimal instead of binary GB and MB because
 	// they look nicer in the stack overflow failure message.
@@ -1166,8 +1170,6 @@ newm(void(*fn)(void), P *p)
 	mp = runtime·allocm(p);
 	mp->nextp = p;
 	mp->mstartfn = fn;
-	if(raceenabled)
-		mp->g0->racectx = runtime·racegostart(newm);
 
 	if(runtime·iscgo) {
 		CgoThreadStart ts;
diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index a773addb07..d5e77c7568 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -153,6 +153,11 @@ runtime·racegoend(void)
 void
 runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
 {
+	if(g != g->m->curg) {
+		// The call is coming from manual instrumentation of Go code running on g0/gsignal.
+		// Not interesting.
+		return;
+	}
 	if(callpc != nil)
 		runtime·racefuncenter(callpc);
 	runtime·racewriterangepc1(addr, sz, pc);
@@ -163,6 +168,11 @@ runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
 void
 runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
 {
+	if(g != g->m->curg) {
+		// The call is coming from manual instrumentation of Go code running on g0/gsignal.
+		// Not interesting.
+		return;
+	}
 	if(callpc != nil)
 		runtime·racefuncenter(callpc);
 	runtime·racereadrangepc1(addr, sz, pc);

From 176c44699b5be7861070c01856494b6b94ff918a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 12:48:32 -0400
Subject: [PATCH 353/423] runtime: remove guard against uninitialized forcegc.g

The race was in the old C code.
The new Go code does not have the race
and does not need the check.

LGTM=bradfitz, dvyukov
R=golang-codereviews, bradfitz, dvyukov
CC=golang-codereviews, rlh
https://golang.org/cl/140180043
---
 src/pkg/runtime/proc.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index b159215d1b..71ea89705b 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2955,12 +2955,9 @@ sysmon(void)
 		lastgc = runtime·atomicload64(&mstats.last_gc);
 		if(lastgc != 0 && unixnow - lastgc > forcegcperiod && runtime·atomicload(&runtime·forcegc.idle)) {
 			runtime·lock(&runtime·forcegc.lock);
-			if(runtime·forcegc.g != nil) {
-				// Goroutine may be started but has not initialized g yet.
-				runtime·forcegc.idle = 0;
-				runtime·forcegc.g->schedlink = nil;
-				injectglist(runtime·forcegc.g);
-			}
+			runtime·forcegc.idle = 0;
+			runtime·forcegc.g->schedlink = nil;
+			injectglist(runtime·forcegc.g);
 			runtime·unlock(&runtime·forcegc.lock);
 		}
 

From 4930a8d0582d96d390339d2ca454ff8375bb535a Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Wed, 3 Sep 2014 09:54:53 -0700
Subject: [PATCH 354/423] runtime: relax flaky GC pause test

We often saw GC pauses of 0 ns, not just on Windows.
Google Compute Engine timer granularity might suck
too.

LGTM=rsc
R=rsc, dvyukov
CC=golang-codereviews
https://golang.org/cl/140910043
---
 src/pkg/runtime/gc_test.go | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/gc_test.go b/src/pkg/runtime/gc_test.go
index 816fc89b04..6abec4cca7 100644
--- a/src/pkg/runtime/gc_test.go
+++ b/src/pkg/runtime/gc_test.go
@@ -165,9 +165,12 @@ func TestGcLastTime(t *testing.T) {
 		t.Fatalf("bad last GC time: got %v, want [%v, %v]", last, t0, t1)
 	}
 	pause := ms.PauseNs[(ms.NumGC+255)%256]
-	// Due to timer granularity pause can actually be 0 on windows.
-	if (pause == 0 && runtime.GOOS != "windows") || pause > 10e9 {
-		t.Fatalf("bad last GC pause: got %v, want [0, 10e9]", pause)
+	// Due to timer granularity, pause can actually be 0 on windows
+	// or on virtualized environments.
+	if pause == 0 {
+		t.Logf("last GC pause was 0")
+	} else if pause > 10e9 {
+		t.Logf("bad last GC pause: got %v, want [0, 10e9]", pause)
 	}
 }
 

From 97f8386af7907191cefbbfa26a3bd01c4ec95655 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 13:02:48 -0400
Subject: [PATCH 355/423] runtime: convert symtab.c into symtab.go

Because symtab.c was partially converted before,
the diffs are not terribly useful.

The earlier conversion was trying to refactor or
clean up the code in addition to doing the translation.
It also made a mistake by redefining Func to be something
users could overwrite.

I undid those changes, making symtab.go a more
literal line-for-line translation of symtab.c instead.

LGTM=josharian
R=golang-codereviews, dave, bradfitz, josharian
CC=golang-codereviews, iant, khr, r
https://golang.org/cl/140880043
---
 src/pkg/runtime/error.go     |   2 +-
 src/pkg/runtime/extern.go    |  13 +-
 src/pkg/runtime/funcdata.h   |   2 +
 src/pkg/runtime/runtime.c    |   1 +
 src/pkg/runtime/string.go    |  13 --
 src/pkg/runtime/stubs.go     |  18 +-
 src/pkg/runtime/symtab.c     | 333 -----------------------------------
 src/pkg/runtime/symtab.go    | 274 +++++++++++++++++++++-------
 src/pkg/runtime/traceback.go |  80 ++++++---
 9 files changed, 276 insertions(+), 460 deletions(-)
 delete mode 100644 src/pkg/runtime/symtab.c

diff --git a/src/pkg/runtime/error.go b/src/pkg/runtime/error.go
index 54591ee43e..3ea93680ce 100644
--- a/src/pkg/runtime/error.go
+++ b/src/pkg/runtime/error.go
@@ -85,7 +85,7 @@ type errorCString struct{ cstr unsafe.Pointer }
 func (e errorCString) RuntimeError() {}
 
 func (e errorCString) Error() string {
-	return "runtime error: " + cstringToGo(e.cstr)
+	return "runtime error: " + gostringnocopy((*byte)(e.cstr))
 }
 
 // For calling from C.
diff --git a/src/pkg/runtime/extern.go b/src/pkg/runtime/extern.go
index 2ca22d923b..3d06a23fce 100644
--- a/src/pkg/runtime/extern.go
+++ b/src/pkg/runtime/extern.go
@@ -75,12 +75,6 @@ of the run-time system.
 */
 package runtime
 
-import "unsafe"
-
-// sigpanic is the C function sigpanic.
-// That is, unsafe.Pointer(&sigpanic) is the C function pointer for sigpanic.
-var sigpanic struct{}
-
 // Caller reports file and line number information about function invocations on
 // the calling goroutine's stack.  The argument skip is the number of stack frames
 // to ascend, with 0 identifying the caller of Caller.  (For historical reasons the
@@ -109,7 +103,7 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
 	// All architectures turn faults into apparent calls to sigpanic.
 	// If we see a call to sigpanic, we do not back up the PC to find
 	// the line number of the call instruction, because there is no call.
-	if xpc > f.entry && (g == nil || g.entry != uintptr(unsafe.Pointer(&sigpanic))) {
+	if xpc > f.entry && (g == nil || g.entry != funcPC(sigpanic)) {
 		xpc--
 	}
 	line = int(funcline(f, xpc, &file))
@@ -117,11 +111,6 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
 	return
 }
 
-func findfunc(uintptr) *_func
-
-//go:noescape
-func funcline(*_func, uintptr, *string) int32
-
 // Callers fills the slice pc with the program counters of function invocations
 // on the calling goroutine's stack.  The argument skip is the number of stack frames
 // to skip before recording in pc, with 0 identifying the frame for Callers itself and
diff --git a/src/pkg/runtime/funcdata.h b/src/pkg/runtime/funcdata.h
index 85e82838b7..dc9c41363e 100644
--- a/src/pkg/runtime/funcdata.h
+++ b/src/pkg/runtime/funcdata.h
@@ -6,6 +6,8 @@
 // in Go binaries. It is included by both C and assembly, so it must
 // be written using #defines. It is included by the runtime package
 // as well as the compilers.
+//
+// symtab.go also contains a copy of these constants.
 
 #define PCDATA_ArgSize 0 /* argument size at CALL instruction */
 #define PCDATA_StackMapIndex 1
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index d4999e7465..b0adfb601b 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -120,6 +120,7 @@ runtime·goenvs_unix(void)
 	syscall·envs.cap = n;
 }
 
+#pragma textflag NOSPLIT
 Slice
 runtime·environ()
 {
diff --git a/src/pkg/runtime/string.go b/src/pkg/runtime/string.go
index 1cefad9671..91f33db118 100644
--- a/src/pkg/runtime/string.go
+++ b/src/pkg/runtime/string.go
@@ -145,19 +145,6 @@ type stringStruct struct {
 	len int
 }
 
-func cstringToGo(str unsafe.Pointer) (s string) {
-	i := 0
-	for ; ; i++ {
-		if *(*byte)(unsafe.Pointer(uintptr(str) + uintptr(i))) == 0 {
-			break
-		}
-	}
-	t := (*stringStruct)(unsafe.Pointer(&s))
-	t.str = unsafe.Pointer(str)
-	t.len = i
-	return
-}
-
 func intstring(v int64) string {
 	s, b := rawstring(4)
 	n := runetochar(b, rune(v))
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index bf83500b5a..14857908fd 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -248,19 +248,15 @@ func open(name *byte, mode, perm int32) int32
 //go:noescape
 func gotraceback(*bool) int32
 
-func funcname(*_func) *byte
-
-func gofuncname(f *_func) string {
-	return gostringnocopy(funcname(f))
-}
-
 const _NoArgs = ^uintptr(0)
 
-var newproc, lessstack struct{} // C/assembly functions
-
-func funcspdelta(*_func, uintptr) int32 // symtab.c
-func funcarglen(*_func, uintptr) int32  // symtab.c
-const _ArgsSizeUnknown = -0x80000000    // funcdata.h
+func newstack()
+func newproc()
+func lessstack()
+func morestack()
+func mstart()
+func rt0_go()
+func sigpanic()
 
 // return0 is a stub used to return 0 from deferproc.
 // It is called at the very end of deferproc to signal
diff --git a/src/pkg/runtime/symtab.c b/src/pkg/runtime/symtab.c
deleted file mode 100644
index 802ad5da38..0000000000
--- a/src/pkg/runtime/symtab.c
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Runtime symbol table parsing.
-// See http://golang.org/s/go12symtab for an overview.
-
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "funcdata.h"
-
-typedef struct Ftab Ftab;
-struct Ftab
-{
-	uintptr	entry;
-	uintptr	funcoff;
-};
-
-extern byte runtime·pclntab[];
-extern byte runtime·epclntab[];
-
-static Ftab *ftab;
-static uintptr runtime·nftab;
-static uint32 *filetab;
-static uint32 runtime·nfiletab;
-
-extern Slice runtime·pclntable;
-extern Slice runtime·ftabs;
-extern Slice runtime·filetab;
-extern uint32 runtime·pcquantum;
-
-static String end = { (uint8*)"end", 3 };
-
-void
-runtime·symtabinit(void)
-{
-	int32 i, j;
-	Func *f1, *f2;
-	
-	// See golang.org/s/go12symtab for header: 0xfffffffb,
-	// two zero bytes, a byte giving the PC quantum,
-	// and a byte giving the pointer width in bytes.
-	if(*(uint32*)runtime·pclntab != 0xfffffffb || runtime·pclntab[4] != 0 || runtime·pclntab[5] != 0 || runtime·pclntab[6] != PCQuantum || runtime·pclntab[7] != sizeof(void*)) {
-		runtime·printf("runtime: function symbol table header: %x %x\n", *(uint32*)runtime·pclntab, *(uint32*)(runtime·pclntab+4));
-		runtime·throw("invalid function symbol table\n");
-	}
-
-	runtime·nftab = *(uintptr*)(runtime·pclntab+8);
-	ftab = (Ftab*)(runtime·pclntab+8+sizeof(void*));
-	for(i=0; i<runtime·nftab; i++) {
-		// NOTE: ftab[runtime·nftab].entry is legal; it is the address beyond the final function.
-		if(ftab[i].entry > ftab[i+1].entry) {
-			f1 = (Func*)(runtime·pclntab + ftab[i].funcoff);
-			f2 = (Func*)(runtime·pclntab + ftab[i+1].funcoff);
-			runtime·printf("function symbol table not sorted by program counter: %p %s > %p %s", ftab[i].entry, runtime·funcname(f1), ftab[i+1].entry, i+1 == runtime·nftab ? "end" : runtime·funcname(f2));
-			for(j=0; j<=i; j++)
-				runtime·printf("\t%p %s\n", ftab[j].entry, runtime·funcname((Func*)(runtime·pclntab + ftab[j].funcoff)));
-			runtime·throw("invalid runtime symbol table");
-		}
-	}
-	
-	filetab = (uint32*)(runtime·pclntab + *(uint32*)&ftab[runtime·nftab].funcoff);
-	runtime·nfiletab = filetab[0];
-
-	runtime·pcquantum = PCQuantum;
-
-	runtime·pclntable.array = (byte*)runtime·pclntab;
-	runtime·pclntable.len = (byte*)runtime·epclntab - (byte*)runtime·pclntab;
-	runtime·pclntable.cap = runtime·pclntable.len;
-
-	runtime·ftabs.array = (byte*)ftab;
-	runtime·ftabs.len = runtime·nftab+1;
-	runtime·ftabs.cap = runtime·ftabs.len;
-
-	runtime·filetab.array = (byte*)filetab;
-	runtime·filetab.len = filetab[0];
-	runtime·filetab.cap = runtime·filetab.len;
-}
-
-static uint32
-readvarint(byte **pp)
-{
-	byte *p;
-	uint32 v;
-	int32 shift;
-	
-	v = 0;
-	p = *pp;
-	for(shift = 0;; shift += 7) {
-		v |= (*p & 0x7F) << shift;
-		if(!(*p++ & 0x80))
-			break;
-	}
-	*pp = p;
-	return v;
-}
-
-void*
-runtime·funcdata(Func *f, int32 i)
-{
-	byte *p;
-
-	if(i < 0 || i >= f->nfuncdata)
-		return nil;
-	p = (byte*)&f->nfuncdata + 4 + f->npcdata*4;
-	if(sizeof(void*) == 8 && ((uintptr)p & 4)) {
-		if(((uintptr)f & 4))
-			runtime·printf("misaligned func %p\n", f);
-		p += 4;
-	}
-	return ((void**)p)[i];
-}
-
-static bool
-step(byte **pp, uintptr *pc, int32 *value, bool first)
-{
-	uint32 uvdelta, pcdelta;
-	int32 vdelta;
-
-	uvdelta = readvarint(pp);
-	if(uvdelta == 0 && !first)
-		return 0;
-	if(uvdelta&1)
-		uvdelta = ~(uvdelta>>1);
-	else
-		uvdelta >>= 1;
-	vdelta = (int32)uvdelta;
-	pcdelta = readvarint(pp) * PCQuantum;
-	*value += vdelta;
-	*pc += pcdelta;
-	return 1;
-}
-
-// Return associated data value for targetpc in func f.
-// (Source file is f->src.)
-static int32
-pcvalue(Func *f, int32 off, uintptr targetpc, bool strict)
-{
-	byte *p;
-	uintptr pc;
-	int32 value;
-
-	enum {
-		debug = 0
-	};
-
-	// The table is a delta-encoded sequence of (value, pc) pairs.
-	// Each pair states the given value is in effect up to pc.
-	// The value deltas are signed, zig-zag encoded.
-	// The pc deltas are unsigned.
-	// The starting value is -1, the starting pc is the function entry.
-	// The table ends at a value delta of 0 except in the first pair.
-	if(off == 0)
-		return -1;
-	p = runtime·pclntab + off;
-	pc = f->entry;
-	value = -1;
-
-	if(debug && !runtime·panicking)
-		runtime·printf("pcvalue start f=%s [%p] pc=%p targetpc=%p value=%d tab=%p\n",
-			runtime·funcname(f), f, pc, targetpc, value, p);
-	
-	while(step(&p, &pc, &value, pc == f->entry)) {
-		if(debug)
-			runtime·printf("\tvalue=%d until pc=%p\n", value, pc);
-		if(targetpc < pc)
-			return value;
-	}
-	
-	// If there was a table, it should have covered all program counters.
-	// If not, something is wrong.
-	if(runtime·panicking || !strict)
-		return -1;
-	runtime·printf("runtime: invalid pc-encoded table f=%s pc=%p targetpc=%p tab=%p\n",
-		runtime·funcname(f), pc, targetpc, p);
-	p = (byte*)f + off;
-	pc = f->entry;
-	value = -1;
-	
-	while(step(&p, &pc, &value, pc == f->entry))
-		runtime·printf("\tvalue=%d until pc=%p\n", value, pc);
-	
-	runtime·throw("invalid runtime symbol table");
-	return -1;
-}
-
-static String unknown = { (uint8*)"?", 1 };
-
-int8*
-runtime·funcname(Func *f)
-{
-	if(f == nil || f->nameoff == 0)
-		return nil;
-	return (int8*)(runtime·pclntab + f->nameoff);
-}
-
-static int32
-funcline(Func *f, uintptr targetpc, String *file, bool strict)
-{
-	int32 line;
-	int32 fileno;
-
-	*file = unknown;
-	fileno = pcvalue(f, f->pcfile, targetpc, strict);
-	line = pcvalue(f, f->pcln, targetpc, strict);
-	if(fileno == -1 || line == -1 || fileno >= runtime·nfiletab) {
-		// runtime·printf("looking for %p in %S got file=%d line=%d\n", targetpc, *f->name, fileno, line);
-		return 0;
-	}
-	*file = runtime·gostringnocopy(runtime·pclntab + filetab[fileno]);
-	return line;
-}
-
-int32
-runtime·funcline(Func *f, uintptr targetpc, String *file)
-{
-	return funcline(f, targetpc, file, true);
-}
-
-int32
-runtime·funcspdelta(Func *f, uintptr targetpc)
-{
-	int32 x;
-	
-	x = pcvalue(f, f->pcsp, targetpc, true);
-	if(x&(sizeof(void*)-1))
-		runtime·printf("invalid spdelta %d %d\n", f->pcsp, x);
-	return x;
-}
-
-int32
-runtime·pcdatavalue(Func *f, int32 table, uintptr targetpc)
-{
-	if(table < 0 || table >= f->npcdata)
-		return -1;
-	return pcvalue(f, (&f->nfuncdata)[1+table], targetpc, true);
-}
-
-int32
-runtime·funcarglen(Func *f, uintptr targetpc)
-{
-	if(targetpc == f->entry)
-		return 0;
-	return runtime·pcdatavalue(f, PCDATA_ArgSize, targetpc-PCQuantum);
-}
-
-Func*
-runtime·findfunc(uintptr addr)
-{
-	Ftab *f;
-	int32 nf, n;
-
-	if(runtime·nftab == 0)
-		return nil;
-	if(addr < ftab[0].entry || addr >= ftab[runtime·nftab].entry)
-		return nil;
-
-	// binary search to find func with entry <= addr.
-	f = ftab;
-	nf = runtime·nftab;
-	while(nf > 0) {
-		n = nf/2;
-		if(f[n].entry <= addr && addr < f[n+1].entry)
-			return (Func*)(runtime·pclntab + f[n].funcoff);
-		else if(addr < f[n].entry)
-			nf = n;
-		else {
-			f += n+1;
-			nf -= n+1;
-		}
-	}
-
-	// can't get here -- we already checked above
-	// that the address was in the table bounds.
-	// this can only happen if the table isn't sorted
-	// by address or if the binary search above is buggy.
-	runtime·prints("findfunc unreachable\n");
-	return nil;
-}
-
-static bool
-hasprefix(String s, int8 *p)
-{
-	int32 i;
-
-	for(i=0; i<s.len; i++) {
-		if(p[i] == 0)
-			return 1;
-		if(p[i] != s.str[i])
-			return 0;
-	}
-	return p[i] == 0;
-}
-
-static bool
-contains(String s, int8 *p)
-{
-	int32 i;
-
-	if(p[0] == 0)
-		return 1;
-	for(i=0; i<s.len; i++) {
-		if(s.str[i] != p[0])
-			continue;
-		if(hasprefix((String){s.str + i, s.len - i}, p))
-			return 1;
-	}
-	return 0;
-}
-
-bool
-runtime·showframe(Func *f, G *gp)
-{
-	static int32 traceback = -1;
-	String name;
-
-	if(g->m->throwing > 0 && gp != nil && (gp == g->m->curg || gp == g->m->caughtsig))
-		return 1;
-	if(traceback < 0)
-		traceback = runtime·gotraceback(nil);
-	name = runtime·gostringnocopy((uint8*)runtime·funcname(f));
-
-	// Special case: always show runtime.panic frame, so that we can
-	// see where a panic started in the middle of a stack trace.
-	// See golang.org/issue/5832.
-	if(name.len == 7+1+5 && hasprefix(name, "runtime.panic"))
-		return 1;
-
-	return traceback > 1 || f != nil && contains(name, ".") && !hasprefix(name, "runtime.");
-}
diff --git a/src/pkg/runtime/symtab.go b/src/pkg/runtime/symtab.go
index 880a78d481..bd9e9924c4 100644
--- a/src/pkg/runtime/symtab.go
+++ b/src/pkg/runtime/symtab.go
@@ -6,25 +6,140 @@ package runtime
 
 import "unsafe"
 
+// NOTE: Func does not expose the actual unexported fields, because we return *Func
+// values to users, and we want to keep them from being able to overwrite the data
+// with (say) *f = Func{}.
+// All code operating on a *Func must call raw to get the *_func instead.
+
+// A Func represents a Go function in the running binary.
+type Func struct {
+	opaque struct{} // unexported field to disallow conversions
+}
+
+func (f *Func) raw() *_func {
+	return (*_func)(unsafe.Pointer(f))
+}
+
+// funcdata.h
+const (
+	_PCDATA_ArgSize             = 0
+	_PCDATA_StackMapIndex       = 1
+	_FUNCDATA_ArgsPointerMaps   = 0
+	_FUNCDATA_LocalsPointerMaps = 1
+	_FUNCDATA_DeadValueMaps     = 2
+	_ArgsSizeUnknown            = -0x80000000
+)
+
+var (
+	pclntable []byte
+	ftab      []functab
+	filetab   []uint32
+
+	pclntab, epclntab struct{} // linker symbols
+)
+
+type functab struct {
+	entry   uintptr
+	funcoff uintptr
+}
+
+func symtabinit() {
+	// See golang.org/s/go12symtab for header: 0xfffffffb,
+	// two zero bytes, a byte giving the PC quantum,
+	// and a byte giving the pointer width in bytes.
+	pcln := (*[8]byte)(unsafe.Pointer(&pclntab))
+	pcln32 := (*[2]uint32)(unsafe.Pointer(&pclntab))
+	if pcln32[0] != 0xfffffffb || pcln[4] != 0 || pcln[5] != 0 || pcln[6] != _PCQuantum || pcln[7] != ptrSize {
+		println("runtime: function symbol table header:", hex(pcln32[0]), hex(pcln[4]), hex(pcln[5]), hex(pcln[6]), hex(pcln[7]))
+		gothrow("invalid function symbol table\n")
+	}
+
+	// pclntable is all bytes of pclntab symbol.
+	sp := (*sliceStruct)(unsafe.Pointer(&pclntable))
+	sp.array = unsafe.Pointer(&pclntab)
+	sp.len = int(uintptr(unsafe.Pointer(&epclntab)) - uintptr(unsafe.Pointer(&pclntab)))
+	sp.cap = sp.len
+
+	// ftab is lookup table for function by program counter.
+	nftab := int(*(*uintptr)(add(unsafe.Pointer(pcln), 8)))
+	p := add(unsafe.Pointer(pcln), 8+ptrSize)
+	sp = (*sliceStruct)(unsafe.Pointer(&ftab))
+	sp.array = p
+	sp.len = nftab + 1
+	sp.cap = sp.len
+	for i := 0; i < nftab; i++ {
+		// NOTE: ftab[nftab].entry is legal; it is the address beyond the final function.
+		if ftab[i].entry > ftab[i+1].entry {
+			f1 := (*_func)(unsafe.Pointer(&pclntable[ftab[i].funcoff]))
+			f2 := (*_func)(unsafe.Pointer(&pclntable[ftab[i+1].funcoff]))
+			f2name := "end"
+			if i+1 < nftab {
+				f2name = gofuncname(f2)
+			}
+			println("function symbol table not sorted by program counter:", hex(ftab[i].entry), gofuncname(f1), ">", hex(ftab[i+1].entry), f2name)
+			for j := 0; j <= i; j++ {
+				print("\t", hex(ftab[j].entry), " ", gofuncname((*_func)(unsafe.Pointer(&pclntable[ftab[j].funcoff]))))
+			}
+			gothrow("invalid runtime symbol table")
+		}
+	}
+
+	// file table follows ftab.
+	sp = (*sliceStruct)(unsafe.Pointer(&filetab))
+	p = unsafe.Pointer(add(unsafe.Pointer(pcln), ftab[nftab].funcoff))
+	sp.array = unsafe.Pointer(add(unsafe.Pointer(pcln), ftab[nftab].funcoff))
+	// length is in first element of array.
+	// set len to 1 so we can get first element.
+	sp.len = 1
+	sp.cap = 1
+	sp.len = int(filetab[0])
+	sp.cap = sp.len
+}
+
 // FuncForPC returns a *Func describing the function that contains the
 // given program counter address, or else nil.
 func FuncForPC(pc uintptr) *Func {
-	if len(ftabs) == 0 {
+	return (*Func)(unsafe.Pointer(findfunc(pc)))
+}
+
+// Name returns the name of the function.
+func (f *Func) Name() string {
+	return gofuncname(f.raw())
+}
+
+// Entry returns the entry address of the function.
+func (f *Func) Entry() uintptr {
+	return f.raw().entry
+}
+
+// FileLine returns the file name and line number of the
+// source code corresponding to the program counter pc.
+// The result will not be accurate if pc is not a program
+// counter within f.
+func (f *Func) FileLine(pc uintptr) (file string, line int) {
+	// Pass strict=false here, because anyone can call this function,
+	// and they might just be wrong about targetpc belonging to f.
+	line = int(funcline1(f.raw(), pc, &file, false))
+	return file, line
+}
+
+func findfunc(pc uintptr) *_func {
+	if len(ftab) == 0 {
 		return nil
 	}
 
-	if pc < ftabs[0].entry || pc >= ftabs[len(ftabs)-1].entry {
+	if pc < ftab[0].entry || pc >= ftab[len(ftab)-1].entry {
 		return nil
 	}
 
 	// binary search to find func with entry <= pc.
 	lo := 0
-	nf := len(ftabs) - 1 // last entry is sentinel
+	nf := len(ftab) - 1 // last entry is sentinel
 	for nf > 0 {
 		n := nf / 2
-		f := &ftabs[lo+n]
-		if f.entry <= pc && pc < ftabs[lo+n+1].entry {
-			return (*Func)(unsafe.Pointer(&pclntable[f.funcoff]))
+		f := &ftab[lo+n]
+		if f.entry <= pc && pc < ftab[lo+n+1].entry {
+			return (*_func)(unsafe.Pointer(&pclntable[f.funcoff]))
 		} else if pc < f.entry {
 			nf = n
 		} else {
@@ -33,39 +148,11 @@ func FuncForPC(pc uintptr) *Func {
 		}
 	}
 
-	gothrow("FuncForPC: binary search failed")
+	gothrow("findfunc: binary search failed")
 	return nil
 }
 
-// Name returns the name of the function.
-func (f *Func) Name() string {
-	return cstringToGo(unsafe.Pointer(&pclntable[f.nameoff]))
-}
-
-// Entry returns the entry address of the function.
-func (f *Func) Entry() uintptr {
-	return f.entry
-}
-
-// FileLine returns the file name and line number of the
-// source code corresponding to the program counter pc.
-// The result will not be accurate if pc is not a program
-// counter within f.
-func (f *Func) FileLine(pc uintptr) (file string, line int) {
-	fileno := int(f.pcvalue(f.pcfile, pc))
-	if fileno == -1 || fileno >= len(filetab) {
-		return "?", 0
-	}
-	line = int(f.pcvalue(f.pcln, pc))
-	if line == -1 {
-		return "?", 0
-	}
-	file = cstringToGo(unsafe.Pointer(&pclntable[filetab[fileno]]))
-	return file, line
-}
-
-// Return associated data value for targetpc in func f.
-func (f *Func) pcvalue(off int32, targetpc uintptr) int32 {
+func pcvalue(f *_func, off int32, targetpc uintptr, strict bool) int32 {
 	if off == 0 {
 		return -1
 	}
@@ -82,9 +169,95 @@ func (f *Func) pcvalue(off int32, targetpc uintptr) int32 {
 			return val
 		}
 	}
+
+	// If there was a table, it should have covered all program counters.
+	// If not, something is wrong.
+	if panicking != 0 || !strict {
+		return -1
+	}
+
+	print("runtime: invalid pc-encoded table f=", gofuncname(f), " pc=", hex(pc), " targetpc=", hex(targetpc), " tab=", p, "\n")
+
+	p = pclntable[off:]
+	pc = f.entry
+	val = -1
+	for {
+		var ok bool
+		p, ok = step(p, &pc, &val, pc == f.entry)
+		if !ok {
+			break
+		}
+		print("\tvalue=", val, " until pc=", hex(pc), "\n")
+	}
+
+	gothrow("invalid runtime symbol table")
 	return -1
 }
 
+func funcname(f *_func) *byte {
+	if f == nil || f.nameoff == 0 {
+		return nil
+	}
+	return (*byte)(unsafe.Pointer(&pclntable[f.nameoff]))
+}
+
+func gofuncname(f *_func) string {
+	return gostringnocopy(funcname(f))
+}
+
+func funcline1(f *_func, targetpc uintptr, file *string, strict bool) int32 {
+	*file = "?"
+	fileno := int(pcvalue(f, f.pcfile, targetpc, strict))
+	line := pcvalue(f, f.pcln, targetpc, strict)
+	if fileno == -1 || line == -1 || fileno >= len(filetab) {
+		// print("looking for ", hex(targetpc), " in ", gofuncname(f), " got file=", fileno, " line=", lineno, "\n")
+		return 0
+	}
+	*file = gostringnocopy(&pclntable[filetab[fileno]])
+	return line
+}
+
+func funcline(f *_func, targetpc uintptr, file *string) int32 {
+	return funcline1(f, targetpc, file, true)
+}
+
+func funcspdelta(f *_func, targetpc uintptr) int32 {
+	x := pcvalue(f, f.pcsp, targetpc, true)
+	if x&(ptrSize-1) != 0 {
+		print("invalid spdelta ", f.pcsp, " ", x, "\n")
+	}
+	return x
+}
+
+func pcdatavalue(f *_func, table int32, targetpc uintptr) int32 {
+	if table < 0 || table >= f.npcdata {
+		return -1
+	}
+	off := *(*int32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
+	return pcvalue(f, off, targetpc, true)
+}
+
+func funcarglen(f *_func, targetpc uintptr) int32 {
+	if targetpc == f.entry {
+		return 0
+	}
+	return pcdatavalue(f, _PCDATA_ArgSize, targetpc-_PCQuantum)
+}
+
+func funcdata(f *_func, i int32) unsafe.Pointer {
+	if i < 0 || i >= f.nfuncdata {
+		return nil
+	}
+	p := add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(f.npcdata)*4)
+	if ptrSize == 8 && uintptr(p)&4 != 0 {
+		if uintptr(unsafe.Pointer(f))&4 != 0 {
+			println("runtime: misaligned func", f)
+		}
+		p = add(p, 4)
+	}
+	return *(*unsafe.Pointer)(add(p, uintptr(i)*ptrSize))
+}
+
 // step advances to the next pc, value pair in the encoded table.
 func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool) {
 	p, uvdelta := readvarint(p)
@@ -98,7 +271,7 @@ func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool)
 	}
 	vdelta := int32(uvdelta)
 	p, pcdelta := readvarint(p)
-	*pc += uintptr(pcdelta * pcquantum)
+	*pc += uintptr(pcdelta * _PCQuantum)
 	*val += vdelta
 	return p, true
 }
@@ -117,30 +290,3 @@ func readvarint(p []byte) (newp []byte, val uint32) {
 	}
 	return p, v
 }
-
-// Populated by runtime·symtabinit during bootstrapping. Treat as immutable.
-var (
-	pclntable []byte
-	ftabs     []ftab
-	filetab   []uint32
-	pcquantum uint32
-)
-
-type Func struct {
-	entry   uintptr // start pc
-	nameoff int32   // function name
-
-	args  int32 // in/out args size
-	frame int32 // legacy frame size; use pcsp if possible
-
-	pcsp      int32
-	pcfile    int32
-	pcln      int32
-	npcdata   int32
-	nfuncdata int32
-}
-
-type ftab struct {
-	entry   uintptr
-	funcoff uintptr
-}
diff --git a/src/pkg/runtime/traceback.go b/src/pkg/runtime/traceback.go
index 6286c9dac1..adb03440b3 100644
--- a/src/pkg/runtime/traceback.go
+++ b/src/pkg/runtime/traceback.go
@@ -30,10 +30,22 @@ import "unsafe"
 
 const usesLR = GOARCH != "amd64" && GOARCH != "amd64p32" && GOARCH != "386"
 
-// jmpdeferPC is the PC at the beginning of the jmpdefer assembly function.
-// The traceback needs to recognize it on link register architectures.
-var jmpdeferPC = funcPC(jmpdefer)
-var deferprocPC = funcPC(deferproc)
+var (
+	deferprocPC = funcPC(deferproc)
+	goexitPC    = funcPC(goexit)
+	jmpdeferPC  = funcPC(jmpdefer)
+	lessstackPC = funcPC(lessstack)
+	mcallPC     = funcPC(mcall)
+	morestackPC = funcPC(morestack)
+	mstartPC    = funcPC(mstart)
+	newprocPC   = funcPC(newproc)
+	newstackPC  = funcPC(newstack)
+	onMPC       = funcPC(onM)
+	rt0_goPC    = funcPC(rt0_go)
+	sigpanicPC  = funcPC(sigpanic)
+
+	externalthreadhandlerp uintptr // initialized elsewhere
+)
 
 // System-specific hook. See traceback_windows.go
 var systraceback func(*_func, *stkframe, *g, bool, func(*stkframe, unsafe.Pointer) bool, unsafe.Pointer) (changed, aborted bool)
@@ -112,7 +124,7 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 		//	fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown.
 		//	stk is the stack containing sp.
 		//	The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp.
-		if frame.pc == uintptr(unsafe.Pointer(&lessstack)) {
+		if frame.pc == lessstackPC {
 			// Hit top of stack segment.  Unwind to next segment.
 			frame.pc = stk.gobuf.pc
 			frame.sp = stk.gobuf.sp
@@ -213,7 +225,7 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 				frame.arglen = uintptr(f.args)
 			} else if flr == nil {
 				frame.arglen = 0
-			} else if frame.lr == uintptr(unsafe.Pointer(&lessstack)) {
+			} else if frame.lr == lessstackPC {
 				frame.arglen = uintptr(stk.argsize)
 			} else {
 				i := funcarglen(flr, frame.lr)
@@ -342,8 +354,8 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 		n++
 
 	skipped:
-		waspanic = f.entry == uintptr(unsafe.Pointer(&sigpanic))
-		wasnewproc = f.entry == uintptr(unsafe.Pointer(&newproc)) || f.entry == deferprocPC
+		waspanic = f.entry == sigpanicPC
+		wasnewproc = f.entry == newprocPC || f.entry == deferprocPC
 
 		// Do not unwind past the bottom of the stack.
 		if flr == nil {
@@ -448,8 +460,6 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 	return n
 }
 
-func showframe(*_func, *g) bool
-
 func printcreatedby(gp *g) {
 	// Show what created goroutine, except main goroutine (goid 1).
 	pc := gp.gopc
@@ -499,6 +509,40 @@ func gcallers(gp *g, skip int, pcbuf *uintptr, m int) int {
 	return gentraceback(^uintptr(0), ^uintptr(0), 0, gp, skip, pcbuf, m, nil, nil, false)
 }
 
+func showframe(f *_func, gp *g) bool {
+	g := getg()
+	if g.m.throwing > 0 && gp != nil && (gp == g.m.curg || gp == g.m.caughtsig) {
+		return true
+	}
+	traceback := gotraceback(nil)
+	name := gostringnocopy(funcname(f))
+
+	// Special case: always show runtime.panic frame, so that we can
+	// see where a panic started in the middle of a stack trace.
+	// See golang.org/issue/5832.
+	if name == "runtime.panic" {
+		return true
+	}
+
+	return traceback > 1 || f != nil && contains(name, ".") && !hasprefix(name, "runtime.")
+}
+
+func contains(s, t string) bool {
+	if len(t) == 0 {
+		return true
+	}
+	for i := 0; i < len(s); i++ {
+		if s[i] == t[0] && hasprefix(s[i:], t) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasprefix(s, t string) bool {
+	return len(s) >= len(t) && s[:len(t)] == t
+}
+
 var gStatusStrings = [...]string{
 	_Gidle:      "idle",
 	_Grunnable:  "runnable",
@@ -583,22 +627,6 @@ func tracebackothers(me *g) {
 	unlock(&allglock)
 }
 
-func mstart()
-func morestack()
-func rt0_go()
-
-var (
-	goexitPC    = funcPC(goexit)
-	mstartPC    = funcPC(mstart)
-	mcallPC     = funcPC(mcall)
-	onMPC       = funcPC(onM)
-	morestackPC = funcPC(morestack)
-	lessstackPC = funcPC(lessstack)
-	rt0_goPC    = funcPC(rt0_go)
-
-	externalthreadhandlerp uintptr // initialized elsewhere
-)
-
 // Does f mark the top of a goroutine stack?
 func topofstack(f *_func) bool {
 	pc := f.entry

From f82097f5cf8a84b89fd8b9cc056f2854c1115c3c Mon Sep 17 00:00:00 2001
From: Robin Eklind <r.eklind.87@gmail.com>
Date: Wed, 3 Sep 2014 10:44:33 -0700
Subject: [PATCH 356/423] spec: Add link to rune literals from string literals
 when talking about escape sequences.

LGTM=gri
R=golang-codereviews, gobot, gri
CC=golang-codereviews
https://golang.org/cl/140750043
---
 doc/go_spec.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index eec1cdb7a7..e8bb35f0b0 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -479,7 +479,7 @@ Interpreted string literals are character sequences between double
 quotes <code>&quot;&quot;</code>. The text between the quotes,
 which may not contain newlines, forms the
 value of the literal, with backslash escapes interpreted as they
-are in rune literals (except that <code>\'</code> is illegal and
+are in <a href="#Rune_literals">rune literals</a> (except that <code>\'</code> is illegal and
 <code>\"</code> is legal), with the same restrictions.
 The three-digit octal (<code>\</code><i>nnn</i>)
 and two-digit hexadecimal (<code>\x</code><i>nn</i>) escapes represent individual

From 5ea69978fd07abdd4bb5ed63dfb38700389493c6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 17:42:35 -0400
Subject: [PATCH 357/423] runtime: make entersyscall/exitsyscall safe for stack
 splits

It is fundamentally unsafe to grow the stack once someone
has made a call to syscall.Syscall. That function takes 6 uintptr
arguments, but depending on the call some are pointers.
In fact, some might be pointers to stack values, and we don't know which.
That makes it impossible to copy the stack somewhere else.
Since we want to delete all the stack splitting code, relying only
on stack copying, make sure that Syscall never needs to split the stack.

The only thing Syscall does is:
        call entersyscall
        make the system call
        call exitsyscall

As long as we make sure that entersyscall and exitsyscall
can live in the nosplit region, they won't ask for more stack.

Do this by making entersyscall and exitsyscall set up the
stack guard so that any call to a function with a split check
will cause a crash. Then move non-essential slow-path
work onto the m stack using onM and mark the rest of the
work nosplit. The linker will verify that the chain of nosplits
fits in the total nosplit budget.

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/140950043
---
 src/pkg/runtime/proc.c    | 196 +++++++++++++++++++++++++++-----------
 src/pkg/runtime/runtime.h |   2 +-
 src/pkg/runtime/stack.c   |   2 +
 3 files changed, 141 insertions(+), 59 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 71ea89705b..dfbc6142d6 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -502,16 +502,24 @@ runtime·castogscanstatus(G *gp, uint32 oldval, uint32 newval)
 	return false; // not reached
 }
 
+static void badcasgstatus(void);
+static void helpcasgstatus(void);
+
 // If asked to move to or from a Gscanstatus this will throw. Use the castogscanstatus
 // and casfromgscanstatus instead.
 // casgstatus will loop if the g->atomicstatus is in a Gscan status until the routine that 
 // put it in the Gscan state is finished.
+#pragma textflag NOSPLIT
 void
 runtime·casgstatus(G *gp, uint32 oldval, uint32 newval)
 {
-	if(isscanstatus(oldval) || isscanstatus(newval) || oldval == newval) {
-		runtime·printf("casgstatus: oldval=%d, newval=%d\n", oldval, newval);
-		runtime·throw("casgstatus: bad incoming values");
+	void (*fn)(void);
+
+	if((oldval&Gscan) || (newval&Gscan) || oldval == newval) {
+		g->m->scalararg[0] = oldval;
+		g->m->scalararg[1] = newval;
+		fn = badcasgstatus;
+		runtime·onM(&fn);
 	}
 
 	// loop if gp->atomicstatus is in a scan state giving
@@ -520,11 +528,37 @@ runtime·casgstatus(G *gp, uint32 oldval, uint32 newval)
 		// Help GC if needed. 
 		if(gp->preemptscan && !gp->gcworkdone && (oldval == Grunning || oldval == Gsyscall)) {
 			gp->preemptscan = false;
-			runtime·gcphasework(gp);
+			g->m->ptrarg[0] = gp;
+			fn = helpcasgstatus;
+			runtime·onM(&fn);
 		}
 	}	
 }
 
+static void
+badcasgstatus(void)
+{
+	uint32 oldval, newval;
+	
+	oldval = g->m->scalararg[0];
+	newval = g->m->scalararg[1];
+	g->m->scalararg[0] = 0;
+	g->m->scalararg[1] = 0;
+
+	runtime·printf("casgstatus: oldval=%d, newval=%d\n", oldval, newval);
+	runtime·throw("casgstatus: bad incoming values");
+}
+
+static void
+helpcasgstatus(void)
+{
+	G *gp;
+	
+	gp = g->m->ptrarg[0];
+	g->m->ptrarg[0] = 0;
+	runtime·gcphasework(gp);
+}
+
 // stopg ensures that gp is stopped at a GC safe point where its stack can be scanned
 // or in the context of a moving collector the pointers can be flipped from pointing 
 // to old object to pointing to new objects. 
@@ -1770,6 +1804,10 @@ save(void *pc, uintptr sp)
 	g->sched.g = g;
 }
 
+static void entersyscall_bad(void);
+static void entersyscall_sysmon(void);
+static void entersyscall_gcwait(void);
+
 // The goroutine g is about to enter a system call.
 // Record that it's not using the cpu anymore.
 // This is called only from the go syscall library and cgocall,
@@ -1778,13 +1816,30 @@ save(void *pc, uintptr sp)
 // Entersyscall cannot split the stack: the runtime·gosave must
 // make g->sched refer to the caller's stack segment, because
 // entersyscall is going to return immediately after.
+//
+// Nothing entersyscall calls can split the stack either.
+// We cannot safely move the stack during an active call to syscall,
+// because we do not know which of the uintptr arguments are
+// really pointers (back into the stack).
+// In practice, this means that we make the fast path run through
+// entersyscall doing no-split things, and the slow path has to use onM
+// to run bigger things on the m stack.
 #pragma textflag NOSPLIT
 void
 ·entersyscall(int32 dummy)
 {
+	void (*fn)(void);
+
 	// Disable preemption because during this function g is in Gsyscall status,
 	// but can have inconsistent g->sched, do not let GC observe it.
 	g->m->locks++;
+	
+	// Entersyscall must not call any function that might split/grow the stack.
+	// (See details in comment above.)
+	// Catch calls that might, by replacing the stack guard with something that
+	// will trip any stack check and leaving a flag to tell newstack to die.
+	g->stackguard0 = StackPreempt;
+	g->throwsplit = 1;
 
 	// Leave SP around for GC and traceback.
 	save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
@@ -1794,18 +1849,13 @@ void
 	g->syscallguard = g->stackguard;
 	runtime·casgstatus(g, Grunning, Gsyscall);
 	if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
-		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
-		//	g->syscallsp, g->syscallguard-StackGuard, g->syscallstack);
-		runtime·throw("entersyscall");
+		fn = entersyscall_bad;
+		runtime·onM(&fn);
 	}
 
 	if(runtime·atomicload(&runtime·sched.sysmonwait)) {  // TODO: fast atomic
-		runtime·lock(&runtime·sched.lock);
-		if(runtime·atomicload(&runtime·sched.sysmonwait)) {
-			runtime·atomicstore(&runtime·sched.sysmonwait, 0);
-			runtime·notewakeup(&runtime·sched.sysmonnote);
-		}
-		runtime·unlock(&runtime·sched.lock);
+		fn = entersyscall_sysmon;
+		runtime·onM(&fn);
 		save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 	}
 
@@ -1813,12 +1863,8 @@ void
 	g->m->p->m = nil;
 	runtime·atomicstore(&g->m->p->status, Psyscall);
 	if(runtime·sched.gcwaiting) {
-		runtime·lock(&runtime·sched.lock);
-		if (runtime·sched.stopwait > 0 && runtime·cas(&g->m->p->status, Psyscall, Pgcstop)) {
-			if(--runtime·sched.stopwait == 0)
-				runtime·notewakeup(&runtime·sched.stopnote);
-		}
-		runtime·unlock(&runtime·sched.lock);
+		fn = entersyscall_gcwait;
+		runtime·onM(&fn);
 		save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 	}
 
@@ -1829,14 +1875,51 @@ void
 	g->m->locks--;
 }
 
+static void
+entersyscall_bad(void)
+{
+	G *gp;
+	
+	gp = g->m->curg;
+	runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
+		gp->syscallsp, gp->syscallguard-StackGuard, gp->syscallstack);
+	runtime·throw("entersyscall");
+}
+
+static void
+entersyscall_sysmon(void)
+{
+	runtime·lock(&runtime·sched.lock);
+	if(runtime·atomicload(&runtime·sched.sysmonwait)) {
+		runtime·atomicstore(&runtime·sched.sysmonwait, 0);
+		runtime·notewakeup(&runtime·sched.sysmonnote);
+	}
+	runtime·unlock(&runtime·sched.lock);
+}
+
+static void
+entersyscall_gcwait(void)
+{
+	runtime·lock(&runtime·sched.lock);
+	if (runtime·sched.stopwait > 0 && runtime·cas(&g->m->p->status, Psyscall, Pgcstop)) {
+		if(--runtime·sched.stopwait == 0)
+			runtime·notewakeup(&runtime·sched.stopnote);
+	}
+	runtime·unlock(&runtime·sched.lock);
+}
+
+static void entersyscallblock_handoff(void);
+
 // The same as runtime·entersyscall(), but with a hint that the syscall is blocking.
 #pragma textflag NOSPLIT
 void
 ·entersyscallblock(int32 dummy)
 {
-	P *p;
+	void (*fn)(void);
 
 	g->m->locks++;  // see comment in entersyscall
+	g->throwsplit = 1;
+	g->stackguard0 = StackPreempt;  // see comment in entersyscall
 
 	// Leave SP around for GC and traceback.
 	save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
@@ -1846,43 +1929,22 @@ void
 	g->syscallguard = g->stackguard;
 	runtime·casgstatus(g, Grunning, Gsyscall);
 	if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
-		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
-		//	g->syscallsp, g->syscallguard-StackGuard, g->syscallstack);
-		runtime·throw("entersyscallblock");
+		fn = entersyscall_bad;
+		runtime·onM(&fn);
 	}
-
-	p = releasep();
-	handoffp(p);
+	
+	fn = entersyscallblock_handoff;
+	runtime·onM(&fn);
 
 	// Resave for traceback during blocked call.
 	save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 
-	g->stackguard0 = StackPreempt;  // see comment in entersyscall
 	g->m->locks--;
 }
 
-// The same as runtime·entersyscallblock(), but called on g0 stack.
-void
-runtime·entersyscallblock_m(void)
+static void
+entersyscallblock_handoff(void)
 {
-	G *gp;
-
-	gp = g->m->curg;
-	// sched.{g,pc,sp,lr} are already set by mcall.
-	gp->stackguard0 = StackPreempt;  // we are on g0, the goroutine must not touch its stack until exitsyscall
-	gp->sched.ret = 0;
-	gp->sched.ctxt = 0;
-	gp->syscallsp = gp->sched.sp;
-	gp->syscallpc = gp->sched.pc;
-	gp->syscallstack = gp->stackbase;
-	gp->syscallguard = gp->stackguard;
-	runtime·casgstatus(gp, Grunning, Gsyscall);
-	if(gp->syscallsp < gp->syscallguard-StackGuard || gp->syscallstack < gp->syscallsp) {
-		// runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
-		//	gp->syscallsp, gp->syscallguard-StackGuard, gp->syscallstack);
-		runtime·throw("entersyscall_m");
-	}
-
 	handoffp(releasep());
 }
 
@@ -1917,6 +1979,7 @@ runtime·exitsyscall(void)
 			// otherwise restore the real stackguard, we've spoiled it in entersyscall/entersyscallblock
 			g->stackguard0 = g->stackguard;
 		}
+		g->throwsplit = 0;
 		return;
 	}
 
@@ -1935,13 +1998,16 @@ runtime·exitsyscall(void)
 	g->syscallstack = (uintptr)nil;
 	g->syscallsp = (uintptr)nil;
 	g->m->p->syscalltick++;
+	g->throwsplit = 0;
 }
 
+static void exitsyscallfast_pidle(void);
+
 #pragma textflag NOSPLIT
 static bool
 exitsyscallfast(void)
 {
-	P *p;
+	void (*fn)(void);
 
 	// Freezetheworld sets stopwait but does not retake P's.
 	if(runtime·sched.stopwait) {
@@ -1959,21 +2025,35 @@ exitsyscallfast(void)
 	// Try to get any other idle P.
 	g->m->p = nil;
 	if(runtime·sched.pidle) {
-		runtime·lock(&runtime·sched.lock);
-		p = pidleget();
-		if(p && runtime·atomicload(&runtime·sched.sysmonwait)) {
-			runtime·atomicstore(&runtime·sched.sysmonwait, 0);
-			runtime·notewakeup(&runtime·sched.sysmonnote);
-		}
-		runtime·unlock(&runtime·sched.lock);
-		if(p) {
-			acquirep(p);
+		fn = exitsyscallfast_pidle;
+		runtime·onM(&fn);
+		if(g->m->scalararg[0]) {
+			g->m->scalararg[0] = 0;
 			return true;
 		}
 	}
 	return false;
 }
 
+static void
+exitsyscallfast_pidle(void)
+{
+	P *p;
+
+	runtime·lock(&runtime·sched.lock);
+	p = pidleget();
+	if(p && runtime·atomicload(&runtime·sched.sysmonwait)) {
+		runtime·atomicstore(&runtime·sched.sysmonwait, 0);
+		runtime·notewakeup(&runtime·sched.sysmonnote);
+	}
+	runtime·unlock(&runtime·sched.lock);
+	if(p) {
+		acquirep(p);
+		g->m->scalararg[0] = 1;
+	} else
+		g->m->scalararg[0] = 0;
+}
+
 // runtime·exitsyscall slow path on g0.
 // Failed to acquire P, enqueue gp as runnable.
 static void
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 84a373cd51..4cecc39a6f 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -293,6 +293,7 @@ struct	G
 	bool	paniconfault;	// panic (instead of crash) on unexpected fault address
 	bool    preemptscan;    // preempted g does scan for GC
 	bool    gcworkdone;     // debug: cleared at begining of gc work phase cycle, set by gcphasework, tested at end of cycle
+	bool	throwsplit; // must not split stack
 	int8	raceignore;	// ignore race detection events
 	M*	m;		// for debuggers, but offset not hard-coded
 	M*	lockedm;
@@ -867,7 +868,6 @@ int32	runtime·asmcgocall_errno(void (*fn)(void*), void*);
 void	runtime·entersyscall(void);
 void	runtime·entersyscallblock(void);
 void	runtime·exitsyscall(void);
-void	runtime·entersyscallblock_m(void);
 G*	runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
 bool	runtime·sigsend(int32 sig);
 intgo	runtime·callers(intgo, uintptr*, intgo);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 6a57ab08cf..8456f79369 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -876,6 +876,8 @@ runtime·newstack(void)
 			g->m->morebuf.g, g->m, g->m->curg, g->m->g0, g->m->gsignal);
 		runtime·throw("runtime: wrong goroutine in newstack");
 	}
+	if(g->throwsplit)
+		runtime·throw("runtime: stack split at bad time");
 
 	// The goroutine must be executing in order to call newstack, so the possible states are
 	// Grunning and Gsyscall (and, due to GC, also Gscanrunning and Gscansyscall).	

From 55fa7659c990701b3b7fb21e5364585793b9e452 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Wed, 3 Sep 2014 15:57:03 -0700
Subject: [PATCH 358/423] text/template: 0xef is an integer, not a
 floating-point value. The discriminator in the execution engine was stupid.
 Add a test to the parse package too. The problem wasn't there but the
 particular case ('e' in a hex integer) was not covered.

Fixes #8622.

LGTM=ruiu
R=golang-codereviews, ruiu
CC=golang-codereviews
https://golang.org/cl/133530043
---
 src/pkg/text/template/exec.go             | 6 +++++-
 src/pkg/text/template/exec_test.go        | 5 +++++
 src/pkg/text/template/parse/parse_test.go | 2 ++
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/pkg/text/template/exec.go b/src/pkg/text/template/exec.go
index 2f32312645..8e155d478e 100644
--- a/src/pkg/text/template/exec.go
+++ b/src/pkg/text/template/exec.go
@@ -393,7 +393,7 @@ func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
 	switch {
 	case constant.IsComplex:
 		return reflect.ValueOf(constant.Complex128) // incontrovertible.
-	case constant.IsFloat && strings.IndexAny(constant.Text, ".eE") >= 0:
+	case constant.IsFloat && !isHexConstant(constant.Text) && strings.IndexAny(constant.Text, ".eE") >= 0:
 		return reflect.ValueOf(constant.Float64)
 	case constant.IsInt:
 		n := int(constant.Int64)
@@ -407,6 +407,10 @@ func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
 	return zero
 }
 
+func isHexConstant(s string) bool {
+	return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')
+}
+
 func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
 	s.at(field)
 	return s.evalFieldChain(dot, dot, field, field.Ident, args, final)
diff --git a/src/pkg/text/template/exec_test.go b/src/pkg/text/template/exec_test.go
index 868f2cb94c..663aaf3af8 100644
--- a/src/pkg/text/template/exec_test.go
+++ b/src/pkg/text/template/exec_test.go
@@ -514,6 +514,11 @@ var execTests = []execTest{
 	{"bug10", "{{mapOfThree.three}}-{{(mapOfThree).three}}", "3-3", 0, true},
 	// Dereferencing nil pointer while evaluating function arguments should not panic. Issue 7333.
 	{"bug11", "{{valueString .PS}}", "", T{}, false},
+	// 0xef gave constant type float64. Issue 8622.
+	{"bug12xe", "{{printf `%T` 0xef}}", "int", T{}, true},
+	{"bug12xE", "{{printf `%T` 0xEE}}", "int", T{}, true},
+	{"bug12Xe", "{{printf `%T` 0Xef}}", "int", T{}, true},
+	{"bug12XE", "{{printf `%T` 0XEE}}", "int", T{}, true},
 }
 
 func zeroArgs() string {
diff --git a/src/pkg/text/template/parse/parse_test.go b/src/pkg/text/template/parse/parse_test.go
index fa6790bef9..4a504fa7c8 100644
--- a/src/pkg/text/template/parse/parse_test.go
+++ b/src/pkg/text/template/parse/parse_test.go
@@ -69,6 +69,8 @@ var numberTests = []numberTest{
 	{text: "1+2."},
 	{text: "'x"},
 	{text: "'xx'"},
+	// Issue 8622 - 0xe parsed as floating point. Very embarrassing.
+	{"0xef", true, true, true, false, 0xef, 0xef, 0xef, 0},
 }
 
 func TestNumberParse(t *testing.T) {

From ced0ba56289a5326332705a6617c10f3412cee0b Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Thu, 4 Sep 2014 10:00:30 +0900
Subject: [PATCH 359/423] net: fix parsing literal IP address in builtin dns
 stub resolver

This CL fixes a bug introduced by CL 128820043 which is that
builtin dns stub resolver doesn't work well with literal IPv6
address namesever entries in /etc/resolv.conf.

Also simplifies resolv.conf parser and adds more test cases.

LGTM=iant
R=golang-codereviews, bradfitz, iant
CC=golang-codereviews
https://golang.org/cl/140040043
---
 src/pkg/net/dnsclient_unix_test.go      |  4 +-
 src/pkg/net/dnsconfig_unix.go           | 35 +++-------
 src/pkg/net/dnsconfig_unix_test.go      | 91 ++++++++++++++++---------
 src/pkg/net/testdata/domain-resolv.conf |  5 ++
 src/pkg/net/testdata/empty-resolv.conf  |  1 +
 src/pkg/net/testdata/resolv.conf        |  5 +-
 src/pkg/net/testdata/search-resolv.conf |  5 ++
 7 files changed, 83 insertions(+), 63 deletions(-)
 create mode 100644 src/pkg/net/testdata/domain-resolv.conf
 create mode 100644 src/pkg/net/testdata/empty-resolv.conf
 create mode 100644 src/pkg/net/testdata/search-resolv.conf

diff --git a/src/pkg/net/dnsclient_unix_test.go b/src/pkg/net/dnsclient_unix_test.go
index bd7129bd13..1167c26b39 100644
--- a/src/pkg/net/dnsclient_unix_test.go
+++ b/src/pkg/net/dnsclient_unix_test.go
@@ -204,7 +204,7 @@ func TestReloadResolvConfChange(t *testing.T) {
 	if _, err := goLookupIP("golang.org"); err != nil {
 		t.Fatalf("goLookupIP(good) failed: %v", err)
 	}
-	r.WantServers([]string{"[8.8.8.8]"})
+	r.WantServers([]string{"8.8.8.8"})
 
 	// Using a bad resolv.conf when we had a good one
 	// before should not update the config
@@ -215,7 +215,7 @@ func TestReloadResolvConfChange(t *testing.T) {
 
 	// A new good config should get picked up
 	r.SetConf("nameserver 8.8.4.4")
-	r.WantServers([]string{"[8.8.4.4]"})
+	r.WantServers([]string{"8.8.4.4"})
 }
 
 func BenchmarkGoLookupIP(b *testing.B) {
diff --git a/src/pkg/net/dnsconfig_unix.go b/src/pkg/net/dnsconfig_unix.go
index db45716f12..d046b1107a 100644
--- a/src/pkg/net/dnsconfig_unix.go
+++ b/src/pkg/net/dnsconfig_unix.go
@@ -25,13 +25,12 @@ func dnsReadConfig(filename string) (*dnsConfig, error) {
 	if err != nil {
 		return nil, &DNSConfigError{err}
 	}
-	conf := new(dnsConfig)
-	conf.servers = make([]string, 0, 3) // small, but the standard limit
-	conf.search = make([]string, 0)
-	conf.ndots = 1
-	conf.timeout = 5
-	conf.attempts = 2
-	conf.rotate = false
+	defer file.close()
+	conf := &dnsConfig{
+		ndots:    1,
+		timeout:  5,
+		attempts: 2,
+	}
 	for line, ok := file.readLine(); ok; line, ok = file.readLine() {
 		f := getFields(line)
 		if len(f) < 1 {
@@ -39,30 +38,18 @@ func dnsReadConfig(filename string) (*dnsConfig, error) {
 		}
 		switch f[0] {
 		case "nameserver": // add one name server
-			a := conf.servers
-			n := len(a)
-			if len(f) > 1 && n < cap(a) {
+			if len(f) > 1 && len(conf.servers) < 3 { // small, but the standard limit
 				// One more check: make sure server name is
 				// just an IP address.  Otherwise we need DNS
 				// to look it up.
-				name := f[1]
-				switch len(ParseIP(name)) {
-				case 16:
-					name = "[" + name + "]"
-					fallthrough
-				case 4:
-					a = a[0 : n+1]
-					a[n] = name
-					conf.servers = a
+				if ParseIP(f[1]) != nil {
+					conf.servers = append(conf.servers, f[1])
 				}
 			}
 
 		case "domain": // set search path to just this domain
 			if len(f) > 1 {
-				conf.search = make([]string, 1)
-				conf.search[0] = f[1]
-			} else {
-				conf.search = make([]string, 0)
+				conf.search = []string{f[1]}
 			}
 
 		case "search": // set search path to given servers
@@ -99,8 +86,6 @@ func dnsReadConfig(filename string) (*dnsConfig, error) {
 			}
 		}
 	}
-	file.close()
-
 	return conf, nil
 }
 
diff --git a/src/pkg/net/dnsconfig_unix_test.go b/src/pkg/net/dnsconfig_unix_test.go
index 37ed4931db..972f8cebe5 100644
--- a/src/pkg/net/dnsconfig_unix_test.go
+++ b/src/pkg/net/dnsconfig_unix_test.go
@@ -6,41 +6,64 @@
 
 package net
 
-import "testing"
+import (
+	"reflect"
+	"testing"
+)
+
+var dnsReadConfigTests = []struct {
+	name string
+	conf dnsConfig
+}{
+	{
+		name: "testdata/resolv.conf",
+		conf: dnsConfig{
+			servers:  []string{"8.8.8.8", "2001:4860:4860::8888"},
+			search:   []string{"localdomain"},
+			ndots:    5,
+			timeout:  10,
+			attempts: 3,
+			rotate:   true,
+		},
+	},
+	{
+		name: "testdata/domain-resolv.conf",
+		conf: dnsConfig{
+			servers:  []string{"8.8.8.8"},
+			search:   []string{"localdomain"},
+			ndots:    1,
+			timeout:  5,
+			attempts: 2,
+		},
+	},
+	{
+		name: "testdata/search-resolv.conf",
+		conf: dnsConfig{
+			servers:  []string{"8.8.8.8"},
+			search:   []string{"test", "invalid"},
+			ndots:    1,
+			timeout:  5,
+			attempts: 2,
+		},
+	},
+	{
+		name: "testdata/empty-resolv.conf",
+		conf: dnsConfig{
+			ndots:    1,
+			timeout:  5,
+			attempts: 2,
+		},
+	},
+}
 
 func TestDNSReadConfig(t *testing.T) {
-	dnsConfig, err := dnsReadConfig("testdata/resolv.conf")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(dnsConfig.servers) != 1 {
-		t.Errorf("len(dnsConfig.servers) = %d; want %d", len(dnsConfig.servers), 1)
-	}
-	if dnsConfig.servers[0] != "[192.168.1.1]" {
-		t.Errorf("dnsConfig.servers[0] = %s; want %s", dnsConfig.servers[0], "[192.168.1.1]")
-	}
-
-	if len(dnsConfig.search) != 1 {
-		t.Errorf("len(dnsConfig.search) = %d; want %d", len(dnsConfig.search), 1)
-	}
-	if dnsConfig.search[0] != "Home" {
-		t.Errorf("dnsConfig.search[0] = %s; want %s", dnsConfig.search[0], "Home")
-	}
-
-	if dnsConfig.ndots != 5 {
-		t.Errorf("dnsConfig.ndots = %d; want %d", dnsConfig.ndots, 5)
-	}
-
-	if dnsConfig.timeout != 10 {
-		t.Errorf("dnsConfig.timeout = %d; want %d", dnsConfig.timeout, 10)
-	}
-
-	if dnsConfig.attempts != 3 {
-		t.Errorf("dnsConfig.attempts = %d; want %d", dnsConfig.attempts, 3)
-	}
-
-	if dnsConfig.rotate != true {
-		t.Errorf("dnsConfig.rotate = %t; want %t", dnsConfig.rotate, true)
+	for _, tt := range dnsReadConfigTests {
+		conf, err := dnsReadConfig(tt.name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(conf, &tt.conf) {
+			t.Errorf("got %v; want %v", conf, &tt.conf)
+		}
 	}
 }
diff --git a/src/pkg/net/testdata/domain-resolv.conf b/src/pkg/net/testdata/domain-resolv.conf
new file mode 100644
index 0000000000..ff269180f4
--- /dev/null
+++ b/src/pkg/net/testdata/domain-resolv.conf
@@ -0,0 +1,5 @@
+# /etc/resolv.conf
+
+search test invalid
+domain localdomain
+nameserver 8.8.8.8
diff --git a/src/pkg/net/testdata/empty-resolv.conf b/src/pkg/net/testdata/empty-resolv.conf
new file mode 100644
index 0000000000..c4b2b57654
--- /dev/null
+++ b/src/pkg/net/testdata/empty-resolv.conf
@@ -0,0 +1 @@
+# /etc/resolv.conf
diff --git a/src/pkg/net/testdata/resolv.conf b/src/pkg/net/testdata/resolv.conf
index 3841bbf904..3413bed154 100644
--- a/src/pkg/net/testdata/resolv.conf
+++ b/src/pkg/net/testdata/resolv.conf
@@ -1,6 +1,7 @@
 # /etc/resolv.conf
 
-domain Home
-nameserver 192.168.1.1
+domain localdomain
+nameserver 8.8.8.8
+nameserver 2001:4860:4860::8888
 options ndots:5 timeout:10 attempts:3 rotate
 options attempts 3
diff --git a/src/pkg/net/testdata/search-resolv.conf b/src/pkg/net/testdata/search-resolv.conf
new file mode 100644
index 0000000000..1c846bfaff
--- /dev/null
+++ b/src/pkg/net/testdata/search-resolv.conf
@@ -0,0 +1,5 @@
+# /etc/resolv.conf
+
+domain localdomain
+search test invalid
+nameserver 8.8.8.8

From 93805d711ce1d489af032c617a1ae19ef07922e4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Wed, 3 Sep 2014 23:10:15 -0400
Subject: [PATCH 360/423] runtime: give 2 words back in notetsleep_internal

I really hoped we could avoid this nonsense, but it appears not.

Should fix windows/amd64 build breakage.

TBR=iant
CC=golang-codereviews
https://golang.org/cl/137120043
---
 src/pkg/runtime/lock_sema.go | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/lock_sema.go b/src/pkg/runtime/lock_sema.go
index e0476f3291..d136b82806 100644
--- a/src/pkg/runtime/lock_sema.go
+++ b/src/pkg/runtime/lock_sema.go
@@ -173,8 +173,13 @@ func notesleep(n *note) {
 }
 
 //go:nosplit
-func notetsleep_internal(n *note, ns int64) bool {
-	gp := getg()
+func notetsleep_internal(n *note, ns int64, gp *g, deadline int64) bool {
+	// gp and deadline are logically local variables, but they are written
+	// as parameters so that the stack space they require is charged
+	// to the caller.
+	// This reduces the nosplit footprint of notetsleep_internal.
+	gp = getg()
+
 	// Register for wakeup on n->waitm.
 	if !casuintptr(&n.key, 0, uintptr(unsafe.Pointer(gp.m))) {
 		// Must be locked (got wakeup).
@@ -190,7 +195,8 @@ func notetsleep_internal(n *note, ns int64) bool {
 		gp.m.blocked = false
 		return true
 	}
-	deadline := nanotime() + ns
+
+	deadline = nanotime() + ns
 	for {
 		// Registered.  Sleep.
 		gp.m.blocked = true
@@ -244,7 +250,7 @@ func notetsleep(n *note, ns int64) bool {
 	if gp.m.waitsema == 0 {
 		gp.m.waitsema = semacreate()
 	}
-	return notetsleep_internal(n, ns)
+	return notetsleep_internal(n, ns, nil, 0)
 }
 
 // same as runtime·notetsleep, but called on user g (not g0)
@@ -258,7 +264,7 @@ func notetsleepg(n *note, ns int64) bool {
 		gp.m.waitsema = semacreate()
 	}
 	entersyscallblock()
-	ok := notetsleep_internal(n, ns)
+	ok := notetsleep_internal(n, ns, nil, 0)
 	exitsyscall()
 	return ok
 }

From f40341643cc254aa4e00baf455aa85684957cd92 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Thu, 4 Sep 2014 12:53:51 +0900
Subject: [PATCH 361/423] net: fix parsing literal IPv6 address with zone
 identifier in builtin dns stub resolver

Fixes #8619.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/132560043
---
 src/pkg/net/dnsconfig_unix.go      | 4 +++-
 src/pkg/net/dnsconfig_unix_test.go | 2 +-
 src/pkg/net/testdata/resolv.conf   | 1 +
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/pkg/net/dnsconfig_unix.go b/src/pkg/net/dnsconfig_unix.go
index d046b1107a..ebb6e673f1 100644
--- a/src/pkg/net/dnsconfig_unix.go
+++ b/src/pkg/net/dnsconfig_unix.go
@@ -42,7 +42,9 @@ func dnsReadConfig(filename string) (*dnsConfig, error) {
 				// One more check: make sure server name is
 				// just an IP address.  Otherwise we need DNS
 				// to look it up.
-				if ParseIP(f[1]) != nil {
+				if parseIPv4(f[1]) != nil {
+					conf.servers = append(conf.servers, f[1])
+				} else if ip, _ := parseIPv6(f[1], true); ip != nil {
 					conf.servers = append(conf.servers, f[1])
 				}
 			}
diff --git a/src/pkg/net/dnsconfig_unix_test.go b/src/pkg/net/dnsconfig_unix_test.go
index 972f8cebe5..94fb0c32e2 100644
--- a/src/pkg/net/dnsconfig_unix_test.go
+++ b/src/pkg/net/dnsconfig_unix_test.go
@@ -18,7 +18,7 @@ var dnsReadConfigTests = []struct {
 	{
 		name: "testdata/resolv.conf",
 		conf: dnsConfig{
-			servers:  []string{"8.8.8.8", "2001:4860:4860::8888"},
+			servers:  []string{"8.8.8.8", "2001:4860:4860::8888", "fe80::1%lo0"},
 			search:   []string{"localdomain"},
 			ndots:    5,
 			timeout:  10,
diff --git a/src/pkg/net/testdata/resolv.conf b/src/pkg/net/testdata/resolv.conf
index 3413bed154..04e87eed03 100644
--- a/src/pkg/net/testdata/resolv.conf
+++ b/src/pkg/net/testdata/resolv.conf
@@ -3,5 +3,6 @@
 domain localdomain
 nameserver 8.8.8.8
 nameserver 2001:4860:4860::8888
+nameserver fe80::1%lo0
 options ndots:5 timeout:10 attempts:3 rotate
 options attempts 3

From cb767247caeaedd0ed438adba8e27c3334be783e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 00:01:55 -0400
Subject: [PATCH 362/423] runtime: refactor/fix asmcgocall/asmcgocall_errno

Instead of making asmcgocall call asmcgocall_errno,
make both load args into registers and call a shared
assembly function.

On amd64, this costs 1 word in the asmcgocall_errno path
but saves 3 words in the asmcgocall path, and the latter
is what happens on critical nosplit paths on Windows.

On arm, this fixes build failures: asmcgocall was writing
the arguments for asmcgocall_errno into the wrong
place on the stack. Passing them in registers avoids the
decision entirely.

On 386, this isn't really needed, since the nosplit paths
have twice as many words to work with, but do it for consistency.

Update #8635
Fixes arm build (except GOARM=5).

TBR=iant
CC=golang-codereviews
https://golang.org/cl/134390043
---
 misc/cgo/test/callback.go   |  9 +++++++--
 src/pkg/runtime/asm_386.s   | 13 ++++++++-----
 src/pkg/runtime/asm_amd64.s | 13 ++++++++-----
 src/pkg/runtime/asm_arm.s   | 15 +++++++++------
 4 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/misc/cgo/test/callback.go b/misc/cgo/test/callback.go
index 67d271404a..98f653ef77 100644
--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -156,6 +156,7 @@ func testCallbackCallers(t *testing.T) {
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
 		"runtime.cgocallback_gofunc",
+		"asmcgocall",
 		"runtime.asmcgocall_errno",
 		"runtime.cgocall_errno",
 		"test._Cfunc_callback",
@@ -182,8 +183,12 @@ func testCallbackCallers(t *testing.T) {
 		if strings.HasPrefix(fname, "_") {
 			fname = path.Base(f.Name()[1:])
 		}
-		if fname != name[i] {
-			t.Errorf("expected function name %s, got %s", name[i], fname)
+		namei := ""
+		if i < len(name) {
+			namei = name[i]
+		}
+		if fname != namei {
+			t.Errorf("stk[%d] = %q, want %q", i, fname, namei)
 		}
 	}
 }
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 2477726f51..aafe960ce3 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -680,17 +680,21 @@ TEXT gosave<>(SB),NOSPLIT,$0
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT runtime·asmcgocall(SB),NOSPLIT,$12-8
+TEXT runtime·asmcgocall(SB),NOSPLIT,$0-8
 	MOVL	fn+0(FP), AX
 	MOVL	arg+4(FP), BX
-	MOVL	AX, 0(SP)
-	MOVL	BX, 4(SP)
-	CALL	runtime·asmcgocall_errno(SB)
+	CALL	asmcgocall<>(SB)
 	RET
 
 TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 	MOVL	fn+0(FP), AX
 	MOVL	arg+4(FP), BX
+	CALL	asmcgocall<>(SB)
+	MOVL	AX, ret+8(FP)
+	RET
+
+TEXT asmcgocall<>(SB),NOSPLIT,$0-12
+	// fn in AX, arg in BX
 	MOVL	SP, DX
 
 	// Figure out if we need to switch to m->g0 stack.
@@ -720,7 +724,6 @@ TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 	MOVL	8(SP), DI
 	MOVL	DI, g(CX)
 	MOVL	4(SP), SP
-	MOVL	AX, ret+8(FP)
 	RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index d7e30de7b4..5840b56c81 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -764,17 +764,21 @@ TEXT gosave<>(SB),NOSPLIT,$0
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT runtime·asmcgocall(SB),NOSPLIT,$24-16
+TEXT runtime·asmcgocall(SB),NOSPLIT,$0-16
 	MOVQ	fn+0(FP), AX
 	MOVQ	arg+8(FP), BX
-	MOVQ	AX, 0(SP)
-	MOVQ	BX, 8(SP)
-	CALL	runtime·asmcgocall_errno(SB)
+	CALL	asmcgocall<>(SB)
 	RET
 
 TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-20
 	MOVQ	fn+0(FP), AX
 	MOVQ	arg+8(FP), BX
+	CALL	asmcgocall<>(SB)
+	MOVL	AX, ret+16(FP)
+	RET
+
+// asmcgocall common code. fn in AX, arg in BX. returns errno in AX.
+TEXT asmcgocall<>(SB),NOSPLIT,$0-0
 	MOVQ	SP, DX
 
 	// Figure out if we need to switch to m->g0 stack.
@@ -813,7 +817,6 @@ nosave:
 	MOVQ	48(SP), DI
 	MOVQ	DI, g(CX)
 	MOVQ	40(SP), SP
-	MOVL	AX, ret+16(FP)
 	RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 26b58cfb17..49a863258c 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -493,17 +493,21 @@ TEXT gosave<>(SB),NOSPLIT,$0
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT	runtime·asmcgocall(SB),NOSPLIT,$12-8
+TEXT	runtime·asmcgocall(SB),NOSPLIT,$0-8
 	MOVW	fn+0(FP), R1
-	MOVW	arg+4(FP), R2
-	MOVW	R1, 0(R13)
-	MOVW	R2, 4(R13)
-	BL	runtime·asmcgocall_errno(SB)
+	MOVW	arg+4(FP), R0
+	BL	asmcgocall<>(SB)
 	RET
 
 TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 	MOVW	fn+0(FP), R1
 	MOVW	arg+4(FP), R0
+	BL	asmcgocall<>(SB)
+	MOVW	R0, ret+8(FP)
+	RET
+
+TEXT asmcgocall<>(SB),NOSPLIT,$0-0
+	// fn in R1, arg in R0.
 	MOVW	R13, R2
 	MOVW	g, R5
 
@@ -529,7 +533,6 @@ TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 	// Restore registers, g, stack pointer.
 	MOVW	20(R13), g
 	MOVW	16(R13), R13
-	MOVW	R0, ret+8(FP)
 	RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)

From 32ecf57d22cfdf3af9419db515eba85fa1d5b67d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 00:10:10 -0400
Subject: [PATCH 363/423] runtime: reject onM calls from gsignal stack

The implementation and use patterns of onM assume
that they run on either the m->curg or m->g0 stack.

Calling onM from m->gsignal has two problems:

(1) When not on g0, onM switches to g0 and then "back" to curg.
If we didn't start at curg, bad things happen.

(2) The use of scalararg/ptrarg to pass C arguments and results
assumes that there is only one onM call at a time.
If a gsignal starts running, it may have interrupted the
setup/teardown of the args for an onM on the curg or g0 stack.
Using scalararg/ptrarg itself would smash those.

We can fix (1) by remembering what g was running before the switch.

We can fix (2) by requiring that uses of onM that might happen
on a signal handling stack must save the old scalararg/ptrarg
and restore them after the call, instead of zeroing them.
The only sane way to do this is to introduce a separate
onM_signalsafe that omits the signal check, and then if you
see a call to onM_signalsafe you know the surrounding code
must preserve the old scalararg/ptrarg values.
(The implementation would be that onM_signalsafe just calls
fn if on the signal stack or else jumps to onM. It's not necessary
to have two whole copies of the function.)

(2) is not a problem if the caller and callee are both Go and
a closure is used instead of the scalararg/ptrarg slots.

For now, I think we can avoid calling onM from code executing
on gsignal stacks, so just reject it.

In the long term, (2) goes away (as do the scalararg/ptrarg slots)
once everything is in Go, and at that point fixing (1) would be
trivial and maybe worth doing just for regularity.

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/135400043
---
 src/pkg/runtime/asm_386.s      | 14 +++++++--
 src/pkg/runtime/asm_amd64.s    | 14 +++++++--
 src/pkg/runtime/asm_amd64p32.s | 14 +++++++--
 src/pkg/runtime/asm_arm.s      | 16 ++++++++---
 src/pkg/runtime/stubs.go       | 52 +++++++++++++++++++++++++++++-----
 5 files changed, 90 insertions(+), 20 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index aafe960ce3..3c46b40fee 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -205,18 +205,26 @@ TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
 	RET
 
 // func onM(fn func())
-// calls fn() on the M stack.
-// switches to the M stack if not already on it, and
-// switches back when fn() returns.
 TEXT runtime·onM(SB), NOSPLIT, $0-4
 	MOVL	fn+0(FP), DI	// DI = fn
 	get_tls(CX)
 	MOVL	g(CX), AX	// AX = g
 	MOVL	g_m(AX), BX	// BX = m
+
 	MOVL	m_g0(BX), DX	// DX = g0
 	CMPL	AX, DX
 	JEQ	onm
 
+	MOVL	m_curg(BX), BP
+	CMPL	AX, BP
+	JEQ	oncurg
+	
+	// Not g0, not curg. Must be gsignal, but that's not allowed.
+	// Hide call from linker nosplit analysis.
+	MOVL	$runtime·badonm(SB), AX
+	CALL	AX
+
+oncurg:
 	// save our state in g->sched.  Pretend to
 	// be switchtoM if the G stack is scanned.
 	MOVL	$runtime·switchtoM(SB), (g_sched+gobuf_pc)(AX)
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 5840b56c81..eb0795ec3a 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -197,18 +197,26 @@ TEXT runtime·switchtoM(SB), NOSPLIT, $0-8
 	RET
 
 // func onM(fn func())
-// calls fn() on the M stack.
-// switches to the M stack if not already on it, and
-// switches back when fn() returns.
 TEXT runtime·onM(SB), NOSPLIT, $0-8
 	MOVQ	fn+0(FP), DI	// DI = fn
 	get_tls(CX)
 	MOVQ	g(CX), AX	// AX = g
 	MOVQ	g_m(AX), BX	// BX = m
+
 	MOVQ	m_g0(BX), DX	// DX = g0
 	CMPQ	AX, DX
 	JEQ	onm
 
+	MOVQ	m_curg(BX), BP
+	CMPQ	AX, BP
+	JEQ	oncurg
+	
+	// Not g0, not curg. Must be gsignal, but that's not allowed.
+	// Hide call from linker nosplit analysis.
+	MOVQ	$runtime·badonm(SB), AX
+	CALL	AX
+
+oncurg:
 	// save our state in g->sched.  Pretend to
 	// be switchtoM if the G stack is scanned.
 	MOVQ	$runtime·switchtoM(SB), BP
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 5ff89cf068..106a722fe2 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -175,18 +175,26 @@ TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
 	RET
 
 // func onM(fn func())
-// calls fn() on the M stack.
-// switches to the M stack if not already on it, and
-// switches back when fn() returns.
 TEXT runtime·onM(SB), NOSPLIT, $0-4
 	MOVL	fn+0(FP), DI	// DI = fn
 	get_tls(CX)
 	MOVL	g(CX), AX	// AX = g
 	MOVL	g_m(AX), BX	// BX = m
+
 	MOVL	m_g0(BX), DX	// DX = g0
 	CMPL	AX, DX
 	JEQ	onm
 
+	MOVL	m_curg(BX), BP
+	CMPL	AX, BP
+	JEQ	oncurg
+	
+	// Not g0, not curg. Must be gsignal, but that's not allowed.
+	// Hide call from linker nosplit analysis.
+	MOVL	$runtime·badonm(SB), AX
+	CALL	AX
+
+oncurg:
 	// save our state in g->sched.  Pretend to
 	// be switchtoM if the G stack is scanned.
 	MOVL	$runtime·switchtoM(SB), SI
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 49a863258c..6acf3f73db 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -190,16 +190,24 @@ TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
 	RET
 
 // func onM(fn func())
-// calls fn() on the M stack.
-// switches to the M stack if not already on it, and
-// switches back when fn() returns.
 TEXT runtime·onM(SB), NOSPLIT, $0-4
 	MOVW	fn+0(FP), R0	// R0 = fn
 	MOVW	g_m(g), R1	// R1 = m
+
 	MOVW	m_g0(R1), R2	// R2 = g0
 	CMP	g, R2
 	B.EQ	onm
-	
+
+	MOVW	m_g0(R1), R3
+	CMP	g, R3
+	B.EQ	oncurg
+
+	// Not g0, not curg. Must be gsignal, but that's not allowed.
+	// Hide call from linker nosplit analysis.
+	MOVW	$runtime·badonm(SB), R0
+	BL	(R0)
+
+oncurg:
 	// save our state in g->sched.  Pretend to
 	// be switchtoM if the G stack is scanned.
 	MOVW	$runtime·switchtoM(SB), R3
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 14857908fd..287b3df05d 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -58,22 +58,60 @@ func acquirem() *m
 func releasem(mp *m)
 func gomcache() *mcache
 
-// in asm_*.s
-func mcall(func(*g))
+// mcall switches from the g to the g0 stack and invokes fn(g),
+// where g is the goroutine that made the call.
+// mcall saves g's current PC/SP in g->sched so that it can be restored later.
+// It is up to fn to arrange for that later execution, typically by recording
+// g in a data structure, causing something to call ready(g) later.
+// mcall returns to the original goroutine g later, when g has been rescheduled.
+// fn must not return at all; typically it ends by calling schedule, to let the m
+// run other goroutines.
+//
+// mcall can only be called from g stacks (not g0, not gsignal).
+//go:noescape
+func mcall(fn func(*g))
+
+// onM switches from the g to the g0 stack and invokes fn().
+// When fn returns, onM switches back to the g and returns,
+// continuing execution on the g stack.
+// If arguments must be passed to fn, they can be written to
+// g->m->ptrarg (pointers) and g->m->scalararg (non-pointers)
+// before the call and then consulted during fn.
+// Similarly, fn can pass return values back in those locations.
+// If fn is written in Go, it can be a closure, which avoids the need for
+// ptrarg and scalararg entirely.
+// After reading values out of ptrarg and scalararg it is conventional
+// to zero them to avoid (memory or information) leaks.
+//
+// If onM is called from a g0 stack, it invokes fn and returns,
+// without any stack switches.
+//
+// If onM is called from a gsignal stack, it crashes the program.
+// The implication is that functions used in signal handlers must
+// not use onM.
+//
+// NOTE(rsc): We could introduce a separate onMsignal that is
+// like onM but if called from a gsignal stack would just run fn on
+// that stack. The caller of onMsignal would be required to save the
+// old values of ptrarg/scalararg and restore them when the call
+// was finished, in case the signal interrupted an onM sequence
+// in progress on the g or g0 stacks. Until there is a clear need for this,
+// we just reject onM in signal handling contexts entirely.
+//
+//go:noescape
 func onM(fn func())
 
+func badonm() {
+	gothrow("onM called from signal goroutine")
+}
+
 // C functions that run on the M stack.
 // Call using mcall.
-// These functions need to be written to arrange explicitly
-// for the goroutine to continue execution.
 func gosched_m(*g)
 func park_m(*g)
 
 // More C functions that run on the M stack.
 // Call using onM.
-// Arguments should be passed in m->scalararg[x] and m->ptrarg[x].
-// Return values can be passed in those same slots.
-// These functions return to the goroutine when they return.
 func mcacheRefill_m()
 func largeAlloc_m()
 func gc_m()

From e3edfea07f905916cee66121576b029cd6a11444 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 00:54:06 -0400
Subject: [PATCH 364/423] runtime: correct various Go -> C function calls

Some things get converted.
Other things (too complex or too many C deps) get onM calls.
Other things (too simple) get #pragma textflag NOSPLIT.

After this CL, the offending function list is basically:
        - panic.c
        - netpoll.goc
        - mem*.c
        - race stuff
        - readgstatus
        - entersyscall/exitsyscall

LGTM=r, iant
R=golang-codereviews, r, iant
CC=dvyukov, golang-codereviews, khr
https://golang.org/cl/140930043
---
 src/pkg/runtime/cpuprof.go     |  8 ++-
 src/pkg/runtime/debug.go       |  9 +++-
 src/pkg/runtime/malloc.c       | 52 -------------------
 src/pkg/runtime/malloc.go      | 56 ++++++++++++++++++++-
 src/pkg/runtime/malloc.h       |  2 +-
 src/pkg/runtime/mcache.c       |  7 ++-
 src/pkg/runtime/mheap.c        | 11 +++-
 src/pkg/runtime/mprof.go       | 20 +++++---
 src/pkg/runtime/os_darwin.c    | 84 +++++++++++++++++++++++++++----
 src/pkg/runtime/os_nacl.c      |  6 ---
 src/pkg/runtime/os_nacl.go     |  4 ++
 src/pkg/runtime/os_windows.c   |  6 ---
 src/pkg/runtime/os_windows.go  |  4 ++
 src/pkg/runtime/proc.c         | 91 +++++++++++++++++++++++-----------
 src/pkg/runtime/runtime.c      | 32 +-----------
 src/pkg/runtime/runtime.go     | 37 ++++++++++++++
 src/pkg/runtime/signal_unix.c  |  2 +-
 src/pkg/runtime/signal_unix.go | 13 +++++
 src/pkg/runtime/stack_test.go  |  9 ++++
 src/pkg/runtime/stubs.go       |  1 -
 src/pkg/runtime/thunk.s        |  3 ++
 21 files changed, 301 insertions(+), 156 deletions(-)
 create mode 100644 src/pkg/runtime/runtime.go
 create mode 100644 src/pkg/runtime/signal_unix.go

diff --git a/src/pkg/runtime/cpuprof.go b/src/pkg/runtime/cpuprof.go
index 4325d7e1c3..8b1c1c6327 100644
--- a/src/pkg/runtime/cpuprof.go
+++ b/src/pkg/runtime/cpuprof.go
@@ -101,7 +101,13 @@ var (
 	eod = [3]uintptr{0, 1, 0}
 )
 
-func setcpuprofilerate(int32) // proc.c
+func setcpuprofilerate_m() // proc.c
+
+func setcpuprofilerate(hz int32) {
+	g := getg()
+	g.m.scalararg[0] = uintptr(hz)
+	onM(setcpuprofilerate_m)
+}
 
 // lostProfileData is a no-op function used in profiles
 // to mark the number of profiling stack traces that were
diff --git a/src/pkg/runtime/debug.go b/src/pkg/runtime/debug.go
index ed11fb1b1a..bb4bd60ed4 100644
--- a/src/pkg/runtime/debug.go
+++ b/src/pkg/runtime/debug.go
@@ -24,10 +24,15 @@ func UnlockOSThread()
 // The number of logical CPUs on the local machine can be queried with NumCPU.
 // This call will go away when the scheduler improves.
 func GOMAXPROCS(n int) int {
-	return int(gomaxprocsfunc(int32(n)))
+	g := getg()
+	g.m.scalararg[0] = uintptr(n)
+	onM(gomaxprocs_m)
+	n = int(g.m.scalararg[0])
+	g.m.scalararg[0] = 0
+	return n
 }
 
-func gomaxprocsfunc(int32) int32 // proc.c
+func gomaxprocs_m() // proc.c
 
 // NumCPU returns the number of logical CPUs on the local machine.
 func NumCPU() int {
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 311cc442c2..c864bc93c0 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -348,58 +348,6 @@ runtime·MHeap_SysAlloc(MHeap *h, uintptr n)
 	return p;
 }
 
-static struct
-{
-	Mutex	lock;
-	byte*	pos;
-	byte*	end;
-} persistent;
-
-enum
-{
-	PersistentAllocChunk	= 256<<10,
-	PersistentAllocMaxBlock	= 64<<10,  // VM reservation granularity is 64K on windows
-};
-
-// Wrapper around sysAlloc that can allocate small chunks.
-// There is no associated free operation.
-// Intended for things like function/type/debug-related persistent data.
-// If align is 0, uses default align (currently 8).
-void*
-runtime·persistentalloc(uintptr size, uintptr align, uint64 *stat)
-{
-	byte *p;
-
-	if(align != 0) {
-		if(align&(align-1))
-			runtime·throw("persistentalloc: align is not a power of 2");
-		if(align > PageSize)
-			runtime·throw("persistentalloc: align is too large");
-	} else
-		align = 8;
-	if(size >= PersistentAllocMaxBlock)
-		return runtime·sysAlloc(size, stat);
-	runtime·lock(&persistent.lock);
-	persistent.pos = (byte*)ROUND((uintptr)persistent.pos, align);
-	if(persistent.pos + size > persistent.end) {
-		persistent.pos = runtime·sysAlloc(PersistentAllocChunk, &mstats.other_sys);
-		if(persistent.pos == nil) {
-			runtime·unlock(&persistent.lock);
-			runtime·throw("runtime: cannot allocate memory");
-		}
-		persistent.end = persistent.pos + PersistentAllocChunk;
-	}
-	p = persistent.pos;
-	persistent.pos += size;
-	runtime·unlock(&persistent.lock);
-	if(stat != &mstats.other_sys) {
-		// reaccount the allocation against provided stat
-		runtime·xadd64(stat, size);
-		runtime·xadd64(&mstats.other_sys, -(uint64)size);
-	}
-	return p;
-}
-
 // Runtime stubs.
 
 static void*
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index dbe37c8108..883ca0cef7 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -431,7 +431,7 @@ func gogc(force int32) {
 	mp = acquirem()
 	mp.gcing = 1
 	releasem(mp)
-	stoptheworld()
+	onM(stoptheworld)
 	if mp != acquirem() {
 		gothrow("gogc: rescheduled")
 	}
@@ -465,7 +465,7 @@ func gogc(force int32) {
 	// all done
 	mp.gcing = 0
 	semrelease(&worldsema)
-	starttheworld()
+	onM(starttheworld)
 	releasem(mp)
 	mp = nil
 
@@ -760,3 +760,55 @@ func runfinq() {
 		}
 	}
 }
+
+var persistent struct {
+	lock mutex
+	pos  unsafe.Pointer
+	end  unsafe.Pointer
+}
+
+// Wrapper around sysAlloc that can allocate small chunks.
+// There is no associated free operation.
+// Intended for things like function/type/debug-related persistent data.
+// If align is 0, uses default align (currently 8).
+func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer {
+	const (
+		chunk    = 256 << 10
+		maxBlock = 64 << 10 // VM reservation granularity is 64K on windows
+	)
+
+	if align != 0 {
+		if align&(align-1) != 0 {
+			gothrow("persistentalloc: align is not a power of 2")
+		}
+		if align > _PageSize {
+			gothrow("persistentalloc: align is too large")
+		}
+	} else {
+		align = 8
+	}
+
+	if size >= maxBlock {
+		return sysAlloc(size, stat)
+	}
+
+	lock(&persistent.lock)
+	persistent.pos = roundup(persistent.pos, align)
+	if uintptr(persistent.pos)+size > uintptr(persistent.end) {
+		persistent.pos = sysAlloc(chunk, &memstats.other_sys)
+		if persistent.pos == nil {
+			unlock(&persistent.lock)
+			gothrow("runtime: cannot allocate memory")
+		}
+		persistent.end = add(persistent.pos, chunk)
+	}
+	p := persistent.pos
+	persistent.pos = add(persistent.pos, size)
+	unlock(&persistent.lock)
+
+	if stat != &memstats.other_sys {
+		xadd64(stat, int64(size))
+		xadd64(&memstats.other_sys, -int64(size))
+	}
+	return p
+}
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index d9a2bf84ba..5441691940 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -578,7 +578,7 @@ extern bool	runtime·fingwake;
 extern FinBlock	*runtime·finq;		// list of finalizers that are to be executed
 extern FinBlock	*runtime·finc;		// cache of free blocks
 
-void	runtime·setprofilebucket(void *p, Bucket *b);
+void	runtime·setprofilebucket_m(void);
 
 bool	runtime·addfinalizer(void*, FuncVal *fn, uintptr, Type*, PtrType*);
 void	runtime·removefinalizer(void*);
diff --git a/src/pkg/runtime/mcache.c b/src/pkg/runtime/mcache.c
index 8e98890e8e..bb1fc54032 100644
--- a/src/pkg/runtime/mcache.c
+++ b/src/pkg/runtime/mcache.c
@@ -52,24 +52,23 @@ freemcache(MCache *c)
 }
 
 static void
-freemcache_m(G *gp)
+freemcache_m(void)
 {
 	MCache *c;
 
 	c = g->m->ptrarg[0];
 	g->m->ptrarg[0] = nil;
 	freemcache(c);
-	runtime·gogo(&gp->sched);
 }
 
 void
 runtime·freemcache(MCache *c)
 {
-	void (*fn)(G*);
+	void (*fn)(void);
 
 	g->m->ptrarg[0] = c;
 	fn = freemcache_m;
-	runtime·mcall(&fn);
+	runtime·onM(&fn);
 }
 
 // Gets a span that has a free object in it and assigns it
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 0050e96556..902a5c71a2 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -834,9 +834,16 @@ runtime·removefinalizer(void *p)
 
 // Set the heap profile bucket associated with addr to b.
 void
-runtime·setprofilebucket(void *p, Bucket *b)
-{
+runtime·setprofilebucket_m(void)
+{	
+	void *p;
+	Bucket *b;
 	SpecialProfile *s;
+	
+	p = g->m->ptrarg[0];
+	b = g->m->ptrarg[1];
+	g->m->ptrarg[0] = nil;
+	g->m->ptrarg[1] = nil;
 
 	runtime·lock(&runtime·mheap.speciallock);
 	s = runtime·FixAlloc_Alloc(&runtime·mheap.specialprofilealloc);
diff --git a/src/pkg/runtime/mprof.go b/src/pkg/runtime/mprof.go
index b421c4f98f..7177c84592 100644
--- a/src/pkg/runtime/mprof.go
+++ b/src/pkg/runtime/mprof.go
@@ -249,7 +249,14 @@ func mProf_Malloc(p unsafe.Pointer, size uintptr) {
 	setprofilebucket(p, b)
 }
 
-func setprofilebucket(p unsafe.Pointer, b *bucket) // mheap.c
+func setprofilebucket_m() // mheap.c
+
+func setprofilebucket(p unsafe.Pointer, b *bucket) {
+	g := getg()
+	g.m.ptrarg[0] = p
+	g.m.ptrarg[1] = unsafe.Pointer(b)
+	onM(setprofilebucket_m)
+}
 
 // Called when freeing a profiled block.
 func mProf_Free(b *bucket, size uintptr, freed bool) {
@@ -288,8 +295,7 @@ func SetBlockProfileRate(rate int) {
 	atomicstore64(&blockprofilerate, uint64(r))
 }
 
-func tickspersecond() int64 // runtime.c
-func fastrand1() uint32     // runtime.c
+func fastrand1() uint32     // assembly
 func readgstatus(*g) uint32 // proc.c
 
 func blockevent(cycles int64, skip int) {
@@ -531,7 +537,7 @@ func GoroutineProfile(p []StackRecord) (n int, ok bool) {
 		gp := getg()
 		semacquire(&worldsema, false)
 		gp.m.gcing = 1
-		stoptheworld()
+		onM(stoptheworld)
 
 		n = NumGoroutine()
 		if n <= len(p) {
@@ -550,7 +556,7 @@ func GoroutineProfile(p []StackRecord) (n int, ok bool) {
 
 		gp.m.gcing = 0
 		semrelease(&worldsema)
-		starttheworld()
+		onM(starttheworld)
 	}
 
 	return n, ok
@@ -576,7 +582,7 @@ func Stack(buf []byte, all bool) int {
 		semacquire(&worldsema, false)
 		mp.gcing = 1
 		releasem(mp)
-		stoptheworld()
+		onM(stoptheworld)
 		if mp != acquirem() {
 			gothrow("Stack: rescheduled")
 		}
@@ -597,7 +603,7 @@ func Stack(buf []byte, all bool) int {
 	if all {
 		mp.gcing = 0
 		semrelease(&worldsema)
-		starttheworld()
+		onM(starttheworld)
 	}
 	releasem(mp)
 	return n
diff --git a/src/pkg/runtime/os_darwin.c b/src/pkg/runtime/os_darwin.c
index bf13cdbafe..19181d60df 100644
--- a/src/pkg/runtime/os_darwin.c
+++ b/src/pkg/runtime/os_darwin.c
@@ -22,16 +22,31 @@ unimplemented(int8 *name)
 	*(int32*)1231 = 1231;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·semawakeup(M *mp)
 {
 	runtime·mach_semrelease(mp->waitsema);
 }
 
+static void
+semacreate(void)
+{
+	g->m->scalararg[0] = runtime·mach_semcreate();
+}
+
+#pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
-	return runtime·mach_semcreate();
+	uintptr x;
+	void (*fn)(void);
+	
+	fn = semacreate;
+	runtime·onM(&fn);
+	x = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	return x;
 }
 
 // BSD interface for threading.
@@ -143,7 +158,6 @@ runtime·unminit(void)
 // Mach IPC, to get at semaphores
 // Definitions are in /usr/include/mach on a Mac.
 
-#pragma textflag NOSPLIT
 static void
 macherror(int32 r, int8 *fn)
 {
@@ -398,38 +412,88 @@ int32 runtime·mach_semaphore_timedwait(uint32 sema, uint32 sec, uint32 nsec);
 int32 runtime·mach_semaphore_signal(uint32 sema);
 int32 runtime·mach_semaphore_signal_all(uint32 sema);
 
-#pragma textflag NOSPLIT
-int32
-runtime·semasleep(int64 ns)
+static void
+semasleep(void)
 {
 	int32 r, secs, nsecs;
+	int64 ns;
+	
+	ns = g->m->scalararg[0] | g->m->scalararg[1]<<32;
+	g->m->scalararg[0] = 0;
+	g->m->scalararg[1] = 0;
 
 	if(ns >= 0) {
 		secs = runtime·timediv(ns, 1000000000, &nsecs);
 		r = runtime·mach_semaphore_timedwait(g->m->waitsema, secs, nsecs);
-		if(r == KERN_ABORTED || r == KERN_OPERATION_TIMED_OUT)
-			return -1;
+		if(r == KERN_ABORTED || r == KERN_OPERATION_TIMED_OUT) {
+			g->m->scalararg[0] = -1;
+			return;
+		}
 		if(r != 0)
 			macherror(r, "semaphore_wait");
-		return 0;
+		g->m->scalararg[0] = 0;
+		return;
 	}
 	while((r = runtime·mach_semaphore_wait(g->m->waitsema)) != 0) {
 		if(r == KERN_ABORTED)	// interrupted
 			continue;
 		macherror(r, "semaphore_wait");
 	}
-	return 0;
+	g->m->scalararg[0] = 0;
+	return;
 }
 
+#pragma textflag NOSPLIT
+int32
+runtime·semasleep(int64 ns)
+{
+	int32 r;
+	void (*fn)(void);
+
+	g->m->scalararg[0] = (uint32)ns;
+	g->m->scalararg[1] = (uint32)(ns>>32);
+	fn = semasleep;
+	runtime·onM(&fn);
+	r = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	return r;
+}
+
+static int32 mach_semrelease_errno;
+
+static void
+mach_semrelease_fail(void)
+{
+	macherror(mach_semrelease_errno, "semaphore_signal");
+}
+
+#pragma textflag NOSPLIT
 void
 runtime·mach_semrelease(uint32 sem)
 {
 	int32 r;
+	void (*fn)(void);
 
 	while((r = runtime·mach_semaphore_signal(sem)) != 0) {
 		if(r == KERN_ABORTED)	// interrupted
 			continue;
-		macherror(r, "semaphore_signal");
+		
+		// mach_semrelease must be completely nosplit,
+		// because it is called from Go code.
+		// If we're going to die, start that process on the m stack
+		// to avoid a Go stack split.
+		// Only do that if we're actually running on the g stack.
+		// We might be on the gsignal stack, and if so, onM will abort.
+		// We use the global variable instead of scalararg because
+		// we might be on the gsignal stack, having interrupted a
+		// normal call to onM. It doesn't quite matter, since the
+		// program is about to die, but better to be clean.
+		mach_semrelease_errno = r;
+		fn = mach_semrelease_fail;
+		if(g == g->m->curg)
+			runtime·onM(&fn);
+		else
+			fn();
 	}
 }
 
diff --git a/src/pkg/runtime/os_nacl.c b/src/pkg/runtime/os_nacl.c
index b3e0fc6636..f859dd0d35 100644
--- a/src/pkg/runtime/os_nacl.c
+++ b/src/pkg/runtime/os_nacl.c
@@ -196,12 +196,6 @@ runtime·semawakeup(M *mp)
 	runtime·nacl_mutex_unlock(mp->waitsemalock);
 }
 
-void
-os·sigpipe(void)
-{
-	runtime·throw("too many writes on closed pipe");
-}
-
 uintptr
 runtime·memlimit(void)
 {
diff --git a/src/pkg/runtime/os_nacl.go b/src/pkg/runtime/os_nacl.go
index 2ab51b8b1d..12a15aea0d 100644
--- a/src/pkg/runtime/os_nacl.go
+++ b/src/pkg/runtime/os_nacl.go
@@ -24,3 +24,7 @@ func nacl_thread_create(fn, stk, tls, xx unsafe.Pointer) int32
 func nacl_nanosleep(ts, extra unsafe.Pointer) int32
 
 const stackSystem = 0
+
+func os_sigpipe() {
+	gothrow("too many writes on closed pipe")
+}
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 172fd92285..0e53d8a31c 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -588,12 +588,6 @@ runtime·resetcpuprofiler(int32 hz)
 	runtime·atomicstore((uint32*)&g->m->profilehz, hz);
 }
 
-void
-os·sigpipe(void)
-{
-	runtime·throw("too many writes on closed pipe");
-}
-
 uintptr
 runtime·memlimit(void)
 {
diff --git a/src/pkg/runtime/os_windows.go b/src/pkg/runtime/os_windows.go
index 57bd431f78..15957b3290 100644
--- a/src/pkg/runtime/os_windows.go
+++ b/src/pkg/runtime/os_windows.go
@@ -23,3 +23,7 @@ func setlasterror(err uint32)
 func usleep1(usec uint32)
 
 const stackSystem = 512 * ptrSize
+
+func os_sigpipe() {
+	gothrow("too many writes on closed pipe")
+}
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index dfbc6142d6..3e7b07c2c5 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -761,10 +761,7 @@ runtime·stoptheworld(void)
 	// that is blocked trying to acquire the lock.
 	if(g->m->locks > 0)
 		runtime·throw("stoptheworld: holding locks");
-	// There is no evidence that stoptheworld on g0 does not work,
-	// we just don't do it today.
-	if(g == g->m->g0)
-		runtime·throw("stoptheworld: on g0");
+
 	runtime·lock(&runtime·sched.lock);
 	runtime·sched.stopwait = runtime·gomaxprocs;
 	runtime·atomicstore((uint32*)&runtime·sched.gcwaiting, 1);
@@ -2085,24 +2082,54 @@ exitsyscall0(G *gp)
 	schedule();  // Never returns.
 }
 
-// Called from syscall package before fork.
-#pragma textflag NOSPLIT
-void
-syscall·runtime_BeforeFork(void)
+static void
+beforefork(void)
 {
+	G *gp;
+	
+	gp = g->m->curg;
 	// Fork can hang if preempted with signals frequently enough (see issue 5517).
 	// Ensure that we stay on the same M where we disable profiling.
-	g->m->locks++;
-	if(g->m->profilehz != 0)
+	gp->m->locks++;
+	if(gp->m->profilehz != 0)
 		runtime·resetcpuprofiler(0);
 
 	// This function is called before fork in syscall package.
 	// Code between fork and exec must not allocate memory nor even try to grow stack.
 	// Here we spoil g->stackguard to reliably detect any attempts to grow stack.
 	// runtime_AfterFork will undo this in parent process, but not in child.
-	g->m->forkstackguard = g->stackguard;
-	g->stackguard0 = StackPreempt-1;
-	g->stackguard = StackPreempt-1;
+	gp->m->forkstackguard = gp->stackguard;
+	gp->stackguard0 = StackPreempt-1;
+	gp->stackguard = StackPreempt-1;
+}
+
+// Called from syscall package before fork.
+#pragma textflag NOSPLIT
+void
+syscall·runtime_BeforeFork(void)
+{
+	void (*fn)(void);
+	
+	fn = beforefork;
+	runtime·onM(&fn);
+}
+
+static void
+afterfork(void)
+{
+	int32 hz;
+	G *gp;
+	
+	gp = g->m->curg;
+	// See the comment in runtime_BeforeFork.
+	gp->stackguard0 = gp->m->forkstackguard;
+	gp->stackguard = gp->m->forkstackguard;
+	gp->m->forkstackguard = 0;
+
+	hz = runtime·sched.profilehz;
+	if(hz != 0)
+		runtime·resetcpuprofiler(hz);
+	gp->m->locks--;
 }
 
 // Called from syscall package after fork in parent.
@@ -2110,17 +2137,10 @@ syscall·runtime_BeforeFork(void)
 void
 syscall·runtime_AfterFork(void)
 {
-	int32 hz;
-
-	// See the comment in runtime_BeforeFork.
-	g->stackguard0 = g->m->forkstackguard;
-	g->stackguard = g->m->forkstackguard;
-	g->m->forkstackguard = 0;
-
-	hz = runtime·sched.profilehz;
-	if(hz != 0)
-		runtime·resetcpuprofiler(hz);
-	g->m->locks--;
+	void (*fn)(void);
+	
+	fn = afterfork;
+	runtime·onM(&fn);
 }
 
 // Hook used by runtime·malg to call runtime·stackalloc on the
@@ -2453,10 +2473,13 @@ runtime·Breakpoint(void)
 
 // Implementation of runtime.GOMAXPROCS.
 // delete when scheduler is even stronger
-int32
-runtime·gomaxprocsfunc(int32 n)
+void
+runtime·gomaxprocs_m(void)
 {
-	int32 ret;
+	int32 n, ret;
+	
+	n = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
 
 	if(n > MaxGomaxprocs)
 		n = MaxGomaxprocs;
@@ -2464,7 +2487,8 @@ runtime·gomaxprocsfunc(int32 n)
 	ret = runtime·gomaxprocs;
 	if(n <= 0 || n == ret) {
 		runtime·unlock(&runtime·sched.lock);
-		return ret;
+		g->m->scalararg[0] = ret;
+		return;
 	}
 	runtime·unlock(&runtime·sched.lock);
 
@@ -2476,7 +2500,8 @@ runtime·gomaxprocsfunc(int32 n)
 	runtime·semrelease(&runtime·worldsema);
 	runtime·starttheworld();
 
-	return ret;
+	g->m->scalararg[0] = ret;
+	return;
 }
 
 // lockOSThread is called by runtime.LockOSThread and runtime.lockOSThread below
@@ -2540,6 +2565,7 @@ runtime·lockedOSThread(void)
 	return g->lockedm != nil && g->m->lockedg != nil;
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·gcount(void)
 {
@@ -2737,8 +2763,13 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 
 // Arrange to call fn with a traceback hz times a second.
 void
-runtime·setcpuprofilerate(int32 hz)
+runtime·setcpuprofilerate_m(void)
 {
+	int32 hz;
+	
+	hz = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+
 	// Force sane arguments.
 	if(hz < 0)
 		hz = 0;
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index b0adfb601b..751181274a 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -20,6 +20,7 @@ static uint32 traceback_cache = 2<<1;
 //	GOTRACEBACK=1   default behavior - show tracebacks but exclude runtime frames
 //	GOTRACEBACK=2   show tracebacks including runtime frames
 //	GOTRACEBACK=crash   show tracebacks including runtime frames, then crash (core dump etc)
+#pragma textflag NOSPLIT
 int32
 runtime·gotraceback(bool *crash)
 {
@@ -266,37 +267,6 @@ runtime·check(void)
 		runtime·throw("FixedStack is not power-of-2");
 }
 
-static Mutex ticksLock;
-static int64 ticks;
-
-// Note: Called by runtime/pprof in addition to runtime code.
-int64
-runtime·tickspersecond(void)
-{
-	int64 res, t0, t1, c0, c1;
-
-	res = (int64)runtime·atomicload64((uint64*)&ticks);
-	if(res != 0)
-		return ticks;
-	runtime·lock(&ticksLock);
-	res = ticks;
-	if(res == 0) {
-		t0 = runtime·nanotime();
-		c0 = runtime·cputicks();
-		runtime·usleep(100*1000);
-		t1 = runtime·nanotime();
-		c1 = runtime·cputicks();
-		if(t1 == t0)
-			t1++;
-		res = (c1-c0)*1000*1000*1000/(t1-t0);
-		if(res == 0)
-			res++;
-		runtime·atomicstore64((uint64*)&ticks, res);
-	}
-	runtime·unlock(&ticksLock);
-	return res;
-}
-
 #pragma dataflag NOPTR
 DebugVars	runtime·debug;
 
diff --git a/src/pkg/runtime/runtime.go b/src/pkg/runtime/runtime.go
new file mode 100644
index 0000000000..d5b31559a2
--- /dev/null
+++ b/src/pkg/runtime/runtime.go
@@ -0,0 +1,37 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+var ticks struct {
+	lock mutex
+	val  uint64
+}
+
+// Note: Called by runtime/pprof in addition to runtime code.
+func tickspersecond() int64 {
+	r := int64(atomicload64(&ticks.val))
+	if r != 0 {
+		return r
+	}
+	lock(&ticks.lock)
+	r = int64(ticks.val)
+	if r == 0 {
+		t0 := nanotime()
+		c0 := cputicks()
+		usleep(100 * 1000)
+		t1 := nanotime()
+		c1 := cputicks()
+		if t1 == t0 {
+			t1++
+		}
+		r = (c1 - c0) * 1000 * 1000 * 1000 / (t1 - t0)
+		if r == 0 {
+			r++
+		}
+		atomicstore64(&ticks.val, uint64(r))
+	}
+	unlock(&ticks.lock)
+	return r
+}
diff --git a/src/pkg/runtime/signal_unix.c b/src/pkg/runtime/signal_unix.c
index 4d582d3f8c..0e33ece494 100644
--- a/src/pkg/runtime/signal_unix.c
+++ b/src/pkg/runtime/signal_unix.c
@@ -93,7 +93,7 @@ runtime·resetcpuprofiler(int32 hz)
 }
 
 void
-os·sigpipe(void)
+runtime·sigpipe(void)
 {
 	runtime·setsig(SIGPIPE, SIG_DFL, false);
 	runtime·raise(SIGPIPE);
diff --git a/src/pkg/runtime/signal_unix.go b/src/pkg/runtime/signal_unix.go
new file mode 100644
index 0000000000..ba77b6e7be
--- /dev/null
+++ b/src/pkg/runtime/signal_unix.go
@@ -0,0 +1,13 @@
+// Copyright 2012 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+
+package runtime
+
+func sigpipe()
+
+func os_sigpipe() {
+	onM(sigpipe)
+}
diff --git a/src/pkg/runtime/stack_test.go b/src/pkg/runtime/stack_test.go
index b3dcbd12a0..a822d73db4 100644
--- a/src/pkg/runtime/stack_test.go
+++ b/src/pkg/runtime/stack_test.go
@@ -341,3 +341,12 @@ func TestStackOutput(t *testing.T) {
 		t.Errorf("Stack output should begin with \"goroutine \"")
 	}
 }
+
+func TestStackAllOutput(t *testing.T) {
+	b := make([]byte, 1024)
+	stk := string(b[:Stack(b, true)])
+	if !strings.HasPrefix(stk, "goroutine ") {
+		t.Errorf("Stack (len %d):\n%s", len(stk), stk)
+		t.Errorf("Stack output should begin with \"goroutine \"")
+	}
+}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 287b3df05d..3719c7501c 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -202,7 +202,6 @@ func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
 func procyield(cycles uint32)
 func osyield()
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
-func persistentalloc(size, align uintptr, stat *uint64) unsafe.Pointer
 func readgogc() int32
 func purgecachedstats(c *mcache)
 func gostringnocopy(b *byte) string
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 048b7a7236..0b5963e70a 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -118,3 +118,6 @@ TEXT reflect·makechan(SB),NOSPLIT,$0-0
 
 TEXT reflect·rselect(SB), NOSPLIT, $0-0
 	JMP	runtime·reflect_rselect(SB)
+
+TEXT os·sigpipe(SB), NOSPLIT, $0-0
+	JMP	runtime·os_sigpipe(SB)

From 996835887cd8472eadef961120de043a74724fa5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 00:54:37 -0400
Subject: [PATCH 365/423] runtime: fix sigtrampPC on Windows

The arm5 build breakage at CL 139110043 was caused by
calling funcPC on a lessstack defined as a struct{}.
That symbol ended up with a non-4-aligned address,
which caused the memory fault that broke the builders.
The definition of lessstack was fixed in CL 140880043.

Tracking that down suggested that it would be worth
looking for the same bug elsewhere in the directory.
This is the only one I found.

LGTM=bradfitz
R=golang-codereviews, dave, bradfitz
CC=dvyukov, golang-codereviews, iant, khr, r
https://golang.org/cl/134410043
---
 src/pkg/runtime/traceback_windows.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/traceback_windows.go b/src/pkg/runtime/traceback_windows.go
index 892bed04ca..89dc1336e3 100644
--- a/src/pkg/runtime/traceback_windows.go
+++ b/src/pkg/runtime/traceback_windows.go
@@ -10,7 +10,7 @@ import "unsafe"
 // The traceback needs to recognize it on link register architectures.
 var sigtrampPC uintptr
 
-var sigtramp struct{} // assembly function
+func sigtramp()
 
 func init() {
 	sigtrampPC = funcPC(sigtramp)

From a915cb47eef8acc8998414cd5f88c13614821e92 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 01:05:32 -0400
Subject: [PATCH 366/423] runtime: fix onM test for curg on arm

TBR=iant
CC=golang-codereviews
https://golang.org/cl/137130043
---
 src/pkg/runtime/asm_arm.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 6acf3f73db..3f3b9b7bee 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -198,7 +198,7 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 	CMP	g, R2
 	B.EQ	onm
 
-	MOVW	m_g0(R1), R3
+	MOVW	m_curg(R1), R3
 	CMP	g, R3
 	B.EQ	oncurg
 

From b143feb1431b58c02be6edca6bc5f6067b22a14d Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 01:38:49 -0400
Subject: [PATCH 367/423] runtime: fix int64 reconstruction in semasleep

I had this right in one of my clients, but apparently not the one I submitted from.

Fixes 386 builds.

TBR=dfc
CC=golang-codereviews
https://golang.org/cl/138000045
---
 src/pkg/runtime/os_darwin.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/os_darwin.c b/src/pkg/runtime/os_darwin.c
index 19181d60df..d3890eee52 100644
--- a/src/pkg/runtime/os_darwin.c
+++ b/src/pkg/runtime/os_darwin.c
@@ -418,7 +418,7 @@ semasleep(void)
 	int32 r, secs, nsecs;
 	int64 ns;
 	
-	ns = g->m->scalararg[0] | g->m->scalararg[1]<<32;
+	ns = (int64)(uint32)g->m->scalararg[0] | (int64)(uint32)g->m->scalararg[1]<<32;
 	g->m->scalararg[0] = 0;
 	g->m->scalararg[1] = 0;
 

From dae803863978513a159b36822054126f042ff412 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 01:58:31 -0400
Subject: [PATCH 368/423] runtime: fix nacl/amd64p32 build

BP is not a legal register on nacl.

TBR=iant
CC=golang-codereviews
https://golang.org/cl/140980043
---
 src/pkg/runtime/asm_amd64p32.s | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 106a722fe2..512e923148 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -185,8 +185,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-4
 	CMPL	AX, DX
 	JEQ	onm
 
-	MOVL	m_curg(BX), BP
-	CMPL	AX, BP
+	MOVL	m_curg(BX), R8
+	CMPL	AX, R8
 	JEQ	oncurg
 	
 	// Not g0, not curg. Must be gsignal, but that's not allowed.

From 91a670d179ae5a0b91a498b4df9d5f088704dba0 Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 4 Sep 2014 10:04:04 +0400
Subject: [PATCH 369/423] runtime: convert netpoll to Go The common code is
 converted, epoll and kqueue are converted. Windows and solaris are still C.

LGTM=rsc
R=golang-codereviews, rsc, dave
CC=golang-codereviews, iant, khr, rsc
https://golang.org/cl/132910043
---
 src/cmd/api/goapi.go              |   3 +
 src/pkg/runtime/asm_386.s         |   3 +
 src/pkg/runtime/asm_amd64.s       |   3 +
 src/pkg/runtime/asm_amd64p32.s    |  10 +
 src/pkg/runtime/atomic_arm.c      |   7 +
 src/pkg/runtime/netpoll.go        | 448 ++++++++++++++++++++++++++++
 src/pkg/runtime/netpoll.goc       | 481 ------------------------------
 src/pkg/runtime/netpoll_epoll.c   | 103 -------
 src/pkg/runtime/netpoll_epoll.go  |  97 ++++++
 src/pkg/runtime/netpoll_kqueue.c  | 111 -------
 src/pkg/runtime/netpoll_kqueue.go | 101 +++++++
 src/pkg/runtime/netpoll_nacl.c    |  37 ---
 src/pkg/runtime/netpoll_nacl.go   |  26 ++
 src/pkg/runtime/os_darwin.go      |   3 -
 src/pkg/runtime/os_dragonfly.go   |   3 -
 src/pkg/runtime/os_freebsd.go     |   3 -
 src/pkg/runtime/os_linux.go       |   5 -
 src/pkg/runtime/os_netbsd.go      |   3 -
 src/pkg/runtime/os_openbsd.go     |   3 -
 src/pkg/runtime/os_solaris.go     |   4 +
 src/pkg/runtime/os_windows.go     |   4 +
 src/pkg/runtime/runtime.h         |   4 -
 src/pkg/runtime/stubs.go          |   3 +
 src/pkg/runtime/sys_linux_386.s   |   2 +-
 src/pkg/runtime/sys_linux_amd64.s |   2 +-
 src/pkg/runtime/sys_linux_arm.s   |  10 +-
 src/pkg/runtime/thunk.s           |  27 ++
 src/pkg/runtime/time.go           |  10 +-
 src/pkg/syscall/net_nacl.go       |   5 +-
 src/pkg/time/internal_test.go     |   2 +-
 src/pkg/time/sleep.go             |   7 +-
 31 files changed, 757 insertions(+), 773 deletions(-)
 create mode 100644 src/pkg/runtime/netpoll.go
 delete mode 100644 src/pkg/runtime/netpoll.goc
 delete mode 100644 src/pkg/runtime/netpoll_epoll.c
 create mode 100644 src/pkg/runtime/netpoll_epoll.go
 delete mode 100644 src/pkg/runtime/netpoll_kqueue.c
 create mode 100644 src/pkg/runtime/netpoll_kqueue.go
 delete mode 100644 src/pkg/runtime/netpoll_nacl.c
 create mode 100644 src/pkg/runtime/netpoll_nacl.go

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index ce806fc95d..2d6dde2665 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -405,6 +405,9 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" sudog struct{};" +
 			" waitq struct{};" +
 			" wincallbackcontext struct{};" +
+			" keventt struct{};" +
+			" timespec struct{};" +
+			" epollevent struct{};" +
 			"); " +
 			"const (" +
 			" cb_max = 2000;" +
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 3c46b40fee..87dd1fa0f5 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -598,6 +598,9 @@ TEXT runtime·xchgp(SB), NOSPLIT, $0-12
 	MOVL	AX, ret+8(FP)
 	RET
 
+TEXT runtime·xchguintptr(SB), NOSPLIT, $0-12
+	JMP	runtime·xchg(SB)
+
 TEXT runtime·procyield(SB),NOSPLIT,$0-0
 	MOVL	cycles+0(FP), AX
 again:
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index eb0795ec3a..80c2ab3c54 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -709,6 +709,9 @@ TEXT runtime·xchgp(SB), NOSPLIT, $0-24
 	MOVQ	AX, ret+16(FP)
 	RET
 
+TEXT runtime·xchguintptr(SB), NOSPLIT, $0-24
+	JMP	runtime·xchg64(SB)
+
 TEXT runtime·procyield(SB),NOSPLIT,$0-0
 	MOVL	cycles+0(FP), AX
 again:
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 512e923148..a0e63b4405 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -666,6 +666,16 @@ TEXT runtime·xchg64(SB), NOSPLIT, $0-24
 	MOVQ	AX, ret+16(FP)
 	RET
 
+TEXT runtime·xchgp(SB), NOSPLIT, $0-12
+	MOVL	ptr+0(FP), BX
+	MOVL	new+4(FP), AX
+	XCHGL	AX, 0(BX)
+	MOVL	AX, ret+8(FP)
+	RET
+
+TEXT runtime·xchguintptr(SB), NOSPLIT, $0-12
+	JMP	runtime·xchg(SB)
+
 TEXT runtime·procyield(SB),NOSPLIT,$0-0
 	MOVL	cycles+0(FP), AX
 again:
diff --git a/src/pkg/runtime/atomic_arm.c b/src/pkg/runtime/atomic_arm.c
index c15108e9a0..5369820c09 100644
--- a/src/pkg/runtime/atomic_arm.c
+++ b/src/pkg/runtime/atomic_arm.c
@@ -54,6 +54,13 @@ runtime·xchgp(void* volatile* addr, void* v)
 	}
 }
 
+#pragma textflag NOSPLIT
+void*
+runtime·xchguintptr(void* volatile* addr, void* v)
+{
+	return runtime·xchg((uint32*)addr, (uint32)v);
+}
+
 #pragma textflag NOSPLIT
 void
 runtime·procyield(uint32 cnt)
diff --git a/src/pkg/runtime/netpoll.go b/src/pkg/runtime/netpoll.go
new file mode 100644
index 0000000000..5c410fc678
--- /dev/null
+++ b/src/pkg/runtime/netpoll.go
@@ -0,0 +1,448 @@
+// 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.
+
+// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
+
+package runtime
+
+import "unsafe"
+
+// Integrated network poller (platform-independent part).
+// A particular implementation (epoll/kqueue) must define the following functions:
+// func netpollinit()			// to initialize the poller
+// func netpollopen(fd uintptr, pd *pollDesc) int32	// to arm edge-triggered notifications
+// and associate fd with pd.
+// An implementation must call the following function to denote that the pd is ready.
+// func netpollready(rg, wg **gp, pd *pollDesc, mode int32)
+
+// pollDesc contains 2 binary semaphores, rg and wg, to park reader and writer
+// goroutines respectively. The semaphore can be in the following states:
+// pdReady - io readiness notification is pending;
+//           a goroutine consumes the notification by changing the state to nil.
+// pdWait - a goroutine prepares to park on the semaphore, but not yet parked;
+//          the goroutine commits to park by changing the state to G pointer,
+//          or, alternatively, concurrent io notification changes the state to READY,
+//          or, alternatively, concurrent timeout/close changes the state to nil.
+// G pointer - the goroutine is blocked on the semaphore;
+//             io notification or timeout/close changes the state to READY or nil respectively
+//             and unparks the goroutine.
+// nil - nothing of the above.
+const (
+	pdReady uintptr = 1
+	pdWait  uintptr = 2
+)
+
+const pollBlockSize = 4 * 1024
+
+// Network poller descriptor.
+type pollDesc struct {
+	link *pollDesc // in pollcache, protected by pollcache.lock
+
+	// The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations.
+	// This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime.
+	// pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO readiness notification)
+	// proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
+	// in a lock-free way by all operations.
+	// NOTE(dvyukov): the following code uses uintptr to store *g (rg/wg),
+	// that will blow up when GC starts moving objects.
+	lock    mutex // protectes the following fields
+	fd      uintptr
+	closing bool
+	seq     uintptr        // protects from stale timers and ready notifications
+	rg      uintptr        // pdReady, pdWait, G waiting for read or nil
+	rt      timer          // read deadline timer (set if rt.f != nil)
+	rd      int64          // read deadline
+	wg      uintptr        // pdReady, pdWait, G waiting for write or nil
+	wt      timer          // write deadline timer
+	wd      int64          // write deadline
+	user    unsafe.Pointer // user settable cookie
+}
+
+type pollCache struct {
+	lock  mutex
+	first *pollDesc
+	// PollDesc objects must be type-stable,
+	// because we can get ready notification from epoll/kqueue
+	// after the descriptor is closed/reused.
+	// Stale notifications are detected using seq variable,
+	// seq is incremented when deadlines are changed or descriptor is reused.
+}
+
+var pollcache pollCache
+
+func netpollServerInit() {
+	netpollinit()
+}
+
+func netpollOpen(fd uintptr) (*pollDesc, int) {
+	pd := pollcache.alloc()
+	lock(&pd.lock)
+	if pd.wg != 0 && pd.wg != pdReady {
+		gothrow("netpollOpen: blocked write on free descriptor")
+	}
+	if pd.rg != 0 && pd.rg != pdReady {
+		gothrow("netpollOpen: blocked read on free descriptor")
+	}
+	pd.fd = fd
+	pd.closing = false
+	pd.seq++
+	pd.rg = 0
+	pd.rd = 0
+	pd.wg = 0
+	pd.wd = 0
+	unlock(&pd.lock)
+
+	errno := netpollopen(fd, pd)
+	return pd, int(errno)
+}
+
+func netpollClose(pd *pollDesc) {
+	if !pd.closing {
+		gothrow("runtime_pollClose: close w/o unblock")
+	}
+	if pd.wg != 0 && pd.wg != pdReady {
+		gothrow("netpollClose: blocked write on closing descriptor")
+	}
+	if pd.rg != 0 && pd.rg != pdReady {
+		gothrow("netpollClose: blocked read on closing descriptor")
+	}
+	netpollclose(uintptr(pd.fd))
+	pollcache.free(pd)
+}
+
+func (c *pollCache) free(pd *pollDesc) {
+	lock(&c.lock)
+	pd.link = c.first
+	c.first = pd
+	unlock(&c.lock)
+}
+
+func netpollReset(pd *pollDesc, mode int) int {
+	err := netpollcheckerr(pd, int32(mode))
+	if err != 0 {
+		return err
+	}
+	if mode == 'r' {
+		pd.rg = 0
+	} else if mode == 'w' {
+		pd.wg = 0
+	}
+	return 0
+}
+
+func netpollWait(pd *pollDesc, mode int) int {
+	err := netpollcheckerr(pd, int32(mode))
+	if err != 0 {
+		return err
+	}
+	// As for now only Solaris uses level-triggered IO.
+	if GOOS == "solaris" {
+		netpollarm(pd, mode)
+	}
+	for !netpollblock(pd, int32(mode), false) {
+		err = netpollcheckerr(pd, int32(mode))
+		if err != 0 {
+			return err
+		}
+		// Can happen if timeout has fired and unblocked us,
+		// but before we had a chance to run, timeout has been reset.
+		// Pretend it has not happened and retry.
+	}
+	return 0
+}
+
+func netpollWaitCanceled(pd *pollDesc, mode int) {
+	// This function is used only on windows after a failed attempt to cancel
+	// a pending async IO operation. Wait for ioready, ignore closing or timeouts.
+	for !netpollblock(pd, int32(mode), true) {
+	}
+}
+
+func netpollSetDeadline(pd *pollDesc, d int64, mode int) {
+	lock(&pd.lock)
+	if pd.closing {
+		unlock(&pd.lock)
+		return
+	}
+	pd.seq++ // invalidate current timers
+	// Reset current timers.
+	if pd.rt.f != nil {
+		deltimer(&pd.rt)
+		pd.rt.f = nil
+	}
+	if pd.wt.f != nil {
+		deltimer(&pd.wt)
+		pd.wt.f = nil
+	}
+	// Setup new timers.
+	if d != 0 && d <= nanotime() {
+		d = -1
+	}
+	if mode == 'r' || mode == 'r'+'w' {
+		pd.rd = d
+	}
+	if mode == 'w' || mode == 'r'+'w' {
+		pd.wd = d
+	}
+	if pd.rd > 0 && pd.rd == pd.wd {
+		pd.rt.f = netpollDeadline
+		pd.rt.when = pd.rd
+		// Copy current seq into the timer arg.
+		// Timer func will check the seq against current descriptor seq,
+		// if they differ the descriptor was reused or timers were reset.
+		pd.rt.arg = pd
+		pd.rt.seq = pd.seq
+		addtimer(&pd.rt)
+	} else {
+		if pd.rd > 0 {
+			pd.rt.f = netpollReadDeadline
+			pd.rt.when = pd.rd
+			pd.rt.arg = pd
+			pd.rt.seq = pd.seq
+			addtimer(&pd.rt)
+		}
+		if pd.wd > 0 {
+			pd.wt.f = netpollWriteDeadline
+			pd.wt.when = pd.wd
+			pd.wt.arg = pd
+			pd.wt.seq = pd.seq
+			addtimer(&pd.wt)
+		}
+	}
+	// If we set the new deadline in the past, unblock currently pending IO if any.
+	var rg, wg *g
+	atomicstorep(unsafe.Pointer(&wg), nil) // full memory barrier between stores to rd/wd and load of rg/wg in netpollunblock
+	if pd.rd < 0 {
+		rg = netpollunblock(pd, 'r', false)
+	}
+	if pd.wd < 0 {
+		wg = netpollunblock(pd, 'w', false)
+	}
+	unlock(&pd.lock)
+	if rg != nil {
+		goready(rg)
+	}
+	if wg != nil {
+		goready(wg)
+	}
+}
+
+func netpollUnblock(pd *pollDesc) {
+	lock(&pd.lock)
+	if pd.closing {
+		gothrow("netpollUnblock: already closing")
+	}
+	pd.closing = true
+	pd.seq++
+	var rg, wg *g
+	atomicstorep(unsafe.Pointer(&rg), nil) // full memory barrier between store to closing and read of rg/wg in netpollunblock
+	rg = netpollunblock(pd, 'r', false)
+	wg = netpollunblock(pd, 'w', false)
+	if pd.rt.f != nil {
+		deltimer(&pd.rt)
+		pd.rt.f = nil
+	}
+	if pd.wt.f != nil {
+		deltimer(&pd.wt)
+		pd.wt.f = nil
+	}
+	unlock(&pd.lock)
+	if rg != nil {
+		goready(rg)
+	}
+	if wg != nil {
+		goready(wg)
+	}
+}
+
+func netpollfd(pd *pollDesc) uintptr {
+	return pd.fd
+}
+
+func netpolluser(pd *pollDesc) *unsafe.Pointer {
+	return &pd.user
+}
+
+func netpollclosing(pd *pollDesc) bool {
+	return pd.closing
+}
+
+func netpolllock(pd *pollDesc) {
+	lock(&pd.lock)
+}
+
+func netpollunlock(pd *pollDesc) {
+	lock(&pd.lock)
+}
+
+// make pd ready, newly runnable goroutines (if any) are returned in rg/wg
+func netpollready(gpp **g, pd *pollDesc, mode int32) {
+	var rg, wg *g
+	if mode == 'r' || mode == 'r'+'w' {
+		rg = netpollunblock(pd, 'r', true)
+	}
+	if mode == 'w' || mode == 'r'+'w' {
+		wg = netpollunblock(pd, 'w', true)
+	}
+	if rg != nil {
+		rg.schedlink = *gpp
+		*gpp = rg
+	}
+	if wg != nil {
+		wg.schedlink = *gpp
+		*gpp = wg
+	}
+}
+
+func netpollcheckerr(pd *pollDesc, mode int32) int {
+	if pd.closing {
+		return 1 // errClosing
+	}
+	if (mode == 'r' && pd.rd < 0) || (mode == 'w' && pd.wd < 0) {
+		return 2 // errTimeout
+	}
+	return 0
+}
+
+func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
+	return casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
+}
+
+// returns true if IO is ready, or false if timedout or closed
+// waitio - wait only for completed IO, ignore errors
+func netpollblock(pd *pollDesc, mode int32, waitio bool) bool {
+	gpp := &pd.rg
+	if mode == 'w' {
+		gpp = &pd.wg
+	}
+
+	// set the gpp semaphore to WAIT
+	for {
+		old := *gpp
+		if old == pdReady {
+			*gpp = 0
+			return true
+		}
+		if old != 0 {
+			gothrow("netpollblock: double wait")
+		}
+		if casuintptr(gpp, 0, pdWait) {
+			break
+		}
+	}
+
+	// need to recheck error states after setting gpp to WAIT
+	// this is necessary because runtime_pollUnblock/runtime_pollSetDeadline/deadlineimpl
+	// do the opposite: store to closing/rd/wd, membarrier, load of rg/wg
+	if waitio || netpollcheckerr(pd, mode) == 0 {
+		f := netpollblockcommit
+		gopark(**(**unsafe.Pointer)(unsafe.Pointer(&f)), unsafe.Pointer(gpp), "IO wait")
+	}
+	// be careful to not lose concurrent READY notification
+	old := xchguintptr(gpp, 0)
+	if old > pdWait {
+		gothrow("netpollblock: corrupted state")
+	}
+	return old == pdReady
+}
+
+func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g {
+	gpp := &pd.rg
+	if mode == 'w' {
+		gpp = &pd.wg
+	}
+
+	for {
+		old := *gpp
+		if old == pdReady {
+			return nil
+		}
+		if old == 0 && !ioready {
+			// Only set READY for ioready. runtime_pollWait
+			// will check for timeout/cancel before waiting.
+			return nil
+		}
+		var new uintptr
+		if ioready {
+			new = pdReady
+		}
+		if casuintptr(gpp, old, new) {
+			if old == pdReady || old == pdWait {
+				old = 0
+			}
+			return (*g)(unsafe.Pointer(old))
+		}
+	}
+}
+
+func netpolldeadlineimpl(pd *pollDesc, seq uintptr, read, write bool) {
+	lock(&pd.lock)
+	// Seq arg is seq when the timer was set.
+	// If it's stale, ignore the timer event.
+	if seq != pd.seq {
+		// The descriptor was reused or timers were reset.
+		unlock(&pd.lock)
+		return
+	}
+	var rg *g
+	if read {
+		if pd.rd <= 0 || pd.rt.f == nil {
+			gothrow("netpollDeadlineImpl: inconsistent read deadline")
+		}
+		pd.rd = -1
+		atomicstorep(unsafe.Pointer(&pd.rt.f), nil) // full memory barrier between store to rd and load of rg in netpollunblock
+		rg = netpollunblock(pd, 'r', false)
+	}
+	var wg *g
+	if write {
+		if pd.wd <= 0 || pd.wt.f == nil && !read {
+			gothrow("netpolldeadlineimpl: inconsistent write deadline")
+		}
+		pd.wd = -1
+		atomicstorep(unsafe.Pointer(&pd.wt.f), nil) // full memory barrier between store to wd and load of wg in netpollunblock
+		wg = netpollunblock(pd, 'w', false)
+	}
+	unlock(&pd.lock)
+	if rg != nil {
+		goready(rg)
+	}
+	if wg != nil {
+		goready(wg)
+	}
+}
+
+func netpollDeadline(arg interface{}, seq uintptr) {
+	netpolldeadlineimpl(arg.(*pollDesc), seq, true, true)
+}
+
+func netpollReadDeadline(arg interface{}, seq uintptr) {
+	netpolldeadlineimpl(arg.(*pollDesc), seq, true, false)
+}
+
+func netpollWriteDeadline(arg interface{}, seq uintptr) {
+	netpolldeadlineimpl(arg.(*pollDesc), seq, false, true)
+}
+
+func (c *pollCache) alloc() *pollDesc {
+	lock(&c.lock)
+	if c.first == nil {
+		const pdSize = unsafe.Sizeof(pollDesc{})
+		n := pollBlockSize / pdSize
+		if n == 0 {
+			n = 1
+		}
+		// Must be in non-GC memory because can be referenced
+		// only from epoll/kqueue internals.
+		mem := persistentalloc(n*pdSize, 0, &memstats.other_sys)
+		for i := uintptr(0); i < n; i++ {
+			pd := (*pollDesc)(add(mem, i*pdSize))
+			pd.link = c.first
+			c.first = pd
+		}
+	}
+	pd := c.first
+	c.first = pd.link
+	unlock(&c.lock)
+	return pd
+}
diff --git a/src/pkg/runtime/netpoll.goc b/src/pkg/runtime/netpoll.goc
deleted file mode 100644
index 446e78eb01..0000000000
--- a/src/pkg/runtime/netpoll.goc
+++ /dev/null
@@ -1,481 +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.
-
-// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
-
-package net
-
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-
-// Integrated network poller (platform-independent part).
-// A particular implementation (epoll/kqueue) must define the following functions:
-// void runtime·netpollinit(void);			// to initialize the poller
-// int32 runtime·netpollopen(uintptr fd, PollDesc *pd);	// to arm edge-triggered notifications
-							// and associate fd with pd.
-// An implementation must call the following function to denote that the pd is ready.
-// void runtime·netpollready(G **gpp, PollDesc *pd, int32 mode);
-
-// PollDesc contains 2 binary semaphores, rg and wg, to park reader and writer
-// goroutines respectively. The semaphore can be in the following states:
-// READY - io readiness notification is pending;
-//         a goroutine consumes the notification by changing the state to nil.
-// WAIT - a goroutine prepares to park on the semaphore, but not yet parked;
-//        the goroutine commits to park by changing the state to G pointer,
-//        or, alternatively, concurrent io notification changes the state to READY,
-//        or, alternatively, concurrent timeout/close changes the state to nil.
-// G pointer - the goroutine is blocked on the semaphore;
-//             io notification or timeout/close changes the state to READY or nil respectively
-//             and unparks the goroutine.
-// nil - nothing of the above.
-#define READY ((G*)1)
-#define WAIT  ((G*)2)
-
-enum
-{
-	PollBlockSize	= 4*1024,
-};
-
-// time.go defines the layout of this structure.
-// Keep in sync with time.go.
-typedef struct Timer Timer;
-struct Timer
-{
-	intgo	i;
-	int64	when;
-	int64	period;
-	FuncVal	*fv;
-	Eface	arg;
-};
-
-void	runtime·addtimer(Timer*);
-void	runtime·deltimer(Timer*);
-
-struct PollDesc
-{
-	PollDesc* link;	// in pollcache, protected by pollcache.lock
-
-	// The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations.
-	// This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime.
-	// pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO rediness notification)
-	// proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
-	// in a lock-free way by all operations.
-	Mutex	lock;		// protects the following fields
-	uintptr	fd;
-	bool	closing;
-	uintptr	seq;	// protects from stale timers and ready notifications
-	G*	rg;	// READY, WAIT, G waiting for read or nil
-	Timer	rt;	// read deadline timer (set if rt.fv != nil)
-	int64	rd;	// read deadline
-	G*	wg;	// READY, WAIT, G waiting for write or nil
-	Timer	wt;	// write deadline timer
-	int64	wd;	// write deadline
-	void*	user;	// user settable cookie
-};
-
-static struct
-{
-	Mutex		lock;
-	PollDesc*	first;
-	// PollDesc objects must be type-stable,
-	// because we can get ready notification from epoll/kqueue
-	// after the descriptor is closed/reused.
-	// Stale notifications are detected using seq variable,
-	// seq is incremented when deadlines are changed or descriptor is reused.
-} pollcache;
-
-static bool	netpollblock(PollDesc*, int32, bool);
-static G*	netpollunblock(PollDesc*, int32, bool);
-static void	deadline(Eface);
-static void	readDeadline(Eface);
-static void	writeDeadline(Eface);
-static PollDesc*	allocPollDesc(void);
-static intgo	checkerr(PollDesc *pd, int32 mode);
-
-static FuncVal deadlineFn	= {(void(*)(void))deadline};
-static FuncVal readDeadlineFn	= {(void(*)(void))readDeadline};
-static FuncVal writeDeadlineFn	= {(void(*)(void))writeDeadline};
-
-// runtimeNano returns the current value of the runtime clock in nanoseconds.
-func runtimeNano() (ns int64) {
-	ns = runtime·nanotime();
-}
-
-func runtime_pollServerInit() {
-	runtime·netpollinit();
-}
-
-func runtime_pollOpen(fd uintptr) (pd *PollDesc, errno int) {
-	pd = allocPollDesc();
-	runtime·lock(&pd->lock);
-	if(pd->wg != nil && pd->wg != READY)
-		runtime·throw("runtime_pollOpen: blocked write on free descriptor");
-	if(pd->rg != nil && pd->rg != READY)
-		runtime·throw("runtime_pollOpen: blocked read on free descriptor");
-	pd->fd = fd;
-	pd->closing = false;
-	pd->seq++;
-	pd->rg = nil;
-	pd->rd = 0;
-	pd->wg = nil;
-	pd->wd = 0;
-	runtime·unlock(&pd->lock);
-
-	errno = runtime·netpollopen(fd, pd);
-}
-
-func runtime_pollClose(pd *PollDesc) {
-	if(!pd->closing)
-		runtime·throw("runtime_pollClose: close w/o unblock");
-	if(pd->wg != nil && pd->wg != READY)
-		runtime·throw("runtime_pollClose: blocked write on closing descriptor");
-	if(pd->rg != nil && pd->rg != READY)
-		runtime·throw("runtime_pollClose: blocked read on closing descriptor");
-	runtime·netpollclose(pd->fd);
-	runtime·lock(&pollcache.lock);
-	pd->link = pollcache.first;
-	pollcache.first = pd;
-	runtime·unlock(&pollcache.lock);
-}
-
-func runtime_pollReset(pd *PollDesc, mode int) (err int) {
-	err = checkerr(pd, mode);
-	if(err)
-		goto ret;
-	if(mode == 'r')
-		pd->rg = nil;
-	else if(mode == 'w')
-		pd->wg = nil;
-ret:
-}
-
-func runtime_pollWait(pd *PollDesc, mode int) (err int) {
-	err = checkerr(pd, mode);
-	if(err == 0) {
-		// As for now only Solaris uses level-triggered IO.
-		if(Solaris)
-			runtime·netpollarm(pd, mode);
-		while(!netpollblock(pd, mode, false)) {
-			err = checkerr(pd, mode);
-			if(err != 0)
-				break;
-			// Can happen if timeout has fired and unblocked us,
-			// but before we had a chance to run, timeout has been reset.
-			// Pretend it has not happened and retry.
-		}
-	}
-}
-
-func runtime_pollWaitCanceled(pd *PollDesc, mode int) {
-	// This function is used only on windows after a failed attempt to cancel
-	// a pending async IO operation. Wait for ioready, ignore closing or timeouts.
-	while(!netpollblock(pd, mode, true))
-		;
-}
-
-func runtime_pollSetDeadline(pd *PollDesc, d int64, mode int) {
-	G *rg, *wg;
-
-	runtime·lock(&pd->lock);
-	if(pd->closing) {
-		runtime·unlock(&pd->lock);
-		return;
-	}
-	pd->seq++;  // invalidate current timers
-	// Reset current timers.
-	if(pd->rt.fv) {
-		runtime·deltimer(&pd->rt);
-		pd->rt.fv = nil;
-	}
-	if(pd->wt.fv) {
-		runtime·deltimer(&pd->wt);
-		pd->wt.fv = nil;
-	}
-	// Setup new timers.
-	if(d != 0 && d <= runtime·nanotime())
-		d = -1;
-	if(mode == 'r' || mode == 'r'+'w')
-		pd->rd = d;
-	if(mode == 'w' || mode == 'r'+'w')
-		pd->wd = d;
-	if(pd->rd > 0 && pd->rd == pd->wd) {
-		pd->rt.fv = &deadlineFn;
-		pd->rt.when = pd->rd;
-		// Copy current seq into the timer arg.
-		// Timer func will check the seq against current descriptor seq,
-		// if they differ the descriptor was reused or timers were reset.
-		pd->rt.arg.type = (Type*)pd->seq;
-		pd->rt.arg.data = pd;
-		runtime·addtimer(&pd->rt);
-	} else {
-		if(pd->rd > 0) {
-			pd->rt.fv = &readDeadlineFn;
-			pd->rt.when = pd->rd;
-			pd->rt.arg.type = (Type*)pd->seq;
-			pd->rt.arg.data = pd;
-			runtime·addtimer(&pd->rt);
-		}
-		if(pd->wd > 0) {
-			pd->wt.fv = &writeDeadlineFn;
-			pd->wt.when = pd->wd;
-			pd->wt.arg.type = (Type*)pd->seq;
-			pd->wt.arg.data = pd;
-			runtime·addtimer(&pd->wt);
-		}
-	}
-	// If we set the new deadline in the past, unblock currently pending IO if any.
-	rg = nil;
-	runtime·atomicstorep(&wg, nil);  // full memory barrier between stores to rd/wd and load of rg/wg in netpollunblock
-	if(pd->rd < 0)
-		rg = netpollunblock(pd, 'r', false);
-	if(pd->wd < 0)
-		wg = netpollunblock(pd, 'w', false);
-	runtime·unlock(&pd->lock);
-	if(rg)
-		runtime·ready(rg);
-	if(wg)
-		runtime·ready(wg);
-}
-
-func runtime_pollUnblock(pd *PollDesc) {
-	G *rg, *wg;
-
-	runtime·lock(&pd->lock);
-	if(pd->closing)
-		runtime·throw("runtime_pollUnblock: already closing");
-	pd->closing = true;
-	pd->seq++;
-	runtime·atomicstorep(&rg, nil);  // full memory barrier between store to closing and read of rg/wg in netpollunblock
-	rg = netpollunblock(pd, 'r', false);
-	wg = netpollunblock(pd, 'w', false);
-	if(pd->rt.fv) {
-		runtime·deltimer(&pd->rt);
-		pd->rt.fv = nil;
-	}
-	if(pd->wt.fv) {
-		runtime·deltimer(&pd->wt);
-		pd->wt.fv = nil;
-	}
-	runtime·unlock(&pd->lock);
-	if(rg)
-		runtime·ready(rg);
-	if(wg)
-		runtime·ready(wg);
-}
-
-uintptr
-runtime·netpollfd(PollDesc *pd)
-{
-	return pd->fd;
-}
-
-void**
-runtime·netpolluser(PollDesc *pd)
-{
-	return &pd->user;
-}
-
-bool
-runtime·netpollclosing(PollDesc *pd)
-{
-	return pd->closing;
-}
-
-void
-runtime·netpolllock(PollDesc *pd)
-{
-	runtime·lock(&pd->lock);
-}
-
-void
-runtime·netpollunlock(PollDesc *pd)
-{
-	runtime·unlock(&pd->lock);
-}
-
-// make pd ready, newly runnable goroutines (if any) are enqueued info gpp list
-void
-runtime·netpollready(G **gpp, PollDesc *pd, int32 mode)
-{
-	G *rg, *wg;
-
-	rg = wg = nil;
-	if(mode == 'r' || mode == 'r'+'w')
-		rg = netpollunblock(pd, 'r', true);
-	if(mode == 'w' || mode == 'r'+'w')
-		wg = netpollunblock(pd, 'w', true);
-	if(rg) {
-		rg->schedlink = *gpp;
-		*gpp = rg;
-	}
-	if(wg) {
-		wg->schedlink = *gpp;
-		*gpp = wg;
-	}
-}
-
-static intgo
-checkerr(PollDesc *pd, int32 mode)
-{
-	if(pd->closing)
-		return 1;  // errClosing
-	if((mode == 'r' && pd->rd < 0) || (mode == 'w' && pd->wd < 0))
-		return 2;  // errTimeout
-	return 0;
-}
-
-static bool
-blockcommit(G *gp, G **gpp)
-{
-	return runtime·casp(gpp, WAIT, gp);
-}
-
-// returns true if IO is ready, or false if timedout or closed
-// waitio - wait only for completed IO, ignore errors
-static bool
-netpollblock(PollDesc *pd, int32 mode, bool waitio)
-{
-	G **gpp, *old;
-
-	gpp = &pd->rg;
-	if(mode == 'w')
-		gpp = &pd->wg;
-
-	// set the gpp semaphore to WAIT
-	for(;;) {
-		old = *gpp;
-		if(old == READY) {
-			*gpp = nil;
-			return true;
-		}
-		if(old != nil)
-			runtime·throw("netpollblock: double wait");
-		if(runtime·casp(gpp, nil, WAIT))
-			break;
-	}
-
-	// need to recheck error states after setting gpp to WAIT
-	// this is necessary because runtime_pollUnblock/runtime_pollSetDeadline/deadlineimpl
-	// do the opposite: store to closing/rd/wd, membarrier, load of rg/wg
-	if(waitio || checkerr(pd, mode) == 0)
-		runtime·park((bool(*)(G*, void*))blockcommit, gpp, runtime·gostringnocopy((byte*)"IO wait"));
-	// be careful to not lose concurrent READY notification
-	old = runtime·xchgp(gpp, nil);
-	if(old > WAIT)
-		runtime·throw("netpollblock: corrupted state");
-	return old == READY;
-}
-
-static G*
-netpollunblock(PollDesc *pd, int32 mode, bool ioready)
-{
-	G **gpp, *old, *new;
-
-	gpp = &pd->rg;
-	if(mode == 'w')
-		gpp = &pd->wg;
-
-	for(;;) {
-		old = *gpp;
-		if(old == READY)
-			return nil;
-		if(old == nil && !ioready) {
-			// Only set READY for ioready. runtime_pollWait
-			// will check for timeout/cancel before waiting.
-			return nil;
-		}
-		new = nil;
-		if(ioready)
-			new = READY;
-		if(runtime·casp(gpp, old, new))
-			break;
-	}
-	if(old > WAIT)
-		return old;  // must be G*
-	return nil;
-}
-
-static void
-deadlineimpl(Eface arg, bool read, bool write)
-{
-	PollDesc *pd;
-	uint32 seq;
-	G *rg, *wg;
-
-	pd = (PollDesc*)arg.data;
-	// This is the seq when the timer was set.
-	// If it's stale, ignore the timer event.
-	seq = (uintptr)arg.type;
-	rg = wg = nil;
-	runtime·lock(&pd->lock);
-	if(seq != pd->seq) {
-		// The descriptor was reused or timers were reset.
-		runtime·unlock(&pd->lock);
-		return;
-	}
-	if(read) {
-		if(pd->rd <= 0 || pd->rt.fv == nil)
-			runtime·throw("deadlineimpl: inconsistent read deadline");
-		pd->rd = -1;
-		runtime·atomicstorep(&pd->rt.fv, nil);  // full memory barrier between store to rd and load of rg in netpollunblock
-		rg = netpollunblock(pd, 'r', false);
-	}
-	if(write) {
-		if(pd->wd <= 0 || (pd->wt.fv == nil && !read))
-			runtime·throw("deadlineimpl: inconsistent write deadline");
-		pd->wd = -1;
-		runtime·atomicstorep(&pd->wt.fv, nil);  // full memory barrier between store to wd and load of wg in netpollunblock
-		wg = netpollunblock(pd, 'w', false);
-	}
-	runtime·unlock(&pd->lock);
-	if(rg)
-		runtime·ready(rg);
-	if(wg)
-		runtime·ready(wg);
-}
-
-static void
-deadline(Eface arg)
-{
-	deadlineimpl(arg, true, true);
-}
-
-static void
-readDeadline(Eface arg)
-{
-	deadlineimpl(arg, true, false);
-}
-
-static void
-writeDeadline(Eface arg)
-{
-	deadlineimpl(arg, false, true);
-}
-
-static PollDesc*
-allocPollDesc(void)
-{
-	PollDesc *pd;
-	uint32 i, n;
-
-	runtime·lock(&pollcache.lock);
-	if(pollcache.first == nil) {
-		n = PollBlockSize/sizeof(*pd);
-		if(n == 0)
-			n = 1;
-		// Must be in non-GC memory because can be referenced
-		// only from epoll/kqueue internals.
-		pd = runtime·persistentalloc(n*sizeof(*pd), 0, &mstats.other_sys);
-		for(i = 0; i < n; i++) {
-			pd[i].link = pollcache.first;
-			pollcache.first = &pd[i];
-		}
-	}
-	pd = pollcache.first;
-	pollcache.first = pd->link;
-	runtime·unlock(&pollcache.lock);
-	return pd;
-}
diff --git a/src/pkg/runtime/netpoll_epoll.c b/src/pkg/runtime/netpoll_epoll.c
deleted file mode 100644
index 9d6c205155..0000000000
--- a/src/pkg/runtime/netpoll_epoll.c
+++ /dev/null
@@ -1,103 +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.
-
-// +build linux
-
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-
-int32	runtime·epollcreate(int32 size);
-int32	runtime·epollcreate1(int32 flags);
-int32	runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
-int32	runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
-void	runtime·closeonexec(int32 fd);
-
-static int32 epfd = -1;  // epoll descriptor
-
-void
-runtime·netpollinit(void)
-{
-	epfd = runtime·epollcreate1(EPOLL_CLOEXEC);
-	if(epfd >= 0)
-		return;
-	epfd = runtime·epollcreate(1024);
-	if(epfd >= 0) {
-		runtime·closeonexec(epfd);
-		return;
-	}
-	runtime·printf("netpollinit: failed to create descriptor (%d)\n", -epfd);
-	runtime·throw("netpollinit: failed to create descriptor");
-}
-
-int32
-runtime·netpollopen(uintptr fd, PollDesc *pd)
-{
-	EpollEvent ev;
-	int32 res;
-
-	ev.events = EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET;
-	*(uint64*)ev.data = (uint64)(uintptr)pd;
-	res = runtime·epollctl(epfd, EPOLL_CTL_ADD, (int32)fd, &ev);
-	return -res;
-}
-
-int32
-runtime·netpollclose(uintptr fd)
-{
-	EpollEvent ev;
-	int32 res;
-
-	res = runtime·epollctl(epfd, EPOLL_CTL_DEL, (int32)fd, &ev);
-	return -res;
-}
-
-void
-runtime·netpollarm(PollDesc* pd, int32 mode)
-{
-	USED(pd);
-	USED(mode);
-	runtime·throw("unused");
-}
-
-// polls for ready network connections
-// returns list of goroutines that become runnable
-G*
-runtime·netpoll(bool block)
-{
-	static int32 lasterr;
-	EpollEvent events[128], *ev;
-	int32 n, i, waitms, mode;
-	G *gp;
-
-	if(epfd == -1)
-		return nil;
-	waitms = -1;
-	if(!block)
-		waitms = 0;
-retry:
-	n = runtime·epollwait(epfd, events, nelem(events), waitms);
-	if(n < 0) {
-		if(n != -EINTR && n != lasterr) {
-			lasterr = n;
-			runtime·printf("runtime: epollwait on fd %d failed with %d\n", epfd, -n);
-		}
-		goto retry;
-	}
-	gp = nil;
-	for(i = 0; i < n; i++) {
-		ev = &events[i];
-		if(ev->events == 0)
-			continue;
-		mode = 0;
-		if(ev->events & (EPOLLIN|EPOLLRDHUP|EPOLLHUP|EPOLLERR))
-			mode += 'r';
-		if(ev->events & (EPOLLOUT|EPOLLHUP|EPOLLERR))
-			mode += 'w';
-		if(mode)
-			runtime·netpollready(&gp, (void*)(uintptr)*(uint64*)ev->data, mode);
-	}
-	if(block && gp == nil)
-		goto retry;
-	return gp;
-}
diff --git a/src/pkg/runtime/netpoll_epoll.go b/src/pkg/runtime/netpoll_epoll.go
new file mode 100644
index 0000000000..ecfc9cdde8
--- /dev/null
+++ b/src/pkg/runtime/netpoll_epoll.go
@@ -0,0 +1,97 @@
+// 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.
+
+// +build linux
+
+package runtime
+
+import "unsafe"
+
+func epollcreate(size int32) int32
+func epollcreate1(flags int32) int32
+
+//go:noescape
+func epollctl(epfd, op, fd int32, ev *epollevent) int32
+
+//go:noescape
+func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32
+func closeonexec(fd int32)
+
+var (
+	epfd           int32 = -1 // epoll descriptor
+	netpolllasterr int32
+)
+
+func netpollinit() {
+	epfd = epollcreate1(_EPOLL_CLOEXEC)
+	if epfd >= 0 {
+		return
+	}
+	epfd = epollcreate(1024)
+	if epfd >= 0 {
+		closeonexec(epfd)
+		return
+	}
+	println("netpollinit: failed to create epoll descriptor", -epfd)
+	gothrow("netpollinit: failed to create descriptor")
+}
+
+func netpollopen(fd uintptr, pd *pollDesc) int32 {
+	var ev epollevent
+	ev.events = _EPOLLIN | _EPOLLOUT | _EPOLLRDHUP | _EPOLLET
+	*(**pollDesc)(unsafe.Pointer(&ev.data)) = pd
+	return -epollctl(epfd, _EPOLL_CTL_ADD, int32(fd), &ev)
+}
+
+func netpollclose(fd uintptr) int32 {
+	var ev epollevent
+	return -epollctl(epfd, _EPOLL_CTL_DEL, int32(fd), &ev)
+}
+
+func netpollarm(pd *pollDesc, mode int) {
+	gothrow("unused")
+}
+
+// polls for ready network connections
+// returns list of goroutines that become runnable
+func netpoll(block bool) (gp *g) {
+	if epfd == -1 {
+		return
+	}
+	waitms := int32(-1)
+	if !block {
+		waitms = 0
+	}
+	var events [128]epollevent
+retry:
+	n := epollwait(epfd, &events[0], int32(len(events)), waitms)
+	if n < 0 {
+		if n != -_EINTR && n != netpolllasterr {
+			netpolllasterr = n
+			println("runtime: epollwait on fd", epfd, "failed with", -n)
+		}
+		goto retry
+	}
+	for i := int32(0); i < n; i++ {
+		ev := &events[i]
+		if ev.events == 0 {
+			continue
+		}
+		var mode int32
+		if ev.events&(_EPOLLIN|_EPOLLRDHUP|_EPOLLHUP|_EPOLLERR) != 0 {
+			mode += 'r'
+		}
+		if ev.events&(_EPOLLOUT|_EPOLLHUP|_EPOLLERR) != 0 {
+			mode += 'w'
+		}
+		if mode != 0 {
+			pd := *(**pollDesc)(unsafe.Pointer(&ev.data))
+			netpollready((**g)(noescape(unsafe.Pointer(&gp))), pd, mode)
+		}
+	}
+	if block && gp == nil {
+		goto retry
+	}
+	return gp
+}
diff --git a/src/pkg/runtime/netpoll_kqueue.c b/src/pkg/runtime/netpoll_kqueue.c
deleted file mode 100644
index 6b7fc869d3..0000000000
--- a/src/pkg/runtime/netpoll_kqueue.c
+++ /dev/null
@@ -1,111 +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.
-
-// +build darwin dragonfly freebsd netbsd openbsd
-
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-
-// Integrated network poller (kqueue-based implementation).
-
-int32	runtime·kqueue(void);
-int32	runtime·kevent(int32, KeventT*, int32, KeventT*, int32, Timespec*);
-void	runtime·closeonexec(int32);
-
-static int32 kq = -1;
-
-void
-runtime·netpollinit(void)
-{
-	kq = runtime·kqueue();
-	if(kq < 0) {
-		runtime·printf("netpollinit: kqueue failed with %d\n", -kq);
-		runtime·throw("netpollinit: kqueue failed");
-	}
-	runtime·closeonexec(kq);
-}
-
-int32
-runtime·netpollopen(uintptr fd, PollDesc *pd)
-{
-	KeventT ev[2];
-	int32 n;
-
-	// Arm both EVFILT_READ and EVFILT_WRITE in edge-triggered mode (EV_CLEAR)
-	// for the whole fd lifetime.  The notifications are automatically unregistered
-	// when fd is closed.
-	ev[0].ident = (uint32)fd;
-	ev[0].filter = EVFILT_READ;
-	ev[0].flags = EV_ADD|EV_CLEAR;
-	ev[0].fflags = 0;
-	ev[0].data = 0;
-	ev[0].udata = (kevent_udata)pd;
-	ev[1] = ev[0];
-	ev[1].filter = EVFILT_WRITE;
-	n = runtime·kevent(kq, ev, 2, nil, 0, nil);
-	if(n < 0)
-		return -n;
-	return 0;
-}
-
-int32
-runtime·netpollclose(uintptr fd)
-{
-	// Don't need to unregister because calling close()
-	// on fd will remove any kevents that reference the descriptor.
-	USED(fd);
-	return 0;
-}
-
-void
-runtime·netpollarm(PollDesc* pd, int32 mode)
-{
-	USED(pd, mode);
-	runtime·throw("unused");
-}
-
-// Polls for ready network connections.
-// Returns list of goroutines that become runnable.
-G*
-runtime·netpoll(bool block)
-{
-	static int32 lasterr;
-	KeventT events[64], *ev;
-	Timespec ts, *tp;
-	int32 n, i, mode;
-	G *gp;
-
-	if(kq == -1)
-		return nil;
-	tp = nil;
-	if(!block) {
-		ts.tv_sec = 0;
-		ts.tv_nsec = 0;
-		tp = &ts;
-	}
-	gp = nil;
-retry:
-	n = runtime·kevent(kq, nil, 0, events, nelem(events), tp);
-	if(n < 0) {
-		if(n != -EINTR && n != lasterr) {
-			lasterr = n;
-			runtime·printf("runtime: kevent on fd %d failed with %d\n", kq, -n);
-		}
-		goto retry;
-	}
-	for(i = 0; i < n; i++) {
-		ev = &events[i];
-		mode = 0;
-		if(ev->filter == EVFILT_READ)
-			mode += 'r';
-		if(ev->filter == EVFILT_WRITE)
-			mode += 'w';
-		if(mode)
-			runtime·netpollready(&gp, (PollDesc*)ev->udata, mode);
-	}
-	if(block && gp == nil)
-		goto retry;
-	return gp;
-}
diff --git a/src/pkg/runtime/netpoll_kqueue.go b/src/pkg/runtime/netpoll_kqueue.go
new file mode 100644
index 0000000000..d6d55b97b8
--- /dev/null
+++ b/src/pkg/runtime/netpoll_kqueue.go
@@ -0,0 +1,101 @@
+// 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.
+
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package runtime
+
+// Integrated network poller (kqueue-based implementation).
+
+import "unsafe"
+
+func kqueue() int32
+
+//go:noescape
+func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
+func closeonexec(fd int32)
+
+var (
+	kq             int32 = -1
+	netpolllasterr int32
+)
+
+func netpollinit() {
+	kq = kqueue()
+	if kq < 0 {
+		println("netpollinit: kqueue failed with", -kq)
+		gothrow("netpollinit: kqueue failed")
+	}
+	closeonexec(kq)
+}
+
+func netpollopen(fd uintptr, pd *pollDesc) int32 {
+	// Arm both EVFILT_READ and EVFILT_WRITE in edge-triggered mode (EV_CLEAR)
+	// for the whole fd lifetime.  The notifications are automatically unregistered
+	// when fd is closed.
+	var ev [2]keventt
+	*(*uintptr)(unsafe.Pointer(&ev[0].ident)) = fd
+	ev[0].filter = _EVFILT_READ
+	ev[0].flags = _EV_ADD | _EV_CLEAR
+	ev[0].fflags = 0
+	ev[0].data = 0
+	ev[0].udata = (*byte)(unsafe.Pointer(pd))
+	ev[1] = ev[0]
+	ev[1].filter = _EVFILT_WRITE
+	n := kevent(kq, &ev[0], 2, nil, 0, nil)
+	if n < 0 {
+		return -n
+	}
+	return 0
+}
+
+func netpollclose(fd uintptr) int32 {
+	// Don't need to unregister because calling close()
+	// on fd will remove any kevents that reference the descriptor.
+	return 0
+}
+
+func netpollarm(pd *pollDesc, mode int) {
+	gothrow("unused")
+}
+
+// Polls for ready network connections.
+// Returns list of goroutines that become runnable.
+func netpoll(block bool) (gp *g) {
+	if kq == -1 {
+		return
+	}
+	var tp *timespec
+	var ts timespec
+	if !block {
+		tp = &ts
+	}
+	var events [64]keventt
+retry:
+	n := kevent(kq, nil, 0, &events[0], int32(len(events)), tp)
+	if n < 0 {
+		if n != -_EINTR && n != netpolllasterr {
+			netpolllasterr = n
+			println("runtime: kevent on fd", kq, "failed with", -n)
+		}
+		goto retry
+	}
+	for i := 0; i < int(n); i++ {
+		ev := &events[i]
+		var mode int32
+		if ev.filter == _EVFILT_READ {
+			mode += 'r'
+		}
+		if ev.filter == _EVFILT_WRITE {
+			mode += 'w'
+		}
+		if mode != 0 {
+			netpollready((**g)(noescape(unsafe.Pointer(&gp))), (*pollDesc)(unsafe.Pointer(ev.udata)), mode)
+		}
+	}
+	if block && gp == nil {
+		goto retry
+	}
+	return gp
+}
diff --git a/src/pkg/runtime/netpoll_nacl.c b/src/pkg/runtime/netpoll_nacl.c
deleted file mode 100644
index b75753a23b..0000000000
--- a/src/pkg/runtime/netpoll_nacl.c
+++ /dev/null
@@ -1,37 +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 "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-
-// Fake network poller for NaCl.
-// Should never be used, because NaCl network connections do not honor "SetNonblock".
-
-void
-runtime·netpollinit(void)
-{
-}
-
-int32
-runtime·netpollopen(uintptr fd, PollDesc *pd)
-{
-	USED(fd);
-	USED(pd);
-	return 0;
-}
-
-int32
-runtime·netpollclose(uintptr fd)
-{
-	USED(fd);
-	return 0;
-}
-
-G*
-runtime·netpoll(bool block)
-{
-	USED(block);
-	return nil;
-}
diff --git a/src/pkg/runtime/netpoll_nacl.go b/src/pkg/runtime/netpoll_nacl.go
new file mode 100644
index 0000000000..5cbc300321
--- /dev/null
+++ b/src/pkg/runtime/netpoll_nacl.go
@@ -0,0 +1,26 @@
+// 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.
+
+// Fake network poller for NaCl.
+// Should never be used, because NaCl network connections do not honor "SetNonblock".
+
+package runtime
+
+func netpollinit() {
+}
+
+func netpollopen(fd uintptr, pd *pollDesc) int32 {
+	return 0
+}
+
+func netpollclose(fd uintptr) int32 {
+	return 0
+}
+
+func netpollarm(pd *pollDesc, mode int) {
+}
+
+func netpoll(block bool) *g {
+	return nil
+}
diff --git a/src/pkg/runtime/os_darwin.go b/src/pkg/runtime/os_darwin.go
index 4eefec1f64..e0f63ddb90 100644
--- a/src/pkg/runtime/os_darwin.go
+++ b/src/pkg/runtime/os_darwin.go
@@ -18,9 +18,6 @@ func sigaction(mode uint32, new, old unsafe.Pointer)
 func sigaltstack(new, old unsafe.Pointer)
 func sigtramp()
 func setitimer(mode int32, new, old unsafe.Pointer)
-func kqueue() int32
-func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
-func closeonexec(fd int32)
 func mach_semaphore_wait(sema uint32) int32
 func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
 func mach_semaphore_signal(sema uint32) int32
diff --git a/src/pkg/runtime/os_dragonfly.go b/src/pkg/runtime/os_dragonfly.go
index 3e7fc8d4ee..cdaa06986e 100644
--- a/src/pkg/runtime/os_dragonfly.go
+++ b/src/pkg/runtime/os_dragonfly.go
@@ -14,9 +14,6 @@ func setitimer(mode int32, new, old unsafe.Pointer)
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
 func getrlimit(kind int32, limit unsafe.Pointer) int32
 func raise(sig int32)
-func kqueue() int32
-func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
-func closeonexec(fd int32)
 func sys_umtx_sleep(addr unsafe.Pointer, val, timeout int32) int32
 func sys_umtx_wakeup(addr unsafe.Pointer, val int32) int32
 
diff --git a/src/pkg/runtime/os_freebsd.go b/src/pkg/runtime/os_freebsd.go
index 14d1b7ca9d..96964f1e1e 100644
--- a/src/pkg/runtime/os_freebsd.go
+++ b/src/pkg/runtime/os_freebsd.go
@@ -14,9 +14,6 @@ func setitimer(mode int32, new, old unsafe.Pointer)
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
 func getrlimit(kind int32, limit unsafe.Pointer) int32
 func raise(sig int32)
-func kqueue() int32
-func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
-func closeonexec(fd int32)
 func sys_umtx_op(addr unsafe.Pointer, mode int32, val uint32, ptr2, ts unsafe.Pointer) int32
 
 const stackSystem = 0
diff --git a/src/pkg/runtime/os_linux.go b/src/pkg/runtime/os_linux.go
index ba52a31e90..a6799cd414 100644
--- a/src/pkg/runtime/os_linux.go
+++ b/src/pkg/runtime/os_linux.go
@@ -14,11 +14,6 @@ func setitimer(mode int32, new, old unsafe.Pointer)
 func rtsigprocmask(sig int32, new, old unsafe.Pointer, size int32)
 func getrlimit(kind int32, limit unsafe.Pointer) int32
 func raise(sig int32)
-func epollcreate(size int32) int32
-func epollcreate1(flags int32) int32
-func epollctl(epfd, op, fd int32, ev unsafe.Pointer) int32
-func epollwait(epfd int32, ev unsafe.Pointer, nev, timeout int32) int32
-func closeonexec(fd int32)
 func sched_getaffinity(pid, len uintptr, buf *uintptr) int32
 
 const stackSystem = 0
diff --git a/src/pkg/runtime/os_netbsd.go b/src/pkg/runtime/os_netbsd.go
index 15607685e2..8792f497e4 100644
--- a/src/pkg/runtime/os_netbsd.go
+++ b/src/pkg/runtime/os_netbsd.go
@@ -13,9 +13,6 @@ func sigprocmask(mode int32, new, old unsafe.Pointer)
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
 func lwp_tramp()
 func raise(sig int32)
-func kqueue() int32
-func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
-func closeonexec(fd int32)
 func getcontext(ctxt unsafe.Pointer)
 func lwp_create(ctxt unsafe.Pointer, flags uintptr, lwpid unsafe.Pointer) int32
 func lwp_park(abstime unsafe.Pointer, unpark int32, hint, unparkhint unsafe.Pointer) int32
diff --git a/src/pkg/runtime/os_openbsd.go b/src/pkg/runtime/os_openbsd.go
index 681bdde82e..19e2b45a15 100644
--- a/src/pkg/runtime/os_openbsd.go
+++ b/src/pkg/runtime/os_openbsd.go
@@ -12,9 +12,6 @@ func sigaltstack(new, old unsafe.Pointer)
 func sigprocmask(mode int32, new uint32) uint32
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
 func raise(sig int32)
-func kqueue() int32
-func kevent(fd int32, ev1 unsafe.Pointer, nev1 int32, ev2 unsafe.Pointer, nev2 int32, ts unsafe.Pointer) int32
-func closeonexec(fd int32)
 func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32
 func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
 func thrwakeup(ident unsafe.Pointer, n int32) int32
diff --git a/src/pkg/runtime/os_solaris.go b/src/pkg/runtime/os_solaris.go
index 556c1504bc..a5e6966781 100644
--- a/src/pkg/runtime/os_solaris.go
+++ b/src/pkg/runtime/os_solaris.go
@@ -19,6 +19,10 @@ func tstart_sysvicall(mm unsafe.Pointer) uint32
 func nanotime1() int64
 func usleep1(usec uint32)
 func osyield1()
+func netpollinit()
+func netpollopen(fd uintptr, pd *pollDesc) int32
+func netpollclose(fd uintptr) int32
+func netpollarm(pd *pollDesc, mode int)
 
 type libcFunc byte
 
diff --git a/src/pkg/runtime/os_windows.go b/src/pkg/runtime/os_windows.go
index 15957b3290..6a3bfca41f 100644
--- a/src/pkg/runtime/os_windows.go
+++ b/src/pkg/runtime/os_windows.go
@@ -21,6 +21,10 @@ func asmstdcall(fn unsafe.Pointer)
 func getlasterror() uint32
 func setlasterror(err uint32)
 func usleep1(usec uint32)
+func netpollinit()
+func netpollopen(fd uintptr, pd *pollDesc) int32
+func netpollclose(fd uintptr) int32
+func netpollarm(pd *pollDesc, mode int)
 
 const stackSystem = 512 * ptrSize
 
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 4cecc39a6f..7007957b65 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -886,12 +886,8 @@ int64	runtime·cputicks(void);
 int64	runtime·tickspersecond(void);
 void	runtime·blockevent(int64, intgo);
 G*	runtime·netpoll(bool);
-void	runtime·netpollinit(void);
-int32	runtime·netpollopen(uintptr, PollDesc*);
-int32   runtime·netpollclose(uintptr);
 void	runtime·netpollready(G**, PollDesc*, int32);
 uintptr	runtime·netpollfd(PollDesc*);
-void	runtime·netpollarm(PollDesc*, int32);
 void**	runtime·netpolluser(PollDesc*);
 bool	runtime·netpollclosing(PollDesc*);
 void	runtime·netpolllock(PollDesc*);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 3719c7501c..73dc2ec443 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -237,6 +237,9 @@ func xchg64(ptr *uint64, new uint64) uint64
 //go:noescape
 func xchgp(ptr unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
 
+//go:noescape
+func xchguintptr(ptr *uintptr, new uintptr) uintptr
+
 //go:noescape
 func atomicstore(ptr *uint32, val uint32)
 
diff --git a/src/pkg/runtime/sys_linux_386.s b/src/pkg/runtime/sys_linux_386.s
index ace5a1802b..426e05faa1 100644
--- a/src/pkg/runtime/sys_linux_386.s
+++ b/src/pkg/runtime/sys_linux_386.s
@@ -457,7 +457,7 @@ TEXT runtime·epollcreate1(SB),NOSPLIT,$0
 	MOVL	AX, ret+4(FP)
 	RET
 
-// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
+// func epollctl(epfd, op, fd int32, ev *epollEvent) int
 TEXT runtime·epollctl(SB),NOSPLIT,$0
 	MOVL	$255, AX
 	MOVL	epfd+0(FP), BX
diff --git a/src/pkg/runtime/sys_linux_amd64.s b/src/pkg/runtime/sys_linux_amd64.s
index f263ef35ae..3ce6bfc905 100644
--- a/src/pkg/runtime/sys_linux_amd64.s
+++ b/src/pkg/runtime/sys_linux_amd64.s
@@ -378,7 +378,7 @@ TEXT runtime·epollcreate1(SB),NOSPLIT,$0
 	MOVL	AX, ret+8(FP)
 	RET
 
-// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
+// func epollctl(epfd, op, fd int32, ev *epollEvent) int
 TEXT runtime·epollctl(SB),NOSPLIT,$0
 	MOVL	epfd+0(FP), DI
 	MOVL	op+4(FP), SI
diff --git a/src/pkg/runtime/sys_linux_arm.s b/src/pkg/runtime/sys_linux_arm.s
index 3221cdf29f..a2abe8f25c 100644
--- a/src/pkg/runtime/sys_linux_arm.s
+++ b/src/pkg/runtime/sys_linux_arm.s
@@ -424,12 +424,12 @@ TEXT runtime·epollcreate1(SB),NOSPLIT,$0
 	MOVW	R0, ret+4(FP)
 	RET
 
-// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev)
+// func epollctl(epfd, op, fd int32, ev *epollEvent) int
 TEXT runtime·epollctl(SB),NOSPLIT,$0
-	MOVW	0(FP), R0
-	MOVW	4(FP), R1
-	MOVW	8(FP), R2
-	MOVW	12(FP), R3
+	MOVW	epfd+0(FP), R0
+	MOVW	op+4(FP), R1
+	MOVW	fd+8(FP), R2
+	MOVW	ev+12(FP), R3
 	MOVW	$SYS_epoll_ctl, R7
 	SWI	$0
 	MOVW	R0, ret+16(FP)
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 0b5963e70a..0c057a3e23 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -11,6 +11,9 @@
 #define JMP B
 #endif
 
+TEXT net·runtimeNano(SB),NOSPLIT,$0-0
+	JMP	runtime·nanotime(SB)
+
 TEXT time·runtimeNano(SB),NOSPLIT,$0-0
 	JMP     runtime·nanotime(SB)
 
@@ -74,6 +77,30 @@ TEXT reflect·chanrecv(SB), NOSPLIT, $0-0
 TEXT runtime∕debug·freeOSMemory(SB), NOSPLIT, $0-0
 	JMP	runtime·freeOSMemory(SB)
 
+TEXT net·runtime_pollServerInit(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollServerInit(SB)
+
+TEXT net·runtime_pollOpen(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollOpen(SB)
+
+TEXT net·runtime_pollClose(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollClose(SB)
+
+TEXT net·runtime_pollReset(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollReset(SB)
+
+TEXT net·runtime_pollWait(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollWait(SB)
+
+TEXT net·runtime_pollWaitCanceled(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollWaitCanceled(SB)
+
+TEXT net·runtime_pollSetDeadline(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollSetDeadline(SB)
+
+TEXT net·runtime_pollUnblock(SB),NOSPLIT,$0-0
+	JMP	runtime·netpollUnblock(SB)
+
 TEXT syscall·setenv_c(SB), NOSPLIT, $0-0
 	JMP	runtime·syscall_setenv_c(SB)
 
diff --git a/src/pkg/runtime/time.go b/src/pkg/runtime/time.go
index 102539bf21..8cf9eecf83 100644
--- a/src/pkg/runtime/time.go
+++ b/src/pkg/runtime/time.go
@@ -9,7 +9,7 @@ package runtime
 import "unsafe"
 
 // Package time knows the layout of this structure.
-// If this struct changes, adjust ../time/sleep.go:/runtimeTimer and netpoll.goc:/timer.
+// If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
 // For GOOS=nacl, package syscall knows the layout of this structure.
 // If this struct changes, adjust ../syscall/net_nacl.go:/runtimeTimer.
 type timer struct {
@@ -20,8 +20,9 @@ type timer struct {
 	// a well-behaved function and not block.
 	when   int64
 	period int64
-	f      func(interface{})
+	f      func(interface{}, uintptr)
 	arg    interface{}
+	seq    uintptr
 }
 
 var timers struct {
@@ -74,7 +75,7 @@ func stopTimer(t *timer) bool {
 // Go runtime.
 
 // Ready the goroutine arg.
-func goroutineReady(arg interface{}) {
+func goroutineReady(arg interface{}, seq uintptr) {
 	goready(arg.(*g))
 }
 
@@ -185,11 +186,12 @@ func timerproc() {
 			}
 			f := t.f
 			arg := t.arg
+			seq := t.seq
 			unlock(&timers.lock)
 			if raceenabled {
 				raceacquire(unsafe.Pointer(t))
 			}
-			f(arg)
+			f(arg, seq)
 			lock(&timers.lock)
 		}
 		if delta < 0 {
diff --git a/src/pkg/syscall/net_nacl.go b/src/pkg/syscall/net_nacl.go
index 07d52f4525..b5cb530306 100644
--- a/src/pkg/syscall/net_nacl.go
+++ b/src/pkg/syscall/net_nacl.go
@@ -21,8 +21,9 @@ type runtimeTimer struct {
 	i      int
 	when   int64
 	period int64
-	f      func(interface{}) // NOTE: must not be closure
+	f      func(interface{}, uintptr) // NOTE: must not be closure
 	arg    interface{}
+	seq    uintptr
 }
 
 func startTimer(*runtimeTimer)
@@ -49,7 +50,7 @@ func (t *timer) stop() {
 	stopTimer(&t.r)
 }
 
-func timerExpired(i interface{}) {
+func timerExpired(i interface{}, seq uintptr) {
 	t := i.(*timer)
 	go func() {
 		t.q.Lock()
diff --git a/src/pkg/time/internal_test.go b/src/pkg/time/internal_test.go
index b02292ea16..edd523bc80 100644
--- a/src/pkg/time/internal_test.go
+++ b/src/pkg/time/internal_test.go
@@ -12,7 +12,7 @@ func init() {
 var Interrupt = interrupt
 var DaysIn = daysIn
 
-func empty(arg interface{}) {}
+func empty(arg interface{}, seq uintptr) {}
 
 // Test that a runtimeTimer with a duration so large it overflows
 // does not cause other timers to hang.
diff --git a/src/pkg/time/sleep.go b/src/pkg/time/sleep.go
index c7b019feb0..33c349de46 100644
--- a/src/pkg/time/sleep.go
+++ b/src/pkg/time/sleep.go
@@ -17,8 +17,9 @@ type runtimeTimer struct {
 	i      int
 	when   int64
 	period int64
-	f      func(interface{}) // NOTE: must not be closure
+	f      func(interface{}, uintptr) // NOTE: must not be closure
 	arg    interface{}
+	seq    uintptr
 }
 
 // when is a helper function for setting the 'when' field of a runtimeTimer.
@@ -83,7 +84,7 @@ func (t *Timer) Reset(d Duration) bool {
 	return active
 }
 
-func sendTime(c interface{}) {
+func sendTime(c interface{}, seq uintptr) {
 	// Non-blocking send of time on c.
 	// Used in NewTimer, it cannot block anyway (buffer).
 	// Used in NewTicker, dropping sends on the floor is
@@ -117,6 +118,6 @@ func AfterFunc(d Duration, f func()) *Timer {
 	return t
 }
 
-func goFunc(arg interface{}) {
+func goFunc(arg interface{}, seq uintptr) {
 	go arg.(func())()
 }

From 1b47af21995cfbb5f8367b371b37f7c6f8454f5d Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 4 Sep 2014 10:16:57 +0400
Subject: [PATCH 370/423] runtime: fix arm build

TBR=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/140990043
---
 src/pkg/runtime/atomic_arm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/atomic_arm.c b/src/pkg/runtime/atomic_arm.c
index 5369820c09..487b128cbb 100644
--- a/src/pkg/runtime/atomic_arm.c
+++ b/src/pkg/runtime/atomic_arm.c
@@ -58,7 +58,7 @@ runtime·xchgp(void* volatile* addr, void* v)
 void*
 runtime·xchguintptr(void* volatile* addr, void* v)
 {
-	return runtime·xchg((uint32*)addr, (uint32)v);
+	return (void*)runtime·xchg((uint32*)addr, (uint32)v);
 }
 
 #pragma textflag NOSPLIT

From b1d01529975d2d87921c88891f85f3faa65e8cea Mon Sep 17 00:00:00 2001
From: David du Colombier <0intro@gmail.com>
Date: Thu, 4 Sep 2014 08:36:18 +0200
Subject: [PATCH 371/423] runtime: fix Plan 9 build

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/138050043
---
 src/pkg/runtime/os_plan9.c  | 6 ------
 src/pkg/runtime/os_plan9.go | 4 ++++
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/os_plan9.c b/src/pkg/runtime/os_plan9.c
index 98e449251a..fad5b2717f 100644
--- a/src/pkg/runtime/os_plan9.c
+++ b/src/pkg/runtime/os_plan9.c
@@ -317,12 +317,6 @@ runtime·semawakeup(M *mp)
 	runtime·plan9_semrelease(&mp->waitsemacount, 1);
 }
 
-void
-os·sigpipe(void)
-{
-	runtime·throw("too many writes on closed pipe");
-}
-
 static int64
 atolwhex(byte *p)
 {
diff --git a/src/pkg/runtime/os_plan9.go b/src/pkg/runtime/os_plan9.go
index 4a7b16fd64..c45d22551f 100644
--- a/src/pkg/runtime/os_plan9.go
+++ b/src/pkg/runtime/os_plan9.go
@@ -28,3 +28,7 @@ func errstr() string
 const stackSystem = 512
 
 type _Plink uintptr
+
+func os_sigpipe() {
+	gothrow("too many writes on closed pipe")
+}

From d3a2021f71d5a4d31bba88ca634823b14904e239 Mon Sep 17 00:00:00 2001
From: Mikio Hara <mikioh.mikioh@gmail.com>
Date: Thu, 4 Sep 2014 16:23:37 +0900
Subject: [PATCH 372/423] runtime: fix typos

LGTM=dvyukov
R=dvyukov
CC=golang-codereviews
https://golang.org/cl/141000043
---
 src/pkg/runtime/netpoll.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/netpoll.go b/src/pkg/runtime/netpoll.go
index 5c410fc678..55f90f8c1e 100644
--- a/src/pkg/runtime/netpoll.go
+++ b/src/pkg/runtime/netpoll.go
@@ -14,7 +14,7 @@ import "unsafe"
 // func netpollopen(fd uintptr, pd *pollDesc) int32	// to arm edge-triggered notifications
 // and associate fd with pd.
 // An implementation must call the following function to denote that the pd is ready.
-// func netpollready(rg, wg **gp, pd *pollDesc, mode int32)
+// func netpollready(gpp **g, pd *pollDesc, mode int32)
 
 // pollDesc contains 2 binary semaphores, rg and wg, to park reader and writer
 // goroutines respectively. The semaphore can be in the following states:
@@ -99,7 +99,7 @@ func netpollOpen(fd uintptr) (*pollDesc, int) {
 
 func netpollClose(pd *pollDesc) {
 	if !pd.closing {
-		gothrow("runtime_pollClose: close w/o unblock")
+		gothrow("netpollClose: close w/o unblock")
 	}
 	if pd.wg != 0 && pd.wg != pdReady {
 		gothrow("netpollClose: blocked write on closing descriptor")
@@ -388,7 +388,7 @@ func netpolldeadlineimpl(pd *pollDesc, seq uintptr, read, write bool) {
 	var rg *g
 	if read {
 		if pd.rd <= 0 || pd.rt.f == nil {
-			gothrow("netpollDeadlineImpl: inconsistent read deadline")
+			gothrow("netpolldeadlineimpl: inconsistent read deadline")
 		}
 		pd.rd = -1
 		atomicstorep(unsafe.Pointer(&pd.rt.f), nil) // full memory barrier between store to rd and load of rg in netpollunblock

From 29225211e1048f2c2eafd5015637f149a68ecf5c Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 4 Sep 2014 11:31:39 +0400
Subject: [PATCH 373/423] runtime: fix netbsd build

TBR=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/140220043
---
 src/pkg/runtime/defs_netbsd_386.h   | 2 +-
 src/pkg/runtime/defs_netbsd_amd64.h | 2 +-
 src/pkg/runtime/defs_netbsd_arm.h   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pkg/runtime/defs_netbsd_386.h b/src/pkg/runtime/defs_netbsd_386.h
index 53d4b30bb7..fd87804f90 100644
--- a/src/pkg/runtime/defs_netbsd_386.h
+++ b/src/pkg/runtime/defs_netbsd_386.h
@@ -149,7 +149,7 @@ struct KeventT {
 	uint32	flags;
 	uint32	fflags;
 	int64	data;
-	int32	udata;
+	byte	*udata;
 };
 
 
diff --git a/src/pkg/runtime/defs_netbsd_amd64.h b/src/pkg/runtime/defs_netbsd_amd64.h
index 6227575c92..dac94b113b 100644
--- a/src/pkg/runtime/defs_netbsd_amd64.h
+++ b/src/pkg/runtime/defs_netbsd_amd64.h
@@ -154,7 +154,7 @@ struct KeventT {
 	uint32	fflags;
 	byte	Pad_cgo_0[4];
 	int64	data;
-	int64	udata;
+	byte	*udata;
 };
 
 
diff --git a/src/pkg/runtime/defs_netbsd_arm.h b/src/pkg/runtime/defs_netbsd_arm.h
index 115fa439a6..70f34af47b 100644
--- a/src/pkg/runtime/defs_netbsd_arm.h
+++ b/src/pkg/runtime/defs_netbsd_arm.h
@@ -153,7 +153,7 @@ struct KeventT {
 	uint32	flags;
 	uint32	fflags;
 	int64	data;
-	int32	udata;
+	byte	*udata;
 };
 
 

From 97fdfdb52c28cab9251d1a610382d257c39682da Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 4 Sep 2014 11:34:01 +0400
Subject: [PATCH 374/423] runtime: fix solaris netpoll

TBR=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/141030043
---
 src/pkg/runtime/netpoll.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/netpoll.go b/src/pkg/runtime/netpoll.go
index 55f90f8c1e..08da87aa26 100644
--- a/src/pkg/runtime/netpoll.go
+++ b/src/pkg/runtime/netpoll.go
@@ -273,7 +273,7 @@ func netpolllock(pd *pollDesc) {
 }
 
 func netpollunlock(pd *pollDesc) {
-	lock(&pd.lock)
+	unlock(&pd.lock)
 }
 
 // make pd ready, newly runnable goroutines (if any) are returned in rg/wg

From fa9f3058e0c0ff1fc05ea76544f9e9a23fce51d8 Mon Sep 17 00:00:00 2001
From: David Crawshaw <david.crawshaw@zentus.com>
Date: Thu, 4 Sep 2014 13:39:51 -0400
Subject: [PATCH 375/423] androidtest.bash: drop noisy adb sync output

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/138070043
---
 src/androidtest.bash | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/androidtest.bash b/src/androidtest.bash
index 9bf7773b23..43a93a141b 100755
--- a/src/androidtest.bash
+++ b/src/androidtest.bash
@@ -47,7 +47,9 @@ ln -s $GOROOT/src/cmd $FAKE_GOROOT/src/cmd
 ln -s $GOROOT/src/pkg $FAKE_GOROOT/src/pkg
 ln -s $GOROOT/test $FAKE_GOROOT/test
 ln -s $GOROOT/lib $FAKE_GOROOT/lib
-adb sync data
+echo '# Syncing test files to android device'
+time adb sync data &> /dev/null
+echo ''
 rm -rf "$ANDROID_PRODUCT_OUT"
 
 # Run standard build and tests.

From 43345a118b9e68f7779914cc7a965a6b8a1d585e Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 4 Sep 2014 10:43:03 -0700
Subject: [PATCH 376/423] go/parser: initialize file set even in only some
 tests are run

Without this fix, some tests crashed (e.g. go test -run Invalid).

LGTM=adonovan
R=adonovan
CC=golang-codereviews
https://golang.org/cl/133580043
---
 src/pkg/go/parser/error_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/pkg/go/parser/error_test.go b/src/pkg/go/parser/error_test.go
index 8506077cee..48fb53e5b0 100644
--- a/src/pkg/go/parser/error_test.go
+++ b/src/pkg/go/parser/error_test.go
@@ -34,7 +34,7 @@ import (
 
 const testdata = "testdata"
 
-var fsetErrs *token.FileSet
+var fsetErrs = token.NewFileSet()
 
 // getFile assumes that each filename occurs at most once
 func getFile(filename string) (file *token.File) {
@@ -169,7 +169,6 @@ func checkErrors(t *testing.T, filename string, input interface{}) {
 }
 
 func TestErrors(t *testing.T) {
-	fsetErrs = token.NewFileSet()
 	list, err := ioutil.ReadDir(testdata)
 	if err != nil {
 		t.Fatal(err)

From 81ed684a710087eb9745566fa49e57e048088193 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 13:51:12 -0400
Subject: [PATCH 377/423] runtime: reconvert sigqueue.goc from C to Go

The original conversion in CL 132090043 cut up
the function in an attempt to avoid converting most
of the code to Go. This contorts the control flow.

While debugging the onM signal stack bug,
I reconverted sigqueue.goc in its entirety.
This restores the original control flow, which is
much easier to understand.

The current conversion is correct, it's just complex
and will be hard to maintain. The new one is as
readable as the original code.

I uploaded sigqueue.goc as the initial copy of
sigqueue.go in the CL, so if you view the diffs
of sigqueue.go comparing against patch set 2 [sic]
it will show the actual starting point.

For example:
https://golang.org/cl/136160043/diff2/20001:60001/src/pkg/runtime/sigqueue.go

LGTM=dvyukov, iant
R=golang-codereviews, dvyukov, iant
CC=golang-codereviews, khr, r
https://golang.org/cl/136160043
---
 src/cmd/api/goapi.go           |   1 +
 src/pkg/runtime/os_darwin.h    |  15 +--
 src/pkg/runtime/os_dragonfly.h |  11 +-
 src/pkg/runtime/os_freebsd.h   |  12 +--
 src/pkg/runtime/os_linux.h     |  13 +--
 src/pkg/runtime/os_netbsd.h    |  21 ++--
 src/pkg/runtime/os_openbsd.h   |  15 +--
 src/pkg/runtime/os_plan9.h     |  18 ++--
 src/pkg/runtime/os_solaris.h   |  21 ++--
 src/pkg/runtime/os_windows.h   |   4 +-
 src/pkg/runtime/proc.go        |   1 +
 src/pkg/runtime/signal.c       |  25 +++++
 src/pkg/runtime/sigqueue.c     | 184 ---------------------------------
 src/pkg/runtime/sigqueue.go    | 181 ++++++++++++++++++++++++++++----
 14 files changed, 257 insertions(+), 265 deletions(-)
 create mode 100644 src/pkg/runtime/signal.c
 delete mode 100644 src/pkg/runtime/sigqueue.c

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 2d6dde2665..6b21a24e36 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -419,6 +419,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" _Gdead = 6;" +
 			" _Genqueue = 7;" +
 			" _Gcopystack = 8;" +
+			" _NSIG = 32;" +
 			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
diff --git a/src/pkg/runtime/os_darwin.h b/src/pkg/runtime/os_darwin.h
index af9052e9c2..e8bb45dafc 100644
--- a/src/pkg/runtime/os_darwin.h
+++ b/src/pkg/runtime/os_darwin.h
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 4
-
 typedef byte* kevent_udata;
 
 int32	runtime·bsdthread_create(void*, M*, G*, void(*)(void));
@@ -35,8 +33,11 @@ void	runtime·sigpanic(void);
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
 
 
-#define	NSIG 32
-#define	SI_USER	0  /* empirically true, but not what headers say */
-#define	SIG_BLOCK 1
-#define	SIG_UNBLOCK 2
-#define	SIG_SETMASK 3
+enum {
+	NSIG = 32,
+	SI_USER = 0, /* empirically true, but not what headers say */
+	SIG_BLOCK = 1,
+	SIG_UNBLOCK = 2,
+	SIG_SETMASK = 3,
+	SS_DISABLE = 4,
+};
diff --git a/src/pkg/runtime/os_dragonfly.h b/src/pkg/runtime/os_dragonfly.h
index 4fb71478bf..389736a323 100644
--- a/src/pkg/runtime/os_dragonfly.h
+++ b/src/pkg/runtime/os_dragonfly.h
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 4
 
 typedef byte* kevent_udata;
 
@@ -16,11 +15,13 @@ void	runtime·unblocksignals(void);
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
 
+enum {
+	NSIG = 33,
+	SI_USER = 0x10001,
+	SS_DISABLE = 4,
+	RLIMIT_AS = 10,
+};
 
-#define	NSIG 33
-#define	SI_USER	0x10001
-
-#define RLIMIT_AS 10
 typedef struct Rlimit Rlimit;
 struct Rlimit {
 	int64	rlim_cur;
diff --git a/src/pkg/runtime/os_freebsd.h b/src/pkg/runtime/os_freebsd.h
index ec0be3161f..b86bb393c2 100644
--- a/src/pkg/runtime/os_freebsd.h
+++ b/src/pkg/runtime/os_freebsd.h
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 4
-
 typedef byte* kevent_udata;
 
 int32	runtime·thr_new(ThrParam*, int32);
@@ -16,11 +14,13 @@ void	runtime·unblocksignals(void);
 void	runtime·setitimer(int32, Itimerval*, Itimerval*);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
 
+enum {
+	SS_DISABLE = 4,
+	NSIG = 33,
+	SI_USER = 0x10001,
+	RLIMIT_AS = 10,
+};
 
-#define	NSIG 33
-#define	SI_USER	0x10001
-
-#define RLIMIT_AS 10
 typedef struct Rlimit Rlimit;
 struct Rlimit {
 	int64	rlim_cur;
diff --git a/src/pkg/runtime/os_linux.h b/src/pkg/runtime/os_linux.h
index c475d32405..75606d6152 100644
--- a/src/pkg/runtime/os_linux.h
+++ b/src/pkg/runtime/os_linux.h
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 2
 
 // Linux-specific system calls
 int32	runtime·futex(uint32*, int32, uint32, Timespec*, uint32*, uint32);
@@ -15,9 +14,13 @@ void	runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
 void	runtime·sigpanic(void);
 void runtime·setitimer(int32, Itimerval*, Itimerval*);
 
-
-#define	NSIG	65
-#define	SI_USER 0
+enum {
+	SS_DISABLE = 2,
+	NSIG = 65,
+	SI_USER = 0,
+	SIG_SETMASK = 2,
+	RLIMIT_AS = 9,
+};
 
 // It's hard to tease out exactly how big a Sigset is, but
 // rt_sigprocmask crashes if we get it wrong, so if binaries
@@ -29,9 +32,7 @@ struct Sigset
 };
 void	runtime·rtsigprocmask(int32, Sigset*, Sigset*, int32);
 void	runtime·unblocksignals(void);
-#define SIG_SETMASK 2
 
-#define RLIMIT_AS 9
 typedef struct Rlimit Rlimit;
 struct Rlimit {
 	uintptr	rlim_cur;
diff --git a/src/pkg/runtime/os_netbsd.h b/src/pkg/runtime/os_netbsd.h
index a7995df92a..f95db325f0 100644
--- a/src/pkg/runtime/os_netbsd.h
+++ b/src/pkg/runtime/os_netbsd.h
@@ -2,11 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 4
-
-#define SIG_BLOCK 1
-#define SIG_UNBLOCK 2
-#define SIG_SETMASK 3
 
 typedef uintptr kevent_udata;
 
@@ -22,9 +17,15 @@ void	runtime·unblocksignals(void);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
 extern void runtime·lwp_tramp(void);
 
-#define	NSIG 33
-#define	SI_USER	0
+enum {
+	SS_DISABLE = 4,
+	SIG_BLOCK = 1,
+	SIG_UNBLOCK = 2,
+	SIG_SETMASK = 3,
+	NSIG = 33,
+	SI_USER = 0,
 
-// From NetBSD's <sys/ucontext.h>
-#define _UC_SIGMASK	0x01
-#define _UC_CPU		0x04
+	// From NetBSD's <sys/ucontext.h>
+	_UC_SIGMASK = 0x01,
+	_UC_CPU = 0x04,
+};
diff --git a/src/pkg/runtime/os_openbsd.h b/src/pkg/runtime/os_openbsd.h
index 955432ebd6..6ad98109e9 100644
--- a/src/pkg/runtime/os_openbsd.h
+++ b/src/pkg/runtime/os_openbsd.h
@@ -2,11 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 4
-
-#define SIG_BLOCK 1
-#define SIG_UNBLOCK 2
-#define SIG_SETMASK 3
 
 typedef byte* kevent_udata;
 
@@ -21,5 +16,11 @@ Sigset	runtime·sigprocmask(int32, Sigset);
 void	runtime·unblocksignals(void);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
 
-#define	NSIG 33
-#define	SI_USER	0
+enum {
+	SS_DISABLE = 4,
+	SIG_BLOCK = 1,
+	SIG_UNBLOCK = 2,
+	SIG_SETMASK = 3,
+	NSIG = 33,
+	SI_USER = 0,
+};
diff --git a/src/pkg/runtime/os_plan9.h b/src/pkg/runtime/os_plan9.h
index ea853dde85..57a2cafa72 100644
--- a/src/pkg/runtime/os_plan9.h
+++ b/src/pkg/runtime/os_plan9.h
@@ -79,12 +79,14 @@ struct Tos {
 	/* top of stack is here */
 };
 
-#define	NSIG	14	/* number of signals in runtime·SigTab array */
-#define	ERRMAX	128	/* max length of note string */
+enum {
+	NSIG = 14, /* number of signals in runtime·SigTab array */
+	ERRMAX = 128, /* max length of note string */
 
-/* Notes in runtime·sigtab that are handled by runtime·sigpanic. */
-#define	SIGRFAULT	2
-#define	SIGWFAULT	3
-#define	SIGINTDIV	4
-#define	SIGFLOAT	5
-#define	SIGTRAP		6
+	/* Notes in runtime·sigtab that are handled by runtime·sigpanic. */
+	SIGRFAULT = 2,
+	SIGWFAULT = 3,
+	SIGINTDIV = 4,
+	SIGFLOAT = 5,
+	SIGTRAP = 6,
+};
diff --git a/src/pkg/runtime/os_solaris.h b/src/pkg/runtime/os_solaris.h
index ba08771cb7..3d9e1a2406 100644
--- a/src/pkg/runtime/os_solaris.h
+++ b/src/pkg/runtime/os_solaris.h
@@ -2,11 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#define SS_DISABLE 2
-
-#define SIG_BLOCK 1
-#define SIG_UNBLOCK 2
-#define SIG_SETMASK 3
 
 typedef uintptr kevent_udata;
 
@@ -21,18 +16,24 @@ void	runtime·sigprocmask(int32, Sigset*, Sigset*);
 void	runtime·unblocksignals(void);
 int32	runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
 
-#define	NSIG 73 /* number of signals in runtime·SigTab array */
-#define	SI_USER	0
 
 void	runtime·raisesigpipe(void);
 void	runtime·setsig(int32, void(*)(int32, Siginfo*, void*, G*), bool);
 void	runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp);
 void	runtime·sigpanic(void);
 
-#define _UC_SIGMASK	0x01
-#define _UC_CPU		0x04
+enum {
+	SS_DISABLE = 2,
+	SIG_BLOCK = 1,
+	SIG_UNBLOCK = 2,
+	SIG_SETMASK = 3,
+	NSIG = 73, /* number of signals in runtime·SigTab array */
+	SI_USER = 0,
+	_UC_SIGMASK = 0x01,
+	_UC_CPU = 0x04,
+	RLIMIT_AS = 10,
+};
 
-#define RLIMIT_AS 10
 typedef struct Rlimit Rlimit;
 struct Rlimit {
 	int64   rlim_cur;
diff --git a/src/pkg/runtime/os_windows.h b/src/pkg/runtime/os_windows.h
index e1e3cb0e23..d5d168d77b 100644
--- a/src/pkg/runtime/os_windows.h
+++ b/src/pkg/runtime/os_windows.h
@@ -37,4 +37,6 @@ void runtime·install_exception_handler(void);
 void runtime·remove_exception_handler(void);
 
 // TODO(brainman): should not need those
-#define	NSIG	65
+enum {
+	NSIG = 65,
+};
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index f060640a26..3e1d0694a0 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -113,6 +113,7 @@ func releaseSudog(s *sudog) {
 
 // funcPC returns the entry PC of the function f.
 // It assumes that f is a func value. Otherwise the behavior is undefined.
+//go:nosplit
 func funcPC(f interface{}) uintptr {
 	return **(**uintptr)(add(unsafe.Pointer(&f), ptrSize))
 }
diff --git a/src/pkg/runtime/signal.c b/src/pkg/runtime/signal.c
new file mode 100644
index 0000000000..0674bfb22d
--- /dev/null
+++ b/src/pkg/runtime/signal.c
@@ -0,0 +1,25 @@
+// 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 "runtime.h"
+
+void
+runtime·sigenable_m(void)
+{
+	uint32 s;
+	
+	s = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	runtime·sigenable(s);
+}
+
+void
+runtime·sigdisable_m(void)
+{
+	uint32 s;
+	
+	s = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	runtime·sigdisable(s);
+}
diff --git a/src/pkg/runtime/sigqueue.c b/src/pkg/runtime/sigqueue.c
deleted file mode 100644
index e5617bde7d..0000000000
--- a/src/pkg/runtime/sigqueue.c
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements runtime support for signal handling.
-//
-// Most synchronization primitives are not available from
-// the signal handler (it cannot block, allocate memory, or use locks)
-// so the handler communicates with a processing goroutine
-// via struct sig, below.
-//
-// sigsend() is called by the signal handler to queue a new signal.
-// signal_recv() is called by the Go program to receive a newly queued signal.
-// Synchronization between sigsend() and signal_recv() is based on the sig.state
-// variable.  It can be in 3 states: 0, HASWAITER and HASSIGNAL.
-// HASWAITER means that signal_recv() is blocked on sig.Note and there are no
-// new pending signals.
-// HASSIGNAL means that sig.mask *may* contain new pending signals,
-// signal_recv() can't be blocked in this state.
-// 0 means that there are no new pending signals and signal_recv() is not blocked.
-// Transitions between states are done atomically with CAS.
-// When signal_recv() is unblocked, it resets sig.Note and rechecks sig.mask.
-// If several sigsend()'s and signal_recv() execute concurrently, it can lead to
-// unnecessary rechecks of sig.mask, but must not lead to missed signals
-// nor deadlocks.
-
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-#include "cgocall.h"
-#include "../../cmd/ld/textflag.h"
-
-typedef struct Sig Sig;
-struct Sig {
-	uint32 mask[(NSIG+31)/32];
-	uint32 wanted[(NSIG+31)/32];
-	uint32 recv[(NSIG+31)/32];
-	uint32 state;
-	bool inuse;
-	bool afterwait;
-};
-
-#pragma dataflag NOPTR
-static Sig sig;
-
-Note runtime·signote;
-
-enum {
-	HASWAITER = 1,
-	HASSIGNAL = 2,
-};
-
-// Called from sighandler to send a signal back out of the signal handling thread.
-bool
-runtime·sigsend(int32 s)
-{
-	uint32 bit, mask, old, new;
-
-	if(!sig.inuse || s < 0 || s >= 32*nelem(sig.wanted) || !(sig.wanted[s/32]&(1U<<(s&31))))
-		return false;
-	bit = 1 << (s&31);
-	for(;;) {
-		mask = sig.mask[s/32];
-		if(mask & bit)
-			break;		// signal already in queue
-		if(runtime·cas(&sig.mask[s/32], mask, mask|bit)) {
-			// Added to queue.
-			// Only send a wakeup if the receiver needs a kick.
-			for(;;) {
-				old = runtime·atomicload(&sig.state);
-				if(old == HASSIGNAL)
-					break;
-				if(old == HASWAITER)
-					new = 0;
-				else  // if(old == 0)
-					new = HASSIGNAL;
-				if(runtime·cas(&sig.state, old, new)) {
-					if (old == HASWAITER)
-						runtime·notewakeup(&runtime·signote);
-					break;
-				}
-			}
-			break;
-		}
-	}
-	return true;
-}
-
-// Called to receive the next queued signal.
-// Must only be called from a single goroutine at a time.
-void
-runtime·signal_recv_m(void)
-{
-	uint32 i, old, new;
-
-	if(sig.afterwait) {
-		sig.afterwait = false;
-		goto update;
-	}
-	for(;;) {
-		// Serve from local copy if there are bits left.
-		for(i=0; i<NSIG; i++) {
-			if(sig.recv[i/32]&(1U<<(i&31))) {
-				sig.recv[i/32] ^= 1U<<(i&31);
-				g->m->scalararg[0] = true;
-				g->m->scalararg[1] = i;
-				return;
-			}
-		}
-
-		// Check and update sig.state.
-		for(;;) {
-			old = runtime·atomicload(&sig.state);
-			if(old == HASWAITER)
-				runtime·throw("inconsistent state in signal_recv");
-			if(old == HASSIGNAL)
-				new = 0;
-			else  // if(old == 0)
-				new = HASWAITER;
-			if(runtime·cas(&sig.state, old, new)) {
-				if (new == HASWAITER) {
-					sig.afterwait = true;
-					g->m->scalararg[0] = false;
-					g->m->scalararg[1] = 0;
-					return;
-				}
-				break;
-			}
-		}
-
-		// Get a new local copy.
-	update:
-		for(i=0; i<nelem(sig.mask); i++) {
-			for(;;) {
-				old = sig.mask[i];
-				if(runtime·cas(&sig.mask[i], old, 0))
-					break;
-			}
-			sig.recv[i] = old;
-		}
-	}
-}
-
-// Must only be called from a single goroutine at a time.
-void
-runtime·signal_enable_m(void)
-{
-	uint32 s;
-
-	if(!sig.inuse) {
-		// The first call to signal_enable is for us
-		// to use for initialization.  It does not pass
-		// signal information in m.
-		sig.inuse = true;	// enable reception of signals; cannot disable
-		runtime·noteclear(&runtime·signote);
-		return;
-	}
-	s = g->m->scalararg[0];
-	if(s >= nelem(sig.wanted)*32)
-		return;
-	sig.wanted[s/32] |= 1U<<(s&31);
-	runtime·sigenable(s);
-}
-
-// Must only be called from a single goroutine at a time.
-void
-runtime·signal_disable_m(void)
-{
-	uint32 s;
-
-	s = g->m->scalararg[0];
-	if(s >= nelem(sig.wanted)*32)
-		return;
-	sig.wanted[s/32] &= ~(1U<<(s&31));
-	runtime·sigdisable(s);
-}
-
-// This runs on a foreign stack, without an m or a g.  No stack split.
-#pragma textflag NOSPLIT
-void
-runtime·badsignal(uintptr sig)
-{
-	runtime·cgocallback((void (*)(void))runtime·sigsend, &sig, sizeof(sig));
-}
diff --git a/src/pkg/runtime/sigqueue.go b/src/pkg/runtime/sigqueue.go
index 4643559705..63edb664cf 100644
--- a/src/pkg/runtime/sigqueue.go
+++ b/src/pkg/runtime/sigqueue.go
@@ -3,38 +3,177 @@
 // license that can be found in the LICENSE file.
 
 // This file implements runtime support for signal handling.
+//
+// Most synchronization primitives are not available from
+// the signal handler (it cannot block, allocate memory, or use locks)
+// so the handler communicates with a processing goroutine
+// via struct sig, below.
+//
+// sigsend() is called by the signal handler to queue a new signal.
+// signal_recv() is called by the Go program to receive a newly queued signal.
+// Synchronization between sigsend() and signal_recv() is based on the sig.state
+// variable.  It can be in 3 states: 0, HASWAITER and HASSIGNAL.
+// HASWAITER means that signal_recv() is blocked on sig.Note and there are no
+// new pending signals.
+// HASSIGNAL means that sig.mask *may* contain new pending signals,
+// signal_recv() can't be blocked in this state.
+// 0 means that there are no new pending signals and signal_recv() is not blocked.
+// Transitions between states are done atomically with CAS.
+// When signal_recv() is unblocked, it resets sig.Note and rechecks sig.mask.
+// If several sigsend()'s and signal_recv() execute concurrently, it can lead to
+// unnecessary rechecks of sig.mask, but must not lead to missed signals
+// nor deadlocks.
 
 package runtime
 
-func signal_recv() (m uint32) {
+import "unsafe"
+
+var sig struct {
+	note   note
+	mask   [(_NSIG + 31) / 32]uint32
+	wanted [(_NSIG + 31) / 32]uint32
+	recv   [(_NSIG + 31) / 32]uint32
+	state  uint32
+	inuse  bool
+}
+
+const (
+	_HASWAITER = 1
+	_HASSIGNAL = 2
+)
+
+// Called from sighandler to send a signal back out of the signal handling thread.
+func sigsend(s int32) bool {
+	bit := uint32(1) << uint(s&31)
+	if !sig.inuse || s < 0 || int(s) >= 32*len(sig.wanted) || sig.wanted[s/32]&bit == 0 {
+		return false
+	}
+
 	for {
-		mp := acquirem()
-		onM(signal_recv_m)
-		ok := mp.scalararg[0] != 0
-		m = uint32(mp.scalararg[1])
-		releasem(mp)
-		if ok {
-			return
+		mask := sig.mask[s/32]
+		if mask&bit != 0 {
+			break // signal already in queue
+		}
+		if cas(&sig.mask[s/32], mask, mask|bit) {
+			// Added to queue.
+			// Only send a wakeup if the receiver needs a kick.
+			for {
+				old := atomicload(&sig.state)
+				if old == _HASSIGNAL {
+					break
+				}
+
+				var new uint32
+				if old == _HASWAITER {
+					new = 0
+				} else { // old == 0
+					new = _HASSIGNAL
+				}
+				if cas(&sig.state, old, new) {
+					if old == _HASWAITER {
+						notewakeup(&sig.note)
+					}
+					break
+				}
+			}
+			break
+		}
+	}
+	return true
+}
+
+// Called to receive the next queued signal.
+// Must only be called from a single goroutine at a time.
+func signal_recv() uint32 {
+	for {
+		// Serve from local copy if there are bits left.
+		for i := uint32(0); i < _NSIG; i++ {
+			if sig.recv[i/32]&(1<<(i&31)) != 0 {
+				sig.recv[i/32] &^= 1 << (i & 31)
+				return i
+			}
+		}
+
+		// Check and update sig.state.
+		for {
+			old := atomicload(&sig.state)
+			if old == _HASWAITER {
+				gothrow("inconsistent state in signal_recv")
+			}
+
+			var new uint32
+			if old == _HASSIGNAL {
+				new = 0
+			} else { // old == 0
+				new = _HASWAITER
+			}
+			if cas(&sig.state, old, new) {
+				if new == _HASWAITER {
+					notetsleepg(&sig.note, -1)
+					noteclear(&sig.note)
+				}
+				break
+			}
+		}
+
+		// Get a new local copy.
+		for i := range sig.mask {
+			var m uint32
+			for {
+				m = sig.mask[i]
+				if cas(&sig.mask[i], m, 0) {
+					break
+				}
+			}
+			sig.recv[i] = m
 		}
-		notetsleepg(&signote, -1)
-		noteclear(&signote)
 	}
 }
 
+// Must only be called from a single goroutine at a time.
 func signal_enable(s uint32) {
-	mp := acquirem()
-	mp.scalararg[0] = uintptr(s)
-	onM(signal_enable_m)
-	releasem(mp)
+	if !sig.inuse {
+		// The first call to signal_enable is for us
+		// to use for initialization.  It does not pass
+		// signal information in m.
+		sig.inuse = true // enable reception of signals; cannot disable
+		noteclear(&sig.note)
+		return
+	}
+
+	if int(s) >= len(sig.wanted)*32 {
+		return
+	}
+	sig.wanted[s/32] |= 1 << (s & 31)
+	sigenable_go(s)
 }
 
+// Must only be called from a single goroutine at a time.
 func signal_disable(s uint32) {
-	mp := acquirem()
-	mp.scalararg[0] = uintptr(s)
-	onM(signal_disable_m)
-	releasem(mp)
+	if int(s) >= len(sig.wanted)*32 {
+		return
+	}
+	sig.wanted[s/32] &^= 1 << (s & 31)
+	sigdisable_go(s)
 }
 
-func signal_recv_m()
-func signal_enable_m()
-func signal_disable_m()
+// This runs on a foreign stack, without an m or a g.  No stack split.
+//go:nosplit
+func badsignal(sig uintptr) {
+	cgocallback(unsafe.Pointer(funcPC(sigsend)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+}
+
+func sigenable_m()
+func sigdisable_m()
+
+func sigenable_go(s uint32) {
+	g := getg()
+	g.m.scalararg[0] = uintptr(s)
+	onM(sigenable_m)
+}
+
+func sigdisable_go(s uint32) {
+	g := getg()
+	g.m.scalararg[0] = uintptr(s)
+	onM(sigdisable_m)
+}

From 503bcd464e8974b3295177c1a0ed5a4ba5bc5a01 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 14:19:50 -0400
Subject: [PATCH 378/423] runtime: use C for readgstatus, goroutine status
 values

When this code was written, there was no way for Go to
reuse the C function and enum values. Now there is.

LGTM=bradfitz
R=rlh, bradfitz
CC=dvyukov, golang-codereviews, iant, khr, r
https://golang.org/cl/139150045
---
 src/pkg/runtime/proc.c  |  1 +
 src/pkg/runtime/proc.go | 30 ++----------------------------
 2 files changed, 3 insertions(+), 28 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 3e7b07c2c5..d75c210c5a 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -442,6 +442,7 @@ isscanstatus(uint32 status)
 
 // All reads and writes of g's status go through readgstatus, casgstatus
 // castogscanstatus, casfromgscanstatus.
+#pragma textflag NOSPLIT
 uint32
 runtime·readgstatus(G *gp)
 {
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 3e1d0694a0..4789a51b66 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -6,27 +6,6 @@ package runtime
 
 import "unsafe"
 
-// This is not mechanically generated
-// so be very careful and refer to runtime.h
-// for the definitive enum.
-const (
-	gStatusidle = iota
-	gStatusRunnable
-	gStatusRunning
-	gStatusSyscall
-	gStatusWaiting
-	gStatusMoribundUnused
-	gStatusDead
-	gStatusEnqueue
-	gStatusCopystack
-	gStatusScan         = 0x1000
-	gStatusScanRunnable = gStatusScan + gStatusRunnable
-	gStatusScanRunning  = gStatusScan + gStatusRunning
-	gStatusScanSyscall  = gStatusScan + gStatusSyscall
-	gStatusScanWaiting  = gStatusScan + gStatusWaiting
-	gStatusScanEnqueue  = gStatusScan + gStatusEnqueue
-)
-
 var parkunlock_c byte
 
 // start forcegc helper goroutine
@@ -58,18 +37,13 @@ func Gosched() {
 	mcall(gosched_m)
 }
 
-func readgStatus(gp *g) uint32 {
-	//return atomic.LoadUint32(&gp.atomicstatus) // TODO: add bootstrap code to provide.
-	return gp.atomicstatus
-}
-
 // Puts the current goroutine into a waiting state and calls unlockf.
 // If unlockf returns false, the goroutine is resumed.
 func gopark(unlockf unsafe.Pointer, lock unsafe.Pointer, reason string) {
 	mp := acquirem()
 	gp := mp.curg
-	status := readgStatus(gp)
-	if status != gStatusRunning && status != gStatusScanRunning {
+	status := readgstatus(gp)
+	if status != _Grunning && status != _Gscanrunning {
 		gothrow("gopark: bad g status")
 	}
 	mp.waitlock = lock

From c08d8834ddf8d69daba989a4ee0b5e144fce973d Mon Sep 17 00:00:00 2001
From: Dmitriy Vyukov <dvyukov@google.com>
Date: Thu, 4 Sep 2014 14:40:40 -0400
Subject: [PATCH 379/423] runtime: convert cgocall to Go

LGTM=khr, rsc
R=golang-codereviews, khr, rsc
CC=golang-codereviews
https://golang.org/cl/131670043
---
 src/pkg/runtime/{cgocall.c => cgocall.go} | 301 +++++++++-------------
 src/pkg/runtime/proc.c                    |  18 ++
 src/pkg/runtime/stubs.go                  |   9 +
 3 files changed, 148 insertions(+), 180 deletions(-)
 rename src/pkg/runtime/{cgocall.c => cgocall.go} (53%)

diff --git a/src/pkg/runtime/cgocall.c b/src/pkg/runtime/cgocall.go
similarity index 53%
rename from src/pkg/runtime/cgocall.c
rename to src/pkg/runtime/cgocall.go
index 0fd5fbd00c..d44b832dfa 100644
--- a/src/pkg/runtime/cgocall.c
+++ b/src/pkg/runtime/cgocall.go
@@ -2,13 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "stack.h"
-#include "cgocall.h"
-#include "race.h"
-#include "../../cmd/ld/textflag.h"
-
 // Cgo call and callback support.
 //
 // To call into the C function f from Go, the cgo-generated code calls
@@ -17,7 +10,7 @@
 //
 // runtime.cgocall (below) locks g to m, calls entersyscall
 // so as not to block other goroutines or the garbage collector,
-// and then calls runtime.asmcgocall(_cgo_Cfunc_f, frame). 
+// and then calls runtime.asmcgocall(_cgo_Cfunc_f, frame).
 //
 // runtime.asmcgocall (in asm_$GOARCH.s) switches to the m->g0 stack
 // (assumed to be an operating system-allocated stack, so safe to run
@@ -84,56 +77,42 @@
 // _cgoexp_GoF immediately returns to crosscall2, which restores the
 // callee-save registers for gcc and returns to GoF, which returns to f.
 
-void *_cgo_init;	/* filled in by dynamic linker when Cgo is available */
-static int64 cgosync;  /* represents possible synchronization in C code */
+package runtime
 
-static void unwindm(void);
+import "unsafe"
 
 // Call from Go to C.
-
-static void endcgo(void);
-static FuncVal endcgoV = { endcgo };
-
-void
-runtime·cgocall(void (*fn)(void*), void *arg)
-{
-	runtime·cgocall_errno(fn, arg);
+func cgocall(fn, arg unsafe.Pointer) {
+	cgocall_errno(fn, arg)
 }
 
-int32
-runtime·cgocall_errno(void (*fn)(void*), void *arg)
-{
-	Defer d;
-	int32 errno;
+func cgocall_errno(fn, arg unsafe.Pointer) int32 {
+	if !iscgo && GOOS != "solaris" && GOOS != "windows" {
+		gothrow("cgocall unavailable")
+	}
 
-	if(!runtime·iscgo && !Solaris && !Windows)
-		runtime·throw("cgocall unavailable");
+	if fn == nil {
+		gothrow("cgocall nil")
+	}
 
-	if(fn == 0)
-		runtime·throw("cgocall nil");
-
-	if(raceenabled)
-		runtime·racereleasemerge(&cgosync);
+	if raceenabled {
+		racereleasemerge(unsafe.Pointer(&racecgosync))
+	}
 
 	// Create an extra M for callbacks on threads not created by Go on first cgo call.
-	if(runtime·needextram && runtime·cas(&runtime·needextram, 1, 0))
-		runtime·newextram();
-
-	g->m->ncgocall++;
+	if needextram == 1 && cas(&needextram, 1, 0) {
+		newextram()
+	}
 
 	/*
-	 * Mutex g to m to ensure we stay on the same stack if we do a
+	 * Lock g to m to ensure we stay on the same stack if we do a
 	 * cgo callback. Add entry to defer stack in case of panic.
 	 */
-	runtime·lockOSThread();
-	d.fn = &endcgoV;
-	d.siz = 0;
-	d.link = g->defer;
-	d.argp = NoArgs;
-	d.special = true;
-	g->defer = &d;
-	
-	g->m->ncgo++;
+	lockOSThread()
+	mp := getg().m
+	mp.ncgocall++
+	mp.ncgo++
+	defer endcgo(mp)
 
 	/*
 	 * Announce we are entering a system call
@@ -146,182 +125,144 @@ runtime·cgocall_errno(void (*fn)(void*), void *arg)
 	 * so it is safe to call while "in a system call", outside
 	 * the $GOMAXPROCS accounting.
 	 */
-	runtime·entersyscall();
-	errno = runtime·asmcgocall_errno(fn, arg);
-	runtime·exitsyscall();
+	entersyscall()
+	errno := asmcgocall_errno(fn, arg)
+	exitsyscall()
 
-	if(g->defer != &d || d.fn != &endcgoV)
-		runtime·throw("runtime: bad defer entry in cgocallback");
-	g->defer = d.link;
-	endcgo();
-	
-	return errno;
+	return errno
 }
 
-static void
-endcgo(void)
-{
-	runtime·unlockOSThread();
-	g->m->ncgo--;
-	if(g->m->ncgo == 0) {
+func endcgo(mp *m) {
+	mp.ncgo--
+	if mp.ncgo == 0 {
 		// We are going back to Go and are not in a recursive
 		// call.  Let the GC collect any memory allocated via
 		// _cgo_allocate that is no longer referenced.
-		g->m->cgomal = nil;
+		mp.cgomal = nil
 	}
 
-	if(raceenabled)
-		runtime·raceacquire(&cgosync);
+	if raceenabled {
+		raceacquire(unsafe.Pointer(&racecgosync))
+	}
+
+	unlockOSThread() // invalidates mp
 }
 
 // Helper functions for cgo code.
 
-void (*_cgo_malloc)(void*);
-void (*_cgo_free)(void*);
+// Filled by schedinit from corresponding C variables,
+// which are in turn filled in by dynamic linker when Cgo is available.
+var cgoMalloc, cgoFree unsafe.Pointer
 
-void*
-runtime·cmalloc(uintptr n)
-{
-	struct {
-		uint64 n;
-		void *ret;
-	} a;
-
-	a.n = n;
-	a.ret = nil;
-	runtime·cgocall(_cgo_malloc, &a);
-	if(a.ret == nil)
-		runtime·throw("runtime: C malloc failed");
-	return a.ret;
+func cmalloc(n uintptr) unsafe.Pointer {
+	var args struct {
+		n   uint64
+		ret unsafe.Pointer
+	}
+	args.n = uint64(n)
+	cgocall(cgoMalloc, unsafe.Pointer(&args))
+	if args.ret == nil {
+		gothrow("C malloc failed")
+	}
+	return args.ret
 }
 
-void
-runtime·cfree(void *p)
-{
-	runtime·cgocall(_cgo_free, p);
+func cfree(p unsafe.Pointer) {
+	cgocall(cgoFree, p)
 }
 
 // Call from C back to Go.
-
-static FuncVal unwindmf = {unwindm};
-
-typedef struct CallbackArgs CallbackArgs;
-struct CallbackArgs
-{
-	FuncVal *fn;
-	void *arg;
-	uintptr argsize;
-};
-
-// Location of callback arguments depends on stack frame layout
-// and size of stack frame of cgocallback_gofunc.
-
-// On arm, stack frame is two words and there's a saved LR between
-// SP and the stack frame and between the stack frame and the arguments.
-#ifdef GOARCH_arm
-#define CBARGS (CallbackArgs*)((byte*)g->m->g0->sched.sp+4*sizeof(void*))
-#endif
-
-// On amd64, stack frame is one word, plus caller PC.
-#ifdef GOARCH_amd64
-#define CBARGS (CallbackArgs*)((byte*)g->m->g0->sched.sp+2*sizeof(void*))
-#endif
-
-// Unimplemented on amd64p32
-#ifdef GOARCH_amd64p32
-#define CBARGS (CallbackArgs*)(nil)
-#endif
-
-// On 386, stack frame is three words, plus caller PC.
-#ifdef GOARCH_386
-#define CBARGS (CallbackArgs*)((byte*)g->m->g0->sched.sp+4*sizeof(void*))
-#endif
-
-void runtime·cgocallbackg1(void);
-
-#pragma textflag NOSPLIT
-void
-runtime·cgocallbackg(void)
-{
-	if(g != g->m->curg) {
-		runtime·prints("runtime: bad g in cgocallback");
-		runtime·exit(2);
+//go:nosplit
+func cgocallbackg() {
+	if gp := getg(); gp != gp.m.curg {
+		println("runtime: bad g in cgocallback")
+		exit(2)
 	}
 
-	runtime·exitsyscall();	// coming out of cgo call
-	runtime·cgocallbackg1();
-	runtime·entersyscall();	// going back to cgo call
+	exitsyscall() // coming out of cgo call
+	cgocallbackg1()
+	entersyscall() // going back to cgo call
 }
 
-void
-runtime·cgocallbackg1(void)
-{
-	CallbackArgs *cb;
-	Defer d;
-
-	if(g->m->needextram) {
-		g->m->needextram = 0;
-		runtime·newextram();
+func cgocallbackg1() {
+	gp := getg()
+	if gp.m.needextram {
+		gp.m.needextram = false
+		newextram()
 	}
 
 	// Add entry to defer stack in case of panic.
-	d.fn = &unwindmf;
-	d.siz = 0;
-	d.link = g->defer;
-	d.argp = NoArgs;
-	d.special = true;
-	g->defer = &d;
+	restore := true
+	defer unwindm(&restore)
 
-	if(raceenabled)
-		runtime·raceacquire(&cgosync);
+	if raceenabled {
+		raceacquire(unsafe.Pointer(&racecgosync))
+	}
+
+	type args struct {
+		fn      *funcval
+		arg     unsafe.Pointer
+		argsize uintptr
+	}
+	var cb *args
+
+	// Location of callback arguments depends on stack frame layout
+	// and size of stack frame of cgocallback_gofunc.
+	sp := gp.m.g0.sched.sp
+	switch GOARCH {
+	default:
+		gothrow("cgocallbackg is unimplemented on arch")
+	case "arm":
+		// On arm, stack frame is two words and there's a saved LR between
+		// SP and the stack frame and between the stack frame and the arguments.
+		cb = (*args)(unsafe.Pointer(sp + 4*ptrSize))
+	case "amd64":
+		// On amd64, stack frame is one word, plus caller PC.
+		cb = (*args)(unsafe.Pointer(sp + 2*ptrSize))
+	case "386":
+		// On 386, stack frame is three words, plus caller PC.
+		cb = (*args)(unsafe.Pointer(sp + 4*ptrSize))
+	}
 
 	// Invoke callback.
-	cb = CBARGS;
-	runtime·newstackcall(cb->fn, cb->arg, cb->argsize);
+	newstackcall(cb.fn, cb.arg, uint32(cb.argsize))
 
-	if(raceenabled)
-		runtime·racereleasemerge(&cgosync);
+	if raceenabled {
+		racereleasemerge(unsafe.Pointer(&racecgosync))
+	}
 
-	// Pop defer.
 	// Do not unwind m->g0->sched.sp.
 	// Our caller, cgocallback, will do that.
-	if(g->defer != &d || d.fn != &unwindmf)
-		runtime·throw("runtime: bad defer entry in cgocallback");
-	g->defer = d.link;
+	restore = false
 }
 
-static void
-unwindm(void)
-{
+func unwindm(restore *bool) {
+	if !*restore {
+		return
+	}
 	// Restore sp saved by cgocallback during
 	// unwind of g's stack (see comment at top of file).
-	switch(thechar){
+	mp := acquirem()
+	sched := &mp.g0.sched
+	switch GOARCH {
 	default:
-		runtime·throw("runtime: unwindm not implemented");
-	case '8':
-	case '6':
-		g->m->g0->sched.sp = *(uintptr*)g->m->g0->sched.sp;
-		break;
-	case '5':
-		g->m->g0->sched.sp = *(uintptr*)((byte*)g->m->g0->sched.sp + 4);
-		break;
+		gothrow("unwindm not implemented")
+	case "386", "amd64":
+		sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp))
+	case "arm":
+		sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + 4))
 	}
+	releasem(mp)
 }
 
-void
-runtime·badcgocallback(void)	// called from assembly
-{
-	runtime·throw("runtime: misaligned stack in cgocallback");
+// called from assembly
+func badcgocallback() {
+	gothrow("misaligned stack in cgocallback")
 }
 
-void
-runtime·cgounimpl(void)	// called from (incomplete) assembly
-{
-	runtime·throw("runtime: cgo not implemented");
+// called from (incomplete) assembly
+func cgounimpl() {
+	gothrow("cgo not implemented")
 }
 
-// For cgo-using programs with external linking,
-// export "main" (defined in assembly) so that libc can handle basic
-// C runtime startup and call the Go program as if it were
-// the C main function.
-#pragma cgo_export_static main
+var racecgosync uint64 // represents possible synchronization in C code
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index d75c210c5a..45ae1bc2a8 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -132,6 +132,21 @@ static void dropg(void);
 
 extern String runtime·buildVersion;
 
+// For cgo-using programs with external linking,
+// export "main" (defined in assembly) so that libc can handle basic
+// C runtime startup and call the Go program as if it were
+// the C main function.
+#pragma cgo_export_static main
+
+// Filled in by dynamic linker when Cgo is available.
+void* _cgo_init;
+void* _cgo_malloc;
+void* _cgo_free;
+
+// Copy for Go code.
+void* runtime·cgoMalloc;
+void* runtime·cgoFree;
+
 // The bootstrap sequence is:
 //
 //	call osinit
@@ -192,6 +207,9 @@ runtime·schedinit(void)
 		runtime·buildVersion.str = (uint8*)"unknown";
 		runtime·buildVersion.len = 7;
 	}
+
+	runtime·cgoMalloc = _cgo_malloc;
+	runtime·cgoFree = _cgo_free;
 }
 
 extern void main·init(void);
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 73dc2ec443..558963376d 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -32,6 +32,9 @@ func raceacquire(addr unsafe.Pointer)
 //go:noescape
 func racerelease(addr unsafe.Pointer)
 
+//go:noescape
+func racereleasemerge(addr unsafe.Pointer)
+
 //go:noescape
 func raceacquireg(gp *g, addr unsafe.Pointer)
 
@@ -146,6 +149,9 @@ const (
 func gosched()
 func starttheworld()
 func stoptheworld()
+func newextram()
+func lockOSThread()
+func unlockOSThread()
 
 // exported value for testing
 var hashLoad = loadFactor
@@ -282,6 +288,9 @@ func getcallersp(argp unsafe.Pointer) uintptr
 //go:noescape
 func asmcgocall(fn, arg unsafe.Pointer)
 
+//go:noescape
+func asmcgocall_errno(fn, arg unsafe.Pointer) int32
+
 //go:noescape
 func open(name *byte, mode, perm int32) int32
 

From f545b05aaec2d13e664ce48ce2c258bcfce307c4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 15:53:45 -0400
Subject: [PATCH 380/423] runtime: make more functions safe for Go

Convert no-op race functions.
Everything else is tiny and gets NOSPLITs.

After this, all that is left on darwin is sysAlloc, panic, and gothrow (all pending).
There may be system-specific calls in other builds.

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/140240044
---
 src/pkg/runtime/cgocall.go     |   4 +-
 src/pkg/runtime/os_darwin.c    |   1 +
 src/pkg/runtime/os_dragonfly.c |  24 ++++++-
 src/pkg/runtime/os_freebsd.c   |  24 ++++++-
 src/pkg/runtime/os_linux.c     |  25 ++++++-
 src/pkg/runtime/os_nacl.c      |  72 ++++++++++++++++---
 src/pkg/runtime/os_netbsd.c    |   1 +
 src/pkg/runtime/os_openbsd.c   |   1 +
 src/pkg/runtime/os_plan9.c     |   1 +
 src/pkg/runtime/os_solaris.c   |   1 +
 src/pkg/runtime/os_windows.c   |   1 +
 src/pkg/runtime/proc.c         |  20 +++++-
 src/pkg/runtime/race.c         |  56 ++++++---------
 src/pkg/runtime/race.go        |  69 +++++++++++++++++-
 src/pkg/runtime/race0.c        | 124 ---------------------------------
 src/pkg/runtime/race0.go       |  25 +++++--
 src/pkg/runtime/slice.go       |   8 +--
 src/pkg/runtime/string.go      |   6 +-
 src/pkg/runtime/stubs.go       |  31 ---------
 19 files changed, 274 insertions(+), 220 deletions(-)
 delete mode 100644 src/pkg/runtime/race0.c

diff --git a/src/pkg/runtime/cgocall.go b/src/pkg/runtime/cgocall.go
index d44b832dfa..1037c5dc21 100644
--- a/src/pkg/runtime/cgocall.go
+++ b/src/pkg/runtime/cgocall.go
@@ -101,7 +101,7 @@ func cgocall_errno(fn, arg unsafe.Pointer) int32 {
 
 	// Create an extra M for callbacks on threads not created by Go on first cgo call.
 	if needextram == 1 && cas(&needextram, 1, 0) {
-		newextram()
+		onM(newextram)
 	}
 
 	/*
@@ -188,7 +188,7 @@ func cgocallbackg1() {
 	gp := getg()
 	if gp.m.needextram {
 		gp.m.needextram = false
-		newextram()
+		onM(newextram)
 	}
 
 	// Add entry to defer stack in case of panic.
diff --git a/src/pkg/runtime/os_darwin.c b/src/pkg/runtime/os_darwin.c
index d3890eee52..466591877d 100644
--- a/src/pkg/runtime/os_darwin.c
+++ b/src/pkg/runtime/os_darwin.c
@@ -71,6 +71,7 @@ runtime·osinit(void)
 		runtime·ncpu = out;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_dragonfly.c b/src/pkg/runtime/os_dragonfly.c
index a2a88e4c80..f93c02ce1c 100644
--- a/src/pkg/runtime/os_dragonfly.c
+++ b/src/pkg/runtime/os_dragonfly.c
@@ -72,19 +72,40 @@ runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
 	*(int32*)0x1005 = 0x1005;
 }
 
+static void badfutexwakeup(void);
+
+#pragma textflag NOSPLIT
 void
 runtime·futexwakeup(uint32 *addr, uint32 cnt)
 {
 	int32 ret;
+	void (*fn)(void);
 
 	ret = runtime·sys_umtx_wakeup(addr, cnt);
 	if(ret >= 0)
 		return;
 
-	runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
+	g->m->ptrarg[0] = addr;
+	g->m->scalararg[0] = ret;
+	fn = badfutexwakeup;
+	if(g == g->m->gsignal)
+		fn();
+	else
+		runtime·onM(&fn);
 	*(int32*)0x1006 = 0x1006;
 }
 
+static void
+badfutexwakeup(void)
+{
+	void *addr;
+	int32 ret;
+	
+	addr = g->m->ptrarg[0];
+	ret = g->m->scalararg[0];
+	runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
+}
+
 void runtime·lwp_start(void*);
 
 void
@@ -119,6 +140,7 @@ runtime·osinit(void)
 	runtime·ncpu = getncpu();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_freebsd.c b/src/pkg/runtime/os_freebsd.c
index ae959d90bb..ab1edcd93f 100644
--- a/src/pkg/runtime/os_freebsd.c
+++ b/src/pkg/runtime/os_freebsd.c
@@ -73,19 +73,40 @@ fail:
 	*(int32*)0x1005 = 0x1005;
 }
 
+static void badfutexwakeup(void);
+
+#pragma textflag NOSPLIT
 void
 runtime·futexwakeup(uint32 *addr, uint32 cnt)
 {
 	int32 ret;
+	void (*fn)(void);
 
 	ret = runtime·sys_umtx_op(addr, UMTX_OP_WAKE_PRIVATE, cnt, nil, nil);
 	if(ret >= 0)
 		return;
 
-	runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
+	g->m->ptrarg[0] = addr;
+	g->m->scalararg[0] = ret;
+	fn = badfutexwakeup;
+	if(g == g->m->gsignal)
+		fn();
+	else
+		runtime·onM(&fn);
 	*(int32*)0x1006 = 0x1006;
 }
 
+static void
+badfutexwakeup(void)
+{
+	void *addr;
+	int32 ret;
+	
+	addr = g->m->ptrarg[0];
+	ret = g->m->scalararg[0];
+	runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
+}
+
 void runtime·thr_start(void*);
 
 void
@@ -127,6 +148,7 @@ runtime·osinit(void)
 	runtime·ncpu = getncpu();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_linux.c b/src/pkg/runtime/os_linux.c
index 34521cc86a..7ab4858d9a 100644
--- a/src/pkg/runtime/os_linux.c
+++ b/src/pkg/runtime/os_linux.c
@@ -55,24 +55,44 @@ runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
 	runtime·futex(addr, FUTEX_WAIT, val, &ts, nil, 0);
 }
 
+static void badfutexwakeup(void);
+
 // If any procs are sleeping on addr, wake up at most cnt.
+#pragma textflag NOSPLIT
 void
 runtime·futexwakeup(uint32 *addr, uint32 cnt)
 {
 	int64 ret;
+	void (*fn)(void);
 
 	ret = runtime·futex(addr, FUTEX_WAKE, cnt, nil, nil, 0);
-
 	if(ret >= 0)
 		return;
 
 	// I don't know that futex wakeup can return
 	// EAGAIN or EINTR, but if it does, it would be
 	// safe to loop and call futex again.
-	runtime·printf("futexwakeup addr=%p returned %D\n", addr, ret);
+	g->m->ptrarg[0] = addr;
+	g->m->scalararg[0] = (int32)ret; // truncated but fine
+	fn = badfutexwakeup;
+	if(g == g->m->gsignal)
+		fn();
+	else
+		runtime·onM(&fn);
 	*(int32*)0x1006 = 0x1006;
 }
 
+static void
+badfutexwakeup(void)
+{
+	void *addr;
+	int64 ret;
+	
+	addr = g->m->ptrarg[0];
+	ret = (int32)g->m->scalararg[0];
+	runtime·printf("futexwakeup addr=%p returned %D\n", addr, ret);
+}
+
 extern runtime·sched_getaffinity(uintptr pid, uintptr len, uintptr *buf);
 static int32
 getproccount(void)
@@ -162,6 +182,7 @@ runtime·osinit(void)
 byte*	runtime·startup_random_data;
 uint32	runtime·startup_random_data_len;
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_nacl.c b/src/pkg/runtime/os_nacl.c
index f859dd0d35..fba32e5687 100644
--- a/src/pkg/runtime/os_nacl.c
+++ b/src/pkg/runtime/os_nacl.c
@@ -65,6 +65,7 @@ runtime·crash(void)
 	*(int32*)0 = 0;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
@@ -112,8 +113,8 @@ runtime·newosproc(M *mp, void *stk)
 	}
 }
 
-uintptr
-runtime·semacreate(void)
+static void
+semacreate(void)
 {
 	int32 mu, cond;
 	
@@ -128,14 +129,32 @@ runtime·semacreate(void)
 		runtime·throw("semacreate");
 	}
 	g->m->waitsemalock = mu;
-	return cond; // assigned to m->waitsema
+	g->m->scalararg[0] = cond; // assigned to m->waitsema
 }
 
 #pragma textflag NOSPLIT
-int32
-runtime·semasleep(int64 ns)
+uint32
+runtime·semacreate(void)
+{
+	void (*fn)(void);
+	uint32 x;
+	
+	fn = semacreate;
+	runtime·onM(&fn);
+	x = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	return x;
+}
+
+static void
+semasleep(void)
 {
 	int32 ret;
+	int64 ns;
+	
+	ns = (int64)(uint32)g->m->scalararg[0] | (int64)(uint32)g->m->scalararg[1]<<32;
+	g->m->scalararg[0] = 0;
+	g->m->scalararg[1] = 0;
 	
 	ret = runtime·nacl_mutex_lock(g->m->waitsemalock);
 	if(ret < 0) {
@@ -145,7 +164,8 @@ runtime·semasleep(int64 ns)
 	if(g->m->waitsemacount > 0) {
 		g->m->waitsemacount = 0;
 		runtime·nacl_mutex_unlock(g->m->waitsemalock);
-		return 0;
+		g->m->scalararg[0] = 0;
+		return;
 	}
 
 	while(g->m->waitsemacount == 0) {
@@ -163,7 +183,8 @@ runtime·semasleep(int64 ns)
 			ret = runtime·nacl_cond_timed_wait_abs(g->m->waitsema, g->m->waitsemalock, &ts);
 			if(ret == -ETIMEDOUT) {
 				runtime·nacl_mutex_unlock(g->m->waitsemalock);
-				return -1;
+				g->m->scalararg[0] = -1;
+				return;
 			}
 			if(ret < 0) {
 				//runtime·printf("nacl_cond_timed_wait_abs: error %d\n", -ret);
@@ -174,14 +195,34 @@ runtime·semasleep(int64 ns)
 			
 	g->m->waitsemacount = 0;
 	runtime·nacl_mutex_unlock(g->m->waitsemalock);
-	return 0;
+	g->m->scalararg[0] = 0;
 }
 
-void
-runtime·semawakeup(M *mp)
+#pragma textflag NOSPLIT
+int32
+runtime·semasleep(int64 ns)
+{
+	int32 r;
+	void (*fn)(void);
+
+	g->m->scalararg[0] = (uint32)ns;
+	g->m->scalararg[1] = (uint32)(ns>>32);
+	fn = semasleep;
+	runtime·onM(&fn);
+	r = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	return r;
+}
+
+static void
+semawakeup(void)
 {
 	int32 ret;
+	M *mp;
 	
+	mp = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+
 	ret = runtime·nacl_mutex_lock(mp->waitsemalock);
 	if(ret < 0) {
 		//runtime·printf("nacl_mutex_lock: error %d\n", -ret);
@@ -196,6 +237,17 @@ runtime·semawakeup(M *mp)
 	runtime·nacl_mutex_unlock(mp->waitsemalock);
 }
 
+#pragma textflag NOSPLIT
+void
+runtime·semawakeup(M *mp)
+{
+	void (*fn)(void);
+
+	g->m->ptrarg[0] = mp;
+	fn = semawakeup;
+	runtime·onM(&fn);
+}
+
 uintptr
 runtime·memlimit(void)
 {
diff --git a/src/pkg/runtime/os_netbsd.c b/src/pkg/runtime/os_netbsd.c
index 8567146ed4..29ea0cb427 100644
--- a/src/pkg/runtime/os_netbsd.c
+++ b/src/pkg/runtime/os_netbsd.c
@@ -185,6 +185,7 @@ runtime·osinit(void)
 	runtime·ncpu = getncpu();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index dbd12a1282..728cb88c4c 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -164,6 +164,7 @@ runtime·osinit(void)
 	runtime·ncpu = getncpu();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_plan9.c b/src/pkg/runtime/os_plan9.c
index fad5b2717f..efff24ea09 100644
--- a/src/pkg/runtime/os_plan9.c
+++ b/src/pkg/runtime/os_plan9.c
@@ -100,6 +100,7 @@ runtime·crash(void)
 	*(int32*)0 = 0;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index d064384e84..c7ec3f212f 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -143,6 +143,7 @@ runtime·newosproc(M *mp, void *stk)
 	}
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 0e53d8a31c..9bf6ecbc64 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -109,6 +109,7 @@ runtime·osinit(void)
 	}
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 45ae1bc2a8..0c72e4bd06 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2534,6 +2534,7 @@ lockOSThread(void)
 	g->lockedm = g->m;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·LockOSThread(void)
 {
@@ -2541,6 +2542,7 @@ runtime·LockOSThread(void)
 	lockOSThread();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·lockOSThread(void)
 {
@@ -2562,6 +2564,7 @@ unlockOSThread(void)
 	g->lockedm = nil;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·UnlockOSThread(void)
 {
@@ -2569,15 +2572,28 @@ runtime·UnlockOSThread(void)
 	unlockOSThread();
 }
 
+static void badunlockOSThread(void);
+
+#pragma textflag NOSPLIT
 void
 runtime·unlockOSThread(void)
 {
-	if(g->m->locked < LockInternal)
-		runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
+	void (*fn)(void);
+
+	if(g->m->locked < LockInternal) {
+		fn = badunlockOSThread;
+		runtime·onM(&fn);
+	}
 	g->m->locked -= LockInternal;
 	unlockOSThread();
 }
 
+static void
+badunlockOSThread(void)
+{
+	runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
+}
+
 bool
 runtime·lockedOSThread(void)
 {
diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index d5e77c7568..125309510b 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -80,6 +80,7 @@ void runtime·racesymbolizethunk(void*);
 void runtime·racecall(void(*f)(void), ...);
 
 // checks if the address has shadow (i.e. heap or data/bss)
+#pragma textflag NOSPLIT
 static bool
 isvalidaddr(uintptr addr)
 {
@@ -90,6 +91,7 @@ isvalidaddr(uintptr addr)
 	return false;
 }
 
+#pragma textflag NOSPLIT
 uintptr
 runtime·raceinit(void)
 {
@@ -106,12 +108,14 @@ runtime·raceinit(void)
 	return racectx;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racefini(void)
 {
 	runtime·racecall(__tsan_fini);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racemapshadow(void *addr, uintptr size)
 {
@@ -129,6 +133,7 @@ runtime·racemalloc(void *p, uintptr sz)
 	runtime·racecall(__tsan_malloc, p, sz);
 }
 
+#pragma textflag NOSPLIT
 uintptr
 runtime·racegostart(void *pc)
 {
@@ -144,12 +149,14 @@ runtime·racegostart(void *pc)
 	return racectx;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racegoend(void)
 {
 	runtime·racecall(__tsan_go_end, g->racectx);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
 {
@@ -165,6 +172,7 @@ runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
 		runtime·racefuncexit();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
 {
@@ -180,6 +188,7 @@ runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
 		runtime·racefuncexit();
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racewriteobjectpc(void *addr, Type *t, void *callpc, void *pc)
 {
@@ -192,6 +201,7 @@ runtime·racewriteobjectpc(void *addr, Type *t, void *callpc, void *pc)
 		runtime·racewritepc(addr, callpc, pc);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racereadobjectpc(void *addr, Type *t, void *callpc, void *pc)
 {
@@ -204,12 +214,14 @@ runtime·racereadobjectpc(void *addr, Type *t, void *callpc, void *pc)
 		runtime·racereadpc(addr, callpc, pc);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·raceacquire(void *addr)
 {
 	runtime·raceacquireg(g, addr);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·raceacquireg(G *gp, void *addr)
 {
@@ -218,6 +230,7 @@ runtime·raceacquireg(G *gp, void *addr)
 	runtime·racecall(__tsan_acquire, gp->racectx, addr);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racerelease(void *addr)
 {
@@ -226,6 +239,7 @@ runtime·racerelease(void *addr)
 	runtime·racereleaseg(g, addr);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racereleaseg(G *gp, void *addr)
 {
@@ -234,12 +248,14 @@ runtime·racereleaseg(G *gp, void *addr)
 	runtime·racecall(__tsan_release, gp->racectx, addr);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racereleasemerge(void *addr)
 {
 	runtime·racereleasemergeg(g, addr);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racereleasemergeg(G *gp, void *addr)
 {
@@ -248,6 +264,7 @@ runtime·racereleasemergeg(G *gp, void *addr)
 	runtime·racecall(__tsan_release_merge, gp->racectx, addr);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·racefingo(void)
 {
@@ -255,6 +272,7 @@ runtime·racefingo(void)
 }
 
 // func RaceAcquire(addr unsafe.Pointer)
+#pragma textflag NOSPLIT
 void
 runtime·RaceAcquire(void *addr)
 {
@@ -262,6 +280,7 @@ runtime·RaceAcquire(void *addr)
 }
 
 // func RaceRelease(addr unsafe.Pointer)
+#pragma textflag NOSPLIT
 void
 runtime·RaceRelease(void *addr)
 {
@@ -269,6 +288,7 @@ runtime·RaceRelease(void *addr)
 }
 
 // func RaceReleaseMerge(addr unsafe.Pointer)
+#pragma textflag NOSPLIT
 void
 runtime·RaceReleaseMerge(void *addr)
 {
@@ -276,6 +296,7 @@ runtime·RaceReleaseMerge(void *addr)
 }
 
 // func RaceDisable()
+#pragma textflag NOSPLIT
 void
 runtime·RaceDisable(void)
 {
@@ -284,43 +305,10 @@ runtime·RaceDisable(void)
 }
 
 // func RaceEnable()
+#pragma textflag NOSPLIT
 void
 runtime·RaceEnable(void)
 {
 	if(--g->raceignore == 0)
 		runtime·racecall(__tsan_go_ignore_sync_end, g->racectx);
 }
-
-typedef struct SymbolizeContext SymbolizeContext;
-struct SymbolizeContext
-{
-	uintptr	pc;
-	int8*	func;
-	int8*	file;
-	uintptr	line;
-	uintptr	off;
-	uintptr	res;
-};
-
-// Callback from C into Go, runs on g0.
-void
-runtime·racesymbolize(SymbolizeContext *ctx)
-{
-	Func *f;
-	String file;
-
-	f = runtime·findfunc(ctx->pc);
-	if(f == nil) {
-		ctx->func = "??";
-		ctx->file = "-";
-		ctx->line = 0;
-		ctx->off = ctx->pc;
-		ctx->res = 1;
-		return;
-	}
-	ctx->func = runtime·funcname(f);
-	ctx->line = runtime·funcline(f, ctx->pc, &file);
-	ctx->file = (int8*)file.str;  // assume zero-terminated
-	ctx->off = ctx->pc - f->entry;
-	ctx->res = 1;
-}
diff --git a/src/pkg/runtime/race.go b/src/pkg/runtime/race.go
index df8493e35c..c7573517dc 100644
--- a/src/pkg/runtime/race.go
+++ b/src/pkg/runtime/race.go
@@ -38,7 +38,7 @@ func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 	if kind == kindArray || kind == kindStruct {
 		// for composite objects we have to read every address
 		// because a write might happen to any subobject.
-		racereadrangepc(addr, int(t.size), callerpc, pc)
+		racereadrangepc(addr, t.size, callerpc, pc)
 	} else {
 		// for non-composite objects we can read just the start
 		// address, as any write must write the first byte.
@@ -51,10 +51,75 @@ func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 	if kind == kindArray || kind == kindStruct {
 		// for composite objects we have to write every address
 		// because a write might happen to any subobject.
-		racewriterangepc(addr, int(t.size), callerpc, pc)
+		racewriterangepc(addr, t.size, callerpc, pc)
 	} else {
 		// for non-composite objects we can write just the start
 		// address, as any write must write the first byte.
 		racewritepc(addr, callerpc, pc)
 	}
 }
+
+//go:noescape
+func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
+
+//go:noescape
+func racewritepc(addr unsafe.Pointer, callpc, pc uintptr)
+
+//go:noescape
+func racereadrangepc(addr unsafe.Pointer, len uintptr, callpc, pc uintptr)
+
+//go:noescape
+func racewriterangepc(addr unsafe.Pointer, len uintptr, callpc, pc uintptr)
+
+//go:noescape
+func raceacquire(addr unsafe.Pointer)
+
+//go:noescape
+func racerelease(addr unsafe.Pointer)
+
+//go:noescape
+func raceacquireg(gp *g, addr unsafe.Pointer)
+
+//go:noescape
+func racereleaseg(gp *g, addr unsafe.Pointer)
+
+func racefingo()
+
+//go:noescape
+func racemalloc(p unsafe.Pointer, size uintptr)
+
+//go:noescape
+func racereleasemerge(addr unsafe.Pointer)
+
+type symbolizeContext struct {
+	pc   uintptr
+	fn   *byte
+	file *byte
+	line uintptr
+	off  uintptr
+	res  uintptr
+}
+
+var qq = [...]byte{'?', '?', 0}
+var dash = [...]byte{'-', 0}
+
+// Callback from C into Go, runs on g0.
+func racesymbolize(ctx *symbolizeContext) {
+	f := findfunc(ctx.pc)
+	if f == nil {
+		ctx.fn = &qq[0]
+		ctx.file = &dash[0]
+		ctx.line = 0
+		ctx.off = ctx.pc
+		ctx.res = 1
+		return
+	}
+
+	ctx.fn = funcname(f)
+	var file string
+	ctx.line = uintptr(funcline(f, ctx.pc, &file))
+	ctx.file = &bytes(file)[0] // assume NUL-terminated
+	ctx.off = ctx.pc - f.entry
+	ctx.res = 1
+	return
+}
diff --git a/src/pkg/runtime/race0.c b/src/pkg/runtime/race0.c
deleted file mode 100644
index eddb0be79f..0000000000
--- a/src/pkg/runtime/race0.c
+++ /dev/null
@@ -1,124 +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.
-
-// Stub implementation of the race detector API.
-// +build !race
-
-#include "runtime.h"
-
-uintptr
-runtime·raceinit(void)
-{
-	return 0;
-}
-
-void
-runtime·racefini(void)
-{
-}
-
-
-void
-runtime·racemapshadow(void *addr, uintptr size)
-{
-	USED(addr);
-	USED(size);
-}
-
-void
-runtime·racewritepc(void *addr, void *callpc, void *pc)
-{
-	USED(addr);
-	USED(callpc);
-	USED(pc);
-}
-
-void
-runtime·racereadpc(void *addr, void *callpc, void *pc)
-{
-	USED(addr);
-	USED(callpc);
-	USED(pc);
-}
-
-void
-runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
-{
-	USED(addr);
-	USED(sz);
-	USED(callpc);
-	USED(pc);
-}
-
-void
-runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
-{
-	USED(addr);
-	USED(sz);
-	USED(callpc);
-	USED(pc);
-}
-
-void
-runtime·raceacquire(void *addr)
-{
-	USED(addr);
-}
-
-void
-runtime·raceacquireg(G *gp, void *addr)
-{
-	USED(gp);
-	USED(addr);
-}
-
-void
-runtime·racerelease(void *addr)
-{
-	USED(addr);
-}
-
-void
-runtime·racereleaseg(G *gp, void *addr)
-{
-	USED(gp);
-	USED(addr);
-}
-
-void
-runtime·racereleasemerge(void *addr)
-{
-	USED(addr);
-}
-
-void
-runtime·racereleasemergeg(G *gp, void *addr)
-{
-	USED(gp);
-	USED(addr);
-}
-
-void
-runtime·racefingo(void)
-{
-}
-
-void
-runtime·racemalloc(void *p, uintptr sz)
-{
-	USED(p);
-	USED(sz);
-}
-
-uintptr
-runtime·racegostart(void *pc)
-{
-	USED(pc);
-	return 0;
-}
-
-void
-runtime·racegoend(void)
-{
-}
diff --git a/src/pkg/runtime/race0.go b/src/pkg/runtime/race0.go
index 2e67ae6a50..5d90cc859a 100644
--- a/src/pkg/runtime/race0.go
+++ b/src/pkg/runtime/race0.go
@@ -14,7 +14,24 @@ import (
 
 const raceenabled = false
 
-func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
-}
-func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
-}
+// Because raceenabled is false, none of these functions should be called.
+
+func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr)  { gothrow("race") }
+func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { gothrow("race") }
+func raceinit()                                                             { gothrow("race") }
+func racefini()                                                             { gothrow("race") }
+func racemapshadow(addr unsafe.Pointer, size uintptr)                       { gothrow("race") }
+func racewritepc(addr unsafe.Pointer, callerpc, pc uintptr)                 { gothrow("race") }
+func racereadpc(addr unsafe.Pointer, callerpc, pc uintptr)                  { gothrow("race") }
+func racereadrangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr)         { gothrow("race") }
+func racewriterangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr)        { gothrow("race") }
+func raceacquire(addr unsafe.Pointer)                                       { gothrow("race") }
+func raceacquireg(gp *g, addr unsafe.Pointer)                               { gothrow("race") }
+func racerelease(addr unsafe.Pointer)                                       { gothrow("race") }
+func racereleaseg(gp *g, addr unsafe.Pointer)                               { gothrow("race") }
+func racereleasemerge(addr unsafe.Pointer)                                  { gothrow("race") }
+func racereleasemergeg(gp *g, addr unsafe.Pointer)                          { gothrow("race") }
+func racefingo()                                                            { gothrow("race") }
+func racemalloc(p unsafe.Pointer, sz uintptr)                               { gothrow("race") }
+func racegostart(pc uintptr) uintptr                                        { gothrow("race"); return 0 }
+func racegoend()                                                            { gothrow("race") }
diff --git a/src/pkg/runtime/slice.go b/src/pkg/runtime/slice.go
index 68a225a509..3b88927c64 100644
--- a/src/pkg/runtime/slice.go
+++ b/src/pkg/runtime/slice.go
@@ -48,7 +48,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct {
 
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&t))
-		racereadrangepc(old.array, old.len*int(t.elem.size), callerpc, funcPC(growslice))
+		racereadrangepc(old.array, uintptr(old.len*int(t.elem.size)), callerpc, funcPC(growslice))
 	}
 
 	et := t.elem
@@ -104,8 +104,8 @@ func slicecopy(to sliceStruct, fm sliceStruct, width uintptr) int {
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&to))
 		pc := funcPC(slicecopy)
-		racewriterangepc(to.array, n*int(width), callerpc, pc)
-		racereadrangepc(fm.array, n*int(width), callerpc, pc)
+		racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
+		racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
 	}
 
 	size := uintptr(n) * width
@@ -131,7 +131,7 @@ func slicestringcopy(to []byte, fm string) int {
 	if raceenabled {
 		callerpc := getcallerpc(unsafe.Pointer(&to))
 		pc := funcPC(slicestringcopy)
-		racewriterangepc(unsafe.Pointer(&to[0]), n, callerpc, pc)
+		racewriterangepc(unsafe.Pointer(&to[0]), uintptr(n), callerpc, pc)
 	}
 
 	memmove(unsafe.Pointer(&to[0]), unsafe.Pointer((*stringStruct)(unsafe.Pointer(&fm)).str), uintptr(n))
diff --git a/src/pkg/runtime/string.go b/src/pkg/runtime/string.go
index 91f33db118..da3160449f 100644
--- a/src/pkg/runtime/string.go
+++ b/src/pkg/runtime/string.go
@@ -62,7 +62,7 @@ func concatstring5(a [5]string) string {
 func slicebytetostring(b []byte) string {
 	if raceenabled && len(b) > 0 {
 		racereadrangepc(unsafe.Pointer(&b[0]),
-			len(b),
+			uintptr(len(b)),
 			getcallerpc(unsafe.Pointer(&b)),
 			funcPC(slicebytetostring))
 	}
@@ -82,7 +82,7 @@ func slicebytetostringtmp(b []byte) string {
 
 	if raceenabled && len(b) > 0 {
 		racereadrangepc(unsafe.Pointer(&b[0]),
-			len(b),
+			uintptr(len(b)),
 			getcallerpc(unsafe.Pointer(&b)),
 			funcPC(slicebytetostringtmp))
 	}
@@ -119,7 +119,7 @@ func stringtoslicerune(s string) []rune {
 func slicerunetostring(a []rune) string {
 	if raceenabled && len(a) > 0 {
 		racereadrangepc(unsafe.Pointer(&a[0]),
-			len(a)*int(unsafe.Sizeof(a[0])),
+			uintptr(len(a))*unsafe.Sizeof(a[0]),
 			getcallerpc(unsafe.Pointer(&a)),
 			funcPC(slicerunetostring))
 	}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 558963376d..7d59b5c19b 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -14,35 +14,6 @@ import "unsafe"
 const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
 const regSize = 4 << (^uintreg(0) >> 63) // unsafe.Sizeof(uintreg(0)) but an ideal const
 
-//go:noescape
-func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
-
-//go:noescape
-func racewritepc(addr unsafe.Pointer, callpc, pc uintptr)
-
-//go:noescape
-func racereadrangepc(addr unsafe.Pointer, len int, callpc, pc uintptr)
-
-//go:noescape
-func racewriterangepc(addr unsafe.Pointer, len int, callpc, pc uintptr)
-
-//go:noescape
-func raceacquire(addr unsafe.Pointer)
-
-//go:noescape
-func racerelease(addr unsafe.Pointer)
-
-//go:noescape
-func racereleasemerge(addr unsafe.Pointer)
-
-//go:noescape
-func raceacquireg(gp *g, addr unsafe.Pointer)
-
-//go:noescape
-func racereleaseg(gp *g, addr unsafe.Pointer)
-
-func racefingo()
-
 // Should be a built-in for unsafe.Pointer?
 //go:nosplit
 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
@@ -135,8 +106,6 @@ func goexit_m()
 //go:noescape
 func memclr(ptr unsafe.Pointer, n uintptr)
 
-func racemalloc(p unsafe.Pointer, size uintptr)
-
 // memmove copies n bytes from "from" to "to".
 // in memmove_*.s
 //go:noescape

From a29437101c5c49841d22c0ee6bf8bcd4c7a5c925 Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Thu, 4 Sep 2014 15:18:32 -0700
Subject: [PATCH 381/423] go/parser: fix "zero day" parse error

(a b string, ok bool) is not a valid signature

Fixes #8656.

LGTM=adonovan
R=adonovan
CC=golang-codereviews
https://golang.org/cl/137140043
---
 src/pkg/go/parser/parser.go     | 19 ++++++++++---------
 src/pkg/go/parser/short_test.go |  1 +
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/pkg/go/parser/parser.go b/src/pkg/go/parser/parser.go
index 4d6f36258c..9c62076f25 100644
--- a/src/pkg/go/parser/parser.go
+++ b/src/pkg/go/parser/parser.go
@@ -823,9 +823,10 @@ func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params [
 		// parameter or result variable is the function body.
 		p.declare(field, nil, scope, ast.Var, idents...)
 		p.resolve(typ)
-		if p.tok == token.COMMA {
-			p.next()
+		if !p.atComma("parameter list") {
+			return
 		}
+		p.next()
 		for p.tok != token.RPAREN && p.tok != token.EOF {
 			idents := p.parseIdentList()
 			typ := p.parseVarType(ellipsisOk)
@@ -840,15 +841,15 @@ func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params [
 			}
 			p.next()
 		}
-	} else {
-		// Type { "," Type } (anonymous parameters)
-		params = make([]*ast.Field, len(list))
-		for i, typ := range list {
-			p.resolve(typ)
-			params[i] = &ast.Field{Type: typ}
-		}
+		return
 	}
 
+	// Type { "," Type } (anonymous parameters)
+	params = make([]*ast.Field, len(list))
+	for i, typ := range list {
+		p.resolve(typ)
+		params[i] = &ast.Field{Type: typ}
+	}
 	return
 }
 
diff --git a/src/pkg/go/parser/short_test.go b/src/pkg/go/parser/short_test.go
index 8a3c33868b..f861086ddb 100644
--- a/src/pkg/go/parser/short_test.go
+++ b/src/pkg/go/parser/short_test.go
@@ -93,6 +93,7 @@ var invalids = []string{
 	`package p; func f() { go f /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { defer func() {} /* ERROR HERE "function must be invoked" */ }`,
 	`package p; func f() { go func() { func() { f(x func /* ERROR "expected '\)'" */ (){}) } } }`,
+	`package p; func f() (a b string /* ERROR "expected '\)'" */ , ok bool) // issue 8656`,
 }
 
 func TestInvalid(t *testing.T) {

From 1a14b5bad8926941023ca310fa3b53c70717b1e2 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Thu, 4 Sep 2014 17:13:22 -0700
Subject: [PATCH 382/423] cmd/api: don't depend on os/user or USER to check api

The -nocgo builder failed because it has cgo disabled
as well as no USER environment variable:
http://build.golang.org/log/2250abb82f5022b72a12997b8ff89fcdeff094c9

# Checking API compatibility.
Error getting current user: user: Current not implemented on linux/amd64
exit status 1

Don't require the environment variable here.

LGTM=minux
R=dave, adg, minux
CC=golang-codereviews
https://golang.org/cl/140290043
---
 src/cmd/api/run.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/cmd/api/run.go b/src/cmd/api/run.go
index 896b2b4a1a..c323deb603 100644
--- a/src/cmd/api/run.go
+++ b/src/cmd/api/run.go
@@ -98,11 +98,9 @@ func prepGoPath() string {
 	if err == nil {
 		username = u.Username
 	} else {
-		// Only need to handle Unix here, as Windows's os/user uses
-		// native syscall and should work fine without cgo.
 		username = os.Getenv("USER")
 		if username == "" {
-			log.Fatalf("Error getting current user: %v", err)
+			username = "nobody"
 		}
 	}
 

From db58ab96fa4767ca6144678d63203be5381709d6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 21:12:31 -0400
Subject: [PATCH 383/423] runtime: more C to Go conversion adjustments

Mostly NOSPLIT additions.
Had to rewrite atomic_arm.c in Go because it calls lock,
and lock is too complex.

With this CL, I find no Go -> C calls that can split the stack
on any system except Solaris and Windows.

Solaris and Windows need more work and will be done separately.

LGTM=iant, dave
R=golang-codereviews, bradfitz, iant, dave
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/137160043
---
 src/cmd/api/goapi.go            |   1 +
 src/pkg/runtime/asm_arm.s       |  48 ++++----
 src/pkg/runtime/atomic.go       |  51 +++++++++
 src/pkg/runtime/atomic_arm.c    | 192 --------------------------------
 src/pkg/runtime/atomic_arm.go   | 155 ++++++++++++++++++++++++++
 src/pkg/runtime/malloc.c        |   1 +
 src/pkg/runtime/os_dragonfly.c  |  25 +++++
 src/pkg/runtime/os_freebsd.c    |  25 +++++
 src/pkg/runtime/os_netbsd.c     |  70 ++++++++++--
 src/pkg/runtime/os_openbsd.c    |  38 ++++++-
 src/pkg/runtime/os_plan9.c      |  23 ++++
 src/pkg/runtime/proc.c          |  14 ---
 src/pkg/runtime/proc.go         |   9 ++
 src/pkg/runtime/softfloat_arm.c |  31 +++++-
 src/pkg/runtime/stubs.go        |  44 +-------
 src/pkg/runtime/vlrt.c          |  33 ++++++
 16 files changed, 479 insertions(+), 281 deletions(-)
 create mode 100644 src/pkg/runtime/atomic.go
 delete mode 100644 src/pkg/runtime/atomic_arm.c
 create mode 100644 src/pkg/runtime/atomic_arm.go

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 6b21a24e36..18c36bb175 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -411,6 +411,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			"); " +
 			"const (" +
 			" cb_max = 2000;" +
+			" _CacheLineSize = 64;" +
 			" _Gidle = 1;" +
 			" _Grunnable = 2;" +
 			" _Grunning = 3;" +
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 3f3b9b7bee..54ef836211 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -114,7 +114,7 @@ TEXT runtime·asminit(SB),NOSPLIT,$0-0
 
 // void gosave(Gobuf*)
 // save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), NOSPLIT, $-4-4
+TEXT runtime·gosave(SB),NOSPLIT,$-4-4
 	MOVW	0(FP), R0		// gobuf
 	MOVW	SP, gobuf_sp(R0)
 	MOVW	LR, gobuf_pc(R0)
@@ -127,7 +127,7 @@ TEXT runtime·gosave(SB), NOSPLIT, $-4-4
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), NOSPLIT, $-4-4
+TEXT runtime·gogo(SB),NOSPLIT,$-4-4
 	MOVW	0(FP), R1		// gobuf
 	MOVW	gobuf_g(R1), g
 	MOVW	0(g), R2		// make sure g != nil
@@ -151,7 +151,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $-4-4
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
-TEXT runtime·mcall(SB), NOSPLIT, $-4-4
+TEXT runtime·mcall(SB),NOSPLIT,$-4-4
 	// Save caller state in g->sched.
 	MOVW	SP, (g_sched+gobuf_sp)(g)
 	MOVW	LR, (g_sched+gobuf_pc)(g)
@@ -184,13 +184,13 @@ TEXT runtime·mcall(SB), NOSPLIT, $-4-4
 // lives at the bottom of the G stack from the one that lives
 // at the top of the M stack because the one at the top of
 // the M stack terminates the stack walk (see topofstack()).
-TEXT runtime·switchtoM(SB), NOSPLIT, $0-4
+TEXT runtime·switchtoM(SB),NOSPLIT,$0-4
 	MOVW	$0, R0
 	BL	(R0) // clobber lr to ensure push {lr} is kept
 	RET
 
 // func onM(fn func())
-TEXT runtime·onM(SB), NOSPLIT, $0-4
+TEXT runtime·onM(SB),NOSPLIT,$0-4
 	MOVW	fn+0(FP), R0	// R0 = fn
 	MOVW	g_m(g), R1	// R1 = m
 
@@ -300,7 +300,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$-4-0
 // with the desired args running the desired function.
 //
 // func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB), NOSPLIT, $-4-12
+TEXT runtime·newstackcall(SB),NOSPLIT,$-4-12
 	// Save our caller's state as the PC and SP to
 	// restore when returning from f.
 	MOVW	g_m(g), R8
@@ -348,7 +348,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $-4-12
 	MOVW	$NAME(SB), R1;	\
 	B	(R1)
 
-TEXT reflect·call(SB), NOSPLIT, $-4-16
+TEXT reflect·call(SB),NOSPLIT,$-4-16
 	MOVW	argsize+8(FP), R0
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -459,7 +459,7 @@ CALLFN(runtime·call1073741824, 1073741824)
 //
 // Lessstack can appear in stack traces for the same reason
 // as morestack; in that context, it has 0 arguments.
-TEXT runtime·lessstack(SB), NOSPLIT, $-4-0
+TEXT runtime·lessstack(SB),NOSPLIT,$-4-0
 	// Save return value in m->cret
 	MOVW	g_m(g), R8
 	MOVW	R0, m_cret(R8)
@@ -478,7 +478,7 @@ TEXT runtime·lessstack(SB), NOSPLIT, $-4-0
 // to load all registers simultaneously, so that a profiling
 // interrupt can never see mismatched SP/LR/PC.
 // (And double-check that pop is atomic in that way.)
-TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
+TEXT runtime·jmpdefer(SB),NOSPLIT,$0-8
 	MOVW	0(SP), LR
 	MOVW	$-4(LR), LR	// BL deferreturn
 	MOVW	fv+0(FP), R7
@@ -638,7 +638,7 @@ havem:
 	RET
 
 // void setg(G*); set g. for use by needm.
-TEXT runtime·setg(SB), NOSPLIT, $0-4
+TEXT runtime·setg(SB),NOSPLIT,$0-4
 	MOVW	gg+0(FP), g
 
 	// Save g to thread-local storage.
@@ -715,13 +715,13 @@ casfail:
 	MOVB	R0, ret+12(FP)
 	RET
 
-TEXT runtime·casuintptr(SB), NOSPLIT, $0-13
+TEXT runtime·casuintptr(SB),NOSPLIT,$0-13
 	B	runtime·cas(SB)
 
-TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $0-8
+TEXT runtime·atomicloaduintptr(SB),NOSPLIT,$0-8
 	B	runtime·atomicload(SB)
 
-TEXT runtime·atomicloaduint(SB), NOSPLIT, $0-8
+TEXT runtime·atomicloaduint(SB),NOSPLIT,$0-8
 	B	runtime·atomicload(SB)
 
 TEXT runtime·stackguard(SB),NOSPLIT,$0-8
@@ -874,7 +874,7 @@ _sib_notfound:
 	MOVW	R0, ret+12(FP)
 	RET
 
-TEXT runtime·timenow(SB), NOSPLIT, $0-0
+TEXT runtime·timenow(SB),NOSPLIT,$0-0
 	B	time·now(SB)
 
 // A Duff's device for zeroing memory.
@@ -885,7 +885,7 @@ TEXT runtime·timenow(SB), NOSPLIT, $0-0
 // R0: zero
 // R1: ptr to memory to be zeroed
 // R1 is updated as a side effect.
-TEXT runtime·duffzero(SB), NOSPLIT, $0-0
+TEXT runtime·duffzero(SB),NOSPLIT,$0-0
 	MOVW.P	R0, 4(R1)
 	MOVW.P	R0, 4(R1)
 	MOVW.P	R0, 4(R1)
@@ -1026,7 +1026,7 @@ TEXT runtime·duffzero(SB), NOSPLIT, $0-0
 // R1: ptr to source memory
 // R2: ptr to destination memory
 // R1 and R2 are updated as a side effect
-TEXT runtime·duffcopy(SB), NOSPLIT, $0-0
+TEXT runtime·duffcopy(SB),NOSPLIT,$0-0
 	MOVW.P	4(R1), R0
 	MOVW.P	R0, 4(R2)
 	MOVW.P	4(R1), R0
@@ -1285,7 +1285,7 @@ TEXT runtime·duffcopy(SB), NOSPLIT, $0-0
 	MOVW.P	R0, 4(R2)
 	RET
 
-TEXT runtime·fastrand1(SB), NOSPLIT, $-4-4
+TEXT runtime·fastrand1(SB),NOSPLIT,$-4-4
 	MOVW	g_m(g), R1
 	MOVW	m_fastrand(R1), R0
 	ADD.S	R0, R0
@@ -1294,9 +1294,19 @@ TEXT runtime·fastrand1(SB), NOSPLIT, $-4-4
 	MOVW	R0, ret+0(FP)
 	RET
 
-TEXT runtime·gocputicks(SB), NOSPLIT, $0
+TEXT runtime·gocputicks(SB),NOSPLIT,$0
 	B runtime·cputicks(SB)
 
-TEXT runtime·return0(SB), NOSPLIT, $0
+TEXT runtime·return0(SB),NOSPLIT,$0
 	MOVW	$0, R0
 	RET
+
+TEXT runtime·procyield(SB),NOSPLIT,$-4
+	MOVW	cycles+0(FP), R1
+	MOVW	$0, R0
+yieldloop:
+	CMP	R0, R1
+	B.NE	2(PC)
+	RET
+	SUB	$1, R1
+	B yieldloop
diff --git a/src/pkg/runtime/atomic.go b/src/pkg/runtime/atomic.go
new file mode 100644
index 0000000000..7e9d9b3aad
--- /dev/null
+++ b/src/pkg/runtime/atomic.go
@@ -0,0 +1,51 @@
+// 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 !arm
+
+package runtime
+
+import "unsafe"
+
+//go:noescape
+func xadd(ptr *uint32, delta int32) uint32
+
+//go:noescape
+func xadd64(ptr *uint64, delta int64) uint64
+
+//go:noescape
+func xchg(ptr *uint32, new uint32) uint32
+
+//go:noescape
+func xchg64(ptr *uint64, new uint64) uint64
+
+//go:noescape
+func xchgp(ptr unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
+
+//go:noescape
+func xchguintptr(ptr *uintptr, new uintptr) uintptr
+
+//go:noescape
+func atomicload(ptr *uint32) uint32
+
+//go:noescape
+func atomicload64(ptr *uint64) uint64
+
+//go:noescape
+func atomicloadp(ptr unsafe.Pointer) unsafe.Pointer
+
+//go:noescape
+func atomicor8(ptr *uint8, val uint8)
+
+//go:noescape
+func cas64(ptr *uint64, old, new uint64) bool
+
+//go:noescape
+func atomicstore(ptr *uint32, val uint32)
+
+//go:noescape
+func atomicstore64(ptr *uint64, val uint64)
+
+//go:noescape
+func atomicstorep(ptr unsafe.Pointer, val unsafe.Pointer)
diff --git a/src/pkg/runtime/atomic_arm.c b/src/pkg/runtime/atomic_arm.c
deleted file mode 100644
index 487b128cbb..0000000000
--- a/src/pkg/runtime/atomic_arm.c
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
-
-static struct {
-	Mutex l;
-	byte pad[CacheLineSize-sizeof(Mutex)];
-} locktab[57];
-
-#define LOCK(addr) (&locktab[((uintptr)(addr)>>3)%nelem(locktab)].l)
-
-// Atomic add and return new value.
-#pragma textflag NOSPLIT
-uint32
-runtime·xadd(uint32 volatile *val, int32 delta)
-{
-	uint32 oval, nval;
-
-	for(;;){
-		oval = *val;
-		nval = oval + delta;
-		if(runtime·cas(val, oval, nval))
-			return nval;
-	}
-}
-
-#pragma textflag NOSPLIT
-uint32
-runtime·xchg(uint32 volatile* addr, uint32 v)
-{
-	uint32 old;
-
-	for(;;) {
-		old = *addr;
-		if(runtime·cas(addr, old, v))
-			return old;
-	}
-}
-
-#pragma textflag NOSPLIT
-void*
-runtime·xchgp(void* volatile* addr, void* v)
-{
-	void *old;
-
-	for(;;) {
-		old = *addr;
-		if(runtime·casp(addr, old, v))
-			return old;
-	}
-}
-
-#pragma textflag NOSPLIT
-void*
-runtime·xchguintptr(void* volatile* addr, void* v)
-{
-	return (void*)runtime·xchg((uint32*)addr, (uint32)v);
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·procyield(uint32 cnt)
-{
-	uint32 volatile i;
-
-	for(i = 0; i < cnt; i++) {
-	}
-}
-
-#pragma textflag NOSPLIT
-uint32
-runtime·atomicload(uint32 volatile* addr)
-{
-	return runtime·xadd(addr, 0);
-}
-
-#pragma textflag NOSPLIT
-void*
-runtime·atomicloadp(void* volatile* addr)
-{
-	return (void*)runtime·xadd((uint32 volatile*)addr, 0);
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·atomicstorep(void* volatile* addr, void* v)
-{
-	void *old;
-
-	for(;;) {
-		old = *addr;
-		if(runtime·casp(addr, old, v))
-			return;
-	}
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·atomicstore(uint32 volatile* addr, uint32 v)
-{
-	uint32 old;
-	
-	for(;;) {
-		old = *addr;
-		if(runtime·cas(addr, old, v))
-			return;
-	}
-}
-
-#pragma textflag NOSPLIT
-bool
-runtime·cas64(uint64 volatile *addr, uint64 old, uint64 new)
-{
-	bool res;
-	
-	runtime·lock(LOCK(addr));
-	if(*addr == old) {
-		*addr = new;
-		res = true;
-	} else {
-		res = false;
-	}
-	runtime·unlock(LOCK(addr));
-	return res;
-}
-
-#pragma textflag NOSPLIT
-uint64
-runtime·xadd64(uint64 volatile *addr, int64 delta)
-{
-	uint64 res;
-	
-	runtime·lock(LOCK(addr));
-	res = *addr + delta;
-	*addr = res;
-	runtime·unlock(LOCK(addr));
-	return res;
-}
-
-#pragma textflag NOSPLIT
-uint64
-runtime·xchg64(uint64 volatile *addr, uint64 v)
-{
-	uint64 res;
-
-	runtime·lock(LOCK(addr));
-	res = *addr;
-	*addr = v;
-	runtime·unlock(LOCK(addr));
-	return res;
-}
-
-#pragma textflag NOSPLIT
-uint64
-runtime·atomicload64(uint64 volatile *addr)
-{
-	uint64 res;
-	
-	runtime·lock(LOCK(addr));
-	res = *addr;
-	runtime·unlock(LOCK(addr));
-	return res;
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·atomicstore64(uint64 volatile *addr, uint64 v)
-{
-	runtime·lock(LOCK(addr));
-	*addr = v;
-	runtime·unlock(LOCK(addr));
-}
-
-#pragma textflag NOSPLIT
-void
-runtime·atomicor8(byte volatile *addr, byte v)
-{
-	uint32 *addr32, old, word;
-
-	// Align down to 4 bytes and use 32-bit CAS.
-	addr32 = (uint32*)((uintptr)addr & ~3);
-	word = ((uint32)v) << (((uintptr)addr & 3) * 8);
-	for(;;) {
-		old = *addr32;
-		if(runtime·cas(addr32, old, old|word))
-			break;
-	}
-}
diff --git a/src/pkg/runtime/atomic_arm.go b/src/pkg/runtime/atomic_arm.go
new file mode 100644
index 0000000000..b1632cdd16
--- /dev/null
+++ b/src/pkg/runtime/atomic_arm.go
@@ -0,0 +1,155 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+var locktab [57]struct {
+	l   mutex
+	pad [_CacheLineSize - unsafe.Sizeof(mutex{})]byte
+}
+
+func addrLock(addr *uint64) *mutex {
+	return &locktab[(uintptr(unsafe.Pointer(addr))>>3)%uintptr(len(locktab))].l
+}
+
+// Atomic add and return new value.
+//go:nosplit
+func xadd(val *uint32, delta int32) uint32 {
+	for {
+		oval := *val
+		nval := oval + uint32(delta)
+		if cas(val, oval, nval) {
+			return nval
+		}
+	}
+}
+
+//go:nosplit
+func xchg(addr *uint32, v uint32) uint32 {
+	for {
+		old := *addr
+		if cas(addr, old, v) {
+			return old
+		}
+	}
+}
+
+//go:nosplit
+func xchgp(addr *unsafe.Pointer, v unsafe.Pointer) unsafe.Pointer {
+	for {
+		old := *addr
+		if casp(addr, old, v) {
+			return old
+		}
+	}
+}
+
+//go:nosplit
+func xchguintptr(addr *uintptr, v uintptr) uintptr {
+	return uintptr(xchg((*uint32)(unsafe.Pointer(addr)), uint32(v)))
+}
+
+//go:nosplit
+func atomicload(addr *uint32) uint32 {
+	return xadd(addr, 0)
+}
+
+//go:nosplit
+func atomicloadp(addr unsafe.Pointer) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(xadd((*uint32)(addr), 0)))
+}
+
+//go:nosplit
+func atomicstorep(addr unsafe.Pointer, v unsafe.Pointer) {
+	for {
+		old := *(*unsafe.Pointer)(addr)
+		if casp((*unsafe.Pointer)(addr), old, v) {
+			return
+		}
+	}
+}
+
+//go:nosplit
+func atomicstore(addr *uint32, v uint32) {
+	for {
+		old := *addr
+		if cas(addr, old, v) {
+			return
+		}
+	}
+}
+
+//go:nosplit
+func cas64(addr *uint64, old, new uint64) bool {
+	var ok bool
+	onM(func() {
+		lock(addrLock(addr))
+		if *addr == old {
+			*addr = new
+			ok = true
+		}
+		unlock(addrLock(addr))
+	})
+	return ok
+}
+
+//go:nosplit
+func xadd64(addr *uint64, delta int64) uint64 {
+	var r uint64
+	onM(func() {
+		lock(addrLock(addr))
+		r = *addr + uint64(delta)
+		*addr = r
+		unlock(addrLock(addr))
+	})
+	return r
+}
+
+//go:nosplit
+func xchg64(addr *uint64, v uint64) uint64 {
+	var r uint64
+	onM(func() {
+		lock(addrLock(addr))
+		r = *addr
+		*addr = v
+		unlock(addrLock(addr))
+	})
+	return r
+}
+
+//go:nosplit
+func atomicload64(addr *uint64) uint64 {
+	var r uint64
+	onM(func() {
+		lock(addrLock(addr))
+		r = *addr
+		unlock(addrLock(addr))
+	})
+	return r
+}
+
+//go:nosplit
+func atomicstore64(addr *uint64, v uint64) {
+	onM(func() {
+		lock(addrLock(addr))
+		*addr = v
+		unlock(addrLock(addr))
+	})
+}
+
+//go:nosplit
+func atomicor8(addr *uint8, v uint8) {
+	// Align down to 4 bytes and use 32-bit CAS.
+	uaddr := uintptr(unsafe.Pointer(addr))
+	addr32 := (*uint32)(unsafe.Pointer(uaddr &^ 3))
+	word := uint32(v) << ((uaddr & 3) * 8) // little endian
+	for {
+		old := *addr32
+		if cas(addr32, old, old|word) {
+			return
+		}
+	}
+}
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index c864bc93c0..86846f3e6d 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -87,6 +87,7 @@ runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **sp)
 	return 1;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·purgecachedstats(MCache *c)
 {
diff --git a/src/pkg/runtime/os_dragonfly.c b/src/pkg/runtime/os_dragonfly.c
index f93c02ce1c..7bde58f756 100644
--- a/src/pkg/runtime/os_dragonfly.c
+++ b/src/pkg/runtime/os_dragonfly.c
@@ -40,13 +40,38 @@ getncpu(void)
 		return 1;
 }
 
+static void futexsleep(void);
+
 #pragma textflag NOSPLIT
 void
 runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
 {
+	void (*fn)(void);
+
+	g->m->ptrarg[0] = addr;
+	g->m->scalararg[0] = val;
+	g->m->ptrarg[1] = &ns;
+
+	fn = futexsleep;
+	runtime·onM(&fn);
+}
+
+static void
+futexsleep(void)
+{
+	uint32 *addr;
+	uint32 val;
+	int64 ns;
 	int32 timeout = 0;
 	int32 ret;
 
+	addr = g->m->ptrarg[0];
+	val = g->m->scalararg[0];
+	ns = *(int64*)g->m->ptrarg[1];
+	g->m->ptrarg[0] = nil;
+	g->m->scalararg[0] = 0;
+	g->m->ptrarg[1] = nil;
+
 	if(ns >= 0) {
 		// The timeout is specified in microseconds - ensure that we
 		// do not end up dividing to zero, which would put us to sleep
diff --git a/src/pkg/runtime/os_freebsd.c b/src/pkg/runtime/os_freebsd.c
index ab1edcd93f..4c58b531ce 100644
--- a/src/pkg/runtime/os_freebsd.c
+++ b/src/pkg/runtime/os_freebsd.c
@@ -42,12 +42,37 @@ getncpu(void)
 // FreeBSD's umtx_op syscall is effectively the same as Linux's futex, and
 // thus the code is largely similar. See linux/thread.c and lock_futex.c for comments.
 
+static void futexsleep(void);
+
 #pragma textflag NOSPLIT
 void
 runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
 {
+	void (*fn)(void);
+
+	g->m->ptrarg[0] = addr;
+	g->m->scalararg[0] = val;
+	g->m->ptrarg[1] = &ns;
+
+	fn = futexsleep;
+	runtime·onM(&fn);
+}
+
+static void
+futexsleep(void)
+{
+	uint32 *addr;
+	uint32 val;
+	int64 ns;
 	int32 ret;
 	Timespec ts;
+	
+	addr = g->m->ptrarg[0];
+	val = g->m->scalararg[0];
+	ns = *(int64*)g->m->ptrarg[1];
+	g->m->ptrarg[0] = nil;
+	g->m->scalararg[0] = 0;
+	g->m->ptrarg[1] = nil;
 
 	if(ns < 0) {
 		ret = runtime·sys_umtx_op(addr, UMTX_OP_WAIT_UINT_PRIVATE, val, nil, nil);
diff --git a/src/pkg/runtime/os_netbsd.c b/src/pkg/runtime/os_netbsd.c
index 29ea0cb427..cee96ebed1 100644
--- a/src/pkg/runtime/os_netbsd.c
+++ b/src/pkg/runtime/os_netbsd.c
@@ -57,18 +57,23 @@ getncpu(void)
 		return 1;
 }
 
+#pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
 	return 1;
 }
 
-#pragma textflag NOSPLIT
-int32
-runtime·semasleep(int64 ns)
+static void
+semasleep(void)
 {
+	int64 ns;
 	Timespec ts;
 
+	ns = (int64)(uint32)g->m->scalararg[0] | (int64)(uint32)g->m->scalararg[1]<<32;
+	g->m->scalararg[0] = 0;
+	g->m->scalararg[1] = 0;
+
 	// spin-mutex lock
 	while(runtime·xchg(&g->m->waitsemalock, 1))
 		runtime·osyield();
@@ -115,7 +120,8 @@ runtime·semasleep(int64 ns)
 			g->m->waitsemacount--;
 			// spin-mutex unlock
 			runtime·atomicstore(&g->m->waitsemalock, 0);
-			return 0;  // semaphore acquired
+			g->m->scalararg[0] = 0; // semaphore acquired
+			return;
 		}
 
 		// semaphore not available.
@@ -128,13 +134,36 @@ runtime·semasleep(int64 ns)
 	// lock held but giving up
 	// spin-mutex unlock
 	runtime·atomicstore(&g->m->waitsemalock, 0);
-	return -1;
+	g->m->scalararg[0] = -1;
+	return;
 }
 
+#pragma textflag NOSPLIT
+int32
+runtime·semasleep(int64 ns)
+{
+	int32 r;
+	void (*fn)(void);
+
+	g->m->scalararg[0] = (uint32)ns;
+	g->m->scalararg[1] = (uint32)(ns>>32);
+	fn = semasleep;
+	runtime·onM(&fn);
+	r = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+	return r;
+}
+
+static void badsemawakeup(void);
+
+#pragma textflag NOSPLIT
 void
 runtime·semawakeup(M *mp)
 {
 	uint32 ret;
+	void (*fn)(void);
+	void *oldptr;
+	uintptr oldscalar;
 
 	// spin-mutex lock
 	while(runtime·xchg(&mp->waitsemalock, 1))
@@ -143,12 +172,39 @@ runtime·semawakeup(M *mp)
 	// TODO(jsing) - potential deadlock, see semasleep() for details.
 	// Confirm that LWP is parked before unparking...
 	ret = runtime·lwp_unpark(mp->procid, &mp->waitsemacount);
-	if(ret != 0 && ret != ESRCH)
-		runtime·printf("thrwakeup addr=%p sem=%d ret=%d\n", &mp->waitsemacount, mp->waitsemacount, ret);
+	if(ret != 0 && ret != ESRCH) {
+		// semawakeup can be called on signal stack.
+		// Save old ptrarg/scalararg so we can restore them.
+		oldptr = g->m->ptrarg[0];
+		oldscalar = g->m->scalararg[0];
+		g->m->ptrarg[0] = mp;
+		g->m->scalararg[0] = ret;
+		fn = badsemawakeup;
+		if(g == g->m->gsignal)
+			fn();
+		else
+			runtime·onM(&fn);
+		g->m->ptrarg[0] = oldptr;
+		g->m->scalararg[0] = oldscalar;
+	}
 	// spin-mutex unlock
 	runtime·atomicstore(&mp->waitsemalock, 0);
 }
 
+static void
+badsemawakeup(void)
+{
+	M *mp;
+	int32 ret;
+
+	mp = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	ret = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+
+	runtime·printf("thrwakeup addr=%p sem=%d ret=%d\n", &mp->waitsemacount, mp->waitsemacount, ret);
+}
+
 void
 runtime·newosproc(M *mp, void *stk)
 {
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index 728cb88c4c..7c9e478e84 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -54,6 +54,7 @@ getncpu(void)
 		return 1;
 }
 
+#pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
@@ -111,22 +112,55 @@ runtime·semasleep(int64 ns)
 	return -1;
 }
 
+static void badsemawakeup(void);
+
+#pragma textflag NOSPLIT
 void
 runtime·semawakeup(M *mp)
 {
 	uint32 ret;
+	void *oldptr;
+	uint32 oldscalar;
+	void (*fn)(void);
 
 	// spin-mutex lock
 	while(runtime·xchg(&mp->waitsemalock, 1))
 		runtime·osyield();
 	mp->waitsemacount++;
 	ret = runtime·thrwakeup(&mp->waitsemacount, 1);
-	if(ret != 0 && ret != ESRCH)
-		runtime·printf("thrwakeup addr=%p sem=%d ret=%d\n", &mp->waitsemacount, mp->waitsemacount, ret);
+	if(ret != 0 && ret != ESRCH) {
+		// semawakeup can be called on signal stack.
+		// Save old ptrarg/scalararg so we can restore them.
+		oldptr = g->m->ptrarg[0];
+		oldscalar = g->m->scalararg[0];
+		g->m->ptrarg[0] = mp;
+		g->m->scalararg[0] = ret;
+		fn = badsemawakeup;
+		if(g == g->m->gsignal)
+			fn();
+		else
+			runtime·onM(&fn);
+		g->m->ptrarg[0] = oldptr;
+		g->m->scalararg[0] = oldscalar;
+	}
 	// spin-mutex unlock
 	runtime·atomicstore(&mp->waitsemalock, 0);
 }
 
+static void
+badsemawakeup(void)
+{
+	M *mp;
+	int32 ret;
+
+	mp = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	ret = g->m->scalararg[0];
+	g->m->scalararg[0] = 0;
+
+	runtime·printf("thrwakeup addr=%p sem=%d ret=%d\n", &mp->waitsemacount, mp->waitsemacount, ret);
+}
+
 void
 runtime·newosproc(M *mp, void *stk)
 {
diff --git a/src/pkg/runtime/os_plan9.c b/src/pkg/runtime/os_plan9.c
index efff24ea09..bae4549a6e 100644
--- a/src/pkg/runtime/os_plan9.c
+++ b/src/pkg/runtime/os_plan9.c
@@ -160,6 +160,7 @@ runtime·nanotime(void)
 	return ns;
 }
 
+#pragma textflag NOSPLIT
 void
 time·now(int64 sec, int32 nsec)
 {
@@ -172,6 +173,7 @@ time·now(int64 sec, int32 nsec)
 	FLUSH(&nsec);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·itoa(int32 n, byte *p, uint32 len)
 {
@@ -252,12 +254,29 @@ runtime·postnote(int32 pid, int8* msg)
 	return 0;
 }
 
+static void exit(void);
+
+#pragma textflag NOSPLIT
 void
 runtime·exit(int32 e)
 {
+	void (*fn)(void);
+
+	g->m->scalararg[0] = e;
+	fn = exit;
+	runtime·onM(&fn);
+}
+
+static void
+exit(void)
+{
+	int32 e;
 	byte tmp[16];
 	int8 *status;
  
+ 	e = g->m->scalararg[0];
+ 	g->m->scalararg[0] = 0;
+
 	if(e == 0)
 		status = "";
 	else {
@@ -283,6 +302,7 @@ runtime·newosproc(M *mp, void *stk)
 		runtime·throw("newosproc: rfork failed");
 }
 
+#pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
@@ -312,6 +332,7 @@ runtime·semasleep(int64 ns)
 	return 0;  // success
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·semawakeup(M *mp)
 {
@@ -396,12 +417,14 @@ runtime·sigpanic(void)
 	}
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·read(int32 fd, void *buf, int32 nbytes)
 {
 	return runtime·pread(fd, buf, nbytes, -1LL);
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·write(uintptr fd, void *buf, int32 nbytes)
 {
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 0c72e4bd06..3fecfe90e4 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2623,20 +2623,6 @@ runtime·mcount(void)
 	return runtime·sched.mcount;
 }
 
-void
-runtime·badmcall(void (*fn)(G*))  // called from assembly
-{
-	USED(fn); // TODO: print fn?
-	runtime·throw("runtime: mcall called on m->g0 stack");
-}
-
-void
-runtime·badmcall2(void (*fn)(G*))  // called from assembly
-{
-	USED(fn);
-	runtime·throw("runtime: mcall function returned");
-}
-
 void
 runtime·badreflectcall(void) // called from assembly
 {
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index 4789a51b66..d02f7ed7c9 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -91,3 +91,12 @@ func releaseSudog(s *sudog) {
 func funcPC(f interface{}) uintptr {
 	return **(**uintptr)(add(unsafe.Pointer(&f), ptrSize))
 }
+
+// called from assembly
+func badmcall(fn func(*g)) {
+	gothrow("runtime: mcall called on m->g0 stack")
+}
+
+func badmcall2(fn func(*g)) {
+	gothrow("runtime: mcall function returned")
+}
diff --git a/src/pkg/runtime/softfloat_arm.c b/src/pkg/runtime/softfloat_arm.c
index 6b37160114..5e5f4025ec 100644
--- a/src/pkg/runtime/softfloat_arm.c
+++ b/src/pkg/runtime/softfloat_arm.c
@@ -606,20 +606,43 @@ struct Sfregs
 	uint32 cspr;
 };
 
+static void sfloat2(void);
+
 #pragma textflag NOSPLIT
 uint32*
 runtime·_sfloat2(uint32 *lr, Sfregs regs)
 {
-	uint32 skip;
+	void (*fn)(void);
+	
+	g->m->ptrarg[0] = lr;
+	g->m->ptrarg[1] = &regs;
+	fn = sfloat2;
+	runtime·onM(&fn);
+	lr = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	return lr;
+}
 
-	skip = stepflt(lr, (uint32*)&regs.r0);
+static void
+sfloat2(void)
+{
+	uint32 *lr;
+	Sfregs *regs;
+	uint32 skip;
+	
+	lr = g->m->ptrarg[0];
+	regs = g->m->ptrarg[1];
+	g->m->ptrarg[0] = nil;
+	g->m->ptrarg[1] = nil;
+
+	skip = stepflt(lr, (uint32*)&regs->r0);
 	if(skip == 0) {
 		runtime·printf("sfloat2 %p %x\n", lr, *lr);
 		fabort(); // not ok to fail first instruction
 	}
 
 	lr += skip;
-	while(skip = stepflt(lr, (uint32*)&regs.r0))
+	while(skip = stepflt(lr, (uint32*)&regs->r0))
 		lr += skip;
-	return lr;
+	g->m->ptrarg[0] = lr;
 }
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 7d59b5c19b..8e67114f33 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -174,8 +174,8 @@ func munmap(addr unsafe.Pointer, n uintptr)
 func madvise(addr unsafe.Pointer, n uintptr, flags int32)
 func newstackcall(fv *funcval, addr unsafe.Pointer, size uint32)
 func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
-func procyield(cycles uint32)
 func osyield()
+func procyield(cycles uint32)
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
 func readgogc() int32
 func purgecachedstats(c *mcache)
@@ -188,63 +188,21 @@ func write(fd uintptr, p unsafe.Pointer, n int32) int32
 //go:noescape
 func cas(ptr *uint32, old, new uint32) bool
 
-//go:noescape
-func cas64(ptr *uint64, old, new uint64) bool
-
 //go:noescape
 func casp(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
 
 //go:noescape
 func casuintptr(ptr *uintptr, old, new uintptr) bool
 
-//go:noescape
-func xadd(ptr *uint32, delta int32) uint32
-
-//go:noescape
-func xadd64(ptr *uint64, delta int64) uint64
-
-//go:noescape
-func xchg(ptr *uint32, new uint32) uint32
-
-//go:noescape
-func xchg64(ptr *uint64, new uint64) uint64
-
-//go:noescape
-func xchgp(ptr unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer
-
-//go:noescape
-func xchguintptr(ptr *uintptr, new uintptr) uintptr
-
-//go:noescape
-func atomicstore(ptr *uint32, val uint32)
-
-//go:noescape
-func atomicstore64(ptr *uint64, val uint64)
-
-//go:noescape
-func atomicstorep(ptr unsafe.Pointer, val unsafe.Pointer)
-
 //go:noescape
 func atomicstoreuintptr(ptr *uintptr, new uintptr)
 
-//go:noescape
-func atomicload(ptr *uint32) uint32
-
-//go:noescape
-func atomicload64(ptr *uint64) uint64
-
-//go:noescape
-func atomicloadp(ptr unsafe.Pointer) unsafe.Pointer
-
 //go:noescape
 func atomicloaduintptr(ptr *uintptr) uintptr
 
 //go:noescape
 func atomicloaduint(ptr *uint) uint
 
-//go:noescape
-func atomicor8(ptr *uint8, val uint8)
-
 //go:noescape
 func setcallerpc(argp unsafe.Pointer, pc uintptr)
 
diff --git a/src/pkg/runtime/vlrt.c b/src/pkg/runtime/vlrt.c
index d4367c30e6..486555dda3 100644
--- a/src/pkg/runtime/vlrt.c
+++ b/src/pkg/runtime/vlrt.c
@@ -413,6 +413,7 @@ _modv(Vlong n, Vlong d)
 	return r;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _rshav(Vlong a, int b)
 {
@@ -440,6 +441,7 @@ _rshav(Vlong a, int b)
 	return r;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _rshlv(Vlong a, int b)
 {
@@ -487,6 +489,7 @@ _lshv(Vlong a, int b)
 	return (Vlong){t<<b, (t >> (32-b)) | (a.hi << b)};
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _andv(Vlong a, Vlong b)
 {
@@ -497,6 +500,7 @@ _andv(Vlong a, Vlong b)
 	return r;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _orv(Vlong a, Vlong b)
 {
@@ -507,6 +511,7 @@ _orv(Vlong a, Vlong b)
 	return r;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _xorv(Vlong a, Vlong b)
 {
@@ -529,6 +534,7 @@ _vpp(Vlong *r)
 	return l;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _vmm(Vlong *r)
 {
@@ -541,6 +547,7 @@ _vmm(Vlong *r)
 	return l;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _ppv(Vlong *r)
 {
@@ -551,6 +558,7 @@ _ppv(Vlong *r)
 	return *r;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _mmv(Vlong *r)
 {
@@ -642,6 +650,7 @@ _vasop(void *lv, Vlong fn(Vlong, Vlong), int type, Vlong rv)
 	return u;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _p2v(void *p)
 {
@@ -654,6 +663,7 @@ _p2v(void *p)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _sl2v(long sl)
 {
@@ -666,6 +676,7 @@ _sl2v(long sl)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _ul2v(ulong ul)
 {
@@ -685,6 +696,7 @@ _si2v(int si)
 	return (Vlong){si, si>>31};
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _ui2v(uint ui)
 {
@@ -697,6 +709,7 @@ _ui2v(uint ui)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _sh2v(long sh)
 {
@@ -709,6 +722,7 @@ _sh2v(long sh)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _uh2v(ulong ul)
 {
@@ -721,6 +735,7 @@ _uh2v(ulong ul)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _sc2v(long uc)
 {
@@ -733,6 +748,7 @@ _sc2v(long uc)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 Vlong
 _uc2v(ulong ul)
 {
@@ -745,6 +761,7 @@ _uc2v(ulong ul)
 	return ret;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2sc(Vlong rv)
 {
@@ -754,6 +771,7 @@ _v2sc(Vlong rv)
 	return (t << 24) >> 24;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2uc(Vlong rv)
 {
@@ -761,6 +779,7 @@ _v2uc(Vlong rv)
 	return rv.lo & 0xff;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2sh(Vlong rv)
 {
@@ -770,6 +789,7 @@ _v2sh(Vlong rv)
 	return (t << 16) >> 16;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2uh(Vlong rv)
 {
@@ -777,6 +797,7 @@ _v2uh(Vlong rv)
 	return rv.lo & 0xffff;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2sl(Vlong rv)
 {
@@ -784,6 +805,7 @@ _v2sl(Vlong rv)
 	return rv.lo;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2ul(Vlong rv)
 {
@@ -798,6 +820,7 @@ _v2si(Vlong rv)
 	return rv.lo;
 }
 
+#pragma textflag NOSPLIT
 long
 _v2ui(Vlong rv)
 {
@@ -805,24 +828,28 @@ _v2ui(Vlong rv)
 	return rv.lo;
 }
 
+#pragma textflag NOSPLIT
 int
 _testv(Vlong rv)
 {
 	return rv.lo || rv.hi;
 }
 
+#pragma textflag NOSPLIT
 int
 _eqv(Vlong lv, Vlong rv)
 {
 	return lv.lo == rv.lo && lv.hi == rv.hi;
 }
 
+#pragma textflag NOSPLIT
 int
 _nev(Vlong lv, Vlong rv)
 {
 	return lv.lo != rv.lo || lv.hi != rv.hi;
 }
 
+#pragma textflag NOSPLIT
 int
 _ltv(Vlong lv, Vlong rv)
 {
@@ -830,6 +857,7 @@ _ltv(Vlong lv, Vlong rv)
 		(lv.hi == rv.hi && lv.lo < rv.lo);
 }
 
+#pragma textflag NOSPLIT
 int
 _lev(Vlong lv, Vlong rv)
 {
@@ -837,6 +865,7 @@ _lev(Vlong lv, Vlong rv)
 		(lv.hi == rv.hi && lv.lo <= rv.lo);
 }
 
+#pragma textflag NOSPLIT
 int
 _gtv(Vlong lv, Vlong rv)
 {
@@ -852,6 +881,7 @@ _gev(Vlong lv, Vlong rv)
 		(lv.hi == rv.hi && lv.lo >= rv.lo);
 }
 
+#pragma textflag NOSPLIT
 int
 _lov(Vlong lv, Vlong rv)
 {
@@ -859,6 +889,7 @@ _lov(Vlong lv, Vlong rv)
 		(lv.hi == rv.hi && lv.lo < rv.lo);
 }
 
+#pragma textflag NOSPLIT
 int
 _lsv(Vlong lv, Vlong rv)
 {
@@ -866,6 +897,7 @@ _lsv(Vlong lv, Vlong rv)
 		(lv.hi == rv.hi && lv.lo <= rv.lo);
 }
 
+#pragma textflag NOSPLIT
 int
 _hiv(Vlong lv, Vlong rv)
 {
@@ -873,6 +905,7 @@ _hiv(Vlong lv, Vlong rv)
 		(lv.hi == rv.hi && lv.lo > rv.lo);
 }
 
+#pragma textflag NOSPLIT
 int
 _hsv(Vlong lv, Vlong rv)
 {

From 99a08262af725e542327f09d4a1cedf2a8caefe2 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 21:12:48 -0400
Subject: [PATCH 384/423] runtime: mark sysAlloc nosplit

sysAlloc is the only mem function called from Go.

LGTM=iant, khr
R=golang-codereviews, khr, 0intro, iant
CC=dvyukov, golang-codereviews, r
https://golang.org/cl/139210043
---
 src/pkg/runtime/mem_darwin.c    |  2 ++
 src/pkg/runtime/mem_dragonfly.c |  2 ++
 src/pkg/runtime/mem_freebsd.c   |  2 ++
 src/pkg/runtime/mem_linux.c     |  2 ++
 src/pkg/runtime/mem_nacl.c      |  2 ++
 src/pkg/runtime/mem_netbsd.c    |  2 ++
 src/pkg/runtime/mem_openbsd.c   |  2 ++
 src/pkg/runtime/mem_plan9.c     | 32 ++++++++++++++++++++++++++++----
 src/pkg/runtime/mem_solaris.c   |  2 ++
 src/pkg/runtime/mem_windows.c   |  2 ++
 10 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/src/pkg/runtime/mem_darwin.c b/src/pkg/runtime/mem_darwin.c
index ca0ac72de9..72a2d18ad6 100644
--- a/src/pkg/runtime/mem_darwin.c
+++ b/src/pkg/runtime/mem_darwin.c
@@ -7,7 +7,9 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_dragonfly.c b/src/pkg/runtime/mem_dragonfly.c
index 55410cef64..11457b2c03 100644
--- a/src/pkg/runtime/mem_dragonfly.c
+++ b/src/pkg/runtime/mem_dragonfly.c
@@ -7,12 +7,14 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "textflag.h"
 
 enum
 {
 	ENOMEM = 12,
 };
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_freebsd.c b/src/pkg/runtime/mem_freebsd.c
index a033bfcdc0..18a9a2f5b3 100644
--- a/src/pkg/runtime/mem_freebsd.c
+++ b/src/pkg/runtime/mem_freebsd.c
@@ -7,12 +7,14 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "textflag.h"
 
 enum
 {
 	ENOMEM = 12,
 };
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_linux.c b/src/pkg/runtime/mem_linux.c
index 429f820f8b..01e7707bbc 100644
--- a/src/pkg/runtime/mem_linux.c
+++ b/src/pkg/runtime/mem_linux.c
@@ -7,6 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
 enum
 {
@@ -57,6 +58,7 @@ mmap_fixed(byte *v, uintptr n, int32 prot, int32 flags, int32 fd, uint32 offset)
 	return p;
 }
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_nacl.c b/src/pkg/runtime/mem_nacl.c
index 5c5f806324..968fe8da54 100644
--- a/src/pkg/runtime/mem_nacl.c
+++ b/src/pkg/runtime/mem_nacl.c
@@ -7,12 +7,14 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
 enum
 {
 	Debug = 0,
 };
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_netbsd.c b/src/pkg/runtime/mem_netbsd.c
index cf4b24f920..8d04c832ce 100644
--- a/src/pkg/runtime/mem_netbsd.c
+++ b/src/pkg/runtime/mem_netbsd.c
@@ -7,12 +7,14 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
 enum
 {
 	ENOMEM = 12,
 };
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_openbsd.c b/src/pkg/runtime/mem_openbsd.c
index cf4b24f920..8d04c832ce 100644
--- a/src/pkg/runtime/mem_openbsd.c
+++ b/src/pkg/runtime/mem_openbsd.c
@@ -7,12 +7,14 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
 enum
 {
 	ENOMEM = 12,
 };
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_plan9.c b/src/pkg/runtime/mem_plan9.c
index aec652995f..4f753adb4d 100644
--- a/src/pkg/runtime/mem_plan9.c
+++ b/src/pkg/runtime/mem_plan9.c
@@ -7,6 +7,7 @@
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "os_GOOS.h"
+#include "../../cmd/ld/textflag.h"
 
 extern byte runtime·end[];
 static byte *bloc = { runtime·end };
@@ -31,18 +32,41 @@ brk(uintptr nbytes)
 	}
 	bloc = (byte*)bl + nbytes;
 	runtime·unlock(&memlock);
-	return (void*)bl;
-	
+	return (void*)bl;	
 }
 
-void*
-runtime·sysAlloc(uintptr nbytes, uint64 *stat)
+static void
+sysalloc(void)
 {
+	uintptr nbytes;
+	uint64 *stat;
 	void *p;
 
+	nbytes = g->m->scalararg[0];
+	stat = g->m->ptrarg[0];
+	g->m->scalararg[0] = 0;
+	g->m->ptrarg[0] = nil;
+
 	p = brk(nbytes);
 	if(p != nil)
 		runtime·xadd64(stat, nbytes);
+
+	g->m->ptrarg[0] = p;
+}
+
+#pragma textflag NOSPLIT
+void*
+runtime·sysAlloc(uintptr nbytes, uint64 *stat)
+{
+	void (*fn)(void);
+	void *p;
+
+	g->m->scalararg[0] = nbytes;
+	g->m->ptrarg[0] = stat;
+	fn = sysalloc;
+	runtime·onM(&fn);
+	p = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
 	return p;
 }
 
diff --git a/src/pkg/runtime/mem_solaris.c b/src/pkg/runtime/mem_solaris.c
index 87536f6837..01cbe9e1a4 100644
--- a/src/pkg/runtime/mem_solaris.c
+++ b/src/pkg/runtime/mem_solaris.c
@@ -7,12 +7,14 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
 enum
 {
 	ENOMEM = 12,
 };
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {
diff --git a/src/pkg/runtime/mem_windows.c b/src/pkg/runtime/mem_windows.c
index cb1c9de907..33ce003d28 100644
--- a/src/pkg/runtime/mem_windows.c
+++ b/src/pkg/runtime/mem_windows.c
@@ -7,6 +7,7 @@
 #include "os_GOOS.h"
 #include "defs_GOOS_GOARCH.h"
 #include "malloc.h"
+#include "../../cmd/ld/textflag.h"
 
 enum {
 	MEM_COMMIT = 0x1000,
@@ -25,6 +26,7 @@ extern void *runtime·VirtualAlloc;
 extern void *runtime·VirtualFree;
 extern void *runtime·VirtualProtect;
 
+#pragma textflag NOSPLIT
 void*
 runtime·sysAlloc(uintptr n, uint64 *stat)
 {

From 73a6d36d872b00fe873f70fe6c36333ea5c7b65f Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 21:22:18 -0400
Subject: [PATCH 385/423] cmd/dist: make textflag.h available in runtime, avoid
 android/linux conflicts

1) cmd/dist was copying textflag.h to the build include directory,
but only after compiling package runtime. So other packages could
use it, just not runtime. Copy earlier, so that runtime can use it too.

2) We decided for android that anything marked linux is also included
in the build. The generated linux-specific files in cmd/dist must therefore
have explicit +build !android tags, or else you can't have simultaneous
linux/arm and android/arm builds in a single client. The tag was already
there for at least one file, but it was missing from many others.

LGTM=r
R=r
CC=golang-codereviews
https://golang.org/cl/134500043
---
 src/cmd/dist/build.c        |  7 +++----
 src/cmd/dist/buildruntime.c | 18 ++++++++++++++++--
 src/cmd/dist/goc2c.c        |  4 ++++
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/src/cmd/dist/build.c b/src/cmd/dist/build.c
index 11fecbfad6..70c2da432b 100644
--- a/src/cmd/dist/build.c
+++ b/src/cmd/dist/build.c
@@ -897,6 +897,8 @@ install(char *dir)
 			bpathf(&b1, "%s/os_%s.h", bstr(&path), goos), 0);
 		copy(bpathf(&b, "%s/signals_GOOS.h", workdir),
 			bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos), 0);
+		copy(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
+			bpathf(&b1, "%s/src/cmd/ld/textflag.h", goroot), 0);
 	}
 
 	// Generate any missing files; regenerate existing ones.
@@ -1119,15 +1121,12 @@ install(char *dir)
 
 nobuild:
 	// In package runtime, we install runtime.h and cgocall.h too,
-	// for use by cgo compilation. For assembler source, we also
-	// copy cmd/ld/textflag.h.
+	// for use by cgo compilation.
 	if(streq(dir, "pkg/runtime")) {
 		copy(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot), 0);
 		copy(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot), 0);
-		copy(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
-			bpathf(&b1, "%s/src/cmd/ld/textflag.h", goroot), 0);
 	}
 
 
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index ade91024dc..751a83f5ac 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -112,7 +112,7 @@ mkzgoos(char *dir, char *file)
 
 	bwritestr(&out, "// auto generated by go tool dist\n\n");
 
-	if (streq(goos, "linux")) {
+	if(streq(goos, "linux")) {
 		bwritestr(&out, "// +build !android\n\n");
 	}
 	
@@ -174,6 +174,10 @@ mkzasm(char *dir, char *file)
 	vinit(&fields);
 	
 	bwritestr(&out, "// auto generated by go tool dist\n\n");
+	if(streq(goos, "linux")) {
+		bwritestr(&out, "// +build !android\n\n");
+	}
+	
 	for(i=0; i<nelem(zasmhdr); i++) {
 		if(hasprefix(goarch, zasmhdr[i].goarch) && hasprefix(goos, zasmhdr[i].goos)) {
 			bwritestr(&out, zasmhdr[i].hdr);
@@ -287,6 +291,10 @@ mkzsys(char *dir, char *file)
 	binit(&out);
 	
 	bwritestr(&out, "// auto generated by go tool dist\n\n");
+	if(streq(goos, "linux")) {
+		bwritestr(&out, "// +build !android\n\n");
+	}
+	
 	if(streq(goos, "windows")) {
 		bwritef(&out,
 			"// runtime·callbackasm is called by external code to\n"
@@ -339,7 +347,13 @@ mkzruntimedefs(char *dir, char *file)
 	vinit(&seen);
 	
 	bwritestr(&out, "// auto generated by go tool dist\n"
-		"\n"
+		"\n");
+
+	if(streq(goos, "linux")) {
+		bwritestr(&out, "// +build !android\n\n");
+	}
+	
+	bwritestr(&out,
 		"package runtime\n"
 		"import \"unsafe\"\n"
 		"var _ unsafe.Pointer\n"
diff --git a/src/cmd/dist/goc2c.c b/src/cmd/dist/goc2c.c
index a24fbfe204..ddf70411c8 100644
--- a/src/cmd/dist/goc2c.c
+++ b/src/cmd/dist/goc2c.c
@@ -825,6 +825,10 @@ goc2c(char *goc, char *goc_final, char *c)
 	}
 
 	bprintf(&out, "// auto generated by go tool dist\n// goos=%s goarch=%s\n\n", goos, goarch);
+	if(streq(goos, "linux")) {
+		bwritestr(&out, "// +build !android\n\n");
+	}
+	
 	input = bstr(&in);
 	output = &out;
 

From cf3fd0a55fde7c8bf579bdcab663890404a337c4 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 21:56:11 -0400
Subject: [PATCH 386/423] cmd/dist: another attempt at textflag.h

The old change worked fine in my client, but my client
must not have been in a completely clean state.

TBR=r
CC=golang-codereviews
https://golang.org/cl/138100043
---
 src/cmd/dist/a.h            |  1 +
 src/cmd/dist/build.c        | 25 ++++++++++++-------------
 src/cmd/dist/buildruntime.c | 11 ++++++++++-
 3 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/src/cmd/dist/a.h b/src/cmd/dist/a.h
index 2500f038c8..6f7a2d1b95 100644
--- a/src/cmd/dist/a.h
+++ b/src/cmd/dist/a.h
@@ -129,6 +129,7 @@ bool	isfile(char *p);
 char*	lastelem(char*);
 Time	mtime(char*);
 void	readfile(Buf*, char*);
+void	copyfile(char*, char*, int);
 void	run(Buf *b, char *dir, int mode, char *cmd, ...);
 void	runv(Buf *b, char *dir, int mode, Vec *argv);
 void	bgrunv(char *dir, int mode, Vec *argv);
diff --git a/src/cmd/dist/build.c b/src/cmd/dist/build.c
index 70c2da432b..2e9c6b6e6a 100644
--- a/src/cmd/dist/build.c
+++ b/src/cmd/dist/build.c
@@ -35,7 +35,6 @@ bool	rebuildall;
 bool defaultclang;
 
 static bool shouldbuild(char*, char*);
-static void copy(char*, char*, int);
 static void dopack(char*, char*, char**, int);
 static char *findgoversion(void);
 
@@ -674,7 +673,7 @@ install(char *dir)
 
 	// For misc/prof, copy into the tool directory and we're done.
 	if(hasprefix(dir, "misc/")) {
-		copy(bpathf(&b, "%s/%s", tooldir, name),
+		copyfile(bpathf(&b, "%s/%s", tooldir, name),
 			bpathf(&b1, "%s/misc/%s", goroot, name), 1);
 		goto out;
 	}
@@ -886,18 +885,18 @@ install(char *dir)
 
 	// For package runtime, copy some files into the work space.
 	if(streq(dir, "pkg/runtime")) {
-		copy(bpathf(&b, "%s/arch_GOARCH.h", workdir),
+		copyfile(bpathf(&b, "%s/arch_GOARCH.h", workdir),
 			bpathf(&b1, "%s/arch_%s.h", bstr(&path), goarch), 0);
-		copy(bpathf(&b, "%s/defs_GOOS_GOARCH.h", workdir),
+		copyfile(bpathf(&b, "%s/defs_GOOS_GOARCH.h", workdir),
 			bpathf(&b1, "%s/defs_%s_%s.h", bstr(&path), goos, goarch), 0);
 		p = bpathf(&b1, "%s/signal_%s_%s.h", bstr(&path), goos, goarch);
 		if(isfile(p))
-			copy(bpathf(&b, "%s/signal_GOOS_GOARCH.h", workdir), p, 0);
-		copy(bpathf(&b, "%s/os_GOOS.h", workdir),
+			copyfile(bpathf(&b, "%s/signal_GOOS_GOARCH.h", workdir), p, 0);
+		copyfile(bpathf(&b, "%s/os_GOOS.h", workdir),
 			bpathf(&b1, "%s/os_%s.h", bstr(&path), goos), 0);
-		copy(bpathf(&b, "%s/signals_GOOS.h", workdir),
+		copyfile(bpathf(&b, "%s/signals_GOOS.h", workdir),
 			bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos), 0);
-		copy(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
+		copyfile(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/cmd/ld/textflag.h", goroot), 0);
 	}
 
@@ -932,7 +931,7 @@ install(char *dir)
 	// The last batch was required for the generators.
 	// This one is generated.
 	if(streq(dir, "pkg/runtime")) {
-		copy(bpathf(&b, "%s/zasm_GOOS_GOARCH.h", workdir),
+		copyfile(bpathf(&b, "%s/zasm_GOOS_GOARCH.h", workdir),
 			bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch), 0);
 	}
 
@@ -1123,9 +1122,9 @@ nobuild:
 	// In package runtime, we install runtime.h and cgocall.h too,
 	// for use by cgo compilation.
 	if(streq(dir, "pkg/runtime")) {
-		copy(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch),
+		copyfile(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot), 0);
-		copy(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch),
+		copyfile(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch),
 			bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot), 0);
 	}
 
@@ -1248,8 +1247,8 @@ out:
 }
 
 // copy copies the file src to dst, via memory (so only good for small files).
-static void
-copy(char *dst, char *src, int exec)
+void
+copyfile(char *dst, char *src, int exec)
 {
 	Buf b;
 
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index 751a83f5ac..3a274e05cc 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -162,11 +162,12 @@ mkzasm(char *dir, char *file)
 {
 	int i, n;
 	char *aggr, *p;
-	Buf in, b, out, exp;
+	Buf in, b, b1, out, exp;
 	Vec argv, lines, fields;
 
 	binit(&in);
 	binit(&b);
+	binit(&b1);
 	binit(&out);
 	binit(&exp);
 	vinit(&argv);
@@ -187,6 +188,9 @@ mkzasm(char *dir, char *file)
 	fatal("unknown $GOOS/$GOARCH in mkzasm");
 ok:
 
+	copyfile(bpathf(&b, "%s/pkg/%s_%s/textflag.h", goroot, goos, goarch),
+		bpathf(&b1, "%s/src/cmd/ld/textflag.h", goroot), 0);
+
 	// Run 6c -D GOOS_goos -D GOARCH_goarch -I workdir -a -n -o workdir/proc.acid proc.c
 	// to get acid [sic] output. Run once without the -a -o workdir/proc.acid in order to
 	// report compilation failures (the -o redirects all messages, unfortunately).
@@ -198,6 +202,8 @@ ok:
 	vadd(&argv, bprintf(&b, "GOARCH_%s", goarch));
 	vadd(&argv, "-I");
 	vadd(&argv, bprintf(&b, "%s", workdir));
+	vadd(&argv, "-I");
+	vadd(&argv, bprintf(&b, "%s/pkg/%s_%s", goroot, goos, goarch));
 	vadd(&argv, "-n");
 	vadd(&argv, "-a");
 	vadd(&argv, "-o");
@@ -270,6 +276,7 @@ ok:
 
 	bfree(&in);
 	bfree(&b);
+	bfree(&b1);
 	bfree(&out);
 	bfree(&exp);
 	vfree(&argv);
@@ -375,6 +382,8 @@ mkzruntimedefs(char *dir, char *file)
 	vadd(&argv, bprintf(&b, "GOARCH_%s", goarch));
 	vadd(&argv, "-I");
 	vadd(&argv, bprintf(&b, "%s", workdir));
+	vadd(&argv, "-I");
+	vadd(&argv, bprintf(&b, "%s/pkg/%s_%s", goroot, goos, goarch));
 	vadd(&argv, "-q");
 	vadd(&argv, "-n");
 	vadd(&argv, "-o");

From d16a2ad09b373efe891f0acf9c27e0f2455e5590 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 22:48:08 -0400
Subject: [PATCH 387/423] runtime: do not stop traceback at onM

Behavior before this CL:

1. If onM is called on a g0 stack, it just calls the given function.

2. If onM is called on a gsignal stack, it calls badonm.

3. If onM is called on a curg stack, it switches to the g0 stack
and then calls the function.

In cases 1 and 2, if the program then crashes (and badonm always does),
we want to see what called onM, but the traceback stops at onM.
In case 3, the traceback must stop at onM, because the g0
stack we are renting really does stop at onM.

The current code stops the traceback at onM to handle 3,
at the cost of making 1 and 2 crash with incomplete traces.

Change traceback to scan past onM but in case 3 make it look
like on the rented g0 stack, onM was called from mstart.
The traceback already knows that mstart is a top-of-stack function.

Alternate fix at CL 132610043 but I think this one is cleaner.
This CL makes 3 the exception, while that CL makes 1 and 2 the exception.

Submitting TBR to try to get better stack traces out of the
freebsd/amd64 builder, but happy to make changes in a
followup CL.

TBR=khr
R=khr
CC=golang-codereviews
https://golang.org/cl/133620043
---
 src/pkg/runtime/asm_386.s    | 7 ++++++-
 src/pkg/runtime/asm_amd64.s  | 7 ++++++-
 src/pkg/runtime/asm_arm.s    | 7 ++++++-
 src/pkg/runtime/traceback.go | 2 --
 4 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 87dd1fa0f5..40271567b0 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -233,7 +233,12 @@ oncurg:
 
 	// switch to g0
 	MOVL	DX, g(CX)
-	MOVL	(g_sched+gobuf_sp)(DX), SP
+	MOVL	(g_sched+gobuf_sp)(DX), BX
+	// make it look like mstart called onM on g0, to stop traceback
+	SUBL	$4, BX
+	MOVL	$runtime·mstart(SB), DX
+	MOVL	DX, 0(BX)
+	MOVL	BX, SP
 
 	// call target function
 	ARGSIZE(0)
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 80c2ab3c54..9103ef29e3 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -226,7 +226,12 @@ oncurg:
 
 	// switch to g0
 	MOVQ	DX, g(CX)
-	MOVQ	(g_sched+gobuf_sp)(DX), SP
+	MOVQ	(g_sched+gobuf_sp)(DX), BX
+	// make it look like mstart called onM on g0, to stop traceback
+	SUBQ	$8, BX
+	MOVQ	$runtime·mstart(SB), DX
+	MOVQ	DX, 0(BX)
+	MOVQ	BX, SP
 
 	// call target function
 	ARGSIZE(0)
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 54ef836211..3869696f60 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -219,7 +219,12 @@ oncurg:
 
 	// switch to g0
 	MOVW	R2, g
-	MOVW	(g_sched+gobuf_sp)(R2), SP
+	MOVW	(g_sched+gobuf_sp)(R2), R3
+	// make it look like mstart called onM on g0, to stop traceback
+	SUB	$4, R3, R3
+	MOVW	$runtime·mstart(SB), R4
+	MOVW	R4, 0(R3)
+	MOVW	R3, SP
 
 	// call target function
 	ARGSIZE(0)
diff --git a/src/pkg/runtime/traceback.go b/src/pkg/runtime/traceback.go
index adb03440b3..ec7be28dc0 100644
--- a/src/pkg/runtime/traceback.go
+++ b/src/pkg/runtime/traceback.go
@@ -40,7 +40,6 @@ var (
 	mstartPC    = funcPC(mstart)
 	newprocPC   = funcPC(newproc)
 	newstackPC  = funcPC(newstack)
-	onMPC       = funcPC(onM)
 	rt0_goPC    = funcPC(rt0_go)
 	sigpanicPC  = funcPC(sigpanic)
 
@@ -633,7 +632,6 @@ func topofstack(f *_func) bool {
 	return pc == goexitPC ||
 		pc == mstartPC ||
 		pc == mcallPC ||
-		pc == onMPC ||
 		pc == morestackPC ||
 		pc == lessstackPC ||
 		pc == rt0_goPC ||

From cb040d59b945437cdca8c8cff525ebbb7261a217 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 23:05:18 -0400
Subject: [PATCH 388/423] runtime: use new #include "textflag.h"

I did this just to clean things up, but it will be important
when we drop the pkg directory later.

LGTM=bradfitz
R=r, bradfitz
CC=golang-codereviews
https://golang.org/cl/132600043
---
 src/pkg/runtime/asm_386.s               | 2 +-
 src/pkg/runtime/asm_amd64.s             | 2 +-
 src/pkg/runtime/asm_amd64p32.s          | 2 +-
 src/pkg/runtime/asm_arm.s               | 2 +-
 src/pkg/runtime/atomic_386.c            | 2 +-
 src/pkg/runtime/atomic_amd64x.c         | 2 +-
 src/pkg/runtime/heapdump.c              | 2 +-
 src/pkg/runtime/malloc.c                | 2 +-
 src/pkg/runtime/mem_darwin.c            | 2 +-
 src/pkg/runtime/mem_linux.c             | 2 +-
 src/pkg/runtime/mem_nacl.c              | 2 +-
 src/pkg/runtime/mem_netbsd.c            | 2 +-
 src/pkg/runtime/mem_openbsd.c           | 2 +-
 src/pkg/runtime/mem_plan9.c             | 2 +-
 src/pkg/runtime/mem_solaris.c           | 2 +-
 src/pkg/runtime/mem_windows.c           | 2 +-
 src/pkg/runtime/memclr_386.s            | 2 +-
 src/pkg/runtime/memclr_amd64.s          | 2 +-
 src/pkg/runtime/memclr_arm.s            | 2 +-
 src/pkg/runtime/memclr_plan9_386.s      | 2 +-
 src/pkg/runtime/memclr_plan9_amd64.s    | 2 +-
 src/pkg/runtime/memmove_386.s           | 2 +-
 src/pkg/runtime/memmove_amd64.s         | 2 +-
 src/pkg/runtime/memmove_arm.s           | 2 +-
 src/pkg/runtime/memmove_nacl_amd64p32.s | 2 +-
 src/pkg/runtime/memmove_plan9_386.s     | 2 +-
 src/pkg/runtime/memmove_plan9_amd64.s   | 2 +-
 src/pkg/runtime/mgc0.c                  | 2 +-
 src/pkg/runtime/msize.c                 | 2 +-
 src/pkg/runtime/os_darwin.c             | 2 +-
 src/pkg/runtime/os_dragonfly.c          | 2 +-
 src/pkg/runtime/os_freebsd.c            | 2 +-
 src/pkg/runtime/os_freebsd_arm.c        | 2 +-
 src/pkg/runtime/os_linux.c              | 2 +-
 src/pkg/runtime/os_linux_386.c          | 2 +-
 src/pkg/runtime/os_linux_arm.c          | 2 +-
 src/pkg/runtime/os_nacl.c               | 2 +-
 src/pkg/runtime/os_nacl_arm.c           | 2 +-
 src/pkg/runtime/os_netbsd.c             | 2 +-
 src/pkg/runtime/os_netbsd_arm.c         | 2 +-
 src/pkg/runtime/os_openbsd.c            | 2 +-
 src/pkg/runtime/os_plan9.c              | 2 +-
 src/pkg/runtime/os_solaris.c            | 2 +-
 src/pkg/runtime/os_windows.c            | 2 +-
 src/pkg/runtime/panic.c                 | 2 +-
 src/pkg/runtime/proc.c                  | 2 +-
 src/pkg/runtime/race.c                  | 2 +-
 src/pkg/runtime/race_amd64.s            | 2 +-
 src/pkg/runtime/rt0_android_arm.s       | 2 +-
 src/pkg/runtime/rt0_darwin_386.s        | 2 +-
 src/pkg/runtime/rt0_darwin_amd64.s      | 2 +-
 src/pkg/runtime/rt0_dragonfly_386.s     | 2 +-
 src/pkg/runtime/rt0_dragonfly_amd64.s   | 2 +-
 src/pkg/runtime/rt0_freebsd_386.s       | 2 +-
 src/pkg/runtime/rt0_freebsd_amd64.s     | 2 +-
 src/pkg/runtime/rt0_freebsd_arm.s       | 2 +-
 src/pkg/runtime/rt0_linux_386.s         | 2 +-
 src/pkg/runtime/rt0_linux_amd64.s       | 2 +-
 src/pkg/runtime/rt0_linux_arm.s         | 2 +-
 src/pkg/runtime/rt0_nacl_386.s          | 2 +-
 src/pkg/runtime/rt0_nacl_amd64p32.s     | 2 +-
 src/pkg/runtime/rt0_nacl_arm.s          | 2 +-
 src/pkg/runtime/rt0_netbsd_386.s        | 2 +-
 src/pkg/runtime/rt0_netbsd_amd64.s      | 2 +-
 src/pkg/runtime/rt0_netbsd_arm.s        | 2 +-
 src/pkg/runtime/rt0_openbsd_386.s       | 2 +-
 src/pkg/runtime/rt0_openbsd_amd64.s     | 2 +-
 src/pkg/runtime/rt0_plan9_386.s         | 2 +-
 src/pkg/runtime/rt0_plan9_amd64.s       | 2 +-
 src/pkg/runtime/rt0_solaris_amd64.s     | 2 +-
 src/pkg/runtime/rt0_windows_386.s       | 2 +-
 src/pkg/runtime/rt0_windows_amd64.s     | 2 +-
 src/pkg/runtime/runtime.c               | 2 +-
 src/pkg/runtime/softfloat_arm.c         | 2 +-
 src/pkg/runtime/stack.c                 | 2 +-
 src/pkg/runtime/string.c                | 2 +-
 src/pkg/runtime/stubs.goc               | 2 +-
 src/pkg/runtime/sys_darwin_386.s        | 2 +-
 src/pkg/runtime/sys_darwin_amd64.s      | 2 +-
 src/pkg/runtime/sys_dragonfly_386.s     | 2 +-
 src/pkg/runtime/sys_dragonfly_amd64.s   | 2 +-
 src/pkg/runtime/sys_freebsd_386.s       | 2 +-
 src/pkg/runtime/sys_freebsd_amd64.s     | 2 +-
 src/pkg/runtime/sys_freebsd_arm.s       | 2 +-
 src/pkg/runtime/sys_linux_386.s         | 2 +-
 src/pkg/runtime/sys_linux_amd64.s       | 2 +-
 src/pkg/runtime/sys_linux_arm.s         | 2 +-
 src/pkg/runtime/sys_nacl_386.s          | 2 +-
 src/pkg/runtime/sys_nacl_amd64p32.s     | 2 +-
 src/pkg/runtime/sys_nacl_arm.s          | 2 +-
 src/pkg/runtime/sys_netbsd_386.s        | 2 +-
 src/pkg/runtime/sys_netbsd_amd64.s      | 2 +-
 src/pkg/runtime/sys_netbsd_arm.s        | 2 +-
 src/pkg/runtime/sys_openbsd_386.s       | 2 +-
 src/pkg/runtime/sys_openbsd_amd64.s     | 2 +-
 src/pkg/runtime/sys_plan9_386.s         | 2 +-
 src/pkg/runtime/sys_plan9_amd64.s       | 2 +-
 src/pkg/runtime/sys_solaris_amd64.s     | 2 +-
 src/pkg/runtime/sys_windows_386.s       | 2 +-
 src/pkg/runtime/sys_windows_amd64.s     | 2 +-
 src/pkg/runtime/syscall_solaris.goc     | 2 +-
 src/pkg/runtime/thunk.s                 | 2 +-
 src/pkg/runtime/tls_arm.s               | 2 +-
 src/pkg/runtime/vlop_386.s              | 2 +-
 src/pkg/runtime/vlop_arm.s              | 2 +-
 src/pkg/runtime/vlrt.c                  | 2 +-
 106 files changed, 106 insertions(+), 106 deletions(-)

diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 40271567b0..25911a5b9c 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -4,7 +4,7 @@
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 9103ef29e3..962074582d 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -4,7 +4,7 @@
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index a0e63b4405..64a436495f 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -4,7 +4,7 @@
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// copy arguments forward on an even stack
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 3869696f60..9e68e099e2 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -4,7 +4,7 @@
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // using frame size $-4 means do not save LR on stack.
 TEXT runtime·rt0_go(SB),NOSPLIT,$-4
diff --git a/src/pkg/runtime/atomic_386.c b/src/pkg/runtime/atomic_386.c
index d7162a1b8b..82d36f2d96 100644
--- a/src/pkg/runtime/atomic_386.c
+++ b/src/pkg/runtime/atomic_386.c
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma textflag NOSPLIT
 uint32
diff --git a/src/pkg/runtime/atomic_amd64x.c b/src/pkg/runtime/atomic_amd64x.c
index 11b5789363..7be57ac95a 100644
--- a/src/pkg/runtime/atomic_amd64x.c
+++ b/src/pkg/runtime/atomic_amd64x.c
@@ -5,7 +5,7 @@
 // +build amd64 amd64p32
 
 #include "runtime.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma textflag NOSPLIT
 uint32
diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 83c2be2ac7..d07fdb29bc 100644
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -17,7 +17,7 @@
 #include "typekind.h"
 #include "funcdata.h"
 #include "zaexperiment.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern byte runtime·data[];
 extern byte runtime·edata[];
diff --git a/src/pkg/runtime/malloc.c b/src/pkg/runtime/malloc.c
index 86846f3e6d..752ff60f37 100644
--- a/src/pkg/runtime/malloc.c
+++ b/src/pkg/runtime/malloc.c
@@ -13,7 +13,7 @@
 #include "typekind.h"
 #include "race.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Mark mheap as 'no pointers', it does not contain interesting pointers but occupies ~45K.
 #pragma dataflag NOPTR
diff --git a/src/pkg/runtime/mem_darwin.c b/src/pkg/runtime/mem_darwin.c
index 72a2d18ad6..bf3ede5778 100644
--- a/src/pkg/runtime/mem_darwin.c
+++ b/src/pkg/runtime/mem_darwin.c
@@ -7,7 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma textflag NOSPLIT
 void*
diff --git a/src/pkg/runtime/mem_linux.c b/src/pkg/runtime/mem_linux.c
index 01e7707bbc..bfb405607e 100644
--- a/src/pkg/runtime/mem_linux.c
+++ b/src/pkg/runtime/mem_linux.c
@@ -7,7 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/mem_nacl.c b/src/pkg/runtime/mem_nacl.c
index 968fe8da54..6c836f18a7 100644
--- a/src/pkg/runtime/mem_nacl.c
+++ b/src/pkg/runtime/mem_nacl.c
@@ -7,7 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/mem_netbsd.c b/src/pkg/runtime/mem_netbsd.c
index 8d04c832ce..31820e5170 100644
--- a/src/pkg/runtime/mem_netbsd.c
+++ b/src/pkg/runtime/mem_netbsd.c
@@ -7,7 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/mem_openbsd.c b/src/pkg/runtime/mem_openbsd.c
index 8d04c832ce..31820e5170 100644
--- a/src/pkg/runtime/mem_openbsd.c
+++ b/src/pkg/runtime/mem_openbsd.c
@@ -7,7 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/mem_plan9.c b/src/pkg/runtime/mem_plan9.c
index 4f753adb4d..402869f393 100644
--- a/src/pkg/runtime/mem_plan9.c
+++ b/src/pkg/runtime/mem_plan9.c
@@ -7,7 +7,7 @@
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "os_GOOS.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern byte runtime·end[];
 static byte *bloc = { runtime·end };
diff --git a/src/pkg/runtime/mem_solaris.c b/src/pkg/runtime/mem_solaris.c
index 01cbe9e1a4..8e90ba1d9e 100644
--- a/src/pkg/runtime/mem_solaris.c
+++ b/src/pkg/runtime/mem_solaris.c
@@ -7,7 +7,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/mem_windows.c b/src/pkg/runtime/mem_windows.c
index 33ce003d28..7bc028bf3a 100644
--- a/src/pkg/runtime/mem_windows.c
+++ b/src/pkg/runtime/mem_windows.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "defs_GOOS_GOARCH.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum {
 	MEM_COMMIT = 0x1000,
diff --git a/src/pkg/runtime/memclr_386.s b/src/pkg/runtime/memclr_386.s
index aeabad413e..8b163923e9 100644
--- a/src/pkg/runtime/memclr_386.s
+++ b/src/pkg/runtime/memclr_386.s
@@ -4,7 +4,7 @@
 
 // +build !plan9
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·memclr(void*, uintptr)
 TEXT runtime·memclr(SB), NOSPLIT, $0-8
diff --git a/src/pkg/runtime/memclr_amd64.s b/src/pkg/runtime/memclr_amd64.s
index 01c6a415c0..35b3b4beef 100644
--- a/src/pkg/runtime/memclr_amd64.s
+++ b/src/pkg/runtime/memclr_amd64.s
@@ -4,7 +4,7 @@
 
 // +build !plan9
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·memclr(void*, uintptr)
 TEXT runtime·memclr(SB), NOSPLIT, $0-16
diff --git a/src/pkg/runtime/memclr_arm.s b/src/pkg/runtime/memclr_arm.s
index b19ea72a3f..1824d33b14 100644
--- a/src/pkg/runtime/memclr_arm.s
+++ b/src/pkg/runtime/memclr_arm.s
@@ -23,7 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TO = 8
 TOE = 11
diff --git a/src/pkg/runtime/memclr_plan9_386.s b/src/pkg/runtime/memclr_plan9_386.s
index ed5dbbd3c6..b4b671f773 100644
--- a/src/pkg/runtime/memclr_plan9_386.s
+++ b/src/pkg/runtime/memclr_plan9_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·memclr(void*, uintptr)
 TEXT runtime·memclr(SB), NOSPLIT, $0-8
diff --git a/src/pkg/runtime/memclr_plan9_amd64.s b/src/pkg/runtime/memclr_plan9_amd64.s
index 64f3c992ef..37e61dfbcc 100644
--- a/src/pkg/runtime/memclr_plan9_amd64.s
+++ b/src/pkg/runtime/memclr_plan9_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·memclr(void*, uintptr)
 TEXT runtime·memclr(SB),NOSPLIT,$0-16
diff --git a/src/pkg/runtime/memmove_386.s b/src/pkg/runtime/memmove_386.s
index 51b08d56d3..4c0c74c1af 100644
--- a/src/pkg/runtime/memmove_386.s
+++ b/src/pkg/runtime/memmove_386.s
@@ -25,7 +25,7 @@
 
 // +build !plan9
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·memmove(SB), NOSPLIT, $0-12
 	MOVL	to+0(FP), DI
diff --git a/src/pkg/runtime/memmove_amd64.s b/src/pkg/runtime/memmove_amd64.s
index 339c5dd410..f968435340 100644
--- a/src/pkg/runtime/memmove_amd64.s
+++ b/src/pkg/runtime/memmove_amd64.s
@@ -25,7 +25,7 @@
 
 // +build !plan9
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·memmove(void*, void*, uintptr)
 TEXT runtime·memmove(SB), NOSPLIT, $0-24
diff --git a/src/pkg/runtime/memmove_arm.s b/src/pkg/runtime/memmove_arm.s
index 9701dc99f2..f187d42678 100644
--- a/src/pkg/runtime/memmove_arm.s
+++ b/src/pkg/runtime/memmove_arm.s
@@ -23,7 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // TE or TS are spilled to the stack during bulk register moves.
 TS = 0
diff --git a/src/pkg/runtime/memmove_nacl_amd64p32.s b/src/pkg/runtime/memmove_nacl_amd64p32.s
index ba47e85461..373607afec 100644
--- a/src/pkg/runtime/memmove_nacl_amd64p32.s
+++ b/src/pkg/runtime/memmove_nacl_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·memmove(SB), NOSPLIT, $0-12
 	MOVL	to+0(FP), DI
diff --git a/src/pkg/runtime/memmove_plan9_386.s b/src/pkg/runtime/memmove_plan9_386.s
index 4d5f7c6907..025d4ce1bf 100644
--- a/src/pkg/runtime/memmove_plan9_386.s
+++ b/src/pkg/runtime/memmove_plan9_386.s
@@ -23,7 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·memmove(SB), NOSPLIT, $0-12
 	MOVL	to+0(FP), DI
diff --git a/src/pkg/runtime/memmove_plan9_amd64.s b/src/pkg/runtime/memmove_plan9_amd64.s
index 035d475ac8..8e96b87175 100644
--- a/src/pkg/runtime/memmove_plan9_amd64.s
+++ b/src/pkg/runtime/memmove_plan9_amd64.s
@@ -23,7 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·memmove(void*, void*, uintptr)
 TEXT runtime·memmove(SB), NOSPLIT, $0-24
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 05e555b8a4..55c38a7e5b 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -60,7 +60,7 @@
 #include "type.h"
 #include "typekind.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum {
 	Debug		= 0,
diff --git a/src/pkg/runtime/msize.c b/src/pkg/runtime/msize.c
index 2fbd5e1042..7cb65dad0d 100644
--- a/src/pkg/runtime/msize.c
+++ b/src/pkg/runtime/msize.c
@@ -28,7 +28,7 @@
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma dataflag NOPTR
 int32 runtime·class_to_size[NumSizeClasses];
diff --git a/src/pkg/runtime/os_darwin.c b/src/pkg/runtime/os_darwin.c
index 466591877d..536f688cf1 100644
--- a/src/pkg/runtime/os_darwin.c
+++ b/src/pkg/runtime/os_darwin.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern SigTab runtime·sigtab[];
 
diff --git a/src/pkg/runtime/os_dragonfly.c b/src/pkg/runtime/os_dragonfly.c
index 7bde58f756..d470f7c78c 100644
--- a/src/pkg/runtime/os_dragonfly.c
+++ b/src/pkg/runtime/os_dragonfly.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern SigTab runtime·sigtab[];
 extern int32 runtime·sys_umtx_sleep(uint32*, int32, int32);
diff --git a/src/pkg/runtime/os_freebsd.c b/src/pkg/runtime/os_freebsd.c
index 4c58b531ce..aae944ea11 100644
--- a/src/pkg/runtime/os_freebsd.c
+++ b/src/pkg/runtime/os_freebsd.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern SigTab runtime·sigtab[];
 extern int32 runtime·sys_umtx_op(uint32*, int32, uint32, void*, void*);
diff --git a/src/pkg/runtime/os_freebsd_arm.c b/src/pkg/runtime/os_freebsd_arm.c
index 1fa235b01d..2f2d7767f2 100644
--- a/src/pkg/runtime/os_freebsd_arm.c
+++ b/src/pkg/runtime/os_freebsd_arm.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 void
 runtime·checkgoarm(void)
diff --git a/src/pkg/runtime/os_linux.c b/src/pkg/runtime/os_linux.c
index 7ab4858d9a..66e7bcec05 100644
--- a/src/pkg/runtime/os_linux.c
+++ b/src/pkg/runtime/os_linux.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern SigTab runtime·sigtab[];
 
diff --git a/src/pkg/runtime/os_linux_386.c b/src/pkg/runtime/os_linux_386.c
index ad72814649..dc89d04e28 100644
--- a/src/pkg/runtime/os_linux_386.c
+++ b/src/pkg/runtime/os_linux_386.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define AT_NULL		0
 #define AT_RANDOM	25
diff --git a/src/pkg/runtime/os_linux_arm.c b/src/pkg/runtime/os_linux_arm.c
index aad08b9890..e3eda7c2d1 100644
--- a/src/pkg/runtime/os_linux_arm.c
+++ b/src/pkg/runtime/os_linux_arm.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define AT_NULL		0
 #define AT_PLATFORM	15 // introduced in at least 2.6.11
diff --git a/src/pkg/runtime/os_nacl.c b/src/pkg/runtime/os_nacl.c
index fba32e5687..37a1fcca0d 100644
--- a/src/pkg/runtime/os_nacl.c
+++ b/src/pkg/runtime/os_nacl.c
@@ -6,7 +6,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "arch_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "stack.h"
 
 int8 *goos = "nacl";
diff --git a/src/pkg/runtime/os_nacl_arm.c b/src/pkg/runtime/os_nacl_arm.c
index c94b2c78a6..1248ea6449 100644
--- a/src/pkg/runtime/os_nacl_arm.c
+++ b/src/pkg/runtime/os_nacl_arm.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 void
 runtime·checkgoarm(void)
diff --git a/src/pkg/runtime/os_netbsd.c b/src/pkg/runtime/os_netbsd.c
index cee96ebed1..d6c3bc8261 100644
--- a/src/pkg/runtime/os_netbsd.c
+++ b/src/pkg/runtime/os_netbsd.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/os_netbsd_arm.c b/src/pkg/runtime/os_netbsd_arm.c
index e440e7def3..9dd4bcdc9c 100644
--- a/src/pkg/runtime/os_netbsd_arm.c
+++ b/src/pkg/runtime/os_netbsd_arm.c
@@ -6,7 +6,7 @@
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "signal_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 void
 runtime·lwp_mcontext_init(McontextT *mc, void *stack, M *mp, G *gp, void (*fn)(void))
diff --git a/src/pkg/runtime/os_openbsd.c b/src/pkg/runtime/os_openbsd.c
index 7c9e478e84..59abc97b7c 100644
--- a/src/pkg/runtime/os_openbsd.c
+++ b/src/pkg/runtime/os_openbsd.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/os_plan9.c b/src/pkg/runtime/os_plan9.c
index bae4549a6e..f824710793 100644
--- a/src/pkg/runtime/os_plan9.c
+++ b/src/pkg/runtime/os_plan9.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "os_GOOS.h"
 #include "arch_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 int8 *goos = "plan9";
 extern SigTab runtime·sigtab[];
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index c7ec3f212f..5e1f7ab076 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -7,7 +7,7 @@
 #include "os_GOOS.h"
 #include "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma dynexport runtime·end _end
 #pragma dynexport runtime·etext _etext
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 9bf6ecbc64..885fe63343 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -6,7 +6,7 @@
 #include "type.h"
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma dynimport runtime·AddVectoredExceptionHandler AddVectoredExceptionHandler "kernel32.dll"
 #pragma dynimport runtime·CloseHandle CloseHandle "kernel32.dll"
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index 72078f4343..152c9a3d55 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -6,7 +6,7 @@
 #include "arch_GOARCH.h"
 #include "stack.h"
 #include "malloc.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Code related to defer, panic and recover.
 
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 3fecfe90e4..3c5e244a92 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -10,7 +10,7 @@
 #include "race.h"
 #include "type.h"
 #include "mgc0.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Goroutine scheduler
 // The scheduler's job is to distribute ready-to-run goroutines over worker threads.
diff --git a/src/pkg/runtime/race.c b/src/pkg/runtime/race.c
index 125309510b..9ac73fbccf 100644
--- a/src/pkg/runtime/race.c
+++ b/src/pkg/runtime/race.c
@@ -11,7 +11,7 @@
 #include "race.h"
 #include "type.h"
 #include "typekind.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Race runtime functions called via runtime·racecall.
 void __tsan_init(void);
diff --git a/src/pkg/runtime/race_amd64.s b/src/pkg/runtime/race_amd64.s
index a4a9dfeb55..bdea28c7c0 100644
--- a/src/pkg/runtime/race_amd64.s
+++ b/src/pkg/runtime/race_amd64.s
@@ -6,7 +6,7 @@
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // The following thunks allow calling the gcc-compiled race runtime directly
 // from Go code without going all the way through cgo.
diff --git a/src/pkg/runtime/rt0_android_arm.s b/src/pkg/runtime/rt0_android_arm.s
index 3eecbbddc5..6b65fb47b1 100644
--- a/src/pkg/runtime/rt0_android_arm.s
+++ b/src/pkg/runtime/rt0_android_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_arm_android(SB),NOSPLIT,$-4
 	MOVW		(R13), R0      // argc
diff --git a/src/pkg/runtime/rt0_darwin_386.s b/src/pkg/runtime/rt0_darwin_386.s
index 7fe1df4c90..4c8c92dda8 100644
--- a/src/pkg/runtime/rt0_darwin_386.s
+++ b/src/pkg/runtime/rt0_darwin_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_darwin(SB),NOSPLIT,$8
 	MOVL	8(SP), AX
diff --git a/src/pkg/runtime/rt0_darwin_amd64.s b/src/pkg/runtime/rt0_darwin_amd64.s
index ac323c83c2..452d854558 100644
--- a/src/pkg/runtime/rt0_darwin_amd64.s
+++ b/src/pkg/runtime/rt0_darwin_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_darwin(SB),NOSPLIT,$-8
 	LEAQ	8(SP), SI // argv
diff --git a/src/pkg/runtime/rt0_dragonfly_386.s b/src/pkg/runtime/rt0_dragonfly_386.s
index 9262a0f9e1..548ba796a0 100644
--- a/src/pkg/runtime/rt0_dragonfly_386.s
+++ b/src/pkg/runtime/rt0_dragonfly_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_dragonfly(SB),NOSPLIT,$8
 	MOVL	8(SP), AX
diff --git a/src/pkg/runtime/rt0_dragonfly_amd64.s b/src/pkg/runtime/rt0_dragonfly_amd64.s
index a83b20e228..fb56618d8f 100644
--- a/src/pkg/runtime/rt0_dragonfly_amd64.s
+++ b/src/pkg/runtime/rt0_dragonfly_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_dragonfly(SB),NOSPLIT,$-8
 	LEAQ	8(DI), SI // argv
diff --git a/src/pkg/runtime/rt0_freebsd_386.s b/src/pkg/runtime/rt0_freebsd_386.s
index 242b67df5e..cd7a915f84 100644
--- a/src/pkg/runtime/rt0_freebsd_386.s
+++ b/src/pkg/runtime/rt0_freebsd_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_freebsd(SB),NOSPLIT,$8
 	MOVL	8(SP), AX
diff --git a/src/pkg/runtime/rt0_freebsd_amd64.s b/src/pkg/runtime/rt0_freebsd_amd64.s
index 729effbdba..7989f7c3e9 100644
--- a/src/pkg/runtime/rt0_freebsd_amd64.s
+++ b/src/pkg/runtime/rt0_freebsd_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_freebsd(SB),NOSPLIT,$-8
 	LEAQ	8(DI), SI // argv
diff --git a/src/pkg/runtime/rt0_freebsd_arm.s b/src/pkg/runtime/rt0_freebsd_arm.s
index d50c73c237..f31252698e 100644
--- a/src/pkg/runtime/rt0_freebsd_arm.s
+++ b/src/pkg/runtime/rt0_freebsd_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // FreeBSD and Linux use the same linkage to main
 
diff --git a/src/pkg/runtime/rt0_linux_386.s b/src/pkg/runtime/rt0_linux_386.s
index 285aeed73c..74ddc94da9 100644
--- a/src/pkg/runtime/rt0_linux_386.s
+++ b/src/pkg/runtime/rt0_linux_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_linux(SB),NOSPLIT,$8
 	MOVL	8(SP), AX
diff --git a/src/pkg/runtime/rt0_linux_amd64.s b/src/pkg/runtime/rt0_linux_amd64.s
index 7f8c795481..985426acc4 100644
--- a/src/pkg/runtime/rt0_linux_amd64.s
+++ b/src/pkg/runtime/rt0_linux_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
 	LEAQ	8(SP), SI // argv
diff --git a/src/pkg/runtime/rt0_linux_arm.s b/src/pkg/runtime/rt0_linux_arm.s
index 21391c7300..8af3d3505e 100644
--- a/src/pkg/runtime/rt0_linux_arm.s
+++ b/src/pkg/runtime/rt0_linux_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_arm_linux(SB),NOSPLIT,$-4
 	MOVW	(R13), R0	// argc
diff --git a/src/pkg/runtime/rt0_nacl_386.s b/src/pkg/runtime/rt0_nacl_386.s
index e374bf3359..d4ba06306a 100644
--- a/src/pkg/runtime/rt0_nacl_386.s
+++ b/src/pkg/runtime/rt0_nacl_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // NaCl entry has:
 //	0(FP) - arg block == SP+8
diff --git a/src/pkg/runtime/rt0_nacl_amd64p32.s b/src/pkg/runtime/rt0_nacl_amd64p32.s
index de08618fc8..d8703dc0f0 100644
--- a/src/pkg/runtime/rt0_nacl_amd64p32.s
+++ b/src/pkg/runtime/rt0_nacl_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // NaCl entry on 32-bit x86 has DI pointing at the arg block, which contains:
 //
diff --git a/src/pkg/runtime/rt0_nacl_arm.s b/src/pkg/runtime/rt0_nacl_arm.s
index 243cb3375d..eadb4782dd 100644
--- a/src/pkg/runtime/rt0_nacl_arm.s
+++ b/src/pkg/runtime/rt0_nacl_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // NaCl entry has:
 //	0(FP) - 0
diff --git a/src/pkg/runtime/rt0_netbsd_386.s b/src/pkg/runtime/rt0_netbsd_386.s
index f4cc78a1bc..70b8532538 100644
--- a/src/pkg/runtime/rt0_netbsd_386.s
+++ b/src/pkg/runtime/rt0_netbsd_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_netbsd(SB),NOSPLIT,$8
 	MOVL	8(SP), AX
diff --git a/src/pkg/runtime/rt0_netbsd_amd64.s b/src/pkg/runtime/rt0_netbsd_amd64.s
index e2288dbaed..fad56614e5 100644
--- a/src/pkg/runtime/rt0_netbsd_amd64.s
+++ b/src/pkg/runtime/rt0_netbsd_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_netbsd(SB),NOSPLIT,$-8
 	LEAQ	8(SP), SI // argv
diff --git a/src/pkg/runtime/rt0_netbsd_arm.s b/src/pkg/runtime/rt0_netbsd_arm.s
index 1f649d97c4..bad66e06cf 100644
--- a/src/pkg/runtime/rt0_netbsd_arm.s
+++ b/src/pkg/runtime/rt0_netbsd_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // FreeBSD/NetBSD and Linux use the same linkage to main
 
diff --git a/src/pkg/runtime/rt0_openbsd_386.s b/src/pkg/runtime/rt0_openbsd_386.s
index 35439d0d58..f25d2e1cf0 100644
--- a/src/pkg/runtime/rt0_openbsd_386.s
+++ b/src/pkg/runtime/rt0_openbsd_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_openbsd(SB),NOSPLIT,$8
 	MOVL	8(SP), AX
diff --git a/src/pkg/runtime/rt0_openbsd_amd64.s b/src/pkg/runtime/rt0_openbsd_amd64.s
index a394890f94..58fe666391 100644
--- a/src/pkg/runtime/rt0_openbsd_amd64.s
+++ b/src/pkg/runtime/rt0_openbsd_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_openbsd(SB),NOSPLIT,$-8
 	LEAQ	8(SP), SI // argv
diff --git a/src/pkg/runtime/rt0_plan9_386.s b/src/pkg/runtime/rt0_plan9_386.s
index 4aaabfaa45..7e2887b857 100644
--- a/src/pkg/runtime/rt0_plan9_386.s
+++ b/src/pkg/runtime/rt0_plan9_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_plan9(SB),NOSPLIT,$12
 	MOVL	AX, _tos(SB)
diff --git a/src/pkg/runtime/rt0_plan9_amd64.s b/src/pkg/runtime/rt0_plan9_amd64.s
index 9f20eef60a..a372a0ba8b 100644
--- a/src/pkg/runtime/rt0_plan9_amd64.s
+++ b/src/pkg/runtime/rt0_plan9_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_plan9(SB),NOSPLIT,$24
 	MOVQ	AX, _tos(SB)
diff --git a/src/pkg/runtime/rt0_solaris_amd64.s b/src/pkg/runtime/rt0_solaris_amd64.s
index fd0a79cc9b..92a9fc2952 100644
--- a/src/pkg/runtime/rt0_solaris_amd64.s
+++ b/src/pkg/runtime/rt0_solaris_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_solaris(SB),NOSPLIT,$-8
 	LEAQ	8(SP), SI // argv
diff --git a/src/pkg/runtime/rt0_windows_386.s b/src/pkg/runtime/rt0_windows_386.s
index d4008ad5dc..00604372f1 100644
--- a/src/pkg/runtime/rt0_windows_386.s
+++ b/src/pkg/runtime/rt0_windows_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_386_windows(SB),NOSPLIT,$12
 	MOVL	12(SP), AX
diff --git a/src/pkg/runtime/rt0_windows_amd64.s b/src/pkg/runtime/rt0_windows_amd64.s
index 0b144717ba..890a570d1d 100644
--- a/src/pkg/runtime/rt0_windows_amd64.s
+++ b/src/pkg/runtime/rt0_windows_amd64.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT _rt0_amd64_windows(SB),NOSPLIT,$-8
 	LEAQ	8(SP), SI // argv
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 751181274a..d28ee58179 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "stack.h"
 #include "arch_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Keep a cached value to make gotraceback fast,
 // since we call it on every call to gentraceback.
diff --git a/src/pkg/runtime/softfloat_arm.c b/src/pkg/runtime/softfloat_arm.c
index 5e5f4025ec..09b0cf20ac 100644
--- a/src/pkg/runtime/softfloat_arm.c
+++ b/src/pkg/runtime/softfloat_arm.c
@@ -7,7 +7,7 @@
 // It uses true little-endian doubles, while the 7500 used mixed-endian.
 
 #include "runtime.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define CPSR 14
 #define FLAGS_N (1U << 31)
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 8456f79369..3993a372e0 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -11,7 +11,7 @@
 #include "type.h"
 #include "race.h"
 #include "mgc0.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 enum
 {
diff --git a/src/pkg/runtime/string.c b/src/pkg/runtime/string.c
index 5421b53196..4f25adf8e3 100644
--- a/src/pkg/runtime/string.c
+++ b/src/pkg/runtime/string.c
@@ -6,7 +6,7 @@
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "race.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 String	runtime·emptystring;
 
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index f8b2a9f0ad..f6bc14f2c9 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -7,7 +7,7 @@ package runtime
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // This file contains functions called by Go but written
 // in C.  These functions are problematic for the garbage
diff --git a/src/pkg/runtime/sys_darwin_386.s b/src/pkg/runtime/sys_darwin_386.s
index 1ec694db68..a961c71a83 100644
--- a/src/pkg/runtime/sys_darwin_386.s
+++ b/src/pkg/runtime/sys_darwin_386.s
@@ -7,7 +7,7 @@
 // or /usr/include/sys/syscall.h (on a Mac) for system call numbers.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/sys_darwin_amd64.s b/src/pkg/runtime/sys_darwin_amd64.s
index 5f0d9dfa1d..2f98bfb06c 100644
--- a/src/pkg/runtime/sys_darwin_amd64.s
+++ b/src/pkg/runtime/sys_darwin_amd64.s
@@ -12,7 +12,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/sys_dragonfly_386.s b/src/pkg/runtime/sys_dragonfly_386.s
index bd8c8d8f6d..dd0e27e26a 100644
--- a/src/pkg/runtime/sys_dragonfly_386.s
+++ b/src/pkg/runtime/sys_dragonfly_386.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 	
 TEXT runtime·sys_umtx_sleep(SB),NOSPLIT,$-4
 	MOVL	$469, AX		// umtx_sleep
diff --git a/src/pkg/runtime/sys_dragonfly_amd64.s b/src/pkg/runtime/sys_dragonfly_amd64.s
index 1c279df9c8..2c756018c2 100644
--- a/src/pkg/runtime/sys_dragonfly_amd64.s
+++ b/src/pkg/runtime/sys_dragonfly_amd64.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 	
 TEXT runtime·sys_umtx_sleep(SB),NOSPLIT,$0
 	MOVQ addr+0(FP), DI		// arg 1 - ptr
diff --git a/src/pkg/runtime/sys_freebsd_386.s b/src/pkg/runtime/sys_freebsd_386.s
index 929572f073..ffc28560ec 100644
--- a/src/pkg/runtime/sys_freebsd_386.s
+++ b/src/pkg/runtime/sys_freebsd_386.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 	
 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$-4
 	MOVL	$454, AX
diff --git a/src/pkg/runtime/sys_freebsd_amd64.s b/src/pkg/runtime/sys_freebsd_amd64.s
index f1198541dc..65f8c1a6ee 100644
--- a/src/pkg/runtime/sys_freebsd_amd64.s
+++ b/src/pkg/runtime/sys_freebsd_amd64.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // FreeBSD 8, FreeBSD 9, and older versions that I have checked
 // do not restore R10 on exit from a "restarted" system call
diff --git a/src/pkg/runtime/sys_freebsd_arm.s b/src/pkg/runtime/sys_freebsd_arm.s
index da43871b96..d875138b62 100644
--- a/src/pkg/runtime/sys_freebsd_arm.s
+++ b/src/pkg/runtime/sys_freebsd_arm.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // for EABI, as we don't support OABI
 #define SYS_BASE 0x0
diff --git a/src/pkg/runtime/sys_linux_386.s b/src/pkg/runtime/sys_linux_386.s
index 426e05faa1..0f6d4bbb5e 100644
--- a/src/pkg/runtime/sys_linux_386.s
+++ b/src/pkg/runtime/sys_linux_386.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·exit(SB),NOSPLIT,$0
 	MOVL	$252, AX	// syscall number
diff --git a/src/pkg/runtime/sys_linux_amd64.s b/src/pkg/runtime/sys_linux_amd64.s
index 3ce6bfc905..33b91e872f 100644
--- a/src/pkg/runtime/sys_linux_amd64.s
+++ b/src/pkg/runtime/sys_linux_amd64.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 TEXT runtime·exit(SB),NOSPLIT,$0-4
 	MOVL	code+0(FP), DI
diff --git a/src/pkg/runtime/sys_linux_arm.s b/src/pkg/runtime/sys_linux_arm.s
index a2abe8f25c..bd285f3998 100644
--- a/src/pkg/runtime/sys_linux_arm.s
+++ b/src/pkg/runtime/sys_linux_arm.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // for EABI, as we don't support OABI
 #define SYS_BASE 0x0
diff --git a/src/pkg/runtime/sys_nacl_386.s b/src/pkg/runtime/sys_nacl_386.s
index 5798b1aede..47985f31f5 100644
--- a/src/pkg/runtime/sys_nacl_386.s
+++ b/src/pkg/runtime/sys_nacl_386.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "syscall_nacl.h"
 
 #define NACL_SYSCALL(code) \
diff --git a/src/pkg/runtime/sys_nacl_amd64p32.s b/src/pkg/runtime/sys_nacl_amd64p32.s
index 1fd083718a..c30c2a8933 100644
--- a/src/pkg/runtime/sys_nacl_amd64p32.s
+++ b/src/pkg/runtime/sys_nacl_amd64p32.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "syscall_nacl.h"
 
 #define NACL_SYSCALL(code) \
diff --git a/src/pkg/runtime/sys_nacl_arm.s b/src/pkg/runtime/sys_nacl_arm.s
index cc18522208..d354ab4837 100644
--- a/src/pkg/runtime/sys_nacl_arm.s
+++ b/src/pkg/runtime/sys_nacl_arm.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 #include "syscall_nacl.h"
 
 #define NACL_SYSCALL(code) \
diff --git a/src/pkg/runtime/sys_netbsd_386.s b/src/pkg/runtime/sys_netbsd_386.s
index cecc389b5f..83a76cb343 100644
--- a/src/pkg/runtime/sys_netbsd_386.s
+++ b/src/pkg/runtime/sys_netbsd_386.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-4
diff --git a/src/pkg/runtime/sys_netbsd_amd64.s b/src/pkg/runtime/sys_netbsd_amd64.s
index 5b46dbe707..eb9766d3f5 100644
--- a/src/pkg/runtime/sys_netbsd_amd64.s
+++ b/src/pkg/runtime/sys_netbsd_amd64.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // int32 lwp_create(void *context, uintptr flags, void *lwpid)
 TEXT runtime·lwp_create(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/sys_netbsd_arm.s b/src/pkg/runtime/sys_netbsd_arm.s
index bf133a2100..039a0832e0 100644
--- a/src/pkg/runtime/sys_netbsd_arm.s
+++ b/src/pkg/runtime/sys_netbsd_arm.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),NOSPLIT,$-4
diff --git a/src/pkg/runtime/sys_openbsd_386.s b/src/pkg/runtime/sys_openbsd_386.s
index d836a1f9ea..12d9c5c6b4 100644
--- a/src/pkg/runtime/sys_openbsd_386.s
+++ b/src/pkg/runtime/sys_openbsd_386.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define	CLOCK_MONOTONIC	$3
 
diff --git a/src/pkg/runtime/sys_openbsd_amd64.s b/src/pkg/runtime/sys_openbsd_amd64.s
index e9371c3b63..4e9db23908 100644
--- a/src/pkg/runtime/sys_openbsd_amd64.s
+++ b/src/pkg/runtime/sys_openbsd_amd64.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #define CLOCK_MONOTONIC	$3
 
diff --git a/src/pkg/runtime/sys_plan9_386.s b/src/pkg/runtime/sys_plan9_386.s
index 43fb367ed9..dfa09613e4 100644
--- a/src/pkg/runtime/sys_plan9_386.s
+++ b/src/pkg/runtime/sys_plan9_386.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // setldt(int entry, int address, int limit)
 TEXT runtime·setldt(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/sys_plan9_amd64.s b/src/pkg/runtime/sys_plan9_amd64.s
index 257f405c8d..08ddc3ffa8 100644
--- a/src/pkg/runtime/sys_plan9_amd64.s
+++ b/src/pkg/runtime/sys_plan9_amd64.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // setldt(int entry, int address, int limit)
 TEXT runtime·setldt(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/sys_solaris_amd64.s b/src/pkg/runtime/sys_solaris_amd64.s
index 8506e9939a..2055d6c80b 100644
--- a/src/pkg/runtime/sys_solaris_amd64.s
+++ b/src/pkg/runtime/sys_solaris_amd64.s
@@ -7,7 +7,7 @@
 //
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // This is needed by asm_amd64.s
 TEXT runtime·settls(SB),NOSPLIT,$8
diff --git a/src/pkg/runtime/sys_windows_386.s b/src/pkg/runtime/sys_windows_386.s
index f9a456a2ca..f4d561feea 100644
--- a/src/pkg/runtime/sys_windows_386.s
+++ b/src/pkg/runtime/sys_windows_386.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall(SB),NOSPLIT,$0
diff --git a/src/pkg/runtime/sys_windows_amd64.s b/src/pkg/runtime/sys_windows_amd64.s
index 7e59dfc50c..e5890e04ae 100644
--- a/src/pkg/runtime/sys_windows_amd64.s
+++ b/src/pkg/runtime/sys_windows_amd64.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // maxargs should be divisible by 2, as Windows stack
 // must be kept 16-byte aligned on syscall entry.
diff --git a/src/pkg/runtime/syscall_solaris.goc b/src/pkg/runtime/syscall_solaris.goc
index 21bcce4d17..935a2f6cfc 100644
--- a/src/pkg/runtime/syscall_solaris.goc
+++ b/src/pkg/runtime/syscall_solaris.goc
@@ -7,7 +7,7 @@ package syscall
 #include "defs_GOOS_GOARCH.h"
 #include "os_GOOS.h"
 #include "cgocall.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #pragma dynimport libc·chdir chdir "libc.so"
 #pragma dynimport libc·chroot chroot "libc.so"
diff --git a/src/pkg/runtime/thunk.s b/src/pkg/runtime/thunk.s
index 0c057a3e23..babc927680 100644
--- a/src/pkg/runtime/thunk.s
+++ b/src/pkg/runtime/thunk.s
@@ -5,7 +5,7 @@
 // This file exposes various internal runtime functions to other packages in std lib.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 #ifdef GOARCH_arm
 #define JMP B
diff --git a/src/pkg/runtime/tls_arm.s b/src/pkg/runtime/tls_arm.s
index 37edfa968e..1b1cbc9783 100644
--- a/src/pkg/runtime/tls_arm.s
+++ b/src/pkg/runtime/tls_arm.s
@@ -4,7 +4,7 @@
 
 #include "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // We have to resort to TLS variable to save g(R10).
 // One reason is that external code might trigger
diff --git a/src/pkg/runtime/vlop_386.s b/src/pkg/runtime/vlop_386.s
index 7af67c987a..ce8e7d0643 100644
--- a/src/pkg/runtime/vlop_386.s
+++ b/src/pkg/runtime/vlop_386.s
@@ -23,7 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 /*
  * C runtime for 64-bit divide.
diff --git a/src/pkg/runtime/vlop_arm.s b/src/pkg/runtime/vlop_arm.s
index 0953deee78..6abcabad20 100644
--- a/src/pkg/runtime/vlop_arm.s
+++ b/src/pkg/runtime/vlop_arm.s
@@ -24,7 +24,7 @@
 // THE SOFTWARE.
 
 #include "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 arg=0
 
diff --git a/src/pkg/runtime/vlrt.c b/src/pkg/runtime/vlrt.c
index 486555dda3..cb0d147961 100644
--- a/src/pkg/runtime/vlrt.c
+++ b/src/pkg/runtime/vlrt.c
@@ -25,7 +25,7 @@
 
 // +build arm 386
 
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 /*
  * C runtime for 64-bit divide, others.

From 83824639c3ae9f357daf7ac2f8590b46d167296b Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 23:12:10 -0400
Subject: [PATCH 389/423] syscall: in linux/arm Syscall, zero R3, R4, R5

The general kernel system call interface
takes 6 arguments: R0, R1, R2, R3, R4, R5.

Syscall is for calls that only need 3.
The amd64 and 386 versions zero the extra arg registers,
but the arm version does not.

func utimensat calls Syscall with 3 arguments.
The kernel expects a 4th argument.
That turns out to be whatever is in R3 at the time of the call.
CL 137160043 changed various pieces of code and apparently
changed the value left in R3 at the time of utimensat's Syscall.
This causes the kernel to return EINVAL.

Change linux/arm Syscall to zero R3, R4, R5, so that calls will
behave deterministically, even if they pass too few arguments.

Arguably, utimensat could be fixed too, but the predictable
zeroing is certainly worth doing, and once done utimensat's
use of Syscall is fine.

Fixes arm build.

TBR=bradfitz
CC=golang-codereviews
https://golang.org/cl/141080043
---
 src/pkg/syscall/asm_linux_arm.s | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/pkg/syscall/asm_linux_arm.s b/src/pkg/syscall/asm_linux_arm.s
index 014fa618f6..3be0a13e17 100644
--- a/src/pkg/syscall/asm_linux_arm.s
+++ b/src/pkg/syscall/asm_linux_arm.s
@@ -18,6 +18,9 @@ TEXT	·Syscall(SB),NOSPLIT,$0-28
 	MOVW	8(SP), R0
 	MOVW	12(SP), R1
 	MOVW	16(SP), R2
+	MOVW	$0, R3
+	MOVW	$0, R4
+	MOVW	$0, R5
 	SWI		$0
 	MOVW	$0xfffff001, R1
 	CMP		R1, R0

From e0f08b938a37490cd6e4f6bb33360678ac5f42b0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Thu, 4 Sep 2014 23:14:21 -0400
Subject: [PATCH 390/423] runtime: use cas loop to coordinate with sigprof

sigprof and setcpuprofilerate coordinate the enabling/disabling
of the handler using a Mutex. This has always been a bit dodgy:
setcpuprofilerate must be careful to turn off signals before acquiring
the lock to avoid a deadlock.

Now the lock implementations use onM, and onM isn't okay on the
signal stack. We know how to make it okay, but it's more work than
is probably worth doing.

Since this is super-dodgy anyway, replace the lock with a simple
cas loop. It is only contended if setcpuprofilerate is being called,
and that doesn't happen frequently enough to care about the
raw speed or about using futexes/semaphores.

TBR to fix freebsd/amd64 and dragonfly/amd64 builds.
Happy to make changes in a follow-up CL.

TBR=dvyukov
CC=golang-codereviews
https://golang.org/cl/141080044
---
 src/pkg/runtime/proc.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 3c5e244a92..56c35c5a44 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2630,7 +2630,7 @@ runtime·badreflectcall(void) // called from assembly
 }
 
 static struct {
-	Mutex lock;
+	uint32 lock;
 	int32 hz;
 } prof;
 
@@ -2774,10 +2774,12 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 	}
 
 	if(prof.hz != 0) {
-		runtime·lock(&prof.lock);
+		// Simple cas-lock to coordinate with setcpuprofilerate.
+		while(!runtime·cas(&prof.lock, 0, 1))
+			runtime·osyield();
 		if(prof.hz != 0)
 			runtime·cpuproftick(stk, n);
-		runtime·unlock(&prof.lock);
+		runtime·atomicstore(&prof.lock, 0);
 	}
 	mp->mallocing--;
 }
@@ -2804,9 +2806,11 @@ runtime·setcpuprofilerate_m(void)
 	// it would deadlock.
 	runtime·resetcpuprofiler(0);
 
-	runtime·lock(&prof.lock);
+	while(!runtime·cas(&prof.lock, 0, 1))
+		runtime·osyield();
 	prof.hz = hz;
-	runtime·unlock(&prof.lock);
+	runtime·atomicstore(&prof.lock, 0);
+
 	runtime·lock(&runtime·sched.lock);
 	runtime·sched.profilehz = hz;
 	runtime·unlock(&runtime·sched.lock);

From 8217b4a203daaa7f24590f9369c77b758dad1cd6 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 5 Sep 2014 10:04:16 -0400
Subject: [PATCH 391/423] runtime: convert panic/recover to Go

created panic1.go just so diffs were available.
After this CL is in, I'd like to move panic.go -> defer.go
and panic1.go -> panic.go.

LGTM=rsc
R=rsc, khr
CC=golang-codereviews
https://golang.org/cl/133530045
---
 src/cmd/api/goapi.go            |   1 +
 src/cmd/gc/builtin.c            |   4 +-
 src/cmd/gc/popt.c               |   2 +-
 src/cmd/gc/runtime.go           |   4 +-
 src/cmd/gc/walk.c               |   4 +-
 src/pkg/runtime/cgo/callbacks.c |   2 +-
 src/pkg/runtime/panic.c         | 213 +++-----------------------------
 src/pkg/runtime/panic1.go       | 183 +++++++++++++++++++++++++++
 src/pkg/runtime/runtime.h       |   5 +-
 src/pkg/runtime/stack.c         |  24 +++-
 src/pkg/runtime/stack_test.go   |  15 +++
 src/pkg/runtime/stubs.go        |   7 +-
 test/live.go                    |   2 +-
 13 files changed, 251 insertions(+), 215 deletions(-)
 create mode 100644 src/pkg/runtime/panic1.go

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 18c36bb175..7e8f858483 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -381,6 +381,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		src := "package runtime; type (" +
 			" _defer struct{};" +
 			" _func struct{};" +
+			" _panic struct{};" +
 			" _select struct{}; " +
 			" _type struct{};" +
 			" alg struct{};" +
diff --git a/src/cmd/gc/builtin.c b/src/cmd/gc/builtin.c
index c5bce2ead3..60b7c2f977 100644
--- a/src/cmd/gc/builtin.c
+++ b/src/cmd/gc/builtin.c
@@ -9,8 +9,8 @@ char *runtimeimport =
 	"func @\"\".throwreturn ()\n"
 	"func @\"\".throwinit ()\n"
 	"func @\"\".panicwrap (? string, ? string, ? string)\n"
-	"func @\"\".panic (? interface {})\n"
-	"func @\"\".recover (? *int32) (? interface {})\n"
+	"func @\"\".gopanic (? interface {})\n"
+	"func @\"\".gorecover (? *int32) (? interface {})\n"
 	"func @\"\".printbool (? bool)\n"
 	"func @\"\".printfloat (? float64)\n"
 	"func @\"\".printint (? int64)\n"
diff --git a/src/cmd/gc/popt.c b/src/cmd/gc/popt.c
index c8d60c5add..993bb24821 100644
--- a/src/cmd/gc/popt.c
+++ b/src/cmd/gc/popt.c
@@ -49,7 +49,7 @@ noreturn(Prog *p)
 		symlist[0] = pkglookup("panicindex", runtimepkg);
 		symlist[1] = pkglookup("panicslice", runtimepkg);
 		symlist[2] = pkglookup("throwinit", runtimepkg);
-		symlist[3] = pkglookup("panic", runtimepkg);
+		symlist[3] = pkglookup("gopanic", runtimepkg);
 		symlist[4] = pkglookup("panicwrap", runtimepkg);
 		symlist[5] = pkglookup("throwreturn", runtimepkg);
 		symlist[6] = pkglookup("selectgo", runtimepkg);
diff --git a/src/cmd/gc/runtime.go b/src/cmd/gc/runtime.go
index 646cb68aa9..128fd1a31c 100644
--- a/src/cmd/gc/runtime.go
+++ b/src/cmd/gc/runtime.go
@@ -20,8 +20,8 @@ func throwreturn()
 func throwinit()
 func panicwrap(string, string, string)
 
-func panic(interface{})
-func recover(*int32) interface{}
+func gopanic(interface{})
+func gorecover(*int32) interface{}
 
 func printbool(bool)
 func printfloat(float64)
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index 30c139200b..0de37b87fb 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -543,11 +543,11 @@ walkexpr(Node **np, NodeList **init)
 		goto ret;
 
 	case OPANIC:
-		n = mkcall("panic", T, init, n->left);
+		n = mkcall("gopanic", T, init, n->left);
 		goto ret;
 
 	case ORECOVER:
-		n = mkcall("recover", n->type, init, nod(OADDR, nodfp, N));
+		n = mkcall("gorecover", n->type, init, nod(OADDR, nodfp, N));
 		goto ret;
 
 	case OLITERAL:
diff --git a/src/pkg/runtime/cgo/callbacks.c b/src/pkg/runtime/cgo/callbacks.c
index 954a1cdcc3..eb69255db4 100644
--- a/src/pkg/runtime/cgo/callbacks.c
+++ b/src/pkg/runtime/cgo/callbacks.c
@@ -73,7 +73,7 @@ _cgo_panic_internal(byte *p)
 
 	s = runtime·gostring(p);
 	·cgoStringToEface(s, &err);
-	runtime·panic(err);
+	runtime·gopanic(err);
 }
 
 #pragma cgo_export_static _cgo_panic
diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index 152c9a3d55..e38ce740bc 100644
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -38,109 +38,11 @@ runtime·deferproc_m(void) {
 	runtime·memmove(d->args, (void*)argp, siz);
 }
 
-// Print all currently active panics.  Used when crashing.
-static void
-printpanics(Panic *p)
-{
-	if(p->link) {
-		printpanics(p->link);
-		runtime·printf("\t");
-	}
-	runtime·printf("panic: ");
-	runtime·printany(p->arg);
-	if(p->recovered)
-		runtime·printf(" [recovered]");
-	runtime·printf("\n");
-}
-
-static void recovery(G*);
-static void abortpanic(Panic*);
-static FuncVal abortpanicV = { (void(*)(void))abortpanic };
-
-// The implementation of the predeclared function panic.
-void
-runtime·panic(Eface e)
-{
-	Defer *d, dabort;
-	Panic p;
-	uintptr pc, argp;
-	void (*fn)(G*);
-
-	runtime·memclr((byte*)&p, sizeof p);
-	p.arg = e;
-	p.link = g->panic;
-	p.stackbase = g->stackbase;
-	g->panic = &p;
-
-	dabort.fn = &abortpanicV;
-	dabort.siz = sizeof(&p);
-	dabort.args[0] = &p;
-	dabort.argp = NoArgs;
-	dabort.special = true;
-
-	for(;;) {
-		d = g->defer;
-		if(d == nil)
-			break;
-		// take defer off list in case of recursive panic
-		g->defer = d->link;
-		g->ispanic = true;	// rock for runtime·newstack, where runtime·newstackcall ends up
-		argp = d->argp;
-		pc = d->pc;
-
-		// The deferred function may cause another panic,
-		// so newstackcall may not return. Set up a defer
-		// to mark this panic aborted if that happens.
-		dabort.link = g->defer;
-		g->defer = &dabort;
-		p.defer = d;
-
-		runtime·newstackcall(d->fn, (byte*)d->args, d->siz);
-
-		// Newstackcall did not panic. Remove dabort.
-		if(g->defer != &dabort)
-			runtime·throw("bad defer entry in panic");
-		g->defer = dabort.link;
-
-		runtime·freedefer(d);
-		if(p.recovered) {
-			g->panic = p.link;
-			// Aborted panics are marked but remain on the g->panic list.
-			// Recovery will unwind the stack frames containing their Panic structs.
-			// Remove them from the list and free the associated defers.
-			while(g->panic && g->panic->aborted) {
-				runtime·freedefer(g->panic->defer);
-				g->panic = g->panic->link;
-			}
-			if(g->panic == nil)	// must be done with signal
-				g->sig = 0;
-			// Pass information about recovering frame to recovery.
-			g->sigcode0 = (uintptr)argp;
-			g->sigcode1 = (uintptr)pc;
-			fn = recovery;
-			runtime·mcall(&fn);
-			runtime·throw("recovery failed"); // mcall should not return
-		}
-	}
-
-	// ran out of deferred calls - old-school panic now
-	runtime·startpanic();
-	printpanics(g->panic);
-	runtime·dopanic(0);	// should not return
-	runtime·exit(1);	// not reached
-}
-
-static void
-abortpanic(Panic *p)
-{
-	p->aborted = true;
-}
-
 // Unwind the stack after a deferred function calls recover
 // after a panic.  Then arrange to continue running as though
 // the caller of the deferred function returned normally.
-static void
-recovery(G *gp)
+void
+runtime·recovery_m(G *gp)
 {
 	void *argp;
 	uintptr pc;
@@ -199,40 +101,8 @@ runtime·unwindstack(G *gp, byte *sp)
 	}
 }
 
-// The implementation of the predeclared function recover.
-// Cannot split the stack because it needs to reliably
-// find the stack segment of its caller.
-#pragma textflag NOSPLIT
 void
-runtime·recover(byte *argp, GoOutput retbase, ...)
-{
-	Panic *p;
-	Stktop *top;
-	Eface *ret;
-
-	// Must be an unrecovered panic in progress.
-	// Must be on a stack segment created for a deferred call during a panic.
-	// Must be at the top of that segment, meaning the deferred call itself
-	// and not something it called. The top frame in the segment will have
-	// argument pointer argp == top - top->argsize.
-	// The subtraction of g->panicwrap allows wrapper functions that
-	// do not count as official calls to adjust what we consider the top frame
-	// while they are active on the stack. The linker emits adjustments of
-	// g->panicwrap in the prologue and epilogue of functions marked as wrappers.
-	ret = (Eface*)&retbase;
-	top = (Stktop*)g->stackbase;
-	p = g->panic;
-	if(p != nil && !p->recovered && top->panic && argp == (byte*)top - top->argsize - g->panicwrap) {
-		p->recovered = 1;
-		*ret = p->arg;
-	} else {
-		ret->type = nil;
-		ret->data = nil;
-	}
-}
-
-void
-runtime·startpanic(void)
+runtime·startpanic_m(void)
 {
 	if(runtime·mheap.cachealloc.size == 0) { // very early
 		runtime·printf("runtime: panic before malloc heap initialized\n");
@@ -273,28 +143,34 @@ runtime·startpanic(void)
 }
 
 void
-runtime·dopanic(int32 unused)
+runtime·dopanic_m(void)
 {
+	G *gp;
+	uintptr sp, pc;
 	static bool didothers;
 	bool crash;
 	int32 t;
 
-	if(g->sig != 0)
+	gp = g->m->ptrarg[0];
+	g->m->ptrarg[0] = nil;
+	pc = g->m->scalararg[0];
+	sp = g->m->scalararg[1];
+	if(gp->sig != 0)
 		runtime·printf("[signal %x code=%p addr=%p pc=%p]\n",
-			g->sig, g->sigcode0, g->sigcode1, g->sigpc);
+			gp->sig, gp->sigcode0, gp->sigcode1, gp->sigpc);
 
 	if((t = runtime·gotraceback(&crash)) > 0){
-		if(g != g->m->g0) {
+		if(gp != gp->m->g0) {
 			runtime·printf("\n");
-			runtime·goroutineheader(g);
-			runtime·traceback((uintptr)runtime·getcallerpc(&unused), (uintptr)runtime·getcallersp(&unused), 0, g);
+			runtime·goroutineheader(gp);
+			runtime·traceback(pc, sp, 0, gp);
 		} else if(t >= 2 || g->m->throwing > 0) {
 			runtime·printf("\nruntime stack:\n");
-			runtime·traceback((uintptr)runtime·getcallerpc(&unused), (uintptr)runtime·getcallersp(&unused), 0, g);
+			runtime·traceback(pc, sp, 0, gp);
 		}
 		if(!didothers) {
 			didothers = true;
-			runtime·tracebackothers(g);
+			runtime·tracebackothers(gp);
 		}
 	}
 	runtime·unlock(&paniclk);
@@ -341,58 +217,3 @@ runtime·canpanic(G *gp)
 #endif
 	return true;
 }
-
-void
-runtime·throw(int8 *s)
-{
-	if(g->m->throwing == 0)
-		g->m->throwing = 1;
-	runtime·startpanic();
-	runtime·printf("fatal error: %s\n", s);
-	runtime·dopanic(0);
-	*(int32*)0 = 0;	// not reached
-	runtime·exit(1);	// even more not reached
-}
-
-void
-runtime·gothrow(String s)
-{
-	if(g->m->throwing == 0)
-		g->m->throwing = 1;
-	runtime·startpanic();
-	runtime·printf("fatal error: %S\n", s);
-	runtime·dopanic(0);
-	*(int32*)0 = 0;	// not reached
-	runtime·exit(1);	// even more not reached
-}
-
-void
-runtime·panicstring(int8 *s)
-{
-	Eface err;
-
-	// m->softfloat is set during software floating point,
-	// which might cause a fault during a memory load.
-	// It increments m->locks to avoid preemption.
-	// If we're panicking, the software floating point frames
-	// will be unwound, so decrement m->locks as they would.
-	if(g->m->softfloat) {
-		g->m->locks--;
-		g->m->softfloat = 0;
-	}
-
-	if(g->m->mallocing) {
-		runtime·printf("panic: %s\n", s);
-		runtime·throw("panic during malloc");
-	}
-	if(g->m->gcing) {
-		runtime·printf("panic: %s\n", s);
-		runtime·throw("panic during gc");
-	}
-	if(g->m->locks) {
-		runtime·printf("panic: %s\n", s);
-		runtime·throw("panic holding locks");
-	}
-	runtime·newErrorCString(s, &err);
-	runtime·panic(err);
-}
diff --git a/src/pkg/runtime/panic1.go b/src/pkg/runtime/panic1.go
new file mode 100644
index 0000000000..6d939703d4
--- /dev/null
+++ b/src/pkg/runtime/panic1.go
@@ -0,0 +1,183 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+// Print all currently active panics.  Used when crashing.
+func printpanics(p *_panic) {
+	if p.link != nil {
+		printpanics(p.link)
+		print("\t")
+	}
+	print("panic: ")
+	printany(p.arg)
+	if p.recovered {
+		print(" [recovered]")
+	}
+	print("\n")
+}
+
+// The implementation of the predeclared function panic.
+func gopanic(e interface{}) {
+	gp := getg()
+	if gp.m.curg != gp {
+		gothrow("panic on m stack")
+	}
+	var p _panic
+	var dabort _defer
+	p.arg = e
+	p.link = gp._panic
+	gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
+
+	fn := abortpanic
+	dabort.fn = *(**funcval)(unsafe.Pointer(&fn))
+	dabort.siz = ptrSize
+	dabort.args[0] = noescape((unsafe.Pointer)(&p)) // TODO(khr): why do I need noescape here?
+	dabort.argp = _NoArgs
+	dabort.special = true
+
+	for {
+		d := gp._defer
+		if d == nil {
+			break
+		}
+		// take defer off list in case of recursive panic
+		gp._defer = d.link
+		gp.ispanic = true              // rock for runtime·newstack, where runtime·newstackcall ends up
+		argp := unsafe.Pointer(d.argp) // must be pointer so it gets adjusted during stack copy
+		pc := d.pc
+
+		// The deferred function may cause another panic,
+		// so newstackcall may not return. Set up a defer
+		// to mark this panic aborted if that happens.
+		dabort.link = gp._defer
+		gp._defer = (*_defer)(noescape(unsafe.Pointer(&dabort)))
+		p._defer = d
+
+		newstackcall(d.fn, unsafe.Pointer(&d.args), uint32(d.siz))
+
+		// Newstackcall did not panic. Remove dabort.
+		if gp._defer != &dabort {
+			gothrow("bad defer entry in panic")
+		}
+		gp._defer = dabort.link
+
+		// trigger shrinkage to test stack copy.  See stack_test.go:TestStackPanic
+		//GC()
+
+		freedefer(d)
+		if p.recovered {
+			gp._panic = p.link
+			// Aborted panics are marked but remain on the g.panic list.
+			// Remove them from the list and free the associated defers.
+			for gp._panic != nil && gp._panic.aborted {
+				freedefer(gp._panic._defer)
+				gp._panic = gp._panic.link
+			}
+			if gp._panic == nil { // must be done with signal
+				gp.sig = 0
+			}
+			// Pass information about recovering frame to recovery.
+			gp.sigcode0 = uintptr(argp)
+			gp.sigcode1 = pc
+			mcall(recovery_m)
+			gothrow("recovery failed") // mcall should not return
+		}
+	}
+
+	// ran out of deferred calls - old-school panic now
+	startpanic()
+	printpanics(gp._panic)
+	dopanic(0)       // should not return
+	*(*int)(nil) = 0 // not reached
+}
+
+func abortpanic(p *_panic) {
+	p.aborted = true
+}
+
+// The implementation of the predeclared function recover.
+// Cannot split the stack because it needs to reliably
+// find the stack segment of its caller.
+//go:nosplit
+func gorecover(argp uintptr) interface{} {
+	// Must be an unrecovered panic in progress.
+	// Must be on a stack segment created for a deferred call during a panic.
+	// Must be at the top of that segment, meaning the deferred call itself
+	// and not something it called. The top frame in the segment will have
+	// argument pointer argp == top - top.argsize.
+	// The subtraction of g.panicwrap allows wrapper functions that
+	// do not count as official calls to adjust what we consider the top frame
+	// while they are active on the stack. The linker emits adjustments of
+	// g.panicwrap in the prologue and epilogue of functions marked as wrappers.
+	gp := getg()
+	top := (*stktop)(unsafe.Pointer(gp.stackbase))
+	p := gp._panic
+	if p != nil && !p.recovered && top._panic && argp == gp.stackbase-uintptr(top.argsize+gp.panicwrap) {
+		p.recovered = true
+		return p.arg
+	}
+	return nil
+}
+
+func startpanic() {
+	onM(startpanic_m)
+}
+
+func dopanic(unused int) {
+	gp := getg()
+	mp := acquirem()
+	mp.ptrarg[0] = unsafe.Pointer(gp)
+	mp.scalararg[0] = getcallerpc((unsafe.Pointer)(&unused))
+	mp.scalararg[1] = getcallersp((unsafe.Pointer)(&unused))
+	onM(dopanic_m) // should never return
+	*(*int)(nil) = 0
+}
+
+func throw(s *byte) {
+	gothrow(gostringnocopy(s))
+}
+
+func gothrow(s string) {
+	gp := getg()
+	if gp.m.throwing == 0 {
+		gp.m.throwing = 1
+	}
+	startpanic()
+	print("fatal error: ", s, "\n")
+	dopanic(0)
+	*(*int)(nil) = 0 // not reached
+}
+
+func panicstring(s *int8) {
+	// m.softfloat is set during software floating point,
+	// which might cause a fault during a memory load.
+	// It increments m.locks to avoid preemption.
+	// If we're panicking, the software floating point frames
+	// will be unwound, so decrement m.locks as they would.
+	gp := getg()
+	if gp.m.softfloat != 0 {
+		gp.m.locks--
+		gp.m.softfloat = 0
+	}
+
+	if gp.m.mallocing != 0 {
+		print("panic: ", s, "\n")
+		gothrow("panic during malloc")
+	}
+	if gp.m.gcing != 0 {
+		print("panic: ", s, "\n")
+		gothrow("panic during gc")
+	}
+	if gp.m.locks != 0 {
+		print("panic: ", s, "\n")
+		gothrow("panic holding locks")
+	}
+
+	var err interface{}
+	newErrorCString(unsafe.Pointer(s), &err)
+	gopanic(err)
+}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 7007957b65..b3d1a94221 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -656,15 +656,12 @@ struct Defer
 struct Panic
 {
 	Eface	arg;		// argument to panic
-	uintptr	stackbase;	// g->stackbase in panic
 	Panic*	link;		// link to earlier panic
 	Defer*	defer;		// current executing defer
 	bool	recovered;	// whether this panic is over
 	bool	aborted;	// the panic was aborted
 };
 
-typedef struct XXX XXX;
-
 /*
  * stack traces
  */
@@ -1020,7 +1017,7 @@ void	runtime·printcomplex(Complex128);
  */
 void	runtime·newstackcall(FuncVal*, byte*, uint32);
 void	reflect·call(FuncVal*, byte*, uint32, uint32);
-void	runtime·panic(Eface);
+void	runtime·gopanic(Eface);
 void	runtime·panicindex(void);
 void	runtime·panicslice(void);
 void	runtime·panicdivide(void);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 3993a372e0..f0861e4085 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -714,8 +714,8 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 		if(adjinfo->oldstk <= (byte*)d && (byte*)d < adjinfo->oldbase) {
 			// The Defer record is on the stack.  Its fields will
 			// get adjusted appropriately.
-			// This only happens for runtime.main now, but a compiler
-			// optimization could do more of this.
+			// This only happens for runtime.main and runtime.gopanic now,
+			// but a compiler optimization could do more of this.
 			*dp = (Defer*)((byte*)d + adjinfo->delta);
 			continue;
 		}
@@ -752,6 +752,25 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 	}
 }
 
+static void
+adjustpanics(G *gp, AdjustInfo *adjinfo)
+{
+	Panic *p;
+
+	// only the topmost panic is on the current stack
+	p = gp->panic;
+	if(p == nil)
+		return;
+	if(p->link != nil) {
+		// only the topmost panic can be on the current stack
+		// (because panic runs defers on a new stack)
+		if(adjinfo->oldstk <= (byte*)p->link && (byte*)p->link < adjinfo->oldbase)
+			runtime·throw("two panics on one stack");
+	}
+	if(adjinfo->oldstk <= (byte*)p && (byte*)p < adjinfo->oldbase)
+		gp->panic = (Panic*)((byte*)p + adjinfo->delta);
+}
+
 static void
 adjustsudogs(G *gp, AdjustInfo *adjinfo)
 {
@@ -811,6 +830,7 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	// adjust other miscellaneous things that have pointers into stacks.
 	adjustctxt(gp, &adjinfo);
 	adjustdefers(gp, &adjinfo);
+	adjustpanics(gp, &adjinfo);
 	adjustsudogs(gp, &adjinfo);
 	
 	// copy the stack (including Stktop) to the new location
diff --git a/src/pkg/runtime/stack_test.go b/src/pkg/runtime/stack_test.go
index a822d73db4..7b9412af42 100644
--- a/src/pkg/runtime/stack_test.go
+++ b/src/pkg/runtime/stack_test.go
@@ -350,3 +350,18 @@ func TestStackAllOutput(t *testing.T) {
 		t.Errorf("Stack output should begin with \"goroutine \"")
 	}
 }
+
+func TestStackPanic(t *testing.T) {
+	// Test that stack copying copies panics correctly.  This is difficult
+	// to test because it is very unlikely that the stack will be copied
+	// in the middle of gopanic.  But it can happen.
+	// To make this test effective, edit panic.go:gopanic and uncomment
+	// the GC() call just before freedefer(d).
+	defer func() {
+		if x := recover(); x == nil {
+			t.Errorf("recover failed")
+		}
+	}()
+	useStack(32)
+	panic("test panic")
+}
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 8e67114f33..7ed4aaa559 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -83,6 +83,7 @@ func badonm() {
 // Call using mcall.
 func gosched_m(*g)
 func park_m(*g)
+func recovery_m(*g)
 
 // More C functions that run on the M stack.
 // Call using onM.
@@ -100,6 +101,8 @@ func setmaxthreads_m()
 func ready_m()
 func deferproc_m()
 func goexit_m()
+func startpanic_m()
+func dopanic_m()
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
@@ -133,10 +136,6 @@ func memeq(a, b unsafe.Pointer, size uintptr) bool
 var nohashcode uintptr
 var noequalcode uintptr
 
-// Go version of runtime.throw.
-// in panic.c
-func gothrow(s string)
-
 // noescape hides a pointer from escape analysis.  noescape is
 // the identity function but escape analysis doesn't think the
 // output depends on the input.  noescape is inlined and currently
diff --git a/test/live.go b/test/live.go
index 1c01f8dc49..35099d18ba 100644
--- a/test/live.go
+++ b/test/live.go
@@ -467,7 +467,7 @@ func f31(b1, b2, b3 bool) {
 		h31("b") // ERROR "live at call to newobject: autotmp_[0-9]+$" "live at call to convT2E: autotmp_[0-9]+ autotmp_[0-9]+$" "live at call to h31: autotmp_[0-9]+$"
 	}
 	if b3 {
-		panic("asdf") // ERROR "live at call to convT2E: autotmp_[0-9]+$" "live at call to panic: autotmp_[0-9]+$"
+		panic("asdf") // ERROR "live at call to convT2E: autotmp_[0-9]+$" "live at call to gopanic: autotmp_[0-9]+$"
 	}
 	print(b3)
 }

From 0f9b6affb776ac558c54edb69f07a1021a02cad6 Mon Sep 17 00:00:00 2001
From: Alex Brainman <alex.brainman@gmail.com>
Date: Fri, 5 Sep 2014 08:48:21 -0700
Subject: [PATCH 392/423] net: temporarily skip TestAcceptIgnoreSomeErrors

Update #8662

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/138120043
---
 src/pkg/net/net_windows_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/pkg/net/net_windows_test.go b/src/pkg/net/net_windows_test.go
index 2f57745e3c..750a4304b2 100644
--- a/src/pkg/net/net_windows_test.go
+++ b/src/pkg/net/net_windows_test.go
@@ -16,6 +16,8 @@ import (
 )
 
 func TestAcceptIgnoreSomeErrors(t *testing.T) {
+	t.Skip("skipping temporarily, see issue 8662")
+
 	recv := func(ln Listener) (string, error) {
 		c, err := ln.Accept()
 		if err != nil {

From f93e21ac24935304bf0e05ea6c7e36c56077011e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 5 Sep 2014 14:38:29 -0400
Subject: [PATCH 393/423] runtime: clean up sigqueue.go

Minor changes to make logic clearer.
Observed while working on the conversion.

LGTM=iant, dvyukov
R=dvyukov, iant
CC=golang-codereviews
https://golang.org/cl/140250043
---
 src/pkg/runtime/sigqueue.go | 114 +++++++++++++++++-------------------
 1 file changed, 54 insertions(+), 60 deletions(-)

diff --git a/src/pkg/runtime/sigqueue.go b/src/pkg/runtime/sigqueue.go
index 63edb664cf..2d9c24d2d2 100644
--- a/src/pkg/runtime/sigqueue.go
+++ b/src/pkg/runtime/sigqueue.go
@@ -9,19 +9,19 @@
 // so the handler communicates with a processing goroutine
 // via struct sig, below.
 //
-// sigsend() is called by the signal handler to queue a new signal.
-// signal_recv() is called by the Go program to receive a newly queued signal.
-// Synchronization between sigsend() and signal_recv() is based on the sig.state
-// variable.  It can be in 3 states: 0, HASWAITER and HASSIGNAL.
-// HASWAITER means that signal_recv() is blocked on sig.Note and there are no
+// sigsend is called by the signal handler to queue a new signal.
+// signal_recv is called by the Go program to receive a newly queued signal.
+// Synchronization between sigsend and signal_recv is based on the sig.state
+// variable.  It can be in 3 states: sigIdle, sigReceiving and sigSending.
+// sigReceiving means that signal_recv is blocked on sig.Note and there are no
 // new pending signals.
-// HASSIGNAL means that sig.mask *may* contain new pending signals,
-// signal_recv() can't be blocked in this state.
-// 0 means that there are no new pending signals and signal_recv() is not blocked.
+// sigSending means that sig.mask *may* contain new pending signals,
+// signal_recv can't be blocked in this state.
+// sigIdle means that there are no new pending signals and signal_recv is not blocked.
 // Transitions between states are done atomically with CAS.
-// When signal_recv() is unblocked, it resets sig.Note and rechecks sig.mask.
-// If several sigsend()'s and signal_recv() execute concurrently, it can lead to
-// unnecessary rechecks of sig.mask, but must not lead to missed signals
+// When signal_recv is unblocked, it resets sig.Note and rechecks sig.mask.
+// If several sigsends and signal_recv execute concurrently, it can lead to
+// unnecessary rechecks of sig.mask, but it cannot lead to missed signals
 // nor deadlocks.
 
 package runtime
@@ -38,47 +38,51 @@ var sig struct {
 }
 
 const (
-	_HASWAITER = 1
-	_HASSIGNAL = 2
+	sigIdle = iota
+	sigReceiving
+	sigSending
 )
 
 // Called from sighandler to send a signal back out of the signal handling thread.
+// Reports whether the signal was sent. If not, the caller typically crashes the program.
 func sigsend(s int32) bool {
 	bit := uint32(1) << uint(s&31)
 	if !sig.inuse || s < 0 || int(s) >= 32*len(sig.wanted) || sig.wanted[s/32]&bit == 0 {
 		return false
 	}
 
+	// Add signal to outgoing queue.
 	for {
 		mask := sig.mask[s/32]
 		if mask&bit != 0 {
-			break // signal already in queue
+			return true // signal already in queue
 		}
 		if cas(&sig.mask[s/32], mask, mask|bit) {
-			// Added to queue.
-			// Only send a wakeup if the receiver needs a kick.
-			for {
-				old := atomicload(&sig.state)
-				if old == _HASSIGNAL {
-					break
-				}
-
-				var new uint32
-				if old == _HASWAITER {
-					new = 0
-				} else { // old == 0
-					new = _HASSIGNAL
-				}
-				if cas(&sig.state, old, new) {
-					if old == _HASWAITER {
-						notewakeup(&sig.note)
-					}
-					break
-				}
-			}
 			break
 		}
 	}
+
+	// Notify receiver that queue has new bit.
+Send:
+	for {
+		switch atomicload(&sig.state) {
+		default:
+			gothrow("sigsend: inconsistent state")
+		case sigIdle:
+			if cas(&sig.state, sigIdle, sigSending) {
+				break Send
+			}
+		case sigSending:
+			// notification already pending
+			break Send
+		case sigReceiving:
+			if cas(&sig.state, sigReceiving, sigIdle) {
+				notewakeup(&sig.note)
+				break Send
+			}
+		}
+	}
+
 	return true
 }
 
@@ -86,7 +90,7 @@ func sigsend(s int32) bool {
 // Must only be called from a single goroutine at a time.
 func signal_recv() uint32 {
 	for {
-		// Serve from local copy if there are bits left.
+		// Serve any signals from local copy.
 		for i := uint32(0); i < _NSIG; i++ {
 			if sig.recv[i/32]&(1<<(i&31)) != 0 {
 				sig.recv[i/32] &^= 1 << (i & 31)
@@ -94,38 +98,28 @@ func signal_recv() uint32 {
 			}
 		}
 
-		// Check and update sig.state.
+		// Wait for updates to be available from signal sender.
+	Receive:
 		for {
-			old := atomicload(&sig.state)
-			if old == _HASWAITER {
-				gothrow("inconsistent state in signal_recv")
-			}
-
-			var new uint32
-			if old == _HASSIGNAL {
-				new = 0
-			} else { // old == 0
-				new = _HASWAITER
-			}
-			if cas(&sig.state, old, new) {
-				if new == _HASWAITER {
+			switch atomicload(&sig.state) {
+			default:
+				gothrow("signal_recv: inconsistent state")
+			case sigIdle:
+				if cas(&sig.state, sigIdle, sigReceiving) {
 					notetsleepg(&sig.note, -1)
 					noteclear(&sig.note)
+					break Receive
+				}
+			case sigSending:
+				if cas(&sig.state, sigSending, sigIdle) {
+					break Receive
 				}
-				break
 			}
 		}
 
-		// Get a new local copy.
+		// Incorporate updates from sender into local copy.
 		for i := range sig.mask {
-			var m uint32
-			for {
-				m = sig.mask[i]
-				if cas(&sig.mask[i], m, 0) {
-					break
-				}
-			}
-			sig.recv[i] = m
+			sig.recv[i] = xchg(&sig.mask[i], 0)
 		}
 	}
 }

From 4b3906fec35b81e9bce7af5e1ce64c2a431c8301 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 5 Sep 2014 14:58:54 -0400
Subject: [PATCH 394/423] runtime: handle nil ptr load/store in arm software
 floating point

We cannot let a real panic start there, because there is C code
on the stack, and worse, there is an assembly frame with a
saved copy of the registers and we have no idea which ones
are pointers.

Instead, detect the nil ptr load/store and return out of the C
and assembly into a stub that will start the call to sigpanic.

Fixes GOARM=5 build.

LGTM=iant
R=golang-codereviews, iant
CC=dave, golang-codereviews, minux, r
https://golang.org/cl/138130043
---
 src/pkg/runtime/softfloat_arm.c | 69 ++++++++++++++++++++++++++-------
 src/pkg/runtime/vlop_arm.s      | 12 ++++++
 2 files changed, 66 insertions(+), 15 deletions(-)

diff --git a/src/pkg/runtime/softfloat_arm.c b/src/pkg/runtime/softfloat_arm.c
index 09b0cf20ac..3f3f33a19e 100644
--- a/src/pkg/runtime/softfloat_arm.c
+++ b/src/pkg/runtime/softfloat_arm.c
@@ -100,6 +100,8 @@ static const uint8 conditions[10/2] = {
 	        (FLAGS_Z >> 28),     // 8: HI (C set and Z clear), 9: LS (C clear and Z set)
 };
 
+#define FAULT (0x80000000U) // impossible PC offset
+
 // returns number of words that the fp instruction
 // is occupying, 0 if next instruction isn't float.
 static uint32
@@ -221,6 +223,11 @@ stage1:	// load/store regn is cpureg, regm is 8bit offset
 
 	case 0xed900a00:	// single load
 		addr = (uint32*)(regs[regn] + regm);
+		if((uintptr)addr < 4096) {
+			if(trace)
+				runtime·printf("*** load @%p => fault\n", addr);
+			return FAULT;
+		}
 		m->freglo[regd] = addr[0];
 
 		if(trace)
@@ -230,6 +237,11 @@ stage1:	// load/store regn is cpureg, regm is 8bit offset
 
 	case 0xed900b00:	// double load
 		addr = (uint32*)(regs[regn] + regm);
+		if((uintptr)addr < 4096) {
+			if(trace)
+				runtime·printf("*** double load @%p => fault\n", addr);
+			return FAULT;
+		}
 		m->freglo[regd] = addr[0];
 		m->freghi[regd] = addr[1];
 
@@ -240,6 +252,11 @@ stage1:	// load/store regn is cpureg, regm is 8bit offset
 
 	case 0xed800a00:	// single store
 		addr = (uint32*)(regs[regn] + regm);
+		if((uintptr)addr < 4096) {
+			if(trace)
+				runtime·printf("*** store @%p => fault\n", addr);
+			return FAULT;
+		}
 		addr[0] = m->freglo[regd];
 
 		if(trace)
@@ -249,6 +266,11 @@ stage1:	// load/store regn is cpureg, regm is 8bit offset
 
 	case 0xed800b00:	// double store
 		addr = (uint32*)(regs[regn] + regm);
+		if((uintptr)addr < 4096) {
+			if(trace)
+				runtime·printf("*** double store @%p => fault\n", addr);
+			return FAULT;
+		}
 		addr[0] = m->freglo[regd];
 		addr[1] = m->freghi[regd];
 
@@ -607,42 +629,59 @@ struct Sfregs
 };
 
 static void sfloat2(void);
+void _sfloatpanic(void);
 
 #pragma textflag NOSPLIT
 uint32*
-runtime·_sfloat2(uint32 *lr, Sfregs regs)
+runtime·_sfloat2(uint32 *pc, Sfregs regs)
 {
 	void (*fn)(void);
 	
-	g->m->ptrarg[0] = lr;
+	g->m->ptrarg[0] = pc;
 	g->m->ptrarg[1] = &regs;
 	fn = sfloat2;
 	runtime·onM(&fn);
-	lr = g->m->ptrarg[0];
+	pc = g->m->ptrarg[0];
 	g->m->ptrarg[0] = nil;
-	return lr;
+	return pc;
 }
 
 static void
 sfloat2(void)
 {
-	uint32 *lr;
+	uint32 *pc;
+	G *curg;
 	Sfregs *regs;
-	uint32 skip;
+	int32 skip;
+	bool first;
 	
-	lr = g->m->ptrarg[0];
+	pc = g->m->ptrarg[0];
 	regs = g->m->ptrarg[1];
 	g->m->ptrarg[0] = nil;
 	g->m->ptrarg[1] = nil;
 
-	skip = stepflt(lr, (uint32*)&regs->r0);
-	if(skip == 0) {
-		runtime·printf("sfloat2 %p %x\n", lr, *lr);
+	first = true;
+	while(skip = stepflt(pc, (uint32*)&regs->r0)) {
+		first = false;
+		if(skip == FAULT) {
+			// Encountered bad address in store/load.
+			// Record signal information and return to assembly
+			// trampoline that fakes the call.
+			enum { SIGSEGV = 11 };
+			curg = g->m->curg;
+			curg->sig = SIGSEGV;
+			curg->sigcode0 = 0;
+			curg->sigcode1 = 0;
+			curg->sigpc = (uint32)pc;
+			pc = (uint32*)_sfloatpanic;
+			break;
+		}
+		pc += skip;
+	}
+	if(first) {
+		runtime·printf("sfloat2 %p %x\n", pc, *pc);
 		fabort(); // not ok to fail first instruction
 	}
-
-	lr += skip;
-	while(skip = stepflt(lr, (uint32*)&regs->r0))
-		lr += skip;
-	g->m->ptrarg[0] = lr;
+		
+	g->m->ptrarg[0] = pc;
 }
diff --git a/src/pkg/runtime/vlop_arm.s b/src/pkg/runtime/vlop_arm.s
index 6abcabad20..b4b905bb7a 100644
--- a/src/pkg/runtime/vlop_arm.s
+++ b/src/pkg/runtime/vlop_arm.s
@@ -94,6 +94,18 @@ TEXT _sfloat(SB), NOSPLIT, $68-0 // 4 arg + 14*4 saved regs + cpsr + return valu
 	MOVW	8(R13), R0
 	RET
 
+// trampoline for _sfloat2 panic.
+// _sfloat2 instructs _sfloat to return here.
+// We need to push a fake saved LR onto the stack,
+// load the signal fault address into LR, and jump
+// to the real sigpanic.
+// This simulates what sighandler does for a memory fault.
+TEXT _sfloatpanic(SB),NOSPLIT,$-4
+	MOVW	$0, R0
+	MOVW.W	R0, -4(R13)
+	MOVW	g_sigpc(g), LR
+	B	runtime·sigpanic(SB)
+
 // func udiv(n, d uint32) (q, r uint32)
 // Reference: 
 // Sloss, Andrew et. al; ARM System Developer's Guide: Designing and Optimizing System Software

From fcbe51c9e3ecbb1cb5d8d50f64b0bc42a6a0c7f5 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 5 Sep 2014 14:59:09 -0400
Subject: [PATCH 395/423] misc/cgo/test: make issue5548 test pickier

If there is doubt about passing arguments correctly
(as there is in this test), there should be doubt about
getting the results back intact too. Using 0 and 1
(especially 0 for success) makes it easy to get a PASS
accidentally when the return value is not actually
being propagated. Use less common values.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews, r
https://golang.org/cl/141110043
---
 misc/cgo/test/issue5548.go | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

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

From f8f630f5ecb5e30c9feadab5277f393c58da71f6 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 5 Sep 2014 16:51:45 -0400
Subject: [PATCH 396/423] runtime: use reflect.call during panic instead of
 newstackcall

newstackcall creates a new stack segment, and we want to
be able to throw away all that code.

LGTM=khr
R=khr, iant
CC=dvyukov, golang-codereviews, r
https://golang.org/cl/139270043
---
 misc/cgo/test/callback.go       |  1 +
 misc/cgo/test/issue7695_test.go |  3 ++
 src/cmd/dist/buildruntime.c     |  2 +
 src/pkg/reflect/value.go        |  8 +--
 src/pkg/runtime/asm_386.s       | 81 +++++++++--------------------
 src/pkg/runtime/asm_amd64.s     | 87 +++++++++++--------------------
 src/pkg/runtime/asm_amd64p32.s  | 84 ++++++++++++------------------
 src/pkg/runtime/asm_arm.s       | 74 +++++++++-----------------
 src/pkg/runtime/cgocall.go      |  2 +-
 src/pkg/runtime/malloc.go       |  2 +-
 src/pkg/runtime/panic.go        |  2 +-
 src/pkg/runtime/panic1.go       | 17 ++++--
 src/pkg/runtime/runtime.h       |  5 +-
 src/pkg/runtime/stack.c         | 92 ++++++++++++++-------------------
 src/pkg/runtime/stubs.go        |  3 +-
 test/fixedbugs/issue4388.go     |  6 +--
 test/fixedbugs/issue5856.go     |  2 +-
 17 files changed, 187 insertions(+), 284 deletions(-)

diff --git a/misc/cgo/test/callback.go b/misc/cgo/test/callback.go
index 98f653ef77..281e79494e 100644
--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -153,6 +153,7 @@ func testCallbackCallers(t *testing.T) {
 	n := 0
 	name := []string{
 		"test.goCallback",
+		"runtime.call16",
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
 		"runtime.cgocallback_gofunc",
diff --git a/misc/cgo/test/issue7695_test.go b/misc/cgo/test/issue7695_test.go
index 4bd6f8e734..de2fc03d42 100644
--- a/misc/cgo/test/issue7695_test.go
+++ b/misc/cgo/test/issue7695_test.go
@@ -2,6 +2,9 @@
 // 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.
 
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index 3a274e05cc..246bd2710d 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -244,6 +244,8 @@ ok:
 				aggr = "seh";
 			else if(streq(fields.p[1], "Alg"))
 				aggr = "alg";
+			else if(streq(fields.p[1], "Panic"))
+				aggr = "panic";
 		}
 		if(hasprefix(lines.p[i], "}"))
 			aggr = nil;
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index 76086c561b..b02b8ea0c2 100644
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -563,7 +563,7 @@ func (v Value) call(op string, in []Value) []Value {
 	}
 
 	// Call.
-	call(fn, args, uint32(frametype.size), uint32(retOffset))
+	call(fn, args, uint32(frametype.size), uint32(retOffset), nil)
 
 	// For testing; see TestCallMethodJump.
 	if callGC {
@@ -761,7 +761,7 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer) {
 	memmove(unsafe.Pointer(uintptr(args)+ptrSize), frame, argSize-ptrSize)
 
 	// Call.
-	call(fn, args, uint32(frametype.size), uint32(retOffset))
+	call(fn, args, uint32(frametype.size), uint32(retOffset), nil)
 
 	// Copy return values. On amd64p32, the beginning of return values
 	// is 64-bit aligned, so the caller's frame layout (which doesn't have
@@ -2700,7 +2700,9 @@ func mapiterkey(it unsafe.Pointer) (key unsafe.Pointer)
 func mapiternext(it unsafe.Pointer)
 func maplen(m unsafe.Pointer) int
 
-func call(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
+// panicpos is for use by runtime and should be nil in all calls in this package
+func call(fn, arg unsafe.Pointer, n uint32, retoffset uint32, panicpos unsafe.Pointer)
+
 func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
 
 // Dummy annotation marking that the value x escapes,
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 25911a5b9c..0b5ded6836 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -283,6 +283,12 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	JNE	2(PC)
 	INT	$3
 
+	// Cannot grow signal stack.
+	MOVL	m_gsignal(BX), SI
+	CMPL	g(CX), SI
+	JNE	2(PC)
+	INT	$3
+
 	// frame size in DI
 	// arg size in AX
 	// Save in m.
@@ -322,56 +328,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	MOVL	$0, DX
 	JMP runtime·morestack(SB)
 
-// Called from panic.  Mimics morestack,
-// reuses stack growth code to create a frame
-// with the desired args running the desired function.
-//
-// func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-
-	// Save our caller's state as the PC and SP to
-	// restore when returning from f.
-	MOVL	0(SP), AX	// our caller's PC
-	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAL	fv+0(FP), AX	// our caller's SP
-	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
-	MOVL	g(CX), AX
-	MOVL	AX, (m_morebuf+gobuf_g)(BX)
-
-	// Save our own state as the PC and SP to restore
-	// if this goroutine needs to be restarted.
-	MOVL	$runtime·newstackcall(SB), (g_sched+gobuf_pc)(AX)
-	MOVL	SP, (g_sched+gobuf_sp)(AX)
-
-	// Set up morestack arguments to call f on a new stack.
-	// We set f's frame size to 1, as a hint to newstack
-	// that this is a call from runtime·newstackcall.
-	// If it turns out that f needs a larger frame than
-	// the default stack, f's usual stack growth prolog will
-	// allocate a new segment (and recopy the arguments).
-	MOVL	fv+0(FP), AX	// fn
-	MOVL	addr+4(FP), DX	// arg frame
-	MOVL	size+8(FP), CX	// arg size
-
-	MOVL	AX, m_cret(BX)	// f's PC
-	MOVL	DX, m_moreargp(BX)	// f's argument pointer
-	MOVL	CX, m_moreargsize(BX)	// f's argument size
-	MOVL	$1, m_moreframesize(BX)	// f's frame size
-
-	// Call newstack on m->g0's stack.
-	MOVL	m_g0(BX), BP
-	get_tls(CX)
-	MOVL	BP, g(CX)
-	MOVL	(g_sched+gobuf_sp)(BP), SP
-	CALL	runtime·newstack(SB)
-	MOVL	$0, 0x1103	// crash if newstack returns
-	RET
-
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize uint32).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -379,11 +337,11 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
 #define DISPATCH(NAME,MAXSIZE)		\
 	CMPL	CX, $MAXSIZE;		\
 	JA	3(PC);			\
-	MOVL	$NAME(SB), AX;	\
+	MOVL	$NAME(SB), AX;		\
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT reflect·call(SB), NOSPLIT, $0-16
+TEXT reflect·call(SB), NOSPLIT, $0-20
 	MOVL	argsize+8(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -415,11 +373,11 @@ TEXT reflect·call(SB), NOSPLIT, $0-16
 	MOVL	$runtime·badreflectcall(SB), AX
 	JMP	AX
 
-// Argument map for the callXX frames.  Each has one
-// stack map (for the single call) with 3 arguments.
+// Argument map for the callXX frames.  Each has one stack map.
 DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_reflectcall<>+0x04(SB)/4, $6  // 3 args
-DATA gcargs_reflectcall<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4))
+DATA gcargs_reflectcall<>+0x04(SB)/4, $10  // 5 words
+DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsScalar<<6))
+DATA gcargs_reflectcall<>+0x09(SB)/1, $(const_BitsPointer)
 GLOBL gcargs_reflectcall<>(SB),RODATA,$12
 
 // callXX frames have no locals
@@ -428,7 +386,7 @@ DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-16;	\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-20;	\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -436,11 +394,22 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-16;	\
 	MOVL	argsize+8(FP), CX;		\
 	MOVL	SP, DI;				\
 	REP;MOVSB;				\
+	/* initialize panic argp */		\
+	MOVL	panic+16(FP), CX;		\
+	CMPL	CX, $0;				\
+	JEQ	3(PC);				\
+	LEAL	(MAXSIZE+4)(SP), BX;		\
+	MOVL	BX, panic_argp(CX);		\
 	/* call function */			\
 	MOVL	f+0(FP), DX;			\
 	MOVL	(DX), AX; 			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	CALL	AX;				\
+	/* clear panic argp */			\
+	MOVL	panic+16(FP), CX;		\
+	CMPL	CX, $0;				\
+	JEQ	2(PC);				\
+	MOVL	$0, panic_argp(CX);		\
 	/* copy return values back */		\
 	MOVL	argptr+4(FP), DI;		\
 	MOVL	argsize+8(FP), CX;		\
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 962074582d..587fcf4806 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -274,6 +274,12 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	JNE	2(PC)
 	INT	$3
 
+	// Cannot grow signal stack (m->gsignal).
+	MOVQ	m_gsignal(BX), SI
+	CMPQ	g(CX), SI
+	JNE	2(PC)
+	INT	$3
+
 	// Called from f.
 	// Set m->morebuf to f's caller.
 	MOVQ	8(SP), AX	// f's caller's PC
@@ -301,57 +307,8 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	MOVQ	$0, 0x1003	// crash if newstack returns
 	RET
 
-// Called from panic.  Mimics morestack,
-// reuses stack growth code to create a frame
-// with the desired args running the desired function.
-//
-// func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-
-	// Save our caller's state as the PC and SP to
-	// restore when returning from f.
-	MOVQ	0(SP), AX	// our caller's PC
-	MOVQ	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAQ	fv+0(FP), AX	// our caller's SP
-	MOVQ	AX, (m_morebuf+gobuf_sp)(BX)
-	MOVQ	g(CX), AX
-	MOVQ	AX, (m_morebuf+gobuf_g)(BX)
-	
-	// Save our own state as the PC and SP to restore
-	// if this goroutine needs to be restarted.
-	MOVQ	$runtime·newstackcall(SB), BP
-	MOVQ	BP, (g_sched+gobuf_pc)(AX)
-	MOVQ	SP, (g_sched+gobuf_sp)(AX)
-
-	// Set up morestack arguments to call f on a new stack.
-	// We set f's frame size to 1, as a hint to newstack
-	// that this is a call from runtime·newstackcall.
-	// If it turns out that f needs a larger frame than
-	// the default stack, f's usual stack growth prolog will
-	// allocate a new segment (and recopy the arguments).
-	MOVQ	fv+0(FP), AX	// fn
-	MOVQ	addr+8(FP), DX	// arg frame
-	MOVL	size+16(FP), CX	// arg size
-
-	MOVQ	AX, m_cret(BX)	// f's PC
-	MOVQ	DX, m_moreargp(BX)	// argument frame pointer
-	MOVL	CX, m_moreargsize(BX)	// f's argument size
-	MOVL	$1, m_moreframesize(BX)	// f's frame size
-
-	// Call newstack on m->g0's stack.
-	MOVQ	m_g0(BX), BP
-	get_tls(CX)
-	MOVQ	BP, g(CX)
-	MOVQ	(g_sched+gobuf_sp)(BP), SP
-	CALL	runtime·newstack(SB)
-	MOVQ	$0, 0x1103	// crash if newstack returns
-	RET
-
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize uint32).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -363,7 +320,7 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $0-20
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT reflect·call(SB), NOSPLIT, $0-24
+TEXT reflect·call(SB), NOSPLIT, $0-32
 	MOVLQZX argsize+16(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -395,11 +352,10 @@ TEXT reflect·call(SB), NOSPLIT, $0-24
 	MOVQ	$runtime·badreflectcall(SB), AX
 	JMP	AX
 
-// Argument map for the callXX frames.  Each has one
-// stack map (for the single call) with 3 arguments.
+// Argument map for the callXX frames.  Each has one stack map.
 DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_reflectcall<>+0x04(SB)/4, $6  // 3 args
-DATA gcargs_reflectcall<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4))
+DATA gcargs_reflectcall<>+0x04(SB)/4, $8  // 4 words
+DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsPointer<<6))
 GLOBL gcargs_reflectcall<>(SB),RODATA,$12
 
 // callXX frames have no locals
@@ -407,8 +363,16 @@ DATA gclocals_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
 DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
+// CALLFN is marked as a WRAPPER so that a deferred reflect.call func will
+// see the right answer for recover. However, CALLFN is also how we start
+// the panic in the first place. We record the panic argp if this is the start of
+// a panic. Since the wrapper adjustment has already happened, though
+// (in the implicit prologue), we have to write not SP but MAXSIZE+8+SP into
+// p.argp. The MAXSIZE+8 will counter the MAXSIZE+8 the wrapper prologue
+// added to g->panicwrap.
+
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-24;	\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-32;		\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -416,10 +380,21 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-24;	\
 	MOVLQZX argsize+16(FP), CX;		\
 	MOVQ	SP, DI;				\
 	REP;MOVSB;				\
+	/* initialize panic argp */		\
+	MOVQ	panic+24(FP), CX;		\
+	CMPQ	CX, $0;				\
+	JEQ	3(PC);				\
+	LEAQ	(MAXSIZE+8)(SP), BX;		\
+	MOVQ	BX, panic_argp(CX);		\
 	/* call function */			\
 	MOVQ	f+0(FP), DX;			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	CALL	(DX);				\
+	/* clear panic argp */			\
+	MOVQ	panic+24(FP), CX;		\
+	CMPQ	CX, $0;				\
+	JEQ	2(PC);				\
+	MOVQ	$0, panic_argp(CX);		\
 	/* copy return values back */		\
 	MOVQ	argptr+8(FP), DI;		\
 	MOVLQZX	argsize+16(FP), CX;		\
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 64a436495f..5647d77627 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -247,6 +247,12 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	JNE	2(PC)
 	MOVL	0, AX
 
+	// Cannot grow signal stack (m->gsignal).
+	MOVL	m_gsignal(BX), SI
+	CMPL	g(CX), SI
+	JNE	2(PC)
+	MOVL	0, AX
+
 	// Called from f.
 	// Set m->morebuf to f's caller.
 	MOVL	8(SP), AX	// f's caller's PC
@@ -274,57 +280,8 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	MOVL	$0, 0x1003	// crash if newstack returns
 	RET
 
-// Called from panic.  Mimics morestack,
-// reuses stack growth code to create a frame
-// with the desired args running the desired function.
-//
-// func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-
-	// Save our caller's state as the PC and SP to
-	// restore when returning from f.
-	MOVL	0(SP), AX	// our caller's PC
-	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
-	LEAL	fv+0(FP), AX	// our caller's SP
-	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
-	MOVL	g(CX), AX
-	MOVL	AX, (m_morebuf+gobuf_g)(BX)
-	
-	// Save our own state as the PC and SP to restore
-	// if this goroutine needs to be restarted.
-	MOVL	$runtime·newstackcall(SB), DI
-	MOVL	DI, (g_sched+gobuf_pc)(AX)
-	MOVL	SP, (g_sched+gobuf_sp)(AX)
-
-	// Set up morestack arguments to call f on a new stack.
-	// We set f's frame size to 1, as a hint to newstack
-	// that this is a call from runtime·newstackcall.
-	// If it turns out that f needs a larger frame than
-	// the default stack, f's usual stack growth prolog will
-	// allocate a new segment (and recopy the arguments).
-	MOVL	fv+0(FP), AX	// fn
-	MOVL	addr+4(FP), DX	// arg frame
-	MOVL	size+8(FP), CX	// arg size
-
-	MOVQ	AX, m_cret(BX)	// f's PC
-	MOVL	DX, m_moreargp(BX)	// argument frame pointer
-	MOVL	CX, m_moreargsize(BX)	// f's argument size
-	MOVL	$1, m_moreframesize(BX)	// f's frame size
-
-	// Call newstack on m->g0's stack.
-	MOVL	m_g0(BX), BX
-	get_tls(CX)
-	MOVL	BX, g(CX)
-	MOVL	(g_sched+gobuf_sp)(BX), SP
-	CALL	runtime·newstack(SB)
-	MOVL	$0, 0x1103	// crash if newstack returns
-	RET
-
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize uint32).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -368,17 +325,42 @@ TEXT reflect·call(SB), NOSPLIT, $0-20
 	MOVL	$runtime·badreflectcall(SB), AX
 	JMP	AX
 
+// Argument map for the callXX frames.  Each has one stack map.
+DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
+DATA gcargs_reflectcall<>+0x04(SB)/4, $10  // 5 words
+DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsScalar<<6))
+DATA gcargs_reflectcall<>+0x09(SB)/1, $(const_BitsPointer)
+GLOBL gcargs_reflectcall<>(SB),RODATA,$12
+
+// callXX frames have no locals
+DATA gclocals_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
+DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
+GLOBL gclocals_reflectcall<>(SB),RODATA,$8
+
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-16;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
+	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
+	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
 	MOVL	argptr+4(FP), SI;		\
 	MOVL	argsize+8(FP), CX;		\
 	MOVL	SP, DI;				\
 	REP;MOVSB;				\
+	/* initialize panic argp */		\
+	MOVL	panic+16(FP), CX;		\
+	CMPL	CX, $0;				\
+	JEQ	3(PC);				\
+	LEAL	(MAXSIZE+8)(SP), BX;		\
+	MOVL	BX, panic_argp(CX);		\
 	/* call function */			\
 	MOVL	f+0(FP), DX;			\
 	MOVL	(DX), AX;				\
 	CALL	AX; \
+	/* clear panic argp */			\
+	MOVL	panic+16(FP), CX;		\
+	CMPL	CX, $0;				\
+	JEQ	2(PC);				\
+	MOVL	$0, panic_argp(CX);		\
 	/* copy return values back */		\
 	MOVL	argptr+4(FP), DI;		\
 	MOVL	argsize+8(FP), CX;		\
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 9e68e099e2..96a21ceac1 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -269,6 +269,11 @@ TEXT runtime·morestack(SB),NOSPLIT,$-4-0
 	CMP	g, R4
 	BL.EQ	runtime·abort(SB)
 
+	// Cannot grow signal stack (m->gsignal).
+	MOVW	m_gsignal(R8), R4
+	CMP	g, R4
+	BL.EQ	runtime·abort(SB)
+
 	MOVW	R1, m_moreframesize(R8)
 	MOVW	R2, m_moreargsize(R8)
 
@@ -300,49 +305,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$-4-0
 	MOVW	$0, R7
 	B runtime·morestack(SB)
 
-// Called from panic.  Mimics morestack,
-// reuses stack growth code to create a frame
-// with the desired args running the desired function.
-//
-// func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB),NOSPLIT,$-4-12
-	// Save our caller's state as the PC and SP to
-	// restore when returning from f.
-	MOVW	g_m(g), R8
-	MOVW	LR, (m_morebuf+gobuf_pc)(R8)	// our caller's PC
-	MOVW	SP, (m_morebuf+gobuf_sp)(R8)	// our caller's SP
-	MOVW	g,  (m_morebuf+gobuf_g)(R8)
-
-	// Save our own state as the PC and SP to restore
-	// if this goroutine needs to be restarted.
-	MOVW	$runtime·newstackcall(SB), R11
-	MOVW	R11, (g_sched+gobuf_pc)(g)
-	MOVW	LR, (g_sched+gobuf_lr)(g)
-	MOVW	SP, (g_sched+gobuf_sp)(g)
-
-	// Set up morestack arguments to call f on a new stack.
-	// We set f's frame size to 1, as a hint to newstack
-	// that this is a call from runtime·newstackcall.
-	// If it turns out that f needs a larger frame than
-	// the default stack, f's usual stack growth prolog will
-	// allocate a new segment (and recopy the arguments).
-	MOVW	4(SP), R0			// fn
-	MOVW	8(SP), R1			// arg frame
-	MOVW	12(SP), R2			// arg size
-
-	MOVW	R0, m_cret(R8)			// f's PC
-	MOVW	R1, m_moreargp(R8)		// f's argument pointer
-	MOVW	R2, m_moreargsize(R8)		// f's argument size
-	MOVW	$1, R3
-	MOVW	R3, m_moreframesize(R8)		// f's frame size
-
-	// Call newstack on m->g0's stack.
-	MOVW	m_g0(R8), g
-	MOVW	(g_sched+gobuf_sp)(g), SP
-	B	runtime·newstack(SB)
-
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize uint32).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -350,10 +314,10 @@ TEXT runtime·newstackcall(SB),NOSPLIT,$-4-12
 #define DISPATCH(NAME,MAXSIZE)		\
 	CMP	$MAXSIZE, R0;		\
 	B.HI	3(PC);			\
-	MOVW	$NAME(SB), R1;	\
+	MOVW	$NAME(SB), R1;		\
 	B	(R1)
 
-TEXT reflect·call(SB),NOSPLIT,$-4-16
+TEXT reflect·call(SB),NOSPLIT,$-4-20
 	MOVW	argsize+8(FP), R0
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -385,11 +349,11 @@ TEXT reflect·call(SB),NOSPLIT,$-4-16
 	MOVW	$runtime·badreflectcall(SB), R1
 	B	(R1)
 
-// Argument map for the callXX frames.  Each has one
-// stack map (for the single call) with 3 arguments.
+// Argument map for the callXX frames.  Each has one stack map.
 DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_reflectcall<>+0x04(SB)/4, $6  // 3 args
-DATA gcargs_reflectcall<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4))
+DATA gcargs_reflectcall<>+0x04(SB)/4, $10  // 5 words
+DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsScalar<<6))
+DATA gcargs_reflectcall<>+0x09(SB)/1, $(const_BitsPointer)
 GLOBL gcargs_reflectcall<>(SB),RODATA,$12
 
 // callXX frames have no locals
@@ -398,7 +362,7 @@ DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-16;	\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -411,11 +375,23 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-16;	\
 	MOVBU.P R5, 1(R1);			\
 	SUB	$1, R2, R2;			\
 	B	-5(PC);				\
+	/* initialize panic argp */		\
+	MOVW	panic+16(FP), R4;		\
+	CMP	$0, R4;				\
+	B.EQ	3(PC);				\
+	ADD	$(4+MAXSIZE+4), R13, R5;	\
+	MOVW	R5, panic_argp(R4);		\
 	/* call function */			\
 	MOVW	f+0(FP), R7;			\
 	MOVW	(R7), R0;			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	BL	(R0);				\
+	/* clear panic argp */			\
+	MOVW	panic+16(FP), R4;		\
+	CMP	$0, R4;				\
+	B.EQ	3(PC);				\
+	MOVW	$0, R5;				\
+	MOVW	R5, panic_argp(R4);		\
 	/* copy return values back */		\
 	MOVW	argptr+4(FP), R0;		\
 	MOVW	argsize+8(FP), R2;		\
diff --git a/src/pkg/runtime/cgocall.go b/src/pkg/runtime/cgocall.go
index 1037c5dc21..4040fee8e6 100644
--- a/src/pkg/runtime/cgocall.go
+++ b/src/pkg/runtime/cgocall.go
@@ -225,7 +225,7 @@ func cgocallbackg1() {
 	}
 
 	// Invoke callback.
-	newstackcall(cb.fn, cb.arg, uint32(cb.argsize))
+	reflectcall(unsafe.Pointer(cb.fn), unsafe.Pointer(cb.arg), uint32(cb.argsize), 0, nil)
 
 	if raceenabled {
 		racereleasemerge(unsafe.Pointer(&racecgosync))
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 883ca0cef7..664b03b151 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -743,7 +743,7 @@ func runfinq() {
 				default:
 					gothrow("bad kind in runfinq")
 				}
-				reflectcall(unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
+				reflectcall(unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), nil)
 
 				// drop finalizer queue references to finalized object
 				f.fn = nil
diff --git a/src/pkg/runtime/panic.go b/src/pkg/runtime/panic.go
index 1e35561d15..b8fa213f66 100644
--- a/src/pkg/runtime/panic.go
+++ b/src/pkg/runtime/panic.go
@@ -208,7 +208,7 @@ func Goexit() {
 	for gp._defer != nil {
 		d := gp._defer
 		gp._defer = d.link
-		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz))
+		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz), nil)
 		freedefer(d)
 		// Note: we ignore recovers here because Goexit isn't a panic
 	}
diff --git a/src/pkg/runtime/panic1.go b/src/pkg/runtime/panic1.go
index 6d939703d4..7bdfb4b2c0 100644
--- a/src/pkg/runtime/panic1.go
+++ b/src/pkg/runtime/panic1.go
@@ -56,10 +56,17 @@ func gopanic(e interface{}) {
 		dabort.link = gp._defer
 		gp._defer = (*_defer)(noescape(unsafe.Pointer(&dabort)))
 		p._defer = d
+		p.outerwrap = gp.panicwrap
 
-		newstackcall(d.fn, unsafe.Pointer(&d.args), uint32(d.siz))
+		// TODO(rsc): I am pretty sure the panicwrap manipulation here is not correct.
+		// It is close enough to pass all the tests we have, but I think it needs to be
+		// restored during recovery too. I will write better tests and fix it in a separate CL.
 
-		// Newstackcall did not panic. Remove dabort.
+		gp.panicwrap = 0
+		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz), (*_panic)(noescape(unsafe.Pointer(&p))))
+		gp.panicwrap = p.outerwrap
+
+		// reflectcall did not panic. Remove dabort.
 		if gp._defer != &dabort {
 			gothrow("bad defer entry in panic")
 		}
@@ -114,9 +121,11 @@ func gorecover(argp uintptr) interface{} {
 	// while they are active on the stack. The linker emits adjustments of
 	// g.panicwrap in the prologue and epilogue of functions marked as wrappers.
 	gp := getg()
-	top := (*stktop)(unsafe.Pointer(gp.stackbase))
 	p := gp._panic
-	if p != nil && !p.recovered && top._panic && argp == gp.stackbase-uintptr(top.argsize+gp.panicwrap) {
+	//	if p != nil {
+	//		println("recover?", p, p.recovered, hex(argp), hex(p.argp), uintptr(gp.panicwrap), p != nil && !p.recovered && argp == p.argp-uintptr(gp.panicwrap))
+	//	}
+	if p != nil && !p.recovered && argp == p.argp-uintptr(gp.panicwrap) {
 		p.recovered = true
 		return p.arg
 	}
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index b3d1a94221..4f279db3fb 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -452,7 +452,6 @@ struct	Stktop
 	uint32	panicwrap;
 
 	uint8*	argp;	// pointer to arguments in old frame
-	bool	panic;	// is this frame the top of a panic?
 };
 struct	SigTab
 {
@@ -658,6 +657,8 @@ struct Panic
 	Eface	arg;		// argument to panic
 	Panic*	link;		// link to earlier panic
 	Defer*	defer;		// current executing defer
+	uintptr	argp;		// pointer to arguments of deferred call, for recover
+	uint32	outerwrap;	// outer gp->panicwrap
 	bool	recovered;	// whether this panic is over
 	bool	aborted;	// the panic was aborted
 };
@@ -1015,8 +1016,6 @@ void	runtime·printcomplex(Complex128);
 /*
  * runtime go-called
  */
-void	runtime·newstackcall(FuncVal*, byte*, uint32);
-void	reflect·call(FuncVal*, byte*, uint32, uint32);
 void	runtime·gopanic(Eface);
 void	runtime·panicindex(void);
 void	runtime·panicslice(void);
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index f0861e4085..facf0c5e82 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -25,6 +25,8 @@ enum
 	StackFaultOnFree = 0,	// old stacks are mapped noaccess to detect use after free
 
 	StackCache = 1,
+	
+	StackCopyAlways = 1,	// expect to be able to copy stacks 100% of the time
 };
 
 // Global pool of spans that have free stacks.
@@ -324,6 +326,9 @@ runtime·oldstack(void)
 	int64 goid;
 	int32 oldstatus;
 
+	if(StackCopyAlways)
+		runtime·throw("unexpected call to oldstack");
+
 	gp = g->m->curg;
 	top = (Stktop*)gp->stackbase;
 	if(top == nil)
@@ -442,14 +447,14 @@ checkframecopy(Stkframe *frame, void *arg)
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil) {
 			cinfo->frames = -1;
-			if(StackDebug >= 1)
-				runtime·printf("copystack: no locals info for %s\n", runtime·funcname(f));
+			if(StackDebug >= 1 || StackCopyAlways)
+				runtime·printf("runtime: copystack: no locals info for %s\n", runtime·funcname(f));
 			return false;
 		}
 		if(stackmap->n <= 0) {
 			cinfo->frames = -1;
-			if(StackDebug >= 1)
-				runtime·printf("copystack: locals size info only for %s\n", runtime·funcname(f));
+			if(StackDebug >= 1 || StackCopyAlways)
+				runtime·printf("runtime: copystack: locals size info only for %s\n", runtime·funcname(f));
 			return false;
 		}
 	}
@@ -457,8 +462,8 @@ checkframecopy(Stkframe *frame, void *arg)
 		stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
 		if(stackmap == nil) {
 			cinfo->frames = -1;
-			if(StackDebug >= 1)
-				runtime·printf("copystack: no arg info for %s\n", runtime·funcname(f));
+			if(StackDebug >= 1 || StackCopyAlways)
+				runtime·printf("runtime: copystack: no arg info for %s\n", runtime·funcname(f));
 			return false;
 		}
 	}
@@ -510,8 +515,8 @@ copyabletopsegment(G *gp)
 			continue;
 		f = runtime·findfunc((uintptr)fn->fn);
 		if(f == nil) {
-			if(StackDebug >= 1)
-				runtime·printf("copystack: no func for deferred pc %p\n", fn->fn);
+			if(StackDebug >= 1 || StackCopyAlways)
+				runtime·printf("runtime: copystack: no func for deferred pc %p\n", fn->fn);
 			return -1;
 		}
 
@@ -522,14 +527,14 @@ copyabletopsegment(G *gp)
 		// C (particularly, cgo) lies to us.  See issue 7695.
 		stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
 		if(stackmap == nil || stackmap->n <= 0) {
-			if(StackDebug >= 1)
-				runtime·printf("copystack: no arg info for deferred %s\n", runtime·funcname(f));
+			if(StackDebug >= 1 || StackCopyAlways)
+				runtime·printf("runtime: copystack: no arg info for deferred %s\n", runtime·funcname(f));
 			return -1;
 		}
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil || stackmap->n <= 0) {
-			if(StackDebug >= 1)
-				runtime·printf("copystack: no local info for deferred %s\n", runtime·funcname(f));
+			if(StackDebug >= 1 || StackCopyAlways)
+				runtime·printf("runtime: copystack: no local info for deferred %s\n", runtime·funcname(f));
 			return -1;
 		}
 
@@ -755,20 +760,17 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 static void
 adjustpanics(G *gp, AdjustInfo *adjinfo)
 {
-	Panic *p;
+	Panic *p, **l;
 
 	// only the topmost panic is on the current stack
-	p = gp->panic;
-	if(p == nil)
-		return;
-	if(p->link != nil) {
-		// only the topmost panic can be on the current stack
-		// (because panic runs defers on a new stack)
-		if(adjinfo->oldstk <= (byte*)p->link && (byte*)p->link < adjinfo->oldbase)
-			runtime·throw("two panics on one stack");
+	for(l = &gp->panic; (p = *l) != nil; ) {
+		if(adjinfo->oldstk <= (byte*)p && (byte*)p < adjinfo->oldbase)
+			*l = (Panic*)((byte*)p + adjinfo->delta);
+		l = &p->link;
+		
+		if(adjinfo->oldstk <= (byte*)p->argp && (byte*)p->argp < adjinfo->oldbase)
+			p->argp += adjinfo->delta;
 	}
-	if(adjinfo->oldstk <= (byte*)p && (byte*)p < adjinfo->oldbase)
-		gp->panic = (Panic*)((byte*)p + adjinfo->delta);
 }
 
 static void
@@ -867,11 +869,10 @@ runtime·round2(int32 x)
 	return 1 << s;
 }
 
-// Called from runtime·newstackcall or from runtime·morestack when a new
-// stack segment is needed.  Allocate a new stack big enough for
-// m->moreframesize bytes, copy m->moreargsize bytes to the new frame,
-// and then act as though runtime·lessstack called the function at
-// m->morepc.
+// Called from runtime·morestack when a new stack segment is needed.
+// Allocate a new stack big enough for m->moreframesize bytes,
+// copy m->moreargsize bytes to the new frame,
+// and then act as though runtime·lessstack called the function at m->morepc.
 //
 // g->atomicstatus will be Grunning, Gsyscall or Gscanrunning, Gscansyscall upon entry. 
 // If the GC is trying to stop this g then it will set preemptscan to true.
@@ -879,14 +880,13 @@ void
 runtime·newstack(void)
 {
 	int32 framesize, argsize, oldstatus, oldsize, newsize, nframes;
-	Stktop *top, *oldtop;
+	Stktop *top;
 	byte *stk, *oldstk, *oldbase;
 	uintptr sp;
 	uintptr *src, *dst, *dstend;
 	G *gp;
 	Gobuf label, morebuf;
 	void *moreargp;
-	bool newstackcall;
 
 	if(g->m->forkstackguard)
 		runtime·throw("split stack after fork");
@@ -894,6 +894,8 @@ runtime·newstack(void)
 		runtime·printf("runtime: newstack called from g=%p\n"
 			"\tm=%p m->curg=%p m->g0=%p m->gsignal=%p\n",
 			g->m->morebuf.g, g->m, g->m->curg, g->m->g0, g->m->gsignal);
+		morebuf = g->m->morebuf;
+		runtime·traceback(morebuf.pc, morebuf.sp, morebuf.lr, morebuf.g);
 		runtime·throw("runtime: wrong goroutine in newstack");
 	}
 	if(g->throwsplit)
@@ -917,13 +919,8 @@ runtime·newstack(void)
 
 	runtime·casgstatus(gp, oldstatus, Gwaiting); // oldstatus is not in a Gscan status
 	gp->waitreason = runtime·gostringnocopy((byte*)"stack growth");
-	newstackcall = framesize==1;
-	if(newstackcall)
-		framesize = 0;
 
-	// For newstackcall the context already points to beginning of runtime·newstackcall.
-	if(!newstackcall)
-		runtime·rewindmorestack(&gp->sched);
+	runtime·rewindmorestack(&gp->sched);
 
 	if(gp->stackbase == 0)
 		runtime·throw("nil stackbase");
@@ -1008,6 +1005,9 @@ runtime·newstack(void)
 		// end of C code to trigger a copy as soon as C code exits.  That way, we'll
 		// have stack available if we get this deep again.
 	}
+	
+	if(StackCopyAlways)
+		runtime·throw("split stack not allowed");
 
 	// allocate new segment.
 	framesize += argsize;
@@ -1033,17 +1033,6 @@ runtime·newstack(void)
 	top->argp = moreargp;
 	top->argsize = argsize;
 
-	// copy flag from panic
-	top->panic = gp->ispanic;
-	gp->ispanic = false;
-	
-	// if this isn't a panic, maybe we're splitting the stack for a panic.
-	// if we're splitting in the top frame, propagate the panic flag
-	// forward so that recover will know we're in a panic.
-	oldtop = (Stktop*)top->stackbase;
-	if(oldtop != nil && oldtop->panic && top->argp == (byte*)oldtop - oldtop->argsize - gp->panicwrap)
-		top->panic = true;
-
 	top->panicwrap = gp->panicwrap;
 	gp->panicwrap = 0;
 
@@ -1060,6 +1049,7 @@ runtime·newstack(void)
 		while(dst < dstend)
 			*dst++ = *src++;
 	}
+	
 	if(thechar == '5') {
 		// caller would have saved its LR below args.
 		sp -= sizeof(void*);
@@ -1072,12 +1062,8 @@ runtime·newstack(void)
 	label.sp = sp;
 	label.pc = (uintptr)runtime·lessstack;
 	label.g = g->m->curg;
-	if(newstackcall)
-		runtime·gostartcallfn(&label, (FuncVal*)g->m->cret);
-	else {
-		runtime·gostartcall(&label, (void(*)(void))gp->sched.pc, gp->sched.ctxt);
-		gp->sched.ctxt = nil;
-	}
+	runtime·gostartcall(&label, (void(*)(void))gp->sched.pc, gp->sched.ctxt);
+	gp->sched.ctxt = nil;
 	runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Grunning or Gsyscall
 	runtime·gogo(&label);
 
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index 7ed4aaa559..c97831a7c4 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -171,8 +171,7 @@ func cputicks() int64
 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer
 func munmap(addr unsafe.Pointer, n uintptr)
 func madvise(addr unsafe.Pointer, n uintptr, flags int32)
-func newstackcall(fv *funcval, addr unsafe.Pointer, size uint32)
-func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
+func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32, p *_panic)
 func osyield()
 func procyield(cycles uint32)
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
diff --git a/test/fixedbugs/issue4388.go b/test/fixedbugs/issue4388.go
index 2e052e138d..b18c98bacd 100644
--- a/test/fixedbugs/issue4388.go
+++ b/test/fixedbugs/issue4388.go
@@ -17,18 +17,18 @@ type T struct {
 }
 
 func f1() {
-	// The 4 here and below depends on the number of internal runtime frames
+	// The 5 here and below depends on the number of internal runtime frames
 	// that sit between a deferred function called during panic and
 	// the original frame. If that changes, this test will start failing and
 	// the number here will need to be updated.
-	defer checkLine(4)
+	defer checkLine(5)
 	var t *T
 	var c io.Closer = t
 	c.Close()
 }
 
 func f2() {
-	defer checkLine(4)
+	defer checkLine(5)
 	var t T
 	var c io.Closer = t
 	c.Close()
diff --git a/test/fixedbugs/issue5856.go b/test/fixedbugs/issue5856.go
index 35cadf8c9e..78ca3b9f6a 100644
--- a/test/fixedbugs/issue5856.go
+++ b/test/fixedbugs/issue5856.go
@@ -29,7 +29,7 @@ func f() {
 }
 
 func g() {
-	_, file, line, _ := runtime.Caller(2)
+	_, file, line, _ := runtime.Caller(3)
 	if !strings.HasSuffix(file, "issue5856.go") || line != 28 {
 		fmt.Printf("BUG: defer called from %s:%d, want issue5856.go:28\n", file, line)
 		os.Exit(1)

From 277ef8fa07411231761426298c8e489ddef8ef67 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Fri, 5 Sep 2014 17:00:32 -0400
Subject: [PATCH 397/423] runtime: disable StackCopyAlways

I forgot to clear this before submitting.

TBR=khr
CC=golang-codereviews
https://golang.org/cl/132640044
---
 src/pkg/runtime/stack.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index facf0c5e82..20a37046f9 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -26,7 +26,7 @@ enum
 
 	StackCache = 1,
 	
-	StackCopyAlways = 1,	// expect to be able to copy stacks 100% of the time
+	StackCopyAlways = 0,	// expect to be able to copy stacks 100% of the time
 };
 
 // Global pool of spans that have free stacks.

From 005806cab17a20adaec33a1ee02a19355356fa67 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 5 Sep 2014 14:59:31 -0700
Subject: [PATCH 398/423] runtime: run getgcmask on the M stack.

LGTM=rsc
R=rsc, khr
CC=golang-codereviews
https://golang.org/cl/132660043
---
 src/pkg/runtime/export_test.go | 13 ++++++++++++-
 src/pkg/runtime/mgc0.c         |  4 ++--
 src/pkg/runtime/stubs.goc      |  7 -------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 35a4130ee1..fd7fd182fc 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -111,8 +111,19 @@ func ParForIters(desc *ParFor, tid uint32) (uint32, uint32) {
 	return begin, end
 }
 
+// in mgc0.c
 //go:noescape
-func GCMask(x interface{}) []byte
+func getgcmask(data unsafe.Pointer, typ *_type, array **byte, len *uint)
+
+func GCMask(x interface{}) (ret []byte) {
+	e := (*eface)(unsafe.Pointer(&x))
+	s := (*slice)(unsafe.Pointer(&ret))
+	onM(func() {
+		getgcmask(e.data, e._type, &s.array, &s.len)
+		s.cap = s.len
+	})
+	return
+}
 
 func testSchedLocalQueue()
 func testSchedLocalQueueSteal()
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 55c38a7e5b..d4c414736b 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -1805,7 +1805,7 @@ getgcmaskcb(Stkframe *frame, void *ctxt)
 	Stkframe *frame0;
 
 	frame0 = ctxt;
-	if(frame0->sp >= frame->varp - frame->sp && frame0->sp < frame->varp) {
+	if(frame->sp <= frame0->sp && frame0->sp < frame->varp) {
 		*frame0 = *frame;
 		return false;
 	}
@@ -1865,7 +1865,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
 	frame.fn = nil;
 	frame.sp = (uintptr)p;
 	cb = getgcmaskcb;
-	runtime·gentraceback((uintptr)runtime·getcallerpc(&p), (uintptr)runtime·getcallersp(&p), 0, g, 0, nil, 1000, &cb, &frame, false);
+	runtime·gentraceback(g->m->curg->sched.pc, g->m->curg->sched.sp, 0, g->m->curg, 0, nil, 1000, &cb, &frame, false);
 	if(frame.fn != nil) {
 		Func *f;
 		StackMap *stackmap;
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index f6bc14f2c9..34cd1b3bb9 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -54,13 +54,6 @@ func runtime·gomcache() (ret *MCache) {
 	ret = g->m->mcache;
 }
 
-// For testing.
-// TODO: find a better place for this.
-func GCMask(x Eface) (mask Slice) {
-	runtime·getgcmask(x.data, x.type, &mask.array, &mask.len);
-	mask.cap = mask.len;
-}
-
 #pragma textflag NOSPLIT
 func reflect·typelinks() (ret Slice) {
         extern Type *runtime·typelink[], *runtime·etypelink[];

From 0e19a3d6d073e70e8849011d673c68da8b5049b2 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 5 Sep 2014 15:01:09 -0700
Subject: [PATCH 399/423] runtime: move gostringw and gogobytes test stubs to
 Go.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=golang-codereviews
https://golang.org/cl/141150043
---
 src/pkg/runtime/export_test.go | 19 ++++++++++++++-----
 src/pkg/runtime/stubs.goc      | 11 -----------
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index fd7fd182fc..3df02626af 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -142,10 +142,19 @@ var MemclrBytes = memclrBytes
 
 var HashLoad = &hashLoad
 
-func gogoBytes() int32
+// For testing.
+func GogoBytes() int32 {
+	return _RuntimeGogoBytes
+}
 
-var GogoBytes = gogoBytes
+// in string.c
+//go:noescape
+func gostringw(w *uint16) string
 
-func gostringW([]uint16) string
-
-var GostringW = gostringW
+// entry point for testing
+func GostringW(w []uint16) (s string) {
+	onM(func() {
+		s = gostringw(&w[0])
+	})
+	return
+}
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
index 34cd1b3bb9..e1b1a02101 100644
--- a/src/pkg/runtime/stubs.goc
+++ b/src/pkg/runtime/stubs.goc
@@ -23,12 +23,6 @@ package runtime
 // These invariants do not hold yet but will be established once we have
 // finished converting runtime support code from C to Go.
 
-// entry point for testing
-// TODO: mcall and run on M stack
-func gostringW(str Slice) (s String) {
-	s = runtime·gostringw((uint16*)str.array);
-}
-
 #pragma textflag NOSPLIT
 func runtime·getg() (ret *G) {
 	ret = g;
@@ -61,8 +55,3 @@ func reflect·typelinks() (ret Slice) {
         ret.len = runtime·etypelink - runtime·typelink;
         ret.cap = ret.len;
 }
-
-// For testing.
-func gogoBytes() (x int32) {
-	x = RuntimeGogoBytes;
-}

From dbed4e9b4f60b25dd472da0dd46b398114acf2fe Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 6 Sep 2014 10:07:23 -0700
Subject: [PATCH 400/423] runtime: get rid of other Go->C calls in test
 exports.

testSchedLocal* tests need to malloc now because their
stack frames are too big to fit on the G0 stack.

LGTM=iant
R=golang-codereviews, iant, khr
CC=golang-codereviews
https://golang.org/cl/133660043
---
 misc/cgo/test/backdoor/runtime.c | 14 -----------
 misc/cgo/test/backdoor/thunk.s   | 16 ++++++++++++
 src/pkg/runtime/export_test.go   | 11 ++++++---
 src/pkg/runtime/proc.c           | 42 +++++++++++++++-----------------
 src/pkg/runtime/proc.go          |  5 ++++
 src/pkg/runtime/proc_test.go     |  4 +--
 src/pkg/runtime/runtime.h        |  1 -
 7 files changed, 49 insertions(+), 44 deletions(-)
 create mode 100644 misc/cgo/test/backdoor/thunk.s

diff --git a/misc/cgo/test/backdoor/runtime.c b/misc/cgo/test/backdoor/runtime.c
index 7e6b448724..87ee44eb6f 100644
--- a/misc/cgo/test/backdoor/runtime.c
+++ b/misc/cgo/test/backdoor/runtime.c
@@ -10,20 +10,6 @@
 
 typedef char bool;
 
-bool runtime·lockedOSThread(void);
-
-static void
-FLUSH(void*)
-{
-}
-
-void
-·LockedOSThread(bool b)
-{
-	b = runtime·lockedOSThread();
-	FLUSH(&b);
-}
-
 // This is what a cgo-compiled stub declaration looks like.
 void
 ·Issue7695(struct{void *y[8*sizeof(void*)];}p)
diff --git a/misc/cgo/test/backdoor/thunk.s b/misc/cgo/test/backdoor/thunk.s
new file mode 100644
index 0000000000..ae735c8a34
--- /dev/null
+++ b/misc/cgo/test/backdoor/thunk.s
@@ -0,0 +1,16 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Assembly to get into package runtime without using exported symbols.
+
+// +build amd64 amd64p32 arm 386
+
+#include "textflag.h"
+
+#ifdef GOARCH_arm
+#define JMP B
+#endif
+
+TEXT ·LockedOSThread(SB),NOSPLIT,$0-0
+	JMP	runtime·lockedOSThread(SB)
diff --git a/src/pkg/runtime/export_test.go b/src/pkg/runtime/export_test.go
index 3df02626af..07ef26f25a 100644
--- a/src/pkg/runtime/export_test.go
+++ b/src/pkg/runtime/export_test.go
@@ -18,7 +18,7 @@ var Fcmp64 = fcmp64
 var Fintto64 = fintto64
 var F64toint = f64toint
 
-func lockedOSThread() bool
+// in asm_*.s
 func stackguard() (sp, limit uintptr)
 
 var Entersyscall = entersyscall
@@ -127,9 +127,12 @@ func GCMask(x interface{}) (ret []byte) {
 
 func testSchedLocalQueue()
 func testSchedLocalQueueSteal()
-
-var TestSchedLocalQueue1 = testSchedLocalQueue
-var TestSchedLocalQueueSteal1 = testSchedLocalQueueSteal
+func RunSchedLocalQueueTest() {
+	onM(testSchedLocalQueue)
+}
+func RunSchedLocalQueueStealTest() {
+	onM(testSchedLocalQueueSteal)
+}
 
 var HaveGoodHash = haveGoodHash
 var StringHash = stringHash
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 56c35c5a44..c9a56a4bbd 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2594,12 +2594,6 @@ badunlockOSThread(void)
 	runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
 }
 
-bool
-runtime·lockedOSThread(void)
-{
-	return g->lockedm != nil && g->m->lockedg != nil;
-}
-
 #pragma textflag NOSPLIT
 int32
 runtime·gcount(void)
@@ -3552,24 +3546,25 @@ runqsteal(P *p, P *p2)
 void
 runtime·testSchedLocalQueue(void)
 {
-	P p;
-	G gs[nelem(p.runq)];
+	P *p;
+	G *gs;
 	int32 i, j;
 
-	runtime·memclr((byte*)&p, sizeof(p));
+	p = (P*)runtime·mallocgc(sizeof(*p), nil, FlagNoScan);
+	gs = (G*)runtime·mallocgc(nelem(p->runq)*sizeof(*gs), nil, FlagNoScan);
 
-	for(i = 0; i < nelem(gs); i++) {
-		if(runqget(&p) != nil)
+	for(i = 0; i < nelem(p->runq); i++) {
+		if(runqget(p) != nil)
 			runtime·throw("runq is not empty initially");
 		for(j = 0; j < i; j++)
-			runqput(&p, &gs[i]);
+			runqput(p, &gs[i]);
 		for(j = 0; j < i; j++) {
-			if(runqget(&p) != &gs[i]) {
+			if(runqget(p) != &gs[i]) {
 				runtime·printf("bad element at iter %d/%d\n", i, j);
 				runtime·throw("bad element");
 			}
 		}
-		if(runqget(&p) != nil)
+		if(runqget(p) != nil)
 			runtime·throw("runq is not empty afterwards");
 	}
 }
@@ -3577,29 +3572,30 @@ runtime·testSchedLocalQueue(void)
 void
 runtime·testSchedLocalQueueSteal(void)
 {
-	P p1, p2;
-	G gs[nelem(p1.runq)], *gp;
+	P *p1, *p2;
+	G *gs, *gp;
 	int32 i, j, s;
 
-	runtime·memclr((byte*)&p1, sizeof(p1));
-	runtime·memclr((byte*)&p2, sizeof(p2));
+	p1 = (P*)runtime·mallocgc(sizeof(*p1), nil, FlagNoScan);
+	p2 = (P*)runtime·mallocgc(sizeof(*p2), nil, FlagNoScan);
+	gs = (G*)runtime·mallocgc(nelem(p1->runq)*sizeof(*gs), nil, FlagNoScan);
 
-	for(i = 0; i < nelem(gs); i++) {
+	for(i = 0; i < nelem(p1->runq); i++) {
 		for(j = 0; j < i; j++) {
 			gs[j].sig = 0;
-			runqput(&p1, &gs[j]);
+			runqput(p1, &gs[j]);
 		}
-		gp = runqsteal(&p2, &p1);
+		gp = runqsteal(p2, p1);
 		s = 0;
 		if(gp) {
 			s++;
 			gp->sig++;
 		}
-		while(gp = runqget(&p2)) {
+		while(gp = runqget(p2)) {
 			s++;
 			gp->sig++;
 		}
-		while(gp = runqget(&p1))
+		while(gp = runqget(p1))
 			gp->sig++;
 		for(j = 0; j < i; j++) {
 			if(gs[j].sig != 1) {
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index d02f7ed7c9..f324d5c90f 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -100,3 +100,8 @@ func badmcall(fn func(*g)) {
 func badmcall2(fn func(*g)) {
 	gothrow("runtime: mcall function returned")
 }
+
+func lockedOSThread() bool {
+	gp := getg()
+	return gp.lockedm != nil && gp.m.lockedg != nil
+}
diff --git a/src/pkg/runtime/proc_test.go b/src/pkg/runtime/proc_test.go
index 1f597f58e4..aa9bc81ac4 100644
--- a/src/pkg/runtime/proc_test.go
+++ b/src/pkg/runtime/proc_test.go
@@ -366,11 +366,11 @@ func nonleaf(stop chan int) bool {
 }
 
 func TestSchedLocalQueue(t *testing.T) {
-	runtime.TestSchedLocalQueue1()
+	runtime.RunSchedLocalQueueTest()
 }
 
 func TestSchedLocalQueueSteal(t *testing.T) {
-	runtime.TestSchedLocalQueueSteal1()
+	runtime.RunSchedLocalQueueStealTest()
 }
 
 func benchmarkStackGrowth(b *testing.B, rec int) {
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 4f279db3fb..52796f6fe4 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -1060,7 +1060,6 @@ void	runtime·procyield(uint32);
 void	runtime·osyield(void);
 void	runtime·lockOSThread(void);
 void	runtime·unlockOSThread(void);
-bool	runtime·lockedOSThread(void);
 
 bool	runtime·showframe(Func*, G*);
 void	runtime·printcreatedby(G*);

From 8620e2b04e0ca6296070fe36ca7f5952af3b90e9 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Sat, 6 Sep 2014 10:12:47 -0700
Subject: [PATCH 401/423] runtime: badreflectcall runs on the G stack - convert
 to Go.

LGTM=iant
R=golang-codereviews, iant
CC=golang-codereviews
https://golang.org/cl/136260043
---
 src/pkg/runtime/proc.c  | 6 ------
 src/pkg/runtime/proc.go | 4 ++++
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index c9a56a4bbd..414196ceb0 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2617,12 +2617,6 @@ runtime·mcount(void)
 	return runtime·sched.mcount;
 }
 
-void
-runtime·badreflectcall(void) // called from assembly
-{
-	runtime·panicstring("runtime: arg size to reflect.call more than 1GB");
-}
-
 static struct {
 	uint32 lock;
 	int32 hz;
diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index f324d5c90f..a9cac266ba 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -101,6 +101,10 @@ func badmcall2(fn func(*g)) {
 	gothrow("runtime: mcall function returned")
 }
 
+func badreflectcall() {
+	panic("runtime: arg size to reflect.call more than 1GB")
+}
+
 func lockedOSThread() bool {
 	gp := getg()
 	return gp.lockedm != nil && gp.m.lockedg != nil

From 8473695797d346f9adf72ee40013a8c8421a7c87 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 13:19:08 -0400
Subject: [PATCH 402/423] runtime: fix panic/wrapper/recover math

The gp->panicwrap adjustment is just fatally flawed.
Now that there is a Panic.argp field, update that instead.
That can be done on entry only, so that unwinding doesn't
need to worry about undoing anything. The wrappers
emit a few more instructions in the prologue but everything
else in the system gets much simpler.

It also fixes (without trying) a broken test I never checked in.

Fixes #7491.

LGTM=khr
R=khr
CC=dvyukov, golang-codereviews, iant, r
https://golang.org/cl/135490044
---
 src/liblink/obj5.c             | 123 +++++++++++++++++++--------------
 src/liblink/obj6.c             |  78 +++++++++++++++------
 src/liblink/obj8.c             |  78 +++++++++++++++------
 src/pkg/reflect/value.go       |   8 +--
 src/pkg/runtime/asm_386.s      |  20 ++----
 src/pkg/runtime/asm_amd64.s    |  29 ++------
 src/pkg/runtime/asm_amd64p32.s |   5 +-
 src/pkg/runtime/asm_arm.s      |  21 ++----
 src/pkg/runtime/cgocall.go     |   2 +-
 src/pkg/runtime/malloc.go      |   2 +-
 src/pkg/runtime/panic.go       |   2 +-
 src/pkg/runtime/panic1.go      |  52 ++++++++------
 src/pkg/runtime/proc.c         |   1 -
 src/pkg/runtime/runtime.h      |  10 +--
 src/pkg/runtime/stack.c        |   4 --
 src/pkg/runtime/stubs.go       |   2 +-
 test/recover.go                |  48 ++++++++++++-
 17 files changed, 289 insertions(+), 196 deletions(-)

diff --git a/src/liblink/obj5.c b/src/liblink/obj5.c
index de920b029e..d7008a48c0 100644
--- a/src/liblink/obj5.c
+++ b/src/liblink/obj5.c
@@ -241,7 +241,7 @@ nocache(Prog *p)
 static void
 addstacksplit(Link *ctxt, LSym *cursym)
 {
-	Prog *p, *pl, *q, *q1, *q2;
+	Prog *p, *pl, *p1, *p2, *q, *q1, *q2;
 	int o;
 	int32 autosize, autoffset;
 	
@@ -437,32 +437,93 @@ addstacksplit(Link *ctxt, LSym *cursym)
 			p->spadj = autosize;
 			
 			if(cursym->text->reg & WRAPPER) {
-				// g->panicwrap += autosize;
-				// MOVW panicwrap_offset(g), R3
-				// ADD $autosize, R3
-				// MOVW R3 panicwrap_offset(g)
+				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+				//
+				//	MOVW g_panic(g), R1
+				//	CMP $0, R1
+				//	B.EQ end
+				//	MOVW panic_argp(R1), R2
+				//	ADD $(autosize+4), R13, R3
+				//	CMP R2, R3
+				//	B.NE end
+				//	ADD $4, R13, R4
+				//	MOVW R4, panic_argp(R1)
+				// end:
+				//	NOP
+				//
+				// The NOP is needed to give the jumps somewhere to land.
+				// It is a liblink NOP, not an ARM NOP: it encodes to 0 instruction bytes.
+
 				p = appendp(ctxt, p);
 				p->as = AMOVW;
 				p->from.type = D_OREG;
 				p->from.reg = REGG;
-				p->from.offset = 2*ctxt->arch->ptrsize;
+				p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
 				p->to.type = D_REG;
-				p->to.reg = 3;
+				p->to.reg = 1;
+			
+				p = appendp(ctxt, p);
+				p->as = ACMP;
+				p->from.type = D_CONST;
+				p->from.offset = 0;
+				p->to.type = D_REG;
+				p->to.reg = 1;
+			
+				p = appendp(ctxt, p);
+				p->as = AB;
+				p->scond = C_SCOND_EQ;
+				p->to.type = D_BRANCH;
+				p1 = p;
+				
+				p = appendp(ctxt, p);
+				p->as = AMOVW;
+				p->from.type = D_OREG;
+				p->from.reg = 1;
+				p->from.offset = 0; // Panic.argp
+				p->to.type = D_REG;
+				p->to.reg = 2;
 			
 				p = appendp(ctxt, p);
 				p->as = AADD;
 				p->from.type = D_CONST;
-				p->from.offset = autosize;
+				p->from.offset = autosize+4;
+				p->reg = 13;
 				p->to.type = D_REG;
 				p->to.reg = 3;
-				
+
+				p = appendp(ctxt, p);
+				p->as = ACMP;
+				p->from.type = D_REG;
+				p->from.offset = 2;
+				p->to.type = D_REG;
+				p->to.reg = 3;
+
+				p = appendp(ctxt, p);
+				p->as = AB;
+				p->scond = C_SCOND_NE;
+				p->to.type = D_BRANCH;
+				p2 = p;
+			
+				p = appendp(ctxt, p);
+				p->as = AADD;
+				p->from.type = D_CONST;
+				p->from.offset = 4;
+				p->reg = 13;
+				p->to.type = D_REG;
+				p->to.reg = 4;
+
 				p = appendp(ctxt, p);
 				p->as = AMOVW;
 				p->from.type = D_REG;
-				p->from.reg = 3;
+				p->from.reg = 4;
 				p->to.type = D_OREG;
-				p->to.reg = REGG;
-				p->to.offset = 2*ctxt->arch->ptrsize;
+				p->to.reg = 1;
+				p->to.offset = 0; // Panic.argp
+
+				p = appendp(ctxt, p);
+				p->as = ANOP;
+				p1->pcond = p;
+				p2->pcond = p;
 			}
 			break;
 
@@ -483,44 +544,6 @@ addstacksplit(Link *ctxt, LSym *cursym)
 				}
 			}
 
-			if(cursym->text->reg & WRAPPER) {
-				int scond;
-				
-				// Preserve original RET's cond, to allow RET.EQ
-				// in the implementation of reflect.call.
-				scond = p->scond;
-				p->scond = C_SCOND_NONE;
-
-				// g->panicwrap -= autosize;
-				// MOVW panicwrap_offset(g), R3
-				// SUB $autosize, R3
-				// MOVW R3 panicwrap_offset(g)
-				p->as = AMOVW;
-				p->from.type = D_OREG;
-				p->from.reg = REGG;
-				p->from.offset = 2*ctxt->arch->ptrsize;
-				p->to.type = D_REG;
-				p->to.reg = 3;
-				p = appendp(ctxt, p);
-			
-				p->as = ASUB;
-				p->from.type = D_CONST;
-				p->from.offset = autosize;
-				p->to.type = D_REG;
-				p->to.reg = 3;
-				p = appendp(ctxt, p);
-
-				p->as = AMOVW;
-				p->from.type = D_REG;
-				p->from.reg = 3;
-				p->to.type = D_OREG;
-				p->to.reg = REGG;
-				p->to.offset = 2*ctxt->arch->ptrsize;
-				p = appendp(ctxt, p);
-
-				p->scond = scond;
-			}
-
 			p->as = AMOVW;
 			p->scond |= C_PBIT;
 			p->from.type = D_OREG;
diff --git a/src/liblink/obj6.c b/src/liblink/obj6.c
index eef3b4294a..c6b8e0964e 100644
--- a/src/liblink/obj6.c
+++ b/src/liblink/obj6.c
@@ -388,7 +388,7 @@ parsetextconst(vlong arg, vlong *textstksiz, vlong *textarg)
 static void
 addstacksplit(Link *ctxt, LSym *cursym)
 {
-	Prog *p, *q, *q1;
+	Prog *p, *q, *q1, *p1, *p2;
 	int32 autoffset, deltasp;
 	int a, pcsize;
 	uint32 i;
@@ -463,13 +463,64 @@ addstacksplit(Link *ctxt, LSym *cursym)
 	deltasp = autoffset;
 	
 	if(cursym->text->from.scale & WRAPPER) {
-		// g->panicwrap += autoffset + ctxt->arch->regsize;
+		// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+		//
+		//	MOVQ g_panic(CX), BX
+		//	TESTQ BX, BX
+		//	JEQ end
+		//	LEAQ (autoffset+8)(SP), DI
+		//	CMPQ panic_argp(BX), DI
+		//	JNE end
+		//	MOVQ SP, panic_argp(BX)
+		// end:
+		//	NOP
+		//
+		// The NOP is needed to give the jumps somewhere to land.
+		// It is a liblink NOP, not an x86 NOP: it encodes to 0 instruction bytes.
+
 		p = appendp(ctxt, p);
-		p->as = AADDL;
-		p->from.type = D_CONST;
-		p->from.offset = autoffset + ctxt->arch->regsize;
-		indir_cx(ctxt, &p->to);
-		p->to.offset = 2*ctxt->arch->ptrsize;
+		p->as = AMOVQ;
+		p->from.type = D_INDIR+D_CX;
+		p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
+		p->to.type = D_BX;
+
+		p = appendp(ctxt, p);
+		p->as = ATESTQ;
+		p->from.type = D_BX;
+		p->to.type = D_BX;
+
+		p = appendp(ctxt, p);
+		p->as = AJEQ;
+		p->to.type = D_BRANCH;
+		p1 = p;
+
+		p = appendp(ctxt, p);
+		p->as = ALEAQ;
+		p->from.type = D_INDIR+D_SP;
+		p->from.offset = autoffset+8;
+		p->to.type = D_DI;
+
+		p = appendp(ctxt, p);
+		p->as = ACMPQ;
+		p->from.type = D_INDIR+D_BX;
+		p->from.offset = 0; // Panic.argp
+		p->to.type = D_DI;
+
+		p = appendp(ctxt, p);
+		p->as = AJNE;
+		p->to.type = D_BRANCH;
+		p2 = p;
+
+		p = appendp(ctxt, p);
+		p->as = AMOVQ;
+		p->from.type = D_SP;
+		p->to.type = D_INDIR+D_BX;
+		p->to.offset = 0; // Panic.argp
+
+		p = appendp(ctxt, p);
+		p->as = ANOP;
+		p1->pcond = p;
+		p2->pcond = p;
 	}
 
 	if(ctxt->debugstack > 1 && autoffset) {
@@ -589,19 +640,6 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		if(autoffset != deltasp)
 			ctxt->diag("unbalanced PUSH/POP");
 
-		if(cursym->text->from.scale & WRAPPER) {
-			p = load_g_cx(ctxt, p);
-			p = appendp(ctxt, p);
-			// g->panicwrap -= autoffset + ctxt->arch->regsize;
-			p->as = ASUBL;
-			p->from.type = D_CONST;
-			p->from.offset = autoffset + ctxt->arch->regsize;
-			indir_cx(ctxt, &p->to);
-			p->to.offset = 2*ctxt->arch->ptrsize;
-			p = appendp(ctxt, p);
-			p->as = ARET;
-		}
-
 		if(autoffset) {
 			p->as = AADJSP;
 			p->from.type = D_CONST;
diff --git a/src/liblink/obj8.c b/src/liblink/obj8.c
index 50e6d8236d..fa1e1ca243 100644
--- a/src/liblink/obj8.c
+++ b/src/liblink/obj8.c
@@ -261,7 +261,7 @@ static Prog*	stacksplit(Link*, Prog*, int32, int, Prog**);
 static void
 addstacksplit(Link *ctxt, LSym *cursym)
 {
-	Prog *p, *q;
+	Prog *p, *q, *p1, *p2;
 	int32 autoffset, deltasp;
 	int a;
 
@@ -317,13 +317,64 @@ addstacksplit(Link *ctxt, LSym *cursym)
 	deltasp = autoffset;
 	
 	if(cursym->text->from.scale & WRAPPER) {
-		// g->panicwrap += autoffset + ctxt->arch->ptrsize;
+		// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+		//
+		//	MOVL g_panic(CX), BX
+		//	TESTL BX, BX
+		//	JEQ end
+		//	LEAL (autoffset+4)(SP), DI
+		//	CMPL panic_argp(BX), DI
+		//	JNE end
+		//	MOVL SP, panic_argp(BX)
+		// end:
+		//	NOP
+		//
+		// The NOP is needed to give the jumps somewhere to land.
+		// It is a liblink NOP, not an x86 NOP: it encodes to 0 instruction bytes.
+
 		p = appendp(ctxt, p);
-		p->as = AADDL;
-		p->from.type = D_CONST;
-		p->from.offset = autoffset + ctxt->arch->ptrsize;
-		p->to.type = D_INDIR+D_CX;
-		p->to.offset = 2*ctxt->arch->ptrsize;
+		p->as = AMOVL;
+		p->from.type = D_INDIR+D_CX;
+		p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
+		p->to.type = D_BX;
+
+		p = appendp(ctxt, p);
+		p->as = ATESTL;
+		p->from.type = D_BX;
+		p->to.type = D_BX;
+
+		p = appendp(ctxt, p);
+		p->as = AJEQ;
+		p->to.type = D_BRANCH;
+		p1 = p;
+
+		p = appendp(ctxt, p);
+		p->as = ALEAL;
+		p->from.type = D_INDIR+D_SP;
+		p->from.offset = autoffset+4;
+		p->to.type = D_DI;
+
+		p = appendp(ctxt, p);
+		p->as = ACMPL;
+		p->from.type = D_INDIR+D_BX;
+		p->from.offset = 0; // Panic.argp
+		p->to.type = D_DI;
+
+		p = appendp(ctxt, p);
+		p->as = AJNE;
+		p->to.type = D_BRANCH;
+		p2 = p;
+
+		p = appendp(ctxt, p);
+		p->as = AMOVL;
+		p->from.type = D_SP;
+		p->to.type = D_INDIR+D_BX;
+		p->to.offset = 0; // Panic.argp
+
+		p = appendp(ctxt, p);
+		p->as = ANOP;
+		p1->pcond = p;
+		p2->pcond = p;
 	}
 	
 	if(ctxt->debugzerostack && autoffset && !(cursym->text->from.scale&NOSPLIT)) {
@@ -396,19 +447,6 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		if(autoffset != deltasp)
 			ctxt->diag("unbalanced PUSH/POP");
 
-		if(cursym->text->from.scale & WRAPPER) {
-			p = load_g_cx(ctxt, p);
-			p = appendp(ctxt, p);
-			// g->panicwrap -= autoffset + ctxt->arch->ptrsize;
-			p->as = ASUBL;
-			p->from.type = D_CONST;
-			p->from.offset = autoffset + ctxt->arch->ptrsize;
-			p->to.type = D_INDIR+D_CX;
-			p->to.offset = 2*ctxt->arch->ptrsize;
-			p = appendp(ctxt, p);
-			p->as = ARET;
-		}
-
 		if(autoffset) {
 			p->as = AADJSP;
 			p->from.type = D_CONST;
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index b02b8ea0c2..adaafab9c9 100644
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -563,7 +563,7 @@ func (v Value) call(op string, in []Value) []Value {
 	}
 
 	// Call.
-	call(fn, args, uint32(frametype.size), uint32(retOffset), nil)
+	call(fn, args, uint32(frametype.size), uint32(retOffset))
 
 	// For testing; see TestCallMethodJump.
 	if callGC {
@@ -761,7 +761,7 @@ func callMethod(ctxt *methodValue, frame unsafe.Pointer) {
 	memmove(unsafe.Pointer(uintptr(args)+ptrSize), frame, argSize-ptrSize)
 
 	// Call.
-	call(fn, args, uint32(frametype.size), uint32(retOffset), nil)
+	call(fn, args, uint32(frametype.size), uint32(retOffset))
 
 	// Copy return values. On amd64p32, the beginning of return values
 	// is 64-bit aligned, so the caller's frame layout (which doesn't have
@@ -2699,9 +2699,7 @@ func mapiterinit(t *rtype, m unsafe.Pointer) unsafe.Pointer
 func mapiterkey(it unsafe.Pointer) (key unsafe.Pointer)
 func mapiternext(it unsafe.Pointer)
 func maplen(m unsafe.Pointer) int
-
-// panicpos is for use by runtime and should be nil in all calls in this package
-func call(fn, arg unsafe.Pointer, n uint32, retoffset uint32, panicpos unsafe.Pointer)
+func call(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
 
 func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
 
diff --git a/src/pkg/runtime/asm_386.s b/src/pkg/runtime/asm_386.s
index 0b5ded6836..25026417bf 100644
--- a/src/pkg/runtime/asm_386.s
+++ b/src/pkg/runtime/asm_386.s
@@ -329,7 +329,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	JMP runtime·morestack(SB)
 
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -341,7 +341,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT reflect·call(SB), NOSPLIT, $0-20
+TEXT reflect·call(SB), NOSPLIT, $0-16
 	MOVL	argsize+8(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -375,9 +375,8 @@ TEXT reflect·call(SB), NOSPLIT, $0-20
 
 // Argument map for the callXX frames.  Each has one stack map.
 DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_reflectcall<>+0x04(SB)/4, $10  // 5 words
+DATA gcargs_reflectcall<>+0x04(SB)/4, $8  // 4 words
 DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsScalar<<6))
-DATA gcargs_reflectcall<>+0x09(SB)/1, $(const_BitsPointer)
 GLOBL gcargs_reflectcall<>(SB),RODATA,$12
 
 // callXX frames have no locals
@@ -386,7 +385,7 @@ DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;	\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-16;	\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -394,22 +393,11 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;	\
 	MOVL	argsize+8(FP), CX;		\
 	MOVL	SP, DI;				\
 	REP;MOVSB;				\
-	/* initialize panic argp */		\
-	MOVL	panic+16(FP), CX;		\
-	CMPL	CX, $0;				\
-	JEQ	3(PC);				\
-	LEAL	(MAXSIZE+4)(SP), BX;		\
-	MOVL	BX, panic_argp(CX);		\
 	/* call function */			\
 	MOVL	f+0(FP), DX;			\
 	MOVL	(DX), AX; 			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	CALL	AX;				\
-	/* clear panic argp */			\
-	MOVL	panic+16(FP), CX;		\
-	CMPL	CX, $0;				\
-	JEQ	2(PC);				\
-	MOVL	$0, panic_argp(CX);		\
 	/* copy return values back */		\
 	MOVL	argptr+4(FP), DI;		\
 	MOVL	argsize+8(FP), CX;		\
diff --git a/src/pkg/runtime/asm_amd64.s b/src/pkg/runtime/asm_amd64.s
index 587fcf4806..cc32ad8a18 100644
--- a/src/pkg/runtime/asm_amd64.s
+++ b/src/pkg/runtime/asm_amd64.s
@@ -308,7 +308,7 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	RET
 
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -320,7 +320,7 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT reflect·call(SB), NOSPLIT, $0-32
+TEXT reflect·call(SB), NOSPLIT, $0-24
 	MOVLQZX argsize+16(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -354,8 +354,8 @@ TEXT reflect·call(SB), NOSPLIT, $0-32
 
 // Argument map for the callXX frames.  Each has one stack map.
 DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_reflectcall<>+0x04(SB)/4, $8  // 4 words
-DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsPointer<<6))
+DATA gcargs_reflectcall<>+0x04(SB)/4, $6  // 3 words
+DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4))
 GLOBL gcargs_reflectcall<>(SB),RODATA,$12
 
 // callXX frames have no locals
@@ -363,16 +363,8 @@ DATA gclocals_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
 DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
-// CALLFN is marked as a WRAPPER so that a deferred reflect.call func will
-// see the right answer for recover. However, CALLFN is also how we start
-// the panic in the first place. We record the panic argp if this is the start of
-// a panic. Since the wrapper adjustment has already happened, though
-// (in the implicit prologue), we have to write not SP but MAXSIZE+8+SP into
-// p.argp. The MAXSIZE+8 will counter the MAXSIZE+8 the wrapper prologue
-// added to g->panicwrap.
-
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-32;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-24;		\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -380,21 +372,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-32;		\
 	MOVLQZX argsize+16(FP), CX;		\
 	MOVQ	SP, DI;				\
 	REP;MOVSB;				\
-	/* initialize panic argp */		\
-	MOVQ	panic+24(FP), CX;		\
-	CMPQ	CX, $0;				\
-	JEQ	3(PC);				\
-	LEAQ	(MAXSIZE+8)(SP), BX;		\
-	MOVQ	BX, panic_argp(CX);		\
 	/* call function */			\
 	MOVQ	f+0(FP), DX;			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	CALL	(DX);				\
-	/* clear panic argp */			\
-	MOVQ	panic+24(FP), CX;		\
-	CMPQ	CX, $0;				\
-	JEQ	2(PC);				\
-	MOVQ	$0, panic_argp(CX);		\
 	/* copy return values back */		\
 	MOVQ	argptr+8(FP), DI;		\
 	MOVLQZX	argsize+16(FP), CX;		\
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 5647d77627..2597b8250f 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -349,9 +349,8 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 	/* initialize panic argp */		\
 	MOVL	panic+16(FP), CX;		\
 	CMPL	CX, $0;				\
-	JEQ	3(PC);				\
-	LEAL	(MAXSIZE+8)(SP), BX;		\
-	MOVL	BX, panic_argp(CX);		\
+	JEQ	2(PC);				\
+	MOVL	SP, panic_argp(CX);		\
 	/* call function */			\
 	MOVL	f+0(FP), DX;			\
 	MOVL	(DX), AX;				\
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 96a21ceac1..752ea08e57 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -306,7 +306,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$-4-0
 	B runtime·morestack(SB)
 
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -317,7 +317,7 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$-4-0
 	MOVW	$NAME(SB), R1;		\
 	B	(R1)
 
-TEXT reflect·call(SB),NOSPLIT,$-4-20
+TEXT reflect·call(SB),NOSPLIT,$-4-16
 	MOVW	argsize+8(FP), R0
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -351,9 +351,8 @@ TEXT reflect·call(SB),NOSPLIT,$-4-20
 
 // Argument map for the callXX frames.  Each has one stack map.
 DATA gcargs_reflectcall<>+0x00(SB)/4, $1  // 1 stackmap
-DATA gcargs_reflectcall<>+0x04(SB)/4, $10  // 5 words
+DATA gcargs_reflectcall<>+0x04(SB)/4, $8  // 4 words
 DATA gcargs_reflectcall<>+0x08(SB)/1, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)+(const_BitsScalar<<6))
-DATA gcargs_reflectcall<>+0x09(SB)/1, $(const_BitsPointer)
 GLOBL gcargs_reflectcall<>(SB),RODATA,$12
 
 // callXX frames have no locals
@@ -362,7 +361,7 @@ DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-16;		\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -375,23 +374,11 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 	MOVBU.P R5, 1(R1);			\
 	SUB	$1, R2, R2;			\
 	B	-5(PC);				\
-	/* initialize panic argp */		\
-	MOVW	panic+16(FP), R4;		\
-	CMP	$0, R4;				\
-	B.EQ	3(PC);				\
-	ADD	$(4+MAXSIZE+4), R13, R5;	\
-	MOVW	R5, panic_argp(R4);		\
 	/* call function */			\
 	MOVW	f+0(FP), R7;			\
 	MOVW	(R7), R0;			\
 	PCDATA  $PCDATA_StackMapIndex, $0;	\
 	BL	(R0);				\
-	/* clear panic argp */			\
-	MOVW	panic+16(FP), R4;		\
-	CMP	$0, R4;				\
-	B.EQ	3(PC);				\
-	MOVW	$0, R5;				\
-	MOVW	R5, panic_argp(R4);		\
 	/* copy return values back */		\
 	MOVW	argptr+4(FP), R0;		\
 	MOVW	argsize+8(FP), R2;		\
diff --git a/src/pkg/runtime/cgocall.go b/src/pkg/runtime/cgocall.go
index 4040fee8e6..c00694e669 100644
--- a/src/pkg/runtime/cgocall.go
+++ b/src/pkg/runtime/cgocall.go
@@ -225,7 +225,7 @@ func cgocallbackg1() {
 	}
 
 	// Invoke callback.
-	reflectcall(unsafe.Pointer(cb.fn), unsafe.Pointer(cb.arg), uint32(cb.argsize), 0, nil)
+	reflectcall(unsafe.Pointer(cb.fn), unsafe.Pointer(cb.arg), uint32(cb.argsize), 0)
 
 	if raceenabled {
 		racereleasemerge(unsafe.Pointer(&racecgosync))
diff --git a/src/pkg/runtime/malloc.go b/src/pkg/runtime/malloc.go
index 664b03b151..883ca0cef7 100644
--- a/src/pkg/runtime/malloc.go
+++ b/src/pkg/runtime/malloc.go
@@ -743,7 +743,7 @@ func runfinq() {
 				default:
 					gothrow("bad kind in runfinq")
 				}
-				reflectcall(unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), nil)
+				reflectcall(unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
 
 				// drop finalizer queue references to finalized object
 				f.fn = nil
diff --git a/src/pkg/runtime/panic.go b/src/pkg/runtime/panic.go
index b8fa213f66..1e35561d15 100644
--- a/src/pkg/runtime/panic.go
+++ b/src/pkg/runtime/panic.go
@@ -208,7 +208,7 @@ func Goexit() {
 	for gp._defer != nil {
 		d := gp._defer
 		gp._defer = d.link
-		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz), nil)
+		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz))
 		freedefer(d)
 		// Note: we ignore recovers here because Goexit isn't a panic
 	}
diff --git a/src/pkg/runtime/panic1.go b/src/pkg/runtime/panic1.go
index 7bdfb4b2c0..1f2f54ec20 100644
--- a/src/pkg/runtime/panic1.go
+++ b/src/pkg/runtime/panic1.go
@@ -46,25 +46,19 @@ func gopanic(e interface{}) {
 		}
 		// take defer off list in case of recursive panic
 		gp._defer = d.link
-		gp.ispanic = true              // rock for runtime·newstack, where runtime·newstackcall ends up
 		argp := unsafe.Pointer(d.argp) // must be pointer so it gets adjusted during stack copy
 		pc := d.pc
 
 		// The deferred function may cause another panic,
-		// so newstackcall may not return. Set up a defer
+		// so reflectcall may not return. Set up a defer
 		// to mark this panic aborted if that happens.
 		dabort.link = gp._defer
 		gp._defer = (*_defer)(noescape(unsafe.Pointer(&dabort)))
 		p._defer = d
-		p.outerwrap = gp.panicwrap
 
-		// TODO(rsc): I am pretty sure the panicwrap manipulation here is not correct.
-		// It is close enough to pass all the tests we have, but I think it needs to be
-		// restored during recovery too. I will write better tests and fix it in a separate CL.
-
-		gp.panicwrap = 0
-		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz), (*_panic)(noescape(unsafe.Pointer(&p))))
-		gp.panicwrap = p.outerwrap
+		p.argp = getargp(0)
+		reflectcall(unsafe.Pointer(d.fn), unsafe.Pointer(&d.args), uint32(d.siz), uint32(d.siz))
+		p.argp = 0
 
 		// reflectcall did not panic. Remove dabort.
 		if gp._defer != &dabort {
@@ -102,6 +96,21 @@ func gopanic(e interface{}) {
 	*(*int)(nil) = 0 // not reached
 }
 
+// getargp returns the location where the caller
+// writes outgoing function call arguments.
+//go:nosplit
+func getargp(x int) uintptr {
+	// x is an argument mainly so that we can return its address.
+	// However, we need to make the function complex enough
+	// that it won't be inlined. We always pass x = 0, so this code
+	// does nothing other than keep the compiler from thinking
+	// the function is simple enough to inline.
+	if x > 0 {
+		return getcallersp(unsafe.Pointer(&x)) * 0
+	}
+	return uintptr(noescape(unsafe.Pointer(&x)))
+}
+
 func abortpanic(p *_panic) {
 	p.aborted = true
 }
@@ -109,23 +118,20 @@ func abortpanic(p *_panic) {
 // The implementation of the predeclared function recover.
 // Cannot split the stack because it needs to reliably
 // find the stack segment of its caller.
+//
+// TODO(rsc): Once we commit to CopyStackAlways,
+// this doesn't need to be nosplit.
 //go:nosplit
 func gorecover(argp uintptr) interface{} {
-	// Must be an unrecovered panic in progress.
-	// Must be on a stack segment created for a deferred call during a panic.
-	// Must be at the top of that segment, meaning the deferred call itself
-	// and not something it called. The top frame in the segment will have
-	// argument pointer argp == top - top.argsize.
-	// The subtraction of g.panicwrap allows wrapper functions that
-	// do not count as official calls to adjust what we consider the top frame
-	// while they are active on the stack. The linker emits adjustments of
-	// g.panicwrap in the prologue and epilogue of functions marked as wrappers.
+	// Must be in a function running as part of a deferred call during the panic.
+	// Must be called from the topmost function of the call
+	// (the function used in the defer statement).
+	// p.argp is the argument pointer of that topmost deferred function call.
+	// Compare against argp reported by caller.
+	// If they match, the caller is the one who can recover.
 	gp := getg()
 	p := gp._panic
-	//	if p != nil {
-	//		println("recover?", p, p.recovered, hex(argp), hex(p.argp), uintptr(gp.panicwrap), p != nil && !p.recovered && argp == p.argp-uintptr(gp.panicwrap))
-	//	}
-	if p != nil && !p.recovered && argp == p.argp-uintptr(gp.panicwrap) {
+	if p != nil && !p.recovered && argp == p.argp {
 		p.recovered = true
 		return p.arg
 	}
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 414196ceb0..698be9ffae 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -2327,7 +2327,6 @@ runtime·newproc1(FuncVal *fn, byte *argp, int32 narg, int32 nret, void *callerp
 		p->goidcacheend = p->goidcache + GoidCacheBatch;
 	}
 	newg->goid = p->goidcache++;
-	newg->panicwrap = 0;
 	if(raceenabled)
 		newg->racectx = runtime·racegostart((void*)callerpc);
 	runqput(p, newg);
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 52796f6fe4..02563fd36c 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -268,11 +268,10 @@ struct	WinCallbackContext
 struct	G
 {
 	// stackguard0 can be set to StackPreempt as opposed to stackguard
-	uintptr	stackguard0;	// cannot move - also known to linker, libmach, runtime/cgo
+	uintptr	stackguard0;	// cannot move - also known to liblink, libmach, runtime/cgo
 	uintptr	stackbase;	// cannot move - also known to libmach, runtime/cgo
-	uint32	panicwrap;	// cannot move - also known to linker
+	Panic*	panic;	// cannot move - also known to liblink
 	Defer*	defer;
-	Panic*	panic;
 	Gobuf	sched;
 	uintptr	syscallstack;	// if status==Gsyscall, syscallstack = stackbase to use during gc
 	uintptr	syscallsp;	// if status==Gsyscall, syscallsp = sched.sp to use during gc
@@ -287,7 +286,6 @@ struct	G
 	int64	waitsince;	// approx time when the G become blocked
 	String	waitreason;	// if status==Gwaiting
 	G*	schedlink;
-	bool	ispanic;
 	bool	issystem;	// do not output in stack dump, ignore in deadlock detector
 	bool	preempt;	// preemption signal, duplicates stackguard0 = StackPreempt
 	bool	paniconfault;	// panic (instead of crash) on unexpected fault address
@@ -449,7 +447,6 @@ struct	Stktop
 	uintptr	stackbase;
 	Gobuf	gobuf;
 	uint32	argsize;
-	uint32	panicwrap;
 
 	uint8*	argp;	// pointer to arguments in old frame
 };
@@ -654,11 +651,10 @@ struct Defer
  */
 struct Panic
 {
+	uintptr	argp;	// pointer to arguments of deferred call run during panic; cannot move - known to liblink
 	Eface	arg;		// argument to panic
 	Panic*	link;		// link to earlier panic
 	Defer*	defer;		// current executing defer
-	uintptr	argp;		// pointer to arguments of deferred call, for recover
-	uint32	outerwrap;	// outer gp->panicwrap
 	bool	recovered;	// whether this panic is over
 	bool	aborted;	// the panic was aborted
 };
diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index 20a37046f9..18b3f40648 100644
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -371,7 +371,6 @@ runtime·oldstack(void)
 	gp->stackbase = top->stackbase;
 	gp->stackguard = top->stackguard;
 	gp->stackguard0 = gp->stackguard;
-	gp->panicwrap = top->panicwrap;
 	runtime·stackfree(gp, old, top);
 	runtime·casgstatus(gp, Gcopystack, oldstatus); // oldstatus is Grunning or Gsyscall
 	runtime·gogo(&gp->sched);
@@ -1033,9 +1032,6 @@ runtime·newstack(void)
 	top->argp = moreargp;
 	top->argsize = argsize;
 
-	top->panicwrap = gp->panicwrap;
-	gp->panicwrap = 0;
-
 	gp->stackbase = (uintptr)top;
 	gp->stackguard = (uintptr)stk + StackGuard;
 	gp->stackguard0 = gp->stackguard;
diff --git a/src/pkg/runtime/stubs.go b/src/pkg/runtime/stubs.go
index c97831a7c4..03f618e155 100644
--- a/src/pkg/runtime/stubs.go
+++ b/src/pkg/runtime/stubs.go
@@ -171,7 +171,7 @@ func cputicks() int64
 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer
 func munmap(addr unsafe.Pointer, n uintptr)
 func madvise(addr unsafe.Pointer, n uintptr, flags int32)
-func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32, p *_panic)
+func reflectcall(fn, arg unsafe.Pointer, n uint32, retoffset uint32)
 func osyield()
 func procyield(cycles uint32)
 func cgocallback_gofunc(fv *funcval, frame unsafe.Pointer, framesize uintptr)
diff --git a/test/recover.go b/test/recover.go
index 071be6667a..6287d65076 100644
--- a/test/recover.go
+++ b/test/recover.go
@@ -47,6 +47,7 @@ func main() {
 		test11reflect1()
 		test11reflect2()
 	}
+	test111()
 	test12()
 	if !interp {
 		test12reflect1()
@@ -77,7 +78,7 @@ func mustRecoverBody(v1, v2, v3, x interface{}) {
 	}
 	v = v2
 	if v == nil {
-		println("missing recover")
+		println("missing recover", x.(int))
 		die() // panic is useless here
 	}
 	if v != x {
@@ -137,7 +138,7 @@ func test1WithClosures() {
 		mustNotRecover()
 		v := recover()
 		if v == nil {
-			println("missing recover")
+			println("missing recover", x.(int))
 			die()
 		}
 		if v != x {
@@ -406,6 +407,49 @@ func test11reflect2() {
 	panic(11)
 }
 
+// tiny receiver, so basic wrapper in i.M()
+type T3deeper struct{}
+
+func (T3deeper) M() {
+	badstate() // difference from T3
+	mustRecoverBody(doubleRecover(), recover(), recover(), 111)
+}
+
+func test111() {
+	var i I = T3deeper{}
+	defer i.M()
+	panic(111)
+}
+
+type Tiny struct{}
+
+func (Tiny) M() {
+	panic(112)
+}
+
+// i.M is a wrapper, and i.M panics.
+//
+// This is a torture test for an old implementation of recover that
+// tried to deal with wrapper functions by doing some argument
+// positioning math on both entry and exit. Doing anything on exit
+// is a problem because sometimes functions exit via panic instead
+// of an ordinary return, so panic would have to know to do the
+// same math when unwinding the stack. It gets complicated fast.
+// This particular test never worked with the old scheme, because
+// panic never did the right unwinding math.
+//
+// The new scheme adjusts Panic.argp on entry to a wrapper.
+// It has no exit work, so if a wrapper is interrupted by a panic,
+// there's no cleanup that panic itself must do.
+// This test just works now.
+func badstate() {
+	defer func() {
+		recover()
+	}()
+	var i I = Tiny{}
+	i.M()
+}
+
 // large receiver, so basic wrapper in i.M()
 type T4 [2]string
 

From b4c28d918072b26527426d1f4df89ab93179376d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aram=20H=C4=83v=C4=83rneanu?= <aram@mgk.ro>
Date: Sat, 6 Sep 2014 19:35:46 +0200
Subject: [PATCH 403/423] runtime, syscall: rewrite syscall_solaris.goc in Go

LGTM=dave, rsc
R=khr, dvyukov, dave, gobot, rsc
CC=golang-codereviews, rsc
https://golang.org/cl/133220044
---
 src/pkg/runtime/syscall_solaris.c     |  23 ++
 src/pkg/runtime/syscall_solaris.go    | 322 ++++++++++++++++++++++
 src/pkg/runtime/syscall_solaris.goc   | 374 --------------------------
 src/pkg/runtime/thunk_solaris_amd64.s |  88 ++++++
 src/pkg/syscall/asm_solaris_amd64.s   |  76 +++++-
 src/pkg/syscall/so_solaris.go         |   2 +-
 6 files changed, 509 insertions(+), 376 deletions(-)
 create mode 100644 src/pkg/runtime/syscall_solaris.c
 create mode 100644 src/pkg/runtime/syscall_solaris.go
 delete mode 100644 src/pkg/runtime/syscall_solaris.goc
 create mode 100644 src/pkg/runtime/thunk_solaris_amd64.s

diff --git a/src/pkg/runtime/syscall_solaris.c b/src/pkg/runtime/syscall_solaris.c
new file mode 100644
index 0000000000..13ac31bde2
--- /dev/null
+++ b/src/pkg/runtime/syscall_solaris.c
@@ -0,0 +1,23 @@
+// 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.
+
+#pragma dynimport libc·chdir chdir "libc.so"
+#pragma dynimport libc·chroot chroot "libc.so"
+#pragma dynimport libc·close close "libc.so"
+#pragma dynimport libc·dlclose dlclose "libc.so"
+#pragma dynimport libc·dlopen dlopen "libc.so"
+#pragma dynimport libc·dlsym dlsym "libc.so"
+#pragma dynimport libc·execve execve "libc.so"
+#pragma dynimport libc·fcntl fcntl "libc.so"
+#pragma dynimport libc·gethostname gethostname "libc.so"
+#pragma dynimport libc·ioctl ioctl "libc.so"
+#pragma dynimport libc·pipe pipe "libc.so"
+#pragma dynimport libc·setgid setgid "libc.so"
+#pragma dynimport libc·setgroups setgroups "libc.so"
+#pragma dynimport libc·setsid setsid "libc.so"
+#pragma dynimport libc·setuid setuid "libc.so"
+#pragma dynimport libc·setpgid setsid "libc.so"
+#pragma dynimport libc·syscall syscall "libc.so"
+#pragma dynimport libc·forkx forkx "libc.so"
+#pragma dynimport libc·wait4 wait4 "libc.so"
diff --git a/src/pkg/runtime/syscall_solaris.go b/src/pkg/runtime/syscall_solaris.go
new file mode 100644
index 0000000000..d0a3fc8dd0
--- /dev/null
+++ b/src/pkg/runtime/syscall_solaris.go
@@ -0,0 +1,322 @@
+// 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 runtime
+
+import "unsafe"
+
+var (
+	libc_chdir,
+	libc_chroot,
+	libc_close,
+	libc_dlopen,
+	libc_dlclose,
+	libc_dlsym,
+	libc_execve,
+	libc_exit,
+	libc_fcntl,
+	libc_forkx,
+	libc_gethostname,
+	libc_ioctl,
+	libc_pipe,
+	libc_setgid,
+	libc_setgroups,
+	libc_setsid,
+	libc_setuid,
+	libc_setpgid,
+	libc_syscall,
+	libc_wait4,
+	libc_write,
+	pipe1 libcFunc
+)
+
+//go:nosplit
+func syscall_sysvicall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(fn),
+		n:    nargs,
+		args: unsafe.Pointer(&a1),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	return call.r1, call.r2, call.err
+}
+
+//go:nosplit
+func syscall_rawsysvicall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(fn),
+		n:    nargs,
+		args: unsafe.Pointer(&a1),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.r1, call.r2, call.err
+}
+
+// TODO(aram): Once we remove all instances of C calling sysvicallN, make
+// sysvicallN return errors and replace the body of the following functions
+// with calls to sysvicallN.
+
+//go:nosplit
+func syscall_chdir(path uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_chdir),
+		n:    1,
+		args: unsafe.Pointer(&path),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+//go:nosplit
+func syscall_chroot(path uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_chroot),
+		n:    1,
+		args: unsafe.Pointer(&path),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+// like close, but must not split stack, for forkx.
+//go:nosplit
+func syscall_close(fd int32) int32 {
+	return int32(sysvicall1(&libc_close, uintptr(fd)))
+}
+
+func syscall_dlopen(name *byte, mode uintptr) (handle uintptr, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_dlopen),
+		n:    2,
+		args: unsafe.Pointer(&name),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	if call.r1 == 0 {
+		return call.r1, call.err
+	}
+	return call.r1, 0
+}
+
+func syscall_dlclose(handle uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_dlclose),
+		n:    1,
+		args: unsafe.Pointer(&handle),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	return call.r1
+}
+
+func syscall_dlsym(handle uintptr, name *byte) (proc uintptr, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_dlsym),
+		n:    2,
+		args: unsafe.Pointer(&handle),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	if call.r1 == 0 {
+		return call.r1, call.err
+	}
+	return call.r1, 0
+}
+
+//go:nosplit
+func syscall_execve(path, argv, envp uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_execve),
+		n:    3,
+		args: unsafe.Pointer(&path),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+// like exit, but must not split stack, for forkx.
+//go:nosplit
+func syscall_exit(code uintptr) {
+	sysvicall1(&libc_exit, code)
+}
+
+//go:nosplit
+func syscall_fcntl(fd, cmd, arg uintptr) (val, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_fcntl),
+		n:    3,
+		args: unsafe.Pointer(&fd),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.r1, call.err
+}
+
+//go:nosplit
+func syscall_forkx(flags uintptr) (pid uintptr, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_forkx),
+		n:    1,
+		args: unsafe.Pointer(&flags),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.r1, call.err
+}
+
+func syscall_gethostname() (name string, err uintptr) {
+	cname := new([_MAXHOSTNAMELEN]byte)
+	var args = [2]uintptr{uintptr(unsafe.Pointer(&cname[0])), _MAXHOSTNAMELEN}
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_gethostname),
+		n:    2,
+		args: unsafe.Pointer(&args[0]),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	if call.r1 != 0 {
+		return "", call.err
+	}
+	cname[_MAXHOSTNAMELEN-1] = 0
+	return gostringnocopy(&cname[0]), 0
+}
+
+//go:nosplit
+func syscall_ioctl(fd, req, arg uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_ioctl),
+		n:    3,
+		args: unsafe.Pointer(&fd),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+func syscall_pipe() (r, w, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&pipe1),
+		n:    0,
+		args: unsafe.Pointer(&pipe1), // it's unused but must be non-nil, otherwise crashes
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	return call.r1, call.r2, call.err
+}
+
+// This is syscall.RawSyscall, it exists to satisfy some build dependency,
+// but it doesn't work correctly.
+//
+// DO NOT USE!
+//
+// TODO(aram): make this panic once we stop calling fcntl(2) in net using it.
+func syscall_rawsyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_syscall),
+		n:    4,
+		args: unsafe.Pointer(&trap),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.r1, call.r2, call.err
+}
+
+//go:nosplit
+func syscall_setgid(gid uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_setgid),
+		n:    1,
+		args: unsafe.Pointer(&gid),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+//go:nosplit
+func syscall_setgroups(ngid, gid uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_setgroups),
+		n:    2,
+		args: unsafe.Pointer(&ngid),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+//go:nosplit
+func syscall_setsid() (pid, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_setsid),
+		n:    0,
+		args: unsafe.Pointer(&libc_setsid), // it's unused but must be non-nil, otherwise crashes
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.r1, call.err
+}
+
+//go:nosplit
+func syscall_setuid(uid uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_setuid),
+		n:    1,
+		args: unsafe.Pointer(&uid),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+//go:nosplit
+func syscall_setpgid(pid, pgid uintptr) (err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_setpgid),
+		n:    2,
+		args: unsafe.Pointer(&pid),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.err
+}
+
+// This is syscall.Syscall, it exists to satisfy some build dependency,
+// but it doesn't work correctly.
+//
+// DO NOT USE!
+//
+// TODO(aram): make this panic once we stop calling fcntl(2) in net using it.
+func syscall_syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_syscall),
+		n:    4,
+		args: unsafe.Pointer(&trap),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	return call.r1, call.r2, call.err
+}
+
+func syscall_wait4(pid uintptr, wstatus *uint32, options uintptr, rusage unsafe.Pointer) (wpid int, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_wait4),
+		n:    4,
+		args: unsafe.Pointer(&pid),
+	}
+	entersyscallblock()
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	exitsyscall()
+	return int(call.r1), call.err
+}
+
+//go:nosplit
+func syscall_write(fd, buf, nbyte uintptr) (n, err uintptr) {
+	call := libcall{
+		fn:   unsafe.Pointer(&libc_write),
+		n:    3,
+		args: unsafe.Pointer(&fd),
+	}
+	asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call))
+	return call.r1, call.err
+}
diff --git a/src/pkg/runtime/syscall_solaris.goc b/src/pkg/runtime/syscall_solaris.goc
deleted file mode 100644
index 935a2f6cfc..0000000000
--- a/src/pkg/runtime/syscall_solaris.goc
+++ /dev/null
@@ -1,374 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package syscall
-#include "runtime.h"
-#include "defs_GOOS_GOARCH.h"
-#include "os_GOOS.h"
-#include "cgocall.h"
-#include "textflag.h"
-
-#pragma dynimport libc·chdir chdir "libc.so"
-#pragma dynimport libc·chroot chroot "libc.so"
-#pragma dynimport libc·close close "libc.so"
-#pragma dynimport libc·dlclose dlclose "libc.so"
-#pragma dynimport libc·dlopen dlopen "libc.so"
-#pragma dynimport libc·dlsym dlsym "libc.so"
-#pragma dynimport libc·execve execve "libc.so"
-#pragma dynimport libc·fcntl fcntl "libc.so"
-#pragma dynimport libc·gethostname gethostname "libc.so"
-#pragma dynimport libc·ioctl ioctl "libc.so"
-#pragma dynimport libc·pipe pipe "libc.so"
-#pragma dynimport libc·setgid setgid "libc.so"
-#pragma dynimport libc·setgroups setgroups "libc.so"
-#pragma dynimport libc·setsid setsid "libc.so"
-#pragma dynimport libc·setuid setuid "libc.so"
-#pragma dynimport libc·setpgid setsid "libc.so"
-#pragma dynimport libc·syscall syscall "libc.so"
-#pragma dynimport libc·forkx forkx "libc.so"
-#pragma dynimport libc·wait4 wait4 "libc.so"
-extern uintptr libc·chdir;
-extern uintptr libc·chroot;
-extern uintptr libc·close;
-extern uintptr libc·dlclose;
-extern uintptr libc·dlopen;
-extern uintptr libc·dlsym;
-extern uintptr libc·execve;
-extern uintptr libc·exit;
-extern uintptr libc·fcntl;
-extern uintptr libc·gethostname;
-extern uintptr libc·ioctl;
-extern uintptr libc·pipe;
-extern uintptr libc·setgid;
-extern uintptr libc·setgroups;
-extern uintptr libc·setsid;
-extern uintptr libc·setuid;
-extern uintptr libc·setpgid;
-extern uintptr libc·syscall;
-extern uintptr libc·forkx;
-extern uintptr libc·wait4;
-extern uintptr libc·write;
-
-func sysvicall6(func uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err uintptr)
-{
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	USED(a4);
-	USED(a5);
-	USED(a6);
-	c.fn = (void*)func;
-	c.n = nargs;
-	c.args = (void*)&a1;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-#pragma textflag NOSPLIT
-func rawSysvicall6(func uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err uintptr)
-{
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	USED(a4);
-	USED(a5);
-	USED(a6);
-	c.fn = (void*)func;
-	c.n = nargs;
-	c.args = (void*)&a1;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-#pragma textflag NOSPLIT
-func chdir(path uintptr) (err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·chdir;
-	c.n = 1;
-	c.args = (void*)&path;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func chroot1(path uintptr) (err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·chroot;
-	c.n = 1;
-	c.args = (void*)&path;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func close(fd uintptr) (err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·close;
-	c.n = 1;
-	c.args = (void*)&fd;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-func dlclose(handle uintptr) (err uintptr) {
-	LibCall c;
-
-	USED(handle);
-	c.fn = (void*)libc·dlclose;
-	c.n = 1;
-	c.args = (void*)&handle;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	err = c.r1;
-}
-
-func dlopen(name *uint8, mode uintptr) (handle uintptr, err uintptr) {
-	LibCall c;
-
-	USED(mode);
-	c.fn = (void*)libc·dlopen;
-	c.n = 2;
-	c.args = (void*)&name;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	handle = c.r1;
-	if(handle == 0)
-		err = c.err;
-	else
-		err = 0;
-}
-
-func dlsym(handle uintptr, name *uint8) (proc uintptr, err uintptr) {
-	LibCall c;
-
-	USED(name);
-	c.fn = (void*)libc·dlsym;
-	c.n = 2;
-	c.args = &handle;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	proc = c.r1;
-	if(proc == 0)
-		err = c.err;
-	else
-		err = 0;
-}
-
-#pragma textflag NOSPLIT
-func execve(path uintptr, argv uintptr, envp uintptr) (err uintptr) {
-	LibCall c;
-
-	USED(argv);
-	USED(envp);
-	c.fn = (void*)libc·execve;
-	c.n = 3;
-	c.args = (void*)&path;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func exit(code uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·exit;
-	c.n = 1;
-	c.args = (void*)&code;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-}
-
-#pragma textflag NOSPLIT
-func fcntl1(fd uintptr, cmd uintptr, arg uintptr) (val uintptr, err uintptr) {
-	LibCall c;
-
-	USED(cmd);
-	USED(arg);
-	c.fn = (void*)libc·fcntl;
-	c.n = 3;
-	c.args = (void*)&fd;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	val = c.r1;
-}
-
-func gethostname() (name String, err uintptr) {
-	struct { uintptr v[2]; } args;
-	uint8 cname[MAXHOSTNAMELEN];
-	LibCall c;
-
-	c.fn = (void*)libc·gethostname;
-	c.n = 2;
-	args.v[0] = (uintptr)&cname[0];
-	args.v[1] = MAXHOSTNAMELEN;
-	c.args = (void*)&args;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	if(c.r1) {
-		name = runtime·emptystring;
-		return;
-	}
-	cname[MAXHOSTNAMELEN - 1] = 0;
-	name = runtime·gostring(cname);
-}
-
-#pragma textflag NOSPLIT
-func ioctl(fd uintptr, req uintptr, arg uintptr) (err uintptr) {
-	LibCall c;
-
-	USED(req);
-	USED(arg);
-	c.fn = (void*)libc·ioctl;
-	c.n = 3;
-	c.args = (void*)&fd;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-func wait4(pid uintptr, wstatus *uint32, options uintptr, rusage *void) (wpid int, err uintptr) {
-	LibCall c;
-
-	USED(wstatus);
-	USED(options);
-	USED(rusage);
-	c.fn = (void*)libc·wait4;
-	c.n = 4;
-	c.args = (void*)&pid;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	wpid = c.r1;
-}
-
-#pragma textflag NOSPLIT
-func setgid(gid uintptr) (err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·setgid;
-	c.n = 1;
-	c.args = (void*)&gid;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func setgroups1(ngid uintptr, gid uintptr) (err uintptr) {
-	LibCall c;
-
-	USED(gid);
-	c.fn = (void*)libc·setgroups;
-	c.n = 2;
-	c.args = (void*)&ngid;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func setsid() (pid uintptr, err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·setsid;
-	c.n = 0;
-	c.args = (void*)0;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	pid = c.r1;
-}
-
-#pragma textflag NOSPLIT
-func setuid(uid uintptr) (err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·setuid;
-	c.n = 1;
-	c.args = (void*)&uid;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func setpgid(pid uintptr, pgid uintptr) (err uintptr) {
-	LibCall c;
-
-	USED(pgid);
-	c.fn = (void*)libc·setpgid;
-	c.n = 2;
-	c.args = (void*)&pid;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-}
-
-#pragma textflag NOSPLIT
-func forkx(flags uintptr) (pid uintptr, err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)libc·forkx;
-	c.n = 1;
-	c.args = (void*)&flags;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	pid = c.r1;
-}
-
-void runtime·pipe1(void);
-
-func pipe() (r uintptr, w uintptr, err uintptr) {
-	LibCall c;
-
-	c.fn = (void*)runtime·pipe1;
-	c.n = 0;
-	c.args = (void*)0;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	r = c.r1;
-	w = c.r2;
-}
-
-#pragma textflag NOSPLIT
-func write1(fd uintptr, buf uintptr, nbyte uintptr) (n uintptr, err uintptr) {
-	LibCall c;
-
-	USED(buf);
-	USED(nbyte);
-	c.fn = (void*)libc·write;
-	c.n = 3;
-	c.args = (void*)fd;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	n = c.r1;
-}
-
-func Syscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a1);
-	USED(a2);
-	USED(a3);
-	c.fn = (void*)libc·syscall;
-	c.n = 4;
-	c.args = &trap;
-	runtime·cgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-func RawSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a1);
-	USED(a2);
-	USED(a3);
-	c.fn = (void*)libc·syscall;
-	c.n = 4;
-	c.args = &trap;
-	runtime·asmcgocall(runtime·asmsysvicall6, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
diff --git a/src/pkg/runtime/thunk_solaris_amd64.s b/src/pkg/runtime/thunk_solaris_amd64.s
new file mode 100644
index 0000000000..352011e047
--- /dev/null
+++ b/src/pkg/runtime/thunk_solaris_amd64.s
@@ -0,0 +1,88 @@
+// 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 exposes various external library functions to Go code in the runtime.
+
+#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
+
+TEXT runtime·libc_chdir(SB),NOSPLIT,$0
+	MOVQ	libc·chdir(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_chroot(SB),NOSPLIT,$0
+	MOVQ	libc·chroot(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_close(SB),NOSPLIT,$0
+	MOVQ	libc·close(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_dlopen(SB),NOSPLIT,$0
+	MOVQ	libc·dlopen(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_dlclose(SB),NOSPLIT,$0
+	MOVQ	libc·dlclose(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_dlsym(SB),NOSPLIT,$0
+	MOVQ	libc·dlsym(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_execve(SB),NOSPLIT,$0
+	MOVQ	libc·execve(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_exit(SB),NOSPLIT,$0
+	MOVQ	libc·exit(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_fcntl(SB),NOSPLIT,$0
+	MOVQ	libc·fcntl(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_forkx(SB),NOSPLIT,$0
+	MOVQ	libc·forkx(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_gethostname(SB),NOSPLIT,$0
+	MOVQ	libc·gethostname(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_ioctl(SB),NOSPLIT,$0
+	MOVQ	libc·ioctl(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_setgid(SB),NOSPLIT,$0
+	MOVQ	libc·setgid(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_setgroups(SB),NOSPLIT,$0
+	MOVQ	libc·setgroups(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_setsid(SB),NOSPLIT,$0
+	MOVQ	libc·setsid(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_setuid(SB),NOSPLIT,$0
+	MOVQ	libc·setuid(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_setpgid(SB),NOSPLIT,$0
+	MOVQ	libc·setpgid(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_syscall(SB),NOSPLIT,$0
+	MOVQ	libc·syscall(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_wait4(SB),NOSPLIT,$0
+	MOVQ	libc·wait4(SB), AX
+	JMP	AX
+
+TEXT runtime·libc_write(SB),NOSPLIT,$0
+	MOVQ	libc·write(SB), AX
+	JMP	AX
diff --git a/src/pkg/syscall/asm_solaris_amd64.s b/src/pkg/syscall/asm_solaris_amd64.s
index 3735890fa9..d0d271c76b 100644
--- a/src/pkg/syscall/asm_solaris_amd64.s
+++ b/src/pkg/syscall/asm_solaris_amd64.s
@@ -2,6 +2,80 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+#include "textflag.h"
+
 //
-// System calls for amd64, Solaris are implemented in ../runtime/syscall_solaris.goc
+// System calls for solaris/amd64 are implemented in ../runtime/syscall_solaris.go
 //
+
+TEXT ·sysvicall6(SB),NOSPLIT,$0
+	JMP	runtime·syscall_sysvicall6(SB)
+
+TEXT ·rawSysvicall6(SB),NOSPLIT,$0
+	JMP	runtime·syscall_rawsysvicall6(SB)
+
+TEXT ·chdir(SB),NOSPLIT,$0
+	JMP	runtime·syscall_chdir(SB)
+
+TEXT ·chroot1(SB),NOSPLIT,$0
+	JMP	runtime·syscall_chroot(SB)
+
+TEXT ·close(SB),NOSPLIT,$0
+	JMP	runtime·syscall_close(SB)
+
+TEXT ·dlopen(SB),NOSPLIT,$0
+	JMP	runtime·syscall_dlopen(SB)
+
+TEXT ·dlclose(SB),NOSPLIT,$0
+	JMP	runtime·syscall_dlclose(SB)
+
+TEXT ·dlsym(SB),NOSPLIT,$0
+	JMP	runtime·syscall_dlsym(SB)
+
+TEXT ·execve(SB),NOSPLIT,$0
+	JMP	runtime·syscall_execve(SB)
+
+TEXT ·exit(SB),NOSPLIT,$0
+	JMP	runtime·syscall_exit(SB)
+
+TEXT ·fcntl1(SB),NOSPLIT,$0
+	JMP	runtime·syscall_fcntl(SB)
+
+TEXT ·forkx(SB),NOSPLIT,$0
+	JMP	runtime·syscall_forkx(SB)
+
+TEXT ·gethostname(SB),NOSPLIT,$0
+	JMP	runtime·syscall_gethostname(SB)
+
+TEXT ·ioctl(SB),NOSPLIT,$0
+	JMP	runtime·syscall_ioctl(SB)
+
+TEXT ·pipe(SB),NOSPLIT,$0
+	JMP	runtime·syscall_pipe(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0
+	JMP	runtime·syscall_rawsyscall(SB)
+
+TEXT ·setgid(SB),NOSPLIT,$0
+	JMP	runtime·syscall_setgid(SB)
+
+TEXT ·setgroups1(SB),NOSPLIT,$0
+	JMP	runtime·syscall_setgroups(SB)
+
+TEXT ·setsid(SB),NOSPLIT,$0
+	JMP	runtime·syscall_setsid(SB)
+
+TEXT ·setuid(SB),NOSPLIT,$0
+	JMP	runtime·syscall_setuid(SB)
+
+TEXT ·setpgid(SB),NOSPLIT,$0
+	JMP	runtime·syscall_setpgid(SB)
+
+TEXT ·Syscall(SB),NOSPLIT,$0
+	JMP	runtime·syscall_syscall(SB)
+
+TEXT ·wait4(SB),NOSPLIT,$0
+	JMP	runtime·syscall_wait4(SB)
+
+TEXT ·write1(SB),NOSPLIT,$0
+	JMP	runtime·syscall_write(SB)
diff --git a/src/pkg/syscall/so_solaris.go b/src/pkg/syscall/so_solaris.go
index 659cd67c16..bf1b756049 100644
--- a/src/pkg/syscall/so_solaris.go
+++ b/src/pkg/syscall/so_solaris.go
@@ -19,7 +19,7 @@ type soError struct {
 
 func (e *soError) Error() string { return e.Msg }
 
-// Implemented in ../runtime/syscall_solaris.goc.
+// Implemented in asm_solaris_amd64.s.
 func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 func dlclose(handle uintptr) (err Errno)

From e8d65b92d7129edf4ca495206467f600960e803e Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 14:53:44 -0400
Subject: [PATCH 404/423] liblink: fix arm build errors

This was supposed to be in CL 135490044
but got lost in a transfer from machine to machine.

TBR=khr
R=khr
CC=golang-codereviews
https://golang.org/cl/135560043
---
 src/liblink/asm5.c |  6 ++++--
 src/liblink/obj5.c | 12 ++++--------
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/liblink/asm5.c b/src/liblink/asm5.c
index 46aa1c1e3b..65c4ca199a 100644
--- a/src/liblink/asm5.c
+++ b/src/liblink/asm5.c
@@ -309,6 +309,7 @@ static Optab	optab[] =
 	{ AUSEFIELD,	C_ADDR,	C_NONE,	C_NONE, 	 0, 0, 0 },
 	{ APCDATA,	C_LCON,	C_NONE,	C_LCON,		0, 0, 0 },
 	{ AFUNCDATA,	C_LCON,	C_NONE,	C_ADDR,	0, 0, 0 },
+	{ ANOP,		C_NONE,	C_NONE,	C_NONE,		0, 0, 0 },
 
 	{ ADUFFZERO,	C_NONE,	C_NONE,	C_SBRA,		 5, 4, 0 },  // same as ABL
 	{ ADUFFCOPY,	C_NONE,	C_NONE,	C_SBRA,		 5, 4, 0 },  // same as ABL
@@ -686,7 +687,7 @@ span5(Link *ctxt, LSym *cursym)
 				continue;
 			}
 		}
-		if(m == 0 && (p->as != AFUNCDATA && p->as != APCDATA && p->as != ADATABUNDLEEND)) {
+		if(m == 0 && (p->as != AFUNCDATA && p->as != APCDATA && p->as != ADATABUNDLEEND && p->as != ANOP)) {
 			ctxt->diag("zero-width instruction\n%P", p);
 			continue;
 		}
@@ -765,7 +766,7 @@ span5(Link *ctxt, LSym *cursym)
 			}
 			if(m/4 > nelem(out))
 				ctxt->diag("instruction size too large: %d > %d", m/4, nelem(out));
-			if(m == 0 && (p->as != AFUNCDATA && p->as != APCDATA && p->as != ADATABUNDLEEND)) {
+			if(m == 0 && (p->as != AFUNCDATA && p->as != APCDATA && p->as != ADATABUNDLEEND && p->as != ANOP)) {
 				if(p->as == ATEXT) {
 					ctxt->autosize = p->to.offset + 4;
 					continue;
@@ -1479,6 +1480,7 @@ buildop(Link *ctxt)
 		case ACLZ:
 		case AFUNCDATA:
 		case APCDATA:
+		case ANOP:
 		case ADATABUNDLE:
 		case ADATABUNDLEEND:
 			break;
diff --git a/src/liblink/obj5.c b/src/liblink/obj5.c
index d7008a48c0..e8b81ec5ca 100644
--- a/src/liblink/obj5.c
+++ b/src/liblink/obj5.c
@@ -466,12 +466,10 @@ addstacksplit(Link *ctxt, LSym *cursym)
 				p->as = ACMP;
 				p->from.type = D_CONST;
 				p->from.offset = 0;
-				p->to.type = D_REG;
-				p->to.reg = 1;
+				p->reg = 1;
 			
 				p = appendp(ctxt, p);
-				p->as = AB;
-				p->scond = C_SCOND_EQ;
+				p->as = ABEQ;
 				p->to.type = D_BRANCH;
 				p1 = p;
 				
@@ -495,12 +493,10 @@ addstacksplit(Link *ctxt, LSym *cursym)
 				p->as = ACMP;
 				p->from.type = D_REG;
 				p->from.offset = 2;
-				p->to.type = D_REG;
-				p->to.reg = 3;
+				p->reg = 3;
 
 				p = appendp(ctxt, p);
-				p->as = AB;
-				p->scond = C_SCOND_NE;
+				p->as = ABNE;
 				p->to.type = D_BRANCH;
 				p2 = p;
 			

From a09e61395ee5e71c4c4a37fa0faed87592a04834 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 15:27:26 -0400
Subject: [PATCH 405/423] runtime: move stubs.goc code into runtime.c

Now that the calling conventions are the same,
there's no danger to using plain C for these.

LGTM=bradfitz
R=golang-codereviews, bradfitz
CC=dvyukov, golang-codereviews, iant, khr, r
https://golang.org/cl/134580043
---
 src/pkg/runtime/runtime.c | 48 +++++++++++++++++++++++++++++++++
 src/pkg/runtime/stubs.goc | 57 ---------------------------------------
 2 files changed, 48 insertions(+), 57 deletions(-)
 delete mode 100644 src/pkg/runtime/stubs.goc

diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index d28ee58179..42ce1dadfb 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -341,3 +341,51 @@ runtime·timediv(int64 v, int32 div, int32 *rem)
 		*rem = v;
 	return res;
 }
+
+// Helpers for Go. Must be NOSPLIT, must only call NOSPLIT functions, and must not block.
+
+#pragma textflag NOSPLIT
+G*
+runtime·getg(void)
+{
+	return g;
+}
+
+#pragma textflag NOSPLIT
+M*
+runtime·acquirem(void)
+{
+	g->m->locks++;
+	return g->m;
+}
+
+#pragma textflag NOSPLIT
+void
+runtime·releasem(M *mp)
+{
+	mp->locks--;
+	if(mp->locks == 0 && g->preempt) {
+		// restore the preemption request in case we've cleared it in newstack
+		g->stackguard0 = StackPreempt;
+	}
+}
+
+#pragma textflag NOSPLIT
+MCache*
+runtime·gomcache(void)
+{
+	return g->m->mcache;
+}
+
+#pragma textflag NOSPLIT
+Slice
+reflect·typelinks(void)
+{
+	extern Type *runtime·typelink[], *runtime·etypelink[];
+	Slice ret;
+
+	ret.array = (byte*)runtime·typelink;
+	ret.len = runtime·etypelink - runtime·typelink;
+	ret.cap = ret.len;
+	return ret;
+}
diff --git a/src/pkg/runtime/stubs.goc b/src/pkg/runtime/stubs.goc
deleted file mode 100644
index e1b1a02101..0000000000
--- a/src/pkg/runtime/stubs.goc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-#include "runtime.h"
-#include "arch_GOARCH.h"
-#include "malloc.h"
-#include "stack.h"
-#include "textflag.h"
-
-// This file contains functions called by Go but written
-// in C.  These functions are problematic for the garbage
-// collector and stack copier because we don't have
-// stack maps for them.  So we must ensure that the
-// garbage collector and stack copier cannot see these
-// frames.  So we impose the following invariants:
-
-// 1) Functions should be marked NOSPLIT and call
-//    out to only NOSPLIT functions (recursively).
-// 2) Functions should not block.
-
-// These invariants do not hold yet but will be established once we have
-// finished converting runtime support code from C to Go.
-
-#pragma textflag NOSPLIT
-func runtime·getg() (ret *G) {
-	ret = g;
-}
-
-#pragma textflag NOSPLIT
-func runtime·acquirem() (ret *M) {
-	ret = g->m;
-	ret->locks++;
-}
-
-#pragma textflag NOSPLIT
-func runtime·releasem(mp *M) {
-	mp->locks--;
-	if(mp->locks == 0 && g->preempt) {
-		// restore the preemption request in case we've cleared it in newstack
-		g->stackguard0 = StackPreempt;
-	}
-}
-
-#pragma textflag NOSPLIT
-func runtime·gomcache() (ret *MCache) {
-	ret = g->m->mcache;
-}
-
-#pragma textflag NOSPLIT
-func reflect·typelinks() (ret Slice) {
-        extern Type *runtime·typelink[], *runtime·etypelink[];
-        ret.array = (byte*)runtime·typelink;
-        ret.len = runtime·etypelink - runtime·typelink;
-        ret.cap = ret.len;
-}

From e8fc362049aea9000b5e5fe58d0c46dd14e05ba1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 15:27:39 -0400
Subject: [PATCH 406/423] runtime/cgo: use just #include "textflag.h"

This will withstand the src/pkg/ to src/ move.

LGTM=r
R=iant, r
CC=golang-codereviews
https://golang.org/cl/134530044
---
 src/pkg/runtime/cgo/asm_386.s           | 2 +-
 src/pkg/runtime/cgo/asm_amd64.s         | 2 +-
 src/pkg/runtime/cgo/asm_arm.s           | 2 +-
 src/pkg/runtime/cgo/asm_nacl_amd64p32.s | 2 +-
 src/pkg/runtime/cgo/callbacks.c         | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/cgo/asm_386.s b/src/pkg/runtime/cgo/asm_386.s
index ab2f1d17a8..a895083f1b 100644
--- a/src/pkg/runtime/cgo/asm_386.s
+++ b/src/pkg/runtime/cgo/asm_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 /*
  * void crosscall2(void (*fn)(void*, int32), void*, int32)
diff --git a/src/pkg/runtime/cgo/asm_amd64.s b/src/pkg/runtime/cgo/asm_amd64.s
index 64f719ab1c..6095bd1337 100644
--- a/src/pkg/runtime/cgo/asm_amd64.s
+++ b/src/pkg/runtime/cgo/asm_amd64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 /*
  * void crosscall2(void (*fn)(void*, int32), void*, int32)
diff --git a/src/pkg/runtime/cgo/asm_arm.s b/src/pkg/runtime/cgo/asm_arm.s
index b989ab9330..6e57432e35 100644
--- a/src/pkg/runtime/cgo/asm_arm.s
+++ b/src/pkg/runtime/cgo/asm_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 /*
  * void crosscall2(void (*fn)(void*, int32), void*, int32)
diff --git a/src/pkg/runtime/cgo/asm_nacl_amd64p32.s b/src/pkg/runtime/cgo/asm_nacl_amd64p32.s
index 377cf72a3a..eb92014ed8 100644
--- a/src/pkg/runtime/cgo/asm_nacl_amd64p32.s
+++ b/src/pkg/runtime/cgo/asm_nacl_amd64p32.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 /*
  * void crosscall2(void (*fn)(void*, int32), void*, int32)
diff --git a/src/pkg/runtime/cgo/callbacks.c b/src/pkg/runtime/cgo/callbacks.c
index eb69255db4..f074237d5f 100644
--- a/src/pkg/runtime/cgo/callbacks.c
+++ b/src/pkg/runtime/cgo/callbacks.c
@@ -4,7 +4,7 @@
 
 #include "../runtime.h"
 #include "../cgocall.h"
-#include "../../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 // These utility functions are available to be called from code
 // compiled with gcc via crosscall2.

From 9c721aedd572c00d1a91549dda910ce74fe17d44 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 15:27:52 -0400
Subject: [PATCH 407/423] cmd/yacc: move cmd/yacc/expr to
 cmd/yacc/testdata/expr

This will keep the go command from trying to build it
when the cmd/ tree is no longer a special case.

Also update doc.go to refer to the correct location.
(It was incorrect even before this CL.)

LGTM=r
R=iant, r
CC=golang-codereviews
https://golang.org/cl/134560043
---
 src/cmd/yacc/doc.go                      | 5 +++--
 src/cmd/yacc/{ => testdata}/expr/README  | 0
 src/cmd/yacc/{ => testdata}/expr/expr.y  | 0
 src/cmd/yacc/{ => testdata}/expr/main.go | 0
 4 files changed, 3 insertions(+), 2 deletions(-)
 rename src/cmd/yacc/{ => testdata}/expr/README (100%)
 rename src/cmd/yacc/{ => testdata}/expr/expr.y (100%)
 rename src/cmd/yacc/{ => testdata}/expr/main.go (100%)

diff --git a/src/cmd/yacc/doc.go b/src/cmd/yacc/doc.go
index ceaaf2448d..702c9f0d25 100644
--- a/src/cmd/yacc/doc.go
+++ b/src/cmd/yacc/doc.go
@@ -20,8 +20,9 @@ written in C and documented at
 Adepts of the original yacc will have no trouble adapting to this
 form of the tool.
 
-The file expr.y in this directory is a yacc grammar for a very simple
-expression parser.  It needs the flag "-p expr" (see below).
+The directory $GOROOT/cmd/yacc/testdata/expr is a yacc program
+for a very simple expression parser. See expr.y and main.go in that
+directory for examples of how to write and build yacc programs.
 
 The generated parser is reentrant. Parse expects to be given an
 argument that conforms to the following interface:
diff --git a/src/cmd/yacc/expr/README b/src/cmd/yacc/testdata/expr/README
similarity index 100%
rename from src/cmd/yacc/expr/README
rename to src/cmd/yacc/testdata/expr/README
diff --git a/src/cmd/yacc/expr/expr.y b/src/cmd/yacc/testdata/expr/expr.y
similarity index 100%
rename from src/cmd/yacc/expr/expr.y
rename to src/cmd/yacc/testdata/expr/expr.y
diff --git a/src/cmd/yacc/expr/main.go b/src/cmd/yacc/testdata/expr/main.go
similarity index 100%
rename from src/cmd/yacc/expr/main.go
rename to src/cmd/yacc/testdata/expr/main.go

From 7230db9ef8f0bcf69d5ca5743c2177e795f0cbe1 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 21:10:06 -0400
Subject: [PATCH 408/423] misc/makerelease: make goimports-safe

LGTM=bradfitz
R=adg, bradfitz, minux
CC=golang-codereviews
https://golang.org/cl/140310045
---
 misc/makerelease/makerelease.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/misc/makerelease/makerelease.go b/misc/makerelease/makerelease.go
index 1f60f87045..369ab5cb0b 100644
--- a/misc/makerelease/makerelease.go
+++ b/misc/makerelease/makerelease.go
@@ -30,7 +30,7 @@ import (
 	"strings"
 
 	"code.google.com/p/goauth2/oauth"
-	"code.google.com/p/google-api-go-client/storage/v1beta2"
+	storage "code.google.com/p/google-api-go-client/storage/v1beta2"
 )
 
 var (

From b6951bcc0bb081bdd46e3509bd5d4e2c1fa87323 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 21:16:13 -0400
Subject: [PATCH 409/423] runtime: increase stack split limit again

Increase NOSPLIT reservation from 192 to 384 bytes.
The problem is that the non-Unix systems (Solaris and Windows)
just can't make system calls in a small amount of space,
and then worse they do things that are complex enough
to warrant calling runtime.throw on failure.
We don't have time to rewrite the code to use less stack.

I'm not happy about this, but it's still a small amount.

The good news is that we're doing this to get to only
using copying stacks for stack growth. Once that is true,
we can drop the default stack size from 8k to 4k, which
should more than make up for the bytes we're losing here.

LGTM=r
R=iant, r, bradfitz, aram.h
CC=golang-codereviews
https://golang.org/cl/140350043
---
 src/pkg/runtime/stack.go | 92 ----------------------------------------
 src/pkg/runtime/stack.h  |  4 +-
 test/nosplit.go          |  4 +-
 3 files changed, 4 insertions(+), 96 deletions(-)

diff --git a/src/pkg/runtime/stack.go b/src/pkg/runtime/stack.go
index ea27c1fb70..f1b7d32d20 100644
--- a/src/pkg/runtime/stack.go
+++ b/src/pkg/runtime/stack.go
@@ -4,99 +4,7 @@
 
 package runtime
 
-/*
-Stack layout parameters.
-Included both by runtime (compiled via 6c) and linkers (compiled via gcc).
-
-The per-goroutine g->stackguard is set to point stackGuard bytes
-above the bottom of the stack.  Each function compares its stack
-pointer against g->stackguard to check for overflow.  To cut one
-instruction from the check sequence for functions with tiny frames,
-the stack is allowed to protrude stackSmall bytes below the stack
-guard.  Functions with large frames don't bother with the check and
-always call morestack.  The sequences are (for amd64, others are
-similar):
-
-	guard = g->stackguard
-	frame = function's stack frame size
-	argsize = size of function arguments (call + return)
-
-	stack frame size <= stackSmall:
-		CMPQ guard, SP
-		JHI 3(PC)
-		MOVQ m->morearg, $(argsize << 32)
-		CALL morestack(SB)
-
-	stack frame size > stackSmall but < stackBig
-		LEAQ (frame-stackSmall)(SP), R0
-		CMPQ guard, R0
-		JHI 3(PC)
-		MOVQ m->morearg, $(argsize << 32)
-		CALL morestack(SB)
-
-	stack frame size >= stackBig:
-		MOVQ m->morearg, $((argsize << 32) | frame)
-		CALL morestack(SB)
-
-The bottom stackGuard - stackSmall bytes are important: there has
-to be enough room to execute functions that refuse to check for
-stack overflow, either because they need to be adjacent to the
-actual caller's frame (deferproc) or because they handle the imminent
-stack overflow (morestack).
-
-For example, deferproc might call malloc, which does one of the
-above checks (without allocating a full frame), which might trigger
-a call to morestack.  This sequence needs to fit in the bottom
-section of the stack.  On amd64, morestack's frame is 40 bytes, and
-deferproc's frame is 56 bytes.  That fits well within the
-stackGuard - stackSmall = 128 bytes at the bottom.
-The linkers explore all possible call traces involving non-splitting
-functions to make sure that this limit cannot be violated.
-*/
-
 const (
-	// stackSystem is a number of additional bytes to add
-	// to each stack below the usual guard area for OS-specific
-	// purposes like signal handling. Used on Windows and on
-	// Plan 9 because they do not use a separate stack.
-	// Defined in os_*.go.
-
-	// The amount of extra stack to allocate beyond the size
-	// needed for the single frame that triggered the split.
-	stackExtra = 2048
-
-	// The minimum stack segment size to allocate.
-	// If the amount needed for the splitting frame + stackExtra
-	// is less than this number, the stack will have this size instead.
-	stackMin           = 8192
-	stackSystemRounded = stackSystem + (-stackSystem & (stackMin - 1))
-	Fixedstack         = stackMin + stackSystemRounded
-
-	// Functions that need frames bigger than this use an extra
-	// instruction to do the stack split check, to avoid overflow
-	// in case SP - framesize wraps below zero.
-	// This value can be no bigger than the size of the unmapped
-	// space at zero.
-	stackBig = 4096
-
-	// The stack guard is a pointer this many bytes above the
-	// bottom of the stack.
-	stackGuard = 256 + stackSystem
-
-	// After a stack split check the SP is allowed to be this
-	// many bytes below the stack guard.  This saves an instruction
-	// in the checking sequence for tiny frames.
-	stackSmall = 64
-
-	// The maximum number of bytes that a chain of NOSPLIT
-	// functions can use.
-	stackLimit = stackGuard - stackSystem - stackSmall
-
-	// The assumed size of the top-of-stack data block.
-	// The actual size can be smaller than this but cannot be larger.
-	// Checked in proc.c's runtime.malg.
-	stackTop = 88
-
 	// Goroutine preemption request.
 	// Stored into g->stackguard0 to cause split stack check failure.
 	// Must be greater than any real sp.
diff --git a/src/pkg/runtime/stack.h b/src/pkg/runtime/stack.h
index dc9da74887..7f8c43ee54 100644
--- a/src/pkg/runtime/stack.h
+++ b/src/pkg/runtime/stack.h
@@ -89,12 +89,12 @@ enum {
 
 	// The stack guard is a pointer this many bytes above the
 	// bottom of the stack.
-	StackGuard = 256 + StackSystem,
+	StackGuard = 512 + StackSystem,
 
 	// After a stack split check the SP is allowed to be this
 	// many bytes below the stack guard.  This saves an instruction
 	// in the checking sequence for tiny frames.
-	StackSmall = 64,
+	StackSmall = 128,
 
 	// The maximum number of bytes that a chain of NOSPLIT
 	// functions can use.
diff --git a/test/nosplit.go b/test/nosplit.go
index 3854f24203..c9d008acd3 100644
--- a/test/nosplit.go
+++ b/test/nosplit.go
@@ -256,11 +256,11 @@ TestCases:
 				name := m[1]
 				size, _ := strconv.Atoi(m[2])
 
-				// The limit was originally 128 but is now 192.
+				// The limit was originally 128 but is now 384.
 				// Instead of rewriting the test cases above, adjust
 				// the first stack frame to use up the extra 32 bytes.
 				if i == 0 {
-					size += 192 - 128
+					size += 384 - 128
 				}
 
 				if goarch == "amd64" && size%8 == 4 {

From c01c2c8895e9efe48dfef89cb3c0414539962505 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 21:16:35 -0400
Subject: [PATCH 410/423] runtime: eliminate Go -> C -> block paths for Solaris

LGTM=aram, r
R=golang-codereviews, aram, r
CC=golang-codereviews, iant, khr
https://golang.org/cl/141180043
---
 src/pkg/runtime/netpoll.go   | 15 +++++++++++----
 src/pkg/runtime/os_solaris.c | 10 ++++++++++
 src/pkg/runtime/panic1.go    | 13 ++++++++++++-
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/src/pkg/runtime/netpoll.go b/src/pkg/runtime/netpoll.go
index 08da87aa26..3456e02081 100644
--- a/src/pkg/runtime/netpoll.go
+++ b/src/pkg/runtime/netpoll.go
@@ -72,7 +72,7 @@ type pollCache struct {
 var pollcache pollCache
 
 func netpollServerInit() {
-	netpollinit()
+	onM(netpollinit)
 }
 
 func netpollOpen(fd uintptr) (*pollDesc, int) {
@@ -93,7 +93,10 @@ func netpollOpen(fd uintptr) (*pollDesc, int) {
 	pd.wd = 0
 	unlock(&pd.lock)
 
-	errno := netpollopen(fd, pd)
+	var errno int32
+	onM(func() {
+		errno = netpollopen(fd, pd)
+	})
 	return pd, int(errno)
 }
 
@@ -107,7 +110,9 @@ func netpollClose(pd *pollDesc) {
 	if pd.rg != 0 && pd.rg != pdReady {
 		gothrow("netpollClose: blocked read on closing descriptor")
 	}
-	netpollclose(uintptr(pd.fd))
+	onM(func() {
+		netpollclose(uintptr(pd.fd))
+	})
 	pollcache.free(pd)
 }
 
@@ -138,7 +143,9 @@ func netpollWait(pd *pollDesc, mode int) int {
 	}
 	// As for now only Solaris uses level-triggered IO.
 	if GOOS == "solaris" {
-		netpollarm(pd, mode)
+		onM(func() {
+			netpollarm(pd, mode)
+		})
 	}
 	for !netpollblock(pd, int32(mode), false) {
 		err = netpollcheckerr(pd, int32(mode))
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index 5e1f7ab076..c6c2a8a7a1 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -386,36 +386,42 @@ runtime·semawakeup(M *mp)
 		runtime·throw("sem_post");
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·close(int32 fd)
 {
 	return runtime·sysvicall1(libc·close, (uintptr)fd);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·exit(int32 r)
 {
 	runtime·sysvicall1(libc·exit, (uintptr)r);
 }
 
+#pragma textflag NOSPLIT
 /* int32 */ void
 runtime·getcontext(Ucontext* context)
 {
 	runtime·sysvicall1(libc·getcontext, (uintptr)context);
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·getrlimit(int32 res, Rlimit* rlp)
 {
 	return runtime·sysvicall2(libc·getrlimit, (uintptr)res, (uintptr)rlp);
 }
 
+#pragma textflag NOSPLIT
 uint8*
 runtime·mmap(byte* addr, uintptr len, int32 prot, int32 flags, int32 fildes, uint32 off)
 {
 	return (uint8*)runtime·sysvicall6(libc·mmap, (uintptr)addr, (uintptr)len, (uintptr)prot, (uintptr)flags, (uintptr)fildes, (uintptr)off);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·munmap(byte* addr, uintptr len)
 {
@@ -430,6 +436,7 @@ runtime·nanotime(void)
 	return runtime·sysvicall0((uintptr)runtime·nanotime1);
 }
 
+#pragma textflag NOSPLIT
 void
 time·now(int64 sec, int32 usec)
 {
@@ -442,6 +449,7 @@ time·now(int64 sec, int32 usec)
 	FLUSH(&usec);
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·open(int8* path, int32 oflag, int32 mode)
 {
@@ -490,6 +498,7 @@ runtime·raise(int32 sig)
 	runtime·sysvicall1(libc·raise, (uintptr)sig);
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·read(int32 fd, void* buf, int32 nbyte)
 {
@@ -563,6 +572,7 @@ runtime·usleep(uint32 µs)
 	runtime·usleep1(µs);
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·write(uintptr fd, void* buf, int32 nbyte)
 {
diff --git a/src/pkg/runtime/panic1.go b/src/pkg/runtime/panic1.go
index 1f2f54ec20..e877434320 100644
--- a/src/pkg/runtime/panic1.go
+++ b/src/pkg/runtime/panic1.go
@@ -138,10 +138,12 @@ func gorecover(argp uintptr) interface{} {
 	return nil
 }
 
+//go:nosplit
 func startpanic() {
 	onM(startpanic_m)
 }
 
+//go:nosplit
 func dopanic(unused int) {
 	gp := getg()
 	mp := acquirem()
@@ -152,10 +154,19 @@ func dopanic(unused int) {
 	*(*int)(nil) = 0
 }
 
+//go:nosplit
 func throw(s *byte) {
-	gothrow(gostringnocopy(s))
+	gp := getg()
+	if gp.m.throwing == 0 {
+		gp.m.throwing = 1
+	}
+	startpanic()
+	print("fatal error: ", gostringnocopy(s), "\n")
+	dopanic(0)
+	*(*int)(nil) = 0 // not reached
 }
 
+//go:nosplit
 func gothrow(s string) {
 	gp := getg()
 	if gp.m.throwing == 0 {

From 59dd20f4d3d3614edf665d79c1f4fa5f6f30d057 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sat, 6 Sep 2014 21:19:24 -0400
Subject: [PATCH 411/423] runtime: fix windows syscalls for copying stacks

Syscall and everything it calls must be nosplit:
we cannot split a stack once Syscall has been invoked,
because we don't know which of its arguments are
pointers.

LGTM=khr, r, alex.brainman
R=dvyukov, iant, khr, r, bradfitz, alex.brainman
CC=golang-codereviews
https://golang.org/cl/133670043
---
 src/pkg/runtime/cgocall.go          |   2 +
 src/pkg/runtime/os_windows.c        |  17 ++-
 src/pkg/runtime/syscall_windows.c   | 166 ++++++++++++++++++++++++++++
 src/pkg/runtime/syscall_windows.goc | 137 -----------------------
 4 files changed, 184 insertions(+), 138 deletions(-)
 create mode 100644 src/pkg/runtime/syscall_windows.c
 delete mode 100644 src/pkg/runtime/syscall_windows.goc

diff --git a/src/pkg/runtime/cgocall.go b/src/pkg/runtime/cgocall.go
index c00694e669..76a533e933 100644
--- a/src/pkg/runtime/cgocall.go
+++ b/src/pkg/runtime/cgocall.go
@@ -82,10 +82,12 @@ package runtime
 import "unsafe"
 
 // Call from Go to C.
+//go:nosplit
 func cgocall(fn, arg unsafe.Pointer) {
 	cgocall_errno(fn, arg)
 }
 
+//go:nosplit
 func cgocall_errno(fn, arg unsafe.Pointer) int32 {
 	if !iscgo && GOOS != "solaris" && GOOS != "windows" {
 		gothrow("cgocall unavailable")
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index 885fe63343..d7f7a5a3b4 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -158,12 +158,14 @@ runtime·goenvs(void)
 	runtime·stdcall1(runtime·FreeEnvironmentStringsW, (uintptr)env);
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·exit(int32 code)
 {
 	runtime·stdcall1(runtime·ExitProcess, code);
 }
 
+#pragma textflag NOSPLIT
 int32
 runtime·write(uintptr fd, void *buf, int32 n)
 {
@@ -206,12 +208,14 @@ runtime·semasleep(int64 ns)
 	return 0;
 }
 
+#pragma textflag NOSPLIT
 void
 runtime·semawakeup(M *mp)
 {
 	runtime·stdcall1(runtime·SetEvent, mp->waitsema);
 }
 
+#pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
@@ -272,12 +276,15 @@ typedef struct KSYSTEM_TIME {
 const KSYSTEM_TIME* INTERRUPT_TIME	= (KSYSTEM_TIME*)0x7ffe0008;
 const KSYSTEM_TIME* SYSTEM_TIME		= (KSYSTEM_TIME*)0x7ffe0014;
 
+static void badsystime(void);
+
 #pragma textflag NOSPLIT
 int64
 runtime·systime(KSYSTEM_TIME *timeaddr)
 {
 	KSYSTEM_TIME t;
 	int32 i;
+	void (*fn)(void);
 
 	for(i = 1; i < 10000; i++) {
 		// these fields must be read in that order (see URL above)
@@ -289,10 +296,17 @@ runtime·systime(KSYSTEM_TIME *timeaddr)
 		if((i%100) == 0)
 			runtime·osyield();
 	}
-	runtime·throw("interrupt/system time is changing too fast");
+	fn = badsystime;
+	runtime·onM(&fn);
 	return 0;
 }
 
+static void
+badsystime(void)
+{
+	runtime·throw("interrupt/system time is changing too fast");
+}
+
 #pragma textflag NOSPLIT
 int64
 runtime·nanotime(void)
@@ -300,6 +314,7 @@ runtime·nanotime(void)
 	return runtime·systime(INTERRUPT_TIME) * 100LL;
 }
 
+#pragma textflag NOSPLIT
 void
 time·now(int64 sec, int32 usec)
 {
diff --git a/src/pkg/runtime/syscall_windows.c b/src/pkg/runtime/syscall_windows.c
new file mode 100644
index 0000000000..e7903b5171
--- /dev/null
+++ b/src/pkg/runtime/syscall_windows.c
@@ -0,0 +1,166 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "runtime.h"
+#include "os_GOOS.h"
+#include "cgocall.h"
+#include "textflag.h"
+
+typedef struct HandleErr HandleErr;
+typedef struct SyscallErr SyscallErr;
+
+struct HandleErr {
+	uintptr handle;
+	uintptr err;
+};
+
+struct SyscallErr {
+	uintptr r1;
+	uintptr r2;
+	uintptr err;
+};
+
+#pragma textflag NOSPLIT
+HandleErr
+syscall·loadlibrary(uint16 *filename)
+{
+	LibCall c;
+	HandleErr r;
+
+	c.fn = runtime·LoadLibrary;
+	c.n = 1;
+	c.args = &filename;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	r.handle = c.r1;
+	if(r.handle == 0)
+		r.err = c.err;
+	else
+		r.err = 0;
+	return r;
+}
+
+#pragma textflag NOSPLIT
+HandleErr
+syscall·getprocaddress(uintptr handle, int8 *procname)
+{
+	LibCall c;
+	HandleErr r;
+
+	USED(procname);
+	c.fn = runtime·GetProcAddress;
+	c.n = 2;
+	c.args = &handle;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	r.handle = c.r1;
+	if(r.handle == 0)
+		r.err = c.err;
+	else
+		r.err = 0;
+	return r;
+}
+
+#pragma textflag NOSPLIT
+SyscallErr
+syscall·Syscall(uintptr fn, uintptr nargs, uintptr a1, uintptr a2, uintptr a3)
+{
+	LibCall c;
+
+	USED(a2);
+	USED(a3);
+	c.fn = (void*)fn;
+	c.n = nargs;
+	c.args = &a1;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	return (SyscallErr){c.r1, c.r2, c.err};
+}
+
+#pragma textflag NOSPLIT
+SyscallErr
+syscall·Syscall6(uintptr fn, uintptr nargs, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6)
+{
+	LibCall c;
+
+	USED(a2);
+	USED(a3);
+	USED(a4);
+	USED(a5);
+	USED(a6);
+	c.fn = (void*)fn;
+	c.n = nargs;
+	c.args = &a1;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	return (SyscallErr){c.r1, c.r2, c.err};
+}
+
+#pragma textflag NOSPLIT
+SyscallErr
+syscall·Syscall9(uintptr fn, uintptr nargs, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6, uintptr a7, uintptr a8, uintptr a9)
+{
+	LibCall c;
+
+	USED(a2);
+	USED(a3);
+	USED(a4);
+	USED(a5);
+	USED(a6);
+	USED(a7);
+	USED(a8);
+	USED(a9);
+	c.fn = (void*)fn;
+	c.n = nargs;
+	c.args = &a1;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	return (SyscallErr){c.r1, c.r2, c.err};
+}
+
+#pragma textflag NOSPLIT
+SyscallErr
+syscall·Syscall12(uintptr fn, uintptr nargs, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6, uintptr a7, uintptr a8, uintptr a9, uintptr a10, uintptr a11, uintptr a12)
+{
+	LibCall c;
+
+	USED(a2);
+	USED(a3);
+	USED(a4);
+	USED(a5);
+	USED(a6);
+	USED(a7);
+	USED(a8);
+	USED(a9);
+	USED(a10);
+	USED(a11);
+	USED(a12);
+	c.fn = (void*)fn;
+	c.n = nargs;
+	c.args = &a1;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	return (SyscallErr){c.r1, c.r2, c.err};
+}
+
+#pragma textflag NOSPLIT
+SyscallErr
+syscall·Syscall15(uintptr fn, uintptr nargs, uintptr a1, uintptr a2, uintptr a3, uintptr a4, uintptr a5, uintptr a6, uintptr a7, uintptr a8, uintptr a9, uintptr a10, uintptr a11, uintptr a12, uintptr a13, uintptr a14, uintptr a15)
+{
+	LibCall c;
+
+	USED(a2);
+	USED(a3);
+	USED(a4);
+	USED(a5);
+	USED(a6);
+	USED(a7);
+	USED(a8);
+	USED(a9);
+	USED(a10);
+	USED(a11);
+	USED(a12);
+	USED(a13);
+	USED(a14);
+	USED(a15);
+	c.fn = (void*)fn;
+	c.n = nargs;
+	c.args = &a1;
+	runtime·cgocall_errno(runtime·asmstdcall, &c);
+	return (SyscallErr){c.r1, c.r2, c.err};
+}
diff --git a/src/pkg/runtime/syscall_windows.goc b/src/pkg/runtime/syscall_windows.goc
deleted file mode 100644
index a1665c3b5c..0000000000
--- a/src/pkg/runtime/syscall_windows.goc
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package syscall
-#include "runtime.h"
-#include "os_GOOS.h"
-#include "cgocall.h"
-
-func loadlibrary(filename *uint16) (handle uintptr, err uintptr) {
-	LibCall c;
-
-	c.fn = runtime·LoadLibrary;
-	c.n = 1;
-	c.args = &filename;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	handle = c.r1;
-	if(handle == 0)
-		err = c.err;
-	else
-		err = 0;
-}
-
-func getprocaddress(handle uintptr, procname *uint8) (proc uintptr, err uintptr) {
-	LibCall c;
-
-	USED(procname);
-	c.fn = runtime·GetProcAddress;
-	c.n = 2;
-	c.args = &handle;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	proc = c.r1;
-	if(proc == 0)
-		err = c.err;
-	else
-		err = 0;
-}
-
-func Syscall(fn uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	c.fn = (void*)fn;
-	c.n = nargs;
-	c.args = &a1;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-func Syscall6(fn uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	USED(a4);
-	USED(a5);
-	USED(a6);
-	c.fn = (void*)fn;
-	c.n = nargs;
-	c.args = &a1;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-func Syscall9(fn uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr, a7 uintptr, a8 uintptr, a9 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	USED(a4);
-	USED(a5);
-	USED(a6);
-	USED(a7);
-	USED(a8);
-	USED(a9);
-	c.fn = (void*)fn;
-	c.n = nargs;
-	c.args = &a1;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-func Syscall12(fn uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr, a7 uintptr, a8 uintptr, a9 uintptr, a10 uintptr, a11 uintptr, a12 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	USED(a4);
-	USED(a5);
-	USED(a6);
-	USED(a7);
-	USED(a8);
-	USED(a9);
-	USED(a10);
-	USED(a11);
-	USED(a12);
-	c.fn = (void*)fn;
-	c.n = nargs;
-	c.args = &a1;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}
-
-func Syscall15(fn uintptr, nargs uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr, a7 uintptr, a8 uintptr, a9 uintptr, a10 uintptr, a11 uintptr, a12 uintptr, a13 uintptr, a14 uintptr, a15 uintptr) (r1 uintptr, r2 uintptr, err uintptr) {
-	LibCall c;
-
-	USED(a2);
-	USED(a3);
-	USED(a4);
-	USED(a5);
-	USED(a6);
-	USED(a7);
-	USED(a8);
-	USED(a9);
-	USED(a10);
-	USED(a11);
-	USED(a12);
-	USED(a13);
-	USED(a14);
-	USED(a15);
-	c.fn = (void*)fn;
-	c.n = nargs;
-	c.args = &a1;
-	runtime·cgocall(runtime·asmstdcall, &c);
-	err = c.err;
-	r1 = c.r1;
-	r2 = c.r2;
-}

From 8a7597fd7a28cd408852e227661044b31d525032 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 07:23:18 -0400
Subject: [PATCH 412/423] runtime: fix nacl/amd64p32 build

Update #8675
Fixes nacl/amd64p32 build.

TBR=khr
CC=golang-codereviews
https://golang.org/cl/141140045
---
 src/liblink/obj6.c             | 22 ++++++++++++++++++++++
 src/pkg/runtime/asm_amd64p32.s | 16 +++-------------
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/liblink/obj6.c b/src/liblink/obj6.c
index c6b8e0964e..3c62470be9 100644
--- a/src/liblink/obj6.c
+++ b/src/liblink/obj6.c
@@ -483,11 +483,19 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		p->from.type = D_INDIR+D_CX;
 		p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
 		p->to.type = D_BX;
+		if(ctxt->headtype == Hnacl) {
+			p->as = AMOVL;
+			p->from.type = D_INDIR+D_R15;
+			p->from.scale = 1;
+			p->from.index = D_CX;
+		}
 
 		p = appendp(ctxt, p);
 		p->as = ATESTQ;
 		p->from.type = D_BX;
 		p->to.type = D_BX;
+		if(ctxt->headtype == Hnacl)
+			p->as = ATESTL;
 
 		p = appendp(ctxt, p);
 		p->as = AJEQ;
@@ -499,12 +507,20 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		p->from.type = D_INDIR+D_SP;
 		p->from.offset = autoffset+8;
 		p->to.type = D_DI;
+		if(ctxt->headtype == Hnacl)
+			p->as = ALEAL;
 
 		p = appendp(ctxt, p);
 		p->as = ACMPQ;
 		p->from.type = D_INDIR+D_BX;
 		p->from.offset = 0; // Panic.argp
 		p->to.type = D_DI;
+		if(ctxt->headtype == Hnacl) {
+			p->as = ACMPL;
+			p->from.type = D_INDIR+D_R15;
+			p->from.scale = 1;
+			p->from.index = D_BX;
+		}
 
 		p = appendp(ctxt, p);
 		p->as = AJNE;
@@ -516,6 +532,12 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		p->from.type = D_SP;
 		p->to.type = D_INDIR+D_BX;
 		p->to.offset = 0; // Panic.argp
+		if(ctxt->headtype == Hnacl) {
+			p->as = AMOVL;
+			p->to.type = D_INDIR+D_R15;
+			p->to.scale = 1;
+			p->to.index = D_BX;
+		}
 
 		p = appendp(ctxt, p);
 		p->as = ANOP;
diff --git a/src/pkg/runtime/asm_amd64p32.s b/src/pkg/runtime/asm_amd64p32.s
index 2597b8250f..6c10bec5c3 100644
--- a/src/pkg/runtime/asm_amd64p32.s
+++ b/src/pkg/runtime/asm_amd64p32.s
@@ -281,7 +281,7 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	RET
 
 // reflect·call: call a function with the given argument list
-// func call(f *FuncVal, arg *byte, argsize, retoffset uint32, p *Panic).
+// func call(f *FuncVal, arg *byte, argsize, retoffset uint32).
 // we don't have variable-sized frames, so we use a small number
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
@@ -293,7 +293,7 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	JMP	AX
 // Note: can't just "JMP NAME(SB)" - bad inlining results.
 
-TEXT reflect·call(SB), NOSPLIT, $0-20
+TEXT reflect·call(SB), NOSPLIT, $0-16
 	MOVLQZX argsize+8(FP), CX
 	DISPATCH(runtime·call16, 16)
 	DISPATCH(runtime·call32, 32)
@@ -338,7 +338,7 @@ DATA gclocals_reflectcall<>+0x04(SB)/4, $0  // 0 locals
 GLOBL gclocals_reflectcall<>(SB),RODATA,$8
 
 #define CALLFN(NAME,MAXSIZE)			\
-TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
+TEXT NAME(SB), WRAPPER, $MAXSIZE-16;		\
 	FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB);	\
 	FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\
 	/* copy arguments to stack */		\
@@ -346,20 +346,10 @@ TEXT NAME(SB), WRAPPER, $MAXSIZE-20;		\
 	MOVL	argsize+8(FP), CX;		\
 	MOVL	SP, DI;				\
 	REP;MOVSB;				\
-	/* initialize panic argp */		\
-	MOVL	panic+16(FP), CX;		\
-	CMPL	CX, $0;				\
-	JEQ	2(PC);				\
-	MOVL	SP, panic_argp(CX);		\
 	/* call function */			\
 	MOVL	f+0(FP), DX;			\
 	MOVL	(DX), AX;				\
 	CALL	AX; \
-	/* clear panic argp */			\
-	MOVL	panic+16(FP), CX;		\
-	CMPL	CX, $0;				\
-	JEQ	2(PC);				\
-	MOVL	$0, panic_argp(CX);		\
 	/* copy return values back */		\
 	MOVL	argptr+4(FP), DI;		\
 	MOVL	argsize+8(FP), CX;		\

From c0951701cf72270e441904186d5f6714a296d1f3 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 07:23:49 -0400
Subject: [PATCH 413/423] cmd/dist: remove goc2c

After the three pending CLs listed below, there will be no more .goc files.

134580043	runtime: move stubs.goc code into runtime.c
133670043	runtime: fix windows syscalls for copying stacks
141180043	runtime: eliminate Go -> C -> block paths for Solaris

LGTM=bradfitz
R=golang-codereviews, bradfitz, dave
CC=golang-codereviews, iant, r
https://golang.org/cl/132680043
---
 src/cmd/dist/a.h     |   3 -
 src/cmd/dist/build.c |  18 -
 src/cmd/dist/goc2c.c | 839 -------------------------------------------
 3 files changed, 860 deletions(-)
 delete mode 100644 src/cmd/dist/goc2c.c

diff --git a/src/cmd/dist/a.h b/src/cmd/dist/a.h
index 6f7a2d1b95..288063b94b 100644
--- a/src/cmd/dist/a.h
+++ b/src/cmd/dist/a.h
@@ -108,9 +108,6 @@ void	mkzexperiment(char*, char*);
 // buildgo.c
 void	mkzdefaultcc(char*, char*);
 
-// goc2c.c
-void	goc2c(char*, char*, char*);
-
 // main.c
 extern int vflag;
 extern int sflag;
diff --git a/src/cmd/dist/build.c b/src/cmd/dist/build.c
index 2e9c6b6e6a..1c18c5932d 100644
--- a/src/cmd/dist/build.c
+++ b/src/cmd/dist/build.c
@@ -607,7 +607,6 @@ char *depsuffix[] = {
 	".h",
 	".s",
 	".go",
-	".goc",
 };
 
 // gentab records how to generate some trivial files.
@@ -935,23 +934,6 @@ install(char *dir)
 			bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch), 0);
 	}
 
-	// Generate .c files from .goc files.
-	if(streq(dir, "pkg/runtime")) {
-		for(i=0; i<files.len; i++) {
-			p = files.p[i];
-			if(!hassuffix(p, ".goc"))
-				continue;
-			// b = path/zp but with _goos_goarch.c instead of .goc
-			bprintf(&b, "%s%sz%s", bstr(&path), slash, lastelem(p));
-			bprintf(&final_name, "%s%s%s", bstr(&final_path), slash, lastelem(p));
-			b.len -= 4;
-			bwritef(&b, "_%s_%s.c", goos, goarch);
-			goc2c(p, bstr(&final_name), bstr(&b));
-			vadd(&files, bstr(&b));
-		}
-		vuniq(&files);
-	}
-
 	if((!streq(goos, gohostos) || !streq(goarch, gohostarch)) && isgo) {
 		// We've generated the right files; the go command can do the build.
 		if(vflag > 1)
diff --git a/src/cmd/dist/goc2c.c b/src/cmd/dist/goc2c.c
deleted file mode 100644
index ddf70411c8..0000000000
--- a/src/cmd/dist/goc2c.c
+++ /dev/null
@@ -1,839 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "a.h"
-
-/*
- * Translate a .goc file into a .c file.  A .goc file is a combination
- * of a limited form of Go with C.
- */
-
-/*
-	package PACKAGENAME
-	{# line}
-	func NAME([NAME TYPE { , NAME TYPE }]) [(NAME TYPE { , NAME TYPE })] \{
-	  C code with proper brace nesting
-	\}
-*/
-
-/*
- * We generate C code which implements the function such that it can
- * be called from Go and executes the C code.
- */
-
-static char *input;
-static Buf *output;
-#define EOF -1
-
-enum
-{
-	use64bitint = 1,
-};
-
-static int
-xgetchar(void)
-{
-	int c;
-	
-	c = *input;
-	if(c == 0)
-		return EOF;
-	input++;
-	return c;
-}
-
-static void
-xungetc(void)
-{
-	input--;
-}
-
-static void
-xputchar(char c)
-{
-	bwrite(output, &c, 1);
-}
-
-static int
-xisspace(int c)
-{
-	return c == ' ' || c == '\t' || c == '\r' || c == '\n';
-}
-
-/* Whether we're emitting for gcc */
-static int gcc;
-
-/* File and line number */
-static const char *file;
-static const char *final_file;
-static unsigned int lineno;
-
-/* List of names and types.  */
-struct params {
-	struct params *next;
-	char *name;
-	char *type;
-};
-
-/* index into type_table */
-enum {
-	Bool,
-	Float,
-	Int,
-	Uint,
-	Uintptr,
-	String,
-	Slice,
-	Eface,
-	Complex128,
-	Float32,
-	Float64,
-};
-
-static struct {
-	char *name;
-	int size;
-	int rnd; // alignment
-} type_table[] = {
-	/* 
-	 * variable sized first, for easy replacement.
-	 * order matches enum above.
-	 * default is 32-bit architecture sizes.
-	 * spelling as in package runtime, so intgo/uintgo not int/uint.
-	 */
-	{"bool",	1},
-	{"float",	4},
-	{"intgo",		4},
-	{"uintgo",	4},
-	{"uintptr",	4},
-	{"String",	8},
-	{"Slice",	12},
-	{"Eface",	8},
-	{"Complex128", 16},
-
-	/* fixed size */
-	{"float32",	4},
-	{"float64",	8},
-	{"byte",	1},
-	{"int8",	1},
-	{"uint8",	1},
-	{"int16",	2},
-	{"uint16",	2},
-	{"int32",	4},
-	{"rune",	4},
-	{"uint32",	4},
-	{"int64",	8},
-	{"uint64",	8},
-
-	{nil, 0},
-};
-
-/* Fixed structure alignment (non-gcc only) */
-int structround = 4;
-
-/* Unexpected EOF.  */
-static void
-bad_eof(void)
-{
-	fatal("%s:%d: unexpected EOF\n", file, lineno);
-}
-
-/* Free a list of parameters.  */
-static void
-free_params(struct params *p)
-{
-	while (p != nil) {
-		struct params *next;
-
-		next = p->next;
-		xfree(p->name);
-		xfree(p->type);
-		xfree(p);
-		p = next;
-	}
-}
-
-/* Read a character, tracking lineno.  */
-static int
-getchar_update_lineno(void)
-{
-	int c;
-
-	c = xgetchar();
-	if (c == '\n')
-		++lineno;
-	return c;
-}
-
-/* Read a character, giving an error on EOF, tracking lineno.  */
-static int
-getchar_no_eof(void)
-{
-	int c;
-
-	c = getchar_update_lineno();
-	if (c == EOF)
-		bad_eof();
-	return c;
-}
-
-/* Read a character, skipping comments.  */
-static int
-getchar_skipping_comments(void)
-{
-	int c;
-
-	while (1) {
-		c = getchar_update_lineno();
-		if (c != '/')
-			return c;
-
-		c = xgetchar();
-		if (c == '/') {
-			do {
-				c = getchar_update_lineno();
-			} while (c != EOF && c != '\n');
-			return c;
-		} else if (c == '*') {
-			while (1) {
-				c = getchar_update_lineno();
-				if (c == EOF)
-					return EOF;
-				if (c == '*') {
-					do {
-						c = getchar_update_lineno();
-					} while (c == '*');
-					if (c == '/')
-						break;
-				}
-			}
-		} else {
-			xungetc();
-			return '/';
-		}
-	}
-}
-
-/*
- * Read and return a token.  Tokens are string or character literals
- * or else delimited by whitespace or by [(),{}].
- * The latter are all returned as single characters.
- */
-static char *
-read_token(void)
-{
-	int c, q;
-	char *buf;
-	unsigned int alc, off;
-	char* delims = "(),{}";
-
-	while (1) {
-		c = getchar_skipping_comments();
-		if (c == EOF)
-			return nil;
-		if (!xisspace(c))
-			break;
-	}
-	alc = 16;
-	buf = xmalloc(alc + 1);
-	off = 0;
-	if(c == '"' || c == '\'') {
-		q = c;
-		buf[off] = c;
-		++off;
-		while (1) {
-			if (off+2 >= alc) { // room for c and maybe next char
-				alc *= 2;
-				buf = xrealloc(buf, alc + 1);
-			}
-			c = getchar_no_eof();
-			buf[off] = c;
-			++off;
-			if(c == q)
-				break;
-			if(c == '\\') {
-				buf[off] = getchar_no_eof();
-				++off;
-			}
-		}
-	} else if (xstrrchr(delims, c) != nil) {
-		buf[off] = c;
-		++off;
-	} else {
-		while (1) {
-			if (off >= alc) {
-				alc *= 2;
-				buf = xrealloc(buf, alc + 1);
-			}
-			buf[off] = c;
-			++off;
-			c = getchar_skipping_comments();
-			if (c == EOF)
-				break;
-			if (xisspace(c) || xstrrchr(delims, c) != nil) {
-				if (c == '\n')
-					lineno--;
-				xungetc();
-				break;
-			}
-		}
-	}
-	buf[off] = '\0';
-	return buf;
-}
-
-/* Read a token, giving an error on EOF.  */
-static char *
-read_token_no_eof(void)
-{
-	char *token = read_token();
-	if (token == nil)
-		bad_eof();
-	return token;
-}
-
-/* Read the package clause, and return the package name.  */
-static char *
-read_package(void)
-{
-	char *token;
-
-	token = read_token_no_eof();
-	if (token == nil)
-		fatal("%s:%d: no token\n", file, lineno);
-	if (!streq(token, "package")) {
-		fatal("%s:%d: expected \"package\", got \"%s\"\n",
-			file, lineno, token);
-	}
-	return read_token_no_eof();
-}
-
-/* Read and copy preprocessor lines.  */
-static void
-read_preprocessor_lines(void)
-{
-	int first;
-	
-	first = 1;
-	while (1) {
-		int c;
-
-		do {
-			c = getchar_skipping_comments();
-		} while (xisspace(c));
-		if (c != '#') {
-			xungetc();
-			break;
-		}
-		if(first) {
-			first = 0;
-			xputchar('\n');
-		}
-		xputchar(c);
-		do {
-			c = getchar_update_lineno();
-			xputchar(c);
-		} while (c != '\n');
-	}
-}
-
-/*
- * Read a type in Go syntax and return a type in C syntax.  We only
- * permit basic types and pointers.
- */
-static char *
-read_type(void)
-{
-	char *p, *op, *q;
-	int pointer_count;
-	unsigned int len;
-
-	p = read_token_no_eof();
-	if (*p != '*' && !streq(p, "int") && !streq(p, "uint"))
-		return p;
-	op = p;
-	pointer_count = 0;
-	while (*p == '*') {
-		++pointer_count;
-		++p;
-	}
-	len = xstrlen(p);
-	q = xmalloc(len + 2 + pointer_count + 1);
-	xmemmove(q, p, len);
-
-	// Turn int/uint into intgo/uintgo.
-	if((len == 3 && xmemcmp(q, "int", 3) == 0) || (len == 4 && xmemcmp(q, "uint", 4) == 0)) {
-		q[len++] = 'g';
-		q[len++] = 'o';
-	}
-
-	while (pointer_count-- > 0)
-		q[len++] = '*';
-	
-	q[len] = '\0';
-	xfree(op);
-	return q;
-}
-
-/* Return the size of the given type. */
-static int
-type_size(char *p, int *rnd)
-{
-	int i;
-
-	if(p[xstrlen(p)-1] == '*') {
-		*rnd = type_table[Uintptr].rnd;
-		return type_table[Uintptr].size;
-	}
-
-	if(streq(p, "Iface"))
-		p = "Eface";
-
-	for(i=0; type_table[i].name; i++)
-		if(streq(type_table[i].name, p)) {
-			*rnd = type_table[i].rnd;
-			return type_table[i].size;
-		}
-	fatal("%s:%d: unknown type %s\n", file, lineno, p);
-	return 0;
-}
-
-/*
- * Read a list of parameters.  Each parameter is a name and a type.
- * The list ends with a ')'.  We have already read the '('.
- */
-static struct params *
-read_params(int *poffset)
-{
-	char *token;
-	struct params *ret, **pp, *p;
-	int offset, size, rnd;
-
-	ret = nil;
-	pp = &ret;
-	token = read_token_no_eof();
-	offset = 0;
-	if (!streq(token, ")")) {
-		while (1) {
-			p = xmalloc(sizeof(struct params));
-			p->name = token;
-			p->next = nil;
-			*pp = p;
-			pp = &p->next;
-
-			if(streq(token, "...")) {
-				p->type = xstrdup("");
-			} else {
-				p->type = read_type();
-				rnd = 0;
-				size = type_size(p->type, &rnd);
-				if(rnd > structround)
-					rnd = structround;
-				if(offset%rnd)
-					offset += rnd - offset%rnd;
-				offset += size;
-			}
-
-			token = read_token_no_eof();
-			if (!streq(token, ","))
-				break;
-			token = read_token_no_eof();
-		}
-	}
-	if (!streq(token, ")")) {
-		fatal("%s:%d: expected '('\n",
-			file, lineno);
-	}
-	if (poffset != nil)
-		*poffset = offset;
-	return ret;
-}
-
-/*
- * Read a function header.  This reads up to and including the initial
- * '{' character.  Returns 1 if it read a header, 0 at EOF.
- */
-static int
-read_func_header(char **name, struct params **params, int *paramwid, struct params **rets)
-{
-	int lastline;
-	char *token;
-
-	lastline = -1;
-	while (1) {
-		read_preprocessor_lines();
-		token = read_token();
-		if (token == nil)
-			return 0;
-		if (streq(token, "func")) {
-			if(lastline != -1)
-				bwritef(output, "\n");
-			break;
-		}
-		if (lastline != lineno) {
-			if (lastline == lineno-1)
-				bwritef(output, "\n");
-			else
-				bwritef(output, "\n#line %d \"%s\"\n", lineno, final_file);
-			lastline = lineno;
-		}
-		bwritef(output, "%s ", token);
-	}
-
-	*name = read_token_no_eof();
-
-	token = read_token();
-	if (token == nil || !streq(token, "(")) {
-		fatal("%s:%d: expected \"(\"\n",
-			file, lineno);
-	}
-	*params = read_params(paramwid);
-
-	token = read_token();
-	if (token == nil || !streq(token, "("))
-		*rets = nil;
-	else {
-		*rets = read_params(nil);
-		token = read_token();
-	}
-	if (token == nil || !streq(token, "{")) {
-		fatal("%s:%d: expected \"{\"\n",
-			file, lineno);
-	}
-	return 1;
-}
-
-/* Write out parameters.  */
-static void
-write_params(struct params *params, int *first)
-{
-	struct params *p;
-
-	for (p = params; p != nil; p = p->next) {
-		if (*first)
-			*first = 0;
-		else
-			bwritef(output, ", ");
-		bwritef(output, "%s %s", p->type, p->name);
-	}
-}
-
-/* Write a 6g function header.  */
-static void
-write_6g_func_header(char *package, char *name, struct params *params,
-		     int paramwid, struct params *rets)
-{
-	int first, n;
-	struct params *p;
-
-	bwritef(output, "void\n");
-	if(!contains(name, "·"))
-		bwritef(output, "%s·", package);
-	bwritef(output, "%s(", name);
-
-	first = 1;
-	write_params(params, &first);
-
-	/* insert padding to align output struct */
-	if(rets != nil && paramwid%structround != 0) {
-		n = structround - paramwid%structround;
-		if(n & 1)
-			bwritef(output, ", uint8");
-		if(n & 2)
-			bwritef(output, ", uint16");
-		if(n & 4)
-			bwritef(output, ", uint32");
-	}
-
-	write_params(rets, &first);
-	bwritef(output, ")\n{\n");
-	
-	for (p = rets; p != nil; p = p->next) {
-		if(streq(p->name, "..."))
-			continue;
-		if(streq(p->type, "Slice"))
-			bwritef(output, "\t%s.array = 0;\n\t%s.len = 0;\n\t%s.cap = 0;\n", p->name, p->name, p->name);
-		else if(streq(p->type, "String"))
-			bwritef(output, "\t%s.str = 0;\n\t%s.len = 0;\n", p->name, p->name);
-		else if(streq(p->type, "Eface"))
-			bwritef(output, "\t%s.type = 0;\n\t%s.data = 0;\n", p->name, p->name);
-		else if(streq(p->type, "Iface"))
-			bwritef(output, "\t%s.tab = 0;\n\t%s.data = 0;\n", p->name, p->name);
-		else if(streq(p->type, "Complex128"))
-			bwritef(output, "\t%s.real = 0;\n\t%s.imag = 0;\n", p->name, p->name);
-		else
-			bwritef(output, "\t%s = 0;\n", p->name);
-		bwritef(output, "\tFLUSH(&%s);\n", p->name);
-	}
-}
-
-/* Write a 6g function trailer.  */
-static void
-write_6g_func_trailer(struct params *rets)
-{
-	struct params *p;
-
-	for (p = rets; p != nil; p = p->next)
-		if(!streq(p->name, "..."))
-			bwritef(output, "\tFLUSH(&%s);\n", p->name);
-	bwritef(output, "}\n");
-}
-
-/* Define the gcc function return type if necessary.  */
-static void
-define_gcc_return_type(char *package, char *name, struct params *rets)
-{
-	struct params *p;
-
-	if (rets == nil || rets->next == nil)
-		return;
-	bwritef(output, "struct %s_%s_ret {\n", package, name);
-	for (p = rets; p != nil; p = p->next)
-		bwritef(output, "  %s %s;\n", p->type, p->name);
-	bwritef(output, "};\n");
-}
-
-/* Write out the gcc function return type.  */
-static void
-write_gcc_return_type(char *package, char *name, struct params *rets)
-{
-	if (rets == nil)
-		bwritef(output, "void");
-	else if (rets->next == nil)
-		bwritef(output, "%s", rets->type);
-	else
-		bwritef(output, "struct %s_%s_ret", package, name);
-}
-
-/* Write out a gcc function header.  */
-static void
-write_gcc_func_header(char *package, char *name, struct params *params,
-		      struct params *rets)
-{
-	int first;
-	struct params *p;
-
-	define_gcc_return_type(package, name, rets);
-	write_gcc_return_type(package, name, rets);
-	bwritef(output, " %s_%s(", package, name);
-	first = 1;
-	write_params(params, &first);
-	bwritef(output, ") asm (\"%s.%s\");\n", package, name);
-	write_gcc_return_type(package, name, rets);
-	bwritef(output, " %s_%s(", package, name);
-	first = 1;
-	write_params(params, &first);
-	bwritef(output, ")\n{\n");
-	for (p = rets; p != nil; p = p->next)
-		bwritef(output, "  %s %s;\n", p->type, p->name);
-}
-
-/* Write out a gcc function trailer.  */
-static void
-write_gcc_func_trailer(char *package, char *name, struct params *rets)
-{
-	if (rets == nil) {
-		// nothing to do
-	}
-	else if (rets->next == nil)
-		bwritef(output, "return %s;\n", rets->name);
-	else {
-		struct params *p;
-
-		bwritef(output, "  {\n    struct %s_%s_ret __ret;\n", package, name);
-		for (p = rets; p != nil; p = p->next)
-			bwritef(output, "    __ret.%s = %s;\n", p->name, p->name);
-		bwritef(output, "    return __ret;\n  }\n");
-	}
-	bwritef(output, "}\n");
-}
-
-/* Write out a function header.  */
-static void
-write_func_header(char *package, char *name,
-		  struct params *params, int paramwid,
-		  struct params *rets)
-{
-	if (gcc)
-		write_gcc_func_header(package, name, params, rets);
-	else
-		write_6g_func_header(package, name, params, paramwid, rets);
-	bwritef(output, "#line %d \"%s\"\n", lineno, final_file);
-}
-
-/* Write out a function trailer.  */
-static void
-write_func_trailer(char *package, char *name,
-		   struct params *rets)
-{
-	if (gcc)
-		write_gcc_func_trailer(package, name, rets);
-	else
-		write_6g_func_trailer(rets);
-}
-
-/*
- * Read and write the body of the function, ending in an unnested }
- * (which is read but not written).
- */
-static void
-copy_body(void)
-{
-	int nesting = 0;
-	while (1) {
-		int c;
-
-		c = getchar_no_eof();
-		if (c == '}' && nesting == 0)
-			return;
-		xputchar(c);
-		switch (c) {
-		default:
-			break;
-		case '{':
-			++nesting;
-			break;
-		case '}':
-			--nesting;
-			break;
-		case '/':
-			c = getchar_update_lineno();
-			xputchar(c);
-			if (c == '/') {
-				do {
-					c = getchar_no_eof();
-					xputchar(c);
-				} while (c != '\n');
-			} else if (c == '*') {
-				while (1) {
-					c = getchar_no_eof();
-					xputchar(c);
-					if (c == '*') {
-						do {
-							c = getchar_no_eof();
-							xputchar(c);
-						} while (c == '*');
-						if (c == '/')
-							break;
-					}
-				}
-			}
-			break;
-		case '"':
-		case '\'':
-			{
-				int delim = c;
-				do {
-					c = getchar_no_eof();
-					xputchar(c);
-					if (c == '\\') {
-						c = getchar_no_eof();
-						xputchar(c);
-						c = '\0';
-					}
-				} while (c != delim);
-			}
-			break;
-		}
-	}
-}
-
-/* Process the entire file.  */
-static void
-process_file(void)
-{
-	char *package, *name, *p, *n;
-	struct params *params, *rets;
-	int paramwid;
-
-	package = read_package();
-	read_preprocessor_lines();
-	while (read_func_header(&name, &params, &paramwid, &rets)) {
-		// name may have a package override already
-		n = xstrstr(name, "·");
-		if(n != nil) {
-			p = xmalloc(n - name + 1);
-			xmemmove(p, name, n - name);
-			p[n - name] = 0;
-			n += xstrlen("·");
-		} else {
-			p = package;
-			n = name;
-		}
-		write_func_header(p, n, params, paramwid, rets);
-		copy_body();
-		write_func_trailer(p, n, rets);
-		xfree(name);
-		if(p != package) xfree(p);
-		free_params(params);
-		free_params(rets);
-	}
-	xfree(package);
-}
-
-void
-goc2c(char *goc, char *goc_final, char *c)
-{
-	int i;
-	Buf in, out;
-	
-	binit(&in);
-	binit(&out);
-	
-	file = goc;
-	final_file = goc_final;
-	readfile(&in, goc);
-
-	// TODO: set gcc=1 when using gcc
-
-	if(!gcc) {
-		if(streq(goarch, "amd64")) {
-			type_table[Uintptr].size = 8;
-			if(use64bitint) {
-				type_table[Int].size = 8;
-			} else {
-				type_table[Int].size = 4;
-			}
-			structround = 8;
-		} else if(streq(goarch, "amd64p32")) {
-			type_table[Uintptr].size = 4;
-			type_table[Int].size = 4;
-			structround = 8;
-		} else {
-			// NOTE: These are set in the initializer,
-			// but they might have been changed by a
-			// previous invocation of goc2c, so we have
-			// to restore them.
-			type_table[Uintptr].size = 4;
-			type_table[Int].size = 4;
-			structround = 4;
-		}
-
-		type_table[Uint].size = type_table[Int].size;
-		type_table[Slice].size = type_table[Uintptr].size+2*type_table[Int].size;
-		type_table[Eface].size = 2*type_table[Uintptr].size;
-		type_table[String].size = 2*type_table[Uintptr].size;
-
-		for(i=0; i<nelem(type_table); i++)
-			type_table[i].rnd = type_table[i].size;
-
-		type_table[String].rnd = type_table[Uintptr].rnd;
-		type_table[Slice].rnd = type_table[Uintptr].rnd;
-		type_table[Eface].rnd = type_table[Uintptr].rnd;
-		type_table[Complex128].rnd = type_table[Float64].rnd;
-	}
-
-	bprintf(&out, "// auto generated by go tool dist\n// goos=%s goarch=%s\n\n", goos, goarch);
-	if(streq(goos, "linux")) {
-		bwritestr(&out, "// +build !android\n\n");
-	}
-	
-	input = bstr(&in);
-	output = &out;
-
-	lineno = 1;
-	process_file();
-	
-	writefile(&out, c, 0);
-}

From 2034dae94fe8d627c3f746b8a14b4b4c83aecaee Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 07:31:53 -0400
Subject: [PATCH 414/423] build: fix windows make.bat

The Unix make.bash builds cmd/dist from *.c.
make.bat apparently does not.

TBR=r
CC=golang-codereviews
https://golang.org/cl/137280043
---
 src/make.bat | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/make.bat b/src/make.bat
index a1a6c14a40..fff1eb6011 100644
--- a/src/make.bat
+++ b/src/make.bat
@@ -60,7 +60,7 @@ echo # Building C bootstrap tool.
 echo cmd/dist
 if not exist ..\bin\tool mkdir ..\bin\tool
 :: Windows has no glob expansion, so spell out cmd/dist/*.c.
-gcc -O2 -Wall -Werror -o cmd/dist/dist.exe -Icmd/dist %DEFGOROOT% cmd/dist/buf.c cmd/dist/build.c cmd/dist/buildgc.c cmd/dist/buildgo.c cmd/dist/buildruntime.c cmd/dist/goc2c.c cmd/dist/main.c cmd/dist/windows.c cmd/dist/arm.c
+gcc -O2 -Wall -Werror -o cmd/dist/dist.exe -Icmd/dist %DEFGOROOT% cmd/dist/buf.c cmd/dist/build.c cmd/dist/buildgc.c cmd/dist/buildgo.c cmd/dist/buildruntime.c cmd/dist/main.c cmd/dist/windows.c cmd/dist/arm.c
 if errorlevel 1 goto fail
 .\cmd\dist\dist env -wp >env.bat
 if errorlevel 1 goto fail

From fb818eab7fde33270bbbcf06d984af6db1c3eb0a Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 08:59:20 -0400
Subject: [PATCH 415/423] liblink: fix arm wrapper prologue

Fixes arm build.

TBR=khr
CC=golang-codereviews
https://golang.org/cl/132700043
---
 src/liblink/obj5.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/liblink/obj5.c b/src/liblink/obj5.c
index e8b81ec5ca..0b6b8deb5f 100644
--- a/src/liblink/obj5.c
+++ b/src/liblink/obj5.c
@@ -492,7 +492,7 @@ addstacksplit(Link *ctxt, LSym *cursym)
 				p = appendp(ctxt, p);
 				p->as = ACMP;
 				p->from.type = D_REG;
-				p->from.offset = 2;
+				p->from.reg = 2;
 				p->reg = 3;
 
 				p = appendp(ctxt, p);

From 2c14dbe458f77792e12b432423b4462da4f37d49 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 09:07:19 -0400
Subject: [PATCH 416/423] crypto/tls: print unexpected error in test

Maybe will help us understand Solaris build failure.

TBR=aram
CC=golang-codereviews
https://golang.org/cl/139290043
---
 src/pkg/crypto/tls/handshake_client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pkg/crypto/tls/handshake_client_test.go b/src/pkg/crypto/tls/handshake_client_test.go
index 432308b0a8..e5eaa7de20 100644
--- a/src/pkg/crypto/tls/handshake_client_test.go
+++ b/src/pkg/crypto/tls/handshake_client_test.go
@@ -205,7 +205,7 @@ func (test *clientTest) run(t *testing.T, write bool) {
 	if !write {
 		flows, err := test.loadData()
 		if err != nil {
-			t.Fatalf("%s: failed to load data from %s", test.name, test.dataPath())
+			t.Fatalf("%s: failed to load data from %s: %v", test.name, test.dataPath(), err)
 		}
 		for i, b := range flows {
 			if i%2 == 1 {

From b4bfa6c96415f4a578c1e100a515c2c62981b546 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 19:47:40 -0400
Subject: [PATCH 417/423] runtime: save g to TLS more aggressively

This is one of those "how did this ever work?" bugs.
The current build failures are happening because
a fault comes up while executing on m->curg on a
system-created thread using an m obtained from needm,
but TLS is set to m->g0, not m->curg. On fault,
sigtramp starts executing, assumes r10 (g) might be
incorrect, reloads it from TLS, and gets m->g0, not
m->curg. Then sighandler dutifully pushes a call to
sigpanic onto the stack and returns to it.
We're now executing on the m->curg stack but with
g=m->g0. Sigpanic does a stack split check, sees that
the SP is not in range (50% chance depending on relative
ordering of m->g0's and m->curg's stacks), and then
calls morestack. Morestack sees that g=m->g0 and
crashes the program.

The fix is to replace every change of g in asm_arm.s
with a call to a function that both updates g and
saves the updated g to TLS.

Why did it start happening? That's unclear.
Unfortunately there were other bugs in the initial
checkin that mask exactly which of a sequence of
CLs started the behavior where sigpanic would end
up tripping the stack split.

Fixes arm build.
Fixes #8675.

LGTM=iant
R=golang-codereviews, iant
CC=dave, golang-codereviews, khr, minux, r
https://golang.org/cl/135570043
---
 src/pkg/runtime/arch_arm.h |  2 +-
 src/pkg/runtime/asm_arm.s  | 73 ++++++++++++++++++++++++++------------
 src/pkg/runtime/tls_arm.s  |  7 ++--
 3 files changed, 57 insertions(+), 25 deletions(-)

diff --git a/src/pkg/runtime/arch_arm.h b/src/pkg/runtime/arch_arm.h
index 3868d78623..637a334a0b 100644
--- a/src/pkg/runtime/arch_arm.h
+++ b/src/pkg/runtime/arch_arm.h
@@ -6,7 +6,7 @@ enum {
 	thechar = '5',
 	BigEndian = 0,
 	CacheLineSize = 32,
-	RuntimeGogoBytes = 84,
+	RuntimeGogoBytes = 60,
 #ifdef GOOS_nacl
 	PhysPageSize = 65536,
 #else
diff --git a/src/pkg/runtime/asm_arm.s b/src/pkg/runtime/asm_arm.s
index 752ea08e57..3db907945c 100644
--- a/src/pkg/runtime/asm_arm.s
+++ b/src/pkg/runtime/asm_arm.s
@@ -129,11 +129,19 @@ TEXT runtime·gosave(SB),NOSPLIT,$-4-4
 // restore state from Gobuf; longjmp
 TEXT runtime·gogo(SB),NOSPLIT,$-4-4
 	MOVW	0(FP), R1		// gobuf
-	MOVW	gobuf_g(R1), g
-	MOVW	0(g), R2		// make sure g != nil
-	MOVB	runtime·iscgo(SB), R2
-	CMP 	$0, R2 // if in Cgo, we have to save g
-	BL.NE	runtime·save_g(SB) // this call will clobber R0
+	MOVW	gobuf_g(R1), R0
+	BL	setg<>(SB)
+
+	// NOTE: We updated g above, and we are about to update SP.
+	// Until LR and PC are also updated, the g/SP/LR/PC quadruple
+	// are out of sync and must not be used as the basis of a traceback.
+	// Sigprof skips the traceback when SP is not within g's bounds,
+	// and when the PC is inside this function, runtime.gogo.
+	// Since we are about to update SP, until we complete runtime.gogo
+	// we must not leave this function. In particular, no calls
+	// after this point: it must be straight-line code until the
+	// final B instruction.
+	// See large comment in sigprof for more details.
 	MOVW	gobuf_sp(R1), SP	// restore SP
 	MOVW	gobuf_lr(R1), LR
 	MOVW	gobuf_ret(R1), R0
@@ -143,8 +151,8 @@ TEXT runtime·gogo(SB),NOSPLIT,$-4-4
 	MOVW	R11, gobuf_ret(R1)
 	MOVW	R11, gobuf_lr(R1)
 	MOVW	R11, gobuf_ctxt(R1)
-	CMP	R11, R11 // set condition codes for == test, needed by stack split
 	MOVW	gobuf_pc(R1), R11
+	CMP	R11, R11 // set condition codes for == test, needed by stack split
 	B	(R11)
 
 // func mcall(fn func(*g))
@@ -162,7 +170,8 @@ TEXT runtime·mcall(SB),NOSPLIT,$-4-4
 	// Switch to m->g0 & its stack, call fn.
 	MOVW	g, R1
 	MOVW	g_m(g), R8
-	MOVW	m_g0(R8), g
+	MOVW	m_g0(R8), R0
+	BL	setg<>(SB)
 	CMP	g, R1
 	B.NE	2(PC)
 	B	runtime·badmcall(SB)
@@ -218,7 +227,10 @@ oncurg:
 	MOVW	g, (g_sched+gobuf_g)(g)
 
 	// switch to g0
-	MOVW	R2, g
+	MOVW	R0, R5
+	MOVW	R2, R0
+	BL	setg<>(SB)
+	MOVW	R5, R0
 	MOVW	(g_sched+gobuf_sp)(R2), R3
 	// make it look like mstart called onM on g0, to stop traceback
 	SUB	$4, R3, R3
@@ -234,7 +246,8 @@ oncurg:
 
 	// switch back to g
 	MOVW	g_m(g), R1
-	MOVW	m_curg(R1), g
+	MOVW	m_curg(R1), R0
+	BL	setg<>(SB)
 	MOVW	(g_sched+gobuf_sp)(g), SP
 	MOVW	$0, R3
 	MOVW	R3, (g_sched+gobuf_sp)(g)
@@ -293,7 +306,8 @@ TEXT runtime·morestack(SB),NOSPLIT,$-4-0
 	MOVW	g, (m_morebuf+gobuf_g)(R8)
 
 	// Call newstack on m->g0's stack.
-	MOVW	m_g0(R8), g
+	MOVW	m_g0(R8), R0
+	BL	setg<>(SB)
 	MOVW	(g_sched+gobuf_sp)(g), SP
 	BL	runtime·newstack(SB)
 
@@ -433,7 +447,8 @@ TEXT runtime·lessstack(SB),NOSPLIT,$-4-0
 	MOVW	R0, m_cret(R8)
 
 	// Call oldstack on m->g0's stack.
-	MOVW	m_g0(R8), g
+	MOVW	m_g0(R8), R0
+	BL	setg<>(SB)
 	MOVW	(g_sched+gobuf_sp)(g), SP
 	BL	runtime·oldstack(SB)
 
@@ -485,7 +500,7 @@ TEXT runtime·asmcgocall_errno(SB),NOSPLIT,$0-12
 TEXT asmcgocall<>(SB),NOSPLIT,$0-0
 	// fn in R1, arg in R0.
 	MOVW	R13, R2
-	MOVW	g, R5
+	MOVW	g, R4
 
 	// Figure out if we need to switch to m->g0 stack.
 	// We get called to create new OS threads too, and those
@@ -493,21 +508,27 @@ TEXT asmcgocall<>(SB),NOSPLIT,$0-0
 	MOVW	g_m(g), R8
 	MOVW	m_g0(R8), R3
 	CMP	R3, g
-	BEQ	4(PC)
+	BEQ	asmcgocall_g0
 	BL	gosave<>(SB)
-	MOVW	R3, g
+	MOVW	R0, R5
+	MOVW	R3, R0
+	BL	setg<>(SB)
+	MOVW	R5, R0
 	MOVW	(g_sched+gobuf_sp)(g), R13
 
 	// Now on a scheduling stack (a pthread-created stack).
+asmcgocall_g0:
 	SUB	$24, R13
 	BIC	$0x7, R13	// alignment for gcc ABI
-	MOVW	R5, 20(R13) // save old g
+	MOVW	R4, 20(R13) // save old g
 	MOVW	R2, 16(R13)	// save old SP
-	// R0 already contains the first argument
 	BL	(R1)
 
 	// Restore registers, g, stack pointer.
-	MOVW	20(R13), g
+	MOVW	R0, R5
+	MOVW	20(R13), R0
+	BL	setg<>(SB)
+	MOVW	R5, R0
 	MOVW	16(R13), R13
 	RET
 
@@ -572,7 +593,8 @@ havem:
 	// the earlier calls.
 	//
 	// In the new goroutine, -8(SP) and -4(SP) are unused.
-	MOVW	m_curg(R8), g
+	MOVW	m_curg(R8), R0
+	BL	setg<>(SB)
 	MOVW	(g_sched+gobuf_sp)(g), R4 // prepare stack as R4
 	MOVW	(g_sched+gobuf_pc)(g), R5
 	MOVW	R5, -12(R4)
@@ -589,7 +611,8 @@ havem:
 	// (Unlike m->curg, the g0 goroutine never uses sched.pc,
 	// so we do not have to restore it.)
 	MOVW	g_m(g), R8
-	MOVW	m_g0(R8), g
+	MOVW	m_g0(R8), R0
+	BL	setg<>(SB)
 	MOVW	(g_sched+gobuf_sp)(g), R13
 	MOVW	savedsp-8(SP), R4
 	MOVW	R4, (g_sched+gobuf_sp)(g)
@@ -606,14 +629,20 @@ havem:
 	RET
 
 // void setg(G*); set g. for use by needm.
-TEXT runtime·setg(SB),NOSPLIT,$0-4
-	MOVW	gg+0(FP), g
+TEXT runtime·setg(SB),NOSPLIT,$-4-4
+	MOVW	gg+0(FP), R0
+	B	setg<>(SB)
+
+TEXT setg<>(SB),NOSPLIT,$-4-0
+	MOVW	R0, g
 
 	// Save g to thread-local storage.
 	MOVB	runtime·iscgo(SB), R0
 	CMP	$0, R0
-	BL.NE	runtime·save_g(SB)
+	B.EQ	2(PC)
+	B	runtime·save_g(SB)
 
+	MOVW	g, R0
 	RET
 
 TEXT runtime·getcallerpc(SB),NOSPLIT,$-4-4
diff --git a/src/pkg/runtime/tls_arm.s b/src/pkg/runtime/tls_arm.s
index 1b1cbc9783..7a247ab195 100644
--- a/src/pkg/runtime/tls_arm.s
+++ b/src/pkg/runtime/tls_arm.s
@@ -22,12 +22,14 @@
 // ARM code that will overwrite those registers.
 // NOTE: runtime.gogo assumes that R1 is preserved by this function.
 //       runtime.mcall assumes this function only clobbers R0 and R11.
-TEXT runtime·save_g(SB),NOSPLIT,$0
+// Returns with g in R0.
+TEXT runtime·save_g(SB),NOSPLIT,$-4
 #ifdef GOOS_nacl
 	// nothing to do as nacl/arm does not use TLS at all.
+	MOVW	g, R0 // preserve R0 across call to setg<>
 	RET
 #endif
-	MRC		15, 0, R0, C13, C0, 3 // fetch TLS base pointer
+	MRC	15, 0, R0, C13, C0, 3 // fetch TLS base pointer
 	// $runtime.tlsg(SB) is a special linker symbol.
 	// It is the offset from the TLS base pointer to our
 	// thread-local storage for g.
@@ -38,6 +40,7 @@ TEXT runtime·save_g(SB),NOSPLIT,$0
 #endif
 	ADD	R11, R0
 	MOVW	g, 0(R0)
+	MOVW	g, R0 // preserve R0 across call to setg<>
 	RET
 
 // load_g loads the g register from pthread-provided

From 902f8d9ca036974a853ade8efdd609434a19bbbe Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 20:13:35 -0400
Subject: [PATCH 418/423] net/http/httptest: fix deadlock in TestIssue7264

I am seeing deadlocks waiting on <-inHandler.
It seems to me that there is no guarantee that the
handler actually runs, if the client does

        write header
        close connection

fast enough. The server might see the EOF on the
connection before it manages to invoke the handler.

This change fixes the deadlock, but it may make
the test not actually test anything. Not sure.

LGTM=bradfitz
R=bradfitz, dvyukov
CC=golang-codereviews
https://golang.org/cl/140970043
---
 src/pkg/net/http/httptest/server_test.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/pkg/net/http/httptest/server_test.go b/src/pkg/net/http/httptest/server_test.go
index 501cc8a999..a1c38c50ba 100644
--- a/src/pkg/net/http/httptest/server_test.go
+++ b/src/pkg/net/http/httptest/server_test.go
@@ -32,10 +32,7 @@ func TestServer(t *testing.T) {
 func TestIssue7264(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		func() {
-			inHandler := make(chan bool, 1)
-			ts := NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				inHandler <- true
-			}))
+			ts := NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
 			defer ts.Close()
 			tr := &http.Transport{
 				ResponseHeaderTimeout: time.Nanosecond,
@@ -43,7 +40,10 @@ func TestIssue7264(t *testing.T) {
 			defer tr.CloseIdleConnections()
 			c := &http.Client{Transport: tr}
 			res, err := c.Get(ts.URL)
-			<-inHandler
+			// err can be non-nil here.
+			// If the client writes the header and then immediately observes
+			// the timeout and closes the connection, the server might never
+			// have gotten a chance to send a response. That's okay.
 			if err == nil {
 				res.Body.Close()
 			}

From 71de7e7539a9d139daee6f4467ce73995b37b5a0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 23:16:12 -0400
Subject: [PATCH 419/423] runtime: fix
 semacquire->acquireSudog->malloc->gogc->semacquire loop

This is what broke the build at
http://build.golang.org/log/d9c6d334be16cbab85e99fddc6b4ba034319bd4e

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/135580043
---
 src/pkg/runtime/proc.go | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/pkg/runtime/proc.go b/src/pkg/runtime/proc.go
index a9cac266ba..48b8cbe394 100644
--- a/src/pkg/runtime/proc.go
+++ b/src/pkg/runtime/proc.go
@@ -75,7 +75,19 @@ func acquireSudog() *sudog {
 		c.sudogcache = s.next
 		return s
 	}
-	return new(sudog)
+
+	// Delicate dance: the semaphore implementation calls
+	// acquireSudog, acquireSudog calls new(sudog),
+	// new calls malloc, malloc can call the garbage collector,
+	// and the garbage collector calls the semaphore implementation
+	// in stoptheworld.
+	// Break the cycle by doing acquirem/releasem around new(sudog).
+	// The acquirem/releasem increments m.locks during new(sudog),
+	// which keeps the garbage collector from being invoked.
+	mp := acquirem()
+	p := new(sudog)
+	releasem(mp)
+	return p
 }
 
 //go:nosplit

From 50fc0f1af626c57acaae2eb63781a6d76d7de9f0 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 23:40:27 -0400
Subject: [PATCH 420/423] net/http/httptest: delete TestIssue7264

Now it's failing on Windows:

panic: httptest: failed to listen on a port: listen tcp 127.0.0.1:0:
listen: An operation on a socket could not be performed because the
system lacked sufficient buffer space or because a queue was full.

Since we can't seem to understand what the test is trying to test,
and because it is causing problems on multiple systems,
delete it.

Fixes #7264.

TBR=bradfitz
CC=brainman, golang-codereviews
https://golang.org/cl/141210043
---
 src/pkg/net/http/httptest/server_test.go | 23 -----------------------
 1 file changed, 23 deletions(-)

diff --git a/src/pkg/net/http/httptest/server_test.go b/src/pkg/net/http/httptest/server_test.go
index a1c38c50ba..500a9f0b80 100644
--- a/src/pkg/net/http/httptest/server_test.go
+++ b/src/pkg/net/http/httptest/server_test.go
@@ -8,7 +8,6 @@ import (
 	"io/ioutil"
 	"net/http"
 	"testing"
-	"time"
 )
 
 func TestServer(t *testing.T) {
@@ -28,25 +27,3 @@ func TestServer(t *testing.T) {
 		t.Errorf("got %q, want hello", string(got))
 	}
 }
-
-func TestIssue7264(t *testing.T) {
-	for i := 0; i < 1000; i++ {
-		func() {
-			ts := NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
-			defer ts.Close()
-			tr := &http.Transport{
-				ResponseHeaderTimeout: time.Nanosecond,
-			}
-			defer tr.CloseIdleConnections()
-			c := &http.Client{Transport: tr}
-			res, err := c.Get(ts.URL)
-			// err can be non-nil here.
-			// If the client writes the header and then immediately observes
-			// the timeout and closes the connection, the server might never
-			// have gotten a chance to send a response. That's okay.
-			if err == nil {
-				res.Body.Close()
-			}
-		}()
-	}
-}

From 13d0b82bc8821c41ec3782d0d5911cda2499dedc Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@golang.org>
Date: Sun, 7 Sep 2014 23:40:59 -0400
Subject: [PATCH 421/423] runtime: implement time.now in assembly on plan9,
 solaris, windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These all used a C implementation that contained 64-bit divide by 1000000000.
On 32-bit systems that ends up in the 64-bit C divide support, which makes
other calls and ends up using a fair amount of stack. We could convert them
to Go but then they'd still end up in software 64-bit divide code. That would
be okay, because Go code can split the stack, but it's still unnecessary.

Write time·now in assembly, just like on all the other systems, and use the
actual hardware support for 64/32 -> 64/32 division. This cuts the software
routines out entirely.

The actual code to do the division is copied and pasted from the sys_darwin_*.s files.

LGTM=alex.brainman
R=golang-codereviews, alex.brainman
CC=aram, golang-codereviews, iant, khr, r
https://golang.org/cl/136300043
---
 src/pkg/runtime/os_plan9.c          | 13 -------------
 src/pkg/runtime/os_solaris.c        | 13 -------------
 src/pkg/runtime/os_windows.c        | 23 +++++++----------------
 src/pkg/runtime/sys_darwin_amd64.s  |  2 +-
 src/pkg/runtime/sys_plan9_386.s     | 13 +++++++++++++
 src/pkg/runtime/sys_plan9_amd64.s   | 20 ++++++++++++++++++++
 src/pkg/runtime/sys_solaris_amd64.s | 20 ++++++++++++++++++++
 src/pkg/runtime/sys_windows_386.s   | 13 +++++++++++++
 src/pkg/runtime/sys_windows_amd64.s | 21 +++++++++++++++++++++
 9 files changed, 95 insertions(+), 43 deletions(-)

diff --git a/src/pkg/runtime/os_plan9.c b/src/pkg/runtime/os_plan9.c
index f824710793..853f3ef7a1 100644
--- a/src/pkg/runtime/os_plan9.c
+++ b/src/pkg/runtime/os_plan9.c
@@ -160,19 +160,6 @@ runtime·nanotime(void)
 	return ns;
 }
 
-#pragma textflag NOSPLIT
-void
-time·now(int64 sec, int32 nsec)
-{
-	int64 ns;
-
-	ns = runtime·nanotime();
-	sec = ns / 1000000000LL;
-	nsec = ns - sec * 1000000000LL;
-	FLUSH(&sec);
-	FLUSH(&nsec);
-}
-
 #pragma textflag NOSPLIT
 void
 runtime·itoa(int32 n, byte *p, uint32 len)
diff --git a/src/pkg/runtime/os_solaris.c b/src/pkg/runtime/os_solaris.c
index c6c2a8a7a1..e35d2b9971 100644
--- a/src/pkg/runtime/os_solaris.c
+++ b/src/pkg/runtime/os_solaris.c
@@ -436,19 +436,6 @@ runtime·nanotime(void)
 	return runtime·sysvicall0((uintptr)runtime·nanotime1);
 }
 
-#pragma textflag NOSPLIT
-void
-time·now(int64 sec, int32 usec)
-{
-	int64 ns;
-
-	ns = runtime·nanotime();
-	sec = ns / 1000000000LL;
-	usec = ns - sec * 1000000000LL;
-	FLUSH(&sec);
-	FLUSH(&usec);
-}
-
 #pragma textflag NOSPLIT
 int32
 runtime·open(int8* path, int32 oflag, int32 mode)
diff --git a/src/pkg/runtime/os_windows.c b/src/pkg/runtime/os_windows.c
index d7f7a5a3b4..a4d77f6b75 100644
--- a/src/pkg/runtime/os_windows.c
+++ b/src/pkg/runtime/os_windows.c
@@ -301,6 +301,13 @@ runtime·systime(KSYSTEM_TIME *timeaddr)
 	return 0;
 }
 
+#pragma textflag NOSPLIT
+int64
+runtime·unixnano(void)
+{
+	return (runtime·systime(SYSTEM_TIME) - 116444736000000000LL) * 100LL;
+}
+
 static void
 badsystime(void)
 {
@@ -314,22 +321,6 @@ runtime·nanotime(void)
 	return runtime·systime(INTERRUPT_TIME) * 100LL;
 }
 
-#pragma textflag NOSPLIT
-void
-time·now(int64 sec, int32 usec)
-{
-	int64 ns;
-
-	// SystemTime is 100s of nanoseconds since January 1, 1601.
-	// Convert to nanoseconds since January 1, 1970.
-	ns = (runtime·systime(SYSTEM_TIME) - 116444736000000000LL) * 100LL;
-
-	sec = ns / 1000000000LL;
-	usec = ns - sec * 1000000000LL;
-	FLUSH(&sec);
-	FLUSH(&usec);
-}
-
 // Calling stdcall on os stack.
 #pragma textflag NOSPLIT
 static void*
diff --git a/src/pkg/runtime/sys_darwin_amd64.s b/src/pkg/runtime/sys_darwin_amd64.s
index 2f98bfb06c..bd397d72a7 100644
--- a/src/pkg/runtime/sys_darwin_amd64.s
+++ b/src/pkg/runtime/sys_darwin_amd64.s
@@ -158,7 +158,7 @@ TEXT runtime·nanotime(SB),NOSPLIT,$0-8
 	RET
 
 // func now() (sec int64, nsec int32)
-TEXT time·now(SB),NOSPLIT,$8
+TEXT time·now(SB),NOSPLIT,$0-12
 	CALL	nanotime<>(SB)
 
 	// generated code for
diff --git a/src/pkg/runtime/sys_plan9_386.s b/src/pkg/runtime/sys_plan9_386.s
index dfa09613e4..7432981813 100644
--- a/src/pkg/runtime/sys_plan9_386.s
+++ b/src/pkg/runtime/sys_plan9_386.s
@@ -101,6 +101,19 @@ TEXT runtime·nsec(SB),NOSPLIT,$8
 	MOVL	$-1, ret_hi+8(FP)
 	RET
 
+// func now() (sec int64, nsec int32)
+TEXT time·now(SB),NOSPLIT,$8-12
+	CALL	runtime·nanotime(SB)
+	MOVL	0(SP), AX
+	MOVL	4(SP), DX
+
+	MOVL	$1000000000, CX
+	DIVL	CX
+	MOVL	AX, sec+0(FP)
+	MOVL	$0, sec+4(FP)
+	MOVL	DX, nsec+8(FP)
+	RET
+
 TEXT runtime·notify(SB),NOSPLIT,$0
 	MOVL	$28, AX
 	INT	$64
diff --git a/src/pkg/runtime/sys_plan9_amd64.s b/src/pkg/runtime/sys_plan9_amd64.s
index 08ddc3ffa8..954c0c27bb 100644
--- a/src/pkg/runtime/sys_plan9_amd64.s
+++ b/src/pkg/runtime/sys_plan9_amd64.s
@@ -91,6 +91,26 @@ TEXT runtime·nsec(SB),NOSPLIT,$0
 	MOVQ	AX, ret+8(FP)
 	RET
 
+// func now() (sec int64, nsec int32)
+TEXT time·now(SB),NOSPLIT,$8-12
+	CALL	runtime·nanotime(SB)
+	MOVQ	0(SP), AX
+
+	// generated code for
+	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
+	// adapted to reduce duplication
+	MOVQ	AX, CX
+	MOVQ	$1360296554856532783, AX
+	MULQ	CX
+	ADDQ	CX, DX
+	RCRQ	$1, DX
+	SHRQ	$29, DX
+	MOVQ	DX, sec+0(FP)
+	IMULQ	$1000000000, DX
+	SUBQ	DX, CX
+	MOVL	CX, nsec+8(FP)
+	RET
+
 TEXT runtime·notify(SB),NOSPLIT,$0
 	MOVQ	$28, BP
 	SYSCALL
diff --git a/src/pkg/runtime/sys_solaris_amd64.s b/src/pkg/runtime/sys_solaris_amd64.s
index 2055d6c80b..093315c4a4 100644
--- a/src/pkg/runtime/sys_solaris_amd64.s
+++ b/src/pkg/runtime/sys_solaris_amd64.s
@@ -327,3 +327,23 @@ TEXT runtime·osyield1(SB),NOSPLIT,$0
 	MOVQ	libc·sched_yield(SB), AX
 	CALL	AX
 	RET
+
+// func now() (sec int64, nsec int32)
+TEXT time·now(SB),NOSPLIT,$8-12
+	CALL	runtime·nanotime(SB)
+	MOVQ	0(SP), AX
+
+	// generated code for
+	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
+	// adapted to reduce duplication
+	MOVQ	AX, CX
+	MOVQ	$1360296554856532783, AX
+	MULQ	CX
+	ADDQ	CX, DX
+	RCRQ	$1, DX
+	SHRQ	$29, DX
+	MOVQ	DX, sec+0(FP)
+	IMULQ	$1000000000, DX
+	SUBQ	DX, CX
+	MOVL	CX, nsec+8(FP)
+	RET
diff --git a/src/pkg/runtime/sys_windows_386.s b/src/pkg/runtime/sys_windows_386.s
index f4d561feea..a9e096f018 100644
--- a/src/pkg/runtime/sys_windows_386.s
+++ b/src/pkg/runtime/sys_windows_386.s
@@ -365,3 +365,16 @@ TEXT runtime·usleep2(SB),NOSPLIT,$20
 	CALL	AX
 	MOVL	BP, SP
 	RET
+
+// func now() (sec int64, nsec int32)
+TEXT time·now(SB),NOSPLIT,$8-12
+	CALL	runtime·unixnano(SB)
+	MOVL	0(SP), AX
+	MOVL	4(SP), DX
+
+	MOVL	$1000000000, CX
+	DIVL	CX
+	MOVL	AX, sec+0(FP)
+	MOVL	$0, sec+4(FP)
+	MOVL	DX, nsec+8(FP)
+	RET
diff --git a/src/pkg/runtime/sys_windows_amd64.s b/src/pkg/runtime/sys_windows_amd64.s
index e5890e04ae..21f73daf09 100644
--- a/src/pkg/runtime/sys_windows_amd64.s
+++ b/src/pkg/runtime/sys_windows_amd64.s
@@ -384,3 +384,24 @@ TEXT runtime·usleep2(SB),NOSPLIT,$16
 	CALL	AX
 	MOVQ	8(SP), SP
 	RET
+
+// func now() (sec int64, nsec int32)
+TEXT time·now(SB),NOSPLIT,$8-12
+	CALL	runtime·unixnano(SB)
+	MOVQ	0(SP), AX
+
+	// generated code for
+	//	func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
+	// adapted to reduce duplication
+	MOVQ	AX, CX
+	MOVQ	$1360296554856532783, AX
+	MULQ	CX
+	ADDQ	CX, DX
+	RCRQ	$1, DX
+	SHRQ	$29, DX
+	MOVQ	DX, sec+0(FP)
+	IMULQ	$1000000000, DX
+	SUBQ	DX, CX
+	MOVL	CX, nsec+8(FP)
+	RET
+

From ae47e044a8c2f1a4cf21ba2b02eba7304c2d157d Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Sun, 7 Sep 2014 20:48:40 -0700
Subject: [PATCH 422/423] net/http: add Transport.DialTLS hook

Per discussions out of https://golang.org/cl/128930043/
and golang-nuts threads and with agl.

Fixes #8522

LGTM=agl, adg
R=agl, c, adg
CC=c, golang-codereviews
https://golang.org/cl/137940043
---
 src/pkg/net/http/transport.go      | 63 ++++++++++++++++++++----------
 src/pkg/net/http/transport_test.go | 40 +++++++++++++++++++
 2 files changed, 83 insertions(+), 20 deletions(-)

diff --git a/src/pkg/net/http/transport.go b/src/pkg/net/http/transport.go
index 7a229c1b71..527ed8bdd1 100644
--- a/src/pkg/net/http/transport.go
+++ b/src/pkg/net/http/transport.go
@@ -43,8 +43,8 @@ var DefaultTransport RoundTripper = &Transport{
 // MaxIdleConnsPerHost.
 const DefaultMaxIdleConnsPerHost = 2
 
-// Transport is an implementation of RoundTripper that supports http,
-// https, and http proxies (for either http or https with CONNECT).
+// Transport is an implementation of RoundTripper that supports HTTP,
+// HTTPS, and HTTP proxies (for either HTTP or HTTPS with CONNECT).
 // Transport can also cache connections for future re-use.
 type Transport struct {
 	idleMu      sync.Mutex
@@ -61,11 +61,22 @@ type Transport struct {
 	// If Proxy is nil or returns a nil *URL, no proxy is used.
 	Proxy func(*Request) (*url.URL, error)
 
-	// Dial specifies the dial function for creating TCP
-	// connections.
+	// Dial specifies the dial function for creating unencrypted
+	// TCP connections.
 	// If Dial is nil, net.Dial is used.
 	Dial func(network, addr string) (net.Conn, error)
 
+	// DialTLS specifies an optional dial function for creating
+	// TLS connections for non-proxied HTTPS requests.
+	//
+	// If DialTLS is nil, Dial and TLSClientConfig are used.
+	//
+	// If DialTLS is set, the Dial hook is not used for HTTPS
+	// requests and the TLSClientConfig and TLSHandshakeTimeout
+	// are ignored. The returned net.Conn is assumed to already be
+	// past the TLS handshake.
+	DialTLS func(network, addr string) (net.Conn, error)
+
 	// TLSClientConfig specifies the TLS configuration to use with
 	// tls.Client. If nil, the default configuration is used.
 	TLSClientConfig *tls.Config
@@ -504,44 +515,56 @@ func (t *Transport) getConn(req *Request, cm connectMethod) (*persistConn, error
 }
 
 func (t *Transport) dialConn(cm connectMethod) (*persistConn, error) {
-	conn, err := t.dial("tcp", cm.addr())
-	if err != nil {
-		if cm.proxyURL != nil {
-			err = fmt.Errorf("http: error connecting to proxy %s: %v", cm.proxyURL, err)
-		}
-		return nil, err
-	}
-
-	pa := cm.proxyAuth()
-
 	pconn := &persistConn{
 		t:          t,
 		cacheKey:   cm.key(),
-		conn:       conn,
 		reqch:      make(chan requestAndChan, 1),
 		writech:    make(chan writeRequest, 1),
 		closech:    make(chan struct{}),
 		writeErrCh: make(chan error, 1),
 	}
+	tlsDial := t.DialTLS != nil && cm.targetScheme == "https" && cm.proxyURL == nil
+	if tlsDial {
+		var err error
+		pconn.conn, err = t.DialTLS("tcp", cm.addr())
+		if err != nil {
+			return nil, err
+		}
+		if tc, ok := pconn.conn.(*tls.Conn); ok {
+			cs := tc.ConnectionState()
+			pconn.tlsState = &cs
+		}
+	} else {
+		conn, err := t.dial("tcp", cm.addr())
+		if err != nil {
+			if cm.proxyURL != nil {
+				err = fmt.Errorf("http: error connecting to proxy %s: %v", cm.proxyURL, err)
+			}
+			return nil, err
+		}
+		pconn.conn = conn
+	}
 
+	// Proxy setup.
 	switch {
 	case cm.proxyURL == nil:
-		// Do nothing.
+		// Do nothing. Not using a proxy.
 	case cm.targetScheme == "http":
 		pconn.isProxy = true
-		if pa != "" {
+		if pa := cm.proxyAuth(); pa != "" {
 			pconn.mutateHeaderFunc = func(h Header) {
 				h.Set("Proxy-Authorization", pa)
 			}
 		}
 	case cm.targetScheme == "https":
+		conn := pconn.conn
 		connectReq := &Request{
 			Method: "CONNECT",
 			URL:    &url.URL{Opaque: cm.targetAddr},
 			Host:   cm.targetAddr,
 			Header: make(Header),
 		}
-		if pa != "" {
+		if pa := cm.proxyAuth(); pa != "" {
 			connectReq.Header.Set("Proxy-Authorization", pa)
 		}
 		connectReq.Write(conn)
@@ -562,7 +585,7 @@ func (t *Transport) dialConn(cm connectMethod) (*persistConn, error) {
 		}
 	}
 
-	if cm.targetScheme == "https" {
+	if cm.targetScheme == "https" && !tlsDial {
 		// Initiate TLS and check remote host name against certificate.
 		cfg := t.TLSClientConfig
 		if cfg == nil || cfg.ServerName == "" {
@@ -575,7 +598,7 @@ func (t *Transport) dialConn(cm connectMethod) (*persistConn, error) {
 				cfg = &clone
 			}
 		}
-		plainConn := conn
+		plainConn := pconn.conn
 		tlsConn := tls.Client(plainConn, cfg)
 		errc := make(chan error, 2)
 		var timer *time.Timer // for canceling TLS handshake
diff --git a/src/pkg/net/http/transport_test.go b/src/pkg/net/http/transport_test.go
index b55d30ddf9..3460d690e3 100644
--- a/src/pkg/net/http/transport_test.go
+++ b/src/pkg/net/http/transport_test.go
@@ -2096,6 +2096,46 @@ func TestTransportClosesBodyOnError(t *testing.T) {
 	}
 }
 
+func TestTransportDialTLS(t *testing.T) {
+	var mu sync.Mutex // guards following
+	var gotReq, didDial bool
+
+	ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
+		mu.Lock()
+		gotReq = true
+		mu.Unlock()
+	}))
+	defer ts.Close()
+	tr := &Transport{
+		DialTLS: func(netw, addr string) (net.Conn, error) {
+			mu.Lock()
+			didDial = true
+			mu.Unlock()
+			c, err := tls.Dial(netw, addr, &tls.Config{
+				InsecureSkipVerify: true,
+			})
+			if err != nil {
+				return nil, err
+			}
+			return c, c.Handshake()
+		},
+	}
+	defer tr.CloseIdleConnections()
+	client := &Client{Transport: tr}
+	res, err := client.Get(ts.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	res.Body.Close()
+	mu.Lock()
+	if !gotReq {
+		t.Error("didn't get request")
+	}
+	if !didDial {
+		t.Error("didn't use dial hook")
+	}
+}
+
 func wantBody(res *http.Response, err error, want string) error {
 	if err != nil {
 		return err

From 36ca636fab865cb8d5d01927d274ed54153c4e73 Mon Sep 17 00:00:00 2001
From: Brad Fitzpatrick <bradfitz@golang.org>
Date: Sun, 7 Sep 2014 20:52:22 -0700
Subject: [PATCH 423/423] doc: add a few http items to go1.4.txt

CC=golang-codereviews
https://golang.org/cl/132670045
---
 doc/go1.4.txt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/doc/go1.4.txt b/doc/go1.4.txt
index 8cabeb4eb6..c5da7b72b6 100644
--- a/doc/go1.4.txt
+++ b/doc/go1.4.txt
@@ -17,6 +17,9 @@ crypto/tls: add support for ALPN (RFC 7301) (CL 108710046)
 crypto/tls: support programmatic selection of server certificates (CL 107400043)
 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)
 runtime: implement monotonic clocks on windows (CL 108700045)
 runtime/race: freebsd is supported (CL 107270043)