diff --git a/src/pkg/runtime/386/asm.s b/src/pkg/runtime/386/asm.s
index 9df7fb1..bd88f0f 100644
--- a/src/pkg/runtime/386/asm.s
+++ b/src/pkg/runtime/386/asm.s
@@ -64,7 +64,7 @@
 	// create a new goroutine to start program
 	PUSHL	$mainstart(SB)	// entry
 	PUSHL	$0	// arg size
-	CALL	sys·newproc(SB)
+	CALL	runtime·newproc(SB)
 	POPL	AX
 	POPL	AX
 
@@ -137,7 +137,7 @@
  */
 
 // Called during function prolog when more stack is needed.
-TEXT sys·morestack(SB),7,$0
+TEXT runtime·morestack(SB),7,$0
 	// Cannot grow scheduler stack (m->g0).
 	MOVL	m, BX
 	MOVL	m_g0(BX), SI
@@ -215,7 +215,7 @@
 
 
 // Return point when leaving stack.
-TEXT sys·lessstack(SB), 7, $0
+TEXT runtime·lessstack(SB), 7, $0
 	// Save return value in m->cret
 	MOVL	m, BX
 	MOVL	AX, m_cret(BX)
@@ -260,7 +260,7 @@
 	SUBL	$5, (SP)	// return to CALL again
 	JMP	AX	// but first run the deferred function
 
-TEXT	sys·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
@@ -271,12 +271,12 @@
 	STOSL
 	RET
 
-TEXT	sys·getcallerpc+0(SB),7,$0
+TEXT	runtime·getcallerpc+0(SB),7,$0
 	MOVL	x+0(FP),AX		// addr of first arg
 	MOVL	-4(AX),AX		// get calling pc
 	RET
 
-TEXT	sys·setcallerpc+0(SB),7,$0
+TEXT	runtime·setcallerpc+0(SB),7,$0
 	MOVL	x+0(FP),AX		// addr of first arg
 	MOVL	x+4(FP), BX
 	MOVL	BX, -4(AX)		// set calling pc
diff --git a/src/pkg/runtime/386/closure.c b/src/pkg/runtime/386/closure.c
index 763fc45..24d1d03 100644
--- a/src/pkg/runtime/386/closure.c
+++ b/src/pkg/runtime/386/closure.c
@@ -9,7 +9,7 @@
 //	fn func(arg0, arg1, arg2 *ptr, callerpc uintptr, xxx) yyy,
 //	arg0, arg1, arg2 *ptr) (func(xxx) yyy)
 void
