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