969 lines · cpp
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-exception6//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 "clang/Config/config.h"16#include "clang/Driver/CommonArgs.h"17#include "clang/Driver/Distro.h"18#include "clang/Driver/Driver.h"19#include "clang/Driver/SanitizerArgs.h"20#include "clang/Options/Options.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 27using namespace clang::driver;28using namespace clang::driver::toolchains;29using namespace clang;30using namespace llvm::opt;31 32using tools::addPathIfExists;33 34/// Get our best guess at the multiarch triple for a target.35///36/// Debian-based systems are starting to use a multiarch setup where they use37/// a target-triple directory in the library and header search paths.38/// Unfortunately, this triple does not align with the vanilla target triple,39/// so we provide a rough mapping here.40std::string Linux::getMultiarchTriple(const Driver &D,41 const llvm::Triple &TargetTriple,42 StringRef SysRoot) const {43 llvm::Triple::EnvironmentType TargetEnvironment =44 TargetTriple.getEnvironment();45 bool IsAndroid = TargetTriple.isAndroid();46 bool IsMipsR6 = TargetTriple.getSubArch() == llvm::Triple::MipsSubArch_r6;47 bool IsMipsN32Abi = TargetTriple.getEnvironment() == llvm::Triple::GNUABIN32;48 49 // For most architectures, just use whatever we have rather than trying to be50 // clever.51 switch (TargetTriple.getArch()) {52 default:53 break;54 55 // We use the existence of '/lib/<triple>' as a directory to detect some56 // common linux triples that don't quite match the Clang triple for both57 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these58 // 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 TargetEnvironment == llvm::Triple::MuslEABIHF ||65 TargetEnvironment == llvm::Triple::EABIHF)66 return "arm-linux-gnueabihf";67 return "arm-linux-gnueabi";68 case llvm::Triple::armeb:69 case llvm::Triple::thumbeb:70 if (TargetEnvironment == llvm::Triple::GNUEABIHF ||71 TargetEnvironment == llvm::Triple::MuslEABIHF ||72 TargetEnvironment == llvm::Triple::EABIHF)73 return "armeb-linux-gnueabihf";74 return "armeb-linux-gnueabi";75 case llvm::Triple::x86:76 if (IsAndroid)77 return "i686-linux-android";78 return "i386-linux-gnu";79 case llvm::Triple::x86_64:80 if (IsAndroid)81 return "x86_64-linux-android";82 if (TargetEnvironment == llvm::Triple::GNUX32)83 return "x86_64-linux-gnux32";84 return "x86_64-linux-gnu";85 case llvm::Triple::aarch64:86 if (IsAndroid)87 return "aarch64-linux-android";88 if (hasEffectiveTriple() &&89 getEffectiveTriple().getEnvironment() == llvm::Triple::PAuthTest)90 return "aarch64-linux-pauthtest";91 return "aarch64-linux-gnu";92 case llvm::Triple::aarch64_be:93 return "aarch64_be-linux-gnu";94 95 case llvm::Triple::loongarch64: {96 const char *Libc;97 const char *FPFlavor;98 99 if (TargetTriple.isGNUEnvironment()) {100 Libc = "gnu";101 } else if (TargetTriple.isMusl()) {102 Libc = "musl";103 } else {104 return TargetTriple.str();105 }106 107 switch (TargetEnvironment) {108 default:109 return TargetTriple.str();110 case llvm::Triple::GNUSF:111 case llvm::Triple::MuslSF:112 FPFlavor = "sf";113 break;114 case llvm::Triple::GNUF32:115 case llvm::Triple::MuslF32:116 FPFlavor = "f32";117 break;118 case llvm::Triple::GNU:119 case llvm::Triple::GNUF64:120 case llvm::Triple::Musl:121 // This was going to be "f64" in an earlier Toolchain Conventions122 // revision, but starting from Feb 2023 the F64 ABI variants are123 // unmarked in their canonical forms.124 FPFlavor = "";125 break;126 }127 128 return (Twine("loongarch64-linux-") + Libc + FPFlavor).str();129 }130 131 case llvm::Triple::m68k:132 return "m68k-linux-gnu";133 134 case llvm::Triple::mips:135 return IsMipsR6 ? "mipsisa32r6-linux-gnu" : "mips-linux-gnu";136 case llvm::Triple::mipsel:137 return IsMipsR6 ? "mipsisa32r6el-linux-gnu" : "mipsel-linux-gnu";138 case llvm::Triple::mips64: {139 std::string MT = std::string(IsMipsR6 ? "mipsisa64r6" : "mips64") +140 "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");141 if (D.getVFS().exists(concat(SysRoot, "/lib", MT)))142 return MT;143 if (D.getVFS().exists(concat(SysRoot, "/lib/mips64-linux-gnu")))144 return "mips64-linux-gnu";145 break;146 }147 case llvm::Triple::mips64el: {148 std::string MT = std::string(IsMipsR6 ? "mipsisa64r6el" : "mips64el") +149 "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");150 if (D.getVFS().exists(concat(SysRoot, "/lib", MT)))151 return MT;152 if (D.getVFS().exists(concat(SysRoot, "/lib/mips64el-linux-gnu")))153 return "mips64el-linux-gnu";154 break;155 }156 case llvm::Triple::ppc:157 if (D.getVFS().exists(concat(SysRoot, "/lib/powerpc-linux-gnuspe")))158 return "powerpc-linux-gnuspe";159 return "powerpc-linux-gnu";160 case llvm::Triple::ppcle:161 return "powerpcle-linux-gnu";162 case llvm::Triple::ppc64:163 return "powerpc64-linux-gnu";164 case llvm::Triple::ppc64le:165 return "powerpc64le-linux-gnu";166 case llvm::Triple::riscv64:167 if (IsAndroid)168 return "riscv64-linux-android";169 return "riscv64-linux-gnu";170 case llvm::Triple::sparc:171 return "sparc-linux-gnu";172 case llvm::Triple::sparcv9:173 return "sparc64-linux-gnu";174 case llvm::Triple::systemz:175 return "s390x-linux-gnu";176 }177 return TargetTriple.str();178}179 180static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {181 if (Triple.isMIPS()) {182 // lib32 directory has a special meaning on MIPS targets.183 // It contains N32 ABI binaries. Use this folder if produce184 // code for N32 ABI only.185 if (tools::mips::hasMipsAbiArg(Args, "n32"))186 return "lib32";187 return Triple.isArch32Bit() ? "lib" : "lib64";188 }189 190 // It happens that only x86, PPC and SPARC use the 'lib32' variant of191 // oslibdir, and using that variant while targeting other architectures causes192 // problems because the libraries are laid out in shared system roots that193 // can't cope with a 'lib32' library search path being considered. So we only194 // enable them when we know we may need it.195 //196 // FIXME: This is a bit of a hack. We should really unify this code for197 // reasoning about oslibdir spellings with the lib dir spellings in the198 // GCCInstallationDetector, but that is a more significant refactoring.199 if (Triple.getArch() == llvm::Triple::x86 || Triple.isPPC32() ||200 Triple.getArch() == llvm::Triple::sparc)201 return "lib32";202 203 if (Triple.getArch() == llvm::Triple::x86_64 && Triple.isX32())204 return "libx32";205 206 if (Triple.getArch() == llvm::Triple::riscv32)207 return "lib32";208 209 return Triple.isArch32Bit() ? "lib" : "lib64";210}211 212Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)213 : Generic_ELF(D, Triple, Args) {214 GCCInstallation.TripleToDebianMultiarch = [](const llvm::Triple &T) {215 StringRef TripleStr = T.str();216 StringRef DebianMultiarch =217 T.getArch() == llvm::Triple::x86 ? "i386-linux-gnu" : TripleStr;218 return DebianMultiarch;219 };220 221 GCCInstallation.init(Triple, Args);222 Multilibs = GCCInstallation.getMultilibs();223 SelectedMultilibs.assign({GCCInstallation.getMultilib()});224 llvm::Triple::ArchType Arch = Triple.getArch();225 std::string SysRoot = computeSysRoot();226 ToolChain::path_list &PPaths = getProgramPaths();227 228 Generic_GCC::PushPPaths(PPaths);229 230 Distro Distro(D.getVFS(), Triple);231 232 if (Distro.IsAlpineLinux() || Triple.isAndroid()) {233 ExtraOpts.push_back("-z");234 ExtraOpts.push_back("now");235 }236 237 if (Distro.IsOpenSUSE() || Distro.IsUbuntu() || Distro.IsAlpineLinux() ||238 Triple.isAndroid()) {239 ExtraOpts.push_back("-z");240 ExtraOpts.push_back("relro");241 }242 243 // Note, lld from 11 onwards default max-page-size to 65536 for both ARM and244 // AArch64.245 if (Triple.isAndroid()) {246 if (Triple.isARM()) {247 // Android ARM uses max-page-size=4096 to reduce VMA usage.248 ExtraOpts.push_back("-z");249 ExtraOpts.push_back("max-page-size=4096");250 } else if (Triple.isAArch64() || Triple.getArch() == llvm::Triple::x86_64) {251 // Android AArch64 uses max-page-size=16384 to support 4k/16k page sizes.252 // Android emulates a 16k page size for app testing on x86_64 machines.253 ExtraOpts.push_back("-z");254 ExtraOpts.push_back("max-page-size=16384");255 }256 if (Triple.isAndroidVersionLT(29)) {257 // https://github.com/android/ndk/issues/1196258 // The unwinder used by the crash handler on versions of Android prior to259 // API 29 did not correctly handle binaries built with rosegment, which is260 // enabled by default for LLD. Android only supports LLD, so it's not an261 // issue that this flag is not accepted by other linkers.262 ExtraOpts.push_back("--no-rosegment");263 }264 if (!Triple.isAndroidVersionLT(28)) {265 // Android supports relr packing starting with API 28 and had its own266 // flavor (--pack-dyn-relocs=android) starting in API 23.267 // TODO: It's possible to use both with --pack-dyn-relocs=android+relr,268 // but we need to gather some data on the impact of that form before we269 // can know if it's a good default.270 // On the other hand, relr should always be an improvement.271 ExtraOpts.push_back("--use-android-relr-tags");272 ExtraOpts.push_back("--pack-dyn-relocs=relr");273 }274 }275 276 if (GCCInstallation.getParentLibPath().contains("opt/rh/"))277 // With devtoolset on RHEL, we want to add a bin directory that is relative278 // to the detected gcc install, because if we are using devtoolset gcc then279 // we want to use other tools from devtoolset (e.g. ld) instead of the280 // standard system tools.281 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() +282 "/../bin").str());283 284 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)285 ExtraOpts.push_back("-X");286 287 const bool IsAndroid = Triple.isAndroid();288 const bool IsMips = Triple.isMIPS();289 const bool IsHexagon = Arch == llvm::Triple::hexagon;290 const bool IsRISCV = Triple.isRISCV();291 const bool IsCSKY = Triple.isCSKY();292 293 if (IsCSKY && !SelectedMultilibs.empty())294 SysRoot = SysRoot + SelectedMultilibs.back().osSuffix();295 296 if ((IsMips || IsCSKY) && !SysRoot.empty())297 ExtraOpts.push_back("--sysroot=" + SysRoot);298 299 // Do not use 'gnu' hash style for Mips targets because .gnu.hash300 // and the MIPS ABI require .dynsym to be sorted in different ways.301 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS302 // ABI requires a mapping between the GOT and the symbol table.303 // Android loader does not support .gnu.hash until API 23.304 // Hexagon linker/loader does not support .gnu.hash.305 // SUSE SLES 11 will stop being supported Mar 2028.306 if (!IsMips && !IsHexagon) {307 if (Distro.IsOpenSUSE() || (IsAndroid && Triple.isAndroidVersionLT(23)))308 ExtraOpts.push_back("--hash-style=both");309 else310 ExtraOpts.push_back("--hash-style=gnu");311 }312 313#ifdef ENABLE_LINKER_BUILD_ID314 ExtraOpts.push_back("--build-id");315#endif316 317 // The selection of paths to try here is designed to match the patterns which318 // the GCC driver itself uses, as this is part of the GCC-compatible driver.319 // This was determined by running GCC in a fake filesystem, creating all320 // possible permutations of these directories, and seeing which ones it added321 // to the link paths.322 path_list &Paths = getFilePaths();323 324 const std::string OSLibDir = std::string(getOSLibDir(Triple, Args));325 const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);326 327 // mips32: Debian multilib, we use /libo32, while in other case, /lib is328 // used. We need add both libo32 and /lib.329 if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel) {330 Generic_GCC::AddMultilibPaths(D, SysRoot, "libo32", MultiarchTriple, Paths);331 addPathIfExists(D, concat(SysRoot, "/libo32"), Paths);332 addPathIfExists(D, concat(SysRoot, "/usr/libo32"), Paths);333 }334 Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths);335 336 addPathIfExists(D, concat(SysRoot, "/lib", MultiarchTriple), Paths);337 addPathIfExists(D, concat(SysRoot, "/lib/..", OSLibDir), Paths);338 339 if (IsAndroid) {340 // Android sysroots contain a library directory for each supported OS341 // version as well as some unversioned libraries in the usual multiarch342 // directory.343 addPathIfExists(344 D,345 concat(SysRoot, "/usr/lib", MultiarchTriple,346 llvm::to_string(Triple.getEnvironmentVersion().getMajor())),347 Paths);348 }349 350 addPathIfExists(D, concat(SysRoot, "/usr/lib", MultiarchTriple), Paths);351 addPathIfExists(D, concat(SysRoot, "/usr", OSLibDir), Paths);352 if (IsRISCV) {353 StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);354 addPathIfExists(D, concat(SysRoot, "/", OSLibDir, ABIName), Paths);355 addPathIfExists(D, concat(SysRoot, "/usr", OSLibDir, ABIName), Paths);356 }357 358 Generic_GCC::AddMultiarchPaths(D, SysRoot, OSLibDir, Paths);359 360 addPathIfExists(D, concat(SysRoot, "/lib"), Paths);361 addPathIfExists(D, concat(SysRoot, "/usr/lib"), Paths);362}363 364ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const {365 if (getTriple().isAndroid())366 return ToolChain::RLT_CompilerRT;367 return Generic_ELF::GetDefaultRuntimeLibType();368}369 370unsigned Linux::GetDefaultDwarfVersion() const {371 if (getTriple().isAndroid())372 return 4;373 return ToolChain::GetDefaultDwarfVersion();374}375 376ToolChain::CXXStdlibType Linux::GetDefaultCXXStdlibType() const {377 if (getTriple().isAndroid())378 return ToolChain::CST_Libcxx;379 return ToolChain::CST_Libstdcxx;380}381 382bool Linux::HasNativeLLVMSupport() const { return true; }383 384Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }385 386Tool *Linux::buildStaticLibTool() const {387 return new tools::gnutools::StaticLibTool(*this);388}389 390Tool *Linux::buildAssembler() const {391 return new tools::gnutools::Assembler(*this);392}393 394std::string Linux::computeSysRoot() const {395 if (!getDriver().SysRoot.empty())396 return getDriver().SysRoot;397 398 if (getTriple().isAndroid()) {399 // Android toolchains typically include a sysroot at ../sysroot relative to400 // the clang binary.401 const StringRef ClangDir = getDriver().Dir;402 std::string AndroidSysRootPath = (ClangDir + "/../sysroot").str();403 if (getVFS().exists(AndroidSysRootPath))404 return AndroidSysRootPath;405 }406 407 if (getTriple().isCSKY()) {408 // CSKY toolchains use different names for sysroot folder.409 if (!GCCInstallation.isValid())410 return std::string();411 // GCCInstallation.getInstallPath() =412 // $GCCToolchainPath/lib/gcc/csky-linux-gnuabiv2/6.3.0413 // Path = $GCCToolchainPath/csky-linux-gnuabiv2/libc414 std::string Path = (GCCInstallation.getInstallPath() + "/../../../../" +415 GCCInstallation.getTriple().str() + "/libc")416 .str();417 if (getVFS().exists(Path))418 return Path;419 return std::string();420 }421 422 if (!GCCInstallation.isValid() || !getTriple().isMIPS())423 return std::string();424 425 // Standalone MIPS toolchains use different names for sysroot folder426 // and put it into different places. Here we try to check some known427 // variants.428 429 const StringRef InstallDir = GCCInstallation.getInstallPath();430 const StringRef TripleStr = GCCInstallation.getTriple().str();431 const Multilib &Multilib = GCCInstallation.getMultilib();432 433 std::string Path =434 (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())435 .str();436 437 if (getVFS().exists(Path))438 return Path;439 440 Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();441 442 if (getVFS().exists(Path))443 return Path;444 445 return std::string();446}447 448static void setPAuthABIInTriple(const Driver &D, const ArgList &Args,449 llvm::Triple &Triple) {450 Arg *ABIArg = Args.getLastArg(options::OPT_mabi_EQ);451 bool HasPAuthABI =452 ABIArg ? (StringRef(ABIArg->getValue()) == "pauthtest") : false;453 454 switch (Triple.getEnvironment()) {455 case llvm::Triple::UnknownEnvironment:456 if (HasPAuthABI)457 Triple.setEnvironment(llvm::Triple::PAuthTest);458 break;459 case llvm::Triple::PAuthTest:460 break;461 default:462 if (HasPAuthABI)463 D.Diag(diag::err_drv_unsupported_opt_for_target)464 << ABIArg->getAsString(Args) << Triple.getTriple();465 break;466 }467}468 469std::string Linux::ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,470 types::ID InputType) const {471 std::string TripleString =472 Generic_ELF::ComputeEffectiveClangTriple(Args, InputType);473 if (getTriple().isAArch64()) {474 llvm::Triple Triple(TripleString);475 setPAuthABIInTriple(getDriver(), Args, Triple);476 return Triple.getTriple();477 }478 return TripleString;479}480 481// Each combination of options here forms a signing schema, and in most cases482// each signing schema is its own incompatible ABI. The default values of the483// options represent the default signing schema.484static void handlePAuthABI(const Driver &D, const ArgList &DriverArgs,485 ArgStringList &CC1Args) {486 if (!DriverArgs.hasArg(options::OPT_fptrauth_intrinsics,487 options::OPT_fno_ptrauth_intrinsics))488 CC1Args.push_back("-fptrauth-intrinsics");489 490 if (!DriverArgs.hasArg(options::OPT_fptrauth_calls,491 options::OPT_fno_ptrauth_calls))492 CC1Args.push_back("-fptrauth-calls");493 494 if (!DriverArgs.hasArg(options::OPT_fptrauth_returns,495 options::OPT_fno_ptrauth_returns))496 CC1Args.push_back("-fptrauth-returns");497 498 if (!DriverArgs.hasArg(options::OPT_fptrauth_auth_traps,499 options::OPT_fno_ptrauth_auth_traps))500 CC1Args.push_back("-fptrauth-auth-traps");501 502 if (!DriverArgs.hasArg(503 options::OPT_fptrauth_vtable_pointer_address_discrimination,504 options::OPT_fno_ptrauth_vtable_pointer_address_discrimination))505 CC1Args.push_back("-fptrauth-vtable-pointer-address-discrimination");506 507 if (!DriverArgs.hasArg(508 options::OPT_fptrauth_vtable_pointer_type_discrimination,509 options::OPT_fno_ptrauth_vtable_pointer_type_discrimination))510 CC1Args.push_back("-fptrauth-vtable-pointer-type-discrimination");511 512 if (!DriverArgs.hasArg(513 options::OPT_fptrauth_type_info_vtable_pointer_discrimination,514 options::OPT_fno_ptrauth_type_info_vtable_pointer_discrimination))515 CC1Args.push_back("-fptrauth-type-info-vtable-pointer-discrimination");516 517 if (!DriverArgs.hasArg(options::OPT_fptrauth_indirect_gotos,518 options::OPT_fno_ptrauth_indirect_gotos))519 CC1Args.push_back("-fptrauth-indirect-gotos");520 521 if (!DriverArgs.hasArg(options::OPT_fptrauth_init_fini,522 options::OPT_fno_ptrauth_init_fini))523 CC1Args.push_back("-fptrauth-init-fini");524 525 if (!DriverArgs.hasArg(526 options::OPT_fptrauth_init_fini_address_discrimination,527 options::OPT_fno_ptrauth_init_fini_address_discrimination))528 CC1Args.push_back("-fptrauth-init-fini-address-discrimination");529 530 if (!DriverArgs.hasArg(options::OPT_faarch64_jump_table_hardening,531 options::OPT_fno_aarch64_jump_table_hardening))532 CC1Args.push_back("-faarch64-jump-table-hardening");533}534 535void Linux::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,536 llvm::opt::ArgStringList &CC1Args,537 Action::OffloadKind DeviceOffloadKind) const {538 llvm::Triple Triple(ComputeEffectiveClangTriple(DriverArgs));539 if (Triple.isAArch64() && Triple.getEnvironment() == llvm::Triple::PAuthTest)540 handlePAuthABI(getDriver(), DriverArgs, CC1Args);541 Generic_ELF::addClangTargetOptions(DriverArgs, CC1Args, DeviceOffloadKind);542}543 544std::string Linux::getDynamicLinker(const ArgList &Args) const {545 const llvm::Triple::ArchType Arch = getArch();546 const llvm::Triple &Triple = getTriple();547 548 const Distro Distro(getDriver().getVFS(), Triple);549 550 if (Triple.isAndroid()) {551 if (getSanitizerArgs(Args).needsHwasanRt() &&552 !Triple.isAndroidVersionLT(34) && Triple.isArch64Bit()) {553 // On Android 14 and newer, there is a special linker_hwasan64 that554 // allows to run HWASan binaries on non-HWASan system images. This555 // is also available on HWASan system images, so we can just always556 // use that instead.557 return "/system/bin/linker_hwasan64";558 }559 return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";560 }561 if (Triple.isMusl()) {562 std::string ArchName;563 bool IsArm = false;564 565 switch (Arch) {566 case llvm::Triple::arm:567 case llvm::Triple::thumb:568 ArchName = "arm";569 IsArm = true;570 break;571 case llvm::Triple::armeb:572 case llvm::Triple::thumbeb:573 ArchName = "armeb";574 IsArm = true;575 break;576 case llvm::Triple::x86:577 ArchName = "i386";578 break;579 case llvm::Triple::x86_64:580 ArchName = Triple.isX32() ? "x32" : Triple.getArchName().str();581 break;582 default:583 ArchName = Triple.getArchName().str();584 }585 if (IsArm &&586 (Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||587 tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard))588 ArchName += "hf";589 if (Arch == llvm::Triple::ppc &&590 Triple.getSubArch() == llvm::Triple::PPCSubArch_spe)591 ArchName = "powerpc-sf";592 593 return "/lib/ld-musl-" + ArchName + ".so.1";594 }595 596 std::string LibDir;597 std::string Loader;598 599 switch (Arch) {600 default:601 llvm_unreachable("unsupported architecture");602 603 case llvm::Triple::aarch64:604 LibDir = "lib";605 Loader = "ld-linux-aarch64.so.1";606 break;607 case llvm::Triple::aarch64_be:608 LibDir = "lib";609 Loader = "ld-linux-aarch64_be.so.1";610 break;611 case llvm::Triple::arm:612 case llvm::Triple::thumb:613 case llvm::Triple::armeb:614 case llvm::Triple::thumbeb: {615 const bool HF =616 Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||617 Triple.getEnvironment() == llvm::Triple::GNUEABIHFT64 ||618 tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;619 620 LibDir = "lib";621 Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";622 break;623 }624 case llvm::Triple::loongarch32: {625 LibDir = "lib32";626 Loader =627 ("ld-linux-loongarch-" +628 tools::loongarch::getLoongArchABI(getDriver(), Args, Triple) + ".so.1")629 .str();630 break;631 }632 case llvm::Triple::loongarch64: {633 LibDir = "lib64";634 Loader =635 ("ld-linux-loongarch-" +636 tools::loongarch::getLoongArchABI(getDriver(), Args, Triple) + ".so.1")637 .str();638 break;639 }640 case llvm::Triple::m68k:641 LibDir = "lib";642 Loader = "ld.so.1";643 break;644 case llvm::Triple::mips:645 case llvm::Triple::mipsel:646 case llvm::Triple::mips64:647 case llvm::Triple::mips64el: {648 bool IsNaN2008 = tools::mips::isNaN2008(getDriver(), Args, Triple);649 650 LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);651 652 if (tools::mips::isUCLibc(Args))653 Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";654 else if (!Triple.hasEnvironment() &&655 Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)656 Loader =657 Triple.isLittleEndian() ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";658 else659 Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";660 661 break;662 }663 case llvm::Triple::ppc:664 LibDir = "lib";665 Loader = "ld.so.1";666 break;667 case llvm::Triple::ppcle:668 LibDir = "lib";669 Loader = "ld.so.1";670 break;671 case llvm::Triple::ppc64:672 LibDir = "lib64";673 Loader =674 (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";675 break;676 case llvm::Triple::ppc64le:677 LibDir = "lib64";678 Loader =679 (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";680 break;681 case llvm::Triple::riscv32:682 case llvm::Triple::riscv64: {683 StringRef ArchName = llvm::Triple::getArchTypeName(Arch);684 StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple);685 LibDir = "lib";686 Loader = ("ld-linux-" + ArchName + "-" + ABIName + ".so.1").str();687 break;688 }689 case llvm::Triple::sparc:690 case llvm::Triple::sparcel:691 LibDir = "lib";692 Loader = "ld-linux.so.2";693 break;694 case llvm::Triple::sparcv9:695 LibDir = "lib64";696 Loader = "ld-linux.so.2";697 break;698 case llvm::Triple::systemz:699 LibDir = "lib";700 Loader = "ld64.so.1";701 break;702 case llvm::Triple::x86:703 LibDir = "lib";704 Loader = "ld-linux.so.2";705 break;706 case llvm::Triple::x86_64: {707 bool X32 = Triple.isX32();708 709 LibDir = X32 ? "libx32" : "lib64";710 Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";711 break;712 }713 case llvm::Triple::ve:714 return "/opt/nec/ve/lib/ld-linux-ve.so.1";715 case llvm::Triple::csky: {716 LibDir = "lib";717 Loader = "ld.so.1";718 break;719 }720 }721 722 if (Distro == Distro::Exherbo &&723 (Triple.getVendor() == llvm::Triple::UnknownVendor ||724 Triple.getVendor() == llvm::Triple::PC))725 return "/usr/" + Triple.str() + "/lib/" + Loader;726 return "/" + LibDir + "/" + Loader;727}728 729void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,730 ArgStringList &CC1Args) const {731 const Driver &D = getDriver();732 std::string SysRoot = computeSysRoot();733 734 if (DriverArgs.hasArg(options::OPT_nostdinc))735 return;736 737 // Add 'include' in the resource directory, which is similar to738 // GCC_INCLUDE_DIR (private headers) in GCC. Note: the include directory739 // contains some files conflicting with system /usr/include. musl systems740 // prefer the /usr/include copies which are more relevant.741 SmallString<128> ResourceDirInclude(D.ResourceDir);742 llvm::sys::path::append(ResourceDirInclude, "include");743 if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&744 (!getTriple().isMusl() || DriverArgs.hasArg(options::OPT_nostdlibinc)))745 addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);746 747 if (DriverArgs.hasArg(options::OPT_nostdlibinc))748 return;749 750 // LOCAL_INCLUDE_DIR751 addSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/usr/local/include"));752 // TOOL_INCLUDE_DIR753 AddMultilibIncludeArgs(DriverArgs, CC1Args);754 755 // Check for configure-time C include directories.756 StringRef CIncludeDirs(C_INCLUDE_DIRS);757 if (CIncludeDirs != "") {758 SmallVector<StringRef, 5> dirs;759 CIncludeDirs.split(dirs, ":");760 for (StringRef dir : dirs) {761 StringRef Prefix =762 llvm::sys::path::is_absolute(dir) ? "" : StringRef(SysRoot);763 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);764 }765 return;766 }767 768 // On systems using multiarch and Android, add /usr/include/$triple before769 // /usr/include.770 std::string MultiarchIncludeDir = getMultiarchTriple(D, getTriple(), SysRoot);771 if (!MultiarchIncludeDir.empty() &&772 D.getVFS().exists(concat(SysRoot, "/usr/include", MultiarchIncludeDir)))773 addExternCSystemInclude(774 DriverArgs, CC1Args,775 concat(SysRoot, "/usr/include", MultiarchIncludeDir));776 777 if (getTriple().getOS() == llvm::Triple::RTEMS)778 return;779 780 // Add an include of '/include' directly. This isn't provided by default by781 // system GCCs, but is often used with cross-compiling GCCs, and harmless to782 // add even when Clang is acting as-if it were a system compiler.783 addExternCSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/include"));784 785 addExternCSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/usr/include"));786 787 if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && getTriple().isMusl())788 addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);789}790 791void Linux::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,792 llvm::opt::ArgStringList &CC1Args) const {793 // We need a detected GCC installation on Linux to provide libstdc++'s794 // headers in odd Linuxish places.795 if (!GCCInstallation.isValid())796 return;797 798 // Try generic GCC detection first.799 if (Generic_GCC::addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args))800 return;801 802 StringRef LibDir = GCCInstallation.getParentLibPath();803 const Multilib &Multilib = GCCInstallation.getMultilib();804 const GCCVersion &Version = GCCInstallation.getVersion();805 806 StringRef TripleStr = GCCInstallation.getTriple().str();807 const std::string LibStdCXXIncludePathCandidates[] = {808 // Android standalone toolchain has C++ headers in yet another place.809 LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,810 // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,811 // without a subdirectory corresponding to the gcc version.812 LibDir.str() + "/../include/c++",813 // Cray's gcc installation puts headers under "g++" without a814 // version suffix.815 LibDir.str() + "/../include/g++",816 };817 818 for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {819 if (addLibStdCXXIncludePaths(IncludePath, TripleStr,820 Multilib.includeSuffix(), DriverArgs, CC1Args))821 break;822 }823}824 825void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,826 ArgStringList &CC1Args) const {827 CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);828}829 830void Linux::AddHIPIncludeArgs(const ArgList &DriverArgs,831 ArgStringList &CC1Args) const {832 RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);833}834 835void Linux::AddHIPRuntimeLibArgs(const ArgList &Args,836 ArgStringList &CmdArgs) const {837 CmdArgs.push_back(838 Args.MakeArgString(StringRef("-L") + RocmInstallation->getLibPath()));839 840 if (Args.hasFlag(options::OPT_frtlib_add_rpath,841 options::OPT_fno_rtlib_add_rpath, false)) {842 SmallString<0> p = RocmInstallation->getLibPath();843 llvm::sys::path::remove_dots(p, true);844 CmdArgs.append({"-rpath", Args.MakeArgString(p)});845 }846 847 CmdArgs.push_back("-lamdhip64");848}849 850void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,851 ArgStringList &CC1Args) const {852 if (GCCInstallation.isValid()) {853 CC1Args.push_back("-isystem");854 CC1Args.push_back(DriverArgs.MakeArgString(855 GCCInstallation.getParentLibPath() + "/../" +856 GCCInstallation.getTriple().str() + "/include"));857 }858}859 860void Linux::addSYCLIncludeArgs(const ArgList &DriverArgs,861 ArgStringList &CC1Args) const {862 SYCLInstallation->addSYCLIncludeArgs(DriverArgs, CC1Args);863}864 865bool Linux::isPIEDefault(const llvm::opt::ArgList &Args) const {866 return CLANG_DEFAULT_PIE_ON_LINUX || getTriple().isAndroid() ||867 getTriple().isMusl() || getSanitizerArgs(Args).requiresPIE();868}869 870bool Linux::IsAArch64OutlineAtomicsDefault(const ArgList &Args) const {871 // Outline atomics for AArch64 are supported by compiler-rt872 // and libgcc since 9.3.1873 assert(getTriple().isAArch64() && "expected AArch64 target!");874 ToolChain::RuntimeLibType RtLib = GetRuntimeLibType(Args);875 if (RtLib == ToolChain::RLT_CompilerRT)876 return true;877 assert(RtLib == ToolChain::RLT_Libgcc && "unexpected runtime library type!");878 if (GCCInstallation.getVersion().isOlderThan(9, 3, 1))879 return false;880 return true;881}882 883bool Linux::IsMathErrnoDefault() const {884 if (getTriple().isAndroid() || getTriple().isMusl())885 return false;886 return Generic_ELF::IsMathErrnoDefault();887}888 889SanitizerMask Linux::getSupportedSanitizers() const {890 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;891 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;892 const bool IsMIPS = getTriple().isMIPS32();893 const bool IsMIPS64 = getTriple().isMIPS64();894 const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||895 getTriple().getArch() == llvm::Triple::ppc64le;896 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||897 getTriple().getArch() == llvm::Triple::aarch64_be;898 const bool IsArmArch = getTriple().getArch() == llvm::Triple::arm ||899 getTriple().getArch() == llvm::Triple::thumb ||900 getTriple().getArch() == llvm::Triple::armeb ||901 getTriple().getArch() == llvm::Triple::thumbeb;902 const bool IsLoongArch64 = getTriple().getArch() == llvm::Triple::loongarch64;903 const bool IsRISCV64 = getTriple().getArch() == llvm::Triple::riscv64;904 const bool IsSystemZ = getTriple().getArch() == llvm::Triple::systemz;905 const bool IsHexagon = getTriple().getArch() == llvm::Triple::hexagon;906 const bool IsAndroid = getTriple().isAndroid();907 SanitizerMask Res = ToolChain::getSupportedSanitizers();908 Res |= SanitizerKind::Address;909 Res |= SanitizerKind::PointerCompare;910 Res |= SanitizerKind::PointerSubtract;911 Res |= SanitizerKind::Realtime;912 Res |= SanitizerKind::Fuzzer;913 Res |= SanitizerKind::FuzzerNoLink;914 Res |= SanitizerKind::KernelAddress;915 Res |= SanitizerKind::Vptr;916 Res |= SanitizerKind::SafeStack;917 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsLoongArch64)918 Res |= SanitizerKind::DataFlow;919 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64 ||920 IsRISCV64 || IsSystemZ || IsHexagon || IsLoongArch64)921 Res |= SanitizerKind::Leak;922 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64 || IsSystemZ ||923 IsLoongArch64 || IsRISCV64)924 Res |= SanitizerKind::Thread;925 if (IsX86_64 || IsAArch64 || IsSystemZ)926 Res |= SanitizerKind::Type;927 if (IsX86_64 || IsSystemZ || IsPowerPC64)928 Res |= SanitizerKind::KernelMemory;929 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||930 IsPowerPC64 || IsHexagon || IsLoongArch64 || IsRISCV64 || IsSystemZ)931 Res |= SanitizerKind::Scudo;932 if (IsX86_64 || IsAArch64 || IsRISCV64) {933 Res |= SanitizerKind::HWAddress;934 }935 if (IsX86_64 || IsAArch64) {936 Res |= SanitizerKind::KernelHWAddress;937 }938 if (IsX86_64)939 Res |= SanitizerKind::NumericalStability;940 if (!IsAndroid)941 Res |= SanitizerKind::Memory;942 943 // Work around "Cannot represent a difference across sections".944 if (getTriple().getArch() == llvm::Triple::ppc64)945 Res &= ~SanitizerKind::Function;946 return Res;947}948 949void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,950 llvm::opt::ArgStringList &CmdArgs) const {951 // Add linker option -u__llvm_profile_runtime to cause runtime952 // initialization module to be linked in.953 if (needsProfileRT(Args))954 CmdArgs.push_back(Args.MakeArgString(955 Twine("-u", llvm::getInstrProfRuntimeHookVarName())));956 ToolChain::addProfileRTLibs(Args, CmdArgs);957}958 959void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {960 for (const auto &Opt : ExtraOpts)961 CmdArgs.push_back(Opt.c_str());962}963 964const char *Linux::getDefaultLinker() const {965 if (getTriple().isAndroid())966 return "ld.lld";967 return Generic_ELF::getDefaultLinker();968}969