1 //===-- ABIMacOSX_arm.cpp ---------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "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 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 static bool g_register_info_names_constified = false;
1296
1297 const lldb_private::RegisterInfo *
GetRegisterInfoArray(uint32_t & count)1298 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
1299 // Make the C-string names and alt_names for the register infos into const
1300 // C-string values by having the ConstString unique the names in the global
1301 // constant C-string pool.
1302 if (!g_register_info_names_constified) {
1303 g_register_info_names_constified = true;
1304 for (uint32_t i = 0; i < k_num_register_infos; ++i) {
1305 if (g_register_infos[i].name)
1306 g_register_infos[i].name =
1307 ConstString(g_register_infos[i].name).GetCString();
1308 if (g_register_infos[i].alt_name)
1309 g_register_infos[i].alt_name =
1310 ConstString(g_register_infos[i].alt_name).GetCString();
1311 }
1312 }
1313 count = k_num_register_infos;
1314 return g_register_infos;
1315 }
1316
GetRedZoneSize() const1317 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1318
1319 // Static Functions
1320
1321 ABISP
CreateInstance(ProcessSP process_sp,const ArchSpec & arch)1322 ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1323 const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1324 const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1325
1326 if (vendor_type == llvm::Triple::Apple) {
1327 if ((arch_type == llvm::Triple::arm) ||
1328 (arch_type == llvm::Triple::thumb)) {
1329 return ABISP(
1330 new ABIMacOSX_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
1331 }
1332 }
1333
1334 return ABISP();
1335 }
1336
PrepareTrivialCall(Thread & thread,addr_t sp,addr_t function_addr,addr_t return_addr,llvm::ArrayRef<addr_t> args) const1337 bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
1338 addr_t function_addr, addr_t return_addr,
1339 llvm::ArrayRef<addr_t> args) const {
1340 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1341 if (!reg_ctx)
1342 return false;
1343
1344 const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1345 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1346 const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1347 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
1348 const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1349 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
1350
1351 RegisterValue reg_value;
1352
1353 const char *reg_names[] = {"r0", "r1", "r2", "r3"};
1354
1355 llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
1356
1357 for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
1358 if (ai == ae)
1359 break;
1360
1361 reg_value.SetUInt32(*ai);
1362 if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
1363 reg_value))
1364 return false;
1365
1366 ++ai;
1367 }
1368
1369 if (ai != ae) {
1370 // Spill onto the stack
1371 size_t num_stack_regs = ae - ai;
1372
1373 sp -= (num_stack_regs * 4);
1374 // Keep the stack 16 byte aligned
1375 sp &= ~(16ull - 1ull);
1376
1377 // just using arg1 to get the right size
1378 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1379 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
1380
1381 addr_t arg_pos = sp;
1382
1383 for (; ai != ae; ++ai) {
1384 reg_value.SetUInt32(*ai);
1385 if (reg_ctx
1386 ->WriteRegisterValueToMemory(reg_info, arg_pos,
1387 reg_info->byte_size, reg_value)
1388 .Fail())
1389 return false;
1390 arg_pos += reg_info->byte_size;
1391 }
1392 }
1393
1394 TargetSP target_sp(thread.CalculateTarget());
1395 Address so_addr;
1396
1397 // Figure out if our return address is ARM or Thumb by using the
1398 // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
1399 // thumb-ness and set the correct address bits for us.
1400 so_addr.SetLoadAddress(return_addr, target_sp.get());
1401 return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1402
1403 // Set "lr" to the return address
1404 if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
1405 return false;
1406
1407 // If bit zero or 1 is set, this must be a thumb function, no need to figure
1408 // this out from the symbols.
1409 so_addr.SetLoadAddress(function_addr, target_sp.get());
1410 function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1411
1412 const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr");
1413 const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0);
1414
1415 // Make a new CPSR and mask out any Thumb IT (if/then) bits
1416 uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK;
1417 // If bit zero or 1 is set, this must be thumb...
1418 if (function_addr & 1ull)
1419 new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR
1420 else
1421 new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR
1422
1423 if (new_cpsr != curr_cpsr) {
1424 if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr))
1425 return false;
1426 }
1427
1428 function_addr &=
1429 ~1ull; // clear bit zero since the CPSR will take care of the mode for us
1430
1431 // Update the sp - stack pointer - to be aligned to 16-bytes
1432 sp &= ~(0xfull);
1433 if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
1434 return false;
1435
1436 // Set "pc" to the address requested
1437 if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr))
1438 return false;
1439
1440 return true;
1441 }
1442
GetArgumentValues(Thread & thread,ValueList & values) const1443 bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
1444 uint32_t num_values = values.GetSize();
1445
1446 ExecutionContext exe_ctx(thread.shared_from_this());
1447 // For now, assume that the types in the AST values come from the Target's
1448 // scratch AST.
1449
1450 // Extract the register context so we can read arguments from registers
1451
1452 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1453
1454 if (!reg_ctx)
1455 return false;
1456
1457 addr_t sp = 0;
1458
1459 for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1460 // We currently only support extracting values with Clang QualTypes. Do we
1461 // care about others?
1462 Value *value = values.GetValueAtIndex(value_idx);
1463
1464 if (!value)
1465 return false;
1466
1467 CompilerType compiler_type = value->GetCompilerType();
1468 if (compiler_type) {
1469 bool is_signed = false;
1470 size_t bit_width = 0;
1471 llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
1472 if (!bit_size)
1473 return false;
1474 if (compiler_type.IsIntegerOrEnumerationType(is_signed))
1475 bit_width = *bit_size;
1476 else if (compiler_type.IsPointerOrReferenceType())
1477 bit_width = *bit_size;
1478 else
1479 // We only handle integer, pointer and reference types currently...
1480 return false;
1481
1482 if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1483 if (value_idx < 4) {
1484 // Arguments 1-4 are in r0-r3...
1485 const RegisterInfo *arg_reg_info = nullptr;
1486 // Search by generic ID first, then fall back to by name
1487 uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1488 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1489 if (arg_reg_num != LLDB_INVALID_REGNUM) {
1490 arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1491 } else {
1492 switch (value_idx) {
1493 case 0:
1494 arg_reg_info = reg_ctx->GetRegisterInfoByName("r0");
1495 break;
1496 case 1:
1497 arg_reg_info = reg_ctx->GetRegisterInfoByName("r1");
1498 break;
1499 case 2:
1500 arg_reg_info = reg_ctx->GetRegisterInfoByName("r2");
1501 break;
1502 case 3:
1503 arg_reg_info = reg_ctx->GetRegisterInfoByName("r3");
1504 break;
1505 }
1506 }
1507
1508 if (arg_reg_info) {
1509 RegisterValue reg_value;
1510
1511 if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) {
1512 if (is_signed)
1513 reg_value.SignExtend(bit_width);
1514 if (!reg_value.GetScalarValue(value->GetScalar()))
1515 return false;
1516 continue;
1517 }
1518 }
1519 return false;
1520 } else {
1521 if (sp == 0) {
1522 // Read the stack pointer if it already hasn't been read
1523 sp = reg_ctx->GetSP(0);
1524 if (sp == 0)
1525 return false;
1526 }
1527
1528 // Arguments 5 on up are on the stack
1529 const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1530 Status error;
1531 if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1532 sp, arg_byte_size, is_signed, value->GetScalar(), error))
1533 return false;
1534
1535 sp += arg_byte_size;
1536 }
1537 }
1538 }
1539 }
1540 return true;
1541 }
1542
IsArmv7kProcess() const1543 bool ABIMacOSX_arm::IsArmv7kProcess() const {
1544 bool is_armv7k = false;
1545 ProcessSP process_sp(GetProcessSP());
1546 if (process_sp) {
1547 const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
1548 const ArchSpec::Core system_core = arch.GetCore();
1549 if (system_core == ArchSpec::eCore_arm_armv7k) {
1550 is_armv7k = true;
1551 }
1552 }
1553 return is_armv7k;
1554 }
1555
GetReturnValueObjectImpl(Thread & thread,lldb_private::CompilerType & compiler_type) const1556 ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl(
1557 Thread &thread, lldb_private::CompilerType &compiler_type) const {
1558 Value value;
1559 ValueObjectSP return_valobj_sp;
1560
1561 if (!compiler_type)
1562 return return_valobj_sp;
1563
1564 value.SetCompilerType(compiler_type);
1565
1566 RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1567 if (!reg_ctx)
1568 return return_valobj_sp;
1569
1570 bool is_signed;
1571
1572 // Get the pointer to the first stack argument so we have a place to start
1573 // when reading data
1574
1575 const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1576 if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1577 llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
1578 if (!bit_width)
1579 return return_valobj_sp;
1580
1581 switch (*bit_width) {
1582 default:
1583 return return_valobj_sp;
1584 case 128:
1585 if (IsArmv7kProcess()) {
1586 // "A composite type not larger than 16 bytes is returned in r0-r3. The
1587 // format is as if the result had been stored in memory at a word-
1588 // aligned address and then loaded into r0-r3 with an ldm instruction"
1589 {
1590 const RegisterInfo *r1_reg_info =
1591 reg_ctx->GetRegisterInfoByName("r1", 0);
1592 const RegisterInfo *r2_reg_info =
1593 reg_ctx->GetRegisterInfoByName("r2", 0);
1594 const RegisterInfo *r3_reg_info =
1595 reg_ctx->GetRegisterInfoByName("r3", 0);
1596 if (r1_reg_info && r2_reg_info && r3_reg_info) {
1597 llvm::Optional<uint64_t> byte_size =
1598 compiler_type.GetByteSize(&thread);
1599 if (!byte_size)
1600 return return_valobj_sp;
1601 ProcessSP process_sp(thread.GetProcess());
1602 if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
1603 r2_reg_info->byte_size +
1604 r3_reg_info->byte_size &&
1605 process_sp) {
1606 std::unique_ptr<DataBufferHeap> heap_data_up(
1607 new DataBufferHeap(*byte_size, 0));
1608 const ByteOrder byte_order = process_sp->GetByteOrder();
1609 RegisterValue r0_reg_value;
1610 RegisterValue r1_reg_value;
1611 RegisterValue r2_reg_value;
1612 RegisterValue r3_reg_value;
1613 if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
1614 reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
1615 reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&
1616 reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) {
1617 Status error;
1618 if (r0_reg_value.GetAsMemoryData(r0_reg_info,
1619 heap_data_up->GetBytes() + 0,
1620 4, byte_order, error) &&
1621 r1_reg_value.GetAsMemoryData(r1_reg_info,
1622 heap_data_up->GetBytes() + 4,
1623 4, byte_order, error) &&
1624 r2_reg_value.GetAsMemoryData(r2_reg_info,
1625 heap_data_up->GetBytes() + 8,
1626 4, byte_order, error) &&
1627 r3_reg_value.GetAsMemoryData(r3_reg_info,
1628 heap_data_up->GetBytes() + 12,
1629 4, byte_order, error)) {
1630 DataExtractor data(DataBufferSP(heap_data_up.release()),
1631 byte_order,
1632 process_sp->GetAddressByteSize());
1633
1634 return_valobj_sp = ValueObjectConstResult::Create(
1635 &thread, compiler_type, ConstString(""), data);
1636 return return_valobj_sp;
1637 }
1638 }
1639 }
1640 }
1641 }
1642 } else {
1643 return return_valobj_sp;
1644 }
1645 break;
1646 case 64: {
1647 const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1648 uint64_t raw_value;
1649 raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
1650 raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) &
1651 UINT32_MAX))
1652 << 32;
1653 if (is_signed)
1654 value.GetScalar() = (int64_t)raw_value;
1655 else
1656 value.GetScalar() = (uint64_t)raw_value;
1657 } break;
1658 case 32:
1659 if (is_signed)
1660 value.GetScalar() = (int32_t)(
1661 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1662 else
1663 value.GetScalar() = (uint32_t)(
1664 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1665 break;
1666 case 16:
1667 if (is_signed)
1668 value.GetScalar() = (int16_t)(
1669 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1670 else
1671 value.GetScalar() = (uint16_t)(
1672 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1673 break;
1674 case 8:
1675 if (is_signed)
1676 value.GetScalar() = (int8_t)(
1677 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1678 else
1679 value.GetScalar() = (uint8_t)(
1680 reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1681 break;
1682 }
1683 } else if (compiler_type.IsPointerType()) {
1684 uint32_t ptr =
1685 thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
1686 UINT32_MAX;
1687 value.GetScalar() = ptr;
1688 } else {
1689 // not handled yet
1690 return return_valobj_sp;
1691 }
1692
1693 // If we get here, we have a valid Value, so make our ValueObject out of it:
1694
1695 return_valobj_sp = ValueObjectConstResult::Create(
1696 thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
1697 return return_valobj_sp;
1698 }
1699
SetReturnValueObject(lldb::StackFrameSP & frame_sp,lldb::ValueObjectSP & new_value_sp)1700 Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1701 lldb::ValueObjectSP &new_value_sp) {
1702 Status error;
1703 if (!new_value_sp) {
1704 error.SetErrorString("Empty value object for return value.");
1705 return error;
1706 }
1707
1708 CompilerType compiler_type = new_value_sp->GetCompilerType();
1709 if (!compiler_type) {
1710 error.SetErrorString("Null clang type for return value.");
1711 return error;
1712 }
1713
1714 Thread *thread = frame_sp->GetThread().get();
1715
1716 bool is_signed;
1717 uint32_t count;
1718 bool is_complex;
1719
1720 RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1721
1722 bool set_it_simple = false;
1723 if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
1724 compiler_type.IsPointerType()) {
1725 DataExtractor data;
1726 Status data_error;
1727 size_t num_bytes = new_value_sp->GetData(data, data_error);
1728 if (data_error.Fail()) {
1729 error.SetErrorStringWithFormat(
1730 "Couldn't convert return value to raw data: %s",
1731 data_error.AsCString());
1732 return error;
1733 }
1734 lldb::offset_t offset = 0;
1735 if (num_bytes <= 8) {
1736 const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1737 if (num_bytes <= 4) {
1738 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
1739
1740 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value))
1741 set_it_simple = true;
1742 } else {
1743 uint32_t raw_value = data.GetMaxU32(&offset, 4);
1744
1745 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) {
1746 const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1747 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
1748
1749 if (reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value))
1750 set_it_simple = true;
1751 }
1752 }
1753 } else if (num_bytes <= 16 && IsArmv7kProcess()) {
1754 // "A composite type not larger than 16 bytes is returned in r0-r3. The
1755 // format is as if the result had been stored in memory at a word-aligned
1756 // address and then loaded into r0-r3 with an ldm instruction"
1757
1758 const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1759 const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1760 const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
1761 const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
1762 lldb::offset_t offset = 0;
1763 uint32_t bytes_written = 4;
1764 uint32_t raw_value = data.GetMaxU64(&offset, 4);
1765 if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value) &&
1766 bytes_written <= num_bytes) {
1767 bytes_written += 4;
1768 raw_value = data.GetMaxU64(&offset, 4);
1769 if (bytes_written <= num_bytes &&
1770 reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) {
1771 bytes_written += 4;
1772 raw_value = data.GetMaxU64(&offset, 4);
1773 if (bytes_written <= num_bytes &&
1774 reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) {
1775 bytes_written += 4;
1776 raw_value = data.GetMaxU64(&offset, 4);
1777 if (bytes_written <= num_bytes &&
1778 reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value)) {
1779 set_it_simple = true;
1780 }
1781 }
1782 }
1783 }
1784 } else {
1785 error.SetErrorString("We don't support returning longer than 64 bit "
1786 "integer values at present.");
1787 }
1788 } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
1789 if (is_complex)
1790 error.SetErrorString(
1791 "We don't support returning complex values at present");
1792 else
1793 error.SetErrorString(
1794 "We don't support returning float values at present");
1795 }
1796
1797 if (!set_it_simple)
1798 error.SetErrorString(
1799 "We only support setting simple integer return types at present.");
1800
1801 return error;
1802 }
1803
CreateFunctionEntryUnwindPlan(UnwindPlan & unwind_plan)1804 bool ABIMacOSX_arm::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
1805 unwind_plan.Clear();
1806 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1807
1808 uint32_t lr_reg_num = dwarf_lr;
1809 uint32_t sp_reg_num = dwarf_sp;
1810 uint32_t pc_reg_num = dwarf_pc;
1811
1812 UnwindPlan::RowSP row(new UnwindPlan::Row);
1813
1814 // Our Call Frame Address is the stack pointer value
1815 row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1816
1817 // The previous PC is in the LR
1818 row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
1819 unwind_plan.AppendRow(row);
1820
1821 // All other registers are the same.
1822
1823 unwind_plan.SetSourceName("arm at-func-entry default");
1824 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1825
1826 return true;
1827 }
1828
CreateDefaultUnwindPlan(UnwindPlan & unwind_plan)1829 bool ABIMacOSX_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
1830 unwind_plan.Clear();
1831 unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1832
1833 uint32_t fp_reg_num =
1834 dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11
1835 uint32_t pc_reg_num = dwarf_pc;
1836
1837 UnwindPlan::RowSP row(new UnwindPlan::Row);
1838 const int32_t ptr_size = 4;
1839
1840 row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
1841 row->SetOffset(0);
1842
1843 row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1844 row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1845
1846 unwind_plan.AppendRow(row);
1847 unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
1848 unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1849 unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1850 unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
1851
1852 return true;
1853 }
1854
1855 // cf. "ARMv6 Function Calling Conventions"
1856 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
1857 // and "ARMv7 Function Calling Conventions"
1858 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html
1859
1860 // ARMv7 on iOS general purpose reg rules:
1861 // r0-r3 not preserved (used for argument passing)
1862 // r4-r6 preserved
1863 // r7 preserved (frame pointer)
1864 // r8 preserved
1865 // r9 not preserved (usable as volatile scratch register with iOS 3.x and
1866 // later)
1867 // r10-r11 preserved
1868 // r12 not presrved
1869 // r13 preserved (stack pointer)
1870 // r14 not preserved (link register)
1871 // r15 preserved (pc)
1872 // cpsr not preserved (different rules for different bits)
1873
1874 // ARMv7 on iOS floating point rules:
1875 // d0-d7 not preserved (aka s0-s15, q0-q3)
1876 // d8-d15 preserved (aka s16-s31, q4-q7)
1877 // d16-d31 not preserved (aka q8-q15)
1878
RegisterIsVolatile(const RegisterInfo * reg_info)1879 bool ABIMacOSX_arm::RegisterIsVolatile(const RegisterInfo *reg_info) {
1880 if (reg_info) {
1881 // Volatile registers are: r0, r1, r2, r3, r9, r12, r13 (aka sp)
1882 const char *name = reg_info->name;
1883 if (name[0] == 'r') {
1884 switch (name[1]) {
1885 case '0':
1886 return name[2] == '\0'; // r0
1887 case '1':
1888 switch (name[2]) {
1889 case '\0':
1890 return true; // r1
1891 case '2':
1892 case '3':
1893 return name[3] == '\0'; // r12, r13 (sp)
1894 default:
1895 break;
1896 }
1897 break;
1898
1899 case '2':
1900 return name[2] == '\0'; // r2
1901 case '3':
1902 return name[2] == '\0'; // r3
1903 case '9':
1904 return name[2] == '\0'; // r9 (apple-ios only...)
1905
1906 break;
1907 }
1908 } else if (name[0] == 'd') {
1909 switch (name[1]) {
1910 case '0':
1911 return name[2] == '\0'; // d0 is volatile
1912
1913 case '1':
1914 switch (name[2]) {
1915 case '\0':
1916 return true; // d1 is volatile
1917 case '6':
1918 case '7':
1919 case '8':
1920 case '9':
1921 return name[3] == '\0'; // d16 - d19 are volatile
1922 default:
1923 break;
1924 }
1925 break;
1926
1927 case '2':
1928 switch (name[2]) {
1929 case '\0':
1930 return true; // d2 is volatile
1931 case '0':
1932 case '1':
1933 case '2':
1934 case '3':
1935 case '4':
1936 case '5':
1937 case '6':
1938 case '7':
1939 case '8':
1940 case '9':
1941 return name[3] == '\0'; // d20 - d29 are volatile
1942 default:
1943 break;
1944 }
1945 break;
1946
1947 case '3':
1948 switch (name[2]) {
1949 case '\0':
1950 return true; // d3 is volatile
1951 case '0':
1952 case '1':
1953 return name[3] == '\0'; // d30 - d31 are volatile
1954 default:
1955 break;
1956 }
1957 break;
1958 case '4':
1959 case '5':
1960 case '6':
1961 case '7':
1962 return name[2] == '\0'; // d4 - d7 are volatile
1963
1964 default:
1965 break;
1966 }
1967 } else if (name[0] == 's') {
1968 switch (name[1]) {
1969 case '0':
1970 return name[2] == '\0'; // s0 is volatile
1971
1972 case '1':
1973 switch (name[2]) {
1974 case '\0':
1975 return true; // s1 is volatile
1976 case '0':
1977 case '1':
1978 case '2':
1979 case '3':
1980 case '4':
1981 case '5':
1982 return name[3] == '\0'; // s10 - s15 are volatile
1983 default:
1984 break;
1985 }
1986 break;
1987
1988 case '2':
1989 case '3':
1990 case '4':
1991 case '5':
1992 case '6':
1993 case '7':
1994 case '8':
1995 case '9':
1996 return name[2] == '\0'; // s2 - s9 are volatile
1997
1998 default:
1999 break;
2000 }
2001 } else if (name[0] == 'q') {
2002 switch (name[1]) {
2003 case '1':
2004 switch (name[2]) {
2005 case '\0':
2006 return true; // q1 is volatile
2007 case '0':
2008 case '1':
2009 case '2':
2010 case '3':
2011 case '4':
2012 case '5':
2013 return true; // q10-q15 are volatile
2014 default:
2015 break;
2016 };
2017 break;
2018 case '0':
2019 case '2':
2020 case '3':
2021 return name[2] == '\0'; // q0-q3 are volatile
2022 case '8':
2023 case '9':
2024 return name[2] == '\0'; // q8-q9 are volatile
2025 default:
2026 break;
2027 }
2028 } else if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')
2029 return true;
2030 }
2031 return false;
2032 }
2033
Initialize()2034 void ABIMacOSX_arm::Initialize() {
2035 PluginManager::RegisterPlugin(GetPluginNameStatic(),
2036 "Mac OS X ABI for arm targets", CreateInstance);
2037 }
2038
Terminate()2039 void ABIMacOSX_arm::Terminate() {
2040 PluginManager::UnregisterPlugin(CreateInstance);
2041 }
2042
GetPluginNameStatic()2043 lldb_private::ConstString ABIMacOSX_arm::GetPluginNameStatic() {
2044 static ConstString g_name("macosx-arm");
2045 return g_name;
2046 }
2047
2048 // PluginInterface protocol
2049
GetPluginName()2050 lldb_private::ConstString ABIMacOSX_arm::GetPluginName() {
2051 return GetPluginNameStatic();
2052 }
2053
GetPluginVersion()2054 uint32_t ABIMacOSX_arm::GetPluginVersion() { return 1; }
2055