clang: lib/Driver/ToolChains/PS4CPU.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
11#include "clang/Config/config.h"
17#include "llvm/Option/ArgList.h"
18#include "llvm/Support/FileSystem.h"
19#include "llvm/Support/Path.h"
20#include
21
23using namespace clang;
25
26
27static const char *makeArgString(const ArgList &Args, const char *Prefix,
28 const char *Base, const char *Suffix) {
29
30 return Args.MakeArgString(Twine(StringRef(Prefix), Base) + Suffix);
31}
32
34 ArgStringList &CmdArgs) {
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)))
55 Args, "--dependent-lib=", PSTC.getProfileRTLibName(), ""));
56}
57
61 const ArgList &Args,
62 const char *LinkingOutput) const {
65 ArgStringList CmdArgs;
66
67 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
68
69 CmdArgs.push_back("-o");
71
72 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
73 const InputInfo &Input = Inputs[0];
74 assert(Input.isFilename() && "Invalid input.");
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(JA, *this,
81 Exec, CmdArgs, Inputs, Output));
82}
83
85 ArgStringList &CmdArgs) {
88 PSTC.addSanitizerArgs(Args, CmdArgs, "--dependent-lib=lib", ".a");
89}
90
92 ArgStringList &CmdArgs,
93 const char *Prefix,
94 const char *Suffix) const {
95 auto arg = [&](const char *Name) -> const char * {
97 };
98 const SanitizerArgs &SanArgs = getSanitizerArgs(Args);
100 CmdArgs.push_back(arg("SceDbgUBSanitizer_stub_weak"));
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);
114 CmdArgs.push_back(arg("SceUBSanitizer_nosubmission_stub_weak"));
116 CmdArgs.push_back(arg("SceAddressSanitizer_nosubmission_stub_weak"));
118 CmdArgs.push_back(arg("SceThreadSanitizer_nosubmission_stub_weak"));
119}
120
124 const ArgList &Args,
125 const char *LinkingOutput) const {
128 ArgStringList CmdArgs;
129
130
131 Args.ClaimAllArgs(options::OPT_g_Group);
132
133 Args.ClaimAllArgs(options::OPT_emit_llvm);
134
135
136 Args.ClaimAllArgs(options::OPT_w);
137
138 CmdArgs.push_back(
139 Args.MakeArgString("--sysroot=" + TC.getSDKLibraryRootDir()));
140
141 if (Args.hasArg(options::OPT_pie))
142 CmdArgs.push_back("-pie");
143
144 if (Args.hasArg(options::OPT_static))
145 CmdArgs.push_back("-static");
146 if (Args.hasArg(options::OPT_rdynamic))
147 CmdArgs.push_back("-export-dynamic");
148 if (Args.hasArg(options::OPT_shared))
149 CmdArgs.push_back("--shared");
150
151 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
153 CmdArgs.push_back("-o");
155 }
156
157 const bool UseJMC =
158 Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false);
159
160 const char *LTOArgs = "";
161 auto AddLTOFlag = [&](Twine Flag) {
162 LTOArgs = Args.MakeArgString(Twine(LTOArgs) + " " + Flag);
163 };
164
165
166
167
168
169 if (Args.hasFlag(options::OPT_funified_lto, options::OPT_fno_unified_lto,
170 true))
171 CmdArgs.push_back(D.getLTOMode() == LTOK_Thin ? "--lto=thin"
172 : "--lto=full");
173 if (UseJMC)
174 AddLTOFlag("-enable-jmc-instrument");
175
176 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
177 AddLTOFlag(Twine("-crash-diagnostics-dir=") + A->getValue());
178
179 if (StringRef Threads = getLTOParallelism(Args, D); !Threads.empty())
180 AddLTOFlag(Twine("-threads=") + Threads);
181
182 if (*LTOArgs)
183 CmdArgs.push_back(
184 Args.MakeArgString(Twine("-lto-debug-options=") + LTOArgs));
185
186
187 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
188 TC.addSanitizerArgs(Args, CmdArgs, "-l", "");
189
190
191
192
193 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
194 options::OPT_s, options::OPT_t});
195
196 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
197 CmdArgs.push_back("--no-demangle");
198
200
201 if (Args.hasArg(options::OPT_pthread)) {
202 CmdArgs.push_back("-lpthread");
203 }
204
205 if (UseJMC) {
206 CmdArgs.push_back("--whole-archive");
207 CmdArgs.push_back("-lSceDbgJmc");
208 CmdArgs.push_back("--no-whole-archive");
209 }
210
211 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
212 D.Diag(diag::err_drv_unsupported_opt_for_target)
213 << "-fuse-ld" << TC.getTriple().str();
214 }
215
216 std::string LdName = TC.qualifyPSCmdName(TC.getLinkerBaseName());
217 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LdName.c_str()));
218
219 C.addCommand(std::make_unique(JA, *this,
221 Exec, CmdArgs, Inputs, Output));
222}
223
227 const ArgList &Args,
228 const char *LinkingOutput) const {
231 ArgStringList CmdArgs;
232
233 const bool Relocatable = Args.hasArg(options::OPT_r);
234 const bool Shared = Args.hasArg(options::OPT_shared);
235 const bool Static = Args.hasArg(options::OPT_static);
236
237
238 Args.ClaimAllArgs(options::OPT_g_Group);
239
240 Args.ClaimAllArgs(options::OPT_emit_llvm);
241
242
243 Args.ClaimAllArgs(options::OPT_w);
244
245 CmdArgs.push_back("-m");
246 CmdArgs.push_back("elf_x86_64_fbsd");
247
248 CmdArgs.push_back(
249 Args.MakeArgString("--sysroot=" + TC.getSDKLibraryRootDir()));
250
251
252 const bool PIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
253 !Relocatable && !Shared && );
254 if (PIE)
255 CmdArgs.push_back("-pie");
256
257 if (!Relocatable) {
258 CmdArgs.push_back("--eh-frame-hdr");
259 CmdArgs.push_back("--hash-style=sysv");
260
261
262
263
264
265 CmdArgs.push_back("--build-id=uuid");
266
267
268
269
270 CmdArgs.push_back("--unresolved-symbols=report-all");
271
272
273
274 CmdArgs.push_back("-z");
275 CmdArgs.push_back("now");
276
277
278 CmdArgs.push_back("-z");
279 CmdArgs.push_back("start-stop-visibility=hidden");
280
281
282 CmdArgs.push_back("-z");
283 CmdArgs.push_back("rodynamic");
284
285 CmdArgs.push_back("-z");
286 CmdArgs.push_back("common-page-size=0x4000");
287
288 CmdArgs.push_back("-z");
289 CmdArgs.push_back("max-page-size=0x4000");
290
291
292
293
294 CmdArgs.push_back("-z");
295 CmdArgs.push_back("dead-reloc-in-nonalloc=.debug_*=0xffffffffffffffff");
296 CmdArgs.push_back("-z");
297 CmdArgs.push_back(
298 "dead-reloc-in-nonalloc=.debug_ranges=0xfffffffffffffffe");
299 CmdArgs.push_back("-z");
300 CmdArgs.push_back("dead-reloc-in-nonalloc=.debug_loc=0xfffffffffffffffe");
301
302
303
304
305
306
307 if (!Args.hasArgNoClaim(options::OPT_T)) {
308 CmdArgs.push_back("--default-script");
309 CmdArgs.push_back(Static ? "static.script"
310 : Shared ? "prx.script"
311 : "main.script");
312 }
313 }
314
316 CmdArgs.push_back("-static");
317 if (Args.hasArg(options::OPT_rdynamic))
318 CmdArgs.push_back("-export-dynamic");
319 if (Shared)
320 CmdArgs.push_back("--shared");
321
322
323
324 if (!Relocatable && !Shared && !PIE)
325 CmdArgs.push_back("--image-base=0x400000");
326
327 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
329 CmdArgs.push_back("-o");
331 }
332
333 const bool UseJMC =
334 Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false);
335
336 auto AddLTOFlag = [&](Twine Flag) {
337 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=") + Flag));
338 };
339
340
341
342
343
344 if (Args.hasFlag(options::OPT_funified_lto, options::OPT_fno_unified_lto,
345 true))
346 CmdArgs.push_back(D.getLTOMode() == LTOK_Thin ? "--lto=thin"
347 : "--lto=full");
348
349 AddLTOFlag("-emit-jump-table-sizes-section");
350
351 if (UseJMC)
352 AddLTOFlag("-enable-jmc-instrument");
353
354 if (Args.hasFlag(options::OPT_fstack_size_section,
355 options::OPT_fno_stack_size_section, false))
356 AddLTOFlag("-stack-size-section");
357
358 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
359 AddLTOFlag(Twine("-crash-diagnostics-dir=") + A->getValue());
360
362 AddLTOFlag(Twine("jobs=") + Jobs);
363
364 Args.AddAllArgs(CmdArgs, options::OPT_L);
366 Args.addAllArgs(CmdArgs,
367 {options::OPT_T_Group, options::OPT_s, options::OPT_t});
368
369 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
370 CmdArgs.push_back("--no-demangle");
371
372
373 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
374 TC.addSanitizerArgs(Args, CmdArgs, "-l", "");
375
376 const bool AddStartFiles =
377 !Relocatable &&
378 !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib);
379
380 auto AddCRTObject = [&](const char *Name) {
381 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath(Name)));
382 };
383
384 if (AddStartFiles) {
385 if (!Shared)
386 AddCRTObject("crt1.o");
387 AddCRTObject("crti.o");
388 AddCRTObject(Shared ? "crtbeginS.o"
389 : Static ? "crtbeginT.o"
390 : "crtbegin.o");
391 }
392
394
395 if (!Relocatable &&
396 !Args.hasArg(options::OPT_nodefaultlibs, options::OPT_nostdlib)) {
397
398 if (UseJMC) {
399 CmdArgs.push_back("--push-state");
400 CmdArgs.push_back("--whole-archive");
401 CmdArgs.push_back("-lSceJmc_nosubmission");
402 CmdArgs.push_back("--pop-state");
403 }
404
405 if (Args.hasArg(options::OPT_pthread))
406 CmdArgs.push_back("-lpthread");
407
409 if (!Args.hasArg(options::OPT_nostdlibxx))
410 CmdArgs.push_back("-lstdc++");
411 if (!Args.hasArg(options::OPT_nolibc)) {
412 CmdArgs.push_back("-lm");
413 CmdArgs.push_back("-lc");
414 }
415
416 CmdArgs.push_back("-lcompiler_rt");
417 CmdArgs.push_back("-lkernel");
418 } else {
419
420 if (!Args.hasArg(options::OPT_nolibc, options::OPT_nostdlibxx))
421 CmdArgs.push_back("-lc_stub_weak");
422
423 CmdArgs.push_back("-lkernel_stub_weak");
424 }
425 }
426 if (AddStartFiles) {
427 AddCRTObject(Shared ? "crtendS.o" : "crtend.o");
428 AddCRTObject("crtn.o");
429 }
430
431 if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
432 D.Diag(diag::err_drv_unsupported_opt_for_target)
433 << "-fuse-ld" << TC.getTriple().str();
434 }
435
436 std::string LdName = TC.qualifyPSCmdName(TC.getLinkerBaseName());
437 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LdName.c_str()));
438
439 C.addCommand(std::make_unique(JA, *this,
441 Exec, CmdArgs, Inputs, Output));
442}
443
445 const ArgList &Args, StringRef Platform,
446 const char *EnvVar)
448
449
452 if (const char *EnvValue = getenv(EnvVar)) {
453 SDKRootDir = EnvValue;
454 Whence = {"environment variable '", EnvVar, "'"};
455 } else {
456 SDKRootDir = D.Dir + "/../../";
457 Whence = "compiler's location";
458 }
459
460
461
462
463 auto OverrideRoot = [&](const options::ID &Opt, std::string &Root,
465 if (const Arg *A = Args.getLastArg(Opt)) {
466 Root = A->getValue();
467 if (!llvm::sys::fs::exists(Root))
468 D.Diag(clang::diag::warn_missing_sysroot) << Root;
469 return true;
470 }
472 return false;
473 };
474
475 bool CustomSysroot =
476 OverrideRoot(options::OPT__sysroot_EQ, SDKLibraryRootDir, SDKRootDir);
477 bool CustomISysroot =
478 OverrideRoot(options::OPT_isysroot, SDKHeaderRootDir, SDKLibraryRootDir);
479
480
481
482
483 auto CheckSDKPartExists = [&](StringRef Dir, StringRef Desc) {
484 if (llvm::sys::fs::exists(Dir))
485 return true;
486 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
487 << (Twine(Platform) + " " + Desc).str() << Dir << Whence;
488 return false;
489 };
490
491 bool Linking = !Args.hasArg(options::OPT_E, options::OPT_c, options::OPT_S,
492 options::OPT_emit_ast);
493 if (!CustomSysroot && Linking) {
495 llvm::sys::path::append(Dir, "target/lib");
496 if (CheckSDKPartExists(Dir, "system libraries"))
498 }
499 if (!CustomSysroot && !CustomISysroot &&
500 !Args.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc)) {
502 llvm::sys::path::append(Dir, "target/include");
503 CheckSDKPartExists(Dir, "system headers");
504 }
505
507}
508
510 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
511 const Driver &D = getDriver();
512
513 if (DriverArgs.hasArg(options::OPT_nostdinc))
514 return;
515
516 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
518 llvm::sys::path::append(Dir, "include");
519 addSystemInclude(DriverArgs, CC1Args, Dir.str());
520 }
521
522 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
523 return;
524
525 addExternCSystemInclude(DriverArgs, CC1Args,
526 SDKHeaderRootDir + "/target/include");
527 addExternCSystemInclude(DriverArgs, CC1Args,
528 SDKHeaderRootDir + "/target/include_common");
529}
530
533}
534
537}
538
540
541 getDriver().Diag(clang::diag::err_no_external_assembler);
542 return nullptr;
543}
544
547}
548
551 Res |= SanitizerKind::Address;
552 Res |= SanitizerKind::PointerCompare;
553 Res |= SanitizerKind::PointerSubtract;
554 Res |= SanitizerKind::Vptr;
555 return Res;
556}
557
560 Res |= SanitizerKind::Thread;
561 return Res;
562}
563
565 const ArgList &DriverArgs, ArgStringList &CC1Args,
567
568 if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
569 Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
570 getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
571 << A->getAsString(DriverArgs) << getTriple().str();
572 }
573
574 CC1Args.push_back("-fno-use-init-array");
575
576
577 if (getTriple().isPS5() &&
578 !DriverArgs.hasArg(options::OPT_fvisibility_EQ,
579 options::OPT_fvisibility_ms_compat))
580 CC1Args.push_back("-fvisibility=hidden");
581
582
583 if (getTriple().isPS5() &&
584 !DriverArgs.hasArg(options::OPT_fvisibility_global_new_delete_EQ,
585 options::OPT_fvisibility_global_new_delete_hidden))
586 CC1Args.push_back("-fvisibility-global-new-delete=source");
587
588 const Arg *A =
589 DriverArgs.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
590 options::OPT_fno_visibility_from_dllstorageclass);
591 if (!A ||
592 A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass)) {
593 CC1Args.push_back("-fvisibility-from-dllstorageclass");
594
595 if (DriverArgs.hasArg(options::OPT_fvisibility_dllexport_EQ))
596 DriverArgs.AddLastArg(CC1Args, options::OPT_fvisibility_dllexport_EQ);
597 else
598 CC1Args.push_back("-fvisibility-dllexport=protected");
599
600
601
602 if (DriverArgs.hasArg(options::OPT_fvisibility_nodllstorageclass_EQ))
603 DriverArgs.AddLastArg(CC1Args,
604 options::OPT_fvisibility_nodllstorageclass_EQ);
605 else if (getTriple().isPS4())
606 CC1Args.push_back("-fvisibility-nodllstorageclass=hidden");
607 else
608 CC1Args.push_back("-fvisibility-nodllstorageclass=keep");
609
610 if (DriverArgs.hasArg(options::OPT_fvisibility_externs_dllimport_EQ))
611 DriverArgs.AddLastArg(CC1Args,
612 options::OPT_fvisibility_externs_dllimport_EQ);
613 else
614 CC1Args.push_back("-fvisibility-externs-dllimport=default");
615
616
617
618 if (DriverArgs.hasArg(
619 options::OPT_fvisibility_externs_nodllstorageclass_EQ))
620 DriverArgs.AddLastArg(
621 CC1Args, options::OPT_fvisibility_externs_nodllstorageclass_EQ);
622 else if (getTriple().isPS4())
623 CC1Args.push_back("-fvisibility-externs-nodllstorageclass=default");
624 else
625 CC1Args.push_back("-fvisibility-externs-nodllstorageclass=keep");
626 }
627
628
629 if (getTriple().isPS5()) {
630 CC1Args.push_back("-mllvm");
631 CC1Args.push_back("-emit-jump-table-sizes-section");
632 }
633}
634
635
637 const llvm::opt::ArgList &Args)
638 : PS4PS5Base(D, Triple, Args, "PS4", "SCE_ORBIS_SDK_DIR") {}
639
640
642 const llvm::opt::ArgList &Args)
643 : 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)
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
InputInfo - Wrapper for information about an input source.
const char * getFilename() const
bool needsUbsanRt() const
The JSON file list parser is used to communicate input to InstallAPI.
static constexpr ResponseFileSupport AtFileUTF8()