[RFC]Add unittests to {ARM | AArch64}TargetParser

[jojo]

Summary

• Add unittest to {ARM | AArch64}TargetParser
• Correct a incorrect indexing problem in AArch64TargetParser The architecture enumeration is shared across ARM and AArch64 in original implementation.But In the code,I just used the index which was offset by the ARM, and this would index into the array incorrectly. To make AArch64 has its own arch enum,or we will do a lot of slowly iterating.
• Correct a spelling error by the way. parameter of llvm::AArch64::getArchExtName
• Correct a writing mistake, in llvm::ARM::parseArchISA

[jojo]

Remove unnecessary whitespace.

[compnerd]

include/llvm/Support/TargetParser.h

152 ↗

(On Diff #62063)

I think that you should use the AK_ prefix as is the norm. That said, you could do something else which IMO is better: use enum class and drop the prefix.

unittests/Support/TargetParserTest.cpp

24 ↗

(On Diff #62063)

Please delete this. I had added it to avoid hardcoding the offset. Just iterate over the enumeration below. In fact, it is unused.

68 ↗

(On Diff #62063)

This set really feels weird to me.

[jojo]

Remove uncessary items according to inline comments.

include/llvm/Support/TargetParser.h

152 ↗

(On Diff #62063)

If we use enum class, we must do type casting when we perform operations between "unsigned int" and archkind. There are a lot of cases like this, in the TargetParser and places using it. And some generic structure definition shared between arm and aarch64, should be made a set for each.
Do we have to do this? Let AK_ point to ARM, and AAK_ point to AArch64 seems to make sense also.

unittests/Support/TargetParserTest.cpp

24 ↗

(On Diff #62063)

Indeed,remove it.

68 ↗

(On Diff #62063)

I removed two of these which are unnecessary.
The remaining two arrays are needed for some test items,with the help of def file can avoid writing a long array.And if there are changes happened on arch or cpu in def,we can do as small
changes as possible.
Hi,compnerd,If you still feel it can not be accepted,Could you say it further? Can't you accept the way they are defined? Or just don't want to have something like that? so it can get me more clear.
Thank you very much! :)

[jojo]

• Add unittest to ARMTargetParser
• Correct a writing mistake,in llvm::ARM::parseArchISA.
• Make some small changes on AArch64TargetParser

[rengolin]

include/llvm/Support/TargetParser.h

152 ↗

(On Diff #62834)

I think we should leave that discussion for when we change this to a class design, or when we move to table-generated tables. I think it should be fine as is, for now.

[rengolin]

Hi Jojo,

Thanks for the patch. I like how thorough were your tests, and it'll certainly cover a lot more than the current TripleTest. At some point, after we finish this, I think we should clean that one up, so that it stops redundant (and slow) tests.

Saleem (@compnerd), are you happy with the changes? I think we can discuss style in the class discussion (since it's going to change again, anyway), and just get all tools to use the parser for now.

cheers,
--renato

[compnerd]

I think that Id still prefer the AK_ prefix. However, the only thing that is preventing me from accepting the change is that I haven't really carefully looked through all the cases. If you have done so, and everything looks okay, fine by me :-).

[jojo]

Add test for ARM::parseArchISA and ARM::parseArchEndian.

[jojo]

Dear all,

I‘m not so sure about the changes.That would be appreciated if you could give any advice.
It will take some time to read through all the changes,Thank you very much for your review.

[rengolin]

In D21785#479075, @compnerd wrote:

I think that Id still prefer the AK_ prefix. However, the only thing that is preventing me from accepting the change is that I haven't really carefully looked through all the cases. If you have done so, and everything looks okay, fine by me :-).

I don't mind either way (AK, AAK), but if there is anything stopping us from using AK, we should move that discussion later.

If not, I agree we should just keep AK instead. AK means "ArchKind", not "ARMKind", so AArch64 would also be "ArchKind", thus AK.

That would also make this change a lot smaller, and clearer.

thanks,
--renato

[jojo]

Looks like that keep using prefix AK is more reasonable.Update diff to use AK instead.

[rengolin]

lib/Support/TargetParser.cpp

455 ↗

(On Diff #64080)

Now I see why you wanted a different enum.

@compnerd, I really don't mind either way, so I'll leave it up to you. :)

[compnerd]

There are a bunch of place that could use a range based for loop, please prefer them instead.

lib/Support/TargetParser.cpp

419 ↗

(On Diff #64080)

Isn't this the original bug that is being fixed rather than just adding tests for the target parser?

455 ↗

(On Diff #64080)

I don't think that this is necessarily bad. It does make it more obvious if you are targeting a newer architecture variant.

463 ↗

(On Diff #64080)

Given that you are doing explicit checks, why not simplify this to:

if (ArchKind == ...)
  ...
if (ArchKind == ...)
  ...
return ArchKind > AArch64::ArchKind::AK_INVALID && ArchKind < AArch64::ArchKind::AK_LAST;

468 ↗

(On Diff #64080)

Shouldn't this check for AK_INVALID as well?

488 ↗

(On Diff #64080)

Shouldn't this check for AK_INVALID as well?

unittests/Support/TargetParserTest.cpp

180 ↗

(On Diff #64080)

space before the <.

Why not use a range based loop?

for (const auto &ARMCPUName : kARMCPUNames)
  EXPECT_EQ(ARMCPUName.DefaultFPU, ARM::getDefaultFPU(ARMCPUName.Name, 0));

192 ↗

(On Diff #64080)

Similar.

263 ↗

(On Diff #64080)

clang-format this

[jojo]

lib/Support/TargetParser.cpp

419 ↗

(On Diff #64080)

Yes.this is a bug fixing. For AArch64,it's unnecessary to OR the ArchBaseExtensions,as the tables for ARM and AArch64 have not exactly the same design.
The original bug is fixed by correcting the incorrect indexing problem and removing the ORing here.All the changes are included in this revision.

468 ↗

(On Diff #64080)

There is a record for "invalid" in ARCHNames table.
It will return what we want for ArchName and ArchAttr, no need to do additional check.

488 ↗

(On Diff #64080)

the same as above

unittests/Support/TargetParserTest.cpp

180 ↗

(On Diff #64080)

Yes,indeed.
Replace all similar cases.

263 ↗

(On Diff #64080)

Do you mean like this?

{ "crc", "+crc"},
... ...
{ "nocrc", "-crc"},
... ...

[rengolin]

unittests/Support/TargetParserTest.cpp

261 ↗

(On Diff #64644)

He probably just mean running "clang-format" over the file.

$ clang-format unittests/Support/TargetParserTest.cpp

should do.

[jojo]

clang-format unittests/Support/TargetParserTest.cpp

[jojo]

unittests/Support/TargetParserTest.cpp

261 ↗

(On Diff #64644)

Oh, No brainer.

[rengolin]

LGTM. Thanks!

llvm/trunk/include/llvm/Support/AArch64TargetParser.def

 //
 //===----------------------------------------------------------------------===//
 
 // NOTE: NO INCLUDE GUARD DESIRED!
 
 #ifndef AARCH64_ARCH
 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT)
 #endif
+AARCH64_ARCH("invalid", AK_INVALID, nullptr, nullptr,
+             ARMBuildAttrs::CPUArch::v8_A, FK_NONE, AArch64::AEK_NONE)
 AARCH64_ARCH("armv8-a", AK_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",
              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))

llvm/trunk/include/llvm/Support/TargetParser.h

 unsigned parseArchProfile(StringRef Arch);
 unsigned parseArchVersion(StringRef Arch);
 
 } // namespace ARM
 
 // FIXME:This should be made into class design,to avoid dupplication. 
 namespace AArch64 {
 
+// Arch names.
+enum class ArchKind {
+#define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
+#include "AArch64TargetParser.def"
+  AK_LAST
+};
+
 // Arch extension modifiers for CPUs.
 enum ArchExtKind : unsigned {
   AEK_INVALID = 0x0,
   AEK_NONE = 0x1,
   AEK_CRC = 0x2,
   AEK_CRYPTO = 0x4,
   AEK_FP = 0x8,
   AEK_SIMD = 0x10,

llvm/trunk/lib/Support/TargetParser.cpp

 // 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.
-static const struct {
+template <typename T> struct ArchNames {
   const char *NameCStr;
   size_t NameLength;
   const char *CPUAttrCStr;
   size_t CPUAttrLength;
   const char *SubArchCStr;
   size_t SubArchLength;
   unsigned DefaultFPU;
   unsigned ArchBaseExtensions;
-  ARM::ArchKind ID;
+  T 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 StringRef(SubArchCStr, SubArchLength); }
-} ARCHNames[] = {
+};
+ArchNames<ARM::ArchKind> ARCHNames[] = {
 #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) - 1, ARCH_FPU, ARCH_BASE_EXT, ID, ARCH_ATTR},
 #include "llvm/Support/ARMTargetParser.def"
-},AArch64ARCHNames[] = {
+};
+
+ArchNames<AArch64::ArchKind> AArch64ARCHNames[] = {
  #define AARCH64_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) - 1, ARCH_FPU, ARCH_BASE_EXT, ID, ARCH_ATTR},
+    sizeof(SUB_ARCH) - 1, ARCH_FPU, ARCH_BASE_EXT, AArch64::ArchKind::ID, ARCH_ATTR},
  #include "llvm/Support/AArch64TargetParser.def"
  };
 
+
 // List of Arch Extension names.
 // FIXME: TableGen this.
 static const struct {
   const char *NameCStr;
   size_t NameLength;
   unsigned ID;
   const char *Feature;
   const char *NegFeature;

 #include "llvm/Support/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.
-static const struct {
+template <typename T> struct CpuNames {
   const char *NameCStr;
   size_t NameLength;
-  ARM::ArchKind ArchID;
+  T ArchID;
   bool Default; // is $Name the default CPU for $ArchID ?
   unsigned DefaultExtensions;
 
   StringRef getName() const { return StringRef(NameCStr, NameLength); }
-} CPUNames[] = {
+};
+CpuNames<ARM::ArchKind> CPUNames[] = {
 #define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
   { NAME, sizeof(NAME) - 1, ID, IS_DEFAULT, DEFAULT_EXT },
 #include "llvm/Support/ARMTargetParser.def"
-},AArch64CPUNames[] = {
+};
+
+CpuNames<AArch64::ArchKind> AArch64CPUNames[] = {
  #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
-  { NAME, sizeof(NAME) - 1, ID, IS_DEFAULT, DEFAULT_EXT },
+   { NAME, sizeof(NAME) - 1, AArch64::ArchKind::ID, IS_DEFAULT, DEFAULT_EXT },
  #include "llvm/Support/AArch64TargetParser.def"
  };
 
 } // namespace
 
 // ======================================================= //
 // Information by ID
 // ======================================================= //
 
 StringRef llvm::ARM::getFPUName(unsigned FPUKind) {

 }
 
 unsigned llvm::AArch64::getDefaultExtensions(StringRef CPU, unsigned ArchKind) {
   if (CPU == "generic")
     return AArch64ARCHNames[ArchKind].ArchBaseExtensions;
 
   return StringSwitch<unsigned>(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);
 }
 
 bool llvm::AArch64::getExtensionFeatures(unsigned Extensions,
                                      std::vector<const char *> &Features) {
 
   if (Extensions == AArch64::AEK_INVALID)

 
 bool llvm::AArch64::getFPUFeatures(unsigned FPUKind,
                                std::vector<const char *> &Features) {
   return ARM::getFPUFeatures(FPUKind, Features);
 }
 
 bool llvm::AArch64::getArchFeatures(unsigned ArchKind,
                                      std::vector<const char *> &Features) {
-  if (ArchKind == ARM::AK_INVALID || ArchKind >= ARM::AK_LAST)
-    return false;
-
-  if (ArchKind == ARM::AK_ARMV8_1A)
+  if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_1A))
     Features.push_back("+v8.1a");
-  if (ArchKind == ARM::AK_ARMV8_2A)
+  if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_2A))
     Features.push_back("+v8.2a");
 
-  return true;
+  return ArchKind > static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) &&
+         ArchKind < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
 }
 
 StringRef llvm::AArch64::getArchName(unsigned ArchKind) {
-  for (const auto &AI : AArch64ARCHNames)
-    if (AI.ID == ArchKind)
-      return AI.getName();
+  if (ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_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();
+  if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
+      ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_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();
+  if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
+      ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_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;
+  if (ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_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();
 }
 
 const char *llvm::AArch64::getArchExtFeature(StringRef ArchExt) {
   if (ArchExt.startswith("no")) {
     StringRef ArchExtBase(ArchExt.substr(2));
     for (const auto &AE : AArch64ARCHExtNames) {
       if (AE.NegFeature && ArchExtBase == AE.getName())
         return AE.NegFeature;
     }
   }
 
   for (const auto &AE : AArch64ARCHExtNames)
     if (AE.Feature && ArchExt == AE.getName())
       return AE.Feature;
   return nullptr;
 }
 
 StringRef llvm::AArch64::getDefaultCPU(StringRef Arch) {
   unsigned AK = parseArch(Arch);
-  if (AK == ARM::AK_INVALID)
+  if (AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID))
     return StringRef();
 
   // Look for multiple AKs to find the default for pair AK+Name.
   for (const auto &CPU : AArch64CPUNames)
-    if (CPU.ArchID == AK && CPU.Default)
+    if (static_cast<unsigned>(CPU.ArchID) == AK && CPU.Default)
       return CPU.getName();
 
   // If we can't find a default then target the architecture instead
   return "generic";
 }
 
 unsigned llvm::AArch64::checkArchVersion(StringRef Arch) {
   if (Arch[0] == 'v' && std::isdigit(Arch[1]))

 
 // ARM, Thumb, AArch64
 unsigned llvm::ARM::parseArchISA(StringRef Arch) {
   return StringSwitch<unsigned>(Arch)
       .StartsWith("aarch64", ARM::IK_AARCH64)
       .StartsWith("arm64", ARM::IK_AARCH64)
       .StartsWith("thumb", ARM::IK_THUMB)
       .StartsWith("arm", ARM::IK_ARM)
-      .Default(ARM::EK_INVALID);
+      .Default(ARM::IK_INVALID);
 }
 
 // Little/Big endian
 unsigned llvm::ARM::parseArchEndian(StringRef Arch) {
   if (Arch.startswith("armeb") || Arch.startswith("thumbeb") ||
       Arch.startswith("aarch64_be"))
     return ARM::EK_BIG;
 

 unsigned llvm::AArch64::parseFPU(StringRef FPU) {
   return ARM::parseFPU(FPU);
 }
 
 // Allows partial match, ex. "v8a" matches "armv8a".
 unsigned llvm::AArch64::parseArch(StringRef Arch) {
   Arch = getCanonicalArchName(Arch);
   if (checkArchVersion(Arch) < 8)
-    return ARM::AK_INVALID;
+    return static_cast<unsigned>(AArch64::ArchKind::AK_INVALID);
 
   StringRef Syn = getArchSynonym(Arch);
   for (const auto A : AArch64ARCHNames) {
     if (A.getName().endswith(Syn))
-      return A.ID;
+      return static_cast<unsigned>(A.ID);
   }
-  return ARM::AK_INVALID;
+  return static_cast<unsigned>(AArch64::ArchKind::AK_INVALID);
 }
 
 unsigned llvm::AArch64::parseArchExt(StringRef ArchExt) {
   for (const auto A : AArch64ARCHExtNames) {
     if (ArchExt == A.getName())
       return A.ID;
   }
   return AArch64::AEK_INVALID;
 }
 
 unsigned llvm::AArch64::parseCPUArch(StringRef CPU) {
   for (const auto C : AArch64CPUNames) {
     if (CPU == C.getName())
-      return C.ArchID;
+      return static_cast<unsigned>(C.ArchID);
   }
-  return ARM::AK_INVALID;
+  return static_cast<unsigned>(AArch64::ArchKind::AK_INVALID);
 }
 
 // ARM, Thumb, AArch64
 unsigned llvm::AArch64::parseArchISA(StringRef Arch) {
   return ARM::parseArchISA(Arch);
 }
 
 // Little/Big endian

llvm/trunk/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

 bool AArch64AsmParser::parseDirectiveArch(SMLoc L) {
   SMLoc ArchLoc = getLoc();
 
   StringRef Arch, ExtensionString;
   std::tie(Arch, ExtensionString) =
       getParser().parseStringToEndOfStatement().trim().split('+');
 
   unsigned ID = AArch64::parseArch(Arch);
-  if (ID == ARM::AK_INVALID) {
+  if (ID == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID)) {
     Error(ArchLoc, "unknown arch name");
     return false;
   }
 
   MCSubtargetInfo &STI = copySTI();
   STI.setDefaultFeatures("", "");
   if (!ExtensionString.empty())
     STI.setDefaultFeatures("", ("+" + ExtensionString).str());

llvm/trunk/unittests/Support/TargetParserTest.cpp

 //===----------- TargetParser.cpp - Target Parser -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/TargetParser.h"
+#include "gtest/gtest.h"
+#include <string>
 
 using namespace llvm;
 
 namespace {
-static const unsigned kAArch64ArchKinds[] = {
+static const unsigned kHWDivKinds[] = {
+#define ARM_HW_DIV_NAME(NAME, ID) ID,
+#include "llvm/Support/ARMTargetParser.def"
+#undef ARM_HW_DIV_NAME
+};
+
+static const unsigned kARMArchExtKinds[] = {
+#define ARM_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) ID,
+#include "llvm/Support/ARMTargetParser.def"
+#undef ARM_ARCH_EXT_NAME
+};
+
+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 <typename T> struct ArchNames {
+  const char *Name;
+  unsigned DefaultFPU;
+  unsigned ArchBaseExtensions;
+  T ID;
+  ARMBuildAttrs::CPUArch ArchAttr;
+};
+ArchNames<AArch64::ArchKind> kAArch64ARCHNames[] = {
 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU,        \
                      ARCH_BASE_EXT)                                            \
-  llvm::ARM::ID,
+  {NAME, ARM::ARCH_FPU, ARCH_BASE_EXT, AArch64::ArchKind::ID, ARCH_ATTR},
 #include "llvm/Support/AArch64TargetParser.def"
 #undef AARCH64_ARCH
 };
+ArchNames<ARM::ArchKind> 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 <typename T> struct CpuNames {
+  const char *Name;
+  T ID;
+  unsigned DefaultFPU;
+  unsigned DefaultExt;
+};
+CpuNames<AArch64::ArchKind> 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<ARM::ArchKind> 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"};
 
 template <typename T, size_t N>
 bool contains(const T (&array)[N], const T element) {
   return std::find(std::begin(array), std::end(array), element) !=
          std::end(array);
 }
 
 TEST(TargetParserTest, ARMArchName) {

 TEST(TargetParserTest, ARMFPUName) {
   for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
        FK <= ARM::FPUKind::FK_LAST;
        FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
     EXPECT_TRUE(FK == ARM::FK_LAST ? ARM::getFPUName(FK).empty()
                                    : !ARM::getFPUName(FK).empty());
 }
 
-TEST(TargetParserTest, AArch64ArchName) {
+TEST(TargetParserTest, ARMFPUVersion) {
+  for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
+       FK <= ARM::FPUKind::FK_LAST;
+       FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
+    if (FK == ARM::FK_LAST)
+      EXPECT_EQ(0, ARM::getFPUVersion(FK));
+    else
+      EXPECT_LE(0, ARM::getFPUVersion(FK));
+}
+
+TEST(TargetParserTest, ARMFPUNeonSupportLevel) {
+  for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
+       FK <= ARM::FPUKind::FK_LAST;
+       FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
+    if (FK == ARM::FK_LAST)
+      EXPECT_EQ(0, ARM::getFPUNeonSupportLevel(FK));
+    else
+      EXPECT_LE(0, ARM::getFPUNeonSupportLevel(FK));
+}
+
+TEST(TargetParserTest, ARMFPURestriction) {
+  for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
+       FK <= ARM::FPUKind::FK_LAST;
+       FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
+    if (FK == ARM::FK_LAST)
+      EXPECT_EQ(0, ARM::getFPURestriction(FK));
+    else
+      EXPECT_LE(0, ARM::getFPURestriction(FK));
+}
+
+TEST(TargetParserTest, ARMDefaultFPU) {
   for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
-       AK <= ARM::ArchKind::AK_LAST;
+       AK < ARM::ArchKind::AK_LAST;
        AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
-    EXPECT_TRUE(contains(kAArch64ArchKinds, static_cast<unsigned>(AK))
-                    ? !AArch64::getArchName(AK).empty()
-                    : AArch64::getArchName(AK).empty());
+    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, AArch64CPUAttr) {
+TEST(TargetParserTest, ARMDefaultExtensions) {
   for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
-       AK <= ARM::ArchKind::AK_LAST;
+       AK < ARM::ArchKind::AK_LAST;
        AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
-    EXPECT_TRUE(contains(kAArch64ArchKinds, static_cast<unsigned>(AK))
-                    ? !AArch64::getCPUAttr(AK).empty()
-                    : AArch64::getCPUAttr(AK).empty());
+    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, AArch64SubArch) {
+TEST(TargetParserTest, ARMExtensionFeatures) {
+  std::vector<const char *> Features;
+  unsigned Extensions = ARM::AEK_CRC | ARM::AEK_CRYPTO | ARM::AEK_DSP |
+                        ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_MP |
+                        ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_RAS;
+
+  for (unsigned i = 0; i <= Extensions; i++)
+    EXPECT_TRUE(i == 0 ? !ARM::getExtensionFeatures(i, Features)
+                       : ARM::getExtensionFeatures(i, Features));
+}
+
+TEST(TargetParserTest, ARMFPUFeatures) {
+  std::vector<const char *> Features;
+  for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
+       FK <= ARM::FPUKind::FK_LAST;
+       FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
+    EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
+                    ? !ARM::getFPUFeatures(FK, Features)
+                    : ARM::getFPUFeatures(FK, Features));
+}
+
+TEST(TargetParserTest, ARMArchAttr) {
   for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
        AK <= ARM::ArchKind::AK_LAST;
        AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
-    EXPECT_TRUE(contains(kAArch64ArchKinds, static_cast<unsigned>(AK))
-                    ? !AArch64::getSubArch(AK).empty()
-                    : AArch64::getSubArch(AK).empty());
+    EXPECT_TRUE(AK == ARM::AK_LAST
+                    ? (ARMBuildAttrs::CPUArch::Pre_v4 == ARM::getArchAttr(AK))
+                    : (kARMARCHNames[AK].ArchAttr == ARM::getArchAttr(AK)));
+}
+
+TEST(TargetParserTest, ARMArchExtName) {
+  for (ARM::ArchExtKind AEK = static_cast<ARM::ArchExtKind>(0);
+       AEK <= ARM::ArchExtKind::AEK_XSCALE;
+       AEK = static_cast<ARM::ArchExtKind>(static_cast<unsigned>(AEK) + 1))
+    EXPECT_TRUE(contains(kARMArchExtKinds, static_cast<unsigned>(AEK))
+                    ? !ARM::getArchExtName(AEK).empty()
+                    : ARM::getArchExtName(AEK).empty());
+}
+
+TEST(TargetParserTest, ARMArchExtFeature) {
+  const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
+                              {"crypto", "nocrypto", "+crypto", "-crypto"},
+                              {"dsp", "nodsp", "+dsp", "-dsp"},
+                              {"fp", "nofp", nullptr, nullptr},
+                              {"idiv", "noidiv", nullptr, nullptr},
+                              {"mp", "nomp", nullptr, nullptr},
+                              {"simd", "nosimd", nullptr, nullptr},
+                              {"sec", "nosec", nullptr, nullptr},
+                              {"virt", "novirt", nullptr, nullptr},
+                              {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
+                              {"ras", "noras", "+ras", "-ras"},
+                              {"os", "noos", nullptr, nullptr},
+                              {"iwmmxt", "noiwmmxt", nullptr, nullptr},
+                              {"iwmmxt2", "noiwmmxt2", nullptr, nullptr},
+                              {"maverick", "maverick", nullptr, nullptr},
+                              {"xscale", "noxscale", nullptr, nullptr}};
+
+  for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
+    EXPECT_EQ(ArchExt[i][2], ARM::getArchExtFeature(ArchExt[i][0]));
+    EXPECT_EQ(ArchExt[i][3], ARM::getArchExtFeature(ArchExt[i][1]));
+  }
+}
+
+TEST(TargetParserTest, ARMHWDivName) {
+  for (ARM::ArchExtKind AEK = static_cast<ARM::ArchExtKind>(0);
+       AEK <= ARM::ArchExtKind::AEK_XSCALE;
+       AEK = static_cast<ARM::ArchExtKind>(static_cast<unsigned>(AEK) + 1))
+    EXPECT_TRUE(contains(kHWDivKinds, static_cast<unsigned>(AEK))
+                    ? !ARM::getHWDivName(AEK).empty()
+                    : ARM::getHWDivName(AEK).empty());
+}
+
+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"};
+
+  for (unsigned i = 0; i < array_lengthof(hwdiv); i++)
+    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",   "iwmmxt",
+      "xscale",        "swift"};
+
+  for (const auto &ARMCPUName : kARMCPUNames)
+    EXPECT_TRUE(contains(CPU, ARMCPUName.Name)
+                    ? (ARM::AK_INVALID != ARM::parseCPUArch(ARMCPUName.Name))
+                    : (ARM::AK_INVALID == ARM::parseCPUArch(ARMCPUName.Name)));
+}
+
+TEST(TargetParserTest, ARMparseArchEndianAndISA) {
+  const char *Arch[] = {
+      "v2",    "v2a",    "v3",    "v3m",  "v4",   "v4t",  "v5",    "v5t",
+      "v5e",   "v5te",   "v5tej", "v6",   "v6j",  "v6k",  "v6hl",  "v6t2",
+      "v6kz",  "v6z",    "v6zk",  "v6-m", "v6m",  "v6sm", "v6s-m", "v7-a",
+      "v7",    "v7a",    "v7hl",  "v7l",  "v7-r", "v7r",  "v7-m",  "v7m",
+      "v7k",   "v7s",    "v7e-m", "v7em", "v8-a", "v8",   "v8a",   "v8.1-a",
+      "v8.1a", "v8.2-a", "v8.2a"};
+
+  for (unsigned i = 0; i < array_lengthof(Arch); i++) {
+    std::string arm_1 = "armeb" + (std::string)(Arch[i]);
+    std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb";
+    std::string arm_3 = "arm" + (std::string)(Arch[i]);
+    std::string thumb_1 = "thumbeb" + (std::string)(Arch[i]);
+    std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb";
+    std::string thumb_3 = "thumb" + (std::string)(Arch[i]);
+
+    EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(arm_1));
+    EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(arm_2));
+    EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian(arm_3));
+
+    EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_1));
+    EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_2));
+    EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_3));
+    if (i >= 4) {
+      EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(thumb_1));
+      EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(thumb_2));
+      EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian(thumb_3));
+
+      EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_1));
+      EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_2));
+      EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_3));
+    }
+  }
+
+  EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian("aarch64"));
+  EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian("aarch64_be"));
+
+  EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("aarch64"));
+  EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("aarch64_be"));
+  EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("arm64"));
+  EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("arm64_be"));
+}
+
+TEST(TargetParserTest, ARMparseArchProfile) {
+  for (unsigned i = 0; i < array_lengthof(ARMArch); i++) {
+    switch (ARM::parseArch(ARMArch[i])) {
+    case ARM::AK_ARMV6M:
+    case ARM::AK_ARMV7M:
+    case ARM::AK_ARMV7EM:
+    case ARM::AK_ARMV8MMainline:
+    case ARM::AK_ARMV8MBaseline:
+      EXPECT_EQ(ARM::PK_M, ARM::parseArchProfile(ARMArch[i]));
+      continue;
+    case ARM::AK_ARMV7R:
+      EXPECT_EQ(ARM::PK_R, ARM::parseArchProfile(ARMArch[i]));
+      continue;
+    case ARM::AK_ARMV7A:
+    case ARM::AK_ARMV7K:
+    case ARM::AK_ARMV8A:
+    case ARM::AK_ARMV8_1A:
+    case ARM::AK_ARMV8_2A:
+      EXPECT_EQ(ARM::PK_A, ARM::parseArchProfile(ARMArch[i]));
+      continue;
+    }
+    EXPECT_EQ(ARM::PK_INVALID, ARM::parseArchProfile(ARMArch[i]));
+  }
+}
+
+TEST(TargetParserTest, ARMparseArchVersion) {
+  for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
+    if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
+      EXPECT_EQ((ARMArch[i][4] - 48), ARM::parseArchVersion(ARMArch[i]));
+    else
+      EXPECT_EQ(5, ARM::parseArchVersion(ARMArch[i]));
+}
+
+TEST(TargetParserTest, AArch64DefaultFPU) {
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_EQ(kAArch64ARCHNames[AK].DefaultFPU,
+              AArch64::getDefaultFPU(StringRef("generic"), AK));
+
+  for (const auto &AArch64CPUName : kAArch64CPUNames)
+    EXPECT_EQ(AArch64CPUName.DefaultFPU,
+              AArch64::getDefaultFPU(AArch64CPUName.Name,
+                                     static_cast<unsigned>(AArch64CPUName.ID)));
+}
+
+TEST(TargetParserTest, AArch64DefaultExt) {
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_EQ(kAArch64ARCHNames[AK].ArchBaseExtensions,
+              AArch64::getDefaultExtensions(StringRef("generic"), AK));
+
+  for (const auto &AArch64CPUName : kAArch64CPUNames)
+    EXPECT_EQ(
+        AArch64CPUName.DefaultExt,
+        AArch64::getDefaultExtensions(
+            AArch64CPUName.Name, static_cast<unsigned>(AArch64CPUName.ID)));
+}
+
+TEST(TargetParserTest, AArch64ExtensionFeatures) {
+  std::vector<const char *> 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<const char *> Features;
+
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
+                 AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
+                    ? !AArch64::getArchFeatures(AK, Features)
+                    : AArch64::getArchFeatures(AK, Features));
 }
