//===--- 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/LoongArch.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";

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

      return "arm-linux-gnueabihf";

    return "arm-linux-gnueabi";

  case llvm::Triple::armeb:

  case llvm::Triple::thumbeb:

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

      return "armeb-linux-gnueabihf";

    return "armeb-linux-gnueabi";

  case llvm::Triple::x86:

    if (IsAndroid)

      return "i686-linux-android";

    return "i386-linux-gnu";

  case llvm::Triple::x86_64:

    if (IsAndroid)

      return "x86_64-linux-android";

    if (TargetEnvironment == llvm::Triple::GNUX32)

      return "x86_64-linux-gnux32";

    return "x86_64-linux-gnu";

  case llvm::Triple::aarch64:

    if (IsAndroid)

      return "aarch64-linux-android";

    return "aarch64-linux-gnu";

  case llvm::Triple::aarch64_be:

    return "aarch64_be-linux-gnu";

  case llvm::Triple::loongarch64: {

    const char *Libc;

    const char *FPFlavor;

    if (TargetTriple.isGNUEnvironment()) {

      Libc = "gnu";

    } else 
if (0
TargetTriple.isMusl()0
) {

      Libc = "musl";

    } else {

      return TargetTriple.str();

    }

    switch (TargetEnvironment) {

    default:

      return TargetTriple.str();

    case llvm::Triple::GNUSF:

      FPFlavor = "sf";

      break;

    case llvm::Triple::GNUF32:

      FPFlavor = "f32";

      break;

    case llvm::Triple::GNU:

    case llvm::Triple::GNUF64:

      // This was going to be "f64" in an earlier Toolchain Conventions

      // revision, but starting from Feb 2023 the F64 ABI variants are

      // unmarked in their canonical forms.

      FPFlavor = "";

      break;

    }

    return (Twine("loongarch64-linux-") + Libc + FPFlavor).str();

  }

  case llvm::Triple::m68k:

    return "m68k-linux-gnu";

  case llvm::Triple::mips:

    return IsMipsR6 ? 
"mipsisa32r6-linux-gnu"2
 : 
"mips-linux-gnu"416
;

  case llvm::Triple::mipsel:

    return IsMipsR6 ? 
"mipsisa32r6el-linux-gnu"2
 : 
"mipsel-linux-gnu"60
;

  case llvm::Triple::mips64: {

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

                     "-linux-" + (IsMipsN32Abi ? 
"gnuabin32"18
 : 
"gnuabi64"88
);

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

      return MT;

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

      return "mips64-linux-gnu";

    break;

  }

  case llvm::Triple::mips64el: {

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

                     "-linux-" + (IsMipsN32Abi ? 
"gnuabin32"12
 : 
"gnuabi64"58
);

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

      return MT;

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

      return "mips64el-linux-gnu";

    break;

  }

  case llvm::Triple::ppc:

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

      return "powerpc-linux-gnuspe";

    return "powerpc-linux-gnu";

  case llvm::Triple::ppcle:

    return "powerpcle-linux-gnu";

  case llvm::Triple::ppc64:

    return "powerpc64-linux-gnu";

  case llvm::Triple::ppc64le:

    return "powerpc64le-linux-gnu";

  case llvm::Triple::riscv64:

    if (IsAndroid)

      return "riscv64-linux-android";

    return "riscv64-linux-gnu";

  case llvm::Triple::sparc:

    return "sparc-linux-gnu";

  case llvm::Triple::sparcv9:

    return "sparc64-linux-gnu";

  case llvm::Triple::systemz:

    return "s390x-linux-gnu";

  }

  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"281
 : 
"lib64"82
;

  }

  // It happens that only x86, PPC and SPARC 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.isPPC32()4.56k
 ||

      
Triple.getArch() == llvm::Triple::sparc4.53k
)

    return "lib32";

  if (Triple.getArch() == llvm::Triple::x86_64 && 
Triple.isX32()2.54k
)

    return "libx32";

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

    return "lib32";

  return Triple.isArch32Bit() ? 
"lib"908
 : 
