Home | History | Annotate | Line # | Download | only in Support 
      1 //===-- AArch64TargetParser - Parser for AArch64 features -------*- C++ -*-===//
      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 // This file implements a target parser to recognise AArch64 hardware features
     10 // such as FPU/CPU/ARCH and extension names.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "llvm/Support/AArch64TargetParser.h"
     15 #include "llvm/ADT/StringSwitch.h"
     16 #include "llvm/ADT/Triple.h"
     17 #include <cctype>
     18 
     19 using namespace llvm;
     20 
     21 static unsigned checkArchVersion(llvm::StringRef Arch) {
     22   if (Arch.size() >= 2 && Arch[0] == 'v' && std::isdigit(Arch[1]))
     23     return (Arch[1] - 48);
     24   return 0;
     25 }
     26 
     27 unsigned AArch64::getDefaultFPU(StringRef CPU, AArch64::ArchKind AK) {
     28   if (CPU == "generic")
     29     return AArch64ARCHNames[static_cast<unsigned>(AK)].DefaultFPU;
     30 
     31   return StringSwitch<unsigned>(CPU)
     32 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
     33   .Case(NAME, ARM::DEFAULT_FPU)
     34 #include "../../include/llvm/Support/AArch64TargetParser.def"
     35   .Default(ARM::FK_INVALID);
     36 }
     37 
     38 uint64_t AArch64::getDefaultExtensions(StringRef CPU, AArch64::ArchKind AK) {
     39   if (CPU == "generic")
     40     return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchBaseExtensions;
     41 
     42   return StringSwitch<uint64_t>(CPU)
     43 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
     44   .Case(NAME, AArch64ARCHNames[static_cast<unsigned>(ArchKind::ID)]            \
     45                       .ArchBaseExtensions |                                    \
     46                   DEFAULT_EXT)
     47 #include "../../include/llvm/Support/AArch64TargetParser.def"
     48   .Default(AArch64::AEK_INVALID);
     49 }
     50 
     51 AArch64::ArchKind AArch64::getCPUArchKind(StringRef CPU) {
     52   if (CPU == "generic")
     53     return ArchKind::ARMV8A;
     54 
     55   return StringSwitch<AArch64::ArchKind>(CPU)
     56 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
     57   .Case(NAME, ArchKind::ID)
     58 #include "../../include/llvm/Support/AArch64TargetParser.def"
     59   .Default(ArchKind::INVALID);
     60 }
     61 
     62 bool AArch64::getExtensionFeatures(uint64_t Extensions,
     63                                    std::vector<StringRef> &Features) {
     64   if (Extensions == AArch64::AEK_INVALID)
     65     return false;
     66 
     67   if (Extensions & AEK_FP)
     68     Features.push_back("+fp-armv8");
     69   if (Extensions & AEK_SIMD)
     70     Features.push_back("+neon");
     71   if (Extensions & AEK_CRC)
     72     Features.push_back("+crc");
     73   if (Extensions & AEK_CRYPTO)
     74     Features.push_back("+crypto");
     75   if (Extensions & AEK_DOTPROD)
     76     Features.push_back("+dotprod");
     77   if (Extensions & AEK_FP16FML)
     78     Features.push_back("+fp16fml");
     79   if (Extensions & AEK_FP16)
     80     Features.push_back("+fullfp16");
     81   if (Extensions & AEK_PROFILE)
     82     Features.push_back("+spe");
     83   if (Extensions & AEK_RAS)
     84     Features.push_back("+ras");
     85   if (Extensions & AEK_LSE)
     86     Features.push_back("+lse");
     87   if (Extensions & AEK_RDM)
     88     Features.push_back("+rdm");
     89   if (Extensions & AEK_SVE)
     90     Features.push_back("+sve");
     91   if (Extensions & AEK_SVE2)
     92     Features.push_back("+sve2");
     93   if (Extensions & AEK_SVE2AES)
     94     Features.push_back("+sve2-aes");
     95   if (Extensions & AEK_SVE2SM4)
     96     Features.push_back("+sve2-sm4");
     97   if (Extensions & AEK_SVE2SHA3)
     98     Features.push_back("+sve2-sha3");
     99   if (Extensions & AEK_SVE2BITPERM)
    100     Features.push_back("+sve2-bitperm");
    101   if (Extensions & AEK_RCPC)
    102     Features.push_back("+rcpc");
    103   if (Extensions & AEK_BRBE)
    104     Features.push_back("+brbe");
    105   if (Extensions & AEK_PAUTH)
    106     Features.push_back("+pauth");
    107   if (Extensions & AEK_FLAGM)
    108     Features.push_back("+flagm");
    109 
    110   return true;
    111 }
    112 
    113 bool AArch64::getArchFeatures(AArch64::ArchKind AK,
    114                               std::vector<StringRef> &Features) {
    115   if (AK == ArchKind::ARMV8_1A)
    116     Features.push_back("+v8.1a");
    117   if (AK == ArchKind::ARMV8_2A)
    118     Features.push_back("+v8.2a");
    119   if (AK == ArchKind::ARMV8_3A)
    120     Features.push_back("+v8.3a");
    121   if (AK == ArchKind::ARMV8_4A)
    122     Features.push_back("+v8.4a");
    123   if (AK == ArchKind::ARMV8_5A)
    124     Features.push_back("+v8.5a");
    125   if (AK == AArch64::ArchKind::ARMV8_6A)
    126     Features.push_back("+v8.6a");
    127   if (AK == AArch64::ArchKind::ARMV8_7A)
    128     Features.push_back("+v8.7a");
    129   if(AK == AArch64::ArchKind::ARMV8R)
    130     Features.push_back("+v8r");
    131 
    132   return AK != ArchKind::INVALID;
    133 }
    134 
    135 StringRef AArch64::getArchName(AArch64::ArchKind AK) {
    136   return AArch64ARCHNames[static_cast<unsigned>(AK)].getName();
    137 }
    138 
    139 StringRef AArch64::getCPUAttr(AArch64::ArchKind AK) {
    140   return AArch64ARCHNames[static_cast<unsigned>(AK)].getCPUAttr();
    141 }
    142 
    143 StringRef AArch64::getSubArch(AArch64::ArchKind AK) {
    144   return AArch64ARCHNames[static_cast<unsigned>(AK)].getSubArch();
    145 }
    146 
    147 unsigned AArch64::getArchAttr(AArch64::ArchKind AK) {
    148   return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchAttr;
    149 }
    150 
    151 StringRef AArch64::getArchExtName(unsigned ArchExtKind) {
    152   for (const auto &AE : AArch64ARCHExtNames)
    153     if (ArchExtKind == AE.ID)
    154       return AE.getName();
    155   return StringRef();
    156 }
    157 
    158 StringRef AArch64::getArchExtFeature(StringRef ArchExt) {
    159   if (ArchExt.startswith("no")) {
    160     StringRef ArchExtBase(ArchExt.substr(2));
    161     for (const auto &AE : AArch64ARCHExtNames) {
    162       if (AE.NegFeature && ArchExtBase == AE.getName())
    163         return StringRef(AE.NegFeature);
    164     }
    165   }
    166 
    167   for (const auto &AE : AArch64ARCHExtNames)
    168     if (AE.Feature && ArchExt == AE.getName())
    169       return StringRef(AE.Feature);
    170   return StringRef();
    171 }
    172 
    173 StringRef AArch64::getDefaultCPU(StringRef Arch) {
    174   ArchKind AK = parseArch(Arch);
    175   if (AK == ArchKind::INVALID)
    176     return StringRef();
    177 
    178   // Look for multiple AKs to find the default for pair AK+Name.
    179   for (const auto &CPU : AArch64CPUNames)
    180     if (CPU.ArchID == AK && CPU.Default)
    181       return CPU.getName();
    182 
    183   // If we can't find a default then target the architecture instead
    184   return "generic";
    185 }
    186 
    187 void AArch64::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) {
    188   for (const auto &Arch : AArch64CPUNames) {
    189     if (Arch.ArchID != ArchKind::INVALID)
    190       Values.push_back(Arch.getName());
    191   }
    192 }
    193 
    194 bool AArch64::isX18ReservedByDefault(const Triple &TT) {
    195   return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() ||
    196          TT.isOSWindows();
    197 }
    198 
    199 // Allows partial match, ex. "v8a" matches "armv8a".
    200 AArch64::ArchKind AArch64::parseArch(StringRef Arch) {
    201   Arch = ARM::getCanonicalArchName(Arch);
    202   if (checkArchVersion(Arch) < 8)
    203     return ArchKind::INVALID;
    204 
    205   StringRef Syn = ARM::getArchSynonym(Arch);
    206   for (const auto &A : AArch64ARCHNames) {
    207     if (A.getName().endswith(Syn))
    208       return A.ID;
    209   }
    210   return ArchKind::INVALID;
    211 }
    212 
    213 AArch64::ArchExtKind AArch64::parseArchExt(StringRef ArchExt) {
    214   for (const auto &A : AArch64ARCHExtNames) {
    215     if (ArchExt == A.getName())
    216       return static_cast<ArchExtKind>(A.ID);
    217   }
    218   return AArch64::AEK_INVALID;
    219 }
    220 
    221 AArch64::ArchKind AArch64::parseCPUArch(StringRef CPU) {
    222   for (const auto &C : AArch64CPUNames) {
    223     if (CPU == C.getName())
    224       return C.ArchID;
    225   }
    226   return ArchKind::INVALID;
    227 }
    228 
    229 // Parse a branch protection specification, which has the form
    230 //   standard | none | [bti,pac-ret[+b-key,+leaf]*]
    231 // Returns true on success, with individual elements of the specification
    232 // returned in `PBP`. Returns false in error, with `Err` containing
    233 // an erroneous part of the spec.
    234 bool AArch64::parseBranchProtection(StringRef Spec, ParsedBranchProtection &PBP,
    235                                     StringRef &Err) {
    236   PBP = {"none", "a_key", false};
    237   if (Spec == "none")
    238     return true; // defaults are ok
    239 
    240   if (Spec == "standard") {
    241     PBP.Scope = "non-leaf";
    242     PBP.BranchTargetEnforcement = true;
    243     return true;
    244   }
    245 
    246   SmallVector<StringRef, 4> Opts;
    247   Spec.split(Opts, "+");
    248   for (int I = 0, E = Opts.size(); I != E; ++I) {
    249     StringRef Opt = Opts[I].trim();
    250     if (Opt == "bti") {
    251       PBP.BranchTargetEnforcement = true;
    252       continue;
    253     }
    254     if (Opt == "pac-ret") {
    255       PBP.Scope = "non-leaf";
    256       for (; I + 1 != E; ++I) {
    257         StringRef PACOpt = Opts[I + 1].trim();
    258         if (PACOpt == "leaf")
    259           PBP.Scope = "all";
    260         else if (PACOpt == "b-key")
    261           PBP.Key = "b_key";
    262         else
    263           break;
    264       }
    265       continue;
    266     }
    267     if (Opt == "")
    268       Err = "<empty>";
    269     else
    270       Err = Opt;
    271     return false;
    272   }
    273 
    274   return true;
    275 }
    276