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/CommandLine.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/FileSystem.h"
42 #include "llvm/Support/FileUtilities.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/VersionTuple.h"
45 #include "llvm/Support/VirtualFileSystem.h"
46 #include "llvm/TargetParser/AArch64TargetParser.h"
47 #include "llvm/TargetParser/TargetParser.h"
48 #include "llvm/TargetParser/Triple.h"
54 using namespace clang;
55 using namespace driver;
56 using namespace tools;
61 return Args.getLastArg(options::OPT_mkernel, options::OPT_fapple_kext,
62 options::OPT_fno_rtti, options::OPT_frtti);
66 const llvm::Triple &Triple,
67 const Arg *CachedRTTIArg) {
70 if (CachedRTTIArg->getOption().matches(options::OPT_frtti))
77 bool NoRTTI = Triple.isPS() || Triple.isDriverKit();
82 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
94 auto addIfExists = [
this](
path_list &List,
const std::string &Path) {
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,
122 return llvm::createStringError(std::error_code(),
123 Executable +
": " + ErrorMessage);
125 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
126 llvm::MemoryBuffer::getFile(OutputFile.c_str());
128 return llvm::createStringError(OutputBuf.getError(),
129 "Failed to read stdout of " + Executable +
130 ": " + OutputBuf.getError().message());
131 return std::move(*OutputBuf);
135 Triple.setEnvironment(
Env);
136 if (EffectiveTriple != llvm::Triple())
137 EffectiveTriple.setEnvironment(
Env);
147 return Args.hasFlag(options::OPT_fintegrated_as,
148 options::OPT_fno_integrated_as,
156 "(Non-)integrated backend set incorrectly!");
158 bool IBackend = Args.hasFlag(options::OPT_fintegrated_objemitter,
159 options::OPT_fno_integrated_objemitter,
167 DiagID = clang::diag::err_drv_unsupported_opt_for_target;
169 DiagID = clang::diag::warn_drv_unsupported_opt_for_target;
170 Arg *A = Args.getLastArg(options::OPT_fno_integrated_objemitter);
172 D.
Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
173 A = Args.getLastArg(options::OPT_fintegrated_objemitter);
175 D.
Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
181 return ENABLE_X86_RELAX_RELOCATIONS;
185 return PPC_LINUX_DEFAULT_IEEELONGDOUBLE &&
getTriple().isOSLinux();
189 const llvm::Triple &Triple,
190 const llvm::opt::ArgList &Args,
192 std::vector<StringRef> Features;
196 UnifiedFeatures.end());
197 std::vector<std::string> MArch;
198 for (
const auto &Ext : AArch64::Extensions)
199 if (FeatureSet.contains(Ext.Feature))
200 MArch.push_back(Ext.Name.str());
201 for (
const auto &Ext : AArch64::Extensions)
202 if (FeatureSet.contains(Ext.NegFeature))
203 MArch.push_back((
"no" + Ext.Name).str());
205 for (
const auto &ArchInfo : AArch64::ArchInfos)
206 if (FeatureSet.contains(ArchInfo->ArchFeature))
207 ArchName = ArchInfo->Name;
208 assert(!ArchName.empty() &&
"at least one architecture should be found");
209 MArch.insert(MArch.begin(), (
"-march=" + ArchName).str());
210 Result.push_back(llvm::join(MArch,
"+"));
214 const llvm::Triple &Triple,
215 const llvm::opt::ArgList &Args,
217 std::vector<StringRef> Features;
219 D, Triple, Args, Features,
false ,
true );
222 UnifiedFeatures.end());
223 std::vector<std::string> MArch;
224 for (
const auto &Ext : ARM::ARCHExtNames)
225 if (FeatureSet.contains(Ext.Feature))
226 MArch.push_back(Ext.Name.str());
227 for (
const auto &Ext : ARM::ARCHExtNames)
228 if (FeatureSet.contains(Ext.NegFeature))
229 MArch.push_back((
"no" + Ext.Name).str());
230 MArch.insert(MArch.begin(), (
"-march=" + Triple.getArchName()).str());
231 Result.push_back(llvm::join(MArch,
"+"));
234 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) \
235 case llvm::ARM::KIND: \
236 Result.push_back("-mfpu=" NAME); \
238 #include "llvm/TargetParser/ARMTargetParser.def"
240 llvm_unreachable(
"Invalid FPUKind");
244 case arm::FloatABI::Soft:
245 Result.push_back(
"-mfloat-abi=soft");
247 case arm::FloatABI::SoftFP:
248 Result.push_back(
"-mfloat-abi=softfp");
250 case arm::FloatABI::Hard:
251 Result.push_back(
"-mfloat-abi=hard");
253 case arm::FloatABI::Invalid:
254 llvm_unreachable(
"Invalid float ABI");
262 std::vector<std::string> Result;
264 Result.push_back(
"--target=" + Triple.str());
266 switch (Triple.getArch()) {
267 case llvm::Triple::aarch64:
268 case llvm::Triple::aarch64_32:
269 case llvm::Triple::aarch64_be:
272 case llvm::Triple::arm:
273 case llvm::Triple::armeb:
274 case llvm::Triple::thumb:
275 case llvm::Triple::thumbeb:
284 if (
getRTTIMode() == ToolChain::RTTIMode::RM_Disabled)
285 Result.push_back(
"-fno-rtti");
287 Result.push_back(
"-frtti");
290 Result.push_back(
"-fno-exceptions");
292 Result.push_back(
"-fexceptions");
295 std::sort(Result.begin(), Result.end());
296 Result.erase(std::unique(Result.begin(), Result.end()), Result.end());
302 SanitizerArgs SanArgs(*
this, JobArgs, !SanitizerArgsChecked);
303 SanitizerArgsChecked =
true;
309 XRayArguments.reset(
new XRayArgs(*
this, Args));
310 return *XRayArguments;
315 struct DriverSuffix {
317 const char *ModeFlag;
326 static const DriverSuffix DriverSuffixes[] = {
328 {
"clang++",
"--driver-mode=g++"},
329 {
"clang-c++",
"--driver-mode=g++"},
330 {
"clang-cc",
nullptr},
331 {
"clang-cpp",
"--driver-mode=cpp"},
332 {
"clang-g++",
"--driver-mode=g++"},
333 {
"clang-gcc",
nullptr},
334 {
"clang-cl",
"--driver-mode=cl"},
336 {
"cpp",
"--driver-mode=cpp"},
337 {
"cl",
"--driver-mode=cl"},
338 {
"++",
"--driver-mode=g++"},
339 {
"flang",
"--driver-mode=flang"},
340 {
"clang-dxc",
"--driver-mode=dxc"},
343 for (
const auto &DS : DriverSuffixes) {
344 StringRef Suffix(DS.Suffix);
345 if (ProgName.ends_with(Suffix)) {
346 Pos = ProgName.size() - Suffix.size();
356 std::string ProgName = std::string(llvm::sys::path::filename(Argv0));
357 if (is_style_windows(llvm::sys::path::Style::native)) {
359 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),
375 if (!DS && ProgName.ends_with(
".exe")) {
378 ProgName = ProgName.drop_back(StringRef(
".exe").size());
385 ProgName = ProgName.rtrim(
"0123456789.");
392 ProgName = ProgName.slice(0, ProgName.rfind(
'-'));
405 size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);
407 size_t LastComponent = ProgName.rfind(
'-', SuffixPos);
408 if (LastComponent == std::string::npos)
410 std::string ModeSuffix = ProgName.substr(LastComponent + 1,
411 SuffixEnd - LastComponent - 1);
414 StringRef Prefix(ProgName);
415 Prefix = Prefix.slice(0, LastComponent);
416 std::string IgnoredError;
418 llvm::TargetRegistry::lookupTarget(std::string(Prefix), IgnoredError);
427 switch (Triple.getArch()) {
428 case llvm::Triple::aarch64: {
433 case llvm::Triple::aarch64_32:
435 case llvm::Triple::ppc:
437 case llvm::Triple::ppcle:
439 case llvm::Triple::ppc64:
441 case llvm::Triple::ppc64le:
444 return Triple.getArchName();
457 Tool *ToolChain::getClang()
const {
463 Tool *ToolChain::getFlang()
const {
474 llvm_unreachable(
"Linking is not supported by this toolchain");
478 llvm_unreachable(
"Backend Compilation is not supported by this toolchain");
482 llvm_unreachable(
"Creating static lib is not supported by this toolchain");
485 Tool *ToolChain::getAssemble()
const {
488 return Assemble.get();
491 Tool *ToolChain::getClangAs()
const {
494 return Assemble.get();
497 Tool *ToolChain::getLink()
const {
503 Tool *ToolChain::getStaticLibTool()
const {
506 return StaticLibTool.get();
509 Tool *ToolChain::getIfsMerge()
const {
512 return IfsMerge.get();
515 Tool *ToolChain::getOffloadBundler()
const {
521 Tool *ToolChain::getOffloadWrapper()
const {
527 Tool *ToolChain::getOffloadPackager()
const {
533 Tool *ToolChain::getOffloadDeps()
const {
539 Tool *ToolChain::getSPIRVTranslator()
const {
545 Tool *ToolChain::getSYCLPostLink()
const {
551 Tool *ToolChain::getBackendCompiler()
const {
552 if (!BackendCompiler)
554 return BackendCompiler.get();
557 Tool *ToolChain::getAppendFooter()
const {
563 Tool *ToolChain::getTableTform()
const {
569 Tool *ToolChain::getSpirvToIrWrapper()
const {
575 Tool *ToolChain::getLinkerWrapper()
const {
584 return getAssemble();
587 return getIfsMerge();
593 return getStaticLibTool();
603 llvm_unreachable(
"Invalid tool kind.");
617 return getOffloadBundler();
620 return getOffloadWrapper();
622 return getOffloadPackager();
625 return getOffloadDeps();
628 return getSPIRVTranslator();
631 return getSYCLPostLink();
634 return getBackendCompiler();
637 return getAppendFooter();
640 return getTableTform();
643 return getSpirvToIrWrapper();
646 return getLinkerWrapper();
649 llvm_unreachable(
"Invalid tool kind.");
653 const ArgList &Args) {
654 const llvm::Triple &Triple = TC.
getTriple();
655 bool IsWindows = Triple.isOSWindows();
658 return Triple.getArchName();
660 if (TC.
getArch() == llvm::Triple::arm || TC.
getArch() == llvm::Triple::armeb)
666 if (TC.
getArch() == llvm::Triple::x86 && Triple.isAndroid())
669 if (TC.
getArch() == llvm::Triple::x86_64 && Triple.isX32())
672 return llvm::Triple::getArchTypeName(TC.
getArch());
676 if (Triple.isOSDarwin())
679 switch (Triple.getOS()) {
680 case llvm::Triple::FreeBSD:
682 case llvm::Triple::NetBSD:
684 case llvm::Triple::OpenBSD:
686 case llvm::Triple::Solaris:
702 }
else if (Triple.isOSUnknown()) {
703 llvm::sys::path::append(Path,
"lib");
707 return std::string(Path);
714 return llvm::sys::path::filename(CRTAbsolutePath).str();
720 bool AddArch)
const {
722 bool IsITANMSVCWindows =
723 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();
730 Suffix = IsITANMSVCWindows ?
".obj" :
".o";
733 Suffix = IsITANMSVCWindows ?
".lib" :
".a";
736 Suffix = TT.isOSWindows()
737 ? (TT.isWindowsGNUEnvironment() ?
".dll.a" :
".lib")
742 std::string ArchAndEnv;
745 const char *
Env = TT.isAndroid() ?
"-android" :
"";
746 ArchAndEnv = (
"-" + Arch +
Env).str();
748 return (Prefix + Twine(
"clang_rt.") + Component + ArchAndEnv + Suffix).str();
754 std::string CRTBasename =
759 llvm::sys::path::append(
P, CRTBasename);
761 return std::string(
P);
772 llvm::sys::path::append(OldPath, CRTBasename);
773 if (Path.empty() ||
getVFS().exists(OldPath))
774 return std::string(OldPath);
779 return std::string(Path);
791 std::optional<std::string>
792 ToolChain::getFallbackAndroidTargetPath(StringRef BaseDir)
const {
793 llvm::Triple TripleWithoutLevel(
getTriple());
794 TripleWithoutLevel.setEnvironmentName(
"android");
795 const std::string &TripleWithoutLevelStr = TripleWithoutLevel.str();
796 unsigned TripleVersion =
getTriple().getEnvironmentVersion().getMajor();
797 unsigned BestVersion = 0;
800 bool UsingUnversionedDir =
false;
802 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(BaseDir, EC),
LE;
803 !EC && LI !=
LE; LI = LI.increment(EC)) {
804 StringRef DirName = llvm::sys::path::filename(LI->path());
805 StringRef DirNameSuffix = DirName;
806 if (DirNameSuffix.consume_front(TripleWithoutLevelStr)) {
807 if (DirNameSuffix.empty() && TripleDir.empty()) {
809 UsingUnversionedDir =
true;
812 if (!DirNameSuffix.getAsInteger(10, Version) && Version > BestVersion &&
813 Version < TripleVersion) {
814 BestVersion = Version;
816 UsingUnversionedDir =
false;
822 if (TripleDir.empty())
826 llvm::sys::path::append(
P, TripleDir);
827 if (UsingUnversionedDir)
829 return std::string(
P);
832 std::optional<std::string>
834 auto getPathForTriple =
835 [&](
const llvm::Triple &Triple) -> std::optional<std::string> {
837 llvm::sys::path::append(
P, Triple.str());
839 return std::string(
P);
843 if (
auto Path = getPathForTriple(
getTriple()))
863 ArmTriple.setArch(Triple::arm);
864 if (
auto Path = getPathForTriple(ArmTriple))
869 return getFallbackAndroidTargetPath(BaseDir);
876 llvm::sys::path::append(
P,
"lib");
880 if (Triple.isOSDarwin())
882 llvm::sys::path::append(
P, Triple.str());
883 return std::string(
P);
888 llvm::sys::path::append(
P,
"..",
"lib");
897 llvm::sys::path::append(Path,
"lib");
899 llvm::sys::path::append(Path, S);
900 Paths.push_back(std::string(Path));
909 if (Args.hasArg(options::OPT_noprofilelib))
912 return Args.hasArg(options::OPT_fprofile_generate) ||
913 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
914 Args.hasArg(options::OPT_fcs_profile_generate) ||
915 Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||
916 Args.hasArg(options::OPT_fprofile_instr_generate) ||
917 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
918 Args.hasArg(options::OPT_fcreate_profile) ||
919 Args.hasArg(options::OPT_forder_file_instrumentation);
923 return Args.hasArg(options::OPT_coverage) ||
924 Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
930 if (
getDriver().ShouldUseClangCompiler(JA))
return getClang();
948 *LinkerIsLLD =
false;
952 const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
953 StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER;
960 if (
const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {
961 std::string Path(A->getValue());
963 if (llvm::sys::path::parent_path(Path).empty())
965 if (llvm::sys::fs::can_execute(Path)) {
967 *LinkerIsLLD = UseLinker ==
"lld";
968 return std::string(Path);
971 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
976 if (UseLinker.empty() || UseLinker ==
"ld") {
978 if (llvm::sys::path::is_absolute(DefaultLinker))
979 return std::string(DefaultLinker);
988 if (UseLinker.contains(
'/'))
991 if (llvm::sys::path::is_absolute(UseLinker)) {
994 if (llvm::sys::fs::can_execute(UseLinker))
995 return std::string(UseLinker);
998 if (Triple.isOSDarwin())
999 LinkerName.append(
"ld64.");
1001 LinkerName.append(
"ld.");
1002 LinkerName.append(UseLinker);
1005 if (llvm::sys::fs::can_execute(LinkerPath)) {
1007 *LinkerIsLLD = UseLinker ==
"lld";
1013 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
1020 if (Triple.isOSDarwin())
1031 if (D.
IsFlangMode() &&
id == types::TY_PP_Fortran)
1032 id = types::TY_Fortran;
1042 llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
1043 switch (HostTriple.getArch()) {
1046 case llvm::Triple::arm:
1047 case llvm::Triple::armeb:
1048 case llvm::Triple::thumb:
1049 case llvm::Triple::thumbeb:
1050 return getArch() != llvm::Triple::arm &&
getArch() != llvm::Triple::thumb &&
1051 getArch() != llvm::Triple::armeb &&
getArch() != llvm::Triple::thumbeb;
1053 return HostTriple.getArch() !=
getArch();
1062 llvm::ExceptionHandling
1068 if (Model ==
"single") {
1070 return Triple.getArch() == llvm::Triple::arm ||
1071 Triple.getArch() == llvm::Triple::armeb ||
1072 Triple.getArch() == llvm::Triple::thumb ||
1073 Triple.getArch() == llvm::Triple::thumbeb || Triple.isWasm();
1074 }
else if (Model ==
"posix")
1086 case llvm::Triple::x86_64: {
1088 if (!Triple.isOSBinFormatMachO())
1091 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1094 StringRef MArch = A->getValue();
1095 if (MArch ==
"x86_64h")
1096 Triple.setArchName(MArch);
1098 return Triple.getTriple();
1100 case llvm::Triple::aarch64: {
1102 if (!Triple.isOSBinFormatMachO())
1105 if (Triple.isArm64e())
1111 Triple.setArchName(
"arm64");
1112 return Triple.getTriple();
1114 case llvm::Triple::aarch64_32:
1116 case llvm::Triple::arm:
1117 case llvm::Triple::armeb:
1118 case llvm::Triple::thumb:
1119 case llvm::Triple::thumbeb: {
1123 return Triple.getTriple();
1138 ArgStringList &CC1Args)
const {
1143 const ArgList &DriverArgs, ArgStringList &CC1Args,
1147 ArgStringList &CC1ASArgs)
const {}
1152 llvm::opt::ArgStringList &CmdArgs)
const {
1160 const ArgList &Args)
const {
1162 return *runtimeLibType;
1164 const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);
1165 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;
1168 if (LibName ==
"compiler-rt")
1170 else if (LibName ==
"libgcc")
1172 else if (LibName ==
"platform")
1177 << A->getAsString(Args);
1182 return *runtimeLibType;
1186 const ArgList &Args)
const {
1188 return *unwindLibType;
1190 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
1191 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;
1193 if (LibName ==
"none")
1195 else if (LibName ==
"platform" || LibName ==
"") {
1204 }
else if (LibName ==
"libunwind") {
1208 }
else if (LibName ==
"libgcc")
1213 << A->getAsString(Args);
1218 return *unwindLibType;
1223 return *cxxStdlibType;
1225 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1226 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;
1229 if (LibName ==
"libc++")
1231 else if (LibName ==
"libstdc++")
1233 else if (LibName ==
"platform")
1238 << A->getAsString(Args);
1243 return *cxxStdlibType;
1248 ArgStringList &CC1Args,
1249 const Twine &Path) {
1250 CC1Args.push_back(
"-internal-isystem");
1251 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1263 ArgStringList &CC1Args,
1264 const Twine &Path) {
1265 CC1Args.push_back(
"-internal-externc-isystem");
1266 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1270 ArgStringList &CC1Args,
1271 const Twine &Path) {
1272 if (llvm::sys::fs::exists(Path))
1278 ArgStringList &CC1Args,
1280 for (
const auto &Path : Paths) {
1281 CC1Args.push_back(
"-internal-isystem");
1282 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1287 const Twine &B,
const Twine &C,
1290 llvm::sys::path::append(Result, llvm::sys::path::Style::posix, A, B, C, D);
1291 return std::string(Result);
1297 std::string MaxVersionString;
1299 llvm::sys::path::append(Path,
"c++");
1300 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(Path, EC),
LE;
1301 !EC && LI !=
LE; LI = LI.increment(EC)) {
1302 StringRef VersionText = llvm::sys::path::filename(LI->path());
1304 if (VersionText[0] ==
'v' &&
1305 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
1306 if (Version > MaxVersion) {
1307 MaxVersion = Version;
1308 MaxVersionString = std::string(VersionText);
1314 return MaxVersionString;
1318 ArgStringList &CC1Args)
const {
1328 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);
1332 const llvm::opt::ArgList &DriverArgs,
1333 llvm::opt::ArgStringList &CC1Args)
const {
1334 DriverArgs.ClaimAllArgs(options::OPT_stdlibxx_isystem);
1343 if (!DriverArgs.hasArg(options::OPT_nostdincxx))
1344 for (
const auto &
P :
1345 DriverArgs.getAllArgValues(options::OPT_stdlibxx_isystem))
1351 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
1352 options::OPT_nostdlibxx);
1356 ArgStringList &CmdArgs)
const {
1357 assert(!Args.hasArg(options::OPT_nostdlibxx) &&
1358 "should not have called this");
1363 CmdArgs.push_back(
"-lc++");
1364 if (Args.hasArg(options::OPT_fexperimental_library))
1365 CmdArgs.push_back(
"-lc++experimental");
1369 CmdArgs.push_back(
"-lstdc++");
1375 ArgStringList &CmdArgs)
const {
1377 if(LibPath.length() > 0)
1378 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
1382 ArgStringList &CmdArgs)
const {
1383 CmdArgs.push_back(
"-lcc_kext");
1387 std::string &Path)
const {
1391 bool Default = !Args.hasArgNoClaim(options::OPT_shared);
1397 Arg *A = Args.getLastArg(
1398 options::OPT_ffast_math, options::OPT_fno_fast_math,
1399 options::OPT_funsafe_math_optimizations,
1400 options::OPT_fno_unsafe_math_optimizations, options::OPT_ffp_model_EQ);
1402 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
1403 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
1405 if (A && A->getOption().getID() == options::OPT_ffp_model_EQ) {
1406 StringRef Model = A->getValue();
1407 if (Model !=
"fast")
1414 if (!Args.hasFlag(options::OPT_mdaz_ftz, options::OPT_mno_daz_ftz,
Default))
1419 return (Path !=
"crtfastmath.o");
1423 ArgStringList &CmdArgs)
const {
1426 CmdArgs.push_back(Args.MakeArgString(Path));
1444 (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
1445 SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero |
1446 SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow |
1447 SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |
1449 if (
getTriple().getArch() == llvm::Triple::x86 ||
1450 getTriple().getArch() == llvm::Triple::x86_64 ||
1454 Res |= SanitizerKind::CFIICall;
1455 if (
getTriple().getArch() == llvm::Triple::x86_64 ||
1457 Res |= SanitizerKind::ShadowCallStack;
1459 Res |= SanitizerKind::MemTag;
1464 ArgStringList &CC1Args)
const {}
1467 ArgStringList &CC1Args)
const {}
1471 const ArgList &DriverArgs,
1477 ArgStringList &CC1Args)
const {}
1481 return VersionTuple(Version);
1483 if (Version < 10000)
1484 return VersionTuple(Version / 100, Version % 100);
1486 unsigned Build = 0, Factor = 1;
1487 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
1488 Build = Build + (Version % 10) * Factor;
1489 return VersionTuple(Version / 100, Version % 100, Build);
1494 const llvm::opt::ArgList &Args)
const {
1495 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
1496 const Arg *MSCompatibilityVersion =
1497 Args.getLastArg(options::OPT_fms_compatibility_version);
1499 if (MSCVersion && MSCompatibilityVersion) {
1501 D->
Diag(diag::err_drv_argument_not_allowed_with)
1502 << MSCVersion->getAsString(Args)
1503 << MSCompatibilityVersion->getAsString(Args);
1504 return VersionTuple();
1507 if (MSCompatibilityVersion) {
1509 if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
1511 D->
Diag(diag::err_drv_invalid_value)
1512 << MSCompatibilityVersion->getAsString(Args)
1513 << MSCompatibilityVersion->getValue();
1520 unsigned Version = 0;
1521 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {
1523 D->
Diag(diag::err_drv_invalid_value)
1524 << MSCVersion->getAsString(Args) << MSCVersion->getValue();
1530 return VersionTuple();
1534 const llvm::opt::DerivedArgList &Args,
bool SameTripleAsHost,
1539 "requires OpenMP or SYCL offload kind");
1540 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1542 bool Modified =
false;
1545 for (
auto *A : Args) {
1550 if (A->getOption().matches(options::OPT_m_Group)) {
1555 if (SameTripleAsHost ||
1556 A->getOption().matches(options::OPT_mcode_object_version_EQ) ||
1564 A->getOption().matches(options::OPT_LongDouble_Group)) {
1573 if (A->getOption().matches(options::OPT_fsycl)) {
1580 bool XOffloadTargetNoTriple;
1585 XOffloadTargetNoTriple =
1586 A->getOption().matches(options::OPT_Xopenmp_target);
1587 if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {
1592 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1595 }
else if (XOffloadTargetNoTriple) {
1597 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));
1603 XOffloadTargetNoTriple =
1604 A->getOption().matches(options::OPT_Xsycl_frontend);
1605 if (A->getOption().matches(options::OPT_Xsycl_frontend_EQ)) {
1608 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1611 }
else if (XOffloadTargetNoTriple) {
1613 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));
1622 std::unique_ptr<Arg> XOffloadTargetArg(Opts.ParseOneArg(Args, Index));
1623 if (!XOffloadTargetArg || Index > Prev + 1) {
1625 getDriver().
Diag(diag::err_drv_invalid_Xopenmp_target_with_args)
1626 << A->getAsString(Args);
1628 getDriver().
Diag(diag::err_drv_invalid_Xsycl_frontend_with_args)
1629 << A->getAsString(Args);
1633 if (XOffloadTargetNoTriple && XOffloadTargetArg) {
1636 auto SingleTargetTripleCount = [&Args](OptSpecifier Opt) {
1637 const Arg *TargetArg = Args.getLastArg(Opt);
1638 if (!TargetArg || TargetArg->getValues().size() == 1)
1643 !SingleTargetTripleCount(options::OPT_fopenmp_targets_EQ)) {
1644 getDriver().
Diag(diag::err_drv_Xopenmp_target_missing_triple);
1648 !SingleTargetTripleCount(options::OPT_fsycl_targets_EQ)) {
1650 << A->getSpelling();
1655 XOffloadTargetArg->setBaseArg(A);
1656 A = XOffloadTargetArg.release();
1657 AllocatedArgs.push_back(A);
1673 const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A,
1674 llvm::opt::DerivedArgList *DAL,
1677 unsigned ValuePos = 1;
1678 if (A->getOption().matches(options::OPT_Xarch_device) ||
1679 A->getOption().matches(options::OPT_Xarch_host))
1682 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(ValuePos));
1683 unsigned Prev = Index;
1684 std::unique_ptr<llvm::opt::Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1693 if (!XarchArg || Index > Prev + 1) {
1694 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1695 << A->getAsString(Args);
1701 "invalid Xarch argument: '%0', not all driver "
1702 "options can be forwared via Xarch argument");
1703 Diags.Report(DiagID) << A->getAsString(Args);
1706 XarchArg->setBaseArg(A);
1707 A = XarchArg.release();
1709 DAL->AddSynthesizedArg(A);
1711 AllocatedArgs->push_back(A);
1715 const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
1718 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1719 bool Modified =
false;
1722 for (Arg *A : Args) {
1723 bool NeedTrans =
false;
1725 if (A->getOption().matches(options::OPT_Xarch_device)) {
1726 NeedTrans = IsDevice;
1728 }
else if (A->getOption().matches(options::OPT_Xarch_host)) {
1729 NeedTrans = !IsDevice;
1731 }
else if (A->getOption().matches(options::OPT_Xarch__) && IsDevice) {
1735 if (BoundArch.empty() || A->getValue(0) != BoundArch)
1740 if (NeedTrans || Skip)
clang::driver::toolchains::AIX AIX
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
@ SpirvToIrWrapperJobClass
@ OffloadUnbundlingJobClass
@ OffloadBundlingJobClass
@ SPIRVTranslatorJobClass
@ 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.
llvm::vfs::FileSystem & getVFS() const
DiagnosticBuilder Diag(unsigned DiagID) const
DiagnosticsEngine & getDiags() const
std::string GetProgramPath(StringRef Name, const ToolChain &TC) const
GetProgramPath - Lookup Name in the list of program search paths.
const llvm::opt::OptTable & getOpts() const
std::string ResourceDir
The path to the compiler resource directory.
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
SYCL post-link device code processing tool.
constexpr XRayInstrMask None
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
bool LE(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
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...