code review 5792048: runtime: inline calls to notok

src/pkg/runtime/sys_freebsd_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, FreeBSD
 // /usr/src/sys/kern/syscalls.master for syscall numbers.
 //
 
 #include "zasm_GOOS_GOARCH.h"
 ········
@@ skipping 27 matching lines @@
 ········
         MOVL    AX, m(CX)
         CALL    runtime·stackcheck(SB)          // smashes AX
         CALL    runtime·mstart(SB)
         MOVL    0, AX                   // crash (not reached)
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),7,$-4
         MOVL    $1, AX
         INT     $0x80
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·exit1(SB),7,$-4
         MOVL    $431, AX
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·write(SB),7,$-4
         MOVL    $4, AX
         INT     $0x80
         RET
 
 TEXT runtime·getrlimit(SB),7,$-4
         MOVL    $194, AX
         INT     $0x80
         RET
 
 TEXT runtime·raisesigpipe(SB),7,$12
         // thr_self(&8(SP))
         LEAL    8(SP), AX
         MOVL    AX, 0(SP)
         MOVL    $432, AX
         INT     $0x80
         // thr_kill(self, SIGPIPE)
         MOVL    8(SP), AX
         MOVL    AX, 0(SP)
         MOVL    $13, 4(SP)
         MOVL    $433, AX
         INT     $0x80
         RET
 
-TEXT runtime·notok(SB),7,$0
-        MOVL    $0xf1, 0xf1
-        RET
-
 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    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·setitimer(SB), 7, $-4
         MOVL    $83, AX
         INT     $0x80
         RET
 
 // func now() (sec int64, nsec int32)
 TEXT time·now(SB), 7, $32
         MOVL    $116, AX
@@ skipping 33 matching lines @@
         MOVL    ret+0(FP), DI
         MOVL    AX, 0(DI)
         MOVL    DX, 4(DI)
         RET
 
 
 TEXT runtime·sigaction(SB),7,$-4
         MOVL    $416, AX
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·sigtramp(SB),7,$44
         get_tls(CX)
 
         // save g
         MOVL    g(CX), DI
         MOVL    DI, 20(SP)
 ········
         // g = m->gsignal
@@ skipping 16 matching lines @@
         get_tls(CX)
         MOVL    20(SP), BX
         MOVL    BX, g(CX)
 ········
         // call sigreturn
         MOVL    context+8(FP), AX
         MOVL    $0, 0(SP)       // syscall gap
         MOVL    AX, 4(SP)
         MOVL    $417, AX        // sigreturn(ucontext)
         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,$20
         MOVL    $0, DX
         MOVL    usec+0(FP), AX
         MOVL    $1000000, CX
         DIVL    CX
         MOVL    AX, 12(SP)              // tv_sec
         MOVL    $1000, AX
         MULL    DX
@@ skipping 95 matching lines @@
 TEXT runtime·sigprocmask(SB),7,$16
         MOVL    $0, 0(SP)               // syscall gap
         MOVL    $3, 4(SP)               // arg 1 - how (SIG_SETMASK)
         MOVL    args+0(FP), AX
         MOVL    AX, 8(SP)               // arg 2 - set
         MOVL    args+4(FP), AX
         MOVL    AX, 12(SP)              // arg 3 - oset
         MOVL    $340, AX                // sys_sigprocmask
         INT     $0x80
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 GLOBL runtime·tlsoffset(SB),$4