summaryrefslogtreecommitdiff
path: root/src/pkg/runtime/freebsd
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/runtime/freebsd')
-rw-r--r--src/pkg/runtime/freebsd/386/defs.h1
-rw-r--r--src/pkg/runtime/freebsd/386/rt0.s2
-rw-r--r--src/pkg/runtime/freebsd/386/signal.c104
-rw-r--r--src/pkg/runtime/freebsd/386/sys.s70
-rw-r--r--src/pkg/runtime/freebsd/amd64/defs.h1
-rw-r--r--src/pkg/runtime/freebsd/amd64/rt0.s2
-rw-r--r--src/pkg/runtime/freebsd/amd64/signal.c120
-rw-r--r--src/pkg/runtime/freebsd/amd64/sys.s81
-rw-r--r--src/pkg/runtime/freebsd/defs.c1
-rw-r--r--src/pkg/runtime/freebsd/mem.c25
-rw-r--r--src/pkg/runtime/freebsd/os.h8
-rw-r--r--src/pkg/runtime/freebsd/runtime_defs.go14
-rw-r--r--src/pkg/runtime/freebsd/signals.h2
-rw-r--r--src/pkg/runtime/freebsd/thread.c88
14 files changed, 299 insertions, 220 deletions
diff --git a/src/pkg/runtime/freebsd/386/defs.h b/src/pkg/runtime/freebsd/386/defs.h
index 76c55721f..128be9cc9 100644
--- a/src/pkg/runtime/freebsd/386/defs.h
+++ b/src/pkg/runtime/freebsd/386/defs.h
@@ -10,6 +10,7 @@ enum {
PROT_EXEC = 0x4,
MAP_ANON = 0x1000,
MAP_PRIVATE = 0x2,
+ MAP_FIXED = 0x10,
SA_SIGINFO = 0x40,
SA_RESTART = 0x2,
SA_ONSTACK = 0x1,
diff --git a/src/pkg/runtime/freebsd/386/rt0.s b/src/pkg/runtime/freebsd/386/rt0.s
index 67c5f912c..3ca981b3a 100644
--- a/src/pkg/runtime/freebsd/386/rt0.s
+++ b/src/pkg/runtime/freebsd/386/rt0.s
@@ -4,6 +4,6 @@
// Darwin and Linux use the same linkage to main
-TEXT _rt0_386_freebsd(SB),7,$0
+TEXT _rt0_386_freebsd(SB),7,$0
JMP _rt0_386(SB)
diff --git a/src/pkg/runtime/freebsd/386/signal.c b/src/pkg/runtime/freebsd/386/signal.c
index 4fc6d9e12..52b820df1 100644
--- a/src/pkg/runtime/freebsd/386/signal.c
+++ b/src/pkg/runtime/freebsd/386/signal.c
@@ -7,7 +7,7 @@
#include "signals.h"
#include "os.h"
-extern void sigtramp(void);
+extern void runtime·sigtramp(void);
typedef struct sigaction {
union {
@@ -19,33 +19,33 @@ typedef struct sigaction {
} Sigaction;
void
-dumpregs(Mcontext *r)
+runtime·dumpregs(Mcontext *r)
{
- printf("eax %x\n", r->mc_eax);
- printf("ebx %x\n", r->mc_ebx);
- printf("ecx %x\n", r->mc_ecx);
- printf("edx %x\n", r->mc_edx);
- printf("edi %x\n", r->mc_edi);
- printf("esi %x\n", r->mc_esi);
- printf("ebp %x\n", r->mc_ebp);
- printf("esp %x\n", r->mc_esp);
- printf("eip %x\n", r->mc_eip);
- printf("eflags %x\n", r->mc_eflags);
- printf("cs %x\n", r->mc_cs);
- printf("fs %x\n", r->mc_fs);
- printf("gs %x\n", r->mc_gs);
+ runtime·printf("eax %x\n", r->mc_eax);
+ runtime·printf("ebx %x\n", r->mc_ebx);
+ runtime·printf("ecx %x\n", r->mc_ecx);
+ runtime·printf("edx %x\n", r->mc_edx);
+ runtime·printf("edi %x\n", r->mc_edi);
+ runtime·printf("esi %x\n", r->mc_esi);
+ runtime·printf("ebp %x\n", r->mc_ebp);
+ runtime·printf("esp %x\n", r->mc_esp);
+ runtime·printf("eip %x\n", r->mc_eip);
+ runtime·printf("eflags %x\n", r->mc_eflags);
+ runtime·printf("cs %x\n", r->mc_cs);
+ runtime·printf("fs %x\n", r->mc_fs);
+ runtime·printf("gs %x\n", r->mc_gs);
}
String
-signame(int32 sig)
+runtime·signame(int32 sig)
{
if(sig < 0 || sig >= NSIG)
- return emptystring;
- return gostringnocopy((byte*)sigtab[sig].name);
+ return runtime·emptystring;
+ return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
}
void
-sighandler(int32 sig, Siginfo* info, void* context)
+runtime·sighandler(int32 sig, Siginfo* info, void* context)
{
Ucontext *uc;
Mcontext *r;
@@ -55,7 +55,7 @@ sighandler(int32 sig, Siginfo* info, void* context)
uc = context;
r = &uc->uc_mcontext;
- if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+ if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
// Make it look like a call to the signal func.
// Have to pass arguments out of band since
// augmenting the stack frame would break
@@ -64,91 +64,91 @@ sighandler(int32 sig, Siginfo* info, void* context)
gp->sigcode0 = info->si_code;
gp->sigcode1 = (uintptr)info->si_addr;
- // Only push sigpanic if r->mc_eip != 0.
+ // Only push runtime·sigpanic if r->mc_eip != 0.
// If r->mc_eip == 0, probably panicked because of a
// call to a nil func. Not pushing that onto sp will
- // make the trace look like a call to sigpanic instead.
- // (Otherwise the trace will end at sigpanic and we
+ // make the trace look like a call to runtime·sigpanic instead.
+ // (Otherwise the trace will end at runtime·sigpanic and we
// won't get to see who faulted.)
if(r->mc_eip != 0) {
sp = (uintptr*)r->mc_esp;
*--sp = r->mc_eip;
r->mc_esp = (uintptr)sp;
}
- r->mc_eip = (uintptr)sigpanic;
+ r->mc_eip = (uintptr)runtime·sigpanic;
return;
}
- if(sigtab[sig].flags & SigQueue) {
- if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+ if(runtime·sigtab[sig].flags & SigQueue) {
+ if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
return;
- exit(2); // SIGINT, SIGTERM, etc
+ runtime·exit(2); // SIGINT, SIGTERM, etc
}
- if(panicking) // traceback already printed
- exit(2);
- panicking = 1;
+ if(runtime·panicking) // traceback already printed
+ runtime·exit(2);
+ runtime·panicking = 1;
if(sig < 0 || sig >= NSIG)
- printf("Signal %d\n", sig);
+ runtime·printf("Signal %d\n", sig);
else
- printf("%s\n", sigtab[sig].name);
+ runtime·printf("%s\n", runtime·sigtab[sig].name);
- printf("PC=%X\n", r->mc_eip);
- printf("\n");
+ runtime·printf("PC=%X\n", r->mc_eip);
+ runtime·printf("\n");
- if(gotraceback()){
- traceback((void*)r->mc_eip, (void*)r->mc_esp, 0, m->curg);
- tracebackothers(m->curg);
- dumpregs(r);
+ if(runtime·gotraceback()){
+ runtime·traceback((void*)r->mc_eip, (void*)r->mc_esp, 0, m->curg);
+ runtime·tracebackothers(m->curg);
+ runtime·dumpregs(r);
}
- breakpoint();
- exit(2);
+ runtime·breakpoint();
+ runtime·exit(2);
}
void
-sigignore(void)
+runtime·sigignore(void)
{
}
void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
{
Sigaltstack st;
st.ss_sp = (int8*)p;
st.ss_size = n;
st.ss_flags = 0;
- sigaltstack(&st, nil);
+ runtime·sigaltstack(&st, nil);
}
void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
{
static Sigaction sa;
- siginit();
+ runtime·siginit();
int32 i;
sa.sa_flags |= SA_ONSTACK | SA_SIGINFO;
sa.sa_mask = ~0x0ull;
for(i = 0; i < NSIG; i++) {
- if(sigtab[i].flags) {
- if((sigtab[i].flags & SigQueue) != queue)
+ if(runtime·sigtab[i].flags) {
+ if((runtime·sigtab[i].flags & SigQueue) != queue)
continue;
- if(sigtab[i].flags & (SigCatch | SigQueue))
- sa.__sigaction_u.__sa_sigaction = (void*) sigtramp;
+ if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+ sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigtramp;
else
- sa.__sigaction_u.__sa_sigaction = (void*) sigignore;
+ sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigignore;
- if(sigtab[i].flags & SigRestart)
+ if(runtime·sigtab[i].flags & SigRestart)
sa.sa_flags |= SA_RESTART;
else
sa.sa_flags &= ~SA_RESTART;
- sigaction(i, &sa, nil);
+ runtime·sigaction(i, &sa, nil);
}
}
}
diff --git a/src/pkg/runtime/freebsd/386/sys.s b/src/pkg/runtime/freebsd/386/sys.s
index a0860db81..7110e6924 100644
--- a/src/pkg/runtime/freebsd/386/sys.s
+++ b/src/pkg/runtime/freebsd/386/sys.s
@@ -8,17 +8,17 @@
#include "386/asm.h"
-TEXT sys_umtx_op(SB),7,$-4
+TEXT runtime·sys_umtx_op(SB),7,$-4
MOVL $454, AX
INT $0x80
RET
-TEXT thr_new(SB),7,$-4
+TEXT runtime·thr_new(SB),7,$-4
MOVL $455, AX
INT $0x80
RET
-TEXT thr_start(SB),7,$0
+TEXT runtime·thr_start(SB),7,$0
MOVL mm+0(FP), AX
MOVL m_g0(AX), BX
LEAL m_tls(AX), BP
@@ -28,7 +28,7 @@ TEXT thr_start(SB),7,$0
PUSHL $32
PUSHL BP
PUSHL DI
- CALL setldt(SB)
+ CALL runtime·setldt(SB)
POPL AX
POPL AX
POPL AX
@@ -37,43 +37,57 @@ TEXT thr_start(SB),7,$0
MOVL BX, g(CX)
MOVL AX, m(CX)
- CALL stackcheck(SB) // smashes AX
- CALL mstart(SB)
+ CALL runtime·stackcheck(SB) // smashes AX
+ CALL runtime·mstart(SB)
MOVL 0, AX // crash (not reached)
// Exit the entire program (like C exit)
-TEXT exit(SB),7,$-4
+TEXT runtime·exit(SB),7,$-4
MOVL $1, AX
INT $0x80
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT exit1(SB),7,$-4
+TEXT runtime·exit1(SB),7,$-4
MOVL $431, AX
INT $0x80
JAE 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT write(SB),7,$-4
+TEXT runtime·write(SB),7,$-4
MOVL $4, AX
INT $0x80
- JAE 2(PC)
- CALL notok(SB)
RET
-TEXT notok(SB),7,$0
+TEXT runtime·notok(SB),7,$0
MOVL $0xf1, 0xf1
RET
-TEXT ·mmap(SB),7,$-4
+TEXT runtime·mmap(SB),7,$32
+ LEAL arg0+0(FP), SI
+ LEAL 4(SP), DI
+ CLD
+ MOVSL
+ MOVSL
+ MOVSL
+ MOVSL
+ MOVSL
+ MOVSL
+ MOVL $0, AX // top 64 bits of file offset
+ STOSL
MOVL $477, AX
INT $0x80
+ RET
+
+TEXT runtime·munmap(SB),7,$-4
+ MOVL $73, AX
+ INT $0x80
JAE 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
MOVL $116, AX
LEAL 12(SP), BX
MOVL BX, 4(SP)
@@ -90,14 +104,14 @@ TEXT gettime(SB), 7, $32
MOVL BX, (DI)
RET
-TEXT sigaction(SB),7,$-4
+TEXT runtime·sigaction(SB),7,$-4
MOVL $416, AX
INT $0x80
JAE 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT sigtramp(SB),7,$40
+TEXT runtime·sigtramp(SB),7,$40
// g = m->gsignal
get_tls(DX)
MOVL m(DX), BP
@@ -111,7 +125,7 @@ TEXT sigtramp(SB),7,$40
MOVL AX, 0(SP)
MOVL BX, 4(SP)
MOVL CX, 8(SP)
- CALL sighandler(SB)
+ CALL runtime·sighandler(SB)
// g = m->curg
get_tls(DX)
@@ -125,14 +139,14 @@ TEXT sigtramp(SB),7,$40
MOVL AX, 4(SP)
MOVL $417, AX // sigreturn(ucontext)
INT $0x80
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),7,$0
MOVL $53, AX
INT $0x80
JAE 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
/*
@@ -152,7 +166,7 @@ int i386_set_ldt(int, const union ldt_entry *, int);
*/
// setldt(int entry, int address, int limit)
-TEXT setldt(SB),7,$32
+TEXT runtime·setldt(SB),7,$32
MOVL address+4(FP), BX // aka base
// see comment in linux/386/sys.s; freebsd is similar
ADDL $0x8, BX
@@ -177,7 +191,7 @@ TEXT setldt(SB),7,$32
MOVL $0xffffffff, 0(SP) // auto-allocate entry and return in AX
MOVL AX, 4(SP)
MOVL $1, 8(SP)
- CALL i386_set_ldt(SB)
+ CALL runtime·i386_set_ldt(SB)
// compute segment selector - (entry*8+7)
SHLL $3, AX
@@ -185,7 +199,7 @@ TEXT setldt(SB),7,$32
MOVW AX, GS
RET
-TEXT i386_set_ldt(SB),7,$16
+TEXT runtime·i386_set_ldt(SB),7,$16
LEAL args+0(FP), AX // 0(FP) == 4(SP) before SP got moved
MOVL $0, 0(SP) // syscall gap
MOVL $1, 4(SP)
@@ -197,4 +211,4 @@ TEXT i386_set_ldt(SB),7,$16
INT $3
RET
-GLOBL tlsoffset(SB),$4
+GLOBL runtime·tlsoffset(SB),$4
diff --git a/src/pkg/runtime/freebsd/amd64/defs.h b/src/pkg/runtime/freebsd/amd64/defs.h
index 18b68b355..2a295a479 100644
--- a/src/pkg/runtime/freebsd/amd64/defs.h
+++ b/src/pkg/runtime/freebsd/amd64/defs.h
@@ -10,6 +10,7 @@ enum {
PROT_EXEC = 0x4,
MAP_ANON = 0x1000,
MAP_PRIVATE = 0x2,
+ MAP_FIXED = 0x10,
SA_SIGINFO = 0x40,
SA_RESTART = 0x2,
SA_ONSTACK = 0x1,
diff --git a/src/pkg/runtime/freebsd/amd64/rt0.s b/src/pkg/runtime/freebsd/amd64/rt0.s
index 7903b7ccc..5d2eeeeff 100644
--- a/src/pkg/runtime/freebsd/amd64/rt0.s
+++ b/src/pkg/runtime/freebsd/amd64/rt0.s
@@ -4,6 +4,6 @@
// Darwin and Linux use the same linkage to main
-TEXT _rt0_amd64_freebsd(SB),7,$-8
+TEXT _rt0_amd64_freebsd(SB),7,$-8
MOVQ $_rt0_amd64(SB), DX
JMP DX
diff --git a/src/pkg/runtime/freebsd/amd64/signal.c b/src/pkg/runtime/freebsd/amd64/signal.c
index 57bfcfb55..c74ddad0b 100644
--- a/src/pkg/runtime/freebsd/amd64/signal.c
+++ b/src/pkg/runtime/freebsd/amd64/signal.c
@@ -7,7 +7,7 @@
#include "signals.h"
#include "os.h"
-extern void sigtramp(void);
+extern void runtime·sigtramp(void);
typedef struct sigaction {
union {
@@ -19,41 +19,41 @@ typedef struct sigaction {
} Sigaction;
void
-dumpregs(Mcontext *r)
+runtime·dumpregs(Mcontext *r)
{
- printf("rax %X\n", r->mc_rax);
- printf("rbx %X\n", r->mc_rbx);
- printf("rcx %X\n", r->mc_rcx);
- printf("rdx %X\n", r->mc_rdx);
- printf("rdi %X\n", r->mc_rdi);
- printf("rsi %X\n", r->mc_rsi);
- printf("rbp %X\n", r->mc_rbp);
- printf("rsp %X\n", r->mc_rsp);
- printf("r8 %X\n", r->mc_r8 );
- printf("r9 %X\n", r->mc_r9 );
- printf("r10 %X\n", r->mc_r10);
- printf("r11 %X\n", r->mc_r11);
- printf("r12 %X\n", r->mc_r12);
- printf("r13 %X\n", r->mc_r13);
- printf("r14 %X\n", r->mc_r14);
- printf("r15 %X\n", r->mc_r15);
- printf("rip %X\n", r->mc_rip);
- printf("rflags %X\n", r->mc_flags);
- printf("cs %X\n", r->mc_cs);
- printf("fs %X\n", r->mc_fs);
- printf("gs %X\n", r->mc_gs);
+ runtime·printf("rax %X\n", r->mc_rax);
+ runtime·printf("rbx %X\n", r->mc_rbx);
+ runtime·printf("rcx %X\n", r->mc_rcx);
+ runtime·printf("rdx %X\n", r->mc_rdx);
+ runtime·printf("rdi %X\n", r->mc_rdi);
+ runtime·printf("rsi %X\n", r->mc_rsi);
+ runtime·printf("rbp %X\n", r->mc_rbp);
+ runtime·printf("rsp %X\n", r->mc_rsp);
+ runtime·printf("r8 %X\n", r->mc_r8 );
+ runtime·printf("r9 %X\n", r->mc_r9 );
+ runtime·printf("r10 %X\n", r->mc_r10);
+ runtime·printf("r11 %X\n", r->mc_r11);
+ runtime·printf("r12 %X\n", r->mc_r12);
+ runtime·printf("r13 %X\n", r->mc_r13);
+ runtime·printf("r14 %X\n", r->mc_r14);
+ runtime·printf("r15 %X\n", r->mc_r15);
+ runtime·printf("rip %X\n", r->mc_rip);
+ runtime·printf("rflags %X\n", r->mc_flags);
+ runtime·printf("cs %X\n", r->mc_cs);
+ runtime·printf("fs %X\n", r->mc_fs);
+ runtime·printf("gs %X\n", r->mc_gs);
}
String
-signame(int32 sig)
+runtime·signame(int32 sig)
{
if(sig < 0 || sig >= NSIG)
- return emptystring;
- return gostringnocopy((byte*)sigtab[sig].name);
+ return runtime·emptystring;
+ return runtime·gostringnocopy((byte*)runtime·sigtab[sig].name);
}
void
-sighandler(int32 sig, Siginfo* info, void* context)
+runtime·sighandler(int32 sig, Siginfo* info, void* context)
{
Ucontext *uc;
Mcontext *r;
@@ -63,7 +63,7 @@ sighandler(int32 sig, Siginfo* info, void* context)
uc = context;
r = &uc->uc_mcontext;
- if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) {
+ if((gp = m->curg) != nil && (runtime·sigtab[sig].flags & SigPanic)) {
// Make it look like a call to the signal func.
// Have to pass arguments out of band since
// augmenting the stack frame would break
@@ -72,91 +72,91 @@ sighandler(int32 sig, Siginfo* info, void* context)
gp->sigcode0 = info->si_code;
gp->sigcode1 = (uintptr)info->si_addr;
- // Only push sigpanic if r->mc_rip != 0.
+ // Only push runtime·sigpanic if r->mc_rip != 0.
// If r->mc_rip == 0, probably panicked because of a
// call to a nil func. Not pushing that onto sp will
- // make the trace look like a call to sigpanic instead.
- // (Otherwise the trace will end at sigpanic and we
+ // make the trace look like a call to runtime·sigpanic instead.
+ // (Otherwise the trace will end at runtime·sigpanic and we
// won't get to see who faulted.)
if(r->mc_rip != 0) {
sp = (uintptr*)r->mc_rsp;
*--sp = r->mc_rip;
r->mc_rsp = (uintptr)sp;
}
- r->mc_rip = (uintptr)sigpanic;
+ r->mc_rip = (uintptr)runtime·sigpanic;
return;
}
- if(sigtab[sig].flags & SigQueue) {
- if(sigsend(sig) || (sigtab[sig].flags & SigIgnore))
+ if(runtime·sigtab[sig].flags & SigQueue) {
+ if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore))
return;
- exit(2); // SIGINT, SIGTERM, etc
+ runtime·exit(2); // SIGINT, SIGTERM, etc
}
- if(panicking) // traceback already printed
- exit(2);
- panicking = 1;
+ if(runtime·panicking) // traceback already printed
+ runtime·exit(2);
+ runtime·panicking = 1;
if(sig < 0 || sig >= NSIG)
- printf("Signal %d\n", sig);
+ runtime·printf("Signal %d\n", sig);
else
- printf("%s\n", sigtab[sig].name);
+ runtime·printf("%s\n", runtime·sigtab[sig].name);
- printf("PC=%X\n", r->mc_rip);
- printf("\n");
+ runtime·printf("PC=%X\n", r->mc_rip);
+ runtime·printf("\n");
- if(gotraceback()){
- traceback((void*)r->mc_rip, (void*)r->mc_rsp, 0, (void*)r->mc_r15);
- tracebackothers((void*)r->mc_r15);
- dumpregs(r);
+ if(runtime·gotraceback()){
+ runtime·traceback((void*)r->mc_rip, (void*)r->mc_rsp, 0, g);
+ runtime·tracebackothers(g);
+ runtime·dumpregs(r);
}
- breakpoint();
- exit(2);
+ runtime·breakpoint();
+ runtime·exit(2);
}
void
-sigignore(void)
+runtime·sigignore(void)
{
}
void
-signalstack(byte *p, int32 n)
+runtime·signalstack(byte *p, int32 n)
{
Sigaltstack st;
st.ss_sp = (int8*)p;
st.ss_size = n;
st.ss_flags = 0;
- sigaltstack(&st, nil);
+ runtime·sigaltstack(&st, nil);
}
void
-initsig(int32 queue)
+runtime·initsig(int32 queue)
{
static Sigaction sa;
- siginit();
+ runtime·siginit();
int32 i;
sa.sa_flags |= SA_ONSTACK | SA_SIGINFO;
sa.sa_mask = ~0x0ull;
for(i = 0; i < NSIG; i++) {
- if(sigtab[i].flags) {
- if((sigtab[i].flags & SigQueue) != queue)
+ if(runtime·sigtab[i].flags) {
+ if((runtime·sigtab[i].flags & SigQueue) != queue)
continue;
- if(sigtab[i].flags & (SigCatch | SigQueue))
- sa.__sigaction_u.__sa_sigaction = (void*) sigtramp;
+ if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
+ sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigtramp;
else
- sa.__sigaction_u.__sa_sigaction = (void*) sigignore;
+ sa.__sigaction_u.__sa_sigaction = (void*) runtime·sigignore;
- if(sigtab[i].flags & SigRestart)
+ if(runtime·sigtab[i].flags & SigRestart)
sa.sa_flags |= SA_RESTART;
else
sa.sa_flags &= ~SA_RESTART;
- sigaction(i, &sa, nil);
+ runtime·sigaction(i, &sa, nil);
}
}
}
diff --git a/src/pkg/runtime/freebsd/amd64/sys.s b/src/pkg/runtime/freebsd/amd64/sys.s
index 604b763ab..b9cf3832d 100644
--- a/src/pkg/runtime/freebsd/amd64/sys.s
+++ b/src/pkg/runtime/freebsd/amd64/sys.s
@@ -8,7 +8,7 @@
#include "amd64/asm.h"
-TEXT sys_umtx_op(SB),7,$0
+TEXT runtime·sys_umtx_op(SB),7,$0
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVL 20(SP), DX
@@ -18,47 +18,54 @@ TEXT sys_umtx_op(SB),7,$0
SYSCALL
RET
-TEXT thr_new(SB),7,$0
+TEXT runtime·thr_new(SB),7,$0
MOVQ 8(SP), DI
MOVQ 16(SP), SI
MOVL $455, AX
SYSCALL
RET
-TEXT thr_start(SB),7,$0
- MOVQ DI, m
- MOVQ m_g0(m), g
- CALL stackcheck(SB)
- CALL mstart(SB)
- MOVQ 0, AX // crash (not reached)
+TEXT runtime·thr_start(SB),7,$0
+ MOVQ DI, R13 // m
+
+ // set up FS to point at m->tls
+ LEAQ m_tls(R13), DI
+ CALL runtime·settls(SB) // smashes DI
+ // set up m, g
+ get_tls(CX)
+ MOVQ R13, m(CX)
+ MOVQ m_g0(R13), DI
+ MOVQ DI, g(CX)
+
+ CALL runtime·stackcheck(SB)
+ CALL runtime·mstart(SB)
+ MOVQ 0, AX // crash (not reached)
// Exit the entire program (like C exit)
-TEXT exit(SB),7,$-8
+TEXT runtime·exit(SB),7,$-8
MOVL 8(SP), DI // arg 1 exit status
MOVL $1, AX
SYSCALL
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT exit1(SB),7,$-8
+TEXT runtime·exit1(SB),7,$-8
MOVQ 8(SP), DI // arg 1 exit status
MOVL $431, AX
SYSCALL
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT write(SB),7,$-8
+TEXT runtime·write(SB),7,$-8
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
MOVL $4, AX
SYSCALL
- JCC 2(PC)
- CALL notok(SB)
RET
-TEXT gettime(SB), 7, $32
+TEXT runtime·gettime(SB), 7, $32
MOVL $116, AX
LEAQ 8(SP), DI
MOVQ $0, SI
@@ -73,25 +80,28 @@ TEXT gettime(SB), 7, $32
MOVL BX, (DI)
RET
-TEXT sigaction(SB),7,$-8
+TEXT runtime·sigaction(SB),7,$-8
MOVL 8(SP), DI // arg 1 sig
MOVQ 16(SP), SI // arg 2 act
MOVQ 24(SP), DX // arg 3 oact
MOVL $416, AX
SYSCALL
JCC 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT sigtramp(SB),7,$24-16
- MOVQ m_gsignal(m), g
+TEXT runtime·sigtramp(SB),7,$24-16
+ get_tls(CX)
+ MOVQ m(CX), AX
+ MOVQ m_gsignal(AX), AX
+ MOVQ AX, g(CX)
MOVQ DI, 0(SP)
MOVQ SI, 8(SP)
MOVQ DX, 16(SP)
- CALL sighandler(SB)
+ CALL runtime·sighandler(SB)
RET
-TEXT ·mmap(SB),7,$0
+TEXT runtime·mmap(SB),7,$0
MOVQ 8(SP), DI // arg 1 addr
MOVQ 16(SP), SI // arg 2 len
MOVL 24(SP), DX // arg 3 prot
@@ -100,20 +110,39 @@ TEXT ·mmap(SB),7,$0
MOVL 36(SP), R9 // arg 6 offset
MOVL $477, AX
SYSCALL
+ RET
+
+TEXT runtime·munmap(SB),7,$0
+ MOVQ 8(SP), DI // arg 1 addr
+ MOVQ 16(SP), SI // arg 2 len
+ MOVL $73, AX
+ SYSCALL
JCC 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
RET
-TEXT notok(SB),7,$-8
+TEXT runtime·notok(SB),7,$-8
MOVL $0xf1, BP
MOVQ BP, (BP)
RET
-TEXT sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),7,$-8
MOVQ new+8(SP), DI
MOVQ old+16(SP), SI
MOVQ $53, AX
SYSCALL
JCC 2(PC)
- CALL notok(SB)
+ CALL runtime·notok(SB)
+ RET
+
+// set tls base to DI
+TEXT runtime·settls(SB),7,$8
+ ADDQ $16, DI // adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
+ MOVQ DI, 0(SP)
+ MOVQ SP, SI
+ MOVQ $129, DI // AMD64_SET_FSBASE
+ MOVQ $165, AX // sysarch
+ SYSCALL
+ JCC 2(PC)
+ CALL runtime·notok(SB)
RET
diff --git a/src/pkg/runtime/freebsd/defs.c b/src/pkg/runtime/freebsd/defs.c
index 36e69093e..32a80f475 100644
--- a/src/pkg/runtime/freebsd/defs.c
+++ b/src/pkg/runtime/freebsd/defs.c
@@ -28,6 +28,7 @@ enum {
$MAP_ANON = MAP_ANON,
$MAP_PRIVATE = MAP_PRIVATE,
+ $MAP_FIXED = MAP_FIXED,
$SA_SIGINFO = SA_SIGINFO,
$SA_RESTART = SA_RESTART,
diff --git a/src/pkg/runtime/freebsd/mem.c b/src/pkg/runtime/freebsd/mem.c
index 52e351a7d..7fb2c2807 100644
--- a/src/pkg/runtime/freebsd/mem.c
+++ b/src/pkg/runtime/freebsd/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/freebsd/os.h b/src/pkg/runtime/freebsd/os.h
index 47bf7d56f..455355bc7 100644
--- a/src/pkg/runtime/freebsd/os.h
+++ b/src/pkg/runtime/freebsd/os.h
@@ -1,5 +1,5 @@
-int32 thr_new(ThrParam*, int32);
-void sigpanic(void);
-void sigaltstack(Sigaltstack*, Sigaltstack*);
+int32 runtime·thr_new(ThrParam*, int32);
+void runtime·sigpanic(void);
+void runtime·sigaltstack(Sigaltstack*, Sigaltstack*);
struct sigaction;
-void sigaction(int32, struct sigaction*, struct sigaction*);
+void runtime·sigaction(int32, struct sigaction*, struct sigaction*);
diff --git a/src/pkg/runtime/freebsd/runtime_defs.go b/src/pkg/runtime/freebsd/runtime_defs.go
new file mode 100644
index 000000000..86de13316
--- /dev/null
+++ b/src/pkg/runtime/freebsd/runtime_defs.go
@@ -0,0 +1,14 @@
+// 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.
+
+// OS-Specific Go definitions of internal structures. Master is runtime.h
+
+package runtime
+
+type lock struct {
+ key uint32
+ sema uint32
+}
+
+type note lock
diff --git a/src/pkg/runtime/freebsd/signals.h b/src/pkg/runtime/freebsd/signals.h
index 0c41daf84..63a84671d 100644
--- a/src/pkg/runtime/freebsd/signals.h
+++ b/src/pkg/runtime/freebsd/signals.h
@@ -8,7 +8,7 @@
#define Q SigQueue
#define P SigPanic
-SigTab sigtab[] = {
+SigTab runtime·sigtab[] = {
/* 0 */ 0, "SIGNONE: no trap",
/* 1 */ Q+R, "SIGHUP: terminal line hangup",
/* 2 */ Q+R, "SIGINT: interrupt",
diff --git a/src/pkg/runtime/freebsd/thread.c b/src/pkg/runtime/freebsd/thread.c
index 334043312..9bd883833 100644
--- a/src/pkg/runtime/freebsd/thread.c
+++ b/src/pkg/runtime/freebsd/thread.c
@@ -5,8 +5,8 @@
#include "defs.h"
#include "os.h"
-extern SigTab sigtab[];
-extern int32 sys_umtx_op(uint32*, int32, uint32, void*, void*);
+extern SigTab runtime·sigtab[];
+extern int32 runtime·sys_umtx_op(uint32*, int32, uint32, void*, void*);
// FreeBSD's umtx_op syscall is effectively the same as Linux's futex, and
// thus the code is largely similar. See linux/thread.c for comments.
@@ -16,11 +16,11 @@ umtx_wait(uint32 *addr, uint32 val)
{
int32 ret;
- ret = sys_umtx_op(addr, UMTX_OP_WAIT, val, nil, nil);
+ ret = runtime·sys_umtx_op(addr, UMTX_OP_WAIT, val, nil, nil);
if(ret >= 0 || ret == -EINTR)
return;
- printf("umtx_wait addr=%p val=%d ret=%d\n", addr, val, ret);
+ runtime·printf("umtx_wait addr=%p val=%d ret=%d\n", addr, val, ret);
*(int32*)0x1005 = 0x1005;
}
@@ -29,11 +29,11 @@ umtx_wake(uint32 *addr)
{
int32 ret;
- ret = sys_umtx_op(addr, UMTX_OP_WAKE, 1, nil, nil);
+ ret = runtime·sys_umtx_op(addr, UMTX_OP_WAKE, 1, nil, nil);
if(ret >= 0)
return;
- printf("umtx_wake addr=%p ret=%d\n", addr, ret);
+ runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
*(int32*)0x1006 = 0x1006;
}
@@ -46,12 +46,12 @@ umtx_lock(Lock *l)
again:
v = l->key;
if((v&1) == 0){
- if(cas(&l->key, v, v|1))
+ if(runtime·cas(&l->key, v, v|1))
return;
goto again;
}
- if(!cas(&l->key, v, v+2))
+ if(!runtime·cas(&l->key, v, v+2))
goto again;
umtx_wait(&l->key, v+2);
@@ -59,8 +59,8 @@ again:
for(;;){
v = l->key;
if(v < 2)
- throw("bad lock key");
- if(cas(&l->key, v, v-2))
+ runtime·throw("bad lock key");
+ if(runtime·cas(&l->key, v, v-2))
break;
}
@@ -75,8 +75,8 @@ umtx_unlock(Lock *l)
again:
v = l->key;
if((v&1) == 0)
- throw("unlock of unlocked lock");
- if(!cas(&l->key, v, v&~1))
+ runtime·throw("unlock of unlocked lock");
+ if(!runtime·cas(&l->key, v, v&~1))
goto again;
if(v&~1)
@@ -84,53 +84,53 @@ again:
}
void
-lock(Lock *l)
+runtime·lock(Lock *l)
{
if(m->locks < 0)
- throw("lock count");
+ runtime·throw("lock count");
m->locks++;
umtx_lock(l);
}
void
-unlock(Lock *l)
+runtime·unlock(Lock *l)
{
m->locks--;
if(m->locks < 0)
- throw("lock count");
+ runtime·throw("lock count");
umtx_unlock(l);
}
void
-destroylock(Lock*)
+runtime·destroylock(Lock*)
{
}
// Event notifications.
void
-noteclear(Note *n)
+runtime·noteclear(Note *n)
{
n->lock.key = 0;
umtx_lock(&n->lock);
}
void
-notesleep(Note *n)
+runtime·notesleep(Note *n)
{
umtx_lock(&n->lock);
umtx_unlock(&n->lock);
}
void
-notewakeup(Note *n)
+runtime·notewakeup(Note *n)
{
umtx_unlock(&n->lock);
}
-void thr_start(void*);
+void runtime·thr_start(void*);
void
-newosproc(M *m, G *g, void *stk, void (*fn)(void))
+runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
{
ThrParam param;
@@ -138,13 +138,13 @@ newosproc(M *m, G *g, void *stk, void (*fn)(void))
USED(g); // thr_start assumes g == m->g0
if(0){
- printf("newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
+ runtime·printf("newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
stk, m, g, fn, m->id, m->tls[0], &m);
}
- runtime_memclr((byte*)&param, sizeof param);
+ runtime·memclr((byte*)&param, sizeof param);
- param.start_func = thr_start;
+ param.start_func = runtime·thr_start;
param.arg = m;
param.stack_base = (int8*)g->stackbase;
param.stack_size = (byte*)stk - (byte*)g->stackbase;
@@ -155,43 +155,51 @@ newosproc(M *m, G *g, void *stk, void (*fn)(void))
m->tls[0] = m->id; // so 386 asm can find it
- thr_new(&param, sizeof param);
+ runtime·thr_new(&param, sizeof param);
}
void
-osinit(void)
+runtime·osinit(void)
{
}
+void
+runtime·goenvs(void)
+{
+ runtime·goenvs_unix();
+}
+
// Called to initialize a new m (including the bootstrap m).
void
-minit(void)
+runtime·minit(void)
{
// Initialize signal handling
- m->gsignal = malg(32*1024);
- signalstack(m->gsignal->stackguard, 32*1024);
+ m->gsignal = runtime·malg(32*1024);
+ runtime·signalstack(m->gsignal->stackguard, 32*1024);
}
void
-sigpanic(void)
+runtime·sigpanic(void)
{
switch(g->sig) {
case SIGBUS:
if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000)
- panicstring("invalid memory address or nil pointer dereference");
- 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);
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-09-04 21:14:32 +0000