[ARM] Move Triple::getARMCPUForArch into ARMTargetParser

[tmatheson]

Summary

This is very backend specific so either belongs in Toolchains/ARM or in
ARMTargetParser. Since it is used in lldb, ARMTargetParser made more sense.

This is part of an effort to move information about ARM/AArch64 architecture
versions, extensions and CPUs into their respective TargetParsers.

clang/lib/Driver/ToolChains/Arch/ARM.cpp

StringRef arm::getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple) {
   std::string MArch = getARMArch(Arch, Triple);
   // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
   // here means an -march=native that we can't handle, so instead return no CPU.
   if (MArch.empty())
     return StringRef();
 
   // We need to return an empty string here on invalid MArch values as the
   // various places that call this function can't cope with a null result.
-  return Triple.getARMCPUForArch(MArch);
+  return llvm::ARM::getARMCPUForArch(Triple, MArch);
 }
 
 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
 std::string arm::getARMTargetCPU(StringRef CPU, StringRef Arch,
                                  const llvm::Triple &Triple) {
   // FIXME: Warn on inconsistent use of -mcpu and -march.
   // If we have -mcpu=, use that.
   if (!CPU.empty()) {
llvm::ARM::ArchKind arm::getLLVMArchKindForARM(StringRef CPU, StringRef Arch,
                                                const llvm::Triple &Triple) {
   llvm::ARM::ArchKind ArchKind;
   if (CPU == "generic" || CPU.empty()) {
     std::string ARMArch = tools::arm::getARMArch(Arch, Triple);
     ArchKind = llvm::ARM::parseArch(ARMArch);
     if (ArchKind == llvm::ARM::ArchKind::INVALID)
       // In case of generic Arch, i.e. "arm",
       // extract arch from default cpu of the Triple
-      ArchKind = llvm::ARM::parseCPUArch(Triple.getARMCPUForArch(ARMArch));
+      ArchKind =
+          llvm::ARM::parseCPUArch(llvm::ARM::getARMCPUForArch(Triple, ARMArch));
   } else {
     // FIXME: horrible hack to get around the fact that Cortex-A7 is only an
     // armv7k triple if it's actually been specified via "-arch armv7k".
     ArchKind = (Arch == "armv7k" || Arch == "thumbv7k")
                           ? llvm::ARM::ArchKind::ARMV7K
                           : llvm::ARM::parseCPUArch(CPU);
   }
   return ArchKind;

lldb/source/Utility/ArchSpec.cpp

 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-defines.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/ARMTargetParser.h"
 #include "llvm/Support/Compiler.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static bool cores_match(const ArchSpec::Core core1, const ArchSpec::Core core2,
                         bool try_inverse, bool enforce_exact_match);
 
case ArchSpec::eCore_mips64r6el:
       cpu = "mips64r6";
       break;
     default:
       break;
     }
   }
 
   if (GetTriple().isARM())
-    cpu = GetTriple().getARMCPUForArch("").str();
+    cpu = llvm::ARM::getARMCPUForArch(GetTriple(), "").str();
   return cpu;
 }
 
 uint32_t ArchSpec::GetMachOCPUType() const {
   const CoreDefinition *core_def = FindCoreDefinition(m_core);
   if (core_def) {
     const ArchDefinitionEntry *arch_def =
         FindArchDefinitionEntry(&g_macho_arch_def, core_def->core);

llvm/include/llvm/ADT/Triple.h

public:
   /// Form a triple with a little endian variant of the current architecture.
   ///
   /// This can be used to move across "families" of architectures where useful.
   ///
   /// \returns A new triple with a little endian architecture or an unknown
   ///          architecture if no such variant can be found.
   llvm::Triple getLittleEndianArchVariant() const;
 
-  /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
-  ///
-  /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
-  /// string then the triple's arch name is used.
-  StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
-
   /// Tests whether the target triple is little endian.
   ///
   /// \returns true if the triple is little endian, false otherwise.
   bool isLittleEndian() const;
 
   /// Test whether target triples are compatible.
   bool isCompatibleWith(const Triple &Other) const;
 

llvm/include/llvm/Support/ARMTargetParser.h

 ISAKind parseArchISA(StringRef Arch);
 EndianKind parseArchEndian(StringRef Arch);
 ProfileKind parseArchProfile(StringRef Arch);
 unsigned parseArchVersion(StringRef Arch);
 
 void fillValidCPUArchList(SmallVectorImpl<StringRef> &Values);
 StringRef computeDefaultTargetABI(const Triple &TT, StringRef CPU);
 
+/// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
+///
+/// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
+/// string then the triple's arch name is used.
+StringRef getARMCPUForArch(const llvm::Triple &Triple, StringRef MArch = {});
+
 } // namespace ARM
 } // namespace llvm
 
 #endif

llvm/lib/Support/ARMTargetParser.cpp

StringRef ARM::computeDefaultTargetABI(const Triple &TT, StringRef CPU) {
   default:
     if (TT.isOSNetBSD())
       return "apcs-gnu";
     if (TT.isOSOpenBSD())
       return "aapcs-linux";
     return "aapcs";
   }
 }
