runtime: use explicit NOFRAME on openbsd/amd64

This CL marks some openbsd assembly functions as NOFRAME to avoid
relying on the implicit amd64 NOFRAME heuristic, where NOSPLIT functions
without stack were also marked as NOFRAME.

Updates #58378

Change-Id: I993549df41a93255fb714357443f8b24c3dfb0a4
Reviewed-on: https://go-review.googlesource.com/c/go/+/466455
Reviewed-by: Keith Randall <khr@google.com>
Run-TryBot: Quim Muntal <quimmuntal@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Mui <cherryyz@google.com>

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index c81cbf12e9d3dbf7857a3fdcba48577cfc6d8dea..a80535fa466a79acb2c4dc26ca521015d5af8445 100644 (file)
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -614,7 +614,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
        var usefpheuristic bool
        switch ctxt.Headtype {
        case objabi.Hwindows, objabi.Hdarwin, objabi.Hlinux, objabi.Hdragonfly,
-               objabi.Hfreebsd, objabi.Hnetbsd:
+               objabi.Hfreebsd, objabi.Hnetbsd, objabi.Hopenbsd:
        default:
                usefpheuristic = true
        }

diff --git a/src/runtime/sys_openbsd_amd64.s b/src/runtime/sys_openbsd_amd64.s
index 2c026c8d0dba63327c373bc80f06a96277427d52..d3e87c23727135a6c7b767db7f62671b82cf82ea 100644 (file)
--- a/src/runtime/sys_openbsd_amd64.s
+++ b/src/runtime/sys_openbsd_amd64.s
@@ -49,16 +49,14 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
        MOVL    sig+8(FP),   DI
        MOVQ    info+16(FP), SI
        MOVQ    ctx+24(FP),  DX
-       PUSHQ   BP
-       MOVQ    SP, BP
-       ANDQ    $~15, SP     // alignment for x86_64 ABI
+       MOVQ    SP, BX          // callee-saved
+       ANDQ    $~15, SP        // alignment for x86_64 ABI
        CALL    AX
-       MOVQ    BP, SP
-       POPQ    BP
+       MOVQ    BX, SP
        RET
 
 // Called using C ABI.
-TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$0
+TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME|NOFRAME,$0
        // Transition from C ABI to Go ABI.
        PUSH_REGS_HOST_TO_ABI0()
 
