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