Text file src/runtime/sys_netbsd_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, NetBSD
     6  // /usr/src/sys/kern/syscalls.master for syscall numbers.
     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		3
    15  
    16  #define SYS_exit			1
    17  #define SYS_read			3
    18  #define SYS_write			4
    19  #define SYS_open			5
    20  #define SYS_close			6
    21  #define SYS_getpid			20
    22  #define SYS_kill			37
    23  #define SYS_munmap			73
    24  #define SYS_madvise			75
    25  #define SYS_fcntl			92
    26  #define SYS_mmap			197
    27  #define SYS___sysctl			202
    28  #define SYS___sigaltstack14		281
    29  #define SYS___sigprocmask14		293
    30  #define SYS_issetugid			305
    31  #define SYS_getcontext			307
    32  #define SYS_setcontext			308
    33  #define SYS__lwp_create			309
    34  #define SYS__lwp_exit			310
    35  #define SYS__lwp_self			311
    36  #define SYS__lwp_setprivate		317
    37  #define SYS__lwp_kill			318
    38  #define SYS__lwp_unpark			321
    39  #define SYS___sigaction_sigtramp	340
    40  #define SYS_kqueue			344
    41  #define SYS_sched_yield			350
    42  #define SYS___setitimer50		425
    43  #define SYS___clock_gettime50		427
    44  #define SYS___nanosleep50		430
    45  #define SYS___kevent50			435
    46  #define SYS____lwp_park60		478
    47  
    48  // Exit the entire program (like C exit)
    49  TEXT runtime·exit(SB),NOSPLIT,$-4
    50  	MOVL	$SYS_exit, AX
    51  	INT	$0x80
    52  	MOVL	$0xf1, 0xf1		// crash
    53  	RET
    54  
    55  // func exitThread(wait *atomic.Uint32)
    56  TEXT runtime·exitThread(SB),NOSPLIT,$0-4
    57  	MOVL	wait+0(FP), AX
    58  	// We're done using the stack.
    59  	MOVL	$0, (AX)
    60  	MOVL	$SYS__lwp_exit, AX
    61  	INT	$0x80
    62  	MOVL	$0xf1, 0xf1		// crash
    63  	JMP	0(PC)
    64  
    65  TEXT runtime·open(SB),NOSPLIT,$-4
    66  	MOVL	$SYS_open, AX
    67  	INT	$0x80
    68  	JAE	2(PC)
    69  	MOVL	$-1, AX
    70  	MOVL	AX, ret+12(FP)
    71  	RET
    72  
    73  TEXT runtime·closefd(SB),NOSPLIT,$-4
    74  	MOVL	$SYS_close, AX
    75  	INT	$0x80
    76  	JAE	2(PC)
    77  	MOVL	$-1, AX
    78  	MOVL	AX, ret+4(FP)
    79  	RET
    80  
    81  TEXT runtime·read(SB),NOSPLIT,$-4
    82  	MOVL	$SYS_read, AX
    83  	INT	$0x80
    84  	JAE	2(PC)
    85  	NEGL	AX			// caller expects negative errno
    86  	MOVL	AX, ret+12(FP)
    87  	RET
    88  
    89  // func pipe2(flags int32) (r, w int32, errno int32)
    90  TEXT runtime·pipe2(SB),NOSPLIT,$12-16
    91  	MOVL	$453, AX
    92  	LEAL	r+4(FP), BX
    93  	MOVL	BX, 4(SP)
    94  	MOVL	flags+0(FP), BX
    95  	MOVL	BX, 8(SP)
    96  	INT	$0x80
    97  	MOVL	AX, errno+12(FP)
    98  	RET
    99  
   100  TEXT runtime·write1(SB),NOSPLIT,$-4
   101  	MOVL	$SYS_write, AX
   102  	INT	$0x80
   103  	JAE	2(PC)
   104  	NEGL	AX			// caller expects negative errno
   105  	MOVL	AX, ret+12(FP)
   106  	RET
   107  
   108  TEXT runtime·usleep(SB),NOSPLIT,$24
   109  	MOVL	$0, DX
   110  	MOVL	usec+0(FP), AX
   111  	MOVL	$1000000, CX
   112  	DIVL	CX
   113  	MOVL	AX, 12(SP)		// tv_sec - l32
   114  	MOVL	$0, 16(SP)		// tv_sec - h32
   115  	MOVL	$1000, AX
   116  	MULL	DX
   117  	MOVL	AX, 20(SP)		// tv_nsec
   118  
   119  	MOVL	$0, 0(SP)
   120  	LEAL	12(SP), AX
   121  	MOVL	AX, 4(SP)		// arg 1 - rqtp
   122  	MOVL	$0, 8(SP)		// arg 2 - rmtp
   123  	MOVL	$SYS___nanosleep50, AX
   124  	INT	$0x80
   125  	RET
   126  
   127  TEXT runtime·lwp_kill(SB),NOSPLIT,$12-8
   128  	MOVL	$0, 0(SP)
   129  	MOVL	tid+0(FP), AX
   130  	MOVL	AX, 4(SP)		// arg 1 - target
   131  	MOVL	sig+4(FP), AX
   132  	MOVL	AX, 8(SP)		// arg 2 - signo
   133  	MOVL	$SYS__lwp_kill, AX
   134  	INT	$0x80
   135  	RET
   136  
   137  TEXT runtime·raiseproc(SB),NOSPLIT,$12
   138  	MOVL	$SYS_getpid, AX
   139  	INT	$0x80
   140  	MOVL	$0, 0(SP)
   141  	MOVL	AX, 4(SP)		// arg 1 - pid
   142  	MOVL	sig+0(FP), AX
   143  	MOVL	AX, 8(SP)		// arg 2 - signo
   144  	MOVL	$SYS_kill, AX
   145  	INT	$0x80
   146  	RET
   147  
   148  TEXT runtime·mmap(SB),NOSPLIT,$36
   149  	LEAL	addr+0(FP), SI
   150  	LEAL	4(SP), DI
   151  	CLD
   152  	MOVSL				// arg 1 - addr
   153  	MOVSL				// arg 2 - len
   154  	MOVSL				// arg 3 - prot
   155  	MOVSL				// arg 4 - flags
   156  	MOVSL				// arg 5 - fd
   157  	MOVL	$0, AX
   158  	STOSL				// arg 6 - pad
   159  	MOVSL				// arg 7 - offset
   160  	MOVL	$0, AX			// top 32 bits of file offset
   161  	STOSL
   162  	MOVL	$SYS_mmap, AX
   163  	INT	$0x80
   164  	JAE	ok
   165  	MOVL	$0, p+24(FP)
   166  	MOVL	AX, err+28(FP)
   167  	RET
   168  ok:
   169  	MOVL	AX, p+24(FP)
   170  	MOVL	$0, err+28(FP)
   171  	RET
   172  
   173  TEXT runtime·munmap(SB),NOSPLIT,$-4
   174  	MOVL	$SYS_munmap, AX
   175  	INT	$0x80
   176  	JAE	2(PC)
   177  	MOVL	$0xf1, 0xf1		// crash
   178  	RET
   179  
   180  TEXT runtime·madvise(SB),NOSPLIT,$-4
   181  	MOVL	$SYS_madvise, AX
   182  	INT	$0x80
   183  	JAE	2(PC)
   184  	MOVL	$-1, AX
   185  	MOVL	AX, ret+12(FP)
   186  	RET
   187  
   188  TEXT runtime·setitimer(SB),NOSPLIT,$-4
   189  	MOVL	$SYS___setitimer50, AX
   190  	INT	$0x80
   191  	RET
   192  
   193  // func walltime() (sec int64, nsec int32)
   194  TEXT runtime·walltime(SB), NOSPLIT, $32
   195  	LEAL	12(SP), BX
   196  	MOVL	$CLOCK_REALTIME, 4(SP)	// arg 1 - clock_id
   197  	MOVL	BX, 8(SP)		// arg 2 - tp
   198  	MOVL	$SYS___clock_gettime50, AX
   199  	INT	$0x80
   200  
   201  	MOVL	12(SP), AX		// sec - l32
   202  	MOVL	AX, sec_lo+0(FP)
   203  	MOVL	16(SP), AX		// sec - h32
   204  	MOVL	AX, sec_hi+4(FP)
   205  
   206  	MOVL	20(SP), BX		// nsec
   207  	MOVL	BX, nsec+8(FP)
   208  	RET
   209  
   210  // int64 nanotime1(void) so really
   211  // void nanotime1(int64 *nsec)
   212  TEXT runtime·nanotime1(SB),NOSPLIT,$32
   213  	LEAL	12(SP), BX
   214  	MOVL	$CLOCK_MONOTONIC, 4(SP)	// arg 1 - clock_id
   215  	MOVL	BX, 8(SP)		// arg 2 - tp
   216  	MOVL	$SYS___clock_gettime50, AX
   217  	INT	$0x80
   218  
   219  	MOVL	16(SP), CX		// sec - h32
   220  	IMULL	$1000000000, CX
   221  
   222  	MOVL	12(SP), AX		// sec - l32
   223  	MOVL	$1000000000, BX
   224  	MULL	BX			// result in dx:ax
   225  
   226  	MOVL	20(SP), BX		// nsec
   227  	ADDL	BX, AX
   228  	ADCL	CX, DX			// add high bits with carry
   229  
   230  	MOVL	AX, ret_lo+0(FP)
   231  	MOVL	DX, ret_hi+4(FP)
   232  	RET
   233  
   234  TEXT runtime·getcontext(SB),NOSPLIT,$-4
   235  	MOVL	$SYS_getcontext, AX
   236  	INT	$0x80
   237  	JAE	2(PC)
   238  	MOVL	$0xf1, 0xf1		// crash
   239  	RET
   240  
   241  TEXT runtime·sigprocmask(SB),NOSPLIT,$-4
   242  	MOVL	$SYS___sigprocmask14, AX
   243  	INT	$0x80
   244  	JAE	2(PC)
   245  	MOVL	$0xf1, 0xf1		// crash
   246  	RET
   247  
   248  TEXT sigreturn_tramp<>(SB),NOSPLIT,$0
   249  	LEAL	140(SP), AX		// Load address of ucontext
   250  	MOVL	AX, 4(SP)
   251  	MOVL	$SYS_setcontext, AX
   252  	INT	$0x80
   253  	MOVL	$-1, 4(SP)		// Something failed...
   254  	MOVL	$SYS_exit, AX
   255  	INT	$0x80
   256  
   257  TEXT runtime·sigaction(SB),NOSPLIT,$24
   258  	LEAL	sig+0(FP), SI
   259  	LEAL	4(SP), DI
   260  	CLD
   261  	MOVSL				// arg 1 - sig
   262  	MOVSL				// arg 2 - act
   263  	MOVSL				// arg 3 - oact
   264  	LEAL	sigreturn_tramp<>(SB), AX
   265  	STOSL				// arg 4 - tramp
   266  	MOVL	$2, AX
   267  	STOSL				// arg 5 - vers
   268  	MOVL	$SYS___sigaction_sigtramp, AX
   269  	INT	$0x80
   270  	JAE	2(PC)
   271  	MOVL	$0xf1, 0xf1		// crash
   272  	RET
   273  
   274  TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
   275  	MOVL	fn+0(FP), AX
   276  	MOVL	sig+4(FP), BX
   277  	MOVL	info+8(FP), CX
   278  	MOVL	ctx+12(FP), DX
   279  	MOVL	SP, SI
   280  	SUBL	$32, SP
   281  	ANDL	$-15, SP	// align stack: handler might be a C function
   282  	MOVL	BX, 0(SP)
   283  	MOVL	CX, 4(SP)
   284  	MOVL	DX, 8(SP)
   285  	MOVL	SI, 12(SP)	// save SI: handler might be a Go function
   286  	CALL	AX
   287  	MOVL	12(SP), AX
   288  	MOVL	AX, SP
   289  	RET
   290  
   291  // Called by OS using C ABI.
   292  TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$28
   293  	NOP	SP	// tell vet SP changed - stop checking offsets
   294  	// Save callee-saved C registers, since the caller may be a C signal handler.
   295  	MOVL	BX, bx-4(SP)
   296  	MOVL	BP, bp-8(SP)
   297  	MOVL	SI, si-12(SP)
   298  	MOVL	DI, di-16(SP)
   299  	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
   300  	// modify them.
   301  
   302  	MOVL	32(SP), BX // signo
   303  	MOVL	BX, 0(SP)
   304  	MOVL	36(SP), BX // info
   305  	MOVL	BX, 4(SP)
   306  	MOVL	40(SP), BX // context
   307  	MOVL	BX, 8(SP)
   308  	CALL	runtime·sigtrampgo(SB)
   309  
   310  	MOVL	di-16(SP), DI
   311  	MOVL	si-12(SP), SI
   312  	MOVL	bp-8(SP),  BP
   313  	MOVL	bx-4(SP),  BX
   314  	RET
   315  
   316  // int32 lwp_create(void *context, uintptr flags, void *lwpid);
   317  TEXT runtime·lwp_create(SB),NOSPLIT,$16
   318  	MOVL	$0, 0(SP)
   319  	MOVL	ctxt+0(FP), AX
   320  	MOVL	AX, 4(SP)		// arg 1 - context
   321  	MOVL	flags+4(FP), AX
   322  	MOVL	AX, 8(SP)		// arg 2 - flags
   323  	MOVL	lwpid+8(FP), AX
   324  	MOVL	AX, 12(SP)		// arg 3 - lwpid
   325  	MOVL	$SYS__lwp_create, AX
   326  	INT	$0x80
   327  	JCC	2(PC)
   328  	NEGL	AX
   329  	MOVL	AX, ret+12(FP)
   330  	RET
   331  
   332  TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
   333  
   334  	// Set FS to point at m->tls
   335  	LEAL	m_tls(BX), BP
   336  	PUSHAL				// save registers
   337  	PUSHL	BP
   338  	CALL	lwp_setprivate<>(SB)
   339  	POPL	AX
   340  	POPAL
   341  
   342  	// Now segment is established. Initialize m, g.
   343  	get_tls(AX)
   344  	MOVL	DX, g(AX)
   345  	MOVL	BX, g_m(DX)
   346  
   347  	CALL	runtime·stackcheck(SB)	// smashes AX, CX
   348  	MOVL	0(DX), DX		// paranoia; check they are not nil
   349  	MOVL	0(BX), BX
   350  
   351  	// more paranoia; check that stack splitting code works
   352  	PUSHAL
   353  	CALL	runtime·emptyfunc(SB)
   354  	POPAL
   355  
   356  	// Call fn
   357  	CALL	SI
   358  
   359  	// fn should never return
   360  	MOVL	$0x1234, 0x1005
   361  	RET
   362  
   363  TEXT ·netbsdMstart(SB),NOSPLIT|TOPFRAME,$0
   364  	CALL	·netbsdMstart0(SB)
   365  	RET // not reached
   366  
   367  TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
   368  	MOVL	$SYS___sigaltstack14, AX
   369  	MOVL	new+0(FP), BX
   370  	MOVL	old+4(FP), CX
   371  	INT	$0x80
   372  	CMPL	AX, $0xfffff001
   373  	JLS	2(PC)
   374  	INT	$3
   375  	RET
   376  
   377  TEXT runtime·setldt(SB),NOSPLIT,$8
   378  	// Under NetBSD we set the GS base instead of messing with the LDT.
   379  	MOVL	base+4(FP), AX
   380  	MOVL	AX, 0(SP)
   381  	CALL	lwp_setprivate<>(SB)
   382  	RET
   383  
   384  TEXT lwp_setprivate<>(SB),NOSPLIT,$16
   385  	// adjust for ELF: wants to use -4(GS) for g
   386  	MOVL	base+0(FP), CX
   387  	ADDL	$4, CX
   388  	MOVL	$0, 0(SP)		// syscall gap
   389  	MOVL	CX, 4(SP)		// arg 1 - ptr
   390  	MOVL	$SYS__lwp_setprivate, AX
   391  	INT	$0x80
   392  	JCC	2(PC)
   393  	MOVL	$0xf1, 0xf1		// crash
   394  	RET
   395  
   396  TEXT runtime·osyield(SB),NOSPLIT,$-4
   397  	MOVL	$SYS_sched_yield, AX
   398  	INT	$0x80
   399  	RET
   400  
   401  TEXT runtime·lwp_park(SB),NOSPLIT,$-4
   402  	MOVL	$SYS____lwp_park60, AX
   403  	INT	$0x80
   404  	MOVL	AX, ret+24(FP)
   405  	RET
   406  
   407  TEXT runtime·lwp_unpark(SB),NOSPLIT,$-4
   408  	MOVL	$SYS__lwp_unpark, AX
   409  	INT	$0x80
   410  	MOVL	AX, ret+8(FP)
   411  	RET
   412  
   413  TEXT runtime·lwp_self(SB),NOSPLIT,$-4
   414  	MOVL	$SYS__lwp_self, AX
   415  	INT	$0x80
   416  	MOVL	AX, ret+0(FP)
   417  	RET
   418  
   419  TEXT runtime·sysctl(SB),NOSPLIT,$28
   420  	LEAL	mib+0(FP), SI
   421  	LEAL	4(SP), DI
   422  	CLD
   423  	MOVSL				// arg 1 - name
   424  	MOVSL				// arg 2 - namelen
   425  	MOVSL				// arg 3 - oldp
   426  	MOVSL				// arg 4 - oldlenp
   427  	MOVSL				// arg 5 - newp
   428  	MOVSL				// arg 6 - newlen
   429  	MOVL	$SYS___sysctl, AX
   430  	INT	$0x80
   431  	JAE	4(PC)
   432  	NEGL	AX
   433  	MOVL	AX, ret+24(FP)
   434  	RET
   435  	MOVL	$0, AX
   436  	MOVL	AX, ret+24(FP)
   437  	RET
   438  
   439  GLOBL runtime·tlsoffset(SB),NOPTR,$4
   440  
   441  // int32 runtime·kqueue(void)
   442  TEXT runtime·kqueue(SB),NOSPLIT,$0
   443  	MOVL	$SYS_kqueue, AX
   444  	INT	$0x80
   445  	JAE	2(PC)
   446  	NEGL	AX
   447  	MOVL	AX, ret+0(FP)
   448  	RET
   449  
   450  // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
   451  TEXT runtime·kevent(SB),NOSPLIT,$0
   452  	MOVL	$SYS___kevent50, AX
   453  	INT	$0x80
   454  	JAE	2(PC)
   455  	NEGL	AX
   456  	MOVL	AX, ret+24(FP)
   457  	RET
   458  
   459  // func fcntl(fd, cmd, arg int32) (int32, int32)
   460  TEXT runtime·fcntl(SB),NOSPLIT,$-4
   461  	MOVL	$SYS_fcntl, AX
   462  	INT	$0x80
   463  	JAE	noerr
   464  	MOVL	$-1, ret+12(FP)
   465  	MOVL	AX, errno+16(FP)
   466  	RET
   467  noerr:
   468  	MOVL	AX, ret+12(FP)
   469  	MOVL	$0, errno+16(FP)
   470  	RET
   471  
   472  // func issetugid() int32
   473  TEXT runtime·issetugid(SB),NOSPLIT,$0
   474  	MOVL	$SYS_issetugid, AX
   475  	INT	$0x80
   476  	MOVL	AX, ret+0(FP)
   477  	RET
   478  

View as plain text