Imported Upstream version 2011.01.12upstream/2011.01.12

14 files changed, 404 insertions, 306 deletions

diff --git a/src/pkg/runtime/darwin/386/defs.h b/src/pkg/runtime/darwin/386/defs.h
index 371f650a8..f9d874d85 100644
--- a/src/pkg/runtime/darwin/386/defs.h
+++ b/src/pkg/runtime/darwin/386/defs.h
@@ -10,6 +10,7 @@ enum {
 	PROT_EXEC = 0x4,
 	MAP_ANON = 0x1000,
 	MAP_PRIVATE = 0x2,
+	MAP_FIXED = 0x10,
 	MACH_MSG_TYPE_MOVE_RECEIVE = 0x10,
 	MACH_MSG_TYPE_MOVE_SEND = 0x11,
 	MACH_MSG_TYPE_MOVE_SEND_ONCE = 0x12,
diff --git a/src/pkg/runtime/darwin/386/rt0.s b/src/pkg/runtime/darwin/386/rt0.s
index 5b52e912c..30b497f5e 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 f7ee3c448..53a4e2f17 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 @@ sighandler(int32 sig, Siginfo *info, void *context)
 	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 @@ sighandler(int32 sig, Siginfo *info, void *context)
 		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 4e0a0b3fd..79bbfb68b 100644
--- a/src/pkg/runtime/darwin/386/sys.s
+++ b/src/pkg/runtime/darwin/386/sys.s
@@ -8,42 +8,45 @@
 
 #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)
 	RET
 
-TEXT ·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
 	MOVL	$197, AX
 	INT	$0x80
+	RET
+
+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
@@ -58,11 +61,11 @@ TEXT gettime(SB), 7, $32
 	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.
@@ -73,7 +76,7 @@ TEXT sigaction(SB),7,$0
 //	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
@@ -109,19 +112,19 @@ TEXT sigtramp(SB),7,$40
 	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
@@ -150,7 +153,7 @@ TEXT bsdthread_create(SB),7,$32
 //	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].
@@ -162,7 +165,7 @@ TEXT bsdthread_start(SB),7,$0
 	PUSHL	$32	// sizeof tls
 	PUSHL	BP	// &tls
 	PUSHL	DI	// tls #
-	CALL	setldt(SB)
+	CALL	runtime·setldt(SB)
 	POPL	AX
 	POPL	AX
 	POPL	AX
@@ -173,18 +176,18 @@ TEXT bsdthread_start(SB),7,$0
 	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]
@@ -192,7 +195,7 @@ TEXT bsdthread_register(SB),7,$40
 	MOVL	$0, 24(SP)	// dispatchqueue_offset
 	INT	$0x80
 	JAE	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
 // Invoke Mach system call.
@@ -206,57 +209,57 @@ TEXT bsdthread_register(SB),7,$40
 // 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/defs.h b/src/pkg/runtime/darwin/amd64/defs.h
index 0b5fde85c..09e595988 100644
--- a/src/pkg/runtime/darwin/amd64/defs.h
+++ b/src/pkg/runtime/darwin/amd64/defs.h
@@ -10,6 +10,7 @@ enum {
 	PROT_EXEC = 0x4,
 	MAP_ANON = 0x1000,
 	MAP_PRIVATE = 0x2,
+	MAP_FIXED = 0x10,
 	MACH_MSG_TYPE_MOVE_RECEIVE = 0x10,
 	MACH_MSG_TYPE_MOVE_SEND = 0x11,
 	MACH_MSG_TYPE_MOVE_SEND_ONCE = 0x12,
diff --git a/src/pkg/runtime/darwin/amd64/rt0.s b/src/pkg/runtime/darwin/amd64/rt0.s
index 1b706365a..4cfab5876 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 648ef207c..474a1bd5c 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 @@ sighandler(int32 sig, Siginfo *info, void *context)
 	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 @@ sighandler(int32 sig, Siginfo *info, void *context)
 		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, (void*)r->r15);
-		tracebackothers((void*)r->r15);
-		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 1654fa2b0..05dbc7b93 100644
--- a/src/pkg/runtime/darwin/amd64/sys.s
+++ b/src/pkg/runtime/darwin/amd64/sys.s
@@ -7,38 +7,39 @@
 // See http://fxr.watson.org/fxr/source/bsd/kern/syscalls.c?v=xnu-1228
 // or /usr/include/sys/syscall.h (on a Mac) for system call numbers.
 //
