17#include "llvm/Option/ArgList.h"
18#include "llvm/Support/FileSystem.h"
19#include "llvm/Support/Path.h"
20#include "llvm/Support/VirtualFileSystem.h"
30 return llvm::StringSwitch<StringRef>(HvxVer)
39 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
40 StringRef Val = A->getValue();
41 if (!Val.equals_insensitive(
"64b") && !Val.equals_insensitive(
"128b"))
42 D.
Diag(diag::err_drv_unsupported_option_argument)
43 << A->getSpelling() << Val;
49 std::vector<StringRef> &Features,
50 StringRef Cpu,
bool &HasHVX) {
54 auto makeFeature = [&Args](Twine
T,
bool Enable) -> StringRef {
55 const std::string &S =
T.str();
57 Opt.consume_back(
"=");
58 if (Opt.starts_with(
"mno-"))
59 Opt = Opt.drop_front(4);
60 else if (Opt.starts_with(
"m"))
61 Opt = Opt.drop_front(1);
62 return Args.MakeArgString(Twine(Enable ?
"+" :
"-") + Twine(Opt));
65 auto withMinus = [](StringRef S) -> std::string {
69 std::optional<std::string> HvxVer =
71 HasHVX = HvxVer.has_value();
73 Features.push_back(makeFeature(Twine(
"hvx") + *HvxVer,
true));
75 if (Arg *A = Args.getLastArg(options::OPT_mno_hexagon_hvx)) {
77 Features.push_back(makeFeature(A->getOption().getName(),
false));
85 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
88 D.
Diag(diag::err_drv_needs_hvx) << withMinus(A->getOption().getName());
89 else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ))
90 HvxLen = A->getValue();
94 StringRef L = makeFeature(Twine(
"hvx-length") + HvxLen.lower(),
true);
95 Features.push_back(L);
98 unsigned HvxVerNum = 0;
101 StringRef HvxVerRef(*HvxVer);
102 if (HvxVerRef.size() <= 1 ||
103 HvxVerRef.drop_front(1).getAsInteger(10, HvxVerNum))
108 auto checkFlagHvxVersion =
109 [&](
auto FlagOn,
auto FlagOnWithModes,
auto FlagOff,
bool CheckMode,
110 unsigned MinVerNum) -> std::optional<StringRef> {
116 Arg *A = Args.getLastArg(FlagOn, FlagOnWithModes, FlagOff);
120 StringRef OptName = A->getOption().getName();
121 if (A->getOption().matches(FlagOff))
122 return makeFeature(OptName,
false);
125 D.
Diag(diag::err_drv_needs_hvx) << withMinus(OptName);
128 if (HvxVerNum < MinVerNum) {
129 D.
Diag(diag::err_drv_needs_hvx_version)
130 << withMinus(OptName) << (
"v" + std::to_string(HvxVerNum));
134 if (CheckMode && A->getOption().matches(FlagOnWithModes)) {
136 llvm::StringSwitch<bool>(StringRef(A->getValue()).lower())
137 .Cases({
"strict-ieee",
"ieee",
"lossy",
"legacy"},
true)
140 D.
Diag(diag::err_drv_invalid_value)
141 << A->getAsString(Args) << A->getValue();
143 return makeFeature(OptName,
true);
146 if (
auto F = checkFlagHvxVersion(
147 options::OPT_mhexagon_hvx_qfloat, options::OPT_mhexagon_hvx_qfloat_EQ,
148 options::OPT_mno_hexagon_hvx_qfloat,
true, 68)) {
149 Features.push_back(*F);
151 if (
auto F = checkFlagHvxVersion(
152 options::OPT_mhexagon_hvx_ieee_fp, options::OPT_mhexagon_hvx_ieee_fp,
153 options::OPT_mno_hexagon_hvx_ieee_fp,
false, 68)) {
154 Features.push_back(*F);
159 if (HvxVerNum >= 79 && Args.getLastArg(options::OPT_mhexagon_hvx_ieee_fp))
160 Features.push_back(
"+hvx-qfloat");
165 const llvm::Triple &Triple,
167 std::vector<StringRef> &Features) {
169 options::OPT_m_hexagon_Features_Group);
171 bool UseLongCalls =
false;
172 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
173 options::OPT_mno_long_calls)) {
174 if (A->getOption().matches(options::OPT_mlong_calls))
178 Features.push_back(UseLongCalls ?
"+long-calls" :
"-long-calls");
184 const bool TinyCore = Cpu.contains(
't');
187 Cpu = Cpu.take_front(Cpu.size() - 1);
192 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hlx,
193 options::OPT_mno_hexagon_hlx)) {
196 if (Cpu.substr(1).getAsInteger(10, CpuVer) || CpuVer < 85)
197 D.
Diag(diag::err_drv_unsupported_opt_for_target)
198 << A->getSpelling() << Cpu;
202 D.
Diag(diag::warn_drv_needs_hvx) <<
"auto-vectorization";
207 ArgStringList &CmdArgs)
const {
214 const char *LinkingOutput)
const {
218 const Driver &D = HTC.getDriver();
219 ArgStringList CmdArgs;
221 CmdArgs.push_back(
"--arch=hexagon");
225 const char *AsName =
"llvm-mc";
226 CmdArgs.push_back(
"-filetype=obj");
227 CmdArgs.push_back(Args.MakeArgString(
231 if (std::get<0>(
ParsePICArgs(HTC, Args)) == llvm::Reloc::PIC_)
232 CmdArgs.push_back(
"-position-independent");
238 CmdArgs.push_back(
"-o");
241 CmdArgs.push_back(
"-fsyntax-only");
244 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_ieee_fp,
245 options::OPT_mno_hexagon_hvx_ieee_fp)) {
246 if (A->getOption().matches(options::OPT_mhexagon_hvx_ieee_fp))
247 CmdArgs.push_back(
"-mhvx-ieee-fp");
250 if (Args.hasFlag(options::OPT_mhexagon_hmx, options::OPT_mno_hexagon_hmx,
252 CmdArgs.push_back(
"-mhmx");
255 if (Args.hasFlag(options::OPT_mhexagon_hlx, options::OPT_mno_hexagon_hlx,
257 CmdArgs.push_back(
"-mhlx");
260 CmdArgs.push_back(Args.MakeArgString(
"-gpsize=" + Twine(*G)));
263 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
273 for (
const auto &II : Inputs) {
276 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
277 << HTC.getTripleString();
278 else if (II.getType() == types::TY_AST)
279 D.
Diag(clang::diag::err_drv_no_ast_support)
280 << HTC.getTripleString();
281 else if (II.getType() == types::TY_ModuleFile)
282 D.
Diag(diag::err_drv_no_module_support)
283 << HTC.getTripleString();
286 CmdArgs.push_back(II.getFilename());
290 II.getInputArg().render(Args, CmdArgs);
293 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName));
294 C.addCommand(std::make_unique<Command>(JA, *
this,
296 Exec, CmdArgs, Inputs, Output));
300 ArgStringList &CmdArgs)
const {
307 const ArgList &Args, ArgStringList &CmdArgs,
308 const char *LinkingOutput) {
315 bool IsStatic = Args.hasArg(options::OPT_static);
316 bool IsShared = Args.hasArg(options::OPT_shared);
317 bool IsPIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
319 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
320 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
321 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
323 const char *Exec = Args.MakeArgString(HTC.
GetLinkerPath(&UseLLD));
324 StringRef LinkerName = llvm::sys::path::filename(Exec);
325 UseLLD = UseLLD || LinkerName.starts_with(
"ld.lld") ||
326 LinkerName.ends_with(
"ld.lld") ||
327 llvm::sys::path::stem(Exec).ends_with(
"ld.lld");
328 bool UseShared = IsShared && !IsStatic;
337 Args.ClaimAllArgs(options::OPT_g_Group);
338 Args.ClaimAllArgs(options::OPT_emit_llvm);
339 Args.ClaimAllArgs(options::OPT_w);
341 Args.ClaimAllArgs(options::OPT_static_libgcc);
343 CmdArgs.push_back(
"--eh-frame-hdr");
347 if (Args.hasArg(options::OPT_s))
348 CmdArgs.push_back(
"-s");
350 if (Args.hasArg(options::OPT_r))
351 CmdArgs.push_back(
"-r");
354 CmdArgs.push_back(Opt.c_str());
357 CmdArgs.push_back(
"-march=hexagon");
358 CmdArgs.push_back(Args.MakeArgString(
"-mcpu=hexagon" + CpuVer));
362 CmdArgs.push_back(
"-shared");
364 CmdArgs.push_back(
"-call_shared");
368 CmdArgs.push_back(
"-static");
370 if (IsPIE && !IsShared && !Args.hasArg(options::OPT_r))
371 CmdArgs.push_back(
"-pie");
374 CmdArgs.push_back(Args.MakeArgString(
"-G" + Twine(*G)));
376 CmdArgs.push_back(
"-o");
380 if (!Args.hasArg(options::OPT_shared, options::OPT_static, options::OPT_r))
381 CmdArgs.push_back(
"-dynamic-linker=/lib/ld-musl-hexagon.so.1");
387 auto StartFile = [&](StringRef Name) -> std::string {
388 return D.
SysRoot +
"/usr/lib" + MLSuffix.str() +
"/" + Name.str();
391 if (!Args.hasArg(options::OPT_shared, options::OPT_nostartfiles,
392 options::OPT_nostdlib, options::OPT_r)) {
393 if (IsStatic && IsPIE)
394 CmdArgs.push_back(Args.MakeArgString(StartFile(
"rcrt1.o")));
396 CmdArgs.push_back(Args.MakeArgString(StartFile(
"crt1.o")));
397 }
else if (Args.hasArg(options::OPT_shared) &&
398 !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib,
400 CmdArgs.push_back(Args.MakeArgString(StartFile(
"crti.o")));
402 if (!MLSuffix.empty()) {
403 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + D.
SysRoot +
404 "/usr/lib" + MLSuffix));
407 Args.MakeArgString(StringRef(
"-L") + D.
SysRoot +
"/usr/lib"));
408 Args.addAllArgs(CmdArgs, {options::OPT_T_Group, options::OPT_s,
409 options::OPT_t, options::OPT_u_Group});
417 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
418 if (NeedsSanitizerDeps) {
422 CmdArgs.push_back(
"-lunwind");
427 if (!Args.hasArg(options::OPT_nolibc))
428 CmdArgs.push_back(
"-lc");
429 CmdArgs.push_back(
"-lclang_rt.builtins-hexagon");
436 for (
const auto &LibPath : LibPaths)
437 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
438 Args.ClaimAllArgs(options::OPT_L);
445 std::vector<std::string> OsLibs;
446 bool HasStandalone =
false;
447 for (
const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
449 OsLibs.emplace_back(A->getValue());
450 HasStandalone = HasStandalone || (OsLibs.back() ==
"standalone");
452 if (OsLibs.empty()) {
453 OsLibs.push_back(
"standalone");
454 HasStandalone =
true;
463 if (IncStdLib && IncStartFiles) {
467 llvm::sys::path::append(Crt0,
"crt0-noflash-hosted.o");
468 CmdArgs.push_back(Args.MakeArgString(Crt0));
469 }
else if (HTC.
getTriple().isOSUnknown()) {
470 llvm::sys::path::append(Crt0,
"crt0-semihost.o");
471 CmdArgs.push_back(Args.MakeArgString(Crt0));
480 llvm::sys::path::append(Crt0SA,
"crt0_standalone.o");
481 CmdArgs.push_back(Args.MakeArgString(Crt0SA));
484 llvm::sys::path::append(Crt0,
"crt0.o");
485 CmdArgs.push_back(Args.MakeArgString(Crt0));
490 llvm::sys::path::append(
Init, UseShared ?
"initS.o" :
"init.o");
491 CmdArgs.push_back(Args.MakeArgString(
Init));
499 for (
const auto &LibPath : LibPaths)
500 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
501 Args.ClaimAllArgs(options::OPT_L);
506 Args.addAllArgs(CmdArgs, {options::OPT_T_Group, options::OPT_s,
507 options::OPT_t, options::OPT_u_Group});
517 if (IncStdLib && IncDefLibs) {
521 CmdArgs.push_back(
"-lm");
524 CmdArgs.push_back(
"--start-group");
529 CmdArgs.push_back(
"-lh2");
530 CmdArgs.push_back(
"-lsyscall_wrapper");
531 }
else if (HTC.
getTriple().isOSUnknown()) {
532 CmdArgs.push_back(
"-lsemihost");
536 for (StringRef Lib : OsLibs)
537 CmdArgs.push_back(Args.MakeArgString(
"-l" + Lib));
539 if (!Args.hasArg(options::OPT_nolibc))
540 CmdArgs.push_back(
"-lc");
544 CmdArgs.push_back(
"-lclang_rt.builtins");
546 CmdArgs.push_back(
"-lgcc");
548 CmdArgs.push_back(
"-lgcc");
551 CmdArgs.push_back(
"--end-group");
557 if (IncStdLib && IncStartFiles) {
560 llvm::sys::path::append(Fini, UseShared ?
"finiS.o" :
"fini.o");
561 CmdArgs.push_back(Args.MakeArgString(Fini));
570 const char *LinkingOutput)
const {
573 ArgStringList CmdArgs;
577 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
578 C.addCommand(std::make_unique<Command>(JA, *
this,
580 Exec, CmdArgs, Inputs, Output));
587 const std::string &InstalledDir,
592 for (
auto &I : PrefixDirs)
593 if (D.getVFS().exists(I))
597 llvm::sys::path::append(Dir,
"..",
"target");
598 return std::string(Dir);
605 if (!D.SysRoot.empty())
618 llvm::sys::path::append(Dir,
"hexagon");
630 llvm::sys::path::append(Dir,
"usr",
"lib");
632 if (!IsLinuxMusl || !
getVFS().exists(Dir)) {
634 llvm::sys::path::append(Dir,
"lib");
641 bool IsStatic = Args.hasArg(options::OPT_static);
642 bool IsShared = Args.hasArg(options::OPT_shared);
643 bool IsPic = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
646 std::string Variant = CpuVer;
649 if (IsPic || IsShared)
651 llvm::sys::path::append(Dir, Variant);
654 llvm::sys::path::append(Dir, CpuVer);
656 llvm::sys::path::append(Dir,
"G0");
657 if (IsShared && !IsStatic)
658 llvm::sys::path::append(Dir,
"pic");
668 llvm::sys::path::append(Dir,
"usr",
"include");
670 if (!IsLinuxMusl || !
getVFS().exists(Dir)) {
672 llvm::sys::path::append(Dir,
"include");
676std::optional<unsigned>
679 if (Arg *A = Args.getLastArg(options::OPT_G)) {
681 }
else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
682 options::OPT_fPIC)) {
687 if (!Gn.getAsInteger(10, G))
695 llvm::sys::path::append(Dir,
"usr",
"lib");
699 return std::string(Dir);
709 for (Arg *A : Args.filtered(options::OPT_L))
710 llvm::append_range(LibPaths, A->getValues());
715 std::vector<std::string> RootDirs;
716 std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
717 std::back_inserter(RootDirs));
720 if (!llvm::is_contained(RootDirs, SysRoot))
721 RootDirs.push_back(SysRoot);
723 bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
725 bool HasG0 = Args.hasArg(options::OPT_shared);
731 for (
auto &Dir : RootDirs) {
732 std::string LibDir = Dir +
"/lib";
733 std::string LibDirCpu = LibDir +
'/' + CpuVer;
738 bool HasPICOrShared = HasPIC || Args.hasArg(options::OPT_shared);
740 std::string Variant = CpuVer +
"-G0";
743 LibPaths.push_back(LibDir +
"/" + Variant);
745 LibPaths.push_back(LibDirCpu);
751 LibPaths.push_back(LibDirCpu +
"/G0/pic");
752 LibPaths.push_back(LibDirCpu +
"/G0");
754 LibPaths.push_back(LibDirCpu);
756 LibPaths.push_back(LibDir);
761 const llvm::opt::ArgList &Args)
762 :
Linux(D, Triple, Args) {
774 .
flag(
"-fsanitize=memory")
777 .
flag(
"-fsanitize=address")
780 .
flag(
"-fsanitize=shadow-call-stack")
789 "-fsanitize=shadow-call-stack", Flags);
797 llvm::sys::path::append(SanLibPath,
"usr",
"lib");
799 LibPaths.insert(LibPaths.begin(), std::string(SanLibPath));
808 ArgStringList &CmdArgs)
const {
812 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
814 getDriver().
Diag(diag::err_drv_unsupported_unwind_for_platform)
822 CmdArgs.push_back(
"-lc++");
823 if (Args.hasArg(options::OPT_fexperimental_library))
824 CmdArgs.push_back(
"-lc++experimental");
825 CmdArgs.push_back(
"-lc++abi");
827 CmdArgs.push_back(
"-lunwind");
831 CmdArgs.push_back(
"-lstdc++");
845 const llvm::opt::ArgList &DriverArgs)
const {
847 Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
851 if (A->getOption().matches(options::OPT_O0))
853 if (A->getOption().matches(options::OPT_Ofast) ||
854 A->getOption().matches(options::OPT_O4))
856 assert(A->getNumValues() != 0);
857 StringRef S(A->getValue());
858 if (S ==
"s" || S ==
"z" || S.empty())
864 if (S.getAsInteger(10, OptLevel))
870 ArgStringList &CC1Args,
874 bool UseInitArrayDefault =
878 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
879 options::OPT_fno_use_init_array,
880 UseInitArrayDefault))
881 CC1Args.push_back(
"-fno-use-init-array");
886 static const std::tuple<options::ID, const char *, bool> FixedRegs[] = {
887 {options::OPT_ffixed_r6,
"+reserved-r6",
true},
888 {options::OPT_ffixed_r7,
"+reserved-r7",
true},
889 {options::OPT_ffixed_r8,
"+reserved-r8",
true},
890 {options::OPT_ffixed_r9,
"+reserved-r9",
true},
891 {options::OPT_ffixed_r10,
"+reserved-r10",
true},
892 {options::OPT_ffixed_r11,
"+reserved-r11",
true},
893 {options::OPT_ffixed_r12,
"+reserved-r12",
true},
894 {options::OPT_ffixed_r13,
"+reserved-r13",
true},
895 {options::OPT_ffixed_r14,
"+reserved-r14",
true},
896 {options::OPT_ffixed_r15,
"+reserved-r15",
true},
897 {options::OPT_ffixed_r16,
"+reserved-r16",
false},
898 {options::OPT_ffixed_r17,
"+reserved-r17",
false},
899 {options::OPT_ffixed_r18,
"+reserved-r18",
false},
900 {options::OPT_ffixed_r19,
"+reserved-r19",
false},
901 {options::OPT_ffixed_r20,
"+reserved-r20",
false},
902 {options::OPT_ffixed_r21,
"+reserved-r21",
false},
903 {options::OPT_ffixed_r22,
"+reserved-r22",
false},
904 {options::OPT_ffixed_r23,
"+reserved-r23",
false},
905 {options::OPT_ffixed_r24,
"+reserved-r24",
false},
906 {options::OPT_ffixed_r25,
"+reserved-r25",
false},
907 {options::OPT_ffixed_r26,
"+reserved-r26",
false},
908 {options::OPT_ffixed_r27,
"+reserved-r27",
false},
909 {options::OPT_ffixed_r28,
"+reserved-r28",
false},
911 for (
const auto &[Opt,
Feature, IsCallerSaved] : FixedRegs) {
912 if (Arg *A = DriverArgs.getLastArg(Opt)) {
914 getDriver().
Diag(diag::warn_drv_hexagon_reserved_caller_saved_reg)
915 << A->getOption().getName();
916 CC1Args.push_back(
"-target-feature");
924 if (Arg *A = DriverArgs.getLastArg(options::OPT_mhexagon_scs_reg)) {
925 StringRef Val(A->getValue());
927 if (!Val.consume_front(
"r") || Val.getAsInteger(10, RegNo) || RegNo < 16 ||
930 << A->getSpelling() << A->getValue();
932 CC1Args.push_back(
"-target-feature");
933 CC1Args.push_back(DriverArgs.MakeArgString(
"+scs-reg-r" + Twine(RegNo)));
938 CC1Args.push_back(
"-mllvm");
939 CC1Args.push_back(
"-hexagon-autohvx");
944 ArgStringList &CC1Args)
const {
945 if (DriverArgs.hasArg(options::OPT_nostdinc))
949 const bool UseBuiltins = !DriverArgs.hasArg(options::OPT_nobuiltininc);
952 llvm::sys::path::append(ResourceDirInclude,
"include");
955 if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
962 llvm::sys::path::append(LocalIncludeDir,
"usr",
"local",
"include");
971 const llvm::opt::ArgList &DriverArgs,
972 llvm::opt::ArgStringList &CC1Args)
const {
975 llvm::sys::path::append(Dir,
"c++",
"v1");
980 const llvm::opt::ArgList &DriverArgs,
981 llvm::opt::ArgStringList &CC1Args)
const {
984 llvm::sys::path::append(Dir,
"c++");
991 if (Args.getLastArg(options::OPT_rtlib_EQ))
1001 if (Args.getLastArg(options::OPT_unwindlib_EQ))
1010 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1017 StringRef
Value = A->getValue();
1018 if (
Value !=
"libstdc++" &&
Value !=
"libc++")
1019 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
1021 if (
Value ==
"libstdc++")
1023 else if (
Value ==
"libc++")
1030 if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
1031 options::OPT_fno_vectorize))
1032 return A->getOption().matches(options::OPT_fvectorize);
1043 Arg *CpuArg =
nullptr;
1044 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1047 StringRef CPU = CpuArg ? CpuArg->getValue() :
GetDefaultCPU();
1048 CPU.consume_front(
"hexagon");
1052std::optional<std::string>
1056 Arg *HvxEnablingArg =
1057 Args.getLastArg(options::OPT_mhexagon_hvx, options::OPT_mhexagon_hvx_EQ,
1058 options::OPT_mno_hexagon_hvx);
1059 if (!HvxEnablingArg ||
1060 HvxEnablingArg->getOption().matches(options::OPT_mno_hexagon_hvx))
1061 return std::nullopt;
1065 if (!Cpu.empty() && (Cpu.back() ==
'T' || Cpu.back() ==
't'))
1066 HvxVer = Cpu.drop_back(1).str();
1070 if (HvxEnablingArg->getOption().matches(options::OPT_mhexagon_hvx_EQ))
1071 HvxVer = StringRef(HvxEnablingArg->getValue()).lower();
static StringRef getTriple(const Command &Job)
The base class of the type hierarchy.
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
DiagnosticBuilder Diag(unsigned DiagID) const
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.
MultilibBuilder & flag(StringRef Flag, bool Disallow=false)
Add a flag to the flags list Flag must be a flag accepted by the driver.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
std::vector< std::string > flags_list
bool isLLVMIR(ID Id)
Is this LLVM IR.
SmallVector< InputInfo, 4 > InputInfoList
Top level wrappers for InstallAPI frontend operations.
@ Default
Set to the current date and time.
const FunctionProtoType * T
Represents a bound architecture for offload / multiple architecture compilation.
static constexpr ResponseFileSupport AtFileCurCP()