clang 22.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 "clang/Config/config.h"
13#include "clang/Driver/Driver.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(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(makeArgString(
54 Args, "--dependent-lib=", PSTC.getProfileRTLibName(), ""));
55}
56
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(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
67
68 CmdArgs.push_back("-o");
69 CmdArgs.push_back(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(Input.getFilename());
75
76 std::string AsName = TC.qualifyPSCmdName("as");
77 const char *Exec = Args.MakeArgString(TC.GetProgramPath(AsName.c_str()));
78 C.addCommand(std::make_unique<Command>(JA, *this,
80 Exec, CmdArgs, Inputs, 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, "--dependent-lib=lib", ".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, Name, Suffix);
96 };
97 const SanitizerArgs &SanArgs = getSanitizerArgs(Args);
98 if (SanArgs.needsUbsanRt())
99 CmdArgs.push_back(arg("SceDbgUBSanitizer_stub_weak"));
100 if (SanArgs.needsAsanRt())
101 CmdArgs.push_back(arg("SceDbgAddressSanitizer_stub_weak"));
102}
103
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, Name, Suffix);
110 };
111 const SanitizerArgs &SanArgs = getSanitizerArgs(Args);
112 if (SanArgs.needsUbsanRt())
113 CmdArgs.push_back(arg("SceUBSanitizer_nosubmission_stub_weak"));
114 if (SanArgs.needsAsanRt())
115 CmdArgs.push_back(arg("SceAddressSanitizer_nosubmission_stub_weak"));
116 if (SanArgs.needsTsanRt())
117 CmdArgs.push_back(arg("SceThreadSanitizer_nosubmission_stub_weak"));
118}
119
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 Args.MakeArgString("--sysroot=" + TC.getSDKLibraryRootDir()));
139
140 if (Args.hasArg(options::OPT_pie))
141 CmdArgs.push_back("-pie");
142
143 if (Args.hasArg(options::OPT_static))
144 CmdArgs.push_back("-static");
145 if (Args.hasArg(options::OPT_rdynamic))
146 CmdArgs.push_back("-export-dynamic");
147 if (Args.hasArg(options::OPT_shared))
148 CmdArgs.push_back("--shared");
149
150 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
151 if (Output.isFilename()) {
152 CmdArgs.push_back("-o");
153 CmdArgs.push_back(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(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(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 Args.MakeArgString(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, "-l", "");
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("--no-demangle");
197
198 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
199
200 if (Args.hasArg(options::OPT_pthread)) {
201 CmdArgs.push_back("-lpthread");
202 }
203
204 if (UseJMC) {
205 CmdArgs.push_back("--whole-archive");
206 CmdArgs.push_back("-lSceDbgJmc");
207 CmdArgs.push_back("--no-whole-archive");
208 }
209
210 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
211 D.Diag(diag::err_drv_unsupported_opt_for_target)
212 << "-fuse-ld" << TC.getTriple().str();
213 }
214
215 std::string LdName = TC.qualifyPSCmdName(TC.getLinkerBaseName());
216 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LdName.c_str()));
217
218 C.addCommand(std::make_unique<Command>(JA, *this,
220 Exec, CmdArgs, Inputs, Output));
221}
222
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("-m");
245 CmdArgs.push_back("elf_x86_64_fbsd");
246
247 CmdArgs.push_back(
248 Args.MakeArgString("--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("-pie");
255
256 if (!Relocatable) {
257 CmdArgs.push_back("--eh-frame-hdr");
258 CmdArgs.push_back("--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("--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("--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("-z");
277 CmdArgs.push_back("now");
278
279 // Don't export linker-generated __start/stop... section bookends.
280 CmdArgs.push_back("-z");
281 CmdArgs.push_back("start-stop-visibility=hidden");
282
283 // DT_DEBUG is not supported on PlayStation.
284 CmdArgs.push_back("-z");
285 CmdArgs.push_back("rodynamic");
286
287 CmdArgs.push_back("-z");
288 CmdArgs.push_back("common-page-size=0x4000");
289
290 CmdArgs.push_back("-z");
291 CmdArgs.push_back("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("-z");
297 CmdArgs.push_back("dead-reloc-in-nonalloc=.debug_*=0xffffffffffffffff");
298 CmdArgs.push_back("-z");
299 CmdArgs.push_back(
300 "dead-reloc-in-nonalloc=.debug_ranges=0xfffffffffffffffe");
301 CmdArgs.push_back("-z");
302 CmdArgs.push_back("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("--default-script");
311 CmdArgs.push_back(Static ? "static.script"
312 : Shared ? "prx.script"
313 : "main.script");
314 }
315 }
316
317 if (Static)
318 CmdArgs.push_back("-static");
319 if (Args.hasArg(options::OPT_rdynamic))
320 CmdArgs.push_back("-export-dynamic");
321 if (Shared)
322 CmdArgs.push_back("--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("--image-base=0x400000");
328
329 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
330 if (Output.isFilename()) {
331 CmdArgs.push_back("-o");
332 CmdArgs.push_back(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(Args.MakeArgString(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
347 if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_distributor_EQ)) {
348 CmdArgs.push_back(
349 Args.MakeArgString("--thinlto-distributor=" + Twine(A->getValue())));
350 CmdArgs.push_back(Args.MakeArgString("--thinlto-remote-compiler=" +
351 Twine(D.getClangProgramPath())));
352
353 for (const auto &A :
354 Args.getAllArgValues(options::OPT_Xthinlto_distributor_EQ))
355 CmdArgs.push_back(Args.MakeArgString("--thinlto-distributor-arg=" + A));
356 }
357
358 if (Args.hasFlag(options::OPT_funified_lto, options::OPT_fno_unified_lto,
359 true))
360 CmdArgs.push_back(D.getLTOMode() == LTOK_Thin ? "--lto=thin"
361 : "--lto=full");
362
363 AddLTOFlag("-emit-jump-table-sizes-section");
364
365 if (UseJMC)
366 AddLTOFlag("-enable-jmc-instrument");
367
368 if (Args.hasFlag(options::OPT_fstack_size_section,
369 options::OPT_fno_stack_size_section, false))
370 AddLTOFlag("-stack-size-section");
371
372 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
373 AddLTOFlag(Twine("-crash-diagnostics-dir=") + A->getValue());
374
375 if (StringRef Jobs = getLTOParallelism(Args, D); !Jobs.empty())
376 AddLTOFlag(Twine("jobs=") + Jobs);
377
378 Args.AddAllArgs(CmdArgs, options::OPT_L);
379 TC.AddFilePathLibArgs(Args, CmdArgs);
380 Args.addAllArgs(CmdArgs,
381 {options::OPT_T_Group, options::OPT_s, options::OPT_t});
382
383 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
384 CmdArgs.push_back("--no-demangle");
385
386 // Sanitizer runtimes must be supplied before all other objects and libs.
387 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
388 TC.addSanitizerArgs(Args, CmdArgs, "-l", "");
389
390 const bool AddStartFiles =
391 !Relocatable &&
392 !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib);
393
394 auto AddCRTObject = [&](StringRef Name) {
395 // CRT objects can be found on user supplied library paths. This is
396 // an entrenched expectation on PlayStation.
397 CmdArgs.push_back(Args.MakeArgString("-l:" + Name));
398 };
399
400 if (AddStartFiles) {
401 if (!Shared)
402 AddCRTObject("crt1.o");
403 AddCRTObject("crti.o");
404 AddCRTObject(Shared ? "crtbeginS.o"
405 : Static ? "crtbeginT.o"
406 : "crtbegin.o");
407 }
408
409 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
410
411 if (!Relocatable &&
412 !Args.hasArg(options::OPT_nodefaultlibs, options::OPT_nostdlib)) {
413
414 if (UseJMC) {
415 CmdArgs.push_back("--push-state");
416 CmdArgs.push_back("--whole-archive");
417 CmdArgs.push_back("-lSceJmc_nosubmission");
418 CmdArgs.push_back("--pop-state");
419 }
420
421 if (Args.hasArg(options::OPT_pthread))
422 CmdArgs.push_back("-lpthread");
423
424 if (Static) {
425 if (!Args.hasArg(options::OPT_nostdlibxx))
426 CmdArgs.push_back("-lstdc++");
427 if (!Args.hasArg(options::OPT_nolibc)) {
428 CmdArgs.push_back("-lm");
429 CmdArgs.push_back("-lc");
430 }
431
432 CmdArgs.push_back("-lcompiler_rt");
433 CmdArgs.push_back("-lkernel");
434 } else {
435 // The C and C++ libraries are combined.
436 if (!Args.hasArg(options::OPT_nolibc, options::OPT_nostdlibxx))
437 CmdArgs.push_back("-lc_stub_weak");
438
439 CmdArgs.push_back("-lkernel_stub_weak");
440 }
441 }
442 if (AddStartFiles) {
443 AddCRTObject(Shared ? "crtendS.o" : "crtend.o");
444 AddCRTObject("crtn.o");
445 }
446
447 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
448 D.Diag(diag::err_drv_unsupported_opt_for_target)
449 << "-fuse-ld" << TC.getTriple().str();
450 }
451
452 std::string LdName = TC.qualifyPSCmdName(TC.getLinkerBaseName());
453 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LdName.c_str()));
454
455 C.addCommand(std::make_unique<Command>(JA, *this,
457 Exec, CmdArgs, Inputs, Output));
458}
459
460toolchains::PS4PS5Base::PS4PS5Base(const Driver &D, const llvm::Triple &Triple,
461 const ArgList &Args, StringRef Platform,
462 const char *EnvVar)
463 : Generic_ELF(D, Triple, Args) {
464 // Determine the baseline SDK directory from the environment, else
465 // the driver's location, which should be <SDK_DIR>/host_tools/bin.
466 SmallString<128> SDKRootDir;
467 SmallString<80> Whence;
468 if (const char *EnvValue = getenv(EnvVar)) {
469 SDKRootDir = EnvValue;
470 Whence = {"environment variable '", EnvVar, "'"};
471 } else {
472 SDKRootDir = D.Dir + "/../../";
473 Whence = "compiler's location";
474 }
475
476 // Allow --sysroot= to override the root directory for header and library
477 // search, and -isysroot to override header search. If both are specified,
478 // -isysroot overrides --sysroot for header search.
479 auto OverrideRoot = [&](const options::ID &Opt, std::string &Root,
480 StringRef Default) {
481 if (const Arg *A = Args.getLastArg(Opt)) {
482 Root = A->getValue();
483 if (!llvm::sys::fs::exists(Root))
484 D.Diag(clang::diag::warn_missing_sysroot) << Root;
485 return true;
486 }
487 Root = Default.str();
488 return false;
489 };
490
491 bool CustomSysroot =
492 OverrideRoot(options::OPT__sysroot_EQ, SDKLibraryRootDir, SDKRootDir);
493 bool CustomISysroot =
494 OverrideRoot(options::OPT_isysroot, SDKHeaderRootDir, SDKLibraryRootDir);
495
496 // Emit warnings if parts of the SDK are missing, unless the user has taken
497 // control of header or library search. If we're not linking, don't check
498 // for missing libraries.
499 auto CheckSDKPartExists = [&](StringRef Dir, StringRef Desc) {
500 if (llvm::sys::fs::exists(Dir))
501 return true;
502 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
503 << (Twine(Platform) + " " + Desc).str() << Dir << Whence;
504 return false;
505 };
506
507 bool Linking = !Args.hasArg(options::OPT_E, options::OPT_c, options::OPT_S,
508 options::OPT_emit_ast);
509 if (Linking) {
510 SmallString<128> Dir(SDKLibraryRootDir);
511 llvm::sys::path::append(Dir, "target/lib");
512 if (CheckSDKPartExists(Dir, "system libraries"))
513 getFilePaths().push_back(std::string(Dir));
514 }
515 if (!CustomSysroot && !CustomISysroot &&
516 !Args.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc)) {
517 SmallString<128> Dir(SDKHeaderRootDir);
518 llvm::sys::path::append(Dir, "target/include");
519 CheckSDKPartExists(Dir, "system headers");
520 }
521
522 getFilePaths().push_back(".");
523}
524
526 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
527 const Driver &D = getDriver();
528
529 if (DriverArgs.hasArg(options::OPT_nostdinc))
530 return;
531
532 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
533 SmallString<128> Dir(D.ResourceDir);
534 llvm::sys::path::append(Dir, "include");
535 addSystemInclude(DriverArgs, CC1Args, Dir.str());
536 }
537
538 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
539 return;
540
541 addExternCSystemInclude(DriverArgs, CC1Args,
542 SDKHeaderRootDir + "/target/include");
543 addExternCSystemInclude(DriverArgs, CC1Args,
544 SDKHeaderRootDir + "/target/include_common");
545}
546
550
552 return new tools::PS4cpu::Linker(*this);
553}
554
556 // PS5 does not support an external assembler.
557 getDriver().Diag(clang::diag::err_no_external_assembler);
558 return nullptr;
559}
560
562 return new tools::PS5cpu::Linker(*this);
563}
564
567 Res |= SanitizerKind::Address;
568 Res |= SanitizerKind::PointerCompare;
569 Res |= SanitizerKind::PointerSubtract;
570 Res |= SanitizerKind::Vptr;
571 return Res;
572}
573
576 Res |= SanitizerKind::Thread;
577 return Res;
578}
579
581 const ArgList &DriverArgs, ArgStringList &CC1Args,
582 Action::OffloadKind DeviceOffloadingKind) const {
583 // PS4/PS5 do not use init arrays.
584 if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
585 Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
586 getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
587 << A->getAsString(DriverArgs) << getTriple().str();
588 }
589
590 CC1Args.push_back("-fno-use-init-array");
591
592 // Default to `hidden` visibility for PS5.
593 if (getTriple().isPS5() &&
594 !DriverArgs.hasArg(options::OPT_fvisibility_EQ,
595 options::OPT_fvisibility_ms_compat))
596 CC1Args.push_back("-fvisibility=hidden");
597
598 // Default to -fvisibility-global-new-delete=source for PS5.
599 if (getTriple().isPS5() &&
600 !DriverArgs.hasArg(options::OPT_fvisibility_global_new_delete_EQ,
601 options::OPT_fvisibility_global_new_delete_hidden))
602 CC1Args.push_back("-fvisibility-global-new-delete=source");
603
604 const Arg *A =
605 DriverArgs.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
606 options::OPT_fno_visibility_from_dllstorageclass);
607 if (!A ||
608 A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass)) {
609 CC1Args.push_back("-fvisibility-from-dllstorageclass");
610
611 if (DriverArgs.hasArg(options::OPT_fvisibility_dllexport_EQ))
612 DriverArgs.AddLastArg(CC1Args, options::OPT_fvisibility_dllexport_EQ);
613 else
614 CC1Args.push_back("-fvisibility-dllexport=protected");
615
616 // For PS4 we override the visibilty of globals definitions without
617 // dllimport or dllexport annotations.
618 if (DriverArgs.hasArg(options::OPT_fvisibility_nodllstorageclass_EQ))
619 DriverArgs.AddLastArg(CC1Args,
620 options::OPT_fvisibility_nodllstorageclass_EQ);
621 else if (getTriple().isPS4())
622 CC1Args.push_back("-fvisibility-nodllstorageclass=hidden");
623 else
624 CC1Args.push_back("-fvisibility-nodllstorageclass=keep");
625
626 if (DriverArgs.hasArg(options::OPT_fvisibility_externs_dllimport_EQ))
627 DriverArgs.AddLastArg(CC1Args,
628 options::OPT_fvisibility_externs_dllimport_EQ);
629 else
630 CC1Args.push_back("-fvisibility-externs-dllimport=default");
631
632 // For PS4 we override the visibilty of external globals without
633 // dllimport or dllexport annotations.
634 if (DriverArgs.hasArg(
635 options::OPT_fvisibility_externs_nodllstorageclass_EQ))
636 DriverArgs.AddLastArg(
637 CC1Args, options::OPT_fvisibility_externs_nodllstorageclass_EQ);
638 else if (getTriple().isPS4())
639 CC1Args.push_back("-fvisibility-externs-nodllstorageclass=default");
640 else
641 CC1Args.push_back("-fvisibility-externs-nodllstorageclass=keep");
642 }
643
644 // Enable jump table sizes section for PS5.
645 if (getTriple().isPS5()) {
646 CC1Args.push_back("-mllvm");
647 CC1Args.push_back("-emit-jump-table-sizes-section");
648 }
649}
650
651// PS4 toolchain.
652toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
653 const llvm::opt::ArgList &Args)
654 : PS4PS5Base(D, Triple, Args, "PS4", "SCE_ORBIS_SDK_DIR") {}
655
656// PS5 toolchain.
657toolchains::PS5CPU::PS5CPU(const Driver &D, const llvm::Triple &Triple,
658 const llvm::opt::ArgList &Args)
659 : 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:26
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:99
const char * getClangProgramPath() const
Get the path to the main clang executable.
Definition Driver.h:452
DiagnosticBuilder Diag(unsigned DiagID) const
Definition Driver.h:169
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
Definition Driver.h:758
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:92
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory with extern "C" semantics to CC1 arguments.
path_list & getFilePaths()
Definition ToolChain.h:295
const Driver & getDriver() const
Definition ToolChain.h:253
const llvm::Triple & getTriple() const
Definition ToolChain.h:255
std::string GetProgramPath(const char *Name) const
void AddFilePathLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddFilePathLibArgs - Add each thing in getFilePaths() as a "-L" option.
SanitizerArgs getSanitizerArgs(const llvm::opt::ArgList &JobArgs) const
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Tool - Information on a specific compilation tool.
Definition Tool.h:32
const ToolChain & getToolChain() const
Definition Tool.h:52
Generic_ELF(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition Gnu.h:439
Tool * buildLinker() const override
Definition PS4CPU.cpp:551
void addSanitizerArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const char *Prefix, const char *Suffix) const override
Definition PS4CPU.cpp:90
Tool * buildAssembler() const override
Definition PS4CPU.cpp:547
PS4CPU(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition PS4CPU.cpp:652
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:525
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:580
PS4PS5Base(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, StringRef Platform, const char *EnvVar)
Definition PS4CPU.cpp:460
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition PS4CPU.cpp:565
Tool * buildAssembler() const override
Definition PS4CPU.cpp:555
void addSanitizerArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const char *Prefix, const char *Suffix) const override
Definition PS4CPU.cpp:104
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition PS4CPU.cpp:574
Tool * buildLinker() const override
Definition PS4CPU.cpp:561
PS5CPU(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition PS4CPU.cpp:657
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:120
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:223
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:57
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)
llvm::StringRef getLTOParallelism(const llvm::opt::ArgList &Args, const Driver &D)
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)
SmallVector< InputInfo, 4 > InputInfoList
Definition Driver.h:50
The JSON file list parser is used to communicate input to InstallAPI.
static constexpr ResponseFileSupport AtFileUTF8()
Definition Job.h:85