#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)
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
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
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
JAL (R20)
finish:
- MOVV 0(R3), R7 // sec
+ MOVV 0(R3), R4 // sec
MOVV 8(R3), R5 // nsec
MOVV R23, R3 // restore SP
MOVV 8(R3), R25
MOVV R25, m_vdsoPC(R24)
- MOVV R7, sec+0(FP)
- MOVW R5, nsec+8(FP)
RET
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
// 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:
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
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
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
// 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)
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)
SYSCALL
// In parent, return.
- BEQ R4, 3(PC)
- MOVW R4, ret+40(FP)
+ BEQ R4, 2(PC)
RET
// In child, on new stack.
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
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