Text file src/runtime/sys_linux_loong64.s

     1  // Copyright 2022 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 loong64, Linux
     7  //
     8  
     9  #include "go_asm.h"
    10  #include "go_tls.h"
    11  #include "textflag.h"
    12  
    13  #define AT_FDCWD -100
    14  
    15  #define SYS_exit		93
    16  #define SYS_read		63
    17  #define SYS_write		64
    18  #define SYS_close		57
    19  #define SYS_getpid		172
    20  #define SYS_kill		129
    21  #define SYS_fcntl		25
    22  #define SYS_mmap		222
    23  #define SYS_munmap		215
    24  #define SYS_setitimer		103
    25  #define SYS_clone		220
    26  #define SYS_nanosleep		101
    27  #define SYS_sched_yield		124
    28  #define SYS_rt_sigreturn	139
    29  #define SYS_rt_sigaction	134
    30  #define SYS_rt_sigprocmask	135
    31  #define SYS_sigaltstack		132
    32  #define SYS_madvise		233
    33  #define SYS_mincore		232
    34  #define SYS_gettid		178
    35  #define SYS_futex		98
    36  #define SYS_sched_getaffinity	123
    37  #define SYS_exit_group		94
    38  #define SYS_epoll_ctl		21
    39  #define SYS_tgkill		131
    40  #define SYS_openat		56
    41  #define SYS_epoll_pwait		22
    42  #define SYS_clock_gettime	113
    43  #define SYS_epoll_create1	20
    44  #define SYS_brk			214
    45  #define SYS_pipe2		59
    46  #define SYS_timer_create	107
    47  #define SYS_timer_settime	110
    48  #define SYS_timer_delete	111
    49  
    50  TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
    51  	MOVW	code+0(FP), R4
    52  	MOVV	$SYS_exit_group, R11
    53  	SYSCALL
    54  	RET
    55  
    56  // func exitThread(wait *uint32)
    57  TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
    58  	MOVV	wait+0(FP), R19
    59  	// We're done using the stack.
    60  	MOVW	$0, R11
    61  	DBAR
    62  	MOVW	R11, (R19)
    63  	DBAR
    64  	MOVW	$0, R4	// exit code
    65  	MOVV	$SYS_exit, R11
    66  	SYSCALL
    67  	JMP	0(PC)
    68  
    69  TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
    70  	MOVW	$AT_FDCWD, R4 // AT_FDCWD, so this acts like open
    71  	MOVV	name+0(FP), R5
    72  	MOVW	mode+8(FP), R6
    73  	MOVW	perm+12(FP), R7
    74  	MOVV	$SYS_openat, R11
    75  	SYSCALL
    76  	MOVW	$-4096, R5
    77  	BGEU	R5, R4, 2(PC)
    78  	MOVW	$-1, R4
    79  	MOVW	R4, ret+16(FP)
    80  	RET
    81  
    82  TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
    83  	MOVW	fd+0(FP), R4
    84  	MOVV	$SYS_close, R11
    85  	SYSCALL
    86  	MOVW	$-4096, R5
    87  	BGEU	R5, R4, 2(PC)
    88  	MOVW	$-1, R4
    89  	MOVW	R4, ret+8(FP)
    90  	RET
    91  
    92  TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28
    93  	MOVV	fd+0(FP), R4
    94  	MOVV	p+8(FP), R5
    95  	MOVW	n+16(FP), R6
    96  	MOVV	$SYS_write, R11
    97  	SYSCALL
    98  	MOVW	R4, ret+24(FP)
    99  	RET
   100  
   101  TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
   102  	MOVW	fd+0(FP), R4
   103  	MOVV	p+8(FP), R5
   104  	MOVW	n+16(FP), R6
   105  	MOVV	$SYS_read, R11
   106  	SYSCALL
   107  	MOVW	R4, ret+24(FP)
   108  	RET
   109  
   110  // func pipe2(flags int32) (r, w int32, errno int32)
   111  TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
   112  	MOVV	$r+8(FP), R4
   113  	MOVW	flags+0(FP), R5
   114  	MOVV	$SYS_pipe2, R11
   115  	SYSCALL
   116  	MOVW	R4, errno+16(FP)
   117  	RET
   118  
   119  TEXT runtime·usleep(SB),NOSPLIT,$16-4
   120  	MOVWU	usec+0(FP), R6
   121  	MOVV	R6, R5
   122  	MOVW	$1000000, R4
   123  	DIVVU	R4, R6, R6
   124  	MOVV	R6, 8(R3)
   125  	MOVW	$1000, R4
   126  	MULVU	R6, R4, R4
   127  	SUBVU	R4, R5
   128  	MOVV	R5, 16(R3)
   129  
   130  	// nanosleep(&ts, 0)
   131  	ADDV	$8, R3, R4
   132  	MOVW	$0, R5
   133  	MOVV	$SYS_nanosleep, R11
   134  	SYSCALL
   135  	RET
   136  
   137  TEXT runtime·gettid(SB),NOSPLIT,$0-4
   138  	MOVV	$SYS_gettid, R11
   139  	SYSCALL
   140  	MOVW	R4, ret+0(FP)
   141  	RET
   142  
   143  TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
   144  	MOVV	$SYS_getpid, R11
   145  	SYSCALL
   146  	MOVW	R4, R23
   147  	MOVV	$SYS_gettid, R11
   148  	SYSCALL
   149  	MOVW	R4, R5	// arg 2 tid
   150  	MOVW	R23, R4	// arg 1 pid
   151  	MOVW	sig+0(FP), R6	// arg 3
   152  	MOVV	$SYS_tgkill, R11
   153  	SYSCALL
   154  	RET
   155  
   156  TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
   157  	MOVV	$SYS_getpid, R11
   158  	SYSCALL
   159  	//MOVW	R4, R4	// arg 1 pid
   160  	MOVW	sig+0(FP), R5	// arg 2
   161  	MOVV	$SYS_kill, R11
   162  	SYSCALL
   163  	RET
   164  
   165  TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8
   166  	MOVV	$SYS_getpid, R11
   167  	SYSCALL
   168  	MOVV	R4, ret+0(FP)
   169  	RET
   170  
   171  TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24
   172  	MOVV	tgid+0(FP), R4
   173  	MOVV	tid+8(FP), R5
   174  	MOVV	sig+16(FP), R6
   175  	MOVV	$SYS_tgkill, R11
   176  	SYSCALL
   177  	RET
   178  
   179  TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
   180  	MOVW	mode+0(FP), R4
   181  	MOVV	new+8(FP), R5
   182  	MOVV	old+16(FP), R6
   183  	MOVV	$SYS_setitimer, R11
   184  	SYSCALL
   185  	RET
   186  
   187  TEXT runtime·timer_create(SB),NOSPLIT,$0-28
   188  	MOVW	clockid+0(FP), R4
   189  	MOVV	sevp+8(FP), R5
   190  	MOVV	timerid+16(FP), R6
   191  	MOVV	$SYS_timer_create, R11
   192  	SYSCALL
   193  	MOVW	R4, ret+24(FP)
   194  	RET
   195  
   196  TEXT runtime·timer_settime(SB),NOSPLIT,$0-28
   197  	MOVW	timerid+0(FP), R4
   198  	MOVW	flags+4(FP), R5
   199  	MOVV	new+8(FP), R6
   200  	MOVV	old+16(FP), R7
   201  	MOVV	$SYS_timer_settime, R11
   202  	SYSCALL
   203  	MOVW	R4, ret+24(FP)
   204  	RET
   205  
   206  TEXT runtime·timer_delete(SB),NOSPLIT,$0-12
   207  	MOVW	timerid+0(FP), R4
   208  	MOVV	$SYS_timer_delete, R11
   209  	SYSCALL
   210  	MOVW	R4, ret+8(FP)
   211  	RET
   212  
   213  TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
   214  	MOVV	addr+0(FP), R4
   215  	MOVV	n+8(FP), R5
   216  	MOVV	dst+16(FP), R6
   217  	MOVV	$SYS_mincore, R11
   218  	SYSCALL
   219  	MOVW	R4, ret+24(FP)
   220  	RET
   221  
   222  // func walltime() (sec int64, nsec int32)
   223  TEXT runtime·walltime(SB),NOSPLIT,$16-12
   224  	MOVV	R3, R23	// R23 is unchanged by C code
   225  	MOVV	R3, R25
   226  
   227  	MOVV	g_m(g), R24	// R24 = m
   228  
   229  	// Set vdsoPC and vdsoSP for SIGPROF traceback.
   230  	// Save the old values on stack and restore them on exit,
   231  	// so this function is reentrant.
   232  	MOVV	m_vdsoPC(R24), R11
   233  	MOVV	m_vdsoSP(R24), R7
   234  	MOVV	R11, 8(R3)
   235  	MOVV	R7, 16(R3)
   236  
   237  	MOVV    $ret-8(FP), R11 // caller's SP
   238  	MOVV	R1, m_vdsoPC(R24)
   239  	MOVV	R11, m_vdsoSP(R24)
   240  
   241  	MOVV	m_curg(R24), R4
   242  	MOVV	g, R5
   243  	BNE	R4, R5, noswitch
   244  
   245  	MOVV	m_g0(R24), R4
   246  	MOVV	(g_sched+gobuf_sp)(R4), R25	// Set SP to g0 stack
   247  
   248  noswitch:
   249  	SUBV	$16, R25
   250  	AND	$~15, R25	// Align for C code
   251  	MOVV	R25, R3
   252  
   253  	MOVW	$0, R4 // CLOCK_REALTIME=0
   254  	MOVV	$0(R3), R5
   255  
   256  	MOVV	runtime·vdsoClockgettimeSym(SB), R20
   257  	BEQ	R20, fallback
   258  
   259  	JAL	(R20)
   260  
   261  finish:
   262  	MOVV	0(R3), R7	// sec
   263  	MOVV	8(R3), R5	// nsec
   264  
   265  	MOVV	R23, R3	// restore SP
   266  	// Restore vdsoPC, vdsoSP
   267  	// We don't worry about being signaled between the two stores.
   268  	// If we are not in a signal handler, we'll restore vdsoSP to 0,
   269  	// and no one will care about vdsoPC. If we are in a signal handler,
   270  	// we cannot receive another signal.
   271  	MOVV	16(R3), R25
   272  	MOVV	R25, m_vdsoSP(R24)
   273  	MOVV	8(R3), R25
   274  	MOVV	R25, m_vdsoPC(R24)
   275  
   276  	MOVV	R7, sec+0(FP)
   277  	MOVW	R5, nsec+8(FP)
   278  	RET
   279  
   280  fallback:
   281  	MOVV	$SYS_clock_gettime, R11
   282  	SYSCALL
   283  	JMP finish
   284  
   285  TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
   286  	MOVV	R3, R23	// R23 is unchanged by C code
   287  	MOVV	R3, R25
   288  
   289  	MOVV	g_m(g), R24	// R24 = m
   290  
   291  	// Set vdsoPC and vdsoSP for SIGPROF traceback.
   292  	// Save the old values on stack and restore them on exit,
   293  	// so this function is reentrant.
   294  	MOVV	m_vdsoPC(R24), R11
   295  	MOVV	m_vdsoSP(R24), R7
   296  	MOVV	R11, 8(R3)
   297  	MOVV	R7, 16(R3)
   298  
   299  	MOVV    $ret-8(FP), R11 // caller's SP
   300  	MOVV	R1, m_vdsoPC(R24)
   301  	MOVV	R11, m_vdsoSP(R24)
   302  
   303  	MOVV	m_curg(R24), R4
   304  	MOVV	g, R5
   305  	BNE	R4, R5, noswitch
   306  
   307  	MOVV	m_g0(R24), R4
   308  	MOVV	(g_sched+gobuf_sp)(R4), R25	// Set SP to g0 stack
   309  
   310  noswitch:
   311  	SUBV	$16, R25
   312  	AND	$~15, R25	// Align for C code
   313  	MOVV	R25, R3
   314  
   315  	MOVW	$1, R4 // CLOCK_MONOTONIC=1
   316  	MOVV	$0(R3), R5
   317  
   318  	MOVV	runtime·vdsoClockgettimeSym(SB), R20
   319  	BEQ	R20, fallback
   320  
   321  	JAL	(R20)
   322  
   323  finish:
   324  	MOVV	0(R3), R7	// sec
   325  	MOVV	8(R3), R5	// nsec
   326  
   327  	MOVV	R23, R3	// restore SP
   328  	// Restore vdsoPC, vdsoSP
   329  	// We don't worry about being signaled between the two stores.
   330  	// If we are not in a signal handler, we'll restore vdsoSP to 0,
   331  	// and no one will care about vdsoPC. If we are in a signal handler,
   332  	// we cannot receive another signal.
   333  	MOVV	16(R3), R25
   334  	MOVV	R25, m_vdsoSP(R24)
   335  	MOVV	8(R3), R25
   336  	MOVV	R25, m_vdsoPC(R24)
   337  
   338  	// sec is in R7, nsec in R5
   339  	// return nsec in R7
   340  	MOVV	$1000000000, R4
   341  	MULVU	R4, R7, R7
   342  	ADDVU	R5, R7
   343  	MOVV	R7, ret+0(FP)
   344  	RET
   345  
   346  fallback:
   347  	MOVV	$SYS_clock_gettime, R11
   348  	SYSCALL
   349  	JMP	finish
   350  
   351  TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
   352  	MOVW	how+0(FP), R4
   353  	MOVV	new+8(FP), R5
   354  	MOVV	old+16(FP), R6
   355  	MOVW	size+24(FP), R7
   356  	MOVV	$SYS_rt_sigprocmask, R11
   357  	SYSCALL
   358  	MOVW	$-4096, R5
   359  	BGEU	R5, R4, 2(PC)
   360  	MOVV	R0, 0xf1(R0)	// crash
   361  	RET
   362  
   363  TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
   364  	MOVV	sig+0(FP), R4
   365  	MOVV	new+8(FP), R5
   366  	MOVV	old+16(FP), R6
   367  	MOVV	size+24(FP), R7
   368  	MOVV	$SYS_rt_sigaction, R11
   369  	SYSCALL
   370  	MOVW	R4, ret+32(FP)
   371  	RET
   372  
   373  TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
   374  	MOVW	sig+8(FP), R4
   375  	MOVV	info+16(FP), R5
   376  	MOVV	ctx+24(FP), R6
   377  	MOVV	fn+0(FP), R20
   378  	JAL	(R20)
   379  	RET
   380  
   381  TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$64
   382  	// this might be called in external code context,
   383  	// where g is not set.
   384  	MOVB	runtime·iscgo(SB), R19
   385  	BEQ	R19, 2(PC)
   386  	JAL	runtime·load_g(SB)
   387  
   388  	MOVW	R4, 8(R3)
   389  	MOVV	R5, 16(R3)
   390  	MOVV	R6, 24(R3)
   391  	MOVV	$runtime·sigtrampgo(SB), R19
   392  	JAL	(R19)
   393  	RET
   394  
   395  TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
   396  	JMP	runtime·sigtramp(SB)
   397  
   398  TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0
   399  	MOVV	addr+0(FP), R4
   400  	MOVV	n+8(FP), R5
   401  	MOVW	prot+16(FP), R6
   402  	MOVW	flags+20(FP), R7
   403  	MOVW	fd+24(FP), R8
   404  	MOVW	off+28(FP), R9
   405  
   406  	MOVV	$SYS_mmap, R11
   407  	SYSCALL
   408  	MOVW	$-4096, R5
   409  	BGEU	R5, R4, ok
   410  	MOVV	$0, p+32(FP)
   411  	SUBVU	R4, R0, R4
   412  	MOVV	R4, err+40(FP)
   413  	RET
   414  ok:
   415  	MOVV	R4, p+32(FP)
   416  	MOVV	$0, err+40(FP)
   417  	RET
   418  
   419  TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
   420  	MOVV	addr+0(FP), R4
   421  	MOVV	n+8(FP), R5
   422  	MOVV	$SYS_munmap, R11
   423  	SYSCALL
   424  	MOVW	$-4096, R5
   425  	BGEU	R5, R4, 2(PC)
   426  	MOVV	R0, 0xf3(R0)	// crash
   427  	RET
   428  
   429  TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
   430  	MOVV	addr+0(FP), R4
   431  	MOVV	n+8(FP), R5
   432  	MOVW	flags+16(FP), R6
   433  	MOVV	$SYS_madvise, R11
   434  	SYSCALL
   435  	MOVW	R4, ret+24(FP)
   436  	RET
   437  
   438  // int64 futex(int32 *uaddr, int32 op, int32 val,
   439  //	struct timespec *timeout, int32 *uaddr2, int32 val2);
   440  TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0
   441  	MOVV	addr+0(FP), R4
   442  	MOVW	op+8(FP), R5
   443  	MOVW	val+12(FP), R6
   444  	MOVV	ts+16(FP), R7
   445  	MOVV	addr2+24(FP), R8
   446  	MOVW	val3+32(FP), R9
   447  	MOVV	$SYS_futex, R11
   448  	SYSCALL
   449  	MOVW	R4, ret+40(FP)
   450  	RET
   451  
   452  // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
   453  TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
   454  	MOVW	flags+0(FP), R4
   455  	MOVV	stk+8(FP), R5
   456  
   457  	// Copy mp, gp, fn off parent stack for use by child.
   458  	// Careful: Linux system call clobbers ???.
   459  	MOVV	mp+16(FP), R23
   460  	MOVV	gp+24(FP), R24
   461  	MOVV	fn+32(FP), R25
   462  
   463  	MOVV	R23, -8(R5)
   464  	MOVV	R24, -16(R5)
   465  	MOVV	R25, -24(R5)
   466  	MOVV	$1234, R23
   467  	MOVV	R23, -32(R5)
   468  
   469  	MOVV	$SYS_clone, R11
   470  	SYSCALL
   471  
   472  	// In parent, return.
   473  	BEQ	R4, 3(PC)
   474  	MOVW	R4, ret+40(FP)
   475  	RET
   476  
   477  	// In child, on new stack.
   478  	MOVV	-32(R3), R23
   479  	MOVV	$1234, R19
   480  	BEQ	R23, R19, 2(PC)
   481  	MOVV	R0, 0(R0)
   482  
   483  	// Initialize m->procid to Linux tid
   484  	MOVV	$SYS_gettid, R11
   485  	SYSCALL
   486  
   487  	MOVV	-24(R3), R25		// fn
   488  	MOVV	-16(R3), R24		// g
   489  	MOVV	-8(R3), R23		// m
   490  
   491  	BEQ	R23, nog
   492  	BEQ	R24, nog
   493  
   494  	MOVV	R4, m_procid(R23)
   495  
   496  	// TODO: setup TLS.
   497  
   498  	// In child, set up new stack
   499  	MOVV	R23, g_m(R24)
   500  	MOVV	R24, g
   501  	//CALL	runtime·stackcheck(SB)
   502  
   503  nog:
   504  	// Call fn
   505  	JAL	(R25)
   506  
   507  	// It shouldn't return.	 If it does, exit that thread.
   508  	MOVW	$111, R4
   509  	MOVV	$SYS_exit, R11
   510  	SYSCALL
   511  	JMP	-3(PC)	// keep exiting
   512  
   513  TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
   514  	MOVV	new+0(FP), R4
   515  	MOVV	old+8(FP), R5
   516  	MOVV	$SYS_sigaltstack, R11
   517  	SYSCALL
   518  	MOVW	$-4096, R5
   519  	BGEU	R5, R4, 2(PC)
   520  	MOVV	R0, 0xf1(R0)	// crash
   521  	RET
   522  
   523  TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
   524  	MOVV	$SYS_sched_yield, R11
   525  	SYSCALL
   526  	RET
   527  
   528  TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0
   529  	MOVV	pid+0(FP), R4
   530  	MOVV	len+8(FP), R5
   531  	MOVV	buf+16(FP), R6
   532  	MOVV	$SYS_sched_getaffinity, R11
   533  	SYSCALL
   534  	MOVW	R4, ret+24(FP)
   535  	RET
   536  
   537  // int32 runtime·epollcreate(int32 size);
   538  TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0
   539  	MOVW	size+0(FP), R4
   540  	MOVV	$SYS_epoll_create1, R11
   541  	SYSCALL
   542  	MOVW	R4, ret+8(FP)
   543  	RET
   544  
   545  // int32 runtime·epollcreate1(int32 flags);
   546  TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0
   547  	MOVW	flags+0(FP), R4
   548  	MOVV	$SYS_epoll_create1, R11
   549  	SYSCALL
   550  	MOVW	R4, ret+8(FP)
   551  	RET
   552  
   553  // func epollctl(epfd, op, fd int32, ev *epollEvent) int
   554  TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0
   555  	MOVW	epfd+0(FP), R4
   556  	MOVW	op+4(FP), R5
   557  	MOVW	fd+8(FP), R6
   558  	MOVV	ev+16(FP), R7
   559  	MOVV	$SYS_epoll_ctl, R11
   560  	SYSCALL
   561  	MOVW	R4, ret+24(FP)
   562  	RET
   563  
   564  // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
   565  TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0
   566  	MOVW	epfd+0(FP), R4
   567  	MOVV	ev+8(FP), R5
   568  	MOVW	nev+16(FP), R6
   569  	MOVW	timeout+20(FP), R7
   570  	MOVV	$0, R8
   571  	MOVV	$SYS_epoll_pwait, R11
   572  	SYSCALL
   573  	MOVW	R4, ret+24(FP)
   574  	RET
   575  
   576  // void runtime·closeonexec(int32 fd);
   577  TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0
   578  	MOVW	fd+0(FP), R4  // fd
   579  	MOVV	$2, R5	// F_SETFD
   580  	MOVV	$1, R6	// FD_CLOEXEC
   581  	MOVV	$SYS_fcntl, R11
   582  	SYSCALL
   583  	RET
   584  
   585  // func sbrk0() uintptr
   586  TEXT runtime·sbrk0(SB),NOSPLIT|NOFRAME,$0-8
   587  	// Implemented as brk(NULL).
   588  	MOVV	$0, R4
   589  	MOVV	$SYS_brk, R11
   590  	SYSCALL
   591  	MOVV	R4, ret+0(FP)
   592  	RET
   593  
   594  TEXT runtime·access(SB),$0-20
   595  	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
   596  	MOVW	R0, ret+16(FP) // for vet
   597  	RET
   598  
   599  TEXT runtime·connect(SB),$0-28
   600  	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
   601  	MOVW	R0, ret+24(FP) // for vet
   602  	RET
   603  
   604  TEXT runtime·socket(SB),$0-20
   605  	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
   606  	MOVW	R0, ret+16(FP) // for vet
   607  	RET
   608  

View as plain text