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/TargetParser.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"
49 using namespace clang::driver;
50 using namespace clang::driver::tools;
51 using namespace clang;
52 using namespace llvm::opt;
55 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
56 options::OPT_fpic, options::OPT_fno_pic,
57 options::OPT_fPIE, options::OPT_fno_PIE,
58 options::OPT_fpie, options::OPT_fno_pie);
61 if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
62 LastPICArg->getOption().matches(options::OPT_fpic) ||
63 LastPICArg->getOption().matches(options::OPT_fPIE) ||
64 LastPICArg->getOption().matches(options::OPT_fpie)) {
65 CmdArgs.push_back(
"-KPIC");
72 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
73 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
74 !Args.hasArg(options::OPT__SLASH_EP) && !D.
CCCIsCPP()) {
75 D.
Diag(diag::err_drv_argument_only_allowed_with)
76 << A->getBaseArg().getAsString(Args)
77 << (D.
IsCLMode() ?
"/E, /P or /EP" :
"-E");
86 if (Args.hasArg(options::OPT_static))
88 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
89 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
114 for (
unsigned i = 0, e = Target.size(); i != e; ++i) {
119 for (
int j = i - 1; j >= 0 && Target[j] ==
'\\'; --j)
135 Res.push_back(Target[i]);
140 const char *ArgName,
const char *EnvVar) {
141 const char *DirList = ::getenv(EnvVar);
142 bool CombinedArg =
false;
147 StringRef Name(ArgName);
148 if (Name.equals(
"-I") || Name.equals(
"-L"))
151 StringRef Dirs(DirList);
155 StringRef::size_type Delim;
156 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
159 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) +
"."));
161 CmdArgs.push_back(ArgName);
162 CmdArgs.push_back(
".");
167 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
169 CmdArgs.push_back(ArgName);
170 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
173 Dirs = Dirs.substr(Delim + 1);
178 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) +
"."));
180 CmdArgs.push_back(ArgName);
181 CmdArgs.push_back(
".");
185 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
187 CmdArgs.push_back(ArgName);
188 CmdArgs.push_back(Args.MakeArgString(Dirs));
194 const ArgList &Args, ArgStringList &CmdArgs) {
199 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
201 for (
const auto &II : Inputs) {
204 if (II.getType() == types::TY_LLVM_IR ||
205 II.getType() == types::TY_LTO_IR ||
206 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
211 if (II.isFilename()) {
212 CmdArgs.push_back(II.getFilename());
217 const Arg &A = II.getInputArg();
220 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
222 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
224 else if (A.getOption().matches(options::OPT_z)) {
227 A.render(Args, CmdArgs);
229 A.renderAsInput(Args, CmdArgs);
242 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc,
false);
248 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
251 return Args.hasArg(options::OPT_fobjc_link_runtime);
257 return O.getKind() != Option::InputClass &&
262 const Driver &D,
const ArgList &Args,
263 ArgStringList &CmdArgs,
270 Args.AddLastArg(CmdArgs, options::OPT_C);
271 Args.AddLastArg(CmdArgs, options::OPT_CC);
274 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
275 (A = Args.getLastArg(options::OPT_MD)) ||
276 (A = Args.getLastArg(options::OPT_MMD))) {
279 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
280 DepFile = MF->getValue();
282 }
else if (Output.
getType() == types::TY_Dependencies) {
284 }
else if (A->getOption().matches(options::OPT_M) ||
285 A->getOption().matches(options::OPT_MM)) {
288 DepFile = getDependencyFileName(Args, Inputs);
291 CmdArgs.push_back(
"-dependency-file");
292 CmdArgs.push_back(DepFile);
295 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
296 const char *DepTarget;
300 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
301 if (OutputOpt && Output.
getType() != types::TY_Dependencies) {
302 DepTarget = OutputOpt->getValue();
308 llvm::sys::path::replace_extension(
P,
"o");
309 DepTarget = Args.MakeArgString(llvm::sys::path::filename(
P));
312 CmdArgs.push_back(
"-MT");
315 CmdArgs.push_back(Args.MakeArgString(Quoted));
318 if (A->getOption().matches(options::OPT_M) ||
319 A->getOption().matches(options::OPT_MD))
320 CmdArgs.push_back(
"-sys-header-deps");
321 if ((isa<PrecompileJobAction>(JA) &&
322 !Args.hasArg(options::OPT_fno_module_file_deps)) ||
323 Args.hasArg(options::OPT_fmodule_file_deps))
324 CmdArgs.push_back(
"-module-file-deps");
327 if (Args.hasArg(options::OPT_MG)) {
328 if (!A || A->getOption().matches(options::OPT_MD) ||
329 A->getOption().matches(options::OPT_MMD))
330 D.
Diag(diag::err_drv_mg_requires_m_or_mm);
331 CmdArgs.push_back(
"-MG");
334 Args.AddLastArg(CmdArgs, options::OPT_MP);
335 Args.AddLastArg(CmdArgs, options::OPT_MV);
338 for (
const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
341 if (A->getOption().matches(options::OPT_MQ)) {
342 CmdArgs.push_back(
"-MT");
345 CmdArgs.push_back(Args.MakeArgString(Quoted));
349 A->render(Args, CmdArgs);
358 bool RenderedImplicitInclude =
false;
359 for (
const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
360 if (A->getOption().matches(options::OPT_include)) {
361 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
362 RenderedImplicitInclude =
true;
367 bool FoundPTH =
false;
368 bool FoundPCH =
false;
374 llvm::sys::path::replace_extension(P,
"pch");
375 if (llvm::sys::fs::exists(P))
380 llvm::sys::path::replace_extension(P,
"pth");
381 if (llvm::sys::fs::exists(P))
385 if (!FoundPCH && !FoundPTH) {
386 llvm::sys::path::replace_extension(P,
"gch");
387 if (llvm::sys::fs::exists(P)) {
393 if (FoundPCH || FoundPTH) {
394 if (IsFirstImplicitInclude) {
397 CmdArgs.push_back(
"-include-pch");
399 CmdArgs.push_back(
"-include-pth");
400 CmdArgs.push_back(Args.MakeArgString(P));
404 D.
Diag(diag::warn_drv_pch_not_first_include) << P
405 << A->getAsString(Args);
412 A->render(Args, CmdArgs);
415 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
416 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
417 options::OPT_index_header_map);
425 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
426 options::OPT_Xpreprocessor);
429 if (Arg *A = Args.getLastArg(options::OPT_I_))
430 D.
Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
436 if (!Args.hasArg(options::OPT_isysroot)) {
437 CmdArgs.push_back(
"-isysroot");
438 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
455 addDirectoryList(Args, CmdArgs,
"-objcxx-isystem",
"OBJCPLUS_INCLUDE_PATH");
459 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
462 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
467 switch (Triple.getArch()) {
471 case llvm::Triple::aarch64:
472 case llvm::Triple::aarch64_be:
473 case llvm::Triple::arm:
474 case llvm::Triple::armeb:
475 case llvm::Triple::thumb:
476 case llvm::Triple::thumbeb:
477 if (Triple.isOSDarwin() || Triple.isOSWindows())
481 case llvm::Triple::ppc:
482 case llvm::Triple::ppc64:
483 if (Triple.isOSDarwin())
487 case llvm::Triple::hexagon:
488 case llvm::Triple::ppc64le:
489 case llvm::Triple::systemz:
490 case llvm::Triple::xcore:
496 switch (Triple.getArch()) {
500 case llvm::Triple::xcore:
509 llvm::StringRef Arch = Triple.getArchName();
510 return llvm::ARMTargetParser::parseArchVersion(Arch);
515 llvm::StringRef Arch = Triple.getArchName();
516 unsigned Profile = llvm::ARMTargetParser::parseArchProfile(Arch);
517 return Profile == llvm::ARM::PK_M;
522 llvm::StringRef &CPU,
bool FromAs =
false) {
523 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
525 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
526 Arch = A->getValue();
531 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
532 StringRef
Value = A->getValue();
533 if (Value.startswith(
"-mcpu="))
534 CPU = Value.substr(6);
535 if (Value.startswith(
"-march="))
536 Arch = Value.substr(7);
543 const ArgList &Args, StringRef HWDiv,
544 std::vector<const char *> &Features) {
545 if (HWDiv ==
"arm") {
546 Features.push_back(
"+hwdiv-arm");
547 Features.push_back(
"-hwdiv");
548 }
else if (HWDiv ==
"thumb") {
549 Features.push_back(
"-hwdiv-arm");
550 Features.push_back(
"+hwdiv");
551 }
else if (HWDiv ==
"arm,thumb" || HWDiv ==
"thumb,arm") {
552 Features.push_back(
"+hwdiv-arm");
553 Features.push_back(
"+hwdiv");
554 }
else if (HWDiv ==
"none") {
555 Features.push_back(
"-hwdiv-arm");
556 Features.push_back(
"-hwdiv");
558 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
563 const ArgList &Args, StringRef FPU,
564 std::vector<const char *> &Features) {
565 unsigned FPUID = llvm::ARMTargetParser::parseFPU(FPU);
566 if (!llvm::ARMTargetParser::getFPUFeatures(FPUID, Features))
567 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
574 llvm::StringRef ArchName,
575 const llvm::Triple &Triple) {
577 if (llvm::ARMTargetParser::parseArch(MArch) == llvm::ARM::AK_INVALID)
578 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
583 llvm::StringRef CPUName, llvm::StringRef ArchName,
584 const llvm::Triple &Triple) {
588 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
594 const llvm::Triple &Triple) {
597 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
598 options::OPT_mfloat_abi_EQ)) {
599 if (A->getOption().matches(options::OPT_msoft_float))
601 else if (A->getOption().matches(options::OPT_mhard_float))
604 FloatABI = A->getValue();
605 if (FloatABI !=
"soft" && FloatABI !=
"softfp" && FloatABI !=
"hard") {
606 D.
Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
613 if (FloatABI.empty()) {
614 switch (Triple.getOS()) {
615 case llvm::Triple::Darwin:
616 case llvm::Triple::MacOSX:
617 case llvm::Triple::IOS: {
629 case llvm::Triple::Win32:
633 case llvm::Triple::FreeBSD:
634 switch (Triple.getEnvironment()) {
635 case llvm::Triple::GNUEABIHF:
646 switch (Triple.getEnvironment()) {
647 case llvm::Triple::GNUEABIHF:
650 case llvm::Triple::GNUEABI:
653 case llvm::Triple::EABIHF:
656 case llvm::Triple::EABI:
660 case llvm::Triple::Android: {
670 if (Triple.getOS() != llvm::Triple::UnknownOS ||
671 !Triple.isOSBinFormatMachO())
672 D.
Diag(diag::warn_drv_assuming_mfloat_abi_is) <<
"soft";
683 std::vector<const char *> &Features,
686 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
688 const Arg *WaCPU =
nullptr, *WaFPU =
nullptr;
689 const Arg *WaHDiv =
nullptr, *WaArch =
nullptr;
705 if (FloatABI ==
"soft")
706 Features.push_back(
"+soft-float");
709 if (FloatABI !=
"hard")
710 Features.push_back(
"+soft-float-abi");
715 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
716 StringRef
Value = A->getValue();
717 if (Value.startswith(
"-mfpu=")) {
719 }
else if (Value.startswith(
"-mcpu=")) {
721 }
else if (Value.startswith(
"-mhwdiv=")) {
723 }
else if (Value.startswith(
"-march=")) {
730 const Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);
733 D.
Diag(clang::diag::warn_drv_unused_argument)
734 << FPUArg->getAsString(Args);
742 const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
745 D.
Diag(clang::diag::warn_drv_unused_argument)
746 << HDivArg->getAsString(Args);
748 StringRef(WaHDiv->getValue()).substr(8), Features);
753 const Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);
757 D.
Diag(clang::diag::warn_drv_unused_argument)
758 << ArchArg->getAsString(Args);
759 ArchName = StringRef(WaArch->getValue()).substr(7);
762 D.
Diag(clang::diag::warn_drv_unused_argument) << WaArch->getAsString(Args);
763 }
else if (ArchArg) {
764 ArchName = ArchArg->getValue();
769 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
773 D.
Diag(clang::diag::warn_drv_unused_argument)
774 << CPUArg->getAsString(Args);
775 CPUName = StringRef(WaCPU->getValue()).substr(6);
778 CPUName = CPUArg->getValue();
784 if (FloatABI ==
"soft") {
785 Features.push_back(
"-neon");
787 Features.push_back(
"-crypto");
791 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
792 if (A->getOption().matches(options::OPT_mcrc))
793 Features.push_back(
"+crc");
795 Features.push_back(
"-crc");
798 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_1a) {
799 Features.insert(Features.begin(),
"+v8.1a");
805 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
806 options::OPT_mno_long_calls)) {
807 if (A->getOption().matches(options::OPT_mlong_calls))
808 Features.push_back(
"+long-calls");
809 }
else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6))) {
810 Features.push_back(
"+long-calls");
814 void Clang::AddARMTargetArgs(
const ArgList &Args, ArgStringList &CmdArgs,
815 bool KernelOrKext)
const {
816 const Driver &D = getToolChain().getDriver();
818 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
819 llvm::Triple Triple(TripleStr);
825 const char *ABIName =
nullptr;
826 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
827 ABIName = A->getValue();
828 }
else if (Triple.isOSBinFormatMachO()) {
831 if (Triple.getEnvironment() == llvm::Triple::EABI ||
832 Triple.getOS() == llvm::Triple::UnknownOS ||
isARMMProfile(Triple)) {
835 ABIName =
"apcs-gnu";
837 }
else if (Triple.isOSWindows()) {
842 switch (Triple.getEnvironment()) {
843 case llvm::Triple::Android:
844 case llvm::Triple::GNUEABI:
845 case llvm::Triple::GNUEABIHF:
846 ABIName =
"aapcs-linux";
848 case llvm::Triple::EABIHF:
849 case llvm::Triple::EABI:
853 if (Triple.getOS() == llvm::Triple::NetBSD)
854 ABIName =
"apcs-gnu";
860 CmdArgs.push_back(
"-target-abi");
861 CmdArgs.push_back(ABIName);
865 if (FloatABI ==
"soft") {
869 CmdArgs.push_back(
"-msoft-float");
870 CmdArgs.push_back(
"-mfloat-abi");
871 CmdArgs.push_back(
"soft");
872 }
else if (FloatABI ==
"softfp") {
874 CmdArgs.push_back(
"-mfloat-abi");
875 CmdArgs.push_back(
"soft");
878 assert(FloatABI ==
"hard" &&
"Invalid float abi!");
879 CmdArgs.push_back(
"-mfloat-abi");
880 CmdArgs.push_back(
"hard");
885 CmdArgs.push_back(
"-backend-option");
886 CmdArgs.push_back(
"-arm-strict-align");
889 CmdArgs.push_back(
"-backend-option");
890 CmdArgs.push_back(
"-arm-use-movt=0");
895 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
896 options::OPT_munaligned_access)) {
897 CmdArgs.push_back(
"-backend-option");
898 if (A->getOption().matches(options::OPT_mno_unaligned_access))
899 CmdArgs.push_back(
"-arm-strict-align");
901 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
902 D.
Diag(diag::err_target_unsupported_unaligned) <<
"v6m";
903 CmdArgs.push_back(
"-arm-no-strict-align");
909 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
910 options::OPT_mno_global_merge)) {
911 CmdArgs.push_back(
"-backend-option");
912 if (A->getOption().matches(options::OPT_mno_global_merge))
913 CmdArgs.push_back(
"-arm-global-merge=false");
915 CmdArgs.push_back(
"-arm-global-merge=true");
918 if (!Args.hasFlag(options::OPT_mimplicit_float,
919 options::OPT_mno_implicit_float,
true))
920 CmdArgs.push_back(
"-no-implicit-float");
925 if (Args.hasArg(options::OPT_ffixed_r9)) {
926 CmdArgs.push_back(
"-backend-option");
927 CmdArgs.push_back(
"-arm-reserve-r9");
938 if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
940 }
else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
941 StringRef Mcpu = A->getValue();
942 CPU = Mcpu.split(
"+").first.lower();
947 return llvm::sys::getHostCPUName();
953 if (Args.getLastArg(options::OPT_arch))
959 void Clang::AddAArch64TargetArgs(
const ArgList &Args,
960 ArgStringList &CmdArgs)
const {
961 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
962 llvm::Triple Triple(TripleStr);
964 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
965 Args.hasArg(options::OPT_mkernel) ||
966 Args.hasArg(options::OPT_fapple_kext))
967 CmdArgs.push_back(
"-disable-red-zone");
969 if (!Args.hasFlag(options::OPT_mimplicit_float,
970 options::OPT_mno_implicit_float,
true))
971 CmdArgs.push_back(
"-no-implicit-float");
973 const char *ABIName =
nullptr;
974 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
975 ABIName = A->getValue();
976 else if (Triple.isOSDarwin())
977 ABIName =
"darwinpcs";
981 CmdArgs.push_back(
"-target-abi");
982 CmdArgs.push_back(ABIName);
984 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
985 options::OPT_munaligned_access)) {
986 CmdArgs.push_back(
"-backend-option");
987 if (A->getOption().matches(options::OPT_mno_unaligned_access))
988 CmdArgs.push_back(
"-aarch64-strict-align");
990 CmdArgs.push_back(
"-aarch64-no-strict-align");
993 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
994 options::OPT_mno_fix_cortex_a53_835769)) {
995 CmdArgs.push_back(
"-backend-option");
996 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
997 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
999 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=0");
1000 }
else if (Triple.getEnvironment() == llvm::Triple::Android) {
1002 CmdArgs.push_back(
"-backend-option");
1003 CmdArgs.push_back(
"-aarch64-fix-cortex-a53-835769=1");
1007 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1008 options::OPT_mno_global_merge)) {
1009 CmdArgs.push_back(
"-backend-option");
1010 if (A->getOption().matches(options::OPT_mno_global_merge))
1011 CmdArgs.push_back(
"-aarch64-global-merge=false");
1013 CmdArgs.push_back(
"-aarch64-global-merge=true");
1016 if (Args.hasArg(options::OPT_ffixed_x18)) {
1017 CmdArgs.push_back(
"-backend-option");
1018 CmdArgs.push_back(
"-aarch64-reserve-x18");
1025 StringRef &CPUName, StringRef &ABIName) {
1026 const char *DefMips32CPU =
"mips32r2";
1027 const char *DefMips64CPU =
"mips64r2";
1031 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1032 Triple.getEnvironment() == llvm::Triple::GNU) {
1033 DefMips32CPU =
"mips32r6";
1034 DefMips64CPU =
"mips64r6";
1038 if (Triple.getOS() == llvm::Triple::OpenBSD)
1039 DefMips64CPU =
"mips3";
1041 if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ))
1042 CPUName = A->getValue();
1044 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1045 ABIName = A->getValue();
1048 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
1055 if (CPUName.empty() && ABIName.empty()) {
1056 switch (Triple.getArch()) {
1058 llvm_unreachable(
"Unexpected triple arch name");
1059 case llvm::Triple::mips:
1060 case llvm::Triple::mipsel:
1061 CPUName = DefMips32CPU;
1063 case llvm::Triple::mips64:
1064 case llvm::Triple::mips64el:
1065 CPUName = DefMips64CPU;
1070 if (ABIName.empty()) {
1072 if (Triple.getArch() == llvm::Triple::mips ||
1073 Triple.getArch() == llvm::Triple::mipsel)
1079 if (CPUName.empty()) {
1081 CPUName = llvm::StringSwitch<const char *>(ABIName)
1082 .Cases(
"o32",
"eabi", DefMips32CPU)
1083 .Cases(
"n32",
"n64", DefMips64CPU)
1092 return llvm::StringSwitch<llvm::StringRef>(ABI)
1103 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1104 options::OPT_mfloat_abi_EQ)) {
1105 if (A->getOption().matches(options::OPT_msoft_float))
1107 else if (A->getOption().matches(options::OPT_mhard_float))
1110 FloatABI = A->getValue();
1111 if (FloatABI !=
"soft" && FloatABI !=
"hard") {
1112 D.
Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1119 if (FloatABI.empty()) {
1130 std::vector<const char *> &Features,
1131 OptSpecifier OnOpt, OptSpecifier OffOpt,
1132 StringRef FeatureName) {
1133 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1134 if (A->getOption().matches(OnOpt))
1135 Features.push_back(Args.MakeArgString(
"+" + FeatureName));
1137 Features.push_back(Args.MakeArgString(
"-" + FeatureName));
1142 const ArgList &Args,
1143 std::vector<const char *> &Features) {
1150 options::OPT_mabicalls,
"noabicalls");
1153 if (FloatABI ==
"soft") {
1157 Features.push_back(
"+soft-float");
1160 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1161 StringRef Val = StringRef(A->getValue());
1162 if (Val ==
"2008") {
1164 Features.push_back(
"+nan2008");
1166 Features.push_back(
"-nan2008");
1167 D.
Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1169 }
else if (Val ==
"legacy") {
1171 Features.push_back(
"-nan2008");
1173 Features.push_back(
"+nan2008");
1174 D.
Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1177 D.
Diag(diag::err_drv_unsupported_option_argument)
1178 << A->getOption().getName() << Val;
1182 options::OPT_mdouble_float,
"single-float");
1183 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1186 options::OPT_mno_micromips,
"micromips");
1189 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1196 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1197 options::OPT_mfp64)) {
1198 if (A->getOption().matches(options::OPT_mfp32))
1199 Features.push_back(Args.MakeArgString(
"-fp64"));
1200 else if (A->getOption().matches(options::OPT_mfpxx)) {
1201 Features.push_back(Args.MakeArgString(
"+fpxx"));
1202 Features.push_back(Args.MakeArgString(
"+nooddspreg"));
1204 Features.push_back(Args.MakeArgString(
"+fp64"));
1206 Features.push_back(Args.MakeArgString(
"+fpxx"));
1207 Features.push_back(Args.MakeArgString(
"+nooddspreg"));
1211 options::OPT_modd_spreg,
"nooddspreg");
1214 void Clang::AddMIPSTargetArgs(
const ArgList &Args,
1215 ArgStringList &CmdArgs)
const {
1216 const Driver &D = getToolChain().getDriver();
1219 const llvm::Triple &Triple = getToolChain().getTriple();
1222 CmdArgs.push_back(
"-target-abi");
1223 CmdArgs.push_back(ABIName.data());
1227 if (FloatABI ==
"soft") {
1229 CmdArgs.push_back(
"-msoft-float");
1230 CmdArgs.push_back(
"-mfloat-abi");
1231 CmdArgs.push_back(
"soft");
1234 assert(FloatABI ==
"hard" &&
"Invalid float abi!");
1235 CmdArgs.push_back(
"-mfloat-abi");
1236 CmdArgs.push_back(
"hard");
1239 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1240 if (A->getOption().matches(options::OPT_mxgot)) {
1241 CmdArgs.push_back(
"-mllvm");
1242 CmdArgs.push_back(
"-mxgot");
1246 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1247 options::OPT_mno_ldc1_sdc1)) {
1248 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1249 CmdArgs.push_back(
"-mllvm");
1250 CmdArgs.push_back(
"-mno-ldc1-sdc1");
1254 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1255 options::OPT_mno_check_zero_division)) {
1256 if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1257 CmdArgs.push_back(
"-mllvm");
1258 CmdArgs.push_back(
"-mno-check-zero-division");
1262 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1263 StringRef
v = A->getValue();
1264 CmdArgs.push_back(
"-mllvm");
1265 CmdArgs.push_back(Args.MakeArgString(
"-mips-ssection-threshold=" + v));
1272 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1273 StringRef CPUName = A->getValue();
1275 if (CPUName ==
"native") {
1276 std::string CPU = llvm::sys::getHostCPUName();
1277 if (!CPU.empty() && CPU !=
"generic")
1283 return llvm::StringSwitch<const char *>(CPUName)
1284 .Case(
"common",
"generic")
1286 .Case(
"440fp",
"440")
1291 .Case(
"603e",
"603e")
1292 .Case(
"603ev",
"603ev")
1294 .Case(
"604e",
"604e")
1296 .Case(
"630",
"pwr3")
1298 .Case(
"7400",
"7400")
1300 .Case(
"7450",
"7450")
1307 .Case(
"e500mc",
"e500mc")
1308 .Case(
"e5500",
"e5500")
1309 .Case(
"power3",
"pwr3")
1310 .Case(
"power4",
"pwr4")
1311 .Case(
"power5",
"pwr5")
1312 .Case(
"power5x",
"pwr5x")
1313 .Case(
"power6",
"pwr6")
1314 .Case(
"power6x",
"pwr6x")
1315 .Case(
"power7",
"pwr7")
1316 .Case(
"power8",
"pwr8")
1317 .Case(
"pwr3",
"pwr3")
1318 .Case(
"pwr4",
"pwr4")
1319 .Case(
"pwr5",
"pwr5")
1320 .Case(
"pwr5x",
"pwr5x")
1321 .Case(
"pwr6",
"pwr6")
1322 .Case(
"pwr6x",
"pwr6x")
1323 .Case(
"pwr7",
"pwr7")
1324 .Case(
"pwr8",
"pwr8")
1325 .Case(
"powerpc",
"ppc")
1326 .Case(
"powerpc64",
"ppc64")
1327 .Case(
"powerpc64le",
"ppc64le")
1335 std::vector<const char *> &Features) {
1336 for (
const Arg *A : Args.filtered(options::OPT_m_ppc_Features_Group)) {
1337 StringRef Name = A->getOption().getName();
1341 assert(Name.startswith(
"m") &&
"Invalid feature name.");
1342 Name = Name.substr(1);
1344 bool IsNegative = Name.startswith(
"no-");
1346 Name = Name.substr(3);
1352 if (Name ==
"mfcrf")
1355 Features.push_back(Args.MakeArgString((IsNegative ?
"-" :
"+") + Name));
1360 options::OPT_fno_altivec,
"altivec");
1363 void Clang::AddPPCTargetArgs(
const ArgList &Args,
1364 ArgStringList &CmdArgs)
const {
1366 const char *ABIName =
nullptr;
1367 if (getToolChain().getTriple().isOSLinux())
1368 switch (getToolChain().getArch()) {
1369 case llvm::Triple::ppc64: {
1373 bool HasQPX =
false;
1374 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1375 HasQPX = A->getValue() == StringRef(
"a2q");
1376 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1378 ABIName =
"elfv1-qpx";
1385 case llvm::Triple::ppc64le:
1392 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1396 if (StringRef(A->getValue()) !=
"altivec")
1397 ABIName = A->getValue();
1400 CmdArgs.push_back(
"-target-abi");
1401 CmdArgs.push_back(ABIName);
1406 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1407 return A && (A->getValue() == StringRef(Value));
1412 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1413 const char *GPUName = A->getValue();
1414 return llvm::StringSwitch<const char *>(GPUName)
1415 .Cases(
"rv630",
"rv635",
"r600")
1416 .Cases(
"rv610",
"rv620",
"rs780",
"rs880")
1417 .Case(
"rv740",
"rv770")
1418 .Case(
"palm",
"cedar")
1419 .Cases(
"sumo",
"sumo2",
"sumo")
1420 .Case(
"hemlock",
"cypress")
1421 .Case(
"aruba",
"cayman")
1427 void Clang::AddSparcTargetArgs(
const ArgList &Args,
1428 ArgStringList &CmdArgs)
const {
1429 const Driver &D = getToolChain().getDriver();
1430 std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
1432 bool SoftFloatABI =
false;
1434 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1435 if (A->getOption().matches(options::OPT_msoft_float))
1436 SoftFloatABI =
true;
1445 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-msoft-float"
1451 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1452 return A->getValue();
1457 std::vector<const char *> &Features) {
1459 if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
1460 if (A->getOption().matches(options::OPT_mhtm))
1461 Features.push_back(
"+transactional-execution");
1463 Features.push_back(
"-transactional-execution");
1466 if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
1467 if (A->getOption().matches(options::OPT_mvx))
1468 Features.push_back(
"+vector");
1470 Features.push_back(
"-vector");
1475 const llvm::Triple &Triple) {
1476 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1477 if (StringRef(A->getValue()) !=
"native") {
1478 if (Triple.isOSDarwin() && Triple.getArchName() ==
"x86_64h")
1481 return A->getValue();
1489 std::string CPU = llvm::sys::getHostCPUName();
1490 if (!CPU.empty() && CPU !=
"generic")
1491 return Args.MakeArgString(CPU);
1494 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1496 StringRef Arch = A->getValue();
1498 if (Triple.getArch() == llvm::Triple::x86) {
1499 CPU = llvm::StringSwitch<const char *>(Arch)
1500 .Case(
"IA32",
"i386")
1501 .Case(
"SSE",
"pentium3")
1502 .Case(
"SSE2",
"pentium4")
1503 .Case(
"AVX",
"sandybridge")
1504 .Case(
"AVX2",
"haswell")
1507 CPU = llvm::StringSwitch<const char *>(Arch)
1508 .Case(
"AVX",
"sandybridge")
1509 .Case(
"AVX2",
"haswell")
1518 if (Triple.getArch() != llvm::Triple::x86_64 &&
1519 Triple.getArch() != llvm::Triple::x86)
1522 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1525 if (Triple.isOSDarwin()) {
1526 if (Triple.getArchName() ==
"x86_64h")
1528 return Is64Bit ?
"core2" :
"yonah";
1532 if (Triple.isPS4CPU())
1536 if (Triple.getEnvironment() == llvm::Triple::Android)
1537 return Is64Bit ?
"x86-64" :
"i686";
1543 switch (Triple.getOS()) {
1544 case llvm::Triple::FreeBSD:
1545 case llvm::Triple::NetBSD:
1546 case llvm::Triple::OpenBSD:
1548 case llvm::Triple::Haiku:
1550 case llvm::Triple::Bitrig:
1558 static std::string
getCPUName(
const ArgList &Args,
const llvm::Triple &T,
1559 bool FromAs =
false) {
1560 switch (T.getArch()) {
1564 case llvm::Triple::aarch64:
1565 case llvm::Triple::aarch64_be:
1568 case llvm::Triple::arm:
1569 case llvm::Triple::armeb:
1570 case llvm::Triple::thumb:
1571 case llvm::Triple::thumbeb: {
1572 StringRef MArch, MCPU;
1576 case llvm::Triple::mips:
1577 case llvm::Triple::mipsel:
1578 case llvm::Triple::mips64:
1579 case llvm::Triple::mips64el: {
1586 case llvm::Triple::nvptx:
1587 case llvm::Triple::nvptx64:
1588 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1589 return A->getValue();
1592 case llvm::Triple::ppc:
1593 case llvm::Triple::ppc64:
1594 case llvm::Triple::ppc64le: {
1599 if (TargetCPUName.empty() && !T.isOSDarwin()) {
1600 if (T.getArch() == llvm::Triple::ppc64)
1601 TargetCPUName =
"ppc64";
1602 else if (T.getArch() == llvm::Triple::ppc64le)
1603 TargetCPUName =
"ppc64le";
1605 TargetCPUName =
"ppc";
1607 return TargetCPUName;
1610 case llvm::Triple::sparc:
1611 case llvm::Triple::sparcel:
1612 case llvm::Triple::sparcv9:
1613 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1614 return A->getValue();
1617 case llvm::Triple::x86:
1618 case llvm::Triple::x86_64:
1621 case llvm::Triple::hexagon:
1624 case llvm::Triple::systemz:
1627 case llvm::Triple::r600:
1628 case llvm::Triple::amdgcn:
1634 ArgStringList &CmdArgs) {
1638 CmdArgs.push_back(
"-plugin");
1639 std::string Plugin =
1640 ToolChain.
getDriver().
Dir +
"/../lib" CLANG_LIBDIR_SUFFIX
"/LLVMgold.so";
1641 CmdArgs.push_back(Args.MakeArgString(Plugin));
1649 CmdArgs.push_back(Args.MakeArgString(Twine(
"-plugin-opt=mcpu=") + CPU));
1658 const char RefinementStepToken =
':';
1659 Position = In.find(RefinementStepToken);
1660 if (Position != StringRef::npos) {
1661 StringRef Option = A.getOption().getName();
1662 StringRef RefStep = In.substr(Position + 1);
1670 if (RefStep.size() != 1) {
1671 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
1674 char RefStepChar = RefStep[0];
1675 if (RefStepChar < '0' || RefStepChar >
'9') {
1676 D.
Diag(diag::err_drv_invalid_value) << Option << RefStep;
1685 ArgStringList &OutStrings) {
1686 StringRef DisabledPrefixIn =
"!";
1687 StringRef DisabledPrefixOut =
"!";
1688 StringRef EnabledPrefixOut =
"";
1689 StringRef Out =
"-mrecip=";
1691 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1695 unsigned NumOptions = A->getNumValues();
1696 if (NumOptions == 0) {
1698 OutStrings.push_back(Args.MakeArgString(Out +
"all"));
1703 if (NumOptions == 1) {
1704 StringRef Val = A->getValue(0);
1708 StringRef ValBase = Val.slice(0, RefStepLoc);
1709 if (ValBase ==
"all" || ValBase ==
"none" || ValBase ==
"default") {
1710 OutStrings.push_back(Args.MakeArgString(Out + Val));
1719 llvm::StringMap<bool> OptionStrings;
1720 OptionStrings.insert(std::make_pair(
"divd",
false));
1721 OptionStrings.insert(std::make_pair(
"divf",
false));
1722 OptionStrings.insert(std::make_pair(
"vec-divd",
false));
1723 OptionStrings.insert(std::make_pair(
"vec-divf",
false));
1724 OptionStrings.insert(std::make_pair(
"sqrtd",
false));
1725 OptionStrings.insert(std::make_pair(
"sqrtf",
false));
1726 OptionStrings.insert(std::make_pair(
"vec-sqrtd",
false));
1727 OptionStrings.insert(std::make_pair(
"vec-sqrtf",
false));
1729 for (
unsigned i = 0; i != NumOptions; ++i) {
1730 StringRef Val = A->getValue(i);
1732 bool IsDisabled = Val.startswith(DisabledPrefixIn);
1735 Val = Val.substr(1);
1741 StringRef ValBase = Val.slice(0, RefStep);
1742 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
1743 if (OptionIter == OptionStrings.end()) {
1745 OptionIter = OptionStrings.find(ValBase.str() +
'f');
1746 if (OptionIter == OptionStrings.end()) {
1748 D.
Diag(diag::err_drv_unknown_argument) << Val;
1754 if (OptionStrings[ValBase.str() +
'd']) {
1755 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1760 if (OptionIter->second ==
true) {
1762 D.
Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1767 OptionIter->second =
true;
1770 if (ValBase.back() !=
'f' && ValBase.back() !=
'd')
1771 OptionStrings[ValBase.str() +
'd'] =
true;
1774 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1775 Out = Args.MakeArgString(Out + Prefix + Val);
1776 if (i != NumOptions - 1)
1777 Out = Args.MakeArgString(Out +
",");
1780 OutStrings.push_back(Args.MakeArgString(Out));
1784 const ArgList &Args,
1785 std::vector<const char *> &Features) {
1787 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1788 if (StringRef(A->getValue()) ==
"native") {
1789 llvm::StringMap<bool> HostFeatures;
1790 if (llvm::sys::getHostCPUFeatures(HostFeatures))
1791 for (
auto &F : HostFeatures)
1793 Args.MakeArgString((F.second ?
"+" :
"-") + F.first()));
1797 if (Triple.getArchName() ==
"x86_64h") {
1800 Features.push_back(
"-rdrnd");
1801 Features.push_back(
"-aes");
1802 Features.push_back(
"-pclmul");
1803 Features.push_back(
"-rtm");
1804 Features.push_back(
"-hle");
1805 Features.push_back(
"-fsgsbase");
1808 const llvm::Triple::ArchType ArchType = Triple.getArch();
1810 if (Triple.getEnvironment() == llvm::Triple::Android) {
1811 if (ArchType == llvm::Triple::x86_64) {
1812 Features.push_back(
"+sse4.2");
1813 Features.push_back(
"+popcnt");
1815 Features.push_back(
"+ssse3");
1819 if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1820 StringRef Arch = A->getValue();
1821 bool ArchUsed =
false;
1823 if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
1824 if (Arch ==
"AVX" || Arch ==
"AVX2") {
1826 Features.push_back(Args.MakeArgString(
"+" + Arch.lower()));
1830 if (ArchType == llvm::Triple::x86) {
1831 if (Arch ==
"IA32") {
1833 }
else if (Arch ==
"SSE" || Arch ==
"SSE2") {
1835 Features.push_back(Args.MakeArgString(
"+" + Arch.lower()));
1839 D.
Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1844 for (
const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1845 StringRef Name = A->getOption().getName();
1849 assert(Name.startswith(
"m") &&
"Invalid feature name.");
1850 Name = Name.substr(1);
1852 bool IsNegative = Name.startswith(
"no-");
1854 Name = Name.substr(3);
1856 Features.push_back(Args.MakeArgString((IsNegative ?
"-" :
"+") + Name));
1860 void Clang::AddX86TargetArgs(
const ArgList &Args,
1861 ArgStringList &CmdArgs)
const {
1862 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone,
true) ||
1863 Args.hasArg(options::OPT_mkernel) ||
1864 Args.hasArg(options::OPT_fapple_kext))
1865 CmdArgs.push_back(
"-disable-red-zone");
1869 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1870 Args.hasArg(options::OPT_fapple_kext));
1871 if (Arg *A = Args.getLastArg(
1872 options::OPT_msoft_float, options::OPT_mno_soft_float,
1873 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
1874 const Option &O = A->getOption();
1875 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1876 O.matches(options::OPT_msoft_float));
1878 if (NoImplicitFloat)
1879 CmdArgs.push_back(
"-no-implicit-float");
1881 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1882 StringRef Value = A->getValue();
1883 if (Value ==
"intel" || Value ==
"att") {
1884 CmdArgs.push_back(
"-mllvm");
1885 CmdArgs.push_back(Args.MakeArgString(
"-x86-asm-syntax=" + Value));
1887 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1888 << A->getOption().getName() <<
Value;
1893 void Clang::AddHexagonTargetArgs(
const ArgList &Args,
1894 ArgStringList &CmdArgs)
const {
1895 CmdArgs.push_back(
"-mqdsp6-compat");
1896 CmdArgs.push_back(
"-Wreturn-type");
1899 std::string SmallDataThreshold =
"-hexagon-small-data-threshold=";
1900 SmallDataThreshold +=
v;
1901 CmdArgs.push_back(
"-mllvm");
1902 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
1905 if (!Args.hasArg(options::OPT_fno_short_enums))
1906 CmdArgs.push_back(
"-fshort-enums");
1907 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1908 CmdArgs.push_back(
"-mllvm");
1909 CmdArgs.push_back(
"-enable-hexagon-ieee-rnd-near");
1911 CmdArgs.push_back(
"-mllvm");
1912 CmdArgs.push_back(
"-machine-sink-split=0");
1917 std::vector<const char *> &Features) {
1919 text.split(Split, StringRef(
"+"), -1,
false);
1921 for (
const StringRef Feature : Split) {
1922 const char *result = llvm::StringSwitch<const char *>(Feature)
1923 .Case(
"fp",
"+fp-armv8")
1924 .Case(
"simd",
"+neon")
1925 .Case(
"crc",
"+crc")
1926 .Case(
"crypto",
"+crypto")
1927 .Case(
"nofp",
"-fp-armv8")
1928 .Case(
"nosimd",
"-neon")
1929 .Case(
"nocrc",
"-crc")
1930 .Case(
"nocrypto",
"-crypto")
1933 Features.push_back(result);
1934 else if (Feature ==
"neon" || Feature ==
"noneon")
1935 D.
Diag(diag::err_drv_no_neon_modifier);
1945 std::vector<const char *> &Features) {
1946 std::pair<StringRef, StringRef> Split = Mcpu.split(
"+");
1948 if (CPU ==
"cyclone" || CPU ==
"cortex-a53" || CPU ==
"cortex-a57" ||
1949 CPU ==
"cortex-a72") {
1950 Features.push_back(
"+neon");
1951 Features.push_back(
"+crc");
1952 Features.push_back(
"+crypto");
1953 }
else if (CPU ==
"generic") {
1954 Features.push_back(
"+neon");
1967 const ArgList &Args,
1968 std::vector<const char *> &Features) {
1969 std::string MarchLowerCase = March.lower();
1970 std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split(
"+");
1972 if (Split.first ==
"armv8-a" || Split.first ==
"armv8a") {
1974 }
else if (Split.first ==
"armv8.1-a" || Split.first ==
"armv8.1a") {
1975 Features.push_back(
"+v8.1a");
1988 const ArgList &Args,
1989 std::vector<const char *> &Features) {
1991 std::string McpuLowerCase = Mcpu.lower();
2000 const ArgList &Args,
2001 std::vector<const char *> &Features) {
2003 if (Mtune ==
"native")
2004 Mtune = llvm::sys::getHostCPUName();
2005 if (Mtune ==
"cyclone") {
2006 Features.push_back(
"+zcm");
2007 Features.push_back(
"+zcz");
2014 const ArgList &Args,
2015 std::vector<const char *> &Features) {
2017 std::vector<const char *> DecodedFeature;
2018 std::string McpuLowerCase = Mcpu.lower();
2026 std::vector<const char *> &Features) {
2028 bool success =
true;
2030 Features.push_back(
"+neon");
2031 if ((A = Args.getLastArg(options::OPT_march_EQ)))
2033 else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
2035 else if (Args.hasArg(options::OPT_arch))
2039 if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
2042 else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
2045 else if (Args.hasArg(options::OPT_arch))
2050 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
2052 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
2053 Features.push_back(
"-fp-armv8");
2054 Features.push_back(
"-crypto");
2055 Features.push_back(
"-neon");
2059 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
2060 if (A->getOption().matches(options::OPT_mcrc))
2061 Features.push_back(
"+crc");
2063 Features.push_back(
"-crc");
2068 const ArgList &Args, ArgStringList &CmdArgs,
2070 std::vector<const char *> Features;
2071 switch (Triple.getArch()) {
2074 case llvm::Triple::mips:
2075 case llvm::Triple::mipsel:
2076 case llvm::Triple::mips64:
2077 case llvm::Triple::mips64el:
2081 case llvm::Triple::arm:
2082 case llvm::Triple::armeb:
2083 case llvm::Triple::thumb:
2084 case llvm::Triple::thumbeb:
2088 case llvm::Triple::ppc:
2089 case llvm::Triple::ppc64:
2090 case llvm::Triple::ppc64le:
2093 case llvm::Triple::systemz:
2096 case llvm::Triple::aarch64:
2097 case llvm::Triple::aarch64_be:
2100 case llvm::Triple::x86:
2101 case llvm::Triple::x86_64:
2107 llvm::StringMap<unsigned> LastOpt;
2108 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
2109 const char *Name = Features[I];
2110 assert(Name[0] ==
'-' || Name[0] ==
'+');
2111 LastOpt[Name + 1] = I;
2114 for (
unsigned I = 0, N = Features.size(); I < N; ++I) {
2116 const char *Name = Features[I];
2117 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2118 assert(LastI != LastOpt.end());
2119 unsigned Last = LastI->second;
2123 CmdArgs.push_back(
"-target-feature");
2124 CmdArgs.push_back(Name);
2130 const llvm::Triple &Triple) {
2137 if (!Triple.isMacOSX())
2140 return (!Triple.isMacOSXVersionLT(10, 5) &&
2141 (Triple.getArch() == llvm::Triple::x86_64 ||
2142 Triple.getArch() == llvm::Triple::arm));
2152 ArgStringList &CmdArgs) {
2154 const llvm::Triple &Triple = TC.
getTriple();
2159 Args.ClaimAllArgs(options::OPT_fexceptions);
2160 Args.ClaimAllArgs(options::OPT_fno_exceptions);
2161 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2162 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2163 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2164 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
2169 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2175 Args.hasFlag(options::OPT_fobjc_exceptions,
2176 options::OPT_fno_objc_exceptions,
true)) {
2177 CmdArgs.push_back(
"-fobjc-exceptions");
2185 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
2186 !Triple.isPS4CPU() &&
2187 !Triple.isWindowsMSVCEnvironment();
2188 Arg *ExceptionArg = Args.getLastArg(
2189 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2190 options::OPT_fexceptions, options::OPT_fno_exceptions);
2192 CXXExceptionsEnabled =
2193 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2194 ExceptionArg->getOption().matches(options::OPT_fexceptions);
2196 if (CXXExceptionsEnabled) {
2197 if (Triple.isPS4CPU()) {
2199 assert(ExceptionArg &&
2200 "On the PS4 exceptions should only be enabled if passing "
2204 assert(RTTIArg &&
"RTTI disabled explicitly but no RTTIArg!");
2205 D.
Diag(diag::err_drv_argument_not_allowed_with)
2206 << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2208 D.
Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2212 CmdArgs.push_back(
"-fcxx-exceptions");
2219 CmdArgs.push_back(
"-fexceptions");
2223 bool Default =
true;
2229 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2235 bool UseDwarfDirectory =
2236 Args.hasFlag(options::OPT_fdwarf_directory_asm,
2238 return !UseDwarfDirectory;
2243 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
2246 for (
const auto &Act : *A)
2256 bool RelaxDefault =
true;
2258 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2259 RelaxDefault = A->getOption().matches(options::OPT_O0);
2262 RelaxDefault =
false;
2265 RelaxDefault =
true;
2271 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2276 const ArgList &Args,
2277 ArgStringList &CmdArgs,
2280 CmdArgs.push_back(
"-mrelax-all");
2287 bool TakeNextArg =
false;
2291 bool CompressDebugSections =
false;
2293 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2296 for (
const StringRef Value : A->getValues()) {
2298 CmdArgs.push_back(Value.data());
2299 TakeNextArg =
false;
2303 if (Value ==
"-force_cpusubtype_ALL") {
2305 }
else if (Value ==
"-L") {
2306 CmdArgs.push_back(
"-msave-temp-labels");
2307 }
else if (Value ==
"--fatal-warnings") {
2308 CmdArgs.push_back(
"-massembler-fatal-warnings");
2309 }
else if (Value ==
"--noexecstack") {
2310 CmdArgs.push_back(
"-mnoexecstack");
2311 }
else if (Value ==
"-compress-debug-sections" ||
2312 Value ==
"--compress-debug-sections") {
2313 CompressDebugSections =
true;
2314 }
else if (Value ==
"-nocompress-debug-sections" ||
2315 Value ==
"--nocompress-debug-sections") {
2316 CompressDebugSections =
false;
2317 }
else if (Value.startswith(
"-I")) {
2318 CmdArgs.push_back(Value.data());
2323 }
else if (Value.startswith(
"-gdwarf-")) {
2324 CmdArgs.push_back(Value.data());
2325 }
else if (Value.startswith(
"-mcpu") || Value.startswith(
"-mfpu") ||
2326 Value.startswith(
"-mhwdiv") || Value.startswith(
"-march")) {
2329 D.
Diag(diag::err_drv_unsupported_option_argument)
2330 << A->getOption().getName() <<
Value;
2334 if (CompressDebugSections) {
2335 if (llvm::zlib::isAvailable())
2336 CmdArgs.push_back(
"-compress-debug-sections");
2338 D.
Diag(diag::warn_debug_compression_unavailable);
2344 if (TC.
getTriple().isWindowsMSVCEnvironment() &&
2345 TC.
getArch() == llvm::Triple::x86)
2347 if (TC.
getArch() == llvm::Triple::arm || TC.
getArch() == llvm::Triple::armeb)
2355 const llvm::Triple &Triple = TC.
getTriple();
2357 StringRef OSLibName =
2358 (Triple.getOS() == llvm::Triple::FreeBSD) ?
"freebsd" : TC.
getOS();
2359 llvm::sys::path::append(Res,
"lib", OSLibName);
2365 const char *Env = TC.
getTriple().getEnvironment() == llvm::Triple::Android
2369 bool IsOSWindows = TC.
getTriple().isOSWindows();
2370 bool IsITANMSVCWindows = TC.
getTriple().isWindowsMSVCEnvironment() ||
2371 TC.
getTriple().isWindowsItaniumEnvironment();
2373 const char *Prefix = IsITANMSVCWindows ?
"" :
"lib";
2374 const char *Suffix =
2375 Shared ? (IsOSWindows ?
".dll" :
".so") : (IsITANMSVCWindows ?
".lib" :
".a");
2378 llvm::sys::path::append(Path, Prefix + Twine(
"clang_rt.") + Component +
"-" +
2379 Arch + Env + Suffix);
2388 ArgStringList &CmdArgs) {
2389 CmdArgs.push_back(Args.MakeArgString(
getCompilerRT(TC,
"builtins")));
2393 CmdArgs.push_back(
"-lgcc_s");
2395 CmdArgs.push_back(
"-lgcc_eh");
2400 ArgStringList &CmdArgs) {
2401 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2403 Args.hasArg(options::OPT_fprofile_generate) ||
2404 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
2405 Args.hasArg(options::OPT_fprofile_instr_generate) ||
2406 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
2407 Args.hasArg(options::OPT_fcreate_profile) ||
2408 Args.hasArg(options::OPT_coverage)))
2411 CmdArgs.push_back(Args.MakeArgString(
getCompilerRT(TC,
"profile")));
2438 const ArgList &Args) {
2439 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2441 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2443 RuntimeName = A->getValue();
2445 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
2446 .Case(
"libomp", OMPRT_OMP)
2447 .Case(
"libgomp", OMPRT_GOMP)
2448 .Case(
"libiomp5", OMPRT_IOMP5)
2449 .Default(OMPRT_Unknown);
2451 if (RT == OMPRT_Unknown) {
2453 TC.
getDriver().
Diag(diag::err_drv_unsupported_option_argument)
2454 << A->getOption().getName() << A->getValue();
2457 TC.
getDriver().
Diag(diag::err_drv_unsupported_opt) <<
"-fopenmp";
2464 ArgStringList &CmdArgs, StringRef Sanitizer,
2469 CmdArgs.push_back(
"-whole-archive");
2470 CmdArgs.push_back(Args.MakeArgString(
getCompilerRT(TC, Sanitizer, IsShared)));
2472 CmdArgs.push_back(
"-no-whole-archive");
2478 ArgStringList &CmdArgs,
2479 StringRef Sanitizer) {
2481 if (llvm::sys::fs::exists(SanRT +
".syms")) {
2482 CmdArgs.push_back(Args.MakeArgString(
"--dynamic-list=" + SanRT +
".syms"));
2489 ArgStringList &CmdArgs) {
2492 CmdArgs.push_back(
"--no-as-needed");
2493 CmdArgs.push_back(
"-lpthread");
2494 CmdArgs.push_back(
"-lrt");
2495 CmdArgs.push_back(
"-lm");
2497 if (TC.
getTriple().getOS() != llvm::Triple::FreeBSD)
2498 CmdArgs.push_back(
"-ldl");
2509 SharedRuntimes.push_back(
"asan");
2513 if (Args.hasArg(options::OPT_shared) ||
2514 (TC.
getTriple().getEnvironment() == llvm::Triple::Android)) {
2520 HelperStaticRuntimes.push_back(
"asan-preinit");
2522 StaticRuntimes.push_back(
"asan");
2524 StaticRuntimes.push_back(
"asan_cxx");
2528 StaticRuntimes.push_back(
"dfsan");
2530 StaticRuntimes.push_back(
"lsan");
2532 StaticRuntimes.push_back(
"msan");
2534 StaticRuntimes.push_back(
"msan_cxx");
2537 StaticRuntimes.push_back(
"tsan");
2539 StaticRuntimes.push_back(
"tsan_cxx");
2542 StaticRuntimes.push_back(
"ubsan_standalone");
2544 StaticRuntimes.push_back(
"ubsan_standalone_cxx");
2547 StaticRuntimes.push_back(
"safestack");
2553 ArgStringList &CmdArgs) {
2555 HelperStaticRuntimes;
2557 HelperStaticRuntimes);
2558 for (
auto RT : SharedRuntimes)
2560 for (
auto RT : HelperStaticRuntimes)
2562 bool AddExportDynamic =
false;
2563 for (
auto RT : StaticRuntimes) {
2569 if (AddExportDynamic)
2570 CmdArgs.push_back(
"-export-dynamic");
2571 return !StaticRuntimes.empty();
2576 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2577 return !A->getOption().matches(options::OPT_O0);
2583 const llvm::Triple &Triple) {
2585 if (Triple.getArch() == llvm::Triple::xcore) {
2589 if (Triple.isOSLinux()) {
2590 switch (Triple.getArch()) {
2592 case llvm::Triple::mips64:
2593 case llvm::Triple::mips64el:
2594 case llvm::Triple::mips:
2595 case llvm::Triple::mipsel:
2596 case llvm::Triple::systemz:
2597 case llvm::Triple::x86:
2598 case llvm::Triple::x86_64:
2605 if (Triple.isOSWindows()) {
2606 switch (Triple.getArch()) {
2607 case llvm::Triple::x86:
2620 const llvm::Triple &Triple) {
2621 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2622 options::OPT_fomit_frame_pointer))
2623 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2629 const llvm::Triple &Triple) {
2630 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2631 options::OPT_momit_leaf_frame_pointer))
2632 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2634 if (Triple.isPS4CPU())
2643 if (!llvm::sys::fs::current_path(cwd)) {
2644 CmdArgs.push_back(
"-fdebug-compilation-dir");
2645 CmdArgs.push_back(Args.MakeArgString(cwd));
2650 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2651 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2653 llvm::sys::path::replace_extension(T,
"dwo");
2654 return Args.MakeArgString(T);
2658 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2660 llvm::sys::path::replace_extension(F,
"dwo");
2662 return Args.MakeArgString(F);
2667 const JobAction &JA,
const ArgList &Args,
2668 const InputInfo &Output,
const char *OutFile) {
2669 ArgStringList ExtractArgs;
2670 ExtractArgs.push_back(
"--extract-dwo");
2672 ArgStringList StripArgs;
2673 StripArgs.push_back(
"--strip-dwo");
2678 ExtractArgs.push_back(OutFile);
2680 const char *Exec = Args.MakeArgString(TC.
GetProgramPath(
"objcopy"));
2683 C.
addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
2686 C.
addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
2692 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2693 if (A->getOption().matches(options::OPT_O4) ||
2694 A->getOption().matches(options::OPT_Ofast))
2697 if (A->getOption().matches(options::OPT_O0))
2700 assert(A->getOption().matches(options::OPT_O) &&
"Must have a -O flag");
2703 StringRef
S(A->getValue());
2711 unsigned OptLevel = 0;
2712 if (
S.getAsInteger(10, OptLevel))
2715 return OptLevel > 1;
2723 ArgStringList &CmdArgs) {
2726 if (Args.hasArg(options::OPT_verify_pch) && Input.
getType() == types::TY_PCH)
2729 CmdArgs.push_back(
"-x");
2730 if (Args.hasArg(options::OPT_rewrite_objc))
2740 if (Version < 10000)
2743 unsigned Build = 0, Factor = 1;
2744 for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2745 Build = Build + (Version % 10) * Factor;
2746 return VersionTuple(Version / 100, Version % 100, Build);
2755 Args.ClaimAllArgs(options::OPT_flto);
2756 Args.ClaimAllArgs(options::OPT_fno_lto);
2761 const char *Username = getenv(
"LOGNAME");
2763 const char *Username = getenv(
"USERNAME");
2768 for (
const char *P = Username; *
P; ++
P, ++Len) {
2775 if (Username && Len > 0) {
2776 Result.append(Username, Username + Len);
2783 std::string UID = llvm::utostr(getuid());
2786 std::string UID =
"9999";
2788 Result.append(UID.begin(), UID.end());
2792 const llvm::Triple &Triple,
2793 const llvm::opt::ArgList &Args,
2794 bool IsWindowsMSVC) {
2795 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2797 Args.hasArg(options::OPT_fmsc_version) ||
2798 Args.hasArg(options::OPT_fms_compatibility_version)) {
2799 const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2800 const Arg *MSCompatibilityVersion =
2801 Args.getLastArg(options::OPT_fms_compatibility_version);
2803 if (MSCVersion && MSCompatibilityVersion) {
2805 D->
Diag(diag::err_drv_argument_not_allowed_with)
2806 << MSCVersion->getAsString(Args)
2807 << MSCompatibilityVersion->getAsString(Args);
2811 if (MSCompatibilityVersion) {
2813 if (MSVT.
tryParse(MSCompatibilityVersion->getValue()) && D)
2814 D->
Diag(diag::err_drv_invalid_value)
2815 << MSCompatibilityVersion->getAsString(Args)
2816 << MSCompatibilityVersion->getValue();
2821 unsigned Version = 0;
2822 if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2823 D->
Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2824 << MSCVersion->getValue();
2828 unsigned Major, Minor, Micro;
2829 Triple.getEnvironmentVersion(Major, Minor, Micro);
2830 if (Major || Minor || Micro)
2839 const InputInfo &Output,
const ArgList &Args,
2840 ArgStringList &CmdArgs) {
2841 auto *ProfileGenerateArg = Args.getLastArg(
2842 options::OPT_fprofile_instr_generate,
2843 options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
2844 options::OPT_fprofile_generate_EQ);
2846 auto *ProfileUseArg = Args.getLastArg(
2847 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
2848 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ);
2850 if (ProfileGenerateArg && ProfileUseArg)
2851 D.
Diag(diag::err_drv_argument_not_allowed_with)
2852 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
2854 if (ProfileGenerateArg &&
2855 ProfileGenerateArg->getOption().matches(
2856 options::OPT_fprofile_instr_generate_EQ))
2857 ProfileGenerateArg->render(Args, CmdArgs);
2858 else if (ProfileGenerateArg &&
2859 ProfileGenerateArg->getOption().matches(
2860 options::OPT_fprofile_generate_EQ)) {
2862 llvm::sys::path::append(Path,
"default.profraw");
2864 Args.MakeArgString(Twine(
"-fprofile-instr-generate=") + Path));
2866 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2868 if (ProfileUseArg &&
2869 ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
2870 ProfileUseArg->render(Args, CmdArgs);
2871 else if (ProfileUseArg &&
2872 (ProfileUseArg->getOption().matches(options::OPT_fprofile_use_EQ) ||
2873 ProfileUseArg->getOption().matches(
2874 options::OPT_fprofile_instr_use))) {
2876 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
2877 if (Path.empty() || llvm::sys::fs::is_directory(Path))
2878 llvm::sys::path::append(Path,
"default.profdata");
2879 CmdArgs.push_back(Args.MakeArgString(Twine(
"-fprofile-instr-use=") + Path));
2882 if (Args.hasArg(options::OPT_ftest_coverage) ||
2883 Args.hasArg(options::OPT_coverage))
2884 CmdArgs.push_back(
"-femit-coverage-notes");
2885 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2887 Args.hasArg(options::OPT_coverage))
2888 CmdArgs.push_back(
"-femit-coverage-data");
2890 if (Args.hasArg(options::OPT_fcoverage_mapping) && !ProfileGenerateArg)
2891 D.
Diag(diag::err_drv_argument_only_allowed_with)
2892 <<
"-fcoverage-mapping"
2893 <<
"-fprofile-instr-generate";
2895 if (Args.hasArg(options::OPT_fcoverage_mapping))
2896 CmdArgs.push_back(
"-fcoverage-mapping");
2898 if (C.
getArgs().hasArg(options::OPT_c) ||
2899 C.
getArgs().hasArg(options::OPT_S)) {
2901 CmdArgs.push_back(
"-coverage-file");
2903 if (Arg *FinalOutput = C.
getArgs().getLastArg(options::OPT_o)) {
2904 CoverageFilename = FinalOutput->getValue();
2906 CoverageFilename = llvm::sys::path::filename(Output.
getBaseInput());
2908 if (llvm::sys::path::is_relative(CoverageFilename)) {
2910 if (!llvm::sys::fs::current_path(Pwd)) {
2911 llvm::sys::path::append(Pwd, CoverageFilename);
2912 CoverageFilename.swap(Pwd);
2915 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2922 const ArgList &Args,
const char *LinkingOutput)
const {
2924 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
2925 const Driver &D = getToolChain().getDriver();
2926 ArgStringList CmdArgs;
2928 bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
2929 bool IsWindowsCygnus =
2930 getToolChain().getTriple().isWindowsCygwinEnvironment();
2931 bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2934 assert(Inputs.size() >= 1 &&
"Must have at least one input.");
2940 assert((IsCuda || Inputs.size() == 1) &&
"Unable to handle multiple inputs.");
2945 CmdArgs.push_back(
"-cc1");
2948 CmdArgs.push_back(
"-triple");
2949 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2950 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2952 const llvm::Triple TT(TripleStr);
2953 if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2954 TT.getArch() == llvm::Triple::thumb)) {
2955 unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2957 TT.getArchName().substr(Offset).getAsInteger(10, Version);
2959 D.
Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2966 getToolChain().addClangWarningOptions(CmdArgs);
2969 RewriteKind rewriteKind = RK_None;
2971 if (isa<AnalyzeJobAction>(JA)) {
2972 assert(JA.
getType() == types::TY_Plist &&
"Invalid output type.");
2973 CmdArgs.push_back(
"-analyze");
2974 }
else if (isa<MigrateJobAction>(JA)) {
2975 CmdArgs.push_back(
"-migrate");
2976 }
else if (isa<PreprocessJobAction>(JA)) {
2977 if (Output.
getType() == types::TY_Dependencies)
2978 CmdArgs.push_back(
"-Eonly");
2980 CmdArgs.push_back(
"-E");
2981 if (Args.hasArg(options::OPT_rewrite_objc) &&
2982 !Args.hasArg(options::OPT_g_Group))
2983 CmdArgs.push_back(
"-P");
2985 }
else if (isa<AssembleJobAction>(JA)) {
2986 CmdArgs.push_back(
"-emit-obj");
2991 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
2992 }
else if (isa<PrecompileJobAction>(JA)) {
2996 if (JA.
getType() == types::TY_Nothing)
2997 CmdArgs.push_back(
"-fsyntax-only");
2999 CmdArgs.push_back(
"-emit-pch");
3001 CmdArgs.push_back(
"-emit-pth");
3002 }
else if (isa<VerifyPCHJobAction>(JA)) {
3003 CmdArgs.push_back(
"-verify-pch");
3005 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
3006 "Invalid action for clang tool.");
3008 if (JA.
getType() == types::TY_LTO_IR || JA.
getType() == types::TY_LTO_BC) {
3009 CmdArgs.push_back(
"-flto");
3011 if (JA.
getType() == types::TY_Nothing) {
3012 CmdArgs.push_back(
"-fsyntax-only");
3013 }
else if (JA.
getType() == types::TY_LLVM_IR ||
3014 JA.
getType() == types::TY_LTO_IR) {
3015 CmdArgs.push_back(
"-emit-llvm");
3016 }
else if (JA.
getType() == types::TY_LLVM_BC ||
3017 JA.
getType() == types::TY_LTO_BC) {
3018 CmdArgs.push_back(
"-emit-llvm-bc");
3019 }
else if (JA.
getType() == types::TY_PP_Asm) {
3020 CmdArgs.push_back(
"-S");
3021 }
else if (JA.
getType() == types::TY_AST) {
3022 CmdArgs.push_back(
"-emit-pch");
3023 }
else if (JA.
getType() == types::TY_ModuleFile) {
3024 CmdArgs.push_back(
"-module-file-info");
3025 }
else if (JA.
getType() == types::TY_RewrittenObjC) {
3026 CmdArgs.push_back(
"-rewrite-objc");
3027 rewriteKind = RK_NonFragile;
3028 }
else if (JA.
getType() == types::TY_RewrittenLegacyObjC) {
3029 CmdArgs.push_back(
"-rewrite-objc");
3030 rewriteKind = RK_Fragile;
3032 assert(JA.
getType() == types::TY_PP_Asm &&
"Unexpected output type!");
3039 if (JA.
getType() == types::TY_LLVM_BC)
3040 CmdArgs.push_back(
"-emit-llvm-uselists");
3047 CmdArgs.push_back(
"-disable-free");
3051 CmdArgs.push_back(
"-disable-llvm-verifier");
3056 CmdArgs.push_back(
"-main-file-name");
3057 CmdArgs.push_back(getBaseInputName(Args, Input));
3061 if (Args.hasArg(options::OPT_static))
3062 CmdArgs.push_back(
"-static-define");
3064 if (isa<AnalyzeJobAction>(JA)) {
3066 CmdArgs.push_back(
"-analyzer-store=region");
3069 CmdArgs.push_back(
"-analyzer-opt-analyze-nested-blocks");
3071 CmdArgs.push_back(
"-analyzer-eagerly-assume");
3074 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
3075 CmdArgs.push_back(
"-analyzer-checker=core");
3078 CmdArgs.push_back(
"-analyzer-checker=unix");
3080 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
3081 CmdArgs.push_back(
"-analyzer-checker=osx");
3083 CmdArgs.push_back(
"-analyzer-checker=deadcode");
3086 CmdArgs.push_back(
"-analyzer-checker=cplusplus");
3090 "-analyzer-checker=security.insecureAPI.UncheckedReturn");
3091 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.getpw");
3092 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.gets");
3093 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mktemp");
3094 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.mkstemp");
3095 CmdArgs.push_back(
"-analyzer-checker=security.insecureAPI.vfork");
3100 CmdArgs.push_back(
"-analyzer-output");
3101 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3102 CmdArgs.push_back(A->getValue());
3104 CmdArgs.push_back(
"plist");
3109 CmdArgs.push_back(
"-w");
3112 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3117 bool PIE = getToolChain().isPIEDefault();
3118 bool PIC = PIE || getToolChain().isPICDefault();
3119 bool IsPICLevelTwo = PIC;
3122 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
3123 switch (getToolChain().getArch()) {
3124 case llvm::Triple::arm:
3125 case llvm::Triple::armeb:
3126 case llvm::Triple::thumb:
3127 case llvm::Triple::thumbeb:
3128 case llvm::Triple::aarch64:
3129 case llvm::Triple::mips:
3130 case llvm::Triple::mipsel:
3131 case llvm::Triple::mips64:
3132 case llvm::Triple::mips64el:
3136 case llvm::Triple::x86:
3137 case llvm::Triple::x86_64:
3139 IsPICLevelTwo =
true;
3148 if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
3149 switch (getToolChain().getArch()) {
3150 case llvm::Triple::mips64:
3151 case llvm::Triple::mips64el:
3152 case llvm::Triple::sparcel:
3153 case llvm::Triple::x86:
3154 case llvm::Triple::x86_64:
3155 IsPICLevelTwo =
false;
3158 case llvm::Triple::ppc:
3159 case llvm::Triple::sparc:
3160 case llvm::Triple::sparcv9:
3161 IsPICLevelTwo =
true;
3177 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3178 options::OPT_fpic, options::OPT_fno_pic,
3179 options::OPT_fPIE, options::OPT_fno_PIE,
3180 options::OPT_fpie, options::OPT_fno_pie);
3183 if (!getToolChain().isPICDefaultForced()) {
3185 Option O = LastPICArg->getOption();
3186 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3187 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3188 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3190 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3192 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3203 if (PIC && getToolChain().getTriple().isOSDarwin())
3204 IsPICLevelTwo |= getToolChain().isPICDefault();
3208 llvm::Triple Triple(TripleStr);
3209 if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
3211 if (Args.hasArg(options::OPT_static))
3214 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3217 if (!getToolChain().getTriple().isOSDarwin())
3218 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3219 << A->getSpelling() << getToolChain().getTriple().str();
3223 CmdArgs.push_back(
"-mrelocation-model");
3224 CmdArgs.push_back(
"dynamic-no-pic");
3229 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
3230 CmdArgs.push_back(
"-pic-level");
3231 CmdArgs.push_back(
"2");
3236 CmdArgs.push_back(
"-mrelocation-model");
3237 CmdArgs.push_back(PIC ?
"pic" :
"static");
3240 CmdArgs.push_back(
"-pic-level");
3241 CmdArgs.push_back(IsPICLevelTwo ?
"2" :
"1");
3243 CmdArgs.push_back(
"-pie-level");
3244 CmdArgs.push_back(IsPICLevelTwo ?
"2" :
"1");
3249 CmdArgs.push_back(
"-mthread-model");
3250 if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3251 CmdArgs.push_back(A->getValue());
3253 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3255 Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3257 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3258 options::OPT_fno_merge_all_constants))
3259 CmdArgs.push_back(
"-fno-merge-all-constants");
3263 if (Args.hasArg(options::OPT_frewrite_map_file) ||
3264 Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
3265 for (
const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3266 options::OPT_frewrite_map_file_EQ)) {
3267 CmdArgs.push_back(
"-frewrite-map-file");
3268 CmdArgs.push_back(A->getValue());
3273 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3274 StringRef v = A->getValue();
3275 CmdArgs.push_back(
"-mllvm");
3276 CmdArgs.push_back(Args.MakeArgString(
"-warn-stack-size=" + v));
3280 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3281 CmdArgs.push_back(
"-mregparm");
3282 CmdArgs.push_back(A->getValue());
3285 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3286 options::OPT_freg_struct_return)) {
3287 if (getToolChain().getArch() != llvm::Triple::x86) {
3288 D.
Diag(diag::err_drv_unsupported_opt_for_target)
3289 << A->getSpelling() << getToolChain().getTriple().str();
3290 }
else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3291 CmdArgs.push_back(
"-fpcc-struct-return");
3293 assert(A->getOption().matches(options::OPT_freg_struct_return));
3294 CmdArgs.push_back(
"-freg-struct-return");
3298 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd,
false))
3299 CmdArgs.push_back(
"-mrtd");
3302 CmdArgs.push_back(
"-mdisable-fp-elim");
3303 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3304 options::OPT_fno_zero_initialized_in_bss))
3305 CmdArgs.push_back(
"-mno-zero-initialized-in-bss");
3310 OptSpecifier StrictAliasingAliasOption =
3311 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
3314 bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
3315 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
3316 options::OPT_fno_strict_aliasing, TBAAOnByDefault))
3317 CmdArgs.push_back(
"-relaxed-aliasing");
3318 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3319 options::OPT_fno_struct_path_tbaa))
3320 CmdArgs.push_back(
"-no-struct-path-tbaa");
3321 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3323 CmdArgs.push_back(
"-fstrict-enums");
3324 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3325 options::OPT_fno_optimize_sibling_calls))
3326 CmdArgs.push_back(
"-mdisable-tail-calls");
3329 if (Args.hasArg(options::OPT_fsplit_stack))
3330 CmdArgs.push_back(
"-split-stacks");
3334 OptSpecifier FastMathAliasOption =
3335 OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
3342 if (Arg *A = Args.getLastArg(
3343 options::OPT_ffast_math, FastMathAliasOption,
3344 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3345 options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
3346 options::OPT_fno_honor_infinities))
3347 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3348 A->getOption().getID() != options::OPT_fno_finite_math_only &&
3349 A->getOption().getID() != options::OPT_fhonor_infinities)
3350 CmdArgs.push_back(
"-menable-no-infs");
3351 if (Arg *A = Args.getLastArg(
3352 options::OPT_ffast_math, FastMathAliasOption,
3353 options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3354 options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
3355 options::OPT_fno_honor_nans))
3356 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3357 A->getOption().getID() != options::OPT_fno_finite_math_only &&
3358 A->getOption().getID() != options::OPT_fhonor_nans)
3359 CmdArgs.push_back(
"-menable-no-nans");
3362 bool MathErrno = getToolChain().IsMathErrnoDefault();
3364 Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3365 options::OPT_fno_fast_math, options::OPT_fmath_errno,
3366 options::OPT_fno_math_errno)) {
3370 if (A->getOption().getID() == options::OPT_fno_math_errno ||
3371 A->getOption().getID() == options::OPT_ffast_math ||
3372 A->getOption().getID() == options::OPT_Ofast)
3374 else if (A->getOption().getID() == options::OPT_fmath_errno)
3378 CmdArgs.push_back(
"-fmath-errno");
3384 bool AssociativeMath =
false;
3385 if (Arg *A = Args.getLastArg(
3386 options::OPT_ffast_math, FastMathAliasOption,
3387 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3388 options::OPT_fno_unsafe_math_optimizations,
3389 options::OPT_fassociative_math, options::OPT_fno_associative_math))
3390 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3391 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3392 A->getOption().getID() != options::OPT_fno_associative_math)
3393 AssociativeMath =
true;
3394 bool ReciprocalMath =
false;
3395 if (Arg *A = Args.getLastArg(
3396 options::OPT_ffast_math, FastMathAliasOption,
3397 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3398 options::OPT_fno_unsafe_math_optimizations,
3399 options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
3400 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3401 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3402 A->getOption().getID() != options::OPT_fno_reciprocal_math)
3403 ReciprocalMath =
true;
3404 bool SignedZeros =
true;
3405 if (Arg *A = Args.getLastArg(
3406 options::OPT_ffast_math, FastMathAliasOption,
3407 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3408 options::OPT_fno_unsafe_math_optimizations,
3409 options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
3410 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3411 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3412 A->getOption().getID() != options::OPT_fsigned_zeros)
3413 SignedZeros =
false;
3414 bool TrappingMath =
true;
3415 if (Arg *A = Args.getLastArg(
3416 options::OPT_ffast_math, FastMathAliasOption,
3417 options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3418 options::OPT_fno_unsafe_math_optimizations,
3419 options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
3420 if (A->getOption().getID() != options::OPT_fno_fast_math &&
3421 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3422 A->getOption().getID() != options::OPT_ftrapping_math)
3423 TrappingMath =
false;
3424 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3426 CmdArgs.push_back(
"-menable-unsafe-fp-math");
3429 CmdArgs.push_back(
"-fno-signed-zeros");
3432 CmdArgs.push_back(
"-freciprocal-math");
3435 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3436 options::OPT_fno_fast_math,
3437 options::OPT_ffp_contract)) {
3438 if (A->getOption().getID() == options::OPT_ffp_contract) {
3439 StringRef Val = A->getValue();
3440 if (Val ==
"fast" || Val ==
"on" || Val ==
"off") {
3441 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=" + Val));
3443 D.
Diag(diag::err_drv_unsupported_option_argument)
3444 << A->getOption().getName() << Val;
3446 }
else if (A->getOption().matches(options::OPT_ffast_math) ||
3447 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
3449 CmdArgs.push_back(Args.MakeArgString(
"-ffp-contract=fast"));
3453 ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
3460 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3461 options::OPT_fno_fast_math))
3462 if (!A->getOption().matches(options::OPT_fno_fast_math))
3463 CmdArgs.push_back(
"-ffast-math");
3464 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3465 options::OPT_fno_fast_math))
3466 if (A->getOption().matches(options::OPT_ffinite_math_only))
3467 CmdArgs.push_back(
"-ffinite-math-only");
3471 bool IsIntegratedAssemblerDefault =
3472 getToolChain().IsIntegratedAssemblerDefault();
3473 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
3474 IsIntegratedAssemblerDefault) ||
3475 Args.hasArg(options::OPT_dA))
3476 CmdArgs.push_back(
"-masm-verbose");
3478 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3479 IsIntegratedAssemblerDefault))
3480 CmdArgs.push_back(
"-no-integrated-as");
3482 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3483 CmdArgs.push_back(
"-mdebug-pass");
3484 CmdArgs.push_back(
"Structure");
3486 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3487 CmdArgs.push_back(
"-mdebug-pass");
3488 CmdArgs.push_back(
"Arguments");
3493 if (!getToolChain().getTriple().isOSDarwin())
3494 CmdArgs.push_back(
"-mconstructor-aliases");
3498 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
3499 CmdArgs.push_back(
"-fforbid-guard-variables");
3501 if (Args.hasArg(options::OPT_mms_bitfields)) {
3502 CmdArgs.push_back(
"-mms-bitfields");
3508 bool AsynchronousUnwindTables =
3509 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3510 options::OPT_fno_asynchronous_unwind_tables,
3511 (getToolChain().IsUnwindTablesDefault() ||
3512 getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3514 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3515 AsynchronousUnwindTables))
3516 CmdArgs.push_back(
"-munwind-tables");
3518 getToolChain().addClangTargetOptions(Args, CmdArgs);
3520 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3521 CmdArgs.push_back(
"-mlimit-float-precision");
3522 CmdArgs.push_back(A->getValue());
3526 (void)Args.hasArg(options::OPT_mtune_EQ);
3528 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
3529 CmdArgs.push_back(
"-mcode-model");
3530 CmdArgs.push_back(A->getValue());
3534 std::string CPU =
getCPUName(Args, Triple,
false);
3536 CmdArgs.push_back(
"-target-cpu");
3537 CmdArgs.push_back(Args.MakeArgString(CPU));
3540 if (
const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3541 CmdArgs.push_back(
"-mfpmath");
3542 CmdArgs.push_back(A->getValue());
3549 switch (getToolChain().getArch()) {
3553 case llvm::Triple::arm:
3554 case llvm::Triple::armeb:
3555 case llvm::Triple::thumb:
3556 case llvm::Triple::thumbeb:
3557 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
3560 case llvm::Triple::aarch64:
3561 case llvm::Triple::aarch64_be:
3562 AddAArch64TargetArgs(Args, CmdArgs);
3565 case llvm::Triple::mips:
3566 case llvm::Triple::mipsel:
3567 case llvm::Triple::mips64:
3568 case llvm::Triple::mips64el:
3569 AddMIPSTargetArgs(Args, CmdArgs);
3572 case llvm::Triple::ppc:
3573 case llvm::Triple::ppc64:
3574 case llvm::Triple::ppc64le:
3575 AddPPCTargetArgs(Args, CmdArgs);
3578 case llvm::Triple::sparc:
3579 case llvm::Triple::sparcel:
3580 case llvm::Triple::sparcv9:
3581 AddSparcTargetArgs(Args, CmdArgs);
3584 case llvm::Triple::x86:
3585 case llvm::Triple::x86_64:
3586 AddX86TargetArgs(Args, CmdArgs);
3589 case llvm::Triple::hexagon:
3590 AddHexagonTargetArgs(Args, CmdArgs);
3595 if (getToolChain().getDriver().IsCLMode())
3596 AddClangCLArgs(Args, CmdArgs);
3599 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3600 CmdArgs.push_back(
"-target-linker-version");
3601 CmdArgs.push_back(A->getValue());
3605 CmdArgs.push_back(
"-momit-leaf-frame-pointer");
3610 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3612 if (
types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
3613 getToolChain().getArch() == llvm::Triple::x86) {
3614 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3615 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
3616 D.
Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
3617 << Unsupported->getOption().getName();
3621 Args.AddAllArgs(CmdArgs, options::OPT_v);
3622 Args.AddLastArg(CmdArgs, options::OPT_H);
3624 CmdArgs.push_back(
"-header-include-file");
3628 Args.AddLastArg(CmdArgs, options::OPT_P);
3629 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
3632 CmdArgs.push_back(
"-diagnostic-log-file");
3639 Args.ClaimAllArgs(options::OPT_g_Group);
3640 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
3641 if (A->getOption().matches(options::OPT_gline_tables_only) ||
3642 A->getOption().matches(options::OPT_g1)) {
3645 CmdArgs.push_back(
"-gline-tables-only");
3647 const llvm::Triple &Triple = getToolChain().getTriple();
3648 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3649 Triple.getOS() == llvm::Triple::FreeBSD ||
3650 Triple.getOS() == llvm::Triple::Solaris)
3651 CmdArgs.push_back(
"-gdwarf-2");
3652 }
else if (A->getOption().matches(options::OPT_gdwarf_2))
3653 CmdArgs.push_back(
"-gdwarf-2");
3654 else if (A->getOption().matches(options::OPT_gdwarf_3))
3655 CmdArgs.push_back(
"-gdwarf-3");
3656 else if (A->getOption().matches(options::OPT_gdwarf_4))
3657 CmdArgs.push_back(
"-gdwarf-4");
3658 else if (!A->getOption().matches(options::OPT_g0) &&
3659 !A->getOption().matches(options::OPT_ggdb0)) {
3661 const llvm::Triple &Triple = getToolChain().getTriple();
3662 if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3663 Triple.getOS() == llvm::Triple::FreeBSD ||
3664 Triple.getOS() == llvm::Triple::Solaris)
3665 CmdArgs.push_back(
"-gdwarf-2");
3667 CmdArgs.push_back(
"-g");
3672 Args.ClaimAllArgs(options::OPT_g_flags_Group);
3673 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3675 CmdArgs.push_back(
"-dwarf-column-info");
3681 if (getToolChain().getTriple().isOSLinux() &&
3682 Args.hasArg(options::OPT_gsplit_dwarf)) {
3683 CmdArgs.push_back(
"-g");
3684 CmdArgs.push_back(
"-backend-option");
3685 CmdArgs.push_back(
"-split-dwarf=Enable");
3689 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3690 CmdArgs.push_back(
"-backend-option");
3691 CmdArgs.push_back(
"-generate-gnu-dwarf-pub-sections");
3696 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3697 CmdArgs.push_back(
"-backend-option");
3698 CmdArgs.push_back(
"-generate-arange-section");
3701 if (Args.hasFlag(options::OPT_fdebug_types_section,
3702 options::OPT_fno_debug_types_section,
false)) {
3703 CmdArgs.push_back(
"-backend-option");
3704 CmdArgs.push_back(
"-generate-type-units");
3708 bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3710 if (Args.hasFlag(options::OPT_ffunction_sections,
3711 options::OPT_fno_function_sections, UseSeparateSections)) {
3712 CmdArgs.push_back(
"-ffunction-sections");
3715 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
3716 UseSeparateSections)) {
3717 CmdArgs.push_back(
"-fdata-sections");
3720 if (!Args.hasFlag(options::OPT_funique_section_names,
3721 options::OPT_fno_unique_section_names,
true))
3722 CmdArgs.push_back(
"-fno-unique-section-names");
3724 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3729 if (Args.hasArg(options::OPT_nostdinc)) {
3730 CmdArgs.push_back(
"-nostdsysteminc");
3731 CmdArgs.push_back(
"-nobuiltininc");
3733 if (Args.hasArg(options::OPT_nostdlibinc))
3734 CmdArgs.push_back(
"-nostdsysteminc");
3735 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3736 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3740 CmdArgs.push_back(
"-resource-dir");
3743 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3745 bool ARCMTEnabled =
false;
3746 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3747 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3748 options::OPT_ccc_arcmt_modify,
3749 options::OPT_ccc_arcmt_migrate)) {
3750 ARCMTEnabled =
true;
3751 switch (A->getOption().getID()) {
3753 llvm_unreachable(
"missed a case");
3754 case options::OPT_ccc_arcmt_check:
3755 CmdArgs.push_back(
"-arcmt-check");
3757 case options::OPT_ccc_arcmt_modify:
3758 CmdArgs.push_back(
"-arcmt-modify");
3760 case options::OPT_ccc_arcmt_migrate:
3761 CmdArgs.push_back(
"-arcmt-migrate");
3762 CmdArgs.push_back(
"-mt-migrate-directory");
3763 CmdArgs.push_back(A->getValue());
3765 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3766 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3771 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3772 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3773 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3776 if (
const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3778 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
3779 <<
"-ccc-arcmt-migrate";
3781 CmdArgs.push_back(
"-mt-migrate-directory");
3782 CmdArgs.push_back(A->getValue());
3784 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3785 options::OPT_objcmt_migrate_subscripting,
3786 options::OPT_objcmt_migrate_property)) {
3788 CmdArgs.push_back(
"-objcmt-migrate-literals");
3789 CmdArgs.push_back(
"-objcmt-migrate-subscripting");
3790 CmdArgs.push_back(
"-objcmt-migrate-property");
3792 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3793 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3794 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3797 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3798 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3799 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3800 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3801 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3802 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3803 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3804 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3805 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3806 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3807 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3808 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3809 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3810 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3811 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3812 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
3820 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
3826 Args.ClaimAllArgs(options::OPT_D);
3829 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3830 if (A->getOption().matches(options::OPT_O4)) {
3831 CmdArgs.push_back(
"-O3");
3832 D.
Diag(diag::warn_O4_is_O3);
3834 A->render(Args, CmdArgs);
3840 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3841 D.
Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
3846 Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
3847 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
3848 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic,
false))
3849 CmdArgs.push_back(
"-pedantic");
3850 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
3851 Args.AddLastArg(CmdArgs, options::OPT_w);
3858 bool ImplyVCPPCXXVer =
false;
3859 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3860 if (Std->getOption().matches(options::OPT_ansi))
3862 CmdArgs.push_back(
"-std=c++98");
3864 CmdArgs.push_back(
"-std=c89");
3866 Std->render(Args, CmdArgs);
3869 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3870 options::OPT_ftrigraphs,
3871 options::OPT_fno_trigraphs))
3873 A->render(Args, CmdArgs);
3882 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
"-std=",
3884 else if (IsWindowsMSVC)
3885 ImplyVCPPCXXVer =
true;
3887 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3888 options::OPT_fno_trigraphs);
3904 Args.getLastArg(options::OPT_Wwrite_strings,
3905 options::OPT_Wno_write_strings, options::OPT_w);
3907 WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
3908 CmdArgs.push_back(
"-fconst-strings");
3915 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3917 CmdArgs.push_back(
"-fdeprecated-macro");
3921 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3922 if (Asm->getOption().matches(options::OPT_fasm))
3923 CmdArgs.push_back(
"-fgnu-keywords");
3925 CmdArgs.push_back(
"-fno-gnu-keywords");
3929 CmdArgs.push_back(
"-fno-dwarf-directory-asm");
3932 CmdArgs.push_back(
"-fno-autolink");
3937 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3938 options::OPT_ftemplate_depth_EQ)) {
3939 CmdArgs.push_back(
"-ftemplate-depth");
3940 CmdArgs.push_back(A->getValue());
3943 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3944 CmdArgs.push_back(
"-foperator-arrow-depth");
3945 CmdArgs.push_back(A->getValue());
3948 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3949 CmdArgs.push_back(
"-fconstexpr-depth");
3950 CmdArgs.push_back(A->getValue());
3953 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3954 CmdArgs.push_back(
"-fconstexpr-steps");
3955 CmdArgs.push_back(A->getValue());
3958 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3959 CmdArgs.push_back(
"-fbracket-depth");
3960 CmdArgs.push_back(A->getValue());
3963 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3964 options::OPT_Wlarge_by_value_copy_def)) {
3965 if (A->getNumValues()) {
3966 StringRef
bytes = A->getValue();
3967 CmdArgs.push_back(Args.MakeArgString(
"-Wlarge-by-value-copy=" + bytes));
3969 CmdArgs.push_back(
"-Wlarge-by-value-copy=64");
3972 if (Args.hasArg(options::OPT_relocatable_pch))
3973 CmdArgs.push_back(
"-relocatable-pch");
3975 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3976 CmdArgs.push_back(
"-fconstant-string-class");
3977 CmdArgs.push_back(A->getValue());
3980 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3981 CmdArgs.push_back(
"-ftabstop");
3982 CmdArgs.push_back(A->getValue());
3985 CmdArgs.push_back(
"-ferror-limit");
3986 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
3987 CmdArgs.push_back(A->getValue());
3989 CmdArgs.push_back(
"19");
3991 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3992 CmdArgs.push_back(
"-fmacro-backtrace-limit");
3993 CmdArgs.push_back(A->getValue());
3996 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3997 CmdArgs.push_back(
"-ftemplate-backtrace-limit");
3998 CmdArgs.push_back(A->getValue());
4001 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4002 CmdArgs.push_back(
"-fconstexpr-backtrace-limit");
4003 CmdArgs.push_back(A->getValue());
4006 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4007 CmdArgs.push_back(
"-fspell-checking-limit");
4008 CmdArgs.push_back(A->getValue());
4012 CmdArgs.push_back(
"-fmessage-length");
4013 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
4014 CmdArgs.push_back(A->getValue());
4018 unsigned N = llvm::sys::Process::StandardErrColumns();
4019 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
4023 if (
const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4024 options::OPT_fvisibility_ms_compat)) {
4025 if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4026 CmdArgs.push_back(
"-fvisibility");
4027 CmdArgs.push_back(A->getValue());
4029 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4030 CmdArgs.push_back(
"-fvisibility");
4031 CmdArgs.push_back(
"hidden");
4032 CmdArgs.push_back(
"-ftype-visibility");
4033 CmdArgs.push_back(
"default");
4037 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
4039 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
4042 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted,
false) ||
4044 CmdArgs.push_back(
"-ffreestanding");
4047 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
4048 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
4049 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
4050 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
4051 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
4053 if (!isa<PreprocessJobAction>(JA) || Output.
getType() != types::TY_PP_Asm) {
4054 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
4055 Args.AddLastArg(CmdArgs, options::OPT_fzvector);
4057 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
4058 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
4061 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
4062 options::OPT_fno_openmp,
false))
4067 CmdArgs.push_back(
"-fopenmp");
4072 if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
4073 options::OPT_fnoopenmp_use_tls,
4074 getToolChain().getArch() == llvm::Triple::ppc ||
4075 getToolChain().getArch() == llvm::Triple::ppc64 ||
4076 getToolChain().getArch() == llvm::Triple::ppc64le))
4077 CmdArgs.push_back(
"-fnoopenmp-use-tls");
4089 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
4090 Sanitize.
addArgs(getToolChain(), Args, CmdArgs, InputType);
4093 if (
const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
4094 const llvm::Triple::ArchType Arch = getToolChain().getArch();
4095 if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
4096 Arch == llvm::Triple::ppc64le))
4097 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
4098 <<
"ppc/ppc64/ppc64le";
4102 if (Arg *A = Args.getLastArg(options::OPT_fzvector))
4103 if (Args.hasArg(options::OPT_faltivec))
4104 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
4107 if (getToolChain().SupportsProfiling())
4108 Args.AddLastArg(CmdArgs, options::OPT_pg);
4111 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4112 options::OPT_fno_lax_vector_conversions))
4113 CmdArgs.push_back(
"-fno-lax-vector-conversions");
4115 if (Args.getLastArg(options::OPT_fapple_kext))
4116 CmdArgs.push_back(
"-fapple-kext");
4118 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
4119 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
4120 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
4121 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4122 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
4124 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4125 CmdArgs.push_back(
"-ftrapv-handler");
4126 CmdArgs.push_back(A->getValue());
4129 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
4133 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
4134 if (A->getOption().matches(options::OPT_fwrapv))
4135 CmdArgs.push_back(
"-fwrapv");
4136 }
else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4137 options::OPT_fno_strict_overflow)) {
4138 if (A->getOption().matches(options::OPT_fno_strict_overflow))
4139 CmdArgs.push_back(
"-fwrapv");
4142 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4143 options::OPT_fno_reroll_loops))
4144 if (A->getOption().matches(options::OPT_freroll_loops))
4145 CmdArgs.push_back(
"-freroll-loops");
4147 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
4148 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4149 options::OPT_fno_unroll_loops);
4151 Args.AddLastArg(CmdArgs, options::OPT_pthread);
4154 unsigned StackProtectorLevel = 0;
4155 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
4156 Args.ClaimAllArgs(options::OPT_fno_stack_protector);
4157 Args.ClaimAllArgs(options::OPT_fstack_protector_all);
4158 Args.ClaimAllArgs(options::OPT_fstack_protector_strong);
4159 Args.ClaimAllArgs(options::OPT_fstack_protector);
4160 }
else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
4161 options::OPT_fstack_protector_all,
4162 options::OPT_fstack_protector_strong,
4163 options::OPT_fstack_protector)) {
4164 if (A->getOption().matches(options::OPT_fstack_protector)) {
4165 StackProtectorLevel = std::max<unsigned>(
4167 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
4168 }
else if (A->getOption().matches(options::OPT_fstack_protector_strong))
4170 else if (A->getOption().matches(options::OPT_fstack_protector_all))
4173 StackProtectorLevel =
4174 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
4176 if (StackProtectorLevel) {
4177 CmdArgs.push_back(
"-stack-protector");
4178 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
4182 for (
const Arg *A : Args.filtered(options::OPT__param)) {
4183 StringRef Str(A->getValue());
4184 if (Str.startswith(
"ssp-buffer-size=")) {
4185 if (StackProtectorLevel) {
4186 CmdArgs.push_back(
"-stack-protector-buffer-size");
4188 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
4195 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4197 CmdArgs.push_back(
"-backend-option");
4198 CmdArgs.push_back(
"-force-align-stack");
4200 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
4202 CmdArgs.push_back(Args.MakeArgString(
"-mstackrealign"));
4205 if (Args.hasArg(options::OPT_mstack_alignment)) {
4206 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4207 CmdArgs.push_back(Args.MakeArgString(
"-mstack-alignment=" + alignment));
4210 if (Args.hasArg(options::OPT_mstack_probe_size)) {
4211 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4214 CmdArgs.push_back(Args.MakeArgString(
"-mstack-probe-size=" + Size));
4216 CmdArgs.push_back(
"-mstack-probe-size=0");
4219 if (getToolChain().getArch() == llvm::Triple::aarch64 ||
4220 getToolChain().getArch() == llvm::Triple::aarch64_be)
4221 CmdArgs.push_back(
"-fallow-half-arguments-and-returns");
4223 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4224 options::OPT_mno_restrict_it)) {
4225 if (A->getOption().matches(options::OPT_mrestrict_it)) {
4226 CmdArgs.push_back(
"-backend-option");
4227 CmdArgs.push_back(
"-arm-restrict-it");
4229 CmdArgs.push_back(
"-backend-option");
4230 CmdArgs.push_back(
"-arm-no-restrict-it");
4232 }
else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
4233 TT.getArch() == llvm::Triple::thumb)) {
4235 CmdArgs.push_back(
"-backend-option");
4236 CmdArgs.push_back(
"-arm-restrict-it");
4241 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4242 StringRef fname = A->getValue();
4243 if (!llvm::sys::fs::exists(fname))
4244 D.
Diag(diag::err_drv_no_such_file) << fname;
4246 A->render(Args, CmdArgs);
4249 if (Args.hasArg(options::OPT_mkernel)) {
4250 if (!Args.hasArg(options::OPT_fapple_kext) &&
types::isCXX(InputType))
4251 CmdArgs.push_back(
"-fapple-kext");
4252 if (!Args.hasArg(options::OPT_fbuiltin))
4253 CmdArgs.push_back(
"-fno-builtin");
4254 Args.ClaimAllArgs(options::OPT_fno_builtin);
4257 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
4258 CmdArgs.push_back(
"-fno-builtin");
4260 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4261 options::OPT_fno_assume_sane_operator_new))
4262 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4265 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
4266 getToolChain().IsBlocksDefault()) ||
4267 (Args.hasArg(options::OPT_fgnu_runtime) &&
4268 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4269 !Args.hasArg(options::OPT_fno_blocks))) {
4270 CmdArgs.push_back(
"-fblocks");
4272 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4273 !getToolChain().hasBlocksRuntime())
4274 CmdArgs.push_back(
"-fblocks-runtime-optional");
4280 bool HaveModules =
false;
4281 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules,
false)) {
4282 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4283 options::OPT_fno_cxx_modules,
true);
4285 CmdArgs.push_back(
"-fmodules");
4292 if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4293 options::OPT_fno_implicit_module_maps, HaveModules)) {
4294 CmdArgs.push_back(
"-fimplicit-module-maps");
4299 if (Args.hasFlag(options::OPT_fmodules_decluse,
4300 options::OPT_fno_modules_decluse,
false)) {
4301 CmdArgs.push_back(
"-fmodules-decluse");
4306 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4307 options::OPT_fno_modules_strict_decluse,
false)) {
4308 CmdArgs.push_back(
"-fmodules-strict-decluse");
4312 if (!Args.hasFlag(options::OPT_fimplicit_modules,
4313 options::OPT_fno_implicit_modules)) {
4314 CmdArgs.push_back(
"-fno-implicit-modules");
4319 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
4323 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
4326 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4331 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4332 Path = A->getValue();
4338 llvm::sys::path::replace_extension(Path,
".cache");
4339 llvm::sys::path::append(Path,
"modules");
4340 }
else if (Path.empty()) {
4342 llvm::sys::path::system_temp_directory(
false, Path);
4343 llvm::sys::path::append(Path,
"org.llvm.clang.");
4345 llvm::sys::path::append(Path,
"ModuleCache");
4347 const char Arg[] =
"-fmodules-cache-path=";
4348 Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
4349 CmdArgs.push_back(Args.MakeArgString(Path));
4356 llvm::sys::path::replace_extension(VFSDir,
".cache");
4360 llvm::sys::path::append(VFSDir,
"vfs");
4361 CmdArgs.push_back(
"-module-dependency-dir");
4362 CmdArgs.push_back(Args.MakeArgString(VFSDir));
4366 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
4369 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
4370 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4371 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
4373 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4375 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4376 if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4377 D.
Diag(diag::err_drv_argument_not_allowed_with)
4378 << A->getAsString(Args) <<
"-fbuild-session-timestamp";
4380 llvm::sys::fs::file_status Status;
4381 if (llvm::sys::fs::status(A->getValue(), Status))
4382 D.
Diag(diag::err_drv_no_such_file) << A->getValue();
4383 CmdArgs.push_back(Args.MakeArgString(
4384 "-fbuild-session-timestamp=" +
4385 Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
4388 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
4389 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4390 options::OPT_fbuild_session_file))
4391 D.
Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4393 Args.AddLastArg(CmdArgs,
4394 options::OPT_fmodules_validate_once_per_build_session);
4397 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4400 if (Args.hasFlag(options::OPT_fno_access_control,
4401 options::OPT_faccess_control,
false))
4402 CmdArgs.push_back(
"-fno-access-control");
4405 if (Args.hasFlag(options::OPT_fno_elide_constructors,
4406 options::OPT_felide_constructors,
false))
4407 CmdArgs.push_back(
"-fno-elide-constructors");
4414 CmdArgs.push_back(
"-fno-rtti");
4417 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4418 getToolChain().getArch() == llvm::Triple::hexagon))
4419 CmdArgs.push_back(
"-fshort-enums");
4422 if (Arg *A = Args.getLastArg(
4423 options::OPT_fsigned_char, options::OPT_fno_signed_char,
4424 options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4425 if (A->getOption().matches(options::OPT_funsigned_char) ||
4426 A->getOption().matches(options::OPT_fno_signed_char)) {
4427 CmdArgs.push_back(
"-fno-signed-char");
4430 CmdArgs.push_back(
"-fno-signed-char");
4434 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4435 options::OPT_fno_use_cxa_atexit,
4436 !IsWindowsCygnus && !IsWindowsGNU &&
4437 getToolChain().getArch() != llvm::Triple::hexagon &&
4438 getToolChain().getArch() != llvm::Triple::xcore) ||
4440 CmdArgs.push_back(
"-fno-use-cxa-atexit");
4443 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
4445 CmdArgs.push_back(
"-fms-extensions");
4448 if (Args.hasFlag(options::OPT_fuse_line_directives,
4449 options::OPT_fno_use_line_directives,
false))
4450 CmdArgs.push_back(
"-fuse-line-directives");
4453 if (Args.hasFlag(options::OPT_fms_compatibility,
4454 options::OPT_fno_ms_compatibility,
4456 Args.hasFlag(options::OPT_fms_extensions,
4457 options::OPT_fno_ms_extensions,
true))))
4458 CmdArgs.push_back(
"-fms-compatibility");
4462 &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4465 Args.MakeArgString(
"-fms-compatibility-version=" + MSVT.
getAsString()));
4467 bool IsMSVC2015Compatible = MSVT.
getMajor() >= 19;
4468 if (ImplyVCPPCXXVer) {
4469 if (IsMSVC2015Compatible)
4470 CmdArgs.push_back(
"-std=c++14");
4472 CmdArgs.push_back(
"-std=c++11");
4476 if (Args.hasFlag(options::OPT_fborland_extensions,
4477 options::OPT_fno_borland_extensions,
false))
4478 CmdArgs.push_back(
"-fborland-extensions");
4482 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4483 options::OPT_fno_threadsafe_statics,
4484 !IsWindowsMSVC || IsMSVC2015Compatible))
4485 CmdArgs.push_back(
"-fno-threadsafe-statics");
4489 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
4490 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
4491 CmdArgs.push_back(
"-fdelayed-template-parsing");
4495 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
4496 options::OPT_fno_gnu_keywords))
4497 A->render(Args, CmdArgs);
4499 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
4501 CmdArgs.push_back(
"-fgnu89-inline");
4503 if (Args.hasArg(options::OPT_fno_inline))
4504 CmdArgs.push_back(
"-fno-inline");
4506 if (Args.hasArg(options::OPT_fno_inline_functions))
4507 CmdArgs.push_back(
"-fno-inline-functions");
4509 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
4516 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4517 options::OPT_fno_objc_legacy_dispatch,
4519 getToolChain().getArch()))) {
4520 if (getToolChain().UseObjCMixedDispatch())
4521 CmdArgs.push_back(
"-fobjc-dispatch-method=mixed");
4523 CmdArgs.push_back(
"-fobjc-dispatch-method=non-legacy");
4530 if (getToolChain().getArch() == llvm::Triple::x86 &&
4531 getToolChain().getTriple().isMacOSX() &&
4532 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4535 CmdArgs.push_back(
"-fobjc-subscripting-legacy-runtime");
4538 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4539 CmdArgs.push_back(
"-fencode-extended-block-signature");
4546 getToolChain().CheckObjCARC();
4548 CmdArgs.push_back(
"-fobjc-arc");
4555 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libc++");
4557 CmdArgs.push_back(
"-fobjc-arc-cxxlib=libstdc++");
4562 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4563 options::OPT_fno_objc_arc_exceptions,
4565 CmdArgs.push_back(
"-fobjc-arc-exceptions");
4570 if (rewriteKind != RK_None)
4571 CmdArgs.push_back(
"-fno-objc-infer-related-result-type");
4575 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4577 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4580 D.
Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
4581 }
else if (getToolChain().SupportsObjCGC()) {
4582 GCArg->render(Args, CmdArgs);
4585 D.
Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
4589 if (Args.hasFlag(options::OPT_fapplication_extension,
4590 options::OPT_fno_application_extension,
false))
4591 CmdArgs.push_back(
"-fapplication-extension");
4595 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
4598 if (getToolChain().UseSjLjExceptions())
4599 CmdArgs.push_back(
"-fsjlj-exceptions");
4602 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4603 options::OPT_fno_assume_sane_operator_new))
4604 CmdArgs.push_back(
"-fno-assume-sane-operator-new");
4608 if (Args.hasFlag(options::OPT_fsized_deallocation,
4609 options::OPT_fno_sized_deallocation,
false))
4610 CmdArgs.push_back(
"-fsized-deallocation");
4614 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4615 options::OPT_fno_constant_cfstrings) ||
4616 !Args.hasFlag(options::OPT_mconstant_cfstrings,
4617 options::OPT_mno_constant_cfstrings))
4618 CmdArgs.push_back(
"-fno-constant-cfstrings");
4622 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4623 options::OPT_fno_short_wchar))
4624 A->render(Args, CmdArgs);
4627 if (Args.hasFlag(options::OPT_fpascal_strings,
4628 options::OPT_fno_pascal_strings,
false))
4629 CmdArgs.push_back(
"-fpascal-strings");
4633 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
4634 std::string PackStructStr =
"-fpack-struct=";
4635 PackStructStr += A->getValue();
4636 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
4637 }
else if (Args.hasFlag(options::OPT_fpack_struct,
4638 options::OPT_fno_pack_struct,
false)) {
4639 CmdArgs.push_back(
"-fpack-struct=1");
4643 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4644 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4645 if (!SkipMaxTypeAlign) {
4646 std::string MaxTypeAlignStr =
"-fmax-type-align=";
4647 MaxTypeAlignStr += A->getValue();
4648 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4650 }
else if (getToolChain().getTriple().isOSDarwin()) {
4651 if (!SkipMaxTypeAlign) {
4652 std::string MaxTypeAlignStr =
"-fmax-type-align=16";
4653 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4658 if (!Args.hasArg(options::OPT_fcommon))
4659 CmdArgs.push_back(
"-fno-common");
4660 Args.ClaimAllArgs(options::OPT_fno_common);
4664 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
4665 CmdArgs.push_back(
"-fno-common");
4669 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
4670 options::OPT_funsigned_bitfields))
4671 D.
Diag(diag::warn_drv_clang_unsupported)
4672 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4675 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
4676 D.
Diag(diag::err_drv_clang_unsupported)
4677 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4680 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4681 StringRef value = inputCharset->getValue();
4682 if (value !=
"UTF-8")
4683 D.
Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4688 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4689 StringRef value = execCharset->getValue();
4690 if (value !=
"UTF-8")
4691 D.
Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4696 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4697 options::OPT_fno_caret_diagnostics,
true))
4698 CmdArgs.push_back(
"-fno-caret-diagnostics");
4701 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
4702 options::OPT_fno_diagnostics_fixit_info))
4703 CmdArgs.push_back(
"-fno-diagnostics-fixit-info");
4706 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
4707 options::OPT_fno_diagnostics_show_option))
4708 CmdArgs.push_back(
"-fdiagnostics-show-option");
4711 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4712 CmdArgs.push_back(
"-fdiagnostics-show-category");
4713 CmdArgs.push_back(A->getValue());
4716 if (
const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4717 CmdArgs.push_back(
"-fdiagnostics-format");
4718 CmdArgs.push_back(A->getValue());
4721 if (Arg *A = Args.getLastArg(
4722 options::OPT_fdiagnostics_show_note_include_stack,
4723 options::OPT_fno_diagnostics_show_note_include_stack)) {
4724 if (A->getOption().matches(
4725 options::OPT_fdiagnostics_show_note_include_stack))
4726 CmdArgs.push_back(
"-fdiagnostics-show-note-include-stack");
4728 CmdArgs.push_back(
"-fno-diagnostics-show-note-include-stack");
4735 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
4736 for (
const auto &Arg : Args) {
4737 const Option &O = Arg->getOption();
4738 if (!O.matches(options::OPT_fcolor_diagnostics) &&
4739 !O.matches(options::OPT_fdiagnostics_color) &&
4740 !O.matches(options::OPT_fno_color_diagnostics) &&
4741 !O.matches(options::OPT_fno_diagnostics_color) &&
4742 !O.matches(options::OPT_fdiagnostics_color_EQ))
4746 if (O.matches(options::OPT_fcolor_diagnostics) ||
4747 O.matches(options::OPT_fdiagnostics_color)) {
4748 ShowColors = Colors_On;
4749 }
else if (O.matches(options::OPT_fno_color_diagnostics) ||
4750 O.matches(options::OPT_fno_diagnostics_color)) {
4751 ShowColors = Colors_Off;
4753 assert(O.matches(options::OPT_fdiagnostics_color_EQ));
4754 StringRef value(Arg->getValue());
4755 if (value ==
"always")
4756 ShowColors = Colors_On;
4757 else if (value ==
"never")
4758 ShowColors = Colors_Off;
4759 else if (value ==
"auto")
4760 ShowColors = Colors_Auto;
4762 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4763 << (
"-fdiagnostics-color=" + value).str();
4766 if (ShowColors == Colors_On ||
4767 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
4768 CmdArgs.push_back(
"-fcolor-diagnostics");
4770 if (Args.hasArg(options::OPT_fansi_escape_codes))
4771 CmdArgs.push_back(
"-fansi-escape-codes");
4773 if (!Args.hasFlag(options::OPT_fshow_source_location,
4774 options::OPT_fno_show_source_location))
4775 CmdArgs.push_back(
"-fno-show-source-location");
4777 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4779 CmdArgs.push_back(
"-fno-show-column");
4781 if (!Args.hasFlag(options::OPT_fspell_checking,
4782 options::OPT_fno_spell_checking))
4783 CmdArgs.push_back(
"-fno-spell-checking");
4786 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4788 CmdArgs.push_back(
"-fasm-blocks");
4791 if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4792 options::OPT_fno_gnu_inline_asm,
true))
4793 CmdArgs.push_back(
"-fno-gnu-inline-asm");
4799 OptSpecifier VectorizeAliasOption =
4800 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
4801 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4802 options::OPT_fno_vectorize, EnableVec))
4803 CmdArgs.push_back(
"-vectorize-loops");
4807 OptSpecifier SLPVectAliasOption =
4808 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
4809 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4810 options::OPT_fno_slp_vectorize, EnableSLPVec))
4811 CmdArgs.push_back(
"-vectorize-slp");
4814 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
4815 options::OPT_fno_slp_vectorize_aggressive,
false))
4816 CmdArgs.push_back(
"-vectorize-slp-aggressive");
4818 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4819 A->render(Args, CmdArgs);
4823 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4824 options::OPT_fno_dollars_in_identifiers)) {
4825 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
4826 CmdArgs.push_back(
"-fdollars-in-identifiers");
4828 CmdArgs.push_back(
"-fno-dollars-in-identifiers");
4833 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4834 options::OPT_fno_unit_at_a_time)) {
4835 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
4836 D.
Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4839 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4840 options::OPT_fno_apple_pragma_pack,
false))
4841 CmdArgs.push_back(
"-fapple-pragma-pack");
4846 if (getToolChain().getArch() == llvm::Triple::le32) {
4847 CmdArgs.push_back(
"-fno-math-builtin");
4854 if (getToolChain().getTriple().isOSDarwin() &&
4855 (getToolChain().getArch() == llvm::Triple::arm ||
4856 getToolChain().getArch() == llvm::Triple::thumb)) {
4857 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4858 CmdArgs.push_back(
"-fno-builtin-strcat");
4859 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4860 CmdArgs.push_back(
"-fno-builtin-strcpy");
4868 if (Args.hasFlag(options::OPT_frewrite_includes,
4869 options::OPT_fno_rewrite_includes,
false) ||
4871 CmdArgs.push_back(
"-frewrite-includes");
4874 if (Arg *A = Args.getLastArg(options::OPT_traditional,
4875 options::OPT_traditional_cpp)) {
4876 if (isa<PreprocessJobAction>(JA))
4877 CmdArgs.push_back(
"-traditional-cpp");
4879 D.
Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
4882 Args.AddLastArg(CmdArgs, options::OPT_dM);
4883 Args.AddLastArg(CmdArgs, options::OPT_dD);
4886 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4887 CmdArgs.push_back(
"-serialize-diagnostic-file");
4888 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
4891 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4892 CmdArgs.push_back(
"-fretain-comments-from-system-headers");
4895 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
4897 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
4901 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
4902 bool OptDisabled =
false;
4903 for (
const Arg *A : Args.filtered(options::OPT_mllvm)) {
4908 if (StringRef(A->getValue(0)) ==
"-disable-llvm-optzns") {
4909 CmdArgs.push_back(
"-disable-llvm-optzns");
4912 A->render(Args, CmdArgs);
4919 isa<CompileJobAction>(JA))
4920 CmdArgs.push_back(
"-disable-llvm-optzns");
4922 if (Output.
getType() == types::TY_Dependencies) {
4925 CmdArgs.push_back(
"-o");
4928 assert(Output.
isNothing() &&
"Invalid output.");
4933 if (Input.isFilename())
4934 CmdArgs.push_back(Input.getFilename());
4936 Input.getInputArg().renderAsInput(Args, CmdArgs);
4938 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4940 const char *Exec = getToolChain().getDriver().getClangProgramPath();
4944 if (getToolChain().UseDwarfDebugFlags()) {
4945 ArgStringList OriginalArgs;
4946 for (
const auto &Arg : Args)
4947 Arg->render(Args, OriginalArgs);
4951 for (
const char *OriginalArg : OriginalArgs) {
4955 Flags += EscapedArg;
4957 CmdArgs.push_back(
"-dwarf-debug-flags");
4958 CmdArgs.push_back(Args.MakeArgString(Flags));
4963 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
4964 getToolChain().getTriple().isOSLinux() &&
4965 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4966 isa<BackendJobAction>(JA));
4967 const char *SplitDwarfOut;
4969 CmdArgs.push_back(
"-split-dwarf-file");
4971 CmdArgs.push_back(SplitDwarfOut);
4976 if (IsCuda && Inputs.size() > 1)
4977 for (InputInfoList::const_iterator it = std::next(Inputs.begin()),
4980 CmdArgs.push_back(
"-fcuda-include-gpubinary");
4981 CmdArgs.push_back(it->getFilename());
4985 if (Args.hasArg(options::OPT__SLASH_fallback) &&
4986 Output.
getType() == types::TY_Object &&
4987 (InputType == types::TY_C || InputType == types::TY_CXX)) {
4989 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4990 C.
addCommand(llvm::make_unique<FallbackCommand>(JA, *
this, Exec, CmdArgs,
4991 std::move(CLCommand)));
4993 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
4999 if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
5000 SplitDebugInfo(getToolChain(), C, *
this, JA, Args, Output, SplitDwarfOut);
5002 if (Arg *A = Args.getLastArg(options::OPT_pg))
5003 if (Args.hasArg(options::OPT_fomit_frame_pointer))
5004 D.
Diag(diag::err_drv_argument_not_allowed_with) <<
"-fomit-frame-pointer"
5005 << A->getAsString(Args);
5012 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
5016 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
5017 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
5020 Args.ClaimAllArgs(options::OPT_emit_llvm);
5026 ObjCRuntime Clang::AddObjCRuntimeArgs(
const ArgList &args,
5027 ArgStringList &cmdArgs,
5028 RewriteKind rewriteKind)
const {
5031 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
5032 options::OPT_fobjc_runtime_EQ);
5037 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
5039 StringRef value = runtimeArg->getValue();
5041 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
5045 runtimeArg->render(args, cmdArgs);
5054 unsigned objcABIVersion = 1;
5056 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
5057 StringRef value = abiArg->getValue();
5060 else if (value ==
"2")
5062 else if (value ==
"3")
5065 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
5068 bool nonFragileABIIsDefault =
5069 (rewriteKind == RK_NonFragile ||
5070 (rewriteKind == RK_None &&
5071 getToolChain().IsObjCNonFragileABIDefault()));
5072 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
5073 options::OPT_fno_objc_nonfragile_abi,
5074 nonFragileABIIsDefault)) {
5076 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
5077 unsigned nonFragileABIVersion = 1;
5079 unsigned nonFragileABIVersion = 2;
5083 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
5084 StringRef value = abiArg->getValue();
5086 nonFragileABIVersion = 1;
5087 else if (value ==
"2")
5088 nonFragileABIVersion = 2;
5090 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
5094 objcABIVersion = 1 + nonFragileABIVersion;
5102 bool isNonFragile = objcABIVersion != 1;
5108 switch (rewriteKind) {
5110 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5121 }
else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5123 if (getToolChain().getTriple().isOSDarwin()) {
5124 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5133 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
5143 args.MakeArgString(
"-fobjc-runtime=" + runtime.
getAsString()));
5148 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] ==
'-');
5171 std::vector<std::string> EHArgs =
5172 Args.getAllArgValues(options::OPT__SLASH_EH);
5173 for (
auto EHVal : EHArgs) {
5174 for (
size_t I = 0, E = EHVal.size(); I != E; ++I) {
5188 D.
Diag(clang::diag::err_drv_invalid_value) <<
"/EH" << EHVal;
5200 void Clang::AddClangCLArgs(
const ArgList &Args, ArgStringList &CmdArgs)
const {
5201 unsigned RTOptionID = options::OPT__SLASH_MT;
5203 if (Args.hasArg(options::OPT__SLASH_LDd))
5206 RTOptionID = options::OPT__SLASH_MTd;
5208 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
5209 RTOptionID = A->getOption().getID();
5211 switch (RTOptionID) {
5212 case options::OPT__SLASH_MD:
5213 if (Args.hasArg(options::OPT__SLASH_LDd))
5214 CmdArgs.push_back(
"-D_DEBUG");
5215 CmdArgs.push_back(
"-D_MT");
5216 CmdArgs.push_back(
"-D_DLL");
5217 CmdArgs.push_back(
"--dependent-lib=msvcrt");
5219 case options::OPT__SLASH_MDd:
5220 CmdArgs.push_back(
"-D_DEBUG");
5221 CmdArgs.push_back(
"-D_MT");
5222 CmdArgs.push_back(
"-D_DLL");
5223 CmdArgs.push_back(
"--dependent-lib=msvcrtd");
5225 case options::OPT__SLASH_MT:
5226 if (Args.hasArg(options::OPT__SLASH_LDd))
5227 CmdArgs.push_back(
"-D_DEBUG");
5228 CmdArgs.push_back(
"-D_MT");
5229 CmdArgs.push_back(
"--dependent-lib=libcmt");
5231 case options::OPT__SLASH_MTd:
5232 CmdArgs.push_back(
"-D_DEBUG");
5233 CmdArgs.push_back(
"-D_MT");
5234 CmdArgs.push_back(
"--dependent-lib=libcmtd");
5237 llvm_unreachable(
"Unexpected option ID.");
5243 CmdArgs.push_back(
"--dependent-lib=oldnames");
5247 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5248 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5249 A->render(Args, CmdArgs);
5252 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5254 CmdArgs.push_back(
"-fno-rtti-data");
5256 const Driver &D = getToolChain().getDriver();
5260 CmdArgs.push_back(
"-fcxx-exceptions");
5261 CmdArgs.push_back(
"-fexceptions");
5265 if (Args.hasArg(options::OPT__SLASH_EP)) {
5266 CmdArgs.push_back(
"-E");
5267 CmdArgs.push_back(
"-P");
5270 unsigned VolatileOptionID;
5271 if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5272 getToolChain().getArch() == llvm::Triple::x86)
5273 VolatileOptionID = options::OPT__SLASH_volatile_ms;
5275 VolatileOptionID = options::OPT__SLASH_volatile_iso;
5277 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5278 VolatileOptionID = A->getOption().getID();
5280 if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5281 CmdArgs.push_back(
"-fms-volatile");
5283 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5284 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5285 if (MostGeneralArg && BestCaseArg)
5286 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5287 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5289 if (MostGeneralArg) {
5290 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5291 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5292 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5294 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5295 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5296 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5297 D.
Diag(clang::diag::err_drv_argument_not_allowed_with)
5298 << FirstConflict->getAsString(Args)
5299 << SecondConflict->getAsString(Args);
5302 CmdArgs.push_back(
"-fms-memptr-rep=single");
5303 else if (MultipleArg)
5304 CmdArgs.push_back(
"-fms-memptr-rep=multiple");
5306 CmdArgs.push_back(
"-fms-memptr-rep=virtual");
5309 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5310 A->render(Args, CmdArgs);
5312 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5313 CmdArgs.push_back(
"-fdiagnostics-format");
5314 if (Args.hasArg(options::OPT__SLASH_fallback))
5315 CmdArgs.push_back(
"msvc-fallback");
5317 CmdArgs.push_back(
"msvc");
5324 return CLFallback.get();
5328 ArgStringList &CmdArgs)
const {
5331 const llvm::Triple &Triple = getToolChain().getTriple();
5334 CmdArgs.push_back(
"-target-abi");
5335 CmdArgs.push_back(ABIName.data());
5340 const ArgList &Args,
5341 const char *LinkingOutput)
const {
5342 ArgStringList CmdArgs;
5344 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
5348 Args.ClaimAllArgs(options::OPT_w);
5350 Args.ClaimAllArgs(options::OPT_emit_llvm);
5357 CmdArgs.push_back(
"-cc1as");
5360 CmdArgs.push_back(
"-triple");
5361 std::string TripleStr =
5362 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
5363 CmdArgs.push_back(Args.MakeArgString(TripleStr));
5367 CmdArgs.push_back(
"-filetype");
5368 CmdArgs.push_back(
"obj");
5372 CmdArgs.push_back(
"-main-file-name");
5376 const llvm::Triple Triple(TripleStr);
5377 std::string CPU =
getCPUName(Args, Triple,
true);
5379 CmdArgs.push_back(
"-target-cpu");
5380 CmdArgs.push_back(Args.MakeArgString(CPU));
5384 const Driver &D = getToolChain().getDriver();
5388 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5391 Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5394 const Action *SourceAction = &JA;
5396 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
5397 SourceAction = SourceAction->
getInputs()[0];
5402 if (SourceAction->
getType() == types::TY_Asm ||
5403 SourceAction->
getType() == types::TY_PP_Asm) {
5404 Args.ClaimAllArgs(options::OPT_g_Group);
5405 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5406 if (!A->getOption().matches(options::OPT_g0))
5407 CmdArgs.push_back(
"-g");
5409 if (Args.hasArg(options::OPT_gdwarf_2))
5410 CmdArgs.push_back(
"-gdwarf-2");
5411 if (Args.hasArg(options::OPT_gdwarf_3))
5412 CmdArgs.push_back(
"-gdwarf-3");
5413 if (Args.hasArg(options::OPT_gdwarf_4))
5414 CmdArgs.push_back(
"-gdwarf-4");
5421 CmdArgs.push_back(
"-dwarf-debug-producer");
5427 if (getToolChain().UseDwarfDebugFlags()) {
5428 ArgStringList OriginalArgs;
5429 for (
const auto &Arg : Args)
5430 Arg->render(Args, OriginalArgs);
5433 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5435 for (
const char *OriginalArg : OriginalArgs) {
5439 Flags += EscapedArg;
5441 CmdArgs.push_back(
"-dwarf-debug-flags");
5442 CmdArgs.push_back(Args.MakeArgString(Flags));
5448 switch (getToolChain().getArch()) {
5452 case llvm::Triple::mips:
5453 case llvm::Triple::mipsel:
5454 case llvm::Triple::mips64:
5455 case llvm::Triple::mips64el:
5456 AddMIPSTargetArgs(Args, CmdArgs);
5465 for (
const Arg *A : Args.filtered(options::OPT_W_Group))
5469 getToolChain().getDriver());
5471 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
5473 assert(Output.
isFilename() &&
"Unexpected lipo output.");
5474 CmdArgs.push_back(
"-o");
5477 assert(Input.isFilename() &&
"Invalid input.");
5478 CmdArgs.push_back(Input.getFilename());
5480 const char *Exec = getToolChain().getDriver().getClangProgramPath();
5481 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
5486 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
5487 getToolChain().getTriple().isOSLinux())
5492 void GnuTool::anchor() {}
5497 const char *LinkingOutput)
const {
5498 const Driver &D = getToolChain().getDriver();
5499 ArgStringList CmdArgs;
5501 for (
const auto &A : Args) {
5504 if (isa<AssembleJobAction>(JA) &&
5505 A->getOption().matches(options::OPT_g_Group))
5509 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5510 A->getOption().matches(options::OPT_W_Group))
5518 A->render(Args, CmdArgs);
5522 RenderExtraToolArgs(JA, CmdArgs);
5525 if (getToolChain().getTriple().isOSDarwin()) {
5526 CmdArgs.push_back(
"-arch");
5528 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
5536 const llvm::Triple::ArchType Arch = getToolChain().getArch();
5537 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
5538 CmdArgs.push_back(
"-m32");
5539 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5540 Arch == llvm::Triple::ppc64le)
5541 CmdArgs.push_back(
"-m64");
5544 CmdArgs.push_back(
"-o");
5547 assert(Output.
isNothing() &&
"Unexpected output");
5548 CmdArgs.push_back(
"-fsyntax-only");
5551 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
5561 for (
const auto &II : Inputs) {
5563 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5564 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5565 D.
Diag(diag::err_drv_no_linker_llvm_support)
5566 << getToolChain().getTripleString();
5567 else if (II.getType() == types::TY_AST)
5568 D.
Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
5569 else if (II.getType() == types::TY_ModuleFile)
5570 D.
Diag(diag::err_drv_no_module_support)
5571 << getToolChain().getTripleString();
5574 CmdArgs.push_back(
"-x");
5578 if (II.isFilename())
5579 CmdArgs.push_back(II.getFilename());
5581 const Arg &A = II.getInputArg();
5584 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5585 CmdArgs.push_back(
"-lstdc++");
5590 A.render(Args, CmdArgs);
5595 const char *GCCName;
5596 if (!customGCCName.empty())
5597 GCCName = customGCCName.c_str();
5603 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
5604 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
5608 ArgStringList &CmdArgs)
const {
5609 CmdArgs.push_back(
"-E");
5613 ArgStringList &CmdArgs)
const {
5614 const Driver &D = getToolChain().getDriver();
5618 case types::TY_LLVM_IR:
5619 case types::TY_LTO_IR:
5620 case types::TY_LLVM_BC:
5621 case types::TY_LTO_BC:
5622 CmdArgs.push_back(
"-c");
5624 case types::TY_PP_Asm:
5625 CmdArgs.push_back(
"-S");
5627 case types::TY_Nothing:
5628 CmdArgs.push_back(
"-fsyntax-only");
5636 ArgStringList &CmdArgs)
const {
5642 ArgStringList &CmdArgs)
const {}
5646 const ArgList &Args,
5647 const char *LinkingOutput)
const {
5650 const Driver &D = getToolChain().getDriver();
5651 ArgStringList CmdArgs;
5653 std::string MarchString =
"-march=";
5655 CmdArgs.push_back(Args.MakeArgString(MarchString));
5657 RenderExtraToolArgs(JA, CmdArgs);
5660 CmdArgs.push_back(
"-o");
5663 assert(Output.
isNothing() &&
"Unexpected output");
5664 CmdArgs.push_back(
"-fsyntax-only");
5668 CmdArgs.push_back(Args.MakeArgString(std::string(
"-G") + v));
5670 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
5680 for (
const auto &II : Inputs) {
5682 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5683 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5684 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
5685 << getToolChain().getTripleString();
5686 else if (II.getType() == types::TY_AST)
5687 D.
Diag(clang::diag::err_drv_no_ast_support)
5688 << getToolChain().getTripleString();
5689 else if (II.getType() == types::TY_ModuleFile)
5690 D.
Diag(diag::err_drv_no_module_support)
5691 << getToolChain().getTripleString();
5693 if (II.isFilename())
5694 CmdArgs.push_back(II.getFilename());
5698 II.getInputArg().render(Args, CmdArgs);
5701 const char *GCCName =
"hexagon-as";
5702 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
5703 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
5707 ArgStringList &CmdArgs)
const {
5715 const ArgList &Args,
5716 ArgStringList &CmdArgs,
5717 const char *LinkingOutput) {
5724 bool hasStaticArg = Args.hasArg(options::OPT_static);
5725 bool buildingLib = Args.hasArg(options::OPT_shared);
5726 bool buildPIE = Args.hasArg(options::OPT_pie);
5727 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5728 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5729 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5731 bool useShared = buildingLib && !hasStaticArg;
5737 Args.ClaimAllArgs(options::OPT_g_Group);
5738 Args.ClaimAllArgs(options::OPT_emit_llvm);
5739 Args.ClaimAllArgs(options::OPT_w);
5741 Args.ClaimAllArgs(options::OPT_static_libgcc);
5746 for (
const auto &Opt : ToolChain.
ExtraOpts)
5747 CmdArgs.push_back(Opt.c_str());
5750 CmdArgs.push_back(Args.MakeArgString(
"-m" + MarchString));
5753 CmdArgs.push_back(
"-shared");
5754 CmdArgs.push_back(
"-call_shared");
5759 CmdArgs.push_back(
"-static");
5761 if (buildPIE && !buildingLib)
5762 CmdArgs.push_back(
"-pie");
5765 CmdArgs.push_back(Args.MakeArgString(std::string(
"-G") + v));
5772 CmdArgs.push_back(
"-o");
5775 const std::string MarchSuffix =
"/" + MarchString;
5776 const std::string G0Suffix =
"/G0";
5777 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
5778 const std::string RootDir =
5780 const std::string StartFilesDir =
5781 RootDir +
"hexagon/lib" + (useG0 ? MarchG0Suffix : MarchSuffix);
5786 std::vector<std::string> oslibs;
5787 bool hasStandalone =
false;
5789 for (
const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
5791 oslibs.emplace_back(A->getValue());
5792 hasStandalone = hasStandalone || (oslibs.back() ==
"standalone");
5794 if (oslibs.empty()) {
5795 oslibs.push_back(
"standalone");
5796 hasStandalone =
true;
5802 if (incStdLib && incStartFiles) {
5805 if (hasStandalone) {
5807 Args.MakeArgString(StartFilesDir +
"/crt0_standalone.o"));
5809 CmdArgs.push_back(Args.MakeArgString(StartFilesDir +
"/crt0.o"));
5811 std::string initObj = useShared ?
"/initS.o" :
"/init.o";
5812 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5819 for (
const auto &LibPath : LibPaths)
5820 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + LibPath));
5825 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5826 Args.AddAllArgs(CmdArgs, options::OPT_e);
5827 Args.AddAllArgs(CmdArgs, options::OPT_s);
5828 Args.AddAllArgs(CmdArgs, options::OPT_t);
5829 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5836 if (incStdLib && incDefLibs) {
5839 CmdArgs.push_back(
"-lm");
5842 CmdArgs.push_back(
"--start-group");
5845 for (
const std::string &Lib : oslibs)
5846 CmdArgs.push_back(Args.MakeArgString(
"-l" + Lib));
5847 CmdArgs.push_back(
"-lc");
5849 CmdArgs.push_back(
"-lgcc");
5851 CmdArgs.push_back(
"--end-group");
5857 if (incStdLib && incStartFiles) {
5858 std::string finiObj = useShared ?
"/finiS.o" :
"/fini.o";
5859 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5866 const ArgList &Args,
5867 const char *LinkingOutput)
const {
5872 ArgStringList CmdArgs;
5877 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Linker),
5887 MArch = Triple.getArchName();
5888 MArch = StringRef(MArch).lower();
5891 if (MArch ==
"native") {
5892 std::string CPU = llvm::sys::getHostCPUName();
5893 if (CPU !=
"generic") {
5898 if (strcmp(Suffix,
"") == 0)
5901 MArch = std::string(
"arm") + Suffix;
5909 std::string MArch =
getARMArch(Arch, Triple);
5917 const char *result = Triple.getARMCPUForArch(MArch);
5926 const llvm::Triple &Triple) {
5930 std::string MCPU = StringRef(CPU).lower();
5932 if (MCPU ==
"native")
5933 return llvm::sys::getHostCPUName();
5945 if (CPU ==
"generic" &&
5946 llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_ARMV8_1A)
5949 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
5950 if (ArchKind == llvm::ARM::AK_INVALID)
5952 return llvm::ARMTargetParser::getSubArch(ArchKind);
5956 const llvm::Triple &Triple) {
5957 if (Args.hasArg(options::OPT_r))
5963 CmdArgs.push_back(
"--be8");
5987 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5988 return A && (A->getValue() == StringRef(Value));
5992 Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
5993 return A && A->getOption().matches(options::OPT_muclibc);
5996 bool mips::isNaN2008(
const ArgList &Args,
const llvm::Triple &Triple) {
5997 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5998 return llvm::StringSwitch<bool>(NaNArg->getValue())
6000 .Case(
"legacy",
false)
6004 return llvm::StringSwitch<bool>(
getCPUName(Args, Triple))
6005 .Cases(
"mips32r6",
"mips64r6",
true)
6012 StringRef ABIName, StringRef FloatABI) {
6013 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
6014 Triple.getVendor() != llvm::Triple::MipsTechnologies)
6017 if (ABIName !=
"32")
6022 if (FloatABI ==
"soft")
6025 return llvm::StringSwitch<bool>(CPUName)
6026 .Cases(
"mips2",
"mips3",
"mips4",
"mips5",
true)
6027 .Cases(
"mips32",
"mips32r2",
"mips32r3",
"mips32r5",
true)
6028 .Cases(
"mips64",
"mips64r2",
"mips64r3",
"mips64r5",
true)
6033 StringRef CPUName, StringRef ABIName,
6034 StringRef FloatABI) {
6035 bool UseFPXX =
isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
6038 if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
6039 options::OPT_mdouble_float))
6040 if (A->getOption().matches(options::OPT_msingle_float))
6059 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
6060 .Cases(
"ppc",
"ppc601",
"ppc603",
"ppc604",
"ppc604e", llvm::Triple::ppc)
6061 .Cases(
"ppc750",
"ppc7400",
"ppc7450",
"ppc970", llvm::Triple::ppc)
6062 .Case(
"ppc64", llvm::Triple::ppc64)
6063 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
6064 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
6066 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
6068 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
6069 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
6070 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
6071 .Case(
"arm64", llvm::Triple::aarch64)
6072 .Case(
"r600", llvm::Triple::r600)
6073 .Case(
"amdgcn", llvm::Triple::amdgcn)
6074 .Case(
"nvptx", llvm::Triple::nvptx)
6075 .Case(
"nvptx64", llvm::Triple::nvptx64)
6076 .Case(
"amdil", llvm::Triple::amdil)
6077 .Case(
"spir", llvm::Triple::spir)
6078 .Default(llvm::Triple::UnknownArch);
6085 if (Str ==
"x86_64h")
6087 else if (Str ==
"armv6m" || Str ==
"armv7m" || Str ==
"armv7em") {
6088 T.setOS(llvm::Triple::UnknownOS);
6089 T.setObjectFormat(llvm::Triple::MachO);
6095 return Args.MakeArgString(llvm::sys::path::filename(Input.
getBaseInput()));
6100 const char *Str = getBaseInputName(Args, Inputs[0]);
6102 if (
const char *
End = strrchr(Str,
'.'))
6103 return Args.MakeArgString(std::string(Str,
End));
6113 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6114 std::string Str(OutputOpt->getValue());
6115 Res = Str.substr(0, Str.rfind(
'.'));
6117 Res = getBaseInputStem(Args, Inputs);
6119 return Args.MakeArgString(Res +
".d");
6125 const ArgList &Args,
6126 const char *LinkingOutput)
const {
6129 ArgStringList CmdArgs;
6132 Args.ClaimAllArgs(options::OPT_g_Group);
6134 Args.ClaimAllArgs(options::OPT_emit_llvm);
6137 Args.ClaimAllArgs(options::OPT_w);
6140 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
6143 CmdArgs.push_back(
"-Bstatic");
6144 CmdArgs.push_back(
"--eh-frame-hdr");
6145 CmdArgs.push_back(
"--gc-sections");
6148 CmdArgs.push_back(
"-o");
6151 assert(Output.
isNothing() &&
"Invalid output.");
6154 if (!Args.hasArg(options::OPT_nostdlib) &&
6155 !Args.hasArg(options::OPT_nostartfiles)) {
6156 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt0.o")));
6157 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtbegin.o")));
6160 Args.AddAllArgs(CmdArgs, options::OPT_L);
6162 for (
const auto &Path : Paths)
6163 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + Path));
6164 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6165 Args.AddAllArgs(CmdArgs, options::OPT_e);
6166 Args.AddAllArgs(CmdArgs, options::OPT_s);
6167 Args.AddAllArgs(CmdArgs, options::OPT_t);
6168 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6169 Args.AddAllArgs(CmdArgs, options::OPT_r);
6176 if (!Args.hasArg(options::OPT_nostdlib) &&
6177 !Args.hasArg(options::OPT_nodefaultlibs)) {
6180 CmdArgs.push_back(
"-lc");
6181 CmdArgs.push_back(
"-lcompiler_rt");
6184 if (!Args.hasArg(options::OPT_nostdlib) &&
6185 !Args.hasArg(options::OPT_nostartfiles))
6186 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtend.o")));
6188 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
6189 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6195 const ArgList &Args,
6196 const char *LinkingOutput)
const {
6197 ArgStringList CmdArgs;
6199 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
6203 const Action *SourceAction = &JA;
6205 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
6206 SourceAction = SourceAction->
getInputs()[0];
6214 if (Args.hasArg(options::OPT_fno_integrated_as)) {
6215 const llvm::Triple &T(getToolChain().getTriple());
6216 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
6217 CmdArgs.push_back(
"-Q");
6221 if (SourceAction->
getType() == types::TY_Asm ||
6222 SourceAction->
getType() == types::TY_PP_Asm) {
6223 if (Args.hasArg(options::OPT_gstabs))
6224 CmdArgs.push_back(
"--gstabs");
6225 else if (Args.hasArg(options::OPT_g_Group))
6226 CmdArgs.push_back(
"-g");
6230 AddMachOArch(Args, CmdArgs);
6233 if (getToolChain().getArch() == llvm::Triple::x86 ||
6234 getToolChain().getArch() == llvm::Triple::x86_64 ||
6235 Args.hasArg(options::OPT_force__cpusubtype__ALL))
6236 CmdArgs.push_back(
"-force_cpusubtype_ALL");
6238 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
6239 (((Args.hasArg(options::OPT_mkernel) ||
6240 Args.hasArg(options::OPT_fapple_kext)) &&
6241 getMachOToolChain().isKernelStatic()) ||
6242 Args.hasArg(options::OPT_static)))
6243 CmdArgs.push_back(
"-static");
6245 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6247 assert(Output.
isFilename() &&
"Unexpected lipo output.");
6248 CmdArgs.push_back(
"-o");
6251 assert(Input.isFilename() &&
"Invalid input.");
6252 CmdArgs.push_back(Input.getFilename());
6256 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
6257 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6260 void darwin::MachOTool::anchor() {}
6263 ArgStringList &CmdArgs)
const {
6264 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
6267 CmdArgs.push_back(
"-arch");
6268 CmdArgs.push_back(Args.MakeArgString(ArchName));
6271 if (ArchName ==
"arm")
6272 CmdArgs.push_back(
"-force_cpusubtype_ALL");
6275 bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
6279 for (
const auto &
Input : Inputs)
6280 if (
Input.getType() != types::TY_Object)
6286 void darwin::Linker::AddLinkArgs(
Compilation &C,
const ArgList &Args,
6287 ArgStringList &CmdArgs,
6289 const Driver &D = getToolChain().getDriver();
6292 unsigned Version[3] = {0, 0, 0};
6293 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6296 Version[2], HadExtra) ||
6298 D.
Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
6303 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6304 CmdArgs.push_back(
"-demangle");
6306 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6307 CmdArgs.push_back(
"-export_dynamic");
6311 if (Args.hasFlag(options::OPT_fapplication_extension,
6312 options::OPT_fno_application_extension,
false))
6313 CmdArgs.push_back(
"-application_extension");
6318 if (Version[0] >= 116 && D.
IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
6319 const char *TmpPath = C.
getArgs().MakeArgString(
6322 CmdArgs.push_back(
"-object_path_lto");
6323 CmdArgs.push_back(TmpPath);
6327 Args.AddAllArgs(CmdArgs, options::OPT_static);
6328 if (!Args.hasArg(options::OPT_static))
6329 CmdArgs.push_back(
"-dynamic");
6330 if (Args.hasArg(options::OPT_fgnu_runtime)) {
6335 if (!Args.hasArg(options::OPT_dynamiclib)) {
6336 AddMachOArch(Args, CmdArgs);
6338 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
6340 Args.AddLastArg(CmdArgs, options::OPT_bundle);
6341 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6342 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6345 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6346 (A = Args.getLastArg(options::OPT_current__version)) ||
6347 (A = Args.getLastArg(options::OPT_install__name)))
6348 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
6351 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6352 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6353 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6355 CmdArgs.push_back(
"-dylib");
6358 if ((A = Args.getLastArg(options::OPT_bundle)) ||
6359 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6360 (A = Args.getLastArg(options::OPT_client__name)) ||
6361 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6362 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6363 (A = Args.getLastArg(options::OPT_private__bundle)))
6364 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
6367 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6368 "-dylib_compatibility_version");
6369 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6370 "-dylib_current_version");
6372 AddMachOArch(Args, CmdArgs);
6374 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6375 "-dylib_install_name");
6378 Args.AddLastArg(CmdArgs, options::OPT_all__load);
6379 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6380 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
6382 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
6383 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6384 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6385 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6386 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6387 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6388 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
6389 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
6390 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6391 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6392 Args.AddAllArgs(CmdArgs, options::OPT_init);
6397 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6398 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6399 Args.AddLastArg(CmdArgs, options::OPT_single__module);
6400 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6401 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
6404 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6405 options::OPT_fno_pie, options::OPT_fno_PIE)) {
6406 if (A->getOption().matches(options::OPT_fpie) ||
6407 A->getOption().matches(options::OPT_fPIE))
6408 CmdArgs.push_back(
"-pie");
6410 CmdArgs.push_back(
"-no_pie");
6413 Args.AddLastArg(CmdArgs, options::OPT_prebind);
6414 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6415 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6416 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6417 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6418 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6419 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6420 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6421 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6422 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6423 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6424 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6425 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6426 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6427 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6428 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
6433 if (sysroot !=
"") {
6434 CmdArgs.push_back(
"-syslibroot");
6435 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
6436 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6437 CmdArgs.push_back(
"-syslibroot");
6438 CmdArgs.push_back(A->getValue());
6441 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6442 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6443 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6444 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6445 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
6446 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
6447 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6448 Args.AddAllArgs(CmdArgs, options::OPT_y);
6449 Args.AddLastArg(CmdArgs, options::OPT_w);
6450 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6451 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6452 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6453 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6454 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6455 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6456 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6457 Args.AddLastArg(CmdArgs, options::OPT_whyload);
6458 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6459 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6460 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6461 Args.AddLastArg(CmdArgs, options::OPT_Mach);
6467 const ArgList &Args,
6468 const char *LinkingOutput)
const {
6469 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
6475 llvm::opt::ArgStringList InputFileList;
6480 ArgStringList CmdArgs;
6483 if (Args.hasArg(options::OPT_ccc_arcmt_check,
6484 options::OPT_ccc_arcmt_migrate)) {
6485 for (
const auto &Arg : Args)
6488 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
6490 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6496 AddLinkArgs(C, Args, CmdArgs, Inputs);
6498 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
6499 Args.AddAllArgs(CmdArgs, options::OPT_s);
6500 Args.AddAllArgs(CmdArgs, options::OPT_t);
6501 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6502 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
6503 Args.AddLastArg(CmdArgs, options::OPT_e);
6504 Args.AddAllArgs(CmdArgs, options::OPT_r);
6509 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6510 CmdArgs.push_back(
"-ObjC");
6512 CmdArgs.push_back(
"-o");
6515 if (!Args.hasArg(options::OPT_nostdlib) &&
6516 !Args.hasArg(options::OPT_nostartfiles))
6517 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
6522 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
6523 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
6524 "libclang_rt.safestack_osx.a",
6528 Args.AddAllArgs(CmdArgs, options::OPT_L);
6530 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6531 options::OPT_fno_openmp,
false)) {
6534 CmdArgs.push_back(
"-lomp");
6537 CmdArgs.push_back(
"-lgomp");
6540 CmdArgs.push_back(
"-liomp5");
6551 for (
const auto &II : Inputs) {
6552 if (!II.isFilename()) {
6557 if (InputFileList.size() > 0)
6563 InputFileList.push_back(II.getFilename());
6567 !Args.hasArg(options::OPT_nodefaultlibs)) {
6569 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6571 CmdArgs.push_back(
"-framework");
6572 CmdArgs.push_back(
"Foundation");
6574 CmdArgs.push_back(
"-lobjc");
6577 if (LinkingOutput) {
6578 CmdArgs.push_back(
"-arch_multiple");
6579 CmdArgs.push_back(
"-final_output");
6580 CmdArgs.push_back(LinkingOutput);
6583 if (Args.hasArg(options::OPT_fnested_functions))
6584 CmdArgs.push_back(
"-allow_stack_execute");
6589 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6591 if (!Args.hasArg(options::OPT_nostdlib) &&
6592 !Args.hasArg(options::OPT_nodefaultlibs)) {
6593 if (getToolChain().getDriver().CCCIsCXX())
6594 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6599 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
6602 if (!Args.hasArg(options::OPT_nostdlib) &&
6603 !Args.hasArg(options::OPT_nostartfiles)) {
6607 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6608 Args.AddAllArgs(CmdArgs, options::OPT_F);
6611 for (
const Arg *A : Args.filtered(options::OPT_iframework))
6612 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
6614 if (!Args.hasArg(options::OPT_nostdlib) &&
6615 !Args.hasArg(options::OPT_nodefaultlibs)) {
6616 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6617 if (A->getValue() == StringRef(
"Accelerate")) {
6618 CmdArgs.push_back(
"-framework");
6619 CmdArgs.push_back(
"Accelerate");
6624 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6625 std::unique_ptr<Command> Cmd =
6626 llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs);
6627 Cmd->setInputFileList(std::move(InputFileList));
6634 const ArgList &Args,
6635 const char *LinkingOutput)
const {
6636 ArgStringList CmdArgs;
6638 CmdArgs.push_back(
"-create");
6639 assert(Output.
isFilename() &&
"Unexpected lipo output.");
6641 CmdArgs.push_back(
"-output");
6644 for (
const auto &II : Inputs) {
6645 assert(II.isFilename() &&
"Unexpected lipo input.");
6646 CmdArgs.push_back(II.getFilename());
6649 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
6650 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6656 const ArgList &Args,
6657 const char *LinkingOutput)
const {
6658 ArgStringList CmdArgs;
6660 CmdArgs.push_back(
"-o");
6663 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
6665 assert(Input.isFilename() &&
"Unexpected dsymutil input.");
6666 CmdArgs.push_back(Input.getFilename());
6669 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
6670 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6676 const ArgList &Args,
6677 const char *LinkingOutput)
const {
6678 ArgStringList CmdArgs;
6679 CmdArgs.push_back(
"--verify");
6680 CmdArgs.push_back(
"--debug-info");
6681 CmdArgs.push_back(
"--eh-frame");
6682 CmdArgs.push_back(
"--quiet");
6684 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
6686 assert(Input.isFilename() &&
"Unexpected verify input");
6689 CmdArgs.push_back(Input.getFilename());
6692 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
6693 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6699 const ArgList &Args,
6700 const char *LinkingOutput)
const {
6702 ArgStringList CmdArgs;
6704 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6706 CmdArgs.push_back(
"-o");
6709 for (
const auto &II : Inputs)
6710 CmdArgs.push_back(II.getFilename());
6712 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
6713 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6719 const ArgList &Args,
6720 const char *LinkingOutput)
const {
6722 std::string GCCLibPath =
"/usr/gcc/4.5/lib/gcc/";
6723 const llvm::Triple &T = getToolChain().getTriple();
6724 std::string LibPath =
"/usr/lib/";
6725 const llvm::Triple::ArchType Arch = T.getArch();
6727 case llvm::Triple::x86:
6729 (
"i386-" + T.getVendorName() +
"-" + T.getOSName()).str() +
"/4.5.2/";
6731 case llvm::Triple::x86_64:
6732 GCCLibPath += (
"i386-" + T.getVendorName() +
"-" + T.getOSName()).str();
6733 GCCLibPath +=
"/4.5.2/amd64/";
6734 LibPath +=
"amd64/";
6737 llvm_unreachable(
"Unsupported architecture");
6740 ArgStringList CmdArgs;
6743 CmdArgs.push_back(
"-C");
6745 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6746 (!Args.hasArg(options::OPT_shared))) {
6747 CmdArgs.push_back(
"-e");
6748 CmdArgs.push_back(
"_start");
6751 if (Args.hasArg(options::OPT_static)) {
6752 CmdArgs.push_back(
"-Bstatic");
6753 CmdArgs.push_back(
"-dn");
6755 CmdArgs.push_back(
"-Bdynamic");
6756 if (Args.hasArg(options::OPT_shared)) {
6757 CmdArgs.push_back(
"-shared");
6759 CmdArgs.push_back(
"--dynamic-linker");
6760 CmdArgs.push_back(Args.MakeArgString(LibPath +
"ld.so.1"));
6765 CmdArgs.push_back(
"-o");
6768 assert(Output.
isNothing() &&
"Invalid output.");
6771 if (!Args.hasArg(options::OPT_nostdlib) &&
6772 !Args.hasArg(options::OPT_nostartfiles)) {
6773 if (!Args.hasArg(options::OPT_shared)) {
6774 CmdArgs.push_back(Args.MakeArgString(LibPath +
"crt1.o"));
6775 CmdArgs.push_back(Args.MakeArgString(LibPath +
"crti.o"));
6776 CmdArgs.push_back(Args.MakeArgString(LibPath +
"values-Xa.o"));
6777 CmdArgs.push_back(Args.MakeArgString(GCCLibPath +
"crtbegin.o"));
6779 CmdArgs.push_back(Args.MakeArgString(LibPath +
"crti.o"));
6780 CmdArgs.push_back(Args.MakeArgString(LibPath +
"values-Xa.o"));
6781 CmdArgs.push_back(Args.MakeArgString(GCCLibPath +
"crtbegin.o"));
6783 if (getToolChain().getDriver().CCCIsCXX())
6784 CmdArgs.push_back(Args.MakeArgString(LibPath +
"cxa_finalize.o"));
6787 CmdArgs.push_back(Args.MakeArgString(
"-L" + GCCLibPath));
6789 Args.AddAllArgs(CmdArgs, options::OPT_L);
6790 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6791 Args.AddAllArgs(CmdArgs, options::OPT_e);
6792 Args.AddAllArgs(CmdArgs, options::OPT_r);
6796 if (!Args.hasArg(options::OPT_nostdlib) &&
6797 !Args.hasArg(options::OPT_nodefaultlibs)) {
6798 if (getToolChain().getDriver().CCCIsCXX())
6799 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6800 CmdArgs.push_back(
"-lgcc_s");
6801 if (!Args.hasArg(options::OPT_shared)) {
6802 CmdArgs.push_back(
"-lgcc");
6803 CmdArgs.push_back(
"-lc");
6804 CmdArgs.push_back(
"-lm");
6808 if (!Args.hasArg(options::OPT_nostdlib) &&
6809 !Args.hasArg(options::OPT_nostartfiles)) {
6810 CmdArgs.push_back(Args.MakeArgString(GCCLibPath +
"crtend.o"));
6812 CmdArgs.push_back(Args.MakeArgString(LibPath +
"crtn.o"));
6816 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6817 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6823 const ArgList &Args,
6824 const char *LinkingOutput)
const {
6826 ArgStringList CmdArgs;
6827 bool NeedsKPIC =
false;
6829 switch (getToolChain().getArch()) {
6830 case llvm::Triple::x86:
6833 CmdArgs.push_back(
"--32");
6836 case llvm::Triple::ppc:
6837 CmdArgs.push_back(
"-mppc");
6838 CmdArgs.push_back(
"-many");
6841 case llvm::Triple::sparc:
6842 case llvm::Triple::sparcel:
6843 CmdArgs.push_back(
"-32");
6847 case llvm::Triple::sparcv9:
6848 CmdArgs.push_back(
"-64");
6849 CmdArgs.push_back(
"-Av9a");
6853 case llvm::Triple::mips64:
6854 case llvm::Triple::mips64el: {
6859 CmdArgs.push_back(
"-mabi");
6862 if (getToolChain().getArch() == llvm::Triple::mips64)
6863 CmdArgs.push_back(
"-EB");
6865 CmdArgs.push_back(
"-EL");
6878 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6880 CmdArgs.push_back(
"-o");
6883 for (
const auto &II : Inputs)
6884 CmdArgs.push_back(II.getFilename());
6886 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
6887 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
6893 const ArgList &Args,
6894 const char *LinkingOutput)
const {
6895 const Driver &D = getToolChain().getDriver();
6896 ArgStringList CmdArgs;
6899 Args.ClaimAllArgs(options::OPT_g_Group);
6901 Args.ClaimAllArgs(options::OPT_emit_llvm);
6904 Args.ClaimAllArgs(options::OPT_w);
6906 if (getToolChain().getArch() == llvm::Triple::mips64)
6907 CmdArgs.push_back(
"-EB");
6908 else if (getToolChain().getArch() == llvm::Triple::mips64el)
6909 CmdArgs.push_back(
"-EL");
6911 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6912 (!Args.hasArg(options::OPT_shared))) {
6913 CmdArgs.push_back(
"-e");
6914 CmdArgs.push_back(
"__start");
6917 if (Args.hasArg(options::OPT_static)) {
6918 CmdArgs.push_back(
"-Bstatic");
6920 if (Args.hasArg(options::OPT_rdynamic))
6921 CmdArgs.push_back(
"-export-dynamic");
6922 CmdArgs.push_back(
"--eh-frame-hdr");
6923 CmdArgs.push_back(
"-Bdynamic");
6924 if (Args.hasArg(options::OPT_shared)) {
6925 CmdArgs.push_back(
"-shared");
6927 CmdArgs.push_back(
"-dynamic-linker");
6928 CmdArgs.push_back(
"/usr/libexec/ld.so");
6932 if (Args.hasArg(options::OPT_nopie))
6933 CmdArgs.push_back(
"-nopie");
6936 CmdArgs.push_back(
"-o");
6939 assert(Output.
isNothing() &&
"Invalid output.");
6942 if (!Args.hasArg(options::OPT_nostdlib) &&
6943 !Args.hasArg(options::OPT_nostartfiles)) {
6944 if (!Args.hasArg(options::OPT_shared)) {
6945 if (Args.hasArg(options::OPT_pg))
6947 Args.MakeArgString(getToolChain().GetFilePath(
"gcrt0.o")));
6950 Args.MakeArgString(getToolChain().GetFilePath(
"crt0.o")));
6952 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
6955 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
6959 std::string Triple = getToolChain().getTripleString();
6960 if (Triple.substr(0, 6) ==
"x86_64")
6961 Triple.replace(0, 6,
"amd64");
6963 Args.MakeArgString(
"-L/usr/lib/gcc-lib/" + Triple +
"/4.2.1"));
6965 Args.AddAllArgs(CmdArgs, options::OPT_L);
6966 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6967 Args.AddAllArgs(CmdArgs, options::OPT_e);
6968 Args.AddAllArgs(CmdArgs, options::OPT_s);
6969 Args.AddAllArgs(CmdArgs, options::OPT_t);
6970 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6971 Args.AddAllArgs(CmdArgs, options::OPT_r);
6975 if (!Args.hasArg(options::OPT_nostdlib) &&
6976 !Args.hasArg(options::OPT_nodefaultlibs)) {
6978 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6979 if (Args.hasArg(options::OPT_pg))
6980 CmdArgs.push_back(
"-lm_p");
6982 CmdArgs.push_back(
"-lm");
6987 CmdArgs.push_back(
"-lgcc");
6989 if (Args.hasArg(options::OPT_pthread)) {
6990 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
6991 CmdArgs.push_back(
"-lpthread_p");
6993 CmdArgs.push_back(
"-lpthread");
6996 if (!Args.hasArg(options::OPT_shared)) {
6997 if (Args.hasArg(options::OPT_pg))
6998 CmdArgs.push_back(
"-lc_p");
7000 CmdArgs.push_back(
"-lc");
7003 CmdArgs.push_back(
"-lgcc");
7006 if (!Args.hasArg(options::OPT_nostdlib) &&
7007 !Args.hasArg(options::OPT_nostartfiles)) {
7008 if (!Args.hasArg(options::OPT_shared))
7010 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
7013 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
7016 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7017 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7023 const ArgList &Args,
7024 const char *LinkingOutput)
const {
7026 ArgStringList CmdArgs;
7028 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7030 CmdArgs.push_back(
"-o");
7033 for (
const auto &II : Inputs)
7034 CmdArgs.push_back(II.getFilename());
7036 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7037 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7043 const ArgList &Args,
7044 const char *LinkingOutput)
const {
7045 const Driver &D = getToolChain().getDriver();
7046 ArgStringList CmdArgs;
7048 if ((!Args.hasArg(options::OPT_nostdlib)) &&
7049 (!Args.hasArg(options::OPT_shared))) {
7050 CmdArgs.push_back(
"-e");
7051 CmdArgs.push_back(
"__start");
7054 if (Args.hasArg(options::OPT_static)) {
7055 CmdArgs.push_back(
"-Bstatic");
7057 if (Args.hasArg(options::OPT_rdynamic))
7058 CmdArgs.push_back(
"-export-dynamic");
7059 CmdArgs.push_back(
"--eh-frame-hdr");
7060 CmdArgs.push_back(
"-Bdynamic");
7061 if (Args.hasArg(options::OPT_shared)) {
7062 CmdArgs.push_back(
"-shared");
7064 CmdArgs.push_back(
"-dynamic-linker");
7065 CmdArgs.push_back(
"/usr/libexec/ld.so");
7070 CmdArgs.push_back(
"-o");
7073 assert(Output.
isNothing() &&
"Invalid output.");
7076 if (!Args.hasArg(options::OPT_nostdlib) &&
7077 !Args.hasArg(options::OPT_nostartfiles)) {
7078 if (!Args.hasArg(options::OPT_shared)) {
7079 if (Args.hasArg(options::OPT_pg))
7081 Args.MakeArgString(getToolChain().GetFilePath(
"gcrt0.o")));
7084 Args.MakeArgString(getToolChain().GetFilePath(
"crt0.o")));
7086 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
7089 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
7093 Args.AddAllArgs(CmdArgs, options::OPT_L);
7094 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7095 Args.AddAllArgs(CmdArgs, options::OPT_e);
7099 if (!Args.hasArg(options::OPT_nostdlib) &&
7100 !Args.hasArg(options::OPT_nodefaultlibs)) {
7102 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7103 if (Args.hasArg(options::OPT_pg))
7104 CmdArgs.push_back(
"-lm_p");
7106 CmdArgs.push_back(
"-lm");
7109 if (Args.hasArg(options::OPT_pthread)) {
7110 if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
7111 CmdArgs.push_back(
"-lpthread_p");
7113 CmdArgs.push_back(
"-lpthread");
7116 if (!Args.hasArg(options::OPT_shared)) {
7117 if (Args.hasArg(options::OPT_pg))
7118 CmdArgs.push_back(
"-lc_p");
7120 CmdArgs.push_back(
"-lc");
7124 switch (getToolChain().getArch()) {
7125 case llvm::Triple::arm:
7128 case llvm::Triple::x86:
7131 case llvm::Triple::x86_64:
7135 llvm_unreachable(
"Unsupported architecture");
7137 CmdArgs.push_back(Args.MakeArgString(
"-lclang_rt." + MyArch));
7140 if (!Args.hasArg(options::OPT_nostdlib) &&
7141 !Args.hasArg(options::OPT_nostartfiles)) {
7142 if (!Args.hasArg(options::OPT_shared))
7144 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
7147 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
7150 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7151 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7157 const ArgList &Args,
7158 const char *LinkingOutput)
const {
7160 ArgStringList CmdArgs;
7164 if (getToolChain().getArch() == llvm::Triple::x86)
7165 CmdArgs.push_back(
"--32");
7166 else if (getToolChain().getArch() == llvm::Triple::ppc)
7167 CmdArgs.push_back(
"-a32");
7168 else if (getToolChain().getArch() == llvm::Triple::mips ||
7169 getToolChain().getArch() == llvm::Triple::mipsel ||
7170 getToolChain().getArch() == llvm::Triple::mips64 ||
7171 getToolChain().getArch() == llvm::Triple::mips64el) {
7176 CmdArgs.push_back(
"-march");
7177 CmdArgs.push_back(CPUName.data());
7179 CmdArgs.push_back(
"-mabi");
7182 if (getToolChain().getArch() == llvm::Triple::mips ||
7183 getToolChain().getArch() == llvm::Triple::mips64)
7184 CmdArgs.push_back(
"-EB");
7186 CmdArgs.push_back(
"-EL");
7189 }
else if (getToolChain().getArch() == llvm::Triple::arm ||
7190 getToolChain().getArch() == llvm::Triple::armeb ||
7191 getToolChain().getArch() == llvm::Triple::thumb ||
7192 getToolChain().getArch() == llvm::Triple::thumbeb) {
7193 const Driver &D = getToolChain().getDriver();
7194 const llvm::Triple &Triple = getToolChain().getTriple();
7197 if (FloatABI ==
"hard") {
7198 CmdArgs.push_back(
"-mfpu=vfp");
7200 CmdArgs.push_back(
"-mfpu=softvfp");
7203 switch (getToolChain().getTriple().getEnvironment()) {
7204 case llvm::Triple::GNUEABIHF:
7205 case llvm::Triple::GNUEABI:
7206 case llvm::Triple::EABI:
7207 CmdArgs.push_back(
"-meabi=5");
7211 CmdArgs.push_back(
"-matpcs");
7213 }
else if (getToolChain().getArch() == llvm::Triple::sparc ||
7214 getToolChain().getArch() == llvm::Triple::sparcel ||
7215 getToolChain().getArch() == llvm::Triple::sparcv9) {
7216 if (getToolChain().getArch() == llvm::Triple::sparc)
7217 CmdArgs.push_back(
"-Av8plusa");
7219 CmdArgs.push_back(
"-Av9a");
7224 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7226 CmdArgs.push_back(
"-o");
7229 for (
const auto &II : Inputs)
7230 CmdArgs.push_back(II.getFilename());
7232 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7233 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7239 const ArgList &Args,
7240 const char *LinkingOutput)
const {
7244 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
7246 !Args.hasArg(options::OPT_shared) &&
7247 (Args.hasArg(options::OPT_pie) || ToolChain.
isPIEDefault());
7248 ArgStringList CmdArgs;
7251 Args.ClaimAllArgs(options::OPT_g_Group);
7253 Args.ClaimAllArgs(options::OPT_emit_llvm);
7256 Args.ClaimAllArgs(options::OPT_w);
7259 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
7262 CmdArgs.push_back(
"-pie");
7264 if (Args.hasArg(options::OPT_static)) {
7265 CmdArgs.push_back(
"-Bstatic");
7267 if (Args.hasArg(options::OPT_rdynamic))
7268 CmdArgs.push_back(
"-export-dynamic");
7269 CmdArgs.push_back(
"--eh-frame-hdr");
7270 if (Args.hasArg(options::OPT_shared)) {
7271 CmdArgs.push_back(
"-Bshareable");
7273 CmdArgs.push_back(
"-dynamic-linker");
7274 CmdArgs.push_back(
"/libexec/ld-elf.so.1");
7276 if (ToolChain.
getTriple().getOSMajorVersion() >= 9) {
7277 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7278 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7279 CmdArgs.push_back(
"--hash-style=both");
7282 CmdArgs.push_back(
"--enable-new-dtags");
7287 if (Arch == llvm::Triple::x86) {
7288 CmdArgs.push_back(
"-m");
7289 CmdArgs.push_back(
"elf_i386_fbsd");
7292 if (Arch == llvm::Triple::ppc) {
7293 CmdArgs.push_back(
"-m");
7294 CmdArgs.push_back(
"elf32ppc_fbsd");
7298 CmdArgs.push_back(
"-o");
7301 assert(Output.
isNothing() &&
"Invalid output.");
7304 if (!Args.hasArg(options::OPT_nostdlib) &&
7305 !Args.hasArg(options::OPT_nostartfiles)) {
7306 const char *crt1 =
nullptr;
7307 if (!Args.hasArg(options::OPT_shared)) {
7308 if (Args.hasArg(options::OPT_pg))
7316 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
7318 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
7320 const char *crtbegin =
nullptr;
7321 if (Args.hasArg(options::OPT_static))
7322 crtbegin =
"crtbeginT.o";
7323 else if (Args.hasArg(options::OPT_shared) || IsPIE)
7324 crtbegin =
"crtbeginS.o";
7326 crtbegin =
"crtbegin.o";
7328 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
7331 Args.AddAllArgs(CmdArgs, options::OPT_L);
7333 for (
const auto &Path : Paths)
7334 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + Path));
7335 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7336 Args.AddAllArgs(CmdArgs, options::OPT_e);
7337 Args.AddAllArgs(CmdArgs, options::OPT_s);
7338 Args.AddAllArgs(CmdArgs, options::OPT_t);
7339 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7340 Args.AddAllArgs(CmdArgs, options::OPT_r);
7348 if (!Args.hasArg(options::OPT_nostdlib) &&
7349 !Args.hasArg(options::OPT_nodefaultlibs)) {
7352 if (Args.hasArg(options::OPT_pg))
7353 CmdArgs.push_back(
"-lm_p");
7355 CmdArgs.push_back(
"-lm");
7357 if (NeedsSanitizerDeps)
7361 if (Args.hasArg(options::OPT_pg))
7362 CmdArgs.push_back(
"-lgcc_p");
7364 CmdArgs.push_back(
"-lgcc");
7365 if (Args.hasArg(options::OPT_static)) {
7366 CmdArgs.push_back(
"-lgcc_eh");
7367 }
else if (Args.hasArg(options::OPT_pg)) {
7368 CmdArgs.push_back(
"-lgcc_eh_p");
7370 CmdArgs.push_back(
"--as-needed");
7371 CmdArgs.push_back(
"-lgcc_s");
7372 CmdArgs.push_back(
"--no-as-needed");
7375 if (Args.hasArg(options::OPT_pthread)) {
7376 if (Args.hasArg(options::OPT_pg))
7377 CmdArgs.push_back(
"-lpthread_p");
7379 CmdArgs.push_back(
"-lpthread");
7382 if (Args.hasArg(options::OPT_pg)) {
7383 if (Args.hasArg(options::OPT_shared))
7384 CmdArgs.push_back(
"-lc");
7386 CmdArgs.push_back(
"-lc_p");
7387 CmdArgs.push_back(
"-lgcc_p");
7389 CmdArgs.push_back(
"-lc");
7390 CmdArgs.push_back(
"-lgcc");
7393 if (Args.hasArg(options::OPT_static)) {
7394 CmdArgs.push_back(
"-lgcc_eh");
7395 }
else if (Args.hasArg(options::OPT_pg)) {
7396 CmdArgs.push_back(
"-lgcc_eh_p");
7398 CmdArgs.push_back(
"--as-needed");
7399 CmdArgs.push_back(
"-lgcc_s");
7400 CmdArgs.push_back(
"--no-as-needed");
7404 if (!Args.hasArg(options::OPT_nostdlib) &&
7405 !Args.hasArg(options::OPT_nostartfiles)) {
7406 if (Args.hasArg(options::OPT_shared) || IsPIE)
7407 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtendS.o")));
7409 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtend.o")));
7410 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
7415 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7416 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7422 const ArgList &Args,
7423 const char *LinkingOutput)
const {
7425 ArgStringList CmdArgs;
7429 switch (getToolChain().getArch()) {
7430 case llvm::Triple::x86:
7431 CmdArgs.push_back(
"--32");
7433 case llvm::Triple::arm:
7434 case llvm::Triple::armeb:
7435 case llvm::Triple::thumb:
7436 case llvm::Triple::thumbeb: {
7437 StringRef MArch, MCPU;
7441 CmdArgs.push_back(Args.MakeArgString(
"-mcpu=" + Arch));
7445 case llvm::Triple::mips:
7446 case llvm::Triple::mipsel:
7447 case llvm::Triple::mips64:
7448 case llvm::Triple::mips64el: {
7453 CmdArgs.push_back(
"-march");
7454 CmdArgs.push_back(CPUName.data());
7456 CmdArgs.push_back(
"-mabi");
7459 if (getToolChain().getArch() == llvm::Triple::mips ||
7460 getToolChain().getArch() == llvm::Triple::mips64)
7461 CmdArgs.push_back(
"-EB");
7463 CmdArgs.push_back(
"-EL");
7469 case llvm::Triple::sparc:
7470 case llvm::Triple::sparcel:
7471 CmdArgs.push_back(
"-32");
7475 case llvm::Triple::sparcv9:
7476 CmdArgs.push_back(
"-64");
7477 CmdArgs.push_back(
"-Av9");
7485 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7487 CmdArgs.push_back(
"-o");
7490 for (
const auto &II : Inputs)
7491 CmdArgs.push_back(II.getFilename());
7493 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath(
"as")));
7494 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7500 const ArgList &Args,
7501 const char *LinkingOutput)
const {
7502 const Driver &D = getToolChain().getDriver();
7503 ArgStringList CmdArgs;
7506 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
7508 CmdArgs.push_back(
"--eh-frame-hdr");
7509 if (Args.hasArg(options::OPT_static)) {
7510 CmdArgs.push_back(
"-Bstatic");
7512 if (Args.hasArg(options::OPT_rdynamic))
7513 CmdArgs.push_back(
"-export-dynamic");
7514 if (Args.hasArg(options::OPT_shared)) {
7515 CmdArgs.push_back(
"-Bshareable");
7517 CmdArgs.push_back(
"-dynamic-linker");
7518 CmdArgs.push_back(
"/libexec/ld.elf_so");
7524 switch (getToolChain().getArch()) {
7525 case llvm::Triple::x86:
7526 CmdArgs.push_back(
"-m");
7527 CmdArgs.push_back(
"elf_i386");
7529 case llvm::Triple::arm:
7530 case llvm::Triple::thumb:
7531 CmdArgs.push_back(
"-m");
7532 switch (getToolChain().getTriple().getEnvironment()) {
7533 case llvm::Triple::EABI:
7534 case llvm::Triple::GNUEABI:
7535 CmdArgs.push_back(
"armelf_nbsd_eabi");
7537 case llvm::Triple::EABIHF:
7538 case llvm::Triple::GNUEABIHF:
7539 CmdArgs.push_back(
"armelf_nbsd_eabihf");
7542 CmdArgs.push_back(
"armelf_nbsd");
7546 case llvm::Triple::armeb:
7547 case llvm::Triple::thumbeb:
7550 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
7551 CmdArgs.push_back(
"-m");
7552 switch (getToolChain().getTriple().getEnvironment()) {
7553 case llvm::Triple::EABI:
7554 case llvm::Triple::GNUEABI:
7555 CmdArgs.push_back(
"armelfb_nbsd_eabi");
7557 case llvm::Triple::EABIHF:
7558 case llvm::Triple::GNUEABIHF:
7559 CmdArgs.push_back(
"armelfb_nbsd_eabihf");
7562 CmdArgs.push_back(
"armelfb_nbsd");
7566 case llvm::Triple::mips64:
7567 case llvm::Triple::mips64el:
7569 CmdArgs.push_back(
"-m");
7570 if (getToolChain().getArch() == llvm::Triple::mips64)
7571 CmdArgs.push_back(
"elf32btsmip");
7573 CmdArgs.push_back(
"elf32ltsmip");
7575 CmdArgs.push_back(
"-m");
7576 if (getToolChain().getArch() == llvm::Triple::mips64)
7577 CmdArgs.push_back(
"elf64btsmip");
7579 CmdArgs.push_back(
"elf64ltsmip");
7582 case llvm::Triple::ppc:
7583 CmdArgs.push_back(
"-m");
7584 CmdArgs.push_back(
"elf32ppc_nbsd");
7587 case llvm::Triple::ppc64:
7588 case llvm::Triple::ppc64le:
7589 CmdArgs.push_back(
"-m");
7590 CmdArgs.push_back(
"elf64ppc");
7593 case llvm::Triple::sparc:
7594 CmdArgs.push_back(
"-m");
7595 CmdArgs.push_back(
"elf32_sparc");
7598 case llvm::Triple::sparcv9:
7599 CmdArgs.push_back(
"-m");
7600 CmdArgs.push_back(
"elf64_sparc");
7608 CmdArgs.push_back(
"-o");
7611 assert(Output.
isNothing() &&
"Invalid output.");
7614 if (!Args.hasArg(options::OPT_nostdlib) &&
7615 !Args.hasArg(options::OPT_nostartfiles)) {
7616 if (!Args.hasArg(options::OPT_shared)) {
7618 Args.MakeArgString(getToolChain().GetFilePath(
"crt0.o")));
7620 Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
7622 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
7625 Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
7627 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
7631 Args.AddAllArgs(CmdArgs, options::OPT_L);
7632 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7633 Args.AddAllArgs(CmdArgs, options::OPT_e);
7634 Args.AddAllArgs(CmdArgs, options::OPT_s);
7635 Args.AddAllArgs(CmdArgs, options::OPT_t);
7636 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7637 Args.AddAllArgs(CmdArgs, options::OPT_r);
7641 unsigned Major, Minor, Micro;
7642 getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7643 bool useLibgcc =
true;
7644 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
7645 switch (getToolChain().getArch()) {
7646 case llvm::Triple::aarch64:
7647 case llvm::Triple::arm:
7648 case llvm::Triple::armeb:
7649 case llvm::Triple::thumb:
7650 case llvm::Triple::thumbeb:
7651 case llvm::Triple::ppc:
7652 case llvm::Triple::ppc64:
7653 case llvm::Triple::ppc64le:
7654 case llvm::Triple::x86:
7655 case llvm::Triple::x86_64:
7663 if (!Args.hasArg(options::OPT_nostdlib) &&
7664 !Args.hasArg(options::OPT_nodefaultlibs)) {
7666 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7667 CmdArgs.push_back(
"-lm");
7669 if (Args.hasArg(options::OPT_pthread))
7670 CmdArgs.push_back(
"-lpthread");
7671 CmdArgs.push_back(
"-lc");
7674 if (Args.hasArg(options::OPT_static)) {
7678 CmdArgs.push_back(
"-lgcc_eh");
7679 CmdArgs.push_back(
"-lc");
7680 CmdArgs.push_back(
"-lgcc");
7682 CmdArgs.push_back(
"-lgcc");
7683 CmdArgs.push_back(
"--as-needed");
7684 CmdArgs.push_back(
"-lgcc_s");
7685 CmdArgs.push_back(
"--no-as-needed");
7690 if (!Args.hasArg(options::OPT_nostdlib) &&
7691 !Args.hasArg(options::OPT_nostartfiles)) {
7692 if (!Args.hasArg(options::OPT_shared))
7694 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
7697 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
7698 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
7703 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7704 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7710 const ArgList &Args,
7711 const char *LinkingOutput)
const {
7714 ArgStringList CmdArgs;
7715 bool NeedsKPIC =
false;
7717 switch (getToolChain().getArch()) {
7722 case llvm::Triple::x86:
7723 CmdArgs.push_back(
"--32");
7725 case llvm::Triple::x86_64:
7726 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7727 CmdArgs.push_back(
"--x32");
7729 CmdArgs.push_back(
"--64");
7731 case llvm::Triple::ppc:
7732 CmdArgs.push_back(
"-a32");
7733 CmdArgs.push_back(
"-mppc");
7734 CmdArgs.push_back(
"-many");
7736 case llvm::Triple::ppc64:
7737 CmdArgs.push_back(
"-a64");
7738 CmdArgs.push_back(
"-mppc64");
7739 CmdArgs.push_back(
"-many");
7741 case llvm::Triple::ppc64le:
7742 CmdArgs.push_back(
"-a64");
7743 CmdArgs.push_back(
"-mppc64");
7744 CmdArgs.push_back(
"-many");
7745 CmdArgs.push_back(
"-mlittle-endian");
7747 case llvm::Triple::sparc:
7748 case llvm::Triple::sparcel:
7749 CmdArgs.push_back(
"-32");
7750 CmdArgs.push_back(
"-Av8plusa");
7753 case llvm::Triple::sparcv9:
7754 CmdArgs.push_back(
"-64");
7755 CmdArgs.push_back(
"-Av9a");
7758 case llvm::Triple::arm:
7759 case llvm::Triple::armeb:
7760 case llvm::Triple::thumb:
7761 case llvm::Triple::thumbeb: {
7762 const llvm::Triple &Triple = getToolChain().getTriple();
7763 switch (Triple.getSubArch()) {
7764 case llvm::Triple::ARMSubArch_v7:
7765 CmdArgs.push_back(
"-mfpu=neon");
7767 case llvm::Triple::ARMSubArch_v8:
7768 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
7775 getToolChain().getDriver(), Args,
7776 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
7777 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=" + ARMFloatABI));
7779 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
7785 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7786 StringRef(A->getValue()).lower() ==
"krait")
7787 CmdArgs.push_back(
"-march=armv7-a");
7789 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
7790 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
7793 case llvm::Triple::mips:
7794 case llvm::Triple::mipsel:
7795 case llvm::Triple::mips64:
7796 case llvm::Triple::mips64el: {
7802 CmdArgs.push_back(
"-march");
7803 CmdArgs.push_back(CPUName.data());
7805 CmdArgs.push_back(
"-mabi");
7806 CmdArgs.push_back(ABIName.data());
7810 bool IsPicOrPie =
false;
7811 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7812 options::OPT_fpic, options::OPT_fno_pic,
7813 options::OPT_fPIE, options::OPT_fno_PIE,
7814 options::OPT_fpie, options::OPT_fno_pie)) {
7815 if (A->getOption().matches(options::OPT_fPIC) ||
7816 A->getOption().matches(options::OPT_fpic) ||
7817 A->getOption().matches(options::OPT_fPIE) ||
7818 A->getOption().matches(options::OPT_fpie))
7822 CmdArgs.push_back(
"-mno-shared");
7826 CmdArgs.push_back(ABIName ==
"64" ?
"-KPIC" :
"-call_nonpic");
7828 if (getToolChain().getArch() == llvm::Triple::mips ||
7829 getToolChain().getArch() == llvm::Triple::mips64)
7830 CmdArgs.push_back(
"-EB");
7832 CmdArgs.push_back(
"-EL");
7834 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7835 if (StringRef(A->getValue()) ==
"2008")
7836 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
7840 StringRef MIPSFloatABI =
getMipsFloatABI(getToolChain().getDriver(), Args);
7841 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7842 options::OPT_mfp64)) {
7844 A->render(Args, CmdArgs);
7846 ABIName, MIPSFloatABI))
7847 CmdArgs.push_back(
"-mfpxx");
7852 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
7853 if (A->getOption().matches(options::OPT_mips16)) {
7855 A->render(Args, CmdArgs);
7858 CmdArgs.push_back(
"-no-mips16");
7862 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7863 options::OPT_mno_micromips);
7864 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7865 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7867 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7870 if (A->getOption().matches(options::OPT_mmsa))
7871 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
7874 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7875 options::OPT_msoft_float);
7877 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
7878 options::OPT_msingle_float);
7880 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7881 options::OPT_mno_odd_spreg);
7886 case llvm::Triple::systemz: {
7890 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
7898 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7900 CmdArgs.push_back(
"-o");
7903 for (
const auto &II : Inputs)
7904 CmdArgs.push_back(II.getFilename());
7906 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
7907 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
7912 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
7913 getToolChain().getTriple().isOSLinux())
7919 ArgStringList &CmdArgs,
const ArgList &Args) {
7920 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
7921 bool isCygMing = Triple.isOSCygMing();
7922 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7923 Args.hasArg(options::OPT_static);
7925 CmdArgs.push_back(
"-lgcc");
7927 if (StaticLibgcc || isAndroid) {
7929 CmdArgs.push_back(
"-lgcc");
7932 CmdArgs.push_back(
"--as-needed");
7933 CmdArgs.push_back(
"-lgcc_s");
7935 CmdArgs.push_back(
"--no-as-needed");
7938 if (StaticLibgcc && !isAndroid)
7939 CmdArgs.push_back(
"-lgcc_eh");
7940 else if (!Args.hasArg(options::OPT_shared) && D.
CCCIsCXX())
7941 CmdArgs.push_back(
"-lgcc");
7948 if (isAndroid && !StaticLibgcc)
7949 CmdArgs.push_back(
"-ldl");
7954 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
7956 if (ToolChain.
getTriple().getEnvironment() == llvm::Triple::Android) {
7957 if (ToolChain.
getTriple().isArch64Bit())
7958 return "/system/bin/linker64";
7960 return "/system/bin/linker";
7961 }
else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
7962 Arch == llvm::Triple::sparcel)
7963 return "/lib/ld-linux.so.2";
7964 else if (Arch == llvm::Triple::aarch64)
7965 return "/lib/ld-linux-aarch64.so.1";
7966 else if (Arch == llvm::Triple::aarch64_be)
7967 return "/lib/ld-linux-aarch64_be.so.1";
7968 else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
7969 if (ToolChain.
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
7971 return "/lib/ld-linux-armhf.so.3";
7973 return "/lib/ld-linux.so.3";
7974 }
else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
7976 if (ToolChain.
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF ||
7978 return "/lib/ld-linux-armhf.so.3";
7980 return "/lib/ld-linux.so.3";
7981 }
else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
7982 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
7988 StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7989 .Case(
"o32",
"/lib")
7990 .Case(
"n32",
"/lib32")
7991 .Case(
"n64",
"/lib64")
7995 LibName = IsNaN2008 ?
"ld-uClibc-mipsn8.so.0" :
"ld-uClibc.so.0";
7997 LibName = IsNaN2008 ?
"ld-linux-mipsn8.so.1" :
"ld.so.1";
7999 return (LibDir +
"/" + LibName).str();
8000 }
else if (Arch == llvm::Triple::ppc)
8001 return "/lib/ld.so.1";
8002 else if (Arch == llvm::Triple::ppc64) {
8004 return "/lib64/ld64.so.2";
8005 return "/lib64/ld64.so.1";
8006 }
else if (Arch == llvm::Triple::ppc64le) {
8008 return "/lib64/ld64.so.1";
8009 return "/lib64/ld64.so.2";
8010 }
else if (Arch == llvm::Triple::systemz)
8011 return "/lib64/ld64.so.1";
8012 else if (Arch == llvm::Triple::sparcv9)
8013 return "/lib64/ld-linux.so.2";
8014 else if (Arch == llvm::Triple::x86_64 &&
8015 ToolChain.
getTriple().getEnvironment() == llvm::Triple::GNUX32)
8016 return "/libx32/ld-linux-x32.so.2";
8018 return "/lib64/ld-linux-x86-64.so.2";
8022 ArgStringList &CmdArgs,
const ArgList &Args) {
8030 llvm_unreachable(
"unsupported OS");
8031 case llvm::Triple::Win32:
8032 case llvm::Triple::Linux:
8043 static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
8044 switch (T.getArch()) {
8045 case llvm::Triple::x86:
8047 case llvm::Triple::aarch64:
8048 return "aarch64linux";
8049 case llvm::Triple::aarch64_be:
8050 return "aarch64_be_linux";
8051 case llvm::Triple::arm:
8052 case llvm::Triple::thumb:
8053 return "armelf_linux_eabi";
8054 case llvm::Triple::armeb:
8055 case llvm::Triple::thumbeb:
8056 return "armebelf_linux_eabi";
8057 case llvm::Triple::ppc:
8058 return "elf32ppclinux";
8059 case llvm::Triple::ppc64:
8061 case llvm::Triple::ppc64le:
8063 case llvm::Triple::sparc:
8064 case llvm::Triple::sparcel:
8065 return "elf32_sparc";
8066 case llvm::Triple::sparcv9:
8067 return "elf64_sparc";
8068 case llvm::Triple::mips:
8069 return "elf32btsmip";
8070 case llvm::Triple::mipsel:
8071 return "elf32ltsmip";
8072 case llvm::Triple::mips64:
8074 return "elf32btsmipn32";
8075 return "elf64btsmip";
8076 case llvm::Triple::mips64el:
8078 return "elf32ltsmipn32";
8079 return "elf64ltsmip";
8080 case llvm::Triple::systemz:
8081 return "elf64_s390";
8082 case llvm::Triple::x86_64:
8083 if (T.getEnvironment() == llvm::Triple::GNUX32)
8084 return "elf32_x86_64";
8085 return "elf_x86_64";
8087 llvm_unreachable(
"Unexpected arch");
8094 const ArgList &Args,
8095 const char *LinkingOutput)
const {
8099 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
8100 const bool isAndroid =
8101 ToolChain.
getTriple().getEnvironment() == llvm::Triple::Android;
8103 !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
8104 (Args.hasArg(options::OPT_pie) || ToolChain.
isPIEDefault());
8106 ArgStringList CmdArgs;
8109 Args.ClaimAllArgs(options::OPT_g_Group);
8111 Args.ClaimAllArgs(options::OPT_emit_llvm);
8114 Args.ClaimAllArgs(options::OPT_w);
8117 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
8120 CmdArgs.push_back(
"-pie");
8122 if (Args.hasArg(options::OPT_rdynamic))
8123 CmdArgs.push_back(
"-export-dynamic");
8125 if (Args.hasArg(options::OPT_s))
8126 CmdArgs.push_back(
"-s");
8128 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
8131 llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
8133 for (
const auto &Opt : ToolChain.
ExtraOpts)
8134 CmdArgs.push_back(Opt.c_str());
8136 if (!Args.hasArg(options::OPT_static)) {
8137 CmdArgs.push_back(
"--eh-frame-hdr");
8140 CmdArgs.push_back(
"-m");
8143 if (Args.hasArg(options::OPT_static)) {
8144 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8145 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
8146 CmdArgs.push_back(
"-Bstatic");
8148 CmdArgs.push_back(
"-static");
8149 }
else if (Args.hasArg(options::OPT_shared)) {
8150 CmdArgs.push_back(
"-shared");
8153 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8154 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
8155 (!Args.hasArg(options::OPT_static) &&
8156 !Args.hasArg(options::OPT_shared))) {
8157 CmdArgs.push_back(
"-dynamic-linker");
8158 CmdArgs.push_back(Args.MakeArgString(
8162 CmdArgs.push_back(
"-o");
8165 if (!Args.hasArg(options::OPT_nostdlib) &&
8166 !Args.hasArg(options::OPT_nostartfiles)) {
8168 const char *crt1 =
nullptr;
8169 if (!Args.hasArg(options::OPT_shared)) {
8170 if (Args.hasArg(options::OPT_pg))
8178 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
8180 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
8183 const char *crtbegin;
8184 if (Args.hasArg(options::OPT_static))
8185 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
8186 else if (Args.hasArg(options::OPT_shared))
8187 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
8189 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
8191 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
8192 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
8198 Args.AddAllArgs(CmdArgs, options::OPT_L);
8199 Args.AddAllArgs(CmdArgs, options::OPT_u);
8203 for (
const auto &Path : Paths)
8204 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + Path));
8209 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8210 CmdArgs.push_back(
"--no-demangle");
8217 if (D.
CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8218 !Args.hasArg(options::OPT_nodefaultlibs)) {
8219 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8220 !Args.hasArg(options::OPT_static);
8221 if (OnlyLibstdcxxStatic)
8222 CmdArgs.push_back(
"-Bstatic");
8224 if (OnlyLibstdcxxStatic)
8225 CmdArgs.push_back(
"-Bdynamic");
8226 CmdArgs.push_back(
"-lm");
8229 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
8231 if (!Args.hasArg(options::OPT_nostdlib)) {
8232 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8233 if (Args.hasArg(options::OPT_static))
8234 CmdArgs.push_back(
"--start-group");
8236 if (NeedsSanitizerDeps)
8239 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8240 Args.hasArg(options::OPT_pthreads);
8242 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8243 options::OPT_fno_openmp,
false)) {
8251 CmdArgs.push_back(
"-lomp");
8254 CmdArgs.push_back(
"-lgomp");
8258 CmdArgs.push_back(
"-lrt");
8261 CmdArgs.push_back(
"-liomp5");
8271 if (WantPthread && !isAndroid)
8272 CmdArgs.push_back(
"-lpthread");
8274 CmdArgs.push_back(
"-lc");
8276 if (Args.hasArg(options::OPT_static))
8277 CmdArgs.push_back(
"--end-group");
8282 if (!Args.hasArg(options::OPT_nostartfiles)) {
8284 if (Args.hasArg(options::OPT_shared))
8285 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
8287 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
8289 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
8291 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
8293 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
8298 llvm::make_unique<Command>(JA, *
this, ToolChain.
Linker.c_str(), CmdArgs));
8308 const ArgList &Args,
8309 const char *LinkingOutput)
const {
8313 "nacl-arm-macros.s");
8315 NewInputs.push_back(NaClMacros);
8316 NewInputs.append(Inputs.begin(), Inputs.end());
8328 const ArgList &Args,
8329 const char *LinkingOutput)
const {
8334 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
8335 const bool IsStatic =
8336 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
8338 ArgStringList CmdArgs;
8341 Args.ClaimAllArgs(options::OPT_g_Group);
8343 Args.ClaimAllArgs(options::OPT_emit_llvm);
8346 Args.ClaimAllArgs(options::OPT_w);
8349 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
8351 if (Args.hasArg(options::OPT_rdynamic))
8352 CmdArgs.push_back(
"-export-dynamic");
8354 if (Args.hasArg(options::OPT_s))
8355 CmdArgs.push_back(
"-s");
8359 CmdArgs.push_back(
"--build-id");
8362 CmdArgs.push_back(
"--eh-frame-hdr");
8364 CmdArgs.push_back(
"-m");
8365 if (Arch == llvm::Triple::x86)
8366 CmdArgs.push_back(
"elf_i386_nacl");
8367 else if (Arch == llvm::Triple::arm)
8368 CmdArgs.push_back(
"armelf_nacl");
8369 else if (Arch == llvm::Triple::x86_64)
8370 CmdArgs.push_back(
"elf_x86_64_nacl");
8371 else if (Arch == llvm::Triple::mipsel)
8372 CmdArgs.push_back(
"mipselelf_nacl");
8378 CmdArgs.push_back(
"-static");
8379 else if (Args.hasArg(options::OPT_shared))
8380 CmdArgs.push_back(
"-shared");
8382 CmdArgs.push_back(
"-o");
8384 if (!Args.hasArg(options::OPT_nostdlib) &&
8385 !Args.hasArg(options::OPT_nostartfiles)) {
8386 if (!Args.hasArg(options::OPT_shared))
8387 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt1.o")));
8388 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
8390 const char *crtbegin;
8392 crtbegin =
"crtbeginT.o";
8393 else if (Args.hasArg(options::OPT_shared))
8394 crtbegin =
"crtbeginS.o";
8396 crtbegin =
"crtbegin.o";
8397 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
8400 Args.AddAllArgs(CmdArgs, options::OPT_L);
8401 Args.AddAllArgs(CmdArgs, options::OPT_u);
8405 for (
const auto &Path : Paths)
8406 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + Path));
8408 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8409 CmdArgs.push_back(
"--no-demangle");
8413 if (D.
CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8414 !Args.hasArg(options::OPT_nodefaultlibs)) {
8415 bool OnlyLibstdcxxStatic =
8416 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
8417 if (OnlyLibstdcxxStatic)
8418 CmdArgs.push_back(
"-Bstatic");
8420 if (OnlyLibstdcxxStatic)
8421 CmdArgs.push_back(
"-Bdynamic");
8422 CmdArgs.push_back(
"-lm");
8425 if (!Args.hasArg(options::OPT_nostdlib)) {
8426 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8428 CmdArgs.push_back(
"--start-group");
8429 CmdArgs.push_back(
"-lc");
8432 if (Args.hasArg(options::OPT_pthread) ||
8433 Args.hasArg(options::OPT_pthreads) || D.
CCCIsCXX()) {
8438 if (getToolChain().getArch() == llvm::Triple::mipsel)
8439 CmdArgs.push_back(
"-lnacl");
8441 CmdArgs.push_back(
"-lpthread");
8444 CmdArgs.push_back(
"-lgcc");
8445 CmdArgs.push_back(
"--as-needed");
8447 CmdArgs.push_back(
"-lgcc_eh");
8449 CmdArgs.push_back(
"-lgcc_s");
8450 CmdArgs.push_back(
"--no-as-needed");
8455 if (getToolChain().getArch() == llvm::Triple::mipsel)
8456 CmdArgs.push_back(
"-lpnacl_legacy");
8458 CmdArgs.push_back(
"--end-group");
8461 if (!Args.hasArg(options::OPT_nostartfiles)) {
8463 if (Args.hasArg(options::OPT_shared))
8464 crtend =
"crtendS.o";
8466 crtend =
"crtend.o";
8468 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
8469 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
8474 llvm::make_unique<Command>(JA, *
this, ToolChain.
Linker.c_str(), CmdArgs));
8480 const ArgList &Args,
8481 const char *LinkingOutput)
const {
8483 ArgStringList CmdArgs;
8485 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8487 CmdArgs.push_back(
"-o");
8490 for (
const auto &II : Inputs)
8491 CmdArgs.push_back(II.getFilename());
8493 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
8494 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
8500 const ArgList &Args,
8501 const char *LinkingOutput)
const {
8502 const Driver &D = getToolChain().getDriver();
8503 ArgStringList CmdArgs;
8506 CmdArgs.push_back(
"-o");
8509 assert(Output.
isNothing() &&
"Invalid output.");
8512 if (!Args.hasArg(options::OPT_nostdlib) &&
8513 !Args.hasArg(options::OPT_nostartfiles)) {
8514 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crt1.o")));
8515 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
8517 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
8518 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
8521 Args.AddAllArgs(CmdArgs, options::OPT_L);
8522 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8523 Args.AddAllArgs(CmdArgs, options::OPT_e);
8529 if (!Args.hasArg(options::OPT_nostdlib) &&
8530 !Args.hasArg(options::OPT_nodefaultlibs)) {
8532 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8533 CmdArgs.push_back(
"-lm");
8537 if (!Args.hasArg(options::OPT_nostdlib) &&
8538 !Args.hasArg(options::OPT_nostartfiles)) {
8539 if (Args.hasArg(options::OPT_pthread))
8540 CmdArgs.push_back(
"-lpthread");
8541 CmdArgs.push_back(
"-lc");
8542 CmdArgs.push_back(
"-lCompilerRT-Generic");
8543 CmdArgs.push_back(
"-L/usr/pkg/compiler-rt/lib");
8545 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
8548 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
8549 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
8559 const ArgList &Args,
8560 const char *LinkingOutput)
const {
8562 ArgStringList CmdArgs;
8566 if (getToolChain().getArch() == llvm::Triple::x86)
8567 CmdArgs.push_back(
"--32");
8569 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8571 CmdArgs.push_back(
"-o");
8574 for (
const auto &II : Inputs)
8575 CmdArgs.push_back(II.getFilename());
8577 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
8578 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
8584 const ArgList &Args,
8585 const char *LinkingOutput)
const {
8586 const Driver &D = getToolChain().getDriver();
8587 ArgStringList CmdArgs;
8588 bool UseGCC47 = llvm::sys::fs::exists(
"/usr/lib/gcc47");
8591 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
8593 CmdArgs.push_back(
"--eh-frame-hdr");
8594 if (Args.hasArg(options::OPT_static)) {
8595 CmdArgs.push_back(
"-Bstatic");
8597 if (Args.hasArg(options::OPT_rdynamic))
8598 CmdArgs.push_back(
"-export-dynamic");
8599 if (Args.hasArg(options::OPT_shared))
8600 CmdArgs.push_back(
"-Bshareable");
8602 CmdArgs.push_back(
"-dynamic-linker");
8603 CmdArgs.push_back(
"/usr/libexec/ld-elf.so.2");
8605 CmdArgs.push_back(
"--hash-style=both");
8610 if (getToolChain().getArch() == llvm::Triple::x86) {
8611 CmdArgs.push_back(
"-m");
8612 CmdArgs.push_back(
"elf_i386");
8616 CmdArgs.push_back(
"-o");
8619 assert(Output.
isNothing() &&
"Invalid output.");
8622 if (!Args.hasArg(options::OPT_nostdlib) &&
8623 !Args.hasArg(options::OPT_nostartfiles)) {
8624 if (!Args.hasArg(options::OPT_shared)) {
8625 if (Args.hasArg(options::OPT_pg))
8627 Args.MakeArgString(getToolChain().GetFilePath(
"gcrt1.o")));
8629 if (Args.hasArg(options::OPT_pie))
8631 Args.MakeArgString(getToolChain().GetFilePath(
"Scrt1.o")));
8634 Args.MakeArgString(getToolChain().GetFilePath(
"crt1.o")));
8637 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crti.o")));
8638 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8640 Args.MakeArgString(getToolChain().GetFilePath(
"crtbeginS.o")));
8643 Args.MakeArgString(getToolChain().GetFilePath(
"crtbegin.o")));
8646 Args.AddAllArgs(CmdArgs, options::OPT_L);
8647 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8648 Args.AddAllArgs(CmdArgs, options::OPT_e);
8652 if (!Args.hasArg(options::OPT_nostdlib) &&
8653 !Args.hasArg(options::OPT_nodefaultlibs)) {
8657 CmdArgs.push_back(
"-L/usr/lib/gcc47");
8659 CmdArgs.push_back(
"-L/usr/lib/gcc44");
8661 if (!Args.hasArg(options::OPT_static)) {
8663 CmdArgs.push_back(
"-rpath");
8664 CmdArgs.push_back(
"/usr/lib/gcc47");
8666 CmdArgs.push_back(
"-rpath");
8667 CmdArgs.push_back(
"/usr/lib/gcc44");
8672 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8673 CmdArgs.push_back(
"-lm");
8676 if (Args.hasArg(options::OPT_pthread))
8677 CmdArgs.push_back(
"-lpthread");
8679 if (!Args.hasArg(options::OPT_nolibc)) {
8680 CmdArgs.push_back(
"-lc");
8684 if (Args.hasArg(options::OPT_static) ||
8685 Args.hasArg(options::OPT_static_libgcc)) {
8686 CmdArgs.push_back(
"-lgcc");
8687 CmdArgs.push_back(
"-lgcc_eh");
8689 if (Args.hasArg(options::OPT_shared_libgcc)) {
8690 CmdArgs.push_back(
"-lgcc_pic");
8691 if (!Args.hasArg(options::OPT_shared))
8692 CmdArgs.push_back(
"-lgcc");
8694 CmdArgs.push_back(
"-lgcc");
8695 CmdArgs.push_back(
"--as-needed");
8696 CmdArgs.push_back(
"-lgcc_pic");
8697 CmdArgs.push_back(
"--no-as-needed");
8701 if (Args.hasArg(options::OPT_shared)) {
8702 CmdArgs.push_back(
"-lgcc_pic");
8704 CmdArgs.push_back(
"-lgcc");
8709 if (!Args.hasArg(options::OPT_nostdlib) &&
8710 !Args.hasArg(options::OPT_nostartfiles)) {
8711 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8713 Args.MakeArgString(getToolChain().GetFilePath(
"crtendS.o")));
8716 Args.MakeArgString(getToolChain().GetFilePath(
"crtend.o")));
8717 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
"crtn.o")));
8722 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
8723 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
8732 const char *ClangProgramPath) {
8734 std::string visualStudioBinDir;
8735 if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8736 visualStudioBinDir)) {
8738 llvm::sys::path::append(FilePath, Exe);
8739 if (llvm::sys::fs::can_execute(FilePath.c_str()))
8740 return FilePath.str();
8749 const ArgList &Args,
8750 const char *LinkingOutput)
const {
8751 ArgStringList CmdArgs;
8757 Args.MakeArgString(std::string(
"-out:") + Output.
getFilename()));
8759 if (!Args.hasArg(options::OPT_nostdlib) &&
8761 CmdArgs.push_back(
"-defaultlib:libcmt");
8763 if (!llvm::sys::Process::GetEnv(
"LIB")) {
8768 std::string VisualStudioDir;
8770 if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8772 llvm::sys::path::append(LibDir,
"VC",
"lib");
8773 switch (MSVC.getArch()) {
8774 case llvm::Triple::x86:
8777 case llvm::Triple::x86_64:
8778 llvm::sys::path::append(LibDir,
"amd64");
8780 case llvm::Triple::arm:
8781 llvm::sys::path::append(LibDir,
"arm");
8787 Args.MakeArgString(std::string(
"-libpath:") + LibDir.c_str()));
8790 std::string WindowsSdkLibPath;
8791 if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8792 CmdArgs.push_back(Args.MakeArgString(std::string(
"-libpath:") +
8793 WindowsSdkLibPath.c_str()));
8796 CmdArgs.push_back(
"-nologo");
8798 if (Args.hasArg(options::OPT_g_Group))
8799 CmdArgs.push_back(
"-debug");
8801 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
8802 options::OPT_shared);
8804 CmdArgs.push_back(Args.MakeArgString(
"-dll"));
8807 llvm::sys::path::replace_extension(ImplibName,
"lib");
8808 CmdArgs.push_back(Args.MakeArgString(std::string(
"-implib:") + ImplibName));
8812 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
8813 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
8814 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
8815 static const char *CompilerRTComponents[] = {
8816 "asan_dynamic",
"asan_dynamic_runtime_thunk",
8818 for (
const auto &Component : CompilerRTComponents)
8819 CmdArgs.push_back(Args.MakeArgString(
getCompilerRT(TC, Component)));
8822 CmdArgs.push_back(Args.MakeArgString(
"-include:___asan_seh_interceptor"));
8827 static const char *CompilerRTComponents[] = {
8830 for (
const auto &Component : CompilerRTComponents)
8831 CmdArgs.push_back(Args.MakeArgString(
getCompilerRT(TC, Component)));
8835 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
8838 for (
const auto &
Input : Inputs) {
8839 if (
Input.isFilename()) {
8840 CmdArgs.push_back(
Input.getFilename());
8844 const Arg &A =
Input.getInputArg();
8847 if (A.getOption().matches(options::OPT_l)) {
8848 StringRef Lib = A.getValue();
8849 const char *LinkLibArg;
8850 if (Lib.endswith(
".lib"))
8851 LinkLibArg = Args.MakeArgString(Lib);
8853 LinkLibArg = Args.MakeArgString(Lib +
".lib");
8854 CmdArgs.push_back(LinkLibArg);
8860 A.renderAsInput(Args, CmdArgs);
8867 StringRef
Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ,
"link");
8868 if (Linker.equals_lower(
"lld"))
8869 Linker =
"lld-link";
8871 if (Linker.equals_lower(
"link")) {
8879 llvm::sys::path::replace_extension(linkPath,
"exe");
8883 const char *Exec = Args.MakeArgString(linkPath);
8884 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
8890 const ArgList &Args,
8891 const char *LinkingOutput)
const {
8892 C.
addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8898 const char *LinkingOutput)
const {
8899 ArgStringList CmdArgs;
8900 CmdArgs.push_back(
"/nologo");
8901 CmdArgs.push_back(
"/c");
8902 CmdArgs.push_back(
"/W0");
8908 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8909 Args.AddAllArgs(CmdArgs, options::OPT_I);
8912 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8913 if (A->getOption().getID() == options::OPT_O0) {
8914 CmdArgs.push_back(
"/Od");
8916 StringRef OptLevel = A->getValue();
8917 if (OptLevel ==
"1" || OptLevel ==
"2" || OptLevel ==
"s")
8918 A->render(Args, CmdArgs);
8919 else if (OptLevel ==
"3")
8920 CmdArgs.push_back(
"/Ox");
8927 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8929 CmdArgs.push_back(
"/GR-");
8930 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8931 options::OPT_fno_function_sections))
8932 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8935 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8936 options::OPT_fno_data_sections))
8938 A->getOption().getID() == options::OPT_fdata_sections ?
"/Gw" :
"/Gw-");
8939 if (Args.hasArg(options::OPT_fsyntax_only))
8940 CmdArgs.push_back(
"/Zs");
8941 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8942 CmdArgs.push_back(
"/Z7");
8944 std::vector<std::string> Includes =
8945 Args.getAllArgValues(options::OPT_include);
8946 for (
const auto &Include : Includes)
8947 CmdArgs.push_back(Args.MakeArgString(std::string(
"/FI") + Include));
8950 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8951 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
8952 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
8955 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8956 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8957 A->render(Args, CmdArgs);
8960 assert(Inputs.size() == 1);
8962 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8963 CmdArgs.push_back(II.getType() == types::TY_C ?
"/Tc" :
"/Tp");
8964 if (II.isFilename())
8965 CmdArgs.push_back(II.getFilename());
8967 II.getInputArg().renderAsInput(Args, CmdArgs);
8970 assert(Output.
getType() == types::TY_Object);
8972 Args.MakeArgString(std::string(
"/Fo") + Output.
getFilename());
8973 CmdArgs.push_back(Fo);
8975 const Driver &D = getToolChain().getDriver();
8978 return llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec),
8986 const ArgList &Args,
8987 const char *LinkingOutput)
const {
8989 ArgStringList CmdArgs;
8991 if (getToolChain().getArch() == llvm::Triple::x86) {
8992 CmdArgs.push_back(
"--32");
8993 }
else if (getToolChain().getArch() == llvm::Triple::x86_64) {
8994 CmdArgs.push_back(
"--64");
8997 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8999 CmdArgs.push_back(
"-o");
9002 for (
const auto &II : Inputs)
9003 CmdArgs.push_back(II.getFilename());
9005 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
9006 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
9008 if (Args.hasArg(options::OPT_gsplit_dwarf))
9013 void MinGW::Linker::AddLibGCC(
const ArgList &Args,
9014 ArgStringList &CmdArgs)
const {
9015 if (Args.hasArg(options::OPT_mthreads))
9016 CmdArgs.push_back(
"-lmingwthrd");
9017 CmdArgs.push_back(
"-lmingw32");
9020 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
9022 CmdArgs.push_back(
"-lmoldname");
9023 CmdArgs.push_back(
"-lmingwex");
9024 CmdArgs.push_back(
"-lmsvcrt");
9030 const ArgList &Args,
9031 const char *LinkingOutput)
const {
9036 ArgStringList CmdArgs;
9039 Args.ClaimAllArgs(options::OPT_g_Group);
9041 Args.ClaimAllArgs(options::OPT_emit_llvm);
9044 Args.ClaimAllArgs(options::OPT_w);
9046 StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ,
"ld");
9047 if (LinkerName.equals_lower(
"lld")) {
9048 CmdArgs.push_back(
"-flavor");
9049 CmdArgs.push_back(
"gnu");
9053 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
9055 if (Args.hasArg(options::OPT_s))
9056 CmdArgs.push_back(
"-s");
9058 CmdArgs.push_back(
"-m");
9059 if (TC.
getArch() == llvm::Triple::x86)
9060 CmdArgs.push_back(
"i386pe");
9061 if (TC.
getArch() == llvm::Triple::x86_64)
9062 CmdArgs.push_back(
"i386pep");
9063 if (TC.
getArch() == llvm::Triple::arm)
9064 CmdArgs.push_back(
"thumb2pe");
9066 if (Args.hasArg(options::OPT_mwindows)) {
9067 CmdArgs.push_back(
"--subsystem");
9068 CmdArgs.push_back(
"windows");
9069 }
else if (Args.hasArg(options::OPT_mconsole)) {
9070 CmdArgs.push_back(
"--subsystem");
9071 CmdArgs.push_back(
"console");
9074 if (Args.hasArg(options::OPT_static))
9075 CmdArgs.push_back(
"-Bstatic");
9077 if (Args.hasArg(options::OPT_mdll))
9078 CmdArgs.push_back(
"--dll");
9079 else if (Args.hasArg(options::OPT_shared))
9080 CmdArgs.push_back(
"--shared");
9081 CmdArgs.push_back(
"-Bdynamic");
9082 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
9083 CmdArgs.push_back(
"-e");
9084 if (TC.
getArch() == llvm::Triple::x86)
9085 CmdArgs.push_back(
"_DllMainCRTStartup@12");
9087 CmdArgs.push_back(
"DllMainCRTStartup");
9088 CmdArgs.push_back(
"--enable-auto-image-base");
9092 CmdArgs.push_back(
"-o");
9095 Args.AddAllArgs(CmdArgs, options::OPT_e);
9097 Args.AddLastArg(CmdArgs, options::OPT_r);
9098 Args.AddLastArg(CmdArgs, options::OPT_s);
9099 Args.AddLastArg(CmdArgs, options::OPT_t);
9100 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
9101 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
9103 if (!Args.hasArg(options::OPT_nostdlib) &&
9104 !Args.hasArg(options::OPT_nostartfiles)) {
9105 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
9106 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"dllcrt2.o")));
9108 if (Args.hasArg(options::OPT_municode))
9109 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2u.o")));
9111 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2.o")));
9113 if (Args.hasArg(options::OPT_pg))
9114 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"gcrt2.o")));
9115 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtbegin.o")));
9118 Args.AddAllArgs(CmdArgs, options::OPT_L);
9120 for (
const auto &Path : Paths)
9121 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + Path));
9129 if (D.
CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9130 !Args.hasArg(options::OPT_nodefaultlibs)) {
9131 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
9132 !Args.hasArg(options::OPT_static);
9133 if (OnlyLibstdcxxStatic)
9134 CmdArgs.push_back(
"-Bstatic");
9136 if (OnlyLibstdcxxStatic)
9137 CmdArgs.push_back(
"-Bdynamic");
9140 if (!Args.hasArg(options::OPT_nostdlib)) {
9141 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9142 if (Args.hasArg(options::OPT_static))
9143 CmdArgs.push_back(
"--start-group");
9145 if (Args.hasArg(options::OPT_fstack_protector) ||
9146 Args.hasArg(options::OPT_fstack_protector_strong) ||
9147 Args.hasArg(options::OPT_fstack_protector_all)) {
9148 CmdArgs.push_back(
"-lssp_nonshared");
9149 CmdArgs.push_back(
"-lssp");
9151 if (Args.hasArg(options::OPT_fopenmp))
9152 CmdArgs.push_back(
"-lgomp");
9154 AddLibGCC(Args, CmdArgs);
9156 if (Args.hasArg(options::OPT_pg))
9157 CmdArgs.push_back(
"-lgmon");
9159 if (Args.hasArg(options::OPT_pthread))
9160 CmdArgs.push_back(
"-lpthread");
9163 if (Args.hasArg(options::OPT_mwindows)) {
9164 CmdArgs.push_back(
"-lgdi32");
9165 CmdArgs.push_back(
"-lcomdlg32");
9167 CmdArgs.push_back(
"-ladvapi32");
9168 CmdArgs.push_back(
"-lshell32");
9169 CmdArgs.push_back(
"-luser32");
9170 CmdArgs.push_back(
"-lkernel32");
9172 if (Args.hasArg(options::OPT_static))
9173 CmdArgs.push_back(
"--end-group");
9174 else if (!LinkerName.equals_lower(
"lld"))
9175 AddLibGCC(Args, CmdArgs);
9178 if (!Args.hasArg(options::OPT_nostartfiles)) {
9182 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtend.o")));
9185 const char *Exec = Args.MakeArgString(TC.
GetProgramPath(LinkerName.data()));
9186 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
9195 const ArgList &Args,
9196 const char *LinkingOutput)
const {
9198 ArgStringList CmdArgs;
9200 CmdArgs.push_back(
"-o");
9203 CmdArgs.push_back(
"-c");
9205 if (Args.hasArg(options::OPT_v))
9206 CmdArgs.push_back(
"-v");
9208 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
9209 if (!A->getOption().matches(options::OPT_g0))
9210 CmdArgs.push_back(
"-g");
9212 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
9214 CmdArgs.push_back(
"-fverbose-asm");
9216 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9218 for (
const auto &II : Inputs)
9219 CmdArgs.push_back(II.getFilename());
9221 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"xcc"));
9222 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
9228 const ArgList &Args,
9229 const char *LinkingOutput)
const {
9230 ArgStringList CmdArgs;
9233 CmdArgs.push_back(
"-o");
9236 assert(Output.
isNothing() &&
"Invalid output.");
9239 if (Args.hasArg(options::OPT_v))
9240 CmdArgs.push_back(
"-v");
9243 if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
9245 CmdArgs.push_back(
"-fexceptions");
9249 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"xcc"));
9250 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
9256 const ArgList &Args,
9257 const char *LinkingOutput)
const {
9261 ArgStringList CmdArgs;
9264 switch (TC.getArch()) {
9266 llvm_unreachable(
"unsupported architecture");
9267 case llvm::Triple::arm:
9268 case llvm::Triple::thumb:
9270 case llvm::Triple::x86:
9271 CmdArgs.push_back(
"--32");
9273 case llvm::Triple::x86_64:
9274 CmdArgs.push_back(
"--64");
9278 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9280 CmdArgs.push_back(
"-o");
9283 for (
const auto &
Input : Inputs)
9284 CmdArgs.push_back(
Input.getFilename());
9286 const std::string
Assembler = TC.GetProgramPath(
"as");
9287 Exec = Args.MakeArgString(Assembler);
9289 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
9295 const ArgList &Args,
9296 const char *LinkingOutput)
const {
9300 const Driver &D = TC.getDriver();
9302 ArgStringList CmdArgs;
9306 Args.ClaimAllArgs(options::OPT_g_Group);
9308 Args.ClaimAllArgs(options::OPT_emit_llvm);
9310 Args.ClaimAllArgs(options::OPT_w);
9314 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
9316 if (Args.hasArg(options::OPT_pie))
9317 CmdArgs.push_back(
"-pie");
9318 if (Args.hasArg(options::OPT_rdynamic))
9319 CmdArgs.push_back(
"-export-dynamic");
9320 if (Args.hasArg(options::OPT_s))
9321 CmdArgs.push_back(
"--strip-all");
9323 CmdArgs.push_back(
"-m");
9324 switch (TC.getArch()) {
9326 llvm_unreachable(
"unsupported architecture");
9327 case llvm::Triple::arm:
9328 case llvm::Triple::thumb:
9330 CmdArgs.push_back(
"thumb2pe");
9332 case llvm::Triple::x86:
9333 CmdArgs.push_back(
"i386pe");
9334 EntryPoint.append(
"_");
9336 case llvm::Triple::x86_64:
9337 CmdArgs.push_back(
"i386pep");
9341 if (Args.hasArg(options::OPT_shared)) {
9342 switch (T.getArch()) {
9344 llvm_unreachable(
"unsupported architecture");
9345 case llvm::Triple::arm:
9346 case llvm::Triple::thumb:
9347 case llvm::Triple::x86_64:
9348 EntryPoint.append(
"_DllMainCRTStartup");
9350 case llvm::Triple::x86:
9351 EntryPoint.append(
"_DllMainCRTStartup@12");
9355 CmdArgs.push_back(
"-shared");
9356 CmdArgs.push_back(
"-Bdynamic");
9358 CmdArgs.push_back(
"--enable-auto-image-base");
9360 CmdArgs.push_back(
"--entry");
9361 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9363 EntryPoint.append(
"mainCRTStartup");
9365 CmdArgs.push_back(Args.hasArg(options::OPT_static) ?
"-Bstatic"
9368 if (!Args.hasArg(options::OPT_nostdlib) &&
9369 !Args.hasArg(options::OPT_nostartfiles)) {
9370 CmdArgs.push_back(
"--entry");
9371 CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9378 CmdArgs.push_back(
"--allow-multiple-definition");
9380 CmdArgs.push_back(
"-o");
9383 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
9385 llvm::sys::path::replace_extension(ImpLib,
".lib");
9387 CmdArgs.push_back(
"--out-implib");
9388 CmdArgs.push_back(Args.MakeArgString(ImpLib));
9391 if (!Args.hasArg(options::OPT_nostdlib) &&
9392 !Args.hasArg(options::OPT_nostartfiles)) {
9393 const std::string CRTPath(D.
SysRoot +
"/usr/lib/");
9394 const char *CRTBegin;
9397 Args.hasArg(options::OPT_shared) ?
"crtbeginS.obj" :
"crtbegin.obj";
9398 CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
9401 Args.AddAllArgs(CmdArgs, options::OPT_L);
9403 const auto &Paths = TC.getFilePaths();
9404 for (
const auto &Path : Paths)
9405 CmdArgs.push_back(Args.MakeArgString(StringRef(
"-L") + Path));
9409 if (D.
CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9410 !Args.hasArg(options::OPT_nodefaultlibs)) {
9411 bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
9412 !Args.hasArg(options::OPT_static);
9414 CmdArgs.push_back(
"-Bstatic");
9415 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9417 CmdArgs.push_back(
"-Bdynamic");
9420 if (!Args.hasArg(options::OPT_nostdlib)) {
9421 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9423 CmdArgs.push_back(
"-lmsvcrt");
9428 const std::string
Linker = TC.GetProgramPath(
"ld");
9429 Exec = Args.MakeArgString(Linker);
9431 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs));
9437 const ArgList &Args,
9438 const char *LinkingOutput)
const {
9440 ArgStringList CmdArgs;
9442 assert(Inputs.size() == 1);
9444 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9445 assert(Output.
getType() == types::TY_PP_Asm);
9448 Args.AddAllArgs(CmdArgs, options::OPT_clang_i_Group);
9450 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
9452 CmdArgs.push_back(
"-DMYRIAD2");
9453 CmdArgs.push_back(
"-mcpu=myriad2");
9454 CmdArgs.push_back(
"-S");
9457 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
9458 A->render(Args, CmdArgs);
9460 if (Args.hasFlag(options::OPT_ffunction_sections,
9461 options::OPT_fno_function_sections)) {
9462 CmdArgs.push_back(
"-ffunction-sections");
9464 if (Args.hasArg(options::OPT_fno_inline_functions))
9465 CmdArgs.push_back(
"-fno-inline-functions");
9467 CmdArgs.push_back(
"-fno-exceptions");
9469 CmdArgs.push_back(II.getFilename());
9470 CmdArgs.push_back(
"-o");
9474 Args.MakeArgString(getToolChain().GetProgramPath(
"moviCompile"));
9476 llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec), CmdArgs));
9482 const ArgList &Args,
9483 const char *LinkingOutput)
const {
9484 ArgStringList CmdArgs;
9486 assert(Inputs.size() == 1);
9488 assert(II.getType() == types::TY_PP_Asm);
9489 assert(Output.
getType() == types::TY_Object);
9491 CmdArgs.push_back(
"-no6thSlotCompression");
9492 CmdArgs.push_back(
"-cv:myriad2");
9493 CmdArgs.push_back(
"-noSPrefixing");
9494 CmdArgs.push_back(
"-a");
9495 for (
auto Arg : Args.filtered(options::OPT_I)) {
9498 Args.MakeArgString(std::string(
"-i:") + Arg->getValue(0)));
9500 CmdArgs.push_back(
"-elf");
9501 CmdArgs.push_back(II.getFilename());
9503 Args.MakeArgString(std::string(
"-o:") + Output.
getFilename()));
9506 Args.MakeArgString(getToolChain().GetProgramPath(
"moviAsm"));
9508 llvm::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec), CmdArgs));
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...
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
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
std::string DyldPrefix
Dynamic loader prefix, if present.
bool canTypeBeUserSpecified(ID Id)
DiagnosticBuilder Diag(unsigned DiagID) const
static bool GetReleaseVersion(const char *Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
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.
unsigned CCLogDiagnostics
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
ActionClass getKind() const
std::string getAsString() const
Retrieve a string representation of the version number.
const llvm::opt::DerivedArgList & getArgs() const
bool IsUsingLTO(const llvm::opt::ArgList &Args) const
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
bool isSaveTempsEnabled() const
bool needsSharedAsanRt() const
ID getPreprocessedType(ID Id)
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.
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?
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.
unsigned getMajor() const
Retrieve the major version number.
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'.
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
ActionList & getActions()
const char * getClangProgramPath() const
Get the path to the main clang executable.
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
const char * CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
StringRef getSysRoot() const
Returns the sysroot path.
const char * addFailureResultFile(const char *Name, const JobAction *JA)
bool isForDiagnostics()
Return true if we're compiling for diagnostics.
const char * addTempFile(const char *Name)
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
std::string getAsString() const
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.