//===--- Linux.h - Linux ToolChain Implementations --------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "Linux.h"

#include "Arch/ARM.h"

#include "Arch/Mips.h"

#include "Arch/PPC.h"

#include "Arch/RISCV.h"

#include "CommonArgs.h"

#include "clang/Config/config.h"

#include "clang/Driver/Distro.h"

#include "clang/Driver/Driver.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/SanitizerArgs.h"

#include "llvm/Option/ArgList.h"

#include "llvm/ProfileData/InstrProf.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/ScopedPrinter.h"

#include "llvm/Support/VirtualFileSystem.h"

#include <system_error>

using namespace clang::driver;

using namespace clang::driver::toolchains;

using namespace clang;

using namespace llvm::opt;

using tools::addPathIfExists;

/// Get our best guess at the multiarch triple for a target.

///

/// Debian-based systems are starting to use a multiarch setup where they use

/// a target-triple directory in the library and header search paths.

/// Unfortunately, this triple does not align with the vanilla target triple,

/// so we provide a rough mapping here.

std::string Linux::getMultiarchTriple(const Driver &D,

                                      const llvm::Triple &TargetTriple,

                                      StringRef SysRoot) const {

  llvm::Triple::EnvironmentType TargetEnvironment =

      TargetTriple.getEnvironment();

  bool IsAndroid = TargetTriple.isAndroid();

  bool IsMipsR6 = TargetTriple.getSubArch() == llvm::Triple::MipsSubArch_r6;

  bool IsMipsN32Abi = TargetTriple.getEnvironment() == llvm::Triple::GNUABIN32;

  // For most architectures, just use whatever we have rather than trying to be

  // clever.

  switch (TargetTriple.getArch()) {

  default:

    break;

  // We use the existence of '/lib/<triple>' as a directory to detect some

  // common linux triples that don't quite match the Clang triple for both

  // 32-bit and 64-bit targets. Multiarch fixes its install triples to these

  // regardless of what the actual target triple is.

  case llvm::Triple::arm:

  case llvm::Triple::thumb:

    if (IsAndroid) {

      return "arm-linux-androideabi";

    } else if (TargetEnvironment == llvm::Triple::GNUEABIHF) {

      if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabihf"))

        return "arm-linux-gnueabihf";

    } else {

      if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabi"))

        return "arm-linux-gnueabi";

    }

    break;

  case llvm::Triple::armeb:

  case llvm::Triple::thumbeb:

    if (TargetEnvironment == llvm::Triple::GNUEABIHF) {

      if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabihf"))

        return "armeb-linux-gnueabihf";

    } else {

      if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabi"))

        return "armeb-linux-gnueabi";

    }

    break;

  case llvm::Triple::x86:

    if (IsAndroid)

      return "i686-linux-android";

    if (D.getVFS().exists(SysRoot + "/lib/i386-linux-gnu"))

      return "i386-linux-gnu";

    break;

  case llvm::Triple::x86_64:

    if (IsAndroid)

      return "x86_64-linux-android";

    // We don't want this for x32, otherwise it will match x86_64 libs

    if (TargetEnvironment != llvm::Triple::GNUX32 &&

        
D.getVFS().exists(SysRoot + "/lib/x86_64-linux-gnu")2.48k
)

      return "x86_64-linux-gnu";

    break;

  case llvm::Triple::aarch64:

    if (IsAndroid)

      return "aarch64-linux-android";

    if (D.getVFS().exists(SysRoot + "/lib/aarch64-linux-gnu"))

      return "aarch64-linux-gnu";

    break;

  case llvm::Triple::aarch64_be:

    if (D.getVFS().exists(SysRoot + "/lib/aarch64_be-linux-gnu"))

      return "aarch64_be-linux-gnu";

    break;

  case llvm::Triple::mips: {

    std::string MT = IsMipsR6 ? 
"mipsisa32r6-linux-gnu"2
 : 
"mips-linux-gnu"758
;

    if (D.getVFS().exists(SysRoot + "/lib/" + MT))

      return MT;

    break;

  }

  case llvm::Triple::mipsel: {

    if (IsAndroid)

      return "mipsel-linux-android";

    std::string MT = IsMipsR6 ? 
"mipsisa32r6el-linux-gnu"2
 : 
"mipsel-linux-gnu"211
;

    if (D.getVFS().exists(SysRoot + "/lib/" + MT))

      return MT;

    break;

  }

  case llvm::Triple::mips64: {

    std::string MT = std::string(IsMipsR6 ? 
"mipsisa64r6"6
 : 
"mips64"229
) +

                     "-linux-" + (IsMipsN32Abi ? 
"gnuabin32"59
 : 
"gnuabi64"176
);

    if (D.getVFS().exists(SysRoot + "/lib/" + MT))

      return MT;

    if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))

      return "mips64-linux-gnu";

    break;

  }

  case llvm::Triple::mips64el: {

    if (IsAndroid)

      return "mips64el-linux-android";

    std::string MT = std::string(IsMipsR6 ? 
"mipsisa64r6el"6
 : 
"mips64el"157
) +

                     "-linux-" + (IsMipsN32Abi ? 
"gnuabin32"51
 : 
"gnuabi64"112
);

    if (D.getVFS().exists(SysRoot + "/lib/" + MT))

      return MT;

    if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))

      return "mips64el-linux-gnu";

    break;

  }

  case llvm::Triple::ppc:

    if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))

      return "powerpc-linux-gnuspe";

    if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnu"))

      return "powerpc-linux-gnu";

    break;

  case llvm::Triple::ppc64:

    if (D.getVFS().exists(SysRoot + "/lib/powerpc64-linux-gnu"))

      return "powerpc64-linux-gnu";

    break;

  case llvm::Triple::ppc64le:

    if (D.getVFS().exists(SysRoot + "/lib/powerpc64le-linux-gnu"))

      return "powerpc64le-linux-gnu";

    break;

  case llvm::Triple::sparc:

    if (D.getVFS().exists(SysRoot + "/lib/sparc-linux-gnu"))

      return "sparc-linux-gnu";

    break;

  case llvm::Triple::sparcv9:

    if (D.getVFS().exists(SysRoot + "/lib/sparc64-linux-gnu"))

      return "sparc64-linux-gnu";

    break;

  case llvm::Triple::systemz:

    if (D.getVFS().exists(SysRoot + "/lib/s390x-linux-gnu"))

      return "s390x-linux-gnu";

    break;

  }

  return TargetTriple.str();

}

