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 <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/RegisterValue.h"
27 #include "lldb/Utility/Scalar.h"
28 #include "lldb/Utility/Status.h"
29
30 #include "Plugins/Process/Utility/ARMDefines.h"
31 #include "Utility/ARM_DWARF_Registers.h"
32 #include "Utility/ARM_ehframe_Registers.h"
33
34 using namespace lldb;
35 using namespace lldb_private;
36
37 static const RegisterInfo g_register_infos[] = {
38 // NAME ALT SZ OFF ENCODING FORMAT EH_FRAME
39 // DWARF GENERIC PROCESS PLUGIN
40 // LLDB NATIVE
41 // ========== ======= == === ============= ============
42 // ======================= =================== ===========================
43 // ======================= ======================
44 {"r0",
45 "arg1",
46 4,
47 0,
48 eEncodingUint,
49 eFormatHex,
50 {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
51 LLDB_INVALID_REGNUM},
52 nullptr,
53 nullptr,
54 nullptr,
55 0},
56 {"r1",
57 "arg2",
58 4,
59 0,
60 eEncodingUint,
61 eFormatHex,
62 {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
63 LLDB_INVALID_REGNUM},
64 nullptr,
65 nullptr,
66 nullptr,
67 0},
68 {"r2",
69 "arg3",
70 4,
71 0,
72 eEncodingUint,
73 eFormatHex,
74 {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
75 LLDB_INVALID_REGNUM},
76 nullptr,
77 nullptr,
78 nullptr,
79 0},
80 {"r3",
81 "arg4",
82 4,
83 0,
84 eEncodingUint,
85 eFormatHex,
86 {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
87 LLDB_INVALID_REGNUM},
88 nullptr,
89 nullptr,
90 nullptr,
91 0},
92 {"r4",
93 nullptr,
94 4,
95 0,
96 eEncodingUint,
97 eFormatHex,
98 {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
99 LLDB_INVALID_REGNUM},
100 nullptr,
101 nullptr,
102 nullptr,
103 0},
104 {"r5",
105 nullptr,
106 4,
107 0,
108 eEncodingUint,
109 eFormatHex,
110 {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
111 LLDB_INVALID_REGNUM},
112 nullptr,
113 nullptr,
114 nullptr,
115 0},
116 {"r6",
117 nullptr,
118 4,
119 0,
120 eEncodingUint,
121 eFormatHex,
122 {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
123 LLDB_INVALID_REGNUM},
124 nullptr,
125 nullptr,
126 nullptr,
127 0},
128 {"r7",
129 nullptr,
130 4,
131 0,
132 eEncodingUint,
133 eFormatHex,
134 {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
135 LLDB_INVALID_REGNUM},
136 nullptr,
137 nullptr,
138 nullptr,
139 0},
140 {"r8",
141 nullptr,
142 4,
143 0,
144 eEncodingUint,
145 eFormatHex,
146 {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
147 LLDB_INVALID_REGNUM},
148 nullptr,
149 nullptr,
150 nullptr,
151 0},
152 {"r9",
153 nullptr,
154 4,
155 0,
156 eEncodingUint,
157 eFormatHex,
158 {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
159 LLDB_INVALID_REGNUM},
160 nullptr,
161 nullptr,
162 nullptr,
163 0},
164 {"r10",
165 nullptr,
166 4,
167 0,
168 eEncodingUint,
169 eFormatHex,
170 {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
171 LLDB_INVALID_REGNUM},
172 nullptr,
173 nullptr,
174 nullptr,
175 0},
176 {"r11",
177 nullptr,
178 4,
179 0,
180 eEncodingUint,
181 eFormatHex,
182 {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
183 LLDB_INVALID_REGNUM},
184 nullptr,
185 nullptr,
186 nullptr,
187 0},
188 {"r12",
189 nullptr,
190 4,
191 0,
192 eEncodingUint,
193 eFormatHex,
194 {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
195 LLDB_INVALID_REGNUM},
196 nullptr,
197 nullptr,
198 nullptr,
199 0},
200 {"sp",
201 "r13",
202 4,
203 0,
204 eEncodingUint,
205 eFormatHex,
206 {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
207 LLDB_INVALID_REGNUM},
208 nullptr,
209 nullptr,
210 nullptr,
211 0},
212 {"lr",
213 "r14",
214 4,
215 0,
216 eEncodingUint,
217 eFormatHex,
218 {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
219 LLDB_INVALID_REGNUM},
220 nullptr,
221 nullptr,
222 nullptr,
223 0},
224 {"pc",
225 "r15",
226 4,
227 0,
228 eEncodingUint,
229 eFormatHex,
230 {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
231 LLDB_INVALID_REGNUM},
232 nullptr,
233 nullptr,
234 nullptr,
235 0},
236 {"cpsr",
237 "psr",
238 4,
239 0,
240 eEncodingUint,
241 eFormatHex,
242 {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
243 LLDB_INVALID_REGNUM},
244 nullptr,
245 nullptr,
246 nullptr,
247 0},
248 {"s0",
249 nullptr,
250 4,
251 0,
252 eEncodingIEEE754,
253 eFormatFloat,
254 {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
255 LLDB_INVALID_REGNUM},
256 nullptr,
257 nullptr,
258 nullptr,
259 0},
260 {"s1",
261 nullptr,
262 4,
263 0,
264 eEncodingIEEE754,
265 eFormatFloat,
266 {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
267 LLDB_INVALID_REGNUM},
268 nullptr,
269 nullptr,
270 nullptr,
271 0},
272 {"s2",
273 nullptr,
274 4,
275 0,
276 eEncodingIEEE754,
277 eFormatFloat,
278 {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
279 LLDB_INVALID_REGNUM},
280 nullptr,
281 nullptr,
282 nullptr,
283 0},
284 {"s3",
285 nullptr,
286 4,
287 0,
288 eEncodingIEEE754,
289 eFormatFloat,
290 {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
291 LLDB_INVALID_REGNUM},
292 nullptr,
293 nullptr,
294 nullptr,
295 0},
296 {"s4",
297 nullptr,
298 4,
299 0,
300 eEncodingIEEE754,
301 eFormatFloat,
302 {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
303 LLDB_INVALID_REGNUM},
304 nullptr,
305 nullptr,
306 nullptr,
307 0},
308 {"s5",
309 nullptr,
310 4,
311 0,
312 eEncodingIEEE754,
313 eFormatFloat,
314 {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
315 LLDB_INVALID_REGNUM},
316 nullptr,
317 nullptr,
318 nullptr,
319 0},
320 {"s6",
321 nullptr,
322 4,
323 0,
324 eEncodingIEEE754,
325 eFormatFloat,
326 {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
327 LLDB_INVALID_REGNUM},
328 nullptr,
329 nullptr,
330 nullptr,
331 0},
332 {"s7",
333 nullptr,
334 4,
335 0,
336 eEncodingIEEE754,
337 eFormatFloat,
338 {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
339 LLDB_INVALID_REGNUM},
340 nullptr,
341 nullptr,
342 nullptr,
343 0},
344 {"s8",
345 nullptr,
346 4,
347 0,
348 eEncodingIEEE754,
349 eFormatFloat,
350 {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
351 LLDB_INVALID_REGNUM},
352 nullptr,
353 nullptr,
354 nullptr,
355 0},
356 {"s9",
357 nullptr,
358 4,
359 0,
360 eEncodingIEEE754,
361 eFormatFloat,
362 {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
363 LLDB_INVALID_REGNUM},
364 nullptr,
365 nullptr,
366 nullptr,
367 0},
368 {"s10",
369 nullptr,
370 4,
371 0,
372 eEncodingIEEE754,
373 eFormatFloat,
374 {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
375 LLDB_INVALID_REGNUM},
376 nullptr,
377 nullptr,
378 nullptr,
379 0},
380 {"s11",
381 nullptr,
382 4,
383 0,
384 eEncodingIEEE754,
385 eFormatFloat,
386 {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
387 LLDB_INVALID_REGNUM},
388 nullptr,
389 nullptr,
390 nullptr,
391 0},
392 {"s12",
393 nullptr,
394 4,
395 0,
396 eEncodingIEEE754,
397 eFormatFloat,
398 {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
399 LLDB_INVALID_REGNUM},
400 nullptr,
401 nullptr,
402 nullptr,
403 0},
404 {"s13",
405 nullptr,
406 4,
407 0,
408 eEncodingIEEE754,
409 eFormatFloat,
410 {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
411 LLDB_INVALID_REGNUM},
412 nullptr,
413 nullptr,
414 nullptr,
415 0},
416 {"s14",
417 nullptr,
418 4,
419 0,
420 eEncodingIEEE754,
421 eFormatFloat,
422 {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
423 LLDB_INVALID_REGNUM},
424 nullptr,
425 nullptr,
426 nullptr,
427 0},
428 {"s15",
429 nullptr,
430 4,
431 0,
432 eEncodingIEEE754,
433 eFormatFloat,
434 {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
435 LLDB_INVALID_REGNUM},
436 nullptr,
437 nullptr,
438 nullptr,
439 0},
440 {"s16",
441 nullptr,
442 4,
443 0,
444 eEncodingIEEE754,
445 eFormatFloat,
446 {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
447 LLDB_INVALID_REGNUM},
448 nullptr,
449 nullptr,
450 nullptr,
451 0},
452 {"s17",
453 nullptr,
454 4,
455 0,
456 eEncodingIEEE754,
457 eFormatFloat,
458 {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
459 LLDB_INVALID_REGNUM},
460 nullptr,
461 nullptr,
462 nullptr,
463 0},
464 {"s18",
465 nullptr,
466 4,
467 0,
468 eEncodingIEEE754,
469 eFormatFloat,
470 {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
471 LLDB_INVALID_REGNUM},
472 nullptr,
473 nullptr,
474 nullptr,
475 0},
476 {"s19",
477 nullptr,
478 4,
479 0,
480 eEncodingIEEE754,
481 eFormatFloat,
482 {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
483 LLDB_INVALID_REGNUM},
484 nullptr,
485 nullptr,
486 nullptr,
487 0},
488 {"s20",
489 nullptr,
490 4,
491 0,
492 eEncodingIEEE754,
493 eFormatFloat,
494 {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
495 LLDB_INVALID_REGNUM},
496 nullptr,
497 nullptr,
498 nullptr,
499 0},
500 {"s21",
501 nullptr,
502 4,
503 0,
504 eEncodingIEEE754,
505 eFormatFloat,
506 {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
507 LLDB_INVALID_REGNUM},
508 nullptr,
509 nullptr,
510 nullptr,
511 0},
512 {"s22",
513 nullptr,
514 4,
515 0,
516 eEncodingIEEE754,
517 eFormatFloat,
518 {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
519 LLDB_INVALID_REGNUM},
520 nullptr,
521 nullptr,
522 nullptr,
523 0},
524 {"s23",
525 nullptr,
526 4,
527 0,
528 eEncodingIEEE754,
529 eFormatFloat,
530 {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
531 LLDB_INVALID_REGNUM},
532 nullptr,
533 nullptr,
534 nullptr,
535 0},
536 {"s24",
537 nullptr,
538 4,
539 0,
540 eEncodingIEEE754,
541 eFormatFloat,
542 {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
543 LLDB_INVALID_REGNUM},
544 nullptr,
545 nullptr,
546 nullptr,
547 0},
548 {"s25",
549 nullptr,
550 4,
551 0,
552 eEncodingIEEE754,
553 eFormatFloat,
554 {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
555 LLDB_INVALID_REGNUM},
556 nullptr,
557 nullptr,
558 nullptr,
559 0},
560 {"s26",
561 nullptr,
562 4,
563 0,
564 eEncodingIEEE754,
565 eFormatFloat,
566 {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
567 LLDB_INVALID_REGNUM},
568 nullptr,
569 nullptr,
570 nullptr,
571 0},
572 {"s27",
573 nullptr,
574 4,
575 0,
576 eEncodingIEEE754,
577 eFormatFloat,
578 {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
579 LLDB_INVALID_REGNUM},
580 nullptr,
581 nullptr,
582 nullptr,
583 0},
584 {"s28",
585 nullptr,
586 4,
587 0,
588 eEncodingIEEE754,
589 eFormatFloat,
590 {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
591 LLDB_INVALID_REGNUM},
592 nullptr,
593 nullptr,
594 nullptr,
595 0},
596 {"s29",
597 nullptr,
598 4,
599 0,
600 eEncodingIEEE754,
601 eFormatFloat,
602 {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
603 LLDB_INVALID_REGNUM},
604 nullptr,
605 nullptr,
606 nullptr,
607 0},
608 {"s30",
609 nullptr,
610 4,
611 0,
612 eEncodingIEEE754,
613 eFormatFloat,
614 {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
615 LLDB_INVALID_REGNUM},
616 nullptr,
617 nullptr,
618 nullptr,
619 0},
620 {"s31",
621 nullptr,
622 4,
623 0,
624 eEncodingIEEE754,
625 eFormatFloat,
626 {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
627 LLDB_INVALID_REGNUM},
628 nullptr,
629 nullptr,
630 nullptr,
631 0},
632 {"fpscr",
633 nullptr,
634 4,
635 0,
636 eEncodingUint,
637 eFormatHex,
638 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
639 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
640 nullptr,
641 nullptr,
642 nullptr,
643 0},
644 {"d0",
645 nullptr,
646 8,
647 0,
648 eEncodingIEEE754,
649 eFormatFloat,
650 {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
651 LLDB_INVALID_REGNUM},
652 nullptr,
653 nullptr,
654 nullptr,
655 0},
656 {"d1",
657 nullptr,
658 8,
659 0,
660 eEncodingIEEE754,
661 eFormatFloat,
662 {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
663 LLDB_INVALID_REGNUM},
664 nullptr,
665 nullptr,
666 nullptr,
667 0},
668 {"d2",
669 nullptr,
670 8,
671 0,
672 eEncodingIEEE754,
673 eFormatFloat,
674 {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
675 LLDB_INVALID_REGNUM},
676 nullptr,
677 nullptr,
678 nullptr,
679 0},
680 {"d3",
681 nullptr,
682 8,
683 0,
684 eEncodingIEEE754,
685 eFormatFloat,
686 {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
687 LLDB_INVALID_REGNUM},
688 nullptr,
689 nullptr,
690 nullptr,
691 0},
692 {"d4",
693 nullptr,
694 8,
695 0,
696 eEncodingIEEE754,
697 eFormatFloat,
698 {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
699 LLDB_INVALID_REGNUM},
700 nullptr,
701 nullptr,
702 nullptr,
703 0},
704 {"d5",
705 nullptr,
706 8,
707 0,
708 eEncodingIEEE754,
709 eFormatFloat,
710 {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
711 LLDB_INVALID_REGNUM},
712 nullptr,
713 nullptr,
714 nullptr,
715 0},
716 {"d6",
717 nullptr,
718 8,
719 0,
720 eEncodingIEEE754,
721 eFormatFloat,
722 {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
723 LLDB_INVALID_REGNUM},
724 nullptr,
725 nullptr,
726 nullptr,
727 0},
728 {"d7",
729 nullptr,
730 8,
731 0,
732 eEncodingIEEE754,
733 eFormatFloat,
734 {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
735 LLDB_INVALID_REGNUM},
736 nullptr,
737 nullptr,
738 nullptr,
739 0},
740 {"d8",
741 nullptr,
742 8,
743 0,
744 eEncodingIEEE754,
745 eFormatFloat,
746 {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
747 LLDB_INVALID_REGNUM},
748 nullptr,
749 nullptr,
750 nullptr,
751 0},
752 {"d9",
753 nullptr,
754 8,
755 0,
756 eEncodingIEEE754,
757 eFormatFloat,
758 {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
759 LLDB_INVALID_REGNUM},
760 nullptr,
761 nullptr,
762 nullptr,
763 0},
764 {"d10",
765 nullptr,
766 8,
767 0,
768 eEncodingIEEE754,
769 eFormatFloat,
770 {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
771 LLDB_INVALID_REGNUM},
772 nullptr,
773 nullptr,
774 nullptr,
775 0},
776 {"d11",
777 nullptr,
778 8,
779 0,
780 eEncodingIEEE754,
781 eFormatFloat,
782 {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
783 LLDB_INVALID_REGNUM},
784 nullptr,
785 nullptr,
786 nullptr,
787 0},
788 {"d12",
789 nullptr,
790 8,
791 0,
792 eEncodingIEEE754,
793 eFormatFloat,
794 {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
795 LLDB_INVALID_REGNUM},
796 nullptr,
797 nullptr,
798 nullptr,
799 0},
800 {"d13",
801 nullptr,
802 8,
803 0,
804 eEncodingIEEE754,
805 eFormatFloat,
806 {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
807 LLDB_INVALID_REGNUM},
808 nullptr,
809 nullptr,
810 nullptr,
811 0},
812 {"d14",
813 nullptr,
814 8,
815 0,
816 eEncodingIEEE754,
817 eFormatFloat,
818 {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
819 LLDB_INVALID_REGNUM},
820 nullptr,
821 nullptr,
822 nullptr,
823 0},
824 {"d15",
825 nullptr,
826 8,
827 0,
828 eEncodingIEEE754,
829 eFormatFloat,
830 {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
831 LLDB_INVALID_REGNUM},
832 nullptr,
833 nullptr,
834 nullptr,
835 0},
836 {"d16",
837 nullptr,
838 8,
839 0,
840 eEncodingIEEE754,
841 eFormatFloat,
842 {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
843 LLDB_INVALID_REGNUM},
844 nullptr,
845 nullptr,
846 nullptr,
847 0},
848 {"d17",
849 nullptr,
850 8,
851 0,
852 eEncodingIEEE754,
853 eFormatFloat,
854 {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
855 LLDB_INVALID_REGNUM},
856 nullptr,
857 nullptr,
858 nullptr,
859 0},
860 {"d18",
861 nullptr,
862 8,
863 0,
864 eEncodingIEEE754,
865 eFormatFloat,
866 {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
867 LLDB_INVALID_REGNUM},
868 nullptr,
869 nullptr,
870 nullptr,
871 0},
872 {"d19",
873 nullptr,
874 8,
875 0,
876 eEncodingIEEE754,
877 eFormatFloat,
878 {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
879 LLDB_INVALID_REGNUM},
880 nullptr,
881 nullptr,
882 nullptr,
883 0},
884 {"d20",
885 nullptr,
886 8,
887 0,
888 eEncodingIEEE754,
889 eFormatFloat,
890 {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
891 LLDB_INVALID_REGNUM},
892 nullptr,
893 nullptr,
894 nullptr,
895 0},
896 {"d21",
897 nullptr,
898 8,
899 0,
900 eEncodingIEEE754,
901 eFormatFloat,
902 {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
903 LLDB_INVALID_REGNUM},
904 nullptr,
905 nullptr,
906 nullptr,
907 0},
908 {"d22",
909 nullptr,
910 8,
911 0,
912 eEncodingIEEE754,
913 eFormatFloat,
914 {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
915 LLDB_INVALID_REGNUM},
916 nullptr,
917 nullptr,
918 nullptr,
919 0},
920 {"d23",
921 nullptr,
922 8,
923 0,
924 eEncodingIEEE754,
925 eFormatFloat,
926 {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
927 LLDB_INVALID_REGNUM},
928 nullptr,
929 nullptr,
930 nullptr,
931 0},
932 {"d24",
933 nullptr,
934 8,
935 0,
936 eEncodingIEEE754,
937 eFormatFloat,
938 {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
939 LLDB_INVALID_REGNUM},
940 nullptr,
941 nullptr,
942 nullptr,
943 0},
944 {"d25",
945 nullptr,
946 8,
947 0,
948 eEncodingIEEE754,
949 eFormatFloat,
950 {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
951 LLDB_INVALID_REGNUM},
952 nullptr,
953 nullptr,
954 nullptr,
955 0},
956 {"d26",
957 nullptr,
958 8,
959 0,
960 eEncodingIEEE754,
961 eFormatFloat,
962 {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
963 LLDB_INVALID_REGNUM},
964 nullptr,
965 nullptr,
966 nullptr,
967 0},
968 {"d27",
969 nullptr,
970 8,
971 0,
972 eEncodingIEEE754,
973 eFormatFloat,
974 {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
975 LLDB_INVALID_REGNUM},
976 nullptr,
977 nullptr,
978 nullptr,
979 0},
980 {"d28",
981 nullptr,
982 8,
983 0,
984 eEncodingIEEE754,
985 eFormatFloat,
986 {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
987 LLDB_INVALID_REGNUM},
988 nullptr,
989 nullptr,
990 nullptr,
991 0},
992 {"d29",
993 nullptr,
994 8,
995 0,
996 eEncodingIEEE754,
997 eFormatFloat,
998 {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
999 LLDB_INVALID_REGNUM},
1000 nullptr,
1001 nullptr,
1002 nullptr,
1003 0},
1004 {"d30",
1005 nullptr,
1006 8,
1007 0,
1008 eEncodingIEEE754,
1009 eFormatFloat,
1010 {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1011 LLDB_INVALID_REGNUM},
1012 nullptr,
1013 nullptr,
1014 nullptr,
1015 0},
1016 {"d31",
1017 nullptr,
1018 8,
1019 0,
1020 eEncodingIEEE754,
1021 eFormatFloat,
1022 {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1023 LLDB_INVALID_REGNUM},
1024 nullptr,
1025 nullptr,
1026 nullptr,
1027 0},
1028 {"r8_usr",
1029 nullptr,
1030 4,
1031 0,
1032 eEncodingUint,
1033 eFormatHex,
1034 {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
1035 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1036 nullptr,
1037 nullptr,
1038 nullptr,
1039 0},
1040 {"r9_usr",
1041 nullptr,
1042 4,
1043 0,
1044 eEncodingUint,
1045 eFormatHex,
1046 {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
1047 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1048 nullptr,
1049 nullptr,
1050 nullptr,
1051 0},
1052 {"r10_usr",
1053 nullptr,
1054 4,
1055 0,
1056 eEncodingUint,
1057 eFormatHex,
1058 {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
1059 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1060 nullptr,
1061 nullptr,
1062 nullptr,
1063 0},
1064 {"r11_usr",
1065 nullptr,
1066 4,
1067 0,
1068 eEncodingUint,
1069 eFormatHex,
1070 {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
1071 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1072 nullptr,
1073 nullptr,
1074 nullptr,
1075 0},
1076 {"r12_usr",
1077 nullptr,
1078 4,
1079 0,
1080 eEncodingUint,
1081 eFormatHex,
1082 {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
1083 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1084 nullptr,
1085 nullptr,
1086 nullptr,
1087 0},
1088 {"r13_usr",
1089 "sp_usr",
1090 4,
1091 0,
1092 eEncodingUint,
1093 eFormatHex,
1094 {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
1095 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1096 nullptr,
1097 nullptr,
1098 nullptr,
1099 0},
1100 {"r14_usr",
1101 "lr_usr",
1102 4,
1103 0,
1104 eEncodingUint,
1105 eFormatHex,
1106 {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
1107 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1108 nullptr,
1109 nullptr,
1110 nullptr,
1111 0},
1112 {"r8_fiq",
1113 nullptr,
1114 4,
1115 0,
1116 eEncodingUint,
1117 eFormatHex,
1118 {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
1119 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1120 nullptr,
1121 nullptr,
1122 nullptr,
1123 0},
1124 {"r9_fiq",
1125 nullptr,
1126 4,
1127 0,
1128 eEncodingUint,
1129 eFormatHex,
1130 {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
1131 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1132 nullptr,
1133 nullptr,
1134 nullptr,
1135 0},
1136 {"r10_fiq",
1137 nullptr,
1138 4,
1139 0,
1140 eEncodingUint,
1141 eFormatHex,
1142 {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
1143 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1144 nullptr,
1145 nullptr,
1146 nullptr,
1147 0},
1148 {"r11_fiq",
1149 nullptr,
1150 4,
1151 0,
1152 eEncodingUint,
1153 eFormatHex,
1154 {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
1155 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1156 nullptr,
1157 nullptr,
1158 nullptr,
1159 0},
1160 {"r12_fiq",
1161 nullptr,
1162 4,
1163 0,
1164 eEncodingUint,
1165 eFormatHex,
1166 {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
1167 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1168 nullptr,
1169 nullptr,
1170 nullptr,
1171 0},
1172 {"r13_fiq",
1173 "sp_fiq",
1174 4,
1175 0,
1176 eEncodingUint,
1177 eFormatHex,
1178 {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
1179 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1180 nullptr,
1181 nullptr,
1182 nullptr,
1183 0},
1184 {"r14_fiq",
1185 "lr_fiq",
1186 4,
1187 0,
1188 eEncodingUint,
1189 eFormatHex,
1190 {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
1191 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1192 nullptr,
1193 nullptr,
1194 nullptr,
1195 0},
1196 {"r13_irq",
1197 "sp_irq",
1198 4,
1199 0,
1200 eEncodingUint,
1201 eFormatHex,
1202 {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
1203 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1204 nullptr,
1205 nullptr,
1206 nullptr,
1207 0},
1208 {"r14_irq",
1209 "lr_irq",
1210 4,
1211 0,
1212 eEncodingUint,
1213 eFormatHex,
1214 {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
1215 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1216 nullptr,
1217 nullptr,
1218 nullptr,
1219 0},
1220 {"r13_abt",
1221 "sp_abt",
1222 4,
1223 0,
1224 eEncodingUint,
1225 eFormatHex,
1226 {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
1227 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1228 nullptr,
1229 nullptr,
1230 nullptr,
1231 0},
1232 {"r14_abt",
1233 "lr_abt",
1234 4,
1235 0,
1236 eEncodingUint,
1237 eFormatHex,
1238 {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
1239 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1240 nullptr,
1241 nullptr,
1242 nullptr,
1243 0},
1244 {"r13_und",
1245 "sp_und",
1246 4,
1247 0,
1248 eEncodingUint,
1249 eFormatHex,
1250 {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
1251 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1252 nullptr,
1253 nullptr,
1254 nullptr,
1255 0},
1256 {"r14_und",
1257 "lr_und",
1258 4,
1259 0,
1260 eEncodingUint,
1261 eFormatHex,
1262 {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
1263 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1264 nullptr,
1265 nullptr,
1266 nullptr,
1267 0},
1268 {"r13_svc",
1269 "sp_svc",
1270 4,
1271 0,
1272 eEncodingUint,
1273 eFormatHex,
1274 {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
1275 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1276 nullptr,
1277 nullptr,
1278 nullptr,
1279 0},
1280 {"r14_svc",
1281 "lr_svc",
1282 4,
1283 0,
1284 eEncodingUint,
1285 eFormatHex,
1286 {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
1287 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1288 nullptr,
1289 nullptr,
1290 nullptr,
1291 0}};
1292
1293 static const uint32_t k_num_register_infos =
1294 llvm::array_lengthof(g_register_infos);
1295
1296 const lldb_private::RegisterInfo *
GetRegisterInfoArray(uint32_t & count)1297 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
1298 count = k_num_register_infos;
1299 return g_register_infos;
1300 }
1301
GetRedZoneSize() const1302 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1303
1304 // Static Functions
1305
1306 ABISP
CreateInstance(ProcessSP process_sp,const ArchSpec & arch)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
PrepareTrivialCall(Thread & thread,addr_t sp,addr_t function_addr,addr_t return_addr,llvm::ArrayRef<addr_t> args) const1322 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 < llvm::array_lengthof(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
GetArgumentValues(Thread & thread,ValueList & values) const1428 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 llvm::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
IsArmv7kProcess() const1528 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
GetReturnValueObjectImpl(Thread & thread,lldb_private::CompilerType & compiler_type) const1541 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 llvm::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 llvm::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
SetReturnValueObject(lldb::StackFrameSP & frame_sp,lldb::ValueObjectSP & new_value_sp)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
CreateFunctionEntryUnwindPlan(UnwindPlan & unwind_plan)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
CreateDefaultUnwindPlan(UnwindPlan & unwind_plan)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
RegisterIsVolatile(const RegisterInfo * reg_info)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
Initialize()2020 void ABIMacOSX_arm::Initialize() {
2021 PluginManager::RegisterPlugin(GetPluginNameStatic(),
2022 "Mac OS X ABI for arm targets", CreateInstance);
2023 }
2024
Terminate()2025 void ABIMacOSX_arm::Terminate() {
2026 PluginManager::UnregisterPlugin(CreateInstance);
2027 }
2028
GetPluginNameStatic()2029 lldb_private::ConstString ABIMacOSX_arm::GetPluginNameStatic() {
2030 static ConstString g_name("macosx-arm");
2031 return g_name;
2032 }
2033
2034 // PluginInterface protocol
2035
GetPluginName()2036 lldb_private::ConstString ABIMacOSX_arm::GetPluginName() {
2037 return GetPluginNameStatic();
2038 }
2039
GetPluginVersion()2040 uint32_t ABIMacOSX_arm::GetPluginVersion() { return 1; }
2041