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 #define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) \ 68 if (Extensions & ID) { \ 69 const char *feature = FEATURE; \ 70 /* INVALID and NONE have no feature name. */ \ 71 if (feature) \ 72 Features.push_back(feature); \ 73 } 74 #include "../../include/llvm/Support/AArch64TargetParser.def" 75 76 return true; 77 } 78 79 bool AArch64::getArchFeatures(AArch64::ArchKind AK, 80 std::vector<StringRef> &Features) { 81 if (AK == ArchKind::ARMV8A) 82 Features.push_back("+v8a"); 83 if (AK == ArchKind::ARMV8_1A) 84 Features.push_back("+v8.1a"); 85 if (AK == ArchKind::ARMV8_2A) 86 Features.push_back("+v8.2a"); 87 if (AK == ArchKind::ARMV8_3A) 88 Features.push_back("+v8.3a"); 89 if (AK == ArchKind::ARMV8_4A) 90 Features.push_back("+v8.4a"); 91 if (AK == ArchKind::ARMV8_5A) 92 Features.push_back("+v8.5a"); 93 if (AK == AArch64::ArchKind::ARMV8_6A) 94 Features.push_back("+v8.6a"); 95 if (AK == AArch64::ArchKind::ARMV8_7A) 96 Features.push_back("+v8.7a"); 97 if (AK == AArch64::ArchKind::ARMV8_8A) 98 Features.push_back("+v8.8a"); 99 if (AK == AArch64::ArchKind::ARMV9A) 100 Features.push_back("+v9a"); 101 if (AK == AArch64::ArchKind::ARMV9_1A) 102 Features.push_back("+v9.1a"); 103 if (AK == AArch64::ArchKind::ARMV9_2A) 104 Features.push_back("+v9.2a"); 105 if (AK == AArch64::ArchKind::ARMV9_3A) 106 Features.push_back("+v9.3a"); 107 if(AK == AArch64::ArchKind::ARMV8R) 108 Features.push_back("+v8r"); 109 110 return AK != ArchKind::INVALID; 111 } 112 113 StringRef AArch64::getArchName(AArch64::ArchKind AK) { 114 return AArch64ARCHNames[static_cast<unsigned>(AK)].getName(); 115 } 116 117 StringRef AArch64::getCPUAttr(AArch64::ArchKind AK) { 118 return AArch64ARCHNames[static_cast<unsigned>(AK)].getCPUAttr(); 119 } 120 121 StringRef AArch64::getSubArch(AArch64::ArchKind AK) { 122 return AArch64ARCHNames[static_cast<unsigned>(AK)].getSubArch(); 123 } 124 125 unsigned AArch64::getArchAttr(AArch64::ArchKind AK) { 126 return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchAttr; 127 } 128 129 StringRef AArch64::getArchExtName(unsigned ArchExtKind) { 130 for (const auto &AE : AArch64ARCHExtNames) 131 if (ArchExtKind == AE.ID) 132 return AE.getName(); 133 return StringRef(); 134 } 135 136 StringRef AArch64::getArchExtFeature(StringRef ArchExt) { 137 if (ArchExt.startswith("no")) { 138 StringRef ArchExtBase(ArchExt.substr(2)); 139 for (const auto &AE : AArch64ARCHExtNames) { 140 if (AE.NegFeature && ArchExtBase == AE.getName()) 141 return StringRef(AE.NegFeature); 142 } 143 } 144 145 for (const auto &AE : AArch64ARCHExtNames) 146 if (AE.Feature && ArchExt == AE.getName()) 147 return StringRef(AE.Feature); 148 return StringRef(); 149 } 150 151 StringRef AArch64::getDefaultCPU(StringRef Arch) { 152 ArchKind AK = parseArch(Arch); 153 if (AK == ArchKind::INVALID) 154 return StringRef(); 155 156 // Look for multiple AKs to find the default for pair AK+Name. 157 for (const auto &CPU : AArch64CPUNames) 158 if (CPU.ArchID == AK && CPU.Default) 159 return CPU.getName(); 160 161 // If we can't find a default then target the architecture instead 162 return "generic"; 163 } 164 165 void AArch64::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) { 166 for (const auto &Arch : AArch64CPUNames) { 167 if (Arch.ArchID != ArchKind::INVALID) 168 Values.push_back(Arch.getName()); 169 } 170 } 171 172 bool AArch64::isX18ReservedByDefault(const Triple &TT) { 173 return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() || 174 TT.isOSWindows(); 175 } 176 177 // Allows partial match, ex. "v8a" matches "armv8a". 178 AArch64::ArchKind AArch64::parseArch(StringRef Arch) { 179 Arch = ARM::getCanonicalArchName(Arch); 180 if (checkArchVersion(Arch) < 8) 181 return ArchKind::INVALID; 182 183 StringRef Syn = ARM::getArchSynonym(Arch); 184 for (const auto &A : AArch64ARCHNames) { 185 if (A.getName().endswith(Syn)) 186 return A.ID; 187 } 188 return ArchKind::INVALID; 189 } 190 191 AArch64::ArchExtKind AArch64::parseArchExt(StringRef ArchExt) { 192 for (const auto &A : AArch64ARCHExtNames) { 193 if (ArchExt == A.getName()) 194 return static_cast<ArchExtKind>(A.ID); 195 } 196 return AArch64::AEK_INVALID; 197 } 198 199 AArch64::ArchKind AArch64::parseCPUArch(StringRef CPU) { 200 for (const auto &C : AArch64CPUNames) { 201 if (CPU == C.getName()) 202 return C.ArchID; 203 } 204 return ArchKind::INVALID; 205 } 206