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