1 //===-- ABISysV_arm64.cpp ---------------------------------------*- C++ -*-===//
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
9 #include "ABISysV_arm64.h"
10
11 #include <vector>
12
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/ADT/Triple.h"
15
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/PluginManager.h"
18 #include "lldb/Core/Value.h"
19 #include "lldb/Core/ValueObjectConstResult.h"
20 #include "lldb/Symbol/UnwindPlan.h"
21 #include "lldb/Target/Process.h"
22 #include "lldb/Target/RegisterContext.h"
23 #include "lldb/Target/Target.h"
24 #include "lldb/Target/Thread.h"
25 #include "lldb/Utility/ConstString.h"
26 #include "lldb/Utility/Log.h"
27 #include "lldb/Utility/RegisterValue.h"
28 #include "lldb/Utility/Scalar.h"
29 #include "lldb/Utility/Status.h"
30
31 #include "Utility/ARM64_DWARF_Registers.h"
32
33 using namespace lldb;
34 using namespace lldb_private;
35
36 static RegisterInfo g_register_infos[] = {
37 // NAME ALT SZ OFF ENCODING FORMAT
38 // EH_FRAME DWARF GENERIC
39 // PROCESS PLUGIN LLDB NATIVE
40 // ========== ======= == === ============= ===================
41 // =================== ====================== ===========================
42 // ======================= ======================
43 {"x0",
44 nullptr,
45 8,
46 0,
47 eEncodingUint,
48 eFormatHex,
49 {LLDB_INVALID_REGNUM, arm64_dwarf::x0, LLDB_REGNUM_GENERIC_ARG1,
50 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
51 nullptr,
52 nullptr,
53 nullptr,
54 0},
55 {"x1",
56 nullptr,
57 8,
58 0,
59 eEncodingUint,
60 eFormatHex,
61 {LLDB_INVALID_REGNUM, arm64_dwarf::x1, LLDB_REGNUM_GENERIC_ARG2,
62 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
63 nullptr,
64 nullptr,
65 nullptr,
66 0},
67 {"x2",
68 nullptr,
69 8,
70 0,
71 eEncodingUint,
72 eFormatHex,
73 {LLDB_INVALID_REGNUM, arm64_dwarf::x2, LLDB_REGNUM_GENERIC_ARG3,
74 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
75 nullptr,
76 nullptr,
77 nullptr,
78 0},
79 {"x3",
80 nullptr,
81 8,
82 0,
83 eEncodingUint,
84 eFormatHex,
85 {LLDB_INVALID_REGNUM, arm64_dwarf::x3, LLDB_REGNUM_GENERIC_ARG4,
86 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
87 nullptr,
88 nullptr,
89 nullptr,
90 0},
91 {"x4",
92 nullptr,
93 8,
94 0,
95 eEncodingUint,
96 eFormatHex,
97 {LLDB_INVALID_REGNUM, arm64_dwarf::x4, LLDB_REGNUM_GENERIC_ARG5,
98 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
99 nullptr,
100 nullptr,
101 nullptr,
102 0},
103 {"x5",
104 nullptr,
105 8,
106 0,
107 eEncodingUint,
108 eFormatHex,
109 {LLDB_INVALID_REGNUM, arm64_dwarf::x5, LLDB_REGNUM_GENERIC_ARG6,
110 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
111 nullptr,
112 nullptr,
113 nullptr,
114 0},
115 {"x6",
116 nullptr,
117 8,
118 0,
119 eEncodingUint,
120 eFormatHex,
121 {LLDB_INVALID_REGNUM, arm64_dwarf::x6, LLDB_REGNUM_GENERIC_ARG7,
122 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
123 nullptr,
124 nullptr,
125 nullptr,
126 0},
127 {"x7",
128 nullptr,
129 8,
130 0,
131 eEncodingUint,
132 eFormatHex,
133 {LLDB_INVALID_REGNUM, arm64_dwarf::x7, LLDB_REGNUM_GENERIC_ARG8,
134 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
135 nullptr,
136 nullptr,
137 nullptr,
138 0},
139 {"x8",
140 nullptr,
141 8,
142 0,
143 eEncodingUint,
144 eFormatHex,
145 {LLDB_INVALID_REGNUM, arm64_dwarf::x8, LLDB_INVALID_REGNUM,
146 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
147 nullptr,
148 nullptr,
149 nullptr,
150 0},
151 {"x9",
152 nullptr,
153 8,
154 0,
155 eEncodingUint,
156 eFormatHex,
157 {LLDB_INVALID_REGNUM, arm64_dwarf::x9, LLDB_INVALID_REGNUM,
158 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
159 nullptr,
160 nullptr,
161 nullptr,
162 0},
163 {"x10",
164 nullptr,
165 8,
166 0,
167 eEncodingUint,
168 eFormatHex,
169 {LLDB_INVALID_REGNUM, arm64_dwarf::x10, LLDB_INVALID_REGNUM,
170 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
171 nullptr,
172 nullptr,
173 nullptr,
174 0},
175 {"x11",
176 nullptr,
177 8,
178 0,
179 eEncodingUint,
180 eFormatHex,
181 {LLDB_INVALID_REGNUM, arm64_dwarf::x11, LLDB_INVALID_REGNUM,
182 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
183 nullptr,
184 nullptr,
185 nullptr,
186 0},
187 {"x12",
188 nullptr,
189 8,
190 0,
191 eEncodingUint,
192 eFormatHex,
193 {LLDB_INVALID_REGNUM, arm64_dwarf::x12, LLDB_INVALID_REGNUM,
194 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
195 nullptr,
196 nullptr,
197 nullptr,
198 0},
199 {"x13",
200 nullptr,
201 8,
202 0,
203 eEncodingUint,
204 eFormatHex,
205 {LLDB_INVALID_REGNUM, arm64_dwarf::x13, LLDB_INVALID_REGNUM,
206 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
207 nullptr,
208 nullptr,
209 nullptr,
210 0},
211 {"x14",
212 nullptr,
213 8,
214 0,
215 eEncodingUint,
216 eFormatHex,
217 {LLDB_INVALID_REGNUM, arm64_dwarf::x14, LLDB_INVALID_REGNUM,
218 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
219 nullptr,
220 nullptr,
221 nullptr,
222 0},
223 {"x15",
224 nullptr,
225 8,
226 0,
227 eEncodingUint,
228 eFormatHex,
229 {LLDB_INVALID_REGNUM, arm64_dwarf::x15, LLDB_INVALID_REGNUM,
230 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
231 nullptr,
232 nullptr,
233 nullptr,
234 0},
235 {"x16",
236 nullptr,
237 8,
238 0,
239 eEncodingUint,
240 eFormatHex,
241 {LLDB_INVALID_REGNUM, arm64_dwarf::x16, LLDB_INVALID_REGNUM,
242 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
243 nullptr,
244 nullptr,
245 nullptr,
246 0},
247 {"x17",
248 nullptr,
249 8,
250 0,
251 eEncodingUint,
252 eFormatHex,
253 {LLDB_INVALID_REGNUM, arm64_dwarf::x17, LLDB_INVALID_REGNUM,
254 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
255 nullptr,
256 nullptr,
257 nullptr,
258 0},
259 {"x18",
260 nullptr,
261 8,
262 0,
263 eEncodingUint,
264 eFormatHex,
265 {LLDB_INVALID_REGNUM, arm64_dwarf::x18, LLDB_INVALID_REGNUM,
266 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
267 nullptr,
268 nullptr,
269 nullptr,
270 0},
271 {"x19",
272 nullptr,
273 8,
274 0,
275 eEncodingUint,
276 eFormatHex,
277 {LLDB_INVALID_REGNUM, arm64_dwarf::x19, LLDB_INVALID_REGNUM,
278 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
279 nullptr,
280 nullptr,
281 nullptr,
282 0},
283 {"x20",
284 nullptr,
285 8,
286 0,
287 eEncodingUint,
288 eFormatHex,
289 {LLDB_INVALID_REGNUM, arm64_dwarf::x20, LLDB_INVALID_REGNUM,
290 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
291 nullptr,
292 nullptr,
293 nullptr,
294 0},
295 {"x21",
296 nullptr,
297 8,
298 0,
299 eEncodingUint,
300 eFormatHex,
301 {LLDB_INVALID_REGNUM, arm64_dwarf::x21, LLDB_INVALID_REGNUM,
302 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
303 nullptr,
304 nullptr,
305 nullptr,
306 0},
307 {"x22",
308 nullptr,
309 8,
310 0,
311 eEncodingUint,
312 eFormatHex,
313 {LLDB_INVALID_REGNUM, arm64_dwarf::x22, LLDB_INVALID_REGNUM,
314 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
315 nullptr,
316 nullptr,
317 nullptr,
318 0},
319 {"x23",
320 nullptr,
321 8,
322 0,
323 eEncodingUint,
324 eFormatHex,
325 {LLDB_INVALID_REGNUM, arm64_dwarf::x23, LLDB_INVALID_REGNUM,
326 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
327 nullptr,
328 nullptr,
329 nullptr,
330 0},
331 {"x24",
332 nullptr,
333 8,
334 0,
335 eEncodingUint,
336 eFormatHex,
337 {LLDB_INVALID_REGNUM, arm64_dwarf::x24, LLDB_INVALID_REGNUM,
338 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
339 nullptr,
340 nullptr,
341 nullptr,
342 0},
343 {"x25",
344 nullptr,
345 8,
346 0,
347 eEncodingUint,
348 eFormatHex,
349 {LLDB_INVALID_REGNUM, arm64_dwarf::x25, LLDB_INVALID_REGNUM,
350 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
351 nullptr,
352 nullptr,
353 nullptr,
354 0},
355 {"x26",
356 nullptr,
357 8,
358 0,
359 eEncodingUint,
360 eFormatHex,
361 {LLDB_INVALID_REGNUM, arm64_dwarf::x26, LLDB_INVALID_REGNUM,
362 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
363 nullptr,
364 nullptr,
365 nullptr,
366 0},
367 {"x27",
368 nullptr,
369 8,
370 0,
371 eEncodingUint,
372 eFormatHex,
373 {LLDB_INVALID_REGNUM, arm64_dwarf::x27, LLDB_INVALID_REGNUM,
374 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
375 nullptr,
376 nullptr,
377 nullptr,
378 0},
379 {"x28",
380 nullptr,
381 8,
382 0,
383 eEncodingUint,
384 eFormatHex,
385 {LLDB_INVALID_REGNUM, arm64_dwarf::x28, LLDB_INVALID_REGNUM,
386 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
387 nullptr,
388 nullptr,
389 nullptr,
390 0},
391 {"fp",
392 "x29",
393 8,
394 0,
395 eEncodingUint,
396 eFormatHex,
397 {LLDB_INVALID_REGNUM, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP,
398 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
399 nullptr,
400 nullptr,
401 nullptr,
402 0},
403 {"lr",
404 "x30",
405 8,
406 0,
407 eEncodingUint,
408 eFormatHex,
409 {LLDB_INVALID_REGNUM, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA,
410 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
411 nullptr,
412 nullptr,
413 nullptr,
414 0},
415 {"sp",
416 "x31",
417 8,
418 0,
419 eEncodingUint,
420 eFormatHex,
421 {LLDB_INVALID_REGNUM, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP,
422 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
423 nullptr,
424 nullptr,
425 nullptr,
426 0},
427 {"pc",
428 nullptr,
429 8,
430 0,
431 eEncodingUint,
432 eFormatHex,
433 {LLDB_INVALID_REGNUM, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC,
434 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
435 nullptr,
436 nullptr,
437 nullptr,
438 0},
439 {"cpsr",
440 "psr",
441 4,
442 0,
443 eEncodingUint,
444 eFormatHex,
445 {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS,
446 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
447 nullptr,
448 nullptr,
449 nullptr,
450 0},
451
452 {"v0",
453 nullptr,
454 16,
455 0,
456 eEncodingVector,
457 eFormatVectorOfUInt8,
458 {LLDB_INVALID_REGNUM, arm64_dwarf::v0, LLDB_INVALID_REGNUM,
459 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
460 nullptr,
461 nullptr,
462 nullptr,
463 0},
464 {"v1",
465 nullptr,
466 16,
467 0,
468 eEncodingVector,
469 eFormatVectorOfUInt8,
470 {LLDB_INVALID_REGNUM, arm64_dwarf::v1, LLDB_INVALID_REGNUM,
471 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
472 nullptr,
473 nullptr,
474 nullptr,
475 0},
476 {"v2",
477 nullptr,
478 16,
479 0,
480 eEncodingVector,
481 eFormatVectorOfUInt8,
482 {LLDB_INVALID_REGNUM, arm64_dwarf::v2, LLDB_INVALID_REGNUM,
483 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
484 nullptr,
485 nullptr,
486 nullptr,
487 0},
488 {"v3",
489 nullptr,
490 16,
491 0,
492 eEncodingVector,
493 eFormatVectorOfUInt8,
494 {LLDB_INVALID_REGNUM, arm64_dwarf::v3, LLDB_INVALID_REGNUM,
495 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
496 nullptr,
497 nullptr,
498 nullptr,
499 0},
500 {"v4",
501 nullptr,
502 16,
503 0,
504 eEncodingVector,
505 eFormatVectorOfUInt8,
506 {LLDB_INVALID_REGNUM, arm64_dwarf::v4, LLDB_INVALID_REGNUM,
507 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
508 nullptr,
509 nullptr,
510 nullptr,
511 0},
512 {"v5",
513 nullptr,
514 16,
515 0,
516 eEncodingVector,
517 eFormatVectorOfUInt8,
518 {LLDB_INVALID_REGNUM, arm64_dwarf::v5, LLDB_INVALID_REGNUM,
519 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
520 nullptr,
521 nullptr,
522 nullptr,
523 0},
524 {"v6",
525 nullptr,
526 16,
527 0,
528 eEncodingVector,
529 eFormatVectorOfUInt8,
530 {LLDB_INVALID_REGNUM, arm64_dwarf::v6, LLDB_INVALID_REGNUM,
531 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
532 nullptr,
533 nullptr,
534 nullptr,
535 0},
536 {"v7",
537 nullptr,
538 16,
539 0,
540 eEncodingVector,
541 eFormatVectorOfUInt8,
542 {LLDB_INVALID_REGNUM, arm64_dwarf::v7, LLDB_INVALID_REGNUM,
543 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
544 nullptr,
545 nullptr,
546 nullptr,
547 0},
548 {"v8",
549 nullptr,
550 16,
551 0,
552 eEncodingVector,
553 eFormatVectorOfUInt8,
554 {LLDB_INVALID_REGNUM, arm64_dwarf::v8, LLDB_INVALID_REGNUM,
555 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
556 nullptr,
557 nullptr,
558 nullptr,
559 0},
560 {"v9",
561 nullptr,
562 16,
563 0,
564 eEncodingVector,
565 eFormatVectorOfUInt8,
566 {LLDB_INVALID_REGNUM, arm64_dwarf::v9, LLDB_INVALID_REGNUM,
567 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
568 nullptr,
569 nullptr,
570 nullptr,
571 0},
572 {"v10",
573 nullptr,
574 16,
575 0,
576 eEncodingVector,
577 eFormatVectorOfUInt8,
578 {LLDB_INVALID_REGNUM, arm64_dwarf::v10, LLDB_INVALID_REGNUM,
579 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
580 nullptr,
581 nullptr,
582 nullptr,
583 0},
584 {"v11",
585 nullptr,
586 16,
587 0,
588 eEncodingVector,
589 eFormatVectorOfUInt8,
590 {LLDB_INVALID_REGNUM, arm64_dwarf::v11, LLDB_INVALID_REGNUM,
591 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
592 nullptr,
593 nullptr,
594 nullptr,
595 0},
596 {"v12",
597 nullptr,
598 16,
599 0,
600 eEncodingVector,
601 eFormatVectorOfUInt8,
602 {LLDB_INVALID_REGNUM, arm64_dwarf::v12, LLDB_INVALID_REGNUM,
603 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
604 nullptr,
605 nullptr,
606 nullptr,
607 0},
608 {"v13",
609 nullptr,
610 16,
611 0,
612 eEncodingVector,
613 eFormatVectorOfUInt8,
614 {LLDB_INVALID_REGNUM, arm64_dwarf::v13, LLDB_INVALID_REGNUM,
615 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
616 nullptr,
617 nullptr,
618 nullptr,
619 0},
620 {"v14",
621 nullptr,
622 16,
623 0,
624 eEncodingVector,
625 eFormatVectorOfUInt8,
626 {LLDB_INVALID_REGNUM, arm64_dwarf::v14, LLDB_INVALID_REGNUM,
627 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
628 nullptr,
629 nullptr,
630 nullptr,
631 0},
632 {"v15",
633 nullptr,
634 16,
635 0,
636 eEncodingVector,
637 eFormatVectorOfUInt8,
638 {LLDB_INVALID_REGNUM, arm64_dwarf::v15, LLDB_INVALID_REGNUM,
639 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
640 nullptr,
641 nullptr,
642 nullptr,
643 0},
644 {"v16",
645 nullptr,
646 16,
647 0,
648 eEncodingVector,
649 eFormatVectorOfUInt8,
650 {LLDB_INVALID_REGNUM, arm64_dwarf::v16, LLDB_INVALID_REGNUM,
651 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
652 nullptr,
653 nullptr,
654 nullptr,
655 0},
656 {"v17",
657 nullptr,
658 16,
659 0,
660 eEncodingVector,
661 eFormatVectorOfUInt8,
662 {LLDB_INVALID_REGNUM, arm64_dwarf::v17, LLDB_INVALID_REGNUM,
663 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
664 nullptr,
665 nullptr,
666 nullptr,
667 0},
668 {"v18",
669 nullptr,
670 16,
671 0,
672 eEncodingVector,
673 eFormatVectorOfUInt8,
674 {LLDB_INVALID_REGNUM, arm64_dwarf::v18, LLDB_INVALID_REGNUM,
675 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
676 nullptr,
677 nullptr,
678 nullptr,
679 0},
680 {"v19",
681 nullptr,
682 16,
683 0,
684 eEncodingVector,
685 eFormatVectorOfUInt8,
686 {LLDB_INVALID_REGNUM, arm64_dwarf::v19, LLDB_INVALID_REGNUM,
687 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
688 nullptr,
689 nullptr,
690 nullptr,
691 0},
692 {"v20",
693 nullptr,
694 16,
695 0,
696 eEncodingVector,
697 eFormatVectorOfUInt8,
698 {LLDB_INVALID_REGNUM, arm64_dwarf::v20, LLDB_INVALID_REGNUM,
699 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
700 nullptr,
701 nullptr,
702 nullptr,
703 0},
704 {"v21",
705 nullptr,
706 16,
707 0,
708 eEncodingVector,
709 eFormatVectorOfUInt8,
710 {LLDB_INVALID_REGNUM, arm64_dwarf::v21, LLDB_INVALID_REGNUM,
711 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
712 nullptr,
713 nullptr,
714 nullptr,
715 0},
716 {"v22",
717 nullptr,
718 16,
719 0,
720 eEncodingVector,
721 eFormatVectorOfUInt8,
722 {LLDB_INVALID_REGNUM, arm64_dwarf::v22, LLDB_INVALID_REGNUM,
723 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
724 nullptr,
725 nullptr,
726 nullptr,
727 0},
728 {"v23",
729 nullptr,
730 16,
731 0,
732 eEncodingVector,
733 eFormatVectorOfUInt8,
734 {LLDB_INVALID_REGNUM, arm64_dwarf::v23, LLDB_INVALID_REGNUM,
735 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
736 nullptr,
737 nullptr,
738 nullptr,
739 0},
740 {"v24",
741 nullptr,
742 16,
743 0,
744 eEncodingVector,
745 eFormatVectorOfUInt8,
746 {LLDB_INVALID_REGNUM, arm64_dwarf::v24, LLDB_INVALID_REGNUM,
747 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
748 nullptr,
749 nullptr,
750 nullptr,
751 0},
752 {"v25",
753 nullptr,
754 16,
755 0,
756 eEncodingVector,
757 eFormatVectorOfUInt8,
758 {LLDB_INVALID_REGNUM, arm64_dwarf::v25, LLDB_INVALID_REGNUM,
759 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
760 nullptr,
761 nullptr,
762 nullptr,
763 0},
764 {"v26",
765 nullptr,
766 16,
767 0,
768 eEncodingVector,
769 eFormatVectorOfUInt8,
770 {LLDB_INVALID_REGNUM, arm64_dwarf::v26, LLDB_INVALID_REGNUM,
771 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
772 nullptr,
773 nullptr,
774 nullptr,
775 0},
776 {"v27",
777 nullptr,
778 16,
779 0,
780 eEncodingVector,
781 eFormatVectorOfUInt8,
782 {LLDB_INVALID_REGNUM, arm64_dwarf::v27, LLDB_INVALID_REGNUM,
783 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
784 nullptr,
785 nullptr,
786 nullptr,
787 0},
788 {"v28",
789 nullptr,
790 16,
791 0,
792 eEncodingVector,
793 eFormatVectorOfUInt8,
794 {LLDB_INVALID_REGNUM, arm64_dwarf::v28, LLDB_INVALID_REGNUM,
795 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
796 nullptr,
797 nullptr,
798 nullptr,
799 0},
800 {"v29",
801 nullptr,
802 16,
803 0,
804 eEncodingVector,
805 eFormatVectorOfUInt8,
806 {LLDB_INVALID_REGNUM, arm64_dwarf::v29, LLDB_INVALID_REGNUM,
807 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
808 nullptr,
809 nullptr,
810 nullptr,
811 0},
812 {"v30",
813 nullptr,
814 16,
815 0,
816 eEncodingVector,
817 eFormatVectorOfUInt8,
818 {LLDB_INVALID_REGNUM, arm64_dwarf::v30, LLDB_INVALID_REGNUM,
819 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
820 nullptr,
821 nullptr,
822 nullptr,
823 0},
824 {"v31",
825 nullptr,
826 16,
827 0,
828 eEncodingVector,
829 eFormatVectorOfUInt8,
830 {LLDB_INVALID_REGNUM, arm64_dwarf::v31, LLDB_INVALID_REGNUM,
831 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
832 nullptr,
833 nullptr,
834 nullptr,
835 0},
836
837 {"fpsr",
838 nullptr,
839 4,
840 0,
841 eEncodingUint,
842 eFormatHex,
843 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
844 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
845 nullptr,
846 nullptr,
847 nullptr,
848 0},
849 {"fpcr",
850 nullptr,
851 4,
852 0,
853 eEncodingUint,
854 eFormatHex,
855 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
856 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
857 nullptr,
858 nullptr,
859 nullptr,
860 0},
861
862 {"s0",
863 nullptr,
864 4,
865 0,
866 eEncodingIEEE754,
867 eFormatFloat,
868 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
869 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
870 nullptr,
871 nullptr,
872 nullptr,
873 0},
874 {"s1",
875 nullptr,
876 4,
877 0,
878 eEncodingIEEE754,
879 eFormatFloat,
880 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
881 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
882 nullptr,
883 nullptr,
884 nullptr,
885 0},
886 {"s2",
887 nullptr,
888 4,
889 0,
890 eEncodingIEEE754,
891 eFormatFloat,
892 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
893 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
894 nullptr,
895 nullptr,
896 nullptr,
897 0},
898 {"s3",
899 nullptr,
900 4,
901 0,
902 eEncodingIEEE754,
903 eFormatFloat,
904 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
905 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
906 nullptr,
907 nullptr,
908 nullptr,
909 0},
910 {"s4",
911 nullptr,
912 4,
913 0,
914 eEncodingIEEE754,
915 eFormatFloat,
916 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
917 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
918 nullptr,
919 nullptr,
920 nullptr,
921 0},
922 {"s5",
923 nullptr,
924 4,
925 0,
926 eEncodingIEEE754,
927 eFormatFloat,
928 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
929 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
930 nullptr,
931 nullptr,
932 nullptr,
933 0},
934 {"s6",
935 nullptr,
936 4,
937 0,
938 eEncodingIEEE754,
939 eFormatFloat,
940 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
941 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
942 nullptr,
943 nullptr,
944 nullptr,
945 0},
946 {"s7",
947 nullptr,
948 4,
949 0,
950 eEncodingIEEE754,
951 eFormatFloat,
952 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
953 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
954 nullptr,
955 nullptr,
956 nullptr,
957 0},
958 {"s8",
959 nullptr,
960 4,
961 0,
962 eEncodingIEEE754,
963 eFormatFloat,
964 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
965 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
966 nullptr,
967 nullptr,
968 nullptr,
969 0},
970 {"s9",
971 nullptr,
972 4,
973 0,
974 eEncodingIEEE754,
975 eFormatFloat,
976 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
977 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
978 nullptr,
979 nullptr,
980 nullptr,
981 0},
982 {"s10",
983 nullptr,
984 4,
985 0,
986 eEncodingIEEE754,
987 eFormatFloat,
988 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
989 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
990 nullptr,
991 nullptr,
992 nullptr,
993 0},
994 {"s11",
995 nullptr,
996 4,
997 0,
998 eEncodingIEEE754,
999 eFormatFloat,
1000 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1001 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1002 nullptr,
1003 nullptr,
1004 nullptr,
1005 0},
1006 {"s12",
1007 nullptr,
1008 4,
1009 0,
1010 eEncodingIEEE754,
1011 eFormatFloat,
1012 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1013 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1014 nullptr,
1015 nullptr,
1016 nullptr,
1017 0},
1018 {"s13",
1019 nullptr,
1020 4,
1021 0,
1022 eEncodingIEEE754,
1023 eFormatFloat,
1024 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1025 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1026 nullptr,
1027 nullptr,
1028 nullptr,
1029 0},
1030 {"s14",
1031 nullptr,
1032 4,
1033 0,
1034 eEncodingIEEE754,
1035 eFormatFloat,
1036 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1037 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1038 nullptr,
1039 nullptr,
1040 nullptr,
1041 0},
1042 {"s15",
1043 nullptr,
1044 4,
1045 0,
1046 eEncodingIEEE754,
1047 eFormatFloat,
1048 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1049 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1050 nullptr,
1051 nullptr,
1052 nullptr,
1053 0},
1054 {"s16",
1055 nullptr,
1056 4,
1057 0,
1058 eEncodingIEEE754,
1059 eFormatFloat,
1060 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1061 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1062 nullptr,
1063 nullptr,
1064 nullptr,
1065 0},
1066 {"s17",
1067 nullptr,
1068 4,
1069 0,
1070 eEncodingIEEE754,
1071 eFormatFloat,
1072 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1073 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1074 nullptr,
1075 nullptr,
1076 nullptr,
1077 0},
1078 {"s18",
1079 nullptr,
1080 4,
1081 0,
1082 eEncodingIEEE754,
1083 eFormatFloat,
1084 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1085 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1086 nullptr,
1087 nullptr,
1088 nullptr,
1089 0},
1090 {"s19",
1091 nullptr,
1092 4,
1093 0,
1094 eEncodingIEEE754,
1095 eFormatFloat,
1096 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1097 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1098 nullptr,
1099 nullptr,
1100 nullptr,
1101 0},
1102 {"s20",
1103 nullptr,
1104 4,
1105 0,
1106 eEncodingIEEE754,
1107 eFormatFloat,
1108 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1109 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1110 nullptr,
1111 nullptr,
1112 nullptr,
1113 0},
1114 {"s21",
1115 nullptr,
1116 4,
1117 0,
1118 eEncodingIEEE754,
1119 eFormatFloat,
1120 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1121 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1122 nullptr,
1123 nullptr,
1124 nullptr,
1125 0},
1126 {"s22",
1127 nullptr,
1128 4,
1129 0,
1130 eEncodingIEEE754,
1131 eFormatFloat,
1132 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1133 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1134 nullptr,
1135 nullptr,
1136 nullptr,
1137 0},
1138 {"s23",
1139 nullptr,
1140 4,
1141 0,
1142 eEncodingIEEE754,
1143 eFormatFloat,
1144 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1145 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1146 nullptr,
1147 nullptr,
1148 nullptr,
1149 0},
1150 {"s24",
1151 nullptr,
1152 4,
1153 0,
1154 eEncodingIEEE754,
1155 eFormatFloat,
1156 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1157 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1158 nullptr,
1159 nullptr,
1160 nullptr,
1161 0},
1162 {"s25",
1163 nullptr,
1164 4,
1165 0,
1166 eEncodingIEEE754,
1167 eFormatFloat,
1168 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1169 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1170 nullptr,
1171 nullptr,
1172 nullptr,
1173 0},
1174 {"s26",
1175 nullptr,
1176 4,
1177 0,
1178 eEncodingIEEE754,
1179 eFormatFloat,
1180 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1181 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1182 nullptr,
1183 nullptr,
1184 nullptr,
1185 0},
1186 {"s27",
1187 nullptr,
1188 4,
1189 0,
1190 eEncodingIEEE754,
1191 eFormatFloat,
1192 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1193 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1194 nullptr,
1195 nullptr,
1196 nullptr,
1197 0},
1198 {"s28",
1199 nullptr,
1200 4,
1201 0,
1202 eEncodingIEEE754,
1203 eFormatFloat,
1204 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1205 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1206 nullptr,
1207 nullptr,
1208 nullptr,
1209 0},
1210 {"s29",
1211 nullptr,
1212 4,
1213 0,
1214 eEncodingIEEE754,
1215 eFormatFloat,
1216 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1217 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1218 nullptr,
1219 nullptr,
1220 nullptr,
1221 0},
1222 {"s30",
1223 nullptr,
1224 4,
1225 0,
1226 eEncodingIEEE754,
1227 eFormatFloat,
1228 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1229 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1230 nullptr,
1231 nullptr,
1232 nullptr,
1233 0},
1234 {"s31",
1235 nullptr,
1236 4,
1237 0,
1238 eEncodingIEEE754,
1239 eFormatFloat,
1240 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1241 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1242 nullptr,
1243 nullptr,
1244 nullptr,
1245 0},
1246
1247 {"d0",
1248 nullptr,
1249 8,
1250 0,
1251 eEncodingIEEE754,
1252 eFormatFloat,
1253 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1254 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1255 nullptr,
1256 nullptr,
1257 nullptr,
1258 0},
1259 {"d1",
1260 nullptr,
1261 8,
1262 0,
1263 eEncodingIEEE754,
1264 eFormatFloat,
1265 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1266 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1267 nullptr,
1268 nullptr,
1269 nullptr,
1270 0},
1271 {"d2",
1272 nullptr,
1273 8,
1274 0,
1275 eEncodingIEEE754,
1276 eFormatFloat,
1277 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1278 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1279 nullptr,
1280 nullptr,
1281 nullptr,
1282 0},
1283 {"d3",
1284 nullptr,
1285 8,
1286 0,
1287 eEncodingIEEE754,
1288 eFormatFloat,
1289 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1290 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1291 nullptr,
1292 nullptr,
1293 nullptr,
1294 0},
1295 {"d4",
1296 nullptr,
1297 8,
1298 0,
1299 eEncodingIEEE754,
1300 eFormatFloat,
1301 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1302 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1303 nullptr,
1304 nullptr,
1305 nullptr,
1306 0},
1307 {"d5",
1308 nullptr,
1309 8,
1310 0,
1311 eEncodingIEEE754,
1312 eFormatFloat,
1313 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1314 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1315 nullptr,
1316 nullptr,
1317 nullptr,
1318 0},
1319 {"d6",
1320 nullptr,
1321 8,
1322 0,
1323 eEncodingIEEE754,
1324 eFormatFloat,
1325 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1326 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1327 nullptr,
1328 nullptr,
1329 nullptr,
1330 0},
1331 {"d7",
1332 nullptr,
1333 8,
1334 0,
1335 eEncodingIEEE754,
1336 eFormatFloat,
1337 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1338 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1339 nullptr,
1340 nullptr,
1341 nullptr,
1342 0},
1343 {"d8",
1344 nullptr,
1345 8,
1346 0,
1347 eEncodingIEEE754,
1348 eFormatFloat,
1349 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1350 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1351 nullptr,
1352 nullptr,
1353 nullptr,
1354 0},
1355 {"d9",
1356 nullptr,
1357 8,
1358 0,
1359 eEncodingIEEE754,
1360 eFormatFloat,
1361 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1362 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1363 nullptr,
1364 nullptr,
1365 nullptr,
1366 0},
1367 {"d10",
1368 nullptr,
1369 8,
1370 0,
1371 eEncodingIEEE754,
1372 eFormatFloat,
1373 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1374 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1375 nullptr,
1376 nullptr,
1377 nullptr,
1378 0},
1379 {"d11",
1380 nullptr,
1381 8,
1382 0,
1383 eEncodingIEEE754,
1384 eFormatFloat,
1385 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1386 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1387 nullptr,
1388 nullptr,
1389 nullptr,
1390 0},
1391 {"d12",
1392 nullptr,
1393 8,
1394 0,
1395 eEncodingIEEE754,
1396 eFormatFloat,
1397 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1398 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1399 nullptr,
1400 nullptr,
1401 nullptr,
1402 0},
1403 {"d13",
1404 nullptr,
1405 8,
1406 0,
1407 eEncodingIEEE754,
1408 eFormatFloat,
1409 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1410 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1411 nullptr,
1412 nullptr,
1413 nullptr,
1414 0},
1415 {"d14",
1416 nullptr,
1417 8,
1418 0,
1419 eEncodingIEEE754,
1420 eFormatFloat,
1421 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1422 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1423 nullptr,
1424 nullptr,
1425 nullptr,
1426 0},
1427 {"d15",
1428 nullptr,
1429 8,
1430 0,
1431 eEncodingIEEE754,
1432 eFormatFloat,
1433 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1434 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1435 nullptr,
1436 nullptr,
1437 nullptr,
1438 0},
1439 {"d16",
1440 nullptr,
1441 8,
1442 0,
1443 eEncodingIEEE754,
1444 eFormatFloat,
1445 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1446 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1447 nullptr,
1448 nullptr,
1449 nullptr,
1450 0},
1451 {"d17",
1452 nullptr,
1453 8,
1454 0,
1455 eEncodingIEEE754,
1456 eFormatFloat,
1457 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1458 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1459 nullptr,
1460 nullptr,
1461 nullptr,
1462 0},
1463 {"d18",
1464 nullptr,
1465 8,
1466 0,
1467 eEncodingIEEE754,
1468 eFormatFloat,
1469 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1470 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1471 nullptr,
1472 nullptr,
1473 nullptr,
1474 0},
1475 {"d19",
1476 nullptr,
1477 8,
1478 0,
1479 eEncodingIEEE754,
1480 eFormatFloat,
1481 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1482 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1483 nullptr,
1484 nullptr,
1485 nullptr,
1486 0},
1487 {"d20",
1488 nullptr,
1489 8,
1490 0,
1491 eEncodingIEEE754,
1492 eFormatFloat,
1493 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1494 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1495 nullptr,
1496 nullptr,
1497 nullptr,
1498 0},
1499 {"d21",
1500 nullptr,
1501 8,
1502 0,
1503 eEncodingIEEE754,
1504 eFormatFloat,
1505 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1506 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1507 nullptr,
1508 nullptr,
1509 nullptr,
1510 0},
1511 {"d22",
1512 nullptr,
1513 8,
1514 0,
1515 eEncodingIEEE754,
1516 eFormatFloat,
1517 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1518 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1519 nullptr,
1520 nullptr,
1521 nullptr,
1522 0},
1523 {"d23",
1524 nullptr,
1525 8,
1526 0,
1527 eEncodingIEEE754,
1528 eFormatFloat,
1529 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1530 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1531 nullptr,
1532 nullptr,
1533 nullptr,
1534 0},
1535 {"d24",
1536 nullptr,
1537 8,
1538 0,
1539 eEncodingIEEE754,
1540 eFormatFloat,
1541 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1542 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1543 nullptr,
1544 nullptr,
1545 nullptr,
1546 0},
1547 {"d25",
1548 nullptr,
1549 8,
1550 0,
1551 eEncodingIEEE754,
1552 eFormatFloat,
1553 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1554 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1555 nullptr,
1556 nullptr,
1557 nullptr,
1558 0},
1559 {"d26",
1560 nullptr,
1561 8,
1562 0,
1563 eEncodingIEEE754,
1564 eFormatFloat,
1565 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1566 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1567 nullptr,
1568 nullptr,
1569 nullptr,
1570 0},
1571 {"d27",
1572 nullptr,
1573 8,
1574 0,
1575 eEncodingIEEE754,
1576 eFormatFloat,
1577 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1578 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1579 nullptr,
1580 nullptr,
1581 nullptr,
1582 0},
1583 {"d28",
1584 nullptr,
1585 8,
1586 0,
1587 eEncodingIEEE754,
1588 eFormatFloat,
1589 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1590 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1591 nullptr,
1592 nullptr,
1593 nullptr,
1594 0},
1595 {"d29",
1596 nullptr,
1597 8,
1598 0,
1599 eEncodingIEEE754,
1600 eFormatFloat,
1601 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1602 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1603 nullptr,
1604 nullptr,
1605 nullptr,
1606 0},
1607 {"d30",
1608 nullptr,
1609 8,
1610 0,
1611 eEncodingIEEE754,
1612 eFormatFloat,
1613 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1614 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1615 nullptr,
1616 nullptr,
1617 nullptr,
1618 0},
1619 {"d31",
1620 nullptr,
1621 8,
1622 0,
1623 eEncodingIEEE754,
1624 eFormatFloat,
1625 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1626 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1627 nullptr,
1628 nullptr,
1629 nullptr,
1630 0}};
1631
1632 static const uint32_t k_num_register_infos =
1633 llvm::array_lengthof(g_register_infos);
1634 static bool g_register_info_names_constified = false;
1635
1636 const lldb_private::RegisterInfo *
GetRegisterInfoArray(uint32_t & count)1637 ABISysV_arm64::GetRegisterInfoArray(uint32_t &count) {
1638 // Make the C-string names and alt_names for the register infos into const
1639 // C-string values by having the ConstString unique the names in the global
1640 // constant C-string pool.
1641 if (!g_register_info_names_constified) {
1642 g_register_info_names_constified = true;
1643 for (uint32_t i = 0; i < k_num_register_infos; ++i) {
1644 if (g_register_infos[i].name)
1645 g_register_infos[i].name =
1646 ConstString(g_register_infos[i].name).GetCString();
1647 if (g_register_infos[i].alt_name)
1648 g_register_infos[i].alt_name =
1649 ConstString(g_register_infos[i].alt_name).GetCString();
1650 }
1651 }
1652 count = k_num_register_infos;
1653 return g_register_infos;
1654 }
1655
GetPointerReturnRegister(const char * & name)1656 bool ABISysV_arm64::GetPointerReturnRegister(const char *&name) {
1657 name = "x0";
1658 return true;
1659 }
1660
GetRedZoneSize() const1661 size_t ABISysV_arm64::GetRedZoneSize() const { return 128; }
1662
1663 // Static Functions
1664
1665 ABISP
CreateInstance(lldb::ProcessSP process_sp,const ArchSpec & arch)1666 ABISysV_arm64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
1667 const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1668 const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1669
1670 if (vendor_type != llvm::Triple::Apple) {
1671 if (arch_type == llvm::Triple::aarch64 ||
1672 arch_type == llvm::Triple::aarch64_32) {
1673 return ABISP(
1674 new ABISysV_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
1675 }
1676 }
1677
1678 return ABISP();
1679 }
1680
PrepareTrivialCall(Thread & thread,addr_t sp,addr_t func_addr,addr_t return_addr,llvm::ArrayRef<addr_t> args) const1681 bool ABISysV_arm64::PrepareTrivialCall(Thread &thread, addr_t sp,
1682 addr_t func_addr, addr_t return_addr,
1683 llvm::ArrayRef<addr_t> args) const {
1684 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1685 if (!reg_ctx)
1686 return false;
1687
1688 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1689
1690 if (log) {
1691 StreamString s;
1692 s.Printf("ABISysV_arm64::PrepareTrivialCall (tid = 0x%" PRIx64
1693 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
1694 ", return_addr = 0x%" PRIx64,
1695 thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
1696 (uint64_t)return_addr);
1697
1698 for (size_t i = 0; i < args.size(); ++i)
1699 s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
1700 s.PutCString(")");
1701 log->PutString(s.GetString());
1702 }
1703
1704 // x0 - x7 contain first 8 simple args
1705 if (args.size() > 8)
1706 return false;
1707
1708 for (size_t i = 0; i < args.size(); ++i) {
1709 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1710 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
1711 LLDB_LOGF(log, "About to write arg%d (0x%" PRIx64 ") into %s",
1712 static_cast<int>(i + 1), args[i], reg_info->name);
1713 if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
1714 return false;
1715 }
1716
1717 // Set "lr" to the return address
1718 if (!reg_ctx->WriteRegisterFromUnsigned(
1719 reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
1720 LLDB_REGNUM_GENERIC_RA),
1721 return_addr))
1722 return false;
1723
1724 // Set "sp" to the requested value
1725 if (!reg_ctx->WriteRegisterFromUnsigned(
1726 reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
1727 LLDB_REGNUM_GENERIC_SP),
1728 sp))
1729 return false;
1730
1731 // Set "pc" to the address requested
1732 if (!reg_ctx->WriteRegisterFromUnsigned(
1733 reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
1734 LLDB_REGNUM_GENERIC_PC),
1735 func_addr))
1736 return false;
1737
1738 return true;
1739 }
1740
1741 // TODO: We dont support fp/SIMD arguments in v0-v7
GetArgumentValues(Thread & thread,ValueList & values) const1742 bool ABISysV_arm64::GetArgumentValues(Thread &thread, ValueList &values) const {
1743 uint32_t num_values = values.GetSize();
1744
1745 ExecutionContext exe_ctx(thread.shared_from_this());
1746
1747 // Extract the register context so we can read arguments from registers
1748
1749 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1750
1751 if (!reg_ctx)
1752 return false;
1753
1754 addr_t sp = 0;
1755
1756 for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1757 // We currently only support extracting values with Clang QualTypes. Do we
1758 // care about others?
1759 Value *value = values.GetValueAtIndex(value_idx);
1760
1761 if (!value)
1762 return false;
1763
1764 CompilerType value_type = value->GetCompilerType();
1765 if (value_type) {
1766 bool is_signed = false;
1767 size_t bit_width = 0;
1768 llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
1769 if (!bit_size)
1770 return false;
1771 if (value_type.IsIntegerOrEnumerationType(is_signed)) {
1772 bit_width = *bit_size;
1773 } else if (value_type.IsPointerOrReferenceType()) {
1774 bit_width = *bit_size;
1775 } else {
1776 // We only handle integer, pointer and reference types currently...
1777 return false;
1778 }
1779
1780 if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1781 if (value_idx < 8) {
1782 // Arguments 1-8 are in x0-x7...
1783 const RegisterInfo *reg_info = nullptr;
1784 reg_info = reg_ctx->GetRegisterInfo(
1785 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1786
1787 if (reg_info) {
1788 RegisterValue reg_value;
1789
1790 if (reg_ctx->ReadRegister(reg_info, reg_value)) {
1791 if (is_signed)
1792 reg_value.SignExtend(bit_width);
1793 if (!reg_value.GetScalarValue(value->GetScalar()))
1794 return false;
1795 continue;
1796 }
1797 }
1798 return false;
1799 } else {
1800 // TODO: Verify for stack layout for SysV
1801 if (sp == 0) {
1802 // Read the stack pointer if we already haven't read it
1803 sp = reg_ctx->GetSP(0);
1804 if (sp == 0)
1805 return false;
1806 }
1807
1808 // Arguments 5 on up are on the stack
1809 const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1810 Status error;
1811 if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1812 sp, arg_byte_size, is_signed, value->GetScalar(), error))
1813 return false;
1814
1815 sp += arg_byte_size;
1816 // Align up to the next 8 byte boundary if needed
1817 if (sp % 8) {
1818 sp >>= 3;
1819 sp += 1;
1820 sp <<= 3;
1821 }
1822 }
1823 }
1824 }
1825 }
1826 return true;
1827 }
1828
SetReturnValueObject(lldb::StackFrameSP & frame_sp,lldb::ValueObjectSP & new_value_sp)1829 Status ABISysV_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1830 lldb::ValueObjectSP &new_value_sp) {
1831 Status error;
1832 if (!new_value_sp) {
1833 error.SetErrorString("Empty value object for return value.");
1834 return error;
1835 }
1836
1837 CompilerType return_value_type = new_value_sp->GetCompilerType();
1838 if (!return_value_type) {
1839 error.SetErrorString("Null clang type for return value.");
1840 return error;
1841 }
1842
1843 Thread *thread = frame_sp->GetThread().get();
1844
1845 RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1846
1847 if (reg_ctx) {
1848 DataExtractor data;
1849 Status data_error;
1850 const uint64_t byte_size = new_value_sp->GetData(data, data_error);
1851 if (data_error.Fail()) {
1852 error.SetErrorStringWithFormat(
1853 "Couldn't convert return value to raw data: %s",
1854 data_error.AsCString());
1855 return error;
1856 }
1857
1858 const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
1859 if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
1860 if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
1861 // Extract the register context so we can read arguments from registers
1862 lldb::offset_t offset = 0;
1863 if (byte_size <= 16) {
1864 const RegisterInfo *x0_info = reg_ctx->GetRegisterInfo(
1865 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
1866 if (byte_size <= 8) {
1867 uint64_t raw_value = data.GetMaxU64(&offset, byte_size);
1868
1869 if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value))
1870 error.SetErrorString("failed to write register x0");
1871 } else {
1872 uint64_t raw_value = data.GetMaxU64(&offset, 8);
1873
1874 if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) {
1875 const RegisterInfo *x1_info = reg_ctx->GetRegisterInfo(
1876 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
1877 raw_value = data.GetMaxU64(&offset, byte_size - offset);
1878
1879 if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value))
1880 error.SetErrorString("failed to write register x1");
1881 }
1882 }
1883 } else {
1884 error.SetErrorString("We don't support returning longer than 128 bit "
1885 "integer values at present.");
1886 }
1887 } else if (type_flags & eTypeIsFloat) {
1888 if (type_flags & eTypeIsComplex) {
1889 // Don't handle complex yet.
1890 error.SetErrorString(
1891 "returning complex float values are not supported");
1892 } else {
1893 const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
1894
1895 if (v0_info) {
1896 if (byte_size <= 16) {
1897 if (byte_size <= RegisterValue::GetMaxByteSize()) {
1898 RegisterValue reg_value;
1899 error = reg_value.SetValueFromData(v0_info, data, 0, true);
1900 if (error.Success()) {
1901 if (!reg_ctx->WriteRegister(v0_info, reg_value))
1902 error.SetErrorString("failed to write register v0");
1903 }
1904 } else {
1905 error.SetErrorStringWithFormat(
1906 "returning float values with a byte size of %" PRIu64
1907 " are not supported",
1908 byte_size);
1909 }
1910 } else {
1911 error.SetErrorString("returning float values longer than 128 "
1912 "bits are not supported");
1913 }
1914 } else {
1915 error.SetErrorString("v0 register is not available on this target");
1916 }
1917 }
1918 }
1919 } else if (type_flags & eTypeIsVector) {
1920 if (byte_size > 0) {
1921 const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
1922
1923 if (v0_info) {
1924 if (byte_size <= v0_info->byte_size) {
1925 RegisterValue reg_value;
1926 error = reg_value.SetValueFromData(v0_info, data, 0, true);
1927 if (error.Success()) {
1928 if (!reg_ctx->WriteRegister(v0_info, reg_value))
1929 error.SetErrorString("failed to write register v0");
1930 }
1931 }
1932 }
1933 }
1934 }
1935 } else {
1936 error.SetErrorString("no registers are available");
1937 }
1938
1939 return error;
1940 }
1941
CreateFunctionEntryUnwindPlan(UnwindPlan & unwind_plan)1942 bool ABISysV_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
1943 unwind_plan.Clear();
1944 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1945
1946 uint32_t lr_reg_num = arm64_dwarf::lr;
1947 uint32_t sp_reg_num = arm64_dwarf::sp;
1948
1949 UnwindPlan::RowSP row(new UnwindPlan::Row);
1950
1951 // Our previous Call Frame Address is the stack pointer
1952 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1953
1954 unwind_plan.AppendRow(row);
1955 unwind_plan.SetReturnAddressRegister(lr_reg_num);
1956
1957 // All other registers are the same.
1958
1959 unwind_plan.SetSourceName("arm64 at-func-entry default");
1960 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1961 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1962 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
1963
1964 return true;
1965 }
1966
CreateDefaultUnwindPlan(UnwindPlan & unwind_plan)1967 bool ABISysV_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
1968 unwind_plan.Clear();
1969 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1970
1971 uint32_t fp_reg_num = arm64_dwarf::fp;
1972 uint32_t pc_reg_num = arm64_dwarf::pc;
1973
1974 UnwindPlan::RowSP row(new UnwindPlan::Row);
1975 const int32_t ptr_size = 8;
1976
1977 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
1978 row->SetOffset(0);
1979
1980 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1981 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1982
1983 unwind_plan.AppendRow(row);
1984 unwind_plan.SetSourceName("arm64 default unwind plan");
1985 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1986 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1987 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
1988
1989 return true;
1990 }
1991
1992 // AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
1993 // registers x19 through x28 and sp are callee preserved. v8-v15 are non-
1994 // volatile (and specifically only the lower 8 bytes of these regs), the rest
1995 // of the fp/SIMD registers are volatile.
1996
1997 // We treat x29 as callee preserved also, else the unwinder won't try to
1998 // retrieve fp saves.
1999
RegisterIsVolatile(const RegisterInfo * reg_info)2000 bool ABISysV_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) {
2001 if (reg_info) {
2002 const char *name = reg_info->name;
2003
2004 // Sometimes we'll be called with the "alternate" name for these registers;
2005 // recognize them as non-volatile.
2006
2007 if (name[0] == 'p' && name[1] == 'c') // pc
2008 return false;
2009 if (name[0] == 'f' && name[1] == 'p') // fp
2010 return false;
2011 if (name[0] == 's' && name[1] == 'p') // sp
2012 return false;
2013 if (name[0] == 'l' && name[1] == 'r') // lr
2014 return false;
2015
2016 if (name[0] == 'x' || name[0] == 'r') {
2017 // Volatile registers: x0-x18
2018 // Although documentation says only x19-28 + sp are callee saved We ll
2019 // also have to treat x30 as non-volatile. Each dwarf frame has its own
2020 // value of lr. Return false for the non-volatile gpr regs, true for
2021 // everything else
2022 switch (name[1]) {
2023 case '1':
2024 switch (name[2]) {
2025 case '9':
2026 return false; // x19 is non-volatile
2027 default:
2028 return true;
2029 }
2030 break;
2031 case '2':
2032 switch (name[2]) {
2033 case '0':
2034 case '1':
2035 case '2':
2036 case '3':
2037 case '4':
2038 case '5':
2039 case '6':
2040 case '7':
2041 case '8':
2042 return false; // x20 - 28 are non-volatile
2043 case '9':
2044 return false; // x29 aka fp treat as non-volatile
2045 default:
2046 return true;
2047 }
2048 case '3': // x30 (lr) and x31 (sp) treat as non-volatile
2049 if (name[2] == '0' || name[2] == '1')
2050 return false;
2051 break;
2052 default:
2053 return true; // all volatile cases not handled above fall here.
2054 }
2055 } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
2056 // Volatile registers: v0-7, v16-v31
2057 // Return false for non-volatile fp/SIMD regs, true for everything else
2058 switch (name[1]) {
2059 case '8':
2060 case '9':
2061 return false; // v8-v9 are non-volatile
2062 case '1':
2063 switch (name[2]) {
2064 case '0':
2065 case '1':
2066 case '2':
2067 case '3':
2068 case '4':
2069 case '5':
2070 return false; // v10-v15 are non-volatile
2071 default:
2072 return true;
2073 }
2074 default:
2075 return true;
2076 }
2077 }
2078 }
2079 return true;
2080 }
2081
LoadValueFromConsecutiveGPRRegisters(ExecutionContext & exe_ctx,RegisterContext * reg_ctx,const CompilerType & value_type,bool is_return_value,uint32_t & NGRN,uint32_t & NSRN,DataExtractor & data)2082 static bool LoadValueFromConsecutiveGPRRegisters(
2083 ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
2084 const CompilerType &value_type,
2085 bool is_return_value, // false => parameter, true => return value
2086 uint32_t &NGRN, // NGRN (see ABI documentation)
2087 uint32_t &NSRN, // NSRN (see ABI documentation)
2088 DataExtractor &data) {
2089 llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
2090
2091 if (byte_size || *byte_size == 0)
2092 return false;
2093
2094 std::unique_ptr<DataBufferHeap> heap_data_up(
2095 new DataBufferHeap(*byte_size, 0));
2096 const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
2097 Status error;
2098
2099 CompilerType base_type;
2100 const uint32_t homogeneous_count =
2101 value_type.IsHomogeneousAggregate(&base_type);
2102 if (homogeneous_count > 0 && homogeneous_count <= 8) {
2103 // Make sure we have enough registers
2104 if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
2105 if (!base_type)
2106 return false;
2107 llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
2108 if (!base_byte_size)
2109 return false;
2110 uint32_t data_offset = 0;
2111
2112 for (uint32_t i = 0; i < homogeneous_count; ++i) {
2113 char v_name[8];
2114 ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
2115 const RegisterInfo *reg_info =
2116 reg_ctx->GetRegisterInfoByName(v_name, 0);
2117 if (reg_info == nullptr)
2118 return false;
2119
2120 if (*base_byte_size > reg_info->byte_size)
2121 return false;
2122
2123 RegisterValue reg_value;
2124
2125 if (!reg_ctx->ReadRegister(reg_info, reg_value))
2126 return false;
2127
2128 // Make sure we have enough room in "heap_data_up"
2129 if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
2130 const size_t bytes_copied = reg_value.GetAsMemoryData(
2131 reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
2132 byte_order, error);
2133 if (bytes_copied != *base_byte_size)
2134 return false;
2135 data_offset += bytes_copied;
2136 ++NSRN;
2137 } else
2138 return false;
2139 }
2140 data.SetByteOrder(byte_order);
2141 data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
2142 data.SetData(DataBufferSP(heap_data_up.release()));
2143 return true;
2144 }
2145 }
2146
2147 const size_t max_reg_byte_size = 16;
2148 if (*byte_size <= max_reg_byte_size) {
2149 size_t bytes_left = *byte_size;
2150 uint32_t data_offset = 0;
2151 while (data_offset < *byte_size) {
2152 if (NGRN >= 8)
2153 return false;
2154
2155 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
2156 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
2157 if (reg_info == nullptr)
2158 return false;
2159
2160 RegisterValue reg_value;
2161
2162 if (!reg_ctx->ReadRegister(reg_info, reg_value))
2163 return false;
2164
2165 const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
2166 const size_t bytes_copied = reg_value.GetAsMemoryData(
2167 reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
2168 byte_order, error);
2169 if (bytes_copied == 0)
2170 return false;
2171 if (bytes_copied >= bytes_left)
2172 break;
2173 data_offset += bytes_copied;
2174 bytes_left -= bytes_copied;
2175 ++NGRN;
2176 }
2177 } else {
2178 const RegisterInfo *reg_info = nullptr;
2179 if (is_return_value) {
2180 // We are assuming we are decoding this immediately after returning from
2181 // a function call and that the address of the structure is in x8
2182 reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
2183 } else {
2184 // We are assuming we are stopped at the first instruction in a function
2185 // and that the ABI is being respected so all parameters appear where
2186 // they should be (functions with no external linkage can legally violate
2187 // the ABI).
2188 if (NGRN >= 8)
2189 return false;
2190
2191 reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
2192 LLDB_REGNUM_GENERIC_ARG1 + NGRN);
2193 if (reg_info == nullptr)
2194 return false;
2195 ++NGRN;
2196 }
2197
2198 if (reg_info == nullptr)
2199 return false;
2200
2201 const lldb::addr_t value_addr =
2202 reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS);
2203
2204 if (value_addr == LLDB_INVALID_ADDRESS)
2205 return false;
2206
2207 if (exe_ctx.GetProcessRef().ReadMemory(
2208 value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(),
2209 error) != heap_data_up->GetByteSize()) {
2210 return false;
2211 }
2212 }
2213
2214 data.SetByteOrder(byte_order);
2215 data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
2216 data.SetData(DataBufferSP(heap_data_up.release()));
2217 return true;
2218 }
2219
GetReturnValueObjectImpl(Thread & thread,CompilerType & return_compiler_type) const2220 ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl(
2221 Thread &thread, CompilerType &return_compiler_type) const {
2222 ValueObjectSP return_valobj_sp;
2223 Value value;
2224
2225 ExecutionContext exe_ctx(thread.shared_from_this());
2226 if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
2227 return return_valobj_sp;
2228
2229 // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
2230 value.SetCompilerType(return_compiler_type);
2231
2232 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
2233 if (!reg_ctx)
2234 return return_valobj_sp;
2235
2236 llvm::Optional<uint64_t> byte_size =
2237 return_compiler_type.GetByteSize(nullptr);
2238 if (!byte_size)
2239 return return_valobj_sp;
2240
2241 const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
2242 if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
2243 value.SetValueType(Value::eValueTypeScalar);
2244
2245 bool success = false;
2246 if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
2247 // Extract the register context so we can read arguments from registers
2248 if (*byte_size <= 8) {
2249 const RegisterInfo *x0_reg_info = nullptr;
2250 x0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
2251 LLDB_REGNUM_GENERIC_ARG1);
2252 if (x0_reg_info) {
2253 uint64_t raw_value =
2254 thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
2255 0);
2256 const bool is_signed = (type_flags & eTypeIsSigned) != 0;
2257 switch (*byte_size) {
2258 default:
2259 break;
2260 case 16: // uint128_t
2261 // In register x0 and x1
2262 {
2263 const RegisterInfo *x1_reg_info = nullptr;
2264 x1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
2265 LLDB_REGNUM_GENERIC_ARG2);
2266
2267 if (x1_reg_info) {
2268 if (*byte_size <=
2269 x0_reg_info->byte_size + x1_reg_info->byte_size) {
2270 std::unique_ptr<DataBufferHeap> heap_data_up(
2271 new DataBufferHeap(*byte_size, 0));
2272 const ByteOrder byte_order =
2273 exe_ctx.GetProcessRef().GetByteOrder();
2274 RegisterValue x0_reg_value;
2275 RegisterValue x1_reg_value;
2276 if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
2277 reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
2278 Status error;
2279 if (x0_reg_value.GetAsMemoryData(
2280 x0_reg_info, heap_data_up->GetBytes() + 0, 8,
2281 byte_order, error) &&
2282 x1_reg_value.GetAsMemoryData(
2283 x1_reg_info, heap_data_up->GetBytes() + 8, 8,
2284 byte_order, error)) {
2285 DataExtractor data(
2286 DataBufferSP(heap_data_up.release()), byte_order,
2287 exe_ctx.GetProcessRef().GetAddressByteSize());
2288
2289 return_valobj_sp = ValueObjectConstResult::Create(
2290 &thread, return_compiler_type, ConstString(""), data);
2291 return return_valobj_sp;
2292 }
2293 }
2294 }
2295 }
2296 }
2297 break;
2298 case sizeof(uint64_t):
2299 if (is_signed)
2300 value.GetScalar() = (int64_t)(raw_value);
2301 else
2302 value.GetScalar() = (uint64_t)(raw_value);
2303 success = true;
2304 break;
2305
2306 case sizeof(uint32_t):
2307 if (is_signed)
2308 value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
2309 else
2310 value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
2311 success = true;
2312 break;
2313
2314 case sizeof(uint16_t):
2315 if (is_signed)
2316 value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
2317 else
2318 value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
2319 success = true;
2320 break;
2321
2322 case sizeof(uint8_t):
2323 if (is_signed)
2324 value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
2325 else
2326 value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
2327 success = true;
2328 break;
2329 }
2330 }
2331 }
2332 } else if (type_flags & eTypeIsFloat) {
2333 if (type_flags & eTypeIsComplex) {
2334 // Don't handle complex yet.
2335 } else {
2336 if (*byte_size <= sizeof(long double)) {
2337 const RegisterInfo *v0_reg_info =
2338 reg_ctx->GetRegisterInfoByName("v0", 0);
2339 RegisterValue v0_value;
2340 if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
2341 DataExtractor data;
2342 if (v0_value.GetData(data)) {
2343 lldb::offset_t offset = 0;
2344 if (*byte_size == sizeof(float)) {
2345 value.GetScalar() = data.GetFloat(&offset);
2346 success = true;
2347 } else if (*byte_size == sizeof(double)) {
2348 value.GetScalar() = data.GetDouble(&offset);
2349 success = true;
2350 } else if (*byte_size == sizeof(long double)) {
2351 value.GetScalar() = data.GetLongDouble(&offset);
2352 success = true;
2353 }
2354 }
2355 }
2356 }
2357 }
2358 }
2359
2360 if (success)
2361 return_valobj_sp = ValueObjectConstResult::Create(
2362 thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
2363 } else if (type_flags & eTypeIsVector && *byte_size <= 16) {
2364 if (*byte_size > 0) {
2365 const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
2366
2367 if (v0_info) {
2368 std::unique_ptr<DataBufferHeap> heap_data_up(
2369 new DataBufferHeap(*byte_size, 0));
2370 const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
2371 RegisterValue reg_value;
2372 if (reg_ctx->ReadRegister(v0_info, reg_value)) {
2373 Status error;
2374 if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
2375 heap_data_up->GetByteSize(), byte_order,
2376 error)) {
2377 DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order,
2378 exe_ctx.GetProcessRef().GetAddressByteSize());
2379 return_valobj_sp = ValueObjectConstResult::Create(
2380 &thread, return_compiler_type, ConstString(""), data);
2381 }
2382 }
2383 }
2384 }
2385 } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
2386 (type_flags & eTypeIsVector && *byte_size > 16)) {
2387 DataExtractor data;
2388
2389 uint32_t NGRN = 0; // Search ABI docs for NGRN
2390 uint32_t NSRN = 0; // Search ABI docs for NSRN
2391 const bool is_return_value = true;
2392 if (LoadValueFromConsecutiveGPRRegisters(
2393 exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
2394 data)) {
2395 return_valobj_sp = ValueObjectConstResult::Create(
2396 &thread, return_compiler_type, ConstString(""), data);
2397 }
2398 }
2399 return return_valobj_sp;
2400 }
2401
Initialize()2402 void ABISysV_arm64::Initialize() {
2403 PluginManager::RegisterPlugin(GetPluginNameStatic(),
2404 "SysV ABI for AArch64 targets", CreateInstance);
2405 }
2406
Terminate()2407 void ABISysV_arm64::Terminate() {
2408 PluginManager::UnregisterPlugin(CreateInstance);
2409 }
2410
GetPluginNameStatic()2411 lldb_private::ConstString ABISysV_arm64::GetPluginNameStatic() {
2412 static ConstString g_name("SysV-arm64");
2413 return g_name;
2414 }
2415
2416 // PluginInterface protocol
2417
GetPluginName()2418 ConstString ABISysV_arm64::GetPluginName() { return GetPluginNameStatic(); }
2419
GetPluginVersion()2420 uint32_t ABISysV_arm64::GetPluginVersion() { return 1; }
2421