...
Run Format

Text file src/runtime/sys_darwin_arm64.s

Documentation: runtime

     1	// Copyright 2015 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// System calls and other sys.stuff for ARM64, Darwin
     6	// See http://fxr.watson.org/fxr/source/bsd/kern/syscalls.c?v=xnu-1228
     7	// or /usr/include/sys/syscall.h (on a Mac) for system call numbers.
     8	
     9	#include "go_asm.h"
    10	#include "go_tls.h"
    11	#include "textflag.h"
    12	
    13	// Copied from /usr/include/sys/syscall.h
    14	#define	SYS_exit           1
    15	#define	SYS_read           3
    16	#define	SYS_write          4
    17	#define	SYS_open           5
    18	#define	SYS_close          6
    19	#define	SYS_mmap           197
    20	#define	SYS_munmap         73
    21	#define	SYS_madvise        75
    22	#define	SYS_gettimeofday   116
    23	#define	SYS_kill           37
    24	#define	SYS_getpid         20
    25	#define	SYS___pthread_kill 328
    26	#define	SYS_pthread_sigmask 329
    27	#define	SYS_setitimer      83
    28	#define	SYS___sysctl       202
    29	#define	SYS_sigaction      46
    30	#define	SYS_sigreturn      184
    31	#define	SYS_select         93
    32	#define	SYS_bsdthread_register 366
    33	#define	SYS_bsdthread_create 360
    34	#define	SYS_bsdthread_terminate 361
    35	#define	SYS_kqueue         362
    36	#define	SYS_kevent         363
    37	#define	SYS_fcntl          92
    38	
    39	TEXT notok<>(SB),NOSPLIT,$0
    40		MOVD	$0, R8
    41		MOVD	R8, (R8)
    42		B	0(PC)
    43	
    44	TEXT runtime·open(SB),NOSPLIT,$0
    45		MOVD	name+0(FP), R0
    46		MOVW	mode+8(FP), R1
    47		MOVW	perm+12(FP), R2
    48		MOVD	$SYS_open, R16
    49		SVC	$0x80
    50		CSINV	LO, R0, ZR, R0
    51		MOVW	R0, ret+16(FP)
    52		RET
    53	
    54	TEXT runtime·closefd(SB),NOSPLIT,$0
    55		MOVW	fd+0(FP), R0
    56		MOVW	$SYS_close, R16
    57		SVC	$0x80
    58		CSINV	LO, R0, ZR, R0
    59		MOVW	R0, ret+8(FP)
    60		RET
    61	
    62	TEXT runtime·write(SB),NOSPLIT,$0
    63		MOVW	fd+0(FP), R0
    64		MOVD	p+8(FP), R1
    65		MOVW	n+16(FP), R2
    66		MOVW	$SYS_write, R16
    67		SVC	$0x80
    68		CSINV	LO, R0, ZR, R0
    69		MOVW	R0, ret+24(FP)
    70		RET
    71	
    72	TEXT runtime·read(SB),NOSPLIT,$0
    73		MOVW	fd+0(FP), R0
    74		MOVD	p+8(FP), R1
    75		MOVW	n+16(FP), R2
    76		MOVW	$SYS_read, R16
    77		SVC	$0x80
    78		CSINV	LO, R0, ZR, R0
    79		MOVW	R0, ret+24(FP)
    80		RET
    81	
    82	TEXT runtime·exit(SB),NOSPLIT,$-8
    83		MOVW	code+0(FP), R0
    84		MOVW	$SYS_exit, R16
    85		SVC	$0x80
    86		MOVD	$1234, R0
    87		MOVD	$1002, R1
    88		MOVD	R0, (R1)	// fail hard
    89	
    90	// Exit this OS thread (like pthread_exit, which eventually
    91	// calls __bsdthread_terminate).
    92	TEXT exit1<>(SB),NOSPLIT,$0
    93		// Because of exitThread below, this must not use the stack.
    94		// __bsdthread_terminate takes 4 word-size arguments.
    95		// Set them all to 0. (None are an exit status.)
    96		MOVW	$0, R0
    97		MOVW	$0, R1
    98		MOVW	$0, R2
    99		MOVW	$0, R3
   100		MOVW	$SYS_bsdthread_terminate, R16
   101		SVC	$0x80
   102		MOVD	$1234, R0
   103		MOVD	$1003, R1
   104		MOVD	R0, (R1)	// fail hard
   105	
   106	// func exitThread(wait *uint32)
   107	TEXT runtime·exitThread(SB),NOSPLIT,$0-8
   108		MOVD	wait+0(FP), R0
   109		// We're done using the stack.
   110		MOVW	$0, R1
   111		STLRW	R1, (R0)
   112		JMP	exit1<>(SB)
   113	
   114	TEXT runtime·raise(SB),NOSPLIT,$0
   115		// Ideally we'd send the signal to the current thread,
   116		// not the whole process, but that's too hard on OS X.
   117		JMP	runtime·raiseproc(SB)
   118	
   119	TEXT runtime·raiseproc(SB),NOSPLIT,$0
   120		MOVW	$SYS_getpid, R16
   121		SVC	$0x80
   122		// arg 1 pid already in R0 from getpid
   123		MOVW	sig+0(FP), R1	// arg 2 - signal
   124		MOVW	$1, R2	// arg 3 - posix
   125		MOVW	$SYS_kill, R16
   126		SVC	$0x80
   127		RET
   128	
   129	TEXT runtime·mmap(SB),NOSPLIT,$0
   130		MOVD	addr+0(FP), R0
   131		MOVD	n+8(FP), R1
   132		MOVW	prot+16(FP), R2
   133		MOVW	flags+20(FP), R3
   134		MOVW	fd+24(FP), R4
   135		MOVW	off+28(FP), R5
   136		MOVW	$SYS_mmap, R16
   137		SVC	$0x80
   138		BCC	ok
   139		MOVD	$0, p+32(FP)
   140		MOVD	R0, err+40(FP)
   141		RET
   142	ok:
   143		MOVD	R0, p+32(FP)
   144		MOVD	$0, err+40(FP)
   145		RET
   146	
   147	TEXT runtime·munmap(SB),NOSPLIT,$0
   148		MOVD	addr+0(FP), R0
   149		MOVD	n+8(FP), R1
   150		MOVW	$SYS_munmap, R16
   151		SVC	$0x80
   152		BCC	2(PC)
   153		BL	notok<>(SB)
   154		RET
   155	
   156	TEXT runtime·madvise(SB),NOSPLIT,$0
   157		MOVD	addr+0(FP), R0
   158		MOVD	n+8(FP), R1
   159		MOVW	flags+16(FP), R2
   160		MOVW	$SYS_madvise, R16
   161		SVC	$0x80
   162		BCC	2(PC)
   163		BL	notok<>(SB)
   164		RET
   165	
   166	TEXT runtime·setitimer(SB),NOSPLIT,$0
   167		MOVW	mode+0(FP), R0
   168		MOVD	new+8(FP), R1
   169		MOVD	old+16(FP), R2
   170		MOVW	$SYS_setitimer, R16
   171		SVC	$0x80
   172		RET
   173	
   174	TEXT runtime·walltime(SB),NOSPLIT,$40-12
   175		MOVD	RSP, R0	// timeval
   176		MOVD	R0, R9	// this is how dyld calls gettimeofday
   177		MOVW	$0, R1	// zone
   178		MOVD	$0, R2	// see issue 16570
   179		MOVW	$SYS_gettimeofday, R16
   180		SVC	$0x80	// Note: x0 is tv_sec, w1 is tv_usec
   181		CMP	$0, R0
   182		BNE	inreg
   183		MOVD	0(RSP), R0
   184		MOVW	8(RSP), R1
   185	inreg:
   186		MOVD	R0, sec+0(FP)
   187		MOVW	$1000, R3
   188		MUL	R3, R1
   189		MOVW	R1, nsec+8(FP)
   190		RET
   191	
   192	TEXT runtime·nanotime(SB),NOSPLIT,$40
   193		MOVD	RSP, R0	// timeval
   194		MOVD	R0, R9	// this is how dyld calls gettimeofday
   195		MOVW	$0, R1	// zone
   196		MOVD	$0, R2	// see issue 16570
   197		MOVW	$SYS_gettimeofday, R16
   198		SVC	$0x80	// Note: x0 is tv_sec, w1 is tv_usec
   199		CMP	$0, R0
   200		BNE	inreg
   201		MOVD	0(RSP), R0
   202		MOVW	8(RSP), R1
   203	inreg:
   204		MOVW	$1000000000, R3
   205		MUL	R3, R0
   206		MOVW	$1000, R3
   207		MUL	R3, R1
   208		ADD	R1, R0
   209	
   210		MOVD	R0, ret+0(FP)
   211		RET
   212	
   213	TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
   214		MOVW	sig+8(FP), R0
   215		MOVD	info+16(FP), R1
   216		MOVD	ctx+24(FP), R2
   217		MOVD	fn+0(FP), R11
   218		BL	(R11)
   219		RET
   220	
   221	// Sigtramp's job is to call the actual signal handler.
   222	// It is called with the following arguments on the stack:
   223	//	LR	"return address" - ignored
   224	//	R0	actual handler
   225	//	R1	siginfo style - ignored
   226	//	R2	signal number
   227	//	R3	siginfo
   228	//	R4	context
   229	TEXT runtime·sigtramp(SB),NOSPLIT,$0
   230		// this might be called in external code context,
   231		// where g is not set.
   232		// first save R0, because runtime·load_g will clobber it
   233		MOVD.W	R0, -16(RSP)	// note: stack must be 16-byte aligned
   234		MOVB	runtime·iscgo(SB), R0
   235		CMP	$0, R0
   236		BEQ	2(PC)
   237		BL	runtime·load_g(SB)
   238	
   239		CMP	$0, g
   240		BNE	cont
   241		// fake function call stack frame for badsignal
   242		// we only need to pass R2 (signal number), but
   243		// badsignal will expect R2 at 8(RSP), so we also
   244		// push R1 onto stack. turns out we do need R1
   245		// to do sigreturn.
   246		MOVD.W	R1, -16(RSP)
   247		MOVD	R2, 8(RSP)
   248		MOVD	R4, 24(RSP)	// save ucontext, badsignal might clobber R4
   249		MOVD	$runtime·badsignal(SB), R26
   250		BL	(R26)
   251		MOVD	0(RSP), R1	// saved infostype
   252		MOVD	24(RSP), R0	// the ucontext
   253		ADD	$(16+16), RSP
   254		B	ret
   255	
   256	cont:
   257		// Restore R0
   258		MOVD.P	16(RSP), R0
   259	
   260		// NOTE: some Darwin/ARM kernels always use the main stack to run the
   261		// signal handler. We need to switch to gsignal ourselves.
   262		MOVD	g_m(g), R11
   263		MOVD	m_gsignal(R11), R5
   264		MOVD	(g_stack+stack_hi)(R5), R6
   265		SUB	$64, R6
   266	
   267		// copy arguments for call to sighandler
   268		MOVD	R2, 8(R6)	// signal num
   269		MOVD	R3, 16(R6)	// signal info
   270		MOVD	R4, 24(R6)	// context
   271		MOVD	g, 32(R6)	// old_g
   272	
   273		// Backup ucontext and infostyle
   274		MOVD	R4, 40(R6)
   275		MOVD	R1, 48(R6)
   276	
   277		// switch stack and g
   278		MOVD	R6, RSP	// sigtramp is not re-entrant, so no need to back up RSP.
   279		MOVD	R5, g
   280	
   281		BL	(R0)
   282	
   283		// call sigreturn
   284		MOVD	40(RSP), R0	// saved ucontext
   285		MOVD	48(RSP), R1	// saved infostyle
   286	ret:
   287		MOVW	$SYS_sigreturn, R16 // sigreturn(ucontext, infostyle)
   288		SVC	$0x80
   289	
   290		// if sigreturn fails, we can do nothing but exit
   291		B	runtime·exit(SB)
   292	
   293	TEXT runtime·sigprocmask(SB),NOSPLIT,$0
   294		MOVW	how+0(FP), R0
   295		MOVD	new+8(FP), R1
   296		MOVD	old+16(FP), R2
   297		MOVW	$SYS_pthread_sigmask, R16
   298		SVC	$0x80
   299		BCC	2(PC)
   300		BL	notok<>(SB)
   301		RET
   302	
   303	TEXT runtime·sigaction(SB),NOSPLIT,$0
   304		MOVW	mode+0(FP), R0
   305		MOVD	new+8(FP), R1
   306		MOVD	old+16(FP), R2
   307		MOVW	$SYS_sigaction, R16
   308		SVC	$0x80
   309		BCC	2(PC)
   310		BL	notok<>(SB)
   311		RET
   312	
   313	TEXT runtime·usleep(SB),NOSPLIT,$24
   314		MOVW	usec+0(FP), R0
   315		MOVW	R0, R1
   316		MOVW	$1000000, R2
   317		UDIV	R2, R0
   318		MUL	R0, R2
   319		SUB	R2, R1
   320		MOVD	R0, 0(RSP)
   321		MOVW	R1, 8(RSP)
   322	
   323		// select(0, 0, 0, 0, &tv)
   324		MOVW	$0, R0
   325		MOVW	$0, R1
   326		MOVW	$0, R2
   327		MOVW	$0, R3
   328		MOVD	RSP, R4
   329		MOVW	$SYS_select, R16
   330		SVC	$0x80
   331		RET
   332	
   333	TEXT runtime·sysctl(SB),NOSPLIT,$0
   334		MOVD	mib+0(FP), R0
   335		MOVW	miblen+8(FP), R1
   336		MOVD	out+16(FP), R2
   337		MOVD	size+24(FP), R3
   338		MOVD	dst+32(FP), R4
   339		MOVD	ndst+40(FP), R5
   340		MOVW	$SYS___sysctl, R16
   341		SVC	$0x80
   342		BCC	ok
   343		NEG	R0, R0
   344		MOVW	R0, ret+48(FP)
   345		RET
   346	ok:
   347		MOVW	$0, R0
   348		MOVW	R0, ret+48(FP)
   349		RET
   350	
   351	// Thread related functions
   352	// Note: On darwin/arm64, it is no longer possible to use bsdthread_register
   353	// as the libc is always linked in. The runtime must use runtime/cgo to
   354	// create threads, so all thread related functions will just exit with a
   355	// unique status.
   356	// void bsdthread_create(void *stk, M *m, G *g, void (*fn)(void))
   357	TEXT runtime·bsdthread_create(SB),NOSPLIT,$0
   358		MOVD	$44, R0
   359		MOVW	$SYS_exit, R16
   360		SVC	$0x80
   361		RET
   362	
   363	// The thread that bsdthread_create creates starts executing here,
   364	// because we registered this function using bsdthread_register
   365	// at startup.
   366	//	R0 = "pthread"
   367	//	R1 = mach thread port
   368	//	R2 = "func" (= fn)
   369	//	R3 = "arg" (= m)
   370	//	R4 = stack
   371	//	R5 = flags (= 0)
   372	TEXT runtime·bsdthread_start(SB),NOSPLIT,$0
   373		MOVD	$45, R0
   374		MOVW	$SYS_exit, R16
   375		SVC	$0x80
   376		RET
   377	
   378	// int32 bsdthread_register(void)
   379	// registers callbacks for threadstart (see bsdthread_create above
   380	// and wqthread and pthsize (not used).  returns 0 on success.
   381	TEXT runtime·bsdthread_register(SB),NOSPLIT,$0
   382		MOVD	$46, R0
   383		MOVW	$SYS_exit, R16
   384		SVC	$0x80
   385		RET
   386	
   387	// uint32 mach_msg_trap(void*, uint32, uint32, uint32, uint32, uint32, uint32)
   388	TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0
   389		MOVD	h+0(FP), R0
   390		MOVW	op+8(FP), R1
   391		MOVW	send_size+12(FP), R2
   392		MOVW	rcv_size+16(FP), R3
   393		MOVW	rcv_name+20(FP), R4
   394		MOVW	timeout+24(FP), R5
   395		MOVW	notify+28(FP), R6
   396		MOVN	$30, R16
   397		SVC	$0x80
   398		MOVW	R0, ret+32(FP)
   399		RET
   400	
   401	TEXT runtime·mach_task_self(SB),NOSPLIT,$0
   402		MOVN	$27, R16 // task_self_trap
   403		SVC	$0x80
   404		MOVW	R0, ret+0(FP)
   405		RET
   406	
   407	TEXT runtime·mach_thread_self(SB),NOSPLIT,$0
   408		MOVN	$26, R16 // thread_self_trap
   409		SVC	$0x80
   410		MOVW	R0, ret+0(FP)
   411		RET
   412	
   413	TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
   414		MOVN	$25, R16	// mach_reply_port
   415		SVC	$0x80
   416		MOVW	R0, ret+0(FP)
   417		RET
   418	
   419	// Mach provides trap versions of the semaphore ops,
   420	// instead of requiring the use of RPC.
   421	
   422	// uint32 mach_semaphore_wait(uint32)
   423	TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
   424		MOVW	sema+0(FP), R0
   425		MOVN	$35, R16	// semaphore_wait_trap
   426		SVC	$0x80
   427		MOVW	R0, ret+8(FP)
   428		RET
   429	
   430	// uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
   431	TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
   432		MOVW	sema+0(FP), R0
   433		MOVW	sec+4(FP), R1
   434		MOVW	nsec+8(FP), R2
   435		MOVN	$37, R16	// semaphore_timedwait_trap
   436		SVC	$0x80
   437		MOVW	R0, ret+16(FP)
   438		RET
   439	
   440	// uint32 mach_semaphore_signal(uint32)
   441	TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
   442		MOVW	sema+0(FP), R0
   443		MOVN	$32, R16	// semaphore_signal_trap
   444		SVC	$0x80
   445		MOVW	R0, ret+8(FP)
   446		RET
   447	
   448	// uint32 mach_semaphore_signal_all(uint32)
   449	TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
   450		MOVW	sema+0(FP), R0
   451		MOVN	$33, R16	// semaphore_signal_all_trap
   452		SVC	$0x80
   453		MOVW	R0, ret+8(FP)
   454		RET
   455	
   456	// int32 runtime·kqueue(void)
   457	TEXT runtime·kqueue(SB),NOSPLIT,$0
   458		MOVW	$SYS_kqueue, R16
   459		SVC	$0x80
   460		BCC	2(PC)
   461		NEG	R0, R0
   462		MOVW	R0, ret+0(FP)
   463		RET
   464	
   465	// int32 runtime·kevent(int kq, Kevent *ch, int nch, Kevent *ev, int nev, Timespec *ts)
   466	TEXT runtime·kevent(SB),NOSPLIT,$0
   467		MOVW	kq+0(FP), R0
   468		MOVD	ch+8(FP), R1
   469		MOVW	nch+16(FP), R2
   470		MOVD	ev+24(FP), R3
   471		MOVW	nev+32(FP), R4
   472		MOVD	ts+40(FP), R5
   473		MOVW	$SYS_kevent, R16
   474		SVC	$0x80
   475		BCC	2(PC)
   476		NEG	R0, R0
   477		MOVW	R0, ret+48(FP)
   478		RET
   479	
   480	// int32 runtime·closeonexec(int32 fd)
   481	TEXT runtime·closeonexec(SB),NOSPLIT,$0
   482		MOVW	fd+0(FP), R0
   483		MOVW	$2, R1	// F_SETFD
   484		MOVW	$1, R2	// FD_CLOEXEC
   485		MOVW	$SYS_fcntl, R16
   486		SVC	$0x80
   487		RET
   488	
   489	// sigaltstack on some darwin/arm version is buggy and will always
   490	// run the signal handler on the main stack, so our sigtramp has
   491	// to do the stack switch ourselves.
   492	TEXT runtime·sigaltstack(SB),NOSPLIT,$0
   493		RET

View as plain text