18#include "clang/Config/config.h"
27#include "llvm/ADT/STLExtras.h"
28#include "llvm/ADT/SmallString.h"
29#include "llvm/ADT/StringExtras.h"
30#include "llvm/ADT/StringRef.h"
31#include "llvm/ADT/Twine.h"
32#include "llvm/Config/llvm-config.h"
33#include "llvm/MC/MCTargetOptions.h"
34#include "llvm/MC/TargetRegistry.h"
35#include "llvm/Option/Arg.h"
36#include "llvm/Option/ArgList.h"
37#include "llvm/Option/OptTable.h"
38#include "llvm/Option/Option.h"
39#include "llvm/Support/ErrorHandling.h"
40#include "llvm/Support/FileSystem.h"
41#include "llvm/Support/FileUtilities.h"
42#include "llvm/Support/Path.h"
43#include "llvm/Support/VersionTuple.h"
44#include "llvm/Support/VirtualFileSystem.h"
45#include "llvm/TargetParser/AArch64TargetParser.h"
46#include "llvm/TargetParser/TargetParser.h"
47#include "llvm/TargetParser/Triple.h"
54using namespace driver;
60 return Args.getLastArg(options::OPT_mkernel, options::OPT_fapple_kext,
61 options::OPT_fno_rtti, options::OPT_frtti);
65 const llvm::Triple &Triple,
66 const Arg *CachedRTTIArg) {
69 if (CachedRTTIArg->getOption().matches(options::OPT_frtti))
76 bool NoRTTI = Triple.isPS() || Triple.isDriverKit();
81 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
93 auto addIfExists = [
this](
path_list &List,
const std::string &Path) {
109 llvm::sys::fs::createTemporaryFile(
"toolchain-program",
"txt", OutputFile);
110 llvm::FileRemover OutputRemover(OutputFile.c_str());
111 std::optional<llvm::StringRef> Redirects[] = {
117 std::string ErrorMessage;
118 if (llvm::sys::ExecuteAndWait(Executable, {}, {}, Redirects,
121 return llvm::createStringError(std::error_code(),
122 Executable +
": " + ErrorMessage);
124 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
125 llvm::MemoryBuffer::getFile(OutputFile.c_str());
127 return llvm::createStringError(OutputBuf.getError(),
128 "Failed to read stdout of " + Executable +
129 ": " + OutputBuf.getError().message());
130 return std::move(*OutputBuf);
134 Triple.setEnvironment(
Env);
135 if (EffectiveTriple != llvm::Triple())
136 EffectiveTriple.setEnvironment(
Env);
146 return Args.hasFlag(options::OPT_fintegrated_as,
147 options::OPT_fno_integrated_as,
155 "(Non-)integrated backend set incorrectly!");
157 bool IBackend = Args.hasFlag(options::OPT_fintegrated_objemitter,
158 options::OPT_fno_integrated_objemitter,
166 DiagID = clang::diag::err_drv_unsupported_opt_for_target;
168 DiagID = clang::diag::warn_drv_unsupported_opt_for_target;
169 Arg *A = Args.getLastArg(options::OPT_fno_integrated_objemitter);
171 D.
Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
172 A = Args.getLastArg(options::OPT_fintegrated_objemitter);
174 D.
Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
180 return ENABLE_X86_RELAX_RELOCATIONS;
184 return PPC_LINUX_DEFAULT_IEEELONGDOUBLE &&
getTriple().isOSLinux();
188 const llvm::Triple &Triple,
189 const llvm::opt::ArgList &Args,
191 std::vector<StringRef> Features;
195 UnifiedFeatures.end());
196 std::vector<std::string> MArch;
197 for (
const auto &Ext : AArch64::Extensions)
198 if (FeatureSet.contains(Ext.Feature))
199 MArch.push_back(Ext.Name.str());
200 for (
const auto &Ext : AArch64::Extensions)
201 if (FeatureSet.contains(Ext.NegFeature))
202 MArch.push_back((
"no" + Ext.Name).str());
204 for (
const auto &ArchInfo : AArch64::ArchInfos)
205 if (FeatureSet.contains(ArchInfo->ArchFeature))
206 ArchName = ArchInfo->Name;
207 assert(!ArchName.empty() &&
"at least one architecture should be found");
208 MArch.insert(MArch.begin(), (
"-march=" + ArchName).str());
209 Result.push_back(llvm::join(MArch,
"+"));
213 const llvm::Triple &Triple,
214 const llvm::opt::ArgList &Args,
216 std::vector<StringRef> Features;
218 D, Triple, Args, Features,
false ,
true );
221 UnifiedFeatures.end());
222 std::vector<std::string> MArch;
223 for (
const auto &Ext : ARM::ARCHExtNames)
224 if (FeatureSet.contains(Ext.Feature))
225 MArch.push_back(Ext.Name.str());
226 for (
const auto &Ext : ARM::ARCHExtNames)
227 if (FeatureSet.contains(Ext.NegFeature))
228 MArch.push_back((
"no" + Ext.Name).str());
229 MArch.insert(MArch.begin(), (
"-march=" + Triple.getArchName()).str());
230 Result.push_back(llvm::join(MArch,
"+"));
233#define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) \
234 case llvm::ARM::KIND: \
235 Result.push_back("-mfpu=" NAME); \
237#include "llvm/TargetParser/ARMTargetParser.def"
239 llvm_unreachable(
"Invalid FPUKind");
243 case arm::FloatABI::Soft:
244 Result.push_back(
"-mfloat-abi=soft");
246 case arm::FloatABI::SoftFP:
247 Result.push_back(
"-mfloat-abi=softfp");
249 case arm::FloatABI::Hard:
250 Result.push_back(
"-mfloat-abi=hard");
252 case arm::FloatABI::Invalid:
253 llvm_unreachable(
"Invalid float ABI");
261 std::vector<std::string>
Result;
263 Result.push_back(
"--target=" + Triple.str());
265 switch (Triple.getArch()) {
266 case llvm::Triple::aarch64:
267 case llvm::Triple::aarch64_32:
268 case llvm::Triple::aarch64_be:
271 case llvm::Triple::arm:
272 case llvm::Triple::armeb:
273 case llvm::Triple::thumb:
274 case llvm::Triple::thumbeb:
284 Result.push_back(
"-fno-rtti");
286 Result.push_back(
"-frtti");
289 Result.push_back(
"-fno-exceptions");
291 Result.push_back(
"-fexceptions");
301 SanitizerArgs SanArgs(*
this, JobArgs, !SanitizerArgsChecked);
302 SanitizerArgsChecked =
true;
308 XRayArguments.reset(
new XRayArgs(*
this, Args));
309 return *XRayArguments;
316 const char *ModeFlag;
325 static const DriverSuffix DriverSuffixes[] = {
327 {
"clang++",
"--driver-mode=g++"},
328 {
"clang-c++",
"--driver-mode=g++"},
329 {
"clang-cc",
nullptr},
330 {
"clang-cpp",
"--driver-mode=cpp"},
331 {
"clang-g++",
"--driver-mode=g++"},
332 {
"clang-gcc",
nullptr},
333 {
"clang-cl",
"--driver-mode=cl"},
335 {
"cpp",
"--driver-mode=cpp"},
336 {
"cl",
"--driver-mode=cl"},
337 {
"++",
"--driver-mode=g++"},
338 {
"flang",
"--driver-mode=flang"},
339 {
"clang-dxc",
"--driver-mode=dxc"},
342 for (
const auto &DS : DriverSuffixes) {
343 StringRef Suffix(DS.Suffix);
344 if (ProgName.ends_with(Suffix)) {
345 Pos = ProgName.size() - Suffix.size();
355 std::string ProgName = std::string(llvm::sys::path::filename(Argv0));
356 if (is_style_windows(llvm::sys::path::Style::native)) {
358 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),
374 if (!DS && ProgName.ends_with(
".exe")) {
377 ProgName = ProgName.drop_back(StringRef(
".exe").size());
384 ProgName = ProgName.rtrim(
"0123456789.");
391 ProgName = ProgName.slice(0, ProgName.rfind(
'-'));
404 size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);
406 size_t LastComponent = ProgName.rfind(
'-', SuffixPos);
407 if (LastComponent == std::string::npos)
409 std::string ModeSuffix = ProgName.substr(LastComponent + 1,
410 SuffixEnd - LastComponent - 1);
413 StringRef Prefix(ProgName);
414 Prefix = Prefix.slice(0, LastComponent);
415 std::string IgnoredError;
417 llvm::TargetRegistry::lookupTarget(std::string(Prefix), IgnoredError);
426 switch (Triple.getArch()) {
427 case llvm::Triple::aarch64: {
432 case llvm::Triple::aarch64_32:
434 case llvm::Triple::ppc:
436 case llvm::Triple::ppcle:
438 case llvm::Triple::ppc64:
440 case llvm::Triple::ppc64le:
443 return Triple.getArchName();
456Tool *ToolChain::getClang()
const {
462Tool *ToolChain::getFlang()
const {
473 llvm_unreachable(
"Linking is not supported by this toolchain");
477 llvm_unreachable(
"Creating static lib is not supported by this toolchain");
480Tool *ToolChain::getAssemble()
const {
483 return Assemble.get();
486Tool *ToolChain::getClangAs()
const {
489 return Assemble.get();
492Tool *ToolChain::getLink()
const {
498Tool *ToolChain::getStaticLibTool()
const {
501 return StaticLibTool.get();
504Tool *ToolChain::getIfsMerge()
const {
507 return IfsMerge.get();
510Tool *ToolChain::getOffloadBundler()
const {
516Tool *ToolChain::getOffloadPackager()
const {
522Tool *ToolChain::getLinkerWrapper()
const {
531 return getAssemble();
534 return getIfsMerge();
540 return getStaticLibTool();
549 llvm_unreachable(
"Invalid tool kind.");
563 return getOffloadBundler();
566 return getOffloadPackager();
568 return getLinkerWrapper();
571 llvm_unreachable(
"Invalid tool kind.");
575 const ArgList &Args) {
576 const llvm::Triple &Triple = TC.
getTriple();
577 bool IsWindows = Triple.isOSWindows();
580 return Triple.getArchName();
582 if (TC.
getArch() == llvm::Triple::arm || TC.
getArch() == llvm::Triple::armeb)
588 if (TC.
getArch() == llvm::Triple::x86 && Triple.isAndroid())
591 if (TC.
getArch() == llvm::Triple::x86_64 && Triple.isX32())
594 return llvm::Triple::getArchTypeName(TC.
getArch());
598 if (Triple.isOSDarwin())
601 switch (Triple.getOS()) {
602 case llvm::Triple::FreeBSD:
604 case llvm::Triple::NetBSD:
606 case llvm::Triple::OpenBSD:
608 case llvm::Triple::Solaris:
610 case llvm::Triple::AIX:
624 }
else if (Triple.isOSUnknown()) {
625 llvm::sys::path::append(Path,
"lib");
629 return std::string(Path);
636 return llvm::sys::path::filename(CRTAbsolutePath).str();
642 bool AddArch)
const {
644 bool IsITANMSVCWindows =
645 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();
652 Suffix = IsITANMSVCWindows ?
".obj" :
".o";
655 Suffix = IsITANMSVCWindows ?
".lib" :
".a";
658 Suffix = TT.isOSWindows()
659 ? (TT.isWindowsGNUEnvironment() ?
".dll.a" :
".lib")
664 std::string ArchAndEnv;
667 const char *
Env = TT.isAndroid() ?
"-android" :
"";
668 ArchAndEnv = (
"-" + Arch +
Env).str();
670 return (Prefix + Twine(
"clang_rt.") + Component + ArchAndEnv + Suffix).str();
676 std::string CRTBasename =
681 llvm::sys::path::append(
P, CRTBasename);
683 return std::string(
P);
694 llvm::sys::path::append(OldPath, CRTBasename);
695 if (Path.empty() ||
getVFS().exists(OldPath))
696 return std::string(OldPath);
701 return std::string(Path);
713std::optional<std::string>
714ToolChain::getFallbackAndroidTargetPath(StringRef BaseDir)
const {
715 llvm::Triple TripleWithoutLevel(
getTriple());
716 TripleWithoutLevel.setEnvironmentName(
"android");
717 const std::string &TripleWithoutLevelStr = TripleWithoutLevel.str();
718 unsigned TripleVersion =
getTriple().getEnvironmentVersion().getMajor();
719 unsigned BestVersion = 0;
722 bool UsingUnversionedDir =
false;
724 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(BaseDir, EC), LE;
725 !EC && LI != LE; LI = LI.increment(EC)) {
726 StringRef DirName = llvm::sys::path::filename(LI->path());
727 StringRef DirNameSuffix = DirName;
728 if (DirNameSuffix.consume_front(TripleWithoutLevelStr)) {
729 if (DirNameSuffix.empty() && TripleDir.empty()) {
731 UsingUnversionedDir =
true;
734 if (!DirNameSuffix.getAsInteger(10, Version) && Version > BestVersion &&
735 Version < TripleVersion) {
736 BestVersion = Version;
738 UsingUnversionedDir =
false;
744 if (TripleDir.empty())
748 llvm::sys::path::append(
P, TripleDir);
749 if (UsingUnversionedDir)
751 return std::string(
P);
754std::optional<std::string>
756 auto getPathForTriple =
757 [&](
const llvm::Triple &Triple) -> std::optional<std::string> {
759 llvm::sys::path::append(
P, Triple.str());
761 return std::string(
P);
765 if (
auto Path = getPathForTriple(
getTriple()))
785 ArmTriple.setArch(Triple::arm);
786 if (
auto Path = getPathForTriple(ArmTriple))
791 return getFallbackAndroidTargetPath(BaseDir);
798 llvm::sys::path::append(
P,
"lib");
802 if (Triple.isOSDarwin())
804 llvm::sys::path::append(
P, Triple.str());
805 return std::string(
P);
810 llvm::sys::path::append(
P,
"..",
"lib");
819 llvm::sys::path::append(Path,
"lib");
821 llvm::sys::path::append(Path, S);
822 Paths.push_back(std::string(Path));
831 if (Args.hasArg(options::OPT_noprofilelib))
834 return Args.hasArg(options::OPT_fprofile_generate) ||
835 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
836 Args.hasArg(options::OPT_fcs_profile_generate) ||
837 Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||
838 Args.hasArg(options::OPT_fprofile_instr_generate) ||
839 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
840 Args.hasArg(options::OPT_fcreate_profile) ||
841 Args.hasArg(options::OPT_forder_file_instrumentation);
845 return Args.hasArg(options::OPT_coverage) ||
846 Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
852 if (
getDriver().ShouldUseClangCompiler(JA))
return getClang();
870 *LinkerIsLLD =
false;
874 const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
875 StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER;
882 if (
const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {
883 std::string Path(A->getValue());
885 if (llvm::sys::path::parent_path(Path).empty())
887 if (llvm::sys::fs::can_execute(Path)) {
889 *LinkerIsLLD = UseLinker ==
"lld";
890 return std::string(Path);
893 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
898 if (UseLinker.empty() || UseLinker ==
"ld") {
900 if (llvm::sys::path::is_absolute(DefaultLinker))
901 return std::string(DefaultLinker);
910 if (UseLinker.contains(
'/'))
913 if (llvm::sys::path::is_absolute(UseLinker)) {
916 if (llvm::sys::fs::can_execute(UseLinker))
917 return std::string(UseLinker);
920 if (Triple.isOSDarwin())
921 LinkerName.append(
"ld64.");
923 LinkerName.append(
"ld.");
924 LinkerName.append(UseLinker);
927 if (llvm::sys::fs::can_execute(LinkerPath)) {
929 *LinkerIsLLD = UseLinker ==
"lld";
935 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
942 if (Triple.isOSDarwin())
954 id = types::TY_Fortran;
964 llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
965 switch (HostTriple.getArch()) {
968 case llvm::Triple::arm:
969 case llvm::Triple::armeb:
970 case llvm::Triple::thumb:
971 case llvm::Triple::thumbeb:
972 return getArch() != llvm::Triple::arm &&
getArch() != llvm::Triple::thumb &&
973 getArch() != llvm::Triple::armeb &&
getArch() != llvm::Triple::thumbeb;
975 return HostTriple.getArch() !=
getArch();
984llvm::ExceptionHandling
986 return llvm::ExceptionHandling::None;
990 if (Model ==
"single") {
992 return Triple.getArch() == llvm::Triple::arm ||
993 Triple.getArch() == llvm::Triple::armeb ||
994 Triple.getArch() == llvm::Triple::thumb ||
995 Triple.getArch() == llvm::Triple::thumbeb || Triple.isWasm();
996 }
else if (Model ==
"posix")
1008 case llvm::Triple::x86_64: {
1010 if (!Triple.isOSBinFormatMachO())
1013 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1016 StringRef MArch = A->getValue();
1017 if (MArch ==
"x86_64h")
1018 Triple.setArchName(MArch);
1020 return Triple.getTriple();
1022 case llvm::Triple::aarch64: {
1024 if (!Triple.isOSBinFormatMachO())
1027 if (Triple.isArm64e())
1033 Triple.setArchName(
"arm64");
1034 return Triple.getTriple();
1036 case llvm::Triple::aarch64_32:
1038 case llvm::Triple::arm:
1039 case llvm::Triple::armeb:
1040 case llvm::Triple::thumb:
1041 case llvm::Triple::thumbeb: {
1045 return Triple.getTriple();
1060 ArgStringList &CC1Args)
const {
1065 const ArgList &DriverArgs, ArgStringList &CC1Args,
1069 ArgStringList &CC1ASArgs)
const {}
1074 llvm::opt::ArgStringList &CmdArgs)
const {
1082 const ArgList &Args)
const {
1084 return *runtimeLibType;
1086 const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);
1087 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;
1090 if (LibName ==
"compiler-rt")
1092 else if (LibName ==
"libgcc")
1094 else if (LibName ==
"platform")
1099 << A->getAsString(Args);
1104 return *runtimeLibType;
1108 const ArgList &Args)
const {
1110 return *unwindLibType;
1112 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
1113 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;
1115 if (LibName ==
"none")
1117 else if (LibName ==
"platform" || LibName ==
"") {
1126 }
else if (LibName ==
"libunwind") {
1130 }
else if (LibName ==
"libgcc")
1135 << A->getAsString(Args);
1140 return *unwindLibType;
1145 return *cxxStdlibType;
1147 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1148 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;
1151 if (LibName ==
"libc++")
1153 else if (LibName ==
"libstdc++")
1155 else if (LibName ==
"platform")
1160 << A->getAsString(Args);
1165 return *cxxStdlibType;
1170 ArgStringList &CC1Args,
1171 const Twine &Path) {
1172 CC1Args.push_back(
"-internal-isystem");
1173 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1185 ArgStringList &CC1Args,
1186 const Twine &Path) {
1187 CC1Args.push_back(
"-internal-externc-isystem");
1188 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1192 ArgStringList &CC1Args,
1193 const Twine &Path) {
1194 if (llvm::sys::fs::exists(Path))
1200 ArgStringList &CC1Args,
1202 for (
const auto &Path : Paths) {
1203 CC1Args.push_back(
"-internal-isystem");
1204 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1209 const Twine &B,
const Twine &
C,
1212 llvm::sys::path::append(
Result, llvm::sys::path::Style::posix, A, B,
C, D);
1213 return std::string(
Result);
1219 std::string MaxVersionString;
1221 llvm::sys::path::append(Path,
"c++");
1222 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(Path, EC), LE;
1223 !EC && LI != LE; LI = LI.increment(EC)) {
1224 StringRef VersionText = llvm::sys::path::filename(LI->path());
1226 if (VersionText[0] ==
'v' &&
1227 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
1228 if (Version > MaxVersion) {
1229 MaxVersion = Version;
1230 MaxVersionString = std::string(VersionText);
1236 return MaxVersionString;
1240 ArgStringList &CC1Args)
const {
1250 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);
1254 const llvm::opt::ArgList &DriverArgs,
1255 llvm::opt::ArgStringList &CC1Args)
const {
1256 DriverArgs.ClaimAllArgs(options::OPT_stdlibxx_isystem);
1265 if (!DriverArgs.hasArg(options::OPT_nostdincxx))
1266 for (
const auto &
P :
1267 DriverArgs.getAllArgValues(options::OPT_stdlibxx_isystem))
1273 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
1274 options::OPT_nostdlibxx);
1278 ArgStringList &CmdArgs)
const {
1279 assert(!Args.hasArg(options::OPT_nostdlibxx) &&
1280 "should not have called this");
1285 CmdArgs.push_back(
"-lc++");
1286 if (Args.hasArg(options::OPT_fexperimental_library))
1287 CmdArgs.push_back(
"-lc++experimental");
1291 CmdArgs.push_back(
"-lstdc++");
1297 ArgStringList &CmdArgs)
const {
1299 if(LibPath.length() > 0)
1300 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
1304 ArgStringList &CmdArgs)
const {
1305 CmdArgs.push_back(
"-lcc_kext");
1309 std::string &Path)
const {
1313 bool Default = !Args.hasArgNoClaim(options::OPT_shared);
1319 Arg *A = Args.getLastArg(
1320 options::OPT_ffast_math, options::OPT_fno_fast_math,
1321 options::OPT_funsafe_math_optimizations,
1322 options::OPT_fno_unsafe_math_optimizations, options::OPT_ffp_model_EQ);
1324 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
1325 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
1327 if (A && A->getOption().getID() == options::OPT_ffp_model_EQ) {
1328 StringRef Model = A->getValue();
1329 if (Model !=
"fast")
1336 if (!Args.hasFlag(options::OPT_mdaz_ftz, options::OPT_mno_daz_ftz,
Default))
1341 return (Path !=
"crtfastmath.o");
1345 ArgStringList &CmdArgs)
const {
1348 CmdArgs.push_back(Args.MakeArgString(Path));
1366 (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
1367 SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero |
1368 SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow |
1369 SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |
1370 SanitizerKind::Nullability | SanitizerKind::LocalBounds;
1371 if (
getTriple().getArch() == llvm::Triple::x86 ||
1372 getTriple().getArch() == llvm::Triple::x86_64 ||
1376 Res |= SanitizerKind::CFIICall;
1377 if (
getTriple().getArch() == llvm::Triple::x86_64 ||
1379 Res |= SanitizerKind::ShadowCallStack;
1381 Res |= SanitizerKind::MemTag;
1386 ArgStringList &CC1Args)
const {}
1389 ArgStringList &CC1Args)
const {}
1397 ArgStringList &CC1Args)
const {}
1401 return VersionTuple(Version);
1403 if (Version < 10000)
1404 return VersionTuple(Version / 100, Version % 100);
1406 unsigned Build = 0, Factor = 1;
1407 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
1408 Build = Build + (Version % 10) * Factor;
1409 return VersionTuple(Version / 100, Version % 100, Build);
1414 const llvm::opt::ArgList &Args)
const {
1415 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
1416 const Arg *MSCompatibilityVersion =
1417 Args.getLastArg(options::OPT_fms_compatibility_version);
1419 if (MSCVersion && MSCompatibilityVersion) {
1421 D->
Diag(diag::err_drv_argument_not_allowed_with)
1422 << MSCVersion->getAsString(Args)
1423 << MSCompatibilityVersion->getAsString(Args);
1424 return VersionTuple();
1427 if (MSCompatibilityVersion) {
1429 if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
1431 D->
Diag(diag::err_drv_invalid_value)
1432 << MSCompatibilityVersion->getAsString(Args)
1433 << MSCompatibilityVersion->getValue();
1440 unsigned Version = 0;
1441 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {
1443 D->
Diag(diag::err_drv_invalid_value)
1444 << MSCVersion->getAsString(Args) << MSCVersion->getValue();
1450 return VersionTuple();
1454 const llvm::opt::DerivedArgList &Args,
bool SameTripleAsHost,
1456 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1458 bool Modified =
false;
1461 for (
auto *A : Args) {
1466 if (A->getOption().matches(options::OPT_m_Group)) {
1469 if (SameTripleAsHost ||
1470 A->getOption().matches(options::OPT_mcode_object_version_EQ))
1479 bool XOpenMPTargetNoTriple =
1480 A->getOption().matches(options::OPT_Xopenmp_target);
1482 if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {
1487 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1490 }
else if (XOpenMPTargetNoTriple) {
1492 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));
1500 std::unique_ptr<Arg> XOpenMPTargetArg(Opts.ParseOneArg(Args, Index));
1501 if (!XOpenMPTargetArg || Index > Prev + 1) {
1502 getDriver().
Diag(diag::err_drv_invalid_Xopenmp_target_with_args)
1503 << A->getAsString(Args);
1506 if (XOpenMPTargetNoTriple && XOpenMPTargetArg &&
1507 Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() != 1) {
1508 getDriver().
Diag(diag::err_drv_Xopenmp_target_missing_triple);
1511 XOpenMPTargetArg->setBaseArg(A);
1512 A = XOpenMPTargetArg.release();
1513 AllocatedArgs.push_back(A);
1529 const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A,
1530 llvm::opt::DerivedArgList *DAL,
1533 unsigned ValuePos = 1;
1534 if (A->getOption().matches(options::OPT_Xarch_device) ||
1535 A->getOption().matches(options::OPT_Xarch_host))
1538 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(ValuePos));
1539 unsigned Prev = Index;
1540 std::unique_ptr<llvm::opt::Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1549 if (!XarchArg || Index > Prev + 1) {
1550 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1551 << A->getAsString(Args);
1557 "invalid Xarch argument: '%0', not all driver "
1558 "options can be forwared via Xarch argument");
1559 Diags.Report(DiagID) << A->getAsString(Args);
1562 XarchArg->setBaseArg(A);
1563 A = XarchArg.release();
1565 DAL->AddSynthesizedArg(A);
1567 AllocatedArgs->push_back(A);
1571 const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
1574 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1575 bool Modified =
false;
1578 for (Arg *A : Args) {
1579 bool NeedTrans =
false;
1581 if (A->getOption().matches(options::OPT_Xarch_device)) {
1582 NeedTrans = IsDevice;
1584 }
else if (A->getOption().matches(options::OPT_Xarch_host)) {
1585 NeedTrans = !IsDevice;
1587 }
else if (A->getOption().matches(options::OPT_Xarch__) && IsDevice) {
1591 if (BoundArch.empty() || A->getValue(0) != BoundArch)
1596 if (NeedTrans || Skip)
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
@ OffloadUnbundlingJobClass
@ OffloadBundlingJobClass
@ VerifyDebugInfoJobClass
@ OffloadPackagerJobClass
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
std::string GetFilePath(StringRef Name, const ToolChain &TC) const
GetFilePath - Lookup Name in the list of file search paths.
DiagnosticsEngine & getDiags() const
DiagnosticBuilder Diag(unsigned DiagID) const
const llvm::opt::OptTable & getOpts() const
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
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.
bool IsFlangMode() const
Whether the driver should invoke flang for fortran inputs.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
std::vector< std::string > flags_list
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
The JSON file list parser is used to communicate input to InstallAPI.
@ Result
The result type of a method or function.
const FunctionProtoType * T
Diagnostic wrappers for TextAPI types for error reporting.
Helper structure used to pass information extracted from clang executable name such as i686-linux-and...