16#include "clang/Config/config.h"
25#include "llvm/ADT/STLExtras.h"
26#include "llvm/ADT/SmallString.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/ADT/Twine.h"
29#include "llvm/Config/llvm-config.h"
30#include "llvm/MC/MCTargetOptions.h"
31#include "llvm/MC/TargetRegistry.h"
32#include "llvm/Option/Arg.h"
33#include "llvm/Option/ArgList.h"
34#include "llvm/Option/OptTable.h"
35#include "llvm/Option/Option.h"
36#include "llvm/Support/ErrorHandling.h"
37#include "llvm/Support/FileSystem.h"
38#include "llvm/Support/FileUtilities.h"
39#include "llvm/Support/Path.h"
40#include "llvm/Support/VersionTuple.h"
41#include "llvm/Support/VirtualFileSystem.h"
42#include "llvm/TargetParser/TargetParser.h"
43#include "llvm/TargetParser/Triple.h"
50using namespace driver;
56 return Args.getLastArg(options::OPT_mkernel, options::OPT_fapple_kext,
57 options::OPT_fno_rtti, options::OPT_frtti);
61 const llvm::Triple &Triple,
62 const Arg *CachedRTTIArg) {
65 if (CachedRTTIArg->getOption().matches(options::OPT_frtti))
72 bool NoRTTI = Triple.isPS() || Triple.isDriverKit();
80 auto addIfExists = [
this](
path_list &List,
const std::string &Path) {
95 llvm::sys::fs::createTemporaryFile(
"toolchain-program",
"txt", OutputFile);
96 llvm::FileRemover OutputRemover(OutputFile.c_str());
97 std::optional<llvm::StringRef> Redirects[] = {
103 std::string ErrorMessage;
104 if (llvm::sys::ExecuteAndWait(Executable, {}, {}, Redirects,
107 return llvm::createStringError(std::error_code(),
108 Executable +
": " + ErrorMessage);
110 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> OutputBuf =
111 llvm::MemoryBuffer::getFile(OutputFile.c_str());
113 return llvm::createStringError(OutputBuf.getError(),
114 "Failed to read stdout of " + Executable +
115 ": " + OutputBuf.getError().message());
116 return std::move(*OutputBuf);
120 Triple.setEnvironment(Env);
121 if (EffectiveTriple != llvm::Triple())
122 EffectiveTriple.setEnvironment(Env);
132 return Args.hasFlag(options::OPT_fintegrated_as,
133 options::OPT_fno_integrated_as,
141 "(Non-)integrated backend set incorrectly!");
143 bool IBackend = Args.hasFlag(options::OPT_fintegrated_objemitter,
144 options::OPT_fno_integrated_objemitter,
152 DiagID = clang::diag::err_drv_unsupported_opt_for_target;
154 DiagID = clang::diag::warn_drv_unsupported_opt_for_target;
155 Arg *A = Args.getLastArg(options::OPT_fno_integrated_objemitter);
157 D.
Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
158 A = Args.getLastArg(options::OPT_fintegrated_objemitter);
160 D.
Diag(DiagID) << A->getAsString(Args) << Triple.getTriple();
166 return ENABLE_X86_RELAX_RELOCATIONS;
170 return PPC_LINUX_DEFAULT_IEEELONGDOUBLE &&
getTriple().isOSLinux();
175 SanitizerArgs SanArgs(*
this, JobArgs, !SanitizerArgsChecked);
176 SanitizerArgsChecked =
true;
182 XRayArguments.reset(
new XRayArgs(*
this, Args));
183 return *XRayArguments;
190 const char *ModeFlag;
199 static const DriverSuffix DriverSuffixes[] = {
201 {
"clang++",
"--driver-mode=g++"},
202 {
"clang-c++",
"--driver-mode=g++"},
203 {
"clang-cc",
nullptr},
204 {
"clang-cpp",
"--driver-mode=cpp"},
205 {
"clang-g++",
"--driver-mode=g++"},
206 {
"clang-gcc",
nullptr},
207 {
"clang-cl",
"--driver-mode=cl"},
209 {
"cpp",
"--driver-mode=cpp"},
210 {
"cl",
"--driver-mode=cl"},
211 {
"++",
"--driver-mode=g++"},
212 {
"flang",
"--driver-mode=flang"},
213 {
"clang-dxc",
"--driver-mode=dxc"},
216 for (
const auto &DS : DriverSuffixes) {
217 StringRef Suffix(DS.Suffix);
218 if (ProgName.endswith(Suffix)) {
219 Pos = ProgName.size() - Suffix.size();
229 std::string ProgName = std::string(llvm::sys::path::filename(Argv0));
230 if (is_style_windows(llvm::sys::path::Style::native)) {
232 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(),
248 if (!DS && ProgName.endswith(
".exe")) {
251 ProgName = ProgName.drop_back(StringRef(
".exe").size());
258 ProgName = ProgName.rtrim(
"0123456789.");
265 ProgName = ProgName.slice(0, ProgName.rfind(
'-'));
278 size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);
280 size_t LastComponent = ProgName.rfind(
'-', SuffixPos);
281 if (LastComponent == std::string::npos)
283 std::string ModeSuffix = ProgName.substr(LastComponent + 1,
284 SuffixEnd - LastComponent - 1);
287 StringRef Prefix(ProgName);
288 Prefix = Prefix.slice(0, LastComponent);
289 std::string IgnoredError;
291 llvm::TargetRegistry::lookupTarget(std::string(Prefix), IgnoredError);
300 switch (Triple.getArch()) {
301 case llvm::Triple::aarch64: {
306 case llvm::Triple::aarch64_32:
308 case llvm::Triple::ppc:
310 case llvm::Triple::ppcle:
312 case llvm::Triple::ppc64:
314 case llvm::Triple::ppc64le:
317 return Triple.getArchName();
330Tool *ToolChain::getClang()
const {
336Tool *ToolChain::getFlang()
const {
347 llvm_unreachable(
"Linking is not supported by this toolchain");
351 llvm_unreachable(
"Creating static lib is not supported by this toolchain");
354Tool *ToolChain::getAssemble()
const {
357 return Assemble.get();
360Tool *ToolChain::getClangAs()
const {
363 return Assemble.get();
366Tool *ToolChain::getLink()
const {
372Tool *ToolChain::getStaticLibTool()
const {
375 return StaticLibTool.get();
378Tool *ToolChain::getIfsMerge()
const {
381 return IfsMerge.get();
384Tool *ToolChain::getOffloadBundler()
const {
390Tool *ToolChain::getOffloadPackager()
const {
396Tool *ToolChain::getLinkerWrapper()
const {
405 return getAssemble();
408 return getIfsMerge();
414 return getStaticLibTool();
423 llvm_unreachable(
"Invalid tool kind.");
437 return getOffloadBundler();
440 return getOffloadPackager();
442 return getLinkerWrapper();
445 llvm_unreachable(
"Invalid tool kind.");
449 const ArgList &Args) {
450 const llvm::Triple &Triple = TC.
getTriple();
451 bool IsWindows = Triple.isOSWindows();
454 return Triple.getArchName();
456 if (TC.
getArch() == llvm::Triple::arm || TC.
getArch() == llvm::Triple::armeb)
462 if (TC.
getArch() == llvm::Triple::x86 && Triple.isAndroid())
465 if (TC.
getArch() == llvm::Triple::x86_64 && Triple.isX32())
468 return llvm::Triple::getArchTypeName(TC.
getArch());
472 if (Triple.isOSDarwin())
475 switch (Triple.getOS()) {
476 case llvm::Triple::FreeBSD:
478 case llvm::Triple::NetBSD:
480 case llvm::Triple::OpenBSD:
482 case llvm::Triple::Solaris:
484 case llvm::Triple::AIX:
496 }
else if (Triple.isOSUnknown()) {
497 llvm::sys::path::append(Path,
"lib");
501 return std::string(Path.str());
508 return llvm::sys::path::filename(CRTAbsolutePath).str();
514 bool AddArch)
const {
516 bool IsITANMSVCWindows =
517 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment();
524 Suffix = IsITANMSVCWindows ?
".obj" :
".o";
527 Suffix = IsITANMSVCWindows ?
".lib" :
".a";
530 Suffix = TT.isOSWindows()
531 ? (TT.isWindowsGNUEnvironment() ?
".dll.a" :
".lib")
536 std::string ArchAndEnv;
539 const char *Env = TT.isAndroid() ?
"-android" :
"";
540 ArchAndEnv = (
"-" + Arch + Env).str();
542 return (Prefix + Twine(
"clang_rt.") + Component + ArchAndEnv + Suffix).str();
548 std::string CRTBasename =
552 llvm::sys::path::append(
P, CRTBasename);
554 return std::string(
P.str());
562 llvm::sys::path::append(Path, CRTBasename);
563 return std::string(Path.str());
574 auto addPathForTriple = [
this, &Paths](
const llvm::Triple &Triple) {
576 llvm::sys::path::append(
P,
"lib", Triple.str());
577 Paths.push_back(std::string(
P.str()));
599 ArmTriple.setArch(Triple::arm);
600 addPathForTriple(ArmTriple);
606 getTriple().getEnvironmentName() !=
"android") {
607 llvm::Triple TripleWithoutLevel =
getTriple();
608 TripleWithoutLevel.setEnvironmentName(
"android");
609 addPathForTriple(TripleWithoutLevel);
619 Paths.push_back(std::string(
P.str()));
627 llvm::Triple::getArchTypeName(
getArch()));
628 return std::string(Path.str());
632 if (Args.hasArg(options::OPT_noprofilelib))
635 return Args.hasArg(options::OPT_fprofile_generate) ||
636 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
637 Args.hasArg(options::OPT_fcs_profile_generate) ||
638 Args.hasArg(options::OPT_fcs_profile_generate_EQ) ||
639 Args.hasArg(options::OPT_fprofile_instr_generate) ||
640 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
641 Args.hasArg(options::OPT_fcreate_profile) ||
642 Args.hasArg(options::OPT_forder_file_instrumentation);
646 return Args.hasArg(options::OPT_coverage) ||
647 Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
653 if (
getDriver().ShouldUseClangCompiler(JA))
return getClang();
670 *LinkerIsLLD =
false;
674 const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
675 StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER;
682 if (
const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {
683 std::string Path(A->getValue());
685 if (llvm::sys::path::parent_path(Path).empty())
687 if (llvm::sys::fs::can_execute(Path)) {
689 *LinkerIsLLD = UseLinker ==
"lld";
690 return std::string(Path);
693 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
698 if (UseLinker.empty() || UseLinker ==
"ld") {
700 if (llvm::sys::path::is_absolute(DefaultLinker))
701 return std::string(DefaultLinker);
710 if (UseLinker.contains(
'/'))
713 if (llvm::sys::path::is_absolute(UseLinker)) {
716 if (llvm::sys::fs::can_execute(UseLinker))
717 return std::string(UseLinker);
720 if (Triple.isOSDarwin())
721 LinkerName.append(
"ld64.");
723 LinkerName.append(
"ld.");
724 LinkerName.append(UseLinker);
727 if (llvm::sys::fs::can_execute(LinkerPath)) {
729 *LinkerIsLLD = UseLinker ==
"lld";
735 getDriver().
Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
742 if (Triple.isOSDarwin())
754 id = types::TY_Fortran;
764 llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
765 switch (HostTriple.getArch()) {
768 case llvm::Triple::arm:
769 case llvm::Triple::armeb:
770 case llvm::Triple::thumb:
771 case llvm::Triple::thumbeb:
772 return getArch() != llvm::Triple::arm &&
getArch() != llvm::Triple::thumb &&
773 getArch() != llvm::Triple::armeb &&
getArch() != llvm::Triple::thumbeb;
775 return HostTriple.getArch() !=
getArch();
784llvm::ExceptionHandling
786 return llvm::ExceptionHandling::None;
790 if (Model ==
"single") {
792 return Triple.getArch() == llvm::Triple::arm ||
793 Triple.getArch() == llvm::Triple::armeb ||
794 Triple.getArch() == llvm::Triple::thumb ||
795 Triple.getArch() == llvm::Triple::thumbeb || Triple.isWasm();
796 }
else if (Model ==
"posix")
808 case llvm::Triple::x86_64: {
810 if (!Triple.isOSBinFormatMachO())
813 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
816 StringRef MArch = A->getValue();
817 if (MArch ==
"x86_64h")
818 Triple.setArchName(MArch);
820 return Triple.getTriple();
822 case llvm::Triple::aarch64: {
824 if (!Triple.isOSBinFormatMachO())
827 if (Triple.isArm64e())
833 Triple.setArchName(
"arm64");
834 return Triple.getTriple();
836 case llvm::Triple::aarch64_32:
838 case llvm::Triple::arm:
839 case llvm::Triple::armeb:
840 case llvm::Triple::thumb:
841 case llvm::Triple::thumbeb: {
845 return Triple.getTriple();
860 ArgStringList &CC1Args)
const {
865 const ArgList &DriverArgs, ArgStringList &CC1Args,
869 ArgStringList &CC1ASArgs)
const {}
874 llvm::opt::ArgStringList &CmdArgs)
const {
882 const ArgList &Args)
const {
884 return *runtimeLibType;
886 const Arg* A = Args.getLastArg(options::OPT_rtlib_EQ);
887 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_RTLIB;
890 if (LibName ==
"compiler-rt")
892 else if (LibName ==
"libgcc")
894 else if (LibName ==
"platform")
899 << A->getAsString(Args);
904 return *runtimeLibType;
908 const ArgList &Args)
const {
910 return *unwindLibType;
912 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
913 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;
915 if (LibName ==
"none")
917 else if (LibName ==
"platform" || LibName ==
"") {
926 }
else if (LibName ==
"libunwind") {
930 }
else if (LibName ==
"libgcc")
935 << A->getAsString(Args);
940 return *unwindLibType;
945 return *cxxStdlibType;
947 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
948 StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;
951 if (LibName ==
"libc++")
953 else if (LibName ==
"libstdc++")
955 else if (LibName ==
"platform")
960 << A->getAsString(Args);
965 return *cxxStdlibType;
970 ArgStringList &CC1Args,
972 CC1Args.push_back(
"-internal-isystem");
973 CC1Args.push_back(DriverArgs.MakeArgString(Path));
985 ArgStringList &CC1Args,
987 CC1Args.push_back(
"-internal-externc-isystem");
988 CC1Args.push_back(DriverArgs.MakeArgString(Path));
992 ArgStringList &CC1Args,
994 if (llvm::sys::fs::exists(Path))
1000 ArgStringList &CC1Args,
1002 for (
const auto &Path : Paths) {
1003 CC1Args.push_back(
"-internal-isystem");
1004 CC1Args.push_back(DriverArgs.MakeArgString(Path));
1009 const Twine &B,
const Twine &
C,
1012 llvm::sys::path::append(
Result, llvm::sys::path::Style::posix, A, B,
C, D);
1013 return std::string(
Result);
1019 std::string MaxVersionString;
1021 llvm::sys::path::append(Path,
"c++");
1022 for (llvm::vfs::directory_iterator LI =
getVFS().dir_begin(Path, EC), LE;
1023 !EC && LI != LE; LI = LI.increment(EC)) {
1024 StringRef VersionText = llvm::sys::path::filename(LI->path());
1026 if (VersionText[0] ==
'v' &&
1027 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
1028 if (Version > MaxVersion) {
1029 MaxVersion = Version;
1030 MaxVersionString = std::string(VersionText);
1036 return MaxVersionString;
1040 ArgStringList &CC1Args)
const {
1050 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ);
1054 const llvm::opt::ArgList &DriverArgs,
1055 llvm::opt::ArgStringList &CC1Args)
const {
1056 DriverArgs.ClaimAllArgs(options::OPT_stdlibxx_isystem);
1065 if (!DriverArgs.hasArg(options::OPT_nostdincxx))
1066 for (
const auto &
P :
1067 DriverArgs.getAllArgValues(options::OPT_stdlibxx_isystem))
1073 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
1074 options::OPT_nostdlibxx);
1078 ArgStringList &CmdArgs)
const {
1079 assert(!Args.hasArg(options::OPT_nostdlibxx) &&
1080 "should not have called this");
1085 CmdArgs.push_back(
"-lc++");
1086 if (Args.hasArg(options::OPT_fexperimental_library))
1087 CmdArgs.push_back(
"-lc++experimental");
1091 CmdArgs.push_back(
"-lstdc++");
1097 ArgStringList &CmdArgs)
const {
1099 if(LibPath.length() > 0)
1100 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
1104 ArgStringList &CmdArgs)
const {
1105 CmdArgs.push_back(
"-lcc_kext");
1109 std::string &Path)
const {
1115 Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math,
1116 options::OPT_funsafe_math_optimizations,
1117 options::OPT_fno_unsafe_math_optimizations);
1119 if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
1120 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
1125 return (Path !=
"crtfastmath.o");
1129 ArgStringList &CmdArgs)
const {
1132 CmdArgs.push_back(Args.MakeArgString(Path));
1151 (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
1152 SanitizerKind::CFICastStrict | SanitizerKind::FloatDivideByZero |
1153 SanitizerKind::KCFI | SanitizerKind::UnsignedIntegerOverflow |
1154 SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |
1155 SanitizerKind::Nullability | SanitizerKind::LocalBounds;
1156 if (
getTriple().getArch() == llvm::Triple::x86 ||
1157 getTriple().getArch() == llvm::Triple::x86_64 ||
1160 Res |= SanitizerKind::CFIICall;
1161 if (
getTriple().getArch() == llvm::Triple::x86_64 ||
1163 Res |= SanitizerKind::ShadowCallStack;
1165 Res |= SanitizerKind::MemTag;
1170 ArgStringList &CC1Args)
const {}
1173 ArgStringList &CC1Args)
const {}
1181 ArgStringList &CC1Args)
const {}
1185 return VersionTuple(Version);
1187 if (Version < 10000)
1188 return VersionTuple(Version / 100, Version % 100);
1190 unsigned Build = 0, Factor = 1;
1191 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
1192 Build = Build + (Version % 10) * Factor;
1193 return VersionTuple(Version / 100, Version % 100, Build);
1198 const llvm::opt::ArgList &Args)
const {
1199 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
1200 const Arg *MSCompatibilityVersion =
1201 Args.getLastArg(options::OPT_fms_compatibility_version);
1203 if (MSCVersion && MSCompatibilityVersion) {
1205 D->
Diag(diag::err_drv_argument_not_allowed_with)
1206 << MSCVersion->getAsString(Args)
1207 << MSCompatibilityVersion->getAsString(Args);
1208 return VersionTuple();
1211 if (MSCompatibilityVersion) {
1213 if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
1215 D->
Diag(diag::err_drv_invalid_value)
1216 << MSCompatibilityVersion->getAsString(Args)
1217 << MSCompatibilityVersion->getValue();
1224 unsigned Version = 0;
1225 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version)) {
1227 D->
Diag(diag::err_drv_invalid_value)
1228 << MSCVersion->getAsString(Args) << MSCVersion->getValue();
1234 return VersionTuple();
1238 const llvm::opt::DerivedArgList &Args,
bool SameTripleAsHost,
1240 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1242 bool Modified =
false;
1245 for (
auto *A : Args) {
1250 if (A->getOption().matches(options::OPT_m_Group)) {
1251 if (SameTripleAsHost)
1260 bool XOpenMPTargetNoTriple =
1261 A->getOption().matches(options::OPT_Xopenmp_target);
1263 if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) {
1268 Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1271 }
else if (XOpenMPTargetNoTriple) {
1273 Index = Args.getBaseArgs().MakeIndex(A->getValue(0));
1281 std::unique_ptr<Arg> XOpenMPTargetArg(Opts.ParseOneArg(Args, Index));
1282 if (!XOpenMPTargetArg || Index > Prev + 1) {
1283 getDriver().
Diag(diag::err_drv_invalid_Xopenmp_target_with_args)
1284 << A->getAsString(Args);
1287 if (XOpenMPTargetNoTriple && XOpenMPTargetArg &&
1288 Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() != 1) {
1289 getDriver().
Diag(diag::err_drv_Xopenmp_target_missing_triple);
1292 XOpenMPTargetArg->setBaseArg(A);
1293 A = XOpenMPTargetArg.release();
1294 AllocatedArgs.push_back(A);
1310 const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A,
1311 llvm::opt::DerivedArgList *DAL,
1314 unsigned ValuePos = 1;
1315 if (A->getOption().matches(options::OPT_Xarch_device) ||
1316 A->getOption().matches(options::OPT_Xarch_host))
1319 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(ValuePos));
1320 unsigned Prev = Index;
1321 std::unique_ptr<llvm::opt::Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1330 if (!XarchArg || Index > Prev + 1) {
1331 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1332 << A->getAsString(Args);
1338 "invalid Xarch argument: '%0', not all driver "
1339 "options can be forwared via Xarch argument");
1340 Diags.Report(DiagID) << A->getAsString(Args);
1343 XarchArg->setBaseArg(A);
1344 A = XarchArg.release();
1346 DAL->AddSynthesizedArg(A);
1348 AllocatedArgs->push_back(A);
1352 const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
1355 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1356 bool Modified =
false;
1359 for (Arg *A : Args) {
1360 bool NeedTrans =
false;
1362 if (A->getOption().matches(options::OPT_Xarch_device)) {
1363 NeedTrans = IsDevice;
1365 }
else if (A->getOption().matches(options::OPT_Xarch_host)) {
1366 NeedTrans = !IsDevice;
1368 }
else if (A->getOption().matches(options::OPT_Xarch__) && IsDevice) {
1372 if (BoundArch.empty() || A->getValue(0) != BoundArch)
1377 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.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
@ C
Languages that the frontend can parse and compile.
@ Result
The result type of a method or function.
YAML serialization mapping.
Helper structure used to pass information extracted from clang executable name such as i686-linux-and...