ABIMacOSX_arm64.cpp revision 344779 
1//===-- ABIMacOSX_arm64.cpp -------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "ABIMacOSX_arm64.h"
11
12#include <vector>
13
14#include "llvm/ADT/STLExtras.h"
15#include "llvm/ADT/Triple.h"
16
17#include "lldb/Core/Module.h"
18#include "lldb/Core/PluginManager.h"
19#include "lldb/Core/Value.h"
20#include "lldb/Core/ValueObjectConstResult.h"
21#include "lldb/Symbol/UnwindPlan.h"
22#include "lldb/Target/Process.h"
23#include "lldb/Target/RegisterContext.h"
24#include "lldb/Target/Target.h"
25#include "lldb/Target/Thread.h"
26#include "lldb/Utility/ConstString.h"
27#include "lldb/Utility/Log.h"
28#include "lldb/Utility/RegisterValue.h"
29#include "lldb/Utility/Scalar.h"
30#include "lldb/Utility/Status.h"
31
32#include "Utility/ARM64_DWARF_Registers.h"
33
34using namespace lldb;
35using namespace lldb_private;
36
37static const char *pluginDesc = "Mac OS X ABI for arm64 targets";
38
39static RegisterInfo g_register_infos[] = {
40    //  NAME       ALT       SZ OFF ENCODING          FORMAT
41    //  EH_FRAME             DWARF                  GENERIC
42    //  PROCESS PLUGIN          LLDB NATIVE
43    //  ========== =======   == === =============     ===================
44    //  ===================  ====================== ===========================
45    //  ======================= ======================
46    {"x0",
47     nullptr,
48     8,
49     0,
50     eEncodingUint,
51     eFormatHex,
52     {LLDB_INVALID_REGNUM, arm64_dwarf::x0, LLDB_REGNUM_GENERIC_ARG1,
53      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
54     nullptr,
55     nullptr,
56     nullptr,
57     0},
58    {"x1",
59     nullptr,
60     8,
61     0,
62     eEncodingUint,
63     eFormatHex,
64     {LLDB_INVALID_REGNUM, arm64_dwarf::x1, LLDB_REGNUM_GENERIC_ARG2,
65      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
66     nullptr,
67     nullptr,
68     nullptr,
69     0},
70    {"x2",
71     nullptr,
72     8,
73     0,
74     eEncodingUint,
75     eFormatHex,
76     {LLDB_INVALID_REGNUM, arm64_dwarf::x2, LLDB_REGNUM_GENERIC_ARG3,
77      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
78     nullptr,
79     nullptr,
80     nullptr,
81     0},
82    {"x3",
83     nullptr,
84     8,
85     0,
86     eEncodingUint,
87     eFormatHex,
88     {LLDB_INVALID_REGNUM, arm64_dwarf::x3, LLDB_REGNUM_GENERIC_ARG4,
89      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
90     nullptr,
91     nullptr,
92     nullptr,
93     0},
94    {"x4",
95     nullptr,
96     8,
97     0,
98     eEncodingUint,
99     eFormatHex,
100     {LLDB_INVALID_REGNUM, arm64_dwarf::x4, LLDB_REGNUM_GENERIC_ARG5,
101      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
102     nullptr,
103     nullptr,
104     nullptr,
105     0},
106    {"x5",
107     nullptr,
108     8,
109     0,
110     eEncodingUint,
111     eFormatHex,
112     {LLDB_INVALID_REGNUM, arm64_dwarf::x5, LLDB_REGNUM_GENERIC_ARG6,
113      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
114     nullptr,
115     nullptr,
116     nullptr,
117     0},
118    {"x6",
119     nullptr,
120     8,
121     0,
122     eEncodingUint,
123     eFormatHex,
124     {LLDB_INVALID_REGNUM, arm64_dwarf::x6, LLDB_REGNUM_GENERIC_ARG7,
125      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
126     nullptr,
127     nullptr,
128     nullptr,
129     0},
130    {"x7",
131     nullptr,
132     8,
133     0,
134     eEncodingUint,
135     eFormatHex,
136     {LLDB_INVALID_REGNUM, arm64_dwarf::x7, LLDB_REGNUM_GENERIC_ARG8,
137      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
138     nullptr,
139     nullptr,
140     nullptr,
141     0},
142    {"x8",
143     nullptr,
144     8,
145     0,
146     eEncodingUint,
147     eFormatHex,
148     {LLDB_INVALID_REGNUM, arm64_dwarf::x8, LLDB_INVALID_REGNUM,
149      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
150     nullptr,
151     nullptr,
152     nullptr,
153     0},
154    {"x9",
155     nullptr,
156     8,
157     0,
158     eEncodingUint,
159     eFormatHex,
160     {LLDB_INVALID_REGNUM, arm64_dwarf::x9, LLDB_INVALID_REGNUM,
161      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
162     nullptr,
163     nullptr,
164     nullptr,
165     0},
166    {"x10",
167     nullptr,
168     8,
169     0,
170     eEncodingUint,
171     eFormatHex,
172     {LLDB_INVALID_REGNUM, arm64_dwarf::x10, LLDB_INVALID_REGNUM,
173      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
174     nullptr,
175     nullptr,
176     nullptr,
177     0},
178    {"x11",
179     nullptr,
180     8,
181     0,
182     eEncodingUint,
183     eFormatHex,
184     {LLDB_INVALID_REGNUM, arm64_dwarf::x11, LLDB_INVALID_REGNUM,
185      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
186     nullptr,
187     nullptr,
188     nullptr,
189     0},
190    {"x12",
191     nullptr,
192     8,
193     0,
194     eEncodingUint,
195     eFormatHex,
196     {LLDB_INVALID_REGNUM, arm64_dwarf::x12, LLDB_INVALID_REGNUM,
197      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
198     nullptr,
199     nullptr,
200     nullptr,
201     0},
202    {"x13",
203     nullptr,
204     8,
205     0,
206     eEncodingUint,
207     eFormatHex,
208     {LLDB_INVALID_REGNUM, arm64_dwarf::x13, LLDB_INVALID_REGNUM,
209      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
210     nullptr,
211     nullptr,
212     nullptr,
213     0},
214    {"x14",
215     nullptr,
216     8,
217     0,
218     eEncodingUint,
219     eFormatHex,
220     {LLDB_INVALID_REGNUM, arm64_dwarf::x14, LLDB_INVALID_REGNUM,
221      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
222     nullptr,
223     nullptr,
224     nullptr,
225     0},
226    {"x15",
227     nullptr,
228     8,
229     0,
230     eEncodingUint,
231     eFormatHex,
232     {LLDB_INVALID_REGNUM, arm64_dwarf::x15, LLDB_INVALID_REGNUM,
233      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
234     nullptr,
235     nullptr,
236     nullptr,
237     0},
238    {"x16",
239     nullptr,
240     8,
241     0,
242     eEncodingUint,
243     eFormatHex,
244     {LLDB_INVALID_REGNUM, arm64_dwarf::x16, LLDB_INVALID_REGNUM,
245      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
246     nullptr,
247     nullptr,
248     nullptr,
249     0},
250    {"x17",
251     nullptr,
252     8,
253     0,
254     eEncodingUint,
255     eFormatHex,
256     {LLDB_INVALID_REGNUM, arm64_dwarf::x17, LLDB_INVALID_REGNUM,
257      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
258     nullptr,
259     nullptr,
260     nullptr,
261     0},
262    {"x18",
263     nullptr,
264     8,
265     0,
266     eEncodingUint,
267     eFormatHex,
268     {LLDB_INVALID_REGNUM, arm64_dwarf::x18, LLDB_INVALID_REGNUM,
269      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
270     nullptr,
271     nullptr,
272     nullptr,
273     0},
274    {"x19",
275     nullptr,
276     8,
277     0,
278     eEncodingUint,
279     eFormatHex,
280     {LLDB_INVALID_REGNUM, arm64_dwarf::x19, LLDB_INVALID_REGNUM,
281      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
282     nullptr,
283     nullptr,
284     nullptr,
285     0},
286    {"x20",
287     nullptr,
288     8,
289     0,
290     eEncodingUint,
291     eFormatHex,
292     {LLDB_INVALID_REGNUM, arm64_dwarf::x20, LLDB_INVALID_REGNUM,
293      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
294     nullptr,
295     nullptr,
296     nullptr,
297     0},
298    {"x21",
299     nullptr,
300     8,
301     0,
302     eEncodingUint,
303     eFormatHex,
304     {LLDB_INVALID_REGNUM, arm64_dwarf::x21, LLDB_INVALID_REGNUM,
305      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
306     nullptr,
307     nullptr,
308     nullptr,
309     0},
310    {"x22",
311     nullptr,
312     8,
313     0,
314     eEncodingUint,
315     eFormatHex,
316     {LLDB_INVALID_REGNUM, arm64_dwarf::x22, LLDB_INVALID_REGNUM,
317      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
318     nullptr,
319     nullptr,
320     nullptr,
321     0},
322    {"x23",
323     nullptr,
324     8,
325     0,
326     eEncodingUint,
327     eFormatHex,
328     {LLDB_INVALID_REGNUM, arm64_dwarf::x23, LLDB_INVALID_REGNUM,
329      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
330     nullptr,
331     nullptr,
332     nullptr,
333     0},
334    {"x24",
335     nullptr,
336     8,
337     0,
338     eEncodingUint,
339     eFormatHex,
340     {LLDB_INVALID_REGNUM, arm64_dwarf::x24, LLDB_INVALID_REGNUM,
341      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
342     nullptr,
343     nullptr,
344     nullptr,
345     0},
346    {"x25",
347     nullptr,
348     8,
349     0,
350     eEncodingUint,
351     eFormatHex,
352     {LLDB_INVALID_REGNUM, arm64_dwarf::x25, LLDB_INVALID_REGNUM,
353      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
354     nullptr,
355     nullptr,
356     nullptr,
357     0},
358    {"x26",
359     nullptr,
360     8,
361     0,
362     eEncodingUint,
363     eFormatHex,
364     {LLDB_INVALID_REGNUM, arm64_dwarf::x26, LLDB_INVALID_REGNUM,
365      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
366     nullptr,
367     nullptr,
368     nullptr,
369     0},
370    {"x27",
371     nullptr,
372     8,
373     0,
374     eEncodingUint,
375     eFormatHex,
376     {LLDB_INVALID_REGNUM, arm64_dwarf::x27, LLDB_INVALID_REGNUM,
377      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
378     nullptr,
379     nullptr,
380     nullptr,
381     0},
382    {"x28",
383     nullptr,
384     8,
385     0,
386     eEncodingUint,
387     eFormatHex,
388     {LLDB_INVALID_REGNUM, arm64_dwarf::x28, LLDB_INVALID_REGNUM,
389      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
390     nullptr,
391     nullptr,
392     nullptr,
393     0},
394    {"fp",
395     "x29",
396     8,
397     0,
398     eEncodingUint,
399     eFormatHex,
400     {LLDB_INVALID_REGNUM, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP,
401      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
402     nullptr,
403     nullptr,
404     nullptr,
405     0},
406    {"lr",
407     "x30",
408     8,
409     0,
410     eEncodingUint,
411     eFormatHex,
412     {LLDB_INVALID_REGNUM, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA,
413      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
414     nullptr,
415     nullptr,
416     nullptr,
417     0},
418    {"sp",
419     "x31",
420     8,
421     0,
422     eEncodingUint,
423     eFormatHex,
424     {LLDB_INVALID_REGNUM, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP,
425      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
426     nullptr,
427     nullptr,
428     nullptr,
429     0},
430    {"pc",
431     nullptr,
432     8,
433     0,
434     eEncodingUint,
435     eFormatHex,
436     {LLDB_INVALID_REGNUM, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC,
437      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
438     nullptr,
439     nullptr,
440     nullptr,
441     0},
442    {"cpsr",
443     "psr",
444     4,
445     0,
446     eEncodingUint,
447     eFormatHex,
448     {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS,
449      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
450     nullptr,
451     nullptr,
452     nullptr,
453     0},
454
455    {"v0",
456     nullptr,
457     16,
458     0,
459     eEncodingVector,
460     eFormatVectorOfUInt8,
461     {LLDB_INVALID_REGNUM, arm64_dwarf::v0, LLDB_INVALID_REGNUM,
462      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
463     nullptr,
464     nullptr,
465     nullptr,
466     0},
467    {"v1",
468     nullptr,
469     16,
470     0,
471     eEncodingVector,
472     eFormatVectorOfUInt8,
473     {LLDB_INVALID_REGNUM, arm64_dwarf::v1, LLDB_INVALID_REGNUM,
474      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
475     nullptr,
476     nullptr,
477     nullptr,
478     0},
479    {"v2",
480     nullptr,
481     16,
482     0,
483     eEncodingVector,
484     eFormatVectorOfUInt8,
485     {LLDB_INVALID_REGNUM, arm64_dwarf::v2, LLDB_INVALID_REGNUM,
486      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
487     nullptr,
488     nullptr,
489     nullptr,
490     0},
491    {"v3",
492     nullptr,
493     16,
494     0,
495     eEncodingVector,
496     eFormatVectorOfUInt8,
497     {LLDB_INVALID_REGNUM, arm64_dwarf::v3, LLDB_INVALID_REGNUM,
498      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
499     nullptr,
500     nullptr,
501     nullptr,
502     0},
503    {"v4",
504     nullptr,
505     16,
506     0,
507     eEncodingVector,
508     eFormatVectorOfUInt8,
509     {LLDB_INVALID_REGNUM, arm64_dwarf::v4, LLDB_INVALID_REGNUM,
510      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
511     nullptr,
512     nullptr,
513     nullptr,
514     0},
515    {"v5",
516     nullptr,
517     16,
518     0,
519     eEncodingVector,
520     eFormatVectorOfUInt8,
521     {LLDB_INVALID_REGNUM, arm64_dwarf::v5, LLDB_INVALID_REGNUM,
522      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
523     nullptr,
524     nullptr,
525     nullptr,
526     0},
527    {"v6",
528     nullptr,
529     16,
530     0,
531     eEncodingVector,
532     eFormatVectorOfUInt8,
533     {LLDB_INVALID_REGNUM, arm64_dwarf::v6, LLDB_INVALID_REGNUM,
534      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
535     nullptr,
536     nullptr,
537     nullptr,
538     0},
539    {"v7",
540     nullptr,
541     16,
542     0,
543     eEncodingVector,
544     eFormatVectorOfUInt8,
545     {LLDB_INVALID_REGNUM, arm64_dwarf::v7, LLDB_INVALID_REGNUM,
546      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
547     nullptr,
548     nullptr,
549     nullptr,
550     0},
551    {"v8",
552     nullptr,
553     16,
554     0,
555     eEncodingVector,
556     eFormatVectorOfUInt8,
557     {LLDB_INVALID_REGNUM, arm64_dwarf::v8, LLDB_INVALID_REGNUM,
558      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
559     nullptr,
560     nullptr,
561     nullptr,
562     0},
563    {"v9",
564     nullptr,
565     16,
566     0,
567     eEncodingVector,
568     eFormatVectorOfUInt8,
569     {LLDB_INVALID_REGNUM, arm64_dwarf::v9, LLDB_INVALID_REGNUM,
570      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
571     nullptr,
572     nullptr,
573     nullptr,
574     0},
575    {"v10",
576     nullptr,
577     16,
578     0,
579     eEncodingVector,
580     eFormatVectorOfUInt8,
581     {LLDB_INVALID_REGNUM, arm64_dwarf::v10, LLDB_INVALID_REGNUM,
582      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
583     nullptr,
584     nullptr,
585     nullptr,
586     0},
587    {"v11",
588     nullptr,
589     16,
590     0,
591     eEncodingVector,
592     eFormatVectorOfUInt8,
593     {LLDB_INVALID_REGNUM, arm64_dwarf::v11, LLDB_INVALID_REGNUM,
594      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
595     nullptr,
596     nullptr,
597     nullptr,
598     0},
599    {"v12",
600     nullptr,
601     16,
602     0,
603     eEncodingVector,
604     eFormatVectorOfUInt8,
605     {LLDB_INVALID_REGNUM, arm64_dwarf::v12, LLDB_INVALID_REGNUM,
606      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
607     nullptr,
608     nullptr,
609     nullptr,
610     0},
611    {"v13",
612     nullptr,
613     16,
614     0,
615     eEncodingVector,
616     eFormatVectorOfUInt8,
617     {LLDB_INVALID_REGNUM, arm64_dwarf::v13, LLDB_INVALID_REGNUM,
618      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
619     nullptr,
620     nullptr,
621     nullptr,
622     0},
623    {"v14",
624     nullptr,
625     16,
626     0,
627     eEncodingVector,
628     eFormatVectorOfUInt8,
629     {LLDB_INVALID_REGNUM, arm64_dwarf::v14, LLDB_INVALID_REGNUM,
630      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
631     nullptr,
632     nullptr,
633     nullptr,
634     0},
635    {"v15",
636     nullptr,
637     16,
638     0,
639     eEncodingVector,
640     eFormatVectorOfUInt8,
641     {LLDB_INVALID_REGNUM, arm64_dwarf::v15, LLDB_INVALID_REGNUM,
642      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
643     nullptr,
644     nullptr,
645     nullptr,
646     0},
647    {"v16",
648     nullptr,
649     16,
650     0,
651     eEncodingVector,
652     eFormatVectorOfUInt8,
653     {LLDB_INVALID_REGNUM, arm64_dwarf::v16, LLDB_INVALID_REGNUM,
654      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
655     nullptr,
656     nullptr,
657     nullptr,
658     0},
659    {"v17",
660     nullptr,
661     16,
662     0,
663     eEncodingVector,
664     eFormatVectorOfUInt8,
665     {LLDB_INVALID_REGNUM, arm64_dwarf::v17, LLDB_INVALID_REGNUM,
666      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
667     nullptr,
668     nullptr,
669     nullptr,
670     0},
671    {"v18",
672     nullptr,
673     16,
674     0,
675     eEncodingVector,
676     eFormatVectorOfUInt8,
677     {LLDB_INVALID_REGNUM, arm64_dwarf::v18, LLDB_INVALID_REGNUM,
678      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
679     nullptr,
680     nullptr,
681     nullptr,
682     0},
683    {"v19",
684     nullptr,
685     16,
686     0,
687     eEncodingVector,
688     eFormatVectorOfUInt8,
689     {LLDB_INVALID_REGNUM, arm64_dwarf::v19, LLDB_INVALID_REGNUM,
690      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
691     nullptr,
692     nullptr,
693     nullptr,
694     0},
695    {"v20",
696     nullptr,
697     16,
698     0,
699     eEncodingVector,
700     eFormatVectorOfUInt8,
701     {LLDB_INVALID_REGNUM, arm64_dwarf::v20, LLDB_INVALID_REGNUM,
702      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
703     nullptr,
704     nullptr,
705     nullptr,
706     0},
707    {"v21",
708     nullptr,
709     16,
710     0,
711     eEncodingVector,
712     eFormatVectorOfUInt8,
713     {LLDB_INVALID_REGNUM, arm64_dwarf::v21, LLDB_INVALID_REGNUM,
714      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
715     nullptr,
716     nullptr,
717     nullptr,
718     0},
719    {"v22",
720     nullptr,
721     16,
722     0,
723     eEncodingVector,
724     eFormatVectorOfUInt8,
725     {LLDB_INVALID_REGNUM, arm64_dwarf::v22, LLDB_INVALID_REGNUM,
726      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
727     nullptr,
728     nullptr,
729     nullptr,
730     0},
731    {"v23",
732     nullptr,
733     16,
734     0,
735     eEncodingVector,
736     eFormatVectorOfUInt8,
737     {LLDB_INVALID_REGNUM, arm64_dwarf::v23, LLDB_INVALID_REGNUM,
738      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
739     nullptr,
740     nullptr,
741     nullptr,
742     0},
743    {"v24",
744     nullptr,
745     16,
746     0,
747     eEncodingVector,
748     eFormatVectorOfUInt8,
749     {LLDB_INVALID_REGNUM, arm64_dwarf::v24, LLDB_INVALID_REGNUM,
750      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
751     nullptr,
752     nullptr,
753     nullptr,
754     0},
755    {"v25",
756     nullptr,
757     16,
758     0,
759     eEncodingVector,
760     eFormatVectorOfUInt8,
761     {LLDB_INVALID_REGNUM, arm64_dwarf::v25, LLDB_INVALID_REGNUM,
762      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
763     nullptr,
764     nullptr,
765     nullptr,
766     0},
767    {"v26",
768     nullptr,
769     16,
770     0,
771     eEncodingVector,
772     eFormatVectorOfUInt8,
773     {LLDB_INVALID_REGNUM, arm64_dwarf::v26, LLDB_INVALID_REGNUM,
774      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
775     nullptr,
776     nullptr,
777     nullptr,
778     0},
779    {"v27",
780     nullptr,
781     16,
782     0,
783     eEncodingVector,
784     eFormatVectorOfUInt8,
785     {LLDB_INVALID_REGNUM, arm64_dwarf::v27, LLDB_INVALID_REGNUM,
786      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
787     nullptr,
788     nullptr,
789     nullptr,
790     0},
791    {"v28",
792     nullptr,
793     16,
794     0,
795     eEncodingVector,
796     eFormatVectorOfUInt8,
797     {LLDB_INVALID_REGNUM, arm64_dwarf::v28, LLDB_INVALID_REGNUM,
798      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
799     nullptr,
800     nullptr,
801     nullptr,
802     0},
803    {"v29",
804     nullptr,
805     16,
806     0,
807     eEncodingVector,
808     eFormatVectorOfUInt8,
809     {LLDB_INVALID_REGNUM, arm64_dwarf::v29, LLDB_INVALID_REGNUM,
810      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
811     nullptr,
812     nullptr,
813     nullptr,
814     0},
815    {"v30",
816     nullptr,
817     16,
818     0,
819     eEncodingVector,
820     eFormatVectorOfUInt8,
821     {LLDB_INVALID_REGNUM, arm64_dwarf::v30, LLDB_INVALID_REGNUM,
822      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
823     nullptr,
824     nullptr,
825     nullptr,
826     0},
827    {"v31",
828     nullptr,
829     16,
830     0,
831     eEncodingVector,
832     eFormatVectorOfUInt8,
833     {LLDB_INVALID_REGNUM, arm64_dwarf::v31, LLDB_INVALID_REGNUM,
834      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
835     nullptr,
836     nullptr,
837     nullptr,
838     0},
839
840    {"fpsr",
841     nullptr,
842     4,
843     0,
844     eEncodingUint,
845     eFormatHex,
846     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
847      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
848     nullptr,
849     nullptr,
850     nullptr,
851     0},
852    {"fpcr",
853     nullptr,
854     4,
855     0,
856     eEncodingUint,
857     eFormatHex,
858     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
859      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
860     nullptr,
861     nullptr,
862     nullptr,
863     0},
864
865    {"s0",
866     nullptr,
867     4,
868     0,
869     eEncodingIEEE754,
870     eFormatFloat,
871     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
872      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
873     nullptr,
874     nullptr,
875     nullptr,
876     0},
877    {"s1",
878     nullptr,
879     4,
880     0,
881     eEncodingIEEE754,
882     eFormatFloat,
883     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
884      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
885     nullptr,
886     nullptr,
887     nullptr,
888     0},
889    {"s2",
890     nullptr,
891     4,
892     0,
893     eEncodingIEEE754,
894     eFormatFloat,
895     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
896      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
897     nullptr,
898     nullptr,
899     nullptr,
900     0},
901    {"s3",
902     nullptr,
903     4,
904     0,
905     eEncodingIEEE754,
906     eFormatFloat,
907     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
908      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
909     nullptr,
910     nullptr,
911     nullptr,
912     0},
913    {"s4",
914     nullptr,
915     4,
916     0,
917     eEncodingIEEE754,
918     eFormatFloat,
919     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
920      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
921     nullptr,
922     nullptr,
923     nullptr,
924     0},
925    {"s5",
926     nullptr,
927     4,
928     0,
929     eEncodingIEEE754,
930     eFormatFloat,
931     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
932      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
933     nullptr,
934     nullptr,
935     nullptr,
936     0},
937    {"s6",
938     nullptr,
939     4,
940     0,
941     eEncodingIEEE754,
942     eFormatFloat,
943     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
944      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
945     nullptr,
946     nullptr,
947     nullptr,
948     0},
949    {"s7",
950     nullptr,
951     4,
952     0,
953     eEncodingIEEE754,
954     eFormatFloat,
955     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
956      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
957     nullptr,
958     nullptr,
959     nullptr,
960     0},
961    {"s8",
962     nullptr,
963     4,
964     0,
965     eEncodingIEEE754,
966     eFormatFloat,
967     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
968      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
969     nullptr,
970     nullptr,
971     nullptr,
972     0},
973    {"s9",
974     nullptr,
975     4,
976     0,
977     eEncodingIEEE754,
978     eFormatFloat,
979     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
980      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
981     nullptr,
982     nullptr,
983     nullptr,
984     0},
985    {"s10",
986     nullptr,
987     4,
988     0,
989     eEncodingIEEE754,
990     eFormatFloat,
991     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
992      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
993     nullptr,
994     nullptr,
995     nullptr,
996     0},
997    {"s11",
998     nullptr,
999     4,
1000     0,
1001     eEncodingIEEE754,
1002     eFormatFloat,
1003     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1004      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1005     nullptr,
1006     nullptr,
1007     nullptr,
1008     0},
1009    {"s12",
1010     nullptr,
1011     4,
1012     0,
1013     eEncodingIEEE754,
1014     eFormatFloat,
1015     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1016      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1017     nullptr,
1018     nullptr,
1019     nullptr,
1020     0},
1021    {"s13",
1022     nullptr,
1023     4,
1024     0,
1025     eEncodingIEEE754,
1026     eFormatFloat,
1027     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1028      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1029     nullptr,
1030     nullptr,
1031     nullptr,
1032     0},
1033    {"s14",
1034     nullptr,
1035     4,
1036     0,
1037     eEncodingIEEE754,
1038     eFormatFloat,
1039     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1040      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1041     nullptr,
1042     nullptr,
1043     nullptr,
1044     0},
1045    {"s15",
1046     nullptr,
1047     4,
1048     0,
1049     eEncodingIEEE754,
1050     eFormatFloat,
1051     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1052      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1053     nullptr,
1054     nullptr,
1055     nullptr,
1056     0},
1057    {"s16",
1058     nullptr,
1059     4,
1060     0,
1061     eEncodingIEEE754,
1062     eFormatFloat,
1063     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1064      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1065     nullptr,
1066     nullptr,
1067     nullptr,
1068     0},
1069    {"s17",
1070     nullptr,
1071     4,
1072     0,
1073     eEncodingIEEE754,
1074     eFormatFloat,
1075     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1076      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1077     nullptr,
1078     nullptr,
1079     nullptr,
1080     0},
1081    {"s18",
1082     nullptr,
1083     4,
1084     0,
1085     eEncodingIEEE754,
1086     eFormatFloat,
1087     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1088      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1089     nullptr,
1090     nullptr,
1091     nullptr,
1092     0},
1093    {"s19",
1094     nullptr,
1095     4,
1096     0,
1097     eEncodingIEEE754,
1098     eFormatFloat,
1099     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1100      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1101     nullptr,
1102     nullptr,
1103     nullptr,
1104     0},
1105    {"s20",
1106     nullptr,
1107     4,
1108     0,
1109     eEncodingIEEE754,
1110     eFormatFloat,
1111     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1112      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1113     nullptr,
1114     nullptr,
1115     nullptr,
1116     0},
1117    {"s21",
1118     nullptr,
1119     4,
1120     0,
1121     eEncodingIEEE754,
1122     eFormatFloat,
1123     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1124      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1125     nullptr,
1126     nullptr,
1127     nullptr,
1128     0},
1129    {"s22",
1130     nullptr,
1131     4,
1132     0,
1133     eEncodingIEEE754,
1134     eFormatFloat,
1135     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1136      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1137     nullptr,
1138     nullptr,
1139     nullptr,
1140     0},
1141    {"s23",
1142     nullptr,
1143     4,
1144     0,
1145     eEncodingIEEE754,
1146     eFormatFloat,
1147     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1148      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1149     nullptr,
1150     nullptr,
1151     nullptr,
1152     0},
1153    {"s24",
1154     nullptr,
1155     4,
1156     0,
1157     eEncodingIEEE754,
1158     eFormatFloat,
1159     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1160      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1161     nullptr,
1162     nullptr,
1163     nullptr,
1164     0},
1165    {"s25",
1166     nullptr,
1167     4,
1168     0,
1169     eEncodingIEEE754,
1170     eFormatFloat,
1171     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1172      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1173     nullptr,
1174     nullptr,
1175     nullptr,
1176     0},
1177    {"s26",
1178     nullptr,
1179     4,
1180     0,
1181     eEncodingIEEE754,
1182     eFormatFloat,
1183     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1184      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1185     nullptr,
1186     nullptr,
1187     nullptr,
1188     0},
1189    {"s27",
1190     nullptr,
1191     4,
1192     0,
1193     eEncodingIEEE754,
1194     eFormatFloat,
1195     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1196      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1197     nullptr,
1198     nullptr,
1199     nullptr,
1200     0},
1201    {"s28",
1202     nullptr,
1203     4,
1204     0,
1205     eEncodingIEEE754,
1206     eFormatFloat,
1207     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1208      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1209     nullptr,
1210     nullptr,
1211     nullptr,
1212     0},
1213    {"s29",
1214     nullptr,
1215     4,
1216     0,
1217     eEncodingIEEE754,
1218     eFormatFloat,
1219     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1220      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1221     nullptr,
1222     nullptr,
1223     nullptr,
1224     0},
1225    {"s30",
1226     nullptr,
1227     4,
1228     0,
1229     eEncodingIEEE754,
1230     eFormatFloat,
1231     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1232      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1233     nullptr,
1234     nullptr,
1235     nullptr,
1236     0},
1237    {"s31",
1238     nullptr,
1239     4,
1240     0,
1241     eEncodingIEEE754,
1242     eFormatFloat,
1243     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1244      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1245     nullptr,
1246     nullptr,
1247     nullptr,
1248     0},
1249
1250    {"d0",
1251     nullptr,
1252     8,
1253     0,
1254     eEncodingIEEE754,
1255     eFormatFloat,
1256     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1257      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1258     nullptr,
1259     nullptr,
1260     nullptr,
1261     0},
1262    {"d1",
1263     nullptr,
1264     8,
1265     0,
1266     eEncodingIEEE754,
1267     eFormatFloat,
1268     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1269      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1270     nullptr,
1271     nullptr,
1272     nullptr,
1273     0},
1274    {"d2",
1275     nullptr,
1276     8,
1277     0,
1278     eEncodingIEEE754,
1279     eFormatFloat,
1280     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1281      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1282     nullptr,
1283     nullptr,
1284     nullptr,
1285     0},
1286    {"d3",
1287     nullptr,
1288     8,
1289     0,
1290     eEncodingIEEE754,
1291     eFormatFloat,
1292     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1293      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1294     nullptr,
1295     nullptr,
1296     nullptr,
1297     0},
1298    {"d4",
1299     nullptr,
1300     8,
1301     0,
1302     eEncodingIEEE754,
1303     eFormatFloat,
1304     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1305      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1306     nullptr,
1307     nullptr,
1308     nullptr,
1309     0},
1310    {"d5",
1311     nullptr,
1312     8,
1313     0,
1314     eEncodingIEEE754,
1315     eFormatFloat,
1316     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1317      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1318     nullptr,
1319     nullptr,
1320     nullptr,
1321     0},
1322    {"d6",
1323     nullptr,
1324     8,
1325     0,
1326     eEncodingIEEE754,
1327     eFormatFloat,
1328     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1329      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1330     nullptr,
1331     nullptr,
1332     nullptr,
1333     0},
1334    {"d7",
1335     nullptr,
1336     8,
1337     0,
1338     eEncodingIEEE754,
1339     eFormatFloat,
1340     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1341      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1342     nullptr,
1343     nullptr,
1344     nullptr,
1345     0},
1346    {"d8",
1347     nullptr,
1348     8,
1349     0,
1350     eEncodingIEEE754,
1351     eFormatFloat,
1352     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1353      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1354     nullptr,
1355     nullptr,
1356     nullptr,
1357     0},
1358    {"d9",
1359     nullptr,
1360     8,
1361     0,
1362     eEncodingIEEE754,
1363     eFormatFloat,
1364     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1365      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1366     nullptr,
1367     nullptr,
1368     nullptr,
1369     0},
1370    {"d10",
1371     nullptr,
1372     8,
1373     0,
1374     eEncodingIEEE754,
1375     eFormatFloat,
1376     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1377      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1378     nullptr,
1379     nullptr,
1380     nullptr,
1381     0},
1382    {"d11",
1383     nullptr,
1384     8,
1385     0,
1386     eEncodingIEEE754,
1387     eFormatFloat,
1388     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1389      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1390     nullptr,
1391     nullptr,
1392     nullptr,
1393     0},
1394    {"d12",
1395     nullptr,
1396     8,
1397     0,
1398     eEncodingIEEE754,
1399     eFormatFloat,
1400     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1401      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1402     nullptr,
1403     nullptr,
1404     nullptr,
1405     0},
1406    {"d13",
1407     nullptr,
1408     8,
1409     0,
1410     eEncodingIEEE754,
1411     eFormatFloat,
1412     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1413      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1414     nullptr,
1415     nullptr,
1416     nullptr,
1417     0},
1418    {"d14",
1419     nullptr,
1420     8,
1421     0,
1422     eEncodingIEEE754,
1423     eFormatFloat,
1424     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1425      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1426     nullptr,
1427     nullptr,
1428     nullptr,
1429     0},
1430    {"d15",
1431     nullptr,
1432     8,
1433     0,
1434     eEncodingIEEE754,
1435     eFormatFloat,
1436     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1437      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1438     nullptr,
1439     nullptr,
1440     nullptr,
1441     0},
1442    {"d16",
1443     nullptr,
1444     8,
1445     0,
1446     eEncodingIEEE754,
1447     eFormatFloat,
1448     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1449      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1450     nullptr,
1451     nullptr,
1452     nullptr,
1453     0},
1454    {"d17",
1455     nullptr,
1456     8,
1457     0,
1458     eEncodingIEEE754,
1459     eFormatFloat,
1460     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1461      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1462     nullptr,
1463     nullptr,
1464     nullptr,
1465     0},
1466    {"d18",
1467     nullptr,
1468     8,
1469     0,
1470     eEncodingIEEE754,
1471     eFormatFloat,
1472     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1473      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1474     nullptr,
1475     nullptr,
1476     nullptr,
1477     0},
1478    {"d19",
1479     nullptr,
1480     8,
1481     0,
1482     eEncodingIEEE754,
1483     eFormatFloat,
1484     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1485      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1486     nullptr,
1487     nullptr,
1488     nullptr,
1489     0},
1490    {"d20",
1491     nullptr,
1492     8,
1493     0,
1494     eEncodingIEEE754,
1495     eFormatFloat,
1496     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1497      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1498     nullptr,
1499     nullptr,
1500     nullptr,
1501     0},
1502    {"d21",
1503     nullptr,
1504     8,
1505     0,
1506     eEncodingIEEE754,
1507     eFormatFloat,
1508     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1509      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1510     nullptr,
1511     nullptr,
1512     nullptr,
1513     0},
1514    {"d22",
1515     nullptr,
1516     8,
1517     0,
1518     eEncodingIEEE754,
1519     eFormatFloat,
1520     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1521      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1522     nullptr,
1523     nullptr,
1524     nullptr,
1525     0},
1526    {"d23",
1527     nullptr,
1528     8,
1529     0,
1530     eEncodingIEEE754,
1531     eFormatFloat,
1532     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1533      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1534     nullptr,
1535     nullptr,
1536     nullptr,
1537     0},
1538    {"d24",
1539     nullptr,
1540     8,
1541     0,
1542     eEncodingIEEE754,
1543     eFormatFloat,
1544     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1545      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1546     nullptr,
1547     nullptr,
1548     nullptr,
1549     0},
1550    {"d25",
1551     nullptr,
1552     8,
1553     0,
1554     eEncodingIEEE754,
1555     eFormatFloat,
1556     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1557      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1558     nullptr,
1559     nullptr,
1560     nullptr,
1561     0},
1562    {"d26",
1563     nullptr,
1564     8,
1565     0,
1566     eEncodingIEEE754,
1567     eFormatFloat,
1568     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1569      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1570     nullptr,
1571     nullptr,
1572     nullptr,
1573     0},
1574    {"d27",
1575     nullptr,
1576     8,
1577     0,
1578     eEncodingIEEE754,
1579     eFormatFloat,
1580     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1581      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1582     nullptr,
1583     nullptr,
1584     nullptr,
1585     0},
1586    {"d28",
1587     nullptr,
1588     8,
1589     0,
1590     eEncodingIEEE754,
1591     eFormatFloat,
1592     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1593      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1594     nullptr,
1595     nullptr,
1596     nullptr,
1597     0},
1598    {"d29",
1599     nullptr,
1600     8,
1601     0,
1602     eEncodingIEEE754,
1603     eFormatFloat,
1604     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1605      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1606     nullptr,
1607     nullptr,
1608     nullptr,
1609     0},
1610    {"d30",
1611     nullptr,
1612     8,
1613     0,
1614     eEncodingIEEE754,
1615     eFormatFloat,
1616     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1617      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1618     nullptr,
1619     nullptr,
1620     nullptr,
1621     0},
1622    {"d31",
1623     nullptr,
1624     8,
1625     0,
1626     eEncodingIEEE754,
1627     eFormatFloat,
1628     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1629      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1630     nullptr,
1631     nullptr,
1632     nullptr,
1633     0}};
1634
1635static const uint32_t k_num_register_infos =
1636    llvm::array_lengthof(g_register_infos);
1637static bool g_register_info_names_constified = false;
1638
1639const lldb_private::RegisterInfo *
1640ABIMacOSX_arm64::GetRegisterInfoArray(uint32_t &count) {
1641  // Make the C-string names and alt_names for the register infos into const
1642  // C-string values by having the ConstString unique the names in the global
1643  // constant C-string pool.
1644  if (!g_register_info_names_constified) {
1645    g_register_info_names_constified = true;
1646    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
1647      if (g_register_infos[i].name)
1648        g_register_infos[i].name =
1649            ConstString(g_register_infos[i].name).GetCString();
1650      if (g_register_infos[i].alt_name)
1651        g_register_infos[i].alt_name =
1652            ConstString(g_register_infos[i].alt_name).GetCString();
1653    }
1654  }
1655  count = k_num_register_infos;
1656  return g_register_infos;
1657}
1658
1659size_t ABIMacOSX_arm64::GetRedZoneSize() const { return 128; }
1660
1661//------------------------------------------------------------------
1662// Static Functions
1663//------------------------------------------------------------------
1664
1665ABISP
1666ABIMacOSX_arm64::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1667  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1668  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1669
1670  if (vendor_type == llvm::Triple::Apple) {
1671    if (arch_type == llvm::Triple::aarch64) {
1672      return ABISP(new ABIMacOSX_arm64(process_sp));
1673    }
1674  }
1675
1676  return ABISP();
1677}
1678
1679bool ABIMacOSX_arm64::PrepareTrivialCall(
1680    Thread &thread, lldb::addr_t sp, lldb::addr_t func_addr,
1681    lldb::addr_t return_addr, llvm::ArrayRef<lldb::addr_t> args) const {
1682  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1683  if (!reg_ctx)
1684    return false;
1685
1686  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1687
1688  if (log) {
1689    StreamString s;
1690    s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
1691             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
1692             ", return_addr = 0x%" PRIx64,
1693             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
1694             (uint64_t)return_addr);
1695
1696    for (size_t i = 0; i < args.size(); ++i)
1697      s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
1698    s.PutCString(")");
1699    log->PutString(s.GetString());
1700  }
1701
1702  const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1703      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1704  const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1705      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
1706  const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1707      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
1708
1709  // x0 - x7 contain first 8 simple args
1710  if (args.size() > 8) // TODO handle more than 6 arguments
1711    return false;
1712
1713  for (size_t i = 0; i < args.size(); ++i) {
1714    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1715        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
1716    if (log)
1717      log->Printf("About to write arg%d (0x%" PRIx64 ") into %s",
1718                  static_cast<int>(i + 1), args[i], reg_info->name);
1719    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
1720      return false;
1721  }
1722
1723  // Set "lr" to the return address
1724  if (!reg_ctx->WriteRegisterFromUnsigned(
1725          reg_ctx->GetRegisterInfoAtIndex(ra_reg_num), return_addr))
1726    return false;
1727
1728  // Set "sp" to the requested value
1729  if (!reg_ctx->WriteRegisterFromUnsigned(
1730          reg_ctx->GetRegisterInfoAtIndex(sp_reg_num), sp))
1731    return false;
1732
1733  // Set "pc" to the address requested
1734  if (!reg_ctx->WriteRegisterFromUnsigned(
1735          reg_ctx->GetRegisterInfoAtIndex(pc_reg_num), func_addr))
1736    return false;
1737
1738  return true;
1739}
1740
1741bool ABIMacOSX_arm64::GetArgumentValues(Thread &thread,
1742                                        ValueList &values) const {
1743  uint32_t num_values = values.GetSize();
1744
1745  ExecutionContext exe_ctx(thread.shared_from_this());
1746
1747  // Extract the register context so we can read arguments from registers
1748
1749  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1750
1751  if (!reg_ctx)
1752    return false;
1753
1754  addr_t sp = 0;
1755
1756  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1757    // We currently only support extracting values with Clang QualTypes. Do we
1758    // care about others?
1759    Value *value = values.GetValueAtIndex(value_idx);
1760
1761    if (!value)
1762      return false;
1763
1764    CompilerType value_type = value->GetCompilerType();
1765    llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
1766    if (!bit_size)
1767      return false;
1768
1769    bool is_signed = false;
1770    size_t bit_width = 0;
1771    if (value_type.IsIntegerOrEnumerationType(is_signed)) {
1772      bit_width = *bit_size;
1773    } else if (value_type.IsPointerOrReferenceType()) {
1774      bit_width = *bit_size;
1775    } else {
1776      // We only handle integer, pointer and reference types currently...
1777      return false;
1778    }
1779
1780    if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1781      if (value_idx < 8) {
1782        // Arguments 1-6 are in x0-x5...
1783        const RegisterInfo *reg_info = nullptr;
1784        // Search by generic ID first, then fall back to by name
1785        uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1786            eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1787        if (arg_reg_num != LLDB_INVALID_REGNUM) {
1788          reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1789        } else {
1790          switch (value_idx) {
1791          case 0:
1792            reg_info = reg_ctx->GetRegisterInfoByName("x0");
1793            break;
1794          case 1:
1795            reg_info = reg_ctx->GetRegisterInfoByName("x1");
1796            break;
1797          case 2:
1798            reg_info = reg_ctx->GetRegisterInfoByName("x2");
1799            break;
1800          case 3:
1801            reg_info = reg_ctx->GetRegisterInfoByName("x3");
1802            break;
1803          case 4:
1804            reg_info = reg_ctx->GetRegisterInfoByName("x4");
1805            break;
1806          case 5:
1807            reg_info = reg_ctx->GetRegisterInfoByName("x5");
1808            break;
1809          case 6:
1810            reg_info = reg_ctx->GetRegisterInfoByName("x6");
1811            break;
1812          case 7:
1813            reg_info = reg_ctx->GetRegisterInfoByName("x7");
1814            break;
1815          }
1816        }
1817
1818        if (reg_info) {
1819          RegisterValue reg_value;
1820
1821          if (reg_ctx->ReadRegister(reg_info, reg_value)) {
1822            if (is_signed)
1823              reg_value.SignExtend(bit_width);
1824            if (!reg_value.GetScalarValue(value->GetScalar()))
1825              return false;
1826            continue;
1827          }
1828        }
1829        return false;
1830      } else {
1831        if (sp == 0) {
1832          // Read the stack pointer if we already haven't read it
1833          sp = reg_ctx->GetSP(0);
1834          if (sp == 0)
1835            return false;
1836        }
1837
1838        // Arguments 5 on up are on the stack
1839        const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1840        Status error;
1841        if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1842                sp, arg_byte_size, is_signed, value->GetScalar(), error))
1843          return false;
1844
1845        sp += arg_byte_size;
1846        // Align up to the next 8 byte boundary if needed
1847        if (sp % 8) {
1848          sp >>= 3;
1849          sp += 1;
1850          sp <<= 3;
1851        }
1852      }
1853    }
1854  }
1855  return true;
1856}
1857
1858Status
1859ABIMacOSX_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1860                                      lldb::ValueObjectSP &new_value_sp) {
1861  Status error;
1862  if (!new_value_sp) {
1863    error.SetErrorString("Empty value object for return value.");
1864    return error;
1865  }
1866
1867  CompilerType return_value_type = new_value_sp->GetCompilerType();
1868  if (!return_value_type) {
1869    error.SetErrorString("Null clang type for return value.");
1870    return error;
1871  }
1872
1873  Thread *thread = frame_sp->GetThread().get();
1874
1875  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1876
1877  if (reg_ctx) {
1878    DataExtractor data;
1879    Status data_error;
1880    const uint64_t byte_size = new_value_sp->GetData(data, data_error);
1881    if (data_error.Fail()) {
1882      error.SetErrorStringWithFormat(
1883          "Couldn't convert return value to raw data: %s",
1884          data_error.AsCString());
1885      return error;
1886    }
1887
1888    const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
1889    if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
1890      if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
1891        // Extract the register context so we can read arguments from registers
1892        lldb::offset_t offset = 0;
1893        if (byte_size <= 16) {
1894          const RegisterInfo *x0_info = reg_ctx->GetRegisterInfoByName("x0", 0);
1895          if (byte_size <= 8) {
1896            uint64_t raw_value = data.GetMaxU64(&offset, byte_size);
1897
1898            if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value))
1899              error.SetErrorString("failed to write register x0");
1900          } else {
1901            uint64_t raw_value = data.GetMaxU64(&offset, 8);
1902
1903            if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) {
1904              const RegisterInfo *x1_info =
1905                  reg_ctx->GetRegisterInfoByName("x1", 0);
1906              raw_value = data.GetMaxU64(&offset, byte_size - offset);
1907
1908              if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value))
1909                error.SetErrorString("failed to write register x1");
1910            }
1911          }
1912        } else {
1913          error.SetErrorString("We don't support returning longer than 128 bit "
1914                               "integer values at present.");
1915        }
1916      } else if (type_flags & eTypeIsFloat) {
1917        if (type_flags & eTypeIsComplex) {
1918          // Don't handle complex yet.
1919          error.SetErrorString(
1920              "returning complex float values are not supported");
1921        } else {
1922          const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
1923
1924          if (v0_info) {
1925            if (byte_size <= 16) {
1926              if (byte_size <= RegisterValue::GetMaxByteSize()) {
1927                RegisterValue reg_value;
1928                error = reg_value.SetValueFromData(v0_info, data, 0, true);
1929                if (error.Success()) {
1930                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
1931                    error.SetErrorString("failed to write register v0");
1932                }
1933              } else {
1934                error.SetErrorStringWithFormat(
1935                    "returning float values with a byte size of %" PRIu64
1936                    " are not supported",
1937                    byte_size);
1938              }
1939            } else {
1940              error.SetErrorString("returning float values longer than 128 "
1941                                   "bits are not supported");
1942            }
1943          } else {
1944            error.SetErrorString("v0 register is not available on this target");
1945          }
1946        }
1947      }
1948    } else if (type_flags & eTypeIsVector) {
1949      if (byte_size > 0) {
1950        const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
1951
1952        if (v0_info) {
1953          if (byte_size <= v0_info->byte_size) {
1954            RegisterValue reg_value;
1955            error = reg_value.SetValueFromData(v0_info, data, 0, true);
1956            if (error.Success()) {
1957              if (!reg_ctx->WriteRegister(v0_info, reg_value))
1958                error.SetErrorString("failed to write register v0");
1959            }
1960          }
1961        }
1962      }
1963    }
1964  } else {
1965    error.SetErrorString("no registers are available");
1966  }
1967
1968  return error;
1969}
1970
1971bool ABIMacOSX_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
1972  unwind_plan.Clear();
1973  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1974
1975  uint32_t lr_reg_num = arm64_dwarf::lr;
1976  uint32_t sp_reg_num = arm64_dwarf::sp;
1977  uint32_t pc_reg_num = arm64_dwarf::pc;
1978
1979  UnwindPlan::RowSP row(new UnwindPlan::Row);
1980
1981  // Our previous Call Frame Address is the stack pointer
1982  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1983
1984  // Our previous PC is in the LR
1985  row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
1986
1987  unwind_plan.AppendRow(row);
1988
1989  // All other registers are the same.
1990
1991  unwind_plan.SetSourceName("arm64 at-func-entry default");
1992  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1993
1994  return true;
1995}
1996
1997bool ABIMacOSX_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
1998  unwind_plan.Clear();
1999  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
2000
2001  uint32_t fp_reg_num = arm64_dwarf::fp;
2002  uint32_t pc_reg_num = arm64_dwarf::pc;
2003
2004  UnwindPlan::RowSP row(new UnwindPlan::Row);
2005  const int32_t ptr_size = 8;
2006
2007  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
2008  row->SetOffset(0);
2009
2010  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
2011  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
2012
2013  unwind_plan.AppendRow(row);
2014  unwind_plan.SetSourceName("arm64-apple-darwin default unwind plan");
2015  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
2016  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
2017  return true;
2018}
2019
2020// AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
2021// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
2022// volatile (and specifically only the lower 8 bytes of these regs), the rest
2023// of the fp/SIMD registers are volatile.
2024
2025// We treat x29 as callee preserved also, else the unwinder won't try to
2026// retrieve fp saves.
2027
2028bool ABIMacOSX_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) {
2029  if (reg_info) {
2030    const char *name = reg_info->name;
2031
2032    // Sometimes we'll be called with the "alternate" name for these registers;
2033    // recognize them as non-volatile.
2034
2035    if (name[0] == 'p' && name[1] == 'c') // pc
2036      return false;
2037    if (name[0] == 'f' && name[1] == 'p') // fp
2038      return false;
2039    if (name[0] == 's' && name[1] == 'p') // sp
2040      return false;
2041    if (name[0] == 'l' && name[1] == 'r') // lr
2042      return false;
2043
2044    if (name[0] == 'x') {
2045      // Volatile registers: x0-x18, x30 (lr)
2046      // Return false for the non-volatile gpr regs, true for everything else
2047      switch (name[1]) {
2048      case '1':
2049        switch (name[2]) {
2050        case '9':
2051          return false; // x19 is non-volatile
2052        default:
2053          return true;
2054        }
2055        break;
2056      case '2':
2057        switch (name[2]) {
2058        case '0':
2059        case '1':
2060        case '2':
2061        case '3':
2062        case '4':
2063        case '5':
2064        case '6':
2065        case '7':
2066        case '8':
2067          return false; // x20 - 28 are non-volatile
2068        case '9':
2069          return false; // x29 aka fp treat as non-volatile on Darwin
2070        default:
2071          return true;
2072        }
2073      case '3': // x30 aka lr treat as non-volatile
2074        if (name[2] == '0')
2075          return false;
2076        break;
2077      default:
2078        return true;
2079      }
2080    } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
2081      // Volatile registers: v0-7, v16-v31
2082      // Return false for non-volatile fp/SIMD regs, true for everything else
2083      switch (name[1]) {
2084      case '8':
2085      case '9':
2086        return false; // v8-v9 are non-volatile
2087      case '1':
2088        switch (name[2]) {
2089        case '0':
2090        case '1':
2091        case '2':
2092        case '3':
2093        case '4':
2094        case '5':
2095          return false; // v10-v15 are non-volatile
2096        default:
2097          return true;
2098        }
2099      default:
2100        return true;
2101      }
2102    }
2103  }
2104  return true;
2105}
2106
2107static bool LoadValueFromConsecutiveGPRRegisters(
2108    ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
2109    const CompilerType &value_type,
2110    bool is_return_value, // false => parameter, true => return value
2111    uint32_t &NGRN,       // NGRN (see ABI documentation)
2112    uint32_t &NSRN,       // NSRN (see ABI documentation)
2113    DataExtractor &data) {
2114  llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
2115  if (!byte_size || *byte_size == 0)
2116    return false;
2117
2118  std::unique_ptr<DataBufferHeap> heap_data_ap(
2119      new DataBufferHeap(*byte_size, 0));
2120  const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
2121  Status error;
2122
2123  CompilerType base_type;
2124  const uint32_t homogeneous_count =
2125      value_type.IsHomogeneousAggregate(&base_type);
2126  if (homogeneous_count > 0 && homogeneous_count <= 8) {
2127    // Make sure we have enough registers
2128    if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
2129      if (!base_type)
2130        return false;
2131      llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
2132      if (!base_byte_size)
2133        return false;
2134      uint32_t data_offset = 0;
2135
2136      for (uint32_t i = 0; i < homogeneous_count; ++i) {
2137        char v_name[8];
2138        ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
2139        const RegisterInfo *reg_info =
2140            reg_ctx->GetRegisterInfoByName(v_name, 0);
2141        if (reg_info == nullptr)
2142          return false;
2143
2144        if (*base_byte_size > reg_info->byte_size)
2145          return false;
2146
2147        RegisterValue reg_value;
2148
2149        if (!reg_ctx->ReadRegister(reg_info, reg_value))
2150          return false;
2151
2152        // Make sure we have enough room in "heap_data_ap"
2153        if ((data_offset + *base_byte_size) <= heap_data_ap->GetByteSize()) {
2154          const size_t bytes_copied = reg_value.GetAsMemoryData(
2155              reg_info, heap_data_ap->GetBytes() + data_offset, *base_byte_size,
2156              byte_order, error);
2157          if (bytes_copied != *base_byte_size)
2158            return false;
2159          data_offset += bytes_copied;
2160          ++NSRN;
2161        } else
2162          return false;
2163      }
2164      data.SetByteOrder(byte_order);
2165      data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
2166      data.SetData(DataBufferSP(heap_data_ap.release()));
2167      return true;
2168    }
2169  }
2170
2171  const size_t max_reg_byte_size = 16;
2172  if (*byte_size <= max_reg_byte_size) {
2173    size_t bytes_left = *byte_size;
2174    uint32_t data_offset = 0;
2175    while (data_offset < *byte_size) {
2176      if (NGRN >= 8)
2177        return false;
2178
2179      uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
2180          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
2181      if (reg_num == LLDB_INVALID_REGNUM)
2182        return false;
2183
2184      const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
2185      if (reg_info == nullptr)
2186        return false;
2187
2188      RegisterValue reg_value;
2189
2190      if (!reg_ctx->ReadRegister(reg_info, reg_value))
2191        return false;
2192
2193      const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
2194      const size_t bytes_copied = reg_value.GetAsMemoryData(
2195          reg_info, heap_data_ap->GetBytes() + data_offset, curr_byte_size,
2196          byte_order, error);
2197      if (bytes_copied == 0)
2198        return false;
2199      if (bytes_copied >= bytes_left)
2200        break;
2201      data_offset += bytes_copied;
2202      bytes_left -= bytes_copied;
2203      ++NGRN;
2204    }
2205  } else {
2206    const RegisterInfo *reg_info = nullptr;
2207    if (is_return_value) {
2208      // We are assuming we are decoding this immediately after returning from
2209      // a function call and that the address of the structure is in x8
2210      reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
2211    } else {
2212      // We are assuming we are stopped at the first instruction in a function
2213      // and that the ABI is being respected so all parameters appear where
2214      // they should be (functions with no external linkage can legally violate
2215      // the ABI).
2216      if (NGRN >= 8)
2217        return false;
2218
2219      uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
2220          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
2221      if (reg_num == LLDB_INVALID_REGNUM)
2222        return false;
2223      reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
2224      if (reg_info == nullptr)
2225        return false;
2226      ++NGRN;
2227    }
2228
2229    if (reg_info == nullptr)
2230      return false;
2231
2232    const lldb::addr_t value_addr =
2233        reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS);
2234
2235    if (value_addr == LLDB_INVALID_ADDRESS)
2236      return false;
2237
2238    if (exe_ctx.GetProcessRef().ReadMemory(
2239            value_addr, heap_data_ap->GetBytes(), heap_data_ap->GetByteSize(),
2240            error) != heap_data_ap->GetByteSize()) {
2241      return false;
2242    }
2243  }
2244
2245  data.SetByteOrder(byte_order);
2246  data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
2247  data.SetData(DataBufferSP(heap_data_ap.release()));
2248  return true;
2249}
2250
2251ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl(
2252    Thread &thread, CompilerType &return_compiler_type) const {
2253  ValueObjectSP return_valobj_sp;
2254  Value value;
2255
2256  ExecutionContext exe_ctx(thread.shared_from_this());
2257  if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
2258    return return_valobj_sp;
2259
2260  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
2261  value.SetCompilerType(return_compiler_type);
2262
2263  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
2264  if (!reg_ctx)
2265    return return_valobj_sp;
2266
2267  llvm::Optional<uint64_t> byte_size =
2268      return_compiler_type.GetByteSize(nullptr);
2269  if (!byte_size)
2270    return return_valobj_sp;
2271
2272  const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
2273  if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
2274    value.SetValueType(Value::eValueTypeScalar);
2275
2276    bool success = false;
2277    if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
2278      // Extract the register context so we can read arguments from registers
2279      if (*byte_size <= 8) {
2280        const RegisterInfo *x0_reg_info =
2281            reg_ctx->GetRegisterInfoByName("x0", 0);
2282        if (x0_reg_info) {
2283          uint64_t raw_value =
2284              thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
2285                                                                  0);
2286          const bool is_signed = (type_flags & eTypeIsSigned) != 0;
2287          switch (*byte_size) {
2288          default:
2289            break;
2290          case 16: // uint128_t
2291            // In register x0 and x1
2292            {
2293              const RegisterInfo *x1_reg_info =
2294                  reg_ctx->GetRegisterInfoByName("x1", 0);
2295
2296              if (x1_reg_info) {
2297                if (*byte_size <=
2298                    x0_reg_info->byte_size + x1_reg_info->byte_size) {
2299                  std::unique_ptr<DataBufferHeap> heap_data_ap(
2300                      new DataBufferHeap(*byte_size, 0));
2301                  const ByteOrder byte_order =
2302                      exe_ctx.GetProcessRef().GetByteOrder();
2303                  RegisterValue x0_reg_value;
2304                  RegisterValue x1_reg_value;
2305                  if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
2306                      reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
2307                    Status error;
2308                    if (x0_reg_value.GetAsMemoryData(
2309                            x0_reg_info, heap_data_ap->GetBytes() + 0, 8,
2310                            byte_order, error) &&
2311                        x1_reg_value.GetAsMemoryData(
2312                            x1_reg_info, heap_data_ap->GetBytes() + 8, 8,
2313                            byte_order, error)) {
2314                      DataExtractor data(
2315                          DataBufferSP(heap_data_ap.release()), byte_order,
2316                          exe_ctx.GetProcessRef().GetAddressByteSize());
2317
2318                      return_valobj_sp = ValueObjectConstResult::Create(
2319                          &thread, return_compiler_type, ConstString(""), data);
2320                      return return_valobj_sp;
2321                    }
2322                  }
2323                }
2324              }
2325            }
2326            break;
2327          case sizeof(uint64_t):
2328            if (is_signed)
2329              value.GetScalar() = (int64_t)(raw_value);
2330            else
2331              value.GetScalar() = (uint64_t)(raw_value);
2332            success = true;
2333            break;
2334
2335          case sizeof(uint32_t):
2336            if (is_signed)
2337              value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
2338            else
2339              value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
2340            success = true;
2341            break;
2342
2343          case sizeof(uint16_t):
2344            if (is_signed)
2345              value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
2346            else
2347              value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
2348            success = true;
2349            break;
2350
2351          case sizeof(uint8_t):
2352            if (is_signed)
2353              value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
2354            else
2355              value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
2356            success = true;
2357            break;
2358          }
2359        }
2360      }
2361    } else if (type_flags & eTypeIsFloat) {
2362      if (type_flags & eTypeIsComplex) {
2363        // Don't handle complex yet.
2364      } else {
2365        if (*byte_size <= sizeof(long double)) {
2366          const RegisterInfo *v0_reg_info =
2367              reg_ctx->GetRegisterInfoByName("v0", 0);
2368          RegisterValue v0_value;
2369          if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
2370            DataExtractor data;
2371            if (v0_value.GetData(data)) {
2372              lldb::offset_t offset = 0;
2373              if (*byte_size == sizeof(float)) {
2374                value.GetScalar() = data.GetFloat(&offset);
2375                success = true;
2376              } else if (*byte_size == sizeof(double)) {
2377                value.GetScalar() = data.GetDouble(&offset);
2378                success = true;
2379              } else if (*byte_size == sizeof(long double)) {
2380                value.GetScalar() = data.GetLongDouble(&offset);
2381                success = true;
2382              }
2383            }
2384          }
2385        }
2386      }
2387    }
2388
2389    if (success)
2390      return_valobj_sp = ValueObjectConstResult::Create(
2391          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
2392  } else if (type_flags & eTypeIsVector) {
2393    if (*byte_size > 0) {
2394
2395      const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
2396
2397      if (v0_info) {
2398        if (*byte_size <= v0_info->byte_size) {
2399          std::unique_ptr<DataBufferHeap> heap_data_ap(
2400              new DataBufferHeap(*byte_size, 0));
2401          const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
2402          RegisterValue reg_value;
2403          if (reg_ctx->ReadRegister(v0_info, reg_value)) {
2404            Status error;
2405            if (reg_value.GetAsMemoryData(v0_info, heap_data_ap->GetBytes(),
2406                                          heap_data_ap->GetByteSize(),
2407                                          byte_order, error)) {
2408              DataExtractor data(DataBufferSP(heap_data_ap.release()),
2409                                 byte_order,
2410                                 exe_ctx.GetProcessRef().GetAddressByteSize());
2411              return_valobj_sp = ValueObjectConstResult::Create(
2412                  &thread, return_compiler_type, ConstString(""), data);
2413            }
2414          }
2415        }
2416      }
2417    }
2418  } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass) {
2419    DataExtractor data;
2420
2421    uint32_t NGRN = 0; // Search ABI docs for NGRN
2422    uint32_t NSRN = 0; // Search ABI docs for NSRN
2423    const bool is_return_value = true;
2424    if (LoadValueFromConsecutiveGPRRegisters(
2425            exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
2426            data)) {
2427      return_valobj_sp = ValueObjectConstResult::Create(
2428          &thread, return_compiler_type, ConstString(""), data);
2429    }
2430  }
2431  return return_valobj_sp;
2432}
2433
2434void ABIMacOSX_arm64::Initialize() {
2435  PluginManager::RegisterPlugin(GetPluginNameStatic(), pluginDesc,
2436                                CreateInstance);
2437}
2438
2439void ABIMacOSX_arm64::Terminate() {
2440  PluginManager::UnregisterPlugin(CreateInstance);
2441}
2442
2443//------------------------------------------------------------------
2444// PluginInterface protocol
2445//------------------------------------------------------------------
2446
2447ConstString ABIMacOSX_arm64::GetPluginNameStatic() {
2448  static ConstString g_plugin_name("ABIMacOSX_arm64");
2449  return g_plugin_name;
2450}
2451
2452uint32_t ABIMacOSX_arm64::GetPluginVersion() { return 1; }
2453