static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {

  if (Triple.isMIPS()) {

    if (Triple.isAndroid()) {

      StringRef CPUName;

      StringRef ABIName;

      tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);

      if (CPUName == "mips32r6")

        return "libr6";

      if (CPUName == "mips32r2")

        return "libr2";

    }

    // lib32 directory has a special meaning on MIPS targets.

    // It contains N32 ABI binaries. Use this folder if produce

    // code for N32 ABI only.

    if (tools::mips::hasMipsAbiArg(Args, "n32"))

      return "lib32";

    return Triple.isArch32Bit() ? 
"lib"412
 : 
"lib64"144
;

  }

  // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and

  // using that variant while targeting other architectures causes problems

  // because the libraries are laid out in shared system roots that can't cope

  // with a 'lib32' library search path being considered. So we only enable

  // them when we know we may need it.

  //

  // FIXME: This is a bit of a hack. We should really unify this code for

  // reasoning about oslibdir spellings with the lib dir spellings in the

  // GCCInstallationDetector, but that is a more significant refactoring.

  if (Triple.getArch() == llvm::Triple::x86 ||

      
Triple.getArch() == llvm::Triple::ppc2.28k
)

    return "lib32";

  if (Triple.getArch() == llvm::Triple::x86_64 &&

      
Triple.getEnvironment() == llvm::Triple::GNUX32990
)

    return "libx32";

  if (Triple.getArch() == llvm::Triple::riscv32)

    return "lib32";

  return Triple.isArch32Bit() ? 
"lib"697
 : 
"lib64"1.52k
;

}