-sys·closure(int32 siz, byte *fn, byte *arg0)
+runtime·closure(int32 siz, byte *fn, byte *arg0)
 {
 	byte *p, *q, **ret;
 	int32 i, n;
diff --git a/src/pkg/runtime/386/traceback.c b/src/pkg/runtime/386/traceback.c
index 2f5c5e8..307980e 100644
--- a/src/pkg/runtime/386/traceback.c
+++ b/src/pkg/runtime/386/traceback.c
@@ -27,7 +27,7 @@
 
 	stk = (Stktop*)g->stackbase;
 	for(n=0; n<100; n++) {
-		if(pc == (uint64)sys·lessstack) {
+		if(pc == (uint64)runtime·lessstack) {
 			// printf("--\n");
 			// pop to earlier stack block
 			pc = (uintptr)stk->gobuf.pc;
@@ -68,7 +68,7 @@
 		for(i = 0; i < f->args; i++) {
 			if(i != 0)
 				prints(", ");
-			sys·printhex(((uint32*)sp)[i]);
+			runtime·printhex(((uint32*)sp)[i]);
 			if(i >= 4) {
 				prints(", ...");
 				break;
@@ -112,7 +112,7 @@
 	// now unwind n levels
 	stk = (Stktop*)g->stackbase;
 	while(n-- > 0) {
-		while(pc == (uintptr)sys·lessstack) {
+		while(pc == (uintptr)runtime·lessstack) {
 			pc = (uintptr)stk->gobuf.pc;
 			sp = stk->gobuf.sp;
 			stk = (Stktop*)stk->stackbase;
diff --git a/src/pkg/runtime/386/vlrt.c b/src/pkg/runtime/386/vlrt.c
index 093cca7..9087104 100755
--- a/src/pkg/runtime/386/vlrt.c
+++ b/src/pkg/runtime/386/vlrt.c
@@ -270,7 +270,7 @@
 }
 
 void
-sys·uint64div(Vlong n, Vlong d, Vlong q)
+runtime·uint64div(Vlong n, Vlong d, Vlong q)
 {
 	_divvu(&q, n, d);
 }
@@ -288,7 +288,7 @@
 }
 
 void
-sys·uint64mod(Vlong n, Vlong d, Vlong q)
+runtime·uint64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modvu(&q, n, d);
 }
@@ -334,7 +334,7 @@
 }
 
 void
-sys·int64div(Vlong n, Vlong d, Vlong q)
+runtime·int64div(Vlong n, Vlong d, Vlong q)
 {
 	_divv(&q, n, d);
 }
@@ -368,7 +368,7 @@
 }
 
 void
-sys·int64mod(Vlong n, Vlong d, Vlong q)
+runtime·int64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modv(&q, n, d);
 }
diff --git a/src/pkg/runtime/amd64/asm.s b/src/pkg/runtime/amd64/asm.s
index 87bc222..df81c0e 100644
--- a/src/pkg/runtime/amd64/asm.s
+++ b/src/pkg/runtime/amd64/asm.s
@@ -38,7 +38,7 @@
 	// create a new goroutine to start program
 	PUSHQ	$mainstart(SB)		// entry
 	PUSHQ	$0			// arg size
-	CALL	sys·newproc(SB)
+	CALL	runtime·newproc(SB)
 	POPQ	AX
 	POPQ	AX
 
@@ -108,7 +108,7 @@
  */
 
 // Called during function prolog when more stack is needed.
-TEXT sys·morestack(SB),7,$0
+TEXT runtime·morestack(SB),7,$0
 	// Called from f.
 	// Set m->morebuf to f's caller.
 	MOVQ	8(SP), AX	// f's caller's PC
@@ -166,7 +166,7 @@
 	RET
 
 // Return point when leaving stack.
-TEXT sys·lessstack(SB), 7, $0
+TEXT runtime·lessstack(SB), 7, $0
 	// Save return value in m->cret
 	MOVQ	AX, m_cret(m)
 
@@ -178,66 +178,66 @@
 	RET
 
 // morestack trampolines
-TEXT	sys·morestack00+0(SB),7,$0
+TEXT	runtime·morestack00+0(SB),7,$0
 	MOVQ	$0, AX
 	MOVQ	AX, m_moreframe(m)
-	MOVQ	$sys·morestack+0(SB), AX
+	MOVQ	$runtime·morestack+0(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack01+0(SB),7,$0
+TEXT	runtime·morestack01+0(SB),7,$0
 	SHLQ	$32, AX
 	MOVQ	AX, m_moreframe(m)
-	MOVQ	$sys·morestack+0(SB), AX
+	MOVQ	$runtime·morestack+0(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack10+0(SB),7,$0
+TEXT	runtime·morestack10+0(SB),7,$0
 	MOVLQZX	AX, AX
 	MOVQ	AX, m_moreframe(m)
-	MOVQ	$sys·morestack+0(SB), AX
+	MOVQ	$runtime·morestack+0(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack11+0(SB),7,$0
+TEXT	runtime·morestack11+0(SB),7,$0
 	MOVQ	AX, m_moreframe(m)
-	MOVQ	$sys·morestack+0(SB), AX
+	MOVQ	$runtime·morestack+0(SB), AX
 	JMP	AX
 
 // subcases of morestack01
 // with const of 8,16,...48
-TEXT	sys·morestack8(SB),7,$0
+TEXT	runtime·morestack8(SB),7,$0
 	PUSHQ	$1
-	MOVQ	$sys·morestackx(SB), AX
+	MOVQ	$runtime·morestackx(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack16(SB),7,$0
+TEXT	runtime·morestack16(SB),7,$0
 	PUSHQ	$2
-	MOVQ	$sys·morestackx(SB), AX
+	MOVQ	$runtime·morestackx(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack24(SB),7,$0
+TEXT	runtime·morestack24(SB),7,$0
 	PUSHQ	$3
-	MOVQ	$sys·morestackx(SB), AX
+	MOVQ	$runtime·morestackx(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack32(SB),7,$0
+TEXT	runtime·morestack32(SB),7,$0
 	PUSHQ	$4
-	MOVQ	$sys·morestackx(SB), AX
+	MOVQ	$runtime·morestackx(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack40(SB),7,$0
+TEXT	runtime·morestack40(SB),7,$0
 	PUSHQ	$5
-	MOVQ	$sys·morestackx(SB), AX
+	MOVQ	$runtime·morestackx(SB), AX
 	JMP	AX
 
-TEXT	sys·morestack48(SB),7,$0
+TEXT	runtime·morestack48(SB),7,$0
 	PUSHQ	$6
-	MOVQ	$sys·morestackx(SB), AX
+	MOVQ	$runtime·morestackx(SB), AX
 	JMP	AX
 
-TEXT	sys·morestackx(SB),7,$0
+TEXT	runtime·morestackx(SB),7,$0
 	POPQ	AX
 	SHLQ	$35, AX
 	MOVQ	AX, m_moreframe(m)
-	MOVQ	$sys·morestack(SB), AX
+	MOVQ	$runtime·morestack(SB), AX
 	JMP	AX
 
 // bool cas(int32 *val, int32 old, int32 new)
diff --git a/src/pkg/runtime/amd64/closure.c b/src/pkg/runtime/amd64/closure.c
index 21ac7c3..44c399b 100644
--- a/src/pkg/runtime/amd64/closure.c
+++ b/src/pkg/runtime/amd64/closure.c
@@ -9,7 +9,7 @@
 //	fn func(arg0, arg1, arg2 *ptr, callerpc uintptr, xxx) yyy,
 //	arg0, arg1, arg2 *ptr) (func(xxx) yyy)
 void
-sys·closure(int32 siz, byte *fn, byte *arg0)
+runtime·closure(int32 siz, byte *fn, byte *arg0)
 {
 	byte *p, *q, **ret;
 	int32 i, n;
diff --git a/src/pkg/runtime/amd64/traceback.c b/src/pkg/runtime/amd64/traceback.c
index 40e84f5..7b0306f 100644
--- a/src/pkg/runtime/amd64/traceback.c
+++ b/src/pkg/runtime/amd64/traceback.c
@@ -24,7 +24,7 @@
 
 	stk = (Stktop*)g->stackbase;
 	for(n=0; n<100; n++) {
-		if(pc == (uint64)sys·lessstack) {
+		if(pc == (uint64)runtime·lessstack) {
 			// pop to earlier stack block
 			// printf("-- stack jump %p => %p\n", sp, stk->gobuf.sp);
 			pc = (uintptr)stk->gobuf.pc;
@@ -65,7 +65,7 @@
 		for(i = 0; i < f->args; i++) {
 			if(i != 0)
 				prints(", ");
-			sys·printhex(((uint32*)sp)[i]);
+			runtime·printhex(((uint32*)sp)[i]);
 			if(i >= 4) {
 				prints(", ...");
 				break;
@@ -109,7 +109,7 @@
 	// now unwind n levels
 	stk = (Stktop*)g->stackbase;
 	while(n-- > 0) {
-		while(pc == (uintptr)sys·lessstack) {
+		while(pc == (uintptr)runtime·lessstack) {
 			pc = (uintptr)stk->gobuf.pc;
 			sp = stk->gobuf.sp;
 			stk = (Stktop*)stk->stackbase;
diff --git a/src/pkg/runtime/arm/asm.s b/src/pkg/runtime/arm/asm.s
index 07230e5..4052bcc 100644
--- a/src/pkg/runtime/arm/asm.s
+++ b/src/pkg/runtime/arm/asm.s
@@ -49,7 +49,7 @@
 	MOVW.W	R0, -4(R13)
 	MOVW	$0, R0
 	MOVW.W	R0, -4(R13)	// push $0 as guard
-	BL	sys·newproc(SB)
+	BL	runtime·newproc(SB)
 	MOVW	$12(R13), R13	// pop args and LR
 
 	// start this M
@@ -132,7 +132,7 @@
 // R2 arg size
 // R3 prolog's LR
 // using frame size $-4 means do not save LR on stack.
-TEXT sys·morestack(SB),7,$-4
+TEXT runtime·morestack(SB),7,$-4
 	// Cannot grow scheduler stack (m->g0).
 	MOVW	m_g0(m), R4
 	CMP	g, R4
@@ -195,7 +195,7 @@
 
 // Return point when leaving stack.
 // using frame size $-4 means do not save LR on stack.
-TEXT sys·lessstack(SB), 7, $-4
+TEXT runtime·lessstack(SB), 7, $-4
 	// Save return value in m->cret
 	MOVW	R0, m_cret(m)
 
@@ -209,9 +209,9 @@
 // R2 is argsize
 // R3 is LR for f (f's caller's PC)
 // using frame size $-4 means do not save LR on stack.
-TEXT sys·morestackx(SB), 7, $-4
+TEXT runtime·morestackx(SB), 7, $-4
 	MOVW	$0, R1		// set frame size
-	B	sys·morestack(SB)
+	B	runtime·morestack(SB)
 
 
 // void jmpdefer(fn, sp);
@@ -227,7 +227,7 @@
 	MOVW	$-4(R1), SP	// correct for sp pointing to arg0, past stored lr
 	B		(R0)
 
-TEXT	sys·memclr(SB),7,$20
+TEXT	runtime·memclr(SB),7,$20
 	MOVW	0(FP), R0
 	MOVW	$0, R1		// c = 0
 	MOVW	R1, -16(SP)
@@ -240,13 +240,13 @@
 	MOVW	-4(SP), g
 	RET
 
-TEXT	sys·getcallerpc+0(SB),7,$0
+TEXT	runtime·getcallerpc+0(SB),7,$0
 	BL	abort(SB)
 //	MOVL	x+0(FP),AX		// addr of first arg
 //	MOVL	-4(AX),AX		// get calling pc
 //	RET
 
-TEXT	sys·setcallerpc+0(SB),7,$0
+TEXT	runtime·setcallerpc+0(SB),7,$0
 	BL	abort(SB)
 //	MOVL	x+0(FP),AX		// addr of first arg
 //	MOVL	x+4(FP), BX
diff --git a/src/pkg/runtime/arm/traceback.c b/src/pkg/runtime/arm/traceback.c
index 3b862c3..455f21e 100644
--- a/src/pkg/runtime/arm/traceback.c
+++ b/src/pkg/runtime/arm/traceback.c
@@ -65,7 +65,7 @@
 // 		for(i = 0; i < f->args; i++) {
 // 			if(i != 0)
 // 				prints(", ");
-// 			sys·printhex(((uint32*)sp)[i]);
+// 			runtime·printhex(((uint32*)sp)[i]);
 // 			if(i >= 4) {
 // 				prints(", ...");
 // 				break;
diff --git a/src/pkg/runtime/arm/vlrt.c b/src/pkg/runtime/arm/vlrt.c
index 8e3aa624..b8b4cff 100755
--- a/src/pkg/runtime/arm/vlrt.c
+++ b/src/pkg/runtime/arm/vlrt.c
@@ -143,7 +143,7 @@
 }
 
 void
-sys·float64toint64(double d, Vlong y)
+runtime·float64toint64(double d, Vlong y)
 {
 	_d2v(&y, d);
 }
@@ -169,7 +169,7 @@
 }
 
 void
-sys·int64tofloat64(Vlong y, double d)
+runtime·int64tofloat64(Vlong y, double d)
 {
 	d = _v2d(y);
 }
@@ -250,7 +250,7 @@
 }
 
 void
-sys·uint64div(Vlong n, Vlong d, Vlong q)
+runtime·uint64div(Vlong n, Vlong d, Vlong q)
 {
 	_divvu(&q, n, d);
 }
@@ -268,7 +268,7 @@
 }
 
 void
-sys·uint64mod(Vlong n, Vlong d, Vlong q)
+runtime·uint64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modvu(&q, n, d);
 }
@@ -313,7 +313,7 @@
 }
 
 void
-sys·int64div(Vlong n, Vlong d, Vlong q)
+runtime·int64div(Vlong n, Vlong d, Vlong q)
 {
 	_divv(&q, n, d);
 }
@@ -340,7 +340,7 @@
 }
 
 void
-sys·int64mod(Vlong n, Vlong d, Vlong q)
+runtime·int64mod(Vlong n, Vlong d, Vlong q)
 {
 	_modv(&q, n, d);
 }
diff --git a/src/pkg/runtime/cgocall.c b/src/pkg/runtime/cgocall.c
index 70382ce..ce6d7db 100644
--- a/src/pkg/runtime/cgocall.c
+++ b/src/pkg/runtime/cgocall.c
@@ -7,8 +7,8 @@
 
 void *initcgo;	/* filled in by dynamic linker when Cgo is available */
 int64 ncgocall;
-void sys·entersyscall(void);
-void sys·exitsyscall(void);
+void runtime·entersyscall(void);
+void runtime·exitsyscall(void);
 
 void
 cgocall(void (*fn)(void*), void *arg)
@@ -24,9 +24,9 @@
 	 * M to run goroutines while we are in the
 	 * foreign code.
 	 */
-	sys·entersyscall();
+	runtime·entersyscall();
 	runcgo(fn, arg);
-	sys·exitsyscall();
+	runtime·exitsyscall();
 	return;
 }
 
diff --git a/src/pkg/runtime/chan.c b/src/pkg/runtime/chan.c
index 7611023..04566b4 100644
--- a/src/pkg/runtime/chan.c
+++ b/src/pkg/runtime/chan.c
@@ -97,7 +97,7 @@
 
 	if(elem->alg >= nelem(algarray)) {
 		printf("chan(alg=%d)\n", elem->alg);
-		throw("sys·makechan: unsupported elem type");
+		throw("runtime·makechan: unsupported elem type");
 	}
 
 	c = mal(sizeof(*c));
@@ -128,15 +128,15 @@
 
 	if(debug) {
 		prints("makechan: chan=");
-		sys·printpointer(c);
+		runtime·printpointer(c);
 		prints("; elemsize=");
-		sys·printint(elem->size);
+		runtime·printint(elem->size);
 		prints("; elemalg=");
-		sys·printint(elem->alg);
+		runtime·printint(elem->alg);
 		prints("; elemalign=");
-		sys·printint(elem->align);
+		runtime·printint(elem->align);
 		prints("; dataqsiz=");
-		sys·printint(c->dataqsiz);
+		runtime·printint(c->dataqsiz);
 		prints("\n");
 	}
 
@@ -145,7 +145,7 @@
 
 // makechan(elemsize uint32, elemalg uint32, hint uint32) (hchan *chan any);
 void
-sys·makechan(Type *elem, uint32 hint, Hchan *ret)
+runtime·makechan(Type *elem, uint32 hint, Hchan *ret)
 {
 	ret = makechan(elem, hint);
 	FLUSH(&ret);
@@ -178,7 +178,7 @@
 
 	if(debug) {
 		prints("chansend: chan=");
-		sys·printpointer(c);
+		runtime·printpointer(c);
 		prints("; elem=");
 		c->elemalg->print(c->elemsize, ep);
 		prints("\n");
@@ -281,7 +281,7 @@
 
 	if(debug) {
 		prints("chanrecv: chan=");
-		sys·printpointer(c);
+		runtime·printpointer(c);
 		prints("\n");
 	}
 
@@ -379,7 +379,7 @@
 
 // chansend1(hchan *chan any, elem any);
 void
-sys·chansend1(Hchan* c, ...)
+runtime·chansend1(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae;
@@ -391,7 +391,7 @@
 
 // chansend2(hchan *chan any, elem any) (pres bool);
 void
-sys·chansend2(Hchan* c, ...)
+runtime·chansend2(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae, *ap;
@@ -406,7 +406,7 @@
 
 // chanrecv1(hchan *chan any) (elem any);
 void
-sys·chanrecv1(Hchan* c, ...)
+runtime·chanrecv1(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae;
@@ -419,7 +419,7 @@
 
 // chanrecv2(hchan *chan any) (elem any, pres bool);
 void
-sys·chanrecv2(Hchan* c, ...)
+runtime·chanrecv2(Hchan* c, ...)
 {
 	int32 o;
 	byte *ae, *ap;
@@ -434,7 +434,7 @@
 
 // newselect(size uint32) (sel *byte);
 void
-sys·newselect(int32 size, ...)
+runtime·newselect(int32 size, ...)
 {
 	int32 n, o;
 	Select **selp;
@@ -462,16 +462,16 @@
 	*selp = sel;
 	if(debug) {
 		prints("newselect s=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" size=");
-		sys·printint(size);
+		runtime·printint(size);
 		prints("\n");
 	}
 }
 
 // selectsend(sel *byte, hchan *chan any, elem any) (selected bool);
 void
-sys·selectsend(Select *sel, Hchan *c, ...)
+runtime·selectsend(Select *sel, Hchan *c, ...)
 {
 	int32 i, eo;
 	Scase *cas;
@@ -491,7 +491,7 @@
 		sel->scase[i] = cas;
 	}
 
-	cas->pc = sys·getcallerpc(&sel);
+	cas->pc = runtime·getcallerpc(&sel);
 	cas->chan = c;
 
 	eo = rnd(sizeof(sel), sizeof(c));
@@ -504,22 +504,22 @@
 
 	if(debug) {
 		prints("selectsend s=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" pc=");
-		sys·printpointer(cas->pc);
+		runtime·printpointer(cas->pc);
 		prints(" chan=");
-		sys·printpointer(cas->chan);
+		runtime·printpointer(cas->chan);
 		prints(" po=");
-		sys·printint(cas->so);
+		runtime·printint(cas->so);
 		prints(" send=");
-		sys·printint(cas->send);
+		runtime·printint(cas->send);
 		prints("\n");
 	}
 }
 
 // selectrecv(sel *byte, hchan *chan any, elem *any) (selected bool);
 void
-sys·selectrecv(Select *sel, Hchan *c, ...)
+runtime·selectrecv(Select *sel, Hchan *c, ...)
 {
 	int32 i, eo;
 	Scase *cas;
@@ -537,7 +537,7 @@
 		cas = mal(sizeof *cas);
 		sel->scase[i] = cas;
 	}
-	cas->pc = sys·getcallerpc(&sel);
+	cas->pc = runtime·getcallerpc(&sel);
 	cas->chan = c;
 
 	eo = rnd(sizeof(sel), sizeof(c));
@@ -548,15 +548,15 @@
 
 	if(debug) {
 		prints("selectrecv s=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" pc=");
-		sys·printpointer(cas->pc);
+		runtime·printpointer(cas->pc);
 		prints(" chan=");
-		sys·printpointer(cas->chan);
+		runtime·printpointer(cas->chan);
 		prints(" so=");
-		sys·printint(cas->so);
+		runtime·printint(cas->so);
 		prints(" send=");
-		sys·printint(cas->send);
+		runtime·printint(cas->send);
 		prints("\n");
 	}
 }
@@ -564,7 +564,7 @@
 
 // selectdefaul(sel *byte) (selected bool);
 void
-sys·selectdefault(Select *sel, ...)
+runtime·selectdefault(Select *sel, ...)
 {
 	int32 i;
 	Scase *cas;
@@ -578,7 +578,7 @@
 		cas = mal(sizeof *cas);
 		sel->scase[i] = cas;
 	}
-	cas->pc = sys·getcallerpc(&sel);
+	cas->pc = runtime·getcallerpc(&sel);
 	cas->chan = nil;
 
 	cas->so = rnd(sizeof(sel), Structrnd);
@@ -587,20 +587,20 @@
 
 	if(debug) {
 		prints("selectdefault s=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" pc=");
-		sys·printpointer(cas->pc);
+		runtime·printpointer(cas->pc);
 		prints(" so=");
-		sys·printint(cas->so);
+		runtime·printint(cas->so);
 		prints(" send=");
-		sys·printint(cas->send);
+		runtime·printint(cas->send);
 		prints("\n");
 	}
 }
 
 // selectgo(sel *byte);
 void
-sys·selectgo(Select *sel)
+runtime·selectgo(Select *sel)
 {
 	uint32 p, o, i;
 	Scase *cas, *dfl;
@@ -611,7 +611,7 @@
 
 	if(debug) {
 		prints("selectgo: sel=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints("\n");
 	}
 
@@ -768,15 +768,15 @@
 
 	if(debug) {
 		prints("wait-return: sel=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" c=");
-		sys·printpointer(c);
+		runtime·printpointer(c);
 		prints(" cas=");
-		sys·printpointer(cas);
+		runtime·printpointer(cas);
 		prints(" send=");
-		sys·printint(cas->send);
+		runtime·printint(cas->send);
 		prints(" o=");
-		sys·printint(o);
+		runtime·printint(o);
 		prints("\n");
 	}
 
@@ -818,11 +818,11 @@
 	// recv path to wakeup the sender (sg)
 	if(debug) {
 		prints("gotr: sel=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" c=");
-		sys·printpointer(c);
+		runtime·printpointer(c);
 		prints(" o=");
-		sys·printint(o);
+		runtime·printint(o);
 		prints("\n");
 	}
 	if(cas->u.elemp != nil)
@@ -843,11 +843,11 @@
 	// send path to wakeup the receiver (sg)
 	if(debug) {
 		prints("gots: sel=");
-		sys·printpointer(sel);
+		runtime·printpointer(sel);
 		prints(" c=");
-		sys·printpointer(c);
+		runtime·printpointer(c);
 		prints(" o=");
-		sys·printint(o);
+		runtime·printint(o);
 		prints("\n");
 	}
 	if(c->closed & Wclosed)
@@ -869,14 +869,14 @@
 	}
 	unlock(&chanlock);
 
-	sys·setcallerpc(&sel, cas->pc);
+	runtime·setcallerpc(&sel, cas->pc);
 	as = (byte*)&sel + cas->so;
 	*as = true;
 }
 
 // closechan(sel *byte);
 void
-sys·closechan(Hchan *c)
+runtime·closechan(Hchan *c)
 {
 	SudoG *sg;
 	G* gp;
@@ -913,7 +913,7 @@
 void
 chanclose(Hchan *c)
 {
-	sys·closechan(c);
+	runtime·closechan(c);
 }
 
 bool
@@ -937,7 +937,7 @@
 
 // closedchan(sel *byte) bool;
 void
-sys·closedchan(Hchan *c, bool closed)
+runtime·closedchan(Hchan *c, bool closed)
 {
 	closed = chanclosed(c);
 	FLUSH(&closed);
diff --git a/src/pkg/runtime/darwin/386/sys.s b/src/pkg/runtime/darwin/386/sys.s
index 6178470..719fcbb 100644
--- a/src/pkg/runtime/darwin/386/sys.s
+++ b/src/pkg/runtime/darwin/386/sys.s
@@ -35,7 +35,7 @@
 	CALL	notok(SB)
 	RET
 
-TEXT sys·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVL	$197, AX
 	INT	$0x80
 	JAE	2(PC)
diff --git a/src/pkg/runtime/darwin/amd64/sys.s b/src/pkg/runtime/darwin/amd64/sys.s
index b8f0464..c39c44a 100644
--- a/src/pkg/runtime/darwin/amd64/sys.s
+++ b/src/pkg/runtime/darwin/amd64/sys.s
@@ -63,7 +63,7 @@
 	SYSCALL
 	INT $3	// not reached
 
-TEXT	sys·mmap(SB),7,$-8
+TEXT	runtime·mmap(SB),7,$-8
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVL	16(SP), SI		// arg 2 len
 	MOVL	20(SP), DX		// arg 3 prot
@@ -81,7 +81,7 @@
 	MOVQ	BP, (BP)
 	RET
 
-TEXT	sys·memclr(SB),7,$-8
+TEXT	runtime·memclr(SB),7,$-8
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVL	16(SP), CX		// arg 2 count
 	ADDL	$7, CX
@@ -92,12 +92,12 @@
 	STOSQ
 	RET
 
-TEXT	sys·getcallerpc+0(SB),7,$0
+TEXT	runtime·getcallerpc+0(SB),7,$0
 	MOVQ	x+0(FP),AX		// addr of first arg
 	MOVQ	-8(AX),AX		// get calling pc
 	RET
 
-TEXT	sys·setcallerpc+0(SB),7,$0
+TEXT	runtime·setcallerpc+0(SB),7,$0
 	MOVQ	x+0(FP),AX		// addr of first arg
 	MOVQ	x+8(FP), BX
 	MOVQ	BX, -8(AX)		// set calling pc
diff --git a/src/pkg/runtime/darwin/thread.c b/src/pkg/runtime/darwin/thread.c
index 7e6d7c2..bf66f86 100644
--- a/src/pkg/runtime/darwin/thread.c
+++ b/src/pkg/runtime/darwin/thread.c
@@ -245,7 +245,7 @@
 		prints("send:\t");
 		for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
 			prints(" ");
-			sys·printpointer((void*)p[i]);
+			runtime·printpointer((void*)p[i]);
 			if(i%8 == 7)
 				prints("\n\t");
 		}
@@ -258,7 +258,7 @@
 	if(ret != 0){
 		if(DebugMach){
 			prints("mach_msg error ");
-			sys·printint(ret);
+			runtime·printint(ret);
 			prints("\n");
 		}
 		return ret;
@@ -269,7 +269,7 @@
 		prints("recv:\t");
 		for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
 			prints(" ");
-			sys·printpointer((void*)p[i]);
+			runtime·printpointer((void*)p[i]);
 			if(i%8 == 7)
 				prints("\n\t");
 		}
@@ -280,9 +280,9 @@
 	if(h->msgh_id != id+Reply){
 		if(DebugMach){
 			prints("mach_msg reply id mismatch ");
-			sys·printint(h->msgh_id);
+			runtime·printint(h->msgh_id);
 			prints(" != ");
-			sys·printint(id+Reply);
+			runtime·printint(id+Reply);
 			prints("\n");
 		}
 		return -303;	// MIG_REPLY_MISMATCH
@@ -299,7 +299,7 @@
 	&& !(h->msgh_bits & MACH_MSGH_BITS_COMPLEX)){
 		if(DebugMach){
 			prints("mig result ");
-			sys·printint(c->code);
+			runtime·printint(c->code);
 			prints("\n");
 		}
 		return c->code;
@@ -308,9 +308,9 @@
 	if(h->msgh_size != rxsize){
 		if(DebugMach){
 			prints("mach_msg reply size mismatch ");
-			sys·printint(h->msgh_size);
+			runtime·printint(h->msgh_size);
 			prints(" != ");
-			sys·printint(rxsize);
+			runtime·printint(rxsize);
 			prints("\n");
 		}
 		return -307;	// MIG_ARRAY_TOO_LARGE
diff --git a/src/pkg/runtime/hashmap.c b/src/pkg/runtime/hashmap.c
index b9594141..870274a 100644
--- a/src/pkg/runtime/hashmap.c
+++ b/src/pkg/runtime/hashmap.c
@@ -679,12 +679,12 @@
 
 	if(keyalg >= nelem(algarray) || algarray[keyalg].hash == nohash) {
 		printf("map(keyalg=%d)\n", keyalg);
-		throw("sys·makemap: unsupported map key type");
+		throw("runtime·makemap: unsupported map key type");
 	}
 
 	if(valalg >= nelem(algarray)) {
 		printf("map(valalg=%d)\n", valalg);
-		throw("sys·makemap: unsupported map value type");
+		throw("runtime·makemap: unsupported map value type");
 	}
 
 	h = mal(sizeof(*h));
@@ -733,7 +733,7 @@
 
 // makemap(key, val *Type, hint uint32) (hmap *map[any]any);
 void
-sys·makemap(Type *key, Type *val, uint32 hint, Hmap *ret)
+runtime·makemap(Type *key, Type *val, uint32 hint, Hmap *ret)
 {
 	ret = makemap(key, val, hint);
 	FLUSH(&ret);
@@ -756,7 +756,7 @@
 
 // mapaccess1(hmap *map[any]any, key any) (val any);
 void
-sys·mapaccess1(Hmap *h, ...)
+runtime·mapaccess1(Hmap *h, ...)
 {
 	byte *ak, *av;
 	bool pres;
@@ -766,24 +766,24 @@
 
 	mapaccess(h, ak, av, &pres);
 	if(!pres)
-		throw("sys·mapaccess1: key not in map");
+		throw("runtime·mapaccess1: key not in map");
 
 	if(debug) {
-		prints("sys·mapaccess1: map=");
-		sys·printpointer(h);
+		prints("runtime·mapaccess1: map=");
+		runtime·printpointer(h);
 		prints("; key=");
 		h->keyalg->print(h->keysize, ak);
 		prints("; val=");
 		h->valalg->print(h->valsize, av);
 		prints("; pres=");
-		sys·printbool(pres);
+		runtime·printbool(pres);
 		prints("\n");
 	}
 }
 
 // mapaccess2(hmap *map[any]any, key any) (val any, pres bool);
 void
-sys·mapaccess2(Hmap *h, ...)
+runtime·mapaccess2(Hmap *h, ...)
 {
 	byte *ak, *av, *ap;
 
@@ -794,14 +794,14 @@
 	mapaccess(h, ak, av, ap);
 
 	if(debug) {
-		prints("sys·mapaccess2: map=");
-		sys·printpointer(h);
+		prints("runtime·mapaccess2: map=");
+		runtime·printpointer(h);
 		prints("; key=");
 		h->keyalg->print(h->keysize, ak);
 		prints("; val=");
 		h->valalg->print(h->valsize, av);
 		prints("; pres=");
-		sys·printbool(*ap);
+		runtime·printbool(*ap);
 		prints("\n");
 	}
 }
@@ -824,22 +824,22 @@
 
 	if(debug) {
 		prints("mapassign: map=");
-		sys·printpointer(h);
+		runtime·printpointer(h);
 		prints("; key=");
 		h->keyalg->print(h->keysize, ak);
 		prints("; val=");
 		h->valalg->print(h->valsize, av);
 		prints("; hit=");
-		sys·printint(hit);
+		runtime·printint(hit);
 		prints("; res=");
-		sys·printpointer(res);
+		runtime·printpointer(res);
 		prints("\n");
 	}
 }
 
 // mapassign1(hmap *map[any]any, key any, val any);
 void
-sys·mapassign1(Hmap *h, ...)
+runtime·mapassign1(Hmap *h, ...)
 {
 	byte *ak, *av;
 
@@ -851,7 +851,7 @@
 
 // mapassign2(hmap *map[any]any, key any, val any, pres bool);
 void
-sys·mapassign2(Hmap *h, ...)
+runtime·mapassign2(Hmap *h, ...)
 {
 	byte *ak, *av, *ap;
 
@@ -866,7 +866,7 @@
 
 	if(debug) {
 		prints("mapassign2: map=");
-		sys·printpointer(h);
+		runtime·printpointer(h);
 		prints("; key=");
 		h->keyalg->print(h->keysize, ak);
 		prints("\n");
@@ -875,7 +875,7 @@
 
 // mapiterinit(hmap *map[any]any, hiter *any);
 void
-sys·mapiterinit(Hmap *h, struct hash_iter *it)
+runtime·mapiterinit(Hmap *h, struct hash_iter *it)
 {
 	if(h == nil) {
 		it->data = nil;
@@ -884,12 +884,12 @@
 	hash_iter_init(h, it);
 	it->data = hash_next(it);
 	if(debug) {
-		prints("sys·mapiterinit: map=");
-		sys·printpointer(h);
+		prints("runtime·mapiterinit: map=");
+		runtime·printpointer(h);
 		prints("; iter=");
-		sys·printpointer(it);
+		runtime·printpointer(it);
 		prints("; data=");
-		sys·printpointer(it->data);
+		runtime·printpointer(it->data);
 		prints("\n");
 	}
 }
@@ -900,20 +900,20 @@
 	struct hash_iter *it;
 
 	it = mal(sizeof *it);
-	sys·mapiterinit(h, it);
+	runtime·mapiterinit(h, it);
 	return it;
 }
 
 // mapiternext(hiter *any);
 void
-sys·mapiternext(struct hash_iter *it)
+runtime·mapiternext(struct hash_iter *it)
 {
 	it->data = hash_next(it);
 	if(debug) {
-		prints("sys·mapiternext: iter=");
-		sys·printpointer(it);
+		prints("runtime·mapiternext: iter=");
+		runtime·printpointer(it);
 		prints("; data=");
-		sys·printpointer(it->data);
+		runtime·printpointer(it->data);
 		prints("\n");
 	}
 }
@@ -921,12 +921,12 @@
 void
 mapiternext(struct hash_iter *it)
 {
-	sys·mapiternext(it);
+	runtime·mapiternext(it);
 }
 
 // mapiter1(hiter *any) (key any);
 void
-sys·mapiter1(struct hash_iter *it, ...)
+runtime·mapiter1(struct hash_iter *it, ...)
 {
 	Hmap *h;
 	byte *ak, *res;
@@ -936,15 +936,15 @@
 
 	res = it->data;
 	if(res == nil)
-		throw("sys·mapiter2: key:val nil pointer");
+		throw("runtime·mapiter2: key:val nil pointer");
 
 	h->keyalg->copy(h->keysize, ak, res);
 
 	if(debug) {
 		prints("mapiter2: iter=");
-		sys·printpointer(it);
+		runtime·printpointer(it);
 		prints("; map=");
-		sys·printpointer(h);
+		runtime·printpointer(h);
 		prints("\n");
 	}
 }
@@ -965,7 +965,7 @@
 
 // mapiter2(hiter *any) (key any, val any);
 void
-sys·mapiter2(struct hash_iter *it, ...)
+runtime·mapiter2(struct hash_iter *it, ...)
 {
 	Hmap *h;
 	byte *ak, *av, *res;
@@ -976,16 +976,16 @@
 
 	res = it->data;
 	if(res == nil)
-		throw("sys·mapiter2: key:val nil pointer");
+		throw("runtime·mapiter2: key:val nil pointer");
 
 	h->keyalg->copy(h->keysize, ak, res);
 	h->valalg->copy(h->valsize, av, res+h->datavo);
 
 	if(debug) {
 		prints("mapiter2: iter=");
-		sys·printpointer(it);
+		runtime·printpointer(it);
 		prints("; map=");
-		sys·printpointer(h);
+		runtime·printpointer(h);
 		prints("\n");
 	}
 }
diff --git a/src/pkg/runtime/hashmap.h b/src/pkg/runtime/hashmap.h
index e8bcfab..984b80c 100644
--- a/src/pkg/runtime/hashmap.h
+++ b/src/pkg/runtime/hashmap.h
@@ -66,7 +66,7 @@
 #define	malloc		mal
 #define	free(a)		USED(a)
 #define	offsetof(s,m)	(uint32)(&(((s*)0)->m))
-#define	memset(a,b,c)	sys·memclr((byte*)(a), (uint32)(c))
+#define	memset(a,b,c)	runtime·memclr((byte*)(a), (uint32)(c))
 #define	memmove(a,b,c)	mmov((byte*)(a),(byte*)(b),(uint32)(c))
 #define	memcpy(a,b,c)	mcpy((byte*)(a),(byte*)(b),(uint32)(c))
 #define	assert(a)	if(!(a)) throw("assert")
diff --git a/src/pkg/runtime/iface.c b/src/pkg/runtime/iface.c
index 6bd2f93..7ae2a6d 100644
--- a/src/pkg/runtime/iface.c
+++ b/src/pkg/runtime/iface.c
@@ -171,7 +171,7 @@
 // ifaceT2I(sigi *byte, sigt *byte, elem any) (ret Iface);
 #pragma textflag 7
 void
-sys·ifaceT2I(InterfaceType *inter, Type *t, ...)
+runtime·ifaceT2I(InterfaceType *inter, Type *t, ...)
 {
 	byte *elem;
 	Iface *ret;
@@ -187,7 +187,7 @@
 // ifaceT2E(sigt *byte, elem any) (ret Eface);
 #pragma textflag 7
 void
-sys·ifaceT2E(Type *t, ...)
+runtime·ifaceT2E(Type *t, ...)
 {
 	byte *elem;
 	Eface *ret;
@@ -204,7 +204,7 @@
 // ifaceI2T(sigt *byte, iface any) (ret any);
 #pragma textflag 7
 void
-sys·ifaceI2T(Type *t, Iface i, ...)
+runtime·ifaceI2T(Type *t, Iface i, ...)
 {
 	Itab *tab;
 	byte *ret;
@@ -225,7 +225,7 @@
 // ifaceI2T2(sigt *byte, i Iface) (ret any, ok bool);
 #pragma textflag 7
 void
-sys·ifaceI2T2(Type *t, Iface i, ...)
+runtime·ifaceI2T2(Type *t, Iface i, ...)
 {
 	byte *ret;
 	bool *ok;
@@ -237,7 +237,7 @@
 
 	if(i.tab == nil || i.tab->type != t) {
 		*ok = false;
-		sys·memclr(ret, wid);
+		runtime·memclr(ret, wid);
 		return;
 	}
 
@@ -248,7 +248,7 @@
 // ifaceE2T(sigt *byte, e Eface) (ret any);
 #pragma textflag 7
 void
-sys·ifaceE2T(Type *t, Eface e, ...)
+runtime·ifaceE2T(Type *t, Eface e, ...)
 {
 	byte *ret;
 
@@ -267,7 +267,7 @@
 // ifaceE2T2(sigt *byte, iface any) (ret any, ok bool);
 #pragma textflag 7
 void
-sys·ifaceE2T2(Type *t, Eface e, ...)
+runtime·ifaceE2T2(Type *t, Eface e, ...)
 {
 	byte *ret;
 	bool *ok;
@@ -279,7 +279,7 @@
 
 	if(t != e.type) {
 		*ok = false;
-		sys·memclr(ret, wid);
+		runtime·memclr(ret, wid);
 		return;
 	}
 
@@ -290,7 +290,7 @@
 // ifaceI2E(sigi *byte, iface any) (ret any);
 // TODO(rsc): Move to back end, throw away function.
 void
-sys·ifaceI2E(Iface i, Eface ret)
+runtime·ifaceI2E(Iface i, Eface ret)
 {
 	Itab *tab;
 
@@ -307,7 +307,7 @@
 // called only for implicit (no type assertion) conversions.
 // converting nil is okay.
 void
-sys·ifaceI2I(InterfaceType *inter, Iface i, Iface ret)
+runtime·ifaceI2I(InterfaceType *inter, Iface i, Iface ret)
 {
 	Itab *tab;
 
@@ -330,7 +330,7 @@
 // called only for explicit conversions (with type assertion).
 // converting nil is not okay.
 void
-sys·ifaceI2Ix(InterfaceType *inter, Iface i, Iface ret)
+runtime·ifaceI2Ix(InterfaceType *inter, Iface i, Iface ret)
 {
 	Itab *tab;
 
@@ -350,7 +350,7 @@
 
 // ifaceI2I2(sigi *byte, iface any) (ret any, ok bool);
 void
-sys·ifaceI2I2(InterfaceType *inter, Iface i, Iface ret, bool ok)
+runtime·ifaceI2I2(InterfaceType *inter, Iface i, Iface ret, bool ok)
 {
 	Itab *tab;
 
@@ -397,14 +397,14 @@
 // ifaceE2I(sigi *byte, iface any) (ret any);
 // Called only for explicit conversions (with type assertion).
 void
-sys·ifaceE2I(InterfaceType *inter, Eface e, Iface ret)
+runtime·ifaceE2I(InterfaceType *inter, Eface e, Iface ret)
 {
 	ifaceE2I(inter, e, &ret);
 }
 
 // ifaceE2I2(sigi *byte, iface any) (ret any, ok bool);
 void
-sys·ifaceE2I2(InterfaceType *inter, Eface e, Iface ret, bool ok)
+runtime·ifaceE2I2(InterfaceType *inter, Eface e, Iface ret, bool ok)
 {
 	Type *t;
 
@@ -508,7 +508,7 @@
 
 // ifaceeq(i1 any, i2 any) (ret bool);
 void
-sys·ifaceeq(Iface i1, Iface i2, bool ret)
+runtime·ifaceeq(Iface i1, Iface i2, bool ret)
 {
 	ret = ifaceeq(i1, i2);
 	FLUSH(&ret);
@@ -516,7 +516,7 @@
 
 // efaceeq(i1 any, i2 any) (ret bool)
 void
-sys·efaceeq(Eface e1, Eface e2, bool ret)
+runtime·efaceeq(Eface e1, Eface e2, bool ret)
 {
 	ret = efaceeq(e1, e2);
 	FLUSH(&ret);
@@ -524,7 +524,7 @@
 
 // ifacethash(i1 any) (ret uint32);
 void
-sys·ifacethash(Iface i1, uint32 ret)
+runtime·ifacethash(Iface i1, uint32 ret)
 {
 	Itab *tab;
 
@@ -537,7 +537,7 @@
 
 // efacethash(e1 any) (ret uint32)
 void
-sys·efacethash(Eface e1, uint32 ret)
+runtime·efacethash(Eface e1, uint32 ret)
 {
 	Type *t;
 
@@ -549,13 +549,13 @@
 }
 
 void
-sys·printiface(Iface i)
+runtime·printiface(Iface i)
 {
 	printiface(i);
 }
 
 void
-sys·printeface(Eface e)
+runtime·printeface(Eface e)
 {
 	printeface(e);
 }
diff --git a/src/pkg/runtime/linux/386/sys.s b/src/pkg/runtime/linux/386/sys.s
index 3b0babc..cc793b4 100755
--- a/src/pkg/runtime/linux/386/sys.s
+++ b/src/pkg/runtime/linux/386/sys.s
@@ -58,7 +58,7 @@
 	INT $3	// not reached
 	RET
 
-TEXT sys·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVL	$192, AX	// mmap2
 	MOVL	4(SP), BX
 	MOVL	8(SP), CX
diff --git a/src/pkg/runtime/linux/amd64/sys.s b/src/pkg/runtime/linux/amd64/sys.s
index 8ee0ed2..a78357f 100644
--- a/src/pkg/runtime/linux/amd64/sys.s
+++ b/src/pkg/runtime/linux/amd64/sys.s
@@ -36,7 +36,7 @@
 	SYSCALL
 	RET
 
-TEXT	sys·write(SB),7,$0-24
+TEXT	runtime·write(SB),7,$0-24
 	MOVL	8(SP), DI
 	MOVQ	16(SP), SI
 	MOVL	24(SP), DX
@@ -69,7 +69,7 @@
 	SYSCALL
 	INT $3	// not reached
 
-TEXT	sys·mmap(SB),7,$0-32
+TEXT	runtime·mmap(SB),7,$0-32
 	MOVQ	8(SP), DI
 	MOVQ	$0, SI
 	MOVL	16(SP), SI
@@ -90,7 +90,7 @@
 	MOVQ	BP, (BP)
 	RET
 
-TEXT	sys·memclr(SB),7,$0-16
+TEXT	runtime·memclr(SB),7,$0-16
 	MOVQ	8(SP), DI		// arg 1 addr
 	MOVL	16(SP), CX		// arg 2 count (cannot be zero)
 	ADDL	$7, CX
@@ -101,12 +101,12 @@
 	STOSQ
 	RET
 
-TEXT	sys·getcallerpc+0(SB),7,$0
+TEXT	runtime·getcallerpc+0(SB),7,$0
 	MOVQ	x+0(FP),AX		// addr of first arg
 	MOVQ	-8(AX),AX		// get calling pc
 	RET
 
-TEXT	sys·setcallerpc+0(SB),7,$0
+TEXT	runtime·setcallerpc+0(SB),7,$0
 	MOVQ	x+0(FP),AX		// addr of first arg
 	MOVQ	x+8(FP), BX
 	MOVQ	BX, -8(AX)		// set calling pc
diff --git a/src/pkg/runtime/linux/arm/sys.s b/src/pkg/runtime/linux/arm/sys.s
index d7eb43e..4eb38f1 100644
--- a/src/pkg/runtime/linux/arm/sys.s
+++ b/src/pkg/runtime/linux/arm/sys.s
@@ -22,7 +22,7 @@
 	// Exit value already in R0
 	SWI	$SYS_exit
 
-TEXT sys·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVW	0(FP), R0
 	MOVW	4(FP), R1
 	MOVW	8(FP), R2
diff --git a/src/pkg/runtime/linux/thread.c b/src/pkg/runtime/linux/thread.c
index fd488d4..425e669 100644
--- a/src/pkg/runtime/linux/thread.c
+++ b/src/pkg/runtime/linux/thread.c
@@ -49,11 +49,11 @@
 		return;
 
 	prints("futexsleep addr=");
-	sys·printpointer(addr);
+	runtime·printpointer(addr);
 	prints(" val=");
-	sys·printint(val);
+	runtime·printint(val);
 	prints(" returned ");
-	sys·printint(ret);
+	runtime·printint(ret);
 	prints("\n");
 	*(int32*)0x1005 = 0x1005;
 }
@@ -74,9 +74,9 @@
 	// safe to loop and call futex again.
 
 	prints("futexwakeup addr=");
-	sys·printpointer(addr);
+	runtime·printpointer(addr);
 	prints(" returned ");
-	sys·printint(ret);
+	runtime·printint(ret);
 	prints("\n");
 	*(int32*)0x1006 = 0x1006;
 }
diff --git a/src/pkg/runtime/malloc.cgo b/src/pkg/runtime/malloc.cgo
index 0fdb13d..6a769c9 100644
--- a/src/pkg/runtime/malloc.cgo
+++ b/src/pkg/runtime/malloc.cgo
@@ -113,7 +113,7 @@
 		if(sizeclass == 0) {
 			// Large object.
 			mstats.alloc -= s->npages<<PageShift;
-			sys_memclr(v, s->npages<<PageShift);
+			runtime_memclr(v, s->npages<<PageShift);
 			MHeap_Free(&mheap, s);
 			goto out;
 		}
@@ -123,7 +123,7 @@
 	// Small object.
 	c = m->mcache;
 	size = class_to_size[sizeclass];
-	sys_memclr(v, size);
+	runtime_memclr(v, size);
 	mstats.alloc -= size;
 	MCache_Free(c, v, sizeclass, size);
 
@@ -209,7 +209,7 @@
 SysAlloc(uintptr n)
 {
 	mstats.sys += n;
-	return sys_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
diff --git a/src/pkg/runtime/mem.c b/src/pkg/runtime/mem.c
index 2d6e36a..616d1a0 100644
--- a/src/pkg/runtime/mem.c
+++ b/src/pkg/runtime/mem.c
@@ -19,7 +19,7 @@
 {
 	byte *v;
 
-	v = sys_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, 0, 0);
+	v = runtime_mmap(nil, n, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, 0, 0);
 	m->mem.nmmap += n;
 	return v;
 }
@@ -51,10 +51,10 @@
 			// hunk, and then once brk returned we'd immediately
 			// overwrite that hunk with our own.
 			// (the net result would be a memory leak, not a crash.)
-			// so we have to call sys_mmap directly - it is written
+			// so we have to call runtime_mmap directly - it is written
 			// in assembly and tagged not to grow the stack.
 			m->mem.hunk =
-				sys_mmap(nil, NHUNK, PROT_READ|PROT_WRITE|PROT_EXEC,
+				runtime_mmap(nil, NHUNK, PROT_READ|PROT_WRITE|PROT_EXEC,
 					MAP_ANON|MAP_PRIVATE, 0, 0);
 			m->mem.nhunk = NHUNK;
 			m->mem.nmmap += NHUNK;
@@ -68,7 +68,7 @@
 }
 
 void
-sys·mal(uint32 n, uint8 *ret)
+runtime·mal(uint32 n, uint8 *ret)
 {
 	ret = mal(n);
 	FLUSH(&ret);
diff --git a/src/pkg/runtime/mheapmap32.c b/src/pkg/runtime/mheapmap32.c
index 420ca2d..8cea825 100644
--- a/src/pkg/runtime/mheapmap32.c
+++ b/src/pkg/runtime/mheapmap32.c
@@ -84,7 +84,7 @@
 			p2 = m->allocator(sizeof *p2);
 			if(p2 == nil)
 				return false;
-			sys_memclr((byte*)p2, sizeof *p2);
+			runtime_memclr((byte*)p2, sizeof *p2);
 			m->p[i1] = p2;
 		}
 
diff --git a/src/pkg/runtime/mheapmap64.c b/src/pkg/runtime/mheapmap64.c
index 1886ba5..7930291 100644
--- a/src/pkg/runtime/mheapmap64.c
+++ b/src/pkg/runtime/mheapmap64.c
@@ -96,7 +96,7 @@
 			p2 = m->allocator(sizeof *p2);
 			if(p2 == nil)
 				return false;
-			sys_memclr((byte*)p2, sizeof *p2);
+			runtime_memclr((byte*)p2, sizeof *p2);
 			m->p[i1] = p2;
 		}
 
@@ -105,7 +105,7 @@
 			p3 = m->allocator(sizeof *p3);
 			if(p3 == nil)
 				return false;
-			sys_memclr((byte*)p3, sizeof *p3);
+			runtime_memclr((byte*)p3, sizeof *p3);
 			p2->p[i2] = p3;
 		}
 
diff --git a/src/pkg/runtime/nacl/386/sys.s b/src/pkg/runtime/nacl/386/sys.s
index 5f8a1c0..87cbc1e 100755
--- a/src/pkg/runtime/nacl/386/sys.s
+++ b/src/pkg/runtime/nacl/386/sys.s
@@ -54,7 +54,7 @@
 TEXT thread_create(SB),7,$0
 	JMP	SYSCALL(thread_create)
 
-TEXT sys·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
diff --git a/src/pkg/runtime/print.c b/src/pkg/runtime/print.c
index 15cffdf..ed6ea9f 100644
--- a/src/pkg/runtime/print.c
+++ b/src/pkg/runtime/print.c
@@ -12,8 +12,8 @@
 	int32 i;
 
 	for(i=0; i<n; i++) {
-		sys·printpointer((byte*)(p[i]>>4));
-		sys·printpointer((byte*)(p[i]&0xf));
+		runtime·printpointer((byte*)(p[i]>>4));
+		runtime·printpointer((byte*)(p[i]&0xf));
 		if((i&15) == 15)
 			prints("\n");
 		else
@@ -73,25 +73,25 @@
 		}
 		switch(*p) {
 		case 'd':
-			sys·printint(*(int32*)arg);
+			runtime·printint(*(int32*)arg);
 			break;
 		case 'D':
-			sys·printint(*(int64*)arg);
+			runtime·printint(*(int64*)arg);
 			break;
 		case 'x':
-			sys·printhex(*(uint32*)arg);
+			runtime·printhex(*(uint32*)arg);
 			break;
 		case 'X':
-			sys·printhex(*(uint64*)arg);
+			runtime·printhex(*(uint64*)arg);
 			break;
 		case 'p':
-			sys·printpointer(*(void**)arg);
+			runtime·printpointer(*(void**)arg);
 			break;
 		case 's':
 			prints(*(int8**)arg);
 			break;
 		case 'S':
-			sys·printstring(*(String*)arg);
+			runtime·printstring(*(String*)arg);
 			break;
 		}
 		arg = narg;
@@ -105,14 +105,14 @@
 
 
 void
-sys·printpc(void *p)
+runtime·printpc(void *p)
 {
 	prints("PC=");
-	sys·printhex((uint64)sys·getcallerpc(p));
+	runtime·printhex((uint64)runtime·getcallerpc(p));
 }
 
 void
-sys·printbool(bool v)
+runtime·printbool(bool v)
 {
 	if(v) {
 		write(fd, (byte*)"true", 4);
@@ -122,7 +122,7 @@
 }
 
 void
-sys·printfloat(float64 v)
+runtime·printfloat(float64 v)
 {
 	byte buf[20];
 	int32 e, s, i, n;
@@ -200,7 +200,7 @@
 }
 
 void
-sys·printuint(uint64 v)
+runtime·printuint(uint64 v)
 {
 	byte buf[100];
 	int32 i;
@@ -215,17 +215,17 @@
 }
 
 void
-sys·printint(int64 v)
+runtime·printint(int64 v)
 {
 	if(v < 0) {
 		write(fd, "-", 1);
 		v = -v;
 	}
-	sys·printuint(v);
+	runtime·printuint(v);
 }
 
 void
-sys·printhex(uint64 v)
+runtime·printhex(uint64 v)
 {
 	static int8 *dig = "0123456789abcdef";
 	byte buf[100];
@@ -242,13 +242,13 @@
 }
 
 void
-sys·printpointer(void *p)
+runtime·printpointer(void *p)
 {
-	sys·printhex((uint64)p);
+	runtime·printhex((uint64)p);
 }
 
 void
-sys·printstring(String v)
+runtime·printstring(String v)
 {
 	extern int32 maxstring;
 
@@ -261,13 +261,13 @@
 }
 
 void
-sys·printsp(void)
+runtime·printsp(void)
 {
 	write(fd, " ", 1);
 }
 
 void
-sys·printnl(void)
+runtime·printnl(void)
 {
 	write(fd, "\n", 1);
 }
diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index 4113002..0619a03 100644
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -522,7 +522,7 @@
 // from the low-level system calls used by the runtime.
 // The "arguments" are syscall.Syscall's stack frame
 void
-sys·entersyscall(uint64 callerpc, int64 trap)
+runtime·entersyscall(uint64 callerpc, int64 trap)
 {
 	USED(callerpc, trap);
 
@@ -552,7 +552,7 @@
 // This is called only from the go syscall library, not
 // from the low-level system calls used by the runtime.
 void
-sys·exitsyscall(void)
+runtime·exitsyscall(void)
 {
 	lock(&sched);
 	if(sched.predawn) {
@@ -715,7 +715,7 @@
 	// Continue as if lessstack had just called m->morepc
 	// (the PC that decided to grow the stack).
 	label.sp = sp;
-	label.pc = (byte*)sys·lessstack;
+	label.pc = (byte*)runtime·lessstack;
 	label.g = m->curg;
 	gogocall(&label, m->morepc);
 
@@ -747,7 +747,7 @@
  */
 #pragma textflag 7
 void
-sys·newproc(int32 siz, byte* fn, byte* arg0)
+runtime·newproc(int32 siz, byte* fn, byte* arg0)
 {
 	byte *stk, *sp;
 	G *newg;
@@ -756,7 +756,7 @@
 
 	siz = (siz+7) & ~7;
 	if(siz > 1024)
-		throw("sys·newproc: too many args");
+		throw("runtime·newproc: too many args");
 
 	lock(&sched);
 
@@ -795,7 +795,7 @@
 
 #pragma textflag 7
 void
-sys·deferproc(int32 siz, byte* fn, byte* arg0)
+runtime·deferproc(int32 siz, byte* fn, byte* arg0)
 {
 	Defer *d;
 
@@ -811,7 +811,7 @@
 
 #pragma textflag 7
 void
-sys·deferreturn(uintptr arg0)
+runtime·deferreturn(uintptr arg0)
 {
 	Defer *d;
 	byte *sp, *fn;
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 4dcd3da..39fda98 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -20,7 +20,7 @@
 }
 
 void
-sys·panicl(int32 lno)
+runtime·panicl(int32 lno)
 {
 	uint8 *sp;
 
@@ -34,7 +34,7 @@
 	printf("\npanic PC=%X\n", (uint64)(uintptr)&lno);
 	sp = (uint8*)&lno;
 	if(gotraceback()){
-		traceback(sys·getcallerpc(&lno), sp, g);
+		traceback(runtime·getcallerpc(&lno), sp, g);
 		tracebackothers(g);
 	}
 	breakpoint();  // so we can grab it in a debugger
@@ -42,25 +42,25 @@
 }
 
 void
-sys·throwindex(void)
+runtime·throwindex(void)
 {
 	throw("index out of range");
 }
 
 void
-sys·throwslice(void)
+runtime·throwslice(void)
 {
 	throw("slice out of range");
 }
 
 void
-sys·throwreturn(void)
+runtime·throwreturn(void)
 {
 	throw("no return at end of a typed function");
 }
 
 void
-sys·throwinit(void)
+runtime·throwinit(void)
 {
 	throw("recursive call during initialization");
 }
@@ -70,7 +70,7 @@
 {
 	fd = 2;
 	printf("throw: %s\n", s);
-	sys·panicl(-1);
+	runtime·panicl(-1);
 	*(int32*)0 = 0;	// not reached
 	exit(1);	// even more not reached
 }
@@ -332,7 +332,7 @@
 		v = *(uint64*)a;
 		break;
 	}
-	sys·printint(v);
+	runtime·printint(v);
 }
 
 static void
@@ -370,7 +370,7 @@
 strprint(uint32 s, String *a)
 {
 	USED(s);
-	sys·printstring(*a);
+	runtime·printstring(*a);
 }
 
 static uintptr
@@ -384,7 +384,7 @@
 interprint(uint32 s, Iface *a)
 {
 	USED(s);
-	sys·printiface(*a);
+	runtime·printiface(*a);
 }
 
 static uint32
@@ -405,7 +405,7 @@
 nilinterprint(uint32 s, Eface *a)
 {
 	USED(s);
-	sys·printeface(*a);
+	runtime·printeface(*a);
 }
 
 static uint32
diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index d45ac50..fac0008 100644
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -330,7 +330,7 @@
 void	gogo(Gobuf*, uintptr);
 void	gogocall(Gobuf*, void(*)(void));
 uintptr	gosave(Gobuf*);
-void	sys·lessstack(void);
+void	runtime·lessstack(void);
 void	goargs(void);
 void	FLUSH(void*);
 void*	getu(void);
@@ -430,45 +430,45 @@
  * UTF-8 characters in identifiers.
  */
 #ifndef __GNUC__
-#define sys_memclr sys·memclr
-#define sys_getcallerpc sys·getcallerpc
-#define sys_mmap sys·mmap
-#define sys_printslice sys·printslice
-#define sys_printbool sys·printbool
-#define sys_printfloat sys·printfloat
-#define sys_printhex sys·printhex
-#define sys_printint sys·printint
-#define sys_printiface sys·printiface
-#define sys_printeface sys·printeface
-#define sys_printpc sys·printpc
-#define sys_printpointer sys·printpointer
-#define sys_printstring sys·printstring
-#define sys_printuint sys·printuint
-#define sys_setcallerpc sys·setcallerpc
+#define runtime_memclr runtime·memclr
+#define runtime_getcallerpc runtime·getcallerpc
+#define runtime_mmap runtime·mmap
+#define runtime_printslice runtime·printslice
+#define runtime_printbool runtime·printbool
+#define runtime_printfloat runtime·printfloat
+#define runtime_printhex runtime·printhex
+#define runtime_printint runtime·printint
+#define runtime_printiface runtime·printiface
+#define runtime_printeface runtime·printeface
+#define runtime_printpc runtime·printpc
+#define runtime_printpointer runtime·printpointer
+#define runtime_printstring runtime·printstring
+#define runtime_printuint runtime·printuint
+#define runtime_setcallerpc runtime·setcallerpc
 #endif
 
 /*
  * low level go-called
  */
-uint8*	sys_mmap(byte*, uint32, int32, int32, int32, uint32);
-void	sys_memclr(byte*, uint32);
-void	sys_setcallerpc(void*, void*);
-void*	sys_getcallerpc(void*);
+uint8*	runtime_mmap(byte*, uint32, int32, int32, int32, uint32);
+void	runtime_memclr(byte*, uint32);
+void	runtime_setcallerpc(void*, void*);
+void*	runtime_getcallerpc(void*);
 
 /*
  * runtime go-called
  */
-void	sys_printbool(bool);
-void	sys_printfloat(float64);
-void	sys_printint(int64);
-void	sys_printiface(Iface);
-void	sys_printeface(Eface);
-void	sys_printstring(String);
-void	sys_printpc(void*);
-void	sys_printpointer(void*);
-void	sys_printuint(uint64);
-void	sys_printhex(uint64);
-void	sys_printslice(Slice);
+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);
 
 /*
  * wrapped for go users
diff --git a/src/pkg/runtime/slice.c b/src/pkg/runtime/slice.c
index d7a5a06..040029e 100644
--- a/src/pkg/runtime/slice.c
+++ b/src/pkg/runtime/slice.c
@@ -8,7 +8,7 @@
 
 // makeslice(nel int, cap int, width int) (ary []any);
 void
-sys·makeslice(uint32 nel, uint32 cap, uint32 width, Slice ret)
+runtime·makeslice(uint32 nel, uint32 cap, uint32 width, Slice ret)
 {
 	uint64 size;
 
@@ -24,13 +24,13 @@
 
 	if(debug) {
 		prints("makeslice: nel=");
-		sys·printint(nel);
+		runtime·printint(nel);
 		prints("; cap=");
-		sys·printint(cap);
+		runtime·printint(cap);
 		prints("; width=");
-		sys·printint(width);
+		runtime·printint(width);
 		prints("; ret=");
-		sys·printslice(ret);
+		runtime·printslice(ret);
 		prints("\n");
 	}
 }
@@ -39,36 +39,36 @@
 throwslice(uint32 lb, uint32 hb, uint32 n)
 {
 	prints("slice[");
-	sys·printint(lb);
+	runtime·printint(lb);
 	prints(":");
-	sys·printint(hb);
+	runtime·printint(hb);
 	prints("] of [");
-	sys·printint(n);
+	runtime·printint(n);
 	prints("] array\n");
 	throw("array slice");
 }
 
 // sliceslice(old []any, lb int, hb int, width int) (ary []any);
 void
-sys·sliceslice(Slice old, uint32 lb, uint32 hb, uint32 width, Slice ret)
+runtime·sliceslice(Slice old, uint32 lb, uint32 hb, uint32 width, Slice ret)
 {
 
 	if(hb > old.cap || lb > hb) {
 		if(debug) {
-			prints("sys·sliceslice: old=");
-			sys·printslice(old);
+			prints("runtime·sliceslice: old=");
+			runtime·printslice(old);
 			prints("; lb=");
-			sys·printint(lb);
+			runtime·printint(lb);
 			prints("; hb=");
-			sys·printint(hb);
+			runtime·printint(hb);
 			prints("; width=");
-			sys·printint(width);
+			runtime·printint(width);
 			prints("\n");
 
 			prints("oldarray: nel=");
-			sys·printint(old.len);
+			runtime·printint(old.len);
 			prints("; cap=");
-			sys·printint(old.cap);
+			runtime·printint(old.cap);
 			prints("\n");
 		}
 		throwslice(lb, hb, old.cap);
@@ -82,37 +82,37 @@
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("sys·sliceslice: old=");
-		sys·printslice(old);
+		prints("runtime·sliceslice: old=");
+		runtime·printslice(old);
 		prints("; lb=");
-		sys·printint(lb);
+		runtime·printint(lb);
 		prints("; hb=");
-		sys·printint(hb);
+		runtime·printint(hb);
 		prints("; width=");
-		sys·printint(width);
+		runtime·printint(width);
 		prints("; ret=");
-		sys·printslice(ret);
+		runtime·printslice(ret);
 		prints("\n");
 	}
 }
 
 // slicearray(old *any, nel int, lb int, hb int, width int) (ary []any);
 void
-sys·slicearray(byte* old, uint32 nel, uint32 lb, uint32 hb, uint32 width, Slice ret)
+runtime·slicearray(byte* old, uint32 nel, uint32 lb, uint32 hb, uint32 width, Slice ret)
 {
 
 	if(hb > nel || lb > hb) {
 		if(debug) {
-			prints("sys·slicearray: old=");
-			sys·printpointer(old);
+			prints("runtime·slicearray: old=");
+			runtime·printpointer(old);
 			prints("; nel=");
-			sys·printint(nel);
+			runtime·printint(nel);
 			prints("; lb=");
-			sys·printint(lb);
+			runtime·printint(lb);
 			prints("; hb=");
-			sys·printint(hb);
+			runtime·printint(hb);
 			prints("; width=");
-			sys·printint(width);
+			runtime·printint(width);
 			prints("\n");
 		}
 		throwslice(lb, hb, nel);
@@ -126,25 +126,25 @@
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("sys·slicearray: old=");
-		sys·printpointer(old);
+		prints("runtime·slicearray: old=");
+		runtime·printpointer(old);
 		prints("; nel=");
-		sys·printint(nel);
+		runtime·printint(nel);
 		prints("; lb=");
-		sys·printint(lb);
+		runtime·printint(lb);
 		prints("; hb=");
-		sys·printint(hb);
+		runtime·printint(hb);
 		prints("; width=");
-		sys·printint(width);
+		runtime·printint(width);
 		prints("; ret=");
-		sys·printslice(ret);
+		runtime·printslice(ret);
 		prints("\n");
 	}
 }
 
 // arraytoslice(old *any, nel int) (ary []any)
 void
-sys·arraytoslice(byte* old, uint32 nel, Slice ret)
+runtime·arraytoslice(byte* old, uint32 nel, Slice ret)
 {
 
 	// new dope to old array
@@ -155,21 +155,21 @@
 	FLUSH(&ret);
 
 	if(debug) {
-		prints("sys·slicearrayp: old=");
-		sys·printpointer(old);
+		prints("runtime·slicearrayp: old=");
+		runtime·printpointer(old);
 		prints("; ret=");
-		sys·printslice(ret);
+		runtime·printslice(ret);
 		prints("\n");
 	}
 }
 
 void
-sys·printslice(Slice a)
+runtime·printslice(Slice a)
 {
 	prints("[");
-	sys·printint(a.len);
+	runtime·printint(a.len);
 	prints("/");
-	sys·printint(a.cap);
+	runtime·printint(a.cap);
 	prints("]");
-	sys·printpointer(a.array);
+	runtime·printpointer(a.array);
 }
diff --git a/src/pkg/runtime/string.cgo b/src/pkg/runtime/string.cgo
index 3134cbb..bafa679 100644
--- a/src/pkg/runtime/string.cgo
+++ b/src/pkg/runtime/string.cgo
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package sys
+package runtime
 #include "runtime.h"
 
 String	emptystring;
@@ -68,11 +68,11 @@
 {
 	prints(s);
 	prints(" ");
-	sys·printint(a);
+	runtime·printint(a);
 	prints("<");
-	sys·printint(b);
+	runtime·printint(b);
 	prints(">");
-	sys·printint(c);
+	runtime·printint(c);
 	prints("\n");
 	throw("string bounds");
 }
@@ -128,7 +128,7 @@
 
 	if(lindex < 0 || lindex > si.len ||
 	   hindex < lindex || hindex > si.len) {
-		sys·printpc(&si);
+		runtime·printpc(&si);
 		prints(" ");
 		prbounds("slice", lindex, si.len, hindex);
 	}
@@ -144,7 +144,7 @@
 
 func indexstring(s String, i int32) (b byte) {
 	if(i < 0 || i >= s.len) {
-		sys·printpc(&s);
+		runtime·printpc(&s);
 		prints(" ");
 		prbounds("index", 0, i, s.len);
 	}
diff --git a/src/pkg/runtime/symtab.c b/src/pkg/runtime/symtab.c
index a082a76..18ce07a 100644
--- a/src/pkg/runtime/symtab.c
+++ b/src/pkg/runtime/symtab.c
@@ -27,7 +27,7 @@
 
 // Return a pointer to a byte array containing the symbol table segment.
 void
-sys·symdat(Slice *symtab, Slice *pclntab)
+runtime·symdat(Slice *symtab, Slice *pclntab)
 {
 	Slice *a;
 	int32 *v;
diff --git a/src/pkg/syscall/asm_darwin_386.s b/src/pkg/syscall/asm_darwin_386.s
index 646851b..0ea5dd2 100644
--- a/src/pkg/syscall/asm_darwin_386.s
+++ b/src/pkg/syscall/asm_darwin_386.s
@@ -11,7 +11,7 @@
 // Trap # in AX, args on stack above caller pc.
 
 TEXT	syscall·Syscall(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	4(SP), AX	// syscall entry
 	// slide args down on top of system call number
 	LEAL		8(SP), SI
@@ -25,17 +25,17 @@
 	MOVL	$-1, 20(SP)	// r1
 	MOVL	$-1, 24(SP)	// r2
 	MOVL	AX, 28(SP)		// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok:
 	MOVL	AX, 20(SP)	// r1
 	MOVL	DX, 24(SP)	// r2
 	MOVL	$0, 28(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 TEXT	syscall·Syscall6(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	4(SP), AX	// syscall entry
 	// slide args down on top of system call number
 	LEAL		8(SP), SI
@@ -52,13 +52,13 @@
 	MOVL	$-1, 32(SP)	// r1
 	MOVL	$-1, 36(SP)	// r2
 	MOVL	AX, 40(SP)		// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok6:
 	MOVL	AX, 32(SP)	// r1
 	MOVL	DX, 36(SP)	// r2
 	MOVL	$0, 40(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 TEXT syscall·RawSyscall(SB),7,$0
diff --git a/src/pkg/syscall/asm_darwin_amd64.s b/src/pkg/syscall/asm_darwin_amd64.s
index 29cc293..d73a8ae 100644
--- a/src/pkg/syscall/asm_darwin_amd64.s
+++ b/src/pkg/syscall/asm_darwin_amd64.s
@@ -11,7 +11,7 @@
 // Trap # in AX, args in DI SI DX, return in AX DX
 
 TEXT	syscall·Syscall(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVQ	16(SP), DI
 	MOVQ	24(SP), SI
 	MOVQ	32(SP), DX
@@ -25,17 +25,17 @@
 	MOVQ	$-1, 40(SP)	// r1
 	MOVQ	$0, 48(SP)	// r2
 	MOVQ	AX, 56(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok:
 	MOVQ	AX, 40(SP)	// r1
 	MOVQ	DX, 48(SP)	// r2
 	MOVQ	$0, 56(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 TEXT	syscall·Syscall6(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVQ	16(SP), DI
 	MOVQ	24(SP), SI
 	MOVQ	32(SP), DX
@@ -49,13 +49,13 @@
 	MOVQ	$-1, 64(SP)	// r1
 	MOVQ	$0, 72(SP)	// r2
 	MOVQ	AX, 80(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok6:
 	MOVQ	AX, 64(SP)	// r1
 	MOVQ	DX, 72(SP)	// r2
 	MOVQ	$0, 80(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 TEXT syscall·RawSyscall(SB),7,$0
diff --git a/src/pkg/syscall/asm_linux_386.s b/src/pkg/syscall/asm_linux_386.s
index 638a31d..533ddda 100644
--- a/src/pkg/syscall/asm_linux_386.s
+++ b/src/pkg/syscall/asm_linux_386.s
@@ -10,7 +10,7 @@
 // Trap # in AX, args in BX CX DX SI DI, return in AX
 
 TEXT	syscall·Syscall(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	4(SP), AX	// syscall entry
 	MOVL	8(SP), BX
 	MOVL	12(SP), CX
@@ -24,19 +24,19 @@
 	MOVL	$0, 24(SP)	// r2
 	NEGL	AX
 	MOVL	AX, 28(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok:
 	MOVL	AX, 20(SP)	// r1
 	MOVL	DX, 24(SP)	// r2
 	MOVL	$0, 28(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 // func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 // Actually Syscall5 but the rest of the code expects it to be named Syscall6.
 TEXT	syscall·Syscall6(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	4(SP), AX	// syscall entry
 	MOVL	8(SP), BX
 	MOVL	12(SP), CX
@@ -51,13 +51,13 @@
 	MOVL	$0, 36(SP)	// r2
 	NEGL	AX
 	MOVL	AX, 40(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok6:
 	MOVL	AX, 32(SP)	// r1
 	MOVL	DX, 36(SP)	// r2
 	MOVL	$0, 40(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 // func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
@@ -75,7 +75,7 @@
 	MOVL	$0, 24(SP)	// r2
 	NEGL	AX
 	MOVL	AX, 28(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok1:
 	MOVL	AX, 20(SP)	// r1
@@ -88,7 +88,7 @@
 // func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
 // Kernel interface gets call sub-number and pointer to a0.
 TEXT syscall·socketcall(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	$SYS_SOCKETCALL, AX	// syscall entry
 	MOVL	4(SP), BX	// socket call number
 	LEAL		8(SP), CX	// pointer to call arguments
@@ -101,12 +101,12 @@
 	MOVL	$-1, 32(SP)	// n
 	NEGL	AX
 	MOVL	AX, 36(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 oksock:
 	MOVL	AX, 32(SP)	// n
 	MOVL	$0, 36(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 #define SYS__LLSEEK 140	/* from zsysnum_linux_386.go */
@@ -116,7 +116,7 @@
 // Underlying system call is
 //	llseek(int fd, int offhi, int offlo, int64 *result, int whence)
 TEXT syscall·Seek(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	$SYS__LLSEEK, AX	// syscall entry
 	MOVL	4(SP), BX	// fd
 	MOVL	12(SP), CX	// offset-high
@@ -130,10 +130,10 @@
 	MOVL	$-1, 24(SP)	// newoffset high
 	NEGL	AX
 	MOVL	AX, 28(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 okseek:
 	// system call filled in newoffset already
 	MOVL	$0, 28(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
diff --git a/src/pkg/syscall/asm_linux_amd64.s b/src/pkg/syscall/asm_linux_amd64.s
index 0f071d2..e37f564 100644
--- a/src/pkg/syscall/asm_linux_amd64.s
+++ b/src/pkg/syscall/asm_linux_amd64.s
@@ -12,7 +12,7 @@
 // would pass 4th arg in CX, not R10.
 
 TEXT	syscall·Syscall(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVQ	16(SP), DI
 	MOVQ	24(SP), SI
 	MOVQ	32(SP), DX
@@ -27,17 +27,17 @@
 	MOVQ	$0, 48(SP)	// r2
 	NEGQ	AX
 	MOVQ	AX, 56(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok:
 	MOVQ	AX, 40(SP)	// r1
 	MOVQ	DX, 48(SP)	// r2
 	MOVQ	$0, 56(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 TEXT syscall·Syscall6(SB),7,$0
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVQ	16(SP), DI
 	MOVQ	24(SP), SI
 	MOVQ	32(SP), DX
@@ -52,13 +52,13 @@
 	MOVQ	$0, 72(SP)	// r2
 	NEGQ	AX
 	MOVQ	AX, 80(SP)  // errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok6:
 	MOVQ	AX, 64(SP)	// r1
 	MOVQ	DX, 72(SP)	// r2
 	MOVQ	$0, 80(SP)	// errno
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 TEXT syscall·RawSyscall(SB),7,$0
diff --git a/src/pkg/syscall/asm_linux_arm.s b/src/pkg/syscall/asm_linux_arm.s
index 8aa5f34..50ee69d 100644
--- a/src/pkg/syscall/asm_linux_arm.s
+++ b/src/pkg/syscall/asm_linux_arm.s
@@ -14,7 +14,7 @@
 // func Syscall(syscall uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
 
 TEXT	syscall·Syscall(SB),7,$0
-	BL		sys·entersyscall(SB)
+	BL		runtime·entersyscall(SB)
 	MOVW	4(SP), R7
 	MOVW	8(SP), R0
 	MOVW	12(SP), R1
@@ -24,13 +24,13 @@
 	MOVW	R1, 24(SP)	// r2
 	MOVW	$0, R0
 	MOVW	R0, 28(SP)	// errno
-	BL		sys·exitsyscall(SB)
+	BL		runtime·exitsyscall(SB)
 	RET
 
 // func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 // Actually Syscall5 but the rest of the code expects it to be named Syscall6.
 TEXT	syscall·Syscall6(SB),7,$0
-	BL		sys·entersyscall(SB)
+	BL		runtime·entersyscall(SB)
 	MOVW	4(SP), R7	// syscall entry
 	MOVW	8(SP), R0
 	MOVW	12(SP), R1
@@ -43,7 +43,7 @@
 	MOVW	R1, 36(SP)	// r2
 	MOVW	$0, R0
 	MOVW	R0, 40(SP)	// errno
-	BL		sys·exitsyscall(SB)
+	BL		runtime·exitsyscall(SB)
 	RET
 
 // func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
diff --git a/src/pkg/syscall/asm_nacl_386.s b/src/pkg/syscall/asm_nacl_386.s
index c1b1921..d76759b 100644
--- a/src/pkg/syscall/asm_nacl_386.s
+++ b/src/pkg/syscall/asm_nacl_386.s
@@ -12,7 +12,7 @@
 // Trap # in AX, args in BX CX DX SI DI, return in AX
 
 TEXT	syscall·Syscall(SB),7,$20
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	trap+0(FP), AX	// syscall entry
 	MOVL	a1+4(FP), BX
 	MOVL	a2+8(FP), CX
@@ -37,18 +37,18 @@
 	MOVL	$0, r2+20(FP)
 	NEGL	AX
 	MOVL	AX, errno+24(FP)
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok:
 	MOVL	AX, r1+16(FP)
 	MOVL	DX, r2+20(FP)
 	MOVL	$0, errno+24(FP)
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 // func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 TEXT	syscall·Syscall6(SB),7,$24
-	CALL	sys·entersyscall(SB)
+	CALL	runtime·entersyscall(SB)
 	MOVL	a1+4(FP), BX
 	MOVL	a2+8(FP), CX
 	MOVL	a3+12(FP), DX
@@ -75,13 +75,13 @@
 	MOVL	$0, r2+32(FP)
 	NEGL	AX
 	MOVL	AX, errno+36(FP)
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 ok6:
 	MOVL	AX, r1+28(FP)
 	MOVL	DX, r2+32(FP)
 	MOVL	$0, errno+36(FP)
-	CALL	sys·exitsyscall(SB)
+	CALL	runtime·exitsyscall(SB)
 	RET
 
 // func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);