Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

runtime: unify arm64 entry point code

Browse source 
There is a lot of duplication in how arm64 OSes handle entry points.
Do as amd64, have all the logic in a common function.

Cq-Include-Trybots: luci.golang.try:gotip-darwin-arm64-longtest,gotip-windows-arm64
Change-Id: I370c25c3c4b107b525aba14e9dcac34a02d9872e
Reviewed-on: https://go-review.googlesource.com/c/go/+/706175
Reviewed-by: Michael Pratt <mpratt@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Auto-Submit: Quim Muntal <quimmuntal@gmail.com>
This commit is contained in:
qmuntal 2025-09-23 17:17:37 +02:00 • committed by Gopher Robot
parent fdea7da3e6
commit 45d6bc76af
10 changed files with 111 additions and 337 deletions
Download patch file Download diff file Expand all files Collapse all files

72
src/runtime/asm_arm64.s
View file

@ -7,6 +7,78 @@
#include "tls_arm64.h" #include "tls_arm64.h"
#include "funcdata.h" #include "funcdata.h"
#include "textflag.h" #include "textflag.h"
#include "cgo/abi_arm64.h"
// _rt0_arm64 is common startup code for most arm64 systems when using
// internal linking. This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program. The stack holds the
// number of arguments and the C-style argv.
TEXT _rt0_arm64(SB),NOSPLIT,$0
MOVD 0(RSP), R0 // argc
ADD $8, RSP, R1 // argv
JMP runtime·rt0_go(SB)
// main is common startup code for most amd64 systems when using
// external linking. The C startup code will call the symbol "main"
// passing argc and argv in the usual C ABI registers R0 and R1.
TEXT main(SB),NOSPLIT,$0
JMP runtime·rt0_go(SB)
// _rt0_arm64_lib is common startup code for most arm64 systems when
// using -buildmode=c-archive or -buildmode=c-shared. The linker will
// arrange to invoke this function as a global constructor (for
// c-archive) or when the shared library is loaded (for c-shared).
// We expect argc and argv to be passed in the usual C ABI registers
// R0 and R1.
TEXT _rt0_arm64_lib(SB),NOSPLIT,$184
// Preserve callee-save registers.
SAVE_R19_TO_R28(24)
SAVE_F8_TO_F15(104)
// Initialize g as null in case of using g later e.g. sigaction in cgo_sigaction.go
MOVD ZR, g
MOVD R0, _rt0_arm64_lib_argc<>(SB)
MOVD R1, _rt0_arm64_lib_argv<>(SB)
// Synchronous initialization.
MOVD $runtime·libpreinit(SB), R4
BL (R4)
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
CBZ R4, nocgo
MOVD $_rt0_arm64_lib_go(SB), R0
MOVD $0, R1
SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
BL (R4)
ADD $16, RSP
B restore
nocgo:
MOVD $0x800000, R0 // stacksize = 8192KB
MOVD $_rt0_arm64_lib_go(SB), R1
MOVD R0, 8(RSP)
MOVD R1, 16(RSP)
MOVD $runtime·newosproc0(SB),R4
BL (R4)
restore:
// Restore callee-save registers.
RESTORE_R19_TO_R28(24)
RESTORE_F8_TO_F15(104)
RET
TEXT _rt0_arm64_lib_go(SB),NOSPLIT,$0
MOVD _rt0_arm64_lib_argc<>(SB), R0
MOVD _rt0_arm64_lib_argv<>(SB), R1
MOVD $runtime·rt0_go(SB),R4
B (R4)
DATA _rt0_arm64_lib_argc<>(SB)/8, $0
GLOBL _rt0_arm64_lib_argc<>(SB),NOPTR, $8
DATA _rt0_arm64_lib_argv<>(SB)/8, $0
GLOBL _rt0_arm64_lib_argv<>(SB),NOPTR, $8
#ifdef GOARM64_LSE #ifdef GOARM64_LSE
DATA no_lse_msg<>+0x00(SB)/64, $"This program can only run on ARM64 processors with LSE support.\n" DATA no_lse_msg<>+0x00(SB)/64, $"This program can only run on ARM64 processors with LSE support.\n"

9
src/runtime/os_windows.go
View file

