diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go
index 18fb34a..d01de4a 100644
--- a/src/cmd/cgo/out.go
+++ b/src/cmd/cgo/out.go
@@ -174,7 +174,7 @@
 	fmt.Fprintf(fc, "void\n")
 	fmt.Fprintf(fc, "·%s(struct{uint8 x[%d];}p)\n", n.Mangle, argSize)
 	fmt.Fprintf(fc, "{\n")
-	fmt.Fprintf(fc, "\tcgocall(_cgo%s, &p);\n", n.Mangle)
+	fmt.Fprintf(fc, "\truntime·cgocall(_cgo%s, &p);\n", 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.
@@ -416,7 +416,7 @@
 		fmt.Fprintf(fc, "\nvoid\n")
 		fmt.Fprintf(fc, "_cgoexp_%s(void *a, int32 n)\n", exp.ExpName)
 		fmt.Fprintf(fc, "{\n")
-		fmt.Fprintf(fc, "\tcgocallback(·%s, a, n);\n", goname)
+		fmt.Fprintf(fc, "\truntime·cgocallback(·%s, a, n);\n", goname)
 		fmt.Fprintf(fc, "}\n")
 
 		// Calling a function with a receiver from C requires
@@ -603,22 +603,22 @@
 void
 ·_Cfunc_GoString(int8 *p, String s)
 {
-	s = gostring((byte*)p);
+	s = runtime·gostring((byte*)p);
 	FLUSH(&s);
 }
 
 void
 ·_Cfunc_GoStringN(int8 *p, int32 l, String s)
 {
-	s = gostringn((byte*)p, l);
+	s = runtime·gostringn((byte*)p, l);
 	FLUSH(&s);
 }
 
 void
 ·_Cfunc_CString(String s, int8 *p)
 {
-	p = cmalloc(s.len+1);
-	mcpy((byte*)p, s.str, s.len);
+	p = runtime·cmalloc(s.len+1);
+	runtime·mcpy((byte*)p, s.str, s.len);
 	p[s.len] = 0;
 	FLUSH(&p);
 }
diff --git a/src/cmd/gc/builtin.c.boot b/src/cmd/gc/builtin.c.boot
index 277f572..0435e16 100644
--- a/src/cmd/gc/builtin.c.boot
+++ b/src/cmd/gc/builtin.c.boot
@@ -1,6 +1,6 @@
 char *runtimeimport =
 	"package runtime\n"
-	"func \"\".mal (? int32) *any\n"
+	"func \"\".new (? int32) *any\n"
 	"func \"\".panicindex ()\n"
 	"func \"\".panicslice ()\n"
 	"func \"\".throwreturn ()\n"
@@ -19,7 +19,7 @@
 	"func \"\".printslice (? any)\n"
 	"func \"\".printnl ()\n"
 	"func \"\".printsp ()\n"
-	"func \"\".printf ()\n"
+	"func \"\".goprintf ()\n"
 	"func \"\".concatstring ()\n"
 	"func \"\".append ()\n"
 	"func \"\".appendslice (typ *uint8, x any, y []any) any\n"
diff --git a/src/cmd/gc/runtime.go b/src/cmd/gc/runtime.go
index ab14341..a35ef9f 100644
--- a/src/cmd/gc/runtime.go
+++ b/src/cmd/gc/runtime.go
@@ -10,7 +10,7 @@
 
 // emitted by compiler, not referred to by go programs
 
-func mal(int32) *any
+func new(int32) *any
 func panicindex()
 func panicslice()
 func throwreturn()
@@ -31,7 +31,7 @@
 func printslice(any)
 func printnl()
 func printsp()
-func printf()
+func goprintf()
 
 // filled in by compiler: int n, string, string, ...
 func concatstring()
diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index 8824ba6..68c5e84 100644
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -1862,7 +1862,7 @@
 	if(defer) {
 		if(op == OPRINTN)
 			fmtprint(&fmt, "\n");
-		on = syslook("printf", 1);
+		on = syslook("goprintf", 1);
 		on->type = functype(nil, intypes, nil);
 		args->n = nod(OLITERAL, N, N);
 		args->n->val.ctype = CTSTR;
@@ -1891,7 +1891,7 @@
 	Node *fn;
 
 	dowidth(t);
-	fn = syslook("mal", 1);
+	fn = syslook("new", 1);
 	argtype(fn, t);
 	return mkcall1(fn, ptrto(t), nil, nodintconst(t->width));
 }
diff --git a/src/pkg/runtime/386/asm.s b/src/pkg/runtime/386/asm.s
index bf4c97b..deb7b12 100644
--- a/src/pkg/runtime/386/asm.s
+++ b/src/pkg/runtime/386/asm.s
@@ -23,23 +23,23 @@
 	JMP	ok
 
 	// set up %gs
-	CALL	ldt0setup(SB)
+	CALL	runtime·ldt0setup(SB)
 
 	// store through it, to make sure it works
-	CMPL	isplan9(SB), $1
+	CMPL	runtime·isplan9(SB), $1
 	JEQ	ok
 	get_tls(BX)
 	MOVL	$0x123, g(BX)
-	MOVL	tls0(SB), AX
+	MOVL	runtime·tls0(SB), AX
 	CMPL	AX, $0x123
 	JEQ	ok
 	MOVL	AX, 0	// abort
 ok:
 	// set up m and g "registers"
 	get_tls(BX)
-	LEAL	g0(SB), CX
+	LEAL	runtime·g0(SB), CX
 	MOVL	CX, g(BX)
-	LEAL	m0(SB), AX
+	LEAL	runtime·m0(SB), AX
 	MOVL	AX, m(BX)
 
 	// save m->g0 = g0
@@ -49,46 +49,46 @@
 	LEAL	(-8192+104)(SP), AX	// TODO: 104?
 	MOVL	AX, g_stackguard(CX)
 	MOVL	SP, g_stackbase(CX)
-	CALL	emptyfunc(SB)	// fault if stack check is wrong
+	CALL	runtime·emptyfunc(SB)	// fault if stack check is wrong
 
 	// convention is D is always cleared
 	CLD
 
-	CALL	check(SB)
+	CALL	runtime·check(SB)
 
 	// saved argc, argv
 	MOVL	120(SP), AX
 	MOVL	AX, 0(SP)
 	MOVL	124(SP), AX
 	MOVL	AX, 4(SP)
-	CALL	args(SB)
-	CALL	osinit(SB)
-	CALL	schedinit(SB)
+	CALL	runtime·args(SB)
+	CALL	runtime·osinit(SB)
+	CALL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
-	PUSHL	$mainstart(SB)	// entry
+	PUSHL	$runtime·mainstart(SB)	// entry
 	PUSHL	$0	// arg size
-	CALL	·newproc(SB)
+	CALL	runtime·newproc(SB)
 	POPL	AX
 	POPL	AX
 
 	// start this M
-	CALL	mstart(SB)
+	CALL	runtime·mstart(SB)
 
 	INT $3
 	RET
 
-TEXT mainstart(SB),7,$0
+TEXT runtime·mainstart(SB),7,$0
 	CALL	main·init(SB)
-	CALL	initdone(SB)
+	CALL	runtime·initdone(SB)
 	CALL	main·main(SB)
 	PUSHL	$0
-	CALL	exit(SB)
+	CALL	runtime·exit(SB)
 	POPL	AX
 	INT $3
 	RET
 
-TEXT	breakpoint(SB),7,$0
+TEXT runtime·breakpoint(SB),7,$0
 	INT $3
 	RET
 
@@ -98,7 +98,7 @@
 
 // uintptr gosave(Gobuf*)
 // save state in Gobuf; setjmp
-TEXT gosave(SB), 7, $0
+TEXT runtime·gosave(SB), 7, $0
 	MOVL	4(SP), AX		// gobuf
 	LEAL	4(SP), BX		// caller's SP
 	MOVL	BX, gobuf_sp(AX)
@@ -112,7 +112,7 @@
 
 // void gogo(Gobuf*, uintptr)
 // restore state from Gobuf; longjmp
-TEXT gogo(SB), 7, $0
+TEXT runtime·gogo(SB), 7, $0
 	MOVL	8(SP), AX		// return 2nd arg
 	MOVL	4(SP), BX		// gobuf
 	MOVL	gobuf_g(BX), DX
@@ -126,7 +126,7 @@
 // void gogocall(Gobuf*, void (*fn)(void))
 // restore state from Gobuf but then call fn.
 // (call fn, returning to state in Gobuf)
-TEXT gogocall(SB), 7, $0
+TEXT runtime·gogocall(SB), 7, $0
 	MOVL	8(SP), AX		// fn
 	MOVL	4(SP), BX		// gobuf
 	MOVL	gobuf_g(BX), DX
@@ -144,7 +144,7 @@
  */
 
 // Called during function prolog when more stack is needed.
-TEXT ·morestack(SB),7,$0
+TEXT runtime·morestack(SB),7,$0
 	// Cannot grow scheduler stack (m->g0).
 	get_tls(CX)
 	MOVL	m(CX), BX
@@ -178,7 +178,7 @@
 	MOVL	m_g0(BX), BP
 	MOVL	BP, g(CX)
 	MOVL	(m_sched+gobuf_sp)(BX), SP
-	CALL	newstack(SB)
+	CALL	runtime·newstack(SB)
 	MOVL	$0, 0x1003	// crash if newstack returns
 	RET
 
@@ -220,13 +220,13 @@
 	get_tls(CX)
 	MOVL	BP, g(CX)
 	MOVL	(m_sched+gobuf_sp)(BX), SP
-	CALL	newstack(SB)
+	CALL	runtime·newstack(SB)
 	MOVL	$0, 0x1103	// crash if newstack returns
 	RET
 
 
 // Return point when leaving stack.
-TEXT ·lessstack(SB), 7, $0
+TEXT runtime·lessstack(SB), 7, $0
 	// Save return value in m->cret
 	get_tls(CX)
 	MOVL	m(CX), BX
@@ -236,7 +236,7 @@
 	MOVL	m_g0(BX), DX
 	MOVL	DX, g(CX)
 	MOVL	(m_sched+gobuf_sp)(BX), SP
-	CALL	oldstack(SB)
+	CALL	runtime·oldstack(SB)
 	MOVL	$0, 0x1004	// crash if oldstack returns
 	RET
 
@@ -248,7 +248,7 @@
 //		return 1;
 //	}else
 //		return 0;
-TEXT cas(SB), 7, $0
+TEXT runtime·cas(SB), 7, $0
 	MOVL	4(SP), BX
 	MOVL	8(SP), AX
 	MOVL	12(SP), CX
@@ -267,7 +267,7 @@
 //		return 1;
 //	}else
 //		return 0;
-TEXT casp(SB), 7, $0
+TEXT runtime·casp(SB), 7, $0
 	MOVL	4(SP), BX
 	MOVL	8(SP), AX
 	MOVL	12(SP), CX
@@ -284,14 +284,14 @@
 // 1. pop the caller
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
-TEXT jmpdefer(SB), 7, $0
+TEXT runtime·jmpdefer(SB), 7, $0
 	MOVL	4(SP), AX	// fn
 	MOVL	8(SP), BX	// caller sp
 	LEAL	-4(BX), SP	// caller sp after CALL
 	SUBL	$5, (SP)	// return to CALL again
 	JMP	AX	// but first run the deferred function
 
-TEXT	·memclr(SB),7,$0
+TEXT runtime·memclr(SB),7,$0
 	MOVL	4(SP), DI		// arg 1 addr
 	MOVL	8(SP), CX		// arg 2 count
 	ADDL	$3, CX
@@ -302,42 +302,42 @@
 	STOSL
 	RET
 
-TEXT	·getcallerpc+0(SB),7,$0
+TEXT runtime·getcallerpc(SB),7,$0
 	MOVL	x+0(FP),AX		// addr of first arg
 	MOVL	-4(AX),AX		// get calling pc
 	RET
 
-TEXT	·setcallerpc+0(SB),7,$0
+TEXT runtime·setcallerpc(SB),7,$0
 	MOVL	x+0(FP),AX		// addr of first arg
 	MOVL	x+4(FP), BX
 	MOVL	BX, -4(AX)		// set calling pc
 	RET
 
-TEXT getcallersp(SB), 7, $0
+TEXT runtime·getcallersp(SB), 7, $0
 	MOVL	sp+0(FP), AX
 	RET
 
-TEXT ldt0setup(SB),7,$16
+TEXT runtime·ldt0setup(SB),7,$16
 	// 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.
 	// the entry number is just a hint.  setldt will set up GS with what it used.
 	MOVL	$7, 0(SP)
-	LEAL	tls0(SB), AX
+	LEAL	runtime·tls0(SB), AX
 	MOVL	AX, 4(SP)
 	MOVL	$32, 8(SP)	// sizeof(tls array)
-	CALL	setldt(SB)
+	CALL	runtime·setldt(SB)
 	RET
 
-TEXT emptyfunc(SB),0,$0
+TEXT runtime·emptyfunc(SB),0,$0
 	RET
 
-TEXT	abort(SB),7,$0
+TEXT runtime·abort(SB),7,$0
 	INT $0x3
 
 // runcgo(void(*fn)(void*), void *arg)
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
-TEXT	runcgo(SB),7,$16
+TEXT runtime·runcgo(SB),7,$16
 	MOVL	fn+0(FP), AX
 	MOVL	arg+4(FP), BX
 	MOVL	SP, CX
@@ -372,7 +372,7 @@
 // runcgocallback(G *g1, void* sp, void (*fn)(void))
 // Switch to g1 and sp, call fn, switch back.  fn's arguments are on
 // the new stack.
-TEXT	runcgocallback(SB),7,$32
+TEXT runtime·runcgocallback(SB),7,$32
 	MOVL	g1+0(FP), DX
 	MOVL	sp+4(FP), AX
 	MOVL	fn+8(FP), BX
@@ -401,7 +401,7 @@
 	RET
 
 // check that SP is in range [g->stackbase, g->stackguard)
-TEXT stackcheck(SB), 7, $0
+TEXT runtime·stackcheck(SB), 7, $0
 	get_tls(CX)
 	MOVL	g(CX), AX
 	CMPL	g_stackbase(AX), SP
@@ -412,7 +412,4 @@
 	INT	$3
 	RET
 
-GLOBL m0(SB), $1024
-GLOBL g0(SB), $1024
-GLOBL tls0(SB), $32
-GLOBL initcgo(SB), $4
+GLOBL runtime·tls0(SB), $32
diff --git a/src/pkg/runtime/386/closure.c b/src/pkg/runtime/386/closure.c
index 9f639c4..8ecb021 100644
--- a/src/pkg/runtime/386/closure.c
+++ b/src/pkg/runtime/386/closure.c
@@ -9,23 +9,23 @@
 //	fn func(arg0, arg1, arg2 *ptr, callerpc uintptr, xxx) yyy,
 //	arg0, arg1, arg2 *ptr) (func(xxx) yyy)
 void
-·closure(int32 siz, byte *fn, byte *arg0)
+runtime·closure(int32 siz, byte *fn, byte *arg0)
 {
 	byte *p, *q, **ret;
 	int32 i, n;
 	int32 pcrel;
 
-	if(goos != nil && strcmp((uint8*)goos, (uint8*)"nacl") == 0)
-		throw("no closures in native client yet");
+	if(runtime·goos != nil && runtime·strcmp((uint8*)runtime·goos, (uint8*)"nacl") == 0)
+		runtime·throw("no closures in native client yet");
 
 	if(siz < 0 || siz%4 != 0)
-		throw("bad closure size");
+		runtime·throw("bad closure size");
 
 	ret = (byte**)((byte*)&arg0 + siz);
 
 	if(siz > 100) {
 		// TODO(rsc): implement stack growth preamble?
-		throw("closure too big");
+		runtime·throw("closure too big");
 	}
 
 	// compute size of new fn.
@@ -43,12 +43,12 @@
 	if(n%4)
 		n += 4 - n%4;
 
-	p = mal(n);
+	p = runtime·mal(n);
 	*ret = p;
 	q = p + n - siz;
 
 	if(siz > 0) {
-		mcpy(q, (byte*)&arg0, siz);
+		runtime·mcpy(q, (byte*)&arg0, siz);
 
 		// SUBL $siz, SP
 		*p++ = 0x81;
@@ -104,7 +104,5 @@
 	*p++ = 0xc3;
 
 	if(p > q)
-		throw("bad math in sys.closure");
+		runtime·throw("bad math in sys.closure");
 }
-
-
diff --git a/src/pkg/runtime/386/memmove.s b/src/pkg/runtime/386/memmove.s
index 8adb687..38a0652 100644
--- a/src/pkg/runtime/386/memmove.s
+++ b/src/pkg/runtime/386/memmove.s
@@ -23,8 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-	TEXT	memmove(SB), 7, $0
-
+TEXT runtime·memmove(SB), 7, $0
 	MOVL	to+0(FP), DI
 	MOVL	fr+4(FP), SI
 	MOVL	n+8(FP), BX
diff --git a/src/pkg/runtime/386/vlop.s b/src/pkg/runtime/386/vlop.s
index 803276c..28f6da8 100644
--- a/src/pkg/runtime/386/vlop.s
+++ b/src/pkg/runtime/386/vlop.s
@@ -27,7 +27,7 @@
  * C runtime for 64-bit divide.
  */
 
-TEXT	_mul64by32(SB), 7, $0
+TEXT _mul64by32(SB), 7, $0
 	MOVL	r+0(FP), CX
 	MOVL	a+4(FP), AX
 	MULL	b+12(FP)
@@ -39,7 +39,7 @@
 	MOVL	BX, 4(CX)
 	RET
 
-TEXT	_div64by32(SB), 7, $0
+TEXT _div64by32(SB), 7, $0
 	MOVL	r+12(FP), CX
 	MOVL	a+0(FP), AX
 	MOVL	a+4(FP), DX
diff --git a/src/pkg/runtime/386/vlrt.c b/src/pkg/runtime/386/vlrt.c
index 10417f5..1631dbe 100644
--- a/src/pkg/runtime/386/vlrt.c
+++ b/src/pkg/runtime/386/vlrt.c
@@ -59,7 +59,7 @@
 	};
 };
 
-void	abort(void);
+void	runtime·abort(void);
 
 void
 _d2v(Vlong *y, double d)
@@ -270,7 +270,7 @@
 }
 
 void
-·uint64div(Vlong n, Vlong d, Vlong q)
+runtime·uint64div(Vlong n, Vlong d, Vlong q)
 {
 	_divvu(&q, n, d);
 }
@@ -288,7 +288,7 @@
 }
 
 void
-·uint64mod(Vlong n, Vlong d, Vlong q)
+runtime·uint64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modvu(&q, n, d);
 }
@@ -334,7 +334,7 @@
 }
 
 void
-·int64div(Vlong n, Vlong d, Vlong q)
+runtime·int64div(Vlong n, Vlong d, Vlong q)
 {
 	_divv(&q, n, d);
 }
@@ -368,7 +368,7 @@
 }
 
 void
-·int64mod(Vlong n, Vlong d, Vlong q)
+runtime·int64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modv(&q, n, d);
 }
@@ -522,7 +522,7 @@
 	u.hi = 0;
 	switch(type) {
 	default:
-		abort();
+		runtime·abort();
 		break;
 
 	case 1:	/* schar */
diff --git a/src/pkg/runtime/amd64/asm.s b/src/pkg/runtime/amd64/asm.s
index fd3f347..235f272 100644
--- a/src/pkg/runtime/amd64/asm.s
+++ b/src/pkg/runtime/amd64/asm.s
@@ -4,7 +4,7 @@
 
 #include "amd64/asm.h"
 
-TEXT	_rt0_amd64(SB),7,$-8
+TEXT _rt0_amd64(SB),7,$-8
 	// copy arguments forward on an even stack
 	MOVQ	0(DI), AX		// argc
 	LEAQ	8(DI), BX		// argv
@@ -21,22 +21,22 @@
 	JMP ok
 
 needtls:
-	LEAQ	tls0(SB), DI
-	CALL	settls(SB)
+	LEAQ	runtime·tls0(SB), DI
+	CALL	runtime·settls(SB)
 
 	// store through it, to make sure it works
 	get_tls(BX)
 	MOVQ	$0x123, g(BX)
-	MOVQ	tls0(SB), AX
+	MOVQ	runtime·tls0(SB), AX
 	CMPQ	AX, $0x123
 	JEQ 2(PC)
 	MOVL	AX, 0	// abort
 ok:
 	// set the per-goroutine and per-mach "registers"
 	get_tls(BX)
-	LEAQ	g0(SB), CX
+	LEAQ	runtime·g0(SB), CX
 	MOVQ	CX, g(BX)
-	LEAQ	m0(SB), AX
+	LEAQ	runtime·m0(SB), AX
 	MOVQ	AX, m(BX)
 
 	// save m->g0 = g0
@@ -48,40 +48,40 @@
 	MOVQ	SP, g_stackbase(CX)
 
 	CLD				// convention is D is always left cleared
-	CALL	check(SB)
+	CALL	runtime·check(SB)
 
 	MOVL	16(SP), AX		// copy argc
 	MOVL	AX, 0(SP)
 	MOVQ	24(SP), AX		// copy argv
 	MOVQ	AX, 8(SP)
-	CALL	args(SB)
-	CALL	osinit(SB)
-	CALL	schedinit(SB)
+	CALL	runtime·args(SB)
+	CALL	runtime·osinit(SB)
+	CALL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
-	PUSHQ	$mainstart(SB)		// entry
+	PUSHQ	$runtime·mainstart(SB)		// entry
 	PUSHQ	$0			// arg size
-	CALL	·newproc(SB)
+	CALL	runtime·newproc(SB)
 	POPQ	AX
 	POPQ	AX
 
 	// start this M
-	CALL	mstart(SB)
+	CALL	runtime·mstart(SB)
 
-	CALL	notok(SB)		// never returns
+	CALL	runtime·notok(SB)		// never returns
 	RET
 
-TEXT mainstart(SB),7,$0
+TEXT runtime·mainstart(SB),7,$0
 	CALL	main·init(SB)
-	CALL	initdone(SB)
+	CALL	runtime·initdone(SB)
 	CALL	main·main(SB)
 	PUSHQ	$0
-	CALL	exit(SB)
+	CALL	runtime·exit(SB)
 	POPQ	AX
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	breakpoint(SB),7,$0
+TEXT runtime·breakpoint(SB),7,$0
 	BYTE	$0xcc
 	RET
 
@@ -91,7 +91,7 @@
 
 // uintptr gosave(Gobuf*)
 // save state in Gobuf; setjmp
-TEXT gosave(SB), 7, $0
+TEXT runtime·gosave(SB), 7, $0
 	MOVQ	8(SP), AX		// gobuf
 	LEAQ	8(SP), BX		// caller's SP
 	MOVQ	BX, gobuf_sp(AX)
@@ -105,7 +105,7 @@
 
 // void gogo(Gobuf*, uintptr)
 // restore state from Gobuf; longjmp
-TEXT gogo(SB), 7, $0
+TEXT runtime·gogo(SB), 7, $0
 	MOVQ	16(SP), AX		// return 2nd arg
 	MOVQ	8(SP), BX		// gobuf
 	MOVQ	gobuf_g(BX), DX
@@ -119,7 +119,7 @@
 // void gogocall(Gobuf*, void (*fn)(void))
 // restore state from Gobuf but then call fn.
 // (call fn, returning to state in Gobuf)
-TEXT gogocall(SB), 7, $0
+TEXT runtime·gogocall(SB), 7, $0
 	MOVQ	16(SP), AX		// fn
 	MOVQ	8(SP), BX		// gobuf
 	MOVQ	gobuf_g(BX), DX
@@ -138,7 +138,7 @@
 
 // Called during function prolog when more stack is needed.
 // Caller has already done get_tls(CX); MOVQ m(CX), BX.
-TEXT morestack(SB),7,$0
+TEXT runtime·morestack(SB),7,$0
 	// Cannot grow scheduler stack (m->g0).
 	MOVQ	m_g0(BX), SI
 	CMPQ	g(CX), SI
@@ -164,7 +164,7 @@
 	MOVQ	m_g0(BX), BP
 	MOVQ	BP, g(CX)
 	MOVQ	(m_sched+gobuf_sp)(BX), SP
-	CALL	newstack(SB)
+	CALL	runtime·newstack(SB)
 	MOVQ	$0, 0x1003	// crash if newstack returns
 	RET
 
@@ -206,12 +206,12 @@
 	get_tls(CX)
 	MOVQ	BP, g(CX)
 	MOVQ	(m_sched+gobuf_sp)(BX), SP
-	CALL	newstack(SB)
+	CALL	runtime·newstack(SB)
 	MOVQ	$0, 0x1103	// crash if newstack returns
 	RET
 
 // Return point when leaving stack.
-TEXT ·lessstack(SB), 7, $0
+TEXT runtime·lessstack(SB), 7, $0
 	// Save return value in m->cret
 	get_tls(CX)
 	MOVQ	m(CX), BX
@@ -221,81 +221,81 @@
 	MOVQ	m_g0(BX), DX
 	MOVQ	DX, g(CX)
 	MOVQ	(m_sched+gobuf_sp)(BX), SP
-	CALL	oldstack(SB)
+	CALL	runtime·oldstack(SB)
 	MOVQ	$0, 0x1004	// crash if oldstack returns
 	RET
 
 // morestack trampolines
-TEXT	·morestack00+0(SB),7,$0
+TEXT runtime·morestack00(SB),7,$0
 	get_tls(CX)
 	MOVQ	m(CX), BX
 	MOVQ	$0, AX
 	MOVQ	AX, m_moreframe(BX)
-	MOVQ	$morestack+0(SB), AX
+	MOVQ	$runtime·morestack(SB), AX
 	JMP	AX
 
-TEXT	·morestack01+0(SB),7,$0
+TEXT runtime·morestack01(SB),7,$0
 	get_tls(CX)
 	MOVQ	m(CX), BX
 	SHLQ	$32, AX
 	MOVQ	AX, m_moreframe(BX)
-	MOVQ	$morestack+0(SB), AX
+	MOVQ	$runtime·morestack(SB), AX
 	JMP	AX
 
-TEXT	·morestack10+0(SB),7,$0
+TEXT runtime·morestack10(SB),7,$0
 	get_tls(CX)
 	MOVQ	m(CX), BX
 	MOVLQZX	AX, AX
 	MOVQ	AX, m_moreframe(BX)
-	MOVQ	$morestack+0(SB), AX
+	MOVQ	$runtime·morestack(SB), AX
 	JMP	AX
 
-TEXT	·morestack11+0(SB),7,$0
+TEXT runtime·morestack11(SB),7,$0
 	get_tls(CX)
 	MOVQ	m(CX), BX
 	MOVQ	AX, m_moreframe(BX)
-	MOVQ	$morestack+0(SB), AX
+	MOVQ	$runtime·morestack(SB), AX
 	JMP	AX
 
 // subcases of morestack01
 // with const of 8,16,...48
-TEXT	·morestack8(SB),7,$0
+TEXT runtime·morestack8(SB),7,$0
 	PUSHQ	$1
-	MOVQ	$·morestackx(SB), AX
+	MOVQ	$morestack<>(SB), AX
 	JMP	AX
 
-TEXT	·morestack16(SB),7,$0
+TEXT runtime·morestack16(SB),7,$0
 	PUSHQ	$2
-	MOVQ	$·morestackx(SB), AX
+	MOVQ	$morestack<>(SB), AX
 	JMP	AX
 
-TEXT	·morestack24(SB),7,$0
+TEXT runtime·morestack24(SB),7,$0
 	PUSHQ	$3
-	MOVQ	$·morestackx(SB), AX
+	MOVQ	$morestack<>(SB), AX
 	JMP	AX
 
-TEXT	·morestack32(SB),7,$0
+TEXT runtime·morestack32(SB),7,$0
 	PUSHQ	$4
-	MOVQ	$·morestackx(SB), AX
+	MOVQ	$morestack<>(SB), AX
 	JMP	AX
 
-TEXT	·morestack40(SB),7,$0
+TEXT runtime·morestack40(SB),7,$0
 	PUSHQ	$5
-	MOVQ	$·morestackx(SB), AX
+	MOVQ	$morestack<>(SB), AX
 	JMP	AX
 
-TEXT	·morestack48(SB),7,$0
+TEXT runtime·morestack48(SB),7,$0
 	PUSHQ	$6
-	MOVQ	$·morestackx(SB), AX
+	MOVQ	$morestack<>(SB), AX
 	JMP	AX
 
-TEXT	·morestackx(SB),7,$0
+TEXT morestack<>(SB),7,$0
 	get_tls(CX)
 	MOVQ	m(CX), BX
 	POPQ	AX
 	SHLQ	$35, AX
 	MOVQ	AX, m_moreframe(BX)
-	MOVQ	$morestack(SB), AX
+	MOVQ	$runtime·morestack(SB), AX
 	JMP	AX
 
 // bool cas(int32 *val, int32 old, int32 new)
@@ -305,7 +305,7 @@
 //		return 1;
 //	} else
 //		return 0;
-TEXT cas(SB), 7, $0
+TEXT runtime·cas(SB), 7, $0
 	MOVQ	8(SP), BX
 	MOVL	16(SP), AX
 	MOVL	20(SP), CX
@@ -322,7 +322,7 @@
 // 1. pop the caller
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
-TEXT jmpdefer(SB), 7, $0
+TEXT runtime·jmpdefer(SB), 7, $0
 	MOVQ	8(SP), AX	// fn
 	MOVQ	16(SP), BX	// caller sp
 	LEAQ	-8(BX), SP	// caller sp after CALL
@@ -332,7 +332,7 @@
 // runcgo(void(*fn)(void*), void *arg)
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
-TEXT runcgo(SB),7,$32
+TEXT runtime·runcgo(SB),7,$32
 	MOVQ	fn+0(FP), R12
 	MOVQ	arg+8(FP), R13
 	MOVQ	SP, CX
@@ -365,7 +365,7 @@
 // runcgocallback(G *g1, void* sp, void (*fn)(void))
 // Switch to g1 and sp, call fn, switch back.  fn's arguments are on
 // the new stack.
-TEXT runcgocallback(SB),7,$48
+TEXT runtime·runcgocallback(SB),7,$48
 	MOVQ	g1+0(FP), DX
 	MOVQ	sp+8(FP), AX
 	MOVQ	fp+16(FP), BX
@@ -394,7 +394,7 @@
 	RET
 
 // check that SP is in range [g->stackbase, g->stackguard)
-TEXT stackcheck(SB), 7, $0
+TEXT runtime·stackcheck(SB), 7, $0
 	get_tls(CX)
 	MOVQ	g(CX), AX
 	CMPQ	g_stackbase(AX), SP
@@ -405,7 +405,7 @@
 	INT	$3
 	RET
 
-TEXT	·memclr(SB),7,$0
+TEXT runtime·memclr(SB),7,$0
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVL	16(SP), CX		// arg 2 count
 	ADDL	$7, CX
@@ -416,20 +416,19 @@
 	STOSQ
 	RET
 
-TEXT	·getcallerpc+0(SB),7,$0
+TEXT runtime·getcallerpc(SB),7,$0
 	MOVQ	x+0(FP),AX		// addr of first arg
 	MOVQ	-8(AX),AX		// get calling pc
 	RET
 
-TEXT	·setcallerpc+0(SB),7,$0
+TEXT runtime·setcallerpc(SB),7,$0
 	MOVQ	x+0(FP),AX		// addr of first arg
 	MOVQ	x+8(FP), BX
 	MOVQ	BX, -8(AX)		// set calling pc
 	RET
 
-TEXT getcallersp(SB),7,$0
+TEXT runtime·getcallersp(SB),7,$0
 	MOVQ	sp+0(FP), AX
 	RET
 
-GLOBL initcgo(SB), $8
-GLOBL tls0(SB), $64
+GLOBL runtime·tls0(SB), $64
diff --git a/src/pkg/runtime/amd64/closure.c b/src/pkg/runtime/amd64/closure.c
index de2d169..5033468 100644
--- a/src/pkg/runtime/amd64/closure.c
+++ b/src/pkg/runtime/amd64/closure.c
@@ -9,20 +9,20 @@
 //	fn func(arg0, arg1, arg2 *ptr, callerpc uintptr, xxx) yyy,
 //	arg0, arg1, arg2 *ptr) (func(xxx) yyy)
 void
-·closure(int32 siz, byte *fn, byte *arg0)
+runtime·closure(int32 siz, byte *fn, byte *arg0)
 {
 	byte *p, *q, **ret;
 	int32 i, n;
 	int64 pcrel;
 
 	if(siz < 0 || siz%8 != 0)
-		throw("bad closure size");
+		runtime·throw("bad closure size");
 
 	ret = (byte**)((byte*)&arg0 + siz);
 
 	if(siz > 100) {
 		// TODO(rsc): implement stack growth preamble?
-		throw("closure too big");
+		runtime·throw("closure too big");
 	}
 
 	// compute size of new fn.
@@ -40,12 +40,12 @@
 	if(n%8)
 		n += 8 - n%8;
 
-	p = mal(n);
+	p = runtime·mal(n);
 	*ret = p;
 	q = p + n - siz;
 
 	if(siz > 0) {
-		mcpy(q, (byte*)&arg0, siz);
+		runtime·mcpy(q, (byte*)&arg0, siz);
 
 		// SUBQ $siz, SP
 		*p++ = 0x48;
@@ -117,7 +117,7 @@
 	*p++ = 0xc3;
 
 	if(p > q)
-		throw("bad math in sys.closure");
+		runtime·throw("bad math in sys.closure");
 }
 
 
diff --git a/src/pkg/runtime/amd64/memmove.s b/src/pkg/runtime/amd64/memmove.s
index d755580..9966b0b 100644
--- a/src/pkg/runtime/amd64/memmove.s
+++ b/src/pkg/runtime/amd64/memmove.s
@@ -23,7 +23,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-	TEXT	memmove(SB), 7, $0
+TEXT runtime·memmove(SB), 7, $0
 
 	MOVQ	to+0(FP), DI
 	MOVQ	fr+8(FP), SI
diff --git a/src/pkg/runtime/amd64/traceback.c b/src/pkg/runtime/amd64/traceback.c
index 5cdbf20..3ea80a661 100644
--- a/src/pkg/runtime/amd64/traceback.c
+++ b/src/pkg/runtime/amd64/traceback.c
@@ -6,8 +6,8 @@
 #include "malloc.h"
 
 static uintptr isclosureentry(uintptr);
-void ·deferproc(void);
-void ·newproc(void);
+void runtime·deferproc(void);
+void runtime·newproc(void);
 
 // This code is also used for the 386 tracebacks.
 // Use uintptr for an appropriate word-sized integer.
@@ -35,7 +35,7 @@
 	}
 	
 	nascent = 0;
-	if(pc0 == g->sched.pc && sp == g->sched.sp && pc0 == (byte*)goexit) {
+	if(pc0 == g->sched.pc && sp == g->sched.sp && pc0 == (byte*)runtime·goexit) {
 		// Hasn't started yet.  g->sched is set up for goexit
 		// but goroutine will start at g->entry.
 		nascent = 1;
@@ -45,7 +45,7 @@
 	n = 0;
 	stk = (Stktop*)g->stackbase;
 	for(iter = 0; iter < 100 && n < m; iter++) {	// iter avoids looping forever
-		if(pc == (uintptr)·lessstack) {
+		if(pc == (uintptr)runtime·lessstack) {
 			// Hit top of stack segment.  Unwind to next segment.
 			pc = (uintptr)stk->gobuf.pc;
 			sp = stk->gobuf.sp;
@@ -53,14 +53,14 @@
 			continue;
 		}
 
-		if(pc <= 0x1000 || (f = findfunc(pc)) == nil) {
+		if(pc <= 0x1000 || (f = runtime·findfunc(pc)) == nil) {
 			// Dangerous, but worthwhile: see if this is a closure:
 			//	ADDQ $wwxxyyzz, SP; RET
 			//	[48] 81 c4 zz yy xx ww c3
 			// The 0x48 byte is only on amd64.
 			p = (byte*)pc;
 			// We check p < p+8 to avoid wrapping and faulting if we lose track.
-			if(mheap.min < p && p < p+8 && p+8 < mheap.max &&  // pointer in allocated memory
+			if(runtime·mheap.min < p && p < p+8 && p+8 < runtime·mheap.max &&  // pointer in allocated memory
 			   (sizeof(uintptr) != 8 || *p++ == 0x48) &&  // skip 0x48 byte on amd64
 			   p[0] == 0x81 && p[1] == 0xc4 && p[6] == 0xc3) {
 				sp += *(uint32*)(p+2);
@@ -85,14 +85,14 @@
 			// Print during crash.
 			//	main+0xf /home/rsc/go/src/runtime/x.go:23
 			//		main(0x1, 0x2, 0x3)
-			printf("%S", f->name);
+			runtime·printf("%S", f->name);
 			if(pc > f->entry)
-				printf("+%p", (uintptr)(pc - f->entry));
+				runtime·printf("+%p", (uintptr)(pc - f->entry));
 			tracepc = pc;	// back up to CALL instruction for funcline.
 			if(n > 0 && pc > f->entry)
 				tracepc--;
-			printf(" %S:%d\n", f->src, funcline(f, tracepc));
-			printf("\t%S(", f->name);
+			runtime·printf(" %S:%d\n", f->src, runtime·funcline(f, tracepc));
+			runtime·printf("\t%S(", f->name);
 			fp = (uintptr*)sp;
 			if(f->frame < sizeof(uintptr))
 				fp++;
@@ -100,14 +100,14 @@
 				fp += f->frame/sizeof(uintptr);
 			for(i = 0; i < f->args; i++) {
 				if(i != 0)
-					prints(", ");
-				·printhex(fp[i]);
+					runtime·prints(", ");
+				runtime·printhex(fp[i]);
 				if(i >= 4) {
-					prints(", ...");
+					runtime·prints(", ...");
 					break;
 				}
 			}
-			prints(")\n");
+			runtime·prints(")\n");
 			n++;
 		}
 		
@@ -123,26 +123,26 @@
 		else
 			sp += f->frame;
 		pc = *((uintptr*)sp - 1);
-		if(f->entry == (uintptr)·deferproc || f->entry == (uintptr)·newproc)
+		if(f->entry == (uintptr)runtime·deferproc || f->entry == (uintptr)runtime·newproc)
 			sp += 2*sizeof(uintptr);
 	}
 	return n;
 }
 
 void
-traceback(byte *pc0, byte *sp, byte*, G *g)
+runtime·traceback(byte *pc0, byte *sp, byte*, G *g)
 {
 	gentraceback(pc0, sp, g, 0, nil, 100);
 }
 
 int32
-callers(int32 skip, uintptr *pcbuf, int32 m)
+runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
 {
 	byte *pc, *sp;
 
 	// our caller's pc, sp.
 	sp = (byte*)&skip;
-	pc = ·getcallerpc(&skip);
+	pc = runtime·getcallerpc(&skip);
 
 	return gentraceback(pc, sp, g, skip, pcbuf, m);
 }
@@ -154,7 +154,7 @@
 	int32 i, siz;
 	
 	p = (byte*)pc;
-	if(p < mheap.min || p+32 > mheap.max)
+	if(p < runtime·mheap.min || p+32 > runtime·mheap.max)
 		return 0;
 	
 	// SUBQ $siz, SP
diff --git a/src/pkg/runtime/arm/asm.s b/src/pkg/runtime/arm/asm.s
index dd317cc..44c47ba 100644
--- a/src/pkg/runtime/arm/asm.s
+++ b/src/pkg/runtime/arm/asm.s
@@ -19,8 +19,8 @@
 
 	// set up m and g registers
 	// g is R10, m is R9
-	MOVW	$g0(SB), g
-	MOVW	$m0(SB), m
+	MOVW	$runtime·g0(SB), g
+	MOVW	$runtime·m0(SB), m
 
 	// save m->g0 = g0
 	MOVW	g, m_g0(m)
@@ -29,47 +29,47 @@
 	MOVW	$(-8192+104)(R13), R0
 	MOVW	R0, g_stackguard(g)	// (w 104b guard)
 	MOVW	R13, g_stackbase(g)
-	BL	emptyfunc(SB)	// fault if stack check is wrong
+	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
 
-	BL	check(SB)
+	BL	runtime·check(SB)
 
 	// saved argc, argv
 	MOVW	120(R13), R0
 	MOVW	R0, 4(R13)
 	MOVW	124(R13), R1
 	MOVW	R1, 8(R13)
-	BL	args(SB)
-	BL	osinit(SB)
-	BL	schedinit(SB)
+	BL	runtime·args(SB)
+	BL	runtime·osinit(SB)
+	BL	runtime·schedinit(SB)
 
 	// create a new goroutine to start program
-	MOVW	$mainstart(SB), R0
+	MOVW	$runtime·mainstart(SB), R0
 	MOVW.W	R0, -4(R13)
 	MOVW	$8, R0
 	MOVW.W	R0, -4(R13)
 	MOVW	$0, R0
 	MOVW.W	R0, -4(R13)	// push $0 as guard
-	BL	·newproc(SB)
+	BL	runtime·newproc(SB)
 	MOVW	$12(R13), R13	// pop args and LR
 
 	// start this M
-	BL	mstart(SB)
+	BL	runtime·mstart(SB)
 
 	MOVW	$1234, R0
 	MOVW	$1000, R1
 	MOVW	R0, (R1)	// fail hard
-	B	_dep_dummy(SB)	// Never reached
+	B	runtime·_dep_dummy(SB)	// Never reached
 
 
-TEXT mainstart(SB),7,$4
+TEXT runtime·mainstart(SB),7,$4
 	BL	main·init(SB)
-	BL	initdone(SB)
+	BL	runtime·initdone(SB)
 	EOR	R0, R0
 	MOVW	R0, 0(R13)
 	BL	main·main(SB)
 	MOVW	$0, R0
 	MOVW	R0, 4(SP)
-	BL	exit(SB)
+	BL	runtime·exit(SB)
 	MOVW	$1234, R0
 	MOVW	$1001, R1
 	MOVW	R0, (R1)	// fail hard
@@ -77,7 +77,7 @@
 
 // TODO(kaib): remove these once i actually understand how the linker removes symbols
 // pull in dummy dependencies
-TEXT _dep_dummy(SB),7,$0
+TEXT runtime·_dep_dummy(SB),7,$0
 	BL	_div(SB)
 	BL	_divu(SB)
 	BL	_mod(SB)
@@ -85,7 +85,7 @@
 	BL	_modu(SB)
 	BL	_sfloat(SB)
 
-TEXT	breakpoint(SB),7,$0
+TEXT runtime·breakpoint(SB),7,$0
 	// no breakpoint yet; let program exit
 	RET
 
@@ -95,7 +95,7 @@
 
 // uintptr gosave(Gobuf*)
 // save state in Gobuf; setjmp
-TEXT gosave(SB), 7, $-4
+TEXT runtime·gosave(SB), 7, $-4
 	MOVW	0(FP), R0		// gobuf
 	MOVW	SP, gobuf_sp(R0)
 	MOVW	LR, gobuf_pc(R0)
@@ -105,7 +105,7 @@
 
 // void gogo(Gobuf*, uintptr)
 // restore state from Gobuf; longjmp
-TEXT	gogo(SB), 7, $-4
+TEXT runtime·gogo(SB), 7, $-4
 	MOVW	0(FP), R1		// gobuf
 	MOVW	4(FP), R0		// return 2nd arg
 	MOVW	gobuf_g(R1), g
@@ -117,7 +117,7 @@
 // restore state from Gobuf but then call fn.
 // (call fn, returning to state in Gobuf)
 // using frame size $-4 means do not save LR on stack.
-TEXT gogocall(SB), 7, $-4
+TEXT runtime·gogocall(SB), 7, $-4
 	MOVW	0(FP), R0		// gobuf
 	MOVW	4(FP), R1		// fn
 	MOVW	8(FP), R2		// fp offset
@@ -138,11 +138,11 @@
 // NB. we do not save R0 because we've forced 5c to pass all arguments
 // on the stack.
 // using frame size $-4 means do not save LR on stack.
-TEXT ·morestack(SB),7,$-4
+TEXT runtime·morestack(SB),7,$-4
 	// Cannot grow scheduler stack (m->g0).
 	MOVW	m_g0(m), R4
 	CMP	g, R4
-	BL.EQ	abort(SB)
+	BL.EQ	runtime·abort(SB)
 
 	// Save in m.
 	MOVW	R1, m_moreframe(m)
@@ -161,7 +161,7 @@
 	// Call newstack on m's scheduling stack.
 	MOVW	m_g0(m), g
 	MOVW	(m_sched+gobuf_sp)(m), SP
-	B	newstack(SB)
+	B	runtime·newstack(SB)
 
 // Called from reflection library.  Mimics morestack,
 // reuses stack growth code to create a frame
@@ -197,32 +197,32 @@
 	// Call newstack on m's scheduling stack.
 	MOVW	m_g0(m), g
 	MOVW	(m_sched+gobuf_sp)(m), SP
-	B	newstack(SB)
+	B	runtime·newstack(SB)
 
 // Return point when leaving stack.
 // using frame size $-4 means do not save LR on stack.
-TEXT ·lessstack(SB), 7, $-4
+TEXT runtime·lessstack(SB), 7, $-4
 	// Save return value in m->cret
 	MOVW	R0, m_cret(m)
 
 	// Call oldstack on m's scheduling stack.
 	MOVW	m_g0(m), g
 	MOVW	(m_sched+gobuf_sp)(m), SP
-	B	oldstack(SB)
+	B	runtime·oldstack(SB)
 
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. grab stored LR for caller
 // 2. sub 4 bytes to get back to BL deferreturn
 // 3. B to fn
-TEXT jmpdefer(SB), 7, $0
+TEXT runtime·jmpdefer(SB), 7, $0
 	MOVW	0(SP), LR
 	MOVW	$-4(LR), LR	// BL deferreturn
 	MOVW	4(SP), R0		// fn
 	MOVW	8(SP), SP
 	B		(R0)
 
-TEXT	·memclr(SB),7,$20
+TEXT runtime·memclr(SB),7,$20
 	MOVW	0(FP), R0
 	MOVW	$0, R1		// c = 0
 	MOVW	R1, -16(SP)
@@ -230,21 +230,21 @@
 	MOVW	R1, -12(SP)
 	MOVW	m, -8(SP)	// Save m and g
 	MOVW	g, -4(SP)
-	BL	memset(SB)
+	BL	runtime·memset(SB)
 	MOVW	-8(SP), m	// Restore m and g, memset clobbers them
 	MOVW	-4(SP), g
 	RET
 
-TEXT	·getcallerpc+0(SB),7,$-4
+TEXT runtime·getcallerpc(SB),7,$-4
 	MOVW	0(SP), R0
 	RET
 
-TEXT	·setcallerpc+0(SB),7,$-4
+TEXT runtime·setcallerpc(SB),7,$-4
 	MOVW	x+4(FP), R0
 	MOVW	R0, 0(SP)
 	RET
 
-TEXT	getcallersp(SB),7,$-4
+TEXT runtime·getcallersp(SB),7,$-4
 	MOVW	0(FP), R0
 	MOVW	$-4(R0), R0
 	RET
@@ -253,8 +253,8 @@
 // Just call fn(arg), but first align the stack
 // appropriately for the gcc ABI.
 // TODO(kaib): figure out the arm-gcc ABI
-TEXT	runcgo(SB),7,$16
-	BL	abort(SB)
+TEXT runtime·runcgo(SB),7,$16
+	BL	runtime·abort(SB)
 //	MOVL	fn+0(FP), AX
 //	MOVL	arg+4(FP), BX
 //	MOVL	SP, CX
@@ -265,13 +265,13 @@
 //	MOVL	4(SP), SP
 //	RET
 
-TEXT emptyfunc(SB),0,$0
+TEXT runtime·emptyfunc(SB),0,$0
 	RET
 
-TEXT abort(SB),7,$-4
+TEXT runtime·abort(SB),7,$-4
 	MOVW	$0, R0
 	MOVW	(R0), R1
 
-TEXT	runcgocallback(SB),7,$0
+TEXT runtime·runcgocallback(SB),7,$0
 	MOVW	$0, R0
 	MOVW	(R0), R1
diff --git a/src/pkg/runtime/arm/cas5.s b/src/pkg/runtime/arm/cas5.s
index 8a4c8be..20bd3c3 100644
--- a/src/pkg/runtime/arm/cas5.s
+++ b/src/pkg/runtime/arm/cas5.s
@@ -14,12 +14,12 @@
 //	}else
 //		return 0;
 
-TEXT	cas(SB),7,$0
+TEXT runtime·cas(SB),7,$0
 	MOVW	0(FP), R0	// *val
 	MOVW	4(FP), R1	// old
 	MOVW	8(FP), R2	// new
 	MOVW	$1, R3
-	MOVW	$cas_mutex(SB), R4
+	MOVW	$runtime·cas_mutex(SB), R4
 l:
 	SWPW	(R4), R3	// acquire mutex
 	CMP		$0, R3
@@ -39,5 +39,5 @@
 	MOVW	$0, R0
 	RET
  
-DATA cas_mutex(SB)/4, $0
-GLOBL cas_mutex(SB), $4
+DATA runtime·cas_mutex(SB)/4, $0
+GLOBL runtime·cas_mutex(SB), $4
diff --git a/src/pkg/runtime/arm/cas6.s b/src/pkg/runtime/arm/cas6.s
index 63df139..5637998 100644
--- a/src/pkg/runtime/arm/cas6.s
+++ b/src/pkg/runtime/arm/cas6.s
@@ -10,7 +10,7 @@
 //	}else
 //		return 0;
 
-TEXT	cas(SB),7,$0
+TEXT cas(SB),7,$0
 	MOVW	0(FP), R1	// *val
 	MOVW	4(FP), R2	// old
 	MOVW	8(FP), R3	// new
diff --git a/src/pkg/runtime/arm/closure.c b/src/pkg/runtime/arm/closure.c
index 11a7719..3aca3a4 100644
--- a/src/pkg/runtime/arm/closure.c
+++ b/src/pkg/runtime/arm/closure.c
@@ -47,20 +47,20 @@
 
 #pragma textflag 7
 void
-·closure(int32 siz, byte *fn, byte *arg0)
+runtime·closure(int32 siz, byte *fn, byte *arg0)
 {
 	byte *p, *q, **ret;
 	uint32 *pc;
 	int32 n;
 
 	if(siz < 0 || siz%4 != 0)
-		throw("bad closure size");
+		runtime·throw("bad closure size");
 
 	ret = (byte**)((byte*)&arg0 + siz);
 
 	if(siz > 100) {
 		// TODO(kaib): implement stack growth preamble?
-		throw("closure too big");
+		runtime·throw("closure too big");
 	}
 
 	// size of new fn.
@@ -73,7 +73,7 @@
 	// store args aligned after code, so gc can find them.
 	n += siz;
 
-	p = mal(n);
+	p = runtime·mal(n);
 	*ret = p;
 	q = p + n - siz;
 
@@ -83,7 +83,7 @@
 	*pc++ = 0xe52de000 | (siz + 4);
 
 	if(siz > 0) {
-		mcpy(q, (byte*)&arg0, siz);
+		runtime·mcpy(q, (byte*)&arg0, siz);
 
 		//	MOVW	$vars(PC), R0
 		*pc = 0xe28f0000 | (int32)(q - (byte*)pc - 8);
@@ -122,8 +122,8 @@
 	p = (byte*)pc;
 
 	if(p > q)
-		throw("bad math in sys.closure");
+		runtime·throw("bad math in sys.closure");
 
-	cacheflush(*ret, q+siz);
+	runtime·cacheflush(*ret, q+siz);
 }
 
diff --git a/src/pkg/runtime/arm/memmove.s b/src/pkg/runtime/arm/memmove.s
index 9f7dc1d..5c0e574 100644
--- a/src/pkg/runtime/arm/memmove.s
+++ b/src/pkg/runtime/arm/memmove.s
@@ -31,7 +31,7 @@
 TMP1 = 4
 
 // TODO(kaib): This can be done with the existing registers of LR is re-used. Same for memset.
-TEXT memmove(SB), 7, $8
+TEXT runtime·memmove(SB), 7, $8
 	// save g and m
 	MOVW	R9, 4(R13)
 	MOVW	R10, 8(R13)
diff --git a/src/pkg/runtime/arm/memset.s b/src/pkg/runtime/arm/memset.s
index cce9453..974b8da 100644
--- a/src/pkg/runtime/arm/memset.s
+++ b/src/pkg/runtime/arm/memset.s
@@ -31,7 +31,7 @@
 // TODO(kaib): memset clobbers R9 and R10 (m and g). This makes the
 // registers unpredictable if (when) memset SIGSEGV's. Fix it by
 // moving the R4-R11 register bank.
-TEXT memset(SB), $0
+TEXT runtime·memset(SB), $0
 	MOVW	R0, R(TO)
 	MOVW	data+4(FP), R(4)
 	MOVW	n+8(FP), R(N)
diff --git a/src/pkg/runtime/arm/softfloat.c b/src/pkg/runtime/arm/softfloat.c
index a5a6ba1..2ea8216 100644
--- a/src/pkg/runtime/arm/softfloat.c
+++ b/src/pkg/runtime/arm/softfloat.c
@@ -14,8 +14,8 @@
 fabort(void)
 {
 	if (1) {
-		printf("Unsupported floating point instruction\n");
-		abort();
+		runtime·printf("Unsupported floating point instruction\n");
+		runtime·abort();
 	}
 }
 
@@ -88,7 +88,7 @@
 	case 0x80:
 		return 1;
 	default:
-		fabort();
+		runtime·fabort();
 	}
 	return 0;
 }
@@ -108,7 +108,7 @@
 {
 	uint32 i;
 	for (i = 0; i < 8; i++) {
-		printf("\tf%d:\t%X\n", i, m->freg[i]);
+		runtime·printf("\tf%d:\t%X\n", i, m->freg[i]);
 	}
 }
 
@@ -117,7 +117,7 @@
 {
 	uint32 x;
 	
-	·f64to32c(d, &x);
+	runtime·f64to32c(d, &x);
 	return x;
 }
 
@@ -126,7 +126,7 @@
 {
 	uint64 x;
 	
-	·f32to64c(s, &x);
+	runtime·f32to64c(s, &x);
 	return x;
 }
 
@@ -147,16 +147,16 @@
 	lhs = i>>16 & 7;
 	rhs = i & 15;
 
-	prec = precision(i);
+	prec = runtime·precision(i);
 //	if (prec != 1)
 //		goto undef;
 
 	if (unary) {
 		switch (opcode) {
 		case 0: // mvf
-			fd = frhs(rhs);
+			fd = runtime·frhs(rhs);
 			if(prec == 0)
-				fd = s2d(d2s(fd));
+				fd = runtime·s2d(d2s(fd));
 			m->freg[dest] = fd;
 			goto ret;
 		default:
@@ -164,21 +164,21 @@
 		}
 	} else {
 		l = m->freg[lhs];
-		r = frhs(rhs);
+		r = runtime·frhs(rhs);
 		switch (opcode) {
 		default:
 			goto undef;
 		case 0:
-			·fadd64c(l, r, &m->freg[dest]);
+			runtime·fadd64c(l, r, &m->freg[dest]);
 			break;
 		case 1:
-			·fmul64c(l, r, &m->freg[dest]);
+			runtime·fmul64c(l, r, &m->freg[dest]);
 			break;
 		case 2:
-			·fsub64c(l, r, &m->freg[dest]);
+			runtime·fsub64c(l, r, &m->freg[dest]);
 			break;
 		case 4:
-			·fdiv64c(l, r, &m->freg[dest]);
+			runtime·fdiv64c(l, r, &m->freg[dest]);
 			break;
 		}
 		goto ret;
@@ -190,18 +190,18 @@
 
 ret:
 	if (trace || doabort) {
-		printf(" %p %x\t%s%s\tf%d, ", pc, *pc, opnames[opcode | unary<<4],
+		runtime·printf(" %p %x\t%s%s\tf%d, ", pc, *pc, opnames[opcode | unary<<4],
 			fpprec[prec], dest);
 		if (!unary)
-			printf("f%d, ", lhs);
+			runtime·printf("f%d, ", lhs);
 		if (rhs & 0x8)
-			printf("#%s\n", fpconst[rhs&0x7]);
+			runtime·printf("#%s\n", fpconst[rhs&0x7]);
 		else
-			printf("f%d\n", rhs&0x7);
-		fprint();
+			runtime·printf("f%d\n", rhs&0x7);
+		runtime·fprint();
 	}
 	if (doabort)
-		fabort();
+		runtime·fabort();
 }
 
 #define CPSR 14
@@ -225,8 +225,8 @@
 	rhs = i & 0xf;
 
 	l = m->freg[lhs];
-	r = frhs(rhs);
-	·fcmp64c(l, r, &cmp, &nan);
+	r = runtime·frhs(rhs);
+	runtime·fcmp64c(l, r, &cmp, &nan);
 	if (nan)
 		flags = FLAGS_C | FLAGS_V;
 	else if (cmp == 0)
@@ -237,11 +237,11 @@
 		flags = FLAGS_C;
 
 	if (trace) {
-		printf(" %p %x\tcmf\tf%d, ", pc, *pc, lhs);
+		runtime·printf(" %p %x\tcmf\tf%d, ", pc, *pc, lhs);
 		if (rhs & 0x8)
-			printf("#%s\n", fpconst[rhs&0x7]);
+			runtime·printf("#%s\n", fpconst[rhs&0x7]);
 		else
-			printf("f%d\n", rhs&0x7);
+			runtime·printf("f%d\n", rhs&0x7);
 	}
 	regs[CPSR] = regs[CPSR] & 0x0fffffff | flags;
 }
@@ -278,12 +278,12 @@
 		if (tlen)
 			m->freg[freg] = *((uint64*)addr);
 		else
-			m->freg[freg] = s2d(*((uint32*)addr));
+			m->freg[freg] = runtime·s2d(*((uint32*)addr));
 	else
 		if (tlen)
 			*((uint64*)addr) = m->freg[freg];
 		else
-			*((uint32*)addr) = d2s(m->freg[freg]);
+			*((uint32*)addr) = runtime·d2s(m->freg[freg]);
 	goto ret;
 
 undef:
@@ -292,18 +292,18 @@
 ret:
 	if (trace || doabort) {
 		if (isload)
-			printf(" %p %x\tldf", pc, *pc);
+			runtime·printf(" %p %x\tldf", pc, *pc);
 		else
-			printf(" %p %x\tstf", pc, *pc);
-		printf("%s\t\tf%d, %s%d(r%d)", fpprec[tlen], freg, ud ? "" : "-", offset, reg);
-		printf("\t\t// %p", regs[reg] + (ud ? offset : -offset));
+			runtime·printf(" %p %x\tstf", pc, *pc);
+		runtime·printf("%s\t\tf%d, %s%d(r%d)", fpprec[tlen], freg, ud ? "" : "-", offset, reg);
+		runtime·printf("\t\t// %p", regs[reg] + (ud ? offset : -offset));
 		if (coproc != 1 || p != 1 || wb != 0)
-			printf(" coproc: %d pre: %d wb %d", coproc, p, wb);
-		printf("\n");
-		fprint();
+			runtime·printf(" coproc: %d pre: %d wb %d", coproc, p, wb);
+		runtime·printf("\n");
+		runtime·fprint();
 	}
 	if (doabort)
-		fabort();
+		runtime·fabort();
 }
 
 static void
@@ -318,16 +318,16 @@
 	toarm = i>>20 & 0x1;
 	freg = i>>16 & 0x7;
 	reg = i>>12 & 0xf;
-	prec = precision(i);
+	prec = runtime·precision(i);
 
 	if (toarm) { // fix
 		f0 = m->freg[freg];
-		·f64tointc(f0, &val, &ok);
+		runtime·f64tointc(f0, &val, &ok);
 		if (!ok || (int32)val != val)
 			val = 0;
 		regs[reg] = val;
 	} else { // flt
-		·fintto64c((int32)regs[reg], &f0);
+		runtime·fintto64c((int32)regs[reg], &f0);
 		m->freg[freg] = f0;
 	}
 	goto ret;
@@ -335,13 +335,13 @@
 ret:
 	if (trace || doabort) {
 		if (toarm)
-			printf(" %p %x\tfix%s\t\tr%d, f%d\n", pc, *pc, fpprec[prec], reg, freg);
+			runtime·printf(" %p %x\tfix%s\t\tr%d, f%d\n", pc, *pc, fpprec[prec], reg, freg);
 		else
-			printf(" %p %x\tflt%s\t\tf%d, r%d\n", pc, *pc, fpprec[prec], freg, reg);
-		fprint();
+			runtime·printf(" %p %x\tflt%s\t\tf%d, r%d\n", pc, *pc, fpprec[prec], freg, reg);
+		runtime·fprint();
 	}
 	if (doabort)
-		fabort();
+		runtime·fabort();
 }
 
 // returns number of words that the fp instruction is occupying, 0 if next instruction isn't float.
@@ -367,7 +367,7 @@
 	c = i >> 25 & 7;
 	switch(c) {
 	case 6: // 110
-		loadstore(pc, regs);
+		runtime·loadstore(pc, regs);
 		return 1;
 	case 7: // 111
 		if (i>>24 & 1)
@@ -375,15 +375,15 @@
 
 		if (i>>4 & 1) { //data transfer
 			if ((i&0x00f0ff00) == 0x0090f100) {
-				compare(pc, regs);
+				runtime·compare(pc, regs);
 			} else if ((i&0x00e00f10) == 0x00000110) {
-				fltfix(pc, regs);
+				runtime·fltfix(pc, regs);
 			} else {
-				printf(" %p %x\t// case 7 fail\n", pc, i);
-				fabort();
+				runtime·printf(" %p %x\t// case 7 fail\n", pc, i);
+				runtime·fabort();
 			}
 		} else {
-			dataprocess(pc);
+			runtime·dataprocess(pc);
 		}
 		return 1;
 	}
@@ -410,11 +410,11 @@
 
 #pragma textflag 7
 uint32*
-_sfloat2(uint32 *lr, uint32 r0)
+runtime·_sfloat2(uint32 *lr, uint32 r0)
 {
 	uint32 skip;
 
-	while(skip = stepflt(lr, &r0))
+	while(skip = runtime·stepflt(lr, &r0))
 		lr += skip;
 	return lr;
 }
diff --git a/src/pkg/runtime/arm/traceback.c b/src/pkg/runtime/arm/traceback.c
index 0131f21..8289fdb 100644
--- a/src/pkg/runtime/arm/traceback.c
+++ b/src/pkg/runtime/arm/traceback.c
@@ -16,9 +16,9 @@
 	lr = (uintptr)lr0;
 	
 	// If the PC is goexit, it hasn't started yet.
-	if(pc == (uintptr)goexit) {
+	if(pc == (uintptr)runtime·goexit) {
 		pc = (uintptr)g->entry;
-		lr = (uintptr)goexit;
+		lr = (uintptr)runtime·goexit;
 	}
 
 	// If the PC is zero, it's likely a nil function call.
@@ -31,7 +31,7 @@
 	n = 0;
 	stk = (Stktop*)g->stackbase;
 	for(iter = 0; iter < 100 && n < m; iter++) {	// iter avoids looping forever
-		if(pc == (uintptr)·lessstack) {
+		if(pc == (uintptr)runtime·lessstack) {
 			// Hit top of stack segment.  Unwind to next segment.
 			pc = (uintptr)stk->gobuf.pc;
 			sp = stk->gobuf.sp;
@@ -39,7 +39,7 @@
 			stk = (Stktop*)stk->stackbase;
 			continue;
 		}
-		if(pc <= 0x1000 || (f = findfunc(pc-4)) == nil) {
+		if(pc <= 0x1000 || (f = runtime·findfunc(pc-4)) == nil) {
 			// TODO: Check for closure.
 			break;
 		}
@@ -53,24 +53,24 @@
 			// Print during crash.
 			//	main+0xf /home/rsc/go/src/runtime/x.go:23
 			//		main(0x1, 0x2, 0x3)
-			printf("%S", f->name);
+			runtime·printf("%S", f->name);
 			if(pc > f->entry)
-				printf("+%p", (uintptr)(pc - f->entry));
+				runtime·printf("+%p", (uintptr)(pc - f->entry));
 			tracepc = pc;	// back up to CALL instruction for funcline.
 			if(n > 0 && pc > f->entry)
 				tracepc -= sizeof(uintptr);
-			printf(" %S:%d\n", f->src, funcline(f, tracepc));
-			printf("\t%S(", f->name);
+			runtime·printf(" %S:%d\n", f->src, runtime·funcline(f, tracepc));
+			runtime·printf("\t%S(", f->name);
 			for(i = 0; i < f->args; i++) {
 				if(i != 0)
-					prints(", ");
-				·printhex(((uintptr*)sp)[1+i]);
+					runtime·prints(", ");
+				runtime·printhex(((uintptr*)sp)[1+i]);
 				if(i >= 4) {
-					prints(", ...");
+					runtime·prints(", ...");
 					break;
 				}
 			}
-			prints(")\n");
+			runtime·prints(")\n");
 			n++;
 		}
 		
@@ -85,19 +85,19 @@
 }
 
 void
-traceback(byte *pc0, byte *sp, byte *lr, G *g)
+runtime·traceback(byte *pc0, byte *sp, byte *lr, G *g)
 {
 	gentraceback(pc0, sp, lr, g, 0, nil, 100);
 }
 
 // func caller(n int) (pc uintptr, file string, line int, ok bool)
 int32
-callers(int32 skip, uintptr *pcbuf, int32 m)
+runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
 {
 	byte *pc, *sp;
 	
-	sp = getcallersp(&skip);
-	pc = ·getcallerpc(&skip);
+	sp = runtime·getcallersp(&skip);
+	pc = runtime·getcallerpc(&skip);
 
 	return gentraceback(pc, sp, 0, g, skip, pcbuf, m);
 }
diff --git a/src/pkg/runtime/arm/vlop.s b/src/pkg/runtime/arm/vlop.s
index f95f0f1..cda2be6 100644
--- a/src/pkg/runtime/arm/vlop.s
+++ b/src/pkg/runtime/arm/vlop.s
@@ -30,7 +30,7 @@
 
 /* replaced use of R10 by R11 because the former can be the data segment base register */
 
-TEXT	_mulv(SB), $0
+TEXT _mulv(SB), $0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R2	/* l0 */
 	MOVW	8(FP), R11	/* h0 */
@@ -52,7 +52,7 @@
 CC	= 3
 TMP	= 11
 
-TEXT	save<>(SB), 7, $0
+TEXT save<>(SB), 7, $0
 	MOVW	R(Q), 0(FP)
 	MOVW	R(N), 4(FP)
 	MOVW	R(D), 8(FP)
@@ -66,7 +66,7 @@
 /*	  MOVW	-1(R(D)), R(TMP)	/* divide by zero fault */
 s1:	 RET
 
-TEXT	rest<>(SB), 7, $0
+TEXT rest<>(SB), 7, $0
 	MOVW	0(FP), R(Q)
 	MOVW	4(FP), R(N)
 	MOVW	8(FP), R(D)
@@ -79,7 +79,7 @@
 	ADD	$20, R13
 	B	(R14)
 
-TEXT	div<>(SB), 7, $0
+TEXT div<>(SB), 7, $0
 	MOVW	$32, R(CC)
 /*
  * skip zeros 8-at-a-time
@@ -114,7 +114,7 @@
 	BNE	loop
 	RET
 
-TEXT	_div(SB), 7, $16
+TEXT _div(SB), 7, $16
 	BL	save<>(SB)
 	CMP	$0, R(Q)
 	BGE	d1
@@ -135,7 +135,7 @@
 	RSB	$0, R(Q), R(TMP)
 	B	out
 
-TEXT	_mod(SB), 7, $16
+TEXT _mod(SB), 7, $16
 	BL	save<>(SB)
 	CMP	$0, R(D)
 	RSB.LT	$0, R(D), R(D)
@@ -150,13 +150,13 @@
 	MOVW	R(N), R(TMP)
 	B	out
 
-TEXT	_divu(SB), 7, $16
+TEXT _divu(SB), 7, $16
 	BL	save<>(SB)
 	BL	div<>(SB)
 	MOVW	R(Q), R(TMP)
 	B	out
 
-TEXT	_modu(SB), 7, $16
+TEXT _modu(SB), 7, $16
 	BL	save<>(SB)
 	BL	div<>(SB)
 	MOVW	R(N), R(TMP)
@@ -169,7 +169,7 @@
 // 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), 7, $64 // 4 arg + 14*4 saved regs + cpsr
+TEXT _sfloat(SB), 7, $64 // 4 arg + 14*4 saved regs + cpsr
 	MOVW	R14, 4(R13)
 	MOVW	R0, 8(R13)
 	MOVW	$12(R13), R0
diff --git a/src/pkg/runtime/arm/vlrt.c b/src/pkg/runtime/arm/vlrt.c
index 51ae15b..804a67e 100644
--- a/src/pkg/runtime/arm/vlrt.c
+++ b/src/pkg/runtime/arm/vlrt.c
@@ -24,7 +24,7 @@
 // THE SOFTWARE.
 
 // declared here to avoid include of runtime.h
-void	panicstring(char*);
+void	runtime·panicstring(char*);
 
 typedef unsigned long   ulong;
 typedef unsigned int    uint;
@@ -35,9 +35,9 @@
 #define SIGN(n) (1UL<<(n-1))
 
 void
-panicdivide(void)
+runtime·panicdivide(void)
 {
-	panicstring("integer divide by zero");
+	runtime·panicstring("integer divide by zero");
 }
 
 typedef struct  Vlong   Vlong;
@@ -60,7 +60,7 @@
 	};
 };
 
-void    abort(void);
+void    runtime·abort(void);
 
 void
 _addv(Vlong *r, Vlong a, Vlong b)
@@ -152,7 +152,7 @@
 }
 
 void
-·float64toint64(double d, Vlong y)
+runtime·float64toint64(double d, Vlong y)
 {
 	_d2v(&y, d);
 }
@@ -178,7 +178,7 @@
 }
 
 void
-·int64tofloat64(Vlong y, double d)
+runtime·int64tofloat64(Vlong y, double d)
 {
 	d = _v2d(y);
 }
@@ -199,7 +199,7 @@
 	 * get a divide by zero
 	 */
 	if(denlo==0 && denhi==0) {
-		panicdivide();
+		runtime·panicdivide();
 	}
 
 	/*
@@ -259,7 +259,7 @@
 }
 
 void
-·uint64div(Vlong n, Vlong d, Vlong q)
+runtime·uint64div(Vlong n, Vlong d, Vlong q)
 {
 	_divvu(&q, n, d);
 }
@@ -277,7 +277,7 @@
 }
 
 void
-·uint64mod(Vlong n, Vlong d, Vlong q)
+runtime·uint64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modvu(&q, n, d);
 }
@@ -322,7 +322,7 @@
 }
 
 void
-·int64div(Vlong n, Vlong d, Vlong q)
+runtime·int64div(Vlong n, Vlong d, Vlong q)
 {
 	_divv(&q, n, d);
 }
@@ -349,7 +349,7 @@
 }
 
 void
-·int64mod(Vlong n, Vlong d, Vlong q)
+runtime·int64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modv(&q, n, d);
 }
@@ -502,7 +502,7 @@
 	u = *ret;
 	switch(type) {
 	default:
-		abort();
+		runtime·abort();
 		break;
 
 	case 1: /* schar */
diff --git a/src/pkg/runtime/cgocall.c b/src/pkg/runtime/cgocall.c
index 7571694..b2852be 100644
--- a/src/pkg/runtime/cgocall.c
+++ b/src/pkg/runtime/cgocall.c
@@ -7,16 +7,16 @@
 
 void *initcgo;	/* filled in by dynamic linker when Cgo is available */
 int64 ncgocall;
-void ·entersyscall(void);
-void ·exitsyscall(void);
+void runtime·entersyscall(void);
+void runtime·exitsyscall(void);
 
 void
-cgocall(void (*fn)(void*), void *arg)
+runtime·cgocall(void (*fn)(void*), void *arg)
 {
 	G *oldlock;
 
 	if(initcgo == nil)
-		throw("cgocall unavailable");
+		runtime·throw("cgocall unavailable");
 
 	ncgocall++;
 
@@ -34,9 +34,9 @@
 	 * M to run goroutines while we are in the
 	 * foreign code.
 	 */
-	·entersyscall();
-	runcgo(fn, arg);
-	·exitsyscall();
+	runtime·entersyscall();
+	runtime·runcgo(fn, arg);
+	runtime·exitsyscall();
 
 	m->lockedg = oldlock;
 	if(oldlock == nil)
@@ -51,38 +51,38 @@
 // arguments back where they came from, and finally returns to the old
 // stack.
 void
-cgocallback(void (*fn)(void), void *arg, int32 argsize)
+runtime·cgocallback(void (*fn)(void), void *arg, int32 argsize)
 {
 	Gobuf oldsched, oldg1sched;
 	G *g1;
 	void *sp;
 
 	if(g != m->g0)
-		throw("bad g in cgocallback");
+		runtime·throw("bad g in cgocallback");
 
 	g1 = m->curg;
 	oldsched = m->sched;
 	oldg1sched = g1->sched;
 
-	startcgocallback(g1);
+	runtime·startcgocallback(g1);
 
 	sp = g1->sched.sp - argsize;
 	if(sp < g1->stackguard)
-		throw("g stack overflow in cgocallback");
-	mcpy(sp, arg, argsize);
+		runtime·throw("g stack overflow in cgocallback");
+	runtime·mcpy(sp, arg, argsize);
 
-	runcgocallback(g1, sp, fn);
+	runtime·runcgocallback(g1, sp, fn);
 
-	mcpy(arg, sp, argsize);
+	runtime·mcpy(arg, sp, argsize);
 
-	endcgocallback(g1);
+	runtime·endcgocallback(g1);
 
 	m->sched = oldsched;
 	g1->sched = oldg1sched;
 }
 
 void
-·Cgocalls(int64 ret)
+runtime·Cgocalls(int64 ret)
 {
 	ret = ncgocall;
 	FLUSH(&ret);
@@ -92,7 +92,7 @@
 void (*_cgo_free)(void*);
 
 void*
-cmalloc(uintptr n)
+runtime·cmalloc(uintptr n)
 {
 	struct a {
 		uint64 n;
@@ -101,13 +101,13 @@
 
 	a.n = n;
 	a.ret = nil;
-	cgocall(_cgo_malloc, &a);
+	runtime·cgocall(_cgo_malloc, &a);
 	return a.ret;
 }
 
 void
-cfree(void *p)
+runtime·cfree(void *p)
 {
-	cgocall(_cgo_free, p);
+	runtime·cgocall(_cgo_free, p);
 }
 
diff --git a/src/pkg/runtime/cgocall.h b/src/pkg/runtime/cgocall.h
index 9cdb409..1ad954e 100644
--- a/src/pkg/runtime/cgocall.h
+++ b/src/pkg/runtime/cgocall.h
@@ -6,7 +6,7 @@
  * Cgo interface.
  */
 
-void cgocall(void (*fn)(void*), void*);
-void cgocallback(void (*fn)(void), void*, int32);
-void *cmalloc(uintptr);
-void cfree(void*);
+void runtime·cgocall(void (*fn)(void*), void*);
+void runtime·cgocallback(void (*fn)(void), void*, int32);
+void *runtime·cmalloc(uintptr);
+void runtime·cfree(void*);
diff --git a/src/pkg/runtime/chan.c b/src/pkg/runtime/chan.c
index d011599..94ea513 100644
--- a/src/pkg/runtime/chan.c
+++ b/src/pkg/runtime/chan.c
@@ -90,24 +90,24 @@
 static	void	destroychan(Hchan*);
 
 Hchan*
-makechan(Type *elem, int64 hint)
+runtime·makechan_c(Type *elem, int64 hint)
 {
 	Hchan *c;
 	int32 i;
 
 	if(hint < 0 || (int32)hint != hint || hint > ((uintptr)-1) / elem->size)
-		panicstring("makechan: size out of range");
+		runtime·panicstring("makechan: size out of range");
 
-	if(elem->alg >= nelem(algarray)) {
-		printf("chan(alg=%d)\n", elem->alg);
-		throw("runtime.makechan: unsupported elem type");
+	if(elem->alg >= nelem(runtime·algarray)) {
+		runtime·printf("chan(alg=%d)\n", elem->alg);
+		runtime·throw("runtime.makechan: unsupported elem type");
 	}
 
-	c = mal(sizeof(*c));
-	addfinalizer(c, destroychan, 0);
+	c = runtime·mal(sizeof(*c));
+	runtime·addfinalizer(c, destroychan, 0);
 
 	c->elemsize = elem->size;
-	c->elemalg = &algarray[elem->alg];
+	c->elemalg = &runtime·algarray[elem->alg];
 	c->elemalign = elem->align;
 
 	if(hint > 0) {
@@ -117,7 +117,7 @@
 		b = nil;
 		e = nil;
 		for(i=0; i<hint; i++) {
-			d = mal(sizeof(*d) + c->elemsize - sizeof(d->elem));
+			d = runtime·mal(sizeof(*d) + c->elemsize - sizeof(d->elem));
 			if(e == nil)
 				e = d;
 			d->link = b;
@@ -131,7 +131,7 @@
 	}
 
 	if(debug)
-		printf("makechan: chan=%p; elemsize=%D; elemalg=%d; elemalign=%d; dataqsiz=%d\n",
+		runtime·printf("makechan: chan=%p; elemsize=%D; elemalg=%d; elemalign=%d; dataqsiz=%d\n",
 			c, (int64)elem->size, elem->alg, elem->align, c->dataqsiz);
 
 	return c;
@@ -140,15 +140,15 @@
 static void
 destroychan(Hchan *c)
 {
-	destroylock(&c->Lock);
+	runtime·destroylock(&c->Lock);
 }
 
 
 // makechan(elem *Type, hint int64) (hchan *chan any);
 void
-·makechan(Type *elem, int64 hint, Hchan *ret)
+runtime·makechan(Type *elem, int64 hint, Hchan *ret)
 {
-	ret = makechan(elem, hint);
+	ret = runtime·makechan_c(elem, hint);
 	FLUSH(&ret);
 }
 
@@ -158,7 +158,7 @@
 	c->closed += Eincr;
 	if(c->closed & Emax) {
 		// Note that channel locks may still be held at this point.
-		throw("too many operations on a closed channel");
+		runtime·throw("too many operations on a closed channel");
 	}
 }
 
@@ -177,24 +177,24 @@
  * the operation; we'll see that it's now closed.
  */
 void
-chansend(Hchan *c, byte *ep, bool *pres)
+runtime·chansend(Hchan *c, byte *ep, bool *pres)
 {
 	SudoG *sg;
 	G* gp;
 
 	if(c == nil)
-		panicstring("send to nil channel");
+		runtime·panicstring("send to nil channel");
 
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
 	if(debug) {
-		printf("chansend: chan=%p; elem=", c);
+		runtime·printf("chansend: chan=%p; elem=", c);
 		c->elemalg->print(c->elemsize, ep);
-		prints("\n");
+		runtime·prints("\n");
 	}
 
-	lock(c);
+	runtime·lock(c);
 loop:
 	if(c->closed & Wclosed)
 		goto closed;
@@ -209,8 +209,8 @@
 
 		gp = sg->g;
 		gp->param = sg;
-		unlock(c);
-		ready(gp);
+		runtime·unlock(c);
+		runtime·ready(gp);
 
 		if(pres != nil)
 			*pres = true;
@@ -218,7 +218,7 @@
 	}
 
 	if(pres != nil) {
-		unlock(c);
+		runtime·unlock(c);
 		*pres = false;
 		return;
 	}
@@ -229,15 +229,15 @@
 	g->param = nil;
 	g->status = Gwaiting;
 	enqueue(&c->sendq, sg);
-	unlock(c);
-	gosched();
+	runtime·unlock(c);
+	runtime·gosched();
 
-	lock(c);
+	runtime·lock(c);
 	sg = g->param;
 	if(sg == nil)
 		goto loop;
 	freesg(c, sg);
-	unlock(c);
+	runtime·unlock(c);
 	return;
 
 asynch:
@@ -246,17 +246,17 @@
 
 	if(c->qcount >= c->dataqsiz) {
 		if(pres != nil) {
-			unlock(c);
+			runtime·unlock(c);
 			*pres = false;
 			return;
 		}
 		sg = allocsg(c);
 		g->status = Gwaiting;
 		enqueue(&c->sendq, sg);
-		unlock(c);
-		gosched();
+		runtime·unlock(c);
+		runtime·gosched();
 
-		lock(c);
+		runtime·lock(c);
 		goto asynch;
 	}
 	if(ep != nil)
@@ -268,10 +268,10 @@
 	if(sg != nil) {
 		gp = sg->g;
 		freesg(c, sg);
-		unlock(c);
-		ready(gp);
+		runtime·unlock(c);
+		runtime·ready(gp);
 	} else
-		unlock(c);
+		runtime·unlock(c);
 	if(pres != nil)
 		*pres = true;
 	return;
@@ -280,25 +280,25 @@
 	incerr(c);
 	if(pres != nil)
 		*pres = true;
-	unlock(c);
+	runtime·unlock(c);
 }
 
 void
-chanrecv(Hchan* c, byte *ep, bool* pres)
+runtime·chanrecv(Hchan* c, byte *ep, bool* pres)
 {
 	SudoG *sg;
 	G *gp;
 
 	if(c == nil)
-		panicstring("receive from nil channel");
+		runtime·panicstring("receive from nil channel");
 
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
 	if(debug)
-		printf("chanrecv: chan=%p\n", c);
+		runtime·printf("chanrecv: chan=%p\n", c);
 
-	lock(c);
+	runtime·lock(c);
 loop:
 	if(c->dataqsiz > 0)
 		goto asynch;
@@ -313,8 +313,8 @@
 
 		gp = sg->g;
 		gp->param = sg;
-		unlock(c);
-		ready(gp);
+		runtime·unlock(c);
+		runtime·ready(gp);
 
 		if(pres != nil)
 			*pres = true;
@@ -322,7 +322,7 @@
 	}
 
 	if(pres != nil) {
-		unlock(c);
+		runtime·unlock(c);
 		c->elemalg->copy(c->elemsize, ep, nil);
 		*pres = false;
 		return;
@@ -332,10 +332,10 @@
 	g->param = nil;
 	g->status = Gwaiting;
 	enqueue(&c->recvq, sg);
-	unlock(c);
-	gosched();
+	runtime·unlock(c);
+	runtime·gosched();
 
-	lock(c);
+	runtime·lock(c);
 	sg = g->param;
 	if(sg == nil)
 		goto loop;
@@ -343,7 +343,7 @@
 	c->elemalg->copy(c->elemsize, ep, sg->elem);
 	c->elemalg->copy(c->elemsize, sg->elem, nil);
 	freesg(c, sg);
-	unlock(c);
+	runtime·unlock(c);
 	return;
 
 asynch:
@@ -352,7 +352,7 @@
 			goto closed;
 
 		if(pres != nil) {
-			unlock(c);
+			runtime·unlock(c);
 			c->elemalg->copy(c->elemsize, ep, nil);
 			*pres = false;
 			return;
@@ -360,10 +360,10 @@
 		sg = allocsg(c);
 		g->status = Gwaiting;
 		enqueue(&c->recvq, sg);
-		unlock(c);
-		gosched();
+		runtime·unlock(c);
+		runtime·gosched();
 
-		lock(c);
+		runtime·lock(c);
 		goto asynch;
 	}
 	c->elemalg->copy(c->elemsize, ep, c->recvdataq->elem);
@@ -374,14 +374,14 @@
 	if(sg != nil) {
 		gp = sg->g;
 		freesg(c, sg);
-		unlock(c);
-		ready(gp);
+		runtime·unlock(c);
+		runtime·ready(gp);
 		if(pres != nil)
 			*pres = true;
 		return;
 	}
 
-	unlock(c);
+	runtime·unlock(c);
 	if(pres != nil)
 		*pres = true;
 	return;
@@ -392,102 +392,102 @@
 	incerr(c);
 	if(pres != nil)
 		*pres = true;
-	unlock(c);
+	runtime·unlock(c);
 }
 
 // chansend1(hchan *chan any, elem any);
 #pragma textflag 7
 void
-·chansend1(Hchan* c, ...)
+runtime·chansend1(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae;
 
 	if(c == nil)
-		panicstring("send to nil channel");
+		runtime·panicstring("send to nil channel");
 
-	o = rnd(sizeof(c), c->elemalign);
+	o = runtime·rnd(sizeof(c), c->elemalign);
 	ae = (byte*)&c + o;
-	chansend(c, ae, nil);
+	runtime·chansend(c, ae, nil);
 }
 
 // chansend2(hchan *chan any, elem any) (pres bool);
 #pragma textflag 7
 void
-·chansend2(Hchan* c, ...)
+runtime·chansend2(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae, *ap;
 
 	if(c == nil)
-		panicstring("send to nil channel");
+		runtime·panicstring("send to nil channel");
 
-	o = rnd(sizeof(c), c->elemalign);
+	o = runtime·rnd(sizeof(c), c->elemalign);
 	ae = (byte*)&c + o;
-	o = rnd(o+c->elemsize, Structrnd);
+	o = runtime·rnd(o+c->elemsize, Structrnd);
 	ap = (byte*)&c + o;
 
-	chansend(c, ae, ap);
+	runtime·chansend(c, ae, ap);
 }
 
 // chanrecv1(hchan *chan any) (elem any);
 #pragma textflag 7
 void
-·chanrecv1(Hchan* c, ...)
+runtime·chanrecv1(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae;
 
-	o = rnd(sizeof(c), Structrnd);
+	o = runtime·rnd(sizeof(c), Structrnd);
 	ae = (byte*)&c + o;
 
-	chanrecv(c, ae, nil);
+	runtime·chanrecv(c, ae, nil);
 }
 
 // chanrecv2(hchan *chan any) (elem any, pres bool);
 #pragma textflag 7
 void
-·chanrecv2(Hchan* c, ...)
+runtime·chanrecv2(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae, *ap;
 
-	o = rnd(sizeof(c), Structrnd);
+	o = runtime·rnd(sizeof(c), Structrnd);
 	ae = (byte*)&c + o;
-	o = rnd(o+c->elemsize, 1);
+	o = runtime·rnd(o+c->elemsize, 1);
 	ap = (byte*)&c + o;
 
-	chanrecv(c, ae, ap);
+	runtime·chanrecv(c, ae, ap);
 }
 
 // newselect(size uint32) (sel *byte);
 #pragma textflag 7
 void
-·newselect(int32 size, ...)
+runtime·newselect(int32 size, ...)
 {
 	int32 n, o;
 	Select **selp;
 	Select *sel;
 
-	o = rnd(sizeof(size), Structrnd);
+	o = runtime·rnd(sizeof(size), Structrnd);
 	selp = (Select**)((byte*)&size + o);
 	n = 0;
 	if(size > 1)
 		n = size-1;
 
-	sel = mal(sizeof(*sel) + n*sizeof(sel->scase[0]));
+	sel = runtime·mal(sizeof(*sel) + n*sizeof(sel->scase[0]));
 
 	sel->tcase = size;
 	sel->ncase = 0;
 	*selp = sel;
 	if(debug)
-		printf("newselect s=%p size=%d\n", sel, size);
+		runtime·printf("newselect s=%p size=%d\n", sel, size);
 }
 
 // selectsend(sel *byte, hchan *chan any, elem any) (selected bool);
 #pragma textflag 7
 void
-·selectsend(Select *sel, Hchan *c, ...)
+runtime·selectsend(Select *sel, Hchan *c, ...)
 {
 	int32 i, eo;
 	Scase *cas;
@@ -499,31 +499,31 @@
 
 	i = sel->ncase;
 	if(i >= sel->tcase)
-		throw("selectsend: too many cases");
+		runtime·throw("selectsend: too many cases");
 	sel->ncase = i+1;
-	cas = mal(sizeof *cas + c->elemsize - sizeof(cas->u.elem));
+	cas = runtime·mal(sizeof *cas + c->elemsize - sizeof(cas->u.elem));
 	sel->scase[i] = cas;
 
-	cas->pc = ·getcallerpc(&sel);
+	cas->pc = runtime·getcallerpc(&sel);
 	cas->chan = c;
 
-	eo = rnd(sizeof(sel), sizeof(c));
-	eo = rnd(eo+sizeof(c), c->elemsize);
-	cas->so = rnd(eo+c->elemsize, Structrnd);
+	eo = runtime·rnd(sizeof(sel), sizeof(c));
+	eo = runtime·rnd(eo+sizeof(c), c->elemsize);
+	cas->so = runtime·rnd(eo+c->elemsize, Structrnd);
 	cas->send = 1;
 
 	ae = (byte*)&sel + eo;
 	c->elemalg->copy(c->elemsize, cas->u.elem, ae);
 
 	if(debug)
-		printf("selectsend s=%p pc=%p chan=%p so=%d send=%d\n",
+		runtime·printf("selectsend s=%p pc=%p chan=%p so=%d send=%d\n",
 			sel, cas->pc, cas->chan, cas->so, cas->send);
 }
 
 // selectrecv(sel *byte, hchan *chan any, elem *any) (selected bool);
 #pragma textflag 7
 void
-·selectrecv(Select *sel, Hchan *c, ...)
+runtime·selectrecv(Select *sel, Hchan *c, ...)
 {
 	int32 i, eo;
 	Scase *cas;
@@ -534,21 +534,21 @@
 
 	i = sel->ncase;
 	if(i >= sel->tcase)
-		throw("selectrecv: too many cases");
+		runtime·throw("selectrecv: too many cases");
 	sel->ncase = i+1;
-	cas = mal(sizeof *cas);
+	cas = runtime·mal(sizeof *cas);
 	sel->scase[i] = cas;
-	cas->pc = ·getcallerpc(&sel);
+	cas->pc = runtime·getcallerpc(&sel);
 	cas->chan = c;
 
-	eo = rnd(sizeof(sel), sizeof(c));
-	eo = rnd(eo+sizeof(c), sizeof(byte*));
-	cas->so = rnd(eo+sizeof(byte*), Structrnd);
+	eo = runtime·rnd(sizeof(sel), sizeof(c));
+	eo = runtime·rnd(eo+sizeof(c), sizeof(byte*));
+	cas->so = runtime·rnd(eo+sizeof(byte*), Structrnd);
 	cas->send = 0;
 	cas->u.elemp = *(byte**)((byte*)&sel + eo);
 
 	if(debug)
-		printf("selectrecv s=%p pc=%p chan=%p so=%d send=%d\n",
+		runtime·printf("selectrecv s=%p pc=%p chan=%p so=%d send=%d\n",
 			sel, cas->pc, cas->chan, cas->so, cas->send);
 }
 
@@ -556,26 +556,26 @@
 // selectdefaul(sel *byte) (selected bool);
 #pragma textflag 7
 void
-·selectdefault(Select *sel, ...)
+runtime·selectdefault(Select *sel, ...)
 {
 	int32 i;
 	Scase *cas;
 
 	i = sel->ncase;
 	if(i >= sel->tcase)
-		throw("selectdefault: too many cases");
+		runtime·throw("selectdefault: too many cases");
 	sel->ncase = i+1;
-	cas = mal(sizeof *cas);
+	cas = runtime·mal(sizeof *cas);
 	sel->scase[i] = cas;
-	cas->pc = ·getcallerpc(&sel);
+	cas->pc = runtime·getcallerpc(&sel);
 	cas->chan = nil;
 
-	cas->so = rnd(sizeof(sel), Structrnd);
+	cas->so = runtime·rnd(sizeof(sel), Structrnd);
 	cas->send = 2;
 	cas->u.elemp = nil;
 
 	if(debug)
-		printf("selectdefault s=%p pc=%p so=%d send=%d\n",
+		runtime·printf("selectdefault s=%p pc=%p so=%d send=%d\n",
 			sel, cas->pc, cas->so, cas->send);
 }
 
@@ -585,8 +585,8 @@
 	uint32 i;
 
 	for(i=0; i<sel->ncase; i++)
-		free(sel->scase[i]);
-	free(sel);
+		runtime·free(sel->scase[i]);
+	runtime·free(sel);
 }
 
 static void
@@ -599,7 +599,7 @@
 	for(i=0; i<sel->ncase; i++) {
 		if(sel->scase[i]->chan != c) {
 			c = sel->scase[i]->chan;
-			lock(c);
+			runtime·lock(c);
 		}
 	}
 }
@@ -614,7 +614,7 @@
 	for(i=sel->ncase; i>0; i--) {
 		if(sel->scase[i-1]->chan && sel->scase[i-1]->chan != c) {
 			c = sel->scase[i-1]->chan;
-			unlock(c);
+			runtime·unlock(c);
 		}
 	}
 }
@@ -627,7 +627,7 @@
 // that's less than StackGuard-StackSmall, so okay.
 #pragma textflag 7
 void
-·selectgo(Select *sel)
+runtime·selectgo(Select *sel)
 {
 	uint32 p, o, i, j;
 	Scase *cas, *dfl;
@@ -636,16 +636,16 @@
 	G *gp;
 	byte *as;
 
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
 	if(debug)
-		printf("select: sel=%p\n", sel);
+		runtime·printf("select: sel=%p\n", sel);
 
 	if(sel->ncase < 2) {
 		if(sel->ncase < 1) {
 			g->status = Gwaiting;	// forever
-			gosched();
+			runtime·gosched();
 		}
 		// TODO: make special case of one.
 	}
@@ -656,7 +656,7 @@
 		if(gcd(p, sel->ncase) == 1)
 			break;
 		if(i > 1000)
-			throw("select: failed to select prime");
+			runtime·throw("select: failed to select prime");
 	}
 
 	// select an initial offset
@@ -736,10 +736,10 @@
 		case 0:	// recv
 			if(c->dataqsiz > 0) {
 				if(c->qcount > 0)
-					throw("select: pass 2 async recv");
+					runtime·throw("select: pass 2 async recv");
 			} else {
 				if(dequeue(&c->sendq, c))
-					throw("select: pass 2 sync recv");
+					runtime·throw("select: pass 2 sync recv");
 			}
 			enqueue(&c->recvq, sg);
 			break;
@@ -747,10 +747,10 @@
 		case 1:	// send
 			if(c->dataqsiz > 0) {
 				if(c->qcount < c->dataqsiz)
-					throw("select: pass 2 async send");
+					runtime·throw("select: pass 2 async send");
 			} else {
 				if(dequeue(&c->recvq, c))
-					throw("select: pass 2 sync send");
+					runtime·throw("select: pass 2 sync send");
 				c->elemalg->copy(c->elemsize, sg->elem, cas->u.elem);
 			}
 			enqueue(&c->sendq, sg);
@@ -765,7 +765,7 @@
 	g->param = nil;
 	g->status = Gwaiting;
 	selunlock(sel);
-	gosched();
+	runtime·gosched();
 
 	sellock(sel);
 	sg = g->param;
@@ -800,7 +800,7 @@
 	}
 
 	if(debug)
-		printf("wait-return: sel=%p c=%p cas=%p send=%d o=%d\n",
+		runtime·printf("wait-return: sel=%p c=%p cas=%p send=%d o=%d\n",
 			sel, c, cas, cas->send, o);
 
 	if(!cas->send) {
@@ -823,7 +823,7 @@
 	if(sg != nil) {
 		gp = sg->g;
 		freesg(c, sg);
-		ready(gp);
+		runtime·ready(gp);
 	}
 	goto retc;
 
@@ -837,20 +837,20 @@
 	if(sg != nil) {
 		gp = sg->g;
 		freesg(c, sg);
-		ready(gp);
+		runtime·ready(gp);
 	}
 	goto retc;
 
 syncrecv:
 	// can receive from sleeping sender (sg)
 	if(debug)
-		printf("syncrecv: sel=%p c=%p o=%d\n", sel, c, o);
+		runtime·printf("syncrecv: sel=%p c=%p o=%d\n", sel, c, o);
 	if(cas->u.elemp != nil)
 		c->elemalg->copy(c->elemsize, cas->u.elemp, sg->elem);
 	c->elemalg->copy(c->elemsize, sg->elem, nil);
 	gp = sg->g;
 	gp->param = sg;
-	ready(gp);
+	runtime·ready(gp);
 	goto retc;
 
 rclose:
@@ -864,13 +864,13 @@
 syncsend:
 	// can send to sleeping receiver (sg)
 	if(debug)
-		printf("syncsend: sel=%p c=%p o=%d\n", sel, c, o);
+		runtime·printf("syncsend: sel=%p c=%p o=%d\n", sel, c, o);
 	if(c->closed & Wclosed)
 		goto sclose;
 	c->elemalg->copy(c->elemsize, sg->elem, cas->u.elem);
 	gp = sg->g;
 	gp->param = sg;
-	ready(gp);
+	runtime·ready(gp);
 	goto retc;
 
 sclose:
@@ -882,7 +882,7 @@
 	selunlock(sel);
 
 	// return to pc corresponding to chosen case
-	·setcallerpc(&sel, cas->pc);
+	runtime·setcallerpc(&sel, cas->pc);
 	as = (byte*)&sel + cas->so;
 	freesel(sel);
 	*as = true;
@@ -890,15 +890,15 @@
 
 // closechan(sel *byte);
 void
-·closechan(Hchan *c)
+runtime·closechan(Hchan *c)
 {
 	SudoG *sg;
 	G* gp;
 
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
-	lock(c);
+	runtime·lock(c);
 	incerr(c);
 	c->closed |= Wclosed;
 
@@ -910,7 +910,7 @@
 		gp = sg->g;
 		gp->param = nil;
 		freesg(c, sg);
-		ready(gp);
+		runtime·ready(gp);
 	}
 
 	// release all writers
@@ -921,32 +921,32 @@
 		gp = sg->g;
 		gp->param = nil;
 		freesg(c, sg);
-		ready(gp);
+		runtime·ready(gp);
 	}
 
-	unlock(c);
+	runtime·unlock(c);
 }
 
 void
-chanclose(Hchan *c)
+runtime·chanclose(Hchan *c)
 {
-	·closechan(c);
+	runtime·closechan(c);
 }
 
 bool
-chanclosed(Hchan *c)
+runtime·chanclosed(Hchan *c)
 {
 	return (c->closed & Rclosed) != 0;
 }
 
 int32
-chanlen(Hchan *c)
+runtime·chanlen(Hchan *c)
 {
 	return c->qcount;
 }
 
 int32
-chancap(Hchan *c)
+runtime·chancap(Hchan *c)
 {
 	return c->dataqsiz;
 }
@@ -954,9 +954,9 @@
 
 // closedchan(sel *byte) bool;
 void
-·closedchan(Hchan *c, bool closed)
+runtime·closedchan(Hchan *c, bool closed)
 {
-	closed = chanclosed(c);
+	closed = runtime·chanclosed(c);
 	FLUSH(&closed);
 }
 
@@ -972,7 +972,7 @@
 	q->first = sgp->link;
 
 	// if sgp is stale, ignore it
-	if(!cas(&sgp->g->selgen, sgp->selgen, sgp->selgen + 1)) {
+	if(!runtime·cas(&sgp->g->selgen, sgp->selgen, sgp->selgen + 1)) {
 		//prints("INVALID PSEUDOG POINTER\n");
 		freesg(c, sgp);
 		goto loop;
@@ -1017,7 +1017,7 @@
 	if(sg != nil) {
 		c->free = sg->link;
 	} else
-		sg = mal(sizeof(*sg) + c->elemsize - sizeof(sg->elem));
+		sg = runtime·mal(sizeof(*sg) + c->elemsize - sizeof(sg->elem));
 	sg->selgen = g->selgen;
 	sg->g = g;
 	sg->offset = 0;
@@ -1031,7 +1031,7 @@
 {
 	if(sg != nil) {
 		if(sg->isfree)
-			throw("chan.freesg: already free");
+			runtime·throw("chan.freesg: already free");
 		sg->isfree = 1;
 		sg->link = c->free;
 		c->free = sg;
diff --git a/src/pkg/runtime/complex.c b/src/pkg/runtime/complex.c
index 2240d9f..eeb9439 100644
--- a/src/pkg/runtime/complex.c
+++ b/src/pkg/runtime/complex.c
@@ -7,34 +7,34 @@
 typedef struct Complex128 Complex128;
 
 void
-·complex128div(Complex128 n, Complex128 d, Complex128 q)
+runtime·complex128div(Complex128 n, Complex128 d, Complex128 q)
 {
 	int32 ninf, dinf, nnan, dnan;
 	float64 a, b, ratio, denom;
 
 	// Special cases as in C99.
-	ninf = isInf(n.real, 0) || isInf(n.imag, 0);
-	dinf = isInf(d.real, 0) || isInf(d.imag, 0);
+	ninf = runtime·isInf(n.real, 0) || runtime·isInf(n.imag, 0);
+	dinf = runtime·isInf(d.real, 0) || runtime·isInf(d.imag, 0);
 
-	nnan = !ninf && (isNaN(n.real) || isNaN(n.imag));
-	dnan = !dinf && (isNaN(d.real) || isNaN(d.imag));
+	nnan = !ninf && (runtime·isNaN(n.real) || runtime·isNaN(n.imag));
+	dnan = !dinf && (runtime·isNaN(d.real) || runtime·isNaN(d.imag));
 
 	if(nnan || dnan) {
-		q.real = NaN();
-		q.imag = NaN();
+		q.real = runtime·NaN();
+		q.imag = runtime·NaN();
 	} else if(ninf && !dinf && !dnan) {
-		q.real = Inf(0);
-		q.imag = Inf(0);
+		q.real = runtime·Inf(0);
+		q.imag = runtime·Inf(0);
 	} else if(!ninf && !nnan && dinf) {
 		q.real = 0;
 		q.imag = 0;
 	} else if(d.real == 0 && d.imag == 0) {
 		if(n.real == 0 && n.imag == 0) {
-			q.real = NaN();
-			q.imag = NaN();
+			q.real = runtime·NaN();
+			q.imag = runtime·NaN();
 		} else {
-			q.real = Inf(0);
-			q.imag = Inf(0);
+			q.real = runtime·Inf(0);
+			q.imag = runtime·Inf(0);
 		}
 	} else {
 		// Standard complex arithmetic, factored to avoid unnecessary overflow.
diff --git a/src/pkg/runtime/darwin/386/rt0.s b/src/pkg/runtime/darwin/386/rt0.s
index 5b52e91..30b497f 100644
--- a/src/pkg/runtime/darwin/386/rt0.s
+++ b/src/pkg/runtime/darwin/386/rt0.s
@@ -4,5 +4,5 @@
 
 // Darwin and Linux use the same linkage to main
 
-TEXT	_rt0_386_darwin(SB),7,$0
+TEXT _rt0_386_darwin(SB),7,$0
 	JMP	_rt0_386(SB)
diff --git a/src/pkg/runtime/darwin/386/signal.c b/src/pkg/runtime/darwin/386/signal.c
index f7ee3c4..53a4e2f 100644
--- a/src/pkg/runtime/darwin/386/signal.c
+++ b/src/pkg/runtime/darwin/386/signal.c
@@ -8,39 +8,38 @@
 #include "signals.h"
 
 void
-dumpregs(Regs *r)
+runtime·dumpregs(Regs *r)
 {
-	printf("eax     %x\n", r->eax);
-	printf("ebx     %x\n", r->ebx);
-	printf("ecx     %x\n", r->ecx);
-	printf("edx     %x\n", r->edx);
-	printf("edi     %x\n", r->edi);
-	printf("esi     %x\n", r->esi);
-	printf("ebp     %x\n", r->ebp);
-	printf("esp     %x\n", r->esp);
-	printf("eip     %x\n", r->eip);
-	printf("eflags  %x\n", r->eflags);
-	printf("cs      %x\n", r->cs);
-	printf("fs      %x\n", r->fs);
-	printf("gs      %x\n", r->gs);
+	runtime·printf("eax     %x\n", r->eax);
+	runtime·printf("ebx     %x\n", r->ebx);
+	runtime·printf("ecx     %x\n", r->ecx);
+	runtime·printf("edx     %x\n", r->edx);
+	runtime·printf("edi     %x\n", r->edi);
+	runtime·printf("esi     %x\n", r->esi);
+	runtime·printf("ebp     %x\n", r->ebp);
+	runtime·printf("esp     %x\n", r->esp);
+	runtime·printf("eip     %x\n", r->eip);
+	runtime·printf("eflags  %x\n", r->eflags);
+	runtime·printf("cs      %x\n", r->cs);
+	runtime·printf("fs      %x\n", r->fs);
+	runtime·printf("gs      %x\n", r->gs);
 }
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo *info, void *context)
+runtime·sighandler(int32 sig, Siginfo *info, void *context)
 {
 	Ucontext *uc;
 	Mcontext *mc;
 	Regs *r;
 	uintptr *sp;
-	void (*fn)(void);
 	G *gp;
 	byte *pc;
 
@@ -48,7 +47,7 @@
 	mc = uc->uc_mcontext;
 	r = &mc->ss;
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Work around Leopard bug that doesn't set FPE_INTDIV.
 		// Look at instruction to see if it is a divide.
 		// Not necessary in Snow Leopard (si_code will be != 0).
@@ -68,91 +67,91 @@
 		gp->sigcode0 = info->si_code;
 		gp->sigcode1 = (uintptr)info->si_addr;
 
-		// Only push sigpanic if r->eip != 0.
+		// Only push runtime·sigpanic if r->eip != 0.
 		// If r->eip == 0, probably panicked because of a
 		// call to a nil func.  Not pushing that onto sp will
-		// make the trace look like a call to sigpanic instead.
-		// (Otherwise the trace will end at sigpanic and we
+		// make the trace look like a call to runtime·sigpanic instead.
+		// (Otherwise the trace will end at runtime·sigpanic and we
 		// won't get to see who faulted.)
 		if(r->eip != 0) {
 			sp = (uintptr*)r->esp;
 			*--sp = r->eip;
 			r->esp = (uintptr)sp;
 		}
-		r->eip = (uintptr)sigpanic;
+		r->eip = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG){
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	}else{
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 	}
 
-	printf("pc: %x\n", r->eip);
-	printf("\n");
+	runtime·printf("pc: %x\n", r->eip);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->eip, (void*)r->esp, 0, m->curg);
-		tracebackothers(m->curg);
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->eip, (void*)r->esp, 0, m->curg);
+		runtime·tracebackothers(m->curg);
+		runtime·dumpregs(r);
 	}
 
-	breakpoint();
-	exit(2);
+	runtime·breakpoint();
+	runtime·exit(2);
 }
 
 void
-sigignore(int32, Siginfo*, void*)
+runtime·sigignore(int32, Siginfo*, void*)
 {
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	StackT st;
 
 	st.ss_sp = p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	int32 i;
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	sa.sa_flags |= SA_SIGINFO|SA_ONSTACK;
 	sa.sa_mask = 0xFFFFFFFFU;
-	sa.sa_tramp = sigtramp;	// sigtramp's job is to call into real handler
+	sa.sa_tramp = runtime·sigtramp;	// runtime·sigtramp's job is to call into real handler
 	for(i = 0; i<NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue)) {
-				sa.__sigaction_u.__sa_sigaction = sighandler;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue)) {
+				sa.__sigaction_u.__sa_sigaction = runtime·sighandler;
 			} else {
-				sa.__sigaction_u.__sa_sigaction = sigignore;
+				sa.__sigaction_u.__sa_sigaction = runtime·sigignore;
 			}
-			if(sigtab[i].flags & SigRestart)
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
-			sigaction(i, &sa, nil);
+			runtime·sigaction(i, &sa, nil);
 		}
 	}
 }
diff --git a/src/pkg/runtime/darwin/386/sys.s b/src/pkg/runtime/darwin/386/sys.s
index 40c82f32..a2067e4 100644
--- a/src/pkg/runtime/darwin/386/sys.s
+++ b/src/pkg/runtime/darwin/386/sys.s
@@ -8,47 +8,47 @@
 
 #include "386/asm.h"
 
-TEXT notok(SB),7,$0
+TEXT runtime·notok(SB),7,$0
 	MOVL	$0xf1, 0xf1
 	RET
 
 // Exit the entire program (like C exit)
-TEXT exit(SB),7,$0
+TEXT runtime·exit(SB),7,$0
 	MOVL	$1, AX
 	INT	$0x80
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // Exit this OS thread (like pthread_exit, which eventually
 // calls __bsdthread_terminate).
-TEXT exit1(SB),7,$0
+TEXT runtime·exit1(SB),7,$0
 	MOVL	$361, AX
 	INT	$0x80
 	JAE 2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT write(SB),7,$0
+TEXT runtime·write(SB),7,$0
 	MOVL	$4, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT ·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVL	$197, AX
 	INT	$0x80
 	RET
 
-TEXT ·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	MOVL	$73, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // void gettime(int64 *sec, int32 *usec)
-TEXT gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
 	LEAL	12(SP), AX	// must be non-nil, unused
 	MOVL	AX, 4(SP)
 	MOVL	$0, 8(SP)	// time zone pointer
@@ -63,11 +63,11 @@
 	MOVL	DX, (DI)
 	RET
 
-TEXT sigaction(SB),7,$0
+TEXT runtime·sigaction(SB),7,$0
 	MOVL	$46, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // Sigtramp's job is to call the actual signal handler.
@@ -78,7 +78,7 @@
 //	12(FP)	signal number
 //	16(FP)	siginfo
 //	20(FP)	context
-TEXT sigtramp(SB),7,$40
+TEXT runtime·sigtramp(SB),7,$40
 	get_tls(CX)
 
 	// save g
@@ -114,19 +114,19 @@
 	MOVL	BX, 8(SP)
 	MOVL	$184, AX	// sigreturn(ucontext, infostyle)
 	INT	$0x80
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),7,$0
 	MOVL	$53, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // void bsdthread_create(void *stk, M *m, G *g, void (*fn)(void))
 // System call args are: func arg stack pthread flags.
-TEXT bsdthread_create(SB),7,$32
+TEXT runtime·bsdthread_create(SB),7,$32
 	MOVL	$360, AX
 	// 0(SP) is where the caller PC would be; kernel skips it
 	MOVL	func+12(FP), BX
@@ -155,7 +155,7 @@
 //	DI = stack top
 //	SI = flags (= 0x1000000)
 //	SP = stack - C_32_STK_ALIGN
-TEXT bsdthread_start(SB),7,$0
+TEXT runtime·bsdthread_start(SB),7,$0
 	// set up ldt 7+id to point at m->tls.
 	// m->tls is at m+40.  newosproc left
 	// the m->id in tls[0].
@@ -167,7 +167,7 @@
 	PUSHL	$32	// sizeof tls
 	PUSHL	BP	// &tls
 	PUSHL	DI	// tls #
-	CALL	setldt(SB)
+	CALL	runtime·setldt(SB)
 	POPL	AX
 	POPL	AX
 	POPL	AX
@@ -178,18 +178,18 @@
 	MOVL	AX, g(BP)
 	MOVL	DX, m(BP)
 	MOVL	BX, m_procid(DX)	// m->procid = thread port (for debuggers)
-	CALL	stackcheck(SB)		// smashes AX
+	CALL	runtime·stackcheck(SB)		// smashes AX
 	CALL	CX	// fn()
-	CALL	exit1(SB)
+	CALL	runtime·exit1(SB)
 	RET
 
 // void bsdthread_register(void)
 // registers callbacks for threadstart (see bsdthread_create above
 // and wqthread and pthsize (not used).  returns 0 on success.
-TEXT bsdthread_register(SB),7,$40
+TEXT runtime·bsdthread_register(SB),7,$40
 	MOVL	$366, AX
 	// 0(SP) is where kernel expects caller PC; ignored
-	MOVL	$bsdthread_start(SB), 4(SP)	// threadstart
+	MOVL	$runtime·bsdthread_start(SB), 4(SP)	// threadstart
 	MOVL	$0, 8(SP)	// wqthread, not used by us
 	MOVL	$0, 12(SP)	// pthsize, not used by us
 	MOVL	$0, 16(SP)	// dummy_value [sic]
@@ -197,7 +197,7 @@
 	MOVL	$0, 24(SP)	// dispatchqueue_offset
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // Invoke Mach system call.
@@ -211,57 +211,57 @@
 // in the high 16 bits that seems to be the
 // argument count in bytes but is not always.
 // INT $0x80 works fine for those.
-TEXT sysenter(SB),7,$0
+TEXT runtime·sysenter(SB),7,$0
 	POPL	DX
 	MOVL	SP, CX
 	BYTE $0x0F; BYTE $0x34;  // SYSENTER
 	// returns to DX with SP set to CX
 
-TEXT mach_msg_trap(SB),7,$0
+TEXT runtime·mach_msg_trap(SB),7,$0
 	MOVL	$-31, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
-TEXT mach_reply_port(SB),7,$0
+TEXT runtime·mach_reply_port(SB),7,$0
 	MOVL	$-26, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
-TEXT mach_task_self(SB),7,$0
+TEXT runtime·mach_task_self(SB),7,$0
 	MOVL	$-28, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
 // Mach provides trap versions of the semaphore ops,
 // instead of requiring the use of RPC.
 
 // uint32 mach_semaphore_wait(uint32)
-TEXT mach_semaphore_wait(SB),7,$0
+TEXT runtime·mach_semaphore_wait(SB),7,$0
 	MOVL	$-36, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
 // uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
-TEXT mach_semaphore_timedwait(SB),7,$0
+TEXT runtime·mach_semaphore_timedwait(SB),7,$0
 	MOVL	$-38, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
 // uint32 mach_semaphore_signal(uint32)
-TEXT mach_semaphore_signal(SB),7,$0
+TEXT runtime·mach_semaphore_signal(SB),7,$0
 	MOVL	$-33, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
 // uint32 mach_semaphore_signal_all(uint32)
-TEXT mach_semaphore_signal_all(SB),7,$0
+TEXT runtime·mach_semaphore_signal_all(SB),7,$0
 	MOVL	$-34, AX
-	CALL	sysenter(SB)
+	CALL	runtime·sysenter(SB)
 	RET
 
 // setldt(int entry, int address, int limit)
 // entry and limit are ignored.
-TEXT setldt(SB),7,$32
+TEXT runtime·setldt(SB),7,$32
 	MOVL	address+4(FP), BX	// aka base
 
 	/*
diff --git a/src/pkg/runtime/darwin/amd64/rt0.s b/src/pkg/runtime/darwin/amd64/rt0.s
index 1b70636..4cfab58 100644
--- a/src/pkg/runtime/darwin/amd64/rt0.s
+++ b/src/pkg/runtime/darwin/amd64/rt0.s
@@ -4,7 +4,7 @@
 
 // Darwin and Linux use the same linkage to main
 
-TEXT	_rt0_amd64_darwin(SB),7,$-8
+TEXT _rt0_amd64_darwin(SB),7,$-8
 	MOVQ	$_rt0_amd64(SB), AX
 	MOVQ	SP, DI
 	JMP	AX
diff --git a/src/pkg/runtime/darwin/amd64/signal.c b/src/pkg/runtime/darwin/amd64/signal.c
index 5dc811c..474a1bd 100644
--- a/src/pkg/runtime/darwin/amd64/signal.c
+++ b/src/pkg/runtime/darwin/amd64/signal.c
@@ -8,41 +8,41 @@
 #include "signals.h"
 
 void
-dumpregs(Regs *r)
+runtime·dumpregs(Regs *r)
 {
-	printf("rax     %X\n", r->rax);
-	printf("rbx     %X\n", r->rbx);
-	printf("rcx     %X\n", r->rcx);
-	printf("rdx     %X\n", r->rdx);
-	printf("rdi     %X\n", r->rdi);
-	printf("rsi     %X\n", r->rsi);
-	printf("rbp     %X\n", r->rbp);
-	printf("rsp     %X\n", r->rsp);
-	printf("r8      %X\n", r->r8 );
-	printf("r9      %X\n", r->r9 );
-	printf("r10     %X\n", r->r10);
-	printf("r11     %X\n", r->r11);
-	printf("r12     %X\n", r->r12);
-	printf("r13     %X\n", r->r13);
-	printf("r14     %X\n", r->r14);
-	printf("r15     %X\n", r->r15);
-	printf("rip     %X\n", r->rip);
-	printf("rflags  %X\n", r->rflags);
-	printf("cs      %X\n", r->cs);
-	printf("fs      %X\n", r->fs);
-	printf("gs      %X\n", r->gs);
+	runtime·printf("rax     %X\n", r->rax);
+	runtime·printf("rbx     %X\n", r->rbx);
+	runtime·printf("rcx     %X\n", r->rcx);
+	runtime·printf("rdx     %X\n", r->rdx);
+	runtime·printf("rdi     %X\n", r->rdi);
+	runtime·printf("rsi     %X\n", r->rsi);
+	runtime·printf("rbp     %X\n", r->rbp);
+	runtime·printf("rsp     %X\n", r->rsp);
+	runtime·printf("r8      %X\n", r->r8 );
+	runtime·printf("r9      %X\n", r->r9 );
+	runtime·printf("r10     %X\n", r->r10);
+	runtime·printf("r11     %X\n", r->r11);
+	runtime·printf("r12     %X\n", r->r12);
+	runtime·printf("r13     %X\n", r->r13);
+	runtime·printf("r14     %X\n", r->r14);
+	runtime·printf("r15     %X\n", r->r15);
+	runtime·printf("rip     %X\n", r->rip);
+	runtime·printf("rflags  %X\n", r->rflags);
+	runtime·printf("cs      %X\n", r->cs);
+	runtime·printf("fs      %X\n", r->fs);
+	runtime·printf("gs      %X\n", r->gs);
 }
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo *info, void *context)
+runtime·sighandler(int32 sig, Siginfo *info, void *context)
 {
 	Ucontext *uc;
 	Mcontext *mc;
@@ -55,7 +55,7 @@
 	mc = uc->uc_mcontext;
 	r = &mc->ss;
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Work around Leopard bug that doesn't set FPE_INTDIV.
 		// Look at instruction to see if it is a divide.
 		// Not necessary in Snow Leopard (si_code will be != 0).
@@ -77,91 +77,91 @@
 		gp->sigcode0 = info->si_code;
 		gp->sigcode1 = (uintptr)info->si_addr;
 		
-		// Only push sigpanic if r->rip != 0.
+		// Only push runtime·sigpanic if r->rip != 0.
 		// If r->rip == 0, probably panicked because of a
 		// call to a nil func.  Not pushing that onto sp will
-		// make the trace look like a call to sigpanic instead.
-		// (Otherwise the trace will end at sigpanic and we
+		// make the trace look like a call to runtime·sigpanic instead.
+		// (Otherwise the trace will end at runtime·sigpanic and we
 		// won't get to see who faulted.)
 		if(r->rip != 0) {
 			sp = (uintptr*)r->rsp;
 			*--sp = r->rip;
 			r->rsp = (uintptr)sp;
 		}
-		r->rip = (uintptr)sigpanic;
+		r->rip = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG){
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	}else{
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 	}
 
-	printf("pc: %X\n", r->rip);
-	printf("\n");
+	runtime·printf("pc: %X\n", r->rip);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->rip, (void*)r->rsp, 0, g);
-		tracebackothers(g);
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->rip, (void*)r->rsp, 0, g);
+		runtime·tracebackothers(g);
+		runtime·dumpregs(r);
 	}
 
-	breakpoint();
-	exit(2);
+	runtime·breakpoint();
+	runtime·exit(2);
 }
 
 void
-sigignore(int32, Siginfo*, void*)
+runtime·sigignore(int32, Siginfo*, void*)
 {
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	StackT st;
 
 	st.ss_sp = p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	int32 i;
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	sa.sa_flags |= SA_SIGINFO|SA_ONSTACK;
 	sa.sa_mask = 0xFFFFFFFFU;
-	sa.sa_tramp = sigtramp;	// sigtramp's job is to call into real handler
+	sa.sa_tramp = runtime·sigtramp;	// runtime·sigtramp's job is to call into real handler
 	for(i = 0; i<NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue)) {
-				sa.__sigaction_u.__sa_sigaction = sighandler;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue)) {
+				sa.__sigaction_u.__sa_sigaction = runtime·sighandler;
 			} else {
-				sa.__sigaction_u.__sa_sigaction = sigignore;
+				sa.__sigaction_u.__sa_sigaction = runtime·sigignore;
 			}
-			if(sigtab[i].flags & SigRestart)
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
-			sigaction(i, &sa, nil);
+			runtime·sigaction(i, &sa, nil);
 		}
 	}
 }
diff --git a/src/pkg/runtime/darwin/amd64/sys.s b/src/pkg/runtime/darwin/amd64/sys.s
index cbf053a..2f0a4bf 100644
--- a/src/pkg/runtime/darwin/amd64/sys.s
+++ b/src/pkg/runtime/darwin/amd64/sys.s
@@ -14,34 +14,34 @@
 #include "amd64/asm.h"
 
 // Exit the entire program (like C exit)
-TEXT	exit(SB),7,$0
+TEXT runtime·exit(SB),7,$0
 	MOVL	8(SP), DI		// arg 1 exit status
 	MOVL	$(0x2000000+1), AX	// syscall entry
 	SYSCALL
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // Exit this OS thread (like pthread_exit, which eventually
 // calls __bsdthread_terminate).
-TEXT	exit1(SB),7,$0
+TEXT runtime·exit1(SB),7,$0
 	MOVL	8(SP), DI		// arg 1 exit status
 	MOVL	$(0x2000000+361), AX	// syscall entry
 	SYSCALL
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	write(SB),7,$0
+TEXT runtime·write(SB),7,$0
 	MOVL	8(SP), DI		// arg 1 fd
 	MOVQ	16(SP), SI		// arg 2 buf
 	MOVL	24(SP), DX		// arg 3 count
 	MOVL	$(0x2000000+4), AX	// syscall entry
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // void gettime(int64 *sec, int32 *usec)
-TEXT gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
 	MOVQ	SP, DI	// must be non-nil, unused
 	MOVQ	$0, SI
 	MOVQ	$(0x2000000+116), AX
@@ -52,7 +52,7 @@
 	MOVL	DX, (DI)
 	RET
 
-TEXT	sigaction(SB),7,$0
+TEXT runtime·sigaction(SB),7,$0
 	MOVL	8(SP), DI		// arg 1 sig
 	MOVQ	16(SP), SI		// arg 2 act
 	MOVQ	24(SP), DX		// arg 3 oact
@@ -61,10 +61,10 @@
 	MOVL	$(0x2000000+46), AX	// syscall entry
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),7,$64
 	get_tls(BX)
 	
 	// save g
@@ -94,7 +94,7 @@
 	SYSCALL
 	INT $3	// not reached
 
-TEXT	·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVQ	16(SP), SI		// arg 2 len
 	MOVL	24(SP), DX		// arg 3 prot
@@ -105,31 +105,31 @@
 	SYSCALL
 	RET
 
-TEXT ·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVQ	16(SP), SI		// arg 2 len
 	MOVL	$(0x2000000+73), AX	// syscall entry
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	notok(SB),7,$0
+TEXT runtime·notok(SB),7,$0
 	MOVL	$0xf1, BP
 	MOVQ	BP, (BP)
 	RET
 
-TEXT sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),7,$0
 	MOVQ	new+8(SP), DI
 	MOVQ	old+16(SP), SI
 	MOVQ	$(0x2000000+53), AX
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // void bsdthread_create(void *stk, M *m, G *g, void (*fn)(void))
-TEXT bsdthread_create(SB),7,$0
+TEXT runtime·bsdthread_create(SB),7,$0
 	// Set up arguments to bsdthread_create system call.
 	// The ones in quotes pass through to the thread callback
 	// uninterpreted, so we can put whatever we want there.
@@ -158,7 +158,7 @@
 //	R8 = stack
 //	R9 = flags (= 0)
 //	SP = stack - C_64_REDZONE_LEN (= stack - 128)
-TEXT bsdthread_start(SB),7,$0
+TEXT runtime·bsdthread_start(SB),7,$0
 	MOVQ	R8, SP		// empirically, SP is very wrong but R8 is right
 
 	PUSHQ	DX
@@ -167,7 +167,7 @@
 
 	// set up thread local storage pointing at m->tls.
 	LEAQ	m_tls(CX), DI
-	CALL	settls(SB)
+	CALL	runtime·settls(SB)
 
 	POPQ	SI
 	POPQ	CX
@@ -178,16 +178,16 @@
 	MOVQ	SI, m_procid(CX)	// thread port is m->procid
 	MOVQ	m_g0(CX), AX
 	MOVQ	AX, g(BX)
-	CALL	stackcheck(SB)	// smashes AX, CX
+	CALL	runtime·stackcheck(SB)	// smashes AX, CX
 	CALL	DX	// fn
-	CALL	exit1(SB)
+	CALL	runtime·exit1(SB)
 	RET
 
 // void bsdthread_register(void)
 // registers callbacks for threadstart (see bsdthread_create above
 // and wqthread and pthsize (not used).  returns 0 on success.
-TEXT bsdthread_register(SB),7,$0
-	MOVQ	$bsdthread_start(SB), DI	// threadstart
+TEXT runtime·bsdthread_register(SB),7,$0
+	MOVQ	$runtime·bsdthread_start(SB), DI	// threadstart
 	MOVQ	$0, SI	// wqthread, not used by us
 	MOVQ	$0, DX	// pthsize, not used by us
 	MOVQ	$0, R10	// dummy_value [sic]
@@ -196,13 +196,13 @@
 	MOVQ	$(0x2000000+366), AX	// bsdthread_register
 	SYSCALL
 	JCC 2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // Mach system calls use 0x1000000 instead of the BSD's 0x2000000.
 
 // uint32 mach_msg_trap(void*, uint32, uint32, uint32, uint32, uint32, uint32)
-TEXT mach_msg_trap(SB),7,$0
+TEXT runtime·mach_msg_trap(SB),7,$0
 	MOVQ	8(SP), DI
 	MOVL	16(SP), SI
 	MOVL	20(SP), DX
@@ -216,17 +216,17 @@
 	POPQ	R11
 	RET
 
-TEXT mach_task_self(SB),7,$0
+TEXT runtime·mach_task_self(SB),7,$0
 	MOVL	$(0x1000000+28), AX	// task_self_trap
 	SYSCALL
 	RET
 
-TEXT mach_thread_self(SB),7,$0
+TEXT runtime·mach_thread_self(SB),7,$0
 	MOVL	$(0x1000000+27), AX	// thread_self_trap
 	SYSCALL
 	RET
 
-TEXT mach_reply_port(SB),7,$0
+TEXT runtime·mach_reply_port(SB),7,$0
 	MOVL	$(0x1000000+26), AX	// mach_reply_port
 	SYSCALL
 	RET
@@ -235,14 +235,14 @@
 // instead of requiring the use of RPC.
 
 // uint32 mach_semaphore_wait(uint32)
-TEXT mach_semaphore_wait(SB),7,$0
+TEXT runtime·mach_semaphore_wait(SB),7,$0
 	MOVL	8(SP), DI
 	MOVL	$(0x1000000+36), AX	// semaphore_wait_trap
 	SYSCALL
 	RET
 
 // uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
-TEXT mach_semaphore_timedwait(SB),7,$0
+TEXT runtime·mach_semaphore_timedwait(SB),7,$0
 	MOVL	8(SP), DI
 	MOVL	12(SP), SI
 	MOVL	16(SP), DX
@@ -251,21 +251,21 @@
 	RET
 
 // uint32 mach_semaphore_signal(uint32)
-TEXT mach_semaphore_signal(SB),7,$0
+TEXT runtime·mach_semaphore_signal(SB),7,$0
 	MOVL	8(SP), DI
 	MOVL	$(0x1000000+33), AX	// semaphore_signal_trap
 	SYSCALL
 	RET
 
 // uint32 mach_semaphore_signal_all(uint32)
-TEXT mach_semaphore_signal_all(SB),7,$0
+TEXT runtime·mach_semaphore_signal_all(SB),7,$0
 	MOVL	8(SP), DI
 	MOVL	$(0x1000000+34), AX	// semaphore_signal_all_trap
 	SYSCALL
 	RET
 
 // set tls base to DI
-TEXT	settls(SB),7,$32
+TEXT runtime·settls(SB),7,$32
 	/*
 	* Same as in ../386/sys.s:/ugliness, different constant.
 	* See ../../../../libcgo/darwin_amd64.c for the derivation
diff --git a/src/pkg/runtime/darwin/mem.c b/src/pkg/runtime/darwin/mem.c
index 90c8e4a..fc963d7 100644
--- a/src/pkg/runtime/darwin/mem.c
+++ b/src/pkg/runtime/darwin/mem.c
@@ -4,21 +4,21 @@
 #include "malloc.h"
 
 void*
-SysAlloc(uintptr n)
+runtime·SysAlloc(uintptr n)
 {
 	void *v;
 
 	mstats.sys += n;
-	v = runtime_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
+	v = runtime·mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
 	if(v < (void*)4096) {
-		printf("mmap: errno=%p\n", v);
-		throw("mmap");
+		runtime·printf("mmap: errno=%p\n", v);
+		runtime·throw("mmap");
 	}
 	return v;
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v);
 	USED(n);
@@ -26,15 +26,15 @@
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
 	mstats.sys -= n;
-	runtime_munmap(v, n);
+	runtime·munmap(v, n);
 }
 
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 	// Code generators assume that references to addresses
 	// on the first page will fault.  Map the page explicitly with
@@ -42,5 +42,5 @@
 	// allocating that page as the virtual address space fills.
 	// Ignore any error, since other systems might be smart
 	// enough to never allow anything there.
-//	runtime_mmap(nil, 4096, PROT_NONE, MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
+//	mmap(nil, 4096, PROT_NONE, MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
 }
diff --git a/src/pkg/runtime/darwin/os.h b/src/pkg/runtime/darwin/os.h
index 51a164c..35ef4e6 100644
--- a/src/pkg/runtime/darwin/os.h
+++ b/src/pkg/runtime/darwin/os.h
@@ -2,24 +2,24 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-int32	bsdthread_create(void*, M*, G*, void(*)(void));
-void	bsdthread_register(void);
-int32	mach_msg_trap(MachHeader*, int32, uint32, uint32, uint32, uint32, uint32);
-uint32	mach_reply_port(void);
-void	mach_semacquire(uint32);
-uint32	mach_semcreate(void);
-void	mach_semdestroy(uint32);
-void	mach_semrelease(uint32);
-void	mach_semreset(uint32);
-uint32	mach_task_self(void);
-uint32	mach_task_self(void);
-uint32	mach_thread_self(void);
-uint32	mach_thread_self(void);
+int32	runtime·bsdthread_create(void*, M*, G*, void(*)(void));
+void	runtime·bsdthread_register(void);
+int32	runtime·mach_msg_trap(MachHeader*, int32, uint32, uint32, uint32, uint32, uint32);
+uint32	runtime·mach_reply_port(void);
+void	runtime·mach_semacquire(uint32);
+uint32	runtime·mach_semcreate(void);
+void	runtime·mach_semdestroy(uint32);
+void	runtime·mach_semrelease(uint32);
+void	runtime·mach_semreset(uint32);
+uint32	runtime·mach_task_self(void);
+uint32	runtime·mach_task_self(void);
+uint32	runtime·mach_thread_self(void);
+uint32	runtime·mach_thread_self(void);
 
 struct Sigaction;
-void	sigaction(uintptr, struct Sigaction*, struct Sigaction*);
+void	runtime·sigaction(uintptr, struct Sigaction*, struct Sigaction*);
 
 struct StackT;
-void	sigaltstack(struct StackT*, struct StackT*);
-void	sigtramp(void);
-void	sigpanic(void);
+void	runtime·sigaltstack(struct StackT*, struct StackT*);
+void	runtime·sigtramp(void);
+void	runtime·sigpanic(void);
diff --git a/src/pkg/runtime/darwin/signals.h b/src/pkg/runtime/darwin/signals.h
index ac9e5d6..035027f 100644
--- a/src/pkg/runtime/darwin/signals.h
+++ b/src/pkg/runtime/darwin/signals.h
@@ -8,7 +8,7 @@
 #define Q SigQueue
 #define P SigPanic
 
-SigTab sigtab[] = {
+SigTab runtime·sigtab[] = {
 	/* 0 */	0, "SIGNONE: no trap",
 	/* 1 */	Q+R, "SIGHUP: terminal line hangup",
 	/* 2 */	Q+R, "SIGINT: interrupt",
diff --git a/src/pkg/runtime/darwin/thread.c b/src/pkg/runtime/darwin/thread.c
index f4dd180..58aa9da 100644
--- a/src/pkg/runtime/darwin/thread.c
+++ b/src/pkg/runtime/darwin/thread.c
@@ -6,13 +6,13 @@
 #include "defs.h"
 #include "os.h"
 
-extern SigTab sigtab[];
+extern SigTab runtime·sigtab[];
 
 static void
 unimplemented(int8 *name)
 {
-	prints(name);
-	prints(" not implemented\n");
+	runtime·prints(name);
+	runtime·prints(" not implemented\n");
 	*(int32*)1231 = 1231;
 }
 
@@ -29,10 +29,10 @@
 	if(*psema != 0)	// already have one
 		return;
 
-	sema = mach_semcreate();
-	if(!cas(psema, 0, sema)){
+	sema = runtime·mach_semcreate();
+	if(!runtime·cas(psema, 0, sema)){
 		// Someone else filled it in.  Use theirs.
-		mach_semdestroy(sema);
+		runtime·mach_semdestroy(sema);
 		return;
 	}
 }
@@ -52,40 +52,40 @@
 // in Plan 9's user-level locks.
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 
-	if(xadd(&l->key, 1) > 1) {	// someone else has it; wait
+	if(runtime·xadd(&l->key, 1) > 1) {	// someone else has it; wait
 		// Allocate semaphore if needed.
 		if(l->sema == 0)
 			initsema(&l->sema);
-		mach_semacquire(l->sema);
+		runtime·mach_semacquire(l->sema);
 	}
 }
 
 void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 
-	if(xadd(&l->key, -1) > 0) {	// someone else is waiting
+	if(runtime·xadd(&l->key, -1) > 0) {	// someone else is waiting
 		// Allocate semaphore if needed.
 		if(l->sema == 0)
 			initsema(&l->sema);
-		mach_semrelease(l->sema);
+		runtime·mach_semrelease(l->sema);
 	}
 }
 
 void
-destroylock(Lock *l)
+runtime·destroylock(Lock *l)
 {
 	if(l->sema != 0) {
-		mach_semdestroy(l->sema);
+		runtime·mach_semdestroy(l->sema);
 		l->sema = 0;
 	}
 }
@@ -95,79 +95,79 @@
 // but when it's time to block, fall back on the kernel semaphore k.
 // This is the same algorithm used in Plan 9.
 void
-usemacquire(Usema *s)
+runtime·usemacquire(Usema *s)
 {
-	if((int32)xadd(&s->u, -1) < 0) {
+	if((int32)runtime·xadd(&s->u, -1) < 0) {
 		if(s->k == 0)
 			initsema(&s->k);
-		mach_semacquire(s->k);
+		runtime·mach_semacquire(s->k);
 	}
 }
 
 void
-usemrelease(Usema *s)
+runtime·usemrelease(Usema *s)
 {
-	if((int32)xadd(&s->u, 1) <= 0) {
+	if((int32)runtime·xadd(&s->u, 1) <= 0) {
 		if(s->k == 0)
 			initsema(&s->k);
-		mach_semrelease(s->k);
+		runtime·mach_semrelease(s->k);
 	}
 }
 
 
 // Event notifications.
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	n->wakeup = 0;
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	while(!n->wakeup)
-		usemacquire(&n->sema);
+		runtime·usemacquire(&n->sema);
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	n->wakeup = 1;
-	usemrelease(&n->sema);
+	runtime·usemrelease(&n->sema);
 }
 
 
 // BSD interface for threading.
 void
-osinit(void)
+runtime·osinit(void)
 {
 	// Register our thread-creation callback (see {amd64,386}/sys.s)
 	// but only if we're not using cgo.  If we are using cgo we need
 	// to let the C pthread libary install its own thread-creation callback.
 	extern void (*libcgo_thread_start)(void*);
 	if(libcgo_thread_start == nil)
-		bsdthread_register();
+		runtime·bsdthread_register();
 }
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	m->tls[0] = m->id;	// so 386 asm can find it
 	if(0){
-		printf("newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
+		runtime·printf("newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
 			stk, m, g, fn, m->id, m->tls[0], &m);
 	}
-	if(bsdthread_create(stk, m, g, fn) < 0)
-		throw("cannot create new OS thread");
+	if(runtime·bsdthread_create(stk, m, g, fn) < 0)
+		runtime·throw("cannot create new OS thread");
 }
 
 // Called to initialize a new m (including the bootstrap m).
 void
-minit(void)
+runtime·minit(void)
 {
 	// Initialize signal handling.
-	m->gsignal = malg(32*1024);	// OS X wants >=8K, Linux >=2K
-	signalstack(m->gsignal->stackguard, 32*1024);
+	m->gsignal = runtime·malg(32*1024);	// OS X wants >=8K, Linux >=2K
+	runtime·signalstack(m->gsignal->stackguard, 32*1024);
 }
 
 // Mach IPC, to get at semaphores
@@ -176,8 +176,8 @@
 static void
 macherror(int32 r, int8 *fn)
 {
-	printf("mach error %s: %d\n", fn, r);
-	throw("mach error");
+	runtime·printf("mach error %s: %d\n", fn, r);
+	runtime·throw("mach error");
 }
 
 enum
@@ -199,7 +199,7 @@
 	uint32 notify)
 {
 	// TODO: Loop on interrupt.
-	return mach_msg_trap(h, op, send_size, rcv_size, rcv_name, timeout, notify);
+	return runtime·mach_msg_trap(h, op, send_size, rcv_size, rcv_name, timeout, notify);
 }
 
 // Mach RPC (MIG)
@@ -229,7 +229,7 @@
 	CodeMsg *c;
 
 	if((port = m->machport) == 0){
-		port = mach_reply_port();
+		port = runtime·mach_reply_port();
 		m->machport = port;
 	}
 
@@ -240,48 +240,48 @@
 
 	if(DebugMach){
 		p = (uint32*)h;
-		prints("send:\t");
+		runtime·prints("send:\t");
 		for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
-			prints(" ");
-			·printpointer((void*)p[i]);
+			runtime·prints(" ");
+			runtime·printpointer((void*)p[i]);
 			if(i%8 == 7)
-				prints("\n\t");
+				runtime·prints("\n\t");
 		}
 		if(i%8)
-			prints("\n");
+			runtime·prints("\n");
 	}
 
 	ret = mach_msg(h, MACH_SEND_MSG|MACH_RCV_MSG,
 		h->msgh_size, maxsize, port, 0, 0);
 	if(ret != 0){
 		if(DebugMach){
-			prints("mach_msg error ");
-			·printint(ret);
-			prints("\n");
+			runtime·prints("mach_msg error ");
+			runtime·printint(ret);
+			runtime·prints("\n");
 		}
 		return ret;
 	}
 
 	if(DebugMach){
 		p = (uint32*)h;
-		prints("recv:\t");
+		runtime·prints("recv:\t");
 		for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
-			prints(" ");
-			·printpointer((void*)p[i]);
+			runtime·prints(" ");
+			runtime·printpointer((void*)p[i]);
 			if(i%8 == 7)
-				prints("\n\t");
+				runtime·prints("\n\t");
 		}
 		if(i%8)
-			prints("\n");
+			runtime·prints("\n");
 	}
 
 	if(h->msgh_id != id+Reply){
 		if(DebugMach){
-			prints("mach_msg reply id mismatch ");
-			·printint(h->msgh_id);
-			prints(" != ");
-			·printint(id+Reply);
-			prints("\n");
+			runtime·prints("mach_msg reply id mismatch ");
+			runtime·printint(h->msgh_id);
+			runtime·prints(" != ");
+			runtime·printint(id+Reply);
+			runtime·prints("\n");
 		}
 		return -303;	// MIG_REPLY_MISMATCH
 	}
@@ -296,20 +296,20 @@
 	if(h->msgh_size == sizeof(CodeMsg)
 	&& !(h->msgh_bits & MACH_MSGH_BITS_COMPLEX)){
 		if(DebugMach){
-			prints("mig result ");
-			·printint(c->code);
-			prints("\n");
+			runtime·prints("mig result ");
+			runtime·printint(c->code);
+			runtime·prints("\n");
 		}
 		return c->code;
 	}
 
 	if(h->msgh_size != rxsize){
 		if(DebugMach){
-			prints("mach_msg reply size mismatch ");
-			·printint(h->msgh_size);
-			prints(" != ");
-			·printint(rxsize);
-			prints("\n");
+			runtime·prints("mach_msg reply size mismatch ");
+			runtime·printint(h->msgh_size);
+			runtime·prints(" != ");
+			runtime·printint(rxsize);
+			runtime·prints("\n");
 		}
 		return -307;	// MIG_ARRAY_TOO_LARGE
 	}
@@ -363,7 +363,7 @@
 #pragma pack off
 
 uint32
-mach_semcreate(void)
+runtime·mach_semcreate(void)
 {
 	union {
 		Tmach_semcreateMsg tx;
@@ -374,7 +374,7 @@
 
 	m.tx.h.msgh_bits = 0;
 	m.tx.h.msgh_size = sizeof(m.tx);
-	m.tx.h.msgh_remote_port = mach_task_self();
+	m.tx.h.msgh_remote_port = runtime·mach_task_self();
 	m.tx.h.msgh_id = Tmach_semcreate;
 	m.tx.ndr = zerondr;
 
@@ -392,7 +392,7 @@
 }
 
 void
-mach_semdestroy(uint32 sem)
+runtime·mach_semdestroy(uint32 sem)
 {
 	union {
 		Tmach_semdestroyMsg tx;
@@ -402,7 +402,7 @@
 
 	m.tx.h.msgh_bits = MACH_MSGH_BITS_COMPLEX;
 	m.tx.h.msgh_size = sizeof(m.tx);
-	m.tx.h.msgh_remote_port = mach_task_self();
+	m.tx.h.msgh_remote_port = runtime·mach_task_self();
 	m.tx.h.msgh_id = Tmach_semdestroy;
 	m.tx.body.msgh_descriptor_count = 1;
 	m.tx.semaphore.name = sem;
@@ -417,17 +417,17 @@
 }
 
 // The other calls have simple system call traps in sys.s
-int32 mach_semaphore_wait(uint32 sema);
-int32 mach_semaphore_timedwait(uint32 sema, uint32 sec, uint32 nsec);
-int32 mach_semaphore_signal(uint32 sema);
-int32 mach_semaphore_signal_all(uint32 sema);
+int32 runtime·mach_semaphore_wait(uint32 sema);
+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);
 
 void
-mach_semacquire(uint32 sem)
+runtime·mach_semacquire(uint32 sem)
 {
 	int32 r;
 
-	while((r = mach_semaphore_wait(sem)) != 0) {
+	while((r = runtime·mach_semaphore_wait(sem)) != 0) {
 		if(r == KERN_ABORTED)	// interrupted
 			continue;
 		macherror(r, "semaphore_wait");
@@ -435,11 +435,11 @@
 }
 
 void
-mach_semrelease(uint32 sem)
+runtime·mach_semrelease(uint32 sem)
 {
 	int32 r;
 
-	while((r = mach_semaphore_signal(sem)) != 0) {
+	while((r = runtime·mach_semaphore_signal(sem)) != 0) {
 		if(r == KERN_ABORTED)	// interrupted
 			continue;
 		macherror(r, "semaphore_signal");
@@ -447,27 +447,27 @@
 }
 
 void
-sigpanic(void)
+runtime·sigpanic(void)
 {
 	switch(g->sig) {
 	case SIGBUS:
 		if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		printf("unexpected fault address %p\n", g->sigcode1);
-		throw("fault");
+			runtime·panicstring("invalid memory address or nil pointer dereference");
+		runtime·printf("unexpected fault address %p\n", g->sigcode1);
+		runtime·throw("fault");
 	case SIGSEGV:
 		if((g->sigcode0 == 0 || g->sigcode0 == SEGV_MAPERR || g->sigcode0 == SEGV_ACCERR) && g->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		printf("unexpected fault address %p\n", g->sigcode1);
-		throw("fault");
+			runtime·panicstring("invalid memory address or nil pointer dereference");
+		runtime·printf("unexpected fault address %p\n", g->sigcode1);
+		runtime·throw("fault");
 	case SIGFPE:
 		switch(g->sigcode0) {
 		case FPE_INTDIV:
-			panicstring("integer divide by zero");
+			runtime·panicstring("integer divide by zero");
 		case FPE_INTOVF:
-			panicstring("integer overflow");
+			runtime·panicstring("integer overflow");
 		}
-		panicstring("floating point error");
+		runtime·panicstring("floating point error");
 	}
-	panicstring(sigtab[g->sig].name);
+	runtime·panicstring(runtime·sigtab[g->sig].name);
 }
diff --git a/src/pkg/runtime/float.c b/src/pkg/runtime/float.c
index 5122f35..f481519 100644
--- a/src/pkg/runtime/float.c
+++ b/src/pkg/runtime/float.c
@@ -9,7 +9,7 @@
 static	uint64	uvneginf	= 0xFFF0000000000000ULL;
 
 uint32
-float32tobits(float32 f)
+runtime·float32tobits(float32 f)
 {
 	// The obvious cast-and-pointer code is technically
 	// not valid, and gcc miscompiles it.  Use a union instead.
@@ -22,7 +22,7 @@
 }
 
 uint64
-float64tobits(float64 f)
+runtime·float64tobits(float64 f)
 {
 	// The obvious cast-and-pointer code is technically
 	// not valid, and gcc miscompiles it.  Use a union instead.
@@ -35,7 +35,7 @@
 }
 
 float64
-float64frombits(uint64 i)
+runtime·float64frombits(uint64 i)
 {
 	// The obvious cast-and-pointer code is technically
 	// not valid, and gcc miscompiles it.  Use a union instead.
@@ -48,7 +48,7 @@
 }
 
 float32
-float32frombits(uint32 i)
+runtime·float32frombits(uint32 i)
 {
 	// The obvious cast-and-pointer code is technically
 	// not valid, and gcc miscompiles it.  Use a union instead.
@@ -61,11 +61,11 @@
 }
 
 bool
-isInf(float64 f, int32 sign)
+runtime·isInf(float64 f, int32 sign)
 {
 	uint64 x;
 
-	x = float64tobits(f);
+	x = runtime·float64tobits(f);
 	if(sign == 0)
 		return x == uvinf || x == uvneginf;
 	if(sign > 0)
@@ -74,27 +74,27 @@
 }
 
 float64
-NaN(void)
+runtime·NaN(void)
 {
-	return float64frombits(uvnan);
+	return runtime·float64frombits(uvnan);
 }
 
 bool
-isNaN(float64 f)
+runtime·isNaN(float64 f)
 {
 	uint64 x;
 
-	x = float64tobits(f);
-	return ((uint32)(x>>52) & 0x7FF) == 0x7FF && !isInf(f, 0);
+	x = runtime·float64tobits(f);
+	return ((uint32)(x>>52) & 0x7FF) == 0x7FF && !runtime·isInf(f, 0);
 }
 
 float64
-Inf(int32 sign)
+runtime·Inf(int32 sign)
 {
 	if(sign >= 0)
-		return float64frombits(uvinf);
+		return runtime·float64frombits(uvinf);
 	else
-		return float64frombits(uvneginf);
+		return runtime·float64frombits(uvneginf);
 }
 
 enum
@@ -105,7 +105,7 @@
 };
 
 float64
-frexp(float64 d, int32 *ep)
+runtime·frexp(float64 d, int32 *ep)
 {
 	uint64 x;
 
@@ -113,36 +113,36 @@
 		*ep = 0;
 		return 0;
 	}
-	x = float64tobits(d);
+	x = runtime·float64tobits(d);
 	*ep = (int32)((x >> SHIFT) & MASK) - BIAS;
 	x &= ~((uint64)MASK << SHIFT);
 	x |= (uint64)BIAS << SHIFT;
-	return float64frombits(x);
+	return runtime·float64frombits(x);
 }
 
 float64
-ldexp(float64 d, int32 e)
+runtime·ldexp(float64 d, int32 e)
 {
 	uint64 x;
 
 	if(d == 0)
 		return 0;
-	x = float64tobits(d);
+	x = runtime·float64tobits(d);
 	e += (int32)(x >> SHIFT) & MASK;
 	if(e <= 0)
 		return 0;	/* underflow */
 	if(e >= MASK){		/* overflow */
 		if(d < 0)
-			return Inf(-1);
-		return Inf(1);
+			return runtime·Inf(-1);
+		return runtime·Inf(1);
 	}
 	x &= ~((uint64)MASK << SHIFT);
 	x |= (uint64)e << SHIFT;
-	return float64frombits(x);
+	return runtime·float64frombits(x);
 }
 
 float64
-modf(float64 d, float64 *ip)
+runtime·modf(float64 d, float64 *ip)
 {
 	float64 dd;
 	uint64 x;
@@ -150,7 +150,7 @@
 
 	if(d < 1) {
 		if(d < 0) {
-			d = modf(-d, ip);
+			d = runtime·modf(-d, ip);
 			*ip = -*ip;
 			return -d;
 		}
@@ -158,7 +158,7 @@
 		return d;
 	}
 
-	x = float64tobits(d);
+	x = runtime·float64tobits(d);
 	e = (int32)((x >> SHIFT) & MASK) - BIAS;
 
 	/*
@@ -166,7 +166,7 @@
 	 */
 	if(e <= 64-11)
 		x &= ~(((uint64)1 << (64LL-11LL-e))-1);
-	dd = float64frombits(x);
+	dd = runtime·float64frombits(x);
 	*ip = dd;
 	return d - dd;
 }
diff --git a/src/pkg/runtime/freebsd/386/rt0.s b/src/pkg/runtime/freebsd/386/rt0.s
index 67c5f91..3ca981b 100644
--- a/src/pkg/runtime/freebsd/386/rt0.s
+++ b/src/pkg/runtime/freebsd/386/rt0.s
@@ -4,6 +4,6 @@
 
 // Darwin and Linux use the same linkage to main
 
-TEXT	_rt0_386_freebsd(SB),7,$0
+TEXT _rt0_386_freebsd(SB),7,$0
 	JMP	_rt0_386(SB)
 
diff --git a/src/pkg/runtime/freebsd/386/signal.c b/src/pkg/runtime/freebsd/386/signal.c
index 4fc6d9e..52b820d 100644
--- a/src/pkg/runtime/freebsd/386/signal.c
+++ b/src/pkg/runtime/freebsd/386/signal.c
@@ -7,7 +7,7 @@
 #include "signals.h"
 #include "os.h"
 
-extern void sigtramp(void);
+extern void runtime·sigtramp(void);
 
 typedef struct sigaction {
 	union {
@@ -19,33 +19,33 @@
 } Sigaction;
 
 void
-dumpregs(Mcontext *r)
+runtime·dumpregs(Mcontext *r)
 {
-	printf("eax     %x\n", r->mc_eax);
-	printf("ebx     %x\n", r->mc_ebx);
-	printf("ecx     %x\n", r->mc_ecx);
-	printf("edx     %x\n", r->mc_edx);
-	printf("edi     %x\n", r->mc_edi);
-	printf("esi     %x\n", r->mc_esi);
-	printf("ebp     %x\n", r->mc_ebp);
-	printf("esp     %x\n", r->mc_esp);
-	printf("eip     %x\n", r->mc_eip);
-	printf("eflags  %x\n", r->mc_eflags);
-	printf("cs      %x\n", r->mc_cs);
-	printf("fs      %x\n", r->mc_fs);
-	printf("gs      %x\n", r->mc_gs);
+	runtime·printf("eax     %x\n", r->mc_eax);
+	runtime·printf("ebx     %x\n", r->mc_ebx);
+	runtime·printf("ecx     %x\n", r->mc_ecx);
+	runtime·printf("edx     %x\n", r->mc_edx);
+	runtime·printf("edi     %x\n", r->mc_edi);
+	runtime·printf("esi     %x\n", r->mc_esi);
+	runtime·printf("ebp     %x\n", r->mc_ebp);
+	runtime·printf("esp     %x\n", r->mc_esp);
+	runtime·printf("eip     %x\n", r->mc_eip);
+	runtime·printf("eflags  %x\n", r->mc_eflags);
+	runtime·printf("cs      %x\n", r->mc_cs);
+	runtime·printf("fs      %x\n", r->mc_fs);
+	runtime·printf("gs      %x\n", r->mc_gs);
 }
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo* info, void* context)
+runtime·sighandler(int32 sig, Siginfo* info, void* context)
 {
 	Ucontext *uc;
 	Mcontext *r;
@@ -55,7 +55,7 @@
 	uc = context;
 	r = &uc->uc_mcontext;
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Make it look like a call to the signal func.
 		// Have to pass arguments out of band since
 		// augmenting the stack frame would break
@@ -64,91 +64,91 @@
 		gp->sigcode0 = info->si_code;
 		gp->sigcode1 = (uintptr)info->si_addr;
 
-		// Only push sigpanic if r->mc_eip != 0.
+		// Only push runtime·sigpanic if r->mc_eip != 0.
 		// If r->mc_eip == 0, probably panicked because of a
 		// call to a nil func.  Not pushing that onto sp will
-		// make the trace look like a call to sigpanic instead.
-		// (Otherwise the trace will end at sigpanic and we
+		// make the trace look like a call to runtime·sigpanic instead.
+		// (Otherwise the trace will end at runtime·sigpanic and we
 		// won't get to see who faulted.)
 		if(r->mc_eip != 0) {
 			sp = (uintptr*)r->mc_esp;
 			*--sp = r->mc_eip;
 			r->mc_esp = (uintptr)sp;
 		}
-		r->mc_eip = (uintptr)sigpanic;
+		r->mc_eip = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG)
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	else
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 
-	printf("PC=%X\n", r->mc_eip);
-	printf("\n");
+	runtime·printf("PC=%X\n", r->mc_eip);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->mc_eip, (void*)r->mc_esp, 0, m->curg);
-		tracebackothers(m->curg);
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->mc_eip, (void*)r->mc_esp, 0, m->curg);
+		runtime·tracebackothers(m->curg);
+		runtime·dumpregs(r);
 	}
 
-	breakpoint();
-	exit(2);
+	runtime·breakpoint();
+	runtime·exit(2);
 }
 
 void
-sigignore(void)
+runtime·sigignore(void)
 {
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	Sigaltstack st;
 
 	st.ss_sp = (int8*)p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	int32 i;
 	sa.sa_flags |= SA_ONSTACK | SA_SIGINFO;
 	sa.sa_mask = ~0x0ull;
 	
 	for(i = 0; i < NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue))
-				sa.__sigaction_u.__sa_sigaction = (void*) sigtramp;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+				sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigtramp;
 			else
-				sa.__sigaction_u.__sa_sigaction = (void*) sigignore;
+				sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigignore;
 
-			if(sigtab[i].flags & SigRestart)
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
 
-			sigaction(i, &sa, nil);
+			runtime·sigaction(i, &sa, nil);
 		}
 	}
 }
diff --git a/src/pkg/runtime/freebsd/386/sys.s b/src/pkg/runtime/freebsd/386/sys.s
index 012e9a0..2670fc1 100644
--- a/src/pkg/runtime/freebsd/386/sys.s
+++ b/src/pkg/runtime/freebsd/386/sys.s
@@ -8,17 +8,17 @@
 
 #include "386/asm.h"
 	
-TEXT sys_umtx_op(SB),7,$-4
+TEXT runtime·sys_umtx_op(SB),7,$-4
 	MOVL	$454, AX
 	INT	$0x80
 	RET
 
-TEXT thr_new(SB),7,$-4
+TEXT runtime·thr_new(SB),7,$-4
 	MOVL	$455, AX
 	INT	$0x80
 	RET
 
-TEXT thr_start(SB),7,$0
+TEXT runtime·thr_start(SB),7,$0
 	MOVL	mm+0(FP), AX
 	MOVL	m_g0(AX), BX
 	LEAL	m_tls(AX), BP
@@ -28,7 +28,7 @@
 	PUSHL	$32
 	PUSHL	BP
 	PUSHL	DI
-	CALL	setldt(SB)
+	CALL	runtime·setldt(SB)
 	POPL	AX
 	POPL	AX
 	POPL	AX
@@ -37,36 +37,36 @@
 	MOVL	BX, g(CX)
 	
 	MOVL	AX, m(CX)
-	CALL	stackcheck(SB)		// smashes AX
-	CALL	mstart(SB)
+	CALL	runtime·stackcheck(SB)		// smashes AX
+	CALL	runtime·mstart(SB)
 	MOVL	0, AX			// crash (not reached)
 
 // Exit the entire program (like C exit)
-TEXT exit(SB),7,$-4
+TEXT runtime·exit(SB),7,$-4
 	MOVL	$1, AX
 	INT	$0x80
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT exit1(SB),7,$-4
+TEXT runtime·exit1(SB),7,$-4
 	MOVL	$431, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT write(SB),7,$-4
+TEXT runtime·write(SB),7,$-4
 	MOVL	$4, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	notok(SB),7,$0
+TEXT runtime·notok(SB),7,$0
 	MOVL	$0xf1, 0xf1
 	RET
 
-TEXT ·mmap(SB),7,$32
+TEXT runtime·mmap(SB),7,$32
 	LEAL arg0+0(FP), SI
 	LEAL	4(SP), DI
 	CLD
@@ -82,14 +82,14 @@
 	INT	$0x80
 	RET
 
-TEXT ·munmap(SB),7,$-4
+TEXT runtime·munmap(SB),7,$-4
 	MOVL	$73, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
 	MOVL	$116, AX
 	LEAL	12(SP), BX
 	MOVL	BX, 4(SP)
@@ -106,14 +106,14 @@
 	MOVL	BX, (DI)
 	RET
 
-TEXT sigaction(SB),7,$-4
+TEXT runtime·sigaction(SB),7,$-4
 	MOVL	$416, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT sigtramp(SB),7,$40
+TEXT runtime·sigtramp(SB),7,$40
 	// g = m->gsignal
 	get_tls(DX)
 	MOVL	m(DX), BP
@@ -127,7 +127,7 @@
 	MOVL	AX, 0(SP)
 	MOVL	BX, 4(SP)
 	MOVL	CX, 8(SP)
-	CALL	sighandler(SB)
+	CALL	runtime·sighandler(SB)
 
 	// g = m->curg
 	get_tls(DX)
@@ -141,14 +141,14 @@
 	MOVL	AX, 4(SP)
 	MOVL	$417, AX	// sigreturn(ucontext)
 	INT	$0x80
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),7,$0
 	MOVL	$53, AX
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 /*
@@ -168,7 +168,7 @@
 */
 
 // setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$32
+TEXT runtime·setldt(SB),7,$32
 	MOVL	address+4(FP), BX	// aka base
 	// see comment in linux/386/sys.s; freebsd is similar
 	ADDL	$0x8, BX
@@ -193,7 +193,7 @@
 	MOVL	$0xffffffff, 0(SP)	// auto-allocate entry and return in AX
 	MOVL	AX, 4(SP)
 	MOVL	$1, 8(SP)
-	CALL	i386_set_ldt(SB)
+	CALL	runtime·i386_set_ldt(SB)
 
 	// compute segment selector - (entry*8+7)
 	SHLL	$3, AX
@@ -201,7 +201,7 @@
 	MOVW	AX, GS
 	RET
 
-TEXT i386_set_ldt(SB),7,$16
+TEXT runtime·i386_set_ldt(SB),7,$16
 	LEAL	args+0(FP), AX	// 0(FP) == 4(SP) before SP got moved
 	MOVL	$0, 0(SP)	// syscall gap
 	MOVL	$1, 4(SP)
@@ -213,4 +213,4 @@
 	INT	$3
 	RET
 
-GLOBL tlsoffset(SB),$4
+GLOBL runtime·tlsoffset(SB),$4
diff --git a/src/pkg/runtime/freebsd/amd64/rt0.s b/src/pkg/runtime/freebsd/amd64/rt0.s
index 7903b7c..5d2eeee 100644
--- a/src/pkg/runtime/freebsd/amd64/rt0.s
+++ b/src/pkg/runtime/freebsd/amd64/rt0.s
@@ -4,6 +4,6 @@
 
 // Darwin and Linux use the same linkage to main
 
-TEXT	_rt0_amd64_freebsd(SB),7,$-8
+TEXT _rt0_amd64_freebsd(SB),7,$-8
 	MOVQ	$_rt0_amd64(SB), DX
 	JMP	DX
diff --git a/src/pkg/runtime/freebsd/amd64/signal.c b/src/pkg/runtime/freebsd/amd64/signal.c
index 09053ac..c74ddad 100644
--- a/src/pkg/runtime/freebsd/amd64/signal.c
+++ b/src/pkg/runtime/freebsd/amd64/signal.c
@@ -7,7 +7,7 @@
 #include "signals.h"
 #include "os.h"
 
-extern void sigtramp(void);
+extern void runtime·sigtramp(void);
 
 typedef struct sigaction {
 	union {
@@ -19,41 +19,41 @@
 } Sigaction;
 
 void
-dumpregs(Mcontext *r)
+runtime·dumpregs(Mcontext *r)
 {
-	printf("rax     %X\n", r->mc_rax);
-	printf("rbx     %X\n", r->mc_rbx);
-	printf("rcx     %X\n", r->mc_rcx);
-	printf("rdx     %X\n", r->mc_rdx);
-	printf("rdi     %X\n", r->mc_rdi);
-	printf("rsi     %X\n", r->mc_rsi);
-	printf("rbp     %X\n", r->mc_rbp);
-	printf("rsp     %X\n", r->mc_rsp);
-	printf("r8      %X\n", r->mc_r8 );
-	printf("r9      %X\n", r->mc_r9 );
-	printf("r10     %X\n", r->mc_r10);
-	printf("r11     %X\n", r->mc_r11);
-	printf("r12     %X\n", r->mc_r12);
-	printf("r13     %X\n", r->mc_r13);
-	printf("r14     %X\n", r->mc_r14);
-	printf("r15     %X\n", r->mc_r15);
-	printf("rip     %X\n", r->mc_rip);
-	printf("rflags  %X\n", r->mc_flags);
-	printf("cs      %X\n", r->mc_cs);
-	printf("fs      %X\n", r->mc_fs);
-	printf("gs      %X\n", r->mc_gs);
+	runtime·printf("rax     %X\n", r->mc_rax);
+	runtime·printf("rbx     %X\n", r->mc_rbx);
+	runtime·printf("rcx     %X\n", r->mc_rcx);
+	runtime·printf("rdx     %X\n", r->mc_rdx);
+	runtime·printf("rdi     %X\n", r->mc_rdi);
+	runtime·printf("rsi     %X\n", r->mc_rsi);
+	runtime·printf("rbp     %X\n", r->mc_rbp);
+	runtime·printf("rsp     %X\n", r->mc_rsp);
+	runtime·printf("r8      %X\n", r->mc_r8 );
+	runtime·printf("r9      %X\n", r->mc_r9 );
+	runtime·printf("r10     %X\n", r->mc_r10);
+	runtime·printf("r11     %X\n", r->mc_r11);
+	runtime·printf("r12     %X\n", r->mc_r12);
+	runtime·printf("r13     %X\n", r->mc_r13);
+	runtime·printf("r14     %X\n", r->mc_r14);
+	runtime·printf("r15     %X\n", r->mc_r15);
+	runtime·printf("rip     %X\n", r->mc_rip);
+	runtime·printf("rflags  %X\n", r->mc_flags);
+	runtime·printf("cs      %X\n", r->mc_cs);
+	runtime·printf("fs      %X\n", r->mc_fs);
+	runtime·printf("gs      %X\n", r->mc_gs);
 }
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo* info, void* context)
+runtime·sighandler(int32 sig, Siginfo* info, void* context)
 {
 	Ucontext *uc;
 	Mcontext *r;
@@ -63,7 +63,7 @@
 	uc = context;
 	r = &uc->uc_mcontext;
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Make it look like a call to the signal func.
 		// Have to pass arguments out of band since
 		// augmenting the stack frame would break
@@ -72,91 +72,91 @@
 		gp->sigcode0 = info->si_code;
 		gp->sigcode1 = (uintptr)info->si_addr;
 
-		// Only push sigpanic if r->mc_rip != 0.
+		// Only push runtime·sigpanic if r->mc_rip != 0.
 		// If r->mc_rip == 0, probably panicked because of a
 		// call to a nil func.  Not pushing that onto sp will
-		// make the trace look like a call to sigpanic instead.
-		// (Otherwise the trace will end at sigpanic and we
+		// make the trace look like a call to runtime·sigpanic instead.
+		// (Otherwise the trace will end at runtime·sigpanic and we
 		// won't get to see who faulted.)
 		if(r->mc_rip != 0) {
 			sp = (uintptr*)r->mc_rsp;
 			*--sp = r->mc_rip;
 			r->mc_rsp = (uintptr)sp;
 		}
-		r->mc_rip = (uintptr)sigpanic;
+		r->mc_rip = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG)
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	else
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 
-	printf("PC=%X\n", r->mc_rip);
-	printf("\n");
+	runtime·printf("PC=%X\n", r->mc_rip);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->mc_rip, (void*)r->mc_rsp, 0, g);
-		tracebackothers(g);
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->mc_rip, (void*)r->mc_rsp, 0, g);
+		runtime·tracebackothers(g);
+		runtime·dumpregs(r);
 	}
 
-	breakpoint();
-	exit(2);
+	runtime·breakpoint();
+	runtime·exit(2);
 }
 
 void
-sigignore(void)
+runtime·sigignore(void)
 {
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	Sigaltstack st;
 
 	st.ss_sp = (int8*)p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	int32 i;
 	sa.sa_flags |= SA_ONSTACK | SA_SIGINFO;
 	sa.sa_mask = ~0x0ull;
 	
 	for(i = 0; i < NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue))
-				sa.__sigaction_u.__sa_sigaction = (void*) sigtramp;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+				sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigtramp;
 			else
-				sa.__sigaction_u.__sa_sigaction = (void*) sigignore;
+				sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigignore;
 
-			if(sigtab[i].flags & SigRestart)
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
 
-			sigaction(i, &sa, nil);
+			runtime·sigaction(i, &sa, nil);
 		}
 	}
 }
diff --git a/src/pkg/runtime/freebsd/amd64/sys.s b/src/pkg/runtime/freebsd/amd64/sys.s
index 2d84150..0f8a8a8a 100644
--- a/src/pkg/runtime/freebsd/amd64/sys.s
+++ b/src/pkg/runtime/freebsd/amd64/sys.s
@@ -8,7 +8,7 @@
 
 #include "amd64/asm.h"
 	
-TEXT sys_umtx_op(SB),7,$0
+TEXT runtime·sys_umtx_op(SB),7,$0
 	MOVQ 8(SP), DI
 	MOVL 16(SP), SI
 	MOVL 20(SP), DX
@@ -18,19 +18,19 @@
 	SYSCALL
 	RET
 
-TEXT thr_new(SB),7,$0
+TEXT runtime·thr_new(SB),7,$0
 	MOVQ 8(SP), DI
 	MOVQ 16(SP), SI
 	MOVL $455, AX
 	SYSCALL
 	RET
 
-TEXT thr_start(SB),7,$0
+TEXT runtime·thr_start(SB),7,$0
 	MOVQ	DI, R13	// m
 
 	// set up FS to point at m->tls
 	LEAQ	m_tls(R13), DI
-	CALL	settls(SB)	// smashes DI
+	CALL	runtime·settls(SB)	// smashes DI
 
 	// set up m, g
 	get_tls(CX)
@@ -38,36 +38,36 @@
 	MOVQ	m_g0(R13), DI
 	MOVQ	DI, g(CX)
 
-	CALL stackcheck(SB)
-	CALL mstart(SB)
+	CALL runtime·stackcheck(SB)
+	CALL runtime·mstart(SB)
 	MOVQ 0, AX			// crash (not reached)
 
 // Exit the entire program (like C exit)
-TEXT	exit(SB),7,$-8
+TEXT runtime·exit(SB),7,$-8
 	MOVL	8(SP), DI		// arg 1 exit status
 	MOVL	$1, AX
 	SYSCALL
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	exit1(SB),7,$-8
+TEXT runtime·exit1(SB),7,$-8
 	MOVQ	8(SP), DI		// arg 1 exit status
 	MOVL	$431, AX
 	SYSCALL
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	write(SB),7,$-8
+TEXT runtime·write(SB),7,$-8
 	MOVL	8(SP), DI		// arg 1 fd
 	MOVQ	16(SP), SI		// arg 2 buf
 	MOVL	24(SP), DX		// arg 3 count
 	MOVL	$4, AX
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
 	MOVL	$116, AX
 	LEAQ	8(SP), DI
 	MOVQ	$0, SI
@@ -82,17 +82,17 @@
 	MOVL	BX, (DI)
 	RET
 
-TEXT	sigaction(SB),7,$-8
+TEXT runtime·sigaction(SB),7,$-8
 	MOVL	8(SP), DI		// arg 1 sig
 	MOVQ	16(SP), SI		// arg 2 act
 	MOVQ	24(SP), DX		// arg 3 oact
 	MOVL	$416, AX
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	sigtramp(SB),7,$24-16
+TEXT runtime·sigtramp(SB),7,$24-16
 	get_tls(CX)
 	MOVQ	m(CX), AX
 	MOVQ	m_gsignal(AX), AX
@@ -100,10 +100,10 @@
 	MOVQ	DI, 0(SP)
 	MOVQ	SI, 8(SP)
 	MOVQ	DX, 16(SP)
-	CALL	sighandler(SB)
+	CALL	runtime·sighandler(SB)
 	RET
 
-TEXT	·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVQ	16(SP), SI		// arg 2 len
 	MOVL	24(SP), DX		// arg 3 prot
@@ -114,31 +114,31 @@
 	SYSCALL
 	RET
 
-TEXT	·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVQ	16(SP), SI		// arg 2 len
 	MOVL	$73, AX
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	notok(SB),7,$-8
+TEXT runtime·notok(SB),7,$-8
 	MOVL	$0xf1, BP
 	MOVQ	BP, (BP)
 	RET
 
-TEXT sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),7,$-8
 	MOVQ	new+8(SP), DI
 	MOVQ	old+16(SP), SI
 	MOVQ	$53, AX
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // set tls base to DI
-TEXT settls(SB),7,$8
+TEXT runtime·settls(SB),7,$8
 	ADDQ	$16, DI	// adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
 	MOVQ	DI, 0(SP)
 	MOVQ	SP, SI
@@ -146,5 +146,5 @@
 	MOVQ	$165, AX	// sysarch
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
diff --git a/src/pkg/runtime/freebsd/mem.c b/src/pkg/runtime/freebsd/mem.c
index 81e324e..9020178 100644
--- a/src/pkg/runtime/freebsd/mem.c
+++ b/src/pkg/runtime/freebsd/mem.c
@@ -4,21 +4,21 @@
 #include "malloc.h"
 
 void*
-SysAlloc(uintptr n)
+runtime·SysAlloc(uintptr n)
 {
 	void *v;
 
 	mstats.sys += n;
-	v = runtime_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
+	v = runtime·mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
 	if(v < (void*)4096) {
-		printf("mmap: errno=%p\n", v);
-		throw("mmap");
+		runtime·printf("mmap: errno=%p\n", v);
+		runtime·throw("mmap");
 	}
 	return v;
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v);
 	USED(n);
@@ -26,15 +26,15 @@
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
 	mstats.sys -= n;
-	runtime_munmap(v, n);
+	runtime·munmap(v, n);
 }
 
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 	// Code generators assume that references to addresses
 	// on the first page will fault.  Map the page explicitly with
@@ -42,5 +42,5 @@
 	// allocating that page as the virtual address space fills.
 	// Ignore any error, since other systems might be smart
 	// enough to never allow anything there.
-	runtime_mmap(nil, 4096, PROT_NONE, MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
+	runtime·mmap(nil, 4096, PROT_NONE, MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
 }
diff --git a/src/pkg/runtime/freebsd/os.h b/src/pkg/runtime/freebsd/os.h
index 47bf7d5..455355b 100644
--- a/src/pkg/runtime/freebsd/os.h
+++ b/src/pkg/runtime/freebsd/os.h
@@ -1,5 +1,5 @@
-int32 thr_new(ThrParam*, int32);
-void sigpanic(void);
-void sigaltstack(Sigaltstack*, Sigaltstack*);
+int32 runtime·thr_new(ThrParam*, int32);
+void runtime·sigpanic(void);
+void runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
 struct sigaction;
-void sigaction(int32, struct sigaction*, struct sigaction*);
+void runtime·sigaction(int32, struct sigaction*, struct sigaction*);
diff --git a/src/pkg/runtime/freebsd/signals.h b/src/pkg/runtime/freebsd/signals.h
index 0c41daf..63a8467 100644
--- a/src/pkg/runtime/freebsd/signals.h
+++ b/src/pkg/runtime/freebsd/signals.h
@@ -8,7 +8,7 @@
 #define Q SigQueue
 #define P SigPanic
 
-SigTab sigtab[] = {
+SigTab runtime·sigtab[] = {
 	/* 0 */		0, "SIGNONE: no trap",
 	/* 1 */		Q+R, "SIGHUP: terminal line hangup",
 	/* 2 */		Q+R, "SIGINT: interrupt",
diff --git a/src/pkg/runtime/freebsd/thread.c b/src/pkg/runtime/freebsd/thread.c
index 27f8aa5..fc80dfb 100644
--- a/src/pkg/runtime/freebsd/thread.c
+++ b/src/pkg/runtime/freebsd/thread.c
@@ -5,8 +5,8 @@
 #include "defs.h"
 #include "os.h"
 
-extern SigTab sigtab[];
-extern int32 sys_umtx_op(uint32*, int32, uint32, void*, void*);
+extern SigTab runtime·sigtab[];
+extern int32 runtime·sys_umtx_op(uint32*, int32, uint32, void*, 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 for comments.
@@ -16,11 +16,11 @@
 {
 	int32 ret;
 
-	ret = sys_umtx_op(addr, UMTX_OP_WAIT, val, nil, nil);
+	ret = runtime·sys_umtx_op(addr, UMTX_OP_WAIT, val, nil, nil);
 	if(ret >= 0 || ret == -EINTR)
 		return;
 
-	printf("umtx_wait addr=%p val=%d ret=%d\n", addr, val, ret);
+	runtime·printf("umtx_wait addr=%p val=%d ret=%d\n", addr, val, ret);
 	*(int32*)0x1005 = 0x1005;
 }
 
@@ -29,11 +29,11 @@
 {
 	int32 ret;
 
-	ret = sys_umtx_op(addr, UMTX_OP_WAKE, 1, nil, nil);
+	ret = runtime·sys_umtx_op(addr, UMTX_OP_WAKE, 1, nil, nil);
 	if(ret >= 0)
 		return;
 
-	printf("umtx_wake addr=%p ret=%d\n", addr, ret);
+	runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
 	*(int32*)0x1006 = 0x1006;
 }
 
@@ -46,12 +46,12 @@
 again:
 	v = l->key;
 	if((v&1) == 0){
-		if(cas(&l->key, v, v|1))
+		if(runtime·cas(&l->key, v, v|1))
 			return;
 		goto again;
 	}
 
-	if(!cas(&l->key, v, v+2))
+	if(!runtime·cas(&l->key, v, v+2))
 		goto again;
 
 	umtx_wait(&l->key, v+2);
@@ -59,8 +59,8 @@
 	for(;;){
 		v = l->key;
 		if(v < 2)
-			throw("bad lock key");
-		if(cas(&l->key, v, v-2))
+			runtime·throw("bad lock key");
+		if(runtime·cas(&l->key, v, v-2))
 			break;
 	}
 
@@ -75,8 +75,8 @@
 again:
 	v = l->key;
 	if((v&1) == 0)
-		throw("unlock of unlocked lock");
-	if(!cas(&l->key, v, v&~1))
+		runtime·throw("unlock of unlocked lock");
+	if(!runtime·cas(&l->key, v, v&~1))
 		goto again;
 
 	if(v&~1)
@@ -84,53 +84,53 @@
 }
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 	umtx_lock(l);
 }
 
 void 
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	umtx_unlock(l);
 }
 
 void
-destroylock(Lock*)
+runtime·destroylock(Lock*)
 {
 }
 
 // Event notifications.
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	n->lock.key = 0;
 	umtx_lock(&n->lock);
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	umtx_lock(&n->lock);
 	umtx_unlock(&n->lock);
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	umtx_unlock(&n->lock);
 }
 
-void thr_start(void*);
+void runtime·thr_start(void*);
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	ThrParam param;
 
@@ -138,13 +138,13 @@
 	USED(g);	// thr_start assumes g == m->g0
 
 	if(0){
-		printf("newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
+		runtime·printf("newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
 			stk, m, g, fn, m->id, m->tls[0], &m);
 	}
 
-	runtime_memclr((byte*)&param, sizeof param);
+	runtime·memclr((byte*)&param, sizeof param);
 
-	param.start_func = thr_start;
+	param.start_func = runtime·thr_start;
 	param.arg = m;
 	param.stack_base = (int8*)g->stackbase;
 	param.stack_size = (byte*)stk - (byte*)g->stackbase;
@@ -155,45 +155,45 @@
 
 	m->tls[0] = m->id;	// so 386 asm can find it
 
-	thr_new(&param, sizeof param);
+	runtime·thr_new(&param, sizeof param);
 }
 
 void
-osinit(void)
+runtime·osinit(void)
 {
 }
 
 // Called to initialize a new m (including the bootstrap m).
 void
-minit(void)
+runtime·minit(void)
 {
 	// Initialize signal handling
-	m->gsignal = malg(32*1024);
-	signalstack(m->gsignal->stackguard, 32*1024);
+	m->gsignal = runtime·malg(32*1024);
+	runtime·signalstack(m->gsignal->stackguard, 32*1024);
 }
 
 void
-sigpanic(void)
+runtime·sigpanic(void)
 {
 	switch(g->sig) {
 	case SIGBUS:
 		if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		printf("unexpected fault address %p\n", g->sigcode1);
-		throw("fault");
+			runtime·panicstring("invalid memory address or nil pointer dereference");
+		runtime·printf("unexpected fault address %p\n", g->sigcode1);
+		runtime·throw("fault");
 	case SIGSEGV:
 		if((g->sigcode0 == 0 || g->sigcode0 == SEGV_MAPERR || g->sigcode0 == SEGV_ACCERR) && g->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		printf("unexpected fault address %p\n", g->sigcode1);
-		throw("fault");
+			runtime·panicstring("invalid memory address or nil pointer dereference");
+		runtime·printf("unexpected fault address %p\n", g->sigcode1);
+		runtime·throw("fault");
 	case SIGFPE:
 		switch(g->sigcode0) {
 		case FPE_INTDIV:
-			panicstring("integer divide by zero");
+			runtime·panicstring("integer divide by zero");
 		case FPE_INTOVF:
-			panicstring("integer overflow");
+			runtime·panicstring("integer overflow");
 		}
-		panicstring("floating point error");
+		runtime·panicstring("floating point error");
 	}
-	panicstring(sigtab[g->sig].name);
+	runtime·panicstring(runtime·sigtab[g->sig].name);
 }
diff --git a/src/pkg/runtime/hashmap.c b/src/pkg/runtime/hashmap.c
index 704196c..a03202e 100644
--- a/src/pkg/runtime/hashmap.c
+++ b/src/pkg/runtime/hashmap.c
@@ -139,7 +139,7 @@
 
 	if(datasize < sizeof (void *))
 		datasize = sizeof (void *);
-	datasize = rnd(datasize, sizeof (void *));
+	datasize = runtime·rnd(datasize, sizeof (void *));
 	init_sizes (hint, &init_power, &max_power);
 	h->datasize = datasize;
 	h->max_power = max_power;
@@ -289,7 +289,7 @@
 	free (old_st);
 }
 
-int32
+static int32
 hash_lookup (struct hash *h, void *data, void **pres)
 {
 	int32 elemsize = h->datasize + offsetof (struct hash_entry, data[0]);
@@ -330,7 +330,7 @@
 	return (0);
 }
 
-int32
+static int32
 hash_remove (struct hash *h, void *data, void *arg)
 {
 	int32 elemsize = h->datasize + offsetof (struct hash_entry, data[0]);
@@ -454,7 +454,7 @@
 	}
 }
 
-int32
+static int32
 hash_insert (struct hash *h, void *data, void **pres)
 {
 	int32 rc = hash_insert_internal (&h->st, 0, (*h->data_hash) (h->keysize, data), h, data, pres);
@@ -463,7 +463,7 @@
 	return (rc);
 }
 
-uint32
+static uint32
 hash_count (struct hash *h)
 {
 	return (h->count);
@@ -503,7 +503,7 @@
 	sub->e = e;
 }
 
-void *
+static void *
 hash_next (struct hash_iter *it)
 {
 	int32 elemsize = it->elemsize;
@@ -570,7 +570,7 @@
 	}
 }
 
-void
+static void
 hash_iter_init (struct hash *h, struct hash_iter *it)
 {
 	it->elemsize = h->datasize + offsetof (struct hash_entry, data[0]);
@@ -606,7 +606,7 @@
 	*used += lused;
 }
 
-void
+static void
 hash_destroy (struct hash *h)
 {
 	int32 slots = 0;
@@ -645,7 +645,7 @@
 	}
 }
 
-void
+static void
 hash_visit (struct hash *h, void (*data_visit) (void *arg, int32 level, void *data), void *arg)
 {
 	hash_visit_internal (h->st, 0, 0, data_visit, arg);
@@ -692,31 +692,31 @@
 
 // makemap(key, val *Type, hint uint32) (hmap *map[any]any);
 Hmap*
-makemap(Type *key, Type *val, int64 hint)
+runtime·makemap_c(Type *key, Type *val, int64 hint)
 {
 	Hmap *h;
 	int32 keyalg, valalg, keysize, valsize, valsize_in_hash;
 	void (*data_del)(uint32, void*, void*);
 
 	if(hint < 0 || (int32)hint != hint)
-		panicstring("makemap: size out of range");
+		runtime·panicstring("makemap: size out of range");
 
 	keyalg = key->alg;
 	valalg = val->alg;
 	keysize = key->size;
 	valsize = val->size;
 
-	if(keyalg >= nelem(algarray) || algarray[keyalg].hash == nohash) {
-		printf("map(keyalg=%d)\n", keyalg);
-		throw("runtime.makemap: unsupported map key type");
+	if(keyalg >= nelem(runtime·algarray) || runtime·algarray[keyalg].hash == runtime·nohash) {
+		runtime·printf("map(keyalg=%d)\n", keyalg);
+		runtime·throw("runtime.makemap: unsupported map key type");
 	}
 
-	if(valalg >= nelem(algarray)) {
-		printf("map(valalg=%d)\n", valalg);
-		throw("runtime.makemap: unsupported map value type");
+	if(valalg >= nelem(runtime·algarray)) {
+		runtime·printf("map(valalg=%d)\n", valalg);
+		runtime·throw("runtime.makemap: unsupported map value type");
 	}
 
-	h = mal(sizeof(*h));
+	h = runtime·mal(sizeof(*h));
 
 	valsize_in_hash = valsize;
 	data_del = donothing;
@@ -730,38 +730,38 @@
 	// might remove in the future and just assume datavo == keysize.
 	h->datavo = keysize;
 	if(valsize_in_hash >= sizeof(void*))
-		h->datavo = rnd(keysize, sizeof(void*));
+		h->datavo = runtime·rnd(keysize, sizeof(void*));
 
 	hash_init(h, h->datavo+valsize_in_hash,
-		algarray[keyalg].hash,
-		algarray[keyalg].equal,
+		runtime·algarray[keyalg].hash,
+		runtime·algarray[keyalg].equal,
 		data_del,
 		hint);
 
 	h->keysize = keysize;
 	h->valsize = valsize;
-	h->keyalg = &algarray[keyalg];
-	h->valalg = &algarray[valalg];
+	h->keyalg = &runtime·algarray[keyalg];
+	h->valalg = &runtime·algarray[valalg];
 
 	// these calculations are compiler dependent.
 	// figure out offsets of map call arguments.
 
 	// func() (key, val)
-	h->ko0 = rnd(sizeof(h), Structrnd);
-	h->vo0 = rnd(h->ko0+keysize, val->align);
+	h->ko0 = runtime·rnd(sizeof(h), Structrnd);
+	h->vo0 = runtime·rnd(h->ko0+keysize, val->align);
 
 	// func(key) (val[, pres])
-	h->ko1 = rnd(sizeof(h), key->align);
-	h->vo1 = rnd(h->ko1+keysize, Structrnd);
-	h->po1 = rnd(h->vo1+valsize, 1);
+	h->ko1 = runtime·rnd(sizeof(h), key->align);
+	h->vo1 = runtime·rnd(h->ko1+keysize, Structrnd);
+	h->po1 = runtime·rnd(h->vo1+valsize, 1);
 
 	// func(key, val[, pres])
-	h->ko2 = rnd(sizeof(h), key->align);
-	h->vo2 = rnd(h->ko2+keysize, val->align);
-	h->po2 = rnd(h->vo2+valsize, 1);
+	h->ko2 = runtime·rnd(sizeof(h), key->align);
+	h->vo2 = runtime·rnd(h->ko2+keysize, val->align);
+	h->po2 = runtime·rnd(h->vo2+valsize, 1);
 
 	if(debug) {
-		printf("makemap: map=%p; keysize=%d; valsize=%d; keyalg=%d; valalg=%d; offsets=%d,%d; %d,%d,%d; %d,%d,%d\n",
+		runtime·printf("makemap: map=%p; keysize=%d; valsize=%d; keyalg=%d; valalg=%d; offsets=%d,%d; %d,%d,%d; %d,%d,%d\n",
 			h, keysize, valsize, keyalg, valalg, h->ko0, h->vo0, h->ko1, h->vo1, h->po1, h->ko2, h->vo2, h->po2);
 	}
 
@@ -770,19 +770,19 @@
 
 // makemap(key, val *Type, hint int64) (hmap *map[any]any);
 void
-·makemap(Type *key, Type *val, int64 hint, Hmap *ret)
+runtime·makemap(Type *key, Type *val, int64 hint, Hmap *ret)
 {
-	ret = makemap(key, val, hint);
+	ret = runtime·makemap_c(key, val, hint);
 	FLUSH(&ret);
 }
 
 void
-mapaccess(Hmap *h, byte *ak, byte *av, bool *pres)
+runtime·mapaccess(Hmap *h, byte *ak, byte *av, bool *pres)
 {
 	byte *res;
 
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
 	res = nil;
 	if(hash_lookup(h, ak, (void**)&res)) {
@@ -797,7 +797,7 @@
 // mapaccess1(hmap *map[any]any, key any) (val any);
 #pragma textflag 7
 void
-·mapaccess1(Hmap *h, ...)
+runtime·mapaccess1(Hmap *h, ...)
 {
 	byte *ak, *av;
 	bool pres;
@@ -805,25 +805,25 @@
 	ak = (byte*)&h + h->ko1;
 	av = (byte*)&h + h->vo1;
 
-	mapaccess(h, ak, av, &pres);
+	runtime·mapaccess(h, ak, av, &pres);
 
 	if(debug) {
-		prints("runtime.mapaccess1: map=");
-		·printpointer(h);
-		prints("; key=");
+		runtime·prints("runtime.mapaccess1: map=");
+		runtime·printpointer(h);
+		runtime·prints("; key=");
 		h->keyalg->print(h->keysize, ak);
-		prints("; val=");
+		runtime·prints("; val=");
 		h->valalg->print(h->valsize, av);
-		prints("; pres=");
-		·printbool(pres);
-		prints("\n");
+		runtime·prints("; pres=");
+		runtime·printbool(pres);
+		runtime·prints("\n");
 	}
 }
 
 // mapaccess2(hmap *map[any]any, key any) (val any, pres bool);
 #pragma textflag 7
 void
-·mapaccess2(Hmap *h, ...)
+runtime·mapaccess2(Hmap *h, ...)
 {
 	byte *ak, *av, *ap;
 
@@ -831,29 +831,29 @@
 	av = (byte*)&h + h->vo1;
 	ap = (byte*)&h + h->po1;
 
-	mapaccess(h, ak, av, ap);
+	runtime·mapaccess(h, ak, av, ap);
 
 	if(debug) {
-		prints("runtime.mapaccess2: map=");
-		·printpointer(h);
-		prints("; key=");
+		runtime·prints("runtime.mapaccess2: map=");
+		runtime·printpointer(h);
+		runtime·prints("; key=");
 		h->keyalg->print(h->keysize, ak);
-		prints("; val=");
+		runtime·prints("; val=");
 		h->valalg->print(h->valsize, av);
-		prints("; pres=");
-		·printbool(*ap);
-		prints("\n");
+		runtime·prints("; pres=");
+		runtime·printbool(*ap);
+		runtime·prints("\n");
 	}
 }
 
 void
-mapassign(Hmap *h, byte *ak, byte *av)
+runtime·mapassign(Hmap *h, byte *ak, byte *av)
 {
 	byte *res;
 	int32 hit;
 
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
 	res = nil;
 	if(av == nil) {
@@ -863,42 +863,42 @@
 
 	hit = hash_insert(h, ak, (void**)&res);
 	if(!hit && h->indirectval)
-		*(void**)(res+h->datavo) = mal(h->valsize);
+		*(void**)(res+h->datavo) = runtime·mal(h->valsize);
 	h->keyalg->copy(h->keysize, res, ak);
 	h->valalg->copy(h->valsize, hash_indirect(h, res+h->datavo), av);
 
 	if(debug) {
-		prints("mapassign: map=");
-		·printpointer(h);
-		prints("; key=");
+		runtime·prints("mapassign: map=");
+		runtime·printpointer(h);
+		runtime·prints("; key=");
 		h->keyalg->print(h->keysize, ak);
-		prints("; val=");
+		runtime·prints("; val=");
 		h->valalg->print(h->valsize, av);
-		prints("; hit=");
-		·printint(hit);
-		prints("; res=");
-		·printpointer(res);
-		prints("\n");
+		runtime·prints("; hit=");
+		runtime·printint(hit);
+		runtime·prints("; res=");
+		runtime·printpointer(res);
+		runtime·prints("\n");
 	}
 }
 
 // mapassign1(hmap *map[any]any, key any, val any);
 #pragma textflag 7
 void
-·mapassign1(Hmap *h, ...)
+runtime·mapassign1(Hmap *h, ...)
 {
 	byte *ak, *av;
 
 	ak = (byte*)&h + h->ko2;
 	av = (byte*)&h + h->vo2;
 
-	mapassign(h, ak, av);
+	runtime·mapassign(h, ak, av);
 }
 
 // mapassign2(hmap *map[any]any, key any, val any, pres bool);
 #pragma textflag 7
 void
-·mapassign2(Hmap *h, ...)
+runtime·mapassign2(Hmap *h, ...)
 {
 	byte *ak, *av, *ap;
 
@@ -909,20 +909,20 @@
 	if(*ap == false)
 		av = nil;	// delete
 
-	mapassign(h, ak, av);
+	runtime·mapassign(h, ak, av);
 
 	if(debug) {
-		prints("mapassign2: map=");
-		·printpointer(h);
-		prints("; key=");
+		runtime·prints("mapassign2: map=");
+		runtime·printpointer(h);
+		runtime·prints("; key=");
 		h->keyalg->print(h->keysize, ak);
-		prints("\n");
+		runtime·prints("\n");
 	}
 }
 
 // mapiterinit(hmap *map[any]any, hiter *any);
 void
-·mapiterinit(Hmap *h, struct hash_iter *it)
+runtime·mapiterinit(Hmap *h, struct hash_iter *it)
 {
 	if(h == nil) {
 		it->data = nil;
@@ -931,53 +931,47 @@
 	hash_iter_init(h, it);
 	it->data = hash_next(it);
 	if(debug) {
-		prints("runtime.mapiterinit: map=");
-		·printpointer(h);
-		prints("; iter=");
-		·printpointer(it);
-		prints("; data=");
-		·printpointer(it->data);
-		prints("\n");
+		runtime·prints("runtime.mapiterinit: map=");
+		runtime·printpointer(h);
+		runtime·prints("; iter=");
+		runtime·printpointer(it);
+		runtime·prints("; data=");
+		runtime·printpointer(it->data);
+		runtime·prints("\n");
 	}
 }
 
 struct hash_iter*
-mapiterinit(Hmap *h)
+runtime·newmapiterinit(Hmap *h)
 {
 	struct hash_iter *it;
 
-	it = mal(sizeof *it);
-	·mapiterinit(h, it);
+	it = runtime·mal(sizeof *it);
+	runtime·mapiterinit(h, it);
 	return it;
 }
 
 // mapiternext(hiter *any);
 void
-·mapiternext(struct hash_iter *it)
+runtime·mapiternext(struct hash_iter *it)
 {
-	if(gcwaiting)
-		gosched();
+	if(runtime·gcwaiting)
+		runtime·gosched();
 
 	it->data = hash_next(it);
 	if(debug) {
-		prints("runtime.mapiternext: iter=");
-		·printpointer(it);
-		prints("; data=");
-		·printpointer(it->data);
-		prints("\n");
+		runtime·prints("runtime.mapiternext: iter=");
+		runtime·printpointer(it);
+		runtime·prints("; data=");
+		runtime·printpointer(it->data);
+		runtime·prints("\n");
 	}
 }
 
-void
-mapiternext(struct hash_iter *it)
-{
-	·mapiternext(it);
-}
-
 // mapiter1(hiter *any) (key any);
 #pragma textflag 7
 void
-·mapiter1(struct hash_iter *it, ...)
+runtime·mapiter1(struct hash_iter *it, ...)
 {
 	Hmap *h;
 	byte *ak, *res;
@@ -987,21 +981,21 @@
 
 	res = it->data;
 	if(res == nil)
-		throw("runtime.mapiter1: key:val nil pointer");
+		runtime·throw("runtime.mapiter1: key:val nil pointer");
 
 	h->keyalg->copy(h->keysize, ak, res);
 
 	if(debug) {
-		prints("mapiter2: iter=");
-		·printpointer(it);
-		prints("; map=");
-		·printpointer(h);
-		prints("\n");
+		runtime·prints("mapiter2: iter=");
+		runtime·printpointer(it);
+		runtime·prints("; map=");
+		runtime·printpointer(h);
+		runtime·prints("\n");
 	}
 }
 
 bool
-mapiterkey(struct hash_iter *it, void *ak)
+runtime·mapiterkey(struct hash_iter *it, void *ak)
 {
 	Hmap *h;
 	byte *res;
@@ -1017,7 +1011,7 @@
 // mapiter2(hiter *any) (key any, val any);
 #pragma textflag 7
 void
-·mapiter2(struct hash_iter *it, ...)
+runtime·mapiter2(struct hash_iter *it, ...)
 {
 	Hmap *h;
 	byte *ak, *av, *res;
@@ -1028,16 +1022,16 @@
 
 	res = it->data;
 	if(res == nil)
-		throw("runtime.mapiter2: key:val nil pointer");
+		runtime·throw("runtime.mapiter2: key:val nil pointer");
 
 	h->keyalg->copy(h->keysize, ak, res);
 	h->valalg->copy(h->valsize, av, hash_indirect(h, res+h->datavo));
 
 	if(debug) {
-		prints("mapiter2: iter=");
-		·printpointer(it);
-		prints("; map=");
-		·printpointer(h);
-		prints("\n");
+		runtime·prints("mapiter2: iter=");
+		runtime·printpointer(it);
+		runtime·prints("; map=");
+		runtime·printpointer(h);
+		runtime·prints("\n");
 	}
 }
diff --git a/src/pkg/runtime/hashmap.h b/src/pkg/runtime/hashmap.h
index 906de47..40dac6e 100644
--- a/src/pkg/runtime/hashmap.h
+++ b/src/pkg/runtime/hashmap.h
@@ -63,11 +63,13 @@
 	}
  */
 
-#define	malloc		mal
+#define	malloc		runtime·mal
 #define	offsetof(s,m)	(uint32)(&(((s*)0)->m))
-#define	memset(a,b,c)	·memclr((byte*)(a), (uint32)(c))
-#define	memcpy(a,b,c)	mcpy((byte*)(a),(byte*)(b),(uint32)(c))
-#define	assert(a)	if(!(a)) throw("assert")
+#define	memset(a,b,c)	runtime·memclr((byte*)(a), (uint32)(c))
+#define	memcpy(a,b,c)	runtime·mcpy((byte*)(a),(byte*)(b),(uint32)(c))
+#define	assert(a)	if(!(a)) runtime·throw("assert")
+#define free(x)	runtime·free(x)
+#define memmove(a,b,c)	runtime·memmove(a, b, c)
 
 struct hash;		/* opaque */
 struct hash_subtable;	/* opaque */
@@ -114,12 +116,12 @@
 
 /* Lookup *data in *h.   If the data is found, return 1 and place a pointer to
    the found element in *pres.   Otherwise return 0 and place 0 in *pres. */
-int32 hash_lookup (struct hash *h, void *data, void **pres);
+// int32 hash_lookup (struct hash *h, void *data, void **pres);
 
 /* Lookup *data in *h.  If the data is found, execute (*data_del) (arg, p)
    where p points to the data in the table, then remove it from *h and return
    1.  Otherwise return 0.  */
-int32 hash_remove (struct hash *h, void *data, void *arg);
+// int32 hash_remove (struct hash *h, void *data, void *arg);
 
 /* Lookup *data in *h.   If the data is found, return 1, and place a pointer
    to the found element in *pres.   Otherwise, return 0, allocate a region
@@ -129,10 +131,10 @@
 
    If using garbage collection, it is the caller's responsibility to
    add references for **pres if HASH_ADDED is returned. */
-int32 hash_insert (struct hash *h, void *data, void **pres);
+// int32 hash_insert (struct hash *h, void *data, void **pres);
 
 /* Return the number of elements in the table. */
-uint32 hash_count (struct hash *h);
+// uint32 hash_count (struct hash *h);
 
 /* The following call is useful only if not using garbage collection on the
    table.
@@ -141,18 +143,18 @@
    If other memory pointed to by user data must be freed, the caller is
    responsible for doiing do by iterating over *h first; see
    hash_iter_init()/hash_next().  */
-void hash_destroy (struct hash *h);
+// void hash_destroy (struct hash *h);
 
 /*----- iteration -----*/
 
 /* Initialize *it from *h. */
-void hash_iter_init (struct hash *h, struct hash_iter *it);
+// void hash_iter_init (struct hash *h, struct hash_iter *it);
 
 /* Return the next used entry in the table which which *it was initialized. */
-void *hash_next (struct hash_iter *it);
+// void *hash_next (struct hash_iter *it);
 
 /*---- test interface ----*/
 /* Call (*data_visit) (arg, level, data) for every data entry in the table,
    whether used or not.   "level" is the subtable level, 0 means first level. */
 /* TESTING ONLY: DO NOT USE THIS ROUTINE IN NORMAL CODE */
-void hash_visit (struct hash *h, void (*data_visit) (void *arg, int32 level, void *data), void *arg);
+// void hash_visit (struct hash *h, void (*data_visit) (void *arg, int32 level, void *data), void *arg);
diff --git a/src/pkg/runtime/iface.c b/src/pkg/runtime/iface.c
index 35a710e..aa36df68 100644
--- a/src/pkg/runtime/iface.c
+++ b/src/pkg/runtime/iface.c
@@ -6,16 +6,16 @@
 #include "type.h"
 #include "malloc.h"
 
-static void
-printiface(Iface i)
+void
+runtime·printiface(Iface i)
 {
-	printf("(%p,%p)", i.tab, i.data);
+	runtime·printf("(%p,%p)", i.tab, i.data);
 }
 
-static void
-printeface(Eface e)
+void
+runtime·printeface(Eface e)
 {
-	printf("(%p,%p)", e.type, e.data);
+	runtime·printf("(%p,%p)", e.type, e.data);
 }
 
 /*
@@ -49,7 +49,7 @@
 	Eface err;
 
 	if(inter->mhdr.len == 0)
-		throw("internal error - misuse of itab");
+		runtime·throw("internal error - misuse of itab");
 
 	locked = 0;
 
@@ -72,7 +72,7 @@
 	// common case will be no lock contention.
 	for(locked=0; locked<2; locked++) {
 		if(locked)
-			lock(&ifacelock);
+			runtime·lock(&ifacelock);
 		for(m=hash[h]; m!=nil; m=m->link) {
 			if(m->inter == inter && m->type == type) {
 				if(m->bad) {
@@ -89,14 +89,14 @@
 					}
 				}
 				if(locked)
-					unlock(&ifacelock);
+					runtime·unlock(&ifacelock);
 				return m;
 			}
 		}
 	}
 
 	ni = inter->mhdr.len;
-	m = malloc(sizeof(*m) + ni*sizeof m->fun[0]);
+	m = runtime·malloc(sizeof(*m) + ni*sizeof m->fun[0]);
 	m->inter = inter;
 	m->type = type;
 
@@ -117,12 +117,12 @@
 				if(!canfail) {
 				throw:
 					// didn't find method
-					·newTypeAssertionError(nil, type, inter,
+					runtime·newTypeAssertionError(nil, type, inter,
 						nil, type->string, inter->string,
 						iname, &err);
 					if(locked)
-						unlock(&ifacelock);
-					·panic(err);
+						runtime·unlock(&ifacelock);
+					runtime·panic(err);
 					return nil;	// not reached
 				}
 				m->bad = 1;
@@ -139,7 +139,7 @@
 	m->link = hash[h];
 	hash[h] = m;
 	if(locked)
-		unlock(&ifacelock);
+		runtime·unlock(&ifacelock);
 	if(m->bad)
 		return nil;
 	return m;
@@ -155,10 +155,10 @@
 	alg = t->alg;
 
 	if(wid <= sizeof(*dst))
-		algarray[alg].copy(wid, dst, src);
+		runtime·algarray[alg].copy(wid, dst, src);
 	else {
-		p = mal(wid);
-		algarray[alg].copy(wid, p, src);
+		p = runtime·mal(wid);
+		runtime·algarray[alg].copy(wid, p, src);
 		*dst = p;
 	}
 }
@@ -172,15 +172,15 @@
 	alg = t->alg;
 
 	if(wid <= sizeof(*src))
-		algarray[alg].copy(wid, dst, src);
+		runtime·algarray[alg].copy(wid, dst, src);
 	else
-		algarray[alg].copy(wid, dst, *src);
+		runtime·algarray[alg].copy(wid, dst, *src);
 }
 
 // func convT2I(typ *byte, typ2 *byte, elem any) (ret any)
 #pragma textflag 7
 void
-·convT2I(Type *t, InterfaceType *inter, ...)
+runtime·convT2I(Type *t, InterfaceType *inter, ...)
 {
 	byte *elem;
 	Iface *ret;
@@ -188,7 +188,7 @@
 
 	elem = (byte*)(&inter+1);
 	wid = t->size;
-	ret = (Iface*)(elem + rnd(wid, Structrnd));
+	ret = (Iface*)(elem + runtime·rnd(wid, Structrnd));
 	ret->tab = itab(inter, t, 0);
 	copyin(t, elem, &ret->data);
 }
@@ -196,7 +196,7 @@
 // func convT2E(typ *byte, elem any) (ret any)
 #pragma textflag 7
 void
-·convT2E(Type *t, ...)
+runtime·convT2E(Type *t, ...)
 {
 	byte *elem;
 	Eface *ret;
@@ -204,7 +204,7 @@
 
 	elem = (byte*)(&t+1);
 	wid = t->size;
-	ret = (Eface*)(elem + rnd(wid, Structrnd));
+	ret = (Eface*)(elem + runtime·rnd(wid, Structrnd));
 	ret->type = t;
 	copyin(t, elem, &ret->data);
 }
@@ -212,7 +212,7 @@
 // func ifaceI2T(typ *byte, iface any) (ret any)
 #pragma textflag 7
 void
-·assertI2T(Type *t, Iface i, ...)
+runtime·assertI2T(Type *t, Iface i, ...)
 {
 	Itab *tab;
 	byte *ret;
@@ -221,16 +221,16 @@
 	ret = (byte*)(&i+1);
 	tab = i.tab;
 	if(tab == nil) {
-		·newTypeAssertionError(nil, nil, t,
+		runtime·newTypeAssertionError(nil, nil, t,
 			nil, nil, t->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	if(tab->type != t) {
-		·newTypeAssertionError(tab->inter, tab->type, t,
+		runtime·newTypeAssertionError(tab->inter, tab->type, t,
 			tab->inter->string, tab->type->string, t->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	copyout(t, &i.data, ret);
 }
@@ -238,7 +238,7 @@
 // func ifaceI2T2(typ *byte, iface any) (ret any, ok bool)
 #pragma textflag 7
 void
-·assertI2T2(Type *t, Iface i, ...)
+runtime·assertI2T2(Type *t, Iface i, ...)
 {
 	byte *ret;
 	bool *ok;
@@ -246,11 +246,11 @@
 
 	ret = (byte*)(&i+1);
 	wid = t->size;
-	ok = (bool*)(ret+rnd(wid, 1));
+	ok = (bool*)(ret+runtime·rnd(wid, 1));
 
 	if(i.tab == nil || i.tab->type != t) {
 		*ok = false;
-		·memclr(ret, wid);
+		runtime·memclr(ret, wid);
 		return;
 	}
 
@@ -261,7 +261,7 @@
 // func ifaceE2T(typ *byte, iface any) (ret any)
 #pragma textflag 7
 void
-·assertE2T(Type *t, Eface e, ...)
+runtime·assertE2T(Type *t, Eface e, ...)
 {
 	byte *ret;
 	Eface err;
@@ -269,16 +269,16 @@
 	ret = (byte*)(&e+1);
 
 	if(e.type == nil) {
-		·newTypeAssertionError(nil, nil, t,
+		runtime·newTypeAssertionError(nil, nil, t,
 			nil, nil, t->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	if(e.type != t) {
-		·newTypeAssertionError(nil, e.type, t,
+		runtime·newTypeAssertionError(nil, e.type, t,
 			nil, e.type->string, t->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	copyout(t, &e.data, ret);
 }
@@ -286,7 +286,7 @@
 // func ifaceE2T2(sigt *byte, iface any) (ret any, ok bool);
 #pragma textflag 7
 void
-·assertE2T2(Type *t, Eface e, ...)
+runtime·assertE2T2(Type *t, Eface e, ...)
 {
 	byte *ret;
 	bool *ok;
@@ -294,11 +294,11 @@
 
 	ret = (byte*)(&e+1);
 	wid = t->size;
-	ok = (bool*)(ret+rnd(wid, 1));
+	ok = (bool*)(ret+runtime·rnd(wid, 1));
 
 	if(t != e.type) {
 		*ok = false;
-		·memclr(ret, wid);
+		runtime·memclr(ret, wid);
 		return;
 	}
 
@@ -309,7 +309,7 @@
 // func convI2E(elem any) (ret any)
 #pragma textflag 7
 void
-·convI2E(Iface i, Eface ret)
+runtime·convI2E(Iface i, Eface ret)
 {
 	Itab *tab;
 
@@ -324,7 +324,7 @@
 // func ifaceI2E(typ *byte, iface any) (ret any)
 #pragma textflag 7
 void
-·assertI2E(InterfaceType* inter, Iface i, Eface ret)
+runtime·assertI2E(InterfaceType* inter, Iface i, Eface ret)
 {
 	Itab *tab;
 	Eface err;
@@ -332,10 +332,10 @@
 	tab = i.tab;
 	if(tab == nil) {
 		// explicit conversions require non-nil interface value.
-		·newTypeAssertionError(nil, nil, inter,
+		runtime·newTypeAssertionError(nil, nil, inter,
 			nil, nil, inter->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	ret.data = i.data;
 	ret.type = tab->type;
@@ -345,7 +345,7 @@
 // func ifaceI2E2(typ *byte, iface any) (ret any, ok bool)
 #pragma textflag 7
 void
-·assertI2E2(InterfaceType* inter, Iface i, Eface ret, bool ok)
+runtime·assertI2E2(InterfaceType* inter, Iface i, Eface ret, bool ok)
 {
 	Itab *tab;
 
@@ -366,7 +366,7 @@
 // func convI2I(typ *byte, elem any) (ret any)
 #pragma textflag 7
 void
-·convI2I(InterfaceType* inter, Iface i, Iface ret)
+runtime·convI2I(InterfaceType* inter, Iface i, Iface ret)
 {
 	Itab *tab;
 	
@@ -381,7 +381,7 @@
 }
 
 void
-ifaceI2I(InterfaceType *inter, Iface i, Iface *ret)
+runtime·ifaceI2I(InterfaceType *inter, Iface i, Iface *ret)
 {
 	Itab *tab;
 	Eface err;
@@ -389,10 +389,10 @@
 	tab = i.tab;
 	if(tab == nil) {
 		// explicit conversions require non-nil interface value.
-		·newTypeAssertionError(nil, nil, inter,
+		runtime·newTypeAssertionError(nil, nil, inter,
 			nil, nil, inter->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	ret->data = i.data;
 	ret->tab = itab(inter, tab->type, 0);
@@ -401,15 +401,15 @@
 // func ifaceI2I(sigi *byte, iface any) (ret any)
 #pragma textflag 7
 void
-·assertI2I(InterfaceType* inter, Iface i, Iface ret)
+runtime·assertI2I(InterfaceType* inter, Iface i, Iface ret)
 {
-	ifaceI2I(inter, i, &ret);
+	runtime·ifaceI2I(inter, i, &ret);
 }
 
 // func ifaceI2I2(sigi *byte, iface any) (ret any, ok bool)
 #pragma textflag 7
 void
-·assertI2I2(InterfaceType *inter, Iface i, Iface ret, bool ok)
+runtime·assertI2I2(InterfaceType *inter, Iface i, Iface ret, bool ok)
 {
 	Itab *tab;
 
@@ -428,7 +428,7 @@
 }
 
 void
-ifaceE2I(InterfaceType *inter, Eface e, Iface *ret)
+runtime·ifaceE2I(InterfaceType *inter, Eface e, Iface *ret)
 {
 	Type *t;
 	Eface err;
@@ -436,10 +436,10 @@
 	t = e.type;
 	if(t == nil) {
 		// explicit conversions require non-nil interface value.
-		·newTypeAssertionError(nil, nil, inter,
+		runtime·newTypeAssertionError(nil, nil, inter,
 			nil, nil, inter->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	ret->data = e.data;
 	ret->tab = itab(inter, t, 0);
@@ -448,15 +448,15 @@
 // func ifaceE2I(sigi *byte, iface any) (ret any)
 #pragma textflag 7
 void
-·assertE2I(InterfaceType* inter, Eface e, Iface ret)
+runtime·assertE2I(InterfaceType* inter, Eface e, Iface ret)
 {
-	ifaceE2I(inter, e, &ret);
+	runtime·ifaceE2I(inter, e, &ret);
 }
 
 // ifaceE2I2(sigi *byte, iface any) (ret any, ok bool)
 #pragma textflag 7
 void
-·assertE2I2(InterfaceType *inter, Eface e, Iface ret, bool ok)
+runtime·assertE2I2(InterfaceType *inter, Eface e, Iface ret, bool ok)
 {
 	if(e.type == nil) {
 		ok = 0;
@@ -476,7 +476,7 @@
 // func ifaceE2E(typ *byte, iface any) (ret any)
 #pragma textflag 7
 void
-·assertE2E(InterfaceType* inter, Eface e, Eface ret)
+runtime·assertE2E(InterfaceType* inter, Eface e, Eface ret)
 {
 	Type *t;
 	Eface err;
@@ -484,10 +484,10 @@
 	t = e.type;
 	if(t == nil) {
 		// explicit conversions require non-nil interface value.
-		·newTypeAssertionError(nil, nil, inter,
+		runtime·newTypeAssertionError(nil, nil, inter,
 			nil, nil, inter->string,
 			nil, &err);
-		·panic(err);
+		runtime·panic(err);
 	}
 	ret = e;
 	FLUSH(&ret);
@@ -496,7 +496,7 @@
 // func ifaceE2E2(iface any) (ret any, ok bool)
 #pragma textflag 7
 void
-·assertE2E2(InterfaceType* inter, Eface e, Eface ret, bool ok)
+runtime·assertE2E2(InterfaceType* inter, Eface e, Eface ret, bool ok)
 {
 	USED(inter);
 	ret = e;
@@ -516,19 +516,19 @@
 
 	alg = t->alg;
 	wid = t->size;
-	if(algarray[alg].hash == nohash) {
+	if(runtime·algarray[alg].hash == runtime·nohash) {
 		// calling nohash will panic too,
 		// but we can print a better error.
-		·newErrorString(catstring(gostringnocopy((byte*)"hash of unhashable type "), *t->string), &err);
-		·panic(err);
+		runtime·newErrorString(runtime·catstring(runtime·gostringnocopy((byte*)"hash of unhashable type "), *t->string), &err);
+		runtime·panic(err);
 	}
 	if(wid <= sizeof(data))
-		return algarray[alg].hash(wid, &data);
-	return algarray[alg].hash(wid, data);
+		return runtime·algarray[alg].hash(wid, &data);
+	return runtime·algarray[alg].hash(wid, data);
 }
 
 uintptr
-ifacehash(Iface a)
+runtime·ifacehash(Iface a)
 {
 	if(a.tab == nil)
 		return 0;
@@ -536,7 +536,7 @@
 }
 
 uintptr
-efacehash(Eface a)
+runtime·efacehash(Eface a)
 {
 	return ifacehash1(a.data, a.type);
 }
@@ -550,20 +550,20 @@
 	alg = t->alg;
 	wid = t->size;
 
-	if(algarray[alg].equal == noequal) {
+	if(runtime·algarray[alg].equal == runtime·noequal) {
 		// calling noequal will panic too,
 		// but we can print a better error.
-		·newErrorString(catstring(gostringnocopy((byte*)"comparing uncomparable type "), *t->string), &err);
-		·panic(err);
+		runtime·newErrorString(runtime·catstring(runtime·gostringnocopy((byte*)"comparing uncomparable type "), *t->string), &err);
+		runtime·panic(err);
 	}
 
 	if(wid <= sizeof(data1))
-		return algarray[alg].equal(wid, &data1, &data2);
-	return algarray[alg].equal(wid, data1, data2);
+		return runtime·algarray[alg].equal(wid, &data1, &data2);
+	return runtime·algarray[alg].equal(wid, data1, data2);
 }
 
 bool
-ifaceeq(Iface i1, Iface i2)
+runtime·ifaceeq_c(Iface i1, Iface i2)
 {
 	if(i1.tab != i2.tab)
 		return false;
@@ -573,7 +573,7 @@
 }
 
 bool
-efaceeq(Eface e1, Eface e2)
+runtime·efaceeq_c(Eface e1, Eface e2)
 {
 	if(e1.type != e2.type)
 		return false;
@@ -584,23 +584,23 @@
 
 // ifaceeq(i1 any, i2 any) (ret bool);
 void
-·ifaceeq(Iface i1, Iface i2, bool ret)
+runtime·ifaceeq(Iface i1, Iface i2, bool ret)
 {
-	ret = ifaceeq(i1, i2);
+	ret = runtime·ifaceeq_c(i1, i2);
 	FLUSH(&ret);
 }
 
 // efaceeq(i1 any, i2 any) (ret bool)
 void
-·efaceeq(Eface e1, Eface e2, bool ret)
+runtime·efaceeq(Eface e1, Eface e2, bool ret)
 {
-	ret = efaceeq(e1, e2);
+	ret = runtime·efaceeq_c(e1, e2);
 	FLUSH(&ret);
 }
 
 // ifacethash(i1 any) (ret uint32);
 void
-·ifacethash(Iface i1, uint32 ret)
+runtime·ifacethash(Iface i1, uint32 ret)
 {
 	Itab *tab;
 
@@ -613,7 +613,7 @@
 
 // efacethash(e1 any) (ret uint32)
 void
-·efacethash(Eface e1, uint32 ret)
+runtime·efacethash(Eface e1, uint32 ret)
 {
 	Type *t;
 
@@ -625,18 +625,6 @@
 }
 
 void
-·printiface(Iface i)
-{
-	printiface(i);
-}
-
-void
-·printeface(Eface e)
-{
-	printeface(e);
-}
-
-void
 unsafe·Typeof(Eface e, Eface ret)
 {
 	if(e.type == nil) {
@@ -662,17 +650,17 @@
 		if(e.type->size <= sizeof(uintptr)) {
 			// Copy data into x ...
 			x = 0;
-			algarray[e.type->alg].copy(e.type->size, &x, &e.data);
+			runtime·algarray[e.type->alg].copy(e.type->size, &x, &e.data);
 
 			// but then build pointer to x so that Reflect
 			// always returns pointer to data.
-			p = mal(sizeof(uintptr));
+			p = runtime·mal(sizeof(uintptr));
 			*p = x;
 		} else {
 			// Already a pointer, but still make a copy,
 			// to preserve value semantics for interface data.
-			p = mal(e.type->size);
-			algarray[e.type->alg].copy(e.type->size, p, e.data);
+			p = runtime·mal(e.type->size);
+			runtime·algarray[e.type->alg].copy(e.type->size, p, e.data);
 		}
 		retaddr = p;
 	}
@@ -692,7 +680,7 @@
 	// Interface holds either pointer to data
 	// or copy of original data.
 	if(e.type->size <= sizeof(uintptr))
-		algarray[e.type->alg].copy(e.type->size, &e.data, addr);
+		runtime·algarray[e.type->alg].copy(e.type->size, &e.data, addr);
 	else {
 		// Easier: already a pointer to data.
 		// TODO(rsc): Should this make a copy?
@@ -714,9 +702,9 @@
 	t = (Type*)((Eface*)typ.data-1);
 
 	if(t->kind&KindNoPointers)
-		ret = mallocgc(t->size, RefNoPointers, 1, 1);
+		ret = runtime·mallocgc(t->size, RefNoPointers, 1, 1);
 	else
-		ret = mal(t->size);
+		ret = runtime·mal(t->size);
 	FLUSH(&ret);
 }
 
@@ -734,8 +722,8 @@
 	
 	size = n*t->size;
 	if(t->kind&KindNoPointers)
-		ret = mallocgc(size, RefNoPointers, 1, 1);
+		ret = runtime·mallocgc(size, RefNoPointers, 1, 1);
 	else
-		ret = mal(size);
+		ret = runtime·mal(size);
 	FLUSH(&ret);
 }
diff --git a/src/pkg/runtime/linux/386/rt0.s b/src/pkg/runtime/linux/386/rt0.s
index 4d2345d..223e6d2 100644
--- a/src/pkg/runtime/linux/386/rt0.s
+++ b/src/pkg/runtime/linux/386/rt0.s
@@ -4,6 +4,6 @@
 
 // Darwin and Linux use the same linkage to main
 
-TEXT	_rt0_386_linux(SB),7,$0
+TEXT _rt0_386_linux(SB),7,$0
 	JMP	_rt0_386(SB)
 
diff --git a/src/pkg/runtime/linux/386/signal.c b/src/pkg/runtime/linux/386/signal.c
index 6bc95d0..0dbfcf9 100644
--- a/src/pkg/runtime/linux/386/signal.c
+++ b/src/pkg/runtime/linux/386/signal.c
@@ -8,41 +8,41 @@
 #include "os.h"
 
 void
-dumpregs(Sigcontext *r)
+runtime·dumpregs(Sigcontext *r)
 {
-	printf("eax     %x\n", r->eax);
-	printf("ebx     %x\n", r->ebx);
-	printf("ecx     %x\n", r->ecx);
-	printf("edx     %x\n", r->edx);
-	printf("edi     %x\n", r->edi);
-	printf("esi     %x\n", r->esi);
-	printf("ebp     %x\n", r->ebp);
-	printf("esp     %x\n", r->esp);
-	printf("eip     %x\n", r->eip);
-	printf("eflags  %x\n", r->eflags);
-	printf("cs      %x\n", r->cs);
-	printf("fs      %x\n", r->fs);
-	printf("gs      %x\n", r->gs);
+	runtime·printf("eax     %x\n", r->eax);
+	runtime·printf("ebx     %x\n", r->ebx);
+	runtime·printf("ecx     %x\n", r->ecx);
+	runtime·printf("edx     %x\n", r->edx);
+	runtime·printf("edi     %x\n", r->edi);
+	runtime·printf("esi     %x\n", r->esi);
+	runtime·printf("ebp     %x\n", r->ebp);
+	runtime·printf("esp     %x\n", r->esp);
+	runtime·printf("eip     %x\n", r->eip);
+	runtime·printf("eflags  %x\n", r->eflags);
+	runtime·printf("cs      %x\n", r->cs);
+	runtime·printf("fs      %x\n", r->fs);
+	runtime·printf("gs      %x\n", r->gs);
 }
 
 /*
  * This assembler routine takes the args from registers, puts them on the stack,
  * and calls sighandler().
  */
-extern void sigtramp(void);
-extern void sigignore(void);	// just returns
-extern void sigreturn(void);	// calls sigreturn
+extern void runtime·sigtramp(void);
+extern void runtime·sigignore(void);	// just returns
+extern void runtime·sigreturn(void);	// calls runtime·sigreturn
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo* info, void* context)
+runtime·sighandler(int32 sig, Siginfo* info, void* context)
 {
 	Ucontext *uc;
 	Sigcontext *r;
@@ -52,7 +52,7 @@
 	uc = context;
 	r = &uc->uc_mcontext;
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Make it look like a call to the signal func.
 		// Have to pass arguments out of band since
 		// augmenting the stack frame would break
@@ -61,84 +61,84 @@
 		gp->sigcode0 = info->si_code;
 		gp->sigcode1 = ((uintptr*)info)[3];
 
-		// Only push sigpanic if r->eip != 0.
+		// Only push runtime·sigpanic if r->eip != 0.
 		// If r->eip == 0, probably panicked because of a
 		// call to a nil func.  Not pushing that onto sp will
-		// make the trace look like a call to sigpanic instead.
-		// (Otherwise the trace will end at sigpanic and we
+		// make the trace look like a call to runtime·sigpanic instead.
+		// (Otherwise the trace will end at runtime·sigpanic and we
 		// won't get to see who faulted.)
 		if(r->eip != 0) {
 			sp = (uintptr*)r->esp;
 			*--sp = r->eip;
 			r->esp = (uintptr)sp;
 		}
-		r->eip = (uintptr)sigpanic;
+		r->eip = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG)
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	else
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 
-	printf("PC=%X\n", r->eip);
-	printf("\n");
+	runtime·printf("PC=%X\n", r->eip);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->eip, (void*)r->esp, 0, m->curg);
-		tracebackothers(m->curg);
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->eip, (void*)r->esp, 0, m->curg);
+		runtime·tracebackothers(m->curg);
+		runtime·dumpregs(r);
 	}
 
-	breakpoint();
-	exit(2);
+	runtime·breakpoint();
+	runtime·exit(2);
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	Sigaltstack st;
 
 	st.ss_sp = p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	int32 i;
 	sa.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTORER;
 	sa.sa_mask = 0xFFFFFFFFFFFFFFFFULL;
-	sa.sa_restorer = (void*)sigreturn;
+	sa.sa_restorer = (void*)runtime·sigreturn;
 	for(i = 0; i<NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue))
-				sa.k_sa_handler = (void*)sigtramp;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+				sa.k_sa_handler = (void*)runtime·sigtramp;
 			else
-				sa.k_sa_handler = (void*)sigignore;
-			if(sigtab[i].flags & SigRestart)
+				sa.k_sa_handler = (void*)runtime·sigignore;
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
-			rt_sigaction(i, &sa, nil, 8);
+			runtime·rt_sigaction(i, &sa, nil, 8);
 		}
 	}
 }
diff --git a/src/pkg/runtime/linux/386/sys.s b/src/pkg/runtime/linux/386/sys.s
index d13f8589..a1505b0 100644
--- a/src/pkg/runtime/linux/386/sys.s
+++ b/src/pkg/runtime/linux/386/sys.s
@@ -8,21 +8,21 @@
 
 #include "386/asm.h"
 
-TEXT exit(SB),7,$0
+TEXT runtime·exit(SB),7,$0
 	MOVL	$252, AX	// syscall number
 	MOVL	4(SP), BX
 	INT	$0x80
 	INT $3	// not reached
 	RET
 
-TEXT exit1(SB),7,$0
+TEXT runtime·exit1(SB),7,$0
 	MOVL	$1, AX	// exit - exit the current os thread
 	MOVL	4(SP), BX
 	INT	$0x80
 	INT $3	// not reached
 	RET
 
-TEXT write(SB),7,$0
+TEXT runtime·write(SB),7,$0
 	MOVL	$4, AX		// syscall - write
 	MOVL	4(SP),  BX
 	MOVL	8(SP), CX
@@ -30,7 +30,7 @@
 	INT	$0x80
 	RET
 
-TEXT	gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
 	MOVL	$78, AX			// syscall - gettimeofday
 	LEAL	8(SP), BX
 	MOVL	$0, CX
@@ -47,7 +47,7 @@
 	MOVL	BX, (DI)
 	RET
 
-TEXT rt_sigaction(SB),7,$0
+TEXT runtime·rt_sigaction(SB),7,$0
 	MOVL	$174, AX		// syscall - rt_sigaction
 	MOVL	4(SP), BX
 	MOVL	8(SP), CX
@@ -56,7 +56,7 @@
 	INT	$0x80
 	RET
 
-TEXT sigtramp(SB),7,$40
+TEXT runtime·sigtramp(SB),7,$40
 	get_tls(CX)
 	
 	// save g
@@ -76,7 +76,7 @@
 	MOVL	context+8(FP), BX
 	MOVL	BX, 8(SP)
 
-	CALL	sighandler(SB)
+	CALL	runtime·sighandler(SB)
 	
 	// restore g
 	get_tls(CX)
@@ -85,16 +85,16 @@
 	
 	RET
 
-TEXT sigignore(SB),7,$0
+TEXT runtime·sigignore(SB),7,$0
 	RET
 
-TEXT sigreturn(SB),7,$0
+TEXT runtime·sigreturn(SB),7,$0
 	MOVL	$173, AX	// rt_sigreturn
 	INT $0x80
 	INT $3	// not reached
 	RET
 
-TEXT ·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVL	$192, AX	// mmap2
 	MOVL	4(SP), BX
 	MOVL	8(SP), CX
@@ -110,7 +110,7 @@
 	INCL	AX
 	RET
 
-TEXT ·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	MOVL	$91, AX	// munmap
 	MOVL	4(SP), BX
 	MOVL	8(SP), CX
@@ -122,7 +122,7 @@
 
 // int32 futex(int32 *uaddr, int32 op, int32 val,
 //	struct timespec *timeout, int32 *uaddr2, int32 val2);
-TEXT futex(SB),7,$0
+TEXT runtime·futex(SB),7,$0
 	MOVL	$240, AX	// futex
 	MOVL	4(SP), BX
 	MOVL	8(SP), CX
@@ -134,7 +134,7 @@
 	RET
 
 // int32 clone(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
-TEXT clone(SB),7,$0
+TEXT runtime·clone(SB),7,$0
 	MOVL	$120, AX	// clone
 	MOVL	flags+4(SP), BX
 	MOVL	stack+8(SP), CX
@@ -185,7 +185,7 @@
 	PUSHL	$32	// sizeof tls
 	PUSHL	BP	// &tls
 	PUSHL	DI	// tls #
-	CALL	setldt(SB)
+	CALL	runtime·setldt(SB)
 	POPL	AX
 	POPL	AX
 	POPL	AX
@@ -196,21 +196,21 @@
 	MOVL	DX, g(AX)
 	MOVL	BX, m(AX)
 
-	CALL	stackcheck(SB)	// smashes AX, CX
+	CALL	runtime·stackcheck(SB)	// smashes AX, CX
 	MOVL	0(DX), DX	// paranoia; check they are not nil
 	MOVL	0(BX), BX
 
 	// more paranoia; check that stack splitting code works
 	PUSHAL
-	CALL	emptyfunc(SB)
+	CALL	runtime·emptyfunc(SB)
 	POPAL
 
 	CALL	SI	// fn()
-	CALL	exit1(SB)
+	CALL	runtime·exit1(SB)
 	MOVL	$0x1234, 0x1005
 	RET
 
-TEXT sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),7,$-8
 	MOVL	$186, AX	// sigaltstack
 	MOVL	new+4(SP), BX
 	MOVL	old+8(SP), CX
@@ -243,7 +243,7 @@
 #define USEABLE 0x40
 
 // setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$32
+TEXT runtime·setldt(SB),7,$32
 	MOVL	entry+0(FP), BX	// entry
 	MOVL	address+4(FP), CX	// base address
 
diff --git a/src/pkg/runtime/linux/amd64/rt0.s b/src/pkg/runtime/linux/amd64/rt0.s
index 2190b44..dac9ae1 100644
--- a/src/pkg/runtime/linux/amd64/rt0.s
+++ b/src/pkg/runtime/linux/amd64/rt0.s
@@ -4,7 +4,7 @@
 
 // Darwin and Linux use the same linkage to main
 
-TEXT	_rt0_amd64_linux(SB),7,$-8
+TEXT _rt0_amd64_linux(SB),7,$-8
 	MOVQ	$_rt0_amd64(SB), AX
 	MOVQ	SP, DI
 	JMP	AX
diff --git a/src/pkg/runtime/linux/amd64/signal.c b/src/pkg/runtime/linux/amd64/signal.c
index e46a094..e78bbda 100644
--- a/src/pkg/runtime/linux/amd64/signal.c
+++ b/src/pkg/runtime/linux/amd64/signal.c
@@ -8,49 +8,49 @@
 #include "os.h"
 
 void
-dumpregs(Sigcontext *r)
+runtime·dumpregs(Sigcontext *r)
 {
-	printf("rax     %X\n", r->rax);
-	printf("rbx     %X\n", r->rbx);
-	printf("rcx     %X\n", r->rcx);
-	printf("rdx     %X\n", r->rdx);
-	printf("rdi     %X\n", r->rdi);
-	printf("rsi     %X\n", r->rsi);
-	printf("rbp     %X\n", r->rbp);
-	printf("rsp     %X\n", r->rsp);
-	printf("r8      %X\n", r->r8 );
-	printf("r9      %X\n", r->r9 );
-	printf("r10     %X\n", r->r10);
-	printf("r11     %X\n", r->r11);
-	printf("r12     %X\n", r->r12);
-	printf("r13     %X\n", r->r13);
-	printf("r14     %X\n", r->r14);
-	printf("r15     %X\n", r->r15);
-	printf("rip     %X\n", r->rip);
-	printf("rflags  %X\n", r->eflags);
-	printf("cs      %X\n", (uint64)r->cs);
-	printf("fs      %X\n", (uint64)r->fs);
-	printf("gs      %X\n", (uint64)r->gs);
+	runtime·printf("rax     %X\n", r->rax);
+	runtime·printf("rbx     %X\n", r->rbx);
+	runtime·printf("rcx     %X\n", r->rcx);
+	runtime·printf("rdx     %X\n", r->rdx);
+	runtime·printf("rdi     %X\n", r->rdi);
+	runtime·printf("rsi     %X\n", r->rsi);
+	runtime·printf("rbp     %X\n", r->rbp);
+	runtime·printf("rsp     %X\n", r->rsp);
+	runtime·printf("r8      %X\n", r->r8 );
+	runtime·printf("r9      %X\n", r->r9 );
+	runtime·printf("r10     %X\n", r->r10);
+	runtime·printf("r11     %X\n", r->r11);
+	runtime·printf("r12     %X\n", r->r12);
+	runtime·printf("r13     %X\n", r->r13);
+	runtime·printf("r14     %X\n", r->r14);
+	runtime·printf("r15     %X\n", r->r15);
+	runtime·printf("rip     %X\n", r->rip);
+	runtime·printf("rflags  %X\n", r->eflags);
+	runtime·printf("cs      %X\n", (uint64)r->cs);
+	runtime·printf("fs      %X\n", (uint64)r->fs);
+	runtime·printf("gs      %X\n", (uint64)r->gs);
 }
 
 /*
  * This assembler routine takes the args from registers, puts them on the stack,
  * and calls sighandler().
  */
-extern void sigtramp(void);
-extern void sigignore(void);	// just returns
-extern void sigreturn(void);	// calls sigreturn
+extern void runtime·sigtramp(void);
+extern void runtime·sigignore(void);	// just returns
+extern void runtime·sigreturn(void);	// calls runtime·sigreturn
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo* info, void* context)
+runtime·sighandler(int32 sig, Siginfo* info, void* context)
 {
 	Ucontext *uc;
 	Mcontext *mc;
@@ -62,7 +62,7 @@
 	mc = &uc->uc_mcontext;
 	r = (Sigcontext*)mc;	// same layout, more conveient names
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Make it look like a call to the signal func.
 		// Have to pass arguments out of band since
 		// augmenting the stack frame would break
@@ -71,84 +71,84 @@
 		gp->sigcode0 = info->si_code;
 		gp->sigcode1 = ((uintptr*)info)[2];
 
-		// Only push sigpanic if r->rip != 0.
+		// Only push runtime·sigpanic if r->rip != 0.
 		// If r->rip == 0, probably panicked because of a
 		// call to a nil func.  Not pushing that onto sp will
-		// make the trace look like a call to sigpanic instead.
-		// (Otherwise the trace will end at sigpanic and we
+		// make the trace look like a call to runtime·sigpanic instead.
+		// (Otherwise the trace will end at runtime·sigpanic and we
 		// won't get to see who faulted.)
 		if(r->rip != 0) {
 			sp = (uintptr*)r->rsp;
 			*--sp = r->rip;
 			r->rsp = (uintptr)sp;
 		}
-		r->rip = (uintptr)sigpanic;
+		r->rip = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG)
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	else
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 
-	printf("PC=%X\n", r->rip);
-	printf("\n");
+	runtime·printf("PC=%X\n", r->rip);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->rip, (void*)r->rsp, 0, g);
-		tracebackothers(g);
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->rip, (void*)r->rsp, 0, g);
+		runtime·tracebackothers(g);
+		runtime·dumpregs(r);
 	}
 
-	breakpoint();
-	exit(2);
+	runtime·breakpoint();
+	runtime·exit(2);
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	Sigaltstack st;
 
 	st.ss_sp = p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	int32 i;
 	sa.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTORER;
 	sa.sa_mask = 0xFFFFFFFFFFFFFFFFULL;
-	sa.sa_restorer = (void*)sigreturn;
+	sa.sa_restorer = (void*)runtime·sigreturn;
 	for(i = 0; i<NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue))
-				sa.sa_handler = (void*)sigtramp;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+				sa.sa_handler = (void*)runtime·sigtramp;
 			else
-				sa.sa_handler = (void*)sigignore;
-			if(sigtab[i].flags & SigRestart)
+				sa.sa_handler = (void*)runtime·sigignore;
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
-			rt_sigaction(i, &sa, nil, 8);
+			runtime·rt_sigaction(i, &sa, nil, 8);
 		}
 	}
 }
diff --git a/src/pkg/runtime/linux/amd64/sys.s b/src/pkg/runtime/linux/amd64/sys.s
index 73db9d7..170b659 100644
--- a/src/pkg/runtime/linux/amd64/sys.s
+++ b/src/pkg/runtime/linux/amd64/sys.s
@@ -8,19 +8,19 @@
 
 #include "amd64/asm.h"
 
-TEXT	exit(SB),7,$0-8
+TEXT runtime·exit(SB),7,$0-8
 	MOVL	8(SP), DI
 	MOVL	$231, AX	// exitgroup - force all os threads to exit
 	SYSCALL
 	RET
 
-TEXT	exit1(SB),7,$0-8
+TEXT runtime·exit1(SB),7,$0-8
 	MOVL	8(SP), DI
 	MOVL	$60, AX	// exit - exit the current os thread
 	SYSCALL
 	RET
 
-TEXT	open(SB),7,$0-16
+TEXT runtime·open(SB),7,$0-16
 	MOVQ	8(SP), DI
 	MOVL	16(SP), SI
 	MOVL	20(SP), DX
@@ -28,7 +28,7 @@
 	SYSCALL
 	RET
 
-TEXT	write(SB),7,$0-24
+TEXT runtime·write(SB),7,$0-24
 	MOVL	8(SP), DI
 	MOVQ	16(SP), SI
 	MOVL	24(SP), DX
@@ -36,7 +36,7 @@
 	SYSCALL
 	RET
 
-TEXT	gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
 	LEAQ	8(SP), DI
 	MOVQ	$0, SI
 	MOVQ	$0xffffffffff600000, AX
@@ -51,7 +51,7 @@
 	MOVL	BX, (DI)
 	RET
 
-TEXT	rt_sigaction(SB),7,$0-32
+TEXT runtime·rt_sigaction(SB),7,$0-32
 	MOVL	8(SP), DI
 	MOVQ	16(SP), SI
 	MOVQ	24(SP), DX
@@ -60,7 +60,7 @@
 	SYSCALL
 	RET
 
-TEXT	sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),7,$64
 	get_tls(BX)
 
 	// save g
@@ -75,7 +75,7 @@
 	MOVQ	DI, 0(SP)
 	MOVQ	SI, 8(SP)
 	MOVQ	DX, 16(SP)
-	CALL	sighandler(SB)
+	CALL	runtime·sighandler(SB)
 
 	// restore g
 	get_tls(BX)
@@ -83,15 +83,15 @@
 	MOVQ	BP, g(BX)
 	RET
 
-TEXT	sigignore(SB),7,$0
+TEXT runtime·sigignore(SB),7,$0
 	RET
 
-TEXT	sigreturn(SB),7,$0
+TEXT runtime·sigreturn(SB),7,$0
 	MOVL	$15, AX	// rt_sigreturn
 	SYSCALL
 	INT $3	// not reached
 
-TEXT	·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVQ	8(SP), DI
 	MOVQ	$0, SI
 	MOVQ	16(SP), SI
@@ -108,24 +108,24 @@
 	INCQ	AX
 	RET
 
-TEXT	·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	MOVQ	8(SP), DI
 	MOVQ	16(SP), SI
 	MOVQ	$11, AX	// munmap
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT	notok(SB),7,$0
+TEXT runtime·notok(SB),7,$0
 	MOVQ	$0xf1, BP
 	MOVQ	BP, (BP)
 	RET
 
 // int64 futex(int32 *uaddr, int32 op, int32 val,
 //	struct timespec *timeout, int32 *uaddr2, int32 val2);
-TEXT	futex(SB),7,$0
+TEXT runtime·futex(SB),7,$0
 	MOVQ	8(SP), DI
 	MOVL	16(SP), SI
 	MOVL	20(SP), DX
@@ -137,7 +137,7 @@
 	RET
 
 // int64 clone(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
-TEXT	clone(SB),7,$0
+TEXT runtime·clone(SB),7,$0
 	MOVL	flags+8(SP), DI
 	MOVQ	stack+16(SP), SI
 
@@ -165,13 +165,13 @@
 
 	// Set FS to point at m->tls.
 	LEAQ	m_tls(R8), DI
-	CALL	settls(SB)
+	CALL	runtime·settls(SB)
 
 	// In child, set up new stack
 	get_tls(CX)
 	MOVQ	R8, m(CX)
 	MOVQ	R9, g(CX)
-	CALL	stackcheck(SB)
+	CALL	runtime·stackcheck(SB)
 
 	// Call fn
 	CALL	R12
@@ -182,18 +182,18 @@
 	SYSCALL
 	JMP	-3(PC)	// keep exiting
 
-TEXT	sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),7,$-8
 	MOVQ	new+8(SP), DI
 	MOVQ	old+16(SP), SI
 	MOVQ	$131, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // set tls base to DI
-TEXT settls(SB),7,$32
+TEXT runtime·settls(SB),7,$32
 	ADDQ	$16, DI	// ELF wants to use -16(FS), -8(FS)
 
 	MOVQ	DI, SI
@@ -202,6 +202,6 @@
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
diff --git a/src/pkg/runtime/linux/arm/rt0.s b/src/pkg/runtime/linux/arm/rt0.s
index 024547d..8838b48 100644
--- a/src/pkg/runtime/linux/arm/rt0.s
+++ b/src/pkg/runtime/linux/arm/rt0.s
@@ -2,5 +2,5 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-TEXT	_rt0_arm_linux(SB),7,$0
+TEXT _rt0_arm_linux(SB),7,$0
 	B	_rt0_arm(SB)
diff --git a/src/pkg/runtime/linux/arm/signal.c b/src/pkg/runtime/linux/arm/signal.c
index a9dccae..c65aff9 100644
--- a/src/pkg/runtime/linux/arm/signal.c
+++ b/src/pkg/runtime/linux/arm/signal.c
@@ -8,49 +8,49 @@
 #include "os.h"
 
 void
-dumpregs(Sigcontext *r)
+runtime·dumpregs(Sigcontext *r)
 {
-	printf("trap    %x\n", r->trap_no);
-	printf("error   %x\n", r->error_code);
-	printf("oldmask %x\n", r->oldmask);
-	printf("r0      %x\n", r->arm_r0);
-	printf("r1      %x\n", r->arm_r1);
-	printf("r2      %x\n", r->arm_r2);
-	printf("r3      %x\n", r->arm_r3);
-	printf("r4      %x\n", r->arm_r4);
-	printf("r5      %x\n", r->arm_r5);
-	printf("r6      %x\n", r->arm_r6);
-	printf("r7      %x\n", r->arm_r7);
-	printf("r8      %x\n", r->arm_r8);
-	printf("r9      %x\n", r->arm_r9);
-	printf("r10     %x\n", r->arm_r10);
-	printf("fp      %x\n", r->arm_fp);
-	printf("ip      %x\n", r->arm_ip);
-	printf("sp      %x\n", r->arm_sp);
-	printf("lr      %x\n", r->arm_lr);
-	printf("pc      %x\n", r->arm_pc);
-	printf("cpsr    %x\n", r->arm_cpsr);
-	printf("fault   %x\n", r->fault_address);
+	runtime·printf("trap    %x\n", r->trap_no);
+	runtime·printf("error   %x\n", r->error_code);
+	runtime·printf("oldmask %x\n", r->oldmask);
+	runtime·printf("r0      %x\n", r->arm_r0);
+	runtime·printf("r1      %x\n", r->arm_r1);
+	runtime·printf("r2      %x\n", r->arm_r2);
+	runtime·printf("r3      %x\n", r->arm_r3);
+	runtime·printf("r4      %x\n", r->arm_r4);
+	runtime·printf("r5      %x\n", r->arm_r5);
+	runtime·printf("r6      %x\n", r->arm_r6);
+	runtime·printf("r7      %x\n", r->arm_r7);
+	runtime·printf("r8      %x\n", r->arm_r8);
+	runtime·printf("r9      %x\n", r->arm_r9);
+	runtime·printf("r10     %x\n", r->arm_r10);
+	runtime·printf("fp      %x\n", r->arm_fp);
+	runtime·printf("ip      %x\n", r->arm_ip);
+	runtime·printf("sp      %x\n", r->arm_sp);
+	runtime·printf("lr      %x\n", r->arm_lr);
+	runtime·printf("pc      %x\n", r->arm_pc);
+	runtime·printf("cpsr    %x\n", r->arm_cpsr);
+	runtime·printf("fault   %x\n", r->fault_address);
 }
 
 /*
  * This assembler routine takes the args from registers, puts them on the stack,
  * and calls sighandler().
  */
-extern void sigtramp(void);
-extern void sigignore(void);	// just returns
-extern void sigreturn(void);	// calls sigreturn
+extern void runtime·sigtramp(void);
+extern void runtime·sigignore(void);	// just returns
+extern void runtime·sigreturn(void);	// calls runtime·sigreturn
 
 String
-signame(int32 sig)
+runtime·signame(int32 sig)
 {
 	if(sig < 0 || sig >= NSIG)
-		return emptystring;
-	return gostringnocopy((byte*)sigtab[sig].name);
+		return runtime·emptystring;
+	return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
 }
 
 void
-sighandler(int32 sig, Siginfo *info, void *context)
+runtime·sighandler(int32 sig, Siginfo *info, void *context)
 {
 	Ucontext *uc;
 	Sigcontext *r;
@@ -59,7 +59,7 @@
 	uc = context;
 	r = &uc->uc_mcontext;
 
-	if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+	if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
 		// Make it look like a call to the signal func.
 		// Have to pass arguments out of band since
 		// augmenting the stack frame would break
@@ -75,75 +75,75 @@
 		// old link register is more useful in the stack trace.
 		if(r->arm_pc != 0)
 			r->arm_lr = r->arm_pc;
-		r->arm_pc = (uintptr)sigpanic;
+		r->arm_pc = (uintptr)runtime·sigpanic;
 		return;
 	}
 
-	if(sigtab[sig].flags & SigQueue) {
-		if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+	if(runtime·sigtab[sig].flags & SigQueue) {
+		if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
 			return;
-		exit(2);	// SIGINT, SIGTERM, etc
+		runtime·exit(2);	// SIGINT, SIGTERM, etc
 	}
 
-	if(panicking)	// traceback already printed
-		exit(2);
-	panicking = 1;
+	if(runtime·panicking)	// traceback already printed
+		runtime·exit(2);
+	runtime·panicking = 1;
 
 	if(sig < 0 || sig >= NSIG)
-		printf("Signal %d\n", sig);
+		runtime·printf("Signal %d\n", sig);
 	else
-		printf("%s\n", sigtab[sig].name);
+		runtime·printf("%s\n", runtime·sigtab[sig].name);
 
-	printf("PC=%x\n", r->arm_pc);
-	printf("\n");
+	runtime·printf("PC=%x\n", r->arm_pc);
+	runtime·printf("\n");
 
-	if(gotraceback()){
-		traceback((void*)r->arm_pc, (void*)r->arm_sp, (void*)r->arm_lr, m->curg);
-		tracebackothers(m->curg);
-		printf("\n");
-		dumpregs(r);
+	if(runtime·gotraceback()){
+		runtime·traceback((void*)r->arm_pc, (void*)r->arm_sp, (void*)r->arm_lr, m->curg);
+		runtime·tracebackothers(m->curg);
+		runtime·printf("\n");
+		runtime·dumpregs(r);
 	}
 
 //	breakpoint();
-	exit(2);
+	runtime·exit(2);
 }
 
 void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
 {
 	Sigaltstack st;
 
 	st.ss_sp = p;
 	st.ss_size = n;
 	st.ss_flags = 0;
-	sigaltstack(&st, nil);
+	runtime·sigaltstack(&st, nil);
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 	static Sigaction sa;
 
-	siginit();
+	runtime·siginit();
 
 	int32 i;
 	sa.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTORER;
 	sa.sa_mask.sig[0] = 0xFFFFFFFF;
 	sa.sa_mask.sig[1] = 0xFFFFFFFF;
-	sa.sa_restorer = (void*)sigreturn;
+	sa.sa_restorer = (void*)runtime·sigreturn;
 	for(i = 0; i<NSIG; i++) {
-		if(sigtab[i].flags) {
-			if((sigtab[i].flags & SigQueue) != queue)
+		if(runtime·sigtab[i].flags) {
+			if((runtime·sigtab[i].flags & SigQueue) != queue)
 				continue;
-			if(sigtab[i].flags & (SigCatch | SigQueue))
-				sa.sa_handler = (void*)sigtramp;
+			if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+				sa.sa_handler = (void*)runtime·sigtramp;
 			else
-				sa.sa_handler = (void*)sigignore;
-			if(sigtab[i].flags & SigRestart)
+				sa.sa_handler = (void*)runtime·sigignore;
+			if(runtime·sigtab[i].flags & SigRestart)
 				sa.sa_flags |= SA_RESTART;
 			else
 				sa.sa_flags &= ~SA_RESTART;
-			rt_sigaction(i, &sa, nil, 8);
+			runtime·rt_sigaction(i, &sa, nil, 8);
 		}
 	}
 }
diff --git a/src/pkg/runtime/linux/arm/sys.s b/src/pkg/runtime/linux/arm/sys.s
index 2554d32..b25cf81 100644
--- a/src/pkg/runtime/linux/arm/sys.s
+++ b/src/pkg/runtime/linux/arm/sys.s
@@ -30,7 +30,7 @@
 #define ARM_BASE (SYS_BASE + 0x0f0000)
 #define SYS_ARM_cacheflush (ARM_BASE + 2)
 
-TEXT write(SB),7,$0
+TEXT runtime·write(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	8(FP), R2
@@ -38,7 +38,7 @@
 	SWI	$0
 	RET
 
-TEXT exit(SB),7,$-4
+TEXT runtime·exit(SB),7,$-4
 	MOVW	0(FP), R0
 	MOVW	$SYS_exit_group, R7
 	SWI	$0
@@ -46,7 +46,7 @@
 	MOVW	$1002, R1
 	MOVW	R0, (R1)	// fail hard
 
-TEXT exit1(SB),7,$-4
+TEXT runtime·exit1(SB),7,$-4
 	MOVW	0(FP), R0
 	MOVW	$SYS_exit, R7
 	SWI	$0
@@ -54,7 +54,7 @@
 	MOVW	$1003, R1
 	MOVW	R0, (R1)	// fail hard
 
-TEXT ·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	8(FP), R2
@@ -65,14 +65,14 @@
 	SWI	$0
 	RET
 
-TEXT ·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	$SYS_munmap, R7
 	SWI	$0
 	RET
 
-TEXT gettime(SB),7,$32
+TEXT runtime·gettime(SB),7,$32
 	/* dummy version - return 0,0 */
 	MOVW	$0, R1
 	MOVW	0(FP), R0
@@ -101,7 +101,7 @@
 
 // int32 futex(int32 *uaddr, int32 op, int32 val,
 //	struct timespec *timeout, int32 *uaddr2, int32 val2);
-TEXT futex(SB),7,$0
+TEXT runtime·futex(SB),7,$0
 	MOVW	4(SP), R0
 	MOVW	8(SP), R1
 	MOVW	12(SP), R2
@@ -114,7 +114,7 @@
 
 
 // int32 clone(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
-TEXT clone(SB),7,$0
+TEXT runtime·clone(SB),7,$0
 	MOVW	flags+0(FP), R0
 	MOVW	stack+4(FP), R1
 	MOVW	$0, R2	// parent tid ptr
@@ -147,7 +147,7 @@
 	MOVW	$1234, R1
 	CMP	R0, R1
 	BEQ	2(PC)
-	BL	abort(SB)
+	BL	runtime·abort(SB)
 
 	MOVW	0(R13), m
 	MOVW	4(R13), g
@@ -156,7 +156,7 @@
 	MOVW	0(m), R0
 	MOVW	0(g), R0
 
-	BL	emptyfunc(SB)	// fault if stack check is wrong
+	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
 
 	// Initialize m->procid to Linux tid
 	MOVW	$SYS_gettid, R7
@@ -170,7 +170,7 @@
 
 	MOVW	$0, R0
 	MOVW	R0, 4(R13)
-	BL	exit1(SB)
+	BL	runtime·exit1(SB)
 
 	// It shouldn't return
 	MOVW	$1234, R0
@@ -178,7 +178,7 @@
 	MOVW	R0, (R1)
 
 
-TEXT cacheflush(SB),7,$0
+TEXT runtime·cacheflush(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	$0, R2
@@ -186,25 +186,25 @@
 	SWI	$0
 	RET
 
-TEXT sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	$SYS_sigaltstack, R7
 	SWI	$0
 	RET
 
-TEXT sigignore(SB),7,$0
+TEXT runtime·sigignore(SB),7,$0
 	RET
 
-TEXT sigtramp(SB),7,$24
+TEXT runtime·sigtramp(SB),7,$24
 	MOVW	m_gsignal(m), g
 	MOVW	R0, 4(R13)
 	MOVW	R1, 8(R13)
 	MOVW	R2, 12(R13)
-	BL	sighandler(SB)
+	BL	runtime·sighandler(SB)
 	RET
 
-TEXT rt_sigaction(SB),7,$0
+TEXT runtime·rt_sigaction(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	8(FP), R2
@@ -213,7 +213,7 @@
 	SWI	$0
 	RET
 
-TEXT sigreturn(SB),7,$0
+TEXT runtime·sigreturn(SB),7,$0
 	MOVW	$SYS_rt_sigreturn, R7
 	SWI	$0
 	RET
diff --git a/src/pkg/runtime/linux/mem.c b/src/pkg/runtime/linux/mem.c
index 925e7fd..9bf054a 100644
--- a/src/pkg/runtime/linux/mem.c
+++ b/src/pkg/runtime/linux/mem.c
@@ -4,26 +4,26 @@
 #include "malloc.h"
 
 void*
-SysAlloc(uintptr n)
+runtime·SysAlloc(uintptr n)
 {
 	void *p;
 
 	mstats.sys += n;
-	p = runtime_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
+	p = runtime·mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
 	if(p < (void*)4096) {
 		if(p == (void*)EACCES) {
-			printf("mmap: access denied\n");
-			printf("If you're running SELinux, enable execmem for this process.\n");
-			exit(2);
+			runtime·printf("mmap: access denied\n");
+			runtime·printf("If you're running SELinux, enable execmem for this process.\n");
+			runtime·exit(2);
 		}
-		printf("mmap: errno=%p\n", p);
-		throw("mmap");
+		runtime·printf("mmap: errno=%p\n", p);
+		runtime·throw("mmap");
 	}
 	return p;
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v);
 	USED(n);
@@ -31,14 +31,14 @@
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
 	mstats.sys -= n;
-	runtime_munmap(v, n);
+	runtime·munmap(v, n);
 }
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 	// Code generators assume that references to addresses
 	// on the first page will fault.  Map the page explicitly with
@@ -46,5 +46,5 @@
 	// allocating that page as the virtual address space fills.
 	// Ignore any error, since other systems might be smart
 	// enough to never allow anything there.
-	runtime_mmap(nil, 4096, PROT_NONE, MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
+	runtime·mmap(nil, 4096, PROT_NONE, MAP_FIXED|MAP_ANON|MAP_PRIVATE, -1, 0);
 }
diff --git a/src/pkg/runtime/linux/os.h b/src/pkg/runtime/linux/os.h
index 8ca26b7..772ade7 100644
--- a/src/pkg/runtime/linux/os.h
+++ b/src/pkg/runtime/linux/os.h
@@ -3,11 +3,11 @@
 // license that can be found in the LICENSE file.
 
 // Linux-specific system calls
-int32	futex(uint32*, int32, uint32, Timespec*, uint32*, uint32);
-int32	clone(int32, void*, M*, G*, void(*)(void));
+int32	runtime·futex(uint32*, int32, uint32, Timespec*, uint32*, uint32);
+int32	runtime·clone(int32, void*, M*, G*, void(*)(void));
 
 struct Sigaction;
-void	rt_sigaction(uintptr, struct Sigaction*, void*, uintptr);
+void	runtime·rt_sigaction(uintptr, struct Sigaction*, void*, uintptr);
 
-void	sigaltstack(Sigaltstack*, Sigaltstack*);
-void	sigpanic(void);
+void	runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
+void	runtime·sigpanic(void);
diff --git a/src/pkg/runtime/linux/signals.h b/src/pkg/runtime/linux/signals.h
index 788f682..1fc5f8c 100644
--- a/src/pkg/runtime/linux/signals.h
+++ b/src/pkg/runtime/linux/signals.h
@@ -8,7 +8,7 @@
 #define Q SigQueue
 #define P SigPanic
 
-SigTab sigtab[] = {
+SigTab runtime·sigtab[] = {
 	/* 0 */	0, "SIGNONE: no trap",
 	/* 1 */	Q+R, "SIGHUP: terminal line hangup",
 	/* 2 */	Q+R, "SIGINT: interrupt",
diff --git a/src/pkg/runtime/linux/thread.c b/src/pkg/runtime/linux/thread.c
index f31838e..9c9fc75 100644
--- a/src/pkg/runtime/linux/thread.c
+++ b/src/pkg/runtime/linux/thread.c
@@ -6,7 +6,7 @@
 #include "defs.h"
 #include "os.h"
 
-extern SigTab sigtab[];
+extern SigTab runtime·sigtab[];
 
 // Linux futex.
 //
@@ -48,7 +48,7 @@
 	// as an errno.  Libpthread ignores the return value
 	// here, and so can we: as it says a few lines up,
 	// spurious wakeups are allowed.
-	futex(addr, FUTEX_WAIT, val, &longtime, nil, 0);
+	runtime·futex(addr, FUTEX_WAIT, val, &longtime, nil, 0);
 }
 
 // If any procs are sleeping on addr, wake up at least one.
@@ -57,7 +57,7 @@
 {
 	int64 ret;
 
-	ret = futex(addr, FUTEX_WAKE, 1, nil, nil, 0);
+	ret = runtime·futex(addr, FUTEX_WAKE, 1, nil, nil, 0);
 
 	if(ret >= 0)
 		return;
@@ -66,11 +66,11 @@
 	// EAGAIN or EINTR, but if it does, it would be
 	// safe to loop and call futex again.
 
-	prints("futexwakeup addr=");
-	·printpointer(addr);
-	prints(" returned ");
-	·printint(ret);
-	prints("\n");
+	runtime·prints("futexwakeup addr=");
+	runtime·printpointer(addr);
+	runtime·prints(" returned ");
+	runtime·printint(ret);
+	runtime·prints("\n");
 	*(int32*)0x1006 = 0x1006;
 }
 
@@ -83,7 +83,7 @@
 // The uncontended case runs entirely in user space.
 // When contention is detected, we defer to the kernel (futex).
 //
-// A reminder: compare-and-swap cas(addr, old, new) does
+// A reminder: compare-and-swap runtime·cas(addr, old, new) does
 //	if(*addr == old) { *addr = new; return 1; }
 //	else return 0;
 // but atomically.
@@ -96,7 +96,7 @@
 again:
 	v = l->key;
 	if((v&1) == 0){
-		if(cas(&l->key, v, v|1)){
+		if(runtime·cas(&l->key, v, v|1)){
 			// Lock wasn't held; we grabbed it.
 			return;
 		}
@@ -104,7 +104,7 @@
 	}
 
 	// Lock was held; try to add ourselves to the waiter count.
-	if(!cas(&l->key, v, v+2))
+	if(!runtime·cas(&l->key, v, v+2))
 		goto again;
 
 	// We're accounted for, now sleep in the kernel.
@@ -122,8 +122,8 @@
 	for(;;){
 		v = l->key;
 		if(v < 2)
-			throw("bad lock key");
-		if(cas(&l->key, v, v-2))
+			runtime·throw("bad lock key");
+		if(runtime·cas(&l->key, v, v-2))
 			break;
 	}
 
@@ -140,8 +140,8 @@
 again:
 	v = l->key;
 	if((v&1) == 0)
-		throw("unlock of unlocked lock");
-	if(!cas(&l->key, v, v&~1))
+		runtime·throw("unlock of unlocked lock");
+	if(!runtime·cas(&l->key, v, v&~1))
 		goto again;
 
 	// If there were waiters, wake one.
@@ -150,25 +150,25 @@
 }
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 	futexlock(l);
 }
 
 void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	futexunlock(l);
 }
 
 void
-destroylock(Lock*)
+runtime·destroylock(Lock*)
 {
 }
 
@@ -186,20 +186,20 @@
 // you unlock the lock.
 
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	n->lock.key = 0;	// memset(n, 0, sizeof *n)
 	futexlock(&n->lock);
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	futexunlock(&n->lock);
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	futexlock(&n->lock);
 	futexunlock(&n->lock);	// Let other sleepers find out too.
@@ -230,7 +230,7 @@
 };
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	int32 ret;
 	int32 flags;
@@ -248,52 +248,52 @@
 
 	m->tls[0] = m->id;	// so 386 asm can find it
 	if(0){
-		printf("newosproc stk=%p m=%p g=%p fn=%p clone=%p id=%d/%d ostk=%p\n",
-			stk, m, g, fn, clone, m->id, m->tls[0], &m);
+		runtime·printf("newosproc stk=%p m=%p g=%p fn=%p clone=%p id=%d/%d ostk=%p\n",
+			stk, m, g, fn, runtime·clone, m->id, m->tls[0], &m);
 	}
 
-	ret = clone(flags, stk, m, g, fn);
+	ret = runtime·clone(flags, stk, m, g, fn);
 
 	if(ret < 0)
 		*(int32*)123 = 123;
 }
 
 void
-osinit(void)
+runtime·osinit(void)
 {
 }
 
 // Called to initialize a new m (including the bootstrap m).
 void
-minit(void)
+runtime·minit(void)
 {
 	// Initialize signal handling.
-	m->gsignal = malg(32*1024);	// OS X wants >=8K, Linux >=2K
-	signalstack(m->gsignal->stackguard, 32*1024);
+	m->gsignal = runtime·malg(32*1024);	// OS X wants >=8K, Linux >=2K
+	runtime·signalstack(m->gsignal->stackguard, 32*1024);
 }
 
 void
-sigpanic(void)
+runtime·sigpanic(void)
 {
 	switch(g->sig) {
 	case SIGBUS:
 		if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		printf("unexpected fault address %p\n", g->sigcode1);
-		throw("fault");
+			runtime·panicstring("invalid memory address or nil pointer dereference");
+		runtime·printf("unexpected fault address %p\n", g->sigcode1);
+		runtime·throw("fault");
 	case SIGSEGV:
 		if((g->sigcode0 == 0 || g->sigcode0 == SEGV_MAPERR || g->sigcode0 == SEGV_ACCERR) && g->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		printf("unexpected fault address %p\n", g->sigcode1);
-		throw("fault");
+			runtime·panicstring("invalid memory address or nil pointer dereference");
+		runtime·printf("unexpected fault address %p\n", g->sigcode1);
+		runtime·throw("fault");
 	case SIGFPE:
 		switch(g->sigcode0) {
 		case FPE_INTDIV:
-			panicstring("integer divide by zero");
+			runtime·panicstring("integer divide by zero");
 		case FPE_INTOVF:
-			panicstring("integer overflow");
+			runtime·panicstring("integer overflow");
 		}
-		panicstring("floating point error");
+		runtime·panicstring("floating point error");
 	}
-	panicstring(sigtab[g->sig].name);
+	runtime·panicstring(runtime·sigtab[g->sig].name);
 }
diff --git a/src/pkg/runtime/malloc.goc b/src/pkg/runtime/malloc.goc
index 604290b..405b05e 100644
--- a/src/pkg/runtime/malloc.goc
+++ b/src/pkg/runtime/malloc.goc
@@ -12,10 +12,10 @@
 #include "defs.h"
 #include "type.h"
 
-MHeap mheap;
-MStats mstats;
+MHeap runtime·mheap;
+extern MStats mstats;	// defined in extern.go
 
-extern volatile int32 ·MemProfileRate;
+extern volatile int32 runtime·MemProfileRate;
 
 // Same algorithm from chan.c, but a different
 // instance of the static uint32 x.
@@ -36,7 +36,7 @@
 // Small objects are allocated from the per-thread cache's free lists.
 // Large objects (> 32 kB) are allocated straight from the heap.
 void*
-mallocgc(uintptr size, uint32 refflag, int32 dogc, int32 zeroed)
+runtime·mallocgc(uintptr size, uint32 refflag, int32 dogc, int32 zeroed)
 {
 	int32 sizeclass, rate;
 	MCache *c;
@@ -45,10 +45,10 @@
 	void *v;
 	uint32 *ref;
 
-	if(gcwaiting && g != m->g0 && m->locks == 0)
-		gosched();
+	if(runtime·gcwaiting && g != m->g0 && m->locks == 0)
+		runtime·gosched();
 	if(m->mallocing)
-		throw("malloc/free - deadlock");
+		runtime·throw("malloc/free - deadlock");
 	m->mallocing = 1;
 	if(size == 0)
 		size = 1;
@@ -56,19 +56,19 @@
 	mstats.nmalloc++;
 	if(size <= MaxSmallSize) {
 		// Allocate from mcache free lists.
-		sizeclass = SizeToClass(size);
-		size = class_to_size[sizeclass];
+		sizeclass = runtime·SizeToClass(size);
+		size = runtime·class_to_size[sizeclass];
 		c = m->mcache;
-		v = MCache_Alloc(c, sizeclass, size, zeroed);
+		v = runtime·MCache_Alloc(c, sizeclass, size, zeroed);
 		if(v == nil)
-			throw("out of memory");
+			runtime·throw("out of memory");
 		mstats.alloc += size;
 		mstats.total_alloc += size;
 		mstats.by_size[sizeclass].nmalloc++;
 
-		if(!mlookup(v, nil, nil, nil, &ref)) {
-			printf("malloc %D; mlookup failed\n", (uint64)size);
-			throw("malloc mlookup");
+		if(!runtime·mlookup(v, nil, nil, nil, &ref)) {
+			runtime·printf("malloc %D; runtime·mlookup failed\n", (uint64)size);
+			runtime·throw("malloc runtime·mlookup");
 		}
 		*ref = RefNone | refflag;
 	} else {
@@ -78,9 +78,9 @@
 		npages = size >> PageShift;
 		if((size & PageMask) != 0)
 			npages++;
-		s = MHeap_Alloc(&mheap, npages, 0, 1);
+		s = runtime·MHeap_Alloc(&runtime·mheap, npages, 0, 1);
 		if(s == nil)
-			throw("out of memory");
+			runtime·throw("out of memory");
 		size = npages<<PageShift;
 		mstats.alloc += size;
 		mstats.total_alloc += size;
@@ -93,7 +93,7 @@
 
 	m->mallocing = 0;
 
-	if(!(refflag & RefNoProfiling) && (rate = ·MemProfileRate) > 0) {
+	if(!(refflag & RefNoProfiling) && (rate = runtime·MemProfileRate) > 0) {
 		if(size >= rate)
 			goto profile;
 		if(m->mcache->next_sample > size)
@@ -105,24 +105,24 @@
 			m->mcache->next_sample = fastrand1() % (2*rate);
 		profile:
 			*ref |= RefProfiled;
-			MProf_Malloc(v, size);
+			runtime·MProf_Malloc(v, size);
 		}
 	}
 
 	if(dogc && mstats.heap_alloc >= mstats.next_gc)
-		gc(0);
+		runtime·gc(0);
 	return v;
 }
 
 void*
-malloc(uintptr size)
+runtime·malloc(uintptr size)
 {
-	return mallocgc(size, 0, 0, 1);
+	return runtime·mallocgc(size, 0, 0, 1);
 }
 
 // Free the object whose base pointer is v.
 void
-free(void *v)
+runtime·free(void *v)
 {
 	int32 sizeclass, size;
 	MSpan *s;
@@ -133,12 +133,12 @@
 		return;
 
 	if(m->mallocing)
-		throw("malloc/free - deadlock");
+		runtime·throw("malloc/free - deadlock");
 	m->mallocing = 1;
 
-	if(!mlookup(v, nil, nil, &s, &ref)) {
-		printf("free %p: not an allocated block\n", v);
-		throw("free mlookup");
+	if(!runtime·mlookup(v, nil, nil, &s, &ref)) {
+		runtime·printf("free %p: not an allocated block\n", v);
+		runtime·throw("free runtime·mlookup");
 	}
 	prof = *ref & RefProfiled;
 	*ref = RefFree;
@@ -148,34 +148,34 @@
 	if(sizeclass == 0) {
 		// Large object.
 		if(prof)
-			MProf_Free(v, s->npages<<PageShift);
+			runtime·MProf_Free(v, s->npages<<PageShift);
 		mstats.alloc -= s->npages<<PageShift;
-		runtime_memclr(v, s->npages<<PageShift);
-		MHeap_Free(&mheap, s, 1);
+		runtime·memclr(v, s->npages<<PageShift);
+		runtime·MHeap_Free(&runtime·mheap, s, 1);
 	} else {
 		// Small object.
 		c = m->mcache;
-		size = class_to_size[sizeclass];
+		size = runtime·class_to_size[sizeclass];
 		if(size > sizeof(uintptr))
 			((uintptr*)v)[1] = 1;	// mark as "needs to be zeroed"
 		if(prof)
-			MProf_Free(v, size);
+			runtime·MProf_Free(v, size);
 		mstats.alloc -= size;
 		mstats.by_size[sizeclass].nfree++;
-		MCache_Free(c, v, sizeclass, size);
+		runtime·MCache_Free(c, v, sizeclass, size);
 	}
 	m->mallocing = 0;
 }
 
 int32
-mlookup(void *v, byte **base, uintptr *size, MSpan **sp, uint32 **ref)
+runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **sp, uint32 **ref)
 {
 	uintptr n, nobj, i;
 	byte *p;
 	MSpan *s;
 
 	mstats.nlookup++;
-	s = MHeap_LookupMaybe(&mheap, (uintptr)v>>PageShift);
+	s = runtime·MHeap_LookupMaybe(&runtime·mheap, (uintptr)v>>PageShift);
 	if(sp)
 		*sp = s;
 	if(s == nil) {
@@ -206,7 +206,7 @@
 		return 0;
 	}
 
-	n = class_to_size[s->sizeclass];
+	n = runtime·class_to_size[s->sizeclass];
 	i = ((byte*)v - p)/n;
 	if(base)
 		*base = p + i*n;
@@ -217,12 +217,12 @@
 	if(0) {
 		nobj = (s->npages << PageShift) / (n + RefcountOverhead);
 		if((byte*)s->gcref < p || (byte*)(s->gcref+nobj) > p+(s->npages<<PageShift)) {
-			printf("odd span state=%d span=%p base=%p sizeclass=%d n=%D size=%D npages=%D\n",
+			runtime·printf("odd span state=%d span=%p base=%p sizeclass=%d n=%D size=%D npages=%D\n",
 				s->state, s, p, s->sizeclass, (uint64)nobj, (uint64)n, (uint64)s->npages);
-			printf("s->base sizeclass %d v=%p base=%p gcref=%p blocksize=%D nobj=%D size=%D end=%p end=%p\n",
+			runtime·printf("s->base sizeclass %d v=%p base=%p gcref=%p blocksize=%D nobj=%D size=%D end=%p end=%p\n",
 				s->sizeclass, v, p, s->gcref, (uint64)s->npages<<PageShift,
 				(uint64)nobj, (uint64)n, s->gcref + nobj, p+(s->npages<<PageShift));
-			throw("bad gcref");
+			runtime·throw("bad gcref");
 		}
 	}
 	if(ref)
@@ -232,40 +232,40 @@
 }
 
 MCache*
-allocmcache(void)
+runtime·allocmcache(void)
 {
 	MCache *c;
 
-	lock(&mheap);
-	c = FixAlloc_Alloc(&mheap.cachealloc);
-	mstats.mcache_inuse = mheap.cachealloc.inuse;
-	mstats.mcache_sys = mheap.cachealloc.sys;
-	unlock(&mheap);
+	runtime·lock(&runtime·mheap);
+	c = runtime·FixAlloc_Alloc(&runtime·mheap.cachealloc);
+	mstats.mcache_inuse = runtime·mheap.cachealloc.inuse;
+	mstats.mcache_sys = runtime·mheap.cachealloc.sys;
+	runtime·unlock(&runtime·mheap);
 	return c;
 }
 
 void
-mallocinit(void)
+runtime·mallocinit(void)
 {
-	SysMemInit();
-	InitSizes();
-	MHeap_Init(&mheap, SysAlloc);
-	m->mcache = allocmcache();
+	runtime·SysMemInit();
+	runtime·InitSizes();
+	runtime·MHeap_Init(&runtime·mheap, runtime·SysAlloc);
+	m->mcache = runtime·allocmcache();
 
 	// See if it works.
-	free(malloc(1));
+	runtime·free(runtime·malloc(1));
 }
 
 // Runtime stubs.
 
 void*
-mal(uintptr n)
+runtime·mal(uintptr n)
 {
-	return mallocgc(n, 0, 1, 1);
+	return runtime·mallocgc(n, 0, 1, 1);
 }
 
-func mal(n uint32) (ret *uint8) {
-	ret = mal(n);
+func new(n uint32) (ret *uint8) {
+	ret = runtime·mal(n);
 }
 
 // Stack allocator uses malloc/free most of the time,
@@ -275,66 +275,66 @@
 // allocator, assuming that inside malloc all the stack
 // frames are small, so that all the stack allocations
 // will be a single size, the minimum (right now, 5k).
-struct {
+static struct {
 	Lock;
 	FixAlloc;
 } stacks;
 
 void*
-stackalloc(uint32 n)
+runtime·stackalloc(uint32 n)
 {
 	void *v;
 	uint32 *ref;
 
 	if(m->mallocing || m->gcing) {
-		lock(&stacks);
+		runtime·lock(&stacks);
 		if(stacks.size == 0)
-			FixAlloc_Init(&stacks, n, SysAlloc, nil, nil);
+			runtime·FixAlloc_Init(&stacks, n, runtime·SysAlloc, nil, nil);
 		if(stacks.size != n) {
-			printf("stackalloc: in malloc, size=%D want %d", (uint64)stacks.size, n);
-			throw("stackalloc");
+			runtime·printf("stackalloc: in malloc, size=%D want %d", (uint64)stacks.size, n);
+			runtime·throw("stackalloc");
 		}
-		v = FixAlloc_Alloc(&stacks);
+		v = runtime·FixAlloc_Alloc(&stacks);
 		mstats.stacks_inuse = stacks.inuse;
 		mstats.stacks_sys = stacks.sys;
-		unlock(&stacks);
+		runtime·unlock(&stacks);
 		return v;
 	}
-	v = mallocgc(n, RefNoProfiling, 0, 0);
-	if(!mlookup(v, nil, nil, nil, &ref))
-		throw("stackalloc mlookup");
+	v = runtime·mallocgc(n, RefNoProfiling, 0, 0);
+	if(!runtime·mlookup(v, nil, nil, nil, &ref))
+		runtime·throw("stackalloc runtime·mlookup");
 	*ref = RefStack;
 	return v;
 }
 
 void
-stackfree(void *v)
+runtime·stackfree(void *v)
 {
 	if(m->mallocing || m->gcing) {
-		lock(&stacks);
-		FixAlloc_Free(&stacks, v);
+		runtime·lock(&stacks);
+		runtime·FixAlloc_Free(&stacks, v);
 		mstats.stacks_inuse = stacks.inuse;
 		mstats.stacks_sys = stacks.sys;
-		unlock(&stacks);
+		runtime·unlock(&stacks);
 		return;
 	}
-	free(v);
+	runtime·free(v);
 }
 
 func Alloc(n uintptr) (p *byte) {
-	p = malloc(n);
+	p = runtime·malloc(n);
 }
 
 func Free(p *byte) {
-	free(p);
+	runtime·free(p);
 }
 
 func Lookup(p *byte) (base *byte, size uintptr) {
-	mlookup(p, &base, &size, nil, nil);
+	runtime·mlookup(p, &base, &size, nil, nil);
 }
 
 func GC() {
-	gc(1);
+	runtime·gc(1);
 }
 
 func SetFinalizer(obj Eface, finalizer Eface) {
@@ -345,23 +345,23 @@
 	Type *t;
 
 	if(obj.type == nil) {
-		printf("runtime.SetFinalizer: first argument is nil interface\n");
+		runtime·printf("runtime.SetFinalizer: first argument is nil interface\n");
 	throw:
-		throw("runtime.SetFinalizer");
+		runtime·throw("runtime.SetFinalizer");
 	}
 	if(obj.type->kind != KindPtr) {
-		printf("runtime.SetFinalizer: first argument is %S, not pointer\n", *obj.type->string);
+		runtime·printf("runtime.SetFinalizer: first argument is %S, not pointer\n", *obj.type->string);
 		goto throw;
 	}
-	if(!mlookup(obj.data, &base, &size, nil, nil) || obj.data != base) {
-		printf("runtime.SetFinalizer: pointer not at beginning of allocated block\n");
+	if(!runtime·mlookup(obj.data, &base, &size, nil, nil) || obj.data != base) {
+		runtime·printf("runtime.SetFinalizer: pointer not at beginning of allocated block\n");
 		goto throw;
 	}
 	nret = 0;
 	if(finalizer.type != nil) {
 		if(finalizer.type->kind != KindFunc) {
 		badfunc:
-			printf("runtime.SetFinalizer: second argument is %S, not func(%S)\n", *finalizer.type->string, *obj.type->string);
+			runtime·printf("runtime.SetFinalizer: second argument is %S, not func(%S)\n", *finalizer.type->string, *obj.type->string);
 			goto throw;
 		}
 		ft = (FuncType*)finalizer.type;
@@ -376,10 +376,10 @@
 		}
 		nret = (nret + sizeof(void*)-1) & ~(sizeof(void*)-1);
 
-		if(getfinalizer(obj.data, 0)) {
-			printf("runtime.SetFinalizer: finalizer already set");
+		if(runtime·getfinalizer(obj.data, 0)) {
+			runtime·printf("runtime.SetFinalizer: finalizer already set");
 			goto throw;
 		}
 	}
-	addfinalizer(obj.data, finalizer.data, nret);
+	runtime·addfinalizer(obj.data, finalizer.data, nret);
 }
diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index dbd541a..f66baef 100644
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -135,10 +135,10 @@
 // an out-of-memory error has been detected midway through
 // an allocation.  It is okay if SysFree is a no-op.
 
-void*	SysAlloc(uintptr nbytes);
-void	SysFree(void *v, uintptr nbytes);
-void	SysUnused(void *v, uintptr nbytes);
-void	SysMemInit(void);
+void*	runtime·SysAlloc(uintptr nbytes);
+void	runtime·SysFree(void *v, uintptr nbytes);
+void	runtime·SysUnused(void *v, uintptr nbytes);
+void	runtime·SysMemInit(void);
 
 // FixAlloc is a simple free-list allocator for fixed size objects.
 // Malloc uses a FixAlloc wrapped around SysAlloc to manages its
@@ -161,9 +161,9 @@
 	uintptr sys;	// bytes obtained from system
 };
 
-void	FixAlloc_Init(FixAlloc *f, uintptr size, void *(*alloc)(uintptr), void (*first)(void*, byte*), void *arg);
-void*	FixAlloc_Alloc(FixAlloc *f);
-void	FixAlloc_Free(FixAlloc *f, void *p);
+void	runtime·FixAlloc_Init(FixAlloc *f, uintptr size, void *(*alloc)(uintptr), void (*first)(void*, byte*), void *arg);
+void*	runtime·FixAlloc_Alloc(FixAlloc *f);
+void	runtime·FixAlloc_Free(FixAlloc *f, void *p);
 
 
 // Statistics.
@@ -213,7 +213,7 @@
 	} by_size[NumSizeClasses];
 };
 
-#define mstats ·MemStats	/* name shared with Go */
+#define mstats runtime·MemStats	/* name shared with Go */
 extern MStats mstats;
 
 
@@ -230,11 +230,11 @@
 //	taking a bunch of objects out of the central lists
 //	and putting them in the thread free list.
 
-int32	SizeToClass(int32);
-extern	int32	class_to_size[NumSizeClasses];
-extern	int32	class_to_allocnpages[NumSizeClasses];
-extern	int32	class_to_transfercount[NumSizeClasses];
-extern	void	InitSizes(void);
+int32	runtime·SizeToClass(int32);
+extern	int32	runtime·class_to_size[NumSizeClasses];
+extern	int32	runtime·class_to_allocnpages[NumSizeClasses];
+extern	int32	runtime·class_to_transfercount[NumSizeClasses];
+extern	void	runtime·InitSizes(void);
 
 
 // Per-thread (in Go, per-M) cache for small objects.
@@ -256,9 +256,9 @@
 	int32 next_sample;	// trigger heap sample after allocating this many bytes
 };
 
-void*	MCache_Alloc(MCache *c, int32 sizeclass, uintptr size, int32 zeroed);
-void	MCache_Free(MCache *c, void *p, int32 sizeclass, uintptr size);
-void	MCache_ReleaseAll(MCache *c);
+void*	runtime·MCache_Alloc(MCache *c, int32 sizeclass, uintptr size, int32 zeroed);
+void	runtime·MCache_Free(MCache *c, void *p, int32 sizeclass, uintptr size);
+void	runtime·MCache_ReleaseAll(MCache *c);
 
 // An MSpan is a run of pages.
 enum
@@ -285,15 +285,15 @@
 	};
 };
 
-void	MSpan_Init(MSpan *span, PageID start, uintptr npages);
+void	runtime·MSpan_Init(MSpan *span, PageID start, uintptr npages);
 
 // Every MSpan is in one doubly-linked list,
 // either one of the MHeap's free lists or one of the
 // MCentral's span lists.  We use empty MSpan structures as list heads.
-void	MSpanList_Init(MSpan *list);
-bool	MSpanList_IsEmpty(MSpan *list);
-void	MSpanList_Insert(MSpan *list, MSpan *span);
-void	MSpanList_Remove(MSpan *span);	// from whatever list it is in
+void	runtime·MSpanList_Init(MSpan *list);
+bool	runtime·MSpanList_IsEmpty(MSpan *list);
+void	runtime·MSpanList_Insert(MSpan *list, MSpan *span);
+void	runtime·MSpanList_Remove(MSpan *span);	// from whatever list it is in
 
 
 // Central list of free objects of a given size.
@@ -306,9 +306,9 @@
 	int32 nfree;
 };
 
-void	MCentral_Init(MCentral *c, int32 sizeclass);
-int32	MCentral_AllocList(MCentral *c, int32 n, MLink **first);
-void	MCentral_FreeList(MCentral *c, int32 n, MLink *first);
+void	runtime·MCentral_Init(MCentral *c, int32 sizeclass);
+int32	runtime·MCentral_AllocList(MCentral *c, int32 n, MLink **first);
+void	runtime·MCentral_FreeList(MCentral *c, int32 n, MLink *first);
 
 // Main malloc heap.
 // The heap itself is the "free[]" and "large" arrays,
@@ -343,22 +343,22 @@
 	FixAlloc spanalloc;	// allocator for Span*
 	FixAlloc cachealloc;	// allocator for MCache*
 };
-extern MHeap mheap;
+extern MHeap runtime·mheap;
 
-void	MHeap_Init(MHeap *h, void *(*allocator)(uintptr));
-MSpan*	MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, int32 acct);
-void	MHeap_Free(MHeap *h, MSpan *s, int32 acct);
-MSpan*	MHeap_Lookup(MHeap *h, PageID p);
-MSpan*	MHeap_LookupMaybe(MHeap *h, PageID p);
-void	MGetSizeClassInfo(int32 sizeclass, int32 *size, int32 *npages, int32 *nobj);
+void	runtime·MHeap_Init(MHeap *h, void *(*allocator)(uintptr));
+MSpan*	runtime·MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, int32 acct);
+void	runtime·MHeap_Free(MHeap *h, MSpan *s, int32 acct);
+MSpan*	runtime·MHeap_Lookup(MHeap *h, PageID p);
+MSpan*	runtime·MHeap_LookupMaybe(MHeap *h, PageID p);
+void	runtime·MGetSizeClassInfo(int32 sizeclass, int32 *size, int32 *npages, int32 *nobj);
 
-void*	mallocgc(uintptr size, uint32 flag, int32 dogc, int32 zeroed);
-int32	mlookup(void *v, byte **base, uintptr *size, MSpan **s, uint32 **ref);
-void	gc(int32 force);
+void*	runtime·mallocgc(uintptr size, uint32 flag, int32 dogc, int32 zeroed);
+int32	runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **s, uint32 **ref);
+void	runtime·gc(int32 force);
 
-void*	SysAlloc(uintptr);
-void	SysUnused(void*, uintptr);
-void	SysFree(void*, uintptr);
+void*	runtime·SysAlloc(uintptr);
+void	runtime·SysUnused(void*, uintptr);
+void	runtime·SysFree(void*, uintptr);
 
 enum
 {
@@ -375,8 +375,8 @@
 	RefFlags = 0xFFFF0000U,
 };
 
-void	MProf_Malloc(void*, uintptr);
-void	MProf_Free(void*, uintptr);
+void	runtime·MProf_Malloc(void*, uintptr);
+void	runtime·MProf_Free(void*, uintptr);
 
 // Malloc profiling settings.
 // Must match definition in extern.go.
@@ -385,7 +385,7 @@
 	MProf_Sample = 1,
 	MProf_All = 2,
 };
-extern int32 malloc_profile;
+extern int32 runtime·malloc_profile;
 
 typedef struct Finalizer Finalizer;
 struct Finalizer
@@ -396,4 +396,4 @@
 	int32 nret;
 };
 
-Finalizer*	getfinalizer(void*, bool);
+Finalizer*	runtime·getfinalizer(void*, bool);
diff --git a/src/pkg/runtime/mcache.c b/src/pkg/runtime/mcache.c
index 80997bf..0f41a0e 100644
--- a/src/pkg/runtime/mcache.c
+++ b/src/pkg/runtime/mcache.c
@@ -10,7 +10,7 @@
 #include "malloc.h"
 
 void*
-MCache_Alloc(MCache *c, int32 sizeclass, uintptr size, int32 zeroed)
+runtime·MCache_Alloc(MCache *c, int32 sizeclass, uintptr size, int32 zeroed)
 {
 	MCacheList *l;
 	MLink *first, *v;
@@ -20,8 +20,8 @@
 	l = &c->list[sizeclass];
 	if(l->list == nil) {
 		// Replenish using central lists.
-		n = MCentral_AllocList(&mheap.central[sizeclass],
-			class_to_transfercount[sizeclass], &first);
+		n = runtime·MCentral_AllocList(&runtime·mheap.central[sizeclass],
+			runtime·class_to_transfercount[sizeclass], &first);
 		l->list = first;
 		l->nlist = n;
 		c->size += n*size;
@@ -39,7 +39,7 @@
 	if(zeroed) {
 		// block is zeroed iff second word is zero ...
 		if(size > sizeof(uintptr) && ((uintptr*)v)[1] != 0)
-			runtime_memclr((byte*)v, size);
+			runtime·memclr((byte*)v, size);
 		else {
 			// ... except for the link pointer
 			// that we used above; zero that.
@@ -68,14 +68,14 @@
 	l->nlist -= n;
 	if(l->nlist < l->nlistmin)
 		l->nlistmin = l->nlist;
-	c->size -= n*class_to_size[sizeclass];
+	c->size -= n*runtime·class_to_size[sizeclass];
 
 	// Return them to central free list.
-	MCentral_FreeList(&mheap.central[sizeclass], n, first);
+	runtime·MCentral_FreeList(&runtime·mheap.central[sizeclass], n, first);
 }
 
 void
-MCache_Free(MCache *c, void *v, int32 sizeclass, uintptr size)
+runtime·MCache_Free(MCache *c, void *v, int32 sizeclass, uintptr size)
 {
 	int32 i, n;
 	MCacheList *l;
@@ -93,7 +93,7 @@
 
 	if(l->nlist >= MaxMCacheListLen) {
 		// Release a chunk back.
-		ReleaseN(c, l, class_to_transfercount[sizeclass], sizeclass);
+		ReleaseN(c, l, runtime·class_to_transfercount[sizeclass], sizeclass);
 	}
 
 	if(c->size >= MaxMCacheSize) {
@@ -118,7 +118,7 @@
 }
 
 void
-MCache_ReleaseAll(MCache *c)
+runtime·MCache_ReleaseAll(MCache *c)
 {
 	int32 i;
 	MCacheList *l;
diff --git a/src/pkg/runtime/mcentral.c b/src/pkg/runtime/mcentral.c
index 1e1784c..8855dc6 100644
--- a/src/pkg/runtime/mcentral.c
+++ b/src/pkg/runtime/mcentral.c
@@ -23,11 +23,11 @@
 
 // Initialize a single central free list.
 void
-MCentral_Init(MCentral *c, int32 sizeclass)
+runtime·MCentral_Init(MCentral *c, int32 sizeclass)
 {
 	c->sizeclass = sizeclass;
-	MSpanList_Init(&c->nonempty);
-	MSpanList_Init(&c->empty);
+	runtime·MSpanList_Init(&c->nonempty);
+	runtime·MSpanList_Init(&c->empty);
 }
 
 // Allocate up to n objects from the central free list.
@@ -35,16 +35,16 @@
 // The objects are linked together by their first words.
 // On return, *pstart points at the first object and *pend at the last.
 int32
-MCentral_AllocList(MCentral *c, int32 n, MLink **pfirst)
+runtime·MCentral_AllocList(MCentral *c, int32 n, MLink **pfirst)
 {
 	MLink *first, *last, *v;
 	int32 i;
 
-	lock(c);
+	runtime·lock(c);
 	// Replenish central list if empty.
-	if(MSpanList_IsEmpty(&c->nonempty)) {
+	if(runtime·MSpanList_IsEmpty(&c->nonempty)) {
 		if(!MCentral_Grow(c)) {
-			unlock(c);
+			runtime·unlock(c);
 			*pfirst = nil;
 			return 0;
 		}
@@ -61,7 +61,7 @@
 	last->next = nil;
 	c->nfree -= i;
 
-	unlock(c);
+	runtime·unlock(c);
 	*pfirst = first;
 	return i;
 }
@@ -73,15 +73,15 @@
 	MSpan *s;
 	MLink *v;
 
-	if(MSpanList_IsEmpty(&c->nonempty))
+	if(runtime·MSpanList_IsEmpty(&c->nonempty))
 		return nil;
 	s = c->nonempty.next;
 	s->ref++;
 	v = s->freelist;
 	s->freelist = v->next;
 	if(s->freelist == nil) {
-		MSpanList_Remove(s);
-		MSpanList_Insert(&c->empty, s);
+		runtime·MSpanList_Remove(s);
+		runtime·MSpanList_Insert(&c->empty, s);
 	}
 	return v;
 }
@@ -91,7 +91,7 @@
 // The objects are linked together by their first words.
 // On return, *pstart points at the first object and *pend at the last.
 void
-MCentral_FreeList(MCentral *c, int32 n, MLink *start)
+runtime·MCentral_FreeList(MCentral *c, int32 n, MLink *start)
 {
 	MLink *v, *next;
 
@@ -100,12 +100,12 @@
 	// the transfer cache optimization in the TODO above.
 	USED(n);
 
-	lock(c);
+	runtime·lock(c);
 	for(v=start; v; v=next) {
 		next = v->next;
 		MCentral_Free(c, v);
 	}
-	unlock(c);
+	runtime·unlock(c);
 }
 
 // Helper: free one object back into the central free list.
@@ -119,14 +119,14 @@
 
 	// Find span for v.
 	page = (uintptr)v >> PageShift;
-	s = MHeap_Lookup(&mheap, page);
+	s = runtime·MHeap_Lookup(&runtime·mheap, page);
 	if(s == nil || s->ref == 0)
-		throw("invalid free");
+		runtime·throw("invalid free");
 
 	// Move to nonempty if necessary.
 	if(s->freelist == nil) {
-		MSpanList_Remove(s);
-		MSpanList_Insert(&c->nonempty, s);
+		runtime·MSpanList_Remove(s);
+		runtime·MSpanList_Insert(&c->nonempty, s);
 	}
 
 	// Add v back to s's free list.
@@ -137,34 +137,34 @@
 
 	// If s is completely freed, return it to the heap.
 	if(--s->ref == 0) {
-		size = class_to_size[c->sizeclass];
-		MSpanList_Remove(s);
+		size = runtime·class_to_size[c->sizeclass];
+		runtime·MSpanList_Remove(s);
 		// The second word of each freed block indicates
 		// whether it needs to be zeroed.  The first word
 		// is the link pointer and must always be cleared.
 		for(p=s->freelist; p; p=next) {
 			next = p->next;
 			if(size > sizeof(uintptr) && ((uintptr*)p)[1] != 0)
-				runtime_memclr((byte*)p, size);
+				runtime·memclr((byte*)p, size);
 			else
 				p->next = nil;
 		}
 		s->freelist = nil;
 		c->nfree -= (s->npages << PageShift) / size;
-		unlock(c);
-		MHeap_Free(&mheap, s, 0);
-		lock(c);
+		runtime·unlock(c);
+		runtime·MHeap_Free(&runtime·mheap, s, 0);
+		runtime·lock(c);
 	}
 }
 
 void
-MGetSizeClassInfo(int32 sizeclass, int32 *sizep, int32 *npagesp, int32 *nobj)
+runtime·MGetSizeClassInfo(int32 sizeclass, int32 *sizep, int32 *npagesp, int32 *nobj)
 {
 	int32 size;
 	int32 npages;
 
-	npages = class_to_allocnpages[sizeclass];
-	size = class_to_size[sizeclass];
+	npages = runtime·class_to_allocnpages[sizeclass];
+	size = runtime·class_to_size[sizeclass];
 	*npagesp = npages;
 	*sizep = size;
 	*nobj = (npages << PageShift) / (size + RefcountOverhead);
@@ -180,12 +180,12 @@
 	byte *p;
 	MSpan *s;
 
-	unlock(c);
-	MGetSizeClassInfo(c->sizeclass, &size, &npages, &n);
-	s = MHeap_Alloc(&mheap, npages, c->sizeclass, 0);
+	runtime·unlock(c);
+	runtime·MGetSizeClassInfo(c->sizeclass, &size, &npages, &n);
+	s = runtime·MHeap_Alloc(&runtime·mheap, npages, c->sizeclass, 0);
 	if(s == nil) {
 		// TODO(rsc): Log out of memory
-		lock(c);
+		runtime·lock(c);
 		return false;
 	}
 
@@ -201,8 +201,8 @@
 	}
 	*tailp = nil;
 
-	lock(c);
+	runtime·lock(c);
 	c->nfree += n;
-	MSpanList_Insert(&c->nonempty, s);
+	runtime·MSpanList_Insert(&c->nonempty, s);
 	return true;
 }
diff --git a/src/pkg/runtime/mfinal.c b/src/pkg/runtime/mfinal.c
index 03c1e10..f73561b 100644
--- a/src/pkg/runtime/mfinal.c
+++ b/src/pkg/runtime/mfinal.c
@@ -5,7 +5,7 @@
 #include "runtime.h"
 #include "malloc.h"
 
-Lock finlock;
+static Lock finlock;
 
 // Finalizer hash table.  Direct hash, linear scan, at most 3/4 full.
 // Table size is power of 3 so that hash can be key % max.
@@ -44,7 +44,7 @@
 	}
 
 	// cannot happen - table is known to be non-full
-	throw("finalizer table inconsistent");
+	runtime·throw("finalizer table inconsistent");
 
 ret:
 	t->key[i] = k;
@@ -77,7 +77,7 @@
 	}
 
 	// cannot happen - table is known to be non-full
-	throw("finalizer table inconsistent");
+	runtime·throw("finalizer table inconsistent");
 	return nil;
 }
 
@@ -85,7 +85,7 @@
 
 // add finalizer; caller is responsible for making sure not already in table
 void
-addfinalizer(void *p, void (*f)(void*), int32 nret)
+runtime·addfinalizer(void *p, void (*f)(void*), int32 nret)
 {
 	Fintab newtab;
 	int32 i;
@@ -95,28 +95,28 @@
 	
 	e = nil;
 	if(f != nil) {
-		e = mal(sizeof *e);
+		e = runtime·mal(sizeof *e);
 		e->fn = f;
 		e->nret = nret;
 	}
 
-	lock(&finlock);
-	if(!mlookup(p, &base, nil, nil, &ref) || p != base) {
-		unlock(&finlock);
-		throw("addfinalizer on invalid pointer");
+	runtime·lock(&finlock);
+	if(!runtime·mlookup(p, &base, nil, nil, &ref) || p != base) {
+		runtime·unlock(&finlock);
+		runtime·throw("addfinalizer on invalid pointer");
 	}
 	if(f == nil) {
 		if(*ref & RefHasFinalizer) {
 			lookfintab(&fintab, p, 1);
 			*ref &= ~RefHasFinalizer;
 		}
-		unlock(&finlock);
+		runtime·unlock(&finlock);
 		return;
 	}
 
 	if(*ref & RefHasFinalizer) {
-		unlock(&finlock);
-		throw("double finalizer");
+		runtime·unlock(&finlock);
+		runtime·throw("double finalizer");
 	}
 	*ref |= RefHasFinalizer;
 
@@ -124,7 +124,7 @@
 		// keep table at most 3/4 full:
 		// allocate new table and rehash.
 
-		runtime_memclr((byte*)&newtab, sizeof newtab);
+		runtime·memclr((byte*)&newtab, sizeof newtab);
 		newtab.max = fintab.max;
 		if(newtab.max == 0)
 			newtab.max = 3*3*3;
@@ -134,8 +134,8 @@
 			newtab.max *= 3;
 		}
 
-		newtab.key = mallocgc(newtab.max*sizeof newtab.key[0], RefNoPointers, 0, 1);
-		newtab.val = mallocgc(newtab.max*sizeof newtab.val[0], 0, 0, 1);
+		newtab.key = runtime·mallocgc(newtab.max*sizeof newtab.key[0], RefNoPointers, 0, 1);
+		newtab.val = runtime·mallocgc(newtab.max*sizeof newtab.val[0], 0, 0, 1);
 
 		for(i=0; i<fintab.max; i++) {
 			void *k;
@@ -144,39 +144,39 @@
 			if(k != nil && k != (void*)-1)
 				addfintab(&newtab, k, fintab.val[i]);
 		}
-		free(fintab.key);
-		free(fintab.val);
+		runtime·free(fintab.key);
+		runtime·free(fintab.val);
 		fintab = newtab;
 	}
 
 	addfintab(&fintab, p, e);
-	unlock(&finlock);
+	runtime·unlock(&finlock);
 }
 
 // get finalizer; if del, delete finalizer.
 // caller is responsible for updating RefHasFinalizer bit.
 Finalizer*
-getfinalizer(void *p, bool del)
+runtime·getfinalizer(void *p, bool del)
 {
 	Finalizer *f;
 	
-	lock(&finlock);
+	runtime·lock(&finlock);
 	f = lookfintab(&fintab, p, del);
-	unlock(&finlock);
+	runtime·unlock(&finlock);
 	return f;
 }
 
 void
-walkfintab(void (*fn)(void*))
+runtime·walkfintab(void (*fn)(void*))
 {
 	void **key;
 	void **ekey;
 
-	lock(&finlock);
+	runtime·lock(&finlock);
 	key = fintab.key;
 	ekey = key + fintab.max;
 	for(; key < ekey; key++)
 		if(*key != nil && *key != ((void*)-1))
 			fn(*key);
-	unlock(&finlock);
+	runtime·unlock(&finlock);
 }
diff --git a/src/pkg/runtime/mfixalloc.c b/src/pkg/runtime/mfixalloc.c
index 8347a15..ab9df31 100644
--- a/src/pkg/runtime/mfixalloc.c
+++ b/src/pkg/runtime/mfixalloc.c
@@ -12,7 +12,7 @@
 // Initialize f to allocate objects of the given size,
 // using the allocator to obtain chunks of memory.
 void
-FixAlloc_Init(FixAlloc *f, uintptr size, void *(*alloc)(uintptr), void (*first)(void*, byte*), void *arg)
+runtime·FixAlloc_Init(FixAlloc *f, uintptr size, void *(*alloc)(uintptr), void (*first)(void*, byte*), void *arg)
 {
 	f->size = size;
 	f->alloc = alloc;
@@ -26,7 +26,7 @@
 }
 
 void*
-FixAlloc_Alloc(FixAlloc *f)
+runtime·FixAlloc_Alloc(FixAlloc *f)
 {
 	void *v;
 
@@ -40,7 +40,7 @@
 		f->sys += FixAllocChunk;
 		f->chunk = f->alloc(FixAllocChunk);
 		if(f->chunk == nil)
-			throw("out of memory (FixAlloc)");
+			runtime·throw("out of memory (FixAlloc)");
 		f->nchunk = FixAllocChunk;
 	}
 	v = f->chunk;
@@ -53,7 +53,7 @@
 }
 
 void
-FixAlloc_Free(FixAlloc *f, void *p)
+runtime·FixAlloc_Free(FixAlloc *f, void *p)
 {
 	f->inuse -= f->size;
 	*(void**)p = f->list;
diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 47e324ddf..69cc6f5 100644
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -63,7 +63,7 @@
 		n = w->size;
 
 		if(Debug > 1)
-			printf("scanblock %p %D\n", b, n);
+			runtime·printf("scanblock %p %D\n", b, n);
 		off = (uint32)(uintptr)b & (PtrSize-1);
 		if(off) {
 			b += PtrSize - off;
@@ -76,7 +76,7 @@
 			obj = vp[i];
 			if(obj == nil)
 				continue;
-			if(mheap.closure_min != nil && mheap.closure_min <= (byte*)obj && (byte*)obj < mheap.closure_max) {
+			if(runtime·mheap.closure_min != nil && runtime·mheap.closure_min <= (byte*)obj && (byte*)obj < runtime·mheap.closure_max) {
 				if((((uintptr)obj) & 63) != 0)
 					continue;
 	
@@ -92,17 +92,17 @@
 					continue;
 				obj = *pp;
 			}
-			if(mheap.min <= (byte*)obj && (byte*)obj < mheap.max) {
-				if(mlookup(obj, &obj, &size, nil, &refp)) {
+			if(runtime·mheap.min <= (byte*)obj && (byte*)obj < runtime·mheap.max) {
+				if(runtime·mlookup(obj, &obj, &size, nil, &refp)) {
 					ref = *refp;
 					switch(ref & ~RefFlags) {
 					case RefNone:
 						if(Debug > 1)
-							printf("found at %p: ", &vp[i]);
+							runtime·printf("found at %p: ", &vp[i]);
 						*refp = RefSome | (ref & RefFlags);
 						if(!(ref & RefNoPointers)) {
 							if(w >= ebl)
-								throw("scanblock: garbage collection stack overflow");
+								runtime·throw("scanblock: garbage collection stack overflow");
 							w->obj = obj;
 							w->size = size;
 							w++;
@@ -126,7 +126,7 @@
 	else
 		sp = gp->sched.sp;
 	if(Debug > 1)
-		printf("scanstack %d %p\n", gp->goid, sp);
+		runtime·printf("scanstack %d %p\n", gp->goid, sp);
 	stk = (Stktop*)gp->stackbase;
 	while(stk) {
 		scanblock(sp, (byte*)stk - sp);
@@ -143,8 +143,8 @@
 
 	size = 0;
 	refp = nil;
-	if(!mlookup(v, &v, &size, nil, &refp) || !(*refp & RefHasFinalizer))
-		throw("mark - finalizer inconsistency");
+	if(!runtime·mlookup(v, &v, &size, nil, &refp) || !(*refp & RefHasFinalizer))
+		runtime·throw("mark - finalizer inconsistency");
 	
 	// do not mark the finalizer block itself.  just mark the things it points at.
 	scanblock(v, size);
@@ -162,7 +162,7 @@
 	nobj = mstats.heap_objects;
 	if(nobj > ebl - bl || nobj < (ebl-bl)/4) {
 		if(bl != nil)
-			SysFree(bl, (byte*)ebl - (byte*)bl);
+			runtime·SysFree(bl, (byte*)ebl - (byte*)bl);
 		
 		// While we're allocated a new object stack,
 		// add 20% headroom and also round up to
@@ -172,28 +172,28 @@
 		blsize = nobj * sizeof *bl;
 		blsize = (blsize + 4095) & ~4095;
 		nobj = blsize / sizeof *bl;
-		bl = SysAlloc(blsize);
+		bl = runtime·SysAlloc(blsize);
 		ebl = bl + nobj;
 	}
 
 	// mark data+bss.
-	// skip mheap itself, which has no interesting pointers
+	// skip runtime·mheap itself, which has no interesting pointers
 	// and is mostly zeroed and would not otherwise be paged in.
-	scanblock(data, (byte*)&mheap - data);
-	scanblock((byte*)(&mheap+1), end - (byte*)(&mheap+1));
+	scanblock(data, (byte*)&runtime·mheap - data);
+	scanblock((byte*)(&runtime·mheap+1), end - (byte*)(&runtime·mheap+1));
 
 	// mark stacks
-	for(gp=allg; gp!=nil; gp=gp->alllink) {
+	for(gp=runtime·allg; gp!=nil; gp=gp->alllink) {
 		switch(gp->status){
 		default:
-			printf("unexpected G.status %d\n", gp->status);
-			throw("mark - bad status");
+			runtime·printf("unexpected G.status %d\n", gp->status);
+			runtime·throw("mark - bad status");
 		case Gdead:
 			break;
 		case Grunning:
 		case Grecovery:
 			if(gp != g)
-				throw("mark - world not stopped");
+				runtime·throw("mark - world not stopped");
 			scanstack(gp);
 			break;
 		case Grunnable:
@@ -205,7 +205,7 @@
 	}
 
 	// mark things pointed at by objects with finalizers
-	walkfintab(markfin);
+	runtime·walkfintab(markfin);
 }
 
 // free RefNone, free & queue finalizers for RefNone|RefHasFinalizer, reset RefSome
@@ -226,16 +226,16 @@
 		case RefNone:
 			// Free large object.
 			mstats.alloc -= s->npages<<PageShift;
-			runtime_memclr(p, s->npages<<PageShift);
+			runtime·memclr(p, s->npages<<PageShift);
 			if(ref & RefProfiled)
-				MProf_Free(p, s->npages<<PageShift);
+				runtime·MProf_Free(p, s->npages<<PageShift);
 			s->gcref0 = RefFree;
-			MHeap_Free(&mheap, s, 1);
+			runtime·MHeap_Free(&runtime·mheap, s, 1);
 			break;
 		case RefNone|RefHasFinalizer:
-			f = getfinalizer(p, 1);
+			f = runtime·getfinalizer(p, 1);
 			if(f == nil)
-				throw("finalizer inconsistency");
+				runtime·throw("finalizer inconsistency");
 			f->arg = p;
 			f->next = finq;
 			finq = f;
@@ -250,7 +250,7 @@
 	}
 
 	// Chunk full of small blocks.
-	MGetSizeClassInfo(s->sizeclass, &size, &npages, &n);
+	runtime·MGetSizeClassInfo(s->sizeclass, &size, &npages, &n);
 	gcrefp = s->gcref;
 	gcrefep = s->gcref + n;
 	for(; gcrefp < gcrefep; gcrefp++, p += size) {
@@ -261,19 +261,19 @@
 		case RefNone:
 			// Free small object.
 			if(ref & RefProfiled)
-				MProf_Free(p, size);
+				runtime·MProf_Free(p, size);
 			*gcrefp = RefFree;
 			c = m->mcache;
 			if(size > sizeof(uintptr))
 				((uintptr*)p)[1] = 1;	// mark as "needs to be zeroed"
 			mstats.alloc -= size;
 			mstats.by_size[s->sizeclass].nfree++;
-			MCache_Free(c, p, s->sizeclass, size);
+			runtime·MCache_Free(c, p, s->sizeclass, size);
 			break;
 		case RefNone|RefHasFinalizer:
-			f = getfinalizer(p, 1);
+			f = runtime·getfinalizer(p, 1);
 			if(f == nil)
-				throw("finalizer inconsistency");
+				runtime·throw("finalizer inconsistency");
 			f->arg = p;
 			f->next = finq;
 			finq = f;
@@ -292,7 +292,7 @@
 {
 	MSpan *s;
 
-	for(s = mheap.allspans; s != nil; s = s->allnext)
+	for(s = runtime·mheap.allspans; s != nil; s = s->allnext)
 		if(s->state == MSpanInUse)
 			sweepspan(s);
 }
@@ -318,8 +318,8 @@
 {
 	M *m;
 	
-	for(m=allm; m; m=m->alllink)
-		MCache_ReleaseAll(m->mcache);
+	for(m=runtime·allm; m; m=m->alllink)
+		runtime·MCache_ReleaseAll(m->mcache);
 }
 
 static void
@@ -328,7 +328,7 @@
 	M *m;
 	MCache *c;
 
-	for(m=allm; m; m=m->alllink) {
+	for(m=runtime·allm; m; m=m->alllink) {
 		c = m->mcache;
 		mstats.heap_alloc += c->local_alloc;
 		c->local_alloc = 0;
@@ -338,7 +338,7 @@
 }
 
 void
-gc(int32 force)
+runtime·gc(int32 force)
 {
 	int64 t0, t1;
 	byte *p;
@@ -352,27 +352,27 @@
 	// 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 || m->locks > 0 || panicking)
+	if(!mstats.enablegc || m->locks > 0 || runtime·panicking)
 		return;
 
 	if(gcpercent == -2) {	// first time through
-		p = getenv("GOGC");
+		p = runtime·getenv("GOGC");
 		if(p == nil || p[0] == '\0')
 			gcpercent = 100;
-		else if(strcmp(p, (byte*)"off") == 0)
+		else if(runtime·strcmp(p, (byte*)"off") == 0)
 			gcpercent = -1;
 		else
-			gcpercent = atoi(p);
+			gcpercent = runtime·atoi(p);
 	}
 	if(gcpercent < 0)
 		return;
 
-	semacquire(&gcsema);
-	t0 = nanotime();
+	runtime·semacquire(&gcsema);
+	t0 = runtime·nanotime();
 	m->gcing = 1;
-	stoptheworld();
-	if(mheap.Lock.key != 0)
-		throw("mheap locked during gc");
+	runtime·stoptheworld();
+	if(runtime·mheap.Lock.key != 0)
+		runtime·throw("runtime·mheap locked during gc");
 	if(force || mstats.heap_alloc >= mstats.next_gc) {
 		cachestats();
 		mark();
@@ -387,25 +387,25 @@
 	if(fp != nil) {
 		// kick off or wake up goroutine to run queued finalizers
 		if(fing == nil)
-			fing = newproc1((byte*)runfinq, nil, 0, 0);
+			fing = runtime·newproc1((byte*)runfinq, nil, 0, 0);
 		else if(fingwait) {
 			fingwait = 0;
-			ready(fing);
+			runtime·ready(fing);
 		}
 	}
 	m->locks--;
 
-	t1 = nanotime();
+	t1 = runtime·nanotime();
 	mstats.numgc++;
 	mstats.pause_ns += t1 - t0;
 	if(mstats.debuggc)
-		printf("pause %D\n", t1-t0);
-	semrelease(&gcsema);
-	starttheworld();
+		runtime·printf("pause %D\n", t1-t0);
+	runtime·semrelease(&gcsema);
+	runtime·starttheworld();
 	
 	// give the queued finalizers, if any, a chance to run
 	if(fp != nil)
-		gosched();
+		runtime·gosched();
 }
 
 static void
@@ -426,20 +426,20 @@
 		if(f == nil) {
 			fingwait = 1;
 			g->status = Gwaiting;
-			gosched();
+			runtime·gosched();
 			continue;
 		}
 		for(; f; f=next) {
 			next = f->next;
-			frame = mal(sizeof(uintptr) + f->nret);
+			frame = runtime·mal(sizeof(uintptr) + f->nret);
 			*(void**)frame = f->arg;
 			reflect·call((byte*)f->fn, frame, sizeof(uintptr) + f->nret);
-			free(frame);
+			runtime·free(frame);
 			f->fn = nil;
 			f->arg = nil;
 			f->next = nil;
-			free(f);
+			runtime·free(f);
 		}
-		gc(1);	// trigger another gc to clean up the finalized objects, if possible
+		runtime·gc(1);	// trigger another gc to clean up the finalized objects, if possible
 	}
 }
diff --git a/src/pkg/runtime/mheap.c b/src/pkg/runtime/mheap.c
index 12c37ea..b6e3307 100644
--- a/src/pkg/runtime/mheap.c
+++ b/src/pkg/runtime/mheap.c
@@ -35,29 +35,29 @@
 
 // Initialize the heap; fetch memory using alloc.
 void
-MHeap_Init(MHeap *h, void *(*alloc)(uintptr))
+runtime·MHeap_Init(MHeap *h, void *(*alloc)(uintptr))
 {
 	uint32 i;
 
-	FixAlloc_Init(&h->spanalloc, sizeof(MSpan), alloc, RecordSpan, h);
-	FixAlloc_Init(&h->cachealloc, sizeof(MCache), alloc, nil, nil);
-	MHeapMap_Init(&h->map, alloc);
+	runtime·FixAlloc_Init(&h->spanalloc, sizeof(MSpan), alloc, RecordSpan, h);
+	runtime·FixAlloc_Init(&h->cachealloc, sizeof(MCache), alloc, nil, nil);
+	runtime·MHeapMap_Init(&h->map, alloc);
 	// h->mapcache needs no init
 	for(i=0; i<nelem(h->free); i++)
-		MSpanList_Init(&h->free[i]);
-	MSpanList_Init(&h->large);
+		runtime·MSpanList_Init(&h->free[i]);
+	runtime·MSpanList_Init(&h->large);
 	for(i=0; i<nelem(h->central); i++)
-		MCentral_Init(&h->central[i], i);
+		runtime·MCentral_Init(&h->central[i], i);
 }
 
 // Allocate a new span of npage pages from the heap
 // and record its size class in the HeapMap and HeapMapCache.
 MSpan*
-MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, int32 acct)
+runtime·MHeap_Alloc(MHeap *h, uintptr npage, int32 sizeclass, int32 acct)
 {
 	MSpan *s;
 
-	lock(h);
+	runtime·lock(h);
 	mstats.heap_alloc += m->mcache->local_alloc;
 	m->mcache->local_alloc = 0;
 	mstats.heap_objects += m->mcache->local_objects;
@@ -70,7 +70,7 @@
 			mstats.heap_alloc += npage<<PageShift;
 		}
 	}
-	unlock(h);
+	runtime·unlock(h);
 	return s;
 }
 
@@ -82,7 +82,7 @@
 
 	// Try in fixed-size lists up to max.
 	for(n=npage; n < nelem(h->free); n++) {
-		if(!MSpanList_IsEmpty(&h->free[n])) {
+		if(!runtime·MSpanList_IsEmpty(&h->free[n])) {
 			s = h->free[n].next;
 			goto HaveSpan;
 		}
@@ -99,22 +99,22 @@
 HaveSpan:
 	// Mark span in use.
 	if(s->state != MSpanFree)
-		throw("MHeap_AllocLocked - MSpan not free");
+		runtime·throw("MHeap_AllocLocked - MSpan not free");
 	if(s->npages < npage)
-		throw("MHeap_AllocLocked - bad npages");
-	MSpanList_Remove(s);
+		runtime·throw("MHeap_AllocLocked - bad npages");
+	runtime·MSpanList_Remove(s);
 	s->state = MSpanInUse;
 
 	if(s->npages > npage) {
 		// Trim extra and put it back in the heap.
-		t = FixAlloc_Alloc(&h->spanalloc);
+		t = runtime·FixAlloc_Alloc(&h->spanalloc);
 		mstats.mspan_inuse = h->spanalloc.inuse;
 		mstats.mspan_sys = h->spanalloc.sys;
-		MSpan_Init(t, s->start + npage, s->npages - npage);
+		runtime·MSpan_Init(t, s->start + npage, s->npages - npage);
 		s->npages = npage;
-		MHeapMap_Set(&h->map, t->start - 1, s);
-		MHeapMap_Set(&h->map, t->start, t);
-		MHeapMap_Set(&h->map, t->start + t->npages - 1, t);
+		runtime·MHeapMap_Set(&h->map, t->start - 1, s);
+		runtime·MHeapMap_Set(&h->map, t->start, t);
+		runtime·MHeapMap_Set(&h->map, t->start + t->npages - 1, t);
 		t->state = MSpanInUse;
 		MHeap_FreeLocked(h, t);
 	}
@@ -123,7 +123,7 @@
 	// able to map interior pointer to containing span.
 	s->sizeclass = sizeclass;
 	for(n=0; n<npage; n++)
-		MHeapMap_Set(&h->map, s->start+n, s);
+		runtime·MHeapMap_Set(&h->map, s->start+n, s);
 	return s;
 }
 
@@ -171,11 +171,11 @@
 	if(ask < HeapAllocChunk)
 		ask = HeapAllocChunk;
 
-	v = SysAlloc(ask);
+	v = runtime·SysAlloc(ask);
 	if(v == nil) {
 		if(ask > (npage<<PageShift)) {
 			ask = npage<<PageShift;
-			v = SysAlloc(ask);
+			v = runtime·SysAlloc(ask);
 		}
 		if(v == nil)
 			return false;
@@ -190,19 +190,19 @@
 	// NOTE(rsc): In tcmalloc, if we've accumulated enough
 	// system allocations, the heap map gets entirely allocated
 	// in 32-bit mode.  (In 64-bit mode that's not practical.)
-	if(!MHeapMap_Preallocate(&h->map, ((uintptr)v>>PageShift) - 1, (ask>>PageShift) + 2)) {
-		SysFree(v, ask);
+	if(!runtime·MHeapMap_Preallocate(&h->map, ((uintptr)v>>PageShift) - 1, (ask>>PageShift) + 2)) {
+		runtime·SysFree(v, ask);
 		return false;
 	}
 
 	// Create a fake "in use" span and free it, so that the
 	// right coalescing happens.
-	s = FixAlloc_Alloc(&h->spanalloc);
+	s = runtime·FixAlloc_Alloc(&h->spanalloc);
 	mstats.mspan_inuse = h->spanalloc.inuse;
 	mstats.mspan_sys = h->spanalloc.sys;
-	MSpan_Init(s, (uintptr)v>>PageShift, ask>>PageShift);
-	MHeapMap_Set(&h->map, s->start, s);
-	MHeapMap_Set(&h->map, s->start + s->npages - 1, s);
+	runtime·MSpan_Init(s, (uintptr)v>>PageShift, ask>>PageShift);
+	runtime·MHeapMap_Set(&h->map, s->start, s);
+	runtime·MHeapMap_Set(&h->map, s->start + s->npages - 1, s);
 	s->state = MSpanInUse;
 	MHeap_FreeLocked(h, s);
 	return true;
@@ -212,9 +212,9 @@
 // Page number is guaranteed to be in map
 // and is guaranteed to be start or end of span.
 MSpan*
-MHeap_Lookup(MHeap *h, PageID p)
+runtime·MHeap_Lookup(MHeap *h, PageID p)
 {
-	return MHeapMap_Get(&h->map, p);
+	return runtime·MHeapMap_Get(&h->map, p);
 }
 
 // Look up the span at the given page number.
@@ -225,11 +225,11 @@
 // other garbage in their middles, so we have to
 // check for that.
 MSpan*
-MHeap_LookupMaybe(MHeap *h, PageID p)
+runtime·MHeap_LookupMaybe(MHeap *h, PageID p)
 {
 	MSpan *s;
 
-	s = MHeapMap_GetMaybe(&h->map, p);
+	s = runtime·MHeapMap_GetMaybe(&h->map, p);
 	if(s == nil || p < s->start || p - s->start >= s->npages)
 		return nil;
 	if(s->state != MSpanInUse)
@@ -239,9 +239,9 @@
 
 // Free the span back into the heap.
 void
-MHeap_Free(MHeap *h, MSpan *s, int32 acct)
+runtime·MHeap_Free(MHeap *h, MSpan *s, int32 acct)
 {
-	lock(h);
+	runtime·lock(h);
 	mstats.heap_alloc += m->mcache->local_alloc;
 	m->mcache->local_alloc = 0;
 	mstats.heap_objects += m->mcache->local_objects;
@@ -252,7 +252,7 @@
 		mstats.heap_objects--;
 	}
 	MHeap_FreeLocked(h, s);
-	unlock(h);
+	runtime·unlock(h);
 }
 
 static void
@@ -261,45 +261,45 @@
 	MSpan *t;
 
 	if(s->state != MSpanInUse || s->ref != 0) {
-		printf("MHeap_FreeLocked - span %p ptr %p state %d ref %d\n", s, s->start<<PageShift, s->state, s->ref);
-		throw("MHeap_FreeLocked - invalid free");
+		runtime·printf("MHeap_FreeLocked - span %p ptr %p state %d ref %d\n", s, s->start<<PageShift, s->state, s->ref);
+		runtime·throw("MHeap_FreeLocked - invalid free");
 	}
 	s->state = MSpanFree;
-	MSpanList_Remove(s);
+	runtime·MSpanList_Remove(s);
 
 	// Coalesce with earlier, later spans.
-	if((t = MHeapMap_Get(&h->map, s->start - 1)) != nil && t->state != MSpanInUse) {
+	if((t = runtime·MHeapMap_Get(&h->map, s->start - 1)) != nil && t->state != MSpanInUse) {
 		s->start = t->start;
 		s->npages += t->npages;
-		MHeapMap_Set(&h->map, s->start, s);
-		MSpanList_Remove(t);
+		runtime·MHeapMap_Set(&h->map, s->start, s);
+		runtime·MSpanList_Remove(t);
 		t->state = MSpanDead;
-		FixAlloc_Free(&h->spanalloc, t);
+		runtime·FixAlloc_Free(&h->spanalloc, t);
 		mstats.mspan_inuse = h->spanalloc.inuse;
 		mstats.mspan_sys = h->spanalloc.sys;
 	}
-	if((t = MHeapMap_Get(&h->map, s->start + s->npages)) != nil && t->state != MSpanInUse) {
+	if((t = runtime·MHeapMap_Get(&h->map, s->start + s->npages)) != nil && t->state != MSpanInUse) {
 		s->npages += t->npages;
-		MHeapMap_Set(&h->map, s->start + s->npages - 1, s);
-		MSpanList_Remove(t);
+		runtime·MHeapMap_Set(&h->map, s->start + s->npages - 1, s);
+		runtime·MSpanList_Remove(t);
 		t->state = MSpanDead;
-		FixAlloc_Free(&h->spanalloc, t);
+		runtime·FixAlloc_Free(&h->spanalloc, t);
 		mstats.mspan_inuse = h->spanalloc.inuse;
 		mstats.mspan_sys = h->spanalloc.sys;
 	}
 
 	// Insert s into appropriate list.
 	if(s->npages < nelem(h->free))
-		MSpanList_Insert(&h->free[s->npages], s);
+		runtime·MSpanList_Insert(&h->free[s->npages], s);
 	else
-		MSpanList_Insert(&h->large, s);
+		runtime·MSpanList_Insert(&h->large, s);
 
 	// TODO(rsc): IncrementalScavenge() to return memory to OS.
 }
 
 // Initialize a new span with the given start and npages.
 void
-MSpan_Init(MSpan *span, PageID start, uintptr npages)
+runtime·MSpan_Init(MSpan *span, PageID start, uintptr npages)
 {
 	span->next = nil;
 	span->prev = nil;
@@ -313,7 +313,7 @@
 
 // Initialize an empty doubly-linked list.
 void
-MSpanList_Init(MSpan *list)
+runtime·MSpanList_Init(MSpan *list)
 {
 	list->state = MSpanListHead;
 	list->next = list;
@@ -321,7 +321,7 @@
 }
 
 void
-MSpanList_Remove(MSpan *span)
+runtime·MSpanList_Remove(MSpan *span)
 {
 	if(span->prev == nil && span->next == nil)
 		return;
@@ -332,16 +332,16 @@
 }
 
 bool
-MSpanList_IsEmpty(MSpan *list)
+runtime·MSpanList_IsEmpty(MSpan *list)
 {
 	return list->next == list;
 }
 
 void
-MSpanList_Insert(MSpan *list, MSpan *span)
+runtime·MSpanList_Insert(MSpan *list, MSpan *span)
 {
 	if(span->next != nil || span->prev != nil)
-		throw("MSpanList_Insert");
+		runtime·throw("MSpanList_Insert");
 	span->next = list->next;
 	span->prev = list;
 	span->next->prev = span;
diff --git a/src/pkg/runtime/mheapmap32.c b/src/pkg/runtime/mheapmap32.c
index 4481e11..323f8b8 100644
--- a/src/pkg/runtime/mheapmap32.c
+++ b/src/pkg/runtime/mheapmap32.c
@@ -10,13 +10,13 @@
 
 // 3-level radix tree mapping page ids to Span*.
 void
-MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr))
+runtime·MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr))
 {
 	m->allocator = allocator;
 }
 
 MSpan*
-MHeapMap_Get(MHeapMap *m, PageID k)
+runtime·MHeapMap_Get(MHeapMap *m, PageID k)
 {
 	int32 i1, i2;
 
@@ -25,13 +25,13 @@
 	i1 = k & MHeapMap_Level1Mask;
 	k >>= MHeapMap_Level1Bits;
 	if(k != 0)
-		throw("MHeapMap_Get");
+		runtime·throw("MHeapMap_Get");
 
 	return m->p[i1]->s[i2];
 }
 
 MSpan*
-MHeapMap_GetMaybe(MHeapMap *m, PageID k)
+runtime·MHeapMap_GetMaybe(MHeapMap *m, PageID k)
 {
 	int32 i1, i2;
 	MHeapMapNode2 *p2;
@@ -41,7 +41,7 @@
 	i1 = k & MHeapMap_Level1Mask;
 	k >>= MHeapMap_Level1Bits;
 	if(k != 0)
-		throw("MHeapMap_Get");
+		runtime·throw("MHeapMap_Get");
 
 	p2 = m->p[i1];
 	if(p2 == nil)
@@ -50,7 +50,7 @@
 }
 
 void
-MHeapMap_Set(MHeapMap *m, PageID k, MSpan *s)
+runtime·MHeapMap_Set(MHeapMap *m, PageID k, MSpan *s)
 {
 	int32 i1, i2;
 
@@ -59,7 +59,7 @@
 	i1 = k & MHeapMap_Level1Mask;
 	k >>= MHeapMap_Level1Bits;
 	if(k != 0)
-		throw("MHeapMap_Set");
+		runtime·throw("MHeapMap_Set");
 
 	m->p[i1]->s[i2] = s;
 }
@@ -67,7 +67,7 @@
 // Allocate the storage required for entries [k, k+1, ..., k+len-1]
 // so that Get and Set calls need not check for nil pointers.
 bool
-MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr len)
+runtime·MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr len)
 {
 	uintptr end;
 	int32 i1;
diff --git a/src/pkg/runtime/mheapmap32.h b/src/pkg/runtime/mheapmap32.h
index cb8a830..29e61907 100644
--- a/src/pkg/runtime/mheapmap32.h
+++ b/src/pkg/runtime/mheapmap32.h
@@ -32,10 +32,10 @@
 	MSpan *s[1<<MHeapMap_Level2Bits];
 };
 
-void	MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr));
-bool	MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr npages);
-MSpan*	MHeapMap_Get(MHeapMap *m, PageID k);
-MSpan*	MHeapMap_GetMaybe(MHeapMap *m, PageID k);
-void	MHeapMap_Set(MHeapMap *m, PageID k, MSpan *v);
+void	runtime·MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr));
+bool	runtime·MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr npages);
+MSpan*	runtime·MHeapMap_Get(MHeapMap *m, PageID k);
+MSpan*	runtime·MHeapMap_GetMaybe(MHeapMap *m, PageID k);
+void	runtime·MHeapMap_Set(MHeapMap *m, PageID k, MSpan *v);
 
 
diff --git a/src/pkg/runtime/mheapmap64.c b/src/pkg/runtime/mheapmap64.c
index d5590a2..e45ac94 100644
--- a/src/pkg/runtime/mheapmap64.c
+++ b/src/pkg/runtime/mheapmap64.c
@@ -10,13 +10,13 @@
 
 // 3-level radix tree mapping page ids to Span*.
 void
-MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr))
+runtime·MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr))
 {
 	m->allocator = allocator;
 }
 
 MSpan*
-MHeapMap_Get(MHeapMap *m, PageID k)
+runtime·MHeapMap_Get(MHeapMap *m, PageID k)
 {
 	int32 i1, i2, i3;
 
@@ -27,13 +27,13 @@
 	i1 = k & MHeapMap_Level1Mask;
 	k >>= MHeapMap_Level1Bits;
 	if(k != 0)
-		throw("MHeapMap_Get");
+		runtime·throw("MHeapMap_Get");
 
 	return m->p[i1]->p[i2]->s[i3];
 }
 
 MSpan*
-MHeapMap_GetMaybe(MHeapMap *m, PageID k)
+runtime·MHeapMap_GetMaybe(MHeapMap *m, PageID k)
 {
 	int32 i1, i2, i3;
 	MHeapMapNode2 *p2;
@@ -46,7 +46,7 @@
 	i1 = k & MHeapMap_Level1Mask;
 	k >>= MHeapMap_Level1Bits;
 	if(k != 0)
-		throw("MHeapMap_Get");
+		runtime·throw("MHeapMap_Get");
 
 	p2 = m->p[i1];
 	if(p2 == nil)
@@ -58,7 +58,7 @@
 }
 
 void
-MHeapMap_Set(MHeapMap *m, PageID k, MSpan *s)
+runtime·MHeapMap_Set(MHeapMap *m, PageID k, MSpan *s)
 {
 	int32 i1, i2, i3;
 
@@ -69,7 +69,7 @@
 	i1 = k & MHeapMap_Level1Mask;
 	k >>= MHeapMap_Level1Bits;
 	if(k != 0)
-		throw("MHeapMap_Set");
+		runtime·throw("MHeapMap_Set");
 
 	m->p[i1]->p[i2]->s[i3] = s;
 }
@@ -77,7 +77,7 @@
 // Allocate the storage required for entries [k, k+1, ..., k+len-1]
 // so that Get and Set calls need not check for nil pointers.
 bool
-MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr len)
+runtime·MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr len)
 {
 	uintptr end;
 	int32 i1, i2;
diff --git a/src/pkg/runtime/mheapmap64.h b/src/pkg/runtime/mheapmap64.h
index fefeae6..a9934d2 100644
--- a/src/pkg/runtime/mheapmap64.h
+++ b/src/pkg/runtime/mheapmap64.h
@@ -51,10 +51,10 @@
 	MSpan *s[1<<MHeapMap_Level3Bits];
 };
 
-void	MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr));
-bool	MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr npages);
-MSpan*	MHeapMap_Get(MHeapMap *m, PageID k);
-MSpan*	MHeapMap_GetMaybe(MHeapMap *m, PageID k);
-void	MHeapMap_Set(MHeapMap *m, PageID k, MSpan *v);
+void	runtime·MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr));
+bool	runtime·MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr npages);
+MSpan*	runtime·MHeapMap_Get(MHeapMap *m, PageID k);
+MSpan*	runtime·MHeapMap_GetMaybe(MHeapMap *m, PageID k);
+void	runtime·MHeapMap_Set(MHeapMap *m, PageID k, MSpan *v);
 
 
diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index 61a5132..f4581e9 100644
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -45,7 +45,7 @@
 	Bucket *b;
 
 	if(buckhash == nil) {
-		buckhash = SysAlloc(BuckHashSize*sizeof buckhash[0]);
+		buckhash = runtime·SysAlloc(BuckHashSize*sizeof buckhash[0]);
 		mstats.buckhash_sys += BuckHashSize*sizeof buckhash[0];
 	}
 
@@ -62,12 +62,12 @@
 	i = h%BuckHashSize;
 	for(b = buckhash[i]; b; b=b->next)
 		if(b->hash == h && b->nstk == nstk &&
-		   mcmp((byte*)b->stk, (byte*)stk, nstk*sizeof stk[0]) == 0)
+		   runtime·mcmp((byte*)b->stk, (byte*)stk, nstk*sizeof stk[0]) == 0)
 			return b;
 
-	b = mallocgc(sizeof *b + nstk*sizeof stk[0], RefNoProfiling, 0, 1);
+	b = runtime·mallocgc(sizeof *b + nstk*sizeof stk[0], RefNoProfiling, 0, 1);
 	bucketmem += sizeof *b + nstk*sizeof stk[0];
-	memmove(b->stk, stk, nstk*sizeof stk[0]);
+	runtime·memmove(b->stk, stk, nstk*sizeof stk[0]);
 	b->hash = h;
 	b->nstk = nstk;
 	b->next = buckhash[i];
@@ -132,7 +132,7 @@
 		if(ah->addr == (addr>>20))
 			goto found;
 
-	ah = mallocgc(sizeof *ah, RefNoProfiling, 0, 1);
+	ah = runtime·mallocgc(sizeof *ah, RefNoProfiling, 0, 1);
 	addrmem += sizeof *ah;
 	ah->next = addrhash[h];
 	ah->addr = addr>>20;
@@ -140,7 +140,7 @@
 
 found:
 	if((e = addrfree) == nil) {
-		e = mallocgc(64*sizeof *e, RefNoProfiling, 0, 0);
+		e = runtime·mallocgc(64*sizeof *e, RefNoProfiling, 0, 0);
 		addrmem += 64*sizeof *e;
 		for(i=0; i+1<64; i++)
 			e[i].next = &e[i+1];
@@ -185,7 +185,7 @@
 
 // Called by malloc to record a profiled block.
 void
-MProf_Malloc(void *p, uintptr size)
+runtime·MProf_Malloc(void *p, uintptr size)
 {
 	int32 nstk;
 	uintptr stk[32];
@@ -195,19 +195,19 @@
 		return;
 
 	m->nomemprof++;
-	nstk = callers(1, stk, 32);
-	lock(&proflock);
+	nstk = runtime·callers(1, stk, 32);
+	runtime·lock(&proflock);
 	b = stkbucket(stk, nstk);
 	b->allocs++;
 	b->alloc_bytes += size;
 	setaddrbucket((uintptr)p, b);
-	unlock(&proflock);
+	runtime·unlock(&proflock);
 	m->nomemprof--;
 }
 
 // Called when freeing a profiled block.
 void
-MProf_Free(void *p, uintptr size)
+runtime·MProf_Free(void *p, uintptr size)
 {
 	Bucket *b;
 
@@ -215,13 +215,13 @@
 		return;
 
 	m->nomemprof++;
-	lock(&proflock);
+	runtime·lock(&proflock);
 	b = getaddrbucket((uintptr)p);
 	if(b != nil) {
 		b->frees++;
 		b->free_bytes += size;
 	}
-	unlock(&proflock);
+	runtime·unlock(&proflock);
 	m->nomemprof--;
 }
 
@@ -257,7 +257,7 @@
 	Bucket *b;
 	Record *r;
 
-	lock(&proflock);
+	runtime·lock(&proflock);
 	n = 0;
 	for(b=buckets; b; b=b->allnext)
 		if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
@@ -270,5 +270,5 @@
 			if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
 				record(r++, b);
 	}
-	unlock(&proflock);
+	runtime·unlock(&proflock);
 }
diff --git a/src/pkg/runtime/msize.c b/src/pkg/runtime/msize.c
index aebc154..ec85eb3 100644
--- a/src/pkg/runtime/msize.c
+++ b/src/pkg/runtime/msize.c
@@ -28,9 +28,9 @@
 #include "runtime.h"
 #include "malloc.h"
 
-int32 class_to_size[NumSizeClasses];
-int32 class_to_allocnpages[NumSizeClasses];
-int32 class_to_transfercount[NumSizeClasses];
+int32 runtime·class_to_size[NumSizeClasses];
+int32 runtime·class_to_allocnpages[NumSizeClasses];
+int32 runtime·class_to_transfercount[NumSizeClasses];
 
 // The SizeToClass lookup is implemented using two arrays,
 // one mapping sizes <= 1024 to their class and one mapping
@@ -45,24 +45,24 @@
 static int32 size_to_class128[(MaxSmallSize-1024)/128 + 1];
 
 int32
-SizeToClass(int32 size)
+runtime·SizeToClass(int32 size)
 {
 	if(size > MaxSmallSize)
-		throw("SizeToClass - invalid size");
+		runtime·throw("SizeToClass - invalid size");
 	if(size > 1024-8)
 		return size_to_class128[(size-1024+127) >> 7];
 	return size_to_class8[(size+7)>>3];
 }
 
 void
-InitSizes(void)
+runtime·InitSizes(void)
 {
 	int32 align, sizeclass, size, osize, nextsize, n;
 	uint32 i;
 	uintptr allocsize, npages;
 
-	// Initialize the class_to_size table (and choose class sizes in the process).
-	class_to_size[0] = 0;
+	// Initialize the runtime·class_to_size table (and choose class sizes in the process).
+	runtime·class_to_size[0] = 0;
 	sizeclass = 1;	// 0 means no class
 	align = 8;
 	for(size = align; size <= MaxSmallSize; size += align) {
@@ -75,7 +75,7 @@
 				align = 16;	// required for x86 SSE instructions, if we want to use them
 		}
 		if((align&(align-1)) != 0)
-			throw("InitSizes - bug");
+			runtime·throw("InitSizes - bug");
 
 		// Make the allocnpages big enough that
 		// the leftover is less than 1/8 of the total,
@@ -92,78 +92,78 @@
 		// use just this size instead of having two
 		// different sizes.
 		if(sizeclass > 1
-		&& npages == class_to_allocnpages[sizeclass-1]
-		&& allocsize/osize == allocsize/(class_to_size[sizeclass-1]+RefcountOverhead)) {
-			class_to_size[sizeclass-1] = size;
+		&& npages == runtime·class_to_allocnpages[sizeclass-1]
+		&& allocsize/osize == allocsize/(runtime·class_to_size[sizeclass-1]+RefcountOverhead)) {
+			runtime·class_to_size[sizeclass-1] = size;
 			continue;
 		}
 
-		class_to_allocnpages[sizeclass] = npages;
-		class_to_size[sizeclass] = size;
+		runtime·class_to_allocnpages[sizeclass] = npages;
+		runtime·class_to_size[sizeclass] = size;
 		sizeclass++;
 	}
 	if(sizeclass != NumSizeClasses) {
-		printf("sizeclass=%d NumSizeClasses=%d\n", sizeclass, NumSizeClasses);
-		throw("InitSizes - bad NumSizeClasses");
+		runtime·printf("sizeclass=%d NumSizeClasses=%d\n", sizeclass, NumSizeClasses);
+		runtime·throw("InitSizes - bad NumSizeClasses");
 	}
 
 	// Initialize the size_to_class tables.
 	nextsize = 0;
 	for (sizeclass = 1; sizeclass < NumSizeClasses; sizeclass++) {
-		for(; nextsize < 1024 && nextsize <= class_to_size[sizeclass]; nextsize+=8)
+		for(; nextsize < 1024 && nextsize <= runtime·class_to_size[sizeclass]; nextsize+=8)
 			size_to_class8[nextsize/8] = sizeclass;
 		if(nextsize >= 1024)
-			for(; nextsize <= class_to_size[sizeclass]; nextsize += 128)
+			for(; nextsize <= runtime·class_to_size[sizeclass]; nextsize += 128)
 				size_to_class128[(nextsize-1024)/128] = sizeclass;
 	}
 
 	// Double-check SizeToClass.
 	if(0) {
 		for(n=0; n < MaxSmallSize; n++) {
-			sizeclass = SizeToClass(n);
-			if(sizeclass < 1 || sizeclass >= NumSizeClasses || class_to_size[sizeclass] < n) {
-				printf("size=%d sizeclass=%d class_to_size=%d\n", n, sizeclass, class_to_size[sizeclass]);
-				printf("incorrect SizeToClass");
+			sizeclass = runtime·SizeToClass(n);
+			if(sizeclass < 1 || sizeclass >= NumSizeClasses || runtime·class_to_size[sizeclass] < n) {
+				runtime·printf("size=%d sizeclass=%d runtime·class_to_size=%d\n", n, sizeclass, runtime·class_to_size[sizeclass]);
+				runtime·printf("incorrect SizeToClass");
 				goto dump;
 			}
-			if(sizeclass > 1 && class_to_size[sizeclass-1] >= n) {
-				printf("size=%d sizeclass=%d class_to_size=%d\n", n, sizeclass, class_to_size[sizeclass]);
-				printf("SizeToClass too big");
+			if(sizeclass > 1 && runtime·class_to_size[sizeclass-1] >= n) {
+				runtime·printf("size=%d sizeclass=%d runtime·class_to_size=%d\n", n, sizeclass, runtime·class_to_size[sizeclass]);
+				runtime·printf("SizeToClass too big");
 				goto dump;
 			}
 		}
 	}
 
 	// Copy out for statistics table.
-	for(i=0; i<nelem(class_to_size); i++)
-		mstats.by_size[i].size = class_to_size[i];
+	for(i=0; i<nelem(runtime·class_to_size); i++)
+		mstats.by_size[i].size = runtime·class_to_size[i];
 
-	// Initialize the class_to_transfercount table.
+	// Initialize the runtime·class_to_transfercount table.
 	for(sizeclass = 1; sizeclass < NumSizeClasses; sizeclass++) {
-		n = 64*1024 / class_to_size[sizeclass];
+		n = 64*1024 / runtime·class_to_size[sizeclass];
 		if(n < 2)
 			n = 2;
 		if(n > 32)
 			n = 32;
-		class_to_transfercount[sizeclass] = n;
+		runtime·class_to_transfercount[sizeclass] = n;
 	}
 	return;
 
 dump:
 	if(1){
-		printf("NumSizeClasses=%d\n", NumSizeClasses);
-		printf("class_to_size:");
+		runtime·printf("NumSizeClasses=%d\n", NumSizeClasses);
+		runtime·printf("runtime·class_to_size:");
 		for(sizeclass=0; sizeclass<NumSizeClasses; sizeclass++)
-			printf(" %d", class_to_size[sizeclass]);
-		printf("\n\n");
-		printf("size_to_class8:");
+			runtime·printf(" %d", runtime·class_to_size[sizeclass]);
+		runtime·printf("\n\n");
+		runtime·printf("size_to_class8:");
 		for(i=0; i<nelem(size_to_class8); i++)
-			printf(" %d=>%d(%d)\n", i*8, size_to_class8[i], class_to_size[size_to_class8[i]]);
-		printf("\n");
-		printf("size_to_class128:");
+			runtime·printf(" %d=>%d(%d)\n", i*8, size_to_class8[i], runtime·class_to_size[size_to_class8[i]]);
+		runtime·printf("\n");
+		runtime·printf("size_to_class128:");
 		for(i=0; i<nelem(size_to_class128); i++)
-			printf(" %d=>%d(%d)\n", i*128, size_to_class128[i], class_to_size[size_to_class128[i]]);
-		printf("\n");
+			runtime·printf(" %d=>%d(%d)\n", i*128, size_to_class128[i], runtime·class_to_size[size_to_class128[i]]);
+		runtime·printf("\n");
 	}
-	throw("InitSizes failed");
+	runtime·throw("InitSizes failed");
 }
diff --git a/src/pkg/runtime/nacl/386/closure.c b/src/pkg/runtime/nacl/386/closure.c
index 977e630..6cab1eb 100644
--- a/src/pkg/runtime/nacl/386/closure.c
+++ b/src/pkg/runtime/nacl/386/closure.c
@@ -121,7 +121,7 @@
 #define codeptr(p) *(ClosureData***)((byte*)(p)+2)
 
 void
-finclosure(void *v)
+runtime·finclosure(void *v)
 {
 	byte *p;
 	ClosureFreeList *f;
@@ -130,10 +130,10 @@
 	p = clos.code + f->index*ClosureSize;
 	*codeptr(p) = nil;
 
-	lock(&clos);
+	runtime·lock(&clos);
 	f->next = clos.free;
 	clos.free = f;
-	unlock(&clos);
+	runtime·unlock(&clos);
 }
 
 #pragma textflag 7
@@ -141,7 +141,7 @@
 //	fn func(arg0, arg1, arg2 *ptr, callerpc uintptr, xxx) yyy,
 //	arg0, arg1, arg2 *ptr) (func(xxx) yyy)
 void
-·closure(int32 siz, byte *fn, byte *arg0)
+runtime·closure(int32 siz, byte *fn, byte *arg0)
 {
 	byte *p, **ret;
 	int32 e, i, n, off;
@@ -151,16 +151,16 @@
 	ClosureFreeList *f;
 
 	if(siz < 0 || siz%4 != 0)
-		throw("bad closure size");
+		runtime·throw("bad closure size");
 
 	ret = (byte**)((byte*)&arg0 + siz);
 
 	if(siz > 100) {
 		// TODO(rsc): implement stack growth preamble?
-		throw("closure too big");
+		runtime·throw("closure too big");
 	}
 
-	lock(&clos);
+	runtime·lock(&clos);
 	if(clos.free == nil) {
 		// Allocate more closures.
 		if(clos.code == nil) {
@@ -173,25 +173,25 @@
 		}
 		if(clos.ecode+ClosureChunk > rodata) {
 			// Last ditch effort: garbage collect and hope.
-			unlock(&clos);
-			gc(1);
-			lock(&clos);
+			runtime·unlock(&clos);
+			runtime·gc(1);
+			runtime·lock(&clos);
 			if(clos.free != nil)
 				goto alloc;
-			throw("ran out of room for closures in text segment");
+			runtime·throw("ran out of room for closures in text segment");
 		}
 
 		n = ClosureChunk/ClosureSize;
 		
 		// Allocate the pointer block as opaque to the
 		// garbage collector.  Finalizers will clean up.
-		block = mallocgc(n*sizeof block[0], RefNoPointers, 1, 1);
+		block = runtime·mallocgc(n*sizeof block[0], RefNoPointers, 1, 1);
 
 		// Pointers into the pointer block are getting added
 		// to the text segment; keep a pointer here in the data
 		// segment so that the garbage collector doesn't free
 		// the block itself.
-		l = mal(sizeof *l);
+		l = runtime·mal(sizeof *l);
 		l->block = block;
 		l->next = clos.datalist;
 		clos.datalist = l;
@@ -199,7 +199,7 @@
 		p = clos.buf;
 		off = (clos.ecode - clos.code)/ClosureSize;
 		for(i=0; i<n; i++) {
-			f = mal(sizeof *f);
+			f = runtime·mal(sizeof *f);
 			f->index = off++;
 			f->next = clos.free;
 			clos.free = f;
@@ -207,20 +207,20 @@
 			// There are two hard-coded immediate values in
 			// the assembly that need to be pp+i, one 2 bytes in
 			// and one 2 bytes after the 32-byte boundary.
-			mcpy(p, closasm, ClosureSize);
+			runtime·mcpy(p, closasm, ClosureSize);
 			*(ClosureData***)(p+2) = block+i;
 			*(ClosureData***)(p+32+2) = block+i;
 			p += ClosureSize;
 		}
 
 		if(p != clos.buf+sizeof clos.buf)
-			throw("bad buf math in closure");
+			runtime·throw("bad buf math in closure");
 
-		e = dyncode_copy(clos.ecode, clos.buf, ClosureChunk);
+		e = runtime·dyncode_copy(clos.ecode, clos.buf, ClosureChunk);
 		if(e != 0) {
 			fd = 2;
-			printf("dyncode_copy: error %d\n", e);
-			throw("dyncode_copy");
+			runtime·printf("dyncode_copy: error %d\n", e);
+			runtime·throw("dyncode_copy");
 		}
 		clos.ecode += ClosureChunk;
 	}
@@ -232,14 +232,14 @@
 	f->next = nil;
 	p = clos.code + f->index*ClosureSize;
 
-	d = mal(sizeof(*d)+siz);
+	d = runtime·mal(sizeof(*d)+siz);
 	d->free = f;
 	d->fn = fn;
 	d->siz = siz;
-	mcpy((byte*)(d+1), (byte*)&arg0, siz);
+	runtime·mcpy((byte*)(d+1), (byte*)&arg0, siz);
 	*codeptr(p) = d;
-	addfinalizer(f, finclosure, 0);
-	unlock(&clos);
+	runtime·addfinalizer(f, finclosure, 0);
+	runtime·unlock(&clos);
 
 	*ret = p;
 }
diff --git a/src/pkg/runtime/nacl/386/rt0.s b/src/pkg/runtime/nacl/386/rt0.s
index d967baf..838d139 100644
--- a/src/pkg/runtime/nacl/386/rt0.s
+++ b/src/pkg/runtime/nacl/386/rt0.s
@@ -4,5 +4,5 @@
 
 // Native Client and Linux use the same linkage to main
 
-TEXT	_rt0_386_nacl(SB),7,$0
+TEXT _rt0_386_nacl(SB),7,$0
 	JMP	_rt0_386(SB)
diff --git a/src/pkg/runtime/nacl/386/signal.c b/src/pkg/runtime/nacl/386/signal.c
index 4dda63f..50df77c 100644
--- a/src/pkg/runtime/nacl/386/signal.c
+++ b/src/pkg/runtime/nacl/386/signal.c
@@ -8,7 +8,7 @@
 #include "os.h"
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 }
 
diff --git a/src/pkg/runtime/nacl/386/sys.s b/src/pkg/runtime/nacl/386/sys.s
index 483cb7f..f758f8e 100644
--- a/src/pkg/runtime/nacl/386/sys.s
+++ b/src/pkg/runtime/nacl/386/sys.s
@@ -26,48 +26,48 @@
 
 #define SYSCALL(x)	$(0x10000+SYS_/**/x * 32)
 
-TEXT exit(SB),7,$4
+TEXT runtime·exit(SB),7,$4
 	MOVL	code+0(FP), AX
 	MOVL	AX, 0(SP)
 	CALL	SYSCALL(exit)
 	INT $3	// not reached
 	RET
 
-TEXT exit1(SB),7,$4
+TEXT runtime·exit1(SB),7,$4
 	MOVL	code+0(FP), AX
 	MOVL	AX, 0(SP)
 	CALL	SYSCALL(thread_exit)
 	INT $3	// not reached
 	RET
 
-TEXT write(SB),7,$0
+TEXT runtime·write(SB),7,$0
 	JMP	SYSCALL(write)
 
-TEXT close(SB),7,$0
+TEXT runtime·close(SB),7,$0
 	JMP	SYSCALL(close)
 
-TEXT mutex_create(SB),7,$0
+TEXT runtime·mutex_create(SB),7,$0
 	JMP	SYSCALL(mutex_create)
 
-TEXT mutex_lock(SB),7,$0
+TEXT runtime·mutex_lock(SB),7,$0
 	JMP	SYSCALL(mutex_lock)
 
-TEXT	mutex_unlock(SB),7,$0
+TEXT runtime·mutex_unlock(SB),7,$0
 	JMP	SYSCALL(mutex_unlock)
 
-TEXT thread_create(SB),7,$0
+TEXT runtime·thread_create(SB),7,$0
 	JMP	SYSCALL(thread_create)
 
-TEXT dyncode_copy(SB),7,$0
+TEXT runtime·dyncode_copy(SB),7,$0
 	JMP	SYSCALL(dyncode_copy)
 
 // For Native Client: a simple no-op function.
 // Inserting a call to this no-op is a simple way
 // to trigger an alignment.
-TEXT ·naclnop(SB),7,$0
+TEXT runtime·naclnop(SB),7,$0
 	RET
 
-TEXT ·mmap(SB),7,$24
+TEXT runtime·mmap(SB),7,$24
 	MOVL	a1+0(FP), BX
 	MOVL	a2+4(FP), CX	// round up to 64 kB boundary; silences nacl warning
 	ADDL	$(64*1024-1), CX
@@ -86,16 +86,16 @@
 	CMPL	AX, $0xfffff001
 	JLS	6(PC)
 	MOVL	$1, 0(SP)
-	MOVL	$mmap_failed(SB), 4(SP)
+	MOVL	$runtime·mmap_failed(SB), 4(SP)
 	MOVL	$12, 8(SP)	// "mmap failed\n"
 	CALL	SYSCALL(write)
 	INT $3
 	RET
 
-TEXT ·munmap(SB),7,$0
+TEXT runtime·munmap(SB),7,$0
 	JMP	SYSCALL(munmap)
 
-TEXT gettime(SB),7,$32
+TEXT runtime·gettime(SB),7,$32
 	LEAL	8(SP), BX
 	MOVL	BX, 0(SP)
 	MOVL	$0, 4(SP)
@@ -112,7 +112,7 @@
 	RET
 
 // setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$32
+TEXT runtime·setldt(SB),7,$32
 	// entry is ignored - nacl tells us the
 	// segment selector to use and stores it in GS.
 	MOVL	address+4(FP), BX
@@ -123,7 +123,7 @@
 	CMPL	AX, $0xfffff001
 	JLS	6(PC)
 	MOVL	$1, 0(SP)
-	MOVL	$tls_init_failed(SB), 4(SP)
+	MOVL	$runtime·tls_init_failed(SB), 4(SP)
 	MOVL	$16, 8(SP)	// "tls_init failed\n"
 	CALL	SYSCALL(write)
 	INT $3
@@ -133,10 +133,10 @@
 // broken NaCl process, so if something goes wrong,
 // print an error string before dying.
 
-DATA mmap_failed(SB)/8, $"mmap fai"
+DATA runtime·mmap_failed(SB)/8, $"mmap fai"
 DATA mmap_failed+8(SB)/4, $"led\n"
-GLOBL mmap_failed(SB), $12
+GLOBL runtime·mmap_failed(SB), $12
 
-DATA tls_init_failed(SB)/8, $"tls_init"
+DATA runtime·tls_init_failed(SB)/8, $"tls_init"
 DATA tls_init_failed+8(SB)/8, $" failed\n"
-GLOBL tls_init_failed(SB), $16
+GLOBL runtime·tls_init_failed(SB), $16
diff --git a/src/pkg/runtime/nacl/mem.c b/src/pkg/runtime/nacl/mem.c
index d3e4f41..ebe2e9c 100644
--- a/src/pkg/runtime/nacl/mem.c
+++ b/src/pkg/runtime/nacl/mem.c
@@ -8,14 +8,14 @@
 };
 
 void*
-SysAlloc(uintptr n)
+runtime·SysAlloc(uintptr n)
 {
 	mstats.sys += n;
-	return runtime_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
+	return runtime·mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v);
 	USED(n);
@@ -23,15 +23,15 @@
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
 	// round to page size or else nacl prints annoying log messages
 	mstats.sys -= n;
 	n = (n+NaclPage-1) & ~(NaclPage-1);
-	runtime_munmap(v, n);
+	runtime·munmap(v, n);
 }
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 }
diff --git a/src/pkg/runtime/nacl/os.h b/src/pkg/runtime/nacl/os.h
index eb4af57..ce58183 100644
--- a/src/pkg/runtime/nacl/os.h
+++ b/src/pkg/runtime/nacl/os.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-int32 thread_create(void(*fn)(void), void *stk, void *tls, int32 tlssize);
-void close(int32);
-int32 mutex_create(void);
-int32 mutex_lock(int32);
-int32 mutex_unlock(int32);
+int32 runtime·thread_create(void(*fn)(void), void *stk, void *tls, int32 tlssize);
+void runtime·close(int32);
+int32 runtime·mutex_create(void);
+int32 runtime·mutex_lock(int32);
+int32 runtime·mutex_unlock(int32);
diff --git a/src/pkg/runtime/nacl/thread.c b/src/pkg/runtime/nacl/thread.c
index 392be87..a0b6fa0 100644
--- a/src/pkg/runtime/nacl/thread.c
+++ b/src/pkg/runtime/nacl/thread.c
@@ -26,10 +26,10 @@
 	if(*psema != 0)	// already have one
 		return;
 
-	sema = mutex_create();
+	sema = runtime·mutex_create();
 	if((int32)sema < 0) {
-		printf("mutex_create failed\n");
-		breakpoint();
+		runtime·printf("mutex_create failed\n");
+		runtime·breakpoint();
 	}
 	// mutex_create returns a file descriptor;
 	// shift it up and add the 1 bit so that can
@@ -37,7 +37,7 @@
 	sema = (sema<<1) | 1;
 	if(!cas(psema, 0, sema)){
 		// Someone else filled it in.  Use theirs.
-		close(sema);
+		runtime·close(sema);
 		return;
 	}
 }
@@ -53,8 +53,8 @@
 xlock(int32 fd)
 {
 	if(mutex_lock(fd) < 0) {
-		printf("mutex_lock failed\n");
-		breakpoint();
+		runtime·printf("mutex_lock failed\n");
+		runtime·breakpoint();
 	}
 }
 
@@ -62,33 +62,33 @@
 xunlock(int32 fd)
 {
 	if(mutex_unlock(fd) < 0) {
-		printf("mutex_lock failed\n");
-		breakpoint();
+		runtime·printf("mutex_lock failed\n");
+		runtime·breakpoint();
 	}
 }
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 	if(l->sema == 0)
-		initsema(&l->sema);
-	xlock(l->sema>>1);
+		runtime·initsema(&l->sema);
+	runtime·xlock(l->sema>>1);
 }
 
 void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
-	xunlock(l->sema>>1);
+		runtime·throw("lock count");
+	runtime·xunlock(l->sema>>1);
 }
 
 void
-destroylock(Lock*)
+runtime·destroylock(Lock*)
 {
 }
 
@@ -108,36 +108,36 @@
 // a lock be the thread that releases the lock, so this is safe.
 
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	if(n->lock.sema == 0)
-		initsema(&n->lock.sema);
-	xlock(n->lock.sema>>1);
+		runtime·initsema(&n->lock.sema);
+	runtime·xlock(n->lock.sema>>1);
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	if(n->lock.sema == 0) {
-		printf("notewakeup without noteclear");
-		breakpoint();
+		runtime·printf("notewakeup without noteclear");
+		runtime·breakpoint();
 	}
-	xunlock(n->lock.sema>>1);
+	runtime·xunlock(n->lock.sema>>1);
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	if(n->lock.sema == 0) {
-		printf("notesleep without noteclear");
-		breakpoint();
+		runtime·printf("notesleep without noteclear");
+		runtime·breakpoint();
 	}
-	xlock(n->lock.sema>>1);
-	xunlock(n->lock.sema>>1);	// Let other sleepers find out too.
+	runtime·xlock(n->lock.sema>>1);
+	runtime·xunlock(n->lock.sema>>1);	// Let other sleepers find out too.
 }
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	void **vstk;
 
@@ -147,18 +147,18 @@
 	vstk = stk;
 	*--vstk = nil;
 	if(thread_create(fn, vstk, m->tls, sizeof m->tls) < 0) {
-		printf("thread_create failed\n");
-		breakpoint();
+		runtime·printf("thread_create failed\n");
+		runtime·breakpoint();
 	}
 }
 
 void
-osinit(void)
+runtime·osinit(void)
 {
 }
 
 // Called to initialize a new m (including the bootstrap m).
 void
-minit(void)
+runtime·minit(void)
 {
 }
diff --git a/src/pkg/runtime/plan9/386/rt0.s b/src/pkg/runtime/plan9/386/rt0.s
index e8d65d3..b56c8b3 100644
--- a/src/pkg/runtime/plan9/386/rt0.s
+++ b/src/pkg/runtime/plan9/386/rt0.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.
 
-TEXT	_rt0_386_plan9(SB),7, $0
+TEXT _rt0_386_plan9(SB),7, $0
 	MOVL	AX, _tos(SB)
 	
 	// move arguments down to make room for
@@ -27,6 +27,6 @@
 	
 	JMP	_rt0_386(SB)
 
-DATA  isplan9+0(SB)/4, $1
-GLOBL isplan9(SB), $4
+DATA  runtime·isplan9(SB)/4, $1
+GLOBL runtime·isplan9(SB), $4
 GLOBL _tos(SB), $4
diff --git a/src/pkg/runtime/plan9/386/signal.c b/src/pkg/runtime/plan9/386/signal.c
index e7c9844..95fb2ca 100644
--- a/src/pkg/runtime/plan9/386/signal.c
+++ b/src/pkg/runtime/plan9/386/signal.c
@@ -5,6 +5,6 @@
 #include "runtime.h"
 
 void
-gettime(int64*, int32*) 
+runtime·gettime(int64*, int32*) 
 {
 }
diff --git a/src/pkg/runtime/plan9/386/sys.s b/src/pkg/runtime/plan9/386/sys.s
index 8dbacc0..867b894 100644
--- a/src/pkg/runtime/plan9/386/sys.s
+++ b/src/pkg/runtime/plan9/386/sys.s
@@ -6,35 +6,35 @@
 #include "386/asm.h"
 
 // setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$0
+TEXT runtime·setldt(SB),7,$0
 	RET
 
-TEXT write(SB),7,$0
+TEXT runtime·write(SB),7,$0
 	MOVL    $20, AX
 	INT     $64
 	RET
 
-TEXT exits(SB),7,$0
+TEXT runtime·exits(SB),7,$0
 	MOVL    $8, AX
 	INT     $64
 	RET
 
-TEXT brk_(SB),7,$0
+TEXT runtime·brk_(SB),7,$0
 	MOVL    $24, AX
 	INT     $64
 	RET
 
-TEXT plan9_semacquire(SB),7,$0
+TEXT runtime·plan9_semacquire(SB),7,$0
 	MOVL	$37, AX
 	INT	$64
 	RET
 	
-TEXT plan9_semrelease(SB),7,$0
+TEXT runtime·plan9_semrelease(SB),7,$0
 	MOVL	$38, AX
 	INT	$64
 	RET
 	
-TEXT rfork(SB),7,$0
+TEXT runtime·rfork(SB),7,$0
 	MOVL    $19, AX // rfork
 	INT     $64
 
@@ -61,16 +61,16 @@
 	MOVL	0xdfffeff8, AX
 	MOVL	AX, m_procid(BX)	// save pid as m->procid
 
-	CALL	stackcheck(SB)	// smashes AX, CX
+	CALL	runtime·stackcheck(SB)	// smashes AX, CX
 	
 	MOVL	0(DX), DX	// paranoia; check they are not nil
 	MOVL	0(BX), BX
 	
 	// more paranoia; check that stack splitting code works
 	PUSHAL
-	CALL	emptyfunc(SB)
+	CALL	runtime·emptyfunc(SB)
 	POPAL
 	
 	CALL	SI	// fn()
-	CALL	exit(SB)
+	CALL	runtime·exit(SB)
 	RET
diff --git a/src/pkg/runtime/plan9/mem.c b/src/pkg/runtime/plan9/mem.c
index 7d214c3..7e36f95 100644
--- a/src/pkg/runtime/plan9/mem.c
+++ b/src/pkg/runtime/plan9/mem.c
@@ -14,7 +14,7 @@
 };
 
 void*
-SysAlloc(uintptr ask)
+runtime·SysAlloc(uintptr ask)
 {
 	uintptr bl;
 	
@@ -27,7 +27,7 @@
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
 	// from tiny/mem.c
 	// Push pointer back if this is a free
@@ -38,12 +38,12 @@
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v, n);
 }
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 }
diff --git a/src/pkg/runtime/plan9/os.h b/src/pkg/runtime/plan9/os.h
index 748cf7a..9444acc 100644
--- a/src/pkg/runtime/plan9/os.h
+++ b/src/pkg/runtime/plan9/os.h
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-extern int32 write(int32 fd, void* buffer, int32 nbytes);
-extern void exits(int8* msg);
-extern int32 brk_(void*);
+extern int32 runtime·write(int32 fd, void* buffer, int32 nbytes);
+extern void runtime·exits(int8* msg);
+extern int32 runtime·brk_(void*);
 
 /* rfork */
 enum
@@ -22,6 +22,6 @@
 	RFREND          = (1<<13),
 	RFNOMNT         = (1<<14)
 };
-extern int32 rfork(int32 flags, void *stk, M *m, G *g, void (*fn)(void));
-extern int32 plan9_semacquire(uint32 *addr, int32 block);
-extern int32 plan9_semrelease(uint32 *addr, int32 count);
+extern int32 runtime·rfork(int32 flags, void *stk, M *m, G *g, void (*fn)(void));
+extern int32 runtime·plan9_semacquire(uint32 *addr, int32 block);
+extern int32 runtime·plan9_semrelease(uint32 *addr, int32 count);
diff --git a/src/pkg/runtime/plan9/thread.c b/src/pkg/runtime/plan9/thread.c
index 96e83fc..81e3bff 100644
--- a/src/pkg/runtime/plan9/thread.c
+++ b/src/pkg/runtime/plan9/thread.c
@@ -8,39 +8,39 @@
 int8 *goos = "plan9";
 
 void
-minit(void)
+runtime·minit(void)
 {
 }
 
 void
-osinit(void)
+runtime·osinit(void)
 {
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 }
 
 void
-exit(int32)
+runtime·exit(int32)
 {
-	exits(nil);
+	runtime·exits(nil);
 }
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	USED(m, g, stk, fn);
 	
 	m->tls[0] = m->id;	// so 386 asm can find it
 	if(0){
-		printf("newosproc stk=%p m=%p g=%p fn=%p rfork=%p id=%d/%d ostk=%p\n",
+		runtime·printf("newosproc stk=%p m=%p g=%p fn=%p rfork=%p id=%d/%d ostk=%p\n",
 			stk, m, g, fn, rfork, m->id, m->tls[0], &m);
 	}        
 	
 	if (rfork(RFPROC | RFMEM, stk, m, g, fn) < 0 )
-		throw("newosproc: rfork failed");
+		runtime·throw("newosproc: rfork failed");
 }
 
 // Blocking locks.
@@ -57,10 +57,10 @@
 // in Plan 9's user-level locks.
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 	
 	if(xadd(&l->key, 1) == 1)
@@ -72,21 +72,21 @@
 }
 
 void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 
 	if(xadd(&l->key, -1) == 0)
 		return; // changed from 1 -> 0: no contention
 	
-	plan9_semrelease(&l->sema, 1);
+	runtime·plan9_semrelease(&l->sema, 1);
 }
 
 
 void 
-destroylock(Lock *l)
+runtime·destroylock(Lock *l)
 {
 	// nothing
 }
@@ -96,7 +96,7 @@
 // but when it's time to block, fall back on the kernel semaphore k.
 // This is the same algorithm used in Plan 9.
 void
-usemacquire(Usema *s)
+runtime·usemacquire(Usema *s)
 {
 	if((int32)xadd(&s->u, -1) < 0)
 		while(plan9_semacquire(&s->k, 1) < 0) {
@@ -105,31 +105,31 @@
 }
 
 void
-usemrelease(Usema *s)
+runtime·usemrelease(Usema *s)
 {
 	if((int32)xadd(&s->u, 1) <= 0)
-		plan9_semrelease(&s->k, 1);
+		runtime·plan9_semrelease(&s->k, 1);
 }
 
 
 // Event notifications.
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	n->wakeup = 0;
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	while(!n->wakeup)
-		usemacquire(&n->sema);
+		runtime·usemacquire(&n->sema);
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	n->wakeup = 1;
-	usemrelease(&n->sema);
+	runtime·usemrelease(&n->sema);
 }
 
diff --git a/src/pkg/runtime/print.c b/src/pkg/runtime/print.c
index 68f84b4..922c49e 100644
--- a/src/pkg/runtime/print.c
+++ b/src/pkg/runtime/print.c
@@ -10,31 +10,31 @@
 static void vprintf(int8*, byte*);
 
 void
-dump(byte *p, int32 n)
+runtime·dump(byte *p, int32 n)
 {
 	int32 i;
 
 	for(i=0; i<n; i++) {
-		·printpointer((byte*)(p[i]>>4));
-		·printpointer((byte*)(p[i]&0xf));
+		runtime·printpointer((byte*)(p[i]>>4));
+		runtime·printpointer((byte*)(p[i]&0xf));
 		if((i&15) == 15)
-			prints("\n");
+			runtime·prints("\n");
 		else
-			prints(" ");
+			runtime·prints(" ");
 	}
 	if(n & 15)
-		prints("\n");
+		runtime·prints("\n");
 }
 
 void
-prints(int8 *s)
+runtime·prints(int8 *s)
 {
-	write(fd, s, findnull((byte*)s));
+	runtime·write(runtime·fd, s, runtime·findnull((byte*)s));
 }
 
 #pragma textflag 7
 void
-printf(int8 *s, ...)
+runtime·printf(int8 *s, ...)
 {
 	byte *arg;
 
@@ -65,7 +65,7 @@
 		if(*p != '%')
 			continue;
 		if(p > lp)
-			write(fd, lp, p-lp);
+			runtime·write(runtime·fd, lp, p-lp);
 		p++;
 		narg = nil;
 		switch(*p) {
@@ -109,103 +109,101 @@
 		}
 		switch(*p) {
 		case 'a':
-			·printslice(*(Slice*)arg);
+			runtime·printslice(*(Slice*)arg);
 			break;
 		case 'd':
-			·printint(*(int32*)arg);
+			runtime·printint(*(int32*)arg);
 			break;
 		case 'D':
-			·printint(*(int64*)arg);
+			runtime·printint(*(int64*)arg);
 			break;
 		case 'e':
-			·printeface(*(Eface*)arg);
+			runtime·printeface(*(Eface*)arg);
 			break;
 		case 'f':
-			·printfloat(*(float64*)arg);
+			runtime·printfloat(*(float64*)arg);
 			break;
 		case 'C':
-			·printcomplex(*(Complex128*)arg);
+			runtime·printcomplex(*(Complex128*)arg);
 			break;
 		case 'i':
-			·printiface(*(Iface*)arg);
+			runtime·printiface(*(Iface*)arg);
 			break;
 		case 'p':
-			·printpointer(*(void**)arg);
+			runtime·printpointer(*(void**)arg);
 			break;
 		case 's':
-			prints(*(int8**)arg);
+			runtime·prints(*(int8**)arg);
 			break;
 		case 'S':
-			·printstring(*(String*)arg);
+			runtime·printstring(*(String*)arg);
 			break;
 		case 't':
-			·printbool(*(bool*)arg);
+			runtime·printbool(*(bool*)arg);
 			break;
 		case 'U':
-			·printuint(*(uint64*)arg);
+			runtime·printuint(*(uint64*)arg);
 			break;
 		case 'x':
-			·printhex(*(uint32*)arg);
+			runtime·printhex(*(uint32*)arg);
 			break;
 		case 'X':
-			·printhex(*(uint64*)arg);
+			runtime·printhex(*(uint64*)arg);
 			break;
-		case '!':
-			panic(-1);
 		}
 		arg = narg;
 		lp = p+1;
 	}
 	if(p > lp)
-		write(fd, lp, p-lp);
+		runtime·write(runtime·fd, lp, p-lp);
 
 //	unlock(&debuglock);
 }
 
 #pragma textflag 7
 void
-·printf(String s, ...)
+runtime·goprintf(String s, ...)
 {
 	// Can assume s has terminating NUL because only
-	// the Go compiler generates calls to ·printf, using
+	// the Go compiler generates calls to runtime·goprintf, using
 	// string constants, and all the string constants have NULs.
 	vprintf((int8*)s.str, (byte*)(&s+1));
 }
 
 void
-·printpc(void *p)
+runtime·printpc(void *p)
 {
-	prints("PC=");
-	·printhex((uint64)·getcallerpc(p));
+	runtime·prints("PC=");
+	runtime·printhex((uint64)runtime·getcallerpc(p));
 }
 
 void
-·printbool(bool v)
+runtime·printbool(bool v)
 {
 	if(v) {
-		write(fd, (byte*)"true", 4);
+		runtime·write(runtime·fd, (byte*)"true", 4);
 		return;
 	}
-	write(fd, (byte*)"false", 5);
+	runtime·write(runtime·fd, (byte*)"false", 5);
 }
 
 void
-·printfloat(float64 v)
+runtime·printfloat(float64 v)
 {
 	byte buf[20];
 	int32 e, s, i, n;
 	float64 h;
 
-	if(isNaN(v)) {
-		write(fd, "NaN", 3);
+	if(runtime·isNaN(v)) {
+		runtime·write(runtime·fd, "NaN", 3);
 		return;
 	}
-	if(isInf(v, 1)) {
-		write(fd, "+Inf", 4);
+	if(runtime·isInf(v, 1)) {
+		runtime·write(runtime·fd, "+Inf", 4);
 		return;
 	}
-	if(isInf(v, -1)) {
-		write(fd, "-Inf", 4);
+	if(runtime·isInf(v, -1)) {
+		runtime·write(runtime·fd, "-Inf", 4);
 		return;
 	}
 
@@ -264,20 +262,20 @@
 	buf[n+4] = (e/100) + '0';
 	buf[n+5] = (e/10)%10 + '0';
 	buf[n+6] = (e%10) + '0';
-	write(fd, buf, n+7);
+	runtime·write(runtime·fd, buf, n+7);
 }
 
 void
-·printcomplex(Complex128 v)
+runtime·printcomplex(Complex128 v)
 {
-	write(fd, "(", 1);
-	·printfloat(v.real);
-	·printfloat(v.imag);
-	write(fd, "i)", 2);
+	runtime·write(runtime·fd, "(", 1);
+	runtime·printfloat(v.real);
+	runtime·printfloat(v.imag);
+	runtime·write(runtime·fd, "i)", 2);
 }
 
 void
-·printuint(uint64 v)
+runtime·printuint(uint64 v)
 {
 	byte buf[100];
 	int32 i;
@@ -288,21 +286,21 @@
 			break;
 		v = v/10;
 	}
-	write(fd, buf+i, nelem(buf)-i);
+	runtime·write(runtime·fd, buf+i, nelem(buf)-i);
 }
 
 void
-·printint(int64 v)
+runtime·printint(int64 v)
 {
 	if(v < 0) {
-		write(fd, "-", 1);
+		runtime·write(runtime·fd, "-", 1);
 		v = -v;
 	}
-	·printuint(v);
+	runtime·printuint(v);
 }
 
 void
-·printhex(uint64 v)
+runtime·printhex(uint64 v)
 {
 	static int8 *dig = "0123456789abcdef";
 	byte buf[100];
@@ -315,42 +313,42 @@
 		buf[--i] = '0';
 	buf[--i] = 'x';
 	buf[--i] = '0';
-	write(fd, buf+i, nelem(buf)-i);
+	runtime·write(runtime·fd, buf+i, nelem(buf)-i);
 }
 
 void
-·printpointer(void *p)
+runtime·printpointer(void *p)
 {
-	·printhex((uint64)p);
+	runtime·printhex((uint64)p);
 }
 
 void
-·printstring(String v)
+runtime·printstring(String v)
 {
-	extern int32 maxstring;
+	extern int32 runtime·maxstring;
 
-	if(v.len > maxstring) {
-		write(fd, "[invalid string]", 16);
+	if(v.len > runtime·maxstring) {
+		runtime·write(runtime·fd, "[invalid string]", 16);
 		return;
 	}
 	if(v.len > 0)
-		write(fd, v.str, v.len);
+		runtime·write(runtime·fd, v.str, v.len);
 }
 
 void
-·printsp(void)
+runtime·printsp(void)
 {
-	write(fd, " ", 1);
+	runtime·write(runtime·fd, " ", 1);
 }
 
 void
-·printnl(void)
+runtime·printnl(void)
 {
-	write(fd, "\n", 1);
+	runtime·write(runtime·fd, "\n", 1);
 }
 
 void
-·typestring(Eface e, String s)
+runtime·typestring(Eface e, String s)
 {
 	s = *e.type->string;
 	FLUSH(&s);
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index b07b6d6..31641ba 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -12,12 +12,12 @@
 
 typedef struct Sched Sched;
 
-M	m0;
-G	g0;	// idle goroutine for m0
+M	runtime·m0;
+G	runtime·g0;	// idle goroutine for m0
 
 static	int32	debug	= 0;
 
-int32	gcwaiting;
+int32	runtime·gcwaiting;
 
 // Go scheduler
 //
@@ -36,7 +36,7 @@
 //
 // Even a program that can run without deadlock in a single process
 // might use more ms if given the chance.  For example, the prime
-// sieve will use as many ms as there are primes (up to sched.mmax),
+// sieve will use as many ms as there are primes (up to runtime·sched.mmax),
 // allowing different stages of the pipeline to execute in parallel.
 // We could revisit this choice, only kicking off new ms for blocking
 // system calls, but that would limit the amount of parallel computation
@@ -70,7 +70,7 @@
 	int32 waitstop;	// after setting this flag
 };
 
-Sched sched;
+Sched runtime·sched;
 
 // Scheduling helpers.  Sched must be locked.
 static void gput(G*);	// put/get on ghead/gtail
@@ -91,7 +91,7 @@
 //	call osinit
 //	call schedinit
 //	make & queue new G
-//	call mstart
+//	call runtime·mstart
 //
 // The new G does:
 //
@@ -99,66 +99,66 @@
 //	call initdone
 //	call main·main
 void
-schedinit(void)
+runtime·schedinit(void)
 {
 	int32 n;
 	byte *p;
 
-	allm = m;
+	runtime·allm = m;
 	m->nomemprof++;
 
-	mallocinit();
-	goargs();
+	runtime·mallocinit();
+	runtime·goargs();
 
 	// For debugging:
 	// Allocate internal symbol table representation now,
 	// so that we don't need to call malloc when we crash.
 	// findfunc(0);
 
-	sched.gomaxprocs = 1;
-	p = getenv("GOMAXPROCS");
-	if(p != nil && (n = atoi(p)) != 0)
-		sched.gomaxprocs = n;
-	sched.mcpumax = sched.gomaxprocs;
-	sched.mcount = 1;
-	sched.predawn = 1;
+	runtime·sched.gomaxprocs = 1;
+	p = runtime·getenv("GOMAXPROCS");
+	if(p != nil && (n = runtime·atoi(p)) != 0)
+		runtime·sched.gomaxprocs = n;
+	runtime·sched.mcpumax = runtime·sched.gomaxprocs;
+	runtime·sched.mcount = 1;
+	runtime·sched.predawn = 1;
 
 	m->nomemprof--;
 }
 
 // Called after main·init_function; main·main will be called on return.
 void
-initdone(void)
+runtime·initdone(void)
 {
 	// Let's go.
-	sched.predawn = 0;
+	runtime·sched.predawn = 0;
 	mstats.enablegc = 1;
 
 	// If main·init_function started other goroutines,
 	// kick off new ms to handle them, like ready
 	// would have, had it not been pre-dawn.
-	lock(&sched);
+	runtime·lock(&runtime·sched);
 	matchmg();
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 }
 
 void
-goexit(void)
+runtime·goexit(void)
 {
 	g->status = Gmoribund;
-	gosched();
+	runtime·gosched();
 }
 
 void
-tracebackothers(G *me)
+runtime·tracebackothers(G *me)
 {
 	G *g;
 
-	for(g = allg; g != nil; g = g->alllink) {
+	for(g = runtime·allg; g != nil; g = g->alllink) {
 		if(g == me || g->status == Gdead)
 			continue;
-		printf("\ngoroutine %d [%d]:\n", g->goid, g->status);
-		traceback(g->sched.pc, g->sched.sp, 0, g);
+		runtime·printf("\ngoroutine %d [%d]:\n", g->goid, g->status);
+		runtime·traceback(g->sched.pc, g->sched.sp, 0, g);
 	}
 }
 
@@ -169,18 +169,18 @@
 	M *m;
 
 	// If g is wired, hand it off directly.
-	if(sched.mcpu < sched.mcpumax && (m = g->lockedm) != nil) {
+	if(runtime·sched.mcpu < runtime·sched.mcpumax && (m = g->lockedm) != nil) {
 		mnextg(m, g);
 		return;
 	}
 
 	g->schedlink = nil;
-	if(sched.ghead == nil)
-		sched.ghead = g;
+	if(runtime·sched.ghead == nil)
+		runtime·sched.ghead = g;
 	else
-		sched.gtail->schedlink = g;
-	sched.gtail = g;
-	sched.gwait++;
+		runtime·sched.gtail->schedlink = g;
+	runtime·sched.gtail = g;
+	runtime·sched.gwait++;
 }
 
 // Get from `g' queue.  Sched must be locked.
@@ -189,12 +189,12 @@
 {
 	G *g;
 
-	g = sched.ghead;
+	g = runtime·sched.ghead;
 	if(g){
-		sched.ghead = g->schedlink;
-		if(sched.ghead == nil)
-			sched.gtail = nil;
-		sched.gwait--;
+		runtime·sched.ghead = g->schedlink;
+		if(runtime·sched.ghead == nil)
+			runtime·sched.gtail = nil;
+		runtime·sched.gwait--;
 	}
 	return g;
 }
@@ -203,9 +203,9 @@
 static void
 mput(M *m)
 {
-	m->schedlink = sched.mhead;
-	sched.mhead = m;
-	sched.mwait++;
+	m->schedlink = runtime·sched.mhead;
+	runtime·sched.mhead = m;
+	runtime·sched.mwait++;
 }
 
 // Get an `m' to run `g'.  Sched must be locked.
@@ -219,20 +219,20 @@
 		return m;
 
 	// otherwise use general m pool.
-	if((m = sched.mhead) != nil){
-		sched.mhead = m->schedlink;
-		sched.mwait--;
+	if((m = runtime·sched.mhead) != nil){
+		runtime·sched.mhead = m->schedlink;
+		runtime·sched.mwait--;
 	}
 	return m;
 }
 
 // Mark g ready to run.
 void
-ready(G *g)
+runtime·ready(G *g)
 {
-	lock(&sched);
+	runtime·lock(&runtime·sched);
 	readylocked(g);
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 }
 
 // Mark g ready to run.  Sched is already locked.
@@ -250,11 +250,11 @@
 
 	// Mark runnable.
 	if(g->status == Grunnable || g->status == Grunning || g->status == Grecovery)
-		throw("bad g->status in ready");
+		runtime·throw("bad g->status in ready");
 	g->status = Grunnable;
 
 	gput(g);
-	if(!sched.predawn)
+	if(!runtime·sched.predawn)
 		matchmg();
 }
 
@@ -277,11 +277,11 @@
 static void
 mnextg(M *m, G *g)
 {
-	sched.mcpu++;
+	runtime·sched.mcpu++;
 	m->nextg = g;
 	if(m->waitnextg) {
 		m->waitnextg = 0;
-		notewakeup(&m->havenextg);
+		runtime·notewakeup(&m->havenextg);
 	}
 }
 
@@ -294,15 +294,15 @@
 {
 	G *gp;
 
-	if(sched.mcpu < 0)
-		throw("negative sched.mcpu");
+	if(runtime·sched.mcpu < 0)
+		runtime·throw("negative runtime·sched.mcpu");
 
 	// If there is a g waiting as m->nextg,
-	// mnextg took care of the sched.mcpu++.
+	// mnextg took care of the runtime·sched.mcpu++.
 	if(m->nextg != nil) {
 		gp = m->nextg;
 		m->nextg = nil;
-		unlock(&sched);
+		runtime·unlock(&runtime·sched);
 		return gp;
 	}
 
@@ -310,36 +310,36 @@
 		// We can only run one g, and it's not available.
 		// Make sure some other cpu is running to handle
 		// the ordinary run queue.
-		if(sched.gwait != 0)
+		if(runtime·sched.gwait != 0)
 			matchmg();
 	} else {
 		// Look for work on global queue.
-		while(sched.mcpu < sched.mcpumax && (gp=gget()) != nil) {
+		while(runtime·sched.mcpu < runtime·sched.mcpumax && (gp=gget()) != nil) {
 			if(gp->lockedm) {
 				mnextg(gp->lockedm, gp);
 				continue;
 			}
-			sched.mcpu++;		// this m will run gp
-			unlock(&sched);
+			runtime·sched.mcpu++;		// this m will run gp
+			runtime·unlock(&runtime·sched);
 			return gp;
 		}
 		// Otherwise, wait on global m queue.
 		mput(m);
 	}
-	if(sched.mcpu == 0 && sched.msyscall == 0)
-		throw("all goroutines are asleep - deadlock!");
+	if(runtime·sched.mcpu == 0 && runtime·sched.msyscall == 0)
+		runtime·throw("all goroutines are asleep - deadlock!");
 	m->nextg = nil;
 	m->waitnextg = 1;
-	noteclear(&m->havenextg);
-	if(sched.waitstop && sched.mcpu <= sched.mcpumax) {
-		sched.waitstop = 0;
-		notewakeup(&sched.stopped);
+	runtime·noteclear(&m->havenextg);
+	if(runtime·sched.waitstop && runtime·sched.mcpu <= runtime·sched.mcpumax) {
+		runtime·sched.waitstop = 0;
+		runtime·notewakeup(&runtime·sched.stopped);
 	}
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 
-	notesleep(&m->havenextg);
+	runtime·notesleep(&m->havenextg);
 	if((gp = m->nextg) == nil)
-		throw("bad m->nextg in nextgoroutine");
+		runtime·throw("bad m->nextg in nextgoroutine");
 	m->nextg = nil;
 	return gp;
 }
@@ -347,46 +347,46 @@
 // TODO(rsc): Remove. This is only temporary,
 // for the mark and sweep collector.
 void
-stoptheworld(void)
+runtime·stoptheworld(void)
 {
-	lock(&sched);
-	gcwaiting = 1;
-	sched.mcpumax = 1;
-	while(sched.mcpu > 1) {
+	runtime·lock(&runtime·sched);
+	runtime·gcwaiting = 1;
+	runtime·sched.mcpumax = 1;
+	while(runtime·sched.mcpu > 1) {
 		// It would be unsafe for multiple threads to be using
 		// the stopped note at once, but there is only
 		// ever one thread doing garbage collection,
 		// so this is okay.
-		noteclear(&sched.stopped);
-		sched.waitstop = 1;
-		unlock(&sched);
-		notesleep(&sched.stopped);
-		lock(&sched);
+		runtime·noteclear(&runtime·sched.stopped);
+		runtime·sched.waitstop = 1;
+		runtime·unlock(&runtime·sched);
+		runtime·notesleep(&runtime·sched.stopped);
+		runtime·lock(&runtime·sched);
 	}
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 }
 
 // TODO(rsc): Remove. This is only temporary,
 // for the mark and sweep collector.
 void
-starttheworld(void)
+runtime·starttheworld(void)
 {
-	lock(&sched);
-	gcwaiting = 0;
-	sched.mcpumax = sched.gomaxprocs;
+	runtime·lock(&runtime·sched);
+	runtime·gcwaiting = 0;
+	runtime·sched.mcpumax = runtime·sched.gomaxprocs;
 	matchmg();
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 }
 
 // Called to start an M.
 void
-mstart(void)
+runtime·mstart(void)
 {
 	if(g != m->g0)
-		throw("bad mstart");
+		runtime·throw("bad runtime·mstart");
 	if(m->mcache == nil)
-		m->mcache = allocmcache();
-	minit();
+		m->mcache = runtime·allocmcache();
+	runtime·minit();
 	scheduler();
 }
 
@@ -414,33 +414,33 @@
 
 	if(m->mallocing || m->gcing)
 		return;
-	while(sched.mcpu < sched.mcpumax && (g = gget()) != nil){
+	while(runtime·sched.mcpu < runtime·sched.mcpumax && (g = gget()) != nil){
 		M *m;
 
 		// Find the m that will run g.
 		if((m = mget(g)) == nil){
-			m = malloc(sizeof(M));
-			// Add to allm so garbage collector doesn't free m
+			m = runtime·malloc(sizeof(M));
+			// Add to runtime·allm so garbage collector doesn't free m
 			// when it is just in a register (R14 on amd64).
-			m->alllink = allm;
-			allm = m;
-			m->id = sched.mcount++;
+			m->alllink = runtime·allm;
+			runtime·allm = m;
+			m->id = runtime·sched.mcount++;
 
 			if(libcgo_thread_start != nil) {
 				CgoThreadStart ts;
 				// pthread_create will make us a stack.
-				m->g0 = malg(-1);
+				m->g0 = runtime·malg(-1);
 				ts.m = m;
 				ts.g = m->g0;
-				ts.fn = mstart;
-				runcgo(libcgo_thread_start, &ts);
+				ts.fn = runtime·mstart;
+				runtime·runcgo(libcgo_thread_start, &ts);
 			} else {
 				if(Windows)
 					// windows will layout sched stack on os stack
-					m->g0 = malg(-1);
+					m->g0 = runtime·malg(-1);
 				else
-					m->g0 = malg(8192);
-				newosproc(m, m->g0, m->g0->stackbase, mstart);
+					m->g0 = runtime·malg(8192);
+				runtime·newosproc(m, m->g0, m->g0->stackbase, runtime·mstart);
 			}
 		}
 		mnextg(m, g);
@@ -453,8 +453,8 @@
 {
 	G* gp;
 
-	lock(&sched);
-	if(gosave(&m->sched) != 0){
+	runtime·lock(&runtime·sched);
+	if(runtime·gosave(&m->sched) != 0){
 		gp = m->curg;
 		if(gp->status == Grecovery) {
 			// switched to scheduler to get stack unwound.
@@ -475,31 +475,31 @@
 			// each call to deferproc.
 			// (the pc we're returning to does pop pop
 			// before it tests the return value.)
-			gp->sched.sp = getcallersp(d->sp - 2*sizeof(uintptr));
+			gp->sched.sp = runtime·getcallersp(d->sp - 2*sizeof(uintptr));
 			gp->sched.pc = d->pc;
 			gp->status = Grunning;
-			free(d);
-			gogo(&gp->sched, 1);
+			runtime·free(d);
+			runtime·gogo(&gp->sched, 1);
 		}
 
-		// Jumped here via gosave/gogo, so didn't
-		// execute lock(&sched) above.
-		lock(&sched);
+		// Jumped here via runtime·gosave/gogo, so didn't
+		// execute lock(&runtime·sched) above.
+		runtime·lock(&runtime·sched);
 
-		if(sched.predawn)
-			throw("init sleeping");
+		if(runtime·sched.predawn)
+			runtime·throw("init sleeping");
 
 		// Just finished running gp.
 		gp->m = nil;
-		sched.mcpu--;
+		runtime·sched.mcpu--;
 
-		if(sched.mcpu < 0)
-			throw("sched.mcpu < 0 in scheduler");
+		if(runtime·sched.mcpu < 0)
+			runtime·throw("runtime·sched.mcpu < 0 in scheduler");
 		switch(gp->status){
 		case Grunnable:
 		case Gdead:
 			// Shouldn't have been running!
-			throw("bad gp->status in sched");
+			runtime·throw("bad gp->status in sched");
 		case Grunning:
 			gp->status = Grunnable;
 			gput(gp);
@@ -512,8 +512,8 @@
 			}
 			unwindstack(gp, nil);
 			gfput(gp);
-			if(--sched.gcount == 0)
-				exit(0);
+			if(--runtime·sched.gcount == 0)
+				runtime·exit(0);
 			break;
 		}
 		if(gp->readyonstop){
@@ -522,16 +522,16 @@
 		}
 	}
 
-	// Find (or wait for) g to run.  Unlocks sched.
+	// Find (or wait for) g to run.  Unlocks runtime·sched.
 	gp = nextgandunlock();
 	gp->readyonstop = 0;
 	gp->status = Grunning;
 	m->curg = gp;
 	gp->m = m;
-	if(gp->sched.pc == (byte*)goexit) {	// kickoff
-		gogocall(&gp->sched, (void(*)(void))gp->entry);
+	if(gp->sched.pc == (byte*)runtime·goexit) {	// kickoff
+		runtime·gogocall(&gp->sched, (void(*)(void))gp->entry);
 	}
-	gogo(&gp->sched, 1);
+	runtime·gogo(&gp->sched, 1);
 }
 
 // Enter scheduler.  If g->status is Grunning,
@@ -539,45 +539,45 @@
 // before running g again.  If g->status is Gmoribund,
 // kills off g.
 void
-gosched(void)
+runtime·gosched(void)
 {
 	if(m->locks != 0)
-		throw("gosched holding locks");
+		runtime·throw("gosched holding locks");
 	if(g == m->g0)
-		throw("gosched of g0");
-	if(gosave(&g->sched) == 0)
-		gogo(&m->sched, 1);
+		runtime·throw("gosched of g0");
+	if(runtime·gosave(&g->sched) == 0)
+		runtime·gogo(&m->sched, 1);
 }
 
 // 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,
 // not from the low-level system calls used by the runtime.
-// Entersyscall cannot split the stack: the gosave must
+// Entersyscall cannot split the stack: the runtime·gosave must
 // make g->sched refer to the caller's stack pointer.
 #pragma textflag 7
 void
-·entersyscall(void)
+runtime·entersyscall(void)
 {
-	lock(&sched);
+	runtime·lock(&runtime·sched);
 	// Leave SP around for gc and traceback.
 	// Do before notewakeup so that gc
 	// never sees Gsyscall with wrong stack.
-	gosave(&g->sched);
-	if(sched.predawn) {
-		unlock(&sched);
+	runtime·gosave(&g->sched);
+	if(runtime·sched.predawn) {
+		runtime·unlock(&runtime·sched);
 		return;
 	}
 	g->status = Gsyscall;
-	sched.mcpu--;
-	sched.msyscall++;
-	if(sched.gwait != 0)
+	runtime·sched.mcpu--;
+	runtime·sched.msyscall++;
+	if(runtime·sched.gwait != 0)
 		matchmg();
-	if(sched.waitstop && sched.mcpu <= sched.mcpumax) {
-		sched.waitstop = 0;
-		notewakeup(&sched.stopped);
+	if(runtime·sched.waitstop && runtime·sched.mcpu <= runtime·sched.mcpumax) {
+		runtime·sched.waitstop = 0;
+		runtime·notewakeup(&runtime·sched.stopped);
 	}
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 }
 
 // The goroutine g exited its system call.
@@ -585,19 +585,19 @@
 // This is called only from the go syscall library, not
 // from the low-level system calls used by the runtime.
 void
-·exitsyscall(void)
+runtime·exitsyscall(void)
 {
-	lock(&sched);
-	if(sched.predawn) {
-		unlock(&sched);
+	runtime·lock(&runtime·sched);
+	if(runtime·sched.predawn) {
+		runtime·unlock(&runtime·sched);
 		return;
 	}
-	sched.msyscall--;
-	sched.mcpu++;
+	runtime·sched.msyscall--;
+	runtime·sched.mcpu++;
 	// Fast path - if there's room for this m, we're done.
-	if(sched.mcpu <= sched.mcpumax) {
+	if(runtime·sched.mcpu <= runtime·sched.mcpumax) {
 		g->status = Grunning;
-		unlock(&sched);
+		runtime·unlock(&runtime·sched);
 		return;
 	}
 	// Tell scheduler to put g back on the run queue:
@@ -605,35 +605,35 @@
 	// but keeps the garbage collector from thinking
 	// that g is running right now, which it's not.
 	g->readyonstop = 1;
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 
 	// Slow path - all the cpus are taken.
 	// The scheduler will ready g and put this m to sleep.
 	// When the scheduler takes g away from m,
-	// it will undo the sched.mcpu++ above.
-	gosched();
+	// it will undo the runtime·sched.mcpu++ above.
+	runtime·gosched();
 }
 
 // Start scheduling g1 again for a cgo callback.
 void
-startcgocallback(G* g1)
+runtime·startcgocallback(G* g1)
 {
-	lock(&sched);
+	runtime·lock(&runtime·sched);
 	g1->status = Grunning;
-	sched.msyscall--;
-	sched.mcpu++;
-	unlock(&sched);
+	runtime·sched.msyscall--;
+	runtime·sched.mcpu++;
+	runtime·unlock(&runtime·sched);
 }
 
 // Stop scheduling g1 after a cgo callback.
 void
-endcgocallback(G* g1)
+runtime·endcgocallback(G* g1)
 {
-	lock(&sched);
+	runtime·lock(&runtime·sched);
 	g1->status = Gsyscall;
-	sched.mcpu--;
-	sched.msyscall++;
-	unlock(&sched);
+	runtime·sched.mcpu--;
+	runtime·sched.msyscall++;
+	runtime·unlock(&runtime·sched);
 }
 
 /*
@@ -706,7 +706,7 @@
 };
 
 void
-oldstack(void)
+runtime·oldstack(void)
 {
 	Stktop *top, old;
 	uint32 args;
@@ -723,20 +723,20 @@
 	args = old.args;
 	if(args > 0) {
 		sp -= args;
-		mcpy(top->fp, sp, args);
+		runtime·mcpy(top->fp, sp, args);
 	}
 	goid = old.gobuf.g->goid;	// fault if g is bad, before gogo
 
 	if(old.free)
-		stackfree(g1->stackguard - StackGuard);
+		runtime·stackfree(g1->stackguard - StackGuard);
 	g1->stackbase = old.stackbase;
 	g1->stackguard = old.stackguard;
 
-	gogo(&old.gobuf, m->cret);
+	runtime·gogo(&old.gobuf, m->cret);
 }
 
 void
-newstack(void)
+runtime·newstack(void)
 {
 	int32 frame, args;
 	Stktop *top;
@@ -750,7 +750,7 @@
 	g1 = m->curg;
 
 	if(m->morebuf.sp < g1->stackguard - StackGuard)
-		throw("split stack overflow");
+		runtime·throw("split stack overflow");
 
 	if(frame == 1 && args > 0 && m->morebuf.sp - sizeof(Stktop) - args - 32 > g1->stackguard) {
 		// special case: called from reflect.call (frame == 1)
@@ -769,7 +769,7 @@
 		if(frame < StackBig)
 			frame = StackBig;
 		frame += 1024;	// room for more functions, Stktop.
-		stk = stackalloc(frame);
+		stk = runtime·stackalloc(frame);
 		top = (Stktop*)(stk+frame-sizeof(*top));
 		free = true;
 	}
@@ -794,32 +794,32 @@
 	sp = (byte*)top;
 	if(args > 0) {
 		sp -= args;
-		mcpy(sp, m->morefp, args);
+		runtime·mcpy(sp, m->morefp, args);
 	}
 
 	// Continue as if lessstack had just called m->morepc
 	// (the PC that decided to grow the stack).
 	label.sp = sp;
-	label.pc = (byte*)·lessstack;
+	label.pc = (byte*)runtime·lessstack;
 	label.g = m->curg;
-	gogocall(&label, m->morepc);
+	runtime·gogocall(&label, m->morepc);
 
 	*(int32*)345 = 123;	// never return
 }
 
 G*
-malg(int32 stacksize)
+runtime·malg(int32 stacksize)
 {
 	G *g;
 	byte *stk;
 
-	g = malloc(sizeof(G));
+	g = runtime·malloc(sizeof(G));
 	if(stacksize >= 0) {
-		stk = stackalloc(stacksize + StackGuard);
+		stk = runtime·stackalloc(stacksize + StackGuard);
 		g->stack0 = stk;
 		g->stackguard = stk + StackGuard;
 		g->stackbase = stk + StackGuard + stacksize - sizeof(Stktop);
-		runtime_memclr(g->stackbase, sizeof(Stktop));
+		runtime·memclr(g->stackbase, sizeof(Stktop));
 	}
 	return g;
 }
@@ -835,13 +835,13 @@
  */
 #pragma textflag 7
 void
-·newproc(int32 siz, byte* fn, ...)
+runtime·newproc(int32 siz, byte* fn, ...)
 {
-	newproc1(fn, (byte*)(&fn+1), siz, 0);
+	runtime·newproc1(fn, (byte*)(&fn+1), siz, 0);
 }
 
 G*
-newproc1(byte *fn, byte *argp, int32 narg, int32 nret)
+runtime·newproc1(byte *fn, byte *argp, int32 narg, int32 nret)
 {
 	byte *sp;
 	G *newg;
@@ -851,36 +851,36 @@
 	siz = narg + nret;
 	siz = (siz+7) & ~7;
 	if(siz > 1024)
-		throw("runtime.newproc: too many args");
+		runtime·throw("runtime.newproc: too many args");
 
-	lock(&sched);
+	runtime·lock(&runtime·sched);
 
 	if((newg = gfget()) != nil){
 		newg->status = Gwaiting;
 		if(newg->stackguard - StackGuard != newg->stack0)
-			throw("invalid stack in newg");
+			runtime·throw("invalid stack in newg");
 	} else {
-		newg = malg(4096);
+		newg = runtime·malg(4096);
 		newg->status = Gwaiting;
-		newg->alllink = allg;
-		allg = newg;
+		newg->alllink = runtime·allg;
+		runtime·allg = newg;
 	}
 
 	sp = newg->stackbase;
 	sp -= siz;
-	mcpy(sp, argp, narg);
+	runtime·mcpy(sp, argp, narg);
 
 	newg->sched.sp = sp;
-	newg->sched.pc = (byte*)goexit;
+	newg->sched.pc = (byte*)runtime·goexit;
 	newg->sched.g = newg;
 	newg->entry = fn;
 
-	sched.gcount++;
-	goidgen++;
-	newg->goid = goidgen;
+	runtime·sched.gcount++;
+	runtime·goidgen++;
+	newg->goid = runtime·goidgen;
 
 	newprocreadylocked(newg);
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 
 	return newg;
 //printf(" goid=%d\n", newg->goid);
@@ -888,16 +888,16 @@
 
 #pragma textflag 7
 uintptr
-·deferproc(int32 siz, byte* fn, ...)
+runtime·deferproc(int32 siz, byte* fn, ...)
 {
 	Defer *d;
 
-	d = malloc(sizeof(*d) + siz - sizeof(d->args));
+	d = runtime·malloc(sizeof(*d) + siz - sizeof(d->args));
 	d->fn = fn;
 	d->sp = (byte*)(&fn+1);
 	d->siz = siz;
-	d->pc = ·getcallerpc(&siz);
-	mcpy(d->args, d->sp, d->siz);
+	d->pc = runtime·getcallerpc(&siz);
+	runtime·mcpy(d->args, d->sp, d->siz);
 
 	d->link = g->defer;
 	g->defer = d;
@@ -913,7 +913,7 @@
 
 #pragma textflag 7
 void
-·deferreturn(uintptr arg0)
+runtime·deferreturn(uintptr arg0)
 {
 	Defer *d;
 	byte *sp, *fn;
@@ -921,14 +921,14 @@
 	d = g->defer;
 	if(d == nil)
 		return;
-	sp = getcallersp(&arg0);
+	sp = runtime·getcallersp(&arg0);
 	if(d->sp != sp)
 		return;
-	mcpy(d->sp, d->args, d->siz);
+	runtime·mcpy(d->sp, d->args, d->siz);
 	g->defer = d->link;
 	fn = d->fn;
-	free(d);
-	jmpdefer(fn, sp);
+	runtime·free(d);
+	runtime·jmpdefer(fn, sp);
 }
 
 static void
@@ -939,7 +939,7 @@
 	while((d = g->defer) != nil) {
 		g->defer = d->link;
 		reflect·call(d->fn, d->args, d->siz);
-		free(d);
+		runtime·free(d);
 	}
 }
 
@@ -953,7 +953,7 @@
 	
 	// Must be called from a different goroutine, usually m->g0.
 	if(g == gp)
-		throw("unwindstack on self");
+		runtime·throw("unwindstack on self");
 
 	while((top = (Stktop*)gp->stackbase) != nil && top->stackbase != nil) {
 		stk = gp->stackguard - StackGuard;
@@ -962,12 +962,12 @@
 		gp->stackbase = top->stackbase;
 		gp->stackguard = top->stackguard;
 		if(top->free)
-			stackfree(stk);
+			runtime·stackfree(stk);
 	}
 
 	if(sp != nil && (sp < gp->stackguard - StackGuard || gp->stackbase < sp)) {
-		printf("recover: %p not in [%p, %p]\n", sp, gp->stackguard - StackGuard, gp->stackbase);
-		throw("bad unwindstack");
+		runtime·printf("recover: %p not in [%p, %p]\n", sp, gp->stackguard - StackGuard, gp->stackbase);
+		runtime·throw("bad unwindstack");
 	}
 }
 
@@ -976,22 +976,22 @@
 {
 	if(p->link) {
 		printpanics(p->link);
-		printf("\t");
+		runtime·printf("\t");
 	}
-	printf("panic: ");
-	·printany(p->arg);
+	runtime·printf("panic: ");
+	runtime·printany(p->arg);
 	if(p->recovered)
-		printf(" [recovered]");
-	printf("\n");
+		runtime·printf(" [recovered]");
+	runtime·printf("\n");
 }
 	
 void
-·panic(Eface e)
+runtime·panic(Eface e)
 {
 	Defer *d;
 	Panic *p;
 
-	p = mal(sizeof *p);
+	p = runtime·mal(sizeof *p);
 	p->arg = e;
 	p->link = g->panic;
 	p->stackbase = g->stackbase;
@@ -1010,32 +1010,32 @@
 			reflect·call(d->fn, d->args, d->siz);
 		if(p->recovered) {
 			g->panic = p->link;
-			free(p);
+			runtime·free(p);
 			// put recovering defer back on list
 			// for scheduler to find.
 			d->link = g->defer;
 			g->defer = d;
 			g->status = Grecovery;
-			gosched();
-			throw("recovery failed"); // gosched should not return
+			runtime·gosched();
+			runtime·throw("recovery failed"); // gosched should not return
 		}
-		free(d);
+		runtime·free(d);
 	}
 
 	// ran out of deferred calls - old-school panic now
-	fd = 2;
+	runtime·fd = 2;
 	printpanics(g->panic);
-	panic(0);
+	runtime·dopanic(0);
 }
 
 #pragma textflag 7	/* no split, or else g->stackguard is not the stack for fp */
 void
-·recover(byte *fp, Eface ret)
+runtime·recover(byte *fp, Eface ret)
 {
 	Stktop *top, *oldtop;
 	Panic *p;
 
-	fp = getcallersp(fp);
+	fp = runtime·getcallersp(fp);
 
 	// Must be a panic going on.
 	if((p = g->panic) == nil || p->recovered)
@@ -1106,9 +1106,9 @@
 gfput(G *g)
 {
 	if(g->stackguard - StackGuard != g->stack0)
-		throw("invalid stack in gfput");
-	g->schedlink = sched.gfree;
-	sched.gfree = g;
+		runtime·throw("invalid stack in gfput");
+	g->schedlink = runtime·sched.gfree;
+	runtime·sched.gfree = g;
 }
 
 // Get from gfree list.  Sched must be locked.
@@ -1117,69 +1117,69 @@
 {
 	G *g;
 
-	g = sched.gfree;
+	g = runtime·sched.gfree;
 	if(g)
-		sched.gfree = g->schedlink;
+		runtime·sched.gfree = g->schedlink;
 	return g;
 }
 
 void
-·Breakpoint(void)
+runtime·Breakpoint(void)
 {
-	breakpoint();
+	runtime·breakpoint();
 }
 
 void
-·Goexit(void)
+runtime·Goexit(void)
 {
 	rundefer();
-	goexit();
+	runtime·goexit();
 }
 
 void
-·Gosched(void)
+runtime·Gosched(void)
 {
-	gosched();
+	runtime·gosched();
 }
 
 void
-·LockOSThread(void)
+runtime·LockOSThread(void)
 {
-	if(sched.predawn)
-		throw("cannot wire during init");
+	if(runtime·sched.predawn)
+		runtime·throw("cannot wire during init");
 	m->lockedg = g;
 	g->lockedm = m;
 }
 
 // delete when scheduler is stronger
 int32
-gomaxprocsfunc(int32 n)
+runtime·gomaxprocsfunc(int32 n)
 {
 	int32 ret;
 
-	lock(&sched);
-	ret = sched.gomaxprocs;
+	runtime·lock(&runtime·sched);
+	ret = runtime·sched.gomaxprocs;
 	if (n <= 0)
 		n = ret;
-	sched.gomaxprocs = n;
-	sched.mcpumax = n;
+	runtime·sched.gomaxprocs = n;
+	runtime·sched.mcpumax = n;
 	// handle fewer procs?
-	if(sched.mcpu > sched.mcpumax) {
-		unlock(&sched);
+	if(runtime·sched.mcpu > runtime·sched.mcpumax) {
+		runtime·unlock(&runtime·sched);
 		// just give up the cpu.
 		// we'll only get rescheduled once the
 		// number has come down.
-		gosched();
+		runtime·gosched();
 		return ret;
 	}
 	// handle more procs
 	matchmg();
-	unlock(&sched);
+	runtime·unlock(&runtime·sched);
 	return ret;
 }
 
 void
-·UnlockOSThread(void)
+runtime·UnlockOSThread(void)
 {
 	m->lockedg = nil;
 	g->lockedm = nil;
@@ -1187,7 +1187,7 @@
 
 // for testing of wire, unwire
 void
-·mid(uint32 ret)
+runtime·mid(uint32 ret)
 {
 	ret = m->id;
 	FLUSH(&ret);
diff --git a/src/pkg/runtime/reflect.goc b/src/pkg/runtime/reflect.goc
index 51222f1..a2e3c6e 100644
--- a/src/pkg/runtime/reflect.goc
+++ b/src/pkg/runtime/reflect.goc
@@ -24,11 +24,11 @@
  */
 
 func mapaccess(map *byte, key *byte, val *byte) (pres bool) {
-	mapaccess((Hmap*)map, key, val, &pres);
+	runtime·mapaccess((Hmap*)map, key, val, &pres);
 }
 
 func mapassign(map *byte, key *byte, val *byte) {
-	mapassign((Hmap*)map, key, val);
+	runtime·mapassign((Hmap*)map, key, val);
 }
 
 func maplen(map *byte) (len int32) {
@@ -37,22 +37,22 @@
 }
 
 func mapiterinit(map *byte) (it *byte) {
-	it = (byte*)mapiterinit((Hmap*)map);
+	it = (byte*)runtime·newmapiterinit((Hmap*)map);
 }
 
 func mapiternext(it *byte) {
-	mapiternext((struct hash_iter*)it);
+	runtime·mapiternext((struct hash_iter*)it);
 }
 
 func mapiterkey(it *byte, key *byte) (ok bool) {
-	ok = mapiterkey((struct hash_iter*)it, key);
+	ok = runtime·mapiterkey((struct hash_iter*)it, key);
 }
 
 func makemap(typ *byte) (map *byte) {
 	MapType *t;
 
 	t = (MapType*)gettype(typ);
-	map = (byte*)makemap(t->key, t->elem, 0);
+	map = (byte*)runtime·makemap_c(t->key, t->elem, 0);
 }
 
 /*
@@ -67,31 +67,31 @@
 	// in front of the raw ChanType.  the -2 below backs up
 	// to the interface value header.
 	t = (ChanType*)gettype(typ);
-	ch = (byte*)makechan(t->elem, size);
+	ch = (byte*)runtime·makechan_c(t->elem, size);
 }
 
 func chansend(ch *byte, val *byte, pres *bool) {
-	chansend((Hchan*)ch, val, pres);
+	runtime·chansend((Hchan*)ch, val, pres);
 }
 
 func chanrecv(ch *byte, val *byte, pres *bool) {
-	chanrecv((Hchan*)ch, val, pres);
+	runtime·chanrecv((Hchan*)ch, val, pres);
 }
 
 func chanclose(ch *byte) {
-	chanclose((Hchan*)ch);
+	runtime·chanclose((Hchan*)ch);
 }
 
 func chanclosed(ch *byte) (r bool) {
-	r = chanclosed((Hchan*)ch);
+	r = runtime·chanclosed((Hchan*)ch);
 }
 
 func chanlen(ch *byte) (r int32) {
-	r = chanlen((Hchan*)ch);
+	r = runtime·chanlen((Hchan*)ch);
 }
 
 func chancap(ch *byte) (r int32) {
-	r = chancap((Hchan*)ch);
+	r = runtime·chancap((Hchan*)ch);
 }
 
 
@@ -114,5 +114,5 @@
 		((Iface*)ret)->data = nil;
 		return;
 	}
-	ifaceE2I((InterfaceType*)gettype(typ), *(Eface*)x, (Iface*)ret);
+	runtime·ifaceE2I((InterfaceType*)gettype(typ), *(Eface*)x, (Iface*)ret);
 }
diff --git a/src/pkg/runtime/rune.c b/src/pkg/runtime/rune.c
index 598edc6..86ee76d 100644
--- a/src/pkg/runtime/rune.c
+++ b/src/pkg/runtime/rune.c
@@ -39,8 +39,7 @@
 	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
 	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
 	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
-	Rune4	= (1<<(Bit4+3*Bitx))-1,
-                                        /* 0001 1111 1111 1111 1111 1111 */
+	Rune4	= (1<<(Bit4+3*Bitx))-1,		/* 0001 1111 1111 1111 1111 1111 */
 
 	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
 	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
@@ -72,7 +71,7 @@
  * reasons, we return 1 instead of 0.
  */
 int32
-charntorune(int32 *rune, uint8 *str, int32 length)
+runtime·charntorune(int32 *rune, uint8 *str, int32 length)
 {
 	int32 c, c1, c2, c3, l;
 
@@ -168,7 +167,7 @@
 }
 
 int32
-runetochar(byte *str, int32 rune)  /* note: in original, arg2 was pointer */
+runtime·runetochar(byte *str, int32 rune)  /* note: in original, arg2 was pointer */
 {
 	/* Runes are signed, so convert to unsigned for range check. */
 	uint32 c;
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 9b874ce..0b19e10 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -4,87 +4,90 @@
 
 #include "runtime.h"
 
-int32	panicking	= 0;
-int32	maxround	= sizeof(uintptr);
-int32	fd		= 1;
+enum {
+	maxround = sizeof(uintptr),
+};
+
+int32	runtime·panicking	= 0;
+int32	runtime·fd		= 1;
 
 int32
-gotraceback(void)
+runtime·gotraceback(void)
 {
 	byte *p;
 
-	p = getenv("GOTRACEBACK");
+	p = runtime·getenv("GOTRACEBACK");
 	if(p == nil || p[0] == '\0')
 		return 1;	// default is on
-	return atoi(p);
+	return runtime·atoi(p);
 }
 
 void
-panic(int32 unused)
+runtime·dopanic(int32 unused)
 {
-	fd = 2;
-	if(panicking) {
-		printf("double panic\n");
-		exit(3);
+	runtime·fd = 2;
+	if(runtime·panicking) {
+		runtime·printf("double panic\n");
+		runtime·exit(3);
 	}
-	panicking++;
+	runtime·panicking++;
 
-	printf("\npanic PC=%X\n", (uint64)(uintptr)&unused);
-	if(gotraceback()){
-		traceback(·getcallerpc(&unused), getcallersp(&unused), 0, g);
-		tracebackothers(g);
+	runtime·printf("\npanic PC=%X\n", (uint64)(uintptr)&unused);
+	if(runtime·gotraceback()){
+		runtime·traceback(runtime·getcallerpc(&unused), runtime·getcallersp(&unused), 0, g);
+		runtime·tracebackothers(g);
 	}
-	breakpoint();  // so we can grab it in a debugger
-	exit(2);
+	runtime·breakpoint();  // so we can grab it in a debugger
+	runtime·exit(2);
 }
 
 void
-·panicindex(void)
+runtime·panicindex(void)
 {
-	panicstring("index out of range");
+	runtime·panicstring("index out of range");
 }
 
 void
-·panicslice(void)
+runtime·panicslice(void)
 {
-	panicstring("slice bounds out of range");
+	runtime·panicstring("slice bounds out of range");
 }
 
 void
-·throwreturn(void)
+runtime·throwreturn(void)
 {
 	// can only happen if compiler is broken
-	throw("no return at end of a typed function - compiler is broken");
+	runtime·throw("no return at end of a typed function - compiler is broken");
 }
 
 void
-·throwinit(void)
+runtime·throwinit(void)
 {
 	// can only happen with linker skew
-	throw("recursive call during initialization - linker skew");
+	runtime·throw("recursive call during initialization - linker skew");
 }
 
 void
-throw(int8 *s)
+runtime·throw(int8 *s)
 {
-	fd = 2;
-	printf("throw: %s\n", s);
-	panic(-1);
+	runtime·fd = 2;
+	runtime·printf("throw: %s\n", s);
+	runtime·dopanic(0);
 	*(int32*)0 = 0;	// not reached
-	exit(1);	// even more not reached
+	runtime·exit(1);	// even more not reached
 }
 
 void
-panicstring(int8 *s)
+runtime·panicstring(int8 *s)
 {
 	Eface err;
 	
-	·newErrorString(gostringnocopy((byte*)s), &err);
-	·panic(err);
+	runtime·newErrorString(runtime·gostringnocopy((byte*)s), &err);
+	runtime·panic(err);
 }
 
 void
-mcpy(byte *t, byte *f, uint32 n)
+runtime·mcpy(byte *t, byte *f, uint32 n)
 {
 	while(n > 0) {
 		*t = *f;
@@ -95,7 +98,7 @@
 }
 
 int32
-mcmp(byte *s1, byte *s2, uint32 n)
+runtime·mcmp(byte *s1, byte *s2, uint32 n)
 {
 	uint32 i;
 	byte c1, c2;
@@ -113,7 +116,7 @@
 
 
 byte*
-mchr(byte *p, byte c, byte *ep)
+runtime·mchr(byte *p, byte c, byte *ep)
 {
 	for(; p < ep; p++)
 		if(*p == c)
@@ -122,7 +125,7 @@
 }
 
 uint32
-rnd(uint32 n, uint32 m)
+runtime·rnd(uint32 n, uint32 m)
 {
 	uint32 r;
 
@@ -141,38 +144,38 @@
 Slice os·Envs;
 
 void
-args(int32 c, uint8 **v)
+runtime·args(int32 c, uint8 **v)
 {
 	argc = c;
 	argv = v;
 }
 
-int32 isplan9;
+int32 runtime·isplan9;
 
 void
-goargs(void)
+runtime·goargs(void)
 {
 	String *gargv;
 	String *genvv;
 	int32 i, envc;
 	
-	if(isplan9)
+	if(runtime·isplan9)
 		envc=0;
 	else
 		for(envc=0; argv[argc+1+envc] != 0; envc++)
 			;
 
-	gargv = malloc(argc*sizeof gargv[0]);
-	genvv = malloc(envc*sizeof genvv[0]);
+	gargv = runtime·malloc(argc*sizeof gargv[0]);
+	genvv = runtime·malloc(envc*sizeof genvv[0]);
 
 	for(i=0; i<argc; i++)
-		gargv[i] = gostringnocopy(argv[i]);
+		gargv[i] = runtime·gostringnocopy(argv[i]);
 	os·Args.array = (byte*)gargv;
 	os·Args.len = argc;
 	os·Args.cap = argc;
 
 	for(i=0; i<envc; i++)
-		genvv[i] = gostringnocopy(argv[argc+1+i]);
+		genvv[i] = runtime·gostringnocopy(argv[argc+1+i]);
 	os·Envs.array = (byte*)genvv;
 	os·Envs.len = envc;
 	os·Envs.cap = envc;
@@ -180,20 +183,20 @@
 
 // Atomic add and return new value.
 uint32
-xadd(uint32 volatile *val, int32 delta)
+runtime·xadd(uint32 volatile *val, int32 delta)
 {
 	uint32 oval, nval;
 
 	for(;;){
 		oval = *val;
 		nval = oval + delta;
-		if(cas(val, oval, nval))
+		if(runtime·cas(val, oval, nval))
 			return nval;
 	}
 }
 
 byte*
-getenv(int8 *s)
+runtime·getenv(int8 *s)
 {
 	int32 i, j, len;
 	byte *v, *bs;
@@ -201,7 +204,7 @@
 	int32 envc;
 
 	bs = (byte*)s;
-	len = findnull(bs);
+	len = runtime·findnull(bs);
 	envv = (String*)os·Envs.array;
 	envc = os·Envs.len;
 	for(i=0; i<envc; i++){
@@ -220,17 +223,17 @@
 }
 
 void
-·getgoroot(String out)
+runtime·getgoroot(String out)
 {
 	byte *p;
 
-	p = getenv("GOROOT");
-	out = gostringnocopy(p);
+	p = runtime·getenv("GOROOT");
+	out = runtime·gostringnocopy(p);
 	FLUSH(&out);
 }
 
 int32
-atoi(byte *p)
+runtime·atoi(byte *p)
 {
 	int32 n;
 
@@ -241,7 +244,7 @@
 }
 
 void
-check(void)
+runtime·check(void)
 {
 	int8 a;
 	uint8 b;
@@ -256,34 +259,34 @@
 	void* k;
 	uint16* l;
 
-	if(sizeof(a) != 1) throw("bad a");
-	if(sizeof(b) != 1) throw("bad b");
-	if(sizeof(c) != 2) throw("bad c");
-	if(sizeof(d) != 2) throw("bad d");
-	if(sizeof(e) != 4) throw("bad e");
-	if(sizeof(f) != 4) throw("bad f");
-	if(sizeof(g) != 8) throw("bad g");
-	if(sizeof(h) != 8) throw("bad h");
-	if(sizeof(i) != 4) throw("bad i");
-	if(sizeof(j) != 8) throw("bad j");
-	if(sizeof(k) != sizeof(uintptr)) throw("bad k");
-	if(sizeof(l) != sizeof(uintptr)) throw("bad l");
+	if(sizeof(a) != 1) runtime·throw("bad a");
+	if(sizeof(b) != 1) runtime·throw("bad b");
+	if(sizeof(c) != 2) runtime·throw("bad c");
+	if(sizeof(d) != 2) runtime·throw("bad d");
+	if(sizeof(e) != 4) runtime·throw("bad e");
+	if(sizeof(f) != 4) runtime·throw("bad f");
+	if(sizeof(g) != 8) runtime·throw("bad g");
+	if(sizeof(h) != 8) runtime·throw("bad h");
+	if(sizeof(i) != 4) runtime·throw("bad i");
+	if(sizeof(j) != 8) runtime·throw("bad j");
+	if(sizeof(k) != sizeof(uintptr)) runtime·throw("bad k");
+	if(sizeof(l) != sizeof(uintptr)) runtime·throw("bad l");
 //	prints(1"check ok\n");
 
 	uint32 z;
 	z = 1;
-	if(!cas(&z, 1, 2))
-		throw("cas1");
+	if(!runtime·cas(&z, 1, 2))
+		runtime·throw("cas1");
 	if(z != 2)
-		throw("cas2");
+		runtime·throw("cas2");
 
 	z = 4;
-	if(cas(&z, 5, 6))
-		throw("cas3");
+	if(runtime·cas(&z, 5, 6))
+		runtime·throw("cas3");
 	if(z != 4)
-		throw("cas4");
+		runtime·throw("cas4");
 
-	initsig(0);
+	runtime·initsig(0);
 }
 
 /*
@@ -316,7 +319,6 @@
 memequal(uint32 s, void *a, void *b)
 {
 	byte *ba, *bb, *aend;
-	uint32 i;
 
 	ba = a;
 	bb = b;
@@ -350,7 +352,7 @@
 		v = *(uint64*)a;
 		break;
 	}
-	·printint(v);
+	runtime·printint(v);
 }
 
 static void
@@ -411,112 +413,105 @@
 strprint(uint32 s, String *a)
 {
 	USED(s);
-	·printstring(*a);
+	runtime·printstring(*a);
 }
 
 static uintptr
 interhash(uint32 s, Iface *a)
 {
 	USED(s);
-	return ifacehash(*a);
+	return runtime·ifacehash(*a);
 }
 
 static void
 interprint(uint32 s, Iface *a)
 {
 	USED(s);
-	·printiface(*a);
+	runtime·printiface(*a);
 }
 
 static uint32
 interequal(uint32 s, Iface *a, Iface *b)
 {
 	USED(s);
-	return ifaceeq(*a, *b);
+	return runtime·ifaceeq_c(*a, *b);
 }
 
 static uintptr
 nilinterhash(uint32 s, Eface *a)
 {
 	USED(s);
-	return efacehash(*a);
+	return runtime·efacehash(*a);
 }
 
 static void
 nilinterprint(uint32 s, Eface *a)
 {
 	USED(s);
-	·printeface(*a);
+	runtime·printeface(*a);
 }
 
 static uint32
 nilinterequal(uint32 s, Eface *a, Eface *b)
 {
 	USED(s);
-	return efaceeq(*a, *b);
+	return runtime·efaceeq_c(*a, *b);
 }
 
 uintptr
-nohash(uint32 s, void *a)
+runtime·nohash(uint32 s, void *a)
 {
 	USED(s);
 	USED(a);
-	panicstring("hash of unhashable type");
+	runtime·panicstring("hash of unhashable type");
 	return 0;
 }
 
 uint32
-noequal(uint32 s, void *a, void *b)
+runtime·noequal(uint32 s, void *a, void *b)
 {
 	USED(s);
 	USED(a);
 	USED(b);
-	panicstring("comparing uncomparable types");
+	runtime·panicstring("comparing uncomparable types");
 	return 0;
 }
 
 Alg
-algarray[] =
+runtime·algarray[] =
 {
 [AMEM]	{ memhash, memequal, memprint, memcopy },
-[ANOEQ]	{ nohash, noequal, memprint, memcopy },
+[ANOEQ]	{ runtime·nohash, runtime·noequal, memprint, memcopy },
 [ASTRING]	{ strhash, strequal, strprint, memcopy },
 [AINTER]		{ interhash, interequal, interprint, memcopy },
 [ANILINTER]	{ nilinterhash, nilinterequal, nilinterprint, memcopy },
 [AMEMWORD] { memhash, memwordequal, memprint, memwordcopy },
 };
 
-#pragma textflag 7
-void
-FLUSH(void *v)
-{
-	USED(v);
-}
-
 int64
-nanotime(void)
+runtime·nanotime(void)
 {
 	int64 sec;
 	int32 usec;
 
 	sec = 0;
 	usec = 0;
-	gettime(&sec, &usec);
+	runtime·gettime(&sec, &usec);
 	return sec*1000000000 + (int64)usec*1000;
 }
 
 void
-·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool retbool)
+runtime·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool retbool)
 {
 	Func *f;
 
-	if(callers(1+skip, &retpc, 1) == 0 || (f = findfunc(retpc-1)) == nil) {
-		retfile = emptystring;
+	if(runtime·callers(1+skip, &retpc, 1) == 0 || (f = runtime·findfunc(retpc-1)) == nil) {
+		retfile = runtime·emptystring;
 		retline = 0;
 		retbool = false;
 	} else {
 		retfile = f->src;
-		retline = funcline(f, retpc-1);
+		retline = runtime·funcline(f, retpc-1);
 		retbool = true;
 	}
 	FLUSH(&retfile);
@@ -525,15 +520,15 @@
 }
 
 void
-·Callers(int32 skip, Slice pc, int32 retn)
+runtime·Callers(int32 skip, Slice pc, int32 retn)
 {
-	retn = callers(skip, (uintptr*)pc.array, pc.len);
+	retn = runtime·callers(skip, (uintptr*)pc.array, pc.len);
 	FLUSH(&retn);
 }
 
 void
-·FuncForPC(uintptr pc, void *retf)
+runtime·FuncForPC(uintptr pc, void *retf)
 {
-	retf = findfunc(pc);
+	retf = runtime·findfunc(pc);
 	FLUSH(&retf);
 }
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 0a36d27..3f6fb77 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -351,112 +351,108 @@
 /*
  * external data
  */
-extern	Alg	algarray[Amax];
-extern	String	emptystring;
-G*	allg;
-M*	allm;
-int32	goidgen;
-extern	int32	gomaxprocs;
-extern	int32	panicking;
-extern	int32	maxround;
-extern	int32	fd;	// usually 1; set to 2 when panicking
-extern	int32	gcwaiting;		// gc is waiting to run
-int8*	goos;
+extern	Alg	runtime·algarray[Amax];
+extern	String	runtime·emptystring;
+G*	runtime·allg;
+M*	runtime·allm;
+int32	runtime·goidgen;
+extern	int32	runtime·gomaxprocs;
+extern	int32	runtime·panicking;
+extern	int32	runtime·fd;	// usually 1; set to 2 when panicking
+extern	int32	runtime·gcwaiting;		// gc is waiting to run
+int8*	runtime·goos;
 
 /*
  * common functions and data
  */
-int32	strcmp(byte*, byte*);
-int32	findnull(byte*);
-int32	findnullw(uint16*);
-void	dump(byte*, int32);
-int32	runetochar(byte*, int32);
-int32	charntorune(int32*, uint8*, int32);
+int32	runtime·strcmp(byte*, byte*);
+int32	runtime·findnull(byte*);
+int32	runtime·findnullw(uint16*);
+void	runtime·dump(byte*, int32);
+int32	runtime·runetochar(byte*, int32);
+int32	runtime·charntorune(int32*, uint8*, int32);
 
 /*
  * very low level c-called
  */
-void	gogo(Gobuf*, uintptr);
-void	gogocall(Gobuf*, void(*)(void));
-uintptr	gosave(Gobuf*);
-void	·lessstack(void);
-void	goargs(void);
-void	FLUSH(void*);
-void*	getu(void);
-void	throw(int8*);
-void	panicstring(int8*);
-uint32	rnd(uint32, uint32);
-void	prints(int8*);
-void	printf(int8*, ...);
-byte*	mchr(byte*, byte, byte*);
-void	mcpy(byte*, byte*, uint32);
-int32	mcmp(byte*, byte*, uint32);
-void	memmove(void*, void*, uint32);
-void*	mal(uintptr);
-uint32	cmpstring(String, String);
-String	catstring(String, String);
-String	concatstring(int32, String*);
-String	gostring(byte*);
-String  gostringn(byte*, int32);
-String	gostringnocopy(byte*);
-String	gostringw(uint16*);
-void	initsig(int32);
-int32	gotraceback(void);
-void	traceback(uint8 *pc, uint8 *sp, uint8 *lr, G* gp);
-void	tracebackothers(G*);
-int32	open(byte*, int32, ...);
-int32	write(int32, void*, int32);
-bool	cas(uint32*, uint32, uint32);
-bool	casp(void**, void*, void*);
-uint32	xadd(uint32 volatile*, int32);
-void	jmpdefer(byte*, void*);
-void	exit1(int32);
-void	ready(G*);
-byte*	getenv(int8*);
-int32	atoi(byte*);
-void	newosproc(M *m, G *g, void *stk, void (*fn)(void));
-void	signalstack(byte*, int32);
-G*	malg(int32);
-void	minit(void);
-Func*	findfunc(uintptr);
-int32	funcline(Func*, uint64);
-void*	stackalloc(uint32);
-void	stackfree(void*);
-MCache*	allocmcache(void);
-void	mallocinit(void);
-bool	ifaceeq(Iface, Iface);
-bool	efaceeq(Eface, Eface);
-uintptr	ifacehash(Iface);
-uintptr	efacehash(Eface);
-uintptr	nohash(uint32, void*);
-uint32	noequal(uint32, void*, void*);
-void*	malloc(uintptr size);
-void	free(void *v);
-void	addfinalizer(void*, void(*fn)(void*), int32);
-void	walkfintab(void (*fn)(void*));
-void	runpanic(Panic*);
-void*	getcallersp(void*);
+#define FLUSH(x)	USED(x)
 
-void	exit(int32);
-void	breakpoint(void);
-void	gosched(void);
-void	goexit(void);
-void	runcgo(void (*fn)(void*), void*);
-void	runcgocallback(G*, void*, void (*fn)());
-void	·entersyscall(void);
-void	·exitsyscall(void);
-void	startcgocallback(G*);
-void	endcgocallback(G*);
-G*	newproc1(byte*, byte*, int32, int32);
-void	siginit(void);
-bool	sigsend(int32 sig);
-void	gettime(int64*, int32*);
-int32	callers(int32, uintptr*, int32);
-int64	nanotime(void);
-void	panic(int32);
+void	runtime·gogo(Gobuf*, uintptr);
+void	runtime·gogocall(Gobuf*, void(*)(void));
+uintptr	runtime·gosave(Gobuf*);
+void	runtime·lessstack(void);
+void	runtime·goargs(void);
+void*	runtime·getu(void);
+void	runtime·throw(int8*);
+void	runtime·panicstring(int8*);
+uint32	runtime·rnd(uint32, uint32);
+void	runtime·prints(int8*);
+void	runtime·printf(int8*, ...);
+byte*	runtime·mchr(byte*, byte, byte*);
+void	runtime·mcpy(byte*, byte*, uint32);
+int32	runtime·mcmp(byte*, byte*, uint32);
+void	runtime·memmove(void*, void*, uint32);
+void*	runtime·mal(uintptr);
+String	runtime·catstring(String, String);
+String	runtime·gostring(byte*);
+String  runtime·gostringn(byte*, int32);
+String	runtime·gostringnocopy(byte*);
+String	runtime·gostringw(uint16*);
+void	runtime·initsig(int32);
+int32	runtime·gotraceback(void);
+void	runtime·traceback(uint8 *pc, uint8 *sp, uint8 *lr, G* gp);
+void	runtime·tracebackothers(G*);
+int32	runtime·write(int32, void*, int32);
+bool	runtime·cas(uint32*, uint32, uint32);
+bool	runtime·casp(void**, void*, void*);
+uint32	runtime·xadd(uint32 volatile*, int32);
+void	runtime·jmpdefer(byte*, void*);
+void	runtime·exit1(int32);
+void	runtime·ready(G*);
+byte*	runtime·getenv(int8*);
+int32	runtime·atoi(byte*);
+void	runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void));
+void	runtime·signalstack(byte*, int32);
+G*	runtime·malg(int32);
+void	runtime·minit(void);
+Func*	runtime·findfunc(uintptr);
+int32	runtime·funcline(Func*, uint64);
+void*	runtime·stackalloc(uint32);
+void	runtime·stackfree(void*);
+MCache*	runtime·allocmcache(void);
+void	runtime·mallocinit(void);
+bool	runtime·ifaceeq_c(Iface, Iface);
+bool	runtime·efaceeq_c(Eface, Eface);
+uintptr	runtime·ifacehash(Iface);
+uintptr	runtime·efacehash(Eface);
+uintptr	runtime·nohash(uint32, void*);
+uint32	runtime·noequal(uint32, void*, void*);
+void*	runtime·malloc(uintptr size);
+void	runtime·free(void *v);
+void	runtime·addfinalizer(void*, void(*fn)(void*), int32);
+void	runtime·walkfintab(void (*fn)(void*));
+void	runtime·runpanic(Panic*);
+void*	runtime·getcallersp(void*);
 
-#pragma	varargck	argpos	printf	1
+void	runtime·exit(int32);
+void	runtime·breakpoint(void);
+void	runtime·gosched(void);
+void	runtime·goexit(void);
+void	runtime·runcgo(void (*fn)(void*), void*);
+void	runtime·runcgocallback(G*, void*, void (*fn)());
+void	runtime·entersyscall(void);
+void	runtime·exitsyscall(void);
+void	runtime·startcgocallback(G*);
+void	runtime·endcgocallback(G*);
+G*	runtime·newproc1(byte*, byte*, int32, int32);
+void	runtime·siginit(void);
+bool	runtime·sigsend(int32 sig);
+void	runtime·gettime(int64*, int32*);
+int32	runtime·callers(int32, uintptr*, int32);
+int64	runtime·nanotime(void);
+void	runtime·dopanic(int32);
 
+#pragma	varargck	argpos	runtime·printf	1
 #pragma	varargck	type	"d"	int32
 #pragma	varargck	type	"d"	uint32
 #pragma	varargck	type	"D"	int64
@@ -473,8 +469,8 @@
 
 // TODO(rsc): Remove. These are only temporary,
 // for the mark and sweep collector.
-void	stoptheworld(void);
-void	starttheworld(void);
+void	runtime·stoptheworld(void);
+void	runtime·starttheworld(void);
 
 /*
  * mutual exclusion locks.  in the uncontended case,
@@ -482,9 +478,9 @@
  * but on the contention path they sleep in the kernel.
  * a zeroed Lock is unlocked (no need to initialize each lock).
  */
-void	lock(Lock*);
-void	unlock(Lock*);
-void	destroylock(Lock*);
+void	runtime·lock(Lock*);
+void	runtime·unlock(Lock*);
+void	runtime·destroylock(Lock*);
 
 /*
  * sleep and wakeup on one-time events.
@@ -495,33 +491,9 @@
  * once notewakeup has been called, all the notesleeps
  * will return.  future notesleeps will return immediately.
  */
-void	noteclear(Note*);
-void	notesleep(Note*);
-void	notewakeup(Note*);
-
-/*
- * Redefine methods for the benefit of gcc, which does not support
- * UTF-8 characters in identifiers.
- */
-#ifndef __GNUC__
-#define runtime_memclr ·memclr
-#define runtime_getcallerpc ·getcallerpc
-#define runtime_mmap ·mmap
-#define runtime_munmap ·munmap
-#define runtime_printslice ·printslice
-#define runtime_printbool ·printbool
-#define runtime_printfloat ·printfloat
-#define runtime_printhex ·printhex
-#define runtime_printint ·printint
-#define runtime_printiface ·printiface
-#define runtime_printeface ·printeface
-#define runtime_printpc ·printpc
-#define runtime_printpointer ·printpointer
-#define runtime_printstring ·printstring
-#define runtime_printuint ·printuint
-#define runtime_printcomplex ·printcomplex
-#define runtime_setcallerpc ·setcallerpc
-#endif
+void	runtime·noteclear(Note*);
+void	runtime·notesleep(Note*);
+void	runtime·notewakeup(Note*);
 
 /*
  * This is consistent across Linux and BSD.
@@ -533,84 +505,83 @@
 /*
  * low level go-called
  */
-uint8*	runtime_mmap(byte*, uintptr, int32, int32, int32, uint32);
-void	runtime_munmap(uint8*, uintptr);
-void	runtime_memclr(byte*, uint32);
-void	runtime_setcallerpc(void*, void*);
-void*	runtime_getcallerpc(void*);
+uint8*	runtime·mmap(byte*, uintptr, int32, int32, int32, uint32);
+void	runtime·munmap(uint8*, uintptr);
+void	runtime·memclr(byte*, uint32);
+void	runtime·setcallerpc(void*, void*);
+void*	runtime·getcallerpc(void*);
 
 /*
  * runtime go-called
  */
-void	runtime_printbool(bool);
-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);
+void	runtime·printbool(bool);
+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);
 void	reflect·call(byte*, byte*, uint32);
-void	·panic(Eface);
-void	·panicindex(void);
-void	·panicslice(void);
+void	runtime·panic(Eface);
+void	runtime·panicindex(void);
+void	runtime·panicslice(void);
 
 /*
  * runtime c-called (but written in Go)
  */
-void ·newError(String, Eface*);
-void	·printany(Eface);
-void	·newTypeAssertionError(Type*, Type*, Type*, String*, String*, String*, String*, Eface*);
-void	·newErrorString(String, Eface*);
-void	·fadd64c(uint64, uint64, uint64*);
-void	·fsub64c(uint64, uint64, uint64*);
-void	·fmul64c(uint64, uint64, uint64*);
-void	·fdiv64c(uint64, uint64, uint64*);
-void	·fneg64c(uint64, uint64*);
-void	·f32to64c(uint32, uint64*);
-void	·f64to32c(uint64, uint32*);
-void	·fcmp64c(uint64, uint64, int32*, bool*);
-void	·fintto64c(int64, uint64*);
-void	·f64tointc(uint64, int64*, bool*);
+void	runtime·newError(String, Eface*);
+void	runtime·printany(Eface);
+void	runtime·newTypeAssertionError(Type*, Type*, Type*, String*, String*, String*, String*, Eface*);
+void	runtime·newErrorString(String, Eface*);
+void	runtime·fadd64c(uint64, uint64, uint64*);
+void	runtime·fsub64c(uint64, uint64, uint64*);
+void	runtime·fmul64c(uint64, uint64, uint64*);
+void	runtime·fdiv64c(uint64, uint64, uint64*);
+void	runtime·fneg64c(uint64, uint64*);
+void	runtime·f32to64c(uint32, uint64*);
+void	runtime·f64to32c(uint64, uint32*);
+void	runtime·fcmp64c(uint64, uint64, int32*, bool*);
+void	runtime·fintto64c(int64, uint64*);
+void	runtime·f64tointc(uint64, int64*, bool*);
 
 /*
  * wrapped for go users
  */
-float64	Inf(int32 sign);
-float64	NaN(void);
-float32	float32frombits(uint32 i);
-uint32	float32tobits(float32 f);
-float64	float64frombits(uint64 i);
-uint64	float64tobits(float64 f);
-float64	frexp(float64 d, int32 *ep);
-bool	isInf(float64 f, int32 sign);
-bool	isNaN(float64 f);
-float64	ldexp(float64 d, int32 e);
-float64	modf(float64 d, float64 *ip);
-void	semacquire(uint32*);
-void	semrelease(uint32*);
-String	signame(int32 sig);
-int32	gomaxprocsfunc(int32 n);
+float64	runtime·Inf(int32 sign);
+float64	runtime·NaN(void);
+float32	runtime·float32frombits(uint32 i);
+uint32	runtime·float32tobits(float32 f);
+float64	runtime·float64frombits(uint64 i);
+uint64	runtime·float64tobits(float64 f);
+float64	runtime·frexp(float64 d, int32 *ep);
+bool	runtime·isInf(float64 f, int32 sign);
+bool	runtime·isNaN(float64 f);
+float64	runtime·ldexp(float64 d, int32 e);
+float64	runtime·modf(float64 d, float64 *ip);
+void	runtime·semacquire(uint32*);
+void	runtime·semrelease(uint32*);
+String	runtime·signame(int32 sig);
+int32	runtime·gomaxprocsfunc(int32 n);
 
+void	runtime·mapassign(Hmap*, byte*, byte*);
+void	runtime·mapaccess(Hmap*, byte*, byte*, bool*);
+struct hash_iter*	runtime·newmapiterinit(Hmap*);
+void	runtime·mapiternext(struct hash_iter*);
+bool	runtime·mapiterkey(struct hash_iter*, void*);
+void	runtime·mapiterkeyvalue(struct hash_iter*, void*, void*);
+Hmap*	runtime·makemap_c(Type*, Type*, int64);
 
-void	mapassign(Hmap*, byte*, byte*);
-void	mapaccess(Hmap*, byte*, byte*, bool*);
-struct hash_iter*	mapiterinit(Hmap*);
-void	mapiternext(struct hash_iter*);
-bool	mapiterkey(struct hash_iter*, void*);
-void	mapiterkeyvalue(struct hash_iter*, void*, void*);
-Hmap*	makemap(Type*, Type*, int64);
+Hchan*	runtime·makechan_c(Type*, int64);
+void	runtime·chansend(Hchan*, void*, bool*);
+void	runtime·chanrecv(Hchan*, void*, bool*);
+void	runtime·chanclose(Hchan*);
+bool	runtime·chanclosed(Hchan*);
+int32	runtime·chanlen(Hchan*);
+int32	runtime·chancap(Hchan*);
 
-Hchan*	makechan(Type*, int64);
-void	chansend(Hchan*, void*, bool*);
-void	chanrecv(Hchan*, void*, bool*);
-void	chanclose(Hchan*);
-bool	chanclosed(Hchan*);
-int32	chanlen(Hchan*);
-int32	chancap(Hchan*);
-
-void	ifaceE2I(struct InterfaceType*, Eface, Iface*);
+void	runtime·ifaceE2I(struct InterfaceType*, Eface, Iface*);
diff --git a/src/pkg/runtime/runtime1.goc b/src/pkg/runtime/runtime1.goc
index 5488443..da2d0c5 100644
--- a/src/pkg/runtime/runtime1.goc
+++ b/src/pkg/runtime/runtime1.goc
@@ -6,5 +6,5 @@
 #include "runtime.h"
 
 func GOMAXPROCS(n int32) (ret int32) {
-	ret = gomaxprocsfunc(n);
+	ret = runtime·gomaxprocsfunc(n);
 }
diff --git a/src/pkg/runtime/sema.goc b/src/pkg/runtime/sema.goc
index 71395ce..1c77e87 100644
--- a/src/pkg/runtime/sema.goc
+++ b/src/pkg/runtime/sema.goc
@@ -39,7 +39,7 @@
 	s->addr = addr;
 	s->g = nil;
 
-	lock(&semlock);
+	runtime·lock(&semlock);
 	s->prev = semlast;
 	s->next = nil;
 	if(semlast)
@@ -47,13 +47,13 @@
 	else
 		semfirst = s;
 	semlast = s;
-	unlock(&semlock);
+	runtime·unlock(&semlock);
 }
 
 static void
 semdequeue(Sema *s)
 {
-	lock(&semlock);
+	runtime·lock(&semlock);
 	if(s->next)
 		s->next->prev = s->prev;
 	else
@@ -64,7 +64,7 @@
 		semfirst = s->next;
 	s->prev = nil;
 	s->next = nil;
-	unlock(&semlock);
+	runtime·unlock(&semlock);
 }
 
 static void
@@ -72,15 +72,15 @@
 {
 	Sema *s;
 
-	lock(&semlock);
+	runtime·lock(&semlock);
 	for(s=semfirst; s; s=s->next) {
 		if(s->addr == addr && s->g) {
-			ready(s->g);
+			runtime·ready(s->g);
 			s->g = nil;
 			break;
 		}
 	}
-	unlock(&semlock);
+	runtime·unlock(&semlock);
 }
 
 // Step 1 of sleep: make ourselves available for wakeup.
@@ -90,16 +90,16 @@
 static void
 semsleep1(Sema *s)
 {
-	lock(&semlock);
+	runtime·lock(&semlock);
 	s->g = g;
-	unlock(&semlock);
+	runtime·unlock(&semlock);
 }
 
 // Decided not to go through with it: undo step 1.
 static void
 semsleepundo1(Sema *s)
 {
-	lock(&semlock);
+	runtime·lock(&semlock);
 	if(s->g != nil) {
 		s->g = nil;	// back ourselves out
 	} else {
@@ -111,7 +111,7 @@
 			*(int32*)0x555 = 555;
 		g->readyonstop = 0;
 	}
-	unlock(&semlock);
+	runtime·unlock(&semlock);
 }
 
 // Step 2: wait for the wakeup.
@@ -120,7 +120,7 @@
 {
 	USED(s);
 	g->status = Gwaiting;
-	gosched();
+	runtime·gosched();
 }
 
 static int32
@@ -129,7 +129,7 @@
 	uint32 v;
 
 	while((v = *addr) > 0)
-		if(cas(addr, v, v-1))
+		if(runtime·cas(addr, v, v-1))
 			return 1;
 	return 0;
 }
@@ -137,7 +137,7 @@
 // For now has no return value.
 // Might return an ok (not interrupted) bool in the future?
 void
-semacquire(uint32 *addr)
+runtime·semacquire(uint32 *addr)
 {
 	Sema s;
 
@@ -164,22 +164,22 @@
 }
 
 void
-semrelease(uint32 *addr)
+runtime·semrelease(uint32 *addr)
 {
 	uint32 v;
 
 	for(;;) {
 		v = *addr;
-		if(cas(addr, v, v+1))
+		if(runtime·cas(addr, v, v+1))
 			break;
 	}
 	semwakeup(addr);
 }
 
 func Semacquire(addr *uint32) {
-	semacquire(addr);
+	runtime·semacquire(addr);
 }
 
 func Semrelease(addr *uint32) {
-	semrelease(addr);
+	runtime·semrelease(addr);
 }
diff --git a/src/pkg/runtime/sigqueue.goc b/src/pkg/runtime/sigqueue.goc
index 572daab..504590a 100644
--- a/src/pkg/runtime/sigqueue.goc
+++ b/src/pkg/runtime/sigqueue.goc
@@ -47,14 +47,14 @@
 } sig;
 
 void
-siginit(void)
+runtime·siginit(void)
 {
-	noteclear(&sig);
+	runtime·noteclear(&sig);
 }
 
 // Called from sighandler to send a signal back out of the signal handling thread.
 bool
-sigsend(int32 s)
+runtime·sigsend(int32 s)
 {
 	uint32 bit, mask;
 
@@ -65,11 +65,11 @@
 		mask = sig.mask;
 		if(mask & bit)
 			break;		// signal already in queue
-		if(cas(&sig.mask, mask, mask|bit)) {
+		if(runtime·cas(&sig.mask, mask, mask|bit)) {
 			// Added to queue.
 			// Only send a wakeup for the first signal in each round.
 			if(mask == 0)
-				notewakeup(&sig);
+				runtime·notewakeup(&sig);
 			break;
 		}
 	}
@@ -78,22 +78,22 @@
 
 // Called to receive a bitmask of queued signals.
 func Sigrecv() (m uint32) {
-	·entersyscall();
-	notesleep(&sig);
-	·exitsyscall();
-	noteclear(&sig);
+	runtime·entersyscall();
+	runtime·notesleep(&sig);
+	runtime·exitsyscall();
+	runtime·noteclear(&sig);
 	for(;;) {
 		m = sig.mask;
-		if(cas(&sig.mask, m, 0))
+		if(runtime·cas(&sig.mask, m, 0))
 			break;
 	}
 }
 
 func Signame(sig int32) (name String) {
-	name = signame(sig);
+	name = runtime·signame(sig);
 }
 
 func Siginit() {
-	initsig(SigQueue);
+	runtime·initsig(SigQueue);
 	sig.inuse = true;	// enable reception of signals; cannot disable
 }
diff --git a/src/pkg/runtime/slice.c b/src/pkg/runtime/slice.c
index 5884cfc..0510754 100644
--- a/src/pkg/runtime/slice.c
+++ b/src/pkg/runtime/slice.c
@@ -8,30 +8,30 @@
 
 static	int32	debug	= 0;
 
-static	void	makeslice(SliceType*, int32, int32, Slice*);
-	void	·slicecopy(Slice to, Slice fm, uintptr width, int32 ret);
+static	void	makeslice1(SliceType*, int32, int32, Slice*);
+	void	runtime·slicecopy(Slice to, Slice fm, uintptr width, int32 ret);
 
 // see also unsafe·NewArray
 // makeslice(typ *Type, len, cap int64) (ary []any);
 void
-·makeslice(SliceType *t, int64 len, int64 cap, Slice ret)
+runtime·makeslice(SliceType *t, int64 len, int64 cap, Slice ret)
 {
 	if(len < 0 || (int32)len != len)
-		panicstring("makeslice: len out of range");
+		runtime·panicstring("makeslice: len out of range");
 	if(cap < len || (int32)cap != cap || cap > ((uintptr)-1) / t->elem->size)
-		panicstring("makeslice: cap out of range");
+		runtime·panicstring("makeslice: cap out of range");
 
-	makeslice(t, len, cap, &ret);
+	makeslice1(t, len, cap, &ret);
 
 	if(debug) {
-		printf("makeslice(%S, %D, %D); ret=",
+		runtime·printf("makeslice(%S, %D, %D); ret=",
 			*t->string, len, cap);
- 		·printslice(ret);
+ 		runtime·printslice(ret);
 	}
 }
 
 static void
-makeslice(SliceType *t, int32 len, int32 cap, Slice *ret)
+makeslice1(SliceType *t, int32 len, int32 cap, Slice *ret)
 {	
 	uintptr size;
 
@@ -41,17 +41,17 @@
 	ret->cap = cap;
 
 	if((t->elem->kind&KindNoPointers))
-		ret->array = mallocgc(size, RefNoPointers, 1, 1);
+		ret->array = runtime·mallocgc(size, RefNoPointers, 1, 1);
 	else
-		ret->array = mal(size);
+		ret->array = runtime·mal(size);
 }
 
-static void appendslice(SliceType*, Slice, Slice, Slice*);
+static void appendslice1(SliceType*, Slice, Slice, Slice*);
 
 // append(type *Type, n int, old []T, ...,) []T
 #pragma textflag 7
 void
-·append(SliceType *t, int32 n, Slice old, ...)
+runtime·append(SliceType *t, int32 n, Slice old, ...)
 {
 	Slice sl;
 	Slice *ret;
@@ -59,25 +59,25 @@
 	sl.len = n;
 	sl.array = (byte*)(&old+1);
 	ret = (Slice*)(sl.array + ((t->elem->size*n+sizeof(uintptr)-1) & ~(sizeof(uintptr)-1)));
-	appendslice(t, old, sl, ret);
+	appendslice1(t, old, sl, ret);
 }
 
 // appendslice(type *Type, x, y, []T) []T
 void
-·appendslice(SliceType *t, Slice x, Slice y, Slice ret)
+runtime·appendslice(SliceType *t, Slice x, Slice y, Slice ret)
 {
-	appendslice(t, x, y, &ret);
+	appendslice1(t, x, y, &ret);
 }
 
 static void
-appendslice(SliceType *t, Slice x, Slice y, Slice *ret)
+appendslice1(SliceType *t, Slice x, Slice y, Slice *ret)
 {
 	Slice newx;
 	int32 m;
 	uintptr w;
 
 	if(x.len+y.len < x.len)
-		throw("append: slice overflow");
+		runtime·throw("append: slice overflow");
 
 	w = t->elem->size;
 	if(x.len+y.len > x.cap) {
@@ -92,11 +92,11 @@
 					m += m/4;
 			} while(m < x.len+y.len);
 		}
-		makeslice(t, x.len, m, &newx);
-		memmove(newx.array, x.array, x.len*w);
+		makeslice1(t, x.len, m, &newx);
+		runtime·memmove(newx.array, x.array, x.len*w);
 		x = newx;
 	}
-	memmove(x.array+x.len*w, y.array, y.len*w);
+	runtime·memmove(x.array+x.len*w, y.array, y.len*w);
 	x.len += y.len;
 	*ret = x;
 }
@@ -105,27 +105,27 @@
 
 // sliceslice(old []any, lb uint64, hb uint64, width uint64) (ary []any);
 void
-·sliceslice(Slice old, uint64 lb, uint64 hb, uint64 width, Slice ret)
+runtime·sliceslice(Slice old, uint64 lb, uint64 hb, uint64 width, Slice ret)
 {
 	if(hb > old.cap || lb > hb) {
 		if(debug) {
-			prints("runtime.sliceslice: old=");
-			·printslice(old);
-			prints("; lb=");
-			·printint(lb);
-			prints("; hb=");
-			·printint(hb);
-			prints("; width=");
-			·printint(width);
-			prints("\n");
+			runtime·prints("runtime.sliceslice: old=");
+			runtime·printslice(old);
+			runtime·prints("; lb=");
+			runtime·printint(lb);
+			runtime·prints("; hb=");
+			runtime·printint(hb);
+			runtime·prints("; width=");
+			runtime·printint(width);
+			runtime·prints("\n");
 
-			prints("oldarray: nel=");
-			·printint(old.len);
-			prints("; cap=");
-			·printint(old.cap);
-			prints("\n");
+			runtime·prints("oldarray: nel=");
+			runtime·printint(old.len);
+			runtime·prints("; cap=");
+			runtime·printint(old.cap);
+			runtime·prints("\n");
 		}
-		·panicslice();
+		runtime·panicslice();
 	}
 
 	// new array is inside old array
@@ -136,41 +136,41 @@
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("runtime.sliceslice: old=");
-		·printslice(old);
-		prints("; lb=");
-		·printint(lb);
-		prints("; hb=");
-		·printint(hb);
-		prints("; width=");
-		·printint(width);
-		prints("; ret=");
-		·printslice(ret);
-		prints("\n");
+		runtime·prints("runtime.sliceslice: old=");
+		runtime·printslice(old);
+		runtime·prints("; lb=");
+		runtime·printint(lb);
+		runtime·prints("; hb=");
+		runtime·printint(hb);
+		runtime·prints("; width=");
+		runtime·printint(width);
+		runtime·prints("; ret=");
+		runtime·printslice(ret);
+		runtime·prints("\n");
 	}
 }
 
 // sliceslice1(old []any, lb uint64, width uint64) (ary []any);
 void
-·sliceslice1(Slice old, uint64 lb, uint64 width, Slice ret)
+runtime·sliceslice1(Slice old, uint64 lb, uint64 width, Slice ret)
 {
 	if(lb > old.len) {
 		if(debug) {
-			prints("runtime.sliceslice: old=");
-			·printslice(old);
-			prints("; lb=");
-			·printint(lb);
-			prints("; width=");
-			·printint(width);
-			prints("\n");
+			runtime·prints("runtime.sliceslice: old=");
+			runtime·printslice(old);
+			runtime·prints("; lb=");
+			runtime·printint(lb);
+			runtime·prints("; width=");
+			runtime·printint(width);
+			runtime·prints("\n");
 
-			prints("oldarray: nel=");
-			·printint(old.len);
-			prints("; cap=");
-			·printint(old.cap);
-			prints("\n");
+			runtime·prints("oldarray: nel=");
+			runtime·printint(old.len);
+			runtime·prints("; cap=");
+			runtime·printint(old.cap);
+			runtime·prints("\n");
 		}
-		·panicslice();
+		runtime·panicslice();
 	}
 
 	// new array is inside old array
@@ -181,21 +181,21 @@
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("runtime.sliceslice: old=");
-		·printslice(old);
-		prints("; lb=");
-		·printint(lb);
-		prints("; width=");
-		·printint(width);
-		prints("; ret=");
-		·printslice(ret);
-		prints("\n");
+		runtime·prints("runtime.sliceslice: old=");
+		runtime·printslice(old);
+		runtime·prints("; lb=");
+		runtime·printint(lb);
+		runtime·prints("; width=");
+		runtime·printint(width);
+		runtime·prints("; ret=");
+		runtime·printslice(ret);
+		runtime·prints("\n");
 	}
 }
 
 // slicearray(old *any, nel uint64, lb uint64, hb uint64, width uint64) (ary []any);
 void
-·slicearray(byte* old, uint64 nel, uint64 lb, uint64 hb, uint64 width, Slice ret)
+runtime·slicearray(byte* old, uint64 nel, uint64 lb, uint64 hb, uint64 width, Slice ret)
 {
 	if(nel > 0 && old == nil) {
 		// crash if old == nil.
@@ -207,19 +207,19 @@
 
 	if(hb > nel || lb > hb) {
 		if(debug) {
-			prints("runtime.slicearray: old=");
-			·printpointer(old);
-			prints("; nel=");
-			·printint(nel);
-			prints("; lb=");
-			·printint(lb);
-			prints("; hb=");
-			·printint(hb);
-			prints("; width=");
-			·printint(width);
-			prints("\n");
+			runtime·prints("runtime.slicearray: old=");
+			runtime·printpointer(old);
+			runtime·prints("; nel=");
+			runtime·printint(nel);
+			runtime·prints("; lb=");
+			runtime·printint(lb);
+			runtime·prints("; hb=");
+			runtime·printint(hb);
+			runtime·prints("; width=");
+			runtime·printint(width);
+			runtime·prints("\n");
 		}
-		·panicslice();
+		runtime·panicslice();
 	}
 
 	// new array is inside old array
@@ -230,25 +230,25 @@
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("runtime.slicearray: old=");
-		·printpointer(old);
-		prints("; nel=");
-		·printint(nel);
-		prints("; lb=");
-		·printint(lb);
-		prints("; hb=");
-		·printint(hb);
-		prints("; width=");
-		·printint(width);
-		prints("; ret=");
-		·printslice(ret);
-		prints("\n");
+		runtime·prints("runtime.slicearray: old=");
+		runtime·printpointer(old);
+		runtime·prints("; nel=");
+		runtime·printint(nel);
+		runtime·prints("; lb=");
+		runtime·printint(lb);
+		runtime·prints("; hb=");
+		runtime·printint(hb);
+		runtime·prints("; width=");
+		runtime·printint(width);
+		runtime·prints("; ret=");
+		runtime·printslice(ret);
+		runtime·prints("\n");
 	}
 }
 
 // slicecopy(to any, fr any, wid uint32) int
 void
-·slicecopy(Slice to, Slice fm, uintptr width, int32 ret)
+runtime·slicecopy(Slice to, Slice fm, uintptr width, int32 ret)
 {
 	if(fm.len == 0 || to.len == 0 || width == 0) {
 		ret = 0;
@@ -262,27 +262,27 @@
 	if(ret == 1 && width == 1) {	// common case worth about 2x to do here
 		*to.array = *fm.array;	// known to be a byte pointer
 	} else {
-		memmove(to.array, fm.array, ret*width);
+		runtime·memmove(to.array, fm.array, ret*width);
 	}
 
 out:
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("main·copy: to=");
-		·printslice(to);
-		prints("; fm=");
-		·printslice(fm);
-		prints("; width=");
-		·printint(width);
-		prints("; ret=");
-		·printint(ret);
-		prints("\n");
+		runtime·prints("main·copy: to=");
+		runtime·printslice(to);
+		runtime·prints("; fm=");
+		runtime·printslice(fm);
+		runtime·prints("; width=");
+		runtime·printint(width);
+		runtime·prints("; ret=");
+		runtime·printint(ret);
+		runtime·prints("\n");
 	}
 }
 
 void
-·slicestringcopy(Slice to, String fm, int32 ret)
+runtime·slicestringcopy(Slice to, String fm, int32 ret)
 {
 	if(fm.len == 0 || to.len == 0) {
 		ret = 0;
@@ -293,19 +293,19 @@
 	if(to.len < ret)
 		ret = to.len;
 	
-	memmove(to.array, fm.str, ret);
+	runtime·memmove(to.array, fm.str, ret);
 
 out:
 	FLUSH(&ret);
 }
 
 void
-·printslice(Slice a)
+runtime·printslice(Slice a)
 {
-	prints("[");
-	·printint(a.len);
-	prints("/");
-	·printint(a.cap);
-	prints("]");
-	·printpointer(a.array);
+	runtime·prints("[");
+	runtime·printint(a.len);
+	runtime·prints("/");
+	runtime·printint(a.cap);
+	runtime·prints("]");
+	runtime·printpointer(a.array);
 }
diff --git a/src/pkg/runtime/string.goc b/src/pkg/runtime/string.goc
index 1db1c2c..916559e 100644
--- a/src/pkg/runtime/string.goc
+++ b/src/pkg/runtime/string.goc
@@ -6,10 +6,10 @@
 #include "runtime.h"
 #include "malloc.h"
 
-String	emptystring;
+String	runtime·emptystring;
 
 int32
-findnull(byte *s)
+runtime·findnull(byte *s)
 {
 	int32 l;
 
@@ -21,7 +21,7 @@
 }
 
 int32
-findnullw(uint16 *s)
+runtime·findnullw(uint16 *s)
 {
 	int32 l;
 
@@ -32,56 +32,56 @@
 	return l;
 }
 
-int32 maxstring = 256;
+int32 runtime·maxstring = 256;
 
 String
-gostringsize(int32 l)
+runtime·gostringsize(int32 l)
 {
 	String s;
 
 	if(l == 0)
-		return emptystring;
-	s.str = mal(l+1);	// leave room for NUL for C runtime (e.g., callers of getenv)
+		return runtime·emptystring;
+	s.str = runtime·mal(l+1);	// leave room for NUL for C runtime (e.g., callers of getenv)
 	s.len = l;
-	if(l > maxstring)
-		maxstring = l;
+	if(l > runtime·maxstring)
+		runtime·maxstring = l;
 	return s;
 }
 
 String
-gostring(byte *str)
+runtime·gostring(byte *str)
 {
 	int32 l;
 	String s;
 
-	l = findnull(str);
-	s = gostringsize(l);
-	mcpy(s.str, str, l);
+	l = runtime·findnull(str);
+	s = runtime·gostringsize(l);
+	runtime·mcpy(s.str, str, l);
 	return s;
 }
 
 String
-gostringn(byte *str, int32 l)
+runtime·gostringn(byte *str, int32 l)
 {
-    String s;
+	String s;
 
-    s = gostringsize(l);
-    mcpy(s.str, str, l);
-    return s;
+	s = runtime·gostringsize(l);
+	runtime·mcpy(s.str, str, l);
+	return s;
 }
 
 String
-gostringnocopy(byte *str)
+runtime·gostringnocopy(byte *str)
 {
 	String s;
 	
 	s.str = str;
-	s.len = findnull(str);
+	s.len = runtime·findnull(str);
 	return s;
 }
 
 String
-gostringw(uint16 *str)
+runtime·gostringw(uint16 *str)
 {
 	int32 n, i;
 	byte buf[8];
@@ -89,17 +89,17 @@
 
 	n = 0;
 	for(i=0; str[i]; i++)
-		n += runetochar(buf, str[i]);
-	s = gostringsize(n+4);
+		n += runtime·runetochar(buf, str[i]);
+	s = runtime·gostringsize(n+4);
 	n = 0;
 	for(i=0; str[i]; i++)
-		n += runetochar(s.str+n, str[i]);
+		n += runtime·runetochar(s.str+n, str[i]);
 	s.len = n;
 	return s;
 }
 
 String
-catstring(String s1, String s2)
+runtime·catstring(String s1, String s2)
 {
 	String s3;
 
@@ -108,13 +108,13 @@
 	if(s2.len == 0)
 		return s1;
 
-	s3 = gostringsize(s1.len + s2.len);
-	mcpy(s3.str, s1.str, s1.len);
-	mcpy(s3.str+s1.len, s2.str, s2.len);
+	s3 = runtime·gostringsize(s1.len + s2.len);
+	runtime·mcpy(s3.str, s1.str, s1.len);
+	runtime·mcpy(s3.str+s1.len, s2.str, s2.len);
 	return s3;
 }
 
-String
+static String
 concatstring(int32 n, String *s)
 {
 	int32 i, l;
@@ -123,14 +123,14 @@
 	l = 0;
 	for(i=0; i<n; i++) {
 		if(l + s[i].len < l)
-			throw("string concatenation too long");
+			runtime·throw("string concatenation too long");
 		l += s[i].len;
 	}
 	
-	out = gostringsize(l);
+	out = runtime·gostringsize(l);
 	l = 0;
 	for(i=0; i<n; i++) {
-		mcpy(out.str+l, s[i].str, s[i].len);
+		runtime·mcpy(out.str+l, s[i].str, s[i].len);
 		l += s[i].len;
 	}
 	return out;
@@ -143,7 +143,7 @@
 	(&s1)[n] = concatstring(n, &s1);
 }
 
-uint32
+static int32
 cmpstring(String s1, String s2)
 {
 	uint32 i, l;
@@ -172,7 +172,7 @@
 }
 
 int32
-strcmp(byte *s1, byte *s2)
+runtime·strcmp(byte *s1, byte *s2)
 {
 	uint32 i;
 	byte c1, c2;
@@ -194,7 +194,7 @@
 
 	if(lindex < 0 || lindex > si.len ||
 	   hindex < lindex || hindex > si.len) {
-	   	·panicslice();
+	   	runtime·panicslice();
 	}
 
 	l = hindex-lindex;
@@ -206,7 +206,7 @@
 	int32 l;
 
 	if(lindex < 0 || lindex > si.len) {
-		·panicslice();
+		runtime·panicslice();
 	}
 
 	l = si.len-lindex;
@@ -215,20 +215,20 @@
 }
 
 func intstring(v int64) (s String) {
-	s = gostringsize(8);
-	s.len = runetochar(s.str, v);
+	s = runtime·gostringsize(8);
+	s.len = runtime·runetochar(s.str, v);
 }
 
 func slicebytetostring(b Slice) (s String) {
-	s = gostringsize(b.len);
-	mcpy(s.str, b.array, s.len);
+	s = runtime·gostringsize(b.len);
+	runtime·mcpy(s.str, b.array, s.len);
 }
 
 func stringtoslicebyte(s String) (b Slice) {
-	b.array = mallocgc(s.len, RefNoPointers, 1, 1);
+	b.array = runtime·mallocgc(s.len, RefNoPointers, 1, 1);
 	b.len = s.len;
 	b.cap = s.len;
-	mcpy(b.array, s.str, s.len);
+	runtime·mcpy(b.array, s.str, s.len);
 }
 
 func sliceinttostring(b Slice) (s String) {
@@ -239,16 +239,16 @@
 	a = (int32*)b.array;
 	siz1 = 0;
 	for(i=0; i<b.len; i++) {
-		siz1 += runetochar(dum, a[i]);
+		siz1 += runtime·runetochar(dum, a[i]);
 	}
 
-	s = gostringsize(siz1+4);
+	s = runtime·gostringsize(siz1+4);
 	siz2 = 0;
 	for(i=0; i<b.len; i++) {
 		// check for race
 		if(siz2 >= siz1)
 			break;
-		siz2 += runetochar(s.str+siz2, a[i]);
+		siz2 += runtime·runetochar(s.str+siz2, a[i]);
 	}
 	s.len = siz2;
 }
@@ -264,17 +264,17 @@
 	ep = s.str+s.len;
 	n = 0;
 	while(p < ep) {
-		p += charntorune(&dum, p, ep-p);
+		p += runtime·charntorune(&dum, p, ep-p);
 		n++;
 	}
 
-	b.array = mallocgc(n*sizeof(r[0]), RefNoPointers, 1, 1);
+	b.array = runtime·mallocgc(n*sizeof(r[0]), RefNoPointers, 1, 1);
 	b.len = n;
 	b.cap = n;
 	p = s.str;
 	r = (int32*)b.array;
 	while(p < ep)
-		p += charntorune(r++, p, ep-p);
+		p += runtime·charntorune(r++, p, ep-p);
 }
 
 enum
@@ -298,7 +298,7 @@
 	}
 
 	// multi-char rune
-	retk = k + charntorune(&l, s.str+k, s.len-k);
+	retk = k + runtime·charntorune(&l, s.str+k, s.len-k);
 
 out:
 }
@@ -318,7 +318,7 @@
 	}
 
 	// multi-char rune
-	retk = k + charntorune(&retv, s.str+k, s.len-k);
+	retk = k + runtime·charntorune(&retv, s.str+k, s.len-k);
 
 out:
 }
diff --git a/src/pkg/runtime/symtab.c b/src/pkg/runtime/symtab.c
index ea9ac5e..b2cccd3 100644
--- a/src/pkg/runtime/symtab.c
+++ b/src/pkg/runtime/symtab.c
@@ -60,7 +60,7 @@
 			}
 			p = q+2;
 		}else{
-			q = mchr(p, '\0', ep);
+			q = runtime·mchr(p, '\0', ep);
 			if(q == nil)
 				break;
 			p = q+1;
@@ -90,14 +90,14 @@
 	case 'T':
 	case 'l':
 	case 'L':
-		if(strcmp(sym->name, (byte*)"etext") == 0)
+		if(runtime·strcmp(sym->name, (byte*)"etext") == 0)
 			break;
 		if(func == nil) {
 			nfunc++;
 			break;
 		}
 		f = &func[nfunc++];
-		f->name = gostringnocopy(sym->name);
+		f->name = runtime·gostringnocopy(sym->name);
 		f->entry = sym->value;
 		if(sym->symtype == 'L' || sym->symtype == 'l')
 			f->frame = -sizeof(uintptr);
@@ -120,8 +120,8 @@
 		if(fname == nil) {
 			if(sym->value >= nfname) {
 				if(sym->value >= 0x10000) {
-					printf("invalid symbol file index %p\n", sym->value);
-					throw("mangled symbol table");
+					runtime·printf("invalid symbol file index %p\n", sym->value);
+					runtime·throw("mangled symbol table");
 				}
 				nfname = sym->value+1;
 			}
@@ -154,12 +154,12 @@
 		if(n >= nfname)
 			break;
 		q = fname[n];
-		len = findnull(q);
+		len = runtime·findnull(q);
 		if(p+1+len >= ep)
 			break;
 		if(p > buf && p[-1] != '/')
 			*p++ = '/';
-		mcpy(p, q, len+1);
+		runtime·mcpy(p, q, len+1);
 		p += len;
 	}
 }
@@ -185,7 +185,7 @@
 	switch(sym->symtype) {
 	case 't':
 	case 'T':
-		if(strcmp(sym->name, (byte*)"etext") == 0)
+		if(runtime·strcmp(sym->name, (byte*)"etext") == 0)
 			break;
 		f = &func[nfunc++];
 		// find source file
@@ -204,7 +204,7 @@
 			nfile = 0;
 			if(nfile == nelem(files))
 				return;
-			files[nfile].srcstring = gostring(srcbuf);
+			files[nfile].srcstring = runtime·gostring(srcbuf);
 			files[nfile].aline = 0;
 			files[nfile++].delta = 0;
 		} else {
@@ -215,7 +215,7 @@
 					incstart = sym->value;
 				if(nhist == 0 && nfile < nelem(files)) {
 					// new top-level file
-					files[nfile].srcstring = gostring(srcbuf);
+					files[nfile].srcstring = runtime·gostring(srcbuf);
 					files[nfile].aline = sym->value;
 					// this is "line 0"
 					files[nfile++].delta = sym->value - 1;
@@ -293,7 +293,7 @@
 // (Source file is f->src.)
 // NOTE(rsc): If you edit this function, also edit extern.go:/FileLine
 int32
-funcline(Func *f, uint64 targetpc)
+runtime·funcline(Func *f, uint64 targetpc)
 {
 	byte *p, *ep;
 	uintptr pc;
@@ -348,9 +348,9 @@
 	walksymtab(dofunc);
 
 	// initialize tables
-	func = mal((nfunc+1)*sizeof func[0]);
+	func = runtime·mal((nfunc+1)*sizeof func[0]);
 	func[nfunc].entry = (uint64)etext;
-	fname = mal(nfname*sizeof fname[0]);
+	fname = runtime·mal(nfname*sizeof fname[0]);
 	nfunc = 0;
 	walksymtab(dofunc);
 
@@ -364,15 +364,15 @@
 }
 
 Func*
-findfunc(uintptr addr)
+runtime·findfunc(uintptr addr)
 {
 	Func *f;
 	int32 nf, n;
 
-	lock(&funclock);
+	runtime·lock(&funclock);
 	if(func == nil)
 		buildfuncs();
-	unlock(&funclock);
+	runtime·unlock(&funclock);
 
 	if(nfunc == 0)
 		return nil;
@@ -398,6 +398,6 @@
 	// 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.
-	prints("findfunc unreachable\n");
+	runtime·prints("findfunc unreachable\n");
 	return nil;
 }
diff --git a/src/pkg/runtime/tiny/386/rt0.s b/src/pkg/runtime/tiny/386/rt0.s
index ff7aae7..524ac76 100644
--- a/src/pkg/runtime/tiny/386/rt0.s
+++ b/src/pkg/runtime/tiny/386/rt0.s
@@ -11,18 +11,18 @@
 	MOVL	AX, SP
 	
 	// Set up memory hardware.
-	CALL	msetup(SB)
+	CALL	runtime·msetup(SB)
 
 	// _rt0_386 expects to find argc, argv, envv on stack.
 	// Set up argv=["kernel"] and envv=[].
 	SUBL	$64, SP
 	MOVL	$1, 0(SP)
-	MOVL	$kernel(SB), 4(SP)
+	MOVL	$runtime·kernel(SB), 4(SP)
 	MOVL	$0, 8(SP)
 	MOVL	$0, 12(SP)
 	JMP	_rt0_386(SB)
 
-DATA kernel+0(SB)/7, $"kernel\z"
-GLOBL kernel(SB), $7
+DATA runtime·kernel(SB)/7, $"kernel\z"
+GLOBL runtime·kernel(SB), $7
 	
 
diff --git a/src/pkg/runtime/tiny/386/signal.c b/src/pkg/runtime/tiny/386/signal.c
index de06ba8..88e634e 100644
--- a/src/pkg/runtime/tiny/386/signal.c
+++ b/src/pkg/runtime/tiny/386/signal.c
@@ -4,16 +4,16 @@
 
 #include "runtime.h"
 
-extern void ·write(int32 fd, void *v, int32 len, int32 cap);	// slice, spelled out
+extern void runtime·write(int32 fd, void *v, int32 len, int32 cap);	// slice, spelled out
 
 int32
-write(int32 fd, void *v, int32 len)
+runtime·write(int32 fd, void *v, int32 len)
 {
-	·write(fd, v, len, len);
+	runtime·write(fd, v, len, len);
 	return len;
 }
 
 void
-gettime(int64*, int32*) 
+runtime·gettime(int64*, int32*) 
 {
 }
diff --git a/src/pkg/runtime/tiny/386/sys.s b/src/pkg/runtime/tiny/386/sys.s
index c51a5ec..8511714 100644
--- a/src/pkg/runtime/tiny/386/sys.s
+++ b/src/pkg/runtime/tiny/386/sys.s
@@ -17,8 +17,8 @@
 // Called to set up memory hardware.
 // Already running in 32-bit mode thanks to boot block,
 // but we need to install our new GDT that we can modify.
-TEXT msetup(SB), 7, $0
-	MOVL	gdtptr(SB), GDTR
+TEXT runtime·msetup(SB), 7, $0
+	MOVL	runtime·gdtptr(SB), GDTR
 	MOVL	$(1*8+0), AX
 	MOVW	AX, DS
 	MOVW	AX, ES
@@ -29,14 +29,14 @@
 
 	// long jmp to cs:mret
 	BYTE	$0xEA
-	LONG $mret(SB)
+	LONG $runtime·mret(SB)
 	WORD $(2*8+0)
 	
-TEXT mret(SB), 7, $0
+TEXT runtime·mret(SB), 7, $0
 	RET
 
 // GDT memory
-TEXT gdt(SB), 7, $0
+TEXT runtime·gdt(SB), 7, $0
 	// null segment
 	LONG	$0
 	LONG	$0
@@ -54,14 +54,14 @@
 	LONG	$0
 
 // GDT pseudo-descriptor
-TEXT gdtptr(SB), 7, $0
+TEXT runtime·gdtptr(SB), 7, $0
 	WORD	$(4*8)
-	LONG	$gdt(SB)
+	LONG	$runtime·gdt(SB)
 
 // Called to establish the per-thread segment.
 // Write to gdt[3] and reload the gdt register.
 // setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$32
+TEXT runtime·setldt(SB),7,$32
 	MOVL	address+4(FP), BX	// aka base
 	MOVL	limit+8(FP), CX
 
@@ -83,7 +83,7 @@
 	MOVB	CX, 6(AX)
 	MOVB	$0xF2, 5(AX)	// r/w data descriptor, dpl=3, present
 
-	MOVL	gdtptr(SB), GDTR
+	MOVL	runtime·gdtptr(SB), GDTR
 
 	// Compute segment selector - (entry*8+0)
 	MOVL	$(3*8+0), AX
diff --git a/src/pkg/runtime/tiny/mem.c b/src/pkg/runtime/tiny/mem.c
index fbedff2..7abecfb 100644
--- a/src/pkg/runtime/tiny/mem.c
+++ b/src/pkg/runtime/tiny/mem.c
@@ -11,7 +11,7 @@
 static byte *allocp;
 
 void*
-SysAlloc(uintptr ask)
+runtime·SysAlloc(uintptr ask)
 {
 	extern byte end[];
 	byte *q;
@@ -24,12 +24,12 @@
 
 	q = allocp;
 	allocp += ask;
-	·memclr(q, ask);
+	runtime·memclr(q, ask);
 	return q;
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
 	// Push pointer back if this is a free
 	// of the most recent SysAlloc.
@@ -39,12 +39,12 @@
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v, n);
 }
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 }
diff --git a/src/pkg/runtime/tiny/thread.c b/src/pkg/runtime/tiny/thread.c
index 17d4d9f..b976a12 100644
--- a/src/pkg/runtime/tiny/thread.c
+++ b/src/pkg/runtime/tiny/thread.c
@@ -7,22 +7,22 @@
 int8 *goos = "tiny";
 
 void
-minit(void)
+runtime·minit(void)
 {
 }
 
 void
-osinit(void)
+runtime·osinit(void)
 {
 }
 
 void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
 {
 }
 
 void
-exit(int32)
+runtime·exit(int32)
 {
 	for(;;);
 }
@@ -31,56 +31,56 @@
 // so no need for real concurrency or atomicity
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	USED(m, g, stk, fn);
-	throw("newosproc");
+	runtime·throw("newosproc");
 }
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 	if(l->key != 0)
-		throw("deadlock");
+		runtime·throw("deadlock");
 	l->key = 1;
 }
 
 void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	if(l->key != 1)
-		throw("unlock of unlocked lock");
+		runtime·throw("unlock of unlocked lock");
 	l->key = 0;
 }
 
 void 
-destroylock(Lock *l)
+runtime·destroylock(Lock *l)
 {
-    // nothing
+	// nothing
 }
 
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	n->lock.key = 0;
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	n->lock.key = 1;
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	if(n->lock.key != 1)
-		throw("notesleep");
+		runtime·throw("notesleep");
 }
 
diff --git a/src/pkg/runtime/windows/386/rt0.s b/src/pkg/runtime/windows/386/rt0.s
index 4e68504..e379830 100644
--- a/src/pkg/runtime/windows/386/rt0.s
+++ b/src/pkg/runtime/windows/386/rt0.s
@@ -2,5 +2,5 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-TEXT	_rt0_386_windows(SB),7,$0
+TEXT _rt0_386_windows(SB),7,$0
 	JMP	_rt0_386(SB)
diff --git a/src/pkg/runtime/windows/386/signal.c b/src/pkg/runtime/windows/386/signal.c
index a4b3c16..2ae79e5 100644
--- a/src/pkg/runtime/windows/386/signal.c
+++ b/src/pkg/runtime/windows/386/signal.c
@@ -5,13 +5,13 @@
 #include "runtime.h"
 
 void
-initsig(int32)
+runtime·initsig(int32)
 {
 }
 
 String
-signame(int32)
+runtime·signame(int32)
 {
-	return emptystring;
+	return runtime·emptystring;
 }
 
diff --git a/src/pkg/runtime/windows/386/sys.s b/src/pkg/runtime/windows/386/sys.s
index 8c43f9b..c191feb 100644
--- a/src/pkg/runtime/windows/386/sys.s
+++ b/src/pkg/runtime/windows/386/sys.s
@@ -4,7 +4,7 @@
 
 #include "386/asm.h"
 
-TEXT get_kernel_module(SB),7,$0
+TEXT runtime·get_kernel_module(SB),7,$0
 	MOVL	0x30(FS), AX		// get PEB
 	MOVL	0x0c(AX), AX		// get PEB_LDR_DATA
 	MOVL	0x1c(AX), AX		// get init order module list
@@ -13,7 +13,7 @@
 	RET
 
 // void *stdcall_raw(void *fn, int32 count, uintptr *args)
-TEXT stdcall_raw(SB),7,$4
+TEXT runtime·stdcall_raw(SB),7,$4
 	// Copy arguments from stack.
 	MOVL	fn+0(FP), AX
 	MOVL	count+4(FP), CX		// words
@@ -57,7 +57,7 @@
 	RET 
 
 // void tstart(M *newm);
-TEXT tstart(SB),7,$0
+TEXT runtime·tstart(SB),7,$0
 	MOVL	newm+4(SP), CX		// m
 	MOVL	m_g0(CX), DX		// g
 
@@ -84,9 +84,9 @@
 
 	PUSHL	DI			// original stack
 
-	CALL	stackcheck(SB)		// clobbers AX,CX
+	CALL	runtime·stackcheck(SB)		// clobbers AX,CX
 
-	CALL	mstart(SB)
+	CALL	runtime·mstart(SB)
 
 	POPL	DI			// original stack
 	MOVL	DI, SP
@@ -94,11 +94,11 @@
 	RET
 
 // uint32 tstart_stdcall(M *newm);
-TEXT tstart_stdcall(SB),7,$0
+TEXT runtime·tstart_stdcall(SB),7,$0
 	MOVL	newm+4(SP), BX
 
 	PUSHL	BX
-	CALL	tstart+0(SB)
+	CALL	runtime·tstart(SB)
 	POPL	BX
 
 	// Adjust stack for stdcall to return properly.
@@ -111,13 +111,13 @@
 	RET
 
 // setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$0
+TEXT runtime·setldt(SB),7,$0
 	MOVL	address+4(FP), CX
 	MOVL	CX, 0x2c(FS)
 	RET
 
 // for now, return 0,0.  only used for internal performance monitoring.
-TEXT gettime(SB),7,$0
+TEXT runtime·gettime(SB),7,$0
 	MOVL	sec+0(FP), DI
 	MOVL	$0, (DI)
 	MOVL	$0, 4(DI)	// zero extend 32 -> 64 bits
diff --git a/src/pkg/runtime/windows/mem.c b/src/pkg/runtime/windows/mem.c
index ad4efb2..0b5d56c 100644
--- a/src/pkg/runtime/windows/mem.c
+++ b/src/pkg/runtime/windows/mem.c
@@ -16,25 +16,25 @@
 };
 
 void*
-SysAlloc(uintptr n)
+runtime·SysAlloc(uintptr n)
 {
-	return stdcall(VirtualAlloc, 4, nil, n, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+	return runtime·stdcall(runtime·VirtualAlloc, 4, nil, n, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
 }
 
 void
-SysUnused(void *v, uintptr n)
+runtime·SysUnused(void *v, uintptr n)
 {
 	USED(v);
 	USED(n);
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
-	stdcall(VirtualFree, 3, v, n, MEM_RELEASE);
+	runtime·stdcall(runtime·VirtualFree, 3, v, n, MEM_RELEASE);
 }
 
 void
-SysMemInit(void)
+runtime·SysMemInit(void)
 {
 }
diff --git a/src/pkg/runtime/windows/os.h b/src/pkg/runtime/windows/os.h
index 343ddbc..dab14d3 100644
--- a/src/pkg/runtime/windows/os.h
+++ b/src/pkg/runtime/windows/os.h
@@ -5,28 +5,28 @@
 // The following function allows one to dynamically
 // resolve DLL function names.
 // The arguments are strings.
-void *get_proc_addr(void *library, void *name);
+void *runtime·get_proc_addr(void *library, void *name);
 
-extern void *VirtualAlloc;
-extern void *VirtualFree;
-extern void *LoadLibraryEx;
-extern void *GetProcAddress;
-extern void *GetLastError;
+extern void *runtime·VirtualAlloc;
+extern void *runtime·VirtualFree;
+extern void *runtime·LoadLibraryEx;
+extern void *runtime·GetProcAddress;
+extern void *runtime·GetLastError;
 
 #define goargs windows_goargs
-void windows_goargs(void);
+void runtime·windows_goargs(void);
 
 // Get start address of symbol data in memory.
-void *get_symdat_addr(void);
+void *runtime·get_symdat_addr(void);
 
 // Call a Windows function with stdcall conventions,
 // and switch to os stack during the call.
-void *stdcall_raw(void *fn, int32 count, uintptr *args);
-void *stdcall(void *fn, int32 count, ...);
+void *runtime·stdcall_raw(void *fn, int32 count, uintptr *args);
+void *runtime·stdcall(void *fn, int32 count, ...);
 
 // Function to be called by windows CreateTread
 // to start new os thread.
-uint32 tstart_stdcall(M *newm);
+uint32 runtime·tstart_stdcall(M *newm);
 
 // Call stdcall Windows function StdcallParams.fn
 // with params StdcallParams.args,
@@ -43,4 +43,4 @@
 	uintptr	err;
 };
 
-void syscall(StdcallParams *p);
+void runtime·syscall(StdcallParams *p);
diff --git a/src/pkg/runtime/windows/syscall.goc b/src/pkg/runtime/windows/syscall.goc
index 306b715..d3057c5 100644
--- a/src/pkg/runtime/windows/syscall.goc
+++ b/src/pkg/runtime/windows/syscall.goc
@@ -8,22 +8,22 @@
 
 func loadlibraryex(filename uintptr) (handle uint32) {
 	StdcallParams p;
-	p.fn = (void*)LoadLibraryEx;
+	p.fn = (void*)runtime·LoadLibraryEx;
 	p.args[0] = filename;
 	p.args[1] = 0;
 	p.args[2] = 0;
 	p.n = 3;
-	syscall(&p);
+	runtime·syscall(&p);
 	handle = p.r;
 }
 
 func getprocaddress(handle uint32, procname uintptr) (proc uintptr) {
 	StdcallParams p;
-	p.fn = (void*)GetProcAddress;
+	p.fn = (void*)runtime·GetProcAddress;
 	p.args[0] = handle;
 	p.args[1] = procname;
 	p.n = 2;
-	syscall(&p);
+	runtime·syscall(&p);
 	proc = p.r;
 }
 
@@ -34,7 +34,7 @@
 	p.args[1] = a2;
 	p.args[2] = a3;
 	p.n = 3;
-	syscall(&p);
+	runtime·syscall(&p);
 	r1 = p.r;
 	r2 = 0;
 	err = p.err;
@@ -50,7 +50,7 @@
 	p.args[4] = a5;
 	p.args[5] = a6;
 	p.n = 6;
-	syscall(&p);
+	runtime·syscall(&p);
 	r1 = p.r;
 	r2 = 0;
 	err = p.err;
@@ -69,7 +69,7 @@
 	p.args[7] = a8;
 	p.args[8] = a9;
 	p.n = 9;
-	syscall(&p);
+	runtime·syscall(&p);
 	r1 = p.r;
 	r2 = 0;
 	lasterr = p.err;
@@ -91,7 +91,7 @@
 	p.args[10] = a11;
 	p.args[11] = a12;
 	p.n = 12;
-	syscall(&p);
+	runtime·syscall(&p);
 	r1 = p.r;
 	r2 = 0;
 	lasterr = p.err;
@@ -104,7 +104,7 @@
 	p.args[1] = a2;
 	p.args[2] = a3;
 	p.n = 3;
-	syscall(&p);
+	runtime·syscall(&p);
 	r1 = p.r;
 	r2 = 0;
 	err = p.err;
diff --git a/src/pkg/runtime/windows/thread.c b/src/pkg/runtime/windows/thread.c
index decea96..a094b28 100644
--- a/src/pkg/runtime/windows/thread.c
+++ b/src/pkg/runtime/windows/thread.c
@@ -5,20 +5,20 @@
 #include "runtime.h"
 #include "os.h"
 
-extern void *get_kernel_module(void);
+extern void *runtime·get_kernel_module(void);
 
 // Also referenced by external packages
-void *CloseHandle;
-void *ExitProcess;
-void *GetStdHandle;
-void *SetEvent;
-void *WriteFile;
-void *VirtualAlloc;
-void *VirtualFree;
-void *LoadLibraryEx;
-void *GetProcAddress;
-void *GetLastError;
-void *SetLastError;
+void *runtime·CloseHandle;
+void *runtime·ExitProcess;
+void *runtime·GetStdHandle;
+void *runtime·SetEvent;
+void *runtime·WriteFile;
+void *runtime·VirtualAlloc;
+void *runtime·VirtualFree;
+void *runtime·LoadLibraryEx;
+void *runtime·GetProcAddress;
+void *runtime·GetLastError;
+void *runtime·SetLastError;
 
 static void *CreateEvent;
 static void *CreateThread;
@@ -39,7 +39,7 @@
 	ordinals = (uint16*)(base+*(uint32*)(exports+0x24));
 	for(i=0; i<entries; i++) {
 		byte *s = base+names[i];
-		if(!strcmp(name, s))
+		if(runtime·strcmp(name, s) == 0)
 			break;
 	}
 	if(i == entries)
@@ -48,39 +48,39 @@
 }
 
 void
-osinit(void)
+runtime·osinit(void)
 {
 	void *base;
 
-	base = get_kernel_module();
-	GetProcAddress = get_proc_addr2(base, (byte*)"GetProcAddress");
-	LoadLibraryEx = get_proc_addr2(base, (byte*)"LoadLibraryExA");
-	CloseHandle = get_proc_addr("kernel32.dll", "CloseHandle");
-	CreateEvent = get_proc_addr("kernel32.dll", "CreateEventA");
-	CreateThread = get_proc_addr("kernel32.dll", "CreateThread");
-	ExitProcess = get_proc_addr("kernel32.dll", "ExitProcess");
-	GetStdHandle = get_proc_addr("kernel32.dll", "GetStdHandle");
-	SetEvent = get_proc_addr("kernel32.dll", "SetEvent");
-	VirtualAlloc = get_proc_addr("kernel32.dll", "VirtualAlloc");
-	VirtualFree = get_proc_addr("kernel32.dll", "VirtualFree");
-	WaitForSingleObject = get_proc_addr("kernel32.dll", "WaitForSingleObject");
-	WriteFile = get_proc_addr("kernel32.dll", "WriteFile");
-	GetLastError = get_proc_addr("kernel32.dll", "GetLastError");
-	SetLastError = get_proc_addr("kernel32.dll", "SetLastError");
+	base = runtime·get_kernel_module();
+	runtime·GetProcAddress = get_proc_addr2(base, (byte*)"GetProcAddress");
+	runtime·LoadLibraryEx = get_proc_addr2(base, (byte*)"LoadLibraryExA");
+	runtime·CloseHandle = runtime·get_proc_addr("kernel32.dll", "CloseHandle");
+	CreateEvent = runtime·get_proc_addr("kernel32.dll", "CreateEventA");
+	CreateThread = runtime·get_proc_addr("kernel32.dll", "CreateThread");
+	runtime·ExitProcess = runtime·get_proc_addr("kernel32.dll", "ExitProcess");
+	runtime·GetStdHandle = runtime·get_proc_addr("kernel32.dll", "GetStdHandle");
+	runtime·SetEvent = runtime·get_proc_addr("kernel32.dll", "SetEvent");
+	runtime·VirtualAlloc = runtime·get_proc_addr("kernel32.dll", "VirtualAlloc");
+	runtime·VirtualFree = runtime·get_proc_addr("kernel32.dll", "VirtualFree");
+	WaitForSingleObject = runtime·get_proc_addr("kernel32.dll", "WaitForSingleObject");
+	runtime·WriteFile = runtime·get_proc_addr("kernel32.dll", "WriteFile");
+	runtime·GetLastError = runtime·get_proc_addr("kernel32.dll", "GetLastError");
+	runtime·SetLastError = runtime·get_proc_addr("kernel32.dll", "SetLastError");
 }
 
 // The arguments are strings.
 void*
-get_proc_addr(void *library, void *name)
+runtime·get_proc_addr(void *library, void *name)
 {
 	void *base;
 
-	base = stdcall(LoadLibraryEx, 3, library, 0, 0);
-	return stdcall(GetProcAddress, 2, base, name);
+	base = runtime·stdcall(runtime·LoadLibraryEx, 3, library, 0, 0);
+	return runtime·stdcall(runtime·GetProcAddress, 2, base, name);
 }
 
 void
-windows_goargs(void)
+runtime·windows_goargs(void)
 {
 	extern Slice os·Args;
 	extern Slice os·Envs;
@@ -92,48 +92,48 @@
 	int32 i, argc, envc;
 	uint16 *envp;
 
-	gcl = get_proc_addr("kernel32.dll", "GetCommandLineW");
-	clta = get_proc_addr("shell32.dll", "CommandLineToArgvW");
-	ges = get_proc_addr("kernel32.dll", "GetEnvironmentStringsW");
-	fes = get_proc_addr("kernel32.dll", "FreeEnvironmentStringsW");
+	gcl = runtime·get_proc_addr("kernel32.dll", "GetCommandLineW");
+	clta = runtime·get_proc_addr("shell32.dll", "CommandLineToArgvW");
+	ges = runtime·get_proc_addr("kernel32.dll", "GetEnvironmentStringsW");
+	fes = runtime·get_proc_addr("kernel32.dll", "FreeEnvironmentStringsW");
 
-	cmd = stdcall(gcl, 0);
-	env = stdcall(ges, 0);
-	argv = stdcall(clta, 2, cmd, &argc);
+	cmd = runtime·stdcall(gcl, 0);
+	env = runtime·stdcall(ges, 0);
+	argv = runtime·stdcall(clta, 2, cmd, &argc);
 
 	envc = 0;
 	for(envp=env; *envp; envc++)
-		envp += findnullw(envp)+1;
+		envp += runtime·findnullw(envp)+1;
 
-	gargv = malloc(argc*sizeof gargv[0]);
-	genvv = malloc(envc*sizeof genvv[0]);
+	gargv = runtime·malloc(argc*sizeof gargv[0]);
+	genvv = runtime·malloc(envc*sizeof genvv[0]);
 
 	for(i=0; i<argc; i++)
-		gargv[i] = gostringw(argv[i]);
+		gargv[i] = runtime·gostringw(argv[i]);
 	os·Args.array = (byte*)gargv;
 	os·Args.len = argc;
 	os·Args.cap = argc;
 
 	envp = env;
 	for(i=0; i<envc; i++) {
-		genvv[i] = gostringw(envp);
-		envp += findnullw(envp)+1;
+		genvv[i] = runtime·gostringw(envp);
+		envp += runtime·findnullw(envp)+1;
 	}
 	os·Envs.array = (byte*)genvv;
 	os·Envs.len = envc;
 	os·Envs.cap = envc;
 
-	stdcall(fes, 1, env);
+	runtime·stdcall(fes, 1, env);
 }
 
 void
-exit(int32 code)
+runtime·exit(int32 code)
 {
-	stdcall(ExitProcess, 1, code);
+	runtime·stdcall(runtime·ExitProcess, 1, code);
 }
 
 int32
-write(int32 fd, void *buf, int32 n)
+runtime·write(int32 fd, void *buf, int32 n)
 {
 	void *handle;
 	uint32 written;
@@ -141,15 +141,15 @@
 	written = 0;
 	switch(fd) {
 	case 1:
-		handle = stdcall(GetStdHandle, 1, -11);
+		handle = runtime·stdcall(runtime·GetStdHandle, 1, -11);
 		break;
 	case 2:
-		handle = stdcall(GetStdHandle, 1, -12);
+		handle = runtime·stdcall(runtime·GetStdHandle, 1, -12);
 		break;
 	default:
 		return -1;
 	}
-	stdcall(WriteFile, 5, handle, buf, n, &written, 0);
+	runtime·stdcall(runtime·WriteFile, 5, handle, buf, n, &written, 0);
 	return written;
 }
 
@@ -159,10 +159,10 @@
 {
 	void *event;
 
-	event = stdcall(CreateEvent, 4, 0, 0, 0, 0);
-	if(!casp(pevent, 0, event)) {
+	event = runtime·stdcall(CreateEvent, 4, 0, 0, 0, 0);
+	if(!runtime·casp(pevent, 0, event)) {
 		// Someone else filled it in.  Use theirs.
-		stdcall(CloseHandle, 1, event);
+		runtime·stdcall(runtime·CloseHandle, 1, event);
 	}
 }
 
@@ -173,96 +173,96 @@
 	if(l->event == 0)
 		initevent(&l->event);
 
-	if(xadd(&l->key, 1) > 1)	// someone else has it; wait
-		stdcall(WaitForSingleObject, 2, l->event, -1);
+	if(runtime·xadd(&l->key, 1) > 1)	// someone else has it; wait
+		runtime·stdcall(WaitForSingleObject, 2, l->event, -1);
 }
 
 static void
 eventunlock(Lock *l)
 {
-	if(xadd(&l->key, -1) > 0)	// someone else is waiting
-		stdcall(SetEvent, 1, l->event);
+	if(runtime·xadd(&l->key, -1) > 0)	// someone else is waiting
+		runtime·stdcall(runtime·SetEvent, 1, l->event);
 }
 
 void
-lock(Lock *l)
+runtime·lock(Lock *l)
 {
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	m->locks++;
 	eventlock(l);
 }
 
 void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
 {
 	m->locks--;
 	if(m->locks < 0)
-		throw("lock count");
+		runtime·throw("lock count");
 	eventunlock(l);
 }
 
 void
-destroylock(Lock *l)
+runtime·destroylock(Lock *l)
 {
 	if(l->event != 0)
-		stdcall(CloseHandle, 1, l->event);
+		runtime·stdcall(runtime·CloseHandle, 1, l->event);
 }
 
 void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
 {
 	eventlock(&n->lock);
 }
 
 void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
 {
 	eventunlock(&n->lock);
 }
 
 void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
 {
 	eventlock(&n->lock);
 	eventunlock(&n->lock);	// Let other sleepers find out too.
 }
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
 {
 	USED(stk);
 	USED(g);	// assuming g = m->g0
 	USED(fn);	// assuming fn = mstart
 
-	stdcall(CreateThread, 6, 0, 0, tstart_stdcall, m, 0, 0);
+	runtime·stdcall(CreateThread, 6, 0, 0, runtime·tstart_stdcall, m, 0, 0);
 }
 
 // Called to initialize a new m (including the bootstrap m).
 void
-minit(void)
+runtime·minit(void)
 {
 }
 
 // Calling stdcall on os stack.
 #pragma textflag 7
 void *
-stdcall(void *fn, int32 count, ...)
+runtime·stdcall(void *fn, int32 count, ...)
 {
-	return stdcall_raw(fn, count, (uintptr*)(&count + 1));
+	return runtime·stdcall_raw(fn, count, (uintptr*)(&count + 1));
 }
 
 void
-syscall(StdcallParams *p)
+runtime·syscall(StdcallParams *p)
 {
 	uintptr a;
 
-	·entersyscall();
+	runtime·entersyscall();
 	// TODO(brainman): Move calls to SetLastError and GetLastError
 	// to stdcall_raw to speed up syscall.
 	a = 0;
-	stdcall_raw(SetLastError, 1, &a);
-	p->r = (uintptr)stdcall_raw((void*)p->fn, p->n, p->args);
-	p->err = (uintptr)stdcall_raw(GetLastError, 0, &a);
-	·exitsyscall();
+	runtime·stdcall_raw(runtime·SetLastError, 1, &a);
+	p->r = (uintptr)runtime·stdcall_raw((void*)p->fn, p->n, p->args);
+	p->err = (uintptr)runtime·stdcall_raw(runtime·GetLastError, 0, &a);
+	runtime·exitsyscall();
 }