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