[ARM][AArch64] De-template TargetParser types

[pratlucas]

llvm/lib/Support/ARMTargetParser.cpp

486

Nit: use const auto & here instead.

[lenary]

Some comments. The namespace one is more important than the plural-ness comments.

llvm/include/llvm/Support/AArch64TargetParser.h

86

is this in a different namespace to the arm version of this struct?

also, why does this class have a plural name? It doesn't represent a list, it represents an entry in a list? is this something we can fix now?

135

I think this also needs to be in a namespace so it doesn't collide with the ARM variant?

I have similar issues with the pluralness of this class name.

[tschuett]

llvm/include/llvm/Support/AArch64TargetParser.h

25

There is an AArch64 and an ARM namespace.

[lenary]

Well, usually I can read, but not today.

[tmatheson]

llvm/include/llvm/Support/AArch64TargetParser.h

25

Assuming this is in reply to @lenary, let me know if not.

86

Yes it's llvm::AArch64::ArchNames.

I didn't name it so I don't know, it was copied verbatim from ARMTargetParser. Outside the scope of this patch...

135

It's llvm::AArch64::CpuNames.

[tmatheson]

Use auto for loop

llvm/include/llvm/Support/AArch64TargetParser.h

 #include "llvm/ADT/StringRef.h"
 #include <vector>
 
 // FIXME:This should be made into class design,to avoid dupplication.
 namespace llvm {
 
 class Triple;
 
 namespace AArch64 {
 
 // Arch extension modifiers for CPUs. These are labelled with their Arm ARM
 // feature name (though the canonical reference for those is AArch64.td)
 enum ArchExtKind : uint64_t {
   AEK_INVALID =     0,
   AEK_NONE =        1,
   AEK_CRC =         1 << 1,  // FEAT_CRC32
   AEK_CRYPTO =      1 << 2,
enum ArchExtKind : uint64_t {
   AEK_SMEF16F16 =   1ULL << 47  // FEAT_SMEF16F16
 };
 
 enum class ArchKind {
 #define AARCH64_ARCH(NAME, ID, SUB_ARCH, ARCH_BASE_EXT) ID,
 #include "AArch64TargetParser.def"
 };
 
-template <typename T> struct ArchNames {
+struct ArchNames {
   const char *NameCStr;
   size_t NameLength;
   const char *SubArchCStr;
   size_t SubArchLength;
   uint64_t ArchBaseExtensions;
-  T ID;
+  ArchKind ID;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 
   // Sub-Arch name.
   StringRef getSubArch() const {
     return getArchFeature().substr(1, SubArchLength);
   }
 
   // Arch Feature name.
   StringRef getArchFeature() const {
     return StringRef(SubArchCStr, SubArchLength);
   }
 };
 
-const ArchNames<ArchKind> AArch64ARCHNames[] = {
+const ArchNames AArch64ARCHNames[] = {
 #define AARCH64_ARCH(NAME, ID, SUB_ARCH, ARCH_BASE_EXT)                        \
   {NAME,          sizeof(NAME) - 1,     "+" SUB_ARCH, sizeof(SUB_ARCH),        \
    ARCH_BASE_EXT, AArch64::ArchKind::ID},
 #include "AArch64TargetParser.def"
 };
 
 // List of Arch Extension names.
 struct ExtName {
#define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE)                   \
   {NAME, sizeof(NAME) - 1, ID, FEATURE, NEGFEATURE},
 #include "AArch64TargetParser.def"
 };
 
 // List of CPU names and their arches.
 // The same CPU can have multiple arches and can be default on multiple arches.
 // When finding the Arch for a CPU, first-found prevails. Sort them accordingly.
 // When this becomes table-generated, we'd probably need two tables.
-template <typename T> struct CpuNames {
+struct CpuNames {
   const char *NameCStr;
   size_t NameLength;
-  T ArchID;
+  ArchKind ArchID;
   bool Default; // is $Name the default CPU for $ArchID ?
   uint64_t DefaultExtensions;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
-const CpuNames<ArchKind> AArch64CPUNames[] = {
+const CpuNames AArch64CPUNames[] = {
 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)       \
   {NAME, sizeof(NAME) - 1, AArch64::ArchKind::ID, IS_DEFAULT, DEFAULT_EXT},
 #include "AArch64TargetParser.def"
 };
 
 const struct {
   const char *Alias;
   size_t AliasLength;
if ((Kind == ArchKind::INVALID) || (Kind == ArchKind::ARMV8A) ||
     Kind = ArchKind::INVALID;
   else {
     unsigned KindAsInteger = static_cast<unsigned>(Kind);
     Kind = static_cast<ArchKind>(--KindAsInteger);
   }
   return Kind;
 }
 
-// FIXME: These should be moved to TargetTuple once it exists
 bool getExtensionFeatures(uint64_t Extensions,
                           std::vector<StringRef> &Features);
 bool getArchFeatures(ArchKind AK, std::vector<StringRef> &Features);
 
 StringRef getArchName(ArchKind AK);
 StringRef getSubArch(ArchKind AK);
 StringRef getArchExtName(unsigned ArchExtKind);
 StringRef getArchExtFeature(StringRef ArchExt);

llvm/include/llvm/Support/ARMTargetParser.h

 #include "ARMTargetParser.def"
 };
 
 // List of CPU names and their arches.
 // The same CPU can have multiple arches and can be default on multiple arches.
 // When finding the Arch for a CPU, first-found prevails. Sort them accordingly.
 // When this becomes table-generated, we'd probably need two tables.
 // FIXME: TableGen this.
-template <typename T> struct CpuNames {
+struct CpuNames {
   const char *NameCStr;
   size_t NameLength;
-  T ArchID;
+  ArchKind ArchID;
   bool Default; // is $Name the default CPU for $ArchID ?
   uint64_t DefaultExtensions;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 };
 
-const CpuNames<ArchKind> CPUNames[] = {
+const CpuNames CPUNames[] = {
 #define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)           \
   {NAME, sizeof(NAME) - 1, ARM::ArchKind::ID, IS_DEFAULT, DEFAULT_EXT},
 #include "ARMTargetParser.def"
 };
 
 // FPU names.
 enum FPUKind {
 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) KIND,

 // List of canonical arch names (use getArchSynonym).
 // This table also provides the build attribute fields for CPU arch
 // and Arch ID, according to the Addenda to the ARM ABI, chapters
 // 2.4 and 2.3.5.2 respectively.
 // FIXME: SubArch values were simplified to fit into the expectations
 // of the triples and are not conforming with their official names.
 // Check to see if the expectation should be changed.
 // FIXME: TableGen this.
-template <typename T> struct ArchNames {
+struct ArchNames {
   const char *NameCStr;
   size_t NameLength;
   const char *CPUAttrCStr;
   size_t CPUAttrLength;
   const char *SubArchCStr;
   size_t SubArchLength;
   unsigned DefaultFPU;
   uint64_t ArchBaseExtensions;
-  T ID;
+  ArchKind ID;
   ARMBuildAttrs::CPUArch ArchAttr; // Arch ID in build attributes.
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
 
   // CPU class in build attributes.
   StringRef getCPUAttr() const { return StringRef(CPUAttrCStr, CPUAttrLength); }
 
   // Sub-Arch name.
   StringRef getSubArch() const {
     return getArchFeature().substr(1, SubArchLength);
   }
 
   // Arch Feature name.
   StringRef getArchFeature() const {
     return StringRef(SubArchCStr, SubArchLength);
   }
 };
 
-static const ArchNames<ArchKind> ARMArchNames[] = {
+static const ArchNames ARMArchNames[] = {
 #define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU,            \
                  ARCH_BASE_EXT)                                                \
   {NAME,         sizeof(NAME) - 1,                                             \
    CPU_ATTR,     sizeof(CPU_ATTR) - 1,                                         \
    "+" SUB_ARCH, sizeof(SUB_ARCH),                                             \
    ARCH_FPU,     ARCH_BASE_EXT,                                                \
    ArchKind::ID, ARCH_ATTR},
 #include "llvm/Support/ARMTargetParser.def"

 }
 
 // Information by ID
 StringRef getFPUName(unsigned FPUKind);
 FPUVersion getFPUVersion(unsigned FPUKind);
 NeonSupportLevel getFPUNeonSupportLevel(unsigned FPUKind);
 FPURestriction getFPURestriction(unsigned FPUKind);
 
-// FIXME: These should be moved to TargetTuple once it exists
 bool getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features);
 bool getHWDivFeatures(uint64_t HWDivKind, std::vector<StringRef> &Features);
 bool getExtensionFeatures(uint64_t Extensions,
                           std::vector<StringRef> &Features);
 
 StringRef getArchName(ArchKind AK);
 unsigned getArchAttr(ArchKind AK);
 StringRef getCPUAttr(ArchKind AK);

llvm/lib/Support/ARMTargetParser.cpp

ARM::ArchKind ARM::parseCPUArch(StringRef CPU) {
   for (const auto &C : CPUNames) {
     if (CPU == C.getName())
       return C.ArchID;
   }
   return ArchKind::INVALID;
 }
 
 void ARM::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) {
-  for (const CpuNames<ArchKind> &Arch : CPUNames) {
+  for (const CpuNames &Arch : CPUNames) {
     if (Arch.ArchID != ArchKind::INVALID)
       Values.push_back(Arch.getName());
   }
 }
 
 StringRef ARM::computeDefaultTargetABI(const Triple &TT, StringRef CPU) {
   StringRef ArchName =
       CPU.empty() ? TT.getArchName() : getArchName(parseCPUArch(CPU));