[AArch64][ARM][Clang] PerfMon Extension Added

[mubashar_]

Summary

Performance monitor architecture extension has been added to clang.

[lenary]

I'm happy with this patch, but you could update the description to be clearer that you're adding an option to allow PMU v3.4 to be enabled/disabled separately to the architecture - not adding the pmu extension itself.

[dmgreen]

Hmm. This appears to be mapping pmuv3p4 to "perfmon". But "perfmon" has been around a long time, not a new feature related to the pmuv3p4 update. It seems on the AArch64 side to control access to PMCCNTR, i.e. access to the base FEAT_PMUv3.

On the Arm side this is altering how HasV7Ops is define in https://github.com/llvm/llvm-project/blob/main/llvm/lib/Target/ARM/ARM.td#L515, which in turn is breaking Cortex-M cpus. It's probably a bug that HasV7Ops includes FeaturePerfMon, it shouldn't be included in HasV8MMainlineOps or ARMv7m if it's reading a system register with an mrc.

[mubashar_]

The command line option for Clang is now +pmuv3 to enable PerfMon.

[dmgreen]

LGTM. Thanks for the update.

llvm/include/llvm/Support/AArch64TargetParser.def

147

The formatting is a little off, for the subsequent columns.

clang/test/Driver/aarch64-perfmon.c

+// RUN: %clang -### -target aarch64-none-none-eabi -march=armv8.4a+pmuv3 %s 2>&1 | FileCheck --check-prefix=CHECK-PERFMON %s
+// RUN: %clang -### -target aarch64-none-none-eabi -march=armv8.2a+pmuv3 %s 2>&1 | FileCheck --check-prefix=CHECK-PERFMON %s
+// CHECK-PERFMON: "-target-feature" "+perfmon"
+
+// RUN: %clang -### -target aarch64-none-none-eabi -march=armv8.4a+nopmuv3 %s 2>&1 | FileCheck --check-prefix=CHECK-NOPERFMON %s
+// RUN: %clang -### -target aarch64-none-none-eabi -march=armv8.2a+nopmuv3 %s 2>&1 | FileCheck --check-prefix=CHECK-NOPERFMON %s
+// CHECK-NOPERFMON: "-target-feature" "-perfmon"
+
+// RUN: %clang -### -target aarch64-none-none-eabi                 %s 2>&1 | FileCheck %s --check-prefix=ABSENTPERFMON
+// RUN: %clang -### -target aarch64-none-none-eabi -march=armv8.4a %s 2>&1 | FileCheck %s --check-prefix=ABSENTPERFMON
+// RUN: %clang -### -target aarch64-none-none-eabi -march=armv8.2a %s 2>&1 | FileCheck %s --check-prefix=ABSENTPERFMON
+// ABSENTPERFMON-NOT: "-target-feature" "+perfmon"
+// ABSENTPERFMON-NOT: "-target-feature" "-perfmon"
 No newline at end of file

llvm/include/llvm/Support/AArch64TargetParser.h

