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.
getMultiarchTriple(const Driver & D,const llvm::Triple & TargetTriple,StringRef SysRoot) const40 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
getOSLibDir(const llvm::Triple & Triple,const ArgList & Args)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 &&
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
Linux(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)179 Linux::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
GetDefaultRuntimeLibType() const314 ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const {
315 if (getTriple().isAndroid())
316 return ToolChain::RLT_CompilerRT;
317 return Generic_ELF::GetDefaultRuntimeLibType();
318 }
319
GetDefaultCXXStdlibType() const320 ToolChain::CXXStdlibType Linux::GetDefaultCXXStdlibType() const {
321 if (getTriple().isAndroid())
322 return ToolChain::CST_Libcxx;
323 return ToolChain::CST_Libstdcxx;
324 }
325
HasNativeLLVMSupport() const326 bool Linux::HasNativeLLVMSupport() const { return true; }
327
buildLinker() const328 Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
329
buildStaticLibTool() const330 Tool *Linux::buildStaticLibTool() const {
331 return new tools::gnutools::StaticLibTool(*this);
332 }
333
buildAssembler() const334 Tool *Linux::buildAssembler() const {
335 return new tools::gnutools::Assembler(*this);
336 }
337
computeSysRoot() const338 std::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
getDynamicLinker(const ArgList & Args) const377 std::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
AddClangSystemIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const535 void 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
addLibStdCxxIncludePaths(const llvm::opt::ArgList & DriverArgs,llvm::opt::ArgStringList & CC1Args) const596 void 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
AddCudaIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const637 void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
638 ArgStringList &CC1Args) const {
639 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
640 }
641
AddHIPIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const642 void Linux::AddHIPIncludeArgs(const ArgList &DriverArgs,
643 ArgStringList &CC1Args) const {
644 RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);
645 }
646
AddIAMCUIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const647 void 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
isPIEDefault() const657 bool Linux::isPIEDefault() const {
658 return (getTriple().isAndroid() && !getTriple().isAndroidVersionLT(16)) ||
659 getTriple().isMusl() || getSanitizerArgs().requiresPIE();
660 }
661
IsAArch64OutlineAtomicsDefault(const ArgList & Args) const662 bool 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
isNoExecStackDefault() const675 bool Linux::isNoExecStackDefault() const {
676 return getTriple().isAndroid();
677 }
678
IsMathErrnoDefault() const679 bool Linux::IsMathErrnoDefault() const {
680 if (getTriple().isAndroid())
681 return false;
682 return Generic_ELF::IsMathErrnoDefault();
683 }
684
getSupportedSanitizers() const685 SanitizerMask 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
addProfileRTLibs(const llvm::opt::ArgList & Args,llvm::opt::ArgStringList & CmdArgs) const731 void 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
741 llvm::DenormalMode
getDefaultDenormalModeForType(const llvm::opt::ArgList & DriverArgs,const JobAction & JA,const llvm::fltSemantics * FPType) const742 Linux::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
addExtraOpts(llvm::opt::ArgStringList & CmdArgs) const760 void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {
761 for (const auto &Opt : ExtraOpts)
762 CmdArgs.push_back(Opt.c_str());
763 }
764