Lines Matching refs:Args
47 static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
48 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
64 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
65 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
66 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
67 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
69 << A->getBaseArg().getAsString(Args)
77 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
79 if (Args.hasArg(options::OPT_static))
80 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
83 << A->getAsString(Args) << "-static";
115 static void addDirectoryList(const ArgList &Args,
137 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
144 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
147 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
155 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
162 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
165 CmdArgs.push_back(Args.MakeArgString(Dirs));
171 const InputInfoList &Inputs, const ArgList &Args,
177 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
201 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
203 TC.AddCCKextLibArgs(Args, CmdArgs);
205 A.renderAsInput(Args, CmdArgs);
211 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
216 static bool isObjCAutoRefCount(const ArgList &Args) {
217 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
221 static bool isObjCRuntimeLinked(const ArgList &Args) {
222 if (isObjCAutoRefCount(Args)) {
223 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
226 return Args.hasArg(options::OPT_fobjc_link_runtime);
240 const ArgList &Args,
246 CheckPreprocessingOptions(D, Args);
248 Args.AddLastArg(CmdArgs, options::OPT_C);
249 Args.AddLastArg(CmdArgs, options::OPT_CC);
252 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
253 (A = Args.getLastArg(options::OPT_MD)) ||
254 (A = Args.getLastArg(options::OPT_MMD))) {
257 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
266 DepFile = getDependencyFileName(Args, Inputs);
273 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
278 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
287 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
293 CmdArgs.push_back(Args.MakeArgString(Quoted));
304 if (Args.hasArg(options::OPT_MG)) {
311 Args.AddLastArg(CmdArgs, options::OPT_MP);
313 // Convert all -MQ <target> args to -MT <quoted target>
314 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
316 ie = Args.filtered_end(); it != ie; ++it) {
324 CmdArgs.push_back(Args.MakeArgString(Quoted));
328 A->render(Args, CmdArgs);
338 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
339 ie = Args.filtered_end(); it != ie; ++it) {
382 CmdArgs.push_back(Args.MakeArgString(P.str()));
387 << P.str() << A->getAsString(Args);
394 A->render(Args, CmdArgs);
397 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
398 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
407 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
411 if (Arg *A = Args.getLastArg(options::OPT_I_))
412 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
418 if (!Args.hasArg(options::OPT_isysroot)) {
429 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
431 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
433 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
435 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
437 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
441 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
444 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
491 const ArgList &Args,
506 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
511 const ArgList &Args,
527 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
535 const ArgList &Args,
589 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
594 StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
597 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
608 << A->getAsString(Args);
624 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
667 arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
689 const ArgList &Args,
692 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
716 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
717 getARMFPUFeatures(D, A, Args, Features);
718 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
719 getARMHWDivFeatures(D, A, Args, Features);
730 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
739 void Clang::AddARMTargetArgs(const ArgList &Args,
744 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
746 std::string CPUName = arm::getARMTargetCPU(Args, Triple);
752 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
788 StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
824 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
830 if (!Args.hasFlag(options::OPT_mimplicit_float,
838 if (Args.hasArg(options::OPT_ffixed_r9)) {
846 static std::string getAArch64TargetCPU(const ArgList &Args) {
848 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
862 if (Args.getLastArg(options::OPT_arch))
868 void Clang::AddAArch64TargetArgs(const ArgList &Args,
870 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
873 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
874 Args.hasArg(options::OPT_mkernel) ||
875 Args.hasArg(options::OPT_fapple_kext))
878 if (!Args.hasFlag(options::OPT_mimplicit_float,
883 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
894 CmdArgs.push_back(Args.MakeArgString(getAArch64TargetCPU(Args)));
896 if (Args.hasArg(options::OPT_mstrict_align)) {
903 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
912 static void getMipsCPUAndABI(const ArgList &Args,
927 if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
931 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
985 static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
987 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
997 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1014 static void AddTargetFeature(const ArgList &Args,
1018 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1020 Features.push_back(Args.MakeArgString("+" + FeatureName));
1022 Features.push_back(Args.MakeArgString("-" + FeatureName));
1026 static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1028 StringRef FloatABI = getMipsFloatABI(D, Args);
1036 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1047 AddTargetFeature(Args, Features, options::OPT_msingle_float,
1049 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1051 AddTargetFeature(Args, Features, options::OPT_mmicromips,
1053 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1055 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1057 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1059 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1061 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1065 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1071 getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1076 StringRef FloatABI = getMipsFloatABI(D, Args);
1091 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1098 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1106 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1114 if (Arg *A = Args.getLastArg(options::OPT_G)) {
1117 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1123 static std::string getPPCTargetCPU(const ArgList &Args) {
1124 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1186 static void getPPCTargetFeatures(const ArgList &Args,
1188 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1189 ie = Args.filtered_end();
1209 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1213 AddTargetFeature(Args, Features, options::OPT_faltivec,
1218 static std::string getR600TargetGPU(const ArgList &Args) {
1219 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1234 static void getSparcTargetFeatures(const ArgList &Args,
1238 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1246 void Clang::AddSparcTargetArgs(const ArgList &Args,
1252 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1278 static const char *getSystemZTargetCPU(const ArgList &Args) {
1279 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1284 static const char *getX86TargetCPU(const ArgList &Args,
1286 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1301 return Args.MakeArgString(CPU);
1342 static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1351 return getAArch64TargetCPU(Args);
1357 return arm::getARMTargetCPU(Args, T);
1365 getMipsCPUAndABI(Args, T, CPUName, ABIName);
1372 std::string TargetCPUName = getPPCTargetCPU(Args);
1389 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1395 return getX86TargetCPU(Args, T);
1398 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1401 return getSystemZTargetCPU(Args);
1404 return getR600TargetGPU(Args);
1408 static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1415 CmdArgs.push_back(Args.MakeArgString(Plugin));
1421 std::string CPU = getCPUName(Args, ToolChain.getTriple());
1423 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1427 const ArgList &Args,
1451 Args.filtered_begin(options::OPT_m_x86_Features_Group),
1452 ie = Args.filtered_end();
1465 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1469 void Clang::AddX86TargetArgs(const ArgList &Args,
1471 if (!Args.hasFlag(options::OPT_mred_zone,
1474 Args.hasArg(options::OPT_mkernel) ||
1475 Args.hasArg(options::OPT_fapple_kext))
1480 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1481 Args.hasArg(options::OPT_fapple_kext));
1482 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1493 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1497 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1505 static inline bool HasPICArg(const ArgList &Args) {
1506 return Args.hasArg(options::OPT_fPIC)
1507 || Args.hasArg(options::OPT_fpic);
1510 static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1511 return Args.getLastArg(options::OPT_G,
1516 static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1518 if (HasPICArg(Args))
1520 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1527 void Clang::AddHexagonTargetArgs(const ArgList &Args,
1533 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1536 CmdArgs.push_back(Args.MakeArgString(
1540 if (!Args.hasArg(options::OPT_fno_short_enums))
1542 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1550 static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1553 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
1554 getAArch64FPUFeatures(D, A, Args, Features);
1558 if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1565 if (Arg *A = Args.getLastArg(options::OPT_mcrc,
1575 const ArgList &Args, ArgStringList &CmdArgs,
1585 getMIPSTargetFeatures(D, Args, Features);
1592 getARMTargetFeatures(D, Triple, Args, Features, ForAS);
1598 getPPCTargetFeatures(Args, Features);
1601 getSparcTargetFeatures(Args, Features);
1607 getAArch64TargetFeatures(D, Args, Features);
1611 getX86TargetFeatures(Triple, Args, Features);
1665 static ExceptionSettings exceptionSettings(const ArgList &Args,
1675 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1698 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1706 Args.ClaimAllArgs(options::OPT_fexceptions);
1707 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1708 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1709 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1710 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1711 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1716 ExceptionSettings ES = exceptionSettings(Args, Triple);
1721 Args.hasFlag(options::OPT_fobjc_exceptions,
1733 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1754 static bool ShouldDisableAutolink(const ArgList &Args,
1762 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1766 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1768 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1788 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1791 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1804 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1809 const ArgList &Args,
1812 if (UseRelaxAll(C, Args))
1825 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1827 ie = Args.filtered_end(); it != ie; ++it) {
1900 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1906 CmdArgs.push_back(Args.MakeArgString(LibClangRT));
1913 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1914 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1915 Args.hasArg(options::OPT_fprofile_generate) ||
1916 Args.hasArg(options::OPT_fprofile_instr_generate) ||
1917 Args.hasArg(options::OPT_fcreate_profile) ||
1918 Args.hasArg(options::OPT_coverage)))
1924 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
1925 Args.hasArg(options::OPT_shared))
1932 CmdArgs.push_back(Args.MakeArgString(LibProfile));
1950 static void addSanitizerRTLinkFlags(const ToolChain &TC, const ArgList &Args,
1967 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
1989 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1997 static void addAsanRT(const ToolChain &TC, const ArgList &Args,
2003 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibSanitizer));
2007 if (Args.hasArg(options::OPT_shared) ||
2012 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan-preinit",
2016 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
2018 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan_cxx", true);
2024 static void addTsanRT(const ToolChain &TC, const ArgList &Args,
2026 if (!Args.hasArg(options::OPT_shared))
2027 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
2032 static void addMsanRT(const ToolChain &TC, const ArgList &Args,
2034 if (!Args.hasArg(options::OPT_shared))
2035 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
2040 static void addLsanRT(const ToolChain &TC, const ArgList &Args,
2042 if (!Args.hasArg(options::OPT_shared))
2043 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
2048 static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
2052 if (Args.hasArg(options::OPT_shared))
2058 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
2060 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false, true);
2065 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false, true);
2068 static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
2070 if (!Args.hasArg(options::OPT_shared))
2071 addSanitizerRTLinkFlags(TC, Args, CmdArgs, "dfsan", true);
2075 static void addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2080 addUbsanRT(TC, Args, CmdArgs, D.CCCIsCXX(),
2084 addAsanRT(TC, Args, CmdArgs, Sanitize.needsSharedAsanRt(), D.CCCIsCXX());
2086 addTsanRT(TC, Args, CmdArgs);
2088 addMsanRT(TC, Args, CmdArgs);
2090 addLsanRT(TC, Args, CmdArgs);
2092 addDfsanRT(TC, Args, CmdArgs);
2095 static bool shouldUseFramePointerForTarget(const ArgList &Args,
2107 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2118 static bool shouldUseFramePointer(const ArgList &Args,
2120 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2124 return shouldUseFramePointerForTarget(Args, Triple);
2127 static bool shouldUseLeafFramePointer(const ArgList &Args,
2129 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2133 return shouldUseFramePointerForTarget(Args, Triple);
2137 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
2141 CmdArgs.push_back(Args.MakeArgString(cwd));
2145 static const char *SplitDebugName(const ArgList &Args,
2147 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2148 if (FinalOutput && Args.hasArg(options::OPT_c)) {
2151 return Args.MakeArgString(T);
2155 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2159 return Args.MakeArgString(F);
2165 const ArgList &Args, const InputInfo &Output,
2179 Args.MakeArgString(TC.GetProgramPath("objcopy"));
2190 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
2191 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2221 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2225 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2229 if (Args.hasArg(options::OPT_rewrite_objc))
2238 const ArgList &Args,
2240 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2259 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2260 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2291 if (Args.hasArg(options::OPT_rewrite_objc) &&
2292 !Args.hasArg(options::OPT_g_Group))
2298 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
2301 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2357 CmdArgs.push_back(getBaseInputName(Args, Inputs));
2361 if (Args.hasArg(options::OPT_static))
2374 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2401 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2412 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2415 CheckCodeGenerationOptions(D, Args);
2477 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2513 if (Args.hasArg(options::OPT_static))
2516 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2551 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2557 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
2560 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
2564 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2569 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2582 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2585 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
2587 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2591 bool OFastEnabled = isOptimizationLevelFast(Args);
2599 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
2602 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2605 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2608 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2613 if (Args.hasArg(options::OPT_fsplit_stack))
2626 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2636 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2649 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2671 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2682 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2693 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2704 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2720 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2726 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2734 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2743 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2747 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
2756 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2758 Args.hasArg(options::OPT_dA))
2761 if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
2765 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2769 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2784 if (Args.hasArg(options::OPT_mms_bitfields)) {
2792 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2797 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2801 getToolChain().addClangTargetOptions(Args, CmdArgs);
2803 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2809 (void) Args.hasArg(options::OPT_mtune_EQ);
2811 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2817 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2819 std::string CPU = getCPUName(Args, ETriple);
2822 CmdArgs.push_back(Args.MakeArgString(CPU));
2825 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2831 getTargetFeatures(D, ETriple, Args, CmdArgs, false);
2842 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
2849 AddAArch64TargetArgs(Args, CmdArgs);
2856 AddMIPSTargetArgs(Args, CmdArgs);
2860 AddSparcTargetArgs(Args, CmdArgs);
2865 AddX86TargetArgs(Args, CmdArgs);
2869 AddHexagonTargetArgs(Args, CmdArgs);
2875 AddClangCLArgs(Args, CmdArgs);
2878 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2883 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
2889 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2894 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2895 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2901 Args.AddAllArgs(CmdArgs, options::OPT_v);
2902 Args.AddLastArg(CmdArgs, options::OPT_H);
2908 Args.AddLastArg(CmdArgs, options::OPT_P);
2909 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2919 Args.ClaimAllArgs(options::OPT_g_Group);
2920 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2949 Args.ClaimAllArgs(options::OPT_g_flags_Group);
2950 if (Args.hasArg(options::OPT_gcolumn_info))
2958 Args.hasArg(options::OPT_gsplit_dwarf)) {
2965 if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2972 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
2977 if (Args.hasFlag(options::OPT_fdebug_types_section,
2983 if (Args.hasFlag(options::OPT_ffunction_sections,
2988 if (Args.hasFlag(options::OPT_fdata_sections,
2993 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2995 if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
2996 (Args.hasArg(options::OPT_fprofile_instr_use) ||
2997 Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
3001 Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
3003 if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
3004 A->render(Args, CmdArgs);
3005 else if (Args.hasArg(options::OPT_fprofile_instr_use))
3008 if (Args.hasArg(options::OPT_ftest_coverage) ||
3009 Args.hasArg(options::OPT_coverage))
3011 if (Args.hasArg(options::OPT_fprofile_arcs) ||
3012 Args.hasArg(options::OPT_coverage))
3027 CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
3032 if (Args.hasArg(options::OPT_nostdinc)) {
3036 if (Args.hasArg(options::OPT_nostdlibinc))
3038 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3039 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3046 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3049 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3050 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3068 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3069 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3074 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3075 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3076 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3079 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3082 << A->getAsString(Args) << "-ccc-arcmt-migrate";
3087 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3095 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3096 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3097 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3100 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3101 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3102 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3103 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3104 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3105 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3106 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3107 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3108 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3109 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3110 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3111 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3112 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3113 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3114 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
3122 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
3128 Args.ClaimAllArgs(options::OPT_D);
3131 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3136 A->render(Args, CmdArgs);
3142 Args.ClaimAllArgs(options::OPT_flto);
3144 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
3145 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3147 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
3148 Args.AddLastArg(CmdArgs, options::OPT_w);
3155 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3162 Std->render(Args, CmdArgs);
3164 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3167 A->render(Args, CmdArgs);
3176 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3181 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
3197 Args.getLastArg(options::OPT_Wwrite_strings,
3208 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3214 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3221 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3224 if (ShouldDisableAutolink(Args, getToolChain()))
3228 addDebugCompDirArg(Args, CmdArgs);
3230 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3236 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3241 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3246 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3251 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3256 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3260 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3266 if (Args.hasArg(options::OPT_relocatable_pch))
3269 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3274 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3280 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
3285 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3290 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3295 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3302 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
3308 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
3312 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3326 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
3328 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3331 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3336 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
3337 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
3338 Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3339 Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
3340 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3344 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
3345 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3346 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3349 Sanitize.addArgs(Args, CmdArgs);
3351 if (!Args.hasFlag(options::OPT_fsanitize_recover,
3356 if (Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3361 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
3366 << A->getAsString(Args) << "ppc/ppc64/ppc64le";
3369 Args.AddLastArg(CmdArgs, options::OPT_pg);
3372 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3376 if (Args.getLastArg(options::OPT_fapple_kext))
3379 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3380 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3381 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3382 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3383 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3385 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3390 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3394 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3398 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3404 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3409 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3410 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3413 Args.AddLastArg(CmdArgs, options::OPT_pthread);
3418 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3435 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3439 for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3440 ie = Args.filtered_end(); it != ie; ++it) {
3446 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3453 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3458 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3460 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3463 if (Args.hasArg(options::OPT_mstack_alignment)) {
3464 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3465 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
3469 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3493 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3511 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
3522 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3527 A->render(Args, CmdArgs);
3530 if (Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
3531 A->render(Args, CmdArgs);
3533 if (Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
3534 A->render(Args, CmdArgs);
3536 if (Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
3537 A->render(Args, CmdArgs);
3539 if (Args.hasArg(options::OPT_mkernel)) {
3540 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
3542 if (!Args.hasArg(options::OPT_fbuiltin))
3544 Args.ClaimAllArgs(options::OPT_fno_builtin);
3547 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
3550 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3555 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3557 (Args.hasArg(options::OPT_fgnu_runtime) &&
3558 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3559 !Args.hasArg(options::OPT_fno_blocks))) {
3562 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3571 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3572 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3583 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3590 if (Args.hasFlag(options::OPT_fmodules_decluse,
3598 if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3606 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name))
3607 A->render(Args, CmdArgs);
3611 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file))
3612 A->render(Args, CmdArgs);
3616 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3634 CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
3644 CmdArgs.push_back(Args.MakeArgString(VFSDir));
3647 if (Arg *A = Args.getLastArg(options::OPT_fmodules_user_build_path))
3649 A->render(Args, CmdArgs);
3652 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3653 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3654 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3656 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3658 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3659 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp))
3662 Args.AddLastArg(CmdArgs,
3666 Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
3669 if (Args.hasFlag(options::OPT_fno_access_control,
3675 if (Args.hasFlag(options::OPT_fno_elide_constructors,
3681 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
3688 Args.getLastArg(options::OPT_mkernel,
3690 options::OPT_fno_rtti)->getAsString(Args);
3697 if (Args.hasFlag(options::OPT_fshort_enums,
3704 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
3709 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3714 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
3723 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3728 if (Args.hasFlag(options::OPT_fms_compatibility,
3730 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
3736 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3737 IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version)) {
3738 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
3742 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3747 if (Args.hasFlag(options::OPT_fborland_extensions,
3753 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3759 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3761 A->render(Args, CmdArgs);
3763 if (Args.hasFlag(options::OPT_fgnu89_inline,
3768 if (Args.hasArg(options::OPT_fno_inline))
3771 if (Args.hasArg(options::OPT_fno_inline_functions))
3774 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3781 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3809 bool ARC = isObjCAutoRefCount(Args);
3819 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3827 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3840 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3842 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3846 << GCArg->getAsString(Args);
3848 GCArg->render(Args, CmdArgs);
3852 << GCArg->getAsString(Args);
3856 // Handle GCC-style exception args.
3858 addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
3865 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3871 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3873 !Args.hasFlag(options::OPT_mconstant_cfstrings,
3879 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3881 A->render(Args, CmdArgs);
3884 if (Args.hasFlag(options::OPT_fpascal_strings,
3891 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3894 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3895 } else if (Args.hasFlag(options::OPT_fpack_struct,
3901 if (!Args.hasArg(options::OPT_fcommon))
3903 Args.ClaimAllArgs(options::OPT_fno_common);
3907 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3912 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3915 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3918 if (!Args.hasFlag(options::OPT_ffor_scope,
3921 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3924 if (Arg *inputCharset = Args.getLastArg(
3928 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
3932 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3937 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3942 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3947 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3953 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3958 if (Arg *A = Args.getLastArg(
3973 for (const auto &Arg : Args) {
4007 if (Args.hasArg(options::OPT_fansi_escape_codes))
4010 if (!Args.hasFlag(options::OPT_fshow_source_location,
4014 if (!Args.hasFlag(options::OPT_fshow_column,
4019 if (!Args.hasFlag(options::OPT_fspell_checking,
4025 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4032 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
4035 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4040 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4043 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4048 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
4052 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4053 A->render(Args, CmdArgs);
4057 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4067 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4070 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4073 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4091 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4093 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4102 if (Args.hasFlag(options::OPT_frewrite_includes,
4108 if (Arg *A = Args.getLastArg(options::OPT_traditional,
4113 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
4116 Args.AddLastArg(CmdArgs, options::OPT_dM);
4117 Args.AddLastArg(CmdArgs, options::OPT_dD);
4120 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4122 CmdArgs.push_back(Args.MakeArgString(A->getValue()));
4125 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4129 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
4131 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
4135 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
4136 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
4137 ie = Args.filtered_end(); it != ie; ++it) {
4145 (*it)->render(Args, CmdArgs);
4158 addDashXForInput(Args, II, CmdArgs);
4163 II.getInputArg().renderAsInput(Args, CmdArgs);
4166 Args.AddAllArgs(CmdArgs, options::OPT_undef);
4174 for (const auto &Arg : Args)
4175 Arg->render(Args, OriginalArgs);
4184 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4189 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
4195 SplitDwarfOut = SplitDebugName(Args, Inputs);
4200 if (Args.hasArg(options::OPT__SLASH_fallback) &&
4204 Args, LinkingOutput);
4215 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
4217 if (Arg *A = Args.getLastArg(options::OPT_pg))
4218 if (Args.hasArg(options::OPT_fomit_frame_pointer))
4220 << "-fomit-frame-pointer" << A->getAsString(Args);
4227 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
4231 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4232 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
4235 Args.ClaimAllArgs(options::OPT_emit_llvm);
4241 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4245 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
4260 runtimeArg->render(args, cmdArgs);
4271 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
4288 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4298 if (Arg *abiArg = args.getLastArg(
4358 cmdArgs.push_back(args.MakeArgString(
4384 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
4386 std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
4402 void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
4405 if (Args.hasArg(options::OPT__SLASH_LDd))
4410 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
4415 if (Args.hasArg(options::OPT__SLASH_LDd))
4428 if (Args.hasArg(options::OPT__SLASH_LDd))
4447 if (Arg *A = Args.getLastArg(options::OPT_show_includes))
4448 A->render(Args, CmdArgs);
4451 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
4456 EHFlags EH = parseClangCLEHFlags(D, Args);
4464 if (Args.hasArg(options::OPT__SLASH_EP)) {
4469 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
4470 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
4473 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
4476 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
4477 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
4478 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
4484 << FirstConflict->getAsString(Args)
4485 << SecondConflict->getAsString(Args);
4495 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
4496 A->render(Args, CmdArgs);
4498 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
4500 if (Args.hasArg(options::OPT__SLASH_fallback))
4516 const ArgList &Args,
4524 Args.ClaimAllArgs(options::OPT_w);
4526 Args.ClaimAllArgs(options::OPT_emit_llvm);
4536 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
4537 CmdArgs.push_back(Args.MakeArgString(TripleStr));
4547 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4551 std::string CPU = getCPUName(Args, Triple);
4554 CmdArgs.push_back(Args.MakeArgString(CPU));
4559 getTargetFeatures(D, Triple, Args, CmdArgs, true);
4562 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
4575 Args.ClaimAllArgs(options::OPT_g_Group);
4576 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4580 if (Args.hasArg(options::OPT_gdwarf_2))
4582 if (Args.hasArg(options::OPT_gdwarf_3))
4584 if (Args.hasArg(options::OPT_gdwarf_4))
4588 addDebugCompDirArg(Args, CmdArgs);
4593 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
4600 for (const auto &Arg : Args)
4601 Arg->render(Args, OriginalArgs);
4611 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4621 for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
4622 ie = Args.filtered_end();
4626 CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4629 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
4644 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
4646 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4647 SplitDebugName(Args, Inputs));
4653 const ArgList &Args,
4658 for (const auto &A : Args) {
4675 A->render(Args, CmdArgs);
4694 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
4716 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4757 A.render(Args, CmdArgs);
4771 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4810 const ArgList &Args,
4817 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
4818 CmdArgs.push_back(Args.MakeArgString(MarchString));
4830 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4833 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4835 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4863 II.getInputArg().render(Args, CmdArgs);
4867 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4879 const ArgList &Args,
4891 bool hasStaticArg = Args.hasArg(options::OPT_static);
4892 bool buildingLib = Args.hasArg(options::OPT_shared);
4893 bool buildPIE = Args.hasArg(options::OPT_pie);
4894 bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4895 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4896 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4903 Args.ClaimAllArgs(options::OPT_g_Group);
4904 Args.ClaimAllArgs(options::OPT_emit_llvm);
4905 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4907 Args.ClaimAllArgs(options::OPT_static_libgcc);
4915 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4916 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
4930 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4933 Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4958 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4959 ie = Args.filtered_end(); it != ie; ++it) {
4977 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4979 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4982 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4990 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
4995 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4996 Args.AddAllArgs(CmdArgs, options::OPT_e);
4997 Args.AddAllArgs(CmdArgs, options::OPT_s);
4998 Args.AddAllArgs(CmdArgs, options::OPT_t);
4999 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5001 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5008 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5017 CmdArgs.push_back(Args.MakeArgString("-l" + *i));
5030 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5034 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
5038 const char *arm::getARMCPUForMArch(const ArgList &Args,
5041 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5145 StringRef arm::getARMTargetCPU(const ArgList &Args,
5149 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5158 return getARMCPUForMArch(Args, Triple);
5192 bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5193 Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5197 bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
5198 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5205 return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5258 const char *Clang::getBaseInputName(const ArgList &Args,
5260 return Args.MakeArgString(
5264 const char *Clang::getBaseInputStem(const ArgList &Args,
5266 const char *Str = getBaseInputName(Args, Inputs);
5269 return Args.MakeArgString(std::string(Str, End));
5274 const char *Clang::getDependencyFileName(const ArgList &Args,
5279 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
5283 Res = getBaseInputStem(Args, Inputs);
5285 return Args.MakeArgString(Res + ".d");
5291 const ArgList &Args,
5310 if (Args.hasArg(options::OPT_fno_integrated_as)) {
5319 if (Args.hasArg(options::OPT_gstabs))
5321 else if (Args.hasArg(options::OPT_g_Group))
5326 AddMachOArch(Args, CmdArgs);
5331 Args.hasArg(options::OPT_force__cpusubtype__ALL))
5335 (((Args.hasArg(options::OPT_mkernel) ||
5336 Args.hasArg(options::OPT_fapple_kext)) &&
5338 Args.hasArg(options::OPT_static)))
5341 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5354 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5360 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
5362 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
5366 CmdArgs.push_back(Args.MakeArgString(ArchName));
5385 const ArgList &Args,
5392 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
5398 << A->getAsString(Args);
5403 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5406 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
5412 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
5421 Args.AddAllArgs(CmdArgs, options::OPT_static);
5422 if (!Args.hasArg(options::OPT_static))
5424 if (Args.hasArg(options::OPT_fgnu_runtime)) {
5425 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
5429 if (!Args.hasArg(options::OPT_dynamiclib)) {
5430 AddMachOArch(Args, CmdArgs);
5432 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
5434 Args.AddLastArg(CmdArgs, options::OPT_bundle);
5435 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
5436 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
5439 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
5440 (A = Args.getLastArg(options::OPT_current__version)) ||
5441 (A = Args.getLastArg(options::OPT_install__name)))
5443 << A->getAsString(Args) << "-dynamiclib";
5445 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
5446 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
5447 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
5452 if ((A = Args.getLastArg(options::OPT_bundle)) ||
5453 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
5454 (A = Args.getLastArg(options::OPT_client__name)) ||
5455 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
5456 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
5457 (A = Args.getLastArg(options::OPT_private__bundle)))
5459 << A->getAsString(Args) << "-dynamiclib";
5461 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
5463 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
5466 AddMachOArch(Args, CmdArgs);
5468 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
5472 Args.AddLastArg(CmdArgs, options::OPT_all__load);
5473 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
5474 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
5476 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
5477 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
5478 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
5479 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
5480 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
5481 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
5482 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
5483 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
5484 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
5485 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
5486 Args.AddAllArgs(CmdArgs, options::OPT_init);
5489 MachOTC.addMinVersionArgs(Args, CmdArgs);
5491 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
5492 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
5493 Args.AddLastArg(CmdArgs, options::OPT_single__module);
5494 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
5495 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
5497 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
5507 Args.AddLastArg(CmdArgs, options::OPT_prebind);
5508 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
5509 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
5510 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
5511 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
5512 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
5513 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
5514 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
5515 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
5516 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
5517 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
5518 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
5519 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
5520 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
5521 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
5522 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
5530 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5535 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
5536 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
5537 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
5538 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
5539 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
5540 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
5541 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
5542 Args.AddAllArgs(CmdArgs, options::OPT_y);
5543 Args.AddLastArg(CmdArgs, options::OPT_w);
5544 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
5545 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
5546 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
5547 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
5548 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
5549 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
5550 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
5551 Args.AddLastArg(CmdArgs, options::OPT_whyload);
5552 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
5553 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
5554 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
5555 Args.AddLastArg(CmdArgs, options::OPT_Mach);
5567 const ArgList &Args,
5577 if (Args.hasArg(options::OPT_ccc_arcmt_check,
5579 for (const auto &Arg : Args)
5582 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
5590 AddLinkArgs(C, Args, CmdArgs, Inputs);
5592 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
5593 Args.AddAllArgs(CmdArgs, options::OPT_s);
5594 Args.AddAllArgs(CmdArgs, options::OPT_t);
5595 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5596 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5597 Args.AddLastArg(CmdArgs, options::OPT_e);
5598 Args.AddAllArgs(CmdArgs, options::OPT_r);
5603 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
5609 if (!Args.hasArg(options::OPT_nostdlib) &&
5610 !Args.hasArg(options::OPT_nostartfiles))
5611 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
5613 Args.AddAllArgs(CmdArgs, options::OPT_L);
5616 if (Args.hasArg(options::OPT_fopenmp)) {
5618 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
5638 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5640 if (isObjCRuntimeLinked(Args) &&
5641 !Args.hasArg(options::OPT_nostdlib) &&
5642 !Args.hasArg(options::OPT_nodefaultlibs)) {
5644 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
5658 if (Args.hasArg(options::OPT_fnested_functions))
5661 if (!Args.hasArg(options::OPT_nostdlib) &&
5662 !Args.hasArg(options::OPT_nodefaultlibs)) {
5664 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5669 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
5672 if (!Args.hasArg(options::OPT_nostdlib) &&
5673 !Args.hasArg(options::OPT_nostartfiles)) {
5677 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5678 Args.AddAllArgs(CmdArgs, options::OPT_F);
5681 Args.MakeArgString(getToolChain().GetLinkerPath());
5688 const ArgList &Args,
5703 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
5710 const ArgList &Args,
5723 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
5730 const ArgList &Args,
5746 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5753 const ArgList &Args,
5757 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5766 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
5773 const ArgList &Args,
5799 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5800 (!Args.hasArg(options::OPT_shared))) {
5805 if (Args.hasArg(options::OPT_static)) {
5810 if (Args.hasArg(options::OPT_shared)) {
5814 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5825 if (!Args.hasArg(options::OPT_nostdlib) &&
5826 !Args.hasArg(options::OPT_nostartfiles)) {
5827 if (!Args.hasArg(options::OPT_shared)) {
5828 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5829 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5830 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5831 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5833 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5834 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5835 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5838 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
5841 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5843 Args.AddAllArgs(CmdArgs, options::OPT_L);
5844 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5845 Args.AddAllArgs(CmdArgs, options::OPT_e);
5846 Args.AddAllArgs(CmdArgs, options::OPT_r);
5848 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5850 if (!Args.hasArg(options::OPT_nostdlib) &&
5851 !Args.hasArg(options::OPT_nodefaultlibs)) {
5853 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5855 if (!Args.hasArg(options::OPT_shared)) {
5862 if (!Args.hasArg(options::OPT_nostdlib) &&
5863 !Args.hasArg(options::OPT_nostartfiles)) {
5864 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
5866 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
5868 addProfileRT(getToolChain(), Args, CmdArgs);
5871 Args.MakeArgString(getToolChain().GetLinkerPath());
5878 const ArgList &Args,
5882 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5891 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("gas"));
5898 const ArgList &Args,
5902 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5903 (!Args.hasArg(options::OPT_shared))) {
5908 if (Args.hasArg(options::OPT_static)) {
5914 if (Args.hasArg(options::OPT_shared)) {
5929 if (!Args.hasArg(options::OPT_nostdlib) &&
5930 !Args.hasArg(options::OPT_nostartfiles)) {
5931 if (!Args.hasArg(options::OPT_shared)) {
5932 CmdArgs.push_back(Args.MakeArgString(
5934 CmdArgs.push_back(Args.MakeArgString(
5936 CmdArgs.push_back(Args.MakeArgString(
5939 CmdArgs.push_back(Args.MakeArgString(
5942 CmdArgs.push_back(Args.MakeArgString(
5946 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5950 Args.AddAllArgs(CmdArgs, options::OPT_L);
5951 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5952 Args.AddAllArgs(CmdArgs, options::OPT_e);
5954 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5956 if (!Args.hasArg(options::OPT_nostdlib) &&
5957 !Args.hasArg(options::OPT_nodefaultlibs)) {
5962 if (Args.hasArg(options::OPT_pthread))
5964 if (!Args.hasArg(options::OPT_shared))
5969 if (!Args.hasArg(options::OPT_nostdlib) &&
5970 !Args.hasArg(options::OPT_nostartfiles)) {
5971 if (!Args.hasArg(options::OPT_shared))
5972 CmdArgs.push_back(Args.MakeArgString(
5976 addProfileRT(getToolChain(), Args, CmdArgs);
5979 Args.MakeArgString(getToolChain().GetLinkerPath());
5986 const ArgList &Args,
6018 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6037 addAssemblerKPIC(Args, CmdArgs);
6039 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6049 Args.MakeArgString(getToolChain().GetProgramPath("as"));
6056 const ArgList &Args,
6062 Args.ClaimAllArgs(options::OPT_g_Group);
6064 Args.ClaimAllArgs(options::OPT_emit_llvm);
6067 Args.ClaimAllArgs(options::OPT_w);
6074 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6075 (!Args.hasArg(options::OPT_shared))) {
6080 if (Args.hasArg(options::OPT_static)) {
6083 if (Args.hasArg(options::OPT_rdynamic))
6087 if (Args.hasArg(options::OPT_shared)) {
6095 if (Args.hasArg(options::OPT_nopie))
6105 if (!Args.hasArg(options::OPT_nostdlib) &&
6106 !Args.hasArg(options::OPT_nostartfiles)) {
6107 if (!Args.hasArg(options::OPT_shared)) {
6108 if (Args.hasArg(options::OPT_pg))
6109 CmdArgs.push_back(Args.MakeArgString(
6112 CmdArgs.push_back(Args.MakeArgString(
6114 CmdArgs.push_back(Args.MakeArgString(
6117 CmdArgs.push_back(Args.MakeArgString(
6125 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
6128 Args.AddAllArgs(CmdArgs, options::OPT_L);
6129 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6130 Args.AddAllArgs(CmdArgs, options::OPT_e);
6131 Args.AddAllArgs(CmdArgs, options::OPT_s);
6132 Args.AddAllArgs(CmdArgs, options::OPT_t);
6133 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6134 Args.AddAllArgs(CmdArgs, options::OPT_r);
6136 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6138 if (!Args.hasArg(options::OPT_nostdlib) &&
6139 !Args.hasArg(options::OPT_nodefaultlibs)) {
6141 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6142 if (Args.hasArg(options::OPT_pg))
6152 if (Args.hasArg(options::OPT_pthread)) {
6153 if (!Args.hasArg(options::OPT_shared) &&
6154 Args.hasArg(options::OPT_pg))
6160 if (!Args.hasArg(options::OPT_shared)) {
6161 if (Args.hasArg(options::OPT_pg))
6170 if (!Args.hasArg(options::OPT_nostdlib) &&
6171 !Args.hasArg(options::OPT_nostartfiles)) {
6172 if (!Args.hasArg(options::OPT_shared))
6173 CmdArgs.push_back(Args.MakeArgString(
6176 CmdArgs.push_back(Args.MakeArgString(
6181 Args.MakeArgString(getToolChain().GetLinkerPath());
6188 const ArgList &Args,
6192 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6201 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6208 const ArgList &Args,
6213 if ((!Args.hasArg(options::OPT_nostdlib)) &&
6214 (!Args.hasArg(options::OPT_shared))) {
6219 if (Args.hasArg(options::OPT_static)) {
6222 if (Args.hasArg(options::OPT_rdynamic))
6226 if (Args.hasArg(options::OPT_shared)) {
6241 if (!Args.hasArg(options::OPT_nostdlib) &&
6242 !Args.hasArg(options::OPT_nostartfiles)) {
6243 if (!Args.hasArg(options::OPT_shared)) {
6244 if (Args.hasArg(options::OPT_pg))
6245 CmdArgs.push_back(Args.MakeArgString(
6248 CmdArgs.push_back(Args.MakeArgString(
6250 CmdArgs.push_back(Args.MakeArgString(
6253 CmdArgs.push_back(Args.MakeArgString(
6258 Args.AddAllArgs(CmdArgs, options::OPT_L);
6259 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6260 Args.AddAllArgs(CmdArgs, options::OPT_e);
6262 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6264 if (!Args.hasArg(options::OPT_nostdlib) &&
6265 !Args.hasArg(options::OPT_nodefaultlibs)) {
6267 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6268 if (Args.hasArg(options::OPT_pg))
6274 if (Args.hasArg(options::OPT_pthread)) {
6275 if (!Args.hasArg(options::OPT_shared) &&
6276 Args.hasArg(options::OPT_pg))
6282 if (!Args.hasArg(options::OPT_shared)) {
6283 if (Args.hasArg(options::OPT_pg))
6303 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
6306 if (!Args.hasArg(options::OPT_nostdlib) &&
6307 !Args.hasArg(options::OPT_nostartfiles)) {
6308 if (!Args.hasArg(options::OPT_shared))
6309 CmdArgs.push_back(Args.MakeArgString(
6312 CmdArgs.push_back(Args.MakeArgString(
6317 Args.MakeArgString(getToolChain().GetLinkerPath());
6324 const ArgList &Args,
6340 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6354 addAssemblerKPIC(Args, CmdArgs);
6361 StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
6386 addAssemblerKPIC(Args, CmdArgs);
6389 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6398 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6405 const ArgList &Args,
6411 !Args.hasArg(options::OPT_shared) &&
6412 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
6416 Args.ClaimAllArgs(options::OPT_g_Group);
6418 Args.ClaimAllArgs(options::OPT_emit_llvm);
6421 Args.ClaimAllArgs(options::OPT_w);
6424 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6429 if (Args.hasArg(options::OPT_static)) {
6432 if (Args.hasArg(options::OPT_rdynamic))
6435 if (Args.hasArg(options::OPT_shared)) {
6470 if (!Args.hasArg(options::OPT_nostdlib) &&
6471 !Args.hasArg(options::OPT_nostartfiles)) {
6473 if (!Args.hasArg(options::OPT_shared)) {
6474 if (Args.hasArg(options::OPT_pg))
6482 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6484 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6487 if (Args.hasArg(options::OPT_static))
6489 else if (Args.hasArg(options::OPT_shared) || IsPIE)
6494 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
6497 Args.AddAllArgs(CmdArgs, options::OPT_L);
6500 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
6501 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6502 Args.AddAllArgs(CmdArgs, options::OPT_e);
6503 Args.AddAllArgs(CmdArgs, options::OPT_s);
6504 Args.AddAllArgs(CmdArgs, options::OPT_t);
6505 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6506 Args.AddAllArgs(CmdArgs, options::OPT_r);
6508 if (D.IsUsingLTO(Args))
6509 AddGoldPlugin(ToolChain, Args, CmdArgs);
6511 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6513 if (!Args.hasArg(options::OPT_nostdlib) &&
6514 !Args.hasArg(options::OPT_nodefaultlibs)) {
6516 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6517 if (Args.hasArg(options::OPT_pg))
6524 if (Args.hasArg(options::OPT_pg))
6528 if (Args.hasArg(options::OPT_static)) {
6530 } else if (Args.hasArg(options::OPT_pg)) {
6538 if (Args.hasArg(options::OPT_pthread)) {
6539 if (Args.hasArg(options::OPT_pg))
6545 if (Args.hasArg(options::OPT_pg)) {
6546 if (Args.hasArg(options::OPT_shared))
6556 if (Args.hasArg(options::OPT_static)) {
6558 } else if (Args.hasArg(options::OPT_pg)) {
6567 if (!Args.hasArg(options::OPT_nostdlib) &&
6568 !Args.hasArg(options::OPT_nostartfiles)) {
6569 if (Args.hasArg(options::OPT_shared) || IsPIE)
6570 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
6572 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6573 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6576 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
6578 addProfileRT(ToolChain, Args, CmdArgs);
6581 Args.MakeArgString(getToolChain().GetLinkerPath());
6588 const ArgList &Args,
6602 std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
6603 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
6613 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6627 addAssemblerKPIC(Args, CmdArgs);
6633 addAssemblerKPIC(Args, CmdArgs);
6639 Args, CmdArgs);
6646 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6655 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
6662 const ArgList &Args,
6668 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6671 if (Args.hasArg(options::OPT_static)) {
6674 if (Args.hasArg(options::OPT_rdynamic))
6676 if (Args.hasArg(options::OPT_shared)) {
6712 if (mips::hasMipsAbiArg(Args, "32")) {
6718 } else if (mips::hasMipsAbiArg(Args, "64")) {
6748 if (!Args.hasArg(options::OPT_nostdlib) &&
6749 !Args.hasArg(options::OPT_nostartfiles)) {
6750 if (!Args.hasArg(options::OPT_shared)) {
6751 CmdArgs.push_back(Args.MakeArgString(
6753 CmdArgs.push_back(Args.MakeArgString(
6755 CmdArgs.push_back(Args.MakeArgString(
6758 CmdArgs.push_back(Args.MakeArgString(
6760 CmdArgs.push_back(Args.MakeArgString(
6765 Args.AddAllArgs(CmdArgs, options::OPT_L);
6766 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6767 Args.AddAllArgs(CmdArgs, options::OPT_e);
6768 Args.AddAllArgs(CmdArgs, options::OPT_s);
6769 Args.AddAllArgs(CmdArgs, options::OPT_t);
6770 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6771 Args.AddAllArgs(CmdArgs, options::OPT_r);
6773 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6793 if (!Args.hasArg(options::OPT_nostdlib) &&
6794 !Args.hasArg(options::OPT_nodefaultlibs)) {
6796 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6799 if (Args.hasArg(options::OPT_pthread))
6804 if (Args.hasArg(options::OPT_static)) {
6820 if (!Args.hasArg(options::OPT_nostdlib) &&
6821 !Args.hasArg(options::OPT_nostartfiles)) {
6822 if (!Args.hasArg(options::OPT_shared))
6823 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6826 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6828 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6832 addProfileRT(getToolChain(), Args, CmdArgs);
6834 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6841 const ArgList &Args,
6886 getToolChain().getDriver(), Args, getToolChain().getTriple());
6887 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
6889 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
6895 if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
6899 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
6900 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
6907 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6921 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6923 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6926 Args.AddLastArg(CmdArgs, options::OPT_mfp32, options::OPT_mfp64);
6927 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6928 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6930 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6931 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6933 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6937 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6944 StringRef CPUName = getSystemZTargetCPU(Args);
6945 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6949 addAssemblerKPIC(Args, CmdArgs);
6951 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6960 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6966 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6968 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6969 SplitDebugName(Args, Inputs));
6973 ArgStringList &CmdArgs, const ArgList &Args) {
6975 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6976 Args.hasArg(options::OPT_static);
6993 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
7005 static StringRef getLinuxDynamicLinker(const ArgList &Args,
7035 if (mips::isNaN2008(Args, ToolChain.getTriple()))
7040 if (mips::hasMipsAbiArg(Args, "n32"))
7041 return mips::isNaN2008(Args, ToolChain.getTriple())
7043 return mips::isNaN2008(Args, ToolChain.getTriple())
7062 ArgStringList &CmdArgs, const ArgList &Args) {
7064 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7068 addClangRTLinux(TC, Args, CmdArgs);
7071 AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7079 const ArgList &Args,
7087 !Args.hasArg(options::OPT_shared) &&
7088 !Args.hasArg(options::OPT_static) &&
7089 (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
7098 Args.ClaimAllArgs(options::OPT_g_Group);
7100 Args.ClaimAllArgs(options::OPT_emit_llvm);
7103 Args.ClaimAllArgs(options::OPT_w);
7106 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7111 if (Args.hasArg(options::OPT_rdynamic))
7114 if (Args.hasArg(options::OPT_s))
7120 if (!Args.hasArg(options::OPT_static)) {
7154 if (mips::hasMipsAbiArg(Args, "n32"))
7160 if (mips::hasMipsAbiArg(Args, "n32"))
7173 if (Args.hasArg(options::OPT_static)) {
7181 } else if (Args.hasArg(options::OPT_shared)) {
7189 (!Args.hasArg(options::OPT_static) &&
7190 !Args.hasArg(options::OPT_shared))) {
7192 CmdArgs.push_back(Args.MakeArgString(
7193 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
7199 if (!Args.hasArg(options::OPT_nostdlib) &&
7200 !Args.hasArg(options::OPT_nostartfiles)) {
7203 if (!Args.hasArg(options::OPT_shared)){
7204 if (Args.hasArg(options::OPT_pg))
7212 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7214 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7218 if (Args.hasArg(options::OPT_static))
7220 else if (Args.hasArg(options::OPT_shared))
7226 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
7229 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
7232 Args.AddAllArgs(CmdArgs, options::OPT_L);
7233 Args.AddAllArgs(CmdArgs, options::OPT_u);
7238 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
7240 if (D.IsUsingLTO(Args))
7241 AddGoldPlugin(ToolChain, Args, CmdArgs);
7243 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
7246 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7248 addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
7250 addProfileRT(getToolChain(), Args, CmdArgs);
7253 !Args.hasArg(options::OPT_nostdlib) &&
7254 !Args.hasArg(options::OPT_nodefaultlibs)) {
7255 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
7256 !Args.hasArg(options::OPT_static);
7259 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
7265 if (!Args.hasArg(options::OPT_nostdlib)) {
7266 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
7267 if (Args.hasArg(options::OPT_static))
7271 if (Args.hasArg(options::OPT_fopenmp)) {
7273 } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
7296 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
7298 if ((Args.hasArg(options::OPT_pthread) ||
7299 Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
7305 if (Args.hasArg(options::OPT_static))
7308 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
7311 if (!Args.hasArg(options::OPT_nostartfiles)) {
7313 if (Args.hasArg(options::OPT_shared))
7320 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
7322 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
7332 const ArgList &Args,
7336 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7344 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
7351 const ArgList &Args,
7363 if (!Args.hasArg(options::OPT_nostdlib) &&
7364 !Args.hasArg(options::OPT_nostartfiles)) {
7365 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
7366 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7367 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7368 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7371 Args.AddAllArgs(CmdArgs, options::OPT_L);
7372 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7373 Args.AddAllArgs(CmdArgs, options::OPT_e);
7375 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7377 addProfileRT(getToolChain(), Args, CmdArgs);
7379 if (!Args.hasArg(options::OPT_nostdlib) &&
7380 !Args.hasArg(options::OPT_nodefaultlibs)) {
7382 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7387 if (!Args.hasArg(options::OPT_nostdlib) &&
7388 !Args.hasArg(options::OPT_nostartfiles)) {
7389 if (Args.hasArg(options::OPT_pthread))
7395 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
7398 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7409 const ArgList &Args,
7418 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7426 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
7433 const ArgList &Args,
7443 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7446 if (Args.hasArg(options::OPT_static)) {
7449 if (Args.hasArg(options::OPT_rdynamic))
7451 if (Args.hasArg(options::OPT_shared))
7474 if (!Args.hasArg(options::OPT_nostdlib) &&
7475 !Args.hasArg(options::OPT_nostartfiles)) {
7476 if (!Args.hasArg(options::OPT_shared)) {
7477 if (Args.hasArg(options::OPT_pg))
7478 CmdArgs.push_back(Args.MakeArgString(
7481 if (Args.hasArg(options::OPT_pie))
7482 CmdArgs.push_back(Args.MakeArgString(
7485 CmdArgs.push_back(Args.MakeArgString(
7489 CmdArgs.push_back(Args.MakeArgString(
7491 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7492 CmdArgs.push_back(Args.MakeArgString(
7495 CmdArgs.push_back(Args.MakeArgString(
7499 Args.AddAllArgs(CmdArgs, options::OPT_L);
7500 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7501 Args.AddAllArgs(CmdArgs, options::OPT_e);
7503 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7505 if (!Args.hasArg(options::OPT_nostdlib) &&
7506 !Args.hasArg(options::OPT_nodefaultlibs)) {
7514 if (!Args.hasArg(options::OPT_static)) {
7525 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7529 if (Args.hasArg(options::OPT_pthread))
7532 if (!Args
7537 if (Args.hasArg(options::OPT_static) ||
7538 Args.hasArg(options::OPT_static_libgcc)) {
7542 if (Args.hasArg(options::OPT_shared_libgcc)) {
7544 if (!Args.hasArg(options::OPT_shared))
7554 if (Args.hasArg(options::OPT_shared)) {
7562 if (!Args.hasArg(options::OPT_nostdlib) &&
7563 !Args.hasArg(options::OPT_nostartfiles)) {
7564 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
7565 CmdArgs.push_back(Args.MakeArgString(
7568 CmdArgs.push_back(Args.MakeArgString(
7570 CmdArgs.push_back(Args.MakeArgString(
7574 addProfileRT(getToolChain(), Args, CmdArgs);
7576 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7580 static void addSanitizerRTWindows(const ToolChain &TC, const ArgList &Args,
7586 CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
7592 const ArgList &Args,
7597 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
7603 if (!Args.hasArg(options::OPT_nostdlib) &&
7604 !Args.hasArg(options::OPT_nostartfiles) &&
7611 if (Args.hasArg(options::OPT_g_Group)) {
7615 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
7618 CmdArgs.push_back(Args.MakeArgString("-dll"));
7622 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
7627 CmdArgs.push_back(Args.MakeArgString("-debug"));
7628 CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
7631 addSanitizerRTWindows(getToolChain(), Args, CmdArgs,
7634 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan-i386");
7635 addSanitizerRTWindows(getToolChain(), Args, CmdArgs, "asan_cxx-i386");
7639 Args.AddAllArgValues(CmdArgs, options::OPT_l);
7640 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
7647 Input.getInputArg().renderAsInput(Args, CmdArgs);
7650 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
7657 const ArgList &Args,
7659 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7694 const ArgList &Args,
7705 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7706 Args.AddAllArgs(CmdArgs, options::OPT_I);
7709 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7715 A->render(Args, CmdArgs);
7724 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
7727 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
7732 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
7736 if (Args.hasArg(options::OPT_fsyntax_only))
7738 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
7741 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7743 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
7746 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7747 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7748 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
7751 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7753 A->render(Args, CmdArgs);
7764 II.getInputArg().renderAsInput(Args, CmdArgs);
7768 const char *Fo = Args.MakeArgString(std::string("/Fo") +
7774 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
7784 const ArgList &Args,
7793 if (Args.hasArg(options::OPT_v))
7796 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
7800 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
7804 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7810 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7817 const ArgList &Args,
7828 if (Args.hasArg(options::OPT_v))
7831 ExceptionSettings EH = exceptionSettings(Args, getToolChain().getTriple());
7835 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7837 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