"lib64"3.47k
;

}

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

    : Generic_ELF(D, Triple, Args) {

  GCCInstallation.init(Triple, Args);

  Multilibs = GCCInstallation.getMultilibs();

  SelectedMultilibs.assign({GCCInstallation.getMultilib()});

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

  std::string SysRoot = computeSysRoot();

  ToolChain::path_list &PPaths = getProgramPaths();

  Generic_GCC::PushPPaths(PPaths);

  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");

  }

  // Android ARM/AArch64 use max-page-size=4096 to reduce VMA usage. Note, lld

  // from 11 onwards default max-page-size to 65536 for both ARM and AArch64.

  if ((Triple.isARM() || 
Triple.isAArch64()4.71k
) && 
Triple.isAndroid()1.14k
) {

    ExtraOpts.push_back("-z");

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

  }

  if (GCCInstallation.getParentLibPath().contains("opt/rh/"))

    // 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::thumb4.75k
)

    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();

  const bool IsCSKY = Triple.isCSKY();

  if (IsCSKY && 
!SelectedMultilibs.empty()15
)

    SysRoot = SysRoot + SelectedMultilibs.back().osSuffix();

  if ((IsMips || 
IsCSKY5.00k
) && 
!SysRoot.empty()389
)

    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 && 
!IsHexagon5.00k
) {

    if (Distro.IsOpenSUSE() || Distro == Distro::UbuntuLucid ||

        Distro == Distro::UbuntuJaunty || Distro == Distro::UbuntuKarmic ||

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

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

    else

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

  }

#ifdef ENABLE_LINKER_BUILD_ID

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

#endif

  // 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);

  // mips32: Debian multilib, we use /libo32, while in other case, /lib is

  // used. We need add both libo32 and /lib.

  if (Arch == llvm::Triple::mips || 
Arch == llvm::Triple::mipsel5.13k
) {

    Generic_GCC::AddMultilibPaths(D, SysRoot, "libo32", MultiarchTriple, Paths);

    addPathIfExists(D, concat(SysRoot, "/libo32"), Paths);

    addPathIfExists(D, concat(SysRoot, "/usr/libo32"), Paths);

  }

  Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths);

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

  addPathIfExists(D, concat(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.

    addPathIfExists(

        D,

        concat(SysRoot, "/usr/lib", MultiarchTriple,

               llvm::to_string(Triple.getEnvironmentVersion().getMajor())),

        Paths);

  }

  addPathIfExists(D, concat(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, concat(SysRoot, "/usr", OSLibDir), Paths);

  else

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

  if (IsRISCV) {

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

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

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

  }

  Generic_GCC::AddMultiarchPaths(D, SysRoot, OSLibDir, Paths);

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

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

}

ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const {

  if (getTriple().isAndroid())

    return ToolChain::RLT_CompilerRT;

  return Generic_ELF::GetDefaultRuntimeLibType();

}

unsigned Linux::GetDefaultDwarfVersion() const {

  if (getTriple().isAndroid())

    return 4;

  return ToolChain::GetDefaultDwarfVersion();

}

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::buildStaticLibTool() const {

  return new tools::gnutools::StaticLibTool(*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 (getTriple().isCSKY()) {

    // CSKY toolchains use different names for sysroot folder.

    if (!GCCInstallation.isValid())

      return std::string();

    // GCCInstallation.getInstallPath() =

    //   $GCCToolchainPath/lib/gcc/csky-linux-gnuabiv2/6.3.0

    // Path = $GCCToolchainPath/csky-linux-gnuabiv2/libc

    std::string Path = (GCCInstallation.getInstallPath() + "/../../../../" +

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

                           .str();

    if (getVFS().exists(Path))

      return Path;

    return std::string();

  }

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

    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()) {

    if (getSanitizerArgs(Args).needsHwasanRt() &&

        
!Triple.isAndroidVersionLT(34)3
 && 
Triple.isArch64Bit()1
) {

      // On Android 14 and newer, there is a special linker_hwasan64 that

      // allows to run HWASan binaries on non-HWASan system images. This

      // is also available on HWASan system images, so we can just always

      // use that instead.

      return "/system/bin/linker_hwasan64";

    }

    return Triple.isArch64Bit() ? 
"/system/bin/linker64"52
 : 
"/system/bin/linker"65
;

  }

  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;

    case llvm::Triple::x86:

      ArchName = "i386";

      break;

    case llvm::Triple::x86_64:

      ArchName = Triple.isX32() ? 
"x32"2
 : 
Triple.getArchName().str()4
;

      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";

    if (Arch == llvm::Triple::ppc &&

        
Triple.getSubArch() == llvm::Triple::PPCSubArch_spe2
)

      ArchName = "powerpc-sf";

    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::Hard123
;

    LibDir = "lib";

    Loader = HF ? 
"ld-linux-armhf.so.3"20
 : 
"ld-linux.so.3"121
;

    break;

  }

  case llvm::Triple::loongarch32: {

    LibDir = "lib32";

    Loader =

        ("ld-linux-loongarch-" +

         tools::loongarch::getLoongArchABI(getDriver(), Args, Triple) + ".so.1")

            .str();

    break;

  }

  case llvm::Triple::loongarch64: {

    LibDir = "lib64";

    Loader =

        ("ld-linux-loongarch-" +

         tools::loongarch::getLoongArchABI(getDriver(), Args, Triple) + ".so.1")

            .str();

    break;

  }

  case llvm::Triple::m68k:

    LibDir = "lib";

    Loader = "ld.so.1";

    break;

  case llvm::Triple::mips:

  case llvm::Triple::mipsel:

  case llvm::Triple::mips64:

  case llvm::Triple::mips64el: {

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

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

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

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

    else if (!Triple.hasEnvironment() &&

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

      Loader =

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

    else

      Loader = IsNaN2008 ? 
"ld-linux-mipsn8.so.1"8
 : 
"ld.so.1"39
;

    break;

  }

  case llvm::Triple::ppc:

    LibDir = "lib";

    Loader = "ld.so.1";

    break;

  case llvm::Triple::ppcle:

    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"47
;

    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.isX32();

    LibDir = X32 ? 
"libx32"11
 : 
"lib64"699
;

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

    break;

  }

  case llvm::Triple::ve:

    return "/opt/nec/ve/lib/ld-linux-ve.so.1";

  case llvm::Triple::csky: {

    LibDir = "lib";

    Loader = "ld.so.1";

    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;

  // Add 'include' in the resource directory, which is similar to

  // GCC_INCLUDE_DIR (private headers) in GCC. Note: the include directory

  // contains some files conflicting with system /usr/include. musl systems

  // prefer the /usr/include copies which are more relevant.

  SmallString<128> ResourceDirInclude(D.ResourceDir);

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

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

      
(5.77k
!getTriple().isMusl()5.77k
 || 
DriverArgs.hasArg(options::OPT_nostdlibinc)45
))

    addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);

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

    return;

  // LOCAL_INCLUDE_DIR

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

  // TOOL_INCLUDE_DIR

  AddMultilibIncludeArgs(DriverArgs, CC1Args);

  // 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;

  }

  // On systems using multiarch and Android, add /usr/include/$triple before

  // /usr/include.

  std::string MultiarchIncludeDir = getMultiarchTriple(D, getTriple(), SysRoot);

  if (!MultiarchIncludeDir.empty() &&

      D.getVFS().exists(concat(SysRoot, "/usr/include", MultiarchIncludeDir)))

    addExternCSystemInclude(

        DriverArgs, CC1Args,

        concat(SysRoot, "/usr/include", MultiarchIncludeDir));

  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, concat(SysRoot, "/include"));

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

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

    addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);

}

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

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

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

  // headers in odd Linuxish places.

  if (!GCCInstallation.isValid())

    return;

  // Detect Debian g++-multiarch-incdir.diff.

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

  StringRef DebianMultiarch =

      GCCInstallation.getTriple().getArch() == llvm::Triple::x86

          ? 
