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 "clang/Config/config.h"
11#include "clang/Driver/CommonArgs.h"
12#include "clang/Driver/Compilation.h"
13#include "clang/Driver/Driver.h"
14#include "clang/Driver/Options.h"
15#include "clang/Driver/SanitizerArgs.h"
16#include "llvm/Option/ArgList.h"
17#include "llvm/Support/FileSystem.h"
18#include "llvm/Support/Path.h"
19#include <cstdlib> // ::getenv
20
21using namespace clang::driver;
22using namespace clang;
23using namespace llvm::opt;
24
25// Helper to paste bits of an option together and return a saved string.
26static const char *makeArgString(const ArgList &Args, const char *Prefix,
27 const char *Base, const char *Suffix) {
28 // Basically "Prefix + Base + Suffix" all converted to Twine then saved.
29 return Args.MakeArgString(Str: Twine(StringRef(Prefix), Base) + Suffix);
30}
31
32void tools::PScpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args,
33 ArgStringList &CmdArgs) {
34 assert(TC.getTriple().isPS());
35 auto &PSTC = static_cast<const toolchains::PS4PS5Base &>(TC);
36
37 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
38 false) ||
39 Args.hasFlag(options::OPT_fprofile_generate,
40 options::OPT_fno_profile_generate, false) ||
41 Args.hasFlag(options::OPT_fprofile_generate_EQ,
42 options::OPT_fno_profile_generate, false) ||
43 Args.hasFlag(options::OPT_fprofile_instr_generate,
44 options::OPT_fno_profile_instr_generate, false) ||
45 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
46 options::OPT_fno_profile_instr_generate, false) ||
47 Args.hasFlag(options::OPT_fcs_profile_generate,
48 options::OPT_fno_profile_generate, false) ||
49 Args.hasFlag(options::OPT_fcs_profile_generate_EQ,
50 options::OPT_fno_profile_generate, false) ||
51 Args.hasArg(options::OPT_fcreate_profile) ||
52 Args.hasArg(options::OPT_coverage)))
53 CmdArgs.push_back(Elt: makeArgString(
54 Args, Prefix: "--dependent-lib=", Base: PSTC.getProfileRTLibName(), Suffix: ""));
55}
56
57void tools::PScpu::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
58 const InputInfo &Output,
59 const InputInfoList &Inputs,
60 const ArgList &Args,
61 const char *LinkingOutput) const {
62 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain());
63 claimNoWarnArgs(Args);
64 ArgStringList CmdArgs;
65
66 Args.AddAllArgValues(Output&: CmdArgs, options::Id0: OPT_Wa_COMMA, options::Id1: OPT_Xassembler);
67
68 CmdArgs.push_back(Elt: "-o");
69 CmdArgs.push_back(Elt: Output.getFilename());
70
71 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
72 const InputInfo &Input = Inputs[0];
73 assert(Input.isFilename() && "Invalid input.");
74 CmdArgs.push_back(Elt: Input.getFilename());
75
76 std::string AsName = TC.qualifyPSCmdName(CmdName: "as");
77 const char *Exec = Args.MakeArgString(Str: TC.GetProgramPath(Name: AsName.c_str()));
78 C.addCommand(C: std::make_unique<Command>(args: JA, args: *this,
79 args: ResponseFileSupport::AtFileUTF8(),
80 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
81}
82
83void tools::PScpu::addSanitizerArgs(const ToolChain &TC, const ArgList &Args,
84 ArgStringList &CmdArgs) {
85 assert(TC.getTriple().isPS());
86 auto &PSTC = static_cast<const toolchains::PS4PS5Base &>(TC);
87 PSTC.addSanitizerArgs(Args, CmdArgs, Prefix: "--dependent-lib=lib", Suffix: ".a");
88}
89
90void toolchains::PS4CPU::addSanitizerArgs(const ArgList &Args,
91 ArgStringList &CmdArgs,
92 const char *Prefix,
93 const char *Suffix) const {
94 auto arg = [&](const char *Name) -> const char * {
95 return makeArgString(Args, Prefix, Base: Name, Suffix);
96 };
97 const SanitizerArgs &SanArgs = getSanitizerArgs(JobArgs: Args);
98 if (SanArgs.needsUbsanRt())
99 CmdArgs.push_back(Elt: arg("SceDbgUBSanitizer_stub_weak"));
100 if (SanArgs.needsAsanRt())
101 CmdArgs.push_back(Elt: arg("SceDbgAddressSanitizer_stub_weak"));
102}
103
104void toolchains::PS5CPU::addSanitizerArgs(const ArgList &Args,
105 ArgStringList &CmdArgs,
106 const char *Prefix,
107 const char *Suffix) const {
108 auto arg = [&](const char *Name) -> const char * {
109 return makeArgString(Args, Prefix, Base: Name, Suffix);
110 };
111 const SanitizerArgs &SanArgs = getSanitizerArgs(JobArgs: Args);
112 if (SanArgs.needsUbsanRt())
113 CmdArgs.push_back(Elt: arg("SceUBSanitizer_nosubmission_stub_weak"));
114 if (SanArgs.needsAsanRt())
115 CmdArgs.push_back(Elt: arg("SceAddressSanitizer_nosubmission_stub_weak"));
116 if (SanArgs.needsTsanRt())
117 CmdArgs.push_back(Elt: arg("SceThreadSanitizer_nosubmission_stub_weak"));
118}
119
120void tools::PS4cpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
121 const InputInfo &Output,
122 const InputInfoList &Inputs,
123 const ArgList &Args,
124 const char *LinkingOutput) const {
125 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain());
126 const Driver &D = TC.getDriver();
127 ArgStringList CmdArgs;
128
129 // Silence warning for "clang -g foo.o -o foo"
130 Args.ClaimAllArgs(options::OPT_g_Group);
131 // and "clang -emit-llvm foo.o -o foo"
132 Args.ClaimAllArgs(options::OPT_emit_llvm);
133 // and for "clang -w foo.o -o foo". Other warning options are already
134 // handled somewhere else.
135 Args.ClaimAllArgs(options::OPT_w);
136
137 CmdArgs.push_back(
138 Elt: Args.MakeArgString(Str: "--sysroot=" + TC.getSDKLibraryRootDir()));
139
140 if (Args.hasArg(options::OPT_pie))
141 CmdArgs.push_back(Elt: "-pie");
142
143 if (Args.hasArg(options::OPT_static))
144 CmdArgs.push_back(Elt: "-static");
145 if (Args.hasArg(options::OPT_rdynamic))
146 CmdArgs.push_back(Elt: "-export-dynamic");
147 if (Args.hasArg(options::OPT_shared))
148 CmdArgs.push_back(Elt: "--shared");
149
150 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
151 if (Output.isFilename()) {
152 CmdArgs.push_back(Elt: "-o");
153 CmdArgs.push_back(Elt: Output.getFilename());
154 }
155
156 const bool UseJMC =
157 Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false);
158
159 const char *LTOArgs = "";
160 auto AddLTOFlag = [&](Twine Flag) {
161 LTOArgs = Args.MakeArgString(Str: Twine(LTOArgs) + " " + Flag);
162 };
163
164 // If the linker sees bitcode objects it will perform LTO. We can't tell
165 // whether or not that will be the case at this point. So, unconditionally
166 // pass LTO options to ensure proper codegen, metadata production, etc if
167 // LTO indeed occurs.
168 if (Args.hasFlag(options::OPT_funified_lto, options::OPT_fno_unified_lto,
169 true))
170 CmdArgs.push_back(Elt: D.getLTOMode() == LTOK_Thin ? "--lto=thin"
171 : "--lto=full");
172 if (UseJMC)
173 AddLTOFlag("-enable-jmc-instrument");
174
175 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
176 AddLTOFlag(Twine("-crash-diagnostics-dir=") + A->getValue());
177
178 if (StringRef Threads = getLTOParallelism(Args, D); !Threads.empty())
179 AddLTOFlag(Twine("-threads=") + Threads);
180
181 if (*LTOArgs)
182 CmdArgs.push_back(
183 Elt: Args.MakeArgString(Str: Twine("-lto-debug-options=") + LTOArgs));
184
185 // Sanitizer runtimes must be supplied before all other objects and libs.
186 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
187 TC.addSanitizerArgs(Args, CmdArgs, Prefix: "-l", Suffix: "");
188
189 // Other drivers typically add library search paths (`-L`) here via
190 // TC.AddFilePathLibArgs(). We don't do that on PS4 as the PS4 linker
191 // searches those locations by default.
192 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
193 options::OPT_s, options::OPT_t});
194
195 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
196 CmdArgs.push_back(Elt: "--no-demangle");
197
198 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
199
200 if (Args.hasArg(options::OPT_pthread)) {
201 CmdArgs.push_back(Elt: "-lpthread");
202 }
203
204 if (UseJMC) {
205 CmdArgs.push_back(Elt: "--whole-archive");
206 CmdArgs.push_back(Elt: "-lSceDbgJmc");
207 CmdArgs.push_back(Elt: "--no-whole-archive");
208 }
209
210 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
211 D.Diag(diag::DiagID: err_drv_unsupported_opt_for_target)
212 << "-fuse-ld" << TC.getTriple().str();
213 }
214
215 std::string LdName = TC.qualifyPSCmdName(CmdName: TC.getLinkerBaseName());
216 const char *Exec = Args.MakeArgString(Str: TC.GetProgramPath(Name: LdName.c_str()));
217
218 C.addCommand(C: std::make_unique<Command>(args: JA, args: *this,
219 args: ResponseFileSupport::AtFileUTF8(),
220 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
221}
222
223void tools::PS5cpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
224 const InputInfo &Output,
225 const InputInfoList &Inputs,
226 const ArgList &Args,
227 const char *LinkingOutput) const {
228 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain());
229 const Driver &D = TC.getDriver();
230 ArgStringList CmdArgs;
231
232 const bool Relocatable = Args.hasArg(options::OPT_r);
233 const bool Shared = Args.hasArg(options::OPT_shared);
234 const bool Static = Args.hasArg(options::OPT_static);
235
236 // Silence warning for "clang -g foo.o -o foo"
237 Args.ClaimAllArgs(options::OPT_g_Group);
238 // and "clang -emit-llvm foo.o -o foo"
239 Args.ClaimAllArgs(options::OPT_emit_llvm);
240 // and for "clang -w foo.o -o foo". Other warning options are already
241 // handled somewhere else.
242 Args.ClaimAllArgs(options::OPT_w);
243
244 CmdArgs.push_back(Elt: "-m");
245 CmdArgs.push_back(Elt: "elf_x86_64_fbsd");
246
247 CmdArgs.push_back(
248 Elt: Args.MakeArgString(Str: "--sysroot=" + TC.getSDKLibraryRootDir()));
249
250 // Default to PIE for non-static executables.
251 const bool PIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
252 !Relocatable && !Shared && !Static);
253 if (PIE)
254 CmdArgs.push_back(Elt: "-pie");
255
256 if (!Relocatable) {
257 CmdArgs.push_back(Elt: "--eh-frame-hdr");
258 CmdArgs.push_back(Elt: "--hash-style=sysv");
259
260 // Add a build-id by default to allow the PlayStation symbol server to
261 // index the symbols. `uuid` is the cheapest fool-proof method.
262 // (The non-determinism and alternative methods are noted in the downstream
263 // PlayStation docs).
264 // Static executables are only used for a handful of specialized components,
265 // where the extra section is not wanted.
266 if (!Static)
267 CmdArgs.push_back(Elt: "--build-id=uuid");
268
269 // All references are expected to be resolved at static link time for both
270 // executables and dynamic libraries. This has been the default linking
271 // behaviour for numerous PlayStation generations.
272 CmdArgs.push_back(Elt: "--unresolved-symbols=report-all");
273
274 // Lazy binding of PLTs is not supported on PlayStation. They are placed in
275 // the RelRo segment.
276 CmdArgs.push_back(Elt: "-z");
277 CmdArgs.push_back(Elt: "now");
278
279 // Don't export linker-generated __start/stop... section bookends.
280 CmdArgs.push_back(Elt: "-z");
281 CmdArgs.push_back(Elt: "start-stop-visibility=hidden");
282
283 // DT_DEBUG is not supported on PlayStation.
284 CmdArgs.push_back(Elt: "-z");
285 CmdArgs.push_back(Elt: "rodynamic");
286
287 CmdArgs.push_back(Elt: "-z");
288 CmdArgs.push_back(Elt: "common-page-size=0x4000");
289
290 CmdArgs.push_back(Elt: "-z");
291 CmdArgs.push_back(Elt: "max-page-size=0x4000");
292
293 // Patch relocated regions of DWARF whose targets are eliminated at link
294 // time with specific tombstones, such that they're recognisable by the
295 // PlayStation debugger.
296 CmdArgs.push_back(Elt: "-z");
297 CmdArgs.push_back(Elt: "dead-reloc-in-nonalloc=.debug_*=0xffffffffffffffff");
298 CmdArgs.push_back(Elt: "-z");
299 CmdArgs.push_back(
300 Elt: "dead-reloc-in-nonalloc=.debug_ranges=0xfffffffffffffffe");
301 CmdArgs.push_back(Elt: "-z");
302 CmdArgs.push_back(Elt: "dead-reloc-in-nonalloc=.debug_loc=0xfffffffffffffffe");
303
304 // The PlayStation loader expects linked objects to be laid out in a
305 // particular way. This is achieved by linker scripts that are supplied
306 // with the SDK. The scripts are inside <sdkroot>/target/lib, which is
307 // added as a search path elsewhere.
308 // "PRX" has long stood for "PlayStation Relocatable eXecutable".
309 if (!Args.hasArgNoClaim(options::OPT_T)) {
310 CmdArgs.push_back(Elt: "--default-script");
311 CmdArgs.push_back(Elt: Static ? "static.script"
312 : Shared ? "prx.script"
313 : "main.script");
314 }
315 }
316
317 if (Static)
318 CmdArgs.push_back(Elt: "-static");
319 if (Args.hasArg(options::OPT_rdynamic))
320 CmdArgs.push_back(Elt: "-export-dynamic");
321 if (Shared)
322 CmdArgs.push_back(Elt: "--shared");
323
324 // Provide a base address for non-PIE executables. This includes cases where
325 // -static is supplied without -pie.
326 if (!Relocatable && !Shared && !PIE)
327 CmdArgs.push_back(Elt: "--image-base=0x400000");
328
329 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
330 if (Output.isFilename()) {
331 CmdArgs.push_back(Elt: "-o");
332 CmdArgs.push_back(Elt: Output.getFilename());
333 }
334
335 const bool UseJMC =
336 Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false);
337
338 auto AddLTOFlag = [&](Twine Flag) {
339 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine("-plugin-opt=") + Flag));
340 };
341
342 // If the linker sees bitcode objects it will perform LTO. We can't tell
343 // whether or not that will be the case at this point. So, unconditionally
344 // pass LTO options to ensure proper codegen, metadata production, etc if
345 // LTO indeed occurs.
346 if (Args.hasFlag(options::OPT_funified_lto, options::OPT_fno_unified_lto,
347 true))
348 CmdArgs.push_back(Elt: D.getLTOMode() == LTOK_Thin ? "--lto=thin"
349 : "--lto=full");
350
351 AddLTOFlag("-emit-jump-table-sizes-section");
352
353 if (UseJMC)
354 AddLTOFlag("-enable-jmc-instrument");
355
356 if (Args.hasFlag(options::OPT_fstack_size_section,
357 options::OPT_fno_stack_size_section, false))
358 AddLTOFlag("-stack-size-section");
359
360 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
361 AddLTOFlag(Twine("-crash-diagnostics-dir=") + A->getValue());
362
363 if (StringRef Jobs = getLTOParallelism(Args, D); !Jobs.empty())
364 AddLTOFlag(Twine("jobs=") + Jobs);
365
366 Args.AddAllArgs(CmdArgs, options::OPT_L);
367 TC.AddFilePathLibArgs(Args, CmdArgs);
368 Args.addAllArgs(CmdArgs,
369 {options::OPT_T_Group, options::OPT_s, options::OPT_t});
370
371 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
372 CmdArgs.push_back(Elt: "--no-demangle");
373
374 // Sanitizer runtimes must be supplied before all other objects and libs.
375 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
376 TC.addSanitizerArgs(Args, CmdArgs, Prefix: "-l", Suffix: "");
377
378 const bool AddStartFiles =
379 !Relocatable &&
380 !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib);
381
382 auto AddCRTObject = [&](const char *Name) {
383 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name)));
384 };
385
386 if (AddStartFiles) {
387 if (!Shared)
388 AddCRTObject("crt1.o");
389 AddCRTObject("crti.o");
390 AddCRTObject(Shared ? "crtbeginS.o"
391 : Static ? "crtbeginT.o"
392 : "crtbegin.o");
393 }
394
395 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
396
397 if (!Relocatable &&
398 !Args.hasArg(options::OPT_nodefaultlibs, options::OPT_nostdlib)) {
399
400 if (UseJMC) {
401 CmdArgs.push_back(Elt: "--push-state");
402 CmdArgs.push_back(Elt: "--whole-archive");
403 CmdArgs.push_back(Elt: "-lSceJmc_nosubmission");
404 CmdArgs.push_back(Elt: "--pop-state");
405 }
406
407 if (Args.hasArg(options::OPT_pthread))
408 CmdArgs.push_back(Elt: "-lpthread");
409
410 if (Static) {
411 if (!Args.hasArg(options::OPT_nostdlibxx))
412 CmdArgs.push_back(Elt: "-lstdc++");
413 if (!Args.hasArg(options::OPT_nolibc)) {
414 CmdArgs.push_back(Elt: "-lm");
415 CmdArgs.push_back(Elt: "-lc");
416 }
417
418 CmdArgs.push_back(Elt: "-lcompiler_rt");
419 CmdArgs.push_back(Elt: "-lkernel");
420 } else {
421 // The C and C++ libraries are combined.
422 if (!Args.hasArg(options::OPT_nolibc, options::OPT_nostdlibxx))
423 CmdArgs.push_back(Elt: "-lc_stub_weak");
424
425 CmdArgs.push_back(Elt: "-lkernel_stub_weak");
426 }
427 }
428 if (AddStartFiles) {
429 AddCRTObject(Shared ? "crtendS.o" : "crtend.o");
430 AddCRTObject("crtn.o");
431 }
432
433 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
434 D.Diag(diag::err_drv_unsupported_opt_for_target)
435 << "-fuse-ld" << TC.getTriple().str();
436 }
437
438 std::string LdName = TC.qualifyPSCmdName(CmdName: TC.getLinkerBaseName());
439 const char *Exec = Args.MakeArgString(Str: TC.GetProgramPath(Name: LdName.c_str()));
440
441 C.addCommand(C: std::make_unique<Command>(args: JA, args: *this,
442 args: ResponseFileSupport::AtFileUTF8(),
443 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
444}
445
446toolchains::PS4PS5Base::PS4PS5Base(const Driver &D, const llvm::Triple &Triple,
447 const ArgList &Args, StringRef Platform,
448 const char *EnvVar)
449 : Generic_ELF(D, Triple, Args) {
450 // Determine the baseline SDK directory from the environment, else
451 // the driver's location, which should be <SDK_DIR>/host_tools/bin.
452 SmallString<128> SDKRootDir;
453 SmallString<80> Whence;
454 if (const char *EnvValue = getenv(name: EnvVar)) {
455 SDKRootDir = EnvValue;
456 Whence = {"environment variable '", EnvVar, "'"};
457 } else {
458 SDKRootDir = D.Dir + "/../../";
459 Whence = "compiler's location";
460 }
461
462 // Allow --sysroot= to override the root directory for header and library
463 // search, and -isysroot to override header search. If both are specified,
464 // -isysroot overrides --sysroot for header search.
465 auto OverrideRoot = [&](const options::ID &Opt, std::string &Root,
466 StringRef Default) {
467 if (const Arg *A = Args.getLastArg(Ids: Opt)) {
468 Root = A->getValue();
469 if (!llvm::sys::fs::exists(Root))
470 D.Diag(clang::diag::warn_missing_sysroot) << Root;
471 return true;
472 }
473 Root = Default.str();
474 return false;
475 };
476
477 bool CustomSysroot =
478 OverrideRoot(options::OPT__sysroot_EQ, SDKLibraryRootDir, SDKRootDir);
479 bool CustomISysroot =
480 OverrideRoot(options::OPT_isysroot, SDKHeaderRootDir, SDKLibraryRootDir);
481
482 // Emit warnings if parts of the SDK are missing, unless the user has taken
483 // control of header or library search. If we're not linking, don't check
484 // for missing libraries.
485 auto CheckSDKPartExists = [&](StringRef Dir, StringRef Desc) {
486 if (llvm::sys::fs::exists(Path: Dir))
487 return true;
488 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
489 << (Twine(Platform) + " " + Desc).str() << Dir << Whence;
490 return false;
491 };
492
493 bool Linking = !Args.hasArg(options::OPT_E, options::OPT_c, options::OPT_S,
494 options::OPT_emit_ast);
495 if (Linking) {
496 SmallString<128> Dir(SDKLibraryRootDir);
497 llvm::sys::path::append(path&: Dir, a: "target/lib");
498 if (CheckSDKPartExists(Dir, "system libraries"))
499 getFilePaths().push_back(Elt: std::string(Dir));
500 }
501 if (!CustomSysroot && !CustomISysroot &&
502 !Args.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc)) {
503 SmallString<128> Dir(SDKHeaderRootDir);
504 llvm::sys::path::append(path&: Dir, a: "target/include");
505 CheckSDKPartExists(Dir, "system headers");
506 }
507
508 getFilePaths().push_back(Elt: ".");
509}
510
511void toolchains::PS4PS5Base::AddClangSystemIncludeArgs(
512 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
513 const Driver &D = getDriver();
514
515 if (DriverArgs.hasArg(options::OPT_nostdinc))
516 return;
517
518 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
519 SmallString<128> Dir(D.ResourceDir);
520 llvm::sys::path::append(path&: Dir, a: "include");
521 addSystemInclude(DriverArgs, CC1Args, Path: Dir.str());
522 }
523
524 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
525 return;
526
527 addExternCSystemInclude(DriverArgs, CC1Args,
528 Path: SDKHeaderRootDir + "/target/include");
529 addExternCSystemInclude(DriverArgs, CC1Args,
530 Path: SDKHeaderRootDir + "/target/include_common");
531}
532
533Tool *toolchains::PS4CPU::buildAssembler() const {
534 return new tools::PScpu::Assembler(*this);
535}
536
537Tool *toolchains::PS4CPU::buildLinker() const {
538 return new tools::PS4cpu::Linker(*this);
539}
540
541Tool *toolchains::PS5CPU::buildAssembler() const {
542 // PS5 does not support an external assembler.
543 getDriver().Diag(clang::diag::err_no_external_assembler);
544 return nullptr;
545}
546
547Tool *toolchains::PS5CPU::buildLinker() const {
548 return new tools::PS5cpu::Linker(*this);
549}
550
551SanitizerMask toolchains::PS4PS5Base::getSupportedSanitizers() const {
552 SanitizerMask Res = ToolChain::getSupportedSanitizers();
553 Res |= SanitizerKind::Address;
554 Res |= SanitizerKind::PointerCompare;
555 Res |= SanitizerKind::PointerSubtract;
556 Res |= SanitizerKind::Vptr;
557 return Res;
558}
559
560SanitizerMask toolchains::PS5CPU::getSupportedSanitizers() const {
561 SanitizerMask Res = PS4PS5Base::getSupportedSanitizers();
562 Res |= SanitizerKind::Thread;
563 return Res;
564}
565
566void toolchains::PS4PS5Base::addClangTargetOptions(
567 const ArgList &DriverArgs, ArgStringList &CC1Args,
568 Action::OffloadKind DeviceOffloadingKind) const {
569 // PS4/PS5 do not use init arrays.
570 if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
571 Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
572 getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
573 << A->getAsString(DriverArgs) << getTriple().str();
574 }
575
576 CC1Args.push_back(Elt: "-fno-use-init-array");
577
578 // Default to `hidden` visibility for PS5.
579 if (getTriple().isPS5() &&
580 !DriverArgs.hasArg(options::OPT_fvisibility_EQ,
581 options::OPT_fvisibility_ms_compat))
582 CC1Args.push_back(Elt: "-fvisibility=hidden");
583
584 // Default to -fvisibility-global-new-delete=source for PS5.
585 if (getTriple().isPS5() &&
586 !DriverArgs.hasArg(options::OPT_fvisibility_global_new_delete_EQ,
587 options::OPT_fvisibility_global_new_delete_hidden))
588 CC1Args.push_back(Elt: "-fvisibility-global-new-delete=source");
589
590 const Arg *A =
591 DriverArgs.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
592 options::OPT_fno_visibility_from_dllstorageclass);
593 if (!A ||
594 A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass)) {
595 CC1Args.push_back(Elt: "-fvisibility-from-dllstorageclass");
596
597 if (DriverArgs.hasArg(options::OPT_fvisibility_dllexport_EQ))
598 DriverArgs.AddLastArg(CC1Args, options::OPT_fvisibility_dllexport_EQ);
599 else
600 CC1Args.push_back(Elt: "-fvisibility-dllexport=protected");
601
602 // For PS4 we override the visibilty of globals definitions without
603 // dllimport or dllexport annotations.
604 if (DriverArgs.hasArg(options::OPT_fvisibility_nodllstorageclass_EQ))
605 DriverArgs.AddLastArg(CC1Args,
606 options::OPT_fvisibility_nodllstorageclass_EQ);
607 else if (getTriple().isPS4())
608 CC1Args.push_back(Elt: "-fvisibility-nodllstorageclass=hidden");
609 else
610 CC1Args.push_back(Elt: "-fvisibility-nodllstorageclass=keep");
611
612 if (DriverArgs.hasArg(options::OPT_fvisibility_externs_dllimport_EQ))
613 DriverArgs.AddLastArg(CC1Args,
614 options::OPT_fvisibility_externs_dllimport_EQ);
615 else
616 CC1Args.push_back(Elt: "-fvisibility-externs-dllimport=default");
617
618 // For PS4 we override the visibilty of external globals without
619 // dllimport or dllexport annotations.
620 if (DriverArgs.hasArg(
621 options::OPT_fvisibility_externs_nodllstorageclass_EQ))
622 DriverArgs.AddLastArg(
623 CC1Args, options::OPT_fvisibility_externs_nodllstorageclass_EQ);
624 else if (getTriple().isPS4())
625 CC1Args.push_back(Elt: "-fvisibility-externs-nodllstorageclass=default");
626 else
627 CC1Args.push_back(Elt: "-fvisibility-externs-nodllstorageclass=keep");
628 }
629
630 // Enable jump table sizes section for PS5.
631 if (getTriple().isPS5()) {
632 CC1Args.push_back(Elt: "-mllvm");
633 CC1Args.push_back(Elt: "-emit-jump-table-sizes-section");
634 }
635}
636
637// PS4 toolchain.
638toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
639 const llvm::opt::ArgList &Args)
640 : PS4PS5Base(D, Triple, Args, "PS4", "SCE_ORBIS_SDK_DIR") {}
641
642// PS5 toolchain.
643toolchains::PS5CPU::PS5CPU(const Driver &D, const llvm::Triple &Triple,
644 const llvm::opt::ArgList &Args)
645 : PS4PS5Base(D, Triple, Args, "PS5", "SCE_PROSPERO_SDK_DIR") {}
646

Provided by KDAB

Privacy Policy
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more

source code of clang/lib/Driver/ToolChains/PS4CPU.cpp