cybercyst/go
1
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-05-18 22:04:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

all: fix assembly vet issues

Browse Source 
Add missing function prototypes.
Fix function prototypes.
Use FP references instead of SP references.
Fix variable names.
Update comments.
Clean up whitespace. (Not for vet.)

All fairly minor fixes to make vet happy.

Updates #11041

Change-Id: Ifab2cdf235ff61cdc226ab1d84b8467b5ac9446c
Reviewed-on: https://go-review.googlesource.com/27713
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
This commit is contained in:
Josh Bleecher Snyder 2016-07-11 16:05:57 -07:00
parent 6af7639ae1
commit 71ab9fa312
52 changed files with 361 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/crypto/rc4/rc4_arm.s
View File

@ -25,8 +25,8 @@ TEXT ·xorKeyStream(SB),NOSPLIT,$0
MOVW src+4(FP), Rsrc MOVW src+4(FP), Rsrc
MOVW n+8(FP), Rn MOVW n+8(FP), Rn
MOVW state+12(FP), Rstate MOVW state+12(FP), Rstate
MOVW pi+16(FP), Rpi MOVW i+16(FP), Rpi
MOVW pj+20(FP), Rpj MOVW j+20(FP), Rpj
MOVBU (Rpi), Ri MOVBU (Rpi), Ri
MOVBU (Rpj), Rj MOVBU (Rpj), Rj
MOVW $0, Rk MOVW $0, Rk

2
src/crypto/sha256/sha256block_386.s
View File

@ -141,7 +141,7 @@
MSGSCHEDULE1(index); \ MSGSCHEDULE1(index); \
SHA256ROUND(index, const, a, b, c, d, e, f, g, h) SHA256ROUND(index, const, a, b, c, d, e, f, g, h)
TEXT ·block(SB),0,$296-12 TEXT ·block(SB),0,$296-16
MOVL p_base+4(FP), SI MOVL p_base+4(FP), SI
MOVL p_len+8(FP), DX MOVL p_len+8(FP), DX
SHRL $6, DX SHRL $6, DX

12
src/math/modf_386.s
View File

@ -7,16 +7,16 @@
// func Modf(f float64) (int float64, frac float64) // func Modf(f float64) (int float64, frac float64)
TEXT ·Modf(SB),NOSPLIT,$0 TEXT ·Modf(SB),NOSPLIT,$0
// special case for f == -0.0 // special case for f == -0.0
MOVL f+4(FP), DX // high word MOVL f_hi+4(FP), DX // high word
MOVL f+0(FP), AX // low word MOVL f_lo+0(FP), AX // low word
CMPL DX, $(1<<31) // beginning of -0.0 CMPL DX, $(1<<31) // beginning of -0.0
JNE notNegativeZero JNE notNegativeZero
CMPL AX, $0 // could be denormalized CMPL AX, $0 // could be denormalized
JNE notNegativeZero JNE notNegativeZero
MOVL AX, int+8(FP) MOVL AX, int_lo+8(FP)
MOVL DX, int+12(FP) MOVL DX, int_hi+12(FP)
MOVL AX, frac+16(FP) MOVL AX, frac_lo+16(FP)
MOVL DX, frac+20(FP) MOVL DX, frac_hi+20(FP)
RET RET
notNegativeZero: notNegativeZero:
FMOVD f+0(FP), F0 // F0=f FMOVD f+0(FP), F0 // F0=f

13
src/runtime/asm_386.s
View File

@ -843,9 +843,6 @@ TEXT runtime·ldt0setup(SB),NOSPLIT,$16-0
TEXT runtime·emptyfunc(SB),0,$0-0 TEXT runtime·emptyfunc(SB),0,$0-0
RET RET
TEXT runtime·abort(SB),NOSPLIT,$0-0
INT $0x3
// memhash_varlen(p unsafe.Pointer, h seed) uintptr // memhash_varlen(p unsafe.Pointer, h seed) uintptr
// redirects to memhash(p, h, size) using the size // redirects to memhash(p, h, size) using the size
// stored in the closure. // stored in the closure.
@ -1290,15 +1287,15 @@ eq:
// See runtime_test.go:eqstring_generic for // See runtime_test.go:eqstring_generic for
// equivalent Go code. // equivalent Go code.
TEXT runtime·eqstring(SB),NOSPLIT,$0-17 TEXT runtime·eqstring(SB),NOSPLIT,$0-17
MOVL s1str+0(FP), SI MOVL s1_base+0(FP), SI
MOVL s2str+8(FP), DI MOVL s2_base+8(FP), DI
CMPL SI, DI CMPL SI, DI
JEQ same JEQ same
MOVL s1len+4(FP), BX MOVL s1_len+4(FP), BX
LEAL v+16(FP), AX LEAL ret+16(FP), AX
JMP runtime·memeqbody(SB) JMP runtime·memeqbody(SB)
same: same:
MOVB $1, v+16(FP) MOVB $1, ret+16(FP)
RET RET
TEXT bytes·Equal(SB),NOSPLIT,$0-25 TEXT bytes·Equal(SB),NOSPLIT,$0-25

10
src/runtime/asm_amd64.s
View File

@ -1340,15 +1340,15 @@ eq:
// See runtime_test.go:eqstring_generic for // See runtime_test.go:eqstring_generic for
// equivalent Go code. // equivalent Go code.
TEXT runtime·eqstring(SB),NOSPLIT,$0-33 TEXT runtime·eqstring(SB),NOSPLIT,$0-33
MOVQ s1str+0(FP), SI MOVQ s1_base+0(FP), SI
MOVQ s2str+16(FP), DI MOVQ s2_base+16(FP), DI
CMPQ SI, DI CMPQ SI, DI
JEQ eq JEQ eq
MOVQ s1len+8(FP), BX MOVQ s1_len+8(FP), BX
LEAQ v+32(FP), AX LEAQ ret+32(FP), AX
JMP runtime·memeqbody(SB) JMP runtime·memeqbody(SB)
eq: eq:
MOVB $1, v+32(FP) MOVB $1, ret+32(FP)
RET RET
// a in SI // a in SI

14
src/runtime/asm_arm.s
View File

@ -855,13 +855,13 @@ samebytes:
// See runtime_test.go:eqstring_generic for // See runtime_test.go:eqstring_generic for
// equivalent Go code. // equivalent Go code.
TEXT runtime·eqstring(SB),NOSPLIT,$-4-17 TEXT runtime·eqstring(SB),NOSPLIT,$-4-17
MOVW s1str+0(FP), R2 MOVW s1_base+0(FP), R2
MOVW s2str+8(FP), R3 MOVW s2_base+8(FP), R3
MOVW $1, R8 MOVW $1, R8
MOVB R8, v+16(FP) MOVB R8, ret+16(FP)
CMP R2, R3 CMP R2, R3
RET.EQ RET.EQ
MOVW s1len+4(FP), R0 MOVW s1_len+4(FP), R0
ADD R2, R0, R6 ADD R2, R0, R6
loop: loop:
CMP R2, R6 CMP R2, R6
@ -871,7 +871,7 @@ loop:
CMP R4, R5 CMP R4, R5
BEQ loop BEQ loop
MOVW $0, R8 MOVW $0, R8
MOVB R8, v+16(FP) MOVB R8, ret+16(FP)
RET RET
// TODO: share code with memequal? // TODO: share code with memequal?
@ -1033,8 +1033,8 @@ TEXT runtime·usplitR0(SB),NOSPLIT,$0
SUB R1, R3, R1 SUB R1, R3, R1
RET RET
TEXT runtime·sigreturn(SB),NOSPLIT,$0-4 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
RET RET
#ifndef GOOS_nacl #ifndef GOOS_nacl
// This is called from .init_array and follows the platform, not Go, ABI. // This is called from .init_array and follows the platform, not Go, ABI.

10
src/runtime/asm_arm64.s
View File

@ -869,9 +869,9 @@ samebytes:
// See runtime_test.go:eqstring_generic for // See runtime_test.go:eqstring_generic for
// equivalent Go code. // equivalent Go code.
TEXT runtime·eqstring(SB),NOSPLIT,$0-33 TEXT runtime·eqstring(SB),NOSPLIT,$0-33
MOVD s1str+0(FP), R0 MOVD s1_base+0(FP), R0
MOVD s1len+8(FP), R1 MOVD s1_len+8(FP), R1
MOVD s2str+16(FP), R2 MOVD s2_base+16(FP), R2
ADD R0, R1 // end ADD R0, R1 // end
loop: loop:
CMP R0, R1 CMP R0, R1
@ -996,8 +996,8 @@ TEXT runtime·prefetcht2(SB),NOSPLIT,$0-8
TEXT runtime·prefetchnta(SB),NOSPLIT,$0-8 TEXT runtime·prefetchnta(SB),NOSPLIT,$0-8
RET RET
TEXT runtime·sigreturn(SB),NOSPLIT,$0-8 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
RET RET
// This is called from .init_array and follows the platform, not Go, ABI. // This is called from .init_array and follows the platform, not Go, ABI.
TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0 TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0

6
src/runtime/asm_mips64x.s
View File

@ -746,13 +746,13 @@ eq:
// See runtime_test.go:eqstring_generic for // See runtime_test.go:eqstring_generic for
// equivalent Go code. // equivalent Go code.
TEXT runtime·eqstring(SB),NOSPLIT,$0-33 TEXT runtime·eqstring(SB),NOSPLIT,$0-33
MOVV s1str+0(FP), R1 MOVV s1_base+0(FP), R1
MOVV s2str+16(FP), R2 MOVV s2_base+16(FP), R2
MOVV $1, R3 MOVV $1, R3
MOVB R3, ret+32(FP) MOVB R3, ret+32(FP)
BNE R1, R2, 2(PC) BNE R1, R2, 2(PC)
RET RET
MOVV s1len+8(FP), R3 MOVV s1_len+8(FP), R3
ADDV R1, R3, R4 ADDV R1, R3, R4
loop: loop:
BNE R1, R4, 2(PC) BNE R1, R4, 2(PC)

10
src/runtime/asm_ppc64x.s
View File

@ -908,14 +908,14 @@ equal:
// See runtime_test.go:eqstring_generic for // See runtime_test.go:eqstring_generic for
// equivalent Go code. // equivalent Go code.
TEXT runtime·eqstring(SB),NOSPLIT,$0-33 TEXT runtime·eqstring(SB),NOSPLIT,$0-33
MOVD s1str+0(FP), R3 MOVD s1_base+0(FP), R3
MOVD s2str+16(FP), R4 MOVD s2_base+16(FP), R4
MOVD $1, R5 MOVD $1, R5
MOVB R5, ret+32(FP) MOVB R5, ret+32(FP)
CMP R3, R4 CMP R3, R4
BNE 2(PC) BNE 2(PC)
RET RET
MOVD s1len+8(FP), R5 MOVD s1_len+8(FP), R5
BL runtime·memeqbody(SB) BL runtime·memeqbody(SB)
MOVB R9, ret+32(FP) MOVB R9, ret+32(FP)
RET RET
@ -1109,8 +1109,8 @@ TEXT runtime·prefetcht2(SB),NOSPLIT,$0-8
TEXT runtime·prefetchnta(SB),NOSPLIT,$0-8 TEXT runtime·prefetchnta(SB),NOSPLIT,$0-8
RET RET
TEXT runtime·sigreturn(SB),NOSPLIT,$0-8 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
RET RET
// prepGoExitFrame saves the current TOC pointer (i.e. the TOC pointer for the // prepGoExitFrame saves the current TOC pointer (i.e. the TOC pointer for the
// module containing runtime) to the frame that goexit will execute in when // module containing runtime) to the frame that goexit will execute in when

