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