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 "CommonArgs.h" 11 #include "clang/Config/config.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 // Helper to paste bits of an option together and return a saved string. 27 static const char *makeArgString(const ArgList &Args, const char *Prefix, 28 const char *Base, const char *Suffix) { 29 // Basically "Prefix + Base + Suffix" all converted to Twine then saved. 30 return Args.MakeArgString(Twine(StringRef(Prefix), Base) + Suffix); 31 } 32 33 void tools::PScpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args, 34 ArgStringList &CmdArgs) { 35 assert(TC.getTriple().isPS()); 36 auto &PSTC = static_cast<const toolchains::PS4PS5Base &>(TC); 37 38 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs, 39 false) || 40 Args.hasFlag(options::OPT_fprofile_generate, 41 options::OPT_fno_profile_generate, false) || 42 Args.hasFlag(options::OPT_fprofile_generate_EQ, 43 options::OPT_fno_profile_generate, false) || 44 Args.hasFlag(options::OPT_fprofile_instr_generate, 45 options::OPT_fno_profile_instr_generate, false) || 46 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ, 47 options::OPT_fno_profile_instr_generate, false) || 48 Args.hasFlag(options::OPT_fcs_profile_generate, 49 options::OPT_fno_profile_generate, false) || 50 Args.hasFlag(options::OPT_fcs_profile_generate_EQ, 51 options::OPT_fno_profile_generate, false) || 52 Args.hasArg(options::OPT_fcreate_profile) || 53 Args.hasArg(options::OPT_coverage))) 54 CmdArgs.push_back(makeArgString( 55 Args, "--dependent-lib=", PSTC.getProfileRTLibName(), "")); 56 } 57 58 void tools::PScpu::Assembler::ConstructJob(Compilation &C, const JobAction &JA, 59 const InputInfo &Output, 60 const InputInfoList &Inputs, 61 const ArgList &Args, 62 const char *LinkingOutput) const { 63 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain()); 64 claimNoWarnArgs(Args); 65 ArgStringList CmdArgs; 66 67 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 68 69 CmdArgs.push_back("-o"); 70 CmdArgs.push_back(Output.getFilename()); 71 72 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 73 const InputInfo &Input = Inputs[0]; 74 assert(Input.isFilename() && "Invalid input."); 75 CmdArgs.push_back(Input.getFilename()); 76 77 std::string AsName = TC.qualifyPSCmdName("as"); 78 const char *Exec = Args.MakeArgString(TC.GetProgramPath(AsName.c_str())); 79 C.addCommand(std::make_unique<Command>(JA, *this, 80 ResponseFileSupport::AtFileUTF8(), 81 Exec, CmdArgs, Inputs, Output)); 82 } 83 84 void tools::PScpu::addSanitizerArgs(const ToolChain &TC, const ArgList &Args, 85 ArgStringList &CmdArgs) { 86 assert(TC.getTriple().isPS()); 87 auto &PSTC = static_cast<const toolchains::PS4PS5Base &>(TC); 88 PSTC.addSanitizerArgs(Args, CmdArgs, "--dependent-lib=lib", ".a"); 89 } 90 91 void toolchains::PS4CPU::addSanitizerArgs(const ArgList &Args, 92 ArgStringList &CmdArgs, 93 const char *Prefix, 94 const char *Suffix) const { 95 auto arg = [&](const char *Name) -> const char * { 96 return makeArgString(Args, Prefix, Name, Suffix); 97 }; 98 const SanitizerArgs &SanArgs = getSanitizerArgs(Args); 99 if (SanArgs.needsUbsanRt()) 100 CmdArgs.push_back(arg("SceDbgUBSanitizer_stub_weak")); 101 if (SanArgs.needsAsanRt()) 102 CmdArgs.push_back(arg("SceDbgAddressSanitizer_stub_weak")); 103 } 104 105 void toolchains::PS5CPU::addSanitizerArgs(const ArgList &Args, 106 ArgStringList &CmdArgs, 107 const char *Prefix, 108 const char *Suffix) const { 109 auto arg = [&](const char *Name) -> const char * { 110 return makeArgString(Args, Prefix, Name, Suffix); 111 }; 112 const SanitizerArgs &SanArgs = getSanitizerArgs(Args); 113 if (SanArgs.needsUbsanRt()) 114 CmdArgs.push_back(arg("SceUBSanitizer_nosubmission_stub_weak")); 115 if (SanArgs.needsAsanRt()) 116 CmdArgs.push_back(arg("SceAddressSanitizer_nosubmission_stub_weak")); 117 if (SanArgs.needsTsanRt()) 118 CmdArgs.push_back(arg("SceThreadSanitizer_nosubmission_stub_weak")); 119 } 120 121 void tools::PScpu::Linker::ConstructJob(Compilation &C, const JobAction &JA, 122 const InputInfo &Output, 123 const InputInfoList &Inputs, 124 const ArgList &Args, 125 const char *LinkingOutput) const { 126 auto &TC = static_cast<const toolchains::PS4PS5Base &>(getToolChain()); 127 const Driver &D = TC.getDriver(); 128 ArgStringList CmdArgs; 129 130 // Silence warning for "clang -g foo.o -o foo" 131 Args.ClaimAllArgs(options::OPT_g_Group); 132 // and "clang -emit-llvm foo.o -o foo" 133 Args.ClaimAllArgs(options::OPT_emit_llvm); 134 // and for "clang -w foo.o -o foo". Other warning options are already 135 // handled somewhere else. 136 Args.ClaimAllArgs(options::OPT_w); 137 138 if (!D.SysRoot.empty()) 139 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 140 141 if (Args.hasArg(options::OPT_pie)) 142 CmdArgs.push_back("-pie"); 143 144 if (Args.hasArg(options::OPT_rdynamic)) 145 CmdArgs.push_back("-export-dynamic"); 146 if (Args.hasArg(options::OPT_shared)) 147 CmdArgs.push_back("--shared"); 148 149 if (Output.isFilename()) { 150 CmdArgs.push_back("-o"); 151 CmdArgs.push_back(Output.getFilename()); 152 } else { 153 assert(Output.isNothing() && "Invalid output."); 154 } 155 156 const bool UseLTO = D.isUsingLTO(); 157 const bool UseJMC = 158 Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false); 159 const bool IsPS4 = TC.getTriple().isPS4(); 160 const bool IsPS5 = TC.getTriple().isPS5(); 161 assert(IsPS4 || IsPS5); 162 163 const char *PS4LTOArgs = ""; 164 auto AddCodeGenFlag = [&](Twine Flag) { 165 if (IsPS4) 166 PS4LTOArgs = Args.MakeArgString(Twine(PS4LTOArgs) + " " + Flag); 167 else if (IsPS5) 168 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=") + Flag)); 169 }; 170 171 if (UseLTO) { 172 // We default to creating the arange section, but LTO does not. Enable it 173 // here. 174 AddCodeGenFlag("-generate-arange-section"); 175 176 // This tells LTO to perform JustMyCode instrumentation. 177 if (UseJMC) 178 AddCodeGenFlag("-enable-jmc-instrument"); 179 180 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir)) 181 AddCodeGenFlag(Twine("-crash-diagnostics-dir=") + A->getValue()); 182 183 StringRef Parallelism = getLTOParallelism(Args, D); 184 if (!Parallelism.empty()) { 185 if (IsPS4) 186 AddCodeGenFlag(Twine("-threads=") + Parallelism); 187 else 188 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=jobs=") + Parallelism)); 189 } 190 191 if (IsPS4) { 192 const char *Prefix = nullptr; 193 if (D.getLTOMode() == LTOK_Thin) 194 Prefix = "-lto-thin-debug-options="; 195 else if (D.getLTOMode() == LTOK_Full) 196 Prefix = "-lto-debug-options="; 197 else 198 llvm_unreachable("new LTO mode?"); 199 200 CmdArgs.push_back(Args.MakeArgString(Twine(Prefix) + PS4LTOArgs)); 201 } 202 } 203 204 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) 205 TC.addSanitizerArgs(Args, CmdArgs, "-l", ""); 206 207 if (D.isUsingLTO() && Args.hasArg(options::OPT_funified_lto)) { 208 if (D.getLTOMode() == LTOK_Thin) 209 CmdArgs.push_back("--lto=thin"); 210 else if (D.getLTOMode() == LTOK_Full) 211 CmdArgs.push_back("--lto=full"); 212 } 213 214 Args.AddAllArgs(CmdArgs, options::OPT_L); 215 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 216 Args.AddAllArgs(CmdArgs, options::OPT_s); 217 Args.AddAllArgs(CmdArgs, options::OPT_t); 218 Args.AddAllArgs(CmdArgs, options::OPT_r); 219 220 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) 221 CmdArgs.push_back("--no-demangle"); 222 223 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA); 224 225 if (Args.hasArg(options::OPT_pthread)) { 226 CmdArgs.push_back("-lpthread"); 227 } 228 229 if (UseJMC) { 230 CmdArgs.push_back("--whole-archive"); 231 if (IsPS4) 232 CmdArgs.push_back("-lSceDbgJmc"); 233 else 234 CmdArgs.push_back("-lSceJmc_nosubmission"); 235 CmdArgs.push_back("--no-whole-archive"); 236 } 237 238 if (Args.hasArg(options::OPT_fuse_ld_EQ)) { 239 D.Diag(diag::err_drv_unsupported_opt_for_target) 240 << "-fuse-ld" << TC.getTriple().str(); 241 } 242 243 std::string LdName = TC.qualifyPSCmdName(TC.getLinkerBaseName()); 244 const char *Exec = Args.MakeArgString(TC.GetProgramPath(LdName.c_str())); 245 246 C.addCommand(std::make_unique<Command>(JA, *this, 247 ResponseFileSupport::AtFileUTF8(), 248 Exec, CmdArgs, Inputs, Output)); 249 } 250 251 toolchains::PS4PS5Base::PS4PS5Base(const Driver &D, const llvm::Triple &Triple, 252 const ArgList &Args, StringRef Platform, 253 const char *EnvVar) 254 : Generic_ELF(D, Triple, Args) { 255 if (Args.hasArg(clang::driver::options::OPT_static)) 256 D.Diag(clang::diag::err_drv_unsupported_opt_for_target) 257 << "-static" << Platform; 258 259 // Determine where to find the PS4/PS5 libraries. 260 // If -isysroot was passed, use that as the SDK base path. 261 // If not, we use the EnvVar if it exists; otherwise use the driver's 262 // installation path, which should be <SDK_DIR>/host_tools/bin. 263 SmallString<80> Whence; 264 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 265 SDKRootDir = A->getValue(); 266 if (!llvm::sys::fs::exists(SDKRootDir)) 267 D.Diag(clang::diag::warn_missing_sysroot) << SDKRootDir; 268 Whence = A->getSpelling(); 269 } else if (const char *EnvValue = getenv(EnvVar)) { 270 SDKRootDir = EnvValue; 271 Whence = { "environment variable '", EnvVar, "'" }; 272 } else { 273 SDKRootDir = D.Dir + "/../../"; 274 Whence = "compiler's location"; 275 } 276 277 SmallString<512> SDKIncludeDir(SDKRootDir); 278 llvm::sys::path::append(SDKIncludeDir, "target/include"); 279 if (!Args.hasArg(options::OPT_nostdinc) && 280 !Args.hasArg(options::OPT_nostdlibinc) && 281 !Args.hasArg(options::OPT_isysroot) && 282 !Args.hasArg(options::OPT__sysroot_EQ) && 283 !llvm::sys::fs::exists(SDKIncludeDir)) { 284 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected) 285 << Twine(Platform, " system headers").str() << SDKIncludeDir << Whence; 286 } 287 288 SmallString<512> SDKLibDir(SDKRootDir); 289 llvm::sys::path::append(SDKLibDir, "target/lib"); 290 if (!Args.hasArg(options::OPT_nostdlib) && 291 !Args.hasArg(options::OPT_nodefaultlibs) && 292 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) && 293 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) && 294 !Args.hasArg(options::OPT_emit_ast) && 295 !llvm::sys::fs::exists(SDKLibDir)) { 296 D.Diag(clang::diag::warn_drv_unable_to_find_directory_expected) 297 << Twine(Platform, " system libraries").str() << SDKLibDir << Whence; 298 return; 299 } 300 getFilePaths().push_back(std::string(SDKLibDir.str())); 301 } 302 303 void toolchains::PS4PS5Base::AddClangSystemIncludeArgs( 304 const ArgList &DriverArgs, 305 ArgStringList &CC1Args) const { 306 const Driver &D = getDriver(); 307 308 if (DriverArgs.hasArg(options::OPT_nostdinc)) 309 return; 310 311 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 312 SmallString<128> Dir(D.ResourceDir); 313 llvm::sys::path::append(Dir, "include"); 314 addSystemInclude(DriverArgs, CC1Args, Dir.str()); 315 } 316 317 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 318 return; 319 320 addExternCSystemInclude(DriverArgs, CC1Args, 321 SDKRootDir + "/target/include"); 322 addExternCSystemInclude(DriverArgs, CC1Args, 323 SDKRootDir + "/target/include_common"); 324 } 325 326 Tool *toolchains::PS4CPU::buildAssembler() const { 327 return new tools::PScpu::Assembler(*this); 328 } 329 330 Tool *toolchains::PS5CPU::buildAssembler() const { 331 // PS5 does not support an external assembler. 332 getDriver().Diag(clang::diag::err_no_external_assembler); 333 return nullptr; 334 } 335 336 Tool *toolchains::PS4PS5Base::buildLinker() const { 337 return new tools::PScpu::Linker(*this); 338 } 339 340 SanitizerMask toolchains::PS4PS5Base::getSupportedSanitizers() const { 341 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 342 Res |= SanitizerKind::Address; 343 Res |= SanitizerKind::PointerCompare; 344 Res |= SanitizerKind::PointerSubtract; 345 Res |= SanitizerKind::Vptr; 346 return Res; 347 } 348 349 SanitizerMask toolchains::PS5CPU::getSupportedSanitizers() const { 350 SanitizerMask Res = PS4PS5Base::getSupportedSanitizers(); 351 Res |= SanitizerKind::Thread; 352 return Res; 353 } 354 355 void toolchains::PS4PS5Base::addClangTargetOptions( 356 const ArgList &DriverArgs, ArgStringList &CC1Args, 357 Action::OffloadKind DeviceOffloadingKind) const { 358 // PS4/PS5 do not use init arrays. 359 if (DriverArgs.hasArg(options::OPT_fuse_init_array)) { 360 Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array); 361 getDriver().Diag(clang::diag::err_drv_unsupported_opt_for_target) 362 << A->getAsString(DriverArgs) << getTriple().str(); 363 } 364 365 CC1Args.push_back("-fno-use-init-array"); 366 367 const Arg *A = 368 DriverArgs.getLastArg(options::OPT_fvisibility_from_dllstorageclass, 369 options::OPT_fno_visibility_from_dllstorageclass); 370 if (!A || 371 A->getOption().matches(options::OPT_fvisibility_from_dllstorageclass)) { 372 CC1Args.push_back("-fvisibility-from-dllstorageclass"); 373 374 if (DriverArgs.hasArg(options::OPT_fvisibility_dllexport_EQ)) 375 DriverArgs.AddLastArg(CC1Args, options::OPT_fvisibility_dllexport_EQ); 376 else 377 CC1Args.push_back("-fvisibility-dllexport=protected"); 378 379 if (DriverArgs.hasArg(options::OPT_fvisibility_nodllstorageclass_EQ)) 380 DriverArgs.AddLastArg(CC1Args, 381 options::OPT_fvisibility_nodllstorageclass_EQ); 382 else 383 CC1Args.push_back("-fvisibility-nodllstorageclass=hidden"); 384 385 if (DriverArgs.hasArg(options::OPT_fvisibility_externs_dllimport_EQ)) 386 DriverArgs.AddLastArg(CC1Args, 387 options::OPT_fvisibility_externs_dllimport_EQ); 388 else 389 CC1Args.push_back("-fvisibility-externs-dllimport=default"); 390 391 if (DriverArgs.hasArg( 392 options::OPT_fvisibility_externs_nodllstorageclass_EQ)) 393 DriverArgs.AddLastArg( 394 CC1Args, options::OPT_fvisibility_externs_nodllstorageclass_EQ); 395 else 396 CC1Args.push_back("-fvisibility-externs-nodllstorageclass=default"); 397 } 398 } 399 400 // PS4 toolchain. 401 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple, 402 const llvm::opt::ArgList &Args) 403 : PS4PS5Base(D, Triple, Args, "PS4", "SCE_ORBIS_SDK_DIR") {} 404 405 // PS5 toolchain. 406 toolchains::PS5CPU::PS5CPU(const Driver &D, const llvm::Triple &Triple, 407 const llvm::opt::ArgList &Args) 408 : PS4PS5Base(D, Triple, Args, "PS5", "SCE_PROSPERO_SDK_DIR") {} 409