static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,

                                  const Multilib &Multilib,

                                  StringRef InstallPath,

                                  ToolChain::path_list &Paths) {

  if (const auto &PathsCallback = Multilibs.filePathsCallback())

    for (const auto &Path : PathsCallback(Multilib))

      addPathIfExists(D, InstallPath + Path, Paths);

}

Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)

    : Generic_ELF(D, Triple, Args) {

  GCCInstallation.init(Triple, Args);

  Multilibs = GCCInstallation.getMultilibs();

  SelectedMultilib = GCCInstallation.getMultilib();

  llvm::Triple::ArchType Arch = Triple.getArch();

  std::string SysRoot = computeSysRoot();

  // Cross-compiling binutils and GCC installations (vanilla and openSUSE at

  // least) put various tools in a triple-prefixed directory off of the parent

  // of the GCC installation. We use the GCC triple here to ensure that we end

  // up with tools that support the same amount of cross compiling as the

  // detected GCC installation. For example, if we find a GCC installation

  // targeting x86_64, but it is a bi-arch GCC installation, it can also be

  // used to target i386.

  // FIXME: This seems unlikely to be Linux-specific.

  ToolChain::path_list &PPaths = getProgramPaths();

  if (GCCInstallation.isValid()) {

    PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +

                           GCCInstallation.getTriple().str() + "/bin")

                         .str());

  }

  Distro Distro(D.getVFS(), Triple);

  if (Distro.IsAlpineLinux() || Triple.isAndroid()) {

    ExtraOpts.push_back("-z");

    ExtraOpts.push_back("now");

  }

  if (Distro.IsOpenSUSE() || Distro.IsUbuntu() || Distro.IsAlpineLinux() ||

      Triple.isAndroid()) {

    ExtraOpts.push_back("-z");

    ExtraOpts.push_back("relro");

  }

  // The lld default page size is too large for Aarch64, which produces much

  // larger .so files and images for arm64 device targets. Use 4KB page size

  // for Android arm64 targets instead.

  if (Triple.isAArch64() && 
Triple.isAndroid()181
) {

    ExtraOpts.push_back("-z");

    ExtraOpts.push_back("max-page-size=4096");

  }

  if (GCCInstallation.getParentLibPath().find("opt/rh/devtoolset") !=

      StringRef::npos)

    // With devtoolset on RHEL, we want to add a bin directory that is relative

    // to the detected gcc install, because if we are using devtoolset gcc then

    // we want to use other tools from devtoolset (e.g. ld) instead of the

    // standard system tools.

    PPaths.push_back(Twine(GCCInstallation.getParentLibPath() +

                     "/../bin").str());

  if (Arch == llvm::Triple::arm || 
Arch == llvm::Triple::thumb2.79k
)

    ExtraOpts.push_back("-X");

  const bool IsAndroid = Triple.isAndroid();

  const bool IsMips = Triple.isMIPS();

  const bool IsHexagon = Arch == llvm::Triple::hexagon;

  const bool IsRISCV = Triple.isRISCV();

  if (IsMips && 
!SysRoot.empty()597
)

    ExtraOpts.push_back("--sysroot=" + SysRoot);

  // Do not use 'gnu' hash style for Mips targets because .gnu.hash

  // and the MIPS ABI require .dynsym to be sorted in different ways.

  // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS

  // ABI requires a mapping between the GOT and the symbol table.

  // Android loader does not support .gnu.hash until API 23.

  // Hexagon linker/loader does not support .gnu.hash

  if (!IsMips && 
!IsHexagon2.71k
) {

    if (Distro.IsRedhat() || Distro.IsOpenSUSE() || Distro.IsAlpineLinux() ||

        (Distro.IsUbuntu() && 
Distro >= Distro::UbuntuMaverick0
) ||

        (IsAndroid && 
!Triple.isAndroidVersionLT(23)182
))

      ExtraOpts.push_back("--hash-style=gnu");

    if (Distro.IsDebian() || Distro.IsOpenSUSE() ||

        Distro == Distro::UbuntuLucid || Distro == Distro::UbuntuJaunty ||

        Distro == Distro::UbuntuKarmic ||

        (IsAndroid && 
Triple.isAndroidVersionLT(23)182
))

      ExtraOpts.push_back("--hash-style=both");

  }

#ifdef ENABLE_LINKER_BUILD_ID

  ExtraOpts.push_back("--build-id");

