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