mirror of https://go.googlesource.com/go
793 lines
18 KiB
ArmAsm
793 lines
18 KiB
ArmAsm
// Copyright 2015 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// System calls and other sys.stuff for ARM64, Darwin
|
|
// System calls are implemented in libSystem, this file contains
|
|
// trampolines that convert from Go to C calling convention.
|
|
|
|
#include "go_asm.h"
|
|
#include "go_tls.h"
|
|
#include "textflag.h"
|
|
#include "cgo/abi_arm64.h"
|
|
|
|
#define CLOCK_REALTIME 0
|
|
|
|
TEXT notok<>(SB),NOSPLIT,$0
|
|
MOVD $0, R8
|
|
MOVD R8, (R8)
|
|
B 0(PC)
|
|
|
|
TEXT runtime·open_trampoline(SB),NOSPLIT,$0
|
|
SUB $16, RSP
|
|
MOVW 8(R0), R1 // arg 2 flags
|
|
MOVW 12(R0), R2 // arg 3 mode
|
|
MOVW R2, (RSP) // arg 3 is variadic, pass on stack
|
|
MOVD 0(R0), R0 // arg 1 pathname
|
|
BL libc_open(SB)
|
|
ADD $16, RSP
|
|
RET
|
|
|
|
TEXT runtime·close_trampoline(SB),NOSPLIT,$0
|
|
MOVW 0(R0), R0 // arg 1 fd
|
|
BL libc_close(SB)
|
|
RET
|
|
|
|
TEXT runtime·write_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 buf
|
|
MOVW 16(R0), R2 // arg 3 count
|
|
MOVW 0(R0), R0 // arg 1 fd
|
|
BL libc_write(SB)
|
|
MOVD $-1, R1
|
|
CMP R0, R1
|
|
BNE noerr
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
NEG R0, R0 // caller expects negative errno value
|
|
noerr:
|
|
RET
|
|
|
|
TEXT runtime·read_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 buf
|
|
MOVW 16(R0), R2 // arg 3 count
|
|
MOVW 0(R0), R0 // arg 1 fd
|
|
BL libc_read(SB)
|
|
MOVD $-1, R1
|
|
CMP R0, R1
|
|
BNE noerr
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
NEG R0, R0 // caller expects negative errno value
|
|
noerr:
|
|
RET
|
|
|
|
TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
|
|
BL libc_pipe(SB) // pointer already in R0
|
|
CMP $0, R0
|
|
BEQ 3(PC)
|
|
BL libc_error(SB) // return negative errno value
|
|
NEG R0, R0
|
|
RET
|
|
|
|
TEXT runtime·exit_trampoline(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW 0(R0), R0
|
|
BL libc_exit(SB)
|
|
MOVD $1234, R0
|
|
MOVD $1002, R1
|
|
MOVD R0, (R1) // fail hard
|
|
|
|
TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
|
|
MOVD 0(R0), R19 // signal
|
|
BL libc_getpid(SB)
|
|
// arg 1 pid already in R0 from getpid
|
|
MOVD R19, R1 // arg 2 signal
|
|
BL libc_kill(SB)
|
|
RET
|
|
|
|
TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
|
|
MOVD R0, R19
|
|
MOVD 0(R19), R0 // arg 1 addr
|
|
MOVD 8(R19), R1 // arg 2 len
|
|
MOVW 16(R19), R2 // arg 3 prot
|
|
MOVW 20(R19), R3 // arg 4 flags
|
|
MOVW 24(R19), R4 // arg 5 fd
|
|
MOVW 28(R19), R5 // arg 6 off
|
|
BL libc_mmap(SB)
|
|
MOVD $0, R1
|
|
MOVD $-1, R2
|
|
CMP R0, R2
|
|
BNE ok
|
|
BL libc_error(SB)
|
|
MOVW (R0), R1
|
|
MOVD $0, R0
|
|
ok:
|
|
MOVD R0, 32(R19) // ret 1 p
|
|
MOVD R1, 40(R19) // ret 2 err
|
|
RET
|
|
|
|
TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 len
|
|
MOVD 0(R0), R0 // arg 1 addr
|
|
BL libc_munmap(SB)
|
|
CMP $0, R0
|
|
BEQ 2(PC)
|
|
BL notok<>(SB)
|
|
RET
|
|
|
|
TEXT runtime·madvise_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 len
|
|
MOVW 16(R0), R2 // arg 3 advice
|
|
MOVD 0(R0), R0 // arg 1 addr
|
|
BL libc_madvise(SB)
|
|
RET
|
|
|
|
TEXT runtime·mlock_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 len
|
|
MOVD 0(R0), R0 // arg 1 addr
|
|
BL libc_mlock(SB)
|
|
RET
|
|
|
|
TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 new
|
|
MOVD 16(R0), R2 // arg 3 old
|
|
MOVW 0(R0), R0 // arg 1 which
|
|
BL libc_setitimer(SB)
|
|
RET
|
|
|
|
TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
|
|
MOVD R0, R1 // arg 2 timespec
|
|
MOVW $CLOCK_REALTIME, R0 // arg 1 clock_id
|
|
BL libc_clock_gettime(SB)
|
|
RET
|
|
|
|
GLOBL timebase<>(SB),NOPTR,$(machTimebaseInfo__size)
|
|
|
|
TEXT runtime·nanotime_trampoline(SB),NOSPLIT,$40
|
|
MOVD R0, R19
|
|
BL libc_mach_absolute_time(SB)
|
|
MOVD R0, 0(R19)
|
|
MOVW timebase<>+machTimebaseInfo_numer(SB), R20
|
|
MOVD $timebase<>+machTimebaseInfo_denom(SB), R21
|
|
LDARW (R21), R21 // atomic read
|
|
CMP $0, R21
|
|
BNE initialized
|
|
|
|
SUB $(machTimebaseInfo__size+15)/16*16, RSP
|
|
MOVD RSP, R0
|
|
BL libc_mach_timebase_info(SB)
|
|
MOVW machTimebaseInfo_numer(RSP), R20
|
|
MOVW machTimebaseInfo_denom(RSP), R21
|
|
ADD $(machTimebaseInfo__size+15)/16*16, RSP
|
|
|
|
MOVW R20, timebase<>+machTimebaseInfo_numer(SB)
|
|
MOVD $timebase<>+machTimebaseInfo_denom(SB), R22
|
|
STLRW R21, (R22) // atomic write
|
|
|
|
initialized:
|
|
MOVW R20, 8(R19)
|
|
MOVW R21, 12(R19)
|
|
RET
|
|
|
|
TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
|
|
MOVW sig+8(FP), R0
|
|
MOVD info+16(FP), R1
|
|
MOVD ctx+24(FP), R2
|
|
MOVD fn+0(FP), R11
|
|
BL (R11)
|
|
RET
|
|
|
|
TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$176
|
|
// Save callee-save registers in the case of signal forwarding.
|
|
// Please refer to https://golang.org/issue/31827 .
|
|
SAVE_R19_TO_R28(8*4)
|
|
SAVE_F8_TO_F15(8*14)
|
|
|
|
// Save arguments.
|
|
MOVW R0, (8*1)(RSP) // sig
|
|
MOVD R1, (8*2)(RSP) // info
|
|
MOVD R2, (8*3)(RSP) // ctx
|
|
|
|
// this might be called in external code context,
|
|
// where g is not set.
|
|
BL runtime·load_g(SB)
|
|
|
|
#ifdef GOOS_ios
|
|
MOVD RSP, R6
|
|
CMP $0, g
|
|
BEQ nog
|
|
// iOS always use the main stack to run the signal handler.
|
|
// We need to switch to gsignal ourselves.
|
|
MOVD g_m(g), R11
|
|
MOVD m_gsignal(R11), R5
|
|
MOVD (g_stack+stack_hi)(R5), R6
|
|
|
|
nog:
|
|
// Restore arguments.
|
|
MOVW (8*1)(RSP), R0
|
|
MOVD (8*2)(RSP), R1
|
|
MOVD (8*3)(RSP), R2
|
|
|
|
// Reserve space for args and the stack pointer on the
|
|
// gsignal stack.
|
|
SUB $48, R6
|
|
// Save stack pointer.
|
|
MOVD RSP, R4
|
|
MOVD R4, (8*4)(R6)
|
|
// Switch to gsignal stack.
|
|
MOVD R6, RSP
|
|
|
|
// Save arguments.
|
|
MOVW R0, (8*1)(RSP)
|
|
MOVD R1, (8*2)(RSP)
|
|
MOVD R2, (8*3)(RSP)
|
|
#endif
|
|
|
|
// Call sigtrampgo.
|
|
MOVD $runtime·sigtrampgo(SB), R11
|
|
BL (R11)
|
|
|
|
#ifdef GOOS_ios
|
|
// Switch to old stack.
|
|
MOVD (8*4)(RSP), R5
|
|
MOVD R5, RSP
|
|
#endif
|
|
|
|
// Restore callee-save registers.
|
|
RESTORE_R19_TO_R28(8*4)
|
|
RESTORE_F8_TO_F15(8*14)
|
|
|
|
RET
|
|
|
|
TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
|
|
JMP runtime·sigtramp(SB)
|
|
|
|
TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 new
|
|
MOVD 16(R0), R2 // arg 3 old
|
|
MOVW 0(R0), R0 // arg 1 how
|
|
BL libc_pthread_sigmask(SB)
|
|
CMP $0, R0
|
|
BEQ 2(PC)
|
|
BL notok<>(SB)
|
|
RET
|
|
|
|
TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 new
|
|
MOVD 16(R0), R2 // arg 3 old
|
|
MOVW 0(R0), R0 // arg 1 how
|
|
BL libc_sigaction(SB)
|
|
CMP $0, R0
|
|
BEQ 2(PC)
|
|
BL notok<>(SB)
|
|
RET
|
|
|
|
TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
|
|
MOVW 0(R0), R0 // arg 1 usec
|
|
BL libc_usleep(SB)
|
|
RET
|
|
|
|
TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
|
|
MOVW 8(R0), R1 // arg 2 miblen
|
|
MOVD 16(R0), R2 // arg 3 oldp
|
|
MOVD 24(R0), R3 // arg 4 oldlenp
|
|
MOVD 32(R0), R4 // arg 5 newp
|
|
MOVD 40(R0), R5 // arg 6 newlen
|
|
MOVD 0(R0), R0 // arg 1 mib
|
|
BL libc_sysctl(SB)
|
|
RET
|
|
|
|
TEXT runtime·sysctlbyname_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 oldp
|
|
MOVD 16(R0), R2 // arg 3 oldlenp
|
|
MOVD 24(R0), R3 // arg 4 newp
|
|
MOVD 32(R0), R4 // arg 5 newlen
|
|
MOVD 0(R0), R0 // arg 1 name
|
|
BL libc_sysctlbyname(SB)
|
|
RET
|
|
|
|
|
|
TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
|
|
BL libc_kqueue(SB)
|
|
RET
|
|
|
|
TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 keventt
|
|
MOVW 16(R0), R2 // arg 3 nch
|
|
MOVD 24(R0), R3 // arg 4 ev
|
|
MOVW 32(R0), R4 // arg 5 nev
|
|
MOVD 40(R0), R5 // arg 6 ts
|
|
MOVW 0(R0), R0 // arg 1 kq
|
|
BL libc_kevent(SB)
|
|
MOVD $-1, R2
|
|
CMP R0, R2
|
|
BNE ok
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0 // errno
|
|
NEG R0, R0 // caller wants it as a negative error code
|
|
ok:
|
|
RET
|
|
|
|
TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
|
|
SUB $16, RSP
|
|
MOVD R0, R19
|
|
MOVW 0(R19), R0 // arg 1 fd
|
|
MOVW 4(R19), R1 // arg 2 cmd
|
|
MOVW 8(R19), R2 // arg 3 arg
|
|
MOVW R2, (RSP) // arg 3 is variadic, pass on stack
|
|
BL libc_fcntl(SB)
|
|
MOVD $0, R1
|
|
MOVD $-1, R2
|
|
CMP R0, R2
|
|
BNE noerr
|
|
BL libc_error(SB)
|
|
MOVW (R0), R1
|
|
MOVW $-1, R0
|
|
noerr:
|
|
MOVW R0, 12(R19)
|
|
MOVW R1, 16(R19)
|
|
ADD $16, RSP
|
|
RET
|
|
|
|
TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
|
|
#ifdef GOOS_ios
|
|
// sigaltstack on iOS is not supported and will always
|
|
// run the signal handler on the main stack, so our sigtramp has
|
|
// to do the stack switch ourselves.
|
|
MOVW $43, R0
|
|
BL libc_exit(SB)
|
|
#else
|
|
MOVD 8(R0), R1 // arg 2 old
|
|
MOVD 0(R0), R0 // arg 1 new
|
|
CALL libc_sigaltstack(SB)
|
|
CBZ R0, 2(PC)
|
|
BL notok<>(SB)
|
|
#endif
|
|
RET
|
|
|
|
// Thread related functions
|
|
|
|
// mstart_stub is the first function executed on a new thread started by pthread_create.
|
|
// It just does some low-level setup and then calls mstart.
|
|
// Note: called with the C calling convention.
|
|
TEXT runtime·mstart_stub(SB),NOSPLIT,$160
|
|
// R0 points to the m.
|
|
// We are already on m's g0 stack.
|
|
|
|
// Save callee-save registers.
|
|
SAVE_R19_TO_R28(8)
|
|
SAVE_F8_TO_F15(88)
|
|
|
|
MOVD m_g0(R0), g
|
|
BL ·save_g(SB)
|
|
|
|
BL runtime·mstart(SB)
|
|
|
|
// Restore callee-save registers.
|
|
RESTORE_R19_TO_R28(8)
|
|
RESTORE_F8_TO_F15(88)
|
|
|
|
// Go is all done with this OS thread.
|
|
// Tell pthread everything is ok (we never join with this thread, so
|
|
// the value here doesn't really matter).
|
|
MOVD $0, R0
|
|
|
|
RET
|
|
|
|
TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
|
|
MOVD 0(R0), R0 // arg 1 attr
|
|
BL libc_pthread_attr_init(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 size
|
|
MOVD 0(R0), R0 // arg 1 attr
|
|
BL libc_pthread_attr_getstacksize(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 state
|
|
MOVD 0(R0), R0 // arg 1 attr
|
|
BL libc_pthread_attr_setdetachstate(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
|
|
SUB $16, RSP
|
|
MOVD 0(R0), R1 // arg 2 state
|
|
MOVD 8(R0), R2 // arg 3 start
|
|
MOVD 16(R0), R3 // arg 4 arg
|
|
MOVD RSP, R0 // arg 1 &threadid (which we throw away)
|
|
BL libc_pthread_create(SB)
|
|
ADD $16, RSP
|
|
RET
|
|
|
|
TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
|
|
MOVW 0(R0), R0 // arg 1 sig
|
|
BL libc_raise(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 attr
|
|
MOVD 0(R0), R0 // arg 1 mutex
|
|
BL libc_pthread_mutex_init(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
|
|
MOVD 0(R0), R0 // arg 1 mutex
|
|
BL libc_pthread_mutex_lock(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
|
|
MOVD 0(R0), R0 // arg 1 mutex
|
|
BL libc_pthread_mutex_unlock(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 attr
|
|
MOVD 0(R0), R0 // arg 1 cond
|
|
BL libc_pthread_cond_init(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 mutex
|
|
MOVD 0(R0), R0 // arg 1 cond
|
|
BL libc_pthread_cond_wait(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 mutex
|
|
MOVD 16(R0), R2 // arg 3 timeout
|
|
MOVD 0(R0), R0 // arg 1 cond
|
|
BL libc_pthread_cond_timedwait_relative_np(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
|
|
MOVD 0(R0), R0 // arg 1 cond
|
|
BL libc_pthread_cond_signal(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_self_trampoline(SB),NOSPLIT,$0
|
|
MOVD R0, R19 // R19 is callee-save
|
|
BL libc_pthread_self(SB)
|
|
MOVD R0, 0(R19) // return value
|
|
RET
|
|
|
|
TEXT runtime·pthread_kill_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 sig
|
|
MOVD 0(R0), R0 // arg 1 thread
|
|
BL libc_pthread_kill(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_key_create_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 destructor
|
|
MOVD 0(R0), R0 // arg 1 *key
|
|
BL libc_pthread_key_create(SB)
|
|
RET
|
|
|
|
TEXT runtime·pthread_setspecific_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // arg 2 value
|
|
MOVD 0(R0), R0 // arg 1 key
|
|
BL libc_pthread_setspecific(SB)
|
|
RET
|
|
|
|
TEXT runtime·osinit_hack_trampoline(SB),NOSPLIT,$0
|
|
MOVD $0, R0 // arg 1 val
|
|
BL libc_notify_is_valid_token(SB)
|
|
BL libc_xpc_date_create_from_current(SB)
|
|
RET
|
|
|
|
// syscall calls a function in libc on behalf of the syscall package.
|
|
// syscall takes a pointer to a struct like:
|
|
// struct {
|
|
// fn uintptr
|
|
// a1 uintptr
|
|
// a2 uintptr
|
|
// a3 uintptr
|
|
// r1 uintptr
|
|
// r2 uintptr
|
|
// err uintptr
|
|
// }
|
|
// syscall must be called on the g0 stack with the
|
|
// C calling convention (use libcCall).
|
|
TEXT runtime·syscall(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, 8(RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 8(R0), R0 // a1
|
|
|
|
// If fn is declared as vararg, we have to pass the vararg arguments on the stack.
|
|
// (Because ios decided not to adhere to the standard arm64 calling convention, sigh...)
|
|
// The only libSystem calls we support that are vararg are open, fcntl, and ioctl,
|
|
// which are all of the form fn(x, y, ...). So we just need to put the 3rd arg
|
|
// on the stack as well.
|
|
// If we ever have other vararg libSystem calls, we might need to handle more cases.
|
|
MOVD R2, (RSP)
|
|
|
|
BL (R12)
|
|
|
|
MOVD 8(RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 32(R2) // save r1
|
|
MOVD R1, 40(R2) // save r2
|
|
CMPW $-1, R0
|
|
BNE ok
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R2, 8(RSP)
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
MOVD 8(RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 48(R2) // save err
|
|
ok:
|
|
RET
|
|
|
|
// syscallX calls a function in libc on behalf of the syscall package.
|
|
// syscallX takes a pointer to a struct like:
|
|
// struct {
|
|
// fn uintptr
|
|
// a1 uintptr
|
|
// a2 uintptr
|
|
// a3 uintptr
|
|
// r1 uintptr
|
|
// r2 uintptr
|
|
// err uintptr
|
|
// }
|
|
// syscallX must be called on the g0 stack with the
|
|
// C calling convention (use libcCall).
|
|
TEXT runtime·syscallX(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, (RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 8(R0), R0 // a1
|
|
BL (R12)
|
|
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 32(R2) // save r1
|
|
MOVD R1, 40(R2) // save r2
|
|
CMP $-1, R0
|
|
BNE ok
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R2, (RSP)
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 48(R2) // save err
|
|
ok:
|
|
RET
|
|
|
|
// syscallPtr is like syscallX except that the libc function reports an
|
|
// error by returning NULL and setting errno.
|
|
TEXT runtime·syscallPtr(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, (RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 8(R0), R0 // a1
|
|
BL (R12)
|
|
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 32(R2) // save r1
|
|
MOVD R1, 40(R2) // save r2
|
|
CMP $0, R0
|
|
BNE ok
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R2, (RSP)
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 48(R2) // save err
|
|
ok:
|
|
RET
|
|
|
|
// syscall6 calls a function in libc on behalf of the syscall package.
|
|
// syscall6 takes a pointer to a struct like:
|
|
// struct {
|
|
// fn uintptr
|
|
// a1 uintptr
|
|
// a2 uintptr
|
|
// a3 uintptr
|
|
// a4 uintptr
|
|
// a5 uintptr
|
|
// a6 uintptr
|
|
// r1 uintptr
|
|
// r2 uintptr
|
|
// err uintptr
|
|
// }
|
|
// syscall6 must be called on the g0 stack with the
|
|
// C calling convention (use libcCall).
|
|
TEXT runtime·syscall6(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, 8(RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 32(R0), R3 // a4
|
|
MOVD 40(R0), R4 // a5
|
|
MOVD 48(R0), R5 // a6
|
|
MOVD 8(R0), R0 // a1
|
|
|
|
// If fn is declared as vararg, we have to pass the vararg arguments on the stack.
|
|
// See syscall above. The only function this applies to is openat, for which the 4th
|
|
// arg must be on the stack.
|
|
MOVD R3, (RSP)
|
|
|
|
BL (R12)
|
|
|
|
MOVD 8(RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 56(R2) // save r1
|
|
MOVD R1, 64(R2) // save r2
|
|
CMPW $-1, R0
|
|
BNE ok
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R2, 8(RSP)
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
MOVD 8(RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 72(R2) // save err
|
|
ok:
|
|
RET
|
|
|
|
// syscall6X calls a function in libc on behalf of the syscall package.
|
|
// syscall6X takes a pointer to a struct like:
|
|
// struct {
|
|
// fn uintptr
|
|
// a1 uintptr
|
|
// a2 uintptr
|
|
// a3 uintptr
|
|
// a4 uintptr
|
|
// a5 uintptr
|
|
// a6 uintptr
|
|
// r1 uintptr
|
|
// r2 uintptr
|
|
// err uintptr
|
|
// }
|
|
// syscall6X must be called on the g0 stack with the
|
|
// C calling convention (use libcCall).
|
|
TEXT runtime·syscall6X(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, (RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 32(R0), R3 // a4
|
|
MOVD 40(R0), R4 // a5
|
|
MOVD 48(R0), R5 // a6
|
|
MOVD 8(R0), R0 // a1
|
|
BL (R12)
|
|
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 56(R2) // save r1
|
|
MOVD R1, 64(R2) // save r2
|
|
CMP $-1, R0
|
|
BNE ok
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R2, (RSP)
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 72(R2) // save err
|
|
ok:
|
|
RET
|
|
|
|
// syscall9 calls a function in libc on behalf of the syscall package.
|
|
// syscall9 takes a pointer to a struct like:
|
|
// struct {
|
|
// fn uintptr
|
|
// a1 uintptr
|
|
// a2 uintptr
|
|
// a3 uintptr
|
|
// a4 uintptr
|
|
// a5 uintptr
|
|
// a6 uintptr
|
|
// a7 uintptr
|
|
// a8 uintptr
|
|
// a9 uintptr
|
|
// r1 uintptr
|
|
// r2 uintptr
|
|
// err uintptr
|
|
// }
|
|
// syscall9 must be called on the g0 stack with the
|
|
// C calling convention (use libcCall).
|
|
TEXT runtime·syscall9(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, 8(RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 32(R0), R3 // a4
|
|
MOVD 40(R0), R4 // a5
|
|
MOVD 48(R0), R5 // a6
|
|
MOVD 56(R0), R6 // a7
|
|
MOVD 64(R0), R7 // a8
|
|
MOVD 72(R0), R8 // a9
|
|
MOVD 8(R0), R0 // a1
|
|
|
|
// If fn is declared as vararg, we have to pass the vararg arguments on the stack.
|
|
// See syscall above. The only function this applies to is openat, for which the 4th
|
|
// arg must be on the stack.
|
|
MOVD R3, (RSP)
|
|
|
|
BL (R12)
|
|
|
|
MOVD 8(RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 80(R2) // save r1
|
|
MOVD R1, 88(R2) // save r2
|
|
CMPW $-1, R0
|
|
BNE ok
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R2, 8(RSP)
|
|
BL libc_error(SB)
|
|
MOVW (R0), R0
|
|
MOVD 8(RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 96(R2) // save err
|
|
ok:
|
|
RET
|
|
|
|
// syscall_x509 is for crypto/x509. It is like syscall6 but does not check for errors,
|
|
// takes 5 uintptrs and 1 float64, and only returns one value,
|
|
// for use with standard C ABI functions.
|
|
TEXT runtime·syscall_x509(SB),NOSPLIT,$0
|
|
SUB $16, RSP // push structure pointer
|
|
MOVD R0, (RSP)
|
|
|
|
MOVD 0(R0), R12 // fn
|
|
MOVD 16(R0), R1 // a2
|
|
MOVD 24(R0), R2 // a3
|
|
MOVD 32(R0), R3 // a4
|
|
MOVD 40(R0), R4 // a5
|
|
FMOVD 48(R0), F0 // f1
|
|
MOVD 8(R0), R0 // a1
|
|
BL (R12)
|
|
|
|
MOVD (RSP), R2 // pop structure pointer
|
|
ADD $16, RSP
|
|
MOVD R0, 56(R2) // save r1
|
|
RET
|
|
|
|
TEXT runtime·issetugid_trampoline(SB),NOSPLIT,$0
|
|
BL libc_issetugid(SB)
|
|
RET
|
|
|
|
// mach_vm_region_trampoline calls mach_vm_region from libc.
|
|
TEXT runtime·mach_vm_region_trampoline(SB),NOSPLIT,$0
|
|
MOVD 0(R0), R1 // address
|
|
MOVD 8(R0), R2 // size
|
|
MOVW 16(R0), R3 // flavor
|
|
MOVD 24(R0), R4 // info
|
|
MOVD 32(R0), R5 // count
|
|
MOVD 40(R0), R6 // object_name
|
|
MOVD $libc_mach_task_self_(SB), R0
|
|
MOVW 0(R0), R0
|
|
BL libc_mach_vm_region(SB)
|
|
RET
|
|
|
|
// proc_regionfilename_trampoline calls proc_regionfilename for
|
|
// the current process.
|
|
TEXT runtime·proc_regionfilename_trampoline(SB),NOSPLIT,$0
|
|
MOVD 8(R0), R1 // address
|
|
MOVD 16(R0), R2 // buffer
|
|
MOVD 24(R0), R3 // buffer_size
|
|
MOVD 0(R0), R0 // pid
|
|
BL libc_proc_regionfilename(SB)
|
|
RET
|