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