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 
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_generate, false) ||
34        Args.hasFlag(options::OPT_fprofile_generate_EQ,
35                     options::OPT_fno_profile_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.hasFlag(options::OPT_fcs_profile_generate,
41                     options::OPT_fno_profile_generate, false) ||
42        Args.hasFlag(options::OPT_fcs_profile_generate_EQ,
43                     options::OPT_fno_profile_generate, false) ||
44        Args.hasArg(options::OPT_fcreate_profile) ||
45        Args.hasArg(options::OPT_coverage)))
46     CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
47 }
48 
49 void tools::PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
50                                            const InputInfo &Output,
51                                            const InputInfoList &Inputs,
52                                            const ArgList &Args,
53                                            const char *LinkingOutput) const {
54   claimNoWarnArgs(Args);
55   ArgStringList CmdArgs;
56 
57   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
58 
59   CmdArgs.push_back("-o");
60   CmdArgs.push_back(Output.getFilename());
61 
62   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
63   const InputInfo &Input = Inputs[0];
64   assert(Input.isFilename() && "Invalid input.");
65   CmdArgs.push_back(Input.getFilename());
66 
67   const char *Exec =
68       Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
69   C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
70 }
71 
72 static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
73   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
74   if (SanArgs.needsUbsanRt()) {
75     CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
76   }
77   if (SanArgs.needsAsanRt()) {
78     CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
79   }
80 }
81 
82 void tools::PS4cpu::addSanitizerArgs(const ToolChain &TC,
83                                      ArgStringList &CmdArgs) {
84   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
85   if (SanArgs.needsUbsanRt())
86     CmdArgs.push_back("--dependent-lib=libSceDbgUBSanitizer_stub_weak.a");
87   if (SanArgs.needsAsanRt())
88     CmdArgs.push_back("--dependent-lib=libSceDbgAddressSanitizer_stub_weak.a");
89 }
90 
91 void tools::PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
92                                        const InputInfo &Output,
93                                        const InputInfoList &Inputs,
94                                        const ArgList &Args,
95                                        const char *LinkingOutput) const {
96   const toolchains::FreeBSD &ToolChain =
97       static_cast<const toolchains::FreeBSD &>(getToolChain());
98   const Driver &D = ToolChain.getDriver();
99   ArgStringList CmdArgs;
100 
101   // Silence warning for "clang -g foo.o -o foo"
102   Args.ClaimAllArgs(options::OPT_g_Group);
103   // and "clang -emit-llvm foo.o -o foo"
104   Args.ClaimAllArgs(options::OPT_emit_llvm);
105   // and for "clang -w foo.o -o foo". Other warning options are already
106   // handled somewhere else.
107   Args.ClaimAllArgs(options::OPT_w);
108 
109   if (!D.SysRoot.empty())
110     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
111 
112   if (Args.hasArg(options::OPT_pie))
113     CmdArgs.push_back("-pie");
114 
115   if (Args.hasArg(options::OPT_rdynamic))
116     CmdArgs.push_back("-export-dynamic");
117   if (Args.hasArg(options::OPT_shared))
118     CmdArgs.push_back("--oformat=so");
119 
120   if (Output.isFilename()) {
121     CmdArgs.push_back("-o");
122     CmdArgs.push_back(Output.getFilename());
123   } else {
124     assert(Output.isNothing() && "Invalid output.");
125   }
126 
127   if(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
128     AddPS4SanitizerArgs(ToolChain, CmdArgs);
129 
130   Args.AddAllArgs(CmdArgs, options::OPT_L);
131   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
132   Args.AddAllArgs(CmdArgs, options::OPT_e);
133   Args.AddAllArgs(CmdArgs, options::OPT_s);
134   Args.AddAllArgs(CmdArgs, options::OPT_t);
135   Args.AddAllArgs(CmdArgs, options::OPT_r);
136 
137   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
138     CmdArgs.push_back("--no-demangle");
139 
140   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
141 
142   if (Args.hasArg(options::OPT_pthread)) {
143     CmdArgs.push_back("-lpthread");
144   }
145 
146   if (Args.hasArg(options::OPT_fuse_ld_EQ)) {
147     D.Diag(diag::err_drv_unsupported_opt_for_target)
148         << "-fuse-ld" << getToolChain().getTriple().str();
149   }
150 
151   const char *Exec =
152       Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
153 
154   C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
155 }
156 
157 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
158                            const ArgList &Args)
159     : Generic_ELF(D, Triple, Args) {
160   if (Args.hasArg(clang::driver::options::OPT_static))
161     D.Diag(clang::diag::err_drv_unsupported_opt_for_target) << "-static"
162                                                             << "PS4";
163 
164   // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
165   // if it exists; otherwise use the driver's installation path, which
166   // should be <SDK_DIR>/host_tools/bin.
167 
168   SmallString<512> PS4SDKDir;
169   if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
170     if (!llvm::sys::fs::exists(EnvValue))
171       getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
172     PS4SDKDir = EnvValue;
173   } else {
174     PS4SDKDir = getDriver().Dir;
175     llvm::sys::path::append(PS4SDKDir, "/../../");
176   }
177 
178   // By default, the driver won't report a warning if it can't find
179   // PS4's include or lib directories. This behavior could be changed if
180   // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
181   // If -isysroot was passed, use that as the SDK base path.
182   std::string PrefixDir;
183   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
184     PrefixDir = A->getValue();
185     if (!llvm::sys::fs::exists(PrefixDir))
186       getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
187   } else
188     PrefixDir = std::string(PS4SDKDir.str());
189 
190   SmallString<512> PS4SDKIncludeDir(PrefixDir);
191   llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
192   if (!Args.hasArg(options::OPT_nostdinc) &&
193       !Args.hasArg(options::OPT_nostdlibinc) &&
194       !Args.hasArg(options::OPT_isysroot) &&
195       !Args.hasArg(options::OPT__sysroot_EQ) &&
196       !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
197     getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
198         << "PS4 system headers" << PS4SDKIncludeDir;
199   }
200 
201   SmallString<512> PS4SDKLibDir(PS4SDKDir);
202   llvm::sys::path::append(PS4SDKLibDir, "target/lib");
203   if (!Args.hasArg(options::OPT_nostdlib) &&
204       !Args.hasArg(options::OPT_nodefaultlibs) &&
205       !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
206       !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
207       !Args.hasArg(options::OPT_emit_ast) &&
208       !llvm::sys::fs::exists(PS4SDKLibDir)) {
209     getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
210         << "PS4 system libraries" << PS4SDKLibDir;
211     return;
212   }
213   getFilePaths().push_back(std::string(PS4SDKLibDir.str()));
214 }
215 
216 Tool *toolchains::PS4CPU::buildAssembler() const {
217   return new tools::PS4cpu::Assemble(*this);
218 }
219 
220 Tool *toolchains::PS4CPU::buildLinker() const {
221   return new tools::PS4cpu::Link(*this);
222 }
223 
224 bool toolchains::PS4CPU::isPICDefault() const { return true; }
225 
226 bool toolchains::PS4CPU::HasNativeLLVMSupport() const { return true; }
227 
228 SanitizerMask toolchains::PS4CPU::getSupportedSanitizers() const {
229   SanitizerMask Res = ToolChain::getSupportedSanitizers();
230   Res |= SanitizerKind::Address;
231   Res |= SanitizerKind::PointerCompare;
232   Res |= SanitizerKind::PointerSubtract;
233   Res |= SanitizerKind::Vptr;
234   return Res;
235 }
236 
237 void toolchains::PS4CPU::addClangTargetOptions(
238       const ArgList &DriverArgs,
239       ArgStringList &CC1Args,
240       Action::OffloadKind DeviceOffloadingKind) const {
241   // PS4 does not use init arrays.
242   if (DriverArgs.hasArg(options::OPT_fuse_init_array)) {
243     Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array);
244     getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target)
245         << A->getAsString(DriverArgs) << getTriple().str();
246   }
247 
248   CC1Args.push_back("-fno-use-init-array");
249 }
250