16#include "clang/Config/config.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>
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;
52 switch (TargetTriple.getArch()) {
60 case llvm::Triple::arm:
61 case llvm::Triple::thumb:
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:
78 return "i686-linux-android";
79 return "i386-linux-gnu";
80 case llvm::Triple::x86_64:
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:
88 return "aarch64-linux-android";
89 return "aarch64-linux-gnu";
90 case llvm::Triple::aarch64_be:
91 return "aarch64_be-linux-gnu";
93 case llvm::Triple::loongarch64: {
97 if (TargetTriple.isGNUEnvironment()) {
99 }
else if (TargetTriple.isMusl()) {
102 return TargetTriple.str();
105 switch (TargetEnvironment) {
107 return TargetTriple.str();
108 case llvm::Triple::GNUSF:
111 case llvm::Triple::GNUF32:
114 case llvm::Triple::GNU:
115 case llvm::Triple::GNUF64:
123 return (Twine(
"loongarch64-linux-") + Libc + FPFlavor).str();
126 case llvm::Triple::m68k:
127 return "m68k-linux-gnu";
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");
138 if (D.
getVFS().exists(
concat(SysRoot,
"/lib/mips64-linux-gnu")))
139 return "mips64-linux-gnu";
142 case llvm::Triple::mips64el: {
143 std::string MT = std::string(IsMipsR6 ?
"mipsisa64r6el" :
"mips64el") +
144 "-linux-" + (IsMipsN32Abi ?
"gnuabin32" :
"gnuabi64");
147 if (D.
getVFS().exists(
concat(SysRoot,
"/lib/mips64el-linux-gnu")))
148 return "mips64el-linux-gnu";
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:
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";
172 return TargetTriple.str();
175static StringRef
getOSLibDir(
const llvm::Triple &Triple,
const ArgList &Args) {
176 if (Triple.isMIPS()) {
177 if (Triple.isAndroid()) {
181 if (CPUName ==
"mips32r6")
183 if (CPUName ==
"mips32r2")
191 return Triple.isArch32Bit() ?
"lib" :
"lib64";
203 if (Triple.getArch() == llvm::Triple::x86 || Triple.isPPC32() ||
204 Triple.getArch() == llvm::Triple::sparc)
207 if (Triple.getArch() == llvm::Triple::x86_64 && Triple.isX32())
210 if (Triple.getArch() == llvm::Triple::riscv32)
213 return Triple.isArch32Bit() ?
"lib" :
"lib64";
221 llvm::Triple::ArchType Arch = Triple.getArch();
235 Triple.isAndroid()) {
242 if (Triple.isAndroid()) {
243 if (Triple.isARM()) {
246 ExtraOpts.push_back(
"max-page-size=4096");
247 }
else if (Triple.isAArch64() || Triple.getArch() == llvm::Triple::x86_64) {
251 ExtraOpts.push_back(
"max-page-size=16384");
263 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
266 const bool IsAndroid = Triple.isAndroid();
267 const bool IsMips = Triple.isMIPS();
268 const bool IsHexagon = Arch == llvm::Triple::hexagon;
269 const bool IsRISCV = Triple.isRISCV();
270 const bool IsCSKY = Triple.isCSKY();
275 if ((IsMips || IsCSKY) && !SysRoot.empty())
276 ExtraOpts.push_back(
"--sysroot=" + SysRoot);
284 if (!IsMips && !IsHexagon) {
287 (IsAndroid && Triple.isAndroidVersionLT(23)))
288 ExtraOpts.push_back(
"--hash-style=both");
293#ifdef ENABLE_LINKER_BUILD_ID
304 const std::string OSLibDir = std::string(
getOSLibDir(Triple, Args));
309 if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel) {
311 addPathIfExists(D,
concat(SysRoot,
"/libo32"), Paths);
312 addPathIfExists(D,
concat(SysRoot,
"/usr/libo32"), Paths);
316 addPathIfExists(D,
concat(SysRoot,
"/lib", MultiarchTriple), Paths);
317 addPathIfExists(D,
concat(SysRoot,
"/lib/..", OSLibDir), Paths);
325 concat(SysRoot,
"/usr/lib", MultiarchTriple,
326 llvm::to_string(Triple.getEnvironmentVersion().getMajor())),
330 addPathIfExists(D,
concat(SysRoot,
"/usr/lib", MultiarchTriple), Paths);
334 if (Triple.getVendor() == llvm::Triple::OpenEmbedded &&
335 Triple.isArch64Bit())
336 addPathIfExists(D,
concat(SysRoot,
"/usr", OSLibDir), Paths);
338 addPathIfExists(D,
concat(SysRoot,
"/usr/lib/..", OSLibDir), Paths);
341 addPathIfExists(D,
concat(SysRoot,
"/", OSLibDir, ABIName), Paths);
342 addPathIfExists(D,
concat(SysRoot,
"/usr", OSLibDir, ABIName), Paths);
347 addPathIfExists(D,
concat(SysRoot,
"/lib"), Paths);
348 addPathIfExists(D,
concat(SysRoot,
"/usr/lib"), Paths);
389 std::string AndroidSysRootPath = (ClangDir +
"/../sysroot").str();
390 if (
getVFS().exists(AndroidSysRootPath))
391 return AndroidSysRootPath;
397 return std::string();
404 if (
getVFS().exists(Path))
406 return std::string();
410 return std::string();
424 if (
getVFS().exists(Path))
429 if (
getVFS().exists(Path))
432 return std::string();
436 const llvm::Triple::ArchType Arch =
getArch();
437 const llvm::Triple &Triple =
getTriple();
441 if (Triple.isAndroid()) {
443 !Triple.isAndroidVersionLT(34) && Triple.isArch64Bit()) {
448 return "/system/bin/linker_hwasan64";
450 return Triple.isArch64Bit() ?
"/system/bin/linker64" :
"/system/bin/linker";
452 if (Triple.isMusl()) {
453 std::string ArchName;
457 case llvm::Triple::arm:
458 case llvm::Triple::thumb:
462 case llvm::Triple::armeb:
463 case llvm::Triple::thumbeb:
467 case llvm::Triple::x86:
470 case llvm::Triple::x86_64:
471 ArchName = Triple.isX32() ?
"x32" : Triple.getArchName().str();
474 ArchName = Triple.getArchName().str();
477 (Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
480 if (Arch == llvm::Triple::ppc &&
481 Triple.getSubArch() == llvm::Triple::PPCSubArch_spe)
482 ArchName =
"powerpc-sf";
484 return "/lib/ld-musl-" + ArchName +
".so.1";
492 llvm_unreachable(
"unsupported architecture");
494 case llvm::Triple::aarch64:
496 Loader =
"ld-linux-aarch64.so.1";
498 case llvm::Triple::aarch64_be:
500 Loader =
"ld-linux-aarch64_be.so.1";
502 case llvm::Triple::arm:
503 case llvm::Triple::thumb:
504 case llvm::Triple::armeb:
505 case llvm::Triple::thumbeb: {
507 Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
511 Loader = HF ?
"ld-linux-armhf.so.3" :
"ld-linux.so.3";
514 case llvm::Triple::loongarch32: {
517 (
"ld-linux-loongarch-" +
522 case llvm::Triple::loongarch64: {
525 (
"ld-linux-loongarch-" +
530 case llvm::Triple::m68k:
534 case llvm::Triple::mips:
535 case llvm::Triple::mipsel:
536 case llvm::Triple::mips64:
537 case llvm::Triple::mips64el: {
543 Loader = IsNaN2008 ?
"ld-uClibc-mipsn8.so.0" :
"ld-uClibc.so.0";
544 else if (!Triple.hasEnvironment() &&
545 Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
547 Triple.isLittleEndian() ?
"ld-musl-mipsel.so.1" :
"ld-musl-mips.so.1";
549 Loader = IsNaN2008 ?
"ld-linux-mipsn8.so.1" :
"ld.so.1";
553 case llvm::Triple::ppc:
557 case llvm::Triple::ppcle:
561 case llvm::Triple::ppc64:
566 case llvm::Triple::ppc64le:
571 case llvm::Triple::riscv32: {
574 Loader = (
"ld-linux-riscv32-" + ABIName +
".so.1").str();
577 case llvm::Triple::riscv64: {
580 Loader = (
"ld-linux-riscv64-" + ABIName +
".so.1").str();
583 case llvm::Triple::sparc:
584 case llvm::Triple::sparcel:
586 Loader =
"ld-linux.so.2";
588 case llvm::Triple::sparcv9:
590 Loader =
"ld-linux.so.2";
592 case llvm::Triple::systemz:
594 Loader =
"ld64.so.1";
596 case llvm::Triple::x86:
598 Loader =
"ld-linux.so.2";
600 case llvm::Triple::x86_64: {
601 bool X32 = Triple.isX32();
603 LibDir = X32 ?
"libx32" :
"lib64";
604 Loader = X32 ?
"ld-linux-x32.so.2" :
"ld-linux-x86-64.so.2";
607 case llvm::Triple::ve:
608 return "/opt/nec/ve/lib/ld-linux-ve.so.1";
609 case llvm::Triple::csky: {
617 (Triple.getVendor() == llvm::Triple::UnknownVendor ||
618 Triple.getVendor() == llvm::Triple::PC))
619 return "/usr/" + Triple.str() +
"/lib/" + Loader;
620 return "/" + LibDir +
"/" + Loader;
624 ArgStringList &CC1Args)
const {
628 if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
636 llvm::sys::path::append(ResourceDirInclude,
"include");
637 if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&
638 (!
getTriple().isMusl() || DriverArgs.hasArg(options::OPT_nostdlibinc)))
641 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
650 StringRef CIncludeDirs(C_INCLUDE_DIRS);
651 if (CIncludeDirs !=
"") {
653 CIncludeDirs.split(dirs,
":");
654 for (StringRef dir : dirs) {
656 llvm::sys::path::is_absolute(dir) ?
"" : StringRef(SysRoot);
665 if (!MultiarchIncludeDir.empty() &&
666 D.
getVFS().exists(
concat(SysRoot,
"/usr/include", MultiarchIncludeDir)))
669 concat(SysRoot,
"/usr/include", MultiarchIncludeDir));
681 if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&
getTriple().isMusl())
686 llvm::opt::ArgStringList &CC1Args)
const {
694 StringRef DebianMultiarch =
708 const std::string LibStdCXXIncludePathCandidates[] = {
710 LibDir.str() +
"/../" + TripleStr.str() +
"/include/c++/" + Version.
Text,
713 LibDir.str() +
"/../include/c++",
716 LibDir.str() +
"/../include/g++",
719 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
727 ArgStringList &CC1Args)
const {
732 ArgStringList &CC1Args)
const {
737 ArgStringList &CmdArgs)
const {
741 if (Args.hasFlag(options::OPT_frtlib_add_rpath,
742 options::OPT_fno_rtlib_add_rpath,
false))
746 CmdArgs.push_back(
"-lamdhip64");
750 ArgStringList &CC1Args)
const {
752 CC1Args.push_back(
"-isystem");
753 CC1Args.push_back(DriverArgs.MakeArgString(
760 return CLANG_DEFAULT_PIE_ON_LINUX ||
getTriple().isAndroid() ||
767 assert(
getTriple().isAArch64() &&
"expected AArch64 target!");
784 const bool IsX86 =
getTriple().getArch() == llvm::Triple::x86;
785 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
786 const bool IsMIPS =
getTriple().isMIPS32();
787 const bool IsMIPS64 =
getTriple().isMIPS64();
788 const bool IsPowerPC64 =
getTriple().getArch() == llvm::Triple::ppc64 ||
789 getTriple().getArch() == llvm::Triple::ppc64le;
790 const bool IsAArch64 =
getTriple().getArch() == llvm::Triple::aarch64 ||
791 getTriple().getArch() == llvm::Triple::aarch64_be;
792 const bool IsArmArch =
getTriple().getArch() == llvm::Triple::arm ||
793 getTriple().getArch() == llvm::Triple::thumb ||
794 getTriple().getArch() == llvm::Triple::armeb ||
795 getTriple().getArch() == llvm::Triple::thumbeb;
796 const bool IsLoongArch64 =
getTriple().getArch() == llvm::Triple::loongarch64;
797 const bool IsRISCV64 =
getTriple().getArch() == llvm::Triple::riscv64;
798 const bool IsSystemZ =
getTriple().getArch() == llvm::Triple::systemz;
799 const bool IsHexagon =
getTriple().getArch() == llvm::Triple::hexagon;
801 Res |= SanitizerKind::Address;
802 Res |= SanitizerKind::PointerCompare;
803 Res |= SanitizerKind::PointerSubtract;
804 Res |= SanitizerKind::Fuzzer;
805 Res |= SanitizerKind::FuzzerNoLink;
806 Res |= SanitizerKind::KernelAddress;
807 Res |= SanitizerKind::Memory;
808 Res |= SanitizerKind::Vptr;
809 Res |= SanitizerKind::SafeStack;
810 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsLoongArch64)
811 Res |= SanitizerKind::DataFlow;
812 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsArmArch || IsPowerPC64 ||
813 IsRISCV64 || IsSystemZ || IsHexagon || IsLoongArch64)
814 Res |= SanitizerKind::Leak;
815 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64 || IsSystemZ ||
816 IsLoongArch64 || IsRISCV64)
817 Res |= SanitizerKind::Thread;
818 if (IsX86_64 || IsSystemZ)
819 Res |= SanitizerKind::KernelMemory;
820 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||
821 IsPowerPC64 || IsHexagon || IsLoongArch64 || IsRISCV64)
822 Res |= SanitizerKind::Scudo;
823 if (IsX86_64 || IsAArch64 || IsRISCV64) {
824 Res |= SanitizerKind::HWAddress;
826 if (IsX86_64 || IsAArch64) {
827 Res |= SanitizerKind::KernelHWAddress;
836 llvm::opt::ArgStringList &CmdArgs)
const {
840 CmdArgs.push_back(Args.MakeArgString(
841 Twine(
"-u", llvm::getInstrProfRuntimeHookVarName())));
847 CmdArgs.push_back(Opt.c_str());
static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args)
Distro - Helper class for detecting and classifying Linux distributions.
bool IsAlpineLinux() const
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
std::string ResourceDir
The path to the compiler resource directory.
llvm::vfs::FileSystem & getVFS() const
std::string Dir
The path the driver executable was in, as invoked from the command line.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
const std::string & includeSuffix() const
Get the include directory suffix.
The JSON file list parser is used to communicate input to InstallAPI.