#endif

  if (IsAndroid || 
Distro.IsOpenSUSE()3.09k
)

    ExtraOpts.push_back("--enable-new-dtags");

  // The selection of paths to try here is designed to match the patterns which

  // the GCC driver itself uses, as this is part of the GCC-compatible driver.

  // This was determined by running GCC in a fake filesystem, creating all

  // possible permutations of these directories, and seeing which ones it added

  // to the link paths.

  path_list &Paths = getFilePaths();

  const std::string OSLibDir = std::string(getOSLibDir(Triple, Args));

  const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);

  // Add the multilib suffixed paths where they are available.

  if (GCCInstallation.isValid()) {

    const llvm::Triple &GCCTriple = GCCInstallation.getTriple();

    const std::string &LibPath =

        std::string(GCCInstallation.getParentLibPath());

    // Add toolchain / multilib specific file paths.

    addMultilibsFilePaths(D, Multilibs, SelectedMultilib,

                          GCCInstallation.getInstallPath(), Paths);

    // Sourcery CodeBench MIPS toolchain holds some libraries under

    // a biarch-like suffix of the GCC installation.

    addPathIfExists(

        D, GCCInstallation.getInstallPath() + SelectedMultilib.gccSuffix(),

        Paths);

    // GCC cross compiling toolchains will install target libraries which ship

    // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as

    // any part of the GCC installation in

    // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat

    // debatable, but is the reality today. We need to search this tree even

    // when we have a sysroot somewhere else. It is the responsibility of

    // whomever is doing the cross build targeting a sysroot using a GCC

    // installation that is *not* within the system root to ensure two things:

    //

    //  1) Any DSOs that are linked in from this tree or from the install path

    //     above must be present on the system root and found via an

    //     appropriate rpath.

    //  2) There must not be libraries installed into

    //     <prefix>/<triple>/<libdir> unless they should be preferred over

    //     those within the system root.

    //

    // Note that this matches the GCC behavior. See the below comment for where

    // Clang diverges from GCC's behavior.

    addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +

                           OSLibDir + SelectedMultilib.osSuffix(),

                    Paths);

    // If the GCC installation we found is inside of the sysroot, we want to

    // prefer libraries installed in the parent prefix of the GCC installation.

    // It is important to *not* use these paths when the GCC installation is

    // outside of the system root as that can pick up unintended libraries.

    // This usually happens when there is an external cross compiler on the

    // host system, and a more minimal sysroot available that is the target of

    // the cross. Note that GCC does include some of these directories in some

    // configurations but this seems somewhere between questionable and simply

    // a bug.

    if (StringRef(LibPath).startswith(SysRoot)) {

      addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);

      addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);

    }

  }

  // Similar to the logic for GCC above, if we currently running Clang inside

  // of the requested system root, add its parent library paths to

  // those searched.

  // FIXME: It's not clear whether we should use the driver's installed

  // directory ('Dir' below) or the ResourceDir.

  if (StringRef(D.Dir).startswith(SysRoot)) {

    addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);

    addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);

  }

  addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);

  addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);

  if (IsAndroid) {

    // Android sysroots contain a library directory for each supported OS

    // version as well as some unversioned libraries in the usual multiarch

    // directory.

    unsigned Major;

    unsigned Minor;

    unsigned Micro;

    Triple.getEnvironmentVersion(Major, Minor, Micro);

    addPathIfExists(D,

                    SysRoot + "/usr/lib/" + MultiarchTriple + "/" +

                        llvm::to_string(Major),

                    Paths);

  }

  addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);

  // 64-bit OpenEmbedded sysroots may not have a /usr/lib dir. So they cannot

  // find /usr/lib64 as it is referenced as /usr/lib/../lib64. So we handle

  // this here.

  if (Triple.getVendor() == llvm::Triple::OpenEmbedded &&

      
Triple.isArch64Bit()4
)

    addPathIfExists(D, SysRoot + "/usr/" + OSLibDir, Paths);

  else

    addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);

  if (IsRISCV) {

    StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);

    addPathIfExists(D, SysRoot + "/" + OSLibDir + "/" + ABIName, Paths);

    addPathIfExists(D, SysRoot + "/usr/" + OSLibDir + "/" + ABIName, Paths);

  }

  // Try walking via the GCC triple path in case of biarch or multiarch GCC

  // installations with strange symlinks.

  if (GCCInstallation.isValid()) {

    addPathIfExists(D,

                    SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +

                        "/../../" + OSLibDir,

                    Paths);

    // Add the 'other' biarch variant path

    Multilib BiarchSibling;

    if (GCCInstallation.getBiarchSibling(BiarchSibling)) {

      addPathIfExists(D, GCCInstallation.getInstallPath() +

                             BiarchSibling.gccSuffix(),

                      Paths);

    }

    // See comments above on the multilib variant for details of why this is

    // included even from outside the sysroot.

    const std::string &LibPath =

        std::string(GCCInstallation.getParentLibPath());

    const llvm::Triple &GCCTriple = GCCInstallation.getTriple();

    const Multilib &Multilib = GCCInstallation.getMultilib();

    addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +

                           Multilib.osSuffix(),

                    Paths);

    // See comments above on the multilib variant for details of why this is

    // only included from within the sysroot.

    if (StringRef(LibPath).startswith(SysRoot))

      addPathIfExists(D, LibPath, Paths);

  }

  // Similar to the logic for GCC above, if we are currently running Clang

  // inside of the requested system root, add its parent library path to those

  // searched.

  // FIXME: It's not clear whether we should use the driver's installed

  // directory ('Dir' below) or the ResourceDir.

  if (StringRef(D.Dir).startswith(SysRoot))

    addPathIfExists(D, D.Dir + "/../lib", Paths);

  addPathIfExists(D, SysRoot + "/lib", Paths);

  addPathIfExists(D, SysRoot + "/usr/lib", Paths);

}

ToolChain::CXXStdlibType Linux::GetDefaultCXXStdlibType() const {

  if (getTriple().isAndroid())

    return ToolChain::CST_Libcxx;

  return ToolChain::CST_Libstdcxx;

}

bool Linux::HasNativeLLVMSupport() const { return true; }

Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }

Tool *Linux::buildAssembler() const {

  return new tools::gnutools::Assembler(*this);

}

std::string Linux::computeSysRoot() const {

  if (!getDriver().SysRoot.empty())

    return getDriver().SysRoot;

  if (getTriple().isAndroid()) {

    // Android toolchains typically include a sysroot at ../sysroot relative to

    // the clang binary.

    const StringRef ClangDir = getDriver().getInstalledDir();

    std::string AndroidSysRootPath = (ClangDir + "/../sysroot").str();

    if (getVFS().exists(AndroidSysRootPath))

      return AndroidSysRootPath;

  }

  if (!GCCInstallation.isValid() || 
!getTriple().isMIPS()353
)

    return std::string();

  // Standalone MIPS toolchains use different names for sysroot folder

  // and put it into different places. Here we try to check some known

  // variants.

  const StringRef InstallDir = GCCInstallation.getInstallPath();

  const StringRef TripleStr = GCCInstallation.getTriple().str();

  const Multilib &Multilib = GCCInstallation.getMultilib();

  std::string Path =

      (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())

          .str();

  if (getVFS().exists(Path))

    return Path;

  Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();

  if (getVFS().exists(Path))

    return Path;

  return std::string();

}

std::string Linux::getDynamicLinker(const ArgList &Args) const {

  const llvm::Triple::ArchType Arch = getArch();

  const llvm::Triple &Triple = getTriple();

  const Distro Distro(getDriver().getVFS(), Triple);

  if (Triple.isAndroid())

    return Triple.isArch64Bit() ? 
"/system/bin/linker64"46
 : 
"/system/bin/linker"85
;

  if (Triple.isMusl()) {

    std::string ArchName;

    bool IsArm = false;

    switch (Arch) {

    case llvm::Triple::arm:

    case llvm::Triple::thumb:

      ArchName = "arm";

      IsArm = true;

      break;

    case llvm::Triple::armeb:

    case llvm::Triple::thumbeb:

      ArchName = "armeb";

      IsArm = true;

      break;

    default:

      ArchName = Triple.getArchName().str();

    }

    if (IsArm &&

        
(13
Triple.getEnvironment() == llvm::Triple::MuslEABIHF13
 ||

         
tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard8
))

      ArchName += "hf";

    return "/lib/ld-musl-" + ArchName + ".so.1";

  }

  std::string LibDir;

  std::string Loader;

  switch (Arch) {

  default:

    llvm_unreachable("unsupported architecture");

  case llvm::Triple::aarch64:

    LibDir = "lib";

    Loader = "ld-linux-aarch64.so.1";

    break;

  case llvm::Triple::aarch64_be:

    LibDir = "lib";

    Loader = "ld-linux-aarch64_be.so.1";

    break;

  case llvm::Triple::arm:

  case llvm::Triple::thumb:

  case llvm::Triple::armeb:

  case llvm::Triple::thumbeb: {

    const bool HF =

        Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||

        
tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard94
;

    LibDir = "lib";

    Loader = HF ? 
"ld-linux-armhf.so.3"17
 : 
"ld-linux.so.3"92
;

    break;

  }

  case llvm::Triple::mips:

  case llvm::Triple::mipsel:

  case llvm::Triple::mips64:

  case llvm::Triple::mips64el: {

    bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);

    LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);

    if (tools::mips::isUCLibc(Args))

      Loader = IsNaN2008 ? 
"ld-uClibc-mipsn8.so.0"6
 : 
"ld-uClibc.so.0"10
;

    else if (!Triple.hasEnvironment() &&

             
Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies5
)

      Loader =

          Triple.isLittleEndian() ? 
"ld-musl-mipsel.so.1"1
 : 
"ld-musl-mips.so.1"1
;

    else

      Loader = IsNaN2008 ? 
"ld-linux-mipsn8.so.1"68
 : 
"ld.so.1"121
;

    break;

  }

  case llvm::Triple::ppc:

    LibDir = "lib";

    Loader = "ld.so.1";

    break;

  case llvm::Triple::ppc64:

    LibDir = "lib64";

    Loader =

        (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? 
"ld64.so.2"3
 : 
"ld64.so.1"67
;

    break;

  case llvm::Triple::ppc64le:

    LibDir = "lib64";

    Loader =

        (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? 
"ld64.so.1"4
 : 
"ld64.so.2"40
;

    break;

  case llvm::Triple::riscv32: {

    StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);

    LibDir = "lib";

    Loader = ("ld-linux-riscv32-" + ABIName + ".so.1").str();

    break;

  }

  case llvm::Triple::riscv64: {

    StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);

    LibDir = "lib";

    Loader = ("ld-linux-riscv64-" + ABIName + ".so.1").str();

    break;

  }

  case llvm::Triple::sparc:

  case llvm::Triple::sparcel:

    LibDir = "lib";

    Loader = "ld-linux.so.2";

    break;

  case llvm::Triple::sparcv9:

    LibDir = "lib64";

    Loader = "ld-linux.so.2";

    break;

  case llvm::Triple::systemz:

    LibDir = "lib";

    Loader = "ld64.so.1";

    break;

  case llvm::Triple::x86:

    LibDir = "lib";

    Loader = "ld-linux.so.2";

    break;

  case llvm::Triple::x86_64: {

    bool X32 = Triple.getEnvironment() == llvm::Triple::GNUX32;

    LibDir = X32 ? 
"libx32"8
 : 
"lib64"429
;

    Loader = X32 ? 
"ld-linux-x32.so.2"8
 : 
"ld-linux-x86-64.so.2"429
;

    break;

  }

  }

  if (Distro == Distro::Exherbo &&

      
(0
Triple.getVendor() == llvm::Triple::UnknownVendor0
 ||

       Triple.getVendor() == llvm::Triple::PC))

    return "/usr/" + Triple.str() + "/lib/" + Loader;

  return "/" + LibDir + "/" + Loader;

}

void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,

                                      ArgStringList &CC1Args) const {

  const Driver &D = getDriver();

  std::string SysRoot = computeSysRoot();

  if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))

    return;

  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))

    addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");

  SmallString<128> ResourceDirInclude(D.ResourceDir);

  llvm::sys::path::append(ResourceDirInclude, "include");

  if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&

      
(3.60k
!getTriple().isMusl()3.60k
 || 
DriverArgs.hasArg(options::OPT_nostdlibinc)40
))

    addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);

  if (DriverArgs.hasArg(options::OPT_nostdlibinc))

    return;

  // Check for configure-time C include directories.

  StringRef CIncludeDirs(C_INCLUDE_DIRS);

  if (CIncludeDirs != "") {

    SmallVector<StringRef, 5> dirs;

    CIncludeDirs.split(dirs, ":");

    for (StringRef dir : dirs) {

      StringRef Prefix =

          llvm::sys::path::is_absolute(dir) ? "" : StringRef(SysRoot);

      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);

    }

    return;

  }

  // Lacking those, try to detect the correct set of system includes for the

  // target triple.

  // Add include directories specific to the selected multilib set and multilib.

  if (GCCInstallation.isValid()) {

    const auto &Callback = Multilibs.includeDirsCallback();

    if (Callback) {

      for (const auto &Path : Callback(GCCInstallation.getMultilib()))

        addExternCSystemIncludeIfExists(

            DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);

    }

  }

  // Implement generic Debian multiarch support.

  const StringRef X86_64MultiarchIncludeDirs[] = {

      "/usr/include/x86_64-linux-gnu",

      // FIXME: These are older forms of multiarch. It's not clear that they're

      // in use in any released version of Debian, so we should consider

      // removing them.

      "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"};

  const StringRef X86MultiarchIncludeDirs[] = {

      "/usr/include/i386-linux-gnu",

      // FIXME: These are older forms of multiarch. It's not clear that they're

      // in use in any released version of Debian, so we should consider

      // removing them.

      "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",

      "/usr/include/i486-linux-gnu"};

  const StringRef AArch64MultiarchIncludeDirs[] = {

      "/usr/include/aarch64-linux-gnu"};

  const StringRef ARMMultiarchIncludeDirs[] = {

      "/usr/include/arm-linux-gnueabi"};

  const StringRef ARMHFMultiarchIncludeDirs[] = {

      "/usr/include/arm-linux-gnueabihf"};

  const StringRef ARMEBMultiarchIncludeDirs[] = {

      "/usr/include/armeb-linux-gnueabi"};

  const StringRef ARMEBHFMultiarchIncludeDirs[] = {

      "/usr/include/armeb-linux-gnueabihf"};

  const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"};

  const StringRef MIPSELMultiarchIncludeDirs[] = {

      "/usr/include/mipsel-linux-gnu"};

  const StringRef MIPS64MultiarchIncludeDirs[] = {

      "/usr/include/mips64-linux-gnuabi64"};

  const StringRef MIPS64ELMultiarchIncludeDirs[] = {

      "/usr/include/mips64el-linux-gnuabi64"};

  const StringRef MIPSN32MultiarchIncludeDirs[] = {

      "/usr/include/mips64-linux-gnuabin32"};

  const StringRef MIPSN32ELMultiarchIncludeDirs[] = {

      "/usr/include/mips64el-linux-gnuabin32"};

  const StringRef MIPSR6MultiarchIncludeDirs[] = {

      "/usr/include/mipsisa32-linux-gnu"};

  const StringRef MIPSR6ELMultiarchIncludeDirs[] = {

      "/usr/include/mipsisa32r6el-linux-gnu"};

  const StringRef MIPS64R6MultiarchIncludeDirs[] = {

      "/usr/include/mipsisa64r6-linux-gnuabi64"};

  const StringRef MIPS64R6ELMultiarchIncludeDirs[] = {

      "/usr/include/mipsisa64r6el-linux-gnuabi64"};

  const StringRef MIPSN32R6MultiarchIncludeDirs[] = {

      "/usr/include/mipsisa64r6-linux-gnuabin32"};

  const StringRef MIPSN32R6ELMultiarchIncludeDirs[] = {

      "/usr/include/mipsisa64r6el-linux-gnuabin32"};

  const StringRef PPCMultiarchIncludeDirs[] = {

      "/usr/include/powerpc-linux-gnu",

      "/usr/include/powerpc-linux-gnuspe"};

  const StringRef PPC64MultiarchIncludeDirs[] = {

      "/usr/include/powerpc64-linux-gnu"};

  const StringRef PPC64LEMultiarchIncludeDirs[] = {

      "/usr/include/powerpc64le-linux-gnu"};

  const StringRef SparcMultiarchIncludeDirs[] = {

      "/usr/include/sparc-linux-gnu"};

  const StringRef Sparc64MultiarchIncludeDirs[] = {

      "/usr/include/sparc64-linux-gnu"};

  const StringRef SYSTEMZMultiarchIncludeDirs[] = {

      "/usr/include/s390x-linux-gnu"};

  ArrayRef<StringRef> MultiarchIncludeDirs;

  switch (getTriple().getArch()) {

  case llvm::Triple::x86_64:

    MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;

    break;

  case llvm::Triple::x86:

    MultiarchIncludeDirs = X86MultiarchIncludeDirs;

    break;

  case llvm::Triple::aarch64:

  case llvm::Triple::aarch64_be:

    MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;

    break;

  case llvm::Triple::arm:

  case llvm::Triple::thumb:

    if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)

      MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;

    else

      MultiarchIncludeDirs = ARMMultiarchIncludeDirs;

    break;

  case llvm::Triple::armeb:

  case llvm::Triple::thumbeb:

    if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)

      MultiarchIncludeDirs = ARMEBHFMultiarchIncludeDirs;

    else

      MultiarchIncludeDirs = ARMEBMultiarchIncludeDirs;

    break;

  case llvm::Triple::mips:

    if (getTriple().getSubArch() == llvm::Triple::MipsSubArch_r6)

      MultiarchIncludeDirs = MIPSR6MultiarchIncludeDirs;

    else

      MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;

    break;

  case llvm::Triple::mipsel:

    if (getTriple().getSubArch() == llvm::Triple::MipsSubArch_r6)

      MultiarchIncludeDirs = MIPSR6ELMultiarchIncludeDirs;

    else

      MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;

    break;

  case llvm::Triple::mips64:

    if (getTriple().getSubArch() == llvm::Triple::MipsSubArch_r6)

      if (getTriple().getEnvironment() == llvm::Triple::GNUABIN32)

        MultiarchIncludeDirs = MIPSN32R6MultiarchIncludeDirs;

      else

        MultiarchIncludeDirs = MIPS64R6MultiarchIncludeDirs;

    else if (getTriple().getEnvironment() == llvm::Triple::GNUABIN32)

      MultiarchIncludeDirs = MIPSN32MultiarchIncludeDirs;

    else

      MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;

    break;

  case llvm::Triple::mips64el:

    if (getTriple().getSubArch() == llvm::Triple::MipsSubArch_r6)

      if (getTriple().getEnvironment() == llvm::Triple::GNUABIN32)

        MultiarchIncludeDirs = MIPSN32R6ELMultiarchIncludeDirs;

      else

        MultiarchIncludeDirs = MIPS64R6ELMultiarchIncludeDirs;

    else if (getTriple().getEnvironment() == llvm::Triple::GNUABIN32)

      MultiarchIncludeDirs = MIPSN32ELMultiarchIncludeDirs;

    else

      MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;

    break;

  case llvm::Triple::ppc:

    MultiarchIncludeDirs = PPCMultiarchIncludeDirs;

    break;

  case llvm::Triple::ppc64:

    MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;

    break;

  case llvm::Triple::ppc64le:

    MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;

    break;

  case llvm::Triple::sparc:

    MultiarchIncludeDirs = SparcMultiarchIncludeDirs;

    break;

  case llvm::Triple::sparcv9:

    MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;

    break;

  case llvm::Triple::systemz:

    MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;

    break;

  default:

    break;

  }

  const std::string AndroidMultiarchIncludeDir =

      std::string("/usr/include/") +

      getMultiarchTriple(D, getTriple(), SysRoot);

  const StringRef AndroidMultiarchIncludeDirs[] = {AndroidMultiarchIncludeDir};

  if (getTriple().isAndroid())

    MultiarchIncludeDirs = AndroidMultiarchIncludeDirs;

  for (StringRef Dir : MultiarchIncludeDirs) {

    if (D.getVFS().exists(SysRoot + Dir)) {

      addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);

      break;

    }

  }

  if (getTriple().getOS() == llvm::Triple::RTEMS)

    return;

  // Add an include of '/include' directly. This isn't provided by default by

  // system GCCs, but is often used with cross-compiling GCCs, and harmless to

  // add even when Clang is acting as-if it were a system compiler.

  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");

  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");

  if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && 
getTriple().isMusl()3.60k
)

    addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);

}

void Linux::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,

                                     llvm::opt::ArgStringList &CC1Args) const {

  // Try generic GCC detection first.

  if (Generic_GCC::addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args))

    return;

  // We need a detected GCC installation on Linux to provide libstdc++'s

  // headers in odd Linuxish places.

  if (!GCCInstallation.isValid())

    return;

  StringRef LibDir = GCCInstallation.getParentLibPath();

  StringRef TripleStr = GCCInstallation.getTriple().str();

  const Multilib &Multilib = GCCInstallation.getMultilib();

  const GCCVersion &Version = GCCInstallation.getVersion();

  const std::string LibStdCXXIncludePathCandidates[] = {

      // Android standalone toolchain has C++ headers in yet another place.

      LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,

      // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,

      // without a subdirectory corresponding to the gcc version.

      LibDir.str() + "/../include/c++",

      // Cray's gcc installation puts headers under "g++" without a

      // version suffix.

      LibDir.str() + "/../include/g++",

  };

  for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {

    if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,

                                 /*GCCMultiarchTriple*/ "",

                                 /*TargetMultiarchTriple*/ "",

                                 Multilib.includeSuffix(), DriverArgs, CC1Args))

      break;

  }

}

void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,

                               ArgStringList &CC1Args) const {

  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);

}

void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,

                                ArgStringList &CC1Args) const {

  if (GCCInstallation.isValid()) {

    CC1Args.push_back("-isystem");

    CC1Args.push_back(DriverArgs.MakeArgString(

        GCCInstallation.getParentLibPath() + "/../" +

        GCCInstallation.getTriple().str() + "/include"));

  }

}

bool Linux::isPIEDefault() const {

  return (getTriple().isAndroid() && 
!getTriple().isAndroidVersionLT(16)356
) ||

          
getTriple().isMusl()5.08k
 || 
getSanitizerArgs().requiresPIE()5.01k
;

}

bool Linux::isNoExecStackDefault() const {

    return getTriple().isAndroid();

}

bool Linux::IsMathErrnoDefault() const {

  if (getTriple().isAndroid())

    return false;

  return Generic_ELF::IsMathErrnoDefault();

}

SanitizerMask Linux::getSupportedSanitizers() const {

  const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;

  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;

  const bool IsMIPS = getTriple().isMIPS32();

  const bool IsMIPS64 = getTriple().isMIPS64();

  const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||

                           
getTriple().getArch() == llvm::Triple::ppc64le3.25k
;

  const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||

                         
getTriple().getArch() == llvm::Triple::aarch64_be3.20k
;

  const bool IsArmArch = getTriple().getArch() == llvm::Triple::arm ||

                         
getTriple().getArch() == llvm::Triple::thumb2.86k
 ||

                         
getTriple().getArch() == llvm::Triple::armeb2.84k
 ||

                         
getTriple().getArch() == llvm::Triple::thumbeb2.80k
;

  SanitizerMask Res = ToolChain::getSupportedSanitizers();

  Res |= SanitizerKind::Address;

  Res |= SanitizerKind::PointerCompare;

  Res |= SanitizerKind::PointerSubtract;

  Res |= SanitizerKind::Fuzzer;

  Res |= SanitizerKind::FuzzerNoLink;

  Res |= SanitizerKind::KernelAddress;

  Res |= SanitizerKind::Memory;

  Res |= SanitizerKind::Vptr;

  Res |= SanitizerKind::SafeStack;

  if (IsX86_64 || 
IsMIPS642.26k
 || 
IsAArch642.08k
)

    Res |= SanitizerKind::DataFlow;

  if (IsX86_64 || 
IsMIPS642.26k
 || 
IsAArch642.08k
 || 
IsX861.90k
 || 
IsArmArch1.48k
 || 
IsPowerPC64906
)

    Res |= SanitizerKind::Leak;

  if (IsX86_64 || 
IsMIPS642.26k
 || 
IsAArch642.08k
 || 
IsPowerPC641.90k
)

    Res |= SanitizerKind::Thread;

  if (IsX86_64)

    Res |= SanitizerKind::KernelMemory;

  if (IsX86 || 
IsX86_642.95k
)

    Res |= SanitizerKind::Function;

  if (IsX86_64 || 
IsMIPS642.26k
 || 
IsAArch642.08k
 || 
IsX861.90k
 || 
IsMIPS1.48k
 || 
IsArmArch1.07k
 ||

      
IsPowerPC64491
)

    Res |= SanitizerKind::Scudo;

  if (IsX86_64 || 
IsAArch642.26k
) {

    Res |= SanitizerKind::HWAddress;

    Res |= SanitizerKind::KernelHWAddress;

  }

  return Res;

}

void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,