code review 5792048: runtime: inline calls to notok

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"
 
-TEXT runtime·notok(SB),7,$0
-        MOVL    $0xf1, 0xf1
-        RET
-
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),7,$0
         MOVL    $1, AX
         INT     $0x80
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 // Exit this OS thread (like pthread_exit, which eventually
 // calls __bsdthread_terminate).
 TEXT runtime·exit1(SB),7,$0
         MOVL    $361, AX
         INT     $0x80
         JAE 2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·write(SB),7,$0
         MOVL    $4, AX
         INT     $0x80
         RET
 
 TEXT runtime·raisesigpipe(SB),7,$8
         get_tls(CX)
         MOVL    m(CX), DX
         MOVL    m_procid(DX), DX
         MOVL    DX, 0(SP)       // thread_port
         MOVL    $13, 4(SP)      // signal: SIGPIPE
         MOVL    $328, AX        // __pthread_kill
         INT     $0x80
         RET
 
 TEXT runtime·mmap(SB),7,$0
         MOVL    $197, AX
         INT     $0x80
         RET
 
 TEXT runtime·madvise(SB),7,$0
         MOVL    $75, AX
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·munmap(SB),7,$0
         MOVL    $73, AX
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·setitimer(SB),7,$0
         MOVL    $83, AX
         INT     $0x80
         RET
 
 // func now() (sec int64, nsec int32)
 TEXT time·now(SB), 7, $32
         LEAL    12(SP), AX      // must be non-nil, unused
@@ skipping 30 matching lines @@
 
         MOVL    ret+0(FP), DI
         MOVL    AX, 0(DI)
         MOVL    DX, 4(DI)
         RET
 
 TEXT runtime·sigprocmask(SB),7,$0
         MOVL    $329, AX  // pthread_sigmask (on OS X, sigprocmask==entire process)
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·sigaction(SB),7,$0
         MOVL    $46, AX
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        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(FP)   "return address" - ignored
 //      4(FP)   actual handler
 //      8(FP)   siginfo style - ignored
 //      12(FP)  signal number
 //      16(FP)  siginfo
 //      20(FP)  context
@@ skipping 27 matching lines @@
         MOVL    DI, g(CX)
 
         // 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
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·sigaltstack(SB),7,$0
         MOVL    $53, AX
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·usleep(SB),7,$32
         MOVL    $0, DX
         MOVL    usec+0(FP), AX
         MOVL    $1000000, CX
         DIVL    CX
         MOVL    AX, 24(SP)  // sec
         MOVL    DX, 28(SP)  // usec
 
@@ skipping 75 matching lines @@
         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     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         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
@@ skipping 86 matching lines @@
         RET
 
 TEXT runtime·sysctl(SB),7,$0
         MOVL    $202, AX
         INT     $0x80
         JAE     3(PC)
         NEGL    AX
         RET
         MOVL    $0, AX
         RET