Skip to content

G
go
Commit 5f691cfa authored by Shenghou Ma's avatar Shenghou Ma
Browse files
Options

[dev.power64] runtime: manually written parts for linux/power64 and linux/power64le, checkpoint 

LGTM=rsc
R=rsc, iant
CC=golang-codereviews
https://golang.org/cl/122430043
parent 4928b207
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1795 additions and 0 deletions
src/pkg/runtime/arch_power64.h 0 → 100644
View file @ 5f691cfa
// 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.
enum {
thechar = '9',
BigEndian = 1,
CacheLineSize = 64,
RuntimeGogoBytes = 84,
PhysPageSize = 4096,
PCQuantum = 4,
Int64Align = 8
};
src/pkg/runtime/arch_power64le.h 0 → 100644
View file @ 5f691cfa
// 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.
enum {
thechar = '9',
BigEndian = 0,
CacheLineSize = 64,
RuntimeGogoBytes = 84,
PhysPageSize = 4096,
PCQuantum = 4,
Int64Align = 8
};
src/pkg/runtime/asm_power64x.s 0 → 100644
View file @ 5f691cfa
This diff is collapsed.
src/pkg/runtime/atomic_power64x.s 0 → 100644
View file @ 5f691cfa
// 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 power64 power64le
#include "../../cmd/ld/textflag.h"
// uint32 runtime·atomicload(uint32 volatile* addr)
TEXT ·atomicload(SB),NOSPLIT,$-8-8
MOVD 0(FP), R3
SYNC
MOVWZ 0(R3), R3
CMPW R3, R3, CR7
BC 4, 30, 1(PC) // bne- cr7,0x4
ISYNC
RETURN
// uint64 runtime·atomicload64(uint64 volatile* addr)
TEXT ·atomicload64(SB),NOSPLIT,$-8-8
MOVD 0(FP), R3
SYNC
MOVD 0(R3), R3
CMP R3, R3, CR7
BC 4, 30, 1(PC) // bne- cr7,0x4
ISYNC
RETURN
// void *runtime·atomicloadp(void *volatile *addr)
TEXT ·atomicloadp(SB),NOSPLIT,$-8-8
MOVD 0(FP), R3
SYNC
MOVD 0(R3), R3
CMP R3, R3, CR7
BC 4, 30, 1(PC) // bne- cr7,0x4
ISYNC
RETURN
src/pkg/runtime/memclr_power64x.s 0 → 100644
View file @ 5f691cfa
// 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 power64 power64le
#include "../../cmd/ld/textflag.h"
// void runtime·memclr(void*, uintptr)
TEXT runtime·memclr(SB),NOSPLIT,$0-16
MOVD ptr+0(FP), R3
MOVD n+8(FP), R4
CMP R4, $0
BEQ done
SUB $1, R3
MOVD R4, CTR
MOVBU R0, 1(R3)
BC 25, 0, -1(PC) // bdnz+ $-4
done:
RETURN
src/pkg/runtime/memmove_power64x.s 0 → 100644
View file @ 5f691cfa
// 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 power64 power64le
#include "../../cmd/ld/textflag.h"
// void runtime·memmove(void*, void*, uintptr)
TEXT runtime·memmove(SB), NOSPLIT, $-8-24
MOVD to+0(FP), R3
MOVD from+8(FP), R4
MOVD n+16(FP), R5
CMP R5, $0
BNE check
RETURN
check:
CMP R3, R4
BGT backward
SUB $1, R3
ADD R3, R5
SUB $1, R4
loop:
MOVBU 1(R4), R6
MOVBU R6, 1(R3)
CMP R3, R5
BNE loop
RETURN
backward:
ADD R5, R4
ADD R3, R5
loop1:
MOVBU -1(R4), R6
MOVBU R6, -1(R5)
CMP R3, R5
BNE loop1
RETURN
src/pkg/runtime/rt0_linux_power64.s 0 → 100644
View file @ 5f691cfa
#include "../../cmd/ld/textflag.h"
// actually a function descriptor for _main<>(SB)
TEXT _rt0_power64_linux(SB),7,$0
DWORD $_main<>(SB)
DWORD $0
DWORD $0
TEXT _main<>(SB),NOSPLIT,$-8
MOVD 0(R1), R3 // argc
ADD $8, R1, R4 // argv
BR main(SB)
TEXT main(SB),NOSPLIT,$-8
MOVD $_rt0_go(SB), R31
MOVD R31, CTR
BR (CTR)
src/pkg/runtime/rt0_linux_power64le.s 0 → 100644
View file @ 5f691cfa
#include "../../cmd/ld/textflag.h"
TEXT _rt0_power64le_linux(SB),7,$0
BR _main<>(SB)
TEXT _main<>(SB),NOSPLIT,$-8
MOVD 0(R1), R3 // argc
ADD $8, R1, R4 // argv
BR main(SB)
TEXT main(SB),NOSPLIT,$-8
MOVD $_rt0_go(SB), R31
MOVD R31, CTR
BR (CTR)
src/pkg/runtime/signal_linux_power64.h 0 → 100644
View file @ 5f691cfa
// 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.
#define SIG_REGS(ctxt) (*((Sigcontext*)&((Ucontext*)(ctxt))->uc_mcontext)->regs)
#define SIG_R0(info, ctxt) (SIG_REGS(ctxt).gpr[0])
#define SIG_R1(info, ctxt) (SIG_REGS(ctxt).gpr[1])
#define SIG_R2(info, ctxt) (SIG_REGS(ctxt).gpr[2])
#define SIG_R3(info, ctxt) (SIG_REGS(ctxt).gpr[3])
#define SIG_R4(info, ctxt) (SIG_REGS(ctxt).gpr[4])
#define SIG_R5(info, ctxt) (SIG_REGS(ctxt).gpr[5])
#define SIG_R6(info, ctxt) (SIG_REGS(ctxt).gpr[6])
#define SIG_R7(info, ctxt) (SIG_REGS(ctxt).gpr[7])
#define SIG_R8(info, ctxt) (SIG_REGS(ctxt).gpr[8])
#define SIG_R9(info, ctxt) (SIG_REGS(ctxt).gpr[9])
#define SIG_R10(info, ctxt) (SIG_REGS(ctxt).gpr[10])
#define SIG_R11(info, ctxt) (SIG_REGS(ctxt).gpr[11])
#define SIG_R12(info, ctxt) (SIG_REGS(ctxt).gpr[12])
#define SIG_R13(info, ctxt) (SIG_REGS(ctxt).gpr[13])
#define SIG_R14(info, ctxt) (SIG_REGS(ctxt).gpr[14])
#define SIG_R15(info, ctxt) (SIG_REGS(ctxt).gpr[15])
#define SIG_R16(info, ctxt) (SIG_REGS(ctxt).gpr[16])
#define SIG_R17(info, ctxt) (SIG_REGS(ctxt).gpr[17])
#define SIG_R18(info, ctxt) (SIG_REGS(ctxt).gpr[18])
#define SIG_R19(info, ctxt) (SIG_REGS(ctxt).gpr[19])
#define SIG_R20(info, ctxt) (SIG_REGS(ctxt).gpr[20])
#define SIG_R21(info, ctxt) (SIG_REGS(ctxt).gpr[21])
#define SIG_R22(info, ctxt) (SIG_REGS(ctxt).gpr[22])
#define SIG_R23(info, ctxt) (SIG_REGS(ctxt).gpr[23])
#define SIG_R24(info, ctxt) (SIG_REGS(ctxt).gpr[24])
#define SIG_R25(info, ctxt) (SIG_REGS(ctxt).gpr[25])
#define SIG_R26(info, ctxt) (SIG_REGS(ctxt).gpr[26])
#define SIG_R27(info, ctxt) (SIG_REGS(ctxt).gpr[27])
#define SIG_R28(info, ctxt) (SIG_REGS(ctxt).gpr[28])
#define SIG_R29(info, ctxt) (SIG_REGS(ctxt).gpr[29])
#define SIG_R30(info, ctxt) (SIG_REGS(ctxt).gpr[30])
#define SIG_R31(info, ctxt) (SIG_REGS(ctxt).gpr[31])
#define SIG_SP(info, ctxt) (SIG_REGS(ctxt).gpr[1])
#define SIG_PC(info, ctxt) (SIG_REGS(ctxt).nip)
#define SIG_TRAP(info, ctxt) (SIG_REGS(ctxt).trap)
#define SIG_CTR(info, ctxt) (SIG_REGS(ctxt).ctr)
#define SIG_LINK(info, ctxt) (SIG_REGS(ctxt).link)
#define SIG_XER(info, ctxt) (SIG_REGS(ctxt).xer)
#define SIG_CCR(info, ctxt) (SIG_REGS(ctxt).ccr)
#define SIG_CODE0(info, ctxt) ((uintptr)(info)->si_code)
#define SIG_FAULT(info, ctxt) (SIG_REGS(ctxt).dar)
src/pkg/runtime/signal_linux_power64le.h 0 → 100644
View file @ 5f691cfa
// 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.
#define SIG_REGS(ctxt) (*((Sigcontext*)&((Ucontext*)(ctxt))->uc_mcontext)->regs)
#define SIG_R0(info, ctxt) (SIG_REGS(ctxt).gpr[0])
#define SIG_R1(info, ctxt) (SIG_REGS(ctxt).gpr[1])
#define SIG_R2(info, ctxt) (SIG_REGS(ctxt).gpr[2])
#define SIG_R3(info, ctxt) (SIG_REGS(ctxt).gpr[3])
#define SIG_R4(info, ctxt) (SIG_REGS(ctxt).gpr[4])
#define SIG_R5(info, ctxt) (SIG_REGS(ctxt).gpr[5])
#define SIG_R6(info, ctxt) (SIG_REGS(ctxt).gpr[6])
#define SIG_R7(info, ctxt) (SIG_REGS(ctxt).gpr[7])
#define SIG_R8(info, ctxt) (SIG_REGS(ctxt).gpr[8])
#define SIG_R9(info, ctxt) (SIG_REGS(ctxt).gpr[9])
#define SIG_R10(info, ctxt) (SIG_REGS(ctxt).gpr[10])
#define SIG_R11(info, ctxt) (SIG_REGS(ctxt).gpr[11])
#define SIG_R12(info, ctxt) (SIG_REGS(ctxt).gpr[12])
#define SIG_R13(info, ctxt) (SIG_REGS(ctxt).gpr[13])
#define SIG_R14(info, ctxt) (SIG_REGS(ctxt).gpr[14])
#define SIG_R15(info, ctxt) (SIG_REGS(ctxt).gpr[15])
#define SIG_R16(info, ctxt) (SIG_REGS(ctxt).gpr[16])
#define SIG_R17(info, ctxt) (SIG_REGS(ctxt).gpr[17])
#define SIG_R18(info, ctxt) (SIG_REGS(ctxt).gpr[18])
#define SIG_R19(info, ctxt) (SIG_REGS(ctxt).gpr[19])
#define SIG_R20(info, ctxt) (SIG_REGS(ctxt).gpr[20])
#define SIG_R21(info, ctxt) (SIG_REGS(ctxt).gpr[21])
#define SIG_R22(info, ctxt) (SIG_REGS(ctxt).gpr[22])
#define SIG_R23(info, ctxt) (SIG_REGS(ctxt).gpr[23])
#define SIG_R24(info, ctxt) (SIG_REGS(ctxt).gpr[24])
#define SIG_R25(info, ctxt) (SIG_REGS(ctxt).gpr[25])
#define SIG_R26(info, ctxt) (SIG_REGS(ctxt).gpr[26])
#define SIG_R27(info, ctxt) (SIG_REGS(ctxt).gpr[27])
#define SIG_R28(info, ctxt) (SIG_REGS(ctxt).gpr[28])
#define SIG_R29(info, ctxt) (SIG_REGS(ctxt).gpr[29])
#define SIG_R30(info, ctxt) (SIG_REGS(ctxt).gpr[30])
#define SIG_R31(info, ctxt) (SIG_REGS(ctxt).gpr[31])
#define SIG_SP(info, ctxt) (SIG_REGS(ctxt).gpr[1])
#define SIG_PC(info, ctxt) (SIG_REGS(ctxt).nip)
#define SIG_TRAP(info, ctxt) (SIG_REGS(ctxt).trap)
#define SIG_CTR(info, ctxt) (SIG_REGS(ctxt).ctr)
#define SIG_LINK(info, ctxt) (SIG_REGS(ctxt).link)
#define SIG_XER(info, ctxt) (SIG_REGS(ctxt).xer)
#define SIG_CCR(info, ctxt) (SIG_REGS(ctxt).ccr)
#define SIG_CODE0(info, ctxt) ((uintptr)(info)->si_code)
#define SIG_FAULT(info, ctxt) (SIG_REGS(ctxt).dar)
src/pkg/runtime/signal_power64x.c 0 → 100644
View file @ 5f691cfa
// 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 power64 power64le
#include "runtime.h"
#include "defs_GOOS_GOARCH.h"
#include "os_GOOS.h"
#include "signal_GOOS_GOARCH.h"
#include "signals_GOOS.h"
void
runtime·dumpregs(Siginfo *info, void *ctxt)
{
USED(info); USED(ctxt);
runtime·printf("r0 %X\t", SIG_R0(info, ctxt));
runtime·printf("r1 %X\n", SIG_R1(info, ctxt));
runtime·printf("r2 %X\t", SIG_R2(info, ctxt));
runtime·printf("r3 %X\n", SIG_R3(info, ctxt));
runtime·printf("r4 %X\t", SIG_R4(info, ctxt));
runtime·printf("r5 %X\n", SIG_R5(info, ctxt));
runtime·printf("r6 %X\t", SIG_R6(info, ctxt));
runtime·printf("r7 %X\n", SIG_R7(info, ctxt));
runtime·printf("r8 %X\t", SIG_R8(info, ctxt));
runtime·printf("r9 %X\n", SIG_R9(info, ctxt));
runtime·printf("r10 %X\t", SIG_R10(info, ctxt));
runtime·printf("r11 %X\n", SIG_R11(info, ctxt));
runtime·printf("r12 %X\t", SIG_R12(info, ctxt));
runtime·printf("r13 %X\n", SIG_R13(info, ctxt));
runtime·printf("r14 %X\t", SIG_R14(info, ctxt));
runtime·printf("r15 %X\n", SIG_R15(info, ctxt));
runtime·printf("r16 %X\t", SIG_R16(info, ctxt));
runtime·printf("r17 %X\n", SIG_R17(info, ctxt));
runtime·printf("r18 %X\t", SIG_R18(info, ctxt));
runtime·printf("r19 %X\n", SIG_R19(info, ctxt));
runtime·printf("r20 %X\t", SIG_R20(info, ctxt));
runtime·printf("r21 %X\n", SIG_R21(info, ctxt));
runtime·printf("r22 %X\t", SIG_R22(info, ctxt));
runtime·printf("r23 %X\n", SIG_R23(info, ctxt));
runtime·printf("r24 %X\t", SIG_R24(info, ctxt));
runtime·printf("r25 %X\n", SIG_R25(info, ctxt));
runtime·printf("r26 %X\t", SIG_R26(info, ctxt));
runtime·printf("r27 %X\n", SIG_R27(info, ctxt));
runtime·printf("r28 %X\t", SIG_R28(info, ctxt));
runtime·printf("r29 %X\n", SIG_R29(info, ctxt));
runtime·printf("r30 %X\t", SIG_R30(info, ctxt));
runtime·printf("r31 %X\n", SIG_R31(info, ctxt));
runtime·printf("pc %X\t", SIG_PC(info, ctxt));
runtime·printf("ctr %X\n", SIG_CTR(info, ctxt));
runtime·printf("link %X\t", SIG_LINK(info, ctxt));
runtime·printf("xer %X\n", SIG_XER(info, ctxt));
runtime·printf("ccr %X\t", SIG_CCR(info, ctxt));
runtime·printf("trap %X\n", SIG_TRAP(info, ctxt));
}
void
runtime·sighandler(int32 sig, Siginfo *info, void *ctxt, G *gp)
{
SigTab *t;
bool crash;
if(sig == SIGPROF) {
runtime·sigprof((uint8*)SIG_PC(info, ctxt), (uint8*)SIG_SP(info, ctxt), (uint8*)SIG_LINK(info, ctxt), gp, g->m);
return;
}
t = &runtime·sigtab[sig];
if(SIG_CODE0(info, ctxt) != SI_USER && (t->flags & SigPanic)) {
// Make it look like a call to the signal func.
// Have to pass arguments out of band since
// augmenting the stack frame would break
// the unwinding code.
gp->sig = sig;
gp->sigcode0 = SIG_CODE0(info, ctxt);
gp->sigcode1 = SIG_FAULT(info, ctxt);
gp->sigpc = SIG_PC(info, ctxt);
// We arrange link, and pc to pretend the panicking
// function calls sigpanic directly.
// Always save LINK to stack so that panics in leaf
// functions are correctly handled. This smashes
// the stack frame but we're not going back there
// anyway.
SIG_SP(info, ctxt) -= sizeof(uintptr);
*(uintptr*)SIG_SP(info, ctxt) = SIG_LINK(info, ctxt);
// Don't bother saving PC if it's zero, which is
// probably a call to a nil func: the old link register
// is more useful in the stack trace.
if(gp->sigpc != 0)
SIG_LINK(info, ctxt) = gp->sigpc;
// In case we are panicking from external C code
SIG_R0(info, ctxt) = 0;
SIG_R30(info, ctxt) = (uintptr)gp;
SIG_PC(info, ctxt) = (uintptr)runtime·sigpanic;
return;
}
if(SIG_CODE0(info, ctxt) == SI_USER || (t->flags & SigNotify))
if(runtime·sigsend(sig))
return;
if(t->flags & SigKill)
runtime·exit(2);
if(!(t->flags & SigThrow))
return;
g->m->throwing = 1;
g->m->caughtsig = gp;
if(runtime·panicking) // traceback already printed
runtime·exit(2);
runtime·panicking = 1;
if(sig < 0 || sig >= NSIG)
runtime·printf("Signal %d\n", sig);
else
runtime·printf("%s\n", runtime·sigtab[sig].name);
runtime·printf("PC=%x\n", SIG_PC(info, ctxt));
if(g->m->lockedg != nil && g->m->ncgo > 0 && gp == g->m->g0) {
runtime·printf("signal arrived during cgo execution\n");
gp = g->m->lockedg;
}
runtime·printf("\n");
if(runtime·gotraceback(&crash)){
runtime·goroutineheader(gp);
runtime·traceback(SIG_PC(info, ctxt), SIG_SP(info, ctxt), SIG_LINK(info, ctxt), gp);
runtime·tracebackothers(gp);
runtime·printf("\n");
runtime·dumpregs(info, ctxt);
}
if(crash)
runtime·crash();
runtime·exit(2);
}
src/pkg/runtime/sys_linux_power64x.s 0 → 100644
View file @ 5f691cfa
// 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 power64 power64le
//
// System calls and other sys.stuff for Power64, Linux
//
#include "zasm_GOOS_GOARCH.h"
#include "../../cmd/ld/textflag.h"
#define SYS_exit 1
#define SYS_read 3
#define SYS_write 4
#define SYS_open 5
#define SYS_close 6
#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,$-8-8
MOVW 8(R1), R3
SYSCALL $SYS_exit_group
RETURN
TEXT runtime·exit1(SB),NOSPLIT,$-8-8
MOVW 8(R1), R3
SYSCALL $SYS_exit
RETURN
TEXT runtime·open(SB),NOSPLIT,$-8-16
MOVD 8(R1), R3
MOVW 16(R1), R4
MOVW 20(R1), R5
SYSCALL $SYS_open
RETURN
TEXT runtime·close(SB),NOSPLIT,$-8-16
MOVW 8(R1), R3
SYSCALL $SYS_close
RETURN
TEXT runtime·write(SB),NOSPLIT,$-8-24
MOVD 8(R1), R3
MOVD 16(R1), R4
MOVW 24(R1), R5
SYSCALL $SYS_write
RETURN
TEXT runtime·read(SB),NOSPLIT,$-8-24
MOVW 8(R1), R3
MOVD 16(R1), R4
MOVW 24(R1), R5
SYSCALL $SYS_read
RETURN
TEXT runtime·getrlimit(SB),NOSPLIT,$-8-24
MOVW 8(R1), R3
MOVD 16(R1), R4
SYSCALL $SYS_ugetrlimit // ??? why not use SYS_getrlimit
RETURN
TEXT runtime·usleep(SB),NOSPLIT,$-8-16
MOVW usec+0(FP), R3
MOVD R3, R5
MOVW $1000000, R4
DIVD R4, R3
MOVD R3, 0(R1)
MULLD R3, R4
SUB R4, R5
MOVD R5, 8(R1)
// select(0, 0, 0, 0, &tv)
MOVW $0, R3
MOVW $0, R4
MOVW $0, R5
MOVW $0, R6
MOVD R1, R7
SYSCALL $SYS_newselect
RETURN
TEXT runtime·raise(SB),NOSPLIT,$-8
SYSCALL $SYS_gettid
MOVW R3, R3 // arg 1 tid
MOVW sig+0(FP), R4 // arg 2
SYSCALL $SYS_tkill
RETURN
TEXT runtime·setitimer(SB),NOSPLIT,$-8-24
MOVW 8(R1), R3
MOVD 16(R1), R4
MOVD 24(R1), R5
SYSCALL $SYS_setitimer
RETURN
TEXT runtime·mincore(SB),NOSPLIT,$-8-24
MOVD 8(R1), R3
MOVD 16(R1), R4
MOVD 24(R1), R5
SYSCALL $SYS_mincore
RETURN
// 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
MOVW 8(R1), R5 // usec
MOVD $1000, R4
MULLD R4, R5
MOVD R3, sec+0(FP)
MOVW R5, nsec+8(FP)
RETURN
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
RETURN
TEXT runtime·rtsigprocmask(SB),NOSPLIT,$-8-32
MOVW 8(R1), R3
MOVD 16(R1), R4
MOVD 24(R1), R5
MOVW 32(R1), R6
SYSCALL $SYS_rt_sigprocmask
BVC 2(PC)
MOVD R0, 0xf1(R0) // crash
RETURN
TEXT runtime·rt_sigaction(SB),NOSPLIT,$-8-32
MOVD 8(R1), R3
MOVD 16(R1), R4
MOVD 24(R1), R5
MOVD 32(R1), R6
SYSCALL $SYS_rt_sigaction
RETURN
#ifdef GOARCH_power64le
// power64le doesn't need function descriptors
TEXT runtime·sigtramp(SB),NOSPLIT,$64
#else
// function descriptor for the real sigtramp
TEXT runtime·sigtramp(SB),NOSPLIT,$-8
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)
// check that g exists
CMP g, $0
BNE 6(PC)
MOVD R3, 8(R1)
MOVD $runtime·badsignal(SB), R31
MOVD R31, CTR
BL (CTR)
RETURN
// save g
MOVD g, 40(R1)
MOVD g, R6
// g = m->gsignal
MOVD g_m(g), R7
MOVD m_gsignal(R7), g
MOVW R3, 8(R1)
MOVD R4, 16(R1)
MOVD R5, 24(R1)
MOVD R6, 32(R1)
BL runtime·sighandler(SB)
// restore g
MOVD 40(R1), g
RETURN
TEXT runtime·mmap(SB),NOSPLIT,$-8
MOVD 8(R1), R3
MOVD 16(R1), R4
MOVW 24(R1), R5
MOVW 28(R1), R6
MOVW 32(R1), R7
MOVW 36(R1), R8
SYSCALL $SYS_mmap
BVC 2(PC)
NEG R3, R3
RETURN
TEXT runtime·munmap(SB),NOSPLIT,$-8
MOVD 8(R1), R3
MOVD 16(R1), R4
SYSCALL $SYS_munmap
BVC 2(PC)
MOVD R0, 0xf3(R0)
RETURN
TEXT runtime·madvise(SB),NOSPLIT,$-8
MOVD 8(R1), R3
MOVD 16(R1), R4
MOVD 24(R1), R5
SYSCALL $SYS_madvise
// ignore failure - maybe pages are locked
RETURN
// int64 futex(int32 *uaddr, int32 op, int32 val,
// struct timespec *timeout, int32 *uaddr2, int32 val2);
TEXT runtime·futex(SB),NOSPLIT,$-8
MOVD 8(R1), R3
MOVW 16(R1), R4
MOVW 20(R1), R5
MOVD 24(R1), R6
MOVD 32(R1), R7
MOVW 40(R1), R8
SYSCALL $SYS_futex
RETURN
// int64 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
TEXT runtime·clone(SB),NOSPLIT,$-8
MOVW flags+0(FP), R3
MOVD stack+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 2(PC)
RETURN
// 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
MOVD -16(R1), R8
MOVD -8(R1), R7
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)
// Call fn
MOVD R12, CTR
BL (CTR)
// It shouldn't return. If it does, exit
MOVW $111, R3
SYSCALL $SYS_exit_group
BR -2(PC) // keep exiting
TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVD new+0(FP), R3
MOVD old+8(FP), R4
SYSCALL $SYS_sigaltstack
BVC 2(PC)
MOVD R0, 0xf1(R0) // crash
RETURN
TEXT runtime·osyield(SB),NOSPLIT,$-8
SYSCALL $SYS_sched_yield
RETURN
TEXT runtime·sched_getaffinity(SB),NOSPLIT,$-8
MOVD 8(R1), R3
MOVD 16(R1), R4
MOVD 24(R1), R5
SYSCALL $SYS_sched_getaffinity
RETURN
// int32 runtime·epollcreate(int32 size);
TEXT runtime·epollcreate(SB),NOSPLIT,$-8
MOVW 8(R1), R3
SYSCALL $SYS_epoll_create
RETURN
// int32 runtime·epollcreate1(int32 flags);
TEXT runtime·epollcreate1(SB),NOSPLIT,$-8
MOVW 8(R1), R3
SYSCALL $SYS_epoll_create1
RETURN
// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
TEXT runtime·epollctl(SB),NOSPLIT,$-8
MOVW 8(R1), R3
MOVW 12(R1), R4
MOVW 16(R1), R5
MOVD 24(R1), R6
SYSCALL $SYS_epoll_ctl
RETURN
// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
TEXT runtime·epollwait(SB),NOSPLIT,$-8
MOVW 8(R1), R3
MOVD 16(R1), R4
MOVW 24(R1), R5
MOVW 28(R1), R6
SYSCALL $SYS_epoll_wait
RETURN
// void runtime·closeonexec(int32 fd);
TEXT runtime·closeonexec(SB),NOSPLIT,$-8
MOVW 8(R1), R3 // fd
MOVD $2, R4 // F_SETFD
MOVD $1, R5 // FD_CLOEXEC
SYSCALL $SYS_fcntl
RETURN
src/pkg/runtime/sys_power64x.c 0 → 100644
View file @ 5f691cfa
// 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 power64 power64le
#include "runtime.h"
// adjust Gobuf as if it executed a call to fn with context ctxt
// and then did an immediate Gosave.
void
runtime·gostartcall(Gobuf *gobuf, void (*fn)(void), void *ctxt)
{
if(gobuf->lr != 0)
runtime·throw("invalid use of gostartcall");
gobuf->lr = gobuf->pc;
gobuf->pc = (uintptr)fn;
gobuf->ctxt = ctxt;
}
// Called to rewind context saved during morestack back to beginning of function.
// To help us, the linker emits a jmp back to the beginning right after the
// call to morestack. We just have to decode and apply that jump.
void
runtime·rewindmorestack(Gobuf *gobuf)
{
uint32 inst;
inst = *(uint32*)gobuf->pc;
if((gobuf->pc&3) == 0 && (inst>>24) == 0x4b && (inst&3) == 0) {
runtime·printf("runtime: rewind pc=%p to pc=%p\n", gobuf->pc, gobuf->pc + ((int32)(inst<<8)>>8));
gobuf->pc += (int32)(inst<<8)>>8;
return;
}
runtime·printf("runtime: pc=%p %x\n", gobuf->pc, inst);
runtime·throw("runtime: misuse of rewindmorestack");
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7