enum ArchExtKind : uint64_t {
   AEK_F64MM =       1ULL << 32,
   AEK_LS64 =        1ULL << 33,
   AEK_BRBE =        1ULL << 34,
   AEK_PAUTH =       1ULL << 35,
   AEK_FLAGM =       1ULL << 36,
   AEK_SME =         1ULL << 37,
   AEK_SMEF64 =      1ULL << 38,
   AEK_SMEI64 =      1ULL << 39,
+  AEK_PERFMON =     1ULL << 40,
 };
 
 enum class ArchKind {
 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
 #include "AArch64TargetParser.def"
 };
 
 const ARM::ArchNames<ArchKind> AArch64ARCHNames[] = {

llvm/include/llvm/Support/AArch64TargetParser.def

 AARCH64_ARCH_EXT_NAME("tme",          AArch64::AEK_TME,         "+tme",   "-tme")
 AARCH64_ARCH_EXT_NAME("ls64",         AArch64::AEK_LS64,        "+ls64",  "-ls64")
 AARCH64_ARCH_EXT_NAME("brbe",         AArch64::AEK_BRBE,        "+brbe",  "-brbe")
 AARCH64_ARCH_EXT_NAME("pauth",        AArch64::AEK_PAUTH,       "+pauth", "-pauth")
 AARCH64_ARCH_EXT_NAME("flagm",        AArch64::AEK_FLAGM,       "+flagm", "-flagm")
 AARCH64_ARCH_EXT_NAME("sme",          AArch64::AEK_SME,         "+sme",   "-sme")
 AARCH64_ARCH_EXT_NAME("sme-f64",      AArch64::AEK_SMEF64,      "+sme-f64", "-sme-f64")
 AARCH64_ARCH_EXT_NAME("sme-i64",      AArch64::AEK_SMEI64,      "+sme-i64", "-sme-i64")
+AARCH64_ARCH_EXT_NAME("pmuv3",      AArch64::AEK_PERFMON,     "+perfmon", "-perfmon")
 #undef AARCH64_ARCH_EXT_NAME
 
 #ifndef AARCH64_CPU_NAME
 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)
 #endif
 AARCH64_CPU_NAME("cortex-a34", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,
                  (AArch64::AEK_CRC))
 AARCH64_CPU_NAME("cortex-a35", ARMV8A, FK_CRYPTO_NEON_FP_ARMV8, false,

llvm/lib/Support/AArch64TargetParser.cpp

bool AArch64::getExtensionFeatures(uint64_t Extensions,
   if (Extensions & AEK_FLAGM)
     Features.push_back("+flagm");
   if (Extensions & AArch64::AEK_SME)
     Features.push_back("+sme");
   if (Extensions & AArch64::AEK_SMEF64)
     Features.push_back("+sme-f64");
   if (Extensions & AArch64::AEK_SMEI64)
     Features.push_back("+sme-i64");
+  if (Extensions & AArch64::AEK_PERFMON)
+    Features.push_back("+perfmon");
 
   return true;
 }
 
 bool AArch64::getArchFeatures(AArch64::ArchKind AK,
                               std::vector<StringRef> &Features) {
   if (AK == ArchKind::ARMV8A)
     Features.push_back("+v8a");

llvm/unittests/Support/TargetParserTest.cpp

TEST(TargetParserTest, testAArch64Extension) {
   EXPECT_FALSE(testAArch64Extension(
       "generic", AArch64::ArchKind::ARMV8_4A, "fp16"));
   EXPECT_FALSE(testAArch64Extension(
       "generic", AArch64::ArchKind::ARMV8_4A, "fp16fml"));
 }
 
 TEST(TargetParserTest, AArch64ExtensionFeatures) {
   std::vector<uint64_t> Extensions = {
-    AArch64::AEK_CRC,      AArch64::AEK_CRYPTO,
-    AArch64::AEK_FP,       AArch64::AEK_SIMD,
-    AArch64::AEK_FP16,     AArch64::AEK_PROFILE,
-    AArch64::AEK_RAS,      AArch64::AEK_LSE,
-    AArch64::AEK_RDM,      AArch64::AEK_DOTPROD,
-    AArch64::AEK_SVE,      AArch64::AEK_SVE2,
-    AArch64::AEK_SVE2AES,  AArch64::AEK_SVE2SM4,
-    AArch64::AEK_SVE2SHA3, AArch64::AEK_SVE2BITPERM,
-    AArch64::AEK_RCPC,     AArch64::AEK_FP16FML,
-    AArch64::AEK_SME,      AArch64::AEK_SMEF64,
-    AArch64::AEK_SMEI64 };
+      AArch64::AEK_CRC,         AArch64::AEK_CRYPTO,  AArch64::AEK_FP,
+      AArch64::AEK_SIMD,        AArch64::AEK_FP16,    AArch64::AEK_PROFILE,
+      AArch64::AEK_RAS,         AArch64::AEK_LSE,     AArch64::AEK_RDM,
+      AArch64::AEK_DOTPROD,     AArch64::AEK_SVE,     AArch64::AEK_SVE2,
+      AArch64::AEK_SVE2AES,     AArch64::AEK_SVE2SM4, AArch64::AEK_SVE2SHA3,
+      AArch64::AEK_SVE2BITPERM, AArch64::AEK_RCPC,    AArch64::AEK_FP16FML,
+      AArch64::AEK_SME,         AArch64::AEK_SMEF64,  AArch64::AEK_SMEI64,
+      AArch64::AEK_PERFMON};
 
   std::vector<StringRef> Features;
 
   uint64_t ExtVal = 0;
   for (auto Ext : Extensions)
     ExtVal |= Ext;
 
   EXPECT_FALSE(AArch64::getExtensionFeatures(AArch64::AEK_INVALID, Features));
TEST(TargetParserTest, AArch64ExtensionFeatures) {
   EXPECT_TRUE(llvm::is_contained(Features, "+sve2"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sve2-aes"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sm4"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sha3"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sve2-bitperm"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sme"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sme-f64"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sme-i64"));
+  EXPECT_TRUE(llvm::is_contained(Features, "+perfmon"));
 }
 
 TEST(TargetParserTest, AArch64ArchFeatures) {
   std::vector<StringRef> Features;
 
   for (auto AK : AArch64::ArchKinds)
     EXPECT_TRUE((AK == AArch64::ArchKind::INVALID)
                     ? !AArch64::getArchFeatures(AK, Features)
                     : AArch64::getArchFeatures(AK, Features));
 }
 
 TEST(TargetParserTest, AArch64ArchExtFeature) {
-  const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
-                              {"crypto", "nocrypto", "+crypto", "-crypto"},
-                              {"flagm", "noflagm", "+flagm", "-flagm"},
-                              {"fp", "nofp", "+fp-armv8", "-fp-armv8"},
-                              {"simd", "nosimd", "+neon", "-neon"},
-                              {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
-                              {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"},
-                              {"profile", "noprofile", "+spe", "-spe"},
-                              {"ras", "noras", "+ras", "-ras"},
-                              {"lse", "nolse", "+lse", "-lse"},
-                              {"rdm", "nordm", "+rdm", "-rdm"},
-                              {"sve", "nosve", "+sve", "-sve"},
-                              {"sve2", "nosve2", "+sve2", "-sve2"},
-                              {"sve2-aes", "nosve2-aes", "+sve2-aes",
-                               "-sve2-aes"},
-                              {"sve2-sm4", "nosve2-sm4", "+sve2-sm4",
-                               "-sve2-sm4"},
-                              {"sve2-sha3", "nosve2-sha3", "+sve2-sha3",
-                               "-sve2-sha3"},
-                              {"sve2-bitperm", "nosve2-bitperm",
-                               "+sve2-bitperm", "-sve2-bitperm"},
-                              {"dotprod", "nodotprod", "+dotprod", "-dotprod"},
-                              {"rcpc", "norcpc", "+rcpc", "-rcpc" },
-                              {"rng", "norng", "+rand", "-rand"},
-                              {"memtag", "nomemtag", "+mte", "-mte"},
-                              {"tme", "notme", "+tme", "-tme"},
-                              {"pauth", "nopauth", "+pauth", "-pauth"},
-                              {"ssbs", "nossbs", "+ssbs", "-ssbs"},
-                              {"sb", "nosb", "+sb", "-sb"},
-                              {"predres", "nopredres", "+predres", "-predres"},
-                              {"i8mm", "noi8mm", "+i8mm", "-i8mm"},
-                              {"f32mm", "nof32mm", "+f32mm", "-f32mm"},
-                              {"f64mm", "nof64mm", "+f64mm", "-f64mm"},
-                              {"sme", "nosme", "+sme", "-sme"},
-                              {"sme-f64", "nosme-f64", "+sme-f64", "-sme-f64"},
-                              {"sme-i64", "nosme-i64", "+sme-i64", "-sme-i64"},
+  const char *ArchExt[][4] = {
+      {"crc", "nocrc", "+crc", "-crc"},
+      {"sve2-aes", "nosve2-aes", "+sve2-aes", "-sve2-aes"},
+      {"sve2-sm4", "nosve2-sm4", "+sve2-sm4", "-sve2-sm4"},
+      {"sve2-sha3", "nosve2-sha3", "+sve2-sha3", "-sve2-sha3"},
+      {"sve2-bitperm", "nosve2-bitperm", "+sve2-bitperm", "-sve2-bitperm"},
+      {"rcpc", "norcpc", "+rcpc", "-rcpc"},
+      {"pmuv3", "nopmuv3", "+perfmon", "-perfmon"},
   };
 
   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]));
   }
 }
 
 } // namespace