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>

1 files changed, 11 insertions, 137 deletions

diff --git a/src/runtime/sys_openbsd_amd64.s b/src/runtime/sys_openbsd_amd64.s
index 2c026c8d0d..d3e87c2372 100644
--- 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