[Driver] Error out when using an older CPU than Haswell with x86_64h

[thegameg]

Summary

r349381 adds support to specify any CPU that overrides the default for x86_64h.

It does not make sense to allow this to be used with anything older than Haswell.

[thegameg]

Ping

[craig.topper]

lib/Driver/ToolChains/Arch/X86.cpp

24

Why are we blocking all AMD CPUs?

[thegameg]

lib/Driver/ToolChains/Arch/X86.cpp

24

The arch x86_64h is used for Intel 64-bit Haswell in mach-o. We are trying to validate wether the -march= passed along with -target x86_64h-apple-darwin is Intel, and at least Haswell.

include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_unknown_stdin_type_clang_cl : Error<
   "use /Tc or /Tp to set input type for standard input">;
 def err_drv_unknown_language : Error<"language not recognized: '%0'">;
 def err_drv_invalid_arch_name : Error<
   "invalid arch name '%0'">;
 def err_drv_invalid_riscv_arch_name : Error<
   "invalid arch name '%0', %1">;
 def err_drv_invalid_riscv_ext_arch_name : Error<
   "invalid arch name '%0', %1 '%2'">;
+def err_drv_invalid_march_for_triple : Error<
+  "invalid march '%0' for triple '%1'">;
 def err_drv_cuda_bad_gpu_arch : Error<"Unsupported CUDA gpu architecture: %0">;
 def err_drv_no_cuda_installation : Error<
   "cannot find CUDA installation.  Provide its path via --cuda-path, or pass "
   "-nocudainc to build without CUDA includes.">;
 def err_drv_no_cuda_libdevice : Error<
   "cannot find libdevice for %0. Provide path to different CUDA installation "
   "via --cuda-path, or pass -nocudalib to build without linking with libdevice.">;
 def err_drv_cuda_version_unsupported : Error<

lib/Driver/ToolChains/Arch/Mips.h

void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                            const llvm::opt::ArgList &Args,
                            std::vector<StringRef> &Features);
 StringRef getGnuCompatibleMipsABIName(StringRef ABI);
 mips::FloatABI getMipsFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
 std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args,
                                 const llvm::Triple &Triple);
 bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value);
 bool isUCLibc(const llvm::opt::ArgList &Args);
-bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple);
+bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple,
+               const Driver &D);
 bool isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName);
 bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
                    StringRef ABIName, mips::FloatABI FloatABI);
 bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple,
                    StringRef CPUName, StringRef ABIName,
                    mips::FloatABI FloatABI);
 bool supportsIndirectJumpHazardBarrier(StringRef &CPU);
 
 } // end namespace mips
 } // end namespace target
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_MIPS_H

lib/Driver/ToolChains/Arch/Mips.cpp

bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
   return A && (A->getValue() == StringRef(Value));
 }
 
 bool mips::isUCLibc(const ArgList &Args) {
   Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
   return A && A->getOption().matches(options::OPT_muclibc);
 }
 
-bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
+bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple,
+                     const Driver &D) {
   if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
     return llvm::StringSwitch<bool>(NaNArg->getValue())
         .Case("2008", true)
         .Case("legacy", false)
         .Default(false);
 
   // NaN2008 is the default for MIPS32r6/MIPS64r6.
-  return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
+  return llvm::StringSwitch<bool>(getCPUName(Args, Triple, D))
       .Cases("mips32r6", "mips64r6", true)
       .Default(false);
 
   return false;
 }
 
 bool mips::isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName) {
   if (!Triple.isAndroid())

lib/Driver/ToolChains/Arch/X86.h

 #include <vector>
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace x86 {
 
 const char *getX86TargetCPU(const llvm::opt::ArgList &Args,
-                            const llvm::Triple &Triple);
+                            const llvm::Triple &Triple, const Driver &D);
 
 void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
                           const llvm::opt::ArgList &Args,
                           std::vector<llvm::StringRef> &Features);
 
 } // end namespace x86
 } // end namespace target
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_X86_H

lib/Driver/ToolChains/Arch/X86.cpp

 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/ArgList.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