@ -777,13 +777,14 @@ func newosproc(mp *m) {
// //
//go:nowritebarrierrec //go:nowritebarrierrec
//go:nosplit //go:nosplit
func newosproc0(mp *m, stk unsafe.Pointer) { func newosproc0(stacksize uintptr, fn uintptr) {
// TODO: this is completely broken. The args passed to newosproc0 (in asm_amd64.s)
// are stacksize and function, not *m and stack.
// Check os_linux.go for an implementation that might actually work.
throw("bad newosproc0") throw("bad newosproc0")
} }
//go:nosplit
//go:nowritebarrierrec
func libpreinit() {}
func exitThread(wait *atomic.Uint32) { func exitThread(wait *atomic.Uint32) {
// We should never reach exitThread on Windows because we let // We should never reach exitThread on Windows because we let
// the OS clean up threads. // the OS clean up threads.

10
src/runtime/rt0_android_arm64.s
View file

@ -4,17 +4,15 @@
#include "textflag.h" #include "textflag.h"
TEXT _rt0_arm64_android(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_android(SB),NOSPLIT,$0
MOVD $_rt0_arm64_linux(SB), R4 JMP _rt0_arm64(SB)
B (R4)
// When building with -buildmode=c-shared, this symbol is called when the shared // When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded. // library is loaded.
TEXT _rt0_arm64_android_lib(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_android_lib(SB),NOSPLIT,$0
MOVW $1, R0 // argc MOVW $1, R0 // argc
MOVD $_rt0_arm64_android_argv(SB), R1 // **argv MOVD $_rt0_arm64_android_argv(SB), R1 // **argv
MOVD $_rt0_arm64_linux_lib(SB), R4 JMP _rt0_arm64_lib(SB)
B (R4)
DATA _rt0_arm64_android_argv+0x00(SB)/8,$_rt0_arm64_android_argv0(SB) DATA _rt0_arm64_android_argv+0x00(SB)/8,$_rt0_arm64_android_argv0(SB)
DATA _rt0_arm64_android_argv+0x08(SB)/8,$0 // end argv DATA _rt0_arm64_android_argv+0x08(SB)/8,$0 // end argv

60
src/runtime/rt0_darwin_arm64.s
View file

@ -3,61 +3,13 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
#include "textflag.h" #include "textflag.h"
#include "cgo/abi_arm64.h"
TEXT _rt0_arm64_darwin(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_darwin(SB),NOSPLIT,$0
MOVD $runtime·rt0_go(SB), R2 // Darwin puts argc and argv in R0 and R1,
BL (R2) // so there is no need to go through _rt0_arm64.
exit: JMP runtime·rt0_go(SB)
MOVD $0, R0
MOVD $1, R16 // sys_exit
SVC $0x80
B exit
// When linking with -buildmode=c-archive or -buildmode=c-shared, // When linking with -buildmode=c-archive or -buildmode=c-shared,
// this symbol is called from a global initialization function. // this symbol is called from a global initialization function.
// TEXT _rt0_arm64_darwin_lib(SB),NOSPLIT,$0
// Note that all currently shipping darwin/arm64 platforms require JMP _rt0_arm64_lib(SB)
// cgo and do not support c-shared.
TEXT _rt0_arm64_darwin_lib(SB),NOSPLIT,$152
// Preserve callee-save registers.
SAVE_R19_TO_R28(8)
SAVE_F8_TO_F15(88)
MOVD R0, _rt0_arm64_darwin_lib_argc<>(SB)
MOVD R1, _rt0_arm64_darwin_lib_argv<>(SB)
MOVD $0, g // initialize g to nil
// Synchronous initialization.
MOVD $runtime·libpreinit(SB), R4
BL (R4)
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
MOVD $_rt0_arm64_darwin_lib_go(SB), R0
MOVD $0, R1
SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
BL (R4)
ADD $16, RSP
// Restore callee-save registers.
RESTORE_R19_TO_R28(8)
RESTORE_F8_TO_F15(88)
RET
TEXT _rt0_arm64_darwin_lib_go(SB),NOSPLIT,$0
MOVD _rt0_arm64_darwin_lib_argc<>(SB), R0
MOVD _rt0_arm64_darwin_lib_argv<>(SB), R1
MOVD $runtime·rt0_go(SB), R4
B (R4)
DATA _rt0_arm64_darwin_lib_argc<>(SB)/8, $0
GLOBL _rt0_arm64_darwin_lib_argc<>(SB),NOPTR, $8
DATA _rt0_arm64_darwin_lib_argv<>(SB)/8, $0
GLOBL _rt0_arm64_darwin_lib_argv<>(SB),NOPTR, $8
// external linking entry point.
TEXT main(SB),NOSPLIT|NOFRAME,$0
JMP _rt0_arm64_darwin(SB)

68
src/runtime/rt0_freebsd_arm64.s
View file

@ -3,72 +3,12 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
#include "textflag.h" #include "textflag.h"
#include "cgo/abi_arm64.h"
// On FreeBSD argc/argv are passed in R0, not RSP // On FreeBSD argc/argv are passed in R0, not RSP
TEXT _rt0_arm64_freebsd(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_freebsd(SB),NOSPLIT,$0
ADD $8, R0, R1 // argv JMP _rt0_arm64(SB)
MOVD 0(R0), R0 // argc
BL main(SB)
// When building with -buildmode=c-shared, this symbol is called when the shared // When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded. // library is loaded.
TEXT _rt0_arm64_freebsd_lib(SB),NOSPLIT,$184 TEXT _rt0_arm64_freebsd_lib(SB),NOSPLIT,$0
// Preserve callee-save registers. JMP _rt0_arm64_lib(SB)
SAVE_R19_TO_R28(24)
SAVE_F8_TO_F15(104)
// Initialize g as null in case of using g later e.g. sigaction in cgo_sigaction.go
MOVD ZR, g
MOVD R0, _rt0_arm64_freebsd_lib_argc<>(SB)
MOVD R1, _rt0_arm64_freebsd_lib_argv<>(SB)
// Synchronous initialization.
MOVD $runtime·libpreinit(SB), R4
BL (R4)
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
CBZ R4, nocgo
MOVD $_rt0_arm64_freebsd_lib_go(SB), R0
MOVD $0, R1
SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
BL (R4)
ADD $16, RSP
B restore
nocgo:
MOVD $0x800000, R0 // stacksize = 8192KB
MOVD $_rt0_arm64_freebsd_lib_go(SB), R1
MOVD R0, 8(RSP)
MOVD R1, 16(RSP)
MOVD $runtime·newosproc0(SB),R4
BL (R4)
restore:
// Restore callee-save registers.
RESTORE_R19_TO_R28(24)
RESTORE_F8_TO_F15(104)
RET
TEXT _rt0_arm64_freebsd_lib_go(SB),NOSPLIT,$0
MOVD _rt0_arm64_freebsd_lib_argc<>(SB), R0
MOVD _rt0_arm64_freebsd_lib_argv<>(SB), R1
MOVD $runtime·rt0_go(SB),R4
B (R4)
DATA _rt0_arm64_freebsd_lib_argc<>(SB)/8, $0
GLOBL _rt0_arm64_freebsd_lib_argc<>(SB),NOPTR, $8
DATA _rt0_arm64_freebsd_lib_argv<>(SB)/8, $0
GLOBL _rt0_arm64_freebsd_lib_argv<>(SB),NOPTR, $8
TEXT main(SB),NOSPLIT|NOFRAME,$0
MOVD $runtime·rt0_go(SB), R2
BL (R2)
exit:
MOVD $0, R0
MOVD $1, R8 // SYS_exit
SVC
B exit

2
src/runtime/rt0_ios_arm64.s
View file

@ -11,4 +11,4 @@ TEXT _rt0_arm64_ios(SB),NOSPLIT|NOFRAME,$0
// library entry point. // library entry point.
TEXT _rt0_arm64_ios_lib(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_ios_lib(SB),NOSPLIT|NOFRAME,$0
JMP _rt0_arm64_darwin_lib(SB) JMP _rt0_arm64_lib(SB)

68
src/runtime/rt0_linux_arm64.s
View file

@ -3,71 +3,11 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
#include "textflag.h" #include "textflag.h"
#include "cgo/abi_arm64.h"
TEXT _rt0_arm64_linux(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_linux(SB),NOSPLIT,$0
MOVD 0(RSP), R0 // argc JMP _rt0_arm64(SB)
ADD $8, RSP, R1 // argv
BL main(SB)
// When building with -buildmode=c-shared, this symbol is called when the shared // When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded. // library is loaded.
TEXT _rt0_arm64_linux_lib(SB),NOSPLIT,$184 TEXT _rt0_arm64_linux_lib(SB),NOSPLIT,$0
// Preserve callee-save registers. JMP _rt0_arm64_lib(SB)
SAVE_R19_TO_R28(24)
SAVE_F8_TO_F15(104)
// Initialize g as null in case of using g later e.g. sigaction in cgo_sigaction.go
MOVD ZR, g
MOVD R0, _rt0_arm64_linux_lib_argc<>(SB)
MOVD R1, _rt0_arm64_linux_lib_argv<>(SB)
// Synchronous initialization.
MOVD $runtime·libpreinit(SB), R4
BL (R4)
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
CBZ R4, nocgo
MOVD $_rt0_arm64_linux_lib_go(SB), R0
MOVD $0, R1
SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
BL (R4)
ADD $16, RSP
B restore
nocgo:
MOVD $0x800000, R0 // stacksize = 8192KB
MOVD $_rt0_arm64_linux_lib_go(SB), R1
MOVD R0, 8(RSP)
MOVD R1, 16(RSP)
MOVD $runtime·newosproc0(SB),R4
BL (R4)
restore:
// Restore callee-save registers.
RESTORE_R19_TO_R28(24)
RESTORE_F8_TO_F15(104)
RET
TEXT _rt0_arm64_linux_lib_go(SB),NOSPLIT,$0
MOVD _rt0_arm64_linux_lib_argc<>(SB), R0
MOVD _rt0_arm64_linux_lib_argv<>(SB), R1
MOVD $runtime·rt0_go(SB),R4
B (R4)
DATA _rt0_arm64_linux_lib_argc<>(SB)/8, $0
GLOBL _rt0_arm64_linux_lib_argc<>(SB),NOPTR, $8
DATA _rt0_arm64_linux_lib_argv<>(SB)/8, $0
GLOBL _rt0_arm64_linux_lib_argv<>(SB),NOPTR, $8
TEXT main(SB),NOSPLIT|NOFRAME,$0
MOVD $runtime·rt0_go(SB), R2
BL (R2)
exit:
MOVD $0, R0
MOVD $94, R8 // sys_exit
SVC
B exit

62
src/runtime/rt0_netbsd_arm64.s
View file

@ -3,69 +3,13 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
#include "textflag.h" #include "textflag.h"
#include "cgo/abi_arm64.h"
TEXT _rt0_arm64_netbsd(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_netbsd(SB),NOSPLIT,$0
MOVD 0(RSP), R0 // argc MOVD 0(RSP), R0 // argc
ADD $8, RSP, R1 // argv ADD $8, RSP, R1 // argv
BL main(SB) BL main(SB)
// When building with -buildmode=c-shared, this symbol is called when the shared // When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded. // library is loaded.
TEXT _rt0_arm64_netbsd_lib(SB),NOSPLIT,$184 TEXT _rt0_arm64_netbsd_lib(SB),NOSPLIT,$0
// Preserve callee-save registers. JMP _rt0_arm64_lib(SB)
SAVE_R19_TO_R28(24)
SAVE_F8_TO_F15(104)
// Initialize g as null in case of using g later e.g. sigaction in cgo_sigaction.go
MOVD ZR, g
MOVD R0, _rt0_arm64_netbsd_lib_argc<>(SB)
MOVD R1, _rt0_arm64_netbsd_lib_argv<>(SB)
// Synchronous initialization.
MOVD $runtime·libpreinit(SB), R4
BL (R4)
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
CBZ R4, nocgo
MOVD $_rt0_arm64_netbsd_lib_go(SB), R0
MOVD $0, R1
SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
BL (R4)
ADD $16, RSP
B restore
nocgo:
MOVD $0x800000, R0 // stacksize = 8192KB
MOVD $_rt0_arm64_netbsd_lib_go(SB), R1
MOVD R0, 8(RSP)
MOVD R1, 16(RSP)
MOVD $runtime·newosproc0(SB),R4
BL (R4)
restore:
// Restore callee-save registers.
RESTORE_R19_TO_R28(24)
RESTORE_F8_TO_F15(104)
RET
TEXT _rt0_arm64_netbsd_lib_go(SB),NOSPLIT,$0
MOVD _rt0_arm64_netbsd_lib_argc<>(SB), R0
MOVD _rt0_arm64_netbsd_lib_argv<>(SB), R1
MOVD $runtime·rt0_go(SB),R4
B (R4)
DATA _rt0_arm64_netbsd_lib_argc<>(SB)/8, $0
GLOBL _rt0_arm64_netbsd_lib_argc<>(SB),NOPTR, $8
DATA _rt0_arm64_netbsd_lib_argv<>(SB)/8, $0
GLOBL _rt0_arm64_netbsd_lib_argv<>(SB),NOPTR, $8
TEXT main(SB),NOSPLIT|NOFRAME,$0
MOVD $runtime·rt0_go(SB), R2
BL (R2)
exit:
MOVD $0, R0
SVC $1 // sys_exit

72
src/runtime/rt0_openbsd_arm64.s
View file

@ -3,77 +3,11 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
#include "textflag.h" #include "textflag.h"
#include "cgo/abi_arm64.h"
// See comment in runtime/sys_openbsd_arm64.s re this construction. TEXT _rt0_arm64_openbsd(SB),NOSPLIT,$0
#define INVOKE_SYSCALL \ JMP _rt0_arm64(SB)
SVC; \
NOOP; \
NOOP
TEXT _rt0_arm64_openbsd(SB),NOSPLIT|NOFRAME,$0
MOVD 0(RSP), R0 // argc
ADD $8, RSP, R1 // argv
BL main(SB)
// When building with -buildmode=c-shared, this symbol is called when the shared // When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded. // library is loaded.
TEXT _rt0_arm64_openbsd_lib(SB),NOSPLIT,$184 TEXT _rt0_arm64_openbsd_lib(SB),NOSPLIT,$184
// Preserve callee-save registers. JMP _rt0_arm64_lib(SB)
SAVE_R19_TO_R28(24)
SAVE_F8_TO_F15(104)
// Initialize g as null in case of using g later e.g. sigaction in cgo_sigaction.go
MOVD ZR, g
MOVD R0, _rt0_arm64_openbsd_lib_argc<>(SB)
MOVD R1, _rt0_arm64_openbsd_lib_argv<>(SB)
// Synchronous initialization.
MOVD $runtime·libpreinit(SB), R4
BL (R4)
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
CBZ R4, nocgo
MOVD $_rt0_arm64_openbsd_lib_go(SB), R0
MOVD $0, R1
SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
BL (R4)
ADD $16, RSP
B restore
nocgo:
MOVD $0x800000, R0 // stacksize = 8192KB
MOVD $_rt0_arm64_openbsd_lib_go(SB), R1
MOVD R0, 8(RSP)
MOVD R1, 16(RSP)
MOVD $runtime·newosproc0(SB),R4
BL (R4)
restore:
// Restore callee-save registers.
RESTORE_R19_TO_R28(24)
RESTORE_F8_TO_F15(104)
RET
TEXT _rt0_arm64_openbsd_lib_go(SB),NOSPLIT,$0
MOVD _rt0_arm64_openbsd_lib_argc<>(SB), R0
MOVD _rt0_arm64_openbsd_lib_argv<>(SB), R1
MOVD $runtime·rt0_go(SB),R4
B (R4)
DATA _rt0_arm64_openbsd_lib_argc<>(SB)/8, $0
GLOBL _rt0_arm64_openbsd_lib_argc<>(SB),NOPTR, $8
DATA _rt0_arm64_openbsd_lib_argv<>(SB)/8, $0
GLOBL _rt0_arm64_openbsd_lib_argv<>(SB),NOPTR, $8
TEXT main(SB),NOSPLIT|NOFRAME,$0
MOVD $runtime·rt0_go(SB), R2
BL (R2)
exit:
MOVD $0, R0
MOVD $1, R8 // sys_exit
INVOKE_SYSCALL
B exit

25
src/runtime/rt0_windows_arm64.s
View file

@ -8,22 +8,15 @@
// This is the entry point for the program from the // This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program. // kernel for an ordinary -buildmode=exe program.
TEXT _rt0_arm64_windows(SB),NOSPLIT|NOFRAME,$0 TEXT _rt0_arm64_windows(SB),NOSPLIT,$0
B ·rt0_go(SB) // Windows doesn't use argc and argv,
// so there is no need to go through _rt0_arm64.
JMP runtime·rt0_go(SB)
TEXT _rt0_arm64_windows_lib(SB),NOSPLIT|NOFRAME,$0 // When building with -buildmode=c-shared, this symbol is called when the shared
MOVD $_rt0_arm64_windows_lib_go(SB), R0 // library is loaded.
MOVD $0, R1 TEXT _rt0_arm64_windows_lib(SB),NOSPLIT,$0
MOVD _cgo_sys_thread_create(SB), R2 // We get the argc and argv parameters from Win32.
B (R2)
TEXT _rt0_arm64_windows_lib_go(SB),NOSPLIT|NOFRAME,$0
MOVD $0, R0 MOVD $0, R0
MOVD $0, R1 MOVD $0, R1
MOVD $runtime·rt0_go(SB), R2 JMP _rt0_arm64_lib(SB)
B (R2)
TEXT main(SB),NOSPLIT|NOFRAME,$0
MOVD $runtime·rt0_go(SB), R2
B (R2)