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) {
108 unsigned SecondsToWait)
const {
110 llvm::sys::fs::createTemporaryFile(
"toolchain-program",
"txt", OutputFile);
111 llvm::FileRemover OutputRemover(OutputFile.c_str());
112 std::optional<llvm::StringRef> Redirects[] = {
118 std::string ErrorMessage;
119 if (llvm::sys::ExecuteAndWait(Executable, {}, {}, Redirects, SecondsToWait,
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 (!Ext.UserVisibleName.empty())
199 if (FeatureSet.contains(Ext.PosTargetFeature))
200 MArch.push_back(Ext.UserVisibleName.str());
201 for (
const auto &Ext : AArch64::Extensions)
202 if (!Ext.UserVisibleName.empty())
203 if (FeatureSet.contains(Ext.NegTargetFeature))
204 MArch.push_back((
"no" + Ext.UserVisibleName).str());
206 for (
const auto &ArchInfo : AArch64::ArchInfos)
207 if (FeatureSet.contains(ArchInfo->ArchFeature))
208 ArchName = ArchInfo->Name;
209 assert(!ArchName.empty() &&
"at least one architecture should be found");
210 MArch.insert(MArch.begin(), (
"-march=" + ArchName).str());
211 Result.push_back(llvm::join(MArch,
"+"));
215 const llvm::Triple &Triple,
216 const llvm::opt::ArgList &Args,
218 std::vector<StringRef> Features;
220 D, Triple, Args, Features,
false ,
true );
223 UnifiedFeatures.end());
224 std::vector<std::string> MArch;
225 for (
const auto &Ext : ARM::ARCHExtNames)
226 if (!Ext.Name.empty())
227 if (FeatureSet.contains(Ext.Feature))
228 MArch.push_back(Ext.Name.str());
229 for (
const auto &Ext : ARM::ARCHExtNames)
230 if (!Ext.Name.empty())
231 if (FeatureSet.contains(Ext.NegFeature))
232 MArch.push_back((
"no" + Ext.Name).str());
233 MArch.insert(MArch.begin(), (
"-march=" + Triple.getArchName()).str());
234 Result.push_back(llvm::join(MArch,
"+"));
237#define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) \
238 case llvm::ARM::KIND: \
239 Result.push_back("-mfpu=" NAME); \
241#include "llvm/TargetParser/ARMTargetParser.def"
243 llvm_unreachable(
"Invalid FPUKind");
247 case arm::FloatABI::Soft:
248 Result.push_back(
"-mfloat-abi=soft");
250 case arm::FloatABI::SoftFP:
251 Result.push_back(
"-mfloat-abi=softfp");
253 case arm::FloatABI::Hard:
254 Result.push_back(
"-mfloat-abi=hard");
256 case arm::FloatABI::Invalid:
257 llvm_unreachable(
"Invalid float ABI");
265 std::vector<std::string>
Result;
267 Result.push_back(
"--target=" + Triple.str());
269 switch (Triple.getArch()) {
270 case llvm::Triple::aarch64:
271 case llvm::Triple::aarch64_32:
272 case llvm::Triple::aarch64_be:
275 case llvm::Triple::arm:
276 case llvm::Triple::armeb:
277 case llvm::Triple::thumb:
278 case llvm::Triple::thumbeb:
288 Result.push_back(
"-fno-rtti");
290 Result.push_back(
"-frtti");
293 Result.push_back(
"-fno-exceptions");
295 Result.push_back(
"-fexceptions");
305 SanitizerArgs SanArgs(*
this, JobArgs, !SanitizerArgsChecked);
306 SanitizerArgsChecked =
true;
312 XRayArguments.reset(
new XRayArgs(*
this, Args));
313 return *XRayArguments;
320 const char *ModeFlag;
329 static const DriverSuffix DriverSuffixes[] = {
331 {
"clang++",
"--driver-mode=g++"},
332 {
"clang-c++",
"--driver-mode=g++"},
333 {
"clang-cc",
nullptr},
334 {
"clang-cpp",
"--driver-mode=cpp"},
335 {
"clang-g++",
"--driver-mode=g++"},
336 {
"clang-gcc",
nullptr},
337 {
"clang-cl",
"--driver-mode=cl"},
339 {
"cpp",
"--driver-mode=cpp"},
340 {
"cl",
"--driver-mode=cl"},
341 {
"++",
"--driver-mode=g++"},
342 {
"flang",
"--driver-mode=flang"},
343 {
"clang-dxc",
"--driver-mode=dxc"},
346 for (
const auto &DS : DriverSuffixes) {
347 StringRef Suffix(DS.Suffix);
348 if (ProgName.ends_with(Suffix)) {
349 Pos = ProgName.size() - Suffix.size();
359 std::string ProgName = std::string(llvm::sys::path::filename(Argv0));
360 if (is_style_windows(llvm::sys::path::Style::native)) {
362 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),
378 if (!DS && ProgName.ends_with(
".exe")) {
381 ProgName = ProgName.drop_back(StringRef(
".exe").size());
388 ProgName = ProgName.rtrim(
"0123456789.");
395 ProgName = ProgName.slice(0, ProgName.rfind(
'-'));
408 size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);
410 size_t LastComponent = ProgName.rfind(
'-', SuffixPos);
411 if (LastComponent == std::string::npos)
413 std::string ModeSuffix = ProgName.substr(LastComponent + 1,
414 SuffixEnd - LastComponent - 1);
417 StringRef Prefix(ProgName);
418 Prefix = Prefix.slice(0, LastComponent);
419 std::string IgnoredError;
421 llvm::TargetRegistry::lookupTarget(std::string(Prefix), IgnoredError);
430 switch (Triple.getArch()) {
431 case llvm::Triple::aarch64: {
436 case llvm::Triple::aarch64_32:
438 case llvm::Triple::ppc:
440 case llvm::Triple::ppcle:
442 case llvm::Triple::ppc64:
444 case llvm::Triple::ppc64le:
447 return Triple.getArchName();
460Tool *ToolChain::getClang()
const {
466Tool *ToolChain::getFlang()
const {
477 llvm_unreachable(
"Linking is not supported by this toolchain");
481 llvm_unreachable(
"Creating static lib is not supported by this toolchain");
484Tool *ToolChain::getAssemble()
const {
487 return Assemble.get();
490Tool *ToolChain::getClangAs()
const {
493 return Assemble.get();
496Tool *ToolChain::getLink()
const {
502Tool *ToolChain::getStaticLibTool()
const {
505 return StaticLibTool.get();
508Tool *ToolChain::getIfsMerge()
const {
511 return IfsMerge.get();
514Tool *ToolChain::getOffloadBundler()
const {
520Tool *ToolChain::getOffloadPackager()
const {
526Tool *ToolChain::getLinkerWrapper()
const {
535 return getAssemble();
538 return getIfsMerge();
544 return getStaticLibTool();
553 llvm_unreachable(
"Invalid tool kind.");
567 return getOffloadBundler();
570 return getOffloadPackager();
572 return getLinkerWrapper();
575 llvm_unreachable(
"Invalid tool kind.");
579 const ArgList &Args) {
580 const llvm::Triple &Triple = TC.
getTriple();
581 bool IsWindows = Triple.isOSWindows();
584 return Triple.getArchName();
586 if (TC.
getArch() == llvm::Triple::arm || TC.
getArch() == llvm::Triple::armeb)
592 if (TC.
getArch() == llvm::Triple::x86 && Triple.isAndroid())
595 if (TC.
getArch() == llvm::Triple::x86_64 && Triple.isX32())
598 return llvm::Triple::getArchTypeName(TC.
getArch());
602 if (Triple.isOSDarwin())
605 switch (Triple.getOS()) {
606 case llvm::Triple::FreeBSD:
608 case llvm::Triple::NetBSD:
610 case llvm::Triple::OpenBSD:
612 case llvm::Triple::Solaris:
614 case llvm::Triple::AIX:
628 }
else if (Triple.isOSUnknown()) {
629 llvm::sys::path::append(
Path,
"lib");
633 return std::string(
Path);
640 return llvm::sys::path::filename(CRTAbsolutePath).str();
646 bool AddArch)
const {
648 bool IsITANMSVCWindows =
649 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();
656 Suffix = IsITANMSVCWindows ?
".obj" :
".o";
659 Suffix = IsITANMSVCWindows ?
".lib" :
".a";
662 Suffix = TT.isOSWindows()
663 ? (TT.isWindowsGNUEnvironment() ?
".dll.a" :
".lib")
668 std::string ArchAndEnv;
671 const char *
Env = TT.isAndroid() ?
"-android" :
"";
672 ArchAndEnv = (
"-" + Arch +
Env).str();
674 return (Prefix + Twine(
"clang_rt.") + Component + ArchAndEnv + Suffix).str();
680 std::string CRTBasename =
685 llvm::sys::path::append(
P, CRTBasename);
687 return std::string(
P);
698 llvm::sys::path::append(OldPath, CRTBasename);
700 return std::string(OldPath);
705 return std::string(
Path);
717std::optional<std::string>
718ToolChain::getFallbackAndroidTargetPath(StringRef BaseDir)
const {
719 llvm::Triple TripleWithoutLevel(
getTriple());
720 TripleWithoutLevel.setEnvironmentName(
"android");
721 const std::string &TripleWithoutLevelStr = TripleWithoutLevel.str();
722 unsigned TripleVersion =
getTriple().getEnvironmentVersion().getMajor();
723 unsigned BestVersion = 0;
726 bool UsingUnversionedDir =
false;
728 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(BaseDir, EC), LE;
729 !EC && LI != LE; LI = LI.increment(EC)) {
730 StringRef DirName = llvm::sys::path::filename(LI->path());
731 StringRef DirNameSuffix = DirName;
732 if (DirNameSuffix.consume_front(TripleWithoutLevelStr)) {
733 if (DirNameSuffix.empty() && TripleDir.empty()) {
735 UsingUnversionedDir =
true;
738 if (!DirNameSuffix.getAsInteger(10, Version) && Version > BestVersion &&
739 Version < TripleVersion) {
740 BestVersion = Version;
742 UsingUnversionedDir =
false;
748 if (TripleDir.empty())
752 llvm::sys::path::append(
P, TripleDir);
753 if (UsingUnversionedDir)
755 return std::string(
P);
758std::optional<std::string>
760 auto getPathForTriple =
761 [&](
const llvm::Triple &Triple) -> std::optional<std::string> {
763 llvm::sys::path::append(
P, Triple.str());
765 return std::string(
P);
789 ArmTriple.setArch(Triple::arm);
790 if (
auto Path = getPathForTriple(ArmTriple))
795 return getFallbackAndroidTargetPath(BaseDir);
802 llvm::sys::path::append(
P,
"lib");
806 if (Triple.isOSDarwin())
808 llvm::sys::path::append(
P, Triple.str());
809 return std::string(
P);
814 llvm::sys::path::append(
P,
"..",
"lib");
820 llvm::sys::path::append(
P,
"..",
"include");
829 llvm::sys::path::append(
Path,
"lib");
831 llvm::sys::path::append(
Path, S);
832 Paths.push_back(std::string(
Path));
841 if (Args.hasArg(options::OPT_noprofilelib))
844 return Args.hasArg(options::OPT_fprofile_generate) ||
845 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
846 Args.hasArg(options::OPT_fcs_profile_generate) ||
847 Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||
848 Args.hasArg(options::OPT_fprofile_instr_generate) ||
849 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
850 Args.hasArg(options::OPT_fcreate_profile) ||
851 Args.hasArg(options::OPT_forder_file_instrumentation);
855 return Args.hasArg(options::OPT_coverage) ||
856 Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
862 if (
getDriver().ShouldUseClangCompiler(JA))
return getClang();
880 *LinkerIsLLD =
false;
884 const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
885 StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER;
892 if (
const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {
893 std::string
Path(A->getValue());
895 if (llvm::sys::path::parent_path(
Path).empty())
897 if (llvm::sys::fs::can_execute(
Path)) {
899 *LinkerIsLLD = UseLinker ==
"lld";
900 return std::string(
Path);
903 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
908 if (UseLinker.empty() || UseLinker ==
"ld") {
910 if (llvm::sys::path::is_absolute(DefaultLinker))
911 return std::string(DefaultLinker);
920 if (UseLinker.contains(
'/'))
923 if (llvm::sys::path::is_absolute(UseLinker)) {
926 if (llvm::sys::fs::can_execute(UseLinker))
927 return std::string(UseLinker);
930 if (Triple.isOSDarwin())
931 LinkerName.append(
"ld64.");
933 LinkerName.append(
"ld.");
934 LinkerName.append(UseLinker);
937 if (llvm::sys::fs::can_execute(LinkerPath)) {
939 *LinkerIsLLD = UseLinker ==
"lld";
945 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
952 if (Triple.isOSDarwin())
964 id = types::TY_Fortran;
974 llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
975 switch (HostTriple.getArch()) {
978 case llvm::Triple::arm:
979 case llvm::Triple::armeb:
980 case llvm::Triple::thumb:
981 case llvm::Triple::thumbeb:
982 return getArch() != llvm::Triple::arm &&
getArch() != llvm::Triple::thumb &&
983 getArch() != llvm::Triple::armeb &&
getArch() != llvm::Triple::thumbeb;
985 return HostTriple.getArch() !=
getArch();
994llvm::ExceptionHandling
996 return llvm::ExceptionHandling::None;
1000 if (Model ==
"single") {
1002 return Triple.getArch() == llvm::Triple::arm ||
1003 Triple.getArch() == llvm::Triple::armeb ||
1004 Triple.getArch() == llvm::Triple::thumb ||
1005 Triple.getArch() == llvm::Triple::thumbeb || Triple.isWasm();
1006 }
else if (Model ==
"posix")
1018 case llvm::Triple::x86_64: {
1020 if (!Triple.isOSBinFormatMachO())
1023 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1026 StringRef MArch = A->getValue();
1027 if (MArch ==
"x86_64h")
1028 Triple.setArchName(MArch);
1030 return Triple.getTriple();
1032 case llvm::Triple::aarch64: {
1035 if (!Triple.isOSBinFormatMachO())
1036 return Triple.getTriple();
1038 if (Triple.isArm64e())
1039 return Triple.getTriple();
1044 Triple.setArchName(
"arm64");
1045 return Triple.getTriple();
1047 case llvm::Triple::aarch64_32:
1049 case llvm::Triple::arm:
1050 case llvm::Triple::armeb:
1051 case llvm::Triple::thumb:
1052 case llvm::Triple::thumbeb: {
1056 return Triple.getTriple();
1071 ArgStringList &CC1Args)
const {
1076 const ArgList &DriverArgs, ArgStringList &CC1Args,
1080 ArgStringList &CC1ASArgs)
const {}
1085 llvm::opt::ArgStringList &CmdArgs)
const {
1093 const ArgList &Args)
const {
1095 return *runtimeLibType;
1097 const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);
1098 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;
1101 if (LibName ==
"compiler-rt")
1103 else if (LibName ==
"libgcc")
1105 else if (LibName ==
"platform")
1110 << A->getAsString(Args);
1115 return *runtimeLibType;
1119 const ArgList &Args)
const {
1121 return *unwindLibType;
1123 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
1124 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;
1126 if (LibName ==
"none")
1128 else if (LibName ==
"platform" || LibName ==
"") {
1137 }
else if (LibName ==
"libunwind") {
1141 }
else if (LibName ==
"libgcc")
1146 << A->getAsString(Args);
1151 return *unwindLibType;
1156 return *cxxStdlibType;
1158 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1159 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;
1162 if (LibName ==
"libc++")
1164 else if (LibName ==
"libstdc++")
1166 else if (LibName ==
"platform")
1171 << A->getAsString(Args);
1176 return *cxxStdlibType;
1181 ArgStringList &CC1Args,
1182 const Twine &
Path) {
1183 CC1Args.push_back(
"-internal-isystem");
1184 CC1Args.push_back(DriverArgs.MakeArgString(
Path));
1196 ArgStringList &CC1Args,
1197 const Twine &
Path) {
1198 CC1Args.push_back(
"-internal-externc-isystem");
1199 CC1Args.push_back(DriverArgs.MakeArgString(
Path));
1203 ArgStringList &CC1Args,
1204 const Twine &
Path) {
1205 if (llvm::sys::fs::exists(
Path))
1211 ArgStringList &CC1Args,
1213 for (
const auto &
Path : Paths) {
1214 CC1Args.push_back(
"-internal-isystem");
1215 CC1Args.push_back(DriverArgs.MakeArgString(
Path));
1220 const Twine &B,
const Twine &
C,
1223 llvm::sys::path::append(
Result, llvm::sys::path::Style::posix, A, B,
C,
D);
1224 return std::string(
Result);
1230 std::string MaxVersionString;
1232 llvm::sys::path::append(
Path,
"c++");
1233 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(
Path, EC), LE;
1234 !EC && LI != LE; LI = LI.increment(EC)) {
1235 StringRef VersionText = llvm::sys::path::filename(LI->path());
1237 if (VersionText[0] ==
'v' &&
1238 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
1239 if (Version > MaxVersion) {
1240 MaxVersion = Version;
1241 MaxVersionString = std::string(VersionText);
1247 return MaxVersionString;
1251 ArgStringList &CC1Args)
const {
1261 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);
1265 const llvm::opt::ArgList &DriverArgs,
1266 llvm::opt::ArgStringList &CC1Args)
const {
1267 DriverArgs.ClaimAllArgs(options::OPT_stdlibxx_isystem);
1276 if (!DriverArgs.hasArg(options::OPT_nostdincxx))
1277 for (
const auto &
P :
1278 DriverArgs.getAllArgValues(options::OPT_stdlibxx_isystem))
1284 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
1285 options::OPT_nostdlibxx);
1289 ArgStringList &CmdArgs)
const {
1290 assert(!Args.hasArg(options::OPT_nostdlibxx) &&
1291 "should not have called this");
1296 CmdArgs.push_back(
"-lc++");
1297 if (Args.hasArg(options::OPT_fexperimental_library))
1298 CmdArgs.push_back(
"-lc++experimental");
1302 CmdArgs.push_back(
"-lstdc++");
1308 ArgStringList &CmdArgs)
const {
1310 if(LibPath.length() > 0)
1311 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
1315 ArgStringList &CmdArgs)
const {
1316 CmdArgs.push_back(
"-lcc_kext");
1320 std::string &
Path)
const {
1324 bool Default = !Args.hasArgNoClaim(options::OPT_shared);
1330 Arg *A = Args.getLastArg(
1331 options::OPT_ffast_math, options::OPT_fno_fast_math,
1332 options::OPT_funsafe_math_optimizations,
1333 options::OPT_fno_unsafe_math_optimizations, options::OPT_ffp_model_EQ);
1335 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
1336 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
1338 if (A && A->getOption().getID() == options::OPT_ffp_model_EQ) {
1339 StringRef Model = A->getValue();
1340 if (Model !=
"fast")
1347 if (!Args.hasFlag(options::OPT_mdaz_ftz, options::OPT_mno_daz_ftz,
Default))
1352 return (
Path !=
"crtfastmath.o");
1356 ArgStringList &CmdArgs)
const {
1359 CmdArgs.push_back(Args.MakeArgString(
Path));
1377 (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
1378 SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero |
1379 SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow |
1380 SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |
1381 SanitizerKind::Nullability | SanitizerKind::LocalBounds;
1382 if (
getTriple().getArch() == llvm::Triple::x86 ||
1383 getTriple().getArch() == llvm::Triple::x86_64 ||
1387 Res |= SanitizerKind::CFIICall;
1388 if (
getTriple().getArch() == llvm::Triple::x86_64 ||
1390 Res |= SanitizerKind::ShadowCallStack;
1392 Res |= SanitizerKind::MemTag;
1397 ArgStringList &CC1Args)
const {}
1400 ArgStringList &CC1Args)
const {}
1408 ArgStringList &CC1Args)
const {}
1412 return VersionTuple(Version);
1414 if (Version < 10000)
1415 return VersionTuple(Version / 100, Version % 100);
1417 unsigned Build = 0, Factor = 1;
1418 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
1419 Build = Build + (Version % 10) * Factor;
1420 return VersionTuple(Version / 100, Version % 100, Build);
1425 const llvm::opt::ArgList &Args)
const {
1426 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
1427 const Arg *MSCompatibilityVersion =
1428 Args.getLastArg(options::OPT_fms_compatibility_version);
1430 if (MSCVersion && MSCompatibilityVersion) {
1432 D->Diag(diag::err_drv_argument_not_allowed_with)
1433 << MSCVersion->getAsString(Args)
1434 << MSCompatibilityVersion->getAsString(Args);
1435 return VersionTuple();
1438 if (MSCompatibilityVersion) {
1440 if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
1442 D->Diag(diag::err_drv_invalid_value)
1443 << MSCompatibilityVersion->getAsString(Args)
1444 << MSCompatibilityVersion->getValue();
1451 unsigned Version = 0;
1452 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {
1454 D->Diag(diag::err_drv_invalid_value)
1455 << MSCVersion->getAsString(Args) << MSCVersion->getValue();
1461 return VersionTuple();
1465 const llvm::opt::DerivedArgList &Args,
bool SameTripleAsHost,
1467 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1469 bool Modified =
false;
1472 for (
auto *A : Args) {
1477 if (A->getOption().matches(options::OPT_m_Group)) {
1480 if (SameTripleAsHost ||
1481 A->getOption().matches(options::OPT_mcode_object_version_EQ))
1490 bool XOpenMPTargetNoTriple =
1491 A->getOption().matches(options::OPT_Xopenmp_target);
1493 if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {
1498 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1501 }
else if (XOpenMPTargetNoTriple) {
1503 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));
1511 std::unique_ptr<Arg> XOpenMPTargetArg(Opts.ParseOneArg(Args, Index));
1512 if (!XOpenMPTargetArg || Index > Prev + 1) {
1513 getDriver().
Diag(diag::err_drv_invalid_Xopenmp_target_with_args)
1514 << A->getAsString(Args);
1517 if (XOpenMPTargetNoTriple && XOpenMPTargetArg &&
1518 Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() != 1) {
1519 getDriver().
Diag(diag::err_drv_Xopenmp_target_missing_triple);
1522 XOpenMPTargetArg->setBaseArg(A);
1523 A = XOpenMPTargetArg.release();
1524 AllocatedArgs.push_back(A);
1540 const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A,
1541 llvm::opt::DerivedArgList *DAL,
1544 unsigned ValuePos = 1;
1545 if (A->getOption().matches(options::OPT_Xarch_device) ||
1546 A->getOption().matches(options::OPT_Xarch_host))
1549 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(ValuePos));
1550 unsigned Prev = Index;
1551 std::unique_ptr<llvm::opt::Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1560 if (!XarchArg || Index > Prev + 1) {
1561 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1562 << A->getAsString(Args);
1568 "invalid Xarch argument: '%0', not all driver "
1569 "options can be forwared via Xarch argument");
1570 Diags.Report(DiagID) << A->getAsString(Args);
1573 XarchArg->setBaseArg(A);
1574 A = XarchArg.release();
1576 DAL->AddSynthesizedArg(A);
1578 AllocatedArgs->push_back(A);
1582 const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
1585 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1586 bool Modified =
false;
1589 for (Arg *A : Args) {
1590 bool NeedTrans =
false;
1592 if (A->getOption().matches(options::OPT_Xarch_device)) {
1593 NeedTrans = IsDevice;
1595 }
else if (A->getOption().matches(options::OPT_Xarch_host)) {
1596 NeedTrans = !IsDevice;
1598 }
else if (A->getOption().matches(options::OPT_Xarch__) && IsDevice) {
1602 if (BoundArch.empty() || A->getValue(0) != BoundArch)
1607 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...