+namespace {
+bool isAMDMarch(StringRef March) {
+  return llvm::StringSwitch<bool>(March)
+      .Case("k8", true)
+      .Case("athlon64", true)
+      .Case("athlon-fx", true)
+      .Case("opteron", true)
+      .Case("k8-sse3", true)
+      .Case("athlon64-sse3", true)
+      .Case("opteron-sse3", true)
+      .Case("amdfam10", true)
+      .Case("barcelona", true)
+      .Case("btver1", true)
+      .Case("btver2", true)
+      .Case("bdver1", true)
+      .Case("bdver2", true)
+      .Case("bdver3", true)
+      .Case("bdver4", true)
+      .Case("znver1", true)
+      .Default(false);
+}
+
+bool isMarchValidForTriple(StringRef March, const llvm::Triple &Triple) {
+  // Check that no older march than haswell is used with x86_64h.
+  if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h") {
+    if (isAMDMarch(March))
+      return false;
+    return llvm::StringSwitch<bool>(March)
+        .Case("nocona", false)
+        .Case("core2", false)
+        .Case("penryn", false)
+        .Case("bonnell", false)
+        .Case("atom", false)
+        .Case("silvermont", false)
+        .Case("slm", false)
+        .Case("tremont", false)
+        .Case("nehalem", false)
+        .Case("corei7", false)
+        .Case("westmere", false)
+        .Case("sandybridge", false)
+        .Case("corei7-avx", false)
+        .Case("ivybridge", false)
+        .Case("core-avx-i", false)
+        .Default(true);
+  }
+  return true;
+}
+}
+
 const char *x86::getX86TargetCPU(const ArgList &Args,
-                                 const llvm::Triple &Triple) {
+                                 const llvm::Triple &Triple, const Driver &D) {
   if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ)) {
-    if (StringRef(A->getValue()) != "native")
+    if (StringRef(A->getValue()) != "native") {
+      if (isMarchValidForTriple(A->getValue(), Triple))
         return A->getValue();
+      else {
+        D.Diag(diag::err_drv_invalid_march_for_triple)
+            << A->getValue() << Triple.str();
+      }
+    }
 
     // FIXME: Reject attempts to use -march=native unless the target matches
     // the host.
     //
     // FIXME: We should also incorporate the detected target features for use
     // with -native.
     std::string CPU = llvm::sys::getHostCPUName();
     if (!CPU.empty() && CPU != "generic")

lib/Driver/ToolChains/Clang.cpp

static bool isNoCommonDefault(const llvm::Triple &Triple) {
   case llvm::Triple::wasm32:
   case llvm::Triple::wasm64:
     return true;
   }
 }
 
 namespace {
 void RenderARMABI(const llvm::Triple &Triple, const ArgList &Args,
-                  ArgStringList &CmdArgs) {
+                  const Driver &D, ArgStringList &CmdArgs) {
   // Select the ABI to use.
   // FIXME: Support -meabi.
   // FIXME: Parts of this are duplicated in the backend, unify this somehow.
   const char *ABIName = nullptr;
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     ABIName = A->getValue();
   } else {
-    std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
+    std::string CPU = getCPUName(Args, Triple, D, /*FromAs*/ false);
     ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
   }
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName);
 }
 }
 
 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
                              ArgStringList &CmdArgs, bool KernelOrKext) const {
-  RenderARMABI(Triple, Args, CmdArgs);
+  RenderARMABI(Triple, Args, getToolChain().getDriver(), CmdArgs);
 
   // Determine floating point ABI from the options & target defaults.
   arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
   if (ABI == arm::FloatABI::Soft) {
     // Floating point operations and argument passing are soft.
     // FIXME: This changes CPP defines, we need -target-soft-float.
     CmdArgs.push_back("-msoft-float");
     CmdArgs.push_back("-mfloat-abi");
RenderFloatingPointOptions(TC, D, isOptimizationLevelFast(Args), Args,
                                CmdArgs);
 
     // Render ABI arguments
     switch (TC.getArch()) {
     default: break;
     case llvm::Triple::arm:
     case llvm::Triple::armeb:
     case llvm::Triple::thumbeb:
-      RenderARMABI(Triple, Args, CmdArgs);
+      RenderARMABI(Triple, Args, D, CmdArgs);
       break;
     case llvm::Triple::aarch64:
     case llvm::Triple::aarch64_be:
       RenderAArch64ABI(Triple, Args, CmdArgs);
       break;
     }
 
     // Optimization level for CodeGen.
#endif
   (void)Args.hasArg(options::OPT_mtune_EQ);
 
   if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
     CmdArgs.push_back("-mcode-model");
     CmdArgs.push_back(A->getValue());
   }
 
   // Add the target cpu
-  std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
+  std::string CPU = getCPUName(Args, Triple, D, /*FromAs*/ false);
   if (!CPU.empty()) {
     CmdArgs.push_back("-target-cpu");
     CmdArgs.push_back(Args.MakeArgString(CPU));
   }
 
   RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
 
   // These two are potentially updated by AddClangCLArgs.
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back("obj");
 
   // Set the main file name, so that debug info works even with
   // -save-temps or preprocessed assembly.
   CmdArgs.push_back("-main-file-name");
   CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
 
   // Add the target cpu
-  std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true);
+  std::string CPU = getCPUName(Args, Triple, D, /*FromAs*/ true);
   if (!CPU.empty()) {
     CmdArgs.push_back("-target-cpu");
     CmdArgs.push_back(Args.MakeArgString(CPU));
   }
 
   // Add the target features
   getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, true);
 

