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"
12 #include "clang/Driver/Compilation.h"
13 #include "clang/Driver/Driver.h"
14 #include "clang/Driver/DriverDiagnostic.h"
15 #include "clang/Driver/Options.h"
16 #include "clang/Driver/SanitizerArgs.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
26 using clang::driver::tools::AddLinkerInputs;
27
addProfileRTArgs(const ToolChain & TC,const ArgList & Args,ArgStringList & CmdArgs)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_instr_generate, false) ||
34 Args.hasFlag(options::OPT_fprofile_generate_EQ,
35 options::OPT_fno_profile_instr_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.hasArg(options::OPT_fcreate_profile) ||
41 Args.hasArg(options::OPT_coverage)))
42 CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
43 }
44
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const45 void tools::PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
46 const InputInfo &Output,
47 const InputInfoList &Inputs,
48 const ArgList &Args,
49 const char *LinkingOutput) const {
50 claimNoWarnArgs(Args);
51 ArgStringList CmdArgs;
52
53 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
54
55 CmdArgs.push_back("-o");
56 CmdArgs.push_back(Output.getFilename());
57
58 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
59 const InputInfo &Input = Inputs[0];
60 assert(Input.isFilename() && "Invalid input.");
61 CmdArgs.push_back(Input.getFilename());
62
63 const char *Exec =
64 Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
65 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
66 }
67
AddPS4SanitizerArgs(const ToolChain & TC,ArgStringList & CmdArgs)68 static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
69 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
70 if (SanArgs.needsUbsanRt()) {
71 CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
72 }
73 if (SanArgs.needsAsanRt()) {
74 CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
75 }
76 }
77
addSanitizerArgs(const ToolChain & TC,ArgStringList & CmdArgs)78 void tools::PS4cpu::addSanitizerArgs(const ToolChain &TC,
79 ArgStringList &CmdArgs) {
80 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
81 if (SanArgs.needsUbsanRt())
82 CmdArgs.push_back("--dependent-lib=libSceDbgUBSanitizer_stub_weak.a");
83 if (SanArgs.needsAsanRt())
84 CmdArgs.push_back("--dependent-lib=libSceDbgAddressSanitizer_stub_weak.a");
85 }
86
ConstructPS4LinkJob(const Tool & T,Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput)87 static void ConstructPS4LinkJob(const Tool &T, Compilation &C,
88 const JobAction &JA, const InputInfo &Output,
89 const InputInfoList &Inputs,
90 const ArgList &Args,
91 const char *LinkingOutput) {
92 const toolchains::FreeBSD &ToolChain =
93 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
94 const Driver &D = ToolChain.getDriver();
95 ArgStringList CmdArgs;
96
97 // Silence warning for "clang -g foo.o -o foo"
98 Args.ClaimAllArgs(options::OPT_g_Group);
99 // and "clang -emit-llvm foo.o -o foo"
100 Args.ClaimAllArgs(options::OPT_emit_llvm);
101 // and for "clang -w foo.o -o foo". Other warning options are already
102 // handled somewhere else.
103 Args.ClaimAllArgs(options::OPT_w);
104
105 if (!D.SysRoot.empty())
106 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
107
108 if (Args.hasArg(options::OPT_pie))
109 CmdArgs.push_back("-pie");
110
111 if (Args.hasArg(options::OPT_rdynamic))
112 CmdArgs.push_back("-export-dynamic");
113 if (Args.hasArg(options::OPT_shared))
114 CmdArgs.push_back("--oformat=so");
115
116 if (Output.isFilename()) {
117 CmdArgs.push_back("-o");
118 CmdArgs.push_back(Output.getFilename());
119 } else {
120 assert(Output.isNothing() && "Invalid output.");
121 }
122
123 if(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
124 AddPS4SanitizerArgs(ToolChain, CmdArgs);
125
126 Args.AddAllArgs(CmdArgs, options::OPT_L);
127 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
128 Args.AddAllArgs(CmdArgs, options::OPT_e);
129 Args.AddAllArgs(CmdArgs, options::OPT_s);
130 Args.AddAllArgs(CmdArgs, options::OPT_t);
131 Args.AddAllArgs(CmdArgs, options::OPT_r);
132
133 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
134 CmdArgs.push_back("--no-demangle");
135
136 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
137
138 if (Args.hasArg(options::OPT_pthread)) {
139 CmdArgs.push_back("-lpthread");
140 }
141
142 const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
143
144 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
145 }
146
ConstructGoldLinkJob(const Tool & T,Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput)147 static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
148 const JobAction &JA, const InputInfo &Output,
149 const InputInfoList &Inputs,
150 const ArgList &Args,
151 const char *LinkingOutput) {
152 const toolchains::FreeBSD &ToolChain =
153 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
154 const Driver &D = ToolChain.getDriver();
155 ArgStringList CmdArgs;
156
157 // Silence warning for "clang -g foo.o -o foo"
158 Args.ClaimAllArgs(options::OPT_g_Group);
159 // and "clang -emit-llvm foo.o -o foo"
160 Args.ClaimAllArgs(options::OPT_emit_llvm);
161 // and for "clang -w foo.o -o foo". Other warning options are already
162 // handled somewhere else.
163 Args.ClaimAllArgs(options::OPT_w);
164
165 if (!D.SysRoot.empty())
166 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
167
168 if (Args.hasArg(options::OPT_pie))
169 CmdArgs.push_back("-pie");
170
171 if (Args.hasArg(options::OPT_static)) {
172 CmdArgs.push_back("-Bstatic");
173 } else {
174 if (Args.hasArg(options::OPT_rdynamic))
175 CmdArgs.push_back("-export-dynamic");
176 CmdArgs.push_back("--eh-frame-hdr");
177 if (Args.hasArg(options::OPT_shared)) {
178 CmdArgs.push_back("-Bshareable");
179 } else {
180 CmdArgs.push_back("-dynamic-linker");
181 CmdArgs.push_back("/libexec/ld-elf.so.1");
182 }
183 CmdArgs.push_back("--enable-new-dtags");
184 }
185
186 if (Output.isFilename()) {
187 CmdArgs.push_back("-o");
188 CmdArgs.push_back(Output.getFilename());
189 } else {
190 assert(Output.isNothing() && "Invalid output.");
191 }
192
193 if(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
194 AddPS4SanitizerArgs(ToolChain, CmdArgs);
195
196 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
197 const char *crt1 = nullptr;
198 if (!Args.hasArg(options::OPT_shared)) {
199 if (Args.hasArg(options::OPT_pg))
200 crt1 = "gcrt1.o";
201 else if (Args.hasArg(options::OPT_pie))
202 crt1 = "Scrt1.o";
203 else
204 crt1 = "crt1.o";
205 }
206 if (crt1)
207 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
208
209 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
210
211 const char *crtbegin = nullptr;
212 if (Args.hasArg(options::OPT_static))
213 crtbegin = "crtbeginT.o";
214 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
215 crtbegin = "crtbeginS.o";
216 else
217 crtbegin = "crtbegin.o";
218
219 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
220 }
221
222 Args.AddAllArgs(CmdArgs, options::OPT_L);
223 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
224 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
225 Args.AddAllArgs(CmdArgs, options::OPT_e);
226 Args.AddAllArgs(CmdArgs, options::OPT_s);
227 Args.AddAllArgs(CmdArgs, options::OPT_t);
228 Args.AddAllArgs(CmdArgs, options::OPT_r);
229
230 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
231 CmdArgs.push_back("--no-demangle");
232
233 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
234
235 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
236 // For PS4, we always want to pass libm, libstdc++ and libkernel
237 // libraries for both C and C++ compilations.
238 CmdArgs.push_back("-lkernel");
239 if (D.CCCIsCXX()) {
240 if (ToolChain.ShouldLinkCXXStdlib(Args))
241 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
242 if (Args.hasArg(options::OPT_pg))
243 CmdArgs.push_back("-lm_p");
244 else
245 CmdArgs.push_back("-lm");
246 }
247 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
248 // the default system libraries. Just mimic this for now.
249 if (Args.hasArg(options::OPT_pg))
250 CmdArgs.push_back("-lgcc_p");
251 else
252 CmdArgs.push_back("-lcompiler_rt");
253 if (Args.hasArg(options::OPT_static)) {
254 CmdArgs.push_back("-lstdc++");
255 } else if (Args.hasArg(options::OPT_pg)) {
256 CmdArgs.push_back("-lgcc_eh_p");
257 } else {
258 CmdArgs.push_back("--as-needed");
259 CmdArgs.push_back("-lstdc++");
260 CmdArgs.push_back("--no-as-needed");
261 }
262
263 if (Args.hasArg(options::OPT_pthread)) {
264 if (Args.hasArg(options::OPT_pg))
265 CmdArgs.push_back("-lpthread_p");
266 else
267 CmdArgs.push_back("-lpthread");
268 }
269
270 if (Args.hasArg(options::OPT_pg)) {
271 if (Args.hasArg(options::OPT_shared))
272 CmdArgs.push_back("-lc");
273 else {
274 if (Args.hasArg(options::OPT_static)) {
275 CmdArgs.push_back("--start-group");
276 CmdArgs.push_back("-lc_p");
277 CmdArgs.push_back("-lpthread_p");
278 CmdArgs.push_back("--end-group");
279 } else {
280 CmdArgs.push_back("-lc_p");
281 }
282 }
283 CmdArgs.push_back("-lgcc_p");
284 } else {
285 if (Args.hasArg(options::OPT_static)) {
286 CmdArgs.push_back("--start-group");
287 CmdArgs.push_back("-lc");
288 CmdArgs.push_back("-lpthread");
289 CmdArgs.push_back("--end-group");
290 } else {
291 CmdArgs.push_back("-lc");
292 }
293 CmdArgs.push_back("-lcompiler_rt");
294 }
295
296 if (Args.hasArg(options::OPT_static)) {
297 CmdArgs.push_back("-lstdc++");
298 } else if (Args.hasArg(options::OPT_pg)) {
299 CmdArgs.push_back("-lgcc_eh_p");
300 } else {
301 CmdArgs.push_back("--as-needed");
302 CmdArgs.push_back("-lstdc++");
303 CmdArgs.push_back("--no-as-needed");
304 }
305 }
306
307 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
308 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
309 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
310 else
311 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
312 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
313 }
314
315 const char *Exec =
316 #ifdef _WIN32
317 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld.gold"));
318 #else
319 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
320 #endif
321
322 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
323 }
324
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const325 void tools::PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
326 const InputInfo &Output,
327 const InputInfoList &Inputs,
328 const ArgList &Args,
329 const char *LinkingOutput) const {
330 const toolchains::FreeBSD &ToolChain =
331 static_cast<const toolchains::FreeBSD &>(getToolChain());
332 const Driver &D = ToolChain.getDriver();
333 bool PS4Linker;
334 StringRef LinkerOptName;
335 if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
336 LinkerOptName = A->getValue();
337 if (LinkerOptName != "ps4" && LinkerOptName != "gold")
338 D.Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
339 }
340
341 if (LinkerOptName == "gold")
342 PS4Linker = false;
343 else if (LinkerOptName == "ps4")
344 PS4Linker = true;
345 else
346 PS4Linker = !Args.hasArg(options::OPT_shared);
347
348 if (PS4Linker)
349 ConstructPS4LinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
350 else
351 ConstructGoldLinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
352 }
353
PS4CPU(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)354 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
355 const ArgList &Args)
356 : Generic_ELF(D, Triple, Args) {
357 if (Args.hasArg(clang::driver::options::OPT_static))
358 D.Diag(clang::diag::err_drv_unsupported_opt_for_target) << "-static"
359 << "PS4";
360
361 // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
362 // if it exists; otherwise use the driver's installation path, which
363 // should be <SDK_DIR>/host_tools/bin.
364
365 SmallString<512> PS4SDKDir;
366 if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
367 if (!llvm::sys::fs::exists(EnvValue))
368 getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
369 PS4SDKDir = EnvValue;
370 } else {
371 PS4SDKDir = getDriver().Dir;
372 llvm::sys::path::append(PS4SDKDir, "/../../");
373 }
374
375 // By default, the driver won't report a warning if it can't find
376 // PS4's include or lib directories. This behavior could be changed if
377 // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
378 // If -isysroot was passed, use that as the SDK base path.
379 std::string PrefixDir;
380 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
381 PrefixDir = A->getValue();
382 if (!llvm::sys::fs::exists(PrefixDir))
383 getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
384 } else
385 PrefixDir = PS4SDKDir.str();
386
387 SmallString<512> PS4SDKIncludeDir(PrefixDir);
388 llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
389 if (!Args.hasArg(options::OPT_nostdinc) &&
390 !Args.hasArg(options::OPT_nostdlibinc) &&
391 !Args.hasArg(options::OPT_isysroot) &&
392 !Args.hasArg(options::OPT__sysroot_EQ) &&
393 !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
394 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
395 << "PS4 system headers" << PS4SDKIncludeDir;
396 }
397
398 SmallString<512> PS4SDKLibDir(PS4SDKDir);
399 llvm::sys::path::append(PS4SDKLibDir, "target/lib");
400 if (!Args.hasArg(options::OPT_nostdlib) &&
401 !Args.hasArg(options::OPT_nodefaultlibs) &&
402 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
403 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
404 !Args.hasArg(options::OPT_emit_ast) &&
405 !llvm::sys::fs::exists(PS4SDKLibDir)) {
406 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
407 << "PS4 system libraries" << PS4SDKLibDir;
408 return;
409 }
410 getFilePaths().push_back(PS4SDKLibDir.str());
411 }
412
buildAssembler() const413 Tool *toolchains::PS4CPU::buildAssembler() const {
414 return new tools::PS4cpu::Assemble(*this);
415 }
416
buildLinker() const417 Tool *toolchains::PS4CPU::buildLinker() const {
418 return new tools::PS4cpu::Link(*this);
419 }
420
isPICDefault() const421 bool toolchains::PS4CPU::isPICDefault() const { return true; }
422
HasNativeLLVMSupport() const423 bool toolchains::PS4CPU::HasNativeLLVMSupport() const { return true; }
424
getSupportedSanitizers() const425 SanitizerMask toolchains::PS4CPU::getSupportedSanitizers() const {
426 SanitizerMask Res = ToolChain::getSupportedSanitizers();
427 Res |= SanitizerKind::Address;
428 Res |= SanitizerKind::PointerCompare;
429 Res |= SanitizerKind::PointerSubtract;
430 Res |= SanitizerKind::Vptr;
431 return Res;
432 }
433