github.com/mtsmfm/go/src@v0.0.0-20221020090648-44bdcb9f8fde/runtime/sys_linux_amd64.s (about)

     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 AMD64, Linux
     7  //
     8  
     9  #include "go_asm.h"
    10  #include "go_tls.h"
    11  #include "textflag.h"
    12  #include "cgo/abi_amd64.h"
    13  
    14  #define AT_FDCWD -100
    15  
    16  #define SYS_read		0
    17  #define SYS_write		1
    18  #define SYS_close		3
    19  #define SYS_mmap		9
    20  #define SYS_munmap		11
    21  #define SYS_brk 		12
    22  #define SYS_rt_sigaction	13
    23  #define SYS_rt_sigprocmask	14
    24  #define SYS_rt_sigreturn	15
    25  #define SYS_sched_yield 	24
    26  #define SYS_mincore		27
    27  #define SYS_madvise		28
    28  #define SYS_nanosleep		35
    29  #define SYS_setittimer		38
    30  #define SYS_getpid		39
    31  #define SYS_socket		41
    32  #define SYS_connect		42
    33  #define SYS_clone		56
    34  #define SYS_exit		60
    35  #define SYS_kill		62
    36  #define SYS_sigaltstack 	131
    37  #define SYS_arch_prctl		158
    38  #define SYS_gettid		186
    39  #define SYS_futex		202
    40  #define SYS_sched_getaffinity	204
    41  #define SYS_timer_create	222
    42  #define SYS_timer_settime	223
    43  #define SYS_timer_delete	226
    44  #define SYS_clock_gettime	228
    45  #define SYS_exit_group		231
    46  #define SYS_tgkill		234
    47  #define SYS_openat		257
    48  #define SYS_faccessat		269
    49  #define SYS_pipe2		293
    50  
    51  TEXT runtime·exit(SB),NOSPLIT,$0-4
    52  	MOVL	code+0(FP), DI
    53  	MOVL	$SYS_exit_group, AX
    54  	SYSCALL
    55  	RET
    56  
    57  // func exitThread(wait *atomic.Uint32)
    58  TEXT runtime·exitThread(SB),NOSPLIT,$0-8
    59  	MOVQ	wait+0(FP), AX
    60  	// We're done using the stack.
    61  	MOVL	$0, (AX)
    62  	MOVL	$0, DI	// exit code
    63  	MOVL	$SYS_exit, AX
    64  	SYSCALL
    65  	// We may not even have a stack any more.
    66  	INT	$3
    67  	JMP	0(PC)
    68  
    69  TEXT runtime·open(SB),NOSPLIT,$0-20
    70  	// This uses openat instead of open, because Android O blocks open.
    71  	MOVL	$AT_FDCWD, DI // AT_FDCWD, so this acts like open
    72  	MOVQ	name+0(FP), SI
    73  	MOVL	mode+8(FP), DX
    74  	MOVL	perm+12(FP), R10
    75  	MOVL	$SYS_openat, AX
    76  	SYSCALL
    77  	CMPQ	AX, $0xfffffffffffff001
    78  	JLS	2(PC)
    79  	MOVL	$-1, AX
    80  	MOVL	AX, ret+16(FP)
    81  	RET
    82  
    83  TEXT runtime·closefd(SB),NOSPLIT,$0-12
    84  	MOVL	fd+0(FP), DI
    85  	MOVL	$SYS_close, AX
    86  	SYSCALL
    87  	CMPQ	AX, $0xfffffffffffff001
    88  	JLS	2(PC)
    89  	MOVL	$-1, AX
    90  	MOVL	AX, ret+8(FP)
    91  	RET
    92  
    93  TEXT runtime·write1(SB),NOSPLIT,$0-28
    94  	MOVQ	fd+0(FP), DI
    95  	MOVQ	p+8(FP), SI
    96  	MOVL	n+16(FP), DX
    97  	MOVL	$SYS_write, AX
    98  	SYSCALL
    99  	MOVL	AX, ret+24(FP)
   100  	RET
   101  
   102  TEXT runtime·read(SB),NOSPLIT,$0-28
   103  	MOVL	fd+0(FP), DI
   104  	MOVQ	p+8(FP), SI
   105  	MOVL	n+16(FP), DX
   106  	MOVL	$SYS_read, AX
   107  	SYSCALL
   108  	MOVL	AX, ret+24(FP)
   109  	RET
   110  
   111  // func pipe2(flags int32) (r, w int32, errno int32)
   112  TEXT runtime·pipe2(SB),NOSPLIT,$0-20
   113  	LEAQ	r+8(FP), DI
   114  	MOVL	flags+0(FP), SI
   115  	MOVL	$SYS_pipe2, AX
   116  	SYSCALL
   117  	MOVL	AX, errno+16(FP)
   118  	RET
   119  
   120  TEXT runtime·usleep(SB),NOSPLIT,$16
   121  	MOVL	$0, DX
   122  	MOVL	usec+0(FP), AX
   123  	MOVL	$1000000, CX
   124  	DIVL	CX
   125  	MOVQ	AX, 0(SP)
   126  	MOVL	$1000, AX	// usec to nsec
   127  	MULL	DX
   128  	MOVQ	AX, 8(SP)
   129  
   130  	// nanosleep(&ts, 0)
   131  	MOVQ	SP, DI
   132  	MOVL	$0, SI
   133  	MOVL	$SYS_nanosleep, AX
   134  	SYSCALL
   135  	RET
   136  
   137  TEXT runtime·gettid(SB),NOSPLIT,$0-4
   138  	MOVL	$SYS_gettid, AX
   139  	SYSCALL
   140  	MOVL	AX, ret+0(FP)
   141  	RET
   142  
   143  TEXT runtime·raise(SB),NOSPLIT,$0
   144  	MOVL	$SYS_getpid, AX
   145  	SYSCALL
   146  	MOVL	AX, R12
   147  	MOVL	$SYS_gettid, AX
   148  	SYSCALL
   149  	MOVL	AX, SI	// arg 2 tid
   150  	MOVL	R12, DI	// arg 1 pid
   151  	MOVL	sig+0(FP), DX	// arg 3
   152  	MOVL	$SYS_tgkill, AX
   153  	SYSCALL
   154  	RET
   155  
   156  TEXT runtime·raiseproc(SB),NOSPLIT,$0
   157  	MOVL	$SYS_getpid, AX
   158  	SYSCALL
   159  	MOVL	AX, DI	// arg 1 pid
   160  	MOVL	sig+0(FP), SI	// arg 2
   161  	MOVL	$SYS_kill, AX
   162  	SYSCALL
   163  	RET
   164  
   165  TEXT ·getpid(SB),NOSPLIT,$0-8
   166  	MOVL	$SYS_getpid, AX
   167  	SYSCALL
   168  	MOVQ	AX, ret+0(FP)
   169  	RET
   170  
   171  TEXT ·tgkill(SB),NOSPLIT,$0
   172  	MOVQ	tgid+0(FP), DI
   173  	MOVQ	tid+8(FP), SI
   174  	MOVQ	sig+16(FP), DX
   175  	MOVL	$SYS_tgkill, AX
   176  	SYSCALL
   177  	RET
   178  
   179  TEXT runtime·setitimer(SB),NOSPLIT,$0-24
   180  	MOVL	mode+0(FP), DI
   181  	MOVQ	new+8(FP), SI
   182  	MOVQ	old+16(FP), DX
   183  	MOVL	$SYS_setittimer, AX
   184  	SYSCALL
   185  	RET
   186  
   187  TEXT runtime·timer_create(SB),NOSPLIT,$0-28
   188  	MOVL	clockid+0(FP), DI
   189  	MOVQ	sevp+8(FP), SI
   190  	MOVQ	timerid+16(FP), DX
   191  	MOVL	$SYS_timer_create, AX
   192  	SYSCALL
   193  	MOVL	AX, ret+24(FP)
   194  	RET
   195  
   196  TEXT runtime·timer_settime(SB),NOSPLIT,$0-28
   197  	MOVL	timerid+0(FP), DI
   198  	MOVL	flags+4(FP), SI
   199  	MOVQ	new+8(FP), DX
   200  	MOVQ	old+16(FP), R10
   201  	MOVL	$SYS_timer_settime, AX
   202  	SYSCALL
   203  	MOVL	AX, ret+24(FP)
   204  	RET
   205  
   206  TEXT runtime·timer_delete(SB),NOSPLIT,$0-12
   207  	MOVL	timerid+0(FP), DI
   208  	MOVL	$SYS_timer_delete, AX
   209  	SYSCALL
   210  	MOVL	AX, ret+8(FP)
   211  	RET
   212  
   213  TEXT runtime·mincore(SB),NOSPLIT,$0-28
   214  	MOVQ	addr+0(FP), DI
   215  	MOVQ	n+8(FP), SI
   216  	MOVQ	dst+16(FP), DX
   217  	MOVL	$SYS_mincore, AX
   218  	SYSCALL
   219  	MOVL	AX, ret+24(FP)
   220  	RET
   221  
   222  // func nanotime1() int64
   223  TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
   224  	// We don't know how much stack space the VDSO code will need,
   225  	// so switch to g0.
   226  	// In particular, a kernel configured with CONFIG_OPTIMIZE_INLINING=n
   227  	// and hardening can use a full page of stack space in gettime_sym
   228  	// due to stack probes inserted to avoid stack/heap collisions.
   229  	// See issue #20427.
   230  
   231  	MOVQ	SP, R12	// Save old SP; R12 unchanged by C code.
   232  
   233  	MOVQ	g_m(R14), BX // BX unchanged by C code.
   234  
   235  	// Set vdsoPC and vdsoSP for SIGPROF traceback.
   236  	// Save the old values on stack and restore them on exit,
   237  	// so this function is reentrant.
   238  	MOVQ	m_vdsoPC(BX), CX
   239  	MOVQ	m_vdsoSP(BX), DX
   240  	MOVQ	CX, 0(SP)
   241  	MOVQ	DX, 8(SP)
   242  
   243  	LEAQ	ret+0(FP), DX
   244  	MOVQ	-8(DX), CX
   245  	MOVQ	CX, m_vdsoPC(BX)
   246  	MOVQ	DX, m_vdsoSP(BX)
   247  
   248  	CMPQ	R14, m_curg(BX)	// Only switch if on curg.
   249  	JNE	noswitch
   250  
   251  	MOVQ	m_g0(BX), DX
   252  	MOVQ	(g_sched+gobuf_sp)(DX), SP	// Set SP to g0 stack
   253  
   254  noswitch:
   255  	SUBQ	$16, SP		// Space for results
   256  	ANDQ	$~15, SP	// Align for C code
   257  
   258  	MOVL	$1, DI // CLOCK_MONOTONIC
   259  	LEAQ	0(SP), SI
   260  	MOVQ	runtime·vdsoClockgettimeSym(SB), AX
   261  	CMPQ	AX, $0
   262  	JEQ	fallback
   263  	CALL	AX
   264  ret:
   265  	MOVQ	0(SP), AX	// sec
   266  	MOVQ	8(SP), DX	// nsec
   267  	MOVQ	R12, SP		// Restore real SP
   268  	// Restore vdsoPC, vdsoSP
   269  	// We don't worry about being signaled between the two stores.
   270  	// If we are not in a signal handler, we'll restore vdsoSP to 0,
   271  	// and no one will care about vdsoPC. If we are in a signal handler,
   272  	// we cannot receive another signal.
   273  	MOVQ	8(SP), CX
   274  	MOVQ	CX, m_vdsoSP(BX)
   275  	MOVQ	0(SP), CX
   276  	MOVQ	CX, m_vdsoPC(BX)
   277  	// sec is in AX, nsec in DX
   278  	// return nsec in AX
   279  	IMULQ	$1000000000, AX
   280  	ADDQ	DX, AX
   281  	MOVQ	AX, ret+0(FP)
   282  	RET
   283  fallback:
   284  	MOVQ	$SYS_clock_gettime, AX
   285  	SYSCALL
   286  	JMP	ret
   287  
   288  TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28
   289  	MOVL	how+0(FP), DI
   290  	MOVQ	new+8(FP), SI
   291  	MOVQ	old+16(FP), DX
   292  	MOVL	size+24(FP), R10
   293  	MOVL	$SYS_rt_sigprocmask, AX
   294  	SYSCALL
   295  	CMPQ	AX, $0xfffffffffffff001
   296  	JLS	2(PC)
   297  	MOVL	$0xf1, 0xf1  // crash
   298  	RET
   299  
   300  TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-36
   301  	MOVQ	sig+0(FP), DI
   302  	MOVQ	new+8(FP), SI
   303  	MOVQ	old+16(FP), DX
   304  	MOVQ	size+24(FP), R10
   305  	MOVL	$SYS_rt_sigaction, AX
   306  	SYSCALL
   307  	MOVL	AX, ret+32(FP)
   308  	RET
   309  
   310  // Call the function stored in _cgo_sigaction using the GCC calling convention.
   311  TEXT runtime·callCgoSigaction(SB),NOSPLIT,$16
   312  	MOVQ	sig+0(FP), DI
   313  	MOVQ	new+8(FP), SI
   314  	MOVQ	old+16(FP), DX
   315  	MOVQ	_cgo_sigaction(SB), AX
   316  	MOVQ	SP, BX	// callee-saved
   317  	ANDQ	$~15, SP	// alignment as per amd64 psABI
   318  	CALL	AX
   319  	MOVQ	BX, SP
   320  	MOVL	AX, ret+24(FP)
   321  	RET
   322  
   323  TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
   324  	MOVQ	fn+0(FP),    AX
   325  	MOVL	sig+8(FP),   DI
   326  	MOVQ	info+16(FP), SI
   327  	MOVQ	ctx+24(FP),  DX
   328  	PUSHQ	BP
   329  	MOVQ	SP, BP
   330  	ANDQ	$~15, SP     // alignment for x86_64 ABI
   331  	CALL	AX
   332  	MOVQ	BP, SP
   333  	POPQ	BP
   334  	RET
   335  
   336  // Called using C ABI.
   337  TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$0
   338  	// Transition from C ABI to Go ABI.
   339  	PUSH_REGS_HOST_TO_ABI0()
   340  
   341  	// Set up ABIInternal environment: g in R14, cleared X15.
   342  	get_tls(R12)
   343  	MOVQ	g(R12), R14
   344  	PXOR	X15, X15
   345  
   346  	// Reserve space for spill slots.
   347  	NOP	SP		// disable vet stack checking
   348  	ADJSP   $24
   349  
   350  	// Call into the Go signal handler
   351  	MOVQ	DI, AX	// sig
   352  	MOVQ	SI, BX	// info
   353  	MOVQ	DX, CX	// ctx
   354  	CALL	·sigtrampgo<ABIInternal>(SB)
   355  
   356  	ADJSP	$-24
   357  
   358          POP_REGS_HOST_TO_ABI0()
   359  	RET
   360  
   361  // Called using C ABI.
   362  TEXT runtime·sigprofNonGoWrapper<>(SB),NOSPLIT,$0
   363  	// Transition from C ABI to Go ABI.
   364  	PUSH_REGS_HOST_TO_ABI0()
   365  
   366  	// Set up ABIInternal environment: g in R14, cleared X15.
   367  	get_tls(R12)
   368  	MOVQ	g(R12), R14
   369  	PXOR	X15, X15
   370  
   371  	// Reserve space for spill slots.
   372  	NOP	SP		// disable vet stack checking
   373  	ADJSP   $24
   374  
   375  	// Call into the Go signal handler
   376  	MOVQ	DI, AX	// sig
   377  	MOVQ	SI, BX	// info
   378  	MOVQ	DX, CX	// ctx
   379  	CALL	·sigprofNonGo<ABIInternal>(SB)
   380  
   381  	ADJSP	$-24
   382  
   383  	POP_REGS_HOST_TO_ABI0()
   384  	RET
   385  
   386  // Used instead of sigtramp in programs that use cgo.
   387  // Arguments from kernel are in DI, SI, DX.
   388  TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
   389  	// If no traceback function, do usual sigtramp.
   390  	MOVQ	runtime·cgoTraceback(SB), AX
   391  	TESTQ	AX, AX
   392  	JZ	sigtramp
   393  
   394  	// If no traceback support function, which means that
   395  	// runtime/cgo was not linked in, do usual sigtramp.
   396  	MOVQ	_cgo_callers(SB), AX
   397  	TESTQ	AX, AX
   398  	JZ	sigtramp
   399  
   400  	// Figure out if we are currently in a cgo call.
   401  	// If not, just do usual sigtramp.
   402  	get_tls(CX)
   403  	MOVQ	g(CX),AX
   404  	TESTQ	AX, AX
   405  	JZ	sigtrampnog     // g == nil
   406  	MOVQ	g_m(AX), AX
   407  	TESTQ	AX, AX
   408  	JZ	sigtramp        // g.m == nil
   409  	MOVL	m_ncgo(AX), CX
   410  	TESTL	CX, CX
   411  	JZ	sigtramp        // g.m.ncgo == 0
   412  	MOVQ	m_curg(AX), CX
   413  	TESTQ	CX, CX
   414  	JZ	sigtramp        // g.m.curg == nil
   415  	MOVQ	g_syscallsp(CX), CX
   416  	TESTQ	CX, CX
   417  	JZ	sigtramp        // g.m.curg.syscallsp == 0
   418  	MOVQ	m_cgoCallers(AX), R8
   419  	TESTQ	R8, R8
   420  	JZ	sigtramp        // g.m.cgoCallers == nil
   421  	MOVL	m_cgoCallersUse(AX), CX
   422  	TESTL	CX, CX
   423  	JNZ	sigtramp	// g.m.cgoCallersUse != 0
   424  
   425  	// Jump to a function in runtime/cgo.
   426  	// That function, written in C, will call the user's traceback
   427  	// function with proper unwind info, and will then call back here.
   428  	// The first three arguments, and the fifth, are already in registers.
   429  	// Set the two remaining arguments now.
   430  	MOVQ	runtime·cgoTraceback(SB), CX
   431  	MOVQ	$runtime·sigtramp(SB), R9
   432  	MOVQ	_cgo_callers(SB), AX
   433  	JMP	AX
   434  
   435  sigtramp:
   436  	JMP	runtime·sigtramp(SB)
   437  
   438  sigtrampnog:
   439  	// Signal arrived on a non-Go thread. If this is SIGPROF, get a
   440  	// stack trace.
   441  	CMPL	DI, $27 // 27 == SIGPROF
   442  	JNZ	sigtramp
   443  
   444  	// Lock sigprofCallersUse.
   445  	MOVL	$0, AX
   446  	MOVL	$1, CX
   447  	MOVQ	$runtime·sigprofCallersUse(SB), R11
   448  	LOCK
   449  	CMPXCHGL	CX, 0(R11)
   450  	JNZ	sigtramp  // Skip stack trace if already locked.
   451  
   452  	// Jump to the traceback function in runtime/cgo.
   453  	// It will call back to sigprofNonGo, via sigprofNonGoWrapper, to convert
   454  	// the arguments to the Go calling convention.
   455  	// First three arguments to traceback function are in registers already.
   456  	MOVQ	runtime·cgoTraceback(SB), CX
   457  	MOVQ	$runtime·sigprofCallers(SB), R8
   458  	MOVQ	$runtime·sigprofNonGoWrapper<>(SB), R9
   459  	MOVQ	_cgo_callers(SB), AX
   460  	JMP	AX
   461  
   462  // For cgo unwinding to work, this function must look precisely like
   463  // the one in glibc.  The glibc source code is:
   464  // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sigaction.c
   465  // The code that cares about the precise instructions used is:
   466  // https://gcc.gnu.org/viewcvs/gcc/trunk/libgcc/config/i386/linux-unwind.h?revision=219188&view=markup
   467  TEXT runtime·sigreturn(SB),NOSPLIT,$0
   468  	MOVQ	$SYS_rt_sigreturn, AX
   469  	SYSCALL
   470  	INT $3	// not reached
   471  
   472  TEXT runtime·sysMmap(SB),NOSPLIT,$0
   473  	MOVQ	addr+0(FP), DI
   474  	MOVQ	n+8(FP), SI
   475  	MOVL	prot+16(FP), DX
   476  	MOVL	flags+20(FP), R10
   477  	MOVL	fd+24(FP), R8
   478  	MOVL	off+28(FP), R9
   479  
   480  	MOVL	$SYS_mmap, AX
   481  	SYSCALL
   482  	CMPQ	AX, $0xfffffffffffff001
   483  	JLS	ok
   484  	NOTQ	AX
   485  	INCQ	AX
   486  	MOVQ	$0, p+32(FP)
   487  	MOVQ	AX, err+40(FP)
   488  	RET
   489  ok:
   490  	MOVQ	AX, p+32(FP)
   491  	MOVQ	$0, err+40(FP)
   492  	RET
   493  
   494  // Call the function stored in _cgo_mmap using the GCC calling convention.
   495  // This must be called on the system stack.
   496  TEXT runtime·callCgoMmap(SB),NOSPLIT,$16
   497  	MOVQ	addr+0(FP), DI
   498  	MOVQ	n+8(FP), SI
   499  	MOVL	prot+16(FP), DX
   500  	MOVL	flags+20(FP), CX
   501  	MOVL	fd+24(FP), R8
   502  	MOVL	off+28(FP), R9
   503  	MOVQ	_cgo_mmap(SB), AX
   504  	MOVQ	SP, BX
   505  	ANDQ	$~15, SP	// alignment as per amd64 psABI
   506  	MOVQ	BX, 0(SP)
   507  	CALL	AX
   508  	MOVQ	0(SP), SP
   509  	MOVQ	AX, ret+32(FP)
   510  	RET
   511  
   512  TEXT runtime·sysMunmap(SB),NOSPLIT,$0
   513  	MOVQ	addr+0(FP), DI
   514  	MOVQ	n+8(FP), SI
   515  	MOVQ	$SYS_munmap, AX
   516  	SYSCALL
   517  	CMPQ	AX, $0xfffffffffffff001
   518  	JLS	2(PC)
   519  	MOVL	$0xf1, 0xf1  // crash
   520  	RET
   521  
   522  // Call the function stored in _cgo_munmap using the GCC calling convention.
   523  // This must be called on the system stack.
   524  TEXT runtime·callCgoMunmap(SB),NOSPLIT,$16-16
   525  	MOVQ	addr+0(FP), DI
   526  	MOVQ	n+8(FP), SI
   527  	MOVQ	_cgo_munmap(SB), AX
   528  	MOVQ	SP, BX
   529  	ANDQ	$~15, SP	// alignment as per amd64 psABI
   530  	MOVQ	BX, 0(SP)
   531  	CALL	AX
   532  	MOVQ	0(SP), SP
   533  	RET
   534  
   535  TEXT runtime·madvise(SB),NOSPLIT,$0
   536  	MOVQ	addr+0(FP), DI
   537  	MOVQ	n+8(FP), SI
   538  	MOVL	flags+16(FP), DX
   539  	MOVQ	$SYS_madvise, AX
   540  	SYSCALL
   541  	MOVL	AX, ret+24(FP)
   542  	RET
   543  
   544  // int64 futex(int32 *uaddr, int32 op, int32 val,
   545  //	struct timespec *timeout, int32 *uaddr2, int32 val2);
   546  TEXT runtime·futex(SB),NOSPLIT,$0
   547  	MOVQ	addr+0(FP), DI
   548  	MOVL	op+8(FP), SI
   549  	MOVL	val+12(FP), DX
   550  	MOVQ	ts+16(FP), R10
   551  	MOVQ	addr2+24(FP), R8
   552  	MOVL	val3+32(FP), R9
   553  	MOVL	$SYS_futex, AX
   554  	SYSCALL
   555  	MOVL	AX, ret+40(FP)
   556  	RET
   557  
   558  // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
   559  TEXT runtime·clone(SB),NOSPLIT,$0
   560  	MOVL	flags+0(FP), DI
   561  	MOVQ	stk+8(FP), SI
   562  	MOVQ	$0, DX
   563  	MOVQ	$0, R10
   564  	MOVQ    $0, R8
   565  	// Copy mp, gp, fn off parent stack for use by child.
   566  	// Careful: Linux system call clobbers CX and R11.
   567  	MOVQ	mp+16(FP), R13
   568  	MOVQ	gp+24(FP), R9
   569  	MOVQ	fn+32(FP), R12
   570  	CMPQ	R13, $0    // m
   571  	JEQ	nog1
   572  	CMPQ	R9, $0    // g
   573  	JEQ	nog1
   574  	LEAQ	m_tls(R13), R8
   575  #ifdef GOOS_android
   576  	// Android stores the TLS offset in runtime·tls_g.
   577  	SUBQ	runtime·tls_g(SB), R8
   578  #else
   579  	ADDQ	$8, R8	// ELF wants to use -8(FS)
   580  #endif
   581  	ORQ 	$0x00080000, DI //add flag CLONE_SETTLS(0x00080000) to call clone
   582  nog1:
   583  	MOVL	$SYS_clone, AX
   584  	SYSCALL
   585  
   586  	// In parent, return.
   587  	CMPQ	AX, $0
   588  	JEQ	3(PC)
   589  	MOVL	AX, ret+40(FP)
   590  	RET
   591  
   592  	// In child, on new stack.
   593  	MOVQ	SI, SP
   594  
   595  	// If g or m are nil, skip Go-related setup.
   596  	CMPQ	R13, $0    // m
   597  	JEQ	nog2
   598  	CMPQ	R9, $0    // g
   599  	JEQ	nog2
   600  
   601  	// Initialize m->procid to Linux tid
   602  	MOVL	$SYS_gettid, AX
   603  	SYSCALL
   604  	MOVQ	AX, m_procid(R13)
   605  
   606  	// In child, set up new stack
   607  	get_tls(CX)
   608  	MOVQ	R13, g_m(R9)
   609  	MOVQ	R9, g(CX)
   610  	MOVQ	R9, R14 // set g register
   611  	CALL	runtime·stackcheck(SB)
   612  
   613  nog2:
   614  	// Call fn. This is the PC of an ABI0 function.
   615  	CALL	R12
   616  
   617  	// It shouldn't return. If it does, exit that thread.
   618  	MOVL	$111, DI
   619  	MOVL	$SYS_exit, AX
   620  	SYSCALL
   621  	JMP	-3(PC)	// keep exiting
   622  
   623  TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
   624  	MOVQ	new+0(FP), DI
   625  	MOVQ	old+8(FP), SI
   626  	MOVQ	$SYS_sigaltstack, AX
   627  	SYSCALL
   628  	CMPQ	AX, $0xfffffffffffff001
   629  	JLS	2(PC)
   630  	MOVL	$0xf1, 0xf1  // crash
   631  	RET
   632  
   633  // set tls base to DI
   634  TEXT runtime·settls(SB),NOSPLIT,$32
   635  #ifdef GOOS_android
   636  	// Android stores the TLS offset in runtime·tls_g.
   637  	SUBQ	runtime·tls_g(SB), DI
   638  #else
   639  	ADDQ	$8, DI	// ELF wants to use -8(FS)
   640  #endif
   641  	MOVQ	DI, SI
   642  	MOVQ	$0x1002, DI	// ARCH_SET_FS
   643  	MOVQ	$SYS_arch_prctl, AX
   644  	SYSCALL
   645  	CMPQ	AX, $0xfffffffffffff001
   646  	JLS	2(PC)
   647  	MOVL	$0xf1, 0xf1  // crash
   648  	RET
   649  
   650  TEXT runtime·osyield(SB),NOSPLIT,$0
   651  	MOVL	$SYS_sched_yield, AX
   652  	SYSCALL
   653  	RET
   654  
   655  TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
   656  	MOVQ	pid+0(FP), DI
   657  	MOVQ	len+8(FP), SI
   658  	MOVQ	buf+16(FP), DX
   659  	MOVL	$SYS_sched_getaffinity, AX
   660  	SYSCALL
   661  	MOVL	AX, ret+24(FP)
   662  	RET
   663  
   664  // int access(const char *name, int mode)
   665  TEXT runtime·access(SB),NOSPLIT,$0
   666  	// This uses faccessat instead of access, because Android O blocks access.
   667  	MOVL	$AT_FDCWD, DI // AT_FDCWD, so this acts like access
   668  	MOVQ	name+0(FP), SI
   669  	MOVL	mode+8(FP), DX
   670  	MOVL	$0, R10
   671  	MOVL	$SYS_faccessat, AX
   672  	SYSCALL
   673  	MOVL	AX, ret+16(FP)
   674  	RET
   675  
   676  // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
   677  TEXT runtime·connect(SB),NOSPLIT,$0-28
   678  	MOVL	fd+0(FP), DI
   679  	MOVQ	addr+8(FP), SI
   680  	MOVL	len+16(FP), DX
   681  	MOVL	$SYS_connect, AX
   682  	SYSCALL
   683  	MOVL	AX, ret+24(FP)
   684  	RET
   685  
   686  // int socket(int domain, int type, int protocol)
   687  TEXT runtime·socket(SB),NOSPLIT,$0-20
   688  	MOVL	domain+0(FP), DI
   689  	MOVL	typ+4(FP), SI
   690  	MOVL	prot+8(FP), DX
   691  	MOVL	$SYS_socket, AX
   692  	SYSCALL
   693  	MOVL	AX, ret+16(FP)
   694  	RET
   695  
   696  // func sbrk0() uintptr
   697  TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
   698  	// Implemented as brk(NULL).
   699  	MOVQ	$0, DI
   700  	MOVL	$SYS_brk, AX
   701  	SYSCALL
   702  	MOVQ	AX, ret+0(FP)
   703  	RET