Index: include/llvm/Support/AArch64TargetParser.def =================================================================== --- include/llvm/Support/AArch64TargetParser.def +++ include/llvm/Support/AArch64TargetParser.def @@ -16,15 +16,17 @@ #ifndef AARCH64_ARCH #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) #endif -AARCH64_ARCH("armv8-a", AK_ARMV8A, "8-A", "v8", ARMBuildAttrs::CPUArch::v8_A, +AARCH64_ARCH("invalid", AAK_INVALID, nullptr, nullptr, + ARMBuildAttrs::CPUArch::v8_A, FK_NONE, AArch64::AEK_NONE) +AARCH64_ARCH("armv8-a", AAK_ARMV8A, "8-A", "v8", ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8, (AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_FP16 | AArch64::AEK_PROFILE)) -AARCH64_ARCH("armv8.1-a", AK_ARMV8_1A, "8.1-A", "v8.1a", +AARCH64_ARCH("armv8.1-a", AAK_ARMV8_1A, "8.1-A", "v8.1a", ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8, (AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_FP16 | AArch64::AEK_PROFILE)) -AARCH64_ARCH("armv8.2-a", AK_ARMV8_2A, "8.2-A", "v8.2a", +AARCH64_ARCH("armv8.2-a", AAK_ARMV8_2A, "8.2-A", "v8.2a", ARMBuildAttrs::CPUArch::v8_A, FK_CRYPTO_NEON_FP_ARMV8, (AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_FP16 | AArch64::AEK_PROFILE | @@ -49,24 +51,24 @@ #ifndef AARCH64_CPU_NAME #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) #endif -AARCH64_CPU_NAME("cortex-a35", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("cortex-a35", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("cortex-a53", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, true, +AARCH64_CPU_NAME("cortex-a53", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, true, ( AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("cortex-a57", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("cortex-a57", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("cortex-a72", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("cortex-a72", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("cortex-a73", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("cortex-a73", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("cyclone", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("cyclone", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("exynos-m1", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("exynos-m1", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("kryo", AK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("kryo", AAK_ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) -AARCH64_CPU_NAME("vulcan", AK_ARMV8_1A, FK_CRYPTO_NEON_FP_ARMV8, false, +AARCH64_CPU_NAME("vulcan", AAK_ARMV8_1A, FK_CRYPTO_NEON_FP_ARMV8, false, (AArch64::AEK_SIMD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO)) // Invalid CPU -AARCH64_CPU_NAME("invalid", AK_INVALID, FK_INVALID, true, AArch64::AEK_INVALID) +AARCH64_CPU_NAME("invalid", AAK_INVALID, FK_INVALID, true, AArch64::AEK_INVALID) #undef AARCH64_CPU_NAME Index: include/llvm/Support/TargetParser.h =================================================================== --- include/llvm/Support/TargetParser.h +++ include/llvm/Support/TargetParser.h @@ -145,6 +145,13 @@ // FIXME:This should be made into class design,to avoid dupplication. namespace AArch64 { +// Arch names. +enum ArchKind { +#define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID, +#include "AArch64TargetParser.def" + AAK_LAST +}; + // Arch extension modifiers for CPUs. enum ArchExtKind : unsigned { AEK_INVALID = 0x0, Index: lib/Support/TargetParser.cpp =================================================================== --- lib/Support/TargetParser.cpp +++ lib/Support/TargetParser.cpp @@ -61,7 +61,7 @@ size_t SubArchLength; unsigned DefaultFPU; unsigned ArchBaseExtensions; - ARM::ArchKind ID; + unsigned ID; ARMBuildAttrs::CPUArch ArchAttr; // Arch ID in build attributes. StringRef getName() const { return StringRef(NameCStr, NameLength); } @@ -125,7 +125,7 @@ static const struct { const char *NameCStr; size_t NameLength; - ARM::ArchKind ArchID; + unsigned ArchID; bool Default; // is $Name the default CPU for $ArchID ? unsigned DefaultExtensions; @@ -416,7 +416,7 @@ return StringSwitch(CPU) #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \ - .Case(NAME, AArch64ARCHNames[ID].ArchBaseExtensions | DEFAULT_EXT) + .Case(NAME, DEFAULT_EXT) #include "llvm/Support/AArch64TargetParser.def" .Default(AArch64::AEK_INVALID); } @@ -452,48 +452,44 @@ bool llvm::AArch64::getArchFeatures(unsigned ArchKind, std::vector &Features) { - if (ArchKind == ARM::AK_INVALID || ArchKind >= ARM::AK_LAST) + if (ArchKind == AArch64::AAK_INVALID || ArchKind >= AArch64::AAK_LAST) return false; - if (ArchKind == ARM::AK_ARMV8_1A) + if (ArchKind == AArch64::AAK_ARMV8_1A) Features.push_back("+v8.1a"); - if (ArchKind == ARM::AK_ARMV8_2A) + if (ArchKind == AArch64::AAK_ARMV8_2A) Features.push_back("+v8.2a"); return true; } StringRef llvm::AArch64::getArchName(unsigned ArchKind) { - for (const auto &AI : AArch64ARCHNames) - if (AI.ID == ArchKind) - return AI.getName(); - return StringRef(); + if (ArchKind >= AArch64::AAK_LAST) + return StringRef(); + return AArch64ARCHNames[ArchKind].getName(); } StringRef llvm::AArch64::getCPUAttr(unsigned ArchKind) { - for (const auto &AI : AArch64ARCHNames) - if (AI.ID == ArchKind) - return AI.getCPUAttr(); - return StringRef(); + if (ArchKind == AArch64::AAK_INVALID || ArchKind >= AArch64::AAK_LAST) + return StringRef(); + return AArch64ARCHNames[ArchKind].getCPUAttr(); } StringRef llvm::AArch64::getSubArch(unsigned ArchKind) { - for (const auto &AI : AArch64ARCHNames) - if (AI.ID == ArchKind) - return AI.getSubArch(); - return StringRef(); + if (ArchKind == AArch64::AAK_INVALID || ArchKind >= AArch64::AAK_LAST) + return StringRef(); + return AArch64ARCHNames[ArchKind].getSubArch(); } unsigned llvm::AArch64::getArchAttr(unsigned ArchKind) { - for (const auto &AI : AArch64ARCHNames) - if (AI.ID == ArchKind) - return AI.ArchAttr; - return ARMBuildAttrs::CPUArch::v8_A; + if (ArchKind >= AArch64::AAK_LAST) + return ARMBuildAttrs::CPUArch::v8_A; + return AArch64ARCHNames[ArchKind].ArchAttr; } -StringRef llvm::AArch64::getArchExtName(unsigned AArchExtKind) { +StringRef llvm::AArch64::getArchExtName(unsigned ArchExtKind) { for (const auto &AE : AArch64ARCHExtNames) - if (AArchExtKind == AE.ID) + if (ArchExtKind == AE.ID) return AE.getName(); return StringRef(); } @@ -515,7 +511,7 @@ StringRef llvm::AArch64::getDefaultCPU(StringRef Arch) { unsigned AK = parseArch(Arch); - if (AK == ARM::AK_INVALID) + if (AK == AArch64::AAK_INVALID) return StringRef(); // Look for multiple AKs to find the default for pair AK+Name. @@ -784,14 +780,14 @@ unsigned llvm::AArch64::parseArch(StringRef Arch) { Arch = getCanonicalArchName(Arch); if (checkArchVersion(Arch) < 8) - return ARM::AK_INVALID; + return AArch64::AAK_INVALID; StringRef Syn = getArchSynonym(Arch); for (const auto A : AArch64ARCHNames) { if (A.getName().endswith(Syn)) return A.ID; } - return ARM::AK_INVALID; + return AArch64::AAK_INVALID; } unsigned llvm::AArch64::parseArchExt(StringRef ArchExt) { @@ -807,7 +803,7 @@ if (CPU == C.getName()) return C.ArchID; } - return ARM::AK_INVALID; + return AArch64::AAK_INVALID; } // ARM, Thumb, AArch64 Index: lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp =================================================================== --- lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp +++ lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp @@ -4233,7 +4233,7 @@ getParser().parseStringToEndOfStatement().trim().split('+'); unsigned ID = AArch64::parseArch(Arch); - if (ID == ARM::AK_INVALID) { + if (ID == AArch64::AAK_INVALID) { Error(ArchLoc, "unknown arch name"); return false; } Index: unittests/Support/TargetParserTest.cpp =================================================================== --- unittests/Support/TargetParserTest.cpp +++ unittests/Support/TargetParserTest.cpp @@ -9,6 +9,8 @@ #include "gtest/gtest.h" #include "llvm/Support/TargetParser.h" +#include "llvm/Support/ARMBuildAttributes.h" +#include "llvm/ADT/STLExtras.h" using namespace llvm; @@ -16,11 +18,55 @@ static const unsigned kAArch64ArchKinds[] = { #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, \ ARCH_BASE_EXT) \ - llvm::ARM::ID, + llvm::AArch64::ID, #include "llvm/Support/AArch64TargetParser.def" #undef AARCH64_ARCH }; +static const unsigned kAArch64ArchExtKinds[] = { +#define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) \ + ID, +#include "llvm/Support/AArch64TargetParser.def" +#undef AARCH64_ARCH_EXT_NAME +}; + +static const struct { + const char *Name; + unsigned DefaultFPU; + unsigned ArchBaseExtensions; + unsigned ID; + ARMBuildAttrs::CPUArch ArchAttr; +} kAArch64ARCHNames[] = { +#define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) \ + {NAME, llvm::ARM::ARCH_FPU, ARCH_BASE_EXT, llvm::AArch64::ID, ARCH_ATTR}, +#include "llvm/Support/AArch64TargetParser.def" +#undef AARCH64_ARCH +}; + +static const struct { + const char *Name; + unsigned ID; + const char *Feature; + const char *NegFeature; +} kAArch64ARCHExtNames[] = { +#define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) \ + { NAME, ID, FEATURE, NEGFEATURE }, +#include "llvm/Support/AArch64TargetParser.def" +#undef AARCH64_ARCH_EXT_NAME +}; + +static const struct { + const char *Name; + unsigned ID; + unsigned DefaultFPU; + unsigned DefaultExt; +} kAArch64CPUNames[] = { +#define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \ + { NAME, llvm::AArch64::ID, llvm::ARM::DEFAULT_FPU, DEFAULT_EXT }, +#include "llvm/Support/AArch64TargetParser.def" +#undef AARCH64_CPU_NAME +}; + template bool contains(const T (&array)[N], const T element) { return std::find(std::begin(array), std::end(array), element) != @@ -62,31 +108,166 @@ : !ARM::getFPUName(FK).empty()); } +TEST(TargetParserTest, AArch64DefaultFPU) { + for (AArch64::ArchKind AK = static_cast(0); + AK < AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_EQ(kAArch64ARCHNames[AK].DefaultFPU, + AArch64::getDefaultFPU(StringRef("generic"), AK)); + + for (unsigned i = 0; i< array_lengthof(kAArch64CPUNames); i++) + EXPECT_EQ(kAArch64CPUNames[i].DefaultFPU, + AArch64::getDefaultFPU(kAArch64CPUNames[i].Name, + kAArch64CPUNames[i].ID)); +} + +TEST(TargetParserTest, AArch64DefaultExt) { + for (AArch64::ArchKind AK = static_cast(0); + AK < AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_EQ(kAArch64ARCHNames[AK].ArchBaseExtensions, + AArch64::getDefaultExtensions(StringRef("generic"), AK)); + + for (unsigned i = 0; i < array_lengthof(kAArch64CPUNames); i++) + EXPECT_EQ(kAArch64CPUNames[i].DefaultExt, + AArch64::getDefaultExtensions(kAArch64CPUNames[i].Name, + kAArch64CPUNames[i].ID)); +} + +TEST(TargetParserTest, AArch64ExtensionFeatures) { + std::vector Features; + unsigned Extensions = AArch64::AEK_CRC | + AArch64::AEK_CRYPTO | + AArch64::AEK_FP | + AArch64::AEK_SIMD | + AArch64::AEK_FP16 | + AArch64::AEK_PROFILE | + AArch64::AEK_RAS; + + for (unsigned i = 0; i <= Extensions; i++) + EXPECT_TRUE(i == 0 ? !AArch64::getExtensionFeatures(i, Features) + : AArch64::getExtensionFeatures(i, Features)); +} + +TEST(TargetParserTest, AArch64ArchFeatures) { + std::vector Features; + + for (AArch64::ArchKind AK = static_cast(0); + AK < AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_TRUE((AK == AArch64::AAK_INVALID || AK == AArch64::AAK_LAST) + ? !AArch64::getArchFeatures(AK, Features) + : AArch64::getArchFeatures(AK, Features)); +} + TEST(TargetParserTest, AArch64ArchName) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE(contains(kAArch64ArchKinds, static_cast(AK)) - ? !AArch64::getArchName(AK).empty() - : AArch64::getArchName(AK).empty()); + for (AArch64::ArchKind AK = static_cast(0); + AK <= AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_TRUE(AK == AArch64::AAK_LAST + ? AArch64::getArchName(AK).empty() + : !AArch64::getArchName(AK).empty()); } TEST(TargetParserTest, AArch64CPUAttr) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE(contains(kAArch64ArchKinds, static_cast(AK)) - ? !AArch64::getCPUAttr(AK).empty() - : AArch64::getCPUAttr(AK).empty()); + for (AArch64::ArchKind AK = static_cast(0); + AK <= AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_TRUE((AK == AArch64::AAK_INVALID || AK == AArch64::AAK_LAST) + ? AArch64::getCPUAttr(AK).empty() + : !AArch64::getCPUAttr(AK).empty()); } TEST(TargetParserTest, AArch64SubArch) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE(contains(kAArch64ArchKinds, static_cast(AK)) - ? !AArch64::getSubArch(AK).empty() - : AArch64::getSubArch(AK).empty()); + for (AArch64::ArchKind AK = static_cast(0); + AK <= AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_TRUE((AK == AArch64::AAK_INVALID || AK == AArch64::AAK_LAST) + ? AArch64::getSubArch(AK).empty() + : !AArch64::getSubArch(AK).empty()); +} + +TEST(TargetParserTest, AArch64ArchAttr) { + for (AArch64::ArchKind AK = static_cast(0); + AK <= AArch64::ArchKind::AAK_LAST; + AK = static_cast(static_cast(AK) + 1)) + EXPECT_TRUE(AK == AArch64::AAK_LAST + ? (ARMBuildAttrs::CPUArch::v8_A == AArch64::getArchAttr(AK)) + : (kAArch64ARCHNames[AK].ArchAttr == AArch64::getArchAttr(AK))); +} + +TEST(TargetParserTest, AArch64ArchExtName) { + for (AArch64::ArchExtKind AEK = static_cast(0); + AEK <= AArch64::ArchExtKind::AEK_RAS; + AEK = static_cast(static_cast(AEK) + 1)) + EXPECT_TRUE(contains(kAArch64ArchExtKinds, static_cast(AEK)) + ? !AArch64::getArchExtName(AEK).empty() + : AArch64::getArchExtName(AEK).empty()); +} + +TEST(TargetParserTest, AArch64ArchExtFeature) { + const char *ArchExt[][4] = { + { "crc", "nocrc", "+crc", "-crc"}, + { "crypto", "nocrypto", "+crypto", "-crypto"}, + { "fp", "nofp", "+fp-armv8", "-fp-armv8"}, + { "simd", "nosimd", "+neon", "-neon"}, + { "fp16", "nofp16", "+fullfp16", "-fullfp16"}, + { "profile", "noprofile", "+spe", "-spe"}, + { "ras", "noras", "+ras", "-ras"} + }; + + for (unsigned i = 0; i < array_lengthof(ArchExt); i++) { + EXPECT_EQ(ArchExt[i][2], AArch64::getArchExtFeature(ArchExt[i][0])); + EXPECT_EQ(ArchExt[i][3], AArch64::getArchExtFeature(ArchExt[i][1])); + } +} + +TEST(TargetParserTest, AArch64DefaultCPU) { + const char *Arch[] = {"armv8a", "armv8-a", "armv8", + "armv8.1a", "armv8.1-a", + "armv8.2a", "armv8.2-a"}; + + for (unsigned i = 0; i < array_lengthof(Arch); i++) + EXPECT_FALSE(AArch64::getDefaultCPU(Arch[i]).empty()); +} + +TEST(TargetParserTest, AArch64parseArch) { + const char *Arch[] = {"armv8", "armv8a", "armv8-a", + "armv8.1a", "armv8.1-a", + "armv8.2a", "armv8.2-a" + }; + + for (unsigned i = 0; i < array_lengthof(Arch); i++) + EXPECT_NE(AArch64::AAK_INVALID, AArch64::parseArch(Arch[i])); + EXPECT_EQ(AArch64::AAK_INVALID, AArch64::parseArch("aarch64")); + EXPECT_EQ(AArch64::AAK_INVALID, AArch64::parseArch("arm64")); +} + +TEST(TargetParserTest, AArch64parseArchExt) { + const char *const ArchExt[] = { "none", "crc", "crypto", "fp", + "simd", "fp16", "profile", "ras" + }; + + for (unsigned i = 0; i < array_lengthof(kAArch64ARCHExtNames); i++) + EXPECT_TRUE(contains(ArchExt, kAArch64ARCHExtNames[i].Name) + ? (AArch64::AEK_INVALID != + AArch64::parseArchExt(kAArch64ARCHExtNames[i].Name)) + : (AArch64::AEK_INVALID == + AArch64::parseArchExt(kAArch64ARCHExtNames[i].Name))); +} + +TEST(TargetParserTest, AArch64parseCPUArch) { + const char *const CPU[] = { "cortex-a35", "cortex-a53", "cortex-a57", + "cortex-a72", "cortex-a73", "cyclone", + "exynos-m1", "kryo", "vulcan" + }; + + for (unsigned i = 0; i < array_lengthof(kAArch64CPUNames); i++) + EXPECT_TRUE(contains(CPU, kAArch64CPUNames[i].Name) + ? (AArch64::AAK_INVALID != + AArch64::parseCPUArch(kAArch64CPUNames[i].Name)) + : (AArch64::AAK_INVALID == + AArch64::parseCPUArch(kAArch64CPUNames[i].Name))); } }