1// Copyright 2009 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//
6// System calls and other sys.stuff for arm, Linux
7//
8
9#include "go_asm.h"
10#include "go_tls.h"
11#include "textflag.h"
12
13#define CLOCK_REALTIME	0
14#define CLOCK_MONOTONIC	1
15
16// for EABI, as we don't support OABI
17#define SYS_BASE 0x0
18
19#define SYS_exit (SYS_BASE + 1)
20#define SYS_read (SYS_BASE + 3)
21#define SYS_write (SYS_BASE + 4)
22#define SYS_open (SYS_BASE + 5)
23#define SYS_close (SYS_BASE + 6)
24#define SYS_getpid (SYS_BASE + 20)
25#define SYS_kill (SYS_BASE + 37)
26#define SYS_pipe (SYS_BASE + 42)
27#define SYS_clone (SYS_BASE + 120)
28#define SYS_rt_sigreturn (SYS_BASE + 173)
29#define SYS_rt_sigaction (SYS_BASE + 174)
30#define SYS_rt_sigprocmask (SYS_BASE + 175)
31#define SYS_sigaltstack (SYS_BASE + 186)
32#define SYS_mmap2 (SYS_BASE + 192)
33#define SYS_futex (SYS_BASE + 240)
34#define SYS_exit_group (SYS_BASE + 248)
35#define SYS_munmap (SYS_BASE + 91)
36#define SYS_madvise (SYS_BASE + 220)
37#define SYS_setitimer (SYS_BASE + 104)
38#define SYS_mincore (SYS_BASE + 219)
39#define SYS_gettid (SYS_BASE + 224)
40#define SYS_tgkill (SYS_BASE + 268)
41#define SYS_sched_yield (SYS_BASE + 158)
42#define SYS_nanosleep (SYS_BASE + 162)
43#define SYS_sched_getaffinity (SYS_BASE + 242)
44#define SYS_clock_gettime (SYS_BASE + 263)
45#define SYS_epoll_create (SYS_BASE + 250)
46#define SYS_epoll_ctl (SYS_BASE + 251)
47#define SYS_epoll_wait (SYS_BASE + 252)
48#define SYS_epoll_create1 (SYS_BASE + 357)
49#define SYS_pipe2 (SYS_BASE + 359)
50#define SYS_fcntl (SYS_BASE + 55)
51#define SYS_access (SYS_BASE + 33)
52#define SYS_connect (SYS_BASE + 283)
53#define SYS_socket (SYS_BASE + 281)
54#define SYS_brk (SYS_BASE + 45)
55
56#define ARM_BASE (SYS_BASE + 0x0f0000)
57
58TEXT runtime·open(SB),NOSPLIT,$0
59	MOVW	name+0(FP), R0
60	MOVW	mode+4(FP), R1
61	MOVW	perm+8(FP), R2
62	MOVW	$SYS_open, R7
63	SWI	$0
64	MOVW	$0xfffff001, R1
65	CMP	R1, R0
66	MOVW.HI	$-1, R0
67	MOVW	R0, ret+12(FP)
68	RET
69
70TEXT runtime·closefd(SB),NOSPLIT,$0
71	MOVW	fd+0(FP), R0
72	MOVW	$SYS_close, R7
73	SWI	$0
74	MOVW	$0xfffff001, R1
75	CMP	R1, R0
76	MOVW.HI	$-1, R0
77	MOVW	R0, ret+4(FP)
78	RET
79
80TEXT runtime·write1(SB),NOSPLIT,$0
81	MOVW	fd+0(FP), R0
82	MOVW	p+4(FP), R1
83	MOVW	n+8(FP), R2
84	MOVW	$SYS_write, R7
85	SWI	$0
86	MOVW	R0, ret+12(FP)
87	RET
88
89TEXT runtime·read(SB),NOSPLIT,$0
90	MOVW	fd+0(FP), R0
91	MOVW	p+4(FP), R1
92	MOVW	n+8(FP), R2
93	MOVW	$SYS_read, R7
94	SWI	$0
95	MOVW	R0, ret+12(FP)
96	RET
97
98// func pipe() (r, w int32, errno int32)
99TEXT runtime·pipe(SB),NOSPLIT,$0-12
100	MOVW	$r+0(FP), R0
101	MOVW	$SYS_pipe, R7
102	SWI	$0
103	MOVW	R0, errno+8(FP)
104	RET
105
106// func pipe2(flags int32) (r, w int32, errno int32)
107TEXT runtime·pipe2(SB),NOSPLIT,$0-16
108	MOVW	$r+4(FP), R0
109	MOVW	flags+0(FP), R1
110	MOVW	$SYS_pipe2, R7
111	SWI	$0
112	MOVW	R0, errno+12(FP)
113	RET
114
115TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0
116	MOVW	code+0(FP), R0
117	MOVW	$SYS_exit_group, R7
118	SWI	$0
119	MOVW	$1234, R0
120	MOVW	$1002, R1
121	MOVW	R0, (R1)	// fail hard
122
123TEXT exit1<>(SB),NOSPLIT|NOFRAME,$0
124	MOVW	code+0(FP), R0
125	MOVW	$SYS_exit, R7
126	SWI	$0
127	MOVW	$1234, R0
128	MOVW	$1003, R1
129	MOVW	R0, (R1)	// fail hard
130
131// func exitThread(wait *uint32)
132TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-4
133	MOVW	wait+0(FP), R0
134	// We're done using the stack.
135	// Alas, there's no reliable way to make this write atomic
136	// without potentially using the stack. So it goes.
137	MOVW	$0, R1
138	MOVW	R1, (R0)
139	MOVW	$0, R0	// exit code
140	MOVW	$SYS_exit, R7
141	SWI	$0
142	MOVW	$1234, R0
143	MOVW	$1004, R1
144	MOVW	R0, (R1)	// fail hard
145	JMP	0(PC)
146
147TEXT runtime·gettid(SB),NOSPLIT,$0-4
148	MOVW	$SYS_gettid, R7
149	SWI	$0
150	MOVW	R0, ret+0(FP)
151	RET
152
153TEXT	runtime·raise(SB),NOSPLIT|NOFRAME,$0
154	MOVW	$SYS_getpid, R7
155	SWI	$0
156	MOVW	R0, R4
157	MOVW	$SYS_gettid, R7
158	SWI	$0
159	MOVW	R0, R1	// arg 2 tid
160	MOVW	R4, R0	// arg 1 pid
161	MOVW	sig+0(FP), R2	// arg 3
162	MOVW	$SYS_tgkill, R7
163	SWI	$0
164	RET
165
166TEXT	runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
167	MOVW	$SYS_getpid, R7
168	SWI	$0
169	// arg 1 tid already in R0 from getpid
170	MOVW	sig+0(FP), R1	// arg 2 - signal
171	MOVW	$SYS_kill, R7
172	SWI	$0
173	RET
174
175TEXT ·getpid(SB),NOSPLIT,$0-4
176	MOVW	$SYS_getpid, R7
177	SWI	$0
178	MOVW	R0, ret+0(FP)
179	RET
180
181TEXT ·tgkill(SB),NOSPLIT,$0-12
182	MOVW	tgid+0(FP), R0
183	MOVW	tid+4(FP), R1
184	MOVW	sig+8(FP), R2
185	MOVW	$SYS_tgkill, R7
186	SWI	$0
187	RET
188
189TEXT runtime·mmap(SB),NOSPLIT,$0
190	MOVW	addr+0(FP), R0
191	MOVW	n+4(FP), R1
192	MOVW	prot+8(FP), R2
193	MOVW	flags+12(FP), R3
194	MOVW	fd+16(FP), R4
195	MOVW	off+20(FP), R5
196	MOVW	$SYS_mmap2, R7
197	SWI	$0
198	MOVW	$0xfffff001, R6
199	CMP		R6, R0
200	MOVW	$0, R1
201	RSB.HI	$0, R0
202	MOVW.HI	R0, R1		// if error, put in R1
203	MOVW.HI	$0, R0
204	MOVW	R0, p+24(FP)
205	MOVW	R1, err+28(FP)
206	RET
207
208TEXT runtime·munmap(SB),NOSPLIT,$0
209	MOVW	addr+0(FP), R0
210	MOVW	n+4(FP), R1
211	MOVW	$SYS_munmap, R7
212	SWI	$0
213	MOVW	$0xfffff001, R6
214	CMP 	R6, R0
215	MOVW.HI	$0, R8  // crash on syscall failure
216	MOVW.HI	R8, (R8)
217	RET
218
219TEXT runtime·madvise(SB),NOSPLIT,$0
220	MOVW	addr+0(FP), R0
221	MOVW	n+4(FP), R1
222	MOVW	flags+8(FP), R2
223	MOVW	$SYS_madvise, R7
224	SWI	$0
225	MOVW	R0, ret+12(FP)
226	RET
227
228TEXT runtime·setitimer(SB),NOSPLIT,$0
229	MOVW	mode+0(FP), R0
230	MOVW	new+4(FP), R1
231	MOVW	old+8(FP), R2
232	MOVW	$SYS_setitimer, R7
233	SWI	$0
234	RET
235
236TEXT runtime·mincore(SB),NOSPLIT,$0
237	MOVW	addr+0(FP), R0
238	MOVW	n+4(FP), R1
239	MOVW	dst+8(FP), R2
240	MOVW	$SYS_mincore, R7
241	SWI	$0
242	MOVW	R0, ret+12(FP)
243	RET
244
245TEXT runtime·walltime1(SB),NOSPLIT,$0-12
246	// We don't know how much stack space the VDSO code will need,
247	// so switch to g0.
248
249	// Save old SP. Use R13 instead of SP to avoid linker rewriting the offsets.
250	MOVW	R13, R4	// R4 is unchanged by C code.
251
252	MOVW	g_m(g), R5 // R5 is unchanged by C code.
253
254	// Set vdsoPC and vdsoSP for SIGPROF traceback.
255	MOVW	LR, m_vdsoPC(R5)
256	MOVW	R13, m_vdsoSP(R5)
257
258	MOVW	m_curg(R5), R0
259
260	CMP	g, R0		// Only switch if on curg.
261	B.NE	noswitch
262
263	MOVW	m_g0(R5), R0
264	MOVW	(g_sched+gobuf_sp)(R0), R13	 // Set SP to g0 stack
265
266noswitch:
267	SUB	$24, R13	// Space for results
268	BIC	$0x7, R13	// Align for C code
269
270	MOVW	$CLOCK_REALTIME, R0
271	MOVW	$8(R13), R1	// timespec
272	MOVW	runtime·vdsoClockgettimeSym(SB), R2
273	CMP	$0, R2
274	B.EQ	fallback
275
276	// Store g on gsignal's stack, so if we receive a signal
277	// during VDSO code we can find the g.
278	// If we don't have a signal stack, we won't receive signal,
279	// so don't bother saving g.
280	// When using cgo, we already saved g on TLS, also don't save
281	// g here.
282	// Also don't save g if we are already on the signal stack.
283	// We won't get a nested signal.
284	MOVB	runtime·iscgo(SB), R6
285	CMP	$0, R6
286	BNE	nosaveg
287	MOVW	m_gsignal(R5), R6          // g.m.gsignal
288	CMP	$0, R6
289	BEQ	nosaveg
290	CMP	g, R6
291	BEQ	nosaveg
292	MOVW	(g_stack+stack_lo)(R6), R6 // g.m.gsignal.stack.lo
293	MOVW	g, (R6)
294
295	BL	(R2)
296
297	MOVW	$0, R1
298	MOVW	R1, (R6) // clear g slot, R6 is unchanged by C code
299
300	JMP	finish
301
302nosaveg:
303	BL	(R2)
304	JMP	finish
305
306fallback:
307	MOVW	$SYS_clock_gettime, R7
308	SWI	$0
309
310finish:
311	MOVW	8(R13), R0  // sec
312	MOVW	12(R13), R2  // nsec
313
314	MOVW	R4, R13		// Restore real SP
315	MOVW	$0, R1
316	MOVW	R1, m_vdsoSP(R5)
317
318	MOVW	R0, sec_lo+0(FP)
319	MOVW	R1, sec_hi+4(FP)
320	MOVW	R2, nsec+8(FP)
321	RET
322
323// int64 nanotime1(void)
324TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
325	// Switch to g0 stack. See comment above in runtime·walltime.
326
327	// Save old SP. Use R13 instead of SP to avoid linker rewriting the offsets.
328	MOVW	R13, R4	// R4 is unchanged by C code.
329
330	MOVW	g_m(g), R5 // R5 is unchanged by C code.
331
332	// Set vdsoPC and vdsoSP for SIGPROF traceback.
333	MOVW	LR, m_vdsoPC(R5)
334	MOVW	R13, m_vdsoSP(R5)
335
336	MOVW	m_curg(R5), R0
337
338	CMP	g, R0		// Only switch if on curg.
339	B.NE	noswitch
340
341	MOVW	m_g0(R5), R0
342	MOVW	(g_sched+gobuf_sp)(R0), R13	// Set SP to g0 stack
343
344noswitch:
345	SUB	$24, R13	// Space for results
346	BIC	$0x7, R13	// Align for C code
347
348	MOVW	$CLOCK_MONOTONIC, R0
349	MOVW	$8(R13), R1	// timespec
350	MOVW	runtime·vdsoClockgettimeSym(SB), R2
351	CMP	$0, R2
352	B.EQ	fallback
353
354	// Store g on gsignal's stack, so if we receive a signal
355	// during VDSO code we can find the g.
356	// If we don't have a signal stack, we won't receive signal,
357	// so don't bother saving g.
358	// When using cgo, we already saved g on TLS, also don't save
359	// g here.
360	// Also don't save g if we are already on the signal stack.
361	// We won't get a nested signal.
362	MOVB	runtime·iscgo(SB), R6
363	CMP	$0, R6
364	BNE	nosaveg
365	MOVW	m_gsignal(R5), R6          // g.m.gsignal
366	CMP	$0, R6
367	BEQ	nosaveg
368	CMP	g, R6
369	BEQ	nosaveg
370	MOVW	(g_stack+stack_lo)(R6), R6 // g.m.gsignal.stack.lo
371	MOVW	g, (R6)
372
373	BL	(R2)
374
375	MOVW	$0, R1
376	MOVW	R1, (R6) // clear g slot, R6 is unchanged by C code
377
378	JMP	finish
379
380nosaveg:
381	BL	(R2)
382	JMP	finish
383
384fallback:
385	MOVW	$SYS_clock_gettime, R7
386	SWI	$0
387
388finish:
389	MOVW	8(R13), R0	// sec
390	MOVW	12(R13), R2	// nsec
391
392	MOVW	R4, R13		// Restore real SP
393	MOVW	$0, R4
394	MOVW	R4, m_vdsoSP(R5)
395
396	MOVW	$1000000000, R3
397	MULLU	R0, R3, (R1, R0)
398	ADD.S	R2, R0
399	ADC	R4, R1
400
401	MOVW	R0, ret_lo+0(FP)
402	MOVW	R1, ret_hi+4(FP)
403	RET
404
405// int32 futex(int32 *uaddr, int32 op, int32 val,
406//	struct timespec *timeout, int32 *uaddr2, int32 val2);
407TEXT runtime·futex(SB),NOSPLIT,$0
408	MOVW    addr+0(FP), R0
409	MOVW    op+4(FP), R1
410	MOVW    val+8(FP), R2
411	MOVW    ts+12(FP), R3
412	MOVW    addr2+16(FP), R4
413	MOVW    val3+20(FP), R5
414	MOVW	$SYS_futex, R7
415	SWI	$0
416	MOVW	R0, ret+24(FP)
417	RET
418
419// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
420TEXT runtime·clone(SB),NOSPLIT,$0
421	MOVW	flags+0(FP), R0
422	MOVW	stk+4(FP), R1
423	MOVW	$0, R2	// parent tid ptr
424	MOVW	$0, R3	// tls_val
425	MOVW	$0, R4	// child tid ptr
426	MOVW	$0, R5
427
428	// Copy mp, gp, fn off parent stack for use by child.
429	MOVW	$-16(R1), R1
430	MOVW	mp+8(FP), R6
431	MOVW	R6, 0(R1)
432	MOVW	gp+12(FP), R6
433	MOVW	R6, 4(R1)
434	MOVW	fn+16(FP), R6
435	MOVW	R6, 8(R1)
436	MOVW	$1234, R6
437	MOVW	R6, 12(R1)
438
439	MOVW	$SYS_clone, R7
440	SWI	$0
441
442	// In parent, return.
443	CMP	$0, R0
444	BEQ	3(PC)
445	MOVW	R0, ret+20(FP)
446	RET
447
448	// Paranoia: check that SP is as we expect. Use R13 to avoid linker 'fixup'
449	NOP	R13	// tell vet SP/R13 changed - stop checking offsets
450	MOVW	12(R13), R0
451	MOVW	$1234, R1
452	CMP	R0, R1
453	BEQ	2(PC)
454	BL	runtime·abort(SB)
455
456	MOVW	0(R13), R8    // m
457	MOVW	4(R13), R0    // g
458
459	CMP	$0, R8
460	BEQ	nog
461	CMP	$0, R0
462	BEQ	nog
463
464	MOVW	R0, g
465	MOVW	R8, g_m(g)
466
467	// paranoia; check they are not nil
468	MOVW	0(R8), R0
469	MOVW	0(g), R0
470
471	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
472
473	// Initialize m->procid to Linux tid
474	MOVW	$SYS_gettid, R7
475	SWI	$0
476	MOVW	g_m(g), R8
477	MOVW	R0, m_procid(R8)
478
479nog:
480	// Call fn
481	MOVW	8(R13), R0
482	MOVW	$16(R13), R13
483	BL	(R0)
484
485	// It shouldn't return. If it does, exit that thread.
486	SUB	$16, R13 // restore the stack pointer to avoid memory corruption
487	MOVW	$0, R0
488	MOVW	R0, 4(R13)
489	BL	exit1<>(SB)
490
491	MOVW	$1234, R0
492	MOVW	$1005, R1
493	MOVW	R0, (R1)
494
495TEXT runtime·sigaltstack(SB),NOSPLIT,$0
496	MOVW	new+0(FP), R0
497	MOVW	old+4(FP), R1
498	MOVW	$SYS_sigaltstack, R7
499	SWI	$0
500	MOVW	$0xfffff001, R6
501	CMP 	R6, R0
502	MOVW.HI	$0, R8  // crash on syscall failure
503	MOVW.HI	R8, (R8)
504	RET
505
506TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
507	MOVW	sig+4(FP), R0
508	MOVW	info+8(FP), R1
509	MOVW	ctx+12(FP), R2
510	MOVW	fn+0(FP), R11
511	MOVW	R13, R4
512	SUB	$24, R13
513	BIC	$0x7, R13 // alignment for ELF ABI
514	BL	(R11)
515	MOVW	R4, R13
516	RET
517
518TEXT runtime·sigtramp(SB),NOSPLIT,$0
519	// Reserve space for callee-save registers and arguments.
520	MOVM.DB.W [R4-R11], (R13)
521	SUB	$16, R13
522
523	// this might be called in external code context,
524	// where g is not set.
525	// first save R0, because runtime·load_g will clobber it
526	MOVW	R0, 4(R13)
527	MOVB	runtime·iscgo(SB), R0
528	CMP 	$0, R0
529	BL.NE	runtime·load_g(SB)
530
531	MOVW	R1, 8(R13)
532	MOVW	R2, 12(R13)
533	MOVW  	$runtime·sigtrampgo(SB), R11
534	BL	(R11)
535
536	// Restore callee-save registers.
537	ADD	$16, R13
538	MOVM.IA.W (R13), [R4-R11]
539
540	RET
541
542TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
543	MOVW  	$runtime·sigtramp(SB), R11
544	B	(R11)
545
546TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0
547	MOVW	how+0(FP), R0
548	MOVW	new+4(FP), R1
549	MOVW	old+8(FP), R2
550	MOVW	size+12(FP), R3
551	MOVW	$SYS_rt_sigprocmask, R7
552	SWI	$0
553	RET
554
555TEXT runtime·rt_sigaction(SB),NOSPLIT,$0
556	MOVW	sig+0(FP), R0
557	MOVW	new+4(FP), R1
558	MOVW	old+8(FP), R2
559	MOVW	size+12(FP), R3
560	MOVW	$SYS_rt_sigaction, R7
561	SWI	$0
562	MOVW	R0, ret+16(FP)
563	RET
564
565TEXT runtime·usleep(SB),NOSPLIT,$12
566	MOVW	usec+0(FP), R0
567	CALL	runtime·usplitR0(SB)
568	MOVW	R0, 4(R13)
569	MOVW	$1000, R0	// usec to nsec
570	MUL	R0, R1
571	MOVW	R1, 8(R13)
572	MOVW	$4(R13), R0
573	MOVW	$0, R1
574	MOVW	$SYS_nanosleep, R7
575	SWI	$0
576	RET
577
578// As for cas, memory barriers are complicated on ARM, but the kernel
579// provides a user helper. ARMv5 does not support SMP and has no
580// memory barrier instruction at all. ARMv6 added SMP support and has
581// a memory barrier, but it requires writing to a coprocessor
582// register. ARMv7 introduced the DMB instruction, but it's expensive
583// even on single-core devices. The kernel helper takes care of all of
584// this for us.
585
586TEXT kernelPublicationBarrier<>(SB),NOSPLIT,$0
587	// void __kuser_memory_barrier(void);
588	MOVW	$0xffff0fa0, R11
589	CALL	(R11)
590	RET
591
592TEXT ·publicationBarrier(SB),NOSPLIT,$0
593	MOVB	·goarm(SB), R11
594	CMP	$7, R11
595	BLT	2(PC)
596	JMP	·armPublicationBarrier(SB)
597	JMP	kernelPublicationBarrier<>(SB) // extra layer so this function is leaf and no SP adjustment on GOARM=7
598
599TEXT runtime·osyield(SB),NOSPLIT,$0
600	MOVW	$SYS_sched_yield, R7
601	SWI	$0
602	RET
603
604TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
605	MOVW	pid+0(FP), R0
606	MOVW	len+4(FP), R1
607	MOVW	buf+8(FP), R2
608	MOVW	$SYS_sched_getaffinity, R7
609	SWI	$0
610	MOVW	R0, ret+12(FP)
611	RET
612
613// int32 runtime·epollcreate(int32 size)
614TEXT runtime·epollcreate(SB),NOSPLIT,$0
615	MOVW	size+0(FP), R0
616	MOVW	$SYS_epoll_create, R7
617	SWI	$0
618	MOVW	R0, ret+4(FP)
619	RET
620
621// int32 runtime·epollcreate1(int32 flags)
622TEXT runtime·epollcreate1(SB),NOSPLIT,$0
623	MOVW	flags+0(FP), R0
624	MOVW	$SYS_epoll_create1, R7
625	SWI	$0
626	MOVW	R0, ret+4(FP)
627	RET
628
629// func epollctl(epfd, op, fd int32, ev *epollEvent) int
630TEXT runtime·epollctl(SB),NOSPLIT,$0
631	MOVW	epfd+0(FP), R0
632	MOVW	op+4(FP), R1
633	MOVW	fd+8(FP), R2
634	MOVW	ev+12(FP), R3
635	MOVW	$SYS_epoll_ctl, R7
636	SWI	$0
637	MOVW	R0, ret+16(FP)
638	RET
639
640// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout)
641TEXT runtime·epollwait(SB),NOSPLIT,$0
642	MOVW	epfd+0(FP), R0
643	MOVW	ev+4(FP), R1
644	MOVW	nev+8(FP), R2
645	MOVW	timeout+12(FP), R3
646	MOVW	$SYS_epoll_wait, R7
647	SWI	$0
648	MOVW	R0, ret+16(FP)
649	RET
650
651// void runtime·closeonexec(int32 fd)
652TEXT runtime·closeonexec(SB),NOSPLIT,$0
653	MOVW	fd+0(FP), R0	// fd
654	MOVW	$2, R1	// F_SETFD
655	MOVW	$1, R2	// FD_CLOEXEC
656	MOVW	$SYS_fcntl, R7
657	SWI	$0
658	RET
659
660// func runtime·setNonblock(fd int32)
661TEXT runtime·setNonblock(SB),NOSPLIT,$0-4
662	MOVW	fd+0(FP), R0	// fd
663	MOVW	$3, R1	// F_GETFL
664	MOVW	$0, R2
665	MOVW	$SYS_fcntl, R7
666	SWI	$0
667	ORR	$0x800, R0, R2	// O_NONBLOCK
668	MOVW	fd+0(FP), R0	// fd
669	MOVW	$4, R1	// F_SETFL
670	MOVW	$SYS_fcntl, R7
671	SWI	$0
672	RET
673
674// b __kuser_get_tls @ 0xffff0fe0
675TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0
676	MOVW	$0xffff0fe0, R0
677	B	(R0)
678
679TEXT runtime·access(SB),NOSPLIT,$0
680	MOVW	name+0(FP), R0
681	MOVW	mode+4(FP), R1
682	MOVW	$SYS_access, R7
683	SWI	$0
684	MOVW	R0, ret+8(FP)
685	RET
686
687TEXT runtime·connect(SB),NOSPLIT,$0
688	MOVW	fd+0(FP), R0
689	MOVW	addr+4(FP), R1
690	MOVW	len+8(FP), R2
691	MOVW	$SYS_connect, R7
692	SWI	$0
693	MOVW	R0, ret+12(FP)
694	RET
695
696TEXT runtime·socket(SB),NOSPLIT,$0
697	MOVW	domain+0(FP), R0
698	MOVW	typ+4(FP), R1
699	MOVW	prot+8(FP), R2
700	MOVW	$SYS_socket, R7
701	SWI	$0
702	MOVW	R0, ret+12(FP)
703	RET
704
705// func sbrk0() uintptr
706TEXT runtime·sbrk0(SB),NOSPLIT,$0-4
707	// Implemented as brk(NULL).
708	MOVW	$0, R0
709	MOVW	$SYS_brk, R7
710	SWI	$0
711	MOVW	R0, ret+0(FP)
712	RET
713
714TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
715	RET
716