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 & AArch64::AEK_TME) 102 Features.push_back("+tme"); 103 if (Extensions & AEK_RCPC) 104 Features.push_back("+rcpc"); 105 if (Extensions & AEK_BRBE) 106 Features.push_back("+brbe"); 107 if (Extensions & AEK_PAUTH) 108 Features.push_back("+pauth"); 109 if (Extensions & AEK_FLAGM) 110 Features.push_back("+flagm"); 111 if (Extensions & AArch64::AEK_SME) 112 Features.push_back("+sme"); 113 if (Extensions & AArch64::AEK_SMEF64) 114 Features.push_back("+sme-f64"); 115 if (Extensions & AArch64::AEK_SMEI64) 116 Features.push_back("+sme-i64"); 117 if (Extensions & AArch64::AEK_HBC) 118 Features.push_back("+hbc"); 119 if (Extensions & AArch64::AEK_MOPS) 120 Features.push_back("+mops"); 121 if (Extensions & AArch64::AEK_PERFMON) 122 Features.push_back("+perfmon"); 123 if (Extensions & AArch64::AEK_SSBS) 124 Features.push_back("+ssbs"); 125 126 return true; 127 } 128 129 bool AArch64::getArchFeatures(AArch64::ArchKind AK, 130 std::vector<StringRef> &Features) { 131 if (AK == ArchKind::ARMV8A) 132 Features.push_back("+v8a"); 133 if (AK == ArchKind::ARMV8_1A) 134 Features.push_back("+v8.1a"); 135 if (AK == ArchKind::ARMV8_2A) 136 Features.push_back("+v8.2a"); 137 if (AK == ArchKind::ARMV8_3A) 138 Features.push_back("+v8.3a"); 139 if (AK == ArchKind::ARMV8_4A) 140 Features.push_back("+v8.4a"); 141 if (AK == ArchKind::ARMV8_5A) 142 Features.push_back("+v8.5a"); 143 if (AK == AArch64::ArchKind::ARMV8_6A) 144 Features.push_back("+v8.6a"); 145 if (AK == AArch64::ArchKind::ARMV8_7A) 146 Features.push_back("+v8.7a"); 147 if (AK == AArch64::ArchKind::ARMV8_8A) 148 Features.push_back("+v8.8a"); 149 if (AK == AArch64::ArchKind::ARMV9A) 150 Features.push_back("+v9a"); 151 if (AK == AArch64::ArchKind::ARMV9_1A) 152 Features.push_back("+v9.1a"); 153 if (AK == AArch64::ArchKind::ARMV9_2A) 154 Features.push_back("+v9.2a"); 155 if (AK == AArch64::ArchKind::ARMV9_3A) 156 Features.push_back("+v9.3a"); 157 if(AK == AArch64::ArchKind::ARMV8R) 158 Features.push_back("+v8r"); 159 160 return AK != ArchKind::INVALID; 161 } 162 163 StringRef AArch64::getArchName(AArch64::ArchKind AK) { 164 return AArch64ARCHNames[static_cast<unsigned>(AK)].getName(); 165 } 166 167 StringRef AArch64::getCPUAttr(AArch64::ArchKind AK) { 168 return AArch64ARCHNames[static_cast<unsigned>(AK)].getCPUAttr(); 169 } 170 171 StringRef AArch64::getSubArch(AArch64::ArchKind AK) { 172 return AArch64ARCHNames[static_cast<unsigned>(AK)].getSubArch(); 173 } 174 175 unsigned AArch64::getArchAttr(AArch64::ArchKind AK) { 176 return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchAttr; 177 } 178 179 StringRef AArch64::getArchExtName(unsigned ArchExtKind) { 180 for (const auto &AE : AArch64ARCHExtNames) 181 if (ArchExtKind == AE.ID) 182 return AE.getName(); 183 return StringRef(); 184 } 185 186 StringRef AArch64::getArchExtFeature(StringRef ArchExt) { 187 if (ArchExt.startswith("no")) { 188 StringRef ArchExtBase(ArchExt.substr(2)); 189 for (const auto &AE : AArch64ARCHExtNames) { 190 if (AE.NegFeature && ArchExtBase == AE.getName()) 191 return StringRef(AE.NegFeature); 192 } 193 } 194 195 for (const auto &AE : AArch64ARCHExtNames) 196 if (AE.Feature && ArchExt == AE.getName()) 197 return StringRef(AE.Feature); 198 return StringRef(); 199 } 200 201 StringRef AArch64::getDefaultCPU(StringRef Arch) { 202 ArchKind AK = parseArch(Arch); 203 if (AK == ArchKind::INVALID) 204 return StringRef(); 205 206 // Look for multiple AKs to find the default for pair AK+Name. 207 for (const auto &CPU : AArch64CPUNames) 208 if (CPU.ArchID == AK && CPU.Default) 209 return CPU.getName(); 210 211 // If we can't find a default then target the architecture instead 212 return "generic"; 213 } 214 215 void AArch64::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) { 216 for (const auto &Arch : AArch64CPUNames) { 217 if (Arch.ArchID != ArchKind::INVALID) 218 Values.push_back(Arch.getName()); 219 } 220 } 221 222 bool AArch64::isX18ReservedByDefault(const Triple &TT) { 223 return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() || 224 TT.isOSWindows(); 225 } 226 227 // Allows partial match, ex. "v8a" matches "armv8a". 228 AArch64::ArchKind AArch64::parseArch(StringRef Arch) { 229 Arch = ARM::getCanonicalArchName(Arch); 230 if (checkArchVersion(Arch) < 8) 231 return ArchKind::INVALID; 232 233 StringRef Syn = ARM::getArchSynonym(Arch); 234 for (const auto &A : AArch64ARCHNames) { 235 if (A.getName().endswith(Syn)) 236 return A.ID; 237 } 238 return ArchKind::INVALID; 239 } 240 241 AArch64::ArchExtKind AArch64::parseArchExt(StringRef ArchExt) { 242 for (const auto &A : AArch64ARCHExtNames) { 243 if (ArchExt == A.getName()) 244 return static_cast<ArchExtKind>(A.ID); 245 } 246 return AArch64::AEK_INVALID; 247 } 248 249 AArch64::ArchKind AArch64::parseCPUArch(StringRef CPU) { 250 for (const auto &C : AArch64CPUNames) { 251 if (CPU == C.getName()) 252 return C.ArchID; 253 } 254 return ArchKind::INVALID; 255 } 256