1 //===----------- TargetParser.cpp - Target Parser -------------------------===// 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 #include "llvm/TargetParser/TargetParser.h" 10 #include "llvm/ADT/STLExtras.h" 11 #include "llvm/ADT/StringMap.h" 12 #include "llvm/ADT/StringExtras.h" 13 #include "llvm/Support/ARMBuildAttributes.h" 14 #include "llvm/Support/FormatVariadic.h" 15 #include "llvm/TargetParser/AArch64TargetParser.h" 16 #include "llvm/TargetParser/ARMTargetParser.h" 17 #include "llvm/TargetParser/ARMTargetParserCommon.h" 18 #include "llvm/TargetParser/Triple.h" 19 #include "gmock/gmock.h" 20 #include "gtest/gtest.h" 21 #include <optional> 22 #include <sstream> 23 #include <string> 24 25 using namespace llvm; 26 27 namespace { 28 const char *ARMArch[] = { 29 "armv4", "armv4t", "armv5", "armv5t", "armv5e", 30 "armv5te", "armv5tej", "armv6", "armv6j", "armv6k", 31 "armv6hl", "armv6t2", "armv6kz", "armv6z", "armv6zk", 32 "armv6-m", "armv6m", "armv6sm", "armv6s-m", "armv7-a", 33 "armv7", "armv7a", "armv7ve", "armv7hl", "armv7l", 34 "armv7-r", "armv7r", "armv7-m", "armv7m", "armv7k", 35 "armv7s", "armv7e-m", "armv7em", "armv8-a", "armv8", 36 "armv8a", "armv8l", "armv8.1-a", "armv8.1a", "armv8.2-a", 37 "armv8.2a", "armv8.3-a", "armv8.3a", "armv8.4-a", "armv8.4a", 38 "armv8.5-a", "armv8.5a", "armv8.6-a", "armv8.6a", "armv8.7-a", 39 "armv8.7a", "armv8.8-a", "armv8.8a", "armv8.9-a", "armv8.9a", 40 "armv8-r", "armv8r", "armv8-m.base", "armv8m.base", "armv8-m.main", 41 "armv8m.main", "iwmmxt", "iwmmxt2", "xscale", "armv8.1-m.main", 42 "armv9-a", "armv9", "armv9a", "armv9.1-a", "armv9.1a", 43 "armv9.2-a", "armv9.2a", "armv9.3-a", "armv9.3a", "armv9.4-a", 44 "armv9.4a", 45 }; 46 47 std::string FormatExtensionFlags(int64_t Flags) { 48 std::vector<StringRef> Features; 49 50 if (Flags & ARM::AEK_NONE) 51 Features.push_back("none"); 52 ARM::getExtensionFeatures(Flags, Features); 53 54 // The target parser also includes every extension you don't have. 55 // E.g. if AEK_CRC is not set then it adds "-crc". Not useful here. 56 Features.erase(std::remove_if(Features.begin(), Features.end(), 57 [](StringRef extension) { 58 return extension.startswith("-"); 59 }), 60 Features.end()); 61 62 return llvm::join(Features, ", "); 63 } 64 65 std::string FormatExtensionFlags(AArch64::ExtensionBitset Flags) { 66 std::vector<StringRef> Features; 67 68 // AEK_NONE is not meant to be shown to the user so the target parser 69 // does not recognise it. It is relevant here though. 70 if (Flags.test(AArch64::AEK_NONE)) 71 Features.push_back("none"); 72 AArch64::getExtensionFeatures(Flags, Features); 73 74 // The target parser also includes every extension you don't have. 75 // E.g. if AEK_CRC is not set then it adds "-crc". Not useful here. 76 Features.erase(std::remove_if(Features.begin(), Features.end(), 77 [](StringRef extension) { 78 return extension.startswith("-"); 79 }), 80 Features.end()); 81 82 return llvm::join(Features, ", "); 83 } 84 85 std::string SerializeExtensionFlags(AArch64::ExtensionBitset Flags) { 86 std::string SerializedFlags; 87 std::ostringstream ss; 88 int HexValue = 0; 89 for (unsigned int i = 0; i < AArch64::AEK_NUM_EXTENSIONS; i++) { 90 HexValue <<= 1; 91 HexValue |= (int)Flags[i]; 92 if ((i + 1) % 4 == 0) { 93 ss << std::hex << HexValue; 94 HexValue = 0; 95 } 96 } 97 // check if there are remainig unhandled bits 98 if ((AArch64::AEK_NUM_EXTENSIONS % 4) != 0) 99 ss << std::hex << HexValue; 100 101 SerializedFlags = ss.str(); 102 return SerializedFlags; 103 } 104 105 template <ARM::ISAKind ISAKind> struct AssertSameExtensionFlags { 106 AssertSameExtensionFlags(StringRef CPUName) : CPUName(CPUName) {} 107 108 testing::AssertionResult operator()(const char *m_expr, const char *n_expr, 109 uint64_t ExpectedFlags, 110 uint64_t GotFlags) { 111 if (ExpectedFlags == GotFlags) 112 return testing::AssertionSuccess(); 113 114 return testing::AssertionFailure() << llvm::formatv( 115 "CPU: {4}\n" 116 "Expected extension flags: {0} ({1:x})\n" 117 " Got extension flags: {2} ({3:x})\n", 118 FormatExtensionFlags(ExpectedFlags), 119 ExpectedFlags, FormatExtensionFlags(GotFlags), 120 ExpectedFlags, CPUName); 121 } 122 123 testing::AssertionResult 124 operator()(const char *m_expr, const char *n_expr, 125 AArch64::ExtensionBitset ExpectedFlags, 126 AArch64::ExtensionBitset GotFlags) { 127 if (ExpectedFlags == GotFlags) 128 return testing::AssertionSuccess(); 129 130 return testing::AssertionFailure() << llvm::formatv( 131 "CPU: {4}\n" 132 "Expected extension flags: {0} ({1:x})\n" 133 " Got extension flags: {2} ({3:x})\n", 134 FormatExtensionFlags(ExpectedFlags), 135 SerializeExtensionFlags(ExpectedFlags), 136 FormatExtensionFlags(GotFlags), 137 SerializeExtensionFlags(ExpectedFlags), CPUName); 138 } 139 140 private: 141 StringRef CPUName; 142 }; 143 144 template <typename T> struct ARMCPUTestParams { 145 ARMCPUTestParams(StringRef CPUName, StringRef ExpectedArch, 146 StringRef ExpectedFPU, T ExpectedFlags, StringRef CPUAttr) 147 : CPUName(CPUName), ExpectedArch(ExpectedArch), ExpectedFPU(ExpectedFPU), 148 ExpectedFlags(ExpectedFlags), CPUAttr(CPUAttr) {} 149 150 friend std::ostream &operator<<(std::ostream &os, 151 const ARMCPUTestParams<T> ¶ms) { 152 os << "\"" << params.CPUName.str() << "\", \"" << params.ExpectedArch.str() 153 << "\", \"" << params.ExpectedFPU.str() << "\", 0x"; 154 if constexpr (std::is_same<T, uint64_t>::value) 155 os << std::hex << params.ExpectedFlags; 156 else 157 os << SerializeExtensionFlags(params.ExpectedFlags); 158 os << ", \"" << params.CPUAttr.str() << "\""; 159 return os; 160 } 161 162 StringRef CPUName; 163 StringRef ExpectedArch; 164 StringRef ExpectedFPU; 165 T ExpectedFlags; 166 StringRef CPUAttr; 167 }; 168 169 class ARMCPUTestFixture 170 : public ::testing::TestWithParam<ARMCPUTestParams<uint64_t>> {}; 171 172 TEST_P(ARMCPUTestFixture, ARMCPUTests) { 173 auto params = GetParam(); 174 175 ARM::ArchKind AK = ARM::parseCPUArch(params.CPUName); 176 EXPECT_EQ(params.ExpectedArch, ARM::getArchName(AK)); 177 178 ARM::FPUKind FPUKind = ARM::getDefaultFPU(params.CPUName, AK); 179 EXPECT_EQ(params.ExpectedFPU, ARM::getFPUName(FPUKind)); 180 181 uint64_t default_extensions = ARM::getDefaultExtensions(params.CPUName, AK); 182 EXPECT_PRED_FORMAT2( 183 AssertSameExtensionFlags<ARM::ISAKind::ARM>(params.CPUName), 184 params.ExpectedFlags, default_extensions); 185 186 EXPECT_EQ(params.CPUAttr, ARM::getCPUAttr(AK)); 187 } 188 189 // Note that we include ARM::AEK_NONE even when there are other extensions 190 // we expect. This is because the default extensions for a CPU are the sum 191 // of the default extensions for its architecture and for the CPU. 192 // So if a CPU has no extra extensions, it adds AEK_NONE. 193 INSTANTIATE_TEST_SUITE_P( 194 ARMCPUTestsPart1, ARMCPUTestFixture, 195 ::testing::Values( 196 ARMCPUTestParams<uint64_t>("invalid", "invalid", "invalid", ARM::AEK_NONE, ""), 197 ARMCPUTestParams<uint64_t>("generic", "invalid", "none", ARM::AEK_NONE, ""), 198 199 ARMCPUTestParams<uint64_t>("arm8", "armv4", "none", ARM::AEK_NONE, "4"), 200 ARMCPUTestParams<uint64_t>("arm810", "armv4", "none", ARM::AEK_NONE, "4"), 201 ARMCPUTestParams<uint64_t>("strongarm", "armv4", "none", ARM::AEK_NONE, "4"), 202 ARMCPUTestParams<uint64_t>("strongarm110", "armv4", "none", ARM::AEK_NONE, "4"), 203 ARMCPUTestParams<uint64_t>("strongarm1100", "armv4", "none", ARM::AEK_NONE, "4"), 204 ARMCPUTestParams<uint64_t>("strongarm1110", "armv4", "none", ARM::AEK_NONE, "4"), 205 ARMCPUTestParams<uint64_t>("arm7tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"), 206 ARMCPUTestParams<uint64_t>("arm7tdmi-s", "armv4t", "none", ARM::AEK_NONE, "4T"), 207 ARMCPUTestParams<uint64_t>("arm710t", "armv4t", "none", ARM::AEK_NONE, "4T"), 208 ARMCPUTestParams<uint64_t>("arm720t", "armv4t", "none", ARM::AEK_NONE, "4T"), 209 ARMCPUTestParams<uint64_t>("arm9", "armv4t", "none", ARM::AEK_NONE, "4T"), 210 ARMCPUTestParams<uint64_t>("arm9tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"), 211 ARMCPUTestParams<uint64_t>("arm920", "armv4t", "none", ARM::AEK_NONE, "4T"), 212 ARMCPUTestParams<uint64_t>("arm920t", "armv4t", "none", ARM::AEK_NONE, "4T"), 213 ARMCPUTestParams<uint64_t>("arm922t", "armv4t", "none", ARM::AEK_NONE, "4T"), 214 ARMCPUTestParams<uint64_t>("arm940t", "armv4t", "none", ARM::AEK_NONE, "4T"), 215 ARMCPUTestParams<uint64_t>("ep9312", "armv4t", "none", ARM::AEK_NONE, "4T"), 216 ARMCPUTestParams<uint64_t>("arm10tdmi", "armv5t", "none", ARM::AEK_NONE, "5T"), 217 ARMCPUTestParams<uint64_t>("arm1020t", "armv5t", "none", ARM::AEK_NONE, "5T"), 218 ARMCPUTestParams<uint64_t>("arm9e", "armv5te", "none", 219 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 220 ARMCPUTestParams<uint64_t>("arm946e-s", "armv5te", "none", 221 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 222 ARMCPUTestParams<uint64_t>("arm966e-s", "armv5te", "none", 223 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 224 ARMCPUTestParams<uint64_t>("arm968e-s", "armv5te", "none", 225 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 226 ARMCPUTestParams<uint64_t>("arm10e", "armv5te", "none", 227 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 228 ARMCPUTestParams<uint64_t>("arm1020e", "armv5te", "none", 229 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 230 ARMCPUTestParams<uint64_t>("arm1022e", "armv5te", "none", 231 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"), 232 ARMCPUTestParams<uint64_t>("arm926ej-s", "armv5tej", "none", 233 ARM::AEK_NONE | ARM::AEK_DSP, "5TEJ"), 234 ARMCPUTestParams<uint64_t>("arm1136j-s", "armv6", "none", 235 ARM::AEK_NONE | ARM::AEK_DSP, "6"), 236 ARMCPUTestParams<uint64_t>("arm1136jf-s", "armv6", "vfpv2", 237 ARM::AEK_NONE | ARM::AEK_DSP, "6"), 238 ARMCPUTestParams<uint64_t>("arm1176jz-s", "armv6kz", "none", 239 ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"), 240 ARMCPUTestParams<uint64_t>("mpcore", "armv6k", "vfpv2", 241 ARM::AEK_NONE | ARM::AEK_DSP, "6K"), 242 ARMCPUTestParams<uint64_t>("mpcorenovfp", "armv6k", "none", 243 ARM::AEK_NONE | ARM::AEK_DSP, "6K"), 244 ARMCPUTestParams<uint64_t>("arm1176jzf-s", "armv6kz", "vfpv2", 245 ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"), 246 ARMCPUTestParams<uint64_t>("arm1156t2-s", "armv6t2", "none", 247 ARM::AEK_NONE | ARM::AEK_DSP, "6T2"), 248 ARMCPUTestParams<uint64_t>("arm1156t2f-s", "armv6t2", "vfpv2", 249 ARM::AEK_NONE | ARM::AEK_DSP, "6T2"), 250 ARMCPUTestParams<uint64_t>("cortex-m0", "armv6-m", "none", ARM::AEK_NONE, "6-M"), 251 ARMCPUTestParams<uint64_t>("cortex-m0plus", "armv6-m", "none", ARM::AEK_NONE, 252 "6-M"), 253 ARMCPUTestParams<uint64_t>("cortex-m1", "armv6-m", "none", ARM::AEK_NONE, "6-M"), 254 ARMCPUTestParams<uint64_t>("sc000", "armv6-m", "none", ARM::AEK_NONE, "6-M"), 255 ARMCPUTestParams<uint64_t>("cortex-a5", "armv7-a", "neon-vfpv4", 256 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"), 257 ARMCPUTestParams<uint64_t>("cortex-a7", "armv7-a", "neon-vfpv4", 258 ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_MP | 259 ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP, 260 "7-A"), 261 ARMCPUTestParams<uint64_t>("cortex-a8", "armv7-a", "neon", 262 ARM::AEK_SEC | ARM::AEK_DSP, "7-A"))); 263 264 // gtest in llvm has a limit of 50 test cases when using ::Values so we split 265 // them into 2 blocks 266 INSTANTIATE_TEST_SUITE_P( 267 ARMCPUTestsPart2, ARMCPUTestFixture, 268 ::testing::Values( 269 ARMCPUTestParams<uint64_t>("cortex-a9", "armv7-a", "neon-fp16", 270 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"), 271 ARMCPUTestParams<uint64_t>("cortex-a12", "armv7-a", "neon-vfpv4", 272 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 273 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 274 ARM::AEK_DSP, 275 "7-A"), 276 ARMCPUTestParams<uint64_t>("cortex-a15", "armv7-a", "neon-vfpv4", 277 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 278 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 279 ARM::AEK_DSP, 280 "7-A"), 281 ARMCPUTestParams<uint64_t>("cortex-a17", "armv7-a", "neon-vfpv4", 282 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 283 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 284 ARM::AEK_DSP, 285 "7-A"), 286 ARMCPUTestParams<uint64_t>("krait", "armv7-a", "neon-vfpv4", 287 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 288 "7-A"), 289 ARMCPUTestParams<uint64_t>("cortex-r4", "armv7-r", "none", 290 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 291 "7-R"), 292 ARMCPUTestParams<uint64_t>("cortex-r4f", "armv7-r", "vfpv3-d16", 293 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 294 "7-R"), 295 ARMCPUTestParams<uint64_t>("cortex-r5", "armv7-r", "vfpv3-d16", 296 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 297 ARM::AEK_DSP, 298 "7-R"), 299 ARMCPUTestParams<uint64_t>("cortex-r7", "armv7-r", "vfpv3-d16-fp16", 300 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 301 ARM::AEK_DSP, 302 "7-R"), 303 ARMCPUTestParams<uint64_t>("cortex-r8", "armv7-r", "vfpv3-d16-fp16", 304 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 305 ARM::AEK_DSP, 306 "7-R"), 307 ARMCPUTestParams<uint64_t>("cortex-r52", "armv8-r", "neon-fp-armv8", 308 ARM::AEK_NONE | ARM::AEK_CRC | ARM::AEK_MP | 309 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 310 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 311 "8-R"), 312 ARMCPUTestParams<uint64_t>("sc300", "armv7-m", "none", 313 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"), 314 ARMCPUTestParams<uint64_t>("cortex-m3", "armv7-m", "none", 315 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"), 316 ARMCPUTestParams<uint64_t>("cortex-m4", "armv7e-m", "fpv4-sp-d16", 317 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 318 "7E-M"), 319 ARMCPUTestParams<uint64_t>("cortex-m7", "armv7e-m", "fpv5-d16", 320 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 321 "7E-M"), 322 ARMCPUTestParams<uint64_t>("cortex-a32", "armv8-a", "crypto-neon-fp-armv8", 323 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 324 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 325 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 326 "8-A"), 327 ARMCPUTestParams<uint64_t>("cortex-a35", "armv8-a", "crypto-neon-fp-armv8", 328 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 329 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 330 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 331 "8-A"), 332 ARMCPUTestParams<uint64_t>("cortex-a53", "armv8-a", "crypto-neon-fp-armv8", 333 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 334 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 335 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 336 "8-A"), 337 ARMCPUTestParams<uint64_t>("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8", 338 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 339 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 340 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 341 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD, 342 "8.2-A"), 343 ARMCPUTestParams<uint64_t>("cortex-a57", "armv8-a", "crypto-neon-fp-armv8", 344 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 345 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 346 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 347 "8-A"), 348 ARMCPUTestParams<uint64_t>("cortex-a72", "armv8-a", "crypto-neon-fp-armv8", 349 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 350 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 351 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 352 "8-A"), 353 ARMCPUTestParams<uint64_t>("cortex-a73", "armv8-a", "crypto-neon-fp-armv8", 354 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 355 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 356 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 357 "8-A"), 358 ARMCPUTestParams<uint64_t>("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8", 359 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 360 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 361 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 362 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD, 363 "8.2-A"), 364 ARMCPUTestParams<uint64_t>("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8", 365 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 366 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 367 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 368 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD, 369 "8.2-A"), 370 ARMCPUTestParams<uint64_t>("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8", 371 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 372 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 373 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 374 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD, 375 "8.2-A"), 376 ARMCPUTestParams<uint64_t>("cortex-a78c", "armv8.2-a", "crypto-neon-fp-armv8", 377 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 378 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 379 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS | 380 ARM::AEK_FP16 | ARM::AEK_DOTPROD, 381 "8.2-A"), 382 ARMCPUTestParams<uint64_t>("cortex-a710", "armv9-a", "neon-fp-armv8", 383 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 384 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 385 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS | 386 ARM::AEK_DOTPROD | ARM::AEK_FP16FML | 387 ARM::AEK_BF16 | ARM::AEK_I8MM | ARM::AEK_SB, 388 "9-A"), 389 ARMCPUTestParams<uint64_t>("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8", 390 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 391 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 392 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 393 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD, 394 "8.2-A"), 395 ARMCPUTestParams<uint64_t>("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8", 396 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_SEC | 397 ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 398 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_CRC | 399 ARM::AEK_RAS, 400 "8.2-A"), 401 ARMCPUTestParams<uint64_t>("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8", 402 ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD | 403 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 404 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 405 ARM::AEK_DSP | ARM::AEK_CRC, 406 "8.2-A"), 407 ARMCPUTestParams<uint64_t>("cortex-x1c", "armv8.2-a", "crypto-neon-fp-armv8", 408 ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD | 409 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 410 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 411 ARM::AEK_DSP | ARM::AEK_CRC, 412 "8.2-A"), 413 ARMCPUTestParams<uint64_t>("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8", 414 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 415 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 416 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 417 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD, 418 "8.2-A"), 419 ARMCPUTestParams<uint64_t>("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8", 420 ARM::AEK_CRC | ARM::AEK_HWDIVTHUMB | 421 ARM::AEK_HWDIVARM | ARM::AEK_MP | ARM::AEK_SEC | 422 ARM::AEK_VIRT | ARM::AEK_DSP | ARM::AEK_BF16 | 423 ARM::AEK_DOTPROD | ARM::AEK_RAS | ARM::AEK_I8MM | 424 ARM::AEK_SB, 425 "8.5-A"), 426 ARMCPUTestParams<uint64_t>("neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8", 427 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | 428 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | 429 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS | 430 ARM::AEK_FP16 | ARM::AEK_BF16 | ARM::AEK_DOTPROD, 431 "8.4-A"), 432 ARMCPUTestParams<uint64_t>("cyclone", "armv8-a", "crypto-neon-fp-armv8", 433 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 434 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 435 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 436 "8-A"), 437 ARMCPUTestParams<uint64_t>("exynos-m3", "armv8-a", "crypto-neon-fp-armv8", 438 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 439 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 440 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 441 "8-A"), 442 ARMCPUTestParams<uint64_t>("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8", 443 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 444 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 445 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 446 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS, 447 "8.2-A"), 448 ARMCPUTestParams<uint64_t>("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8", 449 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | 450 ARM::AEK_VIRT | ARM::AEK_HWDIVARM | 451 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | 452 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS, 453 "8.2-A"), 454 ARMCPUTestParams<uint64_t>("cortex-m23", "armv8-m.base", "none", 455 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "8-M.Baseline"), 456 ARMCPUTestParams<uint64_t>("cortex-m33", "armv8-m.main", "fpv5-sp-d16", 457 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"), 458 ARMCPUTestParams<uint64_t>("cortex-m35p", "armv8-m.main", "fpv5-sp-d16", 459 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"), 460 ARMCPUTestParams<uint64_t>("cortex-m55", "armv8.1-m.main", 461 "fp-armv8-fullfp16-d16", 462 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD | 463 ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB | 464 ARM::AEK_FP16, 465 "8.1-M.Mainline"), 466 ARMCPUTestParams<uint64_t>("cortex-m85", "armv8.1-m.main", 467 "fp-armv8-fullfp16-d16", 468 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD | 469 ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB | 470 ARM::AEK_FP16 | ARM::AEK_PACBTI, 471 "8.1-M.Mainline"), 472 ARMCPUTestParams<uint64_t>("iwmmxt", "iwmmxt", "none", ARM::AEK_NONE, "iwmmxt"), 473 ARMCPUTestParams<uint64_t>("xscale", "xscale", "none", ARM::AEK_NONE, "xscale"), 474 ARMCPUTestParams<uint64_t>("swift", "armv7s", "neon-vfpv4", 475 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, 476 "7-S"))); 477 478 static constexpr unsigned NumARMCPUArchs = 89; 479 480 TEST(TargetParserTest, testARMCPUArchList) { 481 SmallVector<StringRef, NumARMCPUArchs> List; 482 ARM::fillValidCPUArchList(List); 483 484 // No list exists for these in this test suite, so ensure all are 485 // valid, and match the expected 'magic' count. 486 EXPECT_EQ(List.size(), NumARMCPUArchs); 487 for(StringRef CPU : List) { 488 EXPECT_NE(ARM::parseCPUArch(CPU), ARM::ArchKind::INVALID); 489 } 490 } 491 492 TEST(TargetParserTest, testInvalidARMArch) { 493 auto InvalidArchStrings = {"armv", "armv99", "noarm"}; 494 for (const char* InvalidArch : InvalidArchStrings) 495 EXPECT_EQ(ARM::parseArch(InvalidArch), ARM::ArchKind::INVALID); 496 } 497 498 bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch, 499 unsigned ArchAttr) { 500 ARM::ArchKind AK = ARM::parseArch(Arch); 501 bool Result = (AK != ARM::ArchKind::INVALID); 502 Result &= ARM::getDefaultCPU(Arch).equals(DefaultCPU); 503 Result &= ARM::getSubArch(AK).equals(SubArch); 504 Result &= (ARM::getArchAttr(AK) == ArchAttr); 505 return Result; 506 } 507 508 TEST(TargetParserTest, testARMArch) { 509 EXPECT_TRUE( 510 testARMArch("armv4", "strongarm", "v4", 511 ARMBuildAttrs::CPUArch::v4)); 512 EXPECT_TRUE( 513 testARMArch("armv4t", "arm7tdmi", "v4t", 514 ARMBuildAttrs::CPUArch::v4T)); 515 EXPECT_TRUE( 516 testARMArch("armv5t", "arm10tdmi", "v5", 517 ARMBuildAttrs::CPUArch::v5T)); 518 EXPECT_TRUE( 519 testARMArch("armv5te", "arm1022e", "v5e", 520 ARMBuildAttrs::CPUArch::v5TE)); 521 EXPECT_TRUE( 522 testARMArch("armv5tej", "arm926ej-s", "v5e", 523 ARMBuildAttrs::CPUArch::v5TEJ)); 524 EXPECT_TRUE( 525 testARMArch("armv6", "arm1136jf-s", "v6", 526 ARMBuildAttrs::CPUArch::v6)); 527 EXPECT_TRUE( 528 testARMArch("armv6k", "mpcore", "v6k", 529 ARMBuildAttrs::CPUArch::v6K)); 530 EXPECT_TRUE( 531 testARMArch("armv6t2", "arm1156t2-s", "v6t2", 532 ARMBuildAttrs::CPUArch::v6T2)); 533 EXPECT_TRUE( 534 testARMArch("armv6kz", "arm1176jzf-s", "v6kz", 535 ARMBuildAttrs::CPUArch::v6KZ)); 536 EXPECT_TRUE( 537 testARMArch("armv6-m", "cortex-m0", "v6m", 538 ARMBuildAttrs::CPUArch::v6_M)); 539 EXPECT_TRUE( 540 testARMArch("armv7-a", "generic", "v7", 541 ARMBuildAttrs::CPUArch::v7)); 542 EXPECT_TRUE( 543 testARMArch("armv7ve", "generic", "v7ve", 544 ARMBuildAttrs::CPUArch::v7)); 545 EXPECT_TRUE( 546 testARMArch("armv7-r", "cortex-r4", "v7r", 547 ARMBuildAttrs::CPUArch::v7)); 548 EXPECT_TRUE( 549 testARMArch("armv7-m", "cortex-m3", "v7m", 550 ARMBuildAttrs::CPUArch::v7)); 551 EXPECT_TRUE( 552 testARMArch("armv7e-m", "cortex-m4", "v7em", 553 ARMBuildAttrs::CPUArch::v7E_M)); 554 EXPECT_TRUE( 555 testARMArch("armv8-a", "generic", "v8a", 556 ARMBuildAttrs::CPUArch::v8_A)); 557 EXPECT_TRUE( 558 testARMArch("armv8.1-a", "generic", "v8.1a", 559 ARMBuildAttrs::CPUArch::v8_A)); 560 EXPECT_TRUE( 561 testARMArch("armv8.2-a", "generic", "v8.2a", 562 ARMBuildAttrs::CPUArch::v8_A)); 563 EXPECT_TRUE( 564 testARMArch("armv8.3-a", "generic", "v8.3a", 565 ARMBuildAttrs::CPUArch::v8_A)); 566 EXPECT_TRUE( 567 testARMArch("armv8.4-a", "generic", "v8.4a", 568 ARMBuildAttrs::CPUArch::v8_A)); 569 EXPECT_TRUE( 570 testARMArch("armv8.5-a", "generic", "v8.5a", 571 ARMBuildAttrs::CPUArch::v8_A)); 572 EXPECT_TRUE( 573 testARMArch("armv8.6-a", "generic", "v8.6a", 574 ARMBuildAttrs::CPUArch::v8_A)); 575 EXPECT_TRUE( 576 testARMArch("armv8.7-a", "generic", "v8.7a", 577 ARMBuildAttrs::CPUArch::v8_A)); 578 EXPECT_TRUE(testARMArch("armv8.8-a", "generic", "v8.8a", 579 ARMBuildAttrs::CPUArch::v8_A)); 580 EXPECT_TRUE( 581 testARMArch("armv8.9-a", "generic", "v8.9a", 582 ARMBuildAttrs::CPUArch::v8_A)); 583 EXPECT_TRUE( 584 testARMArch("armv9-a", "generic", "v9a", 585 ARMBuildAttrs::CPUArch::v9_A)); 586 EXPECT_TRUE( 587 testARMArch("armv9.1-a", "generic", "v9.1a", 588 ARMBuildAttrs::CPUArch::v9_A)); 589 EXPECT_TRUE( 590 testARMArch("armv9.2-a", "generic", "v9.2a", 591 ARMBuildAttrs::CPUArch::v9_A)); 592 EXPECT_TRUE( 593 testARMArch("armv9.3-a", "generic", "v9.3a", 594 ARMBuildAttrs::CPUArch::v9_A)); 595 EXPECT_TRUE( 596 testARMArch("armv9.4-a", "generic", "v9.4a", 597 ARMBuildAttrs::CPUArch::v9_A)); 598 EXPECT_TRUE( 599 testARMArch("armv8-r", "cortex-r52", "v8r", 600 ARMBuildAttrs::CPUArch::v8_R)); 601 EXPECT_TRUE( 602 testARMArch("armv8-m.base", "generic", "v8m.base", 603 ARMBuildAttrs::CPUArch::v8_M_Base)); 604 EXPECT_TRUE( 605 testARMArch("armv8-m.main", "generic", "v8m.main", 606 ARMBuildAttrs::CPUArch::v8_M_Main)); 607 EXPECT_TRUE( 608 testARMArch("armv8.1-m.main", "generic", "v8.1m.main", 609 ARMBuildAttrs::CPUArch::v8_1_M_Main)); 610 EXPECT_TRUE( 611 testARMArch("iwmmxt", "iwmmxt", "", 612 ARMBuildAttrs::CPUArch::v5TE)); 613 EXPECT_TRUE( 614 testARMArch("iwmmxt2", "generic", "", 615 ARMBuildAttrs::CPUArch::v5TE)); 616 EXPECT_TRUE( 617 testARMArch("xscale", "xscale", "v5e", 618 ARMBuildAttrs::CPUArch::v5TE)); 619 EXPECT_TRUE( 620 testARMArch("armv7s", "swift", "v7s", 621 ARMBuildAttrs::CPUArch::v7)); 622 EXPECT_TRUE( 623 testARMArch("armv7k", "generic", "v7k", 624 ARMBuildAttrs::CPUArch::v7)); 625 } 626 627 bool testARMExtension(StringRef CPUName,ARM::ArchKind ArchKind, StringRef ArchExt) { 628 return ARM::getDefaultExtensions(CPUName, ArchKind) & 629 ARM::parseArchExt(ArchExt); 630 } 631 632 TEST(TargetParserTest, testARMExtension) { 633 EXPECT_FALSE(testARMExtension("strongarm", ARM::ArchKind::INVALID, "dsp")); 634 EXPECT_FALSE(testARMExtension("arm7tdmi", ARM::ArchKind::INVALID, "dsp")); 635 EXPECT_FALSE(testARMExtension("arm10tdmi", 636 ARM::ArchKind::INVALID, "simd")); 637 EXPECT_FALSE(testARMExtension("arm1022e", ARM::ArchKind::INVALID, "simd")); 638 EXPECT_FALSE(testARMExtension("arm926ej-s", 639 ARM::ArchKind::INVALID, "simd")); 640 EXPECT_FALSE(testARMExtension("arm1136jf-s", 641 ARM::ArchKind::INVALID, "crypto")); 642 EXPECT_FALSE(testARMExtension("arm1156t2-s", 643 ARM::ArchKind::INVALID, "crypto")); 644 EXPECT_FALSE(testARMExtension("arm1176jzf-s", 645 ARM::ArchKind::INVALID, "crypto")); 646 EXPECT_FALSE(testARMExtension("cortex-m0", 647 ARM::ArchKind::INVALID, "crypto")); 648 EXPECT_FALSE(testARMExtension("cortex-a8", 649 ARM::ArchKind::INVALID, "crypto")); 650 EXPECT_FALSE(testARMExtension("cortex-r4", 651 ARM::ArchKind::INVALID, "crypto")); 652 EXPECT_FALSE(testARMExtension("cortex-m3", 653 ARM::ArchKind::INVALID, "crypto")); 654 EXPECT_FALSE(testARMExtension("cortex-a53", 655 ARM::ArchKind::INVALID, "ras")); 656 EXPECT_FALSE(testARMExtension("cortex-a53", 657 ARM::ArchKind::INVALID, "fp16")); 658 EXPECT_TRUE(testARMExtension("cortex-a55", 659 ARM::ArchKind::INVALID, "fp16")); 660 EXPECT_FALSE(testARMExtension("cortex-a55", 661 ARM::ArchKind::INVALID, "fp16fml")); 662 EXPECT_TRUE(testARMExtension("cortex-a75", 663 ARM::ArchKind::INVALID, "fp16")); 664 EXPECT_FALSE(testARMExtension("cortex-a75", 665 ARM::ArchKind::INVALID, "fp16fml")); 666 EXPECT_FALSE(testARMExtension("cortex-r52", 667 ARM::ArchKind::INVALID, "ras")); 668 EXPECT_FALSE(testARMExtension("iwmmxt", ARM::ArchKind::INVALID, "crc")); 669 EXPECT_FALSE(testARMExtension("xscale", ARM::ArchKind::INVALID, "crc")); 670 EXPECT_FALSE(testARMExtension("swift", ARM::ArchKind::INVALID, "crc")); 671 672 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV4, "dsp")); 673 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV4T, "dsp")); 674 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5T, "simd")); 675 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5TE, "simd")); 676 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5TEJ, "simd")); 677 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6, "crypto")); 678 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6K, "crypto")); 679 EXPECT_FALSE(testARMExtension("generic", 680 ARM::ArchKind::ARMV6T2, "crypto")); 681 EXPECT_FALSE(testARMExtension("generic", 682 ARM::ArchKind::ARMV6KZ, "crypto")); 683 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6M, "crypto")); 684 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7A, "crypto")); 685 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7R, "crypto")); 686 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7M, "crypto")); 687 EXPECT_FALSE(testARMExtension("generic", 688 ARM::ArchKind::ARMV7EM, "crypto")); 689 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8A, "ras")); 690 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_1A, "ras")); 691 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "profile")); 692 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "fp16")); 693 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "fp16fml")); 694 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_3A, "fp16")); 695 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_3A, "fp16fml")); 696 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_4A, "fp16")); 697 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_4A, "fp16fml")); 698 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8R, "ras")); 699 EXPECT_FALSE(testARMExtension("generic", 700 ARM::ArchKind::ARMV8MBaseline, "crc")); 701 EXPECT_FALSE(testARMExtension("generic", 702 ARM::ArchKind::ARMV8MMainline, "crc")); 703 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::IWMMXT, "crc")); 704 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::IWMMXT2, "crc")); 705 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::XSCALE, "crc")); 706 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7S, "crypto")); 707 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7K, "crypto")); 708 } 709 710 TEST(TargetParserTest, ARMFPUVersion) { 711 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); 712 FK <= ARM::FPUKind::FK_LAST; 713 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) 714 if (FK == ARM::FK_LAST || ARM::getFPUName(FK) == "invalid" || 715 ARM::getFPUName(FK) == "none" || ARM::getFPUName(FK) == "softvfp") 716 EXPECT_EQ(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK)); 717 else 718 EXPECT_NE(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK)); 719 } 720 721 TEST(TargetParserTest, ARMFPUNeonSupportLevel) { 722 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); 723 FK <= ARM::FPUKind::FK_LAST; 724 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) 725 if (FK == ARM::FK_LAST || 726 ARM::getFPUName(FK).find("neon") == std::string::npos) 727 EXPECT_EQ(ARM::NeonSupportLevel::None, 728 ARM::getFPUNeonSupportLevel(FK)); 729 else 730 EXPECT_NE(ARM::NeonSupportLevel::None, 731 ARM::getFPUNeonSupportLevel(FK)); 732 } 733 734 TEST(TargetParserTest, ARMFPURestriction) { 735 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); 736 FK <= ARM::FPUKind::FK_LAST; 737 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) { 738 if (FK == ARM::FK_LAST || 739 (ARM::getFPUName(FK).find("d16") == std::string::npos && 740 ARM::getFPUName(FK).find("vfpv3xd") == std::string::npos)) 741 EXPECT_EQ(ARM::FPURestriction::None, ARM::getFPURestriction(FK)); 742 else 743 EXPECT_NE(ARM::FPURestriction::None, ARM::getFPURestriction(FK)); 744 } 745 } 746 747 TEST(TargetParserTest, ARMExtensionFeatures) { 748 std::map<uint64_t, std::vector<StringRef>> Extensions; 749 750 for (auto &Ext : ARM::ARCHExtNames) { 751 if (!Ext.Feature.empty() && !Ext.NegFeature.empty()) 752 Extensions[Ext.ID] = {Ext.Feature, Ext.NegFeature}; 753 } 754 755 Extensions[ARM::AEK_HWDIVARM] = { "+hwdiv-arm", "-hwdiv-arm" }; 756 Extensions[ARM::AEK_HWDIVTHUMB] = { "+hwdiv", "-hwdiv" }; 757 758 std::vector<StringRef> Features; 759 760 EXPECT_FALSE(ARM::getExtensionFeatures(ARM::AEK_INVALID, Features)); 761 762 for (auto &E : Extensions) { 763 // test +extension 764 Features.clear(); 765 ARM::getExtensionFeatures(E.first, Features); 766 EXPECT_TRUE(llvm::is_contained(Features, E.second.at(0))); 767 EXPECT_EQ(Extensions.size(), Features.size()); 768 769 // test -extension 770 Features.clear(); 771 ARM::getExtensionFeatures(~E.first, Features); 772 EXPECT_TRUE(llvm::is_contained(Features, E.second.at(1))); 773 EXPECT_EQ(Extensions.size(), Features.size()); 774 } 775 } 776 777 TEST(TargetParserTest, ARMFPUFeatures) { 778 std::vector<StringRef> Features; 779 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); 780 FK <= ARM::FPUKind::FK_LAST; 781 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) { 782 if (FK == ARM::FK_INVALID || FK >= ARM::FK_LAST) 783 EXPECT_FALSE(ARM::getFPUFeatures(FK, Features)); 784 else 785 EXPECT_TRUE(ARM::getFPUFeatures(FK, Features)); 786 } 787 } 788 789 TEST(TargetParserTest, ARMArchExtFeature) { 790 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"}, 791 {"crypto", "nocrypto", "+crypto", "-crypto"}, 792 {"dsp", "nodsp", "+dsp", "-dsp"}, 793 {"fp", "nofp", nullptr, nullptr}, 794 {"idiv", "noidiv", nullptr, nullptr}, 795 {"mp", "nomp", nullptr, nullptr}, 796 {"simd", "nosimd", nullptr, nullptr}, 797 {"sec", "nosec", nullptr, nullptr}, 798 {"virt", "novirt", nullptr, nullptr}, 799 {"fp16", "nofp16", "+fullfp16", "-fullfp16"}, 800 {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"}, 801 {"ras", "noras", "+ras", "-ras"}, 802 {"dotprod", "nodotprod", "+dotprod", "-dotprod"}, 803 {"os", "noos", nullptr, nullptr}, 804 {"iwmmxt", "noiwmmxt", nullptr, nullptr}, 805 {"iwmmxt2", "noiwmmxt2", nullptr, nullptr}, 806 {"maverick", "maverick", nullptr, nullptr}, 807 {"xscale", "noxscale", nullptr, nullptr}, 808 {"sb", "nosb", "+sb", "-sb"}, 809 {"i8mm", "noi8mm", "+i8mm", "-i8mm"}, 810 {"mve", "nomve", "+mve", "-mve"}, 811 {"mve.fp", "nomve.fp", "+mve.fp", "-mve.fp"}}; 812 813 for (unsigned i = 0; i < std::size(ArchExt); i++) { 814 EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0])); 815 EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1])); 816 } 817 } 818 819 static bool 820 testArchExtDependency(const char *ArchExt, 821 const std::initializer_list<const char *> &Expected) { 822 std::vector<StringRef> Features; 823 ARM::FPUKind FPUKind; 824 825 if (!ARM::appendArchExtFeatures("", ARM::ArchKind::ARMV8_1MMainline, ArchExt, 826 Features, FPUKind)) 827 return false; 828 829 return llvm::all_of(Expected, [&](StringRef Ext) { 830 return llvm::is_contained(Features, Ext); 831 }); 832 } 833 834 TEST(TargetParserTest, ARMArchExtDependencies) { 835 EXPECT_TRUE(testArchExtDependency("mve", {"+mve", "+dsp"})); 836 EXPECT_TRUE(testArchExtDependency("mve.fp", {"+mve.fp", "+mve", "+dsp"})); 837 EXPECT_TRUE(testArchExtDependency("nodsp", {"-dsp", "-mve", "-mve.fp"})); 838 EXPECT_TRUE(testArchExtDependency("nomve", {"-mve", "-mve.fp"})); 839 } 840 841 TEST(TargetParserTest, ARMparseHWDiv) { 842 const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"}; 843 844 for (unsigned i = 0; i < std::size(hwdiv); i++) 845 EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i])); 846 } 847 848 TEST(TargetParserTest, ARMparseArchEndianAndISA) { 849 const char *Arch[] = { 850 "v2", "v2a", "v3", "v3m", "v4", "v4t", 851 "v5", "v5t", "v5e", "v5te", "v5tej", "v6", 852 "v6j", "v6k", "v6hl", "v6t2", "v6kz", "v6z", 853 "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a", 854 "v7", "v7a", "v7ve", "v7hl", "v7l", "v7-r", 855 "v7r", "v7-m", "v7m", "v7k", "v7s", "v7e-m", 856 "v7em", "v8-a", "v8", "v8a", "v8l", "v8.1-a", 857 "v8.1a", "v8.2-a", "v8.2a", "v8.3-a", "v8.3a", "v8.4-a", 858 "v8.4a", "v8.5-a", "v8.5a", "v8.6-a", "v8.6a", "v8.7-a", 859 "v8.7a", "v8.8-a", "v8.8a", "v8-r", "v8m.base", "v8m.main", 860 "v8.1m.main"}; 861 862 for (unsigned i = 0; i < std::size(Arch); i++) { 863 std::string arm_1 = "armeb" + (std::string)(Arch[i]); 864 std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb"; 865 std::string arm_3 = "arm" + (std::string)(Arch[i]); 866 std::string thumb_1 = "thumbeb" + (std::string)(Arch[i]); 867 std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb"; 868 std::string thumb_3 = "thumb" + (std::string)(Arch[i]); 869 870 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_1)); 871 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_2)); 872 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(arm_3)); 873 874 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_1)); 875 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_2)); 876 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_3)); 877 if (i >= 4) { 878 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_1)); 879 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_2)); 880 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(thumb_3)); 881 882 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_1)); 883 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_2)); 884 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_3)); 885 } 886 } 887 888 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("aarch64")); 889 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("arm64_32")); 890 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian("aarch64_be")); 891 892 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64")); 893 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_be")); 894 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64")); 895 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_be")); 896 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_32")); 897 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_32")); 898 } 899 900 TEST(TargetParserTest, ARMparseArchProfile) { 901 for (unsigned i = 0; i < std::size(ARMArch); i++) { 902 switch (ARM::parseArch(ARMArch[i])) { 903 case ARM::ArchKind::ARMV6M: 904 case ARM::ArchKind::ARMV7M: 905 case ARM::ArchKind::ARMV7EM: 906 case ARM::ArchKind::ARMV8MMainline: 907 case ARM::ArchKind::ARMV8MBaseline: 908 case ARM::ArchKind::ARMV8_1MMainline: 909 EXPECT_EQ(ARM::ProfileKind::M, ARM::parseArchProfile(ARMArch[i])); 910 break; 911 case ARM::ArchKind::ARMV7R: 912 case ARM::ArchKind::ARMV8R: 913 EXPECT_EQ(ARM::ProfileKind::R, ARM::parseArchProfile(ARMArch[i])); 914 break; 915 case ARM::ArchKind::ARMV7A: 916 case ARM::ArchKind::ARMV7VE: 917 case ARM::ArchKind::ARMV7K: 918 case ARM::ArchKind::ARMV8A: 919 case ARM::ArchKind::ARMV8_1A: 920 case ARM::ArchKind::ARMV8_2A: 921 case ARM::ArchKind::ARMV8_3A: 922 case ARM::ArchKind::ARMV8_4A: 923 case ARM::ArchKind::ARMV8_5A: 924 case ARM::ArchKind::ARMV8_6A: 925 case ARM::ArchKind::ARMV8_7A: 926 case ARM::ArchKind::ARMV8_8A: 927 case ARM::ArchKind::ARMV8_9A: 928 case ARM::ArchKind::ARMV9A: 929 case ARM::ArchKind::ARMV9_1A: 930 case ARM::ArchKind::ARMV9_2A: 931 case ARM::ArchKind::ARMV9_3A: 932 case ARM::ArchKind::ARMV9_4A: 933 EXPECT_EQ(ARM::ProfileKind::A, ARM::parseArchProfile(ARMArch[i])); 934 break; 935 default: 936 EXPECT_EQ(ARM::ProfileKind::INVALID, ARM::parseArchProfile(ARMArch[i])); 937 break; 938 } 939 } 940 } 941 942 TEST(TargetParserTest, ARMparseArchVersion) { 943 for (unsigned i = 0; i < std::size(ARMArch); i++) 944 if (((std::string)ARMArch[i]).substr(0, 4) == "armv") 945 EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i])); 946 else 947 EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i])); 948 } 949 950 TEST(TargetParserTest, getARMCPUForArch) { 951 // Platform specific defaults. 952 { 953 llvm::Triple Triple("arm--nacl"); 954 EXPECT_EQ("cortex-a8", ARM::getARMCPUForArch(Triple)); 955 } 956 { 957 llvm::Triple Triple("arm--openbsd"); 958 EXPECT_EQ("cortex-a8", ARM::getARMCPUForArch(Triple)); 959 } 960 { 961 llvm::Triple Triple("armv6-unknown-freebsd"); 962 EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple)); 963 } 964 { 965 llvm::Triple Triple("thumbv6-unknown-freebsd"); 966 EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple)); 967 } 968 { 969 llvm::Triple Triple("armebv6-unknown-freebsd"); 970 EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple)); 971 } 972 { 973 llvm::Triple Triple("arm--win32"); 974 EXPECT_EQ("cortex-a9", ARM::getARMCPUForArch(Triple)); 975 EXPECT_EQ("generic", ARM::getARMCPUForArch(Triple, "armv8-a")); 976 } 977 // Some alternative architectures 978 { 979 llvm::Triple Triple("armv7k-apple-ios9"); 980 EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple)); 981 } 982 { 983 llvm::Triple Triple("armv7k-apple-watchos3"); 984 EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple)); 985 } 986 { 987 llvm::Triple Triple("armv7k-apple-tvos9"); 988 EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple)); 989 } 990 // armeb is permitted, but armebeb is not 991 { 992 llvm::Triple Triple("armeb-none-eabi"); 993 EXPECT_EQ("arm7tdmi", ARM::getARMCPUForArch(Triple)); 994 } 995 { 996 llvm::Triple Triple("armebeb-none-eabi"); 997 EXPECT_EQ("", ARM::getARMCPUForArch(Triple)); 998 } 999 { 1000 llvm::Triple Triple("armebv6eb-none-eabi"); 1001 EXPECT_EQ("", ARM::getARMCPUForArch(Triple)); 1002 } 1003 // xscaleeb is permitted, but armebxscale is not 1004 { 1005 llvm::Triple Triple("xscaleeb-none-eabi"); 1006 EXPECT_EQ("xscale", ARM::getARMCPUForArch(Triple)); 1007 } 1008 { 1009 llvm::Triple Triple("armebxscale-none-eabi"); 1010 EXPECT_EQ("", ARM::getARMCPUForArch(Triple)); 1011 } 1012 } 1013 1014 TEST(TargetParserTest, ARMPrintSupportedExtensions) { 1015 std::string expected = "All available -march extensions for ARM\n\n" 1016 " Name Description\n" 1017 " crc This is a long dummy description\n" 1018 " crypto\n" 1019 " sha2\n"; 1020 1021 StringMap<StringRef> DummyMap; 1022 DummyMap["crc"] = "This is a long dummy description"; 1023 1024 outs().flush(); 1025 testing::internal::CaptureStdout(); 1026 ARM::PrintSupportedExtensions(DummyMap); 1027 outs().flush(); 1028 std::string captured = testing::internal::GetCapturedStdout(); 1029 1030 // Check that the start of the output is as expected. 1031 EXPECT_EQ(0ULL, captured.find(expected)); 1032 1033 // Should not include "none" or "invalid". 1034 EXPECT_EQ(std::string::npos, captured.find("none")); 1035 EXPECT_EQ(std::string::npos, captured.find("invalid")); 1036 // Should not include anything that lacks a feature name. Checking a few here 1037 // but not all as if one is hidden correctly the rest should be. 1038 EXPECT_EQ(std::string::npos, captured.find("simd")); 1039 EXPECT_EQ(std::string::npos, captured.find("maverick")); 1040 EXPECT_EQ(std::string::npos, captured.find("xscale")); 1041 } 1042 1043 class AArch64CPUTestFixture 1044 : public ::testing::TestWithParam< 1045 ARMCPUTestParams<AArch64::ExtensionBitset>> {}; 1046 1047 TEST_P(AArch64CPUTestFixture, testAArch64CPU) { 1048 auto params = GetParam(); 1049 1050 const std::optional<AArch64::CpuInfo> Cpu = AArch64::parseCpu(params.CPUName); 1051 EXPECT_TRUE(Cpu); 1052 EXPECT_EQ(params.ExpectedArch, Cpu->Arch.Name); 1053 1054 EXPECT_PRED_FORMAT2( 1055 AssertSameExtensionFlags<ARM::ISAKind::AARCH64>(params.CPUName), 1056 params.ExpectedFlags, Cpu->getImpliedExtensions()); 1057 } 1058 1059 INSTANTIATE_TEST_SUITE_P( 1060 AArch64CPUTests, AArch64CPUTestFixture, 1061 ::testing::Values( 1062 ARMCPUTestParams<AArch64::ExtensionBitset>( 1063 "cortex-a34", "armv8-a", "crypto-neon-fp-armv8", 1064 (AArch64::ExtensionBitset( 1065 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1066 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1067 "8-A"), 1068 ARMCPUTestParams<AArch64::ExtensionBitset>( 1069 "cortex-a35", "armv8-a", "crypto-neon-fp-armv8", 1070 (AArch64::ExtensionBitset( 1071 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1072 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1073 "8-A"), 1074 ARMCPUTestParams<AArch64::ExtensionBitset>( 1075 "cortex-a53", "armv8-a", "crypto-neon-fp-armv8", 1076 (AArch64::ExtensionBitset( 1077 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1078 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1079 "8-A"), 1080 ARMCPUTestParams<AArch64::ExtensionBitset>( 1081 "cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8", 1082 (AArch64::ExtensionBitset( 1083 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1084 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_RAS, 1085 AArch64::AEK_LSE, AArch64::AEK_RDM, AArch64::AEK_FP16, 1086 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC})), 1087 "8.2-A"), 1088 ARMCPUTestParams<AArch64::ExtensionBitset>( 1089 "cortex-a510", "armv9-a", "neon-fp-armv8", 1090 (AArch64::ExtensionBitset( 1091 {AArch64::AEK_CRC, AArch64::AEK_FP, AArch64::AEK_SIMD, 1092 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_RDM, 1093 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_BF16, 1094 AArch64::AEK_I8MM, AArch64::AEK_SVE, AArch64::AEK_SVE2, 1095 AArch64::AEK_SVE2BITPERM, AArch64::AEK_PAUTH, AArch64::AEK_MTE, 1096 AArch64::AEK_SSBS, AArch64::AEK_FP16, AArch64::AEK_FP16FML, 1097 AArch64::AEK_SB})), 1098 "9-A"), 1099 ARMCPUTestParams<AArch64::ExtensionBitset>( 1100 "cortex-a57", "armv8-a", "crypto-neon-fp-armv8", 1101 (AArch64::ExtensionBitset( 1102 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1103 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1104 "8-A"), 1105 ARMCPUTestParams<AArch64::ExtensionBitset>( 1106 "cortex-a65", "armv8.2-a", "crypto-neon-fp-armv8", 1107 (AArch64::ExtensionBitset( 1108 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1109 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_FP16, 1110 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RCPC, 1111 AArch64::AEK_RDM, AArch64::AEK_SIMD, AArch64::AEK_SSBS})), 1112 "8.2-A"), 1113 ARMCPUTestParams<AArch64::ExtensionBitset>( 1114 "cortex-a65ae", "armv8.2-a", "crypto-neon-fp-armv8", 1115 (AArch64::ExtensionBitset( 1116 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1117 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_FP16, 1118 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RCPC, 1119 AArch64::AEK_RDM, AArch64::AEK_SIMD, AArch64::AEK_SSBS})), 1120 "8.2-A"), 1121 ARMCPUTestParams<AArch64::ExtensionBitset>( 1122 "cortex-a72", "armv8-a", "crypto-neon-fp-armv8", 1123 (AArch64::ExtensionBitset( 1124 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1125 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1126 "8-A"), 1127 ARMCPUTestParams<AArch64::ExtensionBitset>( 1128 "cortex-a73", "armv8-a", "crypto-neon-fp-armv8", 1129 (AArch64::ExtensionBitset( 1130 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1131 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1132 "8-A"), 1133 ARMCPUTestParams<AArch64::ExtensionBitset>( 1134 "cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8", 1135 (AArch64::ExtensionBitset( 1136 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1137 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_RAS, 1138 AArch64::AEK_LSE, AArch64::AEK_RDM, AArch64::AEK_FP16, 1139 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC})), 1140 "8.2-A"), 1141 ARMCPUTestParams<AArch64::ExtensionBitset>( 1142 "cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8", 1143 (AArch64::ExtensionBitset( 1144 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1145 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1146 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_FP16, 1147 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, AArch64::AEK_SSBS})), 1148 "8.2-A"), 1149 ARMCPUTestParams<AArch64::ExtensionBitset>( 1150 "cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8", 1151 (AArch64::ExtensionBitset( 1152 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1153 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1154 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_FP16, 1155 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, AArch64::AEK_SSBS})), 1156 "8.2-A"), 1157 ARMCPUTestParams<AArch64::ExtensionBitset>( 1158 "cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8", 1159 (AArch64::ExtensionBitset( 1160 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1161 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1162 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_FP16, 1163 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, AArch64::AEK_SSBS})), 1164 "8.2-A"), 1165 ARMCPUTestParams<AArch64::ExtensionBitset>( 1166 "cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8", 1167 (AArch64::ExtensionBitset( 1168 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1169 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1170 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_FP16, 1171 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, AArch64::AEK_SSBS, 1172 AArch64::AEK_PROFILE})), 1173 "8.2-A"), 1174 ARMCPUTestParams<AArch64::ExtensionBitset>( 1175 "cortex-a78c", "armv8.2-a", "crypto-neon-fp-armv8", 1176 (AArch64::ExtensionBitset( 1177 {AArch64::AEK_RAS, AArch64::AEK_CRC, AArch64::AEK_AES, 1178 AArch64::AEK_SHA2, AArch64::AEK_FP, AArch64::AEK_SIMD, 1179 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_RDM, 1180 AArch64::AEK_FP16, AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, 1181 AArch64::AEK_SSBS, AArch64::AEK_PROFILE, AArch64::AEK_FLAGM, 1182 AArch64::AEK_PAUTH, AArch64::AEK_FP16FML})), 1183 "8.2-A"), 1184 ARMCPUTestParams<AArch64::ExtensionBitset>( 1185 "cortex-a710", "armv9-a", "neon-fp-armv8", 1186 (AArch64::ExtensionBitset( 1187 {AArch64::AEK_CRC, AArch64::AEK_FP, AArch64::AEK_SIMD, 1188 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_RDM, 1189 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_MTE, 1190 AArch64::AEK_FP16, AArch64::AEK_FP16FML, AArch64::AEK_SVE, 1191 AArch64::AEK_SVE2, AArch64::AEK_SVE2BITPERM, 1192 AArch64::AEK_PAUTH, AArch64::AEK_FLAGM, AArch64::AEK_SB, 1193 AArch64::AEK_I8MM, AArch64::AEK_BF16})), 1194 "9-A"), 1195 ARMCPUTestParams<AArch64::ExtensionBitset>( 1196 "cortex-a715", "armv9-a", "neon-fp-armv8", 1197 (AArch64::ExtensionBitset( 1198 {AArch64::AEK_CRC, AArch64::AEK_FP, 1199 AArch64::AEK_BF16, AArch64::AEK_SIMD, 1200 AArch64::AEK_RAS, AArch64::AEK_LSE, 1201 AArch64::AEK_RDM, AArch64::AEK_RCPC, 1202 AArch64::AEK_DOTPROD, AArch64::AEK_MTE, 1203 AArch64::AEK_PAUTH, AArch64::AEK_SVE, 1204 AArch64::AEK_SVE2, AArch64::AEK_SVE2BITPERM, 1205 AArch64::AEK_SSBS, AArch64::AEK_SB, 1206 AArch64::AEK_I8MM, AArch64::AEK_PERFMON, 1207 AArch64::AEK_PREDRES, AArch64::AEK_PROFILE, 1208 AArch64::AEK_FP16FML, AArch64::AEK_FP16, 1209 AArch64::AEK_FLAGM})), 1210 "9-A"), 1211 ARMCPUTestParams<AArch64::ExtensionBitset>( 1212 "neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8", 1213 (AArch64::ExtensionBitset( 1214 {AArch64::AEK_RAS, AArch64::AEK_SVE, AArch64::AEK_SSBS, 1215 AArch64::AEK_RCPC, AArch64::AEK_CRC, AArch64::AEK_FP, 1216 AArch64::AEK_SIMD, AArch64::AEK_RAS, AArch64::AEK_LSE, 1217 AArch64::AEK_RDM, AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, 1218 AArch64::AEK_AES, AArch64::AEK_SHA2, AArch64::AEK_SHA3, 1219 AArch64::AEK_SM4, AArch64::AEK_FP16, AArch64::AEK_BF16, 1220 AArch64::AEK_PROFILE, AArch64::AEK_RAND, AArch64::AEK_FP16FML, 1221 AArch64::AEK_I8MM})), 1222 "8.4-A"), 1223 ARMCPUTestParams<AArch64::ExtensionBitset>( 1224 "neoverse-v2", "armv9-a", "neon-fp-armv8", 1225 (AArch64::ExtensionBitset( 1226 {AArch64::AEK_RAS, AArch64::AEK_SVE, 1227 AArch64::AEK_SSBS, AArch64::AEK_RCPC, 1228 AArch64::AEK_CRC, AArch64::AEK_FP, 1229 AArch64::AEK_SIMD, AArch64::AEK_MTE, 1230 AArch64::AEK_LSE, AArch64::AEK_RDM, 1231 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, 1232 AArch64::AEK_FP16, AArch64::AEK_BF16, 1233 AArch64::AEK_SVE2, AArch64::AEK_PROFILE, 1234 AArch64::AEK_FP16FML, AArch64::AEK_I8MM, 1235 AArch64::AEK_SVE2BITPERM, AArch64::AEK_RAND})), 1236 "9-A"), 1237 ARMCPUTestParams<AArch64::ExtensionBitset>( 1238 "cortex-r82", "armv8-r", "crypto-neon-fp-armv8", 1239 (AArch64::ExtensionBitset( 1240 {AArch64::AEK_CRC, AArch64::AEK_RDM, AArch64::AEK_SSBS, 1241 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_SIMD, 1242 AArch64::AEK_FP16, AArch64::AEK_FP16FML, AArch64::AEK_RAS, 1243 AArch64::AEK_RCPC, AArch64::AEK_LSE, AArch64::AEK_SB})), 1244 "8-R"), 1245 ARMCPUTestParams<AArch64::ExtensionBitset>( 1246 "cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8", 1247 (AArch64::ExtensionBitset( 1248 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1249 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1250 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_FP16, 1251 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, AArch64::AEK_SSBS, 1252 AArch64::AEK_PROFILE})), 1253 "8.2-A"), 1254 ARMCPUTestParams<AArch64::ExtensionBitset>( 1255 "cortex-x1c", "armv8.2-a", "crypto-neon-fp-armv8", 1256 (AArch64::ExtensionBitset( 1257 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1258 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1259 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_FP16, 1260 AArch64::AEK_DOTPROD, AArch64::AEK_RCPC, AArch64::AEK_SSBS, 1261 AArch64::AEK_PAUTH, AArch64::AEK_PROFILE})), 1262 "8.2-A"), 1263 ARMCPUTestParams<AArch64::ExtensionBitset>( 1264 "cortex-x2", "armv9-a", "neon-fp-armv8", 1265 (AArch64::ExtensionBitset( 1266 {AArch64::AEK_CRC, AArch64::AEK_FP, AArch64::AEK_SIMD, 1267 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_RDM, 1268 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_MTE, 1269 AArch64::AEK_PAUTH, AArch64::AEK_I8MM, AArch64::AEK_BF16, 1270 AArch64::AEK_SVE, AArch64::AEK_SVE2, AArch64::AEK_SVE2BITPERM, 1271 AArch64::AEK_SSBS, AArch64::AEK_SB, AArch64::AEK_FP16, 1272 AArch64::AEK_FP16FML})), 1273 "9-A"), 1274 ARMCPUTestParams<AArch64::ExtensionBitset>( 1275 "cortex-x3", "armv9-a", "neon-fp-armv8", 1276 (AArch64::ExtensionBitset( 1277 {AArch64::AEK_CRC, AArch64::AEK_FP, 1278 AArch64::AEK_BF16, AArch64::AEK_SIMD, 1279 AArch64::AEK_RAS, AArch64::AEK_LSE, 1280 AArch64::AEK_RDM, AArch64::AEK_RCPC, 1281 AArch64::AEK_DOTPROD, AArch64::AEK_MTE, 1282 AArch64::AEK_PAUTH, AArch64::AEK_SVE, 1283 AArch64::AEK_SVE2, AArch64::AEK_SVE2BITPERM, 1284 AArch64::AEK_SB, AArch64::AEK_PROFILE, 1285 AArch64::AEK_PERFMON, AArch64::AEK_I8MM, 1286 AArch64::AEK_FP16, AArch64::AEK_FP16FML, 1287 AArch64::AEK_PREDRES, AArch64::AEK_FLAGM, 1288 AArch64::AEK_SSBS})), 1289 "9-A"), 1290 ARMCPUTestParams<AArch64::ExtensionBitset>( 1291 "cyclone", "armv8-a", "crypto-neon-fp-armv8", 1292 (AArch64::ExtensionBitset( 1293 {AArch64::AEK_NONE, AArch64::AEK_AES, AArch64::AEK_SHA2, 1294 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1295 "8-A"), 1296 ARMCPUTestParams<AArch64::ExtensionBitset>( 1297 "apple-a7", "armv8-a", "crypto-neon-fp-armv8", 1298 (AArch64::ExtensionBitset( 1299 {AArch64::AEK_NONE, AArch64::AEK_AES, AArch64::AEK_SHA2, 1300 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1301 "8-A"), 1302 ARMCPUTestParams<AArch64::ExtensionBitset>( 1303 "apple-a8", "armv8-a", "crypto-neon-fp-armv8", 1304 (AArch64::ExtensionBitset( 1305 {AArch64::AEK_NONE, AArch64::AEK_AES, AArch64::AEK_SHA2, 1306 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1307 "8-A"), 1308 ARMCPUTestParams<AArch64::ExtensionBitset>( 1309 "apple-a9", "armv8-a", "crypto-neon-fp-armv8", 1310 (AArch64::ExtensionBitset( 1311 {AArch64::AEK_NONE, AArch64::AEK_AES, AArch64::AEK_SHA2, 1312 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1313 "8-A"), 1314 ARMCPUTestParams<AArch64::ExtensionBitset>( 1315 "apple-a10", "armv8-a", "crypto-neon-fp-armv8", 1316 (AArch64::ExtensionBitset( 1317 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1318 AArch64::AEK_FP, AArch64::AEK_RDM, AArch64::AEK_SIMD})), 1319 "8-A"), 1320 ARMCPUTestParams<AArch64::ExtensionBitset>( 1321 "apple-a11", "armv8.2-a", "crypto-neon-fp-armv8", 1322 (AArch64::ExtensionBitset( 1323 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1324 AArch64::AEK_FP, AArch64::AEK_LSE, AArch64::AEK_RAS, 1325 AArch64::AEK_RDM, AArch64::AEK_SIMD, AArch64::AEK_FP16})), 1326 "8.2-A"), 1327 ARMCPUTestParams<AArch64::ExtensionBitset>( 1328 "apple-a12", "armv8.3-a", "crypto-neon-fp-armv8", 1329 (AArch64::ExtensionBitset( 1330 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1331 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_LSE, 1332 AArch64::AEK_RAS, AArch64::AEK_RDM, AArch64::AEK_RCPC, 1333 AArch64::AEK_FP16})), 1334 "8.3-A"), 1335 ARMCPUTestParams<AArch64::ExtensionBitset>( 1336 "apple-a13", "armv8.4-a", "crypto-neon-fp-armv8", 1337 (AArch64::ExtensionBitset( 1338 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1339 AArch64::AEK_SHA3, AArch64::AEK_FP, AArch64::AEK_SIMD, 1340 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1341 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16, 1342 AArch64::AEK_FP16FML, AArch64::AEK_SHA3})), 1343 "8.4-A"), 1344 ARMCPUTestParams<AArch64::ExtensionBitset>( 1345 "apple-a14", "armv8.5-a", "crypto-neon-fp-armv8", 1346 (AArch64::ExtensionBitset( 1347 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1348 AArch64::AEK_SHA3, AArch64::AEK_FP, AArch64::AEK_SIMD, 1349 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1350 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16, 1351 AArch64::AEK_FP16FML, AArch64::AEK_SHA3})), 1352 "8.5-A"), 1353 ARMCPUTestParams<AArch64::ExtensionBitset>( 1354 "apple-a15", "armv8.5-a", "crypto-neon-fp-armv8", 1355 (AArch64::ExtensionBitset( 1356 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1357 AArch64::AEK_SHA3, AArch64::AEK_FP, AArch64::AEK_SIMD, 1358 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1359 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16, 1360 AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16, 1361 AArch64::AEK_I8MM})), 1362 "8.5-A"), 1363 ARMCPUTestParams<AArch64::ExtensionBitset>( 1364 "apple-a16", "armv8.5-a", "crypto-neon-fp-armv8", 1365 (AArch64::ExtensionBitset( 1366 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1367 AArch64::AEK_SHA3, AArch64::AEK_FP, AArch64::AEK_SIMD, 1368 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1369 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16, 1370 AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16, 1371 AArch64::AEK_I8MM})), 1372 "8.5-A"), 1373 ARMCPUTestParams<AArch64::ExtensionBitset>( 1374 "apple-m1", "armv8.5-a", "crypto-neon-fp-armv8", 1375 (AArch64::ExtensionBitset( 1376 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1377 AArch64::AEK_SHA3, AArch64::AEK_FP, AArch64::AEK_SIMD, 1378 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1379 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16, 1380 AArch64::AEK_FP16FML, AArch64::AEK_SHA3})), 1381 "8.5-A"), 1382 ARMCPUTestParams<AArch64::ExtensionBitset>( 1383 "apple-m2", "armv8.5-a", "crypto-neon-fp-armv8", 1384 (AArch64::ExtensionBitset( 1385 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1386 AArch64::AEK_SHA3, AArch64::AEK_FP, AArch64::AEK_SIMD, 1387 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1388 AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, AArch64::AEK_FP16, 1389 AArch64::AEK_FP16FML, AArch64::AEK_SHA3, AArch64::AEK_BF16, 1390 AArch64::AEK_I8MM})), 1391 "8.5-A"), 1392 ARMCPUTestParams<AArch64::ExtensionBitset>( 1393 "apple-s4", "armv8.3-a", "crypto-neon-fp-armv8", 1394 (AArch64::ExtensionBitset( 1395 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1396 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_LSE, 1397 AArch64::AEK_RAS, AArch64::AEK_RDM, AArch64::AEK_RCPC, 1398 AArch64::AEK_FP16})), 1399 "8.3-A"), 1400 ARMCPUTestParams<AArch64::ExtensionBitset>( 1401 "apple-s5", "armv8.3-a", "crypto-neon-fp-armv8", 1402 (AArch64::ExtensionBitset( 1403 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1404 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_LSE, 1405 AArch64::AEK_RAS, AArch64::AEK_RDM, AArch64::AEK_RCPC, 1406 AArch64::AEK_FP16})), 1407 "8.3-A"), 1408 ARMCPUTestParams<AArch64::ExtensionBitset>( 1409 "exynos-m3", "armv8-a", "crypto-neon-fp-armv8", 1410 (AArch64::ExtensionBitset( 1411 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1412 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1413 "8-A"), 1414 ARMCPUTestParams<AArch64::ExtensionBitset>( 1415 "exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8", 1416 (AArch64::ExtensionBitset( 1417 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1418 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_FP16, 1419 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1420 AArch64::AEK_SIMD})), 1421 "8.2-A"), 1422 ARMCPUTestParams<AArch64::ExtensionBitset>( 1423 "exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8", 1424 (AArch64::ExtensionBitset( 1425 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1426 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_FP16, 1427 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RDM, 1428 AArch64::AEK_SIMD})), 1429 "8.2-A"), 1430 ARMCPUTestParams<AArch64::ExtensionBitset>( 1431 "falkor", "armv8-a", "crypto-neon-fp-armv8", 1432 (AArch64::ExtensionBitset( 1433 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1434 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_RDM})), 1435 "8-A"), 1436 ARMCPUTestParams<AArch64::ExtensionBitset>( 1437 "kryo", "armv8-a", "crypto-neon-fp-armv8", 1438 (AArch64::ExtensionBitset( 1439 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1440 AArch64::AEK_FP, AArch64::AEK_SIMD})), 1441 "8-A"), 1442 ARMCPUTestParams<AArch64::ExtensionBitset>( 1443 "neoverse-e1", "armv8.2-a", "crypto-neon-fp-armv8", 1444 (AArch64::ExtensionBitset( 1445 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1446 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_FP16, 1447 AArch64::AEK_LSE, AArch64::AEK_RAS, AArch64::AEK_RCPC, 1448 AArch64::AEK_RDM, AArch64::AEK_SIMD, AArch64::AEK_SSBS})), 1449 "8.2-A"), 1450 ARMCPUTestParams<AArch64::ExtensionBitset>( 1451 "neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8", 1452 (AArch64::ExtensionBitset( 1453 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1454 AArch64::AEK_DOTPROD, AArch64::AEK_FP, AArch64::AEK_FP16, 1455 AArch64::AEK_LSE, AArch64::AEK_PROFILE, AArch64::AEK_RAS, 1456 AArch64::AEK_RCPC, AArch64::AEK_RDM, AArch64::AEK_SIMD, 1457 AArch64::AEK_SSBS})), 1458 "8.2-A"), 1459 ARMCPUTestParams<AArch64::ExtensionBitset>( 1460 "neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8", 1461 (AArch64::ExtensionBitset( 1462 {AArch64::AEK_CRC, AArch64::AEK_AES, 1463 AArch64::AEK_SHA2, AArch64::AEK_SHA3, 1464 AArch64::AEK_SM4, AArch64::AEK_FP, 1465 AArch64::AEK_SIMD, AArch64::AEK_FP16, 1466 AArch64::AEK_RAS, AArch64::AEK_LSE, 1467 AArch64::AEK_SVE, AArch64::AEK_DOTPROD, 1468 AArch64::AEK_RCPC, AArch64::AEK_RDM, 1469 AArch64::AEK_MTE, AArch64::AEK_SSBS, 1470 AArch64::AEK_SB, AArch64::AEK_SVE2, 1471 AArch64::AEK_SVE2BITPERM, AArch64::AEK_BF16, 1472 AArch64::AEK_I8MM})), 1473 "8.5-A"), 1474 ARMCPUTestParams<AArch64::ExtensionBitset>( 1475 "ampere1", "armv8.6-a", "crypto-neon-fp-armv8", 1476 (AArch64::ExtensionBitset( 1477 {AArch64::AEK_CRC, AArch64::AEK_FP, AArch64::AEK_FP16, 1478 AArch64::AEK_SIMD, AArch64::AEK_RAS, AArch64::AEK_LSE, 1479 AArch64::AEK_RDM, AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, 1480 AArch64::AEK_SHA3, AArch64::AEK_BF16, AArch64::AEK_SHA2, 1481 AArch64::AEK_AES, AArch64::AEK_I8MM, AArch64::AEK_SSBS, 1482 AArch64::AEK_SB, AArch64::AEK_RAND})), 1483 "8.6-A"), 1484 ARMCPUTestParams<AArch64::ExtensionBitset>( 1485 "ampere1a", "armv8.6-a", "crypto-neon-fp-armv8", 1486 (AArch64::ExtensionBitset( 1487 {AArch64::AEK_CRC, AArch64::AEK_FP, AArch64::AEK_FP16, 1488 AArch64::AEK_SIMD, AArch64::AEK_RAS, AArch64::AEK_LSE, 1489 AArch64::AEK_RDM, AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, 1490 AArch64::AEK_SM4, AArch64::AEK_SHA3, AArch64::AEK_BF16, 1491 AArch64::AEK_SHA2, AArch64::AEK_AES, AArch64::AEK_I8MM, 1492 AArch64::AEK_SSBS, AArch64::AEK_SB, AArch64::AEK_RAND, 1493 AArch64::AEK_MTE})), 1494 "8.6-A"), 1495 ARMCPUTestParams<AArch64::ExtensionBitset>( 1496 "neoverse-512tvb", "armv8.4-a", "crypto-neon-fp-armv8", 1497 (AArch64::ExtensionBitset( 1498 {AArch64::AEK_RAS, AArch64::AEK_SVE, AArch64::AEK_SSBS, 1499 AArch64::AEK_RCPC, AArch64::AEK_CRC, AArch64::AEK_FP, 1500 AArch64::AEK_SIMD, AArch64::AEK_RAS, AArch64::AEK_LSE, 1501 AArch64::AEK_RDM, AArch64::AEK_RCPC, AArch64::AEK_DOTPROD, 1502 AArch64::AEK_AES, AArch64::AEK_SHA2, AArch64::AEK_SHA3, 1503 AArch64::AEK_SM4, AArch64::AEK_FP16, AArch64::AEK_BF16, 1504 AArch64::AEK_PROFILE, AArch64::AEK_RAND, AArch64::AEK_FP16FML, 1505 AArch64::AEK_I8MM})), 1506 "8.4-A"), 1507 ARMCPUTestParams<AArch64::ExtensionBitset>( 1508 "thunderx2t99", "armv8.1-a", "crypto-neon-fp-armv8", 1509 (AArch64::ExtensionBitset( 1510 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1511 AArch64::AEK_LSE, AArch64::AEK_RDM, AArch64::AEK_FP, 1512 AArch64::AEK_SIMD})), 1513 "8.1-A"), 1514 ARMCPUTestParams<AArch64::ExtensionBitset>( 1515 "thunderx3t110", "armv8.3-a", "crypto-neon-fp-armv8", 1516 (AArch64::ExtensionBitset( 1517 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1518 AArch64::AEK_LSE, AArch64::AEK_RDM, AArch64::AEK_FP, 1519 AArch64::AEK_SIMD, AArch64::AEK_RAS, AArch64::AEK_RCPC})), 1520 "8.3-A"), 1521 ARMCPUTestParams<AArch64::ExtensionBitset>( 1522 "thunderx", "armv8-a", "crypto-neon-fp-armv8", 1523 (AArch64::ExtensionBitset( 1524 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1525 AArch64::AEK_SIMD, AArch64::AEK_FP})), 1526 "8-A"), 1527 ARMCPUTestParams<AArch64::ExtensionBitset>( 1528 "thunderxt81", "armv8-a", "crypto-neon-fp-armv8", 1529 (AArch64::ExtensionBitset( 1530 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1531 AArch64::AEK_SIMD, AArch64::AEK_FP})), 1532 "8-A"), 1533 ARMCPUTestParams<AArch64::ExtensionBitset>( 1534 "thunderxt83", "armv8-a", "crypto-neon-fp-armv8", 1535 (AArch64::ExtensionBitset( 1536 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1537 AArch64::AEK_SIMD, AArch64::AEK_FP})), 1538 "8-A"), 1539 ARMCPUTestParams<AArch64::ExtensionBitset>( 1540 "thunderxt88", "armv8-a", "crypto-neon-fp-armv8", 1541 (AArch64::ExtensionBitset( 1542 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1543 AArch64::AEK_SIMD, AArch64::AEK_FP})), 1544 "8-A"), 1545 ARMCPUTestParams<AArch64::ExtensionBitset>( 1546 "tsv110", "armv8.2-a", "crypto-neon-fp-armv8", 1547 (AArch64::ExtensionBitset( 1548 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1549 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_RAS, 1550 AArch64::AEK_LSE, AArch64::AEK_RDM, AArch64::AEK_PROFILE, 1551 AArch64::AEK_FP16, AArch64::AEK_FP16FML, 1552 AArch64::AEK_DOTPROD})), 1553 "8.2-A"), 1554 ARMCPUTestParams<AArch64::ExtensionBitset>( 1555 "a64fx", "armv8.2-a", "crypto-neon-fp-armv8", 1556 (AArch64::ExtensionBitset( 1557 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1558 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_FP16, 1559 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_SVE, 1560 AArch64::AEK_RDM})), 1561 "8.2-A"), 1562 ARMCPUTestParams<AArch64::ExtensionBitset>( 1563 "carmel", "armv8.2-a", "crypto-neon-fp-armv8", 1564 (AArch64::ExtensionBitset( 1565 {AArch64::AEK_CRC, AArch64::AEK_AES, AArch64::AEK_SHA2, 1566 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_FP16, 1567 AArch64::AEK_RAS, AArch64::AEK_LSE, AArch64::AEK_RDM})), 1568 "8.2-A"))); 1569 1570 // Note: number of CPUs includes aliases. 1571 static constexpr unsigned NumAArch64CPUArchs = 62; 1572 1573 TEST(TargetParserTest, testAArch64CPUArchList) { 1574 SmallVector<StringRef, NumAArch64CPUArchs> List; 1575 AArch64::fillValidCPUArchList(List); 1576 1577 // No list exists for these in this test suite, so ensure all are 1578 // valid, and match the expected 'magic' count. 1579 EXPECT_EQ(List.size(), NumAArch64CPUArchs); 1580 for (StringRef CPU : List) { 1581 EXPECT_TRUE(AArch64::parseCpu(CPU)); 1582 } 1583 } 1584 1585 bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch, 1586 unsigned ArchAttr) { 1587 const std::optional<AArch64::ArchInfo> AI = AArch64::parseArch(Arch); 1588 return AI.has_value(); 1589 } 1590 1591 TEST(TargetParserTest, testAArch64Arch) { 1592 EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8a", 1593 ARMBuildAttrs::CPUArch::v8_A)); 1594 EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a", 1595 ARMBuildAttrs::CPUArch::v8_A)); 1596 EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a", 1597 ARMBuildAttrs::CPUArch::v8_A)); 1598 EXPECT_TRUE(testAArch64Arch("armv8.3-a", "generic", "v8.3a", 1599 ARMBuildAttrs::CPUArch::v8_A)); 1600 EXPECT_TRUE(testAArch64Arch("armv8.4-a", "generic", "v8.4a", 1601 ARMBuildAttrs::CPUArch::v8_A)); 1602 EXPECT_TRUE(testAArch64Arch("armv8.5-a", "generic", "v8.5a", 1603 ARMBuildAttrs::CPUArch::v8_A)); 1604 EXPECT_TRUE(testAArch64Arch("armv8.6-a", "generic", "v8.6a", 1605 ARMBuildAttrs::CPUArch::v8_A)); 1606 EXPECT_TRUE(testAArch64Arch("armv8.7-a", "generic", "v8.7a", 1607 ARMBuildAttrs::CPUArch::v8_A)); 1608 EXPECT_TRUE(testAArch64Arch("armv8.8-a", "generic", "v8.8a", 1609 ARMBuildAttrs::CPUArch::v8_A)); 1610 EXPECT_TRUE(testAArch64Arch("armv8.9-a", "generic", "v8.9a", 1611 ARMBuildAttrs::CPUArch::v8_A)); 1612 EXPECT_TRUE(testAArch64Arch("armv9-a", "generic", "v9a", 1613 ARMBuildAttrs::CPUArch::v8_A)); 1614 EXPECT_TRUE(testAArch64Arch("armv9.1-a", "generic", "v9.1a", 1615 ARMBuildAttrs::CPUArch::v8_A)); 1616 EXPECT_TRUE(testAArch64Arch("armv9.2-a", "generic", "v9.2a", 1617 ARMBuildAttrs::CPUArch::v8_A)); 1618 EXPECT_TRUE(testAArch64Arch("armv9.3-a", "generic", "v9.3a", 1619 ARMBuildAttrs::CPUArch::v8_A)); 1620 EXPECT_TRUE(testAArch64Arch("armv9.4-a", "generic", "v9.4a", 1621 ARMBuildAttrs::CPUArch::v8_A)); 1622 } 1623 1624 bool testAArch64Extension(StringRef CPUName, StringRef ArchExt) { 1625 std::optional<AArch64::ExtensionInfo> Extension = 1626 AArch64::parseArchExtension(ArchExt); 1627 if (!Extension) 1628 return false; 1629 std::optional<AArch64::CpuInfo> CpuInfo = AArch64::parseCpu(CPUName); 1630 return CpuInfo->getImpliedExtensions().test(Extension->ID); 1631 } 1632 1633 bool testAArch64Extension(const AArch64::ArchInfo &AI, StringRef ArchExt) { 1634 std::optional<AArch64::ExtensionInfo> Extension = 1635 AArch64::parseArchExtension(ArchExt); 1636 if (!Extension) 1637 return false; 1638 return AI.DefaultExts.test(Extension->ID); 1639 } 1640 1641 TEST(TargetParserTest, testAArch64Extension) { 1642 EXPECT_FALSE(testAArch64Extension("cortex-a34", "ras")); 1643 EXPECT_FALSE(testAArch64Extension("cortex-a35", "ras")); 1644 EXPECT_FALSE(testAArch64Extension("cortex-a53", "ras")); 1645 EXPECT_TRUE(testAArch64Extension("cortex-a55", "ras")); 1646 EXPECT_TRUE(testAArch64Extension("cortex-a55", "fp16")); 1647 EXPECT_FALSE(testAArch64Extension("cortex-a55", "fp16fml")); 1648 EXPECT_TRUE(testAArch64Extension("cortex-a55", "dotprod")); 1649 EXPECT_FALSE(testAArch64Extension("cortex-a57", "ras")); 1650 EXPECT_FALSE(testAArch64Extension("cortex-a72", "ras")); 1651 EXPECT_FALSE(testAArch64Extension("cortex-a73", "ras")); 1652 EXPECT_TRUE(testAArch64Extension("cortex-a75", "ras")); 1653 EXPECT_TRUE(testAArch64Extension("cortex-a75", "fp16")); 1654 EXPECT_FALSE(testAArch64Extension("cortex-a75", "fp16fml")); 1655 EXPECT_TRUE(testAArch64Extension("cortex-a75", "dotprod")); 1656 EXPECT_TRUE(testAArch64Extension("cortex-r82", "ras")); 1657 EXPECT_TRUE(testAArch64Extension("cortex-r82", "fp16")); 1658 EXPECT_TRUE(testAArch64Extension("cortex-r82", "fp16fml")); 1659 EXPECT_TRUE(testAArch64Extension("cortex-r82", "dotprod")); 1660 EXPECT_TRUE(testAArch64Extension("cortex-r82", "lse")); 1661 EXPECT_FALSE(testAArch64Extension("cyclone", "ras")); 1662 EXPECT_FALSE(testAArch64Extension("exynos-m3", "ras")); 1663 EXPECT_TRUE(testAArch64Extension("exynos-m4", "dotprod")); 1664 EXPECT_TRUE(testAArch64Extension("exynos-m4", "fp16")); 1665 EXPECT_TRUE(testAArch64Extension("exynos-m4", "lse")); 1666 EXPECT_TRUE(testAArch64Extension("exynos-m4", "ras")); 1667 EXPECT_TRUE(testAArch64Extension("exynos-m4", "rdm")); 1668 EXPECT_TRUE(testAArch64Extension("exynos-m5", "dotprod")); 1669 EXPECT_TRUE(testAArch64Extension("exynos-m5", "fp16")); 1670 EXPECT_TRUE(testAArch64Extension("exynos-m5", "lse")); 1671 EXPECT_TRUE(testAArch64Extension("exynos-m5", "ras")); 1672 EXPECT_TRUE(testAArch64Extension("exynos-m5", "rdm")); 1673 EXPECT_TRUE(testAArch64Extension("falkor", "rdm")); 1674 EXPECT_FALSE(testAArch64Extension("kryo", "ras")); 1675 EXPECT_TRUE(testAArch64Extension("saphira", "crc")); 1676 EXPECT_TRUE(testAArch64Extension("saphira", "lse")); 1677 EXPECT_TRUE(testAArch64Extension("saphira", "rdm")); 1678 EXPECT_TRUE(testAArch64Extension("saphira", "ras")); 1679 EXPECT_TRUE(testAArch64Extension("saphira", "rcpc")); 1680 EXPECT_TRUE(testAArch64Extension("saphira", "profile")); 1681 EXPECT_FALSE(testAArch64Extension("saphira", "fp16")); 1682 EXPECT_FALSE(testAArch64Extension("thunderx2t99", "ras")); 1683 EXPECT_FALSE(testAArch64Extension("thunderx", "lse")); 1684 EXPECT_FALSE(testAArch64Extension("thunderxt81", "lse")); 1685 EXPECT_FALSE(testAArch64Extension("thunderxt83", "lse")); 1686 EXPECT_FALSE(testAArch64Extension("thunderxt88", "lse")); 1687 EXPECT_TRUE(testAArch64Extension("tsv110", "aes")); 1688 EXPECT_TRUE(testAArch64Extension("tsv110", "sha2")); 1689 EXPECT_FALSE(testAArch64Extension("tsv110", "sha3")); 1690 EXPECT_FALSE(testAArch64Extension("tsv110", "sm4")); 1691 EXPECT_TRUE(testAArch64Extension("tsv110", "ras")); 1692 EXPECT_TRUE(testAArch64Extension("tsv110", "profile")); 1693 EXPECT_TRUE(testAArch64Extension("tsv110", "fp16")); 1694 EXPECT_TRUE(testAArch64Extension("tsv110", "fp16fml")); 1695 EXPECT_TRUE(testAArch64Extension("tsv110", "dotprod")); 1696 EXPECT_TRUE(testAArch64Extension("a64fx", "fp16")); 1697 EXPECT_TRUE(testAArch64Extension("a64fx", "sve")); 1698 EXPECT_FALSE(testAArch64Extension("a64fx", "sve2")); 1699 EXPECT_TRUE(testAArch64Extension("carmel", "aes")); 1700 EXPECT_TRUE(testAArch64Extension("carmel", "sha2")); 1701 EXPECT_TRUE(testAArch64Extension("carmel", "fp16")); 1702 1703 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8A, "ras")); 1704 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_1A, "ras")); 1705 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_2A, "profile")); 1706 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_2A, "fp16")); 1707 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_2A, "fp16fml")); 1708 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_3A, "fp16")); 1709 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_3A, "fp16fml")); 1710 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_4A, "fp16")); 1711 EXPECT_FALSE(testAArch64Extension(AArch64::ARMV8_4A, "fp16fml")); 1712 } 1713 1714 TEST(TargetParserTest, AArch64ExtensionFeatures) { 1715 std::vector<uint64_t> Extensions = { 1716 AArch64::AEK_CRC, AArch64::AEK_LSE, AArch64::AEK_RDM, 1717 AArch64::AEK_CRYPTO, AArch64::AEK_SM4, AArch64::AEK_SHA3, 1718 AArch64::AEK_SHA2, AArch64::AEK_AES, AArch64::AEK_DOTPROD, 1719 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_FP16, 1720 AArch64::AEK_FP16FML, AArch64::AEK_PROFILE, AArch64::AEK_RAS, 1721 AArch64::AEK_SVE, AArch64::AEK_SVE2, AArch64::AEK_SVE2AES, 1722 AArch64::AEK_SVE2SM4, AArch64::AEK_SVE2SHA3, AArch64::AEK_SVE2BITPERM, 1723 AArch64::AEK_RCPC, AArch64::AEK_RAND, AArch64::AEK_MTE, 1724 AArch64::AEK_SSBS, AArch64::AEK_SB, AArch64::AEK_PREDRES, 1725 AArch64::AEK_BF16, AArch64::AEK_I8MM, AArch64::AEK_F32MM, 1726 AArch64::AEK_F64MM, AArch64::AEK_TME, AArch64::AEK_LS64, 1727 AArch64::AEK_BRBE, AArch64::AEK_PAUTH, AArch64::AEK_FLAGM, 1728 AArch64::AEK_SME, AArch64::AEK_SMEF64F64, AArch64::AEK_SMEI16I64, 1729 AArch64::AEK_SME2, AArch64::AEK_HBC, AArch64::AEK_MOPS, 1730 AArch64::AEK_PERFMON, AArch64::AEK_SVE2p1, AArch64::AEK_SME2p1, 1731 AArch64::AEK_B16B16, AArch64::AEK_SMEF16F16, AArch64::AEK_CSSC, 1732 AArch64::AEK_RCPC3, AArch64::AEK_THE, AArch64::AEK_D128, 1733 AArch64::AEK_LSE128, AArch64::AEK_SPECRES2, AArch64::AEK_RASv2, 1734 AArch64::AEK_ITE, AArch64::AEK_GCS, AArch64::AEK_FPMR, 1735 AArch64::AEK_FP8, AArch64::AEK_FAMINMAX}; 1736 1737 std::vector<StringRef> Features; 1738 1739 AArch64::ExtensionBitset ExtVal; 1740 for (auto Ext : Extensions) 1741 ExtVal.set(Ext); 1742 1743 // NONE has no feature names. 1744 // We return True here because NONE is a valid choice. 1745 EXPECT_TRUE(AArch64::getExtensionFeatures( 1746 AArch64::ExtensionBitset({AArch64::AEK_NONE}), Features)); 1747 EXPECT_TRUE(!Features.size()); 1748 1749 AArch64::getExtensionFeatures(ExtVal, Features); 1750 EXPECT_EQ(Extensions.size(), Features.size()); 1751 1752 EXPECT_TRUE(llvm::is_contained(Features, "+crc")); 1753 EXPECT_TRUE(llvm::is_contained(Features, "+lse")); 1754 EXPECT_TRUE(llvm::is_contained(Features, "+rdm")); 1755 EXPECT_TRUE(llvm::is_contained(Features, "+crypto")); 1756 EXPECT_TRUE(llvm::is_contained(Features, "+sm4")); 1757 EXPECT_TRUE(llvm::is_contained(Features, "+sha3")); 1758 EXPECT_TRUE(llvm::is_contained(Features, "+sha2")); 1759 EXPECT_TRUE(llvm::is_contained(Features, "+aes")); 1760 EXPECT_TRUE(llvm::is_contained(Features, "+dotprod")); 1761 EXPECT_TRUE(llvm::is_contained(Features, "+fp-armv8")); 1762 EXPECT_TRUE(llvm::is_contained(Features, "+neon")); 1763 EXPECT_TRUE(llvm::is_contained(Features, "+fullfp16")); 1764 EXPECT_TRUE(llvm::is_contained(Features, "+fp16fml")); 1765 EXPECT_TRUE(llvm::is_contained(Features, "+spe")); 1766 EXPECT_TRUE(llvm::is_contained(Features, "+ras")); 1767 EXPECT_TRUE(llvm::is_contained(Features, "+sve")); 1768 EXPECT_TRUE(llvm::is_contained(Features, "+sve2")); 1769 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-aes")); 1770 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sm4")); 1771 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sha3")); 1772 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-bitperm")); 1773 EXPECT_TRUE(llvm::is_contained(Features, "+sve2p1")); 1774 EXPECT_TRUE(llvm::is_contained(Features, "+b16b16")); 1775 EXPECT_TRUE(llvm::is_contained(Features, "+rcpc")); 1776 EXPECT_TRUE(llvm::is_contained(Features, "+rand")); 1777 EXPECT_TRUE(llvm::is_contained(Features, "+mte")); 1778 EXPECT_TRUE(llvm::is_contained(Features, "+ssbs")); 1779 EXPECT_TRUE(llvm::is_contained(Features, "+sb")); 1780 EXPECT_TRUE(llvm::is_contained(Features, "+predres")); 1781 EXPECT_TRUE(llvm::is_contained(Features, "+bf16")); 1782 EXPECT_TRUE(llvm::is_contained(Features, "+i8mm")); 1783 EXPECT_TRUE(llvm::is_contained(Features, "+f32mm")); 1784 EXPECT_TRUE(llvm::is_contained(Features, "+f64mm")); 1785 EXPECT_TRUE(llvm::is_contained(Features, "+tme")); 1786 EXPECT_TRUE(llvm::is_contained(Features, "+ls64")); 1787 EXPECT_TRUE(llvm::is_contained(Features, "+brbe")); 1788 EXPECT_TRUE(llvm::is_contained(Features, "+pauth")); 1789 EXPECT_TRUE(llvm::is_contained(Features, "+flagm")); 1790 EXPECT_TRUE(llvm::is_contained(Features, "+sme")); 1791 EXPECT_TRUE(llvm::is_contained(Features, "+sme-f64f64")); 1792 EXPECT_TRUE(llvm::is_contained(Features, "+sme-i16i64")); 1793 EXPECT_TRUE(llvm::is_contained(Features, "+sme-f16f16")); 1794 EXPECT_TRUE(llvm::is_contained(Features, "+sme2")); 1795 EXPECT_TRUE(llvm::is_contained(Features, "+sme2p1")); 1796 EXPECT_TRUE(llvm::is_contained(Features, "+hbc")); 1797 EXPECT_TRUE(llvm::is_contained(Features, "+mops")); 1798 EXPECT_TRUE(llvm::is_contained(Features, "+perfmon")); 1799 EXPECT_TRUE(llvm::is_contained(Features, "+cssc")); 1800 EXPECT_TRUE(llvm::is_contained(Features, "+rcpc3")); 1801 EXPECT_TRUE(llvm::is_contained(Features, "+the")); 1802 EXPECT_TRUE(llvm::is_contained(Features, "+d128")); 1803 EXPECT_TRUE(llvm::is_contained(Features, "+lse128")); 1804 EXPECT_TRUE(llvm::is_contained(Features, "+specres2")); 1805 EXPECT_TRUE(llvm::is_contained(Features, "+ite")); 1806 EXPECT_TRUE(llvm::is_contained(Features, "+gcs")); 1807 EXPECT_TRUE(llvm::is_contained(Features, "+fpmr")); 1808 EXPECT_TRUE(llvm::is_contained(Features, "+fp8")); 1809 EXPECT_TRUE(llvm::is_contained(Features, "+faminmax")); 1810 1811 // Assuming we listed every extension above, this should produce the same 1812 // result. (note that AEK_NONE doesn't have a name so it won't be in the 1813 // result despite its bit being set) 1814 std::vector<StringRef> AllFeatures; 1815 EXPECT_TRUE(AArch64::getExtensionFeatures(ExtVal, AllFeatures)); 1816 EXPECT_THAT(Features, ::testing::ContainerEq(AllFeatures)); 1817 } 1818 1819 TEST(TargetParserTest, AArch64ArchFeatures) { 1820 EXPECT_EQ(AArch64::ARMV8A.ArchFeature, "+v8a"); 1821 EXPECT_EQ(AArch64::ARMV8_1A.ArchFeature, "+v8.1a"); 1822 EXPECT_EQ(AArch64::ARMV8_2A.ArchFeature, "+v8.2a"); 1823 EXPECT_EQ(AArch64::ARMV8_3A.ArchFeature, "+v8.3a"); 1824 EXPECT_EQ(AArch64::ARMV8_4A.ArchFeature, "+v8.4a"); 1825 EXPECT_EQ(AArch64::ARMV8_5A.ArchFeature, "+v8.5a"); 1826 EXPECT_EQ(AArch64::ARMV8_6A.ArchFeature, "+v8.6a"); 1827 EXPECT_EQ(AArch64::ARMV8_7A.ArchFeature, "+v8.7a"); 1828 EXPECT_EQ(AArch64::ARMV8_8A.ArchFeature, "+v8.8a"); 1829 EXPECT_EQ(AArch64::ARMV8_9A.ArchFeature, "+v8.9a"); 1830 EXPECT_EQ(AArch64::ARMV9A.ArchFeature, "+v9a"); 1831 EXPECT_EQ(AArch64::ARMV9_1A.ArchFeature, "+v9.1a"); 1832 EXPECT_EQ(AArch64::ARMV9_2A.ArchFeature, "+v9.2a"); 1833 EXPECT_EQ(AArch64::ARMV9_3A.ArchFeature, "+v9.3a"); 1834 EXPECT_EQ(AArch64::ARMV9_4A.ArchFeature, "+v9.4a"); 1835 EXPECT_EQ(AArch64::ARMV8R.ArchFeature, "+v8r"); 1836 } 1837 1838 TEST(TargetParserTest, AArch64ArchPartialOrder) { 1839 for (const auto *A : AArch64::ArchInfos) { 1840 EXPECT_EQ(*A, *A); 1841 1842 // v8r has no relation to other valid architectures 1843 if (*A != AArch64::ARMV8R) { 1844 EXPECT_FALSE(A->implies(AArch64::ARMV8R)); 1845 EXPECT_FALSE(AArch64::ARMV8R.implies(*A)); 1846 } 1847 } 1848 1849 for (const auto *A : { 1850 &AArch64::ARMV8_1A, 1851 &AArch64::ARMV8_2A, 1852 &AArch64::ARMV8_3A, 1853 &AArch64::ARMV8_4A, 1854 &AArch64::ARMV8_5A, 1855 &AArch64::ARMV8_6A, 1856 &AArch64::ARMV8_7A, 1857 &AArch64::ARMV8_8A, 1858 &AArch64::ARMV8_9A, 1859 }) 1860 EXPECT_TRUE(A->implies(AArch64::ARMV8A)); 1861 1862 for (const auto *A : {&AArch64::ARMV9_1A, &AArch64::ARMV9_2A, 1863 &AArch64::ARMV9_3A, &AArch64::ARMV9_4A}) 1864 EXPECT_TRUE(A->implies(AArch64::ARMV9A)); 1865 1866 EXPECT_TRUE(AArch64::ARMV8_1A.implies(AArch64::ARMV8A)); 1867 EXPECT_TRUE(AArch64::ARMV8_2A.implies(AArch64::ARMV8_1A)); 1868 EXPECT_TRUE(AArch64::ARMV8_3A.implies(AArch64::ARMV8_2A)); 1869 EXPECT_TRUE(AArch64::ARMV8_4A.implies(AArch64::ARMV8_3A)); 1870 EXPECT_TRUE(AArch64::ARMV8_5A.implies(AArch64::ARMV8_4A)); 1871 EXPECT_TRUE(AArch64::ARMV8_6A.implies(AArch64::ARMV8_5A)); 1872 EXPECT_TRUE(AArch64::ARMV8_7A.implies(AArch64::ARMV8_6A)); 1873 EXPECT_TRUE(AArch64::ARMV8_8A.implies(AArch64::ARMV8_7A)); 1874 EXPECT_TRUE(AArch64::ARMV8_9A.implies(AArch64::ARMV8_8A)); 1875 1876 EXPECT_TRUE(AArch64::ARMV9_1A.implies(AArch64::ARMV9A)); 1877 EXPECT_TRUE(AArch64::ARMV9_2A.implies(AArch64::ARMV9_1A)); 1878 EXPECT_TRUE(AArch64::ARMV9_3A.implies(AArch64::ARMV9_2A)); 1879 EXPECT_TRUE(AArch64::ARMV9_4A.implies(AArch64::ARMV9_3A)); 1880 1881 EXPECT_TRUE(AArch64::ARMV9A.implies(AArch64::ARMV8_5A)); 1882 EXPECT_TRUE(AArch64::ARMV9_1A.implies(AArch64::ARMV8_6A)); 1883 EXPECT_TRUE(AArch64::ARMV9_2A.implies(AArch64::ARMV8_7A)); 1884 EXPECT_TRUE(AArch64::ARMV9_3A.implies(AArch64::ARMV8_8A)); 1885 EXPECT_TRUE(AArch64::ARMV9_4A.implies(AArch64::ARMV8_9A)); 1886 } 1887 1888 TEST(TargetParserTest, AArch64ArchExtFeature) { 1889 const char *ArchExt[][4] = { 1890 {"crc", "nocrc", "+crc", "-crc"}, 1891 {"crypto", "nocrypto", "+crypto", "-crypto"}, 1892 {"flagm", "noflagm", "+flagm", "-flagm"}, 1893 {"fp", "nofp", "+fp-armv8", "-fp-armv8"}, 1894 {"simd", "nosimd", "+neon", "-neon"}, 1895 {"fp16", "nofp16", "+fullfp16", "-fullfp16"}, 1896 {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"}, 1897 {"profile", "noprofile", "+spe", "-spe"}, 1898 {"ras", "noras", "+ras", "-ras"}, 1899 {"lse", "nolse", "+lse", "-lse"}, 1900 {"rdm", "nordm", "+rdm", "-rdm"}, 1901 {"sve", "nosve", "+sve", "-sve"}, 1902 {"sve2", "nosve2", "+sve2", "-sve2"}, 1903 {"sve2-aes", "nosve2-aes", "+sve2-aes", "-sve2-aes"}, 1904 {"sve2-sm4", "nosve2-sm4", "+sve2-sm4", "-sve2-sm4"}, 1905 {"sve2-sha3", "nosve2-sha3", "+sve2-sha3", "-sve2-sha3"}, 1906 {"sve2p1", "nosve2p1", "+sve2p1", "-sve2p1"}, 1907 {"b16b16", "nob16b16", "+b16b16", "-b16b16"}, 1908 {"sve2-bitperm", "nosve2-bitperm", "+sve2-bitperm", "-sve2-bitperm"}, 1909 {"dotprod", "nodotprod", "+dotprod", "-dotprod"}, 1910 {"rcpc", "norcpc", "+rcpc", "-rcpc"}, 1911 {"rng", "norng", "+rand", "-rand"}, 1912 {"memtag", "nomemtag", "+mte", "-mte"}, 1913 {"tme", "notme", "+tme", "-tme"}, 1914 {"pauth", "nopauth", "+pauth", "-pauth"}, 1915 {"ssbs", "nossbs", "+ssbs", "-ssbs"}, 1916 {"sb", "nosb", "+sb", "-sb"}, 1917 {"predres", "nopredres", "+predres", "-predres"}, 1918 {"i8mm", "noi8mm", "+i8mm", "-i8mm"}, 1919 {"f32mm", "nof32mm", "+f32mm", "-f32mm"}, 1920 {"f64mm", "nof64mm", "+f64mm", "-f64mm"}, 1921 {"sme", "nosme", "+sme", "-sme"}, 1922 {"sme-f64f64", "nosme-f64f64", "+sme-f64f64", "-sme-f64f64"}, 1923 {"sme-i16i64", "nosme-i16i64", "+sme-i16i64", "-sme-i16i64"}, 1924 {"sme-f16f16", "nosme-f16f16", "+sme-f16f16", "-sme-f16f16"}, 1925 {"sme2", "nosme2", "+sme2", "-sme2"}, 1926 {"sme2p1", "nosme2p1", "+sme2p1", "-sme2p1"}, 1927 {"hbc", "nohbc", "+hbc", "-hbc"}, 1928 {"mops", "nomops", "+mops", "-mops"}, 1929 {"pmuv3", "nopmuv3", "+perfmon", "-perfmon"}, 1930 {"predres2", "nopredres2", "+specres2", "-specres2"}, 1931 {"rasv2", "norasv2", "+rasv2", "-rasv2"}, 1932 {"gcs", "nogcs", "+gcs", "-gcs"}, 1933 {"fpmr", "nofpmr", "+fpmr", "-fpmr"}, 1934 {"fp8", "nofp8", "+fp8", "-fp8"}, 1935 {"faminmax", "nofaminmax", "+faminmax", "-faminmax"}, 1936 }; 1937 1938 for (unsigned i = 0; i < std::size(ArchExt); i++) { 1939 EXPECT_EQ(StringRef(ArchExt[i][2]), 1940 AArch64::getArchExtFeature(ArchExt[i][0])); 1941 EXPECT_EQ(StringRef(ArchExt[i][3]), 1942 AArch64::getArchExtFeature(ArchExt[i][1])); 1943 } 1944 } 1945 1946 TEST(TargetParserTest, AArch64PrintSupportedExtensions) { 1947 std::string expected = "All available -march extensions for AArch64\n\n" 1948 " Name Description\n" 1949 " aes This is a long dummy description\n" 1950 " b16b16\n" 1951 " bf16\n"; 1952 1953 StringMap<StringRef> DummyMap; 1954 DummyMap["aes"] = "This is a long dummy description"; 1955 1956 outs().flush(); 1957 testing::internal::CaptureStdout(); 1958 AArch64::PrintSupportedExtensions(DummyMap); 1959 outs().flush(); 1960 std::string captured = testing::internal::GetCapturedStdout(); 1961 1962 // Check that the start of the output is as expected. 1963 EXPECT_EQ(0ULL, captured.find(expected)); 1964 1965 // Should not include "none". 1966 EXPECT_EQ(std::string::npos, captured.find("none")); 1967 // Should not include anything that lacks a feature name. Checking a few here 1968 // but not all as if one is hidden correctly the rest should be. 1969 EXPECT_EQ(std::string::npos, captured.find("memtag3")); 1970 EXPECT_EQ(std::string::npos, captured.find("sha1")); 1971 EXPECT_EQ(std::string::npos, captured.find("ssbs2")); 1972 } 1973 1974 } // namespace 1975