1 //===--- Tools.cpp - Tools Implementations --------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 #include "clang/Driver/Action.h"
13 #include "clang/Driver/Arg.h"
14 #include "clang/Driver/ArgList.h"
15 #include "clang/Driver/Driver.h"
16 #include "clang/Driver/DriverDiagnostic.h"
17 #include "clang/Driver/Compilation.h"
18 #include "clang/Driver/Job.h"
19 #include "clang/Driver/Option.h"
20 #include "clang/Driver/Options.h"
21 #include "clang/Driver/ToolChain.h"
22 #include "clang/Driver/Util.h"
23 #include "clang/Basic/ObjCRuntime.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/ADT/StringSwitch.h"
27 #include "llvm/ADT/Twine.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/Format.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/Support/Host.h"
32 #include "llvm/Support/Process.h"
33 #include "llvm/Support/ErrorHandling.h"
35 #include "InputInfo.h"
36 #include "ToolChains.h"
38 using namespace clang::driver;
39 using namespace clang::driver::tools;
40 using namespace clang;
42 /// CheckPreprocessingOptions - Perform some validation of preprocessing
43 /// arguments that is shared with gcc.
44 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
45 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
46 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
47 D.Diag(diag::err_drv_argument_only_allowed_with)
48 << A->getAsString(Args) << "-E";
51 /// CheckCodeGenerationOptions - Perform some validation of code generation
52 /// arguments that is shared with gcc.
53 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
54 // In gcc, only ARM checks this, but it seems reasonable to check universally.
55 if (Args.hasArg(options::OPT_static))
56 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
57 options::OPT_mdynamic_no_pic))
58 D.Diag(diag::err_drv_argument_not_allowed_with)
59 << A->getAsString(Args) << "-static";
62 // Quote target names for inclusion in GNU Make dependency files.
63 // Only the characters '$', '#', ' ', '\t' are quoted.
64 static void QuoteTarget(StringRef Target,
65 SmallVectorImpl<char> &Res) {
66 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
70 // Escape the preceding backslashes
71 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
74 // Escape the space/tab
87 Res.push_back(Target[i]);
91 static void addDirectoryList(const ArgList &Args,
92 ArgStringList &CmdArgs,
95 const char *DirList = ::getenv(EnvVar);
97 return; // Nothing to do.
99 StringRef Dirs(DirList);
100 if (Dirs.empty()) // Empty string should not add '.'.
103 StringRef::size_type Delim;
104 while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
105 if (Delim == 0) { // Leading colon.
106 CmdArgs.push_back(ArgName);
107 CmdArgs.push_back(".");
109 CmdArgs.push_back(ArgName);
110 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
112 Dirs = Dirs.substr(Delim + 1);
115 if (Dirs.empty()) { // Trailing colon.
116 CmdArgs.push_back(ArgName);
117 CmdArgs.push_back(".");
118 } else { // Add the last path.
119 CmdArgs.push_back(ArgName);
120 CmdArgs.push_back(Args.MakeArgString(Dirs));
124 static void AddLinkerInputs(const ToolChain &TC,
125 const InputInfoList &Inputs, const ArgList &Args,
126 ArgStringList &CmdArgs) {
127 const Driver &D = TC.getDriver();
129 // Add extra linker input arguments which are not treated as inputs
130 // (constructed via -Xarch_).
131 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
133 for (InputInfoList::const_iterator
134 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
135 const InputInfo &II = *it;
137 if (!TC.HasNativeLLVMSupport()) {
138 // Don't try to pass LLVM inputs unless we have native support.
139 if (II.getType() == types::TY_LLVM_IR ||
140 II.getType() == types::TY_LTO_IR ||
141 II.getType() == types::TY_LLVM_BC ||
142 II.getType() == types::TY_LTO_BC)
143 D.Diag(diag::err_drv_no_linker_llvm_support)
144 << TC.getTripleString();
147 // Add filenames immediately.
148 if (II.isFilename()) {
149 CmdArgs.push_back(II.getFilename());
153 // Otherwise, this is a linker input argument.
154 const Arg &A = II.getInputArg();
156 // Handle reserved library options.
157 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
158 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
159 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
160 TC.AddCCKextLibArgs(Args, CmdArgs);
162 A.renderAsInput(Args, CmdArgs);
165 // LIBRARY_PATH - included following the user specified library paths.
166 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
169 /// \brief Determine whether Objective-C automated reference counting is
171 static bool isObjCAutoRefCount(const ArgList &Args) {
172 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
175 /// \brief Determine whether we are linking the ObjC runtime.
176 static bool isObjCRuntimeLinked(const ArgList &Args) {
177 if (isObjCAutoRefCount(Args)) {
178 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
181 return Args.hasArg(options::OPT_fobjc_link_runtime);
184 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
185 ArgStringList &CmdArgs,
186 llvm::Triple Triple) {
187 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
188 Args.hasArg(options::OPT_fprofile_generate) ||
189 Args.hasArg(options::OPT_fcreate_profile) ||
190 Args.hasArg(options::OPT_coverage)))
193 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
194 // the link line. We cannot do the same thing because unlike gcov there is a
195 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
196 // not supported by old linkers.
197 std::string ProfileRT =
198 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
200 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
203 void Clang::AddPreprocessingOptions(Compilation &C,
206 ArgStringList &CmdArgs,
207 const InputInfo &Output,
208 const InputInfoList &Inputs) const {
211 CheckPreprocessingOptions(D, Args);
213 Args.AddLastArg(CmdArgs, options::OPT_C);
214 Args.AddLastArg(CmdArgs, options::OPT_CC);
216 // Handle dependency file generation.
217 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
218 (A = Args.getLastArg(options::OPT_MD)) ||
219 (A = Args.getLastArg(options::OPT_MMD))) {
220 // Determine the output location.
222 if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
223 DepFile = MF->getValue(Args);
224 C.addFailureResultFile(DepFile);
225 } else if (Output.getType() == types::TY_Dependencies) {
226 DepFile = Output.getFilename();
227 } else if (A->getOption().matches(options::OPT_M) ||
228 A->getOption().matches(options::OPT_MM)) {
231 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
232 C.addFailureResultFile(DepFile);
234 CmdArgs.push_back("-dependency-file");
235 CmdArgs.push_back(DepFile);
237 // Add a default target if one wasn't specified.
238 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
239 const char *DepTarget;
241 // If user provided -o, that is the dependency target, except
242 // when we are only generating a dependency file.
243 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
244 if (OutputOpt && Output.getType() != types::TY_Dependencies) {
245 DepTarget = OutputOpt->getValue(Args);
247 // Otherwise derive from the base input.
249 // FIXME: This should use the computed output file location.
250 SmallString<128> P(Inputs[0].getBaseInput());
251 llvm::sys::path::replace_extension(P, "o");
252 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
255 CmdArgs.push_back("-MT");
256 SmallString<128> Quoted;
257 QuoteTarget(DepTarget, Quoted);
258 CmdArgs.push_back(Args.MakeArgString(Quoted));
261 if (A->getOption().matches(options::OPT_M) ||
262 A->getOption().matches(options::OPT_MD))
263 CmdArgs.push_back("-sys-header-deps");
266 if (Args.hasArg(options::OPT_MG)) {
267 if (!A || A->getOption().matches(options::OPT_MD) ||
268 A->getOption().matches(options::OPT_MMD))
269 D.Diag(diag::err_drv_mg_requires_m_or_mm);
270 CmdArgs.push_back("-MG");
273 Args.AddLastArg(CmdArgs, options::OPT_MP);
275 // Convert all -MQ <target> args to -MT <quoted target>
276 for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
278 ie = Args.filtered_end(); it != ie; ++it) {
282 if (A->getOption().matches(options::OPT_MQ)) {
283 CmdArgs.push_back("-MT");
284 SmallString<128> Quoted;
285 QuoteTarget(A->getValue(Args), Quoted);
286 CmdArgs.push_back(Args.MakeArgString(Quoted));
288 // -MT flag - no change
290 A->render(Args, CmdArgs);
294 // Add -i* options, and automatically translate to
295 // -include-pch/-include-pth for transparent PCH support. It's
296 // wonky, but we include looking for .gch so we can support seamless
297 // replacement into a build system already set up to be generating
299 bool RenderedImplicitInclude = false;
300 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
301 ie = Args.filtered_end(); it != ie; ++it) {
304 if (A->getOption().matches(options::OPT_include)) {
305 bool IsFirstImplicitInclude = !RenderedImplicitInclude;
306 RenderedImplicitInclude = true;
308 // Use PCH if the user requested it.
309 bool UsePCH = D.CCCUsePCH;
311 bool FoundPTH = false;
312 bool FoundPCH = false;
313 llvm::sys::Path P(A->getValue(Args));
316 P.appendSuffix("pch");
317 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
324 P.appendSuffix("pth");
325 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
331 if (!FoundPCH && !FoundPTH) {
332 P.appendSuffix("gch");
333 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
341 if (FoundPCH || FoundPTH) {
342 if (IsFirstImplicitInclude) {
345 CmdArgs.push_back("-include-pch");
347 CmdArgs.push_back("-include-pth");
348 CmdArgs.push_back(Args.MakeArgString(P.str()));
351 // Ignore the PCH if not first on command line and emit warning.
352 D.Diag(diag::warn_drv_pch_not_first_include)
353 << P.str() << A->getAsString(Args);
358 // Not translated, render as usual.
360 A->render(Args, CmdArgs);
363 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
364 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
365 options::OPT_index_header_map);
367 // Add -Wp, and -Xassembler if using the preprocessor.
369 // FIXME: There is a very unfortunate problem here, some troubled
370 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
371 // really support that we would have to parse and then translate
373 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
374 options::OPT_Xpreprocessor);
376 // -I- is a deprecated GCC feature, reject it.
377 if (Arg *A = Args.getLastArg(options::OPT_I_))
378 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
380 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
381 // -isysroot to the CC1 invocation.
382 StringRef sysroot = C.getSysRoot();
384 if (!Args.hasArg(options::OPT_isysroot)) {
385 CmdArgs.push_back("-isysroot");
386 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
390 // If a module path was provided, pass it along. Otherwise, use a temporary
392 if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) {
394 A->render(Args, CmdArgs);
396 SmallString<128> DefaultModuleCache;
397 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
399 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
400 CmdArgs.push_back("-fmodule-cache-path");
401 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
404 // Parse additional include paths from environment variables.
405 // FIXME: We should probably sink the logic for handling these from the
406 // frontend into the driver. It will allow deleting 4 otherwise unused flags.
407 // CPATH - included following the user specified includes (but prior to
408 // builtin and standard includes).
409 addDirectoryList(Args, CmdArgs, "-I", "CPATH");
410 // C_INCLUDE_PATH - system includes enabled when compiling C.
411 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
412 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
413 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
414 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
415 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
416 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
417 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
419 // Add C++ include arguments, if needed.
420 if (types::isCXX(Inputs[0].getType()))
421 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
423 // Add system include arguments.
424 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
427 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
430 // FIXME: This is redundant with -mcpu, why does LLVM use this.
431 // FIXME: tblgen this, or kill it!
432 static const char *getLLVMArchSuffixForARM(StringRef CPU) {
433 return llvm::StringSwitch<const char *>(CPU)
434 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
435 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
436 .Cases("arm920", "arm920t", "arm922t", "v4t")
437 .Cases("arm940t", "ep9312","v4t")
438 .Cases("arm10tdmi", "arm1020t", "v5")
439 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
440 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
441 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
442 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
443 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
444 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
445 .Cases("cortex-a8", "cortex-a9", "v7")
446 .Case("cortex-m3", "v7m")
447 .Case("cortex-m4", "v7m")
448 .Case("cortex-m0", "v6m")
452 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
454 // FIXME: tblgen this.
455 static std::string getARMTargetCPU(const ArgList &Args,
456 const llvm::Triple &Triple) {
457 // FIXME: Warn on inconsistent use of -mcpu and -march.
459 // If we have -mcpu=, use that.
460 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
461 StringRef MCPU = A->getValue(Args);
462 // Handle -mcpu=native.
463 if (MCPU == "native")
464 return llvm::sys::getHostCPUName();
470 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
471 // Otherwise, if we have -march= choose the base CPU for that arch.
472 MArch = A->getValue(Args);
474 // Otherwise, use the Arch from the triple.
475 MArch = Triple.getArchName();
478 // Handle -march=native.
479 std::string NativeMArch;
480 if (MArch == "native") {
481 std::string CPU = llvm::sys::getHostCPUName();
482 if (CPU != "generic") {
483 // Translate the native cpu into the architecture. The switch below will
484 // then chose the minimum cpu for that arch.
485 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
490 return llvm::StringSwitch<const char *>(MArch)
491 .Cases("armv2", "armv2a","arm2")
492 .Case("armv3", "arm6")
493 .Case("armv3m", "arm7m")
494 .Cases("armv4", "armv4t", "arm7tdmi")
495 .Cases("armv5", "armv5t", "arm10tdmi")
496 .Cases("armv5e", "armv5te", "arm1022e")
497 .Case("armv5tej", "arm926ej-s")
498 .Cases("armv6", "armv6k", "arm1136jf-s")
499 .Case("armv6j", "arm1136j-s")
500 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
501 .Case("armv6t2", "arm1156t2-s")
502 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
503 .Cases("armv7r", "armv7-r", "cortex-r4")
504 .Cases("armv7m", "armv7-m", "cortex-m3")
505 .Case("ep9312", "ep9312")
506 .Case("iwmmxt", "iwmmxt")
507 .Case("xscale", "xscale")
508 .Cases("armv6m", "armv6-m", "cortex-m0")
509 // If all else failed, return the most base CPU LLVM supports.
510 .Default("arm7tdmi");
513 // FIXME: Move to target hook.
514 static bool isSignedCharDefault(const llvm::Triple &Triple) {
515 switch (Triple.getArch()) {
519 case llvm::Triple::arm:
520 case llvm::Triple::ppc:
521 case llvm::Triple::ppc64:
522 if (Triple.isOSDarwin())
530 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
532 static void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args,
533 ArgStringList &CmdArgs) {
534 StringRef FPU = A->getValue(Args);
536 // Set the target features based on the FPU.
537 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
538 // Disable any default FPU support.
539 CmdArgs.push_back("-target-feature");
540 CmdArgs.push_back("-vfp2");
541 CmdArgs.push_back("-target-feature");
542 CmdArgs.push_back("-vfp3");
543 CmdArgs.push_back("-target-feature");
544 CmdArgs.push_back("-neon");
545 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
546 CmdArgs.push_back("-target-feature");
547 CmdArgs.push_back("+vfp3");
548 CmdArgs.push_back("-target-feature");
549 CmdArgs.push_back("+d16");
550 CmdArgs.push_back("-target-feature");
551 CmdArgs.push_back("-neon");
552 } else if (FPU == "vfp") {
553 CmdArgs.push_back("-target-feature");
554 CmdArgs.push_back("+vfp2");
555 CmdArgs.push_back("-target-feature");
556 CmdArgs.push_back("-neon");
557 } else if (FPU == "vfp3" || FPU == "vfpv3") {
558 CmdArgs.push_back("-target-feature");
559 CmdArgs.push_back("+vfp3");
560 CmdArgs.push_back("-target-feature");
561 CmdArgs.push_back("-neon");
562 } else if (FPU == "neon") {
563 CmdArgs.push_back("-target-feature");
564 CmdArgs.push_back("+neon");
566 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
570 static void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args,
571 ArgStringList &CmdArgs, StringRef CPU) {
572 StringRef FPMath = A->getValue(Args);
574 // Set the target features based on the FPMath.
575 if (FPMath == "neon") {
576 CmdArgs.push_back("-target-feature");
577 CmdArgs.push_back("+neonfp");
579 if (CPU != "cortex-a8" && CPU != "cortex-a9" && CPU != "cortex-a9-mp")
580 D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU;
582 } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" ||
584 CmdArgs.push_back("-target-feature");
585 CmdArgs.push_back("-neonfp");
587 // FIXME: Add warnings when disabling a feature not present for a given CPU.
589 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
592 // Select the float ABI as determined by -msoft-float, -mhard-float, and
594 static StringRef getARMFloatABI(const Driver &D,
596 const llvm::Triple &Triple) {
598 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
599 options::OPT_mhard_float,
600 options::OPT_mfloat_abi_EQ)) {
601 if (A->getOption().matches(options::OPT_msoft_float))
603 else if (A->getOption().matches(options::OPT_mhard_float))
606 FloatABI = A->getValue(Args);
607 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
608 D.Diag(diag::err_drv_invalid_mfloat_abi)
609 << A->getAsString(Args);
615 // If unspecified, choose the default based on the platform.
616 if (FloatABI.empty()) {
617 switch (Triple.getOS()) {
618 case llvm::Triple::Darwin:
619 case llvm::Triple::MacOSX:
620 case llvm::Triple::IOS: {
621 // Darwin defaults to "softfp" for v6 and v7.
623 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
624 std::string ArchName =
625 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
626 if (StringRef(ArchName).startswith("v6") ||
627 StringRef(ArchName).startswith("v7"))
635 switch(Triple.getEnvironment()) {
636 case llvm::Triple::GNUEABIHF:
639 case llvm::Triple::GNUEABI:
642 case llvm::Triple::EABI:
643 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
646 case llvm::Triple::ANDROIDEABI: {
647 std::string ArchName =
648 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
649 if (StringRef(ArchName).startswith("v7"))
656 // Assume "soft", but warn the user we are guessing.
658 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
668 void Clang::AddARMTargetArgs(const ArgList &Args,
669 ArgStringList &CmdArgs,
670 bool KernelOrKext) const {
671 const Driver &D = getToolChain().getDriver();
672 llvm::Triple Triple = getToolChain().getTriple();
674 // Select the ABI to use.
676 // FIXME: Support -meabi.
677 const char *ABIName = 0;
678 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
679 ABIName = A->getValue(Args);
681 // Select the default based on the platform.
682 switch(Triple.getEnvironment()) {
683 case llvm::Triple::ANDROIDEABI:
684 case llvm::Triple::GNUEABI:
685 case llvm::Triple::GNUEABIHF:
686 ABIName = "aapcs-linux";
688 case llvm::Triple::EABI:
692 ABIName = "apcs-gnu";
695 CmdArgs.push_back("-target-abi");
696 CmdArgs.push_back(ABIName);
698 // Set the CPU based on -march= and -mcpu=.
699 CmdArgs.push_back("-target-cpu");
700 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
702 // Determine floating point ABI from the options & target defaults.
703 StringRef FloatABI = getARMFloatABI(D, Args, Triple);
704 if (FloatABI == "soft") {
705 // Floating point operations and argument passing are soft.
707 // FIXME: This changes CPP defines, we need -target-soft-float.
708 CmdArgs.push_back("-msoft-float");
709 CmdArgs.push_back("-mfloat-abi");
710 CmdArgs.push_back("soft");
711 } else if (FloatABI == "softfp") {
712 // Floating point operations are hard, but argument passing is soft.
713 CmdArgs.push_back("-mfloat-abi");
714 CmdArgs.push_back("soft");
716 // Floating point operations and argument passing are hard.
717 assert(FloatABI == "hard" && "Invalid float abi!");
718 CmdArgs.push_back("-mfloat-abi");
719 CmdArgs.push_back("hard");
722 // Set appropriate target features for floating point mode.
724 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
725 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
726 // stripped out by the ARM target.
728 // Use software floating point operations?
729 if (FloatABI == "soft") {
730 CmdArgs.push_back("-target-feature");
731 CmdArgs.push_back("+soft-float");
734 // Use software floating point argument passing?
735 if (FloatABI != "hard") {
736 CmdArgs.push_back("-target-feature");
737 CmdArgs.push_back("+soft-float-abi");
741 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
742 addFPUArgs(D, A, Args, CmdArgs);
745 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
746 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
748 // Setting -msoft-float effectively disables NEON because of the GCC
749 // implementation, although the same isn't true of VFP or VFP3.
750 if (FloatABI == "soft") {
751 CmdArgs.push_back("-target-feature");
752 CmdArgs.push_back("-neon");
755 // Kernel code has more strict alignment requirements.
757 CmdArgs.push_back("-backend-option");
758 CmdArgs.push_back("-arm-long-calls");
760 CmdArgs.push_back("-backend-option");
761 CmdArgs.push_back("-arm-strict-align");
763 // The kext linker doesn't know how to deal with movw/movt.
764 CmdArgs.push_back("-backend-option");
765 CmdArgs.push_back("-arm-darwin-use-movt=0");
768 // Setting -mno-global-merge disables the codegen global merge pass. Setting
769 // -mglobal-merge has no effect as the pass is enabled by default.
770 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
771 options::OPT_mno_global_merge)) {
772 if (A->getOption().matches(options::OPT_mno_global_merge))
773 CmdArgs.push_back("-mno-global-merge");
776 if (Args.hasArg(options::OPT_mno_implicit_float))
777 CmdArgs.push_back("-no-implicit-float");
780 // Get default architecture.
781 static const char* getMipsArchFromCPU(StringRef CPUName) {
782 if (CPUName == "mips32" || CPUName == "mips32r2")
785 assert((CPUName == "mips64" || CPUName == "mips64r2") &&
786 "Unexpected cpu name.");
791 // Check that ArchName is a known Mips architecture name.
792 static bool checkMipsArchName(StringRef ArchName) {
793 return ArchName == "mips" ||
794 ArchName == "mipsel" ||
795 ArchName == "mips64" ||
796 ArchName == "mips64el";
799 // Get default target cpu.
800 static const char* getMipsCPUFromArch(StringRef ArchName) {
801 if (ArchName == "mips" || ArchName == "mipsel")
804 assert((ArchName == "mips64" || ArchName == "mips64el") &&
805 "Unexpected arch name.");
811 static const char* getMipsABIFromArch(StringRef ArchName) {
812 if (ArchName == "mips" || ArchName == "mipsel")
815 assert((ArchName == "mips64" || ArchName == "mips64el") &&
816 "Unexpected arch name.");
820 // Get CPU and ABI names. They are not independent
821 // so we have to calculate them together.
822 static void getMipsCPUAndABI(const ArgList &Args,
825 StringRef &ABIName) {
828 // Select target cpu and architecture.
829 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
830 CPUName = A->getValue(Args);
831 ArchName = getMipsArchFromCPU(CPUName);
834 ArchName = Args.MakeArgString(TC.getArchName());
835 if (!checkMipsArchName(ArchName))
836 TC.getDriver().Diag(diag::err_drv_invalid_arch_name) << ArchName;
838 CPUName = getMipsCPUFromArch(ArchName);
841 // Select the ABI to use.
842 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
843 ABIName = A->getValue(Args);
845 ABIName = getMipsABIFromArch(ArchName);
848 // Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
850 static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
851 // Select the float ABI as determined by -msoft-float, -mhard-float,
854 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
855 options::OPT_mhard_float,
856 options::OPT_mfloat_abi_EQ)) {
857 if (A->getOption().matches(options::OPT_msoft_float))
859 else if (A->getOption().matches(options::OPT_mhard_float))
862 FloatABI = A->getValue(Args);
863 if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") {
864 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
870 // If unspecified, choose the default based on the platform.
871 if (FloatABI.empty()) {
872 // Assume "hard", because it's a default value used by gcc.
873 // When we start to recognize specific target MIPS processors,
874 // we will be able to select the default more correctly.
881 static void AddTargetFeature(const ArgList &Args,
882 ArgStringList &CmdArgs,
885 StringRef FeatureName) {
886 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
887 CmdArgs.push_back("-target-feature");
888 if (A->getOption().matches(OnOpt))
889 CmdArgs.push_back(Args.MakeArgString("+" + FeatureName));
891 CmdArgs.push_back(Args.MakeArgString("-" + FeatureName));
895 void Clang::AddMIPSTargetArgs(const ArgList &Args,
896 ArgStringList &CmdArgs) const {
897 const Driver &D = getToolChain().getDriver();
900 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
902 CmdArgs.push_back("-target-cpu");
903 CmdArgs.push_back(CPUName.data());
905 CmdArgs.push_back("-target-abi");
906 CmdArgs.push_back(ABIName.data());
908 StringRef FloatABI = getMipsFloatABI(D, Args);
910 if (FloatABI == "soft") {
911 // Floating point operations and argument passing are soft.
912 CmdArgs.push_back("-msoft-float");
913 CmdArgs.push_back("-mfloat-abi");
914 CmdArgs.push_back("soft");
916 // FIXME: Note, this is a hack. We need to pass the selected float
917 // mode to the MipsTargetInfoBase to define appropriate macros there.
918 // Now it is the only method.
919 CmdArgs.push_back("-target-feature");
920 CmdArgs.push_back("+soft-float");
922 else if (FloatABI == "single") {
923 // Restrict the use of hardware floating-point
924 // instructions to 32-bit operations.
925 CmdArgs.push_back("-target-feature");
926 CmdArgs.push_back("+single-float");
929 // Floating point operations and argument passing are hard.
930 assert(FloatABI == "hard" && "Invalid float abi!");
931 CmdArgs.push_back("-mfloat-abi");
932 CmdArgs.push_back("hard");
935 AddTargetFeature(Args, CmdArgs,
936 options::OPT_mips16, options::OPT_mno_mips16,
938 AddTargetFeature(Args, CmdArgs,
939 options::OPT_mdsp, options::OPT_mno_dsp,
941 AddTargetFeature(Args, CmdArgs,
942 options::OPT_mdspr2, options::OPT_mno_dspr2,
946 /// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
947 static std::string getPPCTargetCPU(const ArgList &Args) {
948 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
949 StringRef CPUName = A->getValue(Args);
951 if (CPUName == "native") {
952 std::string CPU = llvm::sys::getHostCPUName();
953 if (!CPU.empty() && CPU != "generic")
959 return llvm::StringSwitch<const char *>(CPUName)
960 .Case("common", "generic")
962 .Case("440fp", "440")
967 .Case("603e", "603e")
968 .Case("603ev", "603ev")
970 .Case("604e", "604e")
973 .Case("7400", "7400")
975 .Case("7450", "7450")
981 .Case("power6", "pwr6")
982 .Case("power7", "pwr7")
983 .Case("powerpc", "ppc")
984 .Case("powerpc64", "ppc64")
991 void Clang::AddPPCTargetArgs(const ArgList &Args,
992 ArgStringList &CmdArgs) const {
993 std::string TargetCPUName = getPPCTargetCPU(Args);
995 // LLVM may default to generating code for the native CPU,
996 // but, like gcc, we default to a more generic option for
997 // each architecture. (except on Darwin)
998 llvm::Triple Triple = getToolChain().getTriple();
999 if (TargetCPUName.empty() && !Triple.isOSDarwin()) {
1000 if (Triple.getArch() == llvm::Triple::ppc64)
1001 TargetCPUName = "ppc64";
1003 TargetCPUName = "ppc";
1006 if (!TargetCPUName.empty()) {
1007 CmdArgs.push_back("-target-cpu");
1008 CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str()));
1012 void Clang::AddSparcTargetArgs(const ArgList &Args,
1013 ArgStringList &CmdArgs) const {
1014 const Driver &D = getToolChain().getDriver();
1016 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1017 CmdArgs.push_back("-target-cpu");
1018 CmdArgs.push_back(A->getValue(Args));
1021 // Select the float ABI as determined by -msoft-float, -mhard-float, and
1023 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1024 options::OPT_mhard_float)) {
1025 if (A->getOption().matches(options::OPT_msoft_float))
1027 else if (A->getOption().matches(options::OPT_mhard_float))
1031 // If unspecified, choose the default based on the platform.
1032 if (FloatABI.empty()) {
1033 switch (getToolChain().getTriple().getOS()) {
1035 // Assume "soft", but warn the user we are guessing.
1037 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
1042 if (FloatABI == "soft") {
1043 // Floating point operations and argument passing are soft.
1045 // FIXME: This changes CPP defines, we need -target-soft-float.
1046 CmdArgs.push_back("-msoft-float");
1047 CmdArgs.push_back("-target-feature");
1048 CmdArgs.push_back("+soft-float");
1050 assert(FloatABI == "hard" && "Invalid float abi!");
1051 CmdArgs.push_back("-mhard-float");
1055 void Clang::AddX86TargetArgs(const ArgList &Args,
1056 ArgStringList &CmdArgs) const {
1057 if (!Args.hasFlag(options::OPT_mred_zone,
1058 options::OPT_mno_red_zone,
1060 Args.hasArg(options::OPT_mkernel) ||
1061 Args.hasArg(options::OPT_fapple_kext))
1062 CmdArgs.push_back("-disable-red-zone");
1064 if (Args.hasFlag(options::OPT_msoft_float,
1065 options::OPT_mno_soft_float,
1067 CmdArgs.push_back("-no-implicit-float");
1069 const char *CPUName = 0;
1070 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1071 if (StringRef(A->getValue(Args)) == "native") {
1072 // FIXME: Reject attempts to use -march=native unless the target matches
1075 // FIXME: We should also incorporate the detected target features for use
1077 std::string CPU = llvm::sys::getHostCPUName();
1078 if (!CPU.empty() && CPU != "generic")
1079 CPUName = Args.MakeArgString(CPU);
1081 CPUName = A->getValue(Args);
1084 // Select the default CPU if none was given (or detection failed).
1086 // FIXME: Need target hooks.
1087 if (getToolChain().getTriple().isOSDarwin()) {
1088 if (getToolChain().getArch() == llvm::Triple::x86_64)
1090 else if (getToolChain().getArch() == llvm::Triple::x86)
1092 } else if (getToolChain().getOS().startswith("haiku")) {
1093 if (getToolChain().getArch() == llvm::Triple::x86_64)
1095 else if (getToolChain().getArch() == llvm::Triple::x86)
1097 } else if (getToolChain().getOS().startswith("openbsd")) {
1098 if (getToolChain().getArch() == llvm::Triple::x86_64)
1100 else if (getToolChain().getArch() == llvm::Triple::x86)
1102 } else if (getToolChain().getOS().startswith("bitrig")) {
1103 if (getToolChain().getArch() == llvm::Triple::x86_64)
1105 else if (getToolChain().getArch() == llvm::Triple::x86)
1107 } else if (getToolChain().getOS().startswith("freebsd")) {
1108 if (getToolChain().getArch() == llvm::Triple::x86_64)
1110 else if (getToolChain().getArch() == llvm::Triple::x86)
1112 } else if (getToolChain().getOS().startswith("netbsd")) {
1113 if (getToolChain().getArch() == llvm::Triple::x86_64)
1115 else if (getToolChain().getArch() == llvm::Triple::x86)
1118 if (getToolChain().getArch() == llvm::Triple::x86_64)
1120 else if (getToolChain().getArch() == llvm::Triple::x86)
1121 CPUName = "pentium4";
1126 CmdArgs.push_back("-target-cpu");
1127 CmdArgs.push_back(CPUName);
1130 // The required algorithm here is slightly strange: the options are applied
1131 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
1132 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
1133 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
1134 // former correctly, but not the latter; handle directly-overridden
1136 llvm::StringMap<unsigned> PrevFeature;
1137 std::vector<const char*> Features;
1138 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1139 ie = Args.filtered_end(); it != ie; ++it) {
1140 StringRef Name = (*it)->getOption().getName();
1144 assert(Name.startswith("-m") && "Invalid feature name.");
1145 Name = Name.substr(2);
1147 bool IsNegative = Name.startswith("no-");
1149 Name = Name.substr(3);
1151 unsigned& Prev = PrevFeature[Name];
1153 Features[Prev - 1] = 0;
1154 Prev = Features.size() + 1;
1155 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1157 for (unsigned i = 0; i < Features.size(); i++) {
1159 CmdArgs.push_back("-target-feature");
1160 CmdArgs.push_back(Features[i]);
1165 static Arg* getLastHexagonArchArg (const ArgList &Args)
1169 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1171 if ((*it)->getOption().matches(options::OPT_march_EQ) ||
1172 (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1176 else if ((*it)->getOption().matches(options::OPT_m_Joined)){
1177 StringRef Value = (*it)->getValue(Args,0);
1178 if (Value.startswith("v")) {
1187 static StringRef getHexagonTargetCPU(const ArgList &Args)
1190 llvm::StringRef WhichHexagon;
1192 // Select the default CPU (v4) if none was given or detection failed.
1193 if ((A = getLastHexagonArchArg (Args))) {
1194 WhichHexagon = A->getValue(Args);
1195 if (WhichHexagon == "")
1198 return WhichHexagon;
1204 void Clang::AddHexagonTargetArgs(const ArgList &Args,
1205 ArgStringList &CmdArgs) const {
1206 llvm::Triple Triple = getToolChain().getTriple();
1208 CmdArgs.push_back("-target-cpu");
1209 CmdArgs.push_back(Args.MakeArgString("hexagon" + getHexagonTargetCPU(Args)));
1210 CmdArgs.push_back("-fno-signed-char");
1211 CmdArgs.push_back("-nobuiltininc");
1213 if (Args.hasArg(options::OPT_mqdsp6_compat))
1214 CmdArgs.push_back("-mqdsp6-compat");
1216 if (Arg *A = Args.getLastArg(options::OPT_G,
1217 options::OPT_msmall_data_threshold_EQ)) {
1218 std::string SmallDataThreshold="-small-data-threshold=";
1219 SmallDataThreshold += A->getValue(Args);
1220 CmdArgs.push_back ("-mllvm");
1221 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
1225 if (!Args.hasArg(options::OPT_fno_short_enums))
1226 CmdArgs.push_back("-fshort-enums");
1227 if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1228 CmdArgs.push_back ("-mllvm");
1229 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1231 CmdArgs.push_back ("-mllvm");
1232 CmdArgs.push_back ("-machine-sink-split=0");
1236 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1237 const llvm::Triple &Triple) {
1238 // We use the zero-cost exception tables for Objective-C if the non-fragile
1239 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1241 if (runtime.isNonFragile())
1244 if (!Triple.isOSDarwin())
1247 return (!Triple.isMacOSXVersionLT(10,5) &&
1248 (Triple.getArch() == llvm::Triple::x86_64 ||
1249 Triple.getArch() == llvm::Triple::arm));
1252 /// addExceptionArgs - Adds exception related arguments to the driver command
1253 /// arguments. There's a master flag, -fexceptions and also language specific
1254 /// flags to enable/disable C++ and Objective-C exceptions.
1255 /// This makes it possible to for example disable C++ exceptions but enable
1256 /// Objective-C exceptions.
1257 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1258 const llvm::Triple &Triple,
1260 const ObjCRuntime &objcRuntime,
1261 ArgStringList &CmdArgs) {
1263 // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1264 // arguments now to avoid warnings about unused arguments.
1265 Args.ClaimAllArgs(options::OPT_fexceptions);
1266 Args.ClaimAllArgs(options::OPT_fno_exceptions);
1267 Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1268 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1269 Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1270 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1274 // Exceptions are enabled by default.
1275 bool ExceptionsEnabled = true;
1277 // This keeps track of whether exceptions were explicitly turned on or off.
1278 bool DidHaveExplicitExceptionFlag = false;
1280 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1281 options::OPT_fno_exceptions)) {
1282 if (A->getOption().matches(options::OPT_fexceptions))
1283 ExceptionsEnabled = true;
1285 ExceptionsEnabled = false;
1287 DidHaveExplicitExceptionFlag = true;
1290 bool ShouldUseExceptionTables = false;
1292 // Exception tables and cleanups can be enabled with -fexceptions even if the
1293 // language itself doesn't support exceptions.
1294 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1295 ShouldUseExceptionTables = true;
1297 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1298 // is not necessarily sensible, but follows GCC.
1299 if (types::isObjC(InputType) &&
1300 Args.hasFlag(options::OPT_fobjc_exceptions,
1301 options::OPT_fno_objc_exceptions,
1303 CmdArgs.push_back("-fobjc-exceptions");
1305 ShouldUseExceptionTables |=
1306 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
1309 if (types::isCXX(InputType)) {
1310 bool CXXExceptionsEnabled = ExceptionsEnabled;
1312 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1313 options::OPT_fno_cxx_exceptions,
1314 options::OPT_fexceptions,
1315 options::OPT_fno_exceptions)) {
1316 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1317 CXXExceptionsEnabled = true;
1318 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1319 CXXExceptionsEnabled = false;
1322 if (CXXExceptionsEnabled) {
1323 CmdArgs.push_back("-fcxx-exceptions");
1325 ShouldUseExceptionTables = true;
1329 if (ShouldUseExceptionTables)
1330 CmdArgs.push_back("-fexceptions");
1333 static bool ShouldDisableCFI(const ArgList &Args,
1334 const ToolChain &TC) {
1335 bool Default = true;
1336 if (TC.getTriple().isOSDarwin()) {
1337 // The native darwin assembler doesn't support cfi directives, so
1338 // we disable them if we think the .s file will be passed to it.
1339 Default = Args.hasFlag(options::OPT_integrated_as,
1340 options::OPT_no_integrated_as,
1341 TC.IsIntegratedAssemblerDefault());
1343 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1344 options::OPT_fno_dwarf2_cfi_asm,
1348 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1349 const ToolChain &TC) {
1350 bool IsIADefault = TC.IsIntegratedAssemblerDefault();
1351 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1352 options::OPT_no_integrated_as,
1354 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1355 options::OPT_fno_dwarf_directory_asm,
1357 return !UseDwarfDirectory;
1360 /// \brief Check whether the given input tree contains any compilation actions.
1361 static bool ContainsCompileAction(const Action *A) {
1362 if (isa<CompileJobAction>(A))
1365 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1366 if (ContainsCompileAction(*it))
1372 /// \brief Check if -relax-all should be passed to the internal assembler.
1373 /// This is done by default when compiling non-assembler source with -O0.
1374 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1375 bool RelaxDefault = true;
1377 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1378 RelaxDefault = A->getOption().matches(options::OPT_O0);
1381 RelaxDefault = false;
1382 for (ActionList::const_iterator it = C.getActions().begin(),
1383 ie = C.getActions().end(); it != ie; ++it) {
1384 if (ContainsCompileAction(*it)) {
1385 RelaxDefault = true;
1391 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1395 /// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1396 /// This needs to be called before we add the C run-time (malloc, etc).
1397 static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
1398 ArgStringList &CmdArgs) {
1399 if (!Args.hasFlag(options::OPT_faddress_sanitizer,
1400 options::OPT_fno_address_sanitizer, false))
1402 if(TC.getTriple().getEnvironment() == llvm::Triple::ANDROIDEABI) {
1403 if (!Args.hasArg(options::OPT_shared)) {
1404 if (!Args.hasArg(options::OPT_pie))
1405 TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie);
1406 // For an executable, we add a .preinit_array stub.
1407 CmdArgs.push_back("-u");
1408 CmdArgs.push_back("__asan_preinit");
1409 CmdArgs.push_back("-lasan");
1412 CmdArgs.push_back("-lasan_preload");
1413 CmdArgs.push_back("-ldl");
1415 if (!Args.hasArg(options::OPT_shared)) {
1416 // LibAsan is "libclang_rt.asan-<ArchName>.a" in the Linux library
1417 // resource directory.
1418 SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1419 llvm::sys::path::append(LibAsan, "lib", "linux",
1420 (Twine("libclang_rt.asan-") +
1421 TC.getArchName() + ".a"));
1422 CmdArgs.push_back(Args.MakeArgString(LibAsan));
1423 CmdArgs.push_back("-lpthread");
1424 CmdArgs.push_back("-ldl");
1425 CmdArgs.push_back("-export-dynamic");
1430 /// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1431 /// This needs to be called before we add the C run-time (malloc, etc).
1432 static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1433 ArgStringList &CmdArgs) {
1434 if (!Args.hasFlag(options::OPT_fthread_sanitizer,
1435 options::OPT_fno_thread_sanitizer, false))
1437 if (!Args.hasArg(options::OPT_shared)) {
1438 // LibTsan is "libclang_rt.tsan-<ArchName>.a" in the Linux library
1439 // resource directory.
1440 SmallString<128> LibTsan(TC.getDriver().ResourceDir);
1441 llvm::sys::path::append(LibTsan, "lib", "linux",
1442 (Twine("libclang_rt.tsan-") +
1443 TC.getArchName() + ".a"));
1444 CmdArgs.push_back(Args.MakeArgString(LibTsan));
1445 CmdArgs.push_back("-lpthread");
1446 CmdArgs.push_back("-ldl");
1447 CmdArgs.push_back("-export-dynamic");
1451 static bool shouldUseFramePointer(const ArgList &Args,
1452 const llvm::Triple &Triple) {
1453 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1454 options::OPT_fomit_frame_pointer))
1455 return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1457 // Don't use a frame pointer on linux x86 and x86_64 if optimizing.
1458 if ((Triple.getArch() == llvm::Triple::x86_64 ||
1459 Triple.getArch() == llvm::Triple::x86) &&
1460 Triple.getOS() == llvm::Triple::Linux) {
1461 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1462 if (!A->getOption().matches(options::OPT_O0))
1469 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
1470 const InputInfo &Output,
1471 const InputInfoList &Inputs,
1472 const ArgList &Args,
1473 const char *LinkingOutput) const {
1474 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1475 options::OPT_fapple_kext);
1476 const Driver &D = getToolChain().getDriver();
1477 ArgStringList CmdArgs;
1479 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1481 // Invoke ourselves in -cc1 mode.
1483 // FIXME: Implement custom jobs for internal actions.
1484 CmdArgs.push_back("-cc1");
1486 // Add the "effective" target triple.
1487 CmdArgs.push_back("-triple");
1488 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1489 CmdArgs.push_back(Args.MakeArgString(TripleStr));
1491 // Select the appropriate action.
1492 RewriteKind rewriteKind = RK_None;
1494 if (isa<AnalyzeJobAction>(JA)) {
1495 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1496 CmdArgs.push_back("-analyze");
1497 } else if (isa<MigrateJobAction>(JA)) {
1498 CmdArgs.push_back("-migrate");
1499 } else if (isa<PreprocessJobAction>(JA)) {
1500 if (Output.getType() == types::TY_Dependencies)
1501 CmdArgs.push_back("-Eonly");
1503 CmdArgs.push_back("-E");
1504 } else if (isa<AssembleJobAction>(JA)) {
1505 CmdArgs.push_back("-emit-obj");
1507 if (UseRelaxAll(C, Args))
1508 CmdArgs.push_back("-mrelax-all");
1510 // When using an integrated assembler, translate -Wa, and -Xassembler
1512 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1513 options::OPT_Xassembler),
1514 ie = Args.filtered_end(); it != ie; ++it) {
1518 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1519 StringRef Value = A->getValue(Args, i);
1521 if (Value == "-force_cpusubtype_ALL") {
1522 // Do nothing, this is the default and we don't support anything else.
1523 } else if (Value == "-L") {
1524 CmdArgs.push_back("-msave-temp-labels");
1525 } else if (Value == "--fatal-warnings") {
1526 CmdArgs.push_back("-mllvm");
1527 CmdArgs.push_back("-fatal-assembler-warnings");
1528 } else if (Value == "--noexecstack") {
1529 CmdArgs.push_back("-mnoexecstack");
1531 D.Diag(diag::err_drv_unsupported_option_argument)
1532 << A->getOption().getName() << Value;
1537 // Also ignore explicit -force_cpusubtype_ALL option.
1538 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
1539 } else if (isa<PrecompileJobAction>(JA)) {
1540 // Use PCH if the user requested it.
1541 bool UsePCH = D.CCCUsePCH;
1543 if (JA.getType() == types::TY_Nothing)
1544 CmdArgs.push_back("-fsyntax-only");
1546 CmdArgs.push_back("-emit-pch");
1548 CmdArgs.push_back("-emit-pth");
1550 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
1552 if (JA.getType() == types::TY_Nothing) {
1553 CmdArgs.push_back("-fsyntax-only");
1554 } else if (JA.getType() == types::TY_LLVM_IR ||
1555 JA.getType() == types::TY_LTO_IR) {
1556 CmdArgs.push_back("-emit-llvm");
1557 } else if (JA.getType() == types::TY_LLVM_BC ||
1558 JA.getType() == types::TY_LTO_BC) {
1559 CmdArgs.push_back("-emit-llvm-bc");
1560 } else if (JA.getType() == types::TY_PP_Asm) {
1561 CmdArgs.push_back("-S");
1562 } else if (JA.getType() == types::TY_AST) {
1563 CmdArgs.push_back("-emit-pch");
1564 } else if (JA.getType() == types::TY_RewrittenObjC) {
1565 CmdArgs.push_back("-rewrite-objc");
1566 rewriteKind = RK_NonFragile;
1567 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
1568 CmdArgs.push_back("-rewrite-objc");
1569 rewriteKind = RK_Fragile;
1571 assert(JA.getType() == types::TY_PP_Asm &&
1572 "Unexpected output type!");
1576 // The make clang go fast button.
1577 CmdArgs.push_back("-disable-free");
1579 // Disable the verification pass in -asserts builds.
1581 CmdArgs.push_back("-disable-llvm-verifier");
1584 // Set the main file name, so that debug info works even with
1586 CmdArgs.push_back("-main-file-name");
1587 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
1589 // Some flags which affect the language (via preprocessor
1590 // defines). See darwin::CC1::AddCPPArgs.
1591 if (Args.hasArg(options::OPT_static))
1592 CmdArgs.push_back("-static-define");
1594 if (isa<AnalyzeJobAction>(JA)) {
1595 // Enable region store model by default.
1596 CmdArgs.push_back("-analyzer-store=region");
1598 // Treat blocks as analysis entry points.
1599 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1601 CmdArgs.push_back("-analyzer-eagerly-assume");
1603 CmdArgs.push_back("-analyzer-ipa=inlining");
1605 // Add default argument set.
1606 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
1607 CmdArgs.push_back("-analyzer-checker=core");
1609 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1610 CmdArgs.push_back("-analyzer-checker=unix");
1612 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
1613 CmdArgs.push_back("-analyzer-checker=osx");
1615 CmdArgs.push_back("-analyzer-checker=deadcode");
1617 // Enable the following experimental checkers for testing.
1618 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
1619 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
1620 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
1621 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
1622 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
1623 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
1626 // Set the output format. The default is plist, for (lame) historical
1628 CmdArgs.push_back("-analyzer-output");
1629 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
1630 CmdArgs.push_back(A->getValue(Args));
1632 CmdArgs.push_back("plist");
1634 // Disable the presentation of standard compiler warnings when
1635 // using --analyze. We only want to show static analyzer diagnostics
1636 // or frontend errors.
1637 CmdArgs.push_back("-w");
1639 // Add -Xanalyzer arguments when running as analyzer.
1640 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
1643 CheckCodeGenerationOptions(D, Args);
1645 // Perform argument translation for LLVM backend. This
1646 // takes some care in reconciling with llvm-gcc. The
1647 // issue is that llvm-gcc translates these options based on
1648 // the values in cc1, whereas we are processing based on
1649 // the driver arguments.
1651 // This comes from the default translation the driver + cc1
1652 // would do to enable flag_pic.
1654 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1655 options::OPT_fpic, options::OPT_fno_pic,
1656 options::OPT_fPIE, options::OPT_fno_PIE,
1657 options::OPT_fpie, options::OPT_fno_pie);
1658 bool PICDisabled = false;
1659 bool PICEnabled = false;
1660 bool PICForPIE = false;
1662 PICForPIE = (LastPICArg->getOption().matches(options::OPT_fPIE) ||
1663 LastPICArg->getOption().matches(options::OPT_fpie));
1664 PICEnabled = (PICForPIE ||
1665 LastPICArg->getOption().matches(options::OPT_fPIC) ||
1666 LastPICArg->getOption().matches(options::OPT_fpic));
1667 PICDisabled = !PICEnabled;
1669 // Note that these flags are trump-cards. Regardless of the order w.r.t. the
1670 // PIC or PIE options above, if these show up, PIC is disabled.
1671 if (Args.hasArg(options::OPT_mkernel))
1673 if (Args.hasArg(options::OPT_static))
1675 bool DynamicNoPIC = Args.hasArg(options::OPT_mdynamic_no_pic);
1677 // Select the relocation model.
1678 const char *Model = getToolChain().GetForcedPicModel();
1681 Model = "dynamic-no-pic";
1682 else if (PICDisabled)
1684 else if (PICEnabled)
1687 Model = getToolChain().GetDefaultRelocationModel();
1689 StringRef ModelStr = Model ? Model : "";
1690 if (Model && ModelStr != "pic") {
1691 CmdArgs.push_back("-mrelocation-model");
1692 CmdArgs.push_back(Model);
1695 // Infer the __PIC__ and __PIE__ values.
1696 if (ModelStr == "pic" && PICForPIE) {
1697 CmdArgs.push_back("-pie-level");
1698 CmdArgs.push_back((LastPICArg &&
1699 LastPICArg->getOption().matches(options::OPT_fPIE)) ?
1701 } else if (ModelStr == "pic" || ModelStr == "dynamic-no-pic") {
1702 CmdArgs.push_back("-pic-level");
1703 CmdArgs.push_back(((ModelStr != "dynamic-no-pic" && LastPICArg &&
1704 LastPICArg->getOption().matches(options::OPT_fPIC)) ||
1705 getToolChain().getTriple().isOSDarwin()) ? "2" : "1");
1708 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1709 options::OPT_fno_merge_all_constants))
1710 CmdArgs.push_back("-fno-merge-all-constants");
1712 // LLVM Code Generator Options.
1714 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1715 CmdArgs.push_back("-mregparm");
1716 CmdArgs.push_back(A->getValue(Args));
1719 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1720 CmdArgs.push_back("-mrtd");
1722 if (shouldUseFramePointer(Args, getToolChain().getTriple()))
1723 CmdArgs.push_back("-mdisable-fp-elim");
1724 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1725 options::OPT_fno_zero_initialized_in_bss))
1726 CmdArgs.push_back("-mno-zero-initialized-in-bss");
1727 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1728 options::OPT_fno_strict_aliasing,
1729 getToolChain().IsStrictAliasingDefault()))
1730 CmdArgs.push_back("-relaxed-aliasing");
1731 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
1733 CmdArgs.push_back("-fstrict-enums");
1734 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
1735 options::OPT_fno_optimize_sibling_calls))
1736 CmdArgs.push_back("-mdisable-tail-calls");
1738 // Handle various floating point optimization flags, mapping them to the
1739 // appropriate LLVM code generation flags. The pattern for all of these is to
1740 // default off the codegen optimizations, and if any flag enables them and no
1741 // flag disables them after the flag enabling them, enable the codegen
1742 // optimization. This is complicated by several "umbrella" flags.
1743 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1744 options::OPT_ffinite_math_only,
1745 options::OPT_fno_finite_math_only,
1746 options::OPT_fhonor_infinities,
1747 options::OPT_fno_honor_infinities))
1748 if (A->getOption().getID() != options::OPT_fno_finite_math_only &&
1749 A->getOption().getID() != options::OPT_fhonor_infinities)
1750 CmdArgs.push_back("-menable-no-infs");
1751 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1752 options::OPT_ffinite_math_only,
1753 options::OPT_fno_finite_math_only,
1754 options::OPT_fhonor_nans,
1755 options::OPT_fno_honor_nans))
1756 if (A->getOption().getID() != options::OPT_fno_finite_math_only &&
1757 A->getOption().getID() != options::OPT_fhonor_nans)
1758 CmdArgs.push_back("-menable-no-nans");
1760 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
1761 bool MathErrno = getToolChain().IsMathErrnoDefault();
1762 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1763 options::OPT_fmath_errno,
1764 options::OPT_fno_math_errno))
1765 MathErrno = A->getOption().getID() == options::OPT_fmath_errno;
1767 CmdArgs.push_back("-fmath-errno");
1769 // There are several flags which require disabling very specific
1770 // optimizations. Any of these being disabled forces us to turn off the
1771 // entire set of LLVM optimizations, so collect them through all the flag
1773 bool AssociativeMath = false;
1774 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1775 options::OPT_funsafe_math_optimizations,
1776 options::OPT_fno_unsafe_math_optimizations,
1777 options::OPT_fassociative_math,
1778 options::OPT_fno_associative_math))
1779 if (A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
1780 A->getOption().getID() != options::OPT_fno_associative_math)
1781 AssociativeMath = true;
1782 bool ReciprocalMath = false;
1783 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1784 options::OPT_funsafe_math_optimizations,
1785 options::OPT_fno_unsafe_math_optimizations,
1786 options::OPT_freciprocal_math,
1787 options::OPT_fno_reciprocal_math))
1788 if (A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
1789 A->getOption().getID() != options::OPT_fno_reciprocal_math)
1790 ReciprocalMath = true;
1791 bool SignedZeros = true;
1792 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1793 options::OPT_funsafe_math_optimizations,
1794 options::OPT_fno_unsafe_math_optimizations,
1795 options::OPT_fsigned_zeros,
1796 options::OPT_fno_signed_zeros))
1797 if (A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
1798 A->getOption().getID() != options::OPT_fsigned_zeros)
1799 SignedZeros = false;
1800 bool TrappingMath = true;
1801 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1802 options::OPT_funsafe_math_optimizations,
1803 options::OPT_fno_unsafe_math_optimizations,
1804 options::OPT_ftrapping_math,
1805 options::OPT_fno_trapping_math))
1806 if (A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
1807 A->getOption().getID() != options::OPT_ftrapping_math)
1808 TrappingMath = false;
1809 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
1811 CmdArgs.push_back("-menable-unsafe-fp-math");
1814 // Validate and pass through -fp-contract option.
1815 if (Arg *A = Args.getLastArg(options::OPT_ffast_math,
1816 options::OPT_ffp_contract)) {
1817 if (A->getOption().getID() == options::OPT_ffp_contract) {
1818 StringRef Val = A->getValue(Args);
1819 if (Val == "fast" || Val == "on" || Val == "off") {
1820 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
1822 D.Diag(diag::err_drv_unsupported_option_argument)
1823 << A->getOption().getName() << Val;
1825 } else { // A is OPT_ffast_math
1826 // If fast-math is set then set the fp-contract mode to fast.
1827 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
1831 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
1832 // and if we find them, tell the frontend to provide the appropriate
1833 // preprocessor macros. This is distinct from enabling any optimizations as
1834 // these options induce language changes which must survive serialization
1835 // and deserialization, etc.
1836 if (Args.hasArg(options::OPT_ffast_math))
1837 CmdArgs.push_back("-ffast-math");
1838 if (Args.hasArg(options::OPT_ffinite_math_only))
1839 CmdArgs.push_back("-ffinite-math-only");
1841 // Decide whether to use verbose asm. Verbose assembly is the default on
1842 // toolchains which have the integrated assembler on by default.
1843 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
1844 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
1845 IsVerboseAsmDefault) ||
1846 Args.hasArg(options::OPT_dA))
1847 CmdArgs.push_back("-masm-verbose");
1849 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
1850 CmdArgs.push_back("-mdebug-pass");
1851 CmdArgs.push_back("Structure");
1853 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
1854 CmdArgs.push_back("-mdebug-pass");
1855 CmdArgs.push_back("Arguments");
1858 // Enable -mconstructor-aliases except on darwin, where we have to
1859 // work around a linker bug; see <rdar://problem/7651567>.
1860 if (!getToolChain().getTriple().isOSDarwin())
1861 CmdArgs.push_back("-mconstructor-aliases");
1863 // Darwin's kernel doesn't support guard variables; just die if we
1865 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
1866 CmdArgs.push_back("-fforbid-guard-variables");
1868 if (Args.hasArg(options::OPT_mms_bitfields)) {
1869 CmdArgs.push_back("-mms-bitfields");
1872 // This is a coarse approximation of what llvm-gcc actually does, both
1873 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
1874 // complicated ways.
1875 bool AsynchronousUnwindTables =
1876 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
1877 options::OPT_fno_asynchronous_unwind_tables,
1878 getToolChain().IsUnwindTablesDefault() &&
1880 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
1881 AsynchronousUnwindTables))
1882 CmdArgs.push_back("-munwind-tables");
1884 getToolChain().addClangTargetOptions(CmdArgs);
1886 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
1887 CmdArgs.push_back("-mlimit-float-precision");
1888 CmdArgs.push_back(A->getValue(Args));
1891 // FIXME: Handle -mtune=.
1892 (void) Args.hasArg(options::OPT_mtune_EQ);
1894 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
1895 CmdArgs.push_back("-mcode-model");
1896 CmdArgs.push_back(A->getValue(Args));
1899 // Add target specific cpu and features flags.
1900 switch(getToolChain().getTriple().getArch()) {
1904 case llvm::Triple::arm:
1905 case llvm::Triple::thumb:
1906 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
1909 case llvm::Triple::mips:
1910 case llvm::Triple::mipsel:
1911 case llvm::Triple::mips64:
1912 case llvm::Triple::mips64el:
1913 AddMIPSTargetArgs(Args, CmdArgs);
1916 case llvm::Triple::ppc:
1917 case llvm::Triple::ppc64:
1918 AddPPCTargetArgs(Args, CmdArgs);
1921 case llvm::Triple::sparc:
1922 AddSparcTargetArgs(Args, CmdArgs);
1925 case llvm::Triple::x86:
1926 case llvm::Triple::x86_64:
1927 AddX86TargetArgs(Args, CmdArgs);
1930 case llvm::Triple::hexagon:
1931 AddHexagonTargetArgs(Args, CmdArgs);
1937 // Pass the linker version in use.
1938 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1939 CmdArgs.push_back("-target-linker-version");
1940 CmdArgs.push_back(A->getValue(Args));
1943 // -mno-omit-leaf-frame-pointer is the default on Darwin.
1944 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
1945 options::OPT_mno_omit_leaf_frame_pointer,
1946 !getToolChain().getTriple().isOSDarwin()))
1947 CmdArgs.push_back("-momit-leaf-frame-pointer");
1949 // Explicitly error on some things we know we don't support and can't just
1951 types::ID InputType = Inputs[0].getType();
1952 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1954 if (types::isCXX(InputType) &&
1955 getToolChain().getTriple().isOSDarwin() &&
1956 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1957 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
1958 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
1959 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1960 << Unsupported->getOption().getName();
1964 Args.AddAllArgs(CmdArgs, options::OPT_v);
1965 Args.AddLastArg(CmdArgs, options::OPT_H);
1966 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
1967 CmdArgs.push_back("-header-include-file");
1968 CmdArgs.push_back(D.CCPrintHeadersFilename ?
1969 D.CCPrintHeadersFilename : "-");
1971 Args.AddLastArg(CmdArgs, options::OPT_P);
1972 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
1974 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
1975 CmdArgs.push_back("-diagnostic-log-file");
1976 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
1977 D.CCLogDiagnosticsFilename : "-");
1980 // Use the last option from "-g" group. "-gline-tables-only" is
1981 // preserved, all other debug options are substituted with "-g".
1982 Args.ClaimAllArgs(options::OPT_g_Group);
1983 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
1984 if (A->getOption().matches(options::OPT_gline_tables_only)) {
1985 CmdArgs.push_back("-gline-tables-only");
1986 } else if (!A->getOption().matches(options::OPT_g0) &&
1987 !A->getOption().matches(options::OPT_ggdb0)) {
1988 CmdArgs.push_back("-g");
1992 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
1993 Args.ClaimAllArgs(options::OPT_g_flags_Group);
1995 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1996 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1998 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2000 if (Args.hasArg(options::OPT_ftest_coverage) ||
2001 Args.hasArg(options::OPT_coverage))
2002 CmdArgs.push_back("-femit-coverage-notes");
2003 if (Args.hasArg(options::OPT_fprofile_arcs) ||
2004 Args.hasArg(options::OPT_coverage))
2005 CmdArgs.push_back("-femit-coverage-data");
2007 if (C.getArgs().hasArg(options::OPT_c) ||
2008 C.getArgs().hasArg(options::OPT_S)) {
2009 if (Output.isFilename()) {
2010 CmdArgs.push_back("-coverage-file");
2011 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
2015 // Pass options for controlling the default header search paths.
2016 if (Args.hasArg(options::OPT_nostdinc)) {
2017 CmdArgs.push_back("-nostdsysteminc");
2018 CmdArgs.push_back("-nobuiltininc");
2020 if (Args.hasArg(options::OPT_nostdlibinc))
2021 CmdArgs.push_back("-nostdsysteminc");
2022 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2023 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2026 // Pass the path to compiler resource files.
2027 CmdArgs.push_back("-resource-dir");
2028 CmdArgs.push_back(D.ResourceDir.c_str());
2030 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2032 bool ARCMTEnabled = false;
2033 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
2034 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2035 options::OPT_ccc_arcmt_modify,
2036 options::OPT_ccc_arcmt_migrate)) {
2037 ARCMTEnabled = true;
2038 switch (A->getOption().getID()) {
2040 llvm_unreachable("missed a case");
2041 case options::OPT_ccc_arcmt_check:
2042 CmdArgs.push_back("-arcmt-check");
2044 case options::OPT_ccc_arcmt_modify:
2045 CmdArgs.push_back("-arcmt-modify");
2047 case options::OPT_ccc_arcmt_migrate:
2048 CmdArgs.push_back("-arcmt-migrate");
2049 CmdArgs.push_back("-mt-migrate-directory");
2050 CmdArgs.push_back(A->getValue(Args));
2052 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2053 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2059 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2061 D.Diag(diag::err_drv_argument_not_allowed_with)
2062 << A->getAsString(Args) << "-ccc-arcmt-migrate";
2064 CmdArgs.push_back("-mt-migrate-directory");
2065 CmdArgs.push_back(A->getValue(Args));
2067 if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2068 options::OPT_objcmt_migrate_subscripting)) {
2069 // None specified, means enable them all.
2070 CmdArgs.push_back("-objcmt-migrate-literals");
2071 CmdArgs.push_back("-objcmt-migrate-subscripting");
2073 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2074 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2078 // Add preprocessing options like -I, -D, etc. if we are using the
2081 // FIXME: Support -fpreprocessed
2082 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2083 AddPreprocessingOptions(C, D, Args, CmdArgs, Output, Inputs);
2085 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2086 // that "The compiler can only warn and ignore the option if not recognized".
2087 // When building with ccache, it will pass -D options to clang even on
2088 // preprocessed inputs and configure concludes that -fPIC is not supported.
2089 Args.ClaimAllArgs(options::OPT_D);
2091 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
2093 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2094 if (A->getOption().matches(options::OPT_O4))
2095 CmdArgs.push_back("-O3");
2096 else if (A->getOption().matches(options::OPT_O) &&
2097 A->getValue(Args)[0] == '\0')
2098 CmdArgs.push_back("-O2");
2100 A->render(Args, CmdArgs);
2103 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2104 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2105 CmdArgs.push_back("-pedantic");
2106 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2107 Args.AddLastArg(CmdArgs, options::OPT_w);
2109 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2110 // (-ansi is equivalent to -std=c89).
2112 // If a std is supplied, only add -trigraphs if it follows the
2114 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2115 if (Std->getOption().matches(options::OPT_ansi))
2116 if (types::isCXX(InputType))
2117 CmdArgs.push_back("-std=c++98");
2119 CmdArgs.push_back("-std=c89");
2121 Std->render(Args, CmdArgs);
2123 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2124 options::OPT_trigraphs))
2126 A->render(Args, CmdArgs);
2128 // Honor -std-default.
2130 // FIXME: Clang doesn't correctly handle -std= when the input language
2131 // doesn't match. For the time being just ignore this for C++ inputs;
2132 // eventually we want to do all the standard defaulting here instead of
2133 // splitting it between the driver and clang -cc1.
2134 if (!types::isCXX(InputType))
2135 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2136 "-std=", /*Joined=*/true);
2137 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2140 // Map the bizarre '-Wwrite-strings' flag to a more sensible
2141 // '-fconst-strings'; this better indicates its actual behavior.
2142 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
2144 // For perfect compatibility with GCC, we do this even in the presence of
2145 // '-w'. This flag names something other than a warning for GCC.
2146 CmdArgs.push_back("-fconst-strings");
2149 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2150 // during C++ compilation, which it is by default. GCC keeps this define even
2151 // in the presence of '-w', match this behavior bug-for-bug.
2152 if (types::isCXX(InputType) &&
2153 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2155 CmdArgs.push_back("-fdeprecated-macro");
2158 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2159 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2160 if (Asm->getOption().matches(options::OPT_fasm))
2161 CmdArgs.push_back("-fgnu-keywords");
2163 CmdArgs.push_back("-fno-gnu-keywords");
2166 if (ShouldDisableCFI(Args, getToolChain()))
2167 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2169 if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2170 CmdArgs.push_back("-fno-dwarf-directory-asm");
2172 if (const char *pwd = ::getenv("PWD")) {
2173 // GCC also verifies that stat(pwd) and stat(".") have the same inode
2174 // number. Not doing those because stats are slow, but we could.
2175 if (llvm::sys::path::is_absolute(pwd)) {
2176 std::string CompDir = pwd;
2177 CmdArgs.push_back("-fdebug-compilation-dir");
2178 CmdArgs.push_back(Args.MakeArgString(CompDir));
2182 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2183 options::OPT_ftemplate_depth_EQ)) {
2184 CmdArgs.push_back("-ftemplate-depth");
2185 CmdArgs.push_back(A->getValue(Args));
2188 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2189 CmdArgs.push_back("-fconstexpr-depth");
2190 CmdArgs.push_back(A->getValue(Args));
2193 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2194 options::OPT_Wlarge_by_value_copy_def)) {
2195 if (A->getNumValues()) {
2196 StringRef bytes = A->getValue(Args);
2197 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2199 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2202 if (Arg *A = Args.getLastArg(options::OPT_fbounds_checking,
2203 options::OPT_fbounds_checking_EQ)) {
2204 if (A->getNumValues()) {
2205 StringRef val = A->getValue(Args);
2206 CmdArgs.push_back(Args.MakeArgString("-fbounds-checking=" + val));
2208 CmdArgs.push_back("-fbounds-checking=1");
2211 if (Args.hasArg(options::OPT__relocatable_pch))
2212 CmdArgs.push_back("-relocatable-pch");
2214 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2215 CmdArgs.push_back("-fconstant-string-class");
2216 CmdArgs.push_back(A->getValue(Args));
2219 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2220 CmdArgs.push_back("-ftabstop");
2221 CmdArgs.push_back(A->getValue(Args));
2224 CmdArgs.push_back("-ferror-limit");
2225 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2226 CmdArgs.push_back(A->getValue(Args));
2228 CmdArgs.push_back("19");
2230 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2231 CmdArgs.push_back("-fmacro-backtrace-limit");
2232 CmdArgs.push_back(A->getValue(Args));
2235 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2236 CmdArgs.push_back("-ftemplate-backtrace-limit");
2237 CmdArgs.push_back(A->getValue(Args));
2240 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2241 CmdArgs.push_back("-fconstexpr-backtrace-limit");
2242 CmdArgs.push_back(A->getValue(Args));
2245 // Pass -fmessage-length=.
2246 CmdArgs.push_back("-fmessage-length");
2247 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2248 CmdArgs.push_back(A->getValue(Args));
2250 // If -fmessage-length=N was not specified, determine whether this is a
2251 // terminal and, if so, implicitly define -fmessage-length appropriately.
2252 unsigned N = llvm::sys::Process::StandardErrColumns();
2253 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2256 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
2257 CmdArgs.push_back("-fvisibility");
2258 CmdArgs.push_back(A->getValue(Args));
2261 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2263 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2265 // -fhosted is default.
2266 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2268 CmdArgs.push_back("-ffreestanding");
2270 // Forward -f (flag) options which we can pass directly.
2271 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
2272 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2273 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
2274 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2275 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
2276 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
2277 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
2278 Args.AddLastArg(CmdArgs, options::OPT_faltivec);
2279 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
2280 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
2282 // Report and error for -faltivec on anything other then PowerPC.
2283 if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
2284 if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc ||
2285 getToolChain().getTriple().getArch() == llvm::Triple::ppc64))
2286 D.Diag(diag::err_drv_argument_only_allowed_with)
2287 << A->getAsString(Args) << "ppc/ppc64";
2289 if (getToolChain().SupportsProfiling())
2290 Args.AddLastArg(CmdArgs, options::OPT_pg);
2292 if (Args.hasFlag(options::OPT_faddress_sanitizer,
2293 options::OPT_fno_address_sanitizer, false))
2294 CmdArgs.push_back("-faddress-sanitizer");
2296 if (Args.hasFlag(options::OPT_fthread_sanitizer,
2297 options::OPT_fno_thread_sanitizer, false))
2298 CmdArgs.push_back("-fthread-sanitizer");
2300 // -flax-vector-conversions is default.
2301 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
2302 options::OPT_fno_lax_vector_conversions))
2303 CmdArgs.push_back("-fno-lax-vector-conversions");
2305 if (Args.getLastArg(options::OPT_fapple_kext))
2306 CmdArgs.push_back("-fapple-kext");
2308 if (Args.hasFlag(options::OPT_frewrite_includes,
2309 options::OPT_fno_rewrite_includes, false))
2310 CmdArgs.push_back("-frewrite-includes");
2312 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
2313 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
2314 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
2315 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
2316 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
2318 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
2319 CmdArgs.push_back("-ftrapv-handler");
2320 CmdArgs.push_back(A->getValue(Args));
2323 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
2325 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
2326 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
2327 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
2328 options::OPT_fno_wrapv)) {
2329 if (A->getOption().matches(options::OPT_fwrapv))
2330 CmdArgs.push_back("-fwrapv");
2331 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
2332 options::OPT_fno_strict_overflow)) {
2333 if (A->getOption().matches(options::OPT_fno_strict_overflow))
2334 CmdArgs.push_back("-fwrapv");
2336 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
2337 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
2339 Args.AddLastArg(CmdArgs, options::OPT_pthread);
2341 // -stack-protector=0 is default.
2342 unsigned StackProtectorLevel = 0;
2343 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2344 options::OPT_fstack_protector_all,
2345 options::OPT_fstack_protector)) {
2346 if (A->getOption().matches(options::OPT_fstack_protector))
2347 StackProtectorLevel = 1;
2348 else if (A->getOption().matches(options::OPT_fstack_protector_all))
2349 StackProtectorLevel = 2;
2351 StackProtectorLevel =
2352 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
2354 if (StackProtectorLevel) {
2355 CmdArgs.push_back("-stack-protector");
2356 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2359 // Translate -mstackrealign
2360 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
2362 CmdArgs.push_back("-backend-option");
2363 CmdArgs.push_back("-force-align-stack");
2365 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
2367 CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
2370 if (Args.hasArg(options::OPT_mstack_alignment)) {
2371 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
2372 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
2375 // Forward -f options with positive and negative forms; we translate
2378 if (Args.hasArg(options::OPT_mkernel)) {
2379 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
2380 CmdArgs.push_back("-fapple-kext");
2381 if (!Args.hasArg(options::OPT_fbuiltin))
2382 CmdArgs.push_back("-fno-builtin");
2383 Args.ClaimAllArgs(options::OPT_fno_builtin);
2385 // -fbuiltin is default.
2386 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
2387 CmdArgs.push_back("-fno-builtin");
2389 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2390 options::OPT_fno_assume_sane_operator_new))
2391 CmdArgs.push_back("-fno-assume-sane-operator-new");
2393 // -fblocks=0 is default.
2394 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
2395 getToolChain().IsBlocksDefault()) ||
2396 (Args.hasArg(options::OPT_fgnu_runtime) &&
2397 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
2398 !Args.hasArg(options::OPT_fno_blocks))) {
2399 CmdArgs.push_back("-fblocks");
2401 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
2402 !getToolChain().hasBlocksRuntime())
2403 CmdArgs.push_back("-fblocks-runtime-optional");
2406 // -fmodules enables modules (off by default). However, for C++/Objective-C++,
2407 // users must also pass -fcxx-modules. The latter flag will disappear once the
2408 // modules implementation is solid for C++/Objective-C++ programs as well.
2409 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
2410 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
2411 options::OPT_fno_cxx_modules,
2413 if (AllowedInCXX || !types::isCXX(InputType))
2414 CmdArgs.push_back("-fmodules");
2417 // -faccess-control is default.
2418 if (Args.hasFlag(options::OPT_fno_access_control,
2419 options::OPT_faccess_control,
2421 CmdArgs.push_back("-fno-access-control");
2423 // -felide-constructors is the default.
2424 if (Args.hasFlag(options::OPT_fno_elide_constructors,
2425 options::OPT_felide_constructors,
2427 CmdArgs.push_back("-fno-elide-constructors");
2429 // -frtti is default.
2430 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
2432 CmdArgs.push_back("-fno-rtti");
2434 // -fshort-enums=0 is default for all architectures except Hexagon.
2435 if (Args.hasFlag(options::OPT_fshort_enums,
2436 options::OPT_fno_short_enums,
2437 getToolChain().getTriple().getArch() ==
2438 llvm::Triple::hexagon))
2439 CmdArgs.push_back("-fshort-enums");
2441 // -fsigned-char is default.
2442 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
2443 isSignedCharDefault(getToolChain().getTriple())))
2444 CmdArgs.push_back("-fno-signed-char");
2446 // -fthreadsafe-static is default.
2447 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
2448 options::OPT_fno_threadsafe_statics))
2449 CmdArgs.push_back("-fno-threadsafe-statics");
2451 // -fuse-cxa-atexit is default.
2452 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
2453 options::OPT_fno_use_cxa_atexit,
2454 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
2455 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
2456 getToolChain().getTriple().getArch() != llvm::Triple::hexagon) ||
2458 CmdArgs.push_back("-fno-use-cxa-atexit");
2460 // -fms-extensions=0 is default.
2461 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2462 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2463 CmdArgs.push_back("-fms-extensions");
2466 if (Args.hasArg(options::OPT_fenable_experimental_ms_inline_asm))
2467 CmdArgs.push_back("-fenable-experimental-ms-inline-asm");
2469 // -fms-compatibility=0 is default.
2470 if (Args.hasFlag(options::OPT_fms_compatibility,
2471 options::OPT_fno_ms_compatibility,
2472 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
2473 Args.hasFlag(options::OPT_fms_extensions,
2474 options::OPT_fno_ms_extensions,
2476 CmdArgs.push_back("-fms-compatibility");
2478 // -fmsc-version=1300 is default.
2479 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2480 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
2481 Args.hasArg(options::OPT_fmsc_version)) {
2482 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
2483 if (msc_ver.empty())
2484 CmdArgs.push_back("-fmsc-version=1300");
2486 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
2490 // -fborland-extensions=0 is default.
2491 if (Args.hasFlag(options::OPT_fborland_extensions,
2492 options::OPT_fno_borland_extensions, false))
2493 CmdArgs.push_back("-fborland-extensions");
2495 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
2497 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
2498 options::OPT_fno_delayed_template_parsing,
2499 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
2500 CmdArgs.push_back("-fdelayed-template-parsing");
2502 // -fgnu-keywords default varies depending on language; only pass if
2504 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
2505 options::OPT_fno_gnu_keywords))
2506 A->render(Args, CmdArgs);
2508 if (Args.hasFlag(options::OPT_fgnu89_inline,
2509 options::OPT_fno_gnu89_inline,
2511 CmdArgs.push_back("-fgnu89-inline");
2513 if (Args.hasArg(options::OPT_fno_inline))
2514 CmdArgs.push_back("-fno-inline");
2516 if (Args.hasArg(options::OPT_fno_inline_functions))
2517 CmdArgs.push_back("-fno-inline-functions");
2519 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
2521 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
2522 // legacy is the default.
2523 if (objcRuntime.isNonFragile()) {
2524 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
2525 options::OPT_fno_objc_legacy_dispatch,
2526 objcRuntime.isLegacyDispatchDefaultForArch(
2527 getToolChain().getTriple().getArch()))) {
2528 if (getToolChain().UseObjCMixedDispatch())
2529 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
2531 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
2535 // -fobjc-default-synthesize-properties=1 is default. This only has an effect
2536 // if the nonfragile objc abi is used.
2537 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) {
2538 CmdArgs.push_back("-fobjc-default-synthesize-properties");
2541 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
2542 // NOTE: This logic is duplicated in ToolChains.cpp.
2543 bool ARC = isObjCAutoRefCount(Args);
2545 if (!getToolChain().SupportsObjCARC())
2546 D.Diag(diag::err_arc_unsupported);
2548 CmdArgs.push_back("-fobjc-arc");
2550 // FIXME: It seems like this entire block, and several around it should be
2551 // wrapped in isObjC, but for now we just use it here as this is where it
2552 // was being used previously.
2553 if (types::isCXX(InputType) && types::isObjC(InputType)) {
2554 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2555 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
2557 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
2560 // Allow the user to enable full exceptions code emission.
2561 // We define off for Objective-CC, on for Objective-C++.
2562 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
2563 options::OPT_fno_objc_arc_exceptions,
2564 /*default*/ types::isCXX(InputType)))
2565 CmdArgs.push_back("-fobjc-arc-exceptions");
2568 // -fobjc-infer-related-result-type is the default, except in the Objective-C
2570 if (rewriteKind != RK_None)
2571 CmdArgs.push_back("-fno-objc-infer-related-result-type");
2573 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
2574 // takes precedence.
2575 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
2577 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
2580 D.Diag(diag::err_drv_objc_gc_arr)
2581 << GCArg->getAsString(Args);
2582 } else if (getToolChain().SupportsObjCGC()) {
2583 GCArg->render(Args, CmdArgs);
2585 // FIXME: We should move this to a hard error.
2586 D.Diag(diag::warn_drv_objc_gc_unsupported)
2587 << GCArg->getAsString(Args);
2591 // Add exception args.
2592 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
2593 KernelOrKext, objcRuntime, CmdArgs);
2595 if (getToolChain().UseSjLjExceptions())
2596 CmdArgs.push_back("-fsjlj-exceptions");
2598 // C++ "sane" operator new.
2599 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2600 options::OPT_fno_assume_sane_operator_new))
2601 CmdArgs.push_back("-fno-assume-sane-operator-new");
2603 // -fconstant-cfstrings is default, and may be subject to argument translation
2605 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2606 options::OPT_fno_constant_cfstrings) ||
2607 !Args.hasFlag(options::OPT_mconstant_cfstrings,
2608 options::OPT_mno_constant_cfstrings))
2609 CmdArgs.push_back("-fno-constant-cfstrings");
2611 // -fshort-wchar default varies depending on platform; only
2612 // pass if specified.
2613 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2614 A->render(Args, CmdArgs);
2616 // -fno-pascal-strings is default, only pass non-default. If the tool chain
2617 // happened to translate to -mpascal-strings, we want to back translate here.
2619 // FIXME: This is gross; that translation should be pulled from the
2621 if (Args.hasFlag(options::OPT_fpascal_strings,
2622 options::OPT_fno_pascal_strings,
2624 Args.hasFlag(options::OPT_mpascal_strings,
2625 options::OPT_mno_pascal_strings,
2627 CmdArgs.push_back("-fpascal-strings");
2629 // Honor -fpack-struct= and -fpack-struct, if given. Note that
2630 // -fno-pack-struct doesn't apply to -fpack-struct=.
2631 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
2632 std::string PackStructStr = "-fpack-struct=";
2633 PackStructStr += A->getValue(Args);
2634 CmdArgs.push_back(Args.MakeArgString(PackStructStr));
2635 } else if (Args.hasFlag(options::OPT_fpack_struct,
2636 options::OPT_fno_pack_struct, false)) {
2637 CmdArgs.push_back("-fpack-struct=1");
2640 if (Args.hasArg(options::OPT_mkernel) ||
2641 Args.hasArg(options::OPT_fapple_kext)) {
2642 if (!Args.hasArg(options::OPT_fcommon))
2643 CmdArgs.push_back("-fno-common");
2644 Args.ClaimAllArgs(options::OPT_fno_common);
2647 // -fcommon is default, only pass non-default.
2648 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
2649 CmdArgs.push_back("-fno-common");
2651 // -fsigned-bitfields is default, and clang doesn't yet support
2652 // -funsigned-bitfields.
2653 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
2654 options::OPT_funsigned_bitfields))
2655 D.Diag(diag::warn_drv_clang_unsupported)
2656 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2658 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2659 if (!Args.hasFlag(options::OPT_ffor_scope,
2660 options::OPT_fno_for_scope))
2661 D.Diag(diag::err_drv_clang_unsupported)
2662 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2664 // -fcaret-diagnostics is default.
2665 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2666 options::OPT_fno_caret_diagnostics, true))
2667 CmdArgs.push_back("-fno-caret-diagnostics");
2669 // -fdiagnostics-fixit-info is default, only pass non-default.
2670 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
2671 options::OPT_fno_diagnostics_fixit_info))
2672 CmdArgs.push_back("-fno-diagnostics-fixit-info");
2674 // Enable -fdiagnostics-show-option by default.
2675 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
2676 options::OPT_fno_diagnostics_show_option))
2677 CmdArgs.push_back("-fdiagnostics-show-option");
2680 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2681 CmdArgs.push_back("-fdiagnostics-show-category");
2682 CmdArgs.push_back(A->getValue(Args));
2686 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2687 CmdArgs.push_back("-fdiagnostics-format");
2688 CmdArgs.push_back(A->getValue(Args));
2691 if (Arg *A = Args.getLastArg(
2692 options::OPT_fdiagnostics_show_note_include_stack,
2693 options::OPT_fno_diagnostics_show_note_include_stack)) {
2694 if (A->getOption().matches(
2695 options::OPT_fdiagnostics_show_note_include_stack))
2696 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2698 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2701 // Color diagnostics are the default, unless the terminal doesn't support
2703 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
2704 options::OPT_fno_color_diagnostics,
2705 llvm::sys::Process::StandardErrHasColors()))
2706 CmdArgs.push_back("-fcolor-diagnostics");
2708 if (!Args.hasFlag(options::OPT_fshow_source_location,
2709 options::OPT_fno_show_source_location))
2710 CmdArgs.push_back("-fno-show-source-location");
2712 if (!Args.hasFlag(options::OPT_fshow_column,
2713 options::OPT_fno_show_column,
2715 CmdArgs.push_back("-fno-show-column");
2717 if (!Args.hasFlag(options::OPT_fspell_checking,
2718 options::OPT_fno_spell_checking))
2719 CmdArgs.push_back("-fno-spell-checking");
2722 // Silently ignore -fasm-blocks for now.
2723 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2726 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2727 A->render(Args, CmdArgs);
2729 // -fdollars-in-identifiers default varies depending on platform and
2730 // language; only pass if specified.
2731 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
2732 options::OPT_fno_dollars_in_identifiers)) {
2733 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
2734 CmdArgs.push_back("-fdollars-in-identifiers");
2736 CmdArgs.push_back("-fno-dollars-in-identifiers");
2739 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
2740 // practical purposes.
2741 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
2742 options::OPT_fno_unit_at_a_time)) {
2743 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
2744 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
2747 if (Args.hasFlag(options::OPT_fapple_pragma_pack,
2748 options::OPT_fno_apple_pragma_pack, false))
2749 CmdArgs.push_back("-fapple-pragma-pack");
2751 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
2753 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
2755 if (getToolChain().getTriple().isOSDarwin() &&
2756 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2757 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
2758 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2759 CmdArgs.push_back("-fno-builtin-strcat");
2760 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2761 CmdArgs.push_back("-fno-builtin-strcpy");
2765 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
2766 if (Arg *A = Args.getLastArg(options::OPT_traditional,
2767 options::OPT_traditional_cpp)) {
2768 if (isa<PreprocessJobAction>(JA))
2769 CmdArgs.push_back("-traditional-cpp");
2771 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
2774 Args.AddLastArg(CmdArgs, options::OPT_dM);
2775 Args.AddLastArg(CmdArgs, options::OPT_dD);
2777 // Handle serialized diagnostics.
2778 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
2779 CmdArgs.push_back("-serialize-diagnostic-file");
2780 CmdArgs.push_back(Args.MakeArgString(A->getValue(Args)));
2783 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
2785 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
2786 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
2787 ie = Args.filtered_end(); it != ie; ++it) {
2790 // We translate this by hand to the -cc1 argument, since nightly test uses
2791 // it and developers have been trained to spell it with -mllvm.
2792 if (StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
2793 CmdArgs.push_back("-disable-llvm-optzns");
2795 (*it)->render(Args, CmdArgs);
2798 if (Output.getType() == types::TY_Dependencies) {
2799 // Handled with other dependency code.
2800 } else if (Output.isFilename()) {
2801 CmdArgs.push_back("-o");
2802 CmdArgs.push_back(Output.getFilename());
2804 assert(Output.isNothing() && "Invalid output.");
2807 for (InputInfoList::const_iterator
2808 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2809 const InputInfo &II = *it;
2810 CmdArgs.push_back("-x");
2811 CmdArgs.push_back(types::getTypeName(II.getType()));
2812 if (II.isFilename())
2813 CmdArgs.push_back(II.getFilename());
2815 II.getInputArg().renderAsInput(Args, CmdArgs);
2818 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2820 const char *Exec = getToolChain().getDriver().getClangProgramPath();
2822 // Optionally embed the -cc1 level arguments into the debug info, for build
2824 if (getToolChain().UseDwarfDebugFlags()) {
2825 ArgStringList OriginalArgs;
2826 for (ArgList::const_iterator it = Args.begin(),
2827 ie = Args.end(); it != ie; ++it)
2828 (*it)->render(Args, OriginalArgs);
2830 SmallString<256> Flags;
2832 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
2834 Flags += OriginalArgs[i];
2836 CmdArgs.push_back("-dwarf-debug-flags");
2837 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
2840 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2842 if (Arg *A = Args.getLastArg(options::OPT_pg))
2843 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2844 D.Diag(diag::err_drv_argument_not_allowed_with)
2845 << "-fomit-frame-pointer" << A->getAsString(Args);
2847 // Claim some arguments which clang supports automatically.
2849 // -fpch-preprocess is used with gcc to add a special marker in the output to
2850 // include the PCH file. Clang's PTH solution is completely transparent, so we
2851 // do not need to deal with it at all.
2852 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
2854 // Claim some arguments which clang doesn't support, but we don't
2855 // care to warn the user about.
2856 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
2857 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
2859 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
2860 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
2861 Args.ClaimAllArgs(options::OPT_emit_llvm);
2864 void ClangAs::AddARMTargetArgs(const ArgList &Args,
2865 ArgStringList &CmdArgs) const {
2866 const Driver &D = getToolChain().getDriver();
2867 llvm::Triple Triple = getToolChain().getTriple();
2869 // Set the CPU based on -march= and -mcpu=.
2870 CmdArgs.push_back("-target-cpu");
2871 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple)));
2874 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
2875 addFPUArgs(D, A, Args, CmdArgs);
2878 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ))
2879 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple));
2882 /// Add options related to the Objective-C runtime/ABI.
2884 /// Returns true if the runtime is non-fragile.
2885 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
2886 ArgStringList &cmdArgs,
2887 RewriteKind rewriteKind) const {
2888 // Look for the controlling runtime option.
2889 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
2890 options::OPT_fgnu_runtime,
2891 options::OPT_fobjc_runtime_EQ);
2893 // Just forward -fobjc-runtime= to the frontend. This supercedes
2894 // options about fragility.
2896 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
2897 ObjCRuntime runtime;
2898 StringRef value = runtimeArg->getValue(args);
2899 if (runtime.tryParse(value)) {
2900 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
2904 runtimeArg->render(args, cmdArgs);
2908 // Otherwise, we'll need the ABI "version". Version numbers are
2909 // slightly confusing for historical reasons:
2910 // 1 - Traditional "fragile" ABI
2911 // 2 - Non-fragile ABI, version 1
2912 // 3 - Non-fragile ABI, version 2
2913 unsigned objcABIVersion = 1;
2914 // If -fobjc-abi-version= is present, use that to set the version.
2915 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
2916 StringRef value = abiArg->getValue(args);
2919 else if (value == "2")
2921 else if (value == "3")
2924 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
2927 // Otherwise, determine if we are using the non-fragile ABI.
2928 bool nonFragileABIIsDefault =
2929 (rewriteKind == RK_NonFragile ||
2930 (rewriteKind == RK_None &&
2931 getToolChain().IsObjCNonFragileABIDefault()));
2932 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
2933 options::OPT_fno_objc_nonfragile_abi,
2934 nonFragileABIIsDefault)) {
2935 // Determine the non-fragile ABI version to use.
2936 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
2937 unsigned nonFragileABIVersion = 1;
2939 unsigned nonFragileABIVersion = 2;
2942 if (Arg *abiArg = args.getLastArg(
2943 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
2944 StringRef value = abiArg->getValue(args);
2946 nonFragileABIVersion = 1;
2947 else if (value == "2")
2948 nonFragileABIVersion = 2;
2950 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
2954 objcABIVersion = 1 + nonFragileABIVersion;
2960 // We don't actually care about the ABI version other than whether
2961 // it's non-fragile.
2962 bool isNonFragile = objcABIVersion != 1;
2964 // If we have no runtime argument, ask the toolchain for its default runtime.
2965 // However, the rewriter only really supports the Mac runtime, so assume that.
2966 ObjCRuntime runtime;
2968 switch (rewriteKind) {
2970 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
2973 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
2976 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
2981 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
2982 // On Darwin, make this use the default behavior for the toolchain.
2983 if (getToolChain().getTriple().isOSDarwin()) {
2984 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
2986 // Otherwise, build for a generic macosx port.
2988 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
2993 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
2994 // Legacy behaviour is to target the gnustep runtime if we are i
2995 // non-fragile mode or the GCC runtime in fragile mode.
2997 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple());
2999 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3002 cmdArgs.push_back(args.MakeArgString(
3003 "-fobjc-runtime=" + runtime.getAsString()));
3007 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
3008 const InputInfo &Output,
3009 const InputInfoList &Inputs,
3010 const ArgList &Args,
3011 const char *LinkingOutput) const {
3012 ArgStringList CmdArgs;
3014 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3015 const InputInfo &Input = Inputs[0];
3017 // Don't warn about "clang -w -c foo.s"
3018 Args.ClaimAllArgs(options::OPT_w);
3019 // and "clang -emit-llvm -c foo.s"
3020 Args.ClaimAllArgs(options::OPT_emit_llvm);
3021 // and "clang -use-gold-plugin -c foo.s"
3022 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
3024 // Invoke ourselves in -cc1as mode.
3026 // FIXME: Implement custom jobs for internal actions.
3027 CmdArgs.push_back("-cc1as");
3029 // Add the "effective" target triple.
3030 CmdArgs.push_back("-triple");
3031 std::string TripleStr =
3032 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
3033 CmdArgs.push_back(Args.MakeArgString(TripleStr));
3035 // Set the output mode, we currently only expect to be used as a real
3037 CmdArgs.push_back("-filetype");
3038 CmdArgs.push_back("obj");
3040 if (UseRelaxAll(C, Args))
3041 CmdArgs.push_back("-relax-all");
3043 // Add target specific cpu and features flags.
3044 switch(getToolChain().getTriple().getArch()) {
3048 case llvm::Triple::arm:
3049 case llvm::Triple::thumb:
3050 AddARMTargetArgs(Args, CmdArgs);
3054 // Ignore explicit -force_cpusubtype_ALL option.
3055 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
3057 // Determine the original source input.
3058 const Action *SourceAction = &JA;
3059 while (SourceAction->getKind() != Action::InputClass) {
3060 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3061 SourceAction = SourceAction->getInputs()[0];
3064 // Forward -g, assuming we are dealing with an actual assembly file.
3065 if (SourceAction->getType() == types::TY_Asm ||
3066 SourceAction->getType() == types::TY_PP_Asm) {
3067 Args.ClaimAllArgs(options::OPT_g_Group);
3068 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
3069 if (!A->getOption().matches(options::OPT_g0))
3070 CmdArgs.push_back("-g");
3073 // Optionally embed the -cc1as level arguments into the debug info, for build
3075 if (getToolChain().UseDwarfDebugFlags()) {
3076 ArgStringList OriginalArgs;
3077 for (ArgList::const_iterator it = Args.begin(),
3078 ie = Args.end(); it != ie; ++it)
3079 (*it)->render(Args, OriginalArgs);
3081 SmallString<256> Flags;
3082 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3084 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3086 Flags += OriginalArgs[i];
3088 CmdArgs.push_back("-dwarf-debug-flags");
3089 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3092 // FIXME: Add -static support, once we have it.
3094 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3095 options::OPT_Xassembler);
3096 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
3098 assert(Output.isFilename() && "Unexpected lipo output.");
3099 CmdArgs.push_back("-o");
3100 CmdArgs.push_back(Output.getFilename());
3102 assert(Input.isFilename() && "Invalid input.");
3103 CmdArgs.push_back(Input.getFilename());
3105 const char *Exec = getToolChain().getDriver().getClangProgramPath();
3106 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3109 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
3110 const InputInfo &Output,
3111 const InputInfoList &Inputs,
3112 const ArgList &Args,
3113 const char *LinkingOutput) const {
3114 const Driver &D = getToolChain().getDriver();
3115 ArgStringList CmdArgs;
3117 for (ArgList::const_iterator
3118 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
3120 if (A->getOption().hasForwardToGCC()) {
3121 // Don't forward any -g arguments to assembly steps.
3122 if (isa<AssembleJobAction>(JA) &&
3123 A->getOption().matches(options::OPT_g_Group))
3126 // It is unfortunate that we have to claim here, as this means
3127 // we will basically never report anything interesting for
3128 // platforms using a generic gcc, even if we are just using gcc
3129 // to get to the assembler.
3131 A->render(Args, CmdArgs);
3135 RenderExtraToolArgs(JA, CmdArgs);
3137 // If using a driver driver, force the arch.
3138 const std::string &Arch = getToolChain().getArchName();
3139 if (getToolChain().getTriple().isOSDarwin()) {
3140 CmdArgs.push_back("-arch");
3142 // FIXME: Remove these special cases.
3143 if (Arch == "powerpc")
3144 CmdArgs.push_back("ppc");
3145 else if (Arch == "powerpc64")
3146 CmdArgs.push_back("ppc64");
3148 CmdArgs.push_back(Args.MakeArgString(Arch));
3151 // Try to force gcc to match the tool chain we want, if we recognize
3154 // FIXME: The triple class should directly provide the information we want
3156 if (Arch == "i386" || Arch == "powerpc")
3157 CmdArgs.push_back("-m32");
3158 else if (Arch == "x86_64" || Arch == "powerpc64")
3159 CmdArgs.push_back("-m64");
3161 if (Output.isFilename()) {
3162 CmdArgs.push_back("-o");
3163 CmdArgs.push_back(Output.getFilename());
3165 assert(Output.isNothing() && "Unexpected output");
3166 CmdArgs.push_back("-fsyntax-only");
3169 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3170 options::OPT_Xassembler);
3172 // Only pass -x if gcc will understand it; otherwise hope gcc
3173 // understands the suffix correctly. The main use case this would go
3174 // wrong in is for linker inputs if they happened to have an odd
3175 // suffix; really the only way to get this to happen is a command
3176 // like '-x foobar a.c' which will treat a.c like a linker input.
3178 // FIXME: For the linker case specifically, can we safely convert
3179 // inputs into '-Wl,' options?
3180 for (InputInfoList::const_iterator
3181 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3182 const InputInfo &II = *it;
3184 // Don't try to pass LLVM or AST inputs to a generic gcc.
3185 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3186 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3187 D.Diag(diag::err_drv_no_linker_llvm_support)
3188 << getToolChain().getTripleString();
3189 else if (II.getType() == types::TY_AST)
3190 D.Diag(diag::err_drv_no_ast_support)
3191 << getToolChain().getTripleString();
3193 if (types::canTypeBeUserSpecified(II.getType())) {
3194 CmdArgs.push_back("-x");
3195 CmdArgs.push_back(types::getTypeName(II.getType()));
3198 if (II.isFilename())
3199 CmdArgs.push_back(II.getFilename());
3201 const Arg &A = II.getInputArg();
3203 // Reverse translate some rewritten options.
3204 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
3205 CmdArgs.push_back("-lstdc++");
3209 // Don't render as input, we need gcc to do the translations.
3210 A.render(Args, CmdArgs);
3214 const std::string customGCCName = D.getCCCGenericGCCName();
3215 const char *GCCName;
3216 if (!customGCCName.empty())
3217 GCCName = customGCCName.c_str();
3218 else if (D.CCCIsCXX) {
3224 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3225 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3228 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
3229 ArgStringList &CmdArgs) const {
3230 CmdArgs.push_back("-E");
3233 void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
3234 ArgStringList &CmdArgs) const {
3235 // The type is good enough.
3238 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
3239 ArgStringList &CmdArgs) const {
3240 const Driver &D = getToolChain().getDriver();
3242 // If -flto, etc. are present then make sure not to force assembly output.
3243 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
3244 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
3245 CmdArgs.push_back("-c");
3247 if (JA.getType() != types::TY_PP_Asm)
3248 D.Diag(diag::err_drv_invalid_gcc_output_type)
3249 << getTypeName(JA.getType());
3251 CmdArgs.push_back("-S");
3255 void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
3256 ArgStringList &CmdArgs) const {
3257 CmdArgs.push_back("-c");
3260 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
3261 ArgStringList &CmdArgs) const {
3262 // The types are (hopefully) good enough.
3265 // Hexagon tools start.
3266 void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
3267 ArgStringList &CmdArgs) const {
3270 void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3271 const InputInfo &Output,
3272 const InputInfoList &Inputs,
3273 const ArgList &Args,
3274 const char *LinkingOutput) const {
3276 const Driver &D = getToolChain().getDriver();
3277 ArgStringList CmdArgs;
3279 std::string MarchString = "-march=";
3280 MarchString += getHexagonTargetCPU(Args);
3281 CmdArgs.push_back(Args.MakeArgString(MarchString));
3283 RenderExtraToolArgs(JA, CmdArgs);
3285 if (Output.isFilename()) {
3286 CmdArgs.push_back("-o");
3287 CmdArgs.push_back(Output.getFilename());
3289 assert(Output.isNothing() && "Unexpected output");
3290 CmdArgs.push_back("-fsyntax-only");
3294 // Only pass -x if gcc will understand it; otherwise hope gcc
3295 // understands the suffix correctly. The main use case this would go
3296 // wrong in is for linker inputs if they happened to have an odd
3297 // suffix; really the only way to get this to happen is a command
3298 // like '-x foobar a.c' which will treat a.c like a linker input.
3300 // FIXME: For the linker case specifically, can we safely convert
3301 // inputs into '-Wl,' options?
3302 for (InputInfoList::const_iterator
3303 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3304 const InputInfo &II = *it;
3306 // Don't try to pass LLVM or AST inputs to a generic gcc.
3307 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3308 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3309 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3310 << getToolChain().getTripleString();
3311 else if (II.getType() == types::TY_AST)
3312 D.Diag(clang::diag::err_drv_no_ast_support)
3313 << getToolChain().getTripleString();
3315 if (II.isFilename())
3316 CmdArgs.push_back(II.getFilename());
3318 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3319 II.getInputArg().render(Args, CmdArgs);
3322 const char *GCCName = "hexagon-as";
3324 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3325 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3328 void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
3329 ArgStringList &CmdArgs) const {
3330 // The types are (hopefully) good enough.
3333 void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
3334 const InputInfo &Output,
3335 const InputInfoList &Inputs,
3336 const ArgList &Args,
3337 const char *LinkingOutput) const {
3339 const Driver &D = getToolChain().getDriver();
3340 ArgStringList CmdArgs;
3342 for (ArgList::const_iterator
3343 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
3345 if (A->getOption().hasForwardToGCC()) {
3346 // Don't forward any -g arguments to assembly steps.
3347 if (isa<AssembleJobAction>(JA) &&
3348 A->getOption().matches(options::OPT_g_Group))
3351 // It is unfortunate that we have to claim here, as this means
3352 // we will basically never report anything interesting for
3353 // platforms using a generic gcc, even if we are just using gcc
3354 // to get to the assembler.
3356 A->render(Args, CmdArgs);
3360 RenderExtraToolArgs(JA, CmdArgs);
3362 // Add Arch Information
3364 if ((A = getLastHexagonArchArg(Args))) {
3365 if (A->getOption().matches(options::OPT_m_Joined))
3366 A->render(Args, CmdArgs);
3368 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args)));
3371 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args)));
3374 CmdArgs.push_back("-mqdsp6-compat");
3376 const char *GCCName;
3377 if (C.getDriver().CCCIsCXX)
3378 GCCName = "hexagon-g++";
3380 GCCName = "hexagon-gcc";
3382 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
3384 if (Output.isFilename()) {
3385 CmdArgs.push_back("-o");
3386 CmdArgs.push_back(Output.getFilename());
3389 for (InputInfoList::const_iterator
3390 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3391 const InputInfo &II = *it;
3393 // Don't try to pass LLVM or AST inputs to a generic gcc.
3394 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
3395 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
3396 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
3397 << getToolChain().getTripleString();
3398 else if (II.getType() == types::TY_AST)
3399 D.Diag(clang::diag::err_drv_no_ast_support)
3400 << getToolChain().getTripleString();
3402 if (II.isFilename())
3403 CmdArgs.push_back(II.getFilename());
3405 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
3406 II.getInputArg().render(Args, CmdArgs);
3408 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3411 // Hexagon tools end.
3414 const char *darwin::CC1::getCC1Name(types::ID Type) const {
3417 llvm_unreachable("Unexpected type for Darwin CC1 tool.");
3419 case types::TY_C: case types::TY_CHeader:
3420 case types::TY_PP_C: case types::TY_PP_CHeader:
3422 case types::TY_ObjC: case types::TY_ObjCHeader:
3423 case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias:
3424 case types::TY_PP_ObjCHeader:
3426 case types::TY_CXX: case types::TY_CXXHeader:
3427 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
3429 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
3430 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias:
3431 case types::TY_PP_ObjCXXHeader:
3432 return "cc1objplus";
3436 void darwin::CC1::anchor() {}
3438 const char *darwin::CC1::getBaseInputName(const ArgList &Args,
3439 const InputInfoList &Inputs) {
3440 return Args.MakeArgString(
3441 llvm::sys::path::filename(Inputs[0].getBaseInput()));
3444 const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
3445 const InputInfoList &Inputs) {
3446 const char *Str = getBaseInputName(Args, Inputs);
3448 if (const char *End = strrchr(Str, '.'))
3449 return Args.MakeArgString(std::string(Str, End));
3455 darwin::CC1::getDependencyFileName(const ArgList &Args,
3456 const InputInfoList &Inputs) {
3457 // FIXME: Think about this more.
3460 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
3461 std::string Str(OutputOpt->getValue(Args));
3462 Res = Str.substr(0, Str.rfind('.'));
3464 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
3466 return Args.MakeArgString(Res + ".d");
3469 void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const {
3470 for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end();
3473 StringRef Option = *it;
3474 bool RemoveOption = false;
3476 // Erase both -fmodule-cache-path and its argument.
3477 if (Option.equals("-fmodule-cache-path") && it+2 != ie) {
3478 it = CmdArgs.erase(it, it+2);
3483 // Remove unsupported -f options.
3484 if (Option.startswith("-f")) {
3485 // Remove -f/-fno- to reduce the number of cases.
3486 if (Option.startswith("-fno-"))
3487 Option = Option.substr(5);
3489 Option = Option.substr(2);
3490 RemoveOption = llvm::StringSwitch<bool>(Option)
3491 .Case("altivec", true)
3492 .Case("modules", true)
3493 .Case("diagnostics-show-note-include-stack", true)
3497 // Handle machine specific options.
3498 if (Option.startswith("-m")) {
3499 RemoveOption = llvm::StringSwitch<bool>(Option)
3500 .Case("-mthumb", true)
3501 .Case("-mno-thumb", true)
3502 .Case("-mno-fused-madd", true)
3503 .Case("-mlong-branch", true)
3504 .Case("-mlongcall", true)
3505 .Case("-mcpu=G4", true)
3506 .Case("-mcpu=G5", true)
3510 // Handle warning options.
3511 if (Option.startswith("-W")) {
3512 // Remove -W/-Wno- to reduce the number of cases.
3513 if (Option.startswith("-Wno-"))
3514 Option = Option.substr(5);
3516 Option = Option.substr(2);
3518 RemoveOption = llvm::StringSwitch<bool>(Option)
3519 .Case("address-of-temporary", true)
3520 .Case("ambiguous-member-template", true)
3521 .Case("analyzer-incompatible-plugin", true)
3522 .Case("array-bounds", true)
3523 .Case("array-bounds-pointer-arithmetic", true)
3524 .Case("bind-to-temporary-copy", true)
3525 .Case("bitwise-op-parentheses", true)
3526 .Case("bool-conversions", true)
3527 .Case("builtin-macro-redefined", true)
3528 .Case("c++-hex-floats", true)
3529 .Case("c++0x-compat", true)
3530 .Case("c++0x-extensions", true)
3531 .Case("c++0x-narrowing", true)
3532 .Case("c++11-compat", true)
3533 .Case("c++11-extensions", true)
3534 .Case("c++11-narrowing", true)
3535 .Case("conditional-uninitialized", true)
3536 .Case("constant-conversion", true)
3537 .Case("conversion-null", true)
3538 .Case("CFString-literal", true)
3539 .Case("constant-logical-operand", true)
3540 .Case("custom-atomic-properties", true)
3541 .Case("default-arg-special-member", true)
3542 .Case("delegating-ctor-cycles", true)
3543 .Case("delete-non-virtual-dtor", true)
3544 .Case("deprecated-implementations", true)
3545 .Case("deprecated-writable-strings", true)
3546 .Case("distributed-object-modifiers", true)
3547 .Case("duplicate-method-arg", true)
3548 .Case("dynamic-class-memaccess", true)
3549 .Case("enum-compare", true)
3550 .Case("exit-time-destructors", true)
3552 .Case("gnu-designator", true)
3553 .Case("header-hygiene", true)
3554 .Case("idiomatic-parentheses", true)
3555 .Case("ignored-qualifiers", true)
3556 .Case("implicit-atomic-properties", true)
3557 .Case("incompatible-pointer-types", true)
3558 .Case("incomplete-implementation", true)
3559 .Case("initializer-overrides", true)
3560 .Case("invalid-noreturn", true)
3561 .Case("invalid-token-paste", true)
3562 .Case("language-extension-token", true)
3563 .Case("literal-conversion", true)
3564 .Case("literal-range", true)
3565 .Case("local-type-template-args", true)
3566 .Case("logical-op-parentheses", true)
3567 .Case("method-signatures", true)
3568 .Case("microsoft", true)
3569 .Case("mismatched-tags", true)
3570 .Case("missing-method-return-type", true)
3571 .Case("non-pod-varargs", true)
3572 .Case("nonfragile-abi2", true)
3573 .Case("null-arithmetic", true)
3574 .Case("null-dereference", true)
3575 .Case("out-of-line-declaration", true)
3576 .Case("overriding-method-mismatch", true)
3577 .Case("readonly-setter-attrs", true)
3578 .Case("return-stack-address", true)
3579 .Case("self-assign", true)
3580 .Case("semicolon-before-method-body", true)
3581 .Case("sentinel", true)
3582 .Case("shift-overflow", true)
3583 .Case("shift-sign-overflow", true)
3584 .Case("sign-conversion", true)
3585 .Case("sizeof-array-argument", true)
3586 .Case("sizeof-pointer-memaccess", true)
3587 .Case("string-compare", true)
3588 .Case("super-class-method-mismatch", true)
3589 .Case("tautological-compare", true)
3590 .Case("typedef-redefinition", true)
3591 .Case("typename-missing", true)
3592 .Case("undefined-reinterpret-cast", true)
3593 .Case("unknown-warning-option", true)
3594 .Case("unnamed-type-template-args", true)
3595 .Case("unneeded-internal-declaration", true)
3596 .Case("unneeded-member-function", true)
3597 .Case("unused-comparison", true)
3598 .Case("unused-exception-parameter", true)
3599 .Case("unused-member-function", true)
3600 .Case("unused-result", true)
3601 .Case("vector-conversions", true)
3603 .Case("used-but-marked-unused", true)
3604 .Case("weak-vtables", true)
3606 } // if (Option.startswith("-W"))
3608 it = CmdArgs.erase(it);
3616 void darwin::CC1::AddCC1Args(const ArgList &Args,
3617 ArgStringList &CmdArgs) const {
3618 const Driver &D = getToolChain().getDriver();
3620 CheckCodeGenerationOptions(D, Args);
3622 // Derived from cc1 spec.
3623 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
3624 !Args.hasArg(options::OPT_mdynamic_no_pic))
3625 CmdArgs.push_back("-fPIC");
3627 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3628 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
3629 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3630 CmdArgs.push_back("-fno-builtin-strcat");
3631 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3632 CmdArgs.push_back("-fno-builtin-strcpy");
3635 if (Args.hasArg(options::OPT_g_Flag) &&
3636 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
3637 CmdArgs.push_back("-feliminate-unused-debug-symbols");
3640 void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
3641 const InputInfoList &Inputs,
3642 const ArgStringList &OutputArgs) const {
3643 const Driver &D = getToolChain().getDriver();
3645 // Derived from cc1_options spec.
3646 if (Args.hasArg(options::OPT_fast) ||
3647 Args.hasArg(options::OPT_fastf) ||
3648 Args.hasArg(options::OPT_fastcp))
3649 CmdArgs.push_back("-O3");
3651 if (Arg *A = Args.getLastArg(options::OPT_pg))
3652 if (Args.hasArg(options::OPT_fomit_frame_pointer))
3653 D.Diag(diag::err_drv_argument_not_allowed_with)
3654 << A->getAsString(Args) << "-fomit-frame-pointer";
3656 AddCC1Args(Args, CmdArgs);
3658 if (!Args.hasArg(options::OPT_Q))
3659 CmdArgs.push_back("-quiet");
3661 CmdArgs.push_back("-dumpbase");
3662 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
3664 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
3666 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
3667 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
3669 // FIXME: The goal is to use the user provided -o if that is our
3670 // final output, otherwise to drive from the original input
3671 // name. Find a clean way to go about this.
3672 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
3673 Args.hasArg(options::OPT_o)) {
3674 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
3675 CmdArgs.push_back("-auxbase-strip");
3676 CmdArgs.push_back(OutputOpt->getValue(Args));
3678 CmdArgs.push_back("-auxbase");
3679 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
3682 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
3684 Args.AddAllArgs(CmdArgs, options::OPT_O);
3685 // FIXME: -Wall is getting some special treatment. Investigate.
3686 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
3687 Args.AddLastArg(CmdArgs, options::OPT_w);
3688 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
3689 options::OPT_trigraphs);
3690 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3691 // Honor -std-default.
3692 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3693 "-std=", /*Joined=*/true);
3696 if (Args.hasArg(options::OPT_v))
3697 CmdArgs.push_back("-version");
3698 if (Args.hasArg(options::OPT_pg) &&
3699 getToolChain().SupportsProfiling())
3700 CmdArgs.push_back("-p");
3701 Args.AddLastArg(CmdArgs, options::OPT_p);
3703 // The driver treats -fsyntax-only specially.
3704 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
3705 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
3706 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
3707 // used to inhibit the default -fno-builtin-str{cat,cpy}.
3709 // FIXME: Should we grow a better way to deal with "removing" args?
3710 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
3711 options::OPT_fsyntax_only),
3712 ie = Args.filtered_end(); it != ie; ++it) {
3713 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
3714 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
3716 (*it)->render(Args, CmdArgs);
3720 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
3722 // Claim Clang only -f options, they aren't worth warning about.
3723 Args.ClaimAllArgs(options::OPT_f_clang_Group);
3725 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3726 if (Args.hasArg(options::OPT_Qn))
3727 CmdArgs.push_back("-fno-ident");
3729 // FIXME: This isn't correct.
3730 //Args.AddLastArg(CmdArgs, options::OPT__help)
3731 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
3733 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3735 // FIXME: Still don't get what is happening here. Investigate.
3736 Args.AddAllArgs(CmdArgs, options::OPT__param);
3738 if (Args.hasArg(options::OPT_fmudflap) ||
3739 Args.hasArg(options::OPT_fmudflapth)) {
3740 CmdArgs.push_back("-fno-builtin");
3741 CmdArgs.push_back("-fno-merge-constants");
3744 if (Args.hasArg(options::OPT_coverage)) {
3745 CmdArgs.push_back("-fprofile-arcs");
3746 CmdArgs.push_back("-ftest-coverage");
3749 if (types::isCXX(Inputs[0].getType()))
3750 CmdArgs.push_back("-D__private_extern__=extern");
3753 void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
3754 const InputInfoList &Inputs,
3755 const ArgStringList &OutputArgs) const {
3756 // Derived from cpp_options
3757 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
3759 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3761 AddCC1Args(Args, CmdArgs);
3763 // NOTE: The code below has some commonality with cpp_options, but
3764 // in classic gcc style ends up sending things in different
3765 // orders. This may be a good merge candidate once we drop pedantic
3768 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
3769 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
3770 options::OPT_trigraphs);
3771 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3772 // Honor -std-default.
3773 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
3774 "-std=", /*Joined=*/true);
3776 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
3777 Args.AddLastArg(CmdArgs, options::OPT_w);
3779 // The driver treats -fsyntax-only specially.
3780 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
3782 // Claim Clang only -f options, they aren't worth warning about.
3783 Args.ClaimAllArgs(options::OPT_f_clang_Group);
3785 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
3786 !Args.hasArg(options::OPT_fno_working_directory))
3787 CmdArgs.push_back("-fworking-directory");
3789 Args.AddAllArgs(CmdArgs, options::OPT_O);
3790 Args.AddAllArgs(CmdArgs, options::OPT_undef);
3791 if (Args.hasArg(options::OPT_save_temps))
3792 CmdArgs.push_back("-fpch-preprocess");
3795 void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
3796 ArgStringList &CmdArgs,
3797 const InputInfoList &Inputs) const {
3798 const Driver &D = getToolChain().getDriver();
3800 CheckPreprocessingOptions(D, Args);
3802 // Derived from cpp_unique_options.
3803 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
3804 Args.AddLastArg(CmdArgs, options::OPT_C);
3805 Args.AddLastArg(CmdArgs, options::OPT_CC);
3806 if (!Args.hasArg(options::OPT_Q))
3807 CmdArgs.push_back("-quiet");
3808 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
3809 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
3810 Args.AddLastArg(CmdArgs, options::OPT_v);
3811 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
3812 Args.AddLastArg(CmdArgs, options::OPT_P);
3814 // FIXME: Handle %I properly.
3815 if (getToolChain().getArchName() == "x86_64") {
3816 CmdArgs.push_back("-imultilib");
3817 CmdArgs.push_back("x86_64");
3820 if (Args.hasArg(options::OPT_MD)) {
3821 CmdArgs.push_back("-MD");
3822 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
3825 if (Args.hasArg(options::OPT_MMD)) {
3826 CmdArgs.push_back("-MMD");
3827 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
3830 Args.AddLastArg(CmdArgs, options::OPT_M);
3831 Args.AddLastArg(CmdArgs, options::OPT_MM);
3832 Args.AddAllArgs(CmdArgs, options::OPT_MF);
3833 Args.AddLastArg(CmdArgs, options::OPT_MG);
3834 Args.AddLastArg(CmdArgs, options::OPT_MP);
3835 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
3836 Args.AddAllArgs(CmdArgs, options::OPT_MT);
3837 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
3838 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
3839 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
3840 CmdArgs.push_back("-MQ");
3841 CmdArgs.push_back(OutputOpt->getValue(Args));
3845 Args.AddLastArg(CmdArgs, options::OPT_remap);
3846 if (Args.hasArg(options::OPT_g3))
3847 CmdArgs.push_back("-dD");
3848 Args.AddLastArg(CmdArgs, options::OPT_H);
3850 AddCPPArgs(Args, CmdArgs);
3852 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
3853 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
3855 for (InputInfoList::const_iterator
3856 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3857 const InputInfo &II = *it;
3859 CmdArgs.push_back(II.getFilename());
3862 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
3863 options::OPT_Xpreprocessor);
3865 if (Args.hasArg(options::OPT_fmudflap)) {
3866 CmdArgs.push_back("-D_MUDFLAP");
3867 CmdArgs.push_back("-include");
3868 CmdArgs.push_back("mf-runtime.h");
3871 if (Args.hasArg(options::OPT_fmudflapth)) {
3872 CmdArgs.push_back("-D_MUDFLAP");
3873 CmdArgs.push_back("-D_MUDFLAPTH");
3874 CmdArgs.push_back("-include");
3875 CmdArgs.push_back("mf-runtime.h");
3879 void darwin::CC1::AddCPPArgs(const ArgList &Args,
3880 ArgStringList &CmdArgs) const {
3881 // Derived from cpp spec.
3883 if (Args.hasArg(options::OPT_static)) {
3884 // The gcc spec is broken here, it refers to dynamic but
3885 // that has been translated. Start by being bug compatible.
3887 // if (!Args.hasArg(arglist.parser.dynamicOption))
3888 CmdArgs.push_back("-D__STATIC__");
3890 CmdArgs.push_back("-D__DYNAMIC__");
3892 if (Args.hasArg(options::OPT_pthread))
3893 CmdArgs.push_back("-D_REENTRANT");
3896 void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
3897 const InputInfo &Output,
3898 const InputInfoList &Inputs,
3899 const ArgList &Args,
3900 const char *LinkingOutput) const {
3901 ArgStringList CmdArgs;
3903 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
3905 CmdArgs.push_back("-E");
3907 if (Args.hasArg(options::OPT_traditional) ||
3908 Args.hasArg(options::OPT_traditional_cpp))
3909 CmdArgs.push_back("-traditional-cpp");
3911 ArgStringList OutputArgs;
3912 assert(Output.isFilename() && "Unexpected CC1 output.");
3913 OutputArgs.push_back("-o");
3914 OutputArgs.push_back(Output.getFilename());
3916 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
3917 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
3919 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
3920 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3923 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
3925 RemoveCC1UnsupportedArgs(CmdArgs);
3927 const char *CC1Name = getCC1Name(Inputs[0].getType());
3929 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
3930 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3933 void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
3934 const InputInfo &Output,
3935 const InputInfoList &Inputs,
3936 const ArgList &Args,
3937 const char *LinkingOutput) const {
3938 const Driver &D = getToolChain().getDriver();
3939 ArgStringList CmdArgs;
3941 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
3943 // Silence warning about unused --serialize-diagnostics
3944 Args.ClaimAllArgs(options::OPT__serialize_diags);
3946 types::ID InputType = Inputs[0].getType();
3947 if (const Arg *A = Args.getLastArg(options::OPT_traditional))
3948 D.Diag(diag::err_drv_argument_only_allowed_with)
3949 << A->getAsString(Args) << "-E";
3951 if (JA.getType() == types::TY_LLVM_IR ||
3952 JA.getType() == types::TY_LTO_IR)
3953 CmdArgs.push_back("-emit-llvm");
3954 else if (JA.getType() == types::TY_LLVM_BC ||
3955 JA.getType() == types::TY_LTO_BC)
3956 CmdArgs.push_back("-emit-llvm-bc");
3957 else if (Output.getType() == types::TY_AST)
3958 D.Diag(diag::err_drv_no_ast_support)
3959 << getToolChain().getTripleString();
3960 else if (JA.getType() != types::TY_PP_Asm &&
3961 JA.getType() != types::TY_PCH)
3962 D.Diag(diag::err_drv_invalid_gcc_output_type)
3963 << getTypeName(JA.getType());
3965 ArgStringList OutputArgs;
3966 if (Output.getType() != types::TY_PCH) {
3967 OutputArgs.push_back("-o");
3968 if (Output.isNothing())
3969 OutputArgs.push_back("/dev/null");
3971 OutputArgs.push_back(Output.getFilename());
3974 // There is no need for this level of compatibility, but it makes
3976 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
3977 Args.hasArg(options::OPT_S));
3979 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
3980 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
3981 if (OutputArgsEarly) {
3982 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
3984 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
3985 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3988 CmdArgs.push_back("-fpreprocessed");
3990 for (InputInfoList::const_iterator
3991 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3992 const InputInfo &II = *it;
3994 // Reject AST inputs.
3995 if (II.getType() == types::TY_AST) {
3996 D.Diag(diag::err_drv_no_ast_support)
3997 << getToolChain().getTripleString();
4001 CmdArgs.push_back(II.getFilename());
4004 if (OutputArgsEarly) {
4005 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
4007 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
4008 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
4012 if (Output.getType() == types::TY_PCH) {
4013 assert(Output.isFilename() && "Invalid PCH output.");
4015 CmdArgs.push_back("-o");
4016 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
4017 // to be a good reason.
4018 const char *TmpPath = C.getArgs().MakeArgString(
4019 D.GetTemporaryPath("cc", "s"));
4020 C.addTempFile(TmpPath);
4021 CmdArgs.push_back(TmpPath);
4023 // If we're emitting a pch file with the last 4 characters of ".pth"
4024 // and falling back to llvm-gcc we want to use ".gch" instead.
4025 std::string OutputFile(Output.getFilename());
4026 size_t loc = OutputFile.rfind(".pth");
4027 if (loc != std::string::npos)
4028 OutputFile.replace(loc, 4, ".gch");
4029 const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile);
4030 CmdArgs.push_back(Tmp);
4033 RemoveCC1UnsupportedArgs(CmdArgs);
4035 const char *CC1Name = getCC1Name(Inputs[0].getType());
4037 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
4038 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4041 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4042 const InputInfo &Output,
4043 const InputInfoList &Inputs,
4044 const ArgList &Args,
4045 const char *LinkingOutput) const {
4046 ArgStringList CmdArgs;
4048 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4049 const InputInfo &Input = Inputs[0];
4051 // Determine the original source input.
4052 const Action *SourceAction = &JA;
4053 while (SourceAction->getKind() != Action::InputClass) {
4054 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4055 SourceAction = SourceAction->getInputs()[0];
4058 // Forward -g, assuming we are dealing with an actual assembly file.
4059 if (SourceAction->getType() == types::TY_Asm ||
4060 SourceAction->getType() == types::TY_PP_Asm) {
4061 if (Args.hasArg(options::OPT_gstabs))
4062 CmdArgs.push_back("--gstabs");
4063 else if (Args.hasArg(options::OPT_g_Group))
4064 CmdArgs.push_back("-g");
4067 // Derived from asm spec.
4068 AddDarwinArch(Args, CmdArgs);
4070 // Use -force_cpusubtype_ALL on x86 by default.
4071 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
4072 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
4073 Args.hasArg(options::OPT_force__cpusubtype__ALL))
4074 CmdArgs.push_back("-force_cpusubtype_ALL");
4076 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
4077 (Args.hasArg(options::OPT_mkernel) ||
4078 Args.hasArg(options::OPT_static) ||
4079 Args.hasArg(options::OPT_fapple_kext)))
4080 CmdArgs.push_back("-static");
4082 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4083 options::OPT_Xassembler);
4085 assert(Output.isFilename() && "Unexpected lipo output.");
4086 CmdArgs.push_back("-o");
4087 CmdArgs.push_back(Output.getFilename());
4089 assert(Input.isFilename() && "Invalid input.");
4090 CmdArgs.push_back(Input.getFilename());
4092 // asm_final spec is empty.
4095 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4096 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4099 void darwin::DarwinTool::anchor() {}
4101 void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4102 ArgStringList &CmdArgs) const {
4103 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4105 // Derived from darwin_arch spec.
4106 CmdArgs.push_back("-arch");
4107 CmdArgs.push_back(Args.MakeArgString(ArchName));
4109 // FIXME: Is this needed anymore?
4110 if (ArchName == "arm")
4111 CmdArgs.push_back("-force_cpusubtype_ALL");
4114 void darwin::Link::AddLinkArgs(Compilation &C,
4115 const ArgList &Args,
4116 ArgStringList &CmdArgs) const {
4117 const Driver &D = getToolChain().getDriver();
4118 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4120 unsigned Version[3] = { 0, 0, 0 };
4121 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4123 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
4124 Version[1], Version[2], HadExtra) ||
4126 D.Diag(diag::err_drv_invalid_version_number)
4127 << A->getAsString(Args);
4130 // Newer linkers support -demangle, pass it if supported and not disabled by
4132 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4133 // Don't pass -demangle to ld_classic.
4135 // FIXME: This is a temporary workaround, ld should be handling this.
4136 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4137 Args.hasArg(options::OPT_static));
4138 if (getToolChain().getArch() == llvm::Triple::x86) {
4139 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4140 options::OPT_Wl_COMMA),
4141 ie = Args.filtered_end(); it != ie; ++it) {
4143 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4144 if (StringRef(A->getValue(Args, i)) == "-kext")
4145 UsesLdClassic = true;
4149 CmdArgs.push_back("-demangle");
4152 // If we are using LTO, then automatically create a temporary file path for
4153 // the linker to use, so that it's lifetime will extend past a possible
4155 if (Version[0] >= 116 && D.IsUsingLTO(Args)) {
4156 const char *TmpPath = C.getArgs().MakeArgString(
4157 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4158 C.addTempFile(TmpPath);
4159 CmdArgs.push_back("-object_path_lto");
4160 CmdArgs.push_back(TmpPath);
4163 // Derived from the "link" spec.
4164 Args.AddAllArgs(CmdArgs, options::OPT_static);
4165 if (!Args.hasArg(options::OPT_static))
4166 CmdArgs.push_back("-dynamic");
4167 if (Args.hasArg(options::OPT_fgnu_runtime)) {
4168 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4169 // here. How do we wish to handle such things?
4172 if (!Args.hasArg(options::OPT_dynamiclib)) {
4173 AddDarwinArch(Args, CmdArgs);
4174 // FIXME: Why do this only on this path?
4175 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4177 Args.AddLastArg(CmdArgs, options::OPT_bundle);
4178 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4179 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4182 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4183 (A = Args.getLastArg(options::OPT_current__version)) ||
4184 (A = Args.getLastArg(options::OPT_install__name)))
4185 D.Diag(diag::err_drv_argument_only_allowed_with)
4186 << A->getAsString(Args) << "-dynamiclib";
4188 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4189 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4190 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4192 CmdArgs.push_back("-dylib");
4195 if ((A = Args.getLastArg(options::OPT_bundle)) ||
4196 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4197 (A = Args.getLastArg(options::OPT_client__name)) ||
4198 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4199 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4200 (A = Args.getLastArg(options::OPT_private__bundle)))
4201 D.Diag(diag::err_drv_argument_not_allowed_with)
4202 << A->getAsString(Args) << "-dynamiclib";
4204 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4205 "-dylib_compatibility_version");
4206 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4207 "-dylib_current_version");
4209 AddDarwinArch(Args, CmdArgs);
4211 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4212 "-dylib_install_name");
4215 Args.AddLastArg(CmdArgs, options::OPT_all__load);
4216 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4217 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4218 if (DarwinTC.isTargetIPhoneOS())
4219 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4220 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4221 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4222 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4223 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4224 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4225 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4226 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4227 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4228 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4229 Args.AddAllArgs(CmdArgs, options::OPT_init);
4231 // Add the deployment target.
4232 VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4234 // If we had an explicit -mios-simulator-version-min argument, honor that,
4235 // otherwise use the traditional deployment targets. We can't just check the
4236 // is-sim attribute because existing code follows this path, and the linker
4237 // may not handle the argument.
4239 // FIXME: We may be able to remove this, once we can verify no one depends on
4241 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4242 CmdArgs.push_back("-ios_simulator_version_min");
4243 else if (DarwinTC.isTargetIPhoneOS())
4244 CmdArgs.push_back("-iphoneos_version_min");
4246 CmdArgs.push_back("-macosx_version_min");
4247 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4249 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4250 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4251 Args.AddLastArg(CmdArgs, options::OPT_single__module);
4252 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4253 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4255 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4256 options::OPT_fno_pie,
4257 options::OPT_fno_PIE)) {
4258 if (A->getOption().matches(options::OPT_fpie) ||
4259 A->getOption().matches(options::OPT_fPIE))
4260 CmdArgs.push_back("-pie");
4262 CmdArgs.push_back("-no_pie");
4265 Args.AddLastArg(CmdArgs, options::OPT_prebind);
4266 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4267 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4268 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4269 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4270 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4271 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4272 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4273 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4274 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4275 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4276 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4277 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4278 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4279 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4280 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4282 // Give --sysroot= preference, over the Apple specific behavior to also use
4283 // --isysroot as the syslibroot.
4284 StringRef sysroot = C.getSysRoot();
4285 if (sysroot != "") {
4286 CmdArgs.push_back("-syslibroot");
4287 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4288 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4289 CmdArgs.push_back("-syslibroot");
4290 CmdArgs.push_back(A->getValue(Args));
4293 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4294 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4295 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4296 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4297 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4298 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4299 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4300 Args.AddAllArgs(CmdArgs, options::OPT_y);
4301 Args.AddLastArg(CmdArgs, options::OPT_w);
4302 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4303 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4304 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4305 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4306 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4307 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4308 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4309 Args.AddLastArg(CmdArgs, options::OPT_whyload);
4310 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4311 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4312 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4313 Args.AddLastArg(CmdArgs, options::OPT_Mach);
4316 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4317 const InputInfo &Output,
4318 const InputInfoList &Inputs,
4319 const ArgList &Args,
4320 const char *LinkingOutput) const {
4321 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4323 // The logic here is derived from gcc's behavior; most of which
4324 // comes from specs (starting with link_command). Consult gcc for
4325 // more information.
4326 ArgStringList CmdArgs;
4328 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4329 if (Args.hasArg(options::OPT_ccc_arcmt_check,
4330 options::OPT_ccc_arcmt_migrate)) {
4331 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4334 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4335 CmdArgs.push_back(Output.getFilename());
4336 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4340 // I'm not sure why this particular decomposition exists in gcc, but
4341 // we follow suite for ease of comparison.
4342 AddLinkArgs(C, Args, CmdArgs);
4344 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4345 Args.AddAllArgs(CmdArgs, options::OPT_s);
4346 Args.AddAllArgs(CmdArgs, options::OPT_t);
4347 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4348 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4349 Args.AddLastArg(CmdArgs, options::OPT_e);
4350 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
4351 Args.AddAllArgs(CmdArgs, options::OPT_r);
4353 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4354 // members of static archive libraries which implement Objective-C classes or
4356 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4357 CmdArgs.push_back("-ObjC");
4359 CmdArgs.push_back("-o");
4360 CmdArgs.push_back(Output.getFilename());
4362 if (!Args.hasArg(options::OPT_nostdlib) &&
4363 !Args.hasArg(options::OPT_nostartfiles)) {
4364 // Derived from startfile spec.
4365 if (Args.hasArg(options::OPT_dynamiclib)) {
4366 // Derived from darwin_dylib1 spec.
4367 if (getDarwinToolChain().isTargetIOSSimulator()) {
4368 // The simulator doesn't have a versioned crt1 file.
4369 CmdArgs.push_back("-ldylib1.o");
4370 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4371 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4372 CmdArgs.push_back("-ldylib1.o");
4374 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4375 CmdArgs.push_back("-ldylib1.o");
4376 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4377 CmdArgs.push_back("-ldylib1.10.5.o");
4380 if (Args.hasArg(options::OPT_bundle)) {
4381 if (!Args.hasArg(options::OPT_static)) {
4382 // Derived from darwin_bundle1 spec.
4383 if (getDarwinToolChain().isTargetIOSSimulator()) {
4384 // The simulator doesn't have a versioned crt1 file.
4385 CmdArgs.push_back("-lbundle1.o");
4386 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4387 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4388 CmdArgs.push_back("-lbundle1.o");
4390 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4391 CmdArgs.push_back("-lbundle1.o");
4395 if (Args.hasArg(options::OPT_pg) &&
4396 getToolChain().SupportsProfiling()) {
4397 if (Args.hasArg(options::OPT_static) ||
4398 Args.hasArg(options::OPT_object) ||
4399 Args.hasArg(options::OPT_preload)) {
4400 CmdArgs.push_back("-lgcrt0.o");
4402 CmdArgs.push_back("-lgcrt1.o");
4404 // darwin_crt2 spec is empty.
4406 // By default on OS X 10.8 and later, we don't link with a crt1.o
4407 // file and the linker knows to use _main as the entry point. But,
4408 // when compiling with -pg, we need to link with the gcrt1.o file,
4409 // so pass the -no_new_main option to tell the linker to use the
4410 // "start" symbol as the entry point.
4411 if (getDarwinToolChain().isTargetMacOS() &&
4412 !getDarwinToolChain().isMacosxVersionLT(10, 8))
4413 CmdArgs.push_back("-no_new_main");
4415 if (Args.hasArg(options::OPT_static) ||
4416 Args.hasArg(options::OPT_object) ||
4417 Args.hasArg(options::OPT_preload)) {
4418 CmdArgs.push_back("-lcrt0.o");
4420 // Derived from darwin_crt1 spec.
4421 if (getDarwinToolChain().isTargetIOSSimulator()) {
4422 // The simulator doesn't have a versioned crt1 file.
4423 CmdArgs.push_back("-lcrt1.o");
4424 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4425 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4426 CmdArgs.push_back("-lcrt1.o");
4428 CmdArgs.push_back("-lcrt1.3.1.o");
4430 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4431 CmdArgs.push_back("-lcrt1.o");
4432 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4433 CmdArgs.push_back("-lcrt1.10.5.o");
4434 else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
4435 CmdArgs.push_back("-lcrt1.10.6.o");
4437 // darwin_crt2 spec is empty.
4444 if (!getDarwinToolChain().isTargetIPhoneOS() &&
4445 Args.hasArg(options::OPT_shared_libgcc) &&
4446 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
4448 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
4449 CmdArgs.push_back(Str);
4453 Args.AddAllArgs(CmdArgs, options::OPT_L);
4455 // If we're building a dynamic lib with -faddress-sanitizer, unresolved
4456 // symbols may appear. Mark all of them as dynamic_lookup.
4457 // Linking executables is handled in lib/Driver/ToolChains.cpp.
4458 if (Args.hasFlag(options::OPT_faddress_sanitizer,
4459 options::OPT_fno_address_sanitizer, false)) {
4460 if (Args.hasArg(options::OPT_dynamiclib) ||
4461 Args.hasArg(options::OPT_bundle)) {
4462 CmdArgs.push_back("-undefined");
4463 CmdArgs.push_back("dynamic_lookup");
4467 if (Args.hasArg(options::OPT_fopenmp))
4468 // This is more complicated in gcc...
4469 CmdArgs.push_back("-lgomp");
4471 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4473 if (isObjCRuntimeLinked(Args) &&
4474 !Args.hasArg(options::OPT_nostdlib) &&
4475 !Args.hasArg(options::OPT_nodefaultlibs)) {
4476 // Avoid linking compatibility stubs on i386 mac.
4477 if (!getDarwinToolChain().isTargetMacOS() ||
4478 getDarwinToolChain().getArchName() != "i386") {
4479 // If we don't have ARC or subscripting runtime support, link in the
4480 // runtime stubs. We have to do this *before* adding any of the normal
4481 // linker inputs so that its initializer gets run first.
4482 ObjCRuntime runtime =
4483 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
4484 // We use arclite library for both ARC and subscripting support.
4485 if ((!runtime.hasARC() && isObjCAutoRefCount(Args)) ||
4486 !runtime.hasSubscripting())
4487 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
4489 CmdArgs.push_back("-framework");
4490 CmdArgs.push_back("Foundation");
4492 CmdArgs.push_back("-lobjc");
4495 if (LinkingOutput) {
4496 CmdArgs.push_back("-arch_multiple");
4497 CmdArgs.push_back("-final_output");
4498 CmdArgs.push_back(LinkingOutput);
4501 if (Args.hasArg(options::OPT_fnested_functions))
4502 CmdArgs.push_back("-allow_stack_execute");
4504 if (!Args.hasArg(options::OPT_nostdlib) &&
4505 !Args.hasArg(options::OPT_nodefaultlibs)) {
4506 if (getToolChain().getDriver().CCCIsCXX)
4507 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4509 // link_ssp spec is empty.
4511 // Let the tool chain choose which runtime library to link.
4512 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
4515 if (!Args.hasArg(options::OPT_nostdlib) &&
4516 !Args.hasArg(options::OPT_nostartfiles)) {
4517 // endfile_spec is empty.
4520 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4521 Args.AddAllArgs(CmdArgs, options::OPT_F);
4524 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4525 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4528 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
4529 const InputInfo &Output,
4530 const InputInfoList &Inputs,
4531 const ArgList &Args,
4532 const char *LinkingOutput) const {
4533 ArgStringList CmdArgs;
4535 CmdArgs.push_back("-create");
4536 assert(Output.isFilename() && "Unexpected lipo output.");
4538 CmdArgs.push_back("-output");
4539 CmdArgs.push_back(Output.getFilename());
4541 for (InputInfoList::const_iterator
4542 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4543 const InputInfo &II = *it;
4544 assert(II.isFilename() && "Unexpected lipo input.");
4545 CmdArgs.push_back(II.getFilename());
4548 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
4549 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4552 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
4553 const InputInfo &Output,
4554 const InputInfoList &Inputs,
4555 const ArgList &Args,
4556 const char *LinkingOutput) const {
4557 ArgStringList CmdArgs;
4559 CmdArgs.push_back("-o");
4560 CmdArgs.push_back(Output.getFilename());
4562 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4563 const InputInfo &Input = Inputs[0];
4564 assert(Input.isFilename() && "Unexpected dsymutil input.");
4565 CmdArgs.push_back(Input.getFilename());
4568 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
4569 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4572 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
4573 const InputInfo &Output,
4574 const InputInfoList &Inputs,
4575 const ArgList &Args,
4576 const char *LinkingOutput) const {
4577 ArgStringList CmdArgs;
4578 CmdArgs.push_back("--verify");
4579 CmdArgs.push_back("--debug-info");
4580 CmdArgs.push_back("--eh-frame");
4581 CmdArgs.push_back("--quiet");
4583 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
4584 const InputInfo &Input = Inputs[0];
4585 assert(Input.isFilename() && "Unexpected verify input");
4587 // Grabbing the output of the earlier dsymutil run.
4588 CmdArgs.push_back(Input.getFilename());
4591 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
4592 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4595 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4596 const InputInfo &Output,
4597 const InputInfoList &Inputs,
4598 const ArgList &Args,
4599 const char *LinkingOutput) const {
4600 ArgStringList CmdArgs;
4602 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4603 options::OPT_Xassembler);
4605 CmdArgs.push_back("-o");
4606 CmdArgs.push_back(Output.getFilename());
4608 for (InputInfoList::const_iterator
4609 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4610 const InputInfo &II = *it;
4611 CmdArgs.push_back(II.getFilename());
4615 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4616 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4620 void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
4621 const InputInfo &Output,
4622 const InputInfoList &Inputs,
4623 const ArgList &Args,
4624 const char *LinkingOutput) const {
4625 // FIXME: Find a real GCC, don't hard-code versions here
4626 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
4627 const llvm::Triple &T = getToolChain().getTriple();
4628 std::string LibPath = "/usr/lib/";
4629 llvm::Triple::ArchType Arch = T.getArch();
4631 case llvm::Triple::x86:
4632 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4633 T.getOSName()).str() + "/4.5.2/";
4635 case llvm::Triple::x86_64:
4636 GCCLibPath += ("i386-" + T.getVendorName() + "-" +
4637 T.getOSName()).str();
4638 GCCLibPath += "/4.5.2/amd64/";
4639 LibPath += "amd64/";
4642 assert(0 && "Unsupported architecture");
4645 ArgStringList CmdArgs;
4647 // Demangle C++ names in errors
4648 CmdArgs.push_back("-C");
4650 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4651 (!Args.hasArg(options::OPT_shared))) {
4652 CmdArgs.push_back("-e");
4653 CmdArgs.push_back("_start");
4656 if (Args.hasArg(options::OPT_static)) {
4657 CmdArgs.push_back("-Bstatic");
4658 CmdArgs.push_back("-dn");
4660 CmdArgs.push_back("-Bdynamic");
4661 if (Args.hasArg(options::OPT_shared)) {
4662 CmdArgs.push_back("-shared");
4664 CmdArgs.push_back("--dynamic-linker");
4665 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
4669 if (Output.isFilename()) {
4670 CmdArgs.push_back("-o");
4671 CmdArgs.push_back(Output.getFilename());
4673 assert(Output.isNothing() && "Invalid output.");
4676 if (!Args.hasArg(options::OPT_nostdlib) &&
4677 !Args.hasArg(options::OPT_nostartfiles)) {
4678 if (!Args.hasArg(options::OPT_shared)) {
4679 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
4680 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
4681 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4682 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4684 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
4685 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
4686 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
4688 if (getToolChain().getDriver().CCCIsCXX)
4689 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
4692 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
4694 Args.AddAllArgs(CmdArgs, options::OPT_L);
4695 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4696 Args.AddAllArgs(CmdArgs, options::OPT_e);
4697 Args.AddAllArgs(CmdArgs, options::OPT_r);
4699 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4701 if (!Args.hasArg(options::OPT_nostdlib) &&
4702 !Args.hasArg(options::OPT_nodefaultlibs)) {
4703 if (getToolChain().getDriver().CCCIsCXX)
4704 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4705 CmdArgs.push_back("-lgcc_s");
4706 if (!Args.hasArg(options::OPT_shared)) {
4707 CmdArgs.push_back("-lgcc");
4708 CmdArgs.push_back("-lc");
4709 CmdArgs.push_back("-lm");
4713 if (!Args.hasArg(options::OPT_nostdlib) &&
4714 !Args.hasArg(options::OPT_nostartfiles)) {
4715 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
4717 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
4719 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4722 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4723 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4726 void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4727 const InputInfo &Output,
4728 const InputInfoList &Inputs,
4729 const ArgList &Args,
4730 const char *LinkingOutput) const {
4731 ArgStringList CmdArgs;
4733 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4734 options::OPT_Xassembler);
4736 CmdArgs.push_back("-o");
4737 CmdArgs.push_back(Output.getFilename());
4739 for (InputInfoList::const_iterator
4740 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4741 const InputInfo &II = *it;
4742 CmdArgs.push_back(II.getFilename());
4746 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
4747 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4750 void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
4751 const InputInfo &Output,
4752 const InputInfoList &Inputs,
4753 const ArgList &Args,
4754 const char *LinkingOutput) const {
4755 ArgStringList CmdArgs;
4757 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4758 (!Args.hasArg(options::OPT_shared))) {
4759 CmdArgs.push_back("-e");
4760 CmdArgs.push_back("_start");
4763 if (Args.hasArg(options::OPT_static)) {
4764 CmdArgs.push_back("-Bstatic");
4765 CmdArgs.push_back("-dn");
4767 // CmdArgs.push_back("--eh-frame-hdr");
4768 CmdArgs.push_back("-Bdynamic");
4769 if (Args.hasArg(options::OPT_shared)) {
4770 CmdArgs.push_back("-shared");
4772 CmdArgs.push_back("--dynamic-linker");
4773 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
4777 if (Output.isFilename()) {
4778 CmdArgs.push_back("-o");
4779 CmdArgs.push_back(Output.getFilename());
4781 assert(Output.isNothing() && "Invalid output.");
4784 if (!Args.hasArg(options::OPT_nostdlib) &&
4785 !Args.hasArg(options::OPT_nostartfiles)) {
4786 if (!Args.hasArg(options::OPT_shared)) {
4787 CmdArgs.push_back(Args.MakeArgString(
4788 getToolChain().GetFilePath("crt1.o")));
4789 CmdArgs.push_back(Args.MakeArgString(
4790 getToolChain().GetFilePath("crti.o")));
4791 CmdArgs.push_back(Args.MakeArgString(
4792 getToolChain().GetFilePath("crtbegin.o")));
4794 CmdArgs.push_back(Args.MakeArgString(
4795 getToolChain().GetFilePath("crti.o")));
4797 CmdArgs.push_back(Args.MakeArgString(
4798 getToolChain().GetFilePath("crtn.o")));
4801 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
4802 + getToolChain().getTripleString()
4805 Args.AddAllArgs(CmdArgs, options::OPT_L);
4806 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4807 Args.AddAllArgs(CmdArgs, options::OPT_e);
4809 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4811 if (!Args.hasArg(options::OPT_nostdlib) &&
4812 !Args.hasArg(options::OPT_nodefaultlibs)) {
4813 // FIXME: For some reason GCC passes -lgcc before adding
4814 // the default system libraries. Just mimic this for now.
4815 CmdArgs.push_back("-lgcc");
4817 if (Args.hasArg(options::OPT_pthread))
4818 CmdArgs.push_back("-pthread");
4819 if (!Args.hasArg(options::OPT_shared))
4820 CmdArgs.push_back("-lc");
4821 CmdArgs.push_back("-lgcc");
4824 if (!Args.hasArg(options::OPT_nostdlib) &&
4825 !Args.hasArg(options::OPT_nostartfiles)) {
4826 if (!Args.hasArg(options::OPT_shared))
4827 CmdArgs.push_back(Args.MakeArgString(
4828 getToolChain().GetFilePath("crtend.o")));
4831 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4834 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4835 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4838 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4839 const InputInfo &Output,
4840 const InputInfoList &Inputs,
4841 const ArgList &Args,
4842 const char *LinkingOutput) const {
4843 ArgStringList CmdArgs;
4845 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4846 options::OPT_Xassembler);
4848 CmdArgs.push_back("-o");
4849 CmdArgs.push_back(Output.getFilename());
4851 for (InputInfoList::const_iterator
4852 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4853 const InputInfo &II = *it;
4854 CmdArgs.push_back(II.getFilename());
4858 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4859 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4862 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
4863 const InputInfo &Output,
4864 const InputInfoList &Inputs,
4865 const ArgList &Args,
4866 const char *LinkingOutput) const {
4867 const Driver &D = getToolChain().getDriver();
4868 ArgStringList CmdArgs;
4870 if ((!Args.hasArg(options::OPT_nostdlib)) &&
4871 (!Args.hasArg(options::OPT_shared))) {
4872 CmdArgs.push_back("-e");
4873 CmdArgs.push_back("__start");
4876 if (Args.hasArg(options::OPT_static)) {
4877 CmdArgs.push_back("-Bstatic");
4879 if (Args.hasArg(options::OPT_rdynamic))
4880 CmdArgs.push_back("-export-dynamic");
4881 CmdArgs.push_back("--eh-frame-hdr");
4882 CmdArgs.push_back("-Bdynamic");
4883 if (Args.hasArg(options::OPT_shared)) {
4884 CmdArgs.push_back("-shared");
4886 CmdArgs.push_back("-dynamic-linker");
4887 CmdArgs.push_back("/usr/libexec/ld.so");
4891 if (Output.isFilename()) {
4892 CmdArgs.push_back("-o");
4893 CmdArgs.push_back(Output.getFilename());
4895 assert(Output.isNothing() && "Invalid output.");
4898 if (!Args.hasArg(options::OPT_nostdlib) &&
4899 !Args.hasArg(options::OPT_nostartfiles)) {
4900 if (!Args.hasArg(options::OPT_shared)) {
4901 if (Args.hasArg(options::OPT_pg))
4902 CmdArgs.push_back(Args.MakeArgString(
4903 getToolChain().GetFilePath("gcrt0.o")));
4905 CmdArgs.push_back(Args.MakeArgString(
4906 getToolChain().GetFilePath("crt0.o")));
4907 CmdArgs.push_back(Args.MakeArgString(
4908 getToolChain().GetFilePath("crtbegin.o")));
4910 CmdArgs.push_back(Args.MakeArgString(
4911 getToolChain().GetFilePath("crtbeginS.o")));
4915 std::string Triple = getToolChain().getTripleString();
4916 if (Triple.substr(0, 6) == "x86_64")
4917 Triple.replace(0, 6, "amd64");
4918 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
4921 Args.AddAllArgs(CmdArgs, options::OPT_L);
4922 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4923 Args.AddAllArgs(CmdArgs, options::OPT_e);
4925 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4927 if (!Args.hasArg(options::OPT_nostdlib) &&
4928 !Args.hasArg(options::OPT_nodefaultlibs)) {
4930 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4931 if (Args.hasArg(options::OPT_pg))
4932 CmdArgs.push_back("-lm_p");
4934 CmdArgs.push_back("-lm");
4937 // FIXME: For some reason GCC passes -lgcc before adding
4938 // the default system libraries. Just mimic this for now.
4939 CmdArgs.push_back("-lgcc");
4941 if (Args.hasArg(options::OPT_pthread))
4942 CmdArgs.push_back("-lpthread");
4943 if (!Args.hasArg(options::OPT_shared)) {
4944 if (Args.hasArg(options::OPT_pg))
4945 CmdArgs.push_back("-lc_p");
4947 CmdArgs.push_back("-lc");
4949 CmdArgs.push_back("-lgcc");
4952 if (!Args.hasArg(options::OPT_nostdlib) &&
4953 !Args.hasArg(options::OPT_nostartfiles)) {
4954 if (!Args.hasArg(options::OPT_shared))
4955 CmdArgs.push_back(Args.MakeArgString(
4956 getToolChain().GetFilePath("crtend.o")));
4958 CmdArgs.push_back(Args.MakeArgString(
4959 getToolChain().GetFilePath("crtendS.o")));
4963 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4964 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4967 void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4968 const InputInfo &Output,
4969 const InputInfoList &Inputs,
4970 const ArgList &Args,
4971 const char *LinkingOutput) const {
4972 ArgStringList CmdArgs;
4974 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4975 options::OPT_Xassembler);
4977 CmdArgs.push_back("-o");
4978 CmdArgs.push_back(Output.getFilename());
4980 for (InputInfoList::const_iterator
4981 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4982 const InputInfo &II = *it;
4983 CmdArgs.push_back(II.getFilename());
4987 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4988 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4991 void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
4992 const InputInfo &Output,
4993 const InputInfoList &Inputs,
4994 const ArgList &Args,
4995 const char *LinkingOutput) const {
4996 const Driver &D = getToolChain().getDriver();
4997 ArgStringList CmdArgs;
4999 if ((!Args.hasArg(options::OPT_nostdlib)) &&
5000 (!Args.hasArg(options::OPT_shared))) {
5001 CmdArgs.push_back("-e");
5002 CmdArgs.push_back("__start");
5005 if (Args.hasArg(options::OPT_static)) {
5006 CmdArgs.push_back("-Bstatic");
5008 if (Args.hasArg(options::OPT_rdynamic))
5009 CmdArgs.push_back("-export-dynamic");
5010 CmdArgs.push_back("--eh-frame-hdr");
5011 CmdArgs.push_back("-Bdynamic");
5012 if (Args.hasArg(options::OPT_shared)) {
5013 CmdArgs.push_back("-shared");
5015 CmdArgs.push_back("-dynamic-linker");
5016 CmdArgs.push_back("/usr/libexec/ld.so");
5020 if (Output.isFilename()) {
5021 CmdArgs.push_back("-o");
5022 CmdArgs.push_back(Output.getFilename());
5024 assert(Output.isNothing() && "Invalid output.");
5027 if (!Args.hasArg(options::OPT_nostdlib) &&
5028 !Args.hasArg(options::OPT_nostartfiles)) {
5029 if (!Args.hasArg(options::OPT_shared)) {
5030 if (Args.hasArg(options::OPT_pg))
5031 CmdArgs.push_back(Args.MakeArgString(
5032 getToolChain().GetFilePath("gcrt0.o")));
5034 CmdArgs.push_back(Args.MakeArgString(
5035 getToolChain().GetFilePath("crt0.o")));
5036 CmdArgs.push_back(Args.MakeArgString(
5037 getToolChain().GetFilePath("crtbegin.o")));
5039 CmdArgs.push_back(Args.MakeArgString(
5040 getToolChain().GetFilePath("crtbeginS.o")));
5044 Args.AddAllArgs(CmdArgs, options::OPT_L);
5045 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5046 Args.AddAllArgs(CmdArgs, options::OPT_e);
5048 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5050 if (!Args.hasArg(options::OPT_nostdlib) &&
5051 !Args.hasArg(options::OPT_nodefaultlibs)) {
5053 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5054 if (Args.hasArg(options::OPT_pg))
5055 CmdArgs.push_back("-lm_p");
5057 CmdArgs.push_back("-lm");
5060 if (Args.hasArg(options::OPT_pthread))
5061 CmdArgs.push_back("-lpthread");
5062 if (!Args.hasArg(options::OPT_shared)) {
5063 if (Args.hasArg(options::OPT_pg))
5064 CmdArgs.push_back("-lc_p");
5066 CmdArgs.push_back("-lc");
5069 std::string myarch = "-lclang_rt.";
5070 const llvm::Triple &T = getToolChain().getTriple();
5071 llvm::Triple::ArchType Arch = T.getArch();
5073 case llvm::Triple::arm:
5076 case llvm::Triple::x86:
5079 case llvm::Triple::x86_64:
5080 myarch += ("amd64");
5083 assert(0 && "Unsupported architecture");
5085 CmdArgs.push_back(Args.MakeArgString(myarch));
5088 if (!Args.hasArg(options::OPT_nostdlib) &&
5089 !Args.hasArg(options::OPT_nostartfiles)) {
5090 if (!Args.hasArg(options::OPT_shared))
5091 CmdArgs.push_back(Args.MakeArgString(
5092 getToolChain().GetFilePath("crtend.o")));
5094 CmdArgs.push_back(Args.MakeArgString(
5095 getToolChain().GetFilePath("crtendS.o")));
5099 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5100 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5103 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5104 const InputInfo &Output,
5105 const InputInfoList &Inputs,
5106 const ArgList &Args,
5107 const char *LinkingOutput) const {
5108 ArgStringList CmdArgs;
5110 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5111 // instruct as in the base system to assemble 32-bit code.
5112 if (getToolChain().getArchName() == "i386")
5113 CmdArgs.push_back("--32");
5115 if (getToolChain().getArchName() == "powerpc")
5116 CmdArgs.push_back("-a32");
5118 // Set byte order explicitly
5119 if (getToolChain().getArchName() == "mips")
5120 CmdArgs.push_back("-EB");
5121 else if (getToolChain().getArchName() == "mipsel")
5122 CmdArgs.push_back("-EL");
5124 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5125 options::OPT_Xassembler);
5127 CmdArgs.push_back("-o");
5128 CmdArgs.push_back(Output.getFilename());
5130 for (InputInfoList::const_iterator
5131 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5132 const InputInfo &II = *it;
5133 CmdArgs.push_back(II.getFilename());
5137 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5138 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5141 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5142 const InputInfo &Output,
5143 const InputInfoList &Inputs,
5144 const ArgList &Args,
5145 const char *LinkingOutput) const {
5146 const Driver &D = getToolChain().getDriver();
5147 ArgStringList CmdArgs;
5149 // Silence warning for "clang -g foo.o -o foo"
5150 Args.ClaimAllArgs(options::OPT_g_Group);
5151 // and "clang -emit-llvm foo.o -o foo"
5152 Args.ClaimAllArgs(options::OPT_emit_llvm);
5153 // and for "clang -w foo.o -o foo". Other warning options are already
5154 // handled somewhere else.
5155 Args.ClaimAllArgs(options::OPT_w);
5157 if (!D.SysRoot.empty())
5158 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5160 if (Args.hasArg(options::OPT_static)) {
5161 CmdArgs.push_back("-Bstatic");
5163 if (Args.hasArg(options::OPT_rdynamic))
5164 CmdArgs.push_back("-export-dynamic");
5165 CmdArgs.push_back("--eh-frame-hdr");
5166 if (Args.hasArg(options::OPT_shared)) {
5167 CmdArgs.push_back("-Bshareable");
5169 CmdArgs.push_back("-dynamic-linker");
5170 CmdArgs.push_back("/libexec/ld-elf.so.1");
5172 if (getToolChain().getTriple().getOSMajorVersion() >= 9) {
5173 llvm::Triple::ArchType Arch = getToolChain().getArch();
5174 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5175 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5176 CmdArgs.push_back("--hash-style=both");
5179 CmdArgs.push_back("--enable-new-dtags");
5182 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5183 // instruct ld in the base system to link 32-bit code.
5184 if (getToolChain().getArchName() == "i386") {
5185 CmdArgs.push_back("-m");
5186 CmdArgs.push_back("elf_i386_fbsd");
5189 if (getToolChain().getArchName() == "powerpc") {
5190 CmdArgs.push_back("-m");
5191 CmdArgs.push_back("elf32ppc_fbsd");
5194 if (Output.isFilename()) {
5195 CmdArgs.push_back("-o");
5196 CmdArgs.push_back(Output.getFilename());
5198 assert(Output.isNothing() && "Invalid output.");
5201 if (!Args.hasArg(options::OPT_nostdlib) &&
5202 !Args.hasArg(options::OPT_nostartfiles)) {
5203 if (!Args.hasArg(options::OPT_shared)) {
5204 if (Args.hasArg(options::OPT_pg))
5205 CmdArgs.push_back(Args.MakeArgString(
5206 getToolChain().GetFilePath("gcrt1.o")));
5208 const char *crt = Args.hasArg(options::OPT_pie) ? "Scrt1.o" : "crt1.o";
5209 CmdArgs.push_back(Args.MakeArgString(
5210 getToolChain().GetFilePath(crt)));
5212 CmdArgs.push_back(Args.MakeArgString(
5213 getToolChain().GetFilePath("crti.o")));
5214 CmdArgs.push_back(Args.MakeArgString(
5215 getToolChain().GetFilePath("crtbegin.o")));
5217 CmdArgs.push_back(Args.MakeArgString(
5218 getToolChain().GetFilePath("crti.o")));
5219 CmdArgs.push_back(Args.MakeArgString(
5220 getToolChain().GetFilePath("crtbeginS.o")));
5224 Args.AddAllArgs(CmdArgs, options::OPT_L);
5225 const ToolChain::path_list Paths = getToolChain().getFilePaths();
5226 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5228 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5229 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5230 Args.AddAllArgs(CmdArgs, options::OPT_e);
5231 Args.AddAllArgs(CmdArgs, options::OPT_s);
5232 Args.AddAllArgs(CmdArgs, options::OPT_t);
5233 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5234 Args.AddAllArgs(CmdArgs, options::OPT_r);
5236 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5238 if (!Args.hasArg(options::OPT_nostdlib) &&
5239 !Args.hasArg(options::OPT_nodefaultlibs)) {
5241 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5242 if (Args.hasArg(options::OPT_pg))
5243 CmdArgs.push_back("-lm_p");
5245 CmdArgs.push_back("-lm");
5247 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5248 // the default system libraries. Just mimic this for now.
5249 if (Args.hasArg(options::OPT_pg))
5250 CmdArgs.push_back("-lgcc_p");
5252 CmdArgs.push_back("-lgcc");
5253 if (Args.hasArg(options::OPT_static)) {
5254 CmdArgs.push_back("-lgcc_eh");
5255 } else if (Args.hasArg(options::OPT_pg)) {
5256 CmdArgs.push_back("-lgcc_eh_p");
5258 CmdArgs.push_back("--as-needed");
5259 CmdArgs.push_back("-lgcc_s");
5260 CmdArgs.push_back("--no-as-needed");
5263 if (Args.hasArg(options::OPT_pthread)) {
5264 if (Args.hasArg(options::OPT_pg))
5265 CmdArgs.push_back("-lpthread_p");
5267 CmdArgs.push_back("-lpthread");
5270 if (Args.hasArg(options::OPT_pg)) {
5271 if (Args.hasArg(options::OPT_shared))
5272 CmdArgs.push_back("-lc");
5274 CmdArgs.push_back("-lc_p");
5275 CmdArgs.push_back("-lgcc_p");
5277 CmdArgs.push_back("-lc");
5278 CmdArgs.push_back("-lgcc");
5281 if (Args.hasArg(options::OPT_static)) {
5282 CmdArgs.push_back("-lgcc_eh");
5283 } else if (Args.hasArg(options::OPT_pg)) {
5284 CmdArgs.push_back("-lgcc_eh_p");
5286 CmdArgs.push_back("--as-needed");
5287 CmdArgs.push_back("-lgcc_s");
5288 CmdArgs.push_back("--no-as-needed");
5292 if (!Args.hasArg(options::OPT_nostdlib) &&
5293 !Args.hasArg(options::OPT_nostartfiles)) {
5294 if (!Args.hasArg(options::OPT_shared))
5295 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5298 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5300 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5304 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5307 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5308 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5311 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5312 const InputInfo &Output,
5313 const InputInfoList &Inputs,
5314 const ArgList &Args,
5315 const char *LinkingOutput) const {
5316 ArgStringList CmdArgs;
5318 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5319 // instruct as in the base system to assemble 32-bit code.
5320 if (getToolChain().getArch() == llvm::Triple::x86)
5321 CmdArgs.push_back("--32");
5323 // Set byte order explicitly
5324 if (getToolChain().getArchName() == "mips")
5325 CmdArgs.push_back("-EB");
5326 else if (getToolChain().getArchName() == "mipsel")
5327 CmdArgs.push_back("-EL");
5329 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5330 options::OPT_Xassembler);
5332 CmdArgs.push_back("-o");
5333 CmdArgs.push_back(Output.getFilename());
5335 for (InputInfoList::const_iterator
5336 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5337 const InputInfo &II = *it;
5338 CmdArgs.push_back(II.getFilename());
5341 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
5342 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5345 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5346 const InputInfo &Output,
5347 const InputInfoList &Inputs,
5348 const ArgList &Args,
5349 const char *LinkingOutput) const {
5350 const Driver &D = getToolChain().getDriver();
5351 ArgStringList CmdArgs;
5353 if (!D.SysRoot.empty())
5354 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5356 if (Args.hasArg(options::OPT_static)) {
5357 CmdArgs.push_back("-Bstatic");
5359 if (Args.hasArg(options::OPT_rdynamic))
5360 CmdArgs.push_back("-export-dynamic");
5361 CmdArgs.push_back("--eh-frame-hdr");
5362 if (Args.hasArg(options::OPT_shared)) {
5363 CmdArgs.push_back("-Bshareable");
5365 CmdArgs.push_back("-dynamic-linker");
5366 CmdArgs.push_back("/libexec/ld.elf_so");
5370 // When building 32-bit code on NetBSD/amd64, we have to explicitly
5371 // instruct ld in the base system to link 32-bit code.
5372 if (getToolChain().getArch() == llvm::Triple::x86) {
5373 CmdArgs.push_back("-m");
5374 CmdArgs.push_back("elf_i386");
5377 if (Output.isFilename()) {
5378 CmdArgs.push_back("-o");
5379 CmdArgs.push_back(Output.getFilename());
5381 assert(Output.isNothing() && "Invalid output.");
5384 if (!Args.hasArg(options::OPT_nostdlib) &&
5385 !Args.hasArg(options::OPT_nostartfiles)) {
5386 if (!Args.hasArg(options::OPT_shared)) {
5387 CmdArgs.push_back(Args.MakeArgString(
5388 getToolChain().GetFilePath("crt0.o")));
5389 CmdArgs.push_back(Args.MakeArgString(
5390 getToolChain().GetFilePath("crti.o")));
5391 CmdArgs.push_back(Args.MakeArgString(
5392 getToolChain().GetFilePath("crtbegin.o")));
5394 CmdArgs.push_back(Args.MakeArgString(
5395 getToolChain().GetFilePath("crti.o")));
5396 CmdArgs.push_back(Args.MakeArgString(
5397 getToolChain().GetFilePath("crtbeginS.o")));
5401 Args.AddAllArgs(CmdArgs, options::OPT_L);
5402 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5403 Args.AddAllArgs(CmdArgs, options::OPT_e);
5404 Args.AddAllArgs(CmdArgs, options::OPT_s);
5405 Args.AddAllArgs(CmdArgs, options::OPT_t);
5406 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5407 Args.AddAllArgs(CmdArgs, options::OPT_r);
5409 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5411 if (!Args.hasArg(options::OPT_nostdlib) &&
5412 !Args.hasArg(options::OPT_nodefaultlibs)) {
5414 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5415 CmdArgs.push_back("-lm");
5417 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5418 // the default system libraries. Just mimic this for now.
5419 if (Args.hasArg(options::OPT_static)) {
5420 CmdArgs.push_back("-lgcc_eh");
5422 CmdArgs.push_back("--as-needed");
5423 CmdArgs.push_back("-lgcc_s");
5424 CmdArgs.push_back("--no-as-needed");
5426 CmdArgs.push_back("-lgcc");
5428 if (Args.hasArg(options::OPT_pthread))
5429 CmdArgs.push_back("-lpthread");
5430 CmdArgs.push_back("-lc");
5432 CmdArgs.push_back("-lgcc");
5433 if (Args.hasArg(options::OPT_static)) {
5434 CmdArgs.push_back("-lgcc_eh");
5436 CmdArgs.push_back("--as-needed");
5437 CmdArgs.push_back("-lgcc_s");
5438 CmdArgs.push_back("--no-as-needed");
5442 if (!Args.hasArg(options::OPT_nostdlib) &&
5443 !Args.hasArg(options::OPT_nostartfiles)) {
5444 if (!Args.hasArg(options::OPT_shared))
5445 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5448 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5450 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
5454 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5456 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5457 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5460 void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5461 const InputInfo &Output,
5462 const InputInfoList &Inputs,
5463 const ArgList &Args,
5464 const char *LinkingOutput) const {
5465 ArgStringList CmdArgs;
5467 // Add --32/--64 to make sure we get the format we want.
5468 // This is incomplete
5469 if (getToolChain().getArch() == llvm::Triple::x86) {
5470 CmdArgs.push_back("--32");
5471 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
5472 CmdArgs.push_back("--64");
5473 } else if (getToolChain().getArch() == llvm::Triple::ppc) {
5474 CmdArgs.push_back("-a32");
5475 CmdArgs.push_back("-mppc");
5476 CmdArgs.push_back("-many");
5477 } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
5478 CmdArgs.push_back("-a64");
5479 CmdArgs.push_back("-mppc64");
5480 CmdArgs.push_back("-many");
5481 } else if (getToolChain().getArch() == llvm::Triple::arm) {
5482 StringRef MArch = getToolChain().getArchName();
5483 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
5484 CmdArgs.push_back("-mfpu=neon");
5486 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
5487 getToolChain().getTriple());
5488 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
5490 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
5491 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
5492 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
5493 } else if (getToolChain().getArch() == llvm::Triple::mips ||
5494 getToolChain().getArch() == llvm::Triple::mipsel ||
5495 getToolChain().getArch() == llvm::Triple::mips64 ||
5496 getToolChain().getArch() == llvm::Triple::mips64el) {
5499 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName);
5501 CmdArgs.push_back("-march");
5502 CmdArgs.push_back(CPUName.data());
5504 // Convert ABI name to the GNU tools acceptable variant.
5505 if (ABIName == "o32")
5507 else if (ABIName == "n64")
5510 CmdArgs.push_back("-mabi");
5511 CmdArgs.push_back(ABIName.data());
5513 if (getToolChain().getArch() == llvm::Triple::mips ||
5514 getToolChain().getArch() == llvm::Triple::mips64)
5515 CmdArgs.push_back("-EB");
5517 CmdArgs.push_back("-EL");
5519 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5520 options::OPT_fpic, options::OPT_fno_pic,
5521 options::OPT_fPIE, options::OPT_fno_PIE,
5522 options::OPT_fpie, options::OPT_fno_pie);
5524 (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5525 LastPICArg->getOption().matches(options::OPT_fpic) ||
5526 LastPICArg->getOption().matches(options::OPT_fPIE) ||
5527 LastPICArg->getOption().matches(options::OPT_fpie))) {
5528 CmdArgs.push_back("-KPIC");
5532 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5533 options::OPT_Xassembler);
5535 CmdArgs.push_back("-o");
5536 CmdArgs.push_back(Output.getFilename());
5538 for (InputInfoList::const_iterator
5539 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5540 const InputInfo &II = *it;
5541 CmdArgs.push_back(II.getFilename());
5545 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5546 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5549 static void AddLibgcc(llvm::Triple Triple, const Driver &D,
5550 ArgStringList &CmdArgs, const ArgList &Args) {
5551 bool isAndroid = Triple.getEnvironment() == llvm::Triple::ANDROIDEABI;
5552 bool StaticLibgcc = isAndroid || Args.hasArg(options::OPT_static) ||
5553 Args.hasArg(options::OPT_static_libgcc);
5555 CmdArgs.push_back("-lgcc");
5559 CmdArgs.push_back("-lgcc");
5562 CmdArgs.push_back("--as-needed");
5563 CmdArgs.push_back("-lgcc_s");
5565 CmdArgs.push_back("--no-as-needed");
5568 if (StaticLibgcc && !isAndroid)
5569 CmdArgs.push_back("-lgcc_eh");
5570 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
5571 CmdArgs.push_back("-lgcc");
5574 void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
5575 const InputInfo &Output,
5576 const InputInfoList &Inputs,
5577 const ArgList &Args,
5578 const char *LinkingOutput) const {
5579 const toolchains::Linux& ToolChain =
5580 static_cast<const toolchains::Linux&>(getToolChain());
5581 const Driver &D = ToolChain.getDriver();
5582 const bool isAndroid = ToolChain.getTriple().getEnvironment() ==
5583 llvm::Triple::ANDROIDEABI;
5585 ArgStringList CmdArgs;
5587 // Silence warning for "clang -g foo.o -o foo"
5588 Args.ClaimAllArgs(options::OPT_g_Group);
5589 // and "clang -emit-llvm foo.o -o foo"
5590 Args.ClaimAllArgs(options::OPT_emit_llvm);
5591 // and for "clang -w foo.o -o foo". Other warning options are already
5592 // handled somewhere else.
5593 Args.ClaimAllArgs(options::OPT_w);
5595 if (!D.SysRoot.empty())
5596 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5598 if (Args.hasArg(options::OPT_pie))
5599 CmdArgs.push_back("-pie");
5601 if (Args.hasArg(options::OPT_rdynamic))
5602 CmdArgs.push_back("-export-dynamic");
5604 if (Args.hasArg(options::OPT_s))
5605 CmdArgs.push_back("-s");
5607 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
5608 e = ToolChain.ExtraOpts.end();
5610 CmdArgs.push_back(i->c_str());
5612 if (!Args.hasArg(options::OPT_static)) {
5613 CmdArgs.push_back("--eh-frame-hdr");
5616 CmdArgs.push_back("-m");
5617 if (ToolChain.getArch() == llvm::Triple::x86)
5618 CmdArgs.push_back("elf_i386");
5619 else if (ToolChain.getArch() == llvm::Triple::arm
5620 || ToolChain.getArch() == llvm::Triple::thumb)
5621 CmdArgs.push_back("armelf_linux_eabi");
5622 else if (ToolChain.getArch() == llvm::Triple::ppc)
5623 CmdArgs.push_back("elf32ppclinux");
5624 else if (ToolChain.getArch() == llvm::Triple::ppc64)
5625 CmdArgs.push_back("elf64ppc");
5626 else if (ToolChain.getArch() == llvm::Triple::mips)
5627 CmdArgs.push_back("elf32btsmip");
5628 else if (ToolChain.getArch() == llvm::Triple::mipsel)
5629 CmdArgs.push_back("elf32ltsmip");
5630 else if (ToolChain.getArch() == llvm::Triple::mips64)
5631 CmdArgs.push_back("elf64btsmip");
5632 else if (ToolChain.getArch() == llvm::Triple::mips64el)
5633 CmdArgs.push_back("elf64ltsmip");
5635 CmdArgs.push_back("elf_x86_64");
5637 if (Args.hasArg(options::OPT_static)) {
5638 if (ToolChain.getArch() == llvm::Triple::arm
5639 || ToolChain.getArch() == llvm::Triple::thumb)
5640 CmdArgs.push_back("-Bstatic");
5642 CmdArgs.push_back("-static");
5643 } else if (Args.hasArg(options::OPT_shared)) {
5644 CmdArgs.push_back("-shared");
5645 if ((ToolChain.getArch() == llvm::Triple::arm
5646 || ToolChain.getArch() == llvm::Triple::thumb) && isAndroid) {
5647 CmdArgs.push_back("-Bsymbolic");
5651 if (ToolChain.getArch() == llvm::Triple::arm ||
5652 ToolChain.getArch() == llvm::Triple::thumb ||
5653 (!Args.hasArg(options::OPT_static) &&
5654 !Args.hasArg(options::OPT_shared))) {
5655 CmdArgs.push_back("-dynamic-linker");
5657 CmdArgs.push_back("/system/bin/linker");
5658 else if (ToolChain.getArch() == llvm::Triple::x86)
5659 CmdArgs.push_back("/lib/ld-linux.so.2");
5660 else if (ToolChain.getArch() == llvm::Triple::arm ||
5661 ToolChain.getArch() == llvm::Triple::thumb) {
5662 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
5663 CmdArgs.push_back("/lib/ld-linux-armhf.so.3");
5665 CmdArgs.push_back("/lib/ld-linux.so.3");
5667 else if (ToolChain.getArch() == llvm::Triple::mips ||
5668 ToolChain.getArch() == llvm::Triple::mipsel)
5669 CmdArgs.push_back("/lib/ld.so.1");
5670 else if (ToolChain.getArch() == llvm::Triple::mips64 ||
5671 ToolChain.getArch() == llvm::Triple::mips64el)
5672 CmdArgs.push_back("/lib64/ld.so.1");
5673 else if (ToolChain.getArch() == llvm::Triple::ppc)
5674 CmdArgs.push_back("/lib/ld.so.1");
5675 else if (ToolChain.getArch() == llvm::Triple::ppc64)
5676 CmdArgs.push_back("/lib64/ld64.so.1");
5678 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
5681 CmdArgs.push_back("-o");
5682 CmdArgs.push_back(Output.getFilename());
5684 if (!Args.hasArg(options::OPT_nostdlib) &&
5685 !Args.hasArg(options::OPT_nostartfiles)) {
5687 const char *crt1 = NULL;
5688 if (!Args.hasArg(options::OPT_shared)){
5689 if (Args.hasArg(options::OPT_pie))
5695 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5697 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5700 const char *crtbegin;
5701 if (Args.hasArg(options::OPT_static))
5702 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
5703 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5704 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
5706 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
5707 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5710 Args.AddAllArgs(CmdArgs, options::OPT_L);
5712 const ToolChain::path_list Paths = ToolChain.getFilePaths();
5714 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5716 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5718 // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5719 // as gold requires -plugin to come before any -plugin-opt that -Wl might
5721 if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) {
5722 CmdArgs.push_back("-plugin");
5723 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5724 CmdArgs.push_back(Args.MakeArgString(Plugin));
5727 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
5728 CmdArgs.push_back("--no-demangle");
5730 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5733 !Args.hasArg(options::OPT_nostdlib) &&
5734 !Args.hasArg(options::OPT_nodefaultlibs)) {
5735 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
5736 !Args.hasArg(options::OPT_static);
5737 if (OnlyLibstdcxxStatic)
5738 CmdArgs.push_back("-Bstatic");
5739 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5740 if (OnlyLibstdcxxStatic)
5741 CmdArgs.push_back("-Bdynamic");
5742 CmdArgs.push_back("-lm");
5745 // Call this before we add the C run-time.
5746 addAsanRTLinux(getToolChain(), Args, CmdArgs);
5747 addTsanRTLinux(getToolChain(), Args, CmdArgs);
5749 if (!Args.hasArg(options::OPT_nostdlib)) {
5750 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
5751 if (Args.hasArg(options::OPT_static))
5752 CmdArgs.push_back("--start-group");
5754 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5756 if (Args.hasArg(options::OPT_pthread) ||
5757 Args.hasArg(options::OPT_pthreads))
5758 CmdArgs.push_back("-lpthread");
5760 CmdArgs.push_back("-lc");
5762 if (Args.hasArg(options::OPT_static))
5763 CmdArgs.push_back("--end-group");
5765 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
5768 if (!Args.hasArg(options::OPT_nostartfiles)) {
5770 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5771 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
5773 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
5775 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
5777 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
5781 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5783 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
5786 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5787 const InputInfo &Output,
5788 const InputInfoList &Inputs,
5789 const ArgList &Args,
5790 const char *LinkingOutput) const {
5791 ArgStringList CmdArgs;
5793 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5794 options::OPT_Xassembler);
5796 CmdArgs.push_back("-o");
5797 CmdArgs.push_back(Output.getFilename());
5799 for (InputInfoList::const_iterator
5800 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5801 const InputInfo &II = *it;
5802 CmdArgs.push_back(II.getFilename());
5806 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5807 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5810 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
5811 const InputInfo &Output,
5812 const InputInfoList &Inputs,
5813 const ArgList &Args,
5814 const char *LinkingOutput) const {
5815 const Driver &D = getToolChain().getDriver();
5816 ArgStringList CmdArgs;
5818 if (Output.isFilename()) {
5819 CmdArgs.push_back("-o");
5820 CmdArgs.push_back(Output.getFilename());
5822 assert(Output.isNothing() && "Invalid output.");
5825 if (!Args.hasArg(options::OPT_nostdlib) &&
5826 !Args.hasArg(options::OPT_nostartfiles)) {
5827 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
5828 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5829 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
5830 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
5833 Args.AddAllArgs(CmdArgs, options::OPT_L);
5834 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5835 Args.AddAllArgs(CmdArgs, options::OPT_e);
5837 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5839 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5841 if (!Args.hasArg(options::OPT_nostdlib) &&
5842 !Args.hasArg(options::OPT_nodefaultlibs)) {
5844 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5845 CmdArgs.push_back("-lm");
5849 if (!Args.hasArg(options::OPT_nostdlib) &&
5850 !Args.hasArg(options::OPT_nostartfiles)) {
5851 if (Args.hasArg(options::OPT_pthread))
5852 CmdArgs.push_back("-lpthread");
5853 CmdArgs.push_back("-lc");
5854 CmdArgs.push_back("-lCompilerRT-Generic");
5855 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
5857 Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
5860 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5861 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5866 // For now, DragonFly Assemble does just about the same as for
5867 // FreeBSD, but this may change soon.
5868 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5869 const InputInfo &Output,
5870 const InputInfoList &Inputs,
5871 const ArgList &Args,
5872 const char *LinkingOutput) const {
5873 ArgStringList CmdArgs;
5875 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5876 // instruct as in the base system to assemble 32-bit code.
5877 if (getToolChain().getArchName() == "i386")
5878 CmdArgs.push_back("--32");
5880 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5881 options::OPT_Xassembler);
5883 CmdArgs.push_back("-o");
5884 CmdArgs.push_back(Output.getFilename());
5886 for (InputInfoList::const_iterator
5887 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5888 const InputInfo &II = *it;
5889 CmdArgs.push_back(II.getFilename());
5893 Args.MakeArgString(getToolChain().GetProgramPath("as"));
5894 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5897 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
5898 const InputInfo &Output,
5899 const InputInfoList &Inputs,
5900 const ArgList &Args,
5901 const char *LinkingOutput) const {
5902 const Driver &D = getToolChain().getDriver();
5903 ArgStringList CmdArgs;
5905 if (!D.SysRoot.empty())
5906 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5908 if (Args.hasArg(options::OPT_static)) {
5909 CmdArgs.push_back("-Bstatic");
5911 if (Args.hasArg(options::OPT_shared))
5912 CmdArgs.push_back("-Bshareable");
5914 CmdArgs.push_back("-dynamic-linker");
5915 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
5919 // When building 32-bit code on DragonFly/pc64, we have to explicitly
5920 // instruct ld in the base system to link 32-bit code.
5921 if (getToolChain().getArchName() == "i386") {
5922 CmdArgs.push_back("-m");
5923 CmdArgs.push_back("elf_i386");
5926 if (Output.isFilename()) {
5927 CmdArgs.push_back("-o");
5928 CmdArgs.push_back(Output.getFilename());
5930 assert(Output.isNothing() && "Invalid output.");
5933 if (!Args.hasArg(options::OPT_nostdlib) &&
5934 !Args.hasArg(options::OPT_nostartfiles)) {
5935 if (!Args.hasArg(options::OPT_shared)) {
5937 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
5939 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5941 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
5944 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
5946 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
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)) {
5958 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
5960 CmdArgs.push_back("-L/usr/lib/gcc41");
5962 if (!Args.hasArg(options::OPT_static)) {
5963 CmdArgs.push_back("-rpath");
5964 CmdArgs.push_back("/usr/lib/gcc41");
5966 CmdArgs.push_back("-rpath-link");
5967 CmdArgs.push_back("/usr/lib/gcc41");
5969 CmdArgs.push_back("-rpath");
5970 CmdArgs.push_back("/usr/lib");
5972 CmdArgs.push_back("-rpath-link");
5973 CmdArgs.push_back("/usr/lib");
5977 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5978 CmdArgs.push_back("-lm");
5981 if (Args.hasArg(options::OPT_shared)) {
5982 CmdArgs.push_back("-lgcc_pic");
5984 CmdArgs.push_back("-lgcc");
5988 if (Args.hasArg(options::OPT_pthread))
5989 CmdArgs.push_back("-lpthread");
5991 if (!Args.hasArg(options::OPT_nolibc)) {
5992 CmdArgs.push_back("-lc");
5995 if (Args.hasArg(options::OPT_shared)) {
5996 CmdArgs.push_back("-lgcc_pic");
5998 CmdArgs.push_back("-lgcc");
6002 if (!Args.hasArg(options::OPT_nostdlib) &&
6003 !Args.hasArg(options::OPT_nostartfiles)) {
6004 if (!Args.hasArg(options::OPT_shared))
6005 CmdArgs.push_back(Args.MakeArgString(
6006 getToolChain().GetFilePath("crtend.o")));
6008 CmdArgs.push_back(Args.MakeArgString(
6009 getToolChain().GetFilePath("crtendS.o")));
6010 CmdArgs.push_back(Args.MakeArgString(
6011 getToolChain().GetFilePath("crtn.o")));
6014 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6017 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6018 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6021 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6022 const InputInfo &Output,
6023 const InputInfoList &Inputs,
6024 const ArgList &Args,
6025 const char *LinkingOutput) const {
6026 ArgStringList CmdArgs;
6028 if (Output.isFilename()) {
6029 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6030 Output.getFilename()));
6032 assert(Output.isNothing() && "Invalid output.");
6035 if (!Args.hasArg(options::OPT_nostdlib) &&
6036 !Args.hasArg(options::OPT_nostartfiles)) {
6037 CmdArgs.push_back("-defaultlib:libcmt");
6040 CmdArgs.push_back("-nologo");
6042 Args.AddAllArgValues(CmdArgs, options::OPT_l);
6044 // Add filenames immediately.
6045 for (InputInfoList::const_iterator
6046 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6047 if (it->isFilename())
6048 CmdArgs.push_back(it->getFilename());
6052 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
6053 C.addCommand(new Command(JA, *this, Exec, CmdArgs));