diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 8494a3f61b..78b7d6edf1 100644
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -423,6 +423,52 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 			" _Genqueue = 7;" +
 			" _Gcopystack = 8;" +
 			" _NSIG = 32;" +
+			" _FlagNoScan = iota;" +
+			" _FlagNoZero;" +
+			" _TinySize;" +
+			" _TinySizeClass;" +
+			" _MaxSmallSize;" +
+			" _PageShift;" +
+			" _PageSize;" +
+			" _PageMask;" +
+			" _BitsPerPointer;" +
+			" _BitsMask;" +
+			" _PointersPerByte;" +
+			" _MaxGCMask;" +
+			" _BitsDead;" +
+			" _BitsPointer;" +
+			" _MSpanInUse;" +
+			" _ConcurrentSweep;" +
+			" _KindBool;" +
+			" _KindInt;" +
+			" _KindInt8;" +
+			" _KindInt16;" +
+			" _KindInt32;" +
+			" _KindInt64;" +
+			" _KindUint;" +
+			" _KindUint8;" +
+			" _KindUint16;" +
+			" _KindUint32;" +
+			" _KindUint64;" +
+			" _KindUintptr;" +
+			" _KindFloat32;" +
+			" _KindFloat64;" +
+			" _KindComplex64;" +
+			" _KindComplex128;" +
+			" _KindArray;" +
+			" _KindChan;" +
+			" _KindFunc;" +
+			" _KindInterface;" +
+			" _KindMap;" +
+			" _KindPtr;" +
+			" _KindSlice;" +
+			" _KindString;" +
+			" _KindStruct;" +
+			" _KindUnsafePointer;" +
+			" _KindDirectIface;" +
+			" _KindGCProg;" +
+			" _KindNoPointers;" +
+			" _KindMask;" +
 			")"
 		f, err = parser.ParseFile(fset, filename, src, 0)
 		if err != nil {
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index 36efb5711c..1257d5b811 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -329,6 +329,8 @@ mkzsys(char *dir, char *file)
 
 static char *runtimedefs[] = {
 	"defs.c",
+	"malloc.c",
+	"mgc0.c",
 	"proc.c",
 	"parfor.c",
 };
@@ -337,8 +339,8 @@ static char *runtimedefs[] = {
 // which contains Go struct definitions equivalent to the C ones.
 // Mostly we just write the output of 6c -q to the file.
 // However, we run it on multiple files, so we have to delete
-// the duplicated definitions, and we don't care about the funcs
-// and consts, so we delete those too.
+// the duplicated definitions, and we don't care about the funcs,
+// so we delete those too.
 // 
 void
 mkzruntimedefs(char *dir, char *file)
diff --git a/src/runtime/arch_386.go b/src/runtime/arch_386.go
index 287b67e270..79d38c7ab1 100644
--- a/src/runtime/arch_386.go
+++ b/src/runtime/arch_386.go
@@ -4,9 +4,5 @@
 
 package runtime
 
-const (
-	cacheLineSize = 64
-)
-
 type uintreg uint32
 type intptr int32 // TODO(rsc): remove
diff --git a/src/runtime/arch_amd64.go b/src/runtime/arch_amd64.go
index fe60c70660..270cd7b957 100644
--- a/src/runtime/arch_amd64.go
+++ b/src/runtime/arch_amd64.go
@@ -4,9 +4,5 @@
 
 package runtime
 
-const (
-	cacheLineSize = 64
-)
-
 type uintreg uint64
 type intptr int64 // TODO(rsc): remove
diff --git a/src/runtime/arch_amd64p32.go b/src/runtime/arch_amd64p32.go
index 90766b404f..5c636aeab2 100644
--- a/src/runtime/arch_amd64p32.go
+++ b/src/runtime/arch_amd64p32.go
@@ -4,9 +4,5 @@
 
 package runtime
 
-const (
-	cacheLineSize = 64
-)
-
 type uintreg uint64
 type intptr int32 // TODO(rsc): remove
diff --git a/src/runtime/arch_arm.go b/src/runtime/arch_arm.go
index 23f2711f6d..79d38c7ab1 100644
--- a/src/runtime/arch_arm.go
+++ b/src/runtime/arch_arm.go
@@ -4,9 +4,5 @@
 
 package runtime
 
-const (
-	cacheLineSize = 32
-)
-
 type uintreg uint32
 type intptr int32 // TODO(rsc): remove
diff --git a/src/runtime/chan.go b/src/runtime/chan.go
index 226b824065..48925b2e3e 100644
--- a/src/runtime/chan.go
+++ b/src/runtime/chan.go
@@ -26,7 +26,7 @@ func makechan(t *chantype, size int64) *hchan {
 	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)) {
+	if size < 0 || int64(uintptr(size)) != size || (elem.size > 0 && uintptr(size) > (maxmem-hchanSize)/uintptr(elem.size)) {
 		panic("makechan: size out of range")
 	}
 
diff --git a/src/runtime/malloc.c b/src/runtime/malloc.c
index b56f42531e..e5c7e09592 100644
--- a/src/runtime/malloc.c
+++ b/src/runtime/malloc.c
@@ -102,9 +102,9 @@ uintptr runtime·sizeof_C_MStats = sizeof(MStats) - (NumSizeClasses - 61) * size
 
 #define MaxArena32 (2U<<30)
 
-// For use by Go.  It can't be a constant in Go, unfortunately,
-// because it depends on the OS.
-uintptr runtime·maxMem = MaxMem;
+// For use by Go. If it were a C enum it would be made available automatically,
+// but the value of MaxMem is too large for enum.
+uintptr runtime·maxmem = MaxMem;
 
 void
 runtime·mallocinit(void)
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index d6f1a1a4a2..7bb85057f4 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -11,49 +11,41 @@ import (
 const (
 	debugMalloc = false
 
-	flagNoScan = 1 << 0 // GC doesn't have to scan object
-	flagNoZero = 1 << 1 // don't zero memory
+	flagNoScan = _FlagNoScan
+	flagNoZero = _FlagNoZero
 
-	maxTinySize   = 16
-	tinySizeClass = 2
-	maxSmallSize  = 32 << 10
+	maxTinySize   = _TinySize
+	tinySizeClass = _TinySizeClass
+	maxSmallSize  = _MaxSmallSize
 
-	pageShift = 13
-	pageSize  = 1 << pageShift
-	pageMask  = pageSize - 1
+	pageShift = _PageShift
+	pageSize  = _PageSize
+	pageMask  = _PageMask
 
-	bitsPerPointer  = 2
-	bitsMask        = 1<<bitsPerPointer - 1
-	pointersPerByte = 8 / bitsPerPointer
-	bitPtrMask      = bitsMask << 2
-	maxGCMask       = 64
-	bitsDead        = 0
-	bitsPointer     = 2
+	bitsPerPointer  = _BitsPerPointer
+	bitsMask        = _BitsMask
+	pointersPerByte = _PointersPerByte
+	maxGCMask       = _MaxGCMask
+	bitsDead        = _BitsDead
+	bitsPointer     = _BitsPointer
 
-	bitBoundary = 1
-	bitMarked   = 2
-	bitMask     = bitBoundary | bitMarked
+	mSpanInUse = _MSpanInUse
 
-	mSpanInUse = 0
-
-	concurrentSweep = true
+	concurrentSweep = _ConcurrentSweep != 0
 )
 
 // Page number (address>>pageShift)
 type pageID uintptr
 
-// All zero-sized allocations return a pointer to this byte.
-var zeroObject byte
-
-// Maximum possible heap size.
-var maxMem uintptr
+// base address for all 0-byte allocations
+var zerobase uintptr
 
 // Allocate an object of size bytes.
 // Small objects are allocated from the per-P cache's free lists.
 // Large objects (> 32 kB) are allocated straight from the heap.
 func mallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 	if size == 0 {
-		return unsafe.Pointer(&zeroObject)
+		return unsafe.Pointer(&zerobase)
 	}
 	size0 := size
 
@@ -357,7 +349,7 @@ func newarray(typ *_type, n uintptr) unsafe.Pointer {
 	if typ.kind&kindNoPointers != 0 {
 		flags |= flagNoScan
 	}
-	if int(n) < 0 || (typ.size > 0 && n > maxMem/uintptr(typ.size)) {
+	if int(n) < 0 || (typ.size > 0 && n > maxmem/uintptr(typ.size)) {
 		panic("runtime: allocation size out of range")
 	}
 	return mallocgc(uintptr(typ.size)*n, typ, flags)
diff --git a/src/runtime/mgc0.c b/src/runtime/mgc0.c
index 30a8ea2c9c..eac6e704be 100644
--- a/src/runtime/mgc0.c
+++ b/src/runtime/mgc0.c
@@ -123,7 +123,7 @@ static FinBlock	*allfin;	// list of all blocks
 BitVector	runtime·gcdatamask;
 BitVector	runtime·gcbssmask;
 
-extern	Mutex	runtime·gclock;
+Mutex	runtime·gclock;
 
 static Workbuf* getempty(Workbuf*);
 static Workbuf* getfull(Workbuf*);
diff --git a/src/runtime/mgc0.go b/src/runtime/mgc0.go
index 130e8262ad..bd5ebab46e 100644
--- a/src/runtime/mgc0.go
+++ b/src/runtime/mgc0.go
@@ -69,18 +69,6 @@ func clearpools() {
 	}
 }
 
-// State of background sweep.
-// Protected by gclock.
-// Must match mgc0.c.
-var sweep struct {
-	g           *g
-	parked      bool
-	spanidx     uint32 // background sweeper position
-	nbgsweep    uint32
-	npausesweep uint32
-}
-
-var gclock mutex // also in mgc0.c
 func gosweepone() uintptr
 func gosweepdone() bool
 
diff --git a/src/runtime/mgc0.h b/src/runtime/mgc0.h
index 0daf7511b6..10f24d009f 100644
--- a/src/runtime/mgc0.h
+++ b/src/runtime/mgc0.h
@@ -68,9 +68,9 @@ enum {
 // there.  On a 64-bit system the off'th word in the arena is tracked by
 // 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 bitBoundary	((uintptr)1) // boundary of an object
-#define bitMarked	((uintptr)2) // marked object
-
-#define bitMask		((uintptr)bitBoundary|bitMarked)
-#define bitPtrMask	((uintptr)BitsMask<<2)
+enum {
+	bitBoundary = 1, // boundary of an object
+	bitMarked = 2, // marked object
+	bitMask = bitBoundary | bitMarked,
+	bitPtrMask = BitsMask<<2,
+};
diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index e0f63ddb90..4327ced914 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -22,5 +22,3 @@ 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/runtime/os_freebsd.go b/src/runtime/os_freebsd.go
index 96964f1e1e..59708049c8 100644
--- a/src/runtime/os_freebsd.go
+++ b/src/runtime/os_freebsd.go
@@ -15,5 +15,3 @@ func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, nds
 func getrlimit(kind int32, limit unsafe.Pointer) int32
 func raise(sig int32)
 func sys_umtx_op(addr unsafe.Pointer, mode int32, val uint32, ptr2, ts unsafe.Pointer) int32
-
-const stackSystem = 0
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index a6799cd414..41123ad570 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -15,5 +15,3 @@ func rtsigprocmask(sig int32, new, old unsafe.Pointer, size int32)
 func getrlimit(kind int32, limit unsafe.Pointer) int32
 func raise(sig int32)
 func sched_getaffinity(pid, len uintptr, buf *uintptr) int32
-
-const stackSystem = 0
diff --git a/src/runtime/os_nacl.go b/src/runtime/os_nacl.go
index a6c409c091..8dd43ff06f 100644
--- a/src/runtime/os_nacl.go
+++ b/src/runtime/os_nacl.go
@@ -23,8 +23,6 @@ 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
-
 func os_sigpipe() {
 	gothrow("too many writes on closed pipe")
 }
diff --git a/src/runtime/os_netbsd.go b/src/runtime/os_netbsd.go
index 8792f497e4..f000c5e9f6 100644
--- a/src/runtime/os_netbsd.go
+++ b/src/runtime/os_netbsd.go
@@ -18,5 +18,3 @@ 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/runtime/os_openbsd.go b/src/runtime/os_openbsd.go
index 19e2b45a15..a000f963e3 100644
--- a/src/runtime/os_openbsd.go
+++ b/src/runtime/os_openbsd.go
@@ -15,5 +15,3 @@ func raise(sig 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/runtime/os_plan9.go b/src/runtime/os_plan9.go
index c7b5bf7050..20e47bf42e 100644
--- a/src/runtime/os_plan9.go
+++ b/src/runtime/os_plan9.go
@@ -24,10 +24,6 @@ func setfpmasks()
 func tstart_plan9(newm *m)
 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
 
 func os_sigpipe() {
diff --git a/src/runtime/os_solaris.go b/src/runtime/os_solaris.go
index 3cffff3e29..ca13151204 100644
--- a/src/runtime/os_solaris.go
+++ b/src/runtime/os_solaris.go
@@ -98,5 +98,3 @@ 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/runtime/os_windows.go b/src/runtime/os_windows.go
index da4c736add..1528d2fd13 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -26,8 +26,6 @@ func netpollopen(fd uintptr, pd *pollDesc) int32
 func netpollclose(fd uintptr) int32
 func netpollarm(pd *pollDesc, mode int)
 
-const stackSystem = 512 * ptrSize
-
 func os_sigpipe() {
 	gothrow("too many writes on closed pipe")
 }
diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h
index abd53c4ba1..4aa9a963f5 100644
--- a/src/runtime/runtime.h
+++ b/src/runtime/runtime.h
@@ -697,7 +697,6 @@ enum
  * external data
  */
 extern	String	runtime·emptystring;
-extern	uintptr runtime·zerobase;
 extern	G**	runtime·allg;
 extern	Slice	runtime·allgs; // []*G
 extern	uintptr runtime·allglen;
diff --git a/src/runtime/sema.go b/src/runtime/sema.go
index 87ba5463b6..beacd67162 100644
--- a/src/runtime/sema.go
+++ b/src/runtime/sema.go
@@ -35,7 +35,7 @@ const semTabSize = 251
 
 var semtable [semTabSize]struct {
 	root semaRoot
-	pad  [cacheLineSize - unsafe.Sizeof(semaRoot{})]byte
+	pad  [_CacheLineSize - unsafe.Sizeof(semaRoot{})]byte
 }
 
 // Called from sync/net packages.
diff --git a/src/runtime/slice.go b/src/runtime/slice.go
index 3b88927c64..171087d7f6 100644
--- a/src/runtime/slice.go
+++ b/src/runtime/slice.go
@@ -22,11 +22,11 @@ func makeslice(t *slicetype, len64 int64, cap64 int64) sliceStruct {
 	// but since the cap is only being supplied implicitly, saying len is clearer.
 	// See issue 4085.
 	len := int(len64)
-	if len64 < 0 || int64(len) != len64 || t.elem.size > 0 && uintptr(len) > maxMem/uintptr(t.elem.size) {
+	if len64 < 0 || int64(len) != len64 || t.elem.size > 0 && uintptr(len) > maxmem/uintptr(t.elem.size) {
 		panic(errorString("makeslice: len out of range"))
 	}
 	cap := int(cap64)
-	if cap < len || int64(cap) != cap64 || t.elem.size > 0 && uintptr(cap) > maxMem/uintptr(t.elem.size) {
+	if cap < len || int64(cap) != cap64 || t.elem.size > 0 && uintptr(cap) > maxmem/uintptr(t.elem.size) {
 		panic(errorString("makeslice: cap out of range"))
 	}
 	p := newarray(t.elem, uintptr(cap))
@@ -42,7 +42,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct {
 	cap64 := int64(old.cap) + n
 	cap := int(cap64)
 
-	if int64(cap) != cap64 || cap < old.cap || t.elem.size > 0 && uintptr(cap) > maxMem/uintptr(t.elem.size) {
+	if int64(cap) != cap64 || cap < old.cap || t.elem.size > 0 && uintptr(cap) > maxmem/uintptr(t.elem.size) {
 		panic(errorString("growslice: cap out of range"))
 	}
 
@@ -72,7 +72,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct {
 		}
 	}
 
-	if uintptr(newcap) >= maxMem/uintptr(et.size) {
+	if uintptr(newcap) >= maxmem/uintptr(et.size) {
 		panic(errorString("growslice: cap out of range"))
 	}
 	lenmem := uintptr(old.len) * uintptr(et.size)
diff --git a/src/runtime/string.go b/src/runtime/string.go
index c84f673427..0809f89bc1 100644
--- a/src/runtime/string.go
+++ b/src/runtime/string.go
@@ -225,7 +225,7 @@ func rawbyteslice(size int) (b []byte) {
 
 // rawruneslice allocates a new rune slice. The rune slice is not zeroed.
 func rawruneslice(size int) (b []rune) {
-	if uintptr(size) > maxMem/4 {
+	if uintptr(size) > maxmem/4 {
 		gothrow("out of memory")
 	}
 	mem := goroundupsize(uintptr(size) * 4)
diff --git a/src/runtime/typekind.go b/src/runtime/typekind.go
index 5985536289..b64ec44f9e 100644
--- a/src/runtime/typekind.go
+++ b/src/runtime/typekind.go
@@ -5,37 +5,37 @@
 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
+	kindBool          = _KindBool
+	kindInt           = _KindInt
+	kindInt8          = _KindInt8
+	kindInt16         = _KindInt16
+	kindInt32         = _KindInt32
+	kindInt64         = _KindInt64
+	kindUint          = _KindUint
+	kindUint8         = _KindUint8
+	kindUint16        = _KindUint16
+	kindUint32        = _KindUint32
+	kindUint64        = _KindUint64
+	kindUintptr       = _KindUintptr
+	kindFloat32       = _KindFloat32
+	kindFloat64       = _KindFloat64
+	kindComplex64     = _KindComplex64
+	kindComplex128    = _KindComplex128
+	kindArray         = _KindArray
+	kindChan          = _KindChan
+	kindFunc          = _KindFunc
+	kindInterface     = _KindInterface
+	kindMap           = _KindMap
+	kindPtr           = _KindPtr
+	kindSlice         = _KindSlice
+	kindString        = _KindString
+	kindStruct        = _KindStruct
+	kindUnsafePointer = _KindUnsafePointer
 
-	kindDirectIface = 1 << 5
-	kindGCProg      = 1 << 6 // Type.gc points to GC program
-	kindNoPointers  = 1 << 7
-	kindMask        = (1 << 5) - 1
+	kindDirectIface = _KindDirectIface
+	kindGCProg      = _KindGCProg
+	kindNoPointers  = _KindNoPointers
+	kindMask        = _KindMask
 )
 
 // isDirectIface reports whether t is stored directly in an interface value.
diff --git a/src/runtime/typekind.h b/src/runtime/typekind.h
index 7c611e8ba6..e0fe177bb7 100644
--- a/src/runtime/typekind.h
+++ b/src/runtime/typekind.h
@@ -2,9 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// PtrSize vs sizeof(void*): This file is also included from src/cmd/ld/...
-// which defines PtrSize to be different from sizeof(void*) when crosscompiling.
-
 enum {
 	KindBool = 1,
 	KindInt,