[AArch64] Handle Cyclone-specific register in common way

[jmolloy]

LGTM.

[Eugene.Zelenko]

Committed in rL235102.

lib/Target/AArch64/Utils/AArch64BaseInfo.h

enum SysRegValues {
     ICH_LR8_EL2       = 0xe668, // 11  100  1100  1101  000
     ICH_LR9_EL2       = 0xe669, // 11  100  1100  1101  001
     ICH_LR10_EL2      = 0xe66a, // 11  100  1100  1101  010
     ICH_LR11_EL2      = 0xe66b, // 11  100  1100  1101  011
     ICH_LR12_EL2      = 0xe66c, // 11  100  1100  1101  100
     ICH_LR13_EL2      = 0xe66d, // 11  100  1100  1101  101
     ICH_LR14_EL2      = 0xe66e, // 11  100  1100  1101  110
     ICH_LR15_EL2      = 0xe66f, // 11  100  1100  1101  111
-  };
 
     // Cyclone specific system registers
-  enum CycloneSysRegValues {
-    CPM_IOACC_CTL_EL3 = 0xff90
+    CPM_IOACC_CTL_EL3 = 0xff90,
   };
 
   // Note that these do not inherit from AArch64NamedImmMapper. This class is
   // sufficiently different in its behaviour that I don't believe it's worth
   // burdening the common AArch64NamedImmMapper with abstractions only needed in
   // this one case.
   struct SysRegMapper {
     static const AArch64NamedImmMapper::Mapping SysRegMappings[];
-    static const AArch64NamedImmMapper::Mapping CycloneSysRegMappings[];
 
     const AArch64NamedImmMapper::Mapping *InstMappings;
     size_t NumInstMappings;
     const FeatureBitset &FeatureBits;
     bool hasFeature(const FeatureBitset &Features) const {
       // empty Features means "always-on"
       return Features.none() || (FeatureBits & Features).any();
     }

lib/Target/AArch64/Utils/AArch64BaseInfo.cpp

const AArch64NamedImmMapper::Mapping AArch64SysReg::SysRegMapper::SysRegMappings[] = {
   {"ich_lr7_el2", ICH_LR7_EL2},
   {"ich_lr8_el2", ICH_LR8_EL2},
   {"ich_lr9_el2", ICH_LR9_EL2},
   {"ich_lr10_el2", ICH_LR10_EL2},
   {"ich_lr11_el2", ICH_LR11_EL2},
   {"ich_lr12_el2", ICH_LR12_EL2},
   {"ich_lr13_el2", ICH_LR13_EL2},
   {"ich_lr14_el2", ICH_LR14_EL2},
-  {"ich_lr15_el2", ICH_LR15_EL2}
-};
+  {"ich_lr15_el2", ICH_LR15_EL2},
 
-const AArch64NamedImmMapper::Mapping
-AArch64SysReg::SysRegMapper::CycloneSysRegMappings[] = {
-  {"cpm_ioacc_ctl_el3", CPM_IOACC_CTL_EL3}
+  // Cyclone registers
+  {"cpm_ioacc_ctl_el3", CPM_IOACC_CTL_EL3, FeatureBitset{AArch64::ProcCyclone}},
 };
 
 uint32_t
 AArch64SysReg::SysRegMapper::fromString(StringRef Name, bool &Valid) const {
   std::string NameLower = Name.lower();
 
   // First search the registers shared by all
   for (unsigned i = 0; i < array_lengthof(SysRegMappings); ++i) {
     if (hasFeature(SysRegMappings[i].FeatureBits) &&
         SysRegMappings[i].Name == NameLower) {
       Valid = true;
       return SysRegMappings[i].Value;
     }
   }
 
-  // Next search for target specific registers
-  if (FeatureBits[AArch64::ProcCyclone]) {
-    for (unsigned i = 0; i < array_lengthof(CycloneSysRegMappings); ++i) {
-      if (CycloneSysRegMappings[i].Name == NameLower) {
-        Valid = true;
-        return CycloneSysRegMappings[i].Value;
-      }
-    }
-  }
-
   // Now try the instruction-specific registers (either read-only or
   // write-only).
   for (unsigned i = 0; i < NumInstMappings; ++i) {
     if (hasFeature(InstMappings[i].FeatureBits) &&
         InstMappings[i].Name == NameLower) {
       Valid = true;
       return InstMappings[i].Value;
     }
AArch64SysReg::SysRegMapper::toString(uint32_t Bits) const {
   // First search the registers shared by all
   for (unsigned i = 0; i < array_lengthof(SysRegMappings); ++i) {
     if (hasFeature(SysRegMappings[i].FeatureBits) &&
         SysRegMappings[i].Value == Bits) {
       return SysRegMappings[i].Name;
     }
   }
 
-  // Next search for target specific registers
-  if (FeatureBits[AArch64::ProcCyclone]) {
-    for (unsigned i = 0; i < array_lengthof(CycloneSysRegMappings); ++i) {
-      if (CycloneSysRegMappings[i].Value == Bits) {
-        return CycloneSysRegMappings[i].Name;
-      }
-    }
-  }
-
   // Now try the instruction-specific registers (either read-only or
   // write-only).
   for (unsigned i = 0; i < NumInstMappings; ++i) {
     if (hasFeature(InstMappings[i].FeatureBits) &&
         InstMappings[i].Value == Bits) {
       return InstMappings[i].Name;
     }
   }