CoCalc -- ABIMacOSX

GitHub Repository: freebsd/freebsd-src
Path: blob/main/contrib/llvm-project/lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp
³⁹⁶⁴⁸ views
1
//===-- ABIMacOSX_arm.cpp -------------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "ABIMacOSX_arm.h"
10

11
#include <optional>
12
#include <vector>
13

14
#include "llvm/ADT/STLExtras.h"
15
#include "llvm/TargetParser/Triple.h"
16

17
#include "lldb/Core/Module.h"
18
#include "lldb/Core/PluginManager.h"
19
#include "lldb/Core/Value.h"
20
#include "lldb/Core/ValueObjectConstResult.h"
21
#include "lldb/Symbol/UnwindPlan.h"
22
#include "lldb/Target/Process.h"
23
#include "lldb/Target/RegisterContext.h"
24
#include "lldb/Target/Target.h"
25
#include "lldb/Target/Thread.h"
26
#include "lldb/Utility/ConstString.h"
27
#include "lldb/Utility/RegisterValue.h"
28
#include "lldb/Utility/Scalar.h"
29
#include "lldb/Utility/Status.h"
30

31
#include "Plugins/Process/Utility/ARMDefines.h"
32
#include "Utility/ARM_DWARF_Registers.h"
33
#include "Utility/ARM_ehframe_Registers.h"
34

35
using namespace lldb;
36
using namespace lldb_private;
37