"i386-linux-gnu"7

          : 
TripleStr60
;

  // Try generic GCC detection first.

  if (Generic_GCC::addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args,

                                               DebianMultiarch))

    return;

  StringRef LibDir = GCCInstallation.getParentLibPath();

  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, TripleStr,

                                 Multilib.includeSuffix(), DriverArgs, CC1Args))

      break;

  }

}

void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,

                               ArgStringList &CC1Args) const {

  CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);

}

void Linux::AddHIPIncludeArgs(const ArgList &DriverArgs,

                              ArgStringList &CC1Args) const {

  RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);

}

void Linux::AddHIPRuntimeLibArgs(const ArgList &Args,

                                 ArgStringList &CmdArgs) const {

  CmdArgs.push_back(

      Args.MakeArgString(StringRef("-L") + RocmInstallation->getLibPath()));

  if (Args.hasFlag(options::OPT_frtlib_add_rpath,

                   options::OPT_fno_rtlib_add_rpath, false))

    CmdArgs.append(

        {"-rpath", Args.MakeArgString(RocmInstallation->getLibPath())});

  CmdArgs.push_back("-lamdhip64");

}

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 llvm::opt::ArgList &Args) const {

  return CLANG_DEFAULT_PIE_ON_LINUX || 
getTriple().isAndroid()0
 ||

         
getTriple().isMusl()0
 || 
getSanitizerArgs(Args).requiresPIE()0
;

}

