contrib/llvm/tools/clang/lib/Driver/ToolChains/Linux.cpp

   1 //===--- Linux.h - Linux 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 "Linux.h"
  11 #include "Arch/ARM.h"
  12 #include "Arch/Mips.h"
  13 #include "Arch/PPC.h"
  14 #include "Arch/RISCV.h"
  15 #include "CommonArgs.h"
  16 #include "clang/Basic/VirtualFileSystem.h"
  17 #include "clang/Config/config.h"
  18 #include "clang/Driver/Distro.h"
  19 #include "clang/Driver/Driver.h"
  20 #include "clang/Driver/Options.h"
  21 #include "clang/Driver/SanitizerArgs.h"
  22 #include "llvm/Option/ArgList.h"
  23 #include "llvm/ProfileData/InstrProf.h"
  24 #include "llvm/Support/Path.h"
  25 #include "llvm/Support/ScopedPrinter.h"
  26 #include <system_error>
  27
  28 using namespace clang::driver;
  29 using namespace clang::driver::toolchains;
  30 using namespace clang;
  31 using namespace llvm::opt;
  32
  33 using tools::addPathIfExists;
  34
  35 /// Get our best guess at the multiarch triple for a target.
  36 ///
  37 /// Debian-based systems are starting to use a multiarch setup where they use
  38 /// a target-triple directory in the library and header search paths.
  39 /// Unfortunately, this triple does not align with the vanilla target triple,
  40 /// so we provide a rough mapping here.
  41 static std::string getMultiarchTriple(const Driver &D,
  42                                       const llvm::Triple &TargetTriple,
  43                                       StringRef SysRoot) {
  44   llvm::Triple::EnvironmentType TargetEnvironment =
  45       TargetTriple.getEnvironment();
  46   bool IsAndroid = TargetTriple.isAndroid();
  47
  48   // For most architectures, just use whatever we have rather than trying to be
  49   // clever.
  50   switch (TargetTriple.getArch()) {
  51   default:
  52     break;
  53
  54   // We use the existence of '/lib/<triple>' as a directory to detect some
  55   // common linux triples that don't quite match the Clang triple for both
  56   // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
  57   // regardless of what the actual target triple is.
  58   case llvm::Triple::arm:
  59   case llvm::Triple::thumb:
  60     if (IsAndroid) {
  61       return "arm-linux-androideabi";
  62     } else if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
  63       if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabihf"))
  64         return "arm-linux-gnueabihf";
  65     } else {
  66       if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabi"))
  67         return "arm-linux-gnueabi";
  68     }
  69     break;
  70   case llvm::Triple::armeb:
  71   case llvm::Triple::thumbeb:
  72     if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
  73       if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabihf"))
  74         return "armeb-linux-gnueabihf";
  75     } else {
  76       if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabi"))
  77         return "armeb-linux-gnueabi";
  78     }
  79     break;
  80   case llvm::Triple::x86:
  81     if (IsAndroid)
  82       return "i686-linux-android";
  83     if (D.getVFS().exists(SysRoot + "/lib/i386-linux-gnu"))
  84       return "i386-linux-gnu";
  85     break;
  86   case llvm::Triple::x86_64:
  87     if (IsAndroid)
  88       return "x86_64-linux-android";
  89     // We don't want this for x32, otherwise it will match x86_64 libs
  90     if (TargetEnvironment != llvm::Triple::GNUX32 &&
  91         D.getVFS().exists(SysRoot + "/lib/x86_64-linux-gnu"))
  92       return "x86_64-linux-gnu";
  93     break;
  94   case llvm::Triple::aarch64:
  95     if (IsAndroid)
  96       return "aarch64-linux-android";
  97     if (D.getVFS().exists(SysRoot + "/lib/aarch64-linux-gnu"))
  98       return "aarch64-linux-gnu";
  99     break;
 100   case llvm::Triple::aarch64_be:
 101     if (D.getVFS().exists(SysRoot + "/lib/aarch64_be-linux-gnu"))
 102       return "aarch64_be-linux-gnu";
 103     break;
 104   case llvm::Triple::mips:
 105     if (D.getVFS().exists(SysRoot + "/lib/mips-linux-gnu"))
 106       return "mips-linux-gnu";
 107     break;
 108   case llvm::Triple::mipsel:
 109     if (IsAndroid)
 110       return "mipsel-linux-android";
 111     if (D.getVFS().exists(SysRoot + "/lib/mipsel-linux-gnu"))
 112       return "mipsel-linux-gnu";
 113     break;
 114   case llvm::Triple::mips64:
 115     if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
 116       return "mips64-linux-gnu";
 117     if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnuabi64"))
 118       return "mips64-linux-gnuabi64";
 119     break;
 120   case llvm::Triple::mips64el:
 121     if (IsAndroid)
 122       return "mips64el-linux-android";
 123     if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
 124       return "mips64el-linux-gnu";
 125     if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnuabi64"))
 126       return "mips64el-linux-gnuabi64";
 127     break;
 128   case llvm::Triple::ppc:
 129     if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
 130       return "powerpc-linux-gnuspe";
 131     if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnu"))
 132       return "powerpc-linux-gnu";
 133     break;
 134   case llvm::Triple::ppc64:
 135     if (D.getVFS().exists(SysRoot + "/lib/powerpc64-linux-gnu"))
 136       return "powerpc64-linux-gnu";
 137     break;
 138   case llvm::Triple::ppc64le:
 139     if (D.getVFS().exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
 140       return "powerpc64le-linux-gnu";
 141     break;
 142   case llvm::Triple::sparc:
 143     if (D.getVFS().exists(SysRoot + "/lib/sparc-linux-gnu"))
 144       return "sparc-linux-gnu";
 145     break;
 146   case llvm::Triple::sparcv9:
 147     if (D.getVFS().exists(SysRoot + "/lib/sparc64-linux-gnu"))
 148       return "sparc64-linux-gnu";
 149     break;
 150   case llvm::Triple::systemz:
 151     if (D.getVFS().exists(SysRoot + "/lib/s390x-linux-gnu"))
 152       return "s390x-linux-gnu";
 153     break;
 154   }
 155   return TargetTriple.str();
 156 }
 157
 158 static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
 159   if (Triple.isMIPS()) {
 160     if (Triple.isAndroid()) {
 161       StringRef CPUName;
 162       StringRef ABIName;
 163       tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
 164       if (CPUName == "mips32r6")
 165         return "libr6";
 166       if (CPUName == "mips32r2")
 167         return "libr2";
 168     }
 169     // lib32 directory has a special meaning on MIPS targets.
 170     // It contains N32 ABI binaries. Use this folder if produce
 171     // code for N32 ABI only.
 172     if (tools::mips::hasMipsAbiArg(Args, "n32"))
 173       return "lib32";
 174     return Triple.isArch32Bit() ? "lib" : "lib64";
 175   }
 176
 177   // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and
 178   // using that variant while targeting other architectures causes problems
 179   // because the libraries are laid out in shared system roots that can't cope
 180   // with a 'lib32' library search path being considered. So we only enable
 181   // them when we know we may need it.
 182   //
 183   // FIXME: This is a bit of a hack. We should really unify this code for
 184   // reasoning about oslibdir spellings with the lib dir spellings in the
 185   // GCCInstallationDetector, but that is a more significant refactoring.
 186   if (Triple.getArch() == llvm::Triple::x86 ||
 187       Triple.getArch() == llvm::Triple::ppc)
 188     return "lib32";
 189
 190   if (Triple.getArch() == llvm::Triple::x86_64 &&
 191       Triple.getEnvironment() == llvm::Triple::GNUX32)
 192     return "libx32";
 193
 194   if (Triple.getArch() == llvm::Triple::riscv32)
 195     return "lib32";
 196
 197   return Triple.isArch32Bit() ? "lib" : "lib64";
 198 }
 199
 200 static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,
 201                                   const Multilib &Multilib,
 202                                   StringRef InstallPath,
 203                                   ToolChain::path_list &Paths) {
 204   if (const auto &PathsCallback = Multilibs.filePathsCallback())
 205     for (const auto &Path : PathsCallback(Multilib))
 206       addPathIfExists(D, InstallPath + Path, Paths);
 207 }
 208
 209 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
 210     : Generic_ELF(D, Triple, Args) {
 211   GCCInstallation.init(Triple, Args);
 212   Multilibs = GCCInstallation.getMultilibs();
 213   llvm::Triple::ArchType Arch = Triple.getArch();
 214   std::string SysRoot = computeSysRoot();
 215
 216   // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
 217   // least) put various tools in a triple-prefixed directory off of the parent
 218   // of the GCC installation. We use the GCC triple here to ensure that we end
 219   // up with tools that support the same amount of cross compiling as the
 220   // detected GCC installation. For example, if we find a GCC installation
 221   // targeting x86_64, but it is a bi-arch GCC installation, it can also be
 222   // used to target i386.
 223   // FIXME: This seems unlikely to be Linux-specific.
 224   ToolChain::path_list &PPaths = getProgramPaths();
 225   PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
 226                          GCCInstallation.getTriple().str() + "/bin")
 227                        .str());
 228
 229   Distro Distro(D.getVFS());
 230
 231   if (Distro.IsAlpineLinux()) {
 232     ExtraOpts.push_back("-z");
 233     ExtraOpts.push_back("now");
 234   }
 235
 236   if (Distro.IsOpenSUSE() || Distro.IsUbuntu() || Distro.IsAlpineLinux()) {
 237     ExtraOpts.push_back("-z");
 238     ExtraOpts.push_back("relro");
 239   }
 240
 241   if (GCCInstallation.getParentLibPath().find("opt/rh/devtoolset") !=
 242       StringRef::npos)
 243     // With devtoolset on RHEL, we want to add a bin directory that is relative
 244     // to the detected gcc install, because if we are using devtoolset gcc then
 245     // we want to use other tools from devtoolset (e.g. ld) instead of the
 246     // standard system tools.
 247     PPaths.push_back(Twine(GCCInstallation.getParentLibPath() +
 248                      "/../bin").str());
 249
 250   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
 251     ExtraOpts.push_back("-X");
 252
 253   const bool IsAndroid = Triple.isAndroid();
 254   const bool IsMips = Triple.isMIPS();
 255   const bool IsHexagon = Arch == llvm::Triple::hexagon;
 256   const bool IsRISCV =
 257       Arch == llvm::Triple::riscv32 || Arch == llvm::Triple::riscv64;
 258
 259   if (IsMips && !SysRoot.empty())
 260     ExtraOpts.push_back("--sysroot=" + SysRoot);
 261
 262   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
 263   // and the MIPS ABI require .dynsym to be sorted in different ways.
 264   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
 265   // ABI requires a mapping between the GOT and the symbol table.
 266   // Android loader does not support .gnu.hash.
 267   // Hexagon linker/loader does not support .gnu.hash
 268   if (!IsMips && !IsAndroid && !IsHexagon) {
 269     if (Distro.IsRedhat() || Distro.IsOpenSUSE() || Distro.IsAlpineLinux() ||
 270         (Distro.IsUbuntu() && Distro >= Distro::UbuntuMaverick))
 271       ExtraOpts.push_back("--hash-style=gnu");
 272
 273     if (Distro.IsDebian() || Distro.IsOpenSUSE() || Distro == Distro::UbuntuLucid ||
 274         Distro == Distro::UbuntuJaunty || Distro == Distro::UbuntuKarmic)
 275       ExtraOpts.push_back("--hash-style=both");
 276   }
 277
 278   if (Distro.IsRedhat() && Distro != Distro::RHEL5 && Distro != Distro::RHEL6)
 279     ExtraOpts.push_back("--no-add-needed");
 280
 281 #ifdef ENABLE_LINKER_BUILD_ID
 282   ExtraOpts.push_back("--build-id");
 283 #endif
 284
 285   if (IsAndroid || Distro.IsOpenSUSE())
 286     ExtraOpts.push_back("--enable-new-dtags");
 287
 288   // The selection of paths to try here is designed to match the patterns which
 289   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
 290   // This was determined by running GCC in a fake filesystem, creating all
 291   // possible permutations of these directories, and seeing which ones it added
 292   // to the link paths.
 293   path_list &Paths = getFilePaths();
 294
 295   const std::string OSLibDir = getOSLibDir(Triple, Args);
 296   const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
 297
 298   // Add the multilib suffixed paths where they are available.
 299   if (GCCInstallation.isValid()) {
 300     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
 301     const std::string &LibPath = GCCInstallation.getParentLibPath();
 302     const Multilib &Multilib = GCCInstallation.getMultilib();
 303     const MultilibSet &Multilibs = GCCInstallation.getMultilibs();
 304
 305     // Add toolchain / multilib specific file paths.
 306     addMultilibsFilePaths(D, Multilibs, Multilib,
 307                           GCCInstallation.getInstallPath(), Paths);
 308
 309     // Sourcery CodeBench MIPS toolchain holds some libraries under
 310     // a biarch-like suffix of the GCC installation.
 311     addPathIfExists(D, GCCInstallation.getInstallPath() + Multilib.gccSuffix(),
 312                     Paths);
 313
 314     // GCC cross compiling toolchains will install target libraries which ship
 315     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
 316     // any part of the GCC installation in
 317     // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
 318     // debatable, but is the reality today. We need to search this tree even
 319     // when we have a sysroot somewhere else. It is the responsibility of
 320     // whomever is doing the cross build targeting a sysroot using a GCC
 321     // installation that is *not* within the system root to ensure two things:
 322     //
 323     //  1) Any DSOs that are linked in from this tree or from the install path
 324     //     above must be present on the system root and found via an
 325     //     appropriate rpath.
 326     //  2) There must not be libraries installed into
 327     //     <prefix>/<triple>/<libdir> unless they should be preferred over
 328     //     those within the system root.
 329     //
 330     // Note that this matches the GCC behavior. See the below comment for where
 331     // Clang diverges from GCC's behavior.
 332     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
 333                            OSLibDir + Multilib.osSuffix(),
 334                     Paths);
 335
 336     // If the GCC installation we found is inside of the sysroot, we want to
 337     // prefer libraries installed in the parent prefix of the GCC installation.
 338     // It is important to *not* use these paths when the GCC installation is
 339     // outside of the system root as that can pick up unintended libraries.
 340     // This usually happens when there is an external cross compiler on the
 341     // host system, and a more minimal sysroot available that is the target of
 342     // the cross. Note that GCC does include some of these directories in some
 343     // configurations but this seems somewhere between questionable and simply
 344     // a bug.
 345     if (StringRef(LibPath).startswith(SysRoot)) {
 346       addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);
 347       addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
 348     }
 349   }
 350
 351   // Similar to the logic for GCC above, if we currently running Clang inside
 352   // of the requested system root, add its parent library paths to
 353   // those searched.
 354   // FIXME: It's not clear whether we should use the driver's installed
 355   // directory ('Dir' below) or the ResourceDir.
 356   if (StringRef(D.Dir).startswith(SysRoot)) {
 357     addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);
 358     addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
 359   }
 360
 361   addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
 362   addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
 363
 364   if (IsAndroid) {
 365     // Android sysroots contain a library directory for each supported OS
 366     // version as well as some unversioned libraries in the usual multiarch
 367     // directory.
 368     unsigned Major;
 369     unsigned Minor;
 370     unsigned Micro;
 371     Triple.getEnvironmentVersion(Major, Minor, Micro);
 372     addPathIfExists(D,
 373                     SysRoot + "/usr/lib/" + MultiarchTriple + "/" +
 374                         llvm::to_string(Major),
 375                     Paths);
 376   }
 377
 378   addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
 379   // 64-bit OpenEmbedded sysroots may not have a /usr/lib dir. So they cannot
 380   // find /usr/lib64 as it is referenced as /usr/lib/../lib64. So we handle
 381   // this here.
 382   if (Triple.getVendor() == llvm::Triple::OpenEmbedded &&
 383       Triple.isArch64Bit())
 384     addPathIfExists(D, SysRoot + "/usr/" + OSLibDir, Paths);
 385   else
 386     addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
 387   if (IsRISCV) {
 388     StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
 389     addPathIfExists(D, SysRoot + "/" + OSLibDir + "/" + ABIName, Paths);
 390     addPathIfExists(D, SysRoot + "/usr/" + OSLibDir + "/" + ABIName, Paths);
 391   }
 392
 393   // Try walking via the GCC triple path in case of biarch or multiarch GCC
 394   // installations with strange symlinks.
 395   if (GCCInstallation.isValid()) {
 396     addPathIfExists(D,
 397                     SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
 398                         "/../../" + OSLibDir,
 399                     Paths);
 400
 401     // Add the 'other' biarch variant path
 402     Multilib BiarchSibling;
 403     if (GCCInstallation.getBiarchSibling(BiarchSibling)) {
 404       addPathIfExists(D, GCCInstallation.getInstallPath() +
 405                              BiarchSibling.gccSuffix(),
 406                       Paths);
 407     }
 408
 409     // See comments above on the multilib variant for details of why this is
 410     // included even from outside the sysroot.
 411     const std::string &LibPath = GCCInstallation.getParentLibPath();
 412     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
 413     const Multilib &Multilib = GCCInstallation.getMultilib();
 414     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +
 415                            Multilib.osSuffix(),
 416                     Paths);
 417
 418     // See comments above on the multilib variant for details of why this is
 419     // only included from within the sysroot.
 420     if (StringRef(LibPath).startswith(SysRoot))
 421       addPathIfExists(D, LibPath, Paths);
 422   }
 423
 424   // Similar to the logic for GCC above, if we are currently running Clang
 425   // inside of the requested system root, add its parent library path to those
 426   // searched.
 427   // FIXME: It's not clear whether we should use the driver's installed
 428   // directory ('Dir' below) or the ResourceDir.
 429   if (StringRef(D.Dir).startswith(SysRoot))
 430     addPathIfExists(D, D.Dir + "/../lib", Paths);
 431
 432   addPathIfExists(D, SysRoot + "/lib", Paths);
 433   addPathIfExists(D, SysRoot + "/usr/lib", Paths);
 434 }
 435
 436 bool Linux::HasNativeLLVMSupport() const { return true; }
 437
 438 Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
 439
 440 Tool *Linux::buildAssembler() const {
 441   return new tools::gnutools::Assembler(*this);
 442 }
 443
 444 std::string Linux::computeSysRoot() const {
 445   if (!getDriver().SysRoot.empty())
 446     return getDriver().SysRoot;
 447
 448   if (getTriple().isAndroid()) {
 449     // Android toolchains typically include a sysroot at ../sysroot relative to
 450     // the clang binary.
 451     const StringRef ClangDir = getDriver().getInstalledDir();
 452     std::string AndroidSysRootPath = (ClangDir + "/../sysroot").str();
 453     if (getVFS().exists(AndroidSysRootPath))
 454       return AndroidSysRootPath;
 455   }
 456
 457   if (!GCCInstallation.isValid() || !getTriple().isMIPS())
 458     return std::string();
 459
 460   // Standalone MIPS toolchains use different names for sysroot folder
 461   // and put it into different places. Here we try to check some known
 462   // variants.
 463
 464   const StringRef InstallDir = GCCInstallation.getInstallPath();
 465   const StringRef TripleStr = GCCInstallation.getTriple().str();
 466   const Multilib &Multilib = GCCInstallation.getMultilib();
 467
 468   std::string Path =
 469       (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
 470           .str();
 471
 472   if (getVFS().exists(Path))
 473     return Path;
 474
 475   Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
 476
 477   if (getVFS().exists(Path))
 478     return Path;
 479
 480   return std::string();
 481 }
 482
 483 std::string Linux::getDynamicLinker(const ArgList &Args) const {
 484   const llvm::Triple::ArchType Arch = getArch();
 485   const llvm::Triple &Triple = getTriple();
 486
 487   const Distro Distro(getDriver().getVFS());
 488
 489   if (Triple.isAndroid())
 490     return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
 491
 492   if (Triple.isMusl()) {
 493     std::string ArchName;
 494     bool IsArm = false;
 495
 496     switch (Arch) {
 497     case llvm::Triple::arm:
 498     case llvm::Triple::thumb:
 499       ArchName = "arm";
 500       IsArm = true;
 501       break;
 502     case llvm::Triple::armeb:
 503     case llvm::Triple::thumbeb:
 504       ArchName = "armeb";
 505       IsArm = true;
 506       break;
 507     default:
 508       ArchName = Triple.getArchName().str();
 509     }
 510     if (IsArm &&
 511         (Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
 512          tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard))
 513       ArchName += "hf";
 514
 515     return "/lib/ld-musl-" + ArchName + ".so.1";
 516   }
 517
 518   std::string LibDir;
 519   std::string Loader;
 520
 521   switch (Arch) {
 522   default:
 523     llvm_unreachable("unsupported architecture");
 524
 525   case llvm::Triple::aarch64:
 526     LibDir = "lib";
 527     Loader = "ld-linux-aarch64.so.1";
 528     break;
 529   case llvm::Triple::aarch64_be:
 530     LibDir = "lib";
 531     Loader = "ld-linux-aarch64_be.so.1";
 532     break;
 533   case llvm::Triple::arm:
 534   case llvm::Triple::thumb:
 535   case llvm::Triple::armeb:
 536   case llvm::Triple::thumbeb: {
 537     const bool HF =
 538         Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
 539         tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;
 540
 541     LibDir = "lib";
 542     Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
 543     break;
 544   }
 545   case llvm::Triple::mips:
 546   case llvm::Triple::mipsel:
 547   case llvm::Triple::mips64:
 548   case llvm::Triple::mips64el: {
 549     bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);
 550
 551     LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
 552
 553     if (tools::mips::isUCLibc(Args))
 554       Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
 555     else if (!Triple.hasEnvironment() &&
 556              Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
 557       Loader =
 558           Triple.isLittleEndian() ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
 559     else
 560       Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
 561
 562     break;
 563   }
 564   case llvm::Triple::ppc:
 565     LibDir = "lib";
 566     Loader = "ld.so.1";
 567     break;
 568   case llvm::Triple::ppc64:
 569     LibDir = "lib64";
 570     Loader =
 571         (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";
 572     break;
 573   case llvm::Triple::ppc64le:
 574     LibDir = "lib64";
 575     Loader =
 576         (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";
 577     break;
 578   case llvm::Triple::riscv32: {
 579     StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
 580     LibDir = "lib";
 581     Loader = ("ld-linux-riscv32-" + ABIName + ".so.1").str();
 582     break;
 583   }
 584   case llvm::Triple::riscv64: {
 585     StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
 586     LibDir = "lib";
 587     Loader = ("ld-linux-riscv64-" + ABIName + ".so.1").str();
 588     break;
 589   }
 590   case llvm::Triple::sparc:
 591   case llvm::Triple::sparcel:
 592     LibDir = "lib";
 593     Loader = "ld-linux.so.2";
 594     break;
 595   case llvm::Triple::sparcv9:
 596     LibDir = "lib64";
 597     Loader = "ld-linux.so.2";
 598     break;
 599   case llvm::Triple::systemz:
 600     LibDir = "lib";
 601     Loader = "ld64.so.1";
 602     break;
 603   case llvm::Triple::x86:
 604     LibDir = "lib";
 605     Loader = "ld-linux.so.2";
 606     break;
 607   case llvm::Triple::x86_64: {
 608     bool X32 = Triple.getEnvironment() == llvm::Triple::GNUX32;
 609
 610     LibDir = X32 ? "libx32" : "lib64";
 611     Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";
 612     break;
 613   }
 614   }
 615
 616   if (Distro == Distro::Exherbo && (Triple.getVendor() == llvm::Triple::UnknownVendor ||
 617                                     Triple.getVendor() == llvm::Triple::PC))
 618     return "/usr/" + Triple.str() + "/lib/" + Loader;
 619   return "/" + LibDir + "/" + Loader;
 620 }
 621
 622 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 623                                       ArgStringList &CC1Args) const {
 624   const Driver &D = getDriver();
 625   std::string SysRoot = computeSysRoot();
 626
 627   if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
 628     return;
 629
 630   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
 631     addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
 632
 633   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
 634     SmallString<128> P(D.ResourceDir);
 635     llvm::sys::path::append(P, "include");
 636     addSystemInclude(DriverArgs, CC1Args, P);
 637   }
 638
 639   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
 640     return;
 641
 642   // Check for configure-time C include directories.
 643   StringRef CIncludeDirs(C_INCLUDE_DIRS);
 644   if (CIncludeDirs != "") {
 645     SmallVector<StringRef, 5> dirs;
 646     CIncludeDirs.split(dirs, ":");
 647     for (StringRef dir : dirs) {
 648       StringRef Prefix =
 649           llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : "";
 650       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
 651     }
 652     return;
 653   }
 654
 655   // Lacking those, try to detect the correct set of system includes for the
 656   // target triple.
 657
 658   // Add include directories specific to the selected multilib set and multilib.
 659   if (GCCInstallation.isValid()) {
 660     const auto &Callback = Multilibs.includeDirsCallback();
 661     if (Callback) {
 662       for (const auto &Path : Callback(GCCInstallation.getMultilib()))
 663         addExternCSystemIncludeIfExists(
 664             DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
 665     }
 666   }
 667
 668   // Implement generic Debian multiarch support.
 669   const StringRef X86_64MultiarchIncludeDirs[] = {
 670       "/usr/include/x86_64-linux-gnu",
 671
 672       // FIXME: These are older forms of multiarch. It's not clear that they're
 673       // in use in any released version of Debian, so we should consider
 674       // removing them.
 675       "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"};
 676   const StringRef X86MultiarchIncludeDirs[] = {
 677       "/usr/include/i386-linux-gnu",
 678
 679       // FIXME: These are older forms of multiarch. It's not clear that they're
 680       // in use in any released version of Debian, so we should consider
 681       // removing them.
 682       "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
 683       "/usr/include/i486-linux-gnu"};
 684   const StringRef AArch64MultiarchIncludeDirs[] = {
 685       "/usr/include/aarch64-linux-gnu"};
 686   const StringRef ARMMultiarchIncludeDirs[] = {
 687       "/usr/include/arm-linux-gnueabi"};
 688   const StringRef ARMHFMultiarchIncludeDirs[] = {
 689       "/usr/include/arm-linux-gnueabihf"};
 690   const StringRef ARMEBMultiarchIncludeDirs[] = {
 691       "/usr/include/armeb-linux-gnueabi"};
 692   const StringRef ARMEBHFMultiarchIncludeDirs[] = {
 693       "/usr/include/armeb-linux-gnueabihf"};
 694   const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"};
 695   const StringRef MIPSELMultiarchIncludeDirs[] = {
 696       "/usr/include/mipsel-linux-gnu"};
 697   const StringRef MIPS64MultiarchIncludeDirs[] = {
 698       "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"};
 699   const StringRef MIPS64ELMultiarchIncludeDirs[] = {
 700       "/usr/include/mips64el-linux-gnu",
 701       "/usr/include/mips64el-linux-gnuabi64"};
 702   const StringRef PPCMultiarchIncludeDirs[] = {
 703       "/usr/include/powerpc-linux-gnu"};
 704   const StringRef PPC64MultiarchIncludeDirs[] = {
 705       "/usr/include/powerpc64-linux-gnu"};
 706   const StringRef PPC64LEMultiarchIncludeDirs[] = {
 707       "/usr/include/powerpc64le-linux-gnu"};
 708   const StringRef SparcMultiarchIncludeDirs[] = {
 709       "/usr/include/sparc-linux-gnu"};
 710   const StringRef Sparc64MultiarchIncludeDirs[] = {
 711       "/usr/include/sparc64-linux-gnu"};
 712   const StringRef SYSTEMZMultiarchIncludeDirs[] = {
 713       "/usr/include/s390x-linux-gnu"};
 714   ArrayRef<StringRef> MultiarchIncludeDirs;
 715   switch (getTriple().getArch()) {
 716   case llvm::Triple::x86_64:
 717     MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
 718     break;
 719   case llvm::Triple::x86:
 720     MultiarchIncludeDirs = X86MultiarchIncludeDirs;
 721     break;
 722   case llvm::Triple::aarch64:
 723   case llvm::Triple::aarch64_be:
 724     MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
 725     break;
 726   case llvm::Triple::arm:
 727   case llvm::Triple::thumb:
 728     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
 729       MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
 730     else
 731       MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
 732     break;
 733   case llvm::Triple::armeb:
 734   case llvm::Triple::thumbeb:
 735     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
 736       MultiarchIncludeDirs = ARMEBHFMultiarchIncludeDirs;
 737     else
 738       MultiarchIncludeDirs = ARMEBMultiarchIncludeDirs;
 739     break;
 740   case llvm::Triple::mips:
 741     MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
 742     break;
 743   case llvm::Triple::mipsel:
 744     MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
 745     break;
 746   case llvm::Triple::mips64:
 747     MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
 748     break;
 749   case llvm::Triple::mips64el:
 750     MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
 751     break;
 752   case llvm::Triple::ppc:
 753     MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
 754     break;
 755   case llvm::Triple::ppc64:
 756     MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
 757     break;
 758   case llvm::Triple::ppc64le:
 759     MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
 760     break;
 761   case llvm::Triple::sparc:
 762     MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
 763     break;
 764   case llvm::Triple::sparcv9:
 765     MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
 766     break;
 767   case llvm::Triple::systemz:
 768     MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;
 769     break;
 770   default:
 771     break;
 772   }
 773
 774   const std::string AndroidMultiarchIncludeDir =
 775       std::string("/usr/include/") +
 776       getMultiarchTriple(D, getTriple(), SysRoot);
 777   const StringRef AndroidMultiarchIncludeDirs[] = {AndroidMultiarchIncludeDir};
 778   if (getTriple().isAndroid())
 779     MultiarchIncludeDirs = AndroidMultiarchIncludeDirs;
 780
 781   for (StringRef Dir : MultiarchIncludeDirs) {
 782     if (D.getVFS().exists(SysRoot + Dir)) {
 783       addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);
 784       break;
 785     }
 786   }
 787
 788   if (getTriple().getOS() == llvm::Triple::RTEMS)
 789     return;
 790
 791   // Add an include of '/include' directly. This isn't provided by default by
 792   // system GCCs, but is often used with cross-compiling GCCs, and harmless to
 793   // add even when Clang is acting as-if it were a system compiler.
 794   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
 795
 796   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
 797 }
 798
 799 static std::string DetectLibcxxIncludePath(StringRef base) {
 800   std::error_code EC;
 801   int MaxVersion = 0;
 802   std::string MaxVersionString = "";
 803   for (llvm::sys::fs::directory_iterator LI(base, EC), LE; !EC && LI != LE;
 804        LI = LI.increment(EC)) {
 805     StringRef VersionText = llvm::sys::path::filename(LI->path());
 806     int Version;
 807     if (VersionText[0] == 'v' &&
 808         !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
 809       if (Version > MaxVersion) {
 810         MaxVersion = Version;
 811         MaxVersionString = VersionText;
 812       }
 813     }
 814   }
 815   return MaxVersion ? (base + "/" + MaxVersionString).str() : "";
 816 }
 817
 818 void Linux::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
 819                                   llvm::opt::ArgStringList &CC1Args) const {
 820   const std::string& SysRoot = computeSysRoot();
 821   const std::string LibCXXIncludePathCandidates[] = {
 822       DetectLibcxxIncludePath(getDriver().ResourceDir + "/include/c++"),
 823       DetectLibcxxIncludePath(getDriver().Dir + "/../include/c++"),
 824       // If this is a development, non-installed, clang, libcxx will
 825       // not be found at ../include/c++ but it likely to be found at
 826       // one of the following two locations:
 827       DetectLibcxxIncludePath(SysRoot + "/usr/local/include/c++"),
 828       DetectLibcxxIncludePath(SysRoot + "/usr/include/c++") };
 829   for (const auto &IncludePath : LibCXXIncludePathCandidates) {
 830     if (IncludePath.empty() || !getVFS().exists(IncludePath))
 831       continue;
 832     // Use the first candidate that exists.
 833     addSystemInclude(DriverArgs, CC1Args, IncludePath);
 834     return;
 835   }
 836 }
 837
 838 void Linux::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
 839                                      llvm::opt::ArgStringList &CC1Args) const {
 840   // We need a detected GCC installation on Linux to provide libstdc++'s
 841   // headers.
 842   if (!GCCInstallation.isValid())
 843     return;
 844
 845   // By default, look for the C++ headers in an include directory adjacent to
 846   // the lib directory of the GCC installation. Note that this is expect to be
 847   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
 848   StringRef LibDir = GCCInstallation.getParentLibPath();
 849   StringRef InstallDir = GCCInstallation.getInstallPath();
 850   StringRef TripleStr = GCCInstallation.getTriple().str();
 851   const Multilib &Multilib = GCCInstallation.getMultilib();
 852   const std::string GCCMultiarchTriple = getMultiarchTriple(
 853       getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot);
 854   const std::string TargetMultiarchTriple =
 855       getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot);
 856   const GCCVersion &Version = GCCInstallation.getVersion();
 857
 858   // The primary search for libstdc++ supports multiarch variants.
 859   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
 860                                "/c++/" + Version.Text, TripleStr,
 861                                GCCMultiarchTriple, TargetMultiarchTriple,
 862                                Multilib.includeSuffix(), DriverArgs, CC1Args))
 863     return;
 864
 865   // Otherwise, fall back on a bunch of options which don't use multiarch
 866   // layouts for simplicity.
 867   const std::string LibStdCXXIncludePathCandidates[] = {
 868       // Gentoo is weird and places its headers inside the GCC install,
 869       // so if the first attempt to find the headers fails, try these patterns.
 870       InstallDir.str() + "/include/g++-v" + Version.Text,
 871       InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
 872           Version.MinorStr,
 873       InstallDir.str() + "/include/g++-v" + Version.MajorStr,
 874       // Android standalone toolchain has C++ headers in yet another place.
 875       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
 876       // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
 877       // without a subdirectory corresponding to the gcc version.
 878       LibDir.str() + "/../include/c++",
 879   };
 880
 881   for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
 882     if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
 883                                  /*GCCMultiarchTriple*/ "",
 884                                  /*TargetMultiarchTriple*/ "",
 885                                  Multilib.includeSuffix(), DriverArgs, CC1Args))
 886       break;
 887   }
 888 }
 889
 890 void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
 891                                ArgStringList &CC1Args) const {
 892   CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
 893 }
 894
 895 void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
 896                                 ArgStringList &CC1Args) const {
 897   if (GCCInstallation.isValid()) {
 898     CC1Args.push_back("-isystem");
 899     CC1Args.push_back(DriverArgs.MakeArgString(
 900         GCCInstallation.getParentLibPath() + "/../" +
 901         GCCInstallation.getTriple().str() + "/include"));
 902   }
 903 }
 904
 905 bool Linux::isPIEDefault() const {
 906   return (getTriple().isAndroid() && !getTriple().isAndroidVersionLT(16)) ||
 907           getTriple().isMusl() || getSanitizerArgs().requiresPIE();
 908 }
 909
 910 SanitizerMask Linux::getSupportedSanitizers() const {
 911   const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
 912   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
 913   const bool IsMIPS = getTriple().isMIPS32();
 914   const bool IsMIPS64 = getTriple().isMIPS64();
 915   const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
 916                            getTriple().getArch() == llvm::Triple::ppc64le;
 917   const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
 918                          getTriple().getArch() == llvm::Triple::aarch64_be;
 919   const bool IsArmArch = getTriple().getArch() == llvm::Triple::arm ||
 920                          getTriple().getArch() == llvm::Triple::thumb ||
 921                          getTriple().getArch() == llvm::Triple::armeb ||
 922                          getTriple().getArch() == llvm::Triple::thumbeb;
 923   SanitizerMask Res = ToolChain::getSupportedSanitizers();
 924   Res |= SanitizerKind::Address;
 925   Res |= SanitizerKind::Fuzzer;
 926   Res |= SanitizerKind::FuzzerNoLink;
 927   Res |= SanitizerKind::KernelAddress;
 928   Res |= SanitizerKind::Memory;
 929   Res |= SanitizerKind::Vptr;
 930   Res |= SanitizerKind::SafeStack;
 931   if (IsX86_64 || IsMIPS64 || IsAArch64)
 932     Res |= SanitizerKind::DataFlow;
 933   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64)
 934     Res |= SanitizerKind::Leak;
 935   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
 936     Res |= SanitizerKind::Thread;
 937   if (IsX86_64 || IsMIPS64)
 938     Res |= SanitizerKind::Efficiency;
 939   if (IsX86 || IsX86_64)
 940     Res |= SanitizerKind::Function;
 941   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||
 942       IsPowerPC64)
 943     Res |= SanitizerKind::Scudo;
 944   if (IsX86_64 || IsAArch64) {
 945     Res |= SanitizerKind::HWAddress;
 946     Res |= SanitizerKind::KernelHWAddress;
 947   }
 948   return Res;
 949 }
 950
 951 void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
 952                              llvm::opt::ArgStringList &CmdArgs) const {
 953   if (!needsProfileRT(Args)) return;
 954
 955   // Add linker option -u__llvm_runtime_variable to cause runtime
 956   // initialization module to be linked in.
 957   if (!Args.hasArg(options::OPT_coverage))
 958     CmdArgs.push_back(Args.MakeArgString(
 959         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
 960   ToolChain::addProfileRTLibs(Args, CmdArgs);
 961 }