runtime: use ABIInternal on syscall and other sys.stuff for loong64

Change-Id: I6b2942c413eab58c457980131022dace036cd76c
Reviewed-on: https://go-review.googlesource.com/c/go/+/623475
Reviewed-by: Meidan Li <limeidan@loongson.cn>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: abner chenc <chenguoqi@loongson.cn>

src/runtime/sys_linux_loong64.s

@@ -47,66 +47,58 @@
 #define SYS_timer_delete	111
 
 // func exit(code int32)
-TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
-	MOVW	code+0(FP), R4
+TEXT runtime·exit<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_exit_group, R11
 	SYSCALL
 	RET
 
 // func exitThread(wait *atomic.Uint32)
-TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
-	MOVV	wait+0(FP), R19
+TEXT runtime·exitThread<ABIInternal>(SB),NOSPLIT|NOFRAME,$0
 	// We're done using the stack.
 	DBAR	$0x12	// StoreRelease barrier
-	MOVW	R0, (R19)
+	MOVW	R0, (R4)
 	MOVW	$0, R4	// exit code
 	MOVV	$SYS_exit, R11
 	SYSCALL
 	JMP	0(PC)
 
 // func open(name *byte, mode, perm int32) int32
-TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
+TEXT runtime·open<ABIInternal>(SB),NOSPLIT,$0
+	// before:
+	//    R4:  name, R5: mode, R6: perm
+	// after:
+	//    R4: AT_FDCWD, R5: name, R6: mode, R7: perm
+	MOVW	R6, R7
+	MOVW	R5, R6
+	MOVV	R4, R5
 	MOVW	$AT_FDCWD, R4 // AT_FDCWD, so this acts like open
-	MOVV	name+0(FP), R5
-	MOVW	mode+8(FP), R6
-	MOVW	perm+12(FP), R7
+
 	MOVV	$SYS_openat, R11
 	SYSCALL
 	MOVW	$-4096, R5
 	BGEU	R5, R4, 2(PC)
 	MOVW	$-1, R4
-	MOVW	R4, ret+16(FP)
 	RET
 
 // func closefd(fd int32) int32
-TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
-	MOVW	fd+0(FP), R4
+TEXT runtime·closefd<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_close, R11
 	SYSCALL
 	MOVW	$-4096, R5
 	BGEU	R5, R4, 2(PC)
 	MOVW	$-1, R4
-	MOVW	R4, ret+8(FP)
 	RET
 
 // func write1(fd uintptr, p unsafe.Pointer, n int32) int32
-TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28
-	MOVV	fd+0(FP), R4
-	MOVV	p+8(FP), R5
-	MOVW	n+16(FP), R6
+TEXT runtime·write1<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_write, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func read(fd int32, p unsafe.Pointer, n int32) int32
-TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
-	MOVW	fd+0(FP), R4
-	MOVV	p+8(FP), R5
-	MOVW	n+16(FP), R6
+TEXT runtime·read<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_read, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func pipe2(flags int32) (r, w int32, errno int32)
@@ -119,16 +111,15 @@ TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
 	RET
 
 // func usleep(usec uint32)
-TEXT runtime·usleep(SB),NOSPLIT,$16-4
-	MOVWU	usec+0(FP), R7
+TEXT runtime·usleep<ABIInternal>(SB),NOSPLIT,$16
 	MOVV	$1000, R6
-	MULVU	R6, R7, R7
+	MULVU	R6, R4, R4
 	MOVV	$1000000000, R6
 
-	DIVVU	R6, R7, R5	// ts->tv_sec
-	REMVU	R6, R7, R4	// ts->tv_nsec
+	DIVVU	R6, R4, R5	// ts->tv_sec
+	REMVU	R6, R4, R8	// ts->tv_nsec
 	MOVV	R5, 8(R3)
-	MOVV	R4, 16(R3)
+	MOVV	R8, 16(R3)
 
 	// nanosleep(&ts, 0)
 	ADDV	$8, R3, R4
@@ -138,14 +129,14 @@ TEXT runtime·usleep(SB),NOSPLIT,$16-4
 	RET
 
 // func gettid() uint32
-TEXT runtime·gettid(SB),NOSPLIT,$0-4
+TEXT runtime·gettid<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_gettid, R11
 	SYSCALL
-	MOVW	R4, ret+0(FP)
 	RET
 
 // func raise(sig uint32)
-TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·raise<ABIInternal>(SB),NOSPLIT,$0
+	MOVW	R4, R24 // backup sig
 	MOVV	$SYS_getpid, R11
 	SYSCALL
 	MOVW	R4, R23
@@ -153,87 +144,66 @@ TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
 	SYSCALL
 	MOVW	R4, R5	// arg 2 tid
 	MOVW	R23, R4	// arg 1 pid
-	MOVW	sig+0(FP), R6	// arg 3
+	MOVW	R24, R6	// arg 3
 	MOVV	$SYS_tgkill, R11
 	SYSCALL
 	RET
 
 // func raiseproc(sig uint32)
-TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·raiseproc<ABIInternal>(SB),NOSPLIT,$0
+	MOVW	R4, R24 // backup sig
 	MOVV	$SYS_getpid, R11
 	SYSCALL
 	//MOVW	R4, R4	// arg 1 pid
-	MOVW	sig+0(FP), R5	// arg 2
+	MOVW	R24, R5	// arg 2
 	MOVV	$SYS_kill, R11
 	SYSCALL
 	RET
 
 // func getpid() int
-TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8
+TEXT ·getpid<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_getpid, R11
 	SYSCALL
-	MOVV	R4, ret+0(FP)
 	RET
 
 // func tgkill(tgid, tid, sig int)
-TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24
-	MOVV	tgid+0(FP), R4
-	MOVV	tid+8(FP), R5
-	MOVV	sig+16(FP), R6
+TEXT ·tgkill<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_tgkill, R11
 	SYSCALL
 	RET
 
 // func setitimer(mode int32, new, old *itimerval)
-TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
-	MOVW	mode+0(FP), R4
-	MOVV	new+8(FP), R5
-	MOVV	old+16(FP), R6
+TEXT runtime·setitimer<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_setitimer, R11
 	SYSCALL
 	RET
 
 // func timer_create(clockid int32, sevp *sigevent, timerid *int32) int32
-TEXT runtime·timer_create(SB),NOSPLIT,$0-28
-	MOVW	clockid+0(FP), R4
-	MOVV	sevp+8(FP), R5
-	MOVV	timerid+16(FP), R6
+TEXT runtime·timer_create<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_timer_create, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func timer_settime(timerid int32, flags int32, new, old *itimerspec) int32
-TEXT runtime·timer_settime(SB),NOSPLIT,$0-28
-	MOVW	timerid+0(FP), R4
-	MOVW	flags+4(FP), R5
-	MOVV	new+8(FP), R6
-	MOVV	old+16(FP), R7
+TEXT runtime·timer_settime<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_timer_settime, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func timer_delete(timerid int32) int32
-TEXT runtime·timer_delete(SB),NOSPLIT,$0-12
-	MOVW	timerid+0(FP), R4
+TEXT runtime·timer_delete<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_timer_delete, R11
 	SYSCALL
-	MOVW	R4, ret+8(FP)
 	RET
 
 // func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
-TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
-	MOVV	addr+0(FP), R4
-	MOVV	n+8(FP), R5
-	MOVV	dst+16(FP), R6
+TEXT runtime·mincore<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_mincore, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func walltime() (sec int64, nsec int32)
-TEXT runtime·walltime(SB),NOSPLIT,$24-12
+TEXT runtime·walltime<ABIInternal>(SB),NOSPLIT,$24
 	MOVV	R3, R23	// R23 is unchanged by C code
 	MOVV	R3, R25
 
@@ -289,7 +259,7 @@ nosaveg:
 	JAL	(R20)
 
 finish:
-	MOVV	0(R3), R7	// sec
+	MOVV	0(R3), R4	// sec
 	MOVV	8(R3), R5	// nsec
 
 	MOVV	R23, R3	// restore SP
@@ -303,8 +273,6 @@ finish:
 	MOVV	8(R3), R25
 	MOVV	R25, m_vdsoPC(R24)
 
-	MOVV	R7, sec+0(FP)
-	MOVW	R5, nsec+8(FP)
 	RET
 
 fallback:
@@ -313,7 +281,7 @@ fallback:
 	JMP finish
 
 // func nanotime1() int64
-TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
+TEXT runtime·nanotime1<ABIInternal>(SB),NOSPLIT,$24
 	MOVV	R3, R23	// R23 is unchanged by C code
 	MOVV	R3, R25
 
@@ -387,8 +355,7 @@ finish:
 	// return nsec in R7
 	MOVV	$1000000000, R4
 	MULVU	R4, R7, R7
