1 //===--- PS4CPU.cpp - PS4CPU ToolChain Implementations ----------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
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
22 using namespace clang::driver;
23 using namespace clang;
24 using namespace llvm::opt;
26 using clang::driver::tools::AddLinkerInputs;
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,
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");
49 void tools::PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
50 const InputInfo &Output,
51 const InputInfoList &Inputs,
53 const char *LinkingOutput) const {
54 claimNoWarnArgs(Args);
55 ArgStringList CmdArgs;
57 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
59 CmdArgs.push_back("-o");
60 CmdArgs.push_back(Output.getFilename());
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());
68 Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
69 C.addCommand(std::make_unique<Command>(
70 JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs));
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");
78 if (SanArgs.needsAsanRt()) {
79 CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
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");
92 void tools::PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
93 const InputInfo &Output,
94 const InputInfoList &Inputs,
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;
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);
110 if (!D.SysRoot.empty())
111 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
113 if (Args.hasArg(options::OPT_pie))
114 CmdArgs.push_back("-pie");
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");
121 if (Output.isFilename()) {
122 CmdArgs.push_back("-o");
123 CmdArgs.push_back(Output.getFilename());
125 assert(Output.isNothing() && "Invalid output.");
128 if(!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
129 AddPS4SanitizerArgs(ToolChain, CmdArgs);
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);
138 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
139 CmdArgs.push_back("--no-demangle");
141 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
143 if (Args.hasArg(options::OPT_pthread)) {
144 CmdArgs.push_back("-lpthread");
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();
153 Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
155 C.addCommand(std::make_unique<Command>(
156 JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs));
159 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
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"
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.
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;
176 PS4SDKDir = getDriver().Dir;
177 llvm::sys::path::append(PS4SDKDir, "/../../");
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;
190 PrefixDir = std::string(PS4SDKDir.str());
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;
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;
215 getFilePaths().push_back(std::string(PS4SDKLibDir.str()));
218 Tool *toolchains::PS4CPU::buildAssembler() const {
219 return new tools::PS4cpu::Assemble(*this);
222 Tool *toolchains::PS4CPU::buildLinker() const {
223 return new tools::PS4cpu::Link(*this);
226 bool toolchains::PS4CPU::isPICDefault() const { return true; }
228 bool toolchains::PS4CPU::HasNativeLLVMSupport() const { return true; }
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;
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();
250 CC1Args.push_back("-fno-use-init-array");