38
static const RegisterInfo g_register_infos[] = {
39
    //  NAME       ALT       SZ OFF ENCODING         FORMAT          EH_FRAME
40
    //  DWARF               GENERIC                     PROCESS PLUGIN
41
    //  LLDB NATIVE
42
    //  ========== =======   == === =============    ============
43
    //  ======================= =================== ===========================
44
    //  ======================= ======================
45
    {"r0",
46
     nullptr,
47
     4,
48
     0,
49
     eEncodingUint,
50
     eFormatHex,
51
     {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
52
      LLDB_INVALID_REGNUM},
53
     nullptr,
54
     nullptr,
55
     nullptr,
56
    },
57
    {"r1",
58
     nullptr,
59
     4,
60
     0,
61
     eEncodingUint,
62
     eFormatHex,
63
     {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
64
      LLDB_INVALID_REGNUM},
65
     nullptr,
66
     nullptr,
67
     nullptr,
68
    },
69
    {"r2",
70
     nullptr,
71
     4,
72
     0,
73
     eEncodingUint,
74
     eFormatHex,
75
     {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
76
      LLDB_INVALID_REGNUM},
77
     nullptr,
78
     nullptr,
79
     nullptr,
80
    },
81
    {"r3",
82
     nullptr,
83
     4,
84
     0,
85
     eEncodingUint,
86
     eFormatHex,
87
     {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
88
      LLDB_INVALID_REGNUM},
89
     nullptr,
90
     nullptr,
91
     nullptr,
92
    },
93
    {"r4",
94
     nullptr,
95
     4,
96
     0,
97
     eEncodingUint,
98
     eFormatHex,
99
     {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
100
      LLDB_INVALID_REGNUM},
101
     nullptr,
102
     nullptr,
103
     nullptr,
104
    },
105
    {"r5",
106
     nullptr,
107
     4,
108
     0,
109
     eEncodingUint,
110
     eFormatHex,
111
     {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
112
      LLDB_INVALID_REGNUM},
113
     nullptr,
114
     nullptr,
115
     nullptr,
116
    },
117
    {"r6",
118
     nullptr,
119
     4,
120
     0,
121
     eEncodingUint,
122
     eFormatHex,
123
     {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
124
      LLDB_INVALID_REGNUM},
125
     nullptr,
126
     nullptr,
127
     nullptr,
128
    },
129
    {"r7",
130
     nullptr,
131
     4,
132
     0,
133
     eEncodingUint,
134
     eFormatHex,
135
     {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
136
      LLDB_INVALID_REGNUM},
137
     nullptr,
138
     nullptr,
139
     nullptr,
140
    },
141
    {"r8",
142
     nullptr,
143
     4,
144
     0,
145
     eEncodingUint,
146
     eFormatHex,
147
     {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
148
      LLDB_INVALID_REGNUM},
149
     nullptr,
150
     nullptr,
151
     nullptr,
152
    },
153
    {"r9",
154
     nullptr,
155
     4,
156
     0,
157
     eEncodingUint,
158
     eFormatHex,
159
     {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
160
      LLDB_INVALID_REGNUM},
161
     nullptr,
162
     nullptr,
163
     nullptr,
164
    },
165
    {"r10",
166
     nullptr,
167
     4,
168
     0,
169
     eEncodingUint,
170
     eFormatHex,
171
     {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
172
      LLDB_INVALID_REGNUM},
173
     nullptr,
174
     nullptr,
175
     nullptr,
176
    },
177
    {"r11",
178
     nullptr,
179
     4,
180
     0,
181
     eEncodingUint,
182
     eFormatHex,
183
     {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
184
      LLDB_INVALID_REGNUM},
185
     nullptr,
186
     nullptr,
187
     nullptr,
188
    },
189
    {"r12",
190
     nullptr,
191
     4,
192
     0,
193
     eEncodingUint,
194
     eFormatHex,
195
     {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
196
      LLDB_INVALID_REGNUM},
197
     nullptr,
198
     nullptr,
199
     nullptr,
200
    },
201
    {"sp",
202
     "r13",
203
     4,
204
     0,
205
     eEncodingUint,
206
     eFormatHex,
207
     {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
208
      LLDB_INVALID_REGNUM},
209
     nullptr,
210
     nullptr,
211
     nullptr,
212
    },
213
    {"lr",
214
     "r14",
215
     4,
216
     0,
217
     eEncodingUint,
218
     eFormatHex,
219
     {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
220
      LLDB_INVALID_REGNUM},
221
     nullptr,
222
     nullptr,
223
     nullptr,
224
    },
225
    {"pc",
226
     "r15",
227
     4,
228
     0,
229
     eEncodingUint,
230
     eFormatHex,
231
     {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
232
      LLDB_INVALID_REGNUM},
233
     nullptr,
234
     nullptr,
235
     nullptr,
236
    },
237
    {"cpsr",
238
     "psr",
239
     4,
240
     0,
241
     eEncodingUint,
242
     eFormatHex,
243
     {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
244
      LLDB_INVALID_REGNUM},
245
     nullptr,
246
     nullptr,
247
     nullptr,
248
    },
249
    {"s0",
250
     nullptr,
251
     4,
252
     0,
253
     eEncodingIEEE754,
254
     eFormatFloat,
255
     {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
256
      LLDB_INVALID_REGNUM},
257
     nullptr,
258
     nullptr,
259
     nullptr,
260
    },
261
    {"s1",
262
     nullptr,
263
     4,
264
     0,
265
     eEncodingIEEE754,
266
     eFormatFloat,
267
     {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
268
      LLDB_INVALID_REGNUM},
269
     nullptr,
270
     nullptr,
271
     nullptr,
272
    },
273
    {"s2",
274
     nullptr,
275
     4,
276
     0,
277
     eEncodingIEEE754,
278
     eFormatFloat,
279
     {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
280
      LLDB_INVALID_REGNUM},
281
     nullptr,
282
     nullptr,
283
     nullptr,
284
    },
285
    {"s3",
286
     nullptr,
287
     4,
288
     0,
289
     eEncodingIEEE754,
290
     eFormatFloat,
291
     {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
292
      LLDB_INVALID_REGNUM},
293
     nullptr,
294
     nullptr,
295
     nullptr,
296
    },
297
    {"s4",
298
     nullptr,
299
     4,
300
     0,
301
     eEncodingIEEE754,
302
     eFormatFloat,
303
     {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
304
      LLDB_INVALID_REGNUM},
305
     nullptr,
306
     nullptr,
307
     nullptr,
308
    },
309
    {"s5",
310
     nullptr,
311
     4,
312
     0,
313
     eEncodingIEEE754,
314
     eFormatFloat,
315
     {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
316
      LLDB_INVALID_REGNUM},
317
     nullptr,
318
     nullptr,
319
     nullptr,
320
    },
321
    {"s6",
322
     nullptr,
323
     4,
324
     0,
325
     eEncodingIEEE754,
326
     eFormatFloat,
327
     {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
328
      LLDB_INVALID_REGNUM},
329
     nullptr,
330
     nullptr,
331
     nullptr,
332
    },
333
    {"s7",
334
     nullptr,
335
     4,
336
     0,
337
     eEncodingIEEE754,
338
     eFormatFloat,
339
     {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
340
      LLDB_INVALID_REGNUM},
341
     nullptr,
342
     nullptr,
343
     nullptr,
344
    },
345
    {"s8",
346
     nullptr,
347
     4,
348
     0,
349
     eEncodingIEEE754,
350
     eFormatFloat,
351
     {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
352
      LLDB_INVALID_REGNUM},
353
     nullptr,
354
     nullptr,
355
     nullptr,
356
    },
357
    {"s9",
358
     nullptr,
359
     4,
360
     0,
361
     eEncodingIEEE754,
362
     eFormatFloat,
363
     {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
364
      LLDB_INVALID_REGNUM},
365
     nullptr,
366
     nullptr,
367
     nullptr,
368
    },
369
    {"s10",
370
     nullptr,
371
     4,
372
     0,
373
     eEncodingIEEE754,
374
     eFormatFloat,
375
     {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
376
      LLDB_INVALID_REGNUM},
377
     nullptr,
378
     nullptr,
379
     nullptr,
380
    },
381
    {"s11",
382
     nullptr,
383
     4,
384
     0,
385
     eEncodingIEEE754,
386
     eFormatFloat,
387
     {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
388
      LLDB_INVALID_REGNUM},
389
     nullptr,
390
     nullptr,
391
     nullptr,
392
    },
393
    {"s12",
394
     nullptr,
395
     4,
396
     0,
397
     eEncodingIEEE754,
398
     eFormatFloat,
399
     {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
400
      LLDB_INVALID_REGNUM},
401
     nullptr,
402
     nullptr,
403
     nullptr,
404
    },
405
    {"s13",
406
     nullptr,
407
     4,
408
     0,
409
     eEncodingIEEE754,
410
     eFormatFloat,
411
     {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
412
      LLDB_INVALID_REGNUM},
413
     nullptr,
414
     nullptr,
415
     nullptr,
416
    },
417
    {"s14",
418
     nullptr,
419
     4,
420
     0,
421
     eEncodingIEEE754,
422
     eFormatFloat,
423
     {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
424
      LLDB_INVALID_REGNUM},
425
     nullptr,
426
     nullptr,
427
     nullptr,
428
    },
429
    {"s15",
430
     nullptr,
431
     4,
432
     0,
433
     eEncodingIEEE754,
434
     eFormatFloat,
435
     {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
436
      LLDB_INVALID_REGNUM},
437
     nullptr,
438
     nullptr,
439
     nullptr,
440
    },
441
    {"s16",
442
     nullptr,
443
     4,
444
     0,
445
     eEncodingIEEE754,
446
     eFormatFloat,
447
     {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
448
      LLDB_INVALID_REGNUM},
449
     nullptr,
450
     nullptr,
451
     nullptr,
452
    },
453
    {"s17",
454
     nullptr,
455
     4,
456
     0,
457
     eEncodingIEEE754,
458
     eFormatFloat,
459
     {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
460
      LLDB_INVALID_REGNUM},
461
     nullptr,
462
     nullptr,
463
     nullptr,
464
    },
465
    {"s18",
466
     nullptr,
467
     4,
468
     0,
469
     eEncodingIEEE754,
470
     eFormatFloat,
471
     {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
472
      LLDB_INVALID_REGNUM},
473
     nullptr,
474
     nullptr,
475
     nullptr,
476
    },
477
    {"s19",
478
     nullptr,
479
     4,
480
     0,
481
     eEncodingIEEE754,
482
     eFormatFloat,
483
     {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
484
      LLDB_INVALID_REGNUM},
485
     nullptr,
486
     nullptr,
487
     nullptr,
488
    },
489
    {"s20",
490
     nullptr,
491
     4,
492
     0,
493
     eEncodingIEEE754,
494
     eFormatFloat,
495
     {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
496
      LLDB_INVALID_REGNUM},
497
     nullptr,
498
     nullptr,
499
     nullptr,
500
    },
501
    {"s21",
502
     nullptr,
503
     4,
504
     0,
505
     eEncodingIEEE754,
506
     eFormatFloat,
507
     {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
508
      LLDB_INVALID_REGNUM},
509
     nullptr,
510
     nullptr,
511
     nullptr,
512
    },
513
    {"s22",
514
     nullptr,
515
     4,
516
     0,
517
     eEncodingIEEE754,
518
     eFormatFloat,
519
     {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
520
      LLDB_INVALID_REGNUM},
521
     nullptr,
522
     nullptr,
523
     nullptr,
524
    },
525
    {"s23",
526
     nullptr,
527
     4,
528
     0,
529
     eEncodingIEEE754,
530
     eFormatFloat,
531
     {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
532
      LLDB_INVALID_REGNUM},
533
     nullptr,
534
     nullptr,
535
     nullptr,
536
    },
537
    {"s24",
538
     nullptr,
539
     4,
540
     0,
541
     eEncodingIEEE754,
542
     eFormatFloat,
543
     {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
544
      LLDB_INVALID_REGNUM},
545
     nullptr,
546
     nullptr,
547
     nullptr,
548
    },
549
    {"s25",
550
     nullptr,
551
     4,
552
     0,
553
     eEncodingIEEE754,
554
     eFormatFloat,
555
     {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
556
      LLDB_INVALID_REGNUM},
557
     nullptr,
558
     nullptr,
559
     nullptr,
560
    },
561
    {"s26",
562
     nullptr,
563
     4,
564
     0,
565
     eEncodingIEEE754,
566
     eFormatFloat,
567
     {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
568
      LLDB_INVALID_REGNUM},
569
     nullptr,
570
     nullptr,
571
     nullptr,
572
    },
573
    {"s27",
574
     nullptr,
575
     4,
576
     0,
577
     eEncodingIEEE754,
578
     eFormatFloat,
579
     {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
580
      LLDB_INVALID_REGNUM},
581
     nullptr,
582
     nullptr,
583
     nullptr,
584
    },
585
    {"s28",
586
     nullptr,
587
     4,
588
     0,
589
     eEncodingIEEE754,
590
     eFormatFloat,
591
     {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
592
      LLDB_INVALID_REGNUM},
593
     nullptr,
594
     nullptr,
595
     nullptr,
596
    },
597
    {"s29",
598
     nullptr,
599
     4,
600
     0,
601
     eEncodingIEEE754,
602
     eFormatFloat,
603
     {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
604
      LLDB_INVALID_REGNUM},
605
     nullptr,
606
     nullptr,
607
     nullptr,
608
    },
609
    {"s30",
610
     nullptr,
611
     4,
612
     0,
613
     eEncodingIEEE754,
614
     eFormatFloat,
615
     {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
616
      LLDB_INVALID_REGNUM},
617
     nullptr,
618
     nullptr,
619
     nullptr,
620
    },
621
    {"s31",
622
     nullptr,
623
     4,
624
     0,
625
     eEncodingIEEE754,
626
     eFormatFloat,
627
     {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
628
      LLDB_INVALID_REGNUM},
629
     nullptr,
630
     nullptr,
631
     nullptr,
632
    },
633
    {"fpscr",
634
     nullptr,
635
     4,
636
     0,
637
     eEncodingUint,
638
     eFormatHex,
639
     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
640
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
641
     nullptr,
642
     nullptr,
643
     nullptr,
644
    },
645
    {"d0",
646
     nullptr,
647
     8,
648
     0,
649
     eEncodingIEEE754,
650
     eFormatFloat,
651
     {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
652
      LLDB_INVALID_REGNUM},
653
     nullptr,
654
     nullptr,
655
     nullptr,
656
    },
657
    {"d1",
658
     nullptr,
659
     8,
660
     0,
661
     eEncodingIEEE754,
662
     eFormatFloat,
663
     {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
664
      LLDB_INVALID_REGNUM},
665
     nullptr,
666
     nullptr,
667
     nullptr,
668
    },
669
    {"d2",
670
     nullptr,
671
     8,
672
     0,
673
     eEncodingIEEE754,
674
     eFormatFloat,
675
     {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
676
      LLDB_INVALID_REGNUM},
677
     nullptr,
678
     nullptr,
679
     nullptr,
680
    },
681
    {"d3",
682
     nullptr,
683
     8,
684
     0,
685
     eEncodingIEEE754,
686
     eFormatFloat,
687
     {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
688
      LLDB_INVALID_REGNUM},
689
     nullptr,
690
     nullptr,
691
     nullptr,
692
    },
693
    {"d4",
694
     nullptr,
695
     8,
696
     0,
697
     eEncodingIEEE754,
698
     eFormatFloat,
699
     {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
700
      LLDB_INVALID_REGNUM},
701
     nullptr,
702
     nullptr,
703
     nullptr,
704
    },
705
    {"d5",
706
     nullptr,
707
     8,
708
     0,
709
     eEncodingIEEE754,
710
     eFormatFloat,
711
     {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
712
      LLDB_INVALID_REGNUM},
713
     nullptr,
714
     nullptr,
715
     nullptr,
716
    },
717
    {"d6",
718
     nullptr,
719
     8,
720
     0,
721
     eEncodingIEEE754,
722
     eFormatFloat,
723
     {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
724
      LLDB_INVALID_REGNUM},
725
     nullptr,
726
     nullptr,
727
     nullptr,
728
    },
729
    {"d7",
730
     nullptr,
731
     8,
732
     0,
733
     eEncodingIEEE754,
734
     eFormatFloat,
735
     {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
736
      LLDB_INVALID_REGNUM},
737
     nullptr,
738
     nullptr,
739
     nullptr,
740
    },
741
    {"d8",
742
     nullptr,
743
     8,
744
     0,
745
     eEncodingIEEE754,
746
     eFormatFloat,
747
     {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
748
      LLDB_INVALID_REGNUM},
749
     nullptr,
750
     nullptr,
751
     nullptr,
752
    },
753
    {"d9",
754
     nullptr,
755
     8,
756
     0,
757
     eEncodingIEEE754,
758
     eFormatFloat,
759
     {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
760
      LLDB_INVALID_REGNUM},
761
     nullptr,
762
     nullptr,
763
     nullptr,
764
    },
765
    {"d10",
766
     nullptr,
767
     8,
768
     0,
769
     eEncodingIEEE754,
770
     eFormatFloat,
771
     {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
772
      LLDB_INVALID_REGNUM},
773
     nullptr,
774
     nullptr,
775
     nullptr,
776
    },
777
    {"d11",
778
     nullptr,
779
     8,
780
     0,
781
     eEncodingIEEE754,
782
     eFormatFloat,
783
     {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
784
      LLDB_INVALID_REGNUM},
785
     nullptr,
786
     nullptr,
787
     nullptr,
788
    },
789
    {"d12",
790
     nullptr,
791
     8,
792
     0,
793
     eEncodingIEEE754,
794
     eFormatFloat,
795
     {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
796
      LLDB_INVALID_REGNUM},
797
     nullptr,
798
     nullptr,
799
     nullptr,
800
    },
801
    {"d13",
802
     nullptr,
803
     8,
804
     0,
805
     eEncodingIEEE754,
806
     eFormatFloat,
807
     {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
808
      LLDB_INVALID_REGNUM},
809
     nullptr,
810
     nullptr,
811
     nullptr,
812
    },
813
    {"d14",
814
     nullptr,
815
     8,
816
     0,
817
     eEncodingIEEE754,
818
     eFormatFloat,
819
     {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
820
      LLDB_INVALID_REGNUM},
821
     nullptr,
822
     nullptr,
823
     nullptr,
824
    },
825
    {"d15",
826
     nullptr,
827
     8,
828
     0,
829
     eEncodingIEEE754,
830
     eFormatFloat,
831
     {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
832
      LLDB_INVALID_REGNUM},
833
     nullptr,
834
     nullptr,
835
     nullptr,
836
    },
837
    {"d16",
838
     nullptr,
839
     8,
840
     0,
841
     eEncodingIEEE754,
842
     eFormatFloat,
843
     {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
844
      LLDB_INVALID_REGNUM},
845
     nullptr,
846
     nullptr,
847
     nullptr,
848
    },
849
    {"d17",
850
     nullptr,
851
     8,
852
     0,
853
     eEncodingIEEE754,
854
     eFormatFloat,
855
     {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
856
      LLDB_INVALID_REGNUM},
857
     nullptr,
858
     nullptr,
859
     nullptr,
860
    },
861
    {"d18",
862
     nullptr,
863
     8,
864
     0,
865
     eEncodingIEEE754,
866
     eFormatFloat,
867
     {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
868
      LLDB_INVALID_REGNUM},
869
     nullptr,
870
     nullptr,
871
     nullptr,
872
    },
873
    {"d19",
874
     nullptr,
875
     8,
876
     0,
877
     eEncodingIEEE754,
878
     eFormatFloat,
879
     {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
880
      LLDB_INVALID_REGNUM},
881
     nullptr,
882
     nullptr,
883
     nullptr,
884
    },
885
    {"d20",
886
     nullptr,
887
     8,
888
     0,
889
     eEncodingIEEE754,
890
     eFormatFloat,
891
     {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
892
      LLDB_INVALID_REGNUM},
893
     nullptr,
894
     nullptr,
895
     nullptr,
896
    },
897
    {"d21",
898
     nullptr,
899
     8,
900
     0,
901
     eEncodingIEEE754,
902
     eFormatFloat,
903
     {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
904
      LLDB_INVALID_REGNUM},
905
     nullptr,
906
     nullptr,
907
     nullptr,
908
    },
909
    {"d22",
910
     nullptr,
911
     8,
912
     0,
913
     eEncodingIEEE754,
914
     eFormatFloat,
915
     {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
916
      LLDB_INVALID_REGNUM},
917
     nullptr,
918
     nullptr,
919
     nullptr,
920
    },
921
    {"d23",
922
     nullptr,
923
     8,
924
     0,
925
     eEncodingIEEE754,
926
     eFormatFloat,
927
     {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
928
      LLDB_INVALID_REGNUM},
929
     nullptr,
930
     nullptr,
931
     nullptr,
932
    },
933
    {"d24",
934
     nullptr,
935
     8,
936
     0,
937
     eEncodingIEEE754,
938
     eFormatFloat,
939
     {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
940
      LLDB_INVALID_REGNUM},
941
     nullptr,
942
     nullptr,
943
     nullptr,
944
    },
945
    {"d25",
946
     nullptr,
947
     8,
948
     0,
949
     eEncodingIEEE754,
950
     eFormatFloat,
951
     {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
952
      LLDB_INVALID_REGNUM},
953
     nullptr,
954
     nullptr,
955
     nullptr,
956
    },
957
    {"d26",
958
     nullptr,
959
     8,
960
     0,
961
     eEncodingIEEE754,
962
     eFormatFloat,
963
     {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
964
      LLDB_INVALID_REGNUM},
965
     nullptr,
966
     nullptr,
967
     nullptr,
968
    },
969
    {"d27",
970
     nullptr,
971
     8,
972
     0,
973
     eEncodingIEEE754,
974
     eFormatFloat,
975
     {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
976
      LLDB_INVALID_REGNUM},
977
     nullptr,
978
     nullptr,
979
     nullptr,
980
    },
981
    {"d28",
982
     nullptr,
983
     8,
984
     0,
985
     eEncodingIEEE754,
986
     eFormatFloat,
987
     {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
988
      LLDB_INVALID_REGNUM},
989
     nullptr,
990
     nullptr,
991
     nullptr,
992
    },
993
    {"d29",
994
     nullptr,
995
     8,
996
     0,
997
     eEncodingIEEE754,
998
     eFormatFloat,
999
     {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1000
      LLDB_INVALID_REGNUM},
1001
     nullptr,
1002
     nullptr,
1003
     nullptr,
1004
    },
1005
    {"d30",
1006
     nullptr,
1007
     8,
1008
     0,
1009
     eEncodingIEEE754,
1010
     eFormatFloat,
1011
     {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1012
      LLDB_INVALID_REGNUM},
1013
     nullptr,
1014
     nullptr,
1015
     nullptr,
1016
    },
1017
    {"d31",
1018
     nullptr,
1019
     8,
1020
     0,
1021
     eEncodingIEEE754,
1022
     eFormatFloat,
1023
     {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
1024
      LLDB_INVALID_REGNUM},
1025
     nullptr,
1026
     nullptr,
1027
     nullptr,
1028
    },
1029
    {"r8_usr",
1030
     nullptr,
1031
     4,
1032
     0,
1033
     eEncodingUint,
1034
     eFormatHex,
1035
     {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
1036
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1037
     nullptr,
1038
     nullptr,
1039
     nullptr,
1040
    },
1041
    {"r9_usr",
1042
     nullptr,
1043
     4,
1044
     0,
1045
     eEncodingUint,
1046
     eFormatHex,
1047
     {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
1048
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1049
     nullptr,
1050
     nullptr,
1051
     nullptr,
1052
    },
1053
    {"r10_usr",
1054
     nullptr,
1055
     4,
1056
     0,
1057
     eEncodingUint,
1058
     eFormatHex,
1059
     {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
1060
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1061
     nullptr,
1062
     nullptr,
1063
     nullptr,
1064
    },
1065
    {"r11_usr",
1066
     nullptr,
1067
     4,
1068
     0,
1069
     eEncodingUint,
1070
     eFormatHex,
1071
     {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
1072
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1073
     nullptr,
1074
     nullptr,
1075
     nullptr,
1076
    },
1077
    {"r12_usr",
1078
     nullptr,
1079
     4,
1080
     0,
1081
     eEncodingUint,
1082
     eFormatHex,
1083
     {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
1084
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1085
     nullptr,
1086
     nullptr,
1087
     nullptr,
1088
    },
1089
    {"r13_usr",
1090
     "sp_usr",
1091
     4,
1092
     0,
1093
     eEncodingUint,
1094
     eFormatHex,
1095
     {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
1096
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1097
     nullptr,
1098
     nullptr,
1099
     nullptr,
1100
    },
1101
    {"r14_usr",
1102
     "lr_usr",
1103
     4,
1104
     0,
1105
     eEncodingUint,
1106
     eFormatHex,
1107
     {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
1108
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1109
     nullptr,
1110
     nullptr,
1111
     nullptr,
1112
    },
1113
    {"r8_fiq",
1114
     nullptr,
1115
     4,
1116
     0,
1117
     eEncodingUint,
1118
     eFormatHex,
1119
     {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
1120
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1121
     nullptr,
1122
     nullptr,
1123
     nullptr,
1124
    },
1125
    {"r9_fiq",
1126
     nullptr,
1127
     4,
1128
     0,
1129
     eEncodingUint,
1130
     eFormatHex,
1131
     {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
1132
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1133
     nullptr,
1134
     nullptr,
1135
     nullptr,
1136
    },
1137
    {"r10_fiq",
1138
     nullptr,
1139
     4,
1140
     0,
1141
     eEncodingUint,
1142
     eFormatHex,
1143
     {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
1144
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1145
     nullptr,
1146
     nullptr,
1147
     nullptr,
1148
    },
1149
    {"r11_fiq",
1150
     nullptr,
1151
     4,
1152
     0,
1153
     eEncodingUint,
1154
     eFormatHex,
1155
     {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
1156
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1157
     nullptr,
1158
     nullptr,
1159
     nullptr,
1160
    },
1161
    {"r12_fiq",
1162
     nullptr,
1163
     4,
1164
     0,
1165
     eEncodingUint,
1166
     eFormatHex,
1167
     {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
1168
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1169
     nullptr,
1170
     nullptr,
1171
     nullptr,
1172
    },
1173
    {"r13_fiq",
1174
     "sp_fiq",
1175
     4,
1176
     0,
1177
     eEncodingUint,
1178
     eFormatHex,
1179
     {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
1180
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1181
     nullptr,
1182
     nullptr,
1183
     nullptr,
1184
    },
1185
    {"r14_fiq",
1186
     "lr_fiq",
1187
     4,
1188
     0,
1189
     eEncodingUint,
1190
     eFormatHex,
1191
     {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
1192
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1193
     nullptr,
1194
     nullptr,
1195
     nullptr,
1196
    },
1197
    {"r13_irq",
1198
     "sp_irq",
1199
     4,
1200
     0,
1201
     eEncodingUint,
1202
     eFormatHex,
1203
     {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
1204
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1205
     nullptr,
1206
     nullptr,
1207
     nullptr,
1208
    },
1209
    {"r14_irq",
1210
     "lr_irq",
1211
     4,
1212
     0,
1213
     eEncodingUint,
1214
     eFormatHex,
1215
     {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
1216
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1217
     nullptr,
1218
     nullptr,
1219
     nullptr,
1220
    },
1221
    {"r13_abt",
1222
     "sp_abt",
1223
     4,
1224
     0,
1225
     eEncodingUint,
1226
     eFormatHex,
1227
     {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
1228
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1229
     nullptr,
1230
     nullptr,
1231
     nullptr,
1232
    },
1233
    {"r14_abt",
1234
     "lr_abt",
1235
     4,
1236
     0,
1237
     eEncodingUint,
1238
     eFormatHex,
1239
     {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
1240
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1241
     nullptr,
1242
     nullptr,
1243
     nullptr,
1244
    },
1245
    {"r13_und",
1246
     "sp_und",
1247
     4,
1248
     0,
1249
     eEncodingUint,
1250
     eFormatHex,
1251
     {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
1252
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1253
     nullptr,
1254
     nullptr,
1255
     nullptr,
1256
    },
1257
    {"r14_und",
1258
     "lr_und",
1259
     4,
1260
     0,
1261
     eEncodingUint,
1262
     eFormatHex,
1263
     {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
1264
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1265
     nullptr,
1266
     nullptr,
1267
     nullptr,
1268
    },
1269
    {"r13_svc",
1270
     "sp_svc",
1271
     4,
1272
     0,
1273
     eEncodingUint,
1274
     eFormatHex,
1275
     {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
1276
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1277
     nullptr,
1278
     nullptr,
1279
     nullptr,
1280
    },
1281
    {"r14_svc",
1282
     "lr_svc",
1283
     4,
1284
     0,
1285
     eEncodingUint,
1286
     eFormatHex,
1287
     {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
1288
      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1289
     nullptr,
1290
     nullptr,
1291
     nullptr,
1292
     }};
1293

1294
static const uint32_t k_num_register_infos = std::size(g_register_infos);
1295

1296
const lldb_private::RegisterInfo *
1297
ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
1298
  count = k_num_register_infos;
1299
  return g_register_infos;
1300
}
1301

1302
size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1303

1304
// Static Functions
1305

1306
ABISP
1307
ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1308
  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1309
  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1310

1311
  if (vendor_type == llvm::Triple::Apple) {
1312
    if ((arch_type == llvm::Triple::arm) ||
1313
        (arch_type == llvm::Triple::thumb)) {
1314
      return ABISP(
1315
          new ABIMacOSX_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
1316
    }
1317
  }
1318

1319
  return ABISP();
1320
}
1321

1322
bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
1323
                                       addr_t function_addr, addr_t return_addr,
1324
                                       llvm::ArrayRef<addr_t> args) const {
1325
  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1326
  if (!reg_ctx)
1327
    return false;
1328

1329
  const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1330
      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1331
  const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1332
      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
1333
  const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1334
      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
1335

1336
  RegisterValue reg_value;
1337

1338
  const char *reg_names[] = {"r0", "r1", "r2", "r3"};
1339

1340
  llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
1341

1342
  for (size_t i = 0; i < std::size(reg_names); ++i) {
1343
    if (ai == ae)
1344
      break;
1345

1346
    reg_value.SetUInt32(*ai);
1347
    if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
1348
                                reg_value))
1349
      return false;
1350

1351
    ++ai;
1352
  }
1353

1354
  if (ai != ae) {
1355
    // Spill onto the stack
1356
    size_t num_stack_regs = ae - ai;
1357

1358
    sp -= (num_stack_regs * 4);
1359
    // Keep the stack 16 byte aligned
1360
    sp &= ~(16ull - 1ull);
1361

1362
    // just using arg1 to get the right size
1363
    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1364
        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
1365

1366
    addr_t arg_pos = sp;
1367

1368
    for (; ai != ae; ++ai) {
1369
      reg_value.SetUInt32(*ai);
1370
      if (reg_ctx
1371
              ->WriteRegisterValueToMemory(reg_info, arg_pos,
1372
                                           reg_info->byte_size, reg_value)
1373
              .Fail())
1374
        return false;
1375
      arg_pos += reg_info->byte_size;
1376
    }
1377
  }
1378

1379
  TargetSP target_sp(thread.CalculateTarget());
1380
  Address so_addr;
1381

1382
  // Figure out if our return address is ARM or Thumb by using the
1383
  // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
1384
  // thumb-ness and set the correct address bits for us.
1385
  so_addr.SetLoadAddress(return_addr, target_sp.get());
1386
  return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1387

1388
  // Set "lr" to the return address
1389
  if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
1390
    return false;
1391

1392
  // If bit zero or 1 is set, this must be a thumb function, no need to figure
1393
  // this out from the symbols.
1394
  so_addr.SetLoadAddress(function_addr, target_sp.get());
1395
  function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1396

1397
  const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr");
1398
  const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0);
1399

1400
  // Make a new CPSR and mask out any Thumb IT (if/then) bits
1401
  uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK;
1402
  // If bit zero or 1 is set, this must be thumb...
1403
  if (function_addr & 1ull)
1404
    new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR
1405
  else
1406
    new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR
1407

1408
  if (new_cpsr != curr_cpsr) {
1409
    if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr))
1410
      return false;
1411
  }
1412

1413
  function_addr &=
1414
      ~1ull; // clear bit zero since the CPSR will take care of the mode for us
1415

1416
  // Update the sp - stack pointer - to be aligned to 16-bytes
1417
  sp &= ~(0xfull);
1418
  if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
1419
    return false;
1420

1421
  // Set "pc" to the address requested
1422
  if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr))
1423
    return false;
1424

1425
  return true;
1426
}
1427

1428
bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
1429
  uint32_t num_values = values.GetSize();
1430

1431
  ExecutionContext exe_ctx(thread.shared_from_this());
1432
  // For now, assume that the types in the AST values come from the Target's
1433
  // scratch AST.
1434

1435
  // Extract the register context so we can read arguments from registers
1436

1437
  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1438

1439
  if (!reg_ctx)
1440
    return false;
1441

1442
  addr_t sp = 0;
1443

1444
  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1445
    // We currently only support extracting values with Clang QualTypes. Do we
1446
    // care about others?
1447
    Value *value = values.GetValueAtIndex(value_idx);
1448

1449
    if (!value)
1450
      return false;
1451

1452
    CompilerType compiler_type = value->GetCompilerType();
1453
    if (compiler_type) {
1454
      bool is_signed = false;
1455
      size_t bit_width = 0;
1456
      std::optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
1457
      if (!bit_size)
1458
        return false;
1459
      if (compiler_type.IsIntegerOrEnumerationType(is_signed))
1460
        bit_width = *bit_size;
1461
      else if (compiler_type.IsPointerOrReferenceType())
1462
        bit_width = *bit_size;
1463
      else
1464
        // We only handle integer, pointer and reference types currently...
1465
        return false;
1466

1467
      if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1468
        if (value_idx < 4) {
1469
          // Arguments 1-4 are in r0-r3...
1470
          const RegisterInfo *arg_reg_info = nullptr;
1471
          // Search by generic ID first, then fall back to by name
1472
          uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1473
              eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
1474
          if (arg_reg_num != LLDB_INVALID_REGNUM) {
1475
            arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1476
          } else {
1477
            switch (value_idx) {
1478
            case 0:
1479
              arg_reg_info = reg_ctx->GetRegisterInfoByName("r0");
1480
              break;
1481
            case 1:
1482
              arg_reg_info = reg_ctx->GetRegisterInfoByName("r1");
1483
              break;
1484
            case 2:
1485
              arg_reg_info = reg_ctx->GetRegisterInfoByName("r2");
1486
              break;
1487
            case 3:
1488
              arg_reg_info = reg_ctx->GetRegisterInfoByName("r3");
1489
              break;
1490
            }
1491
          }
1492

1493
          if (arg_reg_info) {
1494
            RegisterValue reg_value;
1495

1496
            if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) {
1497
              if (is_signed)
1498
                reg_value.SignExtend(bit_width);
1499
              if (!reg_value.GetScalarValue(value->GetScalar()))
1500
                return false;
1501
              continue;
1502
            }
1503
          }
1504
          return false;
1505
        } else {
1506
          if (sp == 0) {
1507
            // Read the stack pointer if it already hasn't been read
1508
            sp = reg_ctx->GetSP(0);
1509
            if (sp == 0)
1510
              return false;
1511
          }
1512

1513
          // Arguments 5 on up are on the stack
1514
          const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1515
          Status error;
1516
          if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1517
                  sp, arg_byte_size, is_signed, value->GetScalar(), error))
1518
            return false;
1519

1520
          sp += arg_byte_size;
1521
        }
1522
      }
1523
    }
1524
  }
1525
  return true;
1526
}
1527

1528
bool ABIMacOSX_arm::IsArmv7kProcess() const {
1529
  bool is_armv7k = false;
1530
  ProcessSP process_sp(GetProcessSP());
1531
  if (process_sp) {
1532
    const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
1533
    const ArchSpec::Core system_core = arch.GetCore();
1534
    if (system_core == ArchSpec::eCore_arm_armv7k) {
1535
      is_armv7k = true;
1536
    }
1537
  }
1538
  return is_armv7k;
1539
}
1540

1541
ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl(
1542
    Thread &thread, lldb_private::CompilerType &compiler_type) const {
1543
  Value value;
1544
  ValueObjectSP return_valobj_sp;
1545

1546
  if (!compiler_type)
1547
    return return_valobj_sp;
1548

1549
  value.SetCompilerType(compiler_type);
1550

1551
  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1552
  if (!reg_ctx)
1553
    return return_valobj_sp;
1554

1555
  bool is_signed;
1556

1557
  // Get the pointer to the first stack argument so we have a place to start
1558
  // when reading data
1559

1560
  const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1561
  if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1562
    std::optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
1563
    if (!bit_width)
1564
      return return_valobj_sp;
1565

1566
    switch (*bit_width) {
1567
    default:
1568
      return return_valobj_sp;
1569
    case 128:
1570
      if (IsArmv7kProcess()) {
1571
        // "A composite type not larger than 16 bytes is returned in r0-r3. The
1572
        // format is as if the result had been stored in memory at a word-
1573
        // aligned address and then loaded into r0-r3 with an ldm instruction"
1574
        {
1575
          const RegisterInfo *r1_reg_info =
1576
              reg_ctx->GetRegisterInfoByName("r1", 0);
1577
          const RegisterInfo *r2_reg_info =
1578
              reg_ctx->GetRegisterInfoByName("r2", 0);
1579
          const RegisterInfo *r3_reg_info =
1580
              reg_ctx->GetRegisterInfoByName("r3", 0);
1581
          if (r1_reg_info && r2_reg_info && r3_reg_info) {
1582
            std::optional<uint64_t> byte_size =
1583
                compiler_type.GetByteSize(&thread);
1584
            if (!byte_size)
1585
              return return_valobj_sp;
1586
            ProcessSP process_sp(thread.GetProcess());
1587
            if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
1588
                                  r2_reg_info->byte_size +
1589
                                  r3_reg_info->byte_size &&
1590
                process_sp) {
1591
              std::unique_ptr<DataBufferHeap> heap_data_up(
1592
                  new DataBufferHeap(*byte_size, 0));
1593
              const ByteOrder byte_order = process_sp->GetByteOrder();
1594
              RegisterValue r0_reg_value;
1595
              RegisterValue r1_reg_value;
1596
              RegisterValue r2_reg_value;
1597
              RegisterValue r3_reg_value;
1598
              if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
1599
                  reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
1600
                  reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&
1601
                  reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) {
1602
                Status error;
1603
                if (r0_reg_value.GetAsMemoryData(*r0_reg_info,
1604
                                                 heap_data_up->GetBytes() + 0,
1605
                                                 4, byte_order, error) &&
1606
                    r1_reg_value.GetAsMemoryData(*r1_reg_info,
1607
                                                 heap_data_up->GetBytes() + 4,
1608
                                                 4, byte_order, error) &&
1609
                    r2_reg_value.GetAsMemoryData(*r2_reg_info,
1610
                                                 heap_data_up->GetBytes() + 8,
1611
                                                 4, byte_order, error) &&
1612
                    r3_reg_value.GetAsMemoryData(*r3_reg_info,
1613
                                                 heap_data_up->GetBytes() + 12,
1614
                                                 4, byte_order, error)) {
1615
                  DataExtractor data(DataBufferSP(heap_data_up.release()),
1616
                                     byte_order,
1617
                                     process_sp->GetAddressByteSize());
1618

1619
                  return_valobj_sp = ValueObjectConstResult::Create(
1620
                      &thread, compiler_type, ConstString(""), data);
1621
                  return return_valobj_sp;
1622
                }
1623
              }
1624
            }
1625
          }
1626
        }
1627
      } else {
1628
        return return_valobj_sp;
1629
      }
1630
      break;
1631
    case 64: {
1632
      const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1633
      uint64_t raw_value;
1634
      raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
1635
      raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) &
1636
                               UINT32_MAX))
1637
                   << 32;
1638
      if (is_signed)
1639
        value.GetScalar() = (int64_t)raw_value;
1640
      else
1641
        value.GetScalar() = (uint64_t)raw_value;
1642
    } break;
1643
    case 32:
1644
      if (is_signed)
1645
        value.GetScalar() = (int32_t)(
1646
            reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1647
      else
1648
        value.GetScalar() = (uint32_t)(
1649
            reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1650
      break;
1651
    case 16:
1652
      if (is_signed)
1653
        value.GetScalar() = (int16_t)(
1654
            reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1655
      else
1656
        value.GetScalar() = (uint16_t)(
1657
            reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1658
      break;
1659
    case 8:
1660
      if (is_signed)
1661
        value.GetScalar() = (int8_t)(
1662
            reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1663
      else
1664
        value.GetScalar() = (uint8_t)(
1665
            reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1666
      break;
1667
    }
1668
  } else if (compiler_type.IsPointerType()) {
1669
    uint32_t ptr =
1670
        thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
1671
        UINT32_MAX;
1672
    value.GetScalar() = ptr;
1673
  } else {
1674
    // not handled yet
1675
    return return_valobj_sp;
1676
  }
1677

1678
  // If we get here, we have a valid Value, so make our ValueObject out of it:
1679

1680
  return_valobj_sp = ValueObjectConstResult::Create(
1681
      thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
1682
  return return_valobj_sp;
1683
}
1684

1685
Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1686
                                           lldb::ValueObjectSP &new_value_sp) {
1687
  Status error;
1688
  if (!new_value_sp) {
1689
    error.SetErrorString("Empty value object for return value.");
1690
    return error;
1691
  }
1692

1693
  CompilerType compiler_type = new_value_sp->GetCompilerType();
1694
  if (!compiler_type) {
1695
    error.SetErrorString("Null clang type for return value.");
1696
    return error;
1697
  }
1698

1699
  Thread *thread = frame_sp->GetThread().get();
1700

1701
  bool is_signed;
1702
  uint32_t count;
1703
  bool is_complex;
1704

1705
  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1706

1707
  bool set_it_simple = false;
1708
  if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
1709
      compiler_type.IsPointerType()) {
1710
    DataExtractor data;
1711
    Status data_error;
1712
    size_t num_bytes = new_value_sp->GetData(data, data_error);
1713
    if (data_error.Fail()) {
1714
      error.SetErrorStringWithFormat(
1715
          "Couldn't convert return value to raw data: %s",
1716
          data_error.AsCString());
1717
      return error;
1718
    }
1719
    lldb::offset_t offset = 0;
1720
    if (num_bytes <= 8) {
1721
      const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1722
      if (num_bytes <= 4) {
1723
        uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
1724

1725
        if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value))
1726
          set_it_simple = true;
1727
      } else {
1728
        uint32_t raw_value = data.GetMaxU32(&offset, 4);
1729

1730
        if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) {
1731
          const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1732
          uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
1733

1734
          if (reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value))
1735
            set_it_simple = true;
1736
        }
1737
      }
1738
    } else if (num_bytes <= 16 && IsArmv7kProcess()) {
1739
      // "A composite type not larger than 16 bytes is returned in r0-r3. The
1740
      // format is as if the result had been stored in memory at a word-aligned
1741
      // address and then loaded into r0-r3 with an ldm instruction"
1742

1743
      const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1744
      const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1745
      const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
1746
      const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
1747
      lldb::offset_t offset = 0;
1748
      uint32_t bytes_written = 4;
1749
      uint32_t raw_value = data.GetMaxU64(&offset, 4);
1750
      if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value) &&
1751
          bytes_written <= num_bytes) {
1752
        bytes_written += 4;
1753
        raw_value = data.GetMaxU64(&offset, 4);
1754
        if (bytes_written <= num_bytes &&
1755
            reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) {
1756
          bytes_written += 4;
1757
          raw_value = data.GetMaxU64(&offset, 4);
1758
          if (bytes_written <= num_bytes &&
1759
              reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) {
1760
            bytes_written += 4;
1761
            raw_value = data.GetMaxU64(&offset, 4);
1762
            if (bytes_written <= num_bytes &&
1763
                reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value)) {
1764
              set_it_simple = true;
1765
            }
1766
          }
1767
        }
1768
      }
1769
    } else {
1770
      error.SetErrorString("We don't support returning longer than 64 bit "
1771
                           "integer values at present.");
1772
    }
1773
  } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
