LCOV - code coverage report
Current view: top level - lib/Support - ARMAttributeParser.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 302 336 89.9 %
Date: 2017-09-14 15:23:50 Functions: 44 46 95.7 %
Legend: Lines: hit not hit

          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      289320 : };
      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        1221 : uint64_t ARMAttributeParser::ParseInteger(const uint8_t *Data,
      75             :                                           uint32_t &Offset) {
      76             :   unsigned Length;
      77        1221 :   uint64_t Value = decodeULEB128(Data + Offset, &Length);
      78        1221 :   Offset = Offset + Length;
      79        1221 :   return Value;
      80             : }
      81             : 
      82         122 : StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
      83             :                                           uint32_t &Offset) {
      84         122 :   const char *String = reinterpret_cast<const char*>(Data + Offset);
      85         122 :   size_t Length = std::strlen(String);
      86         122 :   Offset = Offset + Length + 1;
      87         122 :   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         115 : void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
     101             :                                          uint32_t &Offset) {
     102         115 :   StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
     103         115 :   StringRef ValueDesc = ParseString(Data, Offset);
     104             : 
     105         115 :   if (SW) {
     106         140 :     DictScope AS(*SW, "Attribute");
     107         140 :     SW->printNumber("Tag", Tag);
     108          70 :     if (!TagName.empty())
     109         140 :       SW->printString("TagName", TagName);
     110         140 :     SW->printString("Value", ValueDesc);
     111             :   }
     112         115 : }
     113             : 
     114        1214 : void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
     115             :                                         StringRef ValueDesc) {
     116        3642 :   Attributes.insert(std::make_pair(Tag, Value));
     117             : 
     118        1214 :   if (SW) {
     119             :     StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag,
     120         643 :                                                         /*TagPrefix*/false);
     121        1286 :     DictScope AS(*SW, "Attribute");
     122        1286 :     SW->printNumber("Tag", Tag);
     123        1286 :     SW->printNumber("Value", Value);
     124         643 :     if (!TagName.empty())
     125        1286 :       SW->printString("TagName", TagName);
     126         643 :     if (!ValueDesc.empty())
     127        1286 :       SW->printString("Description", ValueDesc);
     128             :   }
     129        1214 : }
     130             : 
     131         124 : 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         124 :   uint64_t Value = ParseInteger(Data, Offset);
     140             :   StringRef ValueDesc =
     141         371 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     142         124 :   PrintAttribute(Tag, Value, ValueDesc);
     143         124 : }
     144             : 
     145          68 : void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
     146             :                                           uint32_t &Offset) {
     147          68 :   uint64_t Encoded = ParseInteger(Data, Offset);
     148             : 
     149          68 :   StringRef Profile;
     150          68 :   switch (Encoded) {
     151           0 :   default:  Profile = "Unknown"; break;
     152          48 :   case 'A': Profile = "Application"; break;
     153           8 :   case 'R': Profile = "Real-time"; break;
     154           9 :   case 'M': Profile = "Microcontroller"; break;
     155           2 :   case 'S': Profile = "Classic"; break;
     156           1 :   case 0: Profile = "None"; break;
     157             :   }
     158             : 
     159          68 :   PrintAttribute(Tag, Encoded, Profile);
     160          68 : }
     161             : 
     162          84 : 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          84 :   uint64_t Value = ParseInteger(Data, Offset);
     167             :   StringRef ValueDesc =
     168         252 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     169          84 :   PrintAttribute(Tag, Value, ValueDesc);
     170          84 : }
     171             : 
     172          85 : 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          85 :   uint64_t Value = ParseInteger(Data, Offset);
     177             :   StringRef ValueDesc =
     178         254 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     179          85 :   PrintAttribute(Tag, Value, ValueDesc);
     180          85 : }
     181             : 
     182          70 : 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          70 :   uint64_t Value = ParseInteger(Data, Offset);
     190             :   StringRef ValueDesc =
     191         210 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     192          70 :   PrintAttribute(Tag, Value, ValueDesc);
     193          70 : }
     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          27 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     202           9 :   PrintAttribute(Tag, Value, ValueDesc);
     203           9 : }
     204             : 
     205          48 : 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          48 :   uint64_t Value = ParseInteger(Data, Offset);
     212             :   StringRef ValueDesc =
     213         144 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     214          48 :   PrintAttribute(Tag, Value, ValueDesc);
     215          48 : }
     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          51 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     227          17 :   PrintAttribute(Tag, Value, ValueDesc);
     228          17 : }
     229             : 
     230          52 : 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          52 :   uint64_t Value = ParseInteger(Data, Offset);
     235             :   StringRef ValueDesc =
     236         156 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     237          52 :   PrintAttribute(Tag, Value, ValueDesc);
     238          52 : }
     239             : 
     240          12 : 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          12 :   uint64_t Value = ParseInteger(Data, Offset);
     247             :   StringRef ValueDesc =
     248          36 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     249          12 :   PrintAttribute(Tag, Value, ValueDesc);
     250          12 : }
     251             : 
     252          10 : 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          10 :   uint64_t Value = ParseInteger(Data, Offset);
     259             :   StringRef ValueDesc =
     260          30 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     261          10 :   PrintAttribute(Tag, Value, ValueDesc);
     262          10 : }
     263             : 
     264          50 : 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          50 :   uint64_t Value = ParseInteger(Data, Offset);
     271             :   StringRef ValueDesc =
     272         150 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     273          50 :   PrintAttribute(Tag, Value, ValueDesc);
     274          50 : }
     275             : 
     276          10 : 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          10 :   uint64_t Value = ParseInteger(Data, Offset);
     283             :   StringRef ValueDesc =
     284          30 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     285          10 :   PrintAttribute(Tag, Value, ValueDesc);
     286          10 : }
     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          15 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     295           5 :   PrintAttribute(Tag, Value, ValueDesc);
     296           5 : }
     297             : 
     298          50 : 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          50 :   uint64_t Value = ParseInteger(Data, Offset);
     305             :   StringRef ValueDesc =
     306         150 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     307          50 :   PrintAttribute(Tag, Value, ValueDesc);
     308          50 : }
     309             : 
     310          48 : 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          48 :   uint64_t Value = ParseInteger(Data, Offset);
     315             :   StringRef ValueDesc =
     316         144 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     317          48 :   PrintAttribute(Tag, Value, ValueDesc);
     318          48 : }
     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          15 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     328           5 :   PrintAttribute(Tag, Value, ValueDesc);
     329           5 : }
     330             : 
     331          52 : 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          52 :   uint64_t Value = ParseInteger(Data, Offset);
     338             :   StringRef ValueDesc =
     339         156 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     340          52 :   PrintAttribute(Tag, Value, ValueDesc);
     341          52 : }
     342             : 
     343          61 : 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          61 :   uint64_t Value = ParseInteger(Data, Offset);
     350             : 
     351         122 :   std::string Description;
     352          61 :   if (Value < array_lengthof(Strings))
     353         156 :     Description = std::string(Strings[Value]);
     354           9 :   else if (Value <= 12)
     355          63 :     Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
     356          45 :                 + std::string("-byte extended alignment");
     357             :   else
     358             :     Description = "Invalid";
     359             : 
     360          61 :   PrintAttribute(Tag, Value, Description);
     361          61 : }
     362             : 
     363          61 : 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          61 :   uint64_t Value = ParseInteger(Data, Offset);
     371             : 
     372         122 :   std::string Description;
     373          61 :   if (Value < array_lengthof(Strings))
     374         156 :     Description = std::string(Strings[Value]);
     375           9 :   else if (Value <= 12)
     376          54 :     Description = std::string("8-byte stack alignment, ") +
     377          54 :                   utostr(1ULL << Value) + std::string("-byte data alignment");
     378             :   else
     379             :     Description = "Invalid";
     380             : 
     381          61 :   PrintAttribute(Tag, Value, Description);
     382          61 : }
     383             : 
     384          12 : 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          12 :   uint64_t Value = ParseInteger(Data, Offset);
     391             :   StringRef ValueDesc =
     392          36 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     393          12 :   PrintAttribute(Tag, Value, ValueDesc);
     394          12 : }
     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          24 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     405           8 :   PrintAttribute(Tag, Value, ValueDesc);
     406           8 : }
     407             : 
     408          11 : 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          11 :   uint64_t Value = ParseInteger(Data, Offset);
     415             :   StringRef ValueDesc =
     416          33 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     417          11 :   PrintAttribute(Tag, Value, ValueDesc);
     418          11 : }
     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          21 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     427           7 :   PrintAttribute(Tag, Value, ValueDesc);
     428           7 : }
     429             : 
     430          33 : 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          33 :   uint64_t Value = ParseInteger(Data, Offset);
     439             :   StringRef ValueDesc =
     440          99 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     441          33 :   PrintAttribute(Tag, Value, ValueDesc);
     442          33 : }
     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          24 :     (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          21 :     SW->startLine() << "Value: " << Integer << ", " << String << '\n';
     467          14 :     SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
     468           7 :     switch (Integer) {
     469           1 :     case 0:
     470           3 :       SW->printString("Description", StringRef("No Specific Requirements"));
     471           1 :       break;
     472           3 :     case 1:
     473           9 :       SW->printString("Description", StringRef("AEABI Conformant"));
     474           3 :       break;
     475           3 :     default:
     476           9 :       SW->printString("Description", StringRef("AEABI Non-Conformant"));
     477           3 :       break;
     478             :     }
     479             :   }
     480           7 : }
     481             : 
     482          48 : 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          48 :   uint64_t Value = ParseInteger(Data, Offset);
     487             :   StringRef ValueDesc =
     488         144 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     489          48 :   PrintAttribute(Tag, Value, ValueDesc);
     490          48 : }
     491             : 
     492          23 : 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          23 :   uint64_t Value = ParseInteger(Data, Offset);
     497             :   StringRef ValueDesc =
     498          69 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     499          23 :   PrintAttribute(Tag, Value, ValueDesc);
     500          23 : }
     501             : 
     502          50 : 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          50 :   uint64_t Value = ParseInteger(Data, Offset);
     507             :   StringRef ValueDesc =
     508         150 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     509          50 :   PrintAttribute(Tag, Value, ValueDesc);
     510          50 : }
     511             : 
     512          24 : 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          24 :   uint64_t Value = ParseInteger(Data, Offset);
     517             :   StringRef ValueDesc =
     518          72 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     519          24 :   PrintAttribute(Tag, Value, ValueDesc);
     520          24 : }
     521             : 
     522          26 : 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          26 :   uint64_t Value = ParseInteger(Data, Offset);
     529             :   StringRef ValueDesc =
     530          78 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     531          26 :   PrintAttribute(Tag, Value, ValueDesc);
     532          26 : }
     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           9 :     (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           9 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     551           3 :   PrintAttribute(Tag, Value, ValueDesc);
     552           3 : }
     553             : 
     554          36 : 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          36 :   uint64_t Value = ParseInteger(Data, Offset);
     562             :   StringRef ValueDesc =
     563         108 :     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
     564          36 :   PrintAttribute(Tag, Value, ValueDesc);
     565          36 : }
     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         249 : void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
     586             :                                             uint32_t &Offset, uint32_t Length) {
     587        1585 :   while (Offset < Length) {
     588             :     unsigned Length;
     589        1336 :     uint64_t Tag = decodeULEB128(Data + Offset, &Length);
     590        1336 :     Offset += Length;
     591             : 
     592        1336 :     bool Handled = false;
     593       21209 :     for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
     594       21209 :          AHI != AHE && !Handled; ++AHI) {
     595       21162 :       if (DisplayRoutines[AHI].Attribute == Tag) {
     596        2578 :         (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
     597        2578 :                                               Data, Offset);
     598        1289 :         Handled = true;
     599             :         break;
     600             :       }
     601             :     }
     602             :     if (!Handled) {
     603          47 :       if (Tag < 32) {
     604           0 :         errs() << "unhandled AEABI Tag " << Tag
     605           0 :                << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
     606           0 :         continue;
     607             :       }
     608             : 
     609          47 :       if (Tag % 2 == 0)
     610           0 :         IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
     611             :       else
     612          47 :         StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
     613             :     }
     614             :   }
     615         249 : }
     616             : 
     617         249 : void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
     618         249 :   uint32_t Offset = sizeof(uint32_t); /* SectionLength */
     619             : 
     620         249 :   const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
     621         249 :   size_t VendorNameLength = std::strlen(VendorName);
     622         249 :   Offset = Offset + VendorNameLength + 1;
     623             : 
     624         249 :   if (SW) {
     625         144 :     SW->printNumber("SectionLength", Length);
     626         216 :     SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
     627             :   }
     628             : 
     629         747 :   if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
     630           0 :     return;
     631             :   }
     632             : 
     633         498 :   while (Offset < Length) {
     634             :     /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
     635         249 :     uint8_t Tag = Data[Offset];
     636         249 :     Offset = Offset + sizeof(Tag);
     637             : 
     638             :     uint32_t Size =
     639         498 :       *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
     640         249 :     Offset = Offset + sizeof(Size);
     641             : 
     642         249 :     if (SW) {
     643         216 :       SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
     644         144 :       SW->printNumber("Size", Size);
     645             :     }
     646             : 
     647         249 :     if (Size > Length) {
     648           0 :       errs() << "subsection length greater than section length\n";
     649           0 :       return;
     650             :     }
     651             : 
     652         249 :     StringRef ScopeName, IndexName;
     653         498 :     SmallVector<uint8_t, 8> Indicies;
     654         249 :     switch (Tag) {
     655         249 :     case ARMBuildAttrs::File:
     656         249 :       ScopeName = "FileAttributes";
     657         249 :       break;
     658           0 :     case ARMBuildAttrs::Section:
     659           0 :       ScopeName = "SectionAttributes";
     660           0 :       IndexName = "Sections";
     661           0 :       ParseIndexList(Data, Offset, Indicies);
     662           0 :       break;
     663           0 :     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" << utohexstr(Tag) << '\n';
     670             :       return;
     671             :     }
     672             : 
     673         249 :     if (SW) {
     674         144 :       DictScope ASS(*SW, ScopeName);
     675          72 :       if (!Indicies.empty())
     676           0 :         SW->printList(IndexName, Indicies);
     677          72 :       ParseAttributeList(Data, Offset, Length);
     678             :     } else {
     679         177 :       ParseAttributeList(Data, Offset, Length);
     680             :     }
     681             :   }
     682             : }
     683             : 
     684         249 : void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
     685         249 :   size_t Offset = 1;
     686         249 :   unsigned SectionNumber = 0;
     687             : 
     688         498 :   while (Offset < Section.size()) {
     689         498 :     uint32_t SectionLength = isLittle ?
     690         249 :       support::endian::read32le(Section.data() + Offset) :
     691         249 :       support::endian::read32be(Section.data() + Offset);
     692             : 
     693         249 :     if (SW) {
     694         216 :       SW->startLine() << "Section " << ++SectionNumber << " {\n";
     695          72 :       SW->indent();
     696             :     }
     697             : 
     698         249 :     ParseSubsection(Section.data() + Offset, SectionLength);
     699         249 :     Offset = Offset + SectionLength;
     700             : 
     701         249 :     if (SW) {
     702         144 :       SW->unindent();
     703         144 :       SW->startLine() << "}\n";
     704             :     }
     705             :   }
     706         249 : }
     707      144660 : }
     708             : 

Generated by: LCOV version 1.13