mirror of
https://github.com/golang/go
synced 2024-10-05 20:31:20 -06:00
368d548417
The PowerPC ISA does not have a PC-relative load instruction, which poses obvious challenges when generating position-independent code. The way the ELFv2 ABI addresses this is to specify that r2 points to a per "module" (shared library or executable) TOC pointer. Maintaining this pointer requires cooperation between codegen and the system linker: * Non-leaf functions leave space on the stack at r1+24 to save the TOC pointer. * A call to a function that *might* have to go via a PLT stub must be followed by a nop instruction that the system linker can replace with "ld r1, 24(r1)" to restore the TOC pointer (only when dynamically linking Go code). * When calling a function via a function pointer, the address of the function must be in r12, and the first couple of instructions (the "global entry point") of the called function use this to derive the address of the TOC for the module it is in. * When calling a function that is implemented in the same module, the system linker adjusts the call to skip over the instructions mentioned above (the "local entry point"), assuming that r2 is already correctly set. So this changeset adds the global entry point instructions, sets the metadata so the system linker knows where the local entry point is, inserts code to save the TOC pointer at 24(r1), adds a nop after any call not known to be local and copes with the odd non-local code transfer in the runtime (e.g. the stuff around jmpdefer). It does not actually compile PIC yet. Change-Id: I7522e22bdfd2f891745a900c60254fe9e372c854 Reviewed-on: https://go-review.googlesource.com/15967 Reviewed-by: Russ Cox <rsc@golang.org>
411 lines
8.3 KiB
ArmAsm
411 lines
8.3 KiB
ArmAsm
// Copyright 2014 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 linux
|
|
// +build ppc64 ppc64le
|
|
|
|
//
|
|
// System calls and other sys.stuff for ppc64, Linux
|
|
//
|
|
|
|
#include "go_asm.h"
|
|
#include "go_tls.h"
|
|
#include "textflag.h"
|
|
#include "asm_ppc64x.h"
|
|
|
|
#define SYS_exit 1
|
|
#define SYS_read 3
|
|
#define SYS_write 4
|
|
#define SYS_open 5
|
|
#define SYS_close 6
|
|
#define SYS_getpid 20
|
|
#define SYS_kill 37
|
|
#define SYS_fcntl 55
|
|
#define SYS_gettimeofday 78
|
|
#define SYS_select 82 // always return -ENOSYS
|
|
#define SYS_mmap 90
|
|
#define SYS_munmap 91
|
|
#define SYS_setitimer 104
|
|
#define SYS_clone 120
|
|
#define SYS_newselect 142
|
|
#define SYS_sched_yield 158
|
|
#define SYS_rt_sigreturn 172
|
|
#define SYS_rt_sigaction 173
|
|
#define SYS_rt_sigprocmask 174
|
|
#define SYS_sigaltstack 185
|
|
#define SYS_ugetrlimit 190
|
|
#define SYS_madvise 205
|
|
#define SYS_mincore 206
|
|
#define SYS_gettid 207
|
|
#define SYS_tkill 208
|
|
#define SYS_futex 221
|
|
#define SYS_sched_getaffinity 223
|
|
#define SYS_exit_group 234
|
|
#define SYS_epoll_create 236
|
|
#define SYS_epoll_ctl 237
|
|
#define SYS_epoll_wait 238
|
|
#define SYS_clock_gettime 246
|
|
#define SYS_epoll_create1 315
|
|
|
|
TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
|
|
MOVW code+0(FP), R3
|
|
SYSCALL $SYS_exit_group
|
|
RET
|
|
|
|
TEXT runtime·exit1(SB),NOSPLIT|NOFRAME,$0-4
|
|
MOVW code+0(FP), R3
|
|
SYSCALL $SYS_exit
|
|
RET
|
|
|
|
TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
|
|
MOVD name+0(FP), R3
|
|
MOVW mode+8(FP), R4
|
|
MOVW perm+12(FP), R5
|
|
SYSCALL $SYS_open
|
|
BVC 2(PC)
|
|
MOVW $-1, R3
|
|
MOVW R3, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
|
|
MOVW fd+0(FP), R3
|
|
SYSCALL $SYS_close
|
|
BVC 2(PC)
|
|
MOVW $-1, R3
|
|
MOVW R3, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·write(SB),NOSPLIT|NOFRAME,$0-28
|
|
MOVD fd+0(FP), R3
|
|
MOVD p+8(FP), R4
|
|
MOVW n+16(FP), R5
|
|
SYSCALL $SYS_write
|
|
BVC 2(PC)
|
|
MOVW $-1, R3
|
|
MOVW R3, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
|
|
MOVW fd+0(FP), R3
|
|
MOVD p+8(FP), R4
|
|
MOVW n+16(FP), R5
|
|
SYSCALL $SYS_read
|
|
BVC 2(PC)
|
|
MOVW $-1, R3
|
|
MOVW R3, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·getrlimit(SB),NOSPLIT|NOFRAME,$0-20
|
|
MOVW kind+0(FP), R3
|
|
MOVD limit+8(FP), R4
|
|
SYSCALL $SYS_ugetrlimit
|
|
MOVW R3, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·usleep(SB),NOSPLIT,$16-4
|
|
MOVW usec+0(FP), R3
|
|
MOVD R3, R5
|
|
MOVW $1000000, R4
|
|
DIVD R4, R3
|
|
MOVD R3, 8(R1)
|
|
MULLD R3, R4
|
|
SUB R4, R5
|
|
MOVD R5, 16(R1)
|
|
|
|
// select(0, 0, 0, 0, &tv)
|
|
MOVW $0, R3
|
|
MOVW $0, R4
|
|
MOVW $0, R5
|
|
MOVW $0, R6
|
|
ADD $8, R1, R7
|
|
SYSCALL $SYS_newselect
|
|
RET
|
|
|
|
TEXT runtime·gettid(SB),NOSPLIT,$0-4
|
|
SYSCALL $SYS_gettid
|
|
MOVW R3, ret+0(FP)
|
|
RET
|
|
|
|
TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
|
|
SYSCALL $SYS_gettid
|
|
MOVW R3, R3 // arg 1 tid
|
|
MOVW sig+0(FP), R4 // arg 2
|
|
SYSCALL $SYS_tkill
|
|
RET
|
|
|
|
TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
|
|
SYSCALL $SYS_getpid
|
|
MOVW R3, R3 // arg 1 pid
|
|
MOVW sig+0(FP), R4 // arg 2
|
|
SYSCALL $SYS_kill
|
|
RET
|
|
|
|
TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
|
|
MOVW mode+0(FP), R3
|
|
MOVD new+8(FP), R4
|
|
MOVD old+16(FP), R5
|
|
SYSCALL $SYS_setitimer
|
|
RET
|
|
|
|
TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
|
|
MOVD addr+0(FP), R3
|
|
MOVD n+8(FP), R4
|
|
MOVD dst+16(FP), R5
|
|
SYSCALL $SYS_mincore
|
|
MOVW R3, ret+24(FP)
|
|
RET
|
|
|
|
// func now() (sec int64, nsec int32)
|
|
TEXT time·now(SB),NOSPLIT,$16
|
|
MOVD $0(R1), R3
|
|
MOVD $0, R4
|
|
SYSCALL $SYS_gettimeofday
|
|
MOVD 0(R1), R3 // sec
|
|
MOVD 8(R1), R5 // usec
|
|
MOVD $1000, R4
|
|
MULLD R4, R5
|
|
MOVD R3, sec+0(FP)
|
|
MOVW R5, nsec+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·nanotime(SB),NOSPLIT,$16
|
|
MOVW $1, R3 // CLOCK_MONOTONIC
|
|
MOVD $0(R1), R4
|
|
SYSCALL $SYS_clock_gettime
|
|
MOVD 0(R1), R3 // sec
|
|
MOVD 8(R1), R5 // nsec
|
|
// sec is in R3, nsec in R5
|
|
// return nsec in R3
|
|
MOVD $1000000000, R4
|
|
MULLD R4, R3
|
|
ADD R5, R3
|
|
MOVD R3, ret+0(FP)
|
|
RET
|
|
|
|
TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
|
|
MOVW sig+0(FP), R3
|
|
MOVD new+8(FP), R4
|
|
MOVD old+16(FP), R5
|
|
MOVW size+24(FP), R6
|
|
SYSCALL $SYS_rt_sigprocmask
|
|
BVC 2(PC)
|
|
MOVD R0, 0xf1(R0) // crash
|
|
RET
|
|
|
|
TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
|
|
MOVD sig+0(FP), R3
|
|
MOVD new+8(FP), R4
|
|
MOVD old+16(FP), R5
|
|
MOVD size+24(FP), R6
|
|
SYSCALL $SYS_rt_sigaction
|
|
MOVW R3, ret+32(FP)
|
|
RET
|
|
|
|
TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
|
|
MOVW sig+8(FP), R3
|
|
MOVD info+16(FP), R4
|
|
MOVD ctx+24(FP), R5
|
|
MOVD fn+0(FP), R12
|
|
MOVD R12, CTR
|
|
BL (CTR)
|
|
MOVD 24(R1), R2
|
|
RET
|
|
|
|
#ifdef GOARCH_ppc64le
|
|
// ppc64le doesn't need function descriptors
|
|
TEXT runtime·sigtramp(SB),NOSPLIT,$64
|
|
#else
|
|
// function descriptor for the real sigtramp
|
|
TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0
|
|
DWORD $runtime·_sigtramp(SB)
|
|
DWORD $0
|
|
DWORD $0
|
|
TEXT runtime·_sigtramp(SB),NOSPLIT,$64
|
|
#endif
|
|
// initialize essential registers (just in case)
|
|
BL runtime·reginit(SB)
|
|
|
|
// this might be called in external code context,
|
|
// where g is not set.
|
|
MOVB runtime·iscgo(SB), R6
|
|
CMP R6, $0
|
|
BEQ 2(PC)
|
|
BL runtime·load_g(SB)
|
|
|
|
MOVW R3, FIXED_FRAME+0(R1)
|
|
MOVD R4, FIXED_FRAME+8(R1)
|
|
MOVD R5, FIXED_FRAME+16(R1)
|
|
MOVD $runtime·sigtrampgo(SB), R12
|
|
MOVD R12, CTR
|
|
BL (CTR)
|
|
MOVD 24(R1), R2
|
|
RET
|
|
|
|
TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0
|
|
MOVD addr+0(FP), R3
|
|
MOVD n+8(FP), R4
|
|
MOVW prot+16(FP), R5
|
|
MOVW flags+20(FP), R6
|
|
MOVW fd+24(FP), R7
|
|
MOVW off+28(FP), R8
|
|
|
|
SYSCALL $SYS_mmap
|
|
MOVD R3, ret+32(FP)
|
|
RET
|
|
|
|
TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
|
|
MOVD addr+0(FP), R3
|
|
MOVD n+8(FP), R4
|
|
SYSCALL $SYS_munmap
|
|
BVC 2(PC)
|
|
MOVD R0, 0xf3(R0)
|
|
RET
|
|
|
|
TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
|
|
MOVD addr+0(FP), R3
|
|
MOVD n+8(FP), R4
|
|
MOVW flags+16(FP), R5
|
|
SYSCALL $SYS_madvise
|
|
// ignore failure - maybe pages are locked
|
|
RET
|
|
|
|
// int64 futex(int32 *uaddr, int32 op, int32 val,
|
|
// struct timespec *timeout, int32 *uaddr2, int32 val2);
|
|
TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0
|
|
MOVD addr+0(FP), R3
|
|
MOVW op+8(FP), R4
|
|
MOVW val+12(FP), R5
|
|
MOVD ts+16(FP), R6
|
|
MOVD addr2+24(FP), R7
|
|
MOVW val3+32(FP), R8
|
|
SYSCALL $SYS_futex
|
|
MOVW R3, ret+40(FP)
|
|
RET
|
|
|
|
// int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
|
|
TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW flags+0(FP), R3
|
|
MOVD stk+8(FP), R4
|
|
|
|
// Copy mp, gp, fn off parent stack for use by child.
|
|
// Careful: Linux system call clobbers ???.
|
|
MOVD mm+16(FP), R7
|
|
MOVD gg+24(FP), R8
|
|
MOVD fn+32(FP), R12
|
|
|
|
MOVD R7, -8(R4)
|
|
MOVD R8, -16(R4)
|
|
MOVD R12, -24(R4)
|
|
MOVD $1234, R7
|
|
MOVD R7, -32(R4)
|
|
|
|
SYSCALL $SYS_clone
|
|
|
|
// In parent, return.
|
|
CMP R3, $0
|
|
BEQ 3(PC)
|
|
MOVW R3, ret+40(FP)
|
|
RET
|
|
|
|
// In child, on new stack.
|
|
// initialize essential registers
|
|
BL runtime·reginit(SB)
|
|
MOVD -32(R1), R7
|
|
CMP R7, $1234
|
|
BEQ 2(PC)
|
|
MOVD R0, 0(R0)
|
|
|
|
// Initialize m->procid to Linux tid
|
|
SYSCALL $SYS_gettid
|
|
|
|
MOVD -24(R1), R12 // fn
|
|
MOVD -16(R1), R8 // g
|
|
MOVD -8(R1), R7 // m
|
|
|
|
CMP R7, $0
|
|
BEQ nog
|
|
CMP R8, $0
|
|
BEQ nog
|
|
|
|
MOVD R3, m_procid(R7)
|
|
|
|
// TODO: setup TLS.
|
|
|
|
// In child, set up new stack
|
|
MOVD R7, g_m(R8)
|
|
MOVD R8, g
|
|
//CALL runtime·stackcheck(SB)
|
|
|
|
nog:
|
|
// Call fn
|
|
MOVD R12, CTR
|
|
BL (CTR)
|
|
|
|
// It shouldn't return. If it does, exit that thread.
|
|
MOVW $111, R3
|
|
SYSCALL $SYS_exit
|
|
BR -2(PC) // keep exiting
|
|
|
|
TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
|
|
MOVD new+0(FP), R3
|
|
MOVD old+8(FP), R4
|
|
SYSCALL $SYS_sigaltstack
|
|
BVC 2(PC)
|
|
MOVD R0, 0xf1(R0) // crash
|
|
RET
|
|
|
|
TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
|
|
SYSCALL $SYS_sched_yield
|
|
RET
|
|
|
|
TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0
|
|
MOVD pid+0(FP), R3
|
|
MOVD len+8(FP), R4
|
|
MOVD buf+16(FP), R5
|
|
SYSCALL $SYS_sched_getaffinity
|
|
MOVW R3, ret+24(FP)
|
|
RET
|
|
|
|
// int32 runtime·epollcreate(int32 size);
|
|
TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW size+0(FP), R3
|
|
SYSCALL $SYS_epoll_create
|
|
MOVW R3, ret+8(FP)
|
|
RET
|
|
|
|
// int32 runtime·epollcreate1(int32 flags);
|
|
TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW flags+0(FP), R3
|
|
SYSCALL $SYS_epoll_create1
|
|
MOVW R3, ret+8(FP)
|
|
RET
|
|
|
|
// func epollctl(epfd, op, fd int32, ev *epollEvent) int
|
|
TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW epfd+0(FP), R3
|
|
MOVW op+4(FP), R4
|
|
MOVW fd+8(FP), R5
|
|
MOVD ev+16(FP), R6
|
|
SYSCALL $SYS_epoll_ctl
|
|
MOVW R3, ret+24(FP)
|
|
RET
|
|
|
|
// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
|
|
TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW epfd+0(FP), R3
|
|
MOVD ev+8(FP), R4
|
|
MOVW nev+16(FP), R5
|
|
MOVW timeout+20(FP), R6
|
|
SYSCALL $SYS_epoll_wait
|
|
MOVW R3, ret+24(FP)
|
|
RET
|
|
|
|
// void runtime·closeonexec(int32 fd);
|
|
TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0
|
|
MOVW fd+0(FP), R3 // fd
|
|
MOVD $2, R4 // F_SETFD
|
|
MOVD $1, R5 // FD_CLOEXEC
|
|
SYSCALL $SYS_fcntl
|
|
RET
|