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