Lines Matching defs:regNum
129 inline bool Registers_x86::validRegister(int regNum) const {
130 if (regNum == UNW_REG_IP)
132 if (regNum == UNW_REG_SP)
134 if (regNum < 0)
136 if (regNum > 7)
141 inline uint32_t Registers_x86::getRegister(int regNum) const {
142 switch (regNum) {
175 inline void Registers_x86::setRegister(int regNum, uint32_t value) {
176 switch (regNum) {
219 inline const char *Registers_x86::getRegisterName(int regNum) {
220 switch (regNum) {
357 inline bool Registers_x86_64::validRegister(int regNum) const {
358 if (regNum == UNW_REG_IP)
360 if (regNum == UNW_REG_SP)
362 if (regNum < 0)
364 if (regNum > 16)
369 inline uint64_t Registers_x86_64::getRegister(int regNum) const {
370 switch (regNum) {
412 inline void Registers_x86_64::setRegister(int regNum, uint64_t value) {
413 switch (regNum) {
473 inline const char *Registers_x86_64::getRegisterName(int regNum) {
474 switch (regNum) {
557 inline bool Registers_x86_64::validVectorRegister(int regNum) const {
559 if (regNum < UNW_X86_64_XMM0)
561 if (regNum > UNW_X86_64_XMM15)
565 (void)regNum; // suppress unused parameter warning
570 inline v128 Registers_x86_64::getVectorRegister(int regNum) const {
572 assert(validVectorRegister(regNum));
573 return _xmm[regNum - UNW_X86_64_XMM0];
575 (void)regNum; // suppress unused parameter warning
580 inline void Registers_x86_64::setVectorRegister(int regNum, v128 value) {
582 assert(validVectorRegister(regNum));
583 _xmm[regNum - UNW_X86_64_XMM0] = value;
585 (void)regNum; (void)value; // suppress unused parameter warnings
705 inline bool Registers_ppc::validRegister(int regNum) const {
706 if (regNum == UNW_REG_IP)
708 if (regNum == UNW_REG_SP)
710 if (regNum == UNW_PPC_VRSAVE)
712 if (regNum < 0)
714 if (regNum <= UNW_PPC_R31)
716 if (regNum == UNW_PPC_MQ)
718 if (regNum == UNW_PPC_LR)
720 if (regNum == UNW_PPC_CTR)
722 if ((UNW_PPC_CR0 <= regNum) && (regNum <= UNW_PPC_CR7))
727 inline uint32_t Registers_ppc::getRegister(int regNum) const {
728 switch (regNum) {
821 inline void Registers_ppc::setRegister(int regNum, uint32_t value) {
822 //fprintf(stderr, "Registers_ppc::setRegister(%d, 0x%08X)\n", regNum, value);
823 switch (regNum) {
984 inline bool Registers_ppc::validFloatRegister(int regNum) const {
985 if (regNum < UNW_PPC_F0)
987 if (regNum > UNW_PPC_F31)
992 inline double Registers_ppc::getFloatRegister(int regNum) const {
993 assert(validFloatRegister(regNum));
994 return _floatRegisters.__fpregs[regNum - UNW_PPC_F0];
997 inline void Registers_ppc::setFloatRegister(int regNum, double value) {
998 assert(validFloatRegister(regNum));
999 _floatRegisters.__fpregs[regNum - UNW_PPC_F0] = value;
1002 inline bool Registers_ppc::validVectorRegister(int regNum) const {
1003 if (regNum < UNW_PPC_V0)
1005 if (regNum > UNW_PPC_V31)
1010 inline v128 Registers_ppc::getVectorRegister(int regNum) const {
1011 assert(validVectorRegister(regNum));
1012 v128 result = _vectorRegisters[regNum - UNW_PPC_V0];
1016 inline void Registers_ppc::setVectorRegister(int regNum, v128 value) {
1017 assert(validVectorRegister(regNum));
1018 _vectorRegisters[regNum - UNW_PPC_V0] = value;
1021 inline const char *Registers_ppc::getRegisterName(int regNum) {
1022 switch (regNum) {
1274 inline bool Registers_ppc64::validRegister(int regNum) const {
1275 switch (regNum) {
1285 if (regNum >= UNW_PPC64_R0 && regNum <= UNW_PPC64_R31)
1287 if (regNum >= UNW_PPC64_CR0 && regNum <= UNW_PPC64_CR7)
1293 inline uint64_t Registers_ppc64::getRegister(int regNum) const {
1294 switch (regNum) {
1390 inline void Registers_ppc64::setRegister(int regNum, uint64_t value) {
1391 switch (regNum) {
1540 inline bool Registers_ppc64::validFloatRegister(int regNum) const {
1541 return regNum >= UNW_PPC64_F0 && regNum <= UNW_PPC64_F31;
1544 inline double Registers_ppc64::getFloatRegister(int regNum) const {
1545 assert(validFloatRegister(regNum));
1546 return _vectorScalarRegisters[regNum - UNW_PPC64_F0].asfloat.f;
1549 inline void Registers_ppc64::setFloatRegister(int regNum, double value) {
1550 assert(validFloatRegister(regNum));
1551 _vectorScalarRegisters[regNum - UNW_PPC64_F0].asfloat.f = value;
1554 inline bool Registers_ppc64::validVectorRegister(int regNum) const {
1556 if (regNum >= UNW_PPC64_VS0 && regNum <= UNW_PPC64_VS31)
1558 if (regNum >= UNW_PPC64_VS32 && regNum <= UNW_PPC64_VS63)
1561 if (regNum >= UNW_PPC64_V0 && regNum <= UNW_PPC64_V31)
1575 inline v128 Registers_ppc64::getVectorRegister(int regNum) const {
1576 assert(validVectorRegister(regNum));
1577 return _vectorScalarRegisters[getVectorRegNum(regNum)].v;
1580 inline void Registers_ppc64::setVectorRegister(int regNum, v128 value) {
1581 assert(validVectorRegister(regNum));
1582 _vectorScalarRegisters[getVectorRegNum(regNum)].v = value;
1585 inline const char *Registers_ppc64::getRegisterName(int regNum) {
1586 switch (regNum) {
1887 inline bool Registers_arm64::validRegister(int regNum) const {
1888 if (regNum == UNW_REG_IP)
1890 if (regNum == UNW_REG_SP)
1892 if (regNum < 0)
1894 if (regNum > 95)
1896 if (regNum == UNW_AARCH64_RA_SIGN_STATE)
1898 if ((regNum > 32) && (regNum < 64))
1903 inline uint64_t Registers_arm64::getRegister(int regNum) const {
1904 if (regNum == UNW_REG_IP || regNum == UNW_AARCH64_PC)
1906 if (regNum == UNW_REG_SP || regNum == UNW_AARCH64_SP)
1908 if (regNum == UNW_AARCH64_RA_SIGN_STATE)
1910 if (regNum == UNW_AARCH64_FP)
1912 if (regNum == UNW_AARCH64_LR)
1914 if ((regNum >= 0) && (regNum < 29))
1915 return _registers.__x[regNum];
1919 inline void Registers_arm64::setRegister(int regNum, uint64_t value) {
1920 if (regNum == UNW_REG_IP || regNum == UNW_AARCH64_PC)
1922 else if (regNum == UNW_REG_SP || regNum == UNW_AARCH64_SP)
1924 else if (regNum == UNW_AARCH64_RA_SIGN_STATE)
1926 else if (regNum == UNW_AARCH64_FP)
1928 else if (regNum == UNW_AARCH64_LR)
1930 else if ((regNum >= 0) && (regNum < 29))
1931 _registers.__x[regNum] = value;
1936 inline const char *Registers_arm64::getRegisterName(int regNum) {
1937 switch (regNum) {
2077 inline bool Registers_arm64::validFloatRegister(int regNum) const {
2078 if (regNum < UNW_AARCH64_V0)
2080 if (regNum > UNW_AARCH64_V31)
2085 inline double Registers_arm64::getFloatRegister(int regNum) const {
2086 assert(validFloatRegister(regNum));
2087 return _vectorHalfRegisters[regNum - UNW_AARCH64_V0];
2090 inline void Registers_arm64::setFloatRegister(int regNum, double value) {
2091 assert(validFloatRegister(regNum));
2092 _vectorHalfRegisters[regNum - UNW_AARCH64_V0] = value;
2258 inline bool Registers_arm::validRegister(int regNum) const {
2261 if (regNum == UNW_REG_IP)
2264 if (regNum == UNW_REG_SP)
2267 if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R15)
2271 if (regNum >= UNW_ARM_WC0 && regNum <= UNW_ARM_WC3)
2276 if (regNum == UNW_ARM_RA_AUTH_CODE)
2283 inline uint32_t Registers_arm::getRegister(int regNum) const {
2284 if (regNum == UNW_REG_SP || regNum == UNW_ARM_SP)
2287 if (regNum == UNW_ARM_LR)
2290 if (regNum == UNW_REG_IP || regNum == UNW_ARM_IP)
2293 if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R12)
2294 return _registers.__r[regNum];
2297 if (regNum >= UNW_ARM_WC0 && regNum <= UNW_ARM_WC3) {
2302 return _iwmmx_control[regNum - UNW_ARM_WC0];
2307 if (regNum == UNW_ARM_RA_AUTH_CODE)
2314 inline void Registers_arm::setRegister(int regNum, uint32_t value) {
2315 if (regNum == UNW_REG_SP || regNum == UNW_ARM_SP) {
2320 if (regNum == UNW_ARM_LR) {
2325 if (regNum == UNW_REG_IP || regNum == UNW_ARM_IP) {
2330 if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R12) {
2331 _registers.__r[regNum] = value;
2336 if (regNum >= UNW_ARM_WC0 && regNum <= UNW_ARM_WC3) {
2341 _iwmmx_control[regNum - UNW_ARM_WC0] = value;
2346 if (regNum == UNW_ARM_RA_AUTH_CODE) {
2354 inline const char *Registers_arm::getRegisterName(int regNum) {
2355 switch (regNum) {
2523 inline bool Registers_arm::validFloatRegister(int regNum) const {
2526 return ((regNum >= UNW_ARM_D0) && (regNum <= UNW_ARM_D31))
2528 || ((regNum >= UNW_ARM_WR0) && (regNum <= UNW_ARM_WR15))
2533 inline unw_fpreg_t Registers_arm::getFloatRegister(int regNum) {
2534 if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D15) {
2542 return _vfp_d0_d15_pad[regNum - UNW_ARM_D0];
2545 if (regNum >= UNW_ARM_D16 && regNum <= UNW_ARM_D31) {
2550 return _vfp_d16_d31[regNum - UNW_ARM_D16];
2554 if (regNum >= UNW_ARM_WR0 && regNum <= UNW_ARM_WR15) {
2559 return _iwmmx[regNum - UNW_ARM_WR0];
2566 inline void Registers_arm::setFloatRegister(int regNum, unw_fpreg_t value) {
2567 if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D15) {
2575 _vfp_d0_d15_pad[regNum - UNW_ARM_D0] = value;
2579 if (regNum >= UNW_ARM_D16 && regNum <= UNW_ARM_D31) {
2584 _vfp_d16_d31[regNum - UNW_ARM_D16] = value;
2589 if (regNum >= UNW_ARM_WR0 && regNum <= UNW_ARM_WR15) {
2594 _iwmmx[regNum - UNW_ARM_WR0] = value;
2666 inline bool Registers_or1k::validRegister(int regNum) const {
2667 if (regNum == UNW_REG_IP)
2669 if (regNum == UNW_REG_SP)
2671 if (regNum < 0)
2673 if (regNum <= UNW_OR1K_R31)
2675 if (regNum == UNW_OR1K_EPCR)
2680 inline uint32_t Registers_or1k::getRegister(int regNum) const {
2681 if (regNum >= UNW_OR1K_R0 && regNum <= UNW_OR1K_R31)
2682 return _registers.__r[regNum - UNW_OR1K_R0];
2684 switch (regNum) {
2695 inline void Registers_or1k::setRegister(int regNum, uint32_t value) {
2696 if (regNum >= UNW_OR1K_R0 && regNum <= UNW_OR1K_R31) {
2697 _registers.__r[regNum - UNW_OR1K_R0] = value;
2701 switch (regNum) {
2715 inline bool Registers_or1k::validFloatRegister(int /* regNum */) const {
2719 inline double Registers_or1k::getFloatRegister(int /* regNum */) const {
2723 inline void Registers_or1k::setFloatRegister(int /* regNum */,
2728 inline bool Registers_or1k::validVectorRegister(int /* regNum */) const {
2732 inline v128 Registers_or1k::getVectorRegister(int /* regNum */) const {
2736 inline void Registers_or1k::setVectorRegister(int /* regNum */, v128 /* value */) {
2740 inline const char *Registers_or1k::getRegisterName(int regNum) {
2741 switch (regNum) {
2874 inline bool Registers_mips_o32::validRegister(int regNum) const {
2875 if (regNum == UNW_REG_IP)
2877 if (regNum == UNW_REG_SP)
2879 if (regNum < 0)
2881 if (regNum <= UNW_MIPS_R31)
2884 if (regNum == UNW_MIPS_HI)
2886 if (regNum == UNW_MIPS_LO)
2890 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31)
2897 inline uint32_t Registers_mips_o32::getRegister(int regNum) const {
2898 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31)
2899 return _registers.__r[regNum - UNW_MIPS_R0];
2901 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31) {
2904 if (regNum % 2 == 0)
2905 p = (uint32_t *)&_floats[regNum - UNW_MIPS_F0];
2907 p = (uint32_t *)&_floats[(regNum - 1) - UNW_MIPS_F0] + 1;
2912 switch (regNum) {
2927 inline void Registers_mips_o32::setRegister(int regNum, uint32_t value) {
2928 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31) {
2929 _registers.__r[regNum - UNW_MIPS_R0] = value;
2933 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31) {
2936 if (regNum % 2 == 0)
2937 p = (uint32_t *)&_floats[regNum - UNW_MIPS_F0];
2939 p = (uint32_t *)&_floats[(regNum - 1) - UNW_MIPS_F0] + 1;
2945 switch (regNum) {
2964 inline bool Registers_mips_o32::validFloatRegister(int regNum) const {
2966 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31)
2969 (void)regNum;
2974 inline double Registers_mips_o32::getFloatRegister(int regNum) const {
2976 assert(validFloatRegister(regNum));
2977 return _floats[regNum - UNW_MIPS_F0];
2979 (void)regNum;
2984 inline void Registers_mips_o32::setFloatRegister(int regNum,
2987 assert(validFloatRegister(regNum));
2988 _floats[regNum - UNW_MIPS_F0] = value;
2990 (void)regNum;
2996 inline bool Registers_mips_o32::validVectorRegister(int /* regNum */) const {
3000 inline v128 Registers_mips_o32::getVectorRegister(int /* regNum */) const {
3004 inline void Registers_mips_o32::setVectorRegister(int /* regNum */, v128 /* value */) {
3008 inline const char *Registers_mips_o32::getRegisterName(int regNum) {
3009 switch (regNum) {
3204 inline bool Registers_mips_newabi::validRegister(int regNum) const {
3205 if (regNum == UNW_REG_IP)
3207 if (regNum == UNW_REG_SP)
3209 if (regNum < 0)
3211 if (regNum <= UNW_MIPS_R31)
3214 if (regNum == UNW_MIPS_HI)
3216 if (regNum == UNW_MIPS_LO)
3223 inline uint64_t Registers_mips_newabi::getRegister(int regNum) const {
3224 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31)
3225 return _registers.__r[regNum - UNW_MIPS_R0];
3227 switch (regNum) {
3242 inline void Registers_mips_newabi::setRegister(int regNum, uint64_t value) {
3243 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31) {
3244 _registers.__r[regNum - UNW_MIPS_R0] = value;
3248 switch (regNum) {
3267 inline bool Registers_mips_newabi::validFloatRegister(int regNum) const {
3269 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31)
3272 (void)regNum;
3277 inline double Registers_mips_newabi::getFloatRegister(int regNum) const {
3279 assert(validFloatRegister(regNum));
3280 return _floats[regNum - UNW_MIPS_F0];
3282 (void)regNum;
3287 inline void Registers_mips_newabi::setFloatRegister(int regNum,
3290 assert(validFloatRegister(regNum));
3291 _floats[regNum - UNW_MIPS_F0] = value;
3293 (void)regNum;
3299 inline bool Registers_mips_newabi::validVectorRegister(int /* regNum */) const {
3303 inline v128 Registers_mips_newabi::getVectorRegister(int /* regNum */) const {
3307 inline void Registers_mips_newabi::setVectorRegister(int /* regNum */, v128 /* value */) {
3311 inline const char *Registers_mips_newabi::getRegisterName(int regNum) {
3312 switch (regNum) {
3501 inline bool Registers_sparc::validRegister(int regNum) const {
3502 if (regNum == UNW_REG_IP)
3504 if (regNum == UNW_REG_SP)
3506 if (regNum < 0)
3508 if (regNum <= UNW_SPARC_I7)
3513 inline uint32_t Registers_sparc::getRegister(int regNum) const {
3514 if ((UNW_SPARC_G0 <= regNum) && (regNum <= UNW_SPARC_I7)) {
3515 return _registers.__regs[regNum];
3518 switch (regNum) {
3527 inline void Registers_sparc::setRegister(int regNum, uint32_t value) {
3528 if ((UNW_SPARC_G0 <= regNum) && (regNum <= UNW_SPARC_I7)) {
3529 _registers.__regs[regNum] = value;
3533 switch (regNum) {
3564 inline const char *Registers_sparc::getRegisterName(int regNum) {
3565 switch (regNum) {
3687 inline bool Registers_sparc64::validRegister(int regNum) const {
3688 if (regNum == UNW_REG_IP)
3690 if (regNum == UNW_REG_SP)
3692 if (regNum < 0)
3694 if (regNum <= UNW_SPARC_I7)
3699 inline uint64_t Registers_sparc64::getRegister(int regNum) const {
3700 if (regNum >= UNW_SPARC_G0 && regNum <= UNW_SPARC_I7)
3701 return _registers.__regs[regNum];
3703 switch (regNum) {
3712 inline void Registers_sparc64::setRegister(int regNum, uint64_t value) {
3713 if (regNum >= UNW_SPARC_G0 && regNum <= UNW_SPARC_I7) {
3714 _registers.__regs[regNum] = value;
3718 switch (regNum) {
3749 inline const char *Registers_sparc64::getRegisterName(int regNum) {
3750 switch (regNum) {
3872 inline bool Registers_hexagon::validRegister(int regNum) const {
3873 if (regNum <= UNW_HEXAGON_R31)
3878 inline uint32_t Registers_hexagon::getRegister(int regNum) const {
3879 if (regNum >= UNW_HEXAGON_R0 && regNum <= UNW_HEXAGON_R31)
3880 return _registers.__r[regNum - UNW_HEXAGON_R0];
3882 switch (regNum) {
3891 inline void Registers_hexagon::setRegister(int regNum, uint32_t value) {
3892 if (regNum >= UNW_HEXAGON_R0 && regNum <= UNW_HEXAGON_R31) {
3893 _registers.__r[regNum - UNW_HEXAGON_R0] = value;
3897 switch (regNum) {
3908 inline bool Registers_hexagon::validFloatRegister(int /* regNum */) const {
3912 inline double Registers_hexagon::getFloatRegister(int /* regNum */) const {
3916 inline void Registers_hexagon::setFloatRegister(int /* regNum */,
3921 inline bool Registers_hexagon::validVectorRegister(int /* regNum */) const {
3925 inline v128 Registers_hexagon::getVectorRegister(int /* regNum */) const {
3929 inline void Registers_hexagon::setVectorRegister(int /* regNum */, v128 /* value */) {
3933 inline const char *Registers_hexagon::getRegisterName(int regNum) {
3934 switch (regNum) {
4104 inline bool Registers_riscv::validRegister(int regNum) const {
4105 if (regNum == UNW_REG_IP)
4107 if (regNum == UNW_REG_SP)
4109 if (regNum < 0)
4111 if (regNum == UNW_RISCV_VLENB)
4113 if (regNum > UNW_RISCV_F31)
4118 inline reg_t Registers_riscv::getRegister(int regNum) const {
4119 if (regNum == UNW_REG_IP)
4121 if (regNum == UNW_REG_SP)
4123 if (regNum == UNW_RISCV_X0)
4125 if ((regNum > 0) && (regNum < 32))
4126 return _registers[regNum];
4127 if (regNum == UNW_RISCV_VLENB) {
4135 inline void Registers_riscv::setRegister(int regNum, reg_t value) {
4136 if (regNum == UNW_REG_IP)
4138 else if (regNum == UNW_REG_SP)
4140 else if (regNum == UNW_RISCV_X0)
4143 else if ((regNum > 0) && (regNum < 32))
4144 _registers[regNum] = value;
4149 inline const char *Registers_riscv::getRegisterName(int regNum) {
4150 switch (regNum) {
4290 inline bool Registers_riscv::validFloatRegister(int regNum) const {
4292 if (regNum < UNW_RISCV_F0)
4294 if (regNum > UNW_RISCV_F31)
4298 (void)regNum;
4303 inline fp_t Registers_riscv::getFloatRegister(int regNum) const {
4305 assert(validFloatRegister(regNum));
4306 return _floats[regNum - UNW_RISCV_F0];
4308 (void)regNum;
4313 inline void Registers_riscv::setFloatRegister(int regNum, fp_t value) {
4315 assert(validFloatRegister(regNum));
4316 _floats[regNum - UNW_RISCV_F0] = value;
4318 (void)regNum;
4395 inline bool Registers_ve::validRegister(int regNum) const {
4396 if (regNum >= UNW_VE_S0 && regNum <= UNW_VE_S63)
4399 switch (regNum) {
4410 inline uint64_t Registers_ve::getRegister(int regNum) const {
4411 if (regNum >= UNW_VE_S0 && regNum <= UNW_VE_S63)
4412 return _registers.__s[regNum - UNW_VE_S0];
4414 switch (regNum) {
4427 inline void Registers_ve::setRegister(int regNum, uint64_t value) {
4428 if (regNum >= UNW_VE_S0 && regNum <= UNW_VE_S63) {
4429 _registers.__s[regNum - UNW_VE_S0] = value;
4433 switch (regNum) {
4450 inline bool Registers_ve::validFloatRegister(int /* regNum */) const {
4454 inline double Registers_ve::getFloatRegister(int /* regNum */) const {
4458 inline void Registers_ve::setFloatRegister(int /* regNum */,
4463 inline bool Registers_ve::validVectorRegister(int /* regNum */) const {
4467 inline v128 Registers_ve::getVectorRegister(int /* regNum */) const {
4471 inline void Registers_ve::setVectorRegister(int /* regNum */,
4476 inline const char *Registers_ve::getRegisterName(int regNum) {
4477 switch (regNum) {
4830 inline bool Registers_s390x::validRegister(int regNum) const {
4831 switch (regNum) {
4839 if (regNum >= UNW_S390X_R0 && regNum <= UNW_S390X_R15)
4845 inline uint64_t Registers_s390x::getRegister(int regNum) const {
4846 if (regNum >= UNW_S390X_R0 && regNum <= UNW_S390X_R15)
4847 return _registers.__gpr[regNum - UNW_S390X_R0];
4849 switch (regNum) {
4861 inline void Registers_s390x::setRegister(int regNum, uint64_t value) {
4862 if (regNum >= UNW_S390X_R0 && regNum <= UNW_S390X_R15) {
4863 _registers.__gpr[regNum - UNW_S390X_R0] = value;
4867 switch (regNum) {
4882 inline bool Registers_s390x::validFloatRegister(int regNum) const {
4883 return regNum >= UNW_S390X_F0 && regNum <= UNW_S390X_F15;
4886 inline double Registers_s390x::getFloatRegister(int regNum) const {
4888 switch (regNum) {
4925 inline void Registers_s390x::setFloatRegister(int regNum, double value) {
4927 switch (regNum) {
4980 inline bool Registers_s390x::validVectorRegister(int /*regNum*/) const {
4984 inline v128 Registers_s390x::getVectorRegister(int /*regNum*/) const {
4988 inline void Registers_s390x::setVectorRegister(int /*regNum*/, v128 /*value*/) {
4992 inline const char *Registers_s390x::getRegisterName(int regNum) {
4993 switch (regNum) {
5127 inline bool Registers_loongarch::validRegister(int regNum) const {
5128 if (regNum == UNW_REG_IP || regNum == UNW_REG_SP)
5130 if (regNum < 0 || regNum > UNW_LOONGARCH_F31)
5135 inline uint64_t Registers_loongarch::getRegister(int regNum) const {
5136 if (regNum >= UNW_LOONGARCH_R0 && regNum <= UNW_LOONGARCH_R31)
5137 return _registers.__r[regNum - UNW_LOONGARCH_R0];
5139 if (regNum == UNW_REG_IP)
5141 if (regNum == UNW_REG_SP)
5146 inline void Registers_loongarch::setRegister(int regNum, uint64_t value) {
5147 if (regNum >= UNW_LOONGARCH_R0 && regNum <= UNW_LOONGARCH_R31)
5148 _registers.__r[regNum - UNW_LOONGARCH_R0] = value;
5149 else if (regNum == UNW_REG_IP)
5151 else if (regNum == UNW_REG_SP)
5157 inline const char *Registers_loongarch::getRegisterName(int regNum) {
5158 switch (regNum) {
5296 inline bool Registers_loongarch::validFloatRegister(int regNum) const {
5297 if (regNum < UNW_LOONGARCH_F0 || regNum > UNW_LOONGARCH_F31)
5302 inline double Registers_loongarch::getFloatRegister(int regNum) const {
5304 assert(validFloatRegister(regNum));
5305 return _floats[regNum - UNW_LOONGARCH_F0];
5311 inline void Registers_loongarch::setFloatRegister(int regNum, double value) {
5313 assert(validFloatRegister(regNum));
5314 _floats[regNum - UNW_LOONGARCH_F0] = value;