runtime: use explicit NOFRAME on solaris/amd64

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

While here, I've reduced the stack usage of runtime·sigtramp by
16 bytes to compensate the additional 8 bytes from the stack-allocated
frame pointer. There were two unused 8-byte slots on the stack, one
at 24(SP) and the other at 80(SP).

Updates #58378

Change-Id: If9230e71a8b3c72681ffc82030ade6ceccf824db
Reviewed-on: https://go-review.googlesource.com/c/go/+/466456
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Quim Muntal <quimmuntal@gmail.com>

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index a80535fa466a79acb2c4dc26ca521015d5af8445..5c7fb5c763ffc2985935427f4454bb900874a25c 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.Hopenbsd:
+               objabi.Hfreebsd, objabi.Hnetbsd, objabi.Hopenbsd, objabi.Hsolaris:
        default:
                usefpheuristic = true
        }

diff --git a/src/runtime/sys_solaris_amd64.s b/src/runtime/sys_solaris_amd64.s
index 7376e065a027c08305e975a830efa7718ff0ffec..a29dd4f735b346e8d76de70d7bf9a6a65e4dc7c7 100644 (file)
--- a/src/runtime/sys_solaris_amd64.s
+++ b/src/runtime/sys_solaris_amd64.s
@@ -121,29 +121,28 @@ TEXT runtime·tstart_sysvicall(SB),NOSPLIT,$0
 
 // Careful, this is called by __sighndlr, a libc function. We must preserve
 // registers as per AMD 64 ABI.
-TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$0
+TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME|NOFRAME,$0
        // Note that we are executing on altsigstack here, so we have
        // more stack available than NOSPLIT would have us believe.
        // To defeat the linker, we make our own stack frame with
        // more space:
-       SUBQ    $184, SP
-
+       SUBQ    $168, SP
        // save registers
-       MOVQ    BX, 32(SP)
-       MOVQ    BP, 40(SP)
-       MOVQ    R12, 48(SP)
-       MOVQ    R13, 56(SP)
-       MOVQ    R14, 64(SP)
-       MOVQ    R15, 72(SP)
+       MOVQ    BX, 24(SP)
+       MOVQ    BP, 32(SP)
+       MOVQ    R12, 40(SP)
+       MOVQ    R13, 48(SP)
+       MOVQ    R14, 56(SP)
+       MOVQ    R15, 64(SP)
 
        get_tls(BX)
        // check that g exists
        MOVQ    g(BX), R10
        CMPQ    R10, $0
        JNE     allgood
-       MOVQ    SI, 80(SP)
-       MOVQ    DX, 88(SP)
-       LEAQ    80(SP), AX
+       MOVQ    SI, 72(SP)
+       MOVQ    DX, 80(SP)
+       LEAQ    72(SP), AX
        MOVQ    DI, 0(SP)
        MOVQ    AX, 8(SP)
        MOVQ    $runtime·badsignal(SB), AX
@@ -158,35 +157,35 @@ allgood:
        MOVQ    g_m(R10), BP
        LEAQ    m_libcall(BP), R11
        MOVQ    libcall_fn(R11), R10
-       MOVQ    R10, 88(SP)
+       MOVQ    R10, 72(SP)
        MOVQ    libcall_args(R11), R10
-       MOVQ    R10, 96(SP)
+       MOVQ    R10, 80(SP)
        MOVQ    libcall_n(R11), R10
-       MOVQ    R10, 104(SP)
+       MOVQ    R10, 88(SP)
        MOVQ    libcall_r1(R11), R10
-       MOVQ    R10, 168(SP)
+       MOVQ    R10, 152(SP)
        MOVQ    libcall_r2(R11), R10
-       MOVQ    R10, 176(SP)
+       MOVQ    R10, 160(SP)
 
        // save m->scratch
        LEAQ    (m_mOS+mOS_scratch)(BP), R11
        MOVQ    0(R11), R10
-       MOVQ    R10, 112(SP)
+       MOVQ    R10, 96(SP)
        MOVQ    8(R11), R10
-       MOVQ    R10, 120(SP)
+       MOVQ    R10, 104(SP)
        MOVQ    16(R11), R10
-       MOVQ    R10, 128(SP)
+       MOVQ    R10, 112(SP)
        MOVQ    24(R11), R10
-       MOVQ    R10, 136(SP)
+       MOVQ    R10, 120(SP)
        MOVQ    32(R11), R10
-       MOVQ    R10, 144(SP)
+       MOVQ    R10, 128(SP)
        MOVQ    40(R11), R10
-       MOVQ    R10, 152(SP)
+       MOVQ    R10, 136(SP)
 
        // save errno, it might be EINTR; stuff we do here might reset it.
        MOVQ    (m_mOS+mOS_perrno)(BP), R10
        MOVL    0(R10), R10
-       MOVQ    R10, 160(SP)
+       MOVQ    R10, 144(SP)
 
        // prepare call
        MOVQ    DI, 0(SP)
@@ -199,47 +198,46 @@ allgood:
        MOVQ    g_m(BP), BP
        // restore libcall
        LEAQ    m_libcall(BP), R11
-       MOVQ    88(SP), R10
+       MOVQ    72(SP), R10
        MOVQ    R10, libcall_fn(R11)
-       MOVQ    96(SP), R10
+       MOVQ    80(SP), R10
        MOVQ    R10, libcall_args(R11)
-       MOVQ    104(SP), R10
+       MOVQ    88(SP), R10
        MOVQ    R10, libcall_n(R11)
-       MOVQ    168(SP), R10
+       MOVQ    152(SP), R10
        MOVQ    R10, libcall_r1(R11)
-       MOVQ    176(SP), R10
+       MOVQ    160(SP), R10
        MOVQ    R10, libcall_r2(R11)
 
        // restore scratch
        LEAQ    (m_mOS+mOS_scratch)(BP), R11
-       MOVQ    112(SP), R10
+       MOVQ    96(SP), R10
        MOVQ    R10, 0(R11)
-       MOVQ    120(SP), R10
+       MOVQ    104(SP), R10
        MOVQ    R10, 8(R11)
-       MOVQ    128(SP), R10
+       MOVQ    112(SP), R10
        MOVQ    R10, 16(R11)
-       MOVQ    136(SP), R10
+       MOVQ    120(SP), R10
        MOVQ    R10, 24(R11)
-       MOVQ    144(SP), R10
+       MOVQ    128(SP), R10
        MOVQ    R10, 32(R11)
-       MOVQ    152(SP), R10
+       MOVQ    136(SP), R10
        MOVQ    R10, 40(R11)
 
        // restore errno
        MOVQ    (m_mOS+mOS_perrno)(BP), R11
-       MOVQ    160(SP), R10
+       MOVQ    144(SP), R10
        MOVL    R10, 0(R11)
 
 exit:
        // restore registers
-       MOVQ    32(SP), BX
-       MOVQ    40(SP), BP
-       MOVQ    48(SP), R12
-       MOVQ    56(SP), R13
-       MOVQ    64(SP), R14
-       MOVQ    72(SP), R15
-
-       ADDQ    $184, SP
+       MOVQ    24(SP), BX
+       MOVQ    32(SP), BP
+       MOVQ    40(SP), R12
+       MOVQ    48(SP), R13
+       MOVQ    56(SP), R14
+       MOVQ    64(SP), R15
+       ADDQ    $168, SP
        RET
 
 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
@@ -247,12 +245,10 @@ 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 from runtime·usleep (Go). Can be called on Go stack, on OS stack,