1//===--- PPC.cpp - PPC Helpers for Tools ------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "PPC.h"
10#include "ToolChains/CommonArgs.h"
11#include "clang/Driver/Driver.h"
12#include "clang/Driver/DriverDiagnostic.h"
13#include "clang/Driver/Options.h"
14#include "llvm/ADT/StringSwitch.h"
15#include "llvm/Option/ArgList.h"
16#include "llvm/TargetParser/Host.h"
17
18using namespace clang::driver;
19using namespace clang::driver::tools;
20using namespace clang;
21using namespace llvm::opt;
22
23static std::string getPPCGenericTargetCPU(const llvm::Triple &T) {
24  // LLVM may default to generating code for the native CPU,
25  // but, like gcc, we default to a more generic option for
26  // each architecture. (except on AIX)
27  if (T.isOSAIX())
28    return "pwr7";
29  else if (T.getArch() == llvm::Triple::ppc64le)
30    return "ppc64le";
31  else if (T.getArch() == llvm::Triple::ppc64)
32    return "ppc64";
33  else
34    return "ppc";
35}
36
37static std::string normalizeCPUName(StringRef CPUName, const llvm::Triple &T) {
38  // Clang/LLVM does not actually support code generation
39  // for the 405 CPU. However, there are uses of this CPU ID
40  // in projects that previously used GCC and rely on Clang
41  // accepting it. Clang has always ignored it and passed the
42  // generic CPU ID to the back end.
43  if (CPUName == "generic" || CPUName == "405")
44    return getPPCGenericTargetCPU(T);
45
46  if (CPUName == "native") {
47    std::string CPU = std::string(llvm::sys::getHostCPUName());
48    if (!CPU.empty() && CPU != "generic")
49      return CPU;
50    else
51      return getPPCGenericTargetCPU(T);
52  }
53
54  return llvm::StringSwitch<const char *>(CPUName)
55      .Case("common", "generic")
56      .Case("440fp", "440")
57      .Case("630", "pwr3")
58      .Case("G3", "g3")
59      .Case("G4", "g4")
60      .Case("G4+", "g4+")
61      .Case("8548", "e500")
62      .Case("G5", "g5")
63      .Case("power3", "pwr3")
64      .Case("power4", "pwr4")
65      .Case("power5", "pwr5")
66      .Case("power5x", "pwr5x")
67      .Case("power6", "pwr6")
68      .Case("power6x", "pwr6x")
69      .Case("power7", "pwr7")
70      .Case("power8", "pwr8")
71      .Case("power9", "pwr9")
72      .Case("power10", "pwr10")
73      .Case("future", "future")
74      .Case("powerpc", "ppc")
75      .Case("powerpc64", "ppc64")
76      .Case("powerpc64le", "ppc64le")
77      .Default(CPUName.data());
78}
79
80/// Get the (LLVM) name of the PowerPC cpu we are tuning for.
81std::string ppc::getPPCTuneCPU(const ArgList &Args, const llvm::Triple &T) {
82  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ))
83    return normalizeCPUName(A->getValue(), T);
84  return getPPCGenericTargetCPU(T);
85}
86
87/// Get the (LLVM) name of the PowerPC cpu we are targeting.
88std::string ppc::getPPCTargetCPU(const Driver &D, const ArgList &Args,
89                                 const llvm::Triple &T) {
90  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))
91    return normalizeCPUName(A->getValue(), T);
92  return getPPCGenericTargetCPU(T);
93}
94
95const char *ppc::getPPCAsmModeForCPU(StringRef Name) {
96  return llvm::StringSwitch<const char *>(Name)
97      .Case("pwr7", "-mpower7")
98      .Case("power7", "-mpower7")
99      .Case("pwr8", "-mpower8")
100      .Case("power8", "-mpower8")
101      .Case("ppc64le", "-mpower8")
102      .Case("pwr9", "-mpower9")
103      .Case("power9", "-mpower9")
104      .Case("pwr10", "-mpower10")
105      .Case("power10", "-mpower10")
106      .Default("-many");
107}
108
109void ppc::getPPCTargetFeatures(const Driver &D, const llvm::Triple &Triple,
110                               const ArgList &Args,
111                               std::vector<StringRef> &Features) {
112  if (Triple.getSubArch() == llvm::Triple::PPCSubArch_spe)
113    Features.push_back("+spe");
114
115  handleTargetFeaturesGroup(D, Triple, Args, Features,
116                            options::OPT_m_ppc_Features_Group);
117
118  ppc::FloatABI FloatABI = ppc::getPPCFloatABI(D, Args);
119  if (FloatABI == ppc::FloatABI::Soft)
120    Features.push_back("-hard-float");
121
122  ppc::ReadGOTPtrMode ReadGOT = ppc::getPPCReadGOTPtrMode(D, Triple, Args);
123  if (ReadGOT == ppc::ReadGOTPtrMode::SecurePlt)
124    Features.push_back("+secure-plt");
125}
126
127ppc::ReadGOTPtrMode ppc::getPPCReadGOTPtrMode(const Driver &D, const llvm::Triple &Triple,
128                                              const ArgList &Args) {
129  if (Args.getLastArg(options::OPT_msecure_plt))
130    return ppc::ReadGOTPtrMode::SecurePlt;
131  if (Triple.isPPC32SecurePlt())
132    return ppc::ReadGOTPtrMode::SecurePlt;
133  else
134    return ppc::ReadGOTPtrMode::Bss;
135}
136
137ppc::FloatABI ppc::getPPCFloatABI(const Driver &D, const ArgList &Args) {
138  ppc::FloatABI ABI = ppc::FloatABI::Invalid;
139  if (Arg *A =
140          Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
141                          options::OPT_mfloat_abi_EQ)) {
142    if (A->getOption().matches(options::OPT_msoft_float))
143      ABI = ppc::FloatABI::Soft;
144    else if (A->getOption().matches(options::OPT_mhard_float))
145      ABI = ppc::FloatABI::Hard;
146    else {
147      ABI = llvm::StringSwitch<ppc::FloatABI>(A->getValue())
148                .Case("soft", ppc::FloatABI::Soft)
149                .Case("hard", ppc::FloatABI::Hard)
150                .Default(ppc::FloatABI::Invalid);
151      if (ABI == ppc::FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
152        D.Diag(clang::diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
153        ABI = ppc::FloatABI::Hard;
154      }
155    }
156  }
157
158  // If unspecified, choose the default based on the platform.
159  if (ABI == ppc::FloatABI::Invalid) {
160    ABI = ppc::FloatABI::Hard;
161  }
162
163  return ABI;
164}
165
166bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
167  Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
168  return A && (A->getValue() == StringRef(Value));
169}
170