lib/Driver/ToolChains/PS4CPU.cpp

   1 //===--- PS4CPU.cpp - PS4CPU ToolChain Implementations ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "PS4CPU.h"
  11 #include "FreeBSD.h"
  12 #include "CommonArgs.h"
  13 #include "clang/Driver/Compilation.h"
  14 #include "clang/Driver/Driver.h"
  15 #include "clang/Driver/DriverDiagnostic.h"
  16 #include "clang/Driver/Options.h"
  17 #include "clang/Driver/SanitizerArgs.h"
  18 #include "llvm/Option/ArgList.h"
  19 #include "llvm/Support/FileSystem.h"
  20 #include "llvm/Support/Path.h"
  21 #include <cstdlib> // ::getenv
  22
  23 using namespace clang::driver;
  24 using namespace clang;
  25 using namespace llvm::opt;
  26
  27 using clang::driver::tools::AddLinkerInputs;
  28
  29 void tools::PS4cpu::addProfileRTArgs(const ToolChain &TC, const ArgList &Args,
  30                                      ArgStringList &CmdArgs) {
  31   if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
  32                     false) ||
  33        Args.hasFlag(options::OPT_fprofile_generate,
  34                     options::OPT_fno_profile_instr_generate, false) ||
  35        Args.hasFlag(options::OPT_fprofile_generate_EQ,
  36                     options::OPT_fno_profile_instr_generate, false) ||
  37        Args.hasFlag(options::OPT_fprofile_instr_generate,
  38                     options::OPT_fno_profile_instr_generate, false) ||
  39        Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
  40                     options::OPT_fno_profile_instr_generate, false) ||
  41        Args.hasArg(options::OPT_fcreate_profile) ||
  42        Args.hasArg(options::OPT_coverage)))
  43     CmdArgs.push_back("--dependent-lib=libclang_rt.profile-x86_64.a");
  44 }
  45
  46 void tools::PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
  47                                            const InputInfo &Output,
  48                                            const InputInfoList &Inputs,
  49                                            const ArgList &Args,
  50                                            const char *LinkingOutput) const {
  51   claimNoWarnArgs(Args);
  52   ArgStringList CmdArgs;
  53
  54   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
  55
  56   CmdArgs.push_back("-o");
  57   CmdArgs.push_back(Output.getFilename());
  58
  59   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
  60   const InputInfo &Input = Inputs[0];
  61   assert(Input.isFilename() && "Invalid input.");
  62   CmdArgs.push_back(Input.getFilename());
  63
  64   const char *Exec =
  65       Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
  66   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
  67 }
  68
  69 static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
  70   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
  71   if (SanArgs.needsUbsanRt()) {
  72     CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
  73   }
  74   if (SanArgs.needsAsanRt()) {
  75     CmdArgs.push_back("-lSceDbgAddressSanitizer_stub_weak");
  76   }
  77 }
  78
  79 static void ConstructPS4LinkJob(const Tool &T, Compilation &C,
  80                                 const JobAction &JA, const InputInfo &Output,
  81                                 const InputInfoList &Inputs,
  82                                 const ArgList &Args,
  83                                 const char *LinkingOutput) {
  84   const toolchains::FreeBSD &ToolChain =
  85       static_cast<const toolchains::FreeBSD &>(T.getToolChain());
  86   const Driver &D = ToolChain.getDriver();
  87   ArgStringList CmdArgs;
  88
  89   // Silence warning for "clang -g foo.o -o foo"
  90   Args.ClaimAllArgs(options::OPT_g_Group);
  91   // and "clang -emit-llvm foo.o -o foo"
  92   Args.ClaimAllArgs(options::OPT_emit_llvm);
  93   // and for "clang -w foo.o -o foo". Other warning options are already
  94   // handled somewhere else.
  95   Args.ClaimAllArgs(options::OPT_w);
  96
  97   if (!D.SysRoot.empty())
  98     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
  99
 100   if (Args.hasArg(options::OPT_pie))
 101     CmdArgs.push_back("-pie");
 102
 103   if (Args.hasArg(options::OPT_rdynamic))
 104     CmdArgs.push_back("-export-dynamic");
 105   if (Args.hasArg(options::OPT_shared))
 106     CmdArgs.push_back("--oformat=so");
 107
 108   if (Output.isFilename()) {
 109     CmdArgs.push_back("-o");
 110     CmdArgs.push_back(Output.getFilename());
 111   } else {
 112     assert(Output.isNothing() && "Invalid output.");
 113   }
 114
 115   AddPS4SanitizerArgs(ToolChain, CmdArgs);
 116
 117   Args.AddAllArgs(CmdArgs, options::OPT_L);
 118   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
 119   Args.AddAllArgs(CmdArgs, options::OPT_e);
 120   Args.AddAllArgs(CmdArgs, options::OPT_s);
 121   Args.AddAllArgs(CmdArgs, options::OPT_t);
 122   Args.AddAllArgs(CmdArgs, options::OPT_r);
 123
 124   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
 125     CmdArgs.push_back("--no-demangle");
 126
 127   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
 128
 129   if (Args.hasArg(options::OPT_pthread)) {
 130     CmdArgs.push_back("-lpthread");
 131   }
 132
 133   const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
 134
 135   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
 136 }
 137
 138 static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
 139                                  const JobAction &JA, const InputInfo &Output,
 140                                  const InputInfoList &Inputs,
 141                                  const ArgList &Args,
 142                                  const char *LinkingOutput) {
 143   const toolchains::FreeBSD &ToolChain =
 144       static_cast<const toolchains::FreeBSD &>(T.getToolChain());
 145   const Driver &D = ToolChain.getDriver();
 146   ArgStringList CmdArgs;
 147
 148   // Silence warning for "clang -g foo.o -o foo"
 149   Args.ClaimAllArgs(options::OPT_g_Group);
 150   // and "clang -emit-llvm foo.o -o foo"
 151   Args.ClaimAllArgs(options::OPT_emit_llvm);
 152   // and for "clang -w foo.o -o foo". Other warning options are already
 153   // handled somewhere else.
 154   Args.ClaimAllArgs(options::OPT_w);
 155
 156   if (!D.SysRoot.empty())
 157     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 158
 159   if (Args.hasArg(options::OPT_pie))
 160     CmdArgs.push_back("-pie");
 161
 162   if (Args.hasArg(options::OPT_static)) {
 163     CmdArgs.push_back("-Bstatic");
 164   } else {
 165     if (Args.hasArg(options::OPT_rdynamic))
 166       CmdArgs.push_back("-export-dynamic");
 167     CmdArgs.push_back("--eh-frame-hdr");
 168     if (Args.hasArg(options::OPT_shared)) {
 169       CmdArgs.push_back("-Bshareable");
 170     } else {
 171       CmdArgs.push_back("-dynamic-linker");
 172       CmdArgs.push_back("/libexec/ld-elf.so.1");
 173     }
 174     CmdArgs.push_back("--enable-new-dtags");
 175   }
 176
 177   if (Output.isFilename()) {
 178     CmdArgs.push_back("-o");
 179     CmdArgs.push_back(Output.getFilename());
 180   } else {
 181     assert(Output.isNothing() && "Invalid output.");
 182   }
 183
 184   AddPS4SanitizerArgs(ToolChain, CmdArgs);
 185
 186   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
 187     const char *crt1 = nullptr;
 188     if (!Args.hasArg(options::OPT_shared)) {
 189       if (Args.hasArg(options::OPT_pg))
 190         crt1 = "gcrt1.o";
 191       else if (Args.hasArg(options::OPT_pie))
 192         crt1 = "Scrt1.o";
 193       else
 194         crt1 = "crt1.o";
 195     }
 196     if (crt1)
 197       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
 198
 199     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
 200
 201     const char *crtbegin = nullptr;
 202     if (Args.hasArg(options::OPT_static))
 203       crtbegin = "crtbeginT.o";
 204     else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
 205       crtbegin = "crtbeginS.o";
 206     else
 207       crtbegin = "crtbegin.o";
 208
 209     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
 210   }
 211
 212   Args.AddAllArgs(CmdArgs, options::OPT_L);
 213   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
 214   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
 215   Args.AddAllArgs(CmdArgs, options::OPT_e);
 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(ToolChain, Inputs, Args, CmdArgs, JA);
 224
 225   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 226     // For PS4, we always want to pass libm, libstdc++ and libkernel
 227     // libraries for both C and C++ compilations.
 228     CmdArgs.push_back("-lkernel");
 229     if (D.CCCIsCXX()) {
 230       if (ToolChain.ShouldLinkCXXStdlib(Args))
 231         ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
 232       if (Args.hasArg(options::OPT_pg))
 233         CmdArgs.push_back("-lm_p");
 234       else
 235         CmdArgs.push_back("-lm");
 236     }
 237     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
 238     // the default system libraries. Just mimic this for now.
 239     if (Args.hasArg(options::OPT_pg))
 240       CmdArgs.push_back("-lgcc_p");
 241     else
 242       CmdArgs.push_back("-lcompiler_rt");
 243     if (Args.hasArg(options::OPT_static)) {
 244       CmdArgs.push_back("-lstdc++");
 245     } else if (Args.hasArg(options::OPT_pg)) {
 246       CmdArgs.push_back("-lgcc_eh_p");
 247     } else {
 248       CmdArgs.push_back("--as-needed");
 249       CmdArgs.push_back("-lstdc++");
 250       CmdArgs.push_back("--no-as-needed");
 251     }
 252
 253     if (Args.hasArg(options::OPT_pthread)) {
 254       if (Args.hasArg(options::OPT_pg))
 255         CmdArgs.push_back("-lpthread_p");
 256       else
 257         CmdArgs.push_back("-lpthread");
 258     }
 259
 260     if (Args.hasArg(options::OPT_pg)) {
 261       if (Args.hasArg(options::OPT_shared))
 262         CmdArgs.push_back("-lc");
 263       else {
 264         if (Args.hasArg(options::OPT_static)) {
 265           CmdArgs.push_back("--start-group");
 266           CmdArgs.push_back("-lc_p");
 267           CmdArgs.push_back("-lpthread_p");
 268           CmdArgs.push_back("--end-group");
 269         } else {
 270           CmdArgs.push_back("-lc_p");
 271         }
 272       }
 273       CmdArgs.push_back("-lgcc_p");
 274     } else {
 275       if (Args.hasArg(options::OPT_static)) {
 276         CmdArgs.push_back("--start-group");
 277         CmdArgs.push_back("-lc");
 278         CmdArgs.push_back("-lpthread");
 279         CmdArgs.push_back("--end-group");
 280       } else {
 281         CmdArgs.push_back("-lc");
 282       }
 283       CmdArgs.push_back("-lcompiler_rt");
 284     }
 285
 286     if (Args.hasArg(options::OPT_static)) {
 287       CmdArgs.push_back("-lstdc++");
 288     } else if (Args.hasArg(options::OPT_pg)) {
 289       CmdArgs.push_back("-lgcc_eh_p");
 290     } else {
 291       CmdArgs.push_back("--as-needed");
 292       CmdArgs.push_back("-lstdc++");
 293       CmdArgs.push_back("--no-as-needed");
 294     }
 295   }
 296
 297   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
 298     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
 299       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
 300     else
 301       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
 302     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
 303   }
 304
 305   const char *Exec =
 306 #ifdef LLVM_ON_WIN32
 307       Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld.gold"));
 308 #else
 309       Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
 310 #endif
 311
 312   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
 313 }
 314
 315 void tools::PS4cpu::Link::ConstructJob(Compilation &C, const JobAction &JA,
 316                                        const InputInfo &Output,
 317                                        const InputInfoList &Inputs,
 318                                        const ArgList &Args,
 319                                        const char *LinkingOutput) const {
 320   const toolchains::FreeBSD &ToolChain =
 321       static_cast<const toolchains::FreeBSD &>(getToolChain());
 322   const Driver &D = ToolChain.getDriver();
 323   bool PS4Linker;
 324   StringRef LinkerOptName;
 325   if (const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
 326     LinkerOptName = A->getValue();
 327     if (LinkerOptName != "ps4" && LinkerOptName != "gold")
 328       D.Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
 329   }
 330
 331   if (LinkerOptName == "gold")
 332     PS4Linker = false;
 333   else if (LinkerOptName == "ps4")
 334     PS4Linker = true;
 335   else
 336     PS4Linker = !Args.hasArg(options::OPT_shared);
 337
 338   if (PS4Linker)
 339     ConstructPS4LinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
 340   else
 341     ConstructGoldLinkJob(*this, C, JA, Output, Inputs, Args, LinkingOutput);
 342 }
 343
 344 toolchains::PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple,
 345                            const ArgList &Args)
 346     : Generic_ELF(D, Triple, Args) {
 347   if (Args.hasArg(clang::driver::options::OPT_static))
 348     D.Diag(clang::diag::err_drv_unsupported_opt_for_target) << "-static"
 349                                                             << "PS4";
 350
 351   // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
 352   // if it exists; otherwise use the driver's installation path, which
 353   // should be <SDK_DIR>/host_tools/bin.
 354
 355   SmallString<512> PS4SDKDir;
 356   if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
 357     if (!llvm::sys::fs::exists(EnvValue))
 358       getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
 359     PS4SDKDir = EnvValue;
 360   } else {
 361     PS4SDKDir = getDriver().Dir;
 362     llvm::sys::path::append(PS4SDKDir, "/../../");
 363   }
 364
 365   // By default, the driver won't report a warning if it can't find
 366   // PS4's include or lib directories. This behavior could be changed if
 367   // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
 368   // If -isysroot was passed, use that as the SDK base path.
 369   std::string PrefixDir;
 370   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 371     PrefixDir = A->getValue();
 372     if (!llvm::sys::fs::exists(PrefixDir))
 373       getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
 374   } else
 375     PrefixDir = PS4SDKDir.str();
 376
 377   SmallString<512> PS4SDKIncludeDir(PrefixDir);
 378   llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
 379   if (!Args.hasArg(options::OPT_nostdinc) &&
 380       !Args.hasArg(options::OPT_nostdlibinc) &&
 381       !Args.hasArg(options::OPT_isysroot) &&
 382       !Args.hasArg(options::OPT__sysroot_EQ) &&
 383       !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
 384     getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
 385         << "PS4 system headers" << PS4SDKIncludeDir;
 386   }
 387
 388   SmallString<512> PS4SDKLibDir(PS4SDKDir);
 389   llvm::sys::path::append(PS4SDKLibDir, "target/lib");
 390   if (!Args.hasArg(options::OPT_nostdlib) &&
 391       !Args.hasArg(options::OPT_nodefaultlibs) &&
 392       !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
 393       !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
 394       !Args.hasArg(options::OPT_emit_ast) &&
 395       !llvm::sys::fs::exists(PS4SDKLibDir)) {
 396     getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
 397         << "PS4 system libraries" << PS4SDKLibDir;
 398     return;
 399   }
 400   getFilePaths().push_back(PS4SDKLibDir.str());
 401 }
 402
 403 Tool *toolchains::PS4CPU::buildAssembler() const {
 404   return new tools::PS4cpu::Assemble(*this);
 405 }
 406
 407 Tool *toolchains::PS4CPU::buildLinker() const {
 408   return new tools::PS4cpu::Link(*this);
 409 }
 410
 411 bool toolchains::PS4CPU::isPICDefault() const { return true; }
 412
 413 bool toolchains::PS4CPU::HasNativeLLVMSupport() const { return true; }
 414
 415 SanitizerMask toolchains::PS4CPU::getSupportedSanitizers() const {
 416   SanitizerMask Res = ToolChain::getSupportedSanitizers();
 417   Res |= SanitizerKind::Address;
 418   Res |= SanitizerKind::Vptr;
 419   return Res;
 420 }