+// The low 24 bits are the system call number.
+// The high 8 bits specify the kind of system call: 1=Mach, 2=BSD, 3=Machine-Dependent.
+//
 
 #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)
 	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
@@ -49,7 +50,7 @@ TEXT gettime(SB), 7, $32
 	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
@@ -58,24 +59,40 @@ TEXT	sigaction(SB),7,$0
 	MOVL	$(0x2000000+46), AX	// syscall entry
 	SYSCALL
 	JCC	2(PC)
-	CALL	notok(SB)
+	CALL	runtime·notok(SB)
 	RET
 
-TEXT sigtramp(SB),7,$40
-	MOVQ	m_gsignal(m), g
+TEXT runtime·sigtramp(SB),7,$64
+	get_tls(BX)
+	
+	// save g
+	MOVQ	g(BX), BP
+	MOVQ	BP, 40(SP)
+	
+	// g = m->gsignal
+	MOVQ	m(BX), BP
+	MOVQ	m_gsignal(BP), BP
+	MOVQ	BP, g(BX)
+
 	MOVL	DX, 0(SP)
 	MOVQ	CX, 8(SP)
 	MOVQ	R8, 16(SP)
 	MOVQ	R8, 24(SP)	// save ucontext
 	MOVQ	SI, 32(SP)	// save infostyle
 	CALL	DI
+
+	// restore g
+	get_tls(BX)
+	MOVQ	40(SP), BP
+	MOVQ	BP, g(BX)
+
 	MOVL	$(0x2000000+184), AX	// sigreturn(ucontext, infostyle)
 	MOVQ	24(SP), DI	// saved ucontext
 	MOVQ	32(SP), SI	// saved infostyle
 	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
@@ -84,26 +101,33 @@ TEXT	·mmap(SB),7,$0
 	MOVL	36(SP), R9		// arg 6 offset
 	MOVL	$(0x2000000+197), AX	// syscall entry
 	SYSCALL
+	RET
+
+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.
@@ -132,21 +156,36 @@ TEXT bsdthread_create(SB),7,$0
 //	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
-	MOVQ	CX, m
-	MOVQ	m_g0(m), g
-	CALL	stackcheck(SB)
-	MOVQ	SI, m_procid(m)	// thread port is m->procid
+
+	PUSHQ	DX
+	PUSHQ	CX
+	PUSHQ	SI
+
+	// set up thread local storage pointing at m->tls.
+	LEAQ	m_tls(CX), DI
+	CALL	runtime·settls(SB)
+
+	POPQ	SI
+	POPQ	CX
+	POPQ	DX
+	
+	get_tls(BX)
+	MOVQ	CX, m(BX)
+	MOVQ	SI, m_procid(CX)	// thread port is m->procid
+	MOVQ	m_g0(CX), AX
+	MOVQ	AX, g(BX)
+	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]
@@ -155,13 +194,13 @@ TEXT bsdthread_register(SB),7,$0
 	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
@@ -175,17 +214,17 @@ TEXT mach_msg_trap(SB),7,$0
 	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
@@ -194,14 +233,14 @@ TEXT mach_reply_port(SB),7,$0
 // 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
@@ -210,15 +249,28 @@ TEXT mach_semaphore_timedwait(SB),7,$0
 	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 runtime·settls(SB),7,$32
