github.com/varialus/godfly@v0.0.0-20130904042352-1934f9f095ab/src/pkg/runtime/sys_plan9_amd64.s (about)

     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 "zasm_GOOS_GOARCH.h"
     6  #include "../../cmd/ld/textflag.h"
     7  
     8  // setldt(int entry, int address, int limit)
     9  TEXT runtime·setldt(SB),NOSPLIT,$0
    10  	RET
    11  
    12  TEXT runtime·open(SB),NOSPLIT,$0
    13  	MOVQ	$0x8000, AX
    14  	MOVQ	$14, BP
    15  	SYSCALL
    16  	RET
    17  
    18  TEXT runtime·pread(SB),NOSPLIT,$0
    19  	MOVQ	$0x8000, AX
    20  	MOVQ	$50, BP
    21  	SYSCALL
    22  	RET
    23  
    24  TEXT runtime·pwrite(SB),NOSPLIT,$0
    25  	MOVQ	$0x8000, AX
    26  	MOVQ	$51, BP
    27  	SYSCALL
    28  	RET
    29  
    30  // int32 _seek(int64*, int32, int64, int32)
    31  TEXT _seek<>(SB),NOSPLIT,$0
    32  	MOVQ	$0x8000, AX
    33  	MOVQ	$39, BP
    34  	SYSCALL
    35  	RET
    36  
    37  // int64 seek(int32, int64, int32)
    38  TEXT runtime·seek(SB),NOSPLIT,$56
    39  	LEAQ	new+48(SP), CX
    40  	MOVQ	CX, 0(SP)
    41  	MOVQ	fd+0(FP), CX
    42  	MOVQ	CX, 8(SP)
    43  	MOVQ	off+8(FP), CX
    44  	MOVQ	CX, 16(SP)
    45  	MOVQ	whence+16(FP), CX
    46  	MOVQ	CX, 24(SP)
    47  	CALL	_seek<>(SB)
    48  	CMPL	AX, $0
    49  	JGE	2(PC)
    50  	MOVQ	$-1, new+48(SP)
    51  	MOVQ	new+48(SP), AX
    52  	RET
    53  
    54  TEXT runtime·close(SB),NOSPLIT,$0
    55  	MOVQ	$0x8000, AX
    56  	MOVQ	$4, BP
    57  	SYSCALL
    58  	RET
    59  
    60  TEXT runtime·exits(SB),NOSPLIT,$0
    61  	MOVQ	$0x8000, AX
    62  	MOVQ	$8, BP
    63  	SYSCALL
    64  	RET
    65  
    66  TEXT runtime·brk_(SB),NOSPLIT,$0
    67  	MOVQ	$0x8000, AX
    68  	MOVQ	$24, BP
    69  	SYSCALL
    70  	RET
    71  
    72  TEXT runtime·sleep(SB),NOSPLIT,$0
    73  	MOVQ	$0x8000, AX
    74  	MOVQ	$17, BP
    75  	SYSCALL
    76  	RET
    77  
    78  TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
    79  	MOVQ	$0x8000, AX
    80  	MOVQ	$37, BP
    81  	SYSCALL
    82  	RET
    83  
    84  TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
    85  	MOVQ	$0x8000, AX
    86  	MOVQ	$52, BP
    87  	SYSCALL
    88  	RET
    89  
    90  TEXT runtime·notify(SB),NOSPLIT,$0
    91  	MOVQ	$0x8000, AX
    92  	MOVQ	$28, BP
    93  	SYSCALL
    94  	RET
    95  
    96  TEXT runtime·noted(SB),NOSPLIT,$0
    97  	MOVQ	$0x8000, AX
    98  	MOVQ	$29, BP
    99  	SYSCALL
   100  	RET
   101  	
   102  TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
   103  	MOVQ	$0x8000, AX
   104  	MOVQ	$38, BP
   105  	SYSCALL
   106  	RET
   107  
   108  TEXT runtime·nanotime(SB),NOSPLIT,$0
   109  	MOVQ	$0x8000, AX
   110  	MOVQ	$60, BP
   111  	SYSCALL
   112  	RET
   113  
   114  TEXT runtime·rfork(SB),NOSPLIT,$0
   115  	MOVQ	$0x8000, AX
   116  	MOVQ	$19, BP // rfork
   117  	SYSCALL
   118  
   119  	// In parent, return.
   120  	CMPQ	AX, $0
   121  	JEQ	2(PC)
   122  	RET
   123  
   124  	// In child on forked stack.
   125  	MOVQ	mm+24(SP), BX	// m
   126  	MOVQ	gg+32(SP), DX	// g
   127  	MOVQ	fn+40(SP), SI	// fn
   128  
   129  	// set SP to be on the new child stack
   130  	MOVQ	stack+16(SP), CX
   131  	MOVQ	CX, SP
   132  
   133  	// Initialize m, g.
   134  	get_tls(AX)
   135  	MOVQ	DX, g(AX)
   136  	MOVQ	BX, m(AX)
   137  
   138  	// Initialize AX from pid in TLS.
   139  	MOVQ	procid(AX), AX
   140  	MOVQ	AX, m_procid(BX)	// save pid as m->procid
   141  	
   142  	CALL	runtime·stackcheck(SB)	// smashes AX, CX
   143  	
   144  	MOVQ	0(DX), DX	// paranoia; check they are not nil
   145  	MOVQ	0(BX), BX
   146  	
   147  	CALL	SI	// fn()
   148  	CALL	runtime·exit(SB)
   149  	RET
   150  
   151  // This is needed by asm_amd64.s
   152  TEXT runtime·settls(SB),NOSPLIT,$0
   153  	RET
   154  
   155  // void sigtramp(void *ureg, int8 *note)
   156  TEXT runtime·sigtramp(SB),NOSPLIT,$0
   157  	get_tls(AX)
   158  
   159  	// check that m exists
   160  	MOVQ	m(AX), BX
   161  	CMPQ	BX, $0
   162  	JNE	3(PC)
   163  	CALL	runtime·badsignal2(SB) // will exit
   164  	RET
   165  
   166  	// save args
   167  	MOVQ	ureg+8(SP), CX
   168  	MOVQ	note+16(SP), DX
   169  
   170  	// change stack
   171  	MOVQ	m_gsignal(BX), R10
   172  	MOVQ	g_stackbase(R10), BP
   173  	MOVQ	BP, SP
   174  
   175  	// make room for args and g
   176  	SUBQ	$32, SP
   177  
   178  	// save g
   179  	MOVQ	g(AX), BP
   180  	MOVQ	BP, 24(SP)
   181  
   182  	// g = m->gsignal
   183  	MOVQ	R10, g(AX)
   184  
   185  	// load args and call sighandler
   186  	MOVQ	CX, 0(SP)
   187  	MOVQ	DX, 8(SP)
   188  	MOVQ	BP, 16(SP)
   189  
   190  	CALL	runtime·sighandler(SB)
   191  
   192  	// restore g
   193  	get_tls(BX)
   194  	MOVQ	24(SP), R10
   195  	MOVQ	R10, g(BX)
   196  
   197  	// call noted(AX)
   198  	MOVQ	AX, 0(SP)
   199  	CALL	runtime·noted(SB)
   200  	RET
   201  
   202  TEXT runtime·setfpmasks(SB),NOSPLIT,$8
   203  	STMXCSR	0(SP)
   204  	MOVL	0(SP), AX
   205  	ANDL	$~0x3F, AX
   206  	ORL	$(0x3F<<7), AX
   207  	MOVL	AX, 0(SP)
   208  	LDMXCSR	0(SP)
   209  	RET
   210  
   211  #define ERRMAX 128	/* from os_plan9.h */
   212  
   213  // func errstr() String
   214  // Only used by package syscall.
   215  // Grab error string due to a syscall made
   216  // in entersyscall mode, without going
   217  // through the allocator (issue 4994).
   218  // See ../syscall/asm_plan9_386.s:/·Syscall/
   219  TEXT runtime·errstr(SB),NOSPLIT,$0
   220  	get_tls(AX)
   221  	MOVQ	m(AX), BX
   222  	MOVQ	m_errstr(BX), CX
   223  	MOVQ	CX, 8(SP)
   224  	MOVQ	$ERRMAX, 16(SP)
   225  	MOVQ	$0x8000, AX
   226  	MOVQ	$41, BP
   227  	SYSCALL
   228  
   229  	// syscall requires caller-save
   230  	MOVQ	8(SP), CX
   231  
   232  	// push the argument
   233  	PUSHQ	CX
   234  	CALL	runtime·findnull(SB)
   235  	POPQ	CX
   236  	MOVQ	AX, 16(SP)
   237  	RET