code review 5792048: runtime: inline calls to notok

src/pkg/runtime/sys_freebsd_amd64.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 AMD64, FreeBSD
 // /usr/src/sys/kern/syscalls.master for syscall numbers.
 //
 
 #include "zasm_GOOS_GOARCH.h"
 ········
@@ skipping 29 matching lines @@
 
         CALL runtime·stackcheck(SB)
         CALL runtime·mstart(SB)
         MOVQ 0, AX                      // crash (not reached)
 
 // Exit the entire program (like C exit)
 TEXT runtime·exit(SB),7,$-8
         MOVL    8(SP), DI               // arg 1 exit status
         MOVL    $1, AX
         SYSCALL
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·exit1(SB),7,$-8
         MOVQ    8(SP), DI               // arg 1 exit status
         MOVL    $431, AX
         SYSCALL
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 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
         RET
 
@@ skipping 54 matching lines @@
         ADDQ    DX, AX
         RET
 
 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    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·sigtramp(SB),7,$64
         get_tls(BX)
 ········
         // save g
         MOVQ    g(BX), R10
         MOVQ    R10, 40(SP)
 ········
         // g = m->signal
@@ skipping 24 matching lines @@
         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    runtime·notok(SB)
-        RET
-
-TEXT runtime·notok(SB),7,$-8
-        MOVL    $0xf1, BP
-        MOVQ    BP, (BP)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·sigaltstack(SB),7,$-8
         MOVQ    new+8(SP), DI
         MOVQ    old+16(SP), SI
         MOVQ    $53, AX
         SYSCALL
         JCC     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·usleep(SB),7,$16
         MOVL    $0, DX
         MOVL    usec+0(FP), AX
         MOVL    $1000000, CX
         DIVL    CX
         MOVQ    AX, 0(SP)               // tv_sec
         MOVL    $1000, AX
         MULL    DX
         MOVQ    AX, 8(SP)               // tv_nsec
 
         MOVQ    SP, DI                  // arg 1 - rqtp
         MOVQ    $0, SI                  // arg 2 - rmtp
         MOVL    $240, AX                // sys_nanosleep
         SYSCALL
         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)
+        MOVL    $0xf1, 0xf1  // crash
         RET
 
 TEXT runtime·sysctl(SB),7,$0
         MOVQ    8(SP), DI               // arg 1 - name
         MOVL    16(SP), SI              // arg 2 - namelen
         MOVQ    24(SP), DX              // arg 3 - oldp
         MOVQ    32(SP), R10             // arg 4 - oldlenp
         MOVQ    40(SP), R8              // arg 5 - newp
         MOVQ    48(SP), R9              // arg 6 - newlen
         MOVQ    $202, AX                // sys___sysctl
         SYSCALL
         JCC 3(PC)
         NEGL    AX
         RET
         MOVL    $0, AX
         RET
 
 TEXT runtime·osyield(SB),7,$-4
         MOVL    $331, AX                // sys_sched_yield
         SYSCALL
         RET
 
 TEXT runtime·sigprocmask(SB),7,$0
         MOVL    $3, DI                  // arg 1 - how (SIG_SETMASK)
         MOVQ    8(SP), SI               // arg 2 - set
         MOVQ    16(SP), DX              // arg 3 - oset
         MOVL    $340, AX                // sys_sigprocmask
         SYSCALL
         JAE     2(PC)
-        CALL    runtime·notok(SB)
+        MOVL    $0xf1, 0xf1  // crash
         RET