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/HostInfo.h"
20 #include "clang/Driver/ObjCRuntime.h"
21 #include "clang/Driver/Option.h"
22 #include "clang/Driver/Options.h"
23 #include "clang/Driver/ToolChain.h"
24 #include "clang/Driver/Util.h"
26 #include "llvm/ADT/SmallString.h"
27 #include "llvm/ADT/StringSwitch.h"
28 #include "llvm/ADT/Twine.h"
29 #include "llvm/Support/FileSystem.h"
30 #include "llvm/Support/Format.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include "llvm/Support/Host.h"
33 #include "llvm/Support/Process.h"
34 #include "llvm/Support/ErrorHandling.h"
36 #include "InputInfo.h"
37 #include "ToolChains.h"
40 #include <cygwin/version.h>
41 #if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
46 using namespace clang::driver;
47 using namespace clang::driver::tools;
48 using namespace clang;
50 /// CheckPreprocessingOptions - Perform some validation of preprocessing
51 /// arguments that is shared with gcc.
52 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
53 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
54 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
55 D.Diag(diag::err_drv_argument_only_allowed_with)
56 << A->getAsString(Args) << "-E";
59 /// CheckCodeGenerationOptions - Perform some validation of code generation
60 /// arguments that is shared with gcc.
61 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
62 // In gcc, only ARM checks this, but it seems reasonable to check universally.
63 if (Args.hasArg(options::OPT_static))
64 if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
65 options::OPT_mdynamic_no_pic))
66 D.Diag(diag::err_drv_argument_not_allowed_with)
67 << A->getAsString(Args) << "-static";
70 // Quote target names for inclusion in GNU Make dependency files.
71 // Only the characters '$', '#', ' ', '\t' are quoted.
72 static void QuoteTarget(StringRef Target,
73 SmallVectorImpl<char> &Res) {
74 for (unsigned i = 0, e = Target.size(); i != e; ++i) {
78 // Escape the preceding backslashes
79 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
82 // Escape the space/tab
95 Res.push_back(Target[i]);
99 static void AddLinkerInputs(const ToolChain &TC,
100 const InputInfoList &Inputs, const ArgList &Args,
101 ArgStringList &CmdArgs) {
102 const Driver &D = TC.getDriver();
104 // Add extra linker input arguments which are not treated as inputs
105 // (constructed via -Xarch_).
106 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
108 for (InputInfoList::const_iterator
109 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
110 const InputInfo &II = *it;
112 if (!TC.HasNativeLLVMSupport()) {
113 // Don't try to pass LLVM inputs unless we have native support.
114 if (II.getType() == types::TY_LLVM_IR ||
115 II.getType() == types::TY_LTO_IR ||
116 II.getType() == types::TY_LLVM_BC ||
117 II.getType() == types::TY_LTO_BC)
118 D.Diag(diag::err_drv_no_linker_llvm_support)
119 << TC.getTripleString();
122 // Add filenames immediately.
123 if (II.isFilename()) {
124 CmdArgs.push_back(II.getFilename());
128 // Otherwise, this is a linker input argument.
129 const Arg &A = II.getInputArg();
131 // Handle reserved library options.
132 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
133 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
134 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
135 TC.AddCCKextLibArgs(Args, CmdArgs);
137 A.renderAsInput(Args, CmdArgs);
141 /// \brief Determine whether Objective-C automated reference counting is
143 static bool isObjCAutoRefCount(const ArgList &Args) {
144 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
147 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
148 ArgStringList &CmdArgs,
149 llvm::Triple Triple) {
150 if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
151 Args.hasArg(options::OPT_fprofile_generate) ||
152 Args.hasArg(options::OPT_fcreate_profile) ||
153 Args.hasArg(options::OPT_coverage)))
156 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
157 // the link line. We cannot do the same thing because unlike gcov there is a
158 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
159 // not supported by old linkers.
161 Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.a";
163 if (Triple.isOSDarwin()) {
164 // On Darwin, if the static library doesn't exist try the dylib.
166 if (llvm::sys::fs::exists(ProfileRT.str(), Exists) || !Exists)
168 Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.dylib";
171 CmdArgs.push_back(Args.MakeArgString(ProfileRT));
174 static void AddIncludeDirectoryList(const ArgList &Args,
175 ArgStringList &CmdArgs,
177 const char *DirList) {
179 return; // Nothing to do.
181 StringRef Dirs(DirList);
182 if (Dirs.empty()) // Empty string should not add '.'.
185 StringRef::size_type Delim;
186 while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
187 if (Delim == 0) { // Leading colon.
188 CmdArgs.push_back(ArgName);
189 CmdArgs.push_back(".");
191 CmdArgs.push_back(ArgName);
192 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
194 Dirs = Dirs.substr(Delim + 1);
197 if (Dirs.empty()) { // Trailing colon.
198 CmdArgs.push_back(ArgName);
199 CmdArgs.push_back(".");
200 } else { // Add the last path.
201 CmdArgs.push_back(ArgName);
202 CmdArgs.push_back(Args.MakeArgString(Dirs));
206 void Clang::AddPreprocessingOptions(const Driver &D,
208 ArgStringList &CmdArgs,
209 const InputInfo &Output,
210 const InputInfoList &Inputs) const {
213 CheckPreprocessingOptions(D, Args);
215 Args.AddLastArg(CmdArgs, options::OPT_C);
216 Args.AddLastArg(CmdArgs, options::OPT_CC);
218 // Handle dependency file generation.
219 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
220 (A = Args.getLastArg(options::OPT_MD)) ||
221 (A = Args.getLastArg(options::OPT_MMD))) {
222 // Determine the output location.
224 if (Output.getType() == types::TY_Dependencies) {
225 DepFile = Output.getFilename();
226 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
227 DepFile = MF->getValue(Args);
228 } else if (A->getOption().matches(options::OPT_M) ||
229 A->getOption().matches(options::OPT_MM)) {
232 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
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 llvm::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 llvm::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 llvm::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 C++ include arguments, if needed.
368 types::ID InputType = Inputs[0].getType();
369 if (types::isCXX(InputType)) {
370 bool ObjCXXAutoRefCount
371 = types::isObjC(InputType) && isObjCAutoRefCount(Args);
372 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs,
374 Args.AddAllArgs(CmdArgs, options::OPT_stdlib_EQ);
377 // Add -Wp, and -Xassembler if using the preprocessor.
379 // FIXME: There is a very unfortunate problem here, some troubled
380 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
381 // really support that we would have to parse and then translate
383 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
384 options::OPT_Xpreprocessor);
386 // -I- is a deprecated GCC feature, reject it.
387 if (Arg *A = Args.getLastArg(options::OPT_I_))
388 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
390 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
391 // -isysroot to the CC1 invocation.
392 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
393 if (!Args.hasArg(options::OPT_isysroot)) {
394 CmdArgs.push_back("-isysroot");
395 CmdArgs.push_back(A->getValue(Args));
399 // If a module path was provided, pass it along. Otherwise, use a temporary
401 if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) {
403 A->render(Args, CmdArgs);
405 llvm::SmallString<128> DefaultModuleCache;
406 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
408 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
409 CmdArgs.push_back("-fmodule-cache-path");
410 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
413 Args.AddAllArgs(CmdArgs, options::OPT_fauto_module_import);
415 // Parse additional include paths from environment variables.
416 // CPATH - included following the user specified includes (but prior to
417 // builtin and standard includes).
418 AddIncludeDirectoryList(Args, CmdArgs, "-I", ::getenv("CPATH"));
419 // C_INCLUDE_PATH - system includes enabled when compiling C.
420 AddIncludeDirectoryList(Args, CmdArgs, "-c-isystem",
421 ::getenv("C_INCLUDE_PATH"));
422 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
423 AddIncludeDirectoryList(Args, CmdArgs, "-cxx-isystem",
424 ::getenv("CPLUS_INCLUDE_PATH"));
425 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
426 AddIncludeDirectoryList(Args, CmdArgs, "-objc-isystem",
427 ::getenv("OBJC_INCLUDE_PATH"));
428 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
429 AddIncludeDirectoryList(Args, CmdArgs, "-objcxx-isystem",
430 ::getenv("OBJCPLUS_INCLUDE_PATH"));
433 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
435 // FIXME: tblgen this.
436 static const char *getARMTargetCPU(const ArgList &Args,
437 const llvm::Triple &Triple) {
438 // FIXME: Warn on inconsistent use of -mcpu and -march.
440 // If we have -mcpu=, use that.
441 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
442 return A->getValue(Args);
445 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
446 // Otherwise, if we have -march= choose the base CPU for that arch.
447 MArch = A->getValue(Args);
449 // Otherwise, use the Arch from the triple.
450 MArch = Triple.getArchName();
453 return llvm::StringSwitch<const char *>(MArch)
454 .Cases("armv2", "armv2a","arm2")
455 .Case("armv3", "arm6")
456 .Case("armv3m", "arm7m")
457 .Cases("armv4", "armv4t", "arm7tdmi")
458 .Cases("armv5", "armv5t", "arm10tdmi")
459 .Cases("armv5e", "armv5te", "arm1026ejs")
460 .Case("armv5tej", "arm926ej-s")
461 .Cases("armv6", "armv6k", "arm1136jf-s")
462 .Case("armv6j", "arm1136j-s")
463 .Cases("armv6z", "armv6zk", "arm1176jzf-s")
464 .Case("armv6t2", "arm1156t2-s")
465 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
466 .Cases("armv7r", "armv7-r", "cortex-r4")
467 .Cases("armv7m", "armv7-m", "cortex-m3")
468 .Case("ep9312", "ep9312")
469 .Case("iwmmxt", "iwmmxt")
470 .Case("xscale", "xscale")
471 .Cases("armv6m", "armv6-m", "cortex-m0")
472 // If all else failed, return the most base CPU LLVM supports.
473 .Default("arm7tdmi");
476 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
479 // FIXME: This is redundant with -mcpu, why does LLVM use this.
480 // FIXME: tblgen this, or kill it!
481 static const char *getLLVMArchSuffixForARM(StringRef CPU) {
482 return llvm::StringSwitch<const char *>(CPU)
483 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
484 .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
485 .Cases("arm920", "arm920t", "arm922t", "v4t")
486 .Cases("arm940t", "ep9312","v4t")
487 .Cases("arm10tdmi", "arm1020t", "v5")
488 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e")
489 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e")
490 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e")
491 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6")
492 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6")
493 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2")
494 .Cases("cortex-a8", "cortex-a9", "v7")
498 // FIXME: Move to target hook.
499 static bool isSignedCharDefault(const llvm::Triple &Triple) {
500 switch (Triple.getArch()) {
504 case llvm::Triple::arm:
505 case llvm::Triple::ppc:
506 case llvm::Triple::ppc64:
507 if (Triple.isOSDarwin())
511 case llvm::Triple::systemz:
516 void Clang::AddARMTargetArgs(const ArgList &Args,
517 ArgStringList &CmdArgs,
518 bool KernelOrKext) const {
519 const Driver &D = getToolChain().getDriver();
520 llvm::Triple Triple = getToolChain().getTriple();
522 // Select the ABI to use.
524 // FIXME: Support -meabi.
525 const char *ABIName = 0;
526 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
527 ABIName = A->getValue(Args);
529 // Select the default based on the platform.
530 switch(Triple.getEnvironment()) {
531 case llvm::Triple::GNUEABI:
532 ABIName = "aapcs-linux";
534 case llvm::Triple::EABI:
538 ABIName = "apcs-gnu";
541 CmdArgs.push_back("-target-abi");
542 CmdArgs.push_back(ABIName);
544 // Set the CPU based on -march= and -mcpu=.
545 CmdArgs.push_back("-target-cpu");
546 CmdArgs.push_back(getARMTargetCPU(Args, Triple));
548 // Select the float ABI as determined by -msoft-float, -mhard-float, and
551 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
552 options::OPT_mhard_float,
553 options::OPT_mfloat_abi_EQ)) {
554 if (A->getOption().matches(options::OPT_msoft_float))
556 else if (A->getOption().matches(options::OPT_mhard_float))
559 FloatABI = A->getValue(Args);
560 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
561 D.Diag(diag::err_drv_invalid_mfloat_abi)
562 << A->getAsString(Args);
568 // If unspecified, choose the default based on the platform.
569 if (FloatABI.empty()) {
570 const llvm::Triple &Triple = getToolChain().getTriple();
571 switch (Triple.getOS()) {
572 case llvm::Triple::Darwin:
573 case llvm::Triple::MacOSX:
574 case llvm::Triple::IOS: {
575 // Darwin defaults to "softfp" for v6 and v7.
577 // FIXME: Factor out an ARM class so we can cache the arch somewhere.
579 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
580 if (ArchName.startswith("v6") || ArchName.startswith("v7"))
587 case llvm::Triple::Linux: {
588 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) {
596 switch(Triple.getEnvironment()) {
597 case llvm::Triple::GNUEABI:
600 case llvm::Triple::EABI:
601 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
605 // Assume "soft", but warn the user we are guessing.
607 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
613 if (FloatABI == "soft") {
614 // Floating point operations and argument passing are soft.
616 // FIXME: This changes CPP defines, we need -target-soft-float.
617 CmdArgs.push_back("-msoft-float");
618 CmdArgs.push_back("-mfloat-abi");
619 CmdArgs.push_back("soft");
620 } else if (FloatABI == "softfp") {
621 // Floating point operations are hard, but argument passing is soft.
622 CmdArgs.push_back("-mfloat-abi");
623 CmdArgs.push_back("soft");
625 // Floating point operations and argument passing are hard.
626 assert(FloatABI == "hard" && "Invalid float abi!");
627 CmdArgs.push_back("-mfloat-abi");
628 CmdArgs.push_back("hard");
631 // Set appropriate target features for floating point mode.
633 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
634 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
635 // stripped out by the ARM target.
637 // Use software floating point operations?
638 if (FloatABI == "soft") {
639 CmdArgs.push_back("-target-feature");
640 CmdArgs.push_back("+soft-float");
643 // Use software floating point argument passing?
644 if (FloatABI != "hard") {
645 CmdArgs.push_back("-target-feature");
646 CmdArgs.push_back("+soft-float-abi");
651 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
653 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
654 StringRef FPU = A->getValue(Args);
656 // Set the target features based on the FPU.
657 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
658 // Disable any default FPU support.
659 CmdArgs.push_back("-target-feature");
660 CmdArgs.push_back("-vfp2");
661 CmdArgs.push_back("-target-feature");
662 CmdArgs.push_back("-vfp3");
663 CmdArgs.push_back("-target-feature");
664 CmdArgs.push_back("-neon");
665 } else if (FPU == "vfp") {
666 CmdArgs.push_back("-target-feature");
667 CmdArgs.push_back("+vfp2");
668 } else if (FPU == "vfp3") {
669 CmdArgs.push_back("-target-feature");
670 CmdArgs.push_back("+vfp3");
671 } else if (FPU == "neon") {
672 CmdArgs.push_back("-target-feature");
673 CmdArgs.push_back("+neon");
675 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
678 // Setting -msoft-float effectively disables NEON because of the GCC
679 // implementation, although the same isn't true of VFP or VFP3.
680 if (FloatABI == "soft") {
681 CmdArgs.push_back("-target-feature");
682 CmdArgs.push_back("-neon");
685 // Kernel code has more strict alignment requirements.
687 CmdArgs.push_back("-backend-option");
688 CmdArgs.push_back("-arm-long-calls");
690 CmdArgs.push_back("-backend-option");
691 CmdArgs.push_back("-arm-strict-align");
693 // The kext linker doesn't know how to deal with movw/movt.
694 CmdArgs.push_back("-backend-option");
695 CmdArgs.push_back("-arm-darwin-use-movt=0");
698 // Setting -mno-global-merge disables the codegen global merge pass. Setting
699 // -mglobal-merge has no effect as the pass is enabled by default.
700 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
701 options::OPT_mno_global_merge)) {
702 if (A->getOption().matches(options::OPT_mno_global_merge))
703 CmdArgs.push_back("-mno-global-merge");
707 // Get default architecture.
708 static const char* getMipsArchFromCPU(StringRef CPUName) {
709 if (CPUName == "mips32r1" || CPUName == "4ke")
712 assert((CPUName == "mips64r1" || CPUName == "mips64r2") &&
713 "Unexpected cpu name.");
718 // Get default target cpu.
719 static const char* getMipsCPUFromArch(StringRef ArchName, const Driver &D) {
720 if (ArchName == "mips" || ArchName == "mipsel")
722 else if (ArchName == "mips64" || ArchName == "mips64el")
725 D.Diag(diag::err_drv_invalid_arch_name) << ArchName;
731 static const char* getMipsABIFromArch(StringRef ArchName) {
732 if (ArchName == "mips" || ArchName == "mipsel")
735 assert((ArchName == "mips64" || ArchName == "mips64el") &&
736 "Unexpected arch name.");
740 void Clang::AddMIPSTargetArgs(const ArgList &Args,
741 ArgStringList &CmdArgs) const {
742 const Driver &D = getToolChain().getDriver();
747 // Set target cpu and architecture.
748 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
749 CPUName = A->getValue(Args);
750 ArchName = getMipsArchFromCPU(CPUName);
753 ArchName = Args.MakeArgString(getToolChain().getArchName());
754 CPUName = getMipsCPUFromArch(ArchName, D);
757 CmdArgs.push_back("-target-cpu");
758 CmdArgs.push_back(CPUName);
760 // Select the ABI to use.
761 const char *ABIName = 0;
762 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
763 ABIName = A->getValue(Args);
765 ABIName = getMipsABIFromArch(ArchName);
767 CmdArgs.push_back("-target-abi");
768 CmdArgs.push_back(ABIName);
770 // Select the float ABI as determined by -msoft-float, -mhard-float, and
772 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
773 options::OPT_mhard_float)) {
774 if (A->getOption().matches(options::OPT_msoft_float))
776 else if (A->getOption().matches(options::OPT_mhard_float))
780 // If unspecified, choose the default based on the platform.
781 if (FloatABI.empty()) {
782 // Assume "soft", but warn the user we are guessing.
784 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
787 if (FloatABI == "soft") {
788 // Floating point operations and argument passing are soft.
790 // FIXME: This changes CPP defines, we need -target-soft-float.
791 CmdArgs.push_back("-msoft-float");
793 assert(FloatABI == "hard" && "Invalid float abi!");
794 CmdArgs.push_back("-mhard-float");
798 void Clang::AddSparcTargetArgs(const ArgList &Args,
799 ArgStringList &CmdArgs) const {
800 const Driver &D = getToolChain().getDriver();
802 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
803 StringRef MArch = A->getValue(Args);
804 CmdArgs.push_back("-target-cpu");
805 CmdArgs.push_back(MArch.str().c_str());
808 // Select the float ABI as determined by -msoft-float, -mhard-float, and
810 if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
811 options::OPT_mhard_float)) {
812 if (A->getOption().matches(options::OPT_msoft_float))
814 else if (A->getOption().matches(options::OPT_mhard_float))
818 // If unspecified, choose the default based on the platform.
819 if (FloatABI.empty()) {
820 switch (getToolChain().getTriple().getOS()) {
822 // Assume "soft", but warn the user we are guessing.
824 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
829 if (FloatABI == "soft") {
830 // Floating point operations and argument passing are soft.
832 // FIXME: This changes CPP defines, we need -target-soft-float.
833 CmdArgs.push_back("-msoft-float");
834 CmdArgs.push_back("-target-feature");
835 CmdArgs.push_back("+soft-float");
837 assert(FloatABI == "hard" && "Invalid float abi!");
838 CmdArgs.push_back("-mhard-float");
842 void Clang::AddX86TargetArgs(const ArgList &Args,
843 ArgStringList &CmdArgs) const {
844 if (!Args.hasFlag(options::OPT_mred_zone,
845 options::OPT_mno_red_zone,
847 Args.hasArg(options::OPT_mkernel) ||
848 Args.hasArg(options::OPT_fapple_kext))
849 CmdArgs.push_back("-disable-red-zone");
851 if (Args.hasFlag(options::OPT_msoft_float,
852 options::OPT_mno_soft_float,
854 CmdArgs.push_back("-no-implicit-float");
856 const char *CPUName = 0;
857 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
858 if (StringRef(A->getValue(Args)) == "native") {
859 // FIXME: Reject attempts to use -march=native unless the target matches
862 // FIXME: We should also incorporate the detected target features for use
864 std::string CPU = llvm::sys::getHostCPUName();
866 CPUName = Args.MakeArgString(CPU);
868 CPUName = A->getValue(Args);
871 // Select the default CPU if none was given (or detection failed).
873 // FIXME: Need target hooks.
874 if (getToolChain().getTriple().isOSDarwin()) {
875 if (getToolChain().getArch() == llvm::Triple::x86_64)
877 else if (getToolChain().getArch() == llvm::Triple::x86)
879 } else if (getToolChain().getOS().startswith("haiku")) {
880 if (getToolChain().getArch() == llvm::Triple::x86_64)
882 else if (getToolChain().getArch() == llvm::Triple::x86)
884 } else if (getToolChain().getOS().startswith("openbsd")) {
885 if (getToolChain().getArch() == llvm::Triple::x86_64)
887 else if (getToolChain().getArch() == llvm::Triple::x86)
889 } else if (getToolChain().getOS().startswith("freebsd")) {
890 if (getToolChain().getArch() == llvm::Triple::x86_64)
892 else if (getToolChain().getArch() == llvm::Triple::x86)
894 } else if (getToolChain().getOS().startswith("netbsd")) {
895 if (getToolChain().getArch() == llvm::Triple::x86_64)
897 else if (getToolChain().getArch() == llvm::Triple::x86)
900 if (getToolChain().getArch() == llvm::Triple::x86_64)
902 else if (getToolChain().getArch() == llvm::Triple::x86)
903 CPUName = "pentium4";
908 CmdArgs.push_back("-target-cpu");
909 CmdArgs.push_back(CPUName);
912 // The required algorithm here is slightly strange: the options are applied
913 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
914 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
915 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
916 // former correctly, but not the latter; handle directly-overridden
918 llvm::StringMap<unsigned> PrevFeature;
919 std::vector<const char*> Features;
920 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
921 ie = Args.filtered_end(); it != ie; ++it) {
922 StringRef Name = (*it)->getOption().getName();
926 assert(Name.startswith("-m") && "Invalid feature name.");
927 Name = Name.substr(2);
929 bool IsNegative = Name.startswith("no-");
931 Name = Name.substr(3);
933 unsigned& Prev = PrevFeature[Name];
935 Features[Prev - 1] = 0;
936 Prev = Features.size() + 1;
937 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
939 for (unsigned i = 0; i < Features.size(); i++) {
941 CmdArgs.push_back("-target-feature");
942 CmdArgs.push_back(Features[i]);
948 shouldUseExceptionTablesForObjCExceptions(unsigned objcABIVersion,
949 const llvm::Triple &Triple) {
950 // We use the zero-cost exception tables for Objective-C if the non-fragile
951 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
954 if (objcABIVersion >= 2)
957 if (!Triple.isOSDarwin())
960 return (!Triple.isMacOSXVersionLT(10,5) &&
961 (Triple.getArch() == llvm::Triple::x86_64 ||
962 Triple.getArch() == llvm::Triple::arm));
965 /// addExceptionArgs - Adds exception related arguments to the driver command
966 /// arguments. There's a master flag, -fexceptions and also language specific
967 /// flags to enable/disable C++ and Objective-C exceptions.
968 /// This makes it possible to for example disable C++ exceptions but enable
969 /// Objective-C exceptions.
970 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
971 const llvm::Triple &Triple,
972 bool KernelOrKext, bool IsRewriter,
973 unsigned objcABIVersion,
974 ArgStringList &CmdArgs) {
978 // Exceptions are enabled by default.
979 bool ExceptionsEnabled = true;
981 // This keeps track of whether exceptions were explicitly turned on or off.
982 bool DidHaveExplicitExceptionFlag = false;
984 if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
985 options::OPT_fno_exceptions)) {
986 if (A->getOption().matches(options::OPT_fexceptions))
987 ExceptionsEnabled = true;
989 ExceptionsEnabled = false;
991 DidHaveExplicitExceptionFlag = true;
994 bool ShouldUseExceptionTables = false;
996 // Exception tables and cleanups can be enabled with -fexceptions even if the
997 // language itself doesn't support exceptions.
998 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
999 ShouldUseExceptionTables = true;
1001 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1002 // is not necessarily sensible, but follows GCC.
1003 if (types::isObjC(InputType) &&
1004 Args.hasFlag(options::OPT_fobjc_exceptions,
1005 options::OPT_fno_objc_exceptions,
1007 CmdArgs.push_back("-fobjc-exceptions");
1009 ShouldUseExceptionTables |=
1010 shouldUseExceptionTablesForObjCExceptions(objcABIVersion, Triple);
1013 if (types::isCXX(InputType)) {
1014 bool CXXExceptionsEnabled = ExceptionsEnabled;
1016 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1017 options::OPT_fno_cxx_exceptions,
1018 options::OPT_fexceptions,
1019 options::OPT_fno_exceptions)) {
1020 if (A->getOption().matches(options::OPT_fcxx_exceptions))
1021 CXXExceptionsEnabled = true;
1022 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1023 CXXExceptionsEnabled = false;
1026 if (CXXExceptionsEnabled) {
1027 CmdArgs.push_back("-fcxx-exceptions");
1029 ShouldUseExceptionTables = true;
1033 if (ShouldUseExceptionTables)
1034 CmdArgs.push_back("-fexceptions");
1037 static bool ShouldDisableCFI(const ArgList &Args,
1038 const ToolChain &TC) {
1039 if (TC.getTriple().isOSDarwin()) {
1040 // The native darwin assembler doesn't support cfi directives, so
1041 // we disable them if we think the .s file will be passed to it.
1043 // FIXME: Duplicated code with ToolChains.cpp
1044 // FIXME: This doesn't belong here, but ideally we will support static soon
1046 bool HasStatic = (Args.hasArg(options::OPT_mkernel) ||
1047 Args.hasArg(options::OPT_static) ||
1048 Args.hasArg(options::OPT_fapple_kext));
1049 bool IsIADefault = TC.IsIntegratedAssemblerDefault() && !HasStatic;
1050 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1051 options::OPT_no_integrated_as,
1053 bool UseCFI = Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1054 options::OPT_fno_dwarf2_cfi_asm,
1059 // For now we assume that every other assembler support CFI.
1063 /// \brief Check whether the given input tree contains any compilation actions.
1064 static bool ContainsCompileAction(const Action *A) {
1065 if (isa<CompileJobAction>(A))
1068 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1069 if (ContainsCompileAction(*it))
1075 /// \brief Check if -relax-all should be passed to the internal assembler.
1076 /// This is done by default when compiling non-assembler source with -O0.
1077 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1078 bool RelaxDefault = true;
1080 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1081 RelaxDefault = A->getOption().matches(options::OPT_O0);
1084 RelaxDefault = false;
1085 for (ActionList::const_iterator it = C.getActions().begin(),
1086 ie = C.getActions().end(); it != ie; ++it) {
1087 if (ContainsCompileAction(*it)) {
1088 RelaxDefault = true;
1094 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1098 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
1099 const InputInfo &Output,
1100 const InputInfoList &Inputs,
1101 const ArgList &Args,
1102 const char *LinkingOutput) const {
1103 bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1104 options::OPT_fapple_kext);
1105 const Driver &D = getToolChain().getDriver();
1106 ArgStringList CmdArgs;
1108 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1110 // Invoke ourselves in -cc1 mode.
1112 // FIXME: Implement custom jobs for internal actions.
1113 CmdArgs.push_back("-cc1");
1115 // Add the "effective" target triple.
1116 CmdArgs.push_back("-triple");
1117 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1118 CmdArgs.push_back(Args.MakeArgString(TripleStr));
1120 // Select the appropriate action.
1121 bool IsRewriter = false;
1122 if (isa<AnalyzeJobAction>(JA)) {
1123 assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1124 CmdArgs.push_back("-analyze");
1125 } else if (isa<PreprocessJobAction>(JA)) {
1126 if (Output.getType() == types::TY_Dependencies)
1127 CmdArgs.push_back("-Eonly");
1129 CmdArgs.push_back("-E");
1130 } else if (isa<AssembleJobAction>(JA)) {
1131 CmdArgs.push_back("-emit-obj");
1133 if (UseRelaxAll(C, Args))
1134 CmdArgs.push_back("-mrelax-all");
1136 // When using an integrated assembler, translate -Wa, and -Xassembler
1138 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1139 options::OPT_Xassembler),
1140 ie = Args.filtered_end(); it != ie; ++it) {
1144 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1145 StringRef Value = A->getValue(Args, i);
1147 if (Value == "-force_cpusubtype_ALL") {
1148 // Do nothing, this is the default and we don't support anything else.
1149 } else if (Value == "-L") {
1150 CmdArgs.push_back("-msave-temp-labels");
1151 } else if (Value == "--fatal-warnings") {
1152 CmdArgs.push_back("-mllvm");
1153 CmdArgs.push_back("-fatal-assembler-warnings");
1154 } else if (Value == "--noexecstack") {
1155 CmdArgs.push_back("-mnoexecstack");
1157 D.Diag(diag::err_drv_unsupported_option_argument)
1158 << A->getOption().getName() << Value;
1163 // Also ignore explicit -force_cpusubtype_ALL option.
1164 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
1165 } else if (isa<PrecompileJobAction>(JA)) {
1166 // Use PCH if the user requested it.
1167 bool UsePCH = D.CCCUsePCH;
1170 CmdArgs.push_back("-emit-pch");
1172 CmdArgs.push_back("-emit-pth");
1174 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
1176 if (JA.getType() == types::TY_Nothing) {
1177 CmdArgs.push_back("-fsyntax-only");
1178 } else if (JA.getType() == types::TY_LLVM_IR ||
1179 JA.getType() == types::TY_LTO_IR) {
1180 CmdArgs.push_back("-emit-llvm");
1181 } else if (JA.getType() == types::TY_LLVM_BC ||
1182 JA.getType() == types::TY_LTO_BC) {
1183 CmdArgs.push_back("-emit-llvm-bc");
1184 } else if (JA.getType() == types::TY_PP_Asm) {
1185 CmdArgs.push_back("-S");
1186 } else if (JA.getType() == types::TY_AST) {
1187 CmdArgs.push_back("-emit-pch");
1188 } else if (JA.getType() == types::TY_RewrittenObjC) {
1189 CmdArgs.push_back("-rewrite-objc");
1192 assert(JA.getType() == types::TY_PP_Asm &&
1193 "Unexpected output type!");
1197 // The make clang go fast button.
1198 CmdArgs.push_back("-disable-free");
1200 // Disable the verification pass in -asserts builds.
1202 CmdArgs.push_back("-disable-llvm-verifier");
1205 // Set the main file name, so that debug info works even with
1207 CmdArgs.push_back("-main-file-name");
1208 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
1210 // Some flags which affect the language (via preprocessor
1211 // defines). See darwin::CC1::AddCPPArgs.
1212 if (Args.hasArg(options::OPT_static))
1213 CmdArgs.push_back("-static-define");
1215 if (isa<AnalyzeJobAction>(JA)) {
1216 // Enable region store model by default.
1217 CmdArgs.push_back("-analyzer-store=region");
1219 // Treat blocks as analysis entry points.
1220 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1222 CmdArgs.push_back("-analyzer-eagerly-assume");
1224 // Add default argument set.
1225 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
1226 CmdArgs.push_back("-analyzer-checker=core");
1227 CmdArgs.push_back("-analyzer-checker=deadcode");
1228 CmdArgs.push_back("-analyzer-checker=security");
1230 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1231 CmdArgs.push_back("-analyzer-checker=unix");
1233 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
1234 CmdArgs.push_back("-analyzer-checker=osx");
1237 // Set the output format. The default is plist, for (lame) historical
1239 CmdArgs.push_back("-analyzer-output");
1240 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
1241 CmdArgs.push_back(A->getValue(Args));
1243 CmdArgs.push_back("plist");
1245 // Disable the presentation of standard compiler warnings when
1246 // using --analyze. We only want to show static analyzer diagnostics
1247 // or frontend errors.
1248 CmdArgs.push_back("-w");
1250 // Add -Xanalyzer arguments when running as analyzer.
1251 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
1254 CheckCodeGenerationOptions(D, Args);
1256 // Perform argument translation for LLVM backend. This
1257 // takes some care in reconciling with llvm-gcc. The
1258 // issue is that llvm-gcc translates these options based on
1259 // the values in cc1, whereas we are processing based on
1260 // the driver arguments.
1262 // This comes from the default translation the driver + cc1
1263 // would do to enable flag_pic.
1265 // FIXME: Centralize this code.
1266 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
1267 Args.hasArg(options::OPT_fpic) ||
1268 Args.hasArg(options::OPT_fPIE) ||
1269 Args.hasArg(options::OPT_fpie));
1270 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
1271 Args.hasArg(options::OPT_static));
1272 const char *Model = getToolChain().GetForcedPicModel();
1274 if (Args.hasArg(options::OPT_mdynamic_no_pic))
1275 Model = "dynamic-no-pic";
1276 else if (PICDisabled)
1278 else if (PICEnabled)
1281 Model = getToolChain().GetDefaultRelocationModel();
1283 if (StringRef(Model) != "pic") {
1284 CmdArgs.push_back("-mrelocation-model");
1285 CmdArgs.push_back(Model);
1288 // Infer the __PIC__ value.
1290 // FIXME: This isn't quite right on Darwin, which always sets
1292 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
1293 CmdArgs.push_back("-pic-level");
1294 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
1296 if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1297 options::OPT_fno_merge_all_constants))
1298 CmdArgs.push_back("-fno-merge-all-constants");
1300 // LLVM Code Generator Options.
1302 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1303 CmdArgs.push_back("-mregparm");
1304 CmdArgs.push_back(A->getValue(Args));
1307 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1308 CmdArgs.push_back("-mrtd");
1310 // FIXME: Set --enable-unsafe-fp-math.
1311 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
1312 options::OPT_fomit_frame_pointer))
1313 CmdArgs.push_back("-mdisable-fp-elim");
1314 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1315 options::OPT_fno_zero_initialized_in_bss))
1316 CmdArgs.push_back("-mno-zero-initialized-in-bss");
1317 if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1318 options::OPT_fno_strict_aliasing,
1319 getToolChain().IsStrictAliasingDefault()))
1320 CmdArgs.push_back("-relaxed-aliasing");
1322 // Decide whether to use verbose asm. Verbose assembly is the default on
1323 // toolchains which have the integrated assembler on by default.
1324 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
1325 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
1326 IsVerboseAsmDefault) ||
1327 Args.hasArg(options::OPT_dA))
1328 CmdArgs.push_back("-masm-verbose");
1330 if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
1331 CmdArgs.push_back("-mdebug-pass");
1332 CmdArgs.push_back("Structure");
1334 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
1335 CmdArgs.push_back("-mdebug-pass");
1336 CmdArgs.push_back("Arguments");
1339 // Enable -mconstructor-aliases except on darwin, where we have to
1340 // work around a linker bug; see <rdar://problem/7651567>.
1341 if (!getToolChain().getTriple().isOSDarwin())
1342 CmdArgs.push_back("-mconstructor-aliases");
1344 // Darwin's kernel doesn't support guard variables; just die if we
1346 if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
1347 CmdArgs.push_back("-fforbid-guard-variables");
1349 if (Args.hasArg(options::OPT_mms_bitfields)) {
1350 CmdArgs.push_back("-mms-bitfields");
1353 // This is a coarse approximation of what llvm-gcc actually does, both
1354 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
1355 // complicated ways.
1356 bool AsynchronousUnwindTables =
1357 Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
1358 options::OPT_fno_asynchronous_unwind_tables,
1359 getToolChain().IsUnwindTablesDefault() &&
1361 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
1362 AsynchronousUnwindTables))
1363 CmdArgs.push_back("-munwind-tables");
1365 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
1366 CmdArgs.push_back("-mlimit-float-precision");
1367 CmdArgs.push_back(A->getValue(Args));
1370 // FIXME: Handle -mtune=.
1371 (void) Args.hasArg(options::OPT_mtune_EQ);
1373 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
1374 CmdArgs.push_back("-mcode-model");
1375 CmdArgs.push_back(A->getValue(Args));
1378 // Add target specific cpu and features flags.
1379 switch(getToolChain().getTriple().getArch()) {
1383 case llvm::Triple::arm:
1384 case llvm::Triple::thumb:
1385 AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
1388 case llvm::Triple::mips:
1389 case llvm::Triple::mipsel:
1390 case llvm::Triple::mips64:
1391 case llvm::Triple::mips64el:
1392 AddMIPSTargetArgs(Args, CmdArgs);
1395 case llvm::Triple::sparc:
1396 AddSparcTargetArgs(Args, CmdArgs);
1399 case llvm::Triple::x86:
1400 case llvm::Triple::x86_64:
1401 AddX86TargetArgs(Args, CmdArgs);
1405 // Pass the linker version in use.
1406 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1407 CmdArgs.push_back("-target-linker-version");
1408 CmdArgs.push_back(A->getValue(Args));
1411 // -mno-omit-leaf-frame-pointer is the default on Darwin.
1412 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
1413 options::OPT_mno_omit_leaf_frame_pointer,
1414 !getToolChain().getTriple().isOSDarwin()))
1415 CmdArgs.push_back("-momit-leaf-frame-pointer");
1417 // -fno-math-errno is default.
1418 if (Args.hasFlag(options::OPT_fmath_errno,
1419 options::OPT_fno_math_errno,
1421 CmdArgs.push_back("-fmath-errno");
1423 // Explicitly error on some things we know we don't support and can't just
1425 types::ID InputType = Inputs[0].getType();
1426 if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1428 if ((Unsupported = Args.getLastArg(options::OPT_iframework)))
1429 D.Diag(diag::err_drv_clang_unsupported)
1430 << Unsupported->getOption().getName();
1432 if (types::isCXX(InputType) &&
1433 getToolChain().getTriple().isOSDarwin() &&
1434 getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1435 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
1436 (Unsupported = Args.getLastArg(options::OPT_mkernel)))
1437 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1438 << Unsupported->getOption().getName();
1442 Args.AddAllArgs(CmdArgs, options::OPT_v);
1443 Args.AddLastArg(CmdArgs, options::OPT_H);
1444 if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
1445 CmdArgs.push_back("-header-include-file");
1446 CmdArgs.push_back(D.CCPrintHeadersFilename ?
1447 D.CCPrintHeadersFilename : "-");
1449 Args.AddLastArg(CmdArgs, options::OPT_P);
1450 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
1452 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
1453 CmdArgs.push_back("-diagnostic-log-file");
1454 CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
1455 D.CCLogDiagnosticsFilename : "-");
1458 // Special case debug options to only pass -g to clang. This is
1460 Args.ClaimAllArgs(options::OPT_g_Group);
1461 if (Arg *A = Args.getLastArg(options::OPT_g_Group))
1462 if (!A->getOption().matches(options::OPT_g0))
1463 CmdArgs.push_back("-g");
1465 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1466 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1468 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
1470 if (Args.hasArg(options::OPT_ftest_coverage) ||
1471 Args.hasArg(options::OPT_coverage))
1472 CmdArgs.push_back("-femit-coverage-notes");
1473 if (Args.hasArg(options::OPT_fprofile_arcs) ||
1474 Args.hasArg(options::OPT_coverage))
1475 CmdArgs.push_back("-femit-coverage-data");
1477 if (C.getArgs().hasArg(options::OPT_c) ||
1478 C.getArgs().hasArg(options::OPT_S)) {
1479 if (Output.isFilename()) {
1480 CmdArgs.push_back("-coverage-file");
1481 CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
1485 // Pass options for controlling the default header search paths.
1486 if (Args.hasArg(options::OPT_nostdinc)) {
1487 CmdArgs.push_back("-nostdsysteminc");
1488 CmdArgs.push_back("-nobuiltininc");
1490 if (Args.hasArg(options::OPT_nostdlibinc))
1491 CmdArgs.push_back("-nostdsysteminc");
1492 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
1493 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
1496 // Pass the path to compiler resource files.
1497 CmdArgs.push_back("-resource-dir");
1498 CmdArgs.push_back(D.ResourceDir.c_str());
1500 Args.AddLastArg(CmdArgs, options::OPT_working_directory);
1502 if (!Args.hasArg(options::OPT_fno_objc_arc)) {
1503 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
1504 options::OPT_ccc_arcmt_modify,
1505 options::OPT_ccc_arcmt_migrate)) {
1506 switch (A->getOption().getID()) {
1508 llvm_unreachable("missed a case");
1509 case options::OPT_ccc_arcmt_check:
1510 CmdArgs.push_back("-arcmt-check");
1512 case options::OPT_ccc_arcmt_modify:
1513 CmdArgs.push_back("-arcmt-modify");
1515 case options::OPT_ccc_arcmt_migrate:
1516 CmdArgs.push_back("-arcmt-migrate");
1517 CmdArgs.push_back("-arcmt-migrate-directory");
1518 CmdArgs.push_back(A->getValue(Args));
1520 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
1521 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
1527 // Add preprocessing options like -I, -D, etc. if we are using the
1530 // FIXME: Support -fpreprocessed
1531 if (types::getPreprocessedType(InputType) != types::TY_INVALID)
1532 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
1534 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
1535 // that "The compiler can only warn and ignore the option if not recognized".
1536 // When building with ccache, it will pass -D options to clang even on
1537 // preprocessed inputs and configure concludes that -fPIC is not supported.
1538 Args.ClaimAllArgs(options::OPT_D);
1540 // Manually translate -O to -O2 and -O4 to -O3; let clang reject
1542 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1543 if (A->getOption().matches(options::OPT_O4))
1544 CmdArgs.push_back("-O3");
1545 else if (A->getOption().matches(options::OPT_O) &&
1546 A->getValue(Args)[0] == '\0')
1547 CmdArgs.push_back("-O2");
1549 A->render(Args, CmdArgs);
1552 Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
1553 Args.AddLastArg(CmdArgs, options::OPT_pedantic);
1554 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
1555 Args.AddLastArg(CmdArgs, options::OPT_w);
1557 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
1558 // (-ansi is equivalent to -std=c89).
1560 // If a std is supplied, only add -trigraphs if it follows the
1562 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1563 if (Std->getOption().matches(options::OPT_ansi))
1564 if (types::isCXX(InputType))
1565 CmdArgs.push_back("-std=c++98");
1567 CmdArgs.push_back("-std=c89");
1569 Std->render(Args, CmdArgs);
1571 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
1572 options::OPT_trigraphs))
1574 A->render(Args, CmdArgs);
1576 // Honor -std-default.
1578 // FIXME: Clang doesn't correctly handle -std= when the input language
1579 // doesn't match. For the time being just ignore this for C++ inputs;
1580 // eventually we want to do all the standard defaulting here instead of
1581 // splitting it between the driver and clang -cc1.
1582 if (!types::isCXX(InputType))
1583 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1584 "-std=", /*Joined=*/true);
1585 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
1588 // Map the bizarre '-Wwrite-strings' flag to a more sensible
1589 // '-fconst-strings'; this better indicates its actual behavior.
1590 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
1592 // For perfect compatibility with GCC, we do this even in the presence of
1593 // '-w'. This flag names something other than a warning for GCC.
1594 CmdArgs.push_back("-fconst-strings");
1597 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
1598 // during C++ compilation, which it is by default. GCC keeps this define even
1599 // in the presence of '-w', match this behavior bug-for-bug.
1600 if (types::isCXX(InputType) &&
1601 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
1603 CmdArgs.push_back("-fdeprecated-macro");
1606 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
1607 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
1608 if (Asm->getOption().matches(options::OPT_fasm))
1609 CmdArgs.push_back("-fgnu-keywords");
1611 CmdArgs.push_back("-fno-gnu-keywords");
1614 if (ShouldDisableCFI(Args, getToolChain()))
1615 CmdArgs.push_back("-fno-dwarf2-cfi-asm");
1617 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
1618 CmdArgs.push_back("-ftemplate-depth");
1619 CmdArgs.push_back(A->getValue(Args));
1622 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
1623 options::OPT_Wlarge_by_value_copy_def)) {
1624 CmdArgs.push_back("-Wlarge-by-value-copy");
1625 if (A->getNumValues())
1626 CmdArgs.push_back(A->getValue(Args));
1628 CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy.
1631 if (Args.hasArg(options::OPT__relocatable_pch))
1632 CmdArgs.push_back("-relocatable-pch");
1634 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
1635 CmdArgs.push_back("-fconstant-string-class");
1636 CmdArgs.push_back(A->getValue(Args));
1639 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
1640 CmdArgs.push_back("-ftabstop");
1641 CmdArgs.push_back(A->getValue(Args));
1644 CmdArgs.push_back("-ferror-limit");
1645 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
1646 CmdArgs.push_back(A->getValue(Args));
1648 CmdArgs.push_back("19");
1650 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
1651 CmdArgs.push_back("-fmacro-backtrace-limit");
1652 CmdArgs.push_back(A->getValue(Args));
1655 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
1656 CmdArgs.push_back("-ftemplate-backtrace-limit");
1657 CmdArgs.push_back(A->getValue(Args));
1660 // Pass -fmessage-length=.
1661 CmdArgs.push_back("-fmessage-length");
1662 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
1663 CmdArgs.push_back(A->getValue(Args));
1665 // If -fmessage-length=N was not specified, determine whether this is a
1666 // terminal and, if so, implicitly define -fmessage-length appropriately.
1667 unsigned N = llvm::sys::Process::StandardErrColumns();
1668 CmdArgs.push_back(Args.MakeArgString(Twine(N)));
1671 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
1672 CmdArgs.push_back("-fvisibility");
1673 CmdArgs.push_back(A->getValue(Args));
1676 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
1678 // -fhosted is default.
1679 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
1680 options::OPT_fhosted,
1682 CmdArgs.push_back("-ffreestanding");
1684 // Forward -f (flag) options which we can pass directly.
1685 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
1686 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
1687 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
1688 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
1689 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
1690 if (getToolChain().SupportsProfiling())
1691 Args.AddLastArg(CmdArgs, options::OPT_pg);
1693 // -flax-vector-conversions is default.
1694 if (!Args.hasFlag(options::OPT_flax_vector_conversions,
1695 options::OPT_fno_lax_vector_conversions))
1696 CmdArgs.push_back("-fno-lax-vector-conversions");
1698 if (Args.getLastArg(options::OPT_fapple_kext))
1699 CmdArgs.push_back("-fapple-kext");
1701 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
1702 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
1703 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
1704 Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
1705 Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
1707 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
1708 CmdArgs.push_back("-ftrapv-handler");
1709 CmdArgs.push_back(A->getValue(Args));
1712 // Forward -ftrap_function= options to the backend.
1713 if (Arg *A = Args.getLastArg(options::OPT_ftrap_function_EQ)) {
1714 StringRef FuncName = A->getValue(Args);
1715 CmdArgs.push_back("-backend-option");
1716 CmdArgs.push_back(Args.MakeArgString("-trap-func=" + FuncName));
1719 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
1720 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
1721 if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
1722 options::OPT_fno_wrapv)) {
1723 if (A->getOption().matches(options::OPT_fwrapv))
1724 CmdArgs.push_back("-fwrapv");
1725 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
1726 options::OPT_fno_strict_overflow)) {
1727 if (A->getOption().matches(options::OPT_fno_strict_overflow))
1728 CmdArgs.push_back("-fwrapv");
1730 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
1731 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
1733 Args.AddLastArg(CmdArgs, options::OPT_pthread);
1735 // -stack-protector=0 is default.
1736 unsigned StackProtectorLevel = 0;
1737 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
1738 options::OPT_fstack_protector_all,
1739 options::OPT_fstack_protector)) {
1740 if (A->getOption().matches(options::OPT_fstack_protector))
1741 StackProtectorLevel = 1;
1742 else if (A->getOption().matches(options::OPT_fstack_protector_all))
1743 StackProtectorLevel = 2;
1745 StackProtectorLevel =
1746 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
1748 if (StackProtectorLevel) {
1749 CmdArgs.push_back("-stack-protector");
1750 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
1753 // Translate -mstackrealign
1754 if (Args.hasArg(options::OPT_mstackrealign)) {
1755 CmdArgs.push_back("-backend-option");
1756 CmdArgs.push_back("-force-align-stack");
1759 // Forward -f options with positive and negative forms; we translate
1762 if (Args.hasArg(options::OPT_mkernel)) {
1763 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
1764 CmdArgs.push_back("-fapple-kext");
1765 if (!Args.hasArg(options::OPT_fbuiltin))
1766 CmdArgs.push_back("-fno-builtin");
1768 // -fbuiltin is default.
1769 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
1770 CmdArgs.push_back("-fno-builtin");
1772 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1773 options::OPT_fno_assume_sane_operator_new))
1774 CmdArgs.push_back("-fno-assume-sane-operator-new");
1776 // -fblocks=0 is default.
1777 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
1778 getToolChain().IsBlocksDefault()) ||
1779 (Args.hasArg(options::OPT_fgnu_runtime) &&
1780 Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
1781 !Args.hasArg(options::OPT_fno_blocks))) {
1782 CmdArgs.push_back("-fblocks");
1784 if (!Args.hasArg(options::OPT_fgnu_runtime) &&
1785 !getToolChain().hasBlocksRuntime())
1786 CmdArgs.push_back("-fblocks-runtime-optional");
1789 // -faccess-control is default.
1790 if (Args.hasFlag(options::OPT_fno_access_control,
1791 options::OPT_faccess_control,
1793 CmdArgs.push_back("-fno-access-control");
1795 // -felide-constructors is the default.
1796 if (Args.hasFlag(options::OPT_fno_elide_constructors,
1797 options::OPT_felide_constructors,
1799 CmdArgs.push_back("-fno-elide-constructors");
1801 // -frtti is default.
1803 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
1804 CmdArgs.push_back("-fno-rtti");
1806 // -fshort-enums=0 is default.
1807 // FIXME: Are there targers where -fshort-enums is on by default ?
1808 if (Args.hasFlag(options::OPT_fshort_enums,
1809 options::OPT_fno_short_enums, false))
1810 CmdArgs.push_back("-fshort-enums");
1812 // -fsigned-char is default.
1813 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
1814 isSignedCharDefault(getToolChain().getTriple())))
1815 CmdArgs.push_back("-fno-signed-char");
1817 // -fthreadsafe-static is default.
1818 if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
1819 options::OPT_fno_threadsafe_statics))
1820 CmdArgs.push_back("-fno-threadsafe-statics");
1822 // -fuse-cxa-atexit is default.
1824 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
1825 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
1826 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
1827 CmdArgs.push_back("-fno-use-cxa-atexit");
1829 // -fms-extensions=0 is default.
1830 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1831 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1832 CmdArgs.push_back("-fms-extensions");
1834 // -fms-compatibility=0 is default.
1835 if (Args.hasFlag(options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
1836 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1837 CmdArgs.push_back("-fms-compatibility");
1839 // -fmsc-version=1300 is default.
1840 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1841 getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
1842 Args.hasArg(options::OPT_fmsc_version)) {
1843 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
1844 if (msc_ver.empty())
1845 CmdArgs.push_back("-fmsc-version=1300");
1847 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
1851 // -fborland-extensions=0 is default.
1852 if (Args.hasFlag(options::OPT_fborland_extensions,
1853 options::OPT_fno_borland_extensions, false))
1854 CmdArgs.push_back("-fborland-extensions");
1856 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
1858 if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
1859 options::OPT_fno_delayed_template_parsing,
1860 getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1861 CmdArgs.push_back("-fdelayed-template-parsing");
1863 // -fgnu-keywords default varies depending on language; only pass if
1865 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
1866 options::OPT_fno_gnu_keywords))
1867 A->render(Args, CmdArgs);
1869 if (Args.hasFlag(options::OPT_fgnu89_inline,
1870 options::OPT_fno_gnu89_inline,
1872 CmdArgs.push_back("-fgnu89-inline");
1874 // -fobjc-nonfragile-abi=0 is default.
1875 ObjCRuntime objCRuntime;
1876 unsigned objcABIVersion = 0;
1877 bool NeXTRuntimeIsDefault
1878 = (IsRewriter || getToolChain().getTriple().isOSDarwin());
1879 if (Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
1880 NeXTRuntimeIsDefault)) {
1881 objCRuntime.setKind(ObjCRuntime::NeXT);
1883 CmdArgs.push_back("-fgnu-runtime");
1884 objCRuntime.setKind(ObjCRuntime::GNU);
1886 getToolChain().configureObjCRuntime(objCRuntime);
1887 if (objCRuntime.HasARC)
1888 CmdArgs.push_back("-fobjc-runtime-has-arc");
1889 if (objCRuntime.HasWeak)
1890 CmdArgs.push_back("-fobjc-runtime-has-weak");
1891 if (objCRuntime.HasTerminate)
1892 CmdArgs.push_back("-fobjc-runtime-has-terminate");
1894 // Compute the Objective-C ABI "version" to use. Version numbers are
1895 // slightly confusing for historical reasons:
1896 // 1 - Traditional "fragile" ABI
1897 // 2 - Non-fragile ABI, version 1
1898 // 3 - Non-fragile ABI, version 2
1900 // If -fobjc-abi-version= is present, use that to set the version.
1901 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
1902 if (StringRef(A->getValue(Args)) == "1")
1904 else if (StringRef(A->getValue(Args)) == "2")
1906 else if (StringRef(A->getValue(Args)) == "3")
1909 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
1911 // Otherwise, determine if we are using the non-fragile ABI.
1912 bool NonFragileABIIsDefault
1913 = (!IsRewriter && getToolChain().IsObjCNonFragileABIDefault());
1914 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
1915 options::OPT_fno_objc_nonfragile_abi,
1916 NonFragileABIIsDefault)) {
1917 // Determine the non-fragile ABI version to use.
1918 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
1919 unsigned NonFragileABIVersion = 1;
1921 unsigned NonFragileABIVersion = 2;
1924 if (Arg *A = Args.getLastArg(
1925 options::OPT_fobjc_nonfragile_abi_version_EQ)) {
1926 if (StringRef(A->getValue(Args)) == "1")
1927 NonFragileABIVersion = 1;
1928 else if (StringRef(A->getValue(Args)) == "2")
1929 NonFragileABIVersion = 2;
1931 D.Diag(diag::err_drv_clang_unsupported)
1932 << A->getAsString(Args);
1935 objcABIVersion = 1 + NonFragileABIVersion;
1941 if (objcABIVersion == 1) {
1942 CmdArgs.push_back("-fobjc-fragile-abi");
1944 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
1945 // legacy is the default.
1946 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
1947 options::OPT_fno_objc_legacy_dispatch,
1948 getToolChain().IsObjCLegacyDispatchDefault())) {
1949 if (getToolChain().UseObjCMixedDispatch())
1950 CmdArgs.push_back("-fobjc-dispatch-method=mixed");
1952 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
1956 // -fobjc-default-synthesize-properties=0 is default.
1957 if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties,
1958 options::OPT_fno_objc_default_synthesize_properties,
1959 getToolChain().IsObjCDefaultSynthPropertiesDefault())) {
1960 CmdArgs.push_back("-fobjc-default-synthesize-properties");
1963 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
1964 // NOTE: This logic is duplicated in ToolChains.cpp.
1965 bool ARC = isObjCAutoRefCount(Args);
1967 CmdArgs.push_back("-fobjc-arc");
1969 // Allow the user to enable full exceptions code emission.
1970 // We define off for Objective-CC, on for Objective-C++.
1971 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
1972 options::OPT_fno_objc_arc_exceptions,
1973 /*default*/ types::isCXX(InputType)))
1974 CmdArgs.push_back("-fobjc-arc-exceptions");
1977 // -fobjc-infer-related-result-type is the default, except in the Objective-C
1980 CmdArgs.push_back("-fno-objc-infer-related-result-type");
1982 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
1983 // takes precedence.
1984 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
1986 GCArg = Args.getLastArg(options::OPT_fobjc_gc);
1989 D.Diag(diag::err_drv_objc_gc_arr)
1990 << GCArg->getAsString(Args);
1991 } else if (getToolChain().SupportsObjCGC()) {
1992 GCArg->render(Args, CmdArgs);
1994 // FIXME: We should move this to a hard error.
1995 D.Diag(diag::warn_drv_objc_gc_unsupported)
1996 << GCArg->getAsString(Args);
2000 // Add exception args.
2001 addExceptionArgs(Args, InputType, getToolChain().getTriple(),
2002 KernelOrKext, IsRewriter, objcABIVersion, CmdArgs);
2004 if (getToolChain().UseSjLjExceptions())
2005 CmdArgs.push_back("-fsjlj-exceptions");
2007 // C++ "sane" operator new.
2008 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2009 options::OPT_fno_assume_sane_operator_new))
2010 CmdArgs.push_back("-fno-assume-sane-operator-new");
2012 // -fconstant-cfstrings is default, and may be subject to argument translation
2014 if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2015 options::OPT_fno_constant_cfstrings) ||
2016 !Args.hasFlag(options::OPT_mconstant_cfstrings,
2017 options::OPT_mno_constant_cfstrings))
2018 CmdArgs.push_back("-fno-constant-cfstrings");
2020 // -fshort-wchar default varies depending on platform; only
2021 // pass if specified.
2022 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2023 A->render(Args, CmdArgs);
2025 // -fno-pascal-strings is default, only pass non-default. If the tool chain
2026 // happened to translate to -mpascal-strings, we want to back translate here.
2028 // FIXME: This is gross; that translation should be pulled from the
2030 if (Args.hasFlag(options::OPT_fpascal_strings,
2031 options::OPT_fno_pascal_strings,
2033 Args.hasFlag(options::OPT_mpascal_strings,
2034 options::OPT_mno_pascal_strings,
2036 CmdArgs.push_back("-fpascal-strings");
2038 // Honor -fpack-struct= and -fpack-struct, if given. Note that
2039 // -fno-pack-struct doesn't apply to -fpack-struct=.
2040 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
2041 CmdArgs.push_back("-fpack-struct");
2042 CmdArgs.push_back(A->getValue(Args));
2043 } else if (Args.hasFlag(options::OPT_fpack_struct,
2044 options::OPT_fno_pack_struct, false)) {
2045 CmdArgs.push_back("-fpack-struct");
2046 CmdArgs.push_back("1");
2049 if (Args.hasArg(options::OPT_mkernel) ||
2050 Args.hasArg(options::OPT_fapple_kext)) {
2051 if (!Args.hasArg(options::OPT_fcommon))
2052 CmdArgs.push_back("-fno-common");
2055 // -fcommon is default, only pass non-default.
2056 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
2057 CmdArgs.push_back("-fno-common");
2059 // -fsigned-bitfields is default, and clang doesn't yet support
2060 // -funsigned-bitfields.
2061 if (!Args.hasFlag(options::OPT_fsigned_bitfields,
2062 options::OPT_funsigned_bitfields))
2063 D.Diag(diag::warn_drv_clang_unsupported)
2064 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2066 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2067 if (!Args.hasFlag(options::OPT_ffor_scope,
2068 options::OPT_fno_for_scope))
2069 D.Diag(diag::err_drv_clang_unsupported)
2070 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2072 // -fcaret-diagnostics is default.
2073 if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2074 options::OPT_fno_caret_diagnostics, true))
2075 CmdArgs.push_back("-fno-caret-diagnostics");
2077 // -fdiagnostics-fixit-info is default, only pass non-default.
2078 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
2079 options::OPT_fno_diagnostics_fixit_info))
2080 CmdArgs.push_back("-fno-diagnostics-fixit-info");
2082 // Enable -fdiagnostics-show-name by default.
2083 if (Args.hasFlag(options::OPT_fdiagnostics_show_name,
2084 options::OPT_fno_diagnostics_show_name, false))
2085 CmdArgs.push_back("-fdiagnostics-show-name");
2087 // Enable -fdiagnostics-show-option by default.
2088 if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
2089 options::OPT_fno_diagnostics_show_option))
2090 CmdArgs.push_back("-fdiagnostics-show-option");
2093 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2094 CmdArgs.push_back("-fdiagnostics-show-category");
2095 CmdArgs.push_back(A->getValue(Args));
2099 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2100 CmdArgs.push_back("-fdiagnostics-format");
2101 CmdArgs.push_back(A->getValue(Args));
2104 if (Arg *A = Args.getLastArg(
2105 options::OPT_fdiagnostics_show_note_include_stack,
2106 options::OPT_fno_diagnostics_show_note_include_stack)) {
2107 if (A->getOption().matches(
2108 options::OPT_fdiagnostics_show_note_include_stack))
2109 CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2111 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2114 // Color diagnostics are the default, unless the terminal doesn't support
2116 if (Args.hasFlag(options::OPT_fcolor_diagnostics,
2117 options::OPT_fno_color_diagnostics,
2118 llvm::sys::Process::StandardErrHasColors()))
2119 CmdArgs.push_back("-fcolor-diagnostics");
2121 if (!Args.hasFlag(options::OPT_fshow_source_location,
2122 options::OPT_fno_show_source_location))
2123 CmdArgs.push_back("-fno-show-source-location");
2125 if (!Args.hasFlag(options::OPT_fshow_column,
2126 options::OPT_fno_show_column,
2128 CmdArgs.push_back("-fno-show-column");
2130 if (!Args.hasFlag(options::OPT_fspell_checking,
2131 options::OPT_fno_spell_checking))
2132 CmdArgs.push_back("-fno-spell-checking");
2135 // Silently ignore -fasm-blocks for now.
2136 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2139 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2140 A->render(Args, CmdArgs);
2142 // -fdollars-in-identifiers default varies depending on platform and
2143 // language; only pass if specified.
2144 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
2145 options::OPT_fno_dollars_in_identifiers)) {
2146 if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
2147 CmdArgs.push_back("-fdollars-in-identifiers");
2149 CmdArgs.push_back("-fno-dollars-in-identifiers");
2152 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
2153 // practical purposes.
2154 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
2155 options::OPT_fno_unit_at_a_time)) {
2156 if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
2157 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
2160 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
2162 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
2164 if (getToolChain().getTriple().isOSDarwin() &&
2165 (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2166 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
2167 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2168 CmdArgs.push_back("-fno-builtin-strcat");
2169 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2170 CmdArgs.push_back("-fno-builtin-strcpy");
2174 // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
2175 if (Arg *A = Args.getLastArg(options::OPT_traditional,
2176 options::OPT_traditional_cpp)) {
2177 if (isa<PreprocessJobAction>(JA))
2178 CmdArgs.push_back("-traditional-cpp");
2180 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
2183 Args.AddLastArg(CmdArgs, options::OPT_dM);
2184 Args.AddLastArg(CmdArgs, options::OPT_dD);
2186 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
2188 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
2189 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
2190 ie = Args.filtered_end(); it != ie; ++it) {
2193 // We translate this by hand to the -cc1 argument, since nightly test uses
2194 // it and developers have been trained to spell it with -mllvm.
2195 if (StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
2196 CmdArgs.push_back("-disable-llvm-optzns");
2198 (*it)->render(Args, CmdArgs);
2201 if (Output.getType() == types::TY_Dependencies) {
2202 // Handled with other dependency code.
2203 } else if (Output.isFilename()) {
2204 CmdArgs.push_back("-o");
2205 CmdArgs.push_back(Output.getFilename());
2207 assert(Output.isNothing() && "Invalid output.");
2210 for (InputInfoList::const_iterator
2211 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2212 const InputInfo &II = *it;
2213 CmdArgs.push_back("-x");
2214 CmdArgs.push_back(types::getTypeName(II.getType()));
2215 if (II.isFilename())
2216 CmdArgs.push_back(II.getFilename());
2218 II.getInputArg().renderAsInput(Args, CmdArgs);
2221 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2223 const char *Exec = getToolChain().getDriver().getClangProgramPath();
2225 // Optionally embed the -cc1 level arguments into the debug info, for build
2227 if (getToolChain().UseDwarfDebugFlags()) {
2228 ArgStringList OriginalArgs;
2229 for (ArgList::const_iterator it = Args.begin(),
2230 ie = Args.end(); it != ie; ++it)
2231 (*it)->render(Args, OriginalArgs);
2233 llvm::SmallString<256> Flags;
2235 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
2237 Flags += OriginalArgs[i];
2239 CmdArgs.push_back("-dwarf-debug-flags");
2240 CmdArgs.push_back(Args.MakeArgString(Flags.str()));
2243 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2245 if (Arg *A = Args.getLastArg(options::OPT_pg))
2246 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2247 D.Diag(diag::err_drv_argument_not_allowed_with)
2248 << "-fomit-frame-pointer" << A->getAsString(Args);
2250 // Claim some arguments which clang supports automatically.
2252 // -fpch-preprocess is used with gcc to add a special marker in the output to
2253 // include the PCH file. Clang's PTH solution is completely transparent, so we
2254 // do not need to deal with it at all.
2255 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
2257 // Claim some arguments which clang doesn't support, but we don't
2258 // care to warn the user about.
2259 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
2260 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
2262 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
2263 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
2264 Args.ClaimAllArgs(options::OPT_emit_llvm);
2267 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
2268 const InputInfo &Output,
2269 const InputInfoList &Inputs,
2270 const ArgList &Args,
2271 const char *LinkingOutput) const {
2272 ArgStringList CmdArgs;
2274 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2275 const InputInfo &Input = Inputs[0];
2277 // Don't warn about "clang -w -c foo.s"
2278 Args.ClaimAllArgs(options::OPT_w);
2279 // and "clang -emit-llvm -c foo.s"
2280 Args.ClaimAllArgs(options::OPT_emit_llvm);
2281 // and "clang -use-gold-plugin -c foo.s"
2282 Args.ClaimAllArgs(options::OPT_use_gold_plugin);
2284 // Invoke ourselves in -cc1as mode.
2286 // FIXME: Implement custom jobs for internal actions.
2287 CmdArgs.push_back("-cc1as");
2289 // Add the "effective" target triple.
2290 CmdArgs.push_back("-triple");
2291 std::string TripleStr =
2292 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
2293 CmdArgs.push_back(Args.MakeArgString(TripleStr));
2295 // Set the output mode, we currently only expect to be used as a real
2297 CmdArgs.push_back("-filetype");
2298 CmdArgs.push_back("obj");
2300 if (UseRelaxAll(C, Args))
2301 CmdArgs.push_back("-relax-all");
2303 // Ignore explicit -force_cpusubtype_ALL option.
2304 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2306 // FIXME: Add -g support, once we have it.
2308 // FIXME: Add -static support, once we have it.
2310 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2311 options::OPT_Xassembler);
2312 Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
2314 assert(Output.isFilename() && "Unexpected lipo output.");
2315 CmdArgs.push_back("-o");
2316 CmdArgs.push_back(Output.getFilename());
2318 assert(Input.isFilename() && "Invalid input.");
2319 CmdArgs.push_back(Input.getFilename());
2321 const char *Exec = getToolChain().getDriver().getClangProgramPath();
2322 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2325 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
2326 const InputInfo &Output,
2327 const InputInfoList &Inputs,
2328 const ArgList &Args,
2329 const char *LinkingOutput) const {
2330 const Driver &D = getToolChain().getDriver();
2331 ArgStringList CmdArgs;
2333 for (ArgList::const_iterator
2334 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
2336 if (A->getOption().hasForwardToGCC()) {
2337 // Don't forward any -g arguments to assembly steps.
2338 if (isa<AssembleJobAction>(JA) &&
2339 A->getOption().matches(options::OPT_g_Group))
2342 // It is unfortunate that we have to claim here, as this means
2343 // we will basically never report anything interesting for
2344 // platforms using a generic gcc, even if we are just using gcc
2345 // to get to the assembler.
2347 A->render(Args, CmdArgs);
2351 RenderExtraToolArgs(JA, CmdArgs);
2353 // If using a driver driver, force the arch.
2354 const std::string &Arch = getToolChain().getArchName();
2355 if (getToolChain().getTriple().isOSDarwin()) {
2356 CmdArgs.push_back("-arch");
2358 // FIXME: Remove these special cases.
2359 if (Arch == "powerpc")
2360 CmdArgs.push_back("ppc");
2361 else if (Arch == "powerpc64")
2362 CmdArgs.push_back("ppc64");
2364 CmdArgs.push_back(Args.MakeArgString(Arch));
2367 // Try to force gcc to match the tool chain we want, if we recognize
2370 // FIXME: The triple class should directly provide the information we want
2372 if (Arch == "i386" || Arch == "powerpc")
2373 CmdArgs.push_back("-m32");
2374 else if (Arch == "x86_64" || Arch == "powerpc64")
2375 CmdArgs.push_back("-m64");
2377 if (Output.isFilename()) {
2378 CmdArgs.push_back("-o");
2379 CmdArgs.push_back(Output.getFilename());
2381 assert(Output.isNothing() && "Unexpected output");
2382 CmdArgs.push_back("-fsyntax-only");
2386 // Only pass -x if gcc will understand it; otherwise hope gcc
2387 // understands the suffix correctly. The main use case this would go
2388 // wrong in is for linker inputs if they happened to have an odd
2389 // suffix; really the only way to get this to happen is a command
2390 // like '-x foobar a.c' which will treat a.c like a linker input.
2392 // FIXME: For the linker case specifically, can we safely convert
2393 // inputs into '-Wl,' options?
2394 for (InputInfoList::const_iterator
2395 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2396 const InputInfo &II = *it;
2398 // Don't try to pass LLVM or AST inputs to a generic gcc.
2399 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
2400 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
2401 D.Diag(diag::err_drv_no_linker_llvm_support)
2402 << getToolChain().getTripleString();
2403 else if (II.getType() == types::TY_AST)
2404 D.Diag(diag::err_drv_no_ast_support)
2405 << getToolChain().getTripleString();
2407 if (types::canTypeBeUserSpecified(II.getType())) {
2408 CmdArgs.push_back("-x");
2409 CmdArgs.push_back(types::getTypeName(II.getType()));
2412 if (II.isFilename())
2413 CmdArgs.push_back(II.getFilename());
2415 const Arg &A = II.getInputArg();
2417 // Reverse translate some rewritten options.
2418 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
2419 CmdArgs.push_back("-lstdc++");
2423 // Don't render as input, we need gcc to do the translations.
2424 A.render(Args, CmdArgs);
2428 const std::string customGCCName = D.getCCCGenericGCCName();
2429 const char *GCCName;
2430 if (!customGCCName.empty())
2431 GCCName = customGCCName.c_str();
2432 else if (D.CCCIsCXX) {
2434 // FIXME: Detect the version of Cygwin at runtime?
2443 Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
2444 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2447 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
2448 ArgStringList &CmdArgs) const {
2449 CmdArgs.push_back("-E");
2452 void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
2453 ArgStringList &CmdArgs) const {
2454 // The type is good enough.
2457 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
2458 ArgStringList &CmdArgs) const {
2459 const Driver &D = getToolChain().getDriver();
2461 // If -flto, etc. are present then make sure not to force assembly output.
2462 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
2463 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
2464 CmdArgs.push_back("-c");
2466 if (JA.getType() != types::TY_PP_Asm)
2467 D.Diag(diag::err_drv_invalid_gcc_output_type)
2468 << getTypeName(JA.getType());
2470 CmdArgs.push_back("-S");
2474 void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
2475 ArgStringList &CmdArgs) const {
2476 CmdArgs.push_back("-c");
2479 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
2480 ArgStringList &CmdArgs) const {
2481 // The types are (hopefully) good enough.
2484 const char *darwin::CC1::getCC1Name(types::ID Type) const {
2487 llvm_unreachable("Unexpected type for Darwin CC1 tool.");
2489 case types::TY_C: case types::TY_CHeader:
2490 case types::TY_PP_C: case types::TY_PP_CHeader:
2492 case types::TY_ObjC: case types::TY_ObjCHeader:
2493 case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias:
2494 case types::TY_PP_ObjCHeader:
2496 case types::TY_CXX: case types::TY_CXXHeader:
2497 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
2499 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
2500 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias:
2501 case types::TY_PP_ObjCXXHeader:
2502 return "cc1objplus";
2506 const char *darwin::CC1::getBaseInputName(const ArgList &Args,
2507 const InputInfoList &Inputs) {
2508 return Args.MakeArgString(
2509 llvm::sys::path::filename(Inputs[0].getBaseInput()));
2512 const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
2513 const InputInfoList &Inputs) {
2514 const char *Str = getBaseInputName(Args, Inputs);
2516 if (const char *End = strrchr(Str, '.'))
2517 return Args.MakeArgString(std::string(Str, End));
2523 darwin::CC1::getDependencyFileName(const ArgList &Args,
2524 const InputInfoList &Inputs) {
2525 // FIXME: Think about this more.
2528 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2529 std::string Str(OutputOpt->getValue(Args));
2530 Res = Str.substr(0, Str.rfind('.'));
2532 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
2534 return Args.MakeArgString(Res + ".d");
2537 void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const {
2538 for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end();
2541 StringRef Option = *it;
2542 bool RemoveOption = false;
2545 if (Option.equals("-faltivec")) {
2546 it = CmdArgs.erase(it);
2551 // Handle machine specific options.
2552 if (Option.startswith("-m")) {
2553 RemoveOption = llvm::StringSwitch<bool>(Option)
2554 .Case("-mthumb", true)
2555 .Case("-mno-thumb", true)
2556 .Case("-mno-fused-madd", true)
2557 .Case("-mlong-branch", true)
2558 .Case("-mlongcall", true)
2559 .Case("-mcpu=G4", true)
2560 .Case("-mcpu=G5", true)
2564 // Handle warning options.
2565 if (Option.startswith("-W")) {
2566 // Remove -W/-Wno- to reduce the number of cases.
2567 if (Option.startswith("-Wno-"))
2568 Option = Option.substr(5);
2570 Option = Option.substr(2);
2572 RemoveOption = llvm::StringSwitch<bool>(Option)
2573 .Case("address-of-temporary", true)
2574 .Case("ambiguous-member-template", true)
2575 .Case("analyzer-incompatible-plugin", true)
2576 .Case("array-bounds", true)
2577 .Case("array-bounds-pointer-arithmetic", true)
2578 .Case("bind-to-temporary-copy", true)
2579 .Case("bitwise-op-parentheses", true)
2580 .Case("bool-conversions", true)
2581 .Case("builtin-macro-redefined", true)
2582 .Case("c++-hex-floats", true)
2583 .Case("c++0x-compat", true)
2584 .Case("c++0x-extensions", true)
2585 .Case("c++0x-narrowing", true)
2586 .Case("c++11-compat", true)
2587 .Case("c++11-extensions", true)
2588 .Case("c++11-narrowing", true)
2589 .Case("conditional-uninitialized", true)
2590 .Case("constant-conversion", true)
2591 .Case("CFString-literal", true)
2592 .Case("constant-logical-operand", true)
2593 .Case("custom-atomic-properties", true)
2594 .Case("default-arg-special-member", true)
2595 .Case("delegating-ctor-cycles", true)
2596 .Case("delete-non-virtual-dtor", true)
2597 .Case("deprecated-implementations", true)
2598 .Case("deprecated-writable-strings", true)
2599 .Case("distributed-object-modifiers", true)
2600 .Case("duplicate-method-arg", true)
2601 .Case("dynamic-class-memaccess", true)
2602 .Case("enum-compare", true)
2603 .Case("exit-time-destructors", true)
2605 .Case("gnu-designator", true)
2606 .Case("header-hygiene", true)
2607 .Case("idiomatic-parentheses", true)
2608 .Case("ignored-qualifiers", true)
2609 .Case("implicit-atomic-properties", true)
2610 .Case("incompatible-pointer-types", true)
2611 .Case("incomplete-implementation", true)
2612 .Case("initializer-overrides", true)
2613 .Case("invalid-noreturn", true)
2614 .Case("invalid-token-paste", true)
2615 .Case("language-extension-token", true)
2616 .Case("literal-conversion", true)
2617 .Case("literal-range", true)
2618 .Case("local-type-template-args", true)
2619 .Case("logical-op-parentheses", true)
2620 .Case("method-signatures", true)
2621 .Case("microsoft", true)
2622 .Case("mismatched-tags", true)
2623 .Case("missing-method-return-type", true)
2624 .Case("non-pod-varargs", true)
2625 .Case("nonfragile-abi2", true)
2626 .Case("null-arithmetic", true)
2627 .Case("null-dereference", true)
2628 .Case("out-of-line-declaration", true)
2629 .Case("overriding-method-mismatch", true)
2630 .Case("readonly-setter-attrs", true)
2631 .Case("return-stack-address", true)
2632 .Case("self-assign", true)
2633 .Case("semicolon-before-method-body", true)
2634 .Case("sentinel", true)
2635 .Case("shift-overflow", true)
2636 .Case("shift-sign-overflow", true)
2637 .Case("sign-conversion", true)
2638 .Case("sizeof-array-argument", true)
2639 .Case("sizeof-pointer-memaccess", true)
2640 .Case("string-compare", true)
2641 .Case("super-class-method-mismatch", true)
2642 .Case("tautological-compare", true)
2643 .Case("typedef-redefinition", true)
2644 .Case("typename-missing", true)
2645 .Case("undefined-reinterpret-cast", true)
2646 .Case("unknown-warning-option", true)
2647 .Case("unnamed-type-template-args", true)
2648 .Case("unneeded-internal-declaration", true)
2649 .Case("unneeded-member-function", true)
2650 .Case("unused-comparison", true)
2651 .Case("unused-exception-parameter", true)
2652 .Case("unused-member-function", true)
2653 .Case("unused-result", true)
2654 .Case("vector-conversions", true)
2656 .Case("used-but-marked-unused", true)
2657 .Case("weak-vtables", true)
2659 } // if (Option.startswith("-W"))
2661 it = CmdArgs.erase(it);
2669 void darwin::CC1::AddCC1Args(const ArgList &Args,
2670 ArgStringList &CmdArgs) const {
2671 const Driver &D = getToolChain().getDriver();
2673 CheckCodeGenerationOptions(D, Args);
2675 // Derived from cc1 spec.
2676 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
2677 !Args.hasArg(options::OPT_mdynamic_no_pic))
2678 CmdArgs.push_back("-fPIC");
2680 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2681 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2682 if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2683 CmdArgs.push_back("-fno-builtin-strcat");
2684 if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2685 CmdArgs.push_back("-fno-builtin-strcpy");
2688 if (Args.hasArg(options::OPT_g_Flag) &&
2689 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
2690 CmdArgs.push_back("-feliminate-unused-debug-symbols");
2693 void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2694 const InputInfoList &Inputs,
2695 const ArgStringList &OutputArgs) const {
2696 const Driver &D = getToolChain().getDriver();
2698 // Derived from cc1_options spec.
2699 if (Args.hasArg(options::OPT_fast) ||
2700 Args.hasArg(options::OPT_fastf) ||
2701 Args.hasArg(options::OPT_fastcp))
2702 CmdArgs.push_back("-O3");
2704 if (Arg *A = Args.getLastArg(options::OPT_pg))
2705 if (Args.hasArg(options::OPT_fomit_frame_pointer))
2706 D.Diag(diag::err_drv_argument_not_allowed_with)
2707 << A->getAsString(Args) << "-fomit-frame-pointer";
2709 AddCC1Args(Args, CmdArgs);
2711 if (!Args.hasArg(options::OPT_Q))
2712 CmdArgs.push_back("-quiet");
2714 CmdArgs.push_back("-dumpbase");
2715 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
2717 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2719 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2720 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
2722 // FIXME: The goal is to use the user provided -o if that is our
2723 // final output, otherwise to drive from the original input
2724 // name. Find a clean way to go about this.
2725 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
2726 Args.hasArg(options::OPT_o)) {
2727 Arg *OutputOpt = Args.getLastArg(options::OPT_o);
2728 CmdArgs.push_back("-auxbase-strip");
2729 CmdArgs.push_back(OutputOpt->getValue(Args));
2731 CmdArgs.push_back("-auxbase");
2732 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
2735 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
2737 Args.AddAllArgs(CmdArgs, options::OPT_O);
2738 // FIXME: -Wall is getting some special treatment. Investigate.
2739 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2740 Args.AddLastArg(CmdArgs, options::OPT_w);
2741 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
2742 options::OPT_trigraphs);
2743 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2744 // Honor -std-default.
2745 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2746 "-std=", /*Joined=*/true);
2749 if (Args.hasArg(options::OPT_v))
2750 CmdArgs.push_back("-version");
2751 if (Args.hasArg(options::OPT_pg) &&
2752 getToolChain().SupportsProfiling())
2753 CmdArgs.push_back("-p");
2754 Args.AddLastArg(CmdArgs, options::OPT_p);
2756 // The driver treats -fsyntax-only specially.
2757 if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2758 getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2759 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
2760 // used to inhibit the default -fno-builtin-str{cat,cpy}.
2762 // FIXME: Should we grow a better way to deal with "removing" args?
2763 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
2764 options::OPT_fsyntax_only),
2765 ie = Args.filtered_end(); it != ie; ++it) {
2766 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
2767 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
2769 (*it)->render(Args, CmdArgs);
2773 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2775 // Claim Clang only -f options, they aren't worth warning about.
2776 Args.ClaimAllArgs(options::OPT_f_clang_Group);
2778 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2779 if (Args.hasArg(options::OPT_Qn))
2780 CmdArgs.push_back("-fno-ident");
2782 // FIXME: This isn't correct.
2783 //Args.AddLastArg(CmdArgs, options::OPT__help)
2784 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
2786 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2788 // FIXME: Still don't get what is happening here. Investigate.
2789 Args.AddAllArgs(CmdArgs, options::OPT__param);
2791 if (Args.hasArg(options::OPT_fmudflap) ||
2792 Args.hasArg(options::OPT_fmudflapth)) {
2793 CmdArgs.push_back("-fno-builtin");
2794 CmdArgs.push_back("-fno-merge-constants");
2797 if (Args.hasArg(options::OPT_coverage)) {
2798 CmdArgs.push_back("-fprofile-arcs");
2799 CmdArgs.push_back("-ftest-coverage");
2802 if (types::isCXX(Inputs[0].getType()))
2803 CmdArgs.push_back("-D__private_extern__=extern");
2806 void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2807 const InputInfoList &Inputs,
2808 const ArgStringList &OutputArgs) const {
2809 // Derived from cpp_options
2810 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
2812 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2814 AddCC1Args(Args, CmdArgs);
2816 // NOTE: The code below has some commonality with cpp_options, but
2817 // in classic gcc style ends up sending things in different
2818 // orders. This may be a good merge candidate once we drop pedantic
2821 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2822 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
2823 options::OPT_trigraphs);
2824 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2825 // Honor -std-default.
2826 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2827 "-std=", /*Joined=*/true);
2829 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2830 Args.AddLastArg(CmdArgs, options::OPT_w);
2832 // The driver treats -fsyntax-only specially.
2833 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2835 // Claim Clang only -f options, they aren't worth warning about.
2836 Args.ClaimAllArgs(options::OPT_f_clang_Group);
2838 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
2839 !Args.hasArg(options::OPT_fno_working_directory))
2840 CmdArgs.push_back("-fworking-directory");
2842 Args.AddAllArgs(CmdArgs, options::OPT_O);
2843 Args.AddAllArgs(CmdArgs, options::OPT_undef);
2844 if (Args.hasArg(options::OPT_save_temps))
2845 CmdArgs.push_back("-fpch-preprocess");
2848 void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
2849 ArgStringList &CmdArgs,
2850 const InputInfoList &Inputs) const {
2851 const Driver &D = getToolChain().getDriver();
2853 CheckPreprocessingOptions(D, Args);
2855 // Derived from cpp_unique_options.
2856 // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
2857 Args.AddLastArg(CmdArgs, options::OPT_C);
2858 Args.AddLastArg(CmdArgs, options::OPT_CC);
2859 if (!Args.hasArg(options::OPT_Q))
2860 CmdArgs.push_back("-quiet");
2861 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
2862 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
2863 Args.AddLastArg(CmdArgs, options::OPT_v);
2864 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
2865 Args.AddLastArg(CmdArgs, options::OPT_P);
2867 // FIXME: Handle %I properly.
2868 if (getToolChain().getArchName() == "x86_64") {
2869 CmdArgs.push_back("-imultilib");
2870 CmdArgs.push_back("x86_64");
2873 if (Args.hasArg(options::OPT_MD)) {
2874 CmdArgs.push_back("-MD");
2875 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
2878 if (Args.hasArg(options::OPT_MMD)) {
2879 CmdArgs.push_back("-MMD");
2880 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
2883 Args.AddLastArg(CmdArgs, options::OPT_M);
2884 Args.AddLastArg(CmdArgs, options::OPT_MM);
2885 Args.AddAllArgs(CmdArgs, options::OPT_MF);
2886 Args.AddLastArg(CmdArgs, options::OPT_MG);
2887 Args.AddLastArg(CmdArgs, options::OPT_MP);
2888 Args.AddAllArgs(CmdArgs, options::OPT_MQ);
2889 Args.AddAllArgs(CmdArgs, options::OPT_MT);
2890 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
2891 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
2892 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2893 CmdArgs.push_back("-MQ");
2894 CmdArgs.push_back(OutputOpt->getValue(Args));
2898 Args.AddLastArg(CmdArgs, options::OPT_remap);
2899 if (Args.hasArg(options::OPT_g3))
2900 CmdArgs.push_back("-dD");
2901 Args.AddLastArg(CmdArgs, options::OPT_H);
2903 AddCPPArgs(Args, CmdArgs);
2905 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
2906 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
2908 for (InputInfoList::const_iterator
2909 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2910 const InputInfo &II = *it;
2912 CmdArgs.push_back(II.getFilename());
2915 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
2916 options::OPT_Xpreprocessor);
2918 if (Args.hasArg(options::OPT_fmudflap)) {
2919 CmdArgs.push_back("-D_MUDFLAP");
2920 CmdArgs.push_back("-include");
2921 CmdArgs.push_back("mf-runtime.h");
2924 if (Args.hasArg(options::OPT_fmudflapth)) {
2925 CmdArgs.push_back("-D_MUDFLAP");
2926 CmdArgs.push_back("-D_MUDFLAPTH");
2927 CmdArgs.push_back("-include");
2928 CmdArgs.push_back("mf-runtime.h");
2932 void darwin::CC1::AddCPPArgs(const ArgList &Args,
2933 ArgStringList &CmdArgs) const {
2934 // Derived from cpp spec.
2936 if (Args.hasArg(options::OPT_static)) {
2937 // The gcc spec is broken here, it refers to dynamic but
2938 // that has been translated. Start by being bug compatible.
2940 // if (!Args.hasArg(arglist.parser.dynamicOption))
2941 CmdArgs.push_back("-D__STATIC__");
2943 CmdArgs.push_back("-D__DYNAMIC__");
2945 if (Args.hasArg(options::OPT_pthread))
2946 CmdArgs.push_back("-D_REENTRANT");
2949 void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
2950 const InputInfo &Output,
2951 const InputInfoList &Inputs,
2952 const ArgList &Args,
2953 const char *LinkingOutput) const {
2954 ArgStringList CmdArgs;
2956 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2958 CmdArgs.push_back("-E");
2960 if (Args.hasArg(options::OPT_traditional) ||
2961 Args.hasArg(options::OPT_traditional_cpp))
2962 CmdArgs.push_back("-traditional-cpp");
2964 ArgStringList OutputArgs;
2965 assert(Output.isFilename() && "Unexpected CC1 output.");
2966 OutputArgs.push_back("-o");
2967 OutputArgs.push_back(Output.getFilename());
2969 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
2970 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2972 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2973 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2976 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2978 RemoveCC1UnsupportedArgs(CmdArgs);
2980 const char *CC1Name = getCC1Name(Inputs[0].getType());
2982 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
2983 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2986 void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
2987 const InputInfo &Output,
2988 const InputInfoList &Inputs,
2989 const ArgList &Args,
2990 const char *LinkingOutput) const {
2991 const Driver &D = getToolChain().getDriver();
2992 ArgStringList CmdArgs;
2994 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2996 types::ID InputType = Inputs[0].getType();
2998 if ((A = Args.getLastArg(options::OPT_traditional)))
2999 D.Diag(diag::err_drv_argument_only_allowed_with)
3000 << A->getAsString(Args) << "-E";
3002 if (JA.getType() == types::TY_LLVM_IR ||
3003 JA.getType() == types::TY_LTO_IR)
3004 CmdArgs.push_back("-emit-llvm");
3005 else if (JA.getType() == types::TY_LLVM_BC ||
3006 JA.getType() == types::TY_LTO_BC)
3007 CmdArgs.push_back("-emit-llvm-bc");
3008 else if (Output.getType() == types::TY_AST)
3009 D.Diag(diag::err_drv_no_ast_support)
3010 << getToolChain().getTripleString();
3011 else if (JA.getType() != types::TY_PP_Asm &&
3012 JA.getType() != types::TY_PCH)
3013 D.Diag(diag::err_drv_invalid_gcc_output_type)
3014 << getTypeName(JA.getType());
3016 ArgStringList OutputArgs;
3017 if (Output.getType() != types::TY_PCH) {
3018 OutputArgs.push_back("-o");
3019 if (Output.isNothing())
3020 OutputArgs.push_back("/dev/null");
3022 OutputArgs.push_back(Output.getFilename());
3025 // There is no need for this level of compatibility, but it makes
3027 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
3028 Args.hasArg(options::OPT_S));
3030 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
3031 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
3032 if (OutputArgsEarly) {
3033 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
3035 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
3036 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3039 CmdArgs.push_back("-fpreprocessed");
3041 for (InputInfoList::const_iterator
3042 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3043 const InputInfo &II = *it;
3045 // Reject AST inputs.
3046 if (II.getType() == types::TY_AST) {
3047 D.Diag(diag::err_drv_no_ast_support)
3048 << getToolChain().getTripleString();
3052 CmdArgs.push_back(II.getFilename());
3055 if (OutputArgsEarly) {
3056 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
3058 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
3059 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3063 if (Output.getType() == types::TY_PCH) {
3064 assert(Output.isFilename() && "Invalid PCH output.");
3066 CmdArgs.push_back("-o");
3067 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
3068 // to be a good reason.
3069 const char *TmpPath = C.getArgs().MakeArgString(
3070 D.GetTemporaryPath("cc", "s"));
3071 C.addTempFile(TmpPath);
3072 CmdArgs.push_back(TmpPath);
3074 // If we're emitting a pch file with the last 4 characters of ".pth"
3075 // and falling back to llvm-gcc we want to use ".gch" instead.
3076 std::string OutputFile(Output.getFilename());
3077 size_t loc = OutputFile.rfind(".pth");
3078 if (loc != std::string::npos)
3079 OutputFile.replace(loc, 4, ".gch");
3080 const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile);
3081 CmdArgs.push_back(Tmp);
3084 RemoveCC1UnsupportedArgs(CmdArgs);
3086 const char *CC1Name = getCC1Name(Inputs[0].getType());
3088 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
3089 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3092 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3093 const InputInfo &Output,
3094 const InputInfoList &Inputs,
3095 const ArgList &Args,
3096 const char *LinkingOutput) const {
3097 ArgStringList CmdArgs;
3099 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3100 const InputInfo &Input = Inputs[0];
3102 // Determine the original source input.
3103 const Action *SourceAction = &JA;
3104 while (SourceAction->getKind() != Action::InputClass) {
3105 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3106 SourceAction = SourceAction->getInputs()[0];
3109 // Forward -g, assuming we are dealing with an actual assembly file.
3110 if (SourceAction->getType() == types::TY_Asm ||
3111 SourceAction->getType() == types::TY_PP_Asm) {
3112 if (Args.hasArg(options::OPT_gstabs))
3113 CmdArgs.push_back("--gstabs");
3114 else if (Args.hasArg(options::OPT_g_Group))
3115 CmdArgs.push_back("--gdwarf2");
3118 // Derived from asm spec.
3119 AddDarwinArch(Args, CmdArgs);
3121 // Use -force_cpusubtype_ALL on x86 by default.
3122 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
3123 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
3124 Args.hasArg(options::OPT_force__cpusubtype__ALL))
3125 CmdArgs.push_back("-force_cpusubtype_ALL");
3127 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
3128 (Args.hasArg(options::OPT_mkernel) ||
3129 Args.hasArg(options::OPT_static) ||
3130 Args.hasArg(options::OPT_fapple_kext)))
3131 CmdArgs.push_back("-static");
3133 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3134 options::OPT_Xassembler);
3136 assert(Output.isFilename() && "Unexpected lipo output.");
3137 CmdArgs.push_back("-o");
3138 CmdArgs.push_back(Output.getFilename());
3140 assert(Input.isFilename() && "Invalid input.");
3141 CmdArgs.push_back(Input.getFilename());
3143 // asm_final spec is empty.
3146 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3147 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3150 void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
3151 ArgStringList &CmdArgs) const {
3152 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
3154 // Derived from darwin_arch spec.
3155 CmdArgs.push_back("-arch");
3156 CmdArgs.push_back(Args.MakeArgString(ArchName));
3158 // FIXME: Is this needed anymore?
3159 if (ArchName == "arm")
3160 CmdArgs.push_back("-force_cpusubtype_ALL");
3163 void darwin::Link::AddLinkArgs(Compilation &C,
3164 const ArgList &Args,
3165 ArgStringList &CmdArgs) const {
3166 const Driver &D = getToolChain().getDriver();
3167 const toolchains::Darwin &DarwinTC = getDarwinToolChain();
3169 unsigned Version[3] = { 0, 0, 0 };
3170 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3172 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
3173 Version[1], Version[2], HadExtra) ||
3175 D.Diag(diag::err_drv_invalid_version_number)
3176 << A->getAsString(Args);
3179 // Newer linkers support -demangle, pass it if supported and not disabled by
3182 // FIXME: We temporarily avoid passing -demangle to any iOS linker, because
3183 // unfortunately we can't be guaranteed that the linker version used there
3184 // will match the linker version detected at configure time. We need the
3185 // universal driver.
3186 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) &&
3187 !DarwinTC.isTargetIPhoneOS()) {
3188 // Don't pass -demangle to ld_classic.
3190 // FIXME: This is a temporary workaround, ld should be handling this.
3191 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
3192 Args.hasArg(options::OPT_static));
3193 if (getToolChain().getArch() == llvm::Triple::x86) {
3194 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
3195 options::OPT_Wl_COMMA),
3196 ie = Args.filtered_end(); it != ie; ++it) {
3198 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
3199 if (StringRef(A->getValue(Args, i)) == "-kext")
3200 UsesLdClassic = true;
3204 CmdArgs.push_back("-demangle");
3207 // If we are using LTO, then automatically create a temporary file path for
3208 // the linker to use, so that it's lifetime will extend past a possible
3210 if (Version[0] >= 116 && D.IsUsingLTO(Args)) {
3211 const char *TmpPath = C.getArgs().MakeArgString(
3212 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
3213 C.addTempFile(TmpPath);
3214 CmdArgs.push_back("-object_path_lto");
3215 CmdArgs.push_back(TmpPath);
3218 // Derived from the "link" spec.
3219 Args.AddAllArgs(CmdArgs, options::OPT_static);
3220 if (!Args.hasArg(options::OPT_static))
3221 CmdArgs.push_back("-dynamic");
3222 if (Args.hasArg(options::OPT_fgnu_runtime)) {
3223 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
3224 // here. How do we wish to handle such things?
3227 if (!Args.hasArg(options::OPT_dynamiclib)) {
3228 AddDarwinArch(Args, CmdArgs);
3229 // FIXME: Why do this only on this path?
3230 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
3232 Args.AddLastArg(CmdArgs, options::OPT_bundle);
3233 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
3234 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
3237 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
3238 (A = Args.getLastArg(options::OPT_current__version)) ||
3239 (A = Args.getLastArg(options::OPT_install__name)))
3240 D.Diag(diag::err_drv_argument_only_allowed_with)
3241 << A->getAsString(Args) << "-dynamiclib";
3243 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
3244 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
3245 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
3247 CmdArgs.push_back("-dylib");
3250 if ((A = Args.getLastArg(options::OPT_bundle)) ||
3251 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
3252 (A = Args.getLastArg(options::OPT_client__name)) ||
3253 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
3254 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
3255 (A = Args.getLastArg(options::OPT_private__bundle)))
3256 D.Diag(diag::err_drv_argument_not_allowed_with)
3257 << A->getAsString(Args) << "-dynamiclib";
3259 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
3260 "-dylib_compatibility_version");
3261 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
3262 "-dylib_current_version");
3264 AddDarwinArch(Args, CmdArgs);
3266 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
3267 "-dylib_install_name");
3270 Args.AddLastArg(CmdArgs, options::OPT_all__load);
3271 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
3272 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
3273 if (DarwinTC.isTargetIPhoneOS())
3274 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
3275 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
3276 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
3277 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
3278 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
3279 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
3280 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
3281 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
3282 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
3283 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
3284 Args.AddAllArgs(CmdArgs, options::OPT_init);
3286 // Add the deployment target.
3287 unsigned TargetVersion[3];
3288 DarwinTC.getTargetVersion(TargetVersion);
3290 // If we had an explicit -mios-simulator-version-min argument, honor that,
3291 // otherwise use the traditional deployment targets. We can't just check the
3292 // is-sim attribute because existing code follows this path, and the linker
3293 // may not handle the argument.
3295 // FIXME: We may be able to remove this, once we can verify no one depends on
3297 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
3298 CmdArgs.push_back("-ios_simulator_version_min");
3299 else if (DarwinTC.isTargetIPhoneOS())
3300 CmdArgs.push_back("-iphoneos_version_min");
3302 CmdArgs.push_back("-macosx_version_min");
3303 CmdArgs.push_back(Args.MakeArgString(Twine(TargetVersion[0]) + "." +
3304 Twine(TargetVersion[1]) + "." +
3305 Twine(TargetVersion[2])));
3307 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
3308 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
3309 Args.AddLastArg(CmdArgs, options::OPT_single__module);
3310 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
3311 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
3313 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
3314 options::OPT_fno_pie,
3315 options::OPT_fno_PIE)) {
3316 if (A->getOption().matches(options::OPT_fpie) ||
3317 A->getOption().matches(options::OPT_fPIE))
3318 CmdArgs.push_back("-pie");
3320 CmdArgs.push_back("-no_pie");
3323 Args.AddLastArg(CmdArgs, options::OPT_prebind);
3324 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
3325 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
3326 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
3327 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
3328 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
3329 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
3330 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
3331 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
3332 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
3333 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
3334 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
3335 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
3336 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
3337 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
3338 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
3340 // Give --sysroot= preference, over the Apple specific behavior to also use
3341 // --isysroot as the syslibroot.
3342 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
3343 CmdArgs.push_back("-syslibroot");
3344 CmdArgs.push_back(A->getValue(Args));
3345 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
3346 CmdArgs.push_back("-syslibroot");
3347 CmdArgs.push_back(A->getValue(Args));
3348 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3349 CmdArgs.push_back("-syslibroot");
3350 CmdArgs.push_back("/Developer/SDKs/Extra");
3353 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
3354 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
3355 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
3356 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
3357 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
3358 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
3359 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
3360 Args.AddAllArgs(CmdArgs, options::OPT_y);
3361 Args.AddLastArg(CmdArgs, options::OPT_w);
3362 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
3363 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
3364 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
3365 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
3366 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
3367 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
3368 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
3369 Args.AddLastArg(CmdArgs, options::OPT_whyload);
3370 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
3371 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
3372 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
3373 Args.AddLastArg(CmdArgs, options::OPT_Mach);
3376 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
3377 const InputInfo &Output,
3378 const InputInfoList &Inputs,
3379 const ArgList &Args,
3380 const char *LinkingOutput) const {
3381 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
3383 // The logic here is derived from gcc's behavior; most of which
3384 // comes from specs (starting with link_command). Consult gcc for
3385 // more information.
3386 ArgStringList CmdArgs;
3388 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
3389 if (Args.hasArg(options::OPT_ccc_arcmt_check,
3390 options::OPT_ccc_arcmt_migrate)) {
3391 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
3394 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
3395 CmdArgs.push_back(Output.getFilename());
3396 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3400 // I'm not sure why this particular decomposition exists in gcc, but
3401 // we follow suite for ease of comparison.
3402 AddLinkArgs(C, Args, CmdArgs);
3404 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
3405 Args.AddAllArgs(CmdArgs, options::OPT_s);
3406 Args.AddAllArgs(CmdArgs, options::OPT_t);
3407 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3408 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
3409 Args.AddAllArgs(CmdArgs, options::OPT_A);
3410 Args.AddLastArg(CmdArgs, options::OPT_e);
3411 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
3412 Args.AddAllArgs(CmdArgs, options::OPT_r);
3414 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
3415 // members of static archive libraries which implement Objective-C classes or
3417 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
3418 CmdArgs.push_back("-ObjC");
3420 CmdArgs.push_back("-o");
3421 CmdArgs.push_back(Output.getFilename());
3423 if (!Args.hasArg(options::OPT_A) &&
3424 !Args.hasArg(options::OPT_nostdlib) &&
3425 !Args.hasArg(options::OPT_nostartfiles)) {
3426 // Derived from startfile spec.
3427 if (Args.hasArg(options::OPT_dynamiclib)) {
3428 // Derived from darwin_dylib1 spec.
3429 if (getDarwinToolChain().isTargetIOSSimulator()) {
3430 // The simulator doesn't have a versioned crt1 file.
3431 CmdArgs.push_back("-ldylib1.o");
3432 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3433 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3434 CmdArgs.push_back("-ldylib1.o");
3436 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
3437 CmdArgs.push_back("-ldylib1.o");
3438 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3439 CmdArgs.push_back("-ldylib1.10.5.o");
3442 if (Args.hasArg(options::OPT_bundle)) {
3443 if (!Args.hasArg(options::OPT_static)) {
3444 // Derived from darwin_bundle1 spec.
3445 if (getDarwinToolChain().isTargetIOSSimulator()) {
3446 // The simulator doesn't have a versioned crt1 file.
3447 CmdArgs.push_back("-lbundle1.o");
3448 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3449 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3450 CmdArgs.push_back("-lbundle1.o");
3452 if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3453 CmdArgs.push_back("-lbundle1.o");
3457 if (Args.hasArg(options::OPT_pg) &&
3458 getToolChain().SupportsProfiling()) {
3459 if (Args.hasArg(options::OPT_static) ||
3460 Args.hasArg(options::OPT_object) ||
3461 Args.hasArg(options::OPT_preload)) {
3462 CmdArgs.push_back("-lgcrt0.o");
3464 CmdArgs.push_back("-lgcrt1.o");
3466 // darwin_crt2 spec is empty.
3469 if (Args.hasArg(options::OPT_static) ||
3470 Args.hasArg(options::OPT_object) ||
3471 Args.hasArg(options::OPT_preload)) {
3472 CmdArgs.push_back("-lcrt0.o");
3474 // Derived from darwin_crt1 spec.
3475 if (getDarwinToolChain().isTargetIOSSimulator()) {
3476 // The simulator doesn't have a versioned crt1 file.
3477 CmdArgs.push_back("-lcrt1.o");
3478 } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3479 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3480 CmdArgs.push_back("-lcrt1.o");
3482 CmdArgs.push_back("-lcrt1.3.1.o");
3484 if (getDarwinToolChain().isMacosxVersionLT(10, 5))
3485 CmdArgs.push_back("-lcrt1.o");
3486 else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3487 CmdArgs.push_back("-lcrt1.10.5.o");
3489 CmdArgs.push_back("-lcrt1.10.6.o");
3491 // darwin_crt2 spec is empty.
3498 if (!getDarwinToolChain().isTargetIPhoneOS() &&
3499 Args.hasArg(options::OPT_shared_libgcc) &&
3500 getDarwinToolChain().isMacosxVersionLT(10, 5)) {
3502 Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
3503 CmdArgs.push_back(Str);
3507 Args.AddAllArgs(CmdArgs, options::OPT_L);
3509 if (Args.hasArg(options::OPT_fopenmp))
3510 // This is more complicated in gcc...
3511 CmdArgs.push_back("-lgomp");
3513 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
3515 // In ARC, if we don't have runtime support, link in the runtime
3516 // stubs. We have to do this *before* adding any of the normal
3517 // linker inputs so that its initializer gets run first.
3518 if (isObjCAutoRefCount(Args)) {
3519 ObjCRuntime runtime;
3520 getDarwinToolChain().configureObjCRuntime(runtime);
3521 if (!runtime.HasARC)
3522 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
3525 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3527 if (LinkingOutput) {
3528 CmdArgs.push_back("-arch_multiple");
3529 CmdArgs.push_back("-final_output");
3530 CmdArgs.push_back(LinkingOutput);
3533 if (Args.hasArg(options::OPT_fnested_functions))
3534 CmdArgs.push_back("-allow_stack_execute");
3536 if (!Args.hasArg(options::OPT_nostdlib) &&
3537 !Args.hasArg(options::OPT_nodefaultlibs)) {
3538 if (getToolChain().getDriver().CCCIsCXX)
3539 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3541 // link_ssp spec is empty.
3543 // Let the tool chain choose which runtime library to link.
3544 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
3547 if (!Args.hasArg(options::OPT_A) &&
3548 !Args.hasArg(options::OPT_nostdlib) &&
3549 !Args.hasArg(options::OPT_nostartfiles)) {
3550 // endfile_spec is empty.
3553 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
3555 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3556 Args.AddAllArgs(CmdArgs, options::OPT_F);
3559 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3560 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3563 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
3564 const InputInfo &Output,
3565 const InputInfoList &Inputs,
3566 const ArgList &Args,
3567 const char *LinkingOutput) const {
3568 ArgStringList CmdArgs;
3570 CmdArgs.push_back("-create");
3571 assert(Output.isFilename() && "Unexpected lipo output.");
3573 CmdArgs.push_back("-output");
3574 CmdArgs.push_back(Output.getFilename());
3576 for (InputInfoList::const_iterator
3577 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3578 const InputInfo &II = *it;
3579 assert(II.isFilename() && "Unexpected lipo input.");
3580 CmdArgs.push_back(II.getFilename());
3583 Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
3584 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3587 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
3588 const InputInfo &Output,
3589 const InputInfoList &Inputs,
3590 const ArgList &Args,
3591 const char *LinkingOutput) const {
3592 ArgStringList CmdArgs;
3594 CmdArgs.push_back("-o");
3595 CmdArgs.push_back(Output.getFilename());
3597 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
3598 const InputInfo &Input = Inputs[0];
3599 assert(Input.isFilename() && "Unexpected dsymutil input.");
3600 CmdArgs.push_back(Input.getFilename());
3603 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
3604 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3607 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
3608 const InputInfo &Output,
3609 const InputInfoList &Inputs,
3610 const ArgList &Args,
3611 const char *LinkingOutput) const {
3612 ArgStringList CmdArgs;
3613 CmdArgs.push_back("--verify");
3615 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
3616 const InputInfo &Input = Inputs[0];
3617 assert(Input.isFilename() && "Unexpected verify input");
3619 // Grabbing the output of the earlier dsymutil run.
3620 CmdArgs.push_back(Input.getFilename());
3623 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
3624 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3627 void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3628 const InputInfo &Output,
3629 const InputInfoList &Inputs,
3630 const ArgList &Args,
3631 const char *LinkingOutput) const {
3632 ArgStringList CmdArgs;
3634 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3635 options::OPT_Xassembler);
3637 CmdArgs.push_back("-o");
3638 CmdArgs.push_back(Output.getFilename());
3640 for (InputInfoList::const_iterator
3641 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3642 const InputInfo &II = *it;
3643 CmdArgs.push_back(II.getFilename());
3647 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
3648 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3651 void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
3652 const InputInfo &Output,
3653 const InputInfoList &Inputs,
3654 const ArgList &Args,
3655 const char *LinkingOutput) const {
3656 ArgStringList CmdArgs;
3658 if ((!Args.hasArg(options::OPT_nostdlib)) &&
3659 (!Args.hasArg(options::OPT_shared))) {
3660 CmdArgs.push_back("-e");
3661 CmdArgs.push_back("_start");
3664 if (Args.hasArg(options::OPT_static)) {
3665 CmdArgs.push_back("-Bstatic");
3666 CmdArgs.push_back("-dn");
3668 // CmdArgs.push_back("--eh-frame-hdr");
3669 CmdArgs.push_back("-Bdynamic");
3670 if (Args.hasArg(options::OPT_shared)) {
3671 CmdArgs.push_back("-shared");
3673 CmdArgs.push_back("--dynamic-linker");
3674 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
3678 if (Output.isFilename()) {
3679 CmdArgs.push_back("-o");
3680 CmdArgs.push_back(Output.getFilename());
3682 assert(Output.isNothing() && "Invalid output.");
3685 if (!Args.hasArg(options::OPT_nostdlib) &&
3686 !Args.hasArg(options::OPT_nostartfiles)) {
3687 if (!Args.hasArg(options::OPT_shared)) {
3688 CmdArgs.push_back(Args.MakeArgString(
3689 getToolChain().GetFilePath("crt1.o")));
3690 CmdArgs.push_back(Args.MakeArgString(
3691 getToolChain().GetFilePath("crti.o")));
3692 CmdArgs.push_back(Args.MakeArgString(
3693 getToolChain().GetFilePath("crtbegin.o")));
3695 CmdArgs.push_back(Args.MakeArgString(
3696 getToolChain().GetFilePath("crti.o")));
3698 CmdArgs.push_back(Args.MakeArgString(
3699 getToolChain().GetFilePath("crtn.o")));
3702 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
3703 + getToolChain().getTripleString()
3706 Args.AddAllArgs(CmdArgs, options::OPT_L);
3707 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3708 Args.AddAllArgs(CmdArgs, options::OPT_e);
3710 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3712 if (!Args.hasArg(options::OPT_nostdlib) &&
3713 !Args.hasArg(options::OPT_nodefaultlibs)) {
3714 // FIXME: For some reason GCC passes -lgcc before adding
3715 // the default system libraries. Just mimic this for now.
3716 CmdArgs.push_back("-lgcc");
3718 if (Args.hasArg(options::OPT_pthread))
3719 CmdArgs.push_back("-pthread");
3720 if (!Args.hasArg(options::OPT_shared))
3721 CmdArgs.push_back("-lc");
3722 CmdArgs.push_back("-lgcc");
3725 if (!Args.hasArg(options::OPT_nostdlib) &&
3726 !Args.hasArg(options::OPT_nostartfiles)) {
3727 if (!Args.hasArg(options::OPT_shared))
3728 CmdArgs.push_back(Args.MakeArgString(
3729 getToolChain().GetFilePath("crtend.o")));
3732 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
3735 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3736 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3739 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3740 const InputInfo &Output,
3741 const InputInfoList &Inputs,
3742 const ArgList &Args,
3743 const char *LinkingOutput) const {
3744 ArgStringList CmdArgs;
3746 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3747 options::OPT_Xassembler);
3749 CmdArgs.push_back("-o");
3750 CmdArgs.push_back(Output.getFilename());
3752 for (InputInfoList::const_iterator
3753 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3754 const InputInfo &II = *it;
3755 CmdArgs.push_back(II.getFilename());
3759 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3760 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3763 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3764 const InputInfo &Output,
3765 const InputInfoList &Inputs,
3766 const ArgList &Args,
3767 const char *LinkingOutput) const {
3768 const Driver &D = getToolChain().getDriver();
3769 ArgStringList CmdArgs;
3771 if ((!Args.hasArg(options::OPT_nostdlib)) &&
3772 (!Args.hasArg(options::OPT_shared))) {
3773 CmdArgs.push_back("-e");
3774 CmdArgs.push_back("__start");
3777 if (Args.hasArg(options::OPT_static)) {
3778 CmdArgs.push_back("-Bstatic");
3780 if (Args.hasArg(options::OPT_rdynamic))
3781 CmdArgs.push_back("-export-dynamic");
3782 CmdArgs.push_back("--eh-frame-hdr");
3783 CmdArgs.push_back("-Bdynamic");
3784 if (Args.hasArg(options::OPT_shared)) {
3785 CmdArgs.push_back("-shared");
3787 CmdArgs.push_back("-dynamic-linker");
3788 CmdArgs.push_back("/usr/libexec/ld.so");
3792 if (Output.isFilename()) {
3793 CmdArgs.push_back("-o");
3794 CmdArgs.push_back(Output.getFilename());
3796 assert(Output.isNothing() && "Invalid output.");
3799 if (!Args.hasArg(options::OPT_nostdlib) &&
3800 !Args.hasArg(options::OPT_nostartfiles)) {
3801 if (!Args.hasArg(options::OPT_shared)) {
3802 CmdArgs.push_back(Args.MakeArgString(
3803 getToolChain().GetFilePath("crt0.o")));
3804 CmdArgs.push_back(Args.MakeArgString(
3805 getToolChain().GetFilePath("crtbegin.o")));
3807 CmdArgs.push_back(Args.MakeArgString(
3808 getToolChain().GetFilePath("crtbeginS.o")));
3812 std::string Triple = getToolChain().getTripleString();
3813 if (Triple.substr(0, 6) == "x86_64")
3814 Triple.replace(0, 6, "amd64");
3815 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
3818 Args.AddAllArgs(CmdArgs, options::OPT_L);
3819 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3820 Args.AddAllArgs(CmdArgs, options::OPT_e);
3822 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3824 if (!Args.hasArg(options::OPT_nostdlib) &&
3825 !Args.hasArg(options::OPT_nodefaultlibs)) {
3827 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3828 CmdArgs.push_back("-lm");
3831 // FIXME: For some reason GCC passes -lgcc before adding
3832 // the default system libraries. Just mimic this for now.
3833 CmdArgs.push_back("-lgcc");
3835 if (Args.hasArg(options::OPT_pthread))
3836 CmdArgs.push_back("-lpthread");
3837 if (!Args.hasArg(options::OPT_shared))
3838 CmdArgs.push_back("-lc");
3839 CmdArgs.push_back("-lgcc");
3842 if (!Args.hasArg(options::OPT_nostdlib) &&
3843 !Args.hasArg(options::OPT_nostartfiles)) {
3844 if (!Args.hasArg(options::OPT_shared))
3845 CmdArgs.push_back(Args.MakeArgString(
3846 getToolChain().GetFilePath("crtend.o")));
3848 CmdArgs.push_back(Args.MakeArgString(
3849 getToolChain().GetFilePath("crtendS.o")));
3853 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3854 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3857 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3858 const InputInfo &Output,
3859 const InputInfoList &Inputs,
3860 const ArgList &Args,
3861 const char *LinkingOutput) const {
3862 ArgStringList CmdArgs;
3864 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3865 // instruct as in the base system to assemble 32-bit code.
3866 if (getToolChain().getArchName() == "i386")
3867 CmdArgs.push_back("--32");
3869 if (getToolChain().getArchName() == "powerpc")
3870 CmdArgs.push_back("-a32");
3872 // Set byte order explicitly
3873 if (getToolChain().getArchName() == "mips")
3874 CmdArgs.push_back("-EB");
3875 else if (getToolChain().getArchName() == "mipsel")
3876 CmdArgs.push_back("-EL");
3878 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3879 options::OPT_Xassembler);
3881 CmdArgs.push_back("-o");
3882 CmdArgs.push_back(Output.getFilename());
3884 for (InputInfoList::const_iterator
3885 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3886 const InputInfo &II = *it;
3887 CmdArgs.push_back(II.getFilename());
3891 Args.MakeArgString(getToolChain().GetProgramPath("as"));
3892 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3895 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3896 const InputInfo &Output,
3897 const InputInfoList &Inputs,
3898 const ArgList &Args,
3899 const char *LinkingOutput) const {
3900 const Driver &D = getToolChain().getDriver();
3901 ArgStringList CmdArgs;
3903 if (!D.SysRoot.empty())
3904 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
3906 if (Args.hasArg(options::OPT_static)) {
3907 CmdArgs.push_back("-Bstatic");
3909 if (Args.hasArg(options::OPT_rdynamic))
3910 CmdArgs.push_back("-export-dynamic");
3911 CmdArgs.push_back("--eh-frame-hdr");
3912 if (Args.hasArg(options::OPT_shared)) {
3913 CmdArgs.push_back("-Bshareable");
3915 CmdArgs.push_back("-dynamic-linker");
3916 CmdArgs.push_back("/libexec/ld-elf.so.1");
3920 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3921 // instruct ld in the base system to link 32-bit code.
3922 if (getToolChain().getArchName() == "i386") {
3923 CmdArgs.push_back("-m");
3924 CmdArgs.push_back("elf_i386_fbsd");
3927 if (getToolChain().getArchName() == "powerpc") {
3928 CmdArgs.push_back("-m");
3929 CmdArgs.push_back("elf32ppc");
3932 if (Output.isFilename()) {
3933 CmdArgs.push_back("-o");
3934 CmdArgs.push_back(Output.getFilename());
3936 assert(Output.isNothing() && "Invalid output.");
3939 if (!Args.hasArg(options::OPT_nostdlib) &&
3940 !Args.hasArg(options::OPT_nostartfiles)) {
3941 if (!Args.hasArg(options::OPT_shared)) {
3942 if (Args.hasArg(options::OPT_pg))
3943 CmdArgs.push_back(Args.MakeArgString(
3944 getToolChain().GetFilePath("gcrt1.o")));
3946 const char *crt = Args.hasArg(options::OPT_pie) ? "Scrt1.o" : "crt1.o";
3947 CmdArgs.push_back(Args.MakeArgString(
3948 getToolChain().GetFilePath(crt)));
3950 CmdArgs.push_back(Args.MakeArgString(
3951 getToolChain().GetFilePath("crti.o")));
3952 CmdArgs.push_back(Args.MakeArgString(
3953 getToolChain().GetFilePath("crtbegin.o")));
3955 CmdArgs.push_back(Args.MakeArgString(
3956 getToolChain().GetFilePath("crti.o")));
3957 CmdArgs.push_back(Args.MakeArgString(
3958 getToolChain().GetFilePath("crtbeginS.o")));
3962 Args.AddAllArgs(CmdArgs, options::OPT_L);
3963 const ToolChain::path_list Paths = getToolChain().getFilePaths();
3964 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
3966 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
3967 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3968 Args.AddAllArgs(CmdArgs, options::OPT_e);
3969 Args.AddAllArgs(CmdArgs, options::OPT_s);
3970 Args.AddAllArgs(CmdArgs, options::OPT_t);
3971 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3972 Args.AddAllArgs(CmdArgs, options::OPT_r);
3974 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3976 if (!Args.hasArg(options::OPT_nostdlib) &&
3977 !Args.hasArg(options::OPT_nodefaultlibs)) {
3979 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3980 if (Args.hasArg(options::OPT_pg))
3981 CmdArgs.push_back("-lm_p");
3983 CmdArgs.push_back("-lm");
3985 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3986 // the default system libraries. Just mimic this for now.
3987 if (Args.hasArg(options::OPT_pg))
3988 CmdArgs.push_back("-lgcc_p");
3990 CmdArgs.push_back("-lgcc");
3991 if (Args.hasArg(options::OPT_static)) {
3992 CmdArgs.push_back("-lgcc_eh");
3993 } else if (Args.hasArg(options::OPT_pg)) {
3994 CmdArgs.push_back("-lgcc_eh_p");
3996 CmdArgs.push_back("--as-needed");
3997 CmdArgs.push_back("-lgcc_s");
3998 CmdArgs.push_back("--no-as-needed");
4001 if (Args.hasArg(options::OPT_pthread)) {
4002 if (Args.hasArg(options::OPT_pg))
4003 CmdArgs.push_back("-lpthread_p");
4005 CmdArgs.push_back("-lpthread");
4008 if (Args.hasArg(options::OPT_pg)) {
4009 if (Args.hasArg(options::OPT_shared))
4010 CmdArgs.push_back("-lc");
4012 CmdArgs.push_back("-lc_p");
4013 CmdArgs.push_back("-lgcc_p");
4015 CmdArgs.push_back("-lc");
4016 CmdArgs.push_back("-lgcc");
4019 if (Args.hasArg(options::OPT_static)) {
4020 CmdArgs.push_back("-lgcc_eh");
4021 } else if (Args.hasArg(options::OPT_pg)) {
4022 CmdArgs.push_back("-lgcc_eh_p");
4024 CmdArgs.push_back("--as-needed");
4025 CmdArgs.push_back("-lgcc_s");
4026 CmdArgs.push_back("--no-as-needed");
4030 if (!Args.hasArg(options::OPT_nostdlib) &&
4031 !Args.hasArg(options::OPT_nostartfiles)) {
4032 if (!Args.hasArg(options::OPT_shared))
4033 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4036 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4038 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4042 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4045 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4046 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4049 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4050 const InputInfo &Output,
4051 const InputInfoList &Inputs,
4052 const ArgList &Args,
4053 const char *LinkingOutput) const {
4054 ArgStringList CmdArgs;
4056 // When building 32-bit code on NetBSD/amd64, we have to explicitly
4057 // instruct as in the base system to assemble 32-bit code.
4058 if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
4059 getToolChain().getArch() == llvm::Triple::x86)
4060 CmdArgs.push_back("--32");
4063 // Set byte order explicitly
4064 if (getToolChain().getArchName() == "mips")
4065 CmdArgs.push_back("-EB");
4066 else if (getToolChain().getArchName() == "mipsel")
4067 CmdArgs.push_back("-EL");
4069 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4070 options::OPT_Xassembler);
4072 CmdArgs.push_back("-o");
4073 CmdArgs.push_back(Output.getFilename());
4075 for (InputInfoList::const_iterator
4076 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4077 const InputInfo &II = *it;
4078 CmdArgs.push_back(II.getFilename());
4081 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
4082 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4085 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
4086 const InputInfo &Output,
4087 const InputInfoList &Inputs,
4088 const ArgList &Args,
4089 const char *LinkingOutput) const {
4090 const Driver &D = getToolChain().getDriver();
4091 ArgStringList CmdArgs;
4093 if (!D.SysRoot.empty())
4094 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4096 if (Args.hasArg(options::OPT_static)) {
4097 CmdArgs.push_back("-Bstatic");
4099 if (Args.hasArg(options::OPT_rdynamic))
4100 CmdArgs.push_back("-export-dynamic");
4101 CmdArgs.push_back("--eh-frame-hdr");
4102 if (Args.hasArg(options::OPT_shared)) {
4103 CmdArgs.push_back("-Bshareable");
4105 CmdArgs.push_back("-dynamic-linker");
4106 CmdArgs.push_back("/libexec/ld.elf_so");
4110 // When building 32-bit code on NetBSD/amd64, we have to explicitly
4111 // instruct ld in the base system to link 32-bit code.
4112 if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
4113 getToolChain().getArch() == llvm::Triple::x86) {
4114 CmdArgs.push_back("-m");
4115 CmdArgs.push_back("elf_i386");
4118 if (Output.isFilename()) {
4119 CmdArgs.push_back("-o");
4120 CmdArgs.push_back(Output.getFilename());
4122 assert(Output.isNothing() && "Invalid output.");
4125 if (!Args.hasArg(options::OPT_nostdlib) &&
4126 !Args.hasArg(options::OPT_nostartfiles)) {
4127 if (!Args.hasArg(options::OPT_shared)) {
4128 CmdArgs.push_back(Args.MakeArgString(
4129 getToolChain().GetFilePath("crt0.o")));
4130 CmdArgs.push_back(Args.MakeArgString(
4131 getToolChain().GetFilePath("crti.o")));
4132 CmdArgs.push_back(Args.MakeArgString(
4133 getToolChain().GetFilePath("crtbegin.o")));
4135 CmdArgs.push_back(Args.MakeArgString(
4136 getToolChain().GetFilePath("crti.o")));
4137 CmdArgs.push_back(Args.MakeArgString(
4138 getToolChain().GetFilePath("crtbeginS.o")));
4142 Args.AddAllArgs(CmdArgs, options::OPT_L);
4143 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4144 Args.AddAllArgs(CmdArgs, options::OPT_e);
4145 Args.AddAllArgs(CmdArgs, options::OPT_s);
4146 Args.AddAllArgs(CmdArgs, options::OPT_t);
4147 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4148 Args.AddAllArgs(CmdArgs, options::OPT_r);
4150 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4152 if (!Args.hasArg(options::OPT_nostdlib) &&
4153 !Args.hasArg(options::OPT_nodefaultlibs)) {
4155 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4156 CmdArgs.push_back("-lm");
4158 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
4159 // the default system libraries. Just mimic this for now.
4160 if (Args.hasArg(options::OPT_static)) {
4161 CmdArgs.push_back("-lgcc_eh");
4163 CmdArgs.push_back("--as-needed");
4164 CmdArgs.push_back("-lgcc_s");
4165 CmdArgs.push_back("--no-as-needed");
4167 CmdArgs.push_back("-lgcc");
4169 if (Args.hasArg(options::OPT_pthread))
4170 CmdArgs.push_back("-lpthread");
4171 CmdArgs.push_back("-lc");
4173 CmdArgs.push_back("-lgcc");
4174 if (Args.hasArg(options::OPT_static)) {
4175 CmdArgs.push_back("-lgcc_eh");
4177 CmdArgs.push_back("--as-needed");
4178 CmdArgs.push_back("-lgcc_s");
4179 CmdArgs.push_back("--no-as-needed");
4183 if (!Args.hasArg(options::OPT_nostdlib) &&
4184 !Args.hasArg(options::OPT_nostartfiles)) {
4185 if (!Args.hasArg(options::OPT_shared))
4186 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4189 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4191 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4195 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4197 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4198 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4201 void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4202 const InputInfo &Output,
4203 const InputInfoList &Inputs,
4204 const ArgList &Args,
4205 const char *LinkingOutput) const {
4206 ArgStringList CmdArgs;
4208 // Add --32/--64 to make sure we get the format we want.
4209 // This is incomplete
4210 if (getToolChain().getArch() == llvm::Triple::x86) {
4211 CmdArgs.push_back("--32");
4212 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
4213 CmdArgs.push_back("--64");
4214 } else if (getToolChain().getArch() == llvm::Triple::arm) {
4215 StringRef MArch = getToolChain().getArchName();
4216 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
4217 CmdArgs.push_back("-mfpu=neon");
4220 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4221 options::OPT_Xassembler);
4223 CmdArgs.push_back("-o");
4224 CmdArgs.push_back(Output.getFilename());
4226 for (InputInfoList::const_iterator
4227 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4228 const InputInfo &II = *it;
4229 CmdArgs.push_back(II.getFilename());
4233 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4234 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4237 void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
4238 const InputInfo &Output,
4239 const InputInfoList &Inputs,
4240 const ArgList &Args,
4241 const char *LinkingOutput) const {
4242 const toolchains::Linux& ToolChain =
4243 static_cast<const toolchains::Linux&>(getToolChain());
4244 const Driver &D = ToolChain.getDriver();
4245 ArgStringList CmdArgs;
4247 // Silence warning for "clang -g foo.o -o foo"
4248 Args.ClaimAllArgs(options::OPT_g_Group);
4249 // and "clang -emit-llvm foo.o -o foo"
4250 Args.ClaimAllArgs(options::OPT_emit_llvm);
4251 // and for "clang -g foo.o -o foo". Other warning options are already
4252 // handled somewhere else.
4253 Args.ClaimAllArgs(options::OPT_w);
4255 if (!D.SysRoot.empty())
4256 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4258 if (Args.hasArg(options::OPT_pie))
4259 CmdArgs.push_back("-pie");
4261 if (Args.hasArg(options::OPT_rdynamic))
4262 CmdArgs.push_back("-export-dynamic");
4264 if (Args.hasArg(options::OPT_s))
4265 CmdArgs.push_back("-s");
4267 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4268 e = ToolChain.ExtraOpts.end();
4270 CmdArgs.push_back(i->c_str());
4272 if (!Args.hasArg(options::OPT_static)) {
4273 CmdArgs.push_back("--eh-frame-hdr");
4276 CmdArgs.push_back("-m");
4277 if (ToolChain.getArch() == llvm::Triple::x86)
4278 CmdArgs.push_back("elf_i386");
4279 else if (ToolChain.getArch() == llvm::Triple::arm
4280 || ToolChain.getArch() == llvm::Triple::thumb)
4281 CmdArgs.push_back("armelf_linux_eabi");
4282 else if (ToolChain.getArch() == llvm::Triple::ppc)
4283 CmdArgs.push_back("elf32ppclinux");
4284 else if (ToolChain.getArch() == llvm::Triple::ppc64)
4285 CmdArgs.push_back("elf64ppc");
4287 CmdArgs.push_back("elf_x86_64");
4289 if (Args.hasArg(options::OPT_static)) {
4290 if (ToolChain.getArch() == llvm::Triple::arm
4291 || ToolChain.getArch() == llvm::Triple::thumb)
4292 CmdArgs.push_back("-Bstatic");
4294 CmdArgs.push_back("-static");
4295 } else if (Args.hasArg(options::OPT_shared)) {
4296 CmdArgs.push_back("-shared");
4299 if (ToolChain.getArch() == llvm::Triple::arm ||
4300 ToolChain.getArch() == llvm::Triple::thumb ||
4301 (!Args.hasArg(options::OPT_static) &&
4302 !Args.hasArg(options::OPT_shared))) {
4303 CmdArgs.push_back("-dynamic-linker");
4304 if (ToolChain.getArch() == llvm::Triple::x86)
4305 CmdArgs.push_back("/lib/ld-linux.so.2");
4306 else if (ToolChain.getArch() == llvm::Triple::arm ||
4307 ToolChain.getArch() == llvm::Triple::thumb)
4308 CmdArgs.push_back("/lib/ld-linux.so.3");
4309 else if (ToolChain.getArch() == llvm::Triple::ppc)
4310 CmdArgs.push_back("/lib/ld.so.1");
4311 else if (ToolChain.getArch() == llvm::Triple::ppc64)
4312 CmdArgs.push_back("/lib64/ld64.so.1");
4314 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
4317 CmdArgs.push_back("-o");
4318 CmdArgs.push_back(Output.getFilename());
4320 if (!Args.hasArg(options::OPT_nostdlib) &&
4321 !Args.hasArg(options::OPT_nostartfiles)) {
4322 const char *crt1 = NULL;
4323 if (!Args.hasArg(options::OPT_shared)){
4324 if (Args.hasArg(options::OPT_pie))
4330 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
4332 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
4334 const char *crtbegin;
4335 if (Args.hasArg(options::OPT_static))
4336 crtbegin = "crtbeginT.o";
4337 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
4338 crtbegin = "crtbeginS.o";
4340 crtbegin = "crtbegin.o";
4341 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
4344 Args.AddAllArgs(CmdArgs, options::OPT_L);
4346 const ToolChain::path_list Paths = ToolChain.getFilePaths();
4348 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
4350 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4352 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4354 if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) {
4355 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4356 CmdArgs.push_back("-lm");
4359 if (!Args.hasArg(options::OPT_nostdlib)) {
4360 if (Args.hasArg(options::OPT_static))
4361 CmdArgs.push_back("--start-group");
4364 CmdArgs.push_back("-lgcc");
4366 if (Args.hasArg(options::OPT_static)) {
4368 CmdArgs.push_back("-lgcc");
4371 CmdArgs.push_back("--as-needed");
4372 CmdArgs.push_back("-lgcc_s");
4374 CmdArgs.push_back("--no-as-needed");
4377 if (Args.hasArg(options::OPT_static))
4378 CmdArgs.push_back("-lgcc_eh");
4379 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
4380 CmdArgs.push_back("-lgcc");
4382 if (Args.hasArg(options::OPT_pthread) ||
4383 Args.hasArg(options::OPT_pthreads))
4384 CmdArgs.push_back("-lpthread");
4386 CmdArgs.push_back("-lc");
4388 if (Args.hasArg(options::OPT_static))
4389 CmdArgs.push_back("--end-group");
4392 CmdArgs.push_back("-lgcc");
4395 CmdArgs.push_back("--as-needed");
4396 CmdArgs.push_back("-lgcc_s");
4398 CmdArgs.push_back("--no-as-needed");
4400 if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
4401 CmdArgs.push_back("-lgcc");
4405 if (!Args.hasArg(options::OPT_nostartfiles)) {
4407 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
4408 crtend = "crtendS.o";
4410 crtend = "crtend.o";
4412 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
4413 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
4417 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4419 if (Args.hasArg(options::OPT_use_gold_plugin)) {
4420 CmdArgs.push_back("-plugin");
4421 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
4422 CmdArgs.push_back(Args.MakeArgString(Plugin));
4425 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
4428 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4429 const InputInfo &Output,
4430 const InputInfoList &Inputs,
4431 const ArgList &Args,
4432 const char *LinkingOutput) const {
4433 ArgStringList CmdArgs;
4435 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4436 options::OPT_Xassembler);
4438 CmdArgs.push_back("-o");
4439 CmdArgs.push_back(Output.getFilename());
4441 for (InputInfoList::const_iterator
4442 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4443 const InputInfo &II = *it;
4444 CmdArgs.push_back(II.getFilename());
4448 Args.MakeArgString(getToolChain().GetProgramPath("gas"));
4449 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4452 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
4453 const InputInfo &Output,
4454 const InputInfoList &Inputs,
4455 const ArgList &Args,
4456 const char *LinkingOutput) const {
4457 const Driver &D = getToolChain().getDriver();
4458 ArgStringList CmdArgs;
4460 if (Output.isFilename()) {
4461 CmdArgs.push_back("-o");
4462 CmdArgs.push_back(Output.getFilename());
4464 assert(Output.isNothing() && "Invalid output.");
4467 if (!Args.hasArg(options::OPT_nostdlib) &&
4468 !Args.hasArg(options::OPT_nostartfiles))
4469 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4470 "/usr/gnu/lib/crtso.o")));
4472 Args.AddAllArgs(CmdArgs, options::OPT_L);
4473 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4474 Args.AddAllArgs(CmdArgs, options::OPT_e);
4476 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4478 if (!Args.hasArg(options::OPT_nostdlib) &&
4479 !Args.hasArg(options::OPT_nodefaultlibs)) {
4481 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4482 CmdArgs.push_back("-lm");
4485 if (Args.hasArg(options::OPT_pthread))
4486 CmdArgs.push_back("-lpthread");
4487 CmdArgs.push_back("-lc");
4488 CmdArgs.push_back("-lgcc");
4489 CmdArgs.push_back("-L/usr/gnu/lib");
4490 // FIXME: fill in the correct search path for the final
4491 // support libraries.
4492 CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
4495 if (!Args.hasArg(options::OPT_nostdlib) &&
4496 !Args.hasArg(options::OPT_nostartfiles)) {
4497 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4498 "/usr/gnu/lib/libend.a")));
4501 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4504 Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld"));
4505 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4510 // For now, DragonFly Assemble does just about the same as for
4511 // FreeBSD, but this may change soon.
4512 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4513 const InputInfo &Output,
4514 const InputInfoList &Inputs,
4515 const ArgList &Args,
4516 const char *LinkingOutput) const {
4517 ArgStringList CmdArgs;
4519 // When building 32-bit code on DragonFly/pc64, we have to explicitly
4520 // instruct as in the base system to assemble 32-bit code.
4521 if (getToolChain().getArchName() == "i386")
4522 CmdArgs.push_back("--32");
4524 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4525 options::OPT_Xassembler);
4527 CmdArgs.push_back("-o");
4528 CmdArgs.push_back(Output.getFilename());
4530 for (InputInfoList::const_iterator
4531 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4532 const InputInfo &II = *it;
4533 CmdArgs.push_back(II.getFilename());
4537 Args.MakeArgString(getToolChain().GetProgramPath("as"));
4538 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4541 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
4542 const InputInfo &Output,
4543 const InputInfoList &Inputs,
4544 const ArgList &Args,
4545 const char *LinkingOutput) const {
4546 const Driver &D = getToolChain().getDriver();
4547 ArgStringList CmdArgs;
4549 if (!D.SysRoot.empty())
4550 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4552 if (Args.hasArg(options::OPT_static)) {
4553 CmdArgs.push_back("-Bstatic");
4555 if (Args.hasArg(options::OPT_shared))
4556 CmdArgs.push_back("-Bshareable");
4558 CmdArgs.push_back("-dynamic-linker");
4559 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
4563 // When building 32-bit code on DragonFly/pc64, we have to explicitly
4564 // instruct ld in the base system to link 32-bit code.
4565 if (getToolChain().getArchName() == "i386") {
4566 CmdArgs.push_back("-m");
4567 CmdArgs.push_back("elf_i386");
4570 if (Output.isFilename()) {
4571 CmdArgs.push_back("-o");
4572 CmdArgs.push_back(Output.getFilename());
4574 assert(Output.isNothing() && "Invalid output.");
4577 if (!Args.hasArg(options::OPT_nostdlib) &&
4578 !Args.hasArg(options::OPT_nostartfiles)) {
4579 if (!Args.hasArg(options::OPT_shared)) {
4581 Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
4583 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
4585 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
4588 Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
4590 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
4594 Args.AddAllArgs(CmdArgs, options::OPT_L);
4595 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4596 Args.AddAllArgs(CmdArgs, options::OPT_e);
4598 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4600 if (!Args.hasArg(options::OPT_nostdlib) &&
4601 !Args.hasArg(options::OPT_nodefaultlibs)) {
4602 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
4604 CmdArgs.push_back("-L/usr/lib/gcc41");
4606 if (!Args.hasArg(options::OPT_static)) {
4607 CmdArgs.push_back("-rpath");
4608 CmdArgs.push_back("/usr/lib/gcc41");
4610 CmdArgs.push_back("-rpath-link");
4611 CmdArgs.push_back("/usr/lib/gcc41");
4613 CmdArgs.push_back("-rpath");
4614 CmdArgs.push_back("/usr/lib");
4616 CmdArgs.push_back("-rpath-link");
4617 CmdArgs.push_back("/usr/lib");
4621 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4622 CmdArgs.push_back("-lm");
4625 if (Args.hasArg(options::OPT_shared)) {
4626 CmdArgs.push_back("-lgcc_pic");
4628 CmdArgs.push_back("-lgcc");
4632 if (Args.hasArg(options::OPT_pthread))
4633 CmdArgs.push_back("-lpthread");
4635 if (!Args.hasArg(options::OPT_nolibc)) {
4636 CmdArgs.push_back("-lc");
4639 if (Args.hasArg(options::OPT_shared)) {
4640 CmdArgs.push_back("-lgcc_pic");
4642 CmdArgs.push_back("-lgcc");
4646 if (!Args.hasArg(options::OPT_nostdlib) &&
4647 !Args.hasArg(options::OPT_nostartfiles)) {
4648 if (!Args.hasArg(options::OPT_shared))
4649 CmdArgs.push_back(Args.MakeArgString(
4650 getToolChain().GetFilePath("crtend.o")));
4652 CmdArgs.push_back(Args.MakeArgString(
4653 getToolChain().GetFilePath("crtendS.o")));
4654 CmdArgs.push_back(Args.MakeArgString(
4655 getToolChain().GetFilePath("crtn.o")));
4658 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4661 Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4662 C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4665 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
4666 const InputInfo &Output,
4667 const InputInfoList &Inputs,
4668 const ArgList &Args,
4669 const char *LinkingOutput) const {
4670 ArgStringList CmdArgs;
4672 if (Output.isFilename()) {
4673 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
4674 Output.getFilename()));
4676 assert(Output.isNothing() && "Invalid output.");
4679 if (!Args.hasArg(options::OPT_nostdlib) &&
4680 !Args.hasArg(options::OPT_nostartfiles)) {
4681 CmdArgs.push_back("-defaultlib:libcmt");
4684 CmdArgs.push_back("-nologo");
4686 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4689 Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
4690 C.addCommand(new Command(JA, *this, Exec, CmdArgs));