20#include "clang/Config/config.h"
29#include "llvm/ADT/SmallString.h"
30#include "llvm/ADT/StringExtras.h"
31#include "llvm/ADT/StringRef.h"
32#include "llvm/ADT/Twine.h"
33#include "llvm/Config/llvm-config.h"
34#include "llvm/MC/MCTargetOptions.h"
35#include "llvm/MC/TargetRegistry.h"
36#include "llvm/Option/Arg.h"
37#include "llvm/Option/ArgList.h"
38#include "llvm/Option/OptTable.h"
39#include "llvm/Option/Option.h"
40#include "llvm/Support/ErrorHandling.h"
41#include "llvm/Support/FileSystem.h"
42#include "llvm/Support/FileUtilities.h"
43#include "llvm/Support/MemoryBuffer.h"
44#include "llvm/Support/Path.h"
45#include "llvm/Support/Process.h"
46#include "llvm/Support/VersionTuple.h"
47#include "llvm/Support/VirtualFileSystem.h"
48#include "llvm/TargetParser/AArch64TargetParser.h"
49#include "llvm/TargetParser/AMDGPUTargetParser.h"
50#include "llvm/TargetParser/RISCVISAInfo.h"
51#include "llvm/TargetParser/TargetParser.h"
52#include "llvm/TargetParser/Triple.h"
65 return Args.getLastArg(options::OPT_mkernel, options::OPT_fapple_kext,
66 options::OPT_fno_rtti, options::OPT_frtti);
70 const llvm::Triple &Triple,
71 const Arg *CachedRTTIArg) {
74 if (CachedRTTIArg->getOption().matches(options::OPT_frtti))
81 bool NoRTTI = Triple.isPS() || Triple.isDriverKit();
86 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
98 assert(
T.str() ==
T.normalize() &&
"triple should be normalized");
99 auto addIfExists = [
this](
path_list &List,
const std::string &Path) {
100 if (
getVFS().exists(Path))
101 List.push_back(Path);
121 const Driver &D, StringRef Fallback) {
122 std::optional<std::string> MultilibPath =
126 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =
127 D.getVFS().getBufferForFile(*MultilibPath);
132 llvm::ErrorOr<MultilibSet> ErrorOrMultilibSet =
134 if (ErrorOrMultilibSet.getError())
137 Multilibs = std::move(ErrorOrMultilibSet.get());
146 for (StringRef Define : CustomFlagMacroDefines)
150 D.Diag(clang::diag::warn_drv_missing_multilib) << llvm::join(Flags,
" ");
152 raw_svector_ostream OS(
Data);
155 OS <<
"\n" << llvm::join(M.flags(),
" ");
156 D.Diag(clang::diag::note_drv_available_multilibs) << OS.str();
160 D.Diag(clang::diag::err_drv_multilib_custom_error)
161 << M.getErrorMessage();
169 StringRef YAMLBase = llvm::sys::path::parent_path(*MultilibPath);
171 size_t FileInsertPos = 0;
172 size_t LibInsertPos = 0;
177 llvm::sys::path::append(FilePath, M.gccSuffix());
179 std::string(FilePath));
185 llvm::sys::path::append(LibPath, M.gccSuffix());
187 std::string(LibPath));
195std::optional<std::string>
197 StringRef FallbackDir) {
198 if (Arg *A = Args.getLastArg(options::OPT_multi_lib_config)) {
200 if (!D.getVFS().exists(MultilibPath)) {
201 D.Diag(clang::diag::err_drv_no_such_file) << MultilibPath.str();
204 return std::string(MultilibPath);
208 if (!FallbackDir.empty())
209 MultilibPath = FallbackDir;
210 else if (std::optional<std::string> StdlibDir =
getStdlibPath())
211 MultilibPath = *StdlibDir;
214 llvm::sys::path::append(MultilibPath,
"multilib.yaml");
215 if (!D.getVFS().exists(MultilibPath))
217 return std::string(MultilibPath);
221 Triple.setEnvironment(Env);
222 if (EffectiveTriple != llvm::Triple())
223 EffectiveTriple.setEnvironment(Env);
233 return Args.hasFlag(options::OPT_fintegrated_as,
234 options::OPT_fno_integrated_as,
242 "(Non-)integrated backend set incorrectly!");
244 bool IBackend = Args.hasFlag(options::OPT_fintegrated_objemitter,
245 options::OPT_fno_integrated_objemitter,
253 DiagID = clang::diag::err_drv_unsupported_opt_for_target;
255 DiagID = clang::diag::warn_drv_unsupported_opt_for_target;
256 Arg *A = Args.getLastArg(options::OPT_fno_integrated_objemitter);
258 D.Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
259 A = Args.getLastArg(options::OPT_fintegrated_objemitter);
261 D.Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
267 return ENABLE_X86_RELAX_RELOCATIONS;
271 return PPC_LINUX_DEFAULT_IEEELONGDOUBLE &&
getTriple().isOSLinux();
275 const llvm::opt::ArgList &Args) {
276 for (
const Arg *MultilibFlagArg :
277 Args.filtered(options::OPT_fmultilib_flag)) {
278 List.push_back(MultilibFlagArg->getAsString(Args));
279 MultilibFlagArg->claim();
284 const llvm::Triple &Triple,
285 const llvm::opt::ArgList &Args,
287 std::vector<StringRef> Features;
292 llvm::DenseSet<StringRef> FeatureSet(UnifiedFeatures.begin(),
293 UnifiedFeatures.end());
294 std::vector<std::string> MArch;
295 for (
const auto &Ext : AArch64::Extensions)
296 if (Ext.UserVisibleName.value())
297 if (FeatureSet.contains(AArch64::StrTab[Ext.PosTargetFeature]))
298 MArch.push_back(AArch64::StrTab[Ext.UserVisibleName].str());
299 for (
const auto &Ext : AArch64::Extensions)
300 if (Ext.UserVisibleName.value())
301 if (FeatureSet.contains(AArch64::StrTab[Ext.NegTargetFeature]))
302 MArch.push_back((
"no" + AArch64::StrTab[Ext.UserVisibleName]).str());
304 for (
const auto &ArchInfo : AArch64::ArchInfos)
305 if (FeatureSet.contains(AArch64::StrTab[ArchInfo.ArchFeature]))
306 ArchName = AArch64::StrTab[ArchInfo.Name];
307 if (!ArchName.empty()) {
308 MArch.insert(MArch.begin(), (
"-march=" + ArchName).str());
309 Result.push_back(llvm::join(MArch,
"+"));
312 const Arg *BranchProtectionArg =
313 Args.getLastArgNoClaim(options::OPT_mbranch_protection_EQ);
314 if (BranchProtectionArg) {
315 Result.push_back(BranchProtectionArg->getAsString(Args));
318 if (FeatureSet.contains(
"+strict-align"))
319 Result.push_back(
"-mno-unaligned-access");
321 Result.push_back(
"-munaligned-access");
323 if (Arg *Endian = Args.getLastArg(options::OPT_mbig_endian,
324 options::OPT_mlittle_endian)) {
325 if (Endian->getOption().matches(options::OPT_mbig_endian))
326 Result.push_back(Endian->getAsString(Args));
329 const Arg *ABIArg = Args.getLastArgNoClaim(options::OPT_mabi_EQ);
331 Result.push_back(ABIArg->getAsString(Args));
334 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group);
335 A && A->getOption().matches(options::OPT_O)) {
336 switch (A->getValue()[0]) {
348 llvm::Reloc::Model RelocationModel,
349 const llvm::opt::ArgList &Args,
351 std::vector<StringRef> Features;
353 D, Triple, Args, Features,
false ,
true );
355 llvm::DenseSet<StringRef> FeatureSet(UnifiedFeatures.begin(),
356 UnifiedFeatures.end());
357 std::vector<std::string> MArch;
358 for (
const auto &Ext : ARM::ARCHExtNames)
359 if (!Ext.Name.empty())
360 if (FeatureSet.contains(Ext.Feature))
361 MArch.push_back(Ext.Name.str());
362 for (
const auto &Ext : ARM::ARCHExtNames)
363 if (!Ext.Name.empty())
364 if (FeatureSet.contains(Ext.NegFeature))
365 MArch.push_back((
"no" + Ext.Name).str());
366 MArch.insert(MArch.begin(), (
"-march=" + Triple.getArchName()).str());
367 Result.push_back(llvm::join(MArch,
"+"));
370#define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) \
371 case llvm::ARM::KIND: \
372 Result.push_back("-mfpu=" NAME); \
374#include "llvm/TargetParser/ARMTargetParser.def"
376 llvm_unreachable(
"Invalid FPUKind");
380 case arm::FloatABI::Soft:
381 Result.push_back(
"-mfloat-abi=soft");
383 case arm::FloatABI::SoftFP:
384 Result.push_back(
"-mfloat-abi=softfp");
386 case arm::FloatABI::Hard:
387 Result.push_back(
"-mfloat-abi=hard");
389 case arm::FloatABI::Invalid:
390 llvm_unreachable(
"Invalid float ABI");
393 if (RelocationModel == llvm::Reloc::ROPI ||
394 RelocationModel == llvm::Reloc::ROPI_RWPI)
395 Result.push_back(
"-fropi");
397 Result.push_back(
"-fno-ropi");
399 if (RelocationModel == llvm::Reloc::RWPI ||
400 RelocationModel == llvm::Reloc::ROPI_RWPI)
401 Result.push_back(
"-frwpi");
403 Result.push_back(
"-fno-rwpi");
405 const Arg *BranchProtectionArg =
406 Args.getLastArgNoClaim(options::OPT_mbranch_protection_EQ);
407 if (BranchProtectionArg) {
408 Result.push_back(BranchProtectionArg->getAsString(Args));
411 if (FeatureSet.contains(
"+strict-align"))
412 Result.push_back(
"-mno-unaligned-access");
414 Result.push_back(
"-munaligned-access");
416 if (Arg *Endian = Args.getLastArg(options::OPT_mbig_endian,
417 options::OPT_mlittle_endian)) {
418 if (Endian->getOption().matches(options::OPT_mbig_endian))
419 Result.push_back(Endian->getAsString(Args));
422 if (
const Arg *A = Args.getLastArg(options::OPT_O_Group);
423 A && A->getOption().matches(options::OPT_O)) {
424 switch (A->getValue()[0]) {
436 const llvm::opt::ArgList &Args,
438 bool hasShadowCallStack) {
441 auto ISAInfo = llvm::RISCVISAInfo::parseArchString(
443 if (!llvm::errorToBool(ISAInfo.takeError()))
444 Result.push_back(
"-march=" + (*ISAInfo)->toString());
448 if (hasShadowCallStack)
449 Result.push_back(
"-fsanitize=shadow-call-stack");
451 Result.push_back(
"-fno-sanitize=shadow-call-stack");
453 const Arg *CFProtectionArg =
454 Args.getLastArgNoClaim(options::OPT_fcf_protection_EQ);
455 StringRef CFProtectionVal =
456 CFProtectionArg ? CFProtectionArg->getValue() :
"none";
457 Result.push_back((
"-fcf-protection=" + CFProtectionVal).str());
459 if (CFProtectionVal ==
"branch" || CFProtectionVal ==
"full") {
460 if (
const Arg *SchemeArg =
461 Args.getLastArgNoClaim(options::OPT_mcf_branch_label_scheme_EQ))
462 Result.push_back(SchemeArg->getAsString(Args));
470 std::vector<std::string>
Result;
472 Result.push_back(
"--target=" + Triple.str());
478 llvm::Reloc::Model RelocationModel;
483 std::tie(RelocationModel, PICLevel, IsPIE) =
ParsePICArgs(*
this, Args);
486 switch (Triple.getArch()) {
487 case llvm::Triple::aarch64:
488 case llvm::Triple::aarch64_32:
489 case llvm::Triple::aarch64_be:
492 case llvm::Triple::arm:
493 case llvm::Triple::armeb:
494 case llvm::Triple::thumb:
495 case llvm::Triple::thumbeb:
498 case llvm::Triple::riscv32:
499 case llvm::Triple::riscv64:
500 case llvm::Triple::riscv32be:
501 case llvm::Triple::riscv64be:
511 if (Arg *CStdLibArg = Args.getLastArg(options::OPT_cstdlib_EQ))
512 Result.push_back(std::string(CStdLibArg->getOption().getPrefixedName()) +
513 CStdLibArg->getValue());
518 Result.push_back(
"-fno-rtti");
520 Result.push_back(
"-frtti");
523 Result.push_back(
"-fno-exceptions");
525 Result.push_back(
"-fexceptions");
527 if (RelocationModel == llvm::Reloc::PIC_)
528 Result.push_back(IsPIE ? (PICLevel > 1 ?
"-fPIE" :
"-fpie")
529 : (PICLevel > 1 ?
"-fPIC" :
"-fpic"));
531 Result.push_back(
"-fno-pic");
545 bool DiagnoseBoundArchErrors =
546 BoundArchSanitizerArgsChecked.insert(BA.
ArchName).second;
548 !JobArgs.hasFlag(options::OPT_fgpu_sanitize,
549 options::OPT_fno_gpu_sanitize,
true)) {
550 DiagnoseBoundArchErrors =
false;
554 !SanitizerArgsChecked,
555 DiagnoseBoundArchErrors, BA, DeviceOffloadKind);
557 SanitizerArgsChecked =
true;
562 XRayArgs XRayArguments(*
this, JobArgs);
563 return XRayArguments;
570 const char *ModeFlag;
579 static const DriverSuffix DriverSuffixes[] = {
581 {
"clang++",
"--driver-mode=g++"},
582 {
"clang-c++",
"--driver-mode=g++"},
583 {
"clang-cc",
nullptr},
584 {
"clang-cpp",
"--driver-mode=cpp"},
585 {
"clang-g++",
"--driver-mode=g++"},
586 {
"clang-gcc",
nullptr},
587 {
"clang-cl",
"--driver-mode=cl"},
589 {
"cpp",
"--driver-mode=cpp"},
590 {
"cl",
"--driver-mode=cl"},
591 {
"++",
"--driver-mode=g++"},
592 {
"flang",
"--driver-mode=flang"},
595 {
"flang-new",
"--driver-mode=flang"},
596 {
"clang-dxc",
"--driver-mode=dxc"},
599 for (
const auto &DS : DriverSuffixes) {
600 StringRef Suffix(DS.Suffix);
601 if (ProgName.ends_with(Suffix)) {
602 Pos = ProgName.size() - Suffix.size();
612 std::string ProgName = std::string(llvm::sys::path::filename(Argv0));
613 if (is_style_windows(llvm::sys::path::Style::native)) {
615 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),
631 if (!DS && ProgName.ends_with(
".exe")) {
634 ProgName = ProgName.drop_back(StringRef(
".exe").size());
641 ProgName = ProgName.rtrim(
"0123456789.");
648 ProgName = ProgName.slice(0, ProgName.rfind(
'-'));
661 size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);
663 size_t LastComponent = ProgName.rfind(
'-', SuffixPos);
664 if (LastComponent == std::string::npos)
666 std::string ModeSuffix = ProgName.substr(LastComponent + 1,
667 SuffixEnd - LastComponent - 1);
670 StringRef Prefix(ProgName);
671 Prefix = Prefix.slice(0, LastComponent);
672 std::string IgnoredError;
674 llvm::Triple Triple(Prefix);
675 bool IsRegistered = llvm::TargetRegistry::lookupTarget(Triple, IgnoredError);
684 switch (Triple.getArch()) {
685 case llvm::Triple::aarch64: {
690 case llvm::Triple::aarch64_32:
692 case llvm::Triple::ppc:
694 case llvm::Triple::ppcle:
696 case llvm::Triple::ppc64:
698 case llvm::Triple::ppc64le:
701 return Triple.getArchName();
714Tool *ToolChain::getClang()
const {
720Tool *ToolChain::getFlang()
const {
731 llvm_unreachable(
"Linking is not supported by this toolchain");
735 llvm_unreachable(
"Creating static lib is not supported by this toolchain");
738Tool *ToolChain::getAssemble()
const {
741 return Assemble.get();
744Tool *ToolChain::getClangAs()
const {
747 return Assemble.get();
750Tool *ToolChain::getLink()
const {
756Tool *ToolChain::getStaticLibTool()
const {
759 return StaticLibTool.get();
762Tool *ToolChain::getIfsMerge()
const {
764 IfsMerge.reset(
new tools::ifstool::Merger(*
this));
765 return IfsMerge.get();
768Tool *ToolChain::getOffloadBundler()
const {
770 OffloadBundler.reset(
new tools::OffloadBundler(*
this));
771 return OffloadBundler.get();
774Tool *ToolChain::getOffloadPackager()
const {
775 if (!OffloadPackager)
776 OffloadPackager.reset(
new tools::OffloadPackager(*
this));
777 return OffloadPackager.get();
780Tool *ToolChain::getLinkerWrapper()
const {
782 LinkerWrapper.reset(
new tools::LinkerWrapper(*
this, getLink()));
783 return LinkerWrapper.get();
789 return getAssemble();
792 return getIfsMerge();
798 return getStaticLibTool();
809 llvm_unreachable(
"Invalid tool kind.");
821 return getOffloadBundler();
824 return getOffloadPackager();
826 return getLinkerWrapper();
829 llvm_unreachable(
"Invalid tool kind.");
833 const ArgList &Args) {
834 const llvm::Triple &Triple = TC.
getTriple();
835 bool IsWindows = Triple.isOSWindows();
838 return Triple.getArchName();
840 if (TC.
getArch() == llvm::Triple::arm || TC.
getArch() == llvm::Triple::armeb)
846 if (TC.
getArch() == llvm::Triple::x86 && Triple.isAndroid())
849 if (TC.
getArch() == llvm::Triple::x86_64 && Triple.isX32())
852 return llvm::Triple::getArchTypeName(TC.
getArch());
856 if (Triple.isOSDarwin())
858 if (Triple.isWindowsCygwinEnvironment())
861 switch (Triple.getOS()) {
862 case llvm::Triple::FreeBSD:
864 case llvm::Triple::NetBSD:
866 case llvm::Triple::OpenBSD:
868 case llvm::Triple::Solaris:
870 case llvm::Triple::AIX:
872 case llvm::Triple::Serenity:
888 }
else if (Triple.isOSUnknown()) {
889 llvm::sys::path::append(Path,
"lib");
893 return std::string(Path);
900 return llvm::sys::path::filename(CRTAbsolutePath).str();
906 bool IsFortran)
const {
908 bool IsITANMSVCWindows =
909 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();
916 Suffix = IsITANMSVCWindows ?
".obj" :
".o";
919 Suffix = IsITANMSVCWindows ?
".lib" :
".a";
922 if (TT.isOSWindows())
923 Suffix = TT.isOSCygMing() ?
".dll.a" :
".lib";
924 else if (TT.isOSAIX())
931 std::string ArchAndEnv;
934 const char *Env = TT.isAndroid() ?
"-android" :
"";
935 ArchAndEnv = (
"-" +
Arch + Env).str();
938 std::string LibName = IsFortran ?
"flang_rt." :
"clang_rt.";
939 return (Prefix + Twine(LibName) + Component + ArchAndEnv + Suffix).str();
946 Args, Component,
Type,
false, IsFortran);
950 llvm::sys::path::append(P, CRTBasename);
952 return std::string(P);
959 !IsFortran, IsFortran);
961 llvm::sys::path::append(OldPath, CRTBasename);
962 if (Path.empty() ||
getVFS().exists(OldPath))
963 return std::string(OldPath);
968 return std::string(Path);
974 bool isFortran)
const {
980 llvm::opt::ArgStringList &CmdArgs)
const {
985 if (!
getTriple().isKnownWindowsMSVCEnvironment()) {
987 F128LibName.consume_front_insensitive(
"lib");
988 if (!F128LibName.empty()) {
990 CmdArgs.push_back(
"-lflang_rt.quadmath");
993 CmdArgs.push_back(Args.MakeArgString(
"-l" + F128LibName));
1002 CmdArgs.push_back(
"-lexecinfo");
1006 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
1007 options::OPT_fno_openmp,
false)) {
1012 !
getTriple().isKnownWindowsMSVCEnvironment()) {
1014 CmdArgs.push_back(
"-lcompiler_rt");
1016 CmdArgs.push_back(
"-latomic");
1022 ArgStringList &CmdArgs)
const {
1023 auto AddLibSearchPathIfExists = [&](
const Twine &Path) {
1025 if (!llvm::sys::fs::is_directory(Path))
1028 if (
getTriple().isKnownWindowsMSVCEnvironment())
1029 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + Path));
1031 CmdArgs.push_back(Args.MakeArgString(
"-L" + Path));
1044 llvm::sys::path::parent_path(
getDriver().Dir);
1045 llvm::sys::path::append(DefaultLibPath,
"lib");
1046 AddLibSearchPathIfExists(DefaultLibPath);
1050 llvm::opt::ArgStringList &CmdArgs)
const {
1053 if (Args.hasFlag(options::OPT_static_libflangrt,
1054 options::OPT_shared_libflangrt,
getTriple().isOSAIX()))
1058 CmdArgs.push_back(
"-lflang_rt.runtime");
1064std::optional<std::string>
1065ToolChain::getFallbackAndroidTargetPath(StringRef BaseDir)
const {
1066 llvm::Triple TripleWithoutLevel(
getTriple());
1067 TripleWithoutLevel.setEnvironmentName(
"android");
1068 const std::string &TripleWithoutLevelStr = TripleWithoutLevel.str();
1069 unsigned TripleVersion =
getTriple().getEnvironmentVersion().getMajor();
1070 unsigned BestVersion = 0;
1073 bool UsingUnversionedDir =
false;
1075 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(BaseDir, EC), LE;
1076 !EC && LI != LE; LI = LI.increment(EC)) {
1077 StringRef DirName = llvm::sys::path::filename(LI->path());
1078 StringRef DirNameSuffix = DirName;
1079 if (DirNameSuffix.consume_front(TripleWithoutLevelStr)) {
1080 if (DirNameSuffix.empty() && TripleDir.empty()) {
1081 TripleDir = DirName;
1082 UsingUnversionedDir =
true;
1085 if (!DirNameSuffix.getAsInteger(10, Version) && Version > BestVersion &&
1086 Version < TripleVersion) {
1087 BestVersion = Version;
1088 TripleDir = DirName;
1089 UsingUnversionedDir =
false;
1095 if (TripleDir.empty())
1098 SmallString<128> P(BaseDir);
1099 llvm::sys::path::append(P, TripleDir);
1100 if (UsingUnversionedDir)
1101 D.Diag(diag::warn_android_unversioned_fallback) << P <<
getTripleString();
1102 return std::string(P);
1106 return (Triple.hasEnvironment()
1107 ? llvm::Triple(Triple.getArchName(), Triple.getVendorName(),
1108 llvm::Triple::getOSTypeName(Triple.getOS()),
1109 llvm::Triple::getEnvironmentTypeName(
1110 Triple.getEnvironment()))
1111 : llvm::Triple(Triple.getArchName(), Triple.getVendorName(),
1112 llvm::Triple::getOSTypeName(Triple.getOS())));
1115std::optional<std::string>
1117 auto getPathForTriple =
1118 [&](
const llvm::Triple &Triple) -> std::optional<std::string> {
1120 llvm::sys::path::append(P, Triple.str());
1122 return std::string(P);
1127 if (
auto Path = getPathForTriple(
T))
1133 llvm::Triple AMDGPUTriple =
T;
1134 AMDGPUTriple.setArch(Triple::amdgpu);
1135 if (
auto Path = getPathForTriple(AMDGPUTriple))
1139 AMDGPUTriple.setArchName(
"amdgcn");
1140 if (
auto Path = getPathForTriple(AMDGPUTriple))
1147 llvm::Triple SPIRVTriple(
1148 T.normalize(llvm::Triple::CanonicalForm::THREE_IDENT));
1149 if (
auto Path = getPathForTriple(SPIRVTriple))
1154 llvm::Triple AIXTriple;
1155 if (
T.getEnvironment() == Triple::UnknownEnvironment) {
1157 AIXTriple = llvm::Triple(
T.getArchName(),
T.getVendorName(),
1158 llvm::Triple::getOSTypeName(
T.getOS()));
1163 if (
auto Path = getPathForTriple(AIXTriple))
1168 (!
T.getOSVersion().empty() || !
T.getEnvironmentVersion().empty())) {
1171 if (
auto Path = getPathForTriple(TripleWithoutVersion))
1190 if (
T.getArch() == Triple::arm && !
T.isArmMClass()) {
1191 llvm::Triple ArmTriple =
T;
1192 ArmTriple.setArch(Triple::arm);
1193 if (
auto Path = getPathForTriple(ArmTriple))
1198 return getFallbackAndroidTargetPath(BaseDir);
1205 llvm::sys::path::append(P,
"finclude",
"flang");
1211 llvm::sys::path::append(P,
"lib");
1215 if (Triple.isOSDarwin())
1218 llvm::sys::path::append(P, Triple.str());
1219 return std::string(P);
1224 llvm::sys::path::append(P,
"..",
"lib");
1230 llvm::sys::path::append(P,
"..",
"include");
1239 llvm::sys::path::append(Path,
"lib");
1241 llvm::sys::path::append(Path, S);
1242 Paths.push_back(std::string(Path));
1254 for (StringRef ArchName : {
"amdgpu",
"amdgcn"}) {
1257 Canon.setArchName(ArchName);
1258 AddPath({Canon.str()});
1267 if (Args.hasArg(options::OPT_noprofilelib))
1270 return Args.hasArg(options::OPT_fprofile_generate) ||
1271 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
1272 Args.hasArg(options::OPT_fcs_profile_generate) ||
1273 Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||
1274 Args.hasArg(options::OPT_fprofile_instr_generate) ||
1275 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
1276 Args.hasArg(options::OPT_fcreate_profile) ||
1277 Args.hasArg(options::OPT_fprofile_generate_cold_function_coverage) ||
1278 Args.hasArg(options::OPT_fprofile_generate_cold_function_coverage_EQ);
1282 return Args.hasArg(options::OPT_coverage) ||
1283 Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
1288 if (D.IsFlangMode() &&
getDriver().ShouldUseFlangCompiler(JA))
return getFlang();
1289 if (
getDriver().ShouldUseClangCompiler(JA))
return getClang();
1293 return getClangAs();
1298 return D.GetFilePath(Name, *
this);
1301std::optional<std::string>
1303 std::string Path = D.GetFilePath(Name, *
this);
1305 return std::nullopt;
1310 return D.GetProgramPath(Name, *
this);
1315 *LinkerIsLLD =
false;
1319 const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
1327 if (
const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {
1328 std::string Path(A->getValue());
1329 if (!Path.empty()) {
1330 if (llvm::sys::path::parent_path(Path).empty())
1332 if (llvm::sys::fs::can_execute(Path)) {
1334 *LinkerIsLLD = UseLinker ==
"lld";
1335 return std::string(Path);
1338 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
1343 if (UseLinker.empty() || UseLinker ==
"ld") {
1345 if (llvm::sys::path::is_absolute(DefaultLinker))
1346 return std::string(DefaultLinker);
1355 if (UseLinker.contains(
'/'))
1358 if (llvm::sys::path::is_absolute(UseLinker)) {
1361 if (llvm::sys::fs::can_execute(UseLinker))
1362 return std::string(UseLinker);
1365 if (Triple.isOSDarwin())
1366 LinkerName.append(
"ld64.");
1368 LinkerName.append(
"ld.");
1369 LinkerName.append(UseLinker);
1372 if (llvm::sys::fs::can_execute(LinkerPath)) {
1374 *LinkerIsLLD = UseLinker ==
"lld";
1380 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
1387 if (Triple.isOSDarwin())
1398 if (D.IsFlangMode() &&
id == types::TY_PP_Fortran)
1399 id = types::TY_Fortran;
1416 llvm::opt::OptSpecifier OptEq,
1417 llvm::opt::OptSpecifier OptNeg) {
1418 if (!Args.hasFlag(OptEq, OptNeg,
false))
1421 const Arg *A = Args.getLastArg(OptEq);
1422 StringRef LTOName = A->getValue();
1424 return llvm::StringSwitch<LTOKind>(LTOName)
1434 auto OptEq = IsOffload ? options::OPT_foffload_lto_EQ : options::OPT_flto_EQ;
1435 auto OptNeg = IsOffload ? options::OPT_fno_offload_lto : options::OPT_fno_lto;
1439 if (IsOffload && Args.hasFlag(options::OPT_fopenmp_target_jit,
1440 options::OPT_fno_openmp_target_jit,
false)) {
1441 if (Arg *A = Args.getLastArg(OptEq, OptNeg))
1444 << A->getSpelling() <<
"-fopenmp-target-jit";
1448 if (!Args.hasArg(OptEq, OptNeg))
1454 const Arg *A = Args.getLastArg(OptEq);
1456 << A->getSpelling() << A->getValue();
1463 llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
1464 switch (HostTriple.getArch()) {
1467 case llvm::Triple::arm:
1468 case llvm::Triple::armeb:
1469 case llvm::Triple::thumb:
1470 case llvm::Triple::thumbeb:
1471 return getArch() != llvm::Triple::arm &&
getArch() != llvm::Triple::thumb &&
1472 getArch() != llvm::Triple::armeb &&
getArch() != llvm::Triple::thumbeb;
1474 return HostTriple.getArch() !=
getArch();
1483llvm::ExceptionHandling
1485 return llvm::ExceptionHandling::Default;
1489 if (Model ==
"single") {
1491 return Triple.getArch() == llvm::Triple::arm ||
1492 Triple.getArch() == llvm::Triple::armeb ||
1493 Triple.getArch() == llvm::Triple::thumb ||
1494 Triple.getArch() == llvm::Triple::thumbeb || Triple.isWasm();
1495 }
else if (Model ==
"posix")
1507 case llvm::Triple::x86_64: {
1509 if (!Triple.isOSBinFormatMachO())
1512 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1515 StringRef MArch = A->getValue();
1516 if (MArch ==
"x86_64h")
1517 Triple.setArchName(MArch);
1519 return Triple.getTriple();
1521 case llvm::Triple::aarch64: {
1523 if (!Triple.isOSBinFormatMachO())
1524 return Triple.getTriple();
1526 if (Triple.isArm64e())
1527 return Triple.getTriple();
1532 Triple.setArchName(
"arm64");
1533 return Triple.getTriple();
1535 case llvm::Triple::aarch64_32:
1537 case llvm::Triple::amdgpu: {
1541 return Triple.getTriple();
1543 case llvm::Triple::arm:
1544 case llvm::Triple::armeb:
1545 case llvm::Triple::thumb:
1546 case llvm::Triple::thumbeb: {
1551 return Triple.getTriple();
1567 ArgStringList &CC1Args)
const {
1572 const ArgList &DriverArgs, ArgStringList &CC1Args,
BoundArch BA,
1576 ArgStringList &CC1ASArgs)
const {}
1581 llvm::opt::ArgStringList &CmdArgs)
const {
1589 const ArgList &Args)
const {
1591 return *runtimeLibType;
1593 const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);
1594 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;
1597 if (LibName ==
"compiler-rt")
1599 else if (LibName ==
"libgcc")
1601 else if (LibName ==
"platform")
1606 << A->getAsString(Args);
1611 return *runtimeLibType;
1615 const ArgList &Args)
const {
1617 return *unwindLibType;
1619 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
1620 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;
1622 if (LibName ==
"none")
1624 else if (LibName ==
"platform" || LibName ==
"") {
1634 }
else if (LibName ==
"libunwind") {
1638 }
else if (LibName ==
"libgcc")
1643 << A->getAsString(Args);
1648 return *unwindLibType;
1653 return *cxxStdlibType;
1655 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1656 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;
1659 if (LibName ==
"libc++")
1661 else if (LibName ==
"libstdc++")
1663 else if (LibName ==
"platform")
1668 << A->getAsString(Args);
1673 return *cxxStdlibType;
1683 llvm_unreachable(
"unknown C++ standard library type");
1688 return *cStdlibType;
1690 const Arg *A = Args.getLastArg(options::OPT_cstdlib_EQ);
1691 StringRef LibName = A ? A->getValue() :
"system";
1693 if (LibName ==
"newlib")
1695 else if (LibName ==
"picolibc")
1697 else if (LibName ==
"llvm-libc")
1699 else if (LibName ==
"system")
1704 << A->getAsString(Args);
1708 return *cStdlibType;
1713 llvm::opt::ArgStringList &CC1Args,
1714 const Twine &Path) {
1715 CC1Args.push_back(
"-internal-iframework");
1716 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1728 ArgStringList &CC1Args,
1729 const Twine &Path) {
1730 CC1Args.push_back(
"-internal-externc-isystem");
1731 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1735 ArgStringList &CC1Args,
1736 const Twine &Path) {
1737 if (llvm::sys::fs::exists(Path))
1743 ArgStringList &CC1Args,
1744 const Twine &Path) {
1745 CC1Args.push_back(
"-internal-isystem");
1746 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1751 ArgStringList &CC1Args,
1753 for (
const auto &Path : Paths) {
1754 CC1Args.push_back(
"-internal-iframework");
1755 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1761 ArgStringList &CC1Args,
1763 for (
const auto &Path : Paths) {
1764 CC1Args.push_back(
"-internal-isystem");
1765 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1770 const Twine &
C,
const Twine &D) {
1772 llvm::sys::path::append(
Result, llvm::sys::path::Style::posix, A, B,
C, D);
1773 return std::string(
Result);
1779 std::string MaxVersionString;
1781 llvm::sys::path::append(Path,
"c++");
1782 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(Path, EC), LE;
1783 !EC && LI != LE; LI = LI.increment(EC)) {
1784 StringRef VersionText = llvm::sys::path::filename(LI->path());
1786 if (VersionText[0] ==
'v' &&
1787 !VersionText.substr(1).getAsInteger(10, Version)) {
1788 if (Version > MaxVersion) {
1789 MaxVersion = Version;
1790 MaxVersionString = std::string(VersionText);
1796 return MaxVersionString;
1800 ArgStringList &CC1Args)
const {
1810 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);
1814 const llvm::opt::ArgList &DriverArgs,
1815 llvm::opt::ArgStringList &CC1Args)
const {
1816 DriverArgs.ClaimAllArgs(options::OPT_stdlibxx_isystem);
1825 if (!DriverArgs.hasArg(options::OPT_nostdincxx))
1826 for (
const auto &P :
1827 DriverArgs.getAllArgValues(options::OPT_stdlibxx_isystem))
1833 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
1834 options::OPT_nostdlibxx);
1838 ArgStringList &CmdArgs)
const {
1839 assert(!Args.hasArg(options::OPT_nostdlibxx) &&
1840 "should not have called this");
1845 CmdArgs.push_back(
"-lc++");
1846 if (Args.hasArg(options::OPT_fexperimental_library))
1847 CmdArgs.push_back(
"-lc++experimental");
1851 CmdArgs.push_back(
"-lstdc++");
1857 ArgStringList &CmdArgs)
const {
1859 if(LibPath.length() > 0)
1860 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
1864 ArgStringList &CmdArgs)
const {
1865 CmdArgs.push_back(
"-lcc_kext");
1869 std::string &Path)
const {
1873 bool Default = !Args.hasArgNoClaim(options::OPT_shared);
1879 Arg *A = Args.getLastArg(
1880 options::OPT_ffast_math, options::OPT_fno_fast_math,
1881 options::OPT_funsafe_math_optimizations,
1882 options::OPT_fno_unsafe_math_optimizations, options::OPT_ffp_model_EQ);
1884 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
1885 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
1887 if (A && A->getOption().getID() == options::OPT_ffp_model_EQ) {
1888 StringRef Model = A->getValue();
1889 if (Model !=
"fast" && Model !=
"aggressive")
1896 if (!Args.hasFlag(options::OPT_mdaz_ftz, options::OPT_mno_daz_ftz,
Default))
1901 return (Path !=
"crtfastmath.o");
1905 ArgStringList &CmdArgs)
const {
1908 CmdArgs.push_back(Args.MakeArgString(Path));
1928 (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
1929 SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero |
1930 SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow |
1931 SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |
1932 SanitizerKind::Nullability | SanitizerKind::LocalBounds |
1933 SanitizerKind::AllocToken;
1941 Res |= SanitizerKind::CFIICall;
1944 Res |= SanitizerKind::ShadowCallStack;
1946 Res |= SanitizerKind::MemTag;
1948 Res |= SanitizerKind::KernelAddress;
1953 ArgStringList &CC1Args)
const {}
1956 ArgStringList &CC1Args)
const {}
1959 ArgStringList &CC1Args)
const {}
1968 ArgStringList &CC1Args)
const {}
1972 return VersionTuple(Version);
1974 if (Version < 10000)
1975 return VersionTuple(Version / 100, Version % 100);
1977 unsigned Build = 0, Factor = 1;
1978 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
1979 Build = Build + (Version % 10) * Factor;
1980 return VersionTuple(Version / 100, Version % 100, Build);
1985 const llvm::opt::ArgList &Args)
const {
1986 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
1987 const Arg *MSCompatibilityVersion =
1988 Args.getLastArg(options::OPT_fms_compatibility_version);
1990 if (MSCVersion && MSCompatibilityVersion) {
1992 D->Diag(diag::err_drv_argument_not_allowed_with)
1993 << MSCVersion->getAsString(Args)
1994 << MSCompatibilityVersion->getAsString(Args);
1995 return VersionTuple();
1998 if (MSCompatibilityVersion) {
2000 if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
2002 D->Diag(diag::err_drv_invalid_value)
2003 << MSCompatibilityVersion->getAsString(Args)
2004 << MSCompatibilityVersion->getValue();
2011 unsigned Version = 0;
2012 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {
2014 D->Diag(diag::err_drv_invalid_value)
2015 << MSCVersion->getAsString(Args) << MSCVersion->getValue();
2021 return VersionTuple();
2025 const llvm::opt::DerivedArgList &Args,
const llvm::Triple &HostTriple,
2027 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2029 bool Modified =
false;
2030 bool SameTripleAsHost =
getTriple() == HostTriple;
2033 for (
auto *A : Args) {
2038 if (A->getOption().matches(options::OPT_m_Group)) {
2045 if (SameTripleAsHost ||
2046 A->getOption().matches(options::OPT_mcode_object_version_EQ) ||
2047 A->getOption().matches(options::OPT_mlinker_version_EQ))
2056 bool XOpenMPTargetNoTriple =
2057 A->getOption().matches(options::OPT_Xopenmp_target);
2059 if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {
2064 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
2067 }
else if (XOpenMPTargetNoTriple) {
2069 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));
2077 std::unique_ptr<Arg> XOpenMPTargetArg(Opts.ParseOneArg(Args, Index));
2078 if (!XOpenMPTargetArg || Index > Prev + 1) {
2079 if (!A->isClaimed()) {
2080 getDriver().
Diag(diag::err_drv_invalid_Xopenmp_target_with_args)
2081 << A->getAsString(Args);
2085 if (XOpenMPTargetNoTriple && XOpenMPTargetArg &&
2086 Args.getAllArgValues(options::OPT_offload_targets_EQ).size() != 1) {
2087 getDriver().
Diag(diag::err_drv_Xopenmp_target_missing_triple);
2090 XOpenMPTargetArg->setBaseArg(A);
2091 A = XOpenMPTargetArg.release();
2092 if (A->getOption().matches(options::OPT_D) &&
2093 (
getDriver().IsCLMode() || HostTriple.isWindowsMSVCEnvironment()))
2096 AllocatedArgs.push_back(A);
2103 if (!
getDriver().IsCLMode() && HostTriple.isWindowsMSVCEnvironment()) {
2104 DerivedArgList *Translated =
2120 const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A,
2121 llvm::opt::DerivedArgList *DAL,
2124 unsigned ValuePos = 1;
2125 if (A->getOption().matches(options::OPT_Xarch_device) ||
2126 A->getOption().matches(options::OPT_Xarch_host))
2129 const InputArgList &BaseArgs = Args.getBaseArgs();
2130 unsigned Index = BaseArgs.MakeIndex(A->getValue(ValuePos));
2131 unsigned Prev = Index;
2132 std::unique_ptr<llvm::opt::Arg> XarchArg(Opts.ParseOneArg(
2142 if (!XarchArg || Index > Prev + 1) {
2143 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
2144 << A->getAsString(Args);
2150 "invalid Xarch argument: '%0', not all driver "
2151 "options can be forwared via Xarch argument");
2152 Diags.Report(DiagID) << A->getAsString(Args);
2156 XarchArg->setBaseArg(A);
2157 A = XarchArg.release();
2165 for (
const char *
Value : A->getValues()) {
2166 auto Opt = Opts.getOption(options::OPT_Zlinker_input);
2167 unsigned Index = BaseArgs.MakeIndex(Opt.getName(),
Value);
2169 new Arg(Opt, BaseArgs.MakeArgString(Opt.getPrefix() + Opt.getName()),
2170 Index, BaseArgs.getArgString(Index + 1), A);
2172 DAL->append(NewArg);
2174 DAL->AddSynthesizedArg(NewArg);
2176 AllocatedArgs->push_back(NewArg);
2181 DAL->AddSynthesizedArg(A);
2183 AllocatedArgs->push_back(A);
2186 if (A->getOption().matches(options::OPT_D) &&
2188 llvm::Triple(llvm::Triple::normalize(
getDriver().getTargetTriple()))
2189 .isWindowsMSVCEnvironment()))
2196 StringRef XArchVal) {
2197 llvm::Triple ParsedTriple(XArchVal);
2201 if (TT.isAMDGCN() && ParsedTriple.isAMDGCN())
2202 return llvm::AMDGPU::isSubArchCompatible(TT, ParsedTriple);
2204 return TT.getArch() == ParsedTriple.getArch() &&
2205 TT.getSubArch() == ParsedTriple.getSubArch();
2209 const llvm::opt::DerivedArgList &Args,
BoundArch BA,
2212 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2213 bool Modified =
false;
2216 for (Arg *A : Args) {
2217 bool NeedTrans =
false;
2219 if (A->getOption().matches(options::OPT_Xarch_device)) {
2220 NeedTrans = IsDevice;
2222 }
else if (A->getOption().matches(options::OPT_Xarch_host)) {
2223 NeedTrans = !IsDevice;
2225 }
else if (A->getOption().matches(options::OPT_Xarch__)) {
2226 StringRef Val = A->getValue();
2231 if (NeedTrans ||
Skip)
Result
Implement __builtin_bit_cast and related operations.
Defines types useful for describing an Objective-C runtime.
Defines the clang::SanitizerKind enum.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
The basic abstraction for the target Objective-C runtime.
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
The base class of the type hierarchy.
ActionClass getKind() const
@ BinaryTranslatorJobClass
@ OffloadBundlingJobClass
@ VerifyDebugInfoJobClass
@ OffloadPackagerJobClass
static llvm::opt::DerivedArgList * translateArgs(const llvm::opt::DerivedArgList &Args, const llvm::Triple &HostTriple, const llvm::opt::DerivedArgList &Owner)
Translate a filtered list that may contain new clang-cl options, replacing earlier /O expansions.
static const char * translateMacroDefinition(const char *Value, const llvm::opt::ArgList &Args)
Normalize MSVC's '#' macro separator, also used by Clang targeting MSVC and by arguments parsed after...
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
DiagnosticsEngine & getDiags() const
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
DiagnosticBuilder Diag(unsigned DiagID) const
StringRef getFlangF128MathLibrary() const
const llvm::opt::OptTable & getOpts() const
llvm::vfs::FileSystem & getVFS() const
@ OMPRT_OMP
The LLVM OpenMP runtime.
StringRef getPreferredLinker() const
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
static llvm::ErrorOr< MultilibSet > parseYaml(llvm::MemoryBufferRef, llvm::SourceMgr::DiagHandlerTy=nullptr, void *DiagHandlerCtxt=nullptr)
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
std::vector< std::string > flags_list
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
LTOKind
Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
Top level wrappers for InstallAPI frontend operations.
@ Link
'link' clause, allowed on 'declare' construct.
@ Default
Set to the current date and time.
@ Result
The result type of a method or function.
const FunctionProtoType * T
Diagnostic wrappers for TextAPI types for error reporting.
Represents a bound architecture for offload / multiple architecture compilation.
Helper structure used to pass information extracted from clang executable name such as i686-linux-and...