-	ADDVU	R5, R7
-	MOVV	R7, ret+0(FP)
+	ADDVU	R5, R7, R4
 	RET
 
 fallback:
@@ -397,11 +364,7 @@ fallback:
 	JMP	finish
 
 // func rtsigprocmask(how int32, new, old *sigset, size int32)
-TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
-	MOVW	how+0(FP), R4
-	MOVV	new+8(FP), R5
-	MOVV	old+16(FP), R6
-	MOVW	size+24(FP), R7
+TEXT runtime·rtsigprocmask<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_rt_sigprocmask, R11
 	SYSCALL
 	MOVW	$-4096, R5
@@ -410,22 +373,21 @@ TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
 	RET
 
 // func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32
-TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
-	MOVV	sig+0(FP), R4
-	MOVV	new+8(FP), R5
-	MOVV	old+16(FP), R6
-	MOVV	size+24(FP), R7
+TEXT runtime·rt_sigaction<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_rt_sigaction, R11
 	SYSCALL
-	MOVW	R4, ret+32(FP)
 	RET
 
 // func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
-TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
-	MOVW	sig+8(FP), R4
-	MOVV	info+16(FP), R5
-	MOVV	ctx+24(FP), R6
-	MOVV	fn+0(FP), R20
+TEXT runtime·sigfwd<ABIInternal>(SB),NOSPLIT,$0
+	// before:
+	//    R4:  fn, R5: sig, R6: info, R7: ctx
+	// after:
+	//    R20: fn, R4: sig, R5: info, R6: ctx
+	MOVV	R4, R20
+	MOVV	R5, R4
+	MOVV	R6, R5
+	MOVV	R7, R6
 	JAL	(R20)
 	RET
 
@@ -458,48 +420,31 @@ TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
 	JMP	runtime·sigtramp(SB)
 
 // func sysMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)
-TEXT runtime·sysMmap(SB),NOSPLIT|NOFRAME,$0
-	MOVV	addr+0(FP), R4
-	MOVV	n+8(FP), R5
-	MOVW	prot+16(FP), R6
-	MOVW	flags+20(FP), R7
-	MOVW	fd+24(FP), R8
-	MOVW	off+28(FP), R9
-
+TEXT runtime·sysMmap<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_mmap, R11
 	SYSCALL
 	MOVW	$-4096, R5
 	BGEU	R5, R4, ok
-	MOVV	$0, p+32(FP)
-	SUBVU	R4, R0, R4
-	MOVV	R4, err+40(FP)
+	SUBVU	R4, R0, R5
+	MOVV	$0, R4
 	RET
 ok:
-	MOVV	R4, p+32(FP)
-	MOVV	$0, err+40(FP)
+	MOVV	$0, R5
 	RET
 
 // Call the function stored in _cgo_mmap using the GCC calling convention.
 // This must be called on the system stack.
 // func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr
-TEXT runtime·callCgoMmap(SB),NOSPLIT,$0
-	MOVV	addr+0(FP), R4
-	MOVV	n+8(FP), R5
-	MOVW	prot+16(FP), R6
-	MOVW	flags+20(FP), R7
-	MOVW	fd+24(FP), R8
-	MOVW	off+28(FP), R9
+TEXT runtime·callCgoMmap<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	_cgo_mmap(SB), R13
 	SUBV	$16, R3		// reserve 16 bytes for sp-8 where fp may be saved.
 	JAL	(R13)
 	ADDV	$16, R3
-	MOVV	R4, ret+32(FP)
+	MOVV	R4, R4
 	RET
 
 // func sysMunmap(addr unsafe.Pointer, n uintptr)
-TEXT runtime·sysMunmap(SB),NOSPLIT|NOFRAME,$0
-	MOVV	addr+0(FP), R4
-	MOVV	n+8(FP), R5
+TEXT runtime·sysMunmap<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_munmap, R11
 	SYSCALL
 	MOVW	$-4096, R5
@@ -510,9 +455,7 @@ TEXT runtime·sysMunmap(SB),NOSPLIT|NOFRAME,$0
 // Call the function stored in _cgo_munmap using the GCC calling convention.
 // This must be called on the system stack.
 // func callCgoMunmap(addr unsafe.Pointer, n uintptr)
-TEXT runtime·callCgoMunmap(SB),NOSPLIT,$0
-	MOVV	addr+0(FP), R4
-	MOVV	n+8(FP), R5
+TEXT runtime·callCgoMunmap<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	_cgo_munmap(SB), R13
 	SUBV	$16, R3		// reserve 16 bytes for sp-8 where fp may be saved.
 	JAL	(R13)
