17 #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/StringSwitch.h"
31 #include "llvm/ADT/Twine.h"
32 #include "llvm/Option/Arg.h"
33 #include "llvm/Option/ArgList.h"
34 #include "llvm/Option/Option.h"
35 #include "llvm/Support/CodeGen.h"
36 #include "llvm/Support/Compression.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/FileSystem.h"
39 #include "llvm/Support/Host.h"
40 #include "llvm/Support/Path.h"
41 #include "llvm/Support/Process.h"
42 #include "llvm/Support/Program.h"
43 #include "llvm/Support/raw_ostream.h"
44 #include "llvm/Support/TargetParser.h"
50 using namespace clang::driver;
51 using namespace clang::driver::tools;
52 using namespace clang;
53 using namespace llvm::opt;
56 std::vector<const char *> &Features,
58 for (
const Arg *A : Args.filtered(Group)) {
63 assert(Name.startswith(
"m") &&
"Invalid feature name.");
64 Name = Name.substr(1);
66 bool IsNegative = Name.startswith(
"no-");
68 Name = Name.substr(3);
69 Features.push_back(Args.MakeArgString((IsNegative ?
"-" :
"+") + Name));
74 const llvm::Triple &Triple) {
75 if (Triple.getArch() == llvm::Triple::sparcv9) {
76 return llvm::StringSwitch<const char *>(
Name)
77 .Case(
"niagara",
"-Av9b")
78 .Case(
"niagara2",
"-Av9b")
79 .Case(
"niagara3",
"-Av9d")
80 .Case(
"niagara4",
"-Av9d")
83 return llvm::StringSwitch<const char *>(
Name)
85 .Case(
"supersparc",
"-Av8")
86 .Case(
"sparclite",
"-Asparclite")
87 .Case(
"f934",
"-Asparclite")
88 .Case(
"hypersparc",
"-Av8")
89 .Case(
"sparclite86x",
"-Asparclite")
90 .Case(
"sparclet",
"-Asparclet")
91 .Case(
"tsc701",
"-Asparclet")
92 .Case(
"v9",
"-Av8plus")
93 .Case(
"ultrasparc",
"-Av8plus")
94 .Case(
"ultrasparc3",
"-Av8plus")
95 .Case(
"niagara",
"-Av8plusb")
96 .Case(
"niagara2",
"-Av8plusb")
97 .Case(
"niagara3",
"-Av8plusd")
98 .Case(
"niagara4",
"-Av8plusd")
106 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
107 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
108 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
109 D.
Diag(diag::err_drv_argument_only_allowed_with)
110 << A->getBaseArg().getAsString(Args)
111 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
120 if (Args.hasArg(options::OPT_static))
122 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
123 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
132 for (; *Arg; ++Arg) {
148 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
153 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
169 Res.push_back(Target[i]);
174 const char *ArgName,
const char *EnvVar) {
175 const char *DirList = ::getenv(EnvVar);
176 bool CombinedArg =
false;
181 StringRef
Name(ArgName);
182 if (Name.equals(
"-I") || Name.equals(
"-L"))
185 StringRef Dirs(DirList);
189 StringRef::size_type Delim;
190 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
193 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) +
"."));
195 CmdArgs.push_back(ArgName);
196 CmdArgs.push_back(
".");
201 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
203 CmdArgs.push_back(ArgName);
204 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
207 Dirs = Dirs.substr(Delim + 1);
212 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) +
"."));
214 CmdArgs.push_back(ArgName);
215 CmdArgs.push_back(
".");
219 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
221 CmdArgs.push_back(ArgName);
222 CmdArgs.push_back(Args.MakeArgString(Dirs));
228 const ArgList &Args, ArgStringList &CmdArgs) {
233 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
235 for (
const auto &II : Inputs) {
241 if (II.isFilename()) {
242 CmdArgs.push_back(II.getFilename());
247 const Arg &A = II.getInputArg();
250 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
252 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
254 else if (A.getOption().matches(options::OPT_z)) {
257 A.render(Args, CmdArgs);
259 A.renderAsInput(Args, CmdArgs);
272 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc,
false);
278 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
281 return Args.hasArg(options::OPT_fobjc_link_runtime);
287 return O.getKind() != Option::InputClass &&
292 const Driver &D,
const ArgList &Args,
293 ArgStringList &CmdArgs,
301 Args.AddLastArg(CmdArgs, options::OPT_C);
302 Args.AddLastArg(CmdArgs, options::OPT_CC);
305 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
306 (A = Args.getLastArg(options::OPT_MD)) ||
307 (A = Args.getLastArg(options::OPT_MMD))) {
310 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
311 DepFile = MF->getValue();
313 }
else if (Output.
getType() == types::TY_Dependencies) {
315 }
else if (A->getOption().matches(options::OPT_M) ||
316 A->getOption().matches(options::OPT_MM)) {
319 DepFile = getDependencyFileName(Args, Inputs);
322 CmdArgs.push_back(
"-dependency-file");
323 CmdArgs.push_back(DepFile);
326 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
327 const char *DepTarget;
331 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
332 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
333 DepTarget = OutputOpt->getValue();
339 llvm::sys::path::replace_extension(
P,
"o");
340 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
343 CmdArgs.push_back(
"-MT");
346 CmdArgs.push_back(Args.MakeArgString(Quoted));
349 if (A->getOption().matches(options::OPT_M) ||
350 A->getOption().matches(options::OPT_MD))
351 CmdArgs.push_back(
"-sys-header-deps");
352 if ((isa<PrecompileJobAction>(JA) &&
353 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
354 Args.hasArg(options::OPT_fmodule_file_deps))
355 CmdArgs.push_back(
"-module-file-deps");
358 if (Args.hasArg(options::OPT_MG)) {
359 if (!A || A->getOption().matches(options::OPT_MD) ||
360 A->getOption().matches(options::OPT_MMD))
361 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
362 CmdArgs.push_back(
"-MG");
365 Args.AddLastArg(CmdArgs, options::OPT_MP);
366 Args.AddLastArg(CmdArgs, options::OPT_MV);
369 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
372 if (A->getOption().matches(options::OPT_MQ)) {
373 CmdArgs.push_back(
"-MT");
376 CmdArgs.push_back(Args.MakeArgString(Quoted));
380 A->render(Args, CmdArgs);
389 bool RenderedImplicitInclude =
false;
390 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
391 if (A->getOption().matches(options::OPT_include)) {
392 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
393 RenderedImplicitInclude =
true;
398 bool FoundPTH =
false;
399 bool FoundPCH =
false;
405 llvm::sys::path::replace_extension(P,
"pch");
406 if (llvm::sys::fs::exists(P))
411 llvm::sys::path::replace_extension(P,
"pth");
412 if (llvm::sys::fs::exists(P))
416 if (!FoundPCH && !FoundPTH) {
417 llvm::sys::path::replace_extension(P,
"gch");
418 if (llvm::sys::fs::exists(P)) {
424 if (FoundPCH || FoundPTH) {
425 if (IsFirstImplicitInclude) {
428 CmdArgs.push_back(
"-include-pch");
430 CmdArgs.push_back(
"-include-pth");
431 CmdArgs.push_back(Args.MakeArgString(P));
435 D.
Diag(diag::warn_drv_pch_not_first_include) << P
436 << A->getAsString(Args);
443 A->render(Args, CmdArgs);
446 Args.AddAllArgs(CmdArgs,
447 {options::OPT_D, options::OPT_U, options::OPT_I_Group,
448 options::OPT_F, options::OPT_index_header_map});
456 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
457 options::OPT_Xpreprocessor);
460 if (Arg *A = Args.getLastArg(options::OPT_I_))
461 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
467 if (!Args.hasArg(options::OPT_isysroot)) {
468 CmdArgs.push_back(
"-isysroot");
469 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
486 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
495 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
501 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
507 getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
512 switch (Triple.getArch()) {
516 case llvm::Triple::aarch64:
517 case llvm::Triple::aarch64_be:
518 case llvm::Triple::arm:
519 case llvm::Triple::armeb:
520 case llvm::Triple::thumb:
521 case llvm::Triple::thumbeb:
522 if (Triple.isOSDarwin() || Triple.isOSWindows())
526 case llvm::Triple::ppc:
527 case llvm::Triple::ppc64:
528 if (Triple.isOSDarwin())
532 case llvm::Triple::hexagon:
533 case llvm::Triple::ppc64le:
534 case llvm::Triple::systemz:
535 case llvm::Triple::xcore:
541 switch (Triple.getArch()) {
545 case llvm::Triple::xcore:
546 case llvm::Triple::wasm32:
547 case llvm::Triple::wasm64:
556 llvm::StringRef Arch = Triple.getArchName();
557 return llvm::ARM::parseArchVersion(Arch);
562 llvm::StringRef Arch = Triple.getArchName();
563 unsigned Profile = llvm::ARM::parseArchProfile(Arch);
564 return Profile == llvm::ARM::PK_M;
569 llvm::StringRef &CPU,
bool FromAs =
false) {
570 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
572 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
573 Arch = A->getValue();
578 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
579 StringRef
Value = A->getValue();
580 if (Value.startswith(
"-mcpu="))
581 CPU = Value.substr(6);
582 if (Value.startswith(
"-march="))
583 Arch = Value.substr(7);
590 const ArgList &Args, StringRef HWDiv,
591 std::vector<const char *> &Features) {
592 unsigned HWDivID = llvm::ARM::parseHWDiv(HWDiv);
593 if (!llvm::ARM::getHWDivFeatures(HWDivID, Features))
594 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
599 const ArgList &Args, StringRef FPU,
600 std::vector<const char *> &Features) {
601 unsigned FPUID = llvm::ARM::parseFPU(FPU);
602 if (!llvm::ARM::getFPUFeatures(FPUID, Features))
603 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
608 std::vector<const char *> &Features) {
610 text.split(Split, StringRef(
"+"), -1,
false);
612 for (StringRef Feature : Split) {
613 const char *FeatureName = llvm::ARM::getArchExtFeature(Feature);
615 Features.push_back(FeatureName);
626 llvm::StringRef ArchName,
627 std::vector<const char *> &Features,
628 const llvm::Triple &Triple) {
629 std::pair<StringRef, StringRef> Split = ArchName.split(
"+");
632 if (llvm::ARM::parseArch(MArch) == llvm::ARM::AK_INVALID ||
634 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
639 llvm::StringRef CPUName, llvm::StringRef ArchName,
640 std::vector<const char *> &Features,
641 const llvm::Triple &Triple) {
642 std::pair<StringRef, StringRef> Split = CPUName.split(
"+");
647 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
653 return T.getEnvironment() == llvm::Triple::EABI ||
665 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
666 options::OPT_mfloat_abi_EQ)) {
667 if (A->getOption().matches(options::OPT_msoft_float)) {
668 ABI = FloatABI::Soft;
669 }
else if (A->getOption().matches(options::OPT_mhard_float)) {
670 ABI = FloatABI::Hard;
672 ABI = llvm::StringSwitch<arm::FloatABI>(A->getValue())
673 .Case(
"soft", FloatABI::Soft)
674 .Case(
"softfp", FloatABI::SoftFP)
675 .Case(
"hard", FloatABI::Hard)
676 .Default(FloatABI::Invalid);
677 if (ABI == FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
678 D.
Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
679 ABI = FloatABI::Soft;
686 ABI == FloatABI::Hard) {
687 D.
Diag(diag::err_drv_unsupported_opt_for_target) << A->getAsString(Args)
688 << Triple.getArchName();
693 if (ABI == FloatABI::Invalid) {
694 switch (Triple.getOS()) {
695 case llvm::Triple::Darwin:
696 case llvm::Triple::MacOSX:
697 case llvm::Triple::IOS:
698 case llvm::Triple::TvOS: {
700 ABI = (SubArch == 6 || SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
703 case llvm::Triple::WatchOS:
704 ABI = FloatABI::Hard;
708 case llvm::Triple::Win32:
709 ABI = FloatABI::Hard;
712 case llvm::Triple::FreeBSD:
713 switch (Triple.getEnvironment()) {
714 case llvm::Triple::GNUEABIHF:
715 ABI = FloatABI::Hard;
719 ABI = FloatABI::Soft;
725 switch (Triple.getEnvironment()) {
726 case llvm::Triple::GNUEABIHF:
727 case llvm::Triple::EABIHF:
728 ABI = FloatABI::Hard;
730 case llvm::Triple::GNUEABI:
731 case llvm::Triple::EABI:
733 ABI = FloatABI::SoftFP;
735 case llvm::Triple::Android:
736 ABI = (SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
740 ABI = FloatABI::Soft;
741 if (Triple.getOS() != llvm::Triple::UnknownOS ||
742 !Triple.isOSBinFormatMachO())
743 D.
Diag(diag::warn_drv_assuming_mfloat_abi_is) <<
"soft";
749 assert(ABI != FloatABI::Invalid &&
"must select an ABI");
754 const llvm::Triple &Triple,
756 std::vector<const char *> &Features,
761 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
763 const Arg *WaCPU =
nullptr, *WaFPU =
nullptr;
764 const Arg *WaHDiv =
nullptr, *WaArch =
nullptr;
781 Features.push_back(
"+soft-float");
785 Features.push_back(
"+soft-float-abi");
790 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
791 StringRef
Value = A->getValue();
792 if (Value.startswith(
"-mfpu=")) {
794 }
else if (Value.startswith(
"-mcpu=")) {
796 }
else if (Value.startswith(
"-mhwdiv=")) {
798 }
else if (Value.startswith(
"-march=")) {
805 const Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);
809 D.
Diag(clang::diag::warn_drv_unused_argument)
810 << ArchArg->getAsString(Args);
811 ArchName = StringRef(WaArch->getValue()).substr(7);
814 D.
Diag(clang::diag::warn_drv_unused_argument) << WaArch->getAsString(Args);
815 }
else if (ArchArg) {
816 ArchName = ArchArg->getValue();
821 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
825 D.
Diag(clang::diag::warn_drv_unused_argument)
826 << CPUArg->getAsString(Args);
827 CPUName = StringRef(WaCPU->getValue()).substr(6);
830 CPUName = CPUArg->getValue();
835 if (CPUName ==
"native") {
836 llvm::StringMap<bool> HostFeatures;
837 if (llvm::sys::getHostCPUFeatures(HostFeatures))
838 for (
auto &F : HostFeatures)
840 Args.MakeArgString((F.second ?
"+" :
"-") + F.first()));
844 const Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);
847 D.
Diag(clang::diag::warn_drv_unused_argument)
848 << FPUArg->getAsString(Args);
856 const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
859 D.
Diag(clang::diag::warn_drv_unused_argument)
860 << HDivArg->getAsString(Args);
862 StringRef(WaHDiv->getValue()).substr(8), Features);
869 Features.push_back(
"-neon");
871 Features.push_back(
"-crypto");
875 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
876 if (A->getOption().matches(options::OPT_mcrc))
877 Features.push_back(
"+crc");
879 Features.push_back(
"-crc");
882 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_1a) {
883 Features.insert(Features.begin(),
"+v8.1a");
889 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
890 options::OPT_mno_long_calls)) {
891 if (A->getOption().matches(options::OPT_mlong_calls))
892 Features.push_back(
"+long-calls");
893 }
else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
894 !Triple.isWatchOS()) {
895 Features.push_back(
"+long-calls");
900 Features.push_back(
"+strict-align");
901 else if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
902 options::OPT_munaligned_access)) {
903 if (A->getOption().matches(options::OPT_munaligned_access)) {
905 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
906 D.
Diag(diag::err_target_unsupported_unaligned) <<
"v6m";
908 Features.push_back(
"+strict-align");
924 if (Triple.isOSDarwin() || Triple.isOSNetBSD()) {
925 if (VersionNum < 6 ||
926 Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
927 Features.push_back(
"+strict-align");
928 }
else if (Triple.isOSLinux() || Triple.isOSNaCl()) {
930 Features.push_back(
"+strict-align");
932 Features.push_back(
"+strict-align");
938 if (Args.hasArg(options::OPT_ffixed_r9))
939 Features.push_back(
"+reserve-r9");
942 if (KernelOrKext || Args.hasArg(options::OPT_mno_movt))
943 Features.push_back(
"+no-movt");
946 void Clang::AddARMTargetArgs(
const llvm::Triple &Triple,
const ArgList &Args,
947 ArgStringList &CmdArgs,
bool KernelOrKext)
const {
951 const char *ABIName =
nullptr;
952 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
953 ABIName = A->getValue();
954 }
else if (Triple.isOSBinFormatMachO()) {
957 }
else if (Triple.isWatchOS()) {
960 ABIName =
"apcs-gnu";
962 }
else if (Triple.isOSWindows()) {
967 switch (Triple.getEnvironment()) {
968 case llvm::Triple::Android:
969 case llvm::Triple::GNUEABI:
970 case llvm::Triple::GNUEABIHF:
971 ABIName =
"aapcs-linux";
973 case llvm::Triple::EABIHF:
974 case llvm::Triple::EABI:
978 if (Triple.getOS() == llvm::Triple::NetBSD)
979 ABIName =
"apcs-gnu";
985 CmdArgs.push_back(
"-target-abi");
986 CmdArgs.push_back(ABIName);
993 CmdArgs.push_back(
"-msoft-float");
994 CmdArgs.push_back(
"-mfloat-abi");
995 CmdArgs.push_back(
"soft");
998 CmdArgs.push_back(
"-mfloat-abi");
999 CmdArgs.push_back(
"soft");
1003 CmdArgs.push_back(
"-mfloat-abi");
1004 CmdArgs.push_back(
"hard");
1008 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1009 options::OPT_mno_global_merge)) {
1010 CmdArgs.push_back(
"-backend-option");
1011 if (A->getOption().matches(options::OPT_mno_global_merge))
1012 CmdArgs.push_back(
"-arm-global-merge=false");
1014 CmdArgs.push_back(
"-arm-global-merge=true");
1017 if (!Args.hasFlag(options::OPT_mimplicit_float,
1018 options::OPT_mno_implicit_float,
true))
1019 CmdArgs.push_back(
"-no-implicit-float");
1029 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
1030 CPU = StringRef(A->getValue()).lower();
1031 }
else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
1032 StringRef Mcpu = A->getValue();
1033 CPU = Mcpu.split(
"+").first.lower();
1037 if (CPU ==
"native")
1038 return llvm::sys::getHostCPUName();
1039 else if (CPU.size())
1044 if (Args.getLastArg(options::OPT_arch))
1050 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
1051 ArgStringList &CmdArgs)
const {
1052 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1053 llvm::Triple Triple(TripleStr);
1055 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1056 Args.hasArg(options::OPT_mkernel) ||
1057 Args.hasArg(options::OPT_fapple_kext))
1058 CmdArgs.push_back(
"-disable-red-zone");
1060 if (!Args.hasFlag(options::OPT_mimplicit_float,
1061 options::OPT_mno_implicit_float,
true))
1062 CmdArgs.push_back(
"-no-implicit-float");
1064 const char *ABIName =
nullptr;
1065 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1066 ABIName = A->getValue();
1067 else if (Triple.isOSDarwin())
1068 ABIName =
"darwinpcs";
1072 CmdArgs.push_back(
"-target-abi");
1073 CmdArgs.push_back(ABIName);
1075 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1076 options::OPT_mno_fix_cortex_a53_835769)) {
1077 CmdArgs.push_back(
"-backend-option");
1078 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1079 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1081 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1082 }
else if (Triple.isAndroid()) {
1084 CmdArgs.push_back(
"-backend-option");
1085 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1089 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1090 options::OPT_mno_global_merge)) {
1091 CmdArgs.push_back(
"-backend-option");
1092 if (A->getOption().matches(options::OPT_mno_global_merge))
1093 CmdArgs.push_back(
"-aarch64-global-merge=false");
1095 CmdArgs.push_back(
"-aarch64-global-merge=true");
1102 StringRef &CPUName, StringRef &ABIName) {
1103 const char *DefMips32CPU =
"mips32r2";
1104 const char *DefMips64CPU =
"mips64r2";
1108 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1109 Triple.getEnvironment() == llvm::Triple::GNU) {
1110 DefMips32CPU =
"mips32r6";
1111 DefMips64CPU =
"mips64r6";
1115 if (Triple.isAndroid())
1116 DefMips64CPU =
"mips64r6";
1119 if (Triple.getOS() == llvm::Triple::OpenBSD)
1120 DefMips64CPU =
"mips3";
1122 if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ))
1123 CPUName = A->getValue();
1125 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1126 ABIName = A->getValue();
1129 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
1136 if (CPUName.empty() && ABIName.empty()) {
1137 switch (Triple.getArch()) {
1139 llvm_unreachable(
"Unexpected triple arch name");
1140 case llvm::Triple::mips:
1141 case llvm::Triple::mipsel:
1142 CPUName = DefMips32CPU;
1144 case llvm::Triple::mips64:
1145 case llvm::Triple::mips64el:
1146 CPUName = DefMips64CPU;
1151 if (ABIName.empty()) {
1153 if (Triple.getArch() == llvm::Triple::mips ||
1154 Triple.getArch() == llvm::Triple::mipsel)
1160 if (CPUName.empty()) {
1162 CPUName = llvm::StringSwitch<const char *>(ABIName)
1163 .Cases(
"o32",
"eabi", DefMips32CPU)
1164 .Cases(
"n32",
"n64", DefMips64CPU)
1172 const llvm::Triple &Triple) {
1173 StringRef CPUName, ABIName;
1175 return llvm::StringSwitch<std::string>(ABIName)
1183 return llvm::StringSwitch<llvm::StringRef>(ABI)
1194 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1195 options::OPT_mfloat_abi_EQ)) {
1196 if (A->getOption().matches(options::OPT_msoft_float))
1198 else if (A->getOption().matches(options::OPT_mhard_float))
1201 ABI = llvm::StringSwitch<mips::FloatABI>(A->getValue())
1206 D.
Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1225 std::vector<const char *> &Features,
1226 OptSpecifier OnOpt, OptSpecifier OffOpt,
1227 StringRef FeatureName) {
1228 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1229 if (A->getOption().matches(OnOpt))
1230 Features.push_back(Args.MakeArgString(
"+" + FeatureName));
1232 Features.push_back(Args.MakeArgString(
"-" + FeatureName));
1237 const ArgList &Args,
1238 std::vector<const char *> &Features) {
1245 options::OPT_mabicalls,
"noabicalls");
1252 Features.push_back(
"+soft-float");
1255 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1256 StringRef Val = StringRef(A->getValue());
1257 if (Val ==
"2008") {
1259 Features.push_back(
"+nan2008");
1261 Features.push_back(
"-nan2008");
1262 D.
Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1264 }
else if (Val ==
"legacy") {
1266 Features.push_back(
"-nan2008");
1268 Features.push_back(
"+nan2008");
1269 D.
Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1272 D.
Diag(diag::err_drv_unsupported_option_argument)
1273 << A->getOption().getName() << Val;
1277 options::OPT_mdouble_float,
"single-float");
1278 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1281 options::OPT_mno_micromips,
"micromips");
1284 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1291 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1292 options::OPT_mfp64)) {
1293 if (A->getOption().matches(options::OPT_mfp32))
1294 Features.push_back(Args.MakeArgString(
"-fp64"));
1295 else if (A->getOption().matches(options::OPT_mfpxx)) {
1296 Features.push_back(Args.MakeArgString(
"+fpxx"));
1297 Features.push_back(Args.MakeArgString(
"+nooddspreg"));
1299 Features.push_back(Args.MakeArgString(
"+fp64"));
1301 Features.push_back(Args.MakeArgString(
"+fpxx"));
1302 Features.push_back(Args.MakeArgString(
"+nooddspreg"));
1306 options::OPT_modd_spreg,
"nooddspreg");
1309 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1310 ArgStringList &CmdArgs)
const {
1311 const Driver &D = getToolChain().getDriver();
1314 const llvm::Triple &Triple = getToolChain().getTriple();
1317 CmdArgs.push_back(
"-target-abi");
1318 CmdArgs.push_back(ABIName.data());
1323 CmdArgs.push_back(
"-msoft-float");
1324 CmdArgs.push_back(
"-mfloat-abi");
1325 CmdArgs.push_back(
"soft");
1329 CmdArgs.push_back(
"-mfloat-abi");
1330 CmdArgs.push_back(
"hard");
1333 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1334 if (A->getOption().matches(options::OPT_mxgot)) {
1335 CmdArgs.push_back(
"-mllvm");
1336 CmdArgs.push_back(
"-mxgot");
1340 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1341 options::OPT_mno_ldc1_sdc1)) {
1342 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1343 CmdArgs.push_back(
"-mllvm");
1344 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1348 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1349 options::OPT_mno_check_zero_division)) {
1350 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1351 CmdArgs.push_back(
"-mllvm");
1352 CmdArgs.push_back(
"-mno-check-zero-division");
1356 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1357 StringRef
v = A->getValue();
1358 CmdArgs.push_back(
"-mllvm");
1359 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1366 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1367 StringRef CPUName = A->getValue();
1369 if (CPUName ==
"native") {
1370 std::string CPU = llvm::sys::getHostCPUName();
1371 if (!CPU.empty() && CPU !=
"generic")
1377 return llvm::StringSwitch<const char *>(CPUName)
1378 .Case(
"common",
"generic")
1380 .Case(
"440fp",
"440")
1385 .Case(
"603e",
"603e")
1386 .Case(
"603ev",
"603ev")
1388 .Case(
"604e",
"604e")
1390 .Case(
"630",
"pwr3")
1392 .Case(
"7400",
"7400")
1394 .Case(
"7450",
"7450")
1401 .Case(
"e500mc",
"e500mc")
1402 .Case(
"e5500",
"e5500")
1403 .Case(
"power3",
"pwr3")
1404 .Case(
"power4",
"pwr4")
1405 .Case(
"power5",
"pwr5")
1406 .Case(
"power5x",
"pwr5x")
1407 .Case(
"power6",
"pwr6")
1408 .Case(
"power6x",
"pwr6x")
1409 .Case(
"power7",
"pwr7")
1410 .Case(
"power8",
"pwr8")
1411 .Case(
"pwr3",
"pwr3")
1412 .Case(
"pwr4",
"pwr4")
1413 .Case(
"pwr5",
"pwr5")
1414 .Case(
"pwr5x",
"pwr5x")
1415 .Case(
"pwr6",
"pwr6")
1416 .Case(
"pwr6x",
"pwr6x")
1417 .Case(
"pwr7",
"pwr7")
1418 .Case(
"pwr8",
"pwr8")
1419 .Case(
"powerpc",
"ppc")
1420 .Case(
"powerpc64",
"ppc64")
1421 .Case(
"powerpc64le",
"ppc64le")
1429 const ArgList &Args,
1430 std::vector<const char *> &Features) {
1435 !(Triple.getArch() == llvm::Triple::ppc64 ||
1436 Triple.getArch() == llvm::Triple::ppc64le))
1437 Features.push_back(
"+soft-float");
1439 (Triple.getArch() == llvm::Triple::ppc64 ||
1440 Triple.getArch() == llvm::Triple::ppc64le))
1441 D.
Diag(diag::err_drv_invalid_mfloat_abi)
1442 <<
"soft float is not supported for ppc64";
1446 options::OPT_fno_altivec,
"altivec");
1452 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1453 options::OPT_mfloat_abi_EQ)) {
1454 if (A->getOption().matches(options::OPT_msoft_float))
1456 else if (A->getOption().matches(options::OPT_mhard_float))
1459 ABI = llvm::StringSwitch<ppc::FloatABI>(A->getValue())
1464 D.
Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1478 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1479 ArgStringList &CmdArgs)
const {
1481 const char *ABIName =
nullptr;
1482 if (getToolChain().getTriple().isOSLinux())
1483 switch (getToolChain().getArch()) {
1484 case llvm::Triple::ppc64: {
1488 bool HasQPX =
false;
1489 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1490 HasQPX = A->getValue() == StringRef(
"a2q");
1491 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1493 ABIName =
"elfv1-qpx";
1500 case llvm::Triple::ppc64le:
1507 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1511 if (StringRef(A->getValue()) !=
"altivec")
1512 ABIName = A->getValue();
1519 CmdArgs.push_back(
"-msoft-float");
1520 CmdArgs.push_back(
"-mfloat-abi");
1521 CmdArgs.push_back(
"soft");
1525 CmdArgs.push_back(
"-mfloat-abi");
1526 CmdArgs.push_back(
"hard");
1530 CmdArgs.push_back(
"-target-abi");
1531 CmdArgs.push_back(ABIName);
1536 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1537 return A && (A->getValue() == StringRef(Value));
1542 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1543 const char *GPUName = A->getValue();
1544 return llvm::StringSwitch<const char *>(GPUName)
1545 .Cases(
"rv630",
"rv635",
"r600")
1546 .Cases(
"rv610",
"rv620",
"rs780",
"rs880")
1547 .Case(
"rv740",
"rv770")
1548 .Case(
"palm",
"cedar")
1549 .Cases(
"sumo",
"sumo2",
"sumo")
1550 .Case(
"hemlock",
"cypress")
1551 .Case(
"aruba",
"cayman")
1557 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1558 ArgStringList &CmdArgs)
const {
1559 const Driver &D = getToolChain().getDriver();
1560 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
1562 bool SoftFloatABI =
false;
1564 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1565 if (A->getOption().matches(options::OPT_msoft_float))
1566 SoftFloatABI =
true;
1575 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-msoft-float"
1581 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1582 return A->getValue();
1587 std::vector<const char *> &Features) {
1589 if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
1590 if (A->getOption().matches(options::OPT_mhtm))
1591 Features.push_back(
"+transactional-execution");
1593 Features.push_back(
"-transactional-execution");
1596 if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
1597 if (A->getOption().matches(options::OPT_mvx))
1598 Features.push_back(
"+vector");
1600 Features.push_back(
"-vector");
1605 const llvm::Triple &Triple) {
1606 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1607 if (StringRef(A->getValue()) !=
"native") {
1608 if (Triple.isOSDarwin() && Triple.getArchName() ==
"x86_64h")
1611 return A->getValue();
1619 std::string CPU = llvm::sys::getHostCPUName();
1620 if (!CPU.empty() && CPU !=
"generic")
1621 return Args.MakeArgString(CPU);
1624 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1626 StringRef Arch = A->getValue();
1628 if (Triple.getArch() == llvm::Triple::x86) {
1629 CPU = llvm::StringSwitch<const char *>(Arch)
1630 .Case(
"IA32",
"i386")
1631 .Case(
"SSE",
"pentium3")
1632 .Case(
"SSE2",
"pentium4")
1633 .Case(
"AVX",
"sandybridge")
1634 .Case(
"AVX2",
"haswell")
1637 CPU = llvm::StringSwitch<const char *>(Arch)
1638 .Case(
"AVX",
"sandybridge")
1639 .Case(
"AVX2",
"haswell")
1648 if (Triple.getArch() != llvm::Triple::x86_64 &&
1649 Triple.getArch() != llvm::Triple::x86)
1652 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1655 if (Triple.isOSDarwin()) {
1656 if (Triple.getArchName() ==
"x86_64h")
1658 return Is64Bit ?
"core2" :
"yonah";
1662 if (Triple.isPS4CPU())
1666 if (Triple.isAndroid())
1667 return Is64Bit ?
"x86-64" :
"i686";
1673 switch (Triple.getOS()) {
1674 case llvm::Triple::FreeBSD:
1675 case llvm::Triple::NetBSD:
1676 case llvm::Triple::OpenBSD:
1678 case llvm::Triple::Haiku:
1680 case llvm::Triple::Bitrig:
1691 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1692 StringRef CPU = A->getValue();
1697 if (CPU ==
"native")
1698 return llvm::sys::getHostCPUName();
1707 static std::string
getCPUName(
const ArgList &Args,
const llvm::Triple &T,
1708 bool FromAs =
false) {
1709 switch (T.getArch()) {
1713 case llvm::Triple::aarch64:
1714 case llvm::Triple::aarch64_be:
1717 case llvm::Triple::arm:
1718 case llvm::Triple::armeb:
1719 case llvm::Triple::thumb:
1720 case llvm::Triple::thumbeb: {
1721 StringRef MArch, MCPU;
1725 case llvm::Triple::mips:
1726 case llvm::Triple::mipsel:
1727 case llvm::Triple::mips64:
1728 case llvm::Triple::mips64el: {
1735 case llvm::Triple::nvptx:
1736 case llvm::Triple::nvptx64:
1737 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1738 return A->getValue();
1741 case llvm::Triple::ppc:
1742 case llvm::Triple::ppc64:
1743 case llvm::Triple::ppc64le: {
1748 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1749 if (T.getArch() == llvm::Triple::ppc64)
1750 TargetCPUName =
"ppc64";
1751 else if (T.getArch() == llvm::Triple::ppc64le)
1752 TargetCPUName =
"ppc64le";
1754 TargetCPUName =
"ppc";
1756 return TargetCPUName;
1759 case llvm::Triple::sparc:
1760 case llvm::Triple::sparcel:
1761 case llvm::Triple::sparcv9:
1762 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1763 return A->getValue();
1766 case llvm::Triple::x86:
1767 case llvm::Triple::x86_64:
1770 case llvm::Triple::hexagon:
1774 case llvm::Triple::systemz:
1777 case llvm::Triple::r600:
1778 case llvm::Triple::amdgcn:
1781 case llvm::Triple::wasm32:
1782 case llvm::Triple::wasm64:
1788 ArgStringList &CmdArgs,
bool IsThinLTO) {
1792 CmdArgs.push_back(
"-plugin");
1793 std::string Plugin =
1794 ToolChain.
getDriver().
Dir +
"/../lib" CLANG_LIBDIR_SUFFIX
"/LLVMgold.so";
1795 CmdArgs.push_back(Args.MakeArgString(Plugin));
1803 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-opt=mcpu=") + CPU));
1805 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1807 if (A->getOption().matches(options::OPT_O4) ||
1808 A->getOption().matches(options::OPT_Ofast))
1810 else if (A->getOption().matches(options::OPT_O))
1811 OOpt = A->getValue();
1812 else if (A->getOption().matches(options::OPT_O0))
1815 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-opt=O") + OOpt));
1819 CmdArgs.push_back(
"-plugin-opt=thinlto");
1828 const char RefinementStepToken =
':';
1829 Position = In.find(RefinementStepToken);
1830 if (Position != StringRef::npos) {
1831 StringRef Option = A.getOption().getName();
1832 StringRef RefStep = In.substr(Position + 1);
1840 if (RefStep.size() != 1) {
1841 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
1844 char RefStepChar = RefStep[0];
1845 if (RefStepChar < '0' || RefStepChar >
'9') {
1846 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
1855 ArgStringList &OutStrings) {
1856 StringRef DisabledPrefixIn =
"!";
1857 StringRef DisabledPrefixOut =
"!";
1858 StringRef EnabledPrefixOut =
"";
1859 StringRef Out =
"-mrecip=";
1861 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1865 unsigned NumOptions = A->getNumValues();
1866 if (NumOptions == 0) {
1868 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
1873 if (NumOptions == 1) {
1874 StringRef Val = A->getValue(0);
1878 StringRef ValBase = Val.slice(0, RefStepLoc);
1879 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
1880 OutStrings.push_back(Args.MakeArgString(Out + Val));
1889 llvm::StringMap<bool> OptionStrings;
1890 OptionStrings.insert(std::make_pair(
"divd",
false));
1891 OptionStrings.insert(std::make_pair(
"divf",
false));
1892 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
1893 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
1894 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
1895 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
1896 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
1897 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
1899 for (
unsigned i = 0; i != NumOptions; ++i) {
1900 StringRef Val = A->getValue(i);
1902 bool IsDisabled = Val.startswith(DisabledPrefixIn);
1905 Val = Val.substr(1);
1911 StringRef ValBase = Val.slice(0, RefStep);
1913 if (OptionIter == OptionStrings.end()) {
1915 OptionIter = OptionStrings.find(ValBase.str() +
'f');
1916 if (OptionIter == OptionStrings.end()) {
1918 D.
Diag(diag::err_drv_unknown_argument) << Val;
1924 if (OptionStrings[ValBase.str() +
'd']) {
1925 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1930 if (OptionIter->second ==
true) {
1932 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1937 OptionIter->second =
true;
1940 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
1941 OptionStrings[ValBase.str() +
'd'] =
true;
1944 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1945 Out = Args.MakeArgString(Out + Prefix + Val);
1946 if (i != NumOptions - 1)
1947 Out = Args.MakeArgString(Out +
",");
1950 OutStrings.push_back(Args.MakeArgString(Out));
1954 const ArgList &Args,
1955 std::vector<const char *> &Features) {
1957 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1958 if (StringRef(A->getValue()) ==
"native") {
1959 llvm::StringMap<bool> HostFeatures;
1960 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1961 for (
auto &F : HostFeatures)
1963 Args.MakeArgString((F.second ?
"+" :
"-") + F.first()));
1967 if (Triple.getArchName() ==
"x86_64h") {
1970 Features.push_back(
"-rdrnd");
1971 Features.push_back(
"-aes");
1972 Features.push_back(
"-pclmul");
1973 Features.push_back(
"-rtm");
1974 Features.push_back(
"-hle");
1975 Features.push_back(
"-fsgsbase");
1978 const llvm::Triple::ArchType ArchType = Triple.getArch();
1980 if (Triple.isAndroid()) {
1981 if (ArchType == llvm::Triple::x86_64) {
1982 Features.push_back(
"+sse4.2");
1983 Features.push_back(
"+popcnt");
1985 Features.push_back(
"+ssse3");
1989 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1990 StringRef Arch = A->getValue();
1991 bool ArchUsed =
false;
1993 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
1994 if (Arch ==
"AVX" || Arch ==
"AVX2") {
1996 Features.push_back(Args.MakeArgString(
"+" + Arch.lower()));
2000 if (ArchType == llvm::Triple::x86) {
2001 if (Arch ==
"IA32") {
2003 }
else if (Arch ==
"SSE" || Arch ==
"SSE2") {
2005 Features.push_back(Args.MakeArgString(
"+" + Arch.lower()));
2009 D.
Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
2017 void Clang::AddX86TargetArgs(
const ArgList &Args,
2018 ArgStringList &CmdArgs)
const {
2019 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
2020 Args.hasArg(options::OPT_mkernel) ||
2021 Args.hasArg(options::OPT_fapple_kext))
2022 CmdArgs.push_back(
"-disable-red-zone");
2026 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2027 Args.hasArg(options::OPT_fapple_kext));
2028 if (Arg *A = Args.getLastArg(
2029 options::OPT_msoft_float, options::OPT_mno_soft_float,
2030 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2031 const Option &O = A->getOption();
2032 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2033 O.matches(options::OPT_msoft_float));
2035 if (NoImplicitFloat)
2036 CmdArgs.push_back(
"-no-implicit-float");
2038 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2039 StringRef Value = A->getValue();
2040 if (Value ==
"intel" || Value ==
"att") {
2041 CmdArgs.push_back(
"-mllvm");
2042 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
2044 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
2045 << A->getOption().getName() <<
Value;
2050 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
2051 ArgStringList &CmdArgs)
const {
2052 CmdArgs.push_back(
"-mqdsp6-compat");
2053 CmdArgs.push_back(
"-Wreturn-type");
2056 std::string N = llvm::utostr(G.getValue());
2057 std::string Opt = std::string(
"-hexagon-small-data-threshold=") + N;
2058 CmdArgs.push_back(
"-mllvm");
2059 CmdArgs.push_back(Args.MakeArgString(Opt));
2062 if (!Args.hasArg(options::OPT_fno_short_enums))
2063 CmdArgs.push_back(
"-fshort-enums");
2064 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2065 CmdArgs.push_back(
"-mllvm");
2066 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
2068 CmdArgs.push_back(
"-mllvm");
2069 CmdArgs.push_back(
"-machine-sink-split=0");
2072 void Clang::AddWebAssemblyTargetArgs(
const ArgList &Args,
2073 ArgStringList &CmdArgs)
const {
2075 if (!Args.hasArg(options::OPT_fvisibility_EQ,
2076 options::OPT_fvisibility_ms_compat)) {
2077 CmdArgs.push_back(
"-fvisibility");
2078 CmdArgs.push_back(
"hidden");
2084 std::vector<const char *> &Features) {
2086 text.split(Split, StringRef(
"+"), -1,
false);
2088 for (StringRef Feature : Split) {
2089 const char *result = llvm::StringSwitch<const char *>(Feature)
2090 .Case(
"fp",
"+fp-armv8")
2091 .Case(
"simd",
"+neon")
2092 .Case(
"crc",
"+crc")
2093 .Case(
"crypto",
"+crypto")
2094 .Case(
"fp16",
"+fullfp16")
2095 .Case(
"profile",
"+spe")
2096 .Case(
"nofp",
"-fp-armv8")
2097 .Case(
"nosimd",
"-neon")
2098 .Case(
"nocrc",
"-crc")
2099 .Case(
"nocrypto",
"-crypto")
2100 .Case(
"nofp16",
"-fullfp16")
2101 .Case(
"noprofile",
"-spe")
2104 Features.push_back(result);
2105 else if (Feature ==
"neon" || Feature ==
"noneon")
2106 D.
Diag(diag::err_drv_no_neon_modifier);
2116 std::vector<const char *> &Features) {
2117 std::pair<StringRef, StringRef> Split = Mcpu.split(
"+");
2119 if (CPU ==
"cyclone" || CPU ==
"cortex-a53" || CPU ==
"cortex-a57" ||
2120 CPU ==
"cortex-a72" || CPU ==
"cortex-a35" || CPU ==
"exynos-m1") {
2121 Features.push_back(
"+neon");
2122 Features.push_back(
"+crc");
2123 Features.push_back(
"+crypto");
2124 }
else if (CPU ==
"generic") {
2125 Features.push_back(
"+neon");
2138 const ArgList &Args,
2139 std::vector<const char *> &Features) {
2140 std::string MarchLowerCase = March.lower();
2141 std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split(
"+");
2143 if (Split.first ==
"armv8-a" || Split.first ==
"armv8a") {
2145 }
else if (Split.first ==
"armv8.1-a" || Split.first ==
"armv8.1a") {
2146 Features.push_back(
"+v8.1a");
2147 }
else if (Split.first ==
"armv8.2-a" || Split.first ==
"armv8.2a" ) {
2148 Features.push_back(
"+v8.2a");
2161 const ArgList &Args,
2162 std::vector<const char *> &Features) {
2164 std::string McpuLowerCase = Mcpu.lower();
2173 const ArgList &Args,
2174 std::vector<const char *> &Features) {
2175 std::string MtuneLowerCase = Mtune.lower();
2177 if (MtuneLowerCase ==
"native")
2178 MtuneLowerCase = llvm::sys::getHostCPUName();
2179 if (MtuneLowerCase ==
"cyclone") {
2180 Features.push_back(
"+zcm");
2181 Features.push_back(
"+zcz");
2188 const ArgList &Args,
2189 std::vector<const char *> &Features) {
2191 std::vector<const char *> DecodedFeature;
2192 std::string McpuLowerCase = Mcpu.lower();
2200 std::vector<const char *> &Features) {
2202 bool success =
true;
2204 Features.push_back(
"+neon");
2205 if ((A = Args.getLastArg(options::OPT_march_EQ)))
2207 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
2209 else if (Args.hasArg(options::OPT_arch))
2213 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
2216 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
2219 else if (Args.hasArg(options::OPT_arch))
2224 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
2226 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
2227 Features.push_back(
"-fp-armv8");
2228 Features.push_back(
"-crypto");
2229 Features.push_back(
"-neon");
2233 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
2234 if (A->getOption().matches(options::OPT_mcrc))
2235 Features.push_back(
"+crc");
2237 Features.push_back(
"-crc");
2240 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
2241 options::OPT_munaligned_access))
2242 if (A->getOption().matches(options::OPT_mno_unaligned_access))
2243 Features.push_back(
"+strict-align");
2245 if (Args.hasArg(options::OPT_ffixed_x18))
2246 Features.push_back(
"+reserve-x18");
2250 std::vector<const char *> &Features) {
2251 bool HasHVX =
false, HasHVXD =
false;
2256 for (
auto &A : Args) {
2257 auto &Opt = A->getOption();
2258 if (Opt.matches(options::OPT_mhexagon_hvx))
2260 else if (Opt.matches(options::OPT_mno_hexagon_hvx))
2261 HasHVXD = HasHVX =
false;
2262 else if (Opt.matches(options::OPT_mhexagon_hvx_double))
2263 HasHVXD = HasHVX =
true;
2264 else if (Opt.matches(options::OPT_mno_hexagon_hvx_double))
2271 Features.push_back(HasHVX ?
"+hvx" :
"-hvx");
2272 Features.push_back(HasHVXD ?
"+hvx-double" :
"-hvx-double");
2276 std::vector<const char *> &Features) {
2281 const ArgList &Args, ArgStringList &CmdArgs,
2284 std::vector<const char *> Features;
2285 switch (Triple.getArch()) {
2288 case llvm::Triple::mips:
2289 case llvm::Triple::mipsel:
2290 case llvm::Triple::mips64:
2291 case llvm::Triple::mips64el:
2295 case llvm::Triple::arm:
2296 case llvm::Triple::armeb:
2297 case llvm::Triple::thumb:
2298 case llvm::Triple::thumbeb:
2302 case llvm::Triple::ppc:
2303 case llvm::Triple::ppc64:
2304 case llvm::Triple::ppc64le:
2307 case llvm::Triple::systemz:
2310 case llvm::Triple::aarch64:
2311 case llvm::Triple::aarch64_be:
2314 case llvm::Triple::x86:
2315 case llvm::Triple::x86_64:
2318 case llvm::Triple::hexagon:
2321 case llvm::Triple::wasm32:
2322 case llvm::Triple::wasm64:
2328 llvm::StringMap<unsigned> LastOpt;
2329 for (
unsigned I = 0, N = Features.size();
I < N; ++
I) {
2330 const char *
Name = Features[
I];
2331 assert(Name[0] ==
'-' || Name[0] ==
'+');
2332 LastOpt[Name + 1] =
I;
2335 for (
unsigned I = 0, N = Features.size();
I < N; ++
I) {
2337 const char *
Name = Features[
I];
2339 assert(LastI != LastOpt.end());
2340 unsigned Last = LastI->second;
2344 CmdArgs.push_back(
"-target-feature");
2345 CmdArgs.push_back(Name);
2351 const llvm::Triple &Triple) {
2358 if (!Triple.isMacOSX())
2361 return (!Triple.isMacOSXVersionLT(10, 5) &&
2362 (Triple.getArch() == llvm::Triple::x86_64 ||
2363 Triple.getArch() == llvm::Triple::arm));
2373 ArgStringList &CmdArgs) {
2375 const llvm::Triple &Triple = TC.
getTriple();
2380 Args.ClaimAllArgs(options::OPT_fexceptions);
2381 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2382 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2383 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2384 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2385 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
2390 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2396 Args.hasFlag(options::OPT_fobjc_exceptions,
2397 options::OPT_fno_objc_exceptions,
true)) {
2398 CmdArgs.push_back(
"-fobjc-exceptions");
2406 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
2407 !Triple.isPS4CPU() &&
2408 !Triple.isWindowsMSVCEnvironment();
2409 Arg *ExceptionArg = Args.getLastArg(
2410 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2411 options::OPT_fexceptions, options::OPT_fno_exceptions);
2413 CXXExceptionsEnabled =
2414 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2415 ExceptionArg->getOption().matches(options::OPT_fexceptions);
2417 if (CXXExceptionsEnabled) {
2418 if (Triple.isPS4CPU()) {
2420 assert(ExceptionArg &&
2421 "On the PS4 exceptions should only be enabled if passing "
2425 assert(RTTIArg &&
"RTTI disabled explicitly but no RTTIArg!");
2426 D.
Diag(diag::err_drv_argument_not_allowed_with)
2427 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2429 D.
Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2433 CmdArgs.push_back(
"-fcxx-exceptions");
2440 CmdArgs.push_back(
"-fexceptions");
2444 bool Default =
true;
2450 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2456 bool UseDwarfDirectory =
2457 Args.hasFlag(options::OPT_fdwarf_directory_asm,
2459 return !UseDwarfDirectory;
2464 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
2467 for (
const auto &Act : *A)
2477 bool RelaxDefault =
true;
2479 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2480 RelaxDefault = A->getOption().matches(options::OPT_O0);
2483 RelaxDefault =
false;
2486 RelaxDefault =
true;
2492 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2499 assert(A.getOption().matches(options::OPT_gN_Group) &&
2500 "Not a -g option that specifies a debug-info level");
2501 if (A.getOption().matches(options::OPT_g0) ||
2502 A.getOption().matches(options::OPT_ggdb0))
2504 if (A.getOption().matches(options::OPT_gline_tables_only) ||
2505 A.getOption().matches(options::OPT_ggdb1))
2514 return llvm::StringSwitch<unsigned>(ArgValue)
2515 .Case(
"-gdwarf-2", 2)
2516 .Case(
"-gdwarf-3", 3)
2517 .Case(
"-gdwarf-4", 4)
2518 .Case(
"-gdwarf-5", 5)
2524 unsigned DwarfVersion,
2525 llvm::DebuggerKind DebuggerTuning) {
2526 switch (DebugInfoKind) {
2528 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
2531 CmdArgs.push_back(
"-debug-info-kind=limited");
2534 CmdArgs.push_back(
"-debug-info-kind=standalone");
2539 if (DwarfVersion > 0)
2541 Args.MakeArgString(
"-dwarf-version=" + Twine(DwarfVersion)));
2542 switch (DebuggerTuning) {
2543 case llvm::DebuggerKind::GDB:
2544 CmdArgs.push_back(
"-debugger-tuning=gdb");
2546 case llvm::DebuggerKind::LLDB:
2547 CmdArgs.push_back(
"-debugger-tuning=lldb");
2549 case llvm::DebuggerKind::SCE:
2550 CmdArgs.push_back(
"-debugger-tuning=sce");
2558 const ArgList &Args,
2559 ArgStringList &CmdArgs,
2562 CmdArgs.push_back(
"-mrelax-all");
2566 bool DefaultIncrementalLinkerCompatible =
2568 if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2569 options::OPT_mno_incremental_linker_compatible,
2570 DefaultIncrementalLinkerCompatible))
2571 CmdArgs.push_back(
"-mincremental-linker-compatible");
2578 bool TakeNextArg =
false;
2582 bool CompressDebugSections =
false;
2584 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2587 for (StringRef Value : A->getValues()) {
2589 CmdArgs.push_back(Value.data());
2590 TakeNextArg =
false;
2597 case llvm::Triple::mips:
2598 case llvm::Triple::mipsel:
2599 case llvm::Triple::mips64:
2600 case llvm::Triple::mips64el:
2601 if (Value ==
"--trap") {
2602 CmdArgs.push_back(
"-target-feature");
2603 CmdArgs.push_back(
"+use-tcc-in-div");
2606 if (Value ==
"--break") {
2607 CmdArgs.push_back(
"-target-feature");
2608 CmdArgs.push_back(
"-use-tcc-in-div");
2611 if (Value.startswith(
"-msoft-float")) {
2612 CmdArgs.push_back(
"-target-feature");
2613 CmdArgs.push_back(
"+soft-float");
2616 if (Value.startswith(
"-mhard-float")) {
2617 CmdArgs.push_back(
"-target-feature");
2618 CmdArgs.push_back(
"-soft-float");
2624 if (Value ==
"-force_cpusubtype_ALL") {
2626 }
else if (Value ==
"-L") {
2627 CmdArgs.push_back(
"-msave-temp-labels");
2628 }
else if (Value ==
"--fatal-warnings") {
2629 CmdArgs.push_back(
"-massembler-fatal-warnings");
2630 }
else if (Value ==
"--noexecstack") {
2631 CmdArgs.push_back(
"-mnoexecstack");
2632 }
else if (Value ==
"-compress-debug-sections" ||
2633 Value ==
"--compress-debug-sections") {
2634 CompressDebugSections =
true;
2635 }
else if (Value ==
"-nocompress-debug-sections" ||
2636 Value ==
"--nocompress-debug-sections") {
2637 CompressDebugSections =
false;
2638 }
else if (Value.startswith(
"-I")) {
2639 CmdArgs.push_back(Value.data());
2644 }
else if (Value.startswith(
"-gdwarf-")) {
2647 if (DwarfVersion == 0) {
2648 CmdArgs.push_back(Value.data());
2652 llvm::DebuggerKind::Default);
2654 }
else if (Value.startswith(
"-mcpu") || Value.startswith(
"-mfpu") ||
2655 Value.startswith(
"-mhwdiv") || Value.startswith(
"-march")) {
2658 D.
Diag(diag::err_drv_unsupported_option_argument)
2659 << A->getOption().getName() <<
Value;
2663 if (CompressDebugSections) {
2664 if (llvm::zlib::isAvailable())
2665 CmdArgs.push_back(
"-compress-debug-sections");
2667 D.
Diag(diag::warn_debug_compression_unavailable);
2675 ArgStringList &CmdArgs) {
2703 const ArgList &Args) {
2704 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2706 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2708 RuntimeName = A->getValue();
2710 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
2711 .Case(
"libomp", OMPRT_OMP)
2712 .Case(
"libgomp", OMPRT_GOMP)
2713 .Case(
"libiomp5", OMPRT_IOMP5)
2714 .Default(OMPRT_Unknown);
2716 if (RT == OMPRT_Unknown) {
2718 TC.
getDriver().
Diag(diag::err_drv_unsupported_option_argument)
2719 << A->getOption().getName() << A->getValue();
2722 TC.
getDriver().
Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
2729 const ArgList &Args) {
2730 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
2731 options::OPT_fno_openmp,
false))
2736 CmdArgs.push_back(
"-lomp");
2739 CmdArgs.push_back(
"-lgomp");
2742 CmdArgs.push_back(
"-liomp5");
2751 ArgStringList &CmdArgs, StringRef Sanitizer,
2755 if (!IsShared) CmdArgs.push_back(
"-whole-archive");
2757 if (!IsShared) CmdArgs.push_back(
"-no-whole-archive");
2763 ArgStringList &CmdArgs,
2764 StringRef Sanitizer) {
2766 if (llvm::sys::fs::exists(SanRT +
".syms")) {
2767 CmdArgs.push_back(Args.MakeArgString(
"--dynamic-list=" + SanRT +
".syms"));
2774 ArgStringList &CmdArgs) {
2777 CmdArgs.push_back(
"--no-as-needed");
2778 CmdArgs.push_back(
"-lpthread");
2779 CmdArgs.push_back(
"-lrt");
2780 CmdArgs.push_back(
"-lm");
2782 if (TC.
getTriple().getOS() != llvm::Triple::FreeBSD)
2783 CmdArgs.push_back(
"-ldl");
2794 SharedRuntimes.push_back(
"asan");
2798 if (Args.hasArg(options::OPT_shared) || TC.
getTriple().isAndroid()) {
2804 HelperStaticRuntimes.push_back(
"asan-preinit");
2806 StaticRuntimes.push_back(
"asan");
2808 StaticRuntimes.push_back(
"asan_cxx");
2812 StaticRuntimes.push_back(
"dfsan");
2814 StaticRuntimes.push_back(
"lsan");
2816 StaticRuntimes.push_back(
"msan");
2818 StaticRuntimes.push_back(
"msan_cxx");
2821 StaticRuntimes.push_back(
"tsan");
2823 StaticRuntimes.push_back(
"tsan_cxx");
2826 StaticRuntimes.push_back(
"ubsan_standalone");
2828 StaticRuntimes.push_back(
"ubsan_standalone_cxx");
2831 StaticRuntimes.push_back(
"safestack");
2833 StaticRuntimes.push_back(
"cfi");
2835 StaticRuntimes.push_back(
"cfi_diag");
2841 ArgStringList &CmdArgs) {
2843 HelperStaticRuntimes;
2845 HelperStaticRuntimes);
2846 for (
auto RT : SharedRuntimes)
2848 for (
auto RT : HelperStaticRuntimes)
2850 bool AddExportDynamic =
false;
2851 for (
auto RT : StaticRuntimes) {
2857 if (AddExportDynamic)
2858 CmdArgs.push_back(
"-export-dynamic");
2859 return !StaticRuntimes.empty();
2864 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2865 return !A->getOption().matches(options::OPT_O0);
2871 const llvm::Triple &Triple) {
2872 switch (Triple.getArch()) {
2873 case llvm::Triple::xcore:
2874 case llvm::Triple::wasm32:
2875 case llvm::Triple::wasm64:
2883 if (Triple.isOSLinux()) {
2884 switch (Triple.getArch()) {
2886 case llvm::Triple::mips64:
2887 case llvm::Triple::mips64el:
2888 case llvm::Triple::mips:
2889 case llvm::Triple::mipsel:
2890 case llvm::Triple::systemz:
2891 case llvm::Triple::x86:
2892 case llvm::Triple::x86_64:
2899 if (Triple.isOSWindows()) {
2900 switch (Triple.getArch()) {
2901 case llvm::Triple::x86:
2903 case llvm::Triple::arm:
2904 case llvm::Triple::thumb:
2918 const llvm::Triple &Triple) {
2919 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2920 options::OPT_fomit_frame_pointer))
2921 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2922 if (Args.hasArg(options::OPT_pg))
2929 const llvm::Triple &Triple) {
2930 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2931 options::OPT_momit_leaf_frame_pointer))
2932 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2933 if (Args.hasArg(options::OPT_pg))
2936 if (Triple.isPS4CPU())
2945 if (!llvm::sys::fs::current_path(cwd)) {
2946 CmdArgs.push_back(
"-fdebug-compilation-dir");
2947 CmdArgs.push_back(Args.MakeArgString(cwd));
2952 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2953 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2955 llvm::sys::path::replace_extension(T,
"dwo");
2956 return Args.MakeArgString(T);
2960 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2962 llvm::sys::path::replace_extension(F,
"dwo");
2964 return Args.MakeArgString(F);
2969 const JobAction &JA,
const ArgList &Args,
2970 const InputInfo &Output,
const char *OutFile) {
2971 ArgStringList ExtractArgs;
2972 ExtractArgs.push_back(
"--extract-dwo");
2974 ArgStringList StripArgs;
2975 StripArgs.push_back(
"--strip-dwo");
2980 ExtractArgs.push_back(OutFile);
2982 const char *Exec = Args.MakeArgString(TC.
GetProgramPath(
"objcopy"));
2986 C.
addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
2989 C.
addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs, II));
2995 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2996 if (A->getOption().matches(options::OPT_O4) ||
2997 A->getOption().matches(options::OPT_Ofast))
3000 if (A->getOption().matches(options::OPT_O0))
3003 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
3006 StringRef
S(A->getValue());
3014 unsigned OptLevel = 0;
3015 if (
S.getAsInteger(10, OptLevel))
3018 return OptLevel > 1;
3026 ArgStringList &CmdArgs) {
3029 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
3032 CmdArgs.push_back(
"-x");
3033 if (Args.hasArg(options::OPT_rewrite_objc))
3043 if (Version < 10000)
3046 unsigned Build = 0, Factor = 1;
3047 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
3048 Build = Build + (Version % 10) * Factor;
3049 return VersionTuple(Version / 100, Version % 100, Build);
3058 Args.ClaimAllArgs(options::OPT_flto_EQ);
3059 Args.ClaimAllArgs(options::OPT_flto);
3060 Args.ClaimAllArgs(options::OPT_fno_lto);
3065 const char *Username = getenv(
"LOGNAME");
3067 const char *Username = getenv(
"USERNAME");
3072 for (
const char *P = Username; *
P; ++
P, ++Len) {
3079 if (Username && Len > 0) {
3080 Result.append(Username, Username + Len);
3087 std::string UID = llvm::utostr(getuid());
3090 std::string UID =
"9999";
3092 Result.append(UID.begin(), UID.end());
3096 const llvm::Triple &Triple,
3097 const llvm::opt::ArgList &Args,
3098 bool IsWindowsMSVC) {
3099 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3101 Args.hasArg(options::OPT_fmsc_version) ||
3102 Args.hasArg(options::OPT_fms_compatibility_version)) {
3103 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
3104 const Arg *MSCompatibilityVersion =
3105 Args.getLastArg(options::OPT_fms_compatibility_version);
3107 if (MSCVersion && MSCompatibilityVersion) {
3109 D->
Diag(diag::err_drv_argument_not_allowed_with)
3110 << MSCVersion->getAsString(Args)
3111 << MSCompatibilityVersion->getAsString(Args);
3115 if (MSCompatibilityVersion) {
3117 if (MSVT.
tryParse(MSCompatibilityVersion->getValue()) && D)
3118 D->
Diag(diag::err_drv_invalid_value)
3119 << MSCompatibilityVersion->getAsString(Args)
3120 << MSCompatibilityVersion->getValue();
3125 unsigned Version = 0;
3126 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
3127 D->
Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
3128 << MSCVersion->getValue();
3132 unsigned Major, Minor, Micro;
3133 Triple.getEnvironmentVersion(Major, Minor, Micro);
3134 if (Major || Minor || Micro)
3143 const InputInfo &Output,
const ArgList &Args,
3144 ArgStringList &CmdArgs) {
3145 auto *ProfileGenerateArg = Args.getLastArg(
3146 options::OPT_fprofile_instr_generate,
3147 options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
3148 options::OPT_fprofile_generate_EQ,
3149 options::OPT_fno_profile_instr_generate);
3150 if (ProfileGenerateArg &&
3151 ProfileGenerateArg->getOption().matches(
3152 options::OPT_fno_profile_instr_generate))
3153 ProfileGenerateArg =
nullptr;
3155 auto *ProfileUseArg = Args.getLastArg(
3156 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
3157 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
3158 options::OPT_fno_profile_instr_use);
3159 if (ProfileUseArg &&
3160 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
3161 ProfileUseArg =
nullptr;
3163 if (ProfileGenerateArg && ProfileUseArg)
3164 D.
Diag(diag::err_drv_argument_not_allowed_with)
3165 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
3167 if (ProfileGenerateArg) {
3168 if (ProfileGenerateArg->getOption().matches(
3169 options::OPT_fprofile_instr_generate_EQ))
3170 ProfileGenerateArg->render(Args, CmdArgs);
3171 else if (ProfileGenerateArg->getOption().matches(
3172 options::OPT_fprofile_generate_EQ)) {
3174 llvm::sys::path::append(Path,
"default.profraw");
3176 Args.MakeArgString(Twine(
"-fprofile-instr-generate=") + Path));
3178 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3181 if (ProfileUseArg) {
3182 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
3183 ProfileUseArg->render(Args, CmdArgs);
3184 else if ((ProfileUseArg->getOption().matches(
3185 options::OPT_fprofile_use_EQ) ||
3186 ProfileUseArg->getOption().matches(
3187 options::OPT_fprofile_instr_use))) {
3189 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
3190 if (Path.empty() || llvm::sys::fs::is_directory(Path))
3191 llvm::sys::path::append(Path,
"default.profdata");
3193 Args.MakeArgString(Twine(
"-fprofile-instr-use=") + Path));
3197 if (Args.hasArg(options::OPT_ftest_coverage) ||
3198 Args.hasArg(options::OPT_coverage))
3199 CmdArgs.push_back(
"-femit-coverage-notes");
3200 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3202 Args.hasArg(options::OPT_coverage))
3203 CmdArgs.push_back(
"-femit-coverage-data");
3205 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3206 options::OPT_fno_coverage_mapping,
false) &&
3207 !ProfileGenerateArg)
3208 D.
Diag(diag::err_drv_argument_only_allowed_with)
3209 <<
"-fcoverage-mapping"
3210 <<
"-fprofile-instr-generate";
3212 if (Args.hasFlag(options::OPT_fcoverage_mapping,
3213 options::OPT_fno_coverage_mapping,
false))
3214 CmdArgs.push_back(
"-fcoverage-mapping");
3216 if (C.
getArgs().hasArg(options::OPT_c) ||
3217 C.
getArgs().hasArg(options::OPT_S)) {
3219 CmdArgs.push_back(
"-coverage-file");
3221 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o)) {
3222 CoverageFilename = FinalOutput->getValue();
3224 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
3226 if (llvm::sys::path::is_relative(CoverageFilename)) {
3228 if (!llvm::sys::fs::current_path(Pwd)) {
3229 llvm::sys::path::append(Pwd, CoverageFilename);
3230 CoverageFilename.swap(Pwd);
3233 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
3239 ArgStringList &CmdArgs) {
3240 if ((Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
3242 Args.hasFlag(options::OPT_fprofile_generate,
3243 options::OPT_fno_profile_instr_generate,
false) ||
3244 Args.hasFlag(options::OPT_fprofile_generate_EQ,
3245 options::OPT_fno_profile_instr_generate,
false) ||
3246 Args.hasFlag(options::OPT_fprofile_instr_generate,
3247 options::OPT_fno_profile_instr_generate,
false) ||
3248 Args.hasFlag(options::OPT_fprofile_instr_generate_EQ,
3249 options::OPT_fno_profile_instr_generate,
false) ||
3250 Args.hasArg(options::OPT_fcreate_profile) ||
3251 Args.hasArg(options::OPT_coverage)))
3252 CmdArgs.push_back(
"--dependent-lib=libclang_rt.profile-x86_64.a");
3259 static std::tuple<llvm::Reloc::Model, unsigned, bool>
3261 const ArgList &Args) {
3267 if (ToolChain.
getTriple().isOSBinFormatMachO() &&
3268 Args.hasArg(options::OPT_static))
3270 bool IsPICLevelTwo = PIC;
3273 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3276 if (ToolChain.
getTriple().isAndroid()) {
3277 switch (ToolChain.
getArch()) {
3278 case llvm::Triple::arm:
3279 case llvm::Triple::armeb:
3280 case llvm::Triple::thumb:
3281 case llvm::Triple::thumbeb:
3282 case llvm::Triple::aarch64:
3283 case llvm::Triple::mips:
3284 case llvm::Triple::mipsel:
3285 case llvm::Triple::mips64:
3286 case llvm::Triple::mips64el:
3290 case llvm::Triple::x86:
3291 case llvm::Triple::x86_64:
3293 IsPICLevelTwo =
true;
3302 if (ToolChain.
getTriple().getOS() == llvm::Triple::OpenBSD) {
3303 switch (ToolChain.
getArch()) {
3304 case llvm::Triple::mips64:
3305 case llvm::Triple::mips64el:
3306 case llvm::Triple::sparcel:
3307 case llvm::Triple::x86:
3308 case llvm::Triple::x86_64:
3309 IsPICLevelTwo =
false;
3312 case llvm::Triple::ppc:
3313 case llvm::Triple::sparc:
3314 case llvm::Triple::sparcv9:
3315 IsPICLevelTwo =
true;
3327 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3328 options::OPT_fpic, options::OPT_fno_pic,
3329 options::OPT_fPIE, options::OPT_fno_PIE,
3330 options::OPT_fpie, options::OPT_fno_pie);
3335 Option O = LastPICArg->getOption();
3336 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3337 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3338 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3340 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3342 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3345 if (Triple.isPS4CPU()) {
3346 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
3347 StringRef Model = ModelArg ? ModelArg->getValue() :
"";
3348 if (Model !=
"kernel") {
3351 << LastPICArg->getSpelling();
3361 if (PIC && (ToolChain.
getTriple().isOSDarwin() || Triple.isPS4CPU()))
3366 if (KernelOrKext && ((!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
3367 !Triple.isWatchOS()))
3370 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3373 if (!ToolChain.
getTriple().isOSDarwin())
3374 ToolChain.
getDriver().
Diag(diag::err_drv_unsupported_opt_for_target)
3375 << A->getSpelling() << ToolChain.
getTriple().str();
3384 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2 : 0,
false);
3388 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2 : 1, PIE);
3390 return std::make_tuple(llvm::Reloc::Static, 0,
false);
3395 case llvm::Reloc::Default:
3397 case llvm::Reloc::Static:
3399 case llvm::Reloc::PIC_:
3401 case llvm::Reloc::DynamicNoPIC:
3402 return "dynamic-no-pic";
3404 llvm_unreachable(
"Unknown Reloc::Model kind");
3408 ArgStringList &CmdArgs) {
3409 llvm::Reloc::Model RelocationModel;
3412 std::tie(RelocationModel, PICLevel, IsPIE) =
3415 if (RelocationModel != llvm::Reloc::Static)
3416 CmdArgs.push_back(
"-KPIC");
3421 const ArgList &Args,
const char *LinkingOutput)
const {
3422 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
3423 const llvm::Triple Triple(TripleStr);
3426 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3427 const Driver &D = getToolChain().getDriver();
3428 ArgStringList CmdArgs;
3430 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
3431 bool IsWindowsCygnus =
3432 getToolChain().getTriple().isWindowsCygwinEnvironment();
3433 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
3434 bool IsPS4CPU = getToolChain().getTriple().isPS4CPU();
3437 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
3443 assert((IsCuda || Inputs.size() == 1) &&
"Unable to handle multiple inputs.");
3448 CmdArgs.push_back(
"-cc1");
3451 CmdArgs.push_back(
"-triple");
3452 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3454 const ToolChain *AuxToolChain =
nullptr;
3465 llvm_unreachable(
"Can't figure out CUDA compilation mode.");
3466 assert(AuxToolChain !=
nullptr &&
"No aux toolchain.");
3467 CmdArgs.push_back(
"-aux-triple");
3468 CmdArgs.push_back(Args.MakeArgString(AuxToolChain->
getTriple().str()));
3469 CmdArgs.push_back(
"-fcuda-target-overloads");
3470 CmdArgs.push_back(
"-fcuda-disable-target-call-checks");
3473 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3474 Triple.getArch() == llvm::Triple::thumb)) {
3475 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
3477 Triple.getArchName().substr(Offset).getAsInteger(10, Version);
3479 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
3486 getToolChain().addClangWarningOptions(CmdArgs);
3489 RewriteKind rewriteKind = RK_None;
3491 if (isa<AnalyzeJobAction>(JA)) {
3492 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
3493 CmdArgs.push_back(
"-analyze");
3494 }
else if (isa<MigrateJobAction>(JA)) {
3495 CmdArgs.push_back(
"-migrate");
3496 }
else if (isa<PreprocessJobAction>(JA)) {
3497 if (Output.
getType() == types::TY_Dependencies)
3498 CmdArgs.push_back(
"-Eonly");
3500 CmdArgs.push_back(
"-E");
3501 if (Args.hasArg(options::OPT_rewrite_objc) &&
3502 !Args.hasArg(options::OPT_g_Group))
3503 CmdArgs.push_back(
"-P");
3505 }
else if (isa<AssembleJobAction>(JA)) {
3506 CmdArgs.push_back(
"-emit-obj");
3511 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
3512 }
else if (isa<PrecompileJobAction>(JA)) {
3516 if (JA.
getType() == types::TY_Nothing)
3517 CmdArgs.push_back(
"-fsyntax-only");
3519 CmdArgs.push_back(
"-emit-pch");
3521 CmdArgs.push_back(
"-emit-pth");
3522 }
else if (isa<VerifyPCHJobAction>(JA)) {
3523 CmdArgs.push_back(
"-verify-pch");
3525 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3526 "Invalid action for clang tool.");
3527 if (JA.
getType() == types::TY_Nothing) {
3528 CmdArgs.push_back(
"-fsyntax-only");
3529 }
else if (JA.
getType() == types::TY_LLVM_IR ||
3530 JA.
getType() == types::TY_LTO_IR) {
3531 CmdArgs.push_back(
"-emit-llvm");
3532 }
else if (JA.
getType() == types::TY_LLVM_BC ||
3533 JA.
getType() == types::TY_LTO_BC) {
3534 CmdArgs.push_back(
"-emit-llvm-bc");
3535 }
else if (JA.
getType() == types::TY_PP_Asm) {
3536 CmdArgs.push_back(
"-S");
3537 }
else if (JA.
getType() == types::TY_AST) {
3538 CmdArgs.push_back(
"-emit-pch");
3539 }
else if (JA.
getType() == types::TY_ModuleFile) {
3540 CmdArgs.push_back(
"-module-file-info");
3541 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
3542 CmdArgs.push_back(
"-rewrite-objc");
3543 rewriteKind = RK_NonFragile;
3544 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
3545 CmdArgs.push_back(
"-rewrite-objc");
3546 rewriteKind = RK_Fragile;
3548 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
3555 if (JA.
getType() == types::TY_LLVM_BC)
3556 CmdArgs.push_back(
"-emit-llvm-uselists");
3559 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
3562 if (
const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
3564 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3566 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
3573 CmdArgs.push_back(
"-disable-free");
3577 CmdArgs.push_back(
"-disable-llvm-verifier");
3582 CmdArgs.push_back(
"-main-file-name");
3583 CmdArgs.push_back(getBaseInputName(Args, Input));
3587 if (Args.hasArg(options::OPT_static))
3588 CmdArgs.push_back(
"-static-define");
3590 if (isa<AnalyzeJobAction>(JA)) {
3592 CmdArgs.push_back(
"-analyzer-store=region");
3595 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
3597 CmdArgs.push_back(
"-analyzer-eagerly-assume");
3600 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3601 CmdArgs.push_back(
"-analyzer-checker=core");
3604 CmdArgs.push_back(
"-analyzer-checker=unix");
3608 CmdArgs.push_back(
"-analyzer-disable-checker=unix.API");
3609 CmdArgs.push_back(
"-analyzer-disable-checker=unix.Vfork");
3612 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
3613 CmdArgs.push_back(
"-analyzer-checker=osx");
3615 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3618 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3622 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
3623 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3624 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3625 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3626 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3627 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3631 CmdArgs.push_back(
"-analyzer-checker=nullability.NullPassedToNonnull");
3633 "-analyzer-checker=nullability.NullReturnedFromNonnull");
3638 CmdArgs.push_back(
"-analyzer-output");
3639 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3640 CmdArgs.push_back(A->getValue());
3642 CmdArgs.push_back(
"plist");
3647 CmdArgs.push_back(
"-w");
3650 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3655 llvm::Reloc::Model RelocationModel;
3658 std::tie(RelocationModel, PICLevel, IsPIE) =
3663 CmdArgs.push_back(
"-mrelocation-model");
3664 CmdArgs.push_back(RMName);
3667 CmdArgs.push_back(
"-pic-level");
3668 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
3670 CmdArgs.push_back(
"-pie-level");
3671 CmdArgs.push_back(PICLevel == 1 ?
"1" :
"2");
3675 if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
3676 CmdArgs.push_back(
"-meabi");
3677 CmdArgs.push_back(A->getValue());
3680 CmdArgs.push_back(
"-mthread-model");
3681 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3682 CmdArgs.push_back(A->getValue());
3684 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3686 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3688 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3689 options::OPT_fno_merge_all_constants))
3690 CmdArgs.push_back(
"-fno-merge-all-constants");
3694 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3695 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
3696 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3697 options::OPT_frewrite_map_file_EQ)) {
3698 CmdArgs.push_back(
"-frewrite-map-file");
3699 CmdArgs.push_back(A->getValue());
3704 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3705 StringRef v = A->getValue();
3706 CmdArgs.push_back(
"-mllvm");
3707 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
3711 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3712 CmdArgs.push_back(
"-mregparm");
3713 CmdArgs.push_back(A->getValue());
3716 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3717 options::OPT_freg_struct_return)) {
3718 if (getToolChain().getArch() != llvm::Triple::x86) {
3719 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3720 << A->getSpelling() << getToolChain().getTriple().str();
3721 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3722 CmdArgs.push_back(
"-fpcc-struct-return");
3724 assert(A->getOption().matches(options::OPT_freg_struct_return));
3725 CmdArgs.push_back(
"-freg-struct-return");
3729 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
3730 CmdArgs.push_back(
"-mrtd");
3733 CmdArgs.push_back(
"-mdisable-fp-elim");
3734 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3735 options::OPT_fno_zero_initialized_in_bss))
3736 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
3741 OptSpecifier StrictAliasingAliasOption =
3742 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
3745 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
3746 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
3747 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
3748 CmdArgs.push_back(
"-relaxed-aliasing");
3749 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3750 options::OPT_fno_struct_path_tbaa))
3751 CmdArgs.push_back(
"-no-struct-path-tbaa");
3752 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3754 CmdArgs.push_back(
"-fstrict-enums");
3755 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
3756 options::OPT_fno_strict_vtable_pointers,
3758 CmdArgs.push_back(
"-fstrict-vtable-pointers");
3759 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3760 options::OPT_fno_optimize_sibling_calls))
3761 CmdArgs.push_back(
"-mdisable-tail-calls");
3764 if (Args.hasArg(options::OPT_fsplit_stack))
3765 CmdArgs.push_back(
"-split-stacks");
3769 OptSpecifier FastMathAliasOption =
3770 OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
3777 if (Arg *A = Args.getLastArg(
3778 options::OPT_ffast_math, FastMathAliasOption,
3779 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3780 options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
3781 options::OPT_fno_honor_infinities))
3782 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3783 A->getOption().getID() != options::OPT_fno_finite_math_only &&
3784 A->getOption().getID() != options::OPT_fhonor_infinities)
3785 CmdArgs.push_back(
"-menable-no-infs");
3786 if (Arg *A = Args.getLastArg(
3787 options::OPT_ffast_math, FastMathAliasOption,
3788 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3789 options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
3790 options::OPT_fno_honor_nans))
3791 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3792 A->getOption().getID() != options::OPT_fno_finite_math_only &&
3793 A->getOption().getID() != options::OPT_fhonor_nans)
3794 CmdArgs.push_back(
"-menable-no-nans");
3797 bool MathErrno = getToolChain().IsMathErrnoDefault();
3799 Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3800 options::OPT_fno_fast_math, options::OPT_fmath_errno,
3801 options::OPT_fno_math_errno)) {
3805 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3806 A->getOption().getID() == options::OPT_ffast_math ||
3807 A->getOption().getID() == options::OPT_Ofast)
3809 else if (A->getOption().getID() == options::OPT_fmath_errno)
3813 CmdArgs.push_back(
"-fmath-errno");
3819 bool AssociativeMath =
false;
3820 if (Arg *A = Args.getLastArg(
3821 options::OPT_ffast_math, FastMathAliasOption,
3822 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3823 options::OPT_fno_unsafe_math_optimizations,
3824 options::OPT_fassociative_math, options::OPT_fno_associative_math))
3825 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3826 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3827 A->getOption().getID() != options::OPT_fno_associative_math)
3828 AssociativeMath =
true;
3829 bool ReciprocalMath =
false;
3830 if (Arg *A = Args.getLastArg(
3831 options::OPT_ffast_math, FastMathAliasOption,
3832 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3833 options::OPT_fno_unsafe_math_optimizations,
3834 options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
3835 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3836 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3837 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3838 ReciprocalMath =
true;
3839 bool SignedZeros =
true;
3840 if (Arg *A = Args.getLastArg(
3841 options::OPT_ffast_math, FastMathAliasOption,
3842 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3843 options::OPT_fno_unsafe_math_optimizations,
3844 options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
3845 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3846 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3847 A->getOption().getID() != options::OPT_fsigned_zeros)
3848 SignedZeros =
false;
3849 bool TrappingMath =
true;
3850 if (Arg *A = Args.getLastArg(
3851 options::OPT_ffast_math, FastMathAliasOption,
3852 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3853 options::OPT_fno_unsafe_math_optimizations,
3854 options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
3855 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3856 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3857 A->getOption().getID() != options::OPT_ftrapping_math)
3858 TrappingMath =
false;
3859 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3861 CmdArgs.push_back(
"-menable-unsafe-fp-math");
3864 CmdArgs.push_back(
"-fno-signed-zeros");
3867 CmdArgs.push_back(
"-freciprocal-math");
3870 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3871 options::OPT_fno_fast_math,
3872 options::OPT_ffp_contract)) {
3873 if (A->getOption().getID() == options::OPT_ffp_contract) {
3874 StringRef Val = A->getValue();
3875 if (Val ==
"fast" || Val ==
"on" || Val ==
"off") {
3876 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + Val));
3878 D.
Diag(diag::err_drv_unsupported_option_argument)
3879 << A->getOption().getName() << Val;
3881 }
else if (A->getOption().matches(options::OPT_ffast_math) ||
3882 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
3884 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3888 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
3895 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3896 options::OPT_fno_fast_math))
3897 if (!A->getOption().matches(options::OPT_fno_fast_math))
3898 CmdArgs.push_back(
"-ffast-math");
3899 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3900 options::OPT_fno_fast_math))
3901 if (A->getOption().matches(options::OPT_ffinite_math_only))
3902 CmdArgs.push_back(
"-ffinite-math-only");
3906 bool IsIntegratedAssemblerDefault =
3907 getToolChain().IsIntegratedAssemblerDefault();
3908 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
3909 IsIntegratedAssemblerDefault) ||
3910 Args.hasArg(options::OPT_dA))
3911 CmdArgs.push_back(
"-masm-verbose");
3913 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3914 IsIntegratedAssemblerDefault))
3915 CmdArgs.push_back(
"-no-integrated-as");
3917 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3918 CmdArgs.push_back(
"-mdebug-pass");
3919 CmdArgs.push_back(
"Structure");
3921 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3922 CmdArgs.push_back(
"-mdebug-pass");
3923 CmdArgs.push_back(
"Arguments");
3928 if (!getToolChain().getTriple().isOSDarwin())
3929 CmdArgs.push_back(
"-mconstructor-aliases");
3933 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
3934 CmdArgs.push_back(
"-fforbid-guard-variables");
3936 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
3938 CmdArgs.push_back(
"-mms-bitfields");
3944 bool AsynchronousUnwindTables =
3945 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3946 options::OPT_fno_asynchronous_unwind_tables,
3947 (getToolChain().IsUnwindTablesDefault() ||
3948 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3950 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3951 AsynchronousUnwindTables))
3952 CmdArgs.push_back(
"-munwind-tables");
3954 getToolChain().addClangTargetOptions(Args, CmdArgs);
3956 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3957 CmdArgs.push_back(
"-mlimit-float-precision");
3958 CmdArgs.push_back(A->getValue());
3962 (void)Args.hasArg(options::OPT_mtune_EQ);
3964 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
3965 CmdArgs.push_back(
"-mcode-model");
3966 CmdArgs.push_back(A->getValue());
3970 std::string CPU =
getCPUName(Args, Triple,
false);
3972 CmdArgs.push_back(
"-target-cpu");
3973 CmdArgs.push_back(Args.MakeArgString(CPU));
3976 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3977 CmdArgs.push_back(
"-mfpmath");
3978 CmdArgs.push_back(A->getValue());
3985 switch (getToolChain().getArch()) {
3989 case llvm::Triple::arm:
3990 case llvm::Triple::armeb:
3991 case llvm::Triple::thumb:
3992 case llvm::Triple::thumbeb:
3994 AddARMTargetArgs(Triple, Args, CmdArgs, KernelOrKext);
3997 case llvm::Triple::aarch64:
3998 case llvm::Triple::aarch64_be:
3999 AddAArch64TargetArgs(Args, CmdArgs);
4002 case llvm::Triple::mips:
4003 case llvm::Triple::mipsel:
4004 case llvm::Triple::mips64:
4005 case llvm::Triple::mips64el:
4006 AddMIPSTargetArgs(Args, CmdArgs);
4009 case llvm::Triple::ppc:
4010 case llvm::Triple::ppc64:
4011 case llvm::Triple::ppc64le:
4012 AddPPCTargetArgs(Args, CmdArgs);
4015 case llvm::Triple::sparc:
4016 case llvm::Triple::sparcel:
4017 case llvm::Triple::sparcv9:
4018 AddSparcTargetArgs(Args, CmdArgs);
4021 case llvm::Triple::x86:
4022 case llvm::Triple::x86_64:
4023 AddX86TargetArgs(Args, CmdArgs);
4026 case llvm::Triple::hexagon:
4027 AddHexagonTargetArgs(Args, CmdArgs);
4030 case llvm::Triple::wasm32:
4031 case llvm::Triple::wasm64:
4032 AddWebAssemblyTargetArgs(Args, CmdArgs);
4045 unsigned DwarfVersion = 0;
4046 llvm::DebuggerKind DebuggerTuning = getToolChain().getDefaultDebuggerTuning();
4050 bool EmitCodeView =
false;
4053 if (getToolChain().getDriver().IsCLMode())
4054 AddClangCLArgs(Args, CmdArgs, &DebugInfoKind, &EmitCodeView);
4057 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4058 CmdArgs.push_back(
"-target-linker-version");
4059 CmdArgs.push_back(A->getValue());
4063 CmdArgs.push_back(
"-momit-leaf-frame-pointer");
4068 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
4070 if (
types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
4071 getToolChain().getArch() == llvm::Triple::x86) {
4072 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
4073 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
4074 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
4075 << Unsupported->getOption().getName();
4079 Args.AddAllArgs(CmdArgs, options::OPT_v);
4080 Args.AddLastArg(CmdArgs, options::OPT_H);
4082 CmdArgs.push_back(
"-header-include-file");
4086 Args.AddLastArg(CmdArgs, options::OPT_P);
4087 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
4090 CmdArgs.push_back(
"-diagnostic-log-file");
4095 Args.ClaimAllArgs(options::OPT_g_Group);
4096 Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
4097 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
4099 if (A->getOption().matches(options::OPT_gN_Group)) {
4105 A->getIndex() > SplitDwarfArg->getIndex())
4106 SplitDwarfArg =
nullptr;
4113 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
4114 options::OPT_ggdbN_Group)) {
4115 if (A->getOption().matches(options::OPT_glldb))
4116 DebuggerTuning = llvm::DebuggerKind::LLDB;
4117 else if (A->getOption().matches(options::OPT_gsce))
4118 DebuggerTuning = llvm::DebuggerKind::SCE;
4120 DebuggerTuning = llvm::DebuggerKind::GDB;
4124 if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
4125 options::OPT_gdwarf_4, options::OPT_gdwarf_5))
4130 if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {
4132 CmdArgs.push_back(
"-gcodeview");
4133 }
else if (DwarfVersion == 0 &&
4135 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
4139 Args.ClaimAllArgs(options::OPT_g_flags_Group);
4142 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
4144 CmdArgs.push_back(
"-dwarf-column-info");
4147 if (Args.hasArg(options::OPT_gmodules)) {
4149 CmdArgs.push_back(
"-dwarf-ext-refs");
4150 CmdArgs.push_back(
"-fmodule-format=obj");
4156 if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
4158 CmdArgs.push_back(
"-backend-option");
4159 CmdArgs.push_back(
"-split-dwarf=Enable");
4167 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,
4168 options::OPT_fno_standalone_debug,
4169 getToolChain().GetDefaultStandaloneDebug());
4176 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
4177 CmdArgs.push_back(
"-backend-option");
4178 CmdArgs.push_back(
"-generate-gnu-dwarf-pub-sections");
4184 if (Args.hasArg(options::OPT_gdwarf_aranges) || IsPS4CPU) {
4185 CmdArgs.push_back(
"-backend-option");
4186 CmdArgs.push_back(
"-generate-arange-section");
4189 if (Args.hasFlag(options::OPT_fdebug_types_section,
4190 options::OPT_fno_debug_types_section,
false)) {
4191 CmdArgs.push_back(
"-backend-option");
4192 CmdArgs.push_back(
"-generate-type-units");
4197 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI ||
4198 Triple.getArch() == llvm::Triple::wasm32 ||
4199 Triple.getArch() == llvm::Triple::wasm64;
4201 if (Args.hasFlag(options::OPT_ffunction_sections,
4202 options::OPT_fno_function_sections, UseSeparateSections)) {
4203 CmdArgs.push_back(
"-ffunction-sections");
4206 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
4207 UseSeparateSections)) {
4208 CmdArgs.push_back(
"-fdata-sections");
4211 if (!Args.hasFlag(options::OPT_funique_section_names,
4212 options::OPT_fno_unique_section_names,
true))
4213 CmdArgs.push_back(
"-fno-unique-section-names");
4215 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
4220 if (getToolChain().getTriple().isPS4CPU())
4224 if (Args.hasArg(options::OPT_nostdinc)) {
4225 CmdArgs.push_back(
"-nostdsysteminc");
4226 CmdArgs.push_back(
"-nobuiltininc");
4228 if (Args.hasArg(options::OPT_nostdlibinc))
4229 CmdArgs.push_back(
"-nostdsysteminc");
4230 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
4231 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
4235 CmdArgs.push_back(
"-resource-dir");
4238 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
4240 bool ARCMTEnabled =
false;
4241 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
4242 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
4243 options::OPT_ccc_arcmt_modify,
4244 options::OPT_ccc_arcmt_migrate)) {
4245 ARCMTEnabled =
true;
4246 switch (A->getOption().getID()) {
4248 llvm_unreachable(
"missed a case");
4249 case options::OPT_ccc_arcmt_check:
4250 CmdArgs.push_back(
"-arcmt-check");
4252 case options::OPT_ccc_arcmt_modify:
4253 CmdArgs.push_back(
"-arcmt-modify");
4255 case options::OPT_ccc_arcmt_migrate:
4256 CmdArgs.push_back(
"-arcmt-migrate");
4257 CmdArgs.push_back(
"-mt-migrate-directory");
4258 CmdArgs.push_back(A->getValue());
4260 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
4261 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
4266 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
4267 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
4268 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
4271 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
4273 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4274 <<
"-ccc-arcmt-migrate";
4276 CmdArgs.push_back(
"-mt-migrate-directory");
4277 CmdArgs.push_back(A->getValue());
4279 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
4280 options::OPT_objcmt_migrate_subscripting,
4281 options::OPT_objcmt_migrate_property)) {
4283 CmdArgs.push_back(
"-objcmt-migrate-literals");
4284 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
4285 CmdArgs.push_back(
"-objcmt-migrate-property");
4287 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4288 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4289 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4292 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
4293 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
4294 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
4295 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
4296 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
4297 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
4298 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
4299 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
4300 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
4301 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
4302 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
4303 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
4304 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
4305 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
4306 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
4307 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
4315 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs,
4322 Args.ClaimAllArgs(options::OPT_D);
4325 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4326 if (A->getOption().matches(options::OPT_O4)) {
4327 CmdArgs.push_back(
"-O3");
4328 D.
Diag(diag::warn_O4_is_O3);
4330 A->render(Args, CmdArgs);
4336 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4337 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
4343 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
4344 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
4345 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
4346 CmdArgs.push_back(
"-pedantic");
4347 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
4348 Args.AddLastArg(CmdArgs, options::OPT_w);
4355 bool ImplyVCPPCXXVer =
false;
4356 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
4357 if (Std->getOption().matches(options::OPT_ansi))
4359 CmdArgs.push_back(
"-std=c++98");
4361 CmdArgs.push_back(
"-std=c89");
4363 Std->render(Args, CmdArgs);
4366 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
4367 options::OPT_ftrigraphs,
4368 options::OPT_fno_trigraphs))
4370 A->render(Args, CmdArgs);
4379 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
4381 else if (IsWindowsMSVC)
4382 ImplyVCPPCXXVer =
true;
4384 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4385 options::OPT_fno_trigraphs);
4401 Args.getLastArg(options::OPT_Wwrite_strings,
4402 options::OPT_Wno_write_strings, options::OPT_w);
4404 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
4405 CmdArgs.push_back(
"-fconst-strings");
4412 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4414 CmdArgs.push_back(
"-fdeprecated-macro");
4418 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4419 if (Asm->getOption().matches(options::OPT_fasm))
4420 CmdArgs.push_back(
"-fgnu-keywords");
4422 CmdArgs.push_back(
"-fno-gnu-keywords");
4426 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
4429 CmdArgs.push_back(
"-fno-autolink");
4434 for (
const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) {
4435 StringRef
Map = A->getValue();
4436 if (Map.find(
'=') == StringRef::npos)
4437 D.
Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) <<
Map;
4439 CmdArgs.push_back(Args.MakeArgString(
"-fdebug-prefix-map=" + Map));
4443 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4444 options::OPT_ftemplate_depth_EQ)) {
4445 CmdArgs.push_back(
"-ftemplate-depth");
4446 CmdArgs.push_back(A->getValue());
4449 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4450 CmdArgs.push_back(
"-foperator-arrow-depth");
4451 CmdArgs.push_back(A->getValue());
4454 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4455 CmdArgs.push_back(
"-fconstexpr-depth");
4456 CmdArgs.push_back(A->getValue());
4459 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4460 CmdArgs.push_back(
"-fconstexpr-steps");
4461 CmdArgs.push_back(A->getValue());
4464 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4465 CmdArgs.push_back(
"-fbracket-depth");
4466 CmdArgs.push_back(A->getValue());
4469 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4470 options::OPT_Wlarge_by_value_copy_def)) {
4471 if (A->getNumValues()) {
4472 StringRef
bytes = A->getValue();
4473 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
4475 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
4478 if (Args.hasArg(options::OPT_relocatable_pch))
4479 CmdArgs.push_back(
"-relocatable-pch");
4481 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4482 CmdArgs.push_back(
"-fconstant-string-class");
4483 CmdArgs.push_back(A->getValue());
4486 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4487 CmdArgs.push_back(
"-ftabstop");
4488 CmdArgs.push_back(A->getValue());
4491 CmdArgs.push_back(
"-ferror-limit");
4492 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
4493 CmdArgs.push_back(A->getValue());
4495 CmdArgs.push_back(
"19");
4497 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4498 CmdArgs.push_back(
"-fmacro-backtrace-limit");
4499 CmdArgs.push_back(A->getValue());
4502 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4503 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
4504 CmdArgs.push_back(A->getValue());
4507 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4508 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
4509 CmdArgs.push_back(A->getValue());
4512 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4513 CmdArgs.push_back(
"-fspell-checking-limit");
4514 CmdArgs.push_back(A->getValue());
4518 CmdArgs.push_back(
"-fmessage-length");
4519 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
4520 CmdArgs.push_back(A->getValue());
4524 unsigned N = llvm::sys::Process::StandardErrColumns();
4525 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
4529 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4530 options::OPT_fvisibility_ms_compat)) {
4531 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4532 CmdArgs.push_back(
"-fvisibility");
4533 CmdArgs.push_back(A->getValue());
4535 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4536 CmdArgs.push_back(
"-fvisibility");
4537 CmdArgs.push_back(
"hidden");
4538 CmdArgs.push_back(
"-ftype-visibility");
4539 CmdArgs.push_back(
"default");
4543 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
4545 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4548 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
4550 CmdArgs.push_back(
"-ffreestanding");
4553 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
4554 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
4555 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
4558 bool EmulatedTLSDefault = Triple.isAndroid();
4559 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
4560 EmulatedTLSDefault))
4561 CmdArgs.push_back(
"-femulated-tls");
4563 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm) {
4564 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
4565 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4567 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4568 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
4571 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4572 options::OPT_fno_openmp,
false))
4577 CmdArgs.push_back(
"-fopenmp");
4582 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
4583 options::OPT_fnoopenmp_use_tls,
true))
4584 CmdArgs.push_back(
"-fnoopenmp-use-tls");
4596 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
4597 Sanitize.
addArgs(getToolChain(), Args, CmdArgs, InputType);
4600 if (
const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
4601 const llvm::Triple::ArchType Arch = getToolChain().getArch();
4602 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
4603 Arch == llvm::Triple::ppc64le))
4604 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
4605 <<
"ppc/ppc64/ppc64le";
4609 if (Arg *A = Args.getLastArg(options::OPT_fzvector))
4610 if (Args.hasArg(options::OPT_faltivec))
4611 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4614 if (getToolChain().SupportsProfiling())
4615 Args.AddLastArg(CmdArgs, options::OPT_pg);
4618 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4619 options::OPT_fno_lax_vector_conversions))
4620 CmdArgs.push_back(
"-fno-lax-vector-conversions");
4622 if (Args.getLastArg(options::OPT_fapple_kext) ||
4623 (Args.hasArg(options::OPT_mkernel) &&
types::isCXX(InputType)))
4624 CmdArgs.push_back(
"-fapple-kext");
4626 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
4627 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
4628 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
4629 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4630 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
4632 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4633 CmdArgs.push_back(
"-ftrapv-handler");
4634 CmdArgs.push_back(A->getValue());
4637 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
4641 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
4642 if (A->getOption().matches(options::OPT_fwrapv))
4643 CmdArgs.push_back(
"-fwrapv");
4644 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4645 options::OPT_fno_strict_overflow)) {
4646 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4647 CmdArgs.push_back(
"-fwrapv");
4650 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4651 options::OPT_fno_reroll_loops))
4652 if (A->getOption().matches(options::OPT_freroll_loops))
4653 CmdArgs.push_back(
"-freroll-loops");
4655 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
4656 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4657 options::OPT_fno_unroll_loops);
4659 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4662 unsigned StackProtectorLevel = 0;
4663 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
4664 Args.ClaimAllArgs(options::OPT_fno_stack_protector);
4665 Args.ClaimAllArgs(options::OPT_fstack_protector_all);
4666 Args.ClaimAllArgs(options::OPT_fstack_protector_strong);
4667 Args.ClaimAllArgs(options::OPT_fstack_protector);
4668 }
else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
4669 options::OPT_fstack_protector_all,
4670 options::OPT_fstack_protector_strong,
4671 options::OPT_fstack_protector)) {
4672 if (A->getOption().matches(options::OPT_fstack_protector)) {
4673 StackProtectorLevel = std::max<unsigned>(
4675 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
4676 }
else if (A->getOption().matches(options::OPT_fstack_protector_strong))
4678 else if (A->getOption().matches(options::OPT_fstack_protector_all))
4681 StackProtectorLevel =
4682 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
4684 if (StackProtectorLevel) {
4685 CmdArgs.push_back(
"-stack-protector");
4686 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
4690 for (
const Arg *A : Args.filtered(options::OPT__param)) {
4691 StringRef Str(A->getValue());
4692 if (Str.startswith(
"ssp-buffer-size=")) {
4693 if (StackProtectorLevel) {
4694 CmdArgs.push_back(
"-stack-protector-buffer-size");
4696 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
4703 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4705 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
4707 if (Args.hasArg(options::OPT_mstack_alignment)) {
4708 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4709 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
4712 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4713 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4716 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
4718 CmdArgs.push_back(
"-mstack-probe-size=0");
4721 switch (getToolChain().getArch()) {
4722 case llvm::Triple::aarch64:
4723 case llvm::Triple::aarch64_be:
4724 case llvm::Triple::arm:
4725 case llvm::Triple::armeb:
4726 case llvm::Triple::thumb:
4727 case llvm::Triple::thumbeb:
4728 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
4735 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4736 options::OPT_mno_restrict_it)) {
4737 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4738 CmdArgs.push_back(
"-backend-option");
4739 CmdArgs.push_back(
"-arm-restrict-it");
4741 CmdArgs.push_back(
"-backend-option");
4742 CmdArgs.push_back(
"-arm-no-restrict-it");
4744 }
else if (Triple.isOSWindows() &&
4745 (Triple.getArch() == llvm::Triple::arm ||
4746 Triple.getArch() == llvm::Triple::thumb)) {
4748 CmdArgs.push_back(
"-backend-option");
4749 CmdArgs.push_back(
"-arm-restrict-it");
4754 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4755 StringRef fname = A->getValue();
4756 if (!llvm::sys::fs::exists(fname))
4757 D.
Diag(diag::err_drv_no_such_file) << fname;
4759 A->render(Args, CmdArgs);
4764 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
4765 !Args.hasArg(options::OPT_mkernel));
4767 CmdArgs.push_back(
"-fno-builtin");
4770 if (Args.hasArg(options::OPT_ffreestanding))
4771 UseBuiltins =
false;
4774 for (
const auto &Arg : Args) {
4775 const Option &O = Arg->getOption();
4776 if (!O.matches(options::OPT_fno_builtin_))
4785 StringRef FuncName = Arg->getValue();
4786 CmdArgs.push_back(Args.MakeArgString(
"-fno-builtin-" + FuncName));
4789 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4790 options::OPT_fno_assume_sane_operator_new))
4791 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4794 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
4795 getToolChain().IsBlocksDefault()) ||
4796 (Args.hasArg(options::OPT_fgnu_runtime) &&
4797 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4798 !Args.hasArg(options::OPT_fno_blocks))) {
4799 CmdArgs.push_back(
"-fblocks");
4801 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4802 !getToolChain().hasBlocksRuntime())
4803 CmdArgs.push_back(
"-fblocks-runtime-optional");
4809 bool HaveModules =
false;
4810 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
4811 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4812 options::OPT_fno_cxx_modules,
true);
4814 CmdArgs.push_back(
"-fmodules");
4821 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4822 options::OPT_fno_implicit_module_maps, HaveModules)) {
4823 CmdArgs.push_back(
"-fimplicit-module-maps");
4828 if (Args.hasFlag(options::OPT_fmodules_decluse,
4829 options::OPT_fno_modules_decluse,
false)) {
4830 CmdArgs.push_back(
"-fmodules-decluse");
4835 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4836 options::OPT_fno_modules_strict_decluse,
false)) {
4837 CmdArgs.push_back(
"-fmodules-strict-decluse");
4841 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4842 options::OPT_fno_implicit_modules)) {
4843 CmdArgs.push_back(
"-fno-implicit-modules");
4848 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
4852 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
4856 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4858 Args.ClaimAllArgs(options::OPT_fmodule_file);
4863 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4864 Path = A->getValue();
4870 llvm::sys::path::replace_extension(Path,
".cache");
4871 llvm::sys::path::append(Path,
"modules");
4872 }
else if (Path.empty()) {
4874 llvm::sys::path::system_temp_directory(
false, Path);
4875 llvm::sys::path::append(Path,
"org.llvm.clang.");
4877 llvm::sys::path::append(Path,
"ModuleCache");
4879 const char Arg[] =
"-fmodules-cache-path=";
4880 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
4881 CmdArgs.push_back(Args.MakeArgString(Path));
4888 llvm::sys::path::replace_extension(VFSDir,
".cache");
4892 llvm::sys::path::append(VFSDir,
"vfs");
4893 CmdArgs.push_back(
"-module-dependency-dir");
4894 CmdArgs.push_back(Args.MakeArgString(VFSDir));
4898 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
4901 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
4902 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4903 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
4905 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4907 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4908 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4909 D.
Diag(diag::err_drv_argument_not_allowed_with)
4910 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
4912 llvm::sys::fs::file_status Status;
4913 if (llvm::sys::fs::status(A->getValue(), Status))
4914 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
4915 CmdArgs.push_back(Args.MakeArgString(
4916 "-fbuild-session-timestamp=" +
4917 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
4920 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
4921 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4922 options::OPT_fbuild_session_file))
4923 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4925 Args.AddLastArg(CmdArgs,
4926 options::OPT_fmodules_validate_once_per_build_session);
4929 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4932 if (Args.hasFlag(options::OPT_fno_access_control,
4933 options::OPT_faccess_control,
false))
4934 CmdArgs.push_back(
"-fno-access-control");
4937 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4938 options::OPT_felide_constructors,
false))
4939 CmdArgs.push_back(
"-fno-elide-constructors");
4946 CmdArgs.push_back(
"-fno-rtti");
4949 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4950 getToolChain().getArch() == llvm::Triple::hexagon))
4951 CmdArgs.push_back(
"-fshort-enums");
4954 if (Arg *A = Args.getLastArg(
4955 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4956 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4957 if (A->getOption().matches(options::OPT_funsigned_char) ||
4958 A->getOption().matches(options::OPT_fno_signed_char)) {
4959 CmdArgs.push_back(
"-fno-signed-char");
4962 CmdArgs.push_back(
"-fno-signed-char");
4967 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
4968 !IsWindowsCygnus && !IsWindowsGNU &&
4969 getToolChain().getTriple().getOS() != llvm::Triple::Solaris &&
4970 getToolChain().getArch() != llvm::Triple::hexagon &&
4971 getToolChain().getArch() != llvm::Triple::xcore &&
4972 ((getToolChain().getTriple().getVendor() !=
4973 llvm::Triple::MipsTechnologies) ||
4974 getToolChain().getTriple().hasEnvironment())) ||
4976 CmdArgs.push_back(
"-fno-use-cxa-atexit");
4979 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
4981 CmdArgs.push_back(
"-fms-extensions");
4984 if (Args.hasFlag(options::OPT_fuse_line_directives,
4985 options::OPT_fno_use_line_directives,
false))
4986 CmdArgs.push_back(
"-fuse-line-directives");
4989 if (Args.hasFlag(options::OPT_fms_compatibility,
4990 options::OPT_fno_ms_compatibility,
4992 Args.hasFlag(options::OPT_fms_extensions,
4993 options::OPT_fno_ms_extensions,
true))))
4994 CmdArgs.push_back(
"-fms-compatibility");
4998 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
5001 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.
getAsString()));
5003 bool IsMSVC2015Compatible = MSVT.
getMajor() >= 19;
5004 if (ImplyVCPPCXXVer) {
5005 if (IsMSVC2015Compatible)
5006 CmdArgs.push_back(
"-std=c++14");
5008 CmdArgs.push_back(
"-std=c++11");
5012 if (Args.hasFlag(options::OPT_fborland_extensions,
5013 options::OPT_fno_borland_extensions,
false))
5014 CmdArgs.push_back(
"-fborland-extensions");
5017 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
5018 getToolChain().getTriple().isPS4()))
5019 CmdArgs.push_back(
"-fdeclspec");
5020 else if (Args.hasArg(options::OPT_fno_declspec))
5021 CmdArgs.push_back(
"-fno-declspec");
5025 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
5026 options::OPT_fno_threadsafe_statics,
5027 !IsWindowsMSVC || IsMSVC2015Compatible))
5028 CmdArgs.push_back(
"-fno-threadsafe-statics");
5032 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
5033 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
5034 CmdArgs.push_back(
"-fdelayed-template-parsing");
5038 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
5039 options::OPT_fno_gnu_keywords))
5040 A->render(Args, CmdArgs);
5042 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
5044 CmdArgs.push_back(
"-fgnu89-inline");
5046 if (Args.hasArg(options::OPT_fno_inline))
5047 CmdArgs.push_back(
"-fno-inline");
5049 if (Args.hasArg(options::OPT_fno_inline_functions))
5050 CmdArgs.push_back(
"-fno-inline-functions");
5052 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
5059 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
5060 options::OPT_fno_objc_legacy_dispatch,
5062 getToolChain().getArch()))) {
5063 if (getToolChain().UseObjCMixedDispatch())
5064 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
5066 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
5073 if (getToolChain().getArch() == llvm::Triple::x86 &&
5074 getToolChain().getTriple().isMacOSX() &&
5075 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
5078 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
5081 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
5082 CmdArgs.push_back(
"-fencode-extended-block-signature");
5089 getToolChain().CheckObjCARC();
5091 CmdArgs.push_back(
"-fobjc-arc");
5098 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
5100 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
5105 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
5106 options::OPT_fno_objc_arc_exceptions,
5108 CmdArgs.push_back(
"-fobjc-arc-exceptions");
5114 if (rewriteKind != RK_None)
5115 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
5119 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
5121 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
5124 D.
Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
5125 }
else if (getToolChain().SupportsObjCGC()) {
5126 GCArg->render(Args, CmdArgs);
5129 D.
Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
5135 auto WeakArg = Args.getLastArg(options::OPT_fobjc_weak,
5136 options::OPT_fno_objc_weak);
5140 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
5141 D.
Diag(diag::err_objc_weak_with_gc);
5143 if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
5144 D.
Diag(diag::err_objc_weak_unsupported);
5146 WeakArg->render(Args, CmdArgs);
5150 if (Args.hasFlag(options::OPT_fapplication_extension,
5151 options::OPT_fno_application_extension,
false))
5152 CmdArgs.push_back(
"-fapplication-extension");
5156 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
5159 if (getToolChain().UseSjLjExceptions(Args))
5160 CmdArgs.push_back(
"-fsjlj-exceptions");
5163 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5164 options::OPT_fno_assume_sane_operator_new))
5165 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
5169 if (Args.hasFlag(options::OPT_fsized_deallocation,
5170 options::OPT_fno_sized_deallocation,
false))
5171 CmdArgs.push_back(
"-fsized-deallocation");
5175 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
5176 options::OPT_fno_constant_cfstrings) ||
5177 !Args.hasFlag(options::OPT_mconstant_cfstrings,
5178 options::OPT_mno_constant_cfstrings))
5179 CmdArgs.push_back(
"-fno-constant-cfstrings");
5183 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
5184 options::OPT_fno_short_wchar))
5185 A->render(Args, CmdArgs);
5188 if (Args.hasFlag(options::OPT_fpascal_strings,
5189 options::OPT_fno_pascal_strings,
false))
5190 CmdArgs.push_back(
"-fpascal-strings");
5194 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
5195 std::string PackStructStr =
"-fpack-struct=";
5196 PackStructStr += A->getValue();
5197 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
5198 }
else if (Args.hasFlag(options::OPT_fpack_struct,
5199 options::OPT_fno_pack_struct,
false)) {
5200 CmdArgs.push_back(
"-fpack-struct=1");
5204 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
5205 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
5206 if (!SkipMaxTypeAlign) {
5207 std::string MaxTypeAlignStr =
"-fmax-type-align=";
5208 MaxTypeAlignStr += A->getValue();
5209 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5211 }
else if (getToolChain().getTriple().isOSDarwin()) {
5212 if (!SkipMaxTypeAlign) {
5213 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
5214 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5219 bool NoCommonDefault =
5221 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
5223 CmdArgs.push_back(
"-fno-common");
5227 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
5228 options::OPT_funsigned_bitfields))
5229 D.
Diag(diag::warn_drv_clang_unsupported)
5230 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
5233 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
5234 D.
Diag(diag::err_drv_clang_unsupported)
5235 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
5238 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
5239 StringRef value = inputCharset->getValue();
5240 if (value !=
"UTF-8")
5241 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
5246 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
5247 StringRef value = execCharset->getValue();
5248 if (value !=
"UTF-8")
5249 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
5254 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
5255 options::OPT_fno_caret_diagnostics,
true))
5256 CmdArgs.push_back(
"-fno-caret-diagnostics");
5259 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
5260 options::OPT_fno_diagnostics_fixit_info))
5261 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
5264 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
5265 options::OPT_fno_diagnostics_show_option))
5266 CmdArgs.push_back(
"-fdiagnostics-show-option");
5269 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
5270 CmdArgs.push_back(
"-fdiagnostics-show-category");
5271 CmdArgs.push_back(A->getValue());
5274 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
5275 CmdArgs.push_back(
"-fdiagnostics-format");
5276 CmdArgs.push_back(A->getValue());
5279 if (Arg *A = Args.getLastArg(
5280 options::OPT_fdiagnostics_show_note_include_stack,
5281 options::OPT_fno_diagnostics_show_note_include_stack)) {
5282 if (A->getOption().matches(
5283 options::OPT_fdiagnostics_show_note_include_stack))
5284 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
5286 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
5293 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
5294 for (
const auto &Arg : Args) {
5295 const Option &O = Arg->getOption();
5296 if (!O.matches(options::OPT_fcolor_diagnostics) &&
5297 !O.matches(options::OPT_fdiagnostics_color) &&
5298 !O.matches(options::OPT_fno_color_diagnostics) &&
5299 !O.matches(options::OPT_fno_diagnostics_color) &&
5300 !O.matches(options::OPT_fdiagnostics_color_EQ))
5304 if (O.matches(options::OPT_fcolor_diagnostics) ||
5305 O.matches(options::OPT_fdiagnostics_color)) {
5306 ShowColors = Colors_On;
5307 }
else if (O.matches(options::OPT_fno_color_diagnostics) ||
5308 O.matches(options::OPT_fno_diagnostics_color)) {
5309 ShowColors = Colors_Off;
5311 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
5312 StringRef value(Arg->getValue());
5313 if (value ==
"always")
5314 ShowColors = Colors_On;
5315 else if (value ==
"never")
5316 ShowColors = Colors_Off;
5317 else if (value ==
"auto")
5318 ShowColors = Colors_Auto;
5320 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
5321 << (
"-fdiagnostics-color=" + value).str();
5324 if (ShowColors == Colors_On ||
5325 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
5326 CmdArgs.push_back(
"-fcolor-diagnostics");
5328 if (Args.hasArg(options::OPT_fansi_escape_codes))
5329 CmdArgs.push_back(
"-fansi-escape-codes");
5331 if (!Args.hasFlag(options::OPT_fshow_source_location,
5332 options::OPT_fno_show_source_location))
5333 CmdArgs.push_back(
"-fno-show-source-location");
5335 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
5337 CmdArgs.push_back(
"-fno-show-column");
5339 if (!Args.hasFlag(options::OPT_fspell_checking,
5340 options::OPT_fno_spell_checking))
5341 CmdArgs.push_back(
"-fno-spell-checking");
5344 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
5346 CmdArgs.push_back(
"-fasm-blocks");
5349 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
5350 options::OPT_fno_gnu_inline_asm,
true))
5351 CmdArgs.push_back(
"-fno-gnu-inline-asm");
5357 OptSpecifier VectorizeAliasOption =
5358 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
5359 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
5360 options::OPT_fno_vectorize, EnableVec))
5361 CmdArgs.push_back(
"-vectorize-loops");
5365 OptSpecifier SLPVectAliasOption =
5366 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
5367 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
5368 options::OPT_fno_slp_vectorize, EnableSLPVec))
5369 CmdArgs.push_back(
"-vectorize-slp");
5372 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
5373 options::OPT_fno_slp_vectorize_aggressive,
false))
5374 CmdArgs.push_back(
"-vectorize-slp-aggressive");
5376 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
5377 A->render(Args, CmdArgs);
5381 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
5382 options::OPT_fno_dollars_in_identifiers)) {
5383 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
5384 CmdArgs.push_back(
"-fdollars-in-identifiers");
5386 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
5391 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
5392 options::OPT_fno_unit_at_a_time)) {
5393 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
5394 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
5397 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
5398 options::OPT_fno_apple_pragma_pack,
false))
5399 CmdArgs.push_back(
"-fapple-pragma-pack");
5404 if (getToolChain().getArch() == llvm::Triple::le32) {
5405 CmdArgs.push_back(
"-fno-math-builtin");
5412 if (getToolChain().getTriple().isOSDarwin() &&
5413 (getToolChain().getArch() == llvm::Triple::arm ||
5414 getToolChain().getArch() == llvm::Triple::thumb)) {
5415 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
5416 CmdArgs.push_back(
"-fno-builtin-strcat");
5417 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
5418 CmdArgs.push_back(
"-fno-builtin-strcpy");
5426 if (Args.hasFlag(options::OPT_frewrite_includes,
5427 options::OPT_fno_rewrite_includes,
false) ||
5429 CmdArgs.push_back(
"-frewrite-includes");
5432 if (Arg *A = Args.getLastArg(options::OPT_traditional,
5433 options::OPT_traditional_cpp)) {
5434 if (isa<PreprocessJobAction>(JA))
5435 CmdArgs.push_back(
"-traditional-cpp");
5437 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
5440 Args.AddLastArg(CmdArgs, options::OPT_dM);
5441 Args.AddLastArg(CmdArgs, options::OPT_dD);
5444 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5445 CmdArgs.push_back(
"-serialize-diagnostic-file");
5446 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
5449 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5450 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
5453 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
5455 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
5458 for (
const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5459 CmdArgs.push_back(
"-load");
5460 CmdArgs.push_back(A->getValue());
5466 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
5467 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
5472 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
5473 CmdArgs.push_back(
"-disable-llvm-optzns");
5475 A->render(Args, CmdArgs);
5482 CmdArgs.push_back(
"-disable-llvm-passes");
5484 if (Output.
getType() == types::TY_Dependencies) {
5487 CmdArgs.push_back(
"-o");
5490 assert(Output.
isNothing() &&
"Invalid output.");
5495 if (Input.isFilename())
5496 CmdArgs.push_back(Input.getFilename());
5498 Input.getInputArg().renderAsInput(Args, CmdArgs);
5500 Args.AddAllArgs(CmdArgs, options::OPT_undef);
5502 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5506 if (getToolChain().UseDwarfDebugFlags()) {
5507 ArgStringList OriginalArgs;
5508 for (
const auto &Arg : Args)
5509 Arg->render(Args, OriginalArgs);
5513 for (
const char *OriginalArg : OriginalArgs) {
5517 Flags += EscapedArg;
5519 CmdArgs.push_back(
"-dwarf-debug-flags");
5520 CmdArgs.push_back(Args.MakeArgString(Flags));
5525 bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
5526 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
5527 isa<BackendJobAction>(JA));
5528 const char *SplitDwarfOut;
5530 CmdArgs.push_back(
"-split-dwarf-file");
5532 CmdArgs.push_back(SplitDwarfOut);
5537 if (IsCuda && Inputs.size() > 1)
5538 for (
auto I = std::next(Inputs.begin()),
E = Inputs.end();
I !=
E; ++
I) {
5539 CmdArgs.push_back(
"-fcuda-include-gpubinary");
5540 CmdArgs.push_back(
I->getFilename());
5544 if (Args.hasArg(options::OPT__SLASH_fallback) &&
5545 Output.
getType() == types::TY_Object &&
5546 (InputType == types::TY_C || InputType == types::TY_CXX)) {
5548 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
5549 C.
addCommand(llvm::make_unique<FallbackCommand>(
5550 JA, *
this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
5552 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
5558 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
5559 SplitDebugInfo(getToolChain(), C, *
this, JA, Args, Output, SplitDwarfOut);
5561 if (Arg *A = Args.getLastArg(options::OPT_pg))
5562 if (Args.hasArg(options::OPT_fomit_frame_pointer))
5563 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
5564 << A->getAsString(Args);
5571 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
5575 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5576 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
5579 Args.ClaimAllArgs(options::OPT_emit_llvm);
5585 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
5586 ArgStringList &cmdArgs,
5587 RewriteKind rewriteKind)
const {
5590 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5591 options::OPT_fobjc_runtime_EQ);
5596 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5598 StringRef value = runtimeArg->getValue();
5600 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
5604 runtimeArg->render(args, cmdArgs);
5613 unsigned objcABIVersion = 1;
5615 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
5616 StringRef value = abiArg->getValue();
5619 else if (value ==
"2")
5621 else if (value ==
"3")
5624 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
5627 bool nonFragileABIIsDefault =
5628 (rewriteKind == RK_NonFragile ||
5629 (rewriteKind == RK_None &&
5630 getToolChain().IsObjCNonFragileABIDefault()));
5631 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5632 options::OPT_fno_objc_nonfragile_abi,
5633 nonFragileABIIsDefault)) {
5635 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
5636 unsigned nonFragileABIVersion = 1;
5638 unsigned nonFragileABIVersion = 2;
5642 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
5643 StringRef value = abiArg->getValue();
5645 nonFragileABIVersion = 1;
5646 else if (value ==
"2")
5647 nonFragileABIVersion = 2;
5649 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
5653 objcABIVersion = 1 + nonFragileABIVersion;
5661 bool isNonFragile = objcABIVersion != 1;
5667 switch (rewriteKind) {
5669 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5680 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5682 if (getToolChain().getTriple().isOSDarwin()) {
5683 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5692 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
5702 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
5707 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
5732 std::vector<std::string> EHArgs =
5733 Args.getAllArgValues(options::OPT__SLASH_EH);
5734 for (
auto EHVal : EHArgs) {
5735 for (
size_t I = 0,
E = EHVal.size();
I !=
E; ++
I) {
5749 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
5757 void Clang::AddClangCLArgs(
const ArgList &Args, ArgStringList &CmdArgs,
5759 bool *EmitCodeView)
const {
5760 unsigned RTOptionID = options::OPT__SLASH_MT;
5762 if (Args.hasArg(options::OPT__SLASH_LDd))
5765 RTOptionID = options::OPT__SLASH_MTd;
5767 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
5768 RTOptionID = A->getOption().getID();
5770 StringRef FlagForCRT;
5771 switch (RTOptionID) {
5772 case options::OPT__SLASH_MD:
5773 if (Args.hasArg(options::OPT__SLASH_LDd))
5774 CmdArgs.push_back(
"-D_DEBUG");
5775 CmdArgs.push_back(
"-D_MT");
5776 CmdArgs.push_back(
"-D_DLL");
5777 FlagForCRT =
"--dependent-lib=msvcrt";
5779 case options::OPT__SLASH_MDd:
5780 CmdArgs.push_back(
"-D_DEBUG");
5781 CmdArgs.push_back(
"-D_MT");
5782 CmdArgs.push_back(
"-D_DLL");
5783 FlagForCRT =
"--dependent-lib=msvcrtd";
5785 case options::OPT__SLASH_MT:
5786 if (Args.hasArg(options::OPT__SLASH_LDd))
5787 CmdArgs.push_back(
"-D_DEBUG");
5788 CmdArgs.push_back(
"-D_MT");
5789 FlagForCRT =
"--dependent-lib=libcmt";
5791 case options::OPT__SLASH_MTd:
5792 CmdArgs.push_back(
"-D_DEBUG");
5793 CmdArgs.push_back(
"-D_MT");
5794 FlagForCRT =
"--dependent-lib=libcmtd";
5797 llvm_unreachable(
"Unexpected option ID.");
5800 if (Args.hasArg(options::OPT__SLASH_Zl)) {
5801 CmdArgs.push_back(
"-D_VC_NODEFAULTLIB");
5803 CmdArgs.push_back(FlagForCRT.data());
5808 CmdArgs.push_back(
"--dependent-lib=oldnames");
5813 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5814 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5815 A->render(Args, CmdArgs);
5818 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5820 CmdArgs.push_back(
"-fno-rtti-data");
5823 *EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);
5824 bool EmitDwarf = Args.hasArg(options::OPT_gdwarf);
5827 if (*EmitCodeView && !EmitDwarf)
5830 CmdArgs.push_back(
"-gcodeview");
5832 const Driver &D = getToolChain().getDriver();
5835 if (EH.Synch || EH.Asynch) {
5836 CmdArgs.push_back(
"-fcxx-exceptions");
5837 CmdArgs.push_back(
"-fexceptions");
5841 if (Args.hasArg(options::OPT__SLASH_EP)) {
5842 CmdArgs.push_back(
"-E");
5843 CmdArgs.push_back(
"-P");
5846 unsigned VolatileOptionID;
5847 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5848 getToolChain().getArch() == llvm::Triple::x86)
5849 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5851 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5853 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5854 VolatileOptionID = A->getOption().getID();
5856 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5857 CmdArgs.push_back(
"-fms-volatile");
5859 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5860 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5861 if (MostGeneralArg && BestCaseArg)
5862 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5863 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5865 if (MostGeneralArg) {
5866 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5867 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5868 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5870 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5871 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5872 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5873 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5874 << FirstConflict->getAsString(Args)
5875 << SecondConflict->getAsString(Args);
5878 CmdArgs.push_back(
"-fms-memptr-rep=single");
5879 else if (MultipleArg)
5880 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
5882 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
5885 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5886 A->render(Args, CmdArgs);
5888 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5889 CmdArgs.push_back(
"-fdiagnostics-format");
5890 if (Args.hasArg(options::OPT__SLASH_fallback))
5891 CmdArgs.push_back(
"msvc-fallback");
5893 CmdArgs.push_back(
"msvc");
5900 return CLFallback.get();
5904 ArgStringList &CmdArgs)
const {
5907 const llvm::Triple &Triple = getToolChain().getTriple();
5910 CmdArgs.push_back(
"-target-abi");
5911 CmdArgs.push_back(ABIName.data());
5916 const ArgList &Args,
5917 const char *LinkingOutput)
const {
5918 ArgStringList CmdArgs;
5920 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
5923 std::string TripleStr =
5924 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
5925 const llvm::Triple Triple(TripleStr);
5928 Args.ClaimAllArgs(options::OPT_w);
5930 Args.ClaimAllArgs(options::OPT_emit_llvm);
5937 CmdArgs.push_back(
"-cc1as");
5940 CmdArgs.push_back(
"-triple");
5941 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5945 CmdArgs.push_back(
"-filetype");
5946 CmdArgs.push_back(
"obj");
5950 CmdArgs.push_back(
"-main-file-name");
5954 std::string CPU =
getCPUName(Args, Triple,
true);
5956 CmdArgs.push_back(
"-target-cpu");
5957 CmdArgs.push_back(Args.MakeArgString(CPU));
5964 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5967 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5970 const Action *SourceAction = &JA;
5972 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
5973 SourceAction = SourceAction->
getInputs()[0];
5978 if (SourceAction->
getType() == types::TY_Asm ||
5979 SourceAction->
getType() == types::TY_PP_Asm) {
5980 bool WantDebug =
false;
5981 unsigned DwarfVersion = 0;
5982 Args.ClaimAllArgs(options::OPT_g_Group);
5983 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
5984 WantDebug = !A->getOption().matches(options::OPT_g0) &&
5985 !A->getOption().matches(options::OPT_ggdb0);
5989 if (DwarfVersion == 0)
5990 DwarfVersion = getToolChain().GetDefaultDwarfVersion();
5994 DwarfVersion, llvm::DebuggerKind::Default);
6001 CmdArgs.push_back(
"-dwarf-debug-producer");
6005 Args.AddAllArgs(CmdArgs, options::OPT_I);
6010 llvm::Reloc::Model RelocationModel;
6013 std::tie(RelocationModel, PICLevel, IsPIE) =
6018 CmdArgs.push_back(
"-mrelocation-model");
6019 CmdArgs.push_back(RMName);
6024 if (getToolChain().UseDwarfDebugFlags()) {
6025 ArgStringList OriginalArgs;
6026 for (
const auto &Arg : Args)
6027 Arg->render(Args, OriginalArgs);
6030 const char *Exec = getToolChain().getDriver().getClangProgramPath();
6032 for (
const char *OriginalArg : OriginalArgs) {
6036 Flags += EscapedArg;
6038 CmdArgs.push_back(
"-dwarf-debug-flags");
6039 CmdArgs.push_back(Args.MakeArgString(Flags));
6045 switch (getToolChain().getArch()) {
6049 case llvm::Triple::mips:
6050 case llvm::Triple::mipsel:
6051 case llvm::Triple::mips64:
6052 case llvm::Triple::mips64el:
6053 AddMIPSTargetArgs(Args, CmdArgs);
6062 Args.ClaimAllArgs(options::OPT_W_Group);
6065 getToolChain().getDriver());
6067 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
6069 assert(Output.
isFilename() &&
"Unexpected lipo output.");
6070 CmdArgs.push_back(
"-o");
6073 assert(Input.isFilename() &&
"Invalid input.");
6074 CmdArgs.push_back(Input.getFilename());
6076 const char *Exec = getToolChain().getDriver().getClangProgramPath();
6077 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6082 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6083 getToolChain().getTriple().isOSLinux())
6088 void GnuTool::anchor() {}
6093 const char *LinkingOutput)
const {
6094 const Driver &D = getToolChain().getDriver();
6095 ArgStringList CmdArgs;
6097 for (
const auto &A : Args) {
6106 if (isa<AssembleJobAction>(JA) &&
6107 A->getOption().matches(options::OPT_g_Group))
6111 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
6112 A->getOption().matches(options::OPT_W_Group))
6115 A->render(Args, CmdArgs);
6119 RenderExtraToolArgs(JA, CmdArgs);
6122 if (getToolChain().getTriple().isOSDarwin()) {
6123 CmdArgs.push_back(
"-arch");
6125 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
6133 switch (getToolChain().getArch()) {
6136 case llvm::Triple::x86:
6137 case llvm::Triple::ppc:
6138 CmdArgs.push_back(
"-m32");
6140 case llvm::Triple::x86_64:
6141 case llvm::Triple::ppc64:
6142 case llvm::Triple::ppc64le:
6143 CmdArgs.push_back(
"-m64");
6145 case llvm::Triple::sparcel:
6146 CmdArgs.push_back(
"-EL");
6151 CmdArgs.push_back(
"-o");
6154 assert(Output.
isNothing() &&
"Unexpected output");
6155 CmdArgs.push_back(
"-fsyntax-only");
6158 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6168 for (
const auto &II : Inputs) {
6171 D.
Diag(diag::err_drv_no_linker_llvm_support)
6172 << getToolChain().getTripleString();
6173 else if (II.getType() == types::TY_AST)
6174 D.
Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
6175 else if (II.getType() == types::TY_ModuleFile)
6176 D.
Diag(diag::err_drv_no_module_support)
6177 << getToolChain().getTripleString();
6180 CmdArgs.push_back(
"-x");
6184 if (II.isFilename())
6185 CmdArgs.push_back(II.getFilename());
6187 const Arg &A = II.getInputArg();
6190 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
6191 CmdArgs.push_back(
"-lstdc++");
6196 A.render(Args, CmdArgs);
6201 const char *GCCName;
6202 if (!customGCCName.empty())
6203 GCCName = customGCCName.c_str();
6209 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
6210 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6214 ArgStringList &CmdArgs)
const {
6215 CmdArgs.push_back(
"-E");
6219 ArgStringList &CmdArgs)
const {
6220 const Driver &D = getToolChain().getDriver();
6224 case types::TY_LLVM_IR:
6225 case types::TY_LTO_IR:
6226 case types::TY_LLVM_BC:
6227 case types::TY_LTO_BC:
6228 CmdArgs.push_back(
"-c");
6232 case types::TY_Object:
6233 CmdArgs.push_back(
"-c");
6235 case types::TY_PP_Asm:
6236 CmdArgs.push_back(
"-S");
6238 case types::TY_Nothing:
6239 CmdArgs.push_back(
"-fsyntax-only");
6247 ArgStringList &CmdArgs)
const {
6253 ArgStringList &CmdArgs)
const {
6259 const ArgList &Args,
6260 const char *LinkingOutput)
const {
6264 const Driver &D = HTC.getDriver();
6265 ArgStringList CmdArgs;
6267 std::string MArchString =
"-march=hexagon";
6268 CmdArgs.push_back(Args.MakeArgString(MArchString));
6270 RenderExtraToolArgs(JA, CmdArgs);
6272 std::string AsName =
"hexagon-llvm-mc";
6273 std::string MCpuString =
"-mcpu=hexagon" +
6275 CmdArgs.push_back(
"-filetype=obj");
6276 CmdArgs.push_back(Args.MakeArgString(MCpuString));
6279 CmdArgs.push_back(
"-o");
6282 assert(Output.
isNothing() &&
"Unexpected output");
6283 CmdArgs.push_back(
"-fsyntax-only");
6287 std::string N = llvm::utostr(G.getValue());
6288 CmdArgs.push_back(Args.MakeArgString(std::string(
"-gpsize=") + N));
6291 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6301 for (
const auto &II : Inputs) {
6304 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
6305 << HTC.getTripleString();
6306 else if (II.getType() == types::TY_AST)
6307 D.
Diag(clang::diag::err_drv_no_ast_support)
6308 << HTC.getTripleString();
6309 else if (II.getType() == types::TY_ModuleFile)
6310 D.
Diag(diag::err_drv_no_module_support)
6311 << HTC.getTripleString();
6313 if (II.isFilename())
6314 CmdArgs.push_back(II.getFilename());
6318 II.getInputArg().render(Args, CmdArgs);
6321 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName.c_str()));
6322 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6326 ArgStringList &CmdArgs)
const {
6333 const ArgList &Args, ArgStringList &CmdArgs,
6334 const char *LinkingOutput) {
6341 bool IsStatic = Args.hasArg(options::OPT_static);
6342 bool IsShared = Args.hasArg(options::OPT_shared);
6343 bool IsPIE = Args.hasArg(options::OPT_pie);
6344 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
6345 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
6346 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
6348 bool UseShared = IsShared && !IsStatic;
6353 Args.ClaimAllArgs(options::OPT_g_Group);
6354 Args.ClaimAllArgs(options::OPT_emit_llvm);
6355 Args.ClaimAllArgs(options::OPT_w);
6357 Args.ClaimAllArgs(options::OPT_static_libgcc);
6362 if (Args.hasArg(options::OPT_s))
6363 CmdArgs.push_back(
"-s");
6365 if (Args.hasArg(options::OPT_r))
6366 CmdArgs.push_back(
"-r");
6369 CmdArgs.push_back(Opt.c_str());
6371 CmdArgs.push_back(
"-march=hexagon");
6372 std::string CpuVer =
6374 std::string MCpuString =
"-mcpu=hexagon" + CpuVer;
6375 CmdArgs.push_back(Args.MakeArgString(MCpuString));
6378 CmdArgs.push_back(
"-shared");
6380 CmdArgs.push_back(
"-call_shared");
6384 CmdArgs.push_back(
"-static");
6386 if (IsPIE && !IsShared)
6387 CmdArgs.push_back(
"-pie");
6390 std::string N = llvm::utostr(G.getValue());
6391 CmdArgs.push_back(Args.MakeArgString(std::string(
"-G") + N));
6392 UseG0 = G.getValue() == 0;
6398 CmdArgs.push_back(
"-o");
6404 std::vector<std::string> OsLibs;
6405 bool HasStandalone =
false;
6407 for (
const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
6409 OsLibs.emplace_back(A->getValue());
6410 HasStandalone = HasStandalone || (OsLibs.back() ==
"standalone");
6412 if (OsLibs.empty()) {
6413 OsLibs.push_back(
"standalone");
6414 HasStandalone =
true;
6420 const std::string MCpuSuffix =
"/" + CpuVer;
6421 const std::string MCpuG0Suffix = MCpuSuffix +
"/G0";
6422 const std::string RootDir =
6424 const std::string StartSubDir =
6425 "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
6427 auto Find = [&HTC] (
const std::string &RootDir,
const std::string &SubDir,
6428 const char *
Name) -> std::string {
6429 std::string RelName = SubDir +
Name;
6431 if (llvm::sys::fs::exists(P))
6433 return RootDir + RelName;
6436 if (IncStdLib && IncStartFiles) {
6438 if (HasStandalone) {
6439 std::string Crt0SA = Find(RootDir, StartSubDir,
"/crt0_standalone.o");
6440 CmdArgs.push_back(Args.MakeArgString(Crt0SA));
6442 std::string Crt0 = Find(RootDir, StartSubDir,
"/crt0.o");
6443 CmdArgs.push_back(Args.MakeArgString(Crt0));
6445 std::string Init = UseShared
6446 ? Find(RootDir, StartSubDir +
"/pic",
"/initS.o")
6447 : Find(RootDir, StartSubDir,
"/init.o");
6448 CmdArgs.push_back(Args.MakeArgString(Init));
6455 for (
const auto &LibPath : LibPaths)
6456 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
6461 Args.AddAllArgs(CmdArgs,
6462 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6463 options::OPT_t, options::OPT_u_Group});
6470 if (IncStdLib && IncDefLibs) {
6473 CmdArgs.push_back(
"-lm");
6476 CmdArgs.push_back(
"--start-group");
6479 for (
const std::string &Lib : OsLibs)
6480 CmdArgs.push_back(Args.MakeArgString(
"-l" + Lib));
6481 CmdArgs.push_back(
"-lc");
6483 CmdArgs.push_back(
"-lgcc");
6485 CmdArgs.push_back(
"--end-group");
6491 if (IncStdLib && IncStartFiles) {
6492 std::string Fini = UseShared
6493 ? Find(RootDir, StartSubDir +
"/pic",
"/finiS.o")
6494 : Find(RootDir, StartSubDir,
"/fini.o");
6495 CmdArgs.push_back(Args.MakeArgString(Fini));
6502 const ArgList &Args,
6503 const char *LinkingOutput)
const {
6506 ArgStringList CmdArgs;
6510 std::string
Linker = HTC.GetProgramPath(
"hexagon-link");
6511 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Linker),
6519 const ArgList &Args,
6520 const char *LinkingOutput)
const {
6522 std::string
Linker = getToolChain().GetProgramPath(getShortName());
6523 ArgStringList CmdArgs;
6525 CmdArgs.push_back(
"-o");
6527 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Linker),
6533 :
GnuTool(
"wasm::Linker",
"lld", TC) {}
6546 const ArgList &Args,
6547 const char *LinkingOutput)
const {
6548 const char *
Linker = Args.MakeArgString(getToolChain().GetLinkerPath());
6549 ArgStringList CmdArgs;
6550 CmdArgs.push_back(
"-flavor");
6551 CmdArgs.push_back(
"ld");
6558 CmdArgs.push_back(
"--gc-sections");
6561 CmdArgs.push_back(
"-o");
6563 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Linker, CmdArgs, Inputs));
6571 MArch = Triple.getArchName();
6572 MArch = StringRef(MArch).split(
"+").first.lower();
6575 if (MArch ==
"native") {
6576 std::string CPU = llvm::sys::getHostCPUName();
6577 if (CPU !=
"generic") {
6585 MArch = std::string(
"arm") + Suffix.str();
6594 std::string MArch =
getARMArch(Arch, Triple);
6602 return Triple.getARMCPUForArch(MArch);
6607 const llvm::Triple &Triple) {
6611 std::string MCPU = StringRef(CPU).split(
"+").first.lower();
6613 if (MCPU ==
"native")
6614 return llvm::sys::getHostCPUName();
6626 const llvm::Triple &Triple) {
6628 if (CPU ==
"generic") {
6630 ArchKind = llvm::ARM::parseArch(ARMArch);
6631 if (ArchKind == llvm::ARM::AK_INVALID)
6634 ArchKind = llvm::ARM::parseCPUArch(Triple.getARMCPUForArch(ARMArch));
6638 ArchKind = (Arch ==
"armv7k" || Arch ==
"thumbv7k")
6639 ? (
unsigned)llvm::ARM::AK_ARMV7K
6640 : llvm::ARM::parseCPUArch(CPU);
6642 if (ArchKind == llvm::ARM::AK_INVALID)
6644 return llvm::ARM::getSubArch(ArchKind);
6648 const llvm::Triple &Triple) {
6649 if (Args.hasArg(options::OPT_r))
6655 CmdArgs.push_back(
"--be8");
6682 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6683 return A && (A->getValue() == StringRef(Value));
6687 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
6688 return A && A->getOption().matches(options::OPT_muclibc);
6691 bool mips::isNaN2008(
const ArgList &Args,
const llvm::Triple &Triple) {
6692 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
6693 return llvm::StringSwitch<bool>(NaNArg->getValue())
6695 .Case(
"legacy",
false)
6699 return llvm::StringSwitch<bool>(
getCPUName(Args, Triple))
6700 .Cases(
"mips32r6",
"mips64r6",
true)
6708 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
6709 Triple.getVendor() != llvm::Triple::MipsTechnologies)
6712 if (ABIName !=
"32")
6720 return llvm::StringSwitch<bool>(CPUName)
6721 .Cases(
"mips2",
"mips3",
"mips4",
"mips5",
true)
6722 .Cases(
"mips32",
"mips32r2",
"mips32r3",
"mips32r5",
true)
6723 .Cases(
"mips64",
"mips64r2",
"mips64r3",
"mips64r5",
true)
6728 StringRef CPUName, StringRef ABIName,
6730 bool UseFPXX =
isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
6733 if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
6734 options::OPT_mdouble_float))
6735 if (A->getOption().matches(options::OPT_msingle_float))
6754 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
6755 .Cases(
"ppc",
"ppc601",
"ppc603",
"ppc604",
"ppc604e", llvm::Triple::ppc)
6756 .Cases(
"ppc750",
"ppc7400",
"ppc7450",
"ppc970", llvm::Triple::ppc)
6757 .Case(
"ppc64", llvm::Triple::ppc64)
6758 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
6759 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
6761 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
6763 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
6764 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
6765 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
6766 .Case(
"arm64", llvm::Triple::aarch64)
6767 .Case(
"r600", llvm::Triple::r600)
6768 .Case(
"amdgcn", llvm::Triple::amdgcn)
6769 .Case(
"nvptx", llvm::Triple::nvptx)
6770 .Case(
"nvptx64", llvm::Triple::nvptx64)
6771 .Case(
"amdil", llvm::Triple::amdil)
6772 .Case(
"spir", llvm::Triple::spir)
6773 .Default(llvm::Triple::UnknownArch);
6780 if (Str ==
"x86_64h")
6782 else if (Str ==
"armv6m" || Str ==
"armv7m" || Str ==
"armv7em") {
6783 T.setOS(llvm::Triple::UnknownOS);
6784 T.setObjectFormat(llvm::Triple::MachO);
6790 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
6795 const char *Str = getBaseInputName(Args, Inputs[0]);
6797 if (
const char *
End = strrchr(Str,
'.'))
6798 return Args.MakeArgString(std::string(Str,
End));
6808 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6809 std::string Str(OutputOpt->getValue());
6810 Res = Str.substr(0, Str.rfind(
'.'));
6812 Res = getBaseInputStem(Args, Inputs);
6814 return Args.MakeArgString(Res +
".d");
6820 const ArgList &Args,
6821 const char *LinkingOutput)
const {
6824 ArgStringList CmdArgs;
6827 Args.ClaimAllArgs(options::OPT_g_Group);
6829 Args.ClaimAllArgs(options::OPT_emit_llvm);
6832 Args.ClaimAllArgs(options::OPT_w);
6835 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
6838 CmdArgs.push_back(
"-Bstatic");
6839 CmdArgs.push_back(
"--eh-frame-hdr");
6840 CmdArgs.push_back(
"--gc-sections");
6843 CmdArgs.push_back(
"-o");
6846 assert(Output.
isNothing() &&
"Invalid output.");
6849 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
6850 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt0.o")));
6851 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtbegin.o")));
6854 Args.AddAllArgs(CmdArgs, options::OPT_L);
6856 Args.AddAllArgs(CmdArgs,
6857 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
6858 options::OPT_t, options::OPT_Z_Flag, options::OPT_r});
6865 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
6868 CmdArgs.push_back(
"-lc");
6869 CmdArgs.push_back(
"-lcompiler_rt");
6872 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
6873 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtend.o")));
6875 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
6876 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6882 const ArgList &Args,
6883 const char *LinkingOutput)
const {
6884 ArgStringList CmdArgs;
6886 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
6890 const Action *SourceAction = &JA;
6892 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
6893 SourceAction = SourceAction->
getInputs()[0];
6901 if (Args.hasArg(options::OPT_fno_integrated_as)) {
6902 const llvm::Triple &T(getToolChain().getTriple());
6903 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
6904 CmdArgs.push_back(
"-Q");
6908 if (SourceAction->
getType() == types::TY_Asm ||
6909 SourceAction->
getType() == types::TY_PP_Asm) {
6910 if (Args.hasArg(options::OPT_gstabs))
6911 CmdArgs.push_back(
"--gstabs");
6912 else if (Args.hasArg(options::OPT_g_Group))
6913 CmdArgs.push_back(
"-g");
6917 AddMachOArch(Args, CmdArgs);
6920 if (getToolChain().getArch() == llvm::Triple::x86 ||
6921 getToolChain().getArch() == llvm::Triple::x86_64 ||
6922 Args.hasArg(options::OPT_force__cpusubtype__ALL))
6923 CmdArgs.push_back(
"-force_cpusubtype_ALL");
6925 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
6926 (((Args.hasArg(options::OPT_mkernel) ||
6927 Args.hasArg(options::OPT_fapple_kext)) &&
6928 getMachOToolChain().isKernelStatic()) ||
6929 Args.hasArg(options::OPT_static)))
6930 CmdArgs.push_back(
"-static");
6932 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6934 assert(Output.
isFilename() &&
"Unexpected lipo output.");
6935 CmdArgs.push_back(
"-o");
6938 assert(Input.isFilename() &&
"Invalid input.");
6939 CmdArgs.push_back(Input.getFilename());
6943 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
6944 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
6947 void darwin::MachOTool::anchor() {}
6950 ArgStringList &CmdArgs)
const {
6951 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
6954 CmdArgs.push_back(
"-arch");
6955 CmdArgs.push_back(Args.MakeArgString(ArchName));
6958 if (ArchName ==
"arm")
6959 CmdArgs.push_back(
"-force_cpusubtype_ALL");
6962 bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
6966 for (
const auto &
Input : Inputs)
6967 if (
Input.getType() != types::TY_Object)
6973 void darwin::Linker::AddLinkArgs(
Compilation &C,
const ArgList &Args,
6974 ArgStringList &CmdArgs,
6976 const Driver &D = getToolChain().getDriver();
6979 unsigned Version[3] = {0, 0, 0};
6980 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6983 Version[2], HadExtra) ||
6985 D.
Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
6990 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6991 CmdArgs.push_back(
"-demangle");
6993 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6994 CmdArgs.push_back(
"-export_dynamic");
6998 if (Args.hasFlag(options::OPT_fapplication_extension,
6999 options::OPT_fno_application_extension,
false))
7000 CmdArgs.push_back(
"-application_extension");
7006 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
7007 const char *TmpPath = C.
getArgs().MakeArgString(
7010 CmdArgs.push_back(
"-object_path_lto");
7011 CmdArgs.push_back(TmpPath);
7017 if (Version[0] >= 133) {
7021 llvm::sys::path::append(LibLTOPath,
"lib");
7022 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
7023 if (llvm::sys::fs::exists(LibLTOPath)) {
7024 CmdArgs.push_back(
"-lto_library");
7025 CmdArgs.push_back(C.
getArgs().MakeArgString(LibLTOPath));
7027 D.
Diag(diag::warn_drv_lto_libpath);
7033 Args.AddAllArgs(CmdArgs, options::OPT_static);
7034 if (!Args.hasArg(options::OPT_static))
7035 CmdArgs.push_back(
"-dynamic");
7036 if (Args.hasArg(options::OPT_fgnu_runtime)) {
7041 if (!Args.hasArg(options::OPT_dynamiclib)) {
7042 AddMachOArch(Args, CmdArgs);
7044 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
7046 Args.AddLastArg(CmdArgs, options::OPT_bundle);
7047 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
7048 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
7051 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
7052 (A = Args.getLastArg(options::OPT_current__version)) ||
7053 (A = Args.getLastArg(options::OPT_install__name)))
7054 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
7057 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
7058 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
7059 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
7061 CmdArgs.push_back(
"-dylib");
7064 if ((A = Args.getLastArg(options::OPT_bundle)) ||
7065 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
7066 (A = Args.getLastArg(options::OPT_client__name)) ||
7067 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
7068 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
7069 (A = Args.getLastArg(options::OPT_private__bundle)))
7070 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
7073 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
7074 "-dylib_compatibility_version");
7075 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
7076 "-dylib_current_version");
7078 AddMachOArch(Args, CmdArgs);
7080 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
7081 "-dylib_install_name");
7084 Args.AddLastArg(CmdArgs, options::OPT_all__load);
7085 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
7086 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
7088 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
7089 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
7090 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
7091 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
7092 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
7093 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
7094 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
7095 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
7096 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
7097 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
7098 Args.AddAllArgs(CmdArgs, options::OPT_init);
7103 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
7104 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
7105 Args.AddLastArg(CmdArgs, options::OPT_single__module);
7106 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
7107 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
7110 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
7111 options::OPT_fno_pie, options::OPT_fno_PIE)) {
7112 if (A->getOption().matches(options::OPT_fpie) ||
7113 A->getOption().matches(options::OPT_fPIE))
7114 CmdArgs.push_back(
"-pie");
7116 CmdArgs.push_back(
"-no_pie");
7119 Args.AddLastArg(CmdArgs, options::OPT_prebind);
7120 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
7121 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
7122 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
7123 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
7124 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
7125 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
7126 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
7127 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
7128 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
7129 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
7130 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
7131 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
7132 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
7133 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
7134 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
7139 if (sysroot !=
"") {
7140 CmdArgs.push_back(
"-syslibroot");
7141 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
7142 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
7143 CmdArgs.push_back(
"-syslibroot");
7144 CmdArgs.push_back(A->getValue());
7147 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
7148 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
7149 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
7150 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
7151 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
7152 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
7153 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
7154 Args.AddAllArgs(CmdArgs, options::OPT_y);
7155 Args.AddLastArg(CmdArgs, options::OPT_w);
7156 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
7157 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
7158 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
7159 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
7160 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
7161 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
7162 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
7163 Args.AddLastArg(CmdArgs, options::OPT_whyload);
7164 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
7165 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
7166 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
7167 Args.AddLastArg(CmdArgs, options::OPT_Mach);
7173 const ArgList &Args,
7174 const char *LinkingOutput)
const {
7175 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
7181 llvm::opt::ArgStringList InputFileList;
7186 ArgStringList CmdArgs;
7189 if (Args.hasArg(options::OPT_ccc_arcmt_check,
7190 options::OPT_ccc_arcmt_migrate)) {
7191 for (
const auto &Arg : Args)
7194 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
7196 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs,
None));
7202 AddLinkArgs(C, Args, CmdArgs, Inputs);
7206 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
7207 options::OPT_Z_Flag, options::OPT_u_Group,
7208 options::OPT_e, options::OPT_r});
7213 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
7214 CmdArgs.push_back(
"-ObjC");
7216 CmdArgs.push_back(
"-o");
7219 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
7220 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
7225 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
7226 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
7227 "libclang_rt.safestack_osx.a",
7231 Args.AddAllArgs(CmdArgs, options::OPT_L);
7236 for (
const auto &II : Inputs) {
7237 if (!II.isFilename()) {
7242 if (InputFileList.size() > 0)
7248 InputFileList.push_back(II.getFilename());
7251 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
7255 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
7257 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
7259 CmdArgs.push_back(
"-framework");
7260 CmdArgs.push_back(
"Foundation");
7262 CmdArgs.push_back(
"-lobjc");
7265 if (LinkingOutput) {
7266 CmdArgs.push_back(
"-arch_multiple");
7267 CmdArgs.push_back(
"-final_output");
7268 CmdArgs.push_back(LinkingOutput);
7271 if (Args.hasArg(options::OPT_fnested_functions))
7272 CmdArgs.push_back(
"-allow_stack_execute");
7274 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
7276 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
7277 if (getToolChain().getDriver().CCCIsCXX())
7278 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7283 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
7286 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7290 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7291 Args.AddAllArgs(CmdArgs, options::OPT_F);
7294 for (
const Arg *A : Args.filtered(options::OPT_iframework))
7295 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
7297 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
7298 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
7299 if (A->getValue() == StringRef(
"Accelerate")) {
7300 CmdArgs.push_back(
"-framework");
7301 CmdArgs.push_back(
"Accelerate");
7306 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7307 std::unique_ptr<Command> Cmd =
7308 llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs);
7309 Cmd->setInputFileList(std::move(InputFileList));
7316 const ArgList &Args,
7317 const char *LinkingOutput)
const {
7318 ArgStringList CmdArgs;
7320 CmdArgs.push_back(
"-create");
7321 assert(Output.
isFilename() &&
"Unexpected lipo output.");
7323 CmdArgs.push_back(
"-output");
7326 for (
const auto &II : Inputs) {
7327 assert(II.isFilename() &&
"Unexpected lipo input.");
7328 CmdArgs.push_back(II.getFilename());
7331 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
7332 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7338 const ArgList &Args,
7339 const char *LinkingOutput)
const {
7340 ArgStringList CmdArgs;
7342 CmdArgs.push_back(
"-o");
7345 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
7347 assert(Input.isFilename() &&
"Unexpected dsymutil input.");
7348 CmdArgs.push_back(Input.getFilename());
7351 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
7352 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7358 const ArgList &Args,
7359 const char *LinkingOutput)
const {
7360 ArgStringList CmdArgs;
7361 CmdArgs.push_back(
"--verify");
7362 CmdArgs.push_back(
"--debug-info");
7363 CmdArgs.push_back(
"--eh-frame");
7364 CmdArgs.push_back(
"--quiet");
7366 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
7368 assert(Input.isFilename() &&
"Unexpected verify input");
7371 CmdArgs.push_back(Input.getFilename());
7374 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
7375 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7381 const ArgList &Args,
7382 const char *LinkingOutput)
const {
7384 ArgStringList CmdArgs;
7386 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7388 CmdArgs.push_back(
"-o");
7391 for (
const auto &II : Inputs)
7392 CmdArgs.push_back(II.getFilename());
7394 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7395 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7401 const ArgList &Args,
7402 const char *LinkingOutput)
const {
7403 ArgStringList CmdArgs;
7406 CmdArgs.push_back(
"-C");
7408 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
7409 CmdArgs.push_back(
"-e");
7410 CmdArgs.push_back(
"_start");
7413 if (Args.hasArg(options::OPT_static)) {
7414 CmdArgs.push_back(
"-Bstatic");
7415 CmdArgs.push_back(
"-dn");
7417 CmdArgs.push_back(
"-Bdynamic");
7418 if (Args.hasArg(options::OPT_shared)) {
7419 CmdArgs.push_back(
"-shared");
7421 CmdArgs.push_back(
"--dynamic-linker");
7423 Args.MakeArgString(getToolChain().GetFilePath(
"ld.so.1")));
7428 CmdArgs.push_back(
"-o");
7431 assert(Output.
isNothing() &&
"Invalid output.");
7434 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7435 if (!Args.hasArg(options::OPT_shared))
7437 Args.MakeArgString(getToolChain().GetFilePath(
"crt1.o")));
7439 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
7441 Args.MakeArgString(getToolChain().GetFilePath(
"values-Xa.o")));
7443 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
7446 getToolChain().AddFilePathLibArgs(Args, CmdArgs);
7448 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7449 options::OPT_e, options::OPT_r});
7453 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
7454 if (getToolChain().getDriver().CCCIsCXX())
7455 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7456 CmdArgs.push_back(
"-lgcc_s");
7457 CmdArgs.push_back(
"-lc");
7458 if (!Args.hasArg(options::OPT_shared)) {
7459 CmdArgs.push_back(
"-lgcc");
7460 CmdArgs.push_back(
"-lm");
7464 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7466 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
7468 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
7470 getToolChain().addProfileRTLibs(Args, CmdArgs);
7472 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7473 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7479 const ArgList &Args,
7480 const char *LinkingOutput)
const {
7482 ArgStringList CmdArgs;
7484 switch (getToolChain().getArch()) {
7485 case llvm::Triple::x86:
7488 CmdArgs.push_back(
"--32");
7491 case llvm::Triple::ppc:
7492 CmdArgs.push_back(
"-mppc");
7493 CmdArgs.push_back(
"-many");
7496 case llvm::Triple::sparc:
7497 case llvm::Triple::sparcel: {
7498 CmdArgs.push_back(
"-32");
7499 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
7505 case llvm::Triple::sparcv9: {
7506 CmdArgs.push_back(
"-64");
7507 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
7513 case llvm::Triple::mips64:
7514 case llvm::Triple::mips64el: {
7519 CmdArgs.push_back(
"-mabi");
7522 if (getToolChain().getArch() == llvm::Triple::mips64)
7523 CmdArgs.push_back(
"-EB");
7525 CmdArgs.push_back(
"-EL");
7535 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7537 CmdArgs.push_back(
"-o");
7540 for (
const auto &II : Inputs)
7541 CmdArgs.push_back(II.getFilename());
7543 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7544 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7550 const ArgList &Args,
7551 const char *LinkingOutput)
const {
7552 const Driver &D = getToolChain().getDriver();
7553 ArgStringList CmdArgs;
7556 Args.ClaimAllArgs(options::OPT_g_Group);
7558 Args.ClaimAllArgs(options::OPT_emit_llvm);
7561 Args.ClaimAllArgs(options::OPT_w);
7563 if (getToolChain().getArch() == llvm::Triple::mips64)
7564 CmdArgs.push_back(
"-EB");
7565 else if (getToolChain().getArch() == llvm::Triple::mips64el)
7566 CmdArgs.push_back(
"-EL");
7568 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
7569 CmdArgs.push_back(
"-e");
7570 CmdArgs.push_back(
"__start");
7573 if (Args.hasArg(options::OPT_static)) {
7574 CmdArgs.push_back(
"-Bstatic");
7576 if (Args.hasArg(options::OPT_rdynamic))
7577 CmdArgs.push_back(
"-export-dynamic");
7578 CmdArgs.push_back(
"--eh-frame-hdr");
7579 CmdArgs.push_back(
"-Bdynamic");
7580 if (Args.hasArg(options::OPT_shared)) {
7581 CmdArgs.push_back(
"-shared");
7583 CmdArgs.push_back(
"-dynamic-linker");
7584 CmdArgs.push_back(
"/usr/libexec/ld.so");
7588 if (Args.hasArg(options::OPT_nopie))
7589 CmdArgs.push_back(
"-nopie");
7592 CmdArgs.push_back(
"-o");
7595 assert(Output.
isNothing() &&
"Invalid output.");
7598 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7599 if (!Args.hasArg(options::OPT_shared)) {
7600 if (Args.hasArg(options::OPT_pg))
7602 Args.MakeArgString(getToolChain().GetFilePath(
"gcrt0.o")));
7605 Args.MakeArgString(getToolChain().GetFilePath(
"crt0.o")));
7607 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
7610 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
7614 std::string Triple = getToolChain().getTripleString();
7615 if (Triple.substr(0, 6) ==
"x86_64")
7616 Triple.replace(0, 6,
"amd64");
7618 Args.MakeArgString(
"-L/usr/lib/gcc-lib/" + Triple +
"/4.2.1"));
7620 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
7621 options::OPT_e, options::OPT_s, options::OPT_t,
7622 options::OPT_Z_Flag, options::OPT_r});
7626 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
7628 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7629 if (Args.hasArg(options::OPT_pg))
7630 CmdArgs.push_back(
"-lm_p");
7632 CmdArgs.push_back(
"-lm");
7637 CmdArgs.push_back(
"-lgcc");
7639 if (Args.hasArg(options::OPT_pthread)) {
7640 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
7641 CmdArgs.push_back(
"-lpthread_p");
7643 CmdArgs.push_back(
"-lpthread");
7646 if (!Args.hasArg(options::OPT_shared)) {
7647 if (Args.hasArg(options::OPT_pg))
7648 CmdArgs.push_back(
"-lc_p");
7650 CmdArgs.push_back(
"-lc");
7653 CmdArgs.push_back(
"-lgcc");
7656 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7657 if (!Args.hasArg(options::OPT_shared))
7659 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
7662 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
7665 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7666 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7672 const ArgList &Args,
7673 const char *LinkingOutput)
const {
7675 ArgStringList CmdArgs;
7677 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7679 CmdArgs.push_back(
"-o");
7682 for (
const auto &II : Inputs)
7683 CmdArgs.push_back(II.getFilename());
7685 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7686 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7692 const ArgList &Args,
7693 const char *LinkingOutput)
const {
7694 const Driver &D = getToolChain().getDriver();
7695 ArgStringList CmdArgs;
7697 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
7698 CmdArgs.push_back(
"-e");
7699 CmdArgs.push_back(
"__start");
7702 if (Args.hasArg(options::OPT_static)) {
7703 CmdArgs.push_back(
"-Bstatic");
7705 if (Args.hasArg(options::OPT_rdynamic))
7706 CmdArgs.push_back(
"-export-dynamic");
7707 CmdArgs.push_back(
"--eh-frame-hdr");
7708 CmdArgs.push_back(
"-Bdynamic");
7709 if (Args.hasArg(options::OPT_shared)) {
7710 CmdArgs.push_back(
"-shared");
7712 CmdArgs.push_back(
"-dynamic-linker");
7713 CmdArgs.push_back(
"/usr/libexec/ld.so");
7718 CmdArgs.push_back(
"-o");
7721 assert(Output.
isNothing() &&
"Invalid output.");
7724 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7725 if (!Args.hasArg(options::OPT_shared)) {
7726 if (Args.hasArg(options::OPT_pg))
7728 Args.MakeArgString(getToolChain().GetFilePath(
"gcrt0.o")));
7731 Args.MakeArgString(getToolChain().GetFilePath(
"crt0.o")));
7733 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
7736 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
7740 Args.AddAllArgs(CmdArgs,
7741 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
7745 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
7747 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7748 if (Args.hasArg(options::OPT_pg))
7749 CmdArgs.push_back(
"-lm_p");
7751 CmdArgs.push_back(
"-lm");
7754 if (Args.hasArg(options::OPT_pthread)) {
7755 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
7756 CmdArgs.push_back(
"-lpthread_p");
7758 CmdArgs.push_back(
"-lpthread");
7761 if (!Args.hasArg(options::OPT_shared)) {
7762 if (Args.hasArg(options::OPT_pg))
7763 CmdArgs.push_back(
"-lc_p");
7765 CmdArgs.push_back(
"-lc");
7769 switch (getToolChain().getArch()) {
7770 case llvm::Triple::arm:
7773 case llvm::Triple::x86:
7776 case llvm::Triple::x86_64:
7780 llvm_unreachable(
"Unsupported architecture");
7782 CmdArgs.push_back(Args.MakeArgString(
"-lclang_rt." + MyArch));
7785 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7786 if (!Args.hasArg(options::OPT_shared))
7788 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
7791 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
7794 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7795 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7801 const ArgList &Args,
7802 const char *LinkingOutput)
const {
7804 ArgStringList CmdArgs;
7808 switch (getToolChain().getArch()) {
7811 case llvm::Triple::x86:
7812 CmdArgs.push_back(
"--32");
7814 case llvm::Triple::ppc:
7815 CmdArgs.push_back(
"-a32");
7817 case llvm::Triple::mips:
7818 case llvm::Triple::mipsel:
7819 case llvm::Triple::mips64:
7820 case llvm::Triple::mips64el: {
7825 CmdArgs.push_back(
"-march");
7826 CmdArgs.push_back(CPUName.data());
7828 CmdArgs.push_back(
"-mabi");
7831 if (getToolChain().getArch() == llvm::Triple::mips ||
7832 getToolChain().getArch() == llvm::Triple::mips64)
7833 CmdArgs.push_back(
"-EB");
7835 CmdArgs.push_back(
"-EL");
7837 if (Arg *A = Args.getLastArg(options::OPT_G)) {
7838 StringRef v = A->getValue();
7839 CmdArgs.push_back(Args.MakeArgString(
"-G" + v));
7846 case llvm::Triple::arm:
7847 case llvm::Triple::armeb:
7848 case llvm::Triple::thumb:
7849 case llvm::Triple::thumbeb: {
7853 CmdArgs.push_back(
"-mfpu=vfp");
7855 CmdArgs.push_back(
"-mfpu=softvfp");
7857 switch (getToolChain().getTriple().getEnvironment()) {
7858 case llvm::Triple::GNUEABIHF:
7859 case llvm::Triple::GNUEABI:
7860 case llvm::Triple::EABI:
7861 CmdArgs.push_back(
"-meabi=5");
7865 CmdArgs.push_back(
"-matpcs");
7869 case llvm::Triple::sparc:
7870 case llvm::Triple::sparcel:
7871 case llvm::Triple::sparcv9: {
7872 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
7879 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7881 CmdArgs.push_back(
"-o");
7884 for (
const auto &II : Inputs)
7885 CmdArgs.push_back(II.getFilename());
7887 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7888 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
7894 const ArgList &Args,
7895 const char *LinkingOutput)
const {
7899 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
7901 !Args.hasArg(options::OPT_shared) &&
7902 (Args.hasArg(options::OPT_pie) || ToolChain.
isPIEDefault());
7903 ArgStringList CmdArgs;
7906 Args.ClaimAllArgs(options::OPT_g_Group);
7908 Args.ClaimAllArgs(options::OPT_emit_llvm);
7911 Args.ClaimAllArgs(options::OPT_w);
7914 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
7917 CmdArgs.push_back(
"-pie");
7919 if (Args.hasArg(options::OPT_static)) {
7920 CmdArgs.push_back(
"-Bstatic");
7922 if (Args.hasArg(options::OPT_rdynamic))
7923 CmdArgs.push_back(
"-export-dynamic");
7924 CmdArgs.push_back(
"--eh-frame-hdr");
7925 if (Args.hasArg(options::OPT_shared)) {
7926 CmdArgs.push_back(
"-Bshareable");
7928 CmdArgs.push_back(
"-dynamic-linker");
7929 CmdArgs.push_back(
"/libexec/ld-elf.so.1");
7931 if (ToolChain.
getTriple().getOSMajorVersion() >= 9) {
7932 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7933 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7934 CmdArgs.push_back(
"--hash-style=both");
7937 CmdArgs.push_back(
"--enable-new-dtags");
7942 if (Arch == llvm::Triple::x86) {
7943 CmdArgs.push_back(
"-m");
7944 CmdArgs.push_back(
"elf_i386_fbsd");
7947 if (Arch == llvm::Triple::ppc) {
7948 CmdArgs.push_back(
"-m");
7949 CmdArgs.push_back(
"elf32ppc_fbsd");
7952 if (Arg *A = Args.getLastArg(options::OPT_G)) {
7953 if (ToolChain.
getArch() == llvm::Triple::mips ||
7954 ToolChain.
getArch() == llvm::Triple::mipsel ||
7955 ToolChain.
getArch() == llvm::Triple::mips64 ||
7956 ToolChain.
getArch() == llvm::Triple::mips64el) {
7957 StringRef v = A->getValue();
7958 CmdArgs.push_back(Args.MakeArgString(
"-G" + v));
7964 CmdArgs.push_back(
"-o");
7967 assert(Output.
isNothing() &&
"Invalid output.");
7970 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
7971 const char *crt1 =
nullptr;
7972 if (!Args.hasArg(options::OPT_shared)) {
7973 if (Args.hasArg(options::OPT_pg))
7981 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
7983 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
7985 const char *crtbegin =
nullptr;
7986 if (Args.hasArg(options::OPT_static))
7987 crtbegin =
"crtbeginT.o";
7988 else if (Args.hasArg(options::OPT_shared) || IsPIE)
7989 crtbegin =
"crtbeginS.o";
7991 crtbegin =
"crtbegin.o";
7993 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
7996 Args.AddAllArgs(CmdArgs, options::OPT_L);
7998 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7999 Args.AddAllArgs(CmdArgs, options::OPT_e);
8000 Args.AddAllArgs(CmdArgs, options::OPT_s);
8001 Args.AddAllArgs(CmdArgs, options::OPT_t);
8002 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
8003 Args.AddAllArgs(CmdArgs, options::OPT_r);
8011 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
8015 if (Args.hasArg(options::OPT_pg))
8016 CmdArgs.push_back(
"-lm_p");
8018 CmdArgs.push_back(
"-lm");
8020 if (NeedsSanitizerDeps)
8024 if (Args.hasArg(options::OPT_pg))
8025 CmdArgs.push_back(
"-lgcc_p");
8027 CmdArgs.push_back(
"-lgcc");
8028 if (Args.hasArg(options::OPT_static)) {
8029 CmdArgs.push_back(
"-lgcc_eh");
8030 }
else if (Args.hasArg(options::OPT_pg)) {
8031 CmdArgs.push_back(
"-lgcc_eh_p");
8033 CmdArgs.push_back(
"--as-needed");
8034 CmdArgs.push_back(
"-lgcc_s");
8035 CmdArgs.push_back(
"--no-as-needed");
8038 if (Args.hasArg(options::OPT_pthread)) {
8039 if (Args.hasArg(options::OPT_pg))
8040 CmdArgs.push_back(
"-lpthread_p");
8042 CmdArgs.push_back(
"-lpthread");
8045 if (Args.hasArg(options::OPT_pg)) {
8046 if (Args.hasArg(options::OPT_shared))
8047 CmdArgs.push_back(
"-lc");
8049 CmdArgs.push_back(
"-lc_p");
8050 CmdArgs.push_back(
"-lgcc_p");
8052 CmdArgs.push_back(
"-lc");
8053 CmdArgs.push_back(
"-lgcc");
8056 if (Args.hasArg(options::OPT_static)) {
8057 CmdArgs.push_back(
"-lgcc_eh");
8058 }
else if (Args.hasArg(options::OPT_pg)) {
8059 CmdArgs.push_back(
"-lgcc_eh_p");
8061 CmdArgs.push_back(
"--as-needed");
8062 CmdArgs.push_back(
"-lgcc_s");
8063 CmdArgs.push_back(
"--no-as-needed");
8067 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
8068 if (Args.hasArg(options::OPT_shared) || IsPIE)
8069 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtendS.o")));
8071 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtend.o")));
8072 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
8077 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
8078 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
8084 const ArgList &Args,
8085 const char *LinkingOutput)
const {
8087 ArgStringList CmdArgs;
8091 switch (getToolChain().getArch()) {
8092 case llvm::Triple::x86:
8093 CmdArgs.push_back(
"--32");
8095 case llvm::Triple::arm:
8096 case llvm::Triple::armeb:
8097 case llvm::Triple::thumb:
8098 case llvm::Triple::thumbeb: {
8099 StringRef MArch, MCPU;
8103 CmdArgs.push_back(Args.MakeArgString(
"-mcpu=" + Arch));
8107 case llvm::Triple::mips:
8108 case llvm::Triple::mipsel:
8109 case llvm::Triple::mips64:
8110 case llvm::Triple::mips64el: {
8115 CmdArgs.push_back(
"-march");
8116 CmdArgs.push_back(CPUName.data());
8118 CmdArgs.push_back(
"-mabi");
8121 if (getToolChain().getArch() == llvm::Triple::mips ||
8122 getToolChain().getArch() == llvm::Triple::mips64)
8123 CmdArgs.push_back(
"-EB");
8125 CmdArgs.push_back(
"-EL");
8131 case llvm::Triple::sparc:
8132 case llvm::Triple::sparcel: {
8133 CmdArgs.push_back(
"-32");
8134 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
8140 case llvm::Triple::sparcv9: {
8141 CmdArgs.push_back(
"-64");
8142 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
8152 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8154 CmdArgs.push_back(
"-o");
8157 for (
const auto &II : Inputs)
8158 CmdArgs.push_back(II.getFilename());
8160 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath(
"as")));
8161 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
8167 const ArgList &Args,
8168 const char *LinkingOutput)
const {
8169 const Driver &D = getToolChain().getDriver();
8170 ArgStringList CmdArgs;
8173 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
8175 CmdArgs.push_back(
"--eh-frame-hdr");
8176 if (Args.hasArg(options::OPT_static)) {
8177 CmdArgs.push_back(
"-Bstatic");
8179 if (Args.hasArg(options::OPT_rdynamic))
8180 CmdArgs.push_back(
"-export-dynamic");
8181 if (Args.hasArg(options::OPT_shared)) {
8182 CmdArgs.push_back(
"-Bshareable");
8184 CmdArgs.push_back(
"-dynamic-linker");
8185 CmdArgs.push_back(
"/libexec/ld.elf_so");
8191 switch (getToolChain().getArch()) {
8192 case llvm::Triple::x86:
8193 CmdArgs.push_back(
"-m");
8194 CmdArgs.push_back(
"elf_i386");
8196 case llvm::Triple::arm:
8197 case llvm::Triple::thumb:
8198 CmdArgs.push_back(
"-m");
8199 switch (getToolChain().getTriple().getEnvironment()) {
8200 case llvm::Triple::EABI:
8201 case llvm::Triple::GNUEABI:
8202 CmdArgs.push_back(
"armelf_nbsd_eabi");
8204 case llvm::Triple::EABIHF:
8205 case llvm::Triple::GNUEABIHF:
8206 CmdArgs.push_back(
"armelf_nbsd_eabihf");
8209 CmdArgs.push_back(
"armelf_nbsd");
8213 case llvm::Triple::armeb:
8214 case llvm::Triple::thumbeb:
8217 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
8218 CmdArgs.push_back(
"-m");
8219 switch (getToolChain().getTriple().getEnvironment()) {
8220 case llvm::Triple::EABI:
8221 case llvm::Triple::GNUEABI:
8222 CmdArgs.push_back(
"armelfb_nbsd_eabi");
8224 case llvm::Triple::EABIHF:
8225 case llvm::Triple::GNUEABIHF:
8226 CmdArgs.push_back(
"armelfb_nbsd_eabihf");
8229 CmdArgs.push_back(
"armelfb_nbsd");
8233 case llvm::Triple::mips64:
8234 case llvm::Triple::mips64el:
8236 CmdArgs.push_back(
"-m");
8237 if (getToolChain().getArch() == llvm::Triple::mips64)
8238 CmdArgs.push_back(
"elf32btsmip");
8240 CmdArgs.push_back(
"elf32ltsmip");
8242 CmdArgs.push_back(
"-m");
8243 if (getToolChain().getArch() == llvm::Triple::mips64)
8244 CmdArgs.push_back(
"elf64btsmip");
8246 CmdArgs.push_back(
"elf64ltsmip");
8249 case llvm::Triple::ppc:
8250 CmdArgs.push_back(
"-m");
8251 CmdArgs.push_back(
"elf32ppc_nbsd");
8254 case llvm::Triple::ppc64:
8255 case llvm::Triple::ppc64le:
8256 CmdArgs.push_back(
"-m");
8257 CmdArgs.push_back(
"elf64ppc");
8260 case llvm::Triple::sparc:
8261 CmdArgs.push_back(
"-m");
8262 CmdArgs.push_back(
"elf32_sparc");
8265 case llvm::Triple::sparcv9:
8266 CmdArgs.push_back(
"-m");
8267 CmdArgs.push_back(
"elf64_sparc");
8275 CmdArgs.push_back(
"-o");
8278 assert(Output.
isNothing() &&
"Invalid output.");
8281 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
8282 if (!Args.hasArg(options::OPT_shared)) {
8284 Args.MakeArgString(getToolChain().GetFilePath(
"crt0.o")));
8286 Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
8288 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
8291 Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
8293 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
8297 Args.AddAllArgs(CmdArgs, options::OPT_L);
8298 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8299 Args.AddAllArgs(CmdArgs, options::OPT_e);
8300 Args.AddAllArgs(CmdArgs, options::OPT_s);
8301 Args.AddAllArgs(CmdArgs, options::OPT_t);
8302 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
8303 Args.AddAllArgs(CmdArgs, options::OPT_r);
8307 unsigned Major, Minor, Micro;
8308 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
8309 bool useLibgcc =
true;
8310 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
8311 switch (getToolChain().getArch()) {
8312 case llvm::Triple::aarch64:
8313 case llvm::Triple::arm:
8314 case llvm::Triple::armeb:
8315 case llvm::Triple::thumb:
8316 case llvm::Triple::thumbeb:
8317 case llvm::Triple::ppc:
8318 case llvm::Triple::ppc64:
8319 case llvm::Triple::ppc64le:
8320 case llvm::Triple::sparc:
8321 case llvm::Triple::sparcv9:
8322 case llvm::Triple::x86:
8323 case llvm::Triple::x86_64:
8331 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
8334 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8335 CmdArgs.push_back(
"-lm");
8337 if (Args.hasArg(options::OPT_pthread))
8338 CmdArgs.push_back(
"-lpthread");
8339 CmdArgs.push_back(
"-lc");
8342 if (Args.hasArg(options::OPT_static)) {
8346 CmdArgs.push_back(
"-lgcc_eh");
8347 CmdArgs.push_back(
"-lc");
8348 CmdArgs.push_back(
"-lgcc");
8350 CmdArgs.push_back(
"-lgcc");
8351 CmdArgs.push_back(
"--as-needed");
8352 CmdArgs.push_back(
"-lgcc_s");
8353 CmdArgs.push_back(
"--no-as-needed");
8358 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
8359 if (!Args.hasArg(options::OPT_shared))
8361 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
8364 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
8365 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
8368 getToolChain().addProfileRTLibs(Args, CmdArgs);
8370 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
8371 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
8377 const ArgList &Args,
8378 const char *LinkingOutput)
const {
8381 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8382 llvm::Triple Triple = llvm::Triple(TripleStr);
8384 ArgStringList CmdArgs;
8386 llvm::Reloc::Model RelocationModel;
8389 std::tie(RelocationModel, PICLevel, IsPIE) =
8392 switch (getToolChain().getArch()) {
8397 case llvm::Triple::x86:
8398 CmdArgs.push_back(
"--32");
8400 case llvm::Triple::x86_64:
8401 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
8402 CmdArgs.push_back(
"--x32");
8404 CmdArgs.push_back(
"--64");
8406 case llvm::Triple::ppc:
8407 CmdArgs.push_back(
"-a32");
8408 CmdArgs.push_back(
"-mppc");
8409 CmdArgs.push_back(
"-many");
8411 case llvm::Triple::ppc64:
8412 CmdArgs.push_back(
"-a64");
8413 CmdArgs.push_back(
"-mppc64");
8414 CmdArgs.push_back(
"-many");
8416 case llvm::Triple::ppc64le:
8417 CmdArgs.push_back(
"-a64");
8418 CmdArgs.push_back(
"-mppc64");
8419 CmdArgs.push_back(
"-many");
8420 CmdArgs.push_back(
"-mlittle-endian");
8422 case llvm::Triple::sparc:
8423 case llvm::Triple::sparcel: {
8424 CmdArgs.push_back(
"-32");
8425 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
8430 case llvm::Triple::sparcv9: {
8431 CmdArgs.push_back(
"-64");
8432 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
8437 case llvm::Triple::arm:
8438 case llvm::Triple::armeb:
8439 case llvm::Triple::thumb:
8440 case llvm::Triple::thumbeb: {
8441 const llvm::Triple &Triple2 = getToolChain().getTriple();
8442 switch (Triple2.getSubArch()) {
8443 case llvm::Triple::ARMSubArch_v7:
8444 CmdArgs.push_back(
"-mfpu=neon");
8446 case llvm::Triple::ARMSubArch_v8:
8447 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
8456 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
8459 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
8462 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
8466 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
8472 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
8473 StringRef(A->getValue()).lower() ==
"krait")
8474 CmdArgs.push_back(
"-march=armv7-a");
8476 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
8477 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
8480 case llvm::Triple::mips:
8481 case llvm::Triple::mipsel:
8482 case llvm::Triple::mips64:
8483 case llvm::Triple::mips64el: {
8489 CmdArgs.push_back(
"-march");
8490 CmdArgs.push_back(CPUName.data());
8492 CmdArgs.push_back(
"-mabi");
8493 CmdArgs.push_back(ABIName.data());
8497 if (RelocationModel == llvm::Reloc::Static)
8498 CmdArgs.push_back(
"-mno-shared");
8502 CmdArgs.push_back(ABIName ==
"64" ?
"-KPIC" :
"-call_nonpic");
8504 if (getToolChain().getArch() == llvm::Triple::mips ||
8505 getToolChain().getArch() == llvm::Triple::mips64)
8506 CmdArgs.push_back(
"-EB");
8508 CmdArgs.push_back(
"-EL");
8510 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
8511 if (StringRef(A->getValue()) ==
"2008")
8512 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
8516 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
8517 options::OPT_mfp64)) {
8519 A->render(Args, CmdArgs);
8521 Args, getToolChain().getTriple(), CPUName, ABIName,
8523 CmdArgs.push_back(
"-mfpxx");
8528 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
8529 if (A->getOption().matches(options::OPT_mips16)) {
8531 A->render(Args, CmdArgs);
8534 CmdArgs.push_back(
"-no-mips16");
8538 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
8539 options::OPT_mno_micromips);
8540 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
8541 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
8543 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
8546 if (A->getOption().matches(options::OPT_mmsa))
8547 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
8550 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
8551 options::OPT_msoft_float);
8553 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
8554 options::OPT_msingle_float);
8556 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
8557 options::OPT_mno_odd_spreg);
8562 case llvm::Triple::systemz: {
8566 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
8571 Args.AddAllArgs(CmdArgs, options::OPT_I);
8572 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8574 CmdArgs.push_back(
"-o");
8577 for (
const auto &II : Inputs)
8578 CmdArgs.push_back(II.getFilename());
8580 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
8581 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
8586 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
8587 getToolChain().getTriple().isOSLinux())
8593 ArgStringList &CmdArgs,
const ArgList &Args) {
8594 bool isAndroid = Triple.isAndroid();
8595 bool isCygMing = Triple.isOSCygMing();
8596 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
8597 Args.hasArg(options::OPT_static);
8599 CmdArgs.push_back(
"-lgcc");
8601 if (StaticLibgcc || isAndroid) {
8603 CmdArgs.push_back(
"-lgcc");
8606 CmdArgs.push_back(
"--as-needed");
8607 CmdArgs.push_back(
"-lgcc_s");
8609 CmdArgs.push_back(
"--no-as-needed");
8612 if (StaticLibgcc && !isAndroid)
8613 CmdArgs.push_back(
"-lgcc_eh");
8614 else if (!Args.hasArg(options::OPT_shared) && D.
CCCIsCXX())
8615 CmdArgs.push_back(
"-lgcc");
8622 if (isAndroid && !StaticLibgcc)
8623 CmdArgs.push_back(
"-ldl");
8628 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
8630 if (ToolChain.
getTriple().isAndroid()) {
8631 if (ToolChain.
getTriple().isArch64Bit())
8632 return "/system/bin/linker64";
8634 return "/system/bin/linker";
8635 }
else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
8636 Arch == llvm::Triple::sparcel)
8637 return "/lib/ld-linux.so.2";
8638 else if (Arch == llvm::Triple::aarch64)
8639 return "/lib/ld-linux-aarch64.so.1";
8640 else if (Arch == llvm::Triple::aarch64_be)
8641 return "/lib/ld-linux-aarch64_be.so.1";
8642 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
8643 if (ToolChain.
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
8645 return "/lib/ld-linux-armhf.so.3";
8647 return "/lib/ld-linux.so.3";
8648 }
else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
8650 if (ToolChain.
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
8652 return "/lib/ld-linux-armhf.so.3";
8654 return "/lib/ld-linux.so.3";
8655 }
else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
8656 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
8657 std::string LibDir =
8662 LibName = IsNaN2008 ?
"ld-uClibc-mipsn8.so.0" :
"ld-uClibc.so.0";
8663 else if (!ToolChain.
getTriple().hasEnvironment()) {
8664 bool LE = (ToolChain.
getTriple().getArch() == llvm::Triple::mipsel) ||
8665 (ToolChain.
getTriple().getArch() == llvm::Triple::mips64el);
8666 LibName = LE ?
"ld-musl-mipsel.so.1" :
"ld-musl-mips.so.1";
8668 LibName = IsNaN2008 ?
"ld-linux-mipsn8.so.1" :
"ld.so.1";
8670 return (LibDir +
"/" + LibName).str();
8671 }
else if (Arch == llvm::Triple::ppc)
8672 return "/lib/ld.so.1";
8673 else if (Arch == llvm::Triple::ppc64) {
8675 return "/lib64/ld64.so.2";
8676 return "/lib64/ld64.so.1";
8677 }
else if (Arch == llvm::Triple::ppc64le) {
8679 return "/lib64/ld64.so.1";
8680 return "/lib64/ld64.so.2";
8681 }
else if (Arch == llvm::Triple::systemz)
8682 return "/lib/ld64.so.1";
8683 else if (Arch == llvm::Triple::sparcv9)
8684 return "/lib64/ld-linux.so.2";
8685 else if (Arch == llvm::Triple::x86_64 &&
8686 ToolChain.
getTriple().getEnvironment() == llvm::Triple::GNUX32)
8687 return "/libx32/ld-linux-x32.so.2";
8689 return "/lib64/ld-linux-x86-64.so.2";
8693 ArgStringList &CmdArgs,
const ArgList &Args) {
8701 llvm_unreachable(
"unsupported OS");
8702 case llvm::Triple::Win32:
8703 case llvm::Triple::Linux:
8714 static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
8715 switch (T.getArch()) {
8716 case llvm::Triple::x86:
8718 case llvm::Triple::aarch64:
8719 return "aarch64linux";
8720 case llvm::Triple::aarch64_be:
8721 return "aarch64_be_linux";
8722 case llvm::Triple::arm:
8723 case llvm::Triple::thumb:
8724 return "armelf_linux_eabi";
8725 case llvm::Triple::armeb:
8726 case llvm::Triple::thumbeb:
8727 return "armebelf_linux_eabi";
8728 case llvm::Triple::ppc:
8729 return "elf32ppclinux";
8730 case llvm::Triple::ppc64:
8732 case llvm::Triple::ppc64le:
8734 case llvm::Triple::sparc:
8735 case llvm::Triple::sparcel:
8736 return "elf32_sparc";
8737 case llvm::Triple::sparcv9:
8738 return "elf64_sparc";
8739 case llvm::Triple::mips:
8740 return "elf32btsmip";
8741 case llvm::Triple::mipsel:
8742 return "elf32ltsmip";
8743 case llvm::Triple::mips64:
8745 return "elf32btsmipn32";
8746 return "elf64btsmip";
8747 case llvm::Triple::mips64el:
8749 return "elf32ltsmipn32";
8750 return "elf64ltsmip";
8751 case llvm::Triple::systemz:
8752 return "elf64_s390";
8753 case llvm::Triple::x86_64:
8754 if (T.getEnvironment() == llvm::Triple::GNUX32)
8755 return "elf32_x86_64";
8756 return "elf_x86_64";
8758 llvm_unreachable(
"Unexpected arch");
8765 const ArgList &Args,
8766 const char *LinkingOutput)
const {
8771 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
8772 llvm::Triple Triple = llvm::Triple(TripleStr);
8774 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
8775 const bool isAndroid = ToolChain.
getTriple().isAndroid();
8777 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
8778 (Args.hasArg(options::OPT_pie) || ToolChain.
isPIEDefault());
8779 const bool HasCRTBeginEndFiles =
8780 ToolChain.
getTriple().hasEnvironment() ||
8781 (ToolChain.
getTriple().getVendor() != llvm::Triple::MipsTechnologies);
8783 ArgStringList CmdArgs;
8786 Args.ClaimAllArgs(options::OPT_g_Group);
8788 Args.ClaimAllArgs(options::OPT_emit_llvm);
8791 Args.ClaimAllArgs(options::OPT_w);
8793 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
8794 if (llvm::sys::path::filename(Exec) ==
"lld") {
8795 CmdArgs.push_back(
"-flavor");
8796 CmdArgs.push_back(
"old-gnu");
8797 CmdArgs.push_back(
"-target");
8798 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
8802 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
8805 CmdArgs.push_back(
"-pie");
8807 if (Args.hasArg(options::OPT_rdynamic))
8808 CmdArgs.push_back(
"-export-dynamic");
8810 if (Args.hasArg(options::OPT_s))
8811 CmdArgs.push_back(
"-s");
8813 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
8816 for (
const auto &Opt : ToolChain.
ExtraOpts)
8817 CmdArgs.push_back(Opt.c_str());
8819 if (!Args.hasArg(options::OPT_static)) {
8820 CmdArgs.push_back(
"--eh-frame-hdr");
8823 CmdArgs.push_back(
"-m");
8826 if (Args.hasArg(options::OPT_static)) {
8827 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8828 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
8829 CmdArgs.push_back(
"-Bstatic");
8831 CmdArgs.push_back(
"-static");
8832 }
else if (Args.hasArg(options::OPT_shared)) {
8833 CmdArgs.push_back(
"-shared");
8836 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8837 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
8838 (!Args.hasArg(options::OPT_static) &&
8839 !Args.hasArg(options::OPT_shared))) {
8840 CmdArgs.push_back(
"-dynamic-linker");
8841 CmdArgs.push_back(Args.MakeArgString(
8845 CmdArgs.push_back(
"-o");
8848 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
8850 const char *crt1 =
nullptr;
8851 if (!Args.hasArg(options::OPT_shared)) {
8852 if (Args.hasArg(options::OPT_pg))
8860 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
8862 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
8865 const char *crtbegin;
8866 if (Args.hasArg(options::OPT_static))
8867 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
8868 else if (Args.hasArg(options::OPT_shared))
8869 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
8871 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
8873 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
8875 if (HasCRTBeginEndFiles)
8876 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
8882 Args.AddAllArgs(CmdArgs, options::OPT_L);
8883 Args.AddAllArgs(CmdArgs, options::OPT_u);
8890 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8891 CmdArgs.push_back(
"--no-demangle");
8896 getToolChain().addProfileRTLibs(Args, CmdArgs);
8899 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
8900 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8901 !Args.hasArg(options::OPT_static);
8902 if (OnlyLibstdcxxStatic)
8903 CmdArgs.push_back(
"-Bstatic");
8905 if (OnlyLibstdcxxStatic)
8906 CmdArgs.push_back(
"-Bdynamic");
8907 CmdArgs.push_back(
"-lm");
8910 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
8912 if (!Args.hasArg(options::OPT_nostdlib)) {
8913 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8914 if (Args.hasArg(options::OPT_static))
8915 CmdArgs.push_back(
"--start-group");
8917 if (NeedsSanitizerDeps)
8920 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8921 Args.hasArg(options::OPT_pthreads);
8923 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8924 options::OPT_fno_openmp,
false)) {
8932 CmdArgs.push_back(
"-lomp");
8935 CmdArgs.push_back(
"-lgomp");
8939 CmdArgs.push_back(
"-lrt");
8942 CmdArgs.push_back(
"-liomp5");
8952 if (WantPthread && !isAndroid)
8953 CmdArgs.push_back(
"-lpthread");
8955 CmdArgs.push_back(
"-lc");
8957 if (Args.hasArg(options::OPT_static))
8958 CmdArgs.push_back(
"--end-group");
8963 if (!Args.hasArg(options::OPT_nostartfiles)) {
8965 if (Args.hasArg(options::OPT_shared))
8966 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
8968 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
8970 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
8972 if (HasCRTBeginEndFiles)
8973 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
8975 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
8979 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
8989 const ArgList &Args,
8990 const char *LinkingOutput)
const {
8994 "nacl-arm-macros.s");
8996 NewInputs.push_back(NaClMacros);
8997 NewInputs.append(Inputs.begin(), Inputs.end());
9009 const ArgList &Args,
9010 const char *LinkingOutput)
const {
9015 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
9016 const bool IsStatic =
9017 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
9019 ArgStringList CmdArgs;
9022 Args.ClaimAllArgs(options::OPT_g_Group);
9024 Args.ClaimAllArgs(options::OPT_emit_llvm);
9027 Args.ClaimAllArgs(options::OPT_w);
9030 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
9032 if (Args.hasArg(options::OPT_rdynamic))
9033 CmdArgs.push_back(
"-export-dynamic");
9035 if (Args.hasArg(options::OPT_s))
9036 CmdArgs.push_back(
"-s");
9040 CmdArgs.push_back(
"--build-id");
9043 CmdArgs.push_back(
"--eh-frame-hdr");
9045 CmdArgs.push_back(
"-m");
9046 if (Arch == llvm::Triple::x86)
9047 CmdArgs.push_back(
"elf_i386_nacl");
9048 else if (Arch == llvm::Triple::arm)
9049 CmdArgs.push_back(
"armelf_nacl");
9050 else if (Arch == llvm::Triple::x86_64)
9051 CmdArgs.push_back(
"elf_x86_64_nacl");
9052 else if (Arch == llvm::Triple::mipsel)
9053 CmdArgs.push_back(
"mipselelf_nacl");
9059 CmdArgs.push_back(
"-static");
9060 else if (Args.hasArg(options::OPT_shared))
9061 CmdArgs.push_back(
"-shared");
9063 CmdArgs.push_back(
"-o");
9065 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
9066 if (!Args.hasArg(options::OPT_shared))
9067 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt1.o")));
9068 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
9070 const char *crtbegin;
9072 crtbegin =
"crtbeginT.o";
9073 else if (Args.hasArg(options::OPT_shared))
9074 crtbegin =
"crtbeginS.o";
9076 crtbegin =
"crtbegin.o";
9077 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
9080 Args.AddAllArgs(CmdArgs, options::OPT_L);
9081 Args.AddAllArgs(CmdArgs, options::OPT_u);
9085 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
9086 CmdArgs.push_back(
"--no-demangle");
9091 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
9092 bool OnlyLibstdcxxStatic =
9093 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
9094 if (OnlyLibstdcxxStatic)
9095 CmdArgs.push_back(
"-Bstatic");
9097 if (OnlyLibstdcxxStatic)
9098 CmdArgs.push_back(
"-Bdynamic");
9099 CmdArgs.push_back(
"-lm");
9102 if (!Args.hasArg(options::OPT_nostdlib)) {
9103 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9105 CmdArgs.push_back(
"--start-group");
9106 CmdArgs.push_back(
"-lc");
9109 if (Args.hasArg(options::OPT_pthread) ||
9110 Args.hasArg(options::OPT_pthreads) || D.
CCCIsCXX()) {
9115 if (getToolChain().getArch() == llvm::Triple::mipsel)
9116 CmdArgs.push_back(
"-lnacl");
9118 CmdArgs.push_back(
"-lpthread");
9121 CmdArgs.push_back(
"-lgcc");
9122 CmdArgs.push_back(
"--as-needed");
9124 CmdArgs.push_back(
"-lgcc_eh");
9126 CmdArgs.push_back(
"-lgcc_s");
9127 CmdArgs.push_back(
"--no-as-needed");
9132 if (getToolChain().getArch() == llvm::Triple::mipsel)
9133 CmdArgs.push_back(
"-lpnacl_legacy");
9135 CmdArgs.push_back(
"--end-group");
9138 if (!Args.hasArg(options::OPT_nostartfiles)) {
9140 if (Args.hasArg(options::OPT_shared))
9141 crtend =
"crtendS.o";
9143 crtend =
"crtend.o";
9145 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
9146 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
9150 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
9151 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9157 const ArgList &Args,
9158 const char *LinkingOutput)
const {
9160 ArgStringList CmdArgs;
9162 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9164 CmdArgs.push_back(
"-o");
9167 for (
const auto &II : Inputs)
9168 CmdArgs.push_back(II.getFilename());
9170 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
9171 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9177 const ArgList &Args,
9178 const char *LinkingOutput)
const {
9179 const Driver &D = getToolChain().getDriver();
9180 ArgStringList CmdArgs;
9183 CmdArgs.push_back(
"-o");
9186 assert(Output.
isNothing() &&
"Invalid output.");
9189 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
9190 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crt1.o")));
9191 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
9193 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
9194 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
9197 Args.AddAllArgs(CmdArgs,
9198 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
9202 getToolChain().addProfileRTLibs(Args, CmdArgs);
9204 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
9206 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
9207 CmdArgs.push_back(
"-lm");
9211 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
9212 if (Args.hasArg(options::OPT_pthread))
9213 CmdArgs.push_back(
"-lpthread");
9214 CmdArgs.push_back(
"-lc");
9215 CmdArgs.push_back(
"-lCompilerRT-Generic");
9216 CmdArgs.push_back(
"-L/usr/pkg/compiler-rt/lib");
9218 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
9221 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
9222 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9232 const ArgList &Args,
9233 const char *LinkingOutput)
const {
9235 ArgStringList CmdArgs;
9239 if (getToolChain().getArch() == llvm::Triple::x86)
9240 CmdArgs.push_back(
"--32");
9242 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9244 CmdArgs.push_back(
"-o");
9247 for (
const auto &II : Inputs)
9248 CmdArgs.push_back(II.getFilename());
9250 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
9251 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9257 const ArgList &Args,
9258 const char *LinkingOutput)
const {
9259 const Driver &D = getToolChain().getDriver();
9260 ArgStringList CmdArgs;
9263 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
9265 CmdArgs.push_back(
"--eh-frame-hdr");
9266 if (Args.hasArg(options::OPT_static)) {
9267 CmdArgs.push_back(
"-Bstatic");
9269 if (Args.hasArg(options::OPT_rdynamic))
9270 CmdArgs.push_back(
"-export-dynamic");
9271 if (Args.hasArg(options::OPT_shared))
9272 CmdArgs.push_back(
"-Bshareable");
9274 CmdArgs.push_back(
"-dynamic-linker");
9275 CmdArgs.push_back(
"/usr/libexec/ld-elf.so.2");
9277 CmdArgs.push_back(
"--hash-style=gnu");
9278 CmdArgs.push_back(
"--enable-new-dtags");
9283 if (getToolChain().getArch() == llvm::Triple::x86) {
9284 CmdArgs.push_back(
"-m");
9285 CmdArgs.push_back(
"elf_i386");
9289 CmdArgs.push_back(
"-o");
9292 assert(Output.
isNothing() &&
"Invalid output.");
9295 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
9296 if (!Args.hasArg(options::OPT_shared)) {
9297 if (Args.hasArg(options::OPT_pg))
9299 Args.MakeArgString(getToolChain().GetFilePath(
"gcrt1.o")));
9301 if (Args.hasArg(options::OPT_pie))
9303 Args.MakeArgString(getToolChain().GetFilePath(
"Scrt1.o")));
9306 Args.MakeArgString(getToolChain().GetFilePath(
"crt1.o")));
9309 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
9310 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
9312 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
9315 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
9318 Args.AddAllArgs(CmdArgs,
9319 {options::OPT_L, options::OPT_T_Group, options::OPT_e});
9323 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
9324 CmdArgs.push_back(
"-L/usr/lib/gcc50");
9326 if (!Args.hasArg(options::OPT_static)) {
9327 CmdArgs.push_back(
"-rpath");
9328 CmdArgs.push_back(
"/usr/lib/gcc50");
9332 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
9333 CmdArgs.push_back(
"-lm");
9336 if (Args.hasArg(options::OPT_pthread))
9337 CmdArgs.push_back(
"-lpthread");
9339 if (!Args.hasArg(options::OPT_nolibc)) {
9340 CmdArgs.push_back(
"-lc");
9343 if (Args.hasArg(options::OPT_static) ||
9344 Args.hasArg(options::OPT_static_libgcc)) {
9345 CmdArgs.push_back(
"-lgcc");
9346 CmdArgs.push_back(
"-lgcc_eh");
9348 if (Args.hasArg(options::OPT_shared_libgcc)) {
9349 CmdArgs.push_back(
"-lgcc_pic");
9350 if (!Args.hasArg(options::OPT_shared))
9351 CmdArgs.push_back(
"-lgcc");
9353 CmdArgs.push_back(
"-lgcc");
9354 CmdArgs.push_back(
"--as-needed");
9355 CmdArgs.push_back(
"-lgcc_pic");
9356 CmdArgs.push_back(
"--no-as-needed");
9361 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
9362 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
9364 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
9367 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
9368 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
9371 getToolChain().addProfileRTLibs(Args, CmdArgs);
9373 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
9374 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9383 const char *ClangProgramPath) {
9385 std::string visualStudioBinDir;
9386 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
9387 visualStudioBinDir)) {
9389 llvm::sys::path::append(FilePath, Exe);
9390 if (llvm::sys::fs::can_execute(FilePath.c_str()))
9391 return FilePath.str();
9400 const ArgList &Args,
9401 const char *LinkingOutput)
const {
9402 ArgStringList CmdArgs;
9408 Args.MakeArgString(std::string(
"-out:") + Output.
getFilename()));
9410 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
9412 CmdArgs.push_back(
"-defaultlib:libcmt");
9414 if (!llvm::sys::Process::GetEnv(
"LIB")) {
9419 std::string VisualStudioDir;
9421 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
9423 llvm::sys::path::append(LibDir,
"VC",
"lib");
9424 switch (MSVC.getArch()) {
9425 case llvm::Triple::x86:
9428 case llvm::Triple::x86_64:
9429 llvm::sys::path::append(LibDir,
"amd64");
9431 case llvm::Triple::arm:
9432 llvm::sys::path::append(LibDir,
"arm");
9438 Args.MakeArgString(std::string(
"-libpath:") + LibDir.c_str()));
9440 if (MSVC.useUniversalCRT(VisualStudioDir)) {
9441 std::string UniversalCRTLibPath;
9442 if (MSVC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
9443 CmdArgs.push_back(Args.MakeArgString(std::string(
"-libpath:") +
9444 UniversalCRTLibPath.c_str()));
9448 std::string WindowsSdkLibPath;
9449 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
9450 CmdArgs.push_back(Args.MakeArgString(std::string(
"-libpath:") +
9451 WindowsSdkLibPath.c_str()));
9454 CmdArgs.push_back(
"-nologo");
9456 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
9457 CmdArgs.push_back(
"-debug");
9459 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
9460 options::OPT_shared);
9462 CmdArgs.push_back(Args.MakeArgString(
"-dll"));
9465 llvm::sys::path::replace_extension(ImplibName,
"lib");
9466 CmdArgs.push_back(Args.MakeArgString(std::string(
"-implib:") + ImplibName));
9470 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
9471 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
9472 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
9473 for (
const auto &Lib : {
"asan_dynamic",
"asan_dynamic_runtime_thunk"})
9477 CmdArgs.push_back(Args.MakeArgString(
"-include:___asan_seh_interceptor"));
9481 for (
const auto &Lib : {
"asan",
"asan_cxx"})
9486 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
9488 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
9489 options::OPT_fno_openmp,
false)) {
9490 CmdArgs.push_back(
"-nodefaultlib:vcomp.lib");
9491 CmdArgs.push_back(
"-nodefaultlib:vcompd.lib");
9492 CmdArgs.push_back(Args.MakeArgString(std::string(
"-libpath:") +
9496 CmdArgs.push_back(
"-defaultlib:libomp.lib");
9499 CmdArgs.push_back(
"-defaultlib:libiomp5md.lib");
9510 for (
const auto &
Input : Inputs) {
9511 if (
Input.isFilename()) {
9512 CmdArgs.push_back(
Input.getFilename());
9516 const Arg &A =
Input.getInputArg();
9519 if (A.getOption().matches(options::OPT_l)) {
9520 StringRef Lib = A.getValue();
9521 const char *LinkLibArg;
9522 if (Lib.endswith(
".lib"))
9523 LinkLibArg = Args.MakeArgString(Lib);
9525 LinkLibArg = Args.MakeArgString(Lib +
".lib");
9526 CmdArgs.push_back(LinkLibArg);
9532 A.renderAsInput(Args, CmdArgs);
9541 StringRef
Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ,
"link");
9542 if (Linker.equals_lower(
"lld"))
9543 Linker =
"lld-link";
9545 if (Linker.equals_lower(
"link")) {
9553 llvm::sys::path::replace_extension(linkPath,
"exe");
9557 const char *Exec = Args.MakeArgString(linkPath);
9558 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9564 const ArgList &Args,
9565 const char *LinkingOutput)
const {
9566 C.
addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
9572 const char *LinkingOutput)
const {
9573 ArgStringList CmdArgs;
9574 CmdArgs.push_back(
"/nologo");
9575 CmdArgs.push_back(
"/c");
9576 CmdArgs.push_back(
"/W0");
9582 Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
9585 if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
9586 CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ?
"/Oi"
9588 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
9589 if (A->getOption().getID() == options::OPT_O0) {
9590 CmdArgs.push_back(
"/Od");
9592 CmdArgs.push_back(
"/Og");
9594 StringRef OptLevel = A->getValue();
9595 if (OptLevel ==
"s" || OptLevel ==
"z")
9596 CmdArgs.push_back(
"/Os");
9598 CmdArgs.push_back(
"/Ot");
9600 CmdArgs.push_back(
"/Ob2");
9603 if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
9604 options::OPT_fno_omit_frame_pointer))
9605 CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
9608 if (!Args.hasArg(options::OPT_fwritable_strings))
9609 CmdArgs.push_back(
"/GF");
9614 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
9616 CmdArgs.push_back(
"/GR-");
9617 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
9618 options::OPT_fno_function_sections))
9619 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
9622 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
9623 options::OPT_fno_data_sections))
9625 A->getOption().getID() == options::OPT_fdata_sections ?
"/Gw" :
"/Gw-");
9626 if (Args.hasArg(options::OPT_fsyntax_only))
9627 CmdArgs.push_back(
"/Zs");
9628 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
9629 options::OPT__SLASH_Z7))
9630 CmdArgs.push_back(
"/Z7");
9632 std::vector<std::string> Includes =
9633 Args.getAllArgValues(options::OPT_include);
9634 for (
const auto &Include : Includes)
9635 CmdArgs.push_back(Args.MakeArgString(std::string(
"/FI") + Include));
9638 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
9639 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
9640 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
9641 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
9644 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
9645 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
9646 A->render(Args, CmdArgs);
9649 assert(Inputs.size() == 1);
9651 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9652 CmdArgs.push_back(II.getType() == types::TY_C ?
"/Tc" :
"/Tp");
9653 if (II.isFilename())
9654 CmdArgs.push_back(II.getFilename());
9656 II.getInputArg().renderAsInput(Args, CmdArgs);
9659 assert(Output.
getType() == types::TY_Object);
9661 Args.MakeArgString(std::string(
"/Fo") + Output.
getFilename());
9662 CmdArgs.push_back(Fo);
9664 const Driver &D = getToolChain().getDriver();
9667 return llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec),
9675 const ArgList &Args,
9676 const char *LinkingOutput)
const {
9678 ArgStringList CmdArgs;
9680 if (getToolChain().getArch() == llvm::Triple::x86) {
9681 CmdArgs.push_back(
"--32");
9682 }
else if (getToolChain().getArch() == llvm::Triple::x86_64) {
9683 CmdArgs.push_back(
"--64");
9686 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9688 CmdArgs.push_back(
"-o");
9691 for (
const auto &II : Inputs)
9692 CmdArgs.push_back(II.getFilename());
9694 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
9695 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9697 if (Args.hasArg(options::OPT_gsplit_dwarf))
9702 void MinGW::Linker::AddLibGCC(
const ArgList &Args,
9703 ArgStringList &CmdArgs)
const {
9704 if (Args.hasArg(options::OPT_mthreads))
9705 CmdArgs.push_back(
"-lmingwthrd");
9706 CmdArgs.push_back(
"-lmingw32");
9711 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
9712 Args.hasArg(options::OPT_static);
9713 bool Shared = Args.hasArg(options::OPT_shared);
9714 bool CXX = getToolChain().getDriver().CCCIsCXX();
9716 if (Static || (!CXX && !Shared)) {
9717 CmdArgs.push_back(
"-lgcc");
9718 CmdArgs.push_back(
"-lgcc_eh");
9720 CmdArgs.push_back(
"-lgcc_s");
9721 CmdArgs.push_back(
"-lgcc");
9724 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
9727 CmdArgs.push_back(
"-lmoldname");
9728 CmdArgs.push_back(
"-lmingwex");
9729 CmdArgs.push_back(
"-lmsvcrt");
9735 const ArgList &Args,
9736 const char *LinkingOutput)
const {
9741 ArgStringList CmdArgs;
9744 Args.ClaimAllArgs(options::OPT_g_Group);
9746 Args.ClaimAllArgs(options::OPT_emit_llvm);
9749 Args.ClaimAllArgs(options::OPT_w);
9751 StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ,
"ld");
9752 if (LinkerName.equals_lower(
"lld")) {
9753 CmdArgs.push_back(
"-flavor");
9754 CmdArgs.push_back(
"gnu");
9755 }
else if (!LinkerName.equals_lower(
"ld")) {
9756 D.
Diag(diag::err_drv_unsupported_linker) << LinkerName;
9760 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
9762 if (Args.hasArg(options::OPT_s))
9763 CmdArgs.push_back(
"-s");
9765 CmdArgs.push_back(
"-m");
9766 if (TC.
getArch() == llvm::Triple::x86)
9767 CmdArgs.push_back(
"i386pe");
9768 if (TC.
getArch() == llvm::Triple::x86_64)
9769 CmdArgs.push_back(
"i386pep");
9770 if (TC.
getArch() == llvm::Triple::arm)
9771 CmdArgs.push_back(
"thumb2pe");
9773 if (Args.hasArg(options::OPT_mwindows)) {
9774 CmdArgs.push_back(
"--subsystem");
9775 CmdArgs.push_back(
"windows");
9776 }
else if (Args.hasArg(options::OPT_mconsole)) {
9777 CmdArgs.push_back(
"--subsystem");
9778 CmdArgs.push_back(
"console");
9781 if (Args.hasArg(options::OPT_static))
9782 CmdArgs.push_back(
"-Bstatic");
9784 if (Args.hasArg(options::OPT_mdll))
9785 CmdArgs.push_back(
"--dll");
9786 else if (Args.hasArg(options::OPT_shared))
9787 CmdArgs.push_back(
"--shared");
9788 CmdArgs.push_back(
"-Bdynamic");
9789 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
9790 CmdArgs.push_back(
"-e");
9791 if (TC.
getArch() == llvm::Triple::x86)
9792 CmdArgs.push_back(
"_DllMainCRTStartup@12");
9794 CmdArgs.push_back(
"DllMainCRTStartup");
9795 CmdArgs.push_back(
"--enable-auto-image-base");
9799 CmdArgs.push_back(
"-o");
9802 Args.AddAllArgs(CmdArgs, options::OPT_e);
9804 Args.AddLastArg(CmdArgs, options::OPT_r);
9805 Args.AddLastArg(CmdArgs, options::OPT_s);
9806 Args.AddLastArg(CmdArgs, options::OPT_t);
9807 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
9808 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
9810 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
9811 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
9812 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"dllcrt2.o")));
9814 if (Args.hasArg(options::OPT_municode))
9815 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2u.o")));
9817 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2.o")));
9819 if (Args.hasArg(options::OPT_pg))
9820 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"gcrt2.o")));
9821 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtbegin.o")));
9824 Args.AddAllArgs(CmdArgs, options::OPT_L);
9833 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
9834 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
9835 !Args.hasArg(options::OPT_static);
9836 if (OnlyLibstdcxxStatic)
9837 CmdArgs.push_back(
"-Bstatic");
9839 if (OnlyLibstdcxxStatic)
9840 CmdArgs.push_back(
"-Bdynamic");
9843 if (!Args.hasArg(options::OPT_nostdlib)) {
9844 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9845 if (Args.hasArg(options::OPT_static))
9846 CmdArgs.push_back(
"--start-group");
9848 if (Args.hasArg(options::OPT_fstack_protector) ||
9849 Args.hasArg(options::OPT_fstack_protector_strong) ||
9850 Args.hasArg(options::OPT_fstack_protector_all)) {
9851 CmdArgs.push_back(
"-lssp_nonshared");
9852 CmdArgs.push_back(
"-lssp");
9854 if (Args.hasArg(options::OPT_fopenmp))
9855 CmdArgs.push_back(
"-lgomp");
9857 AddLibGCC(Args, CmdArgs);
9859 if (Args.hasArg(options::OPT_pg))
9860 CmdArgs.push_back(
"-lgmon");
9862 if (Args.hasArg(options::OPT_pthread))
9863 CmdArgs.push_back(
"-lpthread");
9866 if (Args.hasArg(options::OPT_mwindows)) {
9867 CmdArgs.push_back(
"-lgdi32");
9868 CmdArgs.push_back(
"-lcomdlg32");
9870 CmdArgs.push_back(
"-ladvapi32");
9871 CmdArgs.push_back(
"-lshell32");
9872 CmdArgs.push_back(
"-luser32");
9873 CmdArgs.push_back(
"-lkernel32");
9875 if (Args.hasArg(options::OPT_static))
9876 CmdArgs.push_back(
"--end-group");
9877 else if (!LinkerName.equals_lower(
"lld"))
9878 AddLibGCC(Args, CmdArgs);
9881 if (!Args.hasArg(options::OPT_nostartfiles)) {
9885 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtend.o")));
9888 const char *Exec = Args.MakeArgString(TC.
GetProgramPath(LinkerName.data()));
9889 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9898 const ArgList &Args,
9899 const char *LinkingOutput)
const {
9901 ArgStringList CmdArgs;
9903 CmdArgs.push_back(
"-o");
9906 CmdArgs.push_back(
"-c");
9908 if (Args.hasArg(options::OPT_v))
9909 CmdArgs.push_back(
"-v");
9911 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
9912 if (!A->getOption().matches(options::OPT_g0))
9913 CmdArgs.push_back(
"-g");
9915 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
9917 CmdArgs.push_back(
"-fverbose-asm");
9919 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9921 for (
const auto &II : Inputs)
9922 CmdArgs.push_back(II.getFilename());
9924 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"xcc"));
9925 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9931 const ArgList &Args,
9932 const char *LinkingOutput)
const {
9933 ArgStringList CmdArgs;
9936 CmdArgs.push_back(
"-o");
9939 assert(Output.
isNothing() &&
"Invalid output.");
9942 if (Args.hasArg(options::OPT_v))
9943 CmdArgs.push_back(
"-v");
9946 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
9948 CmdArgs.push_back(
"-fexceptions");
9952 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"xcc"));
9953 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9959 const ArgList &Args,
9960 const char *LinkingOutput)
const {
9964 ArgStringList CmdArgs;
9969 llvm_unreachable(
"unsupported architecture");
9970 case llvm::Triple::arm:
9971 case llvm::Triple::thumb:
9973 case llvm::Triple::x86:
9974 CmdArgs.push_back(
"--32");
9976 case llvm::Triple::x86_64:
9977 CmdArgs.push_back(
"--64");
9981 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9983 CmdArgs.push_back(
"-o");
9986 for (
const auto &
Input : Inputs)
9987 CmdArgs.push_back(
Input.getFilename());
9990 Exec = Args.MakeArgString(Assembler);
9992 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
9998 const ArgList &Args,
9999 const char *LinkingOutput)
const {
10002 const llvm::Triple &T = TC.
getTriple();
10005 ArgStringList CmdArgs;
10009 Args.ClaimAllArgs(options::OPT_g_Group);
10011 Args.ClaimAllArgs(options::OPT_emit_llvm);
10013 Args.ClaimAllArgs(options::OPT_w);
10017 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
10019 if (Args.hasArg(options::OPT_pie))
10020 CmdArgs.push_back(
"-pie");
10021 if (Args.hasArg(options::OPT_rdynamic))
10022 CmdArgs.push_back(
"-export-dynamic");
10023 if (Args.hasArg(options::OPT_s))
10024 CmdArgs.push_back(
"--strip-all");
10026 CmdArgs.push_back(
"-m");
10029 llvm_unreachable(
"unsupported architecture");
10030 case llvm::Triple::arm:
10031 case llvm::Triple::thumb:
10033 CmdArgs.push_back(
"thumb2pe");
10035 case llvm::Triple::x86:
10036 CmdArgs.push_back(
"i386pe");
10037 EntryPoint.append(
"_");
10039 case llvm::Triple::x86_64:
10040 CmdArgs.push_back(
"i386pep");
10044 if (Args.hasArg(options::OPT_shared)) {
10045 switch (T.getArch()) {
10047 llvm_unreachable(
"unsupported architecture");
10048 case llvm::Triple::arm:
10049 case llvm::Triple::thumb:
10050 case llvm::Triple::x86_64:
10051 EntryPoint.append(
"_DllMainCRTStartup");
10053 case llvm::Triple::x86:
10054 EntryPoint.append(
"_DllMainCRTStartup@12");
10058 CmdArgs.push_back(
"-shared");
10059 CmdArgs.push_back(
"-Bdynamic");
10061 CmdArgs.push_back(
"--enable-auto-image-base");
10063 CmdArgs.push_back(
"--entry");
10064 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
10066 EntryPoint.append(
"mainCRTStartup");
10068 CmdArgs.push_back(Args.hasArg(options::OPT_static) ?
"-Bstatic"
10071 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
10072 CmdArgs.push_back(
"--entry");
10073 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
10080 CmdArgs.push_back(
"--allow-multiple-definition");
10082 CmdArgs.push_back(
"-o");
10085 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
10087 llvm::sys::path::replace_extension(ImpLib,
".lib");
10089 CmdArgs.push_back(
"--out-implib");
10090 CmdArgs.push_back(Args.MakeArgString(ImpLib));
10093 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
10094 const std::string CRTPath(D.
SysRoot +
"/usr/lib/");
10095 const char *CRTBegin;
10098 Args.hasArg(options::OPT_shared) ?
"crtbeginS.obj" :
"crtbegin.obj";
10099 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
10102 Args.AddAllArgs(CmdArgs, options::OPT_L);
10106 if (D.
CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
10107 !Args.hasArg(options::OPT_nodefaultlibs)) {
10108 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
10109 !Args.hasArg(options::OPT_static);
10111 CmdArgs.push_back(
"-Bstatic");
10114 CmdArgs.push_back(
"-Bdynamic");
10117 if (!Args.hasArg(options::OPT_nostdlib)) {
10118 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
10120 CmdArgs.push_back(
"-lmsvcrt");
10127 if (Args.hasArg(options::OPT_shared)) {
10130 for (
const auto &Lib : {
"asan_dynamic",
"asan_dynamic_runtime_thunk"})
10134 CmdArgs.push_back(Args.MakeArgString(
"--undefined"));
10135 CmdArgs.push_back(Args.MakeArgString(TC.
getArch() == llvm::Triple::x86
10136 ?
"___asan_seh_interceptor"
10137 :
"__asan_seh_interceptor"));
10143 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
10149 const ArgList &Args,
10150 const char *LinkingOutput)
const {
10151 ArgStringList CmdArgs;
10152 assert(Inputs.size() == 1);
10154 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX ||
10155 II.getType() == types::TY_PP_CXX);
10158 Args.ClaimAllArgs();
10159 CmdArgs.push_back(
"-E");
10161 assert(Output.
getType() == types::TY_PP_Asm);
10162 CmdArgs.push_back(
"-S");
10163 CmdArgs.push_back(
"-fno-exceptions");
10165 CmdArgs.push_back(
"-mcpu=myriad2");
10166 CmdArgs.push_back(
"-DMYRIAD2");
10171 Args.AddAllArgs(CmdArgs, {options::OPT_I_Group, options::OPT_clang_i_Group,
10172 options::OPT_std_EQ, options::OPT_D, options::OPT_U,
10173 options::OPT_f_Group, options::OPT_f_clang_Group,
10174 options::OPT_g_Group, options::OPT_M_Group,
10175 options::OPT_O_Group, options::OPT_W_Group});
10182 if (Args.getLastArg(options::OPT_MF) && !Args.getLastArg(options::OPT_MT) &&
10185 Arg *A = Args.getLastArg(options::OPT_o);
10187 CmdArgs.push_back(
"-MT");
10188 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
10192 CmdArgs.push_back(II.getFilename());
10193 CmdArgs.push_back(
"-o");
10197 Args.MakeArgString(getToolChain().GetProgramPath(
"moviCompile"));
10198 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec),
10205 const ArgList &Args,
10206 const char *LinkingOutput)
const {
10207 ArgStringList CmdArgs;
10209 assert(Inputs.size() == 1);
10211 assert(II.getType() == types::TY_PP_Asm);
10212 assert(Output.
getType() == types::TY_Object);
10214 CmdArgs.push_back(
"-no6thSlotCompression");
10215 CmdArgs.push_back(
"-cv:myriad2");
10216 CmdArgs.push_back(
"-noSPrefixing");
10217 CmdArgs.push_back(
"-a");
10218 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10219 for (
const Arg *A : Args.filtered(options::OPT_I, options::OPT_isystem)) {
10222 Args.MakeArgString(std::string(
"-i:") + A->getValue(0)));
10224 CmdArgs.push_back(
"-elf");
10225 CmdArgs.push_back(II.getFilename());
10227 Args.MakeArgString(std::string(
"-o:") + Output.
getFilename()));
10230 Args.MakeArgString(getToolChain().GetProgramPath(
"moviAsm"));
10231 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec),
10238 const ArgList &Args,
10239 const char *LinkingOutput)
const {
10242 const llvm::Triple &T = TC.
getTriple();
10243 ArgStringList CmdArgs;
10244 bool UseStartfiles =
10245 !Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles);
10246 bool UseDefaultLibs =
10247 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
10249 if (T.getArch() == llvm::Triple::sparc)
10250 CmdArgs.push_back(
"-EB");
10252 CmdArgs.push_back(
"-EL");
10259 Args.ClaimAllArgs(options::OPT_g_Group);
10260 Args.ClaimAllArgs(options::OPT_w);
10261 Args.ClaimAllArgs(options::OPT_static_libgcc);
10263 if (Args.hasArg(options::OPT_s))
10264 CmdArgs.push_back(
"-s");
10266 CmdArgs.push_back(
"-o");
10269 if (UseStartfiles) {
10272 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crti.o")));
10273 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtbegin.o")));
10276 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
10277 options::OPT_e, options::OPT_s, options::OPT_t,
10278 options::OPT_Z_Flag, options::OPT_r});
10284 if (UseDefaultLibs) {
10286 CmdArgs.push_back(
"-lstdc++");
10287 if (T.getOS() == llvm::Triple::RTEMS) {
10288 CmdArgs.push_back(
"--start-group");
10289 CmdArgs.push_back(
"-lc");
10291 CmdArgs.push_back(
"-lrtemscpu");
10292 CmdArgs.push_back(
"-lrtemsbsp");
10293 CmdArgs.push_back(
"--end-group");
10295 CmdArgs.push_back(
"-lc");
10297 CmdArgs.push_back(
"-lgcc");
10299 if (UseStartfiles) {
10300 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtend.o")));
10301 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtn.o")));
10306 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec),
10313 const ArgList &Args,
10314 const char *LinkingOutput)
const {
10316 ArgStringList CmdArgs;
10318 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
10320 CmdArgs.push_back(
"-o");
10323 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
10325 assert(Input.isFilename() &&
"Invalid input.");
10326 CmdArgs.push_back(Input.getFilename());
10329 Args.MakeArgString(getToolChain().GetProgramPath(
"ps4-as"));
10330 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
10336 CmdArgs.push_back(
"-lSceDbgUBSanitizer_stub_weak");
10339 CmdArgs.push_back(
"-lSceDbgAddressSanitizer_stub_weak");
10346 const ArgList &Args,
10347 const char *LinkingOutput) {
10351 ArgStringList CmdArgs;
10354 Args.ClaimAllArgs(options::OPT_g_Group);
10356 Args.ClaimAllArgs(options::OPT_emit_llvm);
10359 Args.ClaimAllArgs(options::OPT_w);
10362 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
10364 if (Args.hasArg(options::OPT_pie))
10365 CmdArgs.push_back(
"-pie");
10367 if (Args.hasArg(options::OPT_rdynamic))
10368 CmdArgs.push_back(
"-export-dynamic");
10369 if (Args.hasArg(options::OPT_shared))
10370 CmdArgs.push_back(
"--oformat=so");
10373 CmdArgs.push_back(
"-o");
10376 assert(Output.
isNothing() &&
"Invalid output.");
10381 Args.AddAllArgs(CmdArgs, options::OPT_L);
10382 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10383 Args.AddAllArgs(CmdArgs, options::OPT_e);
10384 Args.AddAllArgs(CmdArgs, options::OPT_s);
10385 Args.AddAllArgs(CmdArgs, options::OPT_t);
10386 Args.AddAllArgs(CmdArgs, options::OPT_r);
10388 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10389 CmdArgs.push_back(
"--no-demangle");
10393 if (Args.hasArg(options::OPT_pthread)) {
10394 CmdArgs.push_back(
"-lpthread");
10397 const char *Exec = Args.MakeArgString(ToolChain.
GetProgramPath(
"ps4-ld"));
10399 C.
addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10405 const ArgList &Args,
10406 const char *LinkingOutput) {
10410 ArgStringList CmdArgs;
10413 Args.ClaimAllArgs(options::OPT_g_Group);
10415 Args.ClaimAllArgs(options::OPT_emit_llvm);
10418 Args.ClaimAllArgs(options::OPT_w);
10421 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
10423 if (Args.hasArg(options::OPT_pie))
10424 CmdArgs.push_back(
"-pie");
10426 if (Args.hasArg(options::OPT_static)) {
10427 CmdArgs.push_back(
"-Bstatic");
10429 if (Args.hasArg(options::OPT_rdynamic))
10430 CmdArgs.push_back(
"-export-dynamic");
10431 CmdArgs.push_back(
"--eh-frame-hdr");
10432 if (Args.hasArg(options::OPT_shared)) {
10433 CmdArgs.push_back(
"-Bshareable");
10435 CmdArgs.push_back(
"-dynamic-linker");
10436 CmdArgs.push_back(
"/libexec/ld-elf.so.1");
10438 CmdArgs.push_back(
"--enable-new-dtags");
10442 CmdArgs.push_back(
"-o");
10445 assert(Output.
isNothing() &&
"Invalid output.");
10450 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
10451 const char *crt1 =
nullptr;
10452 if (!Args.hasArg(options::OPT_shared)) {
10453 if (Args.hasArg(options::OPT_pg))
10455 else if (Args.hasArg(options::OPT_pie))
10461 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
10463 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
10465 const char *crtbegin =
nullptr;
10466 if (Args.hasArg(options::OPT_static))
10467 crtbegin =
"crtbeginT.o";
10468 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10469 crtbegin =
"crtbeginS.o";
10471 crtbegin =
"crtbegin.o";
10473 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
10476 Args.AddAllArgs(CmdArgs, options::OPT_L);
10478 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
10479 Args.AddAllArgs(CmdArgs, options::OPT_e);
10480 Args.AddAllArgs(CmdArgs, options::OPT_s);
10481 Args.AddAllArgs(CmdArgs, options::OPT_t);
10482 Args.AddAllArgs(CmdArgs, options::OPT_r);
10484 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
10485 CmdArgs.push_back(
"--no-demangle");
10489 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
10492 CmdArgs.push_back(
"-lkernel");
10495 if (Args.hasArg(options::OPT_pg))
10496 CmdArgs.push_back(
"-lm_p");
10498 CmdArgs.push_back(
"-lm");
10502 if (Args.hasArg(options::OPT_pg))
10503 CmdArgs.push_back(
"-lgcc_p");
10505 CmdArgs.push_back(
"-lcompiler_rt");
10506 if (Args.hasArg(options::OPT_static)) {
10507 CmdArgs.push_back(
"-lstdc++");
10508 }
else if (Args.hasArg(options::OPT_pg)) {
10509 CmdArgs.push_back(
"-lgcc_eh_p");
10511 CmdArgs.push_back(
"--as-needed");
10512 CmdArgs.push_back(
"-lstdc++");
10513 CmdArgs.push_back(
"--no-as-needed");
10516 if (Args.hasArg(options::OPT_pthread)) {
10517 if (Args.hasArg(options::OPT_pg))
10518 CmdArgs.push_back(
"-lpthread_p");
10520 CmdArgs.push_back(
"-lpthread");
10523 if (Args.hasArg(options::OPT_pg)) {
10524 if (Args.hasArg(options::OPT_shared))
10525 CmdArgs.push_back(
"-lc");
10527 if (Args.hasArg(options::OPT_static)) {
10528 CmdArgs.push_back(
"--start-group");
10529 CmdArgs.push_back(
"-lc_p");
10530 CmdArgs.push_back(
"-lpthread_p");
10531 CmdArgs.push_back(
"--end-group");
10533 CmdArgs.push_back(
"-lc_p");
10536 CmdArgs.push_back(
"-lgcc_p");
10538 if (Args.hasArg(options::OPT_static)) {
10539 CmdArgs.push_back(
"--start-group");
10540 CmdArgs.push_back(
"-lc");
10541 CmdArgs.push_back(
"-lpthread");
10542 CmdArgs.push_back(
"--end-group");
10544 CmdArgs.push_back(
"-lc");
10546 CmdArgs.push_back(
"-lcompiler_rt");
10549 if (Args.hasArg(options::OPT_static)) {
10550 CmdArgs.push_back(
"-lstdc++");
10551 }
else if (Args.hasArg(options::OPT_pg)) {
10552 CmdArgs.push_back(
"-lgcc_eh_p");
10554 CmdArgs.push_back(
"--as-needed");
10555 CmdArgs.push_back(
"-lstdc++");
10556 CmdArgs.push_back(
"--no-as-needed");
10560 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
10561 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
10562 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtendS.o")));
10564 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtend.o")));
10565 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
10569 #ifdef LLVM_ON_WIN32
10575 C.
addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
10581 const ArgList &Args,
10582 const char *LinkingOutput)
const {
10587 StringRef LinkerOptName;
10588 if (
const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
10589 LinkerOptName = A->getValue();
10590 if (LinkerOptName !=
"ps4" && LinkerOptName !=
"gold")
10591 D.
Diag(diag::err_drv_unsupported_linker) << LinkerOptName;
10594 if (LinkerOptName ==
"gold")
10596 else if (LinkerOptName ==
"ps4")
10599 PS4Linker = !Args.hasArg(options::OPT_shared);
const Driver & getDriver() const
Represents a version number in the form major[.minor[.subminor[.build]]].
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
unsigned CCPrintHeaders
Set CC_PRINT_HEADERS mode, which causes the frontend to log header include information to CCPrintHead...
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type, or null if unspecified.
unsigned CCCUsePCH
Use lazy precompiled headers for PCH support.
Defines types useful for describing an Objective-C runtime.
std::string GetTemporaryPath(StringRef Prefix, const char *Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
Emit only debug info necessary for generating line number tables (-gline-tables-only).
std::string DyldPrefix
Dynamic loader prefix, if present.
bool canTypeBeUserSpecified(ID Id)
canTypeBeUserSpecified - Can this type be specified on the command line (by the type name); this is u...
bool allowsWeak() const
Does this runtime allow the use of __weak?
DiagnosticBuilder Diag(unsigned DiagID) const
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
static bool GetReleaseVersion(const char *Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
bool needsDfsanRt() const
types::ID getType() const
static StringRef bytes(const std::vector< T, Allocator > &v)
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
std::string Dir
The path the driver executable was in, as invoked from the command line.
Emit location information but do not generate debug info in the output.
ActionClass getKind() const
Action - Represent an abstract compilation step to perform.
std::string getAsString() const
Retrieve a string representation of the version number.
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
const llvm::opt::DerivedArgList & getArgs() const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
const ToolChain * getCudaHostToolChain() const
detail::InMemoryDirectory::const_iterator I
bool isSaveTempsEnabled() const
bool needsSharedAsanRt() const
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed, or INVALID if this input is not preprocessed.
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Defines the clang::LangOptions interface.
StringRef getName() const
Return the actual identifier string.
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
bool isForDiagnostics() const
Return true if we're compiling for diagnostics.
Defines version macros and version-related utility functions for Clang.
bool needsUbsanRt() const
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
void addCommand(std::unique_ptr< Command > C)
'gnustep' is the modern non-fragile GNUstep runtime.
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
const ToolChain * getCudaDeviceToolChain() const
const TemplateArgument * iterator
static LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
bool isCuda(ID Id)
isCuda - Is this a CUDA input.
std::string InstalledDir
The path to the installed clang directory, if any.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
unsigned getMajor() const
Retrieve the major version number.
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
bool needsSafeStackRt() const
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
'#include ""' paths, added by 'gcc -iquote'.
const ToolChain & getDefaultToolChain() const
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
const char * CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
bool tryParse(StringRef string)
Try to parse the given string as a version number.
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
The basic abstraction for the target Objective-C runtime.
std::string SysRoot
sysroot, if present
detail::InMemoryDirectory::const_iterator E
ActionList & getActions()
const char * getClangProgramPath() const
Get the path to the main clang executable.
unsigned Map[Count]
The type of a lookup table which maps from language-specific address spaces to target-specific ones...
bool needsCfiDiagRt() const
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Compilation - A set of tasks to perform for a single driver invocation.
const char * CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
StringRef getSysRoot() const
Returns the sysroot path.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
const char * addFailureResultFile(const char *Name, const JobAction *JA)
addFailureResultFile - Add a file to remove if we crash, and returns its argument.
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
Limit generated debug info to reduce size (-fno-standalone-debug).
std::string getAsString() const
bool isLLVMIR(ID Id)
Is this LLVM IR.
bool linkCXXRuntimes() const
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
std::string ResourceDir
The path to the compiler resource directory.