2
src/runtime/internal/atomic/asm_386.s
View File

@ -61,7 +61,7 @@ TEXT runtime∕internal∕atomic·Cas64(SB), NOSPLIT, $0-21
SETEQ ret+20(FP) SETEQ ret+20(FP)
RET RET
// bool Casp(void **p, void *old, void *new) // bool Casp1(void **p, void *old, void *new)
// Atomically: // Atomically:
// if(*p == old){ // if(*p == old){
// *p = new; // *p = new;

2
src/runtime/internal/atomic/asm_amd64.s
View File

@ -55,7 +55,7 @@ TEXT runtime∕internal∕atomic·Loadint64(SB), NOSPLIT, $0-16
TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24 TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24
JMP runtime∕internal∕atomic·Xadd64(SB) JMP runtime∕internal∕atomic·Xadd64(SB)
// bool Casp(void **val, void *old, void *new) // bool Casp1(void **val, void *old, void *new)
// Atomically: // Atomically:
// if(*val == old){ // if(*val == old){
// *val = new; // *val = new;

2
src/runtime/internal/atomic/asm_amd64p32.s
View File

@ -55,7 +55,7 @@ TEXT runtime∕internal∕atomic·Cas64(SB), NOSPLIT, $0-25
SETEQ ret+24(FP) SETEQ ret+24(FP)
RET RET
// bool Casp(void **val, void *old, void *new) // bool Casp1(void **val, void *old, void *new)
// Atomically: // Atomically:
// if(*val == old){ // if(*val == old){
// *val = new; // *val = new;

2
src/runtime/internal/atomic/asm_arm.s
View File

@ -19,7 +19,7 @@
// B runtime∕internal∕atomic·armcas(SB) // B runtime∕internal∕atomic·armcas(SB)
// //
TEXT runtime∕internal∕atomic·armcas(SB),NOSPLIT,$0-13 TEXT runtime∕internal∕atomic·armcas(SB),NOSPLIT,$0-13
MOVW valptr+0(FP), R1 MOVW ptr+0(FP), R1
MOVW old+4(FP), R2 MOVW old+4(FP), R2
MOVW new+8(FP), R3 MOVW new+8(FP), R3
casl: casl:

2
src/runtime/internal/atomic/asm_arm64.s
View File

@ -47,7 +47,7 @@ TEXT runtime∕internal∕atomic·Loadint64(SB), NOSPLIT, $0-16
TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24 TEXT runtime∕internal∕atomic·Xaddint64(SB), NOSPLIT, $0-24
B runtime∕internal∕atomic·Xadd64(SB) B runtime∕internal∕atomic·Xadd64(SB)
// bool Casp(void **val, void *old, void *new) // bool Casp1(void **val, void *old, void *new)
// Atomically: // Atomically:
// if(*val == old){ // if(*val == old){
// *val = new; // *val = new;

3
src/runtime/internal/atomic/atomic_arm.go
View File

@ -181,3 +181,6 @@ func And8(addr *uint8, v uint8) {
} }
} }
} }
//go:nosplit
func armcas(ptr *uint32, old, new uint32) bool

12
src/runtime/internal/atomic/atomic_ppc64x.s
View File

@ -6,9 +6,9 @@
#include "textflag.h" #include "textflag.h"
// uint32 runtime∕internal∕atomic·Load(uint32 volatile* addr) // uint32 runtime∕internal∕atomic·Load(uint32 volatile* ptr)
TEXT ·Load(SB),NOSPLIT|NOFRAME,$-8-12 TEXT ·Load(SB),NOSPLIT|NOFRAME,$-8-12
MOVD addr+0(FP), R3 MOVD ptr+0(FP), R3
SYNC SYNC
MOVWZ 0(R3), R3 MOVWZ 0(R3), R3
CMPW R3, R3, CR7 CMPW R3, R3, CR7
@ -17,9 +17,9 @@ TEXT ·Load(SB),NOSPLIT|NOFRAME,$-8-12
MOVW R3, ret+8(FP) MOVW R3, ret+8(FP)
RET RET
// uint64 runtime∕internal∕atomic·Load64(uint64 volatile* addr) // uint64 runtime∕internal∕atomic·Load64(uint64 volatile* ptr)
TEXT ·Load64(SB),NOSPLIT|NOFRAME,$-8-16 TEXT ·Load64(SB),NOSPLIT|NOFRAME,$-8-16
MOVD addr+0(FP), R3 MOVD ptr+0(FP), R3
SYNC SYNC
MOVD 0(R3), R3 MOVD 0(R3), R3
CMP R3, R3, CR7 CMP R3, R3, CR7
@ -28,9 +28,9 @@ TEXT ·Load64(SB),NOSPLIT|NOFRAME,$-8-16
MOVD R3, ret+8(FP) MOVD R3, ret+8(FP)
RET RET
// void *runtime∕internal∕atomic·Loadp(void *volatile *addr) // void *runtime∕internal∕atomic·Loadp(void *volatile *ptr)
TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$-8-16 TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$-8-16
MOVD addr+0(FP), R3 MOVD ptr+0(FP), R3
SYNC SYNC
MOVD 0(R3), R3 MOVD 0(R3), R3
CMP R3, R3, CR7 CMP R3, R3, CR7

1
src/runtime/noasm.go
View File

@ -3,6 +3,7 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// Routines that are implemented in assembly in asm_{amd64,386,arm,arm64,ppc64x,s390x}.s // Routines that are implemented in assembly in asm_{amd64,386,arm,arm64,ppc64x,s390x}.s
// These routines have corresponding stubs in stubs_asm.go.
// +build mips64 mips64le // +build mips64 mips64le

4
src/runtime/os3_solaris.go
View File

