Move logic from llvm::Triple::getARMCPUForArch to driver::tools::arm::getARMCPUForMArch

[dschuff]

Summary

This is its only consumer, and this kind of logic belongs in the driver anyway.

[dschuff]

I tried to also bring the couple of relevant unittests in llvm/unittests/ADT/unittests but there seems to be no sane way to create an Arg (for the ArgList) for testing (without going through the same steps ParseArgs does). I'm open to suggestions on that?

[rengolin]

Did you remove the out-of-line function?

lib/Driver/Tools.cpp

5544

Move this switch inside the identical one below, after the StringSwitch.

[dschuff]

The out of line function is on the LLVM side, so that will be a separate commit (D8637)

lib/Driver/Tools.cpp

5544

I don't think that will work. This logic is supposed to override the StringSwitch; e.g. if the OS is FreeBSD and MArch is "armv6" then the CPU is supposed to be "arm1176jzf-s" but if this switch is moved, then the StringSwitch logic will return "arm1136jf-s"

[rengolin]

If the out-of-line is in LLVM, then there's no way of knowing this is the only user. Any other front-end of separate project can be using it, unfortunately.

Being so, don't add this into Clang and lets refactor this in LLVM.

A move to clean up that mess should be done once we have a common target description and warning for at least one release.

lib/Driver/Tools.cpp

5544

The string switch will only return arm1136 if the string is "armv6", I thought you said your string was "arm".

the whole point of the switch below is to catch all the rest, and that's what it seems your case is.

[dschuff]

OK, so we can abandon this and go back to D8589

lib/Driver/Tools.cpp

if (MArch == "native") {
     std::string CPU = llvm::sys::getHostCPUName();
     if (CPU != "generic") {
       // Translate the native cpu into the architecture. The switch below will
       // then chose the minimum cpu for that arch.
       MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
     }
   }
 
-  return Triple.getARMCPUForArch(MArch);
+  switch (Triple.getOS()) {
+  case llvm::Triple::FreeBSD:
+  case llvm::Triple::NetBSD:
+    if (MArch == "armv6")
+      return "arm1176jzf-s";
+    break;
+  case llvm::Triple::Win32:
+    // FIXME: this is invalid for WindowsCE
+    return "cortex-a9";
+  case llvm::Triple::NaCl:
+    if (MArch == "arm")
+      return "cortex-a9";
+    break;
+  default:
+    break;
+  }
+
+  // Now that MArch is set, pick the cpu.
+  const char *result = nullptr;
+  size_t offset = StringRef::npos;
+  if (MArch.startswith("arm"))
+    offset = 3;
+  if (MArch.startswith("thumb"))
+    offset = 5;
+  if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb")
+    offset += 2;
+  if (MArch.endswith("eb"))
+    MArch = MArch.substr(0, MArch.size() - 2);
+  if (offset != StringRef::npos)
+    result = llvm::StringSwitch<const char *>(MArch.substr(offset))
+      .Cases("v2", "v2a", "arm2")
+      .Case("v3", "arm6")
+      .Case("v3m", "arm7m")
+      .Case("v4", "strongarm")
+      .Case("v4t", "arm7tdmi")
+      .Cases("v5", "v5t", "arm10tdmi")
+      .Cases("v5e", "v5te", "arm1022e")
+      .Case("v5tej", "arm926ej-s")
+      .Case("v6", "arm1136jf-s")
+      .Case("v6j", "arm1136j-s")
+      .Cases("v6k", "v6z", "v6zk", "arm1176jzf-s")
+      .Case("v6t2", "arm1156t2-s")
+      .Cases("v6m", "v6-m", "v6sm", "v6s-m", "cortex-m0")
+      .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8")
+      .Cases("v7s", "v7-s", "swift")
+      .Cases("v7r", "v7-r", "cortex-r4")
+      .Cases("v7m", "v7-m", "cortex-m3")
+      .Cases("v7em", "v7e-m", "cortex-m4")
+      .Cases("v8", "v8a", "v8-a", "cortex-a53")
+      .Default(nullptr);
+  else
+    result = llvm::StringSwitch<const char *>(MArch)
+      .Case("ep9312", "ep9312")
+      .Case("iwmmxt", "iwmmxt")
+      .Case("xscale", "xscale")
+      .Default(nullptr);
+
+  if (result)
+    return result;
+
+  // If all else failed, return the most base CPU with thumb interworking
+  // supported by LLVM.
+  // FIXME: Should warn once that we're falling back.
+  switch (Triple.getOS()) {
+  case llvm::Triple::NetBSD:
+    switch (Triple.getEnvironment()) {
+    case llvm::Triple::GNUEABIHF:
+    case llvm::Triple::GNUEABI:
+    case llvm::Triple::EABIHF:
+    case llvm::Triple::EABI:
+      return "arm926ej-s";
+    default:
+      return "strongarm";
+    }
+  default:
+    switch (Triple.getEnvironment()) {
+    case llvm::Triple::EABIHF:
+    case llvm::Triple::GNUEABIHF:
+      return "arm1176jzf-s";
+    default:
+      return "arm7tdmi";
+    }
+  }
 }
 
 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
 StringRef arm::getARMTargetCPU(const ArgList &Args,
                                const llvm::Triple &Triple) {
   // FIXME: Warn on inconsistent use of -mcpu and -march.
   // If we have -mcpu=, use that.
   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {