contrib/llvm-project/clang/lib/Driver/ToolChains/Fuchsia.cpp

   1 //===--- Fuchsia.cpp - Fuchsia 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 "Fuchsia.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/ProfileData/InstrProf.h"
  19 #include "llvm/Support/FileSystem.h"
  20 #include "llvm/Support/Path.h"
  21 #include "llvm/Support/VirtualFileSystem.h"
  22
  23 using namespace clang::driver;
  24 using namespace clang::driver::toolchains;
  25 using namespace clang::driver::tools;
  26 using namespace clang;
  27 using namespace llvm::opt;
  28
  29 using tools::addMultilibFlag;
  30
  31 void fuchsia::Linker::ConstructJob(Compilation &C, const JobAction &JA,
  32                                    const InputInfo &Output,
  33                                    const InputInfoList &Inputs,
  34                                    const ArgList &Args,
  35                                    const char *LinkingOutput) const {
  36   const toolchains::Fuchsia &ToolChain =
  37       static_cast<const toolchains::Fuchsia &>(getToolChain());
  38   const Driver &D = ToolChain.getDriver();
  39
  40   ArgStringList CmdArgs;
  41
  42   // Silence warning for "clang -g foo.o -o foo"
  43   Args.ClaimAllArgs(options::OPT_g_Group);
  44   // and "clang -emit-llvm foo.o -o foo"
  45   Args.ClaimAllArgs(options::OPT_emit_llvm);
  46   // and for "clang -w foo.o -o foo". Other warning options are already
  47   // handled somewhere else.
  48   Args.ClaimAllArgs(options::OPT_w);
  49
  50   CmdArgs.push_back("-z");
  51   CmdArgs.push_back("max-page-size=4096");
  52
  53   CmdArgs.push_back("-z");
  54   CmdArgs.push_back("now");
  55
  56   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
  57   if (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
  58       llvm::sys::path::stem(Exec).equals_insensitive("ld.lld")) {
  59     CmdArgs.push_back("-z");
  60     CmdArgs.push_back("rodynamic");
  61     CmdArgs.push_back("-z");
  62     CmdArgs.push_back("separate-loadable-segments");
  63     CmdArgs.push_back("-z");
  64     CmdArgs.push_back("rel");
  65     CmdArgs.push_back("--pack-dyn-relocs=relr");
  66   }
  67
  68   if (!D.SysRoot.empty())
  69     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
  70
  71   if (!Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_r))
  72     CmdArgs.push_back("-pie");
  73
  74   if (Args.hasArg(options::OPT_rdynamic))
  75     CmdArgs.push_back("-export-dynamic");
  76
  77   if (Args.hasArg(options::OPT_s))
  78     CmdArgs.push_back("-s");
  79
  80   if (Args.hasArg(options::OPT_r)) {
  81     CmdArgs.push_back("-r");
  82   } else {
  83     CmdArgs.push_back("--build-id");
  84     CmdArgs.push_back("--hash-style=gnu");
  85   }
  86
  87   CmdArgs.push_back("--eh-frame-hdr");
  88
  89   if (Args.hasArg(options::OPT_static))
  90     CmdArgs.push_back("-Bstatic");
  91   else if (Args.hasArg(options::OPT_shared))
  92     CmdArgs.push_back("-shared");
  93
  94   const SanitizerArgs &SanArgs = ToolChain.getSanitizerArgs(Args);
  95
  96   if (!Args.hasArg(options::OPT_shared)) {
  97     std::string Dyld = D.DyldPrefix;
  98     if (SanArgs.needsAsanRt() && SanArgs.needsSharedRt())
  99       Dyld += "asan/";
 100     if (SanArgs.needsHwasanRt() && SanArgs.needsSharedRt())
 101       Dyld += "hwasan/";
 102     if (SanArgs.needsTsanRt() && SanArgs.needsSharedRt())
 103       Dyld += "tsan/";
 104     Dyld += "ld.so.1";
 105     CmdArgs.push_back("-dynamic-linker");
 106     CmdArgs.push_back(Args.MakeArgString(Dyld));
 107   }
 108
 109   CmdArgs.push_back("-o");
 110   CmdArgs.push_back(Output.getFilename());
 111
 112   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
 113     if (!Args.hasArg(options::OPT_shared)) {
 114       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("Scrt1.o")));
 115     }
 116   }
 117
 118   Args.AddAllArgs(CmdArgs, options::OPT_L);
 119   Args.AddAllArgs(CmdArgs, options::OPT_u);
 120
 121   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
 122
 123   if (D.isUsingLTO()) {
 124     assert(!Inputs.empty() && "Must have at least one input.");
 125     addLTOOptions(ToolChain, Args, CmdArgs, Output, Inputs[0],
 126                   D.getLTOMode() == LTOK_Thin);
 127   }
 128
 129   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
 130   bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
 131   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
 132   ToolChain.addProfileRTLibs(Args, CmdArgs);
 133
 134   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 135     if (Args.hasArg(options::OPT_static))
 136       CmdArgs.push_back("-Bdynamic");
 137
 138     if (D.CCCIsCXX()) {
 139       if (ToolChain.ShouldLinkCXXStdlib(Args)) {
 140         bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
 141                                    !Args.hasArg(options::OPT_static);
 142         CmdArgs.push_back("--push-state");
 143         CmdArgs.push_back("--as-needed");
 144         if (OnlyLibstdcxxStatic)
 145           CmdArgs.push_back("-Bstatic");
 146         ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
 147         if (OnlyLibstdcxxStatic)
 148           CmdArgs.push_back("-Bdynamic");
 149         CmdArgs.push_back("-lm");
 150         CmdArgs.push_back("--pop-state");
 151       }
 152     }
 153
 154     if (NeedsSanitizerDeps)
 155       linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
 156
 157     if (NeedsXRayDeps)
 158       linkXRayRuntimeDeps(ToolChain, CmdArgs);
 159
 160     AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
 161
 162     if (Args.hasArg(options::OPT_pthread) ||
 163         Args.hasArg(options::OPT_pthreads))
 164       CmdArgs.push_back("-lpthread");
 165
 166     if (Args.hasArg(options::OPT_fsplit_stack))
 167       CmdArgs.push_back("--wrap=pthread_create");
 168
 169     if (!Args.hasArg(options::OPT_nolibc))
 170       CmdArgs.push_back("-lc");
 171   }
 172
 173   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
 174                                          Exec, CmdArgs, Inputs, Output));
 175 }
 176
 177 /// Fuchsia - Fuchsia tool chain which can call as(1) and ld(1) directly.
 178
 179 Fuchsia::Fuchsia(const Driver &D, const llvm::Triple &Triple,
 180                  const ArgList &Args)
 181     : ToolChain(D, Triple, Args) {
 182   getProgramPaths().push_back(getDriver().getInstalledDir());
 183   if (getDriver().getInstalledDir() != D.Dir)
 184     getProgramPaths().push_back(D.Dir);
 185
 186   if (!D.SysRoot.empty()) {
 187     SmallString<128> P(D.SysRoot);
 188     llvm::sys::path::append(P, "lib");
 189     getFilePaths().push_back(std::string(P.str()));
 190   }
 191
 192   auto FilePaths = [&](const Multilib &M) -> std::vector<std::string> {
 193     std::vector<std::string> FP;
 194     SmallString<128> P(getStdlibPath());
 195     llvm::sys::path::append(P, M.gccSuffix());
 196     FP.push_back(std::string(P.str()));
 197     return FP;
 198   };
 199
 200   Multilibs.push_back(Multilib());
 201   // Use the noexcept variant with -fno-exceptions to avoid the extra overhead.
 202   Multilibs.push_back(Multilib("noexcept", {}, {}, 1)
 203                           .flag("-fexceptions")
 204                           .flag("+fno-exceptions"));
 205   // ASan has higher priority because we always want the instrumentated version.
 206   Multilibs.push_back(Multilib("asan", {}, {}, 2)
 207                           .flag("+fsanitize=address"));
 208   // Use the asan+noexcept variant with ASan and -fno-exceptions.
 209   Multilibs.push_back(Multilib("asan+noexcept", {}, {}, 3)
 210                           .flag("+fsanitize=address")
 211                           .flag("-fexceptions")
 212                           .flag("+fno-exceptions"));
 213   // HWASan has higher priority because we always want the instrumentated
 214   // version.
 215   Multilibs.push_back(
 216       Multilib("hwasan", {}, {}, 4).flag("+fsanitize=hwaddress"));
 217   // Use the hwasan+noexcept variant with HWASan and -fno-exceptions.
 218   Multilibs.push_back(Multilib("hwasan+noexcept", {}, {}, 5)
 219                           .flag("+fsanitize=hwaddress")
 220                           .flag("-fexceptions")
 221                           .flag("+fno-exceptions"));
 222   // Use the relative vtables ABI.
 223   // TODO: Remove these multilibs once relative vtables are enabled by default
 224   // for Fuchsia.
 225   Multilibs.push_back(Multilib("relative-vtables", {}, {}, 6)
 226                           .flag("+fexperimental-relative-c++-abi-vtables"));
 227   Multilibs.push_back(Multilib("relative-vtables+noexcept", {}, {}, 7)
 228                           .flag("+fexperimental-relative-c++-abi-vtables")
 229                           .flag("-fexceptions")
 230                           .flag("+fno-exceptions"));
 231   Multilibs.push_back(Multilib("relative-vtables+asan", {}, {}, 8)
 232                           .flag("+fexperimental-relative-c++-abi-vtables")
 233                           .flag("+fsanitize=address"));
 234   Multilibs.push_back(Multilib("relative-vtables+asan+noexcept", {}, {}, 9)
 235                           .flag("+fexperimental-relative-c++-abi-vtables")
 236                           .flag("+fsanitize=address")
 237                           .flag("-fexceptions")
 238                           .flag("+fno-exceptions"));
 239   Multilibs.push_back(Multilib("relative-vtables+hwasan", {}, {}, 10)
 240                           .flag("+fexperimental-relative-c++-abi-vtables")
 241                           .flag("+fsanitize=hwaddress"));
 242   Multilibs.push_back(Multilib("relative-vtables+hwasan+noexcept", {}, {}, 11)
 243                           .flag("+fexperimental-relative-c++-abi-vtables")
 244                           .flag("+fsanitize=hwaddress")
 245                           .flag("-fexceptions")
 246                           .flag("+fno-exceptions"));
 247   // Use Itanium C++ ABI for the compat multilib.
 248   Multilibs.push_back(Multilib("compat", {}, {}, 12).flag("+fc++-abi=itanium"));
 249
 250   Multilibs.FilterOut([&](const Multilib &M) {
 251     std::vector<std::string> RD = FilePaths(M);
 252     return llvm::all_of(RD, [&](std::string P) { return !getVFS().exists(P); });
 253   });
 254
 255   Multilib::flags_list Flags;
 256   addMultilibFlag(
 257       Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, true),
 258       "fexceptions", Flags);
 259   addMultilibFlag(getSanitizerArgs(Args).needsAsanRt(), "fsanitize=address",
 260                   Flags);
 261   addMultilibFlag(getSanitizerArgs(Args).needsHwasanRt(), "fsanitize=hwaddress",
 262                   Flags);
 263
 264   addMultilibFlag(
 265       Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
 266                    options::OPT_fno_experimental_relative_cxx_abi_vtables,
 267                    /*default=*/false),
 268       "fexperimental-relative-c++-abi-vtables", Flags);
 269   addMultilibFlag(Args.getLastArgValue(options::OPT_fcxx_abi_EQ) == "itanium",
 270                   "fc++-abi=itanium", Flags);
 271
 272   Multilibs.setFilePathsCallback(FilePaths);
 273
 274   if (Multilibs.select(Flags, SelectedMultilib))
 275     if (!SelectedMultilib.isDefault())
 276       if (const auto &PathsCallback = Multilibs.filePathsCallback())
 277         for (const auto &Path : PathsCallback(SelectedMultilib))
 278           // Prepend the multilib path to ensure it takes the precedence.
 279           getFilePaths().insert(getFilePaths().begin(), Path);
 280 }
 281
 282 std::string Fuchsia::ComputeEffectiveClangTriple(const ArgList &Args,
 283                                                  types::ID InputType) const {
 284   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
 285   return Triple.str();
 286 }
 287
 288 Tool *Fuchsia::buildLinker() const {
 289   return new tools::fuchsia::Linker(*this);
 290 }
 291
 292 ToolChain::RuntimeLibType Fuchsia::GetRuntimeLibType(
 293     const ArgList &Args) const {
 294   if (Arg *A = Args.getLastArg(clang::driver::options::OPT_rtlib_EQ)) {
 295     StringRef Value = A->getValue();
 296     if (Value != "compiler-rt")
 297       getDriver().Diag(clang::diag::err_drv_invalid_rtlib_name)
 298           << A->getAsString(Args);
 299   }
 300
 301   return ToolChain::RLT_CompilerRT;
 302 }
 303
 304 ToolChain::CXXStdlibType
 305 Fuchsia::GetCXXStdlibType(const ArgList &Args) const {
 306   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
 307     StringRef Value = A->getValue();
 308     if (Value != "libc++")
 309       getDriver().Diag(diag::err_drv_invalid_stdlib_name)
 310         << A->getAsString(Args);
 311   }
 312
 313   return ToolChain::CST_Libcxx;
 314 }
 315
 316 void Fuchsia::addClangTargetOptions(const ArgList &DriverArgs,
 317                                     ArgStringList &CC1Args,
 318                                     Action::OffloadKind) const {
 319   if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
 320                           options::OPT_fno_use_init_array, true))
 321     CC1Args.push_back("-fno-use-init-array");
 322 }
 323
 324 void Fuchsia::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 325                                         ArgStringList &CC1Args) const {
 326   const Driver &D = getDriver();
 327
 328   if (DriverArgs.hasArg(options::OPT_nostdinc))
 329     return;
 330
 331   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
 332     SmallString<128> P(D.ResourceDir);
 333     llvm::sys::path::append(P, "include");
 334     addSystemInclude(DriverArgs, CC1Args, P);
 335   }
 336
 337   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
 338     return;
 339
 340   // Check for configure-time C include directories.
 341   StringRef CIncludeDirs(C_INCLUDE_DIRS);
 342   if (CIncludeDirs != "") {
 343     SmallVector<StringRef, 5> dirs;
 344     CIncludeDirs.split(dirs, ":");
 345     for (StringRef dir : dirs) {
 346       StringRef Prefix =
 347           llvm::sys::path::is_absolute(dir) ? "" : StringRef(D.SysRoot);
 348       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
 349     }
 350     return;
 351   }
 352
 353   if (!D.SysRoot.empty()) {
 354     SmallString<128> P(D.SysRoot);
 355     llvm::sys::path::append(P, "include");
 356     addExternCSystemInclude(DriverArgs, CC1Args, P.str());
 357   }
 358 }
 359
 360 void Fuchsia::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
 361                                            ArgStringList &CC1Args) const {
 362   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
 363       DriverArgs.hasArg(options::OPT_nostdincxx))
 364     return;
 365
 366   const Driver &D = getDriver();
 367   std::string Target = getTripleString();
 368
 369   auto AddCXXIncludePath = [&](StringRef Path) {
 370     std::string Version = detectLibcxxVersion(Path);
 371     if (Version.empty())
 372       return;
 373
 374     // First add the per-target include path.
 375     SmallString<128> TargetDir(Path);
 376     llvm::sys::path::append(TargetDir, Target, "c++", Version);
 377     if (getVFS().exists(TargetDir))
 378       addSystemInclude(DriverArgs, CC1Args, TargetDir);
 379
 380     // Second add the generic one.
 381     SmallString<128> Dir(Path);
 382     llvm::sys::path::append(Dir, "c++", Version);
 383     addSystemInclude(DriverArgs, CC1Args, Dir);
 384   };
 385
 386   switch (GetCXXStdlibType(DriverArgs)) {
 387   case ToolChain::CST_Libcxx: {
 388     SmallString<128> P(D.Dir);
 389     llvm::sys::path::append(P, "..", "include");
 390     AddCXXIncludePath(P);
 391     break;
 392   }
 393
 394   default:
 395     llvm_unreachable("invalid stdlib name");
 396   }
 397 }
 398
 399 void Fuchsia::AddCXXStdlibLibArgs(const ArgList &Args,
 400                                   ArgStringList &CmdArgs) const {
 401   switch (GetCXXStdlibType(Args)) {
 402   case ToolChain::CST_Libcxx:
 403     CmdArgs.push_back("-lc++");
 404     break;
 405
 406   case ToolChain::CST_Libstdcxx:
 407     llvm_unreachable("invalid stdlib name");
 408   }
 409 }
 410
 411 SanitizerMask Fuchsia::getSupportedSanitizers() const {
 412   SanitizerMask Res = ToolChain::getSupportedSanitizers();
 413   Res |= SanitizerKind::Address;
 414   Res |= SanitizerKind::HWAddress;
 415   Res |= SanitizerKind::PointerCompare;
 416   Res |= SanitizerKind::PointerSubtract;
 417   Res |= SanitizerKind::Fuzzer;
 418   Res |= SanitizerKind::FuzzerNoLink;
 419   Res |= SanitizerKind::Leak;
 420   Res |= SanitizerKind::SafeStack;
 421   Res |= SanitizerKind::Scudo;
 422   Res |= SanitizerKind::Thread;
 423   return Res;
 424 }
 425
 426 SanitizerMask Fuchsia::getDefaultSanitizers() const {
 427   SanitizerMask Res;
 428   switch (getTriple().getArch()) {
 429   case llvm::Triple::aarch64:
 430     Res |= SanitizerKind::ShadowCallStack;
 431     break;
 432   case llvm::Triple::x86_64:
 433     Res |= SanitizerKind::SafeStack;
 434     break;
 435   default:
 436     // TODO: Enable SafeStack on RISC-V once tested.
 437     break;
 438   }
 439   return Res;
 440 }