lib/Driver/ToolChains/CommonArgs.h

void addDirectoryList(const llvm::opt::ArgList &Args,
                       const char *EnvVar);
 
 void AddTargetFeature(const llvm::opt::ArgList &Args,
                       std::vector<StringRef> &Features,
                       llvm::opt::OptSpecifier OnOpt,
                       llvm::opt::OptSpecifier OffOpt, StringRef FeatureName);
 
 std::string getCPUName(const llvm::opt::ArgList &Args, const llvm::Triple &T,
-                       bool FromAs = false);
+                       const Driver &D, bool FromAs = false);
 
 void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args,
                                std::vector<StringRef> &Features,
                                llvm::opt::OptSpecifier Group);
 
 /// Handles the -save-stats option and returns the filename to save statistics
 /// to.
 SmallString<128> getStatsFileName(const llvm::opt::ArgList &Args,
                                   const InputInfo &Output,
                                   const InputInfo &Input, const Driver &D);
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_COMMONARGS_H

lib/Driver/ToolChains/CommonArgs.cpp

#endif
 
     return CPU;
   }
 
   return "generic";
 }
 
 std::string tools::getCPUName(const ArgList &Args, const llvm::Triple &T,
-                              bool FromAs) {
+                              const Driver &D, bool FromAs) {
   Arg *A;
 
   switch (T.getArch()) {
   default:
     return "";
 
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
std::string tools::getCPUName(const ArgList &Args, const llvm::Triple &T,
   case llvm::Triple::sparcel:
   case llvm::Triple::sparcv9:
     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
       return A->getValue();
     return "";
 
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
-    return x86::getX86TargetCPU(Args, T);
+    return x86::getX86TargetCPU(Args, T, D);
 
   case llvm::Triple::hexagon:
     return "hexagon" +
            toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
 
   case llvm::Triple::lanai:
     return getLanaiTargetCPU(Args);
 
llvm::sys::path::native(Twine(ToolChain.getDriver().Dir) +
                               Suffix,
                           Plugin);
   CmdArgs.push_back(Args.MakeArgString(Plugin));
 
   // Try to pass driver level flags relevant to LTO code generation down to
   // the plugin.
 
   // Handle flags for selecting CPU variants.
-  std::string CPU = getCPUName(Args, ToolChain.getTriple());
+  std::string CPU =
+      getCPUName(Args, ToolChain.getTriple(), ToolChain.getDriver());
   if (!CPU.empty())
     CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
 
   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
     StringRef OOpt;
     if (A->getOption().matches(options::OPT_O4) ||
         A->getOption().matches(options::OPT_Ofast))
       OOpt = "3";

lib/Driver/ToolChains/FreeBSD.cpp

case llvm::Triple::thumbeb: {
     default:
       CmdArgs.push_back("-matpcs");
     }
     break;
   }
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel:
   case llvm::Triple::sparcv9: {
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(),
+                                 getToolChain().getDriver());
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 

lib/Driver/ToolChains/Gnu.cpp

if (IsBigEndian)
       arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
     IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
     CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
   }
 
   // Most Android ARM64 targets should enable the linker fix for erratum
   // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.
   if (Arch == llvm::Triple::aarch64 && isAndroid) {
-    std::string CPU = getCPUName(Args, Triple);
+    std::string CPU = getCPUName(Args, Triple, D);
     if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
       CmdArgs.push_back("--fix-cortex-a53-843419");
   }
 
   for (const auto &Opt : ToolChain.ExtraOpts)
     CmdArgs.push_back(Opt.c_str());
 
   CmdArgs.push_back("--eh-frame-hdr");
case llvm::Triple::x86_64:
     if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
       CmdArgs.push_back("--x32");
     else
       CmdArgs.push_back("--64");
     break;
   case llvm::Triple::ppc: {
     CmdArgs.push_back("-a32");
     CmdArgs.push_back("-mppc");
-    CmdArgs.push_back(
-      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
+    CmdArgs.push_back(ppc::getPPCAsmModeForCPU(
+        getCPUName(Args, getToolChain().getTriple(), D)));
     break;
   }
   case llvm::Triple::ppc64: {
     CmdArgs.push_back("-a64");
     CmdArgs.push_back("-mppc64");
     CmdArgs.push_back(
-      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
+      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple(), D)));
     break;
   }
   case llvm::Triple::ppc64le: {
     CmdArgs.push_back("-a64");
     CmdArgs.push_back("-mppc64");
     CmdArgs.push_back("-mlittle-endian");
     CmdArgs.push_back(
-      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
+      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple(), D)));
     break;
   }
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64: {
     StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple());
     CmdArgs.push_back("-mabi");
     CmdArgs.push_back(ABIName.data());
     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
       StringRef MArch = A->getValue();
       CmdArgs.push_back("-march");
       CmdArgs.push_back(MArch.data());
     }
     break;
   }
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel: {
     CmdArgs.push_back("-32");
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(), D);
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
   case llvm::Triple::sparcv9: {
     CmdArgs.push_back("-64");
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(), D);
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb: {
bool clang::driver::findMIPSMultilibs(const Driver &D,
   addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
   addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
   addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
                       CPUName == "mips64r5" || CPUName == "octeon",
                   "march=mips64r2", Flags);
   addMultilibFlag(CPUName == "mips64r6", "march=mips64r6", Flags);
   addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
   addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
-  addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
+  addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple, D), "mnan=2008",
                   Flags);
   addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
   addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
   addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
   addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
   addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
   addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
 