@@ -89,122 +87,82 @@ TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$0
 // A single int32 result is returned in AX.
 // (For more results, make an args/results structure.)
 TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    0(DI), DI               // arg 1 - attr
        CALL    libc_pthread_attr_init(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    0(DI), DI               // arg 1 - attr
        CALL    libc_pthread_attr_destroy(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 - stacksize
        MOVQ    0(DI), DI               // arg 1 - attr
        CALL    libc_pthread_attr_getstacksize(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 - detachstate
        MOVQ    0(DI), DI               // arg 1 - attr
        CALL    libc_pthread_attr_setdetachstate(SB)
-       POPQ    BP
        RET
 
-TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $16, SP
+TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$16
        MOVQ    0(DI), SI               // arg 2 - attr
        MOVQ    8(DI), DX               // arg 3 - start
        MOVQ    16(DI), CX              // arg 4 - arg
        MOVQ    SP, DI                  // arg 1 - &thread (discarded)
        CALL    libc_pthread_create(SB)
-       MOVQ    BP, SP
-       POPQ    BP
        RET
 
 TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 - signal
        MOVQ    $0, DX                  // arg 3 - tcb
        MOVL    0(DI), DI               // arg 1 - tid
        CALL    libc_thrkill(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 - clock_id
        MOVQ    16(DI), DX              // arg 3 - abstime
        MOVQ    24(DI), CX              // arg 4 - lock
        MOVQ    32(DI), R8              // arg 5 - abort
        MOVQ    0(DI), DI               // arg 1 - id
        CALL    libc_thrsleep(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 - count
        MOVQ    0(DI), DI               // arg 1 - id
        CALL    libc_thrwakeup(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    0(DI), DI               // arg 1 exit status
        CALL    libc_exit(SB)
        MOVL    $0xf1, 0xf1  // crash
-       POPQ    BP
        RET
 
 TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    DI, BX                  // BX is caller-save
        CALL    libc_getthrid(SB)
        MOVL    AX, 0(BX)               // return value
-       POPQ    BP
        RET
 
 TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    0(DI), BX       // signal
        CALL    libc_getpid(SB)
        MOVL    AX, DI          // arg 1 pid
        MOVL    BX, SI          // arg 2 signal
        CALL    libc_kill(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        CALL    libc_sched_yield(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP                      // make a frame; keep stack aligned
-       MOVQ    SP, BP
        MOVQ    DI, BX
        MOVQ    0(BX), DI               // arg 1 addr
        MOVQ    8(BX), SI               // arg 2 len
@@ -222,54 +180,39 @@ TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
 ok:
        MOVQ    AX, 32(BX)
        MOVQ    DX, 40(BX)
-       POPQ    BP
        RET
 
 TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 len
        MOVQ    0(DI), DI               // arg 1 addr
        CALL    libc_munmap(SB)
        TESTQ   AX, AX
        JEQ     2(PC)
        MOVL    $0xf1, 0xf1  // crash
-       POPQ    BP
        RET
 
 TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 len
        MOVL    16(DI), DX      // arg 3 advice
        MOVQ    0(DI), DI       // arg 1 addr
        CALL    libc_madvise(SB)
        // ignore failure - maybe pages are locked
-       POPQ    BP
        RET
 
 TEXT runtime·open_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 - flags
        MOVL    12(DI), DX              // arg 3 - mode
        MOVQ    0(DI), DI               // arg 1 - path
        XORL    AX, AX                  // vararg: say "no float args"
        CALL    libc_open(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·close_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    0(DI), DI               // arg 1 - fd
        CALL    libc_close(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·read_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 - buf
        MOVL    16(DI), DX              // arg 3 - count
        MOVL    0(DI), DI               // arg 1 - fd
@@ -280,12 +223,9 @@ TEXT runtime·read_trampoline(SB),NOSPLIT,$0
        MOVL    (AX), AX                // errno
        NEGL    AX                      // caller expects negative errno value
 noerr:
-       POPQ    BP
        RET
 
 TEXT runtime·write_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 buf
        MOVL    16(DI), DX              // arg 3 count
        MOVL    0(DI), DI               // arg 1 fd
@@ -296,12 +236,9 @@ TEXT runtime·write_trampoline(SB),NOSPLIT,$0
        MOVL    (AX), AX                // errno
        NEGL    AX                      // caller expects negative errno value
 noerr:
-       POPQ    BP
        RET
 
 TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 flags
        MOVQ    0(DI), DI               // arg 1 filedes
        CALL    libc_pipe2(SB)
@@ -310,30 +247,21 @@ TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
        CALL    libc_errno(SB)
        MOVL    (AX), AX                // errno
        NEGL    AX                      // caller expects negative errno value
-       POPQ    BP
        RET
 
 TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 new
        MOVQ    16(DI), DX              // arg 3 old
        MOVL    0(DI), DI               // arg 1 which
        CALL    libc_setitimer(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    0(DI), DI               // arg 1 usec
        CALL    libc_usleep(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    8(DI), SI               // arg 2 miblen
        MOVQ    16(DI), DX              // arg 3 out
        MOVQ    24(DI), CX              // arg 4 size
@@ -341,19 +269,13 @@ TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
        MOVQ    40(DI), R9              // arg 6 ndst
        MOVQ    0(DI), DI               // arg 1 mib
        CALL    libc_sysctl(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        CALL    libc_kqueue(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 keventt
        MOVL    16(DI), DX              // arg 3 nch
        MOVQ    24(DI), CX              // arg 4 ev
@@ -367,12 +289,9 @@ TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
        MOVL    (AX), AX                // errno
        NEGL    AX                      // caller expects negative errno value
 ok:
-       POPQ    BP
        RET
 
 TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP                      // make a frame; keep stack aligned
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 tp
        MOVL    0(DI), DI               // arg 1 clock_id
        CALL    libc_clock_gettime(SB)
@@ -382,23 +301,17 @@ TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
        MOVL    (AX), AX                // errno
        NEGL    AX                      // caller expects negative errno value
 noerr:
-       POPQ    BP
        RET
 
 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVL    4(DI), SI               // arg 2 cmd
        MOVL    8(DI), DX               // arg 3 arg
        MOVL    0(DI), DI               // arg 1 fd
        XORL    AX, AX                  // vararg: say "no float args"
        CALL    libc_fcntl(SB)
-       POPQ    BP
        RET
 
 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 new
        MOVQ    16(DI), DX              // arg 3 old
        MOVL    0(DI), DI               // arg 1 sig
@@ -406,12 +319,9 @@ TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
        TESTL   AX, AX
        JEQ     2(PC)
        MOVL    $0xf1, 0xf1  // crash
-       POPQ    BP
        RET
 
 TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI       // arg 2 new
        MOVQ    16(DI), DX      // arg 3 old
        MOVL    0(DI), DI       // arg 1 how
@@ -419,19 +329,15 @@ TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
        TESTL   AX, AX
        JEQ     2(PC)
        MOVL    $0xf1, 0xf1  // crash
-       POPQ    BP
        RET
 
 TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
        MOVQ    8(DI), SI               // arg 2 old
        MOVQ    0(DI), DI               // arg 1 new
        CALL    libc_sigaltstack(SB)
        TESTQ   AX, AX
        JEQ     2(PC)
        MOVL    $0xf1, 0xf1  // crash
-       POPQ    BP
        RET
 
 // syscall calls a function in libc on behalf of the syscall package.
@@ -450,10 +356,7 @@ TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
 //
 // syscall expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $16, SP
+TEXT runtime·syscall(SB),NOSPLIT,$16
        MOVQ    (0*8)(DI), CX // fn
        MOVQ    (2*8)(DI), SI // a2
        MOVQ    (3*8)(DI), DX // a3
@@ -480,8 +383,6 @@ TEXT runtime·syscall(SB),NOSPLIT,$0
 
 ok:
        XORL    AX, AX        // no error (it's ignored anyway)
-       MOVQ    BP, SP
-       POPQ    BP
        RET
 
 // syscallX calls a function in libc on behalf of the syscall package.
@@ -500,10 +401,7 @@ ok:
 //
 // syscallX is like syscall but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscallX(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $16, SP
+TEXT runtime·syscallX(SB),NOSPLIT,$16
        MOVQ    (0*8)(DI), CX // fn
        MOVQ    (2*8)(DI), SI // a2
        MOVQ    (3*8)(DI), DX // a3
@@ -530,8 +428,6 @@ TEXT runtime·syscallX(SB),NOSPLIT,$0
 
 ok:
        XORL    AX, AX        // no error (it's ignored anyway)
-       MOVQ    BP, SP
-       POPQ    BP
        RET
 
 // syscall6 calls a function in libc on behalf of the syscall package.
@@ -553,10 +449,7 @@ ok:
 //
 // syscall6 expects a 32-bit result and tests for 32-bit -1
 // to decide there was an error.
-TEXT runtime·syscall6(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $16, SP
+TEXT runtime·syscall6(SB),NOSPLIT,$16
        MOVQ    (0*8)(DI), R11// fn
        MOVQ    (2*8)(DI), SI // a2
        MOVQ    (3*8)(DI), DX // a3
@@ -583,8 +476,6 @@ TEXT runtime·syscall6(SB),NOSPLIT,$0
 
 ok:
        XORL    AX, AX        // no error (it's ignored anyway)
-       MOVQ    BP, SP
-       POPQ    BP
        RET
 
 // syscall6X calls a function in libc on behalf of the syscall package.
@@ -606,10 +497,7 @@ ok:
 //
 // syscall6X is like syscall6 but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscall6X(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $16, SP
+TEXT runtime·syscall6X(SB),NOSPLIT,$16
        MOVQ    (0*8)(DI), R11// fn
        MOVQ    (2*8)(DI), SI // a2
        MOVQ    (3*8)(DI), DX // a3
@@ -636,8 +524,6 @@ TEXT runtime·syscall6X(SB),NOSPLIT,$0
 
 ok:
        XORL    AX, AX        // no error (it's ignored anyway)
-       MOVQ    BP, SP
-       POPQ    BP
        RET
 
 // syscall10 calls a function in libc on behalf of the syscall package.
@@ -660,11 +546,7 @@ ok:
 // }
 // syscall10 must be called on the g0 stack with the
 // C calling convention (use libcCall).
-TEXT runtime·syscall10(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $48, SP
-
+TEXT runtime·syscall10(SB),NOSPLIT,$48
        // Arguments a1 to a6 get passed in registers, with a7 onwards being
        // passed via the stack per the x86-64 System V ABI
        // (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf).
@@ -702,8 +584,6 @@ TEXT runtime·syscall10(SB),NOSPLIT,$0
 
 ok:
        XORL    AX, AX        // no error (it's ignored anyway)
-       MOVQ    BP, SP
-       POPQ    BP
        RET
 
 // syscall10X calls a function in libc on behalf of the syscall package.
@@ -729,11 +609,7 @@ ok:
 //
 // syscall10X is like syscall10 but expects a 64-bit result
 // and tests for 64-bit -1 to decide there was an error.
-TEXT runtime·syscall10X(SB),NOSPLIT,$0
-       PUSHQ   BP
-       MOVQ    SP, BP
-       SUBQ    $48, SP
-
+TEXT runtime·syscall10X(SB),NOSPLIT,$48
        // Arguments a1 to a6 get passed in registers, with a7 onwards being
        // passed via the stack per the x86-64 System V ABI
        // (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf).
@@ -771,6 +647,4 @@ TEXT runtime·syscall10X(SB),NOSPLIT,$0
 
 ok:
        XORL    AX, AX        // no error (it's ignored anyway)
-       MOVQ    BP, SP
-       POPQ    BP
        RET