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