From d794c3a12eb8d762b119cf244bbbac8ee66b5a54 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 27 Oct 2014 17:27:03 -0400 Subject: [dev.power64] runtime: power64 fixes and ports of changes Fix include paths that got moved in the great pkg/ rename. Add missing runtime/arch_* files for power64. Port changes that happened on default since branching to runtime/{asm,atomic,sys_linux}_power64x.s (precise stacks, calling convention change, various new and deleted functions. Port struct renaming and fix some bugs in runtime/defs_linux_power64.h. LGTM=rsc R=rsc, dave CC=golang-codereviews https://codereview.appspot.com/161450043 --- src/runtime/asm_power64x.s | 478 +++++++++++++++++++-------------------------- 1 file changed, 198 insertions(+), 280 deletions(-) (limited to 'src/runtime/asm_power64x.s') diff --git a/src/runtime/asm_power64x.s b/src/runtime/asm_power64x.s index a0511de8e..76bf42094 100644 --- a/src/runtime/asm_power64x.s +++ b/src/runtime/asm_power64x.s @@ -6,9 +6,9 @@ #include "zasm_GOOS_GOARCH.h" #include "funcdata.h" -#include "../../cmd/ld/textflag.h" +#include "textflag.h" -TEXT _rt0_go(SB),NOSPLIT,$0 +TEXT runtime·rt0_go(SB),NOSPLIT,$0 // initialize essential registers BL runtime·reginit(SB) @@ -21,9 +21,10 @@ TEXT _rt0_go(SB),NOSPLIT,$0 MOVD $runtime·g0(SB), g MOVD $(-64*1024), R31 ADD R31, R1, R3 - MOVD R3, g_stackguard(g) MOVD R3, g_stackguard0(g) - MOVD R1, g_stackbase(g) + MOVD R3, g_stackguard1(g) + MOVD R3, (g_stack+stack_lo)(g) + MOVD R1, (g_stack+stack_hi)(g) // TODO: if there is a _cgo_init, call it. // TODO: add TLS @@ -41,7 +42,6 @@ TEXT _rt0_go(SB),NOSPLIT,$0 // args are already prepared BL runtime·args(SB) BL runtime·osinit(SB) - BL runtime·hashinit(SB) BL runtime·schedinit(SB) // create a new goroutine to start program @@ -49,9 +49,7 @@ TEXT _rt0_go(SB),NOSPLIT,$0 MOVDU R3, -8(R1) MOVDU R0, -8(R1) MOVDU R0, -8(R1) - ARGSIZE(24) BL runtime·newproc(SB) - ARGSIZE(-1) ADD $24, R1 // start this M @@ -118,7 +116,7 @@ TEXT runtime·gogo(SB), NOSPLIT, $-8-8 MOVD R31, CTR BR (CTR) -// void mcall(void (*fn)(G*)) +// void mcall(fn func(*g)) // Switch to m->g0's stack, call fn(g). // Fn must never return. It should gogo(&g->sched) // to keep running g. @@ -137,9 +135,10 @@ TEXT runtime·mcall(SB), NOSPLIT, $-8-8 CMP g, R3 BNE 2(PC) BR runtime·badmcall(SB) - MOVD fn+0(FP), R4 + MOVD fn+0(FP), R11 // context + MOVD 0(R11), R4 // code pointer MOVD R4, CTR - MOVD (g_sched+gobuf_sp)(g), R1 + MOVD (g_sched+gobuf_sp)(g), R1 // sp = m->g0->sched.sp MOVDU R3, -8(R1) MOVDU R0, -8(R1) BL (CTR) @@ -150,23 +149,50 @@ TEXT runtime·mcall(SB), NOSPLIT, $-8-8 // lives at the bottom of the G stack from the one that lives // at the top of the M stack because the one at the top of // the M stack terminates the stack walk (see topofstack()). -TEXT runtime·switchtoM(SB), NOSPLIT, $0-8 +TEXT runtime·switchtoM(SB), NOSPLIT, $0-0 UNDEF BL (LR) // make sure this function is not leaf RETURN -// void onM(void (*fn)()) -// calls fn() on the M stack. -// switches to the M stack if not already on it, and -// switches back when fn() returns. +// func onM_signalok(fn func()) +TEXT runtime·onM_signalok(SB), NOSPLIT, $8-8 + MOVD g, R3 // R3 = g + MOVD g_m(R3), R4 // R4 = g->m + MOVD m_gsignal(R4), R4 // R4 = g->m->gsignal + MOVD fn+0(FP), R11 // context for call below + CMP R3, R4 + BEQ onsignal + MOVD R11, 8(R1) + BL runtime·onM(SB) + RETURN + +onsignal: + MOVD 0(R11), R3 // code pointer + MOVD R3, CTR + BL (CTR) + RETURN + +// void onM(fn func()) TEXT runtime·onM(SB), NOSPLIT, $0-8 MOVD fn+0(FP), R3 // R3 = fn - MOVD R3, CTR + MOVD R3, R11 // context MOVD g_m(g), R4 // R4 = m + MOVD m_g0(R4), R5 // R5 = g0 CMP g, R5 BEQ onm + MOVD m_curg(R4), R6 + CMP g, R6 + BEQ oncurg + + // Not g0, not curg. Must be gsignal, but that's not allowed. + // Hide call from linker nosplit analysis. + MOVD $runtime·badonm(SB), R3 + MOVD R3, CTR + BL (CTR) + +oncurg: // save our state in g->sched. Pretend to // be switchtoM if the G stack is scanned. MOVD $runtime·switchtoM(SB), R6 @@ -178,10 +204,16 @@ TEXT runtime·onM(SB), NOSPLIT, $0-8 // switch to g0 MOVD R5, g - MOVD (g_sched+gobuf_sp)(g), R1 + MOVD (g_sched+gobuf_sp)(g), R3 + // make it look like mstart called onM on g0, to stop traceback + SUB $8, R3 + MOVD $runtime·mstart(SB), R4 + MOVD R4, 0(R3) + MOVD R3, R1 // call target function - ARGSIZE(0) + MOVD 0(R11), R3 // code pointer + MOVD R3, CTR BL (CTR) // switch back to g @@ -193,6 +225,8 @@ TEXT runtime·onM(SB), NOSPLIT, $0-8 onm: // already on m stack, just call directly + MOVD 0(R11), R3 // code pointer + MOVD R3, CTR BL (CTR) RETURN @@ -216,8 +250,11 @@ TEXT runtime·morestack(SB),NOSPLIT,$-8-0 BNE 2(PC) BL runtime·abort(SB) - MOVW R3, m_moreframesize(R7) - MOVW R4, m_moreargsize(R7) + // Cannot grow signal stack (m->gsignal). + MOVD m_gsignal(R7), R8 + CMP g, R8 + BNE 2(PC) + BL runtime·abort(SB) // Called from f. // Set g->sched to context in f. @@ -231,8 +268,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$-8-0 // Set m->morebuf to f's caller. MOVD R5, (m_morebuf+gobuf_pc)(R7) // f's caller's PC MOVD R1, (m_morebuf+gobuf_sp)(R7) // f's caller's SP - MOVD $8(R1), R8 // f's argument pointer - MOVD R8, m_moreargp(R7) MOVD g, (m_morebuf+gobuf_g)(R7) // Call newstack on m->g0's stack. @@ -248,51 +283,8 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT,$-8-0 MOVD R0, R11 BR runtime·morestack(SB) -// Called from panic. Mimics morestack, -// reuses stack growth code to create a frame -// with the desired args running the desired function. -// -// func call(fn *byte, arg *byte, argsize uint32). -TEXT runtime·newstackcall(SB), NOSPLIT, $-8-20 - // Save our caller's state as the PC and SP to restore when - // returning from f. - MOVD g_m(g), R5 - MOVD LR, R31 - MOVD R31, (m_morebuf+gobuf_pc)(R5) // our caller's PC - MOVD R1, (m_morebuf+gobuf_sp)(R5) // our caller's SP - MOVD g, (m_morebuf+gobuf_g)(R5) - - // Save our own state as the PC and SP to restore if this - // goroutine needs to be restarted. - MOVD $runtime·newstackcall(SB), R7 - MOVD R7, (g_sched+gobuf_pc)(g) - MOVD LR, R31 - MOVD R31, (g_sched+gobuf_lr)(g) - MOVD R1, (g_sched+gobuf_sp)(g) - - // Set up morestack arguments to call f on a new stack. - // We set f's frame size to 1, as a hint to newstack that - // this is a call from runtime.newstackcall. - // If it turns out that f needs a larger frame than the - // default stack, f's usual stack growth prolog will - // allocate a new segment (and recopy the arguments). - MOVD fn+0(FP), R7 - MOVD args+8(FP), R8 - MOVW n+16(FP), R9 - - MOVD R7, m_cret(R5) - MOVD R8, m_moreargp(R5) - MOVW R9, m_moreargsize(R5) - MOVD $1, R10 - MOVW R10, m_moreframesize(R5) - - // call newstack on m->g0's stack - MOVD m_g0(R5), g - MOVD (g_sched+gobuf_sp)(g), R1 - BR runtime·newstack(SB) - -// reflect·call: call a function with the given argument list -// func call(f *FuncVal, arg *byte, argsize uint32). +// reflectcall: call a function with the given argument list +// func call(f *FuncVal, arg *byte, argsize, retoffset uint32). // we don't have variable-sized frames, so we use a small number // of constant-sized-frame functions to encode a few bits of size in the pc. // Caution: ugly multiline assembly macros in your future! @@ -301,60 +293,47 @@ TEXT runtime·newstackcall(SB), NOSPLIT, $-8-20 MOVD $MAXSIZE, R31; \ CMP R3, R31; \ BGT 4(PC); \ - MOVD $runtime·NAME(SB), R31; \ + MOVD $NAME(SB), R31; \ MOVD R31, CTR; \ BR (CTR) +// Note: can't just "BR NAME(SB)" - bad inlining results. -// Note: can't just "BR runtime·NAME(SB)" - bad inlining results. -TEXT reflect·call(SB), NOSPLIT, $-8-24 +TEXT ·reflectcall(SB), NOSPLIT, $-8-24 MOVW argsize+16(FP), R3 - DISPATCH(call16, 16) - DISPATCH(call32, 32) - DISPATCH(call64, 64) - DISPATCH(call128, 128) - DISPATCH(call256, 256) - DISPATCH(call512, 512) - DISPATCH(call1024, 1024) - DISPATCH(call2048, 2048) - DISPATCH(call4096, 4096) - DISPATCH(call8192, 8192) - DISPATCH(call16384, 16384) - DISPATCH(call32768, 32768) - DISPATCH(call65536, 65536) - DISPATCH(call131072, 131072) - DISPATCH(call262144, 262144) - DISPATCH(call524288, 524288) - DISPATCH(call1048576, 1048576) - DISPATCH(call2097152, 2097152) - DISPATCH(call4194304, 4194304) - DISPATCH(call8388608, 8388608) - DISPATCH(call16777216, 16777216) - DISPATCH(call33554432, 33554432) - DISPATCH(call67108864, 67108864) - DISPATCH(call134217728, 134217728) - DISPATCH(call268435456, 268435456) - DISPATCH(call536870912, 536870912) - DISPATCH(call1073741824, 1073741824) + DISPATCH(runtime·call16, 16) + DISPATCH(runtime·call32, 32) + DISPATCH(runtime·call64, 64) + DISPATCH(runtime·call128, 128) + DISPATCH(runtime·call256, 256) + DISPATCH(runtime·call512, 512) + DISPATCH(runtime·call1024, 1024) + DISPATCH(runtime·call2048, 2048) + DISPATCH(runtime·call4096, 4096) + DISPATCH(runtime·call8192, 8192) + DISPATCH(runtime·call16384, 16384) + DISPATCH(runtime·call32768, 32768) + DISPATCH(runtime·call65536, 65536) + DISPATCH(runtime·call131072, 131072) + DISPATCH(runtime·call262144, 262144) + DISPATCH(runtime·call524288, 524288) + DISPATCH(runtime·call1048576, 1048576) + DISPATCH(runtime·call2097152, 2097152) + DISPATCH(runtime·call4194304, 4194304) + DISPATCH(runtime·call8388608, 8388608) + DISPATCH(runtime·call16777216, 16777216) + DISPATCH(runtime·call33554432, 33554432) + DISPATCH(runtime·call67108864, 67108864) + DISPATCH(runtime·call134217728, 134217728) + DISPATCH(runtime·call268435456, 268435456) + DISPATCH(runtime·call536870912, 536870912) + DISPATCH(runtime·call1073741824, 1073741824) MOVD $runtime·badreflectcall(SB), R31 MOVD R31, CTR BR (CTR) -// Argument map for the callXX frames. Each has one -// stack map (for the single call) with 3 arguments. -DATA gcargs_reflectcall<>+0x00(SB)/4, $1 // 1 stackmap -DATA gcargs_reflectcall<>+0x04(SB)/4, $6 // 3 args -DATA gcargs_reflectcall<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsScalar<<4)) -GLOBL gcargs_reflectcall<>(SB),RODATA,$12 - -// callXX frames have no locals -DATA gclocals_reflectcall<>+0x00(SB)/4, $1 // 1 stackmap -DATA gclocals_reflectcall<>+0x04(SB)/4, $0 // 0 locals -GLOBL gclocals_reflectcall<>(SB),RODATA,$8 - #define CALLFN(NAME,MAXSIZE) \ -TEXT runtime·NAME(SB), WRAPPER, $MAXSIZE-24; \ - FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_reflectcall<>(SB); \ - FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_reflectcall<>(SB);\ +TEXT NAME(SB), WRAPPER, $MAXSIZE-24; \ + NO_LOCAL_POINTERS; \ /* copy arguments to stack */ \ MOVD argptr+8(FP), R3; \ MOVW argsize+16(FP), R4; \ @@ -391,47 +370,33 @@ TEXT runtime·NAME(SB), WRAPPER, $MAXSIZE-24; \ BR -4(PC); \ RETURN -CALLFN(call16, 16) -CALLFN(call32, 32) -CALLFN(call64, 64) -CALLFN(call128, 128) -CALLFN(call256, 256) -CALLFN(call512, 512) -CALLFN(call1024, 1024) -CALLFN(call2048, 2048) -CALLFN(call4096, 4096) -CALLFN(call8192, 8192) -CALLFN(call16384, 16384) -CALLFN(call32768, 32768) -CALLFN(call65536, 65536) -CALLFN(call131072, 131072) -CALLFN(call262144, 262144) -CALLFN(call524288, 524288) -CALLFN(call1048576, 1048576) -CALLFN(call2097152, 2097152) -CALLFN(call4194304, 4194304) -CALLFN(call8388608, 8388608) -CALLFN(call16777216, 16777216) -CALLFN(call33554432, 33554432) -CALLFN(call67108864, 67108864) -CALLFN(call134217728, 134217728) -CALLFN(call268435456, 268435456) -CALLFN(call536870912, 536870912) -CALLFN(call1073741824, 1073741824) - -// Return point when leaving stack. -// -// Lessstack can appear in stack traces for the same reason -// as morestack; in that context, it has 0 arguments. -TEXT runtime·lessstack(SB), NOSPLIT, $-8-0 - // Save return value in m->cret - MOVD g_m(g), R5 - MOVD R3, m_cret(R5) - - // Call oldstack on m->g0's stack. - MOVD m_g0(R5), g - MOVD (g_sched+gobuf_sp)(g), R1 - BL runtime·oldstack(SB) +CALLFN(·call16, 16) +CALLFN(·call32, 32) +CALLFN(·call64, 64) +CALLFN(·call128, 128) +CALLFN(·call256, 256) +CALLFN(·call512, 512) +CALLFN(·call1024, 1024) +CALLFN(·call2048, 2048) +CALLFN(·call4096, 4096) +CALLFN(·call8192, 8192) +CALLFN(·call16384, 16384) +CALLFN(·call32768, 32768) +CALLFN(·call65536, 65536) +CALLFN(·call131072, 131072) +CALLFN(·call262144, 262144) +CALLFN(·call524288, 524288) +CALLFN(·call1048576, 1048576) +CALLFN(·call2097152, 2097152) +CALLFN(·call4194304, 4194304) +CALLFN(·call8388608, 8388608) +CALLFN(·call16777216, 16777216) +CALLFN(·call33554432, 33554432) +CALLFN(·call67108864, 67108864) +CALLFN(·call134217728, 134217728) +CALLFN(·call268435456, 268435456) +CALLFN(·call536870912, 536870912) +CALLFN(·call1073741824, 1073741824) // bool cas(int32 *val, int32 old, int32 new) // Atomically: @@ -440,22 +405,23 @@ TEXT runtime·lessstack(SB), NOSPLIT, $-8-0 // return 1; // } else // return 0; -TEXT runtime·cas(SB), NOSPLIT, $0-16 +TEXT runtime·cas(SB), NOSPLIT, $0-17 MOVD p+0(FP), R3 MOVW old+8(FP), R4 MOVW new+12(FP), R5 SYNC LWAR (R3), R6 CMPW R6, R4 - BNE 7(PC) + BNE 8(PC) STWCCC R5, (R3) BNE -5(PC) MOVD $1, R3 SYNC ISYNC + MOVB R3, ret+16(FP) RETURN MOVD $0, R3 - BR -4(PC) + BR -5(PC) // bool runtime·cas64(uint64 *val, uint64 old, uint64 new) // Atomically: @@ -465,7 +431,7 @@ TEXT runtime·cas(SB), NOSPLIT, $0-16 // } else { // return 0; // } -TEXT runtime·cas64(SB), NOSPLIT, $0-24 +TEXT runtime·cas64(SB), NOSPLIT, $0-25 MOVD p+0(FP), R3 MOVD old+8(FP), R4 MOVD new+16(FP), R5 @@ -478,10 +444,23 @@ TEXT runtime·cas64(SB), NOSPLIT, $0-24 MOVD $1, R3 SYNC ISYNC + MOVB R3, ret+24(FP) RETURN MOVD $0, R3 BR -4(PC) +TEXT runtime·casuintptr(SB), NOSPLIT, $0-25 + BR runtime·cas64(SB) + +TEXT runtime·atomicloaduintptr(SB), NOSPLIT, $-8-16 + BR runtime·atomicload64(SB) + +TEXT runtime·atomicloaduint(SB), NOSPLIT, $-8-16 + BR runtime·atomicload64(SB) + +TEXT runtime·atomicstoreuintptr(SB), NOSPLIT, $0-16 + BR runtime·atomicstore64(SB) + // bool casp(void **val, void *old, void *new) // Atomically: // if(*val == old){ @@ -489,14 +468,14 @@ TEXT runtime·cas64(SB), NOSPLIT, $0-24 // return 1; // } else // return 0; -TEXT runtime·casp(SB), NOSPLIT, $0-24 +TEXT runtime·casp(SB), NOSPLIT, $0-25 BR runtime·cas64(SB) // uint32 xadd(uint32 volatile *val, int32 delta) // Atomically: // *val += delta; // return *val; -TEXT runtime·xadd(SB), NOSPLIT, $0-12 +TEXT runtime·xadd(SB), NOSPLIT, $0-20 MOVD p+0(FP), R4 MOVW delta+8(FP), R5 SYNC @@ -506,10 +485,10 @@ TEXT runtime·xadd(SB), NOSPLIT, $0-12 BNE -4(PC) SYNC ISYNC - MOVW R3, R3 + MOVW R3, ret+16(FP) RETURN -TEXT runtime·xadd64(SB), NOSPLIT, $0-16 +TEXT runtime·xadd64(SB), NOSPLIT, $0-24 MOVD p+0(FP), R4 MOVD delta+8(FP), R5 SYNC @@ -519,9 +498,10 @@ TEXT runtime·xadd64(SB), NOSPLIT, $0-16 BNE -4(PC) SYNC ISYNC + MOVD R3, ret+16(FP) RETURN -TEXT runtime·xchg(SB), NOSPLIT, $0-12 +TEXT runtime·xchg(SB), NOSPLIT, $0-20 MOVD p+0(FP), R4 MOVW new+8(FP), R5 SYNC @@ -530,9 +510,10 @@ TEXT runtime·xchg(SB), NOSPLIT, $0-12 BNE -3(PC) SYNC ISYNC + MOVW R3, ret+16(FP) RETURN -TEXT runtime·xchg64(SB), NOSPLIT, $0-16 +TEXT runtime·xchg64(SB), NOSPLIT, $0-24 MOVD p+0(FP), R4 MOVD new+8(FP), R5 SYNC @@ -541,9 +522,13 @@ TEXT runtime·xchg64(SB), NOSPLIT, $0-16 BNE -3(PC) SYNC ISYNC + MOVD R3, ret+16(FP) RETURN -TEXT runtime·xchgp(SB), NOSPLIT, $0-16 +TEXT runtime·xchgp(SB), NOSPLIT, $0-24 + BR runtime·xchg64(SB) + +TEXT runtime·xchguintptr(SB), NOSPLIT, $0-24 BR runtime·xchg64(SB) TEXT runtime·procyield(SB),NOSPLIT,$0-0 @@ -553,20 +538,33 @@ TEXT runtime·atomicstorep(SB), NOSPLIT, $0-16 BR runtime·atomicstore64(SB) TEXT runtime·atomicstore(SB), NOSPLIT, $0-12 - MOVD 0(FP), R3 - MOVW 8(FP), R4 + MOVD ptr+0(FP), R3 + MOVW val+8(FP), R4 SYNC MOVW R4, 0(R3) RETURN TEXT runtime·atomicstore64(SB), NOSPLIT, $0-16 + MOVD ptr+0(FP), R3 + MOVD val+8(FP), R4 + SYNC + MOVD R4, 0(R3) + RETURN + +// void runtime·atomicor8(byte volatile*, byte); +TEXT runtime·atomicor8(SB), NOSPLIT, $0-9 MOVD 0(FP), R3 MOVD 8(FP), R4 SYNC - MOVD R4, 0(R3) + LWAR (R3), R5 + OR R4, R5 + STWCCC R5, (R3) + BNE -3(PC) + SYNC + ISYNC RETURN -// void jmpdefer(fn, sp); +// void jmpdefer(fv, sp); // called from deferreturn. // 1. grab stored LR for caller // 2. sub 4 bytes to get back to BL deferreturn @@ -576,7 +574,7 @@ TEXT runtime·jmpdefer(SB), NOSPLIT, $-8-16 SUB $4, R31 MOVD R31, LR - MOVD fn+0(FP), R11 + MOVD fv+0(FP), R11 MOVD argp+8(FP), R1 SUB $8, R1 MOVD 0(R11), R3 @@ -597,7 +595,7 @@ TEXT gosave<>(SB),NOSPLIT,$-8 // Call fn(arg) on the scheduler stack, // aligned appropriately for the gcc ABI. // See cgocall.c for more details. -TEXT runtime·asmcgocall(SB),NOSPLIT,$0-16 +TEXT ·asmcgocall(SB),NOSPLIT,$0-16 MOVD R0, 21(R0) // cgocallback(void (*fn)(void*), void *frame, uintptr framesize) @@ -608,19 +606,20 @@ TEXT runtime·cgocallback(SB),NOSPLIT,$24-24 // cgocallback_gofunc(FuncVal*, void *frame, uintptr framesize) // See cgocall.c for more details. -TEXT runtime·cgocallback_gofunc(SB),NOSPLIT,$8-24 +TEXT ·cgocallback_gofunc(SB),NOSPLIT,$8-24 MOVD R0, 23(R0) // void setg(G*); set g. for use by needm. -TEXT runtime·setg(SB), NOSPLIT, $0-16 +TEXT runtime·setg(SB), NOSPLIT, $0-8 MOVD R0, 24(R0) // void setg_gcc(G*); set g called from gcc. TEXT setg_gcc<>(SB),NOSPLIT,$0 MOVD R0, 25(R0) -TEXT runtime·getcallerpc(SB),NOSPLIT,$-8-8 +TEXT runtime·getcallerpc(SB),NOSPLIT,$-8-16 MOVD 0(R1), R3 + MOVD R3, ret+8(FP) RETURN TEXT runtime·gogetcallerpc(SB),NOSPLIT,$-8-16 @@ -629,16 +628,24 @@ TEXT runtime·gogetcallerpc(SB),NOSPLIT,$-8-16 RETURN TEXT runtime·setcallerpc(SB),NOSPLIT,$-8-16 - MOVD x+8(FP),R3 // addr of first arg + MOVD pc+8(FP), R3 MOVD R3, 0(R1) // set calling pc RETURN -TEXT runtime·getcallersp(SB),NOSPLIT,$0-8 +TEXT runtime·getcallersp(SB),NOSPLIT,$0-16 MOVD sp+0(FP), R3 SUB $8, R3 + MOVD R3, ret+8(FP) RETURN -TEXT runtime·abort(SB),NOSPLIT,$-4-0 +// func gogetcallersp(p unsafe.Pointer) uintptr +TEXT runtime·gogetcallersp(SB),NOSPLIT,$0-16 + MOVD sp+0(FP), R3 + SUB $8, R3 + MOVD R3,ret+8(FP) + RETURN + +TEXT runtime·abort(SB),NOSPLIT,$-8-0 MOVW (R0), R0 UNDEF @@ -646,7 +653,7 @@ TEXT runtime·abort(SB),NOSPLIT,$-4-0 #define TBRU 269 /* Time base Upper/Lower */ // int64 runtime·cputicks(void) -TEXT runtime·cputicks(SB),NOSPLIT,$0-0 +TEXT runtime·cputicks(SB),NOSPLIT,$0-8 MOVW SPR(TBRU), R4 MOVW SPR(TBRL), R3 MOVW SPR(TBRU), R5 @@ -654,17 +661,9 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-0 BNE -4(PC) SLD $32, R5 OR R5, R3 + MOVD R3, ret+0(FP) RETURN -TEXT runtime·stackguard(SB),NOSPLIT,$0-16 - MOVD R1, R3 - MOVD R3, sp+0(FP) - MOVD g_stackguard(g), R3 - MOVD R3, limit+8(FP) - RETURN - -GLOBL runtime·tls0(SB), $64 - // AES hashing not implemented for Power TEXT runtime·aeshash(SB),NOSPLIT,$-8-0 MOVW (R0), R1 @@ -675,7 +674,7 @@ TEXT runtime·aeshash64(SB),NOSPLIT,$-8-0 TEXT runtime·aeshashstr(SB),NOSPLIT,$-8-0 MOVW (R0), R1 -TEXT runtime·memeq(SB),NOSPLIT,$-8-24 +TEXT runtime·memeq(SB),NOSPLIT,$-8-25 MOVD a+0(FP), R3 MOVD b+8(FP), R4 MOVD count+16(FP), R5 @@ -683,26 +682,6 @@ TEXT runtime·memeq(SB),NOSPLIT,$-8-24 SUB $1, R4 ADD R3, R5, R8 _next: - CMP R3, R8 - BNE 3(PC) - MOVD $1, R3 - RETURN - MOVBZU 1(R3), R6 - MOVBZU 1(R4), R7 - CMP R6, R7 - BEQ _next - - MOVD $0, R3 - RETURN - -TEXT runtime·gomemeq(SB),NOSPLIT,$0-25 - MOVD a+0(FP), R3 - MOVD b+8(FP), R4 - MOVD count+16(FP), R5 - SUB $1, R3 - SUB $1, R4 - ADD R3, R5, R8 -_next2: CMP R3, R8 BNE 4(PC) MOVD $1, R3 @@ -711,14 +690,14 @@ _next2: MOVBZU 1(R3), R6 MOVBZU 1(R4), R7 CMP R6, R7 - BEQ _next2 + BEQ _next MOVB R0, ret+24(FP) RETURN // eqstring tests whether two strings are equal. // See runtime_test.go:eqstring_generic for -// equivlaent Go code. +// equivalent Go code. TEXT runtime·eqstring(SB),NOSPLIT,$0-33 MOVD s1len+8(FP), R4 MOVD s2len+24(FP), R5 @@ -824,9 +803,6 @@ _index2_notfound: RETURN -TEXT runtime·timenow(SB), NOSPLIT, $0-0 - BR time·now(SB) - // A Duff's device for zeroing memory. // The compiler jumps to computed addresses within // this routine to zero chunks of memory. Do not @@ -966,80 +942,22 @@ TEXT runtime·duffzero(SB), NOSPLIT, $-8-0 MOVDU R0, 8(R3) RETURN -TEXT runtime·fastrand2(SB), NOSPLIT, $0-4 +TEXT runtime·fastrand1(SB), NOSPLIT, $0-4 MOVD g_m(g), R4 - MOVD m_fastrand(R4), R3 + MOVWZ m_fastrand(R4), R3 ADD R3, R3 CMP R3, $0 BGE 2(PC) XOR $0x88888eef, R3 - MOVD R3, m_fastrand(R4) - MOVD R3, ret+0(FP) + MOVW R3, m_fastrand(R4) + MOVW R3, ret+0(FP) RETURN -// The gohash and goeq trampolines are necessary while we have -// both Go and C calls to alg functions. Once we move all call -// sites to Go, we can redo the hash/eq functions to use the -// Go calling convention and remove these. - -// convert call to: -// func (alg unsafe.Pointer, p unsafe.Pointer, size uintpr, seed uintptr) uintptr -// to: -// func (hash *uintptr, size uintptr, p unsafe.Pointer) -TEXT runtime·gohash(SB), NOSPLIT, $24-40 - FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_gohash<>(SB) - FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_gohash<>(SB) - MOVD a+0(FP), R3 - MOVD alg_hash(R3), R3 - MOVD R3, CTR - MOVD p+8(FP), R4 - MOVD size+16(FP), R5 - MOVD seed+24(FP), R6 - MOVD R6, ret+32(FP) - MOVD $ret+32(FP), R7 - MOVD R7, 8(R1) - MOVD R5, 16(R1) - MOVD R4, 24(R1) - PCDATA $PCDATA_StackMapIndex, $0 - BL (CTR) +TEXT runtime·return0(SB), NOSPLIT, $0 + MOVW $0, R3 RETURN -DATA gcargs_gohash<>+0x00(SB)/4, $1 // 1 stackmap -DATA gcargs_gohash<>+0x04(SB)/4, $10 // 5 args -DATA gcargs_gohash<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)) -GLOBL gcargs_gohash<>(SB),RODATA,$12 - -DATA gclocals_gohash<>+0x00(SB)/4, $1 // 1 stackmap -DATA gclocals_gohash<>+0x04(SB)/4, $0 // 0 locals -GLOBL gclocals_gohash<>(SB),RODATA,$8 - -// convert call to: -// func (alg unsafe.Pointer, p, q unsafe.Pointer, size uintptr) bool -// to: -// func (eq *bool, size uintptr, p, q unsafe.Pointer) -TEXT runtime·goeq(SB), NOSPLIT, $32-33 - FUNCDATA $FUNCDATA_ArgsPointerMaps,gcargs_goeq<>(SB) - FUNCDATA $FUNCDATA_LocalsPointerMaps,gclocals_goeq<>(SB) - MOVD alg+0(FP), R3 - MOVD alg_equal(R3), R3 - MOVD R3, CTR - MOVD p+8(FP), R4 - MOVD q+16(FP), R5 - MOVD size+24(FP), R6 - MOVD $ret+32(FP), R7 - MOVD R7, 8(R1) - MOVD R6, 16(R1) - MOVD R5, 24(R1) - MOVD R4, 32(R1) - PCDATA $PCDATA_StackMapIndex, $0 - BL (CTR) - RETURN - -DATA gcargs_goeq<>+0x00(SB)/4, $1 // 1 stackmap -DATA gcargs_goeq<>+0x04(SB)/4, $10 // 5 args -DATA gcargs_goeq<>+0x08(SB)/4, $(const_BitsPointer+(const_BitsPointer<<2)+(const_BitsPointer<<4)) -GLOBL gcargs_goeq<>(SB),RODATA,$12 - -DATA gclocals_goeq<>+0x00(SB)/4, $1 // 1 stackmap -DATA gclocals_goeq<>+0x04(SB)/4, $0 // 0 locals -GLOBL gclocals_goeq<>(SB),RODATA,$8 +// Called from cgo wrappers, this function returns g->m->curg.stack.hi. +// Must obey the gcc calling convention. +TEXT _cgo_topofstack(SB),NOSPLIT,$0 + MOVD R0, 26(R0) -- cgit v1.2.1