github.com/rafaeltorres324/go/src@v0.0.0-20210519164414-9fdf653a9838/runtime/sys_openbsd_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  // System calls and other sys.stuff for AMD64, OpenBSD.
     6  // System calls are implemented in libc/libpthread, this file
     7  // contains trampolines that convert from Go to C calling convention.
     8  // Some direct system call implementations currently remain.
     9  //
    10  
    11  #include "go_asm.h"
    12  #include "go_tls.h"
    13  #include "textflag.h"
    14  
    15  #define CLOCK_MONOTONIC	$3
    16  
    17  TEXT runtime·settls(SB),NOSPLIT,$0
    18  	// Nothing to do, pthread already set thread-local storage up.
    19  	RET
    20  
    21  // mstart_stub is the first function executed on a new thread started by pthread_create.
    22  // It just does some low-level setup and then calls mstart.
    23  // Note: called with the C calling convention.
    24  TEXT runtime·mstart_stub(SB),NOSPLIT,$0
    25  	// DI points to the m.
    26  	// We are already on m's g0 stack.
    27  
    28  	// Save callee-save registers.
    29  	SUBQ	$48, SP
    30  	MOVQ	BX, 0(SP)
    31  	MOVQ	BP, 8(SP)
    32  	MOVQ	R12, 16(SP)
    33  	MOVQ	R13, 24(SP)
    34  	MOVQ	R14, 32(SP)
    35  	MOVQ	R15, 40(SP)
    36  
    37  	// Load g and save to TLS entry.
    38  	// See cmd/link/internal/ld/sym.go:computeTLSOffset.
    39  	MOVQ	m_g0(DI), DX // g
    40  	MOVQ	DX, -8(FS)
    41  
    42  	// Someday the convention will be D is always cleared.
    43  	CLD
    44  
    45  	CALL	runtime·mstart(SB)
    46  
    47  	// Restore callee-save registers.
    48  	MOVQ	0(SP), BX
    49  	MOVQ	8(SP), BP
    50  	MOVQ	16(SP), R12
    51  	MOVQ	24(SP), R13
    52  	MOVQ	32(SP), R14
    53  	MOVQ	40(SP), R15
    54  
    55  	// Go is all done with this OS thread.
    56  	// Tell pthread everything is ok (we never join with this thread, so
    57  	// the value here doesn't really matter).
    58  	XORL	AX, AX
    59  
    60  	ADDQ	$48, SP
    61  	RET
    62  
    63  TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
    64  	MOVQ	fn+0(FP),    AX
    65  	MOVL	sig+8(FP),   DI
    66  	MOVQ	info+16(FP), SI
    67  	MOVQ	ctx+24(FP),  DX
    68  	PUSHQ	BP
    69  	MOVQ	SP, BP
    70  	ANDQ	$~15, SP     // alignment for x86_64 ABI
    71  	CALL	AX
    72  	MOVQ	BP, SP
    73  	POPQ	BP
    74  	RET
    75  
    76  TEXT runtime·sigtramp(SB),NOSPLIT,$72
    77  	// Save callee-saved C registers, since the caller may be a C signal handler.
    78  	MOVQ	BX,  bx-8(SP)
    79  	MOVQ	BP,  bp-16(SP)  // save in case GOEXPERIMENT=noframepointer is set
    80  	MOVQ	R12, r12-24(SP)
    81  	MOVQ	R13, r13-32(SP)
    82  	MOVQ	R14, r14-40(SP)
    83  	MOVQ	R15, r15-48(SP)
    84  	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
    85  	// modify them.
    86  
    87  	MOVQ	DX, ctx-56(SP)
    88  	MOVQ	SI, info-64(SP)
    89  	MOVQ	DI, signum-72(SP)
    90  	CALL	runtime·sigtrampgo(SB)
    91  
    92  	MOVQ	r15-48(SP), R15
    93  	MOVQ	r14-40(SP), R14
    94  	MOVQ	r13-32(SP), R13
    95  	MOVQ	r12-24(SP), R12
    96  	MOVQ	bp-16(SP),  BP
    97  	MOVQ	bx-8(SP),   BX
    98  	RET
    99  
   100  //
   101  // These trampolines help convert from Go calling convention to C calling convention.
   102  // They should be called with asmcgocall.
   103  // A pointer to the arguments is passed in DI.
   104  // A single int32 result is returned in AX.
   105  // (For more results, make an args/results structure.)
   106  TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
   107  	PUSHQ	BP
   108  	MOVQ	SP, BP
   109  	MOVQ	0(DI), DI		// arg 1 - attr
   110  	CALL	libc_pthread_attr_init(SB)
   111  	POPQ	BP
   112  	RET
   113  
   114  TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
   115  	PUSHQ	BP
   116  	MOVQ	SP, BP
   117  	MOVQ	0(DI), DI		// arg 1 - attr
   118  	CALL	libc_pthread_attr_destroy(SB)
   119  	POPQ	BP
   120  	RET
   121  
   122  TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
   123  	PUSHQ	BP
   124  	MOVQ	SP, BP
   125  	MOVQ	8(DI), SI		// arg 2 - stacksize
   126  	MOVQ	0(DI), DI		// arg 1 - attr
   127  	CALL	libc_pthread_attr_getstacksize(SB)
   128  	POPQ	BP
   129  	RET
   130  
   131  TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
   132  	PUSHQ	BP
   133  	MOVQ	SP, BP
   134  	MOVQ	8(DI), SI		// arg 2 - detachstate
   135  	MOVQ	0(DI), DI		// arg 1 - attr
   136  	CALL	libc_pthread_attr_setdetachstate(SB)
   137  	POPQ	BP
   138  	RET
   139  
   140  TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
   141  	PUSHQ	BP
   142  	MOVQ	SP, BP
   143  	SUBQ	$16, SP
   144  	MOVQ	0(DI), SI		// arg 2 - attr
   145  	MOVQ	8(DI), DX		// arg 3 - start
   146  	MOVQ	16(DI), CX		// arg 4 - arg
   147  	MOVQ	SP, DI			// arg 1 - &thread (discarded)
   148  	CALL	libc_pthread_create(SB)
   149  	MOVQ	BP, SP
   150  	POPQ	BP
   151  	RET
   152  
   153  TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
   154  	PUSHQ	BP
   155  	MOVQ	SP, BP
   156  	MOVL	8(DI), SI		// arg 2 - signal
   157  	MOVQ	$0, DX			// arg 3 - tcb
   158  	MOVL	0(DI), DI		// arg 1 - tid
   159  	CALL	libc_thrkill(SB)
   160  	POPQ	BP
   161  	RET
   162  
   163  TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
   164  	PUSHQ	BP
   165  	MOVQ	SP, BP
   166  	MOVL	8(DI), SI		// arg 2 - clock_id
   167  	MOVQ	16(DI), DX		// arg 3 - abstime
   168  	MOVQ	24(DI), CX		// arg 4 - lock
   169  	MOVQ	32(DI), R8		// arg 5 - abort
   170  	MOVQ	0(DI), DI		// arg 1 - id
   171  	CALL	libc_thrsleep(SB)
   172  	POPQ	BP
   173  	RET
   174  
   175  TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
   176  	PUSHQ	BP
   177  	MOVQ	SP, BP
   178  	MOVL	8(DI), SI		// arg 2 - count
   179  	MOVQ	0(DI), DI		// arg 1 - id
   180  	CALL	libc_thrwakeup(SB)
   181  	POPQ	BP
   182  	RET
   183  
   184  TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
   185  	PUSHQ	BP
   186  	MOVQ	SP, BP
   187  	MOVL	0(DI), DI		// arg 1 exit status
   188  	CALL	libc_exit(SB)
   189  	MOVL	$0xf1, 0xf1  // crash
   190  	POPQ	BP
   191  	RET
   192  
   193  TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
   194  	PUSHQ	BP
   195  	MOVQ	SP, BP
   196  	MOVQ	DI, BX			// BX is caller-save
   197  	CALL	libc_getthrid(SB)
   198  	MOVL	AX, 0(BX)		// return value
   199  	POPQ	BP
   200  	RET
   201  
   202  TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
   203  	PUSHQ	BP
   204  	MOVQ	SP, BP
   205  	MOVL	0(DI), BX	// signal
   206  	CALL	libc_getpid(SB)
   207  	MOVL	AX, DI		// arg 1 pid
   208  	MOVL	BX, SI		// arg 2 signal
   209  	CALL	libc_kill(SB)
   210  	POPQ	BP
   211  	RET
   212  
   213  TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
   214  	PUSHQ	BP
   215  	MOVQ	SP, BP
   216  	CALL	libc_sched_yield(SB)
   217  	POPQ	BP
   218  	RET
   219  
   220  TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
   221  	PUSHQ	BP			// make a frame; keep stack aligned
   222  	MOVQ	SP, BP
   223  	MOVQ	DI, BX
   224  	MOVQ	0(BX), DI		// arg 1 addr
   225  	MOVQ	8(BX), SI		// arg 2 len
   226  	MOVL	16(BX), DX		// arg 3 prot
   227  	MOVL	20(BX), CX		// arg 4 flags
   228  	MOVL	24(BX), R8		// arg 5 fid
   229  	MOVL	28(BX), R9		// arg 6 offset
   230  	CALL	libc_mmap(SB)
   231  	XORL	DX, DX
   232  	CMPQ	AX, $-1
   233  	JNE	ok
   234  	CALL	libc_errno(SB)
   235  	MOVLQSX	(AX), DX		// errno
   236  	XORQ	AX, AX
   237  ok:
   238  	MOVQ	AX, 32(BX)
   239  	MOVQ	DX, 40(BX)
   240  	POPQ	BP
   241  	RET
   242  
   243  TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
   244  	PUSHQ	BP
   245  	MOVQ	SP, BP
   246  	MOVQ	8(DI), SI		// arg 2 len
   247  	MOVQ	0(DI), DI		// arg 1 addr
   248  	CALL	libc_munmap(SB)
   249  	TESTQ	AX, AX
   250  	JEQ	2(PC)
   251  	MOVL	$0xf1, 0xf1  // crash
   252  	POPQ	BP
   253  	RET
   254  
   255  TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
   256  	PUSHQ	BP
   257  	MOVQ	SP, BP
   258  	MOVQ	8(DI), SI	// arg 2 len
   259  	MOVL	16(DI), DX	// arg 3 advice
   260  	MOVQ	0(DI), DI	// arg 1 addr
   261  	CALL	libc_madvise(SB)
   262  	// ignore failure - maybe pages are locked
   263  	POPQ	BP
   264  	RET
   265  
   266  TEXT runtime·open_trampoline(SB),NOSPLIT,$0
   267  	PUSHQ	BP
   268  	MOVQ	SP, BP
   269  	MOVL	8(DI), SI		// arg 2 - flags
   270  	MOVL	12(DI), DX		// arg 3 - mode
   271  	MOVQ	0(DI), DI		// arg 1 - path
   272  	XORL	AX, AX			// vararg: say "no float args"
   273  	CALL	libc_open(SB)
   274  	POPQ	BP
   275  	RET
   276  
   277  TEXT runtime·close_trampoline(SB),NOSPLIT,$0
   278  	PUSHQ	BP
   279  	MOVQ	SP, BP
   280  	MOVL	0(DI), DI		// arg 1 - fd
   281  	CALL	libc_close(SB)
   282  	POPQ	BP
   283  	RET
   284  
   285  TEXT runtime·read_trampoline(SB),NOSPLIT,$0
   286  	PUSHQ	BP
   287  	MOVQ	SP, BP
   288  	MOVQ	8(DI), SI		// arg 2 - buf
   289  	MOVL	16(DI), DX		// arg 3 - count
   290  	MOVL	0(DI), DI		// arg 1 - fd
   291  	CALL	libc_read(SB)
   292  	TESTL	AX, AX
   293  	JGE	noerr
   294  	CALL	libc_errno(SB)
   295  	MOVL	(AX), AX		// errno
   296  	NEGL	AX			// caller expects negative errno value
   297  noerr:
   298  	POPQ	BP
   299  	RET
   300  
   301  TEXT runtime·write_trampoline(SB),NOSPLIT,$0
   302  	PUSHQ	BP
   303  	MOVQ	SP, BP
   304  	MOVQ	8(DI), SI		// arg 2 buf
   305  	MOVL	16(DI), DX		// arg 3 count
   306  	MOVL	0(DI), DI		// arg 1 fd
   307  	CALL	libc_write(SB)
   308  	TESTL	AX, AX
   309  	JGE	noerr
   310  	CALL	libc_errno(SB)
   311  	MOVL	(AX), AX		// errno
   312  	NEGL	AX			// caller expects negative errno value
   313  noerr:
   314  	POPQ	BP
   315  	RET
   316  
   317  TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
   318  	PUSHQ	BP
   319  	MOVQ	SP, BP
   320  	MOVL	8(DI), SI		// arg 2 flags
   321  	MOVQ	0(DI), DI		// arg 1 filedes
   322  	CALL	libc_pipe2(SB)
   323  	TESTL	AX, AX
   324  	JEQ	3(PC)
   325  	CALL	libc_errno(SB)
   326  	MOVL	(AX), AX		// errno
   327  	NEGL	AX			// caller expects negative errno value
   328  	POPQ	BP
   329  	RET
   330  
   331  TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
   332  	PUSHQ	BP
   333  	MOVQ	SP, BP
   334  	MOVQ	8(DI), SI		// arg 2 new
   335  	MOVQ	16(DI), DX		// arg 3 old
   336  	MOVL	0(DI), DI		// arg 1 which
   337  	CALL	libc_setitimer(SB)
   338  	POPQ	BP
   339  	RET
   340  
   341  TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
   342  	PUSHQ	BP
   343  	MOVQ	SP, BP
   344  	MOVL	0(DI), DI		// arg 1 usec
   345  	CALL	libc_usleep(SB)
   346  	POPQ	BP
   347  	RET
   348  
   349  TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
   350  	PUSHQ	BP
   351  	MOVQ	SP, BP
   352  	MOVL	8(DI), SI		// arg 2 miblen
   353  	MOVQ	16(DI), DX		// arg 3 out
   354  	MOVQ	24(DI), CX		// arg 4 size
   355  	MOVQ	32(DI), R8		// arg 5 dst
   356  	MOVQ	40(DI), R9		// arg 6 ndst
   357  	MOVQ	0(DI), DI		// arg 1 mib
   358  	CALL	libc_sysctl(SB)
   359  	POPQ	BP
   360  	RET
   361  
   362  TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
   363  	PUSHQ	BP
   364  	MOVQ	SP, BP
   365  	CALL	libc_kqueue(SB)
   366  	POPQ	BP
   367  	RET
   368  
   369  TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
   370  	PUSHQ	BP
   371  	MOVQ	SP, BP
   372  	MOVQ	8(DI), SI		// arg 2 keventt
   373  	MOVL	16(DI), DX		// arg 3 nch
   374  	MOVQ	24(DI), CX		// arg 4 ev
   375  	MOVL	32(DI), R8		// arg 5 nev
   376  	MOVQ	40(DI), R9		// arg 6 ts
   377  	MOVL	0(DI), DI		// arg 1 kq
   378  	CALL	libc_kevent(SB)
   379  	CMPL	AX, $-1
   380  	JNE	ok
   381  	CALL	libc_errno(SB)
   382  	MOVL	(AX), AX		// errno
   383  	NEGL	AX			// caller expects negative errno value
   384  ok:
   385  	POPQ	BP
   386  	RET
   387  
   388  TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
   389  	PUSHQ	BP			// make a frame; keep stack aligned
   390  	MOVQ	SP, BP
   391  	MOVQ	8(DI), SI		// arg 2 tp
   392  	MOVL	0(DI), DI		// arg 1 clock_id
   393  	CALL	libc_clock_gettime(SB)
   394  	TESTL	AX, AX
   395  	JEQ	2(PC)
   396  	MOVL	$0xf1, 0xf1  // crash
   397  	POPQ	BP
   398  	RET
   399  
   400  TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
   401  	PUSHQ	BP
   402  	MOVQ	SP, BP
   403  	MOVL	4(DI), SI		// arg 2 cmd
   404  	MOVL	8(DI), DX		// arg 3 arg
   405  	MOVL	0(DI), DI		// arg 1 fd
   406  	XORL	AX, AX			// vararg: say "no float args"
   407  	CALL	libc_fcntl(SB)
   408  	POPQ	BP
   409  	RET
   410  
   411  TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
   412  	PUSHQ	BP
   413  	MOVQ	SP, BP
   414  	MOVQ	8(DI), SI		// arg 2 new
   415  	MOVQ	16(DI), DX		// arg 3 old
   416  	MOVL	0(DI), DI		// arg 1 sig
   417  	CALL	libc_sigaction(SB)
   418  	TESTL	AX, AX
   419  	JEQ	2(PC)
   420  	MOVL	$0xf1, 0xf1  // crash
   421  	POPQ	BP
   422  	RET
   423  
   424  TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
   425  	PUSHQ	BP
   426  	MOVQ	SP, BP
   427  	MOVQ	8(DI), SI	// arg 2 new
   428  	MOVQ	16(DI), DX	// arg 3 old
   429  	MOVL	0(DI), DI	// arg 1 how
   430  	CALL	libc_pthread_sigmask(SB)
   431  	TESTL	AX, AX
   432  	JEQ	2(PC)
   433  	MOVL	$0xf1, 0xf1  // crash
   434  	POPQ	BP
   435  	RET
   436  
   437  TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
   438  	PUSHQ	BP
   439  	MOVQ	SP, BP
   440  	MOVQ	8(DI), SI		// arg 2 old
   441  	MOVQ	0(DI), DI		// arg 1 new
   442  	CALL	libc_sigaltstack(SB)
   443  	TESTQ	AX, AX
   444  	JEQ	2(PC)
   445  	MOVL	$0xf1, 0xf1  // crash
   446  	POPQ	BP
   447  	RET
   448  
   449  // syscall calls a function in libc on behalf of the syscall package.
   450  // syscall takes a pointer to a struct like:
   451  // struct {
   452  //	fn    uintptr
   453  //	a1    uintptr
   454  //	a2    uintptr
   455  //	a3    uintptr
   456  //	r1    uintptr
   457  //	r2    uintptr
   458  //	err   uintptr
   459  // }
   460  // syscall must be called on the g0 stack with the
   461  // C calling convention (use libcCall).
   462  //
   463  // syscall expects a 32-bit result and tests for 32-bit -1
   464  // to decide there was an error.
   465  TEXT runtime·syscall(SB),NOSPLIT,$0
   466  	PUSHQ	BP
   467  	MOVQ	SP, BP
   468  	SUBQ	$16, SP
   469  	MOVQ	(0*8)(DI), CX // fn
   470  	MOVQ	(2*8)(DI), SI // a2
   471  	MOVQ	(3*8)(DI), DX // a3
   472  	MOVQ	DI, (SP)
   473  	MOVQ	(1*8)(DI), DI // a1
   474  	XORL	AX, AX	      // vararg: say "no float args"
   475  
   476  	CALL	CX
   477  
   478  	MOVQ	(SP), DI
   479  	MOVQ	AX, (4*8)(DI) // r1
   480  	MOVQ	DX, (5*8)(DI) // r2
   481  
   482  	// Standard libc functions return -1 on error
   483  	// and set errno.
   484  	CMPL	AX, $-1	      // Note: high 32 bits are junk
   485  	JNE	ok
   486  
   487  	// Get error code from libc.
   488  	CALL	libc_errno(SB)
   489  	MOVLQSX	(AX), AX
   490  	MOVQ	(SP), DI
   491  	MOVQ	AX, (6*8)(DI) // err
   492  
   493  ok:
   494  	XORL	AX, AX        // no error (it's ignored anyway)
   495  	MOVQ	BP, SP
   496  	POPQ	BP
   497  	RET
   498  
   499  // syscallX calls a function in libc on behalf of the syscall package.
   500  // syscallX takes a pointer to a struct like:
   501  // struct {
   502  //	fn    uintptr
   503  //	a1    uintptr
   504  //	a2    uintptr
   505  //	a3    uintptr
   506  //	r1    uintptr
   507  //	r2    uintptr
   508  //	err   uintptr
   509  // }
   510  // syscallX must be called on the g0 stack with the
   511  // C calling convention (use libcCall).
   512  //
   513  // syscallX is like syscall but expects a 64-bit result
   514  // and tests for 64-bit -1 to decide there was an error.
   515  TEXT runtime·syscallX(SB),NOSPLIT,$0
   516  	PUSHQ	BP
   517  	MOVQ	SP, BP
   518  	SUBQ	$16, SP
   519  	MOVQ	(0*8)(DI), CX // fn
   520  	MOVQ	(2*8)(DI), SI // a2
   521  	MOVQ	(3*8)(DI), DX // a3
   522  	MOVQ	DI, (SP)
   523  	MOVQ	(1*8)(DI), DI // a1
   524  	XORL	AX, AX	      // vararg: say "no float args"
   525  
   526  	CALL	CX
   527  
   528  	MOVQ	(SP), DI
   529  	MOVQ	AX, (4*8)(DI) // r1
   530  	MOVQ	DX, (5*8)(DI) // r2
   531  
   532  	// Standard libc functions return -1 on error
   533  	// and set errno.
   534  	CMPQ	AX, $-1
   535  	JNE	ok
   536  
   537  	// Get error code from libc.
   538  	CALL	libc_errno(SB)
   539  	MOVLQSX	(AX), AX
   540  	MOVQ	(SP), DI
   541  	MOVQ	AX, (6*8)(DI) // err
   542  
   543  ok:
   544  	XORL	AX, AX        // no error (it's ignored anyway)
   545  	MOVQ	BP, SP
   546  	POPQ	BP
   547  	RET
   548  
   549  // syscall6 calls a function in libc on behalf of the syscall package.
   550  // syscall6 takes a pointer to a struct like:
   551  // struct {
   552  //	fn    uintptr
   553  //	a1    uintptr
   554  //	a2    uintptr
   555  //	a3    uintptr
   556  //	a4    uintptr
   557  //	a5    uintptr
   558  //	a6    uintptr
   559  //	r1    uintptr
   560  //	r2    uintptr
   561  //	err   uintptr
   562  // }
   563  // syscall6 must be called on the g0 stack with the
   564  // C calling convention (use libcCall).
   565  //
   566  // syscall6 expects a 32-bit result and tests for 32-bit -1
   567  // to decide there was an error.
   568  TEXT runtime·syscall6(SB),NOSPLIT,$0
   569  	PUSHQ	BP
   570  	MOVQ	SP, BP
   571  	SUBQ	$16, SP
   572  	MOVQ	(0*8)(DI), R11// fn
   573  	MOVQ	(2*8)(DI), SI // a2
   574  	MOVQ	(3*8)(DI), DX // a3
   575  	MOVQ	(4*8)(DI), CX // a4
   576  	MOVQ	(5*8)(DI), R8 // a5
   577  	MOVQ	(6*8)(DI), R9 // a6
   578  	MOVQ	DI, (SP)
   579  	MOVQ	(1*8)(DI), DI // a1
   580  	XORL	AX, AX	      // vararg: say "no float args"
   581  
   582  	CALL	R11
   583  
   584  	MOVQ	(SP), DI
   585  	MOVQ	AX, (7*8)(DI) // r1
   586  	MOVQ	DX, (8*8)(DI) // r2
   587  
   588  	CMPL	AX, $-1
   589  	JNE	ok
   590  
   591  	CALL	libc_errno(SB)
   592  	MOVLQSX	(AX), AX
   593  	MOVQ	(SP), DI
   594  	MOVQ	AX, (9*8)(DI) // err
   595  
   596  ok:
   597  	XORL	AX, AX        // no error (it's ignored anyway)
   598  	MOVQ	BP, SP
   599  	POPQ	BP
   600  	RET
   601  
   602  // syscall6X calls a function in libc on behalf of the syscall package.
   603  // syscall6X takes a pointer to a struct like:
   604  // struct {
   605  //	fn    uintptr
   606  //	a1    uintptr
   607  //	a2    uintptr
   608  //	a3    uintptr
   609  //	a4    uintptr
   610  //	a5    uintptr
   611  //	a6    uintptr
   612  //	r1    uintptr
   613  //	r2    uintptr
   614  //	err   uintptr
   615  // }
   616  // syscall6X must be called on the g0 stack with the
   617  // C calling convention (use libcCall).
   618  //
   619  // syscall6X is like syscall6 but expects a 64-bit result
   620  // and tests for 64-bit -1 to decide there was an error.
   621  TEXT runtime·syscall6X(SB),NOSPLIT,$0
   622  	PUSHQ	BP
   623  	MOVQ	SP, BP
   624  	SUBQ	$16, SP
   625  	MOVQ	(0*8)(DI), R11// fn
   626  	MOVQ	(2*8)(DI), SI // a2
   627  	MOVQ	(3*8)(DI), DX // a3
   628  	MOVQ	(4*8)(DI), CX // a4
   629  	MOVQ	(5*8)(DI), R8 // a5
   630  	MOVQ	(6*8)(DI), R9 // a6
   631  	MOVQ	DI, (SP)
   632  	MOVQ	(1*8)(DI), DI // a1
   633  	XORL	AX, AX	      // vararg: say "no float args"
   634  
   635  	CALL	R11
   636  
   637  	MOVQ	(SP), DI
   638  	MOVQ	AX, (7*8)(DI) // r1
   639  	MOVQ	DX, (8*8)(DI) // r2
   640  
   641  	CMPQ	AX, $-1
   642  	JNE	ok
   643  
   644  	CALL	libc_errno(SB)
   645  	MOVLQSX	(AX), AX
   646  	MOVQ	(SP), DI
   647  	MOVQ	AX, (9*8)(DI) // err
   648  
   649  ok:
   650  	XORL	AX, AX        // no error (it's ignored anyway)
   651  	MOVQ	BP, SP
   652  	POPQ	BP
   653  	RET
   654  
   655  // syscall10 calls a function in libc on behalf of the syscall package.
   656  // syscall10 takes a pointer to a struct like:
   657  // struct {
   658  //	fn    uintptr
   659  //	a1    uintptr
   660  //	a2    uintptr
   661  //	a3    uintptr
   662  //	a4    uintptr
   663  //	a5    uintptr
   664  //	a6    uintptr
   665  //	a7    uintptr
   666  //	a8    uintptr
   667  //	a9    uintptr
   668  //	a10   uintptr
   669  //	r1    uintptr
   670  //	r2    uintptr
   671  //	err   uintptr
   672  // }
   673  // syscall10 must be called on the g0 stack with the
   674  // C calling convention (use libcCall).
   675  TEXT runtime·syscall10(SB),NOSPLIT,$0
   676  	PUSHQ	BP
   677  	MOVQ	SP, BP
   678  	SUBQ    $48, SP
   679  
   680  	// Arguments a1 to a6 get passed in registers, with a7 onwards being
   681  	// passed via the stack per the x86-64 System V ABI
   682  	// (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf).
   683  	MOVQ	(7*8)(DI), R10	// a7
   684  	MOVQ	(8*8)(DI), R11	// a8
   685  	MOVQ	(9*8)(DI), R12	// a9
   686  	MOVQ	(10*8)(DI), R13	// a10
   687  	MOVQ	R10, (0*8)(SP)	// a7
   688  	MOVQ	R11, (1*8)(SP)	// a8
   689  	MOVQ	R12, (2*8)(SP)	// a9
   690  	MOVQ	R13, (3*8)(SP)	// a10
   691  	MOVQ	(0*8)(DI), R11	// fn
   692  	MOVQ	(2*8)(DI), SI	// a2
   693  	MOVQ	(3*8)(DI), DX	// a3
   694  	MOVQ	(4*8)(DI), CX	// a4
   695  	MOVQ	(5*8)(DI), R8	// a5
   696  	MOVQ	(6*8)(DI), R9	// a6
   697  	MOVQ	DI, (4*8)(SP)
   698  	MOVQ	(1*8)(DI), DI	// a1
   699  	XORL	AX, AX	     	// vararg: say "no float args"
   700  
   701  	CALL	R11
   702  
   703  	MOVQ	(4*8)(SP), DI
   704  	MOVQ	AX, (11*8)(DI) // r1
   705  	MOVQ	DX, (12*8)(DI) // r2
   706  
   707  	CMPL	AX, $-1
   708  	JNE	ok
   709  
   710  	CALL	libc_errno(SB)
   711  	MOVLQSX	(AX), AX
   712  	MOVQ	(4*8)(SP), DI
   713  	MOVQ	AX, (13*8)(DI) // err
   714  
   715  ok:
   716  	XORL	AX, AX        // no error (it's ignored anyway)
   717  	MOVQ	BP, SP
   718  	POPQ	BP
   719  	RET
   720  
   721  // syscall10X calls a function in libc on behalf of the syscall package.
   722  // syscall10X takes a pointer to a struct like:
   723  // struct {
   724  //	fn    uintptr
   725  //	a1    uintptr
   726  //	a2    uintptr
   727  //	a3    uintptr
   728  //	a4    uintptr
   729  //	a5    uintptr
   730  //	a6    uintptr
   731  //	a7    uintptr
   732  //	a8    uintptr
   733  //	a9    uintptr
   734  //	a10   uintptr
   735  //	r1    uintptr
   736  //	r2    uintptr
   737  //	err   uintptr
   738  // }
   739  // syscall10X must be called on the g0 stack with the
   740  // C calling convention (use libcCall).
   741  //
   742  // syscall10X is like syscall10 but expects a 64-bit result
   743  // and tests for 64-bit -1 to decide there was an error.
   744  TEXT runtime·syscall10X(SB),NOSPLIT,$0
   745  	PUSHQ	BP
   746  	MOVQ	SP, BP
   747  	SUBQ    $48, SP
   748  
   749  	// Arguments a1 to a6 get passed in registers, with a7 onwards being
   750  	// passed via the stack per the x86-64 System V ABI
   751  	// (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf).
   752  	MOVQ	(7*8)(DI), R10	// a7
   753  	MOVQ	(8*8)(DI), R11	// a8
   754  	MOVQ	(9*8)(DI), R12	// a9
   755  	MOVQ	(10*8)(DI), R13	// a10
   756  	MOVQ	R10, (0*8)(SP)	// a7
   757  	MOVQ	R11, (1*8)(SP)	// a8
   758  	MOVQ	R12, (2*8)(SP)	// a9
   759  	MOVQ	R13, (3*8)(SP)	// a10
   760  	MOVQ	(0*8)(DI), R11	// fn
   761  	MOVQ	(2*8)(DI), SI	// a2
   762  	MOVQ	(3*8)(DI), DX	// a3
   763  	MOVQ	(4*8)(DI), CX	// a4
   764  	MOVQ	(5*8)(DI), R8	// a5
   765  	MOVQ	(6*8)(DI), R9	// a6
   766  	MOVQ	DI, (4*8)(SP)
   767  	MOVQ	(1*8)(DI), DI	// a1
   768  	XORL	AX, AX	     	// vararg: say "no float args"
   769  
   770  	CALL	R11
   771  
   772  	MOVQ	(4*8)(SP), DI
   773  	MOVQ	AX, (11*8)(DI) // r1
   774  	MOVQ	DX, (12*8)(DI) // r2
   775  
   776  	CMPQ	AX, $-1
   777  	JNE	ok
   778  
   779  	CALL	libc_errno(SB)
   780  	MOVLQSX	(AX), AX
   781  	MOVQ	(4*8)(SP), DI
   782  	MOVQ	AX, (13*8)(DI) // err
   783  
   784  ok:
   785  	XORL	AX, AX        // no error (it's ignored anyway)
   786  	MOVQ	BP, SP
   787  	POPQ	BP
   788  	RET