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