Home | History | Annotate | Line # | Download | only in Support 
      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 
      9 #include "llvm/Support/ARMAttributeParser.h"
     10 #include "llvm/ADT/STLExtras.h"
     11 #include "llvm/ADT/StringExtras.h"
     12 #include "llvm/Support/Errc.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 #define ATTRIBUTE_HANDLER(attr)                                                \
     20   { ARMBuildAttrs::attr, &ARMAttributeParser::attr }
     21 
     22 const ARMAttributeParser::DisplayHandler ARMAttributeParser::displayRoutines[] =
     23     {
     24         {ARMBuildAttrs::CPU_raw_name, &ARMAttributeParser::stringAttribute},
     25         {ARMBuildAttrs::CPU_name, &ARMAttributeParser::stringAttribute},
     26         ATTRIBUTE_HANDLER(CPU_arch),
     27         ATTRIBUTE_HANDLER(CPU_arch_profile),
     28         ATTRIBUTE_HANDLER(ARM_ISA_use),
     29         ATTRIBUTE_HANDLER(THUMB_ISA_use),
     30         ATTRIBUTE_HANDLER(FP_arch),
     31         ATTRIBUTE_HANDLER(WMMX_arch),
     32         ATTRIBUTE_HANDLER(Advanced_SIMD_arch),
     33         ATTRIBUTE_HANDLER(MVE_arch),
     34         ATTRIBUTE_HANDLER(PCS_config),
     35         ATTRIBUTE_HANDLER(ABI_PCS_R9_use),
     36         ATTRIBUTE_HANDLER(ABI_PCS_RW_data),
     37         ATTRIBUTE_HANDLER(ABI_PCS_RO_data),
     38         ATTRIBUTE_HANDLER(ABI_PCS_GOT_use),
     39         ATTRIBUTE_HANDLER(ABI_PCS_wchar_t),
     40         ATTRIBUTE_HANDLER(ABI_FP_rounding),
     41         ATTRIBUTE_HANDLER(ABI_FP_denormal),
     42         ATTRIBUTE_HANDLER(ABI_FP_exceptions),
     43         ATTRIBUTE_HANDLER(ABI_FP_user_exceptions),
     44         ATTRIBUTE_HANDLER(ABI_FP_number_model),
     45         ATTRIBUTE_HANDLER(ABI_align_needed),
     46         ATTRIBUTE_HANDLER(ABI_align_preserved),
     47         ATTRIBUTE_HANDLER(ABI_enum_size),
     48         ATTRIBUTE_HANDLER(ABI_HardFP_use),
     49         ATTRIBUTE_HANDLER(ABI_VFP_args),
     50         ATTRIBUTE_HANDLER(ABI_WMMX_args),
     51         ATTRIBUTE_HANDLER(ABI_optimization_goals),
     52         ATTRIBUTE_HANDLER(ABI_FP_optimization_goals),
     53         ATTRIBUTE_HANDLER(compatibility),
     54         ATTRIBUTE_HANDLER(CPU_unaligned_access),
     55         ATTRIBUTE_HANDLER(FP_HP_extension),
     56         ATTRIBUTE_HANDLER(ABI_FP_16bit_format),
     57         ATTRIBUTE_HANDLER(MPextension_use),
     58         ATTRIBUTE_HANDLER(DIV_use),
     59         ATTRIBUTE_HANDLER(DSP_extension),
     60         ATTRIBUTE_HANDLER(T2EE_use),
     61         ATTRIBUTE_HANDLER(Virtualization_use),
     62         ATTRIBUTE_HANDLER(nodefaults),
     63 };
     64 
     65 #undef ATTRIBUTE_HANDLER
     66 
     67 Error ARMAttributeParser::stringAttribute(AttrType tag) {
     68   StringRef tagName =
     69       ELFAttrs::attrTypeAsString(tag, tagToStringMap, /*TagPrefix=*/false);
     70   StringRef desc = de.getCStrRef(cursor);
     71 
     72   if (sw) {
     73     DictScope scope(*sw, "Attribute");
     74     sw->printNumber("Tag", tag);
     75     if (!tagName.empty())
     76       sw->printString("TagName", tagName);
     77     sw->printString("Value", desc);
     78   }
     79   return Error::success();
     80 }
     81 
     82 Error ARMAttributeParser::CPU_arch(AttrType tag) {
     83   static const char *strings[] = {
     84     "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
     85     "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
     86     "ARM v7E-M", "ARM v8", nullptr,
     87     "ARM v8-M Baseline", "ARM v8-M Mainline", nullptr, nullptr, nullptr,
     88     "ARM v8.1-M Mainline"
     89   };
     90   return parseStringAttribute("CPU_arch", tag, makeArrayRef(strings));
     91 }
     92 
     93 Error ARMAttributeParser::CPU_arch_profile(AttrType tag) {
     94   uint64_t value = de.getULEB128(cursor);
     95 
     96   StringRef profile;
     97   switch (value) {
     98   default: profile = "Unknown"; break;
     99   case 'A': profile = "Application"; break;
    100   case 'R': profile = "Real-time"; break;
    101   case 'M': profile = "Microcontroller"; break;
    102   case 'S': profile = "Classic"; break;
    103   case 0: profile = "None"; break;
    104   }
    105 
    106   printAttribute(tag, value, profile);
    107   return Error::success();
    108 }
    109 
    110 Error ARMAttributeParser::ARM_ISA_use(AttrType tag) {
    111   static const char *strings[] = {"Not Permitted", "Permitted"};
    112   return parseStringAttribute("ARM_ISA_use", tag, makeArrayRef(strings));
    113 }
    114 
    115 Error ARMAttributeParser::THUMB_ISA_use(AttrType tag) {
    116   static const char *strings[] = {"Not Permitted", "Thumb-1", "Thumb-2", "Permitted"};
    117   return parseStringAttribute("THUMB_ISA_use", tag, makeArrayRef(strings));
    118 }
    119 
    120 Error ARMAttributeParser::FP_arch(AttrType tag) {
    121   static const char *strings[] = {
    122       "Not Permitted", "VFPv1",     "VFPv2",      "VFPv3",         "VFPv3-D16",
    123       "VFPv4",         "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"};
    124   return parseStringAttribute("FP_arch", tag, makeArrayRef(strings));
    125 }
    126 
    127 Error ARMAttributeParser::WMMX_arch(AttrType tag) {
    128   static const char *strings[] = {"Not Permitted", "WMMXv1", "WMMXv2"};
    129   return parseStringAttribute("WMMX_arch", tag, makeArrayRef(strings));
    130 }
    131 
    132 Error ARMAttributeParser::Advanced_SIMD_arch(AttrType tag) {
    133   static const char *strings[] = {"Not Permitted", "NEONv1", "NEONv2+FMA",
    134                                   "ARMv8-a NEON", "ARMv8.1-a NEON"};
    135   return parseStringAttribute("Advanced_SIMD_arch", tag, makeArrayRef(strings));
    136 }
    137 
    138 Error ARMAttributeParser::MVE_arch(AttrType tag) {
    139   static const char *strings[] = {"Not Permitted", "MVE integer",
    140                                   "MVE integer and float"};
    141   return parseStringAttribute("MVE_arch", tag, makeArrayRef(strings));
    142 }
    143 
    144 Error ARMAttributeParser::PCS_config(AttrType tag) {
    145   static const char *strings[] = {
    146     "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
    147     "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"};
    148   return parseStringAttribute("PCS_config", tag, makeArrayRef(strings));
    149 }
    150 
    151 Error ARMAttributeParser::ABI_PCS_R9_use(AttrType tag) {
    152   static const char *strings[] = {"v6", "Static Base", "TLS", "Unused"};
    153   return parseStringAttribute("ABI_PCS_R9_use", tag, makeArrayRef(strings));
    154 }
    155 
    156 Error ARMAttributeParser::ABI_PCS_RW_data(AttrType tag) {
    157   static const char *strings[] = {"Absolute", "PC-relative", "SB-relative",
    158                                   "Not Permitted"};
    159   return parseStringAttribute("ABI_PCS_RW_data", tag, makeArrayRef(strings));
    160 }
    161 
    162 Error ARMAttributeParser::ABI_PCS_RO_data(AttrType tag) {
    163   static const char *strings[] = {"Absolute", "PC-relative", "Not Permitted"};
    164   return parseStringAttribute("ABI_PCS_RO_data", tag, makeArrayRef(strings));
    165 }
    166 
    167 Error ARMAttributeParser::ABI_PCS_GOT_use(AttrType tag) {
    168   static const char *strings[] = {"Not Permitted", "Direct", "GOT-Indirect"};
    169   return parseStringAttribute("ABI_PCS_GOT_use", tag, makeArrayRef(strings));
    170 }
    171 
    172 Error ARMAttributeParser::ABI_PCS_wchar_t(AttrType tag) {
    173   static const char *strings[] = {"Not Permitted", "Unknown", "2-byte",
    174                                   "Unknown", "4-byte"};
    175   return parseStringAttribute("ABI_PCS_wchar_t", tag, makeArrayRef(strings));
    176 }
    177 
    178 Error ARMAttributeParser::ABI_FP_rounding(AttrType tag) {
    179   static const char *strings[] = {"IEEE-754", "Runtime"};
    180   return parseStringAttribute("ABI_FP_rounding", tag, makeArrayRef(strings));
    181 }
    182 
    183 Error ARMAttributeParser::ABI_FP_denormal(AttrType tag) {
    184   static const char *strings[] = {"Unsupported", "IEEE-754", "Sign Only"};
    185   return parseStringAttribute("ABI_FP_denormal", tag, makeArrayRef(strings));
    186 }
    187 
    188 Error ARMAttributeParser::ABI_FP_exceptions(AttrType tag) {
    189   static const char *strings[] = {"Not Permitted", "IEEE-754"};
    190   return parseStringAttribute("ABI_FP_exceptions", tag, makeArrayRef(strings));
    191 }
    192 Error ARMAttributeParser::ABI_FP_user_exceptions(AttrType tag) {
    193   static const char *strings[] = {"Not Permitted", "IEEE-754"};
    194   return parseStringAttribute("ABI_FP_user_exceptions", tag,
    195                               makeArrayRef(strings));
    196 }
    197 
    198 Error ARMAttributeParser::ABI_FP_number_model(AttrType tag) {
    199   static const char *strings[] = {"Not Permitted", "Finite Only", "RTABI",
    200                                   "IEEE-754"};
    201   return parseStringAttribute("ABI_FP_number_model", tag,
    202                               makeArrayRef(strings));
    203 }
    204 
    205 Error ARMAttributeParser::ABI_align_needed(AttrType tag) {
    206   static const char *strings[] = {"Not Permitted", "8-byte alignment",
    207                                   "4-byte alignment", "Reserved"};
    208 
    209   uint64_t value = de.getULEB128(cursor);
    210 
    211   std::string description;
    212   if (value < array_lengthof(strings))
    213     description = strings[value];
    214   else if (value <= 12)
    215     description = "8-byte alignment, " + utostr(1ULL << value) +
    216                   "-byte extended alignment";
    217   else
    218     description = "Invalid";
    219 
    220   printAttribute(tag, value, description);
    221   return Error::success();
    222 }
    223 
    224 Error ARMAttributeParser::ABI_align_preserved(AttrType tag) {
    225   static const char *strings[] = {"Not Required", "8-byte data alignment",
    226                                   "8-byte data and code alignment", "Reserved"};
    227 
    228   uint64_t value = de.getULEB128(cursor);
    229 
    230   std::string description;
    231   if (value < array_lengthof(strings))
    232     description = std::string(strings[value]);
    233   else if (value <= 12)
    234     description = std::string("8-byte stack alignment, ") +
    235                   utostr(1ULL << value) + std::string("-byte data alignment");
    236   else
    237     description = "Invalid";
    238 
    239   printAttribute(tag, value, description);
    240   return Error::success();
    241 }
    242 
    243 Error ARMAttributeParser::ABI_enum_size(AttrType tag) {
    244   static const char *strings[] = {"Not Permitted", "Packed", "Int32",
    245                                   "External Int32"};
    246   return parseStringAttribute("ABI_enum_size", tag, makeArrayRef(strings));
    247 }
    248 
    249 Error ARMAttributeParser::ABI_HardFP_use(AttrType tag) {
    250   static const char *strings[] = {"Tag_FP_arch", "Single-Precision", "Reserved",
    251                                   "Tag_FP_arch (deprecated)"};
    252   return parseStringAttribute("ABI_HardFP_use", tag, makeArrayRef(strings));
    253 }
    254 
    255 Error ARMAttributeParser::ABI_VFP_args(AttrType tag) {
    256   static const char *strings[] = {"AAPCS", "AAPCS VFP", "Custom",
    257                                   "Not Permitted"};
    258   return parseStringAttribute("ABI_VFP_args", tag, makeArrayRef(strings));
    259 }
    260 
    261 Error ARMAttributeParser::ABI_WMMX_args(AttrType tag) {
    262   static const char *strings[] = {"AAPCS", "iWMMX", "Custom"};
    263   return parseStringAttribute("ABI_WMMX_args", tag, makeArrayRef(strings));
    264 }
    265 
    266 Error ARMAttributeParser::ABI_optimization_goals(AttrType tag) {
    267   static const char *strings[] = {
    268     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
    269     "Best Debugging"
    270   };
    271   return parseStringAttribute("ABI_optimization_goals", tag,
    272                               makeArrayRef(strings));
    273 }
    274 
    275 Error ARMAttributeParser::ABI_FP_optimization_goals(AttrType tag) {
    276   static const char *strings[] = {
    277       "None",     "Speed",        "Aggressive Speed", "Size", "Aggressive Size",
    278       "Accuracy", "Best Accuracy"};
    279   return parseStringAttribute("ABI_FP_optimization_goals", tag,
    280                               makeArrayRef(strings));
    281 }
    282 
    283 Error ARMAttributeParser::compatibility(AttrType tag) {
    284   uint64_t integer = de.getULEB128(cursor);
    285   StringRef string = de.getCStrRef(cursor);
    286 
    287   if (sw) {
    288     DictScope scope(*sw, "Attribute");
    289     sw->printNumber("Tag", tag);
    290     sw->startLine() << "Value: " << integer << ", " << string << '\n';
    291     sw->printString("TagName",
    292                     ELFAttrs::attrTypeAsString(tag, tagToStringMap,
    293                                                /*hasTagPrefix=*/false));
    294     switch (integer) {
    295     case 0:
    296       sw->printString("Description", StringRef("No Specific Requirements"));
    297       break;
    298     case 1:
    299       sw->printString("Description", StringRef("AEABI Conformant"));
    300       break;
    301     default:
    302       sw->printString("Description", StringRef("AEABI Non-Conformant"));
    303       break;
    304     }
    305   }
    306   return Error::success();
    307 }
    308 
    309 Error ARMAttributeParser::CPU_unaligned_access(AttrType tag) {
    310   static const char *strings[] = {"Not Permitted", "v6-style"};
    311   return parseStringAttribute("CPU_unaligned_access", tag,
    312                               makeArrayRef(strings));
    313 }
    314 
    315 Error ARMAttributeParser::FP_HP_extension(AttrType tag) {
    316   static const char *strings[] = {"If Available", "Permitted"};
    317   return parseStringAttribute("FP_HP_extension", tag, makeArrayRef(strings));
    318 }
    319 
    320 Error ARMAttributeParser::ABI_FP_16bit_format(AttrType tag) {
    321   static const char *strings[] = {"Not Permitted", "IEEE-754", "VFPv3"};
    322   return parseStringAttribute("ABI_FP_16bit_format", tag,
    323                               makeArrayRef(strings));
    324 }
    325 
    326 Error ARMAttributeParser::MPextension_use(AttrType tag) {
    327   static const char *strings[] = {"Not Permitted", "Permitted"};
    328   return parseStringAttribute("MPextension_use", tag, makeArrayRef(strings));
    329 }
    330 
    331 Error ARMAttributeParser::DIV_use(AttrType tag) {
    332   static const char *strings[] = {"If Available", "Not Permitted", "Permitted"};
    333   return parseStringAttribute("DIV_use", tag, makeArrayRef(strings));
    334 }
    335 
    336 Error ARMAttributeParser::DSP_extension(AttrType tag) {
    337   static const char *strings[] = {"Not Permitted", "Permitted"};
    338   return parseStringAttribute("DSP_extension", tag, makeArrayRef(strings));
    339 }
    340 
    341 Error ARMAttributeParser::T2EE_use(AttrType tag) {
    342   static const char *strings[] = {"Not Permitted", "Permitted"};
    343   return parseStringAttribute("T2EE_use", tag, makeArrayRef(strings));
    344 }
    345 
    346 Error ARMAttributeParser::Virtualization_use(AttrType tag) {
    347   static const char *strings[] = {"Not Permitted", "TrustZone",
    348                                   "Virtualization Extensions",
    349                                   "TrustZone + Virtualization Extensions"};
    350   return parseStringAttribute("Virtualization_use", tag, makeArrayRef(strings));
    351 }
    352 
    353 Error ARMAttributeParser::nodefaults(AttrType tag) {
    354   uint64_t value = de.getULEB128(cursor);
    355   printAttribute(tag, value, "Unspecified Tags UNDEFINED");
    356   return Error::success();
    357 }
    358 
    359 Error ARMAttributeParser::handler(uint64_t tag, bool &handled) {
    360   handled = false;
    361   for (unsigned AHI = 0, AHE = array_lengthof(displayRoutines); AHI != AHE;
    362        ++AHI) {
    363     if (uint64_t(displayRoutines[AHI].attribute) == tag) {
    364       if (Error e =
    365               (this->*displayRoutines[AHI].routine)(static_cast<AttrType>(tag)))
    366         return e;
    367       handled = true;
    368       break;
    369     }
    370   }
    371 
    372   return Error::success();
    373 }
    374