lib/Driver/ToolChains/Linux.cpp

case llvm::Triple::thumbeb: {
     LibDir = "lib";
     Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
     break;
   }
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
-    bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);
+    bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple, getDriver());
 
     LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
 
     if (tools::mips::isUCLibc(Args))
       Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
     else if (!Triple.hasEnvironment() &&
              Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
       Loader =

lib/Driver/ToolChains/NetBSD.cpp

case llvm::Triple::mips64el: {
 
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
 
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel: {
     CmdArgs.push_back("-32");
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(),
+                                 getToolChain().getDriver());
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
 
   case llvm::Triple::sparcv9: {
     CmdArgs.push_back("-64");
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(),
+                                 getToolChain().getDriver());
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
 
   default:
     break;
   }

lib/Driver/ToolChains/OpenBSD.cpp

void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   case llvm::Triple::ppc:
     CmdArgs.push_back("-mppc");
     CmdArgs.push_back("-many");
     break;
 
   case llvm::Triple::sparc:
   case llvm::Triple::sparcel: {
     CmdArgs.push_back("-32");
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(),
+                                 getToolChain().getDriver());
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
 
   case llvm::Triple::sparcv9: {
     CmdArgs.push_back("-64");
-    std::string CPU = getCPUName(Args, getToolChain().getTriple());
+    std::string CPU = getCPUName(Args, getToolChain().getTriple(),
+                                 getToolChain().getDriver());
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
 
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
     StringRef CPUName;

test/Driver/clang-translation-x86_64h.c

+// RUN: %clang -target x86_64h-apple-darwin -### -S %s -o %t.s 2>&1 | \
+// RUN: FileCheck -check-prefix=AVX2 %s
+// RUN: %clang -target x86_64h-apple-macosx10.12 -### -S %s -o %t.s 2>&1 | \
+// RUN: FileCheck -check-prefix=AVX2 %s
+// AVX2: "-target-cpu"
+// AVX2: "core-avx2"
+
+// RUN: %clang -target x86_64h-apple-darwin -march=skx -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HSKX %s
+// X8664HSKX: "-target-cpu"
+// X8664HSKX: "skx"
+
+// RUN: %clang -target x86_64h-apple-darwin -march=haswell -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HSW %s
+// X8664HSW: "-target-cpu"
+// X8664HSW: "haswell"
+
+// RUN: %clang -target x86_64h-apple-darwin -march=nocona -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HNOCONA %s
+// X8664HNOCONA: invalid march 'nocona' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=core2 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HCORE2 %s
+// X8664HCORE2: invalid march 'core2' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=penryn -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HPENRYN %s
+// X8664HPENRYN: invalid march 'penryn' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=bonnell -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBONNELL %s
+// X8664HBONNELL: invalid march 'bonnell' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=atom -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HATOM %s
+// X8664HATOM: invalid march 'atom' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=silvermont -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HSILVERMONT %s
+// X8664HSILVERMONT: invalid march 'silvermont' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=slm -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HSLM %s
+// X8664HSLM: invalid march 'slm' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=tremont -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HTREMONT %s
+// X8664HTREMONT: invalid march 'tremont' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=nehalem -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HNEHALEM %s
+// X8664HNEHALEM: invalid march 'nehalem' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=corei7 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HCOREI7 %s
+// X8664HCOREI7: invalid march 'corei7' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=westmere -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HWESTMERE %s
+// X8664HWESTMERE: invalid march 'westmere' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=sandybridge -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HSANDYBRIDGE %s
+// X8664HSANDYBRIDGE: invalid march 'sandybridge' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=corei7-avx -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HCOREI7-AVX %s
+// X8664HCOREI7-AVX: invalid march 'corei7-avx' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=ivybridge -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HIVYBRIDGE %s
+// X8664HIVYBRIDGE: invalid march 'ivybridge' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=core-avx-i -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HCORE-AVX-I %s
+// X8664HCORE-AVX-I: invalid march 'core-avx-i' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=k8 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HK8 %s
+// X8664HK8: invalid march 'k8' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=athlon64 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HATHLON64 %s
+// X8664HATHLON64: invalid march 'athlon64' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=athlon-fx -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HATHLON-FX %s
+// X8664HATHLON-FX: invalid march 'athlon-fx' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=opteron -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HOPTERON %s
+// X8664HOPTERON: invalid march 'opteron' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=k8-sse3 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HK8-SSE3 %s
+// X8664HK8-SSE3: invalid march 'k8-sse3' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=athlon64-sse3 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HATHLON64-SSE3 %s
+// X8664HATHLON64-SSE3: invalid march 'athlon64-sse3' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=opteron-sse3 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HOPTERON-SSE3 %s
+// X8664HOPTERON-SSE3: invalid march 'opteron-sse3' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=amdfam10 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HAMDFAM10 %s
+// X8664HAMDFAM10: invalid march 'amdfam10' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=barcelona -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBARCELONA %s
+// X8664HBARCELONA: invalid march 'barcelona' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=btver1 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBTVER1 %s
+// X8664HBTVER1: invalid march 'btver1' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=btver2 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBTVER2 %s
+// X8664HBTVER2: invalid march 'btver2' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=bdver1 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBDVER1 %s
+// X8664HBDVER1: invalid march 'bdver1' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=bdver2 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBDVER2 %s
+// X8664HBDVER2: invalid march 'bdver2' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=bdver3 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBDVER3 %s
+// X8664HBDVER3: invalid march 'bdver3' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=bdver4 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HBDVER4 %s
+// X8664HBDVER4: invalid march 'bdver4' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'
+
+// RUN: %clang -target x86_64h-apple-darwin -march=znver1 -### %s -o /dev/null 2>&1 | \
+// RUN: FileCheck -check-prefix=X8664HZNVER1 %s
+// X8664HZNVER1: invalid march 'znver1' for triple 'x86_64h-apple-macosx{{[0-9.]+}}'

test/Driver/clang-translation.c

 
 // RUN: %clang -target x86_64-apple-darwin9 -### -S %s -o %t.s 2>&1 | \
 // RUN: FileCheck -check-prefix=CORE2 %s
 // RUN: %clang -target x86_64-apple-macosx10.11 -### -S %s -o %t.s 2>&1 | \
 // RUN: FileCheck -check-prefix=CORE2 %s
 // CORE2: "-target-cpu"
 // CORE2: "core2"
 
-// RUN: %clang -target x86_64h-apple-darwin -### -S %s -o %t.s 2>&1 | \
-// RUN: FileCheck -check-prefix=AVX2 %s
-// RUN: %clang -target x86_64h-apple-macosx10.12 -### -S %s -o %t.s 2>&1 | \
-// RUN: FileCheck -check-prefix=AVX2 %s
-// AVX2: "-target-cpu"
-// AVX2: "core-avx2"
-
-// RUN: %clang -target x86_64h-apple-darwin -march=skx -### %s -o /dev/null 2>&1 | \
-// RUN: FileCheck -check-prefix=X8664HSKX %s
-// X8664HSKX: "-target-cpu"
-// X8664HSKX: "skx"
-
 // RUN: %clang -target i386-apple-macosx10.12 -### -S %s -o %t.s 2>&1 | \
 // RUN: FileCheck -check-prefix=PENRYN %s
 // RUN: %clang -target x86_64-apple-macosx10.12 -### -S %s -o %t.s 2>&1 | \
 // RUN: FileCheck -check-prefix=PENRYN %s
 // PENRYN: "-target-cpu"
 // PENRYN: "penryn"