+
+StringRef ARM::getARMCPUForArch(const llvm::Triple &Triple, StringRef MArch) {
+  if (MArch.empty())
+    MArch = Triple.getArchName();
+  MArch = llvm::ARM::getCanonicalArchName(MArch);
+
+  // Some defaults are forced.
+  switch (Triple.getOS()) {
+  case llvm::Triple::FreeBSD:
+  case llvm::Triple::NetBSD:
+  case llvm::Triple::OpenBSD:
+    if (!MArch.empty() && MArch == "v6")
+      return "arm1176jzf-s";
+    if (!MArch.empty() && MArch == "v7")
+      return "cortex-a8";
+    break;
+  case llvm::Triple::Win32:
+    // FIXME: this is invalid for WindowsCE
+    if (llvm::ARM::parseArchVersion(MArch) <= 7)
+      return "cortex-a9";
+    break;
+  case llvm::Triple::IOS:
+  case llvm::Triple::MacOSX:
+  case llvm::Triple::TvOS:
+  case llvm::Triple::WatchOS:
+  case llvm::Triple::DriverKit:
+    if (MArch == "v7k")
+      return "cortex-a7";
+    break;
+  default:
+    break;
+  }
+
+  if (MArch.empty())
+    return StringRef();
+
+  StringRef CPU = llvm::ARM::getDefaultCPU(MArch);
+  if (!CPU.empty() && !CPU.equals("invalid"))
+    return CPU;
+
+  // If no specific architecture version is requested, return the minimum CPU
+  // required by the OS and environment.
+  switch (Triple.getOS()) {
+  case llvm::Triple::NetBSD:
+    switch (Triple.getEnvironment()) {
+    case llvm::Triple::EABI:
+    case llvm::Triple::EABIHF:
+    case llvm::Triple::GNUEABI:
+    case llvm::Triple::GNUEABIHF:
+      return "arm926ej-s";
+    default:
+      return "strongarm";
+    }
+  case llvm::Triple::NaCl:
+  case llvm::Triple::OpenBSD:
+    return "cortex-a8";
+  default:
+    switch (Triple.getEnvironment()) {
+    case llvm::Triple::EABIHF:
+    case llvm::Triple::GNUEABIHF:
+    case llvm::Triple::MuslEABIHF:
+      return "arm1176jzf-s";
+    default:
+      return "arm7tdmi";
+    }
+  }
+
+  llvm_unreachable("invalid arch name");
+}

llvm/lib/Support/Triple.cpp

VersionTuple Triple::getMinimumSupportedOSVersion() const {
   case Triple::DriverKit:
     return VersionTuple(20, 0, 0);
   default:
     break;
   }
   return VersionTuple();
 }
 
