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
34using namespace lldb;
35using namespace lldb_private;
36
37static 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
1293static const uint32_t k_num_register_infos =
1294    llvm::array_lengthof(g_register_infos);
1295static bool g_register_info_names_constified = false;
1296
1297const lldb_private::RegisterInfo *
1298ABIMacOSX_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
1317size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1318
1319// Static Functions
1320
1321ABISP
1322ABIMacOSX_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
1337bool 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
1443bool 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
1543bool 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
1556ValueObjectSP 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
1700Status 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
1804bool 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
1829bool 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
1879bool 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
2034void ABIMacOSX_arm::Initialize() {
2035  PluginManager::RegisterPlugin(GetPluginNameStatic(),
2036                                "Mac OS X ABI for arm targets", CreateInstance);
2037}
2038
2039void ABIMacOSX_arm::Terminate() {
2040  PluginManager::UnregisterPlugin(CreateInstance);
2041}
2042
2043lldb_private::ConstString ABIMacOSX_arm::GetPluginNameStatic() {
2044  static ConstString g_name("macosx-arm");
2045  return g_name;
2046}
2047
2048// PluginInterface protocol
2049
2050lldb_private::ConstString ABIMacOSX_arm::GetPluginName() {
2051  return GetPluginNameStatic();
2052}
2053
2054uint32_t ABIMacOSX_arm::GetPluginVersion() { return 1; }
2055