?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Run DCE after a LoopFlatten test to reduce spurious output [nfc]
[llvm-project.git] / lldb / source / Plugins / ABI / ARM / ABIMacOSX_arm.cpp
blob51067a2a29013a0b52206234a7317cc273b75ea8
1 //===-- ABIMacOSX_arm.cpp -------------------------------------------------===//
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 "ABIMacOSX_arm.h"
10
11 #include <optional>
12 #include <vector>
13
14 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/TargetParser/Triple.h"
16
17 #include "lldb/Core/Module.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/Value.h"
20 #include "lldb/Core/ValueObjectConstResult.h"
21 #include "lldb/Symbol/UnwindPlan.h"
22 #include "lldb/Target/Process.h"
23 #include "lldb/Target/RegisterContext.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Target/Thread.h"
26 #include "lldb/Utility/ConstString.h"
27 #include "lldb/Utility/RegisterValue.h"
28 #include "lldb/Utility/Scalar.h"
29 #include "lldb/Utility/Status.h"
30
31 #include "Plugins/Process/Utility/ARMDefines.h"
32 #include "Utility/ARM_DWARF_Registers.h"
33 #include "Utility/ARM_ehframe_Registers.h"
34
35 using namespace lldb;
36 using namespace lldb_private;
37
38 static const RegisterInfo g_register_infos[] = {
39 // NAME ALT SZ OFF ENCODING FORMAT EH_FRAME
40 // DWARF GENERIC PROCESS PLUGIN
41 // LLDB NATIVE
42 // ========== ======= == === ============= ============
43 // ======================= =================== ===========================
44 // ======================= ======================
45 {"r0",
46 nullptr,
47 4,
48 0,
49 eEncodingUint,
50 eFormatHex,
51 {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
52 LLDB_INVALID_REGNUM},
53 nullptr,
54 nullptr,
55 nullptr,
56 },
57 {"r1",
58 nullptr,
59 4,
60 0,
61 eEncodingUint,
62 eFormatHex,
63 {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
64 LLDB_INVALID_REGNUM},
65 nullptr,
66 nullptr,
67 nullptr,
68 },
69 {"r2",
70 nullptr,
71 4,
72 0,
73 eEncodingUint,
74 eFormatHex,
75 {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
76 LLDB_INVALID_REGNUM},
77 nullptr,
78 nullptr,
79 nullptr,
80 },
81 {"r3",
82 nullptr,
83 4,
84 0,
85 eEncodingUint,
86 eFormatHex,
87 {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
88 LLDB_INVALID_REGNUM},
89 nullptr,
90 nullptr,
91 nullptr,
92 },
93 {"r4",
94 nullptr,
95 4,
96 0,
97 eEncodingUint,
98 eFormatHex,
99 {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
100 LLDB_INVALID_REGNUM},
101 nullptr,
102 nullptr,
103 nullptr,
104 },
105 {"r5",
106 nullptr,
107 4,
108 0,
109 eEncodingUint,
110 eFormatHex,
111 {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
112 LLDB_INVALID_REGNUM},
113 nullptr,
114 nullptr,
115 nullptr,
116 },
117 {"r6",
118 nullptr,
119 4,
120 0,
121 eEncodingUint,
122 eFormatHex,
123 {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
124 LLDB_INVALID_REGNUM},
125 nullptr,
126 nullptr,
127 nullptr,
128 },
129 {"r7",
130 nullptr,
131 4,
132 0,
133 eEncodingUint,
134 eFormatHex,
135 {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
136 LLDB_INVALID_REGNUM},
137 nullptr,
138 nullptr,
139 nullptr,
140 },
141 {"r8",
142 nullptr,
143 4,
144 0,
145 eEncodingUint,
146 eFormatHex,
147 {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
148 LLDB_INVALID_REGNUM},
149 nullptr,
150 nullptr,
151 nullptr,
152 },
153 {"r9",
154 nullptr,
155 4,
156 0,
157 eEncodingUint,
158 eFormatHex,
159 {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
160 LLDB_INVALID_REGNUM},
161 nullptr,
162 nullptr,
163 nullptr,
164 },
165 {"r10",
166 nullptr,
167 4,
168 0,
169 eEncodingUint,
170 eFormatHex,
171 {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
172 LLDB_INVALID_REGNUM},
173 nullptr,
174 nullptr,
175 nullptr,
176 },
177 {"r11",
178 nullptr,
179 4,
180 0,
181 eEncodingUint,
182 eFormatHex,
183 {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
184 LLDB_INVALID_REGNUM},
185 nullptr,
186 nullptr,
187 nullptr,
188 },
189 {"r12",
190 nullptr,
191 4,
192 0,
193 eEncodingUint,
194 eFormatHex,
195 {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
196 LLDB_INVALID_REGNUM},
197 nullptr,
198 nullptr,
199 nullptr,
200 },
201 {"sp",
202 "r13",
203 4,
204 0,
205 eEncodingUint,
206 eFormatHex,
207 {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
208 LLDB_INVALID_REGNUM},
209 nullptr,
210 nullptr,
211 nullptr,
212 },
213 {"lr",
214 "r14",
215 4,
216 0,
217 eEncodingUint,
218 eFormatHex,
219 {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
220 LLDB_INVALID_REGNUM},
221 nullptr,
222 nullptr,
223 nullptr,
224 },
225 {"pc",
226 "r15",
227 4,
228 0,
229 eEncodingUint,
230 eFormatHex,
231 {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
232 LLDB_INVALID_REGNUM},
233 nullptr,
234 nullptr,
235 nullptr,
236 },
237 {"cpsr",
238 "psr",
239 4,
240 0,
241 eEncodingUint,
242 eFormatHex,
243 {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
244 LLDB_INVALID_REGNUM},
245 nullptr,
246 nullptr,
247 nullptr,
248 },
249 {"s0",
250 nullptr,
251 4,
252 0,
253 eEncodingIEEE754,
254 eFormatFloat,
255 {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
256 LLDB_INVALID_REGNUM},
257 nullptr,
258 nullptr,
259 nullptr,
260 },
261 {"s1",
262 nullptr,
263 4,
264 0,
265 eEncodingIEEE754,
266 eFormatFloat,
267 {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
268 LLDB_INVALID_REGNUM},
269 nullptr,
270 nullptr,
271 nullptr,
272 },
273 {"s2",
274 nullptr,
275 4,
276 0,
277 eEncodingIEEE754,
278 eFormatFloat,
279 {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
280 LLDB_INVALID_REGNUM},
281 nullptr,
282 nullptr,
283 nullptr,
284 },
285 {"s3",
286 nullptr,
287 4,
288 0,
289 eEncodingIEEE754,
290 eFormatFloat,
291 {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
292 LLDB_INVALID_REGNUM},
293 nullptr,
294 nullptr,
295 nullptr,
296 },
297 {"s4",
298 nullptr,
299 4,
300 0,
301 eEncodingIEEE754,
302 eFormatFloat,
303 {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
304 LLDB_INVALID_REGNUM},
305 nullptr,
306 nullptr,
307 nullptr,
308 },
309 {"s5",
310 nullptr,
311 4,
312 0,
313 eEncodingIEEE754,
314 eFormatFloat,
315 {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
316 LLDB_INVALID_REGNUM},
317 nullptr,
318 nullptr,
319 nullptr,
320 },
321 {"s6",
322 nullptr,
323 4,
324 0,
325 eEncodingIEEE754,
326 eFormatFloat,
327 {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
328 LLDB_INVALID_REGNUM},
329 nullptr,
330 nullptr,
331 nullptr,
332 },
333 {"s7",
334 nullptr,
335 4,
336 0,
337 eEncodingIEEE754,
338 eFormatFloat,
339 {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
340 LLDB_INVALID_REGNUM},
341 nullptr,
342 nullptr,
343 nullptr,
344 },
345 {"s8",
346 nullptr,
347 4,
348 0,
349 eEncodingIEEE754,
350 eFormatFloat,
351 {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
352 LLDB_INVALID_REGNUM},
353 nullptr,
354 nullptr,
355 nullptr,
356 },
357 {"s9",
358 nullptr,
359 4,
360 0,
361 eEncodingIEEE754,
362 eFormatFloat,
363 {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
364 LLDB_INVALID_REGNUM},
365 nullptr,
366 nullptr,
367 nullptr,
368 },
369 {"s10",
370 nullptr,
371 4,
372 0,
373 eEncodingIEEE754,
374 eFormatFloat,
375 {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
376 LLDB_INVALID_REGNUM},
377 nullptr,
378 nullptr,
379 nullptr,
380 },
381 {"s11",
382 nullptr,
383 4,
384 0,
385 eEncodingIEEE754,
386 eFormatFloat,
387 {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
388 LLDB_INVALID_REGNUM},
389 nullptr,
390 nullptr,
391 nullptr,
392 },
393 {"s12",
394 nullptr,
395 4,
396 0,
397 eEncodingIEEE754,
398 eFormatFloat,
399 {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
400 LLDB_INVALID_REGNUM},
401 nullptr,
402 nullptr,
403 nullptr,
404 },
405 {"s13",
406 nullptr,
407 4,
408 0,
409 eEncodingIEEE754,
410 eFormatFloat,
411 {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
412 LLDB_INVALID_REGNUM},
413 nullptr,
414 nullptr,
415 nullptr,
416 },
417 {"s14",
418 nullptr,
419 4,
420 0,
421 eEncodingIEEE754,
422 eFormatFloat,
423 {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
424 LLDB_INVALID_REGNUM},
425 nullptr,
426 nullptr,
427 nullptr,
428 },
429 {"s15",
430 nullptr,
431 4,
432 0,
433 eEncodingIEEE754,
434 eFormatFloat,
435 {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
436 LLDB_INVALID_REGNUM},
437 nullptr,
438 nullptr,
439 nullptr,
440 },
441 {"s16",
442 nullptr,
443 4,
444 0,
445 eEncodingIEEE754,
446 eFormatFloat,
447 {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
448 LLDB_INVALID_REGNUM},
449 nullptr,
450 nullptr,
451 nullptr,
452 },
453 {"s17",
454 nullptr,
455 4,
456 0,
457 eEncodingIEEE754,
458 eFormatFloat,
459 {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
460 LLDB_INVALID_REGNUM},
461 nullptr,
462 nullptr,
463 nullptr,
464 },
465 {"s18",
466 nullptr,
467 4,
468 0,
469 eEncodingIEEE754,
470 eFormatFloat,
471 {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
472 LLDB_INVALID_REGNUM},
473 nullptr,
474 nullptr,
475 nullptr,
476 },
477 {"s19",
478 nullptr,
479 4,
480 0,
481 eEncodingIEEE754,
482 eFormatFloat,
483 {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
484 LLDB_INVALID_REGNUM},
485 nullptr,
486 nullptr,
487 nullptr,
488 },
489 {"s20",
490 nullptr,
491 4,
492 0,
493 eEncodingIEEE754,
494 eFormatFloat,
495 {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
496 LLDB_INVALID_REGNUM},
497 nullptr,
498 nullptr,
499 nullptr,
500 },
501 {"s21",
502 nullptr,
503 4,
504 0,
505 eEncodingIEEE754,
506 eFormatFloat,
507 {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
508 LLDB_INVALID_REGNUM},
509 nullptr,
510 nullptr,
511 nullptr,
512 },
513 {"s22",
514 nullptr,
515 4,
516 0,
517 eEncodingIEEE754,
518 eFormatFloat,
519 {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
520 LLDB_INVALID_REGNUM},
521 nullptr,
522 nullptr,
523 nullptr,
524 },
525 {"s23",
526 nullptr,
527 4,
528 0,
529 eEncodingIEEE754,
530 eFormatFloat,
531 {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
532 LLDB_INVALID_REGNUM},
533 nullptr,
534 nullptr,
535 nullptr,
536 },
537 {"s24",
538 nullptr,
539 4,
540 0,
541 eEncodingIEEE754,
542 eFormatFloat,
543 {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
544 LLDB_INVALID_REGNUM},
545 nullptr,
546 nullptr,
547 nullptr,
548 },
549 {"s25",
550 nullptr,
551 4,
552 0,
553 eEncodingIEEE754,
554 eFormatFloat,
555 {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
556 LLDB_INVALID_REGNUM},
557 nullptr,
558 nullptr,
559 nullptr,
560 },
561 {"s26",
562 nullptr,
563 4,
564 0,
565 eEncodingIEEE754,
566 eFormatFloat,
567 {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
568 LLDB_INVALID_REGNUM},
569 nullptr,
570 nullptr,
571 nullptr,
572 },
573 {"s27",
574 nullptr,
575 4,
576 0,
577 eEncodingIEEE754,
578 eFormatFloat,
579 {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
580 LLDB_INVALID_REGNUM},
581 nullptr,
582 nullptr,
583 nullptr,
584 },
585 {"s28",
586 nullptr,
587 4,
588 0,
589 eEncodingIEEE754,
590 eFormatFloat,
591 {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
592 LLDB_INVALID_REGNUM},
593 nullptr,
594 nullptr,
595 nullptr,
596 },
597 {"s29",
598 nullptr,
599 4,
600 0,
601 eEncodingIEEE754,
602 eFormatFloat,
603 {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
604 LLDB_INVALID_REGNUM},
605 nullptr,
606 nullptr,
607 nullptr,
608 },
609 {"s30",
610 nullptr,
611 4,
612 0,
613 eEncodingIEEE754,
614 eFormatFloat,
615 {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
616 LLDB_INVALID_REGNUM},
617 nullptr,
618 nullptr,
619 nullptr,
620 },
621 {"s31",
622 nullptr,
623 4,
624 0,
625 eEncodingIEEE754,
626 eFormatFloat,
627 {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
628 LLDB_INVALID_REGNUM},
629 nullptr,
630 nullptr,
631 nullptr,
632 },
633 {"fpscr",
634 nullptr,
635 4,
636 0,
637 eEncodingUint,
638 eFormatHex,
639 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
640 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
641 nullptr,
642 nullptr,
643 nullptr,
644 },
645 {"d0",
646 nullptr,
647 8,
648 0,
649 eEncodingIEEE754,
650 eFormatFloat,
651 {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
652 LLDB_INVALID_REGNUM},
653 nullptr,
654 nullptr,
655 nullptr,
656 },
657 {"d1",
658 nullptr,
659 8,
660 0,
661 eEncodingIEEE754,
662 eFormatFloat,
663 {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
664 LLDB_INVALID_REGNUM},
665 nullptr,
666 nullptr,
667 nullptr,
668 },
669 {"d2",
670 nullptr,
671 8,
672 0,
673 eEncodingIEEE754,
674 eFormatFloat,
675 {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
676 LLDB_INVALID_REGNUM},
677 nullptr,
678 nullptr,
679 nullptr,
680 },
681 {"d3",
682 nullptr,
683 8,
684 0,
685 eEncodingIEEE754,
686 eFormatFloat,
687 {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
688 LLDB_INVALID_REGNUM},
689 nullptr,
690 nullptr,
691 nullptr,
692 },
693 {"d4",
694 nullptr,
695 8,
696 0,
697 eEncodingIEEE754,
698 eFormatFloat,
699 {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
700 LLDB_INVALID_REGNUM},
701 nullptr,
702 nullptr,
703 nullptr,
704 },
705 {"d5",
706 nullptr,
707 8,
708 0,
709 eEncodingIEEE754,
710 eFormatFloat,
711 {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
712 LLDB_INVALID_REGNUM},
713 nullptr,
714 nullptr,
715 nullptr,
716 },
717 {"d6",
718 nullptr,
719 8,
720 0,
721 eEncodingIEEE754,
722 eFormatFloat,
723 {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
724 LLDB_INVALID_REGNUM},
725 nullptr,
726 nullptr,
727 nullptr,
728 },
729 {"d7",
730 nullptr,
731 8,
732 0,
733 eEncodingIEEE754,
734 eFormatFloat,
735 {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
736 LLDB_INVALID_REGNUM},
737 nullptr,
738 nullptr,
739 nullptr,
740 },
741 {"d8",
742 nullptr,
743 8,
744 0,
745 eEncodingIEEE754,
746 eFormatFloat,
747 {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
748 LLDB_INVALID_REGNUM},
749 nullptr,
750 nullptr,
751 nullptr,
752 },
753 {"d9",
754 nullptr,
755 8,
756 0,
757 eEncodingIEEE754,
758 eFormatFloat,
759 {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
760 LLDB_INVALID_REGNUM},
761 nullptr,
762 nullptr,
763 nullptr,
764 },
765 {"d10",
766 nullptr,
767 8,
768 0,
769 eEncodingIEEE754,
770 eFormatFloat,
771 {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
772 LLDB_INVALID_REGNUM},
773 nullptr,
774 nullptr,
775 nullptr,
776 },
777 {"d11",
778 nullptr,
779 8,
780 0,
781 eEncodingIEEE754,
782 eFormatFloat,
783 {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
784 LLDB_INVALID_REGNUM},
785 nullptr,
786 nullptr,
787 nullptr,
788 },
789 {"d12",
790 nullptr,
791 8,
792 0,
793 eEncodingIEEE754,
794 eFormatFloat,
795 {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
796 LLDB_INVALID_REGNUM},
797 nullptr,
798 nullptr,
799 nullptr,
800 },
801 {"d13",
802 nullptr,
803 8,
804 0,
805 eEncodingIEEE754,
806 eFormatFloat,
807 {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
808 LLDB_INVALID_REGNUM},
809 nullptr,
810 nullptr,
811 nullptr,
812 },
813 {"d14",
814 nullptr,
815 8,
816 0,
817 eEncodingIEEE754,
818 eFormatFloat,
819 {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
820 LLDB_INVALID_REGNUM},
821 nullptr,
822 nullptr,
823 nullptr,
824 },
825 {"d15",
826 nullptr,
827 8,
828 0,
829 eEncodingIEEE754,
830 eFormatFloat,
831 {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
832 LLDB_INVALID_REGNUM},
833 nullptr,
834 nullptr,
835 nullptr,
836 },
837 {"d16",
838 nullptr,
839 8,
840 0,
841 eEncodingIEEE754,
842 eFormatFloat,
843 {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
844 LLDB_INVALID_REGNUM},
845 nullptr,
846 nullptr,
847 nullptr,
848 },
849 {"d17",
850 nullptr,
851 8,
852 0,
853 eEncodingIEEE754,
854 eFormatFloat,
855 {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
856 LLDB_INVALID_REGNUM},
857 nullptr,
858 nullptr,
859 nullptr,
860 },
861 {"d18",
862 nullptr,
863 8,
864 0,
865 eEncodingIEEE754,
866 eFormatFloat,
867 {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
868 LLDB_INVALID_REGNUM},
869 nullptr,
870 nullptr,
871 nullptr,
872 },
873 {"d19",
874 nullptr,
875 8,
876 0,
877 eEncodingIEEE754,
878 eFormatFloat,
879 {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
880 LLDB_INVALID_REGNUM},
881 nullptr,
882 nullptr,
883 nullptr,
884 },
885 {"d20",
886 nullptr,
887 8,
888 0,
889 eEncodingIEEE754,
890 eFormatFloat,
891 {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
892 LLDB_INVALID_REGNUM},
893 nullptr,
894 nullptr,
895 nullptr,
896 },
897 {"d21",
898 nullptr,
899 8,
900 0,
901 eEncodingIEEE754,
902 eFormatFloat,
903 {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
904 LLDB_INVALID_REGNUM},
905 nullptr,
906 nullptr,
907 nullptr,
908 },
909 {"d22",
910 nullptr,
911 8,
912 0,
913 eEncodingIEEE754,
914 eFormatFloat,
915 {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
916 LLDB_INVALID_REGNUM},
917 nullptr,
918 nullptr,
919 nullptr,
920 },
921 {"d23",
922 nullptr,
923 8,
924 0,
925 eEncodingIEEE754,
926 eFormatFloat,
927 {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
928 LLDB_INVALID_REGNUM},
929 nullptr,
930 nullptr,
931 nullptr,
932 },
933 {"d24",
934 nullptr,
935 8,
936 0,
937 eEncodingIEEE754,
938 eFormatFloat,
939 {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
940 LLDB_INVALID_REGNUM},
941 nullptr,
942 nullptr,
943 nullptr,
944 },
945 {"d25",
946 nullptr,
947 8,
948 0,
949 eEncodingIEEE754,
950 eFormatFloat,
951 {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
952 LLDB_INVALID_REGNUM},
953 nullptr,
954 nullptr,
955 nullptr,
956 },
957 {"d26",
958 nullptr,
959 8,
960 0,
961 eEncodingIEEE754,
962 eFormatFloat,
963 {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
964 LLDB_INVALID_REGNUM},
965 nullptr,
966 nullptr,
967 nullptr,
968 },
969 {"d27",
970 nullptr,
971 8,
972 0,
973 eEncodingIEEE754,
974 eFormatFloat,
975 {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
976 LLDB_INVALID_REGNUM},
977 nullptr,
978 nullptr,
979 nullptr,
980 },
981 {"d28",
982 nullptr,
983 8,
984 0,
985 eEncodingIEEE754,
986 eFormatFloat,
987 {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
988 LLDB_INVALID_REGNUM},
989 nullptr,
990 nullptr,
991 nullptr,
992 },
993 {"d29",
994 nullptr,
995 8,
996 0,
997 eEncodingIEEE754,
998 eFormatFloat,
999 {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1000 LLDB_INVALID_REGNUM},
1001 nullptr,
1002 nullptr,
1003 nullptr,
1004 },
1005 {"d30",
1006 nullptr,
1007 8,
1008 0,
1009 eEncodingIEEE754,
1010 eFormatFloat,
1011 {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1012 LLDB_INVALID_REGNUM},
1013 nullptr,
1014 nullptr,
1015 nullptr,
1016 },
1017 {"d31",
1018 nullptr,
1019 8,
1020 0,
1021 eEncodingIEEE754,
1022 eFormatFloat,
1023 {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1024 LLDB_INVALID_REGNUM},
1025 nullptr,
1026 nullptr,
1027 nullptr,
1028 },
1029 {"r8_usr",
1030 nullptr,
1031 4,
1032 0,
1033 eEncodingUint,
1034 eFormatHex,
1035 {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
1036 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1037 nullptr,
1038 nullptr,
1039 nullptr,
1040 },
1041 {"r9_usr",
1042 nullptr,
1043 4,
1044 0,
1045 eEncodingUint,
1046 eFormatHex,
1047 {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
1048 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1049 nullptr,
1050 nullptr,
1051 nullptr,
1052 },
1053 {"r10_usr",
1054 nullptr,
1055 4,
1056 0,
1057 eEncodingUint,
1058 eFormatHex,
1059 {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
1060 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1061 nullptr,
1062 nullptr,
1063 nullptr,
1064 },
1065 {"r11_usr",
1066 nullptr,
1067 4,
1068 0,
1069 eEncodingUint,
1070 eFormatHex,
1071 {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
1072 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1073 nullptr,
1074 nullptr,
1075 nullptr,
1076 },
1077 {"r12_usr",
1078 nullptr,
1079 4,
1080 0,
1081 eEncodingUint,
1082 eFormatHex,
1083 {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
1084 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1085 nullptr,
1086 nullptr,
1087 nullptr,
1088 },
1089 {"r13_usr",
1090 "sp_usr",
1091 4,
1092 0,
1093 eEncodingUint,
1094 eFormatHex,
1095 {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
1096 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1097 nullptr,
1098 nullptr,
1099 nullptr,
1100 },
1101 {"r14_usr",
1102 "lr_usr",
1103 4,
1104 0,
1105 eEncodingUint,
1106 eFormatHex,
1107 {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
1108 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1109 nullptr,
1110 nullptr,
1111 nullptr,
1112 },
1113 {"r8_fiq",
1114 nullptr,
1115 4,
1116 0,
1117 eEncodingUint,
1118 eFormatHex,
1119 {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
1120 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1121 nullptr,
1122 nullptr,
1123 nullptr,
1124 },
1125 {"r9_fiq",
1126 nullptr,
1127 4,
1128 0,
1129 eEncodingUint,
1130 eFormatHex,
1131 {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
1132 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1133 nullptr,
1134 nullptr,
1135 nullptr,
1136 },
1137 {"r10_fiq",
1138 nullptr,
1139 4,
1140 0,
1141 eEncodingUint,
1142 eFormatHex,
1143 {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
1144 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1145 nullptr,
1146 nullptr,
1147 nullptr,
1148 },
1149 {"r11_fiq",
1150 nullptr,
1151 4,
1152 0,
1153 eEncodingUint,
1154 eFormatHex,
1155 {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
1156 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1157 nullptr,
1158 nullptr,
1159 nullptr,
1160 },
1161 {"r12_fiq",
1162 nullptr,
1163 4,
1164 0,
1165 eEncodingUint,
1166 eFormatHex,
1167 {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
1168 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1169 nullptr,
1170 nullptr,
1171 nullptr,
1172 },
1173 {"r13_fiq",
1174 "sp_fiq",
1175 4,
1176 0,
1177 eEncodingUint,
1178 eFormatHex,
1179 {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
1180 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1181 nullptr,
1182 nullptr,
1183 nullptr,
1184 },
1185 {"r14_fiq",
1186 "lr_fiq",
1187 4,
1188 0,
1189 eEncodingUint,
1190 eFormatHex,
1191 {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
1192 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1193 nullptr,
1194 nullptr,
1195 nullptr,
1196 },
1197 {"r13_irq",
1198 "sp_irq",
1199 4,
1200 0,
1201 eEncodingUint,
1202 eFormatHex,
1203 {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
1204 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1205 nullptr,
1206 nullptr,
1207 nullptr,
1208 },
1209 {"r14_irq",
1210 "lr_irq",
1211 4,
1212 0,
1213 eEncodingUint,
1214 eFormatHex,
1215 {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
1216 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1217 nullptr,
1218 nullptr,
1219 nullptr,
1220 },
1221 {"r13_abt",
1222 "sp_abt",
1223 4,
1224 0,
1225 eEncodingUint,
1226 eFormatHex,
1227 {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
1228 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1229 nullptr,
1230 nullptr,
1231 nullptr,
1232 },
1233 {"r14_abt",
1234 "lr_abt",
1235 4,
1236 0,
1237 eEncodingUint,
1238 eFormatHex,
1239 {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
1240 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1241 nullptr,
1242 nullptr,
1243 nullptr,
1244 },
1245 {"r13_und",
1246 "sp_und",
1247 4,
1248 0,
1249 eEncodingUint,
1250 eFormatHex,
1251 {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
1252 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1253 nullptr,
1254 nullptr,
1255 nullptr,
1256 },
1257 {"r14_und",
1258 "lr_und",
1259 4,
1260 0,
1261 eEncodingUint,
1262 eFormatHex,
1263 {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
1264 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1265 nullptr,
1266 nullptr,
1267 nullptr,
1268 },
1269 {"r13_svc",
1270 "sp_svc",
1271 4,
1272 0,
1273 eEncodingUint,
1274 eFormatHex,
1275 {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
1276 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1277 nullptr,
1278 nullptr,
1279 nullptr,
1280 },
1281 {"r14_svc",
1282 "lr_svc",
1283 4,
1284 0,
1285 eEncodingUint,
1286 eFormatHex,
1287 {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
1288 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1289 nullptr,
1290 nullptr,
1291 nullptr,
1292 }};
1293
1294 static const uint32_t k_num_register_infos = std::size(g_register_infos);
1295
1296 const lldb_private::RegisterInfo *
1297 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
1298 count = k_num_register_infos;
1299 return g_register_infos;
1300 }
1301
1302 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1303
1304 // Static Functions
1305
1306 ABISP
1307 ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1308 const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1309 const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1310
1311 if (vendor_type == llvm::Triple::Apple) {
1312 if ((arch_type == llvm::Triple::arm) ||
1313 (arch_type == llvm::Triple::thumb)) {
1314 return ABISP(
1315 new ABIMacOSX_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
1316 }
1317 }
1318
1319 return ABISP();
1320 }
1321
1322 bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
1323 addr_t function_addr, addr_t return_addr,
1324 llvm::ArrayRef<addr_t> args) const {
1325 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1326 if (!reg_ctx)
1327 return false;
1328
1329 const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1330 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1331 const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1332 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
1333 const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1334 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
1335
1336 RegisterValue reg_value;
1337
1338 const char *reg_names[] = {"r0", "r1", "r2", "r3"};
1339
1340 llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
1341
1342 for (size_t i = 0; i < std::size(reg_names); ++i) {
1343 if (ai == ae)
1344 break;
1345
1346 reg_value.SetUInt32(*ai);
1347 if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
1348 reg_value))
1349 return false;
1350
1351 ++ai;
1352 }
1353
1354 if (ai != ae) {
1355 // Spill onto the stack
1356 size_t num_stack_regs = ae - ai;
1357
1358 sp -= (num_stack_regs * 4);
1359 // Keep the stack 16 byte aligned
1360 sp &= ~(16ull - 1ull);
1361
1362 // just using arg1 to get the right size
1363 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1364 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
1365
1366 addr_t arg_pos = sp;
1367
1368 for (; ai != ae; ++ai) {
1369 reg_value.SetUInt32(*ai);
1370 if (reg_ctx
1371 ->WriteRegisterValueToMemory(reg_info, arg_pos,
1372 reg_info->byte_size, reg_value)
1373 .Fail())
1374 return false;
1375 arg_pos += reg_info->byte_size;
1376 }
1377 }
1378
1379 TargetSP target_sp(thread.CalculateTarget());
1380 Address so_addr;
1381
1382 // Figure out if our return address is ARM or Thumb by using the
1383 // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
1384 // thumb-ness and set the correct address bits for us.
1385 so_addr.SetLoadAddress(return_addr, target_sp.get());
1386 return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1387
1388 // Set "lr" to the return address
1389 if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
1390 return false;
1391
1392 // If bit zero or 1 is set, this must be a thumb function, no need to figure
1393 // this out from the symbols.
1394 so_addr.SetLoadAddress(function_addr, target_sp.get());
1395 function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1396
1397 const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr");
1398 const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0);
1399
1400 // Make a new CPSR and mask out any Thumb IT (if/then) bits
1401 uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK;
1402 // If bit zero or 1 is set, this must be thumb...
1403 if (function_addr & 1ull)
1404 new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR
1405 else
1406 new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR
1407
1408 if (new_cpsr != curr_cpsr) {
1409 if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr))
1410 return false;
1411 }
1412
1413 function_addr &=
1414 ~1ull; // clear bit zero since the CPSR will take care of the mode for us
1415
1416 // Update the sp - stack pointer - to be aligned to 16-bytes
1417 sp &= ~(0xfull);
1418 if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
1419 return false;
1420
1421 // Set "pc" to the address requested
1422 if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr))
1423 return false;
1424
1425 return true;
1426 }
1427
1428 bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
1429 uint32_t num_values = values.GetSize();
1430
1431 ExecutionContext exe_ctx(thread.shared_from_this());
1432 // For now, assume that the types in the AST values come from the Target's
1433 // scratch AST.
1434
1435 // Extract the register context so we can read arguments from registers
1436
1437 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1438
1439 if (!reg_ctx)
1440 return false;
1441
1442 addr_t sp = 0;
1443
1444 for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1445 // We currently only support extracting values with Clang QualTypes. Do we
1446 // care about others?
1447 Value *value = values.GetValueAtIndex(value_idx);
1448
1449 if (!value)
1450 return false;
1451
1452 CompilerType compiler_type = value->GetCompilerType();
1453 if (compiler_type) {
1454 bool is_signed = false;
1455 size_t bit_width = 0;
1456 std::optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
1457 if (!bit_size)
1458 return false;
1459 if (compiler_type.IsIntegerOrEnumerationType(is_signed))
1460 bit_width = *bit_size;
1461 else if (compiler_type.IsPointerOrReferenceType())
1462 bit_width = *bit_size;
1463 else
1464 // We only handle integer, pointer and reference types currently...
1465 return false;
1466
1467 if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1468 if (value_idx < 4) {
1469 // Arguments 1-4 are in r0-r3...
1470 const RegisterInfo *arg_reg_info = nullptr;
1471 // Search by generic ID first, then fall back to by name
1472 uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1473 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1474 if (arg_reg_num != LLDB_INVALID_REGNUM) {
1475 arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1476 } else {
1477 switch (value_idx) {
1478 case 0:
1479 arg_reg_info = reg_ctx->GetRegisterInfoByName("r0");
1480 break;
1481 case 1:
1482 arg_reg_info = reg_ctx->GetRegisterInfoByName("r1");
1483 break;
1484 case 2:
1485 arg_reg_info = reg_ctx->GetRegisterInfoByName("r2");
1486 break;
1487 case 3:
1488 arg_reg_info = reg_ctx->GetRegisterInfoByName("r3");
1489 break;
1490 }
1491 }
1492
1493 if (arg_reg_info) {
1494 RegisterValue reg_value;
1495
1496 if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) {
1497 if (is_signed)
1498 reg_value.SignExtend(bit_width);
1499 if (!reg_value.GetScalarValue(value->GetScalar()))
1500 return false;
1501 continue;
1502 }
1503 }
1504 return false;
1505 } else {
1506 if (sp == 0) {
1507 // Read the stack pointer if it already hasn't been read
1508 sp = reg_ctx->GetSP(0);
1509 if (sp == 0)
1510 return false;
1511 }
1512
1513 // Arguments 5 on up are on the stack
1514 const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1515 Status error;
1516 if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1517 sp, arg_byte_size, is_signed, value->GetScalar(), error))
1518 return false;
1519
1520 sp += arg_byte_size;
1521 }
1522 }
1523 }
1524 }
1525 return true;
1526 }
1527
1528 bool ABIMacOSX_arm::IsArmv7kProcess() const {
1529 bool is_armv7k = false;
1530 ProcessSP process_sp(GetProcessSP());
1531 if (process_sp) {
1532 const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
1533 const ArchSpec::Core system_core = arch.GetCore();
1534 if (system_core == ArchSpec::eCore_arm_armv7k) {
1535 is_armv7k = true;
1536 }
1537 }
1538 return is_armv7k;
1539 }
1540
1541 ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl(
1542 Thread &thread, lldb_private::CompilerType &compiler_type) const {
1543 Value value;
1544 ValueObjectSP return_valobj_sp;
1545
1546 if (!compiler_type)
1547 return return_valobj_sp;
1548
1549 value.SetCompilerType(compiler_type);
1550
1551 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1552 if (!reg_ctx)
1553 return return_valobj_sp;
1554
1555 bool is_signed;
1556
1557 // Get the pointer to the first stack argument so we have a place to start
1558 // when reading data
1559
1560 const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1561 if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1562 std::optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
1563 if (!bit_width)
1564 return return_valobj_sp;
1565
1566 switch (*bit_width) {
1567 default:
1568 return return_valobj_sp;
1569 case 128:
1570 if (IsArmv7kProcess()) {
1571 // "A composite type not larger than 16 bytes is returned in r0-r3. The
1572 // format is as if the result had been stored in memory at a word-
1573 // aligned address and then loaded into r0-r3 with an ldm instruction"
1574 {
1575 const RegisterInfo *r1_reg_info =
1576 reg_ctx->GetRegisterInfoByName("r1", 0);
1577 const RegisterInfo *r2_reg_info =
1578 reg_ctx->GetRegisterInfoByName("r2", 0);
1579 const RegisterInfo *r3_reg_info =
1580 reg_ctx->GetRegisterInfoByName("r3", 0);
1581 if (r1_reg_info && r2_reg_info && r3_reg_info) {
1582 std::optional<uint64_t> byte_size =
1583 compiler_type.GetByteSize(&thread);
1584 if (!byte_size)
1585 return return_valobj_sp;
1586 ProcessSP process_sp(thread.GetProcess());
1587 if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
1588 r2_reg_info->byte_size +
1589 r3_reg_info->byte_size &&
1590 process_sp) {
1591 std::unique_ptr<DataBufferHeap> heap_data_up(
1592 new DataBufferHeap(*byte_size, 0));
1593 const ByteOrder byte_order = process_sp->GetByteOrder();
1594 RegisterValue r0_reg_value;
1595 RegisterValue r1_reg_value;
1596 RegisterValue r2_reg_value;
1597 RegisterValue r3_reg_value;
1598 if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
1599 reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
1600 reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&
1601 reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) {
1602 Status error;
1603 if (r0_reg_value.GetAsMemoryData(*r0_reg_info,
1604 heap_data_up->GetBytes() + 0,
1605 4, byte_order, error) &&
1606 r1_reg_value.GetAsMemoryData(*r1_reg_info,
1607 heap_data_up->GetBytes() + 4,
1608 4, byte_order, error) &&
1609 r2_reg_value.GetAsMemoryData(*r2_reg_info,
1610 heap_data_up->GetBytes() + 8,
1611 4, byte_order, error) &&
1612 r3_reg_value.GetAsMemoryData(*r3_reg_info,
1613 heap_data_up->GetBytes() + 12,
1614 4, byte_order, error)) {
1615 DataExtractor data(DataBufferSP(heap_data_up.release()),
1616 byte_order,
1617 process_sp->GetAddressByteSize());
1618
1619 return_valobj_sp = ValueObjectConstResult::Create(
1620 &thread, compiler_type, ConstString(""), data);
1621 return return_valobj_sp;
1622 }
1623 }
1624 }
1625 }
1626 }
1627 } else {
1628 return return_valobj_sp;
1629 }
1630 break;
1631 case 64: {
1632 const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1633 uint64_t raw_value;
1634 raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
1635 raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) &
1636 UINT32_MAX))
1637 << 32;
1638 if (is_signed)
1639 value.GetScalar() = (int64_t)raw_value;
1640 else
1641 value.GetScalar() = (uint64_t)raw_value;
1642 } break;
1643 case 32:
1644 if (is_signed)
1645 value.GetScalar() = (int32_t)(
1646 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1647 else
1648 value.GetScalar() = (uint32_t)(
1649 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1650 break;
1651 case 16:
1652 if (is_signed)
1653 value.GetScalar() = (int16_t)(
1654 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1655 else
1656 value.GetScalar() = (uint16_t)(
1657 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1658 break;
1659 case 8:
1660 if (is_signed)
1661 value.GetScalar() = (int8_t)(
1662 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1663 else
1664 value.GetScalar() = (uint8_t)(
1665 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1666 break;
1667 }
1668 } else if (compiler_type.IsPointerType()) {
1669 uint32_t ptr =
1670 thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
1671 UINT32_MAX;
1672 value.GetScalar() = ptr;
1673 } else {
1674 // not handled yet
1675 return return_valobj_sp;
1676 }
1677
1678 // If we get here, we have a valid Value, so make our ValueObject out of it:
1679
1680 return_valobj_sp = ValueObjectConstResult::Create(
1681 thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
1682 return return_valobj_sp;
1683 }
1684
1685 Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1686 lldb::ValueObjectSP &new_value_sp) {
1687 Status error;
1688 if (!new_value_sp) {
1689 error.SetErrorString("Empty value object for return value.");
1690 return error;
1691 }
1692
1693 CompilerType compiler_type = new_value_sp->GetCompilerType();
1694 if (!compiler_type) {
1695 error.SetErrorString("Null clang type for return value.");
1696 return error;
1697 }
1698
1699 Thread *thread = frame_sp->GetThread().get();
1700
1701 bool is_signed;
1702 uint32_t count;
1703 bool is_complex;
1704
1705 RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1706
1707 bool set_it_simple = false;
1708 if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
1709 compiler_type.IsPointerType()) {
1710 DataExtractor data;
1711 Status data_error;
1712 size_t num_bytes = new_value_sp->GetData(data, data_error);
1713 if (data_error.Fail()) {
1714 error.SetErrorStringWithFormat(
1715 "Couldn't convert return value to raw data: %s",
1716 data_error.AsCString());
1717 return error;
1718 }
1719 lldb::offset_t offset = 0;
1720 if (num_bytes <= 8) {
1721 const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1722 if (num_bytes <= 4) {
1723 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
1724
1725 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value))
1726 set_it_simple = true;
1727 } else {
1728 uint32_t raw_value = data.GetMaxU32(&offset, 4);
1729
1730 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) {
1731 const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1732 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
1733
1734 if (reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value))
1735 set_it_simple = true;
1736 }
1737 }
1738 } else if (num_bytes <= 16 && IsArmv7kProcess()) {
1739 // "A composite type not larger than 16 bytes is returned in r0-r3. The
1740 // format is as if the result had been stored in memory at a word-aligned
1741 // address and then loaded into r0-r3 with an ldm instruction"
1742
1743 const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1744 const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1745 const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
1746 const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
1747 lldb::offset_t offset = 0;
1748 uint32_t bytes_written = 4;
1749 uint32_t raw_value = data.GetMaxU64(&offset, 4);
1750 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value) &&
1751 bytes_written <= num_bytes) {
1752 bytes_written += 4;
1753 raw_value = data.GetMaxU64(&offset, 4);
1754 if (bytes_written <= num_bytes &&
1755 reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) {
1756 bytes_written += 4;
1757 raw_value = data.GetMaxU64(&offset, 4);
1758 if (bytes_written <= num_bytes &&
1759 reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) {
1760 bytes_written += 4;
1761 raw_value = data.GetMaxU64(&offset, 4);
1762 if (bytes_written <= num_bytes &&
1763 reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value)) {
1764 set_it_simple = true;
1765 }
1766 }
1767 }
1768 }
1769 } else {
1770 error.SetErrorString("We don't support returning longer than 64 bit "
1771 "integer values at present.");
1772 }
1773 } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
1774 if (is_complex)
1775 error.SetErrorString(
1776 "We don't support returning complex values at present");
1777 else
1778 error.SetErrorString(
1779 "We don't support returning float values at present");
1780 }
1781
1782 if (!set_it_simple)
1783 error.SetErrorString(
1784 "We only support setting simple integer return types at present.");
1785
1786 return error;
1787 }
1788
1789 bool ABIMacOSX_arm::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
1790 unwind_plan.Clear();
1791 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1792
1793 uint32_t lr_reg_num = dwarf_lr;
1794 uint32_t sp_reg_num = dwarf_sp;
1795 uint32_t pc_reg_num = dwarf_pc;
1796
1797 UnwindPlan::RowSP row(new UnwindPlan::Row);
1798
1799 // Our Call Frame Address is the stack pointer value
1800 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1801
1802 // The previous PC is in the LR
1803 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
1804 unwind_plan.AppendRow(row);
1805
1806 // All other registers are the same.
1807
1808 unwind_plan.SetSourceName("arm at-func-entry default");
1809 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1810
1811 return true;
1812 }
1813
1814 bool ABIMacOSX_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
1815 unwind_plan.Clear();
1816 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1817
1818 uint32_t fp_reg_num =
1819 dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11
1820 uint32_t pc_reg_num = dwarf_pc;
1821
1822 UnwindPlan::RowSP row(new UnwindPlan::Row);
1823 const int32_t ptr_size = 4;
1824
1825 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
1826 row->SetOffset(0);
1827 row->SetUnspecifiedRegistersAreUndefined(true);
1828
1829 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1830 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1831
1832 unwind_plan.AppendRow(row);
1833 unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
1834 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1835 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1836 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
1837
1838 return true;
1839 }
1840
1841 // cf. "ARMv6 Function Calling Conventions"
1842 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
1843 // and "ARMv7 Function Calling Conventions"
1844 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html
1845
1846 // ARMv7 on iOS general purpose reg rules:
1847 // r0-r3 not preserved (used for argument passing)
1848 // r4-r6 preserved
1849 // r7 preserved (frame pointer)
1850 // r8 preserved
1851 // r9 not preserved (usable as volatile scratch register with iOS 3.x and
1852 // later)
1853 // r10-r11 preserved
1854 // r12 not presrved
1855 // r13 preserved (stack pointer)
1856 // r14 not preserved (link register)
1857 // r15 preserved (pc)
1858 // cpsr not preserved (different rules for different bits)
1859
1860 // ARMv7 on iOS floating point rules:
1861 // d0-d7 not preserved (aka s0-s15, q0-q3)
1862 // d8-d15 preserved (aka s16-s31, q4-q7)
1863 // d16-d31 not preserved (aka q8-q15)
1864
1865 bool ABIMacOSX_arm::RegisterIsVolatile(const RegisterInfo *reg_info) {
1866 if (reg_info) {
1867 // Volatile registers are: r0, r1, r2, r3, r9, r12, r13 (aka sp)
1868 const char *name = reg_info->name;
1869 if (name[0] == 'r') {
1870 switch (name[1]) {
1871 case '0':
1872 return name[2] == '\0'; // r0
1873 case '1':
1874 switch (name[2]) {
1875 case '\0':
1876 return true; // r1
1877 case '2':
1878 case '3':
1879 return name[3] == '\0'; // r12, r13 (sp)
1880 default:
1881 break;
1882 }
1883 break;
1884
1885 case '2':
1886 return name[2] == '\0'; // r2
1887 case '3':
1888 return name[2] == '\0'; // r3
1889 case '9':
1890 return name[2] == '\0'; // r9 (apple-ios only...)
1891
1892 break;
1893 }
1894 } else if (name[0] == 'd') {
1895 switch (name[1]) {
1896 case '0':
1897 return name[2] == '\0'; // d0 is volatile
1898
1899 case '1':
1900 switch (name[2]) {
1901 case '\0':
1902 return true; // d1 is volatile
1903 case '6':
1904 case '7':
1905 case '8':
1906 case '9':
1907 return name[3] == '\0'; // d16 - d19 are volatile
1908 default:
1909 break;
1910 }
1911 break;
1912
1913 case '2':
1914 switch (name[2]) {
1915 case '\0':
1916 return true; // d2 is volatile
1917 case '0':
1918 case '1':
1919 case '2':
1920 case '3':
1921 case '4':
1922 case '5':
1923 case '6':
1924 case '7':
1925 case '8':
1926 case '9':
1927 return name[3] == '\0'; // d20 - d29 are volatile
1928 default:
1929 break;
1930 }
1931 break;
1932
1933 case '3':
1934 switch (name[2]) {
1935 case '\0':
1936 return true; // d3 is volatile
1937 case '0':
1938 case '1':
1939 return name[3] == '\0'; // d30 - d31 are volatile
1940 default:
1941 break;
1942 }
1943 break;
1944 case '4':
1945 case '5':
1946 case '6':
1947 case '7':
1948 return name[2] == '\0'; // d4 - d7 are volatile
1949
1950 default:
1951 break;
1952 }
1953 } else if (name[0] == 's') {
1954 switch (name[1]) {
1955 case '0':
1956 return name[2] == '\0'; // s0 is volatile
1957
1958 case '1':
1959 switch (name[2]) {
1960 case '\0':
1961 return true; // s1 is volatile
1962 case '0':
1963 case '1':
1964 case '2':
1965 case '3':
1966 case '4':
1967 case '5':
1968 return name[3] == '\0'; // s10 - s15 are volatile
1969 default:
1970 break;
1971 }
1972 break;
1973
1974 case '2':
1975 case '3':
1976 case '4':
1977 case '5':
1978 case '6':
1979 case '7':
1980 case '8':
1981 case '9':
1982 return name[2] == '\0'; // s2 - s9 are volatile
1983
1984 default:
1985 break;
1986 }
1987 } else if (name[0] == 'q') {
1988 switch (name[1]) {
1989 case '1':
1990 switch (name[2]) {
1991 case '\0':
1992 return true; // q1 is volatile
1993 case '0':
1994 case '1':
1995 case '2':
1996 case '3':
1997 case '4':
1998 case '5':
1999 return true; // q10-q15 are volatile
2000 default:
2001 break;
2002 };
2003 break;
2004 case '0':
2005 case '2':
2006 case '3':
2007 return name[2] == '\0'; // q0-q3 are volatile
2008 case '8':
2009 case '9':
2010 return name[2] == '\0'; // q8-q9 are volatile
2011 default:
2012 break;
2013 }
2014 } else if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')
2015 return true;
2016 }
2017 return false;
2018 }
2019
2020 void ABIMacOSX_arm::Initialize() {
2021 PluginManager::RegisterPlugin(GetPluginNameStatic(),
2022 "Mac OS X ABI for arm targets", CreateInstance);
2023 }
2024
2025 void ABIMacOSX_arm::Terminate() {
2026 PluginManager::UnregisterPlugin(CreateInstance);
2027 }
LLVM monorepo