syscall: use name+(NN)FP on linux/386

Generated from go vet.

Change-Id: I8fee4095e43034b868bfd2b07e21ac13d5beabbb
Reviewed-on: https://go-review.googlesource.com/2816
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/syscall/asm_linux_386.s b/src/syscall/asm_linux_386.s
index fa1b3712067fb122905c73c881edb04d73400d02..ec7487b4b9a4f1075c59a04453822c1b44b72a76 100644 (file)
--- a/src/syscall/asm_linux_386.s
+++ b/src/syscall/asm_linux_386.s
@@ -2,9 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 #include "funcdata.h"
 
@@ -17,148 +14,148 @@
 
 TEXT   ·Syscall(SB),NOSPLIT,$0-28
        CALL    runtime·entersyscall(SB)
-       MOVL    4(SP), AX       // syscall entry
-       MOVL    8(SP), BX
-       MOVL    12(SP), CX
-       MOVL    16(SP), DX
+       MOVL    trap+0(FP), AX  // syscall entry
+       MOVL    a1+4(FP), BX
+       MOVL    a2+8(FP), CX
+       MOVL    a3+12(FP), DX
        MOVL    $0, SI
        MOVL    $0,  DI
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     ok
-       MOVL    $-1, 20(SP)     // r1
-       MOVL    $0, 24(SP)      // r2
+       MOVL    $-1, r1+16(FP)
+       MOVL    $0, r2+20(FP)
        NEGL    AX