1774
    if (is_complex)
1775
      error.SetErrorString(
1776
          "We don't support returning complex values at present");
1777
    else
1778
      error.SetErrorString(
1779
          "We don't support returning float values at present");
1780
  }
1781

1782
  if (!set_it_simple)
1783
    error.SetErrorString(
1784
        "We only support setting simple integer return types at present.");
1785

1786
  return error;
1787
}
1788

1789
bool ABIMacOSX_arm::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
1790
  unwind_plan.Clear();
1791
  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1792

1793
  uint32_t lr_reg_num = dwarf_lr;
1794
  uint32_t sp_reg_num = dwarf_sp;
1795
  uint32_t pc_reg_num = dwarf_pc;
1796

1797
  UnwindPlan::RowSP row(new UnwindPlan::Row);
1798

1799
  // Our Call Frame Address is the stack pointer value
1800
  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1801

1802
  // The previous PC is in the LR
1803
  row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
1804
  unwind_plan.AppendRow(row);
1805

1806
  // All other registers are the same.
1807

1808
  unwind_plan.SetSourceName("arm at-func-entry default");
1809
  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1810

1811
  return true;
1812
}
1813

1814
bool ABIMacOSX_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
1815
  unwind_plan.Clear();
1816
  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1817

1818
  uint32_t fp_reg_num =
