clang  12.0.0git
PS4CPU.cpp
Go to the documentation of this file.
1 //===--- PS4CPU.cpp - PS4CPU ToolChain Implementations ----------*- 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 "PS4CPU.h"
10 #include "FreeBSD.h"
11 #include "CommonArgs.h"
13 #include "clang/Driver/Driver.h"
15 #include "clang/Driver/Options.h"
17 #include "llvm/Option/ArgList.h"
18 #include "llvm/Support/FileSystem.h"
19 #include "llvm/Support/Path.h"
20 #include <cstdlib> // ::getenv
21 
22 using namespace clang::driver;
23 using namespace clang;
24 using namespace llvm::opt;
25 
27 
28 void tools::PS4cpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args,
29  ArgStringList &CmdArgs) {
30  if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
31  false) ||
32  Args.hasFlag(options::OPT_fprofile_generate,
33  options::OPT_fno_profile_generate, false) ||
34  Args.hasFlag(options::OPT_fprofile_generate_EQ,
35  options::OPT_fno_profile_generate, false) ||
36  Args.hasFlag(options::OPT_fprofile_instr_generate,
37  options::OPT_fno_profile_instr_generate, false) ||
38  Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
39  options::OPT_fno_profile_instr_generate, false) ||
40  Args.hasFlag(options::OPT_fcs_profile_generate,
41  options::OPT_fno_profile_generate, false) ||
42  Args.hasFlag(options::OPT_fcs_profile_generate_EQ,
43  options::OPT_fno_profile_generate, false) ||
44  Args.hasArg(options::OPT_fcreate_profile) ||
45  Args.hasArg(options::OPT_coverage)))
46  CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
47 }
48 
50  const InputInfo &Output,
51  const InputInfoList &Inputs,
52  const ArgList &Args,
53  const char *LinkingOutput) const {
54  claimNoWarnArgs(Args);
55  ArgStringList CmdArgs;
56 
57  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
58 
59  CmdArgs.push_back("-o");
60  CmdArgs.push_back(Output.getFilename());
61 
62  assert(Inputs.size() == 1 && "Unexpected number of inputs.");
63  const InputInfo &Input = Inputs[0];
64  assert(Input.isFilename() && "Invalid input.");
65  CmdArgs.push_back(Input.getFilename());
66 
67  const char *Exec =
68  Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
69  C.addCommand(std::make_unique<Command>(
70  JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs));
71 }
72 
73 static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
74  const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
75  if (SanArgs.needsUbsanRt()) {
76  CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
77  }
78  if (SanArgs.needsAsanRt()) {
79  CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
80  }
81 }
82 
84  ArgStringList &CmdArgs) {
85  const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
86  if (SanArgs.needsUbsanRt())
87  CmdArgs.push_back("--dependent-lib=libSceDbgUBSanitizer_stub_weak.a");
88  if (SanArgs.needsAsanRt())
89  CmdArgs.push_back("--dependent-lib=libSceDbgAddressSanitizer_stub_weak.a");
90 }
91 
93  const InputInfo &Output,
94  const InputInfoList &Inputs,
95  const ArgList &Args,
96  const char *LinkingOutput) const {
98  static_cast<const toolchains::FreeBSD &>(getToolChain());
99  const Driver &D = ToolChain.getDriver();
100  ArgStringList CmdArgs;
101 
102  // Silence warning for "clang -g foo.o -o foo"
103  Args.ClaimAllArgs(options::OPT_g_Group);
104  // and "clang -emit-llvm foo.o -o foo"
105  Args.ClaimAllArgs(options::OPT_emit_llvm);
106  // and for "clang -w foo.o -o foo". Other warning options are already
107  // handled somewhere else.
108  Args.ClaimAllArgs(options::OPT_w);
109 
110  if (!D.SysRoot.empty())
111  CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
112 
113  if (Args.hasArg(options::OPT_pie))
114  CmdArgs.push_back("-pie");
115 
116  if (Args.hasArg(options::OPT_rdynamic))
117  CmdArgs.push_back("-export-dynamic");
118  if (Args.hasArg(options::OPT_shared))
119  CmdArgs.push_back("--oformat=so");
120 
121  if (Output.isFilename()) {
122  CmdArgs.push_back("-o");
123  CmdArgs.push_back(Output.getFilename());
124  } else {
125  assert(Output.isNothing() && "Invalid output.");
126  }
127 
128  if(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
129  AddPS4SanitizerArgs(ToolChain, CmdArgs);
130 
131  Args.AddAllArgs(CmdArgs, options::OPT_L);
132  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
133  Args.AddAllArgs(CmdArgs, options::OPT_e);
134  Args.AddAllArgs(CmdArgs, options::OPT_s);
135  Args.AddAllArgs(CmdArgs, options::OPT_t);
136  Args.AddAllArgs(CmdArgs, options::OPT_r);
137 
138  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
139  CmdArgs.push_back("--no-demangle");
140 
141  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
142 
143  if (Args.hasArg(options::OPT_pthread)) {
144  CmdArgs.push_back("-lpthread");
145  }
146 
147  if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
148  D.Diag(diag::err_drv_unsupported_opt_for_target)
149  << "-fuse-ld" << getToolChain().getTriple().str();
150  }
151 
152  const char *Exec =
153  Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
154 
155  C.addCommand(std::make_unique<Command>(
156  JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs));
157 }
158 
159 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
160  const ArgList &Args)
161  : Generic_ELF(D, Triple, Args) {
162  if (Args.hasArg(clang::driver::options::OPT_static))
163  D.Diag(clang::diag::err_drv_unsupported_opt_for_target) << "-static"
164  << "PS4";
165 
166  // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
167  // if it exists; otherwise use the driver's installation path, which
168  // should be <SDK_DIR>/host_tools/bin.
169 
170  SmallString<512> PS4SDKDir;
171  if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
172  if (!llvm::sys::fs::exists(EnvValue))
173  getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
174  PS4SDKDir = EnvValue;
175  } else {
176  PS4SDKDir = getDriver().Dir;
177  llvm::sys::path::append(PS4SDKDir, "/../../");
178  }
179 
180  // By default, the driver won't report a warning if it can't find
181  // PS4's include or lib directories. This behavior could be changed if
182  // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
183  // If -isysroot was passed, use that as the SDK base path.
184  std::string PrefixDir;
185  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
186  PrefixDir = A->getValue();
187  if (!llvm::sys::fs::exists(PrefixDir))
188  getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
189  } else
190  PrefixDir = std::string(PS4SDKDir.str());
191 
192  SmallString<512> PS4SDKIncludeDir(PrefixDir);
193  llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
194  if (!Args.hasArg(options::OPT_nostdinc) &&
195  !Args.hasArg(options::OPT_nostdlibinc) &&
196  !Args.hasArg(options::OPT_isysroot) &&
197  !Args.hasArg(options::OPT__sysroot_EQ) &&
198  !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
199  getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
200  << "PS4 system headers" << PS4SDKIncludeDir;
201  }
202 
203  SmallString<512> PS4SDKLibDir(PS4SDKDir);
204  llvm::sys::path::append(PS4SDKLibDir, "target/lib");
205  if (!Args.hasArg(options::OPT_nostdlib) &&
206  !Args.hasArg(options::OPT_nodefaultlibs) &&
207  !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
208  !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
209  !Args.hasArg(options::OPT_emit_ast) &&
210  !llvm::sys::fs::exists(PS4SDKLibDir)) {
211  getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
212  << "PS4 system libraries" << PS4SDKLibDir;
213  return;
214  }
215  getFilePaths().push_back(std::string(PS4SDKLibDir.str()));
216 }
217 
219  return new tools::PS4cpu::Assemble(*this);
220 }
221 
223  return new tools::PS4cpu::Link(*this);
224 }
225 
226 bool toolchains::PS4CPU::isPICDefault() const { return true; }
227 
228 bool toolchains::PS4CPU::HasNativeLLVMSupport() const { return true; }
229 
232  Res |= SanitizerKind::Address;
233  Res |= SanitizerKind::PointerCompare;
234  Res |= SanitizerKind::PointerSubtract;
235  Res |= SanitizerKind::Vptr;
236  return Res;
237 }
238 
240  const ArgList &DriverArgs,
241  ArgStringList &CC1Args,
242  Action::OffloadKind DeviceOffloadingKind) const {
243  // PS4 does not use init arrays.
244  if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
245  Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
246  getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
247  << A->getAsString(DriverArgs) << getTriple().str();
248  }
249 
250  CC1Args.push_back("-fno-use-init-array");
251 }
void addProfileRTArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Tool * buildLinker() const override
Definition: PS4CPU.cpp:222
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
const char * getFilename() const
Definition: InputInfo.h:83
PS4CPU(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: PS4CPU.cpp:159
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:120
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
path_list & getFilePaths()
Definition: ToolChain.h:242
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadingKind) const override
Add options that need to be passed to cc1 for this target.
Definition: PS4CPU.cpp:239
Tool * buildAssembler() const override
Definition: PS4CPU.cpp:218
static constexpr ResponseFileSupport AtFileUTF8()
Definition: Job.h:84
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Definition: PS4CPU.cpp:226
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:205
void addSanitizerArgs(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
const Driver & getDriver() const
Definition: ToolChain.h:204
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
Definition: PS4CPU.cpp:228
static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs)
Definition: PS4CPU.cpp:73
Dataflow Directional Tag Classes.
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
std::string SysRoot
sysroot, if present
Definition: Driver.h:148
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
const SanitizerArgs & getSanitizerArgs() const
Definition: ToolChain.cpp:117
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: PS4CPU.cpp:49
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: PS4CPU.cpp:230
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
const llvm::Triple & getTriple() const
Definition: ToolChain.h:206
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:988
bool isNothing() const
Definition: InputInfo.h:74
std::string GetProgramPath(const char *Name) const
Definition: ToolChain.cpp:545
bool isFilename() const
Definition: InputInfo.h:75
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:90