Text file src/runtime/sys_openbsd_386.s

     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 386, 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·setldt(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,$28
    25  	NOP	SP	// tell vet SP changed - stop checking offsets
    26  
    27  	// We are already on m's g0 stack.
    28  
    29  	// Save callee-save registers.
    30  	MOVL	BX, bx-4(SP)
    31  	MOVL	BP, bp-8(SP)
    32  	MOVL	SI, si-12(SP)
    33  	MOVL	DI, di-16(SP)
    34  
    35  	MOVL	32(SP), AX	// m
    36  	MOVL	m_g0(AX), DX
    37  	get_tls(CX)
    38  	MOVL	DX, g(CX)
    39  
    40  	CALL	runtime·mstart(SB)
    41  
    42  	// Restore callee-save registers.
    43  	MOVL	di-16(SP), DI
    44  	MOVL	si-12(SP), SI
    45  	MOVL	bp-8(SP),  BP
    46  	MOVL	bx-4(SP),  BX
    47  
    48  	// Go is all done with this OS thread.
    49  	// Tell pthread everything is ok (we never join with this thread, so
    50  	// the value here doesn't really matter).
    51  	MOVL	$0, AX
    52  	RET
    53  
    54  TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
    55  	MOVL	fn+0(FP), AX
    56  	MOVL	sig+4(FP), BX
    57  	MOVL	info+8(FP), CX
    58  	MOVL	ctx+12(FP), DX
    59  	MOVL	SP, SI
    60  	SUBL	$32, SP
    61  	ANDL	$~15, SP	// align stack: handler might be a C function
    62  	MOVL	BX, 0(SP)
    63  	MOVL	CX, 4(SP)
    64  	MOVL	DX, 8(SP)
    65  	MOVL	SI, 12(SP)	// save SI: handler might be a Go function
    66  	CALL	AX
    67  	MOVL	12(SP), AX
    68  	MOVL	AX, SP
    69  	RET
    70  
    71  // Called by OS using C ABI.
    72  TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$28
    73  	NOP	SP	// tell vet SP changed - stop checking offsets
    74  	// Save callee-saved C registers, since the caller may be a C signal handler.
    75  	MOVL	BX, bx-4(SP)
    76  	MOVL	BP, bp-8(SP)
    77  	MOVL	SI, si-12(SP)
    78  	MOVL	DI, di-16(SP)
    79  	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
    80  	// modify them.
    81  
    82  	MOVL	32(SP), BX // signo
    83  	MOVL	BX, 0(SP)
    84  	MOVL	36(SP), BX // info
    85  	MOVL	BX, 4(SP)
    86  	MOVL	40(SP), BX // context
    87  	MOVL	BX, 8(SP)
    88  	CALL	runtime·sigtrampgo(SB)
    89  
    90  	MOVL	di-16(SP), DI
    91  	MOVL	si-12(SP), SI
    92  	MOVL	bp-8(SP),  BP
    93  	MOVL	bx-4(SP),  BX
    94  	RET
    95  
    96  // These trampolines help convert from Go calling convention to C calling convention.
    97  // They should be called with asmcgocall - note that while asmcgocall does
    98  // stack alignment, creation of a frame undoes it again.
    99  // A pointer to the arguments is passed on the stack.
   100  // A single int32 result is returned in AX.
   101  // (For more results, make an args/results structure.)
   102  TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
   103  	PUSHL	BP
   104  	MOVL	SP, BP
   105  	SUBL	$4, SP
   106  	MOVL	12(SP), DX		// pointer to args
   107  	MOVL	0(DX), AX
   108  	MOVL	AX, 0(SP)		// arg 1 - attr
   109  	CALL	libc_pthread_attr_init(SB)
   110  	MOVL	BP, SP
   111  	POPL	BP
   112  	RET
   113  
   114  TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0
   115  	PUSHL	BP
   116  	MOVL	SP, BP
   117  	SUBL	$4, SP
   118  	MOVL	12(SP), DX		// pointer to args
   119  	MOVL	0(DX), AX
   120  	MOVL	AX, 0(SP)		// arg 1 - attr
   121  	CALL	libc_pthread_attr_destroy(SB)
   122  	MOVL	BP, SP
   123  	POPL	BP
   124  	RET
   125  
   126  TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
   127  	PUSHL	BP
   128  	MOVL	SP, BP
   129  	SUBL	$8, SP
   130  	MOVL	16(SP), DX		// pointer to args
   131  	MOVL	0(DX), AX
   132  	MOVL	4(DX), BX
   133  	MOVL	AX, 0(SP)		// arg 1 - attr
   134  	MOVL	BX, 4(SP)		// arg 2 - size
   135  	CALL	libc_pthread_attr_getstacksize(SB)
   136  	MOVL	BP, SP
   137  	POPL	BP
   138  	RET
   139  
   140  TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
   141  	PUSHL	BP
   142  	MOVL	SP, BP
   143  	SUBL	$8, SP
   144  	MOVL	16(SP), DX		// pointer to args
   145  	MOVL	0(DX), AX
   146  	MOVL	4(DX), BX
   147  	MOVL	AX, 0(SP)		// arg 1 - attr
   148  	MOVL	BX, 4(SP)		// arg 2 - state
   149  	CALL	libc_pthread_attr_setdetachstate(SB)
   150  	MOVL	BP, SP
   151  	POPL	BP
   152  	RET
   153  
   154  TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
   155  	PUSHL	BP
   156  	MOVL	SP, BP
   157  	SUBL	$20, SP
   158  	MOVL	28(SP), DX		// pointer to args
   159  	LEAL	16(SP), AX
   160  	MOVL	AX, 0(SP)		// arg 1 - &threadid (discarded)
   161  	MOVL	0(DX), AX
   162  	MOVL	4(DX), BX
   163  	MOVL	8(DX), CX
   164  	MOVL	AX, 4(SP)		// arg 2 - attr
   165  	MOVL	BX, 8(SP)		// arg 3 - start
   166  	MOVL	CX, 12(SP)		// arg 4 - arg
   167  	CALL	libc_pthread_create(SB)
   168  	MOVL	BP, SP
   169  	POPL	BP
   170  	RET
   171  
   172  TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
   173  	PUSHL	BP
   174  	MOVL	SP, BP
   175  	SUBL	$12, SP
   176  	MOVL	20(SP), DX		// pointer to args
   177  	MOVL	0(DX), AX
   178  	MOVL	4(DX), BX
   179  	MOVL	AX, 0(SP)		// arg 1 - tid
   180  	MOVL	BX, 4(SP)		// arg 2 - signal
   181  	MOVL	$0, 8(SP)		// arg 3 - tcb
   182  	CALL	libc_thrkill(SB)
   183  	MOVL	BP, SP
   184  	POPL	BP
   185  	RET
   186  
   187  TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
   188  	PUSHL	BP
   189  	MOVL	SP, BP
   190  	SUBL	$20, SP
   191  	MOVL	28(SP), DX		// pointer to args
   192  	MOVL	0(DX), AX
   193  	MOVL	4(DX), BX
   194  	MOVL	8(DX), CX
   195  	MOVL	AX, 0(SP)		// arg 1 - id
   196  	MOVL	BX, 4(SP)		// arg 2 - clock_id
   197  	MOVL	CX, 8(SP)		// arg 3 - abstime
   198  	MOVL	12(DX), AX
   199  	MOVL	16(DX), BX
   200  	MOVL	AX, 12(SP)		// arg 4 - lock
   201  	MOVL	BX, 16(SP)		// arg 5 - abort
   202  	CALL	libc_thrsleep(SB)
   203  	MOVL	BP, SP
   204  	POPL	BP
   205  	RET
   206  
   207  TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
   208  	PUSHL	BP
   209  	MOVL	SP, BP
   210  	SUBL	$8, SP
   211  	MOVL	16(SP), DX		// pointer to args
   212  	MOVL	0(DX), AX
   213  	MOVL	4(DX), BX
   214  	MOVL	AX, 0(SP)		// arg 1 - id
   215  	MOVL	BX, 4(SP)		// arg 2 - count
   216  	CALL	libc_thrwakeup(SB)
   217  	MOVL	BP, SP
   218  	POPL	BP
   219  	RET
   220  
   221  TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
   222  	PUSHL	BP
   223  	MOVL	SP, BP
   224  	SUBL	$4, SP
   225  	MOVL	12(SP), DX		// pointer to args
   226  	MOVL	0(DX), AX
   227  	MOVL	AX, 0(SP)		// arg 1 - status
   228  	CALL	libc_exit(SB)
   229  	MOVL	$0xf1, 0xf1		// crash on failure
   230  	MOVL	BP, SP
   231  	POPL	BP
   232  	RET
   233  
   234  TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
   235  	PUSHL	BP
   236  	CALL	libc_getthrid(SB)
   237  	NOP	SP			// tell vet SP changed - stop checking offsets
   238  	MOVL	8(SP), DX		// pointer to return value
   239  	MOVL	AX, 0(DX)
   240  	POPL	BP
   241  	RET
   242  
   243  TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
   244  	PUSHL	BP
   245  	MOVL	SP, BP
   246  	SUBL	$8, SP
   247  	MOVL	16(SP), DX
   248  	MOVL	0(DX), BX
   249  	CALL	libc_getpid(SB)
   250  	MOVL	AX, 0(SP)		// arg 1 - pid
   251  	MOVL	BX, 4(SP)		// arg 2 - signal
   252  	CALL	libc_kill(SB)
   253  	MOVL	BP, SP
   254  	POPL	BP
   255  	RET
   256  
   257  TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
   258  	PUSHL	BP
   259  	MOVL	SP, BP
   260  	CALL	libc_sched_yield(SB)
   261  	MOVL	BP, SP
   262  	POPL	BP
   263  	RET
   264  
   265  TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
   266  	PUSHL	BP
   267  	MOVL	SP, BP
   268  	SUBL	$32, SP
   269  	MOVL	40(SP), DX		// pointer to args
   270  	MOVL	0(DX), AX
   271  	MOVL	4(DX), BX
   272  	MOVL	8(DX), CX
   273  	MOVL	AX, 0(SP)		// arg 1 - addr
   274  	MOVL	BX, 4(SP)		// arg 2 - len
   275  	MOVL	CX, 8(SP)		// arg 3 - prot
   276  	MOVL	12(DX), AX
   277  	MOVL	16(DX), BX
   278  	MOVL	20(DX), CX
   279  	MOVL	AX, 12(SP)		// arg 4 - flags
   280  	MOVL	BX, 16(SP)		// arg 5 - fid
   281  	MOVL	$0, 20(SP)		// pad
   282  	MOVL	CX, 24(SP)		// arg 6 - offset (low 32 bits)
   283  	MOVL	$0, 28(SP)		// offset (high 32 bits)
   284  	CALL	libc_mmap(SB)
   285  	MOVL	$0, BX
   286  	CMPL	AX, $-1
   287  	JNE	ok
   288  	CALL	libc_errno(SB)
   289  	MOVL	(AX), BX
   290  	MOVL	$0, AX
   291  ok:
   292  	MOVL	40(SP), DX
   293  	MOVL	AX, 24(DX)
   294  	MOVL	BX, 28(DX)
   295  	MOVL	BP, SP
   296  	POPL	BP
   297  	RET
   298  
   299  TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
   300  	PUSHL	BP
   301  	MOVL	SP, BP
   302  	SUBL	$8, SP
   303  	MOVL	16(SP), DX		// pointer to args
   304  	MOVL	0(DX), AX
   305  	MOVL	4(DX), BX
   306  	MOVL	AX, 0(SP)		// arg 1 - addr
   307  	MOVL	BX, 4(SP)		// arg 2 - len
   308  	CALL	libc_munmap(SB)
   309  	CMPL	AX, $-1
   310  	JNE	2(PC)
   311  	MOVL	$0xf1, 0xf1		// crash on failure
   312  	MOVL	BP, SP
   313  	POPL	BP
   314  	RET
   315  
   316  TEXT runtime·madvise_trampoline(SB),NOSPLIT,$0
   317  	PUSHL	BP
   318  	MOVL	SP, BP
   319  	SUBL	$12, SP
   320  	MOVL	20(SP), DX		// pointer to args
   321  	MOVL	0(DX), AX
   322  	MOVL	4(DX), BX
   323  	MOVL	8(DX), CX
   324  	MOVL	AX, 0(SP)		// arg 1 - addr
   325  	MOVL	BX, 4(SP)		// arg 2 - len
   326  	MOVL	CX, 8(SP)		// arg 3 - advice
   327  	CALL	libc_madvise(SB)
   328  	// ignore failure - maybe pages are locked
   329  	MOVL	BP, SP
   330  	POPL	BP
   331  	RET
   332  
   333  TEXT runtime·open_trampoline(SB),NOSPLIT,$0
   334  	PUSHL	BP
   335  	MOVL	SP, BP
   336  	SUBL	$16, SP
   337  	MOVL	24(SP), DX		// pointer to args
   338  	MOVL	0(DX), AX
   339  	MOVL	4(DX), BX
   340  	MOVL	8(DX), CX
   341  	MOVL	AX, 0(SP)		// arg 1 - path
   342  	MOVL	BX, 4(SP)		// arg 2 - flags
   343  	MOVL	CX, 8(SP)		// arg 3 - mode
   344  	MOVL	$0, 12(SP)		// vararg
   345  	CALL	libc_open(SB)
   346  	MOVL	BP, SP
   347  	POPL	BP
   348  	RET
   349  
   350  TEXT runtime·close_trampoline(SB),NOSPLIT,$0
   351  	PUSHL	BP
   352  	MOVL	SP, BP
   353  	SUBL	$4, SP
   354  	MOVL	12(SP), DX
   355  	MOVL	0(DX), AX
   356  	MOVL	AX, 0(SP)		// arg 1 - fd
   357  	CALL	libc_close(SB)
   358  	MOVL	BP, SP
   359  	POPL	BP
   360  	RET
   361  
   362  TEXT runtime·read_trampoline(SB),NOSPLIT,$0
   363  	PUSHL	BP
   364  	MOVL	SP, BP
   365  	SUBL	$12, SP
   366  	MOVL	20(SP), DX		// pointer to args
   367  	MOVL	0(DX), AX
   368  	MOVL	4(DX), BX
   369  	MOVL	8(DX), CX
   370  	MOVL	AX, 0(SP)		// arg 1 - fd
   371  	MOVL	BX, 4(SP)		// arg 2 - buf
   372  	MOVL	CX, 8(SP)		// arg 3 - count
   373  	CALL	libc_read(SB)
   374  	CMPL	AX, $-1
   375  	JNE	noerr
   376  	CALL	libc_errno(SB)
   377  	MOVL	(AX), AX
   378  	NEGL	AX			// caller expects negative errno
   379  noerr:
   380  	MOVL	BP, SP
   381  	POPL	BP
   382  	RET
   383  
   384  TEXT runtime·write_trampoline(SB),NOSPLIT,$0
   385  	PUSHL	BP
   386  	MOVL	SP, BP
   387  	SUBL	$12, SP
   388  	MOVL	20(SP), DX		// pointer to args
   389  	MOVL	0(DX), AX
   390  	MOVL	4(DX), BX
   391  	MOVL	8(DX), CX
   392  	MOVL	AX, 0(SP)		// arg 1 - fd
   393  	MOVL	BX, 4(SP)		// arg 2 - buf
   394  	MOVL	CX, 8(SP)		// arg 3 - count
   395  	CALL	libc_write(SB)
   396  	CMPL	AX, $-1
   397  	JNE	noerr
   398  	CALL	libc_errno(SB)
   399  	MOVL	(AX), AX
   400  	NEGL	AX			// caller expects negative errno
   401  noerr:
   402  	MOVL	BP, SP
   403  	POPL	BP
   404  	RET
   405  
   406  TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
   407  	PUSHL	BP
   408  	MOVL	SP, BP
   409  	SUBL	$8, SP
   410  	MOVL	16(SP), DX		// pointer to args
   411  	MOVL	0(DX), AX
   412  	MOVL	4(DX), BX
   413  	MOVL	AX, 0(SP)		// arg 1 - fds
   414  	MOVL	BX, 4(SP)		// arg 2 - flags
   415  	CALL	libc_pipe2(SB)
   416  	CMPL	AX, $-1
   417  	JNE	noerr
   418  	CALL	libc_errno(SB)
   419  	MOVL	(AX), AX
   420  	NEGL	AX			// caller expects negative errno
   421  noerr:
   422  	MOVL	BP, SP
   423  	POPL	BP
   424  	RET
   425  
   426  TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
   427  	PUSHL	BP
   428  	MOVL	SP, BP
   429  	SUBL	$12, SP
   430  	MOVL	20(SP), DX		// pointer to args
   431  	MOVL	0(DX), AX
   432  	MOVL	4(DX), BX
   433  	MOVL	8(DX), CX
   434  	MOVL	AX, 0(SP)		// arg 1 - which
   435  	MOVL	BX, 4(SP)		// arg 2 - new
   436  	MOVL	CX, 8(SP)		// arg 3 - old
   437  	CALL	libc_setitimer(SB)
   438  	MOVL	BP, SP
   439  	POPL	BP
   440  	RET
   441  
   442  TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
   443  	PUSHL	BP
   444  	MOVL	SP, BP
   445  	SUBL	$4, SP
   446  	MOVL	12(SP), DX		// pointer to args
   447  	MOVL	0(DX), AX
   448  	MOVL	AX, 0(SP)
   449  	CALL	libc_usleep(SB)
   450  	MOVL	BP, SP
   451  	POPL	BP
   452  	RET
   453  
   454  TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
   455  	PUSHL	BP
   456  	MOVL	SP, BP
   457  	SUBL	$24, SP
   458  	MOVL	32(SP), DX		// pointer to args
   459  	MOVL	0(DX), AX
   460  	MOVL	4(DX), BX
   461  	MOVL	8(DX), CX
   462  	MOVL	AX, 0(SP)		// arg 1 - name
   463  	MOVL	BX, 4(SP)		// arg 2 - namelen
   464  	MOVL	CX, 8(SP)		// arg 3 - old
   465  	MOVL	12(DX), AX
   466  	MOVL	16(DX), BX
   467  	MOVL	20(DX), CX
   468  	MOVL	AX, 12(SP)		// arg 4 - oldlenp
   469  	MOVL	BX, 16(SP)		// arg 5 - newp
   470  	MOVL	CX, 20(SP)		// arg 6 - newlen
   471  	CALL	libc_sysctl(SB)
   472  	MOVL	BP, SP
   473  	POPL	BP
   474  	RET
   475  
   476  TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
   477  	PUSHL	BP
   478  	MOVL	SP, BP
   479  	CALL	libc_kqueue(SB)
   480  	MOVL	BP, SP
   481  	POPL	BP
   482  	RET
   483  
   484  TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
   485  	PUSHL	BP
   486  	MOVL	SP, BP
   487  	SUBL	$24, SP
   488  	MOVL	32(SP), DX		// pointer to args
   489  	MOVL	0(DX), AX
   490  	MOVL	4(DX), BX
   491  	MOVL	8(DX), CX
   492  	MOVL	AX, 0(SP)		// arg 1 - kq
   493  	MOVL	BX, 4(SP)		// arg 2 - keventt
   494  	MOVL	CX, 8(SP)		// arg 3 - nch
   495  	MOVL	12(DX), AX
   496  	MOVL	16(DX), BX
   497  	MOVL	20(DX), CX
   498  	MOVL	AX, 12(SP)		// arg 4 - ev
   499  	MOVL	BX, 16(SP)		// arg 5 - nev
   500  	MOVL	CX, 20(SP)		// arg 6 - ts
   501  	CALL	libc_kevent(SB)
   502  	CMPL	AX, $-1
   503  	JNE	noerr
   504  	CALL	libc_errno(SB)
   505  	MOVL	(AX), AX
   506  	NEGL	AX			// caller expects negative errno
   507  noerr:
   508  	MOVL	BP, SP
   509  	POPL	BP
   510  	RET
   511  
   512  TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
   513  	PUSHL	BP
   514  	MOVL	SP, BP
   515  	SUBL	$8, SP
   516  	MOVL	16(SP), DX		// pointer to args
   517  	MOVL	0(DX), AX
   518  	MOVL	4(DX), BX
   519  	MOVL	AX, 0(SP)		// arg 1 - tp
   520  	MOVL	BX, 4(SP)		// arg 2 - clock_id
   521  	CALL	libc_clock_gettime(SB)
   522  	CMPL	AX, $-1
   523  	JNE	noerr
   524  	CALL	libc_errno(SB)
   525  	MOVL	(AX), AX
   526  	NEGL	AX			// caller expects negative errno
   527  noerr:
   528  	MOVL	BP, SP
   529  	POPL	BP
   530  	RET
   531  
   532  TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
   533  	PUSHL	BP
   534  	MOVL	SP, BP
   535  	SUBL	$16, SP
   536  	MOVL	24(SP), DX		// pointer to args
   537  	MOVL	0(DX), AX
   538  	MOVL	4(DX), BX
   539  	MOVL	8(DX), CX
   540  	MOVL	AX, 0(SP)		// arg 1 - fd
   541  	MOVL	BX, 4(SP)		// arg 2 - cmd
   542  	MOVL	CX, 8(SP)		// arg 3 - arg
   543  	MOVL	$0, 12(SP)		// vararg
   544  	CALL	libc_fcntl(SB)
   545  	MOVL	BP, SP
   546  	POPL	BP
   547  	RET
   548  
   549  TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
   550  	PUSHL	BP
   551  	MOVL	SP, BP
   552  	SUBL	$12, SP
   553  	MOVL	20(SP), DX		// pointer to args
   554  	MOVL	0(DX), AX
   555  	MOVL	4(DX), BX
   556  	MOVL	8(DX), CX
   557  	MOVL	AX, 0(SP)		// arg 1 - sig
   558  	MOVL	BX, 4(SP)		// arg 2 - new
   559  	MOVL	CX, 8(SP)		// arg 3 - old
   560  	CALL	libc_sigaction(SB)
   561  	CMPL	AX, $-1
   562  	JNE	2(PC)
   563  	MOVL	$0xf1, 0xf1		// crash on failure
   564  	MOVL	BP, SP
   565  	POPL	BP
   566  	RET
   567  
   568  TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
   569  	PUSHL	BP
   570  	MOVL	SP, BP
   571  	SUBL	$12, SP
   572  	MOVL	20(SP), DX		// pointer to args
   573  	MOVL	0(DX), AX
   574  	MOVL	4(DX), BX
   575  	MOVL	8(DX), CX
   576  	MOVL	AX, 0(SP)		// arg 1 - how
   577  	MOVL	BX, 4(SP)		// arg 2 - new
   578  	MOVL	CX, 8(SP)		// arg 3 - old
   579  	CALL	libc_pthread_sigmask(SB)
   580  	CMPL	AX, $-1
   581  	JNE	2(PC)
   582  	MOVL	$0xf1, 0xf1		// crash on failure
   583  	MOVL	BP, SP
   584  	POPL	BP
   585  	RET
   586  
   587  TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
   588  	PUSHL	BP
   589  	MOVL	SP, BP
   590  	SUBL	$8, SP
   591  	MOVL	16(SP), DX		// pointer to args
   592  	MOVL	0(DX), AX
   593  	MOVL	4(DX), BX
   594  	MOVL	AX, 0(SP)		// arg 1 - new
   595  	MOVL	BX, 4(SP)		// arg 2 - old
   596  	CALL	libc_sigaltstack(SB)
   597  	CMPL	AX, $-1
   598  	JNE	2(PC)
   599  	MOVL	$0xf1, 0xf1		// crash on failure
   600  	MOVL	BP, SP
   601  	POPL	BP
   602  	RET
   603  
   604  // syscall calls a function in libc on behalf of the syscall package.
   605  // syscall takes a pointer to a struct like:
   606  // struct {
   607  //	fn    uintptr
   608  //	a1    uintptr
   609  //	a2    uintptr
   610  //	a3    uintptr
   611  //	r1    uintptr
   612  //	r2    uintptr
   613  //	err   uintptr
   614  // }
   615  // syscall must be called on the g0 stack with the
   616  // C calling convention (use libcCall).
   617  //
   618  // syscall expects a 32-bit result and tests for 32-bit -1
   619  // to decide there was an error.
   620  TEXT runtime·syscall(SB),NOSPLIT,$0
   621  	PUSHL	BP
   622  	MOVL	SP, BP
   623  
   624  	SUBL	$12, SP
   625  	MOVL	20(SP), BX		// pointer to args
   626  
   627  	MOVL	(1*4)(BX), AX
   628  	MOVL	(2*4)(BX), CX
   629  	MOVL	(3*4)(BX), DX
   630  	MOVL	AX, (0*4)(SP)		// a1
   631  	MOVL	CX, (1*4)(SP)		// a2
   632  	MOVL	DX, (2*4)(SP)		// a3
   633  
   634  	MOVL	(0*4)(BX), AX		// fn
   635  	CALL	AX
   636  
   637  	MOVL	AX, (4*4)(BX)		// r1
   638  	MOVL	DX, (5*4)(BX)		// r2
   639  
   640  	// Standard libc functions return -1 on error and set errno.
   641  	CMPL	AX, $-1
   642  	JNE	ok
   643  
   644  	// Get error code from libc.
   645  	CALL	libc_errno(SB)
   646  	MOVL	(AX), AX
   647  	MOVW	AX, (6*4)(BX)		// err
   648  
   649  ok:
   650  	MOVL	$0, AX			// no error (it's ignored anyway)
   651  	MOVL	BP, SP
   652  	POPL	BP
   653  	RET
   654  
   655  // syscallX calls a function in libc on behalf of the syscall package.
   656  // syscallX takes a pointer to a struct like:
   657  // struct {
   658  //	fn    uintptr
   659  //	a1    uintptr
   660  //	a2    uintptr
   661  //	a3    uintptr
   662  //	r1    uintptr
   663  //	r2    uintptr
   664  //	err   uintptr
   665  // }
   666  // syscallX must be called on the g0 stack with the
   667  // C calling convention (use libcCall).
   668  //
   669  // syscallX is like syscall but expects a 64-bit result
   670  // and tests for 64-bit -1 to decide there was an error.
   671  TEXT runtime·syscallX(SB),NOSPLIT,$0
   672  	PUSHL	BP
   673  	MOVL	SP, BP
   674  
   675  	SUBL	$12, SP
   676  	MOVL	20(SP), BX		// pointer to args
   677  
   678  	MOVL	(1*4)(BX), AX
   679  	MOVL	(2*4)(BX), CX
   680  	MOVL	(3*4)(BX), DX
   681  	MOVL	AX, (0*4)(SP)		// a1
   682  	MOVL	CX, (1*4)(SP)		// a2
   683  	MOVL	DX, (2*4)(SP)		// a3
   684  
   685  	MOVL	(0*4)(BX), AX		// fn
   686  	CALL	AX
   687  
   688  	MOVL	AX, (4*4)(BX)		// r1
   689  	MOVL	DX, (5*4)(BX)		// r2
   690  
   691  	// Standard libc functions return -1 on error and set errno.
   692  	CMPL	AX, $-1
   693  	JNE	ok
   694  	CMPL	DX, $-1
   695  	JNE	ok
   696  
   697  	// Get error code from libc.
   698  	CALL	libc_errno(SB)
   699  	MOVL	(AX), AX
   700  	MOVW	AX, (6*4)(BX)		// err
   701  
   702  ok:
   703  	MOVL	$0, AX			// no error (it's ignored anyway)
   704  	MOVL	BP, SP
   705  	POPL	BP
   706  	RET
   707  
   708  // syscall6 calls a function in libc on behalf of the syscall package.
   709  // syscall6 takes a pointer to a struct like:
   710  // struct {
   711  //	fn    uintptr
   712  //	a1    uintptr
   713  //	a2    uintptr
   714  //	a3    uintptr
   715  //	a4    uintptr
   716  //	a5    uintptr
   717  //	a6    uintptr
   718  //	r1    uintptr
   719  //	r2    uintptr
   720  //	err   uintptr
   721  // }
   722  // syscall6 must be called on the g0 stack with the
   723  // C calling convention (use libcCall).
   724  //
   725  // syscall6 expects a 32-bit result and tests for 32-bit -1
   726  // to decide there was an error.
   727  TEXT runtime·syscall6(SB),NOSPLIT,$0
   728  	PUSHL	BP
   729  	MOVL	SP, BP
   730  
   731  	SUBL	$24, SP
   732  	MOVL	32(SP), BX		// pointer to args
   733  
   734  	MOVL	(1*4)(BX), AX
   735  	MOVL	(2*4)(BX), CX
   736  	MOVL	(3*4)(BX), DX
   737  	MOVL	AX, (0*4)(SP)		// a1
   738  	MOVL	CX, (1*4)(SP)		// a2
   739  	MOVL	DX, (2*4)(SP)		// a3
   740  	MOVL	(4*4)(BX), AX
   741  	MOVL	(5*4)(BX), CX
   742  	MOVL	(6*4)(BX), DX
   743  	MOVL	AX, (3*4)(SP)		// a4
   744  	MOVL	CX, (4*4)(SP)		// a5
   745  	MOVL	DX, (5*4)(SP)		// a6
   746  
   747  	MOVL	(0*4)(BX), AX		// fn
   748  	CALL	AX
   749  
   750  	MOVL	AX, (7*4)(BX)		// r1
   751  	MOVL	DX, (8*4)(BX)		// r2
   752  
   753  	// Standard libc functions return -1 on error and set errno.
   754  	CMPL	AX, $-1
   755  	JNE	ok
   756  
   757  	// Get error code from libc.
   758  	CALL	libc_errno(SB)
   759  	MOVL	(AX), AX
   760  	MOVW	AX, (9*4)(BX)		// err
   761  
   762  ok:
   763  	MOVL	$0, AX			// no error (it's ignored anyway)
   764  	MOVL	BP, SP
   765  	POPL	BP
   766  	RET
   767  
   768  // syscall6X calls a function in libc on behalf of the syscall package.
   769  // syscall6X takes a pointer to a struct like:
   770  // struct {
   771  //	fn    uintptr
   772  //	a1    uintptr
   773  //	a2    uintptr
   774  //	a3    uintptr
   775  //	a4    uintptr
   776  //	a5    uintptr
   777  //	a6    uintptr
   778  //	r1    uintptr
   779  //	r2    uintptr
   780  //	err   uintptr
   781  // }
   782  // syscall6X must be called on the g0 stack with the
   783  // C calling convention (use libcCall).
   784  //
   785  // syscall6X is like syscall6 but expects a 64-bit result
   786  // and tests for 64-bit -1 to decide there was an error.
   787  TEXT runtime·syscall6X(SB),NOSPLIT,$0
   788  	PUSHL	BP
   789  	MOVL	SP, BP
   790  
   791  	SUBL	$24, SP
   792  	MOVL	32(SP), BX		// pointer to args
   793  
   794  	MOVL	(1*4)(BX), AX
   795  	MOVL	(2*4)(BX), CX
   796  	MOVL	(3*4)(BX), DX
   797  	MOVL	AX, (0*4)(SP)		// a1
   798  	MOVL	CX, (1*4)(SP)		// a2
   799  	MOVL	DX, (2*4)(SP)		// a3
   800  	MOVL	(4*4)(BX), AX
   801  	MOVL	(5*4)(BX), CX
   802  	MOVL	(6*4)(BX), DX
   803  	MOVL	AX, (3*4)(SP)		// a4
   804  	MOVL	CX, (4*4)(SP)		// a5
   805  	MOVL	DX, (5*4)(SP)		// a6
   806  
   807  	MOVL	(0*4)(BX), AX		// fn
   808  	CALL	AX
   809  
   810  	MOVL	AX, (7*4)(BX)		// r1
   811  	MOVL	DX, (8*4)(BX)		// r2
   812  
   813  	// Standard libc functions return -1 on error and set errno.
   814  	CMPL	AX, $-1
   815  	JNE	ok
   816  	CMPL	DX, $-1
   817  	JNE	ok
   818  
   819  	// Get error code from libc.
   820  	CALL	libc_errno(SB)
   821  	MOVL	(AX), AX
   822  	MOVW	AX, (9*4)(BX)		// err
   823  
   824  ok:
   825  	MOVL	$0, AX			// no error (it's ignored anyway)
   826  	MOVL	BP, SP
   827  	POPL	BP
   828  	RET
   829  
   830  // syscall10 calls a function in libc on behalf of the syscall package.
   831  // syscall10 takes a pointer to a struct like:
   832  // struct {
   833  //	fn    uintptr
   834  //	a1    uintptr
   835  //	a2    uintptr
   836  //	a3    uintptr
   837  //	a4    uintptr
   838  //	a5    uintptr
   839  //	a6    uintptr
   840  //	a7    uintptr
   841  //	a8    uintptr
   842  //	a9    uintptr
   843  //	a10   uintptr
   844  //	r1    uintptr
   845  //	r2    uintptr
   846  //	err   uintptr
   847  // }
   848  // syscall10 must be called on the g0 stack with the
   849  // C calling convention (use libcCall).
   850  TEXT runtime·syscall10(SB),NOSPLIT,$0
   851  	PUSHL	BP
   852  	MOVL	SP, BP
   853  
   854  	SUBL	$40, SP
   855  	MOVL	48(SP), BX		// pointer to args
   856  
   857  	MOVL	(1*4)(BX), AX
   858  	MOVL	(2*4)(BX), CX
   859  	MOVL	(3*4)(BX), DX
   860  	MOVL	AX, (0*4)(SP)		// a1
   861  	MOVL	CX, (1*4)(SP)		// a2
   862  	MOVL	DX, (2*4)(SP)		// a3
   863  	MOVL	(4*4)(BX), AX
   864  	MOVL	(5*4)(BX), CX
   865  	MOVL	(6*4)(BX), DX
   866  	MOVL	AX, (3*4)(SP)		// a4
   867  	MOVL	CX, (4*4)(SP)		// a5
   868  	MOVL	DX, (5*4)(SP)		// a6
   869  	MOVL	(7*4)(BX), AX
   870  	MOVL	(8*4)(BX), CX
   871  	MOVL	(9*4)(BX), DX
   872  	MOVL	AX, (6*4)(SP)		// a7
   873  	MOVL	CX, (7*4)(SP)		// a8
   874  	MOVL	DX, (8*4)(SP)		// a9
   875  	MOVL	(10*4)(BX), AX
   876  	MOVL	AX, (9*4)(SP)		// a10
   877  
   878  	MOVL	(0*4)(BX), AX		// fn
   879  	CALL	AX
   880  
   881  	MOVL	AX, (11*4)(BX)		// r1
   882  	MOVL	DX, (12*4)(BX)		// r2
   883  
   884  	// Standard libc functions return -1 on error and set errno.
   885  	CMPL	AX, $-1
   886  	JNE	ok
   887  
   888  	// Get error code from libc.
   889  	CALL	libc_errno(SB)
   890  	MOVL	(AX), AX
   891  	MOVW	AX, (13*4)(BX)		// err
   892  
   893  ok:
   894  	MOVL	$0, AX			// no error (it's ignored anyway)
   895  	MOVL	BP, SP
   896  	POPL	BP
   897  	RET
   898  
   899  // syscall10X calls a function in libc on behalf of the syscall package.
   900  // syscall10X takes a pointer to a struct like:
   901  // struct {
   902  //	fn    uintptr
   903  //	a1    uintptr
   904  //	a2    uintptr
   905  //	a3    uintptr
   906  //	a4    uintptr
   907  //	a5    uintptr
   908  //	a6    uintptr
   909  //	a7    uintptr
   910  //	a8    uintptr
   911  //	a9    uintptr
   912  //	a10   uintptr
   913  //	r1    uintptr
   914  //	r2    uintptr
   915  //	err   uintptr
   916  // }
   917  // syscall10X must be called on the g0 stack with the
   918  // C calling convention (use libcCall).
   919  //
   920  // syscall10X is like syscall9 but expects a 64-bit result
   921  // and tests for 64-bit -1 to decide there was an error.
   922  TEXT runtime·syscall10X(SB),NOSPLIT,$0
   923  	PUSHL	BP
   924  	MOVL	SP, BP
   925  
   926  	SUBL	$40, SP
   927  	MOVL	48(SP), BX		// pointer to args
   928  
   929  	MOVL	(1*4)(BX), AX
   930  	MOVL	(2*4)(BX), CX
   931  	MOVL	(3*4)(BX), DX
   932  	MOVL	AX, (0*4)(SP)		// a1
   933  	MOVL	CX, (1*4)(SP)		// a2
   934  	MOVL	DX, (2*4)(SP)		// a3
   935  	MOVL	(4*4)(BX), AX
   936  	MOVL	(5*4)(BX), CX
   937  	MOVL	(6*4)(BX), DX
   938  	MOVL	AX, (3*4)(SP)		// a4
   939  	MOVL	CX, (4*4)(SP)		// a5
   940  	MOVL	DX, (5*4)(SP)		// a6
   941  	MOVL	(7*4)(BX), AX
   942  	MOVL	(8*4)(BX), CX
   943  	MOVL	(9*4)(BX), DX
   944  	MOVL	AX, (6*4)(SP)		// a7
   945  	MOVL	CX, (7*4)(SP)		// a8
   946  	MOVL	DX, (8*4)(SP)		// a9
   947  	MOVL	(10*4)(BX), AX
   948  	MOVL	AX, (9*4)(SP)		// a10
   949  
   950  	MOVL	(0*4)(BX), AX		// fn
   951  	CALL	AX
   952  
   953  	MOVL	AX, (11*4)(BX)		// r1
   954  	MOVL	DX, (12*4)(BX)		// r2
   955  
   956  	// Standard libc functions return -1 on error and set errno.
   957  	CMPL	AX, $-1
   958  	JNE	ok
   959  	CMPL	DX, $-1
   960  	JNE	ok
   961  
   962  	// Get error code from libc.
   963  	CALL	libc_errno(SB)
   964  	MOVL	(AX), AX
   965  	MOVW	AX, (13*4)(BX)		// err
   966  
   967  ok:
   968  	MOVL	$0, AX			// no error (it's ignored anyway)
   969  	MOVL	BP, SP
   970  	POPL	BP
   971  	RET
   972  

View as plain text