[PowerPC] Recognize long CPU name for -mtune in Clang

[nemanjai]

Summary

There are two ways of specifying a CPU on PowerPC: power<N> and pwr<N>. Clang/LLVM traditionally supports the latter and Clang replaces the former with the latter when passing it to the back end for the -mcpu= option. However, when the -mtune= option was introduced, this replacement was not implemented for it.

This leaves us in an inconsistent state of accepting both forms for -mcpu= and and only the latter for -mtune=. Furthermore, it leaves us incompatible with GCC which only understands the power<N> version for both options.

This patch just adds the same handling for the long names for -mtune= as already exists for -mcpu=.

[nathanchance]

Thanks for the fix, it appears to work fine for me against the kernel's powernv_defconfig target.

[nickdesaulniers]

Thanks for the patch!

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

37–50

The casing of the function name is a bit awkward, consider something perhaps more concise like normalizeCPUName and retaining the comment.

[MaskRay]

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

80–85

87

[nathanchance]

Could this be merged into main and backported to release/16.x? If this makes 16.0.0 final, I think the kernel can avoid working around this issue altogether, as -mtune was only wired up to do something on PowerPC in during the 16 development cycle; in prior versions, it was ignored so any value was accepted.

[MaskRay]

In D144967#4164858, @nathanchance wrote:

Could this be merged into main and backported to release/16.x? If this makes 16.0.0 final, I think the kernel can avoid working around this issue altogether, as -mtune was only wired up to do something on PowerPC in during the 16 development cycle; in prior versions, it was ignored so any value was accepted.

I support the backport into 16.0.0 but we need to be quick :)

[nemanjai]

I'll provide an updated patch in a few min...

[nemanjai]

In D144967#4165140, @nemanjai wrote:

I'll provide an updated patch in a few min...

Ah, what I mean is I will update the patch and push in a few min.

[amyk]

In D144967#4164858, @nathanchance wrote:

Could this be merged into main and backported to release/16.x? If this makes 16.0.0 final, I think the kernel can avoid working around this issue altogether, as -mtune was only wired up to do something on PowerPC in during the 16 development cycle; in prior versions, it was ignored so any value was accepted.

@nathanchance Just wanted to let you know that this patch is now backported into release/16.x.

[nathanchance]

@amyk thank you so much!

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

enum class ReadGOTPtrMode {
   Bss,
   SecurePlt,
 };
 
 FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
 
 std::string getPPCTargetCPU(const llvm::opt::ArgList &Args,
                             const llvm::Triple &T);
+std::string getPPCTuneCPU(const llvm::opt::ArgList &Args,
+                          const llvm::Triple &T);
 const char *getPPCAsmModeForCPU(StringRef Name);
 ReadGOTPtrMode getPPCReadGOTPtrMode(const Driver &D, const llvm::Triple &Triple,
                                     const llvm::opt::ArgList &Args);
 
 void getPPCTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                           const llvm::opt::ArgList &Args,
                           std::vector<llvm::StringRef> &Features);
 
 } // end namespace ppc
 } // end namespace target
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_PPC_H

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

static std::string getPPCGenericTargetCPU(const llvm::Triple &T) {
   else if (T.getArch() == llvm::Triple::ppc64le)
     return "ppc64le";
   else if (T.getArch() == llvm::Triple::ppc64)
     return "ppc64";
   else
     return "ppc";
 }
 