@@ -520,38 +463,24 @@ TEXT runtime·callCgoMunmap(SB),NOSPLIT,$0
 	RET
 
 // func madvise(addr unsafe.Pointer, n uintptr, flags int32)
-TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
-	MOVV	addr+0(FP), R4
-	MOVV	n+8(FP), R5
-	MOVW	flags+16(FP), R6
+TEXT runtime·madvise<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_madvise, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32
-TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0
-	MOVV	addr+0(FP), R4
-	MOVW	op+8(FP), R5
-	MOVW	val+12(FP), R6
-	MOVV	ts+16(FP), R7
-	MOVV	addr2+24(FP), R8
-	MOVW	val3+32(FP), R9
+TEXT runtime·futex<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_futex, R11
 	SYSCALL
-	MOVW	R4, ret+40(FP)
 	RET
 
 // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
-	MOVW	flags+0(FP), R4
-	MOVV	stk+8(FP), R5
-
+TEXT runtime·clone<ABIInternal>(SB),NOSPLIT,$0
 	// Copy mp, gp, fn off parent stack for use by child.
 	// Careful: Linux system call clobbers ???.
-	MOVV	mp+16(FP), R23
-	MOVV	gp+24(FP), R24
-	MOVV	fn+32(FP), R25
+	MOVV	R6, R23
+	MOVV	R7, R24
+	MOVV	R8, R25
 
 	MOVV	R23, -8(R5)
 	MOVV	R24, -16(R5)
@@ -563,8 +492,7 @@ TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
 	SYSCALL
 
 	// In parent, return.
-	BEQ	R4, 3(PC)
-	MOVW	R4, ret+40(FP)
+	BEQ	R4, 2(PC)
 	RET
 
 	// In child, on new stack.
@@ -604,9 +532,7 @@ nog:
 	JMP	-3(PC)	// keep exiting
 
 // func sigaltstack(new, old *stackt)
-TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
-	MOVV	new+0(FP), R4
-	MOVV	old+8(FP), R5
+TEXT runtime·sigaltstack<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_sigaltstack, R11
 	SYSCALL
 	MOVW	$-4096, R5
@@ -615,47 +541,45 @@ TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
 	RET
 
 // func osyield()
-TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
+TEXT runtime·osyield<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_sched_yield, R11
 	SYSCALL
 	RET
 
 // func sched_getaffinity(pid, len uintptr, buf *uintptr) int32
-TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0
-	MOVV	pid+0(FP), R4
-	MOVV	len+8(FP), R5
-	MOVV	buf+16(FP), R6
+TEXT runtime·sched_getaffinity<ABIInternal>(SB),NOSPLIT,$0
 	MOVV	$SYS_sched_getaffinity, R11
 	SYSCALL
-	MOVW	R4, ret+24(FP)
 	RET
 
 // func sbrk0() uintptr
-TEXT runtime·sbrk0(SB),NOSPLIT|NOFRAME,$0-8
+TEXT runtime·sbrk0<ABIInternal>(SB),NOSPLIT,$0
 	// Implemented as brk(NULL).
 	MOVV	$0, R4
 	MOVV	$SYS_brk, R11
 	SYSCALL
-	MOVV	R4, ret+0(FP)
 	RET
 
+// unimplemented, only needed for android; declared in stubs_linux.go
 TEXT runtime·access(SB),$0-20
-	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
+	MOVV	R0, 2(R0)
 	MOVW	R0, ret+16(FP) // for vet
 	RET
 
+// unimplemented, only needed for android; declared in stubs_linux.go
 TEXT runtime·connect(SB),$0-28
-	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
+	MOVV	R0, 2(R0)
 	MOVW	R0, ret+24(FP) // for vet
 	RET
 
+// unimplemented, only needed for android; declared in stubs_linux.go
 TEXT runtime·socket(SB),$0-20
-	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
+	MOVV	R0, 2(R0)
 	MOVW	R0, ret+16(FP) // for vet
 	RET
 
 // func vgetrandom1(buf *byte, length uintptr, flags uint32, state uintptr, stateSize uintptr) int
-TEXT runtime·vgetrandom1<ABIInternal>(SB),NOSPLIT,$16-48
+TEXT runtime·vgetrandom1<ABIInternal>(SB),NOSPLIT,$16
 	MOVV	R3, R23
 
 	MOVV	runtime·vdsoGetrandomSym(SB), R12