-       MOVL    AX, 28(SP)  // errno
+       MOVL    AX, err+24(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 ok:
-       MOVL    AX, 20(SP)      // r1
-       MOVL    DX, 24(SP)      // r2
-       MOVL    $0, 28(SP)      // errno
+       MOVL    AX, r1+16(FP)
+       MOVL    DX, r2+20(FP)
+       MOVL    $0, err+24(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 
 // func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 TEXT   ·Syscall6(SB),NOSPLIT,$0-40
        CALL    runtime·entersyscall(SB)
-       MOVL    4(SP), AX       // syscall entry
-       MOVL    8(SP), BX
-       MOVL    12(SP), CX
-       MOVL    16(SP), DX
-       MOVL    20(SP), SI
-       MOVL    24(SP), DI
-       MOVL    28(SP), BP
+       MOVL    trap+0(FP), AX  // syscall entry
+       MOVL    a1+4(FP), BX
+       MOVL    a2+8(FP), CX
+       MOVL    a3+12(FP), DX
+       MOVL    a4+16(FP), SI
+       MOVL    a5+20(FP), DI
+       MOVL    a6+24(FP), BP
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     ok6
-       MOVL    $-1, 32(SP)     // r1
-       MOVL    $0, 36(SP)      // r2
+       MOVL    $-1, r1+28(FP)
+       MOVL    $0, r2+32(FP)
        NEGL    AX
-       MOVL    AX, 40(SP)  // errno
+       MOVL    AX, err+36(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 ok6:
-       MOVL    AX, 32(SP)      // r1
-       MOVL    DX, 36(SP)      // r2
-       MOVL    $0, 40(SP)      // errno
+       MOVL    AX, r1+28(FP)
+       MOVL    DX, r2+32(FP)
+       MOVL    $0, err+36(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 
 // func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-       MOVL    4(SP), AX       // syscall entry
-       MOVL    8(SP), BX
-       MOVL    12(SP), CX
-       MOVL    16(SP), DX
+       MOVL    trap+0(FP), AX  // syscall entry
+       MOVL    a1+4(FP), BX
+       MOVL    a2+8(FP), CX
+       MOVL    a3+12(FP), DX
        MOVL    $0, SI
        MOVL    $0,  DI
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     ok1
-       MOVL    $-1, 20(SP)     // r1
-       MOVL    $0, 24(SP)      // r2
+       MOVL    $-1, r1+16(FP)
+       MOVL    $0, r2+20(FP)
        NEGL    AX
-       MOVL    AX, 28(SP)  // errno
+       MOVL    AX, err+24(FP)
        RET
 ok1:
-       MOVL    AX, 20(SP)      // r1
-       MOVL    DX, 24(SP)      // r2
-       MOVL    $0, 28(SP)      // errno
+       MOVL    AX, r1+16(FP)
+       MOVL    DX, r2+20(FP)
+       MOVL    $0, err+24(FP)
        RET
 
 // func RawSyscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 TEXT   ·RawSyscall6(SB),NOSPLIT,$0-40
-       MOVL    4(SP), AX       // syscall entry
-       MOVL    8(SP), BX
-       MOVL    12(SP), CX
-       MOVL    16(SP), DX
-       MOVL    20(SP), SI
-       MOVL    24(SP), DI
-       MOVL    28(SP), BP
+       MOVL    trap+0(FP), AX  // syscall entry
+       MOVL    a1+4(FP), BX
+       MOVL    a2+8(FP), CX
+       MOVL    a3+12(FP), DX
+       MOVL    a4+16(FP), SI
+       MOVL    a5+20(FP), DI
+       MOVL    a6+24(FP), BP
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     ok2
-       MOVL    $-1, 32(SP)     // r1
-       MOVL    $0, 36(SP)      // r2
+       MOVL    $-1, r1+28(FP)
+       MOVL    $0, r2+32(FP)
        NEGL    AX
-       MOVL    AX, 40(SP)  // errno
+       MOVL    AX, err+36(FP)
        RET
 ok2:
-       MOVL    AX, 32(SP)      // r1
-       MOVL    DX, 36(SP)      // r2
-       MOVL    $0, 40(SP)      // errno
+       MOVL    AX, r1+28(FP)
+       MOVL    DX, r2+32(FP)
+       MOVL    $0, err+36(FP)
        RET
 
 #define SYS_SOCKETCALL 102     /* from zsysnum_linux_386.go */
 
-// func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
+// func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err int)
 // Kernel interface gets call sub-number and pointer to a0.
 TEXT ·socketcall(SB),NOSPLIT,$0-36
        CALL    runtime·entersyscall(SB)
        MOVL    $SYS_SOCKETCALL, AX     // syscall entry
-       MOVL    4(SP), BX       // socket call number
-       LEAL            8(SP), CX       // pointer to call arguments
+       MOVL    call+0(FP), BX  // socket call number
+       LEAL            a0+4(FP), CX    // pointer to call arguments
        MOVL    $0, DX
        MOVL    $0, SI
        MOVL    $0,  DI
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     oksock
-       MOVL    $-1, 32(SP)     // n
+       MOVL    $-1, n+28(FP)
        NEGL    AX
-       MOVL    AX, 36(SP)  // errno
+       MOVL    AX, err+32(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 oksock:
-       MOVL    AX, 32(SP)      // n
-       MOVL    $0, 36(SP)      // errno
+       MOVL    AX, n+28(FP)
+       MOVL    $0, err+32(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 
-// func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
+// func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err int)
 // Kernel interface gets call sub-number and pointer to a0.
 TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
        MOVL    $SYS_SOCKETCALL, AX     // syscall entry
-       MOVL    4(SP), BX       // socket call number
-       LEAL            8(SP), CX       // pointer to call arguments
+       MOVL    call+0(FP), BX  // socket call number
+       LEAL            a0+4(FP), CX    // pointer to call arguments
        MOVL    $0, DX
        MOVL    $0, SI
        MOVL    $0,  DI
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     oksock1
-       MOVL    $-1, 32(SP)     // n
+       MOVL    $-1, n+28(FP)
        NEGL    AX
-       MOVL    AX, 36(SP)  // errno
+       MOVL    AX, err+32(FP)
        RET
 oksock1:
-       MOVL    AX, 32(SP)      // n
-       MOVL    $0, 36(SP)      // errno
+       MOVL    AX, n+28(FP)
+       MOVL    $0, err+32(FP)
        RET
 
 #define SYS__LLSEEK 140        /* from zsysnum_linux_386.go */
-// func Seek(fd int, offset int64, whence int) (newoffset int64, errno int)
+// func Seek(fd int, offset int64, whence int) (newoffset int64, err int)
 // Implemented in assembly to avoid allocation when
 // taking the address of the return value newoffset.
 // Underlying system call is
@@ -166,22 +163,22 @@ oksock1:
 TEXT ·seek(SB),NOSPLIT,$0-28
        CALL    runtime·entersyscall(SB)
        MOVL    $SYS__LLSEEK, AX        // syscall entry
-       MOVL    4(SP), BX       // fd
-       MOVL    12(SP), CX      // offset-high
-       MOVL    8(SP), DX       // offset-low
-       LEAL    20(SP), SI      // result pointer
-       MOVL    16(SP),  DI     // whence
+       MOVL    fd+0(FP), BX
+       MOVL    offset_hi+8(FP), CX
+       MOVL    offset_lo+4(FP), DX
+       LEAL    newoffset_lo+16(FP), SI // result pointer
+       MOVL    whence+12(FP),  DI
        CALL    *runtime·_vdso(SB)
        CMPL    AX, $0xfffff001
        JLS     okseek
-       MOVL    $-1, 20(SP)     // newoffset low
-       MOVL    $-1, 24(SP)     // newoffset high
+       MOVL    $-1, newoffset_lo+16(FP)
+       MOVL    $-1, newoffset_hi+20(FP)
        NEGL    AX
-       MOVL    AX, 28(SP)  // errno
+       MOVL    AX, err+24(FP)
        CALL    runtime·exitsyscall(SB)
        RET
 okseek:
        // system call filled in newoffset already
-       MOVL    $0, 28(SP)      // errno
+       MOVL    $0, err+24(FP)
        CALL    runtime·exitsyscall(SB)
        RET