github.com/ader1990/go@v0.0.0-20140630135419-8c24447fa791/src/pkg/syscall/asm_plan9_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  // TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
     6  // so that go vet can check that they are correct.
     7  
     8  #include "../../cmd/ld/textflag.h"
     9  
    10  //
    11  // System call support for Plan 9
    12  //
    13  
    14  //func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err string)
    15  //func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err string)
    16  //func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
    17  //func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
    18  
    19  // Trap # in BP, args on stack above caller pc.
    20  // NxM requires that Plan 9 system calls be
    21  // marked with $0x8000 in AX.
    22  TEXT	·Syscall(SB),NOSPLIT,$0-64
    23  	CALL	runtime·entersyscall(SB)
    24  	MOVQ	$0x8000, AX	// for NxM
    25  	MOVQ	8(SP), BP	// syscall entry
    26  	// slide args down on top of system call number
    27  	LEAQ	16(SP), SI
    28  	LEAQ	8(SP), DI
    29  	CLD
    30  	MOVSQ
    31  	MOVSQ
    32  	MOVSQ
    33  	SYSCALL
    34  	MOVQ	AX, r1+40(SP)
    35  	MOVQ	$0, r2+48(SP)
    36  	CMPL	AX, $-1
    37  	JNE	ok3
    38  
    39  	SUBQ	$16, SP
    40  	CALL	runtime·errstr(SB)
    41  	MOVQ	SP, SI
    42  	ADDQ	$16, SP
    43  	JMP	copyresult3
    44  	
    45  ok3:
    46  	LEAQ	runtime·emptystring(SB), SI	
    47  	
    48  copyresult3:
    49  	LEAQ	err+56(SP), DI
    50  
    51  	CLD
    52  	MOVSQ
    53  	MOVSQ
    54  
    55  	CALL	runtime·exitsyscall(SB)
    56  	RET
    57  
    58  TEXT	·Syscall6(SB),NOSPLIT,$0-88
    59  	CALL	runtime·entersyscall(SB)
    60  	MOVQ	$0x8000, AX	// for NxM
    61  	MOVQ	8(SP), BP	// syscall entry
    62  	// slide args down on top of system call number
    63  	LEAQ		16(SP), SI
    64  	LEAQ		8(SP), DI
    65  	CLD
    66  	MOVSQ
    67  	MOVSQ
    68  	MOVSQ
    69  	MOVSQ
    70  	MOVSQ
    71  	MOVSQ
    72  	SYSCALL
    73  	MOVQ	AX, r1+64(SP)
    74  	MOVQ	$0, r2+72(SP)
    75  	CMPL	AX, $-1
    76  	JNE	ok4
    77  	
    78  	SUBQ	$16, SP
    79  	CALL	runtime·errstr(SB)
    80  	MOVQ	SP, SI
    81  	ADDQ	$16, SP
    82  	JMP	copyresult4
    83  	
    84  ok4:
    85  	LEAQ	runtime·emptystring(SB), SI
    86  	
    87  copyresult4:
    88  	LEAQ	err+80(SP), DI
    89  
    90  	CLD
    91  	MOVSQ
    92  	MOVSQ
    93  
    94  	CALL	runtime·exitsyscall(SB)
    95  	RET
    96  
    97  TEXT ·RawSyscall(SB),NOSPLIT,$0-56
    98  	MOVQ	$0x8000, AX	// for NxM
    99  	MOVQ	8(SP), BP	// syscall entry
   100  	// slide args down on top of system call number
   101  	LEAQ		16(SP), SI
   102  	LEAQ		8(SP), DI
   103  	CLD
   104  	MOVSQ
   105  	MOVSQ
   106  	MOVSQ
   107  	SYSCALL
   108  	MOVQ	AX, r1+40(SP)
   109  	MOVQ	AX, r2+48(SP)
   110  	MOVQ	AX, err+56(SP)
   111  	RET
   112  
   113  TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
   114  	MOVQ	$0x8000, AX	// for NxM
   115  	MOVQ	8(SP), BP	// syscall entry
   116  	// slide args down on top of system call number
   117  	LEAQ		16(SP), SI
   118  	LEAQ		8(SP), DI
   119  	CLD
   120  	MOVSQ
   121  	MOVSQ
   122  	MOVSQ
   123  	MOVSQ
   124  	MOVSQ
   125  	MOVSQ
   126  	SYSCALL
   127  	MOVQ	AX, r1+64(SP)
   128  	MOVQ	AX, r2+72(SP)
   129  	MOVQ	AX, err+80(SP)		
   130  	RET
   131  
   132  #define SYS_SEEK 39	/* from zsysnum_plan9_amd64.go */
   133  
   134  //func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
   135  TEXT ·seek(SB),NOSPLIT,$0-56
   136  	LEAQ	newoffset+40(SP), AX
   137  	MOVQ	AX, placeholder+8(SP)
   138  	
   139  	MOVQ	$0x8000, AX	// for NxM
   140  	MOVQ	$SYS_SEEK, BP	// syscall entry
   141  	SYSCALL
   142  	
   143  	CMPL	AX, $-1
   144  	JNE	ok6
   145  	MOVQ	$-1, newoffset+40(SP)
   146  	
   147  	SUBQ	$16, SP
   148  	CALL	syscall·errstr(SB)
   149  	MOVQ	SP, SI
   150  	ADDQ	$16, SP	
   151  	JMP	copyresult6
   152  	
   153  ok6:
   154  	LEAQ	runtime·emptystring(SB), SI
   155  	
   156  copyresult6:
   157  	LEAQ	err+48(SP), DI
   158  
   159  	CLD
   160  	MOVSQ
   161  	MOVSQ
   162  	RET
   163  
   164  //func exit(code int)
   165  // Import runtime·exit for cleanly exiting.
   166  TEXT ·exit(SB),NOSPLIT,$8-8
   167  	MOVQ	code+0(FP), AX
   168  	MOVQ	AX, 0(SP)
   169  	CALL	runtime·exit(SB)
   170  	RET