+
+TEST(TargetParserTest, AArch64ArchName) {
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_TRUE(AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST)
+                    ? AArch64::getArchName(AK).empty()
+                    : !AArch64::getArchName(AK).empty());
 }
 
+TEST(TargetParserTest, AArch64CPUAttr) {
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
+                 AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
+                    ? AArch64::getCPUAttr(AK).empty()
+                    : !AArch64::getCPUAttr(AK).empty());
+}
+
+TEST(TargetParserTest, AArch64SubArch) {
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
+                 AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
+                    ? AArch64::getSubArch(AK).empty()
+                    : !AArch64::getSubArch(AK).empty());
+}
+
+TEST(TargetParserTest, AArch64ArchAttr) {
+  for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
+       AK++)
+    EXPECT_TRUE(
+        AK == static_cast<unsigned>(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<AArch64::ArchExtKind>(0);
+       AEK <= AArch64::ArchExtKind::AEK_RAS;
+       AEK = static_cast<AArch64::ArchExtKind>(static_cast<unsigned>(AEK) + 1))
+    EXPECT_TRUE(contains(kAArch64ArchExtKinds, static_cast<unsigned>(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(static_cast<unsigned>(AArch64::ArchKind::AK_INVALID),
+              AArch64::parseArch(Arch[i]));
+  EXPECT_EQ(static_cast<unsigned>(AArch64::ArchKind::AK_INVALID),
+            AArch64::parseArch("aarch64"));
+  EXPECT_EQ(static_cast<unsigned>(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",  "kryo",       "vulcan"};
+
+  for (const auto &AArch64CPUName : kAArch64CPUNames)
+    EXPECT_TRUE(contains(CPU, AArch64CPUName.Name)
+                    ? (static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) !=
+                       AArch64::parseCPUArch(AArch64CPUName.Name))
+                    : (static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ==
+                       AArch64::parseCPUArch(AArch64CPUName.Name)));
+}
+}