clang 17.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 "CommonArgs.h"
11#include "clang/Config/config.h"
13#include "clang/Driver/Driver.h"
17#include "llvm/Option/ArgList.h"
18#include "llvm/Support/FileSystem.h"
19#include "llvm/Support/Path.h"
20#include <cstdlib> // ::getenv
21
22using namespace clang::driver;
23using namespace clang;
24using namespace llvm::opt;
25
26// Helper to paste bits of an option together and return a saved string.
27static const char *makeArgString(const ArgList &Args, const char *Prefix,
28 const char *Base, const char *Suffix) {
29 // Basically "Prefix + Base + Suffix" all converted to Twine then saved.
30 return Args.MakeArgString(Twine(StringRef(Prefix), Base) + Suffix);
31}
32
33void tools::PScpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args,
34 ArgStringList &CmdArgs) {
35 assert(TC.getTriple().isPS());
36 auto &PSTC = static_cast<const toolchains::PS4PS5Base &>(TC);
37
38 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
39 false) ||
40 Args.hasFlag(options::OPT_fprofile_generate,
41 options::OPT_fno_profile_generate, false) ||
42 Args.hasFlag(options::OPT_fprofile_generate_EQ,
43 options::OPT_fno_profile_generate, false) ||
44 Args.hasFlag(options::OPT_fprofile_instr_generate,
45 options::OPT_fno_profile_instr_generate, false) ||
46 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
47 options::OPT_fno_profile_instr_generate, false) ||
48 Args.hasFlag(options::OPT_fcs_profile_generate,
49 options::OPT_fno_profile_generate, false) ||
50 Args.hasFlag(options::OPT_fcs_profile_generate_EQ,
51 options::OPT_fno_profile_generate, false) ||
52 Args.hasArg(options::OPT_fcreate_profile) ||
53 Args.hasArg(options::OPT_coverage)))
54 CmdArgs.push_back(makeArgString(
55 Args, "--dependent-lib=", PSTC.getProfileRTLibName(), ""));
56}
57
59 const InputInfo &Output,
60 const InputInfoList &Inputs,
61 const ArgList &Args,
62 const char *LinkingOutput) const {
63 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain());
64 claimNoWarnArgs(Args);
65 ArgStringList CmdArgs;
66
67 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
68
69 CmdArgs.push_back("-o");
70 CmdArgs.push_back(Output.getFilename());
71
72 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
73 const InputInfo &Input = Inputs[0];
74 assert(Input.isFilename() && "Invalid input.");
75 CmdArgs.push_back(Input.getFilename());
76
77 std::string AsName = TC.qualifyPSCmdName("as");
78 const char *Exec = Args.MakeArgString(TC.GetProgramPath(AsName.c_str()));
79 C.addCommand(std::make_unique<Command>(JA, *this,
81 Exec, CmdArgs, Inputs, Output));
82}
83
84void tools::PScpu::addSanitizerArgs(const ToolChain &TC, const ArgList &Args,
85 ArgStringList &CmdArgs) {
86 assert(TC.getTriple().isPS());
87 auto &PSTC = static_cast<const toolchains::PS4PS5Base &>(TC);
88 PSTC.addSanitizerArgs(Args, CmdArgs, "--dependent-lib=lib", ".a");
89}
90
91void toolchains::PS4CPU::addSanitizerArgs(const ArgList &Args,
92 ArgStringList &CmdArgs,
93 const char *Prefix,
94 const char *Suffix) const {
95 auto arg = [&](const char *Name) -> const char * {
96 return makeArgString(Args, Prefix, Name, Suffix);
97 };
98 const SanitizerArgs &SanArgs = getSanitizerArgs(Args);
99 if (SanArgs.needsUbsanRt())
100 CmdArgs.push_back(arg("SceDbgUBSanitizer_stub_weak"));
101 if (SanArgs.needsAsanRt())
102 CmdArgs.push_back(arg("SceDbgAddressSanitizer_stub_weak"));
103}
104
106 ArgStringList &CmdArgs,
107 const char *Prefix,
108 const char *Suffix) const {
109 auto arg = [&](const char *Name) -> const char * {
110 return makeArgString(Args, Prefix, Name, Suffix);
111 };
112 const SanitizerArgs &SanArgs = getSanitizerArgs(Args);
113 if (SanArgs.needsUbsanRt())
114 CmdArgs.push_back(arg("SceUBSanitizer_nosubmission_stub_weak"));
115 if (SanArgs.needsAsanRt())
116 CmdArgs.push_back(arg("SceAddressSanitizer_nosubmission_stub_weak"));
117 if (SanArgs.needsTsanRt())
118 CmdArgs.push_back(arg("SceThreadSanitizer_nosubmission_stub_weak"));
119}
120
122 const InputInfo &Output,
123 const InputInfoList &Inputs,
124 const ArgList &Args,
125 const char *LinkingOutput) const {
126 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain());
127 const Driver &D = TC.getDriver();
128 ArgStringList CmdArgs;
129
130 // Silence warning for "clang -g foo.o -o foo"
131 Args.ClaimAllArgs(options::OPT_g_Group);
132 // and "clang -emit-llvm foo.o -o foo"
133 Args.ClaimAllArgs(options::OPT_emit_llvm);
134 // and for "clang -w foo.o -o foo". Other warning options are already
135 // handled somewhere else.
136 Args.ClaimAllArgs(options::OPT_w);
137
138 if (!D.SysRoot.empty())
139 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
140
141 if (Args.hasArg(options::OPT_pie))
142 CmdArgs.push_back("-pie");
143
144 if (Args.hasArg(options::OPT_rdynamic))
145 CmdArgs.push_back("-export-dynamic");
146 if (Args.hasArg(options::OPT_shared))
147 CmdArgs.push_back("--shared");
148
149 if (Output.isFilename()) {
150 CmdArgs.push_back("-o");
151 CmdArgs.push_back(Output.getFilename());
152 } else {
153 assert(Output.isNothing() && "Invalid output.");
154 }
155
156 const bool UseLTO = D.isUsingLTO();
157 const bool UseJMC =
158 Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false);
159 const bool IsPS4 = TC.getTriple().isPS4();
160 const bool IsPS5 = TC.getTriple().isPS5();
161 assert(IsPS4 || IsPS5);
162
163 auto AddCodeGenFlag = [&](Twine Flag) {
164 const char *Prefix = nullptr;
165 if (IsPS4 && D.getLTOMode() == LTOK_Thin)
166 Prefix = "-lto-thin-debug-options=";
167 else if (IsPS4 && D.getLTOMode() == LTOK_Full)
168 Prefix = "-lto-debug-options=";
169 else if (IsPS5)
170 Prefix = "-plugin-opt=";
171 else
172 llvm_unreachable("new LTO mode?");
173
174 CmdArgs.push_back(Args.MakeArgString(Twine(Prefix) + Flag));
175 };
176
177 if (UseLTO) {
178 // We default to creating the arange section, but LTO does not. Enable it
179 // here.
180 AddCodeGenFlag("-generate-arange-section");
181
182 // This tells LTO to perform JustMyCode instrumentation.
183 if (UseJMC)
184 AddCodeGenFlag("-enable-jmc-instrument");
185
186 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
187 AddCodeGenFlag(Twine("-crash-diagnostics-dir=") + A->getValue());
188 }
189
190 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
191 TC.addSanitizerArgs(Args, CmdArgs, "-l", "");
192
193 Args.AddAllArgs(CmdArgs, options::OPT_L);
194 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
195 Args.AddAllArgs(CmdArgs, options::OPT_e);
196 Args.AddAllArgs(CmdArgs, options::OPT_s);
197 Args.AddAllArgs(CmdArgs, options::OPT_t);
198 Args.AddAllArgs(CmdArgs, options::OPT_r);
199
200 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
201 CmdArgs.push_back("--no-demangle");
202
203 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
204
205 if (Args.hasArg(options::OPT_pthread)) {
206 CmdArgs.push_back("-lpthread");
207 }
208
209 if (UseJMC) {
210 CmdArgs.push_back("--whole-archive");
211 if (IsPS4)
212 CmdArgs.push_back("-lSceDbgJmc");
213 else
214 CmdArgs.push_back("-lSceJmc_nosubmission");
215 CmdArgs.push_back("--no-whole-archive");
216 }
217
218 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
219 D.Diag(diag::err_drv_unsupported_opt_for_target)
220 << "-fuse-ld" << TC.getTriple().str();
221 }
222
223 std::string LdName = TC.qualifyPSCmdName(TC.getLinkerBaseName());
224 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LdName.c_str()));
225
226 C.addCommand(std::make_unique<Command>(JA, *this,
228 Exec, CmdArgs, Inputs, Output));
229}
230
231toolchains::PS4PS5Base::PS4PS5Base(const Driver &D, const llvm::Triple &Triple,
232 const ArgList &Args, StringRef Platform,
233 const char *EnvVar)
234 : Generic_ELF(D, Triple, Args) {
235 if (Args.hasArg(clang::driver::options::OPT_static))
236 D.Diag(clang::diag::err_drv_unsupported_opt_for_target)
237 << "-static" << Platform;
238
239 // Determine where to find the PS4/PS5 libraries. We use the EnvVar
240 // if it exists; otherwise use the driver's installation path, which
241 // should be <SDK_DIR>/host_tools/bin.
242
243 SmallString<512> SDKDir;
244 if (const char *EnvValue = getenv(EnvVar)) {
245 if (!llvm::sys::fs::exists(EnvValue))
246 D.Diag(clang::diag::warn_drv_ps_sdk_dir) << EnvVar << EnvValue;
247 SDKDir = EnvValue;
248 } else {
249 SDKDir = D.Dir;
250 llvm::sys::path::append(SDKDir, "/../../");
251 }
252
253 // By default, the driver won't report a warning if it can't find the
254 // SDK include or lib directories. This behavior could be changed if
255 // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
256 // If -isysroot was passed, use that as the SDK base path.
257 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
258 SDKRootDir = A->getValue();
259 if (!llvm::sys::fs::exists(SDKRootDir))
260 D.Diag(clang::diag::warn_missing_sysroot) << SDKRootDir;
261 } else
262 SDKRootDir = std::string(SDKDir.str());
263
264 SmallString<512> SDKIncludeDir(SDKRootDir);
265 llvm::sys::path::append(SDKIncludeDir, "target/include");
266 if (!Args.hasArg(options::OPT_nostdinc) &&
267 !Args.hasArg(options::OPT_nostdlibinc) &&
268 !Args.hasArg(options::OPT_isysroot) &&
269 !Args.hasArg(options::OPT__sysroot_EQ) &&
270 !llvm::sys::fs::exists(SDKIncludeDir)) {
271 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
272 << Twine(Platform, " system headers").str() << SDKIncludeDir;
273 }
274
275 SmallString<512> SDKLibDir(SDKRootDir);
276 llvm::sys::path::append(SDKLibDir, "target/lib");
277 if (!Args.hasArg(options::OPT_nostdlib) &&
278 !Args.hasArg(options::OPT_nodefaultlibs) &&
279 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
280 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
281 !Args.hasArg(options::OPT_emit_ast) &&
282 !llvm::sys::fs::exists(SDKLibDir)) {
283 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
284 << Twine(Platform, " system libraries").str() << SDKLibDir;
285 return;
286 }
287 getFilePaths().push_back(std::string(SDKLibDir.str()));
288}
289
291 const ArgList &DriverArgs,
292 ArgStringList &CC1Args) const {
293 const Driver &D = getDriver();
294
295 if (DriverArgs.hasArg(options::OPT_nostdinc))
296 return;
297
298 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
300 llvm::sys::path::append(Dir, "include");
301 addSystemInclude(DriverArgs, CC1Args, Dir.str());
302 }
303
304 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
305 return;
306
307 addExternCSystemInclude(DriverArgs, CC1Args,
308 SDKRootDir + "/target/include");
309 addExternCSystemInclude(DriverArgs, CC1Args,
310 SDKRootDir + "/target/include_common");
311}
312
314 return new tools::PScpu::Assembler(*this);
315}
316
318 // PS5 does not support an external assembler.
319 getDriver().Diag(clang::diag::err_no_external_assembler);
320 return nullptr;
321}
322
324 return new tools::PScpu::Linker(*this);
325}
326
329 Res |= SanitizerKind::Address;
330 Res |= SanitizerKind::PointerCompare;
331 Res |= SanitizerKind::PointerSubtract;
332 Res |= SanitizerKind::Vptr;
333 return Res;
334}
335
338 Res |= SanitizerKind::Thread;
339 return Res;
340}
341
343 const ArgList &DriverArgs, ArgStringList &CC1Args,
344 Action::OffloadKind DeviceOffloadingKind) const {
345 // PS4/PS5 do not use init arrays.
346 if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
347 Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
348 getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
349 << A->getAsString(DriverArgs) << getTriple().str();
350 }
351
352 CC1Args.push_back("-fno-use-init-array");
353
354 const Arg *A =
355 DriverArgs.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
356 options::OPT_fno_visibility_from_dllstorageclass);
357 if (!A ||
358 A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass)) {
359 CC1Args.push_back("-fvisibility-from-dllstorageclass");
360
361 if (DriverArgs.hasArg(options::OPT_fvisibility_dllexport_EQ))
362 DriverArgs.AddLastArg(CC1Args, options::OPT_fvisibility_dllexport_EQ);
363 else
364 CC1Args.push_back("-fvisibility-dllexport=protected");
365
366 if (DriverArgs.hasArg(options::OPT_fvisibility_nodllstorageclass_EQ))
367 DriverArgs.AddLastArg(CC1Args,
368 options::OPT_fvisibility_nodllstorageclass_EQ);
369 else
370 CC1Args.push_back("-fvisibility-nodllstorageclass=hidden");
371
372 if (DriverArgs.hasArg(options::OPT_fvisibility_externs_dllimport_EQ))
373 DriverArgs.AddLastArg(CC1Args,
374 options::OPT_fvisibility_externs_dllimport_EQ);
375 else
376 CC1Args.push_back("-fvisibility-externs-dllimport=default");
377
378 if (DriverArgs.hasArg(
379 options::OPT_fvisibility_externs_nodllstorageclass_EQ))
380 DriverArgs.AddLastArg(
381 CC1Args, options::OPT_fvisibility_externs_nodllstorageclass_EQ);
382 else
383 CC1Args.push_back("-fvisibility-externs-nodllstorageclass=default");
384 }
385}
386
387// PS4 toolchain.
388toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
389 const llvm::opt::ArgList &Args)
390 : PS4PS5Base(D, Triple, Args, "PS4", "SCE_ORBIS_SDK_DIR") {}
391
392// PS5 toolchain.
393toolchains::PS5CPU::PS5CPU(const Driver &D, const llvm::Triple &Triple,
394 const llvm::opt::ArgList &Args)
395 : PS4PS5Base(D, Triple, Args, "PS5", "SCE_PROSPERO_SDK_DIR") {}
static const char * makeArgString(const ArgList &Args, const char *Prefix, const char *Base, const char *Suffix)
Definition: PS4CPU.cpp:27
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
std::string SysRoot
sysroot, if present
Definition: Driver.h:183
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:144
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
Definition: Driver.h:704
std::string ResourceDir
The path to the compiler resource directory.
Definition: Driver.h:167
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
Definition: Driver.h:699
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:155
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
const char * getFilename() const
Definition: InputInfo.h:83
bool isNothing() const
Definition: InputInfo.h:74
bool isFilename() const
Definition: InputInfo.h:75
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
path_list & getFilePaths()
Definition: ToolChain.h:278
const Driver & getDriver() const
Definition: ToolChain.h:236
const llvm::Triple & getTriple() const
Definition: ToolChain.h:238
std::string GetProgramPath(const char *Name) const
Definition: ToolChain.cpp:664
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:1144
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
const ToolChain & getToolChain() const
Definition: Tool.h:52
void addSanitizerArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const char *Prefix, const char *Suffix) const override
Definition: PS4CPU.cpp:91
Tool * buildAssembler() const override
Definition: PS4CPU.cpp:313
PS4CPU(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: PS4CPU.cpp:388
Tool * buildLinker() const override
Definition: PS4CPU.cpp:323
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: PS4CPU.cpp:290
virtual void addSanitizerArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const char *Prefix, const char *Suffix) const =0
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:342
PS4PS5Base(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, StringRef Platform, const char *EnvVar)
Definition: PS4CPU.cpp:231
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: PS4CPU.cpp:327
Tool * buildAssembler() const override
Definition: PS4CPU.cpp:317
void addSanitizerArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const char *Prefix, const char *Suffix) const override
Definition: PS4CPU.cpp:105
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: PS4CPU.cpp:336
PS5CPU(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: PS4CPU.cpp:393
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:58
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:121
void addSanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
void addProfileRTArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
@ C
Languages that the frontend can parse and compile.
static constexpr ResponseFileSupport AtFileUTF8()
Definition: Job.h:85