1//===--- Linux.h - Linux ToolChain Implementations --------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Linux.h"
10#include "Arch/ARM.h"
11#include "Arch/Mips.h"
12#include "Arch/PPC.h"
13#include "Arch/RISCV.h"
14#include "CommonArgs.h"
15#include "clang/Config/config.h"
16#include "clang/Driver/Distro.h"
17#include "clang/Driver/Driver.h"
18#include "clang/Driver/Options.h"
19#include "clang/Driver/SanitizerArgs.h"
20#include "llvm/Option/ArgList.h"
21#include "llvm/ProfileData/InstrProf.h"
22#include "llvm/Support/Path.h"
23#include "llvm/Support/ScopedPrinter.h"
24#include "llvm/Support/VirtualFileSystem.h"
25#include <system_error>
26
27using namespace clang::driver;
28using namespace clang::driver::toolchains;
29using namespace clang;
30using namespace llvm::opt;
31
32using tools::addPathIfExists;
33
34/// Get our best guess at the multiarch triple for a target.
35///
36/// Debian-based systems are starting to use a multiarch setup where they use
37/// a target-triple directory in the library and header search paths.
38/// Unfortunately, this triple does not align with the vanilla target triple,
39/// so we provide a rough mapping here.
40std::string Linux::getMultiarchTriple(const Driver &D,
41                                      const llvm::Triple &TargetTriple,
42                                      StringRef SysRoot) const {
43  llvm::Triple::EnvironmentType TargetEnvironment =
44      TargetTriple.getEnvironment();
45  bool IsAndroid = TargetTriple.isAndroid();
46  bool IsMipsR6 = TargetTriple.getSubArch() == llvm::Triple::MipsSubArch_r6;
47  bool IsMipsN32Abi = TargetTriple.getEnvironment() == llvm::Triple::GNUABIN32;
48
49  // For most architectures, just use whatever we have rather than trying to be
50  // clever.
51  switch (TargetTriple.getArch()) {
52  default:
53    break;
54
55  // We use the existence of '/lib/<triple>' as a directory to detect some
56  // common linux triples that don't quite match the Clang triple for both
57  // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
58  // regardless of what the actual target triple is.
59  case llvm::Triple::arm:
60  case llvm::Triple::thumb:
61    if (IsAndroid)
62      return "arm-linux-androideabi";
63    if (TargetEnvironment == llvm::Triple::GNUEABIHF)
64      return "arm-linux-gnueabihf";
65    return "arm-linux-gnueabi";
66  case llvm::Triple::armeb:
67  case llvm::Triple::thumbeb:
68    if (TargetEnvironment == llvm::Triple::GNUEABIHF)
69      return "armeb-linux-gnueabihf";
70    return "armeb-linux-gnueabi";
71  case llvm::Triple::x86:
72    if (IsAndroid)
73      return "i686-linux-android";
74    return "i386-linux-gnu";
75  case llvm::Triple::x86_64:
76    if (IsAndroid)
77      return "x86_64-linux-android";
78    if (TargetEnvironment == llvm::Triple::GNUX32)
79      return "x86_64-linux-gnux32";
80    return "x86_64-linux-gnu";
81  case llvm::Triple::aarch64:
82    if (IsAndroid)
83      return "aarch64-linux-android";
84    return "aarch64-linux-gnu";
85  case llvm::Triple::aarch64_be:
86    return "aarch64_be-linux-gnu";
87
88  case llvm::Triple::m68k:
89    return "m68k-linux-gnu";
90
91  case llvm::Triple::mips:
92    return IsMipsR6 ? "mipsisa32r6-linux-gnu" : "mips-linux-gnu";
93  case llvm::Triple::mipsel:
94    if (IsAndroid)
95      return "mipsel-linux-android";
96    return IsMipsR6 ? "mipsisa32r6el-linux-gnu" : "mipsel-linux-gnu";
97  case llvm::Triple::mips64: {
98    std::string MT = std::string(IsMipsR6 ? "mipsisa64r6" : "mips64") +
99                     "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
100    if (D.getVFS().exists(SysRoot + "/lib/" + MT))
101      return MT;
102    if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
103      return "mips64-linux-gnu";
104    break;
105  }
106  case llvm::Triple::mips64el: {
107    if (IsAndroid)
108      return "mips64el-linux-android";
109    std::string MT = std::string(IsMipsR6 ? "mipsisa64r6el" : "mips64el") +
110                     "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
111    if (D.getVFS().exists(SysRoot + "/lib/" + MT))
112      return MT;
113    if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
114      return "mips64el-linux-gnu";
115    break;
116  }
117  case llvm::Triple::ppc:
118    if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
119      return "powerpc-linux-gnuspe";
120    return "powerpc-linux-gnu";
121  case llvm::Triple::ppcle:
122    return "powerpcle-linux-gnu";
123  case llvm::Triple::ppc64:
124    return "powerpc64-linux-gnu";
125  case llvm::Triple::ppc64le:
126    return "powerpc64le-linux-gnu";
127  case llvm::Triple::sparc:
128    return "sparc-linux-gnu";
129  case llvm::Triple::sparcv9:
130    return "sparc64-linux-gnu";
131  case llvm::Triple::systemz:
132    return "s390x-linux-gnu";
133  }
134  return TargetTriple.str();
135}
136
137static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
138  if (Triple.isMIPS()) {
139    if (Triple.isAndroid()) {
140      StringRef CPUName;
141      StringRef ABIName;
142      tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
143      if (CPUName == "mips32r6")
144        return "libr6";
145      if (CPUName == "mips32r2")
146        return "libr2";
147    }
148    // lib32 directory has a special meaning on MIPS targets.
149    // It contains N32 ABI binaries. Use this folder if produce
150    // code for N32 ABI only.
151    if (tools::mips::hasMipsAbiArg(Args, "n32"))
152      return "lib32";
153    return Triple.isArch32Bit() ? "lib" : "lib64";
154  }
155
156  // It happens that only x86, PPC and SPARC use the 'lib32' variant of
157  // oslibdir, and using that variant while targeting other architectures causes
158  // problems because the libraries are laid out in shared system roots that
159  // can't cope with a 'lib32' library search path being considered. So we only
160  // enable them when we know we may need it.
161  //
162  // FIXME: This is a bit of a hack. We should really unify this code for
163  // reasoning about oslibdir spellings with the lib dir spellings in the
164  // GCCInstallationDetector, but that is a more significant refactoring.
165  if (Triple.getArch() == llvm::Triple::x86 || Triple.isPPC32() ||
166      Triple.getArch() == llvm::Triple::sparc)
167    return "lib32";
168
169  if (Triple.getArch() == llvm::Triple::x86_64 &&
170      Triple.getEnvironment() == llvm::Triple::GNUX32)
171    return "libx32";
172
173  if (Triple.getArch() == llvm::Triple::riscv32)
174    return "lib32";
175
176  return Triple.isArch32Bit() ? "lib" : "lib64";
177}
178
179Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
180    : Generic_ELF(D, Triple, Args) {
181  GCCInstallation.init(Triple, Args);
182  Multilibs = GCCInstallation.getMultilibs();
183  SelectedMultilib = GCCInstallation.getMultilib();
184  llvm::Triple::ArchType Arch = Triple.getArch();
185  std::string SysRoot = computeSysRoot();
186  ToolChain::path_list &PPaths = getProgramPaths();
187
188  Generic_GCC::PushPPaths(PPaths);
189
190  Distro Distro(D.getVFS(), Triple);
191
192  if (Distro.IsAlpineLinux() || Triple.isAndroid()) {
193    ExtraOpts.push_back("-z");
194    ExtraOpts.push_back("now");
195  }
196
197  if (Distro.IsOpenSUSE() || Distro.IsUbuntu() || Distro.IsAlpineLinux() ||
198      Triple.isAndroid()) {
199    ExtraOpts.push_back("-z");
200    ExtraOpts.push_back("relro");
201  }
202
203  // Android ARM/AArch64 use max-page-size=4096 to reduce VMA usage. Note, lld
204  // from 11 onwards default max-page-size to 65536 for both ARM and AArch64.
205  if ((Triple.isARM() || Triple.isAArch64()) && Triple.isAndroid()) {
206    ExtraOpts.push_back("-z");
207    ExtraOpts.push_back("max-page-size=4096");
208  }
209
210  if (GCCInstallation.getParentLibPath().find("opt/rh/devtoolset") !=
211      StringRef::npos)
212    // With devtoolset on RHEL, we want to add a bin directory that is relative
213    // to the detected gcc install, because if we are using devtoolset gcc then
214    // we want to use other tools from devtoolset (e.g. ld) instead of the
215    // standard system tools.
216    PPaths.push_back(Twine(GCCInstallation.getParentLibPath() +
217                     "/../bin").str());
218
219  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
220    ExtraOpts.push_back("-X");
221
222  const bool IsAndroid = Triple.isAndroid();
223  const bool IsMips = Triple.isMIPS();
224  const bool IsHexagon = Arch == llvm::Triple::hexagon;
225  const bool IsRISCV = Triple.isRISCV();
226
227  if (IsMips && !SysRoot.empty())
228    ExtraOpts.push_back("--sysroot=" + SysRoot);
229
230  // Do not use 'gnu' hash style for Mips targets because .gnu.hash
231  // and the MIPS ABI require .dynsym to be sorted in different ways.
232  // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
233  // ABI requires a mapping between the GOT and the symbol table.
234  // Android loader does not support .gnu.hash until API 23.
235  // Hexagon linker/loader does not support .gnu.hash
236  if (!IsMips && !IsHexagon) {
237    if (Distro.IsRedhat() || Distro.IsOpenSUSE() || Distro.IsAlpineLinux() ||
238        (Distro.IsUbuntu() && Distro >= Distro::UbuntuMaverick) ||
239        (IsAndroid && !Triple.isAndroidVersionLT(23)))
240      ExtraOpts.push_back("--hash-style=gnu");
241
242    if (Distro.IsDebian() || Distro.IsOpenSUSE() ||
243        Distro == Distro::UbuntuLucid || Distro == Distro::UbuntuJaunty ||
244        Distro == Distro::UbuntuKarmic ||
245        (IsAndroid && Triple.isAndroidVersionLT(23)))
246      ExtraOpts.push_back("--hash-style=both");
247  }
248
249#ifdef ENABLE_LINKER_BUILD_ID
250  ExtraOpts.push_back("--build-id");
251#endif
252
253  if (IsAndroid || Distro.IsOpenSUSE())
254    ExtraOpts.push_back("--enable-new-dtags");
255
256  // The selection of paths to try here is designed to match the patterns which
257  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
258  // This was determined by running GCC in a fake filesystem, creating all
259  // possible permutations of these directories, and seeing which ones it added
260  // to the link paths.
261  path_list &Paths = getFilePaths();
262
263  const std::string OSLibDir = std::string(getOSLibDir(Triple, Args));
264  const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
265
266  Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths);
267
268  addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
269  addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
270
271  if (IsAndroid) {
272    // Android sysroots contain a library directory for each supported OS
273    // version as well as some unversioned libraries in the usual multiarch
274    // directory.
275    unsigned Major;
276    unsigned Minor;
277    unsigned Micro;
278    Triple.getEnvironmentVersion(Major, Minor, Micro);
279    addPathIfExists(D,
280                    SysRoot + "/usr/lib/" + MultiarchTriple + "/" +
281                        llvm::to_string(Major),
282                    Paths);
283  }
284
285  addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
286  // 64-bit OpenEmbedded sysroots may not have a /usr/lib dir. So they cannot
287  // find /usr/lib64 as it is referenced as /usr/lib/../lib64. So we handle
288  // this here.
289  if (Triple.getVendor() == llvm::Triple::OpenEmbedded &&
290      Triple.isArch64Bit())
291    addPathIfExists(D, SysRoot + "/usr/" + OSLibDir, Paths);
292  else
293    addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
294  if (IsRISCV) {
295    StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
296    addPathIfExists(D, SysRoot + "/" + OSLibDir + "/" + ABIName, Paths);
297    addPathIfExists(D, SysRoot + "/usr/" + OSLibDir + "/" + ABIName, Paths);
298  }
299
300  Generic_GCC::AddMultiarchPaths(D, SysRoot, OSLibDir, Paths);
301
302  // Similar to the logic for GCC above, if we are currently running Clang
303  // inside of the requested system root, add its parent library path to those
304  // searched.
305  // FIXME: It's not clear whether we should use the driver's installed
306  // directory ('Dir' below) or the ResourceDir.
307  if (StringRef(D.Dir).startswith(SysRoot))
308    addPathIfExists(D, D.Dir + "/../lib", Paths);
309
310  addPathIfExists(D, SysRoot + "/lib", Paths);
311  addPathIfExists(D, SysRoot + "/usr/lib", Paths);
312}
313
314ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const {
315  if (getTriple().isAndroid())
316    return ToolChain::RLT_CompilerRT;
317  return Generic_ELF::GetDefaultRuntimeLibType();
318}
319
320ToolChain::CXXStdlibType Linux::GetDefaultCXXStdlibType() const {
321  if (getTriple().isAndroid())
322    return ToolChain::CST_Libcxx;
323  return ToolChain::CST_Libstdcxx;
324}
325
326bool Linux::HasNativeLLVMSupport() const { return true; }
327
328Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
329
330Tool *Linux::buildStaticLibTool() const {
331  return new tools::gnutools::StaticLibTool(*this);
332}
333
334Tool *Linux::buildAssembler() const {
335  return new tools::gnutools::Assembler(*this);
336}
337
338std::string Linux::computeSysRoot() const {
339  if (!getDriver().SysRoot.empty())
340    return getDriver().SysRoot;
341
342  if (getTriple().isAndroid()) {
343    // Android toolchains typically include a sysroot at ../sysroot relative to
344    // the clang binary.
345    const StringRef ClangDir = getDriver().getInstalledDir();
346    std::string AndroidSysRootPath = (ClangDir + "/../sysroot").str();
347    if (getVFS().exists(AndroidSysRootPath))
348      return AndroidSysRootPath;
349  }
350
351  if (!GCCInstallation.isValid() || !getTriple().isMIPS())
352    return std::string();
353
354  // Standalone MIPS toolchains use different names for sysroot folder
355  // and put it into different places. Here we try to check some known
356  // variants.
357
358  const StringRef InstallDir = GCCInstallation.getInstallPath();
359  const StringRef TripleStr = GCCInstallation.getTriple().str();
360  const Multilib &Multilib = GCCInstallation.getMultilib();
361
362  std::string Path =
363      (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
364          .str();
365
366  if (getVFS().exists(Path))
367    return Path;
368
369  Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
370
371  if (getVFS().exists(Path))
372    return Path;
373
374  return std::string();
375}
376
377std::string Linux::getDynamicLinker(const ArgList &Args) const {
378  const llvm::Triple::ArchType Arch = getArch();
379  const llvm::Triple &Triple = getTriple();
380
381  const Distro Distro(getDriver().getVFS(), Triple);
382
383  if (Triple.isAndroid())
384    return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
385
386  if (Triple.isMusl()) {
387    std::string ArchName;
388    bool IsArm = false;
389
390    switch (Arch) {
391    case llvm::Triple::arm:
392    case llvm::Triple::thumb:
393      ArchName = "arm";
394      IsArm = true;
395      break;
396    case llvm::Triple::armeb:
397    case llvm::Triple::thumbeb:
398      ArchName = "armeb";
399      IsArm = true;
400      break;
401    case llvm::Triple::x86:
402      ArchName = "i386";
403      break;
404    case llvm::Triple::x86_64:
405      ArchName = Triple.getEnvironment() == llvm::Triple::MuslX32
406                     ? "x32"
407                     : Triple.getArchName().str();
408      break;
409    default:
410      ArchName = Triple.getArchName().str();
411    }
412    if (IsArm &&
413        (Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
414         tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard))
415      ArchName += "hf";
416
417    return "/lib/ld-musl-" + ArchName + ".so.1";
418  }
419
420  std::string LibDir;
421  std::string Loader;
422
423  switch (Arch) {
424  default:
425    llvm_unreachable("unsupported architecture");
426
427  case llvm::Triple::aarch64:
428    LibDir = "lib";
429    Loader = "ld-linux-aarch64.so.1";
430    break;
431  case llvm::Triple::aarch64_be:
432    LibDir = "lib";
433    Loader = "ld-linux-aarch64_be.so.1";
434    break;
435  case llvm::Triple::arm:
436  case llvm::Triple::thumb:
437  case llvm::Triple::armeb:
438  case llvm::Triple::thumbeb: {
439    const bool HF =
440        Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
441        tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;
442
443    LibDir = "lib";
444    Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
445    break;
446  }
447  case llvm::Triple::m68k:
448    LibDir = "lib";
449    Loader = "ld.so.1";
450    break;
451  case llvm::Triple::mips:
452  case llvm::Triple::mipsel:
453  case llvm::Triple::mips64:
454  case llvm::Triple::mips64el: {
455    bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);
456
457    LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
458
459    if (tools::mips::isUCLibc(Args))
460      Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
461    else if (!Triple.hasEnvironment() &&
462             Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
463      Loader =
464          Triple.isLittleEndian() ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
465    else
466      Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
467
468    break;
469  }
470  case llvm::Triple::ppc:
471    LibDir = "lib";
472    Loader = "ld.so.1";
473    break;
474  case llvm::Triple::ppcle:
475    LibDir = "lib";
476    Loader = "ld.so.1";
477    break;
478  case llvm::Triple::ppc64:
479    LibDir = "lib64";
480    Loader =
481        (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";
482    break;
483  case llvm::Triple::ppc64le:
484    LibDir = "lib64";
485    Loader =
486        (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";
487    break;
488  case llvm::Triple::riscv32: {
489    StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
490    LibDir = "lib";
491    Loader = ("ld-linux-riscv32-" + ABIName + ".so.1").str();
492    break;
493  }
494  case llvm::Triple::riscv64: {
495    StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);
496    LibDir = "lib";
497    Loader = ("ld-linux-riscv64-" + ABIName + ".so.1").str();
498    break;
499  }
500  case llvm::Triple::sparc:
501  case llvm::Triple::sparcel:
502    LibDir = "lib";
503    Loader = "ld-linux.so.2";
504    break;
505  case llvm::Triple::sparcv9:
506    LibDir = "lib64";
507    Loader = "ld-linux.so.2";
508    break;
509  case llvm::Triple::systemz:
510    LibDir = "lib";
511    Loader = "ld64.so.1";
512    break;
513  case llvm::Triple::x86:
514    LibDir = "lib";
515    Loader = "ld-linux.so.2";
516    break;
517  case llvm::Triple::x86_64: {
518    bool X32 = Triple.getEnvironment() == llvm::Triple::GNUX32;
519
520    LibDir = X32 ? "libx32" : "lib64";
521    Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";
522    break;
523  }
524  case llvm::Triple::ve:
525    return "/opt/nec/ve/lib/ld-linux-ve.so.1";
526  }
527
528  if (Distro == Distro::Exherbo &&
529      (Triple.getVendor() == llvm::Triple::UnknownVendor ||
530       Triple.getVendor() == llvm::Triple::PC))
531    return "/usr/" + Triple.str() + "/lib/" + Loader;
532  return "/" + LibDir + "/" + Loader;
533}
534
535void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
536                                      ArgStringList &CC1Args) const {
537  const Driver &D = getDriver();
538  std::string SysRoot = computeSysRoot();
539
540  if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
541    return;
542
543  // Add 'include' in the resource directory, which is similar to
544  // GCC_INCLUDE_DIR (private headers) in GCC. Note: the include directory
545  // contains some files conflicting with system /usr/include. musl systems
546  // prefer the /usr/include copies which are more relevant.
547  SmallString<128> ResourceDirInclude(D.ResourceDir);
548  llvm::sys::path::append(ResourceDirInclude, "include");
549  if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&
550      (!getTriple().isMusl() || DriverArgs.hasArg(options::OPT_nostdlibinc)))
551    addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
552
553  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
554    return;
555
556  // LOCAL_INCLUDE_DIR
557  addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
558  // TOOL_INCLUDE_DIR
559  AddMultilibIncludeArgs(DriverArgs, CC1Args);
560
561  // Check for configure-time C include directories.
562  StringRef CIncludeDirs(C_INCLUDE_DIRS);
563  if (CIncludeDirs != "") {
564    SmallVector<StringRef, 5> dirs;
565    CIncludeDirs.split(dirs, ":");
566    for (StringRef dir : dirs) {
567      StringRef Prefix =
568          llvm::sys::path::is_absolute(dir) ? "" : StringRef(SysRoot);
569      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
570    }
571    return;
572  }
573
574  // On systems using multiarch and Android, add /usr/include/$triple before
575  // /usr/include.
576  std::string MultiarchIncludeDir = getMultiarchTriple(D, getTriple(), SysRoot);
577  if (!MultiarchIncludeDir.empty() &&
578      D.getVFS().exists(SysRoot + "/usr/include/" + MultiarchIncludeDir))
579    addExternCSystemInclude(DriverArgs, CC1Args,
580                            SysRoot + "/usr/include/" + MultiarchIncludeDir);
581
582  if (getTriple().getOS() == llvm::Triple::RTEMS)
583    return;
584
585  // Add an include of '/include' directly. This isn't provided by default by
586  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
587  // add even when Clang is acting as-if it were a system compiler.
588  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
589
590  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
591
592  if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && getTriple().isMusl())
593    addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
594}
595
596void Linux::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
597                                     llvm::opt::ArgStringList &CC1Args) const {
598  // We need a detected GCC installation on Linux to provide libstdc++'s
599  // headers in odd Linuxish places.
600  if (!GCCInstallation.isValid())
601    return;
602
603  // Detect Debian g++-multiarch-incdir.diff.
604  StringRef TripleStr = GCCInstallation.getTriple().str();
605  StringRef DebianMultiarch =
606      GCCInstallation.getTriple().getArch() == llvm::Triple::x86
607          ? "i386-linux-gnu"
608          : TripleStr;
609
610  // Try generic GCC detection first.
611  if (Generic_GCC::addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args,
612                                               DebianMultiarch))
613    return;
614
615  StringRef LibDir = GCCInstallation.getParentLibPath();
616  const Multilib &Multilib = GCCInstallation.getMultilib();
617  const GCCVersion &Version = GCCInstallation.getVersion();
618
619  const std::string LibStdCXXIncludePathCandidates[] = {
620      // Android standalone toolchain has C++ headers in yet another place.
621      LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
622      // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
623      // without a subdirectory corresponding to the gcc version.
624      LibDir.str() + "/../include/c++",
625      // Cray's gcc installation puts headers under "g++" without a
626      // version suffix.
627      LibDir.str() + "/../include/g++",
628  };
629
630  for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
631    if (addLibStdCXXIncludePaths(IncludePath, TripleStr,
632                                 Multilib.includeSuffix(), DriverArgs, CC1Args))
633      break;
634  }
635}
636
637void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
638                               ArgStringList &CC1Args) const {
639  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
640}
641
642void Linux::AddHIPIncludeArgs(const ArgList &DriverArgs,
643                              ArgStringList &CC1Args) const {
644  RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);
645}
646
647void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
648                                ArgStringList &CC1Args) const {
649  if (GCCInstallation.isValid()) {
650    CC1Args.push_back("-isystem");
651    CC1Args.push_back(DriverArgs.MakeArgString(
652        GCCInstallation.getParentLibPath() + "/../" +
653        GCCInstallation.getTriple().str() + "/include"));
654  }
655}
656
657bool Linux::isPIEDefault() const {
658  return (getTriple().isAndroid() && !getTriple().isAndroidVersionLT(16)) ||
659          getTriple().isMusl() || getSanitizerArgs().requiresPIE();
660}
661
662bool Linux::IsAArch64OutlineAtomicsDefault(const ArgList &Args) const {
663  // Outline atomics for AArch64 are supported by compiler-rt
664  // and libgcc since 9.3.1
665  assert(getTriple().isAArch64() && "expected AArch64 target!");
666  ToolChain::RuntimeLibType RtLib = GetRuntimeLibType(Args);
667  if (RtLib == ToolChain::RLT_CompilerRT)
668    return true;
669  assert(RtLib == ToolChain::RLT_Libgcc && "unexpected runtime library type!");
670  if (GCCInstallation.getVersion().isOlderThan(9, 3, 1))
671    return false;
672  return true;
673}
674
675bool Linux::isNoExecStackDefault() const {
676    return getTriple().isAndroid();
677}
678
679bool Linux::IsMathErrnoDefault() const {
680  if (getTriple().isAndroid())
681    return false;
682  return Generic_ELF::IsMathErrnoDefault();
683}
684
685SanitizerMask Linux::getSupportedSanitizers() const {
686  const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
687  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
688  const bool IsMIPS = getTriple().isMIPS32();
689  const bool IsMIPS64 = getTriple().isMIPS64();
690  const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
691                           getTriple().getArch() == llvm::Triple::ppc64le;
692  const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
693                         getTriple().getArch() == llvm::Triple::aarch64_be;
694  const bool IsArmArch = getTriple().getArch() == llvm::Triple::arm ||
695                         getTriple().getArch() == llvm::Triple::thumb ||
696                         getTriple().getArch() == llvm::Triple::armeb ||
697                         getTriple().getArch() == llvm::Triple::thumbeb;
698  const bool IsRISCV64 = getTriple().getArch() == llvm::Triple::riscv64;
699  const bool IsSystemZ = getTriple().getArch() == llvm::Triple::systemz;
700  SanitizerMask Res = ToolChain::getSupportedSanitizers();
701  Res |= SanitizerKind::Address;
702  Res |= SanitizerKind::PointerCompare;
703  Res |= SanitizerKind::PointerSubtract;
704  Res |= SanitizerKind::Fuzzer;
705  Res |= SanitizerKind::FuzzerNoLink;
706  Res |= SanitizerKind::KernelAddress;
707  Res |= SanitizerKind::Memory;
708  Res |= SanitizerKind::Vptr;
709  Res |= SanitizerKind::SafeStack;
710  if (IsX86_64 || IsMIPS64 || IsAArch64)
711    Res |= SanitizerKind::DataFlow;
712  if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64 ||
713      IsRISCV64 || IsSystemZ)
714    Res |= SanitizerKind::Leak;
715  if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
716    Res |= SanitizerKind::Thread;
717  if (IsX86_64)
718    Res |= SanitizerKind::KernelMemory;
719  if (IsX86 || IsX86_64)
720    Res |= SanitizerKind::Function;
721  if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||
722      IsPowerPC64)
723    Res |= SanitizerKind::Scudo;
724  if (IsX86_64 || IsAArch64) {
725    Res |= SanitizerKind::HWAddress;
726    Res |= SanitizerKind::KernelHWAddress;
727  }
728  return Res;
729}
730
731void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
732                             llvm::opt::ArgStringList &CmdArgs) const {
733  // Add linker option -u__llvm_profile_runtime to cause runtime
734  // initialization module to be linked in.
735  if (needsProfileRT(Args))
736    CmdArgs.push_back(Args.MakeArgString(
737        Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
738  ToolChain::addProfileRTLibs(Args, CmdArgs);
739}
740
741llvm::DenormalMode
742Linux::getDefaultDenormalModeForType(const llvm::opt::ArgList &DriverArgs,
743                                     const JobAction &JA,
744                                     const llvm::fltSemantics *FPType) const {
745  switch (getTriple().getArch()) {
746  case llvm::Triple::x86:
747  case llvm::Triple::x86_64: {
748    std::string Unused;
749    // DAZ and FTZ are turned on in crtfastmath.o
750    if (!DriverArgs.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
751        isFastMathRuntimeAvailable(DriverArgs, Unused))
752      return llvm::DenormalMode::getPreserveSign();
753    return llvm::DenormalMode::getIEEE();
754  }
755  default:
756    return llvm::DenormalMode::getIEEE();
757  }
758}
759
760void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {
761  for (const auto &Opt : ExtraOpts)
762    CmdArgs.push_back(Opt.c_str());
763}
764