[dev.power64] code review 160200044: build: merge default into dev.power64

src/pkg/runtime/sys_darwin_386.s

 // 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 "zasm_GOOS_GOARCH.h"
-#include "../../cmd/ld/textflag.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
+        MOVL    AX, ret+12(FP)
         RET
 
 TEXT runtime·close(SB),NOSPLIT,$0
         MOVL    $6, AX
         INT     $0x80
+        MOVL    AX, ret+4(FP)
         RET
 
 TEXT runtime·read(SB),NOSPLIT,$0
         MOVL    $3, AX
         INT     $0x80
+        MOVL    AX, ret+12(FP)
         RET
 
 TEXT runtime·write(SB),NOSPLIT,$0
         MOVL    $4, AX
         INT     $0x80
+        MOVL    AX, ret+12(FP)
         RET
 
 TEXT runtime·raise(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
@@ skipping 127 matching lines @@
         DIVL    CX
         MOVL    AX, sec+0(FP)
         MOVL    $0, sec+4(FP)
         MOVL    DX, nsec+8(FP)
         RET
 
 // int64 nanotime(void) so really
 // void nanotime(int64 *nsec)
 TEXT runtime·nanotime(SB),NOSPLIT,$0
         CALL    runtime·now(SB)
-        MOVL    ret+0(FP), DI
-        MOVL    AX, 0(DI)
-        MOVL    DX, 4(DI)
+        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
@@ skipping 86 matching lines @@
         MOVL    AX, 20(SP)
         MOVL    $93, AX
         INT     $0x80
         RET
 
 // void bsdthread_create(void *stk, M *mp, G *gp, void (*fn)(void))
 // 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    func+12(FP), BX
+        MOVL    fn+12(FP), BX
         MOVL    BX, 4(SP)       // func
         MOVL    mm+4(FP), BX
         MOVL    BX, 8(SP)       // arg
         MOVL    stk+0(FP), BX
         MOVL    BX, 12(SP)      // stack
         MOVL    gg+8(FP), BX
         MOVL    BX, 16(SP)      // pthread
         MOVL    $0x1000000, 20(SP)      // flags = PTHREAD_START_CUSTOM
         INT     $0x80
-        JAE     3(PC)
+        JAE     4(PC)
         NEGL    AX
+        MOVL    AX, ret+16(FP)
         RET
         MOVL    $0, AX
+        MOVL    AX, ret+16(FP)
         RET
 
 // The thread that bsdthread_create creates starts executing here,
 // because we registered this function using bsdthread_register
 // at startup.
 //      AX = "pthread" (= g)
 //      BX = mach thread port
 //      CX = "func" (= fn)
 //      DX = "arg" (= m)
 //      DI = stack top
@@ skipping 33 matching lines @@
 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     3(PC)
+        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.
 
 // uint32 mach_semaphore_wait(uint32)
 TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
         MOVL    $-36, AX
         CALL    runtime·sysenter(SB)
+        MOVL    AX, ret+4(FP)
         RET
 
 // uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
 TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
         MOVL    $-38, AX
         CALL    runtime·sysenter(SB)
+        MOVL    AX, ret+12(FP)
         RET
 
 // uint32 mach_semaphore_signal(uint32)
 TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
         MOVL    $-33, AX
         CALL    runtime·sysenter(SB)
+        MOVL    AX, ret+4(FP)
         RET
 
 // uint32 mach_semaphore_signal_all(uint32)
 TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
         MOVL    $-34, AX
         CALL    runtime·sysenter(SB)
+        MOVL    AX, ret+4(FP)
         RET
 
 // setldt(int entry, int address, int limit)
 // 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
@@ skipping 21 matching lines @@
         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     3(PC)
+        JAE     4(PC)
         NEGL    AX
+        MOVL    AX, ret+24(FP)
         RET
         MOVL    $0, AX
+        MOVL    AX, ret+24(FP)
         RET
 
 // int32 runtime·kqueue(void);
 TEXT runtime·kqueue(SB),NOSPLIT,$0
         MOVL    $362, AX
         INT     $0x80
         JAE     2(PC)
         NEGL    AX
+        MOVL    AX, ret+0(FP)
         RET
 
 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
 TEXT runtime·kevent(SB),NOSPLIT,$0
         MOVL    $363, AX
         INT     $0x80
         JAE     2(PC)
         NEGL    AX
+        MOVL    AX, ret+24(FP)
         RET
 
 // int32 runtime·closeonexec(int32 fd);
 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