1819
      dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11
1820
  uint32_t pc_reg_num = dwarf_pc;
1821

1822
  UnwindPlan::RowSP row(new UnwindPlan::Row);
1823
  const int32_t ptr_size = 4;
1824

1825
  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
1826
  row->SetOffset(0);
1827
  row->SetUnspecifiedRegistersAreUndefined(true);
1828

1829
  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1830
  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1831

1832
  unwind_plan.AppendRow(row);
1833
  unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
1834
  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1835
  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
1836
  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
1837

1838
  return true;
1839
}
1840

1841
// cf. "ARMv6 Function Calling Conventions"
1842
// https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
1843
// and "ARMv7 Function Calling Conventions"
1844
// https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html
1845

1846
// ARMv7 on iOS general purpose reg rules:
1847
//    r0-r3 not preserved  (used for argument passing)
1848
//    r4-r6 preserved
1849
//    r7    preserved (frame pointer)
1850
//    r8    preserved
1851
//    r9    not preserved (usable as volatile scratch register with iOS 3.x and
1852
//    later)
1853
//    r10-r11 preserved
1854
//    r12   not presrved
1855
//    r13   preserved (stack pointer)
1856
//    r14   not preserved (link register)
1857
//    r15   preserved (pc)
1858
//    cpsr  not preserved (different rules for different bits)
1859