@ -131,7 +131,7 @@ func osinit() {
ncpu = getncpu() ncpu = getncpu()
} }
func tstart_sysvicall() func tstart_sysvicall(newm *m) uint32
// May run with m.p==nil, so write barriers are not allowed. // May run with m.p==nil, so write barriers are not allowed.
//go:nowritebarrier //go:nowritebarrier
@ -565,7 +565,7 @@ func sysconf(name int32) int64 {
return int64(sysvicall1(&libc_sysconf, uintptr(name))) return int64(sysvicall1(&libc_sysconf, uintptr(name)))
} }
func usleep1(uint32) func usleep1(usec uint32)
//go:nosplit //go:nosplit
func usleep(µs uint32) { func usleep(µs uint32) {

6
src/runtime/os_darwin.go
View File

@ -503,13 +503,15 @@ func sigaction(mode uint32, new *sigactiont, old *usigactiont)
//go:noescape //go:noescape
func sigaltstack(new, old *stackt) func sigaltstack(new, old *stackt)
func sigtramp() // darwin/arm64 uses registers instead of stack-based arguments.
// TODO: does this matter?
func sigtramp(fn uintptr, infostyle, sig uint32, info *siginfo, ctx unsafe.Pointer)
//go:noescape //go:noescape
func setitimer(mode int32, new, old *itimerval) func setitimer(mode int32, new, old *itimerval)
func raise(sig int32) func raise(sig int32)
func raiseproc(int32) func raiseproc(sig int32)
//extern SigTabTT runtime·sigtab[]; //extern SigTabTT runtime·sigtab[];

4
src/runtime/os_linux.go
View File

@ -133,7 +133,7 @@ const (
) )
//go:noescape //go:noescape
func clone(flags int32, stk, mm, gg, fn unsafe.Pointer) int32 func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32
// May run with m.p==nil, so write barriers are not allowed. // May run with m.p==nil, so write barriers are not allowed.
//go:nowritebarrier //go:nowritebarrier
@ -360,7 +360,7 @@ func memlimit() uintptr {
//#endif //#endif
func sigreturn() func sigreturn()
func sigtramp() func sigtramp(sig uint32, info *siginfo, ctx unsafe.Pointer)
func cgoSigtramp() func cgoSigtramp()
//go:noescape //go:noescape

4
src/runtime/stubs.go
View File

@ -206,6 +206,7 @@ func asmcgocall(fn, arg unsafe.Pointer) int32
const _NoArgs = ^uintptr(0) const _NoArgs = ^uintptr(0)
func morestack() func morestack()
func morestack_noctxt()
func rt0_go() func rt0_go()
// stackBarrier records that the stack has been unwound past a certain // stackBarrier records that the stack has been unwound past a certain
@ -273,3 +274,6 @@ func round(n, a uintptr) uintptr {
// checkASM returns whether assembly runtime checks have passed. // checkASM returns whether assembly runtime checks have passed.
func checkASM() bool func checkASM() bool
func memequal_varlen(a, b unsafe.Pointer) bool
func eqstring(s1, s2 string) bool

11
src/runtime/stubs_asm.go Normal file
View File

@ -0,0 +1,11 @@
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build !mips64,!mips64le
// Declarations for routines that are implemented in noasm.go.
package runtime
func cmpstring(s1, s2 string) int

12
src/runtime/sys_darwin_386.s
View File

@ -280,26 +280,26 @@ TEXT runtime·sigreturn(SB),NOSPLIT,$12-8
// It is called with the following arguments on the stack: // It is called with the following arguments on the stack:
// 0(SP) "return address" - ignored // 0(SP) "return address" - ignored
// 4(SP) actual handler // 4(SP) actual handler
// 8(SP) signal number // 8(SP) siginfo style
// 12(SP) siginfo style // 12(SP) signal number
// 16(SP) siginfo // 16(SP) siginfo
// 20(SP) context // 20(SP) context
TEXT runtime·sigtramp(SB),NOSPLIT,$20 TEXT runtime·sigtramp(SB),NOSPLIT,$20
MOVL fn+0(FP), BX MOVL fn+0(FP), BX
MOVL BX, 0(SP) MOVL BX, 0(SP)
MOVL style+4(FP), BX MOVL infostyle+4(FP), BX
MOVL BX, 4(SP) MOVL BX, 4(SP)
MOVL sig+8(FP), BX MOVL sig+8(FP), BX
MOVL BX, 8(SP) MOVL BX, 8(SP)
MOVL info+12(FP), BX MOVL info+12(FP), BX
MOVL BX, 12(SP) MOVL BX, 12(SP)
MOVL context+16(FP), BX MOVL ctx+16(FP), BX
MOVL BX, 16(SP) MOVL BX, 16(SP)
CALL runtime·sigtrampgo(SB) CALL runtime·sigtrampgo(SB)
// call sigreturn // call sigreturn
MOVL context+16(FP), CX MOVL ctx+16(FP), CX
MOVL style+4(FP), BX MOVL infostyle+4(FP), BX
MOVL $0, 0(SP) // "caller PC" - ignored MOVL $0, 0(SP) // "caller PC" - ignored
MOVL CX, 4(SP) MOVL CX, 4(SP)
MOVL BX, 8(SP) MOVL BX, 8(SP)

2
src/runtime/sys_darwin_amd64.s
View File

@ -197,7 +197,7 @@ TEXT time·now(SB),NOSPLIT,$0-12
RET RET
TEXT runtime·sigprocmask(SB),NOSPLIT,$0 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVL sig+0(FP), DI MOVL how+0(FP), DI
MOVQ new+8(FP), SI MOVQ new+8(FP), SI
MOVQ old+16(FP), DX MOVQ old+16(FP), DX
MOVL $(0x2000000+329), AX // pthread_sigmask (on OS X, sigprocmask==entire process) MOVL $(0x2000000+329), AX // pthread_sigmask (on OS X, sigprocmask==entire process)

4
src/runtime/sys_darwin_arm.s
View File

@ -106,7 +106,7 @@ TEXT runtime·raiseproc(SB),NOSPLIT,$24
MOVW $SYS_getpid, R12 MOVW $SYS_getpid, R12
SWI $0x80 SWI $0x80
// arg 1 pid already in R0 from getpid // arg 1 pid already in R0 from getpid
MOVW arg+0(FP), R1 // arg 2 - signal MOVW sig+0(FP), R1 // arg 2 - signal
MOVW $1, R2 // arg 3 - posix MOVW $1, R2 // arg 3 - posix
MOVW $SYS_kill, R12 MOVW $SYS_kill, R12
SWI $0x80 SWI $0x80
@ -286,7 +286,7 @@ ret:
B runtime·exit(SB) B runtime·exit(SB)
TEXT runtime·sigprocmask(SB),NOSPLIT,$0 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVW sig+0(FP), R0 MOVW how+0(FP), R0
MOVW new+4(FP), R1 MOVW new+4(FP), R1
MOVW old+8(FP), R2 MOVW old+8(FP), R2
MOVW $SYS_pthread_sigmask, R12 MOVW $SYS_pthread_sigmask, R12

2
src/runtime/sys_darwin_arm64.s
View File

@ -271,7 +271,7 @@ ret:
B runtime·exit(SB) B runtime·exit(SB)
TEXT runtime·sigprocmask(SB),NOSPLIT,$0 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVW sig+0(FP), R0 MOVW how+0(FP), R0
MOVD new+8(FP), R1 MOVD new+8(FP), R1
MOVD old+16(FP), R2 MOVD old+16(FP), R2
MOVW $SYS_pthread_sigmask, R16 MOVW $SYS_pthread_sigmask, R16

10
src/runtime/sys_dragonfly_amd64.s
View File

@ -333,11 +333,11 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
TEXT runtime·kevent(SB),NOSPLIT,$0 TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL fd+0(FP), DI MOVL kq+0(FP), DI
MOVQ ev1+8(FP), SI MOVQ ch+8(FP), SI
MOVL nev1+16(FP), DX MOVL nch+16(FP), DX
MOVQ ev2+24(FP), R10 MOVQ ev+24(FP), R10
MOVL nev2+32(FP), R8 MOVL nev+32(FP), R8
MOVQ ts+40(FP), R9 MOVQ ts+40(FP), R9
MOVL $363, AX MOVL $363, AX
SYSCALL SYSCALL

10
src/runtime/sys_freebsd_amd64.s
View File

@ -311,11 +311,11 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
TEXT runtime·kevent(SB),NOSPLIT,$0 TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL fd+0(FP), DI MOVL kq+0(FP), DI
MOVQ ev1+8(FP), SI MOVQ ch+8(FP), SI
MOVL nev1+16(FP), DX MOVL nch+16(FP), DX
MOVQ ev2+24(FP), R10 MOVQ ev+24(FP), R10
MOVL nev2+32(FP), R8 MOVL nev+32(FP), R8
MOVQ ts+40(FP), R9 MOVQ ts+40(FP), R9
MOVL $363, AX MOVL $363, AX
SYSCALL SYSCALL

8
src/runtime/sys_linux_386.s
View File

@ -227,7 +227,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$12
MOVL BX, 0(SP) MOVL BX, 0(SP)
MOVL info+4(FP), BX MOVL info+4(FP), BX
MOVL BX, 4(SP) MOVL BX, 4(SP)
MOVL context+8(FP), BX MOVL ctx+8(FP), BX
MOVL BX, 8(SP) MOVL BX, 8(SP)
CALL runtime·sigtrampgo(SB) CALL runtime·sigtrampgo(SB)
RET RET
@ -297,15 +297,15 @@ TEXT runtime·futex(SB),NOSPLIT,$0
TEXT runtime·clone(SB),NOSPLIT,$0 TEXT runtime·clone(SB),NOSPLIT,$0
MOVL $120, AX // clone MOVL $120, AX // clone
MOVL flags+0(FP), BX MOVL flags+0(FP), BX
MOVL stack+4(FP), CX MOVL stk+4(FP), CX
MOVL $0, DX // parent tid ptr MOVL $0, DX // parent tid ptr
MOVL $0, DI // child tid ptr MOVL $0, DI // child tid ptr
// Copy mp, gp, fn off parent stack for use by child. // Copy mp, gp, fn off parent stack for use by child.
SUBL $16, CX SUBL $16, CX
MOVL mm+8(FP), SI MOVL mp+8(FP), SI
MOVL SI, 0(CX) MOVL SI, 0(CX)
MOVL gg+12(FP), SI MOVL gp+12(FP), SI
MOVL SI, 4(CX) MOVL SI, 4(CX)
MOVL fn+16(FP), SI MOVL fn+16(FP), SI
MOVL SI, 8(CX) MOVL SI, 8(CX)

10
src/runtime/sys_linux_amd64.s
View File

@ -388,10 +388,10 @@ TEXT runtime·futex(SB),NOSPLIT,$0
MOVL AX, ret+40(FP) MOVL AX, ret+40(FP)
RET RET
// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void)); // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
TEXT runtime·clone(SB),NOSPLIT,$0 TEXT runtime·clone(SB),NOSPLIT,$0
MOVL flags+0(FP), DI MOVL flags+0(FP), DI
MOVQ stack+8(FP), SI MOVQ stk+8(FP), SI
MOVQ $0, DX MOVQ $0, DX
MOVQ $0, R10 MOVQ $0, R10
@ -548,7 +548,7 @@ TEXT runtime·access(SB),NOSPLIT,$0
TEXT runtime·connect(SB),NOSPLIT,$0-28 TEXT runtime·connect(SB),NOSPLIT,$0-28
MOVL fd+0(FP), DI MOVL fd+0(FP), DI
MOVQ addr+8(FP), SI MOVQ addr+8(FP), SI
MOVL addrlen+16(FP), DX MOVL len+16(FP), DX
MOVL $42, AX // syscall entry MOVL $42, AX // syscall entry
SYSCALL SYSCALL
MOVL AX, ret+24(FP) MOVL AX, ret+24(FP)
@ -557,8 +557,8 @@ TEXT runtime·connect(SB),NOSPLIT,$0-28
// int socket(int domain, int type, int protocol) // int socket(int domain, int type, int protocol)
TEXT runtime·socket(SB),NOSPLIT,$0-20 TEXT runtime·socket(SB),NOSPLIT,$0-20
MOVL domain+0(FP), DI MOVL domain+0(FP), DI
MOVL type+4(FP), SI MOVL typ+4(FP), SI
MOVL protocol+8(FP), DX MOVL prot+8(FP), DX
MOVL $41, AX // syscall entry MOVL $41, AX // syscall entry
SYSCALL SYSCALL
MOVL AX, ret+16(FP) MOVL AX, ret+16(FP)

23
src/runtime/sys_linux_arm.s
View File

@ -235,13 +235,12 @@ TEXT runtime·nanotime(SB),NOSPLIT,$32
// int32 futex(int32 *uaddr, int32 op, int32 val, // int32 futex(int32 *uaddr, int32 op, int32 val,
// struct timespec *timeout, int32 *uaddr2, int32 val2); // struct timespec *timeout, int32 *uaddr2, int32 val2);
TEXT runtime·futex(SB),NOSPLIT,$0 TEXT runtime·futex(SB),NOSPLIT,$0
// TODO: Rewrite to use FP references. Vet complains. MOVW addr+0(FP), R0
MOVW 4(R13), R0 MOVW op+4(FP), R1
MOVW 8(R13), R1 MOVW val+8(FP), R2
MOVW 12(R13), R2 MOVW ts+12(FP), R3
MOVW 16(R13), R3 MOVW addr2+16(FP), R4
MOVW 20(R13), R4 MOVW val3+20(FP), R5
MOVW 24(R13), R5
MOVW $SYS_futex, R7 MOVW $SYS_futex, R7
SWI $0 SWI $0
MOVW R0, ret+24(FP) MOVW R0, ret+24(FP)
@ -259,9 +258,9 @@ TEXT runtime·clone(SB),NOSPLIT,$0
// Copy mp, gp, fn off parent stack for use by child. // Copy mp, gp, fn off parent stack for use by child.
// TODO(kaib): figure out which registers are clobbered by clone and avoid stack copying // TODO(kaib): figure out which registers are clobbered by clone and avoid stack copying
MOVW $-16(R1), R1 MOVW $-16(R1), R1
MOVW mm+8(FP), R6 MOVW mp+8(FP), R6
MOVW R6, 0(R1) MOVW R6, 0(R1)
MOVW gg+12(FP), R6 MOVW gp+12(FP), R6
MOVW R6, 4(R1) MOVW R6, 4(R1)
MOVW fn+16(FP), R6 MOVW fn+16(FP), R6
MOVW R6, 8(R1) MOVW R6, 8(R1)
@ -491,7 +490,7 @@ TEXT runtime·access(SB),NOSPLIT,$0
TEXT runtime·connect(SB),NOSPLIT,$0 TEXT runtime·connect(SB),NOSPLIT,$0
MOVW fd+0(FP), R0 MOVW fd+0(FP), R0
MOVW addr+4(FP), R1 MOVW addr+4(FP), R1
MOVW addrlen+8(FP), R2 MOVW len+8(FP), R2
MOVW $SYS_connect, R7 MOVW $SYS_connect, R7
SWI $0 SWI $0
MOVW R0, ret+12(FP) MOVW R0, ret+12(FP)
@ -499,8 +498,8 @@ TEXT runtime·connect(SB),NOSPLIT,$0
TEXT runtime·socket(SB),NOSPLIT,$0 TEXT runtime·socket(SB),NOSPLIT,$0
MOVW domain+0(FP), R0 MOVW domain+0(FP), R0
MOVW type+4(FP), R1 MOVW typ+4(FP), R1
MOVW protocol+8(FP), R2 MOVW prot+8(FP), R2
MOVW $SYS_socket, R7 MOVW $SYS_socket, R7
SWI $0 SWI $0
MOVW R0, ret+12(FP) MOVW R0, ret+12(FP)

4
src/runtime/sys_linux_arm64.s
View File

@ -319,8 +319,8 @@ TEXT runtime·clone(SB),NOSPLIT,$-8
MOVD stk+8(FP), R1 MOVD stk+8(FP), R1
// Copy mp, gp, fn off parent stack for use by child. // Copy mp, gp, fn off parent stack for use by child.
MOVD mm+16(FP), R10 MOVD mp+16(FP), R10
MOVD gg+24(FP), R11 MOVD gp+24(FP), R11
MOVD fn+32(FP), R12 MOVD fn+32(FP), R12
MOVD R10, -8(R1) MOVD R10, -8(R1)

4
src/runtime/sys_linux_mips64x.s
View File

@ -309,8 +309,8 @@ TEXT runtime·clone(SB),NOSPLIT,$-8
// Copy mp, gp, fn off parent stack for use by child. // Copy mp, gp, fn off parent stack for use by child.
// Careful: Linux system call clobbers ???. // Careful: Linux system call clobbers ???.
MOVV mm+16(FP), R16 MOVV mp+16(FP), R16
MOVV gg+24(FP), R17 MOVV gp+24(FP), R17
MOVV fn+32(FP), R18 MOVV fn+32(FP), R18
MOVV R16, -8(R5) MOVV R16, -8(R5)

4
src/runtime/sys_linux_ppc64x.s
View File

@ -304,8 +304,8 @@ TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
// Copy mp, gp, fn off parent stack for use by child. // Copy mp, gp, fn off parent stack for use by child.
// Careful: Linux system call clobbers ???. // Careful: Linux system call clobbers ???.
MOVD mm+16(FP), R7 MOVD mp+16(FP), R7
MOVD gg+24(FP), R8 MOVD gp+24(FP), R8
MOVD fn+32(FP), R12 MOVD fn+32(FP), R12
MOVD R7, -8(R4) MOVD R7, -8(R4)

4
src/runtime/sys_nacl_386.s
View File

@ -368,9 +368,9 @@ ret:
// func getRandomData([]byte) // func getRandomData([]byte)
TEXT runtime·getRandomData(SB),NOSPLIT,$8-12 TEXT runtime·getRandomData(SB),NOSPLIT,$8-12
MOVL buf+0(FP), AX MOVL arg_base+0(FP), AX
MOVL AX, 0(SP) MOVL AX, 0(SP)
MOVL len+4(FP), AX MOVL arg_len+4(FP), AX
MOVL AX, 4(SP) MOVL AX, 4(SP)
NACL_SYSCALL(SYS_get_random_bytes) NACL_SYSCALL(SYS_get_random_bytes)
RET RET

10
src/runtime/sys_netbsd_amd64.s
View File

@ -337,11 +337,11 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout) // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
TEXT runtime·kevent(SB),NOSPLIT,$0 TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL fd+0(FP), DI MOVL kq+0(FP), DI
MOVQ ev1+8(FP), SI MOVQ ch+8(FP), SI
MOVL nev1+16(FP), DX MOVL nch+16(FP), DX
MOVQ ev2+24(FP), R10 MOVQ ev+24(FP), R10
MOVL nev2+32(FP), R8 MOVL nev+32(FP), R8
MOVQ ts+40(FP), R9 MOVQ ts+40(FP), R9
MOVL $435, AX MOVL $435, AX
SYSCALL SYSCALL

10
src/runtime/sys_openbsd_amd64.s
View File

@ -327,11 +327,11 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
TEXT runtime·kevent(SB),NOSPLIT,$0 TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL fd+0(FP), DI MOVL kq+0(FP), DI
MOVQ ev1+8(FP), SI MOVQ ch+8(FP), SI
MOVL nev1+16(FP), DX MOVL nch+16(FP), DX
MOVQ ev2+24(FP), R10 MOVQ ev+24(FP), R10
MOVL nev2+32(FP), R8 MOVL nev+32(FP), R8
MOVQ ts+40(FP), R9 MOVQ ts+40(FP), R9
MOVL $72, AX MOVL $72, AX
SYSCALL SYSCALL

74
src/runtime/sys_openbsd_arm.s
View File

@ -15,7 +15,7 @@
// Exit the entire program (like C exit) // Exit the entire program (like C exit)
TEXT runtime·exit(SB),NOSPLIT,$-4 TEXT runtime·exit(SB),NOSPLIT,$-4
MOVW status+0(FP), R0 // arg 1 - status MOVW code+0(FP), R0 // arg 1 - status
MOVW $1, R12 // sys_exit MOVW $1, R12 // sys_exit
SWI $0 SWI $0
MOVW.CS $0, R8 // crash on syscall failure MOVW.CS $0, R8 // crash on syscall failure
@ -31,9 +31,9 @@ TEXT runtime·exit1(SB),NOSPLIT,$-4
RET RET
TEXT runtime·open(SB),NOSPLIT,$-4 TEXT runtime·open(SB),NOSPLIT,$-4
MOVW path+0(FP), R0 // arg 1 - path MOVW name+0(FP), R0 // arg 1 - path
MOVW flags+4(FP), R1 // arg 2 - flags MOVW mode+4(FP), R1 // arg 2 - mode
MOVW mode+8(FP), R2 // arg 3 - mode MOVW perm+8(FP), R2 // arg 3 - perm
MOVW $5, R12 // sys_open MOVW $5, R12 // sys_open
SWI $0 SWI $0
MOVW.CS $-1, R0 MOVW.CS $-1, R0
@ -41,7 +41,7 @@ TEXT runtime·open(SB),NOSPLIT,$-4
RET RET
TEXT runtime·closefd(SB),NOSPLIT,$-4 TEXT runtime·closefd(SB),NOSPLIT,$-4
MOVW path+0(FP), R0 // arg 1 - path MOVW fd+0(FP), R0 // arg 1 - fd
MOVW $6, R12 // sys_close MOVW $6, R12 // sys_close
SWI $0 SWI $0
MOVW.CS $-1, R0 MOVW.CS $-1, R0
@ -50,8 +50,8 @@ TEXT runtime·closefd(SB),NOSPLIT,$-4
TEXT runtime·read(SB),NOSPLIT,$-4 TEXT runtime·read(SB),NOSPLIT,$-4
MOVW fd+0(FP), R0 // arg 1 - fd MOVW fd+0(FP), R0 // arg 1 - fd
MOVW buf+4(FP), R1 // arg 2 - buf MOVW p+4(FP), R1 // arg 2 - buf
MOVW nbyte+8(FP), R2 // arg 3 - nbyte MOVW n+8(FP), R2 // arg 3 - nbyte
MOVW $3, R12 // sys_read MOVW $3, R12 // sys_read
SWI $0 SWI $0
MOVW.CS $-1, R0 MOVW.CS $-1, R0
@ -60,8 +60,8 @@ TEXT runtime·read(SB),NOSPLIT,$-4
TEXT runtime·write(SB),NOSPLIT,$-4 TEXT runtime·write(SB),NOSPLIT,$-4
MOVW fd+0(FP), R0 // arg 1 - fd MOVW fd+0(FP), R0 // arg 1 - fd
MOVW buf+4(FP), R1 // arg 2 - buf MOVW p+4(FP), R1 // arg 2 - buf
MOVW nbyte+8(FP), R2 // arg 3 - nbyte MOVW n+8(FP), R2 // arg 3 - nbyte
MOVW $4, R12 // sys_write MOVW $4, R12 // sys_write
SWI $0 SWI $0
MOVW.CS $-1, R0 MOVW.CS $-1, R0
@ -104,14 +104,14 @@ TEXT runtime·raiseproc(SB),NOSPLIT,$12
TEXT runtime·mmap(SB),NOSPLIT,$16 TEXT runtime·mmap(SB),NOSPLIT,$16
MOVW addr+0(FP), R0 // arg 1 - addr MOVW addr+0(FP), R0 // arg 1 - addr
MOVW len+4(FP), R1 // arg 2 - len MOVW n+4(FP), R1 // arg 2 - len
MOVW prot+8(FP), R2 // arg 3 - prot MOVW prot+8(FP), R2 // arg 3 - prot
MOVW flags+12(FP), R3 // arg 4 - flags MOVW flags+12(FP), R3 // arg 4 - flags
MOVW fd+16(FP), R4 // arg 5 - fd (on stack) MOVW fd+16(FP), R4 // arg 5 - fd (on stack)
MOVW R4, 4(R13) MOVW R4, 4(R13)
MOVW $0, R5 // arg 6 - pad (on stack) MOVW $0, R5 // arg 6 - pad (on stack)
MOVW R5, 8(R13) MOVW R5, 8(R13)
MOVW offset+20(FP), R6 // arg 7 - offset (on stack) MOVW off+20(FP), R6 // arg 7 - offset (on stack)
MOVW R6, 12(R13) // lower 32 bits (from Go runtime) MOVW R6, 12(R13) // lower 32 bits (from Go runtime)
MOVW $0, R7 MOVW $0, R7
MOVW R7, 16(R13) // high 32 bits MOVW R7, 16(R13) // high 32 bits
@ -124,7 +124,7 @@ TEXT runtime·mmap(SB),NOSPLIT,$16
TEXT runtime·munmap(SB),NOSPLIT,$0 TEXT runtime·munmap(SB),NOSPLIT,$0
MOVW addr+0(FP), R0 // arg 1 - addr MOVW addr+0(FP), R0 // arg 1 - addr
MOVW len+4(FP), R1 // arg 2 - len MOVW n+4(FP), R1 // arg 2 - len
MOVW $73, R12 // sys_munmap MOVW $73, R12 // sys_munmap
SWI $0 SWI $0
MOVW.CS $0, R8 // crash on syscall failure MOVW.CS $0, R8 // crash on syscall failure
@ -133,8 +133,8 @@ TEXT runtime·munmap(SB),NOSPLIT,$0
TEXT runtime·madvise(SB),NOSPLIT,$0 TEXT runtime·madvise(SB),NOSPLIT,$0
MOVW addr+0(FP), R0 // arg 1 - addr MOVW addr+0(FP), R0 // arg 1 - addr
MOVW len+4(FP), R1 // arg 2 - len MOVW n+4(FP), R1 // arg 2 - len
MOVW behav+8(FP), R2 // arg 2 - behav MOVW flags+8(FP), R2 // arg 2 - flags
MOVW $75, R12 // sys_madvise MOVW $75, R12 // sys_madvise
SWI $0 SWI $0
MOVW.CS $0, R8 // crash on syscall failure MOVW.CS $0, R8 // crash on syscall failure
@ -142,9 +142,9 @@ TEXT runtime·madvise(SB),NOSPLIT,$0
RET RET
TEXT runtime·setitimer(SB),NOSPLIT,$0 TEXT runtime·setitimer(SB),NOSPLIT,$0
MOVW which+0(FP), R0 // arg 1 - which MOVW mode+0(FP), R0 // arg 1 - mode
MOVW value+4(FP), R1 // arg 2 - value MOVW new+4(FP), R1 // arg 2 - new value
MOVW ovalue+8(FP), R2 // arg 3 - ovalue MOVW old+8(FP), R2 // arg 3 - old value
MOVW $69, R12 // sys_setitimer MOVW $69, R12 // sys_setitimer
SWI $0 SWI $0
RET RET
@ -189,9 +189,9 @@ TEXT runtime·nanotime(SB),NOSPLIT,$32
RET RET
TEXT runtime·sigaction(SB),NOSPLIT,$0 TEXT runtime·sigaction(SB),NOSPLIT,$0
MOVW signum+0(FP), R0 // arg 1 - signum MOVW sig+0(FP), R0 // arg 1 - signum
MOVW nsa+4(FP), R1 // arg 2 - nsa MOVW new+4(FP), R1 // arg 2 - new sigaction
MOVW osa+8(FP), R2 // arg 3 - osa MOVW old+8(FP), R2 // arg 3 - old sigaction
MOVW $46, R12 // sys_sigaction MOVW $46, R12 // sys_sigaction
SWI $0 SWI $0
MOVW.CS $3, R8 // crash on syscall failure MOVW.CS $3, R8 // crash on syscall failure
@ -199,8 +199,8 @@ TEXT runtime·sigaction(SB),NOSPLIT,$0
RET RET
TEXT runtime·sigprocmask(SB),NOSPLIT,$0 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVW how+0(FP), R0 // arg 1 - how MOVW mode+0(FP), R0 // arg 1 - mode
MOVW mask+4(FP), R1 // arg 2 - mask MOVW new+4(FP), R1 // arg 2 - new
MOVW $48, R12 // sys_sigprocmask MOVW $48, R12 // sys_sigprocmask
SWI $0 SWI $0
MOVW.CS $3, R8 // crash on syscall failure MOVW.CS $3, R8 // crash on syscall failure
@ -274,8 +274,8 @@ TEXT runtime·tfork(SB),NOSPLIT,$0
RET RET
TEXT runtime·sigaltstack(SB),NOSPLIT,$0 TEXT runtime·sigaltstack(SB),NOSPLIT,$0
MOVW nss+0(FP), R0 // arg 1 - nss MOVW new+0(FP), R0 // arg 1 - new sigaltstack
MOVW oss+4(FP), R1 // arg 2 - oss MOVW old+4(FP), R1 // arg 2 - old sigaltstack
MOVW $288, R12 // sys_sigaltstack MOVW $288, R12 // sys_sigaltstack
SWI $0 SWI $0
MOVW.CS $0, R8 // crash on syscall failure MOVW.CS $0, R8 // crash on syscall failure
@ -290,7 +290,7 @@ TEXT runtime·osyield(SB),NOSPLIT,$0
TEXT runtime·thrsleep(SB),NOSPLIT,$4 TEXT runtime·thrsleep(SB),NOSPLIT,$4
MOVW ident+0(FP), R0 // arg 1 - ident MOVW ident+0(FP), R0 // arg 1 - ident
MOVW clock_id+4(FP), R1 // arg 2 - clock_id MOVW clock_id+4(FP), R1 // arg 2 - clock_id
MOVW tp+8(FP), R2 // arg 3 - tp MOVW tsp+8(FP), R2 // arg 3 - tsp
MOVW lock+12(FP), R3 // arg 4 - lock MOVW lock+12(FP), R3 // arg 4 - lock
MOVW abort+16(FP), R4 // arg 5 - abort (on stack) MOVW abort+16(FP), R4 // arg 5 - abort (on stack)
MOVW R4, 4(R13) MOVW R4, 4(R13)
@ -310,13 +310,13 @@ TEXT runtime·thrwakeup(SB),NOSPLIT,$0
RET RET
TEXT runtime·sysctl(SB),NOSPLIT,$8 TEXT runtime·sysctl(SB),NOSPLIT,$8
MOVW name+0(FP), R0 // arg 1 - name MOVW mib+0(FP), R0 // arg 1 - mib
MOVW namelen+4(FP), R1 // arg 2 - namelen MOVW miblen+4(FP), R1 // arg 2 - miblen
MOVW oldp+8(FP), R2 // arg 3 - oldp MOVW out+8(FP), R2 // arg 3 - out
MOVW oldlenp+12(FP), R3 // arg 4 - oldlenp MOVW size+12(FP), R3 // arg 4 - size
MOVW newp+16(FP), R4 // arg 5 - newp (on stack) MOVW dst+16(FP), R4 // arg 5 - dest (on stack)
MOVW R4, 4(R13) MOVW R4, 4(R13)
MOVW newlen+20(FP), R5 // arg 6 - newlen (on stack) MOVW ndst+20(FP), R5 // arg 6 - newlen (on stack)
MOVW R5, 8(R13) MOVW R5, 8(R13)
ADD $4, R13 ADD $4, R13
MOVW $202, R12 // sys___sysctl MOVW $202, R12 // sys___sysctl
@ -337,13 +337,13 @@ TEXT runtime·kqueue(SB),NOSPLIT,$0
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
TEXT runtime·kevent(SB),NOSPLIT,$8 TEXT runtime·kevent(SB),NOSPLIT,$8
MOVW fd+0(FP), R0 // arg 1 - fd MOVW kq+0(FP), R0 // arg 1 - kq
MOVW changelist+4(FP), R1 // arg 2 - changelist MOVW ch+4(FP), R1 // arg 2 - changelist
MOVW nchanges+8(FP), R2 // arg 3 - nchanges MOVW nch+8(FP), R2 // arg 3 - nchanges
MOVW eventlist+12(FP), R3 // arg 4 - eventlist MOVW ev+12(FP), R3 // arg 4 - eventlist
MOVW nevents+16(FP), R4 // arg 5 - nevents (on stack) MOVW nev+16(FP), R4 // arg 5 - nevents (on stack)
MOVW R4, 4(R13) MOVW R4, 4(R13)
MOVW timeout+20(FP), R5 // arg 6 - timeout (on stack) MOVW ts+20(FP), R5 // arg 6 - timeout (on stack)
MOVW R5, 8(R13) MOVW R5, 8(R13)
ADD $4, R13 ADD $4, R13
MOVW $72, R12 // sys_kevent MOVW $72, R12 // sys_kevent

18
src/runtime/vlop_386.s
View File

@ -29,28 +29,28 @@
* C runtime for 64-bit divide. * C runtime for 64-bit divide.
*/ */
// runtime·_mul64x32(r *uint64, a uint64, b uint32) uint32 // runtime·_mul64x32(lo64 *uint64, a uint64, b uint32) (hi32 uint32)
// sets *r = low 64 bits of 96-bit product a*b; returns high 32 bits. // sets *lo64 = low 64 bits of 96-bit product a*b; returns high 32 bits.
TEXT runtime·_mul64by32(SB), NOSPLIT, $0 TEXT runtime·_mul64by32(SB), NOSPLIT, $0
MOVL r+0(FP), CX MOVL lo64+0(FP), CX
MOVL a+4(FP), AX MOVL a_lo+4(FP), AX
MULL b+12(FP) MULL b+12(FP)
MOVL AX, 0(CX) MOVL AX, 0(CX)
MOVL DX, BX MOVL DX, BX
MOVL a+8(FP), AX MOVL a_hi+8(FP), AX
MULL b+12(FP) MULL b+12(FP)
ADDL AX, BX ADDL AX, BX
ADCL $0, DX ADCL $0, DX
MOVL BX, 4(CX) MOVL BX, 4(CX)
MOVL DX, AX MOVL DX, AX
MOVL AX, ret+16(FP) MOVL AX, hi32+16(FP)
RET RET
TEXT runtime·_div64by32(SB), NOSPLIT, $0 TEXT runtime·_div64by32(SB), NOSPLIT, $0
MOVL r+12(FP), CX MOVL r+12(FP), CX
MOVL a+0(FP), AX MOVL a_lo+0(FP), AX
MOVL a+4(FP), DX MOVL a_hi+4(FP), DX
DIVL b+8(FP) DIVL b+8(FP)
MOVL DX, 0(CX) MOVL DX, 0(CX)
MOVL AX, ret+16(FP) MOVL AX, q+16(FP)
RET RET

42
src/sync/atomic/asm_arm.s
View File

@ -35,11 +35,11 @@ casloop:
BNE casloop BNE casloop
MOVW $1, R0 MOVW $1, R0
DMB_ISH_7 DMB_ISH_7
MOVBU R0, ret+12(FP) MOVBU R0, swapped+12(FP)
RET RET
casfail: casfail:
MOVW $0, R0 MOVW $0, R0
MOVBU R0, ret+12(FP) MOVBU R0, swapped+12(FP)
RET RET
TEXT ·armCompareAndSwapUint64(SB),NOSPLIT,$0-21 TEXT ·armCompareAndSwapUint64(SB),NOSPLIT,$0-21
@ -49,10 +49,10 @@ TEXT ·armCompareAndSwapUint64(SB),NOSPLIT,$0-21
AND.S $7, R1, R2 AND.S $7, R1, R2
BEQ 2(PC) BEQ 2(PC)
MOVW R2, (R2) MOVW R2, (R2)
MOVW oldlo+4(FP), R2 MOVW old_lo+4(FP), R2
MOVW oldhi+8(FP), R3 MOVW old_hi+8(FP), R3
MOVW newlo+12(FP), R4 MOVW new_lo+12(FP), R4
MOVW newhi+16(FP), R5 MOVW new_hi+16(FP), R5
cas64loop: cas64loop:
// LDREXD and STREXD were introduced in ARMv6k. // LDREXD and STREXD were introduced in ARMv6k.
LDREXD (R1), R6 // loads R6 and R7 LDREXD (R1), R6 // loads R6 and R7
@ -66,11 +66,11 @@ cas64loop:
BNE cas64loop BNE cas64loop
MOVW $1, R0 MOVW $1, R0
DMB_ISH_7 DMB_ISH_7
MOVBU R0, ret+20(FP) MOVBU R0, swapped+20(FP)
RET RET
cas64fail: cas64fail:
MOVW $0, R0 MOVW $0, R0
MOVBU R0, ret+20(FP) MOVBU R0, swapped+20(FP)
RET RET
TEXT ·armAddUint32(SB),NOSPLIT,$0-12 TEXT ·armAddUint32(SB),NOSPLIT,$0-12
@ -85,7 +85,7 @@ addloop:
CMP $0, R0 CMP $0, R0
BNE addloop BNE addloop
DMB_ISH_7 DMB_ISH_7
MOVW R3, ret+8(FP) MOVW R3, new+8(FP)
RET RET
TEXT ·armAddUint64(SB),NOSPLIT,$0-20 TEXT ·armAddUint64(SB),NOSPLIT,$0-20
@ -95,8 +95,8 @@ TEXT ·armAddUint64(SB),NOSPLIT,$0-20
AND.S $7, R1, R2 AND.S $7, R1, R2
BEQ 2(PC) BEQ 2(PC)
MOVW R2, (R2) MOVW R2, (R2)
MOVW deltalo+4(FP), R2 MOVW delta_lo+4(FP), R2
MOVW deltahi+8(FP), R3 MOVW delta_hi+8(FP), R3
add64loop: add64loop:
// LDREXD and STREXD were introduced in ARMv6k. // LDREXD and STREXD were introduced in ARMv6k.
LDREXD (R1), R4 // loads R4 and R5 LDREXD (R1), R4 // loads R4 and R5
@ -107,8 +107,8 @@ add64loop:
CMP $0, R0 CMP $0, R0
BNE add64loop BNE add64loop
DMB_ISH_7 DMB_ISH_7
MOVW R4, retlo+12(FP) MOVW R4, new_lo+12(FP)
MOVW R5, rethi+16(FP) MOVW R5, new_hi+16(FP)
RET RET
TEXT ·armSwapUint32(SB),NOSPLIT,$0-12 TEXT ·armSwapUint32(SB),NOSPLIT,$0-12
@ -132,8 +132,8 @@ TEXT ·armSwapUint64(SB),NOSPLIT,$0-20
AND.S $7, R1, R2 AND.S $7, R1, R2
BEQ 2(PC) BEQ 2(PC)
MOVW R2, (R2) MOVW R2, (R2)
MOVW newlo+4(FP), R2 MOVW new_lo+4(FP), R2
MOVW newhi+8(FP), R3 MOVW new_hi+8(FP), R3
swap64loop: swap64loop:
// LDREXD and STREXD were introduced in ARMv6k. // LDREXD and STREXD were introduced in ARMv6k.
LDREXD (R1), R4 // loads R4 and R5 LDREXD (R1), R4 // loads R4 and R5
@ -142,8 +142,8 @@ swap64loop:
CMP $0, R0 CMP $0, R0
BNE swap64loop BNE swap64loop
DMB_ISH_7 DMB_ISH_7
MOVW R4, oldlo+12(FP) MOVW R4, old_lo+12(FP)
MOVW R5, oldhi+16(FP) MOVW R5, old_hi+16(FP)
RET RET
TEXT ·armLoadUint64(SB),NOSPLIT,$0-12 TEXT ·armLoadUint64(SB),NOSPLIT,$0-12
@ -160,8 +160,8 @@ load64loop:
CMP $0, R0 CMP $0, R0
BNE load64loop BNE load64loop
DMB_ISH_7 DMB_ISH_7
MOVW R2, vallo+4(FP) MOVW R2, val_lo+4(FP)
MOVW R3, valhi+8(FP) MOVW R3, val_hi+8(FP)
RET RET
TEXT ·armStoreUint64(SB),NOSPLIT,$0-12 TEXT ·armStoreUint64(SB),NOSPLIT,$0-12
@ -171,8 +171,8 @@ TEXT ·armStoreUint64(SB),NOSPLIT,$0-12
AND.S $7, R1, R2 AND.S $7, R1, R2
BEQ 2(PC) BEQ 2(PC)
MOVW R2, (R2) MOVW R2, (R2)
MOVW vallo+4(FP), R2 MOVW val_lo+4(FP), R2
MOVW valhi+8(FP), R3 MOVW val_hi+8(FP), R3
store64loop: store64loop:
LDREXD (R1), R4 // loads R4 and R5 LDREXD (R1), R4 // loads R4 and R5
DMB_ISHST_7 DMB_ISHST_7

4
src/sync/atomic/asm_mips64x.s
View File

@ -104,7 +104,7 @@ TEXT ·AddUint32(SB),NOSPLIT,$0-20
MOVV R4, R1 MOVV R4, R1
SC(2, 4) // *R2 = R4 SC(2, 4) // *R2 = R4
BEQ R4, -4(PC) BEQ R4, -4(PC)
MOVW R1, ret+16(FP) MOVW R1, new+16(FP)
SYNC SYNC
RET RET
@ -123,7 +123,7 @@ TEXT ·AddUint64(SB),NOSPLIT,$0-24
MOVV R4, R1 MOVV R4, R1
SCV(2, 4) // *R2 = R4 SCV(2, 4) // *R2 = R4
BEQ R4, -4(PC) BEQ R4, -4(PC)
MOVV R1, ret+16(FP) MOVV R1, new+16(FP)
SYNC SYNC
RET RET

4
src/sync/atomic/asm_ppc64x.s
View File

@ -92,7 +92,7 @@ TEXT ·AddUint32(SB),NOSPLIT,$0-20
STWCCC R5, (R3) STWCCC R5, (R3)
BNE -3(PC) BNE -3(PC)
ISYNC ISYNC
MOVW R5, ret+16(FP) MOVW R5, new+16(FP)
RET RET
TEXT ·AddUintptr(SB),NOSPLIT,$0-24 TEXT ·AddUintptr(SB),NOSPLIT,$0-24
@ -110,7 +110,7 @@ TEXT ·AddUint64(SB),NOSPLIT,$0-24
STDCCC R5, (R3) STDCCC R5, (R3)
BNE -3(PC) BNE -3(PC)
ISYNC ISYNC
MOVD R5, ret+16(FP) MOVD R5, new+16(FP)
RET RET
TEXT ·LoadInt32(SB),NOSPLIT,$0-12 TEXT ·LoadInt32(SB),NOSPLIT,$0-12

23
src/syscall/asm9_unix1_amd64.s
View File

@ -4,9 +4,6 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // 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 "textflag.h"
#include "funcdata.h" #include "funcdata.h"
@ -17,16 +14,16 @@
// func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64); // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64);
TEXT ·Syscall9(SB),NOSPLIT,$0-104 TEXT ·Syscall9(SB),NOSPLIT,$0-104
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVQ 8(SP), AX // syscall entry MOVQ num+0(FP), AX // syscall entry
MOVQ 16(SP), DI MOVQ a1+8(FP), DI
MOVQ 24(SP), SI MOVQ a2+16(FP), SI
MOVQ 32(SP), DX MOVQ a3+24(FP), DX
MOVQ 40(SP), R10 MOVQ a4+32(FP), R10
MOVQ 48(SP), R8 MOVQ a5+40(FP), R8
MOVQ 56(SP), R9 MOVQ a6+48(FP), R9
MOVQ 64(SP), R11 MOVQ a7+56(FP), R11
MOVQ 72(SP), R12 MOVQ a8+64(FP), R12
MOVQ 80(SP), R13 MOVQ a9+72(FP), R13
SUBQ $32, SP SUBQ $32, SP
MOVQ R11, 8(SP) // arg 7 MOVQ R11, 8(SP) // arg 7
MOVQ R12, 16(SP) // arg 8 MOVQ R12, 16(SP) // arg 8

35
src/syscall/asm9_unix2_amd64.s
View File

@ -4,9 +4,6 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // 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 "textflag.h"
#include "funcdata.h" #include "funcdata.h"
@ -17,33 +14,33 @@
// func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64); // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64);
TEXT ·Syscall9(SB),NOSPLIT,$0-104 TEXT ·Syscall9(SB),NOSPLIT,$0-104
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVQ 8(SP), AX // syscall entry MOVQ num+0(FP), AX // syscall entry
MOVQ 16(SP), DI MOVQ a1+8(FP), DI
MOVQ 24(SP), SI MOVQ a2+16(FP), SI
MOVQ 32(SP), DX MOVQ a3+24(FP), DX
MOVQ 40(SP), R10 MOVQ a4+32(FP), R10
MOVQ 48(SP), R8 MOVQ a5+40(FP), R8
MOVQ 56(SP), R9 MOVQ a6+48(FP), R9
// shift around the last three arguments so they're at the // shift around the last three arguments so they're at the
// top of the stack when the syscall is called. // top of the stack when the syscall is called.
MOVQ 64(SP), R11 // arg 7 MOVQ a7+56(FP), R11 // arg 7
MOVQ R11, 8(SP) MOVQ R11, 8(SP)
MOVQ 72(SP), R11 // arg 8 MOVQ a8+64(FP), R11 // arg 8
MOVQ R11, 16(SP) MOVQ R11, 16(SP)
MOVQ 80(SP), R11 // arg 9 MOVQ a9+72(FP), R11 // arg 9
MOVQ R11, 24(SP) MOVQ R11, 24(SP)
SYSCALL SYSCALL
JCC ok9 JCC ok9
MOVQ $-1, 88(SP) // r1 MOVQ $-1, r1+80(FP) // r1
MOVQ $0, 96(SP) // r2 MOVQ $0, r2+88(FP) // r2
MOVQ AX, 104(SP) // errno MOVQ AX, err+96(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
ok9: ok9:
MOVQ AX, 88(SP) // r1 MOVQ AX, r1+80(FP) // r1
MOVQ DX, 96(SP) // r2 MOVQ DX, r2+88(FP) // r2
MOVQ $0, 104(SP) // errno MOVQ $0, err+96(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET

30
src/syscall/asm_darwin_arm64.s
View File

@ -8,10 +8,10 @@
// System call support for ARM64, Darwin // System call support for ARM64, Darwin
// //
// func Syscall(syscall uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr) // func Syscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr)
TEXT ·Syscall(SB),NOSPLIT,$0-56 TEXT ·Syscall(SB),NOSPLIT,$0-56
BL runtime·entersyscall(SB) BL runtime·entersyscall(SB)
MOVD syscall+0(FP), R16 MOVD trap+0(FP), R16
MOVD a1+8(FP), R0 MOVD a1+8(FP), R0
MOVD a2+16(FP), R1 MOVD a2+16(FP), R1
MOVD a3+24(FP), R2 MOVD a3+24(FP), R2
@ -20,19 +20,19 @@ TEXT ·Syscall(SB),NOSPLIT,$0-56
MOVD $-1, R1 MOVD $-1, R1
MOVD R1, r1+32(FP) // r1 MOVD R1, r1+32(FP) // r1
MOVD ZR, r2+40(FP) // r2 MOVD ZR, r2+40(FP) // r2
MOVD R0, errno+48(FP) // errno MOVD R0, err+48(FP) // err
BL runtime·exitsyscall(SB) BL runtime·exitsyscall(SB)
RET RET
ok: ok:
MOVD R0, r1+32(FP) // r1 MOVD R0, r1+32(FP) // r1
MOVD R1, r2+40(FP) // r2 MOVD R1, r2+40(FP) // r2
MOVD ZR, errno+48(FP) // errno MOVD ZR, err+48(FP) // err
BL runtime·exitsyscall(SB) BL runtime·exitsyscall(SB)
RET RET
// func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr) // func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr)
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
MOVD syscall+0(FP), R16 // syscall entry MOVD trap+0(FP), R16 // syscall entry
MOVD a1+8(FP), R0 MOVD a1+8(FP), R0
MOVD a2+16(FP), R1 MOVD a2+16(FP), R1
MOVD a3+24(FP), R2 MOVD a3+24(FP), R2
@ -41,18 +41,18 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-56
MOVD $-1, R1 MOVD $-1, R1
MOVD R1, r1+32(FP) // r1 MOVD R1, r1+32(FP) // r1
MOVD ZR, r2+40(FP) // r2 MOVD ZR, r2+40(FP) // r2
MOVD R0, errno+48(FP) // errno MOVD R0, err+48(FP) // err
RET RET
ok: ok:
MOVD R0, r1+32(FP) // r1 MOVD R0, r1+32(FP) // r1
MOVD R1, r2+40(FP) // r2 MOVD R1, r2+40(FP) // r2
MOVD ZR, errno+48(FP) // errno MOVD ZR, err+48(FP) // err
RET RET
// func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) // func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
TEXT ·Syscall6(SB),NOSPLIT,$0-80 TEXT ·Syscall6(SB),NOSPLIT,$0-80
BL runtime·entersyscall(SB) BL runtime·entersyscall(SB)
MOVD syscall+0(FP), R16 // syscall entry MOVD trap+0(FP), R16 // syscall entry
MOVD a1+8(FP), R0 MOVD a1+8(FP), R0
MOVD a2+16(FP), R1 MOVD a2+16(FP), R1
MOVD a3+24(FP), R2 MOVD a3+24(FP), R2
@ -64,13 +64,13 @@ TEXT ·Syscall6(SB),NOSPLIT,$0-80
MOVD $-1, R1 MOVD $-1, R1
MOVD R1, r1+56(FP) // r1 MOVD R1, r1+56(FP) // r1
MOVD ZR, r2+64(FP) // r2 MOVD ZR, r2+64(FP) // r2
MOVD R0, errno+72(FP) // errno MOVD R0, err+72(FP) // err
BL runtime·exitsyscall(SB) BL runtime·exitsyscall(SB)
RET RET
ok: ok:
MOVD R0, r1+56(FP) // r1 MOVD R0, r1+56(FP) // r1
MOVD R1, r2+64(FP) // r2 MOVD R1, r2+64(FP) // r2
MOVD ZR, errno+72(FP) // errno MOVD ZR, err+72(FP) // err
BL runtime·exitsyscall(SB) BL runtime·exitsyscall(SB)
RET RET
@ -88,19 +88,19 @@ TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
MOVD $-1, R1 MOVD $-1, R1
MOVD R1, r1+56(FP) // r1 MOVD R1, r1+56(FP) // r1
MOVD ZR, r2+64(FP) // r2 MOVD ZR, r2+64(FP) // r2
MOVD R0, errno+72(FP) // errno MOVD R0, err+72(FP) // err
RET RET
ok: ok:
MOVD R0, r1+56(FP) // r1 MOVD R0, r1+56(FP) // r1
MOVD R1, r2+64(FP) // r2 MOVD R1, r2+64(FP) // r2
MOVD ZR, R0 MOVD ZR, R0
MOVD R0, errno+72(FP) // errno MOVD R0, err+72(FP) // err
RET RET
// Actually Syscall7 // Actually Syscall7
TEXT ·Syscall9(SB),NOSPLIT,$0-104 TEXT ·Syscall9(SB),NOSPLIT,$0-104
BL runtime·entersyscall(SB) BL runtime·entersyscall(SB)
MOVD syscall+0(FP), R16 // syscall entry MOVD num+0(FP), R16 // syscall entry
MOVD a1+8(FP), R0 MOVD a1+8(FP), R0
MOVD a2+16(FP), R1 MOVD a2+16(FP), R1
MOVD a3+24(FP), R2 MOVD a3+24(FP), R2
@ -115,13 +115,13 @@ TEXT ·Syscall9(SB),NOSPLIT,$0-104
MOVD $-1, R1 MOVD $-1, R1
MOVD R1, r1+80(FP) // r1 MOVD R1, r1+80(FP) // r1
MOVD ZR, r2+88(FP) // r2 MOVD ZR, r2+88(FP) // r2
MOVD R0, errno+96(FP) // errno MOVD R0, err+96(FP) // err
BL runtime·exitsyscall(SB) BL runtime·exitsyscall(SB)
RET RET
ok: ok:
MOVD R0, r1+80(FP) // r1 MOVD R0, r1+80(FP) // r1
MOVD R1, r2+88(FP) // r2 MOVD R1, r2+88(FP) // r2
MOVD ZR, errno+96(FP) // errno MOVD ZR, err+96(FP) // err
BL runtime·exitsyscall(SB) BL runtime·exitsyscall(SB)
RET RET

10
src/syscall/asm_openbsd_arm.s
View File

@ -17,7 +17,7 @@
TEXT ·Syscall(SB),NOSPLIT,$0-28 TEXT ·Syscall(SB),NOSPLIT,$0-28
BL runtime·entersyscall(SB) BL runtime·entersyscall(SB)
MOVW syscall+0(FP), R12 // syscall number MOVW trap+0(FP), R12 // syscall number
MOVW a1+4(FP), R0 // arg 1 MOVW a1+4(FP), R0 // arg 1
MOVW a2+8(FP), R1 // arg 2 MOVW a2+8(FP), R1 // arg 2
MOVW a3+12(FP), R2 // arg 3 MOVW a3+12(FP), R2 // arg 3
@ -39,7 +39,7 @@ error:
TEXT ·Syscall6(SB),NOSPLIT,$0-40 TEXT ·Syscall6(SB),NOSPLIT,$0-40
BL runtime·entersyscall(SB) BL runtime·entersyscall(SB)
MOVW syscall+0(FP), R12 // syscall number MOVW trap+0(FP), R12 // syscall number
MOVW a1+4(FP), R0 // arg 1 MOVW a1+4(FP), R0 // arg 1
MOVW a2+8(FP), R1 // arg 2 MOVW a2+8(FP), R1 // arg 2
MOVW a3+12(FP), R2 // arg 3 MOVW a3+12(FP), R2 // arg 3
@ -65,7 +65,7 @@ error6:
TEXT ·Syscall9(SB),NOSPLIT,$0-52 TEXT ·Syscall9(SB),NOSPLIT,$0-52
BL runtime·entersyscall(SB) BL runtime·entersyscall(SB)
MOVW syscall+0(FP), R12 // syscall number MOVW num+0(FP), R12 // syscall number
MOVW a1+4(FP), R0 // arg 1 MOVW a1+4(FP), R0 // arg 1
MOVW a2+8(FP), R1 // arg 2 MOVW a2+8(FP), R1 // arg 2
MOVW a3+12(FP), R2 // arg 3 MOVW a3+12(FP), R2 // arg 3
@ -90,7 +90,7 @@ error9:
RET RET
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
MOVW syscall+0(FP), R12 // syscall number MOVW trap+0(FP), R12 // syscall number
MOVW a1+4(FP), R0 // arg 1 MOVW a1+4(FP), R0 // arg 1
MOVW a2+8(FP), R1 // arg 2 MOVW a2+8(FP), R1 // arg 2
MOVW a3+12(FP), R2 // arg 3 MOVW a3+12(FP), R2 // arg 3
@ -109,7 +109,7 @@ errorr:
RET RET
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
MOVW syscall+0(FP), R12 // syscall number MOVW trap+0(FP), R12 // syscall number
MOVW a1+4(FP), R0 // arg 1 MOVW a1+4(FP), R0 // arg 1
MOVW a2+8(FP), R1 // arg 2 MOVW a2+8(FP), R1 // arg 2
MOVW a3+12(FP), R2 // arg 3 MOVW a3+12(FP), R2 // arg 3

28
src/syscall/asm_plan9_386.s
View File

@ -20,10 +20,10 @@
// Trap # in AX, args on stack above caller pc. // Trap # in AX, args on stack above caller pc.
TEXT ·Syscall(SB),NOSPLIT,$0-32 TEXT ·Syscall(SB),NOSPLIT,$0-32
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
CLD CLD
MOVSL MOVSL
MOVSL MOVSL
@ -55,10 +55,10 @@ copyresult3:
TEXT ·Syscall6(SB),NOSPLIT,$0-44 TEXT ·Syscall6(SB),NOSPLIT,$0-44
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
CLD CLD
MOVSL MOVSL
MOVSL MOVSL
@ -92,10 +92,10 @@ copyresult4:
RET RET
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
CLD CLD
MOVSL MOVSL
MOVSL MOVSL
@ -107,10 +107,10 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-28
RET RET
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
MOVL 4(SP), AX // syscall entry MOVL trap+0(SP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
CLD CLD
MOVSL MOVSL
MOVSL MOVSL
@ -136,8 +136,8 @@ TEXT ·seek(SB),NOSPLIT,$0-36
CMPL AX, $-1 CMPL AX, $-1
JNE ok6 JNE ok6
MOVL AX, 24(SP) // newoffset low MOVL AX, newoffset_lo+20(FP)
MOVL AX, 28(SP) // newoffset high MOVL AX, newoffset_hi+24(FP)
SUBL $8, SP SUBL $8, SP
CALL syscall·errstr(SB) CALL syscall·errstr(SB)

20
src/syscall/asm_plan9_amd64.s
View File

@ -19,7 +19,7 @@
TEXT ·Syscall(SB),NOSPLIT,$0-64 TEXT ·Syscall(SB),NOSPLIT,$0-64
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVQ 8(SP), BP // syscall entry MOVQ trap+0(FP), BP // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAQ 16(SP), SI LEAQ 16(SP), SI
LEAQ 8(SP), DI LEAQ 8(SP), DI
@ -54,10 +54,10 @@ copyresult3:
TEXT ·Syscall6(SB),NOSPLIT,$0-88 TEXT ·Syscall6(SB),NOSPLIT,$0-88
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVQ 8(SP), BP // syscall entry MOVQ trap+0(FP), BP // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAQ 16(SP), SI LEAQ 16(SP), SI
LEAQ 8(SP), DI LEAQ 8(SP), DI
CLD CLD
MOVSQ MOVSQ
MOVSQ MOVSQ
@ -91,10 +91,10 @@ copyresult4:
RET RET
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
MOVQ 8(SP), BP // syscall entry MOVQ trap+0(FP), BP // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAQ 16(SP), SI LEAQ 16(SP), SI
LEAQ 8(SP), DI LEAQ 8(SP), DI
CLD CLD
MOVSQ MOVSQ
MOVSQ MOVSQ
@ -106,10 +106,10 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-56
RET RET
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
MOVQ 8(SP), BP // syscall entry MOVQ trap+0(FP), BP // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAQ 16(SP), SI LEAQ 16(SP), SI
LEAQ 8(SP), DI LEAQ 8(SP), DI
CLD CLD
MOVSQ MOVSQ
MOVSQ MOVSQ

73
src/syscall/asm_unix_386.s
View File

@ -4,9 +4,6 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // 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 "textflag.h"
#include "funcdata.h" #include "funcdata.h"
@ -20,7 +17,7 @@
TEXT ·Syscall(SB),NOSPLIT,$0-28 TEXT ·Syscall(SB),NOSPLIT,$0-28
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
@ -30,21 +27,21 @@ TEXT ·Syscall(SB),NOSPLIT,$0-28
MOVSL MOVSL
INT $0x80 INT $0x80
JAE ok JAE ok
MOVL $-1, 20(SP) // r1 MOVL $-1, r1+16(FP) // r1
MOVL $-1, 24(SP) // r2 MOVL $-1, r2+20(FP) // r2
MOVL AX, 28(SP) // errno MOVL AX, err+24(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
ok: ok:
MOVL AX, 20(SP) // r1 MOVL AX, r1+16(FP) // r1
MOVL DX, 24(SP) // r2 MOVL DX, r2+20(FP) // r2
MOVL $0, 28(SP) // errno MOVL $0, err+24(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
TEXT ·Syscall6(SB),NOSPLIT,$0-40 TEXT ·Syscall6(SB),NOSPLIT,$0-40
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
@ -57,21 +54,21 @@ TEXT ·Syscall6(SB),NOSPLIT,$0-40
MOVSL MOVSL
INT $0x80 INT $0x80
JAE ok6 JAE ok6
MOVL $-1, 32(SP) // r1 MOVL $-1, r1+28(FP) // r1
MOVL $-1, 36(SP) // r2 MOVL $-1, r2+32(FP) // r2
MOVL AX, 40(SP) // errno MOVL AX, err+36(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
ok6: ok6:
MOVL AX, 32(SP) // r1 MOVL AX, r1+28(FP) // r1
MOVL DX, 36(SP) // r2 MOVL DX, r2+32(FP) // r2
MOVL $0, 40(SP) // errno MOVL $0, err+36(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
TEXT ·Syscall9(SB),NOSPLIT,$0-52 TEXT ·Syscall9(SB),NOSPLIT,$0-52
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVL 4(SP), AX // syscall entry MOVL num+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
@ -87,20 +84,20 @@ TEXT ·Syscall9(SB),NOSPLIT,$0-52
MOVSL MOVSL
INT $0x80 INT $0x80
JAE ok9 JAE ok9
MOVL $-1, 44(SP) // r1 MOVL $-1, r1+40(FP) // r1
MOVL $-1, 48(SP) // r2 MOVL $-1, r2+44(FP) // r2
MOVL AX, 52(SP) // errno MOVL AX, err+48(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
ok9: ok9:
MOVL AX, 44(SP) // r1 MOVL AX, r1+40(FP) // r1
MOVL DX, 48(SP) // r2 MOVL DX, r2+44(FP) // r2
MOVL $0, 52(SP) // errno MOVL $0, err+48(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
TEXT ·RawSyscall(SB),NOSPLIT,$0-28 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
@ -110,18 +107,18 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-28
MOVSL MOVSL
INT $0x80 INT $0x80
JAE ok1 JAE ok1
MOVL $-1, 20(SP) // r1 MOVL $-1, r1+16(FP) // r1
MOVL $-1, 24(SP) // r2 MOVL $-1, r2+20(FP) // r2
MOVL AX, 28(SP) // errno MOVL AX, err+24(FP) // errno
RET RET
ok1: ok1:
MOVL AX, 20(SP) // r1 MOVL AX, r1+16(FP) // r1
MOVL DX, 24(SP) // r2 MOVL DX, r2+20(FP) // r2
MOVL $0, 28(SP) // errno MOVL $0, err+24(FP) // errno
RET RET
TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
MOVL 4(SP), AX // syscall entry MOVL trap+0(FP), AX // syscall entry
// slide args down on top of system call number // slide args down on top of system call number
LEAL 8(SP), SI LEAL 8(SP), SI
LEAL 4(SP), DI LEAL 4(SP), DI
@ -134,12 +131,12 @@ TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
MOVSL MOVSL
INT $0x80 INT $0x80
JAE ok2 JAE ok2
MOVL $-1, 32(SP) // r1 MOVL $-1, r1+28(FP) // r1
MOVL $-1, 36(SP) // r2 MOVL $-1, r2+32(FP) // r2
MOVL AX, 40(SP) // errno MOVL AX, err+36(FP) // errno
RET RET
ok2: ok2:
MOVL AX, 32(SP) // r1 MOVL AX, r1+28(FP) // r1
MOVL DX, 36(SP) // r2 MOVL DX, r2+32(FP) // r2
MOVL $0, 40(SP) // errno MOVL $0, err+36(FP) // errno
RET RET

99
src/syscall/asm_unix_amd64.s
View File

@ -4,9 +4,6 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // 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 "textflag.h"
#include "funcdata.h" #include "funcdata.h"
@ -14,92 +11,92 @@
// System call support for AMD64 unixes // System call support for AMD64 unixes
// //
// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64); // func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64)
// func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64); // func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64)
// Trap # in AX, args in DI SI DX, return in AX DX // Trap # in AX, args in DI SI DX, return in AX DX
TEXT ·Syscall(SB),NOSPLIT,$0-56 TEXT ·Syscall(SB),NOSPLIT,$0-56
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVQ 8(SP), AX // syscall entry MOVQ trap+0(FP), AX // syscall entry
MOVQ 16(SP), DI MOVQ a1+8(FP), DI
MOVQ 24(SP), SI MOVQ a2+16(FP), SI
MOVQ 32(SP), DX MOVQ a3+24(FP), DX
MOVQ $0, R10 MOVQ $0, R10
MOVQ $0, R8 MOVQ $0, R8
MOVQ $0, R9 MOVQ $0, R9
SYSCALL SYSCALL
JCC ok JCC ok
MOVQ $-1, 40(SP) // r1 MOVQ $-1, r1+32(FP) // r1
MOVQ $0, 48(SP) // r2 MOVQ $0, r2+40(FP) // r2
MOVQ AX, 56(SP) // errno MOVQ AX, err+48(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
ok: ok:
MOVQ AX, 40(SP) // r1 MOVQ AX, r1+32(FP) // r1
MOVQ DX, 48(SP) // r2 MOVQ DX, r2+40(FP) // r2
MOVQ $0, 56(SP) // errno MOVQ $0, err+48(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
TEXT ·Syscall6(SB),NOSPLIT,$0-80 TEXT ·Syscall6(SB),NOSPLIT,$0-80
CALL runtime·entersyscall(SB) CALL runtime·entersyscall(SB)
MOVQ 8(SP), AX // syscall entry MOVQ trap+0(FP), AX // syscall entry
MOVQ 16(SP), DI MOVQ a1+8(FP), DI
MOVQ 24(SP), SI MOVQ a2+16(FP), SI
MOVQ 32(SP), DX MOVQ a3+24(FP), DX
MOVQ 40(SP), R10 MOVQ a4+32(FP), R10
MOVQ 48(SP), R8 MOVQ a5+40(FP), R8
MOVQ 56(SP), R9 MOVQ a6+48(FP), R9
SYSCALL SYSCALL
JCC ok6 JCC ok6
MOVQ $-1, 64(SP) // r1 MOVQ $-1, r1+56(FP) // r1
MOVQ $0, 72(SP) // r2 MOVQ $0, r2+64(FP) // r2
MOVQ AX, 80(SP) // errno MOVQ AX, err+72(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
ok6: ok6:
MOVQ AX, 64(SP) // r1 MOVQ AX, r1+56(FP) // r1
MOVQ DX, 72(SP) // r2 MOVQ DX, r2+64(FP) // r2
MOVQ $0, 80(SP) // errno MOVQ $0, err+72(FP) // errno
CALL runtime·exitsyscall(SB) CALL runtime·exitsyscall(SB)
RET RET
TEXT ·RawSyscall(SB),NOSPLIT,$0-56 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
MOVQ 16(SP), DI MOVQ a1+8(FP), DI
MOVQ 24(SP), SI MOVQ a2+16(FP), SI
MOVQ 32(SP), DX MOVQ a3+24(FP), DX
MOVQ $0, R10 MOVQ $0, R10
MOVQ $0, R8 MOVQ $0, R8
MOVQ $0, R9 MOVQ $0, R9
MOVQ 8(SP), AX // syscall entry MOVQ trap+0(FP), AX // syscall entry
SYSCALL SYSCALL
JCC ok1 JCC ok1
MOVQ $-1, 40(SP) // r1 MOVQ $-1, r1+32(FP) // r1
MOVQ $0, 48(SP) // r2 MOVQ $0, r2+40(FP) // r2
MOVQ AX, 56(SP) // errno MOVQ AX, err+48(FP) // errno
RET RET
ok1: ok1:
MOVQ AX, 40(SP) // r1 MOVQ AX, r1+32(FP) // r1
MOVQ DX, 48(SP) // r2 MOVQ DX, r2+40(FP) // r2
MOVQ $0, 56(SP) // errno MOVQ $0, err+48(FP) // errno
RET RET
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
MOVQ 16(SP), DI MOVQ a1+8(FP), DI
MOVQ 24(SP), SI MOVQ a2+16(FP), SI
MOVQ 32(SP), DX MOVQ a3+24(FP), DX
MOVQ 40(SP), R10 MOVQ a4+32(FP), R10
MOVQ 48(SP), R8 MOVQ a5+40(FP), R8
MOVQ 56(SP), R9 MOVQ a6+48(FP), R9
MOVQ 8(SP), AX // syscall entry MOVQ trap+0(FP), AX // syscall entry
SYSCALL SYSCALL
JCC ok2 JCC ok2
MOVQ $-1, 64(SP) // r1 MOVQ $-1, r1+56(FP) // r1
MOVQ $0, 72(SP) // r2 MOVQ $0, r2+64(FP) // r2
MOVQ AX, 80(SP) // errno MOVQ AX, err+72(FP) // errno
RET RET
ok2: ok2:
MOVQ AX, 64(SP) // r1 MOVQ AX, r1+56(FP) // r1
MOVQ DX, 72(SP) // r2 MOVQ DX, r2+64(FP) // r2
MOVQ $0, 80(SP) // errno MOVQ $0, err+72(FP) // errno
RET RET

2
src/syscall/syscall_netbsd.go
View File

@ -26,7 +26,7 @@ type SockaddrDatalink struct {
raw RawSockaddrDatalink raw RawSockaddrDatalink
} }
func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
func sysctlNodes(mib []_C_int) (nodes []Sysctlnode, err error) { func sysctlNodes(mib []_C_int) (nodes []Sysctlnode, err error) {
var olen uintptr var olen uintptr

2
src/syscall/syscall_openbsd.go
View File

@ -26,7 +26,7 @@ type SockaddrDatalink struct {
raw RawSockaddrDatalink raw RawSockaddrDatalink
} }
func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
func nametomib(name string) (mib []_C_int, err error) { func nametomib(name string) (mib []_C_int, err error) {