[clang][Driver] Handle SPARC -mcpu=native etc.

[ro]

Summary

To make use of SPARC support in getHostCPUName as implemented by D130272, this patch uses it to handle -mcpu=native and -mtune=native. To match GCC, this patch rejects -march instead of silently treating it as a no-op.

Tested on sparcv9-sun-solaris2.11 and checking that those options are passed on as -target-cpu resp. -tune-cpu as expected.

[MaskRay]

I notice that in gcc, -march/-mtune/-mcpu are handled in gcc/config/* and every port may have somewhat different behaviors. E.g. x86 and aarch64 are different (and I suspect x86 has the weird behavior).

Have you checked that whether this matches GCC? We need some clang/test/Driver tests for "-cc1"{{.*}} "-target-cpu" "..."

[MaskRay]

clang/lib/Driver/ToolChains/Clang.cpp

2225

delete blank line after a variable declaration

2226

std::string TuneCPU(Name == "native" ? ... : ...)
if (!TuneCPU.empty()) {
  ...

[ro]

In D130273#3670623, @MaskRay wrote:

I notice that in gcc, -march/-mtune/-mcpu are handled in gcc/config/* and every port may have somewhat different behaviors. E.g. x86 and aarch64 are different (and I suspect x86 has the weird behavior).

Right: e.g. gcc on SPARC doesn't support -march at all. I've made no changes to clang here, i.e. the option is silently ignored. I believe it's important to keep that compatibility so clang command lines can be passed to gcc or vice versa.

Have you checked that whether this matches GCC? We need some clang/test/Driver tests for "-cc1"{{.*}} "-target-cpu" "..."

Not in every detail, especially since the gcc driver just passes -mcpu etc. on to cc1 which handles them itself, so it's not really easy to see what happens.

I'll add some tests, though.

clang/lib/Driver/ToolChains/Clang.cpp

2226

I'm not sure about this: I tried that variant, but I don't really think it's clearer than what I have now:

std::string TuneCPU(Name == "native"
                        ? std::string(llvm::sys::getHostCPUName()
                        : std::string(Name)));

My code was taken from AddSystemZTargetArgs directly below and it would seem a bit weird if they differ in style.

[MaskRay]

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

121

delete blank line

135

The common style omits else here

clang/lib/Driver/ToolChains/Clang.cpp

2226

OK, but I think AddSystemZTargetArgs somewhat deviates from common styles.

Since llvm::sys::getHostCPUName() cannot be empty, and -mtune= (empty value) should be an error (but only aarch64 seems to emit an error), I'd omit the if (!TuneCPU.empty()) test. For aarch64, I made such a simplification: 475e526d85003404ba521e15f8acef1b439fb910

I don't mind whether sparc emits an error for -mtune= or not.

[ro]

• Incorporate review comments.
• Add testcases.
• Reject -march, matching GCC.

clang/lib/Driver/ToolChains/Arch/Sparc.h

 enum class FloatABI {
   Invalid,
   Soft,
   Hard,
 };
 
 FloatABI getSparcFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
 
+std::string getSparcTargetCPU(const Driver &D, const llvm::opt::ArgList &Args,
+                              const llvm::Triple &Triple);
+
 void getSparcTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args,
                             std::vector<llvm::StringRef> &Features);
 const char *getSparcAsmModeForCPU(llvm::StringRef Name,
                                   const llvm::Triple &Triple);
 
 } // end namespace sparc
 } // end namespace target
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_SPARC_H

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

 //===--- Sparc.cpp - Tools Implementations ----------------------*- C++ -*-===//
 //
 // 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 "Sparc.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/Host.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 const char *sparc::getSparcAsmModeForCPU(StringRef Name,
                                          const llvm::Triple &Triple) {
sparc::FloatABI sparc::getSparcFloatABI(const Driver &D,
   // to be hard-float.
   if (ABI == sparc::FloatABI::Invalid) {
     ABI = sparc::FloatABI::Hard;
   }
 
   return ABI;
 }
 
+std::string sparc::getSparcTargetCPU(const Driver &D, const ArgList &Args,
+                                     const llvm::Triple &Triple) {
+  if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ)) {
+    StringRef CPUName = A->getValue();
+
+    if (CPUName == "native") {
+      std::string CPU = std::string(llvm::sys::getHostCPUName());
+      if (!CPU.empty() && CPU != "generic")
+        return CPU;
+      else
+        return "";
+    }
+
+    return std::string(CPUName);
+  }
+
+  if (Triple.getArch() == llvm::Triple::sparc && Triple.isOSSolaris())
+    return "v9";
+  else
+    return "";
+}
+
 void sparc::getSparcTargetFeatures(const Driver &D, const ArgList &Args,
                                    std::vector<StringRef> &Features) {
   sparc::FloatABI FloatABI = sparc::getSparcFloatABI(D, Args);
   if (FloatABI == sparc::FloatABI::Soft)
     Features.push_back("+soft-float");
 }

clang/lib/Driver/ToolChains/Clang.cpp

if (FloatABI == sparc::FloatABI::Soft) {
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("soft");
   } else {
     // Floating point operations and argument passing are hard.
     assert(FloatABI == sparc::FloatABI::Hard && "Invalid float abi!");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("hard");
   }
+
+  if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
+    StringRef Name = A->getValue();
+
+    std::string TuneCPU;
+    if (Name == "native")
+      TuneCPU = std::string(llvm::sys::getHostCPUName());
+    else
+      TuneCPU = std::string(Name);
+
+    if (!TuneCPU.empty()) {
+      CmdArgs.push_back("-tune-cpu");
+      CmdArgs.push_back(Args.MakeArgString(TuneCPU));
+    }
+  }
 }
 
 void Clang::AddSystemZTargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
     StringRef Name = A->getValue();
 
     std::string TuneCPU;

clang/lib/Driver/ToolChains/CommonArgs.cpp

 //===--- CommonArgs.cpp - Args handling for multiple toolchains -*- C++ -*-===//
 //
 // 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 "CommonArgs.h"
 #include "Arch/AArch64.h"
 #include "Arch/ARM.h"
 #include "Arch/M68k.h"
 #include "Arch/Mips.h"
 #include "Arch/PPC.h"
+#include "Arch/Sparc.h"
 #include "Arch/SystemZ.h"
 #include "Arch/VE.h"
 #include "Arch/X86.h"
 #include "HIPAMD.h"
 #include "Hexagon.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
std::string tools::getCPUName(const Driver &D, const ArgList &Args,
   case llvm::Triple::riscv32:
   case llvm::Triple::riscv64:
     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
       return A->getValue();
     return "";
 
   case llvm::Triple::bpfel:
   case llvm::Triple::bpfeb:
-  case llvm::Triple::sparc:
-  case llvm::Triple::sparcel:
-  case llvm::Triple::sparcv9:
     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
       return A->getValue();
-    if (T.getArch() == llvm::Triple::sparc && T.isOSSolaris())
-      return "v9";
     return "";
 
+  case llvm::Triple::sparc:
+  case llvm::Triple::sparcel:
+  case llvm::Triple::sparcv9:
+    return sparc::getSparcTargetCPU(D, Args, T);
+
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     return x86::getX86TargetCPU(D, Args, T);
 
   case llvm::Triple::hexagon:
     return "hexagon" +
            toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();