-StringRef Triple::getARMCPUForArch(StringRef MArch) const {
-  if (MArch.empty())
-    MArch = getArchName();
-  MArch = ARM::getCanonicalArchName(MArch);
-
-  // Some defaults are forced.
-  switch (getOS()) {
-  case llvm::Triple::FreeBSD:
-  case llvm::Triple::NetBSD:
-  case llvm::Triple::OpenBSD:
-    if (!MArch.empty() && MArch == "v6")
-      return "arm1176jzf-s";
-    if (!MArch.empty() && MArch == "v7")
-      return "cortex-a8";
-    break;
-  case llvm::Triple::Win32:
-    // FIXME: this is invalid for WindowsCE
-    if (ARM::parseArchVersion(MArch) <= 7)
-      return "cortex-a9";
-    break;
-  case llvm::Triple::IOS:
-  case llvm::Triple::MacOSX:
-  case llvm::Triple::TvOS:
-  case llvm::Triple::WatchOS:
-  case llvm::Triple::DriverKit:
-    if (MArch == "v7k")
-      return "cortex-a7";
-    break;
-  default:
-    break;
-  }
-
-  if (MArch.empty())
-    return StringRef();
-
-  StringRef CPU = ARM::getDefaultCPU(MArch);
-  if (!CPU.empty() && !CPU.equals("invalid"))
-    return CPU;
-
-  // If no specific architecture version is requested, return the minimum CPU
-  // required by the OS and environment.
-  switch (getOS()) {
-  case llvm::Triple::NetBSD:
-    switch (getEnvironment()) {
-    case llvm::Triple::EABI:
-    case llvm::Triple::EABIHF:
-    case llvm::Triple::GNUEABI:
-    case llvm::Triple::GNUEABIHF:
-      return "arm926ej-s";
-    default:
-      return "strongarm";
-    }
-  case llvm::Triple::NaCl:
-  case llvm::Triple::OpenBSD:
-    return "cortex-a8";
-  default:
-    switch (getEnvironment()) {
-    case llvm::Triple::EABIHF:
-    case llvm::Triple::GNUEABIHF:
-    case llvm::Triple::MuslEABIHF:
-      return "arm1176jzf-s";
-    default:
-      return "arm7tdmi";
-    }
-  }
-
-  llvm_unreachable("invalid arch name");
-}
-
 VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
                                               const VersionTuple &Version) {
   switch (OSKind) {
   case MacOSX:
     // macOS 10.16 is canonicalized to macOS 11.
     if (Version == VersionTuple(10, 16))
       return VersionTuple(11, 0);
     [[fallthrough]];

llvm/unittests/ADT/TripleTest.cpp

TEST(TripleTest, NormalizeAndroid) {
   EXPECT_EQ("arm-unknown-linux-android16",
             Triple::normalize("arm-linux-androideabi16"));
   EXPECT_EQ("armv7a-unknown-linux-android",
             Triple::normalize("armv7a-linux-androideabi"));
   EXPECT_EQ("aarch64-unknown-linux-android21",
             Triple::normalize("aarch64-linux-android21"));
 }
 
-TEST(TripleTest, getARMCPUForArch) {
-  // Platform specific defaults.
-  {
-    llvm::Triple Triple("arm--nacl");
-    EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("arm--openbsd");
-    EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armv6-unknown-freebsd");
-    EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("thumbv6-unknown-freebsd");
-    EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armebv6-unknown-freebsd");
-    EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("arm--win32");
-    EXPECT_EQ("cortex-a9", Triple.getARMCPUForArch());
-    EXPECT_EQ("generic", Triple.getARMCPUForArch("armv8-a"));
-  }
-  // Some alternative architectures
-  {
-    llvm::Triple Triple("armv7k-apple-ios9");
-    EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armv7k-apple-watchos3");
-    EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armv7k-apple-tvos9");
-    EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
-  }
-  // armeb is permitted, but armebeb is not
-  {
-    llvm::Triple Triple("armeb-none-eabi");
-    EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armebeb-none-eabi");
-    EXPECT_EQ("", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armebv6eb-none-eabi");
-    EXPECT_EQ("", Triple.getARMCPUForArch());
-  }
-  // xscaleeb is permitted, but armebxscale is not
-  {
-    llvm::Triple Triple("xscaleeb-none-eabi");
-    EXPECT_EQ("xscale", Triple.getARMCPUForArch());
-  }
-  {
-    llvm::Triple Triple("armebxscale-none-eabi");
-    EXPECT_EQ("", Triple.getARMCPUForArch());
-  }
-}
-
 TEST(TripleTest, NormalizeARM) {
   EXPECT_EQ("armv6-unknown-netbsd-eabi",
             Triple::normalize("armv6-netbsd-eabi"));
   EXPECT_EQ("armv7-unknown-netbsd-eabi",
             Triple::normalize("armv7-netbsd-eabi"));
   EXPECT_EQ("armv6eb-unknown-netbsd-eabi",
             Triple::normalize("armv6eb-netbsd-eabi"));
   EXPECT_EQ("armv7eb-unknown-netbsd-eabi",

llvm/unittests/Support/TargetParserTest.cpp

 //===----------- TargetParser.cpp - Target Parser -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Support/TargetParser.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Support/AArch64TargetParser.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/TargetParser.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 
 namespace {
 const char *ARMArch[] = {

 TEST(TargetParserTest, ARMparseArchVersion) {
   for (unsigned i = 0; i < std::size(ARMArch); i++)
     if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
       EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
     else
       EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
 }
 
+TEST(TargetParserTest, getARMCPUForArch) {
+  // Platform specific defaults.
+  {
+    llvm::Triple Triple("arm--nacl");
+    EXPECT_EQ("cortex-a8", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("arm--openbsd");
+    EXPECT_EQ("cortex-a8", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armv6-unknown-freebsd");
+    EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("thumbv6-unknown-freebsd");
+    EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armebv6-unknown-freebsd");
+    EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("arm--win32");
+    EXPECT_EQ("cortex-a9", ARM::getARMCPUForArch(Triple));
+    EXPECT_EQ("generic", ARM::getARMCPUForArch(Triple, "armv8-a"));
+  }
+  // Some alternative architectures
+  {
+    llvm::Triple Triple("armv7k-apple-ios9");
+    EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armv7k-apple-watchos3");
+    EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armv7k-apple-tvos9");
+    EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple));
+  }
+  // armeb is permitted, but armebeb is not
+  {
+    llvm::Triple Triple("armeb-none-eabi");
+    EXPECT_EQ("arm7tdmi", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armebeb-none-eabi");
+    EXPECT_EQ("", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armebv6eb-none-eabi");
+    EXPECT_EQ("", ARM::getARMCPUForArch(Triple));
+  }
+  // xscaleeb is permitted, but armebxscale is not
+  {
+    llvm::Triple Triple("xscaleeb-none-eabi");
+    EXPECT_EQ("xscale", ARM::getARMCPUForArch(Triple));
+  }
+  {
+    llvm::Triple Triple("armebxscale-none-eabi");
+    EXPECT_EQ("", ARM::getARMCPUForArch(Triple));
+  }
+}
+
 class AArch64CPUTestFixture
     : public ::testing::TestWithParam<ARMCPUTestParams> {};
 
 TEST_P(AArch64CPUTestFixture, testAArch64CPU) {
   ARMCPUTestParams params = GetParam();
 
   AArch64::ArchKind AK = AArch64::parseCPUArch(params.CPUName);
   EXPECT_EQ(params.ExpectedArch, AArch64::getArchName(AK));