1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//
8// Models register sets for supported processors.
9//
10//===----------------------------------------------------------------------===//
11
12#ifndef __REGISTERS_HPP__
13#define __REGISTERS_HPP__
14
15#include <stddef.h>
16#include <stdint.h>
17#include <string.h>
18
19#include "config.h"
20#include "libunwind.h"
21#include "libunwind_ext.h"
22#include "shadow_stack_unwind.h"
23
24#if defined(__APPLE__)
25#include <sys/sysctl.h>
26#endif
27#if defined(_LIBUNWIND_HAVE_GETAUXVAL) || defined(_LIBUNWIND_HAVE_ELF_AUX_INFO)
28#include <sys/auxv.h>
29#endif
30
31namespace libunwind {
32
33// For emulating 128-bit registers
34struct v128 { uint32_t vec[4]; };
35
36enum {
37 REGISTERS_X86,
38 REGISTERS_X86_64,
39 REGISTERS_PPC,
40 REGISTERS_PPC64,
41 REGISTERS_ARM64,
42 REGISTERS_ARM,
43 REGISTERS_OR1K,
44 REGISTERS_MIPS_O32,
45 REGISTERS_MIPS_NEWABI,
46 REGISTERS_SPARC,
47 REGISTERS_SPARC64,
48 REGISTERS_HEXAGON,
49 REGISTERS_RISCV,
50 REGISTERS_VE,
51 REGISTERS_S390X,
52 REGISTERS_LOONGARCH,
53};
54
55#if defined(_LIBUNWIND_TARGET_I386)
56class _LIBUNWIND_HIDDEN Registers_x86;
57extern "C" void __libunwind_Registers_x86_jumpto(Registers_x86 *);
58
59#if defined(_LIBUNWIND_USE_CET)
60extern "C" void *__libunwind_shstk_get_jump_target() {
61 return reinterpret_cast<void *>(&__libunwind_Registers_x86_jumpto);
62}
63#endif
64
65/// Registers_x86 holds the register state of a thread in a 32-bit intel
66/// process.
67class _LIBUNWIND_HIDDEN Registers_x86 {
68public:
69 Registers_x86();
70 Registers_x86(const void *registers);
71
72 typedef uint32_t reg_t;
73 typedef uint32_t link_reg_t;
74 typedef const link_reg_t &link_hardened_reg_arg_t;
75
76 bool validRegister(int num) const;
77 uint32_t getRegister(int num) const;
78 void setRegister(int num, uint32_t value);
79 bool validFloatRegister(int) const { return false; }
80 double getFloatRegister(int num) const;
81 void setFloatRegister(int num, double value);
82 bool validVectorRegister(int) const { return false; }
83 v128 getVectorRegister(int num) const;
84 void setVectorRegister(int num, v128 value);
85 static const char *getRegisterName(int num);
86 void jumpto() { __libunwind_Registers_x86_jumpto(this); }
87 static constexpr int lastDwarfRegNum() {
88 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_X86;
89 }
90 static int getArch() { return REGISTERS_X86; }
91
92 uint32_t getSP() const { return _registers.__esp; }
93 void setSP(uint32_t value) { _registers.__esp = value; }
94 uint32_t getIP() const { return _registers.__eip; }
95 void setIP(uint32_t value) { _registers.__eip = value; }
96 uint32_t getEBP() const { return _registers.__ebp; }
97 void setEBP(uint32_t value) { _registers.__ebp = value; }
98 uint32_t getEBX() const { return _registers.__ebx; }
99 void setEBX(uint32_t value) { _registers.__ebx = value; }
100 uint32_t getECX() const { return _registers.__ecx; }
101 void setECX(uint32_t value) { _registers.__ecx = value; }
102 uint32_t getEDX() const { return _registers.__edx; }
103 void setEDX(uint32_t value) { _registers.__edx = value; }
104 uint32_t getESI() const { return _registers.__esi; }
105 void setESI(uint32_t value) { _registers.__esi = value; }
106 uint32_t getEDI() const { return _registers.__edi; }
107 void setEDI(uint32_t value) { _registers.__edi = value; }
108
109private:
110 struct GPRs {
111 unsigned int __eax;
112 unsigned int __ebx;
113 unsigned int __ecx;
114 unsigned int __edx;
115 unsigned int __edi;
116 unsigned int __esi;
117 unsigned int __ebp;
118 unsigned int __esp;
119 unsigned int __ss;
120 unsigned int __eflags;
121 unsigned int __eip;
122 unsigned int __cs;
123 unsigned int __ds;
124 unsigned int __es;
125 unsigned int __fs;
126 unsigned int __gs;
127 };
128
129 GPRs _registers;
130};
131
132inline Registers_x86::Registers_x86(const void *registers) {
133 static_assert((check_fit<Registers_x86, unw_context_t>::does_fit),
134 "x86 registers do not fit into unw_context_t");
135 memcpy(&_registers, registers, sizeof(_registers));
136}
137
138inline Registers_x86::Registers_x86() {
139 memset(&_registers, 0, sizeof(_registers));
140}
141
142inline bool Registers_x86::validRegister(int regNum) const {
143 if (regNum == UNW_REG_IP)
144 return true;
145 if (regNum == UNW_REG_SP)
146 return true;
147 if (regNum < 0)
148 return false;
149 if (regNum > 7)
150 return false;
151 return true;
152}
153
154inline uint32_t Registers_x86::getRegister(int regNum) const {
155 switch (regNum) {
156 case UNW_REG_IP:
157 return _registers.__eip;
158 case UNW_REG_SP:
159 return _registers.__esp;
160 case UNW_X86_EAX:
161 return _registers.__eax;
162 case UNW_X86_ECX:
163 return _registers.__ecx;
164 case UNW_X86_EDX:
165 return _registers.__edx;
166 case UNW_X86_EBX:
167 return _registers.__ebx;
168#if !defined(__APPLE__)
169 case UNW_X86_ESP:
170#else
171 case UNW_X86_EBP:
172#endif
173 return _registers.__ebp;
174#if !defined(__APPLE__)
175 case UNW_X86_EBP:
176#else
177 case UNW_X86_ESP:
178#endif
179 return _registers.__esp;
180 case UNW_X86_ESI:
181 return _registers.__esi;
182 case UNW_X86_EDI:
183 return _registers.__edi;
184 }
185 _LIBUNWIND_ABORT("unsupported x86 register");
186}
187
188inline void Registers_x86::setRegister(int regNum, uint32_t value) {
189 switch (regNum) {
190 case UNW_REG_IP:
191 _registers.__eip = value;
192 return;
193 case UNW_REG_SP:
194 _registers.__esp = value;
195 return;
196 case UNW_X86_EAX:
197 _registers.__eax = value;
198 return;
199 case UNW_X86_ECX:
200 _registers.__ecx = value;
201 return;
202 case UNW_X86_EDX:
203 _registers.__edx = value;
204 return;
205 case UNW_X86_EBX:
206 _registers.__ebx = value;
207 return;
208#if !defined(__APPLE__)
209 case UNW_X86_ESP:
210#else
211 case UNW_X86_EBP:
212#endif
213 _registers.__ebp = value;
214 return;
215#if !defined(__APPLE__)
216 case UNW_X86_EBP:
217#else
218 case UNW_X86_ESP:
219#endif
220 _registers.__esp = value;
221 return;
222 case UNW_X86_ESI:
223 _registers.__esi = value;
224 return;
225 case UNW_X86_EDI:
226 _registers.__edi = value;
227 return;
228 }
229 _LIBUNWIND_ABORT("unsupported x86 register");
230}
231
232inline const char *Registers_x86::getRegisterName(int regNum) {
233 switch (regNum) {
234 case UNW_REG_IP:
235 return "ip";
236 case UNW_REG_SP:
237 return "esp";
238 case UNW_X86_EAX:
239 return "eax";
240 case UNW_X86_ECX:
241 return "ecx";
242 case UNW_X86_EDX:
243 return "edx";
244 case UNW_X86_EBX:
245 return "ebx";
246 case UNW_X86_EBP:
247 return "ebp";
248 case UNW_X86_ESP:
249 return "esp";
250 case UNW_X86_ESI:
251 return "esi";
252 case UNW_X86_EDI:
253 return "edi";
254 default:
255 return "unknown register";
256 }
257}
258
259inline double Registers_x86::getFloatRegister(int) const {
260 _LIBUNWIND_ABORT("no x86 float registers");
261}
262
263inline void Registers_x86::setFloatRegister(int, double) {
264 _LIBUNWIND_ABORT("no x86 float registers");
265}
266
267inline v128 Registers_x86::getVectorRegister(int) const {
268 _LIBUNWIND_ABORT("no x86 vector registers");
269}
270
271inline void Registers_x86::setVectorRegister(int, v128) {
272 _LIBUNWIND_ABORT("no x86 vector registers");
273}
274#endif // _LIBUNWIND_TARGET_I386
275
276
277#if defined(_LIBUNWIND_TARGET_X86_64)
278/// Registers_x86_64 holds the register state of a thread in a 64-bit intel
279/// process.
280class _LIBUNWIND_HIDDEN Registers_x86_64;
281extern "C" void __libunwind_Registers_x86_64_jumpto(Registers_x86_64 *);
282
283#if defined(_LIBUNWIND_USE_CET)
284extern "C" void *__libunwind_shstk_get_jump_target() {
285 return reinterpret_cast<void *>(&__libunwind_Registers_x86_64_jumpto);
286}
287#endif
288
289class _LIBUNWIND_HIDDEN Registers_x86_64 {
290public:
291 Registers_x86_64();
292 Registers_x86_64(const void *registers);
293
294 typedef uint64_t reg_t;
295 typedef uint64_t link_reg_t;
296 typedef const link_reg_t &link_hardened_reg_arg_t;
297
298 bool validRegister(int num) const;
299 uint64_t getRegister(int num) const;
300 void setRegister(int num, uint64_t value);
301 bool validFloatRegister(int) const { return false; }
302 double getFloatRegister(int num) const;
303 void setFloatRegister(int num, double value);
304 bool validVectorRegister(int) const;
305 v128 getVectorRegister(int num) const;
306 void setVectorRegister(int num, v128 value);
307 static const char *getRegisterName(int num);
308 void jumpto() { __libunwind_Registers_x86_64_jumpto(this); }
309 static constexpr int lastDwarfRegNum() {
310 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_X86_64;
311 }
312 static int getArch() { return REGISTERS_X86_64; }
313
314 uint64_t getSP() const { return _registers.__rsp; }
315 void setSP(uint64_t value) { _registers.__rsp = value; }
316 uint64_t getIP() const { return _registers.__rip; }
317 void setIP(uint64_t value) { _registers.__rip = value; }
318 uint64_t getRBP() const { return _registers.__rbp; }
319 void setRBP(uint64_t value) { _registers.__rbp = value; }
320 uint64_t getRBX() const { return _registers.__rbx; }
321 void setRBX(uint64_t value) { _registers.__rbx = value; }
322 uint64_t getR12() const { return _registers.__r12; }
323 void setR12(uint64_t value) { _registers.__r12 = value; }
324 uint64_t getR13() const { return _registers.__r13; }
325 void setR13(uint64_t value) { _registers.__r13 = value; }
326 uint64_t getR14() const { return _registers.__r14; }
327 void setR14(uint64_t value) { _registers.__r14 = value; }
328 uint64_t getR15() const { return _registers.__r15; }
329 void setR15(uint64_t value) { _registers.__r15 = value; }
330
331private:
332 struct GPRs {
333 uint64_t __rax;
334 uint64_t __rbx;
335 uint64_t __rcx;
336 uint64_t __rdx;
337 uint64_t __rdi;
338 uint64_t __rsi;
339 uint64_t __rbp;
340 uint64_t __rsp;
341 uint64_t __r8;
342 uint64_t __r9;
343 uint64_t __r10;
344 uint64_t __r11;
345 uint64_t __r12;
346 uint64_t __r13;
347 uint64_t __r14;
348 uint64_t __r15;
349 uint64_t __rip;
350 uint32_t __rflags;
351 uint16_t __cs;
352 uint16_t __ss;
353 uint16_t __ds;
354 uint16_t __es;
355 uint16_t __fs;
356 uint16_t __gs;
357 uint64_t __fs_base;
358 uint64_t __gs_base;
359#if defined(_WIN64)
360 uint64_t __padding; // 16-byte align
361#endif
362 };
363 static_assert(offsetof(GPRs, __rflags) == 136 &&
364 offsetof(GPRs, __cs) == 140 &&
365 offsetof(GPRs, __fs_base) == 152 &&
366 offsetof(GPRs, __gs_base) == 160,
367 "x86_64 segment state must match the assembly offsets");
368 GPRs _registers;
369#if defined(_WIN64)
370 v128 _xmm[16];
371#endif
372};
373
374inline Registers_x86_64::Registers_x86_64(const void *registers) {
375 static_assert((check_fit<Registers_x86_64, unw_context_t>::does_fit),
376 "x86_64 registers do not fit into unw_context_t");
377 memcpy(dest: &_registers, src: registers, n: sizeof(_registers));
378}
379
380inline Registers_x86_64::Registers_x86_64() {
381 memset(s: &_registers, c: 0, n: sizeof(_registers));
382}
383
384inline bool Registers_x86_64::validRegister(int regNum) const {
385 if (regNum == UNW_REG_IP)
386 return true;
387 if (regNum == UNW_REG_SP)
388 return true;
389 if (regNum < 0)
390 return false;
391 if (regNum <= UNW_X86_64_RIP)
392 return true;
393 // Extended native register state is captured and restored only on FreeBSD.
394#if defined(__FreeBSD__) && !defined(_LIBUNWIND_IS_BAREMETAL)
395 if (regNum >= UNW_X86_64_RFLAGS && regNum <= UNW_X86_64_GS)
396 return true;
397 if (regNum == UNW_X86_64_FS_BASE || regNum == UNW_X86_64_GS_BASE)
398 return true;
399#endif
400 return false;
401}
402
403inline uint64_t Registers_x86_64::getRegister(int regNum) const {
404 switch (regNum) {
405 case UNW_REG_IP:
406 case UNW_X86_64_RIP:
407 return _registers.__rip;
408 case UNW_REG_SP:
409 return _registers.__rsp;
410 case UNW_X86_64_RAX:
411 return _registers.__rax;
412 case UNW_X86_64_RDX:
413 return _registers.__rdx;
414 case UNW_X86_64_RCX:
415 return _registers.__rcx;
416 case UNW_X86_64_RBX:
417 return _registers.__rbx;
418 case UNW_X86_64_RSI:
419 return _registers.__rsi;
420 case UNW_X86_64_RDI:
421 return _registers.__rdi;
422 case UNW_X86_64_RBP:
423 return _registers.__rbp;
424 case UNW_X86_64_RSP:
425 return _registers.__rsp;
426 case UNW_X86_64_R8:
427 return _registers.__r8;
428 case UNW_X86_64_R9:
429 return _registers.__r9;
430 case UNW_X86_64_R10:
431 return _registers.__r10;
432 case UNW_X86_64_R11:
433 return _registers.__r11;
434 case UNW_X86_64_R12:
435 return _registers.__r12;
436 case UNW_X86_64_R13:
437 return _registers.__r13;
438 case UNW_X86_64_R14:
439 return _registers.__r14;
440 case UNW_X86_64_R15:
441 return _registers.__r15;
442 case UNW_X86_64_RFLAGS:
443 return _registers.__rflags;
444 case UNW_X86_64_ES:
445 return _registers.__es;
446 case UNW_X86_64_CS:
447 return _registers.__cs;
448 case UNW_X86_64_SS:
449 return _registers.__ss;
450 case UNW_X86_64_DS:
451 return _registers.__ds;
452 case UNW_X86_64_FS:
453 return _registers.__fs;
454 case UNW_X86_64_GS:
455 return _registers.__gs;
456 case UNW_X86_64_FS_BASE:
457 return _registers.__fs_base;
458 case UNW_X86_64_GS_BASE:
459 return _registers.__gs_base;
460 }
461 _LIBUNWIND_ABORT("unsupported x86_64 register");
462}
463
464inline void Registers_x86_64::setRegister(int regNum, uint64_t value) {
465 switch (regNum) {
466 case UNW_REG_IP:
467 case UNW_X86_64_RIP:
468 _registers.__rip = value;
469 return;
470 case UNW_REG_SP:
471 _registers.__rsp = value;
472 return;
473 case UNW_X86_64_RAX:
474 _registers.__rax = value;
475 return;
476 case UNW_X86_64_RDX:
477 _registers.__rdx = value;
478 return;
479 case UNW_X86_64_RCX:
480 _registers.__rcx = value;
481 return;
482 case UNW_X86_64_RBX:
483 _registers.__rbx = value;
484 return;
485 case UNW_X86_64_RSI:
486 _registers.__rsi = value;
487 return;
488 case UNW_X86_64_RDI:
489 _registers.__rdi = value;
490 return;
491 case UNW_X86_64_RBP:
492 _registers.__rbp = value;
493 return;
494 case UNW_X86_64_RSP:
495 _registers.__rsp = value;
496 return;
497 case UNW_X86_64_R8:
498 _registers.__r8 = value;
499 return;
500 case UNW_X86_64_R9:
501 _registers.__r9 = value;
502 return;
503 case UNW_X86_64_R10:
504 _registers.__r10 = value;
505 return;
506 case UNW_X86_64_R11:
507 _registers.__r11 = value;
508 return;
509 case UNW_X86_64_R12:
510 _registers.__r12 = value;
511 return;
512 case UNW_X86_64_R13:
513 _registers.__r13 = value;
514 return;
515 case UNW_X86_64_R14:
516 _registers.__r14 = value;
517 return;
518 case UNW_X86_64_R15:
519 _registers.__r15 = value;
520 return;
521 case UNW_X86_64_RFLAGS:
522 _registers.__rflags = static_cast<uint32_t>(value);
523 return;
524 case UNW_X86_64_ES:
525 _registers.__es = static_cast<uint16_t>(value);
526 return;
527 case UNW_X86_64_CS:
528 _registers.__cs = static_cast<uint16_t>(value);
529 return;
530 case UNW_X86_64_SS:
531 _registers.__ss = static_cast<uint16_t>(value);
532 return;
533 case UNW_X86_64_DS:
534 _registers.__ds = static_cast<uint16_t>(value);
535 return;
536 case UNW_X86_64_FS:
537 _registers.__fs = static_cast<uint16_t>(value);
538 return;
539 case UNW_X86_64_GS:
540 _registers.__gs = static_cast<uint16_t>(value);
541 return;
542 case UNW_X86_64_FS_BASE:
543 _registers.__fs_base = value;
544 return;
545 case UNW_X86_64_GS_BASE:
546 _registers.__gs_base = value;
547 return;
548 }
549 _LIBUNWIND_ABORT("unsupported x86_64 register");
550}
551
552inline const char *Registers_x86_64::getRegisterName(int regNum) {
553 switch (regNum) {
554 case UNW_REG_IP:
555 case UNW_X86_64_RIP:
556 return "rip";
557 case UNW_REG_SP:
558 return "rsp";
559 case UNW_X86_64_RAX:
560 return "rax";
561 case UNW_X86_64_RDX:
562 return "rdx";
563 case UNW_X86_64_RCX:
564 return "rcx";
565 case UNW_X86_64_RBX:
566 return "rbx";
567 case UNW_X86_64_RSI:
568 return "rsi";
569 case UNW_X86_64_RDI:
570 return "rdi";
571 case UNW_X86_64_RBP:
572 return "rbp";
573 case UNW_X86_64_RSP:
574 return "rsp";
575 case UNW_X86_64_R8:
576 return "r8";
577 case UNW_X86_64_R9:
578 return "r9";
579 case UNW_X86_64_R10:
580 return "r10";
581 case UNW_X86_64_R11:
582 return "r11";
583 case UNW_X86_64_R12:
584 return "r12";
585 case UNW_X86_64_R13:
586 return "r13";
587 case UNW_X86_64_R14:
588 return "r14";
589 case UNW_X86_64_R15:
590 return "r15";
591 case UNW_X86_64_RFLAGS:
592 return "rflags";
593 case UNW_X86_64_ES:
594 return "es";
595 case UNW_X86_64_CS:
596 return "cs";
597 case UNW_X86_64_SS:
598 return "ss";
599 case UNW_X86_64_DS:
600 return "ds";
601 case UNW_X86_64_FS:
602 return "fs";
603 case UNW_X86_64_GS:
604 return "gs";
605 case UNW_X86_64_FS_BASE:
606 return "fs.base";
607 case UNW_X86_64_GS_BASE:
608 return "gs.base";
609 case UNW_X86_64_XMM0:
610 return "xmm0";
611 case UNW_X86_64_XMM1:
612 return "xmm1";
613 case UNW_X86_64_XMM2:
614 return "xmm2";
615 case UNW_X86_64_XMM3:
616 return "xmm3";
617 case UNW_X86_64_XMM4:
618 return "xmm4";
619 case UNW_X86_64_XMM5:
620 return "xmm5";
621 case UNW_X86_64_XMM6:
622 return "xmm6";
623 case UNW_X86_64_XMM7:
624 return "xmm7";
625 case UNW_X86_64_XMM8:
626 return "xmm8";
627 case UNW_X86_64_XMM9:
628 return "xmm9";
629 case UNW_X86_64_XMM10:
630 return "xmm10";
631 case UNW_X86_64_XMM11:
632 return "xmm11";
633 case UNW_X86_64_XMM12:
634 return "xmm12";
635 case UNW_X86_64_XMM13:
636 return "xmm13";
637 case UNW_X86_64_XMM14:
638 return "xmm14";
639 case UNW_X86_64_XMM15:
640 return "xmm15";
641 default:
642 return "unknown register";
643 }
644}
645
646inline double Registers_x86_64::getFloatRegister(int) const {
647 _LIBUNWIND_ABORT("no x86_64 float registers");
648}
649
650inline void Registers_x86_64::setFloatRegister(int, double) {
651 _LIBUNWIND_ABORT("no x86_64 float registers");
652}
653
654inline bool Registers_x86_64::validVectorRegister(int regNum) const {
655#if defined(_WIN64)
656 if (regNum < UNW_X86_64_XMM0)
657 return false;
658 if (regNum > UNW_X86_64_XMM15)
659 return false;
660 return true;
661#else
662 (void)regNum; // suppress unused parameter warning
663 return false;
664#endif
665}
666
667inline v128 Registers_x86_64::getVectorRegister(int regNum) const {
668#if defined(_WIN64)
669 assert(validVectorRegister(regNum));
670 return _xmm[regNum - UNW_X86_64_XMM0];
671#else
672 (void)regNum; // suppress unused parameter warning
673 _LIBUNWIND_ABORT("no x86_64 vector registers");
674#endif
675}
676
677inline void Registers_x86_64::setVectorRegister(int regNum, v128 value) {
678#if defined(_WIN64)
679 assert(validVectorRegister(regNum));
680 _xmm[regNum - UNW_X86_64_XMM0] = value;
681#else
682 (void)regNum; (void)value; // suppress unused parameter warnings
683 _LIBUNWIND_ABORT("no x86_64 vector registers");
684#endif
685}
686#endif // _LIBUNWIND_TARGET_X86_64
687
688
689#if defined(_LIBUNWIND_TARGET_PPC)
690/// Registers_ppc holds the register state of a thread in a 32-bit PowerPC
691/// process.
692class _LIBUNWIND_HIDDEN Registers_ppc {
693public:
694 Registers_ppc();
695 Registers_ppc(const void *registers);
696
697 typedef uint32_t reg_t;
698 typedef uint32_t link_reg_t;
699 typedef const link_reg_t &link_hardened_reg_arg_t;
700
701 bool validRegister(int num) const;
702 uint32_t getRegister(int num) const;
703 void setRegister(int num, uint32_t value);
704 bool validFloatRegister(int num) const;
705 double getFloatRegister(int num) const;
706 void setFloatRegister(int num, double value);
707 bool validVectorRegister(int num) const;
708 v128 getVectorRegister(int num) const;
709 void setVectorRegister(int num, v128 value);
710 static const char *getRegisterName(int num);
711 void jumpto();
712 static constexpr int lastDwarfRegNum() {
713 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_PPC;
714 }
715 static int getArch() { return REGISTERS_PPC; }
716
717 uint64_t getSP() const { return _registers.__r1; }
718 void setSP(uint32_t value) { _registers.__r1 = value; }
719 uint64_t getIP() const { return _registers.__srr0; }
720 void setIP(uint32_t value) { _registers.__srr0 = value; }
721 uint64_t getCR() const { return _registers.__cr; }
722 void setCR(uint32_t value) { _registers.__cr = value; }
723 uint64_t getLR() const { return _registers.__lr; }
724 void setLR(uint32_t value) { _registers.__lr = value; }
725
726private:
727 struct ppc_thread_state_t {
728 unsigned int __srr0; /* Instruction address register (PC) */
729 unsigned int __srr1; /* Machine state register (supervisor) */
730 unsigned int __r0;
731 unsigned int __r1;
732 unsigned int __r2;
733 unsigned int __r3;
734 unsigned int __r4;
735 unsigned int __r5;
736 unsigned int __r6;
737 unsigned int __r7;
738 unsigned int __r8;
739 unsigned int __r9;
740 unsigned int __r10;
741 unsigned int __r11;
742 unsigned int __r12;
743 unsigned int __r13;
744 unsigned int __r14;
745 unsigned int __r15;
746 unsigned int __r16;
747 unsigned int __r17;
748 unsigned int __r18;
749 unsigned int __r19;
750 unsigned int __r20;
751 unsigned int __r21;
752 unsigned int __r22;
753 unsigned int __r23;
754 unsigned int __r24;
755 unsigned int __r25;
756 unsigned int __r26;
757 unsigned int __r27;
758 unsigned int __r28;
759 unsigned int __r29;
760 unsigned int __r30;
761 unsigned int __r31;
762 unsigned int __cr; /* Condition register */
763 unsigned int __xer; /* User's integer exception register */
764 unsigned int __lr; /* Link register */
765 unsigned int __ctr; /* Count register */
766 unsigned int __mq; /* MQ register (601 only) */
767 unsigned int __vrsave; /* Vector Save Register */
768 };
769
770 struct ppc_float_state_t {
771 double __fpregs[32];
772
773 unsigned int __fpscr_pad; /* fpscr is 64 bits, 32 bits of rubbish */
774 unsigned int __fpscr; /* floating point status register */
775 };
776
777 ppc_thread_state_t _registers;
778 ppc_float_state_t _floatRegisters;
779 v128 _vectorRegisters[32]; // offset 424
780};
781
782inline Registers_ppc::Registers_ppc(const void *registers) {
783 static_assert((check_fit<Registers_ppc, unw_context_t>::does_fit),
784 "ppc registers do not fit into unw_context_t");
785 memcpy(&_registers, static_cast<const uint8_t *>(registers),
786 sizeof(_registers));
787 static_assert(sizeof(ppc_thread_state_t) == 160,
788 "expected float register offset to be 160");
789 memcpy(&_floatRegisters,
790 static_cast<const uint8_t *>(registers) + sizeof(ppc_thread_state_t),
791 sizeof(_floatRegisters));
792 static_assert(sizeof(ppc_thread_state_t) + sizeof(ppc_float_state_t) == 424,
793 "expected vector register offset to be 424 bytes");
794 memcpy(_vectorRegisters,
795 static_cast<const uint8_t *>(registers) + sizeof(ppc_thread_state_t) +
796 sizeof(ppc_float_state_t),
797 sizeof(_vectorRegisters));
798}
799
800inline Registers_ppc::Registers_ppc() {
801 memset(&_registers, 0, sizeof(_registers));
802 memset(&_floatRegisters, 0, sizeof(_floatRegisters));
803 memset(&_vectorRegisters, 0, sizeof(_vectorRegisters));
804}
805
806inline bool Registers_ppc::validRegister(int regNum) const {
807 if (regNum == UNW_REG_IP)
808 return true;
809 if (regNum == UNW_REG_SP)
810 return true;
811 if (regNum == UNW_PPC_VRSAVE)
812 return true;
813 if (regNum < 0)
814 return false;
815 if (regNum <= UNW_PPC_R31)
816 return true;
817 if (regNum == UNW_PPC_MQ)
818 return true;
819 if (regNum == UNW_PPC_LR)
820 return true;
821 if (regNum == UNW_PPC_CTR)
822 return true;
823 if ((UNW_PPC_CR0 <= regNum) && (regNum <= UNW_PPC_CR7))
824 return true;
825 return false;
826}
827
828inline uint32_t Registers_ppc::getRegister(int regNum) const {
829 switch (regNum) {
830 case UNW_REG_IP:
831 return _registers.__srr0;
832 case UNW_REG_SP:
833 return _registers.__r1;
834 case UNW_PPC_R0:
835 return _registers.__r0;
836 case UNW_PPC_R1:
837 return _registers.__r1;
838 case UNW_PPC_R2:
839 return _registers.__r2;
840 case UNW_PPC_R3:
841 return _registers.__r3;
842 case UNW_PPC_R4:
843 return _registers.__r4;
844 case UNW_PPC_R5:
845 return _registers.__r5;
846 case UNW_PPC_R6:
847 return _registers.__r6;
848 case UNW_PPC_R7:
849 return _registers.__r7;
850 case UNW_PPC_R8:
851 return _registers.__r8;
852 case UNW_PPC_R9:
853 return _registers.__r9;
854 case UNW_PPC_R10:
855 return _registers.__r10;
856 case UNW_PPC_R11:
857 return _registers.__r11;
858 case UNW_PPC_R12:
859 return _registers.__r12;
860 case UNW_PPC_R13:
861 return _registers.__r13;
862 case UNW_PPC_R14:
863 return _registers.__r14;
864 case UNW_PPC_R15:
865 return _registers.__r15;
866 case UNW_PPC_R16:
867 return _registers.__r16;
868 case UNW_PPC_R17:
869 return _registers.__r17;
870 case UNW_PPC_R18:
871 return _registers.__r18;
872 case UNW_PPC_R19:
873 return _registers.__r19;
874 case UNW_PPC_R20:
875 return _registers.__r20;
876 case UNW_PPC_R21:
877 return _registers.__r21;
878 case UNW_PPC_R22:
879 return _registers.__r22;
880 case UNW_PPC_R23:
881 return _registers.__r23;
882 case UNW_PPC_R24:
883 return _registers.__r24;
884 case UNW_PPC_R25:
885 return _registers.__r25;
886 case UNW_PPC_R26:
887 return _registers.__r26;
888 case UNW_PPC_R27:
889 return _registers.__r27;
890 case UNW_PPC_R28:
891 return _registers.__r28;
892 case UNW_PPC_R29:
893 return _registers.__r29;
894 case UNW_PPC_R30:
895 return _registers.__r30;
896 case UNW_PPC_R31:
897 return _registers.__r31;
898 case UNW_PPC_LR:
899 return _registers.__lr;
900 case UNW_PPC_CR0:
901 return (_registers.__cr & 0xF0000000);
902 case UNW_PPC_CR1:
903 return (_registers.__cr & 0x0F000000);
904 case UNW_PPC_CR2:
905 return (_registers.__cr & 0x00F00000);
906 case UNW_PPC_CR3:
907 return (_registers.__cr & 0x000F0000);
908 case UNW_PPC_CR4:
909 return (_registers.__cr & 0x0000F000);
910 case UNW_PPC_CR5:
911 return (_registers.__cr & 0x00000F00);
912 case UNW_PPC_CR6:
913 return (_registers.__cr & 0x000000F0);
914 case UNW_PPC_CR7:
915 return (_registers.__cr & 0x0000000F);
916 case UNW_PPC_VRSAVE:
917 return _registers.__vrsave;
918 }
919 _LIBUNWIND_ABORT("unsupported ppc register");
920}
921
922inline void Registers_ppc::setRegister(int regNum, uint32_t value) {
923 //fprintf(stderr, "Registers_ppc::setRegister(%d, 0x%08X)\n", regNum, value);
924 switch (regNum) {
925 case UNW_REG_IP:
926 _registers.__srr0 = value;
927 return;
928 case UNW_REG_SP:
929 _registers.__r1 = value;
930 return;
931 case UNW_PPC_R0:
932 _registers.__r0 = value;
933 return;
934 case UNW_PPC_R1:
935 _registers.__r1 = value;
936 return;
937 case UNW_PPC_R2:
938 _registers.__r2 = value;
939 return;
940 case UNW_PPC_R3:
941 _registers.__r3 = value;
942 return;
943 case UNW_PPC_R4:
944 _registers.__r4 = value;
945 return;
946 case UNW_PPC_R5:
947 _registers.__r5 = value;
948 return;
949 case UNW_PPC_R6:
950 _registers.__r6 = value;
951 return;
952 case UNW_PPC_R7:
953 _registers.__r7 = value;
954 return;
955 case UNW_PPC_R8:
956 _registers.__r8 = value;
957 return;
958 case UNW_PPC_R9:
959 _registers.__r9 = value;
960 return;
961 case UNW_PPC_R10:
962 _registers.__r10 = value;
963 return;
964 case UNW_PPC_R11:
965 _registers.__r11 = value;
966 return;
967 case UNW_PPC_R12:
968 _registers.__r12 = value;
969 return;
970 case UNW_PPC_R13:
971 _registers.__r13 = value;
972 return;
973 case UNW_PPC_R14:
974 _registers.__r14 = value;
975 return;
976 case UNW_PPC_R15:
977 _registers.__r15 = value;
978 return;
979 case UNW_PPC_R16:
980 _registers.__r16 = value;
981 return;
982 case UNW_PPC_R17:
983 _registers.__r17 = value;
984 return;
985 case UNW_PPC_R18:
986 _registers.__r18 = value;
987 return;
988 case UNW_PPC_R19:
989 _registers.__r19 = value;
990 return;
991 case UNW_PPC_R20:
992 _registers.__r20 = value;
993 return;
994 case UNW_PPC_R21:
995 _registers.__r21 = value;
996 return;
997 case UNW_PPC_R22:
998 _registers.__r22 = value;
999 return;
1000 case UNW_PPC_R23:
1001 _registers.__r23 = value;
1002 return;
1003 case UNW_PPC_R24:
1004 _registers.__r24 = value;
1005 return;
1006 case UNW_PPC_R25:
1007 _registers.__r25 = value;
1008 return;
1009 case UNW_PPC_R26:
1010 _registers.__r26 = value;
1011 return;
1012 case UNW_PPC_R27:
1013 _registers.__r27 = value;
1014 return;
1015 case UNW_PPC_R28:
1016 _registers.__r28 = value;
1017 return;
1018 case UNW_PPC_R29:
1019 _registers.__r29 = value;
1020 return;
1021 case UNW_PPC_R30:
1022 _registers.__r30 = value;
1023 return;
1024 case UNW_PPC_R31:
1025 _registers.__r31 = value;
1026 return;
1027 case UNW_PPC_MQ:
1028 _registers.__mq = value;
1029 return;
1030 case UNW_PPC_LR:
1031 _registers.__lr = value;
1032 return;
1033 case UNW_PPC_CTR:
1034 _registers.__ctr = value;
1035 return;
1036 case UNW_PPC_CR0:
1037 _registers.__cr &= 0x0FFFFFFF;
1038 _registers.__cr |= (value & 0xF0000000);
1039 return;
1040 case UNW_PPC_CR1:
1041 _registers.__cr &= 0xF0FFFFFF;
1042 _registers.__cr |= (value & 0x0F000000);
1043 return;
1044 case UNW_PPC_CR2:
1045 _registers.__cr &= 0xFF0FFFFF;
1046 _registers.__cr |= (value & 0x00F00000);
1047 return;
1048 case UNW_PPC_CR3:
1049 _registers.__cr &= 0xFFF0FFFF;
1050 _registers.__cr |= (value & 0x000F0000);
1051 return;
1052 case UNW_PPC_CR4:
1053 _registers.__cr &= 0xFFFF0FFF;
1054 _registers.__cr |= (value & 0x0000F000);
1055 return;
1056 case UNW_PPC_CR5:
1057 _registers.__cr &= 0xFFFFF0FF;
1058 _registers.__cr |= (value & 0x00000F00);
1059 return;
1060 case UNW_PPC_CR6:
1061 _registers.__cr &= 0xFFFFFF0F;
1062 _registers.__cr |= (value & 0x000000F0);
1063 return;
1064 case UNW_PPC_CR7:
1065 _registers.__cr &= 0xFFFFFFF0;
1066 _registers.__cr |= (value & 0x0000000F);
1067 return;
1068 case UNW_PPC_VRSAVE:
1069 _registers.__vrsave = value;
1070 return;
1071 // not saved
1072 return;
1073 case UNW_PPC_XER:
1074 _registers.__xer = value;
1075 return;
1076 case UNW_PPC_AP:
1077 case UNW_PPC_VSCR:
1078 case UNW_PPC_SPEFSCR:
1079 // not saved
1080 return;
1081 }
1082 _LIBUNWIND_ABORT("unsupported ppc register");
1083}
1084
1085inline bool Registers_ppc::validFloatRegister(int regNum) const {
1086 if (regNum < UNW_PPC_F0)
1087 return false;
1088 if (regNum > UNW_PPC_F31)
1089 return false;
1090 return true;
1091}
1092
1093inline double Registers_ppc::getFloatRegister(int regNum) const {
1094 assert(validFloatRegister(regNum));
1095 return _floatRegisters.__fpregs[regNum - UNW_PPC_F0];
1096}
1097
1098inline void Registers_ppc::setFloatRegister(int regNum, double value) {
1099 assert(validFloatRegister(regNum));
1100 _floatRegisters.__fpregs[regNum - UNW_PPC_F0] = value;
1101}
1102
1103inline bool Registers_ppc::validVectorRegister(int regNum) const {
1104 if (regNum < UNW_PPC_V0)
1105 return false;
1106 if (regNum > UNW_PPC_V31)
1107 return false;
1108 return true;
1109}
1110
1111inline v128 Registers_ppc::getVectorRegister(int regNum) const {
1112 assert(validVectorRegister(regNum));
1113 v128 result = _vectorRegisters[regNum - UNW_PPC_V0];
1114 return result;
1115}
1116
1117inline void Registers_ppc::setVectorRegister(int regNum, v128 value) {
1118 assert(validVectorRegister(regNum));
1119 _vectorRegisters[regNum - UNW_PPC_V0] = value;
1120}
1121
1122inline const char *Registers_ppc::getRegisterName(int regNum) {
1123 switch (regNum) {
1124 case UNW_REG_IP:
1125 return "ip";
1126 case UNW_REG_SP:
1127 return "sp";
1128 case UNW_PPC_R0:
1129 return "r0";
1130 case UNW_PPC_R1:
1131 return "r1";
1132 case UNW_PPC_R2:
1133 return "r2";
1134 case UNW_PPC_R3:
1135 return "r3";
1136 case UNW_PPC_R4:
1137 return "r4";
1138 case UNW_PPC_R5:
1139 return "r5";
1140 case UNW_PPC_R6:
1141 return "r6";
1142 case UNW_PPC_R7:
1143 return "r7";
1144 case UNW_PPC_R8:
1145 return "r8";
1146 case UNW_PPC_R9:
1147 return "r9";
1148 case UNW_PPC_R10:
1149 return "r10";
1150 case UNW_PPC_R11:
1151 return "r11";
1152 case UNW_PPC_R12:
1153 return "r12";
1154 case UNW_PPC_R13:
1155 return "r13";
1156 case UNW_PPC_R14:
1157 return "r14";
1158 case UNW_PPC_R15:
1159 return "r15";
1160 case UNW_PPC_R16:
1161 return "r16";
1162 case UNW_PPC_R17:
1163 return "r17";
1164 case UNW_PPC_R18:
1165 return "r18";
1166 case UNW_PPC_R19:
1167 return "r19";
1168 case UNW_PPC_R20:
1169 return "r20";
1170 case UNW_PPC_R21:
1171 return "r21";
1172 case UNW_PPC_R22:
1173 return "r22";
1174 case UNW_PPC_R23:
1175 return "r23";
1176 case UNW_PPC_R24:
1177 return "r24";
1178 case UNW_PPC_R25:
1179 return "r25";
1180 case UNW_PPC_R26:
1181 return "r26";
1182 case UNW_PPC_R27:
1183 return "r27";
1184 case UNW_PPC_R28:
1185 return "r28";
1186 case UNW_PPC_R29:
1187 return "r29";
1188 case UNW_PPC_R30:
1189 return "r30";
1190 case UNW_PPC_R31:
1191 return "r31";
1192 case UNW_PPC_F0:
1193 return "fp0";
1194 case UNW_PPC_F1:
1195 return "fp1";
1196 case UNW_PPC_F2:
1197 return "fp2";
1198 case UNW_PPC_F3:
1199 return "fp3";
1200 case UNW_PPC_F4:
1201 return "fp4";
1202 case UNW_PPC_F5:
1203 return "fp5";
1204 case UNW_PPC_F6:
1205 return "fp6";
1206 case UNW_PPC_F7:
1207 return "fp7";
1208 case UNW_PPC_F8:
1209 return "fp8";
1210 case UNW_PPC_F9:
1211 return "fp9";
1212 case UNW_PPC_F10:
1213 return "fp10";
1214 case UNW_PPC_F11:
1215 return "fp11";
1216 case UNW_PPC_F12:
1217 return "fp12";
1218 case UNW_PPC_F13:
1219 return "fp13";
1220 case UNW_PPC_F14:
1221 return "fp14";
1222 case UNW_PPC_F15:
1223 return "fp15";
1224 case UNW_PPC_F16:
1225 return "fp16";
1226 case UNW_PPC_F17:
1227 return "fp17";
1228 case UNW_PPC_F18:
1229 return "fp18";
1230 case UNW_PPC_F19:
1231 return "fp19";
1232 case UNW_PPC_F20:
1233 return "fp20";
1234 case UNW_PPC_F21:
1235 return "fp21";
1236 case UNW_PPC_F22:
1237 return "fp22";
1238 case UNW_PPC_F23:
1239 return "fp23";
1240 case UNW_PPC_F24:
1241 return "fp24";
1242 case UNW_PPC_F25:
1243 return "fp25";
1244 case UNW_PPC_F26:
1245 return "fp26";
1246 case UNW_PPC_F27:
1247 return "fp27";
1248 case UNW_PPC_F28:
1249 return "fp28";
1250 case UNW_PPC_F29:
1251 return "fp29";
1252 case UNW_PPC_F30:
1253 return "fp30";
1254 case UNW_PPC_F31:
1255 return "fp31";
1256 case UNW_PPC_LR:
1257 return "lr";
1258 default:
1259 return "unknown register";
1260 }
1261
1262}
1263#endif // _LIBUNWIND_TARGET_PPC
1264
1265#if defined(_LIBUNWIND_TARGET_PPC64)
1266/// Registers_ppc64 holds the register state of a thread in a 64-bit PowerPC
1267/// process.
1268class _LIBUNWIND_HIDDEN Registers_ppc64 {
1269public:
1270 Registers_ppc64();
1271 Registers_ppc64(const void *registers);
1272
1273 typedef uint64_t reg_t;
1274 typedef uint64_t link_reg_t;
1275 typedef const link_reg_t &link_hardened_reg_arg_t;
1276
1277 bool validRegister(int num) const;
1278 uint64_t getRegister(int num) const;
1279 void setRegister(int num, uint64_t value);
1280 bool validFloatRegister(int num) const;
1281 double getFloatRegister(int num) const;
1282 void setFloatRegister(int num, double value);
1283 bool validVectorRegister(int num) const;
1284 v128 getVectorRegister(int num) const;
1285 void setVectorRegister(int num, v128 value);
1286 static const char *getRegisterName(int num);
1287 void jumpto();
1288 static constexpr int lastDwarfRegNum() {
1289 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_PPC64;
1290 }
1291 static int getArch() { return REGISTERS_PPC64; }
1292
1293 uint64_t getSP() const { return _registers.__r1; }
1294 void setSP(uint64_t value) { _registers.__r1 = value; }
1295 uint64_t getIP() const { return _registers.__srr0; }
1296 void setIP(uint64_t value) { _registers.__srr0 = value; }
1297 uint64_t getCR() const { return _registers.__cr; }
1298 void setCR(uint64_t value) { _registers.__cr = value; }
1299 uint64_t getLR() const { return _registers.__lr; }
1300 void setLR(uint64_t value) { _registers.__lr = value; }
1301
1302private:
1303 struct ppc64_thread_state_t {
1304 uint64_t __srr0; // Instruction address register (PC)
1305 uint64_t __srr1; // Machine state register (supervisor)
1306 uint64_t __r0;
1307 uint64_t __r1;
1308 uint64_t __r2;
1309 uint64_t __r3;
1310 uint64_t __r4;
1311 uint64_t __r5;
1312 uint64_t __r6;
1313 uint64_t __r7;
1314 uint64_t __r8;
1315 uint64_t __r9;
1316 uint64_t __r10;
1317 uint64_t __r11;
1318 uint64_t __r12;
1319 uint64_t __r13;
1320 uint64_t __r14;
1321 uint64_t __r15;
1322 uint64_t __r16;
1323 uint64_t __r17;
1324 uint64_t __r18;
1325 uint64_t __r19;
1326 uint64_t __r20;
1327 uint64_t __r21;
1328 uint64_t __r22;
1329 uint64_t __r23;
1330 uint64_t __r24;
1331 uint64_t __r25;
1332 uint64_t __r26;
1333 uint64_t __r27;
1334 uint64_t __r28;
1335 uint64_t __r29;
1336 uint64_t __r30;
1337 uint64_t __r31;
1338 uint64_t __cr; // Condition register
1339 uint64_t __xer; // User's integer exception register
1340 uint64_t __lr; // Link register
1341 uint64_t __ctr; // Count register
1342 uint64_t __vrsave; // Vector Save Register
1343 };
1344
1345 union ppc64_vsr_t {
1346 struct asfloat_s {
1347 double f;
1348 uint64_t v2;
1349 } asfloat;
1350 v128 v;
1351 };
1352
1353 ppc64_thread_state_t _registers;
1354 ppc64_vsr_t _vectorScalarRegisters[64];
1355
1356 static int getVectorRegNum(int num);
1357};
1358
1359inline Registers_ppc64::Registers_ppc64(const void *registers) {
1360 static_assert((check_fit<Registers_ppc64, unw_context_t>::does_fit),
1361 "ppc64 registers do not fit into unw_context_t");
1362 memcpy(&_registers, static_cast<const uint8_t *>(registers),
1363 sizeof(_registers));
1364 static_assert(sizeof(_registers) == 312,
1365 "expected vector scalar register offset to be 312");
1366 memcpy(&_vectorScalarRegisters,
1367 static_cast<const uint8_t *>(registers) + sizeof(_registers),
1368 sizeof(_vectorScalarRegisters));
1369 static_assert(sizeof(_registers) +
1370 sizeof(_vectorScalarRegisters) == 1336,
1371 "expected vector register offset to be 1336 bytes");
1372}
1373
1374inline Registers_ppc64::Registers_ppc64() {
1375 memset(&_registers, 0, sizeof(_registers));
1376 memset(&_vectorScalarRegisters, 0, sizeof(_vectorScalarRegisters));
1377}
1378
1379inline bool Registers_ppc64::validRegister(int regNum) const {
1380 switch (regNum) {
1381 case UNW_REG_IP:
1382 case UNW_REG_SP:
1383 case UNW_PPC64_XER:
1384 case UNW_PPC64_LR:
1385 case UNW_PPC64_CTR:
1386 case UNW_PPC64_VRSAVE:
1387 return true;
1388 }
1389
1390 if (regNum >= UNW_PPC64_R0 && regNum <= UNW_PPC64_R31)
1391 return true;
1392 if (regNum >= UNW_PPC64_CR0 && regNum <= UNW_PPC64_CR7)
1393 return true;
1394
1395 return false;
1396}
1397
1398inline uint64_t Registers_ppc64::getRegister(int regNum) const {
1399 switch (regNum) {
1400 case UNW_REG_IP:
1401 return _registers.__srr0;
1402 case UNW_PPC64_R0:
1403 return _registers.__r0;
1404 case UNW_PPC64_R1:
1405 case UNW_REG_SP:
1406 return _registers.__r1;
1407 case UNW_PPC64_R2:
1408 return _registers.__r2;
1409 case UNW_PPC64_R3:
1410 return _registers.__r3;
1411 case UNW_PPC64_R4:
1412 return _registers.__r4;
1413 case UNW_PPC64_R5:
1414 return _registers.__r5;
1415 case UNW_PPC64_R6:
1416 return _registers.__r6;
1417 case UNW_PPC64_R7:
1418 return _registers.__r7;
1419 case UNW_PPC64_R8:
1420 return _registers.__r8;
1421 case UNW_PPC64_R9:
1422 return _registers.__r9;
1423 case UNW_PPC64_R10:
1424 return _registers.__r10;
1425 case UNW_PPC64_R11:
1426 return _registers.__r11;
1427 case UNW_PPC64_R12:
1428 return _registers.__r12;
1429 case UNW_PPC64_R13:
1430 return _registers.__r13;
1431 case UNW_PPC64_R14:
1432 return _registers.__r14;
1433 case UNW_PPC64_R15:
1434 return _registers.__r15;
1435 case UNW_PPC64_R16:
1436 return _registers.__r16;
1437 case UNW_PPC64_R17:
1438 return _registers.__r17;
1439 case UNW_PPC64_R18:
1440 return _registers.__r18;
1441 case UNW_PPC64_R19:
1442 return _registers.__r19;
1443 case UNW_PPC64_R20:
1444 return _registers.__r20;
1445 case UNW_PPC64_R21:
1446 return _registers.__r21;
1447 case UNW_PPC64_R22:
1448 return _registers.__r22;
1449 case UNW_PPC64_R23:
1450 return _registers.__r23;
1451 case UNW_PPC64_R24:
1452 return _registers.__r24;
1453 case UNW_PPC64_R25:
1454 return _registers.__r25;
1455 case UNW_PPC64_R26:
1456 return _registers.__r26;
1457 case UNW_PPC64_R27:
1458 return _registers.__r27;
1459 case UNW_PPC64_R28:
1460 return _registers.__r28;
1461 case UNW_PPC64_R29:
1462 return _registers.__r29;
1463 case UNW_PPC64_R30:
1464 return _registers.__r30;
1465 case UNW_PPC64_R31:
1466 return _registers.__r31;
1467 case UNW_PPC64_CR0:
1468 return (_registers.__cr & 0xF0000000);
1469 case UNW_PPC64_CR1:
1470 return (_registers.__cr & 0x0F000000);
1471 case UNW_PPC64_CR2:
1472 return (_registers.__cr & 0x00F00000);
1473 case UNW_PPC64_CR3:
1474 return (_registers.__cr & 0x000F0000);
1475 case UNW_PPC64_CR4:
1476 return (_registers.__cr & 0x0000F000);
1477 case UNW_PPC64_CR5:
1478 return (_registers.__cr & 0x00000F00);
1479 case UNW_PPC64_CR6:
1480 return (_registers.__cr & 0x000000F0);
1481 case UNW_PPC64_CR7:
1482 return (_registers.__cr & 0x0000000F);
1483 case UNW_PPC64_XER:
1484 return _registers.__xer;
1485 case UNW_PPC64_LR:
1486 return _registers.__lr;
1487 case UNW_PPC64_CTR:
1488 return _registers.__ctr;
1489 case UNW_PPC64_VRSAVE:
1490 return _registers.__vrsave;
1491 }
1492 _LIBUNWIND_ABORT("unsupported ppc64 register");
1493}
1494
1495inline void Registers_ppc64::setRegister(int regNum, uint64_t value) {
1496 switch (regNum) {
1497 case UNW_REG_IP:
1498 _registers.__srr0 = value;
1499 return;
1500 case UNW_PPC64_R0:
1501 _registers.__r0 = value;
1502 return;
1503 case UNW_PPC64_R1:
1504 case UNW_REG_SP:
1505 _registers.__r1 = value;
1506 return;
1507 case UNW_PPC64_R2:
1508 _registers.__r2 = value;
1509 return;
1510 case UNW_PPC64_R3:
1511 _registers.__r3 = value;
1512 return;
1513 case UNW_PPC64_R4:
1514 _registers.__r4 = value;
1515 return;
1516 case UNW_PPC64_R5:
1517 _registers.__r5 = value;
1518 return;
1519 case UNW_PPC64_R6:
1520 _registers.__r6 = value;
1521 return;
1522 case UNW_PPC64_R7:
1523 _registers.__r7 = value;
1524 return;
1525 case UNW_PPC64_R8:
1526 _registers.__r8 = value;
1527 return;
1528 case UNW_PPC64_R9:
1529 _registers.__r9 = value;
1530 return;
1531 case UNW_PPC64_R10:
1532 _registers.__r10 = value;
1533 return;
1534 case UNW_PPC64_R11:
1535 _registers.__r11 = value;
1536 return;
1537 case UNW_PPC64_R12:
1538 _registers.__r12 = value;
1539 return;
1540 case UNW_PPC64_R13:
1541 _registers.__r13 = value;
1542 return;
1543 case UNW_PPC64_R14:
1544 _registers.__r14 = value;
1545 return;
1546 case UNW_PPC64_R15:
1547 _registers.__r15 = value;
1548 return;
1549 case UNW_PPC64_R16:
1550 _registers.__r16 = value;
1551 return;
1552 case UNW_PPC64_R17:
1553 _registers.__r17 = value;
1554 return;
1555 case UNW_PPC64_R18:
1556 _registers.__r18 = value;
1557 return;
1558 case UNW_PPC64_R19:
1559 _registers.__r19 = value;
1560 return;
1561 case UNW_PPC64_R20:
1562 _registers.__r20 = value;
1563 return;
1564 case UNW_PPC64_R21:
1565 _registers.__r21 = value;
1566 return;
1567 case UNW_PPC64_R22:
1568 _registers.__r22 = value;
1569 return;
1570 case UNW_PPC64_R23:
1571 _registers.__r23 = value;
1572 return;
1573 case UNW_PPC64_R24:
1574 _registers.__r24 = value;
1575 return;
1576 case UNW_PPC64_R25:
1577 _registers.__r25 = value;
1578 return;
1579 case UNW_PPC64_R26:
1580 _registers.__r26 = value;
1581 return;
1582 case UNW_PPC64_R27:
1583 _registers.__r27 = value;
1584 return;
1585 case UNW_PPC64_R28:
1586 _registers.__r28 = value;
1587 return;
1588 case UNW_PPC64_R29:
1589 _registers.__r29 = value;
1590 return;
1591 case UNW_PPC64_R30:
1592 _registers.__r30 = value;
1593 return;
1594 case UNW_PPC64_R31:
1595 _registers.__r31 = value;
1596 return;
1597 case UNW_PPC64_CR0:
1598 _registers.__cr &= 0x0FFFFFFF;
1599 _registers.__cr |= (value & 0xF0000000);
1600 return;
1601 case UNW_PPC64_CR1:
1602 _registers.__cr &= 0xF0FFFFFF;
1603 _registers.__cr |= (value & 0x0F000000);
1604 return;
1605 case UNW_PPC64_CR2:
1606 _registers.__cr &= 0xFF0FFFFF;
1607 _registers.__cr |= (value & 0x00F00000);
1608 return;
1609 case UNW_PPC64_CR3:
1610 _registers.__cr &= 0xFFF0FFFF;
1611 _registers.__cr |= (value & 0x000F0000);
1612 return;
1613 case UNW_PPC64_CR4:
1614 _registers.__cr &= 0xFFFF0FFF;
1615 _registers.__cr |= (value & 0x0000F000);
1616 return;
1617 case UNW_PPC64_CR5:
1618 _registers.__cr &= 0xFFFFF0FF;
1619 _registers.__cr |= (value & 0x00000F00);
1620 return;
1621 case UNW_PPC64_CR6:
1622 _registers.__cr &= 0xFFFFFF0F;
1623 _registers.__cr |= (value & 0x000000F0);
1624 return;
1625 case UNW_PPC64_CR7:
1626 _registers.__cr &= 0xFFFFFFF0;
1627 _registers.__cr |= (value & 0x0000000F);
1628 return;
1629 case UNW_PPC64_XER:
1630 _registers.__xer = value;
1631 return;
1632 case UNW_PPC64_LR:
1633 _registers.__lr = value;
1634 return;
1635 case UNW_PPC64_CTR:
1636 _registers.__ctr = value;
1637 return;
1638 case UNW_PPC64_VRSAVE:
1639 _registers.__vrsave = value;
1640 return;
1641 }
1642 _LIBUNWIND_ABORT("unsupported ppc64 register");
1643}
1644
1645inline bool Registers_ppc64::validFloatRegister(int regNum) const {
1646 return regNum >= UNW_PPC64_F0 && regNum <= UNW_PPC64_F31;
1647}
1648
1649inline double Registers_ppc64::getFloatRegister(int regNum) const {
1650 assert(validFloatRegister(regNum));
1651 return _vectorScalarRegisters[regNum - UNW_PPC64_F0].asfloat.f;
1652}
1653
1654inline void Registers_ppc64::setFloatRegister(int regNum, double value) {
1655 assert(validFloatRegister(regNum));
1656 _vectorScalarRegisters[regNum - UNW_PPC64_F0].asfloat.f = value;
1657}
1658
1659inline bool Registers_ppc64::validVectorRegister(int regNum) const {
1660#if defined(__VSX__)
1661 if (regNum >= UNW_PPC64_VS0 && regNum <= UNW_PPC64_VS31)
1662 return true;
1663 if (regNum >= UNW_PPC64_VS32 && regNum <= UNW_PPC64_VS63)
1664 return true;
1665#elif defined(__ALTIVEC__)
1666 if (regNum >= UNW_PPC64_V0 && regNum <= UNW_PPC64_V31)
1667 return true;
1668#endif
1669 return false;
1670}
1671
1672inline int Registers_ppc64::getVectorRegNum(int num)
1673{
1674 if (num >= UNW_PPC64_VS0 && num <= UNW_PPC64_VS31)
1675 return num - UNW_PPC64_VS0;
1676 else
1677 return num - UNW_PPC64_VS32 + 32;
1678}
1679
1680inline v128 Registers_ppc64::getVectorRegister(int regNum) const {
1681 assert(validVectorRegister(regNum));
1682 return _vectorScalarRegisters[getVectorRegNum(regNum)].v;
1683}
1684
1685inline void Registers_ppc64::setVectorRegister(int regNum, v128 value) {
1686 assert(validVectorRegister(regNum));
1687 _vectorScalarRegisters[getVectorRegNum(regNum)].v = value;
1688}
1689
1690inline const char *Registers_ppc64::getRegisterName(int regNum) {
1691 switch (regNum) {
1692 case UNW_REG_IP:
1693 return "ip";
1694 case UNW_REG_SP:
1695 return "sp";
1696 case UNW_PPC64_R0:
1697 return "r0";
1698 case UNW_PPC64_R1:
1699 return "r1";
1700 case UNW_PPC64_R2:
1701 return "r2";
1702 case UNW_PPC64_R3:
1703 return "r3";
1704 case UNW_PPC64_R4:
1705 return "r4";
1706 case UNW_PPC64_R5:
1707 return "r5";
1708 case UNW_PPC64_R6:
1709 return "r6";
1710 case UNW_PPC64_R7:
1711 return "r7";
1712 case UNW_PPC64_R8:
1713 return "r8";
1714 case UNW_PPC64_R9:
1715 return "r9";
1716 case UNW_PPC64_R10:
1717 return "r10";
1718 case UNW_PPC64_R11:
1719 return "r11";
1720 case UNW_PPC64_R12:
1721 return "r12";
1722 case UNW_PPC64_R13:
1723 return "r13";
1724 case UNW_PPC64_R14:
1725 return "r14";
1726 case UNW_PPC64_R15:
1727 return "r15";
1728 case UNW_PPC64_R16:
1729 return "r16";
1730 case UNW_PPC64_R17:
1731 return "r17";
1732 case UNW_PPC64_R18:
1733 return "r18";
1734 case UNW_PPC64_R19:
1735 return "r19";
1736 case UNW_PPC64_R20:
1737 return "r20";
1738 case UNW_PPC64_R21:
1739 return "r21";
1740 case UNW_PPC64_R22:
1741 return "r22";
1742 case UNW_PPC64_R23:
1743 return "r23";
1744 case UNW_PPC64_R24:
1745 return "r24";
1746 case UNW_PPC64_R25:
1747 return "r25";
1748 case UNW_PPC64_R26:
1749 return "r26";
1750 case UNW_PPC64_R27:
1751 return "r27";
1752 case UNW_PPC64_R28:
1753 return "r28";
1754 case UNW_PPC64_R29:
1755 return "r29";
1756 case UNW_PPC64_R30:
1757 return "r30";
1758 case UNW_PPC64_R31:
1759 return "r31";
1760 case UNW_PPC64_CR0:
1761 return "cr0";
1762 case UNW_PPC64_CR1:
1763 return "cr1";
1764 case UNW_PPC64_CR2:
1765 return "cr2";
1766 case UNW_PPC64_CR3:
1767 return "cr3";
1768 case UNW_PPC64_CR4:
1769 return "cr4";
1770 case UNW_PPC64_CR5:
1771 return "cr5";
1772 case UNW_PPC64_CR6:
1773 return "cr6";
1774 case UNW_PPC64_CR7:
1775 return "cr7";
1776 case UNW_PPC64_XER:
1777 return "xer";
1778 case UNW_PPC64_LR:
1779 return "lr";
1780 case UNW_PPC64_CTR:
1781 return "ctr";
1782 case UNW_PPC64_VRSAVE:
1783 return "vrsave";
1784 case UNW_PPC64_F0:
1785 return "fp0";
1786 case UNW_PPC64_F1:
1787 return "fp1";
1788 case UNW_PPC64_F2:
1789 return "fp2";
1790 case UNW_PPC64_F3:
1791 return "fp3";
1792 case UNW_PPC64_F4:
1793 return "fp4";
1794 case UNW_PPC64_F5:
1795 return "fp5";
1796 case UNW_PPC64_F6:
1797 return "fp6";
1798 case UNW_PPC64_F7:
1799 return "fp7";
1800 case UNW_PPC64_F8:
1801 return "fp8";
1802 case UNW_PPC64_F9:
1803 return "fp9";
1804 case UNW_PPC64_F10:
1805 return "fp10";
1806 case UNW_PPC64_F11:
1807 return "fp11";
1808 case UNW_PPC64_F12:
1809 return "fp12";
1810 case UNW_PPC64_F13:
1811 return "fp13";
1812 case UNW_PPC64_F14:
1813 return "fp14";
1814 case UNW_PPC64_F15:
1815 return "fp15";
1816 case UNW_PPC64_F16:
1817 return "fp16";
1818 case UNW_PPC64_F17:
1819 return "fp17";
1820 case UNW_PPC64_F18:
1821 return "fp18";
1822 case UNW_PPC64_F19:
1823 return "fp19";
1824 case UNW_PPC64_F20:
1825 return "fp20";
1826 case UNW_PPC64_F21:
1827 return "fp21";
1828 case UNW_PPC64_F22:
1829 return "fp22";
1830 case UNW_PPC64_F23:
1831 return "fp23";
1832 case UNW_PPC64_F24:
1833 return "fp24";
1834 case UNW_PPC64_F25:
1835 return "fp25";
1836 case UNW_PPC64_F26:
1837 return "fp26";
1838 case UNW_PPC64_F27:
1839 return "fp27";
1840 case UNW_PPC64_F28:
1841 return "fp28";
1842 case UNW_PPC64_F29:
1843 return "fp29";
1844 case UNW_PPC64_F30:
1845 return "fp30";
1846 case UNW_PPC64_F31:
1847 return "fp31";
1848 case UNW_PPC64_V0:
1849 return "v0";
1850 case UNW_PPC64_V1:
1851 return "v1";
1852 case UNW_PPC64_V2:
1853 return "v2";
1854 case UNW_PPC64_V3:
1855 return "v3";
1856 case UNW_PPC64_V4:
1857 return "v4";
1858 case UNW_PPC64_V5:
1859 return "v5";
1860 case UNW_PPC64_V6:
1861 return "v6";
1862 case UNW_PPC64_V7:
1863 return "v7";
1864 case UNW_PPC64_V8:
1865 return "v8";
1866 case UNW_PPC64_V9:
1867 return "v9";
1868 case UNW_PPC64_V10:
1869 return "v10";
1870 case UNW_PPC64_V11:
1871 return "v11";
1872 case UNW_PPC64_V12:
1873 return "v12";
1874 case UNW_PPC64_V13:
1875 return "v13";
1876 case UNW_PPC64_V14:
1877 return "v14";
1878 case UNW_PPC64_V15:
1879 return "v15";
1880 case UNW_PPC64_V16:
1881 return "v16";
1882 case UNW_PPC64_V17:
1883 return "v17";
1884 case UNW_PPC64_V18:
1885 return "v18";
1886 case UNW_PPC64_V19:
1887 return "v19";
1888 case UNW_PPC64_V20:
1889 return "v20";
1890 case UNW_PPC64_V21:
1891 return "v21";
1892 case UNW_PPC64_V22:
1893 return "v22";
1894 case UNW_PPC64_V23:
1895 return "v23";
1896 case UNW_PPC64_V24:
1897 return "v24";
1898 case UNW_PPC64_V25:
1899 return "v25";
1900 case UNW_PPC64_V26:
1901 return "v26";
1902 case UNW_PPC64_V27:
1903 return "v27";
1904 case UNW_PPC64_V28:
1905 return "v28";
1906 case UNW_PPC64_V29:
1907 return "v29";
1908 case UNW_PPC64_V30:
1909 return "v30";
1910 case UNW_PPC64_V31:
1911 return "v31";
1912 }
1913 return "unknown register";
1914}
1915#endif // _LIBUNWIND_TARGET_PPC64
1916
1917
1918#if defined(_LIBUNWIND_TARGET_AARCH64)
1919/// Registers_arm64 holds the register state of a thread in a 64-bit arm
1920/// process.
1921class _LIBUNWIND_HIDDEN Registers_arm64;
1922extern "C" int64_t __libunwind_Registers_arm64_za_disable();
1923extern "C" void __libunwind_Registers_arm64_jumpto(Registers_arm64 *,
1924 unsigned walkedFrames);
1925
1926#if defined(_LIBUNWIND_USE_GCS)
1927extern "C" void *__libunwind_shstk_get_jump_target() {
1928 return reinterpret_cast<void *>(&__libunwind_Registers_arm64_jumpto);
1929}
1930#endif
1931
1932class _LIBUNWIND_HIDDEN Registers_arm64 {
1933public:
1934 Registers_arm64() = default;
1935 Registers_arm64(const void *registers);
1936 Registers_arm64(const Registers_arm64 &);
1937 Registers_arm64 &operator=(const Registers_arm64 &);
1938
1939 typedef uint64_t reg_t;
1940 typedef uint64_t __ptrauth_unwind_registers_arm64_link_reg link_reg_t;
1941
1942 // Use `link_hardened_reg_arg_t` to pass values of `link_reg_t` type as
1943 // function arguments. We need to use a const l-value reference to keep
1944 // signature of `__ptrauth`-qualified values of `link_reg_t` type on AArch64
1945 // PAuth-enabled ABI intact. Passing the raw pointer by value would cause
1946 // authentication on the caller side and make the pointer prone to
1947 // substitution if spilled to the stack in the callee.
1948 typedef const link_reg_t &link_hardened_reg_arg_t;
1949
1950 bool validRegister(int num) const;
1951 uint64_t getRegister(int num) const;
1952 void setRegister(int num, uint64_t value);
1953 bool validFloatRegister(int num) const;
1954 double getFloatRegister(int num) const;
1955 void setFloatRegister(int num, double value);
1956 bool validVectorRegister(int num) const;
1957 v128 getVectorRegister(int num) const;
1958 void setVectorRegister(int num, v128 value);
1959 static const char *getRegisterName(int num);
1960 void jumpto(unsigned walkedFrames = 0) {
1961 zaDisable();
1962 __libunwind_Registers_arm64_jumpto(this, walkedFrames);
1963 }
1964#ifdef _LIBUNWIND_TRACE_RET_INJECT
1965 _LIBUNWIND_TRACE_NO_INLINE
1966 void returnto(unsigned walkedFrames) { jumpto(walkedFrames); }
1967#endif
1968 static constexpr int lastDwarfRegNum() {
1969 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_ARM64;
1970 }
1971 static int getArch() { return REGISTERS_ARM64; }
1972
1973 uint64_t getSP() const { return _registers.__sp; }
1974 void setSP(uint64_t value) { _registers.__sp = value; }
1975 uint64_t getIP() const {
1976 uint64_t value = _registers.__pc;
1977#if defined(_LIBUNWIND_TARGET_AARCH64_AUTHENTICATED_UNWINDING)
1978 // Note the value of the PC was signed to its address in the register state
1979 // but everyone else expects it to be signed by the SP, so convert on return.
1980 value = (uint64_t)ptrauth_auth_and_resign(
1981 (void *)_registers.__pc, ptrauth_key_return_address, &_registers.__pc,
1982 ptrauth_key_return_address, _registers.__sp);
1983#endif
1984 return value;
1985 }
1986 void setIP(uint64_t value) {
1987#if defined(_LIBUNWIND_TARGET_AARCH64_AUTHENTICATED_UNWINDING)
1988 // Note the value which was set should have been signed with the SP.
1989 // We then resign with the slot we are being stored in to so that both SP
1990 // and LR can't be spoofed at the same time.
1991 value = (uint64_t)ptrauth_auth_and_resign(
1992 (void *)value, ptrauth_key_return_address, _registers.__sp,
1993 ptrauth_key_return_address, &_registers.__pc);
1994#endif
1995 _registers.__pc = value;
1996 }
1997 __attribute__((target("pauth-lr"))) void setIPPAuthLR(uint64_t value,
1998 uint64_t signing_pc) {
1999#if defined(_LIBUNWIND_TARGET_AARCH64_AUTHENTICATED_UNWINDING)
2000#ifndef __has_builtin
2001#define __has_builtin(x) 0
2002#endif
2003#if __has_builtin(__builtin_ptrauth_auth_with_pc_and_resign)
2004 value = (uint64_t)ptrauth_auth_with_pc_and_resign(
2005 (void *)value, ptrauth_key_return_address, _registers.__sp, signing_pc,
2006 ptrauth_key_return_address, &_registers.__pc);
2007#else
2008 register uint64_t x17 __asm("x17") = value;
2009 register uint64_t x16 __asm("x16") = _registers.__sp;
2010 register uint64_t x15 __asm("x15") = signing_pc;
2011 uint64_t resignDisc = (uint64_t)&_registers.__pc;
2012 asm("autib171615\n\t"
2013 "pacib %0, %3"
2014 : "+r"(x17)
2015 : "r"(x16), "r"(x15), "r"(resignDisc));
2016 value = x17;
2017#endif
2018#endif
2019 _registers.__pc = value;
2020 }
2021
2022 uint64_t getFP() const { return _registers.__fp; }
2023 void setFP(uint64_t value) { _registers.__fp = value; }
2024
2025#if defined(_LIBUNWIND_TARGET_AARCH64_AUTHENTICATED_UNWINDING)
2026 void
2027 loadAndAuthenticateLinkRegister(reg_t inplaceAuthedLinkRegister,
2028 link_reg_t *referenceAuthedLinkRegister) {
2029 // If we are in an arm64/arm64e frame, then the PC should have been signed
2030 // with the SP
2031 *referenceAuthedLinkRegister =
2032 (uint64_t)ptrauth_auth_data((void *)inplaceAuthedLinkRegister,
2033 ptrauth_key_return_address,
2034 _registers.__sp);
2035 }
2036#endif
2037
2038private:
2039 uint64_t lazyGetVG() const;
2040
2041 void zaDisable() const {
2042 if (!_misc_registers.__has_sme)
2043 return;
2044 if (__libunwind_Registers_arm64_za_disable() != 0)
2045 _LIBUNWIND_ABORT("SME ZA disable failed");
2046 }
2047
2048#if defined(__APPLE__)
2049 static bool checkHasSME() {
2050 int has_sme = 0;
2051 size_t size = sizeof(has_sme);
2052 if (sysctlbyname("hw.optional.arm.FEAT_SME", &has_sme, &size, NULL, 0))
2053 return false;
2054 return has_sme != 0;
2055 }
2056#elif defined(_LIBUNWIND_HAVE_GETAUXVAL)
2057 static bool checkHasSME() {
2058 constexpr int hwcap2_sme = (1 << 23);
2059 unsigned long hwcap2 = getauxval(AT_HWCAP2);
2060 return (hwcap2 & hwcap2_sme) != 0;
2061 }
2062#elif defined(_LIBUNWIND_HAVE_ELF_AUX_INFO)
2063 static bool checkHasSME() {
2064 constexpr int hwcap2_sme = (1 << 23);
2065 unsigned long hwcap2;
2066 if (elf_aux_info(AT_HWCAP2, &hwcap2, sizeof(hwcap2)) != 0)
2067 return false;
2068 return (hwcap2 & hwcap2_sme) != 0;
2069 }
2070#else
2071 static bool checkHasSME() {
2072 // TODO: Support other platforms.
2073 return false;
2074 }
2075#endif
2076
2077 struct GPRs {
2078 uint64_t __x[29] = {}; // x0-x28
2079 uint64_t __fp = 0; // Frame pointer x29
2080 uint64_t __lr = 0; // Link register x30
2081 uint64_t __sp = 0; // Stack pointer x31
2082 uint64_t __pc = 0; // Program counter
2083 uint64_t __ra_sign_state = 0; // RA sign state register
2084 };
2085
2086 struct Misc {
2087 mutable uint32_t __vg = 0; // Vector Granule
2088 bool __has_sme = checkHasSME();
2089 };
2090
2091 GPRs _registers = {};
2092 // Currently only the lower double in 128-bit vectore registers
2093 // is perserved during unwinding. We could define new register
2094 // numbers (> 96) which mean whole vector registers, then this
2095 // struct would need to change to contain whole vector registers.
2096 double _vectorHalfRegisters[32] = {};
2097
2098 // Miscellaneous/virtual registers. These are stored below the GPRs and FPRs
2099 // as they do not correspond to physical registers, so do not need to be
2100 // saved/restored in UnwindRegistersRestore.S and UnwindRegistersSave.S, and
2101 // we don't want to modify the existing offsets for GPRs and FPRs.
2102 Misc _misc_registers;
2103};
2104
2105inline Registers_arm64::Registers_arm64(const void *registers) {
2106 static_assert((check_fit<Registers_arm64, unw_context_t>::does_fit),
2107 "arm64 registers do not fit into unw_context_t");
2108 memcpy(&_registers, registers, sizeof(_registers));
2109 static_assert(sizeof(GPRs) == 0x110,
2110 "expected VFP registers to be at offset 272");
2111 memcpy(_vectorHalfRegisters,
2112 static_cast<const uint8_t *>(registers) + sizeof(GPRs),
2113 sizeof(_vectorHalfRegisters));
2114 _misc_registers.__vg = 0;
2115
2116#if defined(_LIBUNWIND_TARGET_AARCH64_AUTHENTICATED_UNWINDING)
2117 // We have to do some pointer authentication fixups after this copy,
2118 // and as part of that we need to load the source pc without
2119 // authenticating so that we maintain the signature for the resigning
2120 // performed by setIP.
2121 uint64_t pcRegister = 0;
2122 memmove(&pcRegister, ((uint8_t *)&_registers) + offsetof(GPRs, __pc),
2123 sizeof(pcRegister));
2124 setIP(pcRegister);
2125#endif
2126}
2127
2128inline Registers_arm64::Registers_arm64(const Registers_arm64 &other) {
2129 *this = other;
2130}
2131
2132inline Registers_arm64 &
2133Registers_arm64::operator=(const Registers_arm64 &other) {
2134 memmove(static_cast<void *>(this), &other, sizeof(*this));
2135 // We perform this step to ensure that we correctly authenticate and re-sign
2136 // the pc after the bitwise copy.
2137 setIP(other.getIP());
2138 return *this;
2139}
2140
2141inline bool Registers_arm64::validRegister(int regNum) const {
2142 if (regNum == UNW_REG_IP)
2143 return true;
2144 if (regNum == UNW_REG_SP)
2145 return true;
2146 if (regNum < 0)
2147 return false;
2148 if (regNum > 95)
2149 return false;
2150 if (regNum == UNW_AARCH64_RA_SIGN_STATE)
2151 return true;
2152 if (regNum == UNW_AARCH64_VG)
2153 return true;
2154 if ((regNum > 32) && (regNum < 64))
2155 return false;
2156 return true;
2157}
2158
2159inline uint64_t Registers_arm64::lazyGetVG() const {
2160 if (!_misc_registers.__vg) {
2161#if defined(__aarch64__)
2162 register uint64_t vg asm("x0");
2163 asm(".inst 0x04e0e3e0" // CNTD x0
2164 : "=r"(vg));
2165 _misc_registers.__vg = vg;
2166#else
2167 _LIBUNWIND_ABORT("arm64 VG undefined");
2168#endif
2169 }
2170 return _misc_registers.__vg;
2171}
2172
2173inline uint64_t Registers_arm64::getRegister(int regNum) const {
2174 if (regNum == UNW_REG_IP || regNum == UNW_AARCH64_PC)
2175 return getIP();
2176 if (regNum == UNW_REG_SP || regNum == UNW_AARCH64_SP)
2177 return _registers.__sp;
2178 if (regNum == UNW_AARCH64_RA_SIGN_STATE)
2179 return _registers.__ra_sign_state;
2180 if (regNum == UNW_AARCH64_FP)
2181 return getFP();
2182 if (regNum == UNW_AARCH64_LR)
2183 return _registers.__lr;
2184 if (regNum == UNW_AARCH64_VG)
2185 return lazyGetVG();
2186 if ((regNum >= 0) && (regNum < 29))
2187 return _registers.__x[regNum];
2188 _LIBUNWIND_ABORT("unsupported arm64 register");
2189}
2190
2191inline void Registers_arm64::setRegister(int regNum, uint64_t value) {
2192 if (regNum == UNW_REG_IP || regNum == UNW_AARCH64_PC)
2193 setIP(value);
2194 else if (regNum == UNW_REG_SP || regNum == UNW_AARCH64_SP)
2195 _registers.__sp = value;
2196 else if (regNum == UNW_AARCH64_RA_SIGN_STATE)
2197 _registers.__ra_sign_state = value;
2198 else if (regNum == UNW_AARCH64_FP)
2199 setFP(value);
2200 else if (regNum == UNW_AARCH64_LR)
2201 _registers.__lr = value;
2202 else if (regNum == UNW_AARCH64_VG)
2203 _misc_registers.__vg = value;
2204 else if ((regNum >= 0) && (regNum < 29))
2205 _registers.__x[regNum] = value;
2206 else
2207 _LIBUNWIND_ABORT("unsupported arm64 register");
2208}
2209
2210inline const char *Registers_arm64::getRegisterName(int regNum) {
2211 switch (regNum) {
2212 case UNW_REG_IP:
2213 return "pc";
2214 case UNW_REG_SP:
2215 return "sp";
2216 case UNW_AARCH64_X0:
2217 return "x0";
2218 case UNW_AARCH64_X1:
2219 return "x1";
2220 case UNW_AARCH64_X2:
2221 return "x2";
2222 case UNW_AARCH64_X3:
2223 return "x3";
2224 case UNW_AARCH64_X4:
2225 return "x4";
2226 case UNW_AARCH64_X5:
2227 return "x5";
2228 case UNW_AARCH64_X6:
2229 return "x6";
2230 case UNW_AARCH64_X7:
2231 return "x7";
2232 case UNW_AARCH64_X8:
2233 return "x8";
2234 case UNW_AARCH64_X9:
2235 return "x9";
2236 case UNW_AARCH64_X10:
2237 return "x10";
2238 case UNW_AARCH64_X11:
2239 return "x11";
2240 case UNW_AARCH64_X12:
2241 return "x12";
2242 case UNW_AARCH64_X13:
2243 return "x13";
2244 case UNW_AARCH64_X14:
2245 return "x14";
2246 case UNW_AARCH64_X15:
2247 return "x15";
2248 case UNW_AARCH64_X16:
2249 return "x16";
2250 case UNW_AARCH64_X17:
2251 return "x17";
2252 case UNW_AARCH64_X18:
2253 return "x18";
2254 case UNW_AARCH64_X19:
2255 return "x19";
2256 case UNW_AARCH64_X20:
2257 return "x20";
2258 case UNW_AARCH64_X21:
2259 return "x21";
2260 case UNW_AARCH64_X22:
2261 return "x22";
2262 case UNW_AARCH64_X23:
2263 return "x23";
2264 case UNW_AARCH64_X24:
2265 return "x24";
2266 case UNW_AARCH64_X25:
2267 return "x25";
2268 case UNW_AARCH64_X26:
2269 return "x26";
2270 case UNW_AARCH64_X27:
2271 return "x27";
2272 case UNW_AARCH64_X28:
2273 return "x28";
2274 case UNW_AARCH64_FP:
2275 return "fp";
2276 case UNW_AARCH64_LR:
2277 return "lr";
2278 case UNW_AARCH64_SP:
2279 return "sp";
2280 case UNW_AARCH64_PC:
2281 return "pc";
2282 case UNW_AARCH64_V0:
2283 return "d0";
2284 case UNW_AARCH64_V1:
2285 return "d1";
2286 case UNW_AARCH64_V2:
2287 return "d2";
2288 case UNW_AARCH64_V3:
2289 return "d3";
2290 case UNW_AARCH64_V4:
2291 return "d4";
2292 case UNW_AARCH64_V5:
2293 return "d5";
2294 case UNW_AARCH64_V6:
2295 return "d6";
2296 case UNW_AARCH64_V7:
2297 return "d7";
2298 case UNW_AARCH64_V8:
2299 return "d8";
2300 case UNW_AARCH64_V9:
2301 return "d9";
2302 case UNW_AARCH64_V10:
2303 return "d10";
2304 case UNW_AARCH64_V11:
2305 return "d11";
2306 case UNW_AARCH64_V12:
2307 return "d12";
2308 case UNW_AARCH64_V13:
2309 return "d13";
2310 case UNW_AARCH64_V14:
2311 return "d14";
2312 case UNW_AARCH64_V15:
2313 return "d15";
2314 case UNW_AARCH64_V16:
2315 return "d16";
2316 case UNW_AARCH64_V17:
2317 return "d17";
2318 case UNW_AARCH64_V18:
2319 return "d18";
2320 case UNW_AARCH64_V19:
2321 return "d19";
2322 case UNW_AARCH64_V20:
2323 return "d20";
2324 case UNW_AARCH64_V21:
2325 return "d21";
2326 case UNW_AARCH64_V22:
2327 return "d22";
2328 case UNW_AARCH64_V23:
2329 return "d23";
2330 case UNW_AARCH64_V24:
2331 return "d24";
2332 case UNW_AARCH64_V25:
2333 return "d25";
2334 case UNW_AARCH64_V26:
2335 return "d26";
2336 case UNW_AARCH64_V27:
2337 return "d27";
2338 case UNW_AARCH64_V28:
2339 return "d28";
2340 case UNW_AARCH64_V29:
2341 return "d29";
2342 case UNW_AARCH64_V30:
2343 return "d30";
2344 case UNW_AARCH64_V31:
2345 return "d31";
2346 default:
2347 return "unknown register";
2348 }
2349}
2350
2351inline bool Registers_arm64::validFloatRegister(int regNum) const {
2352 if (regNum < UNW_AARCH64_V0)
2353 return false;
2354 if (regNum > UNW_AARCH64_V31)
2355 return false;
2356 return true;
2357}
2358
2359inline double Registers_arm64::getFloatRegister(int regNum) const {
2360 assert(validFloatRegister(regNum));
2361 return _vectorHalfRegisters[regNum - UNW_AARCH64_V0];
2362}
2363
2364inline void Registers_arm64::setFloatRegister(int regNum, double value) {
2365 assert(validFloatRegister(regNum));
2366 _vectorHalfRegisters[regNum - UNW_AARCH64_V0] = value;
2367}
2368
2369inline bool Registers_arm64::validVectorRegister(int) const {
2370 return false;
2371}
2372
2373inline v128 Registers_arm64::getVectorRegister(int) const {
2374 _LIBUNWIND_ABORT("no arm64 vector register support yet");
2375}
2376
2377inline void Registers_arm64::setVectorRegister(int, v128) {
2378 _LIBUNWIND_ABORT("no arm64 vector register support yet");
2379}
2380#endif // _LIBUNWIND_TARGET_AARCH64
2381
2382#if defined(_LIBUNWIND_TARGET_ARM)
2383/// Registers_arm holds the register state of a thread in a 32-bit arm
2384/// process.
2385///
2386/// NOTE: Assumes VFPv3. On ARM processors without a floating point unit,
2387/// this uses more memory than required.
2388class _LIBUNWIND_HIDDEN Registers_arm {
2389public:
2390 Registers_arm();
2391 Registers_arm(const void *registers);
2392
2393 typedef uint32_t reg_t;
2394 typedef uint32_t link_reg_t;
2395 typedef const link_reg_t &link_hardened_reg_arg_t;
2396
2397 bool validRegister(int num) const;
2398 uint32_t getRegister(int num) const;
2399 void setRegister(int num, uint32_t value);
2400 bool validFloatRegister(int num) const;
2401 unw_fpreg_t getFloatRegister(int num);
2402 void setFloatRegister(int num, unw_fpreg_t value);
2403 bool validVectorRegister(int num) const;
2404 v128 getVectorRegister(int num) const;
2405 void setVectorRegister(int num, v128 value);
2406 static const char *getRegisterName(int num);
2407 void jumpto() {
2408 restoreSavedFloatRegisters();
2409 restoreCoreAndJumpTo();
2410 }
2411 static constexpr int lastDwarfRegNum() {
2412 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_ARM;
2413 }
2414 static int getArch() { return REGISTERS_ARM; }
2415
2416 uint32_t getSP() const { return _registers.__sp; }
2417 void setSP(uint32_t value) { _registers.__sp = value; }
2418 uint32_t getIP() const { return _registers.__pc; }
2419 void setIP(uint32_t value) { _registers.__pc = value; }
2420
2421 void saveVFPAsX() {
2422 assert(_use_X_for_vfp_save || !_saved_vfp_d0_d15);
2423 _use_X_for_vfp_save = true;
2424 }
2425
2426 void restoreSavedFloatRegisters() {
2427 if (_saved_vfp_d0_d15) {
2428 if (_use_X_for_vfp_save)
2429 restoreVFPWithFLDMX(_vfp_d0_d15_pad);
2430 else
2431 restoreVFPWithFLDMD(_vfp_d0_d15_pad);
2432 }
2433 if (_saved_vfp_d16_d31)
2434 restoreVFPv3(_vfp_d16_d31);
2435#if defined(__ARM_WMMX)
2436 if (_saved_iwmmx)
2437 restoreiWMMX(_iwmmx);
2438 if (_saved_iwmmx_control)
2439 restoreiWMMXControl(_iwmmx_control);
2440#endif
2441 }
2442
2443private:
2444 struct GPRs {
2445 uint32_t __r[13]; // r0-r12
2446 uint32_t __sp; // Stack pointer r13
2447 uint32_t __lr; // Link register r14
2448 uint32_t __pc; // Program counter r15
2449 };
2450
2451 struct PseudoRegisters {
2452 uint32_t __pac; // Return Authentication Code (PAC)
2453 };
2454
2455 static void saveVFPWithFSTMD(void*);
2456 static void saveVFPWithFSTMX(void*);
2457 static void saveVFPv3(void*);
2458 static void restoreVFPWithFLDMD(void*);
2459 static void restoreVFPWithFLDMX(void*);
2460 static void restoreVFPv3(void*);
2461#if defined(__ARM_WMMX)
2462 static void saveiWMMX(void*);
2463 static void saveiWMMXControl(uint32_t*);
2464 static void restoreiWMMX(void*);
2465 static void restoreiWMMXControl(uint32_t*);
2466#endif
2467 void restoreCoreAndJumpTo();
2468
2469 // ARM registers
2470 GPRs _registers;
2471 PseudoRegisters _pseudo_registers;
2472
2473 // We save floating point registers lazily because we can't know ahead of
2474 // time which ones are used. See EHABI #4.7.
2475
2476 // Whether D0-D15 are saved in the FTSMX instead of FSTMD format.
2477 //
2478 // See EHABI #7.5 that explains how matching instruction sequences for load
2479 // and store need to be used to correctly restore the exact register bits.
2480 bool _use_X_for_vfp_save;
2481 // Whether VFP D0-D15 are saved.
2482 bool _saved_vfp_d0_d15;
2483 // Whether VFPv3 D16-D31 are saved.
2484 bool _saved_vfp_d16_d31;
2485 // VFP registers D0-D15, + padding if saved using FSTMX
2486 unw_fpreg_t _vfp_d0_d15_pad[17];
2487 // VFPv3 registers D16-D31, always saved using FSTMD
2488 unw_fpreg_t _vfp_d16_d31[16];
2489#if defined(__ARM_WMMX)
2490 // Whether iWMMX data registers are saved.
2491 bool _saved_iwmmx;
2492 // Whether iWMMX control registers are saved.
2493 mutable bool _saved_iwmmx_control;
2494 // iWMMX registers
2495 unw_fpreg_t _iwmmx[16];
2496 // iWMMX control registers
2497 mutable uint32_t _iwmmx_control[4];
2498#endif
2499};
2500
2501inline Registers_arm::Registers_arm(const void *registers)
2502 : _use_X_for_vfp_save(false),
2503 _saved_vfp_d0_d15(false),
2504 _saved_vfp_d16_d31(false) {
2505 static_assert((check_fit<Registers_arm, unw_context_t>::does_fit),
2506 "arm registers do not fit into unw_context_t");
2507 // See __unw_getcontext() note about data.
2508 memcpy(&_registers, registers, sizeof(_registers));
2509 memset(&_pseudo_registers, 0, sizeof(_pseudo_registers));
2510 memset(&_vfp_d0_d15_pad, 0, sizeof(_vfp_d0_d15_pad));
2511 memset(&_vfp_d16_d31, 0, sizeof(_vfp_d16_d31));
2512#if defined(__ARM_WMMX)
2513 _saved_iwmmx = false;
2514 _saved_iwmmx_control = false;
2515 memset(&_iwmmx, 0, sizeof(_iwmmx));
2516 memset(&_iwmmx_control, 0, sizeof(_iwmmx_control));
2517#endif
2518}
2519
2520inline Registers_arm::Registers_arm()
2521 : _use_X_for_vfp_save(false),
2522 _saved_vfp_d0_d15(false),
2523 _saved_vfp_d16_d31(false) {
2524 memset(&_registers, 0, sizeof(_registers));
2525 memset(&_pseudo_registers, 0, sizeof(_pseudo_registers));
2526 memset(&_vfp_d0_d15_pad, 0, sizeof(_vfp_d0_d15_pad));
2527 memset(&_vfp_d16_d31, 0, sizeof(_vfp_d16_d31));
2528#if defined(__ARM_WMMX)
2529 _saved_iwmmx = false;
2530 _saved_iwmmx_control = false;
2531 memset(&_iwmmx, 0, sizeof(_iwmmx));
2532 memset(&_iwmmx_control, 0, sizeof(_iwmmx_control));
2533#endif
2534}
2535
2536inline bool Registers_arm::validRegister(int regNum) const {
2537 // Returns true for all non-VFP registers supported by the EHABI
2538 // virtual register set (VRS).
2539 if (regNum == UNW_REG_IP)
2540 return true;
2541
2542 if (regNum == UNW_REG_SP)
2543 return true;
2544
2545 if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R15)
2546 return true;
2547
2548#if defined(__ARM_WMMX)
2549 if (regNum >= UNW_ARM_WC0 && regNum <= UNW_ARM_WC3)
2550 return true;
2551#endif
2552
2553#ifdef __ARM_FEATURE_PAUTH
2554 if (regNum == UNW_ARM_RA_AUTH_CODE)
2555 return true;
2556#endif
2557
2558 return false;
2559}
2560
2561inline uint32_t Registers_arm::getRegister(int regNum) const {
2562 if (regNum == UNW_REG_SP || regNum == UNW_ARM_SP)
2563 return _registers.__sp;
2564
2565 if (regNum == UNW_ARM_LR)
2566 return _registers.__lr;
2567
2568 if (regNum == UNW_REG_IP || regNum == UNW_ARM_IP)
2569 return _registers.__pc;
2570
2571 if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R12)
2572 return _registers.__r[regNum];
2573
2574#if defined(__ARM_WMMX)
2575 if (regNum >= UNW_ARM_WC0 && regNum <= UNW_ARM_WC3) {
2576 if (!_saved_iwmmx_control) {
2577 _saved_iwmmx_control = true;
2578 saveiWMMXControl(_iwmmx_control);
2579 }
2580 return _iwmmx_control[regNum - UNW_ARM_WC0];
2581 }
2582#endif
2583
2584#ifdef __ARM_FEATURE_PAUTH
2585 if (regNum == UNW_ARM_RA_AUTH_CODE)
2586 return _pseudo_registers.__pac;
2587#endif
2588
2589 _LIBUNWIND_ABORT("unsupported arm register");
2590}
2591
2592inline void Registers_arm::setRegister(int regNum, uint32_t value) {
2593 if (regNum == UNW_REG_SP || regNum == UNW_ARM_SP) {
2594 _registers.__sp = value;
2595 return;
2596 }
2597
2598 if (regNum == UNW_ARM_LR) {
2599 _registers.__lr = value;
2600 return;
2601 }
2602
2603 if (regNum == UNW_REG_IP || regNum == UNW_ARM_IP) {
2604 _registers.__pc = value;
2605 return;
2606 }
2607
2608 if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R12) {
2609 _registers.__r[regNum] = value;
2610 return;
2611 }
2612
2613#if defined(__ARM_WMMX)
2614 if (regNum >= UNW_ARM_WC0 && regNum <= UNW_ARM_WC3) {
2615 if (!_saved_iwmmx_control) {
2616 _saved_iwmmx_control = true;
2617 saveiWMMXControl(_iwmmx_control);
2618 }
2619 _iwmmx_control[regNum - UNW_ARM_WC0] = value;
2620 return;
2621 }
2622#endif
2623
2624 if (regNum == UNW_ARM_RA_AUTH_CODE) {
2625 _pseudo_registers.__pac = value;
2626 return;
2627 }
2628
2629 _LIBUNWIND_ABORT("unsupported arm register");
2630}
2631
2632inline const char *Registers_arm::getRegisterName(int regNum) {
2633 switch (regNum) {
2634 case UNW_REG_IP:
2635 case UNW_ARM_IP: // UNW_ARM_R15 is alias
2636 return "pc";
2637 case UNW_ARM_LR: // UNW_ARM_R14 is alias
2638 return "lr";
2639 case UNW_REG_SP:
2640 case UNW_ARM_SP: // UNW_ARM_R13 is alias
2641 return "sp";
2642 case UNW_ARM_R0:
2643 return "r0";
2644 case UNW_ARM_R1:
2645 return "r1";
2646 case UNW_ARM_R2:
2647 return "r2";
2648 case UNW_ARM_R3:
2649 return "r3";
2650 case UNW_ARM_R4:
2651 return "r4";
2652 case UNW_ARM_R5:
2653 return "r5";
2654 case UNW_ARM_R6:
2655 return "r6";
2656 case UNW_ARM_R7:
2657 return "r7";
2658 case UNW_ARM_R8:
2659 return "r8";
2660 case UNW_ARM_R9:
2661 return "r9";
2662 case UNW_ARM_R10:
2663 return "r10";
2664 case UNW_ARM_R11:
2665 return "r11";
2666 case UNW_ARM_R12:
2667 return "r12";
2668 case UNW_ARM_S0:
2669 return "s0";
2670 case UNW_ARM_S1:
2671 return "s1";
2672 case UNW_ARM_S2:
2673 return "s2";
2674 case UNW_ARM_S3:
2675 return "s3";
2676 case UNW_ARM_S4:
2677 return "s4";
2678 case UNW_ARM_S5:
2679 return "s5";
2680 case UNW_ARM_S6:
2681 return "s6";
2682 case UNW_ARM_S7:
2683 return "s7";
2684 case UNW_ARM_S8:
2685 return "s8";
2686 case UNW_ARM_S9:
2687 return "s9";
2688 case UNW_ARM_S10:
2689 return "s10";
2690 case UNW_ARM_S11:
2691 return "s11";
2692 case UNW_ARM_S12:
2693 return "s12";
2694 case UNW_ARM_S13:
2695 return "s13";
2696 case UNW_ARM_S14:
2697 return "s14";
2698 case UNW_ARM_S15:
2699 return "s15";
2700 case UNW_ARM_S16:
2701 return "s16";
2702 case UNW_ARM_S17:
2703 return "s17";
2704 case UNW_ARM_S18:
2705 return "s18";
2706 case UNW_ARM_S19:
2707 return "s19";
2708 case UNW_ARM_S20:
2709 return "s20";
2710 case UNW_ARM_S21:
2711 return "s21";
2712 case UNW_ARM_S22:
2713 return "s22";
2714 case UNW_ARM_S23:
2715 return "s23";
2716 case UNW_ARM_S24:
2717 return "s24";
2718 case UNW_ARM_S25:
2719 return "s25";
2720 case UNW_ARM_S26:
2721 return "s26";
2722 case UNW_ARM_S27:
2723 return "s27";
2724 case UNW_ARM_S28:
2725 return "s28";
2726 case UNW_ARM_S29:
2727 return "s29";
2728 case UNW_ARM_S30:
2729 return "s30";
2730 case UNW_ARM_S31:
2731 return "s31";
2732 case UNW_ARM_D0:
2733 return "d0";
2734 case UNW_ARM_D1:
2735 return "d1";
2736 case UNW_ARM_D2:
2737 return "d2";
2738 case UNW_ARM_D3:
2739 return "d3";
2740 case UNW_ARM_D4:
2741 return "d4";
2742 case UNW_ARM_D5:
2743 return "d5";
2744 case UNW_ARM_D6:
2745 return "d6";
2746 case UNW_ARM_D7:
2747 return "d7";
2748 case UNW_ARM_D8:
2749 return "d8";
2750 case UNW_ARM_D9:
2751 return "d9";
2752 case UNW_ARM_D10:
2753 return "d10";
2754 case UNW_ARM_D11:
2755 return "d11";
2756 case UNW_ARM_D12:
2757 return "d12";
2758 case UNW_ARM_D13:
2759 return "d13";
2760 case UNW_ARM_D14:
2761 return "d14";
2762 case UNW_ARM_D15:
2763 return "d15";
2764 case UNW_ARM_D16:
2765 return "d16";
2766 case UNW_ARM_D17:
2767 return "d17";
2768 case UNW_ARM_D18:
2769 return "d18";
2770 case UNW_ARM_D19:
2771 return "d19";
2772 case UNW_ARM_D20:
2773 return "d20";
2774 case UNW_ARM_D21:
2775 return "d21";
2776 case UNW_ARM_D22:
2777 return "d22";
2778 case UNW_ARM_D23:
2779 return "d23";
2780 case UNW_ARM_D24:
2781 return "d24";
2782 case UNW_ARM_D25:
2783 return "d25";
2784 case UNW_ARM_D26:
2785 return "d26";
2786 case UNW_ARM_D27:
2787 return "d27";
2788 case UNW_ARM_D28:
2789 return "d28";
2790 case UNW_ARM_D29:
2791 return "d29";
2792 case UNW_ARM_D30:
2793 return "d30";
2794 case UNW_ARM_D31:
2795 return "d31";
2796 default:
2797 return "unknown register";
2798 }
2799}
2800
2801inline bool Registers_arm::validFloatRegister(int regNum) const {
2802 // NOTE: Consider the intel MMX registers floating points so the
2803 // __unw_get_fpreg can be used to transmit the 64-bit data back.
2804 return ((regNum >= UNW_ARM_D0) && (regNum <= UNW_ARM_D31))
2805#if defined(__ARM_WMMX)
2806 || ((regNum >= UNW_ARM_WR0) && (regNum <= UNW_ARM_WR15))
2807#endif
2808 ;
2809}
2810
2811inline unw_fpreg_t Registers_arm::getFloatRegister(int regNum) {
2812 if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D15) {
2813 if (!_saved_vfp_d0_d15) {
2814 _saved_vfp_d0_d15 = true;
2815 if (_use_X_for_vfp_save)
2816 saveVFPWithFSTMX(_vfp_d0_d15_pad);
2817 else
2818 saveVFPWithFSTMD(_vfp_d0_d15_pad);
2819 }
2820 return _vfp_d0_d15_pad[regNum - UNW_ARM_D0];
2821 }
2822
2823 if (regNum >= UNW_ARM_D16 && regNum <= UNW_ARM_D31) {
2824 if (!_saved_vfp_d16_d31) {
2825 _saved_vfp_d16_d31 = true;
2826 saveVFPv3(_vfp_d16_d31);
2827 }
2828 return _vfp_d16_d31[regNum - UNW_ARM_D16];
2829 }
2830
2831#if defined(__ARM_WMMX)
2832 if (regNum >= UNW_ARM_WR0 && regNum <= UNW_ARM_WR15) {
2833 if (!_saved_iwmmx) {
2834 _saved_iwmmx = true;
2835 saveiWMMX(_iwmmx);
2836 }
2837 return _iwmmx[regNum - UNW_ARM_WR0];
2838 }
2839#endif
2840
2841 _LIBUNWIND_ABORT("Unknown ARM float register");
2842}
2843
2844inline void Registers_arm::setFloatRegister(int regNum, unw_fpreg_t value) {
2845 if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D15) {
2846 if (!_saved_vfp_d0_d15) {
2847 _saved_vfp_d0_d15 = true;
2848 if (_use_X_for_vfp_save)
2849 saveVFPWithFSTMX(_vfp_d0_d15_pad);
2850 else
2851 saveVFPWithFSTMD(_vfp_d0_d15_pad);
2852 }
2853 _vfp_d0_d15_pad[regNum - UNW_ARM_D0] = value;
2854 return;
2855 }
2856
2857 if (regNum >= UNW_ARM_D16 && regNum <= UNW_ARM_D31) {
2858 if (!_saved_vfp_d16_d31) {
2859 _saved_vfp_d16_d31 = true;
2860 saveVFPv3(_vfp_d16_d31);
2861 }
2862 _vfp_d16_d31[regNum - UNW_ARM_D16] = value;
2863 return;
2864 }
2865
2866#if defined(__ARM_WMMX)
2867 if (regNum >= UNW_ARM_WR0 && regNum <= UNW_ARM_WR15) {
2868 if (!_saved_iwmmx) {
2869 _saved_iwmmx = true;
2870 saveiWMMX(_iwmmx);
2871 }
2872 _iwmmx[regNum - UNW_ARM_WR0] = value;
2873 return;
2874 }
2875#endif
2876
2877 _LIBUNWIND_ABORT("Unknown ARM float register");
2878}
2879
2880inline bool Registers_arm::validVectorRegister(int) const {
2881 return false;
2882}
2883
2884inline v128 Registers_arm::getVectorRegister(int) const {
2885 _LIBUNWIND_ABORT("ARM vector support not implemented");
2886}
2887
2888inline void Registers_arm::setVectorRegister(int, v128) {
2889 _LIBUNWIND_ABORT("ARM vector support not implemented");
2890}
2891#endif // _LIBUNWIND_TARGET_ARM
2892
2893
2894#if defined(_LIBUNWIND_TARGET_OR1K)
2895/// Registers_or1k holds the register state of a thread in an OpenRISC1000
2896/// process.
2897class _LIBUNWIND_HIDDEN Registers_or1k {
2898public:
2899 Registers_or1k();
2900 Registers_or1k(const void *registers);
2901
2902 typedef uint32_t reg_t;
2903 typedef uint32_t link_reg_t;
2904 typedef const link_reg_t &link_hardened_reg_arg_t;
2905
2906 bool validRegister(int num) const;
2907 uint32_t getRegister(int num) const;
2908 void setRegister(int num, uint32_t value);
2909 bool validFloatRegister(int num) const;
2910 double getFloatRegister(int num) const;
2911 void setFloatRegister(int num, double value);
2912 bool validVectorRegister(int num) const;
2913 v128 getVectorRegister(int num) const;
2914 void setVectorRegister(int num, v128 value);
2915 static const char *getRegisterName(int num);
2916 void jumpto();
2917 static constexpr int lastDwarfRegNum() {
2918 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_OR1K;
2919 }
2920 static int getArch() { return REGISTERS_OR1K; }
2921
2922 uint64_t getSP() const { return _registers.__r[1]; }
2923 void setSP(uint32_t value) { _registers.__r[1] = value; }
2924 uint64_t getIP() const { return _registers.__pc; }
2925 void setIP(uint32_t value) { _registers.__pc = value; }
2926
2927private:
2928 struct or1k_thread_state_t {
2929 unsigned int __r[32]; // r0-r31
2930 unsigned int __pc; // Program counter
2931 unsigned int __epcr; // Program counter at exception
2932 };
2933
2934 or1k_thread_state_t _registers;
2935};
2936
2937inline Registers_or1k::Registers_or1k(const void *registers) {
2938 static_assert((check_fit<Registers_or1k, unw_context_t>::does_fit),
2939 "or1k registers do not fit into unw_context_t");
2940 memcpy(&_registers, static_cast<const uint8_t *>(registers),
2941 sizeof(_registers));
2942}
2943
2944inline Registers_or1k::Registers_or1k() {
2945 memset(&_registers, 0, sizeof(_registers));
2946}
2947
2948inline bool Registers_or1k::validRegister(int regNum) const {
2949 if (regNum == UNW_REG_IP)
2950 return true;
2951 if (regNum == UNW_REG_SP)
2952 return true;
2953 if (regNum < 0)
2954 return false;
2955 if (regNum <= UNW_OR1K_R31)
2956 return true;
2957 if (regNum == UNW_OR1K_EPCR)
2958 return true;
2959 return false;
2960}
2961
2962inline uint32_t Registers_or1k::getRegister(int regNum) const {
2963 if (regNum >= UNW_OR1K_R0 && regNum <= UNW_OR1K_R31)
2964 return _registers.__r[regNum - UNW_OR1K_R0];
2965
2966 switch (regNum) {
2967 case UNW_REG_IP:
2968 return _registers.__pc;
2969 case UNW_REG_SP:
2970 return _registers.__r[1];
2971 case UNW_OR1K_EPCR:
2972 return _registers.__epcr;
2973 }
2974 _LIBUNWIND_ABORT("unsupported or1k register");
2975}
2976
2977inline void Registers_or1k::setRegister(int regNum, uint32_t value) {
2978 if (regNum >= UNW_OR1K_R0 && regNum <= UNW_OR1K_R31) {
2979 _registers.__r[regNum - UNW_OR1K_R0] = value;
2980 return;
2981 }
2982
2983 switch (regNum) {
2984 case UNW_REG_IP:
2985 _registers.__pc = value;
2986 return;
2987 case UNW_REG_SP:
2988 _registers.__r[1] = value;
2989 return;
2990 case UNW_OR1K_EPCR:
2991 _registers.__epcr = value;
2992 return;
2993 }
2994 _LIBUNWIND_ABORT("unsupported or1k register");
2995}
2996
2997inline bool Registers_or1k::validFloatRegister(int /* regNum */) const {
2998 return false;
2999}
3000
3001inline double Registers_or1k::getFloatRegister(int /* regNum */) const {
3002 _LIBUNWIND_ABORT("or1k float support not implemented");
3003}
3004
3005inline void Registers_or1k::setFloatRegister(int /* regNum */,
3006 double /* value */) {
3007 _LIBUNWIND_ABORT("or1k float support not implemented");
3008}
3009
3010inline bool Registers_or1k::validVectorRegister(int /* regNum */) const {
3011 return false;
3012}
3013
3014inline v128 Registers_or1k::getVectorRegister(int /* regNum */) const {
3015 _LIBUNWIND_ABORT("or1k vector support not implemented");
3016}
3017
3018inline void Registers_or1k::setVectorRegister(int /* regNum */, v128 /* value */) {
3019 _LIBUNWIND_ABORT("or1k vector support not implemented");
3020}
3021
3022inline const char *Registers_or1k::getRegisterName(int regNum) {
3023 switch (regNum) {
3024 case UNW_OR1K_R0:
3025 return "r0";
3026 case UNW_OR1K_R1:
3027 return "r1";
3028 case UNW_OR1K_R2:
3029 return "r2";
3030 case UNW_OR1K_R3:
3031 return "r3";
3032 case UNW_OR1K_R4:
3033 return "r4";
3034 case UNW_OR1K_R5:
3035 return "r5";
3036 case UNW_OR1K_R6:
3037 return "r6";
3038 case UNW_OR1K_R7:
3039 return "r7";
3040 case UNW_OR1K_R8:
3041 return "r8";
3042 case UNW_OR1K_R9:
3043 return "r9";
3044 case UNW_OR1K_R10:
3045 return "r10";
3046 case UNW_OR1K_R11:
3047 return "r11";
3048 case UNW_OR1K_R12:
3049 return "r12";
3050 case UNW_OR1K_R13:
3051 return "r13";
3052 case UNW_OR1K_R14:
3053 return "r14";
3054 case UNW_OR1K_R15:
3055 return "r15";
3056 case UNW_OR1K_R16:
3057 return "r16";
3058 case UNW_OR1K_R17:
3059 return "r17";
3060 case UNW_OR1K_R18:
3061 return "r18";
3062 case UNW_OR1K_R19:
3063 return "r19";
3064 case UNW_OR1K_R20:
3065 return "r20";
3066 case UNW_OR1K_R21:
3067 return "r21";
3068 case UNW_OR1K_R22:
3069 return "r22";
3070 case UNW_OR1K_R23:
3071 return "r23";
3072 case UNW_OR1K_R24:
3073 return "r24";
3074 case UNW_OR1K_R25:
3075 return "r25";
3076 case UNW_OR1K_R26:
3077 return "r26";
3078 case UNW_OR1K_R27:
3079 return "r27";
3080 case UNW_OR1K_R28:
3081 return "r28";
3082 case UNW_OR1K_R29:
3083 return "r29";
3084 case UNW_OR1K_R30:
3085 return "r30";
3086 case UNW_OR1K_R31:
3087 return "r31";
3088 case UNW_OR1K_EPCR:
3089 return "EPCR";
3090 default:
3091 return "unknown register";
3092 }
3093
3094}
3095#endif // _LIBUNWIND_TARGET_OR1K
3096
3097#if defined(_LIBUNWIND_TARGET_MIPS_O32)
3098/// Registers_mips_o32 holds the register state of a thread in a 32-bit MIPS
3099/// process.
3100class _LIBUNWIND_HIDDEN Registers_mips_o32 {
3101public:
3102 Registers_mips_o32();
3103 Registers_mips_o32(const void *registers);
3104
3105 typedef uint32_t reg_t;
3106 typedef uint32_t link_reg_t;
3107 typedef const link_reg_t &link_hardened_reg_arg_t;
3108
3109 bool validRegister(int num) const;
3110 uint32_t getRegister(int num) const;
3111 void setRegister(int num, uint32_t value);
3112 bool validFloatRegister(int num) const;
3113 double getFloatRegister(int num) const;
3114 void setFloatRegister(int num, double value);
3115 bool validVectorRegister(int num) const;
3116 v128 getVectorRegister(int num) const;
3117 void setVectorRegister(int num, v128 value);
3118 static const char *getRegisterName(int num);
3119 void jumpto();
3120 static constexpr int lastDwarfRegNum() {
3121 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_MIPS;
3122 }
3123 static int getArch() { return REGISTERS_MIPS_O32; }
3124
3125 uint32_t getSP() const { return _registers.__r[29]; }
3126 void setSP(uint32_t value) { _registers.__r[29] = value; }
3127 uint32_t getIP() const { return _registers.__pc; }
3128 void setIP(uint32_t value) { _registers.__pc = value; }
3129
3130private:
3131 struct mips_o32_thread_state_t {
3132 uint32_t __r[32];
3133 uint32_t __pc;
3134 uint32_t __hi;
3135 uint32_t __lo;
3136 };
3137
3138 mips_o32_thread_state_t _registers;
3139#ifdef __mips_hard_float
3140 /// O32 with 32-bit floating point registers only uses half of this
3141 /// space. However, using the same layout for 32-bit vs 64-bit
3142 /// floating point registers results in a single context size for
3143 /// O32 with hard float.
3144 uint32_t _padding;
3145 double _floats[32];
3146#endif
3147};
3148
3149inline Registers_mips_o32::Registers_mips_o32(const void *registers) {
3150 static_assert((check_fit<Registers_mips_o32, unw_context_t>::does_fit),
3151 "mips_o32 registers do not fit into unw_context_t");
3152#ifdef __mips_hard_float
3153 // UnwindRegisters{Save,Restore}.S address this area as (4 * 36 + 8 * N)($4).
3154 static_assert(offsetof(Registers_mips_o32, _floats) == 4 * 36,
3155 "mips_o32 float area offset does not match the .S files");
3156 static_assert(sizeof(_floats[0]) == 8,
3157 "mips_o32 float slot stride does not match the .S files");
3158 static_assert(sizeof(_floats) == 8 * 32,
3159 "mips_o32 float area must cover f0-f31");
3160#endif
3161 memcpy(&_registers, static_cast<const uint8_t *>(registers),
3162 sizeof(_registers));
3163}
3164
3165inline Registers_mips_o32::Registers_mips_o32() {
3166 memset(&_registers, 0, sizeof(_registers));
3167}
3168
3169inline bool Registers_mips_o32::validRegister(int regNum) const {
3170 if (regNum == UNW_REG_IP)
3171 return true;
3172 if (regNum == UNW_REG_SP)
3173 return true;
3174 if (regNum < 0)
3175 return false;
3176 if (regNum <= UNW_MIPS_R31)
3177 return true;
3178#if __mips_isa_rev < 6
3179 if (regNum == UNW_MIPS_HI)
3180 return true;
3181 if (regNum == UNW_MIPS_LO)
3182 return true;
3183#endif
3184#if defined(__mips_hard_float)
3185#if defined(__mips_single_float) || __mips_fpr == 32
3186 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31)
3187 return true;
3188#endif
3189#endif
3190 // FIXME: DSP accumulator registers, MSA registers
3191 return false;
3192}
3193
3194inline uint32_t Registers_mips_o32::getRegister(int regNum) const {
3195 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31)
3196 return _registers.__r[regNum - UNW_MIPS_R0];
3197#if defined(__mips_hard_float)
3198#if defined(__mips_single_float)
3199 // Single float has no even/odd pairing.
3200 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31) {
3201 uint32_t result;
3202 memcpy(&result, &_floats[regNum - UNW_MIPS_F0], sizeof(result));
3203 return result;
3204 }
3205#elif __mips_fpr == 32
3206 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31) {
3207 uint32_t *p;
3208
3209 if (regNum % 2 == 0)
3210 p = (uint32_t *)&_floats[regNum - UNW_MIPS_F0];
3211 else
3212 p = (uint32_t *)&_floats[(regNum - 1) - UNW_MIPS_F0] + 1;
3213 return *p;
3214 }
3215#endif
3216#endif
3217
3218 switch (regNum) {
3219 case UNW_REG_IP:
3220 return _registers.__pc;
3221 case UNW_REG_SP:
3222 return _registers.__r[29];
3223#if __mips_isa_rev < 6
3224 case UNW_MIPS_HI:
3225 return _registers.__hi;
3226 case UNW_MIPS_LO:
3227 return _registers.__lo;
3228#endif
3229 }
3230 _LIBUNWIND_ABORT("unsupported mips_o32 register");
3231}
3232
3233inline void Registers_mips_o32::setRegister(int regNum, uint32_t value) {
3234 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31) {
3235 _registers.__r[regNum - UNW_MIPS_R0] = value;
3236 return;
3237 }
3238#if defined(__mips_hard_float)
3239#if defined(__mips_single_float)
3240 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31) {
3241 memcpy(&_floats[regNum - UNW_MIPS_F0], &value, sizeof(value));
3242 return;
3243 }
3244#elif __mips_fpr == 32
3245 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31) {
3246 uint32_t *p;
3247
3248 if (regNum % 2 == 0)
3249 p = (uint32_t *)&_floats[regNum - UNW_MIPS_F0];
3250 else
3251 p = (uint32_t *)&_floats[(regNum - 1) - UNW_MIPS_F0] + 1;
3252 *p = value;
3253 return;
3254 }
3255#endif
3256#endif
3257
3258 switch (regNum) {
3259 case UNW_REG_IP:
3260 _registers.__pc = value;
3261 return;
3262 case UNW_REG_SP:
3263 _registers.__r[29] = value;
3264 return;
3265#if __mips_isa_rev < 6
3266 case UNW_MIPS_HI:
3267 _registers.__hi = value;
3268 return;
3269 case UNW_MIPS_LO:
3270 _registers.__lo = value;
3271#endif
3272 return;
3273 }
3274 _LIBUNWIND_ABORT("unsupported mips_o32 register");
3275}
3276
3277inline bool Registers_mips_o32::validFloatRegister(int regNum) const {
3278#if defined(__mips_hard_float)
3279#if defined(__mips_single_float) || __mips_fpr == 64
3280 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31)
3281 return true;
3282#endif
3283#endif
3284 (void)regNum;
3285 return false;
3286}
3287
3288inline double Registers_mips_o32::getFloatRegister(int regNum) const {
3289#if defined(__mips_hard_float)
3290#if defined(__mips_single_float)
3291 assert(validFloatRegister(regNum));
3292 float result;
3293 memcpy(&result, &_floats[regNum - UNW_MIPS_F0], sizeof(result));
3294 return result;
3295#elif __mips_fpr == 64
3296 assert(validFloatRegister(regNum));
3297 return _floats[regNum - UNW_MIPS_F0];
3298#endif
3299#endif
3300 (void)regNum;
3301 _LIBUNWIND_ABORT("mips_o32 float support not implemented");
3302}
3303
3304inline void Registers_mips_o32::setFloatRegister(int regNum,
3305 double value) {
3306#if defined(__mips_hard_float)
3307#if defined(__mips_single_float)
3308 assert(validFloatRegister(regNum));
3309 float single = static_cast<float>(value);
3310 memcpy(&_floats[regNum - UNW_MIPS_F0], &single, sizeof(single));
3311 return;
3312#elif __mips_fpr == 64
3313 assert(validFloatRegister(regNum));
3314 _floats[regNum - UNW_MIPS_F0] = value;
3315 return;
3316#endif
3317#endif
3318 (void)regNum;
3319 (void)value;
3320 _LIBUNWIND_ABORT("mips_o32 float support not implemented");
3321}
3322
3323inline bool Registers_mips_o32::validVectorRegister(int /* regNum */) const {
3324 return false;
3325}
3326
3327inline v128 Registers_mips_o32::getVectorRegister(int /* regNum */) const {
3328 _LIBUNWIND_ABORT("mips_o32 vector support not implemented");
3329}
3330
3331inline void Registers_mips_o32::setVectorRegister(int /* regNum */, v128 /* value */) {
3332 _LIBUNWIND_ABORT("mips_o32 vector support not implemented");
3333}
3334
3335inline const char *Registers_mips_o32::getRegisterName(int regNum) {
3336 switch (regNum) {
3337 case UNW_MIPS_R0:
3338 return "$0";
3339 case UNW_MIPS_R1:
3340 return "$1";
3341 case UNW_MIPS_R2:
3342 return "$2";
3343 case UNW_MIPS_R3:
3344 return "$3";
3345 case UNW_MIPS_R4:
3346 return "$4";
3347 case UNW_MIPS_R5:
3348 return "$5";
3349 case UNW_MIPS_R6:
3350 return "$6";
3351 case UNW_MIPS_R7:
3352 return "$7";
3353 case UNW_MIPS_R8:
3354 return "$8";
3355 case UNW_MIPS_R9:
3356 return "$9";
3357 case UNW_MIPS_R10:
3358 return "$10";
3359 case UNW_MIPS_R11:
3360 return "$11";
3361 case UNW_MIPS_R12:
3362 return "$12";
3363 case UNW_MIPS_R13:
3364 return "$13";
3365 case UNW_MIPS_R14:
3366 return "$14";
3367 case UNW_MIPS_R15:
3368 return "$15";
3369 case UNW_MIPS_R16:
3370 return "$16";
3371 case UNW_MIPS_R17:
3372 return "$17";
3373 case UNW_MIPS_R18:
3374 return "$18";
3375 case UNW_MIPS_R19:
3376 return "$19";
3377 case UNW_MIPS_R20:
3378 return "$20";
3379 case UNW_MIPS_R21:
3380 return "$21";
3381 case UNW_MIPS_R22:
3382 return "$22";
3383 case UNW_MIPS_R23:
3384 return "$23";
3385 case UNW_MIPS_R24:
3386 return "$24";
3387 case UNW_MIPS_R25:
3388 return "$25";
3389 case UNW_MIPS_R26:
3390 return "$26";
3391 case UNW_MIPS_R27:
3392 return "$27";
3393 case UNW_MIPS_R28:
3394 return "$28";
3395 case UNW_MIPS_R29:
3396 return "$29";
3397 case UNW_MIPS_R30:
3398 return "$30";
3399 case UNW_MIPS_R31:
3400 return "$31";
3401 case UNW_MIPS_F0:
3402 return "$f0";
3403 case UNW_MIPS_F1:
3404 return "$f1";
3405 case UNW_MIPS_F2:
3406 return "$f2";
3407 case UNW_MIPS_F3:
3408 return "$f3";
3409 case UNW_MIPS_F4:
3410 return "$f4";
3411 case UNW_MIPS_F5:
3412 return "$f5";
3413 case UNW_MIPS_F6:
3414 return "$f6";
3415 case UNW_MIPS_F7:
3416 return "$f7";
3417 case UNW_MIPS_F8:
3418 return "$f8";
3419 case UNW_MIPS_F9:
3420 return "$f9";
3421 case UNW_MIPS_F10:
3422 return "$f10";
3423 case UNW_MIPS_F11:
3424 return "$f11";
3425 case UNW_MIPS_F12:
3426 return "$f12";
3427 case UNW_MIPS_F13:
3428 return "$f13";
3429 case UNW_MIPS_F14:
3430 return "$f14";
3431 case UNW_MIPS_F15:
3432 return "$f15";
3433 case UNW_MIPS_F16:
3434 return "$f16";
3435 case UNW_MIPS_F17:
3436 return "$f17";
3437 case UNW_MIPS_F18:
3438 return "$f18";
3439 case UNW_MIPS_F19:
3440 return "$f19";
3441 case UNW_MIPS_F20:
3442 return "$f20";
3443 case UNW_MIPS_F21:
3444 return "$f21";
3445 case UNW_MIPS_F22:
3446 return "$f22";
3447 case UNW_MIPS_F23:
3448 return "$f23";
3449 case UNW_MIPS_F24:
3450 return "$f24";
3451 case UNW_MIPS_F25:
3452 return "$f25";
3453 case UNW_MIPS_F26:
3454 return "$f26";
3455 case UNW_MIPS_F27:
3456 return "$f27";
3457 case UNW_MIPS_F28:
3458 return "$f28";
3459 case UNW_MIPS_F29:
3460 return "$f29";
3461 case UNW_MIPS_F30:
3462 return "$f30";
3463 case UNW_MIPS_F31:
3464 return "$f31";
3465#if __mips_isa_rev < 6
3466 case UNW_MIPS_HI:
3467 return "$hi";
3468 case UNW_MIPS_LO:
3469 return "$lo";
3470#endif
3471 default:
3472 return "unknown register";
3473 }
3474}
3475#endif // _LIBUNWIND_TARGET_MIPS_O32
3476
3477#if defined(_LIBUNWIND_TARGET_MIPS_NEWABI)
3478/// Registers_mips_newabi holds the register state of a thread in a
3479/// MIPS process using NEWABI (the N32 or N64 ABIs).
3480class _LIBUNWIND_HIDDEN Registers_mips_newabi {
3481public:
3482 Registers_mips_newabi();
3483 Registers_mips_newabi(const void *registers);
3484
3485 typedef uint64_t reg_t;
3486 typedef uint64_t link_reg_t;
3487 typedef const link_reg_t &link_hardened_reg_arg_t;
3488
3489 bool validRegister(int num) const;
3490 uint64_t getRegister(int num) const;
3491 void setRegister(int num, uint64_t value);
3492 bool validFloatRegister(int num) const;
3493 double getFloatRegister(int num) const;
3494 void setFloatRegister(int num, double value);
3495 bool validVectorRegister(int num) const;
3496 v128 getVectorRegister(int num) const;
3497 void setVectorRegister(int num, v128 value);
3498 static const char *getRegisterName(int num);
3499 void jumpto();
3500 static constexpr int lastDwarfRegNum() {
3501 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_MIPS;
3502 }
3503 static int getArch() { return REGISTERS_MIPS_NEWABI; }
3504
3505 uint64_t getSP() const { return _registers.__r[29]; }
3506 void setSP(uint64_t value) { _registers.__r[29] = value; }
3507 uint64_t getIP() const { return _registers.__pc; }
3508 void setIP(uint64_t value) { _registers.__pc = value; }
3509
3510private:
3511 struct mips_newabi_thread_state_t {
3512 uint64_t __r[32];
3513 uint64_t __pc;
3514 uint64_t __hi;
3515 uint64_t __lo;
3516 };
3517
3518 mips_newabi_thread_state_t _registers;
3519#ifdef __mips_hard_float
3520 double _floats[32];
3521#endif
3522};
3523
3524inline Registers_mips_newabi::Registers_mips_newabi(const void *registers) {
3525 static_assert((check_fit<Registers_mips_newabi, unw_context_t>::does_fit),
3526 "mips_newabi registers do not fit into unw_context_t");
3527 memcpy(&_registers, static_cast<const uint8_t *>(registers),
3528 sizeof(_registers));
3529}
3530
3531inline Registers_mips_newabi::Registers_mips_newabi() {
3532 memset(&_registers, 0, sizeof(_registers));
3533}
3534
3535inline bool Registers_mips_newabi::validRegister(int regNum) const {
3536 if (regNum == UNW_REG_IP)
3537 return true;
3538 if (regNum == UNW_REG_SP)
3539 return true;
3540 if (regNum < 0)
3541 return false;
3542 if (regNum <= UNW_MIPS_R31)
3543 return true;
3544#if __mips_isa_rev < 6
3545 if (regNum == UNW_MIPS_HI)
3546 return true;
3547 if (regNum == UNW_MIPS_LO)
3548 return true;
3549#endif
3550 // FIXME: Hard float, DSP accumulator registers, MSA registers
3551 return false;
3552}
3553
3554inline uint64_t Registers_mips_newabi::getRegister(int regNum) const {
3555 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31)
3556 return _registers.__r[regNum - UNW_MIPS_R0];
3557
3558 switch (regNum) {
3559 case UNW_REG_IP:
3560 return _registers.__pc;
3561 case UNW_REG_SP:
3562 return _registers.__r[29];
3563#if __mips_isa_rev < 6
3564 case UNW_MIPS_HI:
3565 return _registers.__hi;
3566 case UNW_MIPS_LO:
3567 return _registers.__lo;
3568#endif
3569 }
3570 _LIBUNWIND_ABORT("unsupported mips_newabi register");
3571}
3572
3573inline void Registers_mips_newabi::setRegister(int regNum, uint64_t value) {
3574 if (regNum >= UNW_MIPS_R0 && regNum <= UNW_MIPS_R31) {
3575 _registers.__r[regNum - UNW_MIPS_R0] = value;
3576 return;
3577 }
3578
3579 switch (regNum) {
3580 case UNW_REG_IP:
3581 _registers.__pc = value;
3582 return;
3583 case UNW_REG_SP:
3584 _registers.__r[29] = value;
3585 return;
3586#if __mips_isa_rev < 6
3587 case UNW_MIPS_HI:
3588 _registers.__hi = value;
3589 return;
3590 case UNW_MIPS_LO:
3591 _registers.__lo = value;
3592 return;
3593#endif
3594 }
3595 _LIBUNWIND_ABORT("unsupported mips_newabi register");
3596}
3597
3598inline bool Registers_mips_newabi::validFloatRegister(int regNum) const {
3599#ifdef __mips_hard_float
3600 if (regNum >= UNW_MIPS_F0 && regNum <= UNW_MIPS_F31)
3601 return true;
3602#else
3603 (void)regNum;
3604#endif
3605 return false;
3606}
3607
3608inline double Registers_mips_newabi::getFloatRegister(int regNum) const {
3609#ifdef __mips_hard_float
3610 assert(validFloatRegister(regNum));
3611 return _floats[regNum - UNW_MIPS_F0];
3612#else
3613 (void)regNum;
3614 _LIBUNWIND_ABORT("mips_newabi float support not implemented");
3615#endif
3616}
3617
3618inline void Registers_mips_newabi::setFloatRegister(int regNum,
3619 double value) {
3620#ifdef __mips_hard_float
3621 assert(validFloatRegister(regNum));
3622 _floats[regNum - UNW_MIPS_F0] = value;
3623#else
3624 (void)regNum;
3625 (void)value;
3626 _LIBUNWIND_ABORT("mips_newabi float support not implemented");
3627#endif
3628}
3629
3630inline bool Registers_mips_newabi::validVectorRegister(int /* regNum */) const {
3631 return false;
3632}
3633
3634inline v128 Registers_mips_newabi::getVectorRegister(int /* regNum */) const {
3635 _LIBUNWIND_ABORT("mips_newabi vector support not implemented");
3636}
3637
3638inline void Registers_mips_newabi::setVectorRegister(int /* regNum */, v128 /* value */) {
3639 _LIBUNWIND_ABORT("mips_newabi vector support not implemented");
3640}
3641
3642inline const char *Registers_mips_newabi::getRegisterName(int regNum) {
3643 switch (regNum) {
3644 case UNW_MIPS_R0:
3645 return "$0";
3646 case UNW_MIPS_R1:
3647 return "$1";
3648 case UNW_MIPS_R2:
3649 return "$2";
3650 case UNW_MIPS_R3:
3651 return "$3";
3652 case UNW_MIPS_R4:
3653 return "$4";
3654 case UNW_MIPS_R5:
3655 return "$5";
3656 case UNW_MIPS_R6:
3657 return "$6";
3658 case UNW_MIPS_R7:
3659 return "$7";
3660 case UNW_MIPS_R8:
3661 return "$8";
3662 case UNW_MIPS_R9:
3663 return "$9";
3664 case UNW_MIPS_R10:
3665 return "$10";
3666 case UNW_MIPS_R11:
3667 return "$11";
3668 case UNW_MIPS_R12:
3669 return "$12";
3670 case UNW_MIPS_R13:
3671 return "$13";
3672 case UNW_MIPS_R14:
3673 return "$14";
3674 case UNW_MIPS_R15:
3675 return "$15";
3676 case UNW_MIPS_R16:
3677 return "$16";
3678 case UNW_MIPS_R17:
3679 return "$17";
3680 case UNW_MIPS_R18:
3681 return "$18";
3682 case UNW_MIPS_R19:
3683 return "$19";
3684 case UNW_MIPS_R20:
3685 return "$20";
3686 case UNW_MIPS_R21:
3687 return "$21";
3688 case UNW_MIPS_R22:
3689 return "$22";
3690 case UNW_MIPS_R23:
3691 return "$23";
3692 case UNW_MIPS_R24:
3693 return "$24";
3694 case UNW_MIPS_R25:
3695 return "$25";
3696 case UNW_MIPS_R26:
3697 return "$26";
3698 case UNW_MIPS_R27:
3699 return "$27";
3700 case UNW_MIPS_R28:
3701 return "$28";
3702 case UNW_MIPS_R29:
3703 return "$29";
3704 case UNW_MIPS_R30:
3705 return "$30";
3706 case UNW_MIPS_R31:
3707 return "$31";
3708 case UNW_MIPS_F0:
3709 return "$f0";
3710 case UNW_MIPS_F1:
3711 return "$f1";
3712 case UNW_MIPS_F2:
3713 return "$f2";
3714 case UNW_MIPS_F3:
3715 return "$f3";
3716 case UNW_MIPS_F4:
3717 return "$f4";
3718 case UNW_MIPS_F5:
3719 return "$f5";
3720 case UNW_MIPS_F6:
3721 return "$f6";
3722 case UNW_MIPS_F7:
3723 return "$f7";
3724 case UNW_MIPS_F8:
3725 return "$f8";
3726 case UNW_MIPS_F9:
3727 return "$f9";
3728 case UNW_MIPS_F10:
3729 return "$f10";
3730 case UNW_MIPS_F11:
3731 return "$f11";
3732 case UNW_MIPS_F12:
3733 return "$f12";
3734 case UNW_MIPS_F13:
3735 return "$f13";
3736 case UNW_MIPS_F14:
3737 return "$f14";
3738 case UNW_MIPS_F15:
3739 return "$f15";
3740 case UNW_MIPS_F16:
3741 return "$f16";
3742 case UNW_MIPS_F17:
3743 return "$f17";
3744 case UNW_MIPS_F18:
3745 return "$f18";
3746 case UNW_MIPS_F19:
3747 return "$f19";
3748 case UNW_MIPS_F20:
3749 return "$f20";
3750 case UNW_MIPS_F21:
3751 return "$f21";
3752 case UNW_MIPS_F22:
3753 return "$f22";
3754 case UNW_MIPS_F23:
3755 return "$f23";
3756 case UNW_MIPS_F24:
3757 return "$f24";
3758 case UNW_MIPS_F25:
3759 return "$f25";
3760 case UNW_MIPS_F26:
3761 return "$f26";
3762 case UNW_MIPS_F27:
3763 return "$f27";
3764 case UNW_MIPS_F28:
3765 return "$f28";
3766 case UNW_MIPS_F29:
3767 return "$f29";
3768 case UNW_MIPS_F30:
3769 return "$f30";
3770 case UNW_MIPS_F31:
3771 return "$f31";
3772#if __mips_isa_rev < 6
3773 case UNW_MIPS_HI:
3774 return "$hi";
3775 case UNW_MIPS_LO:
3776 return "$lo";
3777#endif
3778 default:
3779 return "unknown register";
3780 }
3781}
3782#endif // _LIBUNWIND_TARGET_MIPS_NEWABI
3783
3784#if defined(_LIBUNWIND_TARGET_SPARC)
3785/// Registers_sparc holds the register state of a thread in a 32-bit Sparc
3786/// process.
3787class _LIBUNWIND_HIDDEN Registers_sparc {
3788public:
3789 Registers_sparc();
3790 Registers_sparc(const void *registers);
3791
3792 typedef uint32_t reg_t;
3793 typedef uint32_t link_reg_t;
3794 typedef const link_reg_t &link_hardened_reg_arg_t;
3795
3796 bool validRegister(int num) const;
3797 uint32_t getRegister(int num) const;
3798 void setRegister(int num, uint32_t value);
3799 bool validFloatRegister(int num) const;
3800 double getFloatRegister(int num) const;
3801 void setFloatRegister(int num, double value);
3802 bool validVectorRegister(int num) const;
3803 v128 getVectorRegister(int num) const;
3804 void setVectorRegister(int num, v128 value);
3805 static const char *getRegisterName(int num);
3806 void jumpto();
3807 static constexpr int lastDwarfRegNum() {
3808 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_SPARC;
3809 }
3810 static int getArch() { return REGISTERS_SPARC; }
3811
3812 uint64_t getSP() const { return _registers.__regs[UNW_SPARC_O6]; }
3813 void setSP(uint32_t value) { _registers.__regs[UNW_SPARC_O6] = value; }
3814 uint64_t getIP() const { return _registers.__regs[UNW_SPARC_O7]; }
3815 void setIP(uint32_t value) { _registers.__regs[UNW_SPARC_O7] = value; }
3816
3817private:
3818 struct sparc_thread_state_t {
3819 unsigned int __regs[32];
3820 };
3821
3822 sparc_thread_state_t _registers;
3823};
3824
3825inline Registers_sparc::Registers_sparc(const void *registers) {
3826 static_assert((check_fit<Registers_sparc, unw_context_t>::does_fit),
3827 "sparc registers do not fit into unw_context_t");
3828 memcpy(&_registers, static_cast<const uint8_t *>(registers),
3829 sizeof(_registers));
3830}
3831
3832inline Registers_sparc::Registers_sparc() {
3833 memset(&_registers, 0, sizeof(_registers));
3834}
3835
3836inline bool Registers_sparc::validRegister(int regNum) const {
3837 if (regNum == UNW_REG_IP)
3838 return true;
3839 if (regNum == UNW_REG_SP)
3840 return true;
3841 if (regNum < 0)
3842 return false;
3843 if (regNum <= UNW_SPARC_I7)
3844 return true;
3845 return false;
3846}
3847
3848inline uint32_t Registers_sparc::getRegister(int regNum) const {
3849 if ((UNW_SPARC_G0 <= regNum) && (regNum <= UNW_SPARC_I7)) {
3850 return _registers.__regs[regNum];
3851 }
3852
3853 switch (regNum) {
3854 case UNW_REG_IP:
3855 return _registers.__regs[UNW_SPARC_O7];
3856 case UNW_REG_SP:
3857 return _registers.__regs[UNW_SPARC_O6];
3858 }
3859 _LIBUNWIND_ABORT("unsupported sparc register");
3860}
3861
3862inline void Registers_sparc::setRegister(int regNum, uint32_t value) {
3863 if ((UNW_SPARC_G0 <= regNum) && (regNum <= UNW_SPARC_I7)) {
3864 _registers.__regs[regNum] = value;
3865 return;
3866 }
3867
3868 switch (regNum) {
3869 case UNW_REG_IP:
3870 _registers.__regs[UNW_SPARC_O7] = value;
3871 return;
3872 case UNW_REG_SP:
3873 _registers.__regs[UNW_SPARC_O6] = value;
3874 return;
3875 }
3876 _LIBUNWIND_ABORT("unsupported sparc register");
3877}
3878
3879inline bool Registers_sparc::validFloatRegister(int) const { return false; }
3880
3881inline double Registers_sparc::getFloatRegister(int) const {
3882 _LIBUNWIND_ABORT("no sparc float registers");
3883}
3884
3885inline void Registers_sparc::setFloatRegister(int, double) {
3886 _LIBUNWIND_ABORT("no sparc float registers");
3887}
3888
3889inline bool Registers_sparc::validVectorRegister(int) const { return false; }
3890
3891inline v128 Registers_sparc::getVectorRegister(int) const {
3892 _LIBUNWIND_ABORT("no sparc vector registers");
3893}
3894
3895inline void Registers_sparc::setVectorRegister(int, v128) {
3896 _LIBUNWIND_ABORT("no sparc vector registers");
3897}
3898
3899inline const char *Registers_sparc::getRegisterName(int regNum) {
3900 switch (regNum) {
3901 case UNW_REG_IP:
3902 return "pc";
3903 case UNW_SPARC_G0:
3904 return "g0";
3905 case UNW_SPARC_G1:
3906 return "g1";
3907 case UNW_SPARC_G2:
3908 return "g2";
3909 case UNW_SPARC_G3:
3910 return "g3";
3911 case UNW_SPARC_G4:
3912 return "g4";
3913 case UNW_SPARC_G5:
3914 return "g5";
3915 case UNW_SPARC_G6:
3916 return "g6";
3917 case UNW_SPARC_G7:
3918 return "g7";
3919 case UNW_SPARC_O0:
3920 return "o0";
3921 case UNW_SPARC_O1:
3922 return "o1";
3923 case UNW_SPARC_O2:
3924 return "o2";
3925 case UNW_SPARC_O3:
3926 return "o3";
3927 case UNW_SPARC_O4:
3928 return "o4";
3929 case UNW_SPARC_O5:
3930 return "o5";
3931 case UNW_REG_SP:
3932 case UNW_SPARC_O6:
3933 return "sp";
3934 case UNW_SPARC_O7:
3935 return "o7";
3936 case UNW_SPARC_L0:
3937 return "l0";
3938 case UNW_SPARC_L1:
3939 return "l1";
3940 case UNW_SPARC_L2:
3941 return "l2";
3942 case UNW_SPARC_L3:
3943 return "l3";
3944 case UNW_SPARC_L4:
3945 return "l4";
3946 case UNW_SPARC_L5:
3947 return "l5";
3948 case UNW_SPARC_L6:
3949 return "l6";
3950 case UNW_SPARC_L7:
3951 return "l7";
3952 case UNW_SPARC_I0:
3953 return "i0";
3954 case UNW_SPARC_I1:
3955 return "i1";
3956 case UNW_SPARC_I2:
3957 return "i2";
3958 case UNW_SPARC_I3:
3959 return "i3";
3960 case UNW_SPARC_I4:
3961 return "i4";
3962 case UNW_SPARC_I5:
3963 return "i5";
3964 case UNW_SPARC_I6:
3965 return "fp";
3966 case UNW_SPARC_I7:
3967 return "i7";
3968 default:
3969 return "unknown register";
3970 }
3971}
3972#endif // _LIBUNWIND_TARGET_SPARC
3973
3974#if defined(_LIBUNWIND_TARGET_SPARC64)
3975/// Registers_sparc64 holds the register state of a thread in a 64-bit
3976/// sparc process.
3977class _LIBUNWIND_HIDDEN Registers_sparc64 {
3978public:
3979 Registers_sparc64() = default;
3980 Registers_sparc64(const void *registers);
3981
3982 typedef uint64_t reg_t;
3983 typedef uint64_t link_reg_t;
3984 typedef const link_reg_t &link_hardened_reg_arg_t;
3985
3986 bool validRegister(int num) const;
3987 uint64_t getRegister(int num) const;
3988 void setRegister(int num, uint64_t value);
3989 bool validFloatRegister(int num) const;
3990 double getFloatRegister(int num) const;
3991 void setFloatRegister(int num, double value);
3992 bool validVectorRegister(int num) const;
3993 v128 getVectorRegister(int num) const;
3994 void setVectorRegister(int num, v128 value);
3995 const char *getRegisterName(int num);
3996 void jumpto();
3997 static constexpr int lastDwarfRegNum() {
3998 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_SPARC64;
3999 }
4000 static int getArch() { return REGISTERS_SPARC64; }
4001
4002 uint64_t getSP() const { return _registers.__regs[UNW_SPARC_O6] + 2047; }
4003 void setSP(uint64_t value) { _registers.__regs[UNW_SPARC_O6] = value - 2047; }
4004 uint64_t getIP() const { return _registers.__regs[UNW_SPARC_O7]; }
4005 void setIP(uint64_t value) { _registers.__regs[UNW_SPARC_O7] = value; }
4006 uint64_t getWCookie() const { return _wcookie; }
4007
4008private:
4009 struct sparc64_thread_state_t {
4010 uint64_t __regs[32];
4011 };
4012
4013 sparc64_thread_state_t _registers{};
4014 uint64_t _wcookie = 0;
4015};
4016
4017inline Registers_sparc64::Registers_sparc64(const void *registers) {
4018 static_assert((check_fit<Registers_sparc64, unw_context_t>::does_fit),
4019 "sparc64 registers do not fit into unw_context_t");
4020 memcpy(&_registers, registers, sizeof(_registers));
4021 memcpy(&_wcookie,
4022 static_cast<const uint8_t *>(registers) + sizeof(_registers),
4023 sizeof(_wcookie));
4024}
4025
4026inline bool Registers_sparc64::validRegister(int regNum) const {
4027 if (regNum == UNW_REG_IP)
4028 return true;
4029 if (regNum == UNW_REG_SP)
4030 return true;
4031 if (regNum < 0)
4032 return false;
4033 if (regNum <= UNW_SPARC_I7)
4034 return true;
4035 return false;
4036}
4037
4038inline uint64_t Registers_sparc64::getRegister(int regNum) const {
4039 if (regNum >= UNW_SPARC_G0 && regNum <= UNW_SPARC_I7)
4040 return _registers.__regs[regNum];
4041
4042 switch (regNum) {
4043 case UNW_REG_IP:
4044 return _registers.__regs[UNW_SPARC_O7];
4045 case UNW_REG_SP:
4046 return _registers.__regs[UNW_SPARC_O6] + 2047;
4047 }
4048 _LIBUNWIND_ABORT("unsupported sparc64 register");
4049}
4050
4051inline void Registers_sparc64::setRegister(int regNum, uint64_t value) {
4052 if (regNum >= UNW_SPARC_G0 && regNum <= UNW_SPARC_I7) {
4053 _registers.__regs[regNum] = value;
4054 return;
4055 }
4056
4057 switch (regNum) {
4058 case UNW_REG_IP:
4059 _registers.__regs[UNW_SPARC_O7] = value;
4060 return;
4061 case UNW_REG_SP:
4062 _registers.__regs[UNW_SPARC_O6] = value - 2047;
4063 return;
4064 }
4065 _LIBUNWIND_ABORT("unsupported sparc64 register");
4066}
4067
4068inline bool Registers_sparc64::validFloatRegister(int) const { return false; }
4069
4070inline double Registers_sparc64::getFloatRegister(int) const {
4071 _LIBUNWIND_ABORT("no sparc64 float registers");
4072}
4073
4074inline void Registers_sparc64::setFloatRegister(int, double) {
4075 _LIBUNWIND_ABORT("no sparc64 float registers");
4076}
4077
4078inline bool Registers_sparc64::validVectorRegister(int) const { return false; }
4079
4080inline v128 Registers_sparc64::getVectorRegister(int) const {
4081 _LIBUNWIND_ABORT("no sparc64 vector registers");
4082}
4083
4084inline void Registers_sparc64::setVectorRegister(int, v128) {
4085 _LIBUNWIND_ABORT("no sparc64 vector registers");
4086}
4087
4088inline const char *Registers_sparc64::getRegisterName(int regNum) {
4089 switch (regNum) {
4090 case UNW_REG_IP:
4091 return "pc";
4092 case UNW_SPARC_G0:
4093 return "g0";
4094 case UNW_SPARC_G1:
4095 return "g1";
4096 case UNW_SPARC_G2:
4097 return "g2";
4098 case UNW_SPARC_G3:
4099 return "g3";
4100 case UNW_SPARC_G4:
4101 return "g4";
4102 case UNW_SPARC_G5:
4103 return "g5";
4104 case UNW_SPARC_G6:
4105 return "g6";
4106 case UNW_SPARC_G7:
4107 return "g7";
4108 case UNW_SPARC_O0:
4109 return "o0";
4110 case UNW_SPARC_O1:
4111 return "o1";
4112 case UNW_SPARC_O2:
4113 return "o2";
4114 case UNW_SPARC_O3:
4115 return "o3";
4116 case UNW_SPARC_O4:
4117 return "o4";
4118 case UNW_SPARC_O5:
4119 return "o5";
4120 case UNW_REG_SP:
4121 case UNW_SPARC_O6:
4122 return "o6";
4123 case UNW_SPARC_O7:
4124 return "o7";
4125 case UNW_SPARC_L0:
4126 return "l0";
4127 case UNW_SPARC_L1:
4128 return "l1";
4129 case UNW_SPARC_L2:
4130 return "l2";
4131 case UNW_SPARC_L3:
4132 return "l3";
4133 case UNW_SPARC_L4:
4134 return "l4";
4135 case UNW_SPARC_L5:
4136 return "l5";
4137 case UNW_SPARC_L6:
4138 return "l6";
4139 case UNW_SPARC_L7:
4140 return "l7";
4141 case UNW_SPARC_I0:
4142 return "i0";
4143 case UNW_SPARC_I1:
4144 return "i1";
4145 case UNW_SPARC_I2:
4146 return "i2";
4147 case UNW_SPARC_I3:
4148 return "i3";
4149 case UNW_SPARC_I4:
4150 return "i4";
4151 case UNW_SPARC_I5:
4152 return "i5";
4153 case UNW_SPARC_I6:
4154 return "i6";
4155 case UNW_SPARC_I7:
4156 return "i7";
4157 default:
4158 return "unknown register";
4159 }
4160}
4161#endif // _LIBUNWIND_TARGET_SPARC64
4162
4163#if defined(_LIBUNWIND_TARGET_HEXAGON)
4164/// Registers_hexagon holds the register state of a thread in a Hexagon QDSP6
4165/// process.
4166class _LIBUNWIND_HIDDEN Registers_hexagon {
4167public:
4168 Registers_hexagon();
4169 Registers_hexagon(const void *registers);
4170
4171 typedef uint32_t reg_t;
4172 typedef uint32_t link_reg_t;
4173 typedef const link_reg_t &link_hardened_reg_arg_t;
4174
4175 bool validRegister(int num) const;
4176 uint32_t getRegister(int num) const;
4177 void setRegister(int num, uint32_t value);
4178 bool validFloatRegister(int num) const;
4179 double getFloatRegister(int num) const;
4180 void setFloatRegister(int num, double value);
4181 bool validVectorRegister(int num) const;
4182 v128 getVectorRegister(int num) const;
4183 void setVectorRegister(int num, v128 value);
4184 const char *getRegisterName(int num);
4185 void jumpto();
4186 static constexpr int lastDwarfRegNum() {
4187 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_HEXAGON;
4188 }
4189 static int getArch() { return REGISTERS_HEXAGON; }
4190
4191 uint32_t getSP() const { return _registers.__r[UNW_HEXAGON_R29]; }
4192 void setSP(uint32_t value) { _registers.__r[UNW_HEXAGON_R29] = value; }
4193 uint32_t getIP() const { return _registers.__r[UNW_HEXAGON_PC]; }
4194 void setIP(uint32_t value) { _registers.__r[UNW_HEXAGON_PC] = value; }
4195
4196private:
4197 struct hexagon_thread_state_t {
4198 unsigned int __r[35];
4199 };
4200
4201 hexagon_thread_state_t _registers;
4202};
4203
4204inline Registers_hexagon::Registers_hexagon(const void *registers) {
4205 static_assert((check_fit<Registers_hexagon, unw_context_t>::does_fit),
4206 "hexagon registers do not fit into unw_context_t");
4207 memcpy(&_registers, static_cast<const uint8_t *>(registers),
4208 sizeof(_registers));
4209}
4210
4211inline Registers_hexagon::Registers_hexagon() {
4212 memset(&_registers, 0, sizeof(_registers));
4213}
4214
4215inline bool Registers_hexagon::validRegister(int regNum) const {
4216 if (regNum <= UNW_HEXAGON_R31)
4217 return true;
4218 return false;
4219}
4220
4221inline uint32_t Registers_hexagon::getRegister(int regNum) const {
4222 if (regNum >= UNW_HEXAGON_R0 && regNum <= UNW_HEXAGON_R31)
4223 return _registers.__r[regNum - UNW_HEXAGON_R0];
4224
4225 switch (regNum) {
4226 case UNW_REG_IP:
4227 return _registers.__r[UNW_HEXAGON_PC];
4228 case UNW_REG_SP:
4229 return _registers.__r[UNW_HEXAGON_R29];
4230 }
4231 _LIBUNWIND_ABORT("unsupported hexagon register");
4232}
4233
4234inline void Registers_hexagon::setRegister(int regNum, uint32_t value) {
4235 if (regNum >= UNW_HEXAGON_R0 && regNum <= UNW_HEXAGON_R31) {
4236 _registers.__r[regNum - UNW_HEXAGON_R0] = value;
4237 return;
4238 }
4239
4240 switch (regNum) {
4241 case UNW_REG_IP:
4242 _registers.__r[UNW_HEXAGON_PC] = value;
4243 return;
4244 case UNW_REG_SP:
4245 _registers.__r[UNW_HEXAGON_R29] = value;
4246 return;
4247 }
4248 _LIBUNWIND_ABORT("unsupported hexagon register");
4249}
4250
4251inline bool Registers_hexagon::validFloatRegister(int /* regNum */) const {
4252 return false;
4253}
4254
4255inline double Registers_hexagon::getFloatRegister(int /* regNum */) const {
4256 _LIBUNWIND_ABORT("hexagon float support not implemented");
4257}
4258
4259inline void Registers_hexagon::setFloatRegister(int /* regNum */,
4260 double /* value */) {
4261 _LIBUNWIND_ABORT("hexagon float support not implemented");
4262}
4263
4264inline bool Registers_hexagon::validVectorRegister(int /* regNum */) const {
4265 return false;
4266}
4267
4268inline v128 Registers_hexagon::getVectorRegister(int /* regNum */) const {
4269 _LIBUNWIND_ABORT("hexagon vector support not implemented");
4270}
4271
4272inline void Registers_hexagon::setVectorRegister(int /* regNum */, v128 /* value */) {
4273 _LIBUNWIND_ABORT("hexagon vector support not implemented");
4274}
4275
4276inline const char *Registers_hexagon::getRegisterName(int regNum) {
4277 switch (regNum) {
4278 case UNW_HEXAGON_R0:
4279 return "r0";
4280 case UNW_HEXAGON_R1:
4281 return "r1";
4282 case UNW_HEXAGON_R2:
4283 return "r2";
4284 case UNW_HEXAGON_R3:
4285 return "r3";
4286 case UNW_HEXAGON_R4:
4287 return "r4";
4288 case UNW_HEXAGON_R5:
4289 return "r5";
4290 case UNW_HEXAGON_R6:
4291 return "r6";
4292 case UNW_HEXAGON_R7:
4293 return "r7";
4294 case UNW_HEXAGON_R8:
4295 return "r8";
4296 case UNW_HEXAGON_R9:
4297 return "r9";
4298 case UNW_HEXAGON_R10:
4299 return "r10";
4300 case UNW_HEXAGON_R11:
4301 return "r11";
4302 case UNW_HEXAGON_R12:
4303 return "r12";
4304 case UNW_HEXAGON_R13:
4305 return "r13";
4306 case UNW_HEXAGON_R14:
4307 return "r14";
4308 case UNW_HEXAGON_R15:
4309 return "r15";
4310 case UNW_HEXAGON_R16:
4311 return "r16";
4312 case UNW_HEXAGON_R17:
4313 return "r17";
4314 case UNW_HEXAGON_R18:
4315 return "r18";
4316 case UNW_HEXAGON_R19:
4317 return "r19";
4318 case UNW_HEXAGON_R20:
4319 return "r20";
4320 case UNW_HEXAGON_R21:
4321 return "r21";
4322 case UNW_HEXAGON_R22:
4323 return "r22";
4324 case UNW_HEXAGON_R23:
4325 return "r23";
4326 case UNW_HEXAGON_R24:
4327 return "r24";
4328 case UNW_HEXAGON_R25:
4329 return "r25";
4330 case UNW_HEXAGON_R26:
4331 return "r26";
4332 case UNW_HEXAGON_R27:
4333 return "r27";
4334 case UNW_HEXAGON_R28:
4335 return "r28";
4336 case UNW_HEXAGON_R29:
4337 return "r29";
4338 case UNW_HEXAGON_R30:
4339 return "r30";
4340 case UNW_HEXAGON_R31:
4341 return "r31";
4342 default:
4343 return "unknown register";
4344 }
4345
4346}
4347#endif // _LIBUNWIND_TARGET_HEXAGON
4348
4349
4350#if defined(_LIBUNWIND_TARGET_RISCV)
4351/// Registers_riscv holds the register state of a thread in a RISC-V
4352/// process.
4353
4354// This check makes it safe when LIBUNWIND_ENABLE_CROSS_UNWINDING enabled.
4355# ifdef __riscv
4356# if __riscv_xlen == 32
4357typedef uint32_t reg_t;
4358# elif __riscv_xlen == 64
4359typedef uint64_t reg_t;
4360# else
4361# error "Unsupported __riscv_xlen"
4362# endif
4363
4364# if defined(__riscv_flen)
4365# if __riscv_flen == 64
4366typedef double fp_t;
4367# elif __riscv_flen == 32
4368typedef float fp_t;
4369# else
4370# error "Unsupported __riscv_flen"
4371# endif
4372# else
4373// This is just for suppressing undeclared error of fp_t.
4374typedef double fp_t;
4375# endif
4376# else
4377// Use Max possible width when cross unwinding
4378typedef uint64_t reg_t;
4379typedef double fp_t;
4380# define __riscv_xlen 64
4381# define __riscv_flen 64
4382#endif
4383
4384/// Registers_riscv holds the register state of a thread.
4385class _LIBUNWIND_HIDDEN Registers_riscv {
4386public:
4387 Registers_riscv();
4388 Registers_riscv(const void *registers);
4389
4390 typedef ::libunwind::reg_t reg_t;
4391 typedef ::libunwind::reg_t link_reg_t;
4392 typedef const link_reg_t &link_hardened_reg_arg_t;
4393
4394 bool validRegister(int num) const;
4395 reg_t getRegister(int num) const;
4396 void setRegister(int num, reg_t value);
4397 bool validFloatRegister(int num) const;
4398 fp_t getFloatRegister(int num) const;
4399 void setFloatRegister(int num, fp_t value);
4400 bool validVectorRegister(int num) const;
4401 v128 getVectorRegister(int num) const;
4402 void setVectorRegister(int num, v128 value);
4403 static const char *getRegisterName(int num);
4404 void jumpto();
4405 static constexpr int lastDwarfRegNum() {
4406 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_RISCV;
4407 }
4408 static int getArch() { return REGISTERS_RISCV; }
4409
4410 reg_t getSP() const { return _registers[2]; }
4411 void setSP(reg_t value) { _registers[2] = value; }
4412 reg_t getIP() const { return _registers[0]; }
4413 void setIP(reg_t value) { _registers[0] = value; }
4414
4415private:
4416 // _registers[0] holds the pc
4417 reg_t _registers[32];
4418# if defined(__riscv_flen)
4419 fp_t _floats[32];
4420# endif
4421};
4422
4423inline Registers_riscv::Registers_riscv(const void *registers) {
4424 static_assert((check_fit<Registers_riscv, unw_context_t>::does_fit),
4425 "riscv registers do not fit into unw_context_t");
4426 memcpy(&_registers, registers, sizeof(_registers));
4427# if __riscv_xlen == 32
4428 static_assert(sizeof(_registers) == 0x80,
4429 "expected float registers to be at offset 128");
4430# elif __riscv_xlen == 64
4431 static_assert(sizeof(_registers) == 0x100,
4432 "expected float registers to be at offset 256");
4433# else
4434# error "Unexpected float registers."
4435# endif
4436
4437# if defined(__riscv_flen)
4438 memcpy(_floats,
4439 static_cast<const uint8_t *>(registers) + sizeof(_registers),
4440 sizeof(_floats));
4441# endif
4442}
4443
4444inline Registers_riscv::Registers_riscv() {
4445 memset(&_registers, 0, sizeof(_registers));
4446# if defined(__riscv_flen)
4447 memset(&_floats, 0, sizeof(_floats));
4448# endif
4449}
4450
4451inline bool Registers_riscv::validRegister(int regNum) const {
4452 if (regNum == UNW_REG_IP)
4453 return true;
4454 if (regNum == UNW_REG_SP)
4455 return true;
4456 if (regNum < 0)
4457 return false;
4458 if (regNum == UNW_RISCV_VLENB)
4459 return true;
4460 if (regNum > UNW_RISCV_F31)
4461 return false;
4462 return true;
4463}
4464
4465inline reg_t Registers_riscv::getRegister(int regNum) const {
4466 if (regNum == UNW_REG_IP)
4467 return _registers[0];
4468 if (regNum == UNW_REG_SP)
4469 return _registers[2];
4470 if (regNum == UNW_RISCV_X0)
4471 return 0;
4472 if ((regNum > 0) && (regNum < 32))
4473 return _registers[regNum];
4474 if (regNum == UNW_RISCV_VLENB) {
4475 reg_t vlenb;
4476 __asm__ volatile("csrr %0, 0xC22" : "=r"(vlenb));
4477 return vlenb;
4478 }
4479 _LIBUNWIND_ABORT("unsupported riscv register");
4480}
4481
4482inline void Registers_riscv::setRegister(int regNum, reg_t value) {
4483 if (regNum == UNW_REG_IP)
4484 _registers[0] = value;
4485 else if (regNum == UNW_REG_SP)
4486 _registers[2] = value;
4487 else if (regNum == UNW_RISCV_X0)
4488 /* x0 is hardwired to zero */
4489 return;
4490 else if ((regNum > 0) && (regNum < 32))
4491 _registers[regNum] = value;
4492 else
4493 _LIBUNWIND_ABORT("unsupported riscv register");
4494}
4495
4496inline const char *Registers_riscv::getRegisterName(int regNum) {
4497 switch (regNum) {
4498 case UNW_REG_IP:
4499 return "pc";
4500 case UNW_REG_SP:
4501 return "sp";
4502 case UNW_RISCV_X0:
4503 return "zero";
4504 case UNW_RISCV_X1:
4505 return "ra";
4506 case UNW_RISCV_X2:
4507 return "sp";
4508 case UNW_RISCV_X3:
4509 return "gp";
4510 case UNW_RISCV_X4:
4511 return "tp";
4512 case UNW_RISCV_X5:
4513 return "t0";
4514 case UNW_RISCV_X6:
4515 return "t1";
4516 case UNW_RISCV_X7:
4517 return "t2";
4518 case UNW_RISCV_X8:
4519 return "s0";
4520 case UNW_RISCV_X9:
4521 return "s1";
4522 case UNW_RISCV_X10:
4523 return "a0";
4524 case UNW_RISCV_X11:
4525 return "a1";
4526 case UNW_RISCV_X12:
4527 return "a2";
4528 case UNW_RISCV_X13:
4529 return "a3";
4530 case UNW_RISCV_X14:
4531 return "a4";
4532 case UNW_RISCV_X15:
4533 return "a5";
4534 case UNW_RISCV_X16:
4535 return "a6";
4536 case UNW_RISCV_X17:
4537 return "a7";
4538 case UNW_RISCV_X18:
4539 return "s2";
4540 case UNW_RISCV_X19:
4541 return "s3";
4542 case UNW_RISCV_X20:
4543 return "s4";
4544 case UNW_RISCV_X21:
4545 return "s5";
4546 case UNW_RISCV_X22:
4547 return "s6";
4548 case UNW_RISCV_X23:
4549 return "s7";
4550 case UNW_RISCV_X24:
4551 return "s8";
4552 case UNW_RISCV_X25:
4553 return "s9";
4554 case UNW_RISCV_X26:
4555 return "s10";
4556 case UNW_RISCV_X27:
4557 return "s11";
4558 case UNW_RISCV_X28:
4559 return "t3";
4560 case UNW_RISCV_X29:
4561 return "t4";
4562 case UNW_RISCV_X30:
4563 return "t5";
4564 case UNW_RISCV_X31:
4565 return "t6";
4566 case UNW_RISCV_F0:
4567 return "ft0";
4568 case UNW_RISCV_F1:
4569 return "ft1";
4570 case UNW_RISCV_F2:
4571 return "ft2";
4572 case UNW_RISCV_F3:
4573 return "ft3";
4574 case UNW_RISCV_F4:
4575 return "ft4";
4576 case UNW_RISCV_F5:
4577 return "ft5";
4578 case UNW_RISCV_F6:
4579 return "ft6";
4580 case UNW_RISCV_F7:
4581 return "ft7";
4582 case UNW_RISCV_F8:
4583 return "fs0";
4584 case UNW_RISCV_F9:
4585 return "fs1";
4586 case UNW_RISCV_F10:
4587 return "fa0";
4588 case UNW_RISCV_F11:
4589 return "fa1";
4590 case UNW_RISCV_F12:
4591 return "fa2";
4592 case UNW_RISCV_F13:
4593 return "fa3";
4594 case UNW_RISCV_F14:
4595 return "fa4";
4596 case UNW_RISCV_F15:
4597 return "fa5";
4598 case UNW_RISCV_F16:
4599 return "fa6";
4600 case UNW_RISCV_F17:
4601 return "fa7";
4602 case UNW_RISCV_F18:
4603 return "fs2";
4604 case UNW_RISCV_F19:
4605 return "fs3";
4606 case UNW_RISCV_F20:
4607 return "fs4";
4608 case UNW_RISCV_F21:
4609 return "fs5";
4610 case UNW_RISCV_F22:
4611 return "fs6";
4612 case UNW_RISCV_F23:
4613 return "fs7";
4614 case UNW_RISCV_F24:
4615 return "fs8";
4616 case UNW_RISCV_F25:
4617 return "fs9";
4618 case UNW_RISCV_F26:
4619 return "fs10";
4620 case UNW_RISCV_F27:
4621 return "fs11";
4622 case UNW_RISCV_F28:
4623 return "ft8";
4624 case UNW_RISCV_F29:
4625 return "ft9";
4626 case UNW_RISCV_F30:
4627 return "ft10";
4628 case UNW_RISCV_F31:
4629 return "ft11";
4630 case UNW_RISCV_VLENB:
4631 return "vlenb";
4632 default:
4633 return "unknown register";
4634 }
4635}
4636
4637inline bool Registers_riscv::validFloatRegister(int regNum) const {
4638# if defined(__riscv_flen)
4639 if (regNum < UNW_RISCV_F0)
4640 return false;
4641 if (regNum > UNW_RISCV_F31)
4642 return false;
4643 return true;
4644# else
4645 (void)regNum;
4646 return false;
4647# endif
4648}
4649
4650inline fp_t Registers_riscv::getFloatRegister(int regNum) const {
4651# if defined(__riscv_flen)
4652 assert(validFloatRegister(regNum));
4653 return _floats[regNum - UNW_RISCV_F0];
4654# else
4655 (void)regNum;
4656 _LIBUNWIND_ABORT("libunwind not built with float support");
4657# endif
4658}
4659
4660inline void Registers_riscv::setFloatRegister(int regNum, fp_t value) {
4661# if defined(__riscv_flen)
4662 assert(validFloatRegister(regNum));
4663 _floats[regNum - UNW_RISCV_F0] = value;
4664# else
4665 (void)regNum;
4666 (void)value;
4667 _LIBUNWIND_ABORT("libunwind not built with float support");
4668# endif
4669}
4670
4671inline bool Registers_riscv::validVectorRegister(int) const {
4672 return false;
4673}
4674
4675inline v128 Registers_riscv::getVectorRegister(int) const {
4676 _LIBUNWIND_ABORT("no riscv vector register support yet");
4677}
4678
4679inline void Registers_riscv::setVectorRegister(int, v128) {
4680 _LIBUNWIND_ABORT("no riscv vector register support yet");
4681}
4682#endif // _LIBUNWIND_TARGET_RISCV
4683
4684#if defined(_LIBUNWIND_TARGET_VE)
4685/// Registers_ve holds the register state of a thread in a VE process.
4686class _LIBUNWIND_HIDDEN Registers_ve {
4687public:
4688 Registers_ve();
4689 Registers_ve(const void *registers);
4690
4691 typedef uint64_t reg_t;
4692 typedef uint64_t link_reg_t;
4693 typedef const link_reg_t &link_hardened_reg_arg_t;
4694
4695 bool validRegister(int num) const;
4696 uint64_t getRegister(int num) const;
4697 void setRegister(int num, uint64_t value);
4698 bool validFloatRegister(int num) const;
4699 double getFloatRegister(int num) const;
4700 void setFloatRegister(int num, double value);
4701 bool validVectorRegister(int num) const;
4702 v128 getVectorRegister(int num) const;
4703 void setVectorRegister(int num, v128 value);
4704 static const char *getRegisterName(int num);
4705 void jumpto();
4706 static constexpr int lastDwarfRegNum() {
4707 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_VE;
4708 }
4709 static int getArch() { return REGISTERS_VE; }
4710
4711 uint64_t getSP() const { return _registers.__s[11]; }
4712 void setSP(uint64_t value) { _registers.__s[11] = value; }
4713 uint64_t getIP() const { return _registers.__ic; }
4714 void setIP(uint64_t value) { _registers.__ic = value; }
4715
4716private:
4717 // FIXME: Need to store not only scalar registers but also vector and vector
4718 // mask registers. VEOS uses mcontext_t defined in ucontext.h. It takes
4719 // 524288 bytes (65536*8 bytes), though. Currently, we use libunwind for
4720 // SjLj exception support only, so Registers_ve is not implemented completely.
4721 struct ve_thread_state_t {
4722 uint64_t __s[64]; // s0-s64
4723 uint64_t __ic; // Instruction counter (IC)
4724 uint64_t __vixr; // Vector Index Register
4725 uint64_t __vl; // Vector Length Register
4726 };
4727
4728 ve_thread_state_t _registers; // total 67 registers
4729
4730 // Currently no vector register is preserved.
4731};
4732
4733inline Registers_ve::Registers_ve(const void *registers) {
4734 static_assert((check_fit<Registers_ve, unw_context_t>::does_fit),
4735 "ve registers do not fit into unw_context_t");
4736 memcpy(&_registers, static_cast<const uint8_t *>(registers),
4737 sizeof(_registers));
4738 static_assert(sizeof(_registers) == 536,
4739 "expected vector register offset to be 536");
4740}
4741
4742inline Registers_ve::Registers_ve() {
4743 memset(&_registers, 0, sizeof(_registers));
4744}
4745
4746inline bool Registers_ve::validRegister(int regNum) const {
4747 if (regNum >= UNW_VE_S0 && regNum <= UNW_VE_S63)
4748 return true;
4749
4750 switch (regNum) {
4751 case UNW_REG_IP:
4752 case UNW_REG_SP:
4753 case UNW_VE_VIXR:
4754 case UNW_VE_VL:
4755 return true;
4756 default:
4757 return false;
4758 }
4759}
4760
4761inline uint64_t Registers_ve::getRegister(int regNum) const {
4762 if (regNum >= UNW_VE_S0 && regNum <= UNW_VE_S63)
4763 return _registers.__s[regNum - UNW_VE_S0];
4764
4765 switch (regNum) {
4766 case UNW_REG_IP:
4767 return _registers.__ic;
4768 case UNW_REG_SP:
4769 return _registers.__s[11];
4770 case UNW_VE_VIXR:
4771 return _registers.__vixr;
4772 case UNW_VE_VL:
4773 return _registers.__vl;
4774 }
4775 _LIBUNWIND_ABORT("unsupported ve register");
4776}
4777
4778inline void Registers_ve::setRegister(int regNum, uint64_t value) {
4779 if (regNum >= UNW_VE_S0 && regNum <= UNW_VE_S63) {
4780 _registers.__s[regNum - UNW_VE_S0] = value;
4781 return;
4782 }
4783
4784 switch (regNum) {
4785 case UNW_REG_IP:
4786 _registers.__ic = value;
4787 return;
4788 case UNW_REG_SP:
4789 _registers.__s[11] = value;
4790 return;
4791 case UNW_VE_VIXR:
4792 _registers.__vixr = value;
4793 return;
4794 case UNW_VE_VL:
4795 _registers.__vl = value;
4796 return;
4797 }
4798 _LIBUNWIND_ABORT("unsupported ve register");
4799}
4800
4801inline bool Registers_ve::validFloatRegister(int /* regNum */) const {
4802 return false;
4803}
4804
4805inline double Registers_ve::getFloatRegister(int /* regNum */) const {
4806 _LIBUNWIND_ABORT("VE doesn't have float registers");
4807}
4808
4809inline void Registers_ve::setFloatRegister(int /* regNum */,
4810 double /* value */) {
4811 _LIBUNWIND_ABORT("VE doesn't have float registers");
4812}
4813
4814inline bool Registers_ve::validVectorRegister(int /* regNum */) const {
4815 return false;
4816}
4817
4818inline v128 Registers_ve::getVectorRegister(int /* regNum */) const {
4819 _LIBUNWIND_ABORT("VE vector support not implemented");
4820}
4821
4822inline void Registers_ve::setVectorRegister(int /* regNum */,
4823 v128 /* value */) {
4824 _LIBUNWIND_ABORT("VE vector support not implemented");
4825}
4826
4827inline const char *Registers_ve::getRegisterName(int regNum) {
4828 switch (regNum) {
4829 case UNW_REG_IP:
4830 return "ip";
4831 case UNW_REG_SP:
4832 return "sp";
4833 case UNW_VE_VIXR:
4834 return "vixr";
4835 case UNW_VE_VL:
4836 return "vl";
4837 case UNW_VE_S0:
4838 return "s0";
4839 case UNW_VE_S1:
4840 return "s1";
4841 case UNW_VE_S2:
4842 return "s2";
4843 case UNW_VE_S3:
4844 return "s3";
4845 case UNW_VE_S4:
4846 return "s4";
4847 case UNW_VE_S5:
4848 return "s5";
4849 case UNW_VE_S6:
4850 return "s6";
4851 case UNW_VE_S7:
4852 return "s7";
4853 case UNW_VE_S8:
4854 return "s8";
4855 case UNW_VE_S9:
4856 return "s9";
4857 case UNW_VE_S10:
4858 return "s10";
4859 case UNW_VE_S11:
4860 return "s11";
4861 case UNW_VE_S12:
4862 return "s12";
4863 case UNW_VE_S13:
4864 return "s13";
4865 case UNW_VE_S14:
4866 return "s14";
4867 case UNW_VE_S15:
4868 return "s15";
4869 case UNW_VE_S16:
4870 return "s16";
4871 case UNW_VE_S17:
4872 return "s17";
4873 case UNW_VE_S18:
4874 return "s18";
4875 case UNW_VE_S19:
4876 return "s19";
4877 case UNW_VE_S20:
4878 return "s20";
4879 case UNW_VE_S21:
4880 return "s21";
4881 case UNW_VE_S22:
4882 return "s22";
4883 case UNW_VE_S23:
4884 return "s23";
4885 case UNW_VE_S24:
4886 return "s24";
4887 case UNW_VE_S25:
4888 return "s25";
4889 case UNW_VE_S26:
4890 return "s26";
4891 case UNW_VE_S27:
4892 return "s27";
4893 case UNW_VE_S28:
4894 return "s28";
4895 case UNW_VE_S29:
4896 return "s29";
4897 case UNW_VE_S30:
4898 return "s30";
4899 case UNW_VE_S31:
4900 return "s31";
4901 case UNW_VE_S32:
4902 return "s32";
4903 case UNW_VE_S33:
4904 return "s33";
4905 case UNW_VE_S34:
4906 return "s34";
4907 case UNW_VE_S35:
4908 return "s35";
4909 case UNW_VE_S36:
4910 return "s36";
4911 case UNW_VE_S37:
4912 return "s37";
4913 case UNW_VE_S38:
4914 return "s38";
4915 case UNW_VE_S39:
4916 return "s39";
4917 case UNW_VE_S40:
4918 return "s40";
4919 case UNW_VE_S41:
4920 return "s41";
4921 case UNW_VE_S42:
4922 return "s42";
4923 case UNW_VE_S43:
4924 return "s43";
4925 case UNW_VE_S44:
4926 return "s44";
4927 case UNW_VE_S45:
4928 return "s45";
4929 case UNW_VE_S46:
4930 return "s46";
4931 case UNW_VE_S47:
4932 return "s47";
4933 case UNW_VE_S48:
4934 return "s48";
4935 case UNW_VE_S49:
4936 return "s49";
4937 case UNW_VE_S50:
4938 return "s50";
4939 case UNW_VE_S51:
4940 return "s51";
4941 case UNW_VE_S52:
4942 return "s52";
4943 case UNW_VE_S53:
4944 return "s53";
4945 case UNW_VE_S54:
4946 return "s54";
4947 case UNW_VE_S55:
4948 return "s55";
4949 case UNW_VE_S56:
4950 return "s56";
4951 case UNW_VE_S57:
4952 return "s57";
4953 case UNW_VE_S58:
4954 return "s58";
4955 case UNW_VE_S59:
4956 return "s59";
4957 case UNW_VE_S60:
4958 return "s60";
4959 case UNW_VE_S61:
4960 return "s61";
4961 case UNW_VE_S62:
4962 return "s62";
4963 case UNW_VE_S63:
4964 return "s63";
4965 case UNW_VE_V0:
4966 return "v0";
4967 case UNW_VE_V1:
4968 return "v1";
4969 case UNW_VE_V2:
4970 return "v2";
4971 case UNW_VE_V3:
4972 return "v3";
4973 case UNW_VE_V4:
4974 return "v4";
4975 case UNW_VE_V5:
4976 return "v5";
4977 case UNW_VE_V6:
4978 return "v6";
4979 case UNW_VE_V7:
4980 return "v7";
4981 case UNW_VE_V8:
4982 return "v8";
4983 case UNW_VE_V9:
4984 return "v9";
4985 case UNW_VE_V10:
4986 return "v10";
4987 case UNW_VE_V11:
4988 return "v11";
4989 case UNW_VE_V12:
4990 return "v12";
4991 case UNW_VE_V13:
4992 return "v13";
4993 case UNW_VE_V14:
4994 return "v14";
4995 case UNW_VE_V15:
4996 return "v15";
4997 case UNW_VE_V16:
4998 return "v16";
4999 case UNW_VE_V17:
5000 return "v17";
5001 case UNW_VE_V18:
5002 return "v18";
5003 case UNW_VE_V19:
5004 return "v19";
5005 case UNW_VE_V20:
5006 return "v20";
5007 case UNW_VE_V21:
5008 return "v21";
5009 case UNW_VE_V22:
5010 return "v22";
5011 case UNW_VE_V23:
5012 return "v23";
5013 case UNW_VE_V24:
5014 return "v24";
5015 case UNW_VE_V25:
5016 return "v25";
5017 case UNW_VE_V26:
5018 return "v26";
5019 case UNW_VE_V27:
5020 return "v27";
5021 case UNW_VE_V28:
5022 return "v28";
5023 case UNW_VE_V29:
5024 return "v29";
5025 case UNW_VE_V30:
5026 return "v30";
5027 case UNW_VE_V31:
5028 return "v31";
5029 case UNW_VE_V32:
5030 return "v32";
5031 case UNW_VE_V33:
5032 return "v33";
5033 case UNW_VE_V34:
5034 return "v34";
5035 case UNW_VE_V35:
5036 return "v35";
5037 case UNW_VE_V36:
5038 return "v36";
5039 case UNW_VE_V37:
5040 return "v37";
5041 case UNW_VE_V38:
5042 return "v38";
5043 case UNW_VE_V39:
5044 return "v39";
5045 case UNW_VE_V40:
5046 return "v40";
5047 case UNW_VE_V41:
5048 return "v41";
5049 case UNW_VE_V42:
5050 return "v42";
5051 case UNW_VE_V43:
5052 return "v43";
5053 case UNW_VE_V44:
5054 return "v44";
5055 case UNW_VE_V45:
5056 return "v45";
5057 case UNW_VE_V46:
5058 return "v46";
5059 case UNW_VE_V47:
5060 return "v47";
5061 case UNW_VE_V48:
5062 return "v48";
5063 case UNW_VE_V49:
5064 return "v49";
5065 case UNW_VE_V50:
5066 return "v50";
5067 case UNW_VE_V51:
5068 return "v51";
5069 case UNW_VE_V52:
5070 return "v52";
5071 case UNW_VE_V53:
5072 return "v53";
5073 case UNW_VE_V54:
5074 return "v54";
5075 case UNW_VE_V55:
5076 return "v55";
5077 case UNW_VE_V56:
5078 return "v56";
5079 case UNW_VE_V57:
5080 return "v57";
5081 case UNW_VE_V58:
5082 return "v58";
5083 case UNW_VE_V59:
5084 return "v59";
5085 case UNW_VE_V60:
5086 return "v60";
5087 case UNW_VE_V61:
5088 return "v61";
5089 case UNW_VE_V62:
5090 return "v62";
5091 case UNW_VE_V63:
5092 return "v63";
5093 case UNW_VE_VM0:
5094 return "vm0";
5095 case UNW_VE_VM1:
5096 return "vm1";
5097 case UNW_VE_VM2:
5098 return "vm2";
5099 case UNW_VE_VM3:
5100 return "vm3";
5101 case UNW_VE_VM4:
5102 return "vm4";
5103 case UNW_VE_VM5:
5104 return "vm5";
5105 case UNW_VE_VM6:
5106 return "vm6";
5107 case UNW_VE_VM7:
5108 return "vm7";
5109 case UNW_VE_VM8:
5110 return "vm8";
5111 case UNW_VE_VM9:
5112 return "vm9";
5113 case UNW_VE_VM10:
5114 return "vm10";
5115 case UNW_VE_VM11:
5116 return "vm11";
5117 case UNW_VE_VM12:
5118 return "vm12";
5119 case UNW_VE_VM13:
5120 return "vm13";
5121 case UNW_VE_VM14:
5122 return "vm14";
5123 case UNW_VE_VM15:
5124 return "vm15";
5125 }
5126 return "unknown register";
5127}
5128#endif // _LIBUNWIND_TARGET_VE
5129
5130#if defined(_LIBUNWIND_TARGET_S390X)
5131/// Registers_s390x holds the register state of a thread in a
5132/// 64-bit Linux on IBM zSystems process.
5133class _LIBUNWIND_HIDDEN Registers_s390x {
5134public:
5135 Registers_s390x();
5136 Registers_s390x(const void *registers);
5137
5138 typedef uint64_t reg_t;
5139 typedef uint64_t link_reg_t;
5140 typedef const link_reg_t &link_hardened_reg_arg_t;
5141
5142 bool validRegister(int num) const;
5143 uint64_t getRegister(int num) const;
5144 void setRegister(int num, uint64_t value);
5145 bool validFloatRegister(int num) const;
5146 double getFloatRegister(int num) const;
5147 void setFloatRegister(int num, double value);
5148 bool validVectorRegister(int num) const;
5149 v128 getVectorRegister(int num) const;
5150 void setVectorRegister(int num, v128 value);
5151 static const char *getRegisterName(int num);
5152 void jumpto();
5153 static constexpr int lastDwarfRegNum() {
5154 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_S390X;
5155 }
5156 static int getArch() { return REGISTERS_S390X; }
5157
5158 uint64_t getSP() const { return _registers.__gpr[15]; }
5159 void setSP(uint64_t value) { _registers.__gpr[15] = value; }
5160 uint64_t getIP() const { return _registers.__pswa; }
5161 void setIP(uint64_t value) { _registers.__pswa = value; }
5162
5163private:
5164 struct s390x_thread_state_t {
5165 uint64_t __pswm; // Problem Status Word: Mask
5166 uint64_t __pswa; // Problem Status Word: Address (PC)
5167 uint64_t __gpr[16]; // General Purpose Registers
5168 double __fpr[16]; // Floating-Point Registers
5169 };
5170
5171 s390x_thread_state_t _registers;
5172};
5173
5174inline Registers_s390x::Registers_s390x(const void *registers) {
5175 static_assert((check_fit<Registers_s390x, unw_context_t>::does_fit),
5176 "s390x registers do not fit into unw_context_t");
5177 memcpy(&_registers, static_cast<const uint8_t *>(registers),
5178 sizeof(_registers));
5179}
5180
5181inline Registers_s390x::Registers_s390x() {
5182 memset(&_registers, 0, sizeof(_registers));
5183}
5184
5185inline bool Registers_s390x::validRegister(int regNum) const {
5186 switch (regNum) {
5187 case UNW_S390X_PSWM:
5188 case UNW_S390X_PSWA:
5189 case UNW_REG_IP:
5190 case UNW_REG_SP:
5191 return true;
5192 }
5193
5194 if (regNum >= UNW_S390X_R0 && regNum <= UNW_S390X_R15)
5195 return true;
5196
5197 return false;
5198}
5199
5200inline uint64_t Registers_s390x::getRegister(int regNum) const {
5201 if (regNum >= UNW_S390X_R0 && regNum <= UNW_S390X_R15)
5202 return _registers.__gpr[regNum - UNW_S390X_R0];
5203
5204 switch (regNum) {
5205 case UNW_S390X_PSWM:
5206 return _registers.__pswm;
5207 case UNW_S390X_PSWA:
5208 case UNW_REG_IP:
5209 return _registers.__pswa;
5210 case UNW_REG_SP:
5211 return _registers.__gpr[15];
5212 }
5213 _LIBUNWIND_ABORT("unsupported s390x register");
5214}
5215
5216inline void Registers_s390x::setRegister(int regNum, uint64_t value) {
5217 if (regNum >= UNW_S390X_R0 && regNum <= UNW_S390X_R15) {
5218 _registers.__gpr[regNum - UNW_S390X_R0] = value;
5219 return;
5220 }
5221
5222 switch (regNum) {
5223 case UNW_S390X_PSWM:
5224 _registers.__pswm = value;
5225 return;
5226 case UNW_S390X_PSWA:
5227 case UNW_REG_IP:
5228 _registers.__pswa = value;
5229 return;
5230 case UNW_REG_SP:
5231 _registers.__gpr[15] = value;
5232 return;
5233 }
5234 _LIBUNWIND_ABORT("unsupported s390x register");
5235}
5236
5237inline bool Registers_s390x::validFloatRegister(int regNum) const {
5238 return regNum >= UNW_S390X_F0 && regNum <= UNW_S390X_F15;
5239}
5240
5241inline double Registers_s390x::getFloatRegister(int regNum) const {
5242 // NOTE: FPR DWARF register numbers are not consecutive.
5243 switch (regNum) {
5244 case UNW_S390X_F0:
5245 return _registers.__fpr[0];
5246 case UNW_S390X_F1:
5247 return _registers.__fpr[1];
5248 case UNW_S390X_F2:
5249 return _registers.__fpr[2];
5250 case UNW_S390X_F3:
5251 return _registers.__fpr[3];
5252 case UNW_S390X_F4:
5253 return _registers.__fpr[4];
5254 case UNW_S390X_F5:
5255 return _registers.__fpr[5];
5256 case UNW_S390X_F6:
5257 return _registers.__fpr[6];
5258 case UNW_S390X_F7:
5259 return _registers.__fpr[7];
5260 case UNW_S390X_F8:
5261 return _registers.__fpr[8];
5262 case UNW_S390X_F9:
5263 return _registers.__fpr[9];
5264 case UNW_S390X_F10:
5265 return _registers.__fpr[10];
5266 case UNW_S390X_F11:
5267 return _registers.__fpr[11];
5268 case UNW_S390X_F12:
5269 return _registers.__fpr[12];
5270 case UNW_S390X_F13:
5271 return _registers.__fpr[13];
5272 case UNW_S390X_F14:
5273 return _registers.__fpr[14];
5274 case UNW_S390X_F15:
5275 return _registers.__fpr[15];
5276 }
5277 _LIBUNWIND_ABORT("unsupported s390x register");
5278}
5279
5280inline void Registers_s390x::setFloatRegister(int regNum, double value) {
5281 // NOTE: FPR DWARF register numbers are not consecutive.
5282 switch (regNum) {
5283 case UNW_S390X_F0:
5284 _registers.__fpr[0] = value;
5285 return;
5286 case UNW_S390X_F1:
5287 _registers.__fpr[1] = value;
5288 return;
5289 case UNW_S390X_F2:
5290 _registers.__fpr[2] = value;
5291 return;
5292 case UNW_S390X_F3:
5293 _registers.__fpr[3] = value;
5294 return;
5295 case UNW_S390X_F4:
5296 _registers.__fpr[4] = value;
5297 return;
5298 case UNW_S390X_F5:
5299 _registers.__fpr[5] = value;
5300 return;
5301 case UNW_S390X_F6:
5302 _registers.__fpr[6] = value;
5303 return;
5304 case UNW_S390X_F7:
5305 _registers.__fpr[7] = value;
5306 return;
5307 case UNW_S390X_F8:
5308 _registers.__fpr[8] = value;
5309 return;
5310 case UNW_S390X_F9:
5311 _registers.__fpr[9] = value;
5312 return;
5313 case UNW_S390X_F10:
5314 _registers.__fpr[10] = value;
5315 return;
5316 case UNW_S390X_F11:
5317 _registers.__fpr[11] = value;
5318 return;
5319 case UNW_S390X_F12:
5320 _registers.__fpr[12] = value;
5321 return;
5322 case UNW_S390X_F13:
5323 _registers.__fpr[13] = value;
5324 return;
5325 case UNW_S390X_F14:
5326 _registers.__fpr[14] = value;
5327 return;
5328 case UNW_S390X_F15:
5329 _registers.__fpr[15] = value;
5330 return;
5331 }
5332 _LIBUNWIND_ABORT("unsupported s390x register");
5333}
5334
5335inline bool Registers_s390x::validVectorRegister(int /*regNum*/) const {
5336 return false;
5337}
5338
5339inline v128 Registers_s390x::getVectorRegister(int /*regNum*/) const {
5340 _LIBUNWIND_ABORT("s390x vector support not implemented");
5341}
5342
5343inline void Registers_s390x::setVectorRegister(int /*regNum*/, v128 /*value*/) {
5344 _LIBUNWIND_ABORT("s390x vector support not implemented");
5345}
5346
5347inline const char *Registers_s390x::getRegisterName(int regNum) {
5348 switch (regNum) {
5349 case UNW_REG_IP:
5350 return "ip";
5351 case UNW_REG_SP:
5352 return "sp";
5353 case UNW_S390X_R0:
5354 return "r0";
5355 case UNW_S390X_R1:
5356 return "r1";
5357 case UNW_S390X_R2:
5358 return "r2";
5359 case UNW_S390X_R3:
5360 return "r3";
5361 case UNW_S390X_R4:
5362 return "r4";
5363 case UNW_S390X_R5:
5364 return "r5";
5365 case UNW_S390X_R6:
5366 return "r6";
5367 case UNW_S390X_R7:
5368 return "r7";
5369 case UNW_S390X_R8:
5370 return "r8";
5371 case UNW_S390X_R9:
5372 return "r9";
5373 case UNW_S390X_R10:
5374 return "r10";
5375 case UNW_S390X_R11:
5376 return "r11";
5377 case UNW_S390X_R12:
5378 return "r12";
5379 case UNW_S390X_R13:
5380 return "r13";
5381 case UNW_S390X_R14:
5382 return "r14";
5383 case UNW_S390X_R15:
5384 return "r15";
5385 case UNW_S390X_F0:
5386 return "f0";
5387 case UNW_S390X_F1:
5388 return "f1";
5389 case UNW_S390X_F2:
5390 return "f2";
5391 case UNW_S390X_F3:
5392 return "f3";
5393 case UNW_S390X_F4:
5394 return "f4";
5395 case UNW_S390X_F5:
5396 return "f5";
5397 case UNW_S390X_F6:
5398 return "f6";
5399 case UNW_S390X_F7:
5400 return "f7";
5401 case UNW_S390X_F8:
5402 return "f8";
5403 case UNW_S390X_F9:
5404 return "f9";
5405 case UNW_S390X_F10:
5406 return "f10";
5407 case UNW_S390X_F11:
5408 return "f11";
5409 case UNW_S390X_F12:
5410 return "f12";
5411 case UNW_S390X_F13:
5412 return "f13";
5413 case UNW_S390X_F14:
5414 return "f14";
5415 case UNW_S390X_F15:
5416 return "f15";
5417 }
5418 return "unknown register";
5419}
5420#endif // _LIBUNWIND_TARGET_S390X
5421
5422#if defined(_LIBUNWIND_TARGET_LOONGARCH)
5423/// Registers_loongarch holds the register state of a thread in a 64-bit
5424/// LoongArch process.
5425class _LIBUNWIND_HIDDEN Registers_loongarch {
5426public:
5427 Registers_loongarch();
5428 Registers_loongarch(const void *registers);
5429
5430 typedef uint64_t reg_t;
5431 typedef uint64_t link_reg_t;
5432 typedef const link_reg_t &link_hardened_reg_arg_t;
5433
5434 bool validRegister(int num) const;
5435 uint64_t getRegister(int num) const;
5436 void setRegister(int num, uint64_t value);
5437 bool validFloatRegister(int num) const;
5438 double getFloatRegister(int num) const;
5439 void setFloatRegister(int num, double value);
5440 bool validVectorRegister(int num) const;
5441 v128 getVectorRegister(int num) const;
5442 void setVectorRegister(int num, v128 value);
5443 static const char *getRegisterName(int num);
5444 void jumpto();
5445 static constexpr int lastDwarfRegNum() {
5446 return _LIBUNWIND_HIGHEST_DWARF_REGISTER_LOONGARCH;
5447 }
5448 static int getArch() { return REGISTERS_LOONGARCH; }
5449
5450 uint64_t getSP() const { return _registers.__r[3]; }
5451 void setSP(uint64_t value) { _registers.__r[3] = value; }
5452 uint64_t getIP() const { return _registers.__pc; }
5453 void setIP(uint64_t value) { _registers.__pc = value; }
5454
5455private:
5456 struct loongarch_thread_state_t {
5457 uint64_t __r[32];
5458 uint64_t __pc;
5459 };
5460
5461 loongarch_thread_state_t _registers;
5462#if __loongarch_frlen == 64
5463 double _floats[32];
5464#endif
5465};
5466
5467inline Registers_loongarch::Registers_loongarch(const void *registers) {
5468 static_assert((check_fit<Registers_loongarch, unw_context_t>::does_fit),
5469 "loongarch registers do not fit into unw_context_t");
5470 memcpy(&_registers, registers, sizeof(_registers));
5471 static_assert(sizeof(_registers) == 0x108,
5472 "expected float registers to be at offset 264");
5473#if __loongarch_frlen == 64
5474 memcpy(_floats, static_cast<const uint8_t *>(registers) + sizeof(_registers),
5475 sizeof(_floats));
5476#endif
5477}
5478
5479inline Registers_loongarch::Registers_loongarch() {
5480 memset(&_registers, 0, sizeof(_registers));
5481#if __loongarch_frlen == 64
5482 memset(&_floats, 0, sizeof(_floats));
5483#endif
5484}
5485
5486inline bool Registers_loongarch::validRegister(int regNum) const {
5487 if (regNum == UNW_REG_IP || regNum == UNW_REG_SP)
5488 return true;
5489 if (regNum < 0 || regNum > UNW_LOONGARCH_F31)
5490 return false;
5491 return true;
5492}
5493
5494inline uint64_t Registers_loongarch::getRegister(int regNum) const {
5495 if (regNum >= UNW_LOONGARCH_R0 && regNum <= UNW_LOONGARCH_R31)
5496 return _registers.__r[regNum - UNW_LOONGARCH_R0];
5497
5498 if (regNum == UNW_REG_IP)
5499 return _registers.__pc;
5500 if (regNum == UNW_REG_SP)
5501 return _registers.__r[3];
5502 _LIBUNWIND_ABORT("unsupported loongarch register");
5503}
5504
5505inline void Registers_loongarch::setRegister(int regNum, uint64_t value) {
5506 if (regNum >= UNW_LOONGARCH_R0 && regNum <= UNW_LOONGARCH_R31)
5507 _registers.__r[regNum - UNW_LOONGARCH_R0] = value;
5508 else if (regNum == UNW_REG_IP)
5509 _registers.__pc = value;
5510 else if (regNum == UNW_REG_SP)
5511 _registers.__r[3] = value;
5512 else
5513 _LIBUNWIND_ABORT("unsupported loongarch register");
5514}
5515
5516inline const char *Registers_loongarch::getRegisterName(int regNum) {
5517 switch (regNum) {
5518 case UNW_REG_IP:
5519 return "$pc";
5520 case UNW_REG_SP:
5521 return "$sp";
5522 case UNW_LOONGARCH_R0:
5523 return "$r0";
5524 case UNW_LOONGARCH_R1:
5525 return "$r1";
5526 case UNW_LOONGARCH_R2:
5527 return "$r2";
5528 case UNW_LOONGARCH_R3:
5529 return "$r3";
5530 case UNW_LOONGARCH_R4:
5531 return "$r4";
5532 case UNW_LOONGARCH_R5:
5533 return "$r5";
5534 case UNW_LOONGARCH_R6:
5535 return "$r6";
5536 case UNW_LOONGARCH_R7:
5537 return "$r7";
5538 case UNW_LOONGARCH_R8:
5539 return "$r8";
5540 case UNW_LOONGARCH_R9:
5541 return "$r9";
5542 case UNW_LOONGARCH_R10:
5543 return "$r10";
5544 case UNW_LOONGARCH_R11:
5545 return "$r11";
5546 case UNW_LOONGARCH_R12:
5547 return "$r12";
5548 case UNW_LOONGARCH_R13:
5549 return "$r13";
5550 case UNW_LOONGARCH_R14:
5551 return "$r14";
5552 case UNW_LOONGARCH_R15:
5553 return "$r15";
5554 case UNW_LOONGARCH_R16:
5555 return "$r16";
5556 case UNW_LOONGARCH_R17:
5557 return "$r17";
5558 case UNW_LOONGARCH_R18:
5559 return "$r18";
5560 case UNW_LOONGARCH_R19:
5561 return "$r19";
5562 case UNW_LOONGARCH_R20:
5563 return "$r20";
5564 case UNW_LOONGARCH_R21:
5565 return "$r21";
5566 case UNW_LOONGARCH_R22:
5567 return "$r22";
5568 case UNW_LOONGARCH_R23:
5569 return "$r23";
5570 case UNW_LOONGARCH_R24:
5571 return "$r24";
5572 case UNW_LOONGARCH_R25:
5573 return "$r25";
5574 case UNW_LOONGARCH_R26:
5575 return "$r26";
5576 case UNW_LOONGARCH_R27:
5577 return "$r27";
5578 case UNW_LOONGARCH_R28:
5579 return "$r28";
5580 case UNW_LOONGARCH_R29:
5581 return "$r29";
5582 case UNW_LOONGARCH_R30:
5583 return "$r30";
5584 case UNW_LOONGARCH_R31:
5585 return "$r31";
5586 case UNW_LOONGARCH_F0:
5587 return "$f0";
5588 case UNW_LOONGARCH_F1:
5589 return "$f1";
5590 case UNW_LOONGARCH_F2:
5591 return "$f2";
5592 case UNW_LOONGARCH_F3:
5593 return "$f3";
5594 case UNW_LOONGARCH_F4:
5595 return "$f4";
5596 case UNW_LOONGARCH_F5:
5597 return "$f5";
5598 case UNW_LOONGARCH_F6:
5599 return "$f6";
5600 case UNW_LOONGARCH_F7:
5601 return "$f7";
5602 case UNW_LOONGARCH_F8:
5603 return "$f8";
5604 case UNW_LOONGARCH_F9:
5605 return "$f9";
5606 case UNW_LOONGARCH_F10:
5607 return "$f10";
5608 case UNW_LOONGARCH_F11:
5609 return "$f11";
5610 case UNW_LOONGARCH_F12:
5611 return "$f12";
5612 case UNW_LOONGARCH_F13:
5613 return "$f13";
5614 case UNW_LOONGARCH_F14:
5615 return "$f14";
5616 case UNW_LOONGARCH_F15:
5617 return "$f15";
5618 case UNW_LOONGARCH_F16:
5619 return "$f16";
5620 case UNW_LOONGARCH_F17:
5621 return "$f17";
5622 case UNW_LOONGARCH_F18:
5623 return "$f18";
5624 case UNW_LOONGARCH_F19:
5625 return "$f19";
5626 case UNW_LOONGARCH_F20:
5627 return "$f20";
5628 case UNW_LOONGARCH_F21:
5629 return "$f21";
5630 case UNW_LOONGARCH_F22:
5631 return "$f22";
5632 case UNW_LOONGARCH_F23:
5633 return "$f23";
5634 case UNW_LOONGARCH_F24:
5635 return "$f24";
5636 case UNW_LOONGARCH_F25:
5637 return "$f25";
5638 case UNW_LOONGARCH_F26:
5639 return "$f26";
5640 case UNW_LOONGARCH_F27:
5641 return "$f27";
5642 case UNW_LOONGARCH_F28:
5643 return "$f28";
5644 case UNW_LOONGARCH_F29:
5645 return "$f29";
5646 case UNW_LOONGARCH_F30:
5647 return "$f30";
5648 case UNW_LOONGARCH_F31:
5649 return "$f31";
5650 default:
5651 return "unknown register";
5652 }
5653}
5654
5655inline bool Registers_loongarch::validFloatRegister(int regNum) const {
5656 if (regNum < UNW_LOONGARCH_F0 || regNum > UNW_LOONGARCH_F31)
5657 return false;
5658 return true;
5659}
5660
5661inline double Registers_loongarch::getFloatRegister(int regNum) const {
5662#if __loongarch_frlen == 64
5663 assert(validFloatRegister(regNum));
5664 return _floats[regNum - UNW_LOONGARCH_F0];
5665#else
5666 _LIBUNWIND_ABORT("libunwind not built with float support");
5667#endif
5668}
5669
5670inline void Registers_loongarch::setFloatRegister(int regNum, double value) {
5671#if __loongarch_frlen == 64
5672 assert(validFloatRegister(regNum));
5673 _floats[regNum - UNW_LOONGARCH_F0] = value;
5674#else
5675 _LIBUNWIND_ABORT("libunwind not built with float support");
5676#endif
5677}
5678
5679inline bool Registers_loongarch::validVectorRegister(int) const {
5680 return false;
5681}
5682
5683inline v128 Registers_loongarch::getVectorRegister(int) const {
5684 _LIBUNWIND_ABORT("loongarch vector support not implemented");
5685}
5686
5687inline void Registers_loongarch::setVectorRegister(int, v128) {
5688 _LIBUNWIND_ABORT("loongarch vector support not implemented");
5689}
5690#endif //_LIBUNWIND_TARGET_LOONGARCH
5691
5692} // namespace libunwind
5693
5694#endif // __REGISTERS_HPP__
5695