1 //===--- PS4CPU.cpp - PS4CPU ToolChain Implementations ----------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 #include "CommonArgs.h"
13 #include "clang/Driver/Compilation.h"
14 #include "clang/Driver/Driver.h"
15 #include "clang/Driver/DriverDiagnostic.h"
16 #include "clang/Driver/Options.h"
17 #include "clang/Driver/SanitizerArgs.h"
18 #include "llvm/Option/ArgList.h"
19 #include "llvm/Support/FileSystem.h"
20 #include "llvm/Support/Path.h"
21 #include <cstdlib> // ::getenv
23 using namespace clang::driver;
24 using namespace clang;
25 using namespace llvm::opt;
27 using clang::driver::tools::AddLinkerInputs;
29 void tools::PS4cpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args,
30 ArgStringList &CmdArgs) {
31 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
33 Args.hasFlag(options::OPT_fprofile_generate,
34 options::OPT_fno_profile_instr_generate, false) ||
35 Args.hasFlag(options::OPT_fprofile_generate_EQ,
36 options::OPT_fno_profile_instr_generate, false) ||
37 Args.hasFlag(options::OPT_fprofile_instr_generate,
38 options::OPT_fno_profile_instr_generate, false) ||
39 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
40 options::OPT_fno_profile_instr_generate, false) ||
41 Args.hasArg(options::OPT_fcreate_profile) ||
42 Args.hasArg(options::OPT_coverage)))
43 CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
46 void tools::PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
47 const InputInfo &Output,
48 const InputInfoList &Inputs,
50 const char *LinkingOutput) const {
51 claimNoWarnArgs(Args);
52 ArgStringList CmdArgs;
54 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
56 CmdArgs.push_back("-o");
57 CmdArgs.push_back(Output.getFilename());
59 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
60 const InputInfo &Input = Inputs[0];
61 assert(Input.isFilename() && "Invalid input.");
62 CmdArgs.push_back(Input.getFilename());
65 Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
66 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
69 static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
70 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
71 if (SanArgs.needsUbsanRt()) {
72 CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
74 if (SanArgs.needsAsanRt()) {
75 CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
79 static void ConstructPS4LinkJob(const Tool &T, Compilation &C,
80 const JobAction &JA, const InputInfo &Output,
81 const InputInfoList &Inputs,
83 const char *LinkingOutput) {
84 const toolchains::FreeBSD &ToolChain =
85 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
86 const Driver &D = ToolChain.getDriver();
87 ArgStringList CmdArgs;
89 // Silence warning for "clang -g foo.o -o foo"
90 Args.ClaimAllArgs(options::OPT_g_Group);
91 // and "clang -emit-llvm foo.o -o foo"
92 Args.ClaimAllArgs(options::OPT_emit_llvm);
93 // and for "clang -w foo.o -o foo". Other warning options are already
94 // handled somewhere else.
95 Args.ClaimAllArgs(options::OPT_w);
97 if (!D.SysRoot.empty())
98 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
100 if (Args.hasArg(options::OPT_pie))
101 CmdArgs.push_back("-pie");
103 if (Args.hasArg(options::OPT_rdynamic))
104 CmdArgs.push_back("-export-dynamic");
105 if (Args.hasArg(options::OPT_shared))
106 CmdArgs.push_back("--oformat=so");
108 if (Output.isFilename()) {
109 CmdArgs.push_back("-o");
110 CmdArgs.push_back(Output.getFilename());
112 assert(Output.isNothing() && "Invalid output.");
115 AddPS4SanitizerArgs(ToolChain, CmdArgs);
117 Args.AddAllArgs(CmdArgs, options::OPT_L);
118 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
119 Args.AddAllArgs(CmdArgs, options::OPT_e);
120 Args.AddAllArgs(CmdArgs, options::OPT_s);
121 Args.AddAllArgs(CmdArgs, options::OPT_t);
122 Args.AddAllArgs(CmdArgs, options::OPT_r);
124 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
125 CmdArgs.push_back("--no-demangle");
127 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
129 if (Args.hasArg(options::OPT_pthread)) {
130 CmdArgs.push_back("-lpthread");
133 const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
135 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
138 static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
139 const JobAction &JA, const InputInfo &Output,
140 const InputInfoList &Inputs,
142 const char *LinkingOutput) {
143 const toolchains::FreeBSD &ToolChain =
144 static_cast<const toolchains::FreeBSD &>(T.getToolChain());
145 const Driver &D = ToolChain.getDriver();
146 ArgStringList CmdArgs;
148 // Silence warning for "clang -g foo.o -o foo"
149 Args.ClaimAllArgs(options::OPT_g_Group);
150 // and "clang -emit-llvm foo.o -o foo"
151 Args.ClaimAllArgs(options::OPT_emit_llvm);
152 // and for "clang -w foo.o -o foo". Other warning options are already
153 // handled somewhere else.
154 Args.ClaimAllArgs(options::OPT_w);
156 if (!D.SysRoot.empty())
157 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
159 if (Args.hasArg(options::OPT_pie))
160 CmdArgs.push_back("-pie");
162 if (Args.hasArg(options::OPT_static)) {
163 CmdArgs.push_back("-Bstatic");
165 if (Args.hasArg(options::OPT_rdynamic))
166 CmdArgs.push_back("-export-dynamic");
167 CmdArgs.push_back("--eh-frame-hdr");
168 if (Args.hasArg(options::OPT_shared)) {
169 CmdArgs.push_back("-Bshareable");
171 CmdArgs.push_back("-dynamic-linker");
172 CmdArgs.push_back("/libexec/ld-elf.so.1");
174 CmdArgs.push_back("--enable-new-dtags");
177 if (Output.isFilename()) {
178 CmdArgs.push_back("-o");
179 CmdArgs.push_back(Output.getFilename());
181 assert(Output.isNothing() && "Invalid output.");
184 AddPS4SanitizerArgs(ToolChain, CmdArgs);
186 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
187 const char *crt1 = nullptr;
188 if (!Args.hasArg(options::OPT_shared)) {
189 if (Args.hasArg(options::OPT_pg))
191 else if (Args.hasArg(options::OPT_pie))
197 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
199 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
201 const char *crtbegin = nullptr;
202 if (Args.hasArg(options::OPT_static))
203 crtbegin = "crtbeginT.o";
204 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
205 crtbegin = "crtbeginS.o";
207 crtbegin = "crtbegin.o";
209 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
212 Args.AddAllArgs(CmdArgs, options::OPT_L);
213 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
214 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
215 Args.AddAllArgs(CmdArgs, options::OPT_e);
216 Args.AddAllArgs(CmdArgs, options::OPT_s);
217 Args.AddAllArgs(CmdArgs, options::OPT_t);
218 Args.AddAllArgs(CmdArgs, options::OPT_r);
220 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
221 CmdArgs.push_back("--no-demangle");
223 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
225 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
226 // For PS4, we always want to pass libm, libstdc++ and libkernel
227 // libraries for both C and C++ compilations.
228 CmdArgs.push_back("-lkernel");
230 if (ToolChain.ShouldLinkCXXStdlib(Args))
231 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
232 if (Args.hasArg(options::OPT_pg))
233 CmdArgs.push_back("-lm_p");
235 CmdArgs.push_back("-lm");
237 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
238 // the default system libraries. Just mimic this for now.
239 if (Args.hasArg(options::OPT_pg))
240 CmdArgs.push_back("-lgcc_p");
242 CmdArgs.push_back("-lcompiler_rt");
243 if (Args.hasArg(options::OPT_static)) {
244 CmdArgs.push_back("-lstdc++");
245 } else if (Args.hasArg(options::OPT_pg)) {
246 CmdArgs.push_back("-lgcc_eh_p");
248 CmdArgs.push_back("--as-needed");
249 CmdArgs.push_back("-lstdc++");
250 CmdArgs.push_back("--no-as-needed");
253 if (Args.hasArg(options::OPT_pthread)) {
254 if (Args.hasArg(options::OPT_pg))
255 CmdArgs.push_back("-lpthread_p");
257 CmdArgs.push_back("-lpthread");
260 if (Args.hasArg(options::OPT_pg)) {
261 if (Args.hasArg(options::OPT_shared))
262 CmdArgs.push_back("-lc");
264 if (Args.hasArg(options::OPT_static)) {
265 CmdArgs.push_back("--start-group");
266 CmdArgs.push_back("-lc_p");
267 CmdArgs.push_back("-lpthread_p");
268 CmdArgs.push_back("--end-group");
270 CmdArgs.push_back("-lc_p");
273 CmdArgs.push_back("-lgcc_p");
275 if (Args.hasArg(options::OPT_static)) {
276 CmdArgs.push_back("--start-group");
277 CmdArgs.push_back("-lc");
278 CmdArgs.push_back("-lpthread");
279 CmdArgs.push_back("--end-group");
281 CmdArgs.push_back("-lc");
283 CmdArgs.push_back("-lcompiler_rt");
286 if (Args.hasArg(options::OPT_static)) {
287 CmdArgs.push_back("-lstdc++");
288 } else if (Args.hasArg(options::OPT_pg)) {
289 CmdArgs.push_back("-lgcc_eh_p");
291 CmdArgs.push_back("--as-needed");
292 CmdArgs.push_back("-lstdc++");
293 CmdArgs.push_back("--no-as-needed");
297 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
298 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
299 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
301 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
302 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
307 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld.gold"));
309 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
312 C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
315 void tools::PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
316 const InputInfo &Output,
317 const InputInfoList &Inputs,
319 const char *LinkingOutput) const {
320 const toolchains::FreeBSD &ToolChain =
321 static_cast<const toolchains::FreeBSD &>(getToolChain());
322 const Driver &D = ToolChain.getDriver();
324 StringRef LinkerOptName;
325 if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
326 LinkerOptName = A->getValue();
327 if (LinkerOptName != "ps4" && LinkerOptName != "gold")
328 D.Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
331 if (LinkerOptName == "gold")
333 else if (LinkerOptName == "ps4")
336 PS4Linker = !Args.hasArg(options::OPT_shared);
339 ConstructPS4LinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
341 ConstructGoldLinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
344 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
346 : Generic_ELF(D, Triple, Args) {
347 if (Args.hasArg(clang::driver::options::OPT_static))
348 D.Diag(clang::diag::err_drv_unsupported_opt_for_target) << "-static"
351 // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
352 // if it exists; otherwise use the driver's installation path, which
353 // should be <SDK_DIR>/host_tools/bin.
355 SmallString<512> PS4SDKDir;
356 if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
357 if (!llvm::sys::fs::exists(EnvValue))
358 getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
359 PS4SDKDir = EnvValue;
361 PS4SDKDir = getDriver().Dir;
362 llvm::sys::path::append(PS4SDKDir, "/../../");
365 // By default, the driver won't report a warning if it can't find
366 // PS4's include or lib directories. This behavior could be changed if
367 // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
368 // If -isysroot was passed, use that as the SDK base path.
369 std::string PrefixDir;
370 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
371 PrefixDir = A->getValue();
372 if (!llvm::sys::fs::exists(PrefixDir))
373 getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
375 PrefixDir = PS4SDKDir.str();
377 SmallString<512> PS4SDKIncludeDir(PrefixDir);
378 llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
379 if (!Args.hasArg(options::OPT_nostdinc) &&
380 !Args.hasArg(options::OPT_nostdlibinc) &&
381 !Args.hasArg(options::OPT_isysroot) &&
382 !Args.hasArg(options::OPT__sysroot_EQ) &&
383 !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
384 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
385 << "PS4 system headers" << PS4SDKIncludeDir;
388 SmallString<512> PS4SDKLibDir(PS4SDKDir);
389 llvm::sys::path::append(PS4SDKLibDir, "target/lib");
390 if (!Args.hasArg(options::OPT_nostdlib) &&
391 !Args.hasArg(options::OPT_nodefaultlibs) &&
392 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
393 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
394 !Args.hasArg(options::OPT_emit_ast) &&
395 !llvm::sys::fs::exists(PS4SDKLibDir)) {
396 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
397 << "PS4 system libraries" << PS4SDKLibDir;
400 getFilePaths().push_back(PS4SDKLibDir.str());
403 Tool *toolchains::PS4CPU::buildAssembler() const {
404 return new tools::PS4cpu::Assemble(*this);
407 Tool *toolchains::PS4CPU::buildLinker() const {
408 return new tools::PS4cpu::Link(*this);
411 bool toolchains::PS4CPU::isPICDefault() const { return true; }
413 bool toolchains::PS4CPU::HasNativeLLVMSupport() const { return true; }
415 SanitizerMask toolchains::PS4CPU::getSupportedSanitizers() const {
416 SanitizerMask Res = ToolChain::getSupportedSanitizers();
417 Res |= SanitizerKind::Address;
418 Res |= SanitizerKind::Vptr;