| // Copyright 2009 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. |
| |
| // System calls and other sys.stuff for 386, Darwin |
| // 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. |
| |
| #include "go_asm.h" |
| #include "go_tls.h" |
| #include "textflag.h" |
| |
| // Exit the entire program (like C exit) |
| TEXT runtime·exit(SB),NOSPLIT,$0 |
| MOVL $1, AX |
| INT $0x80 |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| // Exit this OS thread (like pthread_exit, which eventually |
| // calls __bsdthread_terminate). |
| TEXT runtime·exit1(SB),NOSPLIT,$0 |
| MOVL $361, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| TEXT runtime·open(SB),NOSPLIT,$0 |
| MOVL $5, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $-1, AX |
| MOVL AX, ret+12(FP) |
| RET |
| |
| TEXT runtime·closefd(SB),NOSPLIT,$0 |
| MOVL $6, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $-1, AX |
| MOVL AX, ret+4(FP) |
| RET |
| |
| TEXT runtime·read(SB),NOSPLIT,$0 |
| MOVL $3, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $-1, AX |
| MOVL AX, ret+12(FP) |
| RET |
| |
| TEXT runtime·write(SB),NOSPLIT,$0 |
| MOVL $4, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $-1, AX |
| MOVL AX, ret+12(FP) |
| RET |
| |
| TEXT runtime·raise(SB),NOSPLIT,$0 |
| // Ideally we'd send the signal to the current thread, |
| // not the whole process, but that's too hard on OS X. |
| JMP runtime·raiseproc(SB) |
| |
| TEXT runtime·raiseproc(SB),NOSPLIT,$16 |
| MOVL $20, AX // getpid |
| INT $0x80 |
| MOVL AX, 4(SP) // pid |
| MOVL sig+0(FP), AX |
| MOVL AX, 8(SP) // signal |
| MOVL $1, 12(SP) // posix |
| MOVL $37, AX // kill |
| INT $0x80 |
| RET |
| |
| TEXT runtime·mmap(SB),NOSPLIT,$0 |
| MOVL $197, AX |
| INT $0x80 |
| MOVL AX, ret+24(FP) |
| RET |
| |
| TEXT runtime·madvise(SB),NOSPLIT,$0 |
| MOVL $75, AX |
| INT $0x80 |
| // ignore failure - maybe pages are locked |
| RET |
| |
| TEXT runtime·munmap(SB),NOSPLIT,$0 |
| MOVL $73, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| TEXT runtime·setitimer(SB),NOSPLIT,$0 |
| MOVL $83, AX |
| INT $0x80 |
| RET |
| |
| // OS X comm page time offsets |
| // http://www.opensource.apple.com/source/xnu/xnu-1699.26.8/osfmk/i386/cpu_capabilities.h |
| #define cpu_capabilities 0x20 |
| #define nt_tsc_base 0x50 |
| #define nt_scale 0x58 |
| #define nt_shift 0x5c |
| #define nt_ns_base 0x60 |
| #define nt_generation 0x68 |
| #define gtod_generation 0x6c |
| #define gtod_ns_base 0x70 |
| #define gtod_sec_base 0x78 |
| |
| // called from assembly |
| // 64-bit unix nanoseconds returned in DX:AX. |
| // I'd much rather write this in C but we need |
| // assembly for the 96-bit multiply and RDTSC. |
| TEXT runtime·now(SB),NOSPLIT,$40 |
| MOVL $0xffff0000, BP /* comm page base */ |
| |
| // Test for slow CPU. If so, the math is completely |
| // different, and unimplemented here, so use the |
| // system call. |
| MOVL cpu_capabilities(BP), AX |
| TESTL $0x4000, AX |
| JNZ systime |
| |
| // Loop trying to take a consistent snapshot |
| // of the time parameters. |
| timeloop: |
| MOVL gtod_generation(BP), BX |
| TESTL BX, BX |
| JZ systime |
| MOVL nt_generation(BP), CX |
| TESTL CX, CX |
| JZ timeloop |
| RDTSC |
| MOVL nt_tsc_base(BP), SI |
| MOVL (nt_tsc_base+4)(BP), DI |
| MOVL SI, 0(SP) |
| MOVL DI, 4(SP) |
| MOVL nt_scale(BP), SI |
| MOVL SI, 8(SP) |
| MOVL nt_ns_base(BP), SI |
| MOVL (nt_ns_base+4)(BP), DI |
| MOVL SI, 12(SP) |
| MOVL DI, 16(SP) |
| CMPL nt_generation(BP), CX |
| JNE timeloop |
| MOVL gtod_ns_base(BP), SI |
| MOVL (gtod_ns_base+4)(BP), DI |
| MOVL SI, 20(SP) |
| MOVL DI, 24(SP) |
| MOVL gtod_sec_base(BP), SI |
| MOVL (gtod_sec_base+4)(BP), DI |
| MOVL SI, 28(SP) |
| MOVL DI, 32(SP) |
| CMPL gtod_generation(BP), BX |
| JNE timeloop |
| |
| // Gathered all the data we need. Compute time. |
| // ((tsc - nt_tsc_base) * nt_scale) >> 32 + nt_ns_base - gtod_ns_base + gtod_sec_base*1e9 |
| // The multiply and shift extracts the top 64 bits of the 96-bit product. |
| SUBL 0(SP), AX // DX:AX = (tsc - nt_tsc_base) |
| SBBL 4(SP), DX |
| |
| // We have x = tsc - nt_tsc_base - DX:AX to be |
| // multiplied by y = nt_scale = 8(SP), keeping the top 64 bits of the 96-bit product. |
| // x*y = (x&0xffffffff)*y + (x&0xffffffff00000000)*y |
| // (x*y)>>32 = ((x&0xffffffff)*y)>>32 + (x>>32)*y |
| MOVL DX, CX // SI = (x&0xffffffff)*y >> 32 |
| MOVL $0, DX |
| MULL 8(SP) |
| MOVL DX, SI |
| |
| MOVL CX, AX // DX:AX = (x>>32)*y |
| MOVL $0, DX |
| MULL 8(SP) |
| |
| ADDL SI, AX // DX:AX += (x&0xffffffff)*y >> 32 |
| ADCL $0, DX |
| |
| // DX:AX is now ((tsc - nt_tsc_base) * nt_scale) >> 32. |
| ADDL 12(SP), AX // DX:AX += nt_ns_base |
| ADCL 16(SP), DX |
| SUBL 20(SP), AX // DX:AX -= gtod_ns_base |
| SBBL 24(SP), DX |
| MOVL AX, SI // DI:SI = DX:AX |
| MOVL DX, DI |
| MOVL 28(SP), AX // DX:AX = gtod_sec_base*1e9 |
| MOVL 32(SP), DX |
| MOVL $1000000000, CX |
| MULL CX |
| ADDL SI, AX // DX:AX += DI:SI |
| ADCL DI, DX |
| RET |
| |
| systime: |
| // Fall back to system call (usually first call in this thread) |
| LEAL 16(SP), AX // must be non-nil, unused |
| MOVL AX, 4(SP) |
| MOVL $0, 8(SP) // time zone pointer |
| MOVL $0, 12(SP) // required as of Sierra; Issue 16570 |
| MOVL $116, AX |
| INT $0x80 |
| CMPL AX, $0 |
| JNE inreg |
| MOVL 16(SP), AX |
| MOVL 20(SP), DX |
| inreg: |
| // sec is in AX, usec in DX |
| // convert to DX:AX nsec |
| MOVL DX, BX |
| MOVL $1000000000, CX |
| MULL CX |
| IMULL $1000, BX |
| ADDL BX, AX |
| ADCL $0, DX |
| RET |
| |
| // func now() (sec int64, nsec int32) |
| TEXT time·now(SB),NOSPLIT,$0 |
| CALL runtime·now(SB) |
| MOVL $1000000000, CX |
| DIVL CX |
| MOVL AX, sec+0(FP) |
| MOVL $0, sec+4(FP) |
| MOVL DX, nsec+8(FP) |
| RET |
| |
| // func nanotime() int64 |
| TEXT runtime·nanotime(SB),NOSPLIT,$0 |
| CALL runtime·now(SB) |
| MOVL AX, ret_lo+0(FP) |
| MOVL DX, ret_hi+4(FP) |
| RET |
| |
| TEXT runtime·sigprocmask(SB),NOSPLIT,$0 |
| MOVL $329, AX // pthread_sigmask (on OS X, sigprocmask==entire process) |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| TEXT runtime·sigaction(SB),NOSPLIT,$0 |
| MOVL $46, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| TEXT runtime·sigfwd(SB),NOSPLIT,$0-16 |
| MOVL fn+0(FP), AX |
| MOVL sig+4(FP), BX |
| MOVL info+8(FP), CX |
| MOVL ctx+12(FP), DX |
| MOVL SP, SI |
| SUBL $32, SP // align stack; handler might be C code |
| ANDL $~15, SP |
| MOVL BX, 0(SP) |
| MOVL CX, 4(SP) |
| MOVL DX, 8(SP) |
| MOVL SI, 12(SP) |
| CALL AX |
| MOVL 12(SP), AX |
| MOVL AX, SP |
| RET |
| |
| TEXT runtime·sigreturn(SB),NOSPLIT,$12-8 |
| MOVL ctx+0(FP), CX |
| MOVL infostyle+4(FP), BX |
| MOVL $0, 0(SP) // "caller PC" - ignored |
| MOVL CX, 4(SP) |
| MOVL BX, 8(SP) |
| MOVL $184, AX // sigreturn(ucontext, infostyle) |
| INT $0x80 |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| // Sigtramp's job is to call the actual signal handler. |
| // It is called with the following arguments on the stack: |
| // 0(SP) "return address" - ignored |
| // 4(SP) actual handler |
| // 8(SP) signal number |
| // 12(SP) siginfo style |
| // 16(SP) siginfo |
| // 20(SP) context |
| TEXT runtime·sigtramp(SB),NOSPLIT,$20 |
| MOVL fn+0(FP), BX |
| MOVL BX, 0(SP) |
| MOVL style+4(FP), BX |
| MOVL BX, 4(SP) |
| MOVL sig+8(FP), BX |
| MOVL BX, 8(SP) |
| MOVL info+12(FP), BX |
| MOVL BX, 12(SP) |
| MOVL context+16(FP), BX |
| MOVL BX, 16(SP) |
| CALL runtime·sigtrampgo(SB) |
| |
| // call sigreturn |
| MOVL context+16(FP), CX |
| MOVL style+4(FP), BX |
| MOVL $0, 0(SP) // "caller PC" - ignored |
| MOVL CX, 4(SP) |
| MOVL BX, 8(SP) |
| MOVL $184, AX // sigreturn(ucontext, infostyle) |
| INT $0x80 |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| TEXT runtime·sigaltstack(SB),NOSPLIT,$0 |
| MOVL $53, AX |
| INT $0x80 |
| JAE 2(PC) |
| MOVL $0xf1, 0xf1 // crash |
| RET |
| |
| TEXT runtime·usleep(SB),NOSPLIT,$32 |
| MOVL $0, DX |
| MOVL usec+0(FP), AX |
| MOVL $1000000, CX |
| DIVL CX |
| MOVL AX, 24(SP) // sec |
| MOVL DX, 28(SP) // usec |
| |
| // select(0, 0, 0, 0, &tv) |
| MOVL $0, 0(SP) // "return PC" - ignored |
| MOVL $0, 4(SP) |
| MOVL $0, 8(SP) |
| MOVL $0, 12(SP) |
| MOVL $0, 16(SP) |
| LEAL 24(SP), AX |
| MOVL AX, 20(SP) |
| MOVL $93, AX |
| INT $0x80 |
| RET |
| |
| // func bsdthread_create(stk, arg unsafe.Pointer, fn uintptr) int32 |
| // System call args are: func arg stack pthread flags. |
| TEXT runtime·bsdthread_create(SB),NOSPLIT,$32 |
| MOVL $360, AX |
| // 0(SP) is where the caller PC would be; kernel skips it |
| MOVL fn+8(FP), BX |
| MOVL BX, 4(SP) // func |
| MOVL arg+4(FP), BX |
| MOVL BX, 8(SP) // arg |
| MOVL stk+0(FP), BX |
| MOVL BX, 12(SP) // stack |
| MOVL $0, 16(SP) // pthread |
| MOVL $0x1000000, 20(SP) // flags = PTHREAD_START_CUSTOM |
| INT $0x80 |
| JAE 4(PC) |
| NEGL AX |
| MOVL AX, ret+12(FP) |
| RET |
| MOVL $0, AX |
| MOVL AX, ret+12(FP) |
| RET |
| |
| // The thread that bsdthread_create creates starts executing here, |
| // because we registered this function using bsdthread_register |
| // at startup. |
| // AX = "pthread" (= 0x0) |
| // BX = mach thread port |
| // CX = "func" (= fn) |
| // DX = "arg" (= m) |
| // DI = stack top |
| // SI = flags (= 0x1000000) |
| // SP = stack - C_32_STK_ALIGN |
| TEXT runtime·bsdthread_start(SB),NOSPLIT,$0 |
| // set up ldt 7+id to point at m->tls. |
| LEAL m_tls(DX), BP |
| MOVL m_id(DX), DI |
| ADDL $7, DI // m0 is LDT#7. count up. |
| // setldt(tls#, &tls, sizeof tls) |
| PUSHAL // save registers |
| PUSHL $32 // sizeof tls |
| PUSHL BP // &tls |
| PUSHL DI // tls # |
| CALL runtime·setldt(SB) |
| POPL AX |
| POPL AX |
| POPL AX |
| POPAL |
| |
| // Now segment is established. Initialize m, g. |
| get_tls(BP) |
| MOVL m_g0(DX), AX |
| MOVL AX, g(BP) |
| MOVL DX, g_m(AX) |
| MOVL BX, m_procid(DX) // m->procid = thread port (for debuggers) |
| CALL runtime·stackcheck(SB) // smashes AX |
| CALL CX // fn() |
| CALL runtime·exit1(SB) |
| RET |
| |
| // func bsdthread_register() int32 |
| // registers callbacks for threadstart (see bsdthread_create above |
| // and wqthread and pthsize (not used). returns 0 on success. |
| TEXT runtime·bsdthread_register(SB),NOSPLIT,$40 |
| MOVL $366, AX |
| // 0(SP) is where kernel expects caller PC; ignored |
| 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] |
| MOVL $0, 20(SP) // targetconc_ptr |
| MOVL $0, 24(SP) // dispatchqueue_offset |
| INT $0x80 |
| JAE 4(PC) |
| NEGL AX |
| MOVL AX, ret+0(FP) |
| RET |
| MOVL $0, AX |
| MOVL AX, ret+0(FP) |
| RET |
| |
| // Invoke Mach system call. |
| // Assumes system call number in AX, |
| // caller PC on stack, caller's caller PC next, |
| // and then the system call arguments. |
| // |
| // Can be used for BSD too, but we don't, |
| // because if you use this interface the BSD |
| // system call numbers need an extra field |
| // 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 runtime·sysenter(SB),NOSPLIT,$0 |
| POPL DX |
| MOVL SP, CX |
| BYTE $0x0F; BYTE $0x34; // SYSENTER |
| // returns to DX with SP set to CX |
| |
| TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0 |
| MOVL $-31, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+28(FP) |
| RET |
| |
| TEXT runtime·mach_reply_port(SB),NOSPLIT,$0 |
| MOVL $-26, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+0(FP) |
| RET |
| |
| TEXT runtime·mach_task_self(SB),NOSPLIT,$0 |
| MOVL $-28, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+0(FP) |
| RET |
| |
| // Mach provides trap versions of the semaphore ops, |
| // instead of requiring the use of RPC. |
| |
| // func mach_semaphore_wait(sema uint32) int32 |
| TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0 |
| MOVL $-36, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+4(FP) |
| RET |
| |
| // func mach_semaphore_timedwait(sema, sec, nsec uint32) int32 |
| TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0 |
| MOVL $-38, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+12(FP) |
| RET |
| |
| // func mach_semaphore_signal(sema uint32) int32 |
| TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0 |
| MOVL $-33, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+4(FP) |
| RET |
| |
| // func mach_semaphore_signal_all(sema uint32) int32 |
| TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0 |
| MOVL $-34, AX |
| CALL runtime·sysenter(SB) |
| MOVL AX, ret+4(FP) |
| RET |
| |
| // func setldt(entry int, address int, limit int) |
| // entry and limit are ignored. |
| TEXT runtime·setldt(SB),NOSPLIT,$32 |
| MOVL address+4(FP), BX // aka base |
| |
| /* |
| * When linking against the system libraries, |
| * we use its pthread_create and let it set up %gs |
| * for us. When we do that, the private storage |
| * we get is not at 0(GS) but at 0x468(GS). |
| * 8l rewrites 0(TLS) into 0x468(GS) for us. |
| * To accommodate that rewrite, we translate the |
| * address and limit here so that 0x468(GS) maps to 0(address). |
| * |
| * See cgo/gcc_darwin_386.c:/468 for the derivation |
| * of the constant. |
| */ |
| SUBL $0x468, BX |
| |
| /* |
| * Must set up as USER_CTHREAD segment because |
| * Darwin forces that value into %gs for signal handlers, |
| * and if we don't set one up, we'll get a recursive |
| * fault trying to get into the signal handler. |
| * Since we have to set one up anyway, it might as |
| * well be the value we want. So don't bother with |
| * i386_set_ldt. |
| */ |
| MOVL BX, 4(SP) |
| MOVL $3, AX // thread_fast_set_cthread_self - machdep call #3 |
| INT $0x82 // sic: 0x82, not 0x80, for machdep call |
| |
| XORL AX, AX |
| MOVW GS, AX |
| RET |
| |
| TEXT runtime·sysctl(SB),NOSPLIT,$0 |
| MOVL $202, AX |
| INT $0x80 |
| JAE 4(PC) |
| NEGL AX |
| MOVL AX, ret+24(FP) |
| RET |
| MOVL $0, AX |
| MOVL AX, ret+24(FP) |
| RET |
| |
| // func kqueue() int32 |
| TEXT runtime·kqueue(SB),NOSPLIT,$0 |
| MOVL $362, AX |
| INT $0x80 |
| JAE 2(PC) |
| NEGL AX |
| MOVL AX, ret+0(FP) |
| RET |
| |
| // func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 |
| TEXT runtime·kevent(SB),NOSPLIT,$0 |
| MOVL $363, AX |
| INT $0x80 |
| JAE 2(PC) |
| NEGL AX |
| MOVL AX, ret+24(FP) |
| RET |
| |
| // func closeonexec(fd int32) |
| TEXT runtime·closeonexec(SB),NOSPLIT,$32 |
| MOVL $92, AX // fcntl |
| // 0(SP) is where the caller PC would be; kernel skips it |
| MOVL fd+0(FP), BX |
| MOVL BX, 4(SP) // fd |
| MOVL $2, 8(SP) // F_SETFD |
| MOVL $1, 12(SP) // FD_CLOEXEC |
| INT $0x80 |
| JAE 2(PC) |
| NEGL AX |
| RET |