LLVM  10.0.0svn
ARMAttributeParser.cpp
Go to the documentation of this file.
1 //===--- ARMAttributeParser.cpp - ARM Attribute Information Printer -------===//
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 
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/Support/LEB128.h"
14 
15 using namespace llvm;
16 using namespace llvm::ARMBuildAttrs;
17 
18 
19 static const EnumEntry<unsigned> TagNames[] = {
20  { "Tag_File", ARMBuildAttrs::File },
21  { "Tag_Section", ARMBuildAttrs::Section },
22  { "Tag_Symbol", ARMBuildAttrs::Symbol },
23 };
24 
25 namespace llvm {
26 #define ATTRIBUTE_HANDLER(Attr_) \
27  { ARMBuildAttrs::Attr_, &ARMAttributeParser::Attr_ }
28 
29 const ARMAttributeParser::DisplayHandler
30 ARMAttributeParser::DisplayRoutines[] = {
31  { ARMBuildAttrs::CPU_raw_name, &ARMAttributeParser::StringAttribute, },
32  { ARMBuildAttrs::CPU_name, &ARMAttributeParser::StringAttribute },
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) {
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", nullptr,
137  "ARM v8-M Baseline", "ARM v8-M Mainline", nullptr, nullptr, nullptr,
138  "ARM v8.1-M Mainline"
139  };
140 
141  uint64_t Value = ParseInteger(Data, Offset);
142  StringRef ValueDesc =
143  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
144  PrintAttribute(Tag, Value, ValueDesc);
145 }
146 
147 void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
148  uint32_t &Offset) {
149  uint64_t Encoded = ParseInteger(Data, Offset);
150 
151  StringRef Profile;
152  switch (Encoded) {
153  default: Profile = "Unknown"; break;
154  case 'A': Profile = "Application"; break;
155  case 'R': Profile = "Real-time"; break;
156  case 'M': Profile = "Microcontroller"; break;
157  case 'S': Profile = "Classic"; break;
158  case 0: Profile = "None"; break;
159  }
160 
161  PrintAttribute(Tag, Encoded, Profile);
162 }
163 
164 void ARMAttributeParser::ARM_ISA_use(AttrType Tag, const uint8_t *Data,
165  uint32_t &Offset) {
166  static const char *const Strings[] = { "Not Permitted", "Permitted" };
167 
168  uint64_t Value = ParseInteger(Data, Offset);
169  StringRef ValueDesc =
170  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
171  PrintAttribute(Tag, Value, ValueDesc);
172 }
173 
174 void ARMAttributeParser::THUMB_ISA_use(AttrType Tag, const uint8_t *Data,
175  uint32_t &Offset) {
176  static const char *const Strings[] = { "Not Permitted", "Thumb-1", "Thumb-2" };
177 
178  uint64_t Value = ParseInteger(Data, Offset);
179  StringRef ValueDesc =
180  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
181  PrintAttribute(Tag, Value, ValueDesc);
182 }
183 
184 void ARMAttributeParser::FP_arch(AttrType Tag, const uint8_t *Data,
185  uint32_t &Offset) {
186  static const char *const Strings[] = {
187  "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4",
188  "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"
189  };
190 
191  uint64_t Value = ParseInteger(Data, Offset);
192  StringRef ValueDesc =
193  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
194  PrintAttribute(Tag, Value, ValueDesc);
195 }
196 
197 void ARMAttributeParser::WMMX_arch(AttrType Tag, const uint8_t *Data,
198  uint32_t &Offset) {
199  static const char *const Strings[] = { "Not Permitted", "WMMXv1", "WMMXv2" };
200 
201  uint64_t Value = ParseInteger(Data, Offset);
202  StringRef ValueDesc =
203  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
204  PrintAttribute(Tag, Value, ValueDesc);
205 }
206 
207 void ARMAttributeParser::Advanced_SIMD_arch(AttrType Tag, const uint8_t *Data,
208  uint32_t &Offset) {
209  static const char *const Strings[] = {
210  "Not Permitted", "NEONv1", "NEONv2+FMA", "ARMv8-a NEON", "ARMv8.1-a NEON"
211  };
212 
213  uint64_t Value = ParseInteger(Data, Offset);
214  StringRef ValueDesc =
215  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
216  PrintAttribute(Tag, Value, ValueDesc);
217 }
218 
219 void ARMAttributeParser::MVE_arch(AttrType Tag, const uint8_t *Data,
220  uint32_t &Offset) {
221  static const char *const Strings[] = {
222  "Not Permitted", "MVE integer", "MVE integer and float"
223  };
224 
225  uint64_t Value = ParseInteger(Data, Offset);
226  StringRef ValueDesc =
227  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
228  PrintAttribute(Tag, Value, ValueDesc);
229 }
230 
231 void ARMAttributeParser::PCS_config(AttrType Tag, const uint8_t *Data,
232  uint32_t &Offset) {
233  static const char *const Strings[] = {
234  "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
235  "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"
236  };
237 
238  uint64_t Value = ParseInteger(Data, Offset);
239  StringRef ValueDesc =
240  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
241  PrintAttribute(Tag, Value, ValueDesc);
242 }
243 
244 void ARMAttributeParser::ABI_PCS_R9_use(AttrType Tag, const uint8_t *Data,
245  uint32_t &Offset) {
246  static const char *const Strings[] = { "v6", "Static Base", "TLS", "Unused" };
247 
248  uint64_t Value = ParseInteger(Data, Offset);
249  StringRef ValueDesc =
250  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
251  PrintAttribute(Tag, Value, ValueDesc);
252 }
253 
254 void ARMAttributeParser::ABI_PCS_RW_data(AttrType Tag, const uint8_t *Data,
255  uint32_t &Offset) {
256  static const char *const Strings[] = {
257  "Absolute", "PC-relative", "SB-relative", "Not Permitted"
258  };
259 
260  uint64_t Value = ParseInteger(Data, Offset);
261  StringRef ValueDesc =
262  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
263  PrintAttribute(Tag, Value, ValueDesc);
264 }
265 
266 void ARMAttributeParser::ABI_PCS_RO_data(AttrType Tag, const uint8_t *Data,
267  uint32_t &Offset) {
268  static const char *const Strings[] = {
269  "Absolute", "PC-relative", "Not Permitted"
270  };
271 
272  uint64_t Value = ParseInteger(Data, Offset);
273  StringRef ValueDesc =
274  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
275  PrintAttribute(Tag, Value, ValueDesc);
276 }
277 
278 void ARMAttributeParser::ABI_PCS_GOT_use(AttrType Tag, const uint8_t *Data,
279  uint32_t &Offset) {
280  static const char *const Strings[] = {
281  "Not Permitted", "Direct", "GOT-Indirect"
282  };
283 
284  uint64_t Value = ParseInteger(Data, Offset);
285  StringRef ValueDesc =
286  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
287  PrintAttribute(Tag, Value, ValueDesc);
288 }
289 
290 void ARMAttributeParser::ABI_PCS_wchar_t(AttrType Tag, const uint8_t *Data,
291  uint32_t &Offset) {
292  static const char *const Strings[] = {
293  "Not Permitted", "Unknown", "2-byte", "Unknown", "4-byte"
294  };
295 
296  uint64_t Value = ParseInteger(Data, Offset);
297  StringRef ValueDesc =
298  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
299  PrintAttribute(Tag, Value, ValueDesc);
300 }
301 
302 void ARMAttributeParser::ABI_FP_rounding(AttrType Tag, const uint8_t *Data,
303  uint32_t &Offset) {
304  static const char *const Strings[] = { "IEEE-754", "Runtime" };
305 
306  uint64_t Value = ParseInteger(Data, Offset);
307  StringRef ValueDesc =
308  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
309  PrintAttribute(Tag, Value, ValueDesc);
310 }
311 
312 void ARMAttributeParser::ABI_FP_denormal(AttrType Tag, const uint8_t *Data,
313  uint32_t &Offset) {
314  static const char *const Strings[] = {
315  "Unsupported", "IEEE-754", "Sign Only"
316  };
317 
318  uint64_t Value = ParseInteger(Data, Offset);
319  StringRef ValueDesc =
320  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
321  PrintAttribute(Tag, Value, ValueDesc);
322 }
323 
324 void ARMAttributeParser::ABI_FP_exceptions(AttrType Tag, const uint8_t *Data,
325  uint32_t &Offset) {
326  static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
327 
328  uint64_t Value = ParseInteger(Data, Offset);
329  StringRef ValueDesc =
330  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
331  PrintAttribute(Tag, Value, ValueDesc);
332 }
333 
334 void ARMAttributeParser::ABI_FP_user_exceptions(AttrType Tag,
335  const uint8_t *Data,
336  uint32_t &Offset) {
337  static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
338 
339  uint64_t Value = ParseInteger(Data, Offset);
340  StringRef ValueDesc =
341  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
342  PrintAttribute(Tag, Value, ValueDesc);
343 }
344 
345 void ARMAttributeParser::ABI_FP_number_model(AttrType Tag, const uint8_t *Data,
346  uint32_t &Offset) {
347  static const char *const Strings[] = {
348  "Not Permitted", "Finite Only", "RTABI", "IEEE-754"
349  };
350 
351  uint64_t Value = ParseInteger(Data, Offset);
352  StringRef ValueDesc =
353  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
354  PrintAttribute(Tag, Value, ValueDesc);
355 }
356 
357 void ARMAttributeParser::ABI_align_needed(AttrType Tag, const uint8_t *Data,
358  uint32_t &Offset) {
359  static const char *const Strings[] = {
360  "Not Permitted", "8-byte alignment", "4-byte alignment", "Reserved"
361  };
362 
363  uint64_t Value = ParseInteger(Data, Offset);
364 
365  std::string Description;
366  if (Value < array_lengthof(Strings))
367  Description = std::string(Strings[Value]);
368  else if (Value <= 12)
369  Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
370  + std::string("-byte extended alignment");
371  else
372  Description = "Invalid";
373 
374  PrintAttribute(Tag, Value, Description);
375 }
376 
377 void ARMAttributeParser::ABI_align_preserved(AttrType Tag, const uint8_t *Data,
378  uint32_t &Offset) {
379  static const char *const Strings[] = {
380  "Not Required", "8-byte data alignment", "8-byte data and code alignment",
381  "Reserved"
382  };
383 
384  uint64_t Value = ParseInteger(Data, Offset);
385 
386  std::string Description;
387  if (Value < array_lengthof(Strings))
388  Description = std::string(Strings[Value]);
389  else if (Value <= 12)
390  Description = std::string("8-byte stack alignment, ") +
391  utostr(1ULL << Value) + std::string("-byte data alignment");
392  else
393  Description = "Invalid";
394 
395  PrintAttribute(Tag, Value, Description);
396 }
397 
398 void ARMAttributeParser::ABI_enum_size(AttrType Tag, const uint8_t *Data,
399  uint32_t &Offset) {
400  static const char *const Strings[] = {
401  "Not Permitted", "Packed", "Int32", "External Int32"
402  };
403 
404  uint64_t Value = ParseInteger(Data, Offset);
405  StringRef ValueDesc =
406  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
407  PrintAttribute(Tag, Value, ValueDesc);
408 }
409 
410 void ARMAttributeParser::ABI_HardFP_use(AttrType Tag, const uint8_t *Data,
411  uint32_t &Offset) {
412  static const char *const Strings[] = {
413  "Tag_FP_arch", "Single-Precision", "Reserved", "Tag_FP_arch (deprecated)"
414  };
415 
416  uint64_t Value = ParseInteger(Data, Offset);
417  StringRef ValueDesc =
418  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
419  PrintAttribute(Tag, Value, ValueDesc);
420 }
421 
422 void ARMAttributeParser::ABI_VFP_args(AttrType Tag, const uint8_t *Data,
423  uint32_t &Offset) {
424  static const char *const Strings[] = {
425  "AAPCS", "AAPCS VFP", "Custom", "Not Permitted"
426  };
427 
428  uint64_t Value = ParseInteger(Data, Offset);
429  StringRef ValueDesc =
430  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
431  PrintAttribute(Tag, Value, ValueDesc);
432 }
433 
434 void ARMAttributeParser::ABI_WMMX_args(AttrType Tag, const uint8_t *Data,
435  uint32_t &Offset) {
436  static const char *const Strings[] = { "AAPCS", "iWMMX", "Custom" };
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_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", "Debugging",
449  "Best Debugging"
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::ABI_FP_optimization_goals(AttrType Tag,
459  const uint8_t *Data,
460  uint32_t &Offset) {
461  static const char *const Strings[] = {
462  "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Accuracy",
463  "Best Accuracy"
464  };
465 
466  uint64_t Value = ParseInteger(Data, Offset);
467  StringRef ValueDesc =
468  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
469  PrintAttribute(Tag, Value, ValueDesc);
470 }
471 
472 void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
473  uint32_t &Offset) {
474  uint64_t Integer = ParseInteger(Data, Offset);
475  StringRef String = ParseString(Data, Offset);
476 
477  if (SW) {
478  DictScope AS(*SW, "Attribute");
479  SW->printNumber("Tag", Tag);
480  SW->startLine() << "Value: " << Integer << ", " << String << '\n';
481  SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
482  switch (Integer) {
483  case 0:
484  SW->printString("Description", StringRef("No Specific Requirements"));
485  break;
486  case 1:
487  SW->printString("Description", StringRef("AEABI Conformant"));
488  break;
489  default:
490  SW->printString("Description", StringRef("AEABI Non-Conformant"));
491  break;
492  }
493  }
494 }
495 
496 void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
497  uint32_t &Offset) {
498  static const char *const Strings[] = { "Not Permitted", "v6-style" };
499 
500  uint64_t Value = ParseInteger(Data, Offset);
501  StringRef ValueDesc =
502  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
503  PrintAttribute(Tag, Value, ValueDesc);
504 }
505 
506 void ARMAttributeParser::FP_HP_extension(AttrType Tag, const uint8_t *Data,
507  uint32_t &Offset) {
508  static const char *const Strings[] = { "If Available", "Permitted" };
509 
510  uint64_t Value = ParseInteger(Data, Offset);
511  StringRef ValueDesc =
512  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
513  PrintAttribute(Tag, Value, ValueDesc);
514 }
515 
516 void ARMAttributeParser::ABI_FP_16bit_format(AttrType Tag, const uint8_t *Data,
517  uint32_t &Offset) {
518  static const char *const Strings[] = { "Not Permitted", "IEEE-754", "VFPv3" };
519 
520  uint64_t Value = ParseInteger(Data, Offset);
521  StringRef ValueDesc =
522  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
523  PrintAttribute(Tag, Value, ValueDesc);
524 }
525 
526 void ARMAttributeParser::MPextension_use(AttrType Tag, const uint8_t *Data,
527  uint32_t &Offset) {
528  static const char *const Strings[] = { "Not Permitted", "Permitted" };
529 
530  uint64_t Value = ParseInteger(Data, Offset);
531  StringRef ValueDesc =
532  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
533  PrintAttribute(Tag, Value, ValueDesc);
534 }
535 
536 void ARMAttributeParser::DIV_use(AttrType Tag, const uint8_t *Data,
537  uint32_t &Offset) {
538  static const char *const Strings[] = {
539  "If Available", "Not Permitted", "Permitted"
540  };
541 
542  uint64_t Value = ParseInteger(Data, Offset);
543  StringRef ValueDesc =
544  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
545  PrintAttribute(Tag, Value, ValueDesc);
546 }
547 
548 void ARMAttributeParser::DSP_extension(AttrType Tag, const uint8_t *Data,
549  uint32_t &Offset) {
550  static const char *const Strings[] = { "Not Permitted", "Permitted" };
551 
552  uint64_t Value = ParseInteger(Data, Offset);
553  StringRef ValueDesc =
554  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
555  PrintAttribute(Tag, Value, ValueDesc);
556 }
557 
558 void ARMAttributeParser::T2EE_use(AttrType Tag, const uint8_t *Data,
559  uint32_t &Offset) {
560  static const char *const Strings[] = { "Not Permitted", "Permitted" };
561 
562  uint64_t Value = ParseInteger(Data, Offset);
563  StringRef ValueDesc =
564  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
565  PrintAttribute(Tag, Value, ValueDesc);
566 }
567 
568 void ARMAttributeParser::Virtualization_use(AttrType Tag, const uint8_t *Data,
569  uint32_t &Offset) {
570  static const char *const Strings[] = {
571  "Not Permitted", "TrustZone", "Virtualization Extensions",
572  "TrustZone + Virtualization Extensions"
573  };
574 
575  uint64_t Value = ParseInteger(Data, Offset);
576  StringRef ValueDesc =
577  (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
578  PrintAttribute(Tag, Value, ValueDesc);
579 }
580 
581 void ARMAttributeParser::nodefaults(AttrType Tag, const uint8_t *Data,
582  uint32_t &Offset) {
583  uint64_t Value = ParseInteger(Data, Offset);
584  PrintAttribute(Tag, Value, "Unspecified Tags UNDEFINED");
585 }
586 
587 void ARMAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
588  SmallVectorImpl<uint8_t> &IndexList) {
589  for (;;) {
590  unsigned Length;
591  uint64_t Value = decodeULEB128(Data + Offset, &Length);
592  Offset = Offset + Length;
593  if (Value == 0)
594  break;
595  IndexList.push_back(Value);
596  }
597 }
598 
599 void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
600  uint32_t &Offset, uint32_t Length) {
601  while (Offset < Length) {
602  unsigned Length;
603  uint64_t Tag = decodeULEB128(Data + Offset, &Length);
604  Offset += Length;
605 
606  bool Handled = false;
607  for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
608  AHI != AHE && !Handled; ++AHI) {
609  if (uint64_t(DisplayRoutines[AHI].Attribute) == Tag) {
610  (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
611  Data, Offset);
612  Handled = true;
613  break;
614  }
615  }
616  if (!Handled) {
617  if (Tag < 32) {
618  errs() << "unhandled AEABI Tag " << Tag
619  << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
620  continue;
621  }
622 
623  if (Tag % 2 == 0)
624  IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
625  else
626  StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
627  }
628  }
629 }
630 
631 void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
632  uint32_t Offset = sizeof(uint32_t); /* SectionLength */
633 
634  const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
635  size_t VendorNameLength = std::strlen(VendorName);
636  Offset = Offset + VendorNameLength + 1;
637 
638  if (SW) {
639  SW->printNumber("SectionLength", Length);
640  SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
641  }
642 
643  if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
644  return;
645  }
646 
647  while (Offset < Length) {
648  /// Tag_File | Tag_Section | Tag_Symbol uleb128:byte-size
649  uint8_t Tag = Data[Offset];
650  Offset = Offset + sizeof(Tag);
651 
652  uint32_t Size =
653  *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
654  Offset = Offset + sizeof(Size);
655 
656  if (SW) {
657  SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
658  SW->printNumber("Size", Size);
659  }
660 
661  if (Size > Length) {
662  errs() << "subsection length greater than section length\n";
663  return;
664  }
665 
666  StringRef ScopeName, IndexName;
667  SmallVector<uint8_t, 8> Indicies;
668  switch (Tag) {
669  case ARMBuildAttrs::File:
670  ScopeName = "FileAttributes";
671  break;
673  ScopeName = "SectionAttributes";
674  IndexName = "Sections";
675  ParseIndexList(Data, Offset, Indicies);
676  break;
678  ScopeName = "SymbolAttributes";
679  IndexName = "Symbols";
680  ParseIndexList(Data, Offset, Indicies);
681  break;
682  default:
683  errs() << "unrecognised tag: 0x" << Twine::utohexstr(Tag) << '\n';
684  return;
685  }
686 
687  if (SW) {
688  DictScope ASS(*SW, ScopeName);
689  if (!Indicies.empty())
690  SW->printList(IndexName, Indicies);
691  ParseAttributeList(Data, Offset, Length);
692  } else {
693  ParseAttributeList(Data, Offset, Length);
694  }
695  }
696 }
697 
699  uint64_t Offset = 1;
700  unsigned SectionNumber = 0;
701 
702  while (Offset < Section.size()) {
703  uint32_t SectionLength = isLittle ?
704  support::endian::read32le(Section.data() + Offset) :
706 
707  if (SW) {
708  SW->startLine() << "Section " << ++SectionNumber << " {\n";
709  SW->indent();
710  }
711 
712  if (SectionLength == 0 || (SectionLength + Offset) > Section.size()) {
713  errs() << "invalid subsection length " << SectionLength << " at offset "
714  << Offset << "\n";
715  return;
716  }
717 
718  ParseSubsection(Section.data() + Offset, SectionLength);
719  Offset = Offset + SectionLength;
720 
721  if (SW) {
722  SW->unindent();
723  SW->startLine() << "}\n";
724  }
725  }
726 }
727 }
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
#define ATTRIBUTE_HANDLER(Attr_)
void push_back(const T &Elt)
Definition: SmallVector.h:211
uint32_t read32be(const void *P)
Definition: Endian.h:386
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
StringRef AttrTypeAsString(unsigned Attr, bool HasTagPrefix=true)
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
uint64_t decodeULEB128(const uint8_t *p, unsigned *n=nullptr, const uint8_t *end=nullptr, const char **error=nullptr)
Utility function to decode a ULEB128 value.
Definition: LEB128.h:128
static const EnumEntry< unsigned > TagNames[]
const T * data() const
Definition: ArrayRef.h:145
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:1035
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:387
std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:223
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
uint32_t read32le(const void *P)
Definition: Endian.h:383
uint32_t Size
Definition: Profile.cpp:46
LLVM Value Representation.
Definition: Value.h:73
void Parse(ArrayRef< uint8_t > Section, bool isLittle)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48