1860
// ARMv7 on iOS floating point rules:
1861
//    d0-d7   not preserved   (aka s0-s15, q0-q3)
1862
//    d8-d15  preserved       (aka s16-s31, q4-q7)
1863
//    d16-d31 not preserved   (aka q8-q15)
1864

1865
bool ABIMacOSX_arm::RegisterIsVolatile(const RegisterInfo *reg_info) {
1866
  if (reg_info) {
1867
    // Volatile registers are: r0, r1, r2, r3, r9, r12, r13 (aka sp)
1868
    const char *name = reg_info->name;
1869
    if (name[0] == 'r') {
1870
      switch (name[1]) {
1871
      case '0':
1872
        return name[2] == '\0'; // r0
1873
      case '1':
1874
        switch (name[2]) {
1875
        case '\0':
1876
          return true; // r1
1877
        case '2':
1878
        case '3':
1879
          return name[3] == '\0'; // r12, r13 (sp)
1880
        default:
1881
          break;
1882
        }
1883
        break;
1884

1885
      case '2':
1886
        return name[2] == '\0'; // r2
1887
      case '3':
1888
        return name[2] == '\0'; // r3
1889
      case '9':
1890
        return name[2] == '\0'; // r9 (apple-ios only...)
1891

1892
        break;
1893
      }
1894
    } else if (name[0] == 'd') {
1895
      switch (name[1]) {
1896
      case '0':
1897
        return name[2] == '\0'; // d0 is volatile
1898

1899
      case '1':
1900
        switch (name[2]) {
1901
        case '\0':
1902
          return true; // d1 is volatile
1903
        case '6':
1904
        case '7':
1905
        case '8':
1906
        case '9':
1907
          return name[3] == '\0'; // d16 - d19 are volatile
1908
        default:
1909
          break;
1910
        }
1911
        break;
1912

1913
      case '2':
1914
        switch (name[2]) {
1915
        case '\0':
1916
          return true; // d2 is volatile
1917
        case '0':
1918
        case '1':
1919
        case '2':
1920
        case '3':
1921
        case '4':
1922
        case '5':
1923
        case '6':
1924
        case '7':
1925
        case '8':
1926
        case '9':
1927
          return name[3] == '\0'; // d20 - d29 are volatile
1928
        default:
1929
          break;
1930
        }
1931
        break;
1932

1933
      case '3':
1934
        switch (name[2]) {
1935
        case '\0':
1936
          return true; // d3 is volatile
1937
        case '0':
1938
        case '1':
1939
          return name[3] == '\0'; // d30 - d31 are volatile
1940
        default:
1941
          break;
1942
        }
1943
        break;
1944
      case '4':
1945
      case '5':
1946
      case '6':
1947
      case '7':
1948
        return name[2] == '\0'; // d4 - d7 are volatile
1949

1950
      default:
1951
        break;
1952
      }
1953
    } else if (name[0] == 's') {
1954
      switch (name[1]) {
1955
      case '0':
1956
        return name[2] == '\0'; // s0 is volatile
1957

1958
      case '1':
1959
        switch (name[2]) {
1960
        case '\0':
1961
          return true; // s1 is volatile
1962
        case '0':
1963
        case '1':
1964
        case '2':
1965
        case '3':
1966
        case '4':
1967
        case '5':
1968
          return name[3] == '\0'; // s10 - s15 are volatile
1969
        default:
1970
          break;
1971
        }
1972
        break;
1973

1974
      case '2':
1975
      case '3':
1976
      case '4':
1977
      case '5':
1978
      case '6':
1979
      case '7':
1980
      case '8':
1981
      case '9':
1982
        return name[2] == '\0'; // s2 - s9 are volatile
1983

1984
      default:
1985
        break;
1986
      }
1987
    } else if (name[0] == 'q') {
1988
      switch (name[1]) {
1989
      case '1':
1990
        switch (name[2]) {
1991
        case '\0':
1992
          return true; // q1 is volatile
1993
        case '0':
1994
        case '1':
1995
        case '2':
1996
        case '3':
1997
        case '4':
1998
        case '5':
1999
          return true; // q10-q15 are volatile
2000
        default:
2001
          break;
2002
        };
2003
        break;
2004
      case '0':
2005
      case '2':
2006
      case '3':
2007
        return name[2] == '\0'; // q0-q3 are volatile
2008
      case '8':
2009
      case '9':
2010
        return name[2] == '\0'; // q8-q9 are volatile
2011
      default:
2012
        break;
2013
      }
2014
    } else if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')
2015
      return true;
2016
  }
2017
  return false;
2018
}
2019

2020
void ABIMacOSX_arm::Initialize() {
2021
  PluginManager::RegisterPlugin(GetPluginNameStatic(),
2022
                                "Mac OS X ABI for arm targets", CreateInstance);
2023
}
2024

2025
void ABIMacOSX_arm::Terminate() {
2026
  PluginManager::UnregisterPlugin(CreateInstance);
2027
}
2028

2029
Product

Resources

Company