bool Linux::IsAArch64OutlineAtomicsDefault(const ArgList &Args) const {

  // Outline atomics for AArch64 are supported by compiler-rt

  // and libgcc since 9.3.1

  assert(getTriple().isAArch64() && "expected AArch64 target!");

  ToolChain::RuntimeLibType RtLib = GetRuntimeLibType(Args);

  if (RtLib == ToolChain::RLT_CompilerRT)

    return true;

  assert(RtLib == ToolChain::RLT_Libgcc && "unexpected runtime library type!");

  if (GCCInstallation.getVersion().isOlderThan(9, 3, 1))

    return false;

  return true;

}

bool Linux::IsMathErrnoDefault() const {

  if (getTriple().isAndroid() || 
getTriple().isMusl()4.78k
)

    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::ppc64le8.50k
;

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

                         
getTriple().getArch() == llvm::Triple::aarch64_be7.96k
;

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

                         
getTriple().getArch() == llvm::Triple::thumb7.72k
 ||

                         
getTriple().getArch() == llvm::Triple::armeb7.69k
 ||

                         
getTriple().getArch() == llvm::Triple::thumbeb7.63k
;

  const bool IsLoongArch64 = getTriple().getArch() == llvm::Triple::loongarch64;

  const bool IsRISCV64 = getTriple().getArch() == llvm::Triple::riscv64;

  const bool IsSystemZ = getTriple().getArch() == llvm::Triple::systemz;

  const bool IsHexagon = getTriple().getArch() == llvm::Triple::hexagon;

  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 || 
IsMIPS644.31k
 || 
IsAArch644.17k
 || 
IsLoongArch643.40k
)

    Res |= SanitizerKind::DataFlow;

  if (IsX86_64 || 
IsMIPS644.31k
 || 
IsAArch644.17k
 || 
IsX863.40k
 || 
IsArmArch2.65k
 || 
IsPowerPC641.55k
 ||

      
IsRISCV641.15k
 || 
IsSystemZ954
 || 
IsHexagon890
 || 
IsLoongArch64699
)

    Res |= SanitizerKind::Leak;

  if (IsX86_64 || 
IsMIPS644.31k
 || 
IsAArch644.17k
 || 
IsPowerPC643.40k
 || 
IsSystemZ3.00k
 ||

      
IsLoongArch642.93k
)

    Res |= SanitizerKind::Thread;

  if (IsX86_64 || 
IsSystemZ4.31k
)

    Res |= SanitizerKind::KernelMemory;

  if (IsX86_64 || 
IsMIPS644.31k
 || 
IsAArch644.17k
 || 
IsX863.40k
 || 
IsMIPS2.65k
 || 
IsArmArch2.40k
 ||

      
IsPowerPC641.29k
 || 
IsHexagon899
 || 
IsLoongArch64708
 || 
IsRISCV64669
)

    Res |= SanitizerKind::Scudo;

  if (IsX86_64 || 
IsAArch644.31k
 || 
IsRISCV643.54k
) {

    Res |= SanitizerKind::HWAddress;

  }

  if (IsX86_64 || 
IsAArch644.31k
) {

    Res |= SanitizerKind::KernelHWAddress;

  }

  // Work around "Cannot represent a difference across sections".

  if (getTriple().getArch() == llvm::Triple::ppc64)

    Res &= ~SanitizerKind::Function;

  return Res;

}

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

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

  // Add linker option -u__llvm_profile_runtime to cause runtime

  // initialization module to be linked in.

  if (needsProfileRT(Args))

    CmdArgs.push_back(Args.MakeArgString(

        Twine("-u", llvm::getInstrProfRuntimeHookVarName())));

  ToolChain::addProfileRTLibs(Args, CmdArgs);

}

llvm::DenormalMode

Linux::getDefaultDenormalModeForType(const llvm::opt::ArgList &DriverArgs,

                                     const JobAction &JA,

                                     const llvm::fltSemantics *FPType) const {

  switch (getTriple().getArch()) {

  case llvm::Triple::x86:

  case llvm::Triple::x86_64: {

    std::string Unused;

    // DAZ and FTZ are turned on in crtfastmath.o

    if (!DriverArgs.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&

        
isFastMathRuntimeAvailable(DriverArgs, Unused)5.60k
)

      return llvm::DenormalMode::getPreserveSign();

    return llvm::DenormalMode::getIEEE();

  }

  default:

    return llvm::DenormalMode::getIEEE();

  }

}

void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {

  for (const auto &Opt : ExtraOpts)

    CmdArgs.push_back(Opt.c_str());

}

const char *Linux::getDefaultLinker() const {

  if (getTriple().isAndroid())

    return "ld.lld";

  return Generic_ELF::getDefaultLinker();

}