[Triple] Stop abusing a class to have only static methods and just use

the namespace that we are already using for the enums that are produced
by the parsing.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@246367 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Support/TargetParser.h b/include/llvm/Support/TargetParser.h
index 605f74e42b6eb6ed1a36327e7c624d132e71a793..585dbe5706484ab069bc036c5c106fd774470b07 100644 (file)
--- a/include/llvm/Support/TargetParser.h
+++ b/include/llvm/Support/TargetParser.h
@@ -165,49 +165,39 @@ namespace ARM {
     PK_R,
     PK_M
   };
     PK_R,
     PK_M
   };

-} // namespace ARM
-
-// Target Parsers, one per architecture.
-class ARMTargetParser {
-  static StringRef getHWDivSynonym(StringRef HWDiv);
-  static StringRef getFPUSynonym(StringRef FPU);
-  static StringRef getArchSynonym(StringRef Arch);

 
 

-public:
-  static StringRef getCanonicalArchName(StringRef Arch);
+  StringRef getCanonicalArchName(StringRef Arch);

 
   // Information by ID
 
   // Information by ID

-  static const char * getFPUName(unsigned FPUKind);
-  static     unsigned getFPUVersion(unsigned FPUKind);
-  static     unsigned getFPUNeonSupportLevel(unsigned FPUKind);
-  static     unsigned getFPURestriction(unsigned FPUKind);
-  static     unsigned getDefaultFPU(StringRef CPU);
+  const char * getFPUName(unsigned FPUKind);
+  unsigned getFPUVersion(unsigned FPUKind);
+  unsigned getFPUNeonSupportLevel(unsigned FPUKind);
+  unsigned getFPURestriction(unsigned FPUKind);
+  unsigned getDefaultFPU(StringRef CPU);

   // FIXME: This should be moved to TargetTuple once it exists
   // FIXME: This should be moved to TargetTuple once it exists

-  static       bool   getFPUFeatures(unsigned FPUKind,
-                                     std::vector<const char*> &Features);
-  static       bool   getHWDivFeatures(unsigned HWDivKind,
-                                       std::vector<const char*> &Features);
-  static const char * getArchName(unsigned ArchKind);
-  static   unsigned   getArchAttr(unsigned ArchKind);
-  static const char * getCPUAttr(unsigned ArchKind);
-  static const char * getSubArch(unsigned ArchKind);
-  static const char * getArchExtName(unsigned ArchExtKind);
-  static const char * getHWDivName(unsigned HWDivKind);
-  static const char * getDefaultCPU(StringRef Arch);
+  bool getFPUFeatures(unsigned FPUKind, std::vector<const char *> &Features);
+  bool getHWDivFeatures(unsigned HWDivKind,
+                        std::vector<const char *> &Features);
+  const char *getArchName(unsigned ArchKind);
+  unsigned getArchAttr(unsigned ArchKind);
+  const char *getCPUAttr(unsigned ArchKind);
+  const char *getSubArch(unsigned ArchKind);
+  const char *getArchExtName(unsigned ArchExtKind);
+  const char *getHWDivName(unsigned HWDivKind);
+  const char *getDefaultCPU(StringRef Arch);

 
   // Parser
 
   // Parser

-  static unsigned parseHWDiv(StringRef HWDiv);
-  static unsigned parseFPU(StringRef FPU);
-  static unsigned parseArch(StringRef Arch);
-  static unsigned parseArchExt(StringRef ArchExt);
-  static unsigned parseCPUArch(StringRef CPU);
-  static unsigned parseArchISA(StringRef Arch);
-  static unsigned parseArchEndian(StringRef Arch);
-  static unsigned parseArchProfile(StringRef Arch);
-  static unsigned parseArchVersion(StringRef Arch);
-
-};
+  unsigned parseHWDiv(StringRef HWDiv);
+  unsigned parseFPU(StringRef FPU);
+  unsigned parseArch(StringRef Arch);
+  unsigned parseArchExt(StringRef ArchExt);
+  unsigned parseCPUArch(StringRef CPU);
+  unsigned parseArchISA(StringRef Arch);
+  unsigned parseArchEndian(StringRef Arch);
+  unsigned parseArchProfile(StringRef Arch);
+  unsigned parseArchVersion(StringRef Arch);

 
 

