mirror of
https://github.com/golang/go
synced 2024-10-04 08:21:22 -06:00
25f6b02ab0
To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
385 lines
7.5 KiB
ArmAsm
385 lines
7.5 KiB
ArmAsm
// Copyright 2009 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.
|
|
//
|
|
// System calls and other sys.stuff for 386, NetBSD
|
|
// /usr/src/sys/kern/syscalls.master for syscall numbers.
|
|
//
|
|
|
|
#include "zasm_GOOS_GOARCH.h"
|
|
#include "../../cmd/ld/textflag.h"
|
|
|
|
// Exit the entire program (like C exit)
|
|
TEXT runtime·exit(SB),NOSPLIT,$-4
|
|
MOVL $1, AX
|
|
INT $0x80
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·exit1(SB),NOSPLIT,$-4
|
|
MOVL $310, AX // sys__lwp_exit
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·open(SB),NOSPLIT,$-4
|
|
MOVL $5, AX
|
|
INT $0x80
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·close(SB),NOSPLIT,$-4
|
|
MOVL $6, AX
|
|
INT $0x80
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·read(SB),NOSPLIT,$-4
|
|
MOVL $3, AX
|
|
INT $0x80
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·write(SB),NOSPLIT,$-4
|
|
MOVL $4, AX // sys_write
|
|
INT $0x80
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·usleep(SB),NOSPLIT,$24
|
|
MOVL $0, DX
|
|
MOVL usec+0(FP), AX
|
|
MOVL $1000000, CX
|
|
DIVL CX
|
|
MOVL AX, 12(SP) // tv_sec - l32
|
|
MOVL $0, 16(SP) // tv_sec - h32
|
|
MOVL $1000, AX
|
|
MULL DX
|
|
MOVL AX, 20(SP) // tv_nsec
|
|
|
|
MOVL $0, 0(SP)
|
|
LEAL 12(SP), AX
|
|
MOVL AX, 4(SP) // arg 1 - rqtp
|
|
MOVL $0, 8(SP) // arg 2 - rmtp
|
|
MOVL $430, AX // sys_nanosleep
|
|
INT $0x80
|
|
RET
|
|
|
|
TEXT runtime·raise(SB),NOSPLIT,$12
|
|
MOVL $311, AX // sys__lwp_self
|
|
INT $0x80
|
|
MOVL $0, 0(SP)
|
|
MOVL AX, 4(SP) // arg 1 - target
|
|
MOVL sig+0(FP), AX
|
|
MOVL AX, 8(SP) // arg 2 - signo
|
|
MOVL $318, AX // sys__lwp_kill
|
|
INT $0x80
|
|
RET
|
|
|
|
TEXT runtime·mmap(SB),NOSPLIT,$36
|
|
LEAL addr+0(FP), SI
|
|
LEAL 4(SP), DI
|
|
CLD
|
|
MOVSL // arg 1 - addr
|
|
MOVSL // arg 2 - len
|
|
MOVSL // arg 3 - prot
|
|
MOVSL // arg 4 - flags
|
|
MOVSL // arg 5 - fd
|
|
MOVL $0, AX
|
|
STOSL // arg 6 - pad
|
|
MOVSL // arg 7 - offset
|
|
MOVL $0, AX // top 32 bits of file offset
|
|
STOSL
|
|
MOVL $197, AX // sys_mmap
|
|
INT $0x80
|
|
MOVL AX, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·munmap(SB),NOSPLIT,$-4
|
|
MOVL $73, AX // sys_munmap
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·madvise(SB),NOSPLIT,$-4
|
|
MOVL $75, AX // sys_madvise
|
|
INT $0x80
|
|
// ignore failure - maybe pages are locked
|
|
RET
|
|
|
|
TEXT runtime·setitimer(SB),NOSPLIT,$-4
|
|
MOVL $425, AX // sys_setitimer
|
|
INT $0x80
|
|
RET
|
|
|
|
// func now() (sec int64, nsec int32)
|
|
TEXT time·now(SB), NOSPLIT, $32
|
|
LEAL 12(SP), BX
|
|
MOVL $0, 4(SP) // arg 1 - clock_id
|
|
MOVL BX, 8(SP) // arg 2 - tp
|
|
MOVL $427, AX // sys_clock_gettime
|
|
INT $0x80
|
|
|
|
MOVL 12(SP), AX // sec - l32
|
|
MOVL AX, sec+0(FP)
|
|
MOVL 16(SP), AX // sec - h32
|
|
MOVL AX, sec+4(FP)
|
|
|
|
MOVL 20(SP), BX // nsec
|
|
MOVL BX, nsec+8(FP)
|
|
RET
|
|
|
|
// int64 nanotime(void) so really
|
|
// void nanotime(int64 *nsec)
|
|
TEXT runtime·nanotime(SB),NOSPLIT,$32
|
|
LEAL 12(SP), BX
|
|
MOVL $0, 4(SP) // arg 1 - clock_id
|
|
MOVL BX, 8(SP) // arg 2 - tp
|
|
MOVL $427, AX // sys_clock_gettime
|
|
INT $0x80
|
|
|
|
MOVL 16(SP), CX // sec - h32
|
|
IMULL $1000000000, CX
|
|
|
|
MOVL 12(SP), AX // sec - l32
|
|
MOVL $1000000000, BX
|
|
MULL BX // result in dx:ax
|
|
|
|
MOVL 20(SP), BX // nsec
|
|
ADDL BX, AX
|
|
ADCL CX, DX // add high bits with carry
|
|
|
|
MOVL AX, ret_lo+0(FP)
|
|
MOVL DX, ret_hi+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·getcontext(SB),NOSPLIT,$-4
|
|
MOVL $307, AX // sys_getcontext
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·sigprocmask(SB),NOSPLIT,$-4
|
|
MOVL $293, AX // sys_sigprocmask
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·sigreturn_tramp(SB),NOSPLIT,$0
|
|
LEAL 140(SP), AX // Load address of ucontext
|
|
MOVL AX, 4(SP)
|
|
MOVL $308, AX // sys_setcontext
|
|
INT $0x80
|
|
MOVL $-1, 4(SP) // Something failed...
|
|
MOVL $1, AX // sys_exit
|
|
INT $0x80
|
|
|
|
TEXT runtime·sigaction(SB),NOSPLIT,$24
|
|
LEAL sig+0(FP), SI
|
|
LEAL 4(SP), DI
|
|
CLD
|
|
MOVSL // arg 1 - sig
|
|
MOVSL // arg 2 - act
|
|
MOVSL // arg 3 - oact
|
|
LEAL runtime·sigreturn_tramp(SB), AX
|
|
STOSL // arg 4 - tramp
|
|
MOVL $2, AX
|
|
STOSL // arg 5 - vers
|
|
MOVL $340, AX // sys___sigaction_sigtramp
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·sigtramp(SB),NOSPLIT,$44
|
|
get_tls(CX)
|
|
|
|
// check that g exists
|
|
MOVL g(CX), DI
|
|
CMPL DI, $0
|
|
JNE 6(PC)
|
|
MOVL signo+0(FP), BX
|
|
MOVL BX, 0(SP)
|
|
MOVL $runtime·badsignal(SB), AX
|
|
CALL AX
|
|
RET
|
|
|
|
// save g
|
|
MOVL DI, 20(SP)
|
|
|
|
// g = m->gsignal
|
|
MOVL g_m(DI), BX
|
|
MOVL m_gsignal(BX), BX
|
|
MOVL BX, g(CX)
|
|
|
|
// copy arguments for call to sighandler
|
|
MOVL signo+0(FP), BX
|
|
MOVL BX, 0(SP)
|
|
MOVL info+4(FP), BX
|
|
MOVL BX, 4(SP)
|
|
MOVL context+8(FP), BX
|
|
MOVL BX, 8(SP)
|
|
MOVL DI, 12(SP)
|
|
|
|
CALL runtime·sighandler(SB)
|
|
|
|
// restore g
|
|
get_tls(CX)
|
|
MOVL 20(SP), BX
|
|
MOVL BX, g(CX)
|
|
RET
|
|
|
|
// int32 lwp_create(void *context, uintptr flags, void *lwpid);
|
|
TEXT runtime·lwp_create(SB),NOSPLIT,$16
|
|
MOVL $0, 0(SP)
|
|
MOVL ctxt+0(FP), AX
|
|
MOVL AX, 4(SP) // arg 1 - context
|
|
MOVL flags+4(FP), AX
|
|
MOVL AX, 8(SP) // arg 2 - flags
|
|
MOVL lwpid+8(FP), AX
|
|
MOVL AX, 12(SP) // arg 3 - lwpid
|
|
MOVL $309, AX // sys__lwp_create
|
|
INT $0x80
|
|
JCC 2(PC)
|
|
NEGL AX
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
|
|
|
|
// Set FS to point at m->tls
|
|
LEAL m_tls(BX), BP
|
|
PUSHAL // save registers
|
|
PUSHL BP
|
|
CALL runtime·settls(SB)
|
|
POPL AX
|
|
POPAL
|
|
|
|
// Now segment is established. Initialize m, g.
|
|
get_tls(AX)
|
|
MOVL DX, g(AX)
|
|
MOVL BX, g_m(DX)
|
|
|
|
CALL runtime·stackcheck(SB) // smashes AX, CX
|
|
MOVL 0(DX), DX // paranoia; check they are not nil
|
|
MOVL 0(BX), BX
|
|
|
|
// more paranoia; check that stack splitting code works
|
|
PUSHAL
|
|
CALL runtime·emptyfunc(SB)
|
|
POPAL
|
|
|
|
// Call fn
|
|
CALL SI
|
|
|
|
CALL runtime·exit1(SB)
|
|
MOVL $0x1234, 0x1005
|
|
RET
|
|
|
|
TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
|
|
MOVL $281, AX // sys___sigaltstack14
|
|
MOVL new+4(SP), BX
|
|
MOVL old+8(SP), CX
|
|
INT $0x80
|
|
CMPL AX, $0xfffff001
|
|
JLS 2(PC)
|
|
INT $3
|
|
RET
|
|
|
|
TEXT runtime·setldt(SB),NOSPLIT,$8
|
|
// Under NetBSD we set the GS base instead of messing with the LDT.
|
|
MOVL 16(SP), AX // tls0
|
|
MOVL AX, 0(SP)
|
|
CALL runtime·settls(SB)
|
|
RET
|
|
|
|
TEXT runtime·settls(SB),NOSPLIT,$16
|
|
// adjust for ELF: wants to use -8(GS) and -4(GS) for g and m
|
|
MOVL base+0(FP), CX
|
|
ADDL $8, CX
|
|
MOVL $0, 0(SP) // syscall gap
|
|
MOVL CX, 4(SP) // arg 1 - ptr
|
|
MOVL $317, AX // sys__lwp_setprivate
|
|
INT $0x80
|
|
JCC 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·osyield(SB),NOSPLIT,$-4
|
|
MOVL $350, AX // sys_sched_yield
|
|
INT $0x80
|
|
RET
|
|
|
|
TEXT runtime·lwp_park(SB),NOSPLIT,$-4
|
|
MOVL $434, AX // sys__lwp_park
|
|
INT $0x80
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·lwp_unpark(SB),NOSPLIT,$-4
|
|
MOVL $321, AX // sys__lwp_unpark
|
|
INT $0x80
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·lwp_self(SB),NOSPLIT,$-4
|
|
MOVL $311, AX // sys__lwp_self
|
|
INT $0x80
|
|
MOVL AX, ret+0(FP)
|
|
RET
|
|
|
|
TEXT runtime·sysctl(SB),NOSPLIT,$28
|
|
LEAL mib+0(FP), SI
|
|
LEAL 4(SP), DI
|
|
CLD
|
|
MOVSL // arg 1 - name
|
|
MOVSL // arg 2 - namelen
|
|
MOVSL // arg 3 - oldp
|
|
MOVSL // arg 4 - oldlenp
|
|
MOVSL // arg 5 - newp
|
|
MOVSL // arg 6 - newlen
|
|
MOVL $202, AX // sys___sysctl
|
|
INT $0x80
|
|
JCC 3(PC)
|
|
NEGL AX
|
|
RET
|
|
MOVL $0, AX
|
|
RET
|
|
|
|
GLOBL runtime·tlsoffset(SB),$4
|
|
|
|
// int32 runtime·kqueue(void)
|
|
TEXT runtime·kqueue(SB),NOSPLIT,$0
|
|
MOVL $344, AX
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
NEGL AX
|
|
MOVL AX, ret+0(FP)
|
|
RET
|
|
|
|
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout)
|
|
TEXT runtime·kevent(SB),NOSPLIT,$0
|
|
MOVL $435, AX
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
NEGL AX
|
|
MOVL AX, ret+24(FP)
|
|
RET
|
|
|
|
// int32 runtime·closeonexec(int32 fd)
|
|
TEXT runtime·closeonexec(SB),NOSPLIT,$32
|
|
MOVL $92, AX // fcntl
|
|
// 0(SP) is where the caller PC would be; kernel skips it
|
|
MOVL fd+0(FP), BX
|
|
MOVL BX, 4(SP) // fd
|
|
MOVL $2, 8(SP) // F_SETFD
|
|
MOVL $1, 12(SP) // FD_CLOEXEC
|
|
INT $0x80
|
|
JAE 2(PC)
|
|
NEGL AX
|
|
RET
|