diff --git a/unittests/Support/TargetParserTest.cpp b/unittests/Support/TargetParserTest.cpp index 8040be0955d..c84313a8747 100644 --- a/unittests/Support/TargetParserTest.cpp +++ b/unittests/Support/TargetParserTest.cpp @@ -16,111 +16,397 @@ using namespace llvm; namespace { -static const unsigned kAArch64ArchExtKinds[] = { -#define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) ID, -#include "llvm/Support/AArch64TargetParser.def" -#undef AARCH64_ARCH_EXT_NAME -}; - -template struct ArchNames { - const char *Name; - unsigned DefaultFPU; - unsigned ArchBaseExtensions; - T ID; - ARMBuildAttrs::CPUArch ArchAttr; -}; -ArchNames kAArch64ARCHNames[] = { -#define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, \ - ARCH_BASE_EXT) \ - {NAME, ARM::ARCH_FPU, ARCH_BASE_EXT, AArch64::ArchKind::ID, ARCH_ATTR}, -#include "llvm/Support/AArch64TargetParser.def" -#undef AARCH64_ARCH -}; -ArchNames kARMARCHNames[] = { -#define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, \ - ARCH_BASE_EXT) \ - {NAME, ARM::ARCH_FPU, ARCH_BASE_EXT, ARM::ID, ARCH_ATTR}, -#include "llvm/Support/ARMTargetParser.def" -#undef ARM_ARCH -}; - -template struct CpuNames { - const char *Name; - T ID; - unsigned DefaultFPU; - unsigned DefaultExt; -}; -CpuNames kAArch64CPUNames[] = { -#define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \ - {NAME, AArch64::ArchKind::ID, ARM::DEFAULT_FPU, DEFAULT_EXT}, -#include "llvm/Support/AArch64TargetParser.def" -#undef AARCH64_CPU_NAME -}; -CpuNames kARMCPUNames[] = { -#define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \ - {NAME, ARM::ID, ARM::DEFAULT_FPU, DEFAULT_EXT}, -#include "llvm/Support/ARMTargetParser.def" -#undef ARM_CPU_NAME -}; - const char *ARMArch[] = { - "armv2", "armv2a", "armv3", "armv3m", "armv4", - "armv4t", "armv5", "armv5t", "armv5e", "armv5te", - "armv5tej", "armv6", "armv6j", "armv6k", "armv6hl", - "armv6t2", "armv6kz", "armv6z", "armv6zk", "armv6-m", - "armv6m", "armv6sm", "armv6s-m", "armv7-a", "armv7", - "armv7a", "armv7hl", "armv7l", "armv7-r", "armv7r", - "armv7-m", "armv7m", "armv7k", "armv7s", "armv7e-m", - "armv7em", "armv8-a", "armv8", "armv8a", "armv8.1-a", - "armv8.1a", "armv8.2-a", "armv8.2a", "armv8-m.base", "armv8m.base", - "armv8-m.main", "armv8m.main", "iwmmxt", "iwmmxt2", "xscale"}; + "armv2", "armv2a", "armv3", "armv3m", "armv4", + "armv4t", "armv5", "armv5t", "armv5e", "armv5te", + "armv5tej", "armv6", "armv6j", "armv6k", "armv6hl", + "armv6t2", "armv6kz", "armv6z", "armv6zk", "armv6-m", + "armv6m", "armv6sm", "armv6s-m", "armv7-a", "armv7", + "armv7a", "armv7hl", "armv7l", "armv7-r", "armv7r", + "armv7-m", "armv7m", "armv7k", "armv7s", "armv7e-m", + "armv7em", "armv8-a", "armv8", "armv8a", "armv8.1-a", + "armv8.1a", "armv8.2-a", "armv8.2a", "armv8-r", "armv8r", + "armv8-m.base", "armv8m.base", "armv8-m.main", "armv8m.main", "iwmmxt", + "iwmmxt2", "xscale"}; -template -bool contains(const T (&array)[N], const T element) { - return std::find(std::begin(array), std::end(array), element) != - std::end(array); +bool testARMCPU(StringRef CPUName, StringRef ExpectedArch, + StringRef ExpectedFPU, unsigned ExpectedFlags, + StringRef CPUAttr) { + unsigned ArchKind = ARM::parseCPUArch(CPUName); + bool pass = ARM::getArchName(ArchKind).equals(ExpectedArch); + unsigned FPUKind = ARM::getDefaultFPU(CPUName, ArchKind); + pass &= ARM::getFPUName(FPUKind).equals(ExpectedFPU); + + unsigned ExtKind = ARM::getDefaultExtensions(CPUName, ArchKind); + if (ExtKind > 1 && (ExtKind & ARM::AEK_NONE)) + pass &= ((ExtKind ^ ARM::AEK_NONE) == ExpectedFlags); + else + pass &= (ExtKind == ExpectedFlags); + + pass &= ARM::getCPUAttr(ArchKind).equals(CPUAttr); + + return pass; } -template -bool contains(const char *(&array)[N], const char *element) { - return std::find_if(std::begin(array), std::end(array), [&](const char *S) { - return ::strcmp(S, element) == 0; - }) != std::end(array); +TEST(TargetParserTest, testARMCPU) { + EXPECT_TRUE(testARMCPU("invalid", "invalid", "invalid", + ARM::AEK_NONE, "")); + EXPECT_TRUE(testARMCPU("generic", "invalid", "none", + ARM::AEK_NONE, "")); + + EXPECT_TRUE(testARMCPU("arm2", "armv2", "none", + ARM::AEK_NONE, "2")); + EXPECT_TRUE(testARMCPU("arm3", "armv2a", "none", + ARM::AEK_NONE, "2A")); + EXPECT_TRUE(testARMCPU("arm6", "armv3", "none", + ARM::AEK_NONE, "3")); + EXPECT_TRUE(testARMCPU("arm7m", "armv3m", "none", + ARM::AEK_NONE, "3M")); + EXPECT_TRUE(testARMCPU("arm8", "armv4", "none", + ARM::AEK_NONE, "4")); + EXPECT_TRUE(testARMCPU("arm810", "armv4", "none", + ARM::AEK_NONE, "4")); + EXPECT_TRUE(testARMCPU("strongarm", "armv4", "none", + ARM::AEK_NONE, "4")); + EXPECT_TRUE(testARMCPU("strongarm110", "armv4", "none", + ARM::AEK_NONE, "4")); + EXPECT_TRUE(testARMCPU("strongarm1100", "armv4", "none", + ARM::AEK_NONE, "4")); + EXPECT_TRUE(testARMCPU("strongarm1110", "armv4", "none", + ARM::AEK_NONE, "4")); + EXPECT_TRUE(testARMCPU("arm7tdmi", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm7tdmi-s", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm710t", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm720t", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm9", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm9tdmi", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm920", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm920t", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm922t", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm9312", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm940t", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("ep9312", "armv4t", "none", + ARM::AEK_NONE, "4T")); + EXPECT_TRUE(testARMCPU("arm10tdmi", "armv5t", "none", + ARM::AEK_NONE, "5T")); + EXPECT_TRUE(testARMCPU("arm1020t", "armv5t", "none", + ARM::AEK_NONE, "5T")); + EXPECT_TRUE(testARMCPU("arm9e", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm946e-s", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm966e-s", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm968e-s", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm10e", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm1020e", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm1022e", "armv5te", "none", + ARM::AEK_DSP, "5TE")); + EXPECT_TRUE(testARMCPU("arm926ej-s", "armv5tej", "none", + ARM::AEK_DSP, "5TEJ")); + EXPECT_TRUE(testARMCPU("arm1136j-s", "armv6", "none", + ARM::AEK_DSP, "6")); + EXPECT_TRUE(testARMCPU("arm1136jf-s", "armv6", "vfpv2", + ARM::AEK_DSP, "6")); + EXPECT_TRUE(testARMCPU("arm1136jz-s", "armv6", "none", + ARM::AEK_DSP, "6")); + EXPECT_TRUE(testARMCPU("arm1176j-s", "armv6k", "none", + ARM::AEK_DSP, "6K")); + EXPECT_TRUE(testARMCPU("arm1176jz-s", "armv6kz", "none", + ARM::AEK_SEC | ARM::AEK_DSP, "6KZ")); + EXPECT_TRUE(testARMCPU("mpcore", "armv6k", "vfpv2", + ARM::AEK_DSP, "6K")); + EXPECT_TRUE(testARMCPU("mpcorenovfp", "armv6k", "none", + ARM::AEK_DSP, "6K")); + EXPECT_TRUE(testARMCPU("arm1176jzf-s", "armv6kz", "vfpv2", + ARM::AEK_SEC | ARM::AEK_DSP, "6KZ")); + EXPECT_TRUE(testARMCPU("arm1156t2-s", "armv6t2", "none", + ARM::AEK_DSP, "6T2")); + EXPECT_TRUE(testARMCPU("arm1156t2f-s", "armv6t2", "vfpv2", + ARM::AEK_DSP, "6T2")); + EXPECT_TRUE(testARMCPU("cortex-m0", "armv6-m", "none", + ARM::AEK_NONE, "6-M")); + EXPECT_TRUE(testARMCPU("cortex-m0plus", "armv6-m", "none", + ARM::AEK_NONE, "6-M")); + EXPECT_TRUE(testARMCPU("cortex-m1", "armv6-m", "none", + ARM::AEK_NONE, "6-M")); + EXPECT_TRUE(testARMCPU("sc000", "armv6-m", "none", + ARM::AEK_NONE, "6-M")); + EXPECT_TRUE(testARMCPU("cortex-a5", "armv7-a", "neon-vfpv4", + ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A")); + EXPECT_TRUE(testARMCPU("cortex-a7", "armv7-a", "neon-vfpv4", + ARM::AEK_HWDIV | ARM::AEK_HWDIVARM | ARM::AEK_MP | + ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP, + "7-A")); + EXPECT_TRUE(testARMCPU("cortex-a8", "armv7-a", "neon", + ARM::AEK_SEC | ARM::AEK_DSP, "7-A")); + EXPECT_TRUE(testARMCPU("cortex-a9", "armv7-a", "neon-fp16", + ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A")); + EXPECT_TRUE(testARMCPU("cortex-a12", "armv7-a", "neon-vfpv4", + ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | + ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP, + "7-A")); + EXPECT_TRUE(testARMCPU("cortex-a15", "armv7-a", "neon-vfpv4", + ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | + ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP, + "7-A")); + EXPECT_TRUE(testARMCPU("cortex-a17", "armv7-a", "neon-vfpv4", + ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | + ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP, + "7-A")); + EXPECT_TRUE(testARMCPU("krait", "armv7-a", "neon-vfpv4", + ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP, + "7-A")); + EXPECT_TRUE(testARMCPU("cortex-r4", "armv7-r", "none", + ARM::AEK_HWDIV | ARM::AEK_DSP, "7-R")); + EXPECT_TRUE(testARMCPU("cortex-r4f", "armv7-r", "vfpv3-d16", + ARM::AEK_HWDIV | ARM::AEK_DSP, "7-R")); + EXPECT_TRUE(testARMCPU("cortex-r5", "armv7-r", "vfpv3-d16", + ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | + ARM::AEK_DSP, "7-R")); + EXPECT_TRUE(testARMCPU("cortex-r7", "armv7-r", "vfpv3-d16-fp16", + ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | + ARM::AEK_DSP, "7-R")); + EXPECT_TRUE(testARMCPU("cortex-r8", "armv7-r", "vfpv3-d16-fp16", + ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | + ARM::AEK_DSP, "7-R")); + EXPECT_TRUE(testARMCPU("cortex-r52", "armv8-r", "neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_MP | ARM::AEK_VIRT | + ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-R")); + EXPECT_TRUE(testARMCPU("sc300", "armv7-m", "none", + ARM::AEK_HWDIV, "7-M")); + EXPECT_TRUE(testARMCPU("cortex-m3", "armv7-m", "none", + ARM::AEK_HWDIV, "7-M")); + EXPECT_TRUE(testARMCPU("cortex-m4", "armv7e-m", "fpv4-sp-d16", + ARM::AEK_HWDIV | ARM::AEK_DSP, "7E-M")); + EXPECT_TRUE(testARMCPU("cortex-m7", "armv7e-m", "fpv5-d16", + ARM::AEK_HWDIV | ARM::AEK_DSP, "7E-M")); + EXPECT_TRUE(testARMCPU("cortex-a32", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("cortex-a35", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("cortex-a53", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("cortex-a57", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("cortex-a72", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("cortex-a73", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("cyclone", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("exynos-m1", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("exynos-m2", "armv8-a", "crypto-neon-fp-armv8", + ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | + ARM::AEK_VIRT | ARM::AEK_HWDIVARM | + ARM::AEK_HWDIV | ARM::AEK_DSP, + "8-A")); + EXPECT_TRUE(testARMCPU("iwmmxt", "iwmmxt", "none", + ARM::AEK_NONE, "iwmmxt")); + EXPECT_TRUE(testARMCPU("xscale", "xscale", "none", + ARM::AEK_NONE, "xscale")); + EXPECT_TRUE(testARMCPU("swift", "armv7s", "neon-vfpv4", + ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP, + "7-S")); } -TEST(TargetParserTest, ARMArchName) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE(AK == ARM::AK_LAST ? ARM::getArchName(AK).empty() - : !ARM::getArchName(AK).empty()); +bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch, + unsigned ArchAttr) { + unsigned ArchKind = ARM::parseArch(Arch); + return (ArchKind != ARM::AK_INVALID) & + ARM::getDefaultCPU(Arch).equals(DefaultCPU) & + ARM::getSubArch(ArchKind).equals(SubArch) & + (ARM::getArchAttr(ArchKind) == ArchAttr); } -TEST(TargetParserTest, ARMCPUAttr) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE((AK == ARM::AK_INVALID || AK == ARM::AK_LAST) - ? ARM::getCPUAttr(AK).empty() - : !ARM::getCPUAttr(AK).empty()); +TEST(TargetParserTest, testARMArch) { + EXPECT_TRUE( + testARMArch("armv2", "arm2", "v2", + ARMBuildAttrs::CPUArch::Pre_v4)); + EXPECT_TRUE( + testARMArch("armv2a", "arm3", "v2a", + ARMBuildAttrs::CPUArch::Pre_v4)); + EXPECT_TRUE( + testARMArch("armv3", "arm6", "v3", + ARMBuildAttrs::CPUArch::Pre_v4)); + EXPECT_TRUE( + testARMArch("armv3m", "arm7m", "v3m", + ARMBuildAttrs::CPUArch::Pre_v4)); + EXPECT_TRUE( + testARMArch("armv4", "strongarm", "v4", + ARMBuildAttrs::CPUArch::v4)); + EXPECT_TRUE( + testARMArch("armv4t", "arm7tdmi", "v4t", + ARMBuildAttrs::CPUArch::v4T)); + EXPECT_TRUE( + testARMArch("armv5t", "arm10tdmi", "v5", + ARMBuildAttrs::CPUArch::v5T)); + EXPECT_TRUE( + testARMArch("armv5te", "arm1022e", "v5e", + ARMBuildAttrs::CPUArch::v5TE)); + EXPECT_TRUE( + testARMArch("armv5tej", "arm926ej-s", "v5e", + ARMBuildAttrs::CPUArch::v5TEJ)); + EXPECT_TRUE( + testARMArch("armv6", "arm1136jf-s", "v6", + ARMBuildAttrs::CPUArch::v6)); + EXPECT_TRUE( + testARMArch("armv6k", "arm1176j-s", "v6k", + ARMBuildAttrs::CPUArch::v6K)); + EXPECT_TRUE( + testARMArch("armv6t2", "arm1156t2-s", "v6t2", + ARMBuildAttrs::CPUArch::v6T2)); + EXPECT_TRUE( + testARMArch("armv6kz", "arm1176jzf-s", "v6kz", + ARMBuildAttrs::CPUArch::v6KZ)); + EXPECT_TRUE( + testARMArch("armv6-m", "cortex-m0", "v6m", + ARMBuildAttrs::CPUArch::v6_M)); + EXPECT_TRUE( + testARMArch("armv7-a", "cortex-a8", "v7", + ARMBuildAttrs::CPUArch::v7)); + EXPECT_TRUE( + testARMArch("armv7-r", "cortex-r4", "v7r", + ARMBuildAttrs::CPUArch::v7)); + EXPECT_TRUE( + testARMArch("armv7-m", "cortex-m3", "v7m", + ARMBuildAttrs::CPUArch::v7)); + EXPECT_TRUE( + testARMArch("armv7e-m", "cortex-m4", "v7em", + ARMBuildAttrs::CPUArch::v7E_M)); + EXPECT_TRUE( + testARMArch("armv8-a", "cortex-a53", "v8", + ARMBuildAttrs::CPUArch::v8_A)); + EXPECT_TRUE( + testARMArch("armv8.1-a", "generic", "v8.1a", + ARMBuildAttrs::CPUArch::v8_A)); + EXPECT_TRUE( + testARMArch("armv8.2-a", "generic", "v8.2a", + ARMBuildAttrs::CPUArch::v8_A)); + EXPECT_TRUE( + testARMArch("armv8-r", "cortex-r52", "v8r", + ARMBuildAttrs::CPUArch::v8_R)); + EXPECT_TRUE( + testARMArch("armv8-m.base", "generic", "v8m.base", + ARMBuildAttrs::CPUArch::v8_M_Base)); + EXPECT_TRUE( + testARMArch("armv8-m.main", "generic", "v8m.main", + ARMBuildAttrs::CPUArch::v8_M_Main)); + EXPECT_TRUE( + testARMArch("iwmmxt", "iwmmxt", "", + ARMBuildAttrs::CPUArch::v5TE)); + EXPECT_TRUE( + testARMArch("iwmmxt2", "generic", "", + ARMBuildAttrs::CPUArch::v5TE)); + EXPECT_TRUE( + testARMArch("xscale", "xscale", "v5e", + ARMBuildAttrs::CPUArch::v5TE)); + EXPECT_TRUE( + testARMArch("armv7s", "swift", "v7s", + ARMBuildAttrs::CPUArch::v7)); + EXPECT_TRUE( + testARMArch("armv7k", "generic", "v7k", + ARMBuildAttrs::CPUArch::v7)); } -TEST(TargetParserTest, ARMSubArch) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE((AK == ARM::AK_INVALID || AK == ARM::AK_IWMMXT || - AK == ARM::AK_IWMMXT2 || AK == ARM::AK_LAST) - ? ARM::getSubArch(AK).empty() - : !ARM::getSubArch(AK).empty()); +bool testARMExtension(StringRef CPUName, unsigned ArchKind, StringRef ArchExt) { + return ARM::getDefaultExtensions(CPUName, ArchKind) & + ARM::parseArchExt(ArchExt); } -TEST(TargetParserTest, ARMFPUName) { - for (ARM::FPUKind FK = static_cast(0); - FK <= ARM::FPUKind::FK_LAST; - FK = static_cast(static_cast(FK) + 1)) - EXPECT_TRUE(FK == ARM::FK_LAST ? ARM::getFPUName(FK).empty() - : !ARM::getFPUName(FK).empty()); +TEST(TargetParserTest, testARMExtension) { + EXPECT_FALSE(testARMExtension("arm2", 0, "thumb")); + EXPECT_FALSE(testARMExtension("arm3", 0, "thumb")); + EXPECT_FALSE(testARMExtension("arm6", 0, "thumb")); + EXPECT_FALSE(testARMExtension("arm7m", 0, "thumb")); + EXPECT_FALSE(testARMExtension("strongarm", 0, "dsp")); + EXPECT_FALSE(testARMExtension("arm7tdmi", 0, "dsp")); + EXPECT_FALSE(testARMExtension("arm10tdmi", 0, "simd")); + EXPECT_FALSE(testARMExtension("arm1022e", 0, "simd")); + EXPECT_FALSE(testARMExtension("arm926ej-s", 0, "simd")); + EXPECT_FALSE(testARMExtension("arm1136jf-s", 0, "crypto")); + EXPECT_FALSE(testARMExtension("arm1176j-s", 0, "crypto")); + EXPECT_FALSE(testARMExtension("arm1156t2-s", 0, "crypto")); + EXPECT_FALSE(testARMExtension("arm1176jzf-s", 0, "crypto")); + EXPECT_FALSE(testARMExtension("cortex-m0", 0, "crypto")); + EXPECT_FALSE(testARMExtension("cortex-a8", 0, "crypto")); + EXPECT_FALSE(testARMExtension("cortex-r4", 0, "crypto")); + EXPECT_FALSE(testARMExtension("cortex-m3", 0, "crypto")); + EXPECT_FALSE(testARMExtension("cortex-a53", 0, "ras")); + EXPECT_FALSE(testARMExtension("cortex-r52", 0, "ras")); + EXPECT_FALSE(testARMExtension("iwmmxt", 0, "crc")); + EXPECT_FALSE(testARMExtension("xscale", 0, "crc")); + EXPECT_FALSE(testARMExtension("swift", 0, "crc")); + + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2, "thumb")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2A, "thumb")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3, "thumb")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3M, "thumb")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4, "dsp")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4T, "dsp")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5T, "simd")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TE, "simd")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TEJ, "simd")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6K, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6T2, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6KZ, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6M, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7A, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7R, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7M, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7EM, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8A, "ras")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_1A, "ras")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_2A, "spe")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8R, "ras")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MBaseline, "crc")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MMainline, "crc")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT, "crc")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT2, "crc")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_XSCALE, "crc")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7S, "crypto")); + EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7K, "crypto")); } TEST(TargetParserTest, ARMFPUVersion) { @@ -153,31 +439,6 @@ TEST(TargetParserTest, ARMFPURestriction) { EXPECT_LE(0U, ARM::getFPURestriction(FK)); } -TEST(TargetParserTest, ARMDefaultFPU) { - for (ARM::ArchKind AK = static_cast(0); - AK < ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_EQ(kARMARCHNames[AK].DefaultFPU, - ARM::getDefaultFPU(StringRef("generic"), AK)); - - for (const auto &ARMCPUName : kARMCPUNames) - EXPECT_EQ(ARMCPUName.DefaultFPU, ARM::getDefaultFPU(ARMCPUName.Name, 0)); -} - -TEST(TargetParserTest, ARMDefaultExtensions) { - for (ARM::ArchKind AK = static_cast(0); - AK < ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_EQ(kARMARCHNames[AK].ArchBaseExtensions, - ARM::getDefaultExtensions(StringRef("generic"), AK)); - - for (const auto &ARMCPUName : kARMCPUNames) { - unsigned DefaultExt = - kARMARCHNames[ARMCPUName.ID].ArchBaseExtensions | ARMCPUName.DefaultExt; - EXPECT_EQ(DefaultExt, ARM::getDefaultExtensions(ARMCPUName.Name, 0)); - } -} - TEST(TargetParserTest, ARMExtensionFeatures) { std::vector Features; unsigned Extensions = ARM::AEK_CRC | ARM::AEK_CRYPTO | ARM::AEK_DSP | @@ -199,15 +460,6 @@ TEST(TargetParserTest, ARMFPUFeatures) { : ARM::getFPUFeatures(FK, Features)); } -TEST(TargetParserTest, ARMArchAttr) { - for (ARM::ArchKind AK = static_cast(0); - AK <= ARM::ArchKind::AK_LAST; - AK = static_cast(static_cast(AK) + 1)) - EXPECT_TRUE(AK == ARM::AK_LAST - ? (ARMBuildAttrs::CPUArch::Pre_v4 == ARM::getArchAttr(AK)) - : (kARMARCHNames[AK].ArchAttr == ARM::getArchAttr(AK))); -} - TEST(TargetParserTest, ARMArchExtFeature) { const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"}, {"crypto", "nocrypto", "+crypto", "-crypto"}, @@ -232,11 +484,6 @@ TEST(TargetParserTest, ARMArchExtFeature) { } } -TEST(TargetParserTest, ARMDefaultCPU) { - for (unsigned i = 0; i < array_lengthof(ARMArch); i++) - EXPECT_FALSE(ARM::getDefaultCPU(ARMArch[i]).empty()); -} - TEST(TargetParserTest, ARMparseHWDiv) { const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"}; @@ -244,90 +491,6 @@ TEST(TargetParserTest, ARMparseHWDiv) { EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i])); } -TEST(TargetParserTest, ARMparseFPU) { - const char *FPU[] = {"vfp", - "vfpv2", - "vfp2", - "vfpv3", - "vfp3", - "vfpv3-fp16", - "vfpv3-d16", - "vfp3-d16", - "vfpv3-d16-fp16", - "vfpv3xd", - "vfpv3xd-fp16", - "vfpv4", - "vfp4", - "vfpv4-d16", - "vfp4-d16", - "fp4-dp-d16", - "fpv4-dp-d16", - "fpv4-sp-d16", - "fp4-sp-d16", - "vfpv4-sp-d16", - "fpv5-d16", - "fp5-dp-d16", - "fpv5-dp-d16", - "fpv5-sp-d16", - "fp5-sp-d16", - "fp-armv8", - "neon", - "neon-vfpv3", - "neon-fp16", - "neon-vfpv4", - "neon-fp-armv8", - "crypto-neon-fp-armv8", - "softvfp"}; - - for (unsigned i = 0; i < array_lengthof(FPU); i++) - EXPECT_NE(ARM::FK_INVALID, ARM::parseFPU((StringRef)FPU[i])); -} - -TEST(TargetParserTest, ARMparseArch) { - for (unsigned i = 0; i < array_lengthof(ARMArch); i++) - EXPECT_NE(ARM::AEK_INVALID, ARM::parseArch(ARMArch[i])); -} - -TEST(TargetParserTest, ARMparseArchExt) { - const char *ArchExt[] = {"none", "crc", "crypto", "dsp", "fp", - "idiv", "mp", "simd", "sec", "virt", - "fp16", "ras", "os", "iwmmxt", "iwmmxt2", - "maverick", "xscale"}; - - for (unsigned i = 0; i < array_lengthof(ArchExt); i++) - EXPECT_NE(ARM::AEK_INVALID, ARM::parseArchExt(ArchExt[i])); -} - -TEST(TargetParserTest, ARMparseCPUArch) { - const char *CPU[] = { - "arm2", "arm3", "arm6", "arm7m", - "arm8", "arm810", "strongarm", "strongarm110", - "strongarm1100", "strongarm1110", "arm7tdmi", "arm7tdmi-s", - "arm710t", "arm720t", "arm9", "arm9tdmi", - "arm920", "arm920t", "arm922t", "arm9312", - "arm940t", "ep9312", "arm10tdmi", "arm1020t", - "arm9e", "arm946e-s", "arm966e-s", "arm968e-s", - "arm10e", "arm1020e", "arm1022e", "arm926ej-s", - "arm1136j-s", "arm1136jf-s", "arm1136jz-s", "arm1176j-s", - "arm1176jz-s", "mpcore", "mpcorenovfp", "arm1176jzf-s", - "arm1156t2-s", "arm1156t2f-s", "cortex-m0", "cortex-m0plus", - "cortex-m1", "sc000", "cortex-a5", "cortex-a7", - "cortex-a8", "cortex-a9", "cortex-a12", "cortex-a15", - "cortex-a17", "krait", "cortex-r4", "cortex-r4f", - "cortex-r5", "cortex-r7", "cortex-r8", "sc300", - "cortex-m3", "cortex-m4", "cortex-m7", "cortex-a32", - "cortex-a35", "cortex-a53", "cortex-a57", "cortex-a72", - "cortex-a73", "cyclone", "exynos-m1", "exynos-m2", - "iwmmxt", "xscale", "swift", "cortex-r52"}; - - for (const auto &ARMCPUName : kARMCPUNames) { - if (contains(CPU, ARMCPUName.Name)) - EXPECT_NE(ARM::AK_INVALID, ARM::parseCPUArch(ARMCPUName.Name)); - else - EXPECT_EQ(ARM::AK_INVALID, ARM::parseCPUArch(ARMCPUName.Name)); - } -} - TEST(TargetParserTest, ARMparseArchEndianAndISA) { const char *Arch[] = { "v2", "v2a", "v3", "v3m", "v4", "v4t", "v5", "v5t", @@ -383,6 +546,7 @@ TEST(TargetParserTest, ARMparseArchProfile) { EXPECT_EQ(ARM::PK_M, ARM::parseArchProfile(ARMArch[i])); continue; case ARM::AK_ARMV7R: + case ARM::AK_ARMV8R: EXPECT_EQ(ARM::PK_R, ARM::parseArchProfile(ARMArch[i])); continue; case ARM::AK_ARMV7A: @@ -405,29 +569,109 @@ TEST(TargetParserTest, ARMparseArchVersion) { EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i])); } -TEST(TargetParserTest, AArch64DefaultFPU) { - for (unsigned AK = 0; AK < static_cast(AArch64::ArchKind::AK_LAST); - AK++) - EXPECT_EQ(kAArch64ARCHNames[AK].DefaultFPU, - AArch64::getDefaultFPU(StringRef("generic"), AK)); +bool testAArch64CPU(StringRef CPUName, StringRef ExpectedArch, + StringRef ExpectedFPU, unsigned ExpectedFlags, + StringRef CPUAttr) { + unsigned ArchKind = AArch64::parseCPUArch(CPUName); + bool pass = AArch64::getArchName(ArchKind).equals(ExpectedArch); + unsigned FPUKind = AArch64::getDefaultFPU(CPUName, ArchKind); + pass &= AArch64::getFPUName(FPUKind).equals(ExpectedFPU); - for (const auto &AArch64CPUName : kAArch64CPUNames) - EXPECT_EQ(AArch64CPUName.DefaultFPU, - AArch64::getDefaultFPU(AArch64CPUName.Name, - static_cast(AArch64CPUName.ID))); + unsigned ExtKind = AArch64::getDefaultExtensions(CPUName, ArchKind); + if (ExtKind > 1 && (ExtKind & AArch64::AEK_NONE)) + pass &= ((ExtKind ^ AArch64::AEK_NONE) == ExpectedFlags); + else + pass &= (ExtKind == ExpectedFlags); + + pass &= AArch64::getCPUAttr(ArchKind).equals(CPUAttr); + + return pass; } -TEST(TargetParserTest, AArch64DefaultExt) { - for (unsigned AK = 0; AK < static_cast(AArch64::ArchKind::AK_LAST); - AK++) - EXPECT_EQ(kAArch64ARCHNames[AK].ArchBaseExtensions, - AArch64::getDefaultExtensions(StringRef("generic"), AK)); +TEST(TargetParserTest, testAArch64CPU) { + EXPECT_TRUE(testAArch64CPU( + "invalid", "invalid", "invalid", + AArch64::AEK_INVALID, "")); + EXPECT_TRUE(testAArch64CPU( + "generic", "invalid", "none", + AArch64::AEK_NONE, "")); - for (const auto &AArch64CPUName : kAArch64CPUNames) - EXPECT_EQ( - AArch64CPUName.DefaultExt, - AArch64::getDefaultExtensions( - AArch64CPUName.Name, static_cast(AArch64CPUName.ID))); + EXPECT_TRUE(testAArch64CPU( + "cortex-a35", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "cortex-a53", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "cortex-a57", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "cortex-a72", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "cortex-a73", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "cyclone", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "exynos-m1", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "exynos-m2", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "falkor", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "kryo", "armv8-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A")); + EXPECT_TRUE(testAArch64CPU( + "vulcan", "armv8.1-a", "crypto-neon-fp-armv8", + AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8.1-A")); +} + +bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch, + unsigned ArchAttr) { + unsigned ArchKind = AArch64::parseArch(Arch); + return (ArchKind != static_cast(AArch64::ArchKind::AK_INVALID)) & + AArch64::getDefaultCPU(Arch).equals(DefaultCPU) & + AArch64::getSubArch(ArchKind).equals(SubArch) & + (AArch64::getArchAttr(ArchKind) == ArchAttr); +} + +TEST(TargetParserTest, testAArch64Arch) { + EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8", + ARMBuildAttrs::CPUArch::v8_A)); + EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a", + ARMBuildAttrs::CPUArch::v8_A)); + EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a", + ARMBuildAttrs::CPUArch::v8_A)); +} + +bool testAArch64Extension(StringRef CPUName, unsigned ArchKind, + StringRef ArchExt) { + return AArch64::getDefaultExtensions(CPUName, ArchKind) & + AArch64::parseArchExt(ArchExt); +} + +TEST(TargetParserTest, testAArch64Extension) { + EXPECT_FALSE(testAArch64Extension("cortex-a35", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("cortex-a53", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("cortex-a57", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("cortex-a72", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("cortex-a73", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("cyclone", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("exynos-m1", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("kryo", 0, "ras")); + EXPECT_FALSE(testAArch64Extension("vulcan", 0, "ras")); + + EXPECT_FALSE(testAArch64Extension( + "generic", static_cast(AArch64::ArchKind::AK_ARMV8A), "ras")); + EXPECT_FALSE(testAArch64Extension( + "generic", static_cast(AArch64::ArchKind::AK_ARMV8_1A), "ras")); + EXPECT_FALSE(testAArch64Extension( + "generic", static_cast(AArch64::ArchKind::AK_ARMV8_2A), "spe")); } TEST(TargetParserTest, AArch64ExtensionFeatures) { @@ -453,50 +697,6 @@ TEST(TargetParserTest, AArch64ArchFeatures) { : AArch64::getArchFeatures(AK, Features)); } -TEST(TargetParserTest, AArch64ArchName) { - for (unsigned AK = 0; AK < static_cast(AArch64::ArchKind::AK_LAST); - AK++) - EXPECT_TRUE(AK == static_cast(AArch64::ArchKind::AK_LAST) - ? AArch64::getArchName(AK).empty() - : !AArch64::getArchName(AK).empty()); -} - -TEST(TargetParserTest, AArch64CPUAttr) { - for (unsigned AK = 0; AK < static_cast(AArch64::ArchKind::AK_LAST); - AK++) - EXPECT_TRUE((AK == static_cast(AArch64::ArchKind::AK_INVALID) || - AK == static_cast(AArch64::ArchKind::AK_LAST)) - ? AArch64::getCPUAttr(AK).empty() - : !AArch64::getCPUAttr(AK).empty()); -} - -TEST(TargetParserTest, AArch64SubArch) { - for (unsigned AK = 0; AK < static_cast(AArch64::ArchKind::AK_LAST); - AK++) - EXPECT_TRUE((AK == static_cast(AArch64::ArchKind::AK_INVALID) || - AK == static_cast(AArch64::ArchKind::AK_LAST)) - ? AArch64::getSubArch(AK).empty() - : !AArch64::getSubArch(AK).empty()); -} - -TEST(TargetParserTest, AArch64ArchAttr) { - for (unsigned AK = 0; AK < static_cast(AArch64::ArchKind::AK_LAST); - AK++) - EXPECT_TRUE( - AK == static_cast(AArch64::ArchKind::AK_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"}, @@ -507,58 +707,10 @@ TEST(TargetParserTest, AArch64ArchExtFeature) { {"ras", "noras", "+ras", "-ras"}}; for (unsigned i = 0; i < array_lengthof(ArchExt); i++) { - EXPECT_EQ(StringRef(ArchExt[i][2]), AArch64::getArchExtFeature(ArchExt[i][0])); - EXPECT_EQ(StringRef(ArchExt[i][3]), AArch64::getArchExtFeature(ArchExt[i][1])); + EXPECT_EQ(StringRef(ArchExt[i][2]), + AArch64::getArchExtFeature(ArchExt[i][0])); + EXPECT_EQ(StringRef(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(static_cast(AArch64::ArchKind::AK_INVALID), - AArch64::parseArch(Arch[i])); - EXPECT_EQ(static_cast(AArch64::ArchKind::AK_INVALID), - AArch64::parseArch("aarch64")); - EXPECT_EQ(static_cast(AArch64::ArchKind::AK_INVALID), - AArch64::parseArch("arm64")); -} - -TEST(TargetParserTest, AArch64parseArchExt) { - const char *ArchExt[] = {"none", "crc", "crypto", "fp", - "simd", "fp16", "profile", "ras"}; - - for (unsigned i = 0; i < array_lengthof(ArchExt); i++) - EXPECT_NE(AArch64::AEK_INVALID, AArch64::parseArchExt(ArchExt[i])); -} - -TEST(TargetParserTest, AArch64parseCPUArch) { - const char *CPU[] = {"cortex-a35", - "cortex-a53", - "cortex-a57", - "cortex-a72", - "cortex-a73", - "cyclone", - "exynos-m1", - "exynos-m2", - "falkor", - "kryo", - "vulcan"}; - - for (const auto &AArch64CPUName : kAArch64CPUNames) - EXPECT_TRUE(contains(CPU, AArch64CPUName.Name) - ? (static_cast(AArch64::ArchKind::AK_INVALID) != - AArch64::parseCPUArch(AArch64CPUName.Name)) - : (static_cast(AArch64::ArchKind::AK_INVALID) == - AArch64::parseCPUArch(AArch64CPUName.Name))); -} }