+} // namespace ARM

 } // namespace llvm
 
 #endif
 } // namespace llvm
 
 #endif

diff --git a/lib/Support/TargetParser.cpp b/lib/Support/TargetParser.cpp
index dc385babcbd84cff8ac57a73fdfd4f9c12529a18..74f13fc944769ceab873c8d76e2c7ab10f044cd5 100644 (file)
--- a/lib/Support/TargetParser.cpp
+++ b/lib/Support/TargetParser.cpp
@@ -249,31 +249,31 @@ struct {
 // Information by ID
 // ======================================================= //
 
 // Information by ID
 // ======================================================= //
 

-const char *ARMTargetParser::getFPUName(unsigned FPUKind) {
+const char *llvm::ARM::getFPUName(unsigned FPUKind) {

   if (FPUKind >= ARM::FK_LAST)
     return nullptr;
   return FPUNames[FPUKind].Name;
 }
 
   if (FPUKind >= ARM::FK_LAST)
     return nullptr;
   return FPUNames[FPUKind].Name;
 }
 

-unsigned ARMTargetParser::getFPUVersion(unsigned FPUKind) {
+unsigned llvm::ARM::getFPUVersion(unsigned FPUKind) {

   if (FPUKind >= ARM::FK_LAST)
     return 0;
   return FPUNames[FPUKind].FPUVersion;
 }
 
   if (FPUKind >= ARM::FK_LAST)
     return 0;
   return FPUNames[FPUKind].FPUVersion;
 }
 

-unsigned ARMTargetParser::getFPUNeonSupportLevel(unsigned FPUKind) {
+unsigned llvm::ARM::getFPUNeonSupportLevel(unsigned FPUKind) {

   if (FPUKind >= ARM::FK_LAST)
     return 0;
   return FPUNames[FPUKind].NeonSupport;
 }
 
   if (FPUKind >= ARM::FK_LAST)
     return 0;
   return FPUNames[FPUKind].NeonSupport;
 }
 

-unsigned ARMTargetParser::getFPURestriction(unsigned FPUKind) {
+unsigned llvm::ARM::getFPURestriction(unsigned FPUKind) {

   if (FPUKind >= ARM::FK_LAST)
     return 0;
   return FPUNames[FPUKind].Restriction;
 }
 
   if (FPUKind >= ARM::FK_LAST)
     return 0;
   return FPUNames[FPUKind].Restriction;
 }
 

-unsigned ARMTargetParser::getDefaultFPU(StringRef CPU) {
+unsigned llvm::ARM::getDefaultFPU(StringRef CPU) {

   for (const auto C : CPUNames) {
     if (CPU == C.Name)
       return C.DefaultFPU;
   for (const auto C : CPUNames) {
     if (CPU == C.Name)
       return C.DefaultFPU;


@@ -281,7 +281,7 @@ unsigned ARMTargetParser::getDefaultFPU(StringRef CPU) {
   return ARM::FK_INVALID;
 }
 
   return ARM::FK_INVALID;
 }
 

-bool ARMTargetParser::getHWDivFeatures(unsigned HWDivKind,
+bool llvm::ARM::getHWDivFeatures(unsigned HWDivKind,

                                        std::vector<const char *> &Features) {
 
   if (HWDivKind == ARM::AEK_INVALID)
                                        std::vector<const char *> &Features) {
 
   if (HWDivKind == ARM::AEK_INVALID)


@@ -300,7 +300,7 @@ bool ARMTargetParser::getHWDivFeatures(unsigned HWDivKind,
   return true;
 }
 
   return true;
 }
 

-bool ARMTargetParser::getFPUFeatures(unsigned FPUKind,
+bool llvm::ARM::getFPUFeatures(unsigned FPUKind,

                                      std::vector<const char *> &Features) {
 
   if (FPUKind >= ARM::FK_LAST || FPUKind == ARM::FK_INVALID)
                                      std::vector<const char *> &Features) {
 
   if (FPUKind >= ARM::FK_LAST || FPUKind == ARM::FK_INVALID)


@@ -381,31 +381,31 @@ bool ARMTargetParser::getFPUFeatures(unsigned FPUKind,
   return true;
 }
 
   return true;
 }
 

-const char *ARMTargetParser::getArchName(unsigned ArchKind) {
+const char *llvm::ARM::getArchName(unsigned ArchKind) {

   if (ArchKind >= ARM::AK_LAST)
     return nullptr;
   return ARCHNames[ArchKind].Name;
 }
 
   if (ArchKind >= ARM::AK_LAST)
     return nullptr;
   return ARCHNames[ArchKind].Name;
 }
 

-const char *ARMTargetParser::getCPUAttr(unsigned ArchKind) {
+const char *llvm::ARM::getCPUAttr(unsigned ArchKind) {

   if (ArchKind >= ARM::AK_LAST)
     return nullptr;
   return ARCHNames[ArchKind].CPUAttr;
 }
 
   if (ArchKind >= ARM::AK_LAST)
     return nullptr;
   return ARCHNames[ArchKind].CPUAttr;
 }
 

-const char *ARMTargetParser::getSubArch(unsigned ArchKind) {
+const char *llvm::ARM::getSubArch(unsigned ArchKind) {

   if (ArchKind >= ARM::AK_LAST)
     return nullptr;
   return ARCHNames[ArchKind].SubArch;
 }
 
   if (ArchKind >= ARM::AK_LAST)
     return nullptr;
   return ARCHNames[ArchKind].SubArch;
 }
 

-unsigned ARMTargetParser::getArchAttr(unsigned ArchKind) {
+unsigned llvm::ARM::getArchAttr(unsigned ArchKind) {

   if (ArchKind >= ARM::AK_LAST)
     return ARMBuildAttrs::CPUArch::Pre_v4;
   return ARCHNames[ArchKind].ArchAttr;
 }
 
   if (ArchKind >= ARM::AK_LAST)
     return ARMBuildAttrs::CPUArch::Pre_v4;
   return ARCHNames[ArchKind].ArchAttr;
 }
 

-const char *ARMTargetParser::getArchExtName(unsigned ArchExtKind) {
+const char *llvm::ARM::getArchExtName(unsigned ArchExtKind) {

   for (const auto AE : ARCHExtNames) {
     if (ArchExtKind == AE.ID)
       return AE.Name;
   for (const auto AE : ARCHExtNames) {
     if (ArchExtKind == AE.ID)
       return AE.Name;


@@ -413,7 +413,7 @@ const char *ARMTargetParser::getArchExtName(unsigned ArchExtKind) {
   return nullptr;
 }
 
   return nullptr;
 }
 

-const char *ARMTargetParser::getHWDivName(unsigned HWDivKind) {
+const char *llvm::ARM::getHWDivName(unsigned HWDivKind) {

   for (const auto D : HWDivNames) {
     if (HWDivKind == D.ID)
       return D.Name;
   for (const auto D : HWDivNames) {
     if (HWDivKind == D.ID)
       return D.Name;


@@ -421,7 +421,7 @@ const char *ARMTargetParser::getHWDivName(unsigned HWDivKind) {
   return nullptr;
 }
 
   return nullptr;
 }
 

-const char *ARMTargetParser::getDefaultCPU(StringRef Arch) {
+const char *llvm::ARM::getDefaultCPU(StringRef Arch) {

   unsigned AK = parseArch(Arch);
   if (AK == ARM::AK_INVALID)
     return nullptr;
   unsigned AK = parseArch(Arch);
   if (AK == ARM::AK_INVALID)
     return nullptr;


@@ -438,13 +438,13 @@ const char *ARMTargetParser::getDefaultCPU(StringRef Arch) {
 // Parsers
 // ======================================================= //
 
 // Parsers
 // ======================================================= //
 

-StringRef ARMTargetParser::getHWDivSynonym(StringRef HWDiv) {
+static StringRef getHWDivSynonym(StringRef HWDiv) {

   return StringSwitch<StringRef>(HWDiv)
     .Case("thumb,arm", "arm,thumb")
     .Default(HWDiv);
 }
 
   return StringSwitch<StringRef>(HWDiv)
     .Case("thumb,arm", "arm,thumb")
     .Default(HWDiv);
 }
 

-StringRef ARMTargetParser::getFPUSynonym(StringRef FPU) {
+static StringRef getFPUSynonym(StringRef FPU) {

   return StringSwitch<StringRef>(FPU)
     .Cases("fpa", "fpe2", "fpe3", "maverick", "invalid") // Unsupported
     .Case("vfp2", "vfpv2")
   return StringSwitch<StringRef>(FPU)
     .Cases("fpa", "fpe2", "fpe3", "maverick", "invalid") // Unsupported
     .Case("vfp2", "vfpv2")


@@ -461,7 +461,7 @@ StringRef ARMTargetParser::getFPUSynonym(StringRef FPU) {
     .Default(FPU);
 }
 
     .Default(FPU);
 }
 

-StringRef ARMTargetParser::getArchSynonym(StringRef Arch) {
+static StringRef getArchSynonym(StringRef Arch) {

   return StringSwitch<StringRef>(Arch)
     .Case("v6sm", "v6s-m")
     .Case("v6m", "v6-m")
   return StringSwitch<StringRef>(Arch)
     .Case("v6sm", "v6s-m")
     .Case("v6m", "v6-m")


@@ -478,7 +478,7 @@ StringRef ARMTargetParser::getArchSynonym(StringRef Arch) {
 // (iwmmxt|xscale)(eb)? is also permitted. If the former, return
 // "v.+", if the latter, return unmodified string, minus 'eb'.
 // If invalid, return empty string.
 // (iwmmxt|xscale)(eb)? is also permitted. If the former, return
 // "v.+", if the latter, return unmodified string, minus 'eb'.
 // If invalid, return empty string.

-StringRef ARMTargetParser::getCanonicalArchName(StringRef Arch) {
+StringRef llvm::ARM::getCanonicalArchName(StringRef Arch) {

   size_t offset = StringRef::npos;
   StringRef A = Arch;
   StringRef Error = "";
   size_t offset = StringRef::npos;
   StringRef A = Arch;
   StringRef Error = "";


@@ -527,7 +527,7 @@ StringRef ARMTargetParser::getCanonicalArchName(StringRef Arch) {
   return A;
 }
 
   return A;
 }
 

-unsigned ARMTargetParser::parseHWDiv(StringRef HWDiv) {
+unsigned llvm::ARM::parseHWDiv(StringRef HWDiv) {

   StringRef Syn = getHWDivSynonym(HWDiv);
   for (const auto D : HWDivNames) {
     if (Syn == D.Name)
   StringRef Syn = getHWDivSynonym(HWDiv);
   for (const auto D : HWDivNames) {
     if (Syn == D.Name)


@@ -536,7 +536,7 @@ unsigned ARMTargetParser::parseHWDiv(StringRef HWDiv) {
   return ARM::AEK_INVALID;
 }
 
   return ARM::AEK_INVALID;
 }
 

-unsigned ARMTargetParser::parseFPU(StringRef FPU) {
+unsigned llvm::ARM::parseFPU(StringRef FPU) {

   StringRef Syn = getFPUSynonym(FPU);
   for (const auto F : FPUNames) {
     if (Syn == F.Name)
   StringRef Syn = getFPUSynonym(FPU);
   for (const auto F : FPUNames) {
     if (Syn == F.Name)


@@ -546,7 +546,7 @@ unsigned ARMTargetParser::parseFPU(StringRef FPU) {
 }
 
 // Allows partial match, ex. "v7a" matches "armv7a".
 }
 
 // Allows partial match, ex. "v7a" matches "armv7a".

-unsigned ARMTargetParser::parseArch(StringRef Arch) {
+unsigned llvm::ARM::parseArch(StringRef Arch) {

   Arch = getCanonicalArchName(Arch);
   StringRef Syn = getArchSynonym(Arch);
   for (const auto A : ARCHNames) {
   Arch = getCanonicalArchName(Arch);
   StringRef Syn = getArchSynonym(Arch);
   for (const auto A : ARCHNames) {


@@ -556,7 +556,7 @@ unsigned ARMTargetParser::parseArch(StringRef Arch) {
   return ARM::AK_INVALID;
 }
 
   return ARM::AK_INVALID;
 }
 

-unsigned ARMTargetParser::parseArchExt(StringRef ArchExt) {
+unsigned llvm::ARM::parseArchExt(StringRef ArchExt) {

   for (const auto A : ARCHExtNames) {
     if (ArchExt == A.Name)
       return A.ID;
   for (const auto A : ARCHExtNames) {
     if (ArchExt == A.Name)
       return A.ID;


@@ -564,7 +564,7 @@ unsigned ARMTargetParser::parseArchExt(StringRef ArchExt) {
   return ARM::AEK_INVALID;
 }
 
   return ARM::AEK_INVALID;
 }
 

-unsigned ARMTargetParser::parseCPUArch(StringRef CPU) {
+unsigned llvm::ARM::parseCPUArch(StringRef CPU) {

   for (const auto C : CPUNames) {
     if (CPU == C.Name)
       return C.ArchID;
   for (const auto C : CPUNames) {
     if (CPU == C.Name)
       return C.ArchID;


@@ -573,7 +573,7 @@ unsigned ARMTargetParser::parseCPUArch(StringRef CPU) {
 }
 
 // ARM, Thumb, AArch64
 }
 
 // ARM, Thumb, AArch64

-unsigned ARMTargetParser::parseArchISA(StringRef Arch) {
+unsigned llvm::ARM::parseArchISA(StringRef Arch) {

   return StringSwitch<unsigned>(Arch)
       .StartsWith("aarch64", ARM::IK_AARCH64)
       .StartsWith("arm64",   ARM::IK_AARCH64)
   return StringSwitch<unsigned>(Arch)
       .StartsWith("aarch64", ARM::IK_AARCH64)
       .StartsWith("arm64",   ARM::IK_AARCH64)


@@ -583,7 +583,7 @@ unsigned ARMTargetParser::parseArchISA(StringRef Arch) {
 }
 
 // Little/Big endian
 }
 
 // Little/Big endian

-unsigned ARMTargetParser::parseArchEndian(StringRef Arch) {
+unsigned llvm::ARM::parseArchEndian(StringRef Arch) {

   if (Arch.startswith("armeb") ||
       Arch.startswith("thumbeb") ||
       Arch.startswith("aarch64_be"))
   if (Arch.startswith("armeb") ||
       Arch.startswith("thumbeb") ||
       Arch.startswith("aarch64_be"))


@@ -603,7 +603,7 @@ unsigned ARMTargetParser::parseArchEndian(StringRef Arch) {
 }
 
 // Profile A/R/M
 }
 
 // Profile A/R/M

-unsigned ARMTargetParser::parseArchProfile(StringRef Arch) {
+unsigned llvm::ARM::parseArchProfile(StringRef Arch) {

   Arch = getCanonicalArchName(Arch);
   switch(parseArch(Arch)) {
   case ARM::AK_ARMV6M:
   Arch = getCanonicalArchName(Arch);
   switch(parseArch(Arch)) {
   case ARM::AK_ARMV6M:


@@ -624,7 +624,7 @@ unsigned ARMTargetParser::parseArchProfile(StringRef Arch) {
 }
 
 // Version number (ex. v7 = 7).
 }
 
 // Version number (ex. v7 = 7).

-unsigned ARMTargetParser::parseArchVersion(StringRef Arch) {
+unsigned llvm::ARM::parseArchVersion(StringRef Arch) {

   Arch = getCanonicalArchName(Arch);
   switch(parseArch(Arch)) {
   case ARM::AK_ARMV2:
   Arch = getCanonicalArchName(Arch);
   switch(parseArch(Arch)) {
   case ARM::AK_ARMV2:

diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp
index 201d352b85d347364b7fec0077d70138371b4951..86b2d316a28cf01f92327b0dc7486a08a3e2d23e 100644 (file)
--- a/lib/Support/Triple.cpp
+++ b/lib/Support/Triple.cpp
@@ -267,8 +267,8 @@ Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
 }
 
 static Triple::ArchType parseARMArch(StringRef ArchName) {
 }
 
 static Triple::ArchType parseARMArch(StringRef ArchName) {

-  unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
-  unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
+  unsigned ISA = ARM::parseArchISA(ArchName);
+  unsigned ENDIAN = ARM::parseArchEndian(ArchName);

 
   Triple::ArchType arch = Triple::UnknownArch;
   switch (ENDIAN) {
 
   Triple::ArchType arch = Triple::UnknownArch;
   switch (ENDIAN) {


@@ -302,7 +302,7 @@ static Triple::ArchType parseARMArch(StringRef ArchName) {
   }
   }
 
   }
   }
 

-  ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
+  ArchName = ARM::getCanonicalArchName(ArchName);

   if (ArchName.empty())
     return Triple::UnknownArch;
 
   if (ArchName.empty())
     return Triple::UnknownArch;
 


@@ -312,8 +312,8 @@ static Triple::ArchType parseARMArch(StringRef ArchName) {
     return Triple::UnknownArch;
 
   // Thumb only for v6m
     return Triple::UnknownArch;
 
   // Thumb only for v6m

-  unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
-  unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
+  unsigned Profile = ARM::parseArchProfile(ArchName);
+  unsigned Version = ARM::parseArchVersion(ArchName);

   if (Profile == ARM::PK_M && Version == 6) {
     if (ENDIAN == ARM::EK_BIG)
       return Triple::thumbeb;
   if (Profile == ARM::PK_M && Version == 6) {
     if (ENDIAN == ARM::EK_BIG)
       return Triple::thumbeb;


@@ -446,7 +446,7 @@ static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
 }
 
 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
 }
 
 static Triple::SubArchType parseSubArch(StringRef SubArchName) {

-  StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
+  StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);

 
   // For now, this is the small part. Early return.
   if (ARMSubArch.empty())
 
   // For now, this is the small part. Early return.
   if (ARMSubArch.empty())


@@ -457,7 +457,7 @@ static Triple::SubArchType parseSubArch(StringRef SubArchName) {
       .Default(Triple::NoSubArch);
 
   // ARM sub arch.
       .Default(Triple::NoSubArch);
 
   // ARM sub arch.

-  switch(ARMTargetParser::parseArch(ARMSubArch)) {
+  switch(ARM::parseArch(ARMSubArch)) {

   case ARM::AK_ARMV4:
     return Triple::NoSubArch;
   case ARM::AK_ARMV4T:
   case ARM::AK_ARMV4:
     return Triple::NoSubArch;
   case ARM::AK_ARMV4T:


@@ -1293,7 +1293,7 @@ Triple Triple::getLittleEndianArchVariant() const {
 const char *Triple::getARMCPUForArch(StringRef MArch) const {
   if (MArch.empty())
     MArch = getArchName();
 const char *Triple::getARMCPUForArch(StringRef MArch) const {
   if (MArch.empty())
     MArch = getArchName();

-  MArch = ARMTargetParser::getCanonicalArchName(MArch);
+  MArch = ARM::getCanonicalArchName(MArch);

 
   // Some defaults are forced.
   switch (getOS()) {
 
   // Some defaults are forced.
   switch (getOS()) {


@@ -1312,7 +1312,7 @@ const char *Triple::getARMCPUForArch(StringRef MArch) const {
   if (MArch.empty())
     return nullptr;
 
   if (MArch.empty())
     return nullptr;
 

-  const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
+  const char *CPU = ARM::getDefaultCPU(MArch);

   if (CPU)
     return CPU;
 
   if (CPU)
     return CPU;
 

diff --git a/lib/Target/ARM/AsmParser/ARMAsmParser.cpp b/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
index 2d291bf8652cbcd5128a05d32364b5610016aef1..2e467a33484046d3fdd7e0a5dc36a7f4bc0ed9f0 100644 (file)
--- a/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
+++ b/lib/Target/ARM/AsmParser/ARMAsmParser.cpp
@@ -9016,7 +9016,7 @@ bool ARMAsmParser::parseDirectiveUnreq(SMLoc L) {
 bool ARMAsmParser::parseDirectiveArch(SMLoc L) {
   StringRef Arch = getParser().parseStringToEndOfStatement().trim();
 
 bool ARMAsmParser::parseDirectiveArch(SMLoc L) {
   StringRef Arch = getParser().parseStringToEndOfStatement().trim();
 

-  unsigned ID = ARMTargetParser::parseArch(Arch);
+  unsigned ID = ARM::parseArch(Arch);

 
   if (ID == ARM::AK_INVALID) {
     Error(L, "Unknown arch name");
 
   if (ID == ARM::AK_INVALID) {
     Error(L, "Unknown arch name");


@@ -9163,9 +9163,9 @@ bool ARMAsmParser::parseDirectiveFPU(SMLoc L) {
   SMLoc FPUNameLoc = getTok().getLoc();
   StringRef FPU = getParser().parseStringToEndOfStatement().trim();
 
   SMLoc FPUNameLoc = getTok().getLoc();
   StringRef FPU = getParser().parseStringToEndOfStatement().trim();
 

-  unsigned ID = ARMTargetParser::parseFPU(FPU);
+  unsigned ID = ARM::parseFPU(FPU);

   std::vector<const char *> Features;
   std::vector<const char *> Features;

-  if (!ARMTargetParser::getFPUFeatures(ID, Features)) {
+  if (!ARM::getFPUFeatures(ID, Features)) {

     Error(FPUNameLoc, "Unknown FPU name");
     return false;
   }
     Error(FPUNameLoc, "Unknown FPU name");
     return false;
   }


@@ -9809,7 +9809,7 @@ bool ARMAsmParser::parseDirectiveObjectArch(SMLoc L) {
   SMLoc ArchLoc = Parser.getTok().getLoc();
   getLexer().Lex();
 
   SMLoc ArchLoc = Parser.getTok().getLoc();
   getLexer().Lex();
 

-  unsigned ID = ARMTargetParser::parseArch(Arch);
+  unsigned ID = ARM::parseArch(Arch);

 
   if (ID == ARM::AK_INVALID) {
     Error(ArchLoc, "unknown architecture '" + Arch + "'");
 
   if (ID == ARM::AK_INVALID) {
     Error(ArchLoc, "unknown architecture '" + Arch + "'");


@@ -9934,7 +9934,7 @@ bool ARMAsmParser::parseDirectiveArchExtension(SMLoc L) {
     EnableFeature = false;
     Name = Name.substr(2);
   }
     EnableFeature = false;
     Name = Name.substr(2);
   }

-  unsigned FeatureKind = ARMTargetParser::parseArchExt(Name);
+  unsigned FeatureKind = ARM::parseArchExt(Name);

   if (FeatureKind == ARM::AEK_INVALID)
     Error(ExtLoc, "unknown architectural extension: " + Name);
 
   if (FeatureKind == ARM::AEK_INVALID)
     Error(ExtLoc, "unknown architectural extension: " + Name);
 

diff --git a/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp b/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
index 3b01a25fb15194603359d017caab86e5884d5b4f..1fe2dbe78665e65891975eaeb9ff58959c5e5041 100644 (file)
--- a/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
+++ b/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
@@ -745,7 +745,7 @@ void ARMAsmBackend::applyFixup(const MCFixup &Fixup, char *Data,
 }
 
 static MachO::CPUSubTypeARM getMachOSubTypeFromArch(StringRef Arch) {
 }
 
 static MachO::CPUSubTypeARM getMachOSubTypeFromArch(StringRef Arch) {

-  unsigned AK = ARMTargetParser::parseArch(Arch);
+  unsigned AK = ARM::parseArch(Arch);

   switch (AK) {
   default:
     return MachO::CPU_SUBTYPE_ARM_V7;
   switch (AK) {
   default:
     return MachO::CPU_SUBTYPE_ARM_V7;

diff --git a/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp b/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
index d17fdb95dbdf499baa176ea3475945a4e6f361d2..a969d30041af3d6f7add023c7befb7f0def12243 100644 (file)
--- a/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
+++ b/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
@@ -195,16 +195,16 @@ void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
   OS << "\n";
 }
 void ARMTargetAsmStreamer::emitArch(unsigned Arch) {
   OS << "\n";
 }
 void ARMTargetAsmStreamer::emitArch(unsigned Arch) {

-  OS << "\t.arch\t" << ARMTargetParser::getArchName(Arch) << "\n";
+  OS << "\t.arch\t" << ARM::getArchName(Arch) << "\n";

 }
 void ARMTargetAsmStreamer::emitArchExtension(unsigned ArchExt) {
 }
 void ARMTargetAsmStreamer::emitArchExtension(unsigned ArchExt) {

-  OS << "\t.arch_extension\t" << ARMTargetParser::getArchExtName(ArchExt) << "\n";
+  OS << "\t.arch_extension\t" << ARM::getArchExtName(ArchExt) << "\n";

 }
 void ARMTargetAsmStreamer::emitObjectArch(unsigned Arch) {
 }
 void ARMTargetAsmStreamer::emitObjectArch(unsigned Arch) {

-  OS << "\t.object_arch\t" << ARMTargetParser::getArchName(Arch) << '\n';
+  OS << "\t.object_arch\t" << ARM::getArchName(Arch) << '\n';

 }
 void ARMTargetAsmStreamer::emitFPU(unsigned FPU) {
 }
 void ARMTargetAsmStreamer::emitFPU(unsigned FPU) {

-  OS << "\t.fpu\t" << ARMTargetParser::getFPUName(FPU) << "\n";
+  OS << "\t.fpu\t" << ARM::getFPUName(FPU) << "\n";

 }
 void ARMTargetAsmStreamer::finishAttributeSection() {
 }
 }
 void ARMTargetAsmStreamer::finishAttributeSection() {
 }


@@ -684,16 +684,16 @@ void ARMTargetELFStreamer::emitArchDefaultAttributes() {
   using namespace ARMBuildAttrs;
 
   setAttributeItem(CPU_name,
   using namespace ARMBuildAttrs;
 
   setAttributeItem(CPU_name,

-                   ARMTargetParser::getCPUAttr(Arch),
+                   ARM::getCPUAttr(Arch),

                    false);
 
   if (EmittedArch == ARM::AK_INVALID)
     setAttributeItem(CPU_arch,
                    false);
 
   if (EmittedArch == ARM::AK_INVALID)
     setAttributeItem(CPU_arch,

-                     ARMTargetParser::getArchAttr(Arch),
+                     ARM::getArchAttr(Arch),

                      false);
   else
     setAttributeItem(CPU_arch,
                      false);
   else
     setAttributeItem(CPU_arch,

-                     ARMTargetParser::getArchAttr(EmittedArch),
+                     ARM::getArchAttr(EmittedArch),

                      false);
 
   switch (Arch) {
                      false);
 
   switch (Arch) {