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/ADT/STLExtras.h"
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/Support/ARMAttributeParser.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 uint64_t ARMAttributeParser::ParseInteger(const uint8_t *Data,
75                                           uint32_t &Offset) {
76   unsigned Length;
77   uint64_t Value = decodeULEB128(Data + Offset, &Length);
78   Offset = Offset + Length;
79   return Value;
80 }
81 
82 StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
83                                           uint32_t &Offset) {
84   const char *String = reinterpret_cast<const char*>(Data + Offset);
85   size_t Length = std::strlen(String);
86   Offset = Offset + Length + 1;
87   return StringRef(String, Length);
88 }
89 
90 void ARMAttributeParser::IntegerAttribute(AttrType Tag, const uint8_t *Data,
91                                           uint32_t &Offset) {
92 
93   uint64_t Value = ParseInteger(Data, Offset);
94   Attributes.insert(std::make_pair(Tag, Value));
95 
96   if (SW)
97     SW->printNumber(ARMBuildAttrs::AttrTypeAsString(Tag), Value);
98 }
99 
100 void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
101                                          uint32_t &Offset) {
102   StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
103   StringRef ValueDesc = ParseString(Data, Offset);
104 
105   if (SW) {
106     DictScope AS(*SW, "Attribute");
107     SW->printNumber("Tag", Tag);
108     if (!TagName.empty())
109       SW->printString("TagName", TagName);
110     SW->printString("Value", ValueDesc);
111   }
112 }
113 
114 void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
115                                         StringRef ValueDesc) {
116   Attributes.insert(std::make_pair(Tag, Value));
117 
118   if (SW) {
119     StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag,
120                                                         /*TagPrefix*/false);
121     DictScope AS(*SW, "Attribute");
122     SW->printNumber("Tag", Tag);
123     SW->printNumber("Value", Value);
124     if (!TagName.empty())
125       SW->printString("TagName", TagName);
126     if (!ValueDesc.empty())
127       SW->printString("Description", ValueDesc);
128   }
129 }
130 
131 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   uint64_t Value = ParseInteger(Data, Offset);
140   StringRef ValueDesc =
141     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
142   PrintAttribute(Tag, Value, ValueDesc);
143 }
144 
145 void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
146                                           uint32_t &Offset) {
147   uint64_t Encoded = ParseInteger(Data, Offset);
148 
149   StringRef Profile;
150   switch (Encoded) {
151   default:  Profile = "Unknown"; break;
152   case 'A': Profile = "Application"; break;
153   case 'R': Profile = "Real-time"; break;
154   case 'M': Profile = "Microcontroller"; break;
155   case 'S': Profile = "Classic"; break;
156   case 0: Profile = "None"; break;
157   }
158 
159   PrintAttribute(Tag, Encoded, Profile);
160 }
161 
162 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   uint64_t Value = ParseInteger(Data, Offset);
167   StringRef ValueDesc =
168     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
169   PrintAttribute(Tag, Value, ValueDesc);
170 }
171 
172 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   uint64_t Value = ParseInteger(Data, Offset);
177   StringRef ValueDesc =
178     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
179   PrintAttribute(Tag, Value, ValueDesc);
180 }
181 
182 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   uint64_t Value = ParseInteger(Data, Offset);
190   StringRef ValueDesc =
191     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
192   PrintAttribute(Tag, Value, ValueDesc);
193 }
194 
195 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   uint64_t Value = ParseInteger(Data, Offset);
200   StringRef ValueDesc =
201     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
202   PrintAttribute(Tag, Value, ValueDesc);
203 }
204 
205 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   uint64_t Value = ParseInteger(Data, Offset);
212   StringRef ValueDesc =
213     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
214   PrintAttribute(Tag, Value, ValueDesc);
215 }
216 
217 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   uint64_t Value = ParseInteger(Data, Offset);
225   StringRef ValueDesc =
226     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
227   PrintAttribute(Tag, Value, ValueDesc);
228 }
229 
230 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   uint64_t Value = ParseInteger(Data, Offset);
235   StringRef ValueDesc =
236     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
237   PrintAttribute(Tag, Value, ValueDesc);
238 }
239 
240 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   uint64_t Value = ParseInteger(Data, Offset);
247   StringRef ValueDesc =
248     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
249   PrintAttribute(Tag, Value, ValueDesc);
250 }
251 
252 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   uint64_t Value = ParseInteger(Data, Offset);
259   StringRef ValueDesc =
260     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
261   PrintAttribute(Tag, Value, ValueDesc);
262 }
263 
264 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   uint64_t Value = ParseInteger(Data, Offset);
271   StringRef ValueDesc =
272     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
273   PrintAttribute(Tag, Value, ValueDesc);
274 }
275 
276 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   uint64_t Value = ParseInteger(Data, Offset);
283   StringRef ValueDesc =
284     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
285   PrintAttribute(Tag, Value, ValueDesc);
286 }
287 
288 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   uint64_t Value = ParseInteger(Data, Offset);
293   StringRef ValueDesc =
294     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
295   PrintAttribute(Tag, Value, ValueDesc);
296 }
297 
298 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   uint64_t Value = ParseInteger(Data, Offset);
305   StringRef ValueDesc =
306     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
307   PrintAttribute(Tag, Value, ValueDesc);
308 }
309 
310 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   uint64_t Value = ParseInteger(Data, Offset);
315   StringRef ValueDesc =
316     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
317   PrintAttribute(Tag, Value, ValueDesc);
318 }
319 
320 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   uint64_t Value = ParseInteger(Data, Offset);
326   StringRef ValueDesc =
327     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
328   PrintAttribute(Tag, Value, ValueDesc);
329 }
330 
331 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   uint64_t Value = ParseInteger(Data, Offset);
338   StringRef ValueDesc =
339     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
340   PrintAttribute(Tag, Value, ValueDesc);
341 }
342 
343 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   uint64_t Value = ParseInteger(Data, Offset);
350 
351   std::string Description;
352   if (Value < array_lengthof(Strings))
353     Description = std::string(Strings[Value]);
354   else if (Value <= 12)
355     Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
356                 + std::string("-byte extended alignment");
357   else
358     Description = "Invalid";
359 
360   PrintAttribute(Tag, Value, Description);
361 }
362 
363 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   uint64_t Value = ParseInteger(Data, Offset);
371 
372   std::string Description;
373   if (Value < array_lengthof(Strings))
374     Description = std::string(Strings[Value]);
375   else if (Value <= 12)
376     Description = std::string("8-byte stack alignment, ") +
377                   utostr(1ULL << Value) + std::string("-byte data alignment");
378   else
379     Description = "Invalid";
380 
381   PrintAttribute(Tag, Value, Description);
382 }
383 
384 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   uint64_t Value = ParseInteger(Data, Offset);
391   StringRef ValueDesc =
392     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
393   PrintAttribute(Tag, Value, ValueDesc);
394 }
395 
396 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   uint64_t Value = ParseInteger(Data, Offset);
403   StringRef ValueDesc =
404     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
405   PrintAttribute(Tag, Value, ValueDesc);
406 }
407 
408 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   uint64_t Value = ParseInteger(Data, Offset);
415   StringRef ValueDesc =
416     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
417   PrintAttribute(Tag, Value, ValueDesc);
418 }
419 
420 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   uint64_t Value = ParseInteger(Data, Offset);
425   StringRef ValueDesc =
426     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
427   PrintAttribute(Tag, Value, ValueDesc);
428 }
429 
430 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   uint64_t Value = ParseInteger(Data, Offset);
439   StringRef ValueDesc =
440     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
441   PrintAttribute(Tag, Value, ValueDesc);
442 }
443 
444 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   uint64_t Value = ParseInteger(Data, Offset);
453   StringRef ValueDesc =
454     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
455   PrintAttribute(Tag, Value, ValueDesc);
456 }
457 
458 void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
459                                        uint32_t &Offset) {
460   uint64_t Integer = ParseInteger(Data, Offset);
461   StringRef String = ParseString(Data, Offset);
462 
463   if (SW) {
464     DictScope AS(*SW, "Attribute");
465     SW->printNumber("Tag", Tag);
466     SW->startLine() << "Value: " << Integer << ", " << String << '\n';
467     SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
468     switch (Integer) {
469     case 0:
470       SW->printString("Description", StringRef("No Specific Requirements"));
471       break;
472     case 1:
473       SW->printString("Description", StringRef("AEABI Conformant"));
474       break;
475     default:
476       SW->printString("Description", StringRef("AEABI Non-Conformant"));
477       break;
478     }
479   }
480 }
481 
482 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   uint64_t Value = ParseInteger(Data, Offset);
487   StringRef ValueDesc =
488     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
489   PrintAttribute(Tag, Value, ValueDesc);
490 }
491 
492 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   uint64_t Value = ParseInteger(Data, Offset);
497   StringRef ValueDesc =
498     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
499   PrintAttribute(Tag, Value, ValueDesc);
500 }
501 
502 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   uint64_t Value = ParseInteger(Data, Offset);
507   StringRef ValueDesc =
508     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
509   PrintAttribute(Tag, Value, ValueDesc);
510 }
511 
512 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   uint64_t Value = ParseInteger(Data, Offset);
517   StringRef ValueDesc =
518     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
519   PrintAttribute(Tag, Value, ValueDesc);
520 }
521 
522 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   uint64_t Value = ParseInteger(Data, Offset);
529   StringRef ValueDesc =
530     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
531   PrintAttribute(Tag, Value, ValueDesc);
532 }
533 
534 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   uint64_t Value = ParseInteger(Data, Offset);
539   StringRef ValueDesc =
540     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
541   PrintAttribute(Tag, Value, ValueDesc);
542 }
543 
544 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   uint64_t Value = ParseInteger(Data, Offset);
549   StringRef ValueDesc =
550     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
551   PrintAttribute(Tag, Value, ValueDesc);
552 }
553 
554 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   uint64_t Value = ParseInteger(Data, Offset);
562   StringRef ValueDesc =
563     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
564   PrintAttribute(Tag, Value, ValueDesc);
565 }
566 
567 void ARMAttributeParser::nodefaults(AttrType Tag, const uint8_t *Data,
568                                     uint32_t &Offset) {
569   uint64_t Value = ParseInteger(Data, Offset);
570   PrintAttribute(Tag, Value, "Unspecified Tags UNDEFINED");
571 }
572 
573 void ARMAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
574                                         SmallVectorImpl<uint8_t> &IndexList) {
575   for (;;) {
576     unsigned Length;
577     uint64_t Value = decodeULEB128(Data + Offset, &Length);
578     Offset = Offset + Length;
579     if (Value == 0)
580       break;
581     IndexList.push_back(Value);
582   }
583 }
584 
585 void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
586                                             uint32_t &Offset, uint32_t Length) {
587   while (Offset < Length) {
588     unsigned Length;
589     uint64_t Tag = decodeULEB128(Data + Offset, &Length);
590     Offset += Length;
591 
592     bool Handled = false;
593     for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
594          AHI != AHE && !Handled; ++AHI) {
595       if (DisplayRoutines[AHI].Attribute == Tag) {
596         (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
597                                               Data, Offset);
598         Handled = true;
599         break;
600       }
601     }
602     if (!Handled) {
603       if (Tag < 32) {
604         errs() << "unhandled AEABI Tag " << Tag
605                << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
606         continue;
607       }
608 
609       if (Tag % 2 == 0)
610         IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
611       else
612         StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
613     }
614   }
615 }
616 
617 void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
618   uint32_t Offset = sizeof(uint32_t); /* SectionLength */
619 
620   const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
621   size_t VendorNameLength = std::strlen(VendorName);
622   Offset = Offset + VendorNameLength + 1;
623 
624   if (SW) {
625     SW->printNumber("SectionLength", Length);
626     SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
627   }
628 
629   if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
630     return;
631   }
632 
633   while (Offset < Length) {
634     /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
635     uint8_t Tag = Data[Offset];
636     Offset = Offset + sizeof(Tag);
637 
638     uint32_t Size =
639       *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
640     Offset = Offset + sizeof(Size);
641 
642     if (SW) {
643       SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
644       SW->printNumber("Size", Size);
645     }
646 
647     if (Size > Length) {
648       errs() << "subsection length greater than section length\n";
649       return;
650     }
651 
652     StringRef ScopeName, IndexName;
653     SmallVector<uint8_t, 8> Indicies;
654     switch (Tag) {
655     case ARMBuildAttrs::File:
656       ScopeName = "FileAttributes";
657       break;
658     case ARMBuildAttrs::Section:
659       ScopeName = "SectionAttributes";
660       IndexName = "Sections";
661       ParseIndexList(Data, Offset, Indicies);
662       break;
663     case ARMBuildAttrs::Symbol:
664       ScopeName = "SymbolAttributes";
665       IndexName = "Symbols";
666       ParseIndexList(Data, Offset, Indicies);
667       break;
668     default:
669       errs() << "unrecognised tag: 0x" << utohexstr(Tag) << '\n';
670       return;
671     }
672 
673     if (SW) {
674       DictScope ASS(*SW, ScopeName);
675       if (!Indicies.empty())
676         SW->printList(IndexName, Indicies);
677       ParseAttributeList(Data, Offset, Length);
678     } else {
679       ParseAttributeList(Data, Offset, Length);
680     }
681   }
682 }
683 
684 void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
685   size_t Offset = 1;
686   unsigned SectionNumber = 0;
687 
688   while (Offset < Section.size()) {
689     uint32_t SectionLength = isLittle ?
690       support::endian::read32le(Section.data() + Offset) :
691       support::endian::read32be(Section.data() + Offset);
692 
693     if (SW) {
694       SW->startLine() << "Section " << ++SectionNumber << " {\n";
695       SW->indent();
696     }
697 
698     ParseSubsection(Section.data() + Offset, SectionLength);
699     Offset = Offset + SectionLength;
700 
701     if (SW) {
702       SW->unindent();
703       SW->startLine() << "}\n";
704     }
705   }
706 }
707 }
708 
709