-/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
-std::string ppc::getPPCTargetCPU(const ArgList &Args, const llvm::Triple &T) {
-  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ)) {
-    StringRef CPUName = A->getValue();
-
-    // Clang/LLVM does not actually support code generation
-    // for the 405 CPU. However, there are uses of this CPU ID
-    // in projects that previously used GCC and rely on Clang
-    // accepting it. Clang has always ignored it and passed the
-    // generic CPU ID to the back end.
-    if (CPUName == "generic" || CPUName == "405")
-      return getPPCGenericTargetCPU(T);
+static std::string normalizeCPUName(StringRef CPUName, const llvm::Triple &T) {
 
-    if (CPUName == "native") {
-      std::string CPU = std::string(llvm::sys::getHostCPUName());
-      if (!CPU.empty() && CPU != "generic")
-        return CPU;
-      else
-        return getPPCGenericTargetCPU(T);
-    }
 
-    return llvm::StringSwitch<const char *>(CPUName)
-        .Case("common", "generic")
-        .Case("440fp", "440")
-        .Case("630", "pwr3")
-        .Case("G3", "g3")
-        .Case("G4", "g4")
-        .Case("G4+", "g4+")
-        .Case("8548", "e500")
-        .Case("G5", "g5")
-        .Case("power3", "pwr3")
-        .Case("power4", "pwr4")
-        .Case("power5", "pwr5")
-        .Case("power5x", "pwr5x")
-        .Case("power6", "pwr6")
-        .Case("power6x", "pwr6x")
-        .Case("power7", "pwr7")
-        .Case("power8", "pwr8")
-        .Case("power9", "pwr9")
-        .Case("power10", "pwr10")
-        .Case("future", "future")
-        .Case("powerpc", "ppc")
-        .Case("powerpc64", "ppc64")
-        .Case("powerpc64le", "ppc64le")
-        .Default(CPUName.data());
-  }
 
+/// Get the (LLVM) name of the PowerPC cpu we are tuning for.
+std::string ppc::getPPCTuneCPU(const ArgList &Args, const llvm::Triple &T) {
+  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ))
+    return normalizeCPUName(A->getValue(), T);
+  return getPPCGenericTargetCPU(T);
+}
+
+/// Get the (LLVM) name of the PowerPC cpu we are targeting.
+std::string ppc::getPPCTargetCPU(const ArgList &Args, const llvm::Triple &T) {
+  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))
+    return normalizeCPUName(A->getValue(), T);
   return getPPCGenericTargetCPU(T);
 }
 
 const char *ppc::getPPCAsmModeForCPU(StringRef Name) {
   return llvm::StringSwitch<const char *>(Name)
       .Case("pwr7", "-mpower7")
       .Case("power7", "-mpower7")
       .Case("pwr8", "-mpower8")

clang/lib/Driver/ToolChains/Clang.cpp

if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-mips-jalr-reloc=0");
     }
   }
 }
 
 void Clang::AddPPCTargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
+  const llvm::Triple &T = getToolChain().getTriple();
   if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {
     CmdArgs.push_back("-tune-cpu");
-    if (strcmp(A->getValue(), "native") == 0)
-      CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
-    else
-      CmdArgs.push_back(A->getValue());
+    std::string CPU = ppc::getPPCTuneCPU(Args, T);
+    CmdArgs.push_back(Args.MakeArgString(CPU));
   }
 
   // Select the ABI to use.
   const char *ABIName = nullptr;
-  const llvm::Triple &T = getToolChain().getTriple();
   if (T.isOSBinFormatELF()) {
     switch (getToolChain().getArch()) {
     case llvm::Triple::ppc64: {
       if (T.isPPC64ELFv2ABI())
         ABIName = "elfv2";
       else
         ABIName = "elfv1";
       break;

clang/test/Driver/ppc-cpus.c

 // RUN: %clang -### -c -target powerpc64 %s -mcpu=pwr6 2>&1 | FileCheck %s --check-prefix=NO_PPC64
 // RUN: %clang -### -c -target powerpc64 %s -mcpu=pwr7 2>&1 | FileCheck %s --check-prefix=NO_PPC64
 // RUN: %clang -### -c -target powerpc64 %s -mcpu=pwr8 2>&1 | FileCheck %s --check-prefix=NO_PPC64
 
 // NO_PPC64-NOT: "-target-cpu" "ppc64"
 
 // RUN: %clang -### -c --target=powerpc64 %s -mcpu=generic -mtune=pwr9 2>&1 | FileCheck %s --check-prefix=TUNE
 // TUNE: "-target-cpu" "ppc64" "-tune-cpu" "pwr9"
+// RUN: %clang -### -c --target=powerpc64le %s -mcpu=power9 -mtune=power10 2>&1 | FileCheck %s --check-prefix=TUNE-LONG
+// TUNE-LONG: "-target-cpu" "pwr9" "-tune-cpu" "pwr10"
 
 /// Test mcpu options that are equivalent to "generic"
 // RUN: %clang -### -c -target powerpc64 %s -mcpu=generic 2>&1 | FileCheck %s --check-prefix=GENERIC
 // RUN: %clang -### -c -target powerpc64 %s -mcpu=405     2>&1 | FileCheck %s --check-prefix=GENERIC
 //
 // GENERIC: "-target-cpu" "ppc64"