LLDB  mainline
ABIMacOSX_arm.cpp
Go to the documentation of this file.
1 //===-- ABIMacOSX_arm.cpp ---------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "ABIMacOSX_arm.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"
18 #include "lldb/Core/Value.h"
20 #include "lldb/Symbol/UnwindPlan.h"
21 #include "lldb/Target/Process.h"
23 #include "lldb/Target/Target.h"
24 #include "lldb/Target/Thread.h"
27 #include "lldb/Utility/Scalar.h"
28 #include "lldb/Utility/Status.h"
29 
33 
34 using namespace lldb;
35 using namespace lldb_private;
36 
37 static RegisterInfo g_register_infos[] = {
38  // NAME ALT SZ OFF ENCODING FORMAT EH_FRAME
39  // DWARF GENERIC PROCESS PLUGIN
40  // LLDB NATIVE
41  // ========== ======= == === ============= ============
42  // ======================= =================== ===========================
43  // ======================= ======================
44  {"r0",
45  "arg1",
46  4,
47  0,
49  eFormatHex,
51  LLDB_INVALID_REGNUM},
52  nullptr,
53  nullptr,
54  nullptr,
55  0},
56  {"r1",
57  "arg2",
58  4,
59  0,
61  eFormatHex,
63  LLDB_INVALID_REGNUM},
64  nullptr,
65  nullptr,
66  nullptr,
67  0},
68  {"r2",
69  "arg3",
70  4,
71  0,
73  eFormatHex,
75  LLDB_INVALID_REGNUM},
76  nullptr,
77  nullptr,
78  nullptr,
79  0},
80  {"r3",
81  "arg4",
82  4,
83  0,
85  eFormatHex,
87  LLDB_INVALID_REGNUM},
88  nullptr,
89  nullptr,
90  nullptr,
91  0},
92  {"r4",
93  nullptr,
94  4,
95  0,
97  eFormatHex,
99  LLDB_INVALID_REGNUM},
100  nullptr,
101  nullptr,
102  nullptr,
103  0},
104  {"r5",
105  nullptr,
106  4,
107  0,
109  eFormatHex,
111  LLDB_INVALID_REGNUM},
112  nullptr,
113  nullptr,
114  nullptr,
115  0},
116  {"r6",
117  nullptr,
118  4,
119  0,
121  eFormatHex,
123  LLDB_INVALID_REGNUM},
124  nullptr,
125  nullptr,
126  nullptr,
127  0},
128  {"r7",
129  nullptr,
130  4,
131  0,
133  eFormatHex,
135  LLDB_INVALID_REGNUM},
136  nullptr,
137  nullptr,
138  nullptr,
139  0},
140  {"r8",
141  nullptr,
142  4,
143  0,
145  eFormatHex,
147  LLDB_INVALID_REGNUM},
148  nullptr,
149  nullptr,
150  nullptr,
151  0},
152  {"r9",
153  nullptr,
154  4,
155  0,
157  eFormatHex,
159  LLDB_INVALID_REGNUM},
160  nullptr,
161  nullptr,
162  nullptr,
163  0},
164  {"r10",
165  nullptr,
166  4,
167  0,
169  eFormatHex,
171  LLDB_INVALID_REGNUM},
172  nullptr,
173  nullptr,
174  nullptr,
175  0},
176  {"r11",
177  nullptr,
178  4,
179  0,
181  eFormatHex,
183  LLDB_INVALID_REGNUM},
184  nullptr,
185  nullptr,
186  nullptr,
187  0},
188  {"r12",
189  nullptr,
190  4,
191  0,
193  eFormatHex,
195  LLDB_INVALID_REGNUM},
196  nullptr,
197  nullptr,
198  nullptr,
199  0},
200  {"sp",
201  "r13",
202  4,
203  0,
205  eFormatHex,
207  LLDB_INVALID_REGNUM},
208  nullptr,
209  nullptr,
210  nullptr,
211  0},
212  {"lr",
213  "r14",
214  4,
215  0,
217  eFormatHex,
219  LLDB_INVALID_REGNUM},
220  nullptr,
221  nullptr,
222  nullptr,
223  0},
224  {"pc",
225  "r15",
226  4,
227  0,
229  eFormatHex,
231  LLDB_INVALID_REGNUM},
232  nullptr,
233  nullptr,
234  nullptr,
235  0},
236  {"cpsr",
237  "psr",
238  4,
239  0,
241  eFormatHex,
243  LLDB_INVALID_REGNUM},
244  nullptr,
245  nullptr,
246  nullptr,
247  0},
248  {"s0",
249  nullptr,
250  4,
251  0,
253  eFormatFloat,
255  LLDB_INVALID_REGNUM},
256  nullptr,
257  nullptr,
258  nullptr,
259  0},
260  {"s1",
261  nullptr,
262  4,
263  0,
265  eFormatFloat,
267  LLDB_INVALID_REGNUM},
268  nullptr,
269  nullptr,
270  nullptr,
271  0},
272  {"s2",
273  nullptr,
274  4,
275  0,
277  eFormatFloat,
279  LLDB_INVALID_REGNUM},
280  nullptr,
281  nullptr,
282  nullptr,
283  0},
284  {"s3",
285  nullptr,
286  4,
287  0,
289  eFormatFloat,
291  LLDB_INVALID_REGNUM},
292  nullptr,
293  nullptr,
294  nullptr,
295  0},
296  {"s4",
297  nullptr,
298  4,
299  0,
301  eFormatFloat,
303  LLDB_INVALID_REGNUM},
304  nullptr,
305  nullptr,
306  nullptr,
307  0},
308  {"s5",
309  nullptr,
310  4,
311  0,
313  eFormatFloat,
315  LLDB_INVALID_REGNUM},
316  nullptr,
317  nullptr,
318  nullptr,
319  0},
320  {"s6",
321  nullptr,
322  4,
323  0,
325  eFormatFloat,
327  LLDB_INVALID_REGNUM},
328  nullptr,
329  nullptr,
330  nullptr,
331  0},
332  {"s7",
333  nullptr,
334  4,
335  0,
337  eFormatFloat,
339  LLDB_INVALID_REGNUM},
340  nullptr,
341  nullptr,
342  nullptr,
343  0},
344  {"s8",
345  nullptr,
346  4,
347  0,
349  eFormatFloat,
351  LLDB_INVALID_REGNUM},
352  nullptr,
353  nullptr,
354  nullptr,
355  0},
356  {"s9",
357  nullptr,
358  4,
359  0,
361  eFormatFloat,
363  LLDB_INVALID_REGNUM},
364  nullptr,
365  nullptr,
366  nullptr,
367  0},
368  {"s10",
369  nullptr,
370  4,
371  0,
373  eFormatFloat,
375  LLDB_INVALID_REGNUM},
376  nullptr,
377  nullptr,
378  nullptr,
379  0},
380  {"s11",
381  nullptr,
382  4,
383  0,
385  eFormatFloat,
387  LLDB_INVALID_REGNUM},
388  nullptr,
389  nullptr,
390  nullptr,
391  0},
392  {"s12",
393  nullptr,
394  4,
395  0,
397  eFormatFloat,
399  LLDB_INVALID_REGNUM},
400  nullptr,
401  nullptr,
402  nullptr,
403  0},
404  {"s13",
405  nullptr,
406  4,
407  0,
409  eFormatFloat,
411  LLDB_INVALID_REGNUM},
412  nullptr,
413  nullptr,
414  nullptr,
415  0},
416  {"s14",
417  nullptr,
418  4,
419  0,
421  eFormatFloat,
423  LLDB_INVALID_REGNUM},
424  nullptr,
425  nullptr,
426  nullptr,
427  0},
428  {"s15",
429  nullptr,
430  4,
431  0,
433  eFormatFloat,
435  LLDB_INVALID_REGNUM},
436  nullptr,
437  nullptr,
438  nullptr,
439  0},
440  {"s16",
441  nullptr,
442  4,
443  0,
445  eFormatFloat,
447  LLDB_INVALID_REGNUM},
448  nullptr,
449  nullptr,
450  nullptr,
451  0},
452  {"s17",
453  nullptr,
454  4,
455  0,
457  eFormatFloat,
459  LLDB_INVALID_REGNUM},
460  nullptr,
461  nullptr,
462  nullptr,
463  0},
464  {"s18",
465  nullptr,
466  4,
467  0,
469  eFormatFloat,
471  LLDB_INVALID_REGNUM},
472  nullptr,
473  nullptr,
474  nullptr,
475  0},
476  {"s19",
477  nullptr,
478  4,
479  0,
481  eFormatFloat,
483  LLDB_INVALID_REGNUM},
484  nullptr,
485  nullptr,
486  nullptr,
487  0},
488  {"s20",
489  nullptr,
490  4,
491  0,
493  eFormatFloat,
495  LLDB_INVALID_REGNUM},
496  nullptr,
497  nullptr,
498  nullptr,
499  0},
500  {"s21",
501  nullptr,
502  4,
503  0,
505  eFormatFloat,
507  LLDB_INVALID_REGNUM},
508  nullptr,
509  nullptr,
510  nullptr,
511  0},
512  {"s22",
513  nullptr,
514  4,
515  0,
517  eFormatFloat,
519  LLDB_INVALID_REGNUM},
520  nullptr,
521  nullptr,
522  nullptr,
523  0},
524  {"s23",
525  nullptr,
526  4,
527  0,
529  eFormatFloat,
531  LLDB_INVALID_REGNUM},
532  nullptr,
533  nullptr,
534  nullptr,
535  0},
536  {"s24",
537  nullptr,
538  4,
539  0,
541  eFormatFloat,
543  LLDB_INVALID_REGNUM},
544  nullptr,
545  nullptr,
546  nullptr,
547  0},
548  {"s25",
549  nullptr,
550  4,
551  0,
553  eFormatFloat,
555  LLDB_INVALID_REGNUM},
556  nullptr,
557  nullptr,
558  nullptr,
559  0},
560  {"s26",
561  nullptr,
562  4,
563  0,
565  eFormatFloat,
567  LLDB_INVALID_REGNUM},
568  nullptr,
569  nullptr,
570  nullptr,
571  0},
572  {"s27",
573  nullptr,
574  4,
575  0,
577  eFormatFloat,
579  LLDB_INVALID_REGNUM},
580  nullptr,
581  nullptr,
582  nullptr,
583  0},
584  {"s28",
585  nullptr,
586  4,
587  0,
589  eFormatFloat,
591  LLDB_INVALID_REGNUM},
592  nullptr,
593  nullptr,
594  nullptr,
595  0},
596  {"s29",
597  nullptr,
598  4,
599  0,
601  eFormatFloat,
603  LLDB_INVALID_REGNUM},
604  nullptr,
605  nullptr,
606  nullptr,
607  0},
608  {"s30",
609  nullptr,
610  4,
611  0,
613  eFormatFloat,
615  LLDB_INVALID_REGNUM},
616  nullptr,
617  nullptr,
618  nullptr,
619  0},
620  {"s31",
621  nullptr,
622  4,
623  0,
625  eFormatFloat,
627  LLDB_INVALID_REGNUM},
628  nullptr,
629  nullptr,
630  nullptr,
631  0},
632  {"fpscr",
633  nullptr,
634  4,
635  0,
637  eFormatHex,
639  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
640  nullptr,
641  nullptr,
642  nullptr,
643  0},
644  {"d0",
645  nullptr,
646  8,
647  0,
649  eFormatFloat,
651  LLDB_INVALID_REGNUM},
652  nullptr,
653  nullptr,
654  nullptr,
655  0},
656  {"d1",
657  nullptr,
658  8,
659  0,
661  eFormatFloat,
663  LLDB_INVALID_REGNUM},
664  nullptr,
665  nullptr,
666  nullptr,
667  0},
668  {"d2",
669  nullptr,
670  8,
671  0,
673  eFormatFloat,
675  LLDB_INVALID_REGNUM},
676  nullptr,
677  nullptr,
678  nullptr,
679  0},
680  {"d3",
681  nullptr,
682  8,
683  0,
685  eFormatFloat,
687  LLDB_INVALID_REGNUM},
688  nullptr,
689  nullptr,
690  nullptr,
691  0},
692  {"d4",
693  nullptr,
694  8,
695  0,
697  eFormatFloat,
699  LLDB_INVALID_REGNUM},
700  nullptr,
701  nullptr,
702  nullptr,
703  0},
704  {"d5",
705  nullptr,
706  8,
707  0,
709  eFormatFloat,
711  LLDB_INVALID_REGNUM},
712  nullptr,
713  nullptr,
714  nullptr,
715  0},
716  {"d6",
717  nullptr,
718  8,
719  0,
721  eFormatFloat,
723  LLDB_INVALID_REGNUM},
724  nullptr,
725  nullptr,
726  nullptr,
727  0},
728  {"d7",
729  nullptr,
730  8,
731  0,
733  eFormatFloat,
735  LLDB_INVALID_REGNUM},
736  nullptr,
737  nullptr,
738  nullptr,
739  0},
740  {"d8",
741  nullptr,
742  8,
743  0,
745  eFormatFloat,
747  LLDB_INVALID_REGNUM},
748  nullptr,
749  nullptr,
750  nullptr,
751  0},
752  {"d9",
753  nullptr,
754  8,
755  0,
757  eFormatFloat,
759  LLDB_INVALID_REGNUM},
760  nullptr,
761  nullptr,
762  nullptr,
763  0},
764  {"d10",
765  nullptr,
766  8,
767  0,
769  eFormatFloat,
771  LLDB_INVALID_REGNUM},
772  nullptr,
773  nullptr,
774  nullptr,
775  0},
776  {"d11",
777  nullptr,
778  8,
779  0,
781  eFormatFloat,
783  LLDB_INVALID_REGNUM},
784  nullptr,
785  nullptr,
786  nullptr,
787  0},
788  {"d12",
789  nullptr,
790  8,
791  0,
793  eFormatFloat,
795  LLDB_INVALID_REGNUM},
796  nullptr,
797  nullptr,
798  nullptr,
799  0},
800  {"d13",
801  nullptr,
802  8,
803  0,
805  eFormatFloat,
807  LLDB_INVALID_REGNUM},
808  nullptr,
809  nullptr,
810  nullptr,
811  0},
812  {"d14",
813  nullptr,
814  8,
815  0,
817  eFormatFloat,
819  LLDB_INVALID_REGNUM},
820  nullptr,
821  nullptr,
822  nullptr,
823  0},
824  {"d15",
825  nullptr,
826  8,
827  0,
829  eFormatFloat,
831  LLDB_INVALID_REGNUM},
832  nullptr,
833  nullptr,
834  nullptr,
835  0},
836  {"d16",
837  nullptr,
838  8,
839  0,
841  eFormatFloat,
843  LLDB_INVALID_REGNUM},
844  nullptr,
845  nullptr,
846  nullptr,
847  0},
848  {"d17",
849  nullptr,
850  8,
851  0,
853  eFormatFloat,
855  LLDB_INVALID_REGNUM},
856  nullptr,
857  nullptr,
858  nullptr,
859  0},
860  {"d18",
861  nullptr,
862  8,
863  0,
865  eFormatFloat,
867  LLDB_INVALID_REGNUM},
868  nullptr,
869  nullptr,
870  nullptr,
871  0},
872  {"d19",
873  nullptr,
874  8,
875  0,
877  eFormatFloat,
879  LLDB_INVALID_REGNUM},
880  nullptr,
881  nullptr,
882  nullptr,
883  0},
884  {"d20",
885  nullptr,
886  8,
887  0,
889  eFormatFloat,
891  LLDB_INVALID_REGNUM},
892  nullptr,
893  nullptr,
894  nullptr,
895  0},
896  {"d21",
897  nullptr,
898  8,
899  0,
901  eFormatFloat,
903  LLDB_INVALID_REGNUM},
904  nullptr,
905  nullptr,
906  nullptr,
907  0},
908  {"d22",
909  nullptr,
910  8,
911  0,
913  eFormatFloat,
915  LLDB_INVALID_REGNUM},
916  nullptr,
917  nullptr,
918  nullptr,
919  0},
920  {"d23",
921  nullptr,
922  8,
923  0,
925  eFormatFloat,
927  LLDB_INVALID_REGNUM},
928  nullptr,
929  nullptr,
930  nullptr,
931  0},
932  {"d24",
933  nullptr,
934  8,
935  0,
937  eFormatFloat,
939  LLDB_INVALID_REGNUM},
940  nullptr,
941  nullptr,
942  nullptr,
943  0},
944  {"d25",
945  nullptr,
946  8,
947  0,
949  eFormatFloat,
951  LLDB_INVALID_REGNUM},
952  nullptr,
953  nullptr,
954  nullptr,
955  0},
956  {"d26",
957  nullptr,
958  8,
959  0,
961  eFormatFloat,
963  LLDB_INVALID_REGNUM},
964  nullptr,
965  nullptr,
966  nullptr,
967  0},
968  {"d27",
969  nullptr,
970  8,
971  0,
973  eFormatFloat,
975  LLDB_INVALID_REGNUM},
976  nullptr,
977  nullptr,
978  nullptr,
979  0},
980  {"d28",
981  nullptr,
982  8,
983  0,
985  eFormatFloat,
987  LLDB_INVALID_REGNUM},
988  nullptr,
989  nullptr,
990  nullptr,
991  0},
992  {"d29",
993  nullptr,
994  8,
995  0,
997  eFormatFloat,
999  LLDB_INVALID_REGNUM},
1000  nullptr,
1001  nullptr,
1002  nullptr,
1003  0},
1004  {"d30",
1005  nullptr,
1006  8,
1007  0,
1009  eFormatFloat,
1011  LLDB_INVALID_REGNUM},
1012  nullptr,
1013  nullptr,
1014  nullptr,
1015  0},
1016  {"d31",
1017  nullptr,
1018  8,
1019  0,
1021  eFormatFloat,
1023  LLDB_INVALID_REGNUM},
1024  nullptr,
1025  nullptr,
1026  nullptr,
1027  0},
1028  {"r8_usr",
1029  nullptr,
1030  4,
1031  0,
1032  eEncodingUint,
1033  eFormatHex,
1035  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1036  nullptr,
1037  nullptr,
1038  nullptr,
1039  0},
1040  {"r9_usr",
1041  nullptr,
1042  4,
1043  0,
1044  eEncodingUint,
1045  eFormatHex,
1047  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1048  nullptr,
1049  nullptr,
1050  nullptr,
1051  0},
1052  {"r10_usr",
1053  nullptr,
1054  4,
1055  0,
1056  eEncodingUint,
1057  eFormatHex,
1059  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1060  nullptr,
1061  nullptr,
1062  nullptr,
1063  0},
1064  {"r11_usr",
1065  nullptr,
1066  4,
1067  0,
1068  eEncodingUint,
1069  eFormatHex,
1071  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1072  nullptr,
1073  nullptr,
1074  nullptr,
1075  0},
1076  {"r12_usr",
1077  nullptr,
1078  4,
1079  0,
1080  eEncodingUint,
1081  eFormatHex,
1083  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1084  nullptr,
1085  nullptr,
1086  nullptr,
1087  0},
1088  {"r13_usr",
1089  "sp_usr",
1090  4,
1091  0,
1092  eEncodingUint,
1093  eFormatHex,
1095  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1096  nullptr,
1097  nullptr,
1098  nullptr,
1099  0},
1100  {"r14_usr",
1101  "lr_usr",
1102  4,
1103  0,
1104  eEncodingUint,
1105  eFormatHex,
1107  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1108  nullptr,
1109  nullptr,
1110  nullptr,
1111  0},
1112  {"r8_fiq",
1113  nullptr,
1114  4,
1115  0,
1116  eEncodingUint,
1117  eFormatHex,
1119  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1120  nullptr,
1121  nullptr,
1122  nullptr,
1123  0},
1124  {"r9_fiq",
1125  nullptr,
1126  4,
1127  0,
1128  eEncodingUint,
1129  eFormatHex,
1131  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1132  nullptr,
1133  nullptr,
1134  nullptr,
1135  0},
1136  {"r10_fiq",
1137  nullptr,
1138  4,
1139  0,
1140  eEncodingUint,
1141  eFormatHex,
1143  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1144  nullptr,
1145  nullptr,
1146  nullptr,
1147  0},
1148  {"r11_fiq",
1149  nullptr,
1150  4,
1151  0,
1152  eEncodingUint,
1153  eFormatHex,
1155  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1156  nullptr,
1157  nullptr,
1158  nullptr,
1159  0},
1160  {"r12_fiq",
1161  nullptr,
1162  4,
1163  0,
1164  eEncodingUint,
1165  eFormatHex,
1167  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1168  nullptr,
1169  nullptr,
1170  nullptr,
1171  0},
1172  {"r13_fiq",
1173  "sp_fiq",
1174  4,
1175  0,
1176  eEncodingUint,
1177  eFormatHex,
1179  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1180  nullptr,
1181  nullptr,
1182  nullptr,
1183  0},
1184  {"r14_fiq",
1185  "lr_fiq",
1186  4,
1187  0,
1188  eEncodingUint,
1189  eFormatHex,
1191  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1192  nullptr,
1193  nullptr,
1194  nullptr,
1195  0},
1196  {"r13_irq",
1197  "sp_irq",
1198  4,
1199  0,
1200  eEncodingUint,
1201  eFormatHex,
1203  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1204  nullptr,
1205  nullptr,
1206  nullptr,
1207  0},
1208  {"r14_irq",
1209  "lr_irq",
1210  4,
1211  0,
1212  eEncodingUint,
1213  eFormatHex,
1215  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1216  nullptr,
1217  nullptr,
1218  nullptr,
1219  0},
1220  {"r13_abt",
1221  "sp_abt",
1222  4,
1223  0,
1224  eEncodingUint,
1225  eFormatHex,
1227  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1228  nullptr,
1229  nullptr,
1230  nullptr,
1231  0},
1232  {"r14_abt",
1233  "lr_abt",
1234  4,
1235  0,
1236  eEncodingUint,
1237  eFormatHex,
1239  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1240  nullptr,
1241  nullptr,
1242  nullptr,
1243  0},
1244  {"r13_und",
1245  "sp_und",
1246  4,
1247  0,
1248  eEncodingUint,
1249  eFormatHex,
1251  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1252  nullptr,
1253  nullptr,
1254  nullptr,
1255  0},
1256  {"r14_und",
1257  "lr_und",
1258  4,
1259  0,
1260  eEncodingUint,
1261  eFormatHex,
1263  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1264  nullptr,
1265  nullptr,
1266  nullptr,
1267  0},
1268  {"r13_svc",
1269  "sp_svc",
1270  4,
1271  0,
1272  eEncodingUint,
1273  eFormatHex,
1275  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1276  nullptr,
1277  nullptr,
1278  nullptr,
1279  0},
1280  {"r14_svc",
1281  "lr_svc",
1282  4,
1283  0,
1284  eEncodingUint,
1285  eFormatHex,
1287  LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
1288  nullptr,
1289  nullptr,
1290  nullptr,
1291  0}};
1292 
1294  llvm::array_lengthof(g_register_infos);
1296 
1297 const lldb_private::RegisterInfo *
1299  // Make the C-string names and alt_names for the register infos into const
1300  // C-string values by having the ConstString unique the names in the global
1301  // constant C-string pool.
1304  for (uint32_t i = 0; i < k_num_register_infos; ++i) {
1305  if (g_register_infos[i].name)
1306  g_register_infos[i].name =
1308  if (g_register_infos[i].alt_name)
1309  g_register_infos[i].alt_name =
1310  ConstString(g_register_infos[i].alt_name).GetCString();
1311  }
1312  }
1313  count = k_num_register_infos;
1314  return g_register_infos;
1315 }
1316 
1317 size_t ABIMacOSX_arm::GetRedZoneSize() const { return 0; }
1318 
1319 // Static Functions
1320 
1321 ABISP
1322 ABIMacOSX_arm::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
1323  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
1324  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
1325 
1326  if (vendor_type == llvm::Triple::Apple) {
1327  if ((arch_type == llvm::Triple::arm) ||
1328  (arch_type == llvm::Triple::thumb)) {
1329  return ABISP(new ABIMacOSX_arm(process_sp));
1330  }
1331  }
1332 
1333  return ABISP();
1334 }
1335 
1337  addr_t function_addr, addr_t return_addr,
1338  llvm::ArrayRef<addr_t> args) const {
1339  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1340  if (!reg_ctx)
1341  return false;
1342 
1343  const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1345  const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1347  const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1349 
1350  RegisterValue reg_value;
1351 
1352  const char *reg_names[] = {"r0", "r1", "r2", "r3"};
1353 
1354  llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
1355 
1356  for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i) {
1357  if (ai == ae)
1358  break;
1359 
1360  reg_value.SetUInt32(*ai);
1361  if (!reg_ctx->WriteRegister(reg_ctx->GetRegisterInfoByName(reg_names[i]),
1362  reg_value))
1363  return false;
1364 
1365  ++ai;
1366  }
1367 
1368  if (ai != ae) {
1369  // Spill onto the stack
1370  size_t num_stack_regs = ae - ai;
1371 
1372  sp -= (num_stack_regs * 4);
1373  // Keep the stack 16 byte aligned
1374  sp &= ~(16ull - 1ull);
1375 
1376  // just using arg1 to get the right size
1377  const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
1379 
1380  addr_t arg_pos = sp;
1381 
1382  for (; ai != ae; ++ai) {
1383  reg_value.SetUInt32(*ai);
1384  if (reg_ctx
1385  ->WriteRegisterValueToMemory(reg_info, arg_pos,
1386  reg_info->byte_size, reg_value)
1387  .Fail())
1388  return false;
1389  arg_pos += reg_info->byte_size;
1390  }
1391  }
1392 
1393  TargetSP target_sp(thread.CalculateTarget());
1394  Address so_addr;
1395 
1396  // Figure out if our return address is ARM or Thumb by using the
1397  // Address::GetCallableLoadAddress(Target*) which will figure out the ARM
1398  // thumb-ness and set the correct address bits for us.
1399  so_addr.SetLoadAddress(return_addr, target_sp.get());
1400  return_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1401 
1402  // Set "lr" to the return address
1403  if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_num, return_addr))
1404  return false;
1405 
1406  // If bit zero or 1 is set, this must be a thumb function, no need to figure
1407  // this out from the symbols.
1408  so_addr.SetLoadAddress(function_addr, target_sp.get());
1409  function_addr = so_addr.GetCallableLoadAddress(target_sp.get());
1410 
1411  const RegisterInfo *cpsr_reg_info = reg_ctx->GetRegisterInfoByName("cpsr");
1412  const uint32_t curr_cpsr = reg_ctx->ReadRegisterAsUnsigned(cpsr_reg_info, 0);
1413 
1414  // Make a new CPSR and mask out any Thumb IT (if/then) bits
1415  uint32_t new_cpsr = curr_cpsr & ~MASK_CPSR_IT_MASK;
1416  // If bit zero or 1 is set, this must be thumb...
1417  if (function_addr & 1ull)
1418  new_cpsr |= MASK_CPSR_T; // Set T bit in CPSR
1419  else
1420  new_cpsr &= ~MASK_CPSR_T; // Clear T bit in CPSR
1421 
1422  if (new_cpsr != curr_cpsr) {
1423  if (!reg_ctx->WriteRegisterFromUnsigned(cpsr_reg_info, new_cpsr))
1424  return false;
1425  }
1426 
1427  function_addr &=
1428  ~1ull; // clear bit zero since the CPSR will take care of the mode for us
1429 
1430  // Update the sp - stack pointer - to be aligned to 16-bytes
1431  sp &= ~(0xfull);
1432  if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_num, sp))
1433  return false;
1434 
1435  // Set "pc" to the address requested
1436  if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr))
1437  return false;
1438 
1439  return true;
1440 }
1441 
1442 bool ABIMacOSX_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
1443  uint32_t num_values = values.GetSize();
1444 
1445  ExecutionContext exe_ctx(thread.shared_from_this());
1446  // For now, assume that the types in the AST values come from the Target's
1447  // scratch AST.
1448 
1449  // Extract the register context so we can read arguments from registers
1450 
1451  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1452 
1453  if (!reg_ctx)
1454  return false;
1455 
1456  addr_t sp = 0;
1457 
1458  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
1459  // We currently only support extracting values with Clang QualTypes. Do we
1460  // care about others?
1461  Value *value = values.GetValueAtIndex(value_idx);
1462 
1463  if (!value)
1464  return false;
1465 
1466  CompilerType compiler_type = value->GetCompilerType();
1467  if (compiler_type) {
1468  bool is_signed = false;
1469  size_t bit_width = 0;
1470  llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
1471  if (!bit_size)
1472  return false;
1473  if (compiler_type.IsIntegerOrEnumerationType(is_signed))
1474  bit_width = *bit_size;
1475  else if (compiler_type.IsPointerOrReferenceType())
1476  bit_width = *bit_size;
1477  else
1478  // We only handle integer, pointer and reference types currently...
1479  return false;
1480 
1481  if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
1482  if (value_idx < 4) {
1483  // Arguments 1-4 are in r0-r3...
1484  const RegisterInfo *arg_reg_info = nullptr;
1485  // Search by generic ID first, then fall back to by name
1486  uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
1488  if (arg_reg_num != LLDB_INVALID_REGNUM) {
1489  arg_reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
1490  } else {
1491  switch (value_idx) {
1492  case 0:
1493  arg_reg_info = reg_ctx->GetRegisterInfoByName("r0");
1494  break;
1495  case 1:
1496  arg_reg_info = reg_ctx->GetRegisterInfoByName("r1");
1497  break;
1498  case 2:
1499  arg_reg_info = reg_ctx->GetRegisterInfoByName("r2");
1500  break;
1501  case 3:
1502  arg_reg_info = reg_ctx->GetRegisterInfoByName("r3");
1503  break;
1504  }
1505  }
1506 
1507  if (arg_reg_info) {
1508  RegisterValue reg_value;
1509 
1510  if (reg_ctx->ReadRegister(arg_reg_info, reg_value)) {
1511  if (is_signed)
1512  reg_value.SignExtend(bit_width);
1513  if (!reg_value.GetScalarValue(value->GetScalar()))
1514  return false;
1515  continue;
1516  }
1517  }
1518  return false;
1519  } else {
1520  if (sp == 0) {
1521  // Read the stack pointer if it already hasn't been read
1522  sp = reg_ctx->GetSP(0);
1523  if (sp == 0)
1524  return false;
1525  }
1526 
1527  // Arguments 5 on up are on the stack
1528  const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
1529  Status error;
1530  if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
1531  sp, arg_byte_size, is_signed, value->GetScalar(), error))
1532  return false;
1533 
1534  sp += arg_byte_size;
1535  }
1536  }
1537  }
1538  }
1539  return true;
1540 }
1541 
1543  bool is_armv7k = false;
1544  ProcessSP process_sp(GetProcessSP());
1545  if (process_sp) {
1546  const ArchSpec &arch(process_sp->GetTarget().GetArchitecture());
1547  const ArchSpec::Core system_core = arch.GetCore();
1548  if (system_core == ArchSpec::eCore_arm_armv7k) {
1549  is_armv7k = true;
1550  }
1551  }
1552  return is_armv7k;
1553 }
1554 
1556  Thread &thread, lldb_private::CompilerType &compiler_type) const {
1557  Value value;
1558  ValueObjectSP return_valobj_sp;
1559 
1560  if (!compiler_type)
1561  return return_valobj_sp;
1562 
1563  value.SetCompilerType(compiler_type);
1564 
1565  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
1566  if (!reg_ctx)
1567  return return_valobj_sp;
1568 
1569  bool is_signed;
1570 
1571  // Get the pointer to the first stack argument so we have a place to start
1572  // when reading data
1573 
1574  const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1575  if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
1576  llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
1577  if (!bit_width)
1578  return return_valobj_sp;
1579 
1580  switch (*bit_width) {
1581  default:
1582  return return_valobj_sp;
1583  case 128:
1584  if (IsArmv7kProcess()) {
1585  // "A composite type not larger than 16 bytes is returned in r0-r3. The
1586  // format is as if the result had been stored in memory at a word-
1587  // aligned address and then loaded into r0-r3 with an ldm instruction"
1588  {
1589  const RegisterInfo *r1_reg_info =
1590  reg_ctx->GetRegisterInfoByName("r1", 0);
1591  const RegisterInfo *r2_reg_info =
1592  reg_ctx->GetRegisterInfoByName("r2", 0);
1593  const RegisterInfo *r3_reg_info =
1594  reg_ctx->GetRegisterInfoByName("r3", 0);
1595  if (r1_reg_info && r2_reg_info && r3_reg_info) {
1596  llvm::Optional<uint64_t> byte_size =
1597  compiler_type.GetByteSize(&thread);
1598  if (!byte_size)
1599  return return_valobj_sp;
1600  ProcessSP process_sp(thread.GetProcess());
1601  if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
1602  r2_reg_info->byte_size +
1603  r3_reg_info->byte_size &&
1604  process_sp) {
1605  std::unique_ptr<DataBufferHeap> heap_data_up(
1606  new DataBufferHeap(*byte_size, 0));
1607  const ByteOrder byte_order = process_sp->GetByteOrder();
1608  RegisterValue r0_reg_value;
1609  RegisterValue r1_reg_value;
1610  RegisterValue r2_reg_value;
1611  RegisterValue r3_reg_value;
1612  if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
1613  reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
1614  reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&
1615  reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) {
1616  Status error;
1617  if (r0_reg_value.GetAsMemoryData(r0_reg_info,
1618  heap_data_up->GetBytes() + 0,
1619  4, byte_order, error) &&
1620  r1_reg_value.GetAsMemoryData(r1_reg_info,
1621  heap_data_up->GetBytes() + 4,
1622  4, byte_order, error) &&
1623  r2_reg_value.GetAsMemoryData(r2_reg_info,
1624  heap_data_up->GetBytes() + 8,
1625  4, byte_order, error) &&
1626  r3_reg_value.GetAsMemoryData(r3_reg_info,
1627  heap_data_up->GetBytes() + 12,
1628  4, byte_order, error)) {
1629  DataExtractor data(DataBufferSP(heap_data_up.release()),
1630  byte_order,
1631  process_sp->GetAddressByteSize());
1632 
1633  return_valobj_sp = ValueObjectConstResult::Create(
1634  &thread, compiler_type, ConstString(""), data);
1635  return return_valobj_sp;
1636  }
1637  }
1638  }
1639  }
1640  }
1641  } else {
1642  return return_valobj_sp;
1643  }
1644  break;
1645  case 64: {
1646  const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1647  uint64_t raw_value;
1648  raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
1649  raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) &
1650  UINT32_MAX))
1651  << 32;
1652  if (is_signed)
1653  value.GetScalar() = (int64_t)raw_value;
1654  else
1655  value.GetScalar() = (uint64_t)raw_value;
1656  } break;
1657  case 32:
1658  if (is_signed)
1659  value.GetScalar() = (int32_t)(
1660  reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1661  else
1662  value.GetScalar() = (uint32_t)(
1663  reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX);
1664  break;
1665  case 16:
1666  if (is_signed)
1667  value.GetScalar() = (int16_t)(
1668  reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1669  else
1670  value.GetScalar() = (uint16_t)(
1671  reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT16_MAX);
1672  break;
1673  case 8:
1674  if (is_signed)
1675  value.GetScalar() = (int8_t)(
1676  reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1677  else
1678  value.GetScalar() = (uint8_t)(
1679  reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
1680  break;
1681  }
1682  } else if (compiler_type.IsPointerType()) {
1683  uint32_t ptr =
1684  thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
1685  UINT32_MAX;
1686  value.GetScalar() = ptr;
1687  } else {
1688  // not handled yet
1689  return return_valobj_sp;
1690  }
1691 
1692  // If we get here, we have a valid Value, so make our ValueObject out of it:
1693 
1694  return_valobj_sp = ValueObjectConstResult::Create(
1695  thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
1696  return return_valobj_sp;
1697 }
1698 
1699 Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
1700  lldb::ValueObjectSP &new_value_sp) {
1701  Status error;
1702  if (!new_value_sp) {
1703  error.SetErrorString("Empty value object for return value.");
1704  return error;
1705  }
1706 
1707  CompilerType compiler_type = new_value_sp->GetCompilerType();
1708  if (!compiler_type) {
1709  error.SetErrorString("Null clang type for return value.");
1710  return error;
1711  }
1712 
1713  Thread *thread = frame_sp->GetThread().get();
1714 
1715  bool is_signed;
1716  uint32_t count;
1717  bool is_complex;
1718 
1719  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
1720 
1721  bool set_it_simple = false;
1722  if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
1723  compiler_type.IsPointerType()) {
1724  DataExtractor data;
1725  Status data_error;
1726  size_t num_bytes = new_value_sp->GetData(data, data_error);
1727  if (data_error.Fail()) {
1729  "Couldn't convert return value to raw data: %s",
1730  data_error.AsCString());
1731  return error;
1732  }
1733  lldb::offset_t offset = 0;
1734  if (num_bytes <= 8) {
1735  const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1736  if (num_bytes <= 4) {
1737  uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
1738 
1739  if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value))
1740  set_it_simple = true;
1741  } else {
1742  uint32_t raw_value = data.GetMaxU32(&offset, 4);
1743 
1744  if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value)) {
1745  const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1746  uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
1747 
1748  if (reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value))
1749  set_it_simple = true;
1750  }
1751  }
1752  } else if (num_bytes <= 16 && IsArmv7kProcess()) {
1753  // "A composite type not larger than 16 bytes is returned in r0-r3. The
1754  // format is as if the result had been stored in memory at a word-aligned
1755  // address and then loaded into r0-r3 with an ldm instruction"
1756 
1757  const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("r0", 0);
1758  const RegisterInfo *r1_info = reg_ctx->GetRegisterInfoByName("r1", 0);
1759  const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
1760  const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
1761  lldb::offset_t offset = 0;
1762  uint32_t bytes_written = 4;
1763  uint32_t raw_value = data.GetMaxU64(&offset, 4);
1764  if (reg_ctx->WriteRegisterFromUnsigned(r0_info, raw_value) &&
1765  bytes_written <= num_bytes) {
1766  bytes_written += 4;
1767  raw_value = data.GetMaxU64(&offset, 4);
1768  if (bytes_written <= num_bytes &&
1769  reg_ctx->WriteRegisterFromUnsigned(r1_info, raw_value)) {
1770  bytes_written += 4;
1771  raw_value = data.GetMaxU64(&offset, 4);
1772  if (bytes_written <= num_bytes &&
1773  reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) {
1774  bytes_written += 4;
1775  raw_value = data.GetMaxU64(&offset, 4);
1776  if (bytes_written <= num_bytes &&
1777  reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value)) {
1778  set_it_simple = true;
1779  }
1780  }
1781  }
1782  }
1783  } else {
1784  error.SetErrorString("We don't support returning longer than 64 bit "
1785  "integer values at present.");
1786  }
1787  } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
1788  if (is_complex)
1789  error.SetErrorString(
1790  "We don't support returning complex values at present");
1791  else
1792  error.SetErrorString(
1793  "We don't support returning float values at present");
1794  }
1795 
1796  if (!set_it_simple)
1797  error.SetErrorString(
1798  "We only support setting simple integer return types at present.");
1799 
1800  return error;
1801 }
1802 
1804  unwind_plan.Clear();
1805  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1806 
1807  uint32_t lr_reg_num = dwarf_lr;
1808  uint32_t sp_reg_num = dwarf_sp;
1809  uint32_t pc_reg_num = dwarf_pc;
1810 
1812 
1813  // Our Call Frame Address is the stack pointer value
1814  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
1815 
1816  // The previous PC is in the LR
1817  row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
1818  unwind_plan.AppendRow(row);
1819 
1820  // All other registers are the same.
1821 
1822  unwind_plan.SetSourceName("arm at-func-entry default");
1823  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1824 
1825  return true;
1826 }
1827 
1829  unwind_plan.Clear();
1830  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
1831 
1832  uint32_t fp_reg_num =
1833  dwarf_r7; // apple uses r7 for all frames. Normal arm uses r11
1834  uint32_t pc_reg_num = dwarf_pc;
1835 
1837  const int32_t ptr_size = 4;
1838 
1839  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
1840  row->SetOffset(0);
1841 
1842  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1843  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1844 
1845  unwind_plan.AppendRow(row);
1846  unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
1847  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
1849 
1850  return true;
1851 }
1852 
1853 // cf. "ARMv6 Function Calling Conventions"
1854 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
1855 // and "ARMv7 Function Calling Conventions"
1856 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html
1857 
1858 // ARMv7 on iOS general purpose reg rules:
1859 // r0-r3 not preserved (used for argument passing)
1860 // r4-r6 preserved
1861 // r7 preserved (frame pointer)
1862 // r8 preserved
1863 // r9 not preserved (usable as volatile scratch register with iOS 3.x and
1864 // later)
1865 // r10-r11 preserved
1866 // r12 not presrved
1867 // r13 preserved (stack pointer)
1868 // r14 not preserved (link register)
1869 // r15 preserved (pc)
1870 // cpsr not preserved (different rules for different bits)
1871 
1872 // ARMv7 on iOS floating point rules:
1873 // d0-d7 not preserved (aka s0-s15, q0-q3)
1874 // d8-d15 preserved (aka s16-s31, q4-q7)
1875 // d16-d31 not preserved (aka q8-q15)
1876 
1877 bool ABIMacOSX_arm::RegisterIsVolatile(const RegisterInfo *reg_info) {
1878  if (reg_info) {
1879  // Volatile registers are: r0, r1, r2, r3, r9, r12, r13 (aka sp)
1880  const char *name = reg_info->name;
1881  if (name[0] == 'r') {
1882  switch (name[1]) {
1883  case '0':
1884  return name[2] == '\0'; // r0
1885  case '1':
1886  switch (name[2]) {
1887  case '\0':
1888  return true; // r1
1889  case '2':
1890  case '3':
1891  return name[3] == '\0'; // r12, r13 (sp)
1892  default:
1893  break;
1894  }
1895  break;
1896 
1897  case '2':
1898  return name[2] == '\0'; // r2
1899  case '3':
1900  return name[2] == '\0'; // r3
1901  case '9':
1902  return name[2] == '\0'; // r9 (apple-ios only...)
1903 
1904  break;
1905  }
1906  } else if (name[0] == 'd') {
1907  switch (name[1]) {
1908  case '0':
1909  return name[2] == '\0'; // d0 is volatile
1910 
1911  case '1':
1912  switch (name[2]) {
1913  case '\0':
1914  return true; // d1 is volatile
1915  case '6':
1916  case '7':
1917  case '8':
1918  case '9':
1919  return name[3] == '\0'; // d16 - d19 are volatile
1920  default:
1921  break;
1922  }
1923  break;
1924 
1925  case '2':
1926  switch (name[2]) {
1927  case '\0':
1928  return true; // d2 is volatile
1929  case '0':
1930  case '1':
1931  case '2':
1932  case '3':
1933  case '4':
1934  case '5':
1935  case '6':
1936  case '7':
1937  case '8':
1938  case '9':
1939  return name[3] == '\0'; // d20 - d29 are volatile
1940  default:
1941  break;
1942  }
1943  break;
1944 
1945  case '3':
1946  switch (name[2]) {
1947  case '\0':
1948  return true; // d3 is volatile
1949  case '0':
1950  case '1':
1951  return name[3] == '\0'; // d30 - d31 are volatile
1952  default:
1953  break;
1954  }
1955  break;
1956  case '4':
1957  case '5':
1958  case '6':
1959  case '7':
1960  return name[2] == '\0'; // d4 - d7 are volatile
1961 
1962  default:
1963  break;
1964  }
1965  } else if (name[0] == 's') {
1966  switch (name[1]) {
1967  case '0':
1968  return name[2] == '\0'; // s0 is volatile
1969 
1970  case '1':
1971  switch (name[2]) {
1972  case '\0':
1973  return true; // s1 is volatile
1974  case '0':
1975  case '1':
1976  case '2':
1977  case '3':
1978  case '4':
1979  case '5':
1980  return name[3] == '\0'; // s10 - s15 are volatile
1981  default:
1982  break;
1983  }
1984  break;
1985 
1986  case '2':
1987  case '3':
1988  case '4':
1989  case '5':
1990  case '6':
1991  case '7':
1992  case '8':
1993  case '9':
1994  return name[2] == '\0'; // s2 - s9 are volatile
1995 
1996  default:
1997  break;
1998  }
1999  } else if (name[0] == 'q') {
2000  switch (name[1]) {
2001  case '1':
2002  switch (name[2]) {
2003  case '\0':
2004  return true; // q1 is volatile
2005  case '0':
2006  case '1':
2007  case '2':
2008  case '3':
2009  case '4':
2010  case '5':
2011  return true; // q10-q15 are volatile
2012  default:
2013  break;
2014  };
2015  break;
2016  case '0':
2017  case '2':
2018  case '3':
2019  return name[2] == '\0'; // q0-q3 are volatile
2020  case '8':
2021  case '9':
2022  return name[2] == '\0'; // q8-q9 are volatile
2023  default:
2024  break;
2025  }
2026  } else if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')
2027  return true;
2028  }
2029  return false;
2030 }
2031 
2033  PluginManager::RegisterPlugin(GetPluginNameStatic(),
2034  "Mac OS X ABI for arm targets", CreateInstance);
2035 }
2036 
2038  PluginManager::UnregisterPlugin(CreateInstance);
2039 }
2040 
2042  static ConstString g_name("macosx-arm");
2043  return g_name;
2044 }
2045 
2046 // PluginInterface protocol
2047 
2049  return GetPluginNameStatic();
2050 }
2051 
uint32_t GetPluginVersion() override
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:63
An data extractor class.
Definition: DataExtractor.h:47
Core GetCore() const
Definition: ArchSpec.h:410
static void Terminate()
void SetSourceName(const char *)
Definition: UnwindPlan.cpp:542
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
bool IsPointerOrReferenceType(CompilerType *pointee_type=nullptr) const
static void Initialize()
#define LLDB_REGNUM_GENERIC_RA
Definition: lldb-defines.h:66
uint64_t ReadRegisterAsUnsigned(uint32_t reg, uint64_t fail_value)
static lldb_private::ConstString GetPluginNameStatic()
#define MASK_CPSR_IT_MASK
Definition: ARMDefines.h:174
#define LLDB_REGNUM_GENERIC_ARG4
Definition: lldb-defines.h:74
uint32_t GetAsMemoryData(const RegisterInfo *reg_info, void *dst, uint32_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
bool IsIntegerOrEnumerationType(bool &is_signed) const
virtual uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num)=0
Convert from a given register numbering scheme to the lldb register numbering scheme.
An architecture specification class.
Definition: ArchSpec.h:32
#define LLDB_REGNUM_GENERIC_ARG2
Definition: lldb-defines.h:70
bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp, lldb::addr_t func_addr, lldb::addr_t returnAddress, llvm::ArrayRef< lldb::addr_t > args) const override
virtual bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)=0
Value * GetValueAtIndex(size_t idx)
Definition: Value.cpp:701
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
lldb_private::ConstString GetPluginName() override
size_t GetRedZoneSize() const override
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:64
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:998
llvm::Optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
A subclass of DataBuffer that stores a data buffer on the heap.
#define LLDB_REGNUM_GENERIC_ARG1
Definition: lldb-defines.h:68
bool IsPointerType(CompilerType *pointee_type=nullptr) const
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
static const uint32_t k_num_register_infos
const lldb_private::RegisterInfo * GetRegisterInfoArray(uint32_t &count) override
#define LLDB_REGNUM_GENERIC_FP
Definition: lldb-defines.h:65
#define UINT32_MAX
Definition: lldb-defines.h:31
bool IsFloatingPointType(uint32_t &count, bool &is_complex) const
bool CreateDefaultUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
static bool g_register_info_names_constified
uint64_t offset_t
Definition: lldb-types.h:87
std::shared_ptr< Row > RowSP
Definition: UnwindPlan.h:366
void AppendRow(const RowSP &row_sp)
Definition: UnwindPlan.cpp:355
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1584
static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch)
virtual lldb::RegisterContextSP GetRegisterContext()=0
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
bool GetArgumentValues(lldb_private::Thread &thread, lldb_private::ValueList &values) const override
virtual bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)=0
#define LLDB_REGNUM_GENERIC_FLAGS
Definition: lldb-defines.h:67
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
const CompilerType & GetCompilerType()
Definition: Value.cpp:239
void SetRegisterKind(lldb::RegisterKind kind)
Definition: UnwindPlan.h:408
A section + offset based address class.
Definition: Address.h:80
void SetUInt32(uint32_t uint, Type t=eTypeUInt32)
bool WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval)
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
static RegisterInfo g_register_infos[]
const RegisterInfo * GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num)
void SetUnwindPlanValidAtAllInstructions(lldb_private::LazyBool valid_at_all_insn)
Definition: UnwindPlan.h:461
bool CreateFunctionEntryUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override
uint64_t addr_t
Definition: lldb-types.h:83
A uniqued constant string class.
Definition: ConstString.h:38
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:247
llvm::Optional< uint64_t > GetBitSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bits.
uint32_t GetMaxU32(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an integer of size byte_size from *offset_ptr.
#define LLDB_REGNUM_GENERIC_ARG3
Definition: lldb-defines.h:72
Definition: SBAddress.h:15
lldb_private::Status SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value) override
bool GetScalarValue(Scalar &scalar) const
lldb::ValueObjectSP GetReturnValueObjectImpl(lldb_private::Thread &thread, lldb_private::CompilerType &ast_type) const override
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
void SetCompilerType(const CompilerType &compiler_type)
Definition: Value.cpp:268
#define MASK_CPSR_T
Definition: ARMDefines.h:175
bool SignExtend(uint32_t sign_bitpos)
const Scalar & GetScalar() const
Definition: Value.h:178
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:395
bool RegisterIsVolatile(const lldb_private::RegisterInfo *reg_info) override
bool IsArmv7kProcess() const
void SetSourcedFromCompiler(lldb_private::LazyBool from_compiler)
Definition: UnwindPlan.h:449
An error handling class.
Definition: Status.h:44
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:90