diff --git a/libunwind/src/UnwindRegistersRestore.S b/libunwind/src/UnwindRegistersRestore.S --- a/libunwind/src/UnwindRegistersRestore.S +++ b/libunwind/src/UnwindRegistersRestore.S @@ -134,7 +134,7 @@ // load register (GPR) #define PPC64_LR(n) \ - ld %r##n, (8 * (n + 2))(%r3) + ld GPR(n), (8 * (n + 2))(GPR(3)) // restore integral registers // skip r0 for now @@ -176,12 +176,12 @@ // (note that this also restores floating point registers and V registers, // because part of VS is mapped to these registers) - addi %r4, %r3, PPC64_OFFS_FP + addi GPR(4), GPR(3), PPC64_OFFS_FP // load VS register #define PPC64_LVS(n) \ - lxvd2x %vs##n, 0, %r4 ;\ - addi %r4, %r4, 16 + lxvd2x VSR(n), 0, GPR(4) ;\ + addi GPR(4), GPR(4), 16 // restore the first 32 VS regs (and also all floating point regs) PPC64_LVS(0) @@ -220,23 +220,23 @@ // use VRSAVE to conditionally restore the remaining VS regs, // that are where the V regs are mapped - ld %r5, PPC64_OFFS_VRSAVE(%r3) // test VRsave - cmpwi %r5, 0 + ld GPR(5), PPC64_OFFS_VRSAVE(GPR(3)) // test VRsave + cmpwi GPR(5), 0 beq Lnovec // conditionally load VS -#define PPC64_CLVS_BOTTOM(n) \ - beq Ldone##n ;\ - addi %r4, %r3, PPC64_OFFS_FP + n * 16 ;\ - lxvd2x %vs##n, 0, %r4 ;\ +#define PPC64_CLVS_BOTTOM(n) \ + beq Ldone##n ;\ + addi GPR(4), GPR(3), PPC64_OFFS_FP + n * 16 ;\ + lxvd2x VSR(n), 0, GPR(4) ;\ Ldone##n: -#define PPC64_CLVSl(n) \ - andis. %r0, %r5, (1<<(47-n)) ;\ +#define PPC64_CLVSl(n) \ + andis. GPR(0), GPR(5), (1 PPC_SHIFT(47-n)) ;\ PPC64_CLVS_BOTTOM(n) -#define PPC64_CLVSh(n) \ - andi. %r0, %r5, (1<<(63-n)) ;\ +#define PPC64_CLVSh(n) \ + andi. GPR(0), GPR(5), (1 PPC_SHIFT(63-n)) ;\ PPC64_CLVS_BOTTOM(n) PPC64_CLVSl(32) @@ -276,7 +276,7 @@ // load FP register #define PPC64_LF(n) \ - lfd %f##n, (PPC64_OFFS_FP + n * 16)(%r3) + lfd FPR(n), (PPC64_OFFS_FP + n * 16)(GPR(3)) // restore float registers PPC64_LF(0) @@ -314,30 +314,30 @@ #if defined(__ALTIVEC__) // restore vector registers if any are in use - ld %r5, PPC64_OFFS_VRSAVE(%r3) // test VRsave - cmpwi %r5, 0 + ld GPR(5), PPC64_OFFS_VRSAVE(GPR(3)) // test VRsave + cmpwi GPR(5), 0 beq Lnovec - subi %r4, %r1, 16 + subi GPR(4), GPR(1), 16 // r4 is now a 16-byte aligned pointer into the red zone // the _vectorScalarRegisters may not be 16-byte aligned // so copy via red zone temp buffer -#define PPC64_CLV_UNALIGNED_BOTTOM(n) \ - beq Ldone##n ;\ - ld %r0, (PPC64_OFFS_V + n * 16)(%r3) ;\ - std %r0, 0(%r4) ;\ - ld %r0, (PPC64_OFFS_V + n * 16 + 8)(%r3) ;\ - std %r0, 8(%r4) ;\ - lvx %v##n, 0, %r4 ;\ +#define PPC64_CLV_UNALIGNED_BOTTOM(n) \ + beq Ldone##n ;\ + ld GPR(0), (PPC64_OFFS_V + n * 16)(GPR(3)) ;\ + std GPR(0), 0(GPR(4)) ;\ + ld GPR(0), (PPC64_OFFS_V + n * 16 + 8)(GPR(3)) ;\ + std GPR(0), 8(GPR(4)) ;\ + lvx VR(n), 0, GPR(4) ;\ Ldone ## n: -#define PPC64_CLV_UNALIGNEDl(n) \ - andis. %r0, %r5, (1<<(15-n)) ;\ +#define PPC64_CLV_UNALIGNEDl(n) \ + andis. GPR(0), GPR(5), (1 PPC_SHIFT(15-n)) ;\ PPC64_CLV_UNALIGNED_BOTTOM(n) -#define PPC64_CLV_UNALIGNEDh(n) \ - andi. %r0, %r5, (1<<(31-n)) ;\ +#define PPC64_CLV_UNALIGNEDh(n) \ + andi. GPR(0), GPR(5), (1 PPC_SHIFT(31-n)) ;\ PPC64_CLV_UNALIGNED_BOTTOM(n) PPC64_CLV_UNALIGNEDl(0) @@ -377,10 +377,10 @@ #endif Lnovec: - ld %r0, PPC64_OFFS_CR(%r3) - mtcr %r0 - ld %r0, PPC64_OFFS_SRR0(%r3) - mtctr %r0 + ld GPR(0), PPC64_OFFS_CR(GPR(3)) + mtcr GPR(0) + ld GPR(0), PPC64_OFFS_SRR0(GPR(3)) + mtctr GPR(0) PPC64_LR(0) PPC64_LR(5) @@ -402,111 +402,111 @@ // restore integral registerrs // skip r0 for now // skip r1 for now - lwz %r2, 16(%r3) + lwz GPR(2), 16(GPR(3)) // skip r3 for now // skip r4 for now // skip r5 for now - lwz %r6, 32(%r3) - lwz %r7, 36(%r3) - lwz %r8, 40(%r3) - lwz %r9, 44(%r3) - lwz %r10, 48(%r3) - lwz %r11, 52(%r3) - lwz %r12, 56(%r3) - lwz %r13, 60(%r3) - lwz %r14, 64(%r3) - lwz %r15, 68(%r3) - lwz %r16, 72(%r3) - lwz %r17, 76(%r3) - lwz %r18, 80(%r3) - lwz %r19, 84(%r3) - lwz %r20, 88(%r3) - lwz %r21, 92(%r3) - lwz %r22, 96(%r3) - lwz %r23,100(%r3) - lwz %r24,104(%r3) - lwz %r25,108(%r3) - lwz %r26,112(%r3) - lwz %r27,116(%r3) - lwz %r28,120(%r3) - lwz %r29,124(%r3) - lwz %r30,128(%r3) - lwz %r31,132(%r3) + lwz GPR(6), 32(GPR(3)) + lwz GPR(7), 36(GPR(3)) + lwz GPR(8), 40(GPR(3)) + lwz GPR(9), 44(GPR(3)) + lwz GPR(10), 48(GPR(3)) + lwz GPR(11), 52(GPR(3)) + lwz GPR(12), 56(GPR(3)) + lwz GPR(13), 60(GPR(3)) + lwz GPR(14), 64(GPR(3)) + lwz GPR(15), 68(GPR(3)) + lwz GPR(16), 72(GPR(3)) + lwz GPR(17), 76(GPR(3)) + lwz GPR(18), 80(GPR(3)) + lwz GPR(19), 84(GPR(3)) + lwz GPR(20), 88(GPR(3)) + lwz GPR(21), 92(GPR(3)) + lwz GPR(22), 96(GPR(3)) + lwz GPR(23),100(GPR(3)) + lwz GPR(24),104(GPR(3)) + lwz GPR(25),108(GPR(3)) + lwz GPR(26),112(GPR(3)) + lwz GPR(27),116(GPR(3)) + lwz GPR(28),120(GPR(3)) + lwz GPR(29),124(GPR(3)) + lwz GPR(30),128(GPR(3)) + lwz GPR(31),132(GPR(3)) #ifndef __NO_FPRS__ // restore float registers - lfd %f0, 160(%r3) - lfd %f1, 168(%r3) - lfd %f2, 176(%r3) - lfd %f3, 184(%r3) - lfd %f4, 192(%r3) - lfd %f5, 200(%r3) - lfd %f6, 208(%r3) - lfd %f7, 216(%r3) - lfd %f8, 224(%r3) - lfd %f9, 232(%r3) - lfd %f10,240(%r3) - lfd %f11,248(%r3) - lfd %f12,256(%r3) - lfd %f13,264(%r3) - lfd %f14,272(%r3) - lfd %f15,280(%r3) - lfd %f16,288(%r3) - lfd %f17,296(%r3) - lfd %f18,304(%r3) - lfd %f19,312(%r3) - lfd %f20,320(%r3) - lfd %f21,328(%r3) - lfd %f22,336(%r3) - lfd %f23,344(%r3) - lfd %f24,352(%r3) - lfd %f25,360(%r3) - lfd %f26,368(%r3) - lfd %f27,376(%r3) - lfd %f28,384(%r3) - lfd %f29,392(%r3) - lfd %f30,400(%r3) - lfd %f31,408(%r3) + lfd FPR(0), 160(GPR(3)) + lfd FPR(1), 168(GPR(3)) + lfd FPR(2), 176(GPR(3)) + lfd FPR(3), 184(GPR(3)) + lfd FPR(4), 192(GPR(3)) + lfd FPR(5), 200(GPR(3)) + lfd FPR(6), 208(GPR(3)) + lfd FPR(7), 216(GPR(3)) + lfd FPR(8), 224(GPR(3)) + lfd FPR(9), 232(GPR(3)) + lfd FPR(10),240(GPR(3)) + lfd FPR(11),248(GPR(3)) + lfd FPR(12),256(GPR(3)) + lfd FPR(13),264(GPR(3)) + lfd FPR(14),272(GPR(3)) + lfd FPR(15),280(GPR(3)) + lfd FPR(16),288(GPR(3)) + lfd FPR(17),296(GPR(3)) + lfd FPR(18),304(GPR(3)) + lfd FPR(19),312(GPR(3)) + lfd FPR(20),320(GPR(3)) + lfd FPR(21),328(GPR(3)) + lfd FPR(22),336(GPR(3)) + lfd FPR(23),344(GPR(3)) + lfd FPR(24),352(GPR(3)) + lfd FPR(25),360(GPR(3)) + lfd FPR(26),368(GPR(3)) + lfd FPR(27),376(GPR(3)) + lfd FPR(28),384(GPR(3)) + lfd FPR(29),392(GPR(3)) + lfd FPR(30),400(GPR(3)) + lfd FPR(31),408(GPR(3)) #endif #if defined(__ALTIVEC__) // restore vector registers if any are in use - lwz %r5, 156(%r3) // test VRsave - cmpwi %r5, 0 + lwz GPR(5), 156(GPR(3)) // test VRsave + cmpwi GPR(5), 0 beq Lnovec - subi %r4, %r1, 16 - rlwinm %r4, %r4, 0, 0, 27 // mask low 4-bits + subi GPR(4), GPR(1), 16 + rlwinm GPR(4), GPR(4), 0, 0, 27 // mask low 4-bits // r4 is now a 16-byte aligned pointer into the red zone // the _vectorRegisters may not be 16-byte aligned so copy via red zone temp buffer - + #define LOAD_VECTOR_UNALIGNEDl(_index) \ - andis. %r0, %r5, (1<<(15-_index)) SEPARATOR \ - beq Ldone ## _index SEPARATOR \ - lwz %r0, 424+_index*16(%r3) SEPARATOR \ - stw %r0, 0(%r4) SEPARATOR \ - lwz %r0, 424+_index*16+4(%r3) SEPARATOR \ - stw %r0, 4(%r4) SEPARATOR \ - lwz %r0, 424+_index*16+8(%r3) SEPARATOR \ - stw %r0, 8(%r4) SEPARATOR \ - lwz %r0, 424+_index*16+12(%r3) SEPARATOR \ - stw %r0, 12(%r4) SEPARATOR \ - lvx %v ## _index, 0, %r4 SEPARATOR \ + andis. GPR(0), GPR(5), (1 PPC_SHIFT(15-_index)) SEPARATOR \ + beq Ldone ## _index SEPARATOR \ + lwz GPR(0), 424+_index*16(GPR(3)) SEPARATOR \ + stw GPR(0), 0(GPR(4)) SEPARATOR \ + lwz GPR(0), 424+_index*16+4(GPR(3)) SEPARATOR \ + stw GPR(0), 4(GPR(4)) SEPARATOR \ + lwz GPR(0), 424+_index*16+8(GPR(3)) SEPARATOR \ + stw GPR(0), 8(GPR(4)) SEPARATOR \ + lwz GPR(0), 424+_index*16+12(GPR(3)) SEPARATOR \ + stw GPR(0), 12(GPR(4)) SEPARATOR \ + lvx VR(_index), 0, GPR(4) SEPARATOR \ Ldone ## _index: #define LOAD_VECTOR_UNALIGNEDh(_index) \ - andi. %r0, %r5, (1<<(31-_index)) SEPARATOR \ - beq Ldone ## _index SEPARATOR \ - lwz %r0, 424+_index*16(%r3) SEPARATOR \ - stw %r0, 0(%r4) SEPARATOR \ - lwz %r0, 424+_index*16+4(%r3) SEPARATOR \ - stw %r0, 4(%r4) SEPARATOR \ - lwz %r0, 424+_index*16+8(%r3) SEPARATOR \ - stw %r0, 8(%r4) SEPARATOR \ - lwz %r0, 424+_index*16+12(%r3) SEPARATOR \ - stw %r0, 12(%r4) SEPARATOR \ - lvx %v ## _index, 0, %r4 SEPARATOR \ + andi. GPR(0), GPR(5), (1 PPC_SHIFT(31-_index)) SEPARATOR \ + beq Ldone ## _index SEPARATOR \ + lwz GPR(0), 424+_index*16(GPR(3)) SEPARATOR \ + stw GPR(0), 0(GPR(4)) SEPARATOR \ + lwz GPR(0), 424+_index*16+4(GPR(3)) SEPARATOR \ + stw GPR(0), 4(GPR(4)) SEPARATOR \ + lwz GPR(0), 424+_index*16+8(GPR(3)) SEPARATOR \ + stw GPR(0), 8(GPR(4)) SEPARATOR \ + lwz GPR(0), 424+_index*16+12(GPR(3)) SEPARATOR \ + stw GPR(0), 12(GPR(4)) SEPARATOR \ + lvx VR(_index), 0, GPR(4) SEPARATOR \ Ldone ## _index: @@ -545,17 +545,17 @@ #endif Lnovec: - lwz %r0, 136(%r3) // __cr - mtcr %r0 - lwz %r0, 148(%r3) // __ctr - mtctr %r0 - lwz %r0, 0(%r3) // __ssr0 - mtctr %r0 - lwz %r0, 8(%r3) // do r0 now - lwz %r5, 28(%r3) // do r5 now - lwz %r4, 24(%r3) // do r4 now - lwz %r1, 12(%r3) // do sp now - lwz %r3, 20(%r3) // do r3 last + lwz GPR(0), 136(GPR(3)) // __cr + mtcr GPR(0) + lwz GPR(0), 148(GPR(3)) // __ctr + mtctr GPR(0) + lwz GPR(0), 0(GPR(3)) // __ssr0 + mtctr GPR(0) + lwz GPR(0), 8(GPR(3)) // do r0 now + lwz GPR(5), 28(GPR(3)) // do r5 now + lwz GPR(4), 24(GPR(3)) // do r4 now + lwz GPR(1), 12(GPR(3)) // do sp now + lwz GPR(3), 20(GPR(3)) // do r3 last bctr #elif defined(__aarch64__) diff --git a/libunwind/src/UnwindRegistersSave.S b/libunwind/src/UnwindRegistersSave.S --- a/libunwind/src/UnwindRegistersSave.S +++ b/libunwind/src/UnwindRegistersSave.S @@ -335,12 +335,12 @@ // store register (GPR) #define PPC64_STR(n) \ - std %r##n, (8 * (n + 2))(%r3) + std GPR(n), (8 * (n + 2))(GPR(3)) // save GPRs PPC64_STR(0) - mflr %r0 - std %r0, PPC64_OFFS_SRR0(%r3) // store lr as ssr0 + mflr GPR(0) + std GPR(0), PPC64_OFFS_SRR0(GPR(3)) // store lr as ssr0 PPC64_STR(1) PPC64_STR(2) PPC64_STR(3) @@ -373,28 +373,28 @@ PPC64_STR(30) PPC64_STR(31) - mfcr %r0 - std %r0, PPC64_OFFS_CR(%r3) - mfxer %r0 - std %r0, PPC64_OFFS_XER(%r3) - mflr %r0 - std %r0, PPC64_OFFS_LR(%r3) - mfctr %r0 - std %r0, PPC64_OFFS_CTR(%r3) - mfvrsave %r0 - std %r0, PPC64_OFFS_VRSAVE(%r3) + mfcr GPR(0) + std GPR(0), PPC64_OFFS_CR(GPR(3)) + mfxer GPR(0) + std GPR(0), PPC64_OFFS_XER(GPR(3)) + mflr GPR(0) + std GPR(0), PPC64_OFFS_LR(GPR(3)) + mfctr GPR(0) + std GPR(0), PPC64_OFFS_CTR(GPR(3)) + mfvrsave GPR(0) + std GPR(0), PPC64_OFFS_VRSAVE(GPR(3)) #if defined(__VSX__) // save VS registers // (note that this also saves floating point registers and V registers, // because part of VS is mapped to these registers) - addi %r4, %r3, PPC64_OFFS_FP + addi GPR(4), GPR(3), PPC64_OFFS_FP // store VS register -#define PPC64_STVS(n) \ - stxvd2x %vs##n, 0, %r4 ;\ - addi %r4, %r4, 16 +#define PPC64_STVS(n) \ + stxvd2x VSR(n), 0, GPR(4) ;\ + addi GPR(4), GPR(4), 16 PPC64_STVS(0) PPC64_STVS(1) @@ -465,7 +465,7 @@ // store FP register #define PPC64_STF(n) \ - stfd %f##n, (PPC64_OFFS_FP + n * 16)(%r3) + stfd FPR(n), (PPC64_OFFS_FP + n * 16)(GPR(3)) // save float registers PPC64_STF(0) @@ -507,14 +507,14 @@ // Use 16-bytes below the stack pointer as an // aligned buffer to save each vector register. // Note that the stack pointer is always 16-byte aligned. - subi %r4, %r1, 16 + subi GPR(4), GPR(1), 16 -#define PPC64_STV_UNALIGNED(n) \ - stvx %v##n, 0, %r4 ;\ - ld %r5, 0(%r4) ;\ - std %r5, (PPC64_OFFS_V + n * 16)(%r3) ;\ - ld %r5, 8(%r4) ;\ - std %r5, (PPC64_OFFS_V + n * 16 + 8)(%r3) +#define PPC64_STV_UNALIGNED(n) \ + stvx VR(n), 0, GPR(4) ;\ + ld GPR(5), 0(GPR(4)) ;\ + std GPR(5), (PPC64_OFFS_V + n * 16)(GPR(3)) ;\ + ld GPR(5), 8(GPR(4)) ;\ + std GPR(5), (PPC64_OFFS_V + n * 16 + 8)(GPR(3)) PPC64_STV_UNALIGNED(0) PPC64_STV_UNALIGNED(1) @@ -552,7 +552,7 @@ #endif #endif - li %r3, 0 // return UNW_ESUCCESS + li GPR(3), 0 // return UNW_ESUCCESS blr @@ -565,140 +565,140 @@ // thread_state pointer is in r3 // DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext) - stw %r0, 8(%r3) - mflr %r0 - stw %r0, 0(%r3) // store lr as ssr0 - stw %r1, 12(%r3) - stw %r2, 16(%r3) - stw %r3, 20(%r3) - stw %r4, 24(%r3) - stw %r5, 28(%r3) - stw %r6, 32(%r3) - stw %r7, 36(%r3) - stw %r8, 40(%r3) - stw %r9, 44(%r3) - stw %r10, 48(%r3) - stw %r11, 52(%r3) - stw %r12, 56(%r3) - stw %r13, 60(%r3) - stw %r14, 64(%r3) - stw %r15, 68(%r3) - stw %r16, 72(%r3) - stw %r17, 76(%r3) - stw %r18, 80(%r3) - stw %r19, 84(%r3) - stw %r20, 88(%r3) - stw %r21, 92(%r3) - stw %r22, 96(%r3) - stw %r23,100(%r3) - stw %r24,104(%r3) - stw %r25,108(%r3) - stw %r26,112(%r3) - stw %r27,116(%r3) - stw %r28,120(%r3) - stw %r29,124(%r3) - stw %r30,128(%r3) - stw %r31,132(%r3) + stw GPR(0), 8(GPR(3)) + mflr GPR(0) + stw GPR(0), 0(GPR(3)) // store lr as ssr0 + stw GPR(1), 12(GPR(3)) + stw GPR(2), 16(GPR(3)) + stw GPR(3), 20(GPR(3)) + stw GPR(4), 24(GPR(3)) + stw GPR(5), 28(GPR(3)) + stw GPR(6), 32(GPR(3)) + stw GPR(7), 36(GPR(3)) + stw GPR(8), 40(GPR(3)) + stw GPR(9), 44(GPR(3)) + stw GPR(10), 48(GPR(3)) + stw GPR(11), 52(GPR(3)) + stw GPR(12), 56(GPR(3)) + stw GPR(13), 60(GPR(3)) + stw GPR(14), 64(GPR(3)) + stw GPR(15), 68(GPR(3)) + stw GPR(16), 72(GPR(3)) + stw GPR(17), 76(GPR(3)) + stw GPR(18), 80(GPR(3)) + stw GPR(19), 84(GPR(3)) + stw GPR(20), 88(GPR(3)) + stw GPR(21), 92(GPR(3)) + stw GPR(22), 96(GPR(3)) + stw GPR(23),100(GPR(3)) + stw GPR(24),104(GPR(3)) + stw GPR(25),108(GPR(3)) + stw GPR(26),112(GPR(3)) + stw GPR(27),116(GPR(3)) + stw GPR(28),120(GPR(3)) + stw GPR(29),124(GPR(3)) + stw GPR(30),128(GPR(3)) + stw GPR(31),132(GPR(3)) // save VRSave register - mfspr %r0, 256 - stw %r0, 156(%r3) + mfspr GPR(0), 256 + stw GPR(0), 156(GPR(3)) // save CR registers - mfcr %r0 - stw %r0, 136(%r3) + mfcr GPR(0) + stw GPR(0), 136(GPR(3)) // save CTR register - mfctr %r0 - stw %r0, 148(%r3) + mfctr GPR(0) + stw GPR(0), 148(GPR(3)) #if !defined(__NO_FPRS__) // save float registers - stfd %f0, 160(%r3) - stfd %f1, 168(%r3) - stfd %f2, 176(%r3) - stfd %f3, 184(%r3) - stfd %f4, 192(%r3) - stfd %f5, 200(%r3) - stfd %f6, 208(%r3) - stfd %f7, 216(%r3) - stfd %f8, 224(%r3) - stfd %f9, 232(%r3) - stfd %f10,240(%r3) - stfd %f11,248(%r3) - stfd %f12,256(%r3) - stfd %f13,264(%r3) - stfd %f14,272(%r3) - stfd %f15,280(%r3) - stfd %f16,288(%r3) - stfd %f17,296(%r3) - stfd %f18,304(%r3) - stfd %f19,312(%r3) - stfd %f20,320(%r3) - stfd %f21,328(%r3) - stfd %f22,336(%r3) - stfd %f23,344(%r3) - stfd %f24,352(%r3) - stfd %f25,360(%r3) - stfd %f26,368(%r3) - stfd %f27,376(%r3) - stfd %f28,384(%r3) - stfd %f29,392(%r3) - stfd %f30,400(%r3) - stfd %f31,408(%r3) + stfd FPR(0), 160(GPR(3)) + stfd FPR(1), 168(GPR(3)) + stfd FPR(2), 176(GPR(3)) + stfd FPR(3), 184(GPR(3)) + stfd FPR(4), 192(GPR(3)) + stfd FPR(5), 200(GPR(3)) + stfd FPR(6), 208(GPR(3)) + stfd FPR(7), 216(GPR(3)) + stfd FPR(8), 224(GPR(3)) + stfd FPR(9), 232(GPR(3)) + stfd FPR(10),240(GPR(3)) + stfd FPR(11),248(GPR(3)) + stfd FPR(12),256(GPR(3)) + stfd FPR(13),264(GPR(3)) + stfd FPR(14),272(GPR(3)) + stfd FPR(15),280(GPR(3)) + stfd FPR(16),288(GPR(3)) + stfd FPR(17),296(GPR(3)) + stfd FPR(18),304(GPR(3)) + stfd FPR(19),312(GPR(3)) + stfd FPR(20),320(GPR(3)) + stfd FPR(21),328(GPR(3)) + stfd FPR(22),336(GPR(3)) + stfd FPR(23),344(GPR(3)) + stfd FPR(24),352(GPR(3)) + stfd FPR(25),360(GPR(3)) + stfd FPR(26),368(GPR(3)) + stfd FPR(27),376(GPR(3)) + stfd FPR(28),384(GPR(3)) + stfd FPR(29),392(GPR(3)) + stfd FPR(30),400(GPR(3)) + stfd FPR(31),408(GPR(3)) #endif #if defined(__ALTIVEC__) // save vector registers - subi %r4, %r1, 16 - rlwinm %r4, %r4, 0, 0, 27 // mask low 4-bits + subi GPR(4), GPR(1), 16 + rlwinm GPR(4), GPR(4), 0, 0, 27 // mask low 4-bits // r4 is now a 16-byte aligned pointer into the red zone -#define SAVE_VECTOR_UNALIGNED(_vec, _offset) \ - stvx _vec, 0, %r4 SEPARATOR \ - lwz %r5, 0(%r4) SEPARATOR \ - stw %r5, _offset(%r3) SEPARATOR \ - lwz %r5, 4(%r4) SEPARATOR \ - stw %r5, _offset+4(%r3) SEPARATOR \ - lwz %r5, 8(%r4) SEPARATOR \ - stw %r5, _offset+8(%r3) SEPARATOR \ - lwz %r5, 12(%r4) SEPARATOR \ - stw %r5, _offset+12(%r3) - - SAVE_VECTOR_UNALIGNED( %v0, 424+0x000) - SAVE_VECTOR_UNALIGNED( %v1, 424+0x010) - SAVE_VECTOR_UNALIGNED( %v2, 424+0x020) - SAVE_VECTOR_UNALIGNED( %v3, 424+0x030) - SAVE_VECTOR_UNALIGNED( %v4, 424+0x040) - SAVE_VECTOR_UNALIGNED( %v5, 424+0x050) - SAVE_VECTOR_UNALIGNED( %v6, 424+0x060) - SAVE_VECTOR_UNALIGNED( %v7, 424+0x070) - SAVE_VECTOR_UNALIGNED( %v8, 424+0x080) - SAVE_VECTOR_UNALIGNED( %v9, 424+0x090) - SAVE_VECTOR_UNALIGNED(%v10, 424+0x0A0) - SAVE_VECTOR_UNALIGNED(%v11, 424+0x0B0) - SAVE_VECTOR_UNALIGNED(%v12, 424+0x0C0) - SAVE_VECTOR_UNALIGNED(%v13, 424+0x0D0) - SAVE_VECTOR_UNALIGNED(%v14, 424+0x0E0) - SAVE_VECTOR_UNALIGNED(%v15, 424+0x0F0) - SAVE_VECTOR_UNALIGNED(%v16, 424+0x100) - SAVE_VECTOR_UNALIGNED(%v17, 424+0x110) - SAVE_VECTOR_UNALIGNED(%v18, 424+0x120) - SAVE_VECTOR_UNALIGNED(%v19, 424+0x130) - SAVE_VECTOR_UNALIGNED(%v20, 424+0x140) - SAVE_VECTOR_UNALIGNED(%v21, 424+0x150) - SAVE_VECTOR_UNALIGNED(%v22, 424+0x160) - SAVE_VECTOR_UNALIGNED(%v23, 424+0x170) - SAVE_VECTOR_UNALIGNED(%v24, 424+0x180) - SAVE_VECTOR_UNALIGNED(%v25, 424+0x190) - SAVE_VECTOR_UNALIGNED(%v26, 424+0x1A0) - SAVE_VECTOR_UNALIGNED(%v27, 424+0x1B0) - SAVE_VECTOR_UNALIGNED(%v28, 424+0x1C0) - SAVE_VECTOR_UNALIGNED(%v29, 424+0x1D0) - SAVE_VECTOR_UNALIGNED(%v30, 424+0x1E0) - SAVE_VECTOR_UNALIGNED(%v31, 424+0x1F0) +#define SAVE_VECTOR_UNALIGNED(_vec, _offset) \ + stvx _vec, 0, GPR(4) SEPARATOR \ + lwz GPR(5), 0(GPR(4)) SEPARATOR \ + stw GPR(5), _offset(GPR(3)) SEPARATOR \ + lwz GPR(5), 4(GPR(4)) SEPARATOR \ + stw GPR(5), _offset+4(GPR(3)) SEPARATOR \ + lwz GPR(5), 8(GPR(4)) SEPARATOR \ + stw GPR(5), _offset+8(GPR(3)) SEPARATOR \ + lwz GPR(5), 12(GPR(4)) SEPARATOR \ + stw GPR(5), _offset+12(GPR(3)) + + SAVE_VECTOR_UNALIGNED( VR(0), 424+0x000) + SAVE_VECTOR_UNALIGNED( VR(1), 424+0x010) + SAVE_VECTOR_UNALIGNED( VR(2), 424+0x020) + SAVE_VECTOR_UNALIGNED( VR(3), 424+0x030) + SAVE_VECTOR_UNALIGNED( VR(4), 424+0x040) + SAVE_VECTOR_UNALIGNED( VR(5), 424+0x050) + SAVE_VECTOR_UNALIGNED( VR(6), 424+0x060) + SAVE_VECTOR_UNALIGNED( VR(7), 424+0x070) + SAVE_VECTOR_UNALIGNED( VR(8), 424+0x080) + SAVE_VECTOR_UNALIGNED( VR(9), 424+0x090) + SAVE_VECTOR_UNALIGNED(VR(10), 424+0x0A0) + SAVE_VECTOR_UNALIGNED(VR(11), 424+0x0B0) + SAVE_VECTOR_UNALIGNED(VR(12), 424+0x0C0) + SAVE_VECTOR_UNALIGNED(VR(13), 424+0x0D0) + SAVE_VECTOR_UNALIGNED(VR(14), 424+0x0E0) + SAVE_VECTOR_UNALIGNED(VR(15), 424+0x0F0) + SAVE_VECTOR_UNALIGNED(VR(16), 424+0x100) + SAVE_VECTOR_UNALIGNED(VR(17), 424+0x110) + SAVE_VECTOR_UNALIGNED(VR(18), 424+0x120) + SAVE_VECTOR_UNALIGNED(VR(19), 424+0x130) + SAVE_VECTOR_UNALIGNED(VR(20), 424+0x140) + SAVE_VECTOR_UNALIGNED(VR(21), 424+0x150) + SAVE_VECTOR_UNALIGNED(VR(22), 424+0x160) + SAVE_VECTOR_UNALIGNED(VR(23), 424+0x170) + SAVE_VECTOR_UNALIGNED(VR(24), 424+0x180) + SAVE_VECTOR_UNALIGNED(VR(25), 424+0x190) + SAVE_VECTOR_UNALIGNED(VR(26), 424+0x1A0) + SAVE_VECTOR_UNALIGNED(VR(27), 424+0x1B0) + SAVE_VECTOR_UNALIGNED(VR(28), 424+0x1C0) + SAVE_VECTOR_UNALIGNED(VR(29), 424+0x1D0) + SAVE_VECTOR_UNALIGNED(VR(30), 424+0x1E0) + SAVE_VECTOR_UNALIGNED(VR(31), 424+0x1F0) #endif - li %r3, 0 // return UNW_ESUCCESS + li GPR(3), 0 // return UNW_ESUCCESS blr diff --git a/libunwind/src/assembly.h b/libunwind/src/assembly.h --- a/libunwind/src/assembly.h +++ b/libunwind/src/assembly.h @@ -216,4 +216,14 @@ #endif #endif /* __arm__ */ +#if defined(__ppc__) || defined(__powerpc64__) + // clang-format off +#define GPR(num) %r##num +#define FPR(num) %f##num +#define VSR(num) %vs##num +#define VR(num) %v##num +#define PPC_SHIFT(index) <<(index) + // clang-format on +#endif + #endif /* UNWIND_ASSEMBLY_H */