...
Run Format

Text file src/runtime/sys_plan9_386.s

Documentation: runtime

     1	// Copyright 2010 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	#include "go_asm.h"
     6	#include "go_tls.h"
     7	#include "textflag.h"
     8	
     9	// setldt(int entry, int address, int limit)
    10	TEXT runtime·setldt(SB),NOSPLIT,$0
    11		RET
    12	
    13	TEXT runtime·open(SB),NOSPLIT,$0
    14		MOVL    $14, AX
    15		INT     $64
    16		MOVL	AX, ret+12(FP)
    17		RET
    18	
    19	TEXT runtime·pread(SB),NOSPLIT,$0
    20		MOVL    $50, AX
    21		INT     $64
    22		MOVL	AX, ret+20(FP)
    23		RET
    24	
    25	TEXT runtime·pwrite(SB),NOSPLIT,$0
    26		MOVL    $51, AX
    27		INT     $64
    28		MOVL	AX, ret+20(FP)
    29		RET
    30	
    31	// int32 _seek(int64*, int32, int64, int32)
    32	TEXT _seek<>(SB),NOSPLIT,$0
    33		MOVL	$39, AX
    34		INT	$64
    35		RET
    36	
    37	TEXT runtime·seek(SB),NOSPLIT,$24
    38		LEAL	ret+16(FP), AX
    39		MOVL	fd+0(FP), BX
    40		MOVL	offset_lo+4(FP), CX
    41		MOVL	offset_hi+8(FP), DX
    42		MOVL	whence+12(FP), SI
    43		MOVL	AX, 0(SP)
    44		MOVL	BX, 4(SP)
    45		MOVL	CX, 8(SP)
    46		MOVL	DX, 12(SP)
    47		MOVL	SI, 16(SP)
    48		CALL	_seek<>(SB)
    49		CMPL	AX, $0
    50		JGE	3(PC)
    51		MOVL	$-1, ret_lo+16(FP)
    52		MOVL	$-1, ret_hi+20(FP)
    53		RET
    54	
    55	TEXT runtime·closefd(SB),NOSPLIT,$0
    56		MOVL	$4, AX
    57		INT	$64
    58		MOVL	AX, ret+4(FP)
    59		RET
    60	
    61	TEXT runtime·exits(SB),NOSPLIT,$0
    62		MOVL    $8, AX
    63		INT     $64
    64		RET
    65	
    66	TEXT runtime·brk_(SB),NOSPLIT,$0
    67		MOVL    $24, AX
    68		INT     $64
    69		MOVL	AX, ret+4(FP)
    70		RET
    71	
    72	TEXT runtime·sleep(SB),NOSPLIT,$0
    73		MOVL    $17, AX
    74		INT     $64
    75		MOVL	AX, ret+4(FP)
    76		RET
    77	
    78	TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
    79		MOVL	$37, AX
    80		INT	$64
    81		MOVL	AX, ret+8(FP)
    82		RET
    83	
    84	TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
    85		MOVL	$52, AX
    86		INT	$64
    87		MOVL	AX, ret+8(FP)
    88		RET
    89	
    90	TEXT nsec<>(SB),NOSPLIT,$0
    91		MOVL	$53, AX
    92		INT	$64
    93		RET
    94	
    95	TEXT runtime·nsec(SB),NOSPLIT,$8
    96		LEAL	ret+4(FP), AX
    97		MOVL	AX, 0(SP)
    98		CALL	nsec<>(SB)
    99		CMPL	AX, $0
   100		JGE	3(PC)
   101		MOVL	$-1, ret_lo+4(FP)
   102		MOVL	$-1, ret_hi+8(FP)
   103		RET
   104	
   105	// func walltime() (sec int64, nsec int32)
   106	TEXT runtime·walltime(SB),NOSPLIT,$8-12
   107		CALL	runtime·nanotime(SB)
   108		MOVL	0(SP), AX
   109		MOVL	4(SP), DX
   110	
   111		MOVL	$1000000000, CX
   112		DIVL	CX
   113		MOVL	AX, sec_lo+0(FP)
   114		MOVL	$0, sec_hi+4(FP)
   115		MOVL	DX, nsec+8(FP)
   116		RET
   117	
   118	TEXT runtime·notify(SB),NOSPLIT,$0
   119		MOVL	$28, AX
   120		INT	$64
   121		MOVL	AX, ret+4(FP)
   122		RET
   123	
   124	TEXT runtime·noted(SB),NOSPLIT,$0
   125		MOVL	$29, AX
   126		INT	$64
   127		MOVL	AX, ret+4(FP)
   128		RET
   129		
   130	TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
   131		MOVL	$38, AX
   132		INT	$64
   133		MOVL	AX, ret+8(FP)
   134		RET
   135	
   136	TEXT runtime·rfork(SB),NOSPLIT,$0
   137		MOVL	$19, AX
   138		INT	$64
   139		MOVL	AX, ret+4(FP)
   140		RET
   141	
   142	TEXT runtime·tstart_plan9(SB),NOSPLIT,$4
   143		MOVL	newm+0(FP), CX
   144		MOVL	m_g0(CX), DX
   145	
   146		// Layout new m scheduler stack on os stack.
   147		MOVL	SP, AX
   148		MOVL	AX, (g_stack+stack_hi)(DX)
   149		SUBL	$(64*1024), AX		// stack size
   150		MOVL	AX, (g_stack+stack_lo)(DX)
   151		MOVL	AX, g_stackguard0(DX)
   152		MOVL	AX, g_stackguard1(DX)
   153	
   154		// Initialize procid from TOS struct.
   155		MOVL	_tos(SB), AX
   156		MOVL	48(AX), AX
   157		MOVL	AX, m_procid(CX)	// save pid as m->procid
   158	
   159		// Finally, initialize g.
   160		get_tls(BX)
   161		MOVL	DX, g(BX)
   162	
   163		CALL	runtime·stackcheck(SB)	// smashes AX, CX
   164		CALL	runtime·mstart(SB)
   165	
   166		// Exit the thread.
   167		MOVL	$0, 0(SP)
   168		CALL	runtime·exits(SB)
   169		JMP	0(PC)
   170	
   171	// void sigtramp(void *ureg, int8 *note)
   172	TEXT runtime·sigtramp(SB),NOSPLIT,$0
   173		get_tls(AX)
   174	
   175		// check that g exists
   176		MOVL	g(AX), BX
   177		CMPL	BX, $0
   178		JNE	3(PC)
   179		CALL	runtime·badsignal2(SB) // will exit
   180		RET
   181	
   182		// save args
   183		MOVL	ureg+0(FP), CX
   184		MOVL	note+4(FP), DX
   185	
   186		// change stack
   187		MOVL	g_m(BX), BX
   188		MOVL	m_gsignal(BX), BP
   189		MOVL	(g_stack+stack_hi)(BP), BP
   190		MOVL	BP, SP
   191	
   192		// make room for args and g
   193		SUBL	$24, SP
   194	
   195		// save g
   196		MOVL	g(AX), BP
   197		MOVL	BP, 20(SP)
   198	
   199		// g = m->gsignal
   200		MOVL	m_gsignal(BX), DI
   201		MOVL	DI, g(AX)
   202	
   203		// load args and call sighandler
   204		MOVL	CX, 0(SP)
   205		MOVL	DX, 4(SP)
   206		MOVL	BP, 8(SP)
   207	
   208		CALL	runtime·sighandler(SB)
   209		MOVL	12(SP), AX
   210	
   211		// restore g
   212		get_tls(BX)
   213		MOVL	20(SP), BP
   214		MOVL	BP, g(BX)
   215	
   216		// call noted(AX)
   217		MOVL	AX, 0(SP)
   218		CALL	runtime·noted(SB)
   219		RET
   220	
   221	// Only used by the 64-bit runtime.
   222	TEXT runtime·setfpmasks(SB),NOSPLIT,$0
   223		RET
   224	
   225	#define ERRMAX 128	/* from os_plan9.h */
   226	
   227	// void errstr(int8 *buf, int32 len)
   228	TEXT errstr<>(SB),NOSPLIT,$0
   229		MOVL    $41, AX
   230		INT     $64
   231		RET
   232	
   233	// func errstr() string
   234	// Only used by package syscall.
   235	// Grab error string due to a syscall made
   236	// in entersyscall mode, without going
   237	// through the allocator (issue 4994).
   238	// See ../syscall/asm_plan9_386.s:/·Syscall/
   239	TEXT runtime·errstr(SB),NOSPLIT,$8-8
   240		get_tls(AX)
   241		MOVL	g(AX), BX
   242		MOVL	g_m(BX), BX
   243		MOVL	(m_mOS+mOS_errstr)(BX), CX
   244		MOVL	CX, 0(SP)
   245		MOVL	$ERRMAX, 4(SP)
   246		CALL	errstr<>(SB)
   247		CALL	runtime·findnull(SB)
   248		MOVL	4(SP), AX
   249		MOVL	AX, ret_len+4(FP)
   250		MOVL	0(SP), AX
   251		MOVL	AX, ret_base+0(FP)
   252		RET

View as plain text