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