mirror of
https://github.com/golang/go
synced 2024-11-19 19:04:47 -07:00
71ab9fa312
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>
351 lines
7.3 KiB
ArmAsm
351 lines
7.3 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 AMD64, OpenBSD
|
|
// /usr/src/sys/kern/syscalls.master for syscall numbers.
|
|
//
|
|
|
|
#include "go_asm.h"
|
|
#include "go_tls.h"
|
|
#include "textflag.h"
|
|
|
|
#define CLOCK_MONOTONIC $3
|
|
|
|
// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
|
|
TEXT runtime·tfork(SB),NOSPLIT,$32
|
|
|
|
// Copy mp, gp and fn off parent stack for use by child.
|
|
MOVQ mm+16(FP), R8
|
|
MOVQ gg+24(FP), R9
|
|
MOVQ fn+32(FP), R12
|
|
|
|
MOVQ param+0(FP), DI
|
|
MOVQ psize+8(FP), SI
|
|
MOVL $8, AX // sys___tfork
|
|
SYSCALL
|
|
|
|
// Return if tfork syscall failed.
|
|
JCC 4(PC)
|
|
NEGQ AX
|
|
MOVL AX, ret+40(FP)
|
|
RET
|
|
|
|
// In parent, return.
|
|
CMPL AX, $0
|
|
JEQ 3(PC)
|
|
MOVL AX, ret+40(FP)
|
|
RET
|
|
|
|
// Set FS to point at m->tls.
|
|
LEAQ m_tls(R8), DI
|
|
CALL runtime·settls(SB)
|
|
|
|
// In child, set up new stack.
|
|
get_tls(CX)
|
|
MOVQ R8, g_m(R9)
|
|
MOVQ R9, g(CX)
|
|
CALL runtime·stackcheck(SB)
|
|
|
|
// Call fn
|
|
CALL R12
|
|
|
|
// It shouldn't return. If it does, exit
|
|
MOVQ $0, DI // arg 1 - notdead
|
|
MOVL $302, AX // sys___threxit
|
|
SYSCALL
|
|
JMP -3(PC) // keep exiting
|
|
|
|
TEXT runtime·osyield(SB),NOSPLIT,$0
|
|
MOVL $298, AX // sys_sched_yield
|
|
SYSCALL
|
|
RET
|
|
|
|
TEXT runtime·thrsleep(SB),NOSPLIT,$0
|
|
MOVQ ident+0(FP), DI // arg 1 - ident
|
|
MOVL clock_id+8(FP), SI // arg 2 - clock_id
|
|
MOVQ tsp+16(FP), DX // arg 3 - tp
|
|
MOVQ lock+24(FP), R10 // arg 4 - lock
|
|
MOVQ abort+32(FP), R8 // arg 5 - abort
|
|
MOVL $94, AX // sys___thrsleep
|
|
SYSCALL
|
|
MOVL AX, ret+40(FP)
|
|
RET
|
|
|
|
TEXT runtime·thrwakeup(SB),NOSPLIT,$0
|
|
MOVQ ident+0(FP), DI // arg 1 - ident
|
|
MOVL n+8(FP), SI // arg 2 - n
|
|
MOVL $301, AX // sys___thrwakeup
|
|
SYSCALL
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
// Exit the entire program (like C exit)
|
|
TEXT runtime·exit(SB),NOSPLIT,$-8
|
|
MOVL code+0(FP), DI // arg 1 - exit status
|
|
MOVL $1, AX // sys_exit
|
|
SYSCALL
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·exit1(SB),NOSPLIT,$-8
|
|
MOVQ $0, DI // arg 1 - notdead
|
|
MOVL $302, AX // sys___threxit
|
|
SYSCALL
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·open(SB),NOSPLIT,$-8
|
|
MOVQ name+0(FP), DI // arg 1 pathname
|
|
MOVL mode+8(FP), SI // arg 2 flags
|
|
MOVL perm+12(FP), DX // arg 3 mode
|
|
MOVL $5, AX
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $-1, AX
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·closefd(SB),NOSPLIT,$-8
|
|
MOVL fd+0(FP), DI // arg 1 fd
|
|
MOVL $6, AX
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $-1, AX
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·read(SB),NOSPLIT,$-8
|
|
MOVL fd+0(FP), DI // arg 1 fd
|
|
MOVQ p+8(FP), SI // arg 2 buf
|
|
MOVL n+16(FP), DX // arg 3 count
|
|
MOVL $3, AX
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $-1, AX
|
|
MOVL AX, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·write(SB),NOSPLIT,$-8
|
|
MOVQ fd+0(FP), DI // arg 1 - fd
|
|
MOVQ p+8(FP), SI // arg 2 - buf
|
|
MOVL n+16(FP), DX // arg 3 - nbyte
|
|
MOVL $4, AX // sys_write
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $-1, AX
|
|
MOVL AX, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·usleep(SB),NOSPLIT,$16
|
|
MOVL $0, DX
|
|
MOVL usec+0(FP), AX
|
|
MOVL $1000000, CX
|
|
DIVL CX
|
|
MOVQ AX, 0(SP) // tv_sec
|
|
MOVL $1000, AX
|
|
MULL DX
|
|
MOVQ AX, 8(SP) // tv_nsec
|
|
|
|
MOVQ SP, DI // arg 1 - rqtp
|
|
MOVQ $0, SI // arg 2 - rmtp
|
|
MOVL $91, AX // sys_nanosleep
|
|
SYSCALL
|
|
RET
|
|
|
|
TEXT runtime·raise(SB),NOSPLIT,$16
|
|
MOVL $299, AX // sys_getthrid
|
|
SYSCALL
|
|
MOVQ AX, DI // arg 1 - pid
|
|
MOVL sig+0(FP), SI // arg 2 - signum
|
|
MOVL $37, AX // sys_kill
|
|
SYSCALL
|
|
RET
|
|
|
|
TEXT runtime·raiseproc(SB),NOSPLIT,$16
|
|
MOVL $20, AX // sys_getpid
|
|
SYSCALL
|
|
MOVQ AX, DI // arg 1 - pid
|
|
MOVL sig+0(FP), SI // arg 2 - signum
|
|
MOVL $37, AX // sys_kill
|
|
SYSCALL
|
|
RET
|
|
|
|
TEXT runtime·setitimer(SB),NOSPLIT,$-8
|
|
MOVL mode+0(FP), DI // arg 1 - which
|
|
MOVQ new+8(FP), SI // arg 2 - itv
|
|
MOVQ old+16(FP), DX // arg 3 - oitv
|
|
MOVL $69, AX // sys_setitimer
|
|
SYSCALL
|
|
RET
|
|
|
|
// func now() (sec int64, nsec int32)
|
|
TEXT time·now(SB), NOSPLIT, $32
|
|
MOVQ $0, DI // arg 1 - clock_id
|
|
LEAQ 8(SP), SI // arg 2 - tp
|
|
MOVL $87, AX // sys_clock_gettime
|
|
SYSCALL
|
|
MOVQ 8(SP), AX // sec
|
|
MOVQ 16(SP), DX // nsec
|
|
|
|
// sec is in AX, nsec in DX
|
|
MOVQ AX, sec+0(FP)
|
|
MOVL DX, nsec+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·nanotime(SB),NOSPLIT,$24
|
|
MOVQ CLOCK_MONOTONIC, DI // arg 1 - clock_id
|
|
LEAQ 8(SP), SI // arg 2 - tp
|
|
MOVL $87, AX // sys_clock_gettime
|
|
SYSCALL
|
|
MOVQ 8(SP), AX // sec
|
|
MOVQ 16(SP), DX // nsec
|
|
|
|
// sec is in AX, nsec in DX
|
|
// return nsec in AX
|
|
IMULQ $1000000000, AX
|
|
ADDQ DX, AX
|
|
MOVQ AX, ret+0(FP)
|
|
RET
|
|
|
|
TEXT runtime·sigaction(SB),NOSPLIT,$-8
|
|
MOVL sig+0(FP), DI // arg 1 - signum
|
|
MOVQ new+8(FP), SI // arg 2 - nsa
|
|
MOVQ old+16(FP), DX // arg 3 - osa
|
|
MOVL $46, AX
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·sigprocmask(SB),NOSPLIT,$0
|
|
MOVL mode+0(FP), DI // arg 1 - how
|
|
MOVL new+4(FP), SI // arg 2 - set
|
|
MOVL $48, AX // sys_sigprocmask
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
|
|
MOVL sig+8(FP), DI
|
|
MOVQ info+16(FP), SI
|
|
MOVQ ctx+24(FP), DX
|
|
MOVQ fn+0(FP), AX
|
|
CALL AX
|
|
RET
|
|
|
|
TEXT runtime·sigtramp(SB),NOSPLIT,$24
|
|
MOVQ DI, 0(SP)
|
|
MOVQ SI, 8(SP)
|
|
MOVQ DX, 16(SP)
|
|
CALL runtime·sigtrampgo(SB)
|
|
RET
|
|
|
|
TEXT runtime·mmap(SB),NOSPLIT,$0
|
|
MOVQ addr+0(FP), DI // arg 1 - addr
|
|
MOVQ n+8(FP), SI // arg 2 - len
|
|
MOVL prot+16(FP), DX // arg 3 - prot
|
|
MOVL flags+20(FP), R10 // arg 4 - flags
|
|
MOVL fd+24(FP), R8 // arg 5 - fd
|
|
MOVL off+28(FP), R9
|
|
SUBQ $16, SP
|
|
MOVQ R9, 8(SP) // arg 7 - offset (passed on stack)
|
|
MOVQ $0, R9 // arg 6 - pad
|
|
MOVL $197, AX
|
|
SYSCALL
|
|
ADDQ $16, SP
|
|
MOVQ AX, ret+32(FP)
|
|
RET
|
|
|
|
TEXT runtime·munmap(SB),NOSPLIT,$0
|
|
MOVQ addr+0(FP), DI // arg 1 - addr
|
|
MOVQ n+8(FP), SI // arg 2 - len
|
|
MOVL $73, AX // sys_munmap
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·madvise(SB),NOSPLIT,$0
|
|
MOVQ addr+0(FP), DI // arg 1 - addr
|
|
MOVQ n+8(FP), SI // arg 2 - len
|
|
MOVL flags+16(FP), DX // arg 3 - behav
|
|
MOVQ $75, AX // sys_madvise
|
|
SYSCALL
|
|
// ignore failure - maybe pages are locked
|
|
RET
|
|
|
|
TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
|
|
MOVQ new+8(SP), DI // arg 1 - nss
|
|
MOVQ old+16(SP), SI // arg 2 - oss
|
|
MOVQ $288, AX // sys_sigaltstack
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
// set tls base to DI
|
|
TEXT runtime·settls(SB),NOSPLIT,$0
|
|
// adjust for ELF: wants to use -8(FS) for g
|
|
ADDQ $8, DI
|
|
MOVQ $329, AX // sys___settcb
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
TEXT runtime·sysctl(SB),NOSPLIT,$0
|
|
MOVQ mib+0(FP), DI // arg 1 - name
|
|
MOVL miblen+8(FP), SI // arg 2 - namelen
|
|
MOVQ out+16(FP), DX // arg 3 - oldp
|
|
MOVQ size+24(FP), R10 // arg 4 - oldlenp
|
|
MOVQ dst+32(FP), R8 // arg 5 - newp
|
|
MOVQ ndst+40(FP), R9 // arg 6 - newlen
|
|
MOVQ $202, AX // sys___sysctl
|
|
SYSCALL
|
|
JCC 4(PC)
|
|
NEGQ AX
|
|
MOVL AX, ret+48(FP)
|
|
RET
|
|
MOVL $0, AX
|
|
MOVL AX, ret+48(FP)
|
|
RET
|
|
|
|
// int32 runtime·kqueue(void);
|
|
TEXT runtime·kqueue(SB),NOSPLIT,$0
|
|
MOVQ $0, DI
|
|
MOVQ $0, SI
|
|
MOVQ $0, DX
|
|
MOVL $269, AX
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
NEGQ 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 kq+0(FP), DI
|
|
MOVQ ch+8(FP), SI
|
|
MOVL nch+16(FP), DX
|
|
MOVQ ev+24(FP), R10
|
|
MOVL nev+32(FP), R8
|
|
MOVQ ts+40(FP), R9
|
|
MOVL $72, AX
|
|
SYSCALL
|
|
JCC 2(PC)
|
|
NEGQ AX
|
|
MOVL AX, ret+48(FP)
|
|
RET
|
|
|
|
// void runtime·closeonexec(int32 fd);
|
|
TEXT runtime·closeonexec(SB),NOSPLIT,$0
|
|
MOVL fd+0(FP), DI // fd
|
|
MOVQ $2, SI // F_SETFD
|
|
MOVQ $1, DX // FD_CLOEXEC
|
|
MOVL $92, AX // fcntl
|
|
SYSCALL
|
|
RET
|