+	/*
+	* Same as in ../386/sys.s:/ugliness, different constant.
+	* See ../../../../libcgo/darwin_amd64.c for the derivation
+	* of the constant.
+	*/
+	SUBQ $0x8a0, DI
+
+	MOVL	$(0x3000000+3), AX	// thread_fast_set_cthread_self - machdep call #3
+	SYSCALL
+	RET
diff --git a/src/pkg/runtime/darwin/defs.c b/src/pkg/runtime/darwin/defs.c
index 8735e7857..1a1cdf880 100644
--- a/src/pkg/runtime/darwin/defs.c
+++ b/src/pkg/runtime/darwin/defs.c
@@ -26,6 +26,7 @@ enum {
 
 	$MAP_ANON = MAP_ANON,
 	$MAP_PRIVATE = MAP_PRIVATE,
+	$MAP_FIXED = MAP_FIXED,
 
 	$MACH_MSG_TYPE_MOVE_RECEIVE = MACH_MSG_TYPE_MOVE_RECEIVE,
 	$MACH_MSG_TYPE_MOVE_SEND = MACH_MSG_TYPE_MOVE_SEND,
diff --git a/src/pkg/runtime/darwin/mem.c b/src/pkg/runtime/darwin/mem.c
index 52e351a7d..7fb2c2807 100644
--- a/src/pkg/runtime/darwin/mem.c
+++ b/src/pkg/runtime/darwin/mem.c
@@ -4,14 +4,21 @@
 #include "malloc.h"
 
 void*
-SysAlloc(uintptr n)
+runtime·SysAlloc(uintptr n)
 {
+	void *v;
+
 	mstats.sys += n;
-	return 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) {
+		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);
@@ -19,10 +26,14 @@ SysUnused(void *v, uintptr n)
 }
 
 void
-SysFree(void *v, uintptr n)
+runtime·SysFree(void *v, uintptr n)
 {
-	USED(v);
-	USED(n);
-	// TODO(rsc): call munmap
+	mstats.sys -= n;
+	runtime·munmap(v, n);
 }
 
+
+void
+runtime·SysMemInit(void)
+{
+}
diff --git a/src/pkg/runtime/darwin/os.h b/src/pkg/runtime/darwin/os.h
index 51a164c33..35ef4e6d9 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/runtime_defs.go b/src/pkg/runtime/darwin/runtime_defs.go
new file mode 100644
index 000000000..cf0b414a9
--- /dev/null
+++ b/src/pkg/runtime/darwin/runtime_defs.go
@@ -0,0 +1,23 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Go definitions of internal structures. Master is runtime.h
+
+package runtime
+
+type lock struct {
+	key  uint32
+	sema uint32
+}
+
+type usema struct {
+	u uint32
+	k uint32
+}
+
+
+type note struct {
+	wakeup int32
+	sema   usema
+}
diff --git a/src/pkg/runtime/darwin/signals.h b/src/pkg/runtime/darwin/signals.h
index ac9e5d606..035027fad 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 e51d53019..d69c62412 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 @@ initsema(uint32 *psema)
 	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 @@ initsema(uint32 *psema)
 // 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,84 @@ destroylock(Lock *l)
 // 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();
+	if(!runtime·iscgo)
+		runtime·bsdthread_register();
 }
 
 void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·goenvs(void)
+{
+	runtime·goenvs_unix();
+}
+
+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 +181,8 @@ minit(void)
 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 +204,7 @@ mach_msg(MachHeader *h,
 	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 +234,7 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 	CodeMsg *c;
 
 	if((port = m->machport) == 0){
-		port = mach_reply_port();
+		port = runtime·mach_reply_port();
 		m->machport = port;
 	}
 
@@ -240,48 +245,48 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 
 	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 +301,20 @@ machcall(MachHeader *h, int32 maxsize, int32 rxsize)
 	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 +368,7 @@ struct Tmach_semdestroyMsg
 #pragma pack off
 
 uint32
-mach_semcreate(void)
+runtime·mach_semcreate(void)
 {
 	union {
 		Tmach_semcreateMsg tx;
@@ -374,7 +379,7 @@ mach_semcreate(void)
 
 	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 +397,7 @@ mach_semcreate(void)
 }
 
 void
-mach_semdestroy(uint32 sem)
+runtime·mach_semdestroy(uint32 sem)
 {
 	union {
 		Tmach_semdestroyMsg tx;
@@ -402,7 +407,7 @@ mach_semdestroy(uint32 sem)
 
 	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 +422,17 @@ mach_semdestroy(uint32 sem)
 }
 
 // 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 +440,11 @@ mach_semacquire(uint32 sem)
 }
 
 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,25 +452,27 @@ mach_semrelease(uint32 sem)
 }
 
 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");
-		break;
+			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->sigcode1 < 0x1000)
-			panicstring("invalid memory address or nil pointer dereference");
-		break;
+		if((g->sigcode0 == 0 || g->sigcode0 == SEGV_MAPERR || g->sigcode0 == SEGV_ACCERR) && g->sigcode1 < 0x1000)
+			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);
 }