Line data Source code
1 : //===--- ARMAttributeParser.cpp - ARM Attribute Information Printer -------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 :
10 : #include "llvm/Support/ARMAttributeParser.h"
11 : #include "llvm/ADT/STLExtras.h"
12 : #include "llvm/ADT/StringExtras.h"
13 : #include "llvm/Support/LEB128.h"
14 : #include "llvm/Support/ScopedPrinter.h"
15 :
16 : using namespace llvm;
17 : using namespace llvm::ARMBuildAttrs;
18 :
19 :
20 : static const EnumEntry<unsigned> TagNames[] = {
21 : { "Tag_File", ARMBuildAttrs::File },
22 : { "Tag_Section", ARMBuildAttrs::Section },
23 : { "Tag_Symbol", ARMBuildAttrs::Symbol },
24 : };
25 :
26 : namespace llvm {
27 : #define ATTRIBUTE_HANDLER(Attr_) \
28 : { ARMBuildAttrs::Attr_, &ARMAttributeParser::Attr_ }
29 :
30 : const ARMAttributeParser::DisplayHandler
31 : ARMAttributeParser::DisplayRoutines[] = {
32 : { ARMBuildAttrs::CPU_raw_name, &ARMAttributeParser::StringAttribute, },
33 : { ARMBuildAttrs::CPU_name, &ARMAttributeParser::StringAttribute },
34 : ATTRIBUTE_HANDLER(CPU_arch),
35 : ATTRIBUTE_HANDLER(CPU_arch_profile),
36 : ATTRIBUTE_HANDLER(ARM_ISA_use),
37 : ATTRIBUTE_HANDLER(THUMB_ISA_use),
38 : ATTRIBUTE_HANDLER(FP_arch),
39 : ATTRIBUTE_HANDLER(WMMX_arch),
40 : ATTRIBUTE_HANDLER(Advanced_SIMD_arch),
41 : ATTRIBUTE_HANDLER(PCS_config),
42 : ATTRIBUTE_HANDLER(ABI_PCS_R9_use),
43 : ATTRIBUTE_HANDLER(ABI_PCS_RW_data),
44 : ATTRIBUTE_HANDLER(ABI_PCS_RO_data),
45 : ATTRIBUTE_HANDLER(ABI_PCS_GOT_use),
46 : ATTRIBUTE_HANDLER(ABI_PCS_wchar_t),
47 : ATTRIBUTE_HANDLER(ABI_FP_rounding),
48 : ATTRIBUTE_HANDLER(ABI_FP_denormal),
49 : ATTRIBUTE_HANDLER(ABI_FP_exceptions),
50 : ATTRIBUTE_HANDLER(ABI_FP_user_exceptions),
51 : ATTRIBUTE_HANDLER(ABI_FP_number_model),
52 : ATTRIBUTE_HANDLER(ABI_align_needed),
53 : ATTRIBUTE_HANDLER(ABI_align_preserved),
54 : ATTRIBUTE_HANDLER(ABI_enum_size),
55 : ATTRIBUTE_HANDLER(ABI_HardFP_use),
56 : ATTRIBUTE_HANDLER(ABI_VFP_args),
57 : ATTRIBUTE_HANDLER(ABI_WMMX_args),
58 : ATTRIBUTE_HANDLER(ABI_optimization_goals),
59 : ATTRIBUTE_HANDLER(ABI_FP_optimization_goals),
60 : ATTRIBUTE_HANDLER(compatibility),
61 : ATTRIBUTE_HANDLER(CPU_unaligned_access),
62 : ATTRIBUTE_HANDLER(FP_HP_extension),
63 : ATTRIBUTE_HANDLER(ABI_FP_16bit_format),
64 : ATTRIBUTE_HANDLER(MPextension_use),
65 : ATTRIBUTE_HANDLER(DIV_use),
66 : ATTRIBUTE_HANDLER(DSP_extension),
67 : ATTRIBUTE_HANDLER(T2EE_use),
68 : ATTRIBUTE_HANDLER(Virtualization_use),
69 : ATTRIBUTE_HANDLER(nodefaults)
70 : };
71 :
72 : #undef ATTRIBUTE_HANDLER
73 :
74 2742 : uint64_t ARMAttributeParser::ParseInteger(const uint8_t *Data,
75 : uint32_t &Offset) {
76 : unsigned Length;
77 2742 : uint64_t Value = decodeULEB128(Data + Offset, &Length);
78 2742 : Offset = Offset + Length;
79 2742 : return Value;
80 : }
81 :
82 189 : StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
83 : uint32_t &Offset) {
84 189 : const char *String = reinterpret_cast<const char*>(Data + Offset);
85 189 : size_t Length = std::strlen(String);
86 189 : Offset = Offset + Length + 1;
87 189 : return StringRef(String, Length);
88 : }
89 :
90 0 : void ARMAttributeParser::IntegerAttribute(AttrType Tag, const uint8_t *Data,
91 : uint32_t &Offset) {
92 :
93 0 : uint64_t Value = ParseInteger(Data, Offset);
94 0 : Attributes.insert(std::make_pair(Tag, Value));
95 :
96 0 : if (SW)
97 0 : SW->printNumber(ARMBuildAttrs::AttrTypeAsString(Tag), Value);
98 0 : }
99 :
100 182 : void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
101 : uint32_t &Offset) {
102 182 : StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
103 182 : StringRef ValueDesc = ParseString(Data, Offset);
104 :
105 182 : if (SW) {
106 72 : DictScope AS(*SW, "Attribute");
107 144 : SW->printNumber("Tag", Tag);
108 72 : if (!TagName.empty())
109 144 : SW->printString("TagName", TagName);
110 144 : SW->printString("Value", ValueDesc);
111 : }
112 182 : }
113 :
114 2735 : void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
115 : StringRef ValueDesc) {
116 2735 : Attributes.insert(std::make_pair(Tag, Value));
117 :
118 2735 : if (SW) {
119 : StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag,
120 649 : /*TagPrefix*/false);
121 1298 : DictScope AS(*SW, "Attribute");
122 1298 : SW->printNumber("Tag", Tag);
123 1298 : SW->printNumber("Value", Value);
124 649 : if (!TagName.empty())
125 1298 : SW->printString("TagName", TagName);
126 649 : if (!ValueDesc.empty())
127 1298 : SW->printString("Description", ValueDesc);
128 : }
129 2735 : }
130 :
131 304 : void ARMAttributeParser::CPU_arch(AttrType Tag, const uint8_t *Data,
132 : uint32_t &Offset) {
133 : static const char *const Strings[] = {
134 : "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
135 : "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
136 : "ARM v7E-M", "ARM v8"
137 : };
138 :
139 304 : uint64_t Value = ParseInteger(Data, Offset);
140 : StringRef ValueDesc =
141 304 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
142 304 : PrintAttribute(Tag, Value, ValueDesc);
143 304 : }
144 :
145 233 : void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
146 : uint32_t &Offset) {
147 233 : uint64_t Encoded = ParseInteger(Data, Offset);
148 :
149 233 : StringRef Profile;
150 233 : switch (Encoded) {
151 0 : default: Profile = "Unknown"; break;
152 211 : case 'A': Profile = "Application"; break;
153 8 : case 'R': Profile = "Real-time"; break;
154 11 : case 'M': Profile = "Microcontroller"; break;
155 2 : case 'S': Profile = "Classic"; break;
156 1 : case 0: Profile = "None"; break;
157 : }
158 :
159 233 : PrintAttribute(Tag, Encoded, Profile);
160 233 : }
161 :
162 262 : void ARMAttributeParser::ARM_ISA_use(AttrType Tag, const uint8_t *Data,
163 : uint32_t &Offset) {
164 : static const char *const Strings[] = { "Not Permitted", "Permitted" };
165 :
166 262 : uint64_t Value = ParseInteger(Data, Offset);
167 : StringRef ValueDesc =
168 262 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
169 262 : PrintAttribute(Tag, Value, ValueDesc);
170 262 : }
171 :
172 264 : void ARMAttributeParser::THUMB_ISA_use(AttrType Tag, const uint8_t *Data,
173 : uint32_t &Offset) {
174 : static const char *const Strings[] = { "Not Permitted", "Thumb-1", "Thumb-2" };
175 :
176 264 : uint64_t Value = ParseInteger(Data, Offset);
177 : StringRef ValueDesc =
178 264 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
179 264 : PrintAttribute(Tag, Value, ValueDesc);
180 264 : }
181 :
182 196 : void ARMAttributeParser::FP_arch(AttrType Tag, const uint8_t *Data,
183 : uint32_t &Offset) {
184 : static const char *const Strings[] = {
185 : "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4",
186 : "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"
187 : };
188 :
189 196 : uint64_t Value = ParseInteger(Data, Offset);
190 : StringRef ValueDesc =
191 196 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
192 196 : PrintAttribute(Tag, Value, ValueDesc);
193 196 : }
194 :
195 9 : void ARMAttributeParser::WMMX_arch(AttrType Tag, const uint8_t *Data,
196 : uint32_t &Offset) {
197 : static const char *const Strings[] = { "Not Permitted", "WMMXv1", "WMMXv2" };
198 :
199 9 : uint64_t Value = ParseInteger(Data, Offset);
200 : StringRef ValueDesc =
201 9 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
202 9 : PrintAttribute(Tag, Value, ValueDesc);
203 9 : }
204 :
205 174 : void ARMAttributeParser::Advanced_SIMD_arch(AttrType Tag, const uint8_t *Data,
206 : uint32_t &Offset) {
207 : static const char *const Strings[] = {
208 : "Not Permitted", "NEONv1", "NEONv2+FMA", "ARMv8-a NEON", "ARMv8.1-a NEON"
209 : };
210 :
211 174 : uint64_t Value = ParseInteger(Data, Offset);
212 : StringRef ValueDesc =
213 174 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
214 174 : PrintAttribute(Tag, Value, ValueDesc);
215 174 : }
216 :
217 17 : void ARMAttributeParser::PCS_config(AttrType Tag, const uint8_t *Data,
218 : uint32_t &Offset) {
219 : static const char *const Strings[] = {
220 : "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
221 : "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"
222 : };
223 :
224 17 : uint64_t Value = ParseInteger(Data, Offset);
225 : StringRef ValueDesc =
226 17 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
227 17 : PrintAttribute(Tag, Value, ValueDesc);
228 17 : }
229 :
230 58 : void ARMAttributeParser::ABI_PCS_R9_use(AttrType Tag, const uint8_t *Data,
231 : uint32_t &Offset) {
232 : static const char *const Strings[] = { "v6", "Static Base", "TLS", "Unused" };
233 :
234 58 : uint64_t Value = ParseInteger(Data, Offset);
235 : StringRef ValueDesc =
236 58 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
237 58 : PrintAttribute(Tag, Value, ValueDesc);
238 58 : }
239 :
240 18 : void ARMAttributeParser::ABI_PCS_RW_data(AttrType Tag, const uint8_t *Data,
241 : uint32_t &Offset) {
242 : static const char *const Strings[] = {
243 : "Absolute", "PC-relative", "SB-relative", "Not Permitted"
244 : };
245 :
246 18 : uint64_t Value = ParseInteger(Data, Offset);
247 : StringRef ValueDesc =
248 18 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
249 18 : PrintAttribute(Tag, Value, ValueDesc);
250 18 : }
251 :
252 16 : void ARMAttributeParser::ABI_PCS_RO_data(AttrType Tag, const uint8_t *Data,
253 : uint32_t &Offset) {
254 : static const char *const Strings[] = {
255 : "Absolute", "PC-relative", "Not Permitted"
256 : };
257 :
258 16 : uint64_t Value = ParseInteger(Data, Offset);
259 : StringRef ValueDesc =
260 16 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
261 16 : PrintAttribute(Tag, Value, ValueDesc);
262 16 : }
263 :
264 56 : void ARMAttributeParser::ABI_PCS_GOT_use(AttrType Tag, const uint8_t *Data,
265 : uint32_t &Offset) {
266 : static const char *const Strings[] = {
267 : "Not Permitted", "Direct", "GOT-Indirect"
268 : };
269 :
270 56 : uint64_t Value = ParseInteger(Data, Offset);
271 : StringRef ValueDesc =
272 56 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
273 56 : PrintAttribute(Tag, Value, ValueDesc);
274 56 : }
275 :
276 51 : void ARMAttributeParser::ABI_PCS_wchar_t(AttrType Tag, const uint8_t *Data,
277 : uint32_t &Offset) {
278 : static const char *const Strings[] = {
279 : "Not Permitted", "Unknown", "2-byte", "Unknown", "4-byte"
280 : };
281 :
282 51 : uint64_t Value = ParseInteger(Data, Offset);
283 : StringRef ValueDesc =
284 51 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
285 51 : PrintAttribute(Tag, Value, ValueDesc);
286 51 : }
287 :
288 5 : void ARMAttributeParser::ABI_FP_rounding(AttrType Tag, const uint8_t *Data,
289 : uint32_t &Offset) {
290 : static const char *const Strings[] = { "IEEE-754", "Runtime" };
291 :
292 5 : uint64_t Value = ParseInteger(Data, Offset);
293 : StringRef ValueDesc =
294 5 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
295 5 : PrintAttribute(Tag, Value, ValueDesc);
296 5 : }
297 :
298 91 : void ARMAttributeParser::ABI_FP_denormal(AttrType Tag, const uint8_t *Data,
299 : uint32_t &Offset) {
300 : static const char *const Strings[] = {
301 : "Unsupported", "IEEE-754", "Sign Only"
302 : };
303 :
304 91 : uint64_t Value = ParseInteger(Data, Offset);
305 : StringRef ValueDesc =
306 91 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
307 91 : PrintAttribute(Tag, Value, ValueDesc);
308 91 : }
309 :
310 89 : void ARMAttributeParser::ABI_FP_exceptions(AttrType Tag, const uint8_t *Data,
311 : uint32_t &Offset) {
312 : static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
313 :
314 89 : uint64_t Value = ParseInteger(Data, Offset);
315 : StringRef ValueDesc =
316 89 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
317 89 : PrintAttribute(Tag, Value, ValueDesc);
318 89 : }
319 :
320 5 : void ARMAttributeParser::ABI_FP_user_exceptions(AttrType Tag,
321 : const uint8_t *Data,
322 : uint32_t &Offset) {
323 : static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
324 :
325 5 : uint64_t Value = ParseInteger(Data, Offset);
326 : StringRef ValueDesc =
327 5 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
328 5 : PrintAttribute(Tag, Value, ValueDesc);
329 5 : }
330 :
331 93 : void ARMAttributeParser::ABI_FP_number_model(AttrType Tag, const uint8_t *Data,
332 : uint32_t &Offset) {
333 : static const char *const Strings[] = {
334 : "Not Permitted", "Finite Only", "RTABI", "IEEE-754"
335 : };
336 :
337 93 : uint64_t Value = ParseInteger(Data, Offset);
338 : StringRef ValueDesc =
339 93 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
340 93 : PrintAttribute(Tag, Value, ValueDesc);
341 93 : }
342 :
343 102 : void ARMAttributeParser::ABI_align_needed(AttrType Tag, const uint8_t *Data,
344 : uint32_t &Offset) {
345 : static const char *const Strings[] = {
346 : "Not Permitted", "8-byte alignment", "4-byte alignment", "Reserved"
347 : };
348 :
349 102 : uint64_t Value = ParseInteger(Data, Offset);
350 :
351 : std::string Description;
352 102 : if (Value < array_lengthof(Strings))
353 186 : Description = std::string(Strings[Value]);
354 9 : else if (Value <= 12)
355 18 : Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
356 36 : + std::string("-byte extended alignment");
357 : else
358 : Description = "Invalid";
359 :
360 102 : PrintAttribute(Tag, Value, Description);
361 102 : }
362 :
363 102 : void ARMAttributeParser::ABI_align_preserved(AttrType Tag, const uint8_t *Data,
364 : uint32_t &Offset) {
365 : static const char *const Strings[] = {
366 : "Not Required", "8-byte data alignment", "8-byte data and code alignment",
367 : "Reserved"
368 : };
369 :
370 102 : uint64_t Value = ParseInteger(Data, Offset);
371 :
372 : std::string Description;
373 102 : if (Value < array_lengthof(Strings))
374 186 : Description = std::string(Strings[Value]);
375 9 : else if (Value <= 12)
376 18 : Description = std::string("8-byte stack alignment, ") +
377 45 : utostr(1ULL << Value) + std::string("-byte data alignment");
378 : else
379 : Description = "Invalid";
380 :
381 102 : PrintAttribute(Tag, Value, Description);
382 102 : }
383 :
384 53 : void ARMAttributeParser::ABI_enum_size(AttrType Tag, const uint8_t *Data,
385 : uint32_t &Offset) {
386 : static const char *const Strings[] = {
387 : "Not Permitted", "Packed", "Int32", "External Int32"
388 : };
389 :
390 53 : uint64_t Value = ParseInteger(Data, Offset);
391 : StringRef ValueDesc =
392 53 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
393 53 : PrintAttribute(Tag, Value, ValueDesc);
394 53 : }
395 :
396 8 : void ARMAttributeParser::ABI_HardFP_use(AttrType Tag, const uint8_t *Data,
397 : uint32_t &Offset) {
398 : static const char *const Strings[] = {
399 : "Tag_FP_arch", "Single-Precision", "Reserved", "Tag_FP_arch (deprecated)"
400 : };
401 :
402 8 : uint64_t Value = ParseInteger(Data, Offset);
403 : StringRef ValueDesc =
404 8 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
405 8 : PrintAttribute(Tag, Value, ValueDesc);
406 8 : }
407 :
408 39 : void ARMAttributeParser::ABI_VFP_args(AttrType Tag, const uint8_t *Data,
409 : uint32_t &Offset) {
410 : static const char *const Strings[] = {
411 : "AAPCS", "AAPCS VFP", "Custom", "Not Permitted"
412 : };
413 :
414 39 : uint64_t Value = ParseInteger(Data, Offset);
415 : StringRef ValueDesc =
416 39 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
417 39 : PrintAttribute(Tag, Value, ValueDesc);
418 39 : }
419 :
420 7 : void ARMAttributeParser::ABI_WMMX_args(AttrType Tag, const uint8_t *Data,
421 : uint32_t &Offset) {
422 : static const char *const Strings[] = { "AAPCS", "iWMMX", "Custom" };
423 :
424 7 : uint64_t Value = ParseInteger(Data, Offset);
425 : StringRef ValueDesc =
426 7 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
427 7 : PrintAttribute(Tag, Value, ValueDesc);
428 7 : }
429 :
430 68 : void ARMAttributeParser::ABI_optimization_goals(AttrType Tag,
431 : const uint8_t *Data,
432 : uint32_t &Offset) {
433 : static const char *const Strings[] = {
434 : "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
435 : "Best Debugging"
436 : };
437 :
438 68 : uint64_t Value = ParseInteger(Data, Offset);
439 : StringRef ValueDesc =
440 68 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
441 68 : PrintAttribute(Tag, Value, ValueDesc);
442 68 : }
443 :
444 8 : void ARMAttributeParser::ABI_FP_optimization_goals(AttrType Tag,
445 : const uint8_t *Data,
446 : uint32_t &Offset) {
447 : static const char *const Strings[] = {
448 : "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Accuracy",
449 : "Best Accuracy"
450 : };
451 :
452 8 : uint64_t Value = ParseInteger(Data, Offset);
453 : StringRef ValueDesc =
454 8 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
455 8 : PrintAttribute(Tag, Value, ValueDesc);
456 8 : }
457 :
458 7 : void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
459 : uint32_t &Offset) {
460 7 : uint64_t Integer = ParseInteger(Data, Offset);
461 7 : StringRef String = ParseString(Data, Offset);
462 :
463 7 : if (SW) {
464 14 : DictScope AS(*SW, "Attribute");
465 14 : SW->printNumber("Tag", Tag);
466 7 : SW->startLine() << "Value: " << Integer << ", " << String << '\n';
467 7 : SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
468 7 : switch (Integer) {
469 1 : case 0:
470 2 : SW->printString("Description", StringRef("No Specific Requirements"));
471 1 : break;
472 3 : case 1:
473 6 : SW->printString("Description", StringRef("AEABI Conformant"));
474 3 : break;
475 3 : default:
476 6 : SW->printString("Description", StringRef("AEABI Non-Conformant"));
477 3 : break;
478 : }
479 : }
480 7 : }
481 :
482 224 : void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
483 : uint32_t &Offset) {
484 : static const char *const Strings[] = { "Not Permitted", "v6-style" };
485 :
486 224 : uint64_t Value = ParseInteger(Data, Offset);
487 : StringRef ValueDesc =
488 224 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
489 224 : PrintAttribute(Tag, Value, ValueDesc);
490 224 : }
491 :
492 24 : void ARMAttributeParser::FP_HP_extension(AttrType Tag, const uint8_t *Data,
493 : uint32_t &Offset) {
494 : static const char *const Strings[] = { "If Available", "Permitted" };
495 :
496 24 : uint64_t Value = ParseInteger(Data, Offset);
497 : StringRef ValueDesc =
498 24 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
499 24 : PrintAttribute(Tag, Value, ValueDesc);
500 24 : }
501 :
502 56 : void ARMAttributeParser::ABI_FP_16bit_format(AttrType Tag, const uint8_t *Data,
503 : uint32_t &Offset) {
504 : static const char *const Strings[] = { "Not Permitted", "IEEE-754", "VFPv3" };
505 :
506 56 : uint64_t Value = ParseInteger(Data, Offset);
507 : StringRef ValueDesc =
508 56 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
509 56 : PrintAttribute(Tag, Value, ValueDesc);
510 56 : }
511 :
512 25 : void ARMAttributeParser::MPextension_use(AttrType Tag, const uint8_t *Data,
513 : uint32_t &Offset) {
514 : static const char *const Strings[] = { "Not Permitted", "Permitted" };
515 :
516 25 : uint64_t Value = ParseInteger(Data, Offset);
517 : StringRef ValueDesc =
518 25 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
519 25 : PrintAttribute(Tag, Value, ValueDesc);
520 25 : }
521 :
522 27 : void ARMAttributeParser::DIV_use(AttrType Tag, const uint8_t *Data,
523 : uint32_t &Offset) {
524 : static const char *const Strings[] = {
525 : "If Available", "Not Permitted", "Permitted"
526 : };
527 :
528 27 : uint64_t Value = ParseInteger(Data, Offset);
529 : StringRef ValueDesc =
530 27 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
531 27 : PrintAttribute(Tag, Value, ValueDesc);
532 27 : }
533 :
534 3 : void ARMAttributeParser::DSP_extension(AttrType Tag, const uint8_t *Data,
535 : uint32_t &Offset) {
536 : static const char *const Strings[] = { "Not Permitted", "Permitted" };
537 :
538 3 : uint64_t Value = ParseInteger(Data, Offset);
539 : StringRef ValueDesc =
540 3 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
541 3 : PrintAttribute(Tag, Value, ValueDesc);
542 3 : }
543 :
544 3 : void ARMAttributeParser::T2EE_use(AttrType Tag, const uint8_t *Data,
545 : uint32_t &Offset) {
546 : static const char *const Strings[] = { "Not Permitted", "Permitted" };
547 :
548 3 : uint64_t Value = ParseInteger(Data, Offset);
549 : StringRef ValueDesc =
550 3 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
551 3 : PrintAttribute(Tag, Value, ValueDesc);
552 3 : }
553 :
554 44 : void ARMAttributeParser::Virtualization_use(AttrType Tag, const uint8_t *Data,
555 : uint32_t &Offset) {
556 : static const char *const Strings[] = {
557 : "Not Permitted", "TrustZone", "Virtualization Extensions",
558 : "TrustZone + Virtualization Extensions"
559 : };
560 :
561 44 : uint64_t Value = ParseInteger(Data, Offset);
562 : StringRef ValueDesc =
563 44 : (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
564 44 : PrintAttribute(Tag, Value, ValueDesc);
565 44 : }
566 :
567 1 : void ARMAttributeParser::nodefaults(AttrType Tag, const uint8_t *Data,
568 : uint32_t &Offset) {
569 1 : uint64_t Value = ParseInteger(Data, Offset);
570 1 : PrintAttribute(Tag, Value, "Unspecified Tags UNDEFINED");
571 1 : }
572 :
573 0 : void ARMAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
574 : SmallVectorImpl<uint8_t> &IndexList) {
575 : for (;;) {
576 : unsigned Length;
577 0 : uint64_t Value = decodeULEB128(Data + Offset, &Length);
578 0 : Offset = Offset + Length;
579 0 : if (Value == 0)
580 : break;
581 0 : IndexList.push_back(Value);
582 0 : }
583 0 : }
584 :
585 429 : void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
586 : uint32_t &Offset, uint32_t Length) {
587 3353 : while (Offset < Length) {
588 : unsigned Length;
589 2924 : uint64_t Tag = decodeULEB128(Data + Offset, &Length);
590 2924 : Offset += Length;
591 :
592 : bool Handled = false;
593 37208 : for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
594 40132 : AHI != AHE && !Handled; ++AHI) {
595 40079 : if (uint64_t(DisplayRoutines[AHI].Attribute) == Tag) {
596 2871 : (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
597 2871 : Data, Offset);
598 : Handled = true;
599 : break;
600 : }
601 : }
602 : if (!Handled) {
603 53 : if (Tag < 32) {
604 0 : errs() << "unhandled AEABI Tag " << Tag
605 0 : << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
606 0 : continue;
607 : }
608 :
609 53 : if (Tag % 2 == 0)
610 0 : IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
611 : else
612 53 : StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
613 : }
614 : }
615 429 : }
616 :
617 429 : void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
618 429 : uint32_t Offset = sizeof(uint32_t); /* SectionLength */
619 :
620 429 : const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
621 429 : size_t VendorNameLength = std::strlen(VendorName);
622 429 : Offset = Offset + VendorNameLength + 1;
623 :
624 429 : if (SW) {
625 74 : SW->printNumber("SectionLength", Length);
626 148 : SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
627 : }
628 :
629 858 : if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
630 0 : return;
631 : }
632 :
633 858 : while (Offset < Length) {
634 : /// Tag_File | Tag_Section | Tag_Symbol uleb128:byte-size
635 429 : uint8_t Tag = Data[Offset];
636 429 : Offset = Offset + sizeof(Tag);
637 :
638 : uint32_t Size =
639 429 : *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
640 429 : Offset = Offset + sizeof(Size);
641 :
642 429 : if (SW) {
643 148 : SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
644 148 : SW->printNumber("Size", Size);
645 : }
646 :
647 429 : if (Size > Length) {
648 0 : errs() << "subsection length greater than section length\n";
649 0 : return;
650 : }
651 :
652 429 : StringRef ScopeName, IndexName;
653 : SmallVector<uint8_t, 8> Indicies;
654 429 : switch (Tag) {
655 : case ARMBuildAttrs::File:
656 429 : ScopeName = "FileAttributes";
657 429 : break;
658 : case ARMBuildAttrs::Section:
659 0 : ScopeName = "SectionAttributes";
660 0 : IndexName = "Sections";
661 0 : ParseIndexList(Data, Offset, Indicies);
662 0 : break;
663 : case ARMBuildAttrs::Symbol:
664 0 : ScopeName = "SymbolAttributes";
665 0 : IndexName = "Symbols";
666 0 : ParseIndexList(Data, Offset, Indicies);
667 0 : break;
668 0 : default:
669 0 : errs() << "unrecognised tag: 0x" << Twine::utohexstr(Tag) << '\n';
670 : return;
671 : }
672 :
673 429 : if (SW) {
674 148 : DictScope ASS(*SW, ScopeName);
675 74 : if (!Indicies.empty())
676 0 : SW->printList(IndexName, Indicies);
677 74 : ParseAttributeList(Data, Offset, Length);
678 : } else {
679 355 : ParseAttributeList(Data, Offset, Length);
680 : }
681 : }
682 : }
683 :
684 429 : void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
685 : size_t Offset = 1;
686 : unsigned SectionNumber = 0;
687 :
688 858 : while (Offset < Section.size()) {
689 429 : uint32_t SectionLength = isLittle ?
690 429 : support::endian::read32le(Section.data() + Offset) :
691 0 : support::endian::read32be(Section.data() + Offset);
692 :
693 429 : if (SW) {
694 74 : SW->startLine() << "Section " << ++SectionNumber << " {\n";
695 74 : SW->indent();
696 : }
697 :
698 429 : ParseSubsection(Section.data() + Offset, SectionLength);
699 429 : Offset = Offset + SectionLength;
700 :
701 429 : if (SW) {
702 : SW->unindent();
703 74 : SW->startLine() << "}\n";
704 : }